Ruby signature verification

ruby --version
# Install libsodium 1.0.20 with your OS package manager.
# Set SODIUM_LIBRARY to its full library path if it is not in the loader path.

ruby ruby/verify.rb vectors/positive.key.json vectors/positive.envelope.json
ruby ruby/verify.rb vectors/tampered.key.json vectors/tampered.envelope.json
ruby ruby/verify.rb vectors/expired.key.json vectors/expired.envelope.json
python3 selftest.py --command ruby ruby/verify.rb

# KDPika signature authenticity only. Ruby 2.6+, native libsodium 1.0.20.
# Run: ruby verify.rb key.json envelope.json. Output signature_valid=true/false.
# Set SODIUM_LIBRARY to the installed library path if needed. Trust the key separately.
require 'json'
require 'strscan'
require 'base64'
require 'digest'
require 'fiddle/import'
module Sodium
  extend Fiddle::Importer
  dlload ENV.fetch('SODIUM_LIBRARY', RUBY_PLATFORM.include?('darwin') ? 'libsodium.dylib' : 'libsodium.so')
  extern 'int sodium_init()'
  extern 'int crypto_sign_verify_detached(void*, void*, unsigned long long, void*)'
end
NumberToken = Struct.new(:raw)
class RawJson
  def initialize(raw)
    raise 'Invalid JSON size or UTF-8' if raw.bytesize > 1_048_576 || !raw.force_encoding('UTF-8').valid_encoding?
    @scanner = StringScanner.new(raw)
  end
  def string
    token = @scanner.scan(/"(?:[^"\\\x00-\x1f]|\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4}))*"/)
    raise 'Invalid JSON string' unless token
    JSON.parse(token)
  end
  def value(depth)
    raise 'JSON exceeds 64 levels' if depth > 64
    @scanner.skip(/[ \t\r\n]*/)
    return string if @scanner.peek(1) == '"'
    if ['{', '['].include?(@scanner.peek(1))
      object = @scanner.getch == '{'; ending = object ? '}' : ']'; result = object ? {} : []
      @scanner.skip(/[ \t\r\n]*/)
      return result if @scanner.scan(Regexp.new(Regexp.escape(ending)))
      loop do
        if object
          @scanner.skip(/[ \t\r\n]*/); key = string; @scanner.skip(/[ \t\r\n]*/)
          raise 'Duplicate or invalid property' if result.key?(key) || !@scanner.scan(/:/)
          result[key] = value(depth + 1)
        else
          result << value(depth + 1)
        end
        @scanner.skip(/[ \t\r\n]*/); next_char = @scanner.getch
        return result if next_char == ending
        raise 'Invalid collection' unless next_char == ','
      end
    end
    {'true' => true, 'false' => false, 'null' => nil}.each do |token, result|
      return result if @scanner.scan(Regexp.new(token))
    end
    number = @scanner.scan(/-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/)
    raise 'Invalid JSON value' unless number
    NumberToken.new(number)
  end
  def parse
    result = value(0); @scanner.skip(/[ \t\r\n]*/)
    raise 'Trailing JSON' unless @scanner.eos?
    result
  end
end
def quote(value)
  raise 'Invalid Unicode' unless value.valid_encoding?
  JSON.generate(value).gsub("\u2028", '\\u2028').gsub("\u2029", '\\u2029')
end
def canonical(value)
  case value
  when NumberToken then value.raw
  when Hash then '{' + value.keys.sort_by(&:b).map { |k| quote(k) + ':' + canonical(value[k]) }.join(',') + '}'
  when Array then '[' + value.map { |child| canonical(child) }.join(',') + ']'
  when String then quote(value)
  when TrueClass then 'true'
  when FalseClass then 'false'
  when NilClass then 'null'
  else raise 'Unsupported value'
  end
end
def decode(value, size)
  raise 'Invalid base64url' unless value.is_a?(String) && /\A[A-Za-z0-9_-]+\z/.match?(value)
  raw = Base64.urlsafe_decode64(value)
  raise 'Invalid base64url length' unless raw.bytesize == size && Base64.urlsafe_encode64(raw, padding: false) == value
  raw
end
def verify_envelope(trusted_key_raw, envelope_raw)
  key = RawJson.new(trusted_key_raw).parse; env = RawJson.new(envelope_raw).parse
  public_key = decode(key.fetch('public_key'), 32)
  id = 'ed25519_' + Digest::SHA256.hexdigest(public_key)[0, 16]
  return false unless key['algorithm'] == 'Ed25519' && key['encoding'] == 'base64url' && key['key_id'] == id &&
                      env['algorithm'] == 'Ed25519' && env['key_id'] == id && env['payload'].is_a?(Hash)
  message = canonical(env['payload']).b; signature = decode(env.fetch('signature'), 64)
  Sodium.sodium_init >= 0 && Sodium.crypto_sign_verify_detached(signature, message, message.bytesize, public_key) == 0
rescue StandardError
  false
end
if $PROGRAM_NAME == __FILE__
  begin
    valid = ARGV.length == 2 && verify_envelope(File.binread(ARGV[0]), File.binread(ARGV[1]))
  rescue StandardError
    valid = false
  end
  puts "signature_valid=#{valid}"; exit(valid ? 0 : 1)
end