ruby_olm 0.1.1

data/lib/ruby_olm/account.rb

@@ -0,0 +1,42 @@
+module RubyOlm
+
+  class Account
+
+    # @param pickle [String] pickled state
+    # @param password [String] password used to encrypt pickled state
+    # @return [Account]
+    def self.from_pickle(pickle, password="")
+      Account.new(pickle: pickle, password: password)
+    end
+    
+    # @param [type] defaults to 'curve25519' 
+    # @return [String]
+    def ik(type='curve25519')
+      raise RangeError unless identity_keys[type]
+      identity_keys[type]
+    end
+    
+    # @param [type] defaults to 'curve25519'
+    # @param [value] return only the key values and not the ids 
+    #
+    # @return [Array<Hash>] if !values
+    # @return [Array<String>] if values
+    def otk(values=true, type='curve25519')
+      if values
+        one_time_keys[type].values
+      else
+        one_time_keys[type]
+      end
+    end
+    
+    def gen_otk(number=1)
+      generate_one_time_keys(number)
+    end
+    
+    alias_method :mark_otk, :mark_keys_as_published
+    alias_method :max_otk, :max_number_of_one_time_keys
+    alias_method :update_otk, :remove_one_time_keys
+    
+  end
+
+end

data/lib/ruby_olm/message.rb

@@ -0,0 +1,6 @@
+module RubyOlm
+
+  class Message < OlmMessage
+  end
+  
+end

data/lib/ruby_olm/olm_error.rb

@@ -0,0 +1,70 @@
+module RubyOlm
+
+  module OlmError
+
+    class SUCCESS < StandardError
+    end
+  
+    class NOT_ENOUGH_RANDOM < StandardError
+    end
+    
+    class OUTPUT_BUFFER_TOO_SMALL < StandardError
+    end
+    
+    class BAD_MESSAGE_VERSION < StandardError
+    end
+    
+    class BAD_MESSAGE_FORMAT < StandardError
+    end
+    
+    class BAD_MESSAGE_MAC < StandardError
+    end
+    
+    class BAD_MESSAGE_KEY_ID < StandardError
+    end
+    
+    class INVALID_BASE64 < StandardError
+    end
+    
+    class BAD_ACCOUNT_KEY < StandardError
+    end
+    
+    class UNKNOWN_PICKLE_VERSION < StandardError
+    end
+    
+    class CORRUPTED_PICKLE < StandardError
+    end
+    
+    class BAD_SESSION_KEY < StandardError
+    end
+    
+    class UNKNOWN_MESSAGE_INDEX < StandardError
+    end
+    
+    class BAD_LEGACY_ACCOUNT_PICKLE < StandardError
+    end
+    
+    class BAD_SIGNATURE < StandardError
+    end
+    
+    class OLM_INPUT_BUFFER_TOO_SMALL < StandardError
+    end
+    
+    class UnknownError < StandardError
+    end
+
+    def self.from_string(str)
+      begin
+        OlmError.const_get(str)
+      rescue NameError
+        UnknownError.new str
+      end
+    end
+
+    def self.raise_from_string(str)
+      raise from_string(str)
+    end
+  
+  end
+  
+end

data/lib/ruby_olm/olm_message.rb

@@ -0,0 +1,25 @@
+require 'base64'
+
+module RubyOlm
+
+  class OlmMessage
+
+    # @param msg [String] base64 or bytes
+    def initialize(msg)
+      raise "abstract class" if self.class == OlmMessage
+      @value = msg
+    end
+    
+    # @return [String] bytes
+    def to_bytes
+      Base64.decode64(value)
+    end
+    
+    # @return [String] base64
+    def to_s
+      @value.dup
+    end
+
+  end
+  
+end

data/lib/ruby_olm/pre_key_message.rb

@@ -0,0 +1,6 @@
+module RubyOlm
+
+  class PreKeyMessage < OlmMessage
+  end
+  
+end

data/lib/ruby_olm/session.rb

@@ -0,0 +1,16 @@
+module RubyOlm
+
+  class Session
+  
+    # @param pickle [String] pickled state
+    # @param password [String] password used to encrypt pickled state
+    # @return [Session]
+    def self.from_pickle(pickle, password="")
+      Session.new(pickle, password)
+    end
+
+    alias_method :has_received?, :has_received_message
+    
+  end
+
+end

data/lib/ruby_olm/version.rb

@@ -0,0 +1,5 @@
+module RubyOlm
+  
+  VERSION="0.1.1"
+  
+end

data/lib/ruby_olm.rb

@@ -0,0 +1,10 @@
+require 'ruby_olm/version'
+require 'ruby_olm/ext_lib_olm'
+require 'ruby_olm/account'
+require 'ruby_olm/session'
+require 'ruby_olm/olm_message'
+require 'ruby_olm/message'
+require 'ruby_olm/pre_key_message'
+
+module RubyOlm
+end

data/rakefile

