jose 0.1.0 → 0.2.0

data/lib/jose/jwa/curve25519_unsupported.rb

@@ -0,0 +1,52 @@
+module JOSE::JWA::Curve25519_Unsupported
+
+  extend self
+
+  def __ruby__?; true; end
+  def __supported__?; false; end
+
+  def ed25519_keypair(secret = nil)
+    raise NotImplementedError
+  end
+
+  def ed25519_secret_to_public(sk)
+    raise NotImplementedError
+  end
+
+  def ed25519_sign(m, sk)
+    raise NotImplementedError
+  end
+
+  def ed25519_verify(sig, m, pk)
+    raise NotImplementedError
+  end
+
+  def ed25519ph_keypair(secret = nil)
+    raise NotImplementedError
+  end
+
+  def ed25519ph_secret_to_public(sk)
+    raise NotImplementedError
+  end
+
+  def ed25519ph_sign(m, sk)
+    raise NotImplementedError
+  end
+
+  def ed25519ph_verify(sig, m, pk)
+    raise NotImplementedError
+  end
+
+  def x25519_keypair(secret = nil)
+    raise NotImplementedError
+  end
+
+  def x25519_secret_to_public(sk)
+    raise NotImplementedError
+  end
+
+  def x25519_shared_secret(pk, sk)
+    raise NotImplementedError
+  end
+
+end

data/lib/jose/jwa/curve448.rb

@@ -0,0 +1,99 @@
+module JOSE::JWA::Curve448
+
+  extend self
+
+  MUTEX = Mutex.new
+
+  @__implementations__ = []
+  @__ruby_implementations__ = []
+
+  def __implementation__
+    return MUTEX.synchronize { @__implementation__ ||= __pick_best_implementation__ }
+  end
+
+  def __implementation__=(implementation)
+    return MUTEX.synchronize { @__implementation__ = implementation }
+  end
+
+  def __register__(implementation, ruby = false)
+    MUTEX.synchronize {
+      if ruby
+        @__ruby_implementations__.unshift(implementation)
+      else
+        @__implementations__.unshift(implementation)
+      end
+      __config_change__(false)
+      implementation
+    }
+  end
+
+  def __config_change__(lock = true)
+    MUTEX.lock if lock
+    @__implementation__ = __pick_best_implementation__ if @__implementation__.nil? or @__implementation__.__ruby__? or not @__implementation__.__supported__?
+    MUTEX.unlock if lock
+  end
+
+  def ed448_keypair(secret = nil)
+    return (@__implementation__ || __implementation__).ed448_keypair(secret)
+  end
+
+  def ed448_secret_to_public(sk)
+    return (@__implementation__ || __implementation__).ed448_secret_to_public(sk)
+  end
+
+  def ed448_sign(m, sk)
+    return (@__implementation__ || __implementation__).ed448_sign(m, sk)
+  end
+
+  def ed448_verify(sig, m, pk)
+    return (@__implementation__ || __implementation__).ed448_verify(sig, m, pk)
+  end
+
+  def ed448ph_keypair(secret = nil)
+    return (@__implementation__ || __implementation__).ed448ph_keypair(secret)
+  end
+
+  def ed448ph_secret_to_public(sk)
+    return (@__implementation__ || __implementation__).ed448ph_secret_to_public(sk)
+  end
+
+  def ed448ph_sign(m, sk)
+    return (@__implementation__ || __implementation__).ed448ph_sign(m, sk)
+  end
+
+  def ed448ph_verify(sig, m, pk)
+    return (@__implementation__ || __implementation__).ed448ph_verify(sig, m, pk)
+  end
+
+  def x448_keypair(secret = nil)
+    return (@__implementation__ || __implementation__).x448_keypair(secret)
+  end
+
+  def x448_secret_to_public(sk)
+    return (@__implementation__ || __implementation__).x448_secret_to_public(sk)
+  end
+
+  def x448_shared_secret(pk, sk)
+    return (@__implementation__ || __implementation__).x448_shared_secret(pk, sk)
+  end
+
+private
+  def __pick_best_implementation__
+    implementation = nil
+    implementation = @__implementations__.detect do |implementation|
+      next implementation.__supported__?
+    end
+    implementation ||= @__ruby_implementations__.detect do |implementation|
+      next implementation.__supported__?
+    end
+    implementation ||= JOSE::JWA::Curve448_Unsupported
+    return implementation
+  end
+
+end
+
+require 'jose/jwa/ed448'
+require 'jose/jwa/x448'
+
+require 'jose/jwa/curve448_unsupported'
+require 'jose/jwa/curve448_ruby'

