email_address 0.1.2 → 0.2.0

data/lib/email_address/local.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module EmailAddress
   ##############################################################################
   # EmailAddress Local part consists of
@@ -65,42 +67,51 @@ module EmailAddress
   #                        [CFWS]
   ############################################################################
   class Local
-    attr_reader   :local
+    attr_reader :local
     attr_accessor :mailbox, :comment, :tag, :config, :original
-    attr_accessor :syntax
+    attr_accessor :syntax, :locale
 
     # RFC-2142: MAILBOX NAMES FOR COMMON SERVICES, ROLES AND FUNCTIONS
-    BUSINESS_MAILBOXES = %w(info marketing sales support)
-    NETWORK_MAILBOXES  = %w(abuse noc security)
-    SERVICE_MAILBOXES  = %w(postmaster hostmaster usenet news webmaster www uucp ftp)
-    SYSTEM_MAILBOXES   = %w(help mailer-daemon root) # Not from RFC-2142
-    ROLE_MAILBOXES     = %w(staff office orders billing careers jobs) # Not from RFC-2142
-    SPECIAL_MAILBOXES  = BUSINESS_MAILBOXES + NETWORK_MAILBOXES + SERVICE_MAILBOXES +
-                         SYSTEM_MAILBOXES + ROLE_MAILBOXES
-    STANDARD_MAX_SIZE  = 64
+    BUSINESS_MAILBOXES = %w[info marketing sales support]
+    NETWORK_MAILBOXES = %w[abuse noc security]
+    SERVICE_MAILBOXES = %w[postmaster hostmaster usenet news webmaster www uucp ftp]
+    SYSTEM_MAILBOXES = %w[help mailer-daemon root] # Not from RFC-2142
+    ROLE_MAILBOXES = %w[staff office orders billing careers jobs] # Not from RFC-2142
+    SPECIAL_MAILBOXES = BUSINESS_MAILBOXES + NETWORK_MAILBOXES + SERVICE_MAILBOXES +
+      SYSTEM_MAILBOXES + ROLE_MAILBOXES
+    STANDARD_MAX_SIZE = 64
 
     # Conventional : word([.-+'_]word)*
