ring_sig 0.2.0 → 0.3.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    YWJjNzNiMmVjMTJjMDY1YzU2M2QyY2MxM2ExZDkwYTQxNzUwMmE5MA==
-  data.tar.gz: !binary |-
-    MDhiZDVlZTVmYzc2YWZkYTIxY2U1NjgyOWNlMzY2YWIyM2E0MDAxMQ==
+SHA1:
+  metadata.gz: a9a8ff4b8548f802c19f9529c15034fc4c1329ab
+  data.tar.gz: 56e3a1befb6c39b8c8205e49f167598fd3fc0bfa
 SHA512:
-  metadata.gz: !binary |-
-    YzdiMzZkNzBlNTY2M2U3NzY1NmE5NTViZTJkYWY5ZjFjMzg5MjIyYzNiM2E3
-    MjBhN2EyNmVmOTdiMTQwYzdmODliOGIyNzJkMzdiYzIzMmVkMGZiNThiZTQ2
-    MmFhZDcwZWZjMDY2ZDcyZDgxOWI4ZjY1ZDUzM2IzNTA4NWI2YzU=
-  data.tar.gz: !binary |-
-    ZWMxNjk0YzE3NzM0YmQzYjcwMDdjM2NiODBhYWFlNTA1MmQ5MmQxNWY4MDQ1
-    Njk4M2E1ZGM4OTA3MmQ5ZTMwZThiYmY4ZTRhZTA4ZmE2MmNlZTZiMTYzMGY4
-    ZWU1MTQ2ZmZlNDk2ZTUzMjUyMmRjMTFhOWY2OGU4ZGU1NjFlMmE=
+  metadata.gz: d07e37c8ea67cceb18a6eca210cb03ce3c29381a3fe627ed24994a83e3b1093107521cc2b9588f76d26c4469aad9cd9eb266f80e34edfadb80b999d986fb1434
+  data.tar.gz: 594217e061216f7e336827112e9ed01bb35772ba6b6547173eb673d3d79dd385bdd920a6c38231b21134a2e4333a8375440130d6e28b044aa95a3f4d32867305

data/.travis.yml

@@ -2,6 +2,6 @@ script: "rspec"
 rvm:
   - 1.9.3
   - 2.0.0
-  - 2.1.0
+  - 2.1.2
   - jruby-19mode
   - rbx

data/CHANGELOG.md

@@ -5,6 +5,24 @@ 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.
 
+0.3.0
+----
+Released on 2014-09-15
+
+This release breaks API compatibility with version 0.2.0.
+
+- Change `PrivateKey`, `PublicKey`, and `Signature` constructors such that they
+  accept a required `Hasher` argument rather than an optional `ECDSA::Group` and
+  `hash_algorithm`. The `Hasher` encapsulates these properties.
+- Change `Hasher` constructor so that `group` and `hash_algorithm` attributes
+  are passed in as explicit arguments rather than options.
+- Remove `RingSig.default_group` and `RingSig.defaut_hash_algorithm` attributes.
+  There are now no default algorithms.
+- Update gem dependency for `ecdsa` gem to 1.2.
+
+This will hopefully be the last major API change for a while, but it still may
+change until 1.0 is released.
+
 0.2.0
 ----
 Released on 2014-09-12

data/README.md

@@ -46,61 +46,94 @@ at RubyGems.org.  To install it, run:
 
 ## Usage
 
+### Initialization
+
 First, require the gem:
+
 ```ruby
 require 'ring_sig'
 ```
 
-Next, create a private key for signing. For our example, we'll just use the
+Instantiate a hasher. This specifies the `ECDSA::Group`, and the hash algorithm
+that will be used for signing.
+
+```ruby
+hasher = RingSig::Hasher::Secp256k1_Sha256
+```
+
+Create a private key for signing. For our example, we'll just use the
 private key `1`. In the wild, you'll want to utilize a securely generated key.
+
 ```ruby
-key = RingSig::PrivateKey.new(1)
+key = RingSig::PrivateKey.new(1, hasher)
 ```
 
-Next, access a set a foreign public keys for signing. To demonstrate that any
+Instantiate a set a foreign public keys for signing. To demonstrate that any
 arbitrary keys can be used, we'll use the public keys from the coinbase
-transactions of the first three blocks on the bitcoin blockchain.
+transactions of the first three blocks on the bitcoin blockchain (we can do this
+since our hasher uses Secp256k1 as its `ECDSA::Group`).
 
 ```ruby
 foreign_keys = %w{
     04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f
     0496b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52da7589379515d4e0a604f8141781e62294721166bf621e73a82cbf2342c858ee
     047211a824f55b505228e4c3d5194c1fcfaa15a456abdf37f9b9d97a4040afc073dee6c89064984f03385237d92167c13e236446b417ab79a0fcae412ae3316b77
-  }.map {|s| RingSig::PublicKey.from_hex(s) }
+  }.map {|s| RingSig::PublicKey.from_hex(s, hasher) }
 ```
 
+### Signing
+
 Next, we sign the message. This will assign a `RingSig::Signature` to the `sig`
 variable, and a deterministically shuffled Array of `RingSig::PublicKey`s to the
 `public_keys` variable.
