def get_rrtxt(mfrom):
RE_SPF = re.compile(br'^v=spf1$|^v=spf1 ', re.IGNORECASE)
fpr('MFROM identity: %s' % mfrom)
try:
local_part, domain = spf.split_email(s=mfrom, h='')
fpr('Domain: %s' % domain)
print
_dns = spf.DNSLookup(domain, 'TXT', strict=True, timeout=20)
if _dns:
#dbginfo('debug','DNS: %s ' % dns)
# for k, v in DNSLookup(name, qtype, self.strict, timeout):
for k, v in _dns:
#k = (k[0].lower(), k[1])
if k[1] == 'TXT':
m = re.match(RE_SPF, v[0])
if m:
fpr('DNS RR: %s' % k[1])
print
#for i in v:
# fpr.green('%s' % i )
fpr.green('%s' % "".join(v))
#print
else:
fpr('No TXT RR was found')
print
except spf.TempError, e:
fpr.err('Error: %s' % e)
print
def chEque():
print
if r:
# compare float
# https://ubuntuforums.org/showthread.php?t=840665
def float_eq(a, b, epsilon=0.00000001):
fpr.cyan('<float_eq> %s' % abs(a - b))
if abs(a - b) < epsilon:
return True
return False
m1 = float(r) / rpm
m2 = mpt * float(t)
fpr.cyan('r/rpm = %s, mpt * t = %s' % (m1, m2))
if float_eq(m1, m2):
fpr.green('Equetion is met')
waitin()
return True
else:
fpr.err('Equetion is false')
waitin()
return False
def spfdns(domain, q):
#local_part,domain = spf.split_email(s=dd['id'].get('mfrom'),h='')
txt = q.dns_spf(domain)
if txt:
fpr.green('TXT: %s\n\n' % txt)
else:
fpr.err('SPF record not found or more than one record found')
def viewSmtpSess():
#from core.msg.builder import msg_builder
size = len(msg_builder().as_string(unixfrom=False))
#from core.msg.threads import get_rcpts
unknown = '-- undefined --'
if cfgs['conv_logs']:
fpr.green('Conversation Logs: ON', 'r')
fpr.info('_' * (tc - 4))
print
#FIXME:
d = smtp['connect']['hosts'][0]
fpr('SMTP Host : %s:%s' %
(d.get('host', unknown), d.get('port', unknown)))
if d.get('smtp_auth_user'):
fpr('SMTP Authentication : %s:%s' % (d.get(
'smtp_auth_user', unknown), d.get('smtp_auth_pass', unknown)))
else:
fpr('SMTP Authentication : NoAuth')
fpr('SMTP Encryption : %s' % d.get('tls_mode', unknown))
fpr('SMTP HELO : %s' % d.get('helo', unknown))
print
if smtp['addrlist']['mail_from']:
fpr('Envelope Sender : %s' % smtp['addrlist']['mail_from'])
else:
fpr.err('Envelope Sender : %s' % unknown)
# shown only 1st rcpt if more than one
r = list(smtp['addrlist']['rcpts'])
#if smtp['addrlist']['rcpt_to']:
# r.insert(0,smtp['addrlist']['rcpt_to'])
if r:
if len(r) > 1:
fpr('Envelope Recipient(s) : %s .. + %d more' % (r[0], len(r) - 1))
else:
fpr('Envelope Recipient(s) : %s' % r[0])
else:
fpr.err('Envelope Recipient(s) : %s' % unknown)
del r[:]
print
fpr('Number of Recipients : %s' % get_rcpts('NoR'))
fpr('Message Size : %s bytes' % size)
fpr('Message Subject : %s' %
smtp['headers'].get('h_Subject', unknown))
fpr.info('_' * (tc - 4))
print
def viewSmtpConv(s):
#import re
#import sys
#from StringIO import StringIO
#from core.ui.cless import Less
if s:
if raw_input(
' Would you like to view SMTP conversation [y/N]:> ') not in [
'y', 'Y'
]:
return True
else:
print
dl = len(s.splitlines())
for line in s.splitlines():
if len(line) > tc:
dl += len(line) / tc
if dl > tr:
fpr('SMTP conversation logs are much bigger than your screen (%s lines)'
% dl)
if raw_input(
' Would like to use system pager to view it [y/N]:> ') in [
'y', 'Y'
]:
fpr.blue('_' * (tc - 4))
print
# use Less if output is much bigger than one screen
pager = Less(num_lines=tr)
# fetch output from fancy print as Less input must be a string
# make copy of original stdout han redirect stdout to string
sto = sys.stdout
sys.stdout = StringIO()
for line in s.splitlines():
if re.search('^send:', line):
fpr.cyan(line)
elif re.search('^reply:', line):
fpr.green(line)
elif re.search('^data:', line):
fpr.purple(line)
else:
fpr.info(line)
x = sys.stdout.getvalue()
sys.stdout.close()
sys.stdout = sto
print x | pager
return True
#else:
# fpr.blue( '_'*(tc-4))
# print
# fpr.blue( '_'*(tc-4))
#else:
fpr.blue('_' * (tc - 4))
print
for line in s.splitlines():
if re.search('^send:', line):
fpr.cyan(line)
elif re.search('^reply:', line):
fpr.green(line)
elif re.search('^data:', line):
fpr.purple(line)
else:
fpr.info(line)
fpr.blue('_' * (tc - 4))
def smtp_dha(cpt=1, rate=None, rcpts=[], method='RCPT TO',relays={} ,name='DHA-T-Single',v=False):
dhar = dict()
from pprint import pprint
from core.data import cfgs,smtp,fpr,tc,DEBUG
from core.func import dbginfo
from core.msg.viewers import viewSmtpConv
from core.msg.threads import get_tid
dbginfo('DEBUG','name=%s, cpt=%s, method=%s, rate=%s, rcpts=%s' % (name,cpt,method,rate,rcpts) )
#verbnose
dhost=smtp['connect']['hosts'][0]
try:
import sys
import smtplib
# # log debuglevel output from smtplib
# # redirect stderr from smtplib to string
# #
# # - from smtplib import stderr
# if cfgs['conv_logs'] and cl:
# ostderr = smtplib.stderr
# smtplib.stderr = StderrLogger()
# run smtp session
if v:
fpr.white('Establishing the session ..')
s = smtplib.SMTP(dhost['host'],dhost['port'])
# if cfgs['conv_logs'] and cl:
# s.set_debuglevel('debug')
# HELO - introduce yourself
if v:
fpr.cyan('>>> %s %s' % ('EHLO',dhost['helo']))
(c,m) = s.ehlo(dhost['helo'])
#r = s.helo(smtp['connect']['hosts'][0]['helo'])
if v:
#print (c,m)
if 200 <= c <= 299:
fpr.green('<<< %s %s' %(c,m))
if s.does_esmtp:
fpr.white('ESMTP supported and have extn:')
#print s.does_esmtp
#print s.esmtp_features
for (scmd,sarg) in s.esmtp_features.items():
fpr.white(' * %s %s' % (scmd,sarg))
elif 500 <= c <= 599:
fpr.err('<<< %s %s' %(c,m))
# STAARTTLS
if 'starttls' in s.esmtp_features.keys():
if dhost['tls_mode'] == 'TLS':
if v:
fpr.white('TLS supported and requested')
fpr.white('Establishing TLS session ..')
fpr.cyan('>>> %s' % ('STARTTLS'))
(c,m) = s.starttls()
if 200 <= c <= 299:
fpr.green('<<< %s %s' %(c,m))
# HELO - introducing yourself on encrypted session should be done as well
if v:
fpr.cyan('>>> %s %s' % ('EHLO',dhost['helo']))
(c,m) = s.ehlo(dhost['helo'])
if v:
#print (c,m)
if 200 <= c <= 299:
fpr.green('<<< %s %s' %(c,m))
if s.does_esmtp:
fpr.white('ESMTP supported and have extn:')
#print s.does_esmtp
#print s.esmtp_features
for (scmd,sarg) in s.esmtp_features.items():
fpr.white(' * %s %s' % (scmd,sarg))
elif 500 <= c <= 599:
fpr.err('<<< %s %s' %(c,m))
elif 500 <= c <= 599:
fpr.err('<<< %s %s' %(c,m))
else:
if v:
fpr.white('TLS supported but not requested')
fpr.white('Unencrypted session established')
# SMTP AUTH
if 'auth' in s.esmtp_features.keys():
if dhost['smtp_auth_user'] != '':
if v:
fpr.cyan('>>> %s %s' % ('AUTH PLAIN','*********'))
(c,m) = s.login(dhost['smtp_auth_user'],dhost['smtp_auth_pass'])
if v:
if 200 <= c <= 299:
fpr.green('<<< %s %s' %(c,m))
elif 500 <= c <= 599:
fpr.err('<<< %s %s' %(c,m))
elif dhost['smtp_auth_user'] != '':
if v:
fpr.white('Authentication SET but not available (AUTH not supported)')
fpr.white('Trying without AUTH')
if method.lower() == 'rcpt to':
# MAIL FROM
sender = smtp['addrlist']['mail_from']
#rcpt = smtp['addrlist']['rcpt_to']
if v:
fpr.cyan('>>> %s %s' % ('MAIL FROM:',sender))
(c,m) = s.docmd('MAIL FROM:',sender)
if v:
if 200 <= c <= 299:
fpr.green('<<< %s %s' %(c,m))
elif 500 <= c <= 599:
fpr.err('<<< %s %s' %(c,m))
# number of recipients to test
# rpt - rcpt/thread
# cpt - command/thread
if cpt == None:
cpt = 1
rpt = len(rcpts)
cpt = rpt
if v:
fpr.white('Enumerating recipients ..')
fpr.white(' * %s recipients to test with this thread' % len(rcpts))
fpr.white(' * method in use: %s' % method.lower())
#print rcpts
for r in rcpts:
if method.lower() == 'rcpt to':
if v:
fpr.cyan('>>> %s: <%s>' % (method,r))
(c,m) = s.docmd('%s:' % method,'<%s>' % r)
else:
# treat results returned from vrfy and expn similar
# expn should have a separate condition as it could return
# a list of recipients in case of mailing list but
# in modern networks you should be really lucky to find such an SMTP server
# supporting - good luck with that
# - it should be implemented just as proof of concept rather than for real use
if v:
fpr.cyan('>>> %s <%s>' % (method,r))
(c,m) = s.docmd('%s' % method,'<%s>' % r)
if 200 <= c <= 299:
if v:
fpr.green('<<< %s %s' %(c,m))
dhar.setdefault(r,
{ 'valid': True, 'code': c, 'msg': m, 'method': method.lower(),
'host': dhost['host'], 'thread': name }
)
elif 500 <= c <= 599:
if v:
fpr.err('<<< %s %s' %(c,m))
dhar.setdefault(r,
{ 'valid': False, 'code': c, 'msg': m, 'method': method.lower(),
'host': dhost['host'], 'thread': name }
)
else:
if v:
fpr.err('<<< %s %s' %(c,m))
dhar.setdefault(r,
{ 'valid': False, 'code': c, 'msg': m, 'method': method.lower(),
'host': dhost['host'], 'thread': name }
)
# query timeout - wait before next command
#sleep(1)
# pprint(dhar)
# quit smtp session
if v:
fpr.cyan('>>> %s' % ('QUIT:'))
(c,m) = s.quit()
if v:
if 200 <= c <= 299:
fpr.green('<<< %s %s' %(c,m))
fpr.white('Session closed successfully')
elif 500 <= c <= 599:
fpr.err('<<< %s %s' %(c,m))
if v:
print
fpr('To check valid recipients back to the main submenu')
#pprint(dhar)
# the exception is triggered only when all recipoient failed :(
except smtplib.SMTPRecipientsRefused, e:
fpr.fail('Error: unable to sent message. All recipients refused.')
smtp['replay']['threads']['fail'].append(name)
#print 'exception smtplib.SMTPRecipientsRefused',a
fpr.warn(str(e))
smtp['addrlist']['r_reject'].update(e.recipients)
def enumSMTPcmd(v=None,dhost=smtp['connect']['hosts'][0]):
#TODO: if no EHLO , use HELO
from pprint import pprint
# secure extn - list of extn received after successfull STARTTLS commands
scmds = { 'extn' : [], 'secure_extn': [], 'cmds': '', 'method': [], }
#pprint(dhost)
#pprint(scmds)
print
try:
import sys
import smtplib
# run smtp session
if v:
fpr.white('Establishing the session with %s on port %s' % (dhost['host'],dhost['port']))
s = smtplib.SMTP(dhost['host'],dhost['port'])
if v:
fpr.cyan('>>> %s' % 'HELP')
r = s.help()
scmds['scmds'] = r
if v:
fpr.green('<<< %s' % r)
# if cfgs['conv_logs'] and cl:
# s.set_debuglevel('debug')
# HELO - introduce yourself
if v:
fpr.cyan('>>> %s %s' % ('EHLO',dhost['helo']))
(c,m) = s.ehlo(dhost['helo'])
#r = s.helo(smtp['connect']['hosts'][0]['helo'])
#print (c,m)
if 200 <= c <= 299:
if v:
fpr.green('<<< %s %s' %(c,m))
if s.does_esmtp:
if v:
fpr.white('ESMTP supported and have extn:')
#print s.does_esmtp
#print s.esmtp_features
for (scmd,sarg) in s.esmtp_features.items():
if v:
fpr.white(' * %s %s' % (scmd,sarg))
scmds['extn'].append((scmd,sarg))
elif 500 <= c <= 599:
fpr.err('<<< %s %s' %(c,m))
# STAARTTLS
if 'starttls' in s.esmtp_features.keys():
if dhost['tls_mode'] == 'TLS':
if v:
fpr.white('TLS supported and requested')
fpr.white('Establishing TLS session ..')
fpr.cyan('>>> %s' % ('STARTTLS'))
(c,m) = s.starttls()
if 200 <= c <= 299:
fpr.green('<<< %s %s' %(c,m))
# HELO - introducing yourself on encrypted session should be done as well
if v:
fpr.cyan('>>> %s %s' % ('EHLO',dhost['helo']))
(c,m) = s.ehlo(dhost['helo'])
if v:
#print (c,m)
if 200 <= c <= 299:
fpr.green('<<< %s %s' %(c,m))
if s.does_esmtp:
fpr.white('ESMTP supported and have extn:')
#print s.does_esmtp
#print s.esmtp_features
for (scmd,sarg) in s.esmtp_features.items():
fpr.white(' * %s %s' % (scmd,sarg))
scmds['secure_extn'].append((scmd,sarg))
elif 500 <= c <= 599:
fpr.err('<<< %s %s' %(c,m))
elif 500 <= c <= 599:
fpr.err('<<< %s %s' %(c,m))
else:
if v:
fpr.white('TLS supported but not requested')
fpr.white('Unencrypted session established')
# # SMTP AUTH
# if 'auth' in s.esmtp_features.keys():
# if smtp['connect']['hosts'][0]['smtp_auth_user'] != '':
# if v:
# fpr.cyan('>>> %s %s' % ('AUTH PLAIN','*********'))
# (c,m) = s.login(smtp['connect']['hosts'][0]['smtp_auth_user'],smtp['connect']['hosts'][0]['smtp_auth_pass'])
# if v:
# if 200 <= c <= 299:
# fpr.green('<<< %s %s' %(c,m))
# elif 500 <= c <= 599:
# fpr.err('<<< %s %s' %(c,m))
# else:
# if smtp['connect']['hosts'][0]['smtp_auth_user'] != '':
# if v:
# fpr.white('Authentication SET but not available (AUTH not supported)')
# fpr.white('Trying without AUTH')
# else:
# if v:
# fpr.white('Authentication not available (AUTH not supported)')
# fpr.white('Trying without AUTH')
#print rcpts
r = 'postmaster'
for sm in ['EXPN','VRFY']:
if v:
fpr.cyan('>>> %s <%s>' % (sm,r))
(c,m) = s.docmd('%s' % sm,'<%s>' % r)
if 200 <= c <= 299:
if v:
fpr.green('<<< %s %s' %(c,m))
scmds['method'].append(sm)
elif 500 <= c <= 599:
if v:
fpr.err('<<< %s %s' %(c,m))
else:
if v:
fpr.err('<<< %s %s' %(c,m))
if 'rcpt' in scmds['scmds'].lower():
scmds['method'].append('RCPT')
# pprint(dhar)
# quit smtp session
if v:
fpr.cyan('>>> %s' % ('QUIT:'))
(c,m) = s.quit()
if v:
if 200 <= c <= 299:
fpr.green('<<< %s %s' %(c,m))
fpr.white('Session closed successfully')
elif 500 <= c <= 599:
fpr.err('<<< %s %s' %(c,m))
#pprint(scmds)
return scmds
# the exception is triggered only when all recipoient failed :(
except smtplib.SMTPRecipientsRefused, e:
fpr.fail('Error: unable to sent message. All recipients refused.')
fpr.warn(str(e))
def chDHAThrDep(t=None,cpt=None):
#VERIFY: In Python 2.x : int/int --> int and int/float --> float In Python 3.x : int/int can result in a float
r=get_rcpts('NoR')
t_s=None
cpt_s=None
if not r:
fpr.err('Recipients not defined. Build a list of recipients first.')
fpr.err('Flush the values if the recipient list has been modified.')
return
if t:
smtp['dha']['threads']['not'] = int(t)
if cpt:
smtp['dha']['threads']['cpt'] = int(cpt)
fpr.info('_'*(tc-4))
print
fpr.warn('Your limits:')
fpr.warn('t_set = %s : cpt_set = %s : r = %s' %
(smtp['dha']['threads'].get('not',None),
smtp['dha']['threads'].get('cpt',None),r)
)
print
# fpr.err('Maximum possible limits to met Essential Conditions:')
# fpr.err('t = %s : rpm = %s : mpt = %s - r = %s' % (t,rpm,mpt,r) )
# fpr.info('_'*(tc-4))
print
def setReals(t,cpt):
if t and cpt :
smtp['dha']['threads']['reals'].setdefault('not',t)
smtp['dha']['threads']['reals'].setdefault('cpt',cpt)
smtp['dha']['threads']['reals']['not']=t
smtp['dha']['threads']['reals']['cpt']=cpt
fpr.ok('Reals were set!')
if r:
# count the cpt - based on r and t
# -------------------------------------------------------------------- #
if t:
fpr.green('%s : %s : %s' % (t,cpt,r) )
# cpt = r / t
# t = r / cpt
if t >= r:
t_new = r
cpt = 1
fpr.err('realistic returns would be: t = %s, cpt = %s for r = %s' %
(t_new,cpt,r))
setReals(t_new,cpt)
if t < r:
# I - validate CPT - CPT < R
cpt = float(r) / t
fpr.green('counted cpt = %s' % cpt)
# round up - if there is a remainder
if (r % t > 0):
cpt = r / t + (r % t > 0)
fpr.green('rounding up cpt = %s' % cpt)
# find the lowest T for rounded CpT
t_new = float(r) / cpt
fpr.green('counted new t = %s' % t_new)
#if (r % cpt > 0): # if remainder
# t_new = r / cpt + ( r % cpt > 0)
# fpr.green('rounding up new t = %s' % t_new)
# fpr.err('realistic returns would be: *t = %s, cpt = %s for r = %s' %
# (int(t_new),int(cpt),r))
# setReals(int(t_new),int(cpt))
#else:
fpr.err('realistic returns would be: *t = %s, cpt = %s for r = %s' %
(int(t_new),int(cpt),r))
setReals(int(t_new),int(cpt))
else:
fpr.err('realistic returns would be: t = %s, cpt = %s for r = %s' %
(t,int(cpt),r))
setReals(int(t),int(cpt))
elif cpt:
fpr.green('%s : %s : %s' % (t,cpt,r) )
# cpt = r / t
# t = r / cpt
if cpt >= r:
cpt_new = r
t = 1
fpr.err('realistic returns would be: t = %s, cpt = %s for r = %s' %
(t,cpt_new,r))
setReals(t,cpt_new)
if cpt < r:
# I - validate T - t < R
t = float(r) / cpt
fpr.green('counted t = %s' % t)
# round up - if there is a remainder
if (r % cpt > 0):
t = r / cpt + (r % cpt > 0)
fpr.green('rounding up t = %s' % t)
# find the lowest T for rounded CpT
cpt_new = float(r) / t
fpr.green('counted new cpt = %s' % cpt_new)
fpr.err('realistic returns would be: *t = %s, cpt = %s for r = %s' %
(int(t),int(cpt_new),r))
setReals(int(t),int(cpt_new))
else:
fpr.err('realistic returns would be: t = %s, cpt = %s for r = %s' %
(t,int(cpt),r))
setReals(int(t),int(cpt))
else:
fpr.err('err')
else:
fpr.err('Recipients not defined. Build a list of recipients first.')
fpr.err('Flush the values if the recipient list has been modified.')
def splitHeaders(inputs, crlf=False):
#TODO: split headers and parse one header per
import email
bancls()
print
fpr.warn('_' * (tc - 4))
print
print inputs
print
fpr.warn('_' * (tc - 4))
print
print '\r\n'.join(inputs)
print
fpr.warn('_' * (tc - 4))
print
waitin()
bancls()
if crlf:
# remove empty elements from list
# no newlines are allowed between headers
inputs = [x for x in inputs if x != '']
msg = email.message_from_string('\r\n'.join(inputs))
AUTHRE = re.compile('Authentication-Results', re.IGNORECASE)
RECSPF = re.compile('Received-SPF', re.IGNORECASE)
hh = {
'Received-SPF': list(),
'Authentication-Results': list(),
}
parser = email.parser.HeaderParser()
headers = parser.parsestr(msg.as_string())
for hn, hv in headers.items():
if DDDEBUG: fpr.green('Found: %s\n%s' % (hn, hv))
m1 = re.match(AUTHRE, hn)
m2 = re.match(RECSPF, hn)
if m1:
if DDDEBUG: print hn, hv
hh['Authentication-Results'].append(hv)
if m2:
if DDDEBUG: print hn, hv
hh['Received-SPF'].append(hv)
# print "---------------------------------"
# from pprint import pprint
# pprint(hh)
# print "---------------------------------"
# print
#build a list
# print len(hh['Received-SPF'])
# print len(hh['Authentication-Results'])
pp = {
'Received-SPF': dict(),
'Authentication-Results': dict(),
}
for hn in ['Received-SPF', 'Authentication-Results']:
x = 0
for h in hh[hn]:
p = parse_spfHeaders2('%s: ' % hn + h)
if DDDEBUG: pprint(p)
pp.setdefault(hn, x)
x += 1
pp[hn].setdefault(x, p)
print "---------------------------------"
pprint(pp)
print "---------------------------------"
return pp
def parse_spfHeaders2(h):
from email.message import Message
import re
if not h:
return False
#print type(h)
#print h
#h1 = h.replace('\n','')
#print h1
# re.DOTALL '.'match everything inludinf newline
# re.IGNORECASE is used at the splitHeaders() function first
AUTHRE = re.compile('^(Authentication-Results):(.*)', re.DOTALL)
RECSPF = re.compile('^(Received-SPF):(.*)', re.DOTALL)
m1 = re.match(AUTHRE, h)
m2 = re.match(RECSPF, h)
if DDDEBUG: fpr.purple(h)
dd = {'hn': '', 'hv': ''}
#""" Authentication-Results """
if m1:
dd['hn'] = m1.group(1)
dd['hv'] = m1.group(2)
fpr.info('_' * (tc - 4))
print
fpr('Header-name : %s' % m1.group(1))
fpr('Header-value : %s' % m1.group(2))
fpr.info('_' * (tc - 4))
print
try:
import authres
# FIXME: fast workaround for authres module
#
# remove "d=" tag from dmarc auth method as authres
# does recognize only below ptype
# -> elif ptype.lower() not in ['smtp', 'header', 'body', 'policy']
# and it raise a Syntax error for d=
h = h.replace('\n', '')
h = h.replace('\r', '')
h = h.replace('\t', ' ')
DTAG = re.compile('.*dmarc=.* \(.*\)* d=([a-z0-9\.\-]+)',
re.IGNORECASE)
md = re.match(DTAG, h)
if md:
fpr.warn('Stripping "d=" tag from dmarc method: d=%s' %
md.group(1))
#fpr.green( '%s ---- %s' % (md.group(1), md.group()))
h = re.sub('d=%s' % md.group(1), '', h)
if DDDEBUG: print h
#else:
# print 'no d-tag'
arh = authres.AuthenticationResultsHeader.parse(h)
#if DDDEBUG:
# from pprint import pprint
# pprint(str(arh))
except Exception, e:
fpr.err('Exception: %s' % e)
p = {}
if str(arh.authserv_id):
p['authserv_id'] = str(arh.authserv_id)
print len(arh.results)
for i in arh.results:
if DDDEBUG:
pprint(i)
fpr('method: %s' % str(i.method))
if str(i.method) == 'spf':
p.setdefault('spf', {})
p['spf'].setdefault('mailfrom', {})
p['spf'].setdefault('helo', {})
p['spf'].setdefault('pra', {})
if DDDEBUG:
fpr('result : %s' % str(i.result))
if hasattr(i, 'smtp_mailfrom'):
fpr('smtp.mailfrom : %s' % str(i.smtp_mailfrom))
if hasattr(i, 'smtp_helo'):
fpr('smtp.helo : %s' % str(i.smtp_helo))
if hasattr(i, 'smtp_pra'):
fpr('smtp.pra : %s' % str(i.smtp_pra))
for j in i.properties:
if j.name == 'mailfrom':
p['spf']['mailfrom']['result'] = str(i.result)
p['spf']['mailfrom']['type'] = str(j.type)
p['spf']['mailfrom']['name'] = str(j.name)
p['spf']['mailfrom']['value'] = str(j.value)
if j.name == 'helo':
p['spf']['helo']['result'] = str(i.result)
p['spf']['helo']['type'] = str(j.type)
p['spf']['helo']['name'] = str(j.name)
p['spf']['helo']['value'] = str(j.value)
if j.name == 'pra':
p['spf']['pra']['result'] = str(i.result)
p['spf']['pra']['type'] = str(j.type)
p['spf']['pra']['name'] = str(j.name)
p['spf']['pra']['value'] = str(j.value)
if DDDEBUG:
fpr.green(' type: %s' % str(j.type))
fpr(' name: %s' % str(j.name))
fpr(' value: %s' % str(j.value))
if str(i.method) == 'dkim':
p.setdefault('dkim', {})
p['dkim']['result'] = str(i.result)
if DDDEBUG:
fpr('result : %s' % str(i.result))
fpr('header_i : %s' % str(i.header_i))
for j in i.properties:
# dkim header identity
p['dkim']['header_i'] = str(j.value)
if DDDEBUG:
fpr.green(' type: %s' % str(j.type))
fpr(' name: %s' % str(j.name))
fpr(' value: %s' % str(j.value))
if str(i.method) == 'dmarc':
p.setdefault('dmarc', {})
p['dmarc']['result'] = str(i.result)
if DDDEBUG:
fpr('result : %s' % str(i.result))
p['h_value'] = dd['hv']
return p
print
fpr.warn('Verification skipped. Missing client IP address!')
waitin()
return
# if SPF Policy is defined manually skip DNS and use it
if dd.get('policy'):
#fpr('SPF record supplied by input is found! ')
fpr('Policy origin: User input\n\n')
if get_yesno_input(
' Run validation against supplied SPF record [y/N]: > '):
print
fpr('Policy origin: INPUT\n\n')
fpr('_' * (tc - 4))
print
fpr.green('%s' % dd['policy'])
fpr('_' * (tc - 4))
print
fpr('Evaluating policy mechanism ..')
print
spfmech(dd['policy'], q, 1)
print
return
if True:
print
fpr('Policy origin: DNS/TXT RR\n\n')
try:
txt = q.dns_spf(domain)
if txt:
fpr('_' * (tc - 4))
print
def chThrDep(t=None, rpm=None, mpt=None):
#VERIFY: In Python 2.x : int/int --> int and int/float --> float In Python 3.x : int/int can result in a float
from core.data import smtp, fpr, tc, tr
from core.func import waitin
r = get_rcpts('NoR')
#Warunki Konieczne - Essential Conditions
# to met WK1, WK2, WK3
if not t:
t = smtp['replay']['threads'].get('not', None)
elif t and not (1 <= int(t) <= r):
if r > 1:
t = r
if r == 1: #special case
pass
if t:
smtp['replay']['threads']['not'] = int(t)
if not rpm:
rpm = smtp['replay']['threads'].get('rpm', None)
elif rpm and not (1 <= int(rpm) <= r):
rpm = int(r)
if rpm:
fpr.ok('Saving RpM as %s' % rpm)
smtp['replay']['threads']['rpm'] = int(rpm)
if not mpt:
mpt = smtp['replay']['threads'].get('mpt', None)
elif mpt and not (1 <= int(mpt) <= r):
mpt = int(r)
if mpt:
fpr.ok('Saving MpT as %s' % mpt)
smtp['replay']['threads']['mpt'] = int(mpt)
if r:
# specific feature: the result depends from number of recipients
# -------------------------------------------------------------------- #
if t and not rpm and not mpt:
fpr.warn('%s : %s : %s - %s' % (t, rpm, mpt, r))
# allow to set t if no rpm or mpt values and number of rcpt > 1
# but t must be <= r, so if t greater then r => it will be equal to r
if r > 1:
smtp['replay']['threads']['not'] = int(t)
fpr.ok('Saving NoT as %s' % t)
return t
# special case when r == 1 , not related to our Equation
# for r = 1 allow to set T > 1 but do not allow than set rpm or mpt
# in this special case the sam message is flooding a sepcific rcpt
# with this smae message in multiple threads/connection !
if r == 1:
#pass
smtp['replay']['threads']['not'] = int(t)
fpr.ok('Saving NoT as %s' % t)
return t
# set initial
elif rpm and not t and not mpt:
fpr.warn('%s : %s : %s - %s' % (t, rpm, mpt, r))
if r > 1:
smtp['replay']['threads']['rpm'] = int(rpm)
#return rpm
#return True
if r == 1:
fpr.warn('It doesn\'t make sense to define RpM when NoR = 1')
return False
#
elif mpt and not t and not rpm:
fpr.warn('%s : %s : %s - %s' % (t, rpm, mpt, r))
if r > 1:
smtp['replay']['threads']['mpt'] = int(mpt)
#return mpt
#return True
if r == 1:
fpr.warn('It doesn\'t make sense to define MpT when NoR = 1')
return False
else:
fpr.err('Recipients not defined. Build a list of recipients first.')
fpr.err('Flush the values if the recipient list has been modified.')
return
# Some maths :)
#
# rpm - recipient per message
# r - number of recipients (all)
# m - number of messages (all)
#
# rpm = r / m ==> m = r / rpm
# mpt - messages per thread
# t - number of threads
# m - number of messages (all)
#
# mpt = m / t ==> m = mpt * t
# r / rpm = mpt * t
#
# ==> t = r / (rpm * mpt)
#
# ==> rpm = r / (mpt * t)
#
# ==> mpt = r / (rpm * t)
fpr.info('_' * (tc - 4))
print
fpr.warn('Your limits:')
fpr.warn('t = %s : rpm = %s : mpt = %s - r = %s' %
(smtp['replay']['threads'].get(
'not', None), smtp['replay']['threads'].get('rpm', None),
smtp['replay']['threads'].get('mpt', None), r))
print
fpr.err('Maximum possible limits to met Essential Conditions:')
fpr.err('t = %s : rpm = %s : mpt = %s - r = %s' % (t, rpm, mpt, r))
fpr.info('_' * (tc - 4))
print
def chEque():
print
if r:
# compare float
# https://ubuntuforums.org/showthread.php?t=840665
def float_eq(a, b, epsilon=0.00000001):
fpr.cyan('<float_eq> %s' % abs(a - b))
if abs(a - b) < epsilon:
return True
return False
m1 = float(r) / rpm
m2 = mpt * float(t)
fpr.cyan('r/rpm = %s, mpt * t = %s' % (m1, m2))
if float_eq(m1, m2):
fpr.green('Equetion is met')
waitin()
return True
else:
fpr.err('Equetion is false')
waitin()
return False
def setReals(t, rpm, mpt):
if t and rpm and mpt:
smtp['replay']['threads']['reals'].setdefault('not', t)
smtp['replay']['threads']['reals'].setdefault('rpm', rpm)
smtp['replay']['threads']['reals'].setdefault('mpt', mpt)
smtp['replay']['threads']['reals']['not'] = t
smtp['replay']['threads']['reals']['rpm'] = rpm
smtp['replay']['threads']['reals']['mpt'] = mpt
fpr.ok('Reals were set!')
if r:
# count the mpt - based on rpm and t
# -------------------------------------------------------------------- #
if t and rpm and not mpt:
fpr.green('%s : %s : %s - %s' % (t, rpm, mpt, r))
# m = r / rpm
# mpt = m / t
# I - validate MPT - MPT <= R
mpt = float(r) / (rpm * t)
fpr.green('counting mpt = %s' % mpt)
chEque()
# round up - if there is a remainder
if (r % (rpm * t) > 0):
mpt = r / (rpm * t) + (r % (rpm * t) > 0)
fpr.green('rounding up mpt = %s' % mpt)
# find the lowest T for rounded MpT to met RpM
t_new = float(r) / (rpm * mpt) #+ (r % (rpm * mpt) > 0)
fpr.green('counting new t = %s' % t_new)
if (r % (rpm * mpt) > 0): # if remainder
t_new = r / (rpm * mpt) + (r % (rpm * mpt) > 0)
fpr.green('rounding up new t = %s' % t_new)
fpr.err(
'realistic returns would be: *t = %s, rpm = %s, mpt = %s for r = %s'
% (int(t_new), rpm, int(mpt), r))
setReals(int(t_new), rpm, int(mpt))
else:
fpr.err(
'realistic returns would be: t = %s, rpm = %s, mpt = %s for r = %s'
% (t, rpm, int(mpt), r))
setReals(t, rpm, int(mpt))
# count the rpm - for mpt and t
# -------------------------------------------------------------------- #
elif t and mpt and not rpm:
fpr.blue('%s : %s : %s - %s' % (t, rpm, mpt, r))
# m = mpt * t
# m = r / rpm
# TODO
# WK: validate RPM , RPM <= R
rpm = float(r) / (mpt * t)
fpr.blue('counting: rpm = %s' % rpm)
chEque()
# if there is a remainder
if (r % (mpt * t) > 0):
rpm = r / (mpt * t) + (r % (mpt * t) > 0)
fpr.blue('rounding up rpm = %s' % rpm)
# find the lowest T for rounded MpT to met RpM
t_new = float(r) / (rpm * mpt) #+ (r % (rpm * mpt) > 0)
fpr.green('counting new t = %s' % t_new)
if (r % (rpm * mpt) > 0): # if remainder
t_new = r / (rpm * mpt) + (r % (rpm * mpt) > 0)
fpr.green('rounding up new t = %s' % t_new)
fpr.err(
'realistic returns would be: *t = %s, rpm = %s, mpt = %s for r = %s'
% (int(t_new), int(rpm), mpt, r))
setReals(int(t_new), int(rpm), mpt)
else:
fpr.err(
'realistic returns would be: t = %s, rpm = %s, mpt = %s for r = %s'
% (t, int(rpm), mpt, r))
setReals(t, int(rpm), mpt)
# count the mpt ( use t = 1 )
# -------------------------------------------------------------------- #
elif rpm and not t and not mpt:
t = 1
fpr.purple('assuming t eq 1 for equation')
fpr.purple('%s : %s : %s - %s' % (t, rpm, mpt, r))
mpt = float(r) / rpm
fpr.purple('counting: mpt = %s' % mpt)
chEque()
#if there is a remainder
if (r % rpm > 0):
mpt = r / rpm + (r % rpm > 0)
fpr.purple('rounding up mpt = %s' % mpt)
# find the lowest T for rounded MpT to met RpM
t_new = float(r) / (rpm * mpt) #+ (r % (rpm * mpt) > 0)
fpr.green('counting new t = %s' % t_new)
if (r % (rpm * mpt) > 0): # if remainder
t_new = r / (rpm * mpt) + (r % (rpm * mpt) > 0)
fpr.green('rounding up new t = %s' % t_new)
fpr.err(
'realistic returns would be: *t = %s, rpm = %s, mpt = %s for r = %s'
% (int(t_new), rpm, mpt, r))
setReals(int(t_new), rpm, mpt)
else:
fpr.err(
'realistic returns would be: t = %s, rpm = %s, mpt = %s for r = %s'
% (t, rpm, int(mpt), r))
setReals(t, rpm, int(mpt))
# count the rpm ( use t = 1 )
# -------------------------------------------------------------------- #
elif mpt and not t and not rpm:
t = 1
fpr.purple('assuming t eq 1 for equation')
fpr.purple('%s : %s : %s - %s' % (t, rpm, mpt, r))
rpm = float(r) / mpt
fpr.purple('counting: rpm = %s' % rpm)
t = 1
chEque()
#if there is a remainder
if (r % mpt > 0):
rpm = r / mpt + (r % mpt > 0)
fpr.purple('rounding up rpm = %s' % rpm)
# find the lowest T for rounded MpT to met RpM
t_new = float(r) / (rpm * mpt) #+ (r % (rpm * mpt) > 0)
fpr.green('counting new t = %s' % t_new)
if (r % (rpm * mpt) > 0): # if remainder
t_new = r / (rpm * mpt) + (r % (rpm * mpt) > 0)
fpr.green('rounding up new t = %s' % t_new)
fpr.err(
'realistic returns would be: *t = %s, rpm = %s, mpt = %s for r = %s'
% (int(t_new), int(rpm), mpt, r))
setReals(int(t_new), int(rpm), mpt)
else:
fpr.err(
'realistic returns would be: t = %s, rpm = %s, mpt = %s for r = %s'
% (t, int(rpm), mpt, r))
setReals(t, int(rpm), mpt)
# count t - for rpm and mpt
# -------------------------------------------------------------------- #
elif mpt and rpm and not t:
fpr.white('%s : %s : %s - %s' % (t, rpm, mpt, r))
print type(mpt)
# add 1 to round up a result
# (r % (rpm * mpt) > 0) it will return True which is 1
# if there is a remainder and 0 if not
t = float(r) / (rpm * mpt) #+ (r % (rpm * mpt) > 0)
fpr.white('counted: t = %s' % t)
chEque()
# round up
if (r % (rpm * mpt) > 0):
t = r / (rpm * mpt) + (r % (rpm * mpt) > 0)
fpr.white('rounding up t = %s' % t)
# validate WK
# t = <1,r>
# if t < 1
if (float(r) / (rpm * mpt)) < 1:
fpr.info('Now to met equetion for t=1 it is not possible for %s (R) recipients '\
'to send %s (MpT) messeges in one thread with %s (RpM) recipient in message' %
(r,mpt,rpm))
print
fpr.info('New RpM value can be counted based on existing MpT or new MpT ' \
'value can be counted based on existing RpM' )
print
fpr.info('For simplicity it is assumed that RpM limits is more important so MpT ' \
'is going to be recounted to met an equation')
print
mpt_new = float(r) / rpm
fpr.white('New MpT to met equetion is %s' % mpt_new)
mpt = mpt_new
chEque()
# now just round up
mpt_new = r / rpm + (r % rpm > 0)
fpr.white('rounding up new mpt = %s' % mpt_new)
fpr.err(
'realistic returns would be: t = %s, rpm = %s, *mpt = %s for r = %s'
% (int(t), rpm, int(mpt_new), r))
setReals(int(t), rpm, int(mpt_new))
else:
# so if t > 1 and it was counted
fpr.err(
'realistic returns would be: t = %s, rpm = %s, mpt = %s for r = %s'
% (int(t), rpm, int(mpt), r))
setReals(int(t), rpm, int(mpt))
# only true if r / rpm = mpt * t
# -------------------------------------------------------------------- #
elif t and rpm and mpt:
fpr.cyan('%s : %s : %s - %s' % (t, rpm, mpt, r))
if not chEque():
fpr.info('_' * (tc - 4))
print
fpr.warn('It is not recommended trying to set NoT with RpM and MpT. ' \
'Suggested action would be to flush these values.' )
fpr.info('_' * (tc - 4))
print
waitin()
return False
else:
fpr.err(
'realistic returns would be: t = %s, rpm = %s, mpt = %s for r = %s'
% (t, rpm, mpt, r))
setReals(t_new, rpm, mpt)
# for test
waitin()