dmarcator 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f88c01ff39e839792769a66063bd78cd312f51d5fba6917acf6777d034e0269
-  data.tar.gz: 9b39f980958757f2a27718d157ad9925424a20da358a7100d3b87f9a3765af5f
+  metadata.gz: 48797112128c5187471c9c2ad1f907c73450cf8ef0f6910e2a22815d74221222
+  data.tar.gz: 89727b4555cc67beddbcb53dbbfb4845dc69e6cb8c66e37b8549fa7a4ec2ec36
 SHA512:
-  metadata.gz: 4c5aa75a034fedffc21ad9100de83b82f049dc08416f66cdcf2056ec6f76a8f28415ccfee012ea6432d4cbbbd760279c5a0dbce32d614f0932a0d8e9cd9efa3e
-  data.tar.gz: c1351578b215094ca74bb710725f2b66ad49f8e1c24ba14862ee32bc11099163f0d0e8cbb0736f5d23a614b6d1b801ea4fa9cd52e0a3f521f13ffffa21959897
+  metadata.gz: b6305c8a45f78711592f6a68b61236241d68a45410de08eaeeaa8e158b6337421e9b5d6c78b21ace4b0b38109fa74f3eec198ba4b5bbe6c2a49e5127ff2e69ff
+  data.tar.gz: 20111fdcf9bd38ff20f48a2be10ffdf4aa946850643fca2a48696fa10c041f5b3a4d49d37f6deed32f9767ed758828fce1ade967a8c12fc52cd0c1adc2ede6a2

data/ChangeLog.md

@@ -1,3 +1,18 @@
+### 1.2.0 / 2026-10-30
+
+* Plaintext lookups now use DNS over TCP (`DMARCator::Resolver::Plain`) instead of `Resolv::DNS`. `Resolv` reads UDP replies into a 512-byte buffer, so a larger answer cannot be decoded, is discarded, and the resulting timeout is swallowed. Any TXT set over 512 bytes — common for SPF and for domains with several DKIM keys — was therefore returned as an empty array, which is indistinguishable from "no records published". TCP has no such limit, and failures raise `ResolutionError`.
+* `DMARCATOR_DNS_TIMEOUT` now applies to plaintext lookups as well (default 5 seconds).
+* `DMARCator::DNS_TIMEOUTS` is no longer used and is deprecated; it will be removed in 2.0.
+* An injected `Resolv::DNS` still works, but carries the same 512-byte UDP limitation. Use `DMARCator::Resolver::Plain`, DoH, or DoT for SPF and DKIM accuracy.
+
+### 1.1.0 / 2026-10-30
+
+* Replace the Parslet grammar with a hand-written parser in `DMARCator::Internal`. Parsing behaviour is unchanged, verified differentially against the previous parser over 128 real-world and 47 edge-case records in both lenient and strict modes; record parsing is roughly 30x faster (0.84 ms to 0.03 ms per record).
+* Remove the `parslet` runtime dependency. `nokogiri` is now the only runtime dependency.
+* Messages for structurally malformed records now come from the parser itself (for example `invalid DMARC record: "..."`) and are truncated to 300 characters.
+* `DMARCator::Internal::Parser::Transform` no longer exists. It was internal, so this is not covered by the compatibility promise.
+* Reject records whose string encoding is invalid or not ASCII-compatible with `InvalidRecord`. Previously `Record.parse` could raise `ArgumentError` (invalid UTF-8) or `Encoding::CompatibilityError` (for example UTF-16), which escaped `rescue DMARCator::Error`. Binary strings from a DNS resolver, and other ASCII-compatible encodings such as ISO-8859-1, are unaffected.
+
 ### 1.0.0 / 2026-10-30
 
 The public API is now frozen.

data/README.md

@@ -12,7 +12,7 @@ DMARCator is a Ruby library for parsing and querying [DMARC] records.
 
 [DMARC] policies are published as DNS TXT records at `_dmarc.<domain>`. This
 library parses those records into a structured `DMARCator::Record`, queries them
-directly through Ruby's `Resolv` DNS client, and parses the XML aggregate
+over DNS, and parses the XML aggregate
 reports those policies generate.
 
 ## Installation