+
 ```ruby
 sig, public_keys = key.sign("Hello World!", foreign_keys)
 ```
 
-You can see the signature contents by using the `to_hex` method:
+You can encode the contents of the signature using the `to_hex` method:
+
+```ruby
+sig_hex = sig.to_hex
+```
+
+### Verifying
+In order to verify the signature, the verifier will need the signature, and the
+ordered set of public keys.
+
+In order to instantiate a signature object from a hex string, you can use the
+`from_hex` method:
+
 ```ruby
-puts sig.to_hex
+sig2 = RingSig::Signature.from_hex(sig_hex, hasher)
 ```
 
 Finally, verify the signature:
+
 ```ruby
-sig.verify("Hello World!", public_keys)
+sig2.verify("Hello World!", public_keys)
 ```
 
-By default, this gem uses SHA256 for its hash algorithm, and Secp256k1 for its
-ECDSA group. You can specify alternates if you'd like:
+### Algorithms
+
+The above example signature used Secp256k1 for the ECDSA group, and SHA256 for
+the hash algorithm. You can specify alternates if you'd like, by using a
+different hasher:
+
 ```ruby
-key = RingSig::PrivateKey.new(1, group: ECDSA::Group::Secp256r1, hash_algorithm: OpenSSL::Digest::RIPEMD160)
+key = RingSig::PrivateKey.new(1, RingSig::Hasher::Secp384r1_Sha384)
 ```
 
-You can also specify module-wide alternate defaults:
+You can also instantiate your own hasher directly, rather than using the
+pre-defined constants:
+
 ```ruby
-RingSig.default_group = ECDSA::Group::Secp256r1
-RingSig.default_hash_algorithm = OpenSSL::Digest::RIPEMD160
-key = RingSig::PrivateKey.new(1)
-puts key.group # ECDSA::Group::Secp256r1
-puts key.hash_algorithm # OpenSSL::Digest::RIPEMD160
+hasher = RingSig::Hasher.new(ECDSA::Group::Secp384r1, OpenSSL::Digest::SHA384)
 ```
 
+Note that the byte-length of the group's order and the digest method must match,
+or else the signatures generated will leak the position of the true signer.
+
 ## Standards
 
 There currently aren't any standards around Ring Signatures that I know of. This
@@ -136,7 +169,7 @@ for this gem.
 
 ## Supported platforms
 
-Ruby 2.0.0 and above.
+Ruby 1.9.3 and above, including jruby-19mode.
 
 ## Documentation
 

data/lib/ring_sig/hasher.rb

@@ -5,17 +5,19 @@ module RingSig
     attr_reader :group
 
     # @return [#digest]
-    attr_reader :hash_algorithm
+    attr_reader :algorithm
 
     # Creates a new instance of {Hasher}.
     #
-    # @param opts [Hash]
-    # @option opts :group [ECDSA::Group]
-    # @option opts :hash_algorithm [#digest]
-    def initialize(opts = {})
-      @group = opts.delete(:group) { RingSig.default_group }
-      @hash_algorithm = opts.delete(:hash_algorithm) { RingSig.default_hash_algorithm }
-      raise ArgumentError, "Unknown options #{opts.keys.join(', ')}" unless opts.empty?
+    # @note The byte-length of the group's order and the digest method must
+    #   match, or else signatures generated from this hasher will leak the
+    #   position of the true signer.
+    #
+    # @param group [ECDSA::Group]
+    # @param algorithm [#digest]
+    def initialize(group, algorithm)
+      @group = group
+      @algorithm = algorithm
     end
 
     # Continuously hashes until a value less than the group's order is found.
@@ -25,7 +27,7 @@ module RingSig
     def hash_string(s)
       n = nil
       loop do
-        s = @hash_algorithm.digest(s)
+        s = algorithm.digest(s)
         n = s.unpack('H*').first.to_i(16)
         break if n < @group.order
       end
@@ -76,6 +78,11 @@ module RingSig
       array
     end
 
+    # @return [Boolean] true if the hashers are equal.
+    def ==(other)
+      group == other.group && algorithm == other.algorithm
+    end
+
     private
 
     # Deterministically returns a random number between 0 and n.
@@ -91,5 +98,11 @@ module RingSig
         return r % n if r < @group.order - @group.order % n
       end
     end
+
+    Secp256k1_Sha256 = new(ECDSA::Group::Secp256k1, OpenSSL::Digest::SHA256)
+    Secp256r1_Sha256 = new(ECDSA::Group::Secp256r1, OpenSSL::Digest::SHA256)
+    Secp384r1_Sha384 = new(ECDSA::Group::Secp384r1, OpenSSL::Digest::SHA384)
+    Secp160k1_Ripemd160 = new(ECDSA::Group::Secp160k1, OpenSSL::Digest::RIPEMD160)
+    Secp160r1_Ripemd160 = new(ECDSA::Group::Secp160r1, OpenSSL::Digest::RIPEMD160)
   end
 end

data/lib/ring_sig/private_key.rb

