rbsecp256k1 3.0.1 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 529c72afdaa5cd79bc685fd28661d367be89a019366e9b9d46bb9db7dd99e499
-  data.tar.gz: 21d2af92f7c0c696f2a36b6a6de4c330f0dac30078a1d61327e3e22bb80bd4ef
+  metadata.gz: e0bda0a3b5513e2716322c5bd47668b1fe17493ee6a542848d4d3add50cabd67
+  data.tar.gz: 45d1d8dccfa8303b5d750f270dd65331ae6c72948982863e430628cfe9ce2b9a
 SHA512:
-  metadata.gz: 2d32348b294c9e75ac950f1be1ae2dc0de0c1a31a3038da397426dc56f5cde637a453037f0e5dab0c6bb7bc1761f9afc6934c2f804d328bb4f31279754ec1584
-  data.tar.gz: '03028eee4ffcf8d8df75488444a8fc963ffa2e10fceb0ac4ac9fb8762f5c403594d74eafedf110ff2c955091fb2d9f76257a5517c7f80fdd2bccc6e2274d6882'
+  metadata.gz: 980d07a3fb920d7c873aca6969dc7102896379005e5a30741f637387fd43c06efdfddb09905e5c24a1dd1bb780211ebe9d46e3a8d16f02f95bf0a180cc6a7652
+  data.tar.gz: acb8d3284c484d946a5e22ebb4f4f2fb2c72f4e0e1e3b9bdb5b8beed2890283c361a14eda2453817401c0a8d98ace34219208f10d8997d98d21ef49766843d0c

data/documentation/context.md

@@ -0,0 +1,66 @@
+[Index](index.md)
+
+Secp256k1::Context
+==================
+
+Secp256k1::Context represents a libsecp256k1 context object. Contexts are
+thread-safe and initialization is expensive, so a single context should be used
+for multiple operations as much as possible.
+
+Initializers
+------------
+
+#### new
+
+Returns a newly initialized libsecp256k1 context. The context is randomized at
+initialization.
+
+Instance Methods
+----------------
+
+#### ecdh(point, scalar)
+
+**Requires:** libsecp256k1 was built with the experimental ECDH module.
+
+Takes a `point` ([PublicKey](public_key.md)) and a `scalar` ([PrivateKey](private_key.md)) and returns a new
+[SharedSecret](shared_secret.md) containing the 32-byte shared secret. Raises a `RuntimeError` if
+the `scalar` is invalid (zero or causes an overflow).
+
+#### generate_key_pair
+
+Generates and returns a new [KeyPair](key_pair.md) using a cryptographically
+secure random number generator (CSRNG) provided by OpenSSL.
+
+#### key_pair_from_private_key(private_key_data)
+
+Returns a new [KeyPair](key_pair.md) from the given `private_key_data`. The
+`private_key_data` is expected to be a binary string. Raises a `RuntimeError`
+if the private key is invalid or key derivation fails.
+
+#### recoverable_signature_from_compact(compact_signature, recovery_id)
+
+**Requires:** libsecp256k1 was build with recovery module.
+
+Attempts to load a [RecoverableSignature](recoverable_signature.md) from the given `compact_signature`
+and `recovery_id`. Raises a RuntimeError if the signature data or recovery ID are invalid.
+
+#### sign(private_key, hash32)
+
+Signs the SHA-256 hash given by `hash32` using `private_key` and returns a new
+[Signature](signature.md). The `private_key` is expected to be a [PrivateKey](private_key.md)
+object and `data` can be either a binary string or text.
+
+#### sign_recoverable(private_key, hash32)
+
+**Requires:** libsecp256k1 was build with recovery module.
+
+Signs the data represented by the SHA-256 hash `hash32` using `private_key` and returns a
+new [RecoverableSignature](recoverable_signature.md). The `private_key` is expected to be a [PrivateKey](private_key.md) and
+`data` can be either a binary string or text.
+
+#### verify(signature, public_key, hash32)
+
+Verifies the given `signature` ([Signature](signature.md)) was signed by
+the private key corresponding to `public_key` ([PublicKey](public_key.md)) and signed `hash32`. Returns `true`
+if `signature` is valid or `false` otherwise. Note that `data` can be either a
+text or binary string.

data/documentation/index.md