@@ -173,9 +173,9 @@ end
 ```
 
 Notes for large scans: `Record.lookup` adds a parse per domain (~0.4 ms, far
-more than the lookup on a fast resolver); `Resolv::DNS` does not lock per query,
-so use one resolver per thread when parallelising; and DoT/DoH open a new TLS
-connection per lookup, so plaintext is the better choice for bulk work.
+more than the lookup on a fast resolver); each lookup opens its own TCP
+connection, so keep one resolver per thread when parallelising; and DoT/DoH add
+a TLS handshake per lookup, so plaintext is the better choice for bulk work.
 
 ### SPF and DKIM
 
@@ -205,9 +205,8 @@ DMARCator.configure do |config|
 end
 ```
 
-A resolver object is shared by every thread, and `Resolv::DNS` does not
-serialise concurrent lookups, so threaded applications should configure a
-factory instead:
+A resolver object is shared by every thread, so threaded applications should
+configure a factory instead:
 
 ```ruby
 DMARCator.configure do |config|
@@ -251,8 +250,9 @@ report.records.first.source_ip
 
 ## DNS transport
 
-By default, DMARC lookups use plain DNS through `Resolv`. Encrypted transports
-can be selected with environment variables; no DNS provider is baked in:
+By default, lookups use plain DNS over **TCP** (`DMARCator::Resolver::Plain`).
+Encrypted transports can be selected with environment variables; no DNS provider
+is baked in:
 
 ```sh
 # DNS over HTTPS (RFC 8484)
@@ -271,7 +271,15 @@ export DMARCATOR_DNS_TIMEOUT=5
 
 Certificates are always verified. `DMARCATOR_DOH_IP` pins the address so the
 DoH endpoint does not have to be resolved first; TLS still verifies the URL's
-hostname.
+hostname. `DMARCATOR_DNS_TIMEOUT` applies to every transport, including
+plaintext (default 5 seconds).
+
+Plaintext uses TCP rather than UDP deliberately. `Resolv::DNS` reads UDP replies
+into a 512-byte buffer, so a larger answer cannot be decoded, is discarded, and
+the resulting timeout is swallowed — meaning any TXT set over 512 bytes (common
+for SPF, and for domains with several DKIM keys) came back as an empty result,
+indistinguishable from "no records published". TCP has no such limit, and
+failures raise `DMARCator::ResolutionError`.
 
 Encrypted transports fail closed: a transport failure raises
 `DMARCator::ResolutionError` instead of being reported as a domain without a
@@ -300,9 +308,10 @@ XML helper, the internal resolver plumbing — may change in a minor release.
 * `DMARCator::Record`, `DMARCator::Report` and the parsed value objects are
   read-only after construction and safe to share between threads.
 * The memoized parser and transform are shared, and safe for concurrent use.
-* Resolvers are not necessarily safe for concurrent lookups: `Resolv::DNS` does
-  not serialise queries. Use one resolver per thread, or configure a factory
-  with `DMARCator.configure` so each lookup builds its own.
+* Resolvers are not necessarily safe for concurrent lookups: each lookup opens
+  its own connection, but `Resolv::DNS` (if you inject one) does not serialise
+  queries. Use one resolver per thread, or configure a factory with
+  `DMARCator.configure` so each lookup builds its own.
 * `DMARCator.configure` mutates process-wide state. Call it during boot rather
   than per request.
 
@@ -348,7 +357,6 @@ for the reporting policy and scope.
 ## Requirements
 
 * [Ruby] >= 3.3.13
-* [parslet] >= 1.0.0, < 3.0.0
 * [nokogiri] >= 1.10
 
 ## Testing
@@ -417,6 +425,5 @@ created by D Salko and released under the MIT License.
 [dmarc-parser-gem]: https://rubygems.org/gems/dmarc_parser
 [Trail of Bits]: https://www.trailofbits.com
 [Ruby]: https://www.ruby-lang.org
-[parslet]: https://kschiess.github.io/parslet/
 [nokogiri]: https://nokogiri.org
 [LICENSE.txt]: LICENSE.txt

data/lib/dmarcator/internal/parser.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
+require 'strscan'
+require 'uri'
+
 require_relative '../exceptions'
 require_relative '../uri'
 
-require 'parslet'
-require 'uri'
-
 module DMARCator
   #
   # Implementation details of the library. Nothing here is covered by the
@@ -15,342 +15,300 @@ module DMARCator
   #
   module Internal
     #
-    # DMARC parser.
+    # Parses DMARC records (RFC 7489 section 6.4).
     #
-    # An implementation detail: use {Record.parse} rather than this class.
+    # A hand-written parser rather than a parser-combinator grammar: the
+    # language is small, and this keeps record parsing allocation-light and
+    # free of a runtime dependency.
     #
-    # @api private
+    # @see https://www.rfc-editor.org/rfc/rfc7489#section-6.4
     #
