def get_cpt_no():
# set_dval(q=' Set CPT', dd=smtp['dha']['threads'], key='cpt', val=None)
info('info','Note: CPT defines a number of commands sent per single thread where each \n' \
' thread is a a new SMTP connection which need to be established.\n\n' \
' * CPT = NOR / NOT\n' \
' * CPT can not be greater than number of recipients (NOR) \n' \
' * CPT is recounted when NOT is changed.\n' \
' * CPT is equal NOR by default ', adj='l'
)
print
n = raw_input(' [%s]> ' % smtp['dha']['threads'].get('cpt',None)) \
or smtp['dha']['threads'].get('cpt',None)
if n == None:
return
MAX_COMMANDS = 1000
if type(n) is int or n.isdigit():
print
if 0 < int(n) < MAX_COMMANDS:
# smtp['dha']['threads']['cpt'] = int(n)
# fpr.ok('%s'%n)
if chDHAThrDep(cpt=int(n)):
fpr.ok('%s'%n)
else:
fpr.fail('Setting CPT as %s' % n)
def flushMsgContent():
from core.data import smtp, smpls, fpr
if raw_input(' Flush message data part [y/N]:> ') in ['y', 'Y']:
#print smtp
for k in smtp['content'].keys():
if type(smtp['content'][k]) is list:
del smtp['content'][k][:]
if type(smtp['content'][k]) is dict:
smtp['content'][k].clear()
if type(smtp['content'][k]) is str:
smtp['content'][k] = ''
for k in smpls.keys():
if 'astat' in smpls[k]:
smpls[k]['astat'] = 0
for k in smpls['zip'].keys():
if type(smpls['zip'][k]) is dict:
if 'astat' in smpls['zip'][k]:
smpls['zip'][k]['astat'] = 0
# print smpls['zip'][k]['astat']
for k in smpls['zip-smpls'].keys():
if type(smpls['zip-smpls'][k]) is dict:
if 'astat' in smpls['zip-smpls'][k]:
smpls['zip-smpls'][k]['astat'] = 0
# reset the custom mime settings
smtp['use_mime'] = True
#print smtp
fpr.ok('Message data was flushed !')
def flushDKIMHeaders():
import re
from core.data import smtp, fpr
if raw_input(
' Flush attached DKIM-Signature headers and Private Key [y/N]:> '
) in ['y', 'Y']:
for k in smtp['headers'].keys():
h = re.match('^(h\d*_DKIM-Signature)$', k)
#if re.match('^h\d*_DKIM',k):
if h:
#print k
#h = re.match('^h\d*_DKIM-Signature$',k)
#if h:
#print (k,h.group(1)) #DEBUG
del smtp['headers'][k]
fpr(' * %s flushed ' % h.groups())
for k in range(smtp['sign']['dkim']['dstat']):
if smtp['sign']['dkim'].get(k):
smtp['sign']['dkim'].pop(k, None)
fpr(' * Private Key #%s flushed ' % k)
# if key in dict
if smtp['sign']['dkim']['dstat'] in smtp['sign']['dkim']:
# print 'POP'
smtp['sign']['dkim'].pop(smtp['sign']['dkim']['dstat'], None)
#smtp['sign']['dkim'].pop(smtp['sign']['dkim']['dstat'],None)
smtp['sign']['dkim']['dstat'] = 0
fpr.ok('DKIM-Signature headers were flushed !')
fpr.ok('DKIM Private Keys were flushed')
def get_threads_no():
info('info','Note: NOT defines the number of threads where each thread is a new separate' \
' and simultaneous connection. \n' \
' * NOT = NOR / CPT \n' \
' * NOT is 1 by default \n' \
' * NOT value should be keep between 1 - %s \n' \
' * NOT is recounted when CPT is changed' % MAX_THREADS, adj='l'
)
print
n = raw_input(' [%s]> ' % smtp['dha']['threads'].get('not',None)) \
or smtp['dha']['threads'].get('not',None)
if n == None:
return
if type(n) is int or n.isdigit():
print
if 0 < int(n) < MAX_THREADS:
# smtp['dha']['threads']['not'] = int(n)
# fpr.ok('%s'%n)
if chDHAThrDep(t=int(n)):
fpr.ok('%s'%n)
else:
fpr.fail('Setting NoT as %s' % n)
def att_plain_sample(mbody, smtype, sm):
#from core.data import smpls,fpr,tc,tr
#from core.ui.cmenu import Menu
#from core.ui.banner import bancls
while True:
bancls()
if smpls[smtype]['astat'] != 0:
fpr('It seems you have already attached this type of sample')
if not raw_input(' Do you want to append another one [y/N]:') in [
'y', 'Y'
]:
break
if True:
smpl_menu = Menu(sm)
if smpl_menu.op == '':
break
#if smpl_menu.op == '1':
if smpl_menu.op in ['1', '2', '3', '4', '5', '6', '7']:
if smpls[smtype][smpl_menu.op].get('sval', '') == '_':
mbody.append(smpls[smtype][smpl_menu.op]['val'].replace(
smpls[smtype][smpl_menu.op]['sval'], ""))
else:
mbody.append(smpls[smtype][smpl_menu.op]['val'])
smpls[smtype]['astat'] += 1
fpr.ok('Sample attached (x%d)' % smpls[smtype]['astat'])
break
def get_msgs_no():
# from core.data import smtp,fpr,tc,tr
# from core.data import MAX_MSG_PER_TH
# from core.func import info
info('info','Note: MPT defines a number of messages sent per single thread where each \n' \
' thread is a a new SMTP connection which need to be established.\n\n' \
' * MPT can not be greater than number of recipients (NOR) when \n' \
' NOR is greater than one.\n' \
' * Settinng MPT also does not make sense for single recipient. ', adj='l'
)
print
n = raw_input(' [%s]> ' % smtp['replay']['threads'].get('mpt',None)) \
or smtp['replay']['threads'].get('mpt',None)
if n == None:
return
if type(n) is int or n.isdigit():
print
if 1 <= int(n) <= MAX_MSG_PER_TH:
print
#ret = chThrDep(mpt=int(n))
#if ret > True:
# smtp['replay']['threads']['mpt']=int(ret)
if chThrDep(mpt=int(n)):
fpr.ok('%s' % n)
else:
print
fpr.fail('%s' % n)
def get_rcpt_no():
# from core.data import smtp,fpr,tc,tr
# from core.data import MAX_RCPT_PER_MSG
# from core.func import info
info('info','Note: RPM defines a number of recipients used with a single message.\n' \
' It\'s a number of RCPT TO commands send with corresponding addresses.\n\n' \
' * RPM value can not be greater than number of recipients (NOR) when \n' \
' NOR is greater than one.\n' \
' * Settinng RPM does not make sense for single recipient. ', adj='l'
)
#fpr('RpM can not be greater than number of recipients when NoR > 1')
#fpr('Settinng RpM does not make sense for single recipient')
print
n = raw_input(' [%s]> ' % smtp['replay']['threads'].get('rpm',None)) \
or smtp['replay']['threads'].get('rpm',None)
if n == None:
return
if type(n) is int or n.isdigit():
print
if 0 < int(n) < MAX_RCPT_PER_MSG:
print
#ret = chThrDep(rpm=int(n))
#if ret > True:
# smtp['replay']['threads']['rpm']=int(ret)
if chThrDep(rpm=int(n)):
fpr.ok('%s' % n)
else:
print
fpr.fail('%s' % n)
def iworkspace():
SECMODE=0700
fpr('Initialiazing workspace ..')
# Directory check
if os_type() == 'posix':
# fpr('+ POSIX system found')
# fpr('+ Directory check')
for k in cfgs:
#print k
if re.match('.*_path$',k):
#print k,cfgs[k]
_dir = cfgs[k]
#if not os.path.exists(_dir):
if not os.path.isdir(_dir):
try:
os.makedirs(_dir)
fpr.ok('* Creating workspace directory: %s' % _dir )
except OSError as exception:
fpr.fail('* Creating workspace directory: %s' % _dir )
if exception.errno != errno.EEXIST:
raise
if exception.errno != errno.EACCES:
raise
if os.path.isdir(_dir):
if os.path.basename(_dir) in ['keys','logs']:
try:
os.chmod(_dir,SECMODE)
except OSError, e:
pass
def logs_save(logs, thread_name, logpfx):
from core.data import cfgs, smtp, fpr, tc, DEBUG
from core.func import dbginfo
from datetime import datetime
logfile = logpfx + datetime.now().strftime('%Y%m%d%H%M%S')
import os, errno
import logging
logger = logging.getLogger('threadslogs')
fn = cfgs['log_path'] + '/' + logfile
try:
print
with open(fn, "w") as text_file:
text_file.write("{0}".format(logs))
fpr.ok('Saving logs in %s' % logfile)
logger.info('[%s]: Successful saving logs in file: %s' %
(thread_name, logfile))
except IOError as ioex:
fpr.fail('Saving logs in %s' % logfile)
#fpr.fail('Err: Logs not saved with %s' % logfile )
print
fpr.err('Errno: %s' % ioex.errno)
fpr.err('Err code: %s' % errno.errorcode[ioex.errno])
fpr.err('Err message: %s' % os.strerror(ioex.errno))
logger.info('[%s]: Saving logs in file: %s failed: %s: %s' %
(thread_name, logfile, errno.errorcode[ioex.errno],
os.strerror(ioex.errno)))
def runDHAThreads():
viewDHAThreadsSummary()
print
if smtp['addrlist']['r_reject'].keys() or smtp['addrlist']['r_valid'].keys():
fpr('Flushing currently found results (valid/refused recipients) ..')
del smtp['dha']['threads']['ok'][:]
del smtp['dha']['threads']['fail'][:]
smtp['addrlist']['r_reject'].clear()
smtp['addrlist']['r_valid'].clear()
from pprint import pprint
if smtp['dha'].get('cmd') != 'RCPT TO':
#chek if sysem support EXPN/VRFY command before threading
print
if get_yesno_input(' Would you like to test an SMTP server for %s method before threading [y/N]: ' % smtp['dha'].get('cmd')):
sc = enumSMTPcmd(v=False,dhost=smtp['connect']['hosts'][0])
# enumSMTPcmd(v=True,dhost=smtp['connect']['hosts'][0]):
#pprint(sc)
#if smtp['connect']['hosts'][0]['tls_mode'] == 'TLS':
#print smtp['dha'].get('cmd')
if smtp['dha'].get('cmd') in sc['method']:
fpr.ok('Method %s is supported' % smtp['dha'].get('cmd'))
else:
fpr.fail('Method %s is unsupported' % smtp['dha'].get('cmd'))
print
fpr('Consider to change an SMTP method!')
print
t = srThread()
t.daemon = True
t.delay = smtp['dha']['threads'].get('delay',1)
t.threads = smtp['dha']['threads']['reals'].get(
'not',smtp['dha']['threads'].get('not',1)
)
t.cpt = smtp['dha']['threads']['reals'].get(
'cpt',smtp['dha']['threads'].get('cpt',get_rcpts('NoR'))
)
t.method = smtp['dha'].get('cmd')
t.rcpts = smtp['addrlist']['rcpts']
#print get_rcpts('NoR')
if get_rcpts('NoR'):
if raw_input(' Confirm threading [y/N]:> ') in ['y','Y']:
# enable logging
from core.msg.sender import Logger
logger = Logger()
t.run()
logger.close()
else:
print
fpr.err('Threading were Cancaled!')
else:
print
fpr.err('Err. No recipients defined!')
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!')
def loadSession():
print
if not get_yesno_input(' Would you like to load saved session: [y/N]> '):
return
print
fpr('Session files are stored under the session subdirectory by default.\n' \
'Please provide a full path if you would like to load a session file from different location.')
# get the latest file as default:
print
latest = max(glob.iglob(os.path.join(cfgs['sess_path'], '*.session')),
key=os.path.getctime)
if latest:
fpr('Latest saved session is %s' % os.path.basename(latest))
print
sf = raw_input(' [%s]> ' % os.path.basename(latest)) or latest
print
# if filename does not include path than search file in session dir
if not os.path.dirname(sf):
sf = cfgs['sess_path'] + '/' + sf
if os.path.exists(sf):
# import json
try:
f = open(sf, 'r')
# json loads
tmp = json.load(f)
#from pprint import pprint
#pprint(tmp)
#TODO: test tmpe dict
x = 0
for k in tmp.keys():
if k in [
'connection', 'signatures', 'replay', 'content',
'headers'
]:
x += 1
if x:
fpr.ok('Session file seems to be proper')
else:
fpr.fail('Session file is not proper')
return
# overwrite main SMTP dict
print '====='
#smtp = {k:v for k,v in tmp.items()}
for k, v in inSMTPdict(tmp).items():
print k, v
smtp[k] = v
print '====='
fpr.ok('Session load successful')
except IOError as e:
fpr.err('Loding session failed: %s' % e)
else:
fpr.err('Session file does not exist')
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!')
def flushMsgHeaders():
import re
from core.data import smtp, fpr
if raw_input(' Flush message headers [y/N]:> ') in ['y', 'Y']:
for k in smtp['headers'].keys():
if re.match('^h\d*_', k):
h = re.match('^h\d*_(.*)$', k)
#print (k,h.group(1)) #DEBUG
del smtp['headers'][k]
fpr.ok('Message headers were flushed !')
def att_raw_sample(mbody, smtype, sm):
#from core.data import smpls,fpr,tc,tr
#from core.ui.cmenu import Menu
#from core.ui.banner import bancls
while True:
bancls()
if smpls[smtype]['astat'] != 0:
fpr('It seems you have already attached this type of sample')
if not raw_input(' Do you want to append another one [y/N]:') in [
'y', 'Y'
]:
break
if True:
smpl_menu = Menu(sm)
if smpl_menu.op == '':
break
#if smpl_menu.op == '1':
if smpl_menu.op in ['1', '2', '3', '4']:
#FIXME this will not work like that for long tmal
# fix sampel types in this shity way, the whole code regarding samples need
# to be rewritten and reorginize, this is not flexible/scalable
if smpls[smtype][smpl_menu.op].get('type') == 'text':
#this overwites type under smpls[smtype]['type']
if smpls[smtype][smpl_menu.op].get('sval', '') == '_':
# mbody.append(smpls[smtype][smpl_menu.op]['val'].replace("_",""))
smtp['content']['text'].append(
smpls[smtype][smpl_menu.op]['val'].replace(
smpls[smtype][smpl_menu.op]['sval'], ""))
else:
#print "wtf: %s - %s" % (smtype,smpls[smtype][smpl_menu.op]['val'])
#mbody here is smtp['content']['vof'] - this is dict {} - so overwrite
#this with fixed path to 'text' or create a seperate att_plain and add
#this as mime plain/text ???
#mbody.append(smpls[smtype][smpl_menu.op]['val'])
smtp['content']['text'].append(
smpls[smtype][smpl_menu.op]['val'])
smpls[smtype]['astat'] += 1
fpr.ok('Sample attached (x%d)' % smpls[smtype]['astat'])
break
else:
if smpls[smtype]['type'] == 'b64':
#att_b64(mbody,smtype,'1')
att_b64(mbody, smtype, smpl_menu.op)
elif smpls[smtype]['type'] == 'file':
#att_file_sample(mbody,smtype,'1')
att_file_sample(mbody, smtype, smpl_menu.op)
break
def att_dkim_signature(dsig):
if smtp['sign']['dkim']['dstat'] != 0:
fpr('It seems you have already attached %s DKIM Signature' %
smtp['sign']['dkim']['dstat'])
if not raw_input(' Do you want to append another one [y/N]:') in [
'y', 'Y'
]:
return
smtp['headers']['h' + str(smtp['sign']['dkim']['dstat']) +
'_DKIM-Signature'] = dsig
smtp['sign']['dkim']['dstat'] += 1
fpr.ok('DKIM Signature attached (x%d)' % smtp['sign']['dkim']['dstat'])
def get_timeout():
info('info','Note: Time waiting for server reply', adj='l' )
print
n = raw_input(' [%s]> ' % smtp['dha']['threads'].get('timeout',TH_TIMEOUT)) \
or smtp['dha']['threads'].get('timeout',TH_TIMEOUT)
if n and (type(n) is int or n.isdigit()):
if 0 <= int(n):
print
smtp['dha']['threads']['timeout']=int(n)
fpr.ok('%s'%n)
else:
print
fpr.fail('%s'%n)
def dumpSession():
info('info','Saved session allows to save current connection and message setting to be \n' \
'useful with further tests, as a proof of successful test or used as template\n\n'\
'Note: Session file can store sensitive data like SMTP authentication\n' \
' credential or private keys and certificate.',adj='l')
print
if not get_yesno_input(
' Would you like to save your current session: [y/N]> '):
return
print
fpr('Session files are stored under the session subdirectory by default.\n' \
'Please provide a full path if you would like to store you session somehere else.')
sessfile = 'minja-' + datetime.now().strftime('%Y%m%d%H%M%S') + '.session'
print
sf = raw_input(' [%s]> ' % sessfile) or sessfile
print
if sf == sessfile or not os.path.dirname(sf):
sf = cfgs['sess_path'] + '/' + sf
if os.path.exists(sf):
fpr('Session file already exist')
else:
if os.access(os.path.dirname(sf), os.W_OK):
#the file does not exists but write privileges are given
fpr('Saving under %s\n' % sf)
#import json
dd = outSMTPdict(smtp)
try:
#f = codecs.open(sf, 'w', encoding='utf-8')
f = open(sf, 'w')
json.dump(dd, f, indent=3)
fpr.ok('Session saving')
except IOError as e:
fpr.err('Saving file failed: %s' % e)
else:
fpr.fail('Missing write permission')
def get_delay():
info('info','Note: Delay is number of miliseconds between starting new threads, \n' \
' where each new thread is a new SMTP connection.', adj='l'
)
print
n = raw_input(' [%s]> ' % smtp['dha']['threads'].get('delay',TH_DELAY)) \
or smtp['dha']['threads'].get('delay',TH_DELAY)
if n and (type(n) is int or n.isdigit()):
if 0 <= int(n):
print
smtp['dha']['threads']['delay']=int(n)
fpr.ok('%s'%n)
else:
print
fpr.fail('%s'%n)
def save_content_asfile(content, fn, mode='w'):
# if os.path.isfile(fn):
# if not get_yesno_input (' File already exist. Overwrite it [y/N]: '):
# return False
try:
with open(fn, mode) as fo:
fo.write(content)
fpr.ok('Saving content in %s' % fn)
except IOError as ioex:
fpr.fail('Saving content in %s' % fn )
#fpr.fail('Err: Logs not saved with %s' % logfile )
print
fpr.err('Errno: %s' % ioex.errno)
fpr.err('Err code: %s' % errno.errorcode[ioex.errno])
fpr.err('Err message: %s' % os.strerror(ioex.errno) )
def att_load_eml(mbody, emlfn):
#import os
#from core.data import smtp,fpr,tc,tr
#from core.func import waitin,dbginfo
if os.path.isfile(emlfn):
print
fpr('Loading %s ..' % emlfn)
fp = open(emlfn, 'rb')
inputs = fp.read()
fp.close()
if not inputs:
dbginfo(
'error',
'Err: File has no content. Please verify file size !\n[ %s ]' %
emlfn)
#break
return False
if inputs:
info('info', '-- Loaded message: Top dump (view: 500 chars) --',
'%s' % inputs[:500] + ' . . .')
print
#dbglog(inputs)
fpr.ok('Message content has been loaded')
#smtp['content']['string'] = ''.join(inputs)
mbody['string'] = ''.join(inputs)
#smtp['content']['string'] = '\r\n'.join(inputs)
#smtp['use_mime'] = False
waitin()
else:
fpr('No such file or you don\'t have a permission to access it')
print
return False
def get_rate():
# from core.data import smtp,fpr,tc,tr
# import re
rate = smtp['replay']['threads'].get('rate', '')
fpr('Allowed values are N, N/Ms, N/Mm, N/Mh')
fpr('where:')
fpr(' N - number of Recipients/Messages \
\n M - value of s-seconds, m-minutes or h-hours\n')
print
r = raw_input(' [%s]> ' % (rate or ''))
if r:
m = re.match(r'^(\d+)(\/)*(\d+[smh])*$', r)
if not m:
# print
fpr.err('Err: Incorrect syntax')
return False
else:
#print type(m.group())
#if m.group(1):
# print m.group(1)
#if m.group(2):
# print m.group(2)
#if m.group(3):
# print m.group(3)
if m.group(1) and not m.group(2):
fpr.ok('%s' % m.group())
smtp['replay']['threads']['rate'] = m.group()
return m.group()
if m.group(3):
fpr.ok('%s' % m.group())
smtp['replay']['threads']['rate'] = m.group()
return m.group()
else:
return (rate or '')
def run_wizzard_host(d):
# WHAT CAN BE DONE MORE:
# - use get)single and get_yesno fun
# - modify to support multiple hosts ?
fpr('Welcome in Wizzard')
print
fpr('Please follow .. ')
print
t = dict()
t['host'] = get_single_input('SMTP Host', d.get('host',''),nl='')
t['port'] = get_single_input('SMTP Port', d.get('port',''),nl='')
t['helo'] = get_single_input('SMTP HELO', d.get('helo',''),nl='')
t['smtp_auth_user'] = get_single_input('SMTP AUTH Username ', d.get('smtp_auth_user',''),nl='')
t['smtp_auth_pass'] = get_single_input('SMTP AUTH Password ', d.get('smtp_auth_pass',''),nl='')
# t['tls_mode'] = get_single_input('SMTP TLS', d.get('tls_mode','NoTLS'),nl='')
if d.get('tls_mode') == 'NoTLS':
fpr('TLS Mode: Disabled')
if get_yesno_input(' > Enable TLS mode [y/N]> '):
t['tls_mode'] = 'TLS'
fpr('TLS Mode: Enabled')
elif d.get('tls_mode') == 'TLS':
fpr('TLS Mode: Enabled')
if get_yesno_input(' > Disable TLS mode [y/N]> '):
t['tls_mode'] = 'NoTLS'
fpr('TLS Mode: Disabled')
print
if raw_input(' Save [Y/n]> ') in ['y', 'Y', '']:
print
fpr.ok('Settings saved')
for k in t.keys():
d[k] = t[k]
else:
print
fpr.fail('Settings not saved!')
def get_msgs_delay():
# from core.data import smtp,fpr,tc,tr
# from core.data import MAX_MSG_PER_TH
# from core.func import info
info('info','Note: Delay is number of miliseconds between starting new threads, \n' \
' where each new thread is a new SMTP connection.', adj='l'
)
#fpr('Specify Delay between running new thread/connection')
print
n = raw_input(' [%s]> ' % smtp['replay']['threads'].get('delay',TH_DELAY)) \
or smtp['replay']['threads'].get('delay',TH_DELAY)
if n and (type(n) is int or n.isdigit()):
if 0 <= int(n):
print
smtp['replay']['threads']['delay'] = int(n)
fpr.ok('%s' % n)
else:
print
fpr.fail('%s' % n)
def mpart_saver(part, op):
if op == 1: #save as it is, no decoding
#pprint(part)
part['encext'] = None
for (h, hv) in part['mheaders']:
#fpr('%s: %s' % (h,hv))
if h.lower() == 'content-transfer-encoding':
part['encext'] = '.' + hv.lower()
print
if not get_yesno_input(' Would you like to save this part: [y/N]> '):
return
print
if part['filename']:
fn = part['filename'] + part['encext']
else:
fn = 'minja-' + part['type'].replace(
'/', '_') + '-' + datetime.now().strftime(
'%Y%m%d%H%M%S') + part['encext']
print
fn = raw_input(' [%s]> ' % fn) or fn
print
#if sf == sessfile or not os.path.dirname(sf):
# sf = cfgs['sess_path']+'/'+sf
if not os.path.dirname(fn):
fn = cfgs['mparts_path'] + '/' + fn
if os.path.exists(fn):
fpr('File already exist')
else:
if os.access(os.path.dirname(fn), os.W_OK):
#the file does not exists but write privileges are given
fpr('Saving under %s\n' % fn)
try:
#f = codecs.open(fn, 'w', encoding='utf-8')
f = open(fn, 'w')
f.write(part['payload'])
f.close()
fpr.ok('Session saving')
except IOError as e:
fpr.err('Saving file failed: %s' % e)
else:
fpr.fail('Missing write permission')
if op == 2: #decode base64 first
print
if not get_yesno_input(' Would you like to save this part: [y/N]> '):
return
print
if part['filename']:
fn = part['filename']
else:
fn = 'minja-' + part['type'].replace(
'/', '_') + '-' + datetime.now().strftime('%Y%m%d%H%M%S')
print
fn = raw_input(' [%s]> ' % fn) or fn
print
#if sf == sessfile or not os.path.dirname(sf):
# sf = cfgs['sess_path']+'/'+sf
if not os.path.dirname(fn):
fn = cfgs['mparts_path'] + '/' + fn
if os.path.exists(fn):
fpr('File already exist')
else:
if os.access(os.path.dirname(fn), os.W_OK):
#the file does not exists but write privileges are given
fpr('Saving under %s\n' % fn)
try:
#f = codecs.open(fn, 'w', encoding='utf-8')
f = open(fn, 'wb')
d = decode_attch(part['payload'])
#pprint(d)
f.write(d['raw'])
f.close()
fpr.ok('Session saving')
except IOError as e:
fpr.err('Saving file failed: %s' % e)
else:
fpr.fail('Missing write permission')
def e_base64(op):
# load from file
if op == '1':
fn = ''
while True:
bancls()
fpr('Diagnostics: Base64 encoder')
print
fpr('Please provide a file name:')
fn = raw_input(' []> ')
print
inputs = get_file_content(fn)
print
if inputs:
#inputs = f.readlines() # include \n
#inputs = f.read().splitlines() # exclude \n
dbginfo('debug', inputs)
print
encb64 = coders.encode_attch(inputs)
if isinstance(encb64, dict):
fpr.ok('File content was encoded successful')
else:
fpr.fail('File content was not encoded')
waitin()
return encb64
elif raw_input(' Return to menu [y/N]> ') in ['y', 'Y']:
break
waitin()
# load from input - paste it
if op == '2':
bancls()
fpr('Diagnostics: Base64 encoder')
print
if raw_input(' Would you like to encode some content [y/N]> ') in [
'y', 'Y'
]:
print
fpr('Please provide some plain content')
fpr('Use Ctrl-D with new line to continue.')
print
fpr.blue('_' * (tc - 4))
print
inputs = get_inputs()
fpr.blue('_' * (tc - 4))
if inputs:
dbglog(inputs)
print
encb64 = coders.encode_attch('\n'.join(inputs))
if isinstance(encb64, dict):
fpr.ok('Input content was encoded successful')
else:
fpr.fail('Input content was not encoded')
waitin()
return encb64
#print inputs
waitin()
fpr('_' * (tc - 4))
if dd.get('ip'):
res, code, expl = q.check()
valid = True
else:
print
fpr.warn(
'Verification skipped. Missing client IP address!')
except spf.TempError, e:
fpr.err('Error: %s' % e)
print
if not valid:
fpr.fail('SPF policy validation')
return
fpr.ok('SPF policy validation')
print
fpr('SPF Verification result')
fpr('_' * (tc - 4) + '\n\n')
fpr.info('%s,%s,%s' % (res, code, expl))
print
fpr('SPF status : %s' % res)
fpr.info('SPF code : %s ' % code)
fpr('SPF info : %s' % expl)
fpr('_' * (tc - 4) + '\n\n')
"""
| get_header(self, res, receiver=None, header_type='spf', aid=None, **kv)
| Generate Received-SPF or Authentication Results header based on the
| last lookup.
def setSPFvalues(deauth, sh, x):
# deauth - dictionary with current SPF values
# sh - dictionary with parsed headers
# xhv - header number
def cldeauth(death=deauth):
del deauth['spf']
deauth.setdefault(
'spf',
dict({
'id': {
'mfrom': '',
'helo': '',
'pra': ''
},
'ip': None
}))
from pprint import pprint
from core.func import get_single_input
n = 0
for i in sh:
#fpr("%s" % i)
for j in sh[i]:
n += 1
if n == x:
# pprint(sh[i][j])
if i == 'Received-SPF':
if sh[i][j].get('identity') == 'mailfrom':
cldeauth()
deauth['spf']['id']['mfrom'] = sh[i][j].get(
'envelope-from')
deauth['spf']['ip'] = sh[i][j].get('client-ip')
# x-sender - container of helo value (Cisco ESA)
if sh[i][j].get('identity') == 'helo':
cldeauth()
if sh[i][j].get('x'):
deauth['spf']['id']['helo'] = sh[i][j]['x'].get(
'x-sender')
deauth['spf']['ip'] = sh[i][j].get('client-ip')
if i == 'Authentication-Results':
if sh[i][j].get('spf'):
if sh[i][j]['spf'].get('helo') and sh[i][j]['spf'].get(
'mailfrom'):
fpr('The Authentication-Results store more than one SPF identity'
)
fpr('Choose identity:')
print
fpr(' 1) mailfrom')
fpr(' 2) helo')
fpr.info(' 3) pra')
x = get_single_input('', '')
if x == '1':
cldeauth()
deauth['spf']['id']['mfrom'] = sh[i][j]['spf'][
'mailfrom'].get('value')
if x == '2':
cldeauth()
deauth['spf']['id']['helo'] = sh[i][j]['spf'][
'helo'].get('value')
#from core.msg.viewers import viewers
bancls()
import core.msg.viewers as viewers
viewers.viewSPFvalues(deauth['spf'])
fpr.ok('SPF values has been set')
if DDDEBUG: pprint(deauth)
def get_sample(sample):
#import os
#import hashlib
#from urllib2 import Request, urlopen, URLError, HTTPError
#from core.func import dbginfo
fpr('Fetching sample .. ')
fn = sample['filename']+'.tmp'
url = sample['url']
req = Request(url)
try:
r = urlopen(req)
print
except HTTPError as e:
dbginfo('error',
'Err: The server couldn\'t fulfill the request.\n' \
'Code: %s ' % e.code
)
except URLError as e:
dbginfo('error',
'Err: Server can not be reached!\n' \
'Reason: %s ' % e.reason
)
else:
# everything is fine
data = r.read()
fpr.ok('Data fetching')
with open(fn,"wb") as f:
if data:
try:
f.write(data)
except IOError:
fpr.fail('Temporary file saving')
return
else:
f.close()
fpr.ok('Temporary file saving')
if os.path.isfile(fn):
md5tmpfn = hashlib.md5(open(fn, 'rb').read()).hexdigest()
#print sample['md5']
#print hashlib.md5(open(fn, 'rb').read()).hexdigest()
if sample['md5'] == md5tmpfn:
fpr.ok('Hash testing')
try:
os.rename(fn, sample['filename'])
except IOError:
fpr.fail('File saving')
return
else:
fpr.ok('File saving')
else:
fpr.fail('Hash testing')
else:
fpr.err('No data')
return
def dkim_vrfy(message):
PYDNS_AVAILABLE = False
DNSPYTHON_AVAILABLE = False
# check dns libraries
try:
import dns
DNSPYTHON_AVAILABLE = True
except ImportError:
pass
try:
import DNS
PYDNS_AVAILABLE = True
except ImportError:
pass
try:
from dkim import DKIM, verify, DKIMException
if not (PYDNS_AVAILABLE or DNSPYTHON_AVAILABLE):
raise Exception("no supported dns library available")
except:
pass
try:
import dkim
if True:
d = dkim.DKIM(message)
#print 'dir:',dir(d)
#print 'sel:',d.selector
#print 'dom:',d.domain
#print 'h:',d.headers
#print 'sh:',d.signed_headers
#print 'sa:',d.signature_algorithm
#print 'sf:',d.signature_fields
#print 'ks:',d.keysize
r = d.verify()
fpr('Signature details')
fpr('_' * (tc - 4))
print
fpr(' selector (s): %s' % d.selector)
fpr(' domain (d): %s' % d.domain)
fpr(' headers : %s' % d.headers)
fpr(' signed heads: %s' % d.signed_headers)
fpr(' key algo (a): %s' % d.signature_algorithm)
fpr(' key size : %s' % d.keysize)
print
fpr(' DKIM-Signature: %s' % d.signature_fields)
fpr('_' * (tc - 4))
print
else:
r = dkim.verify(message)
if r:
fpr.ok("DKIM signature verification successful")
else:
fpr.fail("DKIM signature verification failed")
except DKIMException, e:
fpr("Verification result:")
print
fpr('%s' % e)
print
fpr.fail("DKIM signature verification failed")