@@ -0,0 +1,319 @@
+rbsecp256k1 Reference
+=====================
+
+Find your topic in the index, or refer to one of the examples below.
+
+Classes and Modules
+-------------------
+
+| Module                     | Classes                                          | Utilities
+|----------------------------|:-------------------------------------------------|:--------------------------------
+| [Secp256k1](secp256k1.md)  | [Context](context.md)                            | [Util](util.md)
+|                            | [KeyPair](key_pair.md)                           |
+|                            | [PublicKey](public_key.md)                       |
+|                            | [PrivateKey](private_key.md)                     |
+|                            | [SharedSecret](shared_secret.md)                 |
+|                            | [Signature](signature.md)                        |
+|                            | [RecoverableSignature](recoverable_signature.md) |
+
+Glossary
+--------
+
+**[Context](context.md)** is a libsecp256k1 library context. It contains
+pre-computed tables and values to make ECDSA signing and verification more
+efficient.
+
+**[KeyPair](key_pair.md)** is a Secp256k1 elliptic-curve key pair.
+
+**[PublicKey](public_key.md)** is a Secp256k1 public key. It can come in either
+compressed or uncompressed format.
+
+**[PrivateKey](private_key.md)** is a 64-byte Secp256k1 private key.
+
+**[SharedSecret](shared_secret.md)** A 32-byte shared secret computed from a
+public key (point) and private key (scalar).
+
+**[Signature](signature.md)** is an ECDSA signature of the SHA-256 message hash
+of a piece of data.
+
+**[RecoverableSignature](recoverable_signature.md)** is a recoverable ECDSA signature of the SHA-256 message
+hash of a piece of data.
+
+Examples
+--------
+
+### 1. Creating a libsecp256k1 context
+
+This example demonstrates how to create a new libsecp256k1 context. This is the
+first step of using this library:
+
+```ruby
+context = Secp256k1::Context.new
+# => #<Secp256k1::Context:0x0000559b0bd8f5d0>
+```
+
+### 2. Generating a key pair
+
+This example shows how to generate a new public-private key pair:
+
+```ruby
+context = Secp256k1::Context.new
+key_pair = context.generate_key_pair
+# => #<Secp256k1::KeyPair:0x0000559b0bc876b0 @public_key=#<Secp256k1::PublicKey:0x0000559b0bc876d8>, @private_key=#<Secp256k1::PrivateKey:0x0000559b0bc87700 @data="\r\xA7\xB3<\x92\xCDw\xC1\xDB\xEB[BB;=\x80\xB83\xA8]\x06\xD9\x90\xF8v\xFFi\xF0/\x1E\x96\xF9">>
+```
+
+### 3. Getting compressed and uncompressed public key representations
+
+This example shows how to generate compressed and uncompressed public keys:
+
+```ruby
+context = Secp256k1::Context.new
+key_pair = context.generate_key_pair
+
+# 1. Get the binary representation of compressed public key
+key_pair.public_key.compressed
+# => "\x03D\x88\xD6 3|3\x836\xCB(\x9CW%\xF4T\xB7\xCD\x8AF T\xE7\xE8\xCE\xB0\xC7c{\xE2:\xFE"
+
+# 2. Show hex representation of compressed public key
+Secp256k1::Util.bin_to_hex(key_pair.public_key.compressed)
+# => "034488d620337c338336cb289c5725f454b7cd8a462054e7e8ceb0c7637be23afe"
+
+# 3. Get the binary representation of uncompressed public key
+key_pair.public_key.uncompressed
+# => "\x04D\x88\xD6 3|3\x836\xCB(\x9CW%\xF4T\xB7\xCD\x8AF T\xE7\xE8\xCE\xB0\xC7c{\xE2:\xFE XRew\x1F\e\x05\xC8\xDC\xA7\xE3\x8C\xBD\x91s?\xFCW\xD5\xB3\xA8aaCCG\xD4\x94m\xA5c"
+
+# 4. Show hex representation of uncompressed public key
+Secp256k1::Util.bin_to_hex(key_pair.public_key.uncompressed)
+# => "044488d620337c338336cb289c5725f454b7cd8a462054e7e8ceb0c7637be23afe20585265771f1b05c8dca7e38cbd91733ffc57d5b3a86161434347d4946da563"
+```
+
+### 3. Signing a message
+
+This example shows how to sign a message using your private key:
+
+```ruby
+require 'digest'
+
+context = Secp256k1::Context.new
+key_pair = context.generate_key_pair
+
+signature = context.sign(key_pair.private_key, Digest::SHA256.digest("test message"))
+# => #<Secp256k1::Signature:0x0000559b0bc79358>
+```
+
+### 4. Getting DER and Compact signature encodings
+
+This example shows you how to get the DER encoded and compact encoded
+representations of a signature:
+
+```ruby
+require 'digest'
+
+context = Secp256k1::Context.new
+key_pair = context.generate_key_pair
+
+signature = context.sign(key_pair.private_key, Digest::SHA256.digest("test message"))
+
+# 1. Get the compact binary representation
+signature.compact
+# => "\xAB#e6_\x866\e\xAC\e\x92W\xC8a\x84N\xD4\xB6\x88\xF8\xEE\xDF\xFBC\xE8j\xB2\xF0\x10\xB8\xA0\x89\x13L\e\x9E\x91cB\xD7\xAC\x11\xF7\x02,Y&TM\xA5zp\xFD\xB3\xB1\xDCIV\xBB\\\xAF\x16@\xFC\x00"
+
+# 2. Get the compact hex representation
+Secp256k1::Util.bin_to_hex(signature.compact)
+# => "ab2365365f86361bac1b9257c861844ed4b688f8eedffb43e86ab2f010b8a089134c1b9e916342d7ac11f7022c5926544da57a70fdb3b1dc4956bb5caf1640fc00"
+
+# 3. Get the DER binary representation
+signature.der_encoded
+# => "0E\x02!\x00\xAB#e6_\x866\e\xAC\e\x92W\xC8a\x84N\xD4\xB6\x88\xF8\xEE\xDF\xFBC\xE8j\xB2\xF0\x10\xB8\xA0\x89\x02 \x13L\e\x9E\x91cB\xD7\xAC\x11\xF7\x02,Y&TM\xA5zp\xFD\xB3\xB1\xDCIV\xBB\\\xAF\x16@\xFC"
+
+# 4. Get the DER hex representation
+Secp256k1::Util.bin_to_hex(signature.der_encoded)
+# => "3045022100ab2365365f86361bac1b9257c861844ed4b688f8eedffb43e86ab2f010b8a0890220134c1b9e916342d7ac11f7022c5926544da57a70fdb3b1dc4956bb5caf1640fc"
+```
+
+### 5. Verifying a signature
+
+This example shows how to verify a signature using a public key:
+
+```ruby
+require 'digest'
+
+context = Secp256k1::Context.new
+key_pair = context.generate_key_pair
+hash = Digest::SHA256.digest("test message")
+
+signature = context.sign(key_pair.private_key, hash)
+
+# 1. Verify signature against matching message
+context.verify(signature, key_pair.public_key, hash)
+# => true
+
+# 2. Verify signature against different message
+context.verify(signature, key_pair.public_key, hash)
+# => false
+```
+
+### 6. Loading a private key or key pair from private key data
+
+This example shows how to load a key pair from raw binary private key data:
+
+```ruby
+context = Secp256k1::Context.new
+
+#1. Load private key alone
+private_key = Secp256k1::PrivateKey.from_data("I\nX\x85\xAEz}\n\x9B\xA4\\\x81)\xD4\x9Aq\xFDH\t\xBE\x8EP\xC5.\xC6\x1F7-\x86\xA0\xCB\xF9")
+# => #<Secp256k1::PrivateKey:0x00005647df1bcd30 @data="I\nX\x85\xAEz}\n\x9B\xA4\\\x81)\xD4\x9Aq\xFDH\t\xBE\x8EP\xC5.\xC6\x1F7-\x86\xA0\xCB\xF9">
+
+# 2. Load key pair from private key data
+key_pair = context.key_pair_from_private_key("I\nX\x85\xAEz}\n\x9B\xA4\\\x81)\xD4\x9Aq\xFDH\t\xBE\x8EP\xC5.\xC6\x1F7-\x86\xA0\xCB\xF9")
+# => #<Secp256k1::KeyPair:0x0000559b0bbf9a90 @public_key=#<Secp256k1::PublicKey:0x0000559b0bbf9ab8>, @private_key=#<Secp256k1::PrivateKey:0x0000559b0bbf9ae0 @data="I\nX\x85\xAEz}\n\x9B\xA4\\\x81)Ԛq\xFDH\t\xBE\x8EP\xC5.\xC6\u001F7-\x86\xA0\xCB\xF9">>
+```
+
+### 7. Loading a public key from binary data
+
+This example shows how to load a public key from binary data:
+
+```ruby
+# 1. Load public key from uncompressed pubkey
+public_key = Secp256k1::PublicKey.from_data("\x04$\xA2\xE7\xBB1\xC4|tN\xE6\xE4J-\xED\x9A[\xAFf-<\x14\x84^QQ\"\x14\xC3\x91\xE4\xF2\xB5\xEEEj\xAB\xD9\xFE\b\e7Zk\xC5{k\x12\xE3\xEA\xA2\xA5\xD7\xC1\xA5&\xE5|:K\xA9 X\xA3\x90")
+# => #<Secp256k1::PublicKey:0x0000559b0bdc72f0>
+
+# 2. Load public key from compressed pubkey
+public_key = Secp256k1::PublicKey.from_data("\x02$\xA2\xE7\xBB1\xC4|tN\xE6\xE4J-\xED\x9A[\xAFf-<\x14\x84^QQ\"\x14\xC3\x91\xE4\xF2\xB5")
+# => #<Secp256k1::PublicKey:0x0000559b0bdd3668>
+```
+
+### 8. Loading a DER or compact encoded signature
+
+This example shows how to load signatures from binary data:
+
+```ruby
+# 1. From DER encoded signature
+signature = Secp256k1::Signature.from_der_encoded("0D\x02 <\xC6\x7F/\x921l\x89Z\xFBs\x89p\xEE\x18u\x8B\x92\x9D\xA6\x84\xC5Y<t\xB7\xF1\f\xEE\f\x81J\x02 \t\"\xDF]\x1D\xA7W@^\xAAokH\b\x00\xE2L\xCF\x82\xA3\x05\x1E\x00\xF9\xFC\xB19\x0F\x93|\xB1f")
+# => #<Secp256k1::Signature:0x0000559b0b823d58>
+
+# 2. From compact signature
+signature = Secp256k1::Signature.from_compact("<\xC6\x7F/\x921l\x89Z\xFBs\x89p\xEE\x18u\x8B\x92\x9D\xA6\x84\xC5Y<t\xB7\xF1\f\xEE\f\x81J\t\"\xDF]\x1D\xA7W@^\xAAokH\b\x00\xE2L\xCF\x82\xA3\x05\x1E\x00\xF9\xFC\xB19\x0F\x93|\xB1f\x00")
+# => #<Secp256k1::Signature:0x0000559b0bdcaa68>
+```
+
+Recoverable Signature Examples
+------------------------------
+
+### 1. Checking for recovery module
+
+To check if you have compiled the recovery module into your local libsecp256k1
+run the following:
+
+```ruby
+Secp256k1.have_recovery?
+# => true
+```
+
+### 2. Sign data producing recoverable signature
+
+You can sign data producing a recoverable signature as follows:
+
+```ruby
+require 'digest'
+
+hash = Digest::SHA256.digest('test message')
+context = Secp256k1::Context.new
+key_pair = context.generate_key_pair
+
+signature = context.sign_recoverable(key_pair.private_key, hash)
+# => #<Secp256k1::RecoverableSignature:0x000055f2ea76e548>
+```
+
+### 3. Serialize recoverable signature as compact representation
+
+You can produce the compact binary serialization of a recoverable signature:
+
+```ruby
+require 'digest'
+
+hash = Digest::SHA256.digest('test message')
+context = Secp256k1::Context.new
+key_pair = context.generate_key_pair
+
+signature = context.sign_recoverable(key_pair.private_key, hash)
+compact_data, recovery_id = signature.compact
+# => ["D,\x9C\xA6%I\x14-\xCA\xC0\x11\x0F\xEB\x1E\xB0\xB6\\-\xE2\b\x98\xFB\xEA\xD5\x9BZ\xE6\xDF#\xC1\x1A\xEEL\xF02\xB1\xE9{\r\xEBhh<\\\xCF\xB6\x98\xEA\x8F\xF65\xF2\xBF\x84\xD8\xE5x\xF0\xA5)\xA2Wb\x9D", 1]
+```
+
+### 4. Recoverable signature from compact representation
+
+You can load a recoverable signature give its compact representation and
+recovery ID:
+
+```ruby
+context = Secp256k1::Context.new
+
+compact_data = "D,\x9C\xA6%I\x14-\xCA\xC0\x11\x0F\xEB\x1E\xB0\xB6\\-\xE2\b\x98\xFB\xEA\xD5\x9BZ\xE6\xDF#\xC1\x1A\xEEL\xF02\xB1\xE9{\r\xEBhh<\\\xCF\xB6\x98\xEA\x8F\xF65\xF2\xBF\x84\xD8\xE5x\xF0\xA5)\xA2Wb\x9D"
+recovery_id = 1
+
+signature = context.recoverable_signature_from_compact(compact_data, recovery_id)
+# => #<Secp256k1::RecoverableSignature:0x000055f2ea7615c8>
+```
+
+### 5. Convert recoverable signature to non-recoverable signature
+
+You can convert a recoverable signature to a non-recoverable signature suitable
+for use by all methods that take a [Signature](signature.md) object:
+
+```ruby
+require 'digest'
+
+hash = Digest::SHA256.digest('test message')
+context = Secp256k1::Context.new
+key_pair = context.generate_key_pair
+
+recoverable_signature = context.sign_recoverable(key_pair.private_key, hash)
+signature = recoverable_signature.to_signature
+# => #<Secp256k1::Signature:0x000055f2ea8ca4f0>
+```
+
+### 6. Recover public key from recoverable signature
+
+You can recover the [PublicKey](public_key.md) associated with a recoverable signature:
+
+```ruby
+require 'digest'
+
+hash = Digest::SHA256.digest('test message')
+context = Secp256k1::Context.new
+key_pair = context.generate_key_pair
+
+recoverable_signature = context.sign_recoverable(key_pair.private_key, hash)
+public_key = recoverable_signature.recover_public_key(hash)
+# => #<Secp256k1::PublicKey:0x000055f2ea756678>
+
+public_key == key_pair.public_key
+# => true
+```
+
+EC Diffie-Hellman
+-----------------
+
+### 1. Checking for ECDH module
+
+To check if you have compiled the ECDH module into your local libsecp256k1 run
+the following:
+
+```ruby
+Secp256k1.have_ecdh?
+# => true
+```
+
+### 2. Generating a shared secret
+
+To generate a shared secret run the following:
+
+```ruby
+context = Secp256k1::Context.new
+key_pair = context.generate_key_pair
+
+shared_secret = context.ecdh(key_pair.public_key, key_pair.private_key)
+shared_secret.data
+# => "\x1FQ\x90X\xA5\xF2\xAEx;\xD7i\xB6\\T,2[\x90\xD1)a$\x1CA\x17\x8F\e\x91\xE3\x06C\x93"
+```