-    # @see https://tools.ietf.org/html/rfc7489#section-6.4
+    # @api private
     #
-    class Parser < Parslet::Parser
-
+    class Parser
       # Maximum accepted DMARC record size in bytes. Real records are far
       # smaller; the cap bounds parsing work on hostile input.
-      #
       MAX_RECORD_BYTES = 4096
 
-      root :dmarc_record
+      # Maximum length of error messages echoed from untrusted input.
+      MAX_ERROR_MESSAGE_LENGTH = 300
 
-      rule(:dmarc_record) do
-        dmarc_version.repeat(1,1) >>
-        (dmarc_sep >> dmarc_tag).repeat >>
-        dmarc_sep.maybe >>
-        wsp?.maybe
-      end
+      # Tags whose value is one keyword from a fixed set.
+      KEYWORD_TAGS = {
+        'p' => %w[none quarantine reject],
+        'sp' => %w[none quarantine reject],
+        'adkim' => %w[r s],
+        'aspf' => %w[r s],
+        'rf' => %w[afrf iodef]
+      }.freeze
 
-      rule(:dmarc_sep) { wsp? >> str(';') >> wsp? }
+      # Tags whose value is a decimal number of at most N digits.
+      DIGIT_TAGS = { 'ri' => 10, 'pct' => 3 }.freeze
 
-      rule(:dmarc_version) do
-        str('v') >> wsp? >>
-        str('=') >> wsp? >>
-        str('DMARC1').as(:v)
-      end
+      # Tags whose value is a list of mailto URIs.
+      URI_TAGS = %w[rua ruf].freeze
 
-      rule(:dmarc_tag) do
-        dmarc_request   |
-        dmarc_srequest  |
-        dmarc_auri      |
-        dmarc_furi      |
-        dmarc_adkim     |
-        dmarc_aspf      |
-        dmarc_ainterval |
-        dmarc_fo        |
-        dmarc_rfmt      |
-        dmarc_percent   |
-        unknown_tag
-      end
+      # The `v=` tag, which may only appear first.
+      VERSION = /\Av[ \t]*=[ \t]*DMARC1\z/
 
-      #
-      # Defines a rule for a `tag=value` DMARC tag, capturing values that do not
-      # match the rule as `:invalid_tag` so strict mode can reject them.
-      #
-      # @param [Symbol] name
-      #   The rule name, used as `dmarc_<name>`.
-      #
-      # @param [String] tag
-      #   The DMARC tag name.
-      #
-      # @yieldreturn [Parslet::Atoms::Base]
-      #   The parslet matching the tag's value.
-      #
-      # @api private
-      #
-      def self.tag_rule(name,tag,&block)
-        rule(:"dmarc_#{name}") do
-          (
-            str(tag) >> wsp? >> str('=') >> wsp? >>
-            instance_eval(&block).as(tag.to_sym)
-          ) |
-          (
-            str(tag) >> wsp? >> str('=') >> wsp? >>
-            match["^; \t"].repeat(1)
-          ).as(:invalid_tag)
-        end
-      end
+      # Characters allowed in a mailto local part and domain.
+      ADDRESS = /[A-Za-z0-9._%+-]+@[A-Za-z0-9._%+-]+/
 
-      tag_rule(:request,'p') do
-        str('none') | str('quarantine') | str('reject')
-      end
+      # Characters allowed between tags.
+      WSP = /[ \t]*/
 
-      tag_rule(:srequest,'sp') do
-        str('none') | str('quarantine') | str('reject')
-      end
+      class << self
+        #
+        # Parses a DMARC record.
+        #
+        # @param [String] record
+        #   The raw DMARC record to parse.
+        #
+        # @param [Boolean] strict (false)
+        #   When `true`, raise on unknown tags or invalid tag values instead
+        #   of silently ignoring them.
+        #
+        # @return [Hash{Symbol => Object}]
+        #
+        # @raise [InvalidRecord]
+        #   The record is malformed, is too large, or (in strict mode)
+        #   contains an unknown tag or invalid tag value.
+        #
+        def parse(record, strict: false)
+          unless record.is_a?(String)
+            raise InvalidRecord, "DMARC record must be a String, got #{record.class}"
+          end
 
-      tag_rule(:auri, 'rua') do
-        dmarc_uri >> (uri_list_sep.present? >> uri_list_sep).repeat >> (wsp? >> str(',')).absent?
-      end
+          if record.bytesize > MAX_RECORD_BYTES
+            raise InvalidRecord, "DMARC record exceeds maximum size of #{MAX_RECORD_BYTES} bytes"
+          end
 