@@ -11,65 +11,44 @@ module RingSig
     # @return [PublicKey]
     attr_reader :public_key
 
-    # @return [ECDSA::Group]
-    attr_reader :group
-
-    # @return [#digest]
-    attr_reader :hash_algorithm
+    # @return [Hasher]
+    attr_reader :hasher
 
     # Creates a new instance of {PrivateKey}.
     #
     # @param value [Integer]
-    # @param opts [Hash]
-    # @option opts :group [ECDSA::Group]
-    # @option opts :hash_algorithm [#digest]
-    def initialize(value, opts = {})
-      @group = opts.delete(:group) { RingSig.default_group }
-      @hash_algorithm = opts.delete(:hash_algorithm) { RingSig.default_hash_algorithm }
-      raise ArgumentError, "Unknown opts: #{opts.keys.join(', ')}" unless opts.empty?
-
+    # @param hasher [Hasher]
+    def initialize(value, hasher)
       raise ArgumentError, "Value is not an integer" unless value.is_a?(Integer)
       raise ArgumentError, "Value is too small" if value < 1
-      raise ArgumentError, "Value is too large" if value >= group.order
+      raise ArgumentError, "Value is too large" if value >= hasher.group.order
 
       @value = value
-      @public_key = PublicKey.new(group.generator.multiply_by_scalar(value), group: group)
-      @hasher = Hasher.new(group: group, hash_algorithm: hash_algorithm)
+      @hasher = hasher
+      @public_key = PublicKey.new(hasher.group.generator * value, hasher)
     end
 
     # Creates a new instance of {PrivateKey} from a hex string.
     #
     # @param hex_string [String]
-    # @param opts [Hash]
-    # @option opts :group [ECDSA::Group]
-    # @option opts :hash_algorithm [#digest]
+    # @param hasher [Hasher]
     # @return [PrivateKey]
-    def self.from_hex(hex_string, opts = {})
-      group = opts.delete(:group) { RingSig.default_group }
-      hash_algorithm = opts.delete(:hash_algorithm) { RingSig.default_hash_algorithm }
-      raise ArgumentError, "Unknown opts: #{opts.keys.join(', ')}" unless opts.empty?
-
-      self.from_octet([hex_string].pack('H*'), group: group, hash_algorithm: hash_algorithm)
+    def self.from_hex(hex_string, hasher)
+      self.from_octet([hex_string].pack('H*'), hasher)
     end
 
     # Creates a new instance of {PrivateKey} from an octet string.
     #
     # @param octet_string [String]
-    # @param opts [Hash]
-    # @option opts :group [ECDSA::Group]
-    # @option opts :hash_algorithm [#digest]
+    # @param hasher [Hasher]
     # @return [PrivateKey]
-    def self.from_octet(octet_string, opts = {})
-      group = opts.delete(:group) { RingSig.default_group }
-      hash_algorithm = opts.delete(:hash_algorithm) { RingSig.default_hash_algorithm }
-      raise ArgumentError, "Unknown opts: #{opts.keys.join(', ')}" unless opts.empty?
-
-      value = ECDSA::Format::FieldElementOctetString.decode(octet_string, group.field)
-      PrivateKey.new(value, group: group, hash_algorithm: hash_algorithm)
+    def self.from_octet(octet_string, hasher)
+      value = ECDSA::Format::FieldElementOctetString.decode(octet_string, hasher.group.field)
+      PrivateKey.new(value, hasher)
     end
 
     # Encodes this private key into an octet string. The encoded data contains
-    # only the value. It does not contain the group or hash_algorithm.
+    # only the value. It does not contain the hasher.
     #
     # @return [String]
     def to_hex
@@ -77,11 +56,11 @@ module RingSig
     end
 
     # Encodes this public key into a hex string. The encoded data contains
-    # only the value. It does not contain the group or hash_algorithm.
+    # only the value. It does not contain the hasher.
     #
     # @return [String]
     def to_octet
-      ECDSA::Format::FieldElementOctetString.encode(value, group.field)
+      ECDSA::Format::FieldElementOctetString.encode(value, hasher.group.field)
     end
 
     # Signs a message with this key's private key and a set of foreign public
@@ -95,27 +74,27 @@ module RingSig
     # @return [Array(Signature, Array<PublicKey>)] A pair containing the signature
     #   and the set of public keys (in the correct order) for verifying.
     def sign(message, foreign_keys)
-      raise ArgumentError "Foreign keys must all have the same group" unless foreign_keys.all?{ |e| e.group == group }
+      raise ArgumentError "Foreign keys must all have the same hasher" unless foreign_keys.all?{ |e| e.hasher == hasher }
 
-      message_digest = @hasher.hash_string(message)
-      seed = @hasher.hash_array([value, message_digest])
+      message_digest = hasher.hash_string(message)
+      seed = hasher.hash_array([value, message_digest])
 
-      all_keys = @hasher.shuffle([self] + foreign_keys, seed)
+      all_keys = hasher.shuffle([self] + foreign_keys, seed)
 
       q_array, w_array = generate_q_w(all_keys, seed)
       ll_array, rr_array = generate_ll_rr(all_keys, q_array, w_array)