data/documentation/key_pair.md

@@ -0,0 +1,28 @@
+[Index](index.md)
+
+Secp256k1::KeyPair
+==================
+
+Secp256k1::KeyPair represents a public-private Secp256k1 key pair.
+
+Initializers
+------------
+
+#### new(public_key, private_key)
+
+Initializes a new key pair with `public_key` (type: [PublicKey](public_key.md)) and `private_key` (type: [PrivateKey](private_key.md)).
+
+Instance Methods
+----------------
+
+#### public_key
+
+Returns the [PublicKey](public_key.md) part of this key pair.
+
+#### private_key
+
+Returns the [PrivateKey](private_key.md) part of this key pair.
+
+#### ==(other)
+
+Returns `true` if the `other` has the same public and private key.

data/documentation/private_key.md

@@ -0,0 +1,25 @@
+[Index](index.md)
+
+Secp256k1::PrivateKey
+=====================
+
+Secp256k1::PrivateKey represents the private key part of a public-private key pair.
+
+Class Methods
+-------------
+
+#### from_data(private_key_data)
+
+Loads new private key from the given binary `private_key_data` string. Raises
+`ArgumentError` if the given data is invalid.
+
+Instance Methods
+----------------
+
+#### data
+
+Returns the binary private key data as a `String`.
+
+#### ==(other)
+
+Returns `true` if this private key matches `other`.

