otp 0.0.9 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 032b0bd99d66d97d8281cd5006409b1f482c2314
-  data.tar.gz: ca0320a12fe5d73c907e8cd445dac6fd0219112f
+  metadata.gz: 81f98da9bacd6750a761f89590463ed0777b2b1d
+  data.tar.gz: 710bb562bde9f46efcdf89f5e9777839ba8dbf37
 SHA512:
-  metadata.gz: f60da46723a92855571fcabbf0b8e0ad264093822516ebdd9d152181cb102280c92a3ce97a499b9bf661aac9adf6ff2694e2ae02294eb39d2e6d1be70d3eb8ed
-  data.tar.gz: 8d90aba69fd87db84b94a3b0a374f817a8566d970be4820e868f16a1098b81e8de188247bc9b29c4f811a0e4779bb1c8cc43907aef5fc1b4fd974a7fd68e28bb
+  metadata.gz: a5921f7970174fafc13b4ce15de85f94772ae958338bab7645d9a5804e61b45a6e8ef1666e0a18075dfabb47e52d8356f6fe7a03575d6ac472b5471052a7c755
+  data.tar.gz: 85f05deafa16e5232185255572003d7c3c477ada47079dcd393262983694030f24cc7e540e54d503c4f19f132aee103b1cb5c3b277301efd771cb42f56adbd2c

data/.rubocop.yml

@@ -39,8 +39,8 @@ Style/FormatString:
 Style/EachWithObject:
   Enabled: false
 
-Metrics/AbcSize:
-  Max: 20
+#Metrics/AbcSize:
+#  Max: 20
 
 Metrics/MethodLength:
   Max: 30

data/README.md

@@ -47,11 +47,11 @@ You can use the last and post option parameters to verify several generations, i
 
 TOTP and HOTP algorithm details can be referred at the following URLs.
 
