| 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; |