data/documentation/public_key.md

@@ -0,0 +1,32 @@
+[Index](index.md)
+
+Secp256k1::PublicKey
+====================
+
+Secp256k1::PublicKey represents the public key part of a public-private key pair.
+
+See: [KeyPair](key_pair.md)
+
+Class Methods
+-------------
+
+#### from_data(public_key_data)
+
+Parses compressed or uncompressed from binary string `public_key_data` and
+creates and returns a new public key from it. Raises a `RuntimeError` if the
+given public key data is invalid.
+
+Instance Methods
+----------------
+
+#### compressed
+
+Returns the binary compressed representation of this public key.
+
+#### uncompressed
+
+Returns the binary uncompressed representation of this public key.
+
+#### ==(other)
+
+Return `true` if this public key matches `other`.

data/documentation/recoverable_signature.md

@@ -0,0 +1,30 @@
+[Index](index.md)
+
+Secp256k1::RecoverableSignature
+===============================
+
+**Requires:** libsecp256k1 was build with recovery module.
+
+Secp256k1::RecoverableSignature represents a recoverable ECDSA signature
+signing the 32-byte SHA-256 hash of some data.
+
+Instance Methods
+----------------
+
+#### compact
+
+Returns an array whose first element is the 64-byte compact signature as a
+binary string and whose second element is the integer recovery ID.
+
+#### recover_public_key
+
+Recovers the public key corresponding to the recoverable signature. Returns a
+[PublicKey](public_key.md).
+
+#### to_signature
+
+Converts a recoverable signature to a non-recoverable [Signature](signature.md) object.
+
+#### ==(other)
+
+Returns `true` if this recoverable signature matches `other`.

data/documentation/secp256k1.md

@@ -0,0 +1,19 @@
+[Index](index.md)
+
+Secp256k1
+=========
+
+Secp256k1 is the top-level module for this library.
+
+Class Methods
+-------------
+
+#### have_recovery?
+
+Returns `true` if the recovery module was built with libsecp256k1, `false`
+otherwise.
+
+#### have_ecdh?
+
+Returns `true` if the EC Diffie-Hellman module was built with libsecp256k1,
+`false` otherwise.

data/documentation/shared_secret.md

@@ -0,0 +1,16 @@
+[Index](index.md)
+
+Secp256k1::SharedSecret
+=======================
+
+**Requires:** libsecp256k1 was build with ECDH module.
+
+Secp256k1::SharedSecret represents a 32-byte shared secret computed from a
+public key (point) and private key (scalar).
+
+Instance Methods
+----------------
+
+#### data
+
+Binary string containing the 32-byte shared secret.

data/documentation/signature.md

@@ -0,0 +1,42 @@
+[Index](index.md)
+
+Secp256k1::Signature
+====================
+
+Secp256k1::Signature represents an ECDSA signature signing the 32-byte SHA-256
+hash of some data.
+
+Class Methods
+-------------
+
+#### from_compact(compact_signature)
+
+Parses a signature from binary string `compact_signature`. Raises a
+`RuntimeError` ig the signature data is invalid.
+
+#### from_der_encoded(der_encoded_signature)
+
+Parses a signature from binary string `der_encoded_signature`. Raises a
+`RuntimeError` ig the signature data is invalid.
+
+Instance Methods
+----------------
+
+#### der_encoded
+
+Returns the DER encoded representation of this signature.
+
+#### compact
+
+Returns the compact 64-byte representation of this signature.
+
+#### normalized
+
+Returns an array containing two elements. The first is a Boolean indicating
+whether or not the signature was normalized, false if it was already in lower-S
+normal form. The second element is a `Signature` containing the normalized
+signature object.
+
+#### ==(other)
+
+Returns `true` if this signature matches `other`.

