def main():
# Load the whitelist into memory
WhiteListLoad()
HashTableLoad()
thread_pool = create_and_start_worker_threads()
# Register to have the Milter factory create instances of the class:
Milter.factory = MacroMilter
flags = Milter.CHGBODY + Milter.CHGHDRS + Milter.ADDHDRS
flags += Milter.ADDRCPT
flags += Milter.DELRCPT
Milter.set_flags(flags) # tell Sendmail which features we use
# start milter processing
print "%s Macro milter startup - Version %s" % (time.strftime('%d.%b.%Y %H:%M:%S'), __version__)
sys.stdout.flush()
# set the "last" fall back to ACCEPT if exception occur
Milter.set_exception_policy(Milter.ACCEPT)
# start the milter
Milter.runmilter("MacroMilter", SOCKET, TIMEOUT)
shutdown_worker_threads(thread_pool)
cleanup_queues()
print "%s Macro milter shutdown" % time.strftime('%d.%b.%Y %H:%M:%S')
def main():
# banner
print('mraptor_milter v%s - http://decalage.info/python/oletools' % __version__)
print('logging to file %s' % LOGFILE_PATH)
print('Press Ctrl+C to stop.')
# make sure the log directory exists:
try:
os.makedirs(LOGFILE_DIR)
except:
pass
# Add the log message handler to the logger
# log to files rotating once a day:
handler = logging.handlers.TimedRotatingFileHandler(LOGFILE_PATH, when='D', encoding='utf8')
# create formatter and add it to the handlers
formatter = logging.Formatter('%(asctime)s - %(levelname)8s: %(message)s')
handler.setFormatter(formatter)
log.addHandler(handler)
# enable logging:
log.setLevel(logging.DEBUG)
log.info('Starting mraptor_milter v%s - listening on %s' % (__version__, SOCKET))
log.debug('Python version: %s' % sys.version)
# Register to have the Milter factory create instances of the class:
Milter.factory = MacroRaptorMilter
flags = Milter.CHGBODY + Milter.CHGHDRS + Milter.ADDHDRS
flags += Milter.ADDRCPT
flags += Milter.DELRCPT
Milter.set_flags(flags) # tell Sendmail which features we use
# set the "last" fall back to ACCEPT if exception occur
Milter.set_exception_policy(Milter.ACCEPT)
# start the milter
Milter.runmilter("mraptor_milter", SOCKET, TIMEOUT)
log.info('Stopping mraptor_milter.')
def main():
# banner
print('mraptor_milter v%s - http://decalage.info/python/oletools' % __version__)
print('logging to file %s' % LOGFILE_PATH)
print('Press Ctrl+C to stop.')
# make sure the log directory exists:
try:
os.makedirs(LOGFILE_DIR)
except:
pass
# Add the log message handler to the logger
# log to files rotating once a day:
handler = logging.handlers.TimedRotatingFileHandler(LOGFILE_PATH, when='D', encoding='utf8')
# create formatter and add it to the handlers
formatter = logging.Formatter('%(asctime)s - %(levelname)8s: %(message)s')
handler.setFormatter(formatter)
log.addHandler(handler)
# enable logging:
log.setLevel(logging.DEBUG)
log.info('Starting mraptor_milter v%s - listening on %s' % (__version__, SOCKET))
log.debug('Python version: %s' % sys.version)
# Register to have the Milter factory create instances of the class:
Milter.factory = MacroRaptorMilter
flags = Milter.CHGBODY + Milter.CHGHDRS + Milter.ADDHDRS
flags += Milter.ADDRCPT
flags += Milter.DELRCPT
Milter.set_flags(flags) # tell Sendmail which features we use
# set the "last" fall back to ACCEPT if exception occur
Milter.set_exception_policy(Milter.ACCEPT)
# start the milter
Milter.runmilter("mraptor_milter", SOCKET, TIMEOUT)
log.info('Stopping mraptor_milter.')
def main():
# make sure the log directory exists:
try:
os.makedirs(LOGFILE_DIR, 0o0027)
except:
pass
# Load the whitelist into memory
WhiteListLoad()
HashTableLoad()
# Add the log message handler to the logger
# rotation handeld by logrotatd
oldumask = os.umask(0o0026)
handler = logging.handlers.WatchedFileHandler(LOGFILE_PATH,
encoding='utf8')
# create formatter and add it to the handlers
formatter = logging.Formatter('%(asctime)s - %(levelname)8s: %(message)s')
handler.setFormatter(formatter)
log.addHandler(handler)
os.umask(oldumask)
# Loglevels are: 1 = Debug, 2 = Info, 3 = Error
if LOGLEVEL == 2:
log.setLevel(logging.INFO)
elif LOGLEVEL == 3:
log.setLevel(logging.WARNING)
else:
log.setLevel(logging.DEBUG)
# Register to have the Milter factory create instances of the class:
Milter.factory = MacroMilter
flags = Milter.CHGBODY + Milter.CHGHDRS + Milter.ADDHDRS
flags += Milter.ADDRCPT
flags += Milter.DELRCPT
Milter.set_flags(flags) # tell Sendmail which features we use
# start milter processing
print("%s MacroMilter startup - Version %s" %
(time.strftime('%Y-%m-%d %H:%M:%S'), __version__))
print('logging to file %s' % LOGFILE_PATH)
log.info('Starting MarcoMilter v%s - listening on %s' %
(__version__, SOCKET))
log.debug('Python version: %s' % sys.version)
sys.stdout.flush()
# ensure desired permissions on unix socket
os.umask(UMASK)
# set the "last" fall back to ACCEPT if exception occur
Milter.set_exception_policy(Milter.ACCEPT)
# start the milter
Milter.runmilter("MacroMilter", SOCKET, TIMEOUT)
print("%s MacroMilter shutdown" % time.strftime('%Y-%m-%d %H:%M:%S'))
def main():
# Load the whitelist into memory
WhiteListLoad()
HashTableLoad()
# create helper threads
bt = Thread(target=background)
perft = Thread(target=writeperformacedata)
ha = Thread(target=writehashtofile)
ex = Thread(target=writeExData)
# start helper threads
ex.start()
perft.start()
bt.start()
ha.start()
# Register to have the Milter factory create instances of the class:
Milter.factory = MacroMilter
flags = Milter.CHGBODY + Milter.CHGHDRS + Milter.ADDHDRS
flags += Milter.ADDRCPT
flags += Milter.DELRCPT
Milter.set_flags(flags) # tell Sendmail which features we use
# start milter processing
print "%s Macro milter startup - Version %s" % (time.strftime('%d.%b.%Y %H:%M:%S'), __version__)
sys.stdout.flush()
# set the "last" fall back to ACCEPT if exception occur
Milter.set_exception_policy(Milter.ACCEPT)
# start the milter
Milter.runmilter("MacroMilter",SOCKET,TIMEOUT)
# wait for helper threads
bt.join() # stop logging thread
perft.join() # stop performance data thread
ha.join() # stop hash data thread
ex.join() # stop filename thread - obsolete - delete in next version
# cleanup the queues
logq.put(None)
extension_data.put(None)
hash_to_write.put(None)
performace_data.put(None)
print "%s Macro milter shutdown" % time.strftime('%d.%b.%Y %H:%M:%S')
def main():
# TODO: log to file with rotation
logging.basicConfig(format='%(levelname)8s: %(message)s', level=logging.DEBUG)
logging.info('Starting MacroRaptorMilter - listening on %s' % SOCKET)
logging.info('Press Ctrl+C to stop.')
# Register to have the Milter factory create instances of the class:
Milter.factory = MacroRaptorMilter
flags = Milter.CHGBODY + Milter.CHGHDRS + Milter.ADDHDRS
flags += Milter.ADDRCPT
flags += Milter.DELRCPT
Milter.set_flags(flags) # tell Sendmail which features we use
# set the "last" fall back to ACCEPT if exception occur
Milter.set_exception_policy(Milter.ACCEPT)
# start the milter
Milter.runmilter("MacroRaptorMilter", SOCKET, TIMEOUT)
logging.info('Stopping MacroRaptorMilter.')
def main():
bt = Thread(target=background)
bt.start()
#socketname = "/home/stuart/pythonsock"
socketname = 'inet:[email protected]'
timeout = 600
# Register to have the Milter factory create instances of your class:
Milter.factory = myMilter
flags = Milter.CHGBODY + Milter.CHGHDRS + Milter.ADDHDRS
flags += Milter.ADDRCPT
flags += Milter.DELRCPT
Milter.set_flags(flags) # tell Sendmail which features we use
#Milter.setdbg(3)
Milter.settimeout(10)
Milter.set_exception_policy(0)
print("%s milter startup" % time.strftime('%Y%b%d %H:%M:%S'))
sys.stdout.flush()
Milter.runmilter("pythonfilter", socketname, timeout)
logq.put(None)
bt.join()
print("%s bms milter shutdown" % time.strftime('%Y%b%d %H:%M:%S'))
if hres and q.h != q.o:
self.add_header('X-Hello-SPF', hres, 0)
return Milter.CONTINUE
if __name__ == "__main__":
Milter.factory = spfMilter
Milter.set_flags(Milter.CHGHDRS + Milter.ADDHDRS)
global config
config = read_config([
'spfmilter.cfg', '/etc/mail/spfmilter.cfg',
'/etc/postfix/spfmilter.cfg'
])
ue = config.untrapped_exception.upper()
if ue == 'CONTINUE':
Milter.set_exception_policy(Milter.CONTINUE)
elif ue == 'REJECT':
Milter.set_exception_policy(Milter.REJECT)
elif ue == 'TEMPFAIL':
Milter.set_exception_policy(Milter.TEMPFAIL)
else:
print("WARNING: invalid untrapped_exception policy: %s" % ue)
miltername = config.miltername
socketname = config.socketname
# FIXME: set process umask based on config
print(
"""To use this with sendmail, add the following to sendmail.cf:
O InputMailFilters=%s
X%s, S=local:%s
def main():
"Run PyQuarantine-Milter."
# parse command line
parser = argparse.ArgumentParser(
description="PyQuarantine milter daemon",
formatter_class=lambda prog: argparse.HelpFormatter(
prog, max_help_position=45, width=140))
parser.add_argument("-c",
"--config",
help="List of config files to read.",
nargs="+",
default=pyquarantine.QuarantineMilter.get_cfg_files())
parser.add_argument("-s",
"--socket",
help="Socket used to communicate with the MTA.",
default="inet:[email protected]")
parser.add_argument("-d",
"--debug",
help="Log debugging messages.",
action="store_true")
parser.add_argument("-t",
"--test",
help="Check configuration.",
action="store_true")
parser.add_argument("-v",
"--version",
help="Print version.",
action="version",
version=f"%(prog)s ({version})")
args = parser.parse_args()
# setup logging
loglevel = logging.INFO
logname = "pyquarantine-milter"
syslog_name = logname
if args.debug:
loglevel = logging.DEBUG
logname = f"{logname}[%(name)s]"
syslog_name = f"{syslog_name}: [%(name)s] %(levelname)s"
# set config files for milter class
pyquarantine.QuarantineMilter.set_cfg_files(args.config)
root_logger = logging.getLogger()
root_logger.setLevel(loglevel)
# setup console log
stdouthandler = logging.StreamHandler(sys.stdout)
stdouthandler.setLevel(logging.DEBUG)
formatter = logging.Formatter("%(message)s")
stdouthandler.setFormatter(formatter)
root_logger.addHandler(stdouthandler)
logger = logging.getLogger(__name__)
if args.test:
try:
pyquarantine.setup_milter(test=args.test)
print("Configuration ok")
except RuntimeError as e:
logger.error(e)
sys.exit(255)
else:
sys.exit(0)
formatter = logging.Formatter(
f"%(asctime)s {logname}: [%(levelname)s] %(message)s",
datefmt="%Y-%m-%d %H:%M:%S")
stdouthandler.setFormatter(formatter)
# setup syslog
sysloghandler = logging.handlers.SysLogHandler(
address="/dev/log", facility=logging.handlers.SysLogHandler.LOG_MAIL)
sysloghandler.setLevel(loglevel)
formatter = logging.Formatter(f"{syslog_name}: %(message)s")
sysloghandler.setFormatter(formatter)
root_logger.addHandler(sysloghandler)
logger.info("PyQuarantine-Milter starting")
try:
# generate milter config
pyquarantine.setup_milter()
except RuntimeError as e:
logger.error(e)
sys.exit(255)
# register to have the Milter factory create instances of your class:
Milter.factory = pyquarantine.QuarantineMilter
Milter.set_exception_policy(Milter.TEMPFAIL)
# run milter
rc = 0
try:
Milter.runmilter("pyquarantine-milter",
socketname=args.socket,
timeout=300)
except Milter.milter.error as e:
logger.error(e)
rc = 255
pyquarantine.mailer.queue.put(None)
logger.info("PyQuarantine-Milter terminated")
sys.exit(rc)
def main():
if LOGHANDLER == 'file':
endstr = '**'
# make sure the log directory exists:
try:
os.makedirs(LOGFILE_DIR, 0o0027)
except:
pass
else:
endstr = ''
# Load the whitelist into memory
global WhiteList, Hash_Whitelist
global r
global rsub
global wfp
global bg_redis_write
global bg_submit_wf
WhiteList, Hash_Whitelist= wildlib.whiteListLoad(CONFIG)
# Register to have the Milter factory create instances of your class:
Milter.factory = WildfireMilter
flags = Milter.ADDHDRS
Milter.set_flags(flags) # tell Sendmail which features we use
print("\n*************************************************************")
print("*********** %s startup - Version %s ***********" % ('Wildfire Milter', __version__))
print('************* logging to %s' % LOGHANDLER, end='')
if LOGSTDOUT:
print(' and to stdout ', end=endstr)
else:
print(' **************', end=endstr)
print("**************\n*************************************************************\n")
log.info('* Starting %s v%s - listening on %s' % ('Wildfire Milter', __version__, SOCKET))
log.debug('* Python version: %s' % str(sys.version).replace('\n', ' - '))
log.debug('* Config file: %s' % CONFIG)
print()
sys.stdout.flush()
# Initialize Wildfire API
wfp = wildlib.wildfireConnect(WILDHOST, WILDKEY)
# Initialize main Redis Cache
r = wildlib.redisConnect(REDISHOST, REDISPORT, REDISDB, REDISAUTH)
# Initialize Redis Cache for Wildfire submit
if 'threading' in sys.modules and submitq is not None:
# This is done in another process/thread
rsub = None
else:
rsub = wildlib.redisConnect(REDISHOST, REDISPORT, DBSUB, REDISAUTH)
# ensure desired permissions on unix socket
os.umask(UMASK)
# set the "last" fall back to ACCEPT if exception occur
Milter.set_exception_policy(Milter.ACCEPT)
if TASK_TYPE != 'single':
bg_redis_write = Thread(target=redis_background_write, args=(redisq,))
bg_submit_wf = Thread(target=submit_wildfire_background, args=(submitq,))
bg_redis_write.start()
bg_submit_wf.start()
# Notify systemd that the milter is ready to serve and to protect
if systemd.daemon.booted():
systemd.daemon.notify('READY=1')
systemd.daemon.notify('STATUS=Initialization of WildFire API and Redis completed. Ready to work.')
# start the milter #################################
Milter.runmilter('WildfireMilter', SOCKET, TIMEOUT)
####################################################
if TASK_TYPE != 'single':
# Terminate the running threads.
redisq.put(None)
submitq.put(None)
bg_redis_write.join()
bg_submit_wf.join()
if systemd.daemon.booted():
systemd.daemon.notify('STOPPING=1')
systemd.daemon.notify('STATUS=Wildfire Milter ready to stop.')
log.info('Wildfire Milter shutdown')
print("\n*********** %s shutdown ***********\n" % 'WildfireMilter')
def main():
python_version = ".".join([str(v) for v in sys.version_info[0:3]])
python_version = f"{python_version}-{sys.version_info[3]}"
"Run PyMod-Milter."
parser = argparse.ArgumentParser(
description="PyMod milter daemon",
formatter_class=lambda prog: argparse.HelpFormatter(
prog, max_help_position=45, width=140))
parser.add_argument(
"-c", "--config", help="Config file to read.",
default="/etc/pymodmilter/pymodmilter.conf")
parser.add_argument(
"-s",
"--socket",
help="Socket used to communicate with the MTA.",
default="")
parser.add_argument(
"-d",
"--debug",
help="Log debugging messages.",
action="store_true")
parser.add_argument(
"-t",
"--test",
help="Check configuration.",
action="store_true")
parser.add_argument(
"-v", "--version",
help="Print version.",
action="version",
version=f"%(prog)s {version} (python {python_version})")
args = parser.parse_args()
root_logger = logging.getLogger()
root_logger.setLevel(logging.DEBUG)
# setup console log
stdouthandler = logging.StreamHandler(sys.stdout)
formatter = logging.Formatter("%(levelname)s: %(message)s")
stdouthandler.setFormatter(formatter)
root_logger.addHandler(stdouthandler)
logger = logging.getLogger(__name__)
if not args.debug:
logger.setLevel(logging.INFO)
try:
logger.debug("read milter configuration")
cfg = get_milter_config(args.config)
logger.setLevel(cfg.get_loglevel(args.debug))
if args.socket:
socket = args.socket
elif "socket" in cfg:
socket = cfg["socket"]
else:
raise RuntimeError(
"listening socket is neither specified on the command line "
"nor in the configuration file")
if not cfg["rules"]:
raise RuntimeError("no rules configured")
for rule in cfg["rules"]:
if not rule["actions"]:
raise RuntimeError(
f"{rule['name']}: no actions configured")
except (RuntimeError, AssertionError) as e:
logger.error(f"config error: {e}")
sys.exit(255)
try:
ModifyMilter.set_config(cfg, args.debug)
except RuntimeError as e:
logger.error(e)
sys.exit(254)
if args.test:
print("Configuration OK")
sys.exit(0)
# setup console log for runtime
formatter = logging.Formatter("%(asctime)s - %(levelname)s: %(message)s")
stdouthandler.setFormatter(formatter)
stdouthandler.setLevel(logging.DEBUG)
# setup syslog
sysloghandler = logging.handlers.SysLogHandler(
address="/dev/log", facility=logging.handlers.SysLogHandler.LOG_MAIL)
sysloghandler.setFormatter(
logging.Formatter("pymodmilter: %(message)s"))
root_logger.addHandler(sysloghandler)
logger.info("pymodmilter starting")
# register milter factory class
Milter.factory = ModifyMilter
Milter.set_exception_policy(Milter.TEMPFAIL)
if args.debug:
Milter.setdbg(1)
rc = 0
try:
Milter.runmilter("pymodmilter", socketname=socket, timeout=600)
except Milter.milter.error as e:
logger.error(e)
rc = 255
mailer.queue.put(None)
logger.info("pymodmilter stopped")
sys.exit(rc)
return Milter.CONTINUE
def abort(self):
print("abort after %d body chars" % self.bodysize)
return Milter.CONTINUE
#res=do_eml("From hello world\nJozsika\n\njkhdsjkdhas\n")
# TESTING
try:
fp = open("milter.eml", "rb")
#msg = mime.message_from_file(fp)
#print(type(fp))
try:
msg = email.message_from_binary_file(fp)
except:
msg = email.message_from_file(fp)
res = do_eml(msg)
print("X-deepspam: " + res)
except:
print("missing/bad milter.eml -> skipping self-test!")
# MILTER MODE
Milter.factory = deepspamMilter
Milter.set_flags(Milter.ADDHDRS)
Milter.set_exception_policy(Milter.ACCEPT)
sys.stdout.flush()
# Milter.runmilter("deepspam","/var/spool/postfix/var/run/deepspam",240)
Milter.runmilter("deepspam", "inet:1080", 240)
"%s has been blacklisted by %s." % (q.s,receiver))
return Milter.REJECT
self.add_header('Received-SPF',q.get_header(res,receiver),0)
if hres and q.h != q.o:
self.add_header('X-Hello-SPF',hres,0)
return Milter.CONTINUE
if __name__ == "__main__":
Milter.factory = spfMilter
Milter.set_flags(Milter.CHGHDRS + Milter.ADDHDRS)
global config
config = read_config(
['spfmilter.cfg','/etc/mail/spfmilter.cfg','/etc/postfix/spfmilter.cfg'])
ue = config.untrapped_exception.upper()
if ue == 'CONTINUE':
Milter.set_exception_policy(Milter.CONTINUE)
elif ue == 'REJECT':
Milter.set_exception_policy(Milter.REJECT)
elif ue == 'TEMPFAIL':
Milter.set_exception_policy(Milter.TEMPFAIL)
else:
print("WARNING: invalid untrapped_exception policy: %s"%ue)
miltername = config.miltername
socketname = config.socketname
# FIXME: set process umask based on config
print("""To use this with sendmail, add the following to sendmail.cf:
O InputMailFilters=%s
X%s, S=local:%s
