epithet 1.1.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 100d3ac2b640a77419d9d6f45228ed67251285ed6f0bf390b9249573d20db887
-  data.tar.gz: 5350064afb6799feec528888c475bcc0d8e403272f13332d00bdcd43b7bcd47c
+  metadata.gz: 8065749fc3d0aaf89280bc7238f8dfe30ce749bf9c09c84fbec0406bde779d1b
+  data.tar.gz: 8e42aeba4a5f3bae8cec60bac6719a1214f6750de8a8b33ce009af8d7c8dd20c
 SHA512:
-  metadata.gz: 77e5c3acde924854471a36ede3d43e010fcf4f2bd7f4a49b75c753e7c80e4c0651355c0c33ec28a9d1c229abf14fd5da61b40c1eae2a23cbd31f8c8ef94cd9a5
-  data.tar.gz: 21a8c95376177e30642bed7aefd1b1f87ccd5f0a00d489592c154ed1ecf86cdf076df57f04f98d01ad802b4ea1c62367b5afcc0fdd165501f95fe081ac10efd9
+  metadata.gz: 6946cf232b610670fd5cdd5c1293f1d3c882a4efa36f3e1a9971ce667f9291130372f2106b83cf8bbad16673d1b13fbb5e7b1475989a2b2dc7b201fc44347562
+  data.tar.gz: 3437d52226de8303e23db85c11dd803ac1556f267b067696822f864b17d8b1ed1b314ec421074da0766e23ecd2efb926c6cb58dfefc7d7f0d1272e804d3ddcce

data/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 2.1.0 - 2026-07-23
+
+- Add support for JRuby and TruffleRuby
+- Support multiple scrypt providers (OpenSSL, BouncyCastle, and the `scrypt` gem)
+- Raise `Epithet::ConfigurationError` (< `RuntimeError`) if config missing
+- Unknown cipher/digest names now raise `ArgumentError`
+- Internal reorganisation into separate files
+- Robustness improvements inc. broader CI coverage & concurrency hammer
+- Documentation edits
+
+## 2.0.0 - 2026-07-16
+
+### Breaking changes
+
+- The subkey-derivation option `context:` replaces `salt:`, to avoid confusion with scrypt's salt parameter.
+- Subkey derivation now binds the configured cipher and digest names (lowercased) into the HKDF info.
+- Nil and empty-string prefixes now yield bare params with no separator.
+- Config no longer exposes the alphabet string, it carries the Block58 codec around instead.
+- Drop support for Rubies < 3.4.
+
+### Other changes
+
+- Raise Epithet::FormatError (< ArgumentError) on invalid wire format
+- Improve handling of string encodings
+- Additional invariants
+- Friendlier errors
+- Documentation improvements
+
 ## 1.1.0 - 2026-07-14
 
 - Freeze config strings upon object initialization

data/README.md

@@ -1,6 +1,6 @@
 # Epithet
 
-Epithet generates stable, compact, purposefully prefixed Base58 identifiers from 64-bit integers for reversible obfuscation and tamper detection.
+Epithet generates stable, compact, purposefully prefixed base58 identifiers from 64-bit integers for reversible obfuscation and tamper detection.
 
 * https://github.com/inopinatus/epithet
 * https://inopinatus.github.io/epithet/
@@ -21,7 +21,7 @@ gem install epithet
 
 ## Usage
 
-With `EPITHET_PASSPHRASE="example only"`:
+With `EPITHET_PASSPHRASE=example_only`:
 
 ```ruby
 require 'epithet'
@@ -29,7 +29,8 @@ require 'epithet'
 def epithet_initialize
   Epithet.configure(
     passphrase: ENV.fetch('EPITHET_PASSPHRASE'),
-    salt: 'v1'
+    scrypt: { salt: 'myapp/production' },
+    context: 'v1'
   )
 end
 
@@ -38,17 +39,21 @@ user_epithet = Epithet.new('user')
 
 id = 42
 param = user_epithet.encode(id)
-# => "user_VsuNnfEYQJJTJYE3n28jaY"
+# => "user_GikJf7Y58t5sgqJpifjgZy"
 
 user_epithet.decode(param)
 # => 42
 ```
 
-Configuration at initialisation is recommended, because deriving key material from the passphrase uses scrypt, and is consequently expensive. The `salt:` is optional; it's included when deriving the subkey material for obfuscating and tamper resistance, and may be useful for additional context discrimination or during secrets rotation.
+Configuration once at initialisation is recommended, because deriving key material from the passphrase uses scrypt, and is consequently expensive.  The `context:` is optional; this parameter is included when deriving the subkey material for obfuscating and tamper resistance, and may be used for separation of purpose or key rotation.  The scrypt step is seasoned by a salt, which defaults to a fixed constant; set an application-specific salt, as in the example above, so that two applications inadvertently sharing a passphrase never derive the same keys.
 