-      challenge = @hasher.hash_array([message_digest] + ll_array + rr_array)
+      challenge = hasher.hash_array([message_digest] + ll_array + rr_array)
       c_array, r_array = generate_c_r(all_keys, q_array, w_array, challenge)
 
       public_keys = all_keys.map(&:public_key)
-      signature = Signature.new(key_image, c_array, r_array, group: group, hash_algorithm: hash_algorithm)
+      signature = Signature.new(key_image, c_array, r_array, hasher)
 
       [signature, public_keys]
     end
 
     # @return [ECDSA::Point] the key image.
     def key_image
-      @key_image ||= @hasher.hash_point(point) * value
+      @key_image ||= hasher.hash_point(point) * value
     end
 
     # @return [ECDSA::Point] the public key's point.
@@ -126,7 +105,7 @@ module RingSig
     # @return [Boolean] true if the private keys are equal.
     def ==(other)
       return false unless other.is_a?(PrivateKey)
-      value == other.value && group == other.group && hash_algorithm == other.hash_algorithm
+      value == other.value && hasher == other.hasher
     end
 
     private
@@ -135,9 +114,9 @@ module RingSig
       q_array, w_array = [], []
 
       all_keys.each_with_index do |k, i|
-        q_array[i] = @hasher.hash_array(['q', seed, i])
+        q_array[i] = hasher.hash_array(['q', seed, i])
         w_array[i] = 0
-        w_array[i] = @hasher.hash_array(['w', seed, i]) if k.is_a?(PublicKey)
+        w_array[i] = hasher.hash_array(['w', seed, i]) if k.is_a?(PublicKey)
       end
 
       [q_array, w_array]
@@ -147,8 +126,8 @@ module RingSig
       ll_array, rr_array = [], []
 
       all_keys.each_with_index do |k, i|
-        ll_array[i] = group.generator * q_array[i]
-        rr_array[i] = @hasher.hash_point(k.point) * q_array[i]
+        ll_array[i] = hasher.group.generator * q_array[i]
+        rr_array[i] = hasher.hash_point(k.point) * q_array[i]
         if k.is_a?(PublicKey)
           ll_array[i] += k.point * w_array[i]
           rr_array[i] += key_image * w_array[i]
@@ -166,8 +145,8 @@ module RingSig
           c_array[i] = w_array[i]
           r_array[i] = q_array[i]
         else
-          c_array[i] = (challenge - w_array.inject{|a, b| a + b}) % group.order
-          r_array[i] = (q_array[i] - c_array[i] * k.value) % group.order
+          c_array[i] = (challenge - w_array.inject{|a, b| a + b}) % hasher.group.order
+          r_array[i] = (q_array[i] - c_array[i] * k.value) % hasher.group.order
         end
       end
 

data/lib/ring_sig/public_key.rb

@@ -7,56 +7,45 @@ module RingSig
     # @return [ECDSA::Point]
     attr_reader :point
 
-    # @return [ECDSA::Group]
-    attr_reader :group
+    # @return [Hasher]
+    attr_reader :hasher
 
     # Creates a new instance of {PublicKey}.
     #
     # @param point [ECDSA::Point]
-    # @param opts [Hash]
-    # @option opts :group [ECDSA::Group]
-    def initialize(point, opts = {})
-      @group = opts.delete(:group) { RingSig.default_group }
-      raise ArgumentError, "Unknown opts: #{opts.keys.join(', ')}" unless opts.empty?
-
+    # @param hasher [Hasher]
+    def initialize(point, hasher)
       raise ArgumentError, "Point is not an ECDSA::Point" unless point.is_a?(ECDSA::Point)
-      raise ArgumentError, "Point is not on the group's curve" unless group.include?(point)
+      raise ArgumentError, "Point is not on the group's curve" unless hasher.group.include?(point)
 
       @point = point
+      @hasher = hasher
     end
 
     # Creates a new instance of {PublicKey} from a hex string.
     #
     # @param hex_string [String]
-    # @param opts [Hash]
-    # @option opts :group [ECDSA::Group]
+    # @param hasher [Hasher]
     # @return [PublicKey]
-    def self.from_hex(hex_string, opts = {})
-      group = opts.delete(:group) { RingSig.default_group }
-      raise ArgumentError, "Unknown opts: #{opts.keys.join(', ')}" unless opts.empty?
-
-      self.from_octet([hex_string].pack('H*'), group: group)
+    def self.from_hex(hex_string, hasher)
+      self.from_octet([hex_string].pack('H*'), hasher)
     end
 
     # Creates a new instance of {PublicKey} from an octet string.
     #
     # @param octet_string [String]
-    # @param opts [Hash]
-    # @option opts :group [ECDSA::Group]
+    # @param hasher [Hasher]
     # @return [PublicKey]
