cose 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb978af65e0e7ba43a06e776b45792856bec76e58a7ce6d1d3d88619c6fca09e
-  data.tar.gz: c8cdf73b87523e266c36076c542cf91bb5e252bda826523308b4adc355ce1c6d
+  metadata.gz: 32030549359b2c5afe6862546965c13f4071b55c9ace03a6385ce5c62c3af7bc
+  data.tar.gz: 46e4769b04dadb56b998ae807a2cfe80e73c95c131c93b8b6424d5752f1aae0a
 SHA512:
-  metadata.gz: bc8f10f840915de994963318cf3fb5f138eb836bd391280029cceb7b5b4c9a95577dd281be1d67f1dc36def4a5a809af6e4ff665dc26e0cf30990219248cf043
-  data.tar.gz: 87ec47c8278246a0fdbec217a1d13b6588aed62400bfd49010d4573dab75b70a436867fe8d4fb895b784bbe29783c28e2910f576f213aeda8d830662f1067f7f
+  metadata.gz: 907c461c040d4e80b19403922557a7098e30cb348a829f9252ed74ab4c9f8d3ca62ba24f75ddc6e4df6c19de95f900be53483dbc4c97ded66927433513a38ce0
+  data.tar.gz: 8142ebaaf7c32486f60f29243e689ae5bf96a4a39eed87838c55eeed8a13cc102e7dbd14d489749da9cff5ac149aa4a97c172f113e69f70e0658d285f3571063

data/.rubocop.yml

@@ -16,6 +16,7 @@ Lint:
 
 Metrics/LineLength:
   Max: 120
+  IgnoreCopDirectives: true
 
 Naming:
   Enabled: true

data/.travis.yml

@@ -4,16 +4,25 @@ language: ruby
 rvm:
   - ruby-head
   - 2.6.2
-  - 2.5.4
-  - 2.4.5
+  - 2.5.5
+  - 2.4.6
+  - 2.3.8
+  - 2.2.10
 
 gemfile:
   - gemfiles/openssl_2_0.gemfile
   - gemfiles/openssl_2_1.gemfile
+  - gemfiles/openssl_default.gemfile
 
-before_install: gem install bundler -v 2.0.1
+before_install: gem install bundler -v '~> 1.17'
 
 matrix:
   fast_finish: true
   allow_failures:
     - rvm: ruby-head
+    - rvm: 2.2.10
+  exclude:
+    - rvm: 2.2.10
+      gemfile: gemfiles/openssl_2_0.gemfile
+    - rvm: 2.2.10
+      gemfile: gemfiles/openssl_2_1.gemfile

data/Appraisals

@@ -5,3 +5,6 @@ end
 appraise "openssl_2_1" do
   gem "openssl", "~> 2.1.0"
 end
+
+appraise "openssl_default" do
+end

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [v0.6.0] - 2019-04-03
+
+### Added
+
+- Support Key Common Parameters (`#base_iv`, `key_ops`, `#alg` and `#kid`)
+- Support OKP Key
+- Support RSA private key serialization
+- Works with ruby 2.3
+
+### Changed
+
+- Key type-specific parameters names better match RFC
+
 ## [v0.5.0] - 2019-03-25
 
 ### Added
@@ -54,6 +67,7 @@
 - EC2 key object
 - Works with ruby 2.5
 
+[v0.6.0]: https://github.com/cedarcode/cose-ruby/compare/v0.5.0...v0.6.0/
 [v0.5.0]: https://github.com/cedarcode/cose-ruby/compare/v0.4.1...v0.5.0/
 [v0.4.1]: https://github.com/cedarcode/cose-ruby/compare/v0.4.0...v0.4.1/
 [v0.4.0]: https://github.com/cedarcode/cose-ruby/compare/v0.3.0...v0.4.0/

data/README.md

@@ -30,48 +30,65 @@ Or install it yourself as:
 ```ruby
 cbor_data = "..."
 
-cose_key = COSE::Key.deserialize(cbor_data)
+key = COSE::Key.deserialize(cbor_data)
 ```
 
 Once you have a `COSE::Key` instance you can either access key parameters directly and/or convert it to an
