dnssec-killkey
changeset 20 5b52190d8750
parent 13 4844031fc55e
child 21 6715f8f9d04c
equal deleted inserted replaced
19:2c3bcb280768 20:5b52190d8750
     1 #!/bin/bash
     1 #!/usr/bin/perl -w
     2 
     2 
     3 source dnstools.conf
     3 use strict;
     4 
     4 
     5 master_dir=$MASTER_DIR		# ordner fuer die einzelnen zonedateiordner
     5 my $master_dir="/etc/bind/master";	# ordner fuer die einzelnen zonedateiordner
     6 ablauf_zeit=$ABL_ZEIT		# zeit in minuten waehrend der 2 keys verwendet werden / ungefaehr doppelte TTL 
     6 my $ablauf_zeit="48";			# zeit fuer den key-rollover in h
       
     7 my $zone;
       
     8 my @status;
       
     9 my @auto;
       
    10 chomp (my $now_time=`date +%s`);	# aktuelle unixzeit
     7 
    11 
       
    12 # prueft zonen aus ARGV und loescht das schluesselmaterial
       
    13 foreach (@ARGV) {
       
    14         chomp ($zone = `idn --quiet $_`);
       
    15 	my $zdir = "$master_dir/$zone";
       
    16         if (-e "$master_dir/$zone") {
     8 
    17 
     9 # loescht zu allen manuell eingegeben domains das schluesselmaterial
    18 		if (-e "$zdir/$zone.signed") { `rm $zdir/$zone.signed`}
    10 for utf8domain in $@
    19 		if (-e "$zdir/.keycounter") { `rm $zdir/.keycounter`}
    11 do
    20 		if (-e "$zdir/.index.ksk") { `rm $zdir/.index.ksk`}
    12         domain=$(idn --quiet "$utf8domain")
    21 		if (-e "$zdir/.index.zsk") { `rm $zdir/.index.zsk`}
       
    22 		if (-e "$zdir/dsset-$zone.") { `rm $zdir/dsset-$zone.`}
       
    23 		if (-e "$zdir/keyset-$zone.") { `rm $zdir/keyset-$zone.`}
    13 
    24 
    14         if [ -d $master_dir/$domain ]
    25 		foreach (`ls $master_dir/$zone/K*[key,private]`){ `rm $_`}
    15         then
       
    16 		zdir="$master_dir/$domain"
       
    17 
    26 
    18 		[ -f $zdir/$domain.signed ] && rm $zdir/$domain.signed
    27         } else {
    19 		[ -f $zdir/keycounter ] && rm $zdir/keycounter
    28                 print "$zone ist keine verwaltete zone \n";
    20 		[ -f $zdir/.index.ksk ] && rm $zdir/.index.ksk
    29         }
    21 		[ -f $zdir/.index.zsk ] && rm $zdir/.index.zsk
    30 }
    22 		[ -f $zdir/dsset-$domain. ] && rm $zdir/dsset-$domain.
       
    23 		[ -f $zdir/keyset-$domain. ] && rm $zdir/keyset-$domain.
       
    24 
    31 
    25 		for key in $zdir/K$domain*
    32 # beendet den key-rollover
    26 		do
    33 foreach (`ls $master_dir`) {
    27 			rm $key
    34 	chomp ($zone = $_);
    28 		done
    35 	my @index = ();
       
    36 	my $index_wc;
    29 
    37 
    30 		echo "Schluesselmaterial fuer $domain entfernt - mkready ausfuehren! "
    38 	# prueft nach der ".index.zsk"-datei und erstellt den zeitpunkt
    31         else
    39 	# an dem das key-rollover endet. - $status[9]
    32                 echo $domain ist keine verwaltete Zone
    40 	if (-e "$master_dir/$zone/.index.zsk") {
    33         fi
    41 		@status = stat("$master_dir/$zone/.index.zsk");
    34 done
    42 		$status[9] += (3600 * $ablauf_zeit);
       
    43 	} else { next; }
    35 
    44 
       
    45 	# prueft ob das key-rollover-ende erreicht ist
       
    46 	unless ($status[9] < $now_time ) {
       
    47 		next;
       
    48 	}
    36 
    49 
       
    50 	# prueft die anzahl der schluessel in der ".index.zsk"
       
    51 	# loescht alte schluessel
       
    52 	open (INDEX, "$master_dir/$zone/.index.zsk");
       
    53 	@index = <INDEX>;
       
    54 	$index_wc = @index;
       
    55 	close (INDEX);
       
    56 	if ($index_wc > 1) {
       
    57 		open (INDEX, ">$master_dir/$zone/.index.zsk");
       
    58 		print INDEX $index[1];
       
    59 		close (INDEX);
       
    60 		push @auto, $zone;
       
    61 	}
    37 
    62 
    38 cd $master_dir
    63 	# prueft die anzahl der schluessel in der ".index.ksk"
    39 for domain in *
    64 	# loescht alte schluessel
    40 do
    65 	open (INDEX, "$master_dir/$zone/.index.ksk");
       
    66 	@index = <INDEX>;
       
    67 	$index_wc = @index;
       
    68 	close (INDEX);
       
    69 	if ($index_wc > 1) {
       
    70 		open (INDEX, ">$master_dir/$zone/.index.ksk");
       
    71 		print INDEX $index[1];
       
    72 		close (INDEX);
       
    73 		push @auto, $zone;
       
    74 	}
    41 
    75 
    42 	if ( find $master_dir/$domain -name "index*" -mmin +$ablauf_zeit >/dev/null )	# prueft die schluesselindexdateien
    76 }
    43 	then										# auf zeitpunkt der aenderung
       
    44 
    77 
    45 		cd $master_dir/$domain
    78 # nach abgeschlossenem key-rollover werden fuer die entsprechende zone
    46 		INDEX_FILE=`find . -name ".index*" -mmin +$ablauf_zeit`		# schreibt eine liste INDEX_FILE aller
    79 # unbenoetigte schluessel entfernt und die vorhandenen schluessel in die
    47 										# dateien die vor ABL_ZEIT erstellt worden
    80 # zonedatei geschrieben.
    48 		for INDEX in $INDEX_FILE
    81 foreach (@auto) {
    49 		do
    82 	my $zone = $_;
    50 		
    83 	my @old_zone_content = ();
    51 			if ( wc -l $INDEX | grep ^2 > /dev/null )	# prueft die indexdatei auf anzahl an eintraegen
    84 	my @new_zone_content = ();
    52 			then						
    85 	my @keylist = ();
    53 				INDEX=${INDEX#./}			
    86 	my $file;
    54 				echo aktualisiert $INDEX in $domain
    87 
    55 				
    88 	open (INDEX, "$master_dir/$zone/.index.zsk");
    56 				DNS_KEY=`tail -n1 $INDEX`		# speichert den letzten eintrag aus dem
    89 	@keylist = <INDEX>;
    57 									# index in die variable DNS_KEY
    90 	close (INDEX);
    58 			
    91 
    59 				echo $DNS_KEY > $master_dir/$domain/$INDEX	# schreibt nur die variable
    92 	open (INDEX, "$master_dir/$zone/.index.ksk");
    60 										# DNS_KEY in die indexdatei
    93 	push @keylist, <INDEX>;
       
    94 	close (INDEX);
       
    95 
       
    96 	open (ZONE, "$master_dir/$zone/$zone");
       
    97 	@old_zone_content = <ZONE>;
       
    98 	close (ZONE);
       
    99 
       
   100 	# kuerzt die schluessel-bezeichnung aus der indexdatei auf die
       
   101 	# id um sie besser vergleichen zu koennen.
       
   102 	foreach (@keylist) {
       
   103 		chomp;
       
   104 		s#K.*\+.*\+(.*)#$1#;
       
   105 	}
       
   106 
       
   107 	# filtert alle schluessel aus der zonedatei
       
   108 	# old_zone_content ==> new_zone_content
       
   109 	foreach (@old_zone_content) {
       
   110 		unless (/IN\sDNSKEY/) {
       
   111 			push @new_zone_content, $_;
       
   112 		}
       
   113 	}
       
   114 
       
   115 	# prueft alle schluesseldateien (ksk, zsk) ob sie in der jeweiligen
       
   116 	# indexdatei beschrieben sind. wenn nicht werden sie geloescht.
       
   117 	foreach (`ls $master_dir/$zone/K*[key,private]`){
       
   118 		chomp;
       
   119 		$file = $_;
       
   120 		my $rm_count = 1;
       
   121 
       
   122 		foreach (@keylist) {
       
   123 
       
   124 			if ($file =~ /$_/) {
       
   125 				$rm_count = 0;
       
   126 
       
   127 				# schluessel die in der indexdatei standen, werden an die
       
   128 				# zonedatei angehangen.
       
   129 				if ($file =~ /.*key/) {
       
   130 					open (KEYFILE, "$file");
       
   131 					push @new_zone_content, <KEYFILE>;
       
   132 					close (KEYFILE);
       
   133 					
       
   134 					last;
       
   135 				}
       
   136 			}
       
   137 		}
       
   138 
       
   139 		#loescht alle unbenoetigten schluessel
       
   140 		if ($rm_count == 1) {
       
   141 			print `rm -f $file`;
       
   142 		}
       
   143 	}
       
   144 
       
   145 	open (ZONE, ">$master_dir/$zone/$zone");
       
   146 	print ZONE @new_zone_content;
       
   147 	close (ZONE);
    61 	
   148 	
    62 				rm $(ls K*[key,private] | grep -v "`cat .index.zsk`" | \
   149 	print "$master_dir/$zone/$zone wurde neu erstellt \n";
    63 				grep -v "`cat .index.ksk`") 2> /dev/null		# loesche alle schluessel die nicht in der indexdatei
   150 }
    64 										# stehen
       
    65 				mv $domain .$domain
       
    66 				grep -v 'DNSKEY' .$domain >> $domain		# erzeugt ein backup und entfernt alle schluessel
       
    67 										# aus der zonedatei
       
    68 				cat K$domain.*key >>$domain			# schreibt die aktuellen schluessel in die zonedatei
       
    69 
       
    70 				key_counter=`< keycounter`
       
    71 				dnssec-signzone $domain && echo $[ key_counter + 1 ] > keycounter
       
    72 			fi
       
    73 			
       
    74 
       
    75 		done
       
    76 	fi
       
    77 done