-Refer to the Epithet rdoc for the full set of configuration options.
+Refer to the [Epithet rdoc](https://inopinatus.github.io/epithet/) for the full set of configuration options.
 
-Note that `decode` returns `nil` when authentication fails and raises ArgumentError on invalid formats.
+Note that `Epithet#decode` returns `nil` when authentication fails, and raises `Epithet::FormatError` (an ArgumentError) on invalid formats.
+
+## Platform support
+
+Epithet supports standard Ruby (aka MRI/CRuby), JRuby, and TruffleRuby.  It uses your platform's OpenSSL scrypt where available; on JRuby it falls back to the BouncyCastle provider bundled with jruby-openssl, and LibreSSL builds can fall back to the optional [scrypt gem](https://rubygems.org/gems/scrypt).  To use the latter gem provider, your application must bundle and require `scrypt` before Epithet, we won't require it on your behalf.  All three providers produce identical key material.  To force a provider without a capability check, pass its class in the scrypt parameters, e.g. `scrypt: { provider: Epithet::Scrypt::BouncyCastle }`; omit `provider:` to select one automatically.
 
 ## Development
 

data/SECURITY.md

@@ -1,50 +1,73 @@
 # Epithet security
 
-## Cryptographic considerations
-
-The primary construction is `AES-256-ECB(id(8B) + HMAC-SHA256(id)[0,7])` with the result base58
-encoded for transmission and a contextual prefix prepended. Subkeys for AES and HMAC are by default
-derived with HKDF using an internal key generator that takes IKM from a passphrase via scrypt,
-salting generated keys by prefix and purpose.
-
 This library is intended for high-performance obfuscation of integer sequences, deflection of casual
 tampering, and conversion to a compact, stable wire parameter format that is hard to guess and hard
-to predict.  Although it uses standard cryptographic primitives to do so, the design trade-off of
-the compact format means it is not intended to defeat nation-state security services, talented
-cryptographers, or even a well-resourced enterprise.
+to predict.  Epithet forms a single-block deterministic PRP with an embedded truncated tag, and
+although it uses standard cryptographic primitives to do so, the design trade-off of the compact
+format means it is not intended to defeat nation-state security services, talented cryptographers,
+or even a well-resourced enterprise.
 
-The identifiers produced are intentionally deterministic i.e. replayable and reusable. For privacy,
-confidentiality, and authentication purposes they should therefore be considered equivalent to the
-plaintext integer they represent, and those concerns must still be addressed in the usual manner.
+## Cryptographic considerations
 
-The tamper detection is necessarily probabilistic, because the MAC is truncated.
+The primary construction is `AES-256-ECB(id(8B) + MSB_64(HMAC-SHA256(id)))` with the result base58
+encoded for transmission and a contextual prefix prepended.  Subkeys for AES and HMAC are by default
+derived with HKDF using an internal key generator that takes IKM from a passphrase via scrypt,
+salting generated keys by prefix and context and binding them by algorithm.
 
-Encodings are canonical, producing exactly one string per id, and Epithet will reject attempts to
-decode a value exceeding the 128-bit block.
+An epithet should never be used as an authentication token, only as an object identifier.  The
+64-bit tag is shorter than the minimum RFC 2104 §5 recommends for message authentication, and the
+tamper detection is necessarily probabilistic because the MAC is truncated.  After N independent
+forgery attempts, expected success is approximately (N/2^{64}).  The identifiers produced are
+intentionally deterministic i.e. replayable and reusable.  For privacy, confidentiality, and
+authentication purposes they should be considered equivalent to the plaintext integer they
+represent, and those concerns must still be addressed in the usual manner.
 
 If configuring alternative cipher algorithms, note that only 128-bit block ciphers that function
-without IV/nonce requirements are accepted. Streaming ciphers (e.g. chacha20) or block ciphers in
+without IV/nonce requirements are accepted.  Streaming ciphers (e.g. chacha20) or block ciphers in
 streaming modes (e.g. aes-256-ctr) must not be used; no nonce/IV value is included in construction,
 making them trivially vulnerable to known-plaintext attacks.  These, CBC/OCB, and other IV/nonce
 modes may also be rejected by Epithet's guardrails.
 
-If configuring alternative digest algorithms, note that any algorithm may be accepted whenever they
-it produces at least 64 bits of output. HMAC does not rest on collision resistance, so even dated
-digests are not trivially forgeable here, but algorithms other than the defaults step outside the
-supported security profile.  If you must stray, stay within the SHA-2 family.
+If configuring alternative digest algorithms, note that any algorithm may be accepted that produces
+at least 64 bits of output.  HMAC does not rest on collision resistance, so even dated digests are
+not trivially forgeable here, but algorithms other than the defaults step outside the supported
+profile.  If you must stray, we recommend staying within the SHA-2 family.
+
+Encodings are canonical, producing exactly one string per id, and Epithet will reject attempts to
+decode a value exceeding the 128-bit block.
 
 A weak, guessable, or disclosed passphrase will compromise the obfuscation and tamper-detection
 properties.
 
-Use Epithet at your own risk.
+To sum up: neither the design nor implementation of this library has received an independent
+cryptographic review.  It leaks equality, offers a 64-bit forgery bound, and supplies no
+authorization or privacy boundary.  Use Epithet at your own risk.
+
+## On seasoning
+
+Epithet uses salt in two ways.  Firstly, if the default key generator is in use, as part of the
+setup-time scrypt operation turning the configured passphrase into initial keying material.
+Secondly, for the HKDF extract phase to separate derived subkeys by some application-specific
+division such as purpose or rotation epoch.
+
+To avoid confusing the two uses, the HKDF salt is not referred to directly in Epithet's public API,
+and is instead derived from the context and prefix parameters.
+
+Epithet does not store or verify passwords; the scrypt salt, and the context & prefix parameters
+used in the HKDF salt, are non-secret configuration and may be safely committed to source control.
+
+## On rotation
+
+This gem provides a deterministic primitive; managing lifecycle, policy, and application-aware
+responses to legacy identifiers is intentionally left to framework/application-specific adapters.
+When implementing an adapter, the context parameter is recommended as the basis for key rotation.
 
-## On salt
+## Startup cost
 
-Epithet uses salt in two ways.  Firstly, as part of a scrypt operation to turn the configured
-passphrase into initial keying material.  Secondly, to supply an additional affordance to separate
-derived subkeys by some application-specific division such as purpose or rotation epoch.  Epithet
-does not store or verify passwords; both uses of salt are non-secret configuration and may safely be
-committed to source control.
+Turning a passphrase into initial keying material is intrinsically expensive.  The default scrypt
+parameters (N=2^17, r=8) cost roughly 128 MiB of peak memory and a fraction of a second of CPU.
+When deployed as indicated this is a boot-time cost, incurred once per configuration rather than
+per encode/decode, but budget for it in memory-constrained deployments.
 
 ## Vulnerabilities
 

data/examples/basic.rb

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
 
+require 'securerandom'
 require 'epithet'
 
+# Using a random passphrase means that epithet identifiers are effectively
+# ephemeral, since decoding is limited to the lifetime of this process.
 def epithet_initialize
   Epithet.configure(
-    passphrase: ENV.fetch('EPITHET_PASSPHRASE') { 'example only' },
-    salt: 'v1'
+    passphrase: ENV.fetch('EPITHET_PASSPHRASE') { SecureRandom.random_bytes(32) },
+    scrypt: { salt: 'myapp/production' },
+    context: 'v1'
   )
 end
 
@@ -13,6 +17,6 @@ epithet_initialize
 user_epithet = Epithet.new('user')
 
 id = Integer(ARGV.shift || 42)
-param = user_epithet.encode(id) #=> "user_VsuNnfEYQJJTJYE3n28jaY"
+param = user_epithet.encode(id)
 
 puts "User(#{user_epithet.decode(param)}) => #{param}"

data/lib/epithet/block58.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+class Epithet
+  # Fixed-length base58 codec for a fixed-size block.
+  #
+  # Obtain codecs via Block58::build, which selects the fastest variant for
+  # the block size, an unrolled decoder for 16-byte blocks, or the generic
+  # chunked decoder otherwise.
+  class Block58
+    # `= '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'`
+    Alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+
+    POW58 = Array.new(11) { 58**it }.freeze # :nodoc:
+
+    attr_reader :size
+
+    # Same as ::new but may select a tuned subclass for performance.
+    def self.build(block_size, ...) = (block_size == 16 ? Unrolled16 : self).new(block_size, ...)
+
+    # Create a codec for a block size in bytes.
+    #
+    # The alphabet must be 58 distinct bytes in ascending order, so that
+    # lexicographic order agrees with numeric order.
+    def initialize(block_size, alphabet: Alphabet)
+      raise ArgumentError, 'invalid block size' unless Integer === block_size && block_size > 0
+      @alphabet = alphabet.b.freeze
+      raise ArgumentError, 'invalid alphabet length' unless @alphabet.bytesize == 58
+      raise ArgumentError, 'alphabet not strictly ascending' unless @alphabet.bytes.each_cons(2).all? { _2 > _1 }
+      @size = ((block_size * 8) / Math.log2(58)).ceil
+      @charsel = @alphabet.gsub(/[\^\-\\]/, '\\\\\&').freeze
+      @blank = (@alphabet[0] * @size).freeze
+      @lut = @alphabet.each_byte.with_index.with_object("\0" * 256) { |(val, idx), lut| lut.setbyte(val, idx) }.freeze
+      @limit = 1 << (block_size * 8)
+      @max = i2s(@limit - 1).freeze
+    end
+
+    def inspect
+      "#<#{self.class}:#{'%#016x' % (object_id << 1)} size=#{@size} alphabet=#{@alphabet}>"
+    end
+
+    # Return true if the string is in range with the right size and alphabet.
+    # The input is read as bytes, whatever its encoding.
+    def valid?(s)
+      String === s && s.bytesize == @size && (s = s.b) <= @max && s.count(@charsel) == @size
+    end
+
+    # Encode an acceptable integer to fixed-length base58.
+    def i2s(int)
+      raise ArgumentError, 'integer out of block range' unless Integer === int && int >= 0 && int < @limit
+
+      # Using divmod+setbyte is faster than Integer#digits under YJIT,
+      # and about equal in plain MRI.
+      alphabet = @alphabet
+      out = @blank.dup
+      idx = @size - 1
+      n = int
+      while idx >= 0 && n > 0
+        n, rem = n.divmod(58)
+        out.setbyte(idx, alphabet.getbyte(rem))
+        idx -= 1
+      end
+      out
+    end
+
+    # Decode a fixed-length base58 string to an integer.
+    # Assumes the input passes `#valid?`, behaviour undefined if it doesn't.
+    def s2i(str)
+      # Chunking intermediate results into 64-bit integers is ~5x faster
+      # under YJIT than Horner's scheme
+      #
+      #   str.each_byte.inject(0) { _1 * 58 + @lut[_2] }
+      #
+      # at computing the inner product.
+      lut = @lut
+      size = @size
+      pow = POW58
+      acc = 0
+      pos = 0
+      while pos < size
+        n = size - pos
+        n = 10 if n > 10
+        chunk = 0
+        i = 0
+        while i < n
+          chunk = (chunk * 58) + lut.getbyte(str.getbyte(pos))
+          pos += 1
+          i += 1
+        end
+        acc = (acc * pow[n]) + chunk
+      end
+      acc
+    end
+
+    # Specialised decoder for 16-byte blocks (22 digits) with a fully unrolled inner product.
+    class Unrolled16 < Block58
+      def initialize(...)
+        super
+        raise ArgumentError, 'unrolled codec requires a 16-byte block' unless @size == 22
+      end
+
+      # Decode a 22-digit base58 string to an integer.
+      # Assumes the input passes `#valid?`, behaviour undefined if it doesn't.
+      def s2i(str)
+        # rubocop:disable Style/NumericLiterals, Lint/AmbiguousOperatorPrecedence, Layout
+        #
+        # By unrolling the chunks against literal coefficients, this tested with Ruby 4.0
+        # at ~1.5x faster under YJIT than the generic chunked Block58#s2i, and ~6x faster
+        # than Horner's scheme.
+        lut = @lut
+
+        acc0 = lut.getbyte(str.getbyte(0)) * 7427658739644928 +
+               lut.getbyte(str.getbyte(1)) * 128063081718016 +
+               lut.getbyte(str.getbyte(2)) * 2207984167552 +
+               lut.getbyte(str.getbyte(3)) * 38068692544 +
+               lut.getbyte(str.getbyte(4)) * 656356768 +
+               lut.getbyte(str.getbyte(5)) * 11316496 +
+               lut.getbyte(str.getbyte(6)) * 195112 +
+               lut.getbyte(str.getbyte(7)) * 3364 +
+               lut.getbyte(str.getbyte(8)) * 58 +
+               lut.getbyte(str.getbyte(9))
+
+        acc1 = lut.getbyte(str.getbyte(10)) * 7427658739644928 +
+               lut.getbyte(str.getbyte(11)) * 128063081718016 +
+               lut.getbyte(str.getbyte(12)) * 2207984167552 +
+               lut.getbyte(str.getbyte(13)) * 38068692544 +
+               lut.getbyte(str.getbyte(14)) * 656356768 +
+               lut.getbyte(str.getbyte(15)) * 11316496 +
+               lut.getbyte(str.getbyte(16)) * 195112 +
+               lut.getbyte(str.getbyte(17)) * 3364 +
+               lut.getbyte(str.getbyte(18)) * 58 +
+               lut.getbyte(str.getbyte(19))
+
+               lut.getbyte(str.getbyte(21)) +
+               lut.getbyte(str.getbyte(20)) * 58 +
+                                       acc1 * 3364 +
+                                       acc0 * 1449225352009601191936
+
+        # rubocop:enable Style/NumericLiterals, Lint/AmbiguousOperatorPrecedence, Layout
+      end
+    end
+  end
+end

data/lib/epithet/config.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'openssl'
+require 'epithet/block58'
+require 'epithet/keygen'
+
+class Epithet
+  # Class for passing around preset configs. See Epithet::configure for options.
+  class Config
+    attr_reader :keygen, :context, :separator, :cipher, :digest, :codec # :nodoc:
+
+    def initialize(opts = {})
+      opts = opts.dup
+      @separator = -String(opts.delete(:separator) { '_' })
+      @context = -String(opts.delete(:context))
+      alphabet = String(opts.delete(:alphabet) { Block58::Alphabet })
+      @cipher = -(opts.delete(:cipher) || 'aes-256-ecb').downcase
+      @digest = -(opts.delete(:digest) || 'sha256').downcase
+      keygen, passphrase, scrypt = %i[keygen passphrase scrypt].map { opts.delete it }
+
+      cipher = probe(OpenSSL::Cipher, @cipher)
+      digest = probe(OpenSSL::Digest, @digest)
+
+      raise ArgumentError, 'separator intersects alphabet' if @separator.bytes.intersect?(alphabet.bytes)
+      raise ArgumentError, "#{@cipher} not a 128-bit block cipher" if cipher.block_size != 16
+      raise ArgumentError, "#{@cipher} requires an IV/nonce" if cipher.iv_len != 0
+      raise ArgumentError, "#{@digest} produces < 64-bit digest" if digest.digest_length < 8
+      raise ArgumentError, 'use keygen: or passphrase:, not both' if keygen && (passphrase || scrypt)
+      raise ArgumentError, 'one of passphrase: or keygen: is required' unless keygen || passphrase
+      raise ArgumentError, "unused option(s) #{opts.keys}" unless opts.empty?
+
+      @codec = Block58.build(cipher.block_size, alphabet:)
+      @keygen = keygen || Keygen.new(passphrase:, digest: @digest, scrypt:)
+      freeze
+    end
+
+    # The openssl gem <4.0 raises bare RuntimeError for unrecognised algorithm
+    # names; jruby-openssl raises NotImplementedError.
+    def probe(kind, name) # :nodoc:
+      kind.new(name)
+    rescue OpenSSL::OpenSSLError, RuntimeError, NotImplementedError
+      raise ArgumentError, "unknown #{kind.name[/\w+\z/].downcase} #{name}"
+    end
+  end
+end

data/lib/epithet/keygen.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'openssl'
+require 'epithet/scrypt'
+
+class Epithet
+  # Key derivation helper
+  class Keygen
+    # Default parameters for scrypt.
+    #
+    # ```ruby
+    # DEFAULT_SCRYPT_PARAMS = {
+    #   provider: Epithet::Scrypt,
+    #   salt: 'epithet-default',
+    #   N: 1 << 17,
+    #   r: 8,
+    #   p: 1,
+    #   length: 32
+    # }.freeze
+    # ```
+    DEFAULT_SCRYPT_PARAMS = {
+      provider: Epithet::Scrypt,
+      salt: 'epithet-default',
+      N: 1 << 17,
+      r: 8,
+      p: 1,
+      length: 32
+    }.freeze
+
+    # Create a new key generator from a supplied passphrase, or from high-entropy initial key
+    # material if already prepared.  The passphrase will be hashed with scrypt.  Supplied scrypt
+    # params, if any, are merged over DEFAULT_SCRYPT_PARAMS, so this works:
+    #
+    #     Epithet::Keygen.new(
+    #       passphrase: ENV.fetch('EPITHET_PASSPHRASE'),
+    #       scrypt: { salt: "#{MyApp.name}/#{MyApp.env}" }
+    #     )
+    #
+    # A scrypt provider will be chosen by `Epithet::Scrypt`.  To override automatic selection
+    # and use a specific scrypt provider class, pass it as `provider` in the scrypt parameters:
+    #
+    #     kg = Epithet::Keygen.new(passphrase: 'pw', scrypt: { provider: Epithet::Scrypt::OpenSSL })
+    #
+    # but this should be unnecessary in the common case.
+    def initialize(ikm: nil, passphrase: nil, digest: 'sha256', scrypt: {})
+      raise ArgumentError, 'keygen requires either ikm or passphrase' unless passphrase.nil? ^ ikm.nil?
+
+      @ikm = (ikm&.b || build_scrypt(Hash(scrypt)).ikm(passphrase)).freeze
+      @digest = -String(digest)
+      freeze
+    end
+
+    def inspect
+      "#<#{self.class}:#{'%#016x' % (object_id << 1)} digest=#{@digest}>"
+    end
+
+    # Derive a key via HKDF.
+    def generate(info, salt, length)
+      OpenSSL::KDF.hkdf(@ikm, hash: @digest, info:, salt:, length:)
+    end
+
+    private
+
+    def build_scrypt(opts)
+      params = DEFAULT_SCRYPT_PARAMS.merge(opts)
+      params.delete(:provider).new(**params)
+    end
+  end
+end

data/lib/epithet/scrypt.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'openssl'
+require 'monitor'
+
+class Epithet
+  # Provider registry & classes for the scrypt implementations.
+  #
+  # A scrypt provider is any class that can be instantiated with the scrypt
+  # parameters `salt`, `N`, `r`, `p`, and `length`, has a predicate singleton
+  # method `auto?` indicating willingness to operate, and an instance method
+  # `ikm(passphrase)` that derives the key material.  Automatic selection picks
+  # the most recently registered willing provider.
+  #
+  # Of the builtin providers, we prefer `OpenSSL::KDF.scrypt` when the platform
+  # supplies it, then JRuby's BouncyCastle implementation, and finally an
+  # already-loaded [`scrypt`](https://rubygems.org/gems/scrypt) gem.  If none of
+  # these are available, selection falls through to a base class which raises
+  # `NotImplementedError` at the point of use.
+  #
+  # Epithet deliberately does not require the optional `scrypt` gem itself; an
+  # application relying on the `SCryptGem` provider should bundle and require
+  # `scrypt` before configuring Epithet.
+  #
+  # You may register a custom scrypt provider with the necessary signature, even
+  # after Epithet has loaded:
+  #
+  #     class MyProvider < Epithet::Scrypt::Base
+  #       def ikm(passphrase)
+  #         #...
+  #       end
+  #     end
+  #     Epithet::Scrypt.register(MyProvider)
+  #
+  # and this will be unconditionally preferred unless you also define a selective
+  # `auto?` method.
+  #
+  # Your `ikm` method should return `length` bytes of key material.
+  #
+  # Using this mechanism as a hook to deviate from the scrypt algorithm is not
+  # recommended; the better move would be to substitute a variant key
+  # generator in the `Epithet::Config` parameters, or supply IKM to an
+  # `Epithet::Keygen`.
+  module Scrypt
+    extend MonitorMixin
+
+    class << self
+      # The registered providers, in automatic-selection order.
+      def providers = synchronize { @providers }
+
+      # Registers `klass` ahead of the existing providers.
+      def register(klass) = synchronize { @providers = [klass, *@providers].freeze }
+
+      # Returns the first registered provider willing to operate.
+      def auto = providers.detect(&:auto?)
+
+      # Instantiates the automatically selected provider.
+      def new(...) = auto.new(...)
+    end
+
+    # :section: Providers
+    #
+    # ### `Base` class
+    #
+    # Defines the common `salt`, `N`, `r`, `p`, and `length` parameters.  It is
+    # the last-resort provider: `ikm(passphrase)` raises `NotImplementedError`
+    # when no scrypt implementation is available.
+    #
+    # ### `OpenSSL` class
+    #
+    # The default, preferred provider.  It uses `OpenSSL::KDF.scrypt` when the
+    # platform's OpenSSL supplies it.
+    #
+    # ### `BouncyCastle` class
+    #
+    # The JRuby fallback.  JRuby's `openssl` is a BouncyCastle wrapper, but does
+    # not expose BouncyCastle's scrypt, so this provider invokes it directly.
+    #
+    # ### `SCryptGem` class
+    #
+    # A fallback for LibreSSL and other OpenSSLs that lack scrypt.  It is
+    # available when the application has already loaded the optional
+    # [`scrypt`](https://rubygems.org/gems/scrypt) gem.
+    Base = Data.define(:salt, :N, :r, :p, :length) do # :nodoc: # rubocop:disable Naming/MethodName
+      def self.auto? = true
+      def ikm(passphrase) = raise NotImplementedError, 'no scrypt available'
+    end
+
+    class SCryptGem < Base # :nodoc:
+      def self.auto? = defined? ::SCrypt::Engine
+
+      def ikm(passphrase)
+        ::SCrypt::Engine.scrypt(passphrase, salt, self.N, r, p, length)
+      end
+    end
+
+    class BouncyCastle < Base # :nodoc:
+      def self.auto? = RUBY_ENGINE == 'jruby'
+
+      def ikm(passphrase)
+        String.from_java_bytes(
+          Java::OrgBouncycastleCryptoGenerators::SCrypt.generate(
+            passphrase.to_java_bytes, salt.to_java_bytes, self.N, r, p, length
+          )
+        )
+      end
+    end
+
+    class OpenSSL < Base # :nodoc:
+      def self.auto? = ::OpenSSL::KDF.respond_to? :scrypt
+
+      def ikm(passphrase)
+        ::OpenSSL::KDF.scrypt(passphrase, **to_h)
+      end
+    end
+
+    @providers = [OpenSSL, BouncyCastle, SCryptGem, Base].freeze
+  end
+end

data/lib/epithet/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 class Epithet
-  # `= '1.1.0'`
-  VERSION = '1.1.0'
+  # `= '2.1.0'`
+  VERSION = '2.1.0'
 end

data/lib/epithet.rb

@@ -2,6 +2,10 @@
 
 require 'epithet/version'
 require 'openssl'
+require 'epithet/scrypt'
+require 'epithet/keygen'
+require 'epithet/block58'
+require 'epithet/config'
 
 #
 # Epithet, a tool for external identifiers.
@@ -10,56 +14,67 @@ require 'openssl'
 # prefix (typically a model or table name), produces a replayable string parameter of
 # consistent length, with modest obfuscation and authentication properties.
 #
-# Pseudo-AEAD is via `AES-256-ECB(id(8B) + HMAC-SHA256(id)[0,7])` with the result
+# Pseudo-AEAD is via `AES-256-ECB(id(8B) + MSB_64(HMAC-SHA256(id)))` with the result
 # base58 encoded for transmission and the contextual prefix prepended.
 #
-# Encodings are canonical; a given configuration accepts exactly one string per id.
+# Encodings are canonical; a given configuration produces exactly one string per id.
 #
 # Subkeys for AES and HMAC are by default derived with HKDF using an internal key
 # generator that takes IKM from a passphrase via scrypt.  An alternative key generator
-# may be injected via Config objects. Subkeys are salted by prefix and an optional
-# additional salt, which may be useful for purpose separation or rotation.
+# may be injected via Config objects.  Subkeys are salted by prefix and an optional
+# context string, which may be useful for purpose separation or rotation, and each
+# subkey is bound to the configured name of the algorithm that consumes it.
 #
 # Example usage:
 #
 #     # in setup-environment.sh
-#     EPITHET_PASSPHRASE='example only'
+#     EPITHET_PASSPHRASE='example_only' ; export EPITHET_PASSPHRASE
 #
 #     # ... later, in Ruby ...
 #     Epithet.configure(passphrase: ENV.fetch('EPITHET_PASSPHRASE'))
 #     user_epithet = Epithet.new('user')
-#     user_epithet.encode(1) #=> "user_DAG6Joc5JmgygTBuEo8a9K"
+#     user_epithet.encode(1) #=> "user_NEwRoiarS9wdmiLmjEtti3"
 #
 class Epithet
+  # Raised by #decode when the input is not valid wire format.
+  FormatError = Class.new(ArgumentError)
+
+  # Raised if no defaults are configured.
+  ConfigurationError = Class.new(RuntimeError)
+
   # Create an encoder/decoder.
   #
   # Setup could be moderately expensive due to key derivation; you are recommended to cache
-  # and reuse instances with equal parameters (e.g. setup once per model)
+  # and reuse instances with equal parameters (e.g. setup the key generation once per runtime).
+  #
+  # * The stringified `prefix` is included in key derivation.  It may be nil or empty, in which
+  #   case the separator is ignored and a bare param will be produced.
   #
-  # * `prefix` is stringified, and may be nil, producing an empty prefix.
-  #   The prefix is included in the salt for key generation.
+  # * `config` is optional and intended for cases where you need finer control than global defaults.
   #
-  # * `config` is optional and intended for cases where you needed finer control than global defaults.
+  # Mixing incompatible character encodings across prefix/separator/payload may raise
+  # Encoding::CompatibilityError or Epithet::FormatError.  Don't expect UTF-16LE to work.
   #
   # The simplest typical invocation is `Epithet.new('prefix')`.
   #
   def initialize(prefix, config: Epithet.defaults)
-    prefix = String(prefix)
-    key_salt = [prefix.bytesize, prefix, config.salt.bytesize, config.salt].pack('Q>Z*Q>Z*')
-    @block58 = Block58.build(16, alphabet: config.alphabet)
-    @prefix_s = "#{prefix}#{config.separator}"
+    prefix = -String(prefix)
+    @prefix = prefix.empty? ? prefix : -(prefix + config.separator)
+    @wire_prefix = @prefix.b.freeze
+    key_salt = [prefix.bytesize, prefix, config.context.bytesize, config.context].pack('Q>Z*Q>Z*')
+    @codec = config.codec
 
     cipher_key_len = OpenSSL::Cipher.new(config.cipher).key_len
     digest_key_len = OpenSSL::Digest.new(config.digest).block_length
-    cipher_key = config.keygen.generate('epithet:ecb', key_salt, cipher_key_len)
-    digest_key = config.keygen.generate('epithet:mac', key_salt, digest_key_len)
+    cipher_key = config.keygen.generate("epithet:cipher:#{config.cipher}", key_salt, cipher_key_len)
+    digest_key = config.keygen.generate("epithet:digest:#{config.digest}", key_salt, digest_key_len)
 
     @encryptor = OpenSSL::Cipher.new(config.cipher).encrypt.tap { |c| c.key = cipher_key; c.padding = 0 }
     @decryptor = OpenSSL::Cipher.new(config.cipher).decrypt.tap { |c| c.key = cipher_key; c.padding = 0 }
     @hmac = OpenSSL::HMAC.new(digest_key, config.digest)
   end
 
-  # Encode a 64-bit unsigned Integer to a prefixed Base58 string.
+  # Encode a 64-bit unsigned integer to a prefixed base58 string.
   # Raises ArgumentError on invalid values.
   def encode(id)
     raise ArgumentError, 'not a 64-bit unsigned integer' unless Integer === id && id.bit_length <= 64 && id >= 0
@@ -71,21 +86,23 @@ class Epithet
     block = e.update([pt, m].pack('a8a8')) + e.final
     ct = block.unpack('Q>2').then { (_1 << 64) + _2 }
 
-    @prefix_s + @block58.i2s(ct)
+    @prefix + @codec.i2s(ct)
   end
 
-  # Decode a prefixed or raw Base58 string to an Integer. Raw inputs are
+  # Decode a prefixed or raw base58 string to an integer.  The input is
+  # stringified and read as bytes, whatever its encoding; raw inputs are
   # recognised by their exact payload length.
   #
-  # Returns the Integer on success, nil if authentication fails.
-  # Raises ArgumentError on invalid wire format (see Block58#valid?).
+  # Returns the integer on success, nil if authentication fails.
+  # Raises FormatError on invalid wire format (see Block58#valid?).
   def decode(s)
-    s = s.delete_prefix(@prefix_s) unless s.bytesize == @block58.size
-    raise ArgumentError, 'unexpected format' unless @block58.valid?(s)
+    s = String(s).b
+    s = s.delete_prefix(@wire_prefix) unless s.bytesize == @codec.size
+    raise FormatError, 'unexpected format' unless @codec.valid?(s)
 
     d = @decryptor.dup
     h = @hmac.dup
-    ct = @block58.s2i(s)
+    ct = @codec.s2i(s)
     block = d.update([ct >> 64, ct].pack('Q>2')) + d.final
     pt, m = block.unpack('a8a8')
     id = pt.unpack1('Q>')
@@ -110,31 +127,33 @@ class Epithet
     #       scrypt: { salt: "#{MyApp.name}/#{MyApp.env}" }
     #     )
     #
-    #     # Retaining already-configured passphrase but updating salt,
+    #     # Retaining already-configured passphrase but updating context,
     #     # and using a custom separator.
     #     Epithet.configure(
     #       keygen: Epithet.defaults.keygen,
-    #       salt: 'rotation-19',
+    #       context: 'rotation-19',
     #       separator: '-'
     #     )
     #
     # #### Options
     #
     # *   `:passphrase` - Install new key generator with scrypt-derived key material
-    # *   `:scrypt` - Params for scrypt, merged over `Keygen::DEFAULT_SCRYPT_PARAMS`
-    # *   `:keygen` - Install an existing key generator
+    # *   `:scrypt` - Override scrypt parameters (cost, salt, provider etc); see Epithet::Scrypt
+    # *   `:keygen` - Use an existing key generator
     # *   `:cipher` - Must be a 128-bit block cipher in ECB mode or equivalent; omit for standard `aes-256-ecb`
-    # *   `:digest` - Must be >= 64 bits; omit for standard `sha256`
-    # *   `:separator` - String inserted between the prefix and the generated param; omit for standard `_`.
-    #                    May be `nil`. Must not share bytes with the alphabet.
-    # *   `:alphabet` - Alphabet for the wire encoding; must be 58 strictly ascending bytes; omit for `Block58::Alphabet`.
-    # *   `:salt` - If supplied, stringified form is included in subkey derivation
+    # *   `:digest` - Must be >= 64 bits digest; omit for standard `sha256`
+    # *   `:separator` - String inserted between the prefix and the generated param.
+    #                    Omit for standard `_`.  May be `nil`.  Must not share bytes with the alphabet.
+    #                    Not emitted when prefix is `nil` or empty.
+    # *   `:alphabet` - Custom base58 alphabet for the wire encoding.  Must be strictly ascending bytes.
+    # *   `:context` - If supplied, string form is included in subkey derivation.
+    #                  Useful for purpose separation, or rotation epochs.
     #
     # At minimum, one of `passphrase:` or `keygen:` is required.
-    # Configuration via `passphrase` is recommended.
     #
     # If passing an existing key generator, the object must respond to `generate(info, salt, length)`
     # and return a byte string suitable for use with OpenSSL cryptographic primitives.
+    # Configuration sharing means an alternative keygen must support concurrent `generate` calls.
     #
     # See [`SECURITY.md`](SECURITY.md) for discussion of ciphers & digests.
     #
@@ -144,8 +163,8 @@ class Epithet
     #
     #     cfg = Epithet::Config.new(
     #       keygen: my_key_gen,
-    #       cipher: 'stronk-512-jcb',
-    #       digest: 'md7'
+    #       cipher: 'camellia-256-ecb',
+    #       digest: 'sha224'
     #     )
     #
     # and either install this as default with
@@ -157,212 +176,6 @@ class Epithet
     #     acct_epithet = Epithet.new('acct', config: cfg)
     #
     def configure(opts) = @defaults = Config === opts ? opts : Config.new(opts)
-    def defaults() = @defaults || raise('no Epithet defaults configured')
-  end
-
-  # Class for passing around preset configs. See Epithet::configure for options.
-  class Config
-    attr_reader :keygen, :salt, :separator, :alphabet, :cipher, :digest # :nodoc:
-
-    def initialize(opts = {})
-      opts = opts.dup
-      @separator = -String(opts.delete(:separator) { '_' })
-      @salt = -String(opts.delete(:salt))
-      @alphabet = -String(opts.delete(:alphabet) { Block58::Alphabet })
-      @cipher = -(opts.delete(:cipher) || 'aes-256-ecb')
-      @digest = -(opts.delete(:digest) || 'sha256')
-
-      cipher = OpenSSL::Cipher.new(@cipher)
-      raise ArgumentError, 'separator intersects alphabet' if @separator.bytes.intersect?(@alphabet.bytes)
-      raise ArgumentError, "#{@cipher} not a 128-bit block cipher" if cipher.block_size != 16
-      raise ArgumentError, "#{@cipher} requires an IV/nonce" if cipher.iv_len != 0
-      raise ArgumentError, "#{@digest} produces < 64-bit digest" if OpenSSL::Digest.new(@digest).digest_length < 8
-
-      @keygen = opts.delete(:keygen) || Keygen.new(
-        passphrase: opts.delete(:passphrase),
-        digest: @digest,
-        scrypt: opts.delete(:scrypt) || {})
-      raise ArgumentError, "unused option(s) #{opts.keys}" unless opts.empty?
-      freeze
-    end
-  end
-
-  # Key derivation helper
-  class Keygen
-    # Default parameters for scrypt.
-    #
-    # ```ruby
-    # DEFAULT_SCRYPT_PARAMS = {
-    #   salt: 'epithet-default',
-    #   N: 1 << 17,
-    #   r: 8,
-    #   p: 1,
-    #   length: 32
-    # }.freeze
-    # ```
-    DEFAULT_SCRYPT_PARAMS = {
-      salt: 'epithet-default',
-      N: 1 << 17,
-      r: 8,
-      p: 1,
-      length: 32
-    }.freeze
-
-    # Create a new key generator from either high-entropy key material, or a supplied passphrase.
-    # Supplied scrypt params are merged over DEFAULT_SCRYPT_PARAMS.
-    def initialize(ikm: nil, passphrase: nil, digest: 'sha256', scrypt: {})
-      if (passphrase.nil? && ikm.nil?) || (!passphrase.nil? && !ikm.nil?)
-        raise ArgumentError, 'keygen requires either ikm or passphrase'
-      end
-
-      @ikm = (ikm ? ikm.b : OpenSSL::KDF.scrypt(passphrase, **DEFAULT_SCRYPT_PARAMS, **scrypt)).freeze
-      @digest = -String(digest)
-      freeze
-    end
-
-    def inspect
-      "#<#{self.class}:#{'%#016x' % (object_id << 1)} digest=#{@digest}>"
-    end
-
-    # Derive a key via HKDF.
-    def generate(info, salt, length)
-      OpenSSL::KDF.hkdf(@ikm, hash: @digest, info: info, salt: salt, length: length)
-    end
-  end
-
-  # Fixed-length Base58 codec for a fixed-size block.
-  #
-  # Obtain codecs via Block58::build, which selects the fastest variant for
-  # the block size, an unrolled decoder for 16-byte blocks, or the generic
-  # chunked decoder otherwise.
-  class Block58
-    # `= '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'`
-    Alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
-
-    POW58 = Array.new(11) { 58**_1 }.freeze # :nodoc:
-
-    attr_reader :size
-
-    # Same as ::new but may select a tuned subclass for performance.
-    def self.build(block_size, ...) = (block_size == 16 ? Unrolled16 : self).new(block_size, ...)
-
-    # Create a codec for a block size in bytes.
-    #
-    # The alphabet must be 58 distinct bytes in ascending order, so that
-    # lexicographic order agrees with numeric order.
-    def initialize(block_size, alphabet: Alphabet)
-      raise ArgumentError, 'invalid block size' unless Integer === block_size && block_size > 0
-      @alphabet = alphabet.b.freeze
-      raise ArgumentError, 'invalid alphabet length' unless @alphabet.bytesize == 58
-      raise ArgumentError, 'alphabet not strictly ascending' unless @alphabet.bytes.each_cons(2).all? { _2 > _1 }
-      @size = ((block_size * 8) / Math.log2(58)).ceil(0)
-      @charsel = @alphabet.gsub(/[\^\-\\]/, '\\\\\&').freeze
-      @blank = @alphabet[0] * @size
-      @lut = @alphabet.each_byte.with_index.with_object("\0" * 256) { |(val, idx), lut| lut.setbyte(val, idx) }.freeze
-      @max = i2s((1 << (block_size * 8)) - 1).freeze
-    end
-
-    def inspect
-      "#<#{self.class}:#{'%#016x' % (object_id << 1)} size=#{@size} alphabet=#{@alphabet}>"
-    end
-
-    # Return true if the string is in range with the right size and alphabet.
-    def valid?(s)
-      String === s && s.bytesize == @size && s <= @max && s.count(@charsel) == @size
-    end
-
-    # Encode a non-negative Integer to fixed-length Base58.
-    # Truncates if int >= 58**size.
-    def i2s(int)
-      # Using divmod+setbyte is faster than Integer#digits under YJIT,
-      # and about equal in plain MRI.
-      alphabet = @alphabet
-      out = @blank.dup
-      idx = @size - 1
-      n = int
-      while idx >= 0 && n > 0
-        n, rem = n.divmod(58)
-        out.setbyte(idx, alphabet.getbyte(rem))
-        idx -= 1
-      end
-      out
-    end
-
-    # Decode a fixed-length Base58 string to an Integer.
-    # Assumes the input passes `#valid?`. Wraps at 58**size on the i2s round trip.
-    def s2i(str)
-      # Chunking intermediate results into 64-bit integers is ~5x faster
-      # under YJIT than Horner's scheme
-      #
-      #   str.each_byte.inject(0) { _1 * 58 + @lut[_2] }
-      #
-      # at computing the inner product.
-      lut = @lut
-      size = @size
-      pow = POW58
-      acc = 0
-      pos = 0
-      while pos < size
-        n = size - pos
-        n = 10 if n > 10
-        chunk = 0
-        i = 0
-        while i < n
-          chunk = (chunk * 58) + lut.getbyte(str.getbyte(pos))
-          pos += 1
-          i += 1
-        end
-        acc = (acc * pow[n]) + chunk
-      end
-      acc
-    end
-
-    # Specialised decoder for 16-byte blocks (22 digits) with a fully unrolled inner product.
-    class Unrolled16 < Block58
-      def initialize(...)
-        super
-        raise ArgumentError, 'unrolled codec requires a 16-byte block' unless @size == 22
-      end
-
-      # Decode a fixed-length Base58 string to an Integer.
-      # Assumes the input passes `#valid?`.
-      def s2i(str)
-        # rubocop:disable Style/NumericLiterals, Lint/AmbiguousOperatorPrecedence, Layout
-        #
-        # By unrolling the chunks against literal coefficients, this is ~1.6x
-        # faster under YJIT than the generic chunked Block58#s2i, and ~8x
-        # faster than Horner's scheme.
-        lut = @lut
-
-        acc0 = lut.getbyte(str.getbyte(0)) * 7427658739644928 +
-               lut.getbyte(str.getbyte(1)) * 128063081718016 +
-               lut.getbyte(str.getbyte(2)) * 2207984167552 +
-               lut.getbyte(str.getbyte(3)) * 38068692544 +
-               lut.getbyte(str.getbyte(4)) * 656356768 +
-               lut.getbyte(str.getbyte(5)) * 11316496 +
-               lut.getbyte(str.getbyte(6)) * 195112 +
-               lut.getbyte(str.getbyte(7)) * 3364 +
-               lut.getbyte(str.getbyte(8)) * 58 +
-               lut.getbyte(str.getbyte(9))
-
-        acc1 = lut.getbyte(str.getbyte(10)) * 7427658739644928 +
-               lut.getbyte(str.getbyte(11)) * 128063081718016 +
-               lut.getbyte(str.getbyte(12)) * 2207984167552 +
-               lut.getbyte(str.getbyte(13)) * 38068692544 +
-               lut.getbyte(str.getbyte(14)) * 656356768 +
-               lut.getbyte(str.getbyte(15)) * 11316496 +
-               lut.getbyte(str.getbyte(16)) * 195112 +
-               lut.getbyte(str.getbyte(17)) * 3364 +
-               lut.getbyte(str.getbyte(18)) * 58 +
-               lut.getbyte(str.getbyte(19))
-
-                                 lut.getbyte(str.getbyte(21)) +
-                            58 * lut.getbyte(str.getbyte(20)) +
-                          3364 * acc1 +
-        1449225352009601191936 * acc0
-
-        # rubocop:enable Style/NumericLiterals, Lint/AmbiguousOperatorPrecedence, Layout
-      end
-    end
+    def defaults() = @defaults || raise(ConfigurationError, 'no Epithet defaults configured')
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: epithet
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Josh Goodall
@@ -37,20 +37,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: rdoc
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '7'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '7'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -65,7 +51,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Epithet generates stable, prefixed, Base58 identifiers from 64-bit integers
+description: Epithet generates stable, prefixed, base58 identifiers from 64-bit integers
   using AES and HMAC.
 email:
 - inopinatus@hey.com
@@ -79,6 +65,10 @@ files:
 - SECURITY.md
 - examples/basic.rb
 - lib/epithet.rb
+- lib/epithet/block58.rb
+- lib/epithet/config.rb
+- lib/epithet/keygen.rb
+- lib/epithet/scrypt.rb
 - lib/epithet/version.rb
 homepage: https://github.com/inopinatus/epithet
 licenses:
@@ -96,14 +86,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.3'
+      version: '3.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.16
 specification_version: 4
-summary: External base58 identifiers with reversible, authenticated obfuscation.
+summary: External base58 identifiers with reversible, tamper-evident obfuscation.
 test_files: []