obfuskey 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9bc5f45d8820d179791885eba40fc30d7cf1145e1f62194f3354fc9bac512f90
+  data.tar.gz: ea7b2365b2c97baec0f8368a087ea461bfd47dd0e6250d94e1278c70a93b7903
+SHA512:
+  metadata.gz: 174c3b7d704769bea2c6d10ee3f25c557c395932bcc3d66f5d6a0a3c0b139b429c81856810d11ce29aa17be6f3f361b6a2258fec0394b9123e90a0796f813bb4
+  data.tar.gz: 221acb4d5cf61847afb3874ab4dd81a743c08f4e133fa48b6264d4bcbdca5bbd08d64159fa7f1f8e05739c3934f809b32219630c91632a076cdb8d194592e517

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Nathan Lucas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,59 @@
+# obfuskey-rb
+
+A Ruby port of [Obfuskey](https://github.com/bnlucas/obfuskey). Generates deterministic, reversible, fixed-length keys from integer values using a custom alphabet. Cross-compatible with the Python, JavaScript, and Rust implementations — the same `(alphabet, key_length, value)` triple produces the same key in every language.
+
+## Install
+
+```ruby
+# Gemfile
+gem "obfuskey"
+```
+
+## Usage
+
+```ruby
+require "obfuskey"
+
+obf = Obfuskey.new(Obfuskey::Alphabets::BASE62)
+key = obf.get_key(12345)       # => "d2Aasl"
+obf.get_value(key)             # => 12345
+```
+
+### Custom key length or multiplier
+
+```ruby
+Obfuskey.new(Obfuskey::Alphabets::BASE62, key_length: 8)
+Obfuskey.new(Obfuskey::Alphabets::BASE62, multiplier: 123)   # odd integer
+```
+
+### Obfusbit (bit-packed structured keys)
+
+```ruby
+schema = [
+  { name: "id",   bits: 10 },
+  { name: "type", bits: 2  },
+  { name: "flag", bits: 1  }
+]
+
+key_maker = Obfuskey.new(Obfuskey::Alphabets::BASE62, key_length: 3)
+ob = Obfusbit.new(schema, obfuskey: key_maker)
+
+encoded = ob.pack({ "id" => 100, "type" => 2, "flag" => 1 }, obfuscate: true)
+ob.unpack(encoded, obfuscated: true)
+# => { "id" => 100, "type" => 2, "flag" => 1 }
+```
+
+## Alphabets
+
+`Obfuskey::Alphabets` provides `BASE16`, `BASE32`, `BASE36`, `BASE52`, `BASE56`, `BASE58`, `BASE62`, `BASE64`, `BASE94`, `CROCKFORD_BASE32`, `ZBASE32`, `BASE64_URL_SAFE`.
+
+## Tests
+
+```
+bundle install
+bundle exec rspec
+```
+
+## License
+
+MIT

data/lib/obfuskey/alphabets.rb

@@ -0,0 +1,25 @@
+class Obfuskey
+  module Alphabets
+    BASE16 = "0123456789ABCDEF".freeze
+    BASE32 = "234567ABCDEFGHIJKLMNOPQRSTUVWXYZ".freeze
+    BASE36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ".freeze
+    BASE52 = "0123456789BCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz".freeze
+    BASE56 = "23456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnpqrstuvwxyz".freeze
+    BASE58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz".freeze
+    BASE62 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".freeze
+    BASE64 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/".freeze
+    BASE94 = (
+      '!"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ' \
+      '[\]^_`abcdefghijklmnopqrstuvwxyz{|}~'
+    ).freeze
+
+    CROCKFORD_BASE32 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ".freeze
+    ZBASE32 = "ybndrfg8ejkmcpqxot1uwisza345h769".freeze
+    BASE64_URL_SAFE = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_".freeze
+
+    ALL = [
+      BASE16, BASE32, BASE36, BASE52, BASE56, BASE58,
+      BASE62, BASE64, BASE94, CROCKFORD_BASE32, ZBASE32, BASE64_URL_SAFE
+    ].freeze
+  end
+end

data/lib/obfuskey/errors.rb

@@ -0,0 +1,11 @@
+class Obfuskey
+  class Error < StandardError; end
+  class BitOverflowError < Error; end
+  class DuplicateError < Error; end
+  class KeyLengthError < Error; end
+  class MaximumValueError < Error; end
+  class MultiplierError < Error; end
+  class NegativeValueError < Error; end
+  class SchemaValidationError < Error; end
+  class UnknownKeyError < Error; end
+end

data/lib/obfuskey/math.rb

@@ -0,0 +1,91 @@
+class Obfuskey
+  module Math
+    module_function
+
+    def factor(n)
+      s = 0
+      d = n - 1
+      while d.even?
+        s += 1
+        d /= 2
+      end
+      [s, d]
+    end
+
+    def trial_division(n)
+      return false if n <= 1
+      return true if n == 2
+      return false if n.even?
+
+      i = 3
+      limit = Integer.sqrt(n)
+      while i <= limit
+        return false if (n % i).zero?
+        i += 2
+      end
+      true
+    end
+
+    def strong_pseudoprime(n, base = 2)
+      return false if n.even?
+      return false if n == 1
+
+      s, d = factor(n)
+      x = base.pow(d, n)
+      return true if x == 1 || x == n - 1
+
+      (s - 1).times do
+        x = x.pow(2, n)
+        return true if x == n - 1
+        return false if x == 1
+      end
+
+      false
+    end
+
+    def small_strong_pseudoprime(n)
+      [2, 13, 23, 1_662_803].all? { |base| strong_pseudoprime(n, base) }
+    end
+
+    def prime?(n)
+      return true if n == 2
+      return false if n < 2 || n.even?
+      return [3, 5, 7, 11, 13, 17].include?(n) if n.gcd(510_510) > 1
+      return trial_division(n) if n < 2_000_000
+
+      small_strong_pseudoprime(n)
+    end
+
+    def next_prime(n)
+      if n.bit_length > 512
+        raise MaximumValueError,
+          "For integers larger than 512-bit, a more advanced prime generator is required."
+      end
+
+      return 2 if n < 2
+      return [3, 5, 5][n - 2] if n < 5
+
+      gap = [
+        1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3,
+        2, 1, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2
+      ]
+
+      n += 1 + (n & 1)
+      n += gap[n % 30] if (n % 3).zero? || (n % 5).zero?
+      n += gap[n % 30] until prime?(n)
+      n
+    end
+
+    def mod_inv(base, mod)
+      g, x, _ = extended_gcd(base % mod, mod)
+      raise ArgumentError, "base and mod are not coprime" unless g == 1
+      x % mod
+    end
+
+    def extended_gcd(a, b)
+      return [a, 1, 0] if b.zero?
+      g, x1, y1 = extended_gcd(b, a % b)
+      [g, y1, x1 - (a / b) * y1]
+    end
+  end
+end

data/lib/obfuskey/obfusbit.rb

@@ -0,0 +1,130 @@
+class Obfusbit
+  Error = Obfuskey::Error
+  MaximumValueError = Obfuskey::MaximumValueError
+  SchemaValidationError = Obfuskey::SchemaValidationError
+  BitOverflowError = Obfuskey::BitOverflowError
+
+  attr_reader :obfuskey
+
+  def initialize(schema, obfuskey: nil)
+    @schema = schema.is_a?(Obfuskey::ObfusbitSchema) ? schema : Obfuskey::ObfusbitSchema.new(schema)
+    @obfuskey = obfuskey
+    @total_bits = @schema.total_bits
+    @max_bits = @schema.max_bits
+
+    if @obfuskey && @max_bits > @obfuskey.maximum_value
+      raise MaximumValueError,
+        "The provided schema requires a maximum packed integer value of #{@max_bits} " \
+        "(which needs #{@total_bits} bits to represent), but the provided Obfuskey instance " \
+        "can only handle up to a maximum value of #{@obfuskey.maximum_value} " \
+        "(which covers #{@obfuskey.maximum_value.bit_length} bits)."
+    end
+  end
+
+  def total_bits
+    @total_bits
+  end
+
+  def max_bits
+    @max_bits
+  end
+
+  def schema
+    @schema.definition
+  end
+
+  def pack(values, obfuscate: false)
+    @schema.validate_values!(values)
+
+    normalized = values.each_with_object({}) { |(k, v), h| h[k.to_s] = v }
+    packed_int = 0
+
+    @schema.field_info.each do |name, info|
+      packed_int |= normalized[name] << info[:shift]
+    end
+
+    if obfuscate
+      raise ArgumentError, "An Obfuskey instance was not provided during initialization." unless @obfuskey
+      return @obfuskey.get_key(packed_int)
+    end
+
+    packed_int
+  end
+
+  def unpack(packed_data, obfuscated: false)
+    if obfuscated
+      raise ArgumentError, "An Obfuskey instance was not provided during initialization." unless @obfuskey
+      raise TypeError, "packed_data must be a String when obfuscated is true." unless packed_data.is_a?(String)
+      packed_int = @obfuskey.get_value(packed_data)
+    else
+      raise TypeError, "packed_data must be an Integer when obfuscated is false." unless packed_data.is_a?(Integer)
+      packed_int = packed_data
+    end
+
+    result = {}
+    @schema.field_info.each do |name, info|
+      mask = (1 << info[:bits]) - 1
+      result[name] = (packed_int >> info[:shift]) & mask
+    end
+    result
+  end
+
+  def pack_bytes(values, byteorder: :big)
+    packed_int = pack(values, obfuscate: false)
+    int_to_bytes(packed_int, byteorder)
+  end
+
+  def unpack_bytes(byte_data, byteorder: :big)
+    packed_int = bytes_to_int(byte_data, byteorder)
+    unpack(packed_int, obfuscated: false)
+  end
+
+  def to_s
+    key_repr = @obfuskey ? "obfuskey=#{@obfuskey}" : "no obfuskey"
+    "Obfusbit(schema=#{@schema}, #{key_repr})"
+  end
+  alias inspect to_s
+
+  private
+
+  def required_byte_length
+    (@total_bits + 7) / 8
+  end
+
+  def int_to_bytes(packed_int, byteorder)
+    unless packed_int >= 0 && packed_int <= @max_bits
+      raise ArgumentError,
+        "Packed integer #{packed_int} is out of range (0 to #{@max_bits}) " \
+        "for the schema's total bit capacity."
+    end
+
+    byte_length = required_byte_length
+    bytes = Array.new(byte_length)
+    value = packed_int
+    (byte_length - 1).downto(0) do |i|
+      bytes[i] = value & 0xff
+      value >>= 8
+    end
+
+    bytes = bytes.reverse if byteorder.to_sym == :little
+    bytes.pack("C*")
+  end
+
+  def bytes_to_int(byte_data, byteorder)
+    raise TypeError, "byte_data must be a String." unless byte_data.is_a?(String)
+
+    expected = required_byte_length
+    if byte_data.bytesize != expected
+      raise ArgumentError,
+        "Byte data length (#{byte_data.bytesize}) does not match expected length " \
+        "for this schema (#{expected} bytes based on #{@total_bits} bits)."
+    end
+
+    bytes = byte_data.bytes
+    bytes = bytes.reverse if byteorder.to_sym == :little
+
+    result = 0
+    bytes.each { |b| result = (result << 8) | b }
+    result
+  end
+end

data/lib/obfuskey/obfusbit_schema.rb

@@ -0,0 +1,112 @@
+class Obfuskey
+  class ObfusbitSchema
+    attr_reader :definition, :total_bits, :max_bits, :field_names
+
+    def initialize(raw_schema)
+      validate_schema!(raw_schema)
+
+      @definition = raw_schema
+      @total_bits = raw_schema.sum { |item| item[:bits] || item["bits"] }
+      @max_bits = (1 << @total_bits) - 1
+      @field_info = calculate_field_info(raw_schema)
+      @field_names = raw_schema.map { |item| (item[:name] || item["name"]).to_s }.to_set
+    end
+
+    def field_info
+      # Return a deep copy so callers can't mutate internal state.
+      @field_info.each_with_object({}) { |(k, v), h| h[k] = v.dup }
+    end
+
+    def get_field_info(name)
+      info = @field_info[name.to_s]
+      raise ArgumentError, "Field '#{name}' not found in schema." unless info
+      info
+    end
+
+    def validate_values!(values)
+      input_names = values.keys.map(&:to_s).to_set
+
+      missing = @field_names - input_names
+      unless missing.empty?
+        raise ArgumentError,
+          "Required values for the following fields are missing: #{missing.sort.join(', ')}."
+      end
+
+      extra = input_names - @field_names
+      unless extra.empty?
+        raise ArgumentError,
+          "Unexpected fields provided in input values: #{extra.sort.join(', ')}."
+      end
+
+      values.each do |name, value|
+        info = get_field_info(name)
+        bits = info[:bits]
+        unless value.is_a?(Integer) && value >= 0 && value < (1 << bits)
+          raise BitOverflowError,
+            "Value '#{name}' (#{value}) exceeds its allocated #{bits} bits " \
+            "(maximum allowed: #{(1 << bits) - 1})."
+        end
+      end
+    end
+
+    def to_s
+      "ObfusbitSchema(total_bits=#{@total_bits}, fields=#{@definition.length})"
+    end
+    alias inspect to_s
+
+    private
+
+    def calculate_field_info(raw_schema)
+      info = {}
+      shift = 0
+      raw_schema.reverse_each do |item|
+        name = (item[:name] || item["name"]).to_s
+        bits = item[:bits] || item["bits"]
+        info[name] = { bits: bits, shift: shift }
+        shift += bits
+      end
+      info
+    end
+
+    def validate_schema!(schema)
+      raise SchemaValidationError, "Schema must be a list of dictionaries." unless schema.is_a?(Array)
+      raise SchemaValidationError, "Schema cannot be empty." if schema.empty?
+
+      seen = Set.new
+      schema.each_with_index do |item, i|
+        unless item.is_a?(Hash)
+          raise SchemaValidationError,
+            "Schema item at index #{i} must be a hash, got #{item.class.name}."
+        end
+
+        name = item[:name] || item["name"]
+        bits = item[:bits] || item["bits"]
+
+        raise SchemaValidationError, "Schema item at index #{i} is missing the 'name' key." if name.nil?
+        raise SchemaValidationError, "Schema item at index #{i} is missing the 'bits' key." if bits.nil?
+
+        unless name.is_a?(String) || name.is_a?(Symbol)
+          raise SchemaValidationError,
+            "Schema item (index #{i}): 'name' must be a string, got #{name.class.name}."
+        end
+
+        unless bits.is_a?(Integer)
+          raise SchemaValidationError,
+            "Schema item '#{name}' (index #{i}): 'bits' must be an integer, got #{bits.class.name}."
+        end
+
+        if bits <= 0
+          raise SchemaValidationError,
+            "Schema item '#{name}' (index #{i}): 'bits' must be a positive integer, got #{bits}."
+        end
+
+        name_str = name.to_s
+        if seen.include?(name_str)
+          raise SchemaValidationError,
+            "Schema contains duplicate name: '#{name_str}'. Names must be unique."
+        end
+        seen << name_str
+      end
+    end
+  end
+end

data/lib/obfuskey/obfuskey.rb

@@ -0,0 +1,85 @@
+class Obfuskey
+  KEY_LENGTH = 6
+
+  attr_reader :alphabet, :key_length, :maximum_value
+
+  def initialize(alphabet, key_length: KEY_LENGTH, multiplier: nil)
+    if alphabet.chars.uniq.length != alphabet.length
+      raise DuplicateError, "The alphabet contains duplicate characters."
+    end
+
+    if !multiplier.nil? && (!multiplier.is_a?(Integer) || multiplier.even?)
+      raise MultiplierError, "The multiplier must be an odd integer."
+    end
+
+    @alphabet = alphabet
+    @key_length = key_length
+    @maximum_value = alphabet.length**key_length - 1
+    @multiplier = multiplier
+    @prime_multiplier = PRIME_MULTIPLIER
+  end
+
+  def multiplier
+    @multiplier ||= generate_multiplier
+  end
+
+  def set_prime_multiplier(prime_multiplier)
+    @prime_multiplier = prime_multiplier
+    @multiplier = nil
+  end
+
+  def get_key(value)
+    raise NegativeValueError, "The value must be greater than or equal to zero." if value < 0
+
+    if value > @maximum_value
+      raise MaximumValueError, "The maximum value possible is #{@maximum_value}"
+    end
+
+    return @alphabet[0] * @key_length if value.zero?
+
+    encoded = Utils.encode((value * multiplier) % (@maximum_value + 1), @alphabet)
+    encoded.rjust(@key_length, @alphabet[0])
+  end
+
+  def get_value(key)
+    unless key.chars.all? { |c| @alphabet.include?(c) }
+      raise UnknownKeyError,
+        "The key contains characters not found in the current alphabet."
+    end
+
+    if key.length != @key_length
+      raise KeyLengthError, "The key length does not match the set length."
+    end
+
+    return 0 if key == @alphabet[0] * @key_length
+
+    decoded = Utils.decode(key, @alphabet)
+    max_p1 = @maximum_value + 1
+    decoded * Math.mod_inv(multiplier, max_p1) % max_p1
+  end
+
+  def to_s
+    multiplier_info =
+      if @multiplier.nil?
+        ", multiplier=auto (prime_mult=#{@prime_multiplier})"
+      else
+        ", multiplier=#{@multiplier}"
+      end
+
+    display_alphabet =
+      if @alphabet.length > 20
+        "'#{@alphabet[0, 10]}...#{@alphabet[-5, 5]}'"
+      else
+        "'#{@alphabet}'"
+      end
+
+    "Obfuskey(alphabet=#{display_alphabet}, key_length=#{@key_length}#{multiplier_info})"
+  end
+  alias inspect to_s
+
+  private
+
+  def generate_multiplier
+    Utils.generate_prime(@alphabet, @key_length, @prime_multiplier)
+  end
+end

data/lib/obfuskey/utils.rb

@@ -0,0 +1,46 @@
+class Obfuskey
+  PRIME_MULTIPLIER = 1.618033988749894848
+
+  module Utils
+    module_function
+
+    def decode(value, alphabet)
+      chars = value.chars
+      unless chars.all? { |c| alphabet.include?(c) }
+        raise UnknownKeyError,
+          "The value contains characters not found in the current alphabet."
+      end
+
+      return alphabet.index(value) if chars.length == 1
+
+      base = alphabet.length
+      result = 0
+      chars.each do |c|
+        result = result * base + alphabet.index(c)
+      end
+      result
+    end
+
+    def encode(value, alphabet)
+      raise NegativeValueError, "The value must be greater than or equal to zero." if value < 0
+
+      return alphabet[value] if value < alphabet.length
+
+      base = alphabet.length
+      key = +""
+      while value > 0
+        value, i = value.divmod(base)
+        key << alphabet[i]
+      end
+      key.reverse
+    end
+
+    def generate_prime(alphabet, key_length, prime_multiplier = PRIME_MULTIPLIER)
+      # Mirror Python's Decimal(float) conversion: Rational(float) preserves
+      # the exact binary representation of a Float, matching Python's behavior.
+      factor = prime_multiplier.is_a?(Float) ? Rational(prime_multiplier) : prime_multiplier
+      target = ((alphabet.length**key_length - 1) * factor).to_i
+      Math.next_prime(target)
+    end
+  end
+end

data/lib/obfuskey/version.rb

@@ -0,0 +1,3 @@
+class Obfuskey
+  VERSION = "0.1.0".freeze
+end

data/lib/obfuskey.rb

@@ -0,0 +1,10 @@
+require "set"
+
+require "obfuskey/version"
+require "obfuskey/errors"
+require "obfuskey/alphabets"
+require "obfuskey/math"
+require "obfuskey/utils"
+require "obfuskey/obfuskey"
+require "obfuskey/obfusbit_schema"
+require "obfuskey/obfusbit"

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: obfuskey
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nathan Lucas
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: A Ruby port of obfuskey that produces deterministic, reversible keys
+  from integers using a custom alphabet. Cross-compatible with the Python, JavaScript,
+  and Rust implementations.
+email:
+- nathan@bnlucas.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/obfuskey.rb
+- lib/obfuskey/alphabets.rb
+- lib/obfuskey/errors.rb
+- lib/obfuskey/math.rb
+- lib/obfuskey/obfusbit.rb
+- lib/obfuskey/obfusbit_schema.rb
+- lib/obfuskey/obfuskey.rb
+- lib/obfuskey/utils.rb
+- lib/obfuskey/version.rb
+homepage: https://github.com/bnlucas/obfuskey-rb
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/bnlucas/obfuskey-rb
+  source_code_uri: https://github.com/bnlucas/obfuskey-rb
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Generate obfuscated, fixed-length keys for integer values.
+test_files: []