data/lib/jose/jwa/curve448_ruby.rb

@@ -0,0 +1,54 @@
+module JOSE::JWA::Curve448_Ruby
+
+  extend self
+
+  def __ruby__?; true; end
+  def __supported__?; JOSE.__crypto_fallback__; end
+
+  def ed448_keypair(secret = nil)
+    return JOSE::JWA::Ed448.keypair(secret)
+  end
+
+  def ed448_secret_to_public(sk)
+    return JOSE::JWA::Ed448.sk_to_pk(sk)
+  end
+
+  def ed448_sign(m, sk)
+    return JOSE::JWA::Ed448.sign(m, sk)
+  end
+
+  def ed448_verify(sig, m, pk)
+    return JOSE::JWA::Ed448.verify(sig, m, pk)
+  end
+
+  def ed448ph_keypair(secret = nil)
+    return JOSE::JWA::Ed448.keypair(secret)
+  end
+
+  def ed448ph_secret_to_public(sk)
+    return JOSE::JWA::Ed448.sk_to_pk(sk)
+  end
+
+  def ed448ph_sign(m, sk)
+    return JOSE::JWA::Ed448.sign_ph(m, sk)
+  end
+
+  def ed448ph_verify(sig, m, pk)
+    return JOSE::JWA::Ed448.verify_ph(sig, m, pk)
+  end
+
+  def x448_keypair(secret = nil)
+    return JOSE::JWA::X448.keypair(secret)
+  end
+
+  def x448_secret_to_public(sk)
+    return JOSE::JWA::X448.sk_to_pk(sk)
+  end
+
+  def x448_shared_secret(pk, sk)
+    return JOSE::JWA::X448.shared_secret(pk, sk)
+  end
+
+end
+
+JOSE::JWA::Curve448.__register__(JOSE::JWA::Curve448_Ruby, true)

data/lib/jose/jwa/curve448_unsupported.rb

@@ -0,0 +1,52 @@
+module JOSE::JWA::Curve448_Unsupported
+
+  extend self
+
+  def __ruby__?; true; end
+  def __supported__?; false; end
+
+  def ed448_keypair(secret = nil)
+    raise NotImplementedError
+  end
+
+  def ed448_secret_to_public(sk)
+    raise NotImplementedError
+  end
+
+  def ed448_sign(m, sk)
+    raise NotImplementedError
+  end
+
+  def ed448_verify(sig, m, pk)
+    raise NotImplementedError
+  end
+
+  def ed448ph_keypair(secret = nil)
+    raise NotImplementedError
+  end
+
+  def ed448ph_secret_to_public(sk)
+    raise NotImplementedError
+  end
+
+  def ed448ph_sign(m, sk)
+    raise NotImplementedError
+  end
+
+  def ed448ph_verify(sig, m, pk)
+    raise NotImplementedError
+  end
+
+  def x448_keypair(secret = nil)
+    raise NotImplementedError
+  end
+
+  def x448_secret_to_public(sk)
+    raise NotImplementedError
+  end
+
+  def x448_shared_secret(pk, sk)
+    raise NotImplementedError
+  end
+
+end

data/lib/jose/jwa/ed25519.rb