-    def self.from_octet(octet_string, opts = {})
-      group = opts.delete(:group) { RingSig.default_group }
-      raise ArgumentError, "Unknown opts: #{opts.keys.join(', ')}" unless opts.empty?
-
-      point = ECDSA::Format::PointOctetString.decode(octet_string, group)
-      PublicKey.new(point, group: group)
+    def self.from_octet(octet_string, hasher)
+      point = ECDSA::Format::PointOctetString.decode(octet_string, hasher.group)
+      PublicKey.new(point, hasher)
     end
 
     # Encodes this public key into an octet string. The encoded data contains
-    # only the point. It does not contain the group.
+    # only the point. It does not contain the hasher.
     #
     # @param opts [Hash]
-    # @option opts :compression [Boolean]
+    # @option opts [Boolean] :compression (true)
     # @return [String]
     def to_hex(opts = {})
       compression = opts.delete(:compression) { true }
@@ -66,10 +55,10 @@ module RingSig
     end
 
     # Encodes this public key into a hex string. The encoded data contains
-    # only the point. It does not contain the group.
+    # only the point. It does not contain the hasher.
     #
     # @param opts [Hash]
-    # @option opts :compression [Boolean]
+    # @option opts [Boolean] :compression (true)
     # @return [String]
     def to_octet(opts = {})
       compression = opts.delete(:compression) { true }
@@ -86,7 +75,7 @@ module RingSig
     # @return [Boolean] true if the public keys are equal.
     def ==(other)
       return false unless other.is_a?(PublicKey)
-      point == other.point && group == other.group
+      point == other.point && hasher == other.hasher
     end
   end
 end

data/lib/ring_sig/signature.rb

@@ -10,75 +10,53 @@ module RingSig
     # @return [Array]
     attr_reader :r_array
 
-    # @return [ECDSA::Group]
-    attr_reader :group
-
-    # @return [#digest]
-    attr_reader :hash_algorithm
+    # @return [Hasher]
+    attr_reader :hasher
 
     # Creates a new instance of {Signature}.
     #
     # @param key_image [ECDSA::Point]
     # @param c_array [Array<Integer>]
     # @param r_array [Array<Integer>]
-    # @param opts [Hash]
-    # @option opts :group [ECDSA::Group]
-    # @option opts :hash_algorithm [#digest]
-    def initialize(key_image, c_array, r_array, opts = {})
-      @group = opts.delete(:group) { RingSig.default_group }
-      @hash_algorithm = opts.delete(:hash_algorithm) { RingSig.default_hash_algorithm }
-      raise ArgumentError, "Unknown opts: #{opts.keys.join(', ')}" unless opts.empty?
-
+    # @param hasher [Hasher]
+    def initialize(key_image, c_array, r_array, hasher)
       @key_image, @c_array, @r_array = key_image, c_array, r_array
       key_image.is_a?(ECDSA::Point) or raise ArgumentError, 'key_image is not an ECDSA::Point.'
       c_array.is_a?(Array) or raise ArgumentError, 'c_array is not an array.'
       r_array.is_a?(Array) or raise ArgumentError, 'r_array is not an array.'
 
-      @hasher = Hasher.new(group: group, hash_algorithm: hash_algorithm)
+      @hasher = hasher
     end
 
     # Creates a new instance of {Signature} from a der string.
     #
     # @param der_string [String]
-    # @param opts [Hash]
-    # @option opts :group [ECDSA::Group]
-    # @option opts :hash_algorithm [#digest]
+    # @param hasher [Hasher]
     # @return [Signature]
-    def self.from_der(der_string, opts = {})
-      group = opts.delete(:group) { RingSig.default_group }
-      hash_algorithm = opts.delete(:hash_algorithm) { RingSig.default_hash_algorithm }
-      raise ArgumentError, "Unknown opts: #{opts.keys.join(', ')}" unless opts.empty?
-
+    def self.from_der(der_string, hasher)
       asn1 = OpenSSL::ASN1.decode(der_string)
 
-      key_image = ECDSA::Format::PointOctetString.decode(asn1.value[0].value, group)
+      key_image = ECDSA::Format::PointOctetString.decode(asn1.value[0].value, hasher.group)
       c_array = asn1.value[1].value.map{|i| i.value.to_i}
       r_array = asn1.value[2].value.map{|i| i.value.to_i}
 
-      Signature.new(key_image, c_array, r_array, group: group, hash_algorithm: hash_algorithm)
+      Signature.new(key_image, c_array, r_array, hasher)
     end
 
     # Creates a new instance of {Signature} from a hex string.
     #
     # @param hex_string [String]
-    # @param opts [Hash]
-    # @option opts :group [ECDSA::Group]
-    # @option opts :hash_algorithm [#digest]
+    # @param hasher [Hasher]
     # @return [Signature]
-    def self.from_hex(hex_string, opts = {})
-      group = opts.delete(:group) { RingSig.default_group }
-      hash_algorithm = opts.delete(:hash_algorithm) { RingSig.default_hash_algorithm }
-      raise ArgumentError, "Unknown opts: #{opts.keys.join(', ')}" unless opts.empty?
-
-      Signature.from_der([hex_string].pack('H*'), group: group, hash_algorithm: hash_algorithm)
+    def self.from_hex(hex_string, hasher)
+      Signature.from_der([hex_string].pack('H*'), hasher)
     end
 
     # Encodes this signature into a der string. The encoded data contains
