argon2id 0.2.1-aarch64-linux → 0.4.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84a2ff49d5729e851e8276957320dd99dfe1b886ca7a5ee896417007275bac83
-  data.tar.gz: 4bf6f72159c95c445dce23d8079a673e8caaa299ceec68497e286c42774db58e
+  metadata.gz: f175cce3525d0e51d765f25b478d3dc679400044230ec19a1fc5162a16b81c08
+  data.tar.gz: e44fa146bfa95dfd9eb369659141965ab3547005730a54c540913e3bf41bcd07
 SHA512:
-  metadata.gz: 0b9b619b2aef08cbc99d743bb8ac2f4c68f451d4754239308ea9574ad51ea69e5f8b39884a6e48541df74332e636729aae195771ea047b022f404990af064b30
-  data.tar.gz: f62a63c618e890d26911311905a171c1f1408f865ecfc7c4bc317b5ff9d948a69f71cc0a222025a46c504f94ba794b3dc0276859f5dd77d4e7e64ef8d34b87eb
+  metadata.gz: 7412da1d6fd6459893ccb22cb82966c024a408529e65758c10ea6f271e4d9ca3e738c0fd4426e4657b275a894fe09eb2d73cc32a91cc5ec6cf0783b2d2792c49
+  data.tar.gz: e1449e2aa0de3f442aca0209af67ce3d51d18027e89d4fd4e32bdc6de66ec40fc66497aa13e7ab2f8183a3860e26820371b1b6b6473b3afa957765d88de45c83

data/CHANGELOG.md

@@ -5,6 +5,32 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.0] - 2024-11-02
+
+### Added
+
+- Added support for JRuby 9.4 by adding an implementation of Argon2id hashing
+  and verification using JRuby-OpenSSL's Bouncy Castle internals.
+- Added `output` to `Argon2id::Password` instances so the actual "output" part
+  of a password hash can be retrieved (and compared)
+
+### Changed
+
+- Verifying a password will now consistently raise an `ArgumentError` when
+  given an invalid encoded hash rather than an `Argon2id::Error`
+
+## [0.3.0] - 2024-11-01
+
+### Added
+
+- Expose all parameters of a hash through new readers on `Argon2id::Password`:
+  namely, `type`, `version`, `m_cost`, `t_cost`, and `parallelism`
+
+### Changed
+
+- Remove the dependency on the `base64` gem by inlining the definition of
+  `Base64.decode64` (thanks to @etiennebarrie for the tip)
+
 ## [0.2.1] - 2024-11-01
 
 ### Added
@@ -51,6 +77,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   reference C implementation of Argon2, the password-hashing function that won
   the Password Hashing Competition.
 
+[0.4.0]: https://github.com/mudge/argon2id/releases/tag/v0.4.0
+[0.3.0]: https://github.com/mudge/argon2id/releases/tag/v0.3.0
 [0.2.1]: https://github.com/mudge/argon2id/releases/tag/v0.2.1
 [0.2.0]: https://github.com/mudge/argon2id/releases/tag/v0.2.0
 [0.1.2]: https://github.com/mudge/argon2id/releases/tag/v0.1.2

data/README.md

