def exists(self, user, memo=None): """ Check whether a user exists in this domain or an alias of it. @type user: L{User} @param user: A user. @type memo: L{NoneType <types.NoneType>} or L{dict} of L{AliasBase} @param memo: A record of the addresses already considered while resolving aliases. The default value should be used by all external code. @rtype: no-argument callable which returns L{IMessage <smtp.IMessage>} provider. @return: A function which takes no arguments and returns a message receiver for the user. @raises SMTPBadRcpt: When the given user does not exist in this domain or an alias of it. """ if self.userDirectory(user.dest.local) is not None: return lambda: self.startMessage(user) try: a = self.alias[user.dest.local] except: raise smtp.SMTPBadRcpt(user) else: aliases = a.resolve(self.alias, memo) if aliases: return lambda: aliases log.err("Bad alias configuration: " + str(user)) raise smtp.SMTPBadRcpt(user)
def validateTo(self, user): print "validateTo:", user if str(user) in ['*****@*****.**', '*****@*****.**']: raise smtp.SMTPBadRcpt(user) if user.dest.domain in self.postman.valid_domains: def emailcallback(incoming): return self.postman.new_email(incoming, self.email_element, user.dest.domain) return lambda: ScewptMessage(emailcallback) elif user.dest.domain in self.postman.invalid_domains: raise smtp.SMTPBadRcpt(user) else: def handleCheckDomain(isvalid): print 'isvalid:', isvalid, user.dest.domain if isvalid or user.dest.domain == 'localhost': self.postman.valid_domains.append(user.dest.domain) else: self.postman.invalid_domains.append(user.dest.domain) d = self.postman.check_domain(user.dest.domain) d.addBoth(handleCheckDomain) d.addBoth(lambda ign: self.validateTo(user)) return d
def exists(self, user, memo=None): """Check for existence of user in the domain """ if self.userDirectory(user.dest.local) is not None: return lambda: self.startMessage(user) try: a = self.alias[user.dest.local] except: raise smtp.SMTPBadRcpt(user) else: aliases = a.resolve(self.alias, memo) if aliases: return lambda: aliases log.err("Bad alias configuration: " + str(user)) raise smtp.SMTPBadRcpt(user)
def validateTo(self, user): # Accept recipients @localhost. if user.dest.domain == "localhost": return lambda: MaildirMessage(self._getAddressDir(str(user.dest))) else: log.msg("Received email for invalid recipient %s" % user) raise smtp.SMTPBadRcpt(user)
def validateTo(self, user): # Accept recipients @localhost. if user.dest.domain == "localhost": return StdoutMessage else: log.msg("Received email for invalid recipient %s" % (user), ) raise smtp.SMTPBadRcpt(user)
def validateFrom(self, helo, origin): #valida que el dominio solo sea el del server de quien envia el mensaje if origin.domain in domain_aux: return origin else: log.msg("Invalid domain %s" % origin.domain) raise smtp.SMTPBadRcpt(origin.domain)
def validateTo(self, user): # Only messages directed to configured users are accepted logging.info("validating to %s", user) if self.db.validUser(user.dest): logging.info("ok") return lambda: ImmudbMessage(self.db, user.dest) raise smtp.SMTPBadRcpt(user)
def validateTo(self, user): if '-' in user.dest.local: ml_id, recipient_id = user.dest.local.split('-', 1) return lambda: ReturnPathMessage(ml_id, recipient_id) logging.getLogger('smtpd').warn( "Recipient '%s' refused: badly formated.", user) raise smtp.SMTPBadRcpt(user)
def validateTo(self, user): # Only messages directed to mailhooks.com are accepted. callbacks = self.factory.callbacks if user.dest.domain in callbacks.keys(): return lambda: Message(callbacks[user.dest.domain]) elif '*' in callbacks.keys(): return lambda: Message(callbacks['*']) raise smtp.SMTPBadRcpt(user)
def not_found(failure): failure.trap(KeyNotFound) # if key was not found, check config to see if will send anyway if self._encrypted_only: emit(catalog.SMTP_RECIPIENT_REJECTED, user.dest.addrstr) raise smtp.SMTPBadRcpt(user.dest.addrstr) log.msg("Warning: will send an unencrypted message (because " "encrypted_only' is set to False).") emit(catalog.SMTP_RECIPIENT_ACCEPTED_UNENCRYPTED, user.dest.addrstr)
def exists(self, user): """ Raise an exception to indicate that the user does not exist in this domain. @type user: L{User} @param user: A user. @raise SMTPBadRcpt: When the given user does not exist in this domain. """ raise smtp.SMTPBadRcpt(user)
def exists(self, user): """Check whether we will relay Call overridable willRelay method """ if self.willRelay(user.dest, user.protocol): # The most cursor form of verification of the addresses orig = filter(None, str(user.orig).split('@', 1)) dest = filter(None, str(user.dest).split('@', 1)) if len(orig) == 2 and len(dest) == 2: return lambda: self.startMessage(user) raise smtp.SMTPBadRcpt(user)
def validateTo(self, user): """Validate the SMTP ``RCPT TO:`` address for the incoming connection. The local username and domain name to which this SMTP message is addressed, after being stripped of any ``'+'`` aliases, **must** be identical to those in the email address set our ``EMAIL_SMTP_FROM_ADDR`` configuration file option. :type user: :api:`twisted.mail.smtp.User` :param user: Information about the user this SMTP message was addressed to. :raises: A :api:`twisted.mail.smtp.SMTPBadRcpt` if any of the above conditions weren't met. :rtype: callable :returns: A parameterless function which returns an instance of :class:`SMTPMessage`. """ logging.debug("Validating SMTP 'RCPT TO:' email address...") recipient = user.dest ourAddress = smtp.Address(self.context.smtpFromAddr) if not ((ourAddress.domain in recipient.domain) or (recipient.domain == b"bridgedb")): logging.debug(("Not our domain (%s) or subdomain, skipping" " SMTP 'RCPT TO' address: %s") % (ourAddress.domain.decode('utf-8'), str(recipient))) raise smtp.SMTPBadRcpt(str(recipient)) # The recipient's username should at least start with ours, # but it still might be a '+' address. if not recipient.local.startswith(ourAddress.local): logging.debug(("Username doesn't begin with ours, skipping" " SMTP 'RCPT TO' address: %s") % str(recipient)) raise smtp.SMTPBadRcpt(str(recipient)) # Ignore everything after the first '+', if there is one. beforePlus = recipient.local.split(b'+', 1)[0] if beforePlus != ourAddress.local: raise smtp.SMTPBadRcpt(str(recipient)) return lambda: SMTPMessage(self.context, self.fromCanonicalSMTP)
def validateTo(self, user): # Only messages directed to the "console" user are accepted. try: token = Canarytoken(value=user.dest.local) self.canarydrop = Canarydrop(**get_canarydrop( canarytoken=token.value())) return lambda: CanaryMessage(esmtp=self) except (NoCanarytokenPresent, NoCanarytokenFound): log.warn('No token in recipient address: {address}'\ .format(address=user.dest.local)) except Exception as e: log.error(e) raise smtp.SMTPBadRcpt(user)
def verify_if_can_encrypt_for_recipient(can_encrypt): if can_encrypt: self.log.debug('Accepting mail for %s...' % user.dest.addrstr) emit_async(catalog.SMTP_RECIPIENT_ACCEPTED_ENCRYPTED, self._userid, user.dest.addrstr) elif self._encrypted_only: emit_async(catalog.SMTP_RECIPIENT_REJECTED, self._userid, user.dest.addrstr) raise smtp.SMTPBadRcpt(user.dest.addrstr) else: self.log.warn( 'Warning: will send an unencrypted message (because ' '"encrypted_only" is set to False).') emit_async(catalog.SMTP_RECIPIENT_ACCEPTED_UNENCRYPTED, self._userid, user.dest.addrstr)
def localValidateTo(self, user): """ Determine whether the given user exists locally. If they do not, reject the address as invalid. If they do, return a delivery object appropriate for that user. Currently this delivery object is the same as the remote delivery object, but at some point it may make sense to optimize this codepath and skip the network for local<->local delivery. """ siteStore = self.avatar.store.parent loginSystem = siteStore.findUnique(userbase.LoginSystem) account = loginSystem.accountByAddress( user.dest.local.decode('ascii'), user.dest.domain.decode('ascii')) if account is None: return defer.fail(smtp.SMTPBadRcpt(user)) else: # XXX TODO - We could skip the network here. return self.remoteValidateTo(user)
def validateTo(self, user): """ Validate the address of C{user}, a recipient of the message. This method is called once for each recipient and validates the C{user}'s address against the RFC 2822 definition. If the configuration option ENCRYPTED_ONLY_KEY is True, it also asserts the existence of the user's key. In the end, it returns an encrypted message object that is able to send itself to the C{user}'s address. :param user: The user whose address we wish to validate. :type: twisted.mail.smtp.User @return: A Deferred which becomes, or a callable which takes no arguments and returns an object implementing IMessage. This will be called and the returned object used to deliver the message when it arrives. @rtype: no-argument callable @raise SMTPBadRcpt: Raised if messages to the address are not to be accepted. """ # try to find recipient's public key try: address = validate_address(user.dest.addrstr) # verify if recipient key is available in keyring self._km.get_key(address, OpenPGPKey) # might raise KeyNotFound log.msg("Accepting mail for %s..." % user.dest.addrstr) signal(proto.SMTP_RECIPIENT_ACCEPTED_ENCRYPTED, user.dest.addrstr) except KeyNotFound: # if key was not found, check config to see if will send anyway. if self._encrypted_only: signal(proto.SMTP_RECIPIENT_REJECTED, user.dest.addrstr) raise smtp.SMTPBadRcpt(user.dest.addrstr) log.msg("Warning: will send an unencrypted message (because " "encrypted_only' is set to False).") signal(proto.SMTP_RECIPIENT_ACCEPTED_UNENCRYPTED, user.dest.addrstr) return lambda: EncryptedMessage(self._origin, user, self._km, self. _host, self._port, self._cert, self. _key)
def validate_address(address): """ Validate C{address} as defined in RFC 2822. :param address: The address to be validated. :type address: str @return: A valid address. @rtype: str @raise smtp.SMTPBadRcpt: Raised if C{address} is invalid. """ leap_assert_type(address, str) # in the following, the address is parsed as described in RFC 2822 and # ('', '') is returned if the parse fails. _, address = parseaddr(address) if address == '': raise smtp.SMTPBadRcpt(address) return address
def exists(self, user): """ Check whether mail can be relayed to a user. @type user: L{User} @param user: A user. @rtype: no-argument callable which returns L{IMessage <smtp.IMessage>} provider @return: A function which takes no arguments and returns a message receiver for the user. @raise SMTPBadRcpt: When mail cannot be relayed to the user. """ if self.willRelay(user.dest, user.protocol): # The most cursor form of verification of the addresses orig = filter(None, str(user.orig).split('@', 1)) dest = filter(None, str(user.dest).split('@', 1)) if len(orig) == 2 and len(dest) == 2: return lambda: self.startMessage(user) raise smtp.SMTPBadRcpt(user)
def validateTo(self, user): # Only messages directed to either a valid forward or a mailinglist are # accepted ip = user.protocol.transport.getPeer()[1] addr = None try: addr = MailingList.objects.get(listaddress__iexact='%s' % user.dest) print >>sys.stderr, 'list addr: %s' % (addr) return lambda: ListMessage(user, addr) except MailingList.DoesNotExist: pass try: addr = Forward.objects.get(forward__iexact='%s' % user.dest ) print >>sys.stderr, 'forward addr: %s' % (addr) return lambda: ForwardMessage(user, addr) except Forward.DoesNotExist: pass if ip in self.local_ips: return lambda: LocalMessage(user) raise smtp.SMTPBadRcpt(user)
def validateTo(self, user): # Only messages directed to the "console" user are accepted. if (user.dest.local == "benb" and user.dest.domain == 'benb.org'): return lambda: ConsoleMessage() raise smtp.SMTPBadRcpt(user)
def notLoggedIn(err): err.trap(userbase.NoSuchUser) return defer.fail(smtp.SMTPBadRcpt(user))
def validateTo(self, user): # Only accept mail for our domains -- if set. Otherwise, anything goes. if not MY_DOMAINS or user.dest.domain in MY_DOMAINS: return lambda: TempMailMessage(user) raise smtp.SMTPBadRcpt(user)
def validateTo(self, user): if not str(user.dest).lower() == self.googleSearchAddress: raise smtp.SMTPBadRcpt(user.dest) else: return lambda: ReplyFromGoogle(self.googleSearchAddress, self. upstreamServer)
def validateTo(self, user): if str(user) == self.factory.address or str(user) in self.factory.accept: return lambda: Message(self.factory.name) raise smtp.SMTPBadRcpt(user)
def exists(self, user): raise smtp.SMTPBadRcpt(user)
def validateTo(self, user): if not user.dest.domain in self.validDomains: raise smtp.SMTPBadRcpt(user) print "Accepting mail for %s..." % user.dest return lambda: MaildirMessageWriter(self._getAddressDir(str(user.dest)) )
def validateTo(self, user): # Only messages directed to the "console" user are accepted. if user.dest.local == "console": return lambda: CanaryMessage() raise smtp.SMTPBadRcpt(user)
def exists(self, user): if user.dest.local in self.messages: return defer.succeed(lambda: self.startMessage(user)) return defer.fail(smtp.SMTPBadRcpt(user))
def validateTo(self, user): # Only messages directed to the "console" user are accepted. if user.dest.local == "blog": return lambda: BlogMessage(self.store) raise smtp.SMTPBadRcpt(user)