-    # the key_image, c_array, and r_array. It does not contain the group
-    # or hash_algorithm.
+    # the key_image, c_array, and r_array. It does not contain the hasher.
     #
     # @param opts [Hash]
-    # @option opts :compression [Boolean]
+    # @option opts [Boolean] :compression (true)
     # @return [String]
     def to_der(opts = {})
       compression = opts.delete(:compression) { true }
@@ -92,11 +70,10 @@ module RingSig
     end
 
     # Encodes this signature into a hex string. The encoded data contains
-    # the key_image, c_array, and r_array. It does not contain the group
-    # or hash_algorithm.
+    # the key_image, c_array, and r_array. It does not contain the hasher.
     #
     # @param opts [Hash]
-    # @option opts :compression [Boolean]
+    # @option opts [Boolean] :compression (true)
     # @return [String]
     def to_hex(opts = {})
       compression = opts.delete(:compression) { true }
@@ -115,14 +92,14 @@ module RingSig
       rr_array = []
 
       public_keys.each_with_index do |k, i|
-        ll_array[i] = (group.generator * r_array[i]) + (k.point * c_array[i])
-        rr_array[i] = (@hasher.hash_point(k.point) * (r_array[i]) + key_image * c_array[i])
+        ll_array[i] = (hasher.group.generator * r_array[i]) + (k.point * c_array[i])
+        rr_array[i] = (hasher.hash_point(k.point) * (r_array[i]) + key_image * c_array[i])
       end
 
-      c_sum = c_array.inject{|a, b| a + b} % group.order
+      c_sum = c_array.inject{|a, b| a + b} % hasher.group.order
 
-      message_digest = @hasher.hash_string(message)
-      challenge = @hasher.hash_array([message_digest] + ll_array + rr_array)
+      message_digest = hasher.hash_string(message)
+      challenge = hasher.hash_array([message_digest] + ll_array + rr_array)
 
       c_sum == challenge
     end

data/lib/ring_sig/version.rb

@@ -1,4 +1,4 @@
 module RingSig
   # This gem's version.
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/lib/ring_sig.rb

@@ -5,22 +5,7 @@ require 'ring_sig/private_key'
 require 'ring_sig/public_key'
 require 'ring_sig/signature'
 require 'ring_sig/version'
-require 'ring_sig/ecdsa/point'
 
 # The top-level module for the RingSig gem.
 module RingSig
-  class << self
-    # @return [ECDSA::Group] the default group. This group will be used in any
-    #   method in the RingSig library that calls for a group, if none is
-    #   specified. Starts as `ECDSA::Group::Secp256k1`.
-    attr_accessor :default_group
-
-    # @return [#digest] the default hash algorithm. This hash algorithm will be
-    #   used in any method in the RingSig library that calls for a hash
-    #   algorithm, if none is specified. Starts as `OpenSSL::Digest::SHA256`.
-    attr_accessor :default_hash_algorithm
-  end
-
-  self.default_group = ECDSA::Group::Secp256k1
-  self.default_hash_algorithm = OpenSSL::Digest::SHA256
 end

data/ring_sig.gemspec

@@ -22,5 +22,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'markdown', '~> 1'
   s.add_development_dependency 'redcarpet', '~> 3' unless RUBY_PLATFORM == 'java'
 
-  s.add_runtime_dependency 'ecdsa', '~> 1.1'
+  s.add_runtime_dependency 'ecdsa', '~> 1.2'
 end

data/spec/hasher_spec.rb

@@ -4,7 +4,7 @@ describe RingSig::Hasher do
   context 'Standard: SHA256 hash algorithm, secp256k1 group' do
     group = ECDSA::Group::Secp256k1
     hash_algorithm = OpenSSL::Digest::SHA256
-    hasher = RingSig::Hasher.new(group: group, hash_algorithm: hash_algorithm)
+    hasher = RingSig::Hasher.new(group, hash_algorithm)
 
     describe '#hash_string' do
       it 'hashes "a"' do
@@ -67,7 +67,7 @@ describe RingSig::Hasher do
       SimpleHashAlgorithm
     end
 
-    let(:hasher) { RingSig::Hasher.new(group: group, hash_algorithm: hash_algorithm) }
+    let(:hasher) { RingSig::Hasher.new(group, hash_algorithm) }
 
     # We test the hash_algorithm itself in this context, since we implemented our own simple hash_algorithm.
     shared_examples_for 'hash algorithm' do |input, expected_value|

data/spec/private_key_spec.rb

@@ -1,7 +1,8 @@
 require 'spec_helper'
 
 describe RingSig::PrivateKey do
-  key = RingSig::PrivateKey.new(1)
+  hasher = RingSig::Hasher::Secp256k1_Sha256
+  key = RingSig::PrivateKey.new(1, hasher)
   key_hex = '0000000000000000000000000000000000000000000000000000000000000001'
   group = ECDSA::Group::Secp256k1
   message = 'a'