@@ -0,0 +1,18 @@
+require 'rake/testtask'
+require 'rake/extensiontask'
+
+Rake::ExtensionTask.new  do |ext|
+  ext.name = "ext_lib_olm"
+  ext.ext_dir = "ext/ruby_olm/ext_lib_olm"
+  ext.lib_dir = "lib/ruby_olm"
+end
+
+task :test => :compile
+
+Rake::TestTask.new do |t|
+  t.name = :test
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]    
+end
+
+task :default => :test

data/test/examples/test_bob_no_answer.rb

@@ -0,0 +1,62 @@
+require 'minitest/autorun'
+require 'ruby_olm'
+
+class TestExchange < Minitest::Test
+
+  include RubyOlm
+  
+  # Alice -> Bob
+  # Alice -> Bob
+  #
+  def test_bob_no_answer
+    
+    alice = Account.new
+    bob = Account.new
+
+    # Alice wants to send a message to Bob
+    alice_msg = "hi bob"
+
+    # Bob generates a one-time-key
+    bob.gen_otk
+
+    # Alice must have Bob's identity and one-time-key to make a session
+    alice_session = alice.outbound_session(bob.ik, bob.otk.first)
+
+    # Bob marks all one-time-keys as published
+    bob.mark_otk
+
+    # Alice can encrypt
+    encrypted = alice_session.encrypt(alice_msg)
+    assert_instance_of PreKeyMessage, encrypted
+    
+    # Bob can create a session from this first message
+    bob_session = bob.inbound_session(encrypted)
+
+    # Bob can now update his list of marked otk (since he knows one has been used)
+    bob.update_otk(bob_session)
+
+    # Bob can decrypt Alice's message
+    bob_msg = bob_session.decrypt(encrypted)
+
+    assert_equal alice_msg, bob_msg
+    
+    # At this point Bob has received but Alice hasn't
+    assert bob_session.has_received?
+    refute alice_session.has_received?
+
+    ###
+
+    # Alice sends another message before reply from Bob
+    alice_msg = "BOB!"
+    
+    encrypted = alice_session.encrypt(alice_msg)
+    assert_instance_of PreKeyMessage, encrypted
+
+    # Bob needs to check if this is the same session or a new one
+    same_session = bob_session.will_receive? encrypted
+    
+    assert same_session
+
+  end
+  
+end

data/test/examples/test_exchange.rb

@@ -0,0 +1,60 @@
+require 'minitest/autorun'
+require 'ruby_olm'
+
+class TestExchange < Minitest::Test
+
+  include RubyOlm
+  
+  # Alice -> Bob
+  # Alice <- Bob
+  def test_exchange
+
+    alice = Account.new
+    bob = Account.new
+
+    # Alice wants to send a message to Bob
+    alice_msg = "hi bob"
+
+    # Bob generates a one-time-key
+    bob.gen_otk
+
+    # Alice must have Bob's identity and one-time-key to make a session
+    alice_session = alice.outbound_session(bob.ik, bob.otk.first)
+
+    # Bob marks all one-time-keys as published
+    bob.mark_otk
+
+    # Alice can encrypt
+    encrypted = alice_session.encrypt(alice_msg)
+    assert_instance_of PreKeyMessage, encrypted
+    
+    # Bob can create a session from this first message
+    bob_session = bob.inbound_session(encrypted)
+
+    # Bob can now update his list of marked otk (since he knows one has been used)
+    bob.update_otk(bob_session)
+
+    # Bob can decrypt Alice's message
+    bob_msg = bob_session.decrypt(encrypted)
+
+    assert_equal alice_msg, bob_msg
+    
+    # At this point Bob has received but Alice hasn't
+    assert bob_session.has_received?
+    refute alice_session.has_received?
+    
+    ####
+    
+    # Bob can send messages back to Alice    
+    bob_msg = "hi alice"
+    
+    encrypted = bob_session.encrypt(bob_msg)
+    assert_instance_of Message, encrypted
+    
+    alice_msg = alice_session.decrypt(encrypted)
+    
+    assert_equal alice_msg, bob_msg 
+    
+  end
+
+end

data/test/spec/test_account.rb

@@ -0,0 +1,152 @@
+require 'minitest/autorun'
+require 'ruby_olm'
+
+describe "Account" do
+
+  let(:account){ RubyOlm::Account.new }
+
+  # returns curve2599 identity key
+  #
+  describe "#ik" do
+    
+    let(:rv){ account.ik }
+  
+    it("returns a String"){ rv.must_be_instance_of String }
+
+  end
+
+  describe "#identity_keys" do
+  
+    let(:rv){ account.identity_keys }
+  
+    it("returns a Hash"){ rv.must_be_instance_of Hash }
+  
+  end
+  
+  # returns the maximum number of one-time-keys able to be 
+  # cached by account
+  #
+  describe "#max_otk" do
+    
+    let(:rv){ account.max_otk }
+    
+    it("returns an unsigned integer") do
+      rv.must_be_kind_of Integer
+      rv.must_be :'>=', 0
+    end
+    
+  end
+  
+  # generates zero or more one-time-keys which will then be cached
+  # by account until such time they are:
+  #
+  # - overwritten by future calls to #generate_otk
+  # - removed by session establishment
+  #     
+  describe "#gen_otk" do
+  
+    it("returns self"){ account.gen_otk.must_equal account }
+  
+  end
+  
+  # marks one-time-keys as published
+  #
+  describe "#mark_otk" do
+  
+    it("returns self"){ account.mark_otk.must_equal account }
+  
+  end
+  
+  # returns cached one-time-keys which have not yet been marked as published
+  #
+  describe "#otk" do
+  
+    let(:rv){ account.otk }
+  
+    it("returns an Array"){ rv.must_be_kind_of Array }
+    
+    describe "return value" do
+    
+      describe "before #gen_otk" do
+      
+        describe "before #mark_otk" do
+        
+          it("is empty"){ rv.size.must_equal 0 }
+        
+        end
+        
+        describe "after #mark_otk" do
+        
+          before{ account.mark_otk }
+        
+          it("is empty"){ rv.size.must_equal 0 }
+        
+        end
+        
+      end
+    
+      describe "after #gen_otk" do
+      
+        let(:max){ account.max_otk }
+        let(:n){ rand(0..max) }
+      
+        before{ account.gen_otk(n) }
+     
+        describe "before #mark_otk" do
+        
+          it("has n keys"){ rv.size.must_equal n }
+        
+        end
+        
+        describe "after #mark_otk" do
+        
+          before{ account.mark_otk }
+        
+          it("is empty"){ rv.size.must_equal 0 }
+        
+        end
+     
+      end
+        
+    end
+  
+  end
+  
+  # creates inbound and outbound sessions
+  #
+  describe "session factory" do
+  
+    let(:remote){ RubyOlm::Account.new }
+  
+    before do
+      remote.gen_otk
+      account.gen_otk
+    end
+    
+    describe "#outbound_session" do
+    
+      it("creates session") { account.outbound_session(remote.ik, remote.otk.first).must_be_kind_of RubyOlm::Session }
+      
+    end
+    
+    describe "#inbound_session" do
+      
+      let(:remote_session){ remote.outbound_session(account.ik, account.otk.first) }
+      let(:remote_message){ remote_session.encrypt("hello") }
+      
+      it("creates session") { account.inbound_session(remote_message).must_be_kind_of RubyOlm::Session }
+      
+    end
+    
+    describe "#inbound_session from known remote" do
+      
+      let(:remote_session){ remote.outbound_session(account.ik, account.otk.first) }
+      let(:remote_message){ remote_session.encrypt("hello") }
+      
+      it("creates session") { account.inbound_session(remote_message, remote.ik).must_be_kind_of RubyOlm::Session }
+      
+    end
+    
+  end
+  
+end

data/test/unit/test_account_methods.rb

@@ -0,0 +1,85 @@
+require 'minitest/autorun'
+require 'ruby_olm'
+
+class TestAccount < Minitest::Test
+
+  include RubyOlm
+  
+  def setup
+    @state = Account.new
+  end
+  
+  def test_identity_keys
+    assert_instance_of Hash, @state.identity_keys
+  end
+  
+  def test_ik_default
+    assert_equal @state.identity_keys['curve25519'], @state.ik
+  end
+  
+  def test_one_time_keys
+    assert_instance_of Hash, @state.one_time_keys
+  end
+  
+  def test_otk_default
+    assert_instance_of Array, @state.otk
+    assert_equal @state.one_time_keys['curve25519'].values, @state.otk
+  end
+  
+  def test_generate_one_time_keys
+    assert_equal @state, @state.generate_one_time_keys(rand(1..10))
+  end
+  
+  def test_gen_otk
+    test_generate_one_time_keys
+  end 
+  
+  def test_last_error
+    assert_equal OlmError::SUCCESS, @state.last_error
+  end
+  
+  def test_sign
+    assert_instance_of String, @state.sign("hello")
+  end
+  
+  def test_mark_keys_as_published
+    assert_equal @state, @state.mark_keys_as_published
+  end
+  
+  def test_mark_otk
+    test_mark_keys_as_published
+  end
+  
+  def test_max_number_of_one_time_keys
+    assert_kind_of Integer, @state.max_number_of_one_time_keys
+  end
+  
+  def test_max_otk
+    test_max_number_of_one_time_keys
+  end
+  
+  def test_to_pickle
+    assert_kind_of String, @state.to_pickle
+  end
+  
+  def test_from_pickle
+    Account.from_pickle(@state.to_pickle)
+  end
+  
+  def test_from_pickle_with_key
+    Account.from_pickle(@state.to_pickle("hey"), "hey")
+  end
+  
+  def test_from_pickle_invalid
+    assert_raises OlmError::BAD_ACCOUNT_KEY do
+      Account.from_pickle("")
+    end
+  end
+  
+  def test_from_pickle_bad_key
+    assert_raises OlmError::BAD_ACCOUNT_KEY do
+      Account.from_pickle(@state.to_pickle, "hey")
+    end
+  end
+  
+end