ruby-ecdsa-1.2.0+git20191006.1.ce478ea/.gitignore 0000644 0000000 0000000 00000000056 13546435715 016604 0 ustar 0000000 0000000 Gemfile.lock
ecdsa*.gem
.yardoc
doc
/coverage
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/.rubocop.yml 0000644 0000000 0000000 00000001504 13546435715 017065 0 ustar 0000000 0000000 AlignParameters:
Enabled: false
AndOr:
Enabled: false
ClassLength:
Max: 150
CyclomaticComplexity:
Max: 20
Documentation:
Enabled: false
FormatString:
EnforcedStyle: percent
LineLength:
Max: 120
Exclude:
- lib/ecdsa/group/*.rb
- spec/nist_example_spec.rb
MethodLength:
Max: 20
# The unless keyword doesn't exists in most other languages and it makes lines
# longer. Let's not force ourselves to use it.
NegatedIf:
Enabled: false
# Buggy cop: it was auto-correcting files that were excluded when I ran rubcop -a
NumericLiterals:
Enabled: false
Exclude:
- lib/ecdsa/group/nist*.rb
SignalException:
EnforcedStyle: only_raise
# Very picky about what I name block params to 'reduce'.
SingleLineBlockParams:
Enabled: false
TrailingComma:
EnforcedStyleForMultiline: comma
Enabled: false
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/.travis.yml 0000644 0000000 0000000 00000000147 13546435715 016726 0 ustar 0000000 0000000 script: "rspec"
rvm:
- 1.9.3
- 2.0.0
- 2.1.10
- 2.3.1
- 2.6.5
- jruby-19mode
- ruby-head
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/.yardopts 0000644 0000000 0000000 00000000105 13546435715 016455 0 ustar 0000000 0000000 lib/ecdsa/**/*.rb
--readme README.md
--markup markdown
-
ChangeLog.md ruby-ecdsa-1.2.0+git20191006.1.ce478ea/ChangeLog.md 0000644 0000000 0000000 00000003257 13546435715 016773 0 ustar 0000000 0000000 Change log
====
This gem follows [Semantic Versioning 2.0.0](http://semver.org/spec/v2.0.0.html).
All classes and public methods are part of the public API, unless explicitly noted otherwise
in their documentation.
1.2.0
----
Released on 2014-09-14.
- Adds aliases to `ECDSA::Point` so you can do point arithmetic with `+` and `*`
operators. (Thanks to Stephen McCarthy.)
1.1.0
----
Released on 2014-04-20.
New features:
- `ECDSA.recover_public_key` was added. It finds all possible public keys that
could have been used to make a signature.
- `Group#valid_public_key?` and `Group#partially_valid_public_key?` were added.
They are different from `Group#include?` because they both return false for
the infinity point and `Group#valid_public_key?` checks to make sure
that the point can be expressed as the generator point times a scalar.
- `PrimeField#square_roots` now works all prime fields.
Bug fixes:
- The signing and verification operations now properly take the leftmost bits
of the digest if it is a string. If it is an integer, it is left alone.
- Nicer exception error messages from `ECDSA.check_signature!`. They start with
"Invalid signature: " so they could be understood in the context of a larger
application without looking at the class of the exception.
- `ECDSA.sign` returns nil if r is zero.
1.0.0
----
Released on 2014-04-06.
- PointOctetString: Made the `decode` method treat all strings as binary.
- Group: Changed two methods to be private: `#point_satisfies_equation?` and
`#equation_right_hand_side`.
- Group: made `#include?` return false instead of raising an exception when a
point in another group is passed in.
- Added lots of documentation.
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/Contributing.md 0000644 0000000 0000000 00000002116 13546435715 017604 0 ustar 0000000 0000000 Contributing
====
The ECDSA gem is hosted on the [DavidEGrayson/ruby_ecdsa github page](https://github.com/DavidEGrayson/ruby_ecdsa).
To report a bug, go to the github page and create a new issue.
If you want to contribute code, these are the general steps:
1. Clone the git repository to your computer.
2. Run these commands to get the development dependencies:
gem install bundler
bundle
3. Run the specs with the command `bundle exec rspec` to make sure they are working.
4. Add a new spec somewhere in the `spec` directory for the bug or feature you want to fix.
5. Run the specs again to make sure your spec is failing.
6. Modify the code.
7. Run the specs again to make sure they are all passing.
8. Run 'rubocop' and fix any warnings (or prepare an argument for why the rubocop configuration should be changed).
9. Fork our repository on github and push your changes to a branch of your repository. It is good practice make a branch with a special name and push to that instead of master.
10. On github, make a pull request from your branch to our repository.
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/Gemfile 0000644 0000000 0000000 00000000557 13546435715 016115 0 ustar 0000000 0000000 source 'https://rubygems.org/'
gem 'rspec'
gem 'rubocop', '0.20.1'
gem 'simplecov'
gem 'yard'
gem 'markdown'
if Gem::Version.create(RUBY_VERSION) < Gem::Version.create("2.2.2")
# NOTE: markdown depends on textutils, and textutils depends on AS.
# AS5 requires Ruby2.2.2 or later.
gem 'activesupport', '< 5'
end
platforms :ruby, :rbx do
gem 'redcarpet'
end ruby-ecdsa-1.2.0+git20191006.1.ce478ea/LICENSE.txt 0000644 0000000 0000000 00000002041 13546435715 016433 0 ustar 0000000 0000000 Copyright (c) 2014 David Grayson.
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE. ruby-ecdsa-1.2.0+git20191006.1.ce478ea/README.md 0000644 0000000 0000000 00000015234 13546435715 016077 0 ustar 0000000 0000000 # ECDSA gem for Ruby
[](https://travis-ci.org/DavidEGrayson/ruby_ecdsa)
This gem implements the Elliptic Curve Digital Signature Algorithm (ECDSA)
almost entirely in pure Ruby. It aims to be easier to use and easier to
understand than Ruby's
[OpenSSL EC support](http://www.ruby-doc.org/stdlib/libdoc/openssl/rdoc/OpenSSL/PKey/EC.html).
This gem does use OpenSSL but it only uses it to decode and encode ASN1 strings
for ECDSA signatures. All cryptographic calculations are done in pure Ruby.
The main classes of this gem are `ECDSA::Group`, `ECDSA::Point`, and
`ECDSA::Signature`. These classes operate on Ruby integers and do not deal at
all with binary formatting. Encoding and decoding of binary formats is solely
handled by classes under the `ECDSA::Format` module.
You can enter your own curve parameters by instantiating a new `ECDSA::Group`
object or you can use a pre-existing group object such as
`ECDSA::Group::Secp256k1`. The pre-existing groups can be seen in the
`lib/ecdsa/group` folder, and include all the curves defined in
[SEC2](http://www.secg.org/collateral/sec2_final.pdf) and
[NIST's Recommended Elliptic Curves for Federal Government Use](http://csrc.nist.gov/groups/ST/toolkit/documents/dss/NISTReCur.pdf).
This gem does not use any randomness; all the algorithms are deterministic.
In order to sign a message, you must generate a secure random number _k_
between 0 and the order of the group and pass it as an argument to `ECDSA.sign`.
You should take measures to ensure that you never use the same random number to
sign two different messages, or else it would be easy for someone to compute
your private key from those two signatures.
This gem is hosted at the [DavidEGrayson/ruby_ecdsa github repository](https://github.com/DavidEGrayson/ruby_ecdsa).
## Current limitations
- This gem only supports fields of integers modulo a prime number
(_Fp_). ECDSA's characteristic 2 fields are not supported.
- The algorithms have not been optimized for speed, and will probably never be,
because that would hinder the goal of helping people understand ECDSA.
This gem was not written by a cryptography expert and has not been carefully
checked. It is provided "as is" and it is the user's responsibility to make
sure it will be suitable for the desired purpose.
## Installation
This library is distributed as a gem named [ecdsa](https://rubygems.org/gems/ecdsa)
at RubyGems.org. To install it, run:
gem install ecdsa
## Generating a private key
An ECDSA private key is a random number between 1 and the order of the group.
If you trust the `SecureRandom` class provided by your Ruby implementation, you
could generate a private key using this code:
```ruby
require 'ecdsa'
require 'securerandom'
group = ECDSA::Group::Secp256k1
private_key = 1 + SecureRandom.random_number(group.order - 1)
puts 'private key: %#x' % private_key
```
## Computing the public key for a private key
The public key consists of the coordinates of the point that is computed by
multiplying the generator point of the curve with the private key.
This is equivalent to adding the generator to itself `private_key` times.
```ruby
public_key = group.generator.multiply_by_scalar(private_key)
puts 'public key: '
puts ' x: %#x' % public_key.x
puts ' y: %#x' % public_key.y
```
The `public_key` object produced by the code above is an `ECDSA::Point` object.
## Encoding a public key as a binary string
Assuming that you have an `ECDSA::Point` object representing the public key,
you can convert it to the standard binary format defined in SEC1 with this code:
```ruby
public_key_string = ECDSA::Format::PointOctetString.encode(public_key, compression: true)
```
Setting the `compression` option to `true` decreases the size of the string by
almost 50% by only including one bit of the Y coordinate. The other bits of the
Y coordinate are deduced from the X coordinate when the string is decoded.
This code returns a binary string.
## Decoding a public key from a binary string
To decode a SEC1 octet string, you can use the code below. The `group` object
is assumed to be an `ECDSA::Group`.
```ruby
public_key = ECDSA::Format::PointOctetString.decode(public_key_string, group)
```
## Signing a message
This example shows how to generate a signature for a message. In this example,
we will use SHA2 as our digest algorithm, but other algorithms can be used.
This example assumes that you trust the `SecureRandom` class in your Ruby
implementation to generate the temporary key (also known as `k`). Beware that
if you accidentally sign two different messages with the same temporary key, it
is easy for someone to compute your private key from those two signatures and
then forge your signature. Also, if someone can correctly guess the value of
the temporary key used for a signature, they can compute your private key from
that signature.
This example assumes that you have required the `ecdsa` gem, that you have an
`ECDSA::Group` object named `group`, and that you have the private key stored as
an integer in a variable named `private_key`.
```ruby
require 'digest/sha2'
message = 'ECDSA is cool.'
digest = Digest::SHA2.digest(message)
signature = nil
while signature.nil?
temp_key = 1 + SecureRandom.random_number(group.order - 1)
signature = ECDSA.sign(group, private_key, digest, temp_key)
end
puts 'signature: '
puts ' r: %#x' % signature.r
puts ' s: %#x' % signature.s
```
## Encoding a signature as a DER string
Signatures can be stored and transmitted as a [DER](http://en.wikipedia.org/wiki/X.690) string.
The code below encodes an `ECDSA::Signature` object as a binary DER string.
```ruby
signature_der_string = ECDSA::Format::SignatureDerString.encode(signature)
```
## Decoding a signature from a DER string
The code below decodes a binary DER string to produce an `ECDSA::Signature` object.
```ruby
signature = ECDSA::Format::SignatureDerString.decode(signature_der_string)
```
## Verifying a signature
The code below shows how to verify an ECDSA signature. It assumes that you have
an `ECDSA::Point` object representing a public key, a string or integer
representing the digest of the signed messaged, and an `ECDSA::Signature` object
representing the signature. The `valid_signature?` method returns `true` if the
signature is valid and `false` if it is not.
```ruby
valid = ECDSA.valid_signature?(public_key, digest, signature)
puts "valid: #{valid}"
```
## Supported platforms
This library should run on any Ruby interpreter that is compatible with Ruby 1.9.3.
It has been tested on JRuby 1.7.11 and MRI.
## Documentation
For complete documentation, see the [ECDSA page on RubyDoc.info](http://rubydoc.info/gems/ecdsa). ruby-ecdsa-1.2.0+git20191006.1.ce478ea/Rakefile 0000644 0000000 0000000 00000001057 13546435715 016263 0 ustar 0000000 0000000 desc "Run the specs and generate a code coverage report."
task 'default' => 'spec'
desc 'Run specs'
task 'spec' do
sh 'rspec'
end
desc 'Run specs and generate coverage report'
task 'coverage' do
ENV['COVERAGE'] = 'Y'
Rake::Task['spec'].invoke
end
desc 'Print out lines of code and related statistics.'
task 'stats' do
puts 'Lines of code and comments (including blank lines):'
sh "find lib -type f | xargs wc -l"
end
desc 'Print TODO items from the source code'
task 'todo' do
sh 'grep -ni todo -r lib spec || echo none', verbose: false
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/ecdsa.gemspec 0000644 0000000 0000000 00000001307 13546435715 017240 0 ustar 0000000 0000000 # This file was written by hand.
$LOAD_PATH << 'lib'
require 'ecdsa/version'
Gem::Specification.new do |s|
s.name = 'ecdsa'
s.version = ECDSA::VERSION
s.date = Time.now.strftime('%Y-%m-%d')
# The summary should be the same as the description at https://github.com/DavidEGrayson/ruby_ecdsa
s.summary = 'This gem implements the Ellipctic Curve Digital Signature Algorithm (ECDSA) almost entirely in pure Ruby.'
s.homepage = 'https://github.com/DavidEGrayson/ruby_ecdsa'
s.authors = ['David Grayson']
s.email = 'davidegrayson@gmail.com'
s.license = 'MIT'
s.required_rubygems_version = Gem::Requirement.new('>= 2')
s.files = Dir['lib/**/*.rb', 'Gemfile', 'README.md', 'LICENSE.txt']
end ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ 0000755 0000000 0000000 00000000000 13546435715 015361 5 ustar 0000000 0000000 ruby-ecdsa-1.2.0+git20191006.1.ce478ea/resources.txt 0000644 0000000 0000000 00000001502 13546435715 017364 0 ustar 0000000 0000000 Good resources for learning about ECDSA:
https://www.secg.org/
http://csrc.nist.gov/groups/ST/toolkit/documents/dss/NISTReCur.pdf
http://csrc.nist.gov/groups/ST/toolkit/documents/Examples/ECDSA_Prime.pdf
http://csrc.nist.gov/publications/fips/fips186-3/fips_186-3.pdf
http://math.stanford.edu/~jbooher/expos/sqr_qnr.pdf
Further resources for handling compressed coordinates:
ec_GFp_simple_set_compressed_coordinates in OpenSSL
https://github.com/openssl/openssl/blob/a898936218bc279b5d7cdf76d58a25e7a2d419cb/crypto/ec/ecp_oct.c#L70
BN_mod_sqrt in OpenSSL:
https://github.com/openssl/openssl/blob/a898936218bc279b5d7cdf76d58a25e7a2d419cb/crypto/bn/bn_sqrt.c#L62
secp256k1_fe_sqrt in bitcoin's secp256k1 library:
https://github.com/bitcoin/secp256k1/blob/8b3263b638b19a1e39509dcb04bbfc2e9048a7a2/src/field_impl.h#L65
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/spec/ 0000755 0000000 0000000 00000000000 13546435715 015545 5 ustar 0000000 0000000 ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa.rb 0000644 0000000 0000000 00000002437 13546435715 016773 0 ustar 0000000 0000000 require_relative 'ecdsa/group'
require_relative 'ecdsa/signature'
require_relative 'ecdsa/sign'
require_relative 'ecdsa/verify'
require_relative 'ecdsa/recover_public_key'
require_relative 'ecdsa/format'
require_relative 'ecdsa/version'
# TODO: fix the broken URLs we have for SEC1 and SEC2 all over the code base
# The top-level module for the ECDSA gem.
module ECDSA
# This method is NOT part of the public API of the ECDSA gem.
def self.byte_length(integer)
length = 0
while integer > 0
length += 1
integer >>= 8
end
length
end
# This method is NOT part of the public API of the ECDSA gem.
def self.bit_length(integer)
length = 0
while integer > 0
length += 1
integer >>= 1
end
length
end
# This method is NOT part of the public API of the ECDSA gem.
def self.normalize_digest(digest, bit_length)
if digest.is_a?(String)
digest = digest.dup.force_encoding('BINARY')
digest_bit_length = digest.size * 8
num = Format::IntegerOctetString.decode(digest)
if digest_bit_length <= bit_length
num
else
num >> (digest_bit_length - bit_length)
end
elsif digest.is_a?(Integer)
digest
else
raise ArgumentError, 'Digest must be a string or integer.'
end
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/ 0000755 0000000 0000000 00000000000 13546435715 016440 5 ustar 0000000 0000000 ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/format.rb 0000644 0000000 0000000 00000000330 13546435715 020251 0 ustar 0000000 0000000 require 'ecdsa/format/decode_error'
require 'ecdsa/format/point_octet_string'
require 'ecdsa/format/integer_octet_string'
require 'ecdsa/format/field_element_octet_string'
require 'ecdsa/format/signature_der_string'
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/format/ 0000755 0000000 0000000 00000000000 13546435715 017730 5 ustar 0000000 0000000 ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/group.rb 0000644 0000000 0000000 00000013330 13546435715 020121 0 ustar 0000000 0000000 require_relative 'prime_field'
require_relative 'point'
# TODO: we keep using this abstraction called the 'point_field' all over the place.
# Figure out what it is really called and make it come from a method on Group.
module ECDSA
class Group
# The name of the group.
# @return (String)
attr_reader :name
# The generator point.
# @return (Point)
attr_reader :generator
# The order of the group. This is the smallest positive
# integer `i` such that the generator point multiplied by `i` is infinity.
# This is also the number of different points that are on the curve.
# @return (Order)
attr_reader :order
# The cofactor of the group.
# This is the number of points on the curve divided by the number of points
# in the group generated by the generator.
attr_reader :cofactor
# The a parameter in the curve equation (*y^2 = x^3 + ax + b*).
# @option opts :a (Integer)
attr_reader :param_a
# The b parameter in the curve equation.
# @return (Integer)
attr_reader :param_b
# The field that coordinates on the curve belong to.
# @return (PrimeField)
attr_reader :field
# These parameters are defined in http://www.secg.org/collateral/sec2_final.pdf
#
# @param opts (Hash)
# @option opts :p (Integer) A prime number that defines the field used. The field will be *Fp*.
# @option opts :a (Integer) The a parameter in the curve equation (*y^2 = x^3 + ax + b*).
# @option opts :b (Integer) The b parameter in the curve equation.
# @option opts :g (Array(Integer)) The coordinates of the generator point, with x first.
# @option opts :n (Integer) The order of g. This is the smallest positive
# integer `i` such that the generator point multiplied by `i` is infinity.
# This is also the number of different points that are on the curve.
# @option opts :h (Integer) The cofactor (optional).
def initialize(opts)
@opts = opts
@name = opts.fetch(:name) { '%#x' % object_id }
@field = PrimeField.new(opts[:p])
@param_a = opts[:a]
@param_b = opts[:b]
@generator = new_point(@opts[:g])
@order = opts[:n]
@cofactor = opts[:h]
@param_a.is_a?(Integer) or raise ArgumentError, 'Invalid a.'
@param_b.is_a?(Integer) or raise ArgumentError, 'Invalid b.'
@param_a = field.mod @param_a
@param_b = field.mod @param_b
end
# Creates a new point.
# The argument can either be an array of integers representing the
# coordinates with x first, or it can be an integer (private key),
# or it can be `:infinity`.
def new_point(p)
case p
when :infinity
infinity
when Array
x, y = p
Point.new(self, x, y)
when Integer
generator.multiply_by_scalar(p)
else
raise ArgumentError, "Invalid point specifier #{p.inspect}."
end
end
# Returns the infinity point.
#
# @return (Point)
def infinity
@infinity ||= Point.new(self, :infinity)
end
# The number of bits that it takes to represent a member of the field.
# Log base 2 of the prime p, rounded up.
#
# @return (Integer)
def bit_length
@bit_length ||= ECDSA.bit_length(field.prime)
end
# The number of bytes that it takes to represent a member of the field.
# Log base 256 of the prime p, rounded up.
#
# @return (Integer)
def byte_length
@byte_length ||= ECDSA.byte_length(field.prime)
end
# Returns true if the point is a solution to the curve's defining equation
# or if it is the infinity point.
def include?(point)
return false if point.group != self
point.infinity? or point_satisfies_equation?(point)
end
# Returns true if the point is not infinity, it is a solution to the curve's
# defining equation, and it is a multiple of G. This process is defined in
# SEC1 2.0, Section 3.2.2.1: Elliptic Curve Public Key Partial Validation Primitive
def valid_public_key?(point)
return false if point.group != self
return false if point.infinity?
return false if !point_satisfies_equation?(point)
point.multiply_by_scalar(order).infinity?
end
# Returns true if the point is not infinity and it is a solution to
# the curve's defining equation. This is defined in
# SEC1 2.0, Section 3.2.3.1: Elliptic Curve Public Key Partial Validation Primitive
def partially_valid_public_key?(point)
return false if point.group != self
return false if point.infinity?
point_satisfies_equation?(point)
end
# Given the x coordinate of a point, finds all possible corresponding y coordinates.
#
# @return (Array)
def solve_for_y(x)
field.square_roots equation_right_hand_side x
end
# @return (String)
def inspect
"#<#{self.class}:#{name}>"
end
# @return (String)
def to_s
inspect
end
private
def point_satisfies_equation?(point)
field.square(point.y) == equation_right_hand_side(point.x)
end
def equation_right_hand_side(x)
field.mod(x * x * x + param_a * x + param_b)
end
NAMES = %w(
Nistp192
Nistp224
Nistp256
Nistp384
Nistp521
Secp112r1
Secp112r2
Secp128r1
Secp128r2
Secp160k1
Secp160r1
Secp160r2
Secp192k1
Secp192r1
Secp224k1
Secp224r1
Secp256k1
Secp256r1
Secp384r1
Secp521r1
)
NAMES.each do |name|
autoload name, 'ecdsa/group/' + name.downcase
end
# Group#infinity_point was deprecated in favor of #infinity.
# This alias is for backwards compatibility with versions 0.1.4 and before.
alias_method :infinity_point, :infinity
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/group/ 0000755 0000000 0000000 00000000000 13546435715 017574 5 ustar 0000000 0000000 ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/point.rb 0000644 0000000 0000000 00000012504 13546435715 020120 0 ustar 0000000 0000000 module ECDSA
# Instances of this class represent a point on an elliptic curve.
# The instances hold their `x` and `y` coordinates along with a reference to
# the {Group} (curve) they belong to.
#
# An instance of this class can also represent the infinity point
# (the additive identity of the group), in which case `x` and `y` are `nil`.
#
# Note: These {Point} objects are not checked when they are created so they
# might not actually be on the curve. You can use {Group#include?} to see if
# they are on the curve.
class Point
# @return {Group} the curve that the point is on.
attr_reader :group
# @return (Integer or nil) the x coordinate, or nil for the infinity point.
attr_reader :x
# @return (Integer or nil) the y coordinate, or nil for the infinity point.
attr_reader :y
# Creates a new instance of {Point}.
# This method is NOT part of the public interface of the ECDSA gem.
# You should call {Group#new_point} instead of calling this directly.
#
# @param group (Group)
# @param args Either the x and y coordinates as integers, or just
# `:infinity` to create the infinity point.
def initialize(group, *args)
@group = group
if args == [:infinity]
@infinity = true
# leave @x and @y nil
else
x, y = args
raise ArgumentError, "Invalid x: #{x.inspect}" if !x.is_a? Integer
raise ArgumentError, "Invalid y: #{y.inspect}" if !y.is_a? Integer
@x = x
@y = y
end
end
# Returns an array of the coordinates, with `x` first and `y` second.
#
# @return (Array)
def coords
[x, y]
end
# Adds this point to another point on the same curve using the standard
# rules for point addition defined in section 2.2.1 of
# [SEC1](http://www.secg.org/collateral/sec1_final.pdf).
#
# @param other (Point)
# @return The sum of the two points.
def add_to_point(other)
check_group! other
# Assertions:
# raise "point given (#{point.inspect}) does not belong to #{group.name}" if !group.include?(point)
# raise "point (#{inspect}) does not belong to #{group.name}" if !group.include?(self)
# Rules 1 and 2
return other if infinity?
return self if other.infinity?
# Rule 3
return group.infinity if x == other.x && y == field.mod(-other.y)
# Rule 4
if x != other.x
gamma = field.mod((other.y - y) * field.inverse(other.x - x))
sum_x = field.mod(gamma * gamma - x - other.x)
sum_y = field.mod(gamma * (x - sum_x) - y)
return self.class.new(group, sum_x, sum_y)
end
# Rule 5
return double if self == other
raise "Failed to add #{inspect} to #{other.inspect}: No addition rules matched."
end
# (see #add_to_point)
alias_method :+, :add_to_point
# Returns the additive inverse of the point.
#
# @return (Point)
def negate
return self if infinity?
self.class.new(group, x, field.mod(-y))
end
# Returns the point added to itself.
#
# This algorithm is defined in
# [SEC1](http://www.secg.org/collateral/sec1_final.pdf), Section 2.2.1,
# Rule 5.
#
# @return (Point)
def double
return self if infinity?
gamma = field.mod((3 * x * x + @group.param_a) * field.inverse(2 * y))
new_x = field.mod(gamma * gamma - 2 * x)
new_y = field.mod(gamma * (x - new_x) - y)
self.class.new(group, new_x, new_y)
end
# Returns the point multiplied by a non-negative integer.
#
# @param i (Integer)
# @return (Point)
def multiply_by_scalar(i)
raise ArgumentError, 'Scalar is not an integer.' if !i.is_a?(Integer)
raise ArgumentError, 'Scalar is negative.' if i < 0
result = group.infinity
v = self
while i > 0
result = result.add_to_point(v) if i.odd?
v = v.double
i >>= 1
end
result
end
# (see #multiply_by_scalar)
alias_method :*, :multiply_by_scalar
# Compares this point to another.
#
# @return (true or false) true if the points are equal
def eql?(other)
return false if !other.is_a?(Point) || other.group != group
x == other.x && y == other.y
end
# Compares this point to another.
#
# @return (true or false) true if the points are equal
def ==(other)
eql?(other)
end
# Returns a hash for this point so it can be stored in hash tables
# with the expected behavior. Two points that have the same coordinates
# and are on the same curve are equal, so they should not get separate
# spots in a hash table.
#
# @return (Integer)
def hash
[group, x, y].hash
end
# Returns true if this instance represents the infinity point (the additive
# identity of the group).
#
# @return (true or false)
def infinity?
@infinity == true
end
# Returns a string showing the value of the point which is useful for
# debugging.
#
# @return (String)
def inspect
if infinity?
'#<%s: %s, infinity>' % [self.class, group.name]
else
'#<%s: %s, 0x%x, 0x%x>' % [self.class, group.name, x, y]
end
end
private
def check_group!(point)
raise 'Mismatched groups.' if point.group != group
end
def field
group.field
end
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/prime_field.rb 0000644 0000000 0000000 00000013144 13546435715 021247 0 ustar 0000000 0000000 module ECDSA
# Instances of this class represent a field where the elements are non-negative
# integers less than a prime *p*.
#
# To add two elements of the field:
#
# ```ruby
# sum = field.mod(a + b)
# ```
#
# To multiply two elements of the field:
#
# ```ruby
# product = field.mod(a * b)
# ```
class PrimeField
# @return (Integer) the prime number that the field is based on.
attr_reader :prime
def initialize(prime)
raise ArgumentError, "Invalid prime #{prime.inspect}" if !prime.is_a?(Integer)
@prime = prime
end
# Returns true if the given object is an integer and a member of the field.
# @param e (Object)
# @return (true or false)
def include?(e)
e.is_a?(Integer) && e >= 0 && e < prime
end
# Calculates the remainder of `n` after being divided by the field's prime.
# @param n (Integer)
# @return (Integer)
def mod(n)
n % prime
end
# Computes the multiplicative inverse of a field element using the
# [Extended Euclidean Algorithm](http://en.wikipedia.org/wiki/Extended_Euclidean_algorithm).
#
# @param n (Integer)
# @return (Integer) integer `inv` such that `(inv * num) % prime` is one.
def inverse(n)
raise ArgumentError, '0 has no multiplicative inverse.' if n.zero?
# For every i, we make sure that num * s[i] + prime * t[i] = r[i].
# Eventually r[i] will equal 1 because gcd(num, prime) is always 1.
# At that point, s[i] is the multiplicative inverse of num in the field.
remainders = [n, prime]
s = [1, 0]
t = [0, 1]
arrays = [remainders, s, t]
while remainders.last > 0
quotient = remainders[-2] / remainders[-1]
arrays.each do |array|
array << array[-2] - quotient * array[-1]
end
end
raise 'Inversion bug: remainder is not 1.' if remainders[-2] != 1
mod s[-2]
end
# Computes `n` raised to the power `m`.
# This algorithm uses the same idea as {Point#multiply_by_scalar}.
#
# @param n (Integer) the base
# @param m (Integer) the exponent
# @return (Integer)
def power(n, m)
result = 1
v = n
while m > 0
result = mod result * v if m.odd?
v = square v
m >>= 1
end
result
end
# Computes `n` multiplied by itself.
# @param n (Integer)
# @return (Integer)
def square(n)
mod n * n
end
# Finds all possible square roots of the given field element.
#
# @param n (Integer)
# @return (Array) A sorted array of numbers whose square is equal to `n`.
def square_roots(n)
raise ArgumentError, "Not a member of the field: #{n}." if !include?(n)
case
when prime == 2 then [n]
when (prime % 4) == 3 then square_roots_for_p_3_mod_4(n)
when (prime % 8) == 5 then square_roots_for_p_5_mod_8(n)
else square_roots_default(n)
end
end
# This method is NOT part of the public API of the ECDSA gem.
def self.factor_out_twos(x)
e = 0
while x.even?
x /= 2
e += 1
end
[e, x]
end
# This method is NOT part of the public API of the ECDSA gem.
#
# Algorithm algorithm 2.149 from http://cacr.uwaterloo.ca/hac/
def self.jacobi(n, p)
raise 'Jacobi symbol is not defined for primes less than 3.' if p < 3
n = n % p
return 0 if n == 0 # Step 1
return 1 if n == 1 # Step 2
e, n1 = factor_out_twos n # Step 3
s = (e.even? || [1, 7].include?(p % 8)) ? 1 : -1 # Step 4
s = -s if (p % 4) == 3 && (n1 % 4) == 3 # Step 5
# Step 6 and 7
return s if n1 == 1
s * jacobi(p, n1)
end
private
def jacobi(n)
self.class.send(:jacobi, n, prime)
end
# This is Algorithm 1 from https://www.math.arizona.edu/~jeremybooher/expos/sqr_qnr.pdf
# It is also Algorithm 3.36 from http://cacr.uwaterloo.ca/hac/
# The algorithm assumes that its input actually does have a square root.
# To get around that, we double check the answer after running the algorithm to make
# sure it works.
def square_roots_for_p_3_mod_4(n)
candidate = power n, (prime + 1) / 4
square_roots_given_candidate n, candidate
end
# This is Algorithm 3.37 from http://cacr.uwaterloo.ca/hac/
def square_roots_for_p_5_mod_8(n)
case power n, (prime - 1) / 4
when 1
candidate = power n, (prime + 3) / 8
when prime - 1
candidate = mod 2 * n * power(4 * n, (prime - 5) / 8)
else
# I think this can happen because we are not checking the Jacobi.
return []
end
square_roots_given_candidate n, candidate
end
# This is Algorithm 3.34 from http://cacr.uwaterloo.ca/hac/
# It has no limitations except prime must be at least three, so we could
# remove all the other square root algorithms if we wanted to.
def square_roots_default(n)
return [0] if n == 0
return [] if jacobi(n) == -1 # Step 1
# Step 2, except we don't want to use randomness.
b = (1...prime).find { |i| jacobi(i) == -1 }
s, t = self.class.factor_out_twos(prime - 1) # Step 3
n_inv = inverse(n) # Step 4
# Step 5
c = power b, t
r = power n, (t + 1) / 2
# Step 6
(1...s).each do |i|
d = power r * r * n_inv, 1 << (s - i - 1)
r = mod r * c if d == prime - 1
c = square c
end
square_roots_given_candidate n, r
end
def square_roots_given_candidate(n, candidate)
return [] if square(candidate) != n
[candidate, mod(-candidate)].uniq.sort
end
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/recover_public_key.rb 0000644 0000000 0000000 00000004547 13546435715 022652 0 ustar 0000000 0000000 module ECDSA
# Recovers the set of possible public keys from a {Signature} and the digest
# that it signs.
#
# If you do not pass a block to `recover_public_key` then it returns an
# Enumerator that will lazily find more public keys when needed. If you
# are going to iterate through the enumerator more than once, you should
# probably convert it to an array first with `to_a` to save CPU time.
#
# If you pass a block, it will yield the public keys to the block one at a
# time as it finds them.
#
# This is better than just returning an array of all possibilities, because
# it allows the caller to stop the algorithm when the desired public key has
# been found, saving CPU time.
#
# This algorithm comes from Section 4.1.6 of [SEC1 2.0](http://www.secg.org/download/aid-780/sec1-v2.pdf)
#
# @param group (Group)
# @param digest (String or Integer)
# @param signature (Signature)
def self.recover_public_key(group, digest, signature)
return enum_for(:recover_public_key, group, digest, signature) if !block_given?
digest = normalize_digest(digest, group.bit_length)
each_possible_temporary_public_key(group, digest, signature) do |point|
yield calculate_public_key(group, digest, signature, point)
end
nil
end
private
def self.each_possible_temporary_public_key(group, digest, signature)
# Instead of using the cofactor as the iteration limit as specified in SEC1,
# we just iterate until x is too large to fit in the underlying field.
# That way we don't have to know the cofactor of the group.
signature.r.step(group.field.prime - 1, group.order) do |x|
group.solve_for_y(x).each do |y|
point = group.new_point [x, y]
yield point if point.multiply_by_scalar(group.order).infinity?
end
end
end
# Assuming that we know the public key corresponding to the (random) temporary
# private key used during signing, this method tells us what the actual
# public key was.
def self.calculate_public_key(group, digest, signature, temporary_public_key)
point_field = PrimeField.new(group.order)
# public key = (tempPubKey * s - G * e) / r
rs = temporary_public_key.multiply_by_scalar(signature.s)
ge = group.generator.multiply_by_scalar(digest)
r_inv = point_field.inverse(signature.r)
rs.add_to_point(ge.negate).multiply_by_scalar(r_inv)
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/sign.rb 0000644 0000000 0000000 00000004041 13546435715 017724 0 ustar 0000000 0000000 module ECDSA
# Produces an ECDSA signature.
#
# This algorithm comes from section 4.1.3 of [SEC1](http://www.secg.org/collateral/sec1_final.pdf).
#
# @param group (Group) The curve that is being used.
# @param private_key (Integer) The private key. (The number of times to add
# the generator point to itself to get the public key.)
# @param digest (String or Integer)
# A digest of the message to be signed, usually generated with a hashing algorithm
# like SHA2. The same algorithm must be used when verifying the signature.
# @param temporary_key (Integer)
# A temporary private key.
# This is also known as "k" or "nonce".
# Warning: Never use the same `temporary_key` value twice for two different messages
# or else it will be easy for someone to calculate your private key.
# The `temporary_key` should be generated with a secure random number generator.
# @return (Signature or nil) Usually this method returns a {Signature}, but
# there is a very small chance that the calculated "s" value for the
# signature will be 0, in which case the method returns nil. If that happens,
# you should generate a new temporary key and try again.
def self.sign(group, private_key, digest, temporary_key)
# TODO: add an option for specifying that the s value should be low,
# which is needed by systems like Bitcoin: https://github.com/bitcoin/bips/blob/master/bip-0062.mediawiki#low-s-values-in-signatures
# Second part of step 1: Select ephemeral elliptic curve key pair
# temporary_key was already selected for us by the caller
r_point = group.new_point temporary_key
# Steps 2 and 3
point_field = PrimeField.new(group.order)
r = point_field.mod(r_point.x)
return nil if r.zero?
# Step 4, calculating the hash, was already performed by the caller.
# Step 5
e = normalize_digest(digest, group.bit_length)
# Step 6
s = point_field.mod(point_field.inverse(temporary_key) * (e + r * private_key))
return nil if s.zero?
Signature.new r, s
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/signature.rb 0000644 0000000 0000000 00000001203 13546435715 020762 0 ustar 0000000 0000000 module ECDSA
# Instances of this class represents ECDSA signatures,
# which are simply a pair of integers named `r` and `s`.
class Signature
# @return (Integer)
attr_reader :r
# @return (Integer)
attr_reader :s
# @param r (Integer) the value of r.
# @param s (Integer) the value of s.
def initialize(r, s)
@r, @s = r, s
r.is_a?(Integer) or raise ArgumentError, 'r is not an integer.'
s.is_a?(Integer) or raise ArgumentError, 's is not an integer.'
end
# Returns an array containing `r` first and `s` second.
# @return (Array)
def components
[r, s]
end
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/verify.rb 0000644 0000000 0000000 00000004410 13546435715 020270 0 ustar 0000000 0000000 module ECDSA
# An instance of this class is raised if the signature is invalid.
class InvalidSignatureError < StandardError
end
# Verifies the given {Signature} and returns true if it is valid.
#
# This algorithm comes from Section 4.1.4 of [SEC1](http://www.secg.org/collateral/sec1_final.pdf).
#
# @param public_key (Point)
# @param digest (String or Integer)
# @param signature (Signature)
# @return true if the ECDSA signature if valid, returns false otherwise.
def self.valid_signature?(public_key, digest, signature)
check_signature! public_key, digest, signature
rescue InvalidSignatureError
false
end
# Verifies the given {Signature} and raises an {InvalidSignatureError} if it
# is invalid.
#
# This algorithm comes from Section 4.1.4 of [SEC1](http://www.secg.org/collateral/sec1_final.pdf).
#
# @param public_key (Point)
# @param digest (String or Integer)
# @param signature (Signature)
# @return true
def self.check_signature!(public_key, digest, signature)
group = public_key.group
field = group.field
# Step 1: r and s must be in the field and non-zero
raise InvalidSignatureError, 'Invalid signature: r is not in the field.' if !field.include?(signature.r)
raise InvalidSignatureError, 'Invalid signature: s is not in the field.' if !field.include?(signature.s)
raise InvalidSignatureError, 'Invalid signature: r is zero.' if signature.r.zero?
raise InvalidSignatureError, 'Invalid signature: s is zero.' if signature.s.zero?
# Step 2 was already performed when the digest of the message was computed.
# Step 3: Convert octet string to number and take leftmost bits.
e = normalize_digest(digest, group.bit_length)
# Step 4
point_field = PrimeField.new(group.order)
s_inverted = point_field.inverse(signature.s)
u1 = point_field.mod(e * s_inverted)
u2 = point_field.mod(signature.r * s_inverted)
# Step 5
r = group.generator.multiply_by_scalar(u1).add_to_point public_key.multiply_by_scalar(u2)
raise InvalidSignatureError, 'Invalid signature: r is infinity in step 5.' if r.infinity?
# Steps 6 and 7
v = point_field.mod r.x
# Step 8
raise InvalidSignatureError, 'Invalid signature: v does not equal r.' if v != signature.r
true
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/version.rb 0000644 0000000 0000000 00000000045 13546435715 020451 0 ustar 0000000 0000000 module ECDSA
VERSION = '1.2.0'
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/format/decode_error.rb 0000644 0000000 0000000 00000000574 13546435715 022717 0 ustar 0000000 0000000 module ECDSA
module Format
# Raising instance of this class as an exception indicates that
# the data being decoded was invalid, but does not necessarily
# indicate a bug in the program, unlike most other exceptions
# because it is possible the data being decoded is coming from
# an untrusted source.
class DecodeError < StandardError
end
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/format/field_element_octet_string.rb 0000644 0000000 0000000 00000002576 13546435715 025647 0 ustar 0000000 0000000 module ECDSA
module Format
# This module provides methods for converting elements of a field to octet
# strings. The conversions are defined in these sections of
# [SEC1](http://www.secg.org/collateral/sec1_final.pdf):
#
# * Section 2.3.5: FieldElement-to-OctetString Conversion
# * Section 2.3.6: OctetString-to-FieldElement Conversion
module FieldElementOctetString
# Converts a field element to an octet string.
#
# @param element (Integer) The integer to encode.
# @param field (PrimeField)
# @return (String)
def self.encode(element, field)
raise ArgumentError, 'Given element is not an element of the field.' if !field.include?(element)
length = ECDSA.byte_length(field.prime)
IntegerOctetString.encode(element, length)
end
# Converts an octet string to a field element.
# Raises a {DecodeError} if the input string is invalid for any reason.
#
# @param string (String)
# @param field (PrimeField)
# @return (Integer)
def self.decode(string, field)
int = IntegerOctetString.decode(string)
if !field.include?(int)
# The integer has to be non-negative, so it must be too big.
raise DecodeError, 'Decoded integer is too large for field: 0x%x >= 0x%x.' % [int, field.prime]
end
int
end
end
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/format/integer_octet_string.rb 0000644 0000000 0000000 00000002435 13546435715 024502 0 ustar 0000000 0000000 module ECDSA
module Format
# This module provides methods for converting integers to big endian octet
# strings. The conversions are defined in these sections of
# [SEC1](http://www.secg.org/collateral/sec1_final.pdf):
#
# * Section 2.3.7: Integer-to-OctetString Conversion
# * Section 2.3.8: OctetString-to-Integer Conversion
#
# We use Ruby integers to represent bit strings, so this module can also be
# thought of as implementing these sections of SEC1:
#
# * Section 2.3.1: BitString-to-OctetString Conversion
# * Section 2.3.2: OctetString-to-BitString Conversion
module IntegerOctetString
# @param integer (Integer) The integer to encode.
# @param length (Integer) The number of bytes desired in the output string.
# @return (String)
def self.encode(integer, length)
raise ArgumentError, 'Integer to encode is negative.' if integer < 0
raise ArgumentError, 'Integer to encode is too large.' if integer >= (1 << (8 * length))
(length - 1).downto(0).map do |i|
(integer >> (8 * i)) & 0xFF
end.pack('C*')
end
# @param string (String)
# @return (Integer)
def self.decode(string)
string.bytes.reduce { |n, b| (n << 8) + b }
end
end
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/format/point_octet_string.rb 0000644 0000000 0000000 00000007262 13546435715 024201 0 ustar 0000000 0000000 # encoding: ASCII-8BIT
require_relative '../point'
module ECDSA
module Format
# This module provides methods for converting between {Point} objects and "octet strings",
# which are just strings with binary data in them that have the coordinates of the point.
# The point octet string format is defined in two sections of [SEC1](http://www.secg.org/collateral/sec1_final.pdf):
#
# * Section 2.3.3: EllipticCurvePoint-to-OctetString Conversion
# * Section 2.3.4: OctetString-to-EllipticCurvePoint Conversion
module PointOctetString
# Converts a {Point} to an octet string.
#
# @param point (Point)
# @param opts (Hash)
# @option opts :compression Set this option to true to generate a compressed
# octet string, which only has one bit of the Y coordinate.
# (Default: false)
def self.encode(point, opts = {})
return "\x00" if point.infinity?
if opts[:compression]
start_byte = point.y.even? ? "\x02" : "\x03"
start_byte + FieldElementOctetString.encode(point.x, point.group.field)
else
"\x04" +
FieldElementOctetString.encode(point.x, point.group.field) +
FieldElementOctetString.encode(point.y, point.group.field)
end
end
# Converts an octet string to a {Point} in the specified group.
# Raises a {DecodeError} if the string is invalid for any reason.
#
# This is equivalent to
# [ec_GFp_simple_oct2point](https://github.com/openssl/openssl/blob/a898936/crypto/ec/ecp_oct.c#L325)
# in OpenSSL.
#
# @param string (String)
# @param group (Group)
# @return (Point)
def self.decode(string, group)
string = string.dup.force_encoding('BINARY')
raise DecodeError, 'Point octet string is empty.' if string.empty?
case string[0].ord
when 0
check_length string, 1
return group.infinity
when 2
decode_compressed string, group, 0
when 3
decode_compressed string, group, 1
when 4
decode_uncompressed string, group
else
raise DecodeError, 'Unrecognized start byte for point octet string: 0x%x' % string[0].ord
end
end
private
def self.decode_compressed(string, group, y_lsb)
expected_length = 1 + group.byte_length
check_length string, expected_length
x_string = string[1, group.byte_length]
x = ECDSA::Format::FieldElementOctetString.decode x_string, group.field
possible_ys = group.solve_for_y(x)
y = possible_ys.find { |py| (py % 2) == y_lsb }
raise DecodeError, 'Could not solve for y.' if y.nil?
finish_decode x, y, group
end
def self.decode_uncompressed(string, group)
expected_length = 1 + 2 * group.byte_length
check_length string, expected_length
x_string = string[1, group.byte_length]
y_string = string[1 + group.byte_length, group.byte_length]
x = ECDSA::Format::FieldElementOctetString.decode x_string, group.field
y = ECDSA::Format::FieldElementOctetString.decode y_string, group.field
finish_decode x, y, group
end
def self.finish_decode(x, y, group)
point = group.new_point [x, y]
if !group.include? point
raise DecodeError, "Decoded point does not satisfy curve equation: #{point.inspect}."
end
point
end
def self.check_length(string, expected_length)
if string.length != expected_length
raise DecodeError, "Expected point octet string to be length #{expected_length} but it was #{string.length}."
end
end
end
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/format/signature_der_string.rb 0000644 0000000 0000000 00000001736 13546435715 024505 0 ustar 0000000 0000000 require 'openssl'
require_relative '../signature'
module ECDSA
module Format
# This module provides methods to convert between {Signature} objects and their
# binary DER representation. The format used is defined in
# [RFC 3278 section 8.2](http://tools.ietf.org/html/rfc3278#section-8.2).
module SignatureDerString
# Converts a DER string to a {Signature}.
# @param der_string (String)
# @return (Signature)
def self.decode(der_string)
asn1 = OpenSSL::ASN1.decode(der_string)
r = asn1.value[0].value.to_i
s = asn1.value[1].value.to_i
Signature.new(r, s)
end
# Converts a {Signature} to a DER string.
# @param signature (Signature)
# @return (String)
def self.encode(signature)
asn1 = OpenSSL::ASN1::Sequence.new [
OpenSSL::ASN1::Integer.new(signature.r),
OpenSSL::ASN1::Integer.new(signature.s),
]
asn1.to_der
end
end
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/group/nistp192.rb 0000644 0000000 0000000 00000001074 13546435715 021514 0 ustar 0000000 0000000 # Source: http://csrc.nist.gov/groups/ST/toolkit/documents/dss/NISTReCur.pdf
module ECDSA
class Group
Nistp192 = new(
name: 'nistp192',
p: 62771017353866807638357894232076664160839087_00390324961279,
a: -3,
b: 0x64210519_e59c80e7_0fa7e9ab_72243049_feb8deec_c146b9b1,
g: [0x188da80e_b03090f6_7cbf20eb_43a18800_f4ff0afd_82ff1012,
0x07192b95_ffc8da78_631011ed_6b24cdd5_73f977a1_1e794811],
n: 62771017353866807638357894231760590137671947_73182842284081,
h: nil, # cofactor not given in NIST document
)
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/group/nistp224.rb 0000644 0000000 0000000 00000001153 13546435715 021506 0 ustar 0000000 0000000 # Source: http://csrc.nist.gov/groups/ST/toolkit/documents/dss/NISTReCur.pdf
module ECDSA
class Group
Nistp224 = new(
name: 'nistp224',
p: 26959946667150639794667015087019630673557916_260026308143510066298881,
a: -3,
b: 0xb4050a85_0c04b3ab_f5413256_5044b0b7_d7bfd8ba_270b3943_2355ffb4,
g: [0xb70e0cbd_6bb4bf7f_321390b9_4a03c1d3_56c21122_343280d6_115c1d21,
0xbd376388_b5f723fb_4c22dfe6_cd4375a0_5a074764_44d58199_85007e34],
n: 26959946667150639794667015087019625940457807_714424391721682722368061,
h: nil, # cofactor not given in NIST document
)
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/group/nistp256.rb 0000644 0000000 0000000 00000001232 13546435715 021511 0 ustar 0000000 0000000 # Source: http://csrc.nist.gov/groups/ST/toolkit/documents/dss/NISTReCur.pdf
module ECDSA
class Group
Nistp256 = new(
name: 'nistp256',
p: 11579208921035624876269744694940757353008614_3415290314195533631308867097853951,
a: -3,
b: 0x5ac635d8_aa3a93e7_b3ebbd55_769886bc_651d06b0_cc53b0f6_3bce3c3e_27d2604b,
g: [0x6b17d1f2_e12c4247_f8bce6e5_63a440f2_77037d81_2deb33a0_f4a13945_d898c296,
0x4fe342e2_fe1a7f9b_8ee7eb4a_7c0f9e16_2bce3357_6b315ece_cbb64068_37bf51f5],
n: 11579208921035624876269744694940757352999695_5224135760342422259061068512044369,
h: nil, # cofactor not given in NIST document
)
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/group/nistp384.rb 0000644 0000000 0000000 00000001537 13546435715 021523 0 ustar 0000000 0000000 # Source: http://csrc.nist.gov/groups/ST/toolkit/documents/dss/NISTReCur.pdf
module ECDSA
class Group
Nistp384 = new(
name: 'nistp384',
p: 39402006196394479212279040100143613805079739_27046544666794829340424572177149687032904726_6088258938001861606973112319,
a: -3,
b: 0xb3312fa7_e23ee7e4_988e056b_e3f82d19_181d9c6e_fe814112_0314088f_5013875a_c656398d_8a2ed19d_2a85c8ed_d3ec2aef,
g: [0xaa87ca22_be8b0537_8eb1c71e_f320ad74_6e1d3b62_8ba79b98_59f741e0_82542a38_5502f25d_bf55296c_3a545e38_72760ab7,
0x3617de4a_96262c6f_5d9e98bf_9292dc29_f8f41dbd_289a147c_e9da3113_b5f0b8c0_0a60b1ce_1d7e819d_7a431d7c_90ea0e5f,
],
n: 39402006196394479212279040100143613805079739_27046544666794690527962765939911326356939895_6308152294913554433653942643,
h: nil, # cofactor not given in NIST document
)
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/group/nistp521.rb 0000644 0000000 0000000 00000002065 13546435715 021511 0 ustar 0000000 0000000 # Source: "Curve P-256" from http://csrc.nist.gov/groups/ST/toolkit/documents/dss/NISTReCur.doc
module ECDSA
class Group
Nistp521 = new(
name: 'nistp521',
p: 68647976601306097149819007990813932172694353_00143305409394463459185543183397656052122559_64066145455497729631139148085803712198799971_6643812574028291115057151,
a: -3,
b: 0x051_953eb961_8e1c9a1f_929a21a0_b68540ee_a2da725b_99b315f3_b8b48991_8ef109e1_56193951_ec7e937b_1652c0bd_3bb1bf07_3573df88_3d2c34f1_ef451fd4_6b503f00,
g: [0x00c6_858e06b7_0404e9cd_9e3ecb66_2395b442_9c648139_053fb521_f828af60_6b4d3dba_a14b5e77_efe75928_fe1dc127_a2ffa8de_3348b3c1_856a429b_f97e7e31_c2e5bd66,
0x0118_39296a78_9a3bc004_5c8a5fb4_2c7d1bd9_98f54449_579b4468_17afbd17_273e662c_97ee7299_5ef42640_c550b901_3fad0761_353c7086_a272c240_88be9476_9fd16650],
n: 68647976601306097149819007990813932172694353_00143305409394463459185543183397655394245057_74633321719753296399637136332111386476861244_0380340372808892707005449,
h: nil, # cofactor not given in NIST document
)
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/group/secp112r1.rb 0000644 0000000 0000000 00000000651 13546435715 021544 0 ustar 0000000 0000000 # Source: http://www.secg.org/collateral/sec2_final.pdf
module ECDSA
class Group
Secp112r1 = new(
name: 'secp112r1',
p: 0xDB7C_2ABF62E3_5E668076_BEAD208B,
a: 0xDB7C_2ABF62E3_5E668076_BEAD2088,
b: 0x659E_F8BA0439_16EEDE89_11702B22,
g: [0x0948_7239995A_5EE76B55_F9C2F098,
0xA89C_E5AF8724_C0A23E0E_0FF77500],
n: 0xDB7C_2ABF62E3_5E7628DF_AC6561C5,
h: 1,
)
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/group/secp112r2.rb 0000644 0000000 0000000 00000000651 13546435715 021545 0 ustar 0000000 0000000 # Source: http://www.secg.org/collateral/sec2_final.pdf
module ECDSA
class Group
Secp112r2 = new(
name: 'secp112r2',
p: 0xDB7C_2ABF62E3_5E668076_BEAD208B,
a: 0x6127_C24C05F3_8A0AAAF6_5C0EF02C,
b: 0x51DE_F1815DB5_ED74FCC3_4C85D709,
g: [0x4BA3_0AB5E892_B4E1649D_D0928643,
0xADCD_46F5882E_3747DEF3_6E956E97],
n: 0x36DF_0AAFD8B8_D7597CA1_0520D04B,
h: 4,
)
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/group/secp128r1.rb 0000644 0000000 0000000 00000000701 13546435715 021547 0 ustar 0000000 0000000 # Source: http://www.secg.org/collateral/sec2_final.pdf
module ECDSA
class Group
Secp128r1 = new(
name: 'secp128r1',
p: 0xFFFFFFFD_FFFFFFFF_FFFFFFFF_FFFFFFFF,
a: 0xFFFFFFFD_FFFFFFFF_FFFFFFFF_FFFFFFFC,
b: 0xE87579C1_1079F43D_D824993C_2CEE5ED3,
g: [0x161FF752_8B899B2D_0C28607C_A52C5B86,
0xCF5AC839_5BAFEB13_C02DA292_DDED7A83],
n: 0xFFFFFFFE_00000000_75A30D1B_9038A115,
h: 1,
)
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/group/secp128r2.rb 0000644 0000000 0000000 00000000701 13546435715 021550 0 ustar 0000000 0000000 # Source: http://www.secg.org/collateral/sec2_final.pdf
module ECDSA
class Group
Secp128r2 = new(
name: 'secp128r2',
p: 0xFFFFFFFD_FFFFFFFF_FFFFFFFF_FFFFFFFF,
a: 0xD6031998_D1B3BBFE_BF59CC9B_BFF9AEE1,
b: 0x5EEEFCA3_80D02919_DC2C6558_BB6D8A5D,
g: [0x7B6AA5D8_5E572983_E6FB32A7_CDEBC140,
0x27B6916A_894D3AEE_7106FE80_5FC34B44],
n: 0x3FFFFFFF_7FFFFFFF_BE002472_0613B5A3,
h: 4,
)
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/group/secp160k1.rb 0000644 0000000 0000000 00000000640 13546435715 021536 0 ustar 0000000 0000000 # Source: http://www.secg.org/collateral/sec2_final.pdf
module ECDSA
class Group
Secp160k1 = new(
name: 'secp160k1',
p: 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFE_FFFFAC73,
a: 0,
b: 7,
g: [0x3B4C382C_E37AA192_A4019E76_3036F4F5_DD4D7EBB,
0x938CF935_318FDCED_6BC28286_531733C3_F03C4FEE],
n: 0x01_00000000_00000000_0001B8FA_16DFAB9A_CA16B6B3,
h: 1,
)
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/group/secp160r1.rb 0000644 0000000 0000000 00000000772 13546435715 021553 0 ustar 0000000 0000000 # Source: http://www.secg.org/collateral/sec2_final.pdf
module ECDSA
class Group
Secp160r1 = new(
name: 'secp160r1',
p: 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_7FFFFFFF,
a: 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_7FFFFFFC,
b: 0x1C97BEFC_54BD7A8B_65ACF89F_81D4D4AD_C565FA45,
g: [0x4A96B568_8EF57328_46646989_68C38BB9_13CBFC82,
0x23A62855_3168947D_59DCC912_04235137_7AC5FB32],
n: 0x01_00000000_00000000_0001F4C8_F927AED3_CA752257,
h: 1,
)
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/group/secp160r2.rb 0000644 0000000 0000000 00000000772 13546435715 021554 0 ustar 0000000 0000000 # Source: http://www.secg.org/collateral/sec2_final.pdf
module ECDSA
class Group
Secp160r2 = new(
name: 'secp160r2',
p: 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFE_FFFFAC73,
a: 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFE_FFFFAC70,
b: 0xB4E134D3_FB59EB8B_AB572749_04664D5A_F50388BA,
g: [0x52DCB034_293A117E_1F4FF11B_30F7199D_3144CE6D,
0xFEAFFEF2_E331F296_E071FA0D_F9982CFE_A7D43F2E],
n: 0x01_00000000_00000000_0000351E_E786A818_F3A1A16B,
h: 1,
)
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/group/secp192k1.rb 0000644 0000000 0000000 00000000701 13546435715 021541 0 ustar 0000000 0000000 # Source: http://www.secg.org/collateral/sec2_final.pdf
module ECDSA
class Group
Secp192k1 = new(
name: 'secp192k1',
p: 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFE_FFFFEE37,
a: 0,
b: 3,
g: [0xDB4FF10E_C057E9AE_26B07D02_80B7F434_1DA5D1B1_EAE06C7D,
0x9B2F2F6D_9C5628A7_844163D0_15BE8634_4082AA88_D95E2F9D],
n: 0xFFFFFFFF_FFFFFFFF_FFFFFFFE_26F2FC17_0F69466A_74DEFD8D,
h: 1,
)
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/group/secp192r1.rb 0000644 0000000 0000000 00000001055 13546435715 021553 0 ustar 0000000 0000000 # Source: http://www.secg.org/collateral/sec2_final.pdf
module ECDSA
class Group
Secp192r1 = new(
name: 'secp192r1',
p: 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFE_FFFFFFFF_FFFFFFFF,
a: 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFE_FFFFFFFF_FFFFFFFC,
b: 0x64210519_E59C80E7_0FA7E9AB_72243049_FEB8DEEC_C146B9B1,
g: [0x188DA80E_B03090F6_7CBF20EB_43A18800_F4FF0AFD_82FF1012,
0x07192B95_FFC8DA78_631011ED_6B24CDD5_73F977A1_1E794811],
n: 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_99DEF836_146BC9B1_B4D22831,
h: 1,
)
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/group/secp224k1.rb 0000644 0000000 0000000 00000000750 13546435715 021541 0 ustar 0000000 0000000 # Source: http://www.secg.org/collateral/sec2_final.pdf
module ECDSA
class Group
Secp224k1 = new(
name: 'secp224k1',
p: 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFE_FFFFE56D,
a: 0,
b: 5,
g: [0xA1455B33_4DF099DF_30FC28A1_69A467E9_E47075A9_0F7E650E_B6B7A45C,
0x7E089FED_7FBA3442_82CAFBD6_F7E319F7_C0B0BD59_E2CA4BDB_556D61A5],
n: 0x01_00000000_00000000_00000000_0001DCE8_D2EC6184_CAF0A971_769FB1F7,
h: 1,
)
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/group/secp224r1.rb 0000644 0000000 0000000 00000001143 13546435715 021545 0 ustar 0000000 0000000 # Source: http://www.secg.org/collateral/sec2_final.pdf
module ECDSA
class Group
Secp224r1 = new(
name: 'secp224r1',
p: 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_00000000_00000000_00000001,
a: 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFE_FFFFFFFF_FFFFFFFF_FFFFFFFE,
b: 0xB4050A85_0C04B3AB_F5413256_5044B0B7_D7BFD8BA_270B3943_2355FFB4,
g: [0xB70E0CBD_6BB4BF7F_321390B9_4A03C1D3_56C21122_343280D6_115C1D21,
0xBD376388_B5F723FB_4C22DFE6_CD4375A0_5A074764_44D58199_85007E34],
n: 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFF16A2_E0B8F03E_13DD2945_5C5C2A3D,
h: 1,
)
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/group/secp256k1.rb 0000644 0000000 0000000 00000001250 13546435715 021542 0 ustar 0000000 0000000 # Source: http://www.secg.org/collateral/sec2_final.pdf
module ECDSA
class Group
Secp256k1 = new(
name: 'secp256k1',
p: 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFE_FFFFFC2F,
a: 0,
b: 7,
g: [0x79BE667E_F9DCBBAC_55A06295_CE870B07_029BFCDB_2DCE28D9_59F2815B_16F81798,
0x483ADA77_26A3C465_5DA4FBFC_0E1108A8_FD17B448_A6855419_9C47D08F_FB10D4B8],
n: 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFE_BAAEDCE6_AF48A03B_BFD25E8C_D0364141,
h: 1,
)
# compressed G: "\x02\x79\xBE\x66\x7E\xF9\xDC\xBB\xAC\x55\xA0\x62\x95\xCE\x87\x0B\x07\x02\x9B\xFC\xDB\x2D\xCE\x28\xD9\x59\xF2\x81\x5B\x16\xF8\x17\x98",
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/group/secp256r1.rb 0000644 0000000 0000000 00000001231 13546435715 021550 0 ustar 0000000 0000000 # Source: http://www.secg.org/collateral/sec2_final.pdf
module ECDSA
class Group
Secp256r1 = new(
name: 'secp256r1',
p: 0xFFFFFFFF_00000001_00000000_00000000_00000000_FFFFFFFF_FFFFFFFF_FFFFFFFF,
a: 0xFFFFFFFF_00000001_00000000_00000000_00000000_FFFFFFFF_FFFFFFFF_FFFFFFFC,
b: 0x5AC635D8_AA3A93E7_B3EBBD55_769886BC_651D06B0_CC53B0F6_3BCE3C3E_27D2604B,
g: [0x6B17D1F2_E12C4247_F8BCE6E5_63A440F2_77037D81_2DEB33A0_F4A13945_D898C296,
0x4FE342E2_FE1A7F9B_8EE7EB4A_7C0F9E16_2BCE3357_6B315ECE_CBB64068_37BF51F5],
n: 0xFFFFFFFF_00000000_FFFFFFFF_FFFFFFFF_BCE6FAAD_A7179E84_F3B9CAC2_FC632551,
h: 1,
)
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/group/secp384r1.rb 0000644 0000000 0000000 00000001561 13546435715 021560 0 ustar 0000000 0000000 # Source: http://www.secg.org/collateral/sec2_final.pdf
module ECDSA
class Group
Secp384r1 = new(
name: 'secp384r1',
p: 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFE_FFFFFFFF_00000000_00000000_FFFFFFFF,
a: 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFE_FFFFFFFF_00000000_00000000_FFFFFFFC,
b: 0xB3312FA7_E23EE7E4_988E056B_E3F82D19_181D9C6E_FE814112_0314088F_5013875A_C656398D_8A2ED19D_2A85C8ED_D3EC2AEF,
g: [0xAA87CA22_BE8B0537_8EB1C71E_F320AD74_6E1D3B62_8BA79B98_59F741E0_82542A38_5502F25D_BF55296C_3A545E38_72760AB7,
0x3617DE4A_96262C6F_5D9E98BF_9292DC29_F8F41DBD_289A147C_E9DA3113_B5F0B8C0_0A60B1CE_1D7E819D_7A431D7C_90EA0E5F],
n: 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_C7634D81_F4372DDF_581A0DB2_48B0A77A_ECEC196A_CCC52973,
h: 1,
)
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/lib/ecdsa/group/secp521r1.rb 0000644 0000000 0000000 00000002107 13546435715 021546 0 ustar 0000000 0000000 # Source: http://www.secg.org/collateral/sec2_final.pdf
module ECDSA
class Group
Secp521r1 = new(
name: 'secp521r1',
p: 0x01FF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF,
a: 0x01FF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFC,
b: 0x0051_953EB961_8E1C9A1F_929A21A0_B68540EE_A2DA725B_99B315F3_B8B48991_8EF109E1_56193951_EC7E937B_1652C0BD_3BB1BF07_3573DF88_3D2C34F1_EF451FD4_6B503F00,
g: [0x00C6858E06B70404E9CD9E3ECB662395B4429C648139053FB521F828AF606B4D3DBAA14B5E77EFE75928FE1DC127A2FFA8DE3348B3C1856A429BF97E7E31C2E5BD66,
0x011839296A789A3BC0045C8A5FB42C7D1BD998F54449579B446817AFBD17273E662C97EE72995EF42640C550B9013FAD0761353C7086A272C24088BE94769FD16650],
n: 0x01FF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFA_51868783_BF2F966B_7FCC0148_F709A5D0_3BB5C9B8_899C47AE_BB6FB71E_91386409,
h: 1,
)
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/spec/ecdsa_spec.rb 0000644 0000000 0000000 00000002307 13546435715 020165 0 ustar 0000000 0000000 require 'spec_helper'
describe ECDSA do
describe '.byte_length' do
it 'returns 0 for 0' do
expect(ECDSA.byte_length(0)).to eq 0
end
it 'returns 1 for 254' do
expect(ECDSA.byte_length(254)).to eq 1
end
it 'returns 2 for 256' do
expect(ECDSA.byte_length(256)).to eq 2
end
end
describe '.bit_length' do
it 'returns 0 for 0' do
expect(ECDSA.bit_length(0)).to eq 0
end
it 'returns 8 for 254' do
expect(ECDSA.bit_length(254)).to eq 8
end
it 'returns 16 for 0x8000' do
expect(ECDSA.bit_length(0x8000)).to eq 16
end
end
describe '.normalize_digest' do
it 'does nothing to integers' do
expect(ECDSA.normalize_digest(0x1234, 8)).to eq 0x1234
end
it 'takes the leftmost bits of strings' do
expect(ECDSA.normalize_digest("\x24\xAA", 7)).to eq 0x12
end
it 'raises an exception if the input is not an integer or string' do
expect { ECDSA.normalize_digest(:a, 1) }.to raise_error ArgumentError,
'Digest must be a string or integer.'
end
it 'normalizes string encoding' do
expect(ECDSA.normalize_digest("\xAB\xCD".force_encoding('UTF-16LE'), 8)).to eq 0xAB
end
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/spec/example_spec.rb 0000644 0000000 0000000 00000003044 13546435715 020540 0 ustar 0000000 0000000 describe 'examples in README.md' do
def puts(*a)
end
specify 'typical usage' do
# Generating a private key
require 'ecdsa'
require 'securerandom'
group = ECDSA::Group::Secp256k1
private_key = 1 + SecureRandom.random_number(group.order - 1)
puts 'private key: %#x' % private_key
# Computing the public key for a private key
public_key = group.generator.multiply_by_scalar(private_key)
puts 'public key: '
puts ' x: %#x' % public_key.x
puts ' y: %#x' % public_key.y
# Encoding a public key as a binary string
public_key_string = ECDSA::Format::PointOctetString.encode(public_key, compression: true)
# Decoding a public key from a binary string
public_key = ECDSA::Format::PointOctetString.decode(public_key_string, group)
# Signing a message
require 'digest/sha2'
message = 'ECDSA is cool.'
digest = Digest::SHA2.digest(message)
signature = nil
while signature.nil?
temp_key = 1 + SecureRandom.random_number(group.order - 1)
signature = ECDSA.sign(group, private_key, digest, temp_key)
end
puts 'signature: '
puts ' r: %#x' % signature.r
puts ' s: %#x' % signature.s
# Encoding a signature as a DER string
signature_der_string = ECDSA::Format::SignatureDerString.encode(signature)
# Decoding a signature from a DER string
signature = ECDSA::Format::SignatureDerString.decode(signature_der_string)
# Verifying a signature
valid = ECDSA.valid_signature?(public_key, digest, signature)
puts "valid: #{valid}"
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/spec/format/ 0000755 0000000 0000000 00000000000 13546435715 017035 5 ustar 0000000 0000000 ruby-ecdsa-1.2.0+git20191006.1.ce478ea/spec/group_spec.rb 0000644 0000000 0000000 00000010744 13546435715 020246 0 ustar 0000000 0000000 require 'spec_helper'
describe ECDSA::Group do
subject(:group) { ECDSA::Group::Secp128r2 }
let(:partially_valid_point) do
x = 0xa4ba08661ccb3c0a4f0be92e7d7b3efa
y = group.solve_for_y(x).first
group.new_point [x, y]
end
it '#inspect is nice' do
expect(group.inspect).to eq '#'
end
it '#to_s is the same as inspect' do
expect(group.to_s).to eq group.inspect
end
describe '#infinity' do
it 'returns the infinity point' do
expect(group.infinity).to be_infinity
end
it 'has an alias #infinity_point for backwards compatibility' do
expect(group.method(:infinity_point)).to eq group.method(:infinity)
end
end
describe '#new_point' do
it 'when given :infinity, returns the infinity point' do
expect(group.new_point(:infinity)).to eq group.infinity
end
it 'raises an exception when given something invalid' do
expect { group.new_point(:smile) }.to raise_error ArgumentError,
'Invalid point specifier :smile.'
end
end
describe '#solve_for_y' do
it 'when given the x of the generator point returns y and -y' do
g = group.generator
expect(group.solve_for_y(g.x)).to eq [g.y, group.field.mod(-g.y)].sort
end
end
describe '#include?' do
it 'returns true for the infinity point' do
expect(group).to include group.infinity
end
it 'returns true for the generator' do
expect(group).to include group.generator
end
it 'returns true for a point on the curve that is not a multiple of the generator' do
expect(group).to include partially_valid_point
end
it 'returns false for a point not on the curve' do
expect(group).to_not include group.new_point [44, 55]
end
it 'returns false for a point on the wrong group' do
point = ECDSA::Group::Nistp521.new_point group.generator.coords
expect(group).to_not include point
end
end
describe '#partially_valid_public_key?' do
it 'returns false for the infinity point' do
expect(group).to_not be_partially_valid_public_key group.infinity
end
it 'returns true for the generator' do
expect(group).to be_partially_valid_public_key group.generator
end
it 'returns true for a point on the curve that is not a multiple of the generator' do
expect(group).to be_partially_valid_public_key partially_valid_point
end
it 'returns false for a point not on the curve' do
expect(group).to_not be_partially_valid_public_key group.new_point [44, 55]
end
it 'returns false for a point on the wrong group' do
point = ECDSA::Group::Nistp521.new_point group.generator.coords
expect(group).to_not be_partially_valid_public_key point
end
end
describe '#valid_public_key?' do
it 'returns false for the infinity point' do
expect(group).to_not be_valid_public_key group.infinity
end
it 'returns true for the generator' do
expect(group).to be_valid_public_key group.generator
end
it 'returns false for a point on the curve that is not a multiple of the generator' do
expect(group).to_not be_valid_public_key partially_valid_point
end
it 'returns false for a point not on the curve' do
expect(group).to_not be_valid_public_key group.new_point [44, 55]
end
it 'returns false for a point on the wrong group' do
point = ECDSA::Group::Nistp521.new_point group.generator.coords
expect(group).to_not be_valid_public_key point
end
end
end
shared_examples_for 'group' do
it 'generator point is on the curve' do
expect(group.include?(group.generator)).to eq true
end
it 'has maybe the right order' do
expect(group.generator.multiply_by_scalar(group.order)).to eq group.infinity
end
it '#name matches the string used to look it up' do
expect(group.name).to eq name.downcase
end
end
describe 'specific groups' do
describe ECDSA::Group::Secp256k1 do
subject(:group) { ECDSA::Group::Secp256k1 }
it 'has a bit length of 256' do
expect(group.bit_length).to eq 256
end
it 'has the right generator point' do
expect(group.generator.coords).to eq [
0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798,
0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8,
]
end
end
ECDSA::Group::NAMES.each do |name|
group = ECDSA::Group.const_get(name)
describe group do
subject(:group) { group }
let(:name) { name }
it_behaves_like 'group'
end
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/spec/nist_example_spec.rb 0000644 0000000 0000000 00000012376 13546435715 021605 0 ustar 0000000 0000000 require 'spec_helper'
# Examples came from http://csrc.nist.gov/groups/ST/toolkit/documents/Examples/ECDSA_Prime.pdf
# Key generation procedures came from http://csrc.nist.gov/publications/fips/fips186-3/fips_186-3.pdf
shared_examples_for 'NIST example' do
specify 'private key generation with D' do
point = group.new_point(d)
expect(point).to eq public_key
end
specify 'signature generation' do
signature = ECDSA.sign(group, d, e, k)
expect(signature).to eq signature
end
specify 'signature verification' do
result = ECDSA.check_signature!(public_key, e, signature)
expect(result).to eq true
end
end
describe 'NIST P-192 examples' do
let(:group) { ECDSA::Group::Nistp192 }
let(:d) { 0x78916860_32FD8057_F636B44B_1F47CCE5_64D25099_23A7465B }
let :public_key do
group.new_point [
0xFBA2AAC6_47884B50_4EB8CD5A_0A1287BA_BCC62163_F606A9A2,
0xDAE6D4CC_05EF4F27_D79EE38B_71C9C8EF_4865D988_50D84AA5,
]
end
let :signature do
ECDSA::Signature.new(
0xF0ECBA72_B88CDE39_9CC5A18E_2A8B7DA5_4D81D04F_B9802821,
0x1E6D3D4A_E2B1FAB2_BD2040F5_DABF00F8_54FA140B_6D21E8ED,
)
end
let(:k) { 0xD06CB0A0_EF2F708B_0744F08A_A06B6DEE_DEA9C0F8_0A69D847 }
let(:e) { 0x1B376F0B_735C615C_EEEB31BA_EE654B0A_374825DB }
it_behaves_like 'NIST example'
end
describe 'NIST P-224 examples' do
let(:group) { ECDSA::Group::Nistp224 }
let(:d) { 0x3F0C488E_987C80BE_0FEE521F_8D90BE60_34EC69AE_11CA72AA_777481E8 }
let(:public_key) do
group.new_point [
0xE84FB0B8_E7000CB6_57D7973C_F6B42ED7_8B301674_276DF744_AF130B3E,
0x4376675C_6FC5612C_21A0FF2D_2A89D298_7DF7A2BC_52183B59_82298555,
]
end
let :signature do
ECDSA::Signature.new(
0xC3A3F5B8_27125320_04C6F6D1_DB672F55_D931C340_9EA1216D_0BE77380,
0xC5AA1EAE_6095DEA3_4C9BD84D_A3852CCA_41A8BD9D_5548F36D_ABDF6617,
)
end
let(:k) { 0xA548803B_79DF17C4_0CDE3FF0_E36D0251_43BCBBA1_46EC3290_8EB84937 }
let(:e) { 0x1F1E1CF8_92926CFC_CFC5A28F_EEF3D807_D23F7780_08DBA4B3_5F04B2FD }
it_behaves_like 'NIST example'
end
describe 'NIST P-256 examples' do
let(:group) { ECDSA::Group::Nistp256 }
let(:d) { 0xC477F9F6_5C22CCE2_0657FAA5_B2D1D812_2336F851_A508A1ED_04E479C3_4985BF96 }
let :public_key do
group.new_point [
0xB7E08AFD_FE94BAD3_F1DC8C73_4798BA1C_62B3A0AD_1E9EA2A3_8201CD08_89BC7A19,
0x3603F747_959DBF7A_4BB226E4_19287290_63ADC7AE_43529E61_B563BBC6_06CC5E09,
]
end
let :signature do
ECDSA::Signature.new(
0x2B42F576_D07F4165_FF65D1F3_B1500F81_E44C316F_1F0B3EF5_7325B69A_CA46104F,
0xDC42C212_2D6392CD_3E3A993A_89502A81_98C1886F_E69D262C_4B329BDB_6B63FAF1,
)
end
let(:k) { 0x7A1A7E52_797FC8CA_AA435D2A_4DACE391_58504BF2_04FBE19F_14DBB427_FAEE50AE }
let(:e) { 0xA41A41A1_2A799548_211C410C_65D8133A_FDE34D28_BDD542E4_B680CF28_99C8A8C4 }
it_behaves_like 'NIST example'
end
describe 'NIST P-384 examples' do
let(:group) { ECDSA::Group::Nistp384 }
let :d do
0xF92C02ED_629E4B48_C0584B1C_6CE3A3E3_B4FAAE4A_FC6ACB04_55E73DFC_392E6A0A_E393A856_5E6B9714_D1224B57_D83F8A08
end
let :public_key do
group.new_point [
0x3BF701BC_9E9D36B4_D5F14553_43F09126_F2564390_F2B48736_5071243C_61E6471F_B9D2AB74_657B82F9_086489D9_EF0F5CB5,
0xD1A358EA_FBF952E6_8D533855_CCBDAA6F_F75B137A_51014431_99325583_552A6295_FFE5382D_00CFCDA3_0344A9B5_B68DB855,
]
end
let :signature do
ECDSA::Signature.new(
0x30EA514F_C0D38D82_08756F06_8113C7CA_DA9F66A3_B40EA3B3_13D040D9_B57DD41A_332795D0_2CC7D507_FCEF9FAF_01A27088,
0xCC808E50_4BE414F4_6C9027BC_BF78ADF0_67A43922_D6FCAA66_C4476875_FBB7B94E_FD1F7D5D_BE620BFB_821C46D5_49683AD8,
)
end
let :k do
0x2E44EF1F_8C0BEA83_94E3DDA8_1EC6A784_2A459B53_4701749E_2ED95F05_4F013768_0878E074_9FC43F85_EDCAE06C_C2F43FEF
end
let :e do
0x5AEA187D_1C4F6E1B_35057D20_126D836C_6ADBBC70_49EE0299_C9529F5E_0B3F8B5A_7411149D_6C30D6CB_2B8AF70E_0A781E89
end
it_behaves_like 'NIST example'
end
describe 'NIST P-521 examples' do
let(:group) { ECDSA::Group::Nistp521 }
let(:d) do
0x0100_085F47B8_E1B8B11B_7EB33028_C0B2888E_304BFC98_501955B4_5BBA1478_DC184EEE_DF09B86A_5F7C2199_44060727_87205E69_A63709FE_35AA93BA_333514B2_4F961722
end
let :public_key do
group.new_point [
0x0098_E91EEF9A_68452822_309C52FA_B453F5F1_17C1DA8E_D796B255_E9AB8F64_10CCA16E_59DF403A_6BDC6CA4_67A37056_B1E54B30_05D8AC03_0DECFEB6_8DF18B17_1885D5C4,
0x0164_350C321A_ECFC1CCA_1BA4364C_9B156561_50B4B78D_6A48D7D2_8E7F3198_5EF17BE8_554376B7_2900712C_4B83AD66_83272315_26E313F5_F092999A_4632FD50_D946BC2E,
]
end
let :signature do
ECDSA::Signature.new(
0x0140_C8EDCA57_108CE3F7_E7A240DD_D3AD74D8_1E2DE624_51FC1D55_8FDC7926_9ADACD1C_2526EEEE_F32F8C04_32A9D56E_2B4A8A73_2891C37C_9B96641A_9254CCFE_5DC3E2BA,
0x00D7_2F15229D_0096376D_A6651D99_85BFD7C0_7F8D4958_3B545DB3_EAB20E0A_2C1E8615_BD9E2984_55BDEB6B_61378E77_AF1C54EE_E2CE37B2_C61F5C9A_8232951C_B988B5B1,
)
end
let :k do
0xC91E2349_EF6CA22D_2DE39DD5_1819B6AA_D922D3AE_CDEAB452_BA172F7D_63E370CE_CD70575F_597C09A1_74BA76BE_D05A48E5_62BE0625_336D16B8_703147A6_A231D6BF
end
let :e do
0x9BF0E1DE_EDA31E00_F925B77F_7CB6B1CE_D7368DE1_DC75BB9F_94582C1C_A709205D_32AF9002_5B02FA13_2FBEBD6C_DDCD9172_C0D66D8E_581767A8_B6F71DE6_0BE1F932
end
it_behaves_like 'NIST example'
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/spec/point_spec.rb 0000644 0000000 0000000 00000010262 13546435715 020236 0 ustar 0000000 0000000 require 'spec_helper'
describe ECDSA::Point do
let(:group) do
ECDSA::Group::Secp256k1
end
describe '#multiply_by_scalar' do
it 'does not give infinity when we multiply the generator of secp256k1 by a number less than the order' do
# this test was added to fix a particular bug
k = 2
expect(k).to be < group.order
point = group.generator.multiply_by_scalar(k)
expect(point).to_not be_infinity
end
it 'complains if the argument is not an integer' do
expect { group.generator.multiply_by_scalar(1.1) }.to raise_error ArgumentError, 'Scalar is not an integer.'
end
it 'complains if the argument is negative' do
expect { group.generator.multiply_by_scalar(-3) }.to raise_error ArgumentError, 'Scalar is negative.'
end
it 'is aliased to :*' do
expect(group.generator.method(:*)).to eq group.generator.method(:multiply_by_scalar)
end
end
describe '#coords' do
it 'returns [nil, nil] for infinity' do
expect(group.infinity.coords).to eq [nil, nil]
end
it 'returns x and y' do
expect(group.generator.coords).to eq [
0x79BE667E_F9DCBBAC_55A06295_CE870B07_029BFCDB_2DCE28D9_59F2815B_16F81798,
0x483ADA77_26A3C465_5DA4FBFC_0E1108A8_FD17B448_A6855419_9C47D08F_FB10D4B8]
end
end
describe '#double' do
it 'returns infinity for infinity' do
expect(group.infinity.double).to eq group.infinity
end
it 'can double the generator' do
expect(group.generator.double).to_not be_infinity
end
end
describe '#add_to_point' do
context 'when adding point + infinity' do
it 'returns the point' do
expect(group.generator.add_to_point(group.infinity)).to eq group.generator
end
end
context 'when adding infinity + point' do
it 'returns the point' do
expect(group.infinity.add_to_point(group.generator)).to eq group.generator
end
end
context 'when adding the generator to itself' do
it 'returns the double' do
expect(group.generator.add_to_point(group.generator)).to eq group.generator.double
end
end
it 'is aliased to :+' do
expect(group.generator.method(:+)).to eq group.generator.method(:add_to_point)
end
end
describe '#negate' do
it 'returns infinity for infinity' do
expect(group.infinity.negate).to eq group.infinity
end
it 'returns a point with same x coordinate but negated y coordinate' do
n = group.generator.negate
expect(n.x).to eq group.generator.x
expect(n.y).to eq group.field.mod(-group.generator.y)
end
end
describe '#inspect' do
it 'shows the coordinates if the point has them' do
expect(group.generator.inspect).to eq '#'
end
it 'shows infinity if the point is infinity' do
expect(group.infinity.inspect).to eq '#'
end
end
shared_examples_for 'point comparator' do |method|
let(:p1) { group.new_point [4, 5] }
it 'returns true for points with the same coordinates' do
p2 = group.new_point [4, 5]
expect(method.call(p1, p2)).to eq true
end
it 'returns false for points with different x coordinates' do
p2 = group.new_point [5, 5]
expect(method.call(p1, p2)).to eq false
end
it 'returns false for points with different y coordinates' do
p2 = group.new_point [4, 4]
expect(method.call(p1, p2)).to eq false
end
it 'returns false for non-points' do
expect(method.call(p1, 44)).to eq false
end
it 'returns false for points on another curve' do
p2 = ECDSA::Group::Secp112r2.new_point [4, 5]
expect(method.call(p1, p2)).to eq false
end
end
describe '#eql?' do
it_behaves_like 'point comparator', ->(p, q) { p.eql? q }
end
describe '#==' do
it_behaves_like 'point comparator', ->(p, q) { p == q }
end
describe '#hash' do
# There is a small chance these tests will fail due to a hash collision.
it_behaves_like 'point comparator', ->(p, q) { p.hash == q.hash }
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/spec/prime_field_spec.rb 0000644 0000000 0000000 00000012234 13546435715 021365 0 ustar 0000000 0000000 require 'spec_helper'
describe ECDSA::PrimeField do
let(:prime) { 1367 }
subject(:field) { described_class.new(prime) }
describe '#include?' do
it 'returns true for 0' do
expect(field).to include 0
end
it 'returns true for prime-1' do
expect(field).to include prime - 1
end
it 'returns false for prime' do
expect(field).to_not include prime
end
end
describe '#mod' do
it 'returns the integer modulo the prime' do
n = double('num')
expect(n).to receive(:%).with(prime).and_return(4)
expect(field.mod(n)).to eq 4
end
end
describe '#inverse' do
it 'when given 0 raises an exception' do
expect { field.inverse(0) }.to raise_error ArgumentError, '0 has no multiplicative inverse.'
end
it 'when given 1 returns 1' do
expect(field.inverse(1)).to eq 1
end
def check_inversion(n)
inverse = field.inverse(n)
expect(field).to include inverse
expect(field.mod(inverse * n)).to eq 1
end
it 'when given prime - 1 returns the inverse' do
check_inversion prime - 1
end
it 'when given 44 returns the inverse' do
check_inversion 44
end
context 'for large primes' do
let(:prime) { 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFE_FFFFFC2F }
it 'still works' do
check_inversion 0xd4418917_5bd60c4f_6ead9f5f_301fd4a9_a5ece4c4_7ab45186_11b4c650_77ba7a6b
end
end
end
describe '#square_roots' do
context 'if the prime is equivalent to 3 mod 4' do
it 'can calculate the square root of 0' do
expect(field.square_roots(0)).to eq [0]
end
it 'can calculate the square root of 1' do
expect(field.square_roots(1)).to eq [1, 1366]
end
it 'can calculate the square root of 1311 or 56 mod 1367' do
expect(field.square_roots(402)).to eq [56, 1311]
end
it 'reports that prime-1 has no square roots' do
expect(field.square_roots(1366)).to eq []
end
end
context 'if the prime is equivalent to 5 mod 8' do
let(:field) { ECDSA::Group::Secp224k1.field }
specify { expect(field.prime % 8).to eq 5 }
it 'can calculate the square root of some number (d=1)' do
n = 0xf55074f61370f55558add0478947a9fbc8f11281925f5b907b0cc12c
expect(field.square_roots(n)).to eq [
0xe0d2648bb5d136d71c565a34c4dd9cacf7fb15a0bed82ee371a1cc7,
0xf1f2d9b744a2ec928e3a9a5cb3b2263530804ea5f4127d10c8e5c8a6,
]
end
it 'can calculate the square root of some number (d=-1)' do
n = 0xcd0f7d84a2df8e7d0b97f6d9afbee85e9b1bfd0fa9862dd439285da6
expect(field.square_roots(n)).to eq [
0x402a63ee19abceb3a03f51c1f615bcb9822751b8178a0fd3eb088091,
0xbfd59c11e654314c5fc0ae3e09ea43467dd8ae47e875f02b14f764dc,
]
end
it 'returns nothing for numbers without a square root' do
n = 0xb00a6fc555ab5034b48b756bf2c9f4203702d1187112bba7fe328bed
expect(field.square_roots(n)).to eq []
end
end
context 'if the prime is 1 mod 8' do
let(:field) { ECDSA::Group::Nistp224.field }
specify { expect(field.prime % 8).to eq 1 }
it 'can calculate the square root of some number' do
n = 0x184fbd4fe8e123c572b92d3d36526bf8fd74f182cabddd89e1a7608b
expect(field.square_roots(n)).to eq [
0x7b2bf4e3ca4fd4d306fa7a88c8c13998b1165820a9a3dc9d31220109,
0x84d40b1c35b02b2cf9058577373ec6664ee9a7df565c2362ceddfef8,
]
end
it 'returns nothing for a number without a square root' do
n = 0x95a81e99ed57ac8de0dcc1be14f604b6b7c9a15feb109654390527a8
expect(field.square_roots(n)).to eq []
end
end
context 'if the prime is 2' do
let(:field) { ECDSA::PrimeField.new(2) }
it 'returns 0 for 0' do
expect(field.square_roots(0)).to eq [0]
end
it 'returns 1 for 1' do
expect(field.square_roots(1)).to eq [1]
end
end
end
describe '#power' do
it 'returns 1 when raising to the power 0' do
expect(field.power(5, 0)).to eq 1
end
it 'returns 1 when raising 0 to the power 0' do
expect(field.power(0, 0)).to eq 1
end
end
describe '#square' do
it 'returns 0 for 0' do
expect(field.square(0)).to eq 0
end
it 'returns 1 for 1' do
expect(field.square(1)).to eq 1
end
it 'returns 402 for 1311' do
expect(field.square(1311)).to eq 402
end
end
describe '.jacobi (private)' do
# These test cases come from Example 2.153 from http://cacr.uwaterloo.ca/hac/
test_cases = {
3 => [[2, 5, 8, 11, 17, 20], [1, 4, 10, 13, 16, 19]],
7 => [[5, 10, 13, 19, 20], [1, 2, 4, 8, 11, 16]],
21 => [[2, 8, 10, 11, 13, 19], [1, 4, 5, 16, 17, 20]],
}
test_cases.each do |p, data|
context "with p = #{p}" do
data[0].each do |n|
it "returns -1 for n = #{n}" do
expect(ECDSA::PrimeField.send(:jacobi, n, p)).to eq(-1)
end
end
data[1].each do |n|
it "returns 1 for n = #{n}" do
expect(ECDSA::PrimeField.send(:jacobi, n, p)).to eq 1
end
end
end
end
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/spec/recover_public_key_spec.rb 0000644 0000000 0000000 00000004123 13546435715 022757 0 ustar 0000000 0000000 require 'spec_helper'
describe 'ECDSA.recover_public_key' do
# The data for this spec came from https://en.bitcoin.it/wiki/Protocol_specification#alert
let :group do
ECDSA::Group::Secp256k1
end
let :public_key do
group.new_point [
0xfc9702847840aaf195de8442ebecedf5b095cdbb9bc716bda9110971b28a49e0,
0xead8564ff0db22209e0374782c093bb899692d524e9d6a6956e7c5ecbcd68284,
]
end
let :digest do
"\xbf\x91\xfb\x0b\x4f\x63\x33\x77\x4a\x02\x2b\xd3\x07\x8e\xd6\xcc" \
"\xd1\x76\xee\x31\xed\x4f\xb3\xf9\xaf\xce\xb7\x2a\x37\xe7\x87\x86"
end
let :signature do
ECDSA::Signature.new(
0x8389df45f0703f39ec8c1cc42c13810ffcae14995bb648340219e353b63b53eb,
0x09ec65e1c1aaeec1fd334c6b684bde2b3f573060d5b70c3a46723326e4e8a4f1,
)
end
it 'can recover the public key from the digest and signature' do
points = ECDSA.recover_public_key(group, digest, signature).to_a
expect(points).to include public_key
# Double check the results
points.each do |point|
ECDSA.check_signature!(point, digest, signature)
end
end
it 'returns an Enumerator if not given a block' do
points = ECDSA.recover_public_key(group, digest, signature)
expect(points).to be_a_kind_of Enumerator
end
it 'yields public keys if given a block' do
points = []
result = ECDSA.recover_public_key(group, digest, signature) do |point|
points << point
ECDSA.check_signature!(point, digest, signature)
end
expect(result).to be_nil
expect(points).to include public_key
end
it 'also works for a group with cofactor > 1' do
group = ECDSA::Group::Secp112r2
public_key = group.new_point [
0xaa4ae790df9561195766c97dc1be,
0x0cf3d4295fb062d227e8932f6e4c,
]
signature = ECDSA::Signature.new(
0x041ef05c6308e84bef9bb55255a2,
0x33d38ed36ad0b94a182455bb3dac,
)
points = ECDSA.recover_public_key(group, digest, signature).to_a
expect(points).to include public_key
# Double check the results
points.each do |point|
ECDSA.check_signature!(point, digest, signature)
end
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/spec/sign_spec.rb 0000644 0000000 0000000 00000000766 13546435715 020055 0 ustar 0000000 0000000 require 'spec_helper'
describe 'ECDSA.sign' do
it 'returns nil if r is zero' do
expect(ECDSA.sign(Davidp16d1, 333, 222, 1)).to eq nil
end
it 'returns nil if s is zero' do
group = ECDSA::Group::Secp112r2
private_key = 1
temporary_key = 1
r_point = group.new_point temporary_key
point_field = ECDSA::PrimeField.new(group.order)
r = point_field.mod(r_point.x)
e = -(r * private_key)
expect(ECDSA.sign(group, private_key, e, temporary_key)).to eq nil
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/spec/signature_spec.rb 0000644 0000000 0000000 00000000524 13546435715 021106 0 ustar 0000000 0000000 require 'spec_helper'
describe ECDSA::Signature do
let(:signature) { described_class.new(44, 55) }
it 'has the right r value' do
expect(signature.r).to eq 44
end
it 'has the right s value' do
expect(signature.s).to eq 55
end
it 'has the right components' do
expect(signature.components).to eq [44, 55]
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/spec/spec_helper.rb 0000644 0000000 0000000 00000000355 13546435715 020366 0 ustar 0000000 0000000 if ENV['COVERAGE'] == 'Y'
require 'simplecov'
SimpleCov.start
end
$LOAD_PATH << 'lib'
require 'ecdsa'
Davidp16d1 = ECDSA::Group.new(
name: 'davidp16d1',
p: 0xff8f,
a: -3,
b: 0x2ccd,
g: [0, 0x5455],
n: 0x7efb,
h: 2,
)
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/spec/verify_spec.rb 0000644 0000000 0000000 00000003462 13546435715 020415 0 ustar 0000000 0000000 # encoding: ASCII-8BIT
require 'spec_helper'
describe ECDSA do
describe 'bitcoin alert message' do
# The data for this spec came from https://en.bitcoin.it/wiki/Protocol_specification#alert
let :group do
ECDSA::Group::Secp256k1
end
let :digest do
"\xbf\x91\xfb\x0b\x4f\x63\x33\x77\x4a\x02\x2b\xd3\x07\x8e\xd6\xcc" \
"\xd1\x76\xee\x31\xed\x4f\xb3\xf9\xaf\xce\xb7\x2a\x37\xe7\x87\x86"
end
let :signature_der_string do
"\x30\x45" \
"\x02\x21\x00" \
"\x83\x89\xdf\x45\xf0\x70\x3f\x39\xec\x8c\x1c\xc4\x2c\x13\x81\x0f" \
"\xfc\xae\x14\x99\x5b\xb6\x48\x34\x02\x19\xe3\x53\xb6\x3b\x53\xeb" \
"\x02\x20" \
"\x09\xec\x65\xe1\xc1\xaa\xee\xc1\xfd\x33\x4c\x6b\x68\x4b\xde\x2b" \
"\x3f\x57\x30\x60\xd5\xb7\x0c\x3a\x46\x72\x33\x26\xe4\xe8\xa4\xf1"
end
let :signature do
ECDSA::Format::SignatureDerString.decode(signature_der_string)
end
let :public_key_octet_string do
"\x04" \
"\xfc\x97\x02\x84\x78\x40\xaa\xf1\x95\xde\x84\x42\xeb\xec\xed\xf5" \
"\xb0\x95\xcd\xbb\x9b\xc7\x16\xbd\xa9\x11\x09\x71\xb2\x8a\x49\xe0" \
"\xea\xd8\x56\x4f\xf0\xdb\x22\x20\x9e\x03\x74\x78\x2c\x09\x3b\xb8" \
"\x99\x69\x2d\x52\x4e\x9d\x6a\x69\x56\xe7\xc5\xec\xbc\xd6\x82\x84"
end
let :public_key do
ECDSA::Format::PointOctetString.decode(public_key_octet_string, group)
end
it 'can verify the key is on the curve' do
expect(group).to include public_key
end
it 'can verify the signature' do
result = ECDSA.check_signature!(public_key, digest, signature)
expect(result).to eq true
end
it 'can detect if the message is corrupted' do
digest[2] = "\x44"
result = ECDSA.valid_signature?(public_key, digest, signature)
expect(result).to eq false
end
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/spec/format/field_element_octet_string_spec.rb 0000644 0000000 0000000 00000002004 13546435715 025750 0 ustar 0000000 0000000 # encoding: ASCII-8BIT
require 'spec_helper'
describe ECDSA::Format::FieldElementOctetString do
let(:field) { ECDSA::PrimeField.new(0x1EEF) }
context 'for prime fields' do
describe '#encode' do
it 'defers to IntegerOctetString.encode' do
expect(described_class.encode(0x1234, field)).to eq "\x12\x34"
end
it 'raises an error if you give it something not in the field' do
expect { described_class.encode(0x1EEF, field) }.to raise_error(
ArgumentError, 'Given element is not an element of the field.'
)
end
end
describe '#decode' do
it 'defers to IntegerOctetString.decode' do
expect(described_class.decode("\x07\x89", field)).to eq 0x0789
end
it 'raises an error if the integer in the string is too large' do
expect { described_class.decode("\x1E\xEF", field) }.to raise_error(
ECDSA::Format::DecodeError, 'Decoded integer is too large for field: 0x1eef >= 0x1eef.'
)
end
end
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/spec/format/integer_octet_string_spec.rb 0000644 0000000 0000000 00000001514 13546435715 024616 0 ustar 0000000 0000000 # encoding: ASCII-8BIT
require 'spec_helper'
describe ECDSA::Format::IntegerOctetString do
describe '#encode' do
it 'converts 0x1234 to "\x12\x34"' do
expect(described_class.encode(0x1234, 2)).to eq "\x12\x34"
end
it 'converts 0x0004 to "\x00\x04"' do
expect(described_class.encode(0x0004, 2)).to eq "\x00\x04"
end
it 'complains if the integer is too large' do
expect { described_class.encode(0x10000, 2) }.to raise_error ArgumentError, 'Integer to encode is too large.'
end
it 'complains if the integer is negative' do
expect { described_class.encode(-1, 2) }.to raise_error ArgumentError, 'Integer to encode is negative.'
end
end
describe '#decode' do
it 'converts "\x12\x34" to 0x1234' do
expect(described_class.decode("\x12\x34")).to eq 0x1234
end
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/spec/format/point_octet_string_format_spec.rb 0000644 0000000 0000000 00000010737 13546435715 025671 0 ustar 0000000 0000000 # encoding: ASCII-8BIT
require 'spec_helper'
describe ECDSA::Format::PointOctetString do
let(:group) { ECDSA::Group::Secp112r1 }
describe '#encode' do
let(:converter) { ECDSA::Format::PointOctetString.method(:encode) }
it 'converts infinity to "\x00"' do
expect(converter.call(group.infinity)).to eq "\x00"
end
context 'for a prime field' do
context 'without point compression (default)' do
it 'converts a non-infinity point' do
expect(converter.call(group.generator)).to eq "\x04" \
"\x09\x48\x72\x39\x99\x5A\x5E\xE7\x6B\x55\xF9\xC2\xF0\x98" \
"\xA8\x9C\xE5\xAF\x87\x24\xC0\xA2\x3E\x0E\x0F\xF7\x75\x00"
end
end
context 'with point compression' do
let(:converter) do
->(p) { ECDSA::Format::PointOctetString.encode(p, compression: true) }
end
context 'with an even Y' do
let(:point) { group.generator }
it 'starts with 0x02' do
expect(converter.call(point)).to eq "\x02\x09\x48\x72\x39\x99\x5A\x5E\xE7\x6B\x55\xF9\xC2\xF0\x98"
end
end
context 'with an odd Y' do
let(:point) { group.generator.multiply_by_scalar(3) }
it 'starts with 0x03' do
expect(converter.call(point)).to eq "\x03\xCF\xC1\xE3\x44\x7F\xC3\x3E\x5C\x2A\x7D\x2B\xF7\x12\x98"
end
end
end
end
end
describe '#decode' do
let(:converter) do
->(p) { ECDSA::Format::PointOctetString.decode(p, group) }
end
it 'raises an error for the empty string' do
expect { converter.call('') }.to raise_error ECDSA::Format::DecodeError,
'Point octet string is empty.'
end
it 'decodes "\x00" to infinity' do
expect(converter.call("\x00")).to eq group.infinity
end
it 'raises an error if the start byte is not recognized' do
expect { converter.call("\x12") }.to raise_error ECDSA::Format::DecodeError,
'Unrecognized start byte for point octet string: 0x12'
end
it 'raises an error if the string starts with 0x00 but is more than 1 byte' do
expect { converter.call("\x00\x00") }.to raise_error ECDSA::Format::DecodeError,
'Expected point octet string to be length 1 but it was 2.'
end
[2, 3].each do |start_byte|
it "raises an error if string starts with #{start_byte} but is the wrong length" do
expect { converter.call(start_byte.chr + '...') }.to raise_error ECDSA::Format::DecodeError,
'Expected point octet string to be length 15 but it was 4.'
end
end
it 'raises an error if string starts with 4 but is the wrong length' do
expect { converter.call("\x04...") }.to raise_error ECDSA::Format::DecodeError,
'Expected point octet string to be length 29 but it was 4.'
end
it 'can decode an uncompressed point' do
str = "\x04" \
"\x09\x48\x72\x39\x99\x5A\x5E\xE7\x6B\x55\xF9\xC2\xF0\x98" \
"\xA8\x9C\xE5\xAF\x87\x24\xC0\xA2\x3E\x0E\x0F\xF7\x75\x00"
expect(converter.call(str)).to eq group.generator
end
it 'can decode a compressed point starting with 0x02' do
str = "\x02" \
"\x09\x48\x72\x39\x99\x5A\x5E\xE7\x6B\x55\xF9\xC2\xF0\x98"
expect(converter.call(str)).to eq group.generator
end
it 'can decode a compressed point starting with 0x03' do
str = "\x03" \
"\x09\x48\x72\x39\x99\x5A\x5E\xE7\x6B\x55\xF9\xC2\xF0\x98"
expect(converter.call(str)).to eq group.generator.negate
end
it 'raises an error if the point is not actually on the curve' do
str = "\x04" \
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08" \
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09"
expect { converter.call(str) }.to raise_error ECDSA::Format::DecodeError,
'Decoded point does not satisfy curve equation: #.'
end
it 'raises an error if it cannot solve for Y' do
str = "\x03" \
"\x09\x48\x72\x39\x99\x5A\x5E\xE7\x6B\x55\xF9\xC2\xF0\x99"
expect { converter.call(str) }.to raise_error ECDSA::Format::DecodeError,
'Could not solve for y.'
end
it 'can decode a string with the wrong encoding set' do
str = "\x04" \
"\x09\x48\x72\x39\x99\x5A\x5E\xE7\x6B\x55\xF9\xC2\xF0\x98" \
"\xA8\x9C\xE5\xAF\x87\x24\xC0\xA2\x3E\x0E\x0F\xF7\x75\x00"
str.force_encoding('UTF-8')
expect(converter.call(str)).to eq group.generator
end
end
end
ruby-ecdsa-1.2.0+git20191006.1.ce478ea/spec/format/signature_der_string_spec.rb 0000644 0000000 0000000 00000002042 13546435715 024613 0 ustar 0000000 0000000 # encoding: ASCII-8BIT
require 'spec_helper'
describe ECDSA::Format::SignatureDerString do
let(:signature_der) do
"\x30\x45" \
"\x02\x21\x00" \
"\x83\x89\xdf\x45\xf0\x70\x3f\x39\xec\x8c\x1c\xc4\x2c\x13\x81\x0f" \
"\xfc\xae\x14\x99\x5b\xb6\x48\x34\x02\x19\xe3\x53\xb6\x3b\x53\xeb" \
"\x02\x20" \
"\x09\xec\x65\xe1\xc1\xaa\xee\xc1\xfd\x33\x4c\x6b\x68\x4b\xde\x2b" \
"\x3f\x57\x30\x60\xd5\xb7\x0c\x3a\x46\x72\x33\x26\xe4\xe8\xa4\xf1"
end
let(:r) { 0x8389df45f0703f39ec8c1cc42c13810ffcae14995bb648340219e353b63b53eb }
let(:s) { 0x9ec65e1c1aaeec1fd334c6b684bde2b3f573060d5b70c3a46723326e4e8a4f1 }
describe '#decode' do
let(:signature) { described_class.decode(signature_der) }
it 'retrieves the right r value' do
expect(signature.r).to eq r
end
it 'retrieves the right s value' do
expect(signature.s).to eq s
end
end
describe '#encode' do
it 'can encode' do
str = described_class.encode(ECDSA::Signature.new(r, s))
expect(str).to eq signature_der
end
end
end