@@ -5,18 +5,19 @@ function that won the 2015 [Password Hashing Competition][].
 
 [![Build Status](https://github.com/mudge/argon2id/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/mudge/argon2id/actions)
 
-**Current version:** 0.2.1  
+**Current version:** 0.4.0  
 **Bundled Argon2 version:** libargon2.1 (20190702)
 
 ```ruby
-Argon2id::Password.create("opensesame").to_s
-#=> "$argon2id$v=19$m=19456,t=2,p=1$ZS2nBFWBpnt28HjtzNOW4w$SQ+p+dIcWbpzWpZQ/ZZFj8IQkyhYZf127U4QdkRmKFU"
+Argon2id::Password.create("password").to_s
+#=> "$argon2id$v=19$m=19456,t=2,p=1$agNV6OfDL1OwE44WdrFCJw$ITrBwvCsW4b5GjgZuL67RCcvVMEWBWXtASc9TVyI3rY"
 
-Argon2id::Password.create("opensesame") == "opensesame"
-#=> true
+password = Argon2id::Password.new("$argon2id$v=19$m=19456,t=2,p=1$ZS2nBFWBpnt28HjtzNOW4w$SQ+p+dIcWbpzWpZQ/ZZFj8IQkyhYZf127U4QdkRmKFU")
+password == "password"     #=> true
+password == "not password" #=> false
 
-Argon2id::Password.new("$argon2id$v=19$m=19456,t=2,p=1$ZS2nBFWBpnt28HjtzNOW4w$SQ+p+dIcWbpzWpZQ/ZZFj8IQkyhYZf127U4QdkRmKFU") == "opensesame"
-#=> true
+password.m_cost #=> 19456
+password.salt   #=> "e-\xA7\x04U\x81\xA6{v\xF0x\xED\xCC\xD3\x96\xE3"
 ```
 
 ## Table of contents
@@ -142,12 +143,18 @@ password.is_password?("opensesame")    #=> true
 password.is_password?("notopensesame") #=> false
 ```
 
-The original salt for a password can be retrieved with `Argon2id::Password#salt`:
+The various parts of the encoded password can be retrieved:
 
 ```ruby
 password = Argon2id::Password.new("$argon2id$v=19$m=256,t=2,p=1$c29tZXNhbHQ$nf65EOgLrQMR/uIPnA4rEsF5h7TKyQwu9U1bMCHGi/4")
-password.salt
-#=> "somesalt"
+password.type        #=> "argon2id"
+password.version     #=> 19
+password.m_cost      #=> 256
+password.t_cost      #=> 2
+password.parallelism #=> 1
+password.salt        #=> "somesalt"
+password.output
+#=> "\x9D\xFE\xB9\x10\xE8\v\xAD\x03\x11\xFE\xE2\x0F\x9C\x0E+\x12\xC1y\x87\xB4\xCA\xC9\f.\xF5M[0!\xC6\x8B\xFE"
 ```
 
 ### Errors
@@ -155,16 +162,22 @@ password.salt
 Any errors returned from Argon2 will be raised as `Argon2id::Error`, e.g.
 
 ```ruby
-password = Argon2id::Password.new("not a valid hash encoding")
-password == "opensesame"
-# Decoding failed (Argon2id::Error)
+Argon2id::Password.create("password", salt_len: 0)
+# Salt is too short (Argon2id::Error)
 ```
 
 ## Requirements
 
-This gem requires the following to run:
+This gem requires any of the following to run:
 
 * [Ruby](https://www.ruby-lang.org/en/) 2.6 to 3.3
+* [JRuby](https://www.jruby.org) 9.4
+* [TruffleRuby](https://www.graalvm.org/ruby/) 24.1
+
+> [!NOTE]
+> The JRuby version of the gem uses
+> [JRuby-OpenSSL](https://github.com/jruby/jruby-openssl)'s implementation of
+> Argon2 instead of the reference C implementation.
 
 ### Native gems
 
@@ -176,6 +189,7 @@ Where possible, a pre-compiled native gem will be provided for the following pla
     * [musl](https://musl.libc.org/)-based systems such as [Alpine](https://alpinelinux.org) are supported as long as a [glibc-compatible library is installed](https://wiki.alpinelinux.org/wiki/Running_glibc_programs)
 * macOS `x86_64-darwin` and `arm64-darwin`
 * Windows `x64-mingw32` and `x64-mingw-ucrt`
+* Java: any platform running JRuby 9.4 or higher
 
 ### Verifying the gems
 
@@ -184,11 +198,11 @@ notes](https://github.com/mudge/argon2id/releases) for each version and can be
 checked with `sha256sum`, e.g.
 
 ```console
-$ gem fetch argon2id -v 0.2.0
-Fetching argon2id-0.2.0-arm64-darwin.gem
-Downloaded argon2id-0.2.0-arm64-darwin
-$ sha256sum argon2id-0.2.0-arm64-darwin.gem
-ce1fa632393e814da750f44146dc6de1353e4b24746fb94f6f4ea748b9dad26b  argon2id-0.2.0-arm64-darwin.gem
+$ gem fetch argon2id -v 0.3.0
+Fetching argon2id-0.3.0-arm64-darwin.gem
+Downloaded argon2id-0.3.0-arm64-darwin
+$ sha256sum argon2id-0.3.0-arm64-darwin.gem
+9d49de6840942b48d020dddd422a1577fde7289ccb08a637bdb29f4a09b4e181  argon2id-0.3.0-arm64-darwin.gem
 ```
 
 [GPG](https://www.gnupg.org/) signatures are attached to each release (the
@@ -198,8 +212,8 @@ from a public keyserver, e.g. `gpg --keyserver keyserver.ubuntu.com --recv-key
 0x39AC3530070E0F75`):
 
 ```console
-$ gpg --verify argon2id-0.2.0-arm64-darwin.gem.sig argon2id-0.2.0-arm64-darwin.gem
-gpg: Signature made Fri  1 Nov 14:48:57 2024 GMT
+$ gpg --verify argon2id-0.3.0-arm64-darwin.gem.sig argon2id-0.3.0-arm64-darwin.gem
+gpg: Signature made Fri  1 Nov 18:15:47 2024 GMT
 gpg:                using RSA key 702609D9C790F45B577D7BEC39AC3530070E0F75
 gpg: Good signature from "Paul Mucur <mudge@mudge.name>" [unknown]
 gpg:                 aka "Paul Mucur <paul@ghostcassette.com>" [unknown]

data/Rakefile

@@ -20,6 +20,13 @@ ENV["RUBY_CC_VERSION"] = %w[3.3.0 3.2.0 3.1.0 3.0.0 2.7.0 2.6.0].join(":")
 
 gemspec = Gem::Specification.load("argon2id.gemspec")
 
+if RUBY_PLATFORM == "java"
+  gemspec.files.reject! { |path| File.fnmatch?("ext/*", path) }
+  gemspec.extensions.clear
+  gemspec.platform = Gem::Platform.new("java")
+  gemspec.required_ruby_version = ">= 3.1.0"
+end
+
 Gem::PackageTask.new(gemspec).define
 
 Rake::ExtensionTask.new("argon2id", gemspec) do |e|
@@ -50,6 +57,15 @@ namespace :gem do
       SCRIPT
     end
   end
+
+  desc "Compile gem for JRuby"
+  task :jruby do
+    RakeCompilerDock.sh <<~SCRIPT, rubyvm: "jruby", platform: "jruby", verbose: true
+      gem install bundler --no-document &&
+      bundle &&
+      bundle exec rake gem
+    SCRIPT
+  end
 end
 
 task default: [:compile, :test]

data/argon2id.gemspec

@@ -53,7 +53,6 @@ Gem::Specification.new do |s|
   ]
   s.rdoc_options = ["--main", "README.md"]
 
-  s.add_runtime_dependency("base64")
   s.add_development_dependency("rake-compiler", "~> 1.2")
   s.add_development_dependency("rake-compiler-dock", "~> 1.5")
   s.add_development_dependency("minitest", "~> 5.25")

data/ext/argon2id/argon2id.c

@@ -70,6 +70,9 @@ rb_argon2id_verify(VALUE module, VALUE encoded, VALUE pwd) {
   if (result == ARGON2_VERIFY_MISMATCH) {
     return Qfalse;
   }
+  if (result == ARGON2_DECODING_FAIL || result == ARGON2_DECODING_LENGTH_FAIL) {
+    rb_raise(rb_eArgError, "%s", argon2_error_message(result));
+  }
 
   rb_raise(cArgon2idError, "%s", argon2_error_message(result));
 }

data/lib/argon2id/password.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "base64"
 require "openssl"
 
 module Argon2id
@@ -12,34 +11,67 @@ module Argon2id
   #   password.to_s
   #   #=> "$argon2id$v=19$m=19456,t=2,p=1$+Lrjry9Ifq0poLr15OGU1Q$utkDvejJB0ugwm4s9+a+vF6+1a/W+Y3CYa5Wte/85ig"
   #
-  # To verify an encoded Argon2id password hash, use Argon2id::Password.new:
+  # To wrap an encoded Argon2id password hash, use Argon2id::Password.new:
   #
-  #   password = Argon2id::Password.new("$argon2id$v=19$m=19456,t=2,p=1$+Lrjry9Ifq0poLr15OGU1Q$utkDvejJB0ugwm4s9+a+vF6+1a/W+Y3CYa5Wte/85ig")
-  #   password == "password"
-  #   #=> true
+  #   password = Argon2id::Password.new("$argon2id$v=19$m=256,t=2,p=1$c29tZXNhbHQ$nf65EOgLrQMR/uIPnA4rEsF5h7TKyQwu9U1bMCHGi/4")
+  #
+  # You can then verify it matches a given plain text:
+  #
+  #   password == "password"     #=> true
+  #   password == "not password" #=> false
+  #
+  #   password.is_password?("password")     #=> true
+  #   password.is_password?("not password") #=> false
+  #
+  # You can read various parameters out of a password hash:
+  #
+  #   password.type        #=> "argon2id"
+  #   password.version     #=> 19
+  #   password.m_cost      #=> 19456
+  #   password.t_cost      #=> 2
+  #   password.parallelism #=> 1
+  #   password.salt        #=>  "somesalt"
   class Password
     # A regular expression to match valid hashes.
     PATTERN = %r{
       \A
       \$
-      argon2(?:id|i|d)
-      (?:\$v=\d+)?
-      \$m=\d+
-      ,t=\d+
-      ,p=\d+
+      (argon2(?:id|i|d))
+      (?:\$v=(\d+))?
+      \$m=(\d+)
+      ,t=(\d+)
+      ,p=(\d+)
       \$
-      (?<base64_salt>[a-zA-Z0-9+/]+)
+      ([a-zA-Z0-9+/]+)
       \$
-      [a-zA-Z0-9+/]+
+      ([a-zA-Z0-9+/]+)
       \z
     }x.freeze
 
     # The encoded password hash.
     attr_reader :encoded
 
+    # The type of the hashing function.
+    attr_reader :type
+
+    # The version number of the hashing function.
+    attr_reader :version
+
+    # The "time cost" of the hashing function.
+    attr_reader :t_cost
+
+    # The "memory cost" of the hashing function.
+    attr_reader :m_cost
+
+    # The number of threads and compute lanes of the hashing function.
+    attr_reader :parallelism
+
     # The salt.
     attr_reader :salt
 
+    # The hash output.
+    attr_reader :output
+
     # Create a new Password object that hashes a given plain text password +pwd+.
     #
     # - +:t_cost+: integer (default 2) the "time cost" given as a number of iterations
@@ -72,8 +104,6 @@ module Argon2id
       )
     end
 
-    # call-seq: Argon2id::Password.new(encoded)
-    #
     # Create a new Password with the given encoded password hash.
     #
     #   password = Argon2id::Password.new("$argon2id$v=19$m=19456,t=2,p=1$FI8yp1gXbthJCskBlpKPoQ$nOfCCpS2r+I8GRN71cZND4cskn7YKBNzuHUEO3YpY2s")
@@ -82,17 +112,21 @@ module Argon2id
     def initialize(encoded)
       raise ArgumentError, "invalid hash" unless PATTERN =~ String(encoded)
 
-      @encoded = Regexp.last_match(0)
-      @salt = Base64.decode64(Regexp.last_match(1))
+      @encoded = $&
+      @type = $1
+      @version = Integer($2 || 0x10)
+      @m_cost = Integer($3)
+      @t_cost = Integer($4)
+      @parallelism = Integer($5)
+      @salt = $6.unpack1("m")
+      @output = $7.unpack1("m")
     end
 
     # Return the encoded password hash.
-    def to_s
-      encoded
-    end
+    alias_method :to_s, :encoded
 
-    # Compare the password with given plain text, returning true if it verifies
-    # successfully.
+    # Compare the password with the given plain text, returning true if it
+    # verifies successfully.
     #
     #   password = Argon2id::Password.new("$argon2id$v=19$m=19456,t=2,p=1$FI8yp1gXbthJCskBlpKPoQ$nOfCCpS2r+I8GRN71cZND4cskn7YKBNzuHUEO3YpY2s")
     #   password == "password"    #=> true

data/lib/argon2id/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Argon2id
-  VERSION = "0.2.1"
+  VERSION = "0.4.0"
 end

data/lib/argon2id.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
-begin
-  ::RUBY_VERSION =~ /(\d+\.\d+)/
-  require_relative "#{Regexp.last_match(1)}/argon2id.so"
-rescue LoadError
-  require "argon2id.so"
+if RUBY_PLATFORM == "java"
+  require "openssl"
+else
+  begin
+    ::RUBY_VERSION =~ /(\d+\.\d+)/
+    require_relative "#{Regexp.last_match(1)}/argon2id.so"
+  rescue LoadError
+    require "argon2id.so"
+  end
 end
 
 require "argon2id/version"
@@ -48,4 +52,54 @@ module Argon2id
     # The default desired length of the hash in bytes used by Argon2id::Password.create
     attr_accessor :output_len
   end
+
+  if RUBY_PLATFORM == "java"
+    Error = Class.new(StandardError)
+
+    def self.hash_encoded(t_cost, m_cost, parallelism, pwd, salt, hashlen)
+      raise Error, "Salt is too short" unless String(salt).bytesize.positive?
+
+      hash = Java::byte[Integer(hashlen)].new
+      params = Java::OrgBouncycastleCryptoParams::Argon2Parameters::Builder
+        .new(Java::OrgBouncycastleCryptoParams::Argon2Parameters::ARGON2_id)
+        .with_salt(String(salt).to_java_bytes)
+        .with_parallelism(Integer(parallelism))
+        .with_memory_as_kb(Integer(m_cost))
+        .with_iterations(Integer(t_cost))
+        .build
+      generator = Java::OrgBouncycastleCryptoGenerators::Argon2BytesGenerator.new
+      encoder = Java::JavaUtil::Base64.get_encoder.without_padding
+
+      generator.init(params)
+      generator.generate_bytes(String(pwd).to_java_bytes, hash)
+
+      encoded_salt = encoder.encode_to_string(params.get_salt)
+      encoded_output = encoder.encode_to_string(hash)
+
+      "$argon2id$v=#{params.get_version}$m=#{params.get_memory}," \
+        "t=#{params.get_iterations},p=#{params.get_lanes}" \
+        "$#{encoded_salt}$#{encoded_output}"
+    rescue => e
+      raise Error, e.message
+    end
+
+    def self.verify(encoded, pwd)
+      password = Password.new(encoded)
+      other_password = Password.new(
+        hash_encoded(
+          password.t_cost,
+          password.m_cost,
+          password.parallelism,
+          String(pwd),
+          password.salt,
+          password.output.bytesize
+        )
+      )
+
+      Java::OrgBouncycastleUtil::Arrays.constant_time_are_equal(
+        password.output.to_java_bytes,
+        other_password.output.to_java_bytes
+      )
+    end
+  end
 end

data/test/test_hash_encoded.rb

@@ -17,42 +17,32 @@ class TestHashEncoded < Minitest::Test
   end
 
   def test_raises_with_too_short_output
-    error = assert_raises(Argon2id::Error) do
+    assert_raises(Argon2id::Error) do
       Argon2id.hash_encoded(2, 256, 1, "password", "somesalt", 1)
     end
-
-    assert_equal "Output is too short", error.message
   end
 
   def test_raises_with_too_few_lanes
-    error = assert_raises(Argon2id::Error) do
+    assert_raises(Argon2id::Error) do
       Argon2id.hash_encoded(2, 256, 0, "password", "somesalt", 32)
     end
-
-    assert_equal "Too few lanes", error.message
   end
 
   def test_raises_with_too_small_memory_cost
-    error = assert_raises(Argon2id::Error) do
+    assert_raises(Argon2id::Error) do
       Argon2id.hash_encoded(2, 0, 1, "password", "somesalt", 32)
     end
-
-    assert_equal "Memory cost is too small", error.message
   end
 
   def test_raises_with_too_small_time_cost
-    error = assert_raises(Argon2id::Error) do
+    assert_raises(Argon2id::Error) do
       Argon2id.hash_encoded(0, 256, 1, "password", "somesalt", 32)
     end
-
-    assert_equal "Time cost is too small", error.message
   end
 
   def test_raises_with_too_short_salt
-    error = assert_raises(Argon2id::Error) do
-      Argon2id.hash_encoded(0, 256, 1, "password", "", 32)
+    assert_raises(Argon2id::Error) do
+      Argon2id.hash_encoded(2, 256, 1, "password", "", 32)
     end
-
-    assert_equal "Salt is too short", error.message
   end
 end

data/test/test_password.rb

@@ -109,4 +109,64 @@ class TestPassword < Minitest::Test
 
     assert Argon2id::Password.new(password) == "password"
   end
+
+  def test_extracting_type_from_hash
+    password = Argon2id::Password.new("$argon2id$v=19$m=256,t=2,p=1$c29tZXNhbHQ$nf65EOgLrQMR/uIPnA4rEsF5h7TKyQwu9U1bMCHGi/4")
+
+    assert_equal "argon2id", password.type
+  end
+
+  def test_extracting_type_from_argoni_hash
+    password = Argon2id::Password.new("$argon2i$v=19$m=256,t=2,p=1$c29tZXNhbHQ$nf65EOgLrQMR/uIPnA4rEsF5h7TKyQwu9U1bMCHGi/4")
+
+    assert_equal "argon2i", password.type
+  end
+
+  def test_extracting_version_from_hash
+    password = Argon2id::Password.new("$argon2id$v=19$m=256,t=2,p=1$c29tZXNhbHQ$nf65EOgLrQMR/uIPnA4rEsF5h7TKyQwu9U1bMCHGi/4")
+
+    assert_equal 19, password.version
+  end
+
+  def test_extracting_version_from_versionless_hash
+    password = Argon2id::Password.new("$argon2id$m=256,t=2,p=1$c29tZXNhbHQ$nf65EOgLrQMR/uIPnA4rEsF5h7TKyQwu9U1bMCHGi/4")
+
+    assert_equal 16, password.version
+  end
+
+  def test_extracting_time_cost_from_hash
+    password = Argon2id::Password.new("$argon2id$v=19$m=256,t=2,p=1$c29tZXNhbHQ$nf65EOgLrQMR/uIPnA4rEsF5h7TKyQwu9U1bMCHGi/4")
+
+    assert_equal 2, password.t_cost
+  end
+
+  def test_extracting_time_cost_from_versionless_hash
+    password = Argon2id::Password.new("$argon2id$m=256,t=2,p=1$c29tZXNhbHQ$nf65EOgLrQMR/uIPnA4rEsF5h7TKyQwu9U1bMCHGi/4")
+
+    assert_equal 2, password.t_cost
+  end
+
+  def test_extracting_memory_cost_from_hash
+    password = Argon2id::Password.new("$argon2id$v=19$m=256,t=2,p=1$c29tZXNhbHQ$nf65EOgLrQMR/uIPnA4rEsF5h7TKyQwu9U1bMCHGi/4")
+
+    assert_equal 256, password.m_cost
+  end
+
+  def test_extracting_memory_cost_from_versionless_hash
+    password = Argon2id::Password.new("$argon2id$m=256,t=2,p=1$c29tZXNhbHQ$nf65EOgLrQMR/uIPnA4rEsF5h7TKyQwu9U1bMCHGi/4")
+
+    assert_equal 256, password.m_cost
+  end
+
+  def test_extracting_parallelism_from_hash
+    password = Argon2id::Password.new("$argon2id$v=19$m=256,t=2,p=1$c29tZXNhbHQ$nf65EOgLrQMR/uIPnA4rEsF5h7TKyQwu9U1bMCHGi/4")
+
+    assert_equal 1, password.parallelism
+  end
+
+  def test_extracting_parallelism_from_versionless_hash
+    password = Argon2id::Password.new("$argon2id$m=256,t=2,p=1$c29tZXNhbHQ$nf65EOgLrQMR/uIPnA4rEsF5h7TKyQwu9U1bMCHGi/4")
+
+    assert_equal 1, password.parallelism
+  end
 end

data/test/test_verify.rb

@@ -19,7 +19,7 @@ class TestVerify < Minitest::Test
   end
 
   def test_raises_if_given_invalid_encoded
-    assert_raises(Argon2id::Error) do
+    assert_raises(ArgumentError) do
       Argon2id.verify("", "opensesame")
     end
   end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: argon2id
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.4.0
 platform: aarch64-linux
 authors:
 - Paul Mucur
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-11-01 00:00:00.000000000 Z
+date: 2024-11-02 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: base64
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement