Zonemaster/Engine/Test/Consistency.pm untested

filter: Statementstmt 0.0% 0 / 416 Branchbran 0.0% 0 / 132 Conditioncond 0.0% 0 / 41 MC/DCmcdc 0.0% 0 / 24 Subroutinesub 0.0% 0 / 25 Podpod 0.0% 0 / 12 totaltotal 0.0% 0 / 650 CC 67 SCAR 56.3
CC
67
Cov
0%
consistency05
812.0
consistency01
72.0
all
56.0
CRAP 278.5
1 package Zonemaster::Engine::Test::Consistency;
2  
3 use v5.16.0;
4 use warnings;
5  
6 use version; our $VERSION = version->declare("v1.1.16");
7  
8 use List::MoreUtils qw[uniq];
9 use Locale::TextDomain qw[Zonemaster-Engine];
10 use Net::IP::XS;
11 use Readonly;
12  
13 use Zonemaster::Engine::Profile;
14 use Zonemaster::Engine::Constants qw[:ip :soa];
15 use Zonemaster::Engine::NameserverSet;
16 use Zonemaster::Engine::Test::Address;
17 use Zonemaster::Engine::Util;
18 use Zonemaster::Engine::TestMethods;
19  
20 =head1 NAME
21  
22 Zonemaster::Engine::Test::Consistency - Module implementing tests focused on name servers responses consistency
23  
24 =head1 SYNOPSIS
25  
26 my @results = Zonemaster::Engine::Test::Consistency->all( $zone );
27  
28 =head1 METHODS
29  
30 =over
31  
32 =item all()
33  
34 my @logentry_array = all( $zone );
35  
36 Runs the default set of tests for that module, i.e. L<six tests|/TESTS>.
37  
38 Takes a L<Zonemaster::Engine::Zone> object.
39  
40 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
41  
42 =back
43  
44 =cut
45  
46 sub all {
47 my ( $class, $zone ) = @_;
48 my @results;
49  
50 if ( Zonemaster::Engine::Util::should_run_test( q{consistency01} ) ) {
51 push @results, $class->consistency01( $zone );
52 }
53 if ( Zonemaster::Engine::Util::should_run_test( q{consistency02} ) ) {
54 push @results, $class->consistency02( $zone );
55 }
56 if ( Zonemaster::Engine::Util::should_run_test( q{consistency03} ) ) {
57 push @results, $class->consistency03( $zone );
58 }
59 if ( Zonemaster::Engine::Util::should_run_test( q{consistency04} ) ) {
60 push @results, $class->consistency04( $zone );
61 }
62 if ( Zonemaster::Engine::Util::should_run_test( q{consistency05} ) ) {
63 push @results, $class->consistency05( $zone );
64 }
65 if ( Zonemaster::Engine::Util::should_run_test( q{consistency06} ) ) {
66 push @results, $class->consistency06( $zone );
67 }
68  
69 return @results;
70 }
71  
72 =over
73  
74 =item metadata()
75  
76 my $hash_ref = metadata();
77  
78 Returns a reference to a hash, the keys of which are the names of all Test Cases in the module, and the corresponding values are references to
79 an array containing all the message tags that the Test Case can use in L<log entries|Zonemaster::Engine::Logger::Entry>.
80  
81 =back
82  
83 =cut
84  
85 sub metadata {
86 my ( $class ) = @_;
87  
88 return {
89 consistency01 => [
90 qw(
91 NO_RESPONSE
92 NO_RESPONSE_SOA_QUERY
93 ONE_SOA_SERIAL
94 MULTIPLE_SOA_SERIALS
95 SOA_SERIAL
96 SOA_SERIAL_VARIATION
97 IPV4_DISABLED
98 IPV6_DISABLED
99 TEST_CASE_END
100 TEST_CASE_START
101 )
102 ],
103 consistency02 => [
104 qw(
105 NO_RESPONSE
106 NO_RESPONSE_SOA_QUERY
107 ONE_SOA_RNAME
108 MULTIPLE_SOA_RNAMES
109 SOA_RNAME
110 IPV4_DISABLED
111 IPV6_DISABLED
112 TEST_CASE_END
113 TEST_CASE_START
114 )
115 ],
116 consistency03 => [
117 qw(
118 NO_RESPONSE
119 NO_RESPONSE_SOA_QUERY
120 ONE_SOA_TIME_PARAMETER_SET
121 MULTIPLE_SOA_TIME_PARAMETER_SET
122 SOA_TIME_PARAMETER_SET
123 IPV4_DISABLED
124 IPV6_DISABLED
125 TEST_CASE_END
126 TEST_CASE_START
127 )
128 ],
129 consistency04 => [
130 qw(
131 NO_RESPONSE
132 NO_RESPONSE_NS_QUERY
133 ONE_NS_SET
134 MULTIPLE_NS_SET
135 NS_SET
136 IPV4_DISABLED
137 IPV6_DISABLED
138 TEST_CASE_END
139 TEST_CASE_START
140 )
141 ],
142 consistency05 => [
143 qw(
144 CS05_CHILD_ZONE_LAME
145 CS05_DELEGATION
146 CS05_EXTRA_ADDR_CHILD
147 CS05_ID_ADDR_MISMATCH
148 CS05_ID_ADDR_MISSING
149 CS05_INCONSISTENT_DELEGATION
150 CS05_MISSING_GLUE_FOR_NS
151 CS05_MISSING_GLUE_FOR_NS_UNDEL
152 CS05_MISSING_GLUE_FOR_ROOT_NS
153 CS05_NO_MISMATCH_GLUE_ZONE
154 CS05_NO_NS_ADDR_CHILD
155 CS05_OOD_ADDR_MISMATCH
156 TEST_CASE_END
157 TEST_CASE_START
158 )
159 ],
160 consistency06 => [
161 qw(
162 NO_RESPONSE
163 NO_RESPONSE_SOA_QUERY
164 ONE_SOA_MNAME
165 MULTIPLE_SOA_MNAMES
166 TEST_CASE_END
167 TEST_CASE_START
168 )
169 ],
170 };
171 } ## end sub metadata
172  
173 Readonly my %TAG_DESCRIPTIONS => (
174 CONSISTENCY01 => sub {
175 __x # CONSISTENCY:CONSISTENCY01
176 'SOA serial number consistency';
177 },
178 CONSISTENCY02 => sub {
179 __x # CONSISTENCY:CONSISTENCY02
180 'SOA RNAME consistency';
181 },
182 CONSISTENCY03 => sub {
183 __x # CONSISTENCY:CONSISTENCY03
184 'SOA timers consistency';
185 },
186 CONSISTENCY04 => sub {
187 __x # CONSISTENCY:CONSISTENCY04
188 'Name server NS consistency';
189 },
190 CONSISTENCY05 => sub {
191 __x # CONSISTENCY:CONSISTENCY05
192 'Consistency between delegation and zone data';
193 },
194 CONSISTENCY06 => sub {
195 __x # CONSISTENCY:CONSISTENCY06
196 'SOA MNAME consistency';
197 },
198 CS05_CHILD_ZONE_LAME => sub {
199 __x # CONSISTENCY:CS05_CHILD_ZONE_LAME
200 'There is no working name server for the child zone. Tested name servers are "{ns_list}".', @_;
201 },
202 CS05_DELEGATION => sub {
203 __x # CONSISTENCY:CS05_DELEGATION
204 'Delegation of the child zone as provided by the parent name servers listed: "{ns_deleg_list}". Parent name servers: "{ns_list}".', @_;
205 },
206 CS05_EXTRA_ADDR_CHILD => sub {
207 __x # CONSISTENCY:CS05_EXTRA_ADDR_CHILD
208 'There is one or more extra address records found in the child zone that are not present as glue in the delegation: "{ns_list}".', @_;
209 },
210 CS05_NO_MISMATCH_GLUE_ZONE => sub {
211 __ # CONSISTENCY:CS05_NO_MISMATCH_GLUE_ZONE
212 'There is no mismatch between delegation from parent and authoritative data in the child zone.';
213 },
214 CS05_ID_ADDR_MISMATCH => sub {
215 __x # CONSISTENCY:CS05_ID_ADDR_MISMATCH
216 'For name server {nsname} the glue record in the delegation "{ns_ip_list_glue}" is different from the address record in the child zone "{ns_ip_list_zone}".', @_;
217 },
218 CS05_ID_ADDR_MISSING => sub {
219 __x # CONSISTENCY:CS05_ID_ADDR_MISSING
220 'Address record for {nsname}, used as glue record in delegation, is missing in the child zone.', @_;
221 },
222 CS05_INCONSISTENT_DELEGATION => sub {
223 __ # CONSISTENCY:CS05_INCONSISTENT_DELEGATION
224 'The delegation is inconsistent between the parent name servers.';
225 },
226 CS05_MISSING_GLUE_FOR_NS => sub {
227 __x # CONSISTENCY:CS05_MISSING_GLUE_FOR_NS
228 'Expected glue record for {nsname} is missing in the delegation. Found in the parent name servers "{ns_list}".', @_;
229 },
230 CS05_MISSING_GLUE_FOR_NS_UNDEL => sub {
231 __x # CONSISTENCY:CS05_MISSING_GLUE_FOR_NS_UNDEL
232 'IP address (glue record) is expected but missing for {nsname} in the undelegated data.', @_;
233 },
234 CS05_MISSING_GLUE_FOR_ROOT_NS => sub {
235 __x # CONSISTENCY:CS05_MISSING_GLUE_FOR_ROOT_NS
236 'IP address (glue record) is expected but missing for {nsname} in the undelegated data or hint data for root.', @_;
237 },
238 CS05_NO_NS_ADDR_CHILD => sub {
239 __ # CONSISTENCY:CS05_NO_NS_ADDR_CHILD
240 'Child zone cannot be tested since there are no name server IP addresses for that zone.';
241 },
242 CS05_OOD_ADDR_MISMATCH => sub {
243 __x # CONSISTENCY:CS05_OOD_ADDR_MISMATCH
244 'For name server {nsname} the glue record in the delegation "{ns_ip_list_glue}" is different from the address record in the child zone "{ns_ip_list_zone}".', @_;
245 },
246 IPV4_DISABLED => sub {
247 __x # CONSISTENCY:IPV4_DISABLED
248 'IPv4 is disabled, not sending "{rrtype}" query to {ns}.', @_;
249 },
250 IPV6_DISABLED => sub {
251 __x # CONSISTENCY:IPV6_DISABLED
252 'IPv6 is disabled, not sending "{rrtype}" query to {ns}.', @_;
253 },
254 MULTIPLE_NS_SET => sub {
255 __x # CONSISTENCY:MULTIPLE_NS_SET
256 'Found {count} NS set(s).', @_;
257 },
258 MULTIPLE_SOA_MNAMES => sub {
259 __x # CONSISTENCY:MULTIPLE_SOA_MNAMES
260 'Saw {count} SOA mname.', @_;
261 },
262 MULTIPLE_SOA_RNAMES => sub {
263 __x # CONSISTENCY:MULTIPLE_SOA_RNAMES
264 'Found {count} SOA rname(s).', @_;
265 },
266 MULTIPLE_SOA_SERIALS => sub {
267 __x # CONSISTENCY:MULTIPLE_SOA_SERIALS
268 'Found {count} SOA serial number(s).', @_;
269 },
270 MULTIPLE_SOA_TIME_PARAMETER_SET => sub {
271 __x # CONSISTENCY:MULTIPLE_SOA_TIME_PARAMETER_SET
272 "Found {count} SOA time parameter set(s).", @_;
273 },
274 NO_RESPONSE => sub {
275 __x # CONSISTENCY:NO_RESPONSE
276 'Nameserver {ns} did not respond.', @_;
277 },
278 NO_RESPONSE_NS_QUERY => sub {
279 __x # CONSISTENCY:NO_RESPONSE_NS_QUERY
280 'No response from nameserver {ns} on NS queries.', @_;
281 },
282 NO_RESPONSE_SOA_QUERY => sub {
283 __x # CONSISTENCY:NO_RESPONSE_SOA_QUERY
284 'No response from nameserver {ns} on SOA queries.', @_;
285 },
286 NS_SET => sub {
287 __x # CONSISTENCY:NS_SET
288 'Saw NS set ({nsname_list}) on following nameserver set : {servers}.', @_;
289 },
290 ONE_NS_SET => sub {
291 __x # CONSISTENCY:ONE_NS_SET
292 "A single NS set was found ({nsname_list}).", @_;
293 },
294 ONE_SOA_MNAME => sub {
295 __x # CONSISTENCY:ONE_SOA_MNAME
296 "A single SOA mname value was seen ({mname}).", @_;
297 },
298 ONE_SOA_RNAME => sub {
299 __x # CONSISTENCY:ONE_SOA_RNAME
300 "A single SOA rname value was found ({rname}).", @_;
301 },
302 ONE_SOA_SERIAL => sub {
303 __x # CONSISTENCY:ONE_SOA_SERIAL
304 "A single SOA serial number was found ({serial}).", @_;
305 },
306 ONE_SOA_TIME_PARAMETER_SET => sub {
307 __x # CONSISTENCY:ONE_SOA_TIME_PARAMETER_SET
308 'A single SOA time parameter set was seen '
309 . '(REFRESH={refresh},RETRY={retry},EXPIRE={expire},MINIMUM={minimum}).',
310 @_;
311 },
312 SOA_RNAME => sub {
313 __x # CONSISTENCY:SOA_RNAME
314 "Found SOA rname {rname} on following nameserver set : {ns_list}.", @_;
315 },
316 SOA_SERIAL => sub {
317 __x # CONSISTENCY:SOA_SERIAL
318 'Saw SOA serial number {serial} on following nameserver set : {ns_list}.', @_;
319 },
320 SOA_SERIAL_VARIATION => sub {
321 __x # CONSISTENCY:SOA_SERIAL_VARIATION
322 'Difference between the smaller serial ({serial_min}) and the bigger one ({serial_max}) '
323 . 'is greater than the maximum allowed ({max_variation}).', @_;
324 },
325 SOA_TIME_PARAMETER_SET => sub {
326 __x # CONSISTENCY:SOA_TIME_PARAMETER_SET
327 'Saw SOA time parameter set (REFRESH={refresh}, RETRY={retry}, EXPIRE={expire}, '
328 . 'MINIMUM={minimum}) on following nameserver set : {ns_list}.', @_;
329 },
330 TEST_CASE_END => sub {
331 __x # CONSISTENCY:TEST_CASE_END
332 'TEST_CASE_END {testcase}.', @_;
333 },
334 TEST_CASE_START => sub {
335 __x # CONSISTENCY:TEST_CASE_START
336 'TEST_CASE_START {testcase}.', @_;
337 },
338 );
339  
340 =over
341  
342 =item tag_descriptions()
343  
344 my $hash_ref = tag_descriptions();
345  
346 Used by the L<built-in translation system|Zonemaster::Engine::Translator>.
347  
348 Returns a reference to a hash, the keys of which are the message tags and the corresponding values are strings (message ids).
349  
350 =back
351  
352 =cut
353  
354 sub tag_descriptions {
355 return \%TAG_DESCRIPTIONS;
356 }
357  
358 =over
359  
360 =item version()
361  
362 my $version_string = version();
363  
364 Returns a string containing the version of the current module.
365  
366 =back
367  
368 =cut
369  
370 sub version {
371 return "$Zonemaster::Engine::Test::Consistency::VERSION";
372 }
373  
374 =head1 INTERNAL METHODS
375  
376 =over
377  
378 =item _emit_log()
379  
380 my $log_entry = _emit_log( $message_tag_string, $hash_ref );
381  
382 Adds a message to the L<logger|Zonemaster::Engine::Logger> for this module.
383 See L<Zonemaster::Engine::Logger::Entry/add($tag, $argref, $module, $testcase)> for more details.
384  
385 Takes a string (message tag) and a reference to a hash (arguments).
386  
387 Returns a L<Zonemaster::Engine::Logger::Entry> object.
388  
389 =back
390  
391 =cut
392  
393 sub _emit_log { my ( $tag, $argref ) = @_; return Zonemaster::Engine->logger->add( $tag, $argref, 'Consistency' ); }
394  
395 =over
396  
397 =item _ip_disabled_message()
398  
399 my $bool = _ip_disabled_message( $logentry_array_ref, $ns, @query_type_array );
400  
401 Checks if the IP version of a given name server is allowed to be queried. If not, it adds a logging message and returns true. Else, it returns false.
402  
403 Takes a reference to an array of L<Zonemaster::Engine::Logger::Entry> objects, a L<Zonemaster::Engine::Nameserver> object and an array of strings (query type).
404  
405 Returns a boolean.
406  
407 =back
408  
409 =cut
410  
411 sub _ip_disabled_message {
412 my ( $results_array, $ns, @rrtypes ) = @_;
413  
414 if ( not Zonemaster::Engine::Profile->effective->get(q{net.ipv6}) and $ns->address->version == $IP_VERSION_6 ) {
415 push @$results_array, map {
416 _emit_log(
417 IPV6_DISABLED => {
418 ns => $ns->string,
419 rrtype => $_
420 }
421 )
422 } @rrtypes;
423 return 1;
424 }
425  
426 if ( not Zonemaster::Engine::Profile->effective->get(q{net.ipv4}) and $ns->address->version == $IP_VERSION_4 ) {
427 push @$results_array, map {
428 _emit_log(
429 IPV4_DISABLED => {
430 ns => $ns->string,
431 rrtype => $_,
432 }
433 )
434 } @rrtypes;
435 return 1;
436 }
437 return 0;
438 }
439  
440  
441 =head1 TESTS
442  
443 =over
444  
445 =item consistency01()
446  
447 my @logentry_array = consistency01( $zone );
448  
449 Runs the L<Consistency01 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Consistency-TP/consistency01.md>.
450  
451 Takes a L<Zonemaster::Engine::Zone> object.
452  
453 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
454  
455 =back
456  
457 =cut
458  
459 sub consistency01 {
460 my ( $class, $zone ) = @_;
461  
462 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Consistency01';
463 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
464 my %nsnames_and_ip;
465 my %serials;
466 my $query_type = q{SOA};
467  
468 foreach
469 my $local_ns ( @{ Zonemaster::Engine::TestMethods->method4( $zone ) }, @{ Zonemaster::Engine::TestMethods->method5( $zone ) } )
470 {
471  
472 next if $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short };
473  
474 if ( _ip_disabled_message( \@results, $local_ns, $query_type ) ) {
475 next;
476 }
477  
478 my $p = $local_ns->query( $zone->name, $query_type );
479  
480 if ( not $p ) {
481 push @results, _emit_log( NO_RESPONSE => { ns => $local_ns->string } );
482 next;
483 }
484  
485 my ( $soa ) = $p->get_records_for_name( $query_type, $zone->name );
486  
487 if ( not $soa ) {
488 push @results, _emit_log( NO_RESPONSE_SOA_QUERY => { ns => $local_ns->string } );
489 next;
490 }
491 else {
492 push @{ $serials{ $soa->serial } }, $local_ns->name->string . q{/} . $local_ns->address->short;
493 $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short }++;
494 }
495 } ## end foreach my $local_ns ( @{ Zonemaster::Engine::TestMethods...})
496  
497 my @serial_numbers = sort keys %serials;
498  
499 foreach my $serial ( @serial_numbers ) {
500 push @results,
501 _emit_log(
502 SOA_SERIAL => {
503 serial => $serial,
504 ns_list => join( q{;}, sort @{ $serials{$serial} } ),
505 }
506 );
507 }
508  
509 if ( scalar( @serial_numbers ) == 1 ) {
510 push @results,
511 _emit_log(
512 ONE_SOA_SERIAL => {
513 serial => ( keys %serials )[0],
514 }
515 );
516 }
517 elsif ( scalar @serial_numbers ) {
518 push @results,
519 _emit_log(
520 MULTIPLE_SOA_SERIALS => {
521 count => scalar( keys %serials ),
522 }
523 );
524 if ( $serial_numbers[-1] - $serial_numbers[0] > $SERIAL_MAX_VARIATION ) {
525 push @results,
526 _emit_log(
527 SOA_SERIAL_VARIATION => {
528 serial_min => $serial_numbers[0],
529 serial_max => $serial_numbers[-1],
530 max_variation => $SERIAL_MAX_VARIATION,
531 }
532 );
533 }
534 } ## end elsif ( scalar @serial_numbers)
535  
536 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
537 } ## end sub consistency01
538  
539 =over
540  
541 =item consistency02()
542  
543 my @logentry_array = consistency02( $zone );
544  
545 Runs the L<Consistency02 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Consistency-TP/consistency02.md>.
546  
547 Takes a L<Zonemaster::Engine::Zone> object.
548  
549 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
550  
551 =back
552  
553 =cut
554  
555 sub consistency02 {
556 my ( $class, $zone ) = @_;
557  
558 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Consistency02';
559 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
560 my %nsnames_and_ip;
561 my %rnames;
562 my $query_type = q{SOA};
563  
564 foreach
565 my $local_ns ( @{ Zonemaster::Engine::TestMethods->method4( $zone ) }, @{ Zonemaster::Engine::TestMethods->method5( $zone ) } )
566 {
567  
568 next if $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short };
569  
570 if ( _ip_disabled_message( \@results, $local_ns, $query_type ) ) {
571 next;
572 }
573  
574 my $p = $local_ns->query( $zone->name, $query_type );
575  
576 if ( not $p ) {
577 push @results, _emit_log( NO_RESPONSE => { ns => $local_ns->string } );
578 next;
579 }
580  
581 my ( $soa ) = $p->get_records_for_name( $query_type, $zone->name );
582  
583 if ( not $soa ) {
584 push @results, _emit_log( NO_RESPONSE_SOA_QUERY => { ns => $local_ns->string } );
585 next;
586 }
587 else {
588 push @{ $rnames{ lc( $soa->rname ) } }, $local_ns->name->string . q{/} . $local_ns->address->short;
589 $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short }++;
590 }
591 } ## end foreach my $local_ns ( @{ Zonemaster::Engine::TestMethods...})
592  
593 if ( scalar( keys %rnames ) == 1 ) {
594 push @results,
595 _emit_log(
596 ONE_SOA_RNAME => {
597 rname => ( keys %rnames )[0],
598 }
599 );
600 }
601 elsif ( scalar( keys %rnames ) ) {
602 push @results,
603 _emit_log(
604 MULTIPLE_SOA_RNAMES => {
605 count => scalar( keys %rnames ),
606 }
607 );
608 foreach my $rname ( keys %rnames ) {
609 push @results,
610 _emit_log(
611 SOA_RNAME => {
612 rname => $rname,
613 ns_list => join( q{;}, @{ $rnames{$rname} } ),
614 }
615 );
616 }
617 }
618  
619 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
620 } ## end sub consistency02
621  
622 =over
623  
624 =item consistency03()
625  
626 my @logentry_array = consistency03( $zone );
627  
628 Runs the L<Consistency03 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Consistency-TP/consistency03.md>.
629  
630 Takes a L<Zonemaster::Engine::Zone> object.
631  
632 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
633  
634 =back
635  
636 =cut
637  
638 sub consistency03 {
639 my ( $class, $zone ) = @_;
640  
641 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Consistency03';
642 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
643 my %nsnames_and_ip;
644 my %time_parameter_sets;
645 my $query_type = q{SOA};
646  
647 foreach
648 my $local_ns ( @{ Zonemaster::Engine::TestMethods->method4( $zone ) }, @{ Zonemaster::Engine::TestMethods->method5( $zone ) } )
649 {
650  
651 next if $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short };
652  
653 if ( _ip_disabled_message( \@results, $local_ns, $query_type ) ) {
654 next;
655 }
656  
657 my $p = $local_ns->query( $zone->name, $query_type );
658  
659 if ( not $p ) {
660 push @results, _emit_log( NO_RESPONSE => { ns => $local_ns->string } );
661 next;
662 }
663  
664 my ( $soa ) = $p->get_records_for_name( $query_type, $zone->name );
665  
666 if ( not $soa ) {
667 push @results, _emit_log( NO_RESPONSE_SOA_QUERY => { ns => $local_ns->string } );
668 next;
669 }
670 else {
671 push
672 @{ $time_parameter_sets{ sprintf q{%d;%d;%d;%d}, $soa->refresh, $soa->retry, $soa->expire, $soa->minimum }
673 },
674 $local_ns->name->string . q{/} . $local_ns->address->short;
675 $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short }++;
676 }
677 } ## end foreach my $local_ns ( @{ Zonemaster::Engine::TestMethods...})
678  
679 if ( scalar( keys %time_parameter_sets ) == 1 ) {
680 my ( $refresh, $retry, $expire, $minimum ) = split /;/sxm, ( keys %time_parameter_sets )[0];
681 push @results,
682 _emit_log(
683 ONE_SOA_TIME_PARAMETER_SET => {
684 refresh => $refresh,
685 retry => $retry,
686 expire => $expire,
687 minimum => $minimum,
688 }
689 );
690 }
691 elsif ( scalar( keys %time_parameter_sets ) ) {
692 push @results,
693 _emit_log(
694 MULTIPLE_SOA_TIME_PARAMETER_SET => {
695 count => scalar( keys %time_parameter_sets ),
696 }
697 );
698 foreach my $time_parameter_set ( keys %time_parameter_sets ) {
699 my ( $refresh, $retry, $expire, $minimum ) = split /;/sxm, $time_parameter_set;
700 push @results,
701 _emit_log(
702 SOA_TIME_PARAMETER_SET => {
703 refresh => $refresh,
704 retry => $retry,
705 expire => $expire,
706 minimum => $minimum,
707 ns_list => join( q{;}, sort @{ $time_parameter_sets{$time_parameter_set} } ),
708 }
709 );
710 }
711 } ## end elsif ( scalar( keys %time_parameter_sets...))
712  
713 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
714 } ## end sub consistency03
715  
716 =over
717  
718 =item consistency04()
719  
720 my @logentry_array = consistency04( $zone );
721  
722 Runs the L<Consistency04 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Consistency-TP/consistency04.md>.
723  
724 Takes a L<Zonemaster::Engine::Zone> object.
725  
726 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
727  
728 =back
729  
730 =cut
731  
732 sub consistency04 {
733 my ( $class, $zone ) = @_;
734  
735 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Consistency04';
736 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
737 my %nsnames_and_ip;
738 my %ns_sets;
739 my $query_type = q{NS};
740  
741 foreach
742 my $local_ns ( @{ Zonemaster::Engine::TestMethods->method4( $zone ) }, @{ Zonemaster::Engine::TestMethods->method5( $zone ) } )
743 {
744  
745 next if $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short };
746  
747 if ( _ip_disabled_message( \@results, $local_ns, $query_type ) ) {
748 next;
749 }
750  
751 my $p = $local_ns->query( $zone->name, $query_type );
752  
753 if ( not $p ) {
754 push @results, _emit_log( NO_RESPONSE => { ns => $local_ns->string } );
755 next;
756 }
757  
758 my ( @ns ) = sort map { lc( $_->nsdname ) } $p->get_records_for_name( $query_type, $zone->name );
759  
760 if ( not scalar( @ns ) ) {
761 push @results, _emit_log( NO_RESPONSE_NS_QUERY => { ns => $local_ns->string } );
762 next;
763 }
764 else {
765 push @{ $ns_sets{ join( q{;}, @ns ) } }, $local_ns->string;
766 $nsnames_and_ip{ $local_ns->string }++;
767 }
768 } ## end foreach my $local_ns ( @{ Zonemaster::Engine::TestMethods...})
769  
770 if ( scalar( keys %ns_sets ) == 1 ) {
771 push @results, _emit_log( ONE_NS_SET => { nsname_list => ( keys %ns_sets )[0] });
772 }
773 elsif ( scalar( keys %ns_sets ) ) {
774 push @results,
775 _emit_log(
776 MULTIPLE_NS_SET => {
777 count => scalar( keys %ns_sets ),
778 }
779 );
780 foreach my $ns_set ( keys %ns_sets ) {
781 push @results,
782 _emit_log(
783 NS_SET => {
784 nsname_list => $ns_set,
785 servers => join( q{;}, @{ $ns_sets{$ns_set} } ),
786 }
787 );
788 }
789 }
790  
791 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
792 } ## end sub consistency04
793  
794 =over
795  
796 =item consistency05()
797  
798 my @logentry_array = consistency05( $zone );
799  
800 Runs the L<Consistency05 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Consistency-TP/consistency05.md>.
801  
802 Takes a L<Zonemaster::Engine::Zone> object.
803  
804 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
805  
806 =back
807  
808 =cut
809  
810 sub consistency05 {
811 my ( $class, $zone ) = @_;
812  
813 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Consistency05';
814 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
815  
816 # Steps 1–3
817 my @parent_ns = @{ Zonemaster::Engine::TestMethodsV2->get_parent_ns_names_and_ips( $zone ) // [] };
818 my @parent_ns_ips = @{ Zonemaster::Engine::TestMethodsV2->get_parent_ns_ips( $zone ) // [] };
819  
820 my @child_ns_ips = uniq
821 @{ Zonemaster::Engine::TestMethodsV2->get_del_ns_ips( $zone ) // [] },
822 @{ Zonemaster::Engine::TestMethodsV2->get_zone_ns_ips( $zone ) // [] };
823  
824 my %delegation;
825 my %child_zone_ns;
826 my $delegation_id_ns = Zonemaster::Engine::NameserverSet->new();
827 my $delegation_ood_ns = Zonemaster::Engine::NameserverSet->new();
828 my %missing_glue;
829 my $auth_addr_records_in_child = Zonemaster::Engine::NameserverSet->new();
830 my %extra_address_child;
831  
832 # Step 4
833 foreach my $parent_ns ( @parent_ns_ips ) {
834 # Do SOA query over TCP preferably, but fall back to UDP if name
835 # server does not respond over TCP.
836 my $p = $parent_ns->query( $zone->name(), 'SOA', { usevc => 1 } );
837 $p //= $parent_ns->query( $zone->name(), 'SOA' );
838  
839 next unless ( defined $p and $p->is_redirect );
840  
841 my %authority =
842 map { lc name( $_->nsdname() ) => 1 }
843 $p->get_records_for_name( 'NS', $zone, 'authority' );
844  
845
846 my @additional =
847 map {
848 my $name = name( $_->owner() );
849  
850 # Filters out A and AAAA records with invalid IP addresses
851 my $addr = Net::IP::XS->new( $_->address );
852 if ( defined $addr ) {
853 Zonemaster::Engine::Nameserver->new( { name => $name, address => $addr } )
854 }
855 else {
856 ()
857 }
858 }
859 grep {
860 my $name = lc name( $_->owner() );
861 exists $authority{$name} and ( $_->type eq 'A' or $_->type eq 'AAAA' )
862 }
863 $p->additional;
864  
865 my $set = Zonemaster::Engine::NameserverSet->new( keys %authority, @additional );
866  
867 $delegation{$parent_ns} = [ $set->sorted_items() ];
868 }
869  
870  
871 # Step 5
872 foreach my $parent_ns_ip ( sort keys %delegation ) {
873 foreach my $delegation_ns ( @{ $delegation{$parent_ns_ip} } ) {
874 my $delegation_ns_name = do {
875 if ( $delegation_ns->isa('Zonemaster::Engine::Nameserver') ) {
876 $delegation_ns->name()
877 }
878 else {
879 $delegation_ns;
880 }
881 };
882  
883 if ( $zone->name()->is_in_bailiwick( $delegation_ns_name ) ) {
884 if ( $delegation_ns->isa('Zonemaster::Engine::DNSName') ) {
885 push @{$missing_glue{ lc $delegation_ns }}, $parent_ns_ip;
886 }
887 $delegation_id_ns->push($delegation_ns);
888 }
889 else {
890 $delegation_ood_ns->push($delegation_ns);
891 }
892 }
893 }
894  
895 # Step 6
896 {
897 my %delegation_sets;
898 for my $d ( keys %delegation ) {
899 my $s = join(";", @{$delegation{$d}});
900 push @{$delegation_sets{$s}}, $d;
901 }
902 if ( scalar %delegation_sets > 1 ) {
903 push @results, _emit_log( CS05_INCONSISTENT_DELEGATION => {} );
904 while ( my ($ns_deleg_list, $ns_list) = each %delegation_sets ) {
905 push @results, _emit_log( CS05_DELEGATION => {
906 ns_deleg_list => $ns_deleg_list,
907 ns_list => join( ';', sort @$ns_list )
908 } );
909 }
910 }
911 }
912  
913 # Step 7
914 if ( $zone->name() ne '.' ) {
915 foreach my $fake_name ( Zonemaster::Engine::Recursor->get_fake_names( $zone->name() ) ) {
916 $fake_name = name( $fake_name );
917 my @fake_ns = map {
918 Zonemaster::Engine::Nameserver->new( { name => $fake_name, address => $_ } )
919 } Zonemaster::Engine::Recursor->get_fake_addresses( $zone->name(), $fake_name );
920  
921 if ( $zone->name()->is_in_bailiwick( $fake_name ) ) {
922 if ( scalar @fake_ns == 0 ) {
923 push @results, _emit_log( CS05_MISSING_GLUE_FOR_NS_UNDEL => { nsname => $fake_name } );
924 }
925 else {
926 $delegation_id_ns->push( @fake_ns );
927 }
928 }
929 else {
930 if ( scalar @fake_ns == 0 ) {
931 $delegation_ood_ns->push( $fake_name );
932 }
933 else {
934 $delegation_ood_ns->push( @fake_ns );
935 }
936 }
937 }
938 }
939  
940 # Step 8
941 if ( $zone->name() eq '.' ) {
942 my @hint_ns = @{ Zonemaster::Engine::TestMethodsV2->get_del_ns_names_and_ips( $zone ) };
943  
944 foreach my $item ( @hint_ns ) {
945 if ( $item->isa( 'Zonemaster::Engine::DNSName') ) {
946 push @results, _emit_log( CS05_MISSING_GLUE_FOR_ROOT_NS => { nsname => $item } );
947 }
948 else {
949 $delegation_id_ns->push( $item );
950 }
951 }
952 }
953  
954 # Step 9
955 while ( my ($ns, $ns_list) = each %missing_glue ) {
956 push @results, _emit_log( CS05_MISSING_GLUE_FOR_NS => {
957 nsname => $ns,
958 ns_list => join(';', @$ns_list)
959 } );
960 }
961  
962 # Step 10
963 if ( scalar @child_ns_ips == 0 ) {
964 push @results, _emit_log( CS05_NO_NS_ADDR_CHILD => {} );
965 goto out;
966 }
967  
968 # Step 11
969 foreach my $ns ( @child_ns_ips ) {
970 my $p = $ns->query( $zone->name(), 'NS' );
971 next unless defined $p and $p->rcode eq 'NOERROR' and $p->aa;
972  
973 my @ns_nsnames = uniq map { name( lc $_->nsdname() ) } $p->get_records_for_name( 'NS', $zone );
974 $child_zone_ns{ $ns->address()->short() } = \@ns_nsnames if scalar @ns_nsnames > 0;
975  
976 my @id_ns = uniq (
977 grep( { $zone->name()->is_in_bailiwick(name($_)) } @ns_nsnames ),
978 $delegation_id_ns->names()
979 );
980  
981 foreach my $s ( @id_ns ) {
982 foreach my $qtype ( qw(A AAAA) ) {
983 my $p = Zonemaster::Engine::Recursor->recurse( $s, $qtype, 'IN', [ $ns ] );
984 next unless defined $p and $p->rcode eq 'NOERROR' and $p->aa;
985  
986 $auth_addr_records_in_child->push(
987 map {
988 Zonemaster::Engine::Nameserver->new( { name => $s, address => $_->address() } )
989 } $p->get_records_for_name( $qtype, $s, 'answer' )
990 );
991 }
992 }
993 }
994  
995 # Step 12
996 if ( scalar %child_zone_ns == 0 ) {
997 push @results, _emit_log( CS05_CHILD_ZONE_LAME => { ns_list => join(';', @child_ns_ips) } );
998 goto out;
999 }
1000  
1001 # Step 13
1002 foreach my $n ( $delegation_id_ns->names() ) {
1003 my $parent_glue = Zonemaster::Engine::NameserverSet->new(
1004 grep { $_->isa('Zonemaster::Engine::Nameserver') } $delegation_id_ns->get($n)
1005 );
1006 next if $parent_glue->is_empty();
1007  
1008 my $child_auth = Zonemaster::Engine::NameserverSet->new();
1009 $child_auth->push( $auth_addr_records_in_child->get($n) );
1010 my ( $only_in_parent, $only_in_child ) = $parent_glue->difference( $child_auth );
1011  
1012 if ( $child_auth->is_empty() ) {
1013 push @results, _emit_log( CS05_ID_ADDR_MISSING => { nsname => $n } );
1014 }
1015 elsif ( not $only_in_parent->is_empty() ) {
1016 push @results, _emit_log( CS05_ID_ADDR_MISMATCH => {
1017 nsname => $n,
1018 ns_ip_list_glue => join( ';', map { $_->address()->short() } $only_in_parent->sorted_items() ),
1019 ns_ip_list_zone => join( ';', map { $_->address()->short() } $child_auth->sorted_items() )
1020 } );
1021 }
1022 elsif ( not $only_in_child->is_empty() ) {
1023 $extra_address_child{ $_->address()->short() } = 1 foreach $only_in_child->items();
1024 }
1025 }
1026  
1027 # Step 14
1028 if ( scalar %extra_address_child ) {
1029 push @results, _emit_log( CS05_EXTRA_ADDR_CHILD => {
1030 ns_list => join(';', sort keys %extra_address_child )
1031 } );
1032 }
1033  
1034 # Step 15
1035 foreach my $n ( $delegation_ood_ns->names() ) {
1036 my $set = Zonemaster::Engine::NameserverSet->new(
1037 grep { $_->isa('Zonemaster::Engine::Nameserver') } $delegation_ood_ns->get($n)
1038 );
1039 next if $set->is_empty();
1040  
1041 my $lookup = Zonemaster::Engine::NameserverSet->new(
1042 map {
1043 Zonemaster::Engine::Nameserver->new( { name => $_->owner(), address => $_->address() } )
1044 }
1045 map {
1046 my $p = Zonemaster::Engine::Recursor->recurse( $n, $_ );
1047 if ( defined $p and $p->rcode eq 'NOERROR' ) {
1048 $p->get_records_for_name( $_, $n, 'answer' );
1049 }
1050 else {
1051 ();
1052 }
1053 } ( qw(A AAAA) )
1054 );
1055  
1056 if ( not $lookup->is_empty() ) {
1057 if ( not $set->equals( $lookup ) ) {
1058 push @results, _emit_log( CS05_OOD_ADDR_MISMATCH => {
1059 nsname => $n,
1060 ns_ip_list_ref => join( ";", map { $_->address() } $set->sorted_items() ),
1061 ns_ip_list_lookup => join( ";", map { $_->address() } $lookup->sorted_items() )
1062 } );
1063 }
1064 }
1065 }
1066  
1067 # Step 16
1068 if ( not grep /^CS05_/, map { $_->tag() } @results ) {
1069 push @results, _emit_log( CS05_NO_MISMATCH_GLUE_ZONE => {} );
1070 }
1071  
1072 out:
1073 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
1074 } ## end sub consistency05
1075  
1076 =over
1077  
1078 =item consistency06()
1079  
1080 my @logentry_array = consistency06( $zone );
1081  
1082 Runs the L<Consistency06 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Consistency-TP/consistency06.md>.
1083  
1084 Takes a L<Zonemaster::Engine::Zone> object.
1085  
1086 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
1087  
1088 =back
1089  
1090 =cut
1091  
1092 sub consistency06 {
1093 my ( $class, $zone ) = @_;
1094  
1095 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Consistency06';
1096 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
1097 my %nsnames_and_ip;
1098 my %mnames;
1099 my $query_type = q{SOA};
1100  
1101 foreach
1102 my $local_ns ( @{ Zonemaster::Engine::TestMethods->method4( $zone ) }, @{ Zonemaster::Engine::TestMethods->method5( $zone ) } )
1103 {
1104  
1105 next if $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short };
1106  
1107 if ( _ip_disabled_message( \@results, $local_ns, $query_type ) ) {
1108 next;
1109 }
1110  
1111 my $p = $local_ns->query( $zone->name, $query_type );
1112  
1113 if ( not $p ) {
1114 push @results, _emit_log( NO_RESPONSE => { ns => $local_ns->string } );
1115 next;
1116 }
1117  
1118 my ( $soa ) = $p->get_records_for_name( $query_type, $zone->name );
1119  
1120 if ( not $soa ) {
1121 push @results, _emit_log( NO_RESPONSE_SOA_QUERY => { ns => $local_ns->string } );
1122 next;
1123 }
1124 else {
1125 push @{ $mnames{ lc( $soa->mname ) } }, $local_ns->name->string . q{/} . $local_ns->address->short;
1126 $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short }++;
1127 }
1128 } ## end foreach my $local_ns ( @{ Zonemaster::Engine::TestMethods...})
1129  
1130 if ( scalar( keys %mnames ) == 1 ) {
1131 push @results,
1132 _emit_log(
1133 ONE_SOA_MNAME => {
1134 mname => ( keys %mnames )[0],
1135 }
1136 );
1137 }
1138 elsif ( scalar( keys %mnames ) ) {
1139 push @results,
1140 _emit_log(
1141 MULTIPLE_SOA_MNAMES => {
1142 count => scalar( keys %mnames ),
1143 }
1144 );
1145 foreach my $mname ( keys %mnames ) {
1146 push @results,
1147 _emit_log(
1148 SOA_MNAME => {
1149 mname => $mname,
1150 ns_list => join( q{;}, @{ $mnames{$mname} } ),
1151 }
1152 );
1153 }
1154 }
1155  
1156 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
1157 } ## end sub consistency06
1158  
1159 1;