-`OpenSSL::PKey::PKey` instance for operating with it (encrypting/decrypting, signing/verifying, etc).
+`OpenSSL::PKey::PKey` instance (if supported for the key type) for operating with it
+(encrypting/decrypting, signing/verifying, etc).
 
 ```ruby
 # Convert to an OpenSSL::PKey::PKey
-openssl_pkey = cose_key.to_pkey
+if key.respond_to?(:to_pkey)
+  openssl_pkey = key.to_pkey
+end
 
 # Access COSE key parameters
 case key
+when COSE::Key::OKP
+  key.crv
+  key.x
+  key.d
 when COSE::Key::EC2
-  key.curve
-  key.x_coordinate
-  key.y_coordinate
-  key.d_coordinate
+  key.crv
+  key.x
+  key.y
+  key.d
 when COSE::Key::RSA
-  key.modulus_n
-  key.public_exponent_e
-  key.private_exponent_d
-  key.prime_factor_p
-  key.prime_factor_q
-  key.d_p
-  key.d_q
-  key.q_inv
+  key.n
+  key.e
+  key.d
+  key.p
+  key.q
+  key.dp
+  key.dq
+  key.qinv
 when COSE::Key::Symmetric
-  key.key_value
+  key.k
 end
 ```
 
 If you already know which COSE key type is encoded in the CBOR data, then:
 
