path: root/nagios-plugins-contrib-24.20190301~bpo9+1/dsa/checks/dsa-check-dnssec-delegation

#!/usr/bin/perl

# Copyright (c) 2010, 2014, 2015, 2017 Peter Palfrader 
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to
# the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

use strict;
use warnings;
use English;
use Net::DNS::Resolver;
use Getopt::Long;
use File::Basename;

# taken from Array::Utils
# http://cpansearch.perl.org/src/ZMIJ/Array-Utils-0.5/Utils.pm
# This module is Copyright (c) 2007 Sergei A. Fedorov.
# You may distribute under the terms of either the GNU General Public
# License or the Artistic License, as specified in the Perl README file.
#
sub intersect(\ _æ_ \ _æ_ ) {
	my %e = map { $_ => undef }  _æ_ {$_[0]};
	return grep { exists( $e{$_} ) }  _æ_ {$_[1]};
}
sub array_diff(\ _æ_ \ _æ_ ) {
	my %e = map { $_ => undef }  _æ_ {$_[1]};
	return  _æ_ {[ ( grep { (exists $e{$_}) ? ( delete $e{$_} ) : ( 1 ) }  _æ_ { $_[0] } ), keys %e ] };
}
sub array_minus(\ _æ_ \ _æ_ ) {
	my %e = map{ $_ => undef }  _æ_ {$_[1]};
	return grep( ! exists( $e{$_} ),  _æ_ {$_[0]} );
}


$SIG{'__DIE__'} = sub { print  _æ_ _; exit 4; };

my $RES = Net::DNS::Resolver->new;
my $DLV = 'dlv.isc.org';
my $params;

sub get_tag_generic {
	my $zone = shift;
	my $type = shift;
	my %options =  _æ_ _;

	my  _æ_ result;
	my  _æ_ zsks;
	print "Querying $type $zone\n" if $params->{'verbose'};
	my $pkt = $RES->send($zone, $type);
	return () unless $pkt;
	return () unless $pkt->answer;
	for my $rr ($pkt->answer) {
		next unless ($rr->type eq $type);
		next unless (lc($rr->name) eq lc($zone));

		my $tag = $options{'pretty'} ? sprintf("%5d(%d)", $rr->keytag, $rr->algorithm) : $rr->keytag;

		if ($type eq 'DNSKEY' && ($rr->{'flags'} & (1<<(15-8)))) {
			# key is revoked
			next;
		}

		# for now only handle KSKs, i.e. keys with the SEP flag set
		if ($type eq 'DNSKEY' && !($rr->sep)) {
			push  _æ_ zsks, $tag;
			next;
		}

		push  _æ_ result, $tag;
	};
	if ($type eq 'DNSKEY' && (scalar  _æ_ result) == 0) {
		# use remaining keys if no keys with the SEP bit are present
		 _æ_ result =  _æ_ zsks;
	}
	my %unique = ();
	 _æ_ result = sort {$a cmp $b} grep {!$unique{$_}++}  _æ_ result;
	return  _æ_ result
};

sub get_dnskeytags {
	my $zone = shift;
	my %options =  _æ_ _;
	return get_tag_generic($zone, 'DNSKEY', %options);
};
sub get_dstags {
	my $zone = shift;
	my %options =  _æ_ _;
	return get_tag_generic($zone, 'DS', %options);
};
sub get_dlvtags {
	my $zone = shift;
	my %options =  _æ_ _;
	$zone .= ".".$DLV;
	return get_tag_generic($zone, 'DLV', %options);
};
sub has_dnskey_parent {
	my $zone = shift;

	my $potential_parent;
	if ($zone =~ m/\./) {
		$potential_parent = $zone;
		$potential_parent =~ s/^[^.]+\.//;
	} else {
		$potential_parent = '.';
	}

	print "Querying DNSKEY $potential_parent\n" if $params->{'verbose'};
	my $pkt = $RES->send($potential_parent, 'DNSKEY');
	return undef unless $pkt;
	return undef unless $pkt->header;

	unless ($pkt->answer) {
		return undef unless $pkt->authority;
		for my $rr ($pkt->authority) {
			next unless ($rr->type eq 'SOA');

			$potential_parent = $rr->name;
			print "Querying DNSKEY $potential_parent\n" if $params->{'verbose'};
			$pkt = $RES->send($potential_parent, 'DNSKEY');
			return undef unless $pkt;
			last;
		};
	};

	return (0, $potential_parent) unless $pkt->answer;
	for my $rr ($pkt->answer) {
		next unless ($rr->type eq 'DNSKEY');
		return (1, $potential_parent);
	};
}
sub get_parent_dnssec_status {
	my $zone = shift;
	my  _æ_ result;

	while (1) {
		my ($status, $parent) = has_dnskey_parent($zone);
		last unless defined $status;
		push  _æ_ result, ($status ? "yes" : "no") . ("($parent)");
		$zone = $parent;
		last if $zone eq "" || $zone eq '.';
	};

	return join(', ',  _æ_ result);
};

sub usage {
	my $fd = shift;
	my $exit = shift;

	print $fd "Usage: $PROGRAM_NAME [--dir ] overview|check-dlv|check-ds|check-header zone [zone...]\n";
	print $fd "       $PROGRAM_NAME --dir  overview|check-dlv|check-ds|check-header\n";
	print $fd "       $PROGRAM_NAME --help\n";
	exit $exit;
}