-      tag_rule(:ainterval,'ri') { digit.repeat(1, 10) >> digit.absent? }
+          # Malformed or non-ASCII-compatible encodings make the regular
+          # expressions below raise ArgumentError or Encoding::CompatibilityError
+          # instead of InvalidRecord, which would escape `rescue DMARCator::Error`.
+          unless record.encoding.ascii_compatible?
+            raise InvalidRecord,
+                  "DMARC record must be ASCII-compatible text, got #{record.encoding}"
+          end
 
-      tag_rule(:furi,'ruf') do
-        dmarc_uri >> (uri_list_sep.present? >> uri_list_sep).repeat >> (wsp? >> str(',')).absent?
-      end
+          unless record.valid_encoding?
+            raise InvalidRecord, "DMARC record is not valid #{record.encoding} text"
+          end
 
-      tag_rule(:fo,'fo') do
-        fo_opt >> (wsp? >> str(':') >> wsp? >> fo_opt).repeat
-      end
+          tags = { v: :DMARC1 }
 
-      rule(:fo_opt) { match['01ds'].as(:fo_opt) }
+          split(record).each do |segment|
+            status, key, value = parse_segment(segment)
 
-      tag_rule(:rfmt,'rf') { str('afrf') | str('iodef') }
+            case status
+            when :ok
+              raise InvalidRecord, "duplicate DMARC tag: #{key}" if tags.key?(key)
 
-      tag_rule(:percent,'pct') { digit.repeat(1,3) >> digit.absent? }
+              tags[key] = value
+            when :unknown
+              if strict
+                raise InvalidRecord, "unknown DMARC tag: #{truncate(segment).inspect}"
+              end
+            when :invalid
+              if strict
+                raise InvalidRecord, "invalid DMARC tag value: #{truncate(segment).inspect}"
+              end
+            end
+          end
 
-      tag_rule(:adkim, 'adkim') { match['rs'] }
-      tag_rule(:aspf, 'aspf')   { match['rs'] }
+          validate!(tags)
+        end
 
-      rule(:unknown_tag) { match["^; \t"].repeat(1).as(:unknown_tag) }
+        private
 
-      rule(:dmarc_uri) do
-        mailto_uri.as(:uri) >> (
-          str('!') >> digit.repeat(1, 10).as(:size) >> digit.absent? >> (
-            match['kmgt']
-          ).as(:unit).maybe
-        ).maybe >> str('!').absent?
-      end
+        #
+        # Splits a record into tag segments, validating the version tag.
+        #
+        def split(record)
+          separator = record.index(';')
+          version = (separator ? record[0, separator] : record).sub(/[ \t]+\z/, '')
+          rest = separator ? record[(separator + 1)..] : ''
 
-      rule(:uri_list_sep) { wsp? >> str(',') >> wsp? >> dmarc_uri }
+          unless version.match?(VERSION)
+            raise InvalidRecord, "invalid DMARC record: #{truncate(record).inspect}"
+          end
 
-      rule(:mailto_uri) do
-        match['mM'] >> match['aA'] >> match['iI'] >> match['lL'] >> match['tT'] >> match['oO'] >>
-        str(':') >> mailto_address
-      end
+          # At most one trailing separator, plus optional surrounding space.
+          rest = rest.sub(/[ \t]+\z/, '').sub(/;[ \t]*\z/, '').sub(/[ \t]+\z/, '')
 
-      rule(:mailto_address) do
-        mailto_local >> str('@') >> mailto_domain
-      end
+          return [] if rest.empty?
 