+```ruby
+okp_key_cbor = "..."
+
+cose_okp_key = COSE::Key::OKP.deserialize(okp_key_cbor)
+
+cose_okp_key.crv
+cose_okp_key.x
+cose_okp_key.d
+```
+
 ```ruby
 ec2_key_cbor = "..."
 
 cose_ec2_key = COSE::Key::EC2.deserialize(ec2_key_cbor)
 
-cose_ec2_key.curve
-cose_ec2_key.x_coordinate
-cose_ec2_key.y_coordinate
-cose_ec2_key.d_coordinate
+cose_ec2_key.crv
+cose_ec2_key.x
+cose_ec2_key.y
+cose_ec2_key.d
 
 # or
 
@@ -83,7 +100,7 @@ symmetric_key_cbor = "..."
 
 cose_symmetric_key = COSE::Key::Symmetric.deserialize(symmetric_key_cbor)
 
-cose_symmetric_key.key_value
+cose_symmetric_key.k
 ```
 
 ```ruby
@@ -91,14 +108,14 @@ rsa_key_cbor = "..."
 
 cose_rsa_key = COSE::Key::RSA.deserialize(rsa_key_cbor)
 
-cose_rsa_key.modulus_n
-cose_rsa_key.public_exponent_e
-cose_rsa_key.private_exponent_d
-cose_rsa_key.prime_factor_p
-cose_rsa_key.prime_factor_q
-cose_rsa_key.d_p
-cose_rsa_key.d_q
-cose_rsa_key.q_inv
+cose_rsa_key.n
+cose_rsa_key.e
+cose_rsa_key.d
+cose_rsa_key.p
+cose_rsa_key.q
+cose_rsa_key.dp
+cose_rsa_key.dq
+cose_rsa_key.qinv
 
 # or
 

data/cose.gemspec

@@ -35,7 +35,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "appraisal", "~> 2.2.0"
   spec.add_development_dependency "bundler", ">= 1.17", "< 3"
-  spec.add_development_dependency "byebug", "~> 11.0"
+  spec.add_development_dependency "byebug", ">= 10.0"
   spec.add_development_dependency "rake", "~> 12.3"
   spec.add_development_dependency "rspec", "~> 3.8"
   spec.add_development_dependency "rubocop", "0.65.0"

data/gemfiles/openssl_default.gemfile

@@ -0,0 +1,5 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gemspec path: "../"

data/lib/cose/key.rb

@@ -1,5 +1,6 @@
 require "cbor"
 require "cose/key/ec2"
+require "cose/key/okp"
 require "cose/key/rsa"
 require "cose/key/symmetric"
 require "openssl"
@@ -23,12 +24,16 @@ module COSE
       map = CBOR.decode(data)
 
       case map[Base::LABEL_KTY]
+      when COSE::Key::OKP::KTY_OKP
+        COSE::Key::OKP.from_map(map)
       when COSE::Key::EC2::KTY_EC2
         COSE::Key::EC2.from_map(map)
       when COSE::Key::RSA::KTY_RSA
         COSE::Key::RSA.from_map(map)
       when COSE::Key::Symmetric::KTY_SYMMETRIC
         COSE::Key::Symmetric.from_map(map)
+      when nil
+        raise UnknownKeyType, "Missing required key type kty label"
       else
         raise UnknownKeyType, "Unsupported or unknown key type #{map[Base::LABEL_KTY]}"
       end

data/lib/cose/key/base.rb

@@ -5,16 +5,50 @@ require "cbor"
 module COSE
   module Key
     class Base
+      LABEL_BASE_IV = 5
+      LABEL_KEY_OPS = 4
+      LABEL_ALG = 3
+      LABEL_KID = 2
       LABEL_KTY = 1
 
       def self.deserialize(cbor)
         from_map(CBOR.decode(cbor))
       end
 
-      def self.enforce_type(map, kty, error_message)
-        if map[LABEL_KTY] != kty
-          raise error_message
-        end
+      def self.from_map(map)
+        enforce_type(map)
+
+        new(
+          base_iv: map[LABEL_BASE_IV],
+          key_ops: map[LABEL_KEY_OPS],
+          alg: map[LABEL_ALG],
+          kid: map[LABEL_KID],
+          **keyword_arguments_for_initialize(map)
+        )
+      end
+
+      attr_reader :kid, :alg, :key_ops, :base_iv
+
+      def initialize(kid: nil, alg: nil, key_ops: nil, base_iv: nil)
+        @kid = kid
+        @alg = alg
+        @key_ops = key_ops
+        @base_iv = base_iv
+      end
+
+      def serialize
+        CBOR.encode(map)
+      end
+
+      def map
+        map = {
+          LABEL_BASE_IV => base_iv,
+          LABEL_KEY_OPS => key_ops,
+          LABEL_ALG => alg,
+          LABEL_KID => kid,
+        }
+
+        map.reject { |_k, v| v.nil? }
       end
     end
   end

data/lib/cose/key/curve_key.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "cose/key/base"
+require "openssl"
+
+module COSE
+  module Key
+    class CurveKey < Base
+      LABEL_CRV = -1
+      LABEL_X = -2
+      LABEL_D = -4
+
+      attr_reader :crv, :d, :x
+
+      def self.keyword_arguments_for_initialize(map)
+        {
+          crv: map[LABEL_CRV],
+          x: map[LABEL_X],
+          d: map[LABEL_D]
+        }
+      end
+
+      def initialize(crv:, x: nil, d: nil, **keyword_arguments) # rubocop:disable Naming/UncommunicativeMethodParamName
+        super(**keyword_arguments)
+
+        if !crv
+          raise ArgumentError, "Required crv is missing"
+        elsif !x && !d
+          raise ArgumentError, "x and d cannot be missing simultaneously"
+        else
+          @crv = crv
+          @x = x
+          @d = d
+        end
+      end
+
+      def map
+        map = super.merge(
+          LABEL_CRV => crv,
+          LABEL_X => x,
+          LABEL_D => d
+        )
+
+        map.reject { |_k, v| v.nil? }
+      end
+    end
+  end
+end

data/lib/cose/key/ec2.rb

@@ -1,17 +1,12 @@
 # frozen_string_literal: true
 
-require "cose/key/base"
+require "cose/key/curve_key"
 require "openssl"
 
 module COSE
   module Key
-    class EC2 < Base
-      ALG_LABEL = 3
-
-      CRV_LABEL = -1
-      D_LABEL = -4
-      X_LABEL = -2
-      Y_LABEL = -3
+    class EC2 < CurveKey
+      LABEL_Y = -3
 
       KTY_EC2 = 2
       CRV_P256 = 1
@@ -24,6 +19,12 @@ module COSE
         CRV_P521 => "secp521r1"
       }.freeze
 
+      def self.enforce_type(map)
+        if map[LABEL_KTY] != KTY_EC2
+          raise "Not an EC2 key"
+        end
+      end
+
       def self.from_pkey(pkey)
         curve = PKEY_CURVES.key(pkey.group.curve_name) || raise("Unsupported EC curve #{pkey.group.curve_name}")
 
@@ -42,73 +43,58 @@ module COSE
 
           coordinate_length = bytes.size / 2
 
-          x_coordinate = bytes[0..(coordinate_length - 1)]
-          y_coordinate = bytes[coordinate_length..-1]
+          x = bytes[0..(coordinate_length - 1)]
+          y = bytes[coordinate_length..-1]
         end
 
         if private_key
-          d_coordinate = private_key.to_s(2)
+          d = private_key.to_s(2)
         end
 
-        new(curve: curve, x_coordinate: x_coordinate, y_coordinate: y_coordinate, d_coordinate: d_coordinate)
+        new(crv: curve, x: x, y: y, d: d)
       end
 
-      attr_reader :algorithm, :curve, :d_coordinate, :x_coordinate, :y_coordinate
+      attr_reader :y
 
-      def initialize(algorithm: nil, curve:, d_coordinate: nil, x_coordinate:, y_coordinate:)
-        if !curve
-          raise ArgumentError, "Required curve is missing"
-        elsif !x_coordinate
-          raise ArgumentError, "Required x-coordinate is missing"
-        elsif !y_coordinate
-          raise ArgumentError, "Required y-coordinate is missing"
+      def initialize(y: nil, **keyword_arguments) # rubocop:disable Naming/UncommunicativeMethodParamName
+        if (!y || !keyword_arguments[:x]) && !keyword_arguments[:d]
+          raise ArgumentError, "Both x and y are required if d is missing"
         else
-          @algorithm = algorithm
-          @curve = curve
-          @d_coordinate = d_coordinate
-          @x_coordinate = x_coordinate
-          @y_coordinate = y_coordinate
+          super(**keyword_arguments)
+
+          @y = y
         end
       end
 
-      def serialize
-        CBOR.encode(
+      def map
+        map = super.merge(
           Base::LABEL_KTY => KTY_EC2,
-          CRV_LABEL => curve,
-          X_LABEL => x_coordinate,
-          Y_LABEL => y_coordinate,
-          D_LABEL => d_coordinate
+          LABEL_Y => y,
         )
+
+        map.reject { |_k, v| v.nil? }
       end
 
       def to_pkey
-        if PKEY_CURVES[curve]
-          group = OpenSSL::PKey::EC::Group.new(PKEY_CURVES[curve])
+        if PKEY_CURVES[crv]
+          group = OpenSSL::PKey::EC::Group.new(PKEY_CURVES[crv])
           pkey = OpenSSL::PKey::EC.new(group)
-          public_key_bn = OpenSSL::BN.new("\x04" + x_coordinate + y_coordinate, 2)
+          public_key_bn = OpenSSL::BN.new("\x04" + x + y, 2)
           public_key_point = OpenSSL::PKey::EC::Point.new(group, public_key_bn)
           pkey.public_key = public_key_point
 
-          if d_coordinate
-            pkey.private_key = OpenSSL::BN.new(d_coordinate, 2)
+          if d
+            pkey.private_key = OpenSSL::BN.new(d, 2)
           end
 
           pkey
         else
-          raise "Unsupported curve #{curve}"
+          raise "Unsupported curve #{crv}"
         end
       end
 
-      def self.from_map(map)
-        enforce_type(map, KTY_EC2, "Not an EC2 key")
-
-        new(
-          algorithm: map[ALG_LABEL],
-          curve: map[CRV_LABEL],
-          d_coordinate: map[D_LABEL],
-          x_coordinate: map[X_LABEL],
-          y_coordinate: map[Y_LABEL]
-        )
+      def self.keyword_arguments_for_initialize(map)
+        super.merge(y: map[LABEL_Y])
       end
     end
   end

data/lib/cose/key/okp.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "cose/key/curve_key"
+require "openssl"
+
+module COSE
+  module Key
+    class OKP < CurveKey
+      KTY_OKP = 1
+
+      def self.enforce_type(map)
+        if map[LABEL_KTY] != KTY_OKP
+          raise "Not an OKP key"
+        end
+      end
+
+      def map
+        super.merge(LABEL_KTY => KTY_OKP)
+      end
+    end
+  end
+end

data/lib/cose/key/rsa.rb

@@ -11,99 +11,124 @@ module COSE
       LABEL_D = -3
       LABEL_P = -4
       LABEL_Q = -5
-      LABEL_D_P = -6
-      LABEL_D_Q = -7
-      LABEL_Q_INV = -8
+      LABEL_DP = -6
+      LABEL_DQ = -7
+      LABEL_QINV = -8
 
       KTY_RSA = 3
 
+      def self.enforce_type(map)
+        if map[LABEL_KTY] != KTY_RSA
+          raise "Not an RSA key"
+        end
+      end
+
       def self.from_pkey(pkey)
         params = pkey.params
 
         attributes = {
-          modulus_n: params["n"].to_s(2),
-          public_exponent_e: params["e"].to_s(2)
+          n: params["n"].to_s(2),
+          e: params["e"].to_s(2)
         }
 
         if pkey.private?
           attributes.merge!(
-            private_exponent_d: params["d"].to_s(2),
-            prime_factor_p: params["p"].to_s(2),
-            prime_factor_q: params["q"].to_s(2),
-            d_p: params["dmp1"].to_s(2),
-            d_q: params["dmq1"].to_s(2),
-            q_inv: params["iqmp"].to_s(2)
+            d: params["d"].to_s(2),
+            p: params["p"].to_s(2),
+            q: params["q"].to_s(2),
+            dp: params["dmp1"].to_s(2),
+            dq: params["dmq1"].to_s(2),
+            qinv: params["iqmp"].to_s(2)
           )
         end
 
         new(attributes)
       end
 
-      attr_reader(
-        :modulus_n,
-        :public_exponent_e,
-        :private_exponent_d,
-        :prime_factor_p,
-        :prime_factor_q,
-        :d_p,
-        :d_q,
-        :q_inv
-      )
-
-      def initialize(
-        modulus_n:,
-        public_exponent_e:,
-        private_exponent_d: nil,
-        prime_factor_p: nil,
-        prime_factor_q: nil,
-        d_p: nil,
-        d_q: nil,
-        q_inv: nil
-      )
-        if !modulus_n
-          raise ArgumentError, "Required modulus_n is missing"
-        elsif !public_exponent_e
-          raise ArgumentError, "Required public_exponent_e is missing"
+      attr_reader :n, :e, :d, :p, :q, :dp, :dq, :qinv
+
+      def initialize(n:, e:, d: nil, p: nil, q: nil, dp: nil, dq: nil, qinv: nil, **keyword_arguments) # rubocop:disable Naming/UncommunicativeMethodParamName
+        super(**keyword_arguments)
+
+        if !n
+          raise ArgumentError, "Required public field n is missing"
+        elsif !e
+          raise ArgumentError, "Required public field e is missing"
         else
-          @modulus_n = modulus_n
-          @public_exponent_e = public_exponent_e
-          @private_exponent_d = private_exponent_d
-          @prime_factor_p = prime_factor_p
-          @prime_factor_q = prime_factor_q
-          @d_p = d_p
-          @d_q = d_q
-          @q_inv = q_inv
+          private_fields = { d: d, p: p, q: q, dp: dp, dq: dq, qinv: qinv }
+
+          if private_fields.values.all?(&:nil?) || private_fields.values.none?(&:nil?)
+            @n = n
+            @e = e
+            @d = d
+            @p = p
+            @q = q
+            @dp = dp
+            @dq = dq
+            @qinv = qinv
+          else
+            missing = private_fields.detect { |_k, v| v.nil? }[0]
+            raise ArgumentError, "Incomplete private fields, #{missing} is missing"
+          end
         end
       end
 
-      def serialize
-        CBOR.encode(
+      def map
+        map = super.merge(
           Base::LABEL_KTY => KTY_RSA,
-          LABEL_N => modulus_n,
-          LABEL_E => public_exponent_e,
-          LABEL_D => private_exponent_d,
-          LABEL_P => prime_factor_p,
-          LABEL_Q => prime_factor_q,
-          LABEL_D_P => d_p,
-          LABEL_D_Q => d_q,
-          LABEL_Q_INV => q_inv
+          LABEL_N => n,
+          LABEL_E => e,
+          LABEL_D => d,
+          LABEL_P => p,
+          LABEL_Q => q,
+          LABEL_DP => dp,
+          LABEL_DQ => dq,
+          LABEL_QINV => qinv
         )
+
+        map.reject { |_k, v| v.nil? }
       end
 
       def to_pkey
         pkey = OpenSSL::PKey::RSA.new
 
-        pkey.set_key(bn(modulus_n), bn(public_exponent_e), bn(private_exponent_d))
-        pkey.set_factors(bn(prime_factor_p), bn(prime_factor_q))
-        pkey.set_crt_params(bn(d_p), bn(d_q), bn(q_inv))
+        if pkey.respond_to?(:set_key)
+          pkey.set_key(bn(n), bn(e), bn(d))
+        else
+          pkey.n = bn(n)
+          pkey.e = bn(e)
+          pkey.d = bn(d)
+        end
+
+        if pkey.respond_to?(:set_factors)
+          pkey.set_factors(bn(p), bn(q))
+        else
+          pkey.p = bn(p)
+          pkey.q = bn(q)
+        end
+
+        if pkey.respond_to?(:set_crt_params)
+          pkey.set_crt_params(bn(dp), bn(dq), bn(qinv))
+        else
+          pkey.dmp1 = bn(dp)
+          pkey.dmq1 = bn(dq)
+          pkey.iqmp = bn(qinv)
+        end
 
         pkey
       end
 
-      def self.from_map(map)
-        enforce_type(map, KTY_RSA, "Not an RSA key")
-
-        new(modulus_n: map[LABEL_N], public_exponent_e: map[LABEL_E])
+      def self.keyword_arguments_for_initialize(map)
+        {
+          n: map[LABEL_N],
+          e: map[LABEL_E],
+          d: map[LABEL_D],
+          p: map[LABEL_P],
+          q: map[LABEL_Q],
+          dp: map[LABEL_DP],
+          dq: map[LABEL_DQ],
+          qinv: map[LABEL_QINV]
+        }
       end
 
       private

data/lib/cose/key/symmetric.rb

@@ -5,23 +5,34 @@ require "cose/key/base"
 module COSE
   module Key
     class Symmetric < Base
-      K_LABEL = -1
+      LABEL_K = -1
+
       KTY_SYMMETRIC = 4
 
-      attr_reader :key_value
+      attr_reader :k
 
-      def initialize(key_value:)
-        if !key_value
-          raise ArgumentError, "Required key value is missing"
+      def self.enforce_type(map)
+        if map[LABEL_KTY] != KTY_SYMMETRIC
+          raise "Not a Symmetric key"
         end
+      end
+
+      def initialize(k:, **keyword_arguments) # rubocop:disable Naming/UncommunicativeMethodParamName
+        super(**keyword_arguments)
 
-        @key_value = key_value
+        if !k
+          raise ArgumentError, "Required key value k is missing"
+        else
+          @k = k
+        end
       end
 
-      def self.from_map(map)
-        enforce_type(map, KTY_SYMMETRIC, "Not a Symmetric key")
+      def map
+        super.merge(LABEL_KTY => KTY_SYMMETRIC, LABEL_K => k)
+      end
 
-        new(key_value: map[K_LABEL])
+      def self.keyword_arguments_for_initialize(map)
+        { k: map[LABEL_K] }
       end
     end
   end

data/lib/cose/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module COSE
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cose
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Gonzalo Rodriguez
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-03-25 00:00:00.000000000 Z
+date: 2019-04-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cbor
@@ -63,16 +63,16 @@ dependencies:
   name: byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '11.0'
+        version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '11.0'
+        version: '10.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -138,12 +138,15 @@ files:
 - cose.gemspec
 - gemfiles/openssl_2_0.gemfile
 - gemfiles/openssl_2_1.gemfile
+- gemfiles/openssl_default.gemfile
 - lib/cose.rb
 - lib/cose/encrypt.rb
 - lib/cose/encrypt0.rb
 - lib/cose/key.rb
 - lib/cose/key/base.rb
+- lib/cose/key/curve_key.rb
 - lib/cose/key/ec2.rb
+- lib/cose/key/okp.rb
 - lib/cose/key/rsa.rb
 - lib/cose/key/symmetric.rb
 - lib/cose/mac.rb