wots 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d6efca98c49499aae50fd5225762614026111f16cfc4ccee573e6ea6857e0664
+  data.tar.gz: 236faef3ed700463ea083a7cae7de8d6365663e5ad1e65c9819dab21e92fb6d3
+SHA512:
+  metadata.gz: b8eefc4c86bf05cfa7820e291bcbacf3d1fba792d91a7392f086147979468e8fe8caa62de59c7f47c00bc65145ab9d82f91cbba35215f295ddb85484dea6d477
+  data.tar.gz: 0a3a1affaa6a0d9e9298927cfd16e12a3e84aaa4a8b558f4b739002e2005a4d07f0747156c2716c12e879d5770b3c7aa06a852a47f148b9b3ebeb32f7026d27a

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.ruby-gemset

@@ -0,0 +1 @@
+wots

data/.ruby-version

@@ -0,0 +1 @@
+ruby-3.4.3

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 azuchi
+
+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,85 @@
+# WOTS+
+
+A Ruby implementation of the Winternitz One-Time Signature Plus (WOTS+) scheme as described in [RFC 8391](https://datatracker.ietf.org/doc/html/rfc8391).
+
+WOTS+ is a post-quantum cryptographic signature scheme that provides security against quantum computer attacks.
+
+## Features
+
+- Complete implementation of WOTS+ as specified in RFC 8391
+- Support for multiple hash functions:
+  - `WOTSP-SHA2_256` (SHA-256)
+  - `WOTSP-SHA2_512` (SHA-512)
+  - `WOTSP-SHAKE_256` (SHAKE-256)
+- Support for Winternitz parameters w=4 and w=16
+- Key generation from seed
+- Digital signature generation and verification
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'wots'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install wots
+
+## Usage
+
+### Basic Example
+
+```ruby
+require 'wots'
+
+# Use predefined parameters
+param = WOTS::Param::SHA256
+
+# Generate private key from seed
+seed = "693141c7ee701d13e1a7c733e0aa8326c19961429bfb54083f2f65b30c32e20b"
+private_key = WOTS::PrivateKey.from_seed(param, seed)
+
+# Generate public key
+pub_seed = "46ece585b4c0bfa1186209270e22fa07c4716461b5a026c268e594fb94404f3a"
+public_key = WOTS::PublicKey.from_private_key(private_key, pub_seed)
+
+# Sign a message
+message = "f16c96e88fb99a8287a43121962e89ed521699fa3e126c67eaaa168066354477"
+signature = private_key.sign(pub_seed, message)
+
+# Verify signature by reconstructing public key
+recovered_pk = WOTS::PublicKey.from_signature(signature, pub_seed, message)
+valid = (recovered_pk == public_key)
+puts "Signature valid: #{valid}"
+```
+
+### Available Parameter Sets
+
+```ruby
+# SHA-256 based (n=32 bytes, w=16)
+param = WOTS::Param::SHA256
+
+# SHA-512 based (n=64 bytes, w=16)
+param = WOTS::Param::SHA512
+
+# SHAKE-256 based (n=32 bytes, w=16)
+param = WOTS::Param::SHAKE256
+```
+
+## Security Considerations
+
+**⚠️ IMPORTANT: This is a cryptograFixphic library implementation. While it follows RFC 8391 specifications,
+it has not undergone formal security audits. Use at your own risk in production environments.**
+
+WOTS+ is a **one-time signature scheme**. Each private key should only be used to sign **one message**.
+Reusing a private key to sign multiple messages can leak information about the private key and compromise security.
+
+## Specifications
+
+This implementation follows [RFC 8391 - XMSS: eXtended Merkle Signature Scheme](https://datatracker.ietf.org/doc/html/rfc8391), Section 3 (WOTS+).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/wots/address.rb

@@ -0,0 +1,27 @@
+module WOTS
+  class Address
+    attr_accessor :layer_addr
+    attr_accessor :tree_addr
+    attr_accessor :ots_addr
+    attr_accessor :chain_addr
+    attr_accessor :hash_addr
+    attr_accessor :key_and_mask # 0: key generation, 1: bitmask generation
+
+    def initialize(layer_addr: 0, tree_addr: 0, ots_addr: 0, chain_addr: 0, hash_addr: 0, key_and_mask: 0)
+      @layer_addr = layer_addr
+      @tree_addr = tree_addr
+      @ots_addr = ots_addr
+      @chain_addr = chain_addr
+      @hash_addr = hash_addr
+      @key_and_mask = key_and_mask
+    end
+
+    def type
+      0
+    end
+
+    def to_payload
+      [layer_addr, tree_addr, type, ots_addr, chain_addr, hash_addr, key_and_mask].pack('NQ>NNNNN')
+    end
+  end
+end

data/lib/wots/param/sha256.rb

@@ -0,0 +1,9 @@
+module WOTS
+  class Param
+    SHA256 = new(
+      name: 'WOTSP-SHA2_256',
+      n: 32,
+      w: 16
+    )
+  end
+end

data/lib/wots/param/sha512.rb

@@ -0,0 +1,9 @@
+module WOTS
+  class Param
+    SHA512 = new(
+      name: 'WOTSP-SHA2_512',
+      n: 64,
+      w: 16
+    )
+  end
+end

data/lib/wots/param/shake256.rb

@@ -0,0 +1,9 @@
+module WOTS
+  class Param
+    SHAKE256 = new(
+      name: 'WOTSP-SHAKE_256',
+      n: 32,
+      w: 16
+    )
+  end
+end

data/lib/wots/param.rb

@@ -0,0 +1,177 @@
+require 'openssl'
+
+module WOTS
+  # WOTS+ parameters defined in rfc8391.
+  # https://datatracker.ietf.org/doc/html/rfc8391
+  class Param
+    include Util
+
+    autoload :SHA256, 'wots/param/sha256'
+    autoload :SHA512, 'wots/param/sha512'
+    autoload :SHAKE256, 'wots/param/shake256'
+
+    attr_reader :name
+    attr_reader :n
+    attr_reader :w
+
+    # @param [Hash] opts
+    # @option opts [Integer] :n the message length as well as the length of a private key,
+    # public key, or signature element in bytes.
+    # @option opts [Integer] :w the Winternitz parameter; it is a member of the set {4, 16}.
+    # @option opts [Integer] :len the number of n-byte string elements in a WOTS+ private key, public key, and signature.
+    def initialize(opts)
+      raise ArgumentError, 'name must be string.' unless opts[:name].is_a?(String)
+      raise ArgumentError, 'n must be integer.' unless opts[:n].is_a?(Integer)
+      raise ArgumentError, 'w must be integer.' unless opts[:w].is_a?(Integer)
+
+      @name = opts[:name]
+      @n = opts[:n]
+      @w = opts[:w]
+    end
+
+    def len1
+      @len1 ||= (8.0 * n / Math.log2(w)).ceil
+    end
+
+    def len2
+      @len2 ||= (Math.log2(len1 * (w - 1)) / Math.log2(w)).floor + 1
+    end
+
+    def len
+      @len ||= len1 + len2
+    end
+
+    def f(k, m)
+      keyed_hash(0, k, m)
+    end
+
+    def h(k, m)
+      keyed_hash(1, k, m)
+    end
+
+    def h_msg(k, m)
+      keyed_hash(2, k, m)
+    end
+
+    # PRF function.
+    # @param [String] k key
+    # @param [String] m message
+    # @return [String] Hex string.
+    def prf(k, m)
+      keyed_hash(3, k, m)
+    end
+
+    # Convert data as base w representation.
+    # @param [String] data The data to be converted.
+    # @param [Integer] out_len Output length.
+    # @return [Array] An array of integer.
+    def base_w(data, out_len)
+      x = hex_to_bin(data)
+
+      basew = []
+      in_idx = 0
+      total = 0
+      bits = 0
+      lg_w = Math.log2(w).to_i
+
+      out_len.times do
+        if bits == 0
+          break if in_idx >= x.bytesize
+          total = x.getbyte(in_idx)
+          in_idx += 1
+          bits += 8
+        end
+
+        bits -= lg_w
+        basew << ((total >> bits) & (w - 1))
+      end
+
+      basew
+    end
+
+    # Compute checksum for +base_w+.
+    # @param [Array] base_w
+    # @return [String] Checksum binary string.
+    def compute_checksum(base_w)
+      c_sum = 0
+      len1.times do |i|
+        c_sum = (c_sum + w - 1 - base_w[i])
+      end
+      c_sum = (c_sum << (8 - ((len2 * Math.log2(w).to_i) % 8)))
+      len_2_bytes = ((len2 * Math.log2(w).to_i) / 8.0).ceil
+      to_byte(c_sum, len_2_bytes)
+    end
+
+    # WOTS+ Chaining Function.
+    # @see https://datatracker.ietf.org/doc/html/rfc8391#autoid-16
+    # @param [String] x Input string.
+    # @param [Integer] start_idx Start index.
+    # @param [Integer] steps Number of steps.
+    # @param [String] seed Seed.
+    # @param [WOTS::Address] addr Address.
+    # @return [String] Result.
+    def chain(x, start_idx, steps, seed, addr)
+      return x if steps == 0
+      raise "Invalid range" if (start_idx + steps) > (w - 1)
+
+      result = x.dup
+
+      steps.times do |i|
+        addr.hash_addr = (start_idx + i)
+
+        addr.key_and_mask = 0
+        key = prf(seed, addr.to_payload)
+
+        addr.key_and_mask = 1
+        mask = prf(seed, addr.to_payload)
+
+        masked = xor_bytes(result, mask)
+        result = f(key, masked)
+      end
+
+      result
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Param)
+      name == other.name && n == other.n && w == other.w
+    end
+
+    # Convert +value+ to +length+ size binary string.
+    # @param [Integer] value
+    # @param [Integer] length
+    # @return [String]
+    def to_byte(value, length)
+      bytes = []
+
+      length.times do
+        bytes.unshift(value & 0xFF)
+        value >>= 8
+      end
+
+      bytes.pack("C*")
+    end
+
+    private
+
+    def xor_bytes(a, b)
+      [a].pack('H*').unpack('C*').zip(
+        [b].pack('H*').unpack('C*')
+      ).map { |x, y| x ^ y }.pack("C*")
+    end
+
+    def keyed_hash(prefix, k, m)
+      payload = to_byte(prefix, n) + hex_to_bin(k) + hex_to_bin(m)
+      case name
+      when 'WOTSP-SHA2_256'
+        Digest::SHA256.hexdigest(payload)
+      when 'WOTSP-SHA2_512'
+        Digest::SHA512.hexdigest(payload)
+      when 'WOTSP-SHAKE_256'
+        OpenSSL::Digest.new('shake256', payload).hexdigest
+      else
+        raise 'Unknown param'
+      end
+    end
+  end
+end

data/lib/wots/private_key.rb

@@ -0,0 +1,69 @@
+module WOTS
+  # WOTS+ private key.
+  class PrivateKey
+    include Util
+    extend Util
+
+    attr_reader :param
+    attr_reader :keys
+
+    def initialize(param, keys)
+      raise ArgumentError, "param must be WOTS::Param." unless param.is_a?(WOTS::Param)
+      raise ArgumentError, "keys must be Array." unless keys.is_a?(Array)
+      raise ArgumentError, "The length of keys must be the same as param#len." unless keys.length == param.len
+      keys.each do |key|
+        raise ArgumentError, "key must be hex string." unless hex_string?(key)
+        raise ArgumentError, "key must be #{param.n} bytes." unless hex_to_bin(key).bytesize == param.n
+      end
+
+      @param = param
+      @keys = keys
+    end
+
+    # Generate private key using +seed+.
+    # @param [WOTS::Param] param
+    # @param [String] seed
+    # @raise ArgumentError
+    def self.from_seed(param, seed)
+      raise ArgumentError, "param must be WOTS::Param." unless param.is_a?(WOTS::Param)
+      raise ArgumentError, "seed must be String." unless seed.is_a?(String)
+      raise ArgumentError, "seed must be #{param.n} bytes." unless hex_to_bin(seed).bytesize == param.n
+      raise ArgumentError, "len parameter too large." if param.len.bit_length > 16
+
+      keys = param.len.times.map do |i|
+        param.prf(seed, param.to_byte(i, 32))
+      end
+
+      PrivateKey.new(param, keys)
+    end
+
+    # Generate signature.
+    # @param [String] pub_seed The Public seed.
+    # @param [String] message The message to be signed.
+    # @return [WOTS::Signature]
+    # @raise ArgumentError
+    def sign(pub_seed, message)
+      raise ArgumentError, 'pub_seed must be hex string.' unless hex_string?(pub_seed)
+      raise ArgumentError, "pub_seed must be #{param.n} bytes." unless hex_to_bin(pub_seed).bytesize == param.n
+      raise ArgumentError, "message must be string." unless message.is_a?(String)
+      raise ArgumentError, "message must be #{param.n} bytes." unless hex_to_bin(message).bytesize == param.n
+
+      addr = Address.new
+
+      # Convert message to base w
+      base_w = param.base_w(message, param.len1)
+
+      # Compute checksum
+      c_sum = param.compute_checksum(base_w)
+
+      base_w = base_w + param.base_w(c_sum, param.len2)
+
+      sigs = param.len.times.map do |i|
+        addr.chain_addr = i
+        param.chain(keys[i], 0, base_w[i], pub_seed, addr)
+      end
+
+      Signature.new(param, sigs)
+    end
+  end
+end

data/lib/wots/public_key.rb

@@ -0,0 +1,71 @@
+module WOTS
+  # WOTS+ public key.
+  class PublicKey
+    include Util
+    extend Util
+
+    attr_reader :param
+    attr_reader :keys
+
+    def initialize(param, keys)
+      raise ArgumentError, "param must be WOTS::Param." unless param.is_a?(WOTS::Param)
+      raise ArgumentError, "keys must be Array." unless keys.is_a?(Array)
+      raise ArgumentError, "The length of keys must be the same as param#len." unless keys.length == param.len
+      keys.each do |key|
+        raise ArgumentError, "key must be hex string." unless hex_string?(key)
+        raise ArgumentError, "key must be #{param.n} bytes." unless hex_to_bin(key).bytesize == param.n
+      end
+      @param = param
+      @keys = keys
+    end
+
+    # Generate public key from +private_key+ and +pub_seed+.
+    # @param [WOTS::PrivateKey] private_key
+    # @param [String] pub_seed
+    def self.from_private_key(private_key, pub_seed)
+      raise ArgumentError, 'private_key must be WOTS::PrivateKey.' unless private_key.is_a?(WOTS::PrivateKey)
+      param = private_key.param
+      raise ArgumentError, 'pub_seed must be hex string.' unless hex_string?(pub_seed)
+      raise ArgumentError, "pub_seed must be #{param.n} bytes." unless hex_to_bin(pub_seed).bytesize == param.n
+      addr = WOTS::Address.new
+      keys = param.len.times.map do |i|
+        addr.chain_addr = i
+        sk = private_key.keys[i]
+        param.chain(sk, 0, param.w - 1, pub_seed, addr)
+      end
+      PublicKey.new(private_key.param, keys)
+    end
+
+    # Generate public key from +signature+.
+    # @param [WOTS::Signature] signature
+    # @param [String] pub_seed
+    # @param [String] message
+    # @return [WOTS::PublicKey]
+    # @raise ArgumentError
+    def self.from_signature(signature, pub_seed, message)
+      param = signature.param
+      raise ArgumentError, 'pub_seed must be hex string.' unless hex_string?(pub_seed)
+      raise ArgumentError, "pub_seed must be #{param.n} bytes." unless hex_to_bin(pub_seed).bytesize == param.n
+      raise ArgumentError, "message must be string." unless message.is_a?(String)
+      raise ArgumentError, "message must be #{param.n} bytes." unless hex_to_bin(message).bytesize == param.n
+
+      base_w = param.base_w(message, param.len1)
+      c_sum = param.compute_checksum(base_w)
+      base_w = base_w + param.base_w(c_sum, param.len2)
+
+      addr = WOTS::Address.new
+
+      keys = param.len.times.map do |i|
+        addr.chain_addr = i
+        param.chain(signature.sigs[i], base_w[i], param.w - 1 - base_w[i], pub_seed, addr)
+      end
+
+      PublicKey.new(param, keys)
+    end
+
+    def ==(other)
+      return false unless other.is_a?(PublicKey)
+      param == other.param && keys == other.keys
+    end
+  end
+end

data/lib/wots/signature.rb

@@ -0,0 +1,21 @@
+module WOTS
+  # WOTS+ signature.
+  class Signature
+    include Util
+
+    attr_reader :param, :sigs
+
+    def initialize(param, sigs)
+      raise ArgumentError, "param must be WOTS::Param." unless param.is_a?(WOTS::Param)
+      raise ArgumentError, "sigs must be Array." unless sigs.is_a?(Array)
+      raise ArgumentError, "The length of sigs must be the same as param#len." unless sigs.length == param.len
+      sigs.each do |sig|
+        raise ArgumentError, "sig must be hex string." unless hex_string?(sig)
+        raise ArgumentError, "sig must be #{param.n} bytes." unless hex_to_bin(sig).bytesize == param.n
+      end
+
+      @param = param
+      @sigs = sigs
+    end
+  end
+end

data/lib/wots/util.rb

@@ -0,0 +1,32 @@
+module WOTS
+  module Util
+
+    # Check whether +data+ is hex string or not.
+    # @param [String] data
+    # @return [Boolean]
+    # @raise [ArgumentError]
+    def hex_string?(data)
+      raise ArgumentError, 'data must be string' unless data.is_a?(String)
+      data.match?(/\A[0-9a-fA-F]+\z/)
+    end
+
+    # Convert hex string +data+ to binary.
+    # @param [String] data
+    # @return [String]
+    # @raise [ArgumentError]
+    def hex_to_bin(data)
+      raise ArgumentError, 'data must be string' unless data.is_a?(String)
+      hex_string?(data) ? [data].pack('H*') : data
+    end
+
+    # Convert binary string +data+ to hex string.
+    # @param [String] data
+    # @return [String]
+    # @raise [ArgumentError]
+    def bin_to_hex(data)
+      raise ArgumentError, 'data must be string' unless data.is_a?(String)
+      hex_string?(data) ? data : data.unpack1('H*')
+    end
+
+  end
+end

data/lib/wots/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module WOTS
+  VERSION = "0.1.0"
+end

data/lib/wots.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+require 'digest'
+require_relative "wots/version"
+require_relative 'wots/util'
+require_relative 'wots/param'
+require_relative 'wots/address'
+require_relative 'wots/private_key'
+require_relative 'wots/public_key'
+require_relative 'wots/signature'
+
+module WOTS
+  class Error < StandardError; end
+end

data/sig/wots.rbs

@@ -0,0 +1,4 @@
+module Wots
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: wots
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- azuchi
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: A Ruby implementation of the Winternitz OTS (W-OTS+), as described in
+  RFC8391.
+email:
+- azuchi@chaintope.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".ruby-gemset"
+- ".ruby-version"
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/wots.rb
+- lib/wots/address.rb
+- lib/wots/param.rb
+- lib/wots/param/sha256.rb
+- lib/wots/param/sha512.rb
+- lib/wots/param/shake256.rb
+- lib/wots/private_key.rb
+- lib/wots/public_key.rb
+- lib/wots/signature.rb
+- lib/wots/util.rb
+- lib/wots/version.rb
+- sig/wots.rbs
+homepage: https://github.com/azuchi/wots
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/azuchi/wots
+  source_code_uri: https://github.com/azuchi/wots
+  changelog_uri: https://github.com/azuchi/wots
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: A Ruby implementation of the Winternitz OTS (W-OTS+), as described in RFC8391.
+test_files: []