data/documentation/util.md

@@ -0,0 +1,17 @@
+[Index](index.md)
+
+Secp256k1::Util
+===============
+
+Secp256k1::Util in a module containing generally useful methods for using the library.
+
+Class Methods
+-------------
+
+#### bin_to_hex(binary_data)
+
+Returns the hexadecimal string representation of `binary_data`
+
+#### hex_to_bin(hex_string)
+
+Returns the binary string representation of `hex_string`

data/ext/rbsecp256k1/rbsecp256k1.c

@@ -87,17 +87,14 @@ typedef struct KeyPair_dummy {
 
 typedef struct PublicKey_dummy {
   secp256k1_pubkey pubkey; // Opaque object containing public key data
-  secp256k1_context *ctx;
 } PublicKey;
 
 typedef struct PrivateKey_dummy {
   unsigned char data[32]; // Bytes comprising the private key data
-  secp256k1_context *ctx;
 } PrivateKey;
 
 typedef struct Signature_dummy {
   secp256k1_ecdsa_signature sig; // Signature object, contains 64-byte signature
-  secp256k1_context *ctx;
 } Signature;
 
 #ifdef HAVE_SECP256K1_RECOVERY_H
@@ -140,7 +137,6 @@ PublicKey_free(void *in_public_key)
 {
   PublicKey *public_key;
   public_key = (PublicKey*)in_public_key;
-  secp256k1_context_destroy(public_key->ctx);
   xfree(public_key);
 }
 
@@ -157,7 +153,6 @@ PrivateKey_free(void *in_private_key)
 {
   PrivateKey *private_key;
   private_key = (PrivateKey*)in_private_key;
-  secp256k1_context_destroy(private_key->ctx);
   xfree(private_key);
 }
 
@@ -197,7 +192,6 @@ static void
 Signature_free(void *in_signature)
 {
   Signature *signature = (Signature*)in_signature;
-  secp256k1_context_destroy(signature->ctx);
   xfree(signature);
 }
 
@@ -471,13 +465,11 @@ PublicKey_create_from_private_key(Context *in_context,
     rb_raise(rb_eTypeError, "invalid private key data");
   }
 
-  public_key->ctx = secp256k1_context_clone(in_context->ctx);
   return result;
 }
 
 static VALUE