@@ -0,0 +1,117 @@
+module JOSE::JWA::Ed25519
+
+  extend self
+
+  C_bits = 256
+  C_bytes = (C_bits + 7) / 8
+  C_secretbytes = C_bytes
+  C_publickeybytes = C_bytes
+  C_secretkeybytes = C_secretbytes + C_publickeybytes
+  C_signaturebytes = C_bytes + C_bytes
+  C_B = JOSE::JWA::Edwards25519Point.stdbase.freeze
+
+  def secret_to_curve25519(secret)
+    raise ArgumentError, "secret must be #{C_secretbytes} bytes" if secret.bytesize != C_secretbytes
+    curve25519_scalar = Digest::SHA512.digest(secret)[0, 32]
+    curve25519_scalar.setbyte(0, curve25519_scalar.getbyte(0) & 248)
+    curve25519_scalar.setbyte(31, (curve25519_scalar.getbyte(31) & 127) | 64)
+    return curve25519_scalar
+  end
+
+  def secret_to_pk(secret)
+    raise ArgumentError, "secret must be #{C_secretbytes} bytes" if secret.bytesize != C_secretbytes
+    return (C_B * OpenSSL::BN.new(secret_to_curve25519(secret).reverse, 2).to_i).encode()
+  end
+
+  def keypair(secret = nil)
+    secret ||= SecureRandom.random_bytes(C_secretbytes)
+    pk = secret_to_pk(secret)
+    sk = secret + pk
+    return pk, sk
+  end
+
+  def sk_to_secret(sk)
+    raise ArgumentError, "sk must be #{C_secretkeybytes} bytes" if sk.bytesize != C_secretkeybytes
+    return sk[0, C_secretbytes]
+  end
+
+  def sk_to_pk(sk)
+    raise ArgumentError, "sk must be #{C_secretkeybytes} bytes" if sk.bytesize != C_secretkeybytes
+    return sk[C_secretbytes, C_secretkeybytes]
+  end
+
+  def sk_to_curve25519(sk)
+    return secret_to_curve25519(sk_to_secret(sk))
+  end
+
+  def pk_to_curve25519(pk)
+    raise ArgumentError, "pk must be #{C_publickeybytes} bytes" if pk.bytesize != C_publickeybytes
+    a = C_B.decode(pk)
+    u = (JOSE::JWA::X25519::C_F_one + a.y) / (JOSE::JWA::X25519::C_F_one - a.y)
+    return u.to_bytes(C_bits)
+  end
+
+  def sign(m, sk)
+    raise ArgumentError, "sk must be #{C_secretkeybytes} bytes" if sk.bytesize != C_secretkeybytes
+    secret, pk = sk[0, 32], sk[32, 64]
+    khash = Digest::SHA512.digest(secret)
+    curve25519_scalar, seed = khash[0, 32], khash[32, 64]
+    curve25519_scalar.setbyte(0, curve25519_scalar.getbyte(0) & 248)
+    curve25519_scalar.setbyte(31, (curve25519_scalar.getbyte(31) & 127) | 64)
+    a_s = OpenSSL::BN.new(curve25519_scalar.reverse, 2).to_i
+    # Calculate r_s and r (r only used in encoded form)
+    r_s = (OpenSSL::BN.new(Digest::SHA512.digest(seed+m).reverse, 2) % JOSE::JWA::Edwards25519Point::L).to_i
+    r = (C_B * r_s).encode()
+    # Calculate h.
+    h = (OpenSSL::BN.new(Digest::SHA512.digest(r+pk+m).reverse, 2) % JOSE::JWA::Edwards25519Point::L).to_i
+    # Calculate s.
+    s = OpenSSL::BN.new((r_s+h*a_s) % JOSE::JWA::Edwards25519Point::L).to_s(2).rjust(C_bytes, JOSE::JWA::ZERO_PAD).reverse
+    # The final signature is concatenation of r and s.
+    return r+s
+  end
+
+  def sign_ph(m, sk)
+    return sign(Digest::SHA512.digest(m), sk)
+  end
+
+  def verify(sig, m, pk)
+    # Sanity-check sizes.
+    return false if sig.bytesize != C_signaturebytes
+    return false if pk.bytesize != C_publickeybytes
+    # Split signature into R and S, and parse.
+    r, s = sig[0, 32], sig[32, 64]
+    r_p, s_s = C_B.decode(r), OpenSSL::BN.new(s.reverse, 2).to_i
+    # Parse public key.
+    a_p = C_B.decode(pk)
+    # Check parse results.
+    return false if r_p.nil? or a_p.nil? or s_s > JOSE::JWA::Edwards25519Point::L
+    # Calculate h.
+    h = (OpenSSL::BN.new(Digest::SHA512.digest(r+pk+m).reverse, 2) % JOSE::JWA::Edwards25519Point::L).to_i
+    # Calculate left and right sides of check eq.
+    rhs = r_p + (a_p * h)
+    lhs = C_B * s_s
+    JOSE::JWA::Edwards25519Point::C.times do
+      lhs = lhs.double()
+      rhs = rhs.double()
+    end
+    # Check eq. holds?
+    return lhs == rhs
+  end
+
+  # def verify(sig, m, pk)
+  #   return false if sig.bytesize != C_signaturebytes
+  #   return false if pk.bytesize != C_publickeybytes
+  #   r, s = sig[0, 32], sig[32, 64]
+  #   a = C_B.decode(pk)
+  #   k = (OpenSSL::BN.new(Digest::SHA512.digest(r+pk+m).reverse, 2) % JOSE::JWA::Edwards25519Point::L).to_i
+  #   s_s = (OpenSSL::BN.new(s.reverse, 2)).to_i
+  #   lhs = C_B * s_s
+  #   rhs = C_B.decode(r) + (a * k)
+  #   return lhs == rhs
+  # end
+
+  def verify_ph(sig, m, pk)
+    return verify(sig, Digest::SHA512.digest(m), pk)
+  end
+
+end

