forked from sdgathman/pyspf
-
Notifications
You must be signed in to change notification settings - Fork 0
/
spf.py
executable file
·1918 lines (1683 loc) · 74.1 KB
/
spf.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
#!/usr/bin/python
from __future__ import print_function
"""SPF (Sender Policy Framework) implementation.
Copyright (c) 2003 Terence Way <[email protected]>
Portions Copyright(c) 2004,2005,2006,2007,2008,2011,2012 Stuart Gathman <[email protected]>
Portions Copyright(c) 2005,2006,2007,2008,2011,2012,2013,2014 Scott Kitterman <[email protected]>
Portions Copyright(c) 2013,2014 Stuart Gathman <[email protected]>
This module is free software, and you may redistribute it and/or modify
it under the same terms as Python itself, so long as this copyright message
and disclaimer are retained in their original form.
IN NO EVENT SHALL THE AUTHOR BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF
THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.
THE AUTHOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS,
AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
For more information about SPF, a tool against email forgery, see
http://www.openspf.net/
For news, bugfixes, etc. visit the home page for this implementation at
http://cheeseshop.python.org/pypi/pyspf/
http://sourceforge.net/projects/pymilter/
http://www.wayforward.net/spf/
"""
# CVS Commits since last release (2.0.12):
# Revision 1.108.2.152 2016/04/26 03:57:04 kitterma
# * Set version and update changelog for 2.0.13 development.
#
# Revision 1.108.2.151 2016/04/26 03:53:04 kitterma
# * Catch ValueError due to improper IP address in connect IP or in ip4/ip6
# mechanisms
#
# See pyspf_changelog.txt for earlier CVS commits.
__author__ = "Terence Way, Stuart Gathman, Scott Kitterman"
__email__ = "[email protected]"
__version__ = "2.1: UNRELEASED"
MODULE = 'spf'
USAGE = """To check an incoming mail request:
% python spf.py [-v] {ip} {sender} {helo}
% python spf.py 69.55.226.139 [email protected] mx1.wayforward.net
To test an SPF record:
% python spf.py [-v] "v=spf1..." {ip} {sender} {helo}
% python spf.py "v=spf1 +mx +ip4:10.0.0.1 -all" 10.0.0.1 [email protected] a
To fetch an SPF record:
% python spf.py {domain}
% python spf.py wayforward.net
To test this script (and to output this usage message):
% python spf.py
"""
import re
import sys
import socket # for inet_ntoa() and inet_aton()
import struct # for pack() and unpack()
import time # for time()
try:
import urllib.parse as urllibparse # for quote()
except:
import urllib as urllibparse
import sys # for version_info()
from functools import reduce
try:
from email.message import Message
except ImportError:
from email.Message import Message
try:
# Python standard libarary as of python3.3
if (sys.version_info > (3,0)):
import ipaddress
if bytes is str:
from ipaddress import Bytes
else:
raise ImportError()
except ImportError:
try:
import ipaddr as ipaddress
from ipaddr import Bytes
except ImportError:
print('ipaddr module required: http://code.google.com/p/ipaddr-py/')
def DNSLookup(name, qtype, strict=True, timeout=30):
try:
from SPF.pydns import DNSLookup
except:
from SPF.dnspython import DNSLookup
return DNSLookup(name, qtype, strict, timeout)
RE_SPF = re.compile(br'^v=spf1$|^v=spf1 ',re.IGNORECASE)
# Regular expression to look for modifiers
RE_MODIFIER = re.compile(r'^([a-z][a-z0-9_\-\.]*)=', re.IGNORECASE)
# Regular expression to find macro expansions
PAT_CHAR = r'%(%|_|-|(\{[^\}]*\}))'
RE_CHAR = re.compile(PAT_CHAR)
RE_INVALID_MACRO = re.compile(r'(?<!%)%[^{%_-]|%$')
# Regular expression to break up a macro expansion
RE_ARGS = re.compile(r'([0-9]*)(r?)([^0-9a-zA-Z]*)')
RE_DUAL_CIDR = re.compile(r'//(0|[1-9]\d*)$')
RE_CIDR = re.compile(r'/(0|[1-9]\d*)$')
PAT_IP4 = r'\.'.join([r'(?:\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])']*4)
RE_IP4 = re.compile(PAT_IP4+'$')
RE_TOPLAB = re.compile(
r'\.(?:[0-9a-z]*[a-z][0-9a-z]*|[0-9a-z]+-[0-9a-z-]*[0-9a-z])\.?$|%s'
% PAT_CHAR, re.IGNORECASE)
RE_DOT_ATOM = re.compile(r'%(atext)s+([.]%(atext)s+)*$' % {
'atext': r"[0-9a-z!#$%&'*+/=?^_`{}|~-]" }, re.IGNORECASE)
# Derived from RFC 3986 appendix A
RE_IP6 = re.compile( '(?:%(hex4)s:){6}%(ls32)s$'
'|::(?:%(hex4)s:){5}%(ls32)s$'
'|(?:%(hex4)s)?::(?:%(hex4)s:){4}%(ls32)s$'
'|(?:(?:%(hex4)s:){0,1}%(hex4)s)?::(?:%(hex4)s:){3}%(ls32)s$'
'|(?:(?:%(hex4)s:){0,2}%(hex4)s)?::(?:%(hex4)s:){2}%(ls32)s$'
'|(?:(?:%(hex4)s:){0,3}%(hex4)s)?::%(hex4)s:%(ls32)s$'
'|(?:(?:%(hex4)s:){0,4}%(hex4)s)?::%(ls32)s$'
'|(?:(?:%(hex4)s:){0,5}%(hex4)s)?::%(hex4)s$'
'|(?:(?:%(hex4)s:){0,6}%(hex4)s)?::$'
% {
'ls32': r'(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|%s)'%PAT_IP4,
'hex4': r'[0-9a-f]{1,4}'
}, re.IGNORECASE)
# Local parts and senders have their delimiters replaced with '.' during
# macro expansion
#
JOINERS = {'l': '.', 's': '.'}
RESULTS = {'+': 'pass', '-': 'fail', '?': 'neutral', '~': 'softfail',
'pass': 'pass', 'fail': 'fail', 'permerror': 'permerror',
'error': 'temperror', 'neutral': 'neutral', 'softfail': 'softfail',
'none': 'none', 'local': 'local', 'trusted': 'trusted',
'ambiguous': 'ambiguous', 'unknown': 'permerror' }
EXPLANATIONS = {'pass': 'sender SPF authorized',
'fail': 'SPF fail - not authorized',
'permerror': 'permanent error in processing',
'temperror': 'temporary DNS error in processing',
'softfail': 'domain owner discourages use of this host',
'neutral': 'access neither permitted nor denied',
'none': '',
#Note: The following are not formally SPF results
'local': 'No SPF result due to local policy',
'trusted': 'No SPF check - trusted-forwarder.org',
#Ambiguous only used in harsh mode for SPF validation
'ambiguous': 'No error, but results may vary'
}
DELEGATE = None
# standard default SPF record for best_guess
DEFAULT_SPF = 'v=spf1 a/24 mx/24 ptr'
#Whitelisted forwarders here. Additional locally trusted forwarders can be
#added to this record.
TRUSTED_FORWARDERS = 'v=spf1 ?include:spf.trusted-forwarder.org -all'
# maximum DNS lookups allowed
MAX_LOOKUP = 10 #RFC 4408 Para 10.1/RFC 7208 4.6.4
MAX_MX = 10 #RFC 4408 Para 10.1/RFC 7208 4.6.4
MAX_PTR = 10 #RFC 4408 Para 10.1/RFC 7208 4.6.4
MAX_CNAME = 10 # analogous interpretation to MAX_PTR
MAX_RECURSION = 20
MAX_PER_LOOKUP_TIME = 20 # Per RFC 7208 4.6.4
MAX_VOID_LOOKUPS = 2 # RFC 7208 4.6.4
ALL_MECHANISMS = ('a', 'mx', 'ptr', 'exists', 'include', 'ip4', 'ip6', 'all')
COMMON_MISTAKES = {
'prt': 'ptr', 'ip': 'ip4', 'ipv4': 'ip4', 'ipv6': 'ip6', 'all.': 'all'
}
#If harsh processing, for the validator, is invoked, warn if results
#likely deviate from the publishers intention.
class AmbiguityWarning(Exception):
"SPF Warning - ambiguous results"
def __init__(self, msg, mech=None, ext=None):
Exception.__init__(self, msg, mech)
self.msg = msg
self.mech = mech
self.ext = ext
def __str__(self):
if self.mech:
return '%s: %s' %(self.msg, self.mech)
return self.msg
class TempError(Exception):
"Temporary SPF error"
def __init__(self, msg, mech=None, ext=None):
Exception.__init__(self, msg, mech)
self.msg = str(msg)
self.mech = mech
self.ext = ext
def __str__(self):
if self.mech:
return '%s: %s'%(self.msg, self.mech)
return self.msg
class PermError(Exception):
"Permanent SPF error"
def __init__(self, msg, mech=None, ext=None):
Exception.__init__(self, msg, mech)
self.msg = msg
self.mech = mech
self.ext = ext
def __str__(self):
if self.mech:
return '%s: %s'%(self.msg, self.mech)
return self.msg
def check2(i, s, h, local=None, receiver=None, timeout=MAX_PER_LOOKUP_TIME, verbose=False, querytime=20):
"""Test an incoming MAIL FROM:<s>, from a client with ip address i.
h is the HELO/EHLO domain name. This is the RFC4408/7208 compliant
pySPF2.0 interface. The interface returns an SPF result and explanation
only. SMTP response codes are not returned since neither RFC 4408 nor RFC
7208 does specify receiver policy. Applications updated for RFC 4408 and
RFC 7208 should use this interface. The maximum time, in seconds, this
function is allowed to run before a TempError is returned is controlled by
querytime. When set to 0 the timeout parameter (default 20 seconds)
controls the time allowed for each DNS lookup. When set to a non-zero
value, it total time for all processing related to the SPF check is
limited to querytime (default 20 seconds as recommended in RFC 7208,
paragraph 4.6.4).
Returns (result, explanation) where result in
['pass', 'permerror', 'fail', 'temperror', 'softfail', 'none', 'neutral' ].
Example:
#>>> check2(i='61.51.192.42', s='[email protected]', h='bmsi.com')
"""
res,_,exp = query(i=i, s=s, h=h, local=local,
receiver=receiver,timeout=timeout,verbose=verbose,querytime=querytime).check()
return res,exp
def check(i, s, h, local=None, receiver=None, verbose=False):
"""Test an incoming MAIL FROM:<s>, from a client with ip address i.
h is the HELO/EHLO domain name. This is the pre-RFC SPF Classic interface.
Applications written for pySPF 1.6/1.7 can use this interface to allow
pySPF2 to be a drop in replacement for older versions. With the exception
of result codes, performance in RFC 4408 compliant.
Returns (result, code, explanation) where result in
['pass', 'unknown', 'fail', 'error', 'softfail', 'none', 'neutral' ].
Example:
#>>> check(i='61.51.192.42', s='[email protected]', h='bmsi.com')
"""
res,code,exp = query(i=i, s=s, h=h, local=local, receiver=receiver,
verbose=verbose).check()
if res == 'permerror':
res = 'unknown'
elif res == 'tempfail':
res =='error'
return res, code, exp
class query(object):
"""A query object keeps the relevant information about a single SPF query:
- i: ip address of SMTP client in dotted notation
- s: sender declared in MAIL FROM:<>
- l: local part of sender s
- d: current domain, initially domain part of sender s
- h: EHLO/HELO domain
- v: 'in-addr' for IPv4 clients and 'ip6' for IPv6 clients
- t: current timestamp
- p: SMTP client domain name
- o: domain part of sender s
- r: receiver
- c: pretty ip address (different from i for IPv6)
This is also, by design, the same variables used in SPF macro
expansion.
Also keeps cache: DNS cache.
"""
def __init__(self, i, s, h, local=None, receiver=None, strict=True,
timeout=MAX_PER_LOOKUP_TIME,verbose=False,querytime=0):
self.s, self.h = s, h
if not s and h:
self.s = 'postmaster@' + h
self.ident = 'helo'
else:
self.ident = 'mailfrom'
self.l, self.o = split_email(s, h)
self.t = str(int(time.time()))
self.d = self.o
self.p = None # lazy evaluation
if receiver:
self.r = receiver
else:
self.r = 'unknown'
# Since the cache does not track Time To Live, it is created
# fresh for each query. It is important for efficiently using
# multiple results provided in DNS answers.
self.cache = {}
self.defexps = dict(EXPLANATIONS)
self.exps = dict(EXPLANATIONS)
self.libspf_local = local # local policy
self.lookups = 0
# New processing limit in RFC 7208, section 4.6.4
self.void_lookups = 0
# strict can be False, True, or 2 (numeric) for harsh
self.strict = strict
self.timeout = timeout
self.querytime = querytime # Default to not using a global check
# timelimit since this is an RFC 4408 MAY
if querytime > 0:
self.timeout = querytime
self.timer = 0
self.ipaddr = None
if i:
self.set_ip(i)
# Document bits of the object model not set up here:
# self.i = string, expanded dot notation, suitable for PTR lookups
# self.c = string, human readable form of the connect IP address
# single letter lowercase variable names (e.g. self.i) are used for SPF macros
# For IPv4, self.i = self.c, but not in IPv6
# self.iplist = list of IPv4/6 addresses that would pass, collected
# when list or list6 is passed as 'i'
# self.addr = ipaddr/ipaddress object representing the connect IP
self.default_modifier = True
self.verbose = verbose
self.authserv = None # Only used in A-R header generation tests
def log(self,mech,d,spf):
print('%s: %s "%s"'%(mech,d,spf))
def set_ip(self, i):
"Set connect ip, and ip6 or ip4 mode."
self.iplist = False
if i.lower() == 'list':
self.iplist = []
ip6 = False
elif i.lower() == 'list6':
self.iplist = []
ip6 = True
else:
try:
try:
self.ipaddr = ipaddress.ip_address(i)
except AttributeError:
self.ipaddr = ipaddress.IPAddress(i)
except ValueError as x:
raise PermError(str(x))
if self.ipaddr.version == 6:
if self.ipaddr.ipv4_mapped:
self.ipaddr = ipaddress.IPv4Address(self.ipaddr.ipv4_mapped)
ip6 = False
else:
ip6 = True
else:
ip6 = False
self.c = str(self.ipaddr)
# NOTE: self.A is not lowercase, so isn't a macro. See query.expand()
if ip6:
self.A = 'AAAA'
self.v = 'ip6'
if self.ipaddr:
self.i = '.'.join(list(self.ipaddr.exploded.replace(':','').upper()))
self.cidrmax = 128
else:
self.A = 'A'
self.v = 'in-addr'
if self.ipaddr:
self.i = self.ipaddr.exploded
self.cidrmax = 32
def set_default_explanation(self, exp):
exps = self.exps
defexps = self.defexps
for i in 'softfail', 'fail', 'permerror':
exps[i] = exp
defexps[i] = exp
def set_explanation(self, exp):
exps = self.exps
for i in 'softfail', 'fail', 'permerror':
exps[i] = exp
# Compute p macro only if needed
def getp(self):
if not self.p:
p = self.validated_ptrs()
if not p:
self.p = "unknown"
elif self.d in p:
self.p = self.d
else:
sfx = '.' + self.d
for d in p:
if d.endswith(sfx):
self.p = d
break
else:
self.p = p[0]
return self.p
def best_guess(self, spf=DEFAULT_SPF):
"""Return a best guess based on a default SPF record.
>>> q = query('1.2.3.4','','SUPERVISION1',receiver='example.com')
>>> q.best_guess()[0]
'none'
"""
if RE_TOPLAB.split(self.d)[-1]:
return ('none', 250, '')
pe = self.perm_error
r,c,e = self.check(spf)
if r == 'permerror': # permerror not useful for bestguess
if self.perm_error and self.perm_error.ext:
r,c,e = self.perm_error.ext
else:
r,c = 'neutral',250
self.perm_error = pe
return r,c,e
def check(self, spf=None):
"""
Returns (result, mta-status-code, explanation) where result
in ['fail', 'softfail', 'neutral' 'permerror', 'pass', 'temperror', 'none']
Examples:
>>> q = query(s='[email protected]',
... h='mx.example.org', i='192.0.2.3')
>>> q.check(spf='v=spf1 ?all')
('neutral', 250, 'access neither permitted nor denied')
>>> q.check(spf='v=spf1 redirect=controlledmail.com exp=_exp.controlledmail.com')
('fail', 550, 'SPF fail - not authorized')
>>> q.check(spf='v=spf1 ip4:192.0.0.0/8 ?all moo')
('permerror', 550, 'SPF Permanent Error: Unknown mechanism found: moo')
>>> q.check(spf='v=spf1 ip4:192.0.0.n ?all')
('permerror', 550, 'SPF Permanent Error: Invalid IP4 address: ip4:192.0.0.n')
>>> q.check(spf='v=spf1 ip4:192.0.2.3 ip4:192.0.0.n ?all')
('permerror', 550, 'SPF Permanent Error: Invalid IP4 address: ip4:192.0.0.n')
>>> q.check(spf='v=spf1 ip6:2001:db8:ZZZZ:: ?all')
('permerror', 550, 'SPF Permanent Error: Invalid IP6 address: ip6:2001:db8:ZZZZ::')
>>> q.check(spf='v=spf1 =a ?all moo')
('permerror', 550, 'SPF Permanent Error: Unknown qualifier, RFC 4408 para 4.6.1, found in: =a')
>>> q.check(spf='v=spf1 ip4:192.0.0.0/8 ~all')
('pass', 250, 'sender SPF authorized')
>>> q.check(spf='v=spf1 ip4:192.0.0.0/8 -all moo=')
('pass', 250, 'sender SPF authorized')
>>> q.check(spf='v=spf1 ip4:192.0.0.0/8 -all match.sub-domains_9=yes')
('pass', 250, 'sender SPF authorized')
>>> q.strict = False
>>> q.check(spf='v=spf1 ip4:192.0.0.0/8 -all moo')
('permerror', 550, 'SPF Permanent Error: Unknown mechanism found: moo')
>>> q.perm_error.ext
('pass', 250, 'sender SPF authorized')
>>> q.strict = True
>>> q.check(spf='v=spf1 ip4:192.1.0.0/16 moo -all')
('permerror', 550, 'SPF Permanent Error: Unknown mechanism found: moo')
>>> q.check(spf='v=spf1 ip4:192.1.0.0/16 ~all')
('softfail', 250, 'domain owner discourages use of this host')
>>> q.check(spf='v=spf1 -ip4:192.1.0.0/6 ~all')
('fail', 550, 'SPF fail - not authorized')
# Assumes DNS available
>>> q.check()
('none', 250, '')
>>> q.check(spf='v=spf1 ip4:1.2.3.4 -a:example.net -all')
('fail', 550, 'SPF fail - not authorized')
>>> q.libspf_local='ip4:192.0.2.3 a:example.org'
>>> q.check(spf='v=spf1 ip4:1.2.3.4 -a:example.net -all')
('pass', 250, 'sender SPF authorized')
>>> q.check(spf='v=spf1 ip4:1.2.3.4 -all exp=_exp.controlledmail.com')
('fail', 550, 'Controlledmail.com does not send mail from itself.')
>>> q.check(spf='v=spf1 ip4:1.2.3.4 ?all exp=_exp.controlledmail.com')
('neutral', 250, 'access neither permitted nor denied')
"""
self.mech = [] # unknown mechanisms
# If not strict, certain PermErrors (mispelled
# mechanisms, strict processing limits exceeded)
# will continue processing. However, the exception
# that strict processing would raise is saved here
self.perm_error = None
self.mechanism = None
self.void_lookups = 0
self.options = {}
try:
self.lookups = 0
if not spf:
spf = self.dns_spf(self.d)
if self.verbose: self.log("top",self.d,spf)
if self.libspf_local and spf:
spf = insert_libspf_local_policy(
spf, self.libspf_local)
rc = self.check1(spf, self.d, 0)
if self.perm_error:
# lax processing encountered a permerror, but continued
self.perm_error.ext = rc
raise self.perm_error
return rc
except TempError as x:
self.prob = x.msg
if x.mech:
self.mech.append(x.mech)
return ('temperror', 451, 'SPF Temporary Error: ' + str(x))
except PermError as x:
if not self.perm_error:
self.perm_error = x
self.prob = x.msg
if x.mech:
self.mech.append(x.mech)
# Pre-Lentczner draft treats this as an unknown result
# and equivalent to no SPF record.
return ('permerror', 550, 'SPF Permanent Error: ' + str(x))
def check1(self, spf, domain, recursion):
# spf rfc: 3.7 Processing Limits
#
if recursion > MAX_RECURSION:
# This should never happen in strict mode
# because of the other limits we check,
# so if it does, there is something wrong with
# our code. It is not a PermError because there is not
# necessarily anything wrong with the SPF record.
if self.strict:
raise AssertionError('Too many levels of recursion')
# As an extended result, however, it should be
# a PermError.
raise PermError('Too many levels of recursion')
try:
try:
tmp, self.d = self.d, domain
return self.check0(spf, recursion)
finally:
self.d = tmp
except AmbiguityWarning as x:
self.prob = x.msg
if x.mech:
self.mech.append(x.mech)
return ('ambiguous', 000, 'SPF Ambiguity Warning: %s' % x)
def note_error(self, *msg):
if self.strict:
raise PermError(*msg)
# if lax mode, note error and continue
if not self.perm_error:
try:
raise PermError(*msg)
except PermError as x:
# FIXME: keep a list of errors for even friendlier diagnostics.
self.perm_error = x
return self.perm_error
def expand_domain(self,arg):
"validate and expand domain-spec"
# any trailing dot was removed by expand()
if RE_TOPLAB.split(arg)[-1]:
raise PermError('Invalid domain found (use FQDN)', arg)
return self.expand(arg)
def validate_mechanism(self, mech):
"""Parse and validate a mechanism.
Returns mech,m,arg,cidrlength,result
Examples:
>>> q = query(s='[email protected].',
... h='mx.example.org', i='192.0.2.3')
>>> q.validate_mechanism('A')
('A', 'a', 'email.example.com', 32, 'pass')
>>> q = query(s='[email protected]',
... h='mx.example.org', i='192.0.2.3')
>>> q.validate_mechanism('A//64')
('A//64', 'a', 'email.example.com', 32, 'pass')
>>> q.validate_mechanism('A/24//64')
('A/24//64', 'a', 'email.example.com', 24, 'pass')
>>> q.validate_mechanism('?mx:%{d}/27')
('?mx:%{d}/27', 'mx', 'email.example.com', 27, 'neutral')
>>> try: q.validate_mechanism('ip4:1.2.3.4/247')
... except PermError as x: print(x)
Invalid IP4 CIDR length: ip4:1.2.3.4/247
>>> try: q.validate_mechanism('ip4:1.2.3.4/33')
... except PermError as x: print(x)
Invalid IP4 CIDR length: ip4:1.2.3.4/33
>>> try: q.validate_mechanism('a:example.com:8080')
... except PermError as x: print(x)
Invalid domain found (use FQDN): example.com:8080
>>> try: q.validate_mechanism('ip4:1.2.3.444/24')
... except PermError as x: print(x)
Invalid IP4 address: ip4:1.2.3.444/24
>>> try: q.validate_mechanism('ip4:1.2.03.4/24')
... except PermError as x: print(x)
Invalid IP4 address: ip4:1.2.03.4/24
>>> try: q.validate_mechanism('-all:3030')
... except PermError as x: print(x)
Invalid all mechanism format - only qualifier allowed with all: -all:3030
>>> q.validate_mechanism('-mx:%%%_/.Clara.de/27')
('-mx:%%%_/.Clara.de/27', 'mx', '% /.Clara.de', 27, 'fail')
>>> q.validate_mechanism('~exists:%{i}.%{s1}.100/86400.rate.%{d}')
('~exists:%{i}.%{s1}.100/86400.rate.%{d}', 'exists', '192.0.2.3.com.100/86400.rate.email.example.com', 32, 'softfail')
>>> q.validate_mechanism('a:mail.example.com.')
('a:mail.example.com.', 'a', 'mail.example.com', 32, 'pass')
>>> try: q.validate_mechanism('a:mail.example.com,')
... except PermError as x: print(x)
Do not separate mechnisms with commas: a:mail.example.com,
>>> q = query(s='[email protected]',
... h='mx.example.org', i='2001:db8:1234::face:b007')
>>> q.validate_mechanism('A//64')
('A//64', 'a', 'email.example.com', 64, 'pass')
>>> q.validate_mechanism('A/16')
('A/16', 'a', 'email.example.com', 128, 'pass')
>>> q.validate_mechanism('A/16//48')
('A/16//48', 'a', 'email.example.com', 48, 'pass')
"""
if mech.endswith( "," ):
self.note_error('Do not separate mechnisms with commas', mech)
mech = mech[:-1]
# a mechanism
m, arg, cidrlength, cidr6length = parse_mechanism(mech, self.d)
# map '?' '+' or '-' to 'neutral' 'pass' or 'fail'
if m:
result = RESULTS.get(m[0])
if result:
# eat '?' '+' or '-'
m = m[1:]
else:
# default pass
result = 'pass'
if m in COMMON_MISTAKES:
self.note_error('Unknown mechanism found', mech)
m = COMMON_MISTAKES[m]
if m == 'a' and RE_IP4.match(arg):
x = self.note_error(
'Use the ip4 mechanism for ip4 addresses', mech)
m = 'ip4'
# validate cidr and dual-cidr
if m in ('a', 'mx'):
if cidrlength is None:
cidrlength = 32;
elif cidrlength > 32:
raise PermError('Invalid IP4 CIDR length', mech)
if cidr6length is None:
cidr6length = 128
elif cidr6length > 128:
raise PermError('Invalid IP6 CIDR length', mech)
if self.v == 'ip6':
cidrlength = cidr6length
elif m == 'ip4' or RE_IP4.match(m):
if m != 'ip4':
self.note_error( 'Missing IP4' , mech)
m,arg = 'ip4',m
if cidr6length is not None:
raise PermError('Dual CIDR not allowed', mech)
if cidrlength is None:
cidrlength = 32;
elif cidrlength > 32:
raise PermError('Invalid IP4 CIDR length', mech)
if not RE_IP4.match(arg):
raise PermError('Invalid IP4 address', mech)
elif m == 'ip6':
if cidr6length is not None:
raise PermError('Dual CIDR not allowed', mech)
if cidrlength is None:
cidrlength = 128
elif cidrlength > 128:
raise PermError('Invalid IP6 CIDR length', mech)
if not RE_IP6.match(arg):
raise PermError('Invalid IP6 address', mech)
else:
if cidrlength is not None or cidr6length is not None:
if m in ALL_MECHANISMS:
raise PermError('CIDR not allowed', mech)
cidrlength = self.cidrmax
if m in ('a', 'mx', 'ptr', 'exists', 'include'):
if m == 'exists' and not arg:
raise PermError('implicit exists not allowed', mech)
arg = self.expand_domain(arg)
if not arg:
raise PermError('empty domain:',mech)
if m == 'include':
if arg == self.d:
if mech != 'include':
raise PermError('include has trivial recursion', mech)
raise PermError('include mechanism missing domain', mech)
return mech, m, arg, cidrlength, result
# validate 'all' mechanism per RFC 4408 ABNF
if m == 'all' and mech.count(':'):
# print '|'+ arg + '|', mech, self.d,
self.note_error(
'Invalid all mechanism format - only qualifier allowed with all'
, mech)
if m in ALL_MECHANISMS:
return mech, m, arg, cidrlength, result
if m[1:] in ALL_MECHANISMS:
x = self.note_error(
'Unknown qualifier, RFC 4408 para 4.6.1, found in', mech)
else:
x = self.note_error('Unknown mechanism found', mech)
return mech, m, arg, cidrlength, x
def check0(self, spf, recursion):
"""Test this query information against SPF text.
Returns (result, mta-status-code, explanation) where
result in ['fail', 'unknown', 'pass', 'none']
"""
if not spf:
return ('none', 250, EXPLANATIONS['none'])
# Split string by space, drop the 'v=spf1'. Split by all whitespace
# casuses things like carriage returns being treated as valid space
# separators, so split() is not sufficient.
spf = spf.split(' ')
# Catch case where SPF record has no spaces.
# Can never happen with conforming dns_spf(), however
# in the future we might want to give warnings
# for common mistakes like IN TXT "v=spf1" "mx" "-all"
# in relaxed mode.
if spf[0].lower() != 'v=spf1':
if self.strict > 1:
raise AmbiguityWarning('Invalid SPF record in', self.d)
return ('none', 250, EXPLANATIONS['none'])
# Just to make it even more fun, the relevant piece of the ABNF for
# term separations is *( 1*SP ( directive / modifier ) ), so it's one
# or more spaces, not just one. So strip empty mechanisms.
spf = [mech for mech in spf[1:] if mech]
# copy of explanations to be modified by exp=
exps = self.exps
redirect = None
# no mechanisms at all cause unknown result, unless
# overridden with 'default=' modifier
#
default = 'neutral'
mechs = []
modifiers = []
# Look for modifiers
#
for mech in spf:
m = RE_MODIFIER.split(mech)[1:]
if len(m) != 2:
mechs.append(self.validate_mechanism(mech))
continue
mod,arg = m
if mod in modifiers:
if mod == 'redirect':
raise PermError('redirect= MUST appear at most once',mech)
self.note_error('%s= MUST appear at most once'%mod,mech)
# just use last one in lax mode
modifiers.append(mod)
if mod == 'exp':
# always fetch explanation to check permerrors
if not arg:
raise PermError('exp has empty domain-spec:',arg)
arg = self.expand_domain(arg)
if arg:
try:
exp = self.get_explanation(arg)
if exp and not recursion:
# only set explanation in base recursion level
self.set_explanation(exp)
except: pass
elif mod == 'redirect':
self.check_lookups()
redirect = self.expand_domain(arg)
if not redirect:
raise PermError('redirect has empty domain:',arg)
elif mod == 'default':
# default modifier is obsolete
if self.strict > 1:
raise AmbiguityWarning('The default= modifier is obsolete.')
if not self.strict and self.default_modifier:
# might be an old policy, so do it anyway
arg = self.expand(arg)
# default=- is the same as default=fail
default = RESULTS.get(arg, default)
elif mod == 'op':
if not recursion:
for v in arg.split('.'):
if v: self.options[v] = True
else:
# spf rfc: 3.6 Unrecognized Mechanisms and Modifiers
self.expand(m[1]) # syntax error on invalid macro
# Evaluate mechanisms
#
for mech, m, arg, cidrlength, result in mechs:
if m == 'include':
self.check_lookups()
d = self.dns_spf(arg)
if self.verbose: self.log("include",arg,d)
res, code, txt = self.check1(d,arg, recursion + 1)
if res == 'pass':
break
if res == 'none':
self.note_error(
'No valid SPF record for included domain: %s' %arg,
mech)
res = 'neutral'
continue
elif m == 'all':
break
elif m == 'exists':
self.check_lookups()
try:
if len(self.dns_a(arg,'A')) > 0:
break
except AmbiguityWarning:
# Exists wants no response sometimes so don't raise
# the warning.
pass
elif m == 'a':
self.check_lookups()
if self.cidrmatch(self.dns_a(arg,self.A), cidrlength):
break
elif m == 'mx':
self.check_lookups()
if self.cidrmatch(self.dns_mx(arg), cidrlength):
break
elif m == 'ip4':
if self.v == 'in-addr': # match own connection type only
try:
if self.cidrmatch([arg], cidrlength): break
except socket.error:
raise PermError('syntax error', mech)
elif m == 'ip6':
if self.v == 'ip6': # match own connection type only
try:
if self.cidrmatch([arg], cidrlength): break
except socket.error:
raise PermError('syntax error', mech)
elif m == 'ptr':
self.check_lookups()
if domainmatch(self.validated_ptrs(), arg):
break
else:
# no matches
if redirect:
#Catch redirect to a non-existant SPF record.
redirect_record = self.dns_spf(redirect)
if not redirect_record:
raise PermError('redirect domain has no SPF record',
redirect)
if self.verbose: self.log("redirect",redirect,redirect_record)
# forget modifiers on redirect
if not recursion:
self.exps = dict(self.defexps)
self.options = {}
return self.check1(redirect_record, redirect, recursion)
result = default
mech = None
if not recursion: # record matching mechanism at base level
self.mechanism = mech
if result == 'fail':
return (result, 550, exps[result])
else:
return (result, 250, exps[result])
def check_lookups(self):
self.lookups = self.lookups + 1
if self.lookups > MAX_LOOKUP*4:
raise PermError('More than %d DNS lookups'%(MAX_LOOKUP*4))
if self.lookups > MAX_LOOKUP:
self.note_error('Too many DNS lookups')
def get_explanation(self, spec):
"""Expand an explanation."""
if spec:
try:
a = self.dns_txt(spec,ignore_void=True)
if len(a) == 1:
return str(self.expand(to_ascii(a[0]), stripdot=False))
except PermError:
# RFC4408 6.2/4 syntax errors cause exp= to be ignored
if self.strict > 1:
raise # but report in harsh mode for record checking tools
pass
elif self.strict > 1:
raise PermError('Empty domain-spec on exp=')
# RFC4408 6.2/4 empty domain spec is ignored
# (unless you give precedence to the grammar).
return None
def expand(self, s, stripdot=True): # macros='slodipvh'
"""Do SPF RFC macro expansion.
Examples:
>>> q = query(s='[email protected]',
... h='mx.example.org', i='192.0.2.3')
>>> q.p = 'mx.example.org'
>>> q.r = 'example.net'
>>> q.expand('%{d}')
'email.example.com'
>>> q.expand('%{d4}')
'email.example.com'
>>> q.expand('%{d3}')
'email.example.com'
>>> q.expand('%{d2}')
'example.com'
>>> q.expand('%{d1}')
'com'
>>> q.expand('%{p}')
'mx.example.org'
>>> q.expand('%{p2}')
'example.org'
>>> q.expand('%{dr}')
'com.example.email'
>>> q.expand('%{d2r}')
'example.email'
>>> q.expand('%{l}')
'strong-bad'
>>> q.expand('%{l-}')
'strong.bad'
>>> q.expand('%{lr}')
'strong-bad'
>>> q.expand('%{lr-}')
'bad.strong'
>>> q.expand('%{l1r-}')
'strong'
>>> q.expand('%{c}',stripdot=False)