-PublicKey_create_from_data(Context *in_context,
-                           unsigned char *in_public_key_data,
+PublicKey_create_from_data(unsigned char *in_public_key_data,
                            unsigned int in_public_key_data_len)
 {
   PublicKey *public_key;
@@ -486,7 +478,7 @@ PublicKey_create_from_data(Context *in_context,
   result = PublicKey_alloc(Secp256k1_PublicKey_class);
   TypedData_Get_Struct(result, PublicKey, &PublicKey_DataType, public_key);
 
-  if (secp256k1_ec_pubkey_parse(in_context->ctx,
+  if (secp256k1_ec_pubkey_parse(secp256k1_context_no_precomp,
                                 &(public_key->pubkey),
                                 in_public_key_data,
                                 in_public_key_data_len) != 1)
@@ -494,10 +486,31 @@ PublicKey_create_from_data(Context *in_context,
     rb_raise(rb_eRuntimeError, "invalid public key data");
   }
 
-  public_key->ctx = secp256k1_context_clone(in_context->ctx);
   return result;
 }
 
+/**
+ * Loads a public key from compressed or uncompressed binary data.
+ *
+ * @param in_public_key_data [String] binary string with compressed or
+ *   uncompressed public key data.
+ * @return [Secp256k1::PublicKey] public key derived from data.
+ * @raise [RuntimeError] if public key data is invalid.
+ */
+static VALUE
+PublicKey_from_data(VALUE klass, VALUE in_public_key_data)
+{
+  unsigned char *public_key_data;
+
+  Check_Type(in_public_key_data, T_STRING);
+
+  public_key_data = (unsigned char*)StringValuePtr(in_public_key_data);
+  return PublicKey_create_from_data(
+    public_key_data,
+    (int)RSTRING_LEN(in_public_key_data)
+  );
+}
+
 /**
  * @return [String] binary string containing the uncompressed representation
  *   of this public key.
@@ -512,7 +525,7 @@ PublicKey_uncompressed(VALUE self)
 
   TypedData_Get_Struct(self, PublicKey, &PublicKey_DataType, public_key);
 
-  secp256k1_ec_pubkey_serialize(public_key->ctx,
+  secp256k1_ec_pubkey_serialize(secp256k1_context_no_precomp,
                                 serialized_pubkey,
                                 &serialized_pubkey_len,
                                 &(public_key->pubkey),
@@ -535,7 +548,7 @@ PublicKey_compressed(VALUE self)
 
   TypedData_Get_Struct(self, PublicKey, &PublicKey_DataType, public_key);
 
-  secp256k1_ec_pubkey_serialize(public_key->ctx,
+  secp256k1_ec_pubkey_serialize(secp256k1_context_no_precomp,
                                 serialized_pubkey,
                                 &serialized_pubkey_len,
                                 &(public_key->pubkey),
@@ -569,14 +582,14 @@ PublicKey_equals(VALUE self, VALUE other)
   TypedData_Get_Struct(other, PublicKey, &PublicKey_DataType, rhs);
 
   secp256k1_ec_pubkey_serialize(
-    lhs->ctx,
+    secp256k1_context_no_precomp,
     lhs_compressed,
     &lhs_len,
     &(lhs->pubkey),
     SECP256K1_EC_COMPRESSED
   );
   secp256k1_ec_pubkey_serialize(
-    rhs->ctx,
+    secp256k1_context_no_precomp,
     rhs_compressed,
     &rhs_len,
     &(rhs->pubkey),
@@ -610,12 +623,13 @@ PrivateKey_alloc(VALUE klass)
 }
 
 static VALUE
-PrivateKey_create(Context *in_context, unsigned char *in_private_key_data)
+PrivateKey_create(unsigned char *in_private_key_data)
 {
   PrivateKey *private_key;
   VALUE result;
 
-  if (secp256k1_ec_seckey_verify(in_context->ctx, in_private_key_data) != 1)
+  if (secp256k1_ec_seckey_verify(secp256k1_context_no_precomp,
+                                 in_private_key_data) != 1)
   {
     rb_raise(rb_eArgError, "invalid private key data");
   }
@@ -623,13 +637,35 @@ PrivateKey_create(Context *in_context, unsigned char *in_private_key_data)
   result = PrivateKey_alloc(Secp256k1_PrivateKey_class);
   TypedData_Get_Struct(result, PrivateKey, &PrivateKey_DataType, private_key);
   MEMCPY(private_key->data, in_private_key_data, char, 32);
-  private_key->ctx = secp256k1_context_clone(in_context->ctx);
 
   rb_iv_set(result, "@data", rb_str_new((char*)in_private_key_data, 32));
 
   return result;
 }
 
+/**
+ * Load a private key from binary data.
+ *
+ * @param in_private_key_data [String] 32 byte binary string of private key
+ *   data.
+ * @return [Secp256k1::PrivateKey] private key loaded from the given data.
+ * @raise [ArgumentError] if private key data is not 32 bytes or is invalid.
+ */
+static VALUE
+PrivateKey_from_data(VALUE klass, VALUE in_private_key_data)
+{
+  unsigned char *private_key_data;
+
+  Check_Type(in_private_key_data, T_STRING);
+  if (RSTRING_LEN(in_private_key_data) != 32)
+  {
+    rb_raise(rb_eArgError, "private key data must be 32 bytes in length");
+  }
+
+  private_key_data = (unsigned char*)StringValuePtr(in_private_key_data);
+  return PrivateKey_create(private_key_data);
+}
+
 /**
  * Compare two private keys.
  *
@@ -672,6 +708,77 @@ Signature_alloc(VALUE klass)
   return new_instance;
 }
 
+/**
+ * Deserializes a Signature from 64-byte compact signature data.
+ *
+ * @param in_compact_signature [String] compact signature as 64-byte binary
+ *   string.
+ * @return [Secp256k1::Signature] object deserialized from compact signature.
+ * @raise [ArgumentError] if signature data is invalid.
+ */
+static VALUE
+Signature_from_compact(VALUE klass, VALUE in_compact_signature)
+{
+  Signature *signature;
+  VALUE signature_result;
+  unsigned char *signature_data;
+
+  Check_Type(in_compact_signature, T_STRING);
+
+  if (RSTRING_LEN(in_compact_signature) != 64)
+  {
+    rb_raise(rb_eArgError, "compact signature must be 64 bytes");
+  }
+
+  signature_data = (unsigned char*)StringValuePtr(in_compact_signature);
+
+  signature_result = Signature_alloc(Secp256k1_Signature_class);
+  TypedData_Get_Struct(signature_result, Signature, &Signature_DataType, signature);
+
+  if (secp256k1_ecdsa_signature_parse_compact(secp256k1_context_no_precomp,
+                                              &(signature->sig),
+                                              signature_data) != 1)
+  {
+    rb_raise(rb_eArgError, "invalid compact signature");
+  }
+
+  return signature_result;
+}
+
+/**
+ * Converts a DER encoded binary signature into a signature object.
+ *
+ * @param in_der_encoded_signature [String] DER encoded signature as binary
+ *   string.
+ * @return [Secp256k1::Signature] signature object initialized using signature
+ *   data.
+ * @raise [ArgumentError] if signature data is invalid.
+ */
+static VALUE
+Signature_from_der_encoded(VALUE klass, VALUE in_der_encoded_signature)
+{
+  Signature *signature;
+  VALUE signature_result;
+  unsigned char *signature_data;
+
+  Check_Type(in_der_encoded_signature, T_STRING);
+
+  signature_data = (unsigned char*)StringValuePtr(in_der_encoded_signature);
+
+  signature_result = Signature_alloc(Secp256k1_Signature_class);
+  TypedData_Get_Struct(signature_result, Signature, &Signature_DataType, signature);
+
+  if (secp256k1_ecdsa_signature_parse_der(secp256k1_context_no_precomp,
+                                          &(signature->sig),
+                                          signature_data,
+                                          RSTRING_LEN(in_der_encoded_signature)) != 1)
+  {
+    rb_raise(rb_eArgError, "invalid DER encoded signature");
+  }
+
+  return signature_result;
+}
+
 /**
  * Return Distinguished Encoding Rules (DER) encoded signature data.
  *
@@ -688,7 +795,7 @@ Signature_der_encoded(VALUE self)
   TypedData_Get_Struct(self, Signature, &Signature_DataType, signature);
 
   der_signature_len = 72;
-  if (secp256k1_ecdsa_signature_serialize_der(signature->ctx,
+  if (secp256k1_ecdsa_signature_serialize_der(secp256k1_context_no_precomp,
                                               der_signature,
                                               &der_signature_len,
                                               &(signature->sig)) != 1)
@@ -713,7 +820,7 @@ Signature_compact(VALUE self)
 
   TypedData_Get_Struct(self, Signature, &Signature_DataType, signature);
 
-  if (secp256k1_ecdsa_signature_serialize_compact(signature->ctx,
+  if (secp256k1_ecdsa_signature_serialize_compact(secp256k1_context_no_precomp,
                                                   compact_signature,
                                                   &(signature->sig)) != 1)
   {
@@ -751,15 +858,13 @@ Signature_normalized(VALUE self)
 
   was_normalized = Qfalse;
   if (secp256k1_ecdsa_signature_normalize(
-        signature->ctx,
+        secp256k1_context_no_precomp,
         &(normalized_signature->sig),
         &(signature->sig)) == 1)
   {
     was_normalized = Qtrue;
   }
 
-  normalized_signature->ctx = secp256k1_context_clone(signature->ctx);
-
   result = rb_ary_new2(2);
   rb_ary_push(result, was_normalized);
   rb_ary_push(result, result_sig);
@@ -787,10 +892,10 @@ Signature_equals(VALUE self, VALUE other)
   TypedData_Get_Struct(other, Signature, &Signature_DataType, rhs);
 
   secp256k1_ecdsa_signature_serialize_compact(
-    lhs->ctx, lhs_compact, &(lhs->sig)
+    secp256k1_context_no_precomp, lhs_compact, &(lhs->sig)
   );
   secp256k1_ecdsa_signature_serialize_compact(
-    rhs->ctx, rhs_compact, &(rhs->sig)
+    secp256k1_context_no_precomp, rhs_compact, &(rhs->sig)
   );
 
   if (memcmp(lhs_compact, rhs_compact, 64) == 0)
@@ -845,7 +950,7 @@ RecoverableSignature_compact(VALUE self)
   );
 
   if (secp256k1_ecdsa_recoverable_signature_serialize_compact(
-        recoverable_signature->ctx,
+        secp256k1_context_no_precomp,
         compact_sig,
         &recovery_id,
         &(recoverable_signature->sig)) != 1)
@@ -891,11 +996,10 @@ RecoverableSignature_to_signature(VALUE self)
 
   // NOTE: This method cannot fail
   secp256k1_ecdsa_recoverable_signature_convert(
-    recoverable_signature->ctx,
+    secp256k1_context_no_precomp,
     &(signature->sig),
     &(recoverable_signature->sig));
 
-  signature->ctx = secp256k1_context_clone(recoverable_signature->ctx);
   return result;
 }
 
@@ -936,7 +1040,6 @@ RecoverableSignature_recover_public_key(VALUE self, VALUE in_hash32)
                               &(recoverable_signature->sig),
                               hash32) == 1)
   {
-    public_key->ctx = secp256k1_context_clone(recoverable_signature->ctx);
     return result;
   }
 
@@ -1076,7 +1179,7 @@ Context_generate_key_pair(VALUE self)
 
   TypedData_Get_Struct(self, Context, &Context_DataType, context);
 
-  private_key = PrivateKey_create(context, private_key_bytes);
+  private_key = PrivateKey_create(private_key_bytes);
   public_key = PublicKey_create_from_private_key(context, private_key_bytes);
   result = rb_funcall(
     Secp256k1_KeyPair_class,
@@ -1089,57 +1192,6 @@ Context_generate_key_pair(VALUE self)
   return result;
 }
 
-/**
- * Loads a public key from compressed or uncompressed binary data.
- *
- * @param in_public_key_data [String] binary string with compressed or
- *   uncompressed public key data.
- * @return [Secp256k1::PublicKey] public key derived from data.
- * @raise [RuntimeError] if public key data is invalid.
- */
-static VALUE
-Context_public_key_from_data(VALUE self, VALUE in_public_key_data)
-{
-  Context *context;
-  unsigned char *public_key_data;
-
-  Check_Type(in_public_key_data, T_STRING);
-
-  TypedData_Get_Struct(self, Context, &Context_DataType, context);
-  public_key_data = (unsigned char*)StringValuePtr(in_public_key_data);
-  return PublicKey_create_from_data(
-    context,
-    public_key_data,
-    (int)RSTRING_LEN(in_public_key_data)
-  );
-}
-
-/**
- * Load a private key from binary data.
- *
- * @param in_private_key_data [String] 32 byte binary string of private key
- *   data.
- * @return [Secp256k1::PrivateKey] private key loaded from the given data.
- * @raise [ArgumentError] if private key data is not 32 bytes or is invalid.
- */
-static VALUE
-Context_private_key_from_data(VALUE self, VALUE in_private_key_data)
-{
-  Context *context;
-  unsigned char *private_key_data;
-
-  Check_Type(in_private_key_data, T_STRING);
-  TypedData_Get_Struct(self, Context, &Context_DataType, context);
-  private_key_data = (unsigned char*)StringValuePtr(in_private_key_data);
-
-  if (RSTRING_LEN(in_private_key_data) != 32)
-  {
-    rb_raise(rb_eArgError, "private key data must be 32 bytes in length");
-  }
-
-  return PrivateKey_create(context, private_key_data);
-}
-
 /**
  * Converts binary private key data into a new key pair.
  *
@@ -1157,16 +1209,16 @@ Context_key_pair_from_private_key(VALUE self, VALUE in_private_key_data)
   unsigned char *private_key_data;
 
   Check_Type(in_private_key_data, T_STRING);
+  TypedData_Get_Struct(self, Context, &Context_DataType, context);
 
   if (RSTRING_LEN(in_private_key_data) != 32)
   {
     rb_raise(rb_eArgError, "private key data must be 32 bytes in length");
   }
 
-  TypedData_Get_Struct(self, Context, &Context_DataType, context);
   private_key_data = (unsigned char*)StringValuePtr(in_private_key_data);
 
-  private_key = PrivateKey_create(context, private_key_data);
+  private_key = PrivateKey_create(private_key_data);
   public_key = PublicKey_create_from_private_key(context, private_key_data);
 
   return rb_funcall(
@@ -1178,83 +1230,6 @@ Context_key_pair_from_private_key(VALUE self, VALUE in_private_key_data)
   );
 }
 
-/**
- * Converts a DER encoded binary signature into a signature object.
- *
- * @param in_der_encoded_signature [String] DER encoded signature as binary
- *   string.
- * @return [Secp256k1::Signature] signature object initialized using signature
- *   data.
- * @raise [ArgumentError] if signature data is invalid.
- */
-static VALUE
-Context_signature_from_der_encoded(VALUE self, VALUE in_der_encoded_signature)
-{
-  Context *context;
-  Signature *signature;
-  VALUE signature_result;
-  unsigned char *signature_data;
-
-  Check_Type(in_der_encoded_signature, T_STRING);
-
-  TypedData_Get_Struct(self, Context, &Context_DataType, context);
-  signature_data = (unsigned char*)StringValuePtr(in_der_encoded_signature);
-
-  signature_result = Signature_alloc(Secp256k1_Signature_class);
-  TypedData_Get_Struct(signature_result, Signature, &Signature_DataType, signature);
-
-  if (secp256k1_ecdsa_signature_parse_der(context->ctx,
-                                          &(signature->sig),
-                                          signature_data,
-                                          RSTRING_LEN(in_der_encoded_signature)) != 1)
-  {
-    rb_raise(rb_eArgError, "invalid DER encoded signature");
-  }
-
-  signature->ctx = secp256k1_context_clone(context->ctx);
-  return signature_result;
-}
-
-/**
- * Deserializes a Signature from 64-byte compact signature data.
- *
- * @param in_compact_signature [String] compact signature as 64-byte binary
- *   string.
- * @return [Secp256k1::Signature] object deserialized from compact signature.
- * @raise [ArgumentError] if signature data is invalid.
- */
-static VALUE
-Context_signature_from_compact(VALUE self, VALUE in_compact_signature)
-{
-  Context *context;
-  Signature *signature;
-  VALUE signature_result;
-  unsigned char *signature_data;
-
-  Check_Type(in_compact_signature, T_STRING);
-
-  if (RSTRING_LEN(in_compact_signature) != 64)
-  {
-    rb_raise(rb_eArgError, "compact signature must be 64 bytes");
-  }
-
-  TypedData_Get_Struct(self, Context, &Context_DataType, context);
-  signature_data = (unsigned char*)StringValuePtr(in_compact_signature);
-
-  signature_result = Signature_alloc(Secp256k1_Signature_class);
-  TypedData_Get_Struct(signature_result, Signature, &Signature_DataType, signature);
-
-  if (secp256k1_ecdsa_signature_parse_compact(context->ctx,
-                                              &(signature->sig),
-                                              signature_data) != 1)
-  {
-    rb_raise(rb_eArgError, "invalid compact signature");
-  }
-
-  signature->ctx = secp256k1_context_clone(context->ctx);
-  return signature_result;
-}
-
 /**
  * Computes the ECDSA signature of the data using the secp256k1 elliptic curve.
  *
@@ -1294,7 +1269,6 @@ Context_sign(VALUE self, VALUE in_private_key, VALUE in_hash32)
                        private_key->data,
                        &(signature->sig))))
   {
-    signature->ctx = secp256k1_context_clone(context->ctx);
     return signature_result;
   }
 
@@ -1444,7 +1418,7 @@ Context_recoverable_signature_from_compact(
   );
 
   if (secp256k1_ecdsa_recoverable_signature_parse_compact(
-        context->ctx,
+        secp256k1_context_no_precomp,
         &(recoverable_signature->sig),
         compact_sig,
         recovery_id) == 1)
@@ -1587,14 +1561,6 @@ void Init_rbsecp256k1()
                    "key_pair_from_private_key",
                    Context_key_pair_from_private_key,
                    1);
-  rb_define_method(Secp256k1_Context_class,
-                   "public_key_from_data",
-                   Context_public_key_from_data,
-                   1);
-  rb_define_method(Secp256k1_Context_class,
-                   "private_key_from_data",
-                   Context_private_key_from_data,
-                   1);
   rb_define_method(Secp256k1_Context_class,
                    "sign",
                    Context_sign,
@@ -1603,14 +1569,6 @@ void Init_rbsecp256k1()
                    "verify",
                    Context_verify,
                    3);
-  rb_define_method(Secp256k1_Context_class,
-                   "signature_from_der_encoded",
-                   Context_signature_from_der_encoded,
-                   1);
-  rb_define_method(Secp256k1_Context_class,
-                   "signature_from_compact",
-                   Context_signature_from_compact,
-                   1);
 
   // Secp256k1::KeyPair
   Secp256k1_KeyPair_class = rb_define_class_under(Secp256k1_module,
@@ -1638,6 +1596,12 @@ void Init_rbsecp256k1()
                    "uncompressed",
                    PublicKey_uncompressed,
                    0);
+  rb_define_singleton_method(
+    Secp256k1_PublicKey_class,
+    "from_data",
+    PublicKey_from_data,
+    1
+  );
   rb_define_method(Secp256k1_PublicKey_class, "==", PublicKey_equals, 1);
 
   // Secp256k1::PrivateKey
@@ -1647,6 +1611,12 @@ void Init_rbsecp256k1()
   rb_define_alloc_func(Secp256k1_PrivateKey_class, PrivateKey_alloc);
   rb_define_attr(Secp256k1_PrivateKey_class, "data", 1, 0);
   rb_define_method(Secp256k1_PrivateKey_class, "==", PrivateKey_equals, 1);
+  rb_define_singleton_method(
+    Secp256k1_PrivateKey_class,
+    "from_data",
+    PrivateKey_from_data,
+    1
+  );
 
   // Secp256k1::Signature
   Secp256k1_Signature_class = rb_define_class_under(Secp256k1_module,
@@ -1669,6 +1639,18 @@ void Init_rbsecp256k1()
                    "==",
                    Signature_equals,
                    1);
+  rb_define_singleton_method(
+    Secp256k1_Signature_class,
+    "from_compact",
+    Signature_from_compact,
+    1
+  );
+  rb_define_singleton_method(
+    Secp256k1_Signature_class,
+    "from_der_encoded",
+    Signature_from_der_encoded,
+    1
+  );
 
 #ifdef HAVE_SECP256K1_RECOVERY_H
   // Secp256k1::RecoverableSignature

data/lib/rbsecp256k1/version.rb

@@ -1,3 +1,3 @@
 module Secp256k1
-  VERSION = '3.0.1'.freeze
+  VERSION = '4.0.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbsecp256k1
 version: !ruby/object:Gem::Version
-  version: 3.0.1
+  version: 4.0.0
 platform: ruby
 authors:
 - Eric Scrivner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-04 00:00:00.000000000 Z
+date: 2019-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mini_portile2
@@ -131,6 +131,16 @@ extra_rdoc_files: []
 files:
 - README.md
 - Rakefile
+- documentation/context.md
+- documentation/index.md
+- documentation/key_pair.md
+- documentation/private_key.md
+- documentation/public_key.md
+- documentation/recoverable_signature.md
+- documentation/secp256k1.md
+- documentation/shared_secret.md
+- documentation/signature.md
+- documentation/util.md
 - ext/rbsecp256k1/extconf.rb
 - ext/rbsecp256k1/rbsecp256k1.c
 - lib/rbsecp256k1.rb