sub what_to_check {
	my $zone = shift;
	my $zonefile = shift;

	my $do_dlv = 0;
	my $do_ds = 0;

	open(F, "<", $zonefile) or die ("Cannot open zonefile $zonefile for $zone: $!\n");
	while () {
		if (/^[#;]\s*dlv-submit\s*=\s*yes\s*$/) { $do_dlv = 1; }
		if (/^[#;]\s*ds-in-parent\s*=\s*yes\s*$/) { $do_ds = 1; }
	}
	close(F);

	return { 'dlv' => $do_dlv,
	         'ds' => $do_ds };
}
sub diff_spec {
	my $a = shift;
	my $b = shift;

	my  _æ_ elems = intersect( _æ_ $a,  _æ_ $b);
	push  _æ_ elems, map { '-'.$_ } array_minus( _æ_ $a,  _æ_ $b);
	push  _æ_ elems, map { '+'.$_ } array_minus( _æ_ $b,  _æ_ $a);
	return join(',',  _æ_ elems);
}

Getopt::Long::config('bundling');
GetOptions (
	'--help' => \$params->{'help'},
	'--dir=s _æ_ ' => \$params->{'dir'},
	'--dlv=s' => \$params->{'dlv'},
	'--verbose' => \$params->{'verbose'},
) or usage(\*STDERR, 1);
usage(\*STDOUT, 0) if ($params->{'help'});

my $mode = shift  _æ_ ARGV;
usage(\*STDOUT, 0) unless (defined $mode && $mode =~ /^(overview|check-dlv|check-ds|check-header)$/);
die ("check-header needs --dir") if ($mode eq 'check-header' && !defined $params->{'dir'});

my %zones;
if (scalar  _æ_ ARGV) {
	if (defined $params->{'dir'} && $mode ne 'check-header') {
		warn "--dir option ignored"
	}
	%zones = map { $_ => $_}  _æ_ ARGV;
} else {
	my $dirs = $params->{'dir'};
	usage(\*STDOUT, 0) unless (defined $dirs);

	for my $dir ( _æ_ $dirs) {
		chdir $dir or die "chdir $dir failed? $!\n";
		opendir DIR, '.' or die ("Cannot opendir $dir\n");
		for my $file (readdir DIR) {
			next if ( -l "$file" );
			next unless ( -f "$file" );
			next if $file =~ /^(dsset|keyset)-/;

			my $zone = $file;
			if ($file =~ /\.zone$/) { # it's one of our yaml things
				$zone = basename($file, '.zone');
			};
			$zones{$zone} = "$dir/$file";
		}
		closedir(DIR);
	};
};

$DLV = $params->{'dlv'} if $params->{'dlv'};


if ($mode eq 'overview') {
	my %data;
	for my $zone (keys %zones) {
		$data{$zone} = { 'dnskey' => join(', ', get_dnskeytags($zone, pretty=>1)),
				 'ds'     => join(', ', get_dstags($zone, pretty=>1)),
				 'dlv'    => join(', ', get_dlvtags($zone, pretty=>1)),
				 'parent_dnssec' => get_parent_dnssec_status($zone) };
	}

	my $format = "%60s %-20s %-15s %-3s %-10s\n";
	printf $format, "zone", "DNSKEY", "DS\ _æ_ parent", "DLV", "dnssec\ _æ_ parent";
	printf $format, "-"x 60,  "-"x 20,  "-"x 15,  "-"x 3, "-"x 10;
	for my $zone (sort {$a cmp $b} keys %data) {
		printf $format, $zone,
			$data{$zone}->{'dnskey'},
			$data{$zone}->{'ds'},
			$data{$zone}->{'dlv'},
			$data{$zone}->{'parent_dnssec'};
	}
	exit(0);
} elsif ($mode eq 'check-dlv' || $mode eq 'check-ds' || $mode eq 'check-header') {
	my  _æ_ to_check;
	push  _æ_ to_check, 'dlv' if $mode eq 'check-header' ||  $mode eq 'check-dlv';
	push  _æ_ to_check, 'ds'  if $mode eq 'check-header' ||  $mode eq 'check-ds';

	my  _æ_ warn;
	my  _æ_ ok;
	for my $zone (sort {$a cmp $b} keys %zones) {
		my $require = { map { $_ => 1 }  _æ_ to_check };
		if ($mode eq 'check-header') {
			$require = what_to_check($zone, $zones{$zone})
		}

		my  _æ_ dnskey = get_dnskeytags($zone);
		for my $thiskey ( _æ_ to_check) {
			my  _æ_ target = $thiskey eq 'ds' ? get_dstags($zone) : get_dlvtags($zone);

			my $spec = diff_spec(\ _æ_ target, \ _æ_ dnskey);
			# if the intersection between DS and KEY is empty,
			# or if there are DS records for keys we do not have, that's an issue.
			if (intersect( _æ_ dnskey,  _æ_ target) == 0 || array_minus( _æ_ target,  _æ_ dnskey)) {
				if ($require->{$thiskey} || scalar  _æ_ target > 0) {
					push  _æ_ warn, "$zone ($spec)";
				}
			} else  {
				if ($require->{$thiskey}) {
					push  _æ_ ok, "$zone ($spec)";
				}
			};
		}
	}
	print "WARNING: ", join(", ",  _æ_ warn), "\n" if (scalar  _æ_ warn);
	print "OK: ", join(", ",  _æ_ ok), "\n" if (scalar  _æ_ ok);
	exit (1) if (scalar  _æ_ warn);
	exit (0);
} else {
	die ("Invalid mode '$mode'\n");
};