Test Postfix autoresponder w/ SMTP daemon

Author: pjkundert

slip39/invoice/email.py slip39/invoice/communications.pyslip39/invoice/email.py renamed to slip39/invoice/communications.py

@@ -35,7 +35,7 @@
 
 __author__                      = "Perry Kundert"
 __email__                       = "[email protected]"
-__copyright__                   = "Copyright (c) 2022 Dominion Research & Development Corp."
+__copyright__                   = "Copyright (c) 2023 Dominion Research & Development Corp."
 __license__                     = "Dual License: GPLv3 (or later) and Commercial (see LICENSE)"
 
 log				= logging.getLogger( 'email' )
@@ -57,6 +57,25 @@ def mx_records( domain, timeout=None ):
         yield mx
 
 
+def matchaddr( address, mailbox=None, domain=None ):
+    """The supplied email address begins with "<mailbox>", optionally followed by a "+<extension>", and
+    then ends with "@<domain>".  If so, return the re.match w/ the 3 groups.  If either 'mailbox' or
+    'domain' is falsey, any will be allowed.
+
+    Does not properly respect email addresses with quoting, eg. 'abc"123@456"@domain.com' because,
+    quite frankly, I don't want to and that's just "Little Bobby Tables" (https://xkcd.com/327/)
+    level asking for trouble...
+
+    Simple <mailbox>[+<extension>]@<domain>, please.
+
+    """
+    return re.match(
+        rf"(^{mailbox if mailbox else '[^@+]*'})(?:\+([^@]+))?@({domain if domain else '.*'})",
+        utils.parseaddr( address )[1],
+        re.IGNORECASE
+    )
+
+
 def dkim_message(
     sender_email,			# The message From:; may be empty (but not for DKIM). For display by the client
     subject,
@@ -99,9 +118,9 @@ def dkim_message(
     if signature_algorithm is None:
         signature_algorithm	= "rsa-sha256"  # "ed25519-sha256" not well supported, yet.
 
-    sender_domain = sender_email.split("@")[-1]
+    sender_domain		= matchaddr( sender_email ).group( 3 )
 
-    msg = multipart.MIMEMultipart("alternative")
+    msg				= multipart.MIMEMultipart("alternative")
     msg.attach(text.MIMEText(message_text, "plain"))
     if message_html:
         msg.attach(text.MIMEText(message_html, "html"))
@@ -117,7 +136,7 @@ def dkim_message(
     if reply_to_email:
         # Autoresponders don't generally respect Reply-To (as recommended in RFC-3834)
         # https://www.rfc-editor.org/rfc/rfc3834#section-4.
-        msg["Reply-To"] = reply_to_email
+        msg["Reply-To"]		= reply_to_email
     msg["Subject"]		= subject
 
     try:
@@ -146,7 +165,8 @@ def dkim_message(
         #     b'DKIM-Signature: v=1; i=@lic...\r\n s=... b=Fp2...6H\r\n 5//6o...Ag=='
         #                                     ^^^^^                ^^^^^
         #
-        # contains a bunch of errant whitespace, especially within the b: and bh: base-64 data
+        # contains a bunch of unnecessary whitespace, especially within the b: and bh: base-64
+        # data.  However, this whitespace is ignored by the standard email.Message parser.
         #
         pre,sig_dirty		= sig.decode( 'utf-8' ).split( ':', 1 )
         log.info( f"DKIM signed: {sig_dirty!r}" )
@@ -162,9 +182,7 @@ def dkim_message(
         #log.info( f"DKIM clean:  {sig_clean!r}" )
 
         # add the dkim signature to the email message headers.
-        # decode the signature back to string_type because later on
-        # the call to msg.as_string() performs it's own bytes encoding...
-        msg["DKIM-Signature"]	= sig_dirty.strip()   # sig_clean
+        msg["DKIM-Signature"]	= sig_dirty.strip()
 
         return msg
 
@@ -303,7 +321,7 @@ def getreply( self ):
     return msg
 
 
-class postqueue:
+class PostQueue:
     """A postfix-compatible post-queue filter.  See:
     https://codepoets.co.uk/2015/python-content_filter-for-postfix-rewriting-the-subject/
 
@@ -322,22 +340,48 @@ class postqueue:
 
     Postfix will pass all To:, Cc: and Bcc: recipients in to_addrs.
 
-    The reinject command is executed/called, and passed from_addr and *to_addrs.
+    The reinject command is executed/called, and passed from_addr and *to_addrs; False disables.
     """
     def __init__( self, reinject=None ):
-        if reinject is None:
-            reinject		= [ '/usr/bin/sendmail', '-G', '-i', '-f' ]
-        self.reinject		= reinject
+        if reinject in (None, True):
+            reinject		= [ '/usr/sbin/sendmail', '-G', '-i', '-f' ]
+        if is_listlike( reinject ):
+            self.reinject	= list( map( str, reinject ))
+        elif not reinject:
+            self.reinject	= lambda *args: None		# False, ''
+        else:
+            self.reinject	= reinject			# str, callable
+        log.info( f"Mail reinjection: {self.reinject!r}" )
 
     def respond( self, from_addr, *to_addrs ):
         msg			= self.message()
         try:
-            # Allow a command (list), or a function for reinject
+            # Allow a command (list), a shell command or a function for reinject
+            err			= None
             if is_listlike( self.reinject ):
-                with Popen( self.reinject + [ from_addr] + to_addrs, stdin=PIPE ) as process:
-                    process.communicate( msg.as_bytes() )
+                with Popen(
+                        self.reinject + [ from_addr] + list( to_addrs ),
+                        stdin	= PIPE,
+                        stdout	= PIPE,
+                        stderr	= PIPE
+                ) as process:
+                    out, err	= process.communicate( msg.as_bytes() )
+                    out		= out.decode( 'UTF-8' )
+                    err		= err.decode( 'UTF-8' )
+            elif isinstance( self.reinject, str ):
+                with Popen(
+                        f"{self.reinject} {from_addr} {' '.join( to_addrs )}",
+                        shell	= True,
+                        stdin	= PIPE,
+                        stdout	= PIPE,
+                        stderr	= PIPE
+                ) as process:
+                    out, err	= process.communicate( msg.as_bytes() )
+                    out		= out.decode( 'UTF-8' )
+                    err		= err.decode( 'UTF-8' )
             else:
-                self.reinject( from_addr, *to_addrs )
+                out		= self.reinject( from_addr, *to_addrs )
+            log.info( f"Results of reinjection: stdout: {out}, stderr: {err}" )
         except Exception as exc:
             log.warning( f"Re-injecting message From: {from_addr}, To: {commas( to_addrs )} via sendmail failed: {exc}" )
             raise
@@ -357,22 +401,7 @@ def response( self, msg ):
         return msg
 
 
-def matchaddr( address, mailbox=None, domain=None ):
-    """The supplied address begins with "<mailbox>", optionally followed by a "+<extension>", and
-    then ends with "@<domain>".  If so, return the re.match w/ the 3 groups.  If either 'mailbox' or
-    'domain' is falsey, any will be allowed.
-
-    Does not properly respect email addresses with quoting, eg. 'abc"123@456"@domain.com'
-    """
-    _,email			= utils.parseaddr( address )
-    return re.match(
-        rf"(^{mailbox if mailbox else '[^@+]*'})(?:\+([^@]+))?@({domain if domain else '.*'})",
-        email,
-        re.IGNORECASE
-    )
-
-
-class autoresponder( postqueue ):
+class AutoResponder( PostQueue ):
     def __init__( self, *args, address=None, server=None, port=None, **kwds ):
         m			= matchaddr( address or '' )
         assert m, \
@@ -460,20 +489,42 @@ def cli( verbose, quiet, json ):
 
 
 @click.command()
-@click.argument( 'address' )
+@click.argument( 'address', nargs=1 )
+@click.argument( 'from_addr', nargs=1 )
+@click.argument( 'to_addrs', nargs=-1 )
 @click.option( '--server', default='localhost' )
 @click.option( '--port', default=25 )
-def respond( address, server, port ):
+@click.option( '--reinject', type=str, default=None, help="A custom command to reinject email, eg. via sendmail" )
+@click.option( '--no-reinject', 'reinject', flag_value='', help="Disable reinjection of filtered mail, eg. via sendmail" )
+def autoresponder( address, from_addr, to_addrs, server, port, reinject ):
     """Run an auto-responder that replies to all incoming emails to the specified email address.
 
+    Will be invoked with a from_addr and 1 or more to_addrs.
+
     - Must be DKIM signed, including the From: and To: addresses.
     - The RCPT TO: "envelope" address must match 'address':
       - We won't autorespond to copies of the email being delivered to other inboxes
     - The MAIL FROM: "envelope" address must match the From: address
       - We won't autorespond to copies forwarded from other email addresses
 
+
+    Configure Postfix system as per: https://github.com/innovara/autoreply, except create
+
+        # autoresponder pipe
+        autoreply unix  -       n       n       -       -       pipe
+         flags= user=autoreply null_sender=
+         argv=python -m slip39.email autoresponder [email protected] ${sender} ${recipient}
+
     """
-    pass
+    AutoResponder(
+        address		= address,
+        server		= server,
+        port		= port,
+        reinject	= reinject,
+    ).respond( from_addr, *to_addrs )
+
+
+cli.add_command( autoresponder )
 
 
 if __name__ == "__main__":

slip39/invoice/email_test.py slip39/invoice/communications_test.pyslip39/invoice/email_test.py renamed to slip39/invoice/communications_test.py

@@ -1,20 +1,33 @@
-from io			import StringIO
+import logging
+import os
 
+from io			import StringIO
 from pathlib		import Path
+from subprocess		import Popen, PIPE
 
 import dkim
 
 from aiosmtpd.controller import Controller
 
-from .email		import dkim_message, send_message, matchaddr, autoresponder
+from .communications	import dkim_message, send_message, matchaddr, AutoResponder
 from ..defaults		import SMTP_TO, SMTP_FROM
 
+log				= logging.getLogger( __package__ )
 
 dkim_key			= Path( __file__ ).resolve().parent.parent.parent / 'licensing.dominionrnd.com.20221230.key'
 dkim_selector			= '20221230'
 
 
-def test_email_dkim():
+def test_communications_matchaddr():
+    assert matchaddr( "abc+def@xyz", mailbox="abc", domain="xyz" ).groups() == ("abc", "def", "xyz")
+    assert matchaddr( "abc+def@xyz",                domain="xYz" ).groups() == ("abc", "def", "xyz")
+    assert matchaddr( "abc+def@xyz", mailbox="Abc"               ).groups() == ("abc", "def", "xyz")
+    assert matchaddr( "abc+def@xyz",                             ).groups() == ("abc", "def", "xyz")
+    assert matchaddr( "abc+def@xyz",                             ).group( 3 ) == "xyz"
+    assert matchaddr( "abc+def@xyz", mailbox="xxx"               ) is None
+
+
+def test_communications_dkim():
     msg				= dkim_message(
         sender_email	= SMTP_FROM,			# Message From: specifies claimed sender
         to_email	= SMTP_TO,			# See https://dkimvalidator.com to test!
@@ -52,27 +65,19 @@ def test_email_dkim():
         msg,
         #from_addr	= SMTP_FROM,		# Envelope MAIL FROM: specifies actual sender
         #to_addrs	= [ SMTP_TO ],		# Will be the same as message To: (should default)
-        #relay		=  ['mail2.kundert.ca'],  # 'localhost',   # use eg. ssh -fNL 0.0.0.0:25:linda.mx.cloudflare.net:25 [email protected]
+        #relay		= ['mail2.kundert.ca'],  # 'localhost',   # use eg. ssh -fNL 0.0.0.0:25:linda.mx.cloudflare.net:25 [email protected]
         #port		= 25,  # 465 --> SSL, 587 --> TLS (default),
         #usessl = False, starttls = False, verifycert = False,  # to mail.kundert.ca; no TLS
         #usessl = False, starttls = True, verifycert = False,  # default
     )
+    # This may fail (eg. if you have no access to networking), so we don't check.
 
 
-def test_email_matchaddr():
-    assert matchaddr( "abc+def@xyz", mailbox="abc", domain="xyz" ).groups() == ("abc", "def", "xyz")
-    assert matchaddr( "abc+def@xyz",                domain="xYz" ).groups() == ("abc", "def", "xyz")
-    assert matchaddr( "abc+def@xyz", mailbox="Abc"               ).groups() == ("abc", "def", "xyz")
-    assert matchaddr( "abc+def@xyz",                             ).groups() == ("abc", "def", "xyz")
-    assert matchaddr( "abc+def@xyz",                             ).group( 3 ) == "xyz"
-    assert matchaddr( "abc+def@xyz", mailbox="xxx"               ) is None
-
-
-def test_email_autoresponder( monkeypatch ):
-    """The Postfix-compatible autoresponder takes an email from stdin, and auto-forwards it (via a
+def test_communications_autoresponder( monkeypatch ):
+    """The Postfix-compatible auto-responder takes an email from stdin, and auto-forwards it (via a
     relay; normally the same Postfix installation that it is running within).
 
-    Let's shuttle a simple message through the autoresponder, and fire up an SMTP daemon to receive
+    Let's shuttle a simple message through the AutoResponder, and fire up an SMTP daemon to receive
     the auto-forwarded message(s).
 
     """
@@ -87,8 +92,8 @@ def test_email_autoresponder( monkeypatch ):
         dkim_selector	= dkim_selector,
         headers		= ['From', 'To'],
     )
-
     envelopes		= []
+
     class PrintingHandler:
         async def handle_RCPT(self, server, session, envelope, address, rcpt_options):
             if matchaddr( address ).group( 3 ) not in ('dominionrnd.com', 'kundert.ca'):
@@ -136,15 +141,47 @@ async def handle_DATA(self, server, session, envelope):
             to_addrs	       += map( str.strip, msg[cc].split( ',' ) )
 
     monkeypatch.setattr( 'sys.stdin', StringIO( msg.as_string() ))
-    ar				= autoresponder(
+    ar				= AutoResponder(
         address		= SMTP_TO,
         server		= controller.hostname,
         port		= controller.port,
-        reinject	= lambda *args, **kwds: None
+        reinject	= False,
     )
     ar.respond(
         from_addr, *to_addrs
     )
-        
+
     assert len( envelopes ) == 2
     assert envelopes[-1].rcpt_tos == [ '[email protected]' ]
+
+    # Now, try the CLI version.
+    here			= Path( __file__ ).resolve().parent
+    for execute in [
+        [
+            "python3", "-m", "slip39.invoice.communications",
+        ]
+
+    ]:
+        command			= list( map( str, execute + [
+            '-v',
+            'autoresponder',
+            '--server',		controller.hostname,
+            '--port',		controller.port,
+            #'--no-reinject',
+            '--reinject',	"echo",
+            '[email protected]',
+            from_addr,
+            *to_addrs
+        ] ))
+        log.info( f"Running filter: {' . '.join( command )}" )
+        with Popen(
+                command,
+                stdin	= PIPE,
+                env	= dict(
+                    os.environ,
+                    PYTHONPATH	= f"{here.parent.parent}"
+                )) as process:
+            process.communicate( msg.as_bytes() )
+
+    assert len( envelopes ) == 3
+    assert envelopes[-1].rcpt_tos == [ '[email protected]' ]