@@ -10,14 +11,14 @@ describe RingSig::PrivateKey do
       04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f
       0496b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52da7589379515d4e0a604f8141781e62294721166bf621e73a82cbf2342c858ee
       047211a824f55b505228e4c3d5194c1fcfaa15a456abdf37f9b9d97a4040afc073dee6c89064984f03385237d92167c13e236446b417ab79a0fcae412ae3316b77
-    }.map {|s| RingSig::PublicKey.from_hex(s) }
+    }.map {|s| RingSig::PublicKey.from_hex(s, hasher) }
 
   it 'raises ArgumentError if value is too small' do
-    expect { RingSig::PrivateKey.new(0) }.to raise_error(ArgumentError)
+    expect { RingSig::PrivateKey.new(0, hasher) }.to raise_error(ArgumentError)
   end
 
   it 'raises ArgumentError if value is too large' do
-    expect { RingSig::PrivateKey.new(group.order) }.to raise_error(ArgumentError)
+    expect { RingSig::PrivateKey.new(group.order, hasher) }.to raise_error(ArgumentError)
   end
 
   describe '#key_image' do
@@ -47,7 +48,7 @@ describe RingSig::PrivateKey do
 
   describe '#from_hex' do
     it 'converts from hex' do
-      expect(RingSig::PrivateKey.from_hex(key_hex)).to eq key
+      expect(RingSig::PrivateKey.from_hex(key_hex, hasher)).to eq key
     end
   end
 
@@ -59,18 +60,18 @@ describe RingSig::PrivateKey do
 
   describe '#from_octet' do
     it 'converts from octet' do
-      expect(RingSig::PrivateKey.from_octet([key_hex].pack('H*'))).to eq key
+      expect(RingSig::PrivateKey.from_octet([key_hex].pack('H*'), hasher)).to eq key
     end
   end
 
   describe '==' do
     it 'returns true when keys are the same' do
       expect(key).to eq key
-      expect(RingSig::PrivateKey.new(key.value) == key).to eq true
+      expect(RingSig::PrivateKey.new(key.value, hasher) == key).to eq true
     end
 
     it 'returns false when keys are different' do
-      expect(RingSig::PrivateKey.new(2) == key).to eq false
+      expect(RingSig::PrivateKey.new(2, hasher) == key).to eq false
     end
   end
 
@@ -105,33 +106,22 @@ describe RingSig::PrivateKey do
     end
   end
 
-  context 'alternate defaults' do
+  context 'alternate hasher' do
     before(:all) do
-      @old_default_group = RingSig.default_group
-      @old_default_hash_algorithm = RingSig.default_hash_algorithm
-      RingSig.default_group = ECDSA::Group::Secp256r1
-      RingSig.default_hash_algorithm = OpenSSL::Digest::RIPEMD160
-
-      @key = RingSig::PrivateKey.new(1)
+      @key = RingSig::PrivateKey.new(1, RingSig::Hasher::Secp160k1_Ripemd160)
       @foreign_keys = [
-          RingSig::PrivateKey.new(2).public_key,
-          RingSig::PrivateKey.new(3).public_key,
-          RingSig::PrivateKey.new(4).public_key,
+          RingSig::PrivateKey.new(2, RingSig::Hasher::Secp160k1_Ripemd160).public_key,
+          RingSig::PrivateKey.new(3, RingSig::Hasher::Secp160k1_Ripemd160).public_key,
         ]
     end
 
-    after(:all) do
-      RingSig.default_group = @old_default_group
-      RingSig.default_hash_algorithm = @old_default_hash_algorithm
-    end
-
     describe '#sign' do
       it 'signs and verifies' do
         sig, public_keys = @key.sign(message, @foreign_keys)
 
-        expect(sig.to_hex).to eq '3081e804210242ea46f23d6dc4e4515f2b1001734cf2c4a09b9ab169a588bf01a13b9e553de03067022100ffffffff00000000fffffffe714565846c5397cd4e5e24b41dfd02b75761d074021500881bf1e9c67d05c7a8a6ef93552a785246603436021500e17e885e1b5c59e80a5ed90ae26bea5067b3314a02146655e2724456f7d8d21238d797e0a809a3013337305a02150198482b6231394361df3ad5b577c70953b2572c9f02141cd9f8cc0df48519ecd6ad6e354ca634c8b604c20214361d1207afcdb5c041df20efac5496b26243403a0215008fddaf160ecfaed0c2048e6f018c933fc398e33b'
+        expect(sig.to_hex).to eq '3081a004150335d6eb01d7c658c2aae34e1e910e1b44c993069d30430214685baa33eacec37ff3530d710ca852731e1ac7b0021500881bf1e9c67d05c7a8a6ef93552a7852466034360214211b72b5e3a934d0e096441c5208b4322a83b7a130420214098d90e6e0a5e08186815be4a20a41480d55d7c202141cd9f8cc0df48519ecd6ad6e354ca634c8b604c2021415019f51cc2480ef6148dcd35a4be28037bf8899'
 
-        expected_public_keys = [0, 2, 1, 3].map{|i| ([@key] + @foreign_keys)[i].public_key}
+        expected_public_keys = [2, 1, 0].map{|i| ([@key] + @foreign_keys)[i].public_key}
         expect(public_keys).to eq expected_public_keys
 
         expect(sig.verify(message, public_keys)).to be true

data/spec/public_key_spec.rb

@@ -4,10 +4,11 @@ describe RingSig::PublicKey do
   compressed_hex = '03678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb6'
   uncompressed_hex = '04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f'
   group = ECDSA::Group::Secp256k1
+  hasher = RingSig::Hasher::Secp256k1_Sha256
   key = RingSig::PublicKey.new(group.new_point([
     46833799212576611471711417854818141128240043280360231002189938627535641370294,
     33454781559405909841731692443380420218121109572881027288991311028992835919199
-    ]))
+    ]), hasher)
 
   describe '#to_hex' do
     it 'converts to compressed hex' do
@@ -21,11 +22,11 @@ describe RingSig::PublicKey do
 
   describe '#from_hex' do
     it 'converts from compressed hex' do
-      expect(RingSig::PublicKey.from_hex(compressed_hex)).to eq key
+      expect(RingSig::PublicKey.from_hex(compressed_hex, hasher)).to eq key
     end
 
     it 'converts from uncompressed hex' do
-      expect(RingSig::PublicKey.from_hex(uncompressed_hex)).to eq key
+      expect(RingSig::PublicKey.from_hex(uncompressed_hex, hasher)).to eq key
     end
   end
 
@@ -41,22 +42,22 @@ describe RingSig::PublicKey do
 
   describe '#from_octet' do
     it 'converts from compressed octet' do
-      expect(RingSig::PublicKey.from_octet([compressed_hex].pack('H*'))).to eq key
+      expect(RingSig::PublicKey.from_octet([compressed_hex].pack('H*'), hasher)).to eq key
     end
 
     it 'converts from uncompressed octet' do
-      expect(RingSig::PublicKey.from_octet([uncompressed_hex].pack('H*'))).to eq key
+      expect(RingSig::PublicKey.from_octet([uncompressed_hex].pack('H*'), hasher)).to eq key
     end
   end
 
   describe '==' do
     it 'returns true when keys are the same' do
       expect(key).to eq key
-      expect(RingSig::PublicKey.new(key.point) == key).to eq true
+      expect(RingSig::PublicKey.new(key.point, hasher) == key).to eq true
     end
 
     it 'returns false when keys are different' do
-      expect(RingSig::PublicKey.new(group.generator) == key).to eq false
+      expect(RingSig::PublicKey.new(group.generator, hasher) == key).to eq false
     end
   end
 end

data/spec/signature_spec.rb

@@ -2,7 +2,8 @@ require 'spec_helper'
 
 describe RingSig::Signature do
   group = ECDSA::Group::Secp256k1
-  signature = RingSig::Signature.new(group.generator, [10], [20])
+  hasher = RingSig::Hasher::Secp256k1_Sha256
+  signature = RingSig::Signature.new(group.generator, [10], [20], hasher)
   sig_hex = '302d04210279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798300302010a3003020114'
   sig_der = "0-\x04!\x02y\xBEf~\xF9\xDC\xBB\xACU\xA0b\x95\xCE\x87\v\a\x02\x9B\xFC\xDB-\xCE(\xD9Y\xF2\x81[\x16\xF8\x17\x980\x03\x02\x01\n0\x03\x02\x01\x14".force_encoding('binary')
 
@@ -36,13 +37,13 @@ describe RingSig::Signature do
 
   describe '#from_hex' do
     it 'converts from hex correctly' do
-      expect(RingSig::Signature.from_hex(sig_hex).components).to eq signature.components
+      expect(RingSig::Signature.from_hex(sig_hex, hasher).components).to eq signature.components
     end
   end
 
   describe '#from_der' do
     it 'converts from der correctly' do
-      expect(RingSig::Signature.from_der(sig_der).components).to eq signature.components
+      expect(RingSig::Signature.from_der(sig_der, hasher).components).to eq signature.components
     end
   end
 end

metadata

@@ -1,127 +1,127 @@
 --- !ruby/object:Gem::Specification
 name: ring_sig
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Stephen McCarthy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-13 00:00:00.000000000 Z
+date: 2014-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: markdown
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1'
 - !ruby/object:Gem::Dependency
   name: redcarpet
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3'
 - !ruby/object:Gem::Dependency
   name: ecdsa
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.2'
 description: Ring Signatures allow someone to non-interactively sign a message which
   can be verified against a set of chosen public keys.
 email: sjmccarthy@gmail.com
@@ -129,16 +129,15 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
-- .yardopts
+- ".gitignore"
+- ".travis.yml"
+- ".yardopts"
 - CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
 - lib/ring_sig.rb
-- lib/ring_sig/ecdsa/point.rb
 - lib/ring_sig/hasher.rb
 - lib/ring_sig/private_key.rb
 - lib/ring_sig/public_key.rb
@@ -160,12 +159,12 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []

data/lib/ring_sig/ecdsa/point.rb

@@ -1,6 +0,0 @@
-module ECDSA
-  class Point
-    alias_method :*, :multiply_by_scalar
-    alias_method :+, :add_to_point
-  end
-end