elliptic 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ef1dcaf22384ecedc56973cf3e2a75bb5da817bb6d5dcaa65f5559e48d4731d4
+  data.tar.gz: a4b7cf7b207cddae72ddd7a5a2cd848fe41e824d56284f46ffb65e3332f96d50
+SHA512:
+  metadata.gz: f78242b719f4871949419099adde1cb3f209d11f176f761aefba7d7828a597ff30f1e4b75fae8ed1048612a226f9dabc4758f21be01466c486851ee483f00a84
+  data.tar.gz: e4561b2707ec6c5dce8e5e09d7dbc516dc5434dbbce7e03e773f6ef8ff0aff7610c9998da0e9c27b9baec976b71e97dccc853c8e9c548a5904476a5297822475

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+### 0.0.1 / 2021-01-22
+
+* Everything is new. First release

data/Manifest.txt

@@ -0,0 +1,10 @@
+CHANGELOG.md
+Manifest.txt
+README.md
+Rakefile
+i/secp256k1.png
+lib/elliptic.rb
+lib/elliptic/version.rb
+test/helper.rb
+test/test_sign.rb
+test/test_version.rb

data/README.md

@@ -0,0 +1,293 @@
+# elliptic - elliptic curve digital signature algorithm (ECDSA) cryptography with OpenSSL made easy (incl. secp256k1 curve)
+
+
+* home  :: [github.com/rubycoco/blockchain](https://github.com/rubycoco/blockchain)
+* bugs  :: [github.com/rubycoco/blockchain/issues](https://github.com/rubycoco/blockchain/issues)
+* gem   :: [rubygems.org/gems/elliptic](https://rubygems.org/gems/elliptic)
+* rdoc  :: [rubydoc.info/gems/elliptic](http://rubydoc.info/gems/elliptic)
+
+
+
+
+## Usage
+
+
+### Intro
+
+Did you know? All you need to open up a new account on a blockchain
+is an (unsigned) 256-bit / 32-byte integer number.
+Yes, that's it.  No questions asked.
+The private key is the secret "magic" that unlocks your own bank.
+
+
+Q: What's the maximum value for a 256-bit / 32-byte integer number
+(hint 2^256-1)?
+
+Maximum value of 2^256-1 =
+
+``` ruby
+2**256-1
+#=> 115792089237316195423570985008687907853269984665640564039457584007913129639935
+(2**256-1).to_s.length
+#=> 78
+```
+
+Yes, that's 78 (!) decimal digits.
+
+
+Let's (re)try the maximum value for a 256-bit (32-byte) integer number
+in hexadecimal (base 16) and binary (base 2) format?
+
+``` ruby
+(2**256-1).to_s(16)
+#=> "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+(2**256-1).to_s(16).length
+#=> 64
+
+(2**256-1).to_s(2)
+#=> "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
+(2**256-1).to_s(2).length
+#=> 256
+```
+
+Surprise - a 256-bit number has 256 binary digits (0 and 1s).
+
+
+
+BEWARE - Blockchain Bandits!
+If you use a low integer number e.g.  1, 2, etc.
+your account is guaranteed to get robbed by blockchain bandits in
+seconds.
+
+(See [A "Blockchain Bandit" Is Guessing Private Keys and Scoring Millions](https://www.wired.com/story/blockchain-bandit-ethereum-weak-private-keys/)
+by Andy Greenberg, Wired Magazine, April 2019)
+
+
+
+
+### Private Key
+
+An ECDSA (Elliptic Curve Digital Signature Algorithm) private key is a random number between 1 and the order of the elliptic curve group.
+
+
+``` ruby
+require 'elliptic'
+
+# note: Algo will auto-generate (random) private key if no private key passed in
+algo = EC::Algo.new    # by default uses Secp256k1 curve (used in Bitcoin and Ethereum)
+
+algo.private_key
+#=> 72190737707147846840353520312904745954595478835413056312168022784020322830309
+```
+
+
+### (Auto-)Calculate the Public Key - Enter Elliptic Curve (EC) Cryptography
+
+The public key are two numbers (that is, a point with the coordinates x and y) computed by multiplying
+the generator point (`G`) of the curve with the private key.
+This is equivalent to adding the generator to itself `private_key` times.
+Magic?
+Let's try:
+
+
+``` ruby
+# This private key is just an example. It should be much more secure!
+privatekey = 1234
+
+# Elliptic curve (EC) machinery - pass in our own key
+algo = EC::Algo.new( privatekey )  # by default uses Secp256k1 curve (used in Bitcoin and Ethereum)
+point = algo.public_key    ## the "magic" one-way K=k*G curve multiplication (K=public key,k=private key, G=generator point)
+
+point.x
+#=> 102884003323827292915668239759940053105992008087520207150474896054185180420338
+point.y
+#=> 49384988101491619794462775601349526588349137780292274540231125201115197157452
+
+point.x.to_s(16)
+#=> "e37648435c60dcd181b3d41d50857ba5b5abebe279429aa76558f6653f1658f2"
+point.y.to_s(16)
+#=> "6d2ee9a82d4158f164ae653e9c6fa7f982ed8c94347fc05c2d068ff1d38b304c"
+```
+
+
+###  Sign & Verify Transactions
+
+Sign a transaction with an (elliptic curve) private key:
+
+``` ruby
+# Step 1 - Calculate the Transaction (tx) Hash
+tx = 'from: Alice  to: Bob     cryptos: 43_000_000_000'
+txhash = Digest::SHA256.digest( tx )
+
+# Step 2 - Get the Signer's Private key
+privatekey = 1234     # This private key is just an example. It should be much more secure!
+
+# Sign!
+signature = EC.sign( txhash, privatekey )
+
+signature.r
+#=> 80563021554295584320113598933963644829902821722081604563031030942154621916407
+signature.s
+#=> 58316177618967642068351252425530175807242657664855230973164972803783751708604
+
+signature.r.to_s(16)
+#=> "3306a2f81ad2b2f62ebe0faec129545bc772babe1ca5e70f6e56556b406464c0"
+signature.s.to_s(16)
+#=> "4fe202bb0835758f514cd4a0787986f8f6bf303df629dc98c5b1a438a426f49a"
+```
+
+
+Verify a signed transaction with an (elliptic curve) public key:
+
+``` ruby
+# Step 1 - Calculate the Transaction (tx) Hash
+tx = 'from: Alice  to: Bob     cryptos: 43_000_000_000'
+txhash = Digest::SHA256.digest( tx )
+
+# Step 2 - Get the Signer's Public Key
+pubkey = EC::Point.new(
+   102884003323827292915668239759940053105992008087520207150474896054185180420338,
+   49384988101491619794462775601349526588349137780292274540231125201115197157452
+)
+
+# Step 3 - Get the Transaction's Signature
+signature = EC::Signature.new(
+  80563021554295584320113598933963644829902821722081604563031030942154621916407,
+  58316177618967642068351252425530175807242657664855230973164972803783751708604
+)
+
+# Don't Trust - Verify
+EC.valid_signature?( txhash, pubkey, signature )
+#=> true
+
+
+# or using hexadecimal numbers
+
+pubkey = EC::Point.new(
+  0xe37648435c60dcd181b3d41d50857ba5b5abebe279429aa76558f6653f1658f2,
+  0x6d2ee9a82d4158f164ae653e9c6fa7f982ed8c94347fc05c2d068ff1d38b304c
+)
+
+signature = EC::Signature.new(
+  0x3306a2f81ad2b2f62ebe0faec129545bc772babe1ca5e70f6e56556b406464c0,
+  0x4fe202bb0835758f514cd4a0787986f8f6bf303df629dc98c5b1a438a426f49a
+)
+
+EC.valid_signature?( txhash, pubkey, signature )
+#=> true
+```
+
+
+To sum up:
+
+- The (raw) private key is a 256-bit unsigned integer number
+- The (raw) public key is a point (x,y), that is, two 256-bit unsigned integer numbers - derived (calculated) from the private key
+- A (raw) signature is composed of (r,s), that is, two 256-bit unsigned integer numbers
+
+That's all the magic.
+
+
+
+
+## Public Key Formats
+
+To get the all-in-one-string
+public key from a point with the coordinates x and y
+use the
+Standards for Efficient Cryptography (SEC)  1) uncompressed format
+or the 2) compressed format:
+
+
+``` ruby
+# 1) Uncompressed format (with prefix 04)
+#   Convert to 64 hexstring characters (32 bytes) in length
+
+prefix = '04'
+pubkey = prefix + "%064x" % point.x + "%064x" % point.y
+#=> "04e37648435c60dcd181b3d41d50857ba5b5abebe279429aa76558f6653f1658f26d2ee9a82d4158f164ae653e9c6fa7f982ed8c94347fc05c2d068ff1d38b304c"
+
+# 2) Compressed format (with prefix - 02 = even / 03 = odd)
+#   Instead of using both x and y coordinates,
+#   just use the x-coordinate and whether y is even/odd
+
+prefix = point.y % 2 == 0 ? '02' : '03'
+pubkey = prefix + "%064x" % point.x
+#=> "02e37648435c60dcd181b3d41d50857ba5b5abebe279429aa76558f6653f1658f2"
+```
+
+or use the builtin helpers:
+
+``` ruby
+# 1) Uncompressed format (with prefix 04)
+#   Convert to 64 hexstring characters (32 bytes) in length
+
+point.to_s   # or point.to_s( :uncompressed )
+#=> "04e37648435c60dcd181b3d41d50857ba5b5abebe279429aa76558f6653f1658f26d2ee9a82d4158f164ae653e9c6fa7f982ed8c94347fc05c2d068ff1d38b304c"
+
+# 2) Compressed format (with prefix - 02 = even / 03 = odd)
+#   Instead of using both x and y coordinates,
+#   just use the x-coordinate and whether y is even/odd
+
+point.to_s( :compressed )
+#=> "02e37648435c60dcd181b3d41d50857ba5b5abebe279429aa76558f6653f1658f2"
+```
+
+
+That's it.
+
+
+
+
+## Aside - Elliptic What?
+
+> Elliptic-curve cryptography (ECC) is
+> an approach to public-key cryptography based
+> on the algebraic structure of elliptic curves over finite fields.
+>
+> (Source: [Elliptic-curve cryptography @ Wikipedia](https://en.wikipedia.org/wiki/Elliptic-curve_cryptography))
+
+
+What's an Elliptic Curve?
+
+![](i/secp256k1.png)
+
+> This is a graph of secp256k1's elliptic curve `y² = x³ + 7`
+> over the real numbers.
+> Note that because secp256k1 is actually defined over the field Zₚ,
+> its graph will in reality look like random scattered points,
+> not anything like this.
+>
+> (Source: [Secp256k1 @ Bitcoin Wiki](https://en.bitcoin.it/wiki/Secp256k1))
+
+
+
+
+**Bitcon Public Service Announcement:**
+
+> If we all buy Bitcoin from one another at ever higher
+> prices we'll all be rich beyond our wildest dreams.
+>
+> -- Trolly McTrollface
+
+**[BEWARE: Yes, Bitcoin Is a Ponzi - Learn How the Investment Fraud Works »](https://github.com/openblockchains/bitcoin-ponzi)**
+
+
+
+
+## Install
+
+Just install the gem:
+
+    $ gem install elliptic
+
+
+## License
+
+The scripts are dedicated to the public domain.
+Use it as you please with no restrictions whatsoever.
+
+
+## Questions? Comments?
+
+Send them along to the [wwwmake forum](http://groups.google.com/group/wwwmake).
+Thanks!

data/Rakefile

@@ -0,0 +1,29 @@
+require 'hoe'
+require './lib/elliptic/version.rb'
+
+Hoe.spec 'elliptic' do
+
+  self.version = EC::VERSION
+
+  self.summary = "elliptic - elliptic curve digital signature algorithm (ECDSA) cryptography with OpenSSL made easy (incl. secp256k1 curve)"
+  self.description = summary
+
+  self.urls    = { home: 'https://github.com/rubycoco/blockchain' }
+
+  self.author  = 'Gerald Bauer'
+  self.email   = 'wwwmake@googlegroups.com'
+
+  # switch extension to .markdown for gihub formatting
+  self.readme_file  = 'README.md'
+  self.history_file = 'CHANGELOG.md'
+
+  self.extra_deps = [
+  ]
+
+  self.licenses = ['Public Domain']
+
+  self.spec_extras = {
+    required_ruby_version: '>= 2.3'
+  }
+
+end

data/lib/elliptic.rb

@@ -0,0 +1,186 @@
+require 'pp'
+require 'digest'
+require 'base64'
+require 'openssl'
+
+## our own code
+require 'elliptic/version'    # note: let version always go first
+
+
+
+module EC
+
+
+
+  class Signature
+
+    def self.decode_der( der )
+      asn1 = OpenSSL::ASN1.decode(der )
+      r = asn1.value[0].value.to_i
+      s = asn1.value[1].value.to_i
+      new(r, s)
+    end
+
+    attr_reader :r, :s
+    def initialize(r, s)
+      @r, @s = r, s
+    end
+
+    def to_der
+      asn1 = OpenSSL::ASN1::Sequence.new [
+          OpenSSL::ASN1::Integer.new( @r ),
+          OpenSSL::ASN1::Integer.new( @s ),
+        ]
+      asn1.to_der
+    end
+  end ## class Signature
+
+
+
+
+  ## "cached" / available groups for now include:
+  GROUP = {
+    ## todo/check: is there a more direct way to get a group object?
+    'secp256k1' =>  OpenSSL::PKey::EC.new( 'secp256k1' ).group
+  }
+
+
+  class Point
+
+    def initialize( *args, group: nil )
+      ## case 1) assume OpenSSL::PKey::EC::Point
+      if args.size == 1 && args[0].is_a?( OpenSSL::PKey::EC::Point )
+         @pt = args[0]
+
+         ## todo/check: is there a "better" way to get the x/y numbers?
+         hex = @pt.to_octet_string( :uncompressed ).unpack( 'H*' )[0]
+
+         ## todo/fix: check for infinity / 0 !!!!
+         @x = hex[2,64].to_i(16)       ## skip leading 0x04 marker
+         @y = hex[2+64,64].to_i(16)
+      else  ## assume x,y with group
+         ## rebuild openssl point from octet
+
+         @x = args[0]
+         @y = args[1]
+
+         ## encoded_point is the octet string representation of the point.
+         ## This must be either a String or an OpenSSL::BN
+         prefix = '04'
+         hex = prefix + ("%064x" % @x) + ("%064x" % @y)
+         bin = [hex].pack( 'H*' )
+
+         ec_group = GROUP[ group || 'secp256k1' ]
+         @pt = OpenSSL::PKey::EC::Point.new( ec_group, bin )
+      end
+    end
+
+    def x()  @x; end
+    def y()  @y; end
+    def group() @pt.group; end
+
+    ## formats - :compressed | :uncompressed
+    def to_bin( format=:uncompressed )  ## todo/check add alias .b too - why? why not?
+      @pt.to_octet_string( format )
+    end
+
+    def to_s( format=:uncompressed )
+      to_bin( format ).unpack( 'H*' )[0]
+    end
+
+    ## return OpenSSL::PKey::EC::Point - find a better name? e.g. to_raw/native or such - why? why not?
+    def to_point()  @pt; end
+  end
+
+
+
+
+  class Algo
+    def initialize( input=nil, group: nil )
+
+     ## case 1) "restore"  public key (only) from point for verify
+     if input.is_a?( OpenSSL::PKey::EC::Point ) ||  ## assume public key only (restore pkey object for verify?)
+        input.is_a?( Point )
+
+       point = input.is_a?( Point ) ? input.to_point : input
+
+       ## note: (auto)get group from point
+       @pkey = OpenSSL::PKey::EC.new( point.group )
+       @pkey.public_key = point
+     else  ## case 2) build a private/public key pair
+
+       ec_group = GROUP[ group || 'secp256k1' ]
+       @pkey = OpenSSL::PKey::EC.new( ec_group )
+
+       if input.nil?     ## auto-generate new key
+         @pkey.generate_key
+       else
+         num = if input.is_a?( String )
+                 input.to_i( 16 )
+               else   ## assume (big) integer
+                 input
+               end
+         @pkey.private_key = OpenSSL::BN.new( num )
+         ## auto-calculate public key too
+         @pkey.public_key = @pkey.group.generator.mul( @pkey.private_key )
+       end
+      end
+    end
+
+
+    def group() @pkey.group; end
+
+    def public?()   @pkey.public?; end
+    def private?()  @pkey.private?; end
+
+
+    ## todo/check/fix: fix case with no private_key if passed in point/public key for verify!!!
+    def private_key() @pkey.private_key.to_i; end
+    alias_method :priv_key, :private_key   ## add signing_key alias too?
+
+    def public_key() @public_key ||= Point.new( @pkey.public_key ); end
+
+
+    def sign( message )
+      signature_der = @pkey.dsa_sign_asn1( message )
+      Signature.decode_der( signature_der )
+    end
+
+    def verify?( message, signature )
+      signature_der = signature.to_der
+      @pkey.dsa_verify_asn1( message, signature_der )
+    end
+    alias_method :valid_signature?, :verify?
+
+
+    def to_text() @pkey.to_text; end
+  end
+
+
+
+  def self.sign( message, priv_key )
+    algo = Algo.new( priv_key )
+    algo.sign( message )
+  end
+
+  def self.verify?( message, pub_key, signature )
+    algo = Algo.new( pub_key )
+    algo.verify?( message, signature )
+  end
+
+  class << self
+    alias_method :valid_signature?, :verify?
+  end
+
+
+
+
+  def self.builtin_curves
+    OpenSSL::PKey::EC.builtin_curves
+  end
+end  ## module EC
+
+
+
+
+puts EC.banner     ## say hello

data/lib/elliptic/version.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+
+module EC
+
+  MAJOR = 0
+  MINOR = 1
+  PATCH = 0
+  VERSION = [MAJOR,MINOR,PATCH].join('.')
+
+  def self.version
+    VERSION
+  end
+
+  def self.banner
+    "elliptic/#{VERSION} on Ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}] in (#{root})"
+  end
+
+  def self.root
+    File.expand_path( File.dirname(File.dirname(File.dirname(__FILE__))) )
+  end
+
+end # module EC

data/test/helper.rb

@@ -0,0 +1,11 @@
+## $:.unshift(File.dirname(__FILE__))
+
+## minitest setup
+
+require 'minitest/autorun'
+
+
+## our own code
+
+require 'elliptic'
+

data/test/test_sign.rb

@@ -0,0 +1,87 @@
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_sign.rb
+
+
+require 'helper'
+
+
+class TestSign < MiniTest::Test
+
+
+def test_keys
+  algo = EC::Algo.new( 1234 )
+  assert_equal 1234,        algo.private_key
+  assert_equal "secp256k1", algo.group.curve_name
+
+  public_key = algo.public_key
+  assert_equal 102884003323827292915668239759940053105992008087520207150474896054185180420338,
+               public_key.x
+
+  assert_equal 49384988101491619794462775601349526588349137780292274540231125201115197157452,
+              public_key.y
+
+  assert_equal "e37648435c60dcd181b3d41d50857ba5b5abebe279429aa76558f6653f1658f2",
+               public_key.x.to_s(16)
+  assert_equal "6d2ee9a82d4158f164ae653e9c6fa7f982ed8c94347fc05c2d068ff1d38b304c",
+               public_key.y.to_s(16)
+
+  assert_equal "02e37648435c60dcd181b3d41d50857ba5b5abebe279429aa76558f6653f1658f2",
+               public_key.to_s( :compressed )
+
+  assert_equal "04e37648435c60dcd181b3d41d50857ba5b5abebe279429aa76558f6653f1658f26d2ee9a82d4158f164ae653e9c6fa7f982ed8c94347fc05c2d068ff1d38b304c",
+               public_key.to_s
+end
+
+def test_sign
+  algo = EC::Algo.new( 1234 )
+  priv_key = algo.private_key
+
+  message  = Digest::SHA256.digest( "hello" )
+
+  ## note: sign uses a secure random generated temp key
+  ##           every signature is different!!!
+  signature = EC.sign( message, priv_key )
+  pp signature.to_der
+
+  signature = EC.sign( message, priv_key )
+  pp signature.to_der
+
+  signature = EC.sign( message, priv_key )
+  pp signature.to_der
+
+  pp algo.sign( message )
+
+
+  ### verify
+  public_key = algo.public_key
+
+  assert EC.verify?( message, public_key, signature )
+  assert EC.valid_signature?( message, public_key, signature )
+
+  assert algo.verify?( message, signature )
+  assert algo.valid_signature?( message, signature )
+
+  ## public key from point (x,y)
+  point = EC::Point.new(
+     102884003323827292915668239759940053105992008087520207150474896054185180420338,
+     49384988101491619794462775601349526588349137780292274540231125201115197157452)
+  assert EC.verify?( message, point, signature )
+
+  ## signature from r,s values
+  signature = EC::Signature.new(
+     17435452009115387225781053203681496505351828576563920844344513414624978140095,
+     57357162317582879484266879619863223941116872722080991745355058707843528515381)
+  assert EC.verify?( message, point, signature )
+
+
+
+  ## tamper with message
+  message  = Digest::SHA256.digest( "hellox" )
+  assert_equal false,  EC.verify?( message, public_key, signature )
+  assert_equal false,  algo.verify?( message, signature )
+end
+
+
+
+end # class TestSign

data/test/test_version.rb

@@ -0,0 +1,19 @@
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_version.rb
+
+
+require 'helper'
+
+
+class TestVersion < MiniTest::Test
+
+def test_version
+   pp EC.version
+   pp EC.banner
+   pp EC.root
+
+   assert true  ## (for now) everything ok if we get here
+end
+
+end # class TestVersion

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: elliptic
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Gerald Bauer
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-01-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.22'
+description: elliptic - elliptic curve digital signature algorithm (ECDSA) cryptography
+  with OpenSSL made easy (incl. secp256k1 curve)
+email: wwwmake@googlegroups.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- CHANGELOG.md
+- Manifest.txt
+- README.md
+files:
+- CHANGELOG.md
+- Manifest.txt
+- README.md
+- Rakefile
+- i/secp256k1.png
+- lib/elliptic.rb
+- lib/elliptic/version.rb
+- test/helper.rb
+- test/test_sign.rb
+- test/test_version.rb
+homepage: https://github.com/rubycoco/blockchain
+licenses:
+- Public Domain
+metadata: {}
+post_install_message:
+rdoc_options:
+- "--main"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key:
+specification_version: 4
+summary: elliptic - elliptic curve digital signature algorithm (ECDSA) cryptography
+  with OpenSSL made easy (incl. secp256k1 curve)
+test_files: []