-      rule(:mailto_local)  { mailto_char.repeat(1) }
-      rule(:mailto_domain) { mailto_char.repeat(1) }
-      rule(:mailto_char)   { match["A-Za-z0-9._%+-"] }
-
-      rule(:digit) { match('[0-9]') }
-      rule(:wsp) { str(' ') | str("\t") }
-      rule(:wsp?) { wsp.repeat }
-
-      #
-      # Converts the raw parse tree into tag attributes.
-      #
-      # @api private
-      #
-      class Transform < Parslet::Transform
-
-        rule(fo_opt: simple(:fo_opt)) { fo_opt }
-        rule(fo: simple(:fo_opt)) { {fo: [fo_opt]} }
-
-        rule(v: simple(:version)) { {v: version.to_sym} }
-        rule(p:  simple(:p))  { {p:  p.to_sym } }
-        rule(sp: simple(:sp)) { {sp: sp.to_sym} }
-        rule(rf: simple(:rf)) { {rf: rf.to_sym} }
-        rule(adkim: simple(:adkim)) { {adkim: adkim.to_sym} }
-        rule(aspf:  simple(:aspf))  { {aspf: aspf.to_sym} }
-
-        rule(pct: simple(:pct)) { {pct: pct.to_i} }
-        rule(ri:  simple(:ri))  { {ri:  ri.to_i}  }
-
-        rule(uri: simple(:uri), size: simple(:size), unit: simple(:unit)) do
-          Uri.new(
-            Transform.parse_uri(uri),
-            size.to_i,
-            unit.to_sym
-          )
-        end
-        rule(uri: simple(:uri), size: simple(:size)) do
-          Uri.new(
-            Transform.parse_uri(uri),
-            size.to_i
-          )
-        end
-        rule(uri: simple(:uri)) { Uri.new(Transform.parse_uri(uri)) }
-        rule(rua: subtree(:uris)) { {rua: Array(uris)} }
-        rule(ruf: subtree(:uris)) { {ruf: Array(uris)} }
+          rest.split(';', -1).map do |segment|
+            segment = segment.sub(/\A[ \t]+/, '').sub(/[ \t]+\z/, '')
 
-        # Maximum length of error messages echoed from untrusted input.
-        MAX_ERROR_MESSAGE_LENGTH = 300
+            if segment.empty?
+              raise InvalidRecord, "invalid DMARC record: #{truncate(record).inspect}"
+            end
+
+            segment
+          end
+        end
 
         #
-        # Parses a `mailto:` URI from a parse tree slice.
-        #
-        # @param [Parslet::Slice] value
-        #
-        # @return [URI::MailTo]
+        # Classifies and parses one `tag=value` segment.
         #
-        # @raise [InvalidRecord]
-        #   The URI is not a valid `mailto:` URI.
+        # @return [Array(Symbol, Symbol, Object), Array(Symbol)]
         #
-        # @api private
-        #
-        def self.parse_uri(value)
-          uri = value.to_s
+        def parse_segment(segment)
+          name, value = segment.split('=', 2)
 
-          begin
-            parsed = URI.parse(uri)
-          rescue URI::Error => error
-            raise InvalidRecord, truncate(error.message)
-          end
+          return [:unknown] if value.nil?
+
+          name = name.sub(/[ \t]+\z/, '').sub(/\A[ \t]+/, '')
+          value = value.sub(/\A[ \t]+/, '').sub(/[ \t]+\z/, '')
 
-          unless parsed.is_a?(URI::MailTo)
-            raise InvalidRecord, "invalid DMARC report URI (expected mailto): #{truncate(uri)}"
+          # A known tag with an empty value is not a tag at all.
+          return [:unknown] if value.empty?
+
+          if (keywords = KEYWORD_TAGS[name])
+            keyword(name, keywords, value)
+          elsif (max = DIGIT_TAGS[name])
+            digits(name, max, value)
+          elsif name == 'fo'
+            fo(value)
+          elsif URI_TAGS.include?(name)
+            uri_list(name, value, segment)
+          else
+            [:unknown]
           end
+        end
 
-          parsed
+        def keyword(name, keywords, value)
+          return [:ok, name.to_sym, value.to_sym] if keywords.include?(value)
+
+          # A known keyword followed by junk is a malformed record, not an
+          # invalid value: the value grammar matched and the remainder did not.
+          malformed!(value) if keywords.any? { |keyword| value.start_with?(keyword) }
+
+          [:invalid]
         end
 
-        #
-        # Truncates an error message to a bounded length.
-        #
-        # @param [String] message
-        #
-        # @return [String]
-        #
-        # @api private
-        #
-        def self.truncate(message)
-          message = message.to_s
+        def digits(name, max, value)
+          if value.match?(/\A\d+\z/)
+            return [:invalid] if value.length > max
 
-          if message.length > MAX_ERROR_MESSAGE_LENGTH
-            message[0, MAX_ERROR_MESSAGE_LENGTH] + "..."
-          else
-            message
+            return [:ok, name.to_sym, value.to_i]
           end
-        end
 
-      end
+          malformed!(value) if value.match?(/\A\d/)
 
