Module: Secp256k1::ECDSA
- Included in:
- PrivateKey, PublicKey
- Defined in:
- lib/secp256k1/ecdsa.rb
Constant Summary collapse
- SIZE_SERIALIZED =
74
- SIZE_COMPACT =
64
Instance Method Summary collapse
- #ecdsa_deserialize(ser_sig) ⇒ Object
- #ecdsa_deserialize_compact(ser_sig) ⇒ Object
- #ecdsa_recover(msg, recover_sig, raw: false, digest: Digest::SHA256) ⇒ Object
- #ecdsa_recoverable_convert(recover_sig) ⇒ Object
- #ecdsa_recoverable_deserialize(ser_sig, rec_id) ⇒ Object
- #ecdsa_recoverable_serialize(recover_sig) ⇒ Object
- #ecdsa_serialize(raw_sig) ⇒ Object
- #ecdsa_serialize_compact(raw_sig) ⇒ Object
-
#ecdsa_signature_normalize(raw_sig, check_only: false) ⇒ Object
Check and optionally convert a signature to a normalized lower-S form.
Instance Method Details
#ecdsa_deserialize(ser_sig) ⇒ Object
18 19 20 21 22 23 24 25 |
# File 'lib/secp256k1/ecdsa.rb', line 18 def ecdsa_deserialize(ser_sig) raw_sig = C::ECDSASignature.new.pointer res = C.secp256k1_ecdsa_signature_parse_der(@ctx, raw_sig, ser_sig, ser_sig.size) raise AssertError, "raw signature parse failed" unless res == 1 raw_sig end |
#ecdsa_deserialize_compact(ser_sig) ⇒ Object
36 37 38 39 40 41 42 43 44 45 |
# File 'lib/secp256k1/ecdsa.rb', line 36 def ecdsa_deserialize_compact(ser_sig) raise ArgumentError, 'invalid signature length' unless ser_sig.size == 64 raw_sig = C::ECDSASignature.new.pointer res = C.secp256k1_ecdsa_signature_parse_compact(@ctx, raw_sig, ser_sig) raise AssertError, "failed to deserialize compact signature" unless res == 1 raw_sig end |
#ecdsa_recover(msg, recover_sig, raw: false, digest: Digest::SHA256) ⇒ Object
62 63 64 65 66 67 68 69 70 71 72 |
# File 'lib/secp256k1/ecdsa.rb', line 62 def ecdsa_recover(msg, recover_sig, raw: false, digest: Digest::SHA256) raise AssertError, 'instance not configured for ecdsa recover' if (@flags & ALL_FLAGS) != ALL_FLAGS msg32 = hash32 msg, raw, digest pubkey = C::Pubkey.new.pointer res = C.secp256k1_ecdsa_recover(@ctx, pubkey, recover_sig, msg32) raise AssertError, 'failed to recover ECDSA public key' unless res == 1 pubkey end |
#ecdsa_recoverable_convert(recover_sig) ⇒ Object
95 96 97 98 99 |
# File 'lib/secp256k1/ecdsa.rb', line 95 def ecdsa_recoverable_convert(recover_sig) normal_sig = C::ECDSASignature.new.pointer C.secp256k1_ecdsa_recoverable_signature_convert(@ctx, normal_sig, recover_sig) normal_sig end |
#ecdsa_recoverable_deserialize(ser_sig, rec_id) ⇒ Object
83 84 85 86 87 88 89 90 91 92 93 |
# File 'lib/secp256k1/ecdsa.rb', line 83 def ecdsa_recoverable_deserialize(ser_sig, rec_id) raise ArgumentError, 'invalid rec_id' if rec_id < 0 || rec_id > 3 raise ArgumentError, 'invalid signature length' if ser_sig.size != 64 recover_sig = C::ECDSARecoverableSignature.new.pointer res = C.secp256k1_ecdsa_recoverable_signature_parse_compact(@ctx, recover_sig, ser_sig, rec_id) raise AssertError, 'failed to parse ECDSA compact sig' unless res == 1 recover_sig end |
#ecdsa_recoverable_serialize(recover_sig) ⇒ Object
74 75 76 77 78 79 80 81 |
# File 'lib/secp256k1/ecdsa.rb', line 74 def ecdsa_recoverable_serialize(recover_sig) output = FFI::MemoryPointer.new :uchar, SIZE_COMPACT recid = FFI::MemoryPointer.new :int C.secp256k1_ecdsa_recoverable_signature_serialize_compact(@ctx, output, recid, recover_sig) [output.read_bytes(SIZE_COMPACT), recid.read_int] end |
#ecdsa_serialize(raw_sig) ⇒ Object
8 9 10 11 12 13 14 15 16 |
# File 'lib/secp256k1/ecdsa.rb', line 8 def ecdsa_serialize(raw_sig) output = FFI::MemoryPointer.new(:uchar, SIZE_SERIALIZED) outputlen = FFI::MemoryPointer.new(:size_t).put_uint(0, SIZE_SERIALIZED) res = C.secp256k1_ecdsa_signature_serialize_der(@ctx, output, outputlen, raw_sig) raise AssertError, "failed to seriazlie signature" unless res == 1 output.read_bytes(outputlen.read_uint) end |
#ecdsa_serialize_compact(raw_sig) ⇒ Object
27 28 29 30 31 32 33 34 |
# File 'lib/secp256k1/ecdsa.rb', line 27 def ecdsa_serialize_compact(raw_sig) output = FFI::MemoryPointer.new(:uchar, SIZE_COMPACT) res = C.secp256k1_ecdsa_signature_serialize_compact(@ctx, output, raw_sig) raise AssertError, "failed to seriazlie compact signature" unless res == 1 output.read_bytes(SIZE_COMPACT) end |
#ecdsa_signature_normalize(raw_sig, check_only: false) ⇒ Object
Check and optionally convert a signature to a normalized lower-S form. If check_only is ‘true` then the normalized signature is not returned.
This function always return a tuple containing a boolean (‘true` if not previously normalized or `false` if signature was already normalized), and the normalized signature. When check_only is `true`, the normalized signature returned is always `nil`.
56 57 58 59 60 |
# File 'lib/secp256k1/ecdsa.rb', line 56 def ecdsa_signature_normalize(raw_sig, check_only: false) sigout = check_only ? nil : C::ECDSASignature.new.pointer res = C.secp256k1_ecdsa_signature_normalize(@ctx, sigout, raw_sig) [res == 1, sigout] end |