YubiRuby 0.1.0 → 1.0.0

data/lib/hex.rb

@@ -47,7 +47,16 @@ module YubiRuby
     #
     def self.encode( obj )
       s = obj.to_str
-      s.unpack('U'*s.length).collect {|x| x.to_s 16}.join
+      s.unpack('U'*s.length).collect {|x| tmp = x.to_s 16; tmp.length == 1 ? "0#{tmp}" : tmp }.join
+    rescue ArgumentError
+      #non UTF-8 string
+      s = obj.to_str
+      out = []
+      0.upto(s.length-1) do |i|
+        tmp = s[i].to_s 16
+        out << (tmp.length == 1 ? "0#{tmp}" : tmp )
+      end
+      out.join
     end
     
     # call-seq:
@@ -59,17 +68,19 @@ module YubiRuby
     end
     
     # call-seq:
-    #   YubiRuby::HEX.decode("hex string") -> "string" or ""
+    #   YubiRuby::HEX.decode("hex string") -> "string" 
     #
     # Decodes <tt>obj.to_str</tt> into a <tt>string</tt>.
     #
-    # An <tt>hex string</tt> length must be pair, if not an 
-    # empty string is returned.
+    # An <tt>hex string</tt> length must be pair, if not a 
+    # NoHexEncodedError excpetion is raised
     def self.decode( obj )
       s = obj.to_str
       dec = ""
-      if (s.length % 2 == 0)
+      if hex?(s)
         (s.length/2).times { |i| dec << s[i*2,2].hex.chr }
+      else
+        raise NoHexEncodedError.new
       end
       
       return dec
@@ -82,5 +93,25 @@ module YubiRuby
     def hex_decode
       HEX.decode(self)
     end
+    
+    # call-seq:
+    #   YubiRuby::HEX.hex?("hex string") -> true or false
+    #
+    # Tests if <tt>obj.to_str</tt> is a valid a <tt>hex string</tt>.
+    #
+    # An <tt>hex string</tt> length must be pair.
+    def self.hex?( obj )
+      s = obj.to_str
+      return false unless (s.length % 2 == 0)
+      return (s.upcase =~ /[^A-F0-9]/).nil?
+    end
+    
+    # call-seq:
+    #   hex? -> true or false
+    #
+    # Invokes YubiRuby::HEX.hex? on +self+.
+    def hex?
+      HEX.hex?(self)
+    end
   end
 end

data/lib/yubiruby.rb

@@ -27,8 +27,10 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+require 'exceptions'
 require 'libyubikey'
 require 'hex'
+require 'fake_yubikey'
 
 module YubiRuby
   # C code version 

data/tasks/yard_doc.rake

@@ -0,0 +1,50 @@
+# =======================
+# = Documentation tasks =
+# =======================
+begin
+  require 'yard'
+  require 'yard/rake/yardoc_task'
+  
+  task :documentation => :'documentation:generate'
+  namespace :documentation do
+    YARD::Rake::YardocTask.new :generate do |t|
+      t.files   = ['lib/**/*.rb', 'ext/**/*.c']
+      t.options = ['--output-dir', File.join('meta', 'documentation'),
+                   '--readme', 'README']
+    end
+    
+    YARD::Rake::YardocTask.new :dotyardoc do |t|
+      t.files   = ['lib/**/*.rb', 'ext/**/*.c']
+      t.options = ['--no-output',
+                   '--readme', 'README']
+    end
+    
+    class Numeric
+      def pretty_inspect(decimal_points = 3)
+        bits = self.to_s.split('.')
+        bits[0] = bits[0].reverse.scan(/\d{1,3}/).join(',').reverse
+        bits[1] = bits[1][0...decimal_points] if bits[1]
+        bits.join('.')
+      end
+    end
+    
+    task :verify do
+      documentation_threshold = 50.0
+      doc = YARD::CLI::Yardoc.new; doc.generate = false; doc.run
+      
+      percent_documented = (
+        YARD::Registry.all.select {|o| !o.docstring.empty? }.size /
+        YARD::Registry.all.size.to_f
+      ) * 100
+      puts "Documentation coverage: #{percent_documented.pretty_inspect(1)}% (threshold: #{documentation_threshold.pretty_inspect(1)}%)"
+    end
+    
+    task :open do
+      system 'open ' + File.join('meta', 'documentation', 'index.html') if PLATFORM['darwin']
+    end
+  end
+  
+rescue LoadError
+  desc 'You need the `yard` gem to generate documentation'
+  task :documentation
+end