-    CONVENTIONAL_MAILBOX_REGEX  = /\A [\p{L}\p{N}]+ (?: [\.\-\+\'_] [\p{L}\p{N}]+ )* \z/x
-    CONVENTIONAL_MAILBOX_WITHIN = /[\p{L}\p{N}]+ (?: [\.\-\+\'_] [\p{L}\p{N}]+ )*/x
+    CONVENTIONAL_MAILBOX_REGEX = /\A [\p{L}\p{N}_]+ (?: [.\-+'_] [\p{L}\p{N}_]+ )* \z/x
+    CONVENTIONAL_MAILBOX_WITHIN = /[\p{L}\p{N}_]+ (?: [.\-+'_] [\p{L}\p{N}_]+ )*/x
 
     # Relaxed: same characters, relaxed order
-    RELAXED_MAILBOX_WITHIN = /[\p{L}\p{N}]+ (?: [\.\-\+\'_]+ [\p{L}\p{N}]+ )*/x
-    RELAXED_MAILBOX_REGEX = /\A [\p{L}\p{N}]+ (?: [\.\-\+\'_]+ [\p{L}\p{N}]+ )* \z/x
+    RELAXED_MAILBOX_WITHIN = /[\p{L}\p{N}_]+ (?: [.\-+'_]+ [\p{L}\p{N}_]+ )*/x
+    RELAXED_MAILBOX_REGEX = /\A [\p{L}\p{N}_]+ (?: [.\-+'_]+ [\p{L}\p{N}_]+ )* \z/x
 
     # RFC5322 Token: token."token".token (dot-separated tokens)
     #   Quoted Token can also have: SPACE \" \\ ( ) , : ; < > @ [ \ ] .
     STANDARD_LOCAL_WITHIN = /
-      (?: [\p{L}\p{N}\!\#\$\%\&\'\*\+\-\/\=\?\^\_\`\{\|\}\~\(\)]+
-        | \" (?: \\[\" \\] | [\x20 \! \x23-\x5B \x5D-\x7E \p{L} \p{N}] )+ \" )
-      (?: \.  (?: [\p{L}\p{N}\!\#\$\%\&\'\*\+\-\/\=\?\^\_\`\{\|\}\~\(\)]+
-              | \" (?: \\[\" \\] | [\x20 \! \x23-\x5B \x5D-\x7E \p{L} \p{N}] )+ \" ) )* /x
+      (?: [\p{L}\p{N}!\#$%&'*+\-\/=?\^_`{|}~()]+
+        | " (?: \\[" \\] | [\x20-\x21\x23-\x2F\x3A-\x40\x5B\x5D-\x60\x7B-\x7E\p{L}\p{N}] )+ " )
+      (?: \.  (?: [\p{L}\p{N}!\#$%&'*+\-\/=?\^_`{|}~()]+
+              | " (?: \\[" \\] | [\x20-\x21\x23-\x2F\x3A-\x40\x5B\x5D-\x60\x7B-\x7E\p{L}\p{N}] )+ " ) )* /x
+
     STANDARD_LOCAL_REGEX = /\A #{STANDARD_LOCAL_WITHIN} \z/x
 
     REDACTED_REGEX = /\A \{ [0-9a-f]{40} \} \z/x # {sha1}
 
-    def initialize(local, config={})
-      self.config   = config.empty? ? EmailAddress::Config.all_settings : config
-      self.local    = local
+    CONVENTIONAL_TAG_REGEX = #  AZaz09_!'+-/=
+      %r{^([\w!'+\-/=.]+)$}i
+    RELAXED_TAG_REGEX = #  AZaz09_!#$%&'*+-/=?^`{|}~
+      %r/^([\w.!\#$%&'*+\-\/=?\^`{|}~]+)$/i
+
+    def initialize(local, config = {}, host = nil, locale = "en")
+      @config = config.is_a?(Hash) ? Config.new(config) : config
+      self.local = local
+      @host = host
+      @locale = locale
+      @error = @error_message = nil
     end
 
     def local=(raw)
@@ -111,23 +122,23 @@ module EmailAddress
       if @config[:local_parse].is_a?(Proc)
         self.mailbox, self.tag, self.comment = @config[:local_parse].call(raw)
       else
-        self.mailbox, self.tag, self.comment = self.parse(raw)
+        self.mailbox, self.tag, self.comment = parse(raw)
       end
 
       self.format
     end
 
     def parse(raw)
-      if raw =~ /\A\"(.*)\"\z/ # Quoted
+      if raw =~ /\A"(.*)"\z/ # Quoted
         raw = $1
-        raw.gsub!(/\\(.)/, '\1') # Unescape
-      elsif @config[:local_fix]
-        raw.gsub!(' ','')
-        raw.gsub!(',','.')
-        raw.gsub!(/([^\p{L}\p{N}]{2,10})/) {|s| s[0] } # Stutter punctuation typo
+        raw = raw.gsub(/\\(.)/, '\1') # Unescape
+      elsif @config[:local_fix] && @config[:local_format] != :standard
+        raw = raw.delete(" ")
+        raw = raw.tr(",", ".")
+        # raw.gsub!(/([^\p{L}\p{N}]{2,10})/) {|s| s[0] } # Stutter punctuation typo
       end
-      raw, comment = self.parse_comment(raw)
-      mailbox, tag = self.parse_tag(raw)
+      raw, comment = parse_comment(raw)
+      mailbox, tag = parse_tag(raw)
       mailbox ||= ""
       [mailbox, tag, comment]
     end
@@ -146,28 +157,28 @@ module EmailAddress
     end
 
     def parse_tag(raw)
-      separator = @config[:tag_separator] ||= '+'
+      separator = @config[:tag_separator] ||= "+"
       raw.split(separator, 2)
     end
 
     # True if the the value contains only Latin characters (7-bit ASCII)
     def ascii?
-      ! self.unicode?
+      !unicode?
     end
 
     # True if the the value contains non-Latin Unicde characters
     def unicode?
-      self.local =~ /[^\p{InBasicLatin}]/ ? true : false
+      /[^\p{InBasicLatin}]/.match?(local)
     end
 
     # Returns true if the value matches the Redacted format
     def redacted?
-      self.local =~ REDACTED_REGEX ? true : false
+      REDACTED_REGEX.match?(local)
     end
 
     # Returns true if the value matches the Redacted format
     def self.redacted?(local)
-      local =~ REDACTED_REGEX ? true : false
+      REDACTED_REGEX.match?(local)
     end
 
     # Is the address for a common system or business role account?
@@ -180,81 +191,80 @@ module EmailAddress
     end
 
     # Builds the local string according to configurations
-    def format(form=@config[:local_format]||:conventional)
+    def format(form = @config[:local_format] || :conventional)
       if @config[:local_format].is_a?(Proc)
         @config[:local_format].call(self)
       elsif form == :conventional
-        self.conventional
+        conventional
       elsif form == :canonical
-        self.canonical
-      elsif form == :relax
-        self.relax
+        canonical
+      elsif form == :relaxed
+        relax
       elsif form == :standard
-        self.standard
+        standard
       end
     end
 
     # Returns a conventional form of the address
     def conventional
-      if self.tag
-        [self.mailbox, self.tag].join(@config[:tag_separator])
+      if tag
+        [mailbox, tag].join(@config[:tag_separator])
       else
-        self.mailbox
+        mailbox
       end
     end
 
     # Returns a canonical form of the address
     def canonical
       if @config[:mailbox_canonical]
-        @config[:mailbox_canonical].call(self.mailbox)
+        @config[:mailbox_canonical].call(mailbox)
       else
-        self.mailbox.downcase
+        mailbox.downcase
       end
     end
 
     # Relaxed format: mailbox and tag, no comment, no extended character set
     def relax
-      form = self.mailbox
-      form += @config[:tag_separator] + self.tag if self.tag
-      form.gsub!(/[ \"\(\),:<>@\[\]\\]/,'')
-      form
+      form = mailbox
+      form += @config[:tag_separator] + tag if tag
+      form.gsub(/[ "(),:<>@\[\]\\]/, "")
     end
 
     # Returns a normalized version of the standard address parts.
     def standard
-      form = self.mailbox
-      form += @config[:tag_separator] + self.tag if self.tag
-      form += "(" + self.comment + ")" if self.comment
-      form.gsub!(/([\\\"])/, '\\\1') # Escape \ and "
-      if form =~ /[ \"\(\),:<>@\[\\\]]/ # Space and "(),:;<>@[\]
-        form = %Q("#{form}")
+      form = mailbox
+      form += @config[:tag_separator] + tag if tag
+      form += "(" + comment + ")" if comment
+      form = form.gsub(/([\\"])/, '\\\1') # Escape \ and "
+      if /[ "(),:<>@\[\\\]]/.match?(form) # Space and "(),:;<>@[\]
+        form = %("#{form}")
       end
       form
     end
 
     # Sets the part to be the conventional form
     def conventional!
-      self.local = self.conventional
+      self.local = conventional
     end
 
     # Sets the part to be the canonical form
     def canonical!
-      self.local = self.canonical
+      self.local = canonical
     end
 
     # Dropps unusual  parts of Standard form to form a relaxed version.
     def relax!
-      self.local = self.relax
+      self.local = relax
     end
 
     # Returns the munged form of the address, like "ma*****"
     def munge
-      self.to_s.sub(/\A(.{1,2}).*/) { |m| $1 + @config[:munge_string] }
+      to_s.sub(/\A(.{1,2}).*/) { |m| $1 + @config[:munge_string] }
     end
 
     # Mailbox with trailing numbers removed
     def root_name
-      self.mailbox =~ /\A(.+?)\d+\z/ ? $1 : self.mailbox
+      mailbox =~ /\A(.+?)\d+\z/ ? $1 : mailbox
     end
 
     ############################################################################
@@ -262,19 +272,19 @@ module EmailAddress
     ############################################################################
 
     # True if the part is valid according to the configurations
-    def valid?(format=@config[:local_format]||:conventional)
+    def valid?(format = @config[:local_format] || :conventional)
       if @config[:mailbox_validator].is_a?(Proc)
-        @config[:mailbox_validator].call(self.mailbox, self.tag)
+        @config[:mailbox_validator].call(mailbox, tag)
       elsif format.is_a?(Proc)
         format.call(self)
       elsif format == :conventional
-        self.conventional?
+        conventional?
       elsif format == :relaxed
-        self.relaxed?
+        relaxed?
       elsif format == :redacted
-        self.redacted?
+        redacted?
       elsif format == :standard
-        self.standard?
+        standard?
       elsif format == :none
         true
       else
@@ -285,13 +295,13 @@ module EmailAddress
     # Returns the format of the address
     def format?
       # if :custom
-      if self.conventional?
+      if conventional?
         :conventional
-      elsif self.relaxed?
+      elsif relaxed?
         :relax
-      elsif self.redacted?
+      elsif redacted?
         :redacted
-      elsif self.standard?
+      elsif standard?
         :standard
       else
         :invalid
@@ -299,24 +309,38 @@ module EmailAddress
     end
 
     def valid_size?
-      return false if @config[:local_size] && !@config[:local_size].include?(self.local.size)
-      return false if @config[:mailbox_size] && !@config[:mailbox_size].include?(self.mailbox.size)
-      return false if self.local.size > STANDARD_MAX_SIZE
+      return set_error(:local_size_long) if local.size > STANDARD_MAX_SIZE
+      if @host&.hosted_service?
+        return false if @config[:local_private_size] && !valid_size_checks(@config[:local_private_size])
+      elsif @config[:local_size] && !valid_size_checks(@config[:local_size])
+        return false
+      end
+      return false if @config[:mailbox_size] && !valid_size_checks(@config[:mailbox_size])
       true
     end
 
-    def valid_encoding?(enc=@config[:local_encoding]||:ascii)
-      return false if enc == :ascii && self.unicode?
-      return false if enc == :unicode && self.ascii?
+    def valid_size_checks(range)
+      return set_error(:local_size_short) if mailbox.size < range.first
+      return set_error(:local_size_long) if mailbox.size > range.last
+      true
+    end
+
+    def valid_encoding?(enc = @config[:local_encoding] || :ascii)
+      return false if enc == :ascii && unicode?
       true
     end
 
     # True if the part matches the conventional format
     def conventional?
       self.syntax = :invalid
-      self.local =~ CONVENTIONAL_MAILBOX_REGEX or return false
-      self.valid_size? or return false
-      self.valid_encoding? or return false
+      if tag
+        return false unless mailbox =~ CONVENTIONAL_MAILBOX_REGEX &&
+          tag =~ CONVENTIONAL_TAG_REGEX
+      else
+        return false unless CONVENTIONAL_MAILBOX_REGEX.match?(local)
+      end
+      valid_size? or return false
+      valid_encoding? or return false
       self.syntax = :conventional
       true
     end
@@ -324,9 +348,12 @@ module EmailAddress
     # Relaxed conventional is not so strict about character order.
     def relaxed?
       self.syntax = :invalid
-      self.valid_size? or return false
-      self.valid_encoding? or return false
-      if self.local =~ RELAXED_MAILBOX_REGEX
+      valid_size? or return false
+      valid_encoding? or return false
+      if tag
+        return false unless mailbox =~ RELAXED_MAILBOX_REGEX &&
+          tag =~ RELAXED_TAG_REGEX
+      elsif RELAXED_MAILBOX_REGEX.match?(local)
         self.syntax = :relaxed
         true
       else
@@ -337,9 +364,9 @@ module EmailAddress
     # True if the part matches the RFC standard format
     def standard?
       self.syntax = :invalid
-      self.valid_size? or return false
-      self.valid_encoding? or return false
-      if self.local =~ STANDARD_LOCAL_REGEX
+      valid_size? or return false
+      valid_encoding? or return false
+      if STANDARD_LOCAL_REGEX.match?(local)
         self.syntax = :standard
         true
       else
@@ -352,10 +379,23 @@ module EmailAddress
     def matches?(*rules)
       rules.flatten.each do |r|
         if r =~ /(.+)@\z/
-          return r if File.fnmatch?($1, self.local)
+          return r if File.fnmatch?($1, local)
         end
       end
       false
     end
+
+    def set_error(err, reason = nil)
+      @error = err
+      @reason = reason
+      @error_message = Config.error_message(err, locale)
+      false
+    end
+
+    attr_reader :error_message
+
+    def error
+      valid? ? nil : (@error || :local_invalid)
+    end
   end
 end

data/lib/email_address/messages.yaml

@@ -0,0 +1,21 @@
+en:
+  email_address:
+    address_unknown: "Unknown Email Address"
+    domain_does_not_accept_email: "This domain is not configured to accept email"
+    domain_invalid: "Invalid Domain Name"
+    domain_no_localhost: "localhost is not allowed for your domain name"
+    domain_unknown: "Domain name not registered"
+    exceeds_size: "Address too long"
+    incomplete_domain: "Domain name is incomplete"
+    invalid_address: "Invalid Email Address"
+    invalid_host: "Invalid Host/Domain Name"
+    invalid_mailbox: "Invalid Mailbox"
+    ip_address_forbidden: "IP Addresses are not allowed"
+    ip_address_no_localhost: "Localhost IP addresses are not allowed"
+    ipv4_address_invalid: "This is not a valid IPv4 address"
+    ipv6_address_invalid: "This is not a valid IPv6 address"
+    local_size_long: "Mailbox name too long"
+    local_size_short: "Mailbox name too short"
+    local_invalid: "Recipient is not valid"
+    not_allowed: "Address is not allowed"
+    server_not_available: "The remote email server is not available"

data/lib/email_address/rewriter.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "base64"
+
+module EmailAddress::Rewriter
+  SRS_FORMAT_REGEX = /\ASRS0=(....)=(\w\w)=(.+?)=(.+?)@(.+)\z/
+
+  def parse_rewritten(e)
+    @rewrite_scheme = nil
+    @rewrite_error = nil
+    parse_srs(e)
+    # e = parse_batv(e)
+  end
+
+  #---------------------------------------------------------------------------
+  # SRS (Sender Rewriting Scheme) allows an address to be forwarded from the
+  # original owner and encoded to be used with the domain name of the MTA (Mail
+  # Transport Agent). It encodes the original address within the local part of the
+  # sending email address and respects VERP. If example.com needs to forward a
+  # message from "sender@gmail.com", the SMTP envelope sender is used at this
+  # address. These methods respect DMARC and prevent spoofing email send using
+  # a different domain.
+  # Format: SRS0=HHH=TT=domain=local@sending-domain.com
+  #---------------------------------------------------------------------------
+  def srs(sending_domain, options = {}, &block)
+    tt = srs_tt
+    a = [tt, hostname, local.to_s].join("=") + "@" + sending_domain
+    hhh = srs_hash(a, options, &block)
+
+    ["SRS0", hhh, a].join("=")
+  end
+
+  def srs?(email)
+    email.match(SRS_FORMAT_REGEX) ? true : false
+  end
+
+  def parse_srs(email, options = {}, &block)
+    if email&.match(SRS_FORMAT_REGEX)
+      @rewrite_scheme = :srs
+      hhh, tt, domain, local, sending_domain = [$1, $2, $3, $4, $5]
+      # hhh = tt = sending_domain if false && hhh # Hide warnings for now :-)
+      a = [tt, domain, local].join("=") + "@" + sending_domain
+      unless srs_hash(a, options, &block) === hhh
+        @rewrite_error = "Invalid SRS Email Address: Possibly altered"
+      end
+      unless tt == srs_tt
+        @rewrite_error = "Invalid SRS Email Address: Too old"
+      end
+      [local, domain].join("@")
+    else
+      email
+    end
+  end
+
+  # SRS Timeout Token
+  # Returns a 2-character code for the day. After a few days the code will roll.
+  # TT has a one-day resolution in order to make the address invalid after a few days.
+  # The cycle period is 3.5 years. Used to control late bounces and harvesting.
+  def srs_tt(t = Time.now.utc)
+    Base64.encode64((t.to_i / (60 * 60 * 24) % 210).to_s)[0, 2]
+  end
+
+  def srs_hash(email, options = {}, &block)
+    key = options[:key] || @config[:key] || email.reverse
+    if block
+      block.call(email)[0, 4]
+    else
+      Base64.encode64(Digest::SHA1.digest(email + key))[0, 4]
+    end
+  end
+
+  #---------------------------------------------------------------------------
+  # Returns a BATV form email address with "Private Signature" (prvs).
+  # Options: key: 0-9 key digit to use
+  #          key_0..key_9: secret key used to sign/verify
+  #          prvs_days: number of days before address "expires"
+  #
+  # BATV - Bounce Address Tag Validation
+  # PRVS - Simple Private Signature
+  # Ex:    prvs=KDDDSSSS=user@example.com
+  #        * K: Digit for Key rotation
+  #        * DDD: Expiry date, since 1970, low 3 digits
+  #        * SSSSSS: sha1( KDDD + orig-mailfrom + key)[0,6]
+  # See:   https://tools.ietf.org/html/draft-levine-smtp-batv-01
+  #---------------------------------------------------------------------------
+  def batv_prvs(options = {})
+    k = options[:prvs_key_id] || "0"
+    prvs_days = options[:prvs_days] || @config[:prvs_days] || 30
+    ddd = prvs_day(prvs_days)
+    ssssss = prvs_sign(k, ddd, to_s, options)
+    ["prvs=", k, ddd, ssssss, "=", to_s].join("")
+  end
+
+  PRVS_REGEX = /\Aprvs=(\d)(\d{3})(\w{6})=(.+)\z/
+
+  def parse_prvs(email, options = {})
+    if email.match(PRVS_REGEX)
+      @rewrite_scheme = :prvs
+      k, ddd, ssssss, email = [$1, $2, $3, $4]
+
+      unless ssssss == prvs_sign(k, ddd, email, options)
+        @rewrite_error = "Invalid BATV Address: Signature unverified"
+      end
+      exp = ddd.to_i
+      roll = 1000 - exp # rolling 1000 day window
+      today = prvs_day(0)
+      # I'm sure this is wrong
+      if exp > today && exp < roll
+        @rewrite_error = "Invalid SRS Email Address: Address expired"
+      elsif exp < today && (today - exp) > 0
+        @rewrite_error = "Invalid SRS Email Address: Address expired"
+      end
+      [local, domain].join("@")
+    else
+      email
+    end
+  end
+
+  def prvs_day(days)
+    ((Time.now.to_i + (days * 24 * 60 * 60)) / (24 * 60 * 60)).to_s[-3, 3]
+  end
+
+  def prvs_sign(k, ddd, email, options = {})
+    str = [ddd, ssssss, "=", to_s].join("")
+    key = options["key_#{k}".to_i] || @config["key_#{k}".to_i] || str.reverse
+    Digest::SHA1.hexdigest([k, ddd, email, key].join(""))[0, 6]
+  end
+
+  #---------------------------------------------------------------------------
+  # VERP Embeds a recipient email address into the bounce address
+  #   Bounce Address:  message-id@example.net
+  #   Recipient Email: recipient@example.org
+  #   VERP :           message-id+recipient=example.org@example.net
+  # To handle incoming verp, the "tag" is the recipient email address,
+  # remember to convert the last '=' into a '@' to reconstruct it.
+  #---------------------------------------------------------------------------
+  def verp(recipient, split_char = "+")
+    local.to_s +
+      split_char + recipient.tr("@", "=") +
+      "@" + hostname
+  end
+
+  # NEXT: DMARC, SPF Validation
+end

data/lib/email_address/version.rb

@@ -1,3 +1,3 @@
 module EmailAddress
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end