| 1 | package Zonemaster::Engine::Test::Nameserver; | ||
| 2 | |||
| 3 | use v5.16.0; | ||
| 4 | use warnings; | ||
| 5 | |||
| 6 | use version; our $VERSION = version->declare( "v1.1.0" ); | ||
| 7 | |||
| 8 | use JSON::PP; | ||
| 9 | use List::MoreUtils qw[uniq none]; | ||
| 10 | use Locale::TextDomain qw[Zonemaster-Engine]; | ||
| 11 | use Net::IP::XS; | ||
| 12 | use Readonly; | ||
| 13 | |||
| 14 | use Zonemaster::Engine::Constants qw[:ip]; | ||
| 15 | use Zonemaster::Engine::Profile; | ||
| 16 | use Zonemaster::Engine::Test::Address; | ||
| 17 | use Zonemaster::Engine::TestMethods; | ||
| 18 | use Zonemaster::Engine::Util qw( escape_unprintable scramble_case ); | ||
| 19 | |||
| 20 | =head1 NAME | ||
| 21 | |||
| 22 | Zonemaster::Engine::Test::Nameserver - Module implementing tests focused on the properties of a name server | ||
| 23 | |||
| 24 | =head1 SYNOPSIS | ||
| 25 | |||
| 26 | my @results = Zonemaster::Engine::Test::Nameserver->all( $zone ); | ||
| 27 | |||
| 28 | =cut | ||
| 29 | |||
| 30 | Readonly my @NONEXISTENT_NAMES => qw{ | ||
| 31 | xn--nameservertest.iis.se | ||
| 32 | xn--nameservertest.icann.org | ||
| 33 | xn--nameservertest.ripe.net | ||
| 34 | }; | ||
| 35 | |||
| 36 | =head1 METHODS | ||
| 37 | |||
| 38 | =over | ||
| 39 | |||
| 40 | =item all() | ||
| 41 | |||
| 42 | my @logentry_array = all( $zone ); | ||
| 43 | |||
| 44 | Runs the default set of tests for that module, i.e. L<fourteen tests|/TESTS>. | ||
| 45 | |||
| 46 | Takes a L<Zonemaster::Engine::Zone> object. | ||
| 47 | |||
| 48 | Returns a list of L<Zonemaster::Engine::Logger::Entry> objects. | ||
| 49 | |||
| 50 | =back | ||
| 51 | |||
| 52 | =cut | ||
| 53 | |||
| 54 | sub all { | ||
| 55 | my ( $class, $zone ) = @_; | ||
| 56 | my @results; | ||
| 57 | |||
| 58 | if ( Zonemaster::Engine::Util::should_run_test( q{nameserver01} ) ) { | ||
| 59 | push @results, $class->nameserver01( $zone ); | ||
| 60 | } | ||
| 61 | if ( Zonemaster::Engine::Util::should_run_test( q{nameserver02} ) ) { | ||
| 62 | push @results, $class->nameserver02( $zone ); | ||
| 63 | } | ||
| 64 | if ( Zonemaster::Engine::Util::should_run_test( q{nameserver03} ) ) { | ||
| 65 | push @results, $class->nameserver03( $zone ); | ||
| 66 | } | ||
| 67 | if ( Zonemaster::Engine::Util::should_run_test( q{nameserver04} ) ) { | ||
| 68 | push @results, $class->nameserver04( $zone ); | ||
| 69 | } | ||
| 70 | if ( Zonemaster::Engine::Util::should_run_test( q{nameserver05} ) ) { | ||
| 71 | push @results, $class->nameserver05( $zone ); | ||
| 72 | } | ||
| 73 | if ( Zonemaster::Engine::Util::should_run_test( q{nameserver06} ) ) { | ||
| 74 | push @results, $class->nameserver06( $zone ); | ||
| 75 | } | ||
| 76 | if ( Zonemaster::Engine::Util::should_run_test( q{nameserver07} ) ) { | ||
| 77 | push @results, $class->nameserver07( $zone ); | ||
| 78 | } | ||
| 79 | if ( Zonemaster::Engine::Util::should_run_test( q{nameserver08} ) ) { | ||
| 80 | push @results, $class->nameserver08( $zone ); | ||
| 81 | } | ||
| 82 | if ( Zonemaster::Engine::Util::should_run_test( q{nameserver09} ) ) { | ||
| 83 | push @results, $class->nameserver09( $zone ); | ||
| 84 | } | ||
| 85 | if ( Zonemaster::Engine::Util::should_run_test( q{nameserver10} ) ) { | ||
| 86 | push @results, $class->nameserver10( $zone ); | ||
| 87 | } | ||
| 88 | if ( Zonemaster::Engine::Util::should_run_test( q{nameserver11} ) ) { | ||
| 89 | push @results, $class->nameserver11( $zone ); | ||
| 90 | } | ||
| 91 | if ( Zonemaster::Engine::Util::should_run_test( q{nameserver12} ) ) { | ||
| 92 | push @results, $class->nameserver12( $zone ); | ||
| 93 | } | ||
| 94 | if ( Zonemaster::Engine::Util::should_run_test( q{nameserver13} ) ) { | ||
| 95 | push @results, $class->nameserver13( $zone ); | ||
| 96 | } | ||
| 97 | if ( Zonemaster::Engine::Util::should_run_test( q{nameserver15} ) ) { | ||
| 98 | push @results, $class->nameserver15( $zone ); | ||
| 99 | } | ||
| 100 | |||
| 101 | return @results; | ||
| 102 | } ## end sub all | ||
| 103 | |||
| 104 | =over | ||
| 105 | |||
| 106 | =item metadata() | ||
| 107 | |||
| 108 | my $hash_ref = metadata(); | ||
| 109 | |||
| 110 | 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 | ||
| 111 | an array containing all the message tags that the Test Case can use in L<log entries|Zonemaster::Engine::Logger::Entry>. | ||
| 112 | |||
| 113 | =back | ||
| 114 | |||
| 115 | =cut | ||
| 116 | |||
| 117 | sub metadata { | ||
| 118 | my ( $class ) = @_; | ||
| 119 | |||
| 120 | return { | ||
| 121 | nameserver01 => [ | ||
| 122 | qw( | ||
| 123 | IS_A_RECURSOR | ||
| 124 | NO_RECURSOR | ||
| 125 | NO_RESPONSE | ||
| 126 | TEST_CASE_END | ||
| 127 | TEST_CASE_START | ||
| 128 | ) | ||
| 129 | ], | ||
| 130 | nameserver02 => [ | ||
| 131 | qw( | ||
| 132 | BREAKS_ON_EDNS | ||
| 133 | EDNS_RESPONSE_WITHOUT_EDNS | ||
| 134 | EDNS_VERSION_ERROR | ||
| 135 | EDNS0_SUPPORT | ||
| 136 | NO_EDNS_SUPPORT | ||
| 137 | NO_RESPONSE | ||
| 138 | NS_ERROR | ||
| 139 | TEST_CASE_END | ||
| 140 | TEST_CASE_START | ||
| 141 | ) | ||
| 142 | ], | ||
| 143 | nameserver03 => [ | ||
| 144 | qw( | ||
| 145 | AXFR_FAILURE | ||
| 146 | AXFR_AVAILABLE | ||
| 147 | TEST_CASE_END | ||
| 148 | TEST_CASE_START | ||
| 149 | ) | ||
| 150 | ], | ||
| 151 | nameserver04 => [ | ||
| 152 | qw( | ||
| 153 | DIFFERENT_SOURCE_IP | ||
| 154 | SAME_SOURCE_IP | ||
| 155 | TEST_CASE_END | ||
| 156 | TEST_CASE_START | ||
| 157 | ) | ||
| 158 | ], | ||
| 159 | nameserver05 => [ | ||
| 160 | qw( | ||
| 161 | AAAA_BAD_RDATA | ||
| 162 | AAAA_QUERY_DROPPED | ||
| 163 | AAAA_UNEXPECTED_RCODE | ||
| 164 | AAAA_WELL_PROCESSED | ||
| 165 | A_UNEXPECTED_RCODE | ||
| 166 | NO_RESPONSE | ||
| 167 | IPV4_DISABLED | ||
| 168 | IPV6_DISABLED | ||
| 169 | TEST_CASE_END | ||
| 170 | TEST_CASE_START | ||
| 171 | ) | ||
| 172 | ], | ||
| 173 | nameserver06 => [ | ||
| 174 | qw( | ||
| 175 | CAN_NOT_BE_RESOLVED | ||
| 176 | CAN_BE_RESOLVED | ||
| 177 | NO_RESOLUTION | ||
| 178 | TEST_CASE_END | ||
| 179 | TEST_CASE_START | ||
| 180 | ) | ||
| 181 | ], | ||
| 182 | nameserver07 => [ | ||
| 183 | qw( | ||
| 184 | UPWARD_REFERRAL_IRRELEVANT | ||
| 185 | UPWARD_REFERRAL | ||
| 186 | NO_UPWARD_REFERRAL | ||
| 187 | TEST_CASE_END | ||
| 188 | TEST_CASE_START | ||
| 189 | ) | ||
| 190 | ], | ||
| 191 | nameserver08 => [ | ||
| 192 | qw( | ||
| 193 | QNAME_CASE_INSENSITIVE | ||
| 194 | QNAME_CASE_SENSITIVE | ||
| 195 | TEST_CASE_END | ||
| 196 | TEST_CASE_START | ||
| 197 | ) | ||
| 198 | ], | ||
| 199 | nameserver09 => [ | ||
| 200 | qw( | ||
| 201 | CASE_QUERY_SAME_ANSWER | ||
| 202 | CASE_QUERY_DIFFERENT_ANSWER | ||
| 203 | CASE_QUERY_SAME_RC | ||
| 204 | CASE_QUERY_DIFFERENT_RC | ||
| 205 | CASE_QUERY_NO_ANSWER | ||
| 206 | CASE_QUERIES_RESULTS_OK | ||
| 207 | CASE_QUERIES_RESULTS_DIFFER | ||
| 208 | TEST_CASE_END | ||
| 209 | TEST_CASE_START | ||
| 210 | ) | ||
| 211 | ], | ||
| 212 | nameserver10 => [ | ||
| 213 | qw( | ||
| 214 | N10_NO_RESPONSE_EDNS1_QUERY | ||
| 215 | N10_UNEXPECTED_RCODE | ||
| 216 | N10_EDNS_RESPONSE_ERROR | ||
| 217 | TEST_CASE_END | ||
| 218 | TEST_CASE_START | ||
| 219 | ) | ||
| 220 | ], | ||
| 221 | nameserver11 => [ | ||
| 222 | qw( | ||
| 223 | N11_NO_EDNS | ||
| 224 | N11_NO_RESPONSE | ||
| 225 | N11_RETURNS_UNKNOWN_OPTION_CODE | ||
| 226 | N11_UNEXPECTED_ANSWER_SECTION | ||
| 227 | N11_UNEXPECTED_RCODE | ||
| 228 | N11_UNSET_AA | ||
| 229 | TEST_CASE_END | ||
| 230 | TEST_CASE_START | ||
| 231 | ) | ||
| 232 | ], | ||
| 233 | nameserver12 => [ | ||
| 234 | qw( | ||
| 235 | NO_RESPONSE | ||
| 236 | NO_EDNS_SUPPORT | ||
| 237 | Z_FLAGS_NOTCLEAR | ||
| 238 | NS_ERROR | ||
| 239 | TEST_CASE_END | ||
| 240 | TEST_CASE_START | ||
| 241 | ) | ||
| 242 | ], | ||
| 243 | nameserver13 => [ | ||
| 244 | qw( | ||
| 245 | NO_RESPONSE | ||
| 246 | NO_EDNS_SUPPORT | ||
| 247 | NS_ERROR | ||
| 248 | MISSING_OPT_IN_TRUNCATED | ||
| 249 | TEST_CASE_END | ||
| 250 | TEST_CASE_START | ||
| 251 | ) | ||
| 252 | ], | ||
| 253 | nameserver15 => [ | ||
| 254 | qw( | ||
| 255 | N15_ERROR_ON_VERSION_QUERY | ||
| 256 | N15_NO_VERSION_REVEALED | ||
| 257 | N15_SOFTWARE_VERSION | ||
| 258 | N15_WRONG_CLASS | ||
| 259 | ) | ||
| 260 | ], | ||
| 261 | }; | ||
| 262 | } ## end sub metadata | ||
| 263 | |||
| 264 | Readonly my %TAG_DESCRIPTIONS => ( | ||
| 265 | NAMESERVER01 => sub { | ||
| 266 | __x # NAMESERVER:NAMESERVER01 | ||
| 267 | 'A name server should not be a recursor'; | ||
| 268 | }, | ||
| 269 | NAMESERVER02 => sub { | ||
| 270 | __x # NAMESERVER:NAMESERVER02 | ||
| 271 | 'Test of EDNS0 support'; | ||
| 272 | }, | ||
| 273 | NAMESERVER03 => sub { | ||
| 274 | __x # NAMESERVER:NAMESERVER03 | ||
| 275 | 'Test availability of zone transfer (AXFR)'; | ||
| 276 | }, | ||
| 277 | NAMESERVER04 => sub { | ||
| 278 | __x # NAMESERVER:NAMESERVER04 | ||
| 279 | 'Same source address'; | ||
| 280 | }, | ||
| 281 | NAMESERVER05 => sub { | ||
| 282 | __x # NAMESERVER:NAMESERVER05 | ||
| 283 | 'Behaviour against AAAA query'; | ||
| 284 | }, | ||
| 285 | NAMESERVER06 => sub { | ||
| 286 | __x # NAMESERVER:NAMESERVER06 | ||
| 287 | 'NS can be resolved'; | ||
| 288 | }, | ||
| 289 | NAMESERVER07 => sub { | ||
| 290 | __x # NAMESERVER:NAMESERVER07 | ||
| 291 | 'To check whether authoritative name servers return an upward referral'; | ||
| 292 | }, | ||
| 293 | NAMESERVER08 => sub { | ||
| 294 | __x # NAMESERVER:NAMESERVER08 | ||
| 295 | 'Testing QNAME case insensitivity'; | ||
| 296 | }, | ||
| 297 | NAMESERVER09 => sub { | ||
| 298 | __x # NAMESERVER:NAMESERVER09 | ||
| 299 | 'Testing QNAME case sensitivity'; | ||
| 300 | }, | ||
| 301 | NAMESERVER10 => sub { | ||
| 302 | __x # NAMESERVER:NAMESERVER10 | ||
| 303 | 'Test for undefined EDNS version'; | ||
| 304 | }, | ||
| 305 | NAMESERVER11 => sub { | ||
| 306 | __x # NAMESERVER:NAMESERVER11 | ||
| 307 | 'Test for unknown EDNS OPTION-CODE'; | ||
| 308 | }, | ||
| 309 | NAMESERVER12 => sub { | ||
| 310 | __x # NAMESERVER:NAMESERVER12 | ||
| 311 | 'Test for unknown EDNS flags'; | ||
| 312 | }, | ||
| 313 | NAMESERVER13 => sub { | ||
| 314 | __x # NAMESERVER:NAMESERVER13 | ||
| 315 | 'Test for truncated response on EDNS query'; | ||
| 316 | }, | ||
| 317 | NAMESERVER15 => sub { | ||
| 318 | __x # NAMESERVER:NAMESERVER15 | ||
| 319 | 'Checking for revealed software version'; | ||
| 320 | }, | ||
| 321 | AAAA_BAD_RDATA => sub { | ||
| 322 | __x # NAMESERVER:AAAA_BAD_RDATA | ||
| 323 | 'Nameserver {ns} answered AAAA query with an unexpected RDATA length ({length} instead of 16).', @_; | ||
| 324 | }, | ||
| 325 | AAAA_QUERY_DROPPED => sub { | ||
| 326 | __x # NAMESERVER:AAAA_QUERY_DROPPED | ||
| 327 | 'Nameserver {ns} dropped AAAA query.', @_; | ||
| 328 | }, | ||
| 329 | AAAA_UNEXPECTED_RCODE => sub { | ||
| 330 | __x # NAMESERVER:AAAA_UNEXPECTED_RCODE | ||
| 331 | 'Nameserver {ns} answered AAAA query with an unexpected rcode ({rcode}).', @_; | ||
| 332 | }, | ||
| 333 | AAAA_WELL_PROCESSED => sub { | ||
| 334 | __x # NAMESERVER:AAAA_WELL_PROCESSED | ||
| 335 | 'The following nameservers answer AAAA queries without problems : {ns_list}.', @_; | ||
| 336 | }, | ||
| 337 | A_UNEXPECTED_RCODE => sub { | ||
| 338 | __x # NAMESERVER:A_UNEXPECTED_RCODE | ||
| 339 | 'Nameserver {ns} answered A query with an unexpected rcode ({rcode}).', @_; | ||
| 340 | }, | ||
| 341 | AXFR_AVAILABLE => sub { | ||
| 342 | __x # NAMESERVER:AXFR_AVAILABLE | ||
| 343 | 'Nameserver {ns} allow zone transfer using AXFR.', @_; | ||
| 344 | }, | ||
| 345 | AXFR_FAILURE => sub { | ||
| 346 | __x # NAMESERVER:AXFR_FAILURE | ||
| 347 | 'AXFR not available on nameserver {ns}.', @_; | ||
| 348 | }, | ||
| 349 | BREAKS_ON_EDNS => sub { | ||
| 350 | __x # NAMESERVER:BREAKS_ON_EDNS | ||
| 351 | 'No response from {ns} when EDNS is used in query asking for {domain}.', @_; | ||
| 352 | }, | ||
| 353 | CAN_BE_RESOLVED => sub { | ||
| 354 | __x # NAMESERVER:CAN_BE_RESOLVED | ||
| 355 | 'All nameservers succeeded to resolve to an IP address.', @_; | ||
| 356 | }, | ||
| 357 | CAN_NOT_BE_RESOLVED => sub { | ||
| 358 | __x # NAMESERVER:CAN_NOT_BE_RESOLVED | ||
| 359 | 'The following nameservers failed to resolve to an IP address : {nsname_list}.', @_; | ||
| 360 | }, | ||
| 361 | CASE_QUERIES_RESULTS_DIFFER => sub { | ||
| 362 | __x # NAMESERVER:CASE_QUERIES_RESULTS_DIFFER | ||
| 363 | 'When asked for {type} records on "{domain}" with different cases, all servers do not reply consistently.', @_; | ||
| 364 | }, | ||
| 365 | CASE_QUERIES_RESULTS_OK => sub { | ||
| 366 | __x # NAMESERVER:CASE_QUERIES_RESULTS_OK | ||
| 367 | 'When asked for {type} records on "{domain}" with different cases, all servers reply consistently.', @_; | ||
| 368 | }, | ||
| 369 | CASE_QUERY_DIFFERENT_ANSWER => sub { | ||
| 370 | __x # NAMESERVER:CASE_QUERY_DIFFERENT_ANSWER | ||
| 371 | 'When asked for {type} records on "{query1}" and "{query2}", ' | ||
| 372 | . 'nameserver {ns} returns different answers.', | ||
| 373 | @_; | ||
| 374 | }, | ||
| 375 | CASE_QUERY_DIFFERENT_RC => sub { | ||
| 376 | __x # NAMESERVER:CASE_QUERY_DIFFERENT_RC | ||
| 377 | 'When asked for {type} records on "{query1}" and "{query2}", ' | ||
| 378 | . 'nameserver {ns} returns different RCODE ("{rcode1}" vs "{rcode2}").', | ||
| 379 | @_; | ||
| 380 | }, | ||
| 381 | CASE_QUERY_NO_ANSWER => sub { | ||
| 382 | __x # NAMESERVER:CASE_QUERY_NO_ANSWER | ||
| 383 | 'When asked for {type} records on "{domain}", nameserver {ns} returns nothing.', @_; | ||
| 384 | }, | ||
| 385 | CASE_QUERY_SAME_ANSWER => sub { | ||
| 386 | __x # NAMESERVER:CASE_QUERY_SAME_ANSWER | ||
| 387 | 'When asked for {type} records on "{query1}" and "{query2}", nameserver {ns} returns same answers.', | ||
| 388 | @_; | ||
| 389 | }, | ||
| 390 | CASE_QUERY_SAME_RC => sub { | ||
| 391 | __x # NAMESERVER:CASE_QUERY_SAME_RC | ||
| 392 | 'When asked for {type} records on "{query1}" and "{query2}", ' | ||
| 393 | . 'nameserver {ns} returns same RCODE "{rcode}".', | ||
| 394 | @_; | ||
| 395 | }, | ||
| 396 | DIFFERENT_SOURCE_IP => sub { | ||
| 397 | __x # NAMESERVER:DIFFERENT_SOURCE_IP | ||
| 398 | 'Nameserver {ns} replies on a SOA query with a different source address ({source}).', @_; | ||
| 399 | }, | ||
| 400 | EDNS_RESPONSE_WITHOUT_EDNS => sub { | ||
| 401 | __x # NAMESERVER:EDNS_RESPONSE_WITHOUT_EDNS | ||
| 402 | 'Response without EDNS from {ns} on query with EDNS0 asking for {domain}.', @_; | ||
| 403 | }, | ||
| 404 | EDNS_VERSION_ERROR => sub { | ||
| 405 | __x # NAMESERVER:EDNS_VERSION_ERROR | ||
| 406 | 'Incorrect version of EDNS (expected 0) in response from {ns} ' | ||
| 407 | . 'on query with EDNS (version 0) asking for {domain}.', | ||
| 408 | @_; | ||
| 409 | }, | ||
| 410 | EDNS0_SUPPORT => sub { | ||
| 411 | __x # NAMESERVER:EDNS0_SUPPORT | ||
| 412 | 'The following nameservers support EDNS0 : {ns_list}.', @_; | ||
| 413 | }, | ||
| 414 | IPV4_DISABLED => sub { | ||
| 415 | __x # NAMESERVER:IPV4_DISABLED | ||
| 416 | 'IPv4 is disabled, not sending "{rrtype}" query to {ns}.', @_; | ||
| 417 | }, | ||
| 418 | IPV6_DISABLED => sub { | ||
| 419 | __x # NAMESERVER:IPV6_DISABLED | ||
| 420 | 'IPv6 is disabled, not sending "{rrtype}" query to {ns}.', @_; | ||
| 421 | }, | ||
| 422 | IS_A_RECURSOR => sub { | ||
| 423 | __x # NAMESERVER:IS_A_RECURSOR | ||
| 424 | 'Nameserver {ns} is a recursor.', @_; | ||
| 425 | }, | ||
| 426 | MISSING_OPT_IN_TRUNCATED => sub { | ||
| 427 | __x # NAMESERVER:MISSING_OPT_IN_TRUNCATED | ||
| 428 | 'Nameserver {ns} replies on an EDNS query with a truncated response without EDNS.', @_; | ||
| 429 | }, | ||
| 430 | NO_EDNS_SUPPORT => sub { | ||
| 431 | __x # NAMESERVER:NO_EDNS_SUPPORT | ||
| 432 | 'Nameserver {ns} does not support EDNS0 (replies with FORMERR).', @_; | ||
| 433 | }, | ||
| 434 | NO_RECURSOR => sub { | ||
| 435 | __x # NAMESERVER:NO_RECURSOR | ||
| 436 | 'Nameserver {ns} is not a recursor.', @_; | ||
| 437 | }, | ||
| 438 | NO_RESOLUTION => sub { | ||
| 439 | __x # NAMESERVER:NO_RESOLUTION | ||
| 440 | "No nameserver was successfully resolved to an IP address.", @_; | ||
| 441 | }, | ||
| 442 | NO_RESPONSE => sub { | ||
| 443 | __x # NAMESERVER:NO_RESPONSE | ||
| 444 | 'No response from {ns} asking for {domain}.', @_; | ||
| 445 | }, | ||
| 446 | NO_UPWARD_REFERRAL => sub { | ||
| 447 | __x # NAMESERVER:NO_UPWARD_REFERRAL | ||
| 448 | 'None of the following nameservers returns an upward referral : {nsname_list}.', @_; | ||
| 449 | }, | ||
| 450 | NS_ERROR => sub { | ||
| 451 | __x # NAMESERVER:NS_ERROR | ||
| 452 | 'Erroneous response from nameserver {ns}.', @_; | ||
| 453 | }, | ||
| 454 | N10_EDNS_RESPONSE_ERROR => sub { | ||
| 455 | __x # NAMESERVER:N10_EDNS_RESPONSE_ERROR | ||
| 456 | 'Expected RCODE but received erroneous response to an EDNS version 1 query. Fetched from the nameservers with IP addresses {ns_ip_list}', @_; | ||
| 457 | }, | ||
| 458 | N10_NO_RESPONSE_EDNS1_QUERY => sub { | ||
| 459 | __x # NAMESERVER:N10_NO_RESPONSE_EDNS1_QUERY | ||
| 460 | 'No response to an EDNS version 1 query. Fetched from the nameservers with IP addresses {ns_ip_list}', @_; | ||
| 461 | }, | ||
| 462 | N10_UNEXPECTED_RCODE => sub { | ||
| 463 | __x # NAMESERVER:N10_UNEXPECTED_RCODE | ||
| 464 | 'Erroneous RCODE ("{rcode}") in response to an EDNS version 1 query. Fetched from the nameservers with IP addresses {ns_ip_list}', @_; | ||
| 465 | }, | ||
| 466 | N11_NO_EDNS => sub { | ||
| 467 | __x # NAMESERVER:N11_NO_EDNS | ||
| 468 | 'The DNS response, on query with unknown EDNS option-code, does not contain any EDNS from name servers "{ns_ip_list}".', @_; | ||
| 469 | }, | ||
| 470 | N11_NO_RESPONSE => sub { | ||
| 471 | __x # NAMESERVER:N11_NO_RESPONSE | ||
| 472 | 'There is no response on query with unknown EDNS option-code from name servers "{ns_ip_list}".', @_; | ||
| 473 | }, | ||
| 474 | N11_RETURNS_UNKNOWN_OPTION_CODE => sub { | ||
| 475 | __x # NAMESERVER:N11_RETURNS_UNKNOWN_OPTION_CODE | ||
| 476 | 'The DNS response contains an unknown EDNS option-code. Returned from name servers "{ns_ip_list}".', @_; | ||
| 477 | }, | ||
| 478 | N11_UNEXPECTED_ANSWER_SECTION => sub { | ||
| 479 | __x # NAMESERVER:N11_UNEXPECTED_ANSWER_SECTION | ||
| 480 | 'The DNS response, on query with unknown EDNS option-code, does not contain the expected SOA record in the answer section from name servers "{ns_ip_list}".', @_; | ||
| 481 | }, | ||
| 482 | N11_UNEXPECTED_RCODE => sub { | ||
| 483 | __x # NAMESERVER:N11_UNEXPECTED_RCODE | ||
| 484 | 'The DNS response, on query with unknown EDNS option-code, has unexpected RCODE name "{rcode}" from name servers "{ns_ip_list}".', @_; | ||
| 485 | }, | ||
| 486 | N11_UNSET_AA => sub { | ||
| 487 | __x # NAMESERVER:N11_UNSET_AA | ||
| 488 | 'The DNS response, on query with unknown EDNS option-code, is unexpectedly not authoritative from name servers "{ns_ip_list}".', @_; | ||
| 489 | }, | ||
| 490 | N15_ERROR_ON_VERSION_QUERY => sub { | ||
| 491 | __x # NAMESERVER:N15_ERROR_ON_VERSION_QUERY | ||
| 492 | 'The following name server(s) do not respond or respond with SERVFAIL to software version query "{query_name}". Returned from name servers: "{ns_list}"', @_; | ||
| 493 | }, | ||
| 494 | N15_NO_VERSION_REVEALED => sub { | ||
| 495 | __x # NAMESERVER:N15_NO_VERSION_REVEALED | ||
| 496 | 'The following name server(s) do not reveal the software version. Returned from name servers: "{ns_list}"', @_; | ||
| 497 | }, | ||
| 498 | N15_SOFTWARE_VERSION => sub { | ||
| 499 | __x # NAMESERVER:N15_SOFTWARE_VERSION | ||
| 500 | 'The following name server(s) respond to software version query "{query_name}" with string "{string}". Returned from name servers: "{ns_list}"', @_; | ||
| 501 | }, | ||
| 502 | N15_WRONG_CLASS => sub { | ||
| 503 | __x # NAMESERVER:N15_WRONG_CLASS | ||
| 504 | 'The following name server(s) do not return CH class record(s) on CH class query. Returned from name servers: "{ns_list}"', @_; | ||
| 505 | }, | ||
| 506 | QNAME_CASE_INSENSITIVE => sub { | ||
| 507 | __x # NAMESERVER:QNAME_CASE_INSENSITIVE | ||
| 508 | 'Nameserver {ns} does not preserve original case of the queried name ({domain}).', @_; | ||
| 509 | }, | ||
| 510 | QNAME_CASE_SENSITIVE => sub { | ||
| 511 | __x # NAMESERVER:QNAME_CASE_SENSITIVE | ||
| 512 | "Nameserver {ns} preserves original case of queried names ({domain}).", @_; | ||
| 513 | }, | ||
| 514 | SAME_SOURCE_IP => sub { | ||
| 515 | __x # NAMESERVER:SAME_SOURCE_IP | ||
| 516 | 'All nameservers reply with same IP used to query them.', @_; | ||
| 517 | }, | ||
| 518 | TEST_CASE_END => sub { | ||
| 519 | __x # NAMESERVER:TEST_CASE_END | ||
| 520 | 'TEST_CASE_END {testcase}.', @_; | ||
| 521 | }, | ||
| 522 | TEST_CASE_START => sub { | ||
| 523 | __x # NAMESERVER:TEST_CASE_START | ||
| 524 | 'TEST_CASE_START {testcase}.', @_; | ||
| 525 | }, | ||
| 526 | UPWARD_REFERRAL => sub { | ||
| 527 | __x # NAMESERVER:UPWARD_REFERRAL | ||
| 528 | 'Nameserver {ns} returns an upward referral.', @_; | ||
| 529 | }, | ||
| 530 | UPWARD_REFERRAL_IRRELEVANT => sub { | ||
| 531 | __x # NAMESERVER:UPWARD_REFERRAL_IRRELEVANT | ||
| 532 | 'Upward referral tests skipped for root zone.', @_; | ||
| 533 | }, | ||
| 534 | Z_FLAGS_NOTCLEAR => sub { | ||
| 535 | __x # NAMESERVER:Z_FLAGS_NOTCLEAR | ||
| 536 | 'Nameserver {ns} has one or more unknown EDNS Z flag bits set.', @_; | ||
| 537 | }, | ||
| 538 | ); | ||
| 539 | |||
| 540 | =over | ||
| 541 | |||
| 542 | =item tag_descriptions() | ||
| 543 | |||
| 544 | my $hash_ref = tag_descriptions(); | ||
| 545 | |||
| 546 | Used by the L<built-in translation system|Zonemaster::Engine::Translator>. | ||
| 547 | |||
| 548 | Returns a reference to a hash, the keys of which are the message tags and the corresponding values are strings (message IDs). | ||
| 549 | |||
| 550 | =back | ||
| 551 | |||
| 552 | =cut | ||
| 553 | |||
| 554 | sub tag_descriptions { | ||
| 555 | return \%TAG_DESCRIPTIONS; | ||
| 556 | } | ||
| 557 | |||
| 558 | =over | ||
| 559 | |||
| 560 | =item version() | ||
| 561 | |||
| 562 | my $version_string = version(); | ||
| 563 | |||
| 564 | Returns a string containing the version of the current module. | ||
| 565 | |||
| 566 | =back | ||
| 567 | |||
| 568 | =cut | ||
| 569 | |||
| 570 | sub version { | ||
| 571 | return "$Zonemaster::Engine::Test::Nameserver::VERSION"; | ||
| 572 | } | ||
| 573 | |||
| 574 | =head1 INTERNAL METHODS | ||
| 575 | |||
| 576 | =over | ||
| 577 | |||
| 578 | =item _emit_log() | ||
| 579 | |||
| 580 | my $log_entry = _emit_log( $message_tag_string, $hash_ref ); | ||
| 581 | |||
| 582 | Adds a message to the L<logger|Zonemaster::Engine::Logger> for this module. | ||
| 583 | See L<Zonemaster::Engine::Logger::Entry/add($tag, $argref, $module, $testcase)> for more details. | ||
| 584 | |||
| 585 | Takes a string (message tag) and a reference to a hash (arguments). | ||
| 586 | |||
| 587 | Returns a L<Zonemaster::Engine::Logger::Entry> object. | ||
| 588 | |||
| 589 | =back | ||
| 590 | |||
| 591 | =cut | ||
| 592 | |||
| 593 | sub _emit_log { my ( $tag, $argref ) = @_; return Zonemaster::Engine->logger->add( $tag, $argref, 'Nameserver' ); } | ||
| 594 | |||
| 595 | =over | ||
| 596 | |||
| 597 | =item _ip_disabled_message() | ||
| 598 | |||
| 599 | my $bool = _ip_disabled_message( $logentry_array_ref, $ns, @query_type_array ); | ||
| 600 | |||
| 601 | 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. | ||
| 602 | |||
| 603 | 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). | ||
| 604 | |||
| 605 | Returns a boolean. | ||
| 606 | |||
| 607 | =back | ||
| 608 | |||
| 609 | =cut | ||
| 610 | |||
| 611 | sub _ip_disabled_message { | ||
| 612 | my ( $results_array, $ns, @rrtypes ) = @_; | ||
| 613 | |||
| 614 | if ( not Zonemaster::Engine::Profile->effective->get(q{net.ipv6}) and $ns->address->version == $IP_VERSION_6 ) { | ||
| 615 | push @$results_array, map { | ||
| 616 | _emit_log( | ||
| 617 | IPV6_DISABLED => { | ||
| 618 | ns => $ns->string, | ||
| 619 | rrtype => $_ | ||
| 620 | } | ||
| 621 | ) | ||
| 622 | } @rrtypes; | ||
| 623 | return 1; | ||
| 624 | } | ||
| 625 | |||
| 626 | if ( not Zonemaster::Engine::Profile->effective->get(q{net.ipv4}) and $ns->address->version == $IP_VERSION_4 ) { | ||
| 627 | push @$results_array, map { | ||
| 628 | _emit_log( | ||
| 629 | IPV4_DISABLED => { | ||
| 630 | ns => $ns->string, | ||
| 631 | rrtype => $_, | ||
| 632 | } | ||
| 633 | ) | ||
| 634 | } @rrtypes; | ||
| 635 | return 1; | ||
| 636 | } | ||
| 637 | return 0; | ||
| 638 | } | ||
| 639 | |||
| 640 | =head1 TESTS | ||
| 641 | |||
| 642 | =over | ||
| 643 | |||
| 644 | =item nameserver01() | ||
| 645 | |||
| 646 | my @logentry_array = nameserver01( $zone ); | ||
| 647 | |||
| 648 | Runs the L<Nameserver01 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Nameserver-TP/nameserver01.md>. | ||
| 649 | |||
| 650 | Takes a L<Zonemaster::Engine::Zone> object. | ||
| 651 | |||
| 652 | Returns a list of L<Zonemaster::Engine::Logger::Entry> objects. | ||
| 653 | |||
| 654 | =back | ||
| 655 | |||
| 656 | =cut | ||
| 657 | |||
| 658 | sub nameserver01 { | ||
| 659 | my ( $class, $zone ) = @_; | ||
| 660 | |||
| 661 | local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Nameserver01'; | ||
| 662 | push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ); | ||
| 663 | |||
| 664 | my @nss = @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) }; | ||
| 665 | |||
| 666 | for my $ns ( @nss ) { | ||
| 667 | |||
| 668 | next if ( _ip_disabled_message( \@results, $ns, q{A} ) ); | ||
| 669 | |||
| 670 | my $response_count = 0; | ||
| 671 | my $nxdomain_count = 0; | ||
| 672 | my $is_no_recursor = 1; | ||
| 673 | my $has_seen_ra = 0; | ||
| 674 | for my $nonexistent_name ( @NONEXISTENT_NAMES ) { | ||
| 675 | |||
| 676 | my $p = $ns->query( $nonexistent_name, q{A} ); | ||
| 677 | if ( !$p ) { | ||
| 678 | push @results, | ||
| 679 | _emit_log( | ||
| 680 | NO_RESPONSE => { | ||
| 681 | ns => $ns->string, | ||
| 682 | domain => $nonexistent_name, | ||
| 683 | } | ||
| 684 | ); | ||
| 685 | $is_no_recursor = 0; | ||
| 686 | } | ||
| 687 | else { | ||
| 688 | $response_count++; | ||
| 689 | |||
| 690 | if ( $p->ra ) { | ||
| 691 | $has_seen_ra = 1; | ||
| 692 | } | ||
| 693 | |||
| 694 | if ( $p->rcode eq q{NXDOMAIN} ) { | ||
| 695 | $nxdomain_count++; | ||
| 696 | } | ||
| 697 | } | ||
| 698 | } ## end for my $nonexistent_name... | ||
| 699 | |||
| 700 | if ( $has_seen_ra || ( $response_count > 0 && $nxdomain_count == $response_count ) ) { | ||
| 701 | push @results, _emit_log( IS_A_RECURSOR => { ns => $ns->string } ); | ||
| 702 | $is_no_recursor = 0; | ||
| 703 | } | ||
| 704 | |||
| 705 | if ( $is_no_recursor ) { | ||
| 706 | push @results, _emit_log( NO_RECURSOR => { ns => $ns->string } ); | ||
| 707 | } | ||
| 708 | } ## end for my $ns ( @nss ) | ||
| 709 | |||
| 710 | return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) ); | ||
| 711 | } ## end sub nameserver01 | ||
| 712 | |||
| 713 | =over | ||
| 714 | |||
| 715 | =item nameserver02() | ||
| 716 | |||
| 717 | my @logentry_array = nameserver02( $zone ); | ||
| 718 | |||
| 719 | Runs the L<Nameserver02 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Nameserver-TP/nameserver02.md>. | ||
| 720 | |||
| 721 | Takes a L<Zonemaster::Engine::Zone> object. | ||
| 722 | |||
| 723 | Returns a list of L<Zonemaster::Engine::Logger::Entry> objects. | ||
| 724 | |||
| 725 | =back | ||
| 726 | |||
| 727 | =cut | ||
| 728 | |||
| 729 | sub nameserver02 { | ||
| 730 | my ( $class, $zone ) = @_; | ||
| 731 | |||
| 732 | local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Nameserver02'; | ||
| 733 | push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ); | ||
| 734 | my %nsnames_and_ip; | ||
| 735 | my $n_error = 0; | ||
| 736 | |||
| 737 | my @nss = @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) }; | ||
| 738 | |||
| 739 | foreach my $local_ns ( @nss ) { | ||
| 740 | next if ( _ip_disabled_message( \@results, $local_ns, q{SOA} ) ); | ||
| 741 | |||
| 742 | next if $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short }; | ||
| 743 | |||
| 744 | my $p = $local_ns->query( $zone->name, q{SOA}, { edns_details => { version => 0 } } ); | ||
| 745 | if ( $p ) { | ||
| 746 | if ( $p->rcode eq q{FORMERR} and not $p->has_edns) { | ||
| 747 | push @results, _emit_log( NO_EDNS_SUPPORT => { ns => $local_ns->string } ); | ||
| 748 | $n_error++; | ||
| 749 | } | ||
| 750 | elsif ( $p->rcode eq q{NOERROR} and not $p->edns_rcode and $p->get_records( q{SOA}, q{answer} ) and $p->edns_version == 0 ) { | ||
| 751 | $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short }++; | ||
| 752 | next; | ||
| 753 | } | ||
| 754 | elsif ( $p->rcode eq q{NOERROR} and not $p->has_edns ) { | ||
| 755 | push @results, | ||
| 756 | _emit_log( | ||
| 757 | EDNS_RESPONSE_WITHOUT_EDNS => { | ||
| 758 | ns => $local_ns->string, | ||
| 759 | domain => $zone->name, | ||
| 760 | } | ||
| 761 | ); | ||
| 762 | $n_error++; | ||
| 763 | } | ||
| 764 | elsif ( $p->rcode eq q{NOERROR} and $p->has_edns and $p->edns_version != 0 ) { | ||
| 765 | push @results, | ||
| 766 | _emit_log( | ||
| 767 | EDNS_VERSION_ERROR => { | ||
| 768 | ns => $local_ns->string, | ||
| 769 | domain => $zone->name, | ||
| 770 | } | ||
| 771 | ); | ||
| 772 | $n_error++; | ||
| 773 | } | ||
| 774 | else { | ||
| 775 | push @results, _emit_log( NS_ERROR => { ns => $local_ns->string } ); | ||
| 776 | $n_error++; | ||
| 777 | } | ||
| 778 | } | ||
| 779 | else { | ||
| 780 | my $p2 = $local_ns->query( $zone->name, q{SOA} ); | ||
| 781 | if ( $p2 ) { | ||
| 782 | push @results, | ||
| 783 | _emit_log( | ||
| 784 | BREAKS_ON_EDNS => { | ||
| 785 | ns => $local_ns->string, | ||
| 786 | domain => $zone->name, | ||
| 787 | } | ||
| 788 | ); | ||
| 789 | $n_error++; | ||
| 790 | } | ||
| 791 | else { | ||
| 792 | push @results, | ||
| 793 | _emit_log( | ||
| 794 | NO_RESPONSE => { | ||
| 795 | ns => $local_ns->string, | ||
| 796 | domain => $zone->name, | ||
| 797 | } | ||
| 798 | ); | ||
| 799 | $n_error++; | ||
| 800 | } | ||
| 801 | } | ||
| 802 | |||
| 803 | $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short }++; | ||
| 804 | } ## end foreach my $local_ns ( @{ Zonemaster::Engine::TestMethods...}) | ||
| 805 | |||
| 806 | if ( scalar keys %nsnames_and_ip and not $n_error ) { | ||
| 807 | push @results, | ||
| 808 | _emit_log( | ||
| 809 | EDNS0_SUPPORT => { | ||
| 810 | ns_list => join( q{;}, keys %nsnames_and_ip ), | ||
| 811 | } | ||
| 812 | ); | ||
| 813 | } | ||
| 814 | |||
| 815 | return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) ); | ||
| 816 | } ## end sub nameserver02 | ||
| 817 | |||
| 818 | =over | ||
| 819 | |||
| 820 | =item nameserver03() | ||
| 821 | |||
| 822 | my @logentry_array = nameserver03( $zone ); | ||
| 823 | |||
| 824 | Runs the L<Nameserver03 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Nameserver-TP/nameserver03.md>. | ||
| 825 | |||
| 826 | Takes a L<Zonemaster::Engine::Zone> object. | ||
| 827 | |||
| 828 | Returns a list of L<Zonemaster::Engine::Logger::Entry> objects. | ||
| 829 | |||
| 830 | =back | ||
| 831 | |||
| 832 | =cut | ||
| 833 | |||
| 834 | sub nameserver03 { | ||
| 835 | my ( $class, $zone ) = @_; | ||
| 836 | |||
| 837 | local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Nameserver03'; | ||
| 838 | push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ); | ||
| 839 | my %nsnames_and_ip; | ||
| 840 | |||
| 841 | my @nss = @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) }; | ||
| 842 | |||
| 843 | foreach my $local_ns ( @nss ) { | ||
| 844 | |||
| 845 | next if ( _ip_disabled_message( \@results, $local_ns, q{AXFR} ) ); | ||
| 846 | |||
| 847 | next if $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short }; | ||
| 848 | |||
| 849 | my $first_rr; | ||
| 850 | eval { | ||
| 851 | $local_ns->axfr( $zone->name, sub { ( $first_rr ) = @_; return 0; } ); | ||
| 852 | 1; | ||
| 853 | } or do { | ||
| 854 | push @results, _emit_log( AXFR_FAILURE => { ns => $local_ns->string } ); | ||
| 855 | }; | ||
| 856 | |||
| 857 | if ( $first_rr and $first_rr->type eq q{SOA} ) { | ||
| 858 | push @results, _emit_log( AXFR_AVAILABLE => { ns => $local_ns->string } ); | ||
| 859 | } | ||
| 860 | |||
| 861 | $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short }++; | ||
| 862 | } ## end foreach my $local_ns ( @{ Zonemaster::Engine::TestMethods...}) | ||
| 863 | |||
| 864 | return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) ); | ||
| 865 | } ## end sub nameserver03 | ||
| 866 | |||
| 867 | =over | ||
| 868 | |||
| 869 | =item nameserver04() | ||
| 870 | |||
| 871 | my @logentry_array = nameserver04( $zone ); | ||
| 872 | |||
| 873 | Runs the L<Nameserver04 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Nameserver-TP/nameserver04.md>. | ||
| 874 | |||
| 875 | Takes a L<Zonemaster::Engine::Zone> object. | ||
| 876 | |||
| 877 | Returns a list of L<Zonemaster::Engine::Logger::Entry> objects. | ||
| 878 | |||
| 879 | =back | ||
| 880 | |||
| 881 | =cut | ||
| 882 | |||
| 883 | sub nameserver04 { | ||
| 884 | my ( $class, $zone ) = @_; | ||
| 885 | |||
| 886 | local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Nameserver04'; | ||
| 887 | push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ); | ||
| 888 | my %nsnames_and_ip; | ||
| 889 | my $n_error = 0; | ||
| 890 | |||
| 891 | my @nss = @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) }; | ||
| 892 | |||
| 893 | foreach my $local_ns ( @nss ) { | ||
| 894 | |||
| 895 | next if ( _ip_disabled_message( \@results, $local_ns, q{SOA} ) ); | ||
| 896 | |||
| 897 | next if $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short }; | ||
| 898 | |||
| 899 | my $p = $local_ns->query( $zone->name, q{SOA} ); | ||
| 900 | if ( $p ) { | ||
| 901 | if ( $p->answerfrom and ( $local_ns->address->short ne Net::IP::XS->new( $p->answerfrom )->short ) ) { | ||
| 902 | push @results, | ||
| 903 | _emit_log( | ||
| 904 | DIFFERENT_SOURCE_IP => { | ||
| 905 | ns => $local_ns->string, | ||
| 906 | source => $p->answerfrom, | ||
| 907 | } | ||
| 908 | ); | ||
| 909 | $n_error++; | ||
| 910 | } | ||
| 911 | } | ||
| 912 | $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short }++; | ||
| 913 | } ## end foreach my $local_ns ( @{ Zonemaster::Engine::TestMethods...}) | ||
| 914 | |||
| 915 | if ( scalar keys %nsnames_and_ip and not $n_error) { | ||
| 916 | push @results, | ||
| 917 | _emit_log( | ||
| 918 | SAME_SOURCE_IP => { | ||
| 919 | names => join( q{,}, keys %nsnames_and_ip ), | ||
| 920 | } | ||
| 921 | ); | ||
| 922 | } | ||
| 923 | |||
| 924 | return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) ); | ||
| 925 | } ## end sub nameserver04 | ||
| 926 | |||
| 927 | =over | ||
| 928 | |||
| 929 | =item nameserver05() | ||
| 930 | |||
| 931 | my @logentry_array = nameserver05( $zone ); | ||
| 932 | |||
| 933 | Runs the L<Nameserver05 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Nameserver-TP/nameserver05.md>. | ||
| 934 | |||
| 935 | Takes a L<Zonemaster::Engine::Zone> object. | ||
| 936 | |||
| 937 | Returns a list of L<Zonemaster::Engine::Logger::Entry> objects. | ||
| 938 | |||
| 939 | =back | ||
| 940 | |||
| 941 | =cut | ||
| 942 | |||
| 943 | sub nameserver05 { | ||
| 944 | my ( $class, $zone ) = @_; | ||
| 945 | |||
| 946 | local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Nameserver05'; | ||
| 947 | push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ); | ||
| 948 | my %nsnames_and_ip; | ||
| 949 | my $aaaa_issue = 0; | ||
| 950 | my @aaaa_ok; | ||
| 951 | |||
| 952 | my @nss = @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) }; | ||
| 953 | |||
| 954 | foreach my $ns ( @nss ) { | ||
| 955 | |||
| 956 | next if ( _ip_disabled_message( \@results, $ns, q{A} ) ); | ||
| 957 | |||
| 958 | next if $nsnames_and_ip{ $ns->name->string . q{/} . $ns->address->short }; | ||
| 959 | |||
| 960 | $nsnames_and_ip{ $ns->name->string . q{/} . $ns->address->short }++; | ||
| 961 | |||
| 962 | my $p = $ns->query( $zone->name, q{A}, { usevc => 0 } ); | ||
| 963 | |||
| 964 | if ( not $p ) { | ||
| 965 | push @results, | ||
| 966 | _emit_log( | ||
| 967 | NO_RESPONSE => { | ||
| 968 | ns => $ns->string, | ||
| 969 | domain => $zone->name, | ||
| 970 | } | ||
| 971 | ); | ||
| 972 | } | ||
| 973 | elsif ( $p->rcode ne q{NOERROR} ) { | ||
| 974 | push @results, | ||
| 975 | _emit_log( | ||
| 976 | A_UNEXPECTED_RCODE => { | ||
| 977 | ns => $ns->string, | ||
| 978 | rcode => $p->rcode, | ||
| 979 | } | ||
| 980 | ); | ||
| 981 | } | ||
| 982 | else { | ||
| 983 | $p = $ns->query( $zone->name, q{AAAA}, { usevc => 0 } ); | ||
| 984 | |||
| 985 | if ( not $p ) { | ||
| 986 | push @results, | ||
| 987 | _emit_log( AAAA_QUERY_DROPPED => { ns => $ns->string } ); | ||
| 988 | $aaaa_issue++; | ||
| 989 | } | ||
| 990 | elsif ( $p->rcode ne q{NOERROR} ) { | ||
| 991 | push @results, | ||
| 992 | _emit_log( | ||
| 993 | AAAA_UNEXPECTED_RCODE => { | ||
| 994 | ns => $ns->string, | ||
| 995 | rcode => $p->rcode, | ||
| 996 | } | ||
| 997 | ); | ||
| 998 | $aaaa_issue++; | ||
| 999 | } | ||
| 1000 | else { | ||
| 1001 | foreach my $rr ( $p->get_records( q{AAAA}, q{answer} ) ) { | ||
| 1002 | if ( length($rr->rdf(0)) != 16 ) { | ||
| 1003 | push @results, | ||
| 1004 | _emit_log( | ||
| 1005 | AAAA_BAD_RDATA => { | ||
| 1006 | ns => $ns->string, | ||
| 1007 | length => length( $rr->rdf( 0 ) ), | ||
| 1008 | } | ||
| 1009 | ); | ||
| 1010 | $aaaa_issue++; | ||
| 1011 | } | ||
| 1012 | else { | ||
| 1013 | push @aaaa_ok, $rr->address; | ||
| 1014 | } | ||
| 1015 | } | ||
| 1016 | } | ||
| 1017 | } | ||
| 1018 | } | ||
| 1019 | |||
| 1020 | if ( scalar @aaaa_ok and not $aaaa_issue ) { | ||
| 1021 | push @results, | ||
| 1022 | _emit_log( | ||
| 1023 | AAAA_WELL_PROCESSED => { | ||
| 1024 | ns_list => join( q{;}, keys %nsnames_and_ip ), | ||
| 1025 | } | ||
| 1026 | ); | ||
| 1027 | } | ||
| 1028 | |||
| 1029 | return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) ); | ||
| 1030 | } ## end sub nameserver05 | ||
| 1031 | |||
| 1032 | =over | ||
| 1033 | |||
| 1034 | =item nameserver06() | ||
| 1035 | |||
| 1036 | my @logentry_array = nameserver06( $zone ); | ||
| 1037 | |||
| 1038 | Runs the L<Nameserver06 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Nameserver-TP/nameserver06.md>. | ||
| 1039 | |||
| 1040 | Takes a L<Zonemaster::Engine::Zone> object. | ||
| 1041 | |||
| 1042 | Returns a list of L<Zonemaster::Engine::Logger::Entry> objects. | ||
| 1043 | |||
| 1044 | =back | ||
| 1045 | |||
| 1046 | =cut | ||
| 1047 | |||
| 1048 | sub nameserver06 { | ||
| 1049 | my ( $class, $zone ) = @_; | ||
| 1050 | |||
| 1051 | local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Nameserver06'; | ||
| 1052 | push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ); | ||
| 1053 | my @all_nsnames = uniq map { lc( $_->string ) } @{ Zonemaster::Engine::TestMethods->method2( $zone ) }, | ||
| 1054 | @{ Zonemaster::Engine::TestMethods->method3( $zone ) }; | ||
| 1055 | my @all_nsnames_with_ip = uniq map { lc( $_->name->string ) } @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) }; | ||
| 1056 | my @all_nsnames_without_ip; | ||
| 1057 | my %diff; | ||
| 1058 | |||
| 1059 | @diff{@all_nsnames} = undef; | ||
| 1060 | delete @diff{@all_nsnames_with_ip}; | ||
| 1061 | |||
| 1062 | @all_nsnames_without_ip = keys %diff; | ||
| 1063 | if ( scalar @all_nsnames_without_ip and scalar @all_nsnames_with_ip ) { | ||
| 1064 | push @results, | ||
| 1065 | _emit_log( | ||
| 1066 | CAN_NOT_BE_RESOLVED => { | ||
| 1067 | nsname_list => join( q{;}, @all_nsnames_without_ip ), | ||
| 1068 | } | ||
| 1069 | ); | ||
| 1070 | } | ||
| 1071 | elsif ( not scalar @all_nsnames_with_ip ) { | ||
| 1072 | push @results, | ||
| 1073 | _emit_log( | ||
| 1074 | NO_RESOLUTION => { | ||
| 1075 | names => join( q{,}, @all_nsnames_without_ip ), | ||
| 1076 | } | ||
| 1077 | ); | ||
| 1078 | } | ||
| 1079 | else { | ||
| 1080 | push @results, _emit_log( CAN_BE_RESOLVED => {} ); | ||
| 1081 | } | ||
| 1082 | |||
| 1083 | return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) ); | ||
| 1084 | } ## end sub nameserver06 | ||
| 1085 | |||
| 1086 | =over | ||
| 1087 | |||
| 1088 | =item nameserver07() | ||
| 1089 | |||
| 1090 | my @logentry_array = nameserver07( $zone ); | ||
| 1091 | |||
| 1092 | Runs the L<Nameserver07 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Nameserver-TP/nameserver07.md>. | ||
| 1093 | |||
| 1094 | Takes a L<Zonemaster::Engine::Zone> object. | ||
| 1095 | |||
| 1096 | Returns a list of L<Zonemaster::Engine::Logger::Entry> objects. | ||
| 1097 | |||
| 1098 | =back | ||
| 1099 | |||
| 1100 | =cut | ||
| 1101 | |||
| 1102 | sub nameserver07 { | ||
| 1103 | my ( $class, $zone ) = @_; | ||
| 1104 | |||
| 1105 | local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Nameserver07'; | ||
| 1106 | push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ); | ||
| 1107 | my %nsnames_and_ip; | ||
| 1108 | my %nsnames; | ||
| 1109 | my $n_error = 0; | ||
| 1110 | |||
| 1111 | if ( $zone->name eq q{.} ) { | ||
| 1112 | push @results, _emit_log( UPWARD_REFERRAL_IRRELEVANT => {} ); | ||
| 1113 | } | ||
| 1114 | else { | ||
| 1115 | my @nss = @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) }; | ||
| 1116 | foreach my $local_ns ( @nss ) { | ||
| 1117 | next if ( _ip_disabled_message( \@results, $local_ns, q{NS} ) ); | ||
| 1118 | |||
| 1119 | next if $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short }; | ||
| 1120 | |||
| 1121 | my $p = $local_ns->query( q{.}, q{NS} ); | ||
| 1122 | if ( $p ) { | ||
| 1123 | my @ns = $p->get_records( q{NS}, q{authority} ); | ||
| 1124 | |||
| 1125 | if ( @ns ) { | ||
| 1126 | push @results, _emit_log( UPWARD_REFERRAL => { ns => $local_ns->string } ); | ||
| 1127 | $n_error++; | ||
| 1128 | } | ||
| 1129 | } | ||
| 1130 | $nsnames{ $local_ns->name }++; | ||
| 1131 | $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short }++; | ||
| 1132 | } ## end foreach my $local_ns ( @{ Zonemaster::Engine::TestMethods...}) | ||
| 1133 | |||
| 1134 | if ( scalar keys %nsnames_and_ip and not $n_error ) { | ||
| 1135 | push @results, | ||
| 1136 | _emit_log( | ||
| 1137 | NO_UPWARD_REFERRAL => { | ||
| 1138 | nsname_list => join( q{;}, sort keys %nsnames ), | ||
| 1139 | } | ||
| 1140 | ); | ||
| 1141 | } | ||
| 1142 | } ## end else [ if ( $zone->name eq q{.})] | ||
| 1143 | |||
| 1144 | return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) ); | ||
| 1145 | } ## end sub nameserver07 | ||
| 1146 | |||
| 1147 | =over | ||
| 1148 | |||
| 1149 | =item nameserver08() | ||
| 1150 | |||
| 1151 | my @logentry_array = nameserver08( $zone ); | ||
| 1152 | |||
| 1153 | Runs the L<Nameserver08 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Nameserver-TP/nameserver08.md>. | ||
| 1154 | |||
| 1155 | Takes a L<Zonemaster::Engine::Zone> object. | ||
| 1156 | |||
| 1157 | Returns a list of L<Zonemaster::Engine::Logger::Entry> objects. | ||
| 1158 | |||
| 1159 | =back | ||
| 1160 | |||
| 1161 | =cut | ||
| 1162 | |||
| 1163 | sub nameserver08 { | ||
| 1164 | my ( $class, $zone ) = @_; | ||
| 1165 | |||
| 1166 | local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Nameserver08'; | ||
| 1167 | push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ); | ||
| 1168 | my %nsnames_and_ip; | ||
| 1169 | my $original_name = q{www.} . $zone->name->string; | ||
| 1170 | my $randomized_uc_name; | ||
| 1171 | |||
| 1172 | $original_name =~ s/[.]+\z//smgx; | ||
| 1173 | |||
| 1174 | do { | ||
| 1175 | $randomized_uc_name = scramble_case $original_name; | ||
| 1176 | } while ( $randomized_uc_name eq $original_name ); | ||
| 1177 | |||
| 1178 | my @nss = @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) }; | ||
| 1179 | |||
| 1180 | foreach my $local_ns ( @nss ) { | ||
| 1181 | |||
| 1182 | next if ( _ip_disabled_message( \@results, $local_ns, q{SOA} ) ); | ||
| 1183 | |||
| 1184 | next if $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short }; | ||
| 1185 | |||
| 1186 | my $p = $local_ns->query( $randomized_uc_name, q{SOA} ); | ||
| 1187 | |||
| 1188 | if ( $p and my ( $qrr ) = $p->question() ) { | ||
| 1189 | my $qrr_name = $qrr->name(); | ||
| 1190 | $qrr_name =~ s/\.\z//smgx; | ||
| 1191 | if ( $qrr_name eq $randomized_uc_name ) { | ||
| 1192 | push @results, | ||
| 1193 | _emit_log( | ||
| 1194 | QNAME_CASE_SENSITIVE => { | ||
| 1195 | ns => $local_ns->string, | ||
| 1196 | domain => $randomized_uc_name, | ||
| 1197 | } | ||
| 1198 | ); | ||
| 1199 | } | ||
| 1200 | else { | ||
| 1201 | push @results, | ||
| 1202 | _emit_log( | ||
| 1203 | QNAME_CASE_INSENSITIVE => { | ||
| 1204 | ns => $local_ns->string, | ||
| 1205 | domain => $randomized_uc_name, | ||
| 1206 | } | ||
| 1207 | ); | ||
| 1208 | } | ||
| 1209 | } ## end if ( $p and my ( $qrr ...)) | ||
| 1210 | $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short }++; | ||
| 1211 | } ## end foreach my $local_ns ( @{ Zonemaster::Engine::TestMethods...}) | ||
| 1212 | |||
| 1213 | return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) ); | ||
| 1214 | } ## end sub nameserver08 | ||
| 1215 | |||
| 1216 | =over | ||
| 1217 | |||
| 1218 | =item nameserver09() | ||
| 1219 | |||
| 1220 | my @logentry_array = nameserver09( $zone ); | ||
| 1221 | |||
| 1222 | Runs the L<Nameserver09 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Nameserver-TP/nameserver09.md>. | ||
| 1223 | |||
| 1224 | Takes a L<Zonemaster::Engine::Zone> object. | ||
| 1225 | |||
| 1226 | Returns a list of L<Zonemaster::Engine::Logger::Entry> objects. | ||
| 1227 | |||
| 1228 | =back | ||
| 1229 | |||
| 1230 | =cut | ||
| 1231 | |||
| 1232 | sub nameserver09 { | ||
| 1233 | my ( $class, $zone ) = @_; | ||
| 1234 | |||
| 1235 | local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Nameserver09'; | ||
| 1236 | push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ); | ||
| 1237 | my %nsnames_and_ip; | ||
| 1238 | my $original_name = q{www.} . $zone->name->string; | ||
| 1239 | my $record_type = q{SOA}; | ||
| 1240 | my $randomized_uc_name1; | ||
| 1241 | my $randomized_uc_name2; | ||
| 1242 | my $all_results_match = 1; | ||
| 1243 | |||
| 1244 | $original_name =~ s/[.]+\z//smgx; | ||
| 1245 | |||
| 1246 | do { | ||
| 1247 | $randomized_uc_name1 = scramble_case $original_name; | ||
| 1248 | } while ( $randomized_uc_name1 eq $original_name ); | ||
| 1249 | |||
| 1250 | do { | ||
| 1251 | $randomized_uc_name2 = scramble_case $original_name; | ||
| 1252 | } while ( $randomized_uc_name2 eq $original_name or $randomized_uc_name2 eq $randomized_uc_name1 ); | ||
| 1253 | |||
| 1254 | my @nss = @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) }; | ||
| 1255 | |||
| 1256 | foreach my $local_ns ( @nss ) { | ||
| 1257 | |||
| 1258 | next if ( _ip_disabled_message( \@results, $local_ns, $record_type ) ); | ||
| 1259 | |||
| 1260 | next if $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short }; | ||
| 1261 | |||
| 1262 | my $p1 = $local_ns->query( $randomized_uc_name1, $record_type ); | ||
| 1263 | my $p2 = $local_ns->query( $randomized_uc_name2, $record_type ); | ||
| 1264 | |||
| 1265 | my $answer1_string = q{}; | ||
| 1266 | my $answer2_string = q{}; | ||
| 1267 | my $json = JSON::PP->new->canonical->pretty; | ||
| 1268 | if ( $p1 and scalar $p1->answer ) { | ||
| 1269 | |||
| 1270 | my @answer1 = map { lc $_->string } sort $p1->answer; | ||
| 1271 | $answer1_string = $json->encode( \@answer1 ); | ||
| 1272 | |||
| 1273 | if ( $p2 and scalar $p2->answer ) { | ||
| 1274 | |||
| 1275 | my @answer2 = map { lc $_->string } sort $p2->answer; | ||
| 1276 | $answer2_string = $json->encode( \@answer2 ); | ||
| 1277 | } | ||
| 1278 | |||
| 1279 | if ( $answer1_string eq $answer2_string ) { | ||
| 1280 | push @results, | ||
| 1281 | _emit_log( | ||
| 1282 | CASE_QUERY_SAME_ANSWER => { | ||
| 1283 | ns => $local_ns->string, | ||
| 1284 | type => $record_type, | ||
| 1285 | query1 => $randomized_uc_name1, | ||
| 1286 | query2 => $randomized_uc_name2, | ||
| 1287 | } | ||
| 1288 | ); | ||
| 1289 | } | ||
| 1290 | else { | ||
| 1291 | $all_results_match = 0; | ||
| 1292 | push @results, | ||
| 1293 | _emit_log( | ||
| 1294 | CASE_QUERY_DIFFERENT_ANSWER => { | ||
| 1295 | ns => $local_ns->string, | ||
| 1296 | type => $record_type, | ||
| 1297 | query1 => $randomized_uc_name1, | ||
| 1298 | query2 => $randomized_uc_name2, | ||
| 1299 | } | ||
| 1300 | ); | ||
| 1301 | } | ||
| 1302 | |||
| 1303 | } ## end if ( $p1 and scalar $p1...) | ||
| 1304 | elsif ( $p1 and $p2 ) { | ||
| 1305 | |||
| 1306 | if ( $p1->rcode eq $p2->rcode ) { | ||
| 1307 | push @results, | ||
| 1308 | _emit_log( | ||
| 1309 | CASE_QUERY_SAME_RC => { | ||
| 1310 | ns => $local_ns->string, | ||
| 1311 | type => $record_type, | ||
| 1312 | query1 => $randomized_uc_name1, | ||
| 1313 | query2 => $randomized_uc_name2, | ||
| 1314 | rcode => $p1->rcode, | ||
| 1315 | } | ||
| 1316 | ); | ||
| 1317 | } | ||
| 1318 | else { | ||
| 1319 | $all_results_match = 0; | ||
| 1320 | push @results, | ||
| 1321 | _emit_log( | ||
| 1322 | CASE_QUERY_DIFFERENT_RC => { | ||
| 1323 | ns => $local_ns->string, | ||
| 1324 | type => $record_type, | ||
| 1325 | query1 => $randomized_uc_name1, | ||
| 1326 | query2 => $randomized_uc_name2, | ||
| 1327 | rcode1 => $p1->rcode, | ||
| 1328 | rcode2 => $p2->rcode, | ||
| 1329 | } | ||
| 1330 | ); | ||
| 1331 | } | ||
| 1332 | |||
| 1333 | } ## end elsif ( $p1 and $p2 ) | ||
| 1334 | elsif ( $p1 or $p2 ) { | ||
| 1335 | $all_results_match = 0; | ||
| 1336 | push @results, | ||
| 1337 | _emit_log( | ||
| 1338 | CASE_QUERY_NO_ANSWER => { | ||
| 1339 | ns => $local_ns->string, | ||
| 1340 | type => $record_type, | ||
| 1341 | domain => $p1 ? $randomized_uc_name1 : $randomized_uc_name2, | ||
| 1342 | } | ||
| 1343 | ); | ||
| 1344 | } | ||
| 1345 | |||
| 1346 | $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short }++; | ||
| 1347 | } ## end foreach my $local_ns ( @{ Zonemaster::Engine::TestMethods...}) | ||
| 1348 | |||
| 1349 | if ( $all_results_match ) { | ||
| 1350 | push @results, | ||
| 1351 | _emit_log( | ||
| 1352 | CASE_QUERIES_RESULTS_OK => { | ||
| 1353 | type => $record_type, | ||
| 1354 | domain => $original_name, | ||
| 1355 | } | ||
| 1356 | ); | ||
| 1357 | } | ||
| 1358 | else { | ||
| 1359 | push @results, | ||
| 1360 | _emit_log( | ||
| 1361 | CASE_QUERIES_RESULTS_DIFFER => { | ||
| 1362 | type => $record_type, | ||
| 1363 | domain => $original_name, | ||
| 1364 | } | ||
| 1365 | ); | ||
| 1366 | } | ||
| 1367 | |||
| 1368 | return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) ); | ||
| 1369 | } ## end sub nameserver09 | ||
| 1370 | |||
| 1371 | =over | ||
| 1372 | |||
| 1373 | =item nameserver10() | ||
| 1374 | |||
| 1375 | my @logentry_array = nameserver10( $zone ); | ||
| 1376 | |||
| 1377 | Runs the L<Nameserver10 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Nameserver-TP/nameserver10.md>. | ||
| 1378 | |||
| 1379 | Takes a L<Zonemaster::Engine::Zone> object. | ||
| 1380 | |||
| 1381 | Returns a list of L<Zonemaster::Engine::Logger::Entry> objects. | ||
| 1382 | |||
| 1383 | =back | ||
| 1384 | |||
| 1385 | =cut | ||
| 1386 | |||
| 1387 | sub nameserver10 { | ||
| 1388 | my ( $class, $zone ) = @_; | ||
| 1389 | |||
| 1390 | local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Nameserver10'; | ||
| 1391 | push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ); | ||
| 1392 | |||
| 1393 | my @no_response_edns1; | ||
| 1394 | my %unexpected_rcode; | ||
| 1395 | my @edns_response_error; | ||
| 1396 | |||
| 1397 | my @nss = @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) }; | ||
| 1398 | |||
| 1399 | for my $ns ( @nss ) { | ||
| 1400 | |||
| 1401 | next if ( _ip_disabled_message( \@results, $ns, q{SOA} ) ); | ||
| 1402 | |||
| 1403 | my $p = $ns->query( $zone->name, q{SOA}, { edns_details => { version => 0 } } ); | ||
| 1404 | |||
| 1405 | if ( $p and $p->rcode eq q{NOERROR} ){ | ||
| 1406 | my $p2 = $ns->query( $zone->name, q{SOA}, { edns_details => { version => 1 } } ); | ||
| 1407 | |||
| 1408 | if ( $p2 ) { | ||
| 1409 | if ( ($p2->rcode ne q{NOERROR} and $p2->edns_rcode != 1) ) { | ||
| 1410 | push @{ $unexpected_rcode{$p->rcode} }, $ns->address->short; | ||
| 1411 | } | ||
| 1412 | elsif ( ($p2->rcode eq q{NOERROR} and $p2->edns_rcode == 1) and $p2->edns_version == 0 and not scalar $p2->answer){ | ||
| 1413 | next; | ||
| 1414 | } | ||
| 1415 | else { | ||
| 1416 | push @edns_response_error, $ns->address->short; | ||
| 1417 | } | ||
| 1418 | } | ||
| 1419 | else { | ||
| 1420 | push @no_response_edns1, $ns->address->short; | ||
| 1421 | } | ||
| 1422 | } | ||
| 1423 | } | ||
| 1424 | |||
| 1425 | if ( scalar @no_response_edns1 ){ | ||
| 1426 | push @results, | ||
| 1427 | _emit_log( | ||
| 1428 | N10_NO_RESPONSE_EDNS1_QUERY => { | ||
| 1429 | ns_ip_list => join ( q{;}, uniq sort @no_response_edns1 ) | ||
| 1430 | } | ||
| 1431 | ); | ||
| 1432 | } | ||
| 1433 | |||
| 1434 | if ( scalar keys %unexpected_rcode ){ | ||
| 1435 | push @results, map { | ||
| 1436 | _emit_log( | ||
| 1437 | N10_UNEXPECTED_RCODE => { | ||
| 1438 | rcode => $_, | ||
| 1439 | ns_ip_list => join( q{;}, uniq sort @{ $unexpected_rcode{$_} } ) | ||
| 1440 | } | ||
| 1441 | ) | ||
| 1442 | } keys %unexpected_rcode; | ||
| 1443 | } | ||
| 1444 | |||
| 1445 | if ( scalar @edns_response_error ){ | ||
| 1446 | push @results, | ||
| 1447 | _emit_log( | ||
| 1448 | N10_EDNS_RESPONSE_ERROR => { | ||
| 1449 | ns_ip_list => join ( q{;}, uniq sort @edns_response_error ) | ||
| 1450 | } | ||
| 1451 | ); | ||
| 1452 | } | ||
| 1453 | |||
| 1454 | return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) ); | ||
| 1455 | } ## end sub nameserver10 | ||
| 1456 | |||
| 1457 | =over | ||
| 1458 | |||
| 1459 | =item nameserver11() | ||
| 1460 | |||
| 1461 | my @logentry_array = nameserver11( $zone ); | ||
| 1462 | |||
| 1463 | Runs the L<Nameserver11 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Nameserver-TP/nameserver11.md>. | ||
| 1464 | |||
| 1465 | Takes a L<Zonemaster::Engine::Zone> object. | ||
| 1466 | |||
| 1467 | Returns a list of L<Zonemaster::Engine::Logger::Entry> objects. | ||
| 1468 | |||
| 1469 | =back | ||
| 1470 | |||
| 1471 | =cut | ||
| 1472 | |||
| 1473 | sub nameserver11 { | ||
| 1474 | my ( $class, $zone ) = @_; | ||
| 1475 | |||
| 1476 | local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Nameserver11'; | ||
| 1477 | push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ); | ||
| 1478 | |||
| 1479 | my @no_response; | ||
| 1480 | my %unexpected_rcode; | ||
| 1481 | my @no_edns; | ||
| 1482 | my @unexpected_answer; | ||
| 1483 | my @unset_aa; | ||
| 1484 | my @unknown_opt_code; | ||
| 1485 | |||
| 1486 | # Choose an unassigned EDNS0 Option Codes | ||
| 1487 | # values 15-26945 are Unassigned. Let's say we use 137 ??? | ||
| 1488 | my $opt_code = 137; | ||
| 1489 | my $opt_data = q{}; | ||
| 1490 | my $opt_length = length($opt_data); | ||
| 1491 | my $rdata = $opt_code*65536 + $opt_length; | ||
| 1492 | |||
| 1493 | foreach my $ns ( @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) } ) { | ||
| 1494 | |||
| 1495 | next if ( _ip_disabled_message( \@results, $ns, q{SOA} ) ); | ||
| 1496 | |||
| 1497 | my $p = $ns->query( $zone->name, q{SOA}, { edns_details => { version => 0 } } ); | ||
| 1498 | |||
| 1499 | if ( not $p or not $p->has_edns or $p->rcode ne q{NOERROR} or not $p->aa or not $p->get_records_for_name(q{SOA}, $zone->name, q{answer}) ) { | ||
| 1500 | next; | ||
| 1501 | } | ||
| 1502 | |||
| 1503 | $p = $ns->query( $zone->name, q{SOA}, { edns_details => { version => 0, data => $rdata } } ); | ||
| 1504 | |||
| 1505 | if ( $p ) { | ||
| 1506 | if ( $p->rcode ne q{NOERROR} ) { | ||
| 1507 | push @{ $unexpected_rcode{$p->rcode} }, $ns->address->short; | ||
| 1508 | } | ||
| 1509 | |||
| 1510 | elsif ( not $p->has_edns ) { | ||
| 1511 | push @no_edns, $ns->address->short; | ||
| 1512 | } | ||
| 1513 | |||
| 1514 | elsif ( not $p->get_records_for_name(q{SOA}, $zone->name, q{answer}) ) { | ||
| 1515 | push @unexpected_answer, $ns->address->short; | ||
| 1516 | } | ||
| 1517 | |||
| 1518 | elsif ( not $p->aa ) { | ||
| 1519 | push @unset_aa, $ns->address->short; | ||
| 1520 | } | ||
| 1521 | |||
| 1522 | elsif ( defined $p->edns_data ) { | ||
| 1523 | my $p_opt = $p->edns_data; | ||
| 1524 | |||
| 1525 | # Unpack the bytes string: | ||
| 1526 | # - OPTION-CODE as unsigned short (16-bit) in "network" (big-endian) order, and | ||
| 1527 | # - OPTION-DATA as a sequence of bytes of length specified by a prefixed unsigned short (16-bit) | ||
| 1528 | # in "network" (big-endian) order (OPTION-LENGTH), and | ||
| 1529 | # - Remaining data, if any (i.e., other OPTIONS) | ||
| 1530 | |||
| 1531 | my @unpacked_opt = eval { unpack("(n n/a)*", $p_opt) }; | ||
| 1532 | |||
| 1533 | while ( my ( $p_opt_code, $p_opt_data, @next_data ) = @unpacked_opt ) { | ||
| 1534 | if ( $p_opt_code == $opt_code ) { | ||
| 1535 | push @unknown_opt_code, $ns->address->short; | ||
| 1536 | last; | ||
| 1537 | } | ||
| 1538 | |||
| 1539 | @unpacked_opt = @next_data; | ||
| 1540 | } | ||
| 1541 | } | ||
| 1542 | } | ||
| 1543 | else{ | ||
| 1544 | push @no_response, $ns->address->short; | ||
| 1545 | } | ||
| 1546 | } | ||
| 1547 | |||
| 1548 | if ( scalar @no_response ) { | ||
| 1549 | push @results, _emit_log( N11_NO_RESPONSE => { ns_ip_list => join( q{;}, uniq sort @no_response ) } ); | ||
| 1550 | } | ||
| 1551 | |||
| 1552 | if ( scalar keys %unexpected_rcode ) { | ||
| 1553 | push @results, map { | ||
| 1554 | _emit_log( | ||
| 1555 | N11_UNEXPECTED_RCODE => { | ||
| 1556 | rcode => $_, | ||
| 1557 | ns_ip_list => join( q{;}, uniq sort @{ $unexpected_rcode{$_} } ) | ||
| 1558 | } | ||
| 1559 | ) | ||
| 1560 | } keys %unexpected_rcode; | ||
| 1561 | } | ||
| 1562 | |||
| 1563 | if ( scalar @no_edns ) { | ||
| 1564 | push @results, _emit_log( N11_NO_EDNS => { ns_ip_list => join( q{;}, uniq sort @no_edns ) } ); | ||
| 1565 | } | ||
| 1566 | |||
| 1567 | if ( scalar @unexpected_answer ) { | ||
| 1568 | push @results, _emit_log( N11_UNEXPECTED_ANSWER_SECTION => { ns_ip_list => join( q{;}, uniq sort @unexpected_answer ) } ); | ||
| 1569 | } | ||
| 1570 | |||
| 1571 | if ( scalar @unset_aa ) { | ||
| 1572 | push @results, _emit_log( N11_UNSET_AA => { ns_ip_list => join( q{;}, uniq sort @unset_aa ) } ); | ||
| 1573 | } | ||
| 1574 | |||
| 1575 | if ( scalar @unknown_opt_code ) { | ||
| 1576 | push @results, _emit_log( N11_RETURNS_UNKNOWN_OPTION_CODE => { ns_ip_list => join( q{;}, uniq sort @unknown_opt_code ) } ); | ||
| 1577 | } | ||
| 1578 | |||
| 1579 | return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) ); | ||
| 1580 | } ## end sub nameserver11 | ||
| 1581 | |||
| 1582 | =over | ||
| 1583 | |||
| 1584 | =item nameserver12() | ||
| 1585 | |||
| 1586 | my @logentry_array = nameserver12( $zone ); | ||
| 1587 | |||
| 1588 | Runs the L<Nameserver12 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Nameserver-TP/nameserver12.md>. | ||
| 1589 | |||
| 1590 | Takes a L<Zonemaster::Engine::Zone> object. | ||
| 1591 | |||
| 1592 | Returns a list of L<Zonemaster::Engine::Logger::Entry> objects. | ||
| 1593 | |||
| 1594 | =back | ||
| 1595 | |||
| 1596 | =cut | ||
| 1597 | |||
| 1598 | sub nameserver12 { | ||
| 1599 | my ( $class, $zone ) = @_; | ||
| 1600 | |||
| 1601 | local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Nameserver12'; | ||
| 1602 | push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ); | ||
| 1603 | |||
| 1604 | my @nss = @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) }; | ||
| 1605 | |||
| 1606 | for my $ns ( @nss ) { | ||
| 1607 | |||
| 1608 | next if ( _ip_disabled_message( \@results, $ns, q{SOA} ) ); | ||
| 1609 | |||
| 1610 | my $p = $ns->query( $zone->name, q{SOA}, { edns_details => { version => 0, z => 3 } } ); | ||
| 1611 | |||
| 1612 | if ( $p ) { | ||
| 1613 | if ( $p->rcode eq q{FORMERR} and not $p->edns_rcode ) { | ||
| 1614 | push @results, _emit_log( NO_EDNS_SUPPORT => { ns => $ns->string } ); | ||
| 1615 | } | ||
| 1616 | elsif ( $p->edns_z ) { | ||
| 1617 | push @results, _emit_log( Z_FLAGS_NOTCLEAR => { ns => $ns->string } ); | ||
| 1618 | } | ||
| 1619 | elsif ( $p->rcode eq q{NOERROR} and not $p->edns_rcode and $p->edns_version == 0 and $p->edns_z == 0 and $p->get_records( q{SOA}, q{answer} ) ) { | ||
| 1620 | next; | ||
| 1621 | } | ||
| 1622 | else { | ||
| 1623 | push @results, _emit_log( NS_ERROR => { ns => $ns->string } ); | ||
| 1624 | } | ||
| 1625 | } | ||
| 1626 | else { | ||
| 1627 | push @results, | ||
| 1628 | _emit_log( | ||
| 1629 | NO_RESPONSE => { | ||
| 1630 | ns => $ns->string, | ||
| 1631 | domain => $zone->name, | ||
| 1632 | } | ||
| 1633 | ); | ||
| 1634 | } | ||
| 1635 | } | ||
| 1636 | |||
| 1637 | return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) ); | ||
| 1638 | } ## end sub nameserver12 | ||
| 1639 | |||
| 1640 | =over | ||
| 1641 | |||
| 1642 | =item nameserver13() | ||
| 1643 | |||
| 1644 | my @logentry_array = nameserver13( $zone ); | ||
| 1645 | |||
| 1646 | Runs the L<Nameserver13 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Nameserver-TP/nameserver13.md>. | ||
| 1647 | |||
| 1648 | Takes a L<Zonemaster::Engine::Zone> object. | ||
| 1649 | |||
| 1650 | Returns a list of L<Zonemaster::Engine::Logger::Entry> objects. | ||
| 1651 | |||
| 1652 | =back | ||
| 1653 | |||
| 1654 | =cut | ||
| 1655 | |||
| 1656 | sub nameserver13 { | ||
| 1657 | my ( $class, $zone ) = @_; | ||
| 1658 | |||
| 1659 | local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Nameserver13'; | ||
| 1660 | push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ); | ||
| 1661 | |||
| 1662 | my @nss = @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) }; | ||
| 1663 | |||
| 1664 | for my $ns ( @nss ) { | ||
| 1665 | |||
| 1666 | next if ( _ip_disabled_message( \@results, $ns, q{DNSKEY} ) ); | ||
| 1667 | |||
| 1668 | my $p = $ns->query( $zone->name, q{DNSKEY}, { usevc => 0, fallback => 0, edns_details => { version => 0, do => 1, size => 512 } } ); | ||
| 1669 | |||
| 1670 | if ( $p ) { | ||
| 1671 | if ( $p->rcode eq q{FORMERR} and not $p->edns_rcode ) { | ||
| 1672 | push @results, _emit_log( NO_EDNS_SUPPORT => { ns => $ns->string, } ); | ||
| 1673 | } | ||
| 1674 | elsif ( $p->tc and not $p->has_edns ) { | ||
| 1675 | push @results, _emit_log( MISSING_OPT_IN_TRUNCATED => { ns => $ns->string } ); | ||
| 1676 | } | ||
| 1677 | elsif ( $p->rcode eq q{NOERROR} and not $p->edns_rcode and $p->edns_version == 0 ) { | ||
| 1678 | next; | ||
| 1679 | } | ||
| 1680 | else { | ||
| 1681 | push @results, _emit_log( NS_ERROR => { ns => $ns->string } ); | ||
| 1682 | } | ||
| 1683 | } | ||
| 1684 | else { | ||
| 1685 | push @results, | ||
| 1686 | _emit_log( | ||
| 1687 | NO_RESPONSE => { | ||
| 1688 | ns => $ns->string, | ||
| 1689 | domain => $zone->name, | ||
| 1690 | } | ||
| 1691 | ); | ||
| 1692 | } | ||
| 1693 | } | ||
| 1694 | |||
| 1695 | return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) ); | ||
| 1696 | } ## end sub nameserver13 | ||
| 1697 | |||
| 1698 | =over | ||
| 1699 | |||
| 1700 | =item nameserver15() | ||
| 1701 | |||
| 1702 | my @logentry_array = nameserver15( $zone ); | ||
| 1703 | |||
| 1704 | Runs the L<Nameserver15 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Nameserver-TP/nameserver15.md>. | ||
| 1705 | |||
| 1706 | Takes a L<Zonemaster::Engine::Zone> object. | ||
| 1707 | |||
| 1708 | Returns a list of L<Zonemaster::Engine::Logger::Entry> objects. | ||
| 1709 | |||
| 1710 | =back | ||
| 1711 | |||
| 1712 | =cut | ||
| 1713 | |||
| 1714 | sub nameserver15 { | ||
| 1715 | my ( $class, $zone ) = @_; | ||
| 1716 | |||
| 1717 | local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Nameserver15'; | ||
| 1718 | push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ); | ||
| 1719 | |||
| 1720 | my %txt_data; | ||
| 1721 | my %error_on_version_query; | ||
| 1722 | my %sending_version_query; | ||
| 1723 | my @wrong_record_class; | ||
| 1724 | |||
| 1725 | foreach my $ns ( @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) } ) { | ||
| 1726 | next if ( _ip_disabled_message( \@results, $ns, q{SOA TXT} ) ); | ||
| 1727 | |||
| 1728 | my $p_soa = $ns->query( $zone->name, q{SOA} ); | ||
| 1729 | |||
| 1730 | next if not $p_soa; | ||
| 1731 | |||
| 1732 | $sending_version_query{$ns} = 1; | ||
| 1733 | |||
| 1734 | foreach my $query_name ( q{version.bind}, q{version.server} ) { | ||
| 1735 | my $p_txt = $ns->query( $query_name, q{TXT}, { class => q{CH} } ); | ||
| 1736 | |||
| 1737 | if ( not $p_txt or $p_txt->rcode eq q{SERVFAIL} ) { | ||
| 1738 | push @{ $error_on_version_query{$query_name} }, $ns; | ||
| 1739 | next; | ||
| 1740 | } | ||
| 1741 | |||
| 1742 | my @rrs_txt = $p_txt->get_records_for_name(q{TXT}, $query_name, q{answer}); | ||
| 1743 | |||
| 1744 | if ( scalar @rrs_txt ) { | ||
| 1745 | foreach my $rr ( @rrs_txt ) { | ||
| 1746 | if ( $rr->class ne q{CH} ) { | ||
| 1747 | push @wrong_record_class, $ns; | ||
| 1748 | } | ||
| 1749 | |||
| 1750 | my $string = escape_unprintable($rr->txtdata); | ||
| 1751 | $string =~ s/^\s+|\s+$//g; # Remove leading and trailing spaces | ||
| 1752 | |||
| 1753 | if ( $string ne "" ) { | ||
| 1754 | push @{ $txt_data{$string}{$query_name} }, $ns; | ||
| 1755 | delete $sending_version_query{$ns}; | ||
| 1756 | } | ||
| 1757 | } | ||
| 1758 | } | ||
| 1759 | } | ||
| 1760 | } | ||
| 1761 | |||
| 1762 | if ( scalar keys %txt_data ) { | ||
| 1763 | foreach my $string ( keys %txt_data ) { | ||
| 1764 | push @results, map { | ||
| 1765 | _emit_log( | ||
| 1766 | N15_SOFTWARE_VERSION => { | ||
| 1767 | string => $string, | ||
| 1768 | query_name => $_, | ||
| 1769 | ns_list => join( q{;}, sort @{ $txt_data{$string}{$_} } ) | ||
| 1770 | } | ||
| 1771 | ) | ||
| 1772 | } keys %{ $txt_data{$string} }; | ||
| 1773 | } | ||
| 1774 | } | ||
| 1775 | |||
| 1776 | if ( scalar keys %error_on_version_query ) { | ||
| 1777 | push @results, map { | ||
| 1778 | _emit_log( | ||
| 1779 | N15_ERROR_ON_VERSION_QUERY => { | ||
| 1780 | query_name => $_, | ||
| 1781 | ns_list => join( q{;}, sort @{ $error_on_version_query{$_} } ) | ||
| 1782 | } | ||
| 1783 | ) | ||
| 1784 | } keys %error_on_version_query; | ||
| 1785 | } | ||
| 1786 | |||
| 1787 | if ( scalar keys %sending_version_query ) { | ||
| 1788 | push @results, | ||
| 1789 | _emit_log( | ||
| 1790 | N15_NO_VERSION_REVEALED => { | ||
| 1791 | ns_list => join( q{;}, sort keys %sending_version_query ) | ||
| 1792 | } | ||
| 1793 | ); | ||
| 1794 | } | ||
| 1795 | |||
| 1796 | if ( scalar @wrong_record_class ) { | ||
| 1797 | push @results, | ||
| 1798 | _emit_log( | ||
| 1799 | N15_WRONG_CLASS => { | ||
| 1800 | ns_list => join( q{;}, sort @wrong_record_class ) | ||
| 1801 | } | ||
| 1802 | ); | ||
| 1803 | } | ||
| 1804 | |||
| 1805 | return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) ); | ||
| 1806 | } ## end sub nameserver15 | ||
| 1807 | |||
| 1808 | 1; |