-      #
-      # Parses a DMARC record.
-      #
-      # @param [String] record
-      #   The raw DMARC record to parse.
-      #
-      # @param [Boolean] strict (false)
-      #   When `true`, raise on unknown tags or invalid tag values instead of
-      #   silently ignoring them.
-      #
-      # @return [Hash{Symbol => Object}]
-      #   The Hash of tags within the record.
-      #
-      # @raise [InvalidRecord]
-      #   The record is not a String, is malformed, is too large, or (in strict
-      #   mode) contains an unknown tag or invalid tag value.
-      #
-      def self.parse(record, strict: false)
-        unless record.is_a?(String)
-          raise InvalidRecord, "DMARC record must be a String, got #{record.class}"
+          [:invalid]
         end
 
-        if record.bytesize > MAX_RECORD_BYTES
-          raise InvalidRecord, "DMARC record exceeds maximum size of #{MAX_RECORD_BYTES} bytes"
+        def fo(value)
+          return [:ok, :fo, value.split(':')] if value.match?(/\A[01ds](?::[01ds])*\z/)
+
+          malformed!(value) if value.match?(/\A[01ds](?::[01ds])*/)
+
+          [:invalid]
         end
 
-        tree = parser.parse(record)
+        def uri_list(name, value, _segment)
+          uris = []
+          scanner = StringScanner.new(value)
 
-        if strict
-          tree.each do |node|
-            next unless ignored?(node)
+          loop do
+            uri = parse_uri(scanner)
 
-            if node.key?(:unknown_tag)
-              raise InvalidRecord, "unknown DMARC tag: #{Transform.truncate(node[:unknown_tag].to_s).inspect}"
-            else
-              raise InvalidRecord, "invalid DMARC tag value: #{Transform.truncate(node[:invalid_tag].to_s).inspect}"
-            end
+            # Any failure inside a URI makes the whole tag invalid.
+            return [:invalid] if uri.nil?
+
+            uris << uri
+
+            scanner.skip(WSP)
+
+            break if scanner.eos?
+
+            # A valid URI followed by junk is a malformed record.
+            malformed!(value) unless scanner.scan(/,/)
+
+            scanner.skip(WSP)
+
+            # A trailing comma leaves no URI to parse.
+            return [:invalid] if scanner.eos?
           end
+
+          [:ok, name.to_sym, uris]
         end
 
-        tags = transform.apply(tree.reject { |node| ignored?(node) })
-        hash = {}
+        #
+        # Parses one `mailto:` URI, with its optional size and unit.
+        #
+        # @return [Uri, nil]
+        #   The URI, or `nil` when the value is not a valid DMARC URI.
+        #
+        def parse_uri(scanner)
+          start = scanner.pos
 
-        tags.each do |tag|
-          tag.each_key do |key|
-            if hash.key?(key)
-              raise InvalidRecord, "duplicate DMARC tag: #{key}"
-            end
+          return nil unless scanner.scan(/mailto:/i) && scanner.scan(ADDRESS)
+
+          uri_text = scanner.string.byteslice(start, scanner.pos - start)
+          size = unit = nil
+
+          if scanner.scan(/!/)
+            digits = scanner.scan(/\d{1,10}/)
+
+            # A bare `!` or more than ten digits is an invalid value.
+            return nil if digits.nil? || scanner.match?(/\d/)
+
+            size = digits.to_i
+            unit = scanner.scan(/[kmgt]/)&.to_sym
+
+            # A second `!` is an invalid value.
+            return nil if scanner.match?(/!/)
           end
 
-          hash.merge!(tag)
-        end
+          parsed = begin
+            URI.parse(uri_text)
+          rescue URI::Error
+            return nil
+          end
 
-        validate!(hash)
+          return nil unless parsed.is_a?(URI::MailTo)
 
-        return hash
-      end
+          Uri.new(parsed, size, unit)
+        end
 
-      #
-      # Determines whether a parse-tree node represents a tag that the lenient
-      # parser dropped because it was unknown or had an invalid value.
-      #
-      # @param [Object] node
-      #   The parse-tree node.
-      #
-      # @return [Boolean]
-      #
-      def self.ignored?(node)
-        node.is_a?(Hash) && (node.key?(:unknown_tag) || node.key?(:invalid_tag))
-      end
+        #
+        # Raises for input whose valid prefix was followed by junk.
+        #
+        def malformed!(value)
+          raise InvalidRecord, "invalid DMARC record: #{truncate(value).inspect}"
+        end
 
-      #
-      # The memoized parser instance. Parslet caches rules per instance, so
-      # reusing it avoids rebuilding the grammar on every call.
-      #
-      # @return [Parser]
-      #
-      # @api private
-      #
-      def self.parser
-        @parser ||= new
-      end
+        #
+        # Validates parsed tag values that have a range.
+        #
+        def validate!(tags)
+          if tags[:pct] && !tags[:pct].between?(0, 100)
+            raise InvalidRecord, 'pct must be an integer between 0 and 100'
+          end
 