data/lib/jose/jwa/ed25519_rbnacl.rb

@@ -0,0 +1,36 @@
+module JOSE::JWA::Ed25519_RbNaCl
+
+  extend self
+
+  def keypair(secret = nil)
+    secret ||= RbNaCl::Random.random_bytes(RbNaCl::Signatures::Ed25519::SEEDBYTES)
+    RbNaCl::Util.check_length(secret, RbNaCl::Signatures::Ed25519::SEEDBYTES, "secret")
+    pk = RbNaCl::Util.zeros(RbNaCl::Signatures::Ed25519::VERIFYKEYBYTES)
+    sk = RbNaCl::Util.zeros(RbNaCl::Signatures::Ed25519::SIGNINGKEYBYTES)
+    RbNaCl::Signatures::Ed25519::SigningKey.sign_ed25519_seed_keypair(pk, sk, secret) || fail(RbNaCl::CryptoError, "Failed to generate a key pair")
+    return pk, sk
+  end
+
+  def sk_to_pk(sk)
+    return sk[RbNaCl::Signatures::Ed25519::VERIFYKEYBYTES..-1]
+  end
+
+  def sign(m, sk)
+    signing_key = RbNaCl::Signatures::Ed25519::SigningKey.allocate
+    signing_key.instance_variable_set(:@signing_key, sk)
+    return signing_key.sign(m)
+  end
+
+  def sign_ph(m, sk)
+    return sign(RbNaCl::Hash.sha512(m), sk)
+  end
+
+  def verify(sig, m, pk)
+    return RbNaCl::Signatures::Ed25519::VerifyKey.new(pk).verify(sig, m)
+  end
+
+  def verify_ph(sig, m, pk)
+    return verify(sig, RbNaCl::Hash.sha512(m), pk)
+  end
+
+end

data/lib/jose/jwa/ed448.rb

@@ -0,0 +1,166 @@
+module JOSE::JWA::Ed448
+
+  extend self
+
+  C_bits = 456
+  C_bytes = (C_bits + 7) / 8
+  C_secretbytes = C_bytes
+  C_legacysecretbytes = 32
+  C_publickeybytes = C_bytes
+  C_secretkeybytes = C_secretbytes + C_publickeybytes
+  C_legacysecretkeybytes = C_legacysecretbytes + C_publickeybytes
+  C_signaturebytes = C_bytes + C_bytes
+  C_B = JOSE::JWA::Edwards448Point.stdbase.freeze
+
+  def secret_to_curve448(secret)
+    raise ArgumentError, "secret must be #{C_secretbytes} bytes" if secret.bytesize != C_secretbytes and secret.bytesize != C_legacysecretbytes
+    curve448_scalar = JOSE::JWA::SHA3.shake256(secret, 114)[0, 56]
+    curve448_scalar.setbyte(0, curve448_scalar.getbyte(0) & 252)
+    curve448_scalar.setbyte(55, curve448_scalar.getbyte(55) | 128)
+    return curve448_scalar
+  end
+
+  def secret_to_pk(secret)
+    raise ArgumentError, "secret must be #{C_secretbytes} bytes" if secret.bytesize != C_secretbytes and secret.bytesize != C_legacysecretbytes
+    return (C_B * OpenSSL::BN.new(secret_to_curve448(secret).reverse, 2).to_i).encode()
+  end
+
+  def keypair(secret = nil)
+    secret ||= SecureRandom.random_bytes(C_secretbytes)
+    pk = secret_to_pk(secret)
+    sk = secret + pk
+    return pk, sk
+  end
+
+  def sk_to_secret(sk)
+    return sk[0, C_secretbytes] if sk.bytesize == C_secretkeybytes
+    return sk[0, C_legacysecretbytes] if sk.bytesize == C_legacysecretkeybytes
+    raise ArgumentError, "sk must be #{C_secretkeybytes} bytes"
+  end
+
+  def sk_to_pk(sk)
+    return sk[C_secretbytes, C_secretkeybytes] if sk.bytesize == C_secretkeybytes
+    return sk[C_legacysecretbytes, C_legacysecretkeybytes] if sk.bytesize == C_legacysecretkeybytes
+    raise ArgumentError, "sk must be #{C_secretkeybytes} bytes"
+  end
+
+  def sk_to_curve448(sk)
+    return secret_to_curve448(sk_to_secret(sk))
+  end
+
+  def pk_to_curve448(pk)
+    raise ArgumentError, "pk must be #{C_publickeybytes} bytes" if pk.bytesize != C_publickeybytes
+    a = C_B.decode(pk)
+    u = a.y.sqr / a.x.sqr
+    return u.to_bytes(448)
+  end
+
+  def sign(m, sk, ctx = nil)
+    raise ArgumentError, "sk must be #{C_secretkeybytes} bytes" if sk.bytesize != C_secretkeybytes and sk.bytesize != C_legacysecretkeybytes
+    ctx ||= ''
+    raise ArgumentError, "ctx must be 255 bytes or smaller" if ctx.bytesize > 255
+    secret, pk = nil, nil
+    if sk.bytesize == C_secretkeybytes
+      secret, pk = sk[0, 57], sk[57, 114]
+    elsif sk.bytesize == C_legacysecretkeybytes
+      secret, pk = sk[0, 32], sk[32, 89]
+    end
+    khash = JOSE::JWA::SHA3.shake256(secret, 114)
+    curve448_scalar, seed = khash[0, 57], khash[57, 114]
+    curve448_scalar.setbyte(0, curve448_scalar.getbyte(0) & 252)
+    curve448_scalar.setbyte(55, curve448_scalar.getbyte(55) | 128)
+    curve448_scalar.setbyte(56, 0)
+    a_s = OpenSSL::BN.new(curve448_scalar.reverse, 2).to_i
+    # Calculate r_s and r (r only used in encoded form)
+    r_s = (OpenSSL::BN.new(JOSE::JWA::SHA3.shake256(['SigEd448', 0, ctx.bytesize, ctx, seed, m].pack('A*CCA*A*A*'), 114).reverse, 2) % JOSE::JWA::Edwards448Point::L).to_i
+    r = (C_B * r_s).encode()
+    # Calculate h.
+    h = (OpenSSL::BN.new(JOSE::JWA::SHA3.shake256(['SigEd448', 0, ctx.bytesize, ctx, r, pk, m].pack('A*CCA*A*A*A*'), 114).reverse, 2) % JOSE::JWA::Edwards448Point::L).to_i
+    # Calculate s.
+    s = OpenSSL::BN.new((r_s+h*a_s) % JOSE::JWA::Edwards448Point::L).to_s(2).rjust(C_bytes, JOSE::JWA::ZERO_PAD).reverse
+    # The final signature is concatenation of r and s.
+    return r+s
+  end
+
+  def sign_ph(m, sk, ctx = nil)
+    raise ArgumentError, "sk must be #{C_secretkeybytes} bytes" if sk.bytesize != C_secretkeybytes and sk.bytesize != C_legacysecretkeybytes
+    ctx ||= ''
+    raise ArgumentError, "ctx must be 255 bytes or smaller" if ctx.bytesize > 255
+    m = JOSE::JWA::SHA3.shake256(['SigEd448', 2, ctx.bytesize, ctx, m].pack('A*CCA*A*'), 64)
+    secret, pk = nil, nil
+    if sk.bytesize == C_secretkeybytes
+      secret, pk = sk[0, 57], sk[57, 114]
+    elsif sk.bytesize == C_legacysecretkeybytes
+      secret, pk = sk[0, 32], sk[32, 89]
+    end
+    khash = JOSE::JWA::SHA3.shake256(secret, 114)
+    curve448_scalar, seed = khash[0, 57], khash[57, 114]
+    curve448_scalar.setbyte(0, curve448_scalar.getbyte(0) & 252)
+    curve448_scalar.setbyte(55, curve448_scalar.getbyte(55) | 128)
+    curve448_scalar.setbyte(56, 0)
+    a_s = OpenSSL::BN.new(curve448_scalar.reverse, 2).to_i
+    # Calculate r_s and r (r only used in encoded form)
+    r_s = (OpenSSL::BN.new(JOSE::JWA::SHA3.shake256(['SigEd448', 1, ctx.bytesize, ctx, seed, m].pack('A*CCA*A*A*'), 114).reverse, 2) % JOSE::JWA::Edwards448Point::L).to_i
+    r = (C_B * r_s).encode()
+    # Calculate h.
+    h = (OpenSSL::BN.new(JOSE::JWA::SHA3.shake256(['SigEd448', 1, ctx.bytesize, ctx, r, pk, m].pack('A*CCA*A*A*A*'), 114).reverse, 2) % JOSE::JWA::Edwards448Point::L).to_i
+    # Calculate s.
+    s = OpenSSL::BN.new((r_s+h*a_s) % JOSE::JWA::Edwards448Point::L).to_s(2).rjust(C_bytes, JOSE::JWA::ZERO_PAD).reverse
+    # The final signature is concatenation of r and s.
+    return r+s
+  end
+
+  def verify(sig, m, pk, ctx = nil)
+    ctx ||= ''
+    raise ArgumentError, "ctx must be 255 bytes or smaller" if ctx.bytesize > 255
+    # Sanity-check sizes.
+    return false if sig.bytesize != C_signaturebytes
+    return false if pk.bytesize != C_publickeybytes
+    # Split signature into R and S, and parse.
+    r, s = sig[0, 57], sig[57, 114]
+    r_p, s_s = C_B.decode(r), OpenSSL::BN.new(s.reverse, 2).to_i
+    # Parse public key.
+    a_p = C_B.decode(pk)
+    # Check parse results.
+    return false if r_p.nil? or a_p.nil? or s_s > JOSE::JWA::Edwards448Point::L
+    # Calculate h.
+    h = (OpenSSL::BN.new(JOSE::JWA::SHA3.shake256(['SigEd448', 0, ctx.bytesize, ctx, r, pk, m].pack('A*CCA*A*A*A*'), 114).reverse, 2) % JOSE::JWA::Edwards448Point::L).to_i
+    # Calculate left and right sides of check eq.
+    rhs = r_p + (a_p * h)
+    lhs = C_B * s_s
+    JOSE::JWA::Edwards448Point::C.times do
+      lhs = lhs.double()
+      rhs = rhs.double()
+    end
+    # Check eq. holds?
+    return lhs == rhs
+  end
+
+  def verify_ph(sig, m, pk, ctx = nil)
+    ctx ||= ''
+    raise ArgumentError, "ctx must be 255 bytes or smaller" if ctx.bytesize > 255
+    m = JOSE::JWA::SHA3.shake256(['SigEd448', 2, ctx.bytesize, ctx, m].pack('A*CCA*A*'), 64)
+    # Sanity-check sizes.
+    return false if sig.bytesize != C_signaturebytes
+    return false if pk.bytesize != C_publickeybytes
+    # Split signature into R and S, and parse.
+    r, s = sig[0, 57], sig[57, 114]
+    r_p, s_s = C_B.decode(r), OpenSSL::BN.new(s.reverse, 2).to_i
+    # Parse public key.
+    a_p = C_B.decode(pk)
+    # Check parse results.
+    return false if r_p.nil? or a_p.nil? or s_s > JOSE::JWA::Edwards448Point::L
+    # Calculate h.
+    h = (OpenSSL::BN.new(JOSE::JWA::SHA3.shake256(['SigEd448', 1, ctx.bytesize, ctx, r, pk, m].pack('A*CCA*A*A*A*'), 114).reverse, 2) % JOSE::JWA::Edwards448Point::L).to_i
+    # Calculate left and right sides of check eq.
+    rhs = r_p + (a_p * h)
+    lhs = C_B * s_s
+    JOSE::JWA::Edwards448Point::C.times do
+      lhs = lhs.double()
+      rhs = rhs.double()
+    end
+    # Check eq. holds?
+    return lhs == rhs
+  end
+
+end