1 #!/usr/bin/perl 

     2 

     3 use strict;

     4 use warnings;

     5 use FindBin;

     6 use File::Basename;

     7 

     8 sub del_double {

     9 

    10     # entfernt doppelte eintraege in einer liste

    11     my %all;

    12     grep { $all{$_} = 0 } @_;

    13     return (keys %all);

    14 }

    15 

    16 sub read_conf {

    17 

    18     # liest die Konfiguration ein

    19     my @configs = ("$FindBin::Bin/dnstools.conf", "/etc/dnstools.conf");

    20     our %config;

    21 

    22     for (grep { -f } @configs) {

    23         open(CONFIG, $_) or die "Can't open $_: $!\n";

    24     }

    25     unless (seek(CONFIG, 0, 0)) {

    26         die "Can't open config (searched: @configs)\n";

    27     }

    28     while (<CONFIG>) {

    29         chomp;

    30         s/#.*//;

    31         s/\t//g;

    32         s/\s//g;

    33 

    34         next unless length;

    35         my ($cname, $ccont) = split(/\s*=\s*/, $_, 2);

    36         $config{$cname} = $ccont;

    37     }

    38     close(CONFIG);

    39 }

    40 

    41 sub add_argv {

    42 

    43     # prueft ob zonen aus ARGV verwaltete zonen sind

    44     # und fuegt sie, falls ja in die liste @new_serial ein

    45     our @new_serial;

    46     our $master_dir;

    47     my $zone;

    48 

    49     for (@ARGV) {

    50         chomp($zone = `idn --quiet "$_"`);

    51         if (-e "$master_dir/$zone/$zone") {

    52             push @new_serial, $zone;

    53         }

    54     }

    55 }

    56 

    57 sub changed_zone {

    58     our $master_dir;

    59     our @new_serial;

    60 

    61     for (<$master_dir/*>) {

    62         my $zone = basename($_);

    63 

    64         if (-e "$master_dir/$zone/.stamp") {

    65             my $stamptime = (-M "$master_dir/$zone/.stamp");

    66             my $filetime  = (-M "$master_dir/$zone/$zone");

    67             if ($stamptime > $filetime) {

    68                 push @new_serial, $zone;

    69                 print " * $zone: zonedatei wurde geaendert\n";

    70             }

    71         }

    72         else {

    73             print " * $zone: keine .stamp-datei gefunden\n"

    74               ;    # NOCH IN NEW_SERIAL PUSHEN

    75             push @new_serial, $zone;

    76         }

    77     }

    78 

    79 }

    80 

    81 sub sign_end {

    82     our $sign_alert_time;    # die zeit zwischen dem ende und der neuen

    83                              # signierung (siehe externe konfiguration)

    84     our $master_dir;

    85     our @new_serial;

    86 

    87     # erzeugt $time (die zeit ab der neu signiert werden soll)

    88     chomp(my $unixtime = `date +%s`);

    89     $unixtime = $unixtime + (3600 * $sign_alert_time);

    90     my $time = `date -d \@$unixtime +%Y%m%d%H`;

    91 

    92     ## vergleicht fuer alle zonen im ordner $master_dir mit einer

    93     ## <zone>.signed-datei den zeitpunkt in $time mit dem ablaufdatum der

    94     ## signatur, welcher aus der datei <zone>.signed ausgelesen wird.

    95     for (<$master_dir/*>) {

    96         s#($master_dir/)(.*)#$2#;

    97         my $zone = $_;

    98 

    99         if (-e "$master_dir/$zone/$zone.signed") {

   100             open(ZONE, "$master_dir/$zone/$zone.signed");

   101             my @zone_sig_content = <ZONE>;

   102             close(ZONE);

   103 

   104             for (@zone_sig_content) {

   105                 if (m#SOA.*[0-9]{14}#) {

   106                     s#.*([0-9]{10})([0-9]{4}).*#$1#;

   107                     if ($_ < $time) {

   108                         push @new_serial, $zone;

   109                     }

   110                 }

   111             }

   112         }

   113     }

   114 }

   115 

   116 sub sign_zone {

   117 

   118     # signiert die zonen und erhoeht den wert in der keycounter-datei

   119     our @new_serial;

   120     our $master_dir;

   121     my $zone;

   122     my $kc;

   123 

   124     for (&del_double(@new_serial)) {

   125         $zone = $_;

   126 

   127         unless (-e "$master_dir/$zone/.index.zsk") {

   128             next;

   129         }

   130 

   131         chdir "$master_dir/$zone";

   132         if (`dnssec-signzone $zone 2>/dev/null`) {

   133             print " * $zone neu signiert \n";

   134 

   135             # erhoeht den keycounter

   136             if ("$master_dir/$zone/.keycounter") {

   137                 open(KC, "$master_dir/$zone/.keycounter");

   138                 $kc = <KC>;

   139                 close(KC);

   140                 $kc += 1;

   141             }

   142             else {

   143                 $kc = 1;

   144             }

   145             open(KC, ">$master_dir/$zone/.keycounter");

   146             print KC $kc;

   147             close(KC);

   148         }

   149         else { print "$zone konnte nicht signiert werden \n"; }

   150     }

   151 }

   152 

   153 sub update_serial {

   154     our $master_dir;

   155     our @new_serial;

   156     chomp(my $date = `date +%Y%m%d`);

   157     my @new_content;

   158     my $sdate;

   159     my $scount;

   160     my $serial;

   161 

   162     for (&del_double(@new_serial)) {

   163 

   164         # erhoeht den serial

   165         my $zone        = $_;

   166         my $file        = "$master_dir/$zone/$zone";

   167         my @new_content = ();

   168 

   169         open(SER, "<$file") or die "$file: $!\n";

   170         for (<SER>) {

   171             if (/^\s+(\d+)(\d{2})\s*;\s*serial/i) {

   172                 $sdate  = $1;

   173                 $scount = $2;

   174                 $serial = "$sdate$scount";

   175                 if ($date eq $sdate) {

   176                     $scount++;

   177                 }

   178                 else {

   179                     $sdate  = $date;

   180                     $scount = "00";

   181                 }

   182             }

   183             if ($serial) {

   184                 s/$serial/$sdate$scount/;

   185             }

   186             push @new_content, $_;

   187         }

   188         close(SER);

   189 

   190         open(RES, ">$file") or die "$file: $!\n";

   191         print RES @new_content;

   192         close(RES);

   193         print " * $zone: serial erhoeht \n";

   194 

   195         open(STAMP, ">$master_dir/$zone/.stamp")

   196           or die "$master_dir/$zone/.stamp: $!\n";

   197         close(STAMP);

   198         print " * $zone: stamp aktualisiert \n";

   199     }

   200 }

   201 

   202 sub mk_zone_conf {

   203 

   204     # erzeugt eine named.conf-datei aus den entsprechenden vorlagen.

   205     our $bind_dir;

   206     our $conf_dir;

   207 

   208     open(TO, ">$bind_dir/named.conf.zones")

   209       or die "$bind_dir/named.conf.zones: $!\n";

   210     while (<$conf_dir/*>) {

   211         open(FROM, "$_") or die "$_: $! \n";

   212         print TO <FROM>;

   213         close(FROM);

   214     }

   215     close(TO);

   216     print "** zonekonfiguration erzeugt\n";

   217 }

   218 

   219 sub update_index {

   220 

   221     # aktualisiert die indexzone;

   222     our @new_serial;

   223     our $indexzone;

   224     our $master_dir;

   225     my @iz_content_old;

   226     my @iz_content_new;

   227 

   228     open(INDEXZONE, "$master_dir/$indexzone/$indexzone")

   229       or die "$master_dir/$indexzone/$indexzone: $!\n";

   230     @iz_content_old = <INDEXZONE>;

   231     close(INDEXZONE);

   232 

   233     for (@iz_content_old) {

   234         unless (m#ZONE::#) {

   235             push @iz_content_new, $_;

   236         }

   237     }

   238 

   239     for my $dir (glob "$master_dir/*") {

   240         my $zone     = basename($dir);

   241         my $info_end = "::sec-off";

   242 

   243         if (-e "$dir/.keycounter") {

   244             $info_end = "::sec-on";

   245         }

   246 

   247         my $iz_line = "\t\tIN TXT\t\t\"ZONE::$zone$info_end\"\n";

   248 

   249         push @iz_content_new, $iz_line;

   250     }

   251 

   252     open(INDEXZONE, ">$master_dir/$indexzone/$indexzone")

   253       or die "$master_dir/$indexzone/$indexzone: $!\n";

   254     print INDEXZONE @iz_content_new;

   255     close(INDEXZONE);

   256 

   257     # fuegt die index-zone in die liste damit der serial erhoet wird

   258     push @new_serial, $indexzone;

   259 

   260     print "** index-zone aktualisiert \n";

   261 }

   262 

   263 sub file_entry {

   264 

   265     # prueft jede domain, die ein verzeichnis in $master_dir hat, ob sie

   266     # dnssec nutzt.

   267     # passt die eintraege in $config_file falls noetig an.

   268     our $master_dir;

   269     our $conf_dir;

   270 

   271     while (<$master_dir/*>) {

   272         s#($master_dir/)(.*)#$2#;

   273         my $zone      = $_;

   274         my $zone_file = "$master_dir/$zone/$zone";

   275         my $conf_file = "$conf_dir/$zone";

   276         my @c_content;

   277 

   278         unless (-f "$conf_file") {

   279             die "$conf_file: $! \n";

   280         }

   281 

   282         if (-e "$master_dir/$zone/.keycounter") {

   283             open(FILE, "<$conf_file") or die "$conf_file: $!\n";

   284             @c_content = <FILE>;

   285             close(FILE);

   286             for (@c_content) {

   287                 if (m{(.*)($zone_file)(";)}) {

   288                     print

   289                       " * zonekonfiguration aktualisiert ($2 ==> $2.signed)\n";

   290                     $_ = "$1$2.signed$3\n";

   291                 }

   292             }

   293             open(FILE, ">$conf_file") or die "$conf_file: $!\n";

   294             print FILE @c_content;

   295             close(FILE);

   296         }

   297         else {

   298             open(FILE, "<$conf_file") or die "$conf_file: $!\n";

   299             @c_content = <FILE>;

   300             close(FILE);

   301             for (@c_content) {

   302                 if (m{(.*)($zone_file)\.signed(.*)}) {

   303                     print

   304                       " * zonekonfiguration aktualisiert ($2.signed ==> $2)\n";

   305                     $_ = "$1$2$3\n";

   306                 }

   307             }

   308             open(FILE, ">$conf_file") or die "$conf_file: $!\n";

   309             print FILE @c_content;

   310             close(FILE);

   311         }

   312     }

   313 }

   314 

   315 sub server_reload {

   316     if (`rndc reload`) { print "** reload dns-server \n" }

   317 }

   318 

   319 sub to_begin_ro {

   320 

   321     # gibt alle zonen mit abgelaufenen keycounter in die liste @begin_ro_list

   322     our @begin_ro_list;

   323     our $master_dir;

   324     our $key_counter_end;

   325     our @new_serial;

   326     my $zone;

   327 

   328     while (<$master_dir/*>) {

   329         chomp($zone = $_);

   330         my $key;

   331 

   332         unless (-f "$zone/.keycounter") { next; }

   333 

   334         open(KEY, "$zone/.keycounter") or die "$zone/.keycounter: $!\n";

   335         $key = <KEY>;

   336         close(KEY);

   337 

   338         # vergleicht den wert aus der keycount-datei mit dem wert aus der

   339         #dnstools.conf (key_counter_end)

   340         if ($key_counter_end <= $key) {

   341             $zone =~ s#($master_dir/)(.*)#$2#;

   342             push @begin_ro_list, $zone;

   343         }

   344     }

   345 }

   346 

   347 sub to_end_ro {

   348 

   349     # funktion ueberprueft ob ein keyrollover fertig ist

   350     # die bedingung dafuer ist das:

   351     # - eine datei .index.zsk vorhanden ist

   352     # - die datei .index.zsk vor mehr x stunden geaendert wurde

   353     # - die datei .index.zsk ueber mehr als zwei zeilen gross ist

   354     our $master_dir;

   355     our @end_ro_list;

   356     our $ablauf_zeit;

   357     chomp(my $now_time = `date +%s`);

   358 

   359     for (<$master_dir/*>) {

   360         my $zone = $_;

   361         $zone =~ s#($master_dir/)(.*)#$2#;

   362 

   363         my @index = ();

   364         my $index_wc;

   365         my @status;

   366 

   367         # prueft nach der ".index.zsk"-datei und erstellt den zeitpunkt

   368         # an dem das key-rollover endet. - $status[9]

   369         if (-e "$master_dir/$zone/.index.zsk") {

   370             @status = stat("$master_dir/$zone/.index.zsk");

   371             $status[9] += (3600 * $ablauf_zeit);

   372         }

   373         else { next; }

   374 

   375         # $status[9] ist der zeitpunkt an dem der key-rollover endet

   376         # prueft ob das key-rollover-ende erreicht ist

   377         unless ($status[9] < $now_time) { next; }

   378 

   379         # prueft die anzahl der schluessel in der .index.zsk

   380         open(INDEX, "$master_dir/$zone/.index.zsk")

   381           or die "$master_dir/$zone/.index.zsk: $!\n";

   382         @index    = <INDEX>;

   383         $index_wc = @index;

   384         close(INDEX);

   385         if ($index_wc > 1) { push @end_ro_list, $zone; }

   386     }

   387 }

   388 

   389 sub begin_ro {

   390 

   391     # anfang des key-rollovers

   392     our @begin_ro_list;

   393     our $master_dir;

   394     our @new_serial;

   395 

   396     for (&del_double(@begin_ro_list)) {

   397 

   398         #erzeugt zsks

   399         my $zone = $_;

   400         my $zpf  = "$master_dir/$zone";

   401         my @index;

   402 

   403         chdir "$zpf" or die "$zpf: $!\n";

   404         my $keyname = `dnssec-keygen -a RSASHA1 -b 512 -n ZONE $zone`;

   405 

   406         open(INDEX, ".index.zsk") or die "$zpf/.index.zsk: $!\n";

   407         @index = <INDEX>;

   408         close(INDEX);

   409 

   410         push @index, $keyname;

   411         if (@index > 2) { shift(@index); }

   412 

   413         open(INDEX, ">.index.zsk") or die "$zpf/.index.zsk: $!\n";

   414         print INDEX @index;

   415         close(INDEX);

   416 

   417         chomp($keyname);

   418         print " * $zone: neuer ZSK $keyname erstellt\n";

   419 

   420         open(KC, ">.keycounter") or die "$zpf/keycounter: $!\n";

   421         print KC "0";

   422         close(KC);

   423 

   424         &kill_useless_keys($zone);

   425         &key_to_zonefile($zone);

   426         push @new_serial, $zone;

   427     }

   428 }

   429 

   430 sub key_to_zonefile {

   431 

   432     # die funktion fugt alle schluessel in eine zonedatei

   433     our $master_dir;

   434     my $zone = $_[0];

   435     my $zpf  = "$master_dir/$zone";

   436     my @old_content;

   437     my @new_content = ();

   438 

   439     open(ZONEFILE, "<$zpf/$zone");

   440     @old_content = <ZONEFILE>;

   441     close(ZONEFILE);

   442 

   443     for (@old_content) {

   444         unless (m#INCLUDE.*key#) { push @new_content, $_; }

   445     }

   446 

   447     for (<$zpf/*>) {

   448         if (m#(.*\/)(K.*\.key)#) {

   449             push @new_content, "\$INCLUDE \"$2\"\n";

   450         }

   451     }

   452     open(ZONEFILE, ">$zpf/$zone") or die "$zpf/$zone: $!\n";

   453     print ZONEFILE @new_content;

   454     close(ZONEFILE);

   455 }

   456 

   457 sub kill_useless_keys {

   458 

   459     # die funktion loescht alle schluessel die nicht in der index.zsk

   460     # der uebergebenen zone stehen

   461     our $master_dir;

   462     my $zone    = $_[0];

   463     my @keylist = ();

   464     my $zpf     = "$master_dir/$zone";

   465 

   466     open(INDEX, "<$zpf/.index.zsk") or die "$zpf/.index.zsk: $!\n";

   467     @keylist = <INDEX>;

   468     close(INDEX);

   469     open(INDEX, "<$zpf/.index.ksk") or die "$zpf/.index.ksk: $!\n";

   470     push @keylist, <INDEX>;

   471 

   472     # kuerzt die schluessel-bezeichnung aus der indexdatei auf die id um sie

   473     # besser vergleichen zu koennen.

   474     for (@keylist) {

   475         chomp;

   476         s#K.*\+.*\+(.*)#$1#;

   477     }

   478 

   479     # prueft alle schluesseldateien (ksk, zsk) ob sie in der jeweiligen

   480     # indexdatei beschrieben sind. wenn nicht werden sie geloescht.

   481     for (`ls $master_dir/$zone/K*[key,private]`) {

   482         chomp;

   483         my $file     = $_;

   484         my $rm_count = 1;

   485         my $keyname;

   486         for (@keylist) {

   487             if ($file =~ /$_/) { $rm_count = 0; }

   488         }

   489         if ($rm_count == 1) {

   490             unlink "$file";

   491             if ($file =~ /$zpf\/(.*\.key)/) {

   492                 print " * $zone: Schluessel $1 entfernt \n";

   493             }

   494         }

   495     }

   496 }

   497 

   498 sub end_ro {

   499     our @end_ro_list;

   500     our $master_dir;

   501     our @new_serial;

   502     my @content;

   503 

   504     for (@end_ro_list) {

   505         my $zone  = $_;

   506         my $count = 0;

   507         my @content;

   508         my $last_key;

   509 

   510         open(INDEX, "<$master_dir/$zone/.index.zsk");

   511         @content = <INDEX>;

   512         close(INDEX);

   513 

   514         for (@content) {

   515             $count++;

   516             $last_key = $_;

   517         }

   518         if ($count > 1) {

   519             open(INDEX, ">$master_dir/$zone/.index.zsk");

   520             print INDEX $last_key;

   521             close(INDEX);

   522         }

   523         &kill_useless_keys($zone);

   524         &key_to_zonefile($zone);

   525         push @new_serial, $zone;

   526     }

   527 }

   528 

   529 &read_conf;

   530 

   531 our %config;

   532 our @new_serial;       # liste fuer neuen serial

   533 our @begin_ro_list;    # liste mit zonen deren key-rollover beginnt

   534 our @end_ro_list;      # liste mit zonen deren key-rollover fertig ist

   535 our $master_dir      = $config{master_dir};

   536 our $bind_dir        = $config{bind_dir};

   537 our $conf_dir        = $config{zone_conf_dir};

   538 our $sign_alert_time = $config{sign_alert_time};

   539 our $indexzone       = $config{indexzone};

   540 our $key_counter_end = $config{key_counter_end};

   541 our $ablauf_zeit     = $config{abl_zeit};

   542 

   543 &add_argv;

   544 &changed_zone;

   545 &sign_end;

   546 

   547 &to_begin_ro;    # prueft nach beginnenden rollover-verfahren

   548 &to_end_ro;      # prueft nach endenden rollover-verfahren

   549 

   550 if (@begin_ro_list) {

   551     &begin_ro;    # eine rollover-beginn-sequenz

   552 }

   553 

   554 if (@end_ro_list) {

   555     &end_ro;      # eine rollover-end-squenz

   556 }

   557 

   558 if (@new_serial) {

   559     &update_index;     # index zone aktuallisieren

   560     &update_serial;    # serial aktuallisieren

   561     &sign_zone;        # zone signieren

   562 }

   563 

   564 &file_entry;           # bearbeitet die file-eintraege der konfigurations-datei

   565 &mk_zone_conf;         # konfiguration zusammenfuegen

   566 &server_reload;        # server neu laden