-      #
-      # The memoized transform instance.
-      #
-      # @return [Transform]
-      #
-      # @api private
-      #
-      def self.transform
-        @transform ||= Transform.new
-      end
+          if tags[:ri] && !tags[:ri].between?(0, 2**32 - 1)
+            raise InvalidRecord, 'ri must be an integer between 0 and 4294967295'
+          end
 
-      #
-      # Validates the parsed tags.
-      #
-      # @param [Hash{Symbol => Object}] tags
-      #   The parsed tags.
-      #
-      # @raise [InvalidRecord]
-      #   One of the tags has an invalid value.
-      #
-      def self.validate!(tags)
-        if tags[:pct] && !(tags[:pct].is_a?(Integer) && tags[:pct].between?(0, 100))
-          raise InvalidRecord, "pct must be an integer between 0 and 100"
+          tags
         end
 
-        if tags[:ri] && !(tags[:ri].is_a?(Integer) && tags[:ri].between?(0, 2**32 - 1))
-          raise InvalidRecord, "ri must be an integer between 0 and 4294967295"
+        #
+        # Truncates an error message to a bounded length.
+        #
+        def truncate(message)
+          message = message.to_s
+
+          if message.length > MAX_ERROR_MESSAGE_LENGTH
+            message[0, MAX_ERROR_MESSAGE_LENGTH] + '...'
+          else
+            message
+          end
         end
       end
-
     end
   end
 end

data/lib/dmarcator/query.rb

@@ -18,8 +18,9 @@ module DMARCator
   #
   # DNS query timeouts in seconds, tried in order.
   #
-  # Applied when the library builds a plaintext resolver. Timeouts on an
-  # injected resolver are left alone.
+  # @deprecated No longer used. Plaintext lookups use a single timeout
+  #   ({Resolver::Plain}), configurable with `DMARCATOR_DNS_TIMEOUT`.
+  #   Removed in 2.0.
   #
   DNS_TIMEOUTS = [2, 4, 8].freeze
 

data/lib/dmarcator/record.rb

@@ -284,36 +284,8 @@ module DMARCator
       end
 
       new(attributes)
-    rescue Parslet::ParseFailed => error
-      # Raising inside the rescue sets this error as the cause automatically.
-      raise InvalidRecord, truncate_error_message(error.message)
     end
 
-    # Maximum length of error messages echoed from parsing untrusted input.
-    MAX_ERROR_MESSAGE_LENGTH = 500
-
-    #
-    # Truncates error messages to avoid echoing large amounts of untrusted
-    # input in exceptions.
-    #
-    # @param [String] message
-    #   The error message to truncate.
-    #
-    # @return [String]
-    #   The truncated error message.
-    #
-    def self.truncate_error_message(message)
-      message = message.to_s
-
-      if message.length > MAX_ERROR_MESSAGE_LENGTH
-        message[0, MAX_ERROR_MESSAGE_LENGTH] + "..."
-      else
-        message
-      end
-    end
-
-    private_class_method :truncate_error_message
-
     #
     # Looks up and parses the DMARC record for a domain.
     #