-* HOTP: An HMAC-Based One-Time Password Algorithm - http://tools.ietf.org/html/rfc4226
-* TOTP: Time-Based One-Time Password Algorithm - http://tools.ietf.org/html/rfc6238
+* [HOTP: An HMAC-Based One-Time Password Algorithm](http://tools.ietf.org/html/rfc4226)
+* [TOTP: Time-Based One-Time Password Algorithm](http://tools.ietf.org/html/rfc6238)
 
 In the OTP URI format, the value of "secret" is encoded with BASE32 algorithm.
 The Format details are described in the document of Google Authenticator.
 
-* The Base16, Base32, and Base64 Data Encodings - http://tools.ietf.org/html/rfc4648
-* Google Authenticator Key URI format - https://github.com/google/google-authenticator/wiki/Key-Uri-Format
+* [The Base16, Base32, and Base64 Data Encodings](http://tools.ietf.org/html/rfc4648)
+* [Google Authenticator Key URI format](https://github.com/google/google-authenticator/wiki/Key-Uri-Format)

data/lib/otp/base.rb

@@ -9,9 +9,7 @@ module OTP
     DEFAULT_DIGITS = 6
     DEFAULT_ALGORITHM = "SHA1"
 
-    attr_accessor :secret
-    attr_accessor :algorithm
-    attr_accessor :digits
+    attr_accessor :secret, :algorithm, :digits
     attr_accessor :issuer, :accountname
 
     def initialize(secret=nil, algorithm=nil, digits=nil)
@@ -21,24 +19,23 @@ module OTP
     end
 
     def new_secret(num_bytes=10)
-      s = (0...num_bytes).map{ Random.rand(256).chr }.join
-      self.secret = OTP::Base32.encode(s)
+      self.raw_secret = OpenSSL::Random.random_bytes(num_bytes)
     end
 
-    def moving_factor
-      raise NotImplementedError
+    def raw_secret=(bytes)
+      self.secret = OTP::Base32.encode(bytes)
     end
 
-    def otp(generation=0)
-      hash = hmac(algorithm, OTP::Base32.decode(secret),
-                  pack_int64(moving_factor+generation))
-      return truncate(hash)
+    def raw_secret
+      return OTP::Base32.decode(secret)
+    end
+
+    def moving_factor
+      raise NotImplementedError
     end
 
     def password(generation=0)
-      pw = (otp(generation) % (10 ** digits)).to_s
-      pw = "0" + pw while pw.length < digits
-      return pw
+      return otp(algorithm, raw_secret, moving_factor+generation, digits)
     end
 
     def verify(given_pw, last:0, post:0)
@@ -48,18 +45,24 @@ module OTP
       return (-last..post).any?{|i| compare(password(i), given_pw) }
     end
 
-    ## URI related methods
-
     def to_uri
-      OTP::URI.format(self)
+      return OTP::URI.format(self)
     end
 
-    def type_specific_uri_params
-      raise NotImplementedError
+    def uri_params
+      params = {}
+      params[:secret] = secret
+      params[:issuer] = issuer if issuer
+      params[:algorithm] = algorithm if algorithm != DEFAULT_ALGORITHM
+      params[:digits] = digits if digits != DEFAULT_DIGITS
+      return params
     end
 
-    def extract_type_specific_uri_params(query)
-      raise NotImplementedError
+    def extract_uri_params(params)
+      self.secret = params["secret"]
+      self.issuer = issuer || params["issuer"]
+      self.algorithm = params["algorithm"] || algorithm
+      self.digits = (params["digits"] || digits).to_i
     end
   end
 end

data/lib/otp/hotp.rb

@@ -13,14 +13,13 @@ module OTP
       return count
     end
 
-    def type_specific_uri_params
-      return {count: count}
+    def uri_params
+      return super.merge(count: count)
     end
 
-    def extract_type_specific_uri_params(query)
-      if value = query["count"]
-        self.count = value.to_i
-      end
+    def extract_uri_params(params)
+      super
+      self.count = (params["count"] || count).to_i
     end
   end
 end

data/lib/otp/totp.rb

@@ -16,16 +16,15 @@ module OTP
       return (time || Time.now).to_i / period
     end
 
-    def type_specific_uri_params
-      params = {}
+    def uri_params
+      params = super
       params["period"] = period if period != DEFAULT_PERIOD
       return params
     end
 
-    def extract_type_specific_uri_params(query)
-      if value = query["period"]
-        self.period = value.to_i
-      end
+    def extract_uri_params(params)
+      super
+      self.period = (params["period"] || period).to_i
     end
   end
 end

data/lib/otp/uri.rb

@@ -2,29 +2,23 @@ require "uri"
 
 module OTP
   module URI
-    module_function
+    SCHEME = "otpauth"
 
-    SCHEME = "othauth"
+    module_function
 
     def parse(uri_string)
       uri = ::URI.parse(uri_string)
-      raise "URI scheme not match: #{uri.scheme}" unless uri.scheme != SCHEME
-      otp = otp_class(uri).new
-      m = %r{/(?:([^:]*): *)?(.+)}.match(::URI.decode(uri.path))
+      if uri.scheme.downcase != SCHEME
+        raise "URI scheme not match: #{uri.scheme}"
+      end
+      otp = type_to_class(uri).new
+      unless m = %r{/(?:([^:]*): *)?(.+)}.match(::URI.decode(uri.path))
+        raise "account name must be present: #{uri_string}"
+      end
       otp.issuer = m[1] if m[1]
       otp.accountname = m[2]
       query = Hash[::URI.decode_www_form(uri.query)]
-      otp.secret = query["secret"]
-      if value = query["algorithm"]
-        otp.algorithm = value
-      end
-      if value = query["issuer"]
-        otp.issuer = value
-      end
-      if value = query["digits"]
-        otp.digits = value.to_i
-      end
-      otp.extract_type_specific_uri_params(query)
+      otp.extract_uri_params(query)
       return otp
     end
 
@@ -32,41 +26,23 @@ module OTP
       raise "secret must be set" if otp.secret.nil?
       raise "accountname must be set" if otp.accountname.nil?
       typename = otp.class.name.split("::")[-1].downcase
-      label = otp.issuer ? "#{otp.issuer}:#{otp.accountname}" : otp.accountname
-      params = pickup_params(otp)
-      return "otpauth://%s/%s?%s" % [
+      label = otp.accountname.dup
+      label.prepend("#{otp.issuer}:") if otp.issuer
+      return "%s://%s/%s?%s" % [
+        SCHEME,
         ::URI.encode(typename),
         ::URI.encode(label),
-        ::URI.encode_www_form(params)
+        ::URI.encode_www_form(otp.uri_params)
       ]
     end
 
-    def otp_class(uri)
-      case uri.host.upcase
-      when "HOTP"
-        OTP::HOTP
-      when "TOTP"
-        OTP::TOTP
-      else
-        raise "unknown OTP type: #{uri.host}"
-      end
-    end
-
-    def pickup_params(otp)
-      param_spec = [
-        [:secret, nil],
-        [:issuer, nil],
-        [:algorithm, OTP::Base::DEFAULT_ALGORITHM],
-        [:digits, OTP::Base::DEFAULT_DIGITS],
-      ]
-      params = param_spec.reduce({}) do |h, (name, default)|
-        value = otp.send(name)
-        if value && value != default
-          h[name] = value
-        end
-        h
-      end
-      return params.merge(otp.type_specific_uri_params)
+    def type_to_class(uri)
+      klass = OTP.const_get(uri.host.upcase)
+      raise unless klass.is_a?(Class)
+      raise unless klass.ancestors.include?(OTP::Base)
+      return klass
+    rescue
+      raise "unknown OTP type: #{uri.host}"
     end
   end
 end

data/lib/otp/utils.rb

@@ -4,6 +4,13 @@ module OTP
   module Utils
     private
 
+    def otp(algorithm, secret, moving_factor, digits)
+      message = pack_int64(moving_factor)
+      digest = hmac(algorithm, secret, message)
+      num = pickup(digest)
+      return truncate(num, digits)
+    end
+
     def pack_int64(i)
       return [i >> 32 & 0xffffffff, i & 0xffffffff].pack("NN")
     end
@@ -14,12 +21,18 @@ module OTP
       return mac.digest
     end
 
-    def truncate(hash)
-      offset = hash[-1].ord & 0xf
-      binary = hash[offset, 4]
+    def pickup(digest)
+      offset = digest[-1].ord & 0xf
+      binary = digest[offset, 4]
       return binary.unpack("N")[0] & 0x7fffffff
     end
 
+    def truncate(num, digits)
+      pw = (num % (10 ** digits)).to_s
+      pw.prepend("0") while pw.length < digits
+      return pw
+    end
+
     def compare(a, b)
       return a.to_i == b.to_i
     end

data/lib/otp/version.rb

@@ -1,3 +1,3 @@
 module OTP
-  VERSION = "0.0.9"
+  VERSION = "0.0.10"
 end

data/test/test_base.rb

@@ -1,25 +1,60 @@
 require_relative "helper"
 
 class TestBase < Test::Unit::TestCase
-  def test_base
+  def test_new_secret
     otp = OTP::Base.new
+
     otp.new_secret(20)
+    assert_equal(20, otp.raw_secret.length)
     assert_equal(32, otp.secret.length)
+
     otp.new_secret(40)
+    assert_equal(40, otp.raw_secret.length)
     assert_equal(64, otp.secret.length)
   end
 
-  def test_methods_expected_to_be_override
+  def test_secret
+    otp = OTP::Base.new
+
+    otp.secret = nil
+    assert_nil(otp.secret)
+    assert_nil(otp.raw_secret)
+
+    otp.secret = ""
+    assert_equal("", otp.secret)
+    assert_equal("", otp.raw_secret)
+
+    otp.secret = "MZXW6YTBOI======"
+    assert_equal("MZXW6YTBOI======", otp.secret)
+    assert_equal("foobar", otp.raw_secret)
+
+    otp.secret = "MZXW6YTBOI"
+    assert_equal("MZXW6YTBOI", otp.secret)
+    assert_equal("foobar", otp.raw_secret)
+  end
+
+  def test_raw_secret
+    otp = OTP::Base.new
+
+    otp.raw_secret = nil
+    assert_nil(otp.secret)
+    assert_nil(otp.raw_secret)
+
+    otp.raw_secret = ""
+    assert_equal("", otp.secret)
+    assert_equal("", otp.raw_secret)
+
+    otp.raw_secret = "foobarbaz"
+    assert_equal("MZXW6YTBOJRGC6Q=", otp.secret)
+    assert_equal("foobarbaz", otp.raw_secret)
+  end
+
+  def test_moving_factor
     base = OTP::Base.new
+    hotp = OTP::HOTP.new
     totp = OTP::TOTP.new
-
-    [
-      [:moving_factor, ],
-      [:type_specific_uri_params, ],
-      [:extract_type_specific_uri_params, {}],
-    ].each do |m, *args|
-      assert_raise(NotImplementedError){ base.send(m, *args) }
-      assert_nothing_raised{ totp.send(m, *args) }
-    end
+    assert_raise(NotImplementedError){ base.moving_factor }
+    assert_nothing_raised{ hotp.moving_factor }
+    assert_nothing_raised{ totp.moving_factor }
   end
 end

data/test/test_uri.rb

@@ -7,17 +7,45 @@ class TestURI < Test::Unit::TestCase
     assert_equal("account@example.com", otp.accountname)
     assert_equal(nil, otp.issuer)
 
+    uri = "otpauth://totp/account@example.com?secret=GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ&issuer=Foo"
+    otp = OTP::URI.parse(uri)
+    assert_equal("account@example.com", otp.accountname)
+    assert_equal("Foo", otp.issuer)
+
     uri = "otpauth://totp/My%20Company:%20%20account@example.com?secret=GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ"
     otp = OTP::URI.parse(uri)
     assert_equal("account@example.com", otp.accountname)
     assert_equal("My Company", otp.issuer)
 
-    uri = "otpauth://totp/My%20Company:%20%20account@example.com?secret=GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ"
+    uri = "otpauth://totp/My%20Company:%20%20account@example.com?secret=GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ&issuer=Foo"
     otp = OTP::URI.parse(uri)
     assert_equal("account@example.com", otp.accountname)
     assert_equal("My Company", otp.issuer)
   end
 
+  def test_totp_simple
+    secret = OTP::Base32.encode("12345678901234567890")
+    totp = OTP::TOTP.new
+    totp.secret = secret
+    totp.accountname = "account@example.com"
+    uri = totp.to_uri
+    assert_not_match(/algorithm=/, uri)
+    assert_not_match(/digits=/, uri)
+    assert_not_match(/issuer=/, uri)
+    assert_not_match(/period=/, uri)
+
+    otp = OTP::URI.parse(uri)
+    assert_equal(OTP::TOTP, otp.class)
+    assert_equal(secret, otp.secret)
+    assert_equal("SHA1", otp.algorithm)
+    assert_equal(6, otp.digits)
+    assert_equal(30, otp.period)
+    assert_equal("account@example.com", otp.accountname)
+    assert_equal(nil, otp.issuer)
+    totp.time = otp.time = Time.now
+    assert_equal(otp.password, totp.password)
+  end
+
   def test_totp
     secret = OTP::Base32.encode("12345678901234567890")
     totp = OTP::TOTP.new
@@ -41,6 +69,28 @@ class TestURI < Test::Unit::TestCase
     assert_equal(otp.password, totp.password)
   end
 
+  def test_hotp_simple
+    secret = OTP::Base32.encode("12345678901234567890")
+    hotp = OTP::HOTP.new
+    hotp.secret = secret
+    hotp.accountname = "account@example.com"
+    uri = hotp.to_uri
+    assert_not_match(/algorithm=/, uri)
+    assert_not_match(/digits=/, uri)
+    assert_not_match(/issuer=/, uri)
+    assert_match(/count=0/, uri)
+
+    otp = OTP::URI.parse(uri)
+    assert_equal(OTP::HOTP, otp.class)
+    assert_equal(secret, otp.secret)
+    assert_equal("SHA1", otp.algorithm)
+    assert_equal(6, otp.digits)
+    assert_equal(0, otp.count)
+    assert_equal("account@example.com", otp.accountname)
+    assert_equal(nil, otp.issuer)
+    assert_equal(otp.password, hotp.password)
+  end
+
   def test_hotp
     secret = OTP::Base32.encode("12345678901234567890")
     hotp = OTP::HOTP.new
@@ -64,7 +114,13 @@ class TestURI < Test::Unit::TestCase
   end
 
   def test_parse_invalid
-    assert_raise(RuntimeError){ OTP::URI.parse("http://www.netlab.jp") }
-    assert_raise(RuntimeError){ OTP::URI.parse("otpauth://foo") }
+    e = assert_raise(RuntimeError){ OTP::URI.parse("http://www.netlab.jp") }
+    assert_match(/URI scheme not match/, e.message)
+    e = assert_raise(RuntimeError){ OTP::URI.parse("otpauth://foo") }
+    assert_match(/unknown OTP type/, e.message)
+    e = assert_raise(RuntimeError){ OTP::URI.parse("otpauth://version") }
+    assert_match(/unknown OTP type/, e.message)
+    e = assert_raise(RuntimeError){ OTP::URI.parse("otpauth://totp/") }
+    assert_match(/account name must be present/, e.message)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: otp
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
 platform: ruby
 authors:
 - Yuuzou Gotou
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-08 00:00:00.000000000 Z
+date: 2015-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler