Zonemaster/Engine/Test/Zone.pm untested

filter: Statementstmt 0.0% 0 / 534 Branchbran 0.0% 0 / 196 Conditioncond 0.0% 0 / 89 MC/DCmcdc 0.0% 0 / 52 Subroutinesub 0.0% 0 / 42 Podpod 0.0% 0 / 24 totaltotal 0.0% 0 / 937 CC 99 SCAR 53.1
CC
99
Cov
0%
zone09
552.0
zone01
462.0
all
210.0
CRAP 203.2
1 package Zonemaster::Engine::Test::Zone;
2  
3 use v5.26.0;
4 use warnings;
5  
6 use version; our $VERSION = version->declare( "v1.0.14" );
7  
8 use Carp;
9 use List::MoreUtils qw[uniq none];
10 use List::Util qw[max];
11 use Locale::TextDomain qw[Zonemaster-Engine];
12 use Readonly;
13 use JSON::PP;
14 use Mail::SPF::v1::Record;
15 use Try::Tiny;
16  
17 use Zonemaster::Engine::Profile;
18 use Zonemaster::Engine::Constants qw[:soa :ip];
19 use Zonemaster::Engine::Recursor;
20 use Zonemaster::Engine::Nameserver;
21 use Zonemaster::Engine::Test::Address;
22 use Zonemaster::Engine::TestMethods;
23 use Zonemaster::Engine::Util;
24  
25 =head1 NAME
26  
27 Zonemaster::Engine::Test::Zone - Module implementing tests focused on the DNS zone content, such as SOA and MX records
28  
29 =head1 SYNOPSIS
30  
31 my @results = Zonemaster::Engine::Test::Zone->all( $zone );
32  
33 =head1 METHODS
34  
35 =over
36  
37 =item all()
38  
39 my @logentry_array = all( $zone );
40  
41 Runs the default set of tests for that module, i.e. between L<eight and ten tests|/TESTS> depending on the tested zone.
42  
43 Takes a L<Zonemaster::Engine::Zone> object.
44  
45 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
46  
47 =back
48  
49 =cut
50  
51 sub all {
52 my ( $class, $zone ) = @_;
53 my @results;
54  
55 push @results, $class->zone01( $zone ) if Zonemaster::Engine::Util::should_run_test( q{zone01} );
56 push @results, $class->zone02( $zone ) if Zonemaster::Engine::Util::should_run_test( q{zone02} );
57 push @results, $class->zone03( $zone ) if Zonemaster::Engine::Util::should_run_test( q{zone03} );
58 push @results, $class->zone04( $zone ) if Zonemaster::Engine::Util::should_run_test( q{zone04} );
59 push @results, $class->zone05( $zone ) if Zonemaster::Engine::Util::should_run_test( q{zone05} );
60 push @results, $class->zone06( $zone ) if Zonemaster::Engine::Util::should_run_test( q{zone06} );
61 push @results, $class->zone07( $zone ) if Zonemaster::Engine::Util::should_run_test( q{zone07} );
62 push @results, $class->zone08( $zone ) if Zonemaster::Engine::Util::should_run_test( q{zone08} );
63  
64 if ( none { $_->tag eq q{NO_RESPONSE_MX_QUERY} } @results ) {
65 push @results, $class->zone09( $zone ) if Zonemaster::Engine::Util::should_run_test( q{zone09} );
66 }
67  
68 if ( none { $_->tag eq q{NO_RESPONSE_SOA_QUERY} } @results ) {
69 push @results, $class->zone10( $zone ) if Zonemaster::Engine::Util::should_run_test( q{zone10} );
70 push @results, $class->zone11( $zone ) if Zonemaster::Engine::Util::should_run_test( q{zone11} );
71 }
72  
73 return @results;
74 } ## end sub all
75  
76 =over
77  
78 =item metadata()
79  
80 my $hash_ref = metadata();
81  
82 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
83 an array containing all the message tags that the Test Case can use in L<log entries|Zonemaster::Engine::Logger::Entry>.
84  
85 =back
86  
87 =cut
88  
89 sub metadata {
90 my ( $class ) = @_;
91  
92 return {
93 zone01 => [
94 qw(
95 Z01_MNAME_HAS_LOCALHOST_ADDR
96 Z01_MNAME_IS_DOT
97 Z01_MNAME_IS_LOCALHOST
98 Z01_MNAME_IS_MASTER
99 Z01_MNAME_MISSING_SOA_RECORD
100 Z01_MNAME_NO_RESPONSE
101 Z01_MNAME_NOT_AUTHORITATIVE
102 Z01_MNAME_NOT_IN_NS_LIST
103 Z01_MNAME_NOT_MASTER
104 Z01_MNAME_NOT_RESOLVE
105 Z01_MNAME_UNEXPECTED_RCODE
106 TEST_CASE_END
107 TEST_CASE_START
108 )
109 ],
110 zone02 => [
111 qw(
112 REFRESH_MINIMUM_VALUE_LOWER
113 REFRESH_MINIMUM_VALUE_OK
114 NO_RESPONSE_SOA_QUERY
115 TEST_CASE_END
116 TEST_CASE_START
117 )
118 ],
119 zone03 => [
120 qw(
121 REFRESH_LOWER_THAN_RETRY
122 REFRESH_HIGHER_THAN_RETRY
123 NO_RESPONSE_SOA_QUERY
124 TEST_CASE_END
125 TEST_CASE_START
126 )
127 ],
128 zone04 => [
129 qw(
130 RETRY_MINIMUM_VALUE_LOWER
131 RETRY_MINIMUM_VALUE_OK
132 NO_RESPONSE_SOA_QUERY
133 TEST_CASE_END
134 TEST_CASE_START
135 )
136 ],
137 zone05 => [
138 qw(
139 EXPIRE_MINIMUM_VALUE_LOWER
140 EXPIRE_LOWER_THAN_REFRESH
141 EXPIRE_MINIMUM_VALUE_OK
142 NO_RESPONSE_SOA_QUERY
143 TEST_CASE_END
144 TEST_CASE_START
145 )
146 ],
147 zone06 => [
148 qw(
149 SOA_DEFAULT_TTL_MAXIMUM_VALUE_HIGHER
150 SOA_DEFAULT_TTL_MAXIMUM_VALUE_LOWER
151 SOA_DEFAULT_TTL_MAXIMUM_VALUE_OK
152 NO_RESPONSE_SOA_QUERY
153 TEST_CASE_END
154 TEST_CASE_START
155 )
156 ],
157 zone07 => [
158 qw(
159 MNAME_IS_CNAME
160 MNAME_IS_NOT_CNAME
161 NO_RESPONSE_SOA_QUERY
162 MNAME_HAS_NO_ADDRESS
163 TEST_CASE_END
164 TEST_CASE_START
165 )
166 ],
167 zone08 => [
168 qw(
169 MX_RECORD_IS_CNAME
170 MX_RECORD_IS_NOT_CNAME
171 NO_RESPONSE_MX_QUERY
172 TEST_CASE_END
173 TEST_CASE_START
174 )
175 ],
176 zone09 => [
177 qw(
178 Z09_ARPA_EMAIL_DOMAIN
179 Z09_INCONSISTENT_MX
180 Z09_INCONSISTENT_MX_DATA
181 Z09_MISSING_MAIL_EXCHANGE
182 Z09_MX_DATA
183 Z09_MX_FOUND
184 Z09_NON_AUTH_MX_RESPONSE
185 Z09_NO_MX_FOUND
186 Z09_NO_MX_FOUND_OR_EXPECTED
187 Z09_NO_SERVERS_MX_RESPONSE
188 Z09_NO_RESPONSE_MX_QUERY
189 Z09_NULL_MX_NON_ZERO_PREF
190 Z09_NULL_MX_WITH_OTHER_MX
191 Z09_ROOT_EMAIL_DOMAIN
192 Z09_TLD_EMAIL_DOMAIN
193 Z09_UNEXPECTED_RCODE_MX
194 Z09_VALID_NULL_MX
195 TEST_CASE_END
196 TEST_CASE_START
197 )
198 ],
199 zone10 => [
200 qw(
201 MULTIPLE_SOA
202 NO_RESPONSE
203 NO_SOA_IN_RESPONSE
204 ONE_SOA
205 WRONG_SOA
206 TEST_CASE_END
207 TEST_CASE_START
208 )
209 ],
210 zone11 => [
211 qw(
212 Z11_DIFFERENT_SPF_POLICIES_FOUND
213 Z11_INCONSISTENT_SPF_POLICIES
214 Z11_NO_SPF_FOUND
215 Z11_NO_SPF_NON_MAIL_DOMAIN
216 Z11_NON_NULL_SPF_NON_MAIL_DOMAIN
217 Z11_NULL_SPF_NON_MAIL_DOMAIN
218 Z11_SPF_MULTIPLE_RECORDS
219 Z11_SPF_SYNTAX_ERROR
220 Z11_SPF_SYNTAX_OK
221 Z11_UNABLE_TO_CHECK_FOR_SPF
222 )
223 ],
224 };
225 } ## end sub metadata
226  
227 Readonly my %TAG_DESCRIPTIONS => (
228 ZONE01 => sub {
229 __x # ZONE:ZONE01
230 'Fully qualified master nameserver in SOA';
231 },
232 ZONE02 => sub {
233 __x # ZONE:ZONE02
234 'SOA \'refresh\' minimum value';
235 },
236 ZONE03 => sub {
237 __x # ZONE:ZONE03
238 'SOA \'retry\' lower than \'refresh\'';
239 },
240 ZONE04 => sub {
241 __x # ZONE:ZONE04
242 'SOA \'retry\' at least 1 hour';
243 },
244 ZONE05 => sub {
245 __x # ZONE:ZONE05
246 'SOA \'expire\' minimum value';
247 },
248 ZONE06 => sub {
249 __x # ZONE:ZONE06
250 'SOA \'minimum\' maximum value';
251 },
252 ZONE07 => sub {
253 __x # ZONE:ZONE07
254 'SOA master is not an alias';
255 },
256 ZONE08 => sub {
257 __x # ZONE:ZONE08
258 'MX is not an alias';
259 },
260 ZONE09 => sub {
261 __x # ZONE:ZONE09
262 'MX record present';
263 },
264 ZONE10 => sub {
265 __x # ZONE:ZONE10
266 'No multiple SOA records';
267 },
268 ZONE11 => sub {
269 __x # ZONE:ZONE11
270 'SPF policy validation', @_;
271 },
272 RETRY_MINIMUM_VALUE_LOWER => sub {
273 __x # ZONE:RETRY_MINIMUM_VALUE_LOWER
274 'SOA \'retry\' value ({retry}) is less than the recommended one ({required_retry}).', @_;
275 },
276 RETRY_MINIMUM_VALUE_OK => sub {
277 __x # ZONE:RETRY_MINIMUM_VALUE_OK
278 'SOA \'retry\' value ({retry}) is at least equal to the minimum recommended value ({required_retry}).', @_;
279 },
280 MNAME_IS_CNAME => sub {
281 __x # ZONE:MNAME_IS_CNAME
282 'SOA \'mname\' value ({mname}) refers to a NS which is an alias (CNAME).', @_;
283 },
284 MNAME_IS_NOT_CNAME => sub {
285 __x # ZONE:MNAME_IS_NOT_CNAME
286 'SOA \'mname\' value ({mname}) refers to a NS which is not an alias (CNAME).', @_;
287 },
288 REFRESH_MINIMUM_VALUE_LOWER => sub {
289 __x # ZONE:REFRESH_MINIMUM_VALUE_LOWER
290 'SOA \'refresh\' value ({refresh}) is less than the recommended one ({required_refresh}).', @_;
291 },
292 REFRESH_MINIMUM_VALUE_OK => sub {
293 __x # ZONE:REFRESH_MINIMUM_VALUE_OK
294 'SOA \'refresh\' value ({refresh}) is at least equal to the minimum recommended value ({required_refresh}).', @_;
295 },
296 EXPIRE_LOWER_THAN_REFRESH => sub {
297 __x # ZONE:EXPIRE_LOWER_THAN_REFRESH
298 'SOA \'expire\' value ({expire}) is lower than the SOA \'refresh\' value ({refresh}).', @_;
299 },
300 SOA_DEFAULT_TTL_MAXIMUM_VALUE_HIGHER => sub {
301 __x # ZONE:SOA_DEFAULT_TTL_MAXIMUM_VALUE_HIGHER
302 'SOA \'minimum\' value ({minimum}) is higher than the recommended one ({highest_minimum}).', @_;
303 },
304 SOA_DEFAULT_TTL_MAXIMUM_VALUE_LOWER => sub {
305 __x # ZONE:SOA_DEFAULT_TTL_MAXIMUM_VALUE_LOWER
306 'SOA \'minimum\' value ({minimum}) is less than the recommended one ({lowest_minimum}).', @_;
307 },
308 SOA_DEFAULT_TTL_MAXIMUM_VALUE_OK => sub {
309 __x # ZONE:SOA_DEFAULT_TTL_MAXIMUM_VALUE_OK
310 'SOA \'minimum\' value ({minimum}) is between the recommended ones ({lowest_minimum}/{highest_minimum}).', @_;
311 },
312 EXPIRE_MINIMUM_VALUE_LOWER => sub {
313 __x # ZONE:EXPIRE_MINIMUM_VALUE_LOWER
314 'SOA \'expire\' value ({expire}) is less than the recommended one ({required_expire}).', @_;
315 },
316 REFRESH_LOWER_THAN_RETRY => sub {
317 __x # ZONE:REFRESH_LOWER_THAN_RETRY
318 'SOA \'refresh\' value ({refresh}) is lower than the SOA \'retry\' value ({retry}).', @_;
319 },
320 REFRESH_HIGHER_THAN_RETRY => sub {
321 __x # ZONE:REFRESH_HIGHER_THAN_RETRY
322 'SOA \'refresh\' value ({refresh}) is higher than the SOA \'retry\' value ({retry}).', @_;
323 },
324 MX_RECORD_IS_CNAME => sub {
325 __x # ZONE:MX_RECORD_IS_CNAME
326 'MX record for the domain is pointing to a CNAME.', @_;
327 },
328 MX_RECORD_IS_NOT_CNAME => sub {
329 __x # ZONE:MX_RECORD_IS_NOT_CNAME
330 'MX record for the domain is not pointing to a CNAME.', @_;
331 },
332 MULTIPLE_SOA => sub {
333 __x # ZONE:MULTIPLE_SOA
334 'Nameserver {ns} responds with multiple ({count}) SOA records on SOA queries.', @_;
335 },
336 NO_RESPONSE => sub {
337 __x # ZONE:NO_RESPONSE
338 'Nameserver {ns} did not respond.', @_;
339 },
340 NO_RESPONSE_SOA_QUERY => sub {
341 __x # ZONE:NO_RESPONSE_SOA_QUERY
342 'No response from nameserver(s) on SOA queries.';
343 },
344 NO_RESPONSE_MX_QUERY => sub {
345 __x # ZONE:NO_RESPONSE_MX_QUERY
346 'No response from nameserver(s) on MX queries.';
347 },
348 NO_SOA_IN_RESPONSE => sub {
349 __x # ZONE:NO_SOA_IN_RESPONSE
350 'Response from nameserver {ns} on SOA queries does not contain SOA record.', @_;
351 },
352 MNAME_HAS_NO_ADDRESS => sub {
353 __x # ZONE:MNAME_HAS_NO_ADDRESS
354 'No IP address found for SOA \'mname\' nameserver ({mname}).', @_;
355 },
356 ONE_SOA => sub {
357 __x # ZONE:ONE_SOA
358 'A unique SOA record is returned by all nameservers of the zone.', @_;
359 },
360 EXPIRE_MINIMUM_VALUE_OK => sub {
361 __x # ZONE:EXPIRE_MINIMUM_VALUE_OK
362 'SOA \'expire\' value ({expire}) is higher than the minimum recommended value ({required_expire}) '
363 . 'and not lower than the \'refresh\' value ({refresh}).',
364 @_;
365 },
366 IPV4_DISABLED => sub {
367 __x # ZONE:IPV4_DISABLED
368 'IPv4 is disabled, not sending "{rrtype}" query to {ns}.', @_;
369 },
370 IPV6_DISABLED => sub {
371 __x # ZONE:IPV6_DISABLED
372 'IPv6 is disabled, not sending "{rrtype}" query to {ns}.', @_;
373 },
374 TEST_CASE_END => sub {
375 __x # ZONE:TEST_CASE_END
376 'TEST_CASE_END {testcase}.', @_;
377 },
378 TEST_CASE_START => sub {
379 __x # ZONE:TEST_CASE_START
380 'TEST_CASE_START {testcase}.', @_;
381 },
382 WRONG_SOA => sub {
383 __x # ZONE:WRONG_SOA
384 'Nameserver {ns} responds with a wrong owner name ({owner} instead of {name}) on SOA queries.', @_;
385 },
386 Z01_MNAME_HAS_LOCALHOST_ADDR => sub {
387 __x # ZONE:Z01_MNAME_HAS_LOCALHOST_ADDR
388 'SOA MNAME name server "{nsname}" resolves to a localhost IP address ({ns_ip}).', @_;
389 },
390 Z01_MNAME_IS_DOT => sub {
391 __x # ZONE:Z01_MNAME_IS_DOT
392 'SOA MNAME is specified as "." which usually means "no server". Fetched from name servers "{ns_ip_list}".', @_;
393 },
394 Z01_MNAME_IS_LOCALHOST => sub {
395 __x # ZONE:Z01_MNAME_IS_LOCALHOST
396 'SOA MNAME name server is "localhost", which is invalid. Fetched from name servers "{ns_ip_list}".', @_;
397 },
398 Z01_MNAME_IS_MASTER => sub {
399 __x # ZONE:Z01_MNAME_IS_MASTER
400 'SOA MNAME name server(s) "{ns_list}" appears to be master.', @_;
401 },
402 Z01_MNAME_MISSING_SOA_RECORD => sub {
403 __x # ZONE:Z01_MNAME_MISSING_SOA_RECORD
404 'SOA MNAME name server "{ns}" responds to an SOA query with no SOA records in the answer section.', @_;
405 },
406 Z01_MNAME_NO_RESPONSE => sub {
407 __x # ZONE:Z01_MNAME_NO_RESPONSE
408 'SOA MNAME name server "{ns}" does not respond to an SOA query.', @_;
409 },
410 Z01_MNAME_NOT_AUTHORITATIVE => sub {
411 __x # ZONE:Z01_MNAME_NOT_AUTHORITATIVE
412 'SOA MNAME name server "{ns}" is not authoritative for the zone.', @_;
413 },
414 Z01_MNAME_NOT_IN_NS_LIST => sub {
415 __x # ZONE:Z01_MNAME_NOT_IN_NS_LIST
416 'SOA MNAME name server "{nsname}" is not listed as NS record for the zone.', @_;
417 },
418 Z01_MNAME_NOT_MASTER => sub {
419 __x # ZONE:Z01_MNAME_NOT_MASTER
420 'SOA MNAME name server(s) "{ns_list}" do not have the highest SOA SERIAL (expected "{soaserial}" but got "{soaserial_list}")', @_;
421 },
422 Z01_MNAME_NOT_RESOLVE => sub {
423 __x # ZONE:Z01_MNAME_NOT_RESOLVE
424 'SOA MNAME name server "{nsname}" cannot be resolved into an IP address.', @_;
425 },
426 Z01_MNAME_UNEXPECTED_RCODE => sub {
427 __x # ZONE:Z01_MNAME_UNEXPECTED_RCODE
428 'SOA MNAME name server "{ns}" gives unexpected RCODE name ("{rcode}") in response to an SOA query.', @_;
429 },
430 Z09_ARPA_EMAIL_DOMAIN => sub {
431 __ # ZONE:Z09_ARPA_EMAIL_DOMAIN
432 'The zone is in the ARPA tree and has an unexpected MX RRset (non-Null MX).';
433 },
434 Z09_INCONSISTENT_MX => sub {
435 __ # ZONE:Z09_INCONSISTENT_MX
436 'Some name servers return an MX RRset while others return none.';
437 },
438 Z09_INCONSISTENT_MX_DATA => sub {
439 __ # ZONE:Z09_INCONSISTENT_MX_DATA
440 'The MX RRset data is inconsistent between the name servers.';
441 },
442 Z09_MISSING_MAIL_EXCHANGE => sub {
443 __x # ZONE:Z09_MISSING_MAIL_EXCHANGE
444 'The child zone has no mail exchange (no MX), as returned by name servers "{ns_list}".', @_;
445 },
446 Z09_MX_DATA => sub {
447 __x # ZONE:Z09_MX_DATA
448 'The MX RDATA in the MX RRset, "{mxrdata_list}", as returned by name servers "{ns_list}".', @_;
449 },
450 Z09_MX_FOUND => sub {
451 __x # ZONE:Z09_MX_FOUND
452 'MX RRset was returned by name servers "{ns_list}".', @_;
453 },
454 Z09_NON_AUTH_MX_RESPONSE => sub {
455 __x # ZONE:Z09_NON_AUTH_MX_RESPONSE
456 'Non-authoritative response on MX query from name servers "{ns_list}".', @_;
457 },
458 Z09_NO_MX_FOUND => sub {
459 __x # ZONE:Z09_NO_MX_FOUND
460 'No MX RRset was returned by name servers "{ns_list}".', @_;
461 },
462 Z09_NO_MX_FOUND_OR_EXPECTED => sub {
463 __ # ZONE:Z09_NO_MX_FOUND_OR_EXPECTED
464 'MX RRset was neither found nor expected for the zone.';
465 },
466 Z09_NO_SERVERS_MX_RESPONSE => sub {
467 __ # ZONE:Z09_NO_SERVERS_MX_RESPONSE
468 'No server responds to MX query.';
469 },
470 Z09_NO_RESPONSE_MX_QUERY => sub {
471 __x # ZONE:Z09_NO_RESPONSE_MX_QUERY
472 'No response on MX query from name servers "{ns_list}".', @_;
473 },
474 Z09_NULL_MX_NON_ZERO_PREF => sub {
475 __ # ZONE:Z09_NULL_MX_NON_ZERO_PREF
476 'The zone has a Null MX with non-zero preference.';
477 },
478 Z09_NULL_MX_WITH_OTHER_MX => sub {
479 __ # ZONE:Z09_NULL_MX_WITH_OTHER_MX
480 'The zone has a Null MX mixed with other MX records.';
481 },
482 Z09_ROOT_EMAIL_DOMAIN => sub {
483 __ # ZONE:Z09_ROOT_EMAIL_DOMAIN
484 'Root zone with an unexpected MX RRset (non-Null MX).';
485 },
486 Z09_TLD_EMAIL_DOMAIN => sub {
487 __ # ZONE:Z09_TLD_EMAIL_DOMAIN
488 'The zone is a TLD and has an unexpected MX RRset (non-Null MX).';
489 },
490 Z09_UNEXPECTED_RCODE_MX => sub {
491 __x # ZONE:Z09_UNEXPECTED_RCODE_MX
492 'Unexpected RCODE name ({rcode}) in response to MX query. Responses from name servers "{ns_list}".', @_;
493 },
494 Z09_VALID_NULL_MX => sub {
495 __ # ZONE:Z09_VALID_NULL_MX
496 'The zone has a valid Null MX record as the only MX record.';
497 },
498 Z11_DIFFERENT_SPF_POLICIES_FOUND => sub {
499 __x # ZONE:Z11_DIFFERENT_SPF_POLICIES_FOUND
500 'The following name servers returned the same SPF policy. Name servers: {ns_list}.',
501 @_;
502 },
503 Z11_INCONSISTENT_SPF_POLICIES => sub {
504 __ # ZONE:Z11_INCONSISTENT_SPF_POLICIES
505 'One or more name servers do not publish the same SPF policy as the others.';
506 },
507 Z11_NO_SPF_FOUND => sub {
508 __x # ZONE:Z11_NO_SPF_FOUND
509 'No SPF policy was found for {domain}.',
510 @_;
511 },
512 Z11_NO_SPF_NON_MAIL_DOMAIN => sub {
513 __x # ZONE:Z11_NO_SPF_NON_MAIL_DOMAIN
514 'No SPF policy was found for {domain}, which is a type of domain (root, TLD or under .ARPA) '
515 . 'not expected to be used for email.',
516 @_;
517 },
518 Z11_NON_NULL_SPF_NON_MAIL_DOMAIN => sub {
519 __x # ZONE:Z11_NON_NULL_SPF_NON_MAIL_DOMAIN
520 'A non-null SPF policy was found on {domain}, although this type of domain (root, TLD or '
521 . 'under .ARPA) is not expected to be used for email.',
522 @_;
523 },
524 Z11_NULL_SPF_NON_MAIL_DOMAIN => sub {
525 __x # ZONE:Z11_NULL_SPF_NON_MAIL_DOMAIN
526 'A null SPF policy was found on {domain}, which is a type of domain (root, TLD or under .ARPA) '
527 . 'not expected to be used for email.',
528 @_;
529 },
530 Z11_SPF_MULTIPLE_RECORDS => sub {
531 __x # ZONE:Z11_SPF_MULTIPLE_RECORDS
532 'The following name servers returned more than one SPF policy. Name servers: {ns_list}.',
533 @_;
534 },
535 Z11_SPF_SYNTAX_ERROR => sub {
536 __x # ZONE:Z11_SPF_SYNTAX_ERROR
537 'The SPF policy of {domain} has a syntax error. Policy retrieved from the following nameservers: {ns_list}.',
538 @_;
539 },
540 Z11_SPF_SYNTAX_OK => sub {
541 __x # ZONE:Z11_SPF_SYNTAX_OK
542 'The SPF policy of {domain} has correct syntax.',
543 @_;
544 },
545 Z11_UNABLE_TO_CHECK_FOR_SPF => sub {
546 __ # ZONE:Z11_UNABLE_TO_CHECK_FOR_SPF
547 'None of the zone’s name servers responded with an authoritative response to queries for SPF policies.';
548 },
549 );
550  
551 =over
552  
553 =item tag_descriptions()
554  
555 my $hash_ref = tag_descriptions();
556  
557 Used by the L<built-in translation system|Zonemaster::Engine::Translator>.
558  
559 Returns a reference to a hash, the keys of which are the message tags and the corresponding values are strings (message IDs).
560  
561 =back
562  
563 =cut
564  
565 sub tag_descriptions {
566 return \%TAG_DESCRIPTIONS;
567 }
568  
569 =over
570  
571 =item version()
572  
573 my $version_string = version();
574  
575 Returns a string containing the version of the current module.
576  
577 =back
578  
579 =cut
580  
581 sub version {
582 return "$Zonemaster::Engine::Test::Zone::VERSION";
583 }
584  
585 =head1 INTERNAL METHODS
586  
587 =over
588  
589 =item _emit_log()
590  
591 my $log_entry = _emit_log( $message_tag_string, $hash_ref );
592  
593 Adds a message to the L<logger|Zonemaster::Engine::Logger> for this module.
594 See L<Zonemaster::Engine::Logger::Entry/add($tag, $argref, $module, $testcase)> for more details.
595  
596 Takes a string (message tag) and a reference to a hash (arguments).
597  
598 Returns a L<Zonemaster::Engine::Logger::Entry> object.
599  
600 =back
601  
602 =cut
603  
604 sub _emit_log { my ( $tag, $argref ) = @_; return Zonemaster::Engine->logger->add( $tag, $argref, 'Zone' ); }
605  
606 =over
607  
608 =item _ip_disabled_message()
609  
610 my $bool = _ip_disabled_message( $logentry_array_ref, $ns, @query_type_string );
611  
612 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.
613  
614 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).
615  
616 Returns a boolean.
617  
618 =back
619  
620 =cut
621  
622 sub _ip_disabled_message {
623 my ( $results_array, $ns, @rrtypes ) = @_;
624  
625 if ( not Zonemaster::Engine::Profile->effective->get(q{net.ipv6}) and $ns->address->version == $IP_VERSION_6 ) {
626 push @$results_array, map {
627 _emit_log(
628 IPV6_DISABLED => {
629 ns => $ns->string,
630 rrtype => $_
631 }
632 )
633 } @rrtypes;
634 return 1;
635 }
636  
637 if ( not Zonemaster::Engine::Profile->effective->get(q{net.ipv4}) and $ns->address->version == $IP_VERSION_4 ) {
638 push @$results_array, map {
639 _emit_log(
640 IPV4_DISABLED => {
641 ns => $ns->string,
642 rrtype => $_,
643 }
644 )
645 } @rrtypes;
646 return 1;
647 }
648 return 0;
649 }
650  
651 =over
652  
653 =item _retrieve_record_from_zone()
654  
655 my $packet = _retrieve_record_from_zone( $logentry_array_ref, $zone, $name, $query_type_string );
656  
657 Retrieves resource records of given type for the given name from the response of the first authoritative server of the given zone that has at least one.
658 Used as an helper function for Test Cases L<Zone02|/zone02()> to L<Zone07|/zone07()>.
659  
660 Takes a reference to an array of L<Zonemaster::Engine::Logger::Entry> objects, a L<Zonemaster::Engine::Zone> object, a L<Zonemaster::Engine::DNSName> object and a string (query type).
661  
662 Returns a L<Zonemaster::Engine::Packet> object, or C<undef>.
663  
664 =back
665  
666 =cut
667  
668 sub _retrieve_record_from_zone {
669 my ( $results_array, $zone, $name, $type ) = @_;
670  
671 foreach my $ns ( @{ Zonemaster::Engine::TestMethods->method5( $zone ) } ) {
672  
673 if ( _ip_disabled_message( $results_array, $ns, $type ) ) {
674 next;
675 }
676  
677 my $p = $ns->query( $name, $type );
678  
679 if ( defined $p and scalar $p->get_records( $type, q{answer} ) > 0 ) {
680 return $p if $p->aa;
681 }
682 }
683  
684 return;
685 }
686  
687 =over
688  
689 =item _is_non_mail_domain()
690  
691 _is_non_mail_domain( $domain );
692  
693 Returns true if C<$domain> is a domain that should not be used for email: the
694 root domain, a TLD or a domain under the C<arpa> TLD.
695  
696 The C<$domain> argument is assumed to be a L<Zonemaster::Engine::DNSName>
697 object.
698  
699 =back
700  
701 =cut
702  
703 sub _is_non_mail_domain {
704 my $domain = shift;
705  
706 return ( $domain eq '.' or $domain->next_higher eq '.' or $domain =~ /\.arpa$/i );
707 }
708  
709 =over
710  
711 =item _spf_syntax_ok()
712  
713 _spf_syntax_ok( $spf_string );
714  
715 Attempts to run L<Mail::SPF::v1::Record/new_from_string($text, %options)> on the provided string.
716  
717 Takes a string (SPF text).
718  
719 =back
720  
721 =cut
722  
723 sub _spf_syntax_ok {
724 my $spf = shift;
725  
726 try {
727 Mail::SPF::v1::Record->new_from_string($spf);
728 }
729 }
730  
731 =head1 TESTS
732  
733 =over
734  
735 =item zone01()
736  
737 my @logentry_array = zone01( $zone );
738  
739 Runs the L<Zone01 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Zone-TP/zone01.md>.
740  
741 Takes a L<Zonemaster::Engine::Zone> object.
742  
743 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
744  
745 =back
746  
747 =cut
748  
749 sub zone01 {
750 my ( $class, $zone ) = @_;
751  
752 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Zone01';
753 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
754  
755 my %mname_ns;
756 my @serial_ns;
757 my %mname_not_master;
758 my @mname_master;
759 my @mname_localhost;
760 my @mname_dot;
761  
762 foreach my $ns ( @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) } ){
763 if ( _ip_disabled_message( \@results, $ns, q{SOA} ) ){
764 next;
765 }
766  
767 my $p = $ns->query( $zone->name, q{SOA} );
768  
769 if ( not $p or $p->rcode ne q{NOERROR} or not $p->aa or not $p->get_records_for_name( q{SOA}, $zone->name ) ){
770 next;
771 }
772  
773 foreach my $soa_rr ( $p->get_records_for_name( q{SOA}, $zone->name ) ){
774 my $soa_mname = lc($soa_rr->mname);
775 $soa_mname =~ s/[.]\z//smx;
776  
777 if ( $soa_mname eq 'localhost' ){
778 push @mname_localhost, $ns->address->short;
779 }
780 elsif ( not $soa_mname ){
781 push @mname_dot, $ns->address->short;
782 }
783 else{
784 $mname_ns{$soa_mname} = undef;
785 }
786  
787 push @serial_ns, $soa_rr->serial;
788 }
789 }
790  
791 if ( scalar @mname_localhost ){
792 push @results, _emit_log( Z01_MNAME_IS_LOCALHOST => { ns_ip_list => join( q{;}, @mname_localhost ) } );
793 }
794  
795 if ( scalar @mname_dot ){
796 push @results, _emit_log( Z01_MNAME_IS_DOT => { ns_ip_list => join( q{;}, @mname_dot ) } );
797 }
798  
799 my $found_ip = 0;
800 my $found_serial = 0;
801  
802 foreach my $mname ( keys %mname_ns ){
803 if ( none { $_ eq $mname } @{ Zonemaster::Engine::TestMethods->method3( $zone ) } ){
804 push @results, _emit_log( Z01_MNAME_NOT_IN_NS_LIST => { nsname => $mname } );
805 }
806  
807 foreach my $ip ( Zonemaster::Engine::Recursor->get_addresses_for( $mname ) ){
808 $found_ip++;
809 $mname_ns{$mname}{$ip->short} = undef;
810 }
811  
812 if ( $found_ip ){
813 foreach my $ip ( keys %{ $mname_ns{$mname} } ){
814 if ( $ip eq '127.0.0.1' or $ip eq '::1' ){
815 push @results, _emit_log( Z01_MNAME_HAS_LOCALHOST_ADDR => { nsname => $mname, ns_ip => $ip } );
816 }
817 else{
818 my $ns = Zonemaster::Engine::Nameserver->new( { name => $mname, address => $ip } );
819  
820 if ( _ip_disabled_message( \@results, $ns, q{SOA} ) ){
821 next;
822 }
823  
824 my $p = $ns->query( $zone->name, q{SOA} );
825  
826 if ( $p ){
827 if ( $p->rcode eq q{NOERROR} and $p->get_records_for_name( q{SOA}, $zone->name, q{answer} ) ){
828 if ( not $p->aa ){
829 push @results, _emit_log( Z01_MNAME_NOT_AUTHORITATIVE => { ns => $ns->string } );
830 }
831 else {
832 $found_serial++;
833 my ( $rr ) = $p->get_records_for_name( q{SOA}, $zone->name, q{answer} );
834 $mname_ns{$mname}{$ip} = $rr->serial;
835 }
836 }
837 elsif ( $p->rcode ne q{NOERROR} ){
838 push @results, _emit_log( Z01_MNAME_UNEXPECTED_RCODE => { ns => $ns->string, rcode => $p->rcode } );
839 }
840 elsif ( not $p->get_records_for_name( q{SOA}, $zone->name, q{answer} ) ){
841 push @results, _emit_log( Z01_MNAME_MISSING_SOA_RECORD => { ns => $ns->string } );
842 }
843 }
844 else {
845 push @results, _emit_log( Z01_MNAME_NO_RESPONSE => { ns => $ns->string } );
846 }
847 }
848 }
849 }
850 else{
851 push @results, _emit_log( Z01_MNAME_NOT_RESOLVE => { nsname => $mname } );
852 }
853 }
854  
855 if ( $found_serial ){
856 foreach my $mname ( keys %mname_ns ){
857 MNAME_IP: foreach my $mname_ip ( keys %{ $mname_ns{$mname} } ){
858 my $mname_serial = $mname_ns{$mname}{$mname_ip};
859  
860 if ( not defined($mname_serial) ){
861 next;
862 }
863  
864 foreach my $serial ( uniq @serial_ns ){
865 if ( Zonemaster::Engine::Util::serial_gt( $serial, $mname_serial ) ){
866 $mname_not_master{$mname}{$mname_ip} = $mname_serial;
867 next MNAME_IP;
868 }
869 }
870  
871 push @mname_master, $mname . '/' . $mname_ip ;
872 }
873 }
874  
875 if ( %mname_not_master ){
876 push @results,
877 _emit_log(
878 Z01_MNAME_NOT_MASTER => {
879 ns_list => join( q{;}, sort map
880 {
881 my $mname = $_;
882 map { "$mname/$_" } keys %{ $mname_not_master{$_} }
883 }
884 keys %mname_not_master
885 ),
886 soaserial => max( uniq map { values %{ $mname_not_master{$_} } } keys %mname_not_master ),
887 soaserial_list => join( q{;}, uniq @serial_ns )
888 }
889 );
890 }
891  
892 if ( @mname_master ){
893 push @results,
894 _emit_log(
895 Z01_MNAME_IS_MASTER => {
896 ns_list => join( q{;}, sort @mname_master )
897 }
898 );
899 }
900 }
901  
902 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) )
903 } ## end sub zone01
904  
905 =over
906  
907 =item zone02()
908  
909 my @logentry_array = zone02( $zone );
910  
911 Runs the L<Zone02 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Zone-TP/zone02.md>.
912  
913 Takes a L<Zonemaster::Engine::Zone> object.
914  
915 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
916  
917 =back
918  
919 =cut
920  
921 sub zone02 {
922 my ( $class, $zone ) = @_;
923  
924 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Zone02';
925 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
926  
927 my $p = _retrieve_record_from_zone( \@results, $zone, $zone->name, q{SOA} );
928  
929 my $soa_refresh_minimum_value = Zonemaster::Engine::Profile->effective->get( q{test_cases_vars.zone02.SOA_REFRESH_MINIMUM_VALUE} );
930  
931 if ( $p and my ( $soa ) = $p->get_records( q{SOA}, q{answer} ) ) {
932 my $soa_refresh = $soa->refresh;
933 if ( $soa_refresh < $soa_refresh_minimum_value ) {
934 push @results,
935 _emit_log(
936 REFRESH_MINIMUM_VALUE_LOWER => {
937 refresh => $soa_refresh,
938 required_refresh => $soa_refresh_minimum_value,
939 }
940 );
941 }
942 else {
943 push @results,
944 _emit_log(
945 REFRESH_MINIMUM_VALUE_OK => {
946 refresh => $soa_refresh,
947 required_refresh => $soa_refresh_minimum_value,
948 }
949 );
950 }
951 } ## end if ( $p and my ( $soa ...))
952 else {
953 push @results, _emit_log( NO_RESPONSE_SOA_QUERY => {} );
954 }
955  
956 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) )
957 } ## end sub zone02
958  
959 =over
960  
961 =item zone03()
962  
963 my @logentry_array = zone03( $zone );
964  
965 Runs the L<Zone03 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Zone-TP/zone03.md>.
966  
967 Takes a L<Zonemaster::Engine::Zone> object.
968  
969 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
970  
971 =back
972  
973 =cut
974  
975 sub zone03 {
976 my ( $class, $zone ) = @_;
977  
978 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Zone03';
979 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
980  
981 my $p = _retrieve_record_from_zone( \@results, $zone, $zone->name, q{SOA} );
982  
983 if ( $p and my ( $soa ) = $p->get_records( q{SOA}, q{answer} ) ) {
984 my $soa_retry = $soa->retry;
985 my $soa_refresh = $soa->refresh;
986 if ( $soa_retry >= $soa_refresh ) {
987 push @results,
988 _emit_log(
989 REFRESH_LOWER_THAN_RETRY => {
990 retry => $soa_retry,
991 refresh => $soa_refresh,
992 }
993 );
994 }
995 else {
996 push @results,
997 _emit_log(
998 REFRESH_HIGHER_THAN_RETRY => {
999 retry => $soa_retry,
1000 refresh => $soa_refresh,
1001 }
1002 );
1003 }
1004 } ## end if ( $p and my ( $soa ...))
1005 else {
1006 push @results, _emit_log( NO_RESPONSE_SOA_QUERY => {} );
1007 }
1008  
1009 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) )
1010 } ## end sub zone03
1011  
1012 =over
1013  
1014 =item zone04()
1015  
1016 my @logentry_array = zone04( $zone );
1017  
1018 Runs the L<Zone04 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Zone-TP/zone04.md>.
1019  
1020 Takes a L<Zonemaster::Engine::Zone> object.
1021  
1022 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
1023  
1024 =back
1025  
1026 =cut
1027  
1028 sub zone04 {
1029 my ( $class, $zone ) = @_;
1030  
1031 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Zone04';
1032 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
1033  
1034 my $p = _retrieve_record_from_zone( \@results, $zone, $zone->name, q{SOA} );
1035  
1036 my $soa_retry_minimum_value = Zonemaster::Engine::Profile->effective->get( q{test_cases_vars.zone04.SOA_RETRY_MINIMUM_VALUE} );
1037  
1038 if ( $p and my ( $soa ) = $p->get_records( q{SOA}, q{answer} ) ) {
1039 my $soa_retry = $soa->retry;
1040 if ( $soa_retry < $soa_retry_minimum_value ) {
1041 push @results,
1042 _emit_log(
1043 RETRY_MINIMUM_VALUE_LOWER => {
1044 retry => $soa_retry,
1045 required_retry => $soa_retry_minimum_value,
1046 }
1047 );
1048 }
1049 else {
1050 push @results,
1051 _emit_log(
1052 RETRY_MINIMUM_VALUE_OK => {
1053 retry => $soa_retry,
1054 required_retry => $soa_retry_minimum_value,
1055 }
1056 );
1057 }
1058 } ## end if ( $p and my ( $soa ...))
1059 else {
1060 push @results, _emit_log( NO_RESPONSE_SOA_QUERY => {} );
1061 }
1062  
1063 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) )
1064 } ## end sub zone04
1065  
1066 =over
1067  
1068 =item zone05()
1069  
1070 my @logentry_array = zone05( $zone );
1071  
1072 Runs the L<Zone05 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Zone-TP/zone05.md>.
1073  
1074 Takes a L<Zonemaster::Engine::Zone> object.
1075  
1076 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
1077  
1078 =back
1079  
1080 =cut
1081  
1082 sub zone05 {
1083 my ( $class, $zone ) = @_;
1084  
1085 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Zone05';
1086 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
1087  
1088 my $p = _retrieve_record_from_zone( \@results, $zone, $zone->name, q{SOA} );
1089  
1090 my $soa_expire_minimum_value = Zonemaster::Engine::Profile->effective->get( q{test_cases_vars.zone05.SOA_EXPIRE_MINIMUM_VALUE} );
1091  
1092 if ( $p and my ( $soa ) = $p->get_records( q{SOA}, q{answer} ) ) {
1093 my $soa_expire = $soa->expire;
1094 my $soa_refresh = $soa->refresh;
1095 if ( $soa_expire < $soa_expire_minimum_value ) {
1096 push @results,
1097 _emit_log(
1098 EXPIRE_MINIMUM_VALUE_LOWER => {
1099 expire => $soa_expire,
1100 required_expire => $soa_expire_minimum_value,
1101 }
1102 );
1103 }
1104 if ( $soa_expire < $soa_refresh ) {
1105 push @results,
1106 _emit_log(
1107 EXPIRE_LOWER_THAN_REFRESH => {
1108 expire => $soa_expire,
1109 refresh => $soa_refresh,
1110 }
1111 );
1112 }
1113 if ( not grep { $_->tag ne q{TEST_CASE_START} } @results ) {
1114 push @results,
1115 _emit_log(
1116 EXPIRE_MINIMUM_VALUE_OK => {
1117 expire => $soa_expire,
1118 refresh => $soa_refresh,
1119 required_expire => $soa_expire_minimum_value,
1120 }
1121 );
1122 }
1123 } ## end if ( $p and my ( $soa ...))
1124 else {
1125 push @results, _emit_log( NO_RESPONSE_SOA_QUERY => {} );
1126 }
1127  
1128 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) )
1129 } ## end sub zone05
1130  
1131 =over
1132  
1133 =item zone06()
1134  
1135 my @logentry_array = zone06( $zone );
1136  
1137 Runs the L<Zone06 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Zone-TP/zone06.md>.
1138  
1139 Takes a L<Zonemaster::Engine::Zone> object.
1140  
1141 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
1142  
1143 =back
1144  
1145 =cut
1146  
1147 sub zone06 {
1148 my ( $class, $zone ) = @_;
1149  
1150 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Zone06';
1151 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
1152  
1153 my $p = _retrieve_record_from_zone( \@results, $zone, $zone->name, q{SOA} );
1154  
1155 my $soa_default_ttl_maximum_value = Zonemaster::Engine::Profile->effective->get( q{test_cases_vars.zone06.SOA_DEFAULT_TTL_MAXIMUM_VALUE} );
1156 my $soa_default_ttl_minimum_value = Zonemaster::Engine::Profile->effective->get( q{test_cases_vars.zone06.SOA_DEFAULT_TTL_MINIMUM_VALUE} );
1157  
1158 if ( $p and my ( $soa ) = $p->get_records( q{SOA}, q{answer} ) ) {
1159 my $soa_minimum = $soa->minimum;
1160 if ( $soa_minimum > $soa_default_ttl_maximum_value ) {
1161 push @results,
1162 _emit_log(
1163 SOA_DEFAULT_TTL_MAXIMUM_VALUE_HIGHER => {
1164 minimum => $soa_minimum,
1165 highest_minimum => $soa_default_ttl_maximum_value,
1166 }
1167 );
1168 }
1169 elsif ( $soa_minimum < $soa_default_ttl_minimum_value ) {
1170 push @results,
1171 _emit_log(
1172 SOA_DEFAULT_TTL_MAXIMUM_VALUE_LOWER => {
1173 minimum => $soa_minimum,
1174 lowest_minimum => $soa_default_ttl_minimum_value,
1175 }
1176 );
1177 }
1178 else {
1179 push @results,
1180 _emit_log(
1181 SOA_DEFAULT_TTL_MAXIMUM_VALUE_OK => {
1182 minimum => $soa_minimum,
1183 highest_minimum => $soa_default_ttl_maximum_value,
1184 lowest_minimum => $soa_default_ttl_minimum_value,
1185 }
1186 );
1187 }
1188 } ## end if ( $p and my ( $soa ...))
1189 else {
1190 push @results, _emit_log( NO_RESPONSE_SOA_QUERY => {} );
1191 }
1192  
1193 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) )
1194 } ## end sub zone06
1195  
1196 =over
1197  
1198 =item zone07()
1199  
1200 my @logentry_array = zone07( $zone );
1201  
1202 Runs the L<Zone07 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Zone-TP/zone07.md>.
1203  
1204 Takes a L<Zonemaster::Engine::Zone> object.
1205  
1206 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
1207  
1208 =back
1209  
1210 =cut
1211  
1212 sub zone07 {
1213 my ( $class, $zone ) = @_;
1214  
1215 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Zone07';
1216 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
1217  
1218 my $p = _retrieve_record_from_zone( \@results, $zone, $zone->name, q{SOA} );
1219  
1220 if ( $p and my ( $soa ) = $p->get_records( q{SOA}, q{answer} ) ) {
1221 my $soa_mname = $soa->mname;
1222 $soa_mname =~ s/[.]\z//smx;
1223 my $addresses_nb = 0;
1224  
1225 foreach my $address_type ( q{A}, q{AAAA} ) {
1226 my $p_mname = Zonemaster::Engine::Recursor->recurse( $soa_mname, $address_type );
1227 if ( $p_mname ) {
1228 my $final_name = name( ($p_mname->question)[0]->owner ); # In case CNAME was followed during the recursive lookup
1229  
1230 if ( $p_mname->has_rrs_of_type_for_name( $address_type, $soa_mname ) or $p_mname->has_rrs_of_type_for_name( $address_type, $final_name ) ) {
1231 $addresses_nb++;
1232 }
1233  
1234 if ( $p_mname->has_rrs_of_type_for_name( q{CNAME}, $soa_mname ) or $final_name ne $soa_mname ) {
1235 push @results,
1236 _emit_log(
1237 MNAME_IS_CNAME => {
1238 mname => $soa_mname,
1239 }
1240 );
1241 }
1242 else {
1243 push @results,
1244 _emit_log(
1245 MNAME_IS_NOT_CNAME => {
1246 mname => $soa_mname,
1247 }
1248 );
1249 }
1250 } ## end if ( $p_mname )
1251 } ## end foreach my $address_type ( ...)
1252  
1253 if ( not $addresses_nb ) {
1254 push @results,
1255 _emit_log(
1256 MNAME_HAS_NO_ADDRESS => {
1257 mname => $soa_mname,
1258 }
1259 );
1260 }
1261 } ## end if ( $p and my ( $soa ...))
1262 else {
1263 push @results, _emit_log( NO_RESPONSE_SOA_QUERY => {} );
1264 }
1265  
1266 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) )
1267 } ## end sub zone07
1268  
1269 =over
1270  
1271 =item zone08()
1272  
1273 my @logentry_array = zone08( $zone );
1274  
1275 Runs the L<Zone08 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Zone-TP/zone08.md>.
1276  
1277 Takes a L<Zonemaster::Engine::Zone> object.
1278  
1279 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
1280  
1281 =back
1282  
1283 =cut
1284  
1285 sub zone08 {
1286 my ( $class, $zone ) = @_;
1287  
1288 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Zone08';
1289 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
1290  
1291 my $p = $zone->query_auth( $zone->name, q{MX} );
1292 if ( $p ) {
1293 my @mx = $p->get_records_for_name( q{MX}, $zone->name );
1294 for my $mx ( @mx ) {
1295 my $p2 = $zone->query_auth( $mx->exchange, q{CNAME} );
1296 if ( $p2 ) {
1297 if ( $p2->has_rrs_of_type_for_name( q{CNAME}, $mx->exchange ) ) {
1298 push @results, _emit_log( MX_RECORD_IS_CNAME => {} );
1299 }
1300 else {
1301 push @results, _emit_log( MX_RECORD_IS_NOT_CNAME => {} );
1302 }
1303 }
1304 }
1305 }
1306 else {
1307 push @results, _emit_log( NO_RESPONSE_MX_QUERY => {} );
1308 }
1309  
1310 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) )
1311 } ## end sub zone08
1312  
1313 =over
1314  
1315 =item zone09()
1316  
1317 my @logentry_array = zone09( $zone );
1318  
1319 Runs the L<Zone09 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Zone-TP/zone09.md>.
1320  
1321 Takes a L<Zonemaster::Engine::Zone> object.
1322  
1323 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
1324  
1325 =back
1326  
1327 =cut
1328  
1329 sub zone09 {
1330 my ( $class, $zone ) = @_;
1331  
1332 state sub sort_mx_records {
1333 sort {
1334 $a->preference() <=> $b->preference() or fc $a->exchange() cmp fc $b->exchange()
1335 } @_;
1336 }
1337  
1338 state sub mx_record_to_string {
1339 $_[0]->preference() . " " . lc( name( $_[0]->exchange() ) );
1340 }
1341  
1342 state sub sort_unique_mx_records {
1343 my %mx_hash = map { mx_record_to_string($_) => $_ } @_;
1344 sort_mx_records( values %mx_hash );
1345 }
1346  
1347 state sub ns_list {
1348 join( ';', sort @_ );
1349 }
1350  
1351 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Zone09';
1352 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
1353  
1354 my @nss = uniq grep { $_->isa('Zonemaster::Engine::Nameserver') } (
1355 @{ Zonemaster::Engine::TestMethodsV2->get_del_ns_names_and_ips( $zone ) // [] },
1356 @{ Zonemaster::Engine::TestMethodsV2->get_zone_ns_names_and_ips( $zone ) // [] }
1357 );
1358  
1359 my %ip_already_processed;
1360  
1361 my @no_response_mx;
1362 my %unexpected_rcode_mx;
1363 my @non_authoritative_mx;
1364 my @no_mx_set;
1365 my %mx_set;
1366  
1367  
1368 foreach my $ns ( @nss ) {
1369 my $ns_ip = $ns->address->short;
1370  
1371 next if exists $ip_already_processed{$ns_ip};
1372 $ip_already_processed{$ns_ip} = 1;
1373  
1374 if ( _ip_disabled_message( \@results, $ns, qw{SOA MX} ) ) {
1375 next;
1376 }
1377  
1378 my $p1 = $ns->query( $zone->name, q{SOA} );
1379  
1380 if ( not $p1 or $p1->rcode ne q{NOERROR} or not $p1->aa or not $p1->has_rrs_of_type_for_name(q{SOA}, $zone->name) ){
1381 next;
1382 }
1383  
1384 my $p2 = $ns->query( $zone->name, q{MX} );
1385  
1386 if ( not $p2 ){
1387 push @no_response_mx, $ns;
1388 }
1389 elsif ( $p2->rcode ne q{NOERROR} ) {
1390 push @{ $unexpected_rcode_mx{$p2->rcode} }, $ns;
1391 }
1392 elsif ( not $p2->aa ) {
1393 push @non_authoritative_mx, $ns;
1394 }
1395 else {
1396 my @sorted_mx_rrs = sort_unique_mx_records( $p2->get_records_for_name( q{MX}, $zone->name, q{answer} ) );
1397 my $mx_rrset_string = join ';', map mx_record_to_string($_), @sorted_mx_rrs;
1398  
1399 if ( !scalar @sorted_mx_rrs ) {
1400 push @no_mx_set, $ns;
1401 }
1402 elsif ( not exists $mx_set{$mx_rrset_string} ) {
1403 $mx_set{$mx_rrset_string} = {
1404 ns => [ $ns->string ],
1405 mx => \@sorted_mx_rrs
1406 };
1407 }
1408 else {
1409 push @{ $mx_set{$mx_rrset_string}{ns} }, $ns->string;
1410 }
1411 }
1412 }
1413  
1414 if ( scalar @no_response_mx ) {
1415 push @results, _emit_log( Z09_NO_RESPONSE_MX_QUERY => {
1416 ns_list => ns_list( @no_response_mx )
1417 } );
1418 }
1419  
1420 foreach my $rcode ( keys %unexpected_rcode_mx ) {
1421 push @results, _emit_log( Z09_UNEXPECTED_RCODE_MX => {
1422 rcode => $rcode,
1423 ns_list => ns_list( @{ $unexpected_rcode_mx{$rcode} } )
1424 } );
1425 }
1426  
1427 if ( scalar @non_authoritative_mx ) {
1428 push @results, _emit_log( Z09_NON_AUTH_MX_RESPONSE => {
1429 ns_list => ns_list( @non_authoritative_mx )
1430 } );
1431 }
1432  
1433 foreach my $mx_string ( keys %mx_set ) {
1434 push @results, _emit_log( Z09_MX_DATA => {
1435 ns_list => ns_list( @{ $mx_set{$mx_string}{ns} } ),
1436 mxrdata_list => $mx_string
1437 } );
1438 }
1439  
1440 if ( scalar @no_mx_set and scalar %mx_set ) {
1441 push @results,
1442 _emit_log( Z09_INCONSISTENT_MX => {} ),
1443 _emit_log( Z09_NO_MX_FOUND => { ns_list => ns_list( @no_mx_set ) } ),
1444 _emit_log( Z09_MX_FOUND => { ns_list => ns_list( map @{$_->{ns}}, values %mx_set ) } );
1445 }
1446  
1447 if ( scalar keys %mx_set > 1 ) {
1448 push @results, _emit_log( Z09_INCONSISTENT_MX_DATA => {} );
1449 }
1450 elsif ( scalar keys %mx_set == 1 ) {
1451 my @mx_records = @{ ( values %mx_set )[0]->{mx} };
1452  
1453 my ( $null_mx ) = grep { $_->exchange() eq '.' } @mx_records;
1454 if ( defined $null_mx ) {
1455 if ( scalar @mx_records > 1 ) {
1456 push @results, _emit_log( Z09_NULL_MX_WITH_OTHER_MX => {} );
1457 }
1458 elsif ( $null_mx->preference() != 0 ) {
1459 push @results, _emit_log( Z09_NULL_MX_NON_ZERO_PREF => {} );
1460 }
1461 else {
1462 push @results, _emit_log( Z09_VALID_NULL_MX => {} );
1463 }
1464 }
1465 else {
1466 if ( $zone->name eq '.' ) {
1467 push @results, _emit_log( Z09_ROOT_EMAIL_DOMAIN => {} );
1468 }
1469 elsif ( $zone->name->next_higher eq '.' ) {
1470 push @results, _emit_log( Z09_TLD_EMAIL_DOMAIN => {} );
1471 }
1472 elsif ( $zone->name =~ /\.arpa$/i ) {
1473 push @results, _emit_log( Z09_ARPA_EMAIL_DOMAIN => {} );
1474 }
1475 }
1476 }
1477  
1478 if ( scalar @no_mx_set and !scalar %mx_set ) {
1479 if ( _is_non_mail_domain($zone->name) ) {
1480 push @results, _emit_log( Z09_NO_MX_FOUND_OR_EXPECTED => {} );
1481 }
1482 else {
1483 push @results, _emit_log( Z09_MISSING_MAIL_EXCHANGE => { ns_list => ns_list( @no_mx_set ) } );
1484 }
1485 }
1486  
1487 if ( !scalar @no_mx_set and !scalar %mx_set ) {
1488 push @results, _emit_log( Z09_NO_SERVERS_MX_RESPONSE => {} );
1489 }
1490  
1491 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) )
1492 } ## end sub zone09
1493  
1494 =over
1495  
1496 =item zone10()
1497  
1498 my @logentry_array = zone10( $zone );
1499  
1500 Runs the L<Zone10 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Zone-TP/zone10.md>.
1501  
1502 Takes a L<Zonemaster::Engine::Zone> object.
1503  
1504 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
1505  
1506 =back
1507  
1508 =cut
1509  
1510 sub zone10 {
1511 my ( $class, $zone ) = @_;
1512  
1513 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Zone10';
1514 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
1515 my $name = name( $zone );
1516  
1517 foreach my $ns ( @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) } ) {
1518  
1519 if ( _ip_disabled_message( \@results, $ns, q{SOA} ) ) {
1520 next;
1521 }
1522  
1523 my $p = $ns->query( $name, q{SOA} );
1524  
1525 if ( not $p ) {
1526 push @results, _emit_log( NO_RESPONSE => { ns => $ns->string } );
1527 next;
1528 }
1529 else {
1530 my @soa = $p->get_records( q{SOA}, q{answer} );
1531 if ( scalar @soa ) {
1532 if ( scalar @soa > 1 ) {
1533 push @results,
1534 _emit_log(
1535 MULTIPLE_SOA => {
1536 ns => $ns->string,
1537 count => scalar @soa,
1538 }
1539 );
1540 }
1541 elsif ( lc( $soa[0]->owner ) ne lc( $name->fqdn ) ) {
1542 push @results,
1543 _emit_log(
1544 WRONG_SOA => {
1545 ns => $ns->string,
1546 owner => lc( $soa[0]->owner ),
1547 name => lc( $name->fqdn ),
1548 }
1549 );
1550 }
1551 } ## end if ( scalar @soa )
1552 else {
1553 push @results, _emit_log( NO_SOA_IN_RESPONSE => { ns => $ns->string } );
1554 }
1555 } ## end else [ if ( not $p ) ]
1556 } ## end foreach my $ns ( @{ Zonemaster::Engine::TestMethods...})
1557 if ( not grep { $_->tag ne q{TEST_CASE_START} } @results ) {
1558 push @results, _emit_log( ONE_SOA => {} );
1559 }
1560  
1561 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) )
1562 } ## end sub zone10
1563  
1564 =over
1565  
1566 =item zone11()
1567  
1568 my @logentry_array = zone11( $zone );
1569  
1570 Runs the L<Zone11 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Zone-TP/zone11.md>.
1571  
1572 Takes a L<Zonemaster::Engine::Zone> object.
1573  
1574 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
1575  
1576 =back
1577  
1578 =cut
1579  
1580 sub zone11 {
1581 my ( $class, $zone ) = @_;
1582  
1583 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Zone11';
1584 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
1585  
1586 # This hash maps nameserver IP addresses to arrayrefs of TXT resource
1587 # record data matching the signature for SPF policies. These arrays
1588 # usually contain at most one string.
1589  
1590 my %ns_spf;
1591  
1592 my @nss = uniq grep { $_->isa('Zonemaster::Engine::Nameserver') } (
1593 @{ Zonemaster::Engine::TestMethodsV2->get_del_ns_names_and_ips( $zone ) // [] },
1594 @{ Zonemaster::Engine::TestMethodsV2->get_zone_ns_names_and_ips( $zone ) // [] }
1595 );
1596  
1597 my %ip_already_processed;
1598 foreach my $ns ( @nss ) {
1599 my $ns_ip = $ns->address->short;
1600  
1601 next if exists $ip_already_processed{$ns_ip};
1602 $ip_already_processed{$ns_ip} = [ grep { $_->address->short eq $ns_ip } @nss ];
1603  
1604 if ( _ip_disabled_message( \@results, $ns, q{TXT} ) ) {
1605 next;
1606 }
1607  
1608 my $p = $ns->query( $zone->name, q{TXT} );
1609  
1610 if ( $p and $p->rcode eq q{NOERROR} and $p->aa ) {
1611 my @txt_rrs = $p->get_records_for_name( q{TXT}, $zone->name );
1612 my @txt_rdata = map { lc $_->txtdata() } @txt_rrs;
1613 my @spf1_policies = grep /\Av=spf1(?:\Z|\s+)/, @txt_rdata;
1614  
1615 $ns_spf{$ns_ip} = \@spf1_policies;
1616 }
1617 }
1618  
1619 # At this point, the values of %ns_spf contain *lists* of SPF policies.
1620 # There should be at most one item in each of those lists, but zones may
1621 # mistakenly publish more than one policy.
1622 #
1623 # We can’t use a list of strings directly as a hash key; we need flat
1624 # strings and a conversion method that can disambiguate between
1625 # [qw(a b c)] and [qw(ab c)]. The best method is to prefix each string in
1626 # the list with its length, then concatenate all of these strings
1627 # together. Hence, [qw(a b c)] becomes "<1>a<1>b<1>c" and [qw(ab c)]
1628 # becomes "<2>ab<1>c".
1629 my %spf_ns = ();
1630 for my $ns_ip ( keys %ns_spf ) {
1631 my @matching_nss = @{ $ip_already_processed{$ns_ip} };
1632 my $mangled_spfs = join '', map { sprintf '<%d>%s', length $_, $_ } sort @{$ns_spf{$ns_ip}};
1633 push @{$spf_ns{$mangled_spfs}}, @matching_nss;
1634 }
1635  
1636 if ( not scalar %ns_spf ) {
1637 push @results, _emit_log( Z11_UNABLE_TO_CHECK_FOR_SPF => {} );
1638 }
1639 elsif ( List::MoreUtils::all { $_ eq '' } keys %spf_ns ) {
1640 if ( _is_non_mail_domain( $zone->name ) ) {
1641 push @results, _emit_log( Z11_NO_SPF_NON_MAIL_DOMAIN => { domain => $zone->name } );
1642 }
1643 else {
1644 push @results, _emit_log( Z11_NO_SPF_FOUND => { domain => $zone->name } );
1645 }
1646 }
1647 elsif ( scalar keys %spf_ns > 1 ) {
1648 push @results, _emit_log( Z11_INCONSISTENT_SPF_POLICIES => {} );
1649  
1650 for my $ns ( values %spf_ns ) {
1651 push @results, _emit_log( Z11_DIFFERENT_SPF_POLICIES_FOUND => { ns_list => join( q{;}, sort @$ns ) } );
1652 }
1653 }
1654 elsif ( my @bad_ips = grep { scalar @{$ns_spf{$_}} > 1 } keys %ns_spf ) {
1655 push @results, _emit_log( Z11_SPF_MULTIPLE_RECORDS => { ns_list => join( q{;}, sort map { @{ $ip_already_processed{$_} } } @bad_ips ) } );
1656 }
1657 else {
1658 my $spf_text = (values %ns_spf)[0][0];
1659  
1660 if ( not _spf_syntax_ok( $spf_text ) ) {
1661 push @results, _emit_log( Z11_SPF_SYNTAX_ERROR => {
1662 ns_list => join( q{;}, sort map { @{ $ip_already_processed{$_} } } keys %ns_spf ),
1663 domain => $zone->name
1664 } );
1665 }
1666 elsif ( not _is_non_mail_domain( $zone->name ) ) {
1667 push @results, _emit_log( Z11_SPF_SYNTAX_OK => { domain => $zone->name } );
1668 }
1669 elsif ( $spf_text =~ /^v=spf1 [\ \t]+ -all [\ \t]* $/ix ) {
1670 push @results, _emit_log( Z11_NULL_SPF_NON_MAIL_DOMAIN => { domain => $zone->name } );
1671 }
1672 else {
1673 push @results, _emit_log( Z11_NON_NULL_SPF_NON_MAIL_DOMAIN => { domain => $zone->name } );
1674 }
1675 }
1676  
1677 return ( @results, info( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) )
1678 } ## end sub zone11
1679  
1680 1;