data/lib/dmarcator/resolver/plain.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'resolv'
+require 'socket'
+
+require_relative '../exceptions'
+require_relative 'encrypted'
+
+module DMARCator
+  module Resolver
+    #
+    # Plain DNS over TCP ([RFC 1035] section 4.2.2).
+    #
+    # TCP rather than UDP on purpose. `Resolv::DNS` reads UDP replies into a
+    # 512-byte buffer, so a larger answer cannot be decoded, is discarded, and
+    # the resulting timeout is swallowed unless `raise_timeout_errors` is set.
+    # Large TXT sets - SPF records, several DKIM keys - therefore came back as
+    # an empty result, which looks exactly like "no records published". TCP has
+    # no such limit, and failures here raise {ResolutionError}.
+    #
+    # [RFC 1035]: https://www.rfc-editor.org/rfc/rfc1035#section-4.2.2
+    #
+    # @since 1.2.0
+    #
+    class Plain < Encrypted
+      # Default DNS port.
+      DEFAULT_PORT = 53
+
+      # Default connect/read timeout in seconds.
+      DEFAULT_TIMEOUT = 5
+
+      # @return [Array<Array(String, Integer)>] the nameservers to try.
+      attr_reader :nameservers
+
+      # @return [Integer] connect/read timeout in seconds.
+      attr_reader :timeout
+
+      #
+      # Builds a resolver from environment variables.
+      #
+      # @param [Hash] env
+      #
+      # @return [Plain]
+      #
+      # @raise [ArgumentError]
+      #   `DMARCATOR_DNS_TIMEOUT` is not an integer.
+      #
+      def self.from_env(env = ENV)
+        new(timeout: timeout_from(env))
+      end
+
+      def self.timeout_from(env)
+        value = env['DMARCATOR_DNS_TIMEOUT']
+
+        value.nil? || value.empty? ? DEFAULT_TIMEOUT : Integer(value, 10)
+      end
+
+      #
+      # The nameservers from the system resolver configuration.
+      #
+      # @return [Array<Array(String, Integer)>]
+      #
+      def self.system_nameservers
+        config = Resolv::DNS::Config.default_config_hash
+
+        if (ports = config[:nameserver_port]) && !ports.empty?
+          return ports.map { |host, port| [host, port || DEFAULT_PORT] }
+        end
+
+        servers = Array(config[:nameserver])
+        servers = ['127.0.0.1'] if servers.empty?
+
+        servers.map { |host| [host, DEFAULT_PORT] }
+      end
+
+      def initialize(nameservers: nil, timeout: DEFAULT_TIMEOUT)
+        @nameservers = (nameservers || self.class.system_nameservers).freeze
+        @timeout = timeout
+
+        raise ArgumentError, 'no nameservers configured' if @nameservers.empty?
+      end
+
+      private
+
+      def exchange(query)
+        wire = query.encode
+        last_error = nil
+
+        @nameservers.each do |host, port|
+          begin
+            return request(host, port, wire)
+          rescue StandardError => error
+            last_error = error
+          end
+        end
+
+        raise ResolutionError,
+              "DNS lookup failed: #{last_error&.message || 'no nameservers'}"
+      end
+
+      def request(host, port, wire)
+        socket = Socket.tcp(host, port, connect_timeout: @timeout)
+        socket.timeout = @timeout if socket.respond_to?(:timeout=)
+
+        socket.write([wire.bytesize].pack('n') + wire)
+
+        header = socket.read(2)
+        raise ResolutionError, 'short DNS response' if header.nil? || header.bytesize < 2
+
+        body = socket.read(header.unpack1('n'))
+        raise ResolutionError, 'short DNS response' if body.nil?
+
+        body
+      ensure
+        socket&.close
+      end
+    end
+  end
+end

data/lib/dmarcator/resolver.rb

@@ -4,6 +4,7 @@ require 'resolv'
 
 require_relative 'exceptions'
 require_relative 'resolver/encrypted'
+require_relative 'resolver/plain'
 require_relative 'resolver/doh'
 require_relative 'resolver/dot'
 
@@ -14,7 +15,7 @@ module DMARCator
   # The transport is chosen with the `DMARCATOR_DNS` environment variable, or
   # explicitly via {.build}:
   #
-  #   DMARCATOR_DNS=plaintext          # default: Resolv::DNS (UDP/TCP)
+  #   DMARCATOR_DNS=plaintext          # default: TCP (Resolver::Plain)
   #   DMARCATOR_DNS=doh                # requires DMARCATOR_DOH_URL
   #   DMARCATOR_DNS=dot                # requires DMARCATOR_DOT_SERVER
   #
@@ -61,9 +62,7 @@ module DMARCator
 
       case name
       when 'plaintext'
-        resolver = Resolv::DNS.new
-        resolver.timeouts = DNS_TIMEOUTS
-        resolver
+        Plain.from_env(env)
       when 'doh'
         DoH.from_env(env)
       when 'dot'

data/lib/dmarcator/version.rb

@@ -2,5 +2,5 @@
 
 module DMARCator
   # dmarcator version
-  VERSION = '1.0.0'
+  VERSION = '1.2.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dmarcator
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Noah Berman
@@ -9,26 +9,6 @@ bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: parslet
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.0.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 3.0.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.0.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
@@ -71,6 +51,7 @@ files:
 - lib/dmarcator/resolver/doh.rb
 - lib/dmarcator/resolver/dot.rb
 - lib/dmarcator/resolver/encrypted.rb
+- lib/dmarcator/resolver/plain.rb
 - lib/dmarcator/uri.rb
 - lib/dmarcator/version.rb
 homepage: https://github.com/bermannoah/dmarcator