data/test/fake_yubikey_spec.rb

@@ -0,0 +1,155 @@
+require 'test/path_loader'
+
+describe 'YubiRuby::FakeYubikey' do
+  @@UID = 'ffa4f1fa55e0'
+  @@KEY = '884b1fc18da3888b59460f6e33acabf5'
+  
+  before :all do
+    @key = YubiRuby::FakeYubikey.new
+  end
+  
+  it "should start in a valid state" do
+    @key.uid.should == "000000000000"
+    @key.session_use.should == 0
+    @key.session_counter.should == 1
+    @key.public_id.should == ""
+  end
+  
+  it "should be serializable" do
+    @key.public_id = 'hehkhbhv'
+    @key.key = @@KEY
+    @key.uid = @@UID
+    3.times { @key.init }
+    File.open('key.dump', 'w+') do |f|  
+      Marshal.dump(@key, f)  
+    end
+    
+    key2 = nil
+    File.open('key.dump') do |f|  
+      key2 = Marshal.load(f)  
+    end
+    
+    key2.public_id.should == @key.public_id
+    key2.uid.should == @key.uid
+    key2.data.session_counter.should == @key.session_counter+1
+    key2.key.should == @key.key
+  end
+  
+  describe "#set_random_uid" do
+    it "should generate a hex valid string" do
+      @key.set_random_uid
+      @key.uid.hex?.should == true
+    end
+  end
+  
+  describe "#set_random_key" do
+    it "should generate a hex valid string" do
+      @key.set_random_key
+      @key.key.hex?.should == true
+    end
+  end
+  
+  describe '#otp' do
+    it "should generate valid otp" do
+      aes = @key.set_random_key
+      @key.set_random_uid
+      
+      validator = YubiRuby::Yubikey.new aes
+      validator.parse(@key.otp).should == true
+      validator.uid.should == @key.uid
+      validator.session_use.should == @key.session_use
+      validator.session_counter.should == @key.session_counter
+    end
+    
+    it "should produce a session overflow after 2**8 generations" do
+      @key = YubiRuby::FakeYubikey.new
+      aes = @key.set_random_key
+      uid = @key.set_random_uid
+      session = @key.session_counter
+      1.upto(2**8-1) do |i|
+        @key.otp 
+        @key.session_counter.should == session
+        @key.session_use.should == i
+      end
+      @key.otp
+      @key.session_counter.should == session+1
+      @key.session_use.should == 0
+    end
+    
+    it "should raise YubiRuby::YubikeySessionCounterOverflow after SESSION_COUNTER_OVERFLOW initialization" do
+      key = YubiRuby::FakeYubikey.new
+      aes = key.set_random_key
+      uid = key.set_random_uid
+      (session = key.session_counter).should == 1
+      2.upto(YubiRuby::FakeYubikey::Data::SESSION_COUNTER_OVERFLOW) do |i|
+        lambda { key.init }.should_not raise_error(YubiRuby::YubikeySessionCounterOverflow)
+      end
+      lambda { key.init }.should raise_error(YubiRuby::YubikeySessionCounterOverflow)
+    end
+    
+    it "should starts with public_id" do
+      @key = YubiRuby::FakeYubikey.new 
+      @key.key = @@KEY
+      @key.uid = @@UID
+      @key.public_id = 'hehkhbhv'
+      @key.otp[0,8].should == 'hehkhbhv'
+    end
+  end
+  
+  describe '#generate_specific_otp_and_fake_yubikey' do
+    it "should work ;)" do
+      aes = 'df5b9d7591b0b3c2819f7a0dd7d1547d'
+      session = 53
+      tsl = 31716
+      tsh = 106
+      counter = 0
+      random = 30172
+      crc = 58822
+      uid = "6d8dec078841"
+      check_otp = 'rfechkcdkjrflgrjlirdgivnedbbtcik'
+      result = YubiRuby::FakeYubikey.generate_specific_otp_and_fake_yubikey(
+        aes, uid, session, tsl, tsh, counter, random)
+      mycrc = YubiRuby::CRC16.calculate(result[1].to_s[0...-2]).ones_complement 16
+
+      lambda {
+        YubiRuby::Yubikey.new(aes).parse(result[0]).should == true
+      }.should_not raise_error(TypeError)
+      result[1].key.should == aes
+      result[1].session_counter.should == session
+      result[1].timestamp_low.should == tsl
+      result[1].timestamp_high.should == tsh
+      result[1].session_use.should == counter
+      result[1].random.should == random
+      result[1].crc.should == crc
+      result[1].uid.should == uid
+      result[0].should == check_otp
+    end
+  end
+  
+  describe "#public_id=" do
+    it "should accepts modhex strings" do
+      id = 'rfechkcdkjrflgrjlirdgivnedbbtcik'
+      @key.public_id = id
+      @key.public_id.should == id
+      id = 'hehkhbhv'
+      @key.public_id = id
+      @key.public_id.should == id
+    end
+    
+    it "should accepts only modhex strings" do
+      id = @key.public_id
+      lambda {@key.public_id = "pluto"}.should raise_error(YubiRuby::NoModHexEncodedError)
+      @key.public_id.should == id
+      lambda{@key.public_id = "pip!8"}.should raise_error(YubiRuby::NoModHexEncodedError)
+      @key.public_id.should == id
+    end
+    
+    it "should truncate longer string" do
+      id = 'rfechkcdkjrflgrjlirdgivnedbbtcikrfechkcdkjrflgrjlirdgivnedbbtcik'
+      (id.length > 32).should == true
+      
+      @key.public_id = id
+      @key.public_id.should == id[0,32]
+    end
+  end
+end

data/test/hex_spec.rb

@@ -0,0 +1,52 @@
+require 'test/path_loader'
+
+describe 'YubiRuby::HEX' do
+  describe '#encode' do
+    it 'should work as expected' do
+      str = "ciao\n"
+      hex = "6369616f0a"
+      YubiRuby::HEX.encode(str).should == hex
+    end
+    
+    it 'should be a reversible operation' do
+      str = "ciao\n"
+      hex = YubiRuby::HEX.encode(str)
+      YubiRuby::HEX.decode(hex).should == str
+    end
+  end
+  
+  describe '#decode' do
+    it 'should work as expected' do
+      str = "ciao\n"
+      hex = "6369616f0a"
+      YubiRuby::HEX.decode(hex).should == str
+    end
+    
+    it 'should be a reversible operation' do
+      hex = "6369616f0a"
+      str = YubiRuby::HEX.decode(hex)
+      YubiRuby::HEX.encode(str).should == hex
+    end
+    
+    it 'should raise NoHexEncodedError if decoding non Hex string' do
+      lambda { YubiRuby::HEX.decode('a')  }.should raise_error(YubiRuby::NoHexEncodedError)
+      lambda {YubiRuby::HEX.decode('zebr') }.should raise_error(YubiRuby::NoHexEncodedError)
+      lambda {YubiRuby::HEX.decode('!af5') }.should raise_error(YubiRuby::NoHexEncodedError)
+      lambda {YubiRuby::HEX.decode('0x12ff') }.should raise_error(YubiRuby::NoHexEncodedError)
+    end
+  end
+  
+  describe '#hex?' do
+    it 'should recognize valid hex' do
+      YubiRuby::HEX.hex?('7af5').should == true
+      YubiRuby::HEX.hex?('12fF').should == true
+    end
+    
+    it 'should recognize invalid hex' do
+      YubiRuby::HEX.hex?('a').should == false
+      YubiRuby::HEX.hex?('zebr').should == false
+      YubiRuby::HEX.hex?('!af5').should == false
+      YubiRuby::HEX.hex?('0x12ff').should == false
+    end
+  end
+end

data/test/modhex_spec.rb

@@ -0,0 +1,81 @@
+require 'test/path_loader'
+
+describe 'YubiRuby::ModHex' do
+  
+  it 'should be a reversible operation' do
+    str = "test"
+    hex = "ifhgieif"
+    YubiRuby::ModHex.decode(YubiRuby::ModHex.encode(str)).should == str
+    YubiRuby::ModHex.encode(YubiRuby::ModHex.decode(hex)).should == hex
+  end
+  
+  describe '#encode' do
+    it 'should work as expected' do
+      str = "test"
+      hex = "ifhgieif"
+      YubiRuby::ModHex.encode(str).should == hex
+    end
+    
+    it "should double the string lenght" do
+      str = '1234zz567890'
+      str.size.should == 12
+      str.modhex_encode.size.should == 24
+    end
+
+  end
+  
+  describe '#decode' do
+    it 'should work as expected' do
+      str = "test"
+      hex = "ifhgieif"
+      YubiRuby::ModHex.decode(hex).should == str
+    end
+    
+    it 'should raise NoModHexEncodedError if decoding non ModHex string' do
+      lambda { YubiRuby::ModHex.decode('a')  }.should raise_error(YubiRuby::NoModHexEncodedError)
+      lambda {YubiRuby::ModHex.decode('zebr') }.should raise_error(YubiRuby::NoModHexEncodedError)
+      lambda {YubiRuby::ModHex.decode('!af5') }.should raise_error(YubiRuby::NoModHexEncodedError)
+      lambda {YubiRuby::ModHex.decode('0x12ff') }.should raise_error(YubiRuby::NoModHexEncodedError)
+    end
+    
+    it "should halves the string lenght" do
+      otp = 'dbkutdgrnlvrhdiregebvkkrgtuefjru'
+      otp.size.should == 32
+      otp.modhex_decode.size.should == 16
+    end
+  end
+  
+  describe '#hex?' do
+    it 'should recognize valid hex' do
+      YubiRuby::ModHex.modhex?('ifhgieif').should == true
+      YubiRuby::ModHex.modhex?('ichkicichv').should == true
+    end
+    
+    it 'should recognize invalid hex' do
+      YubiRuby::ModHex.modhex?('a').should == false
+      YubiRuby::ModHex.modhex?('zebr').should == false
+      YubiRuby::ModHex.modhex?('!af5').should == false
+      YubiRuby::ModHex.modhex?('0x12ff').should == false
+    end
+  end
+end
+
+describe 'String' do
+  describe '#modhex_decode' do
+    it "should call YubiRuby::ModHex#decode once" do
+      otp = 'dbkutdgrnlvrhdiregebvkkrgtuefjru'
+      YubiRuby::ModHex.should_receive(:decode).once.with(otp)
+      YubiRuby::ModHex.should_not_receive(:encode)
+      otp.modhex_decode
+    end
+  end
+  
+  describe '#modhex_encode' do
+    it "should call YubiRuby::ModHex#encode once" do
+      str = 'ciaociao ciao'
+      YubiRuby::ModHex.should_receive(:encode).once.with(str)
+      YubiRuby::ModHex.should_not_receive(:decode)
+      str.modhex_encode
+    end
+  end
+end

data/{tests/ts_yubiruby.rb → test/path_loader.rb}

@@ -1,6 +1,6 @@
 $:.unshift File.join(File.dirname(__FILE__),'..','lib')
 $:.unshift File.join(File.dirname(__FILE__),'..','ext')
 
-require "test/unit"
+require 'yubiruby'
 
-require "tc_modhex"
+String.send(:include, YubiRuby::HEX)

data/test/tc_crc16.rb

@@ -0,0 +1,10 @@
+class TestCRC16 < Test::Unit::TestCase
+  def test_crc_calculate
+    str = YubiRuby::HEX.decode '6d8dec07884101002216a1041b7c'
+    otp_decoded = YubiRuby::HEX.decode '6d8dec07884101002216a1041b7c105e'
+    crc = 24080
+    assert_equal(0xF0B8, YubiRuby::CRC16.calculate(otp_decoded))
+    assert_equal(crc, YubiRuby::CRC16.calculate(str).ones_complement(16))
+  end
+  
+end

data/test/tc_fake_yubikey.rb

@@ -0,0 +1,89 @@
+class TestFakeYubikey < Test::Unit::TestCase
+  def test_init
+    key = YubiRuby::FakeYubikey.new
+    assert_equal("000000000000", key.uid )
+    assert_equal(0, key.session_use)
+    assert_equal(1, key.session_counter)
+  end
+  
+  def test_otp
+    key = YubiRuby::FakeYubikey.new
+    aes = key.set_random_key
+    uid = key.set_random_uid
+    assert(aes.hex?)
+    assert(uid.hex?)
+    validator = YubiRuby::Yubikey.new aes
+    assert(validator.parse(key.otp))
+    assert_equal(validator.uid, uid)
+    assert_equal(validator.session_use, key.session_use)
+    assert_equal(validator.session_counter, key.session_counter)
+  end
+  
+  def test_generate_random_uid
+    key = YubiRuby::FakeYubikey.new
+    assert_equal(key.set_random_uid, key.uid)
+  end
+  
+  def test_generate_random_key
+    key = YubiRuby::FakeYubikey.new
+    assert_equal(key.set_random_key, key.key)
+  end
+    
+  def test_generate_specific_otp_and_fake_yubikey
+    aes = 'df5b9d7591b0b3c2819f7a0dd7d1547d'
+    session = 53
+    tsl = 31716
+    tsh = 106
+    counter = 0
+    random = 30172
+    crc = 58822
+    uid = "6d8dec078841"
+    check_otp = 'rfechkcdkjrflgrjlirdgivnedbbtcik'
+    result = YubiRuby::FakeYubikey.generate_specific_otp_and_fake_yubikey(aes, uid, session, 
+      tsl, tsh, counter, random)
+    mycrc = YubiRuby::CRC16.calculate(result[1].to_s[0...-2]).ones_complement 16
+    
+    
+    YubiRuby::Yubikey.new(aes).parse(result[0]) 
+    assert_equal(aes,result[1].key)
+    assert_equal(session,result[1].session_counter)
+    assert_equal(tsl,result[1].timestamp_low)
+    assert_equal(tsh,result[1].timestamp_high)
+    assert_equal(counter,result[1].session_use)
+    assert_equal(random,result[1].random)
+    assert_equal(crc,result[1].crc)
+    assert_equal(uid,result[1].uid)
+    assert_equal(check_otp,result[0])
+  end
+  
+  def test_session_use_overflow
+    key = YubiRuby::FakeYubikey.new
+    aes = key.set_random_key
+    uid = key.set_random_uid
+    session = key.session_counter
+    1.upto(2**8-1) do |i|
+      key.otp 
+      assert_equal(session, key.session_counter) 
+      assert_equal(i, key.session_use)
+    end
+    key.otp
+    assert_equal(session+1, key.session_counter)
+    assert_equal(0, key.session_use)
+  end
+ 
+#   ruby(71000) malloc: *** error for object 0x101aa6e70: 
+#     incorrect checksum for freed object - object was probably modified after being freed.  
+#  def test_session_counter_overflow
+#    key = YubiRuby::FakeYubikey.new
+#    aes = key.set_random_key
+#    uid = key.set_random_uid
+#    session = key.session_counter
+#    assert_equal(1, session)
+#    2.upto(YubiRuby::FakeYubikey::Data::SESSION_COUNTER_OVERFLOW) do |i|
+#      key.init 
+#    end
+#    assert_raise YubiRuby::YubikeySessionCounterOverflow do
+#      key.init
+#    end
+#  end
+end