tem_ruby 0.10.0 → 0.10.1

data/test/builders/test_abi_builder.rb

@@ -0,0 +1,298 @@
+require 'openssl'
+require 'test/unit'
+
+require 'tem_ruby'
+
+class AbiBuilderTest < Test::Unit::TestCase
+  class Wrapped
+    attr_accessor :p, :q, :n
+    attr_accessor :d  # Derived value.
+    attr_accessor :c  # Constructor value.
+    
+    def initialize(ctor_value = 'ctor default')
+      self.c = ctor_value
+    end
+  end
+  
+  class Multi
+    attr_accessor :p, :q, :n
+    attr_accessor :a, :b, :c
+    attr_accessor :str, :const
+  end
+  
+  module Abi
+    Tem::Builders::Abi.define_abi self do |abi|
+      abi.fixed_length_number :byte, 1, :signed => true
+      abi.fixed_length_number :ubyte, 1, :signed => false
+
+      abi.fixed_length_number :word, 2, :signed => true, :big_endian => false
+      abi.fixed_length_number :netword, 2, :signed => true, :big_endian => true
+                           
+      abi.fixed_length_number :dword, 4, :signed => true, :big_endian => true
+      abi.fixed_length_number :udword, 4, :signed => false, :big_endian => false
+      
+      abi.variable_length_number :vln, :word, :signed => false,
+                                 :big_endian => false
+      abi.variable_length_number :net_vln, :netword, :signed => false,
+                                 :big_endian => true
+      abi.packed_variable_length_numbers :packed, :word, [:p, :q, :n],
+                                         :signed => false,
+                                         :big_endian => false
+      abi.packed_variable_length_numbers :net_packed, :netword,
+                                         [:x, :y, :z, :a],
+                                         :signed => false,
+                                         :big_endian => true
+      abi.fixed_length_string :mac_id, 6
+      abi.object_wrapper :wrapped_raw, Wrapped, [:packed, nil]
+      abi.object_wrapper :wrapped, Wrapped, [:packed, nil],
+          :to => lambda { |o| w = Wrapped.new
+                              w.p, w.q, w.n = o.p, o.q, o.n * 100
+                              w },
+          :read => lambda { |o| w = Wrapped.new(o.c); w.d = o.p * o.q; w },
+          :new => lambda { |klass| klass.new('hook-new') }
+      abi.object_wrapper :multi, Multi,
+                         [:packed, nil,:packed, { :p => :a, :q => :b, :n => :c},
+                          :mac_id, :str, 'constant string', :const]
+    
+      abi.conditional_wrapper :conditional, 2,
+          [{:tag => [0x59, 0xAF], :class => String, :type => :mac_id},
+           {:tag => [0x59, 0xAC], :class => Integer, :type => :net_vln,
+            :predicate => lambda { |n| n % 2 == 1 } },
+           {:tag => [0x59, 0xAD], :type => :dword,
+            :predicate => lambda { |n| n % 3 == 1 } }]
+    end
+  end
+  
+  def setup
+    @garbage = [0xFD, 0xFC, 0xFD, 0xFC, 0xFD] * 5    
+  end
+  
+  def test_fixed_and_variable_length_number_encoding
+    [
+     [:byte, 0, [0]], [:byte, 127, [127]],
+     [:byte, -1, [255]], [:byte, -127, [129]], [:byte, -128, [128]],
+     [:byte, 128, nil], [:byte, -129, nil],
+      
+     [:word, 0, [0, 0]], [:word, 127, [127, 0]], [:word, 128, [128, 0]],
+     [:word, 256, [0, 1]], [:word, 32767, [255, 127]], 
+     [:word, -1, [255, 255]], [:word, -127, [129, 255]],
+     [:word, -128, [128, 255]], [:word, -256, [0, 255]],
+     [:word, -32767, [1, 128], [:word, -32768, [0, 128]]],
+     [:word, 32768, nil], [:byte, -32769, nil],
+      
+     [:netword, 0, [0, 0]], [:netword, 127, [0, 127]], 
+     [:netword, 128, [0, 128]],
+     [:netword, 256, [1, 0]], [:netword, 32767, [127, 255]], 
+     [:netword, -1, [255, 255]], [:netword, -127, [255, 129]],
+     [:netword, -128, [255, 128]], [:netword, -256, [255, 0]],
+     [:netword, -32767, [128, 1], [:netword, -32768, [128, 0]]],
+     [:netword, 32768, nil], [:netword, -32769, nil],
+      
+     [:dword, 0x12345678, [0x12, 0x34, 0x56, 0x78]],
+     [:udword, 0x12345678, [0x78, 0x56, 0x34, 0x12]],
+     [:udword, 0xFFFFFFFF, [255, 255, 255, 255]],
+     [:udword, 0xFFFFFFFE, [254, 255, 255, 255]],
+     
+     [:vln, 0, [0x01, 0x00, 0x00]], [:vln, 1, [0x01, 0x00, 0x01]],
+     [:vln, 256, [0x02, 0x00, 0x00, 0x01]],
+     [:vln, 65537, [0x03, 0x00, 0x01, 0x00, 0x01]],
+     [:vln, 0x12345678, [0x04, 0x00, 0x78, 0x56, 0x34, 0x12]],
+     [:vln, 0xFFFFFFFF, [0x04, 0x00, 255, 255, 255, 255]],
+     [:vln, 0xFFFFFFFE, [0x04, 0x00, 254, 255, 255, 255]],
+
+     [:net_vln, 0, [0x00, 0x01, 0x00]], [:net_vln, 1, [0x00, 0x01, 0x01]],
+     [:net_vln, 256, [0x00, 0x02, 0x01, 0x00]],
+     [:net_vln, 65537, [0x00, 0x03, 0x01, 0x00, 0x01]],
+     [:net_vln, 0x12345678, [0x00, 0x04, 0x12, 0x34, 0x56, 0x78]],
+     [:net_vln, 0xFFFFFFFF, [0x00, 0x04, 255, 255, 255, 255]],
+     [:net_vln, 0xFFFFFFFE, [0x00, 0x04, 255, 255, 255, 254]],
+    ].each do |test_line|
+      type, number, array = *test_line
+      if array
+        assert_equal array, Abi.send(:"to_#{type}", number),
+                     "#{type} failed on Ruby number -> array"
+        assert_equal array, Abi.send(:"to_#{type}",
+                                     OpenSSL::BN.new(number.to_s)),
+                     "#{type} failed on OpenSSL number -> array"
+        assert_equal number, Abi.send(:"read_#{type}", @garbage + array,
+                                      @garbage.length)
+        if Abi.respond_to? :"#{type}_length"
+          assert_equal array.length, Abi.send(:"#{type}_length"),
+                       "#{type} failed on length"
+        elsif Abi.respond_to? :"read_#{type}_length"
+          assert_equal array.length,
+                       Abi.send(:"read_#{type}_length", @garbage + array,
+                                @garbage.length),
+                       "#{type} failed on read_#{type}_length"
+        else
+          flunk "#{type} does not provide _length or read_#{type}_length"
+        end
+      else
+        assert_raise RuntimeError do
+          assert_equal array, Abi.send(:"to_#{type}", number)
+        end
+        assert_raise RuntimeError do
+          assert_equal array, Abi.send(:"to_#{type}",
+                                       OpenSSL::BN.new(number.to_s))
+        end
+      end
+    end
+    
+    assert_equal [255, 255, 255, 255], Abi.signed_to_udword(-1),
+                 'Failed on signed_to_udword'
+  end
+  
+  def test_packed_number_encoding
+    packed = { :p => 0x123, :q => 0xABCDEF, :n => 5 }
+    gold_packed = [0x02, 0x00, 0x03, 0x00, 0x01, 0x00, 0x23, 0x01, 0xEF, 0xCD,
+                   0xAB, 0x05]
+    assert_equal gold_packed, Abi.to_packed(packed), 'packed'
+    assert_equal packed, Abi.read_packed(@garbage + gold_packed,
+                                         @garbage.length), 'packed'
+    assert_equal gold_packed.length,
+                 Abi.read_packed_length(@garbage + gold_packed,
+                                        @garbage.length),
+                 'read_packed_length'
+    
+    net_packed = { :x => 0x271, :y => 0x314159, :z => 0, :a => 0x5AA5 }
+    gold_net_packed = [0x00, 0x02, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02,
+                       0x02, 0x71, 0x31, 0x41, 0x59, 0x00, 0x5A, 0xA5 ]
+    assert_equal gold_net_packed, Abi.to_net_packed(net_packed), 'net-packed'
+    assert_equal net_packed, Abi.read_net_packed(@garbage + gold_net_packed,
+                                                 @garbage.length),
+                 'net_packed'
+    assert_equal gold_net_packed.length,
+                 Abi.read_net_packed_length(@garbage + gold_net_packed,
+                                            @garbage.length),
+                 'read_net_packed_length'
+    components = Abi.net_packed_components
+    assert_equal [:x, :y, :z, :a], components,
+                 'incorrect result from _components'
+    assert_raise TypeError, '_components result is mutable' do    
+      components[0] = :w
+    end
+  end
+  
+  def test_fixed_length_string_encoding
+    [
+      [:mac_id, "abcdef", nil, [?a, ?b, ?c, ?d, ?e, ?f]],
+      [:mac_id, "abc", "abc\0\0\0", [?a, ?b, ?c, 0, 0, 0]],
+      [:mac_id, "", "\0\0\0\0\0\0", [0, 0, 0, 0, 0, 0]],
+      [:mac_id, "abcdefg", nil, nil],
+      [:mac_id, [?a, ?b, ?c, ?d, ?e, ?f], "abcdef", [?a, ?b, ?c, ?d, ?e, ?f]],
+      [:mac_id, [?a, ?b, ?c], "abc\0\0\0", [?a, ?b, ?c, 0, 0, 0]],
+      [:mac_id, [], "\0\0\0\0\0\0", [0, 0, 0, 0, 0, 0]],
+      [:mac_id, [?a, ?b, ?c, ?d, ?e, ?f, ?g], nil, nil],
+    ].each do |line|
+      type, source, string, array = *line
+      string ||= source
+      if array
+        assert_equal array, Abi.send(:"to_#{type}", source),
+                     "#{type} failed on string -> array"
+        assert_equal string, Abi.send(:"read_#{type}", @garbage + array,
+                                      @garbage.length)
+      else
+        assert_raise RuntimeError do
+          assert_equal array, Abi.send(:"to_#{type}", source)
+        end
+      end      
+    end    
+  end
+  
+  def test_object_wrapper_directs
+    packed = { :p => 2301, :q => 4141, :n => 60 } 
+    gold_packed = Abi.to_packed packed
+    wrapped = Abi.read_wrapped_raw @garbage + gold_packed, @garbage.length
+    assert_equal Wrapped, wrapped.class,
+                 'Reading wrapped object instantiated wrong class'
+    assert_equal [packed[:p], packed[:q], packed[:n], nil, 'ctor default'],
+                 [wrapped.p, wrapped.q, wrapped.n, wrapped.d, wrapped.c],
+                 'Reading wrapped object gave wrong attributes'
+    assert_equal gold_packed.length,
+                 Abi.read_wrapped_raw_length(@garbage + gold_packed,
+                                             @garbage.length),
+                 'Reading wrapped object length'
+    assert_equal gold_packed, Abi.to_wrapped_raw(wrapped),
+                 'Wrapped object -> array'
+  end
+  
+  def test_object_wrapper_schema
+    packed = { :p => 2301, :q => 4141, :n => 60 } 
+    xpacked = { :p => 6996, :q => 1331, :n => 22 }
+    gold_multi = Abi.to_packed(packed) + Abi.to_packed(xpacked) +
+                  Abi.to_mac_id("abc")
+    multi = Abi.read_multi @garbage + gold_multi, @garbage.length
+    assert_equal Multi, multi.class,
+                'Reading wrapped object instantiated wrong class'
+    assert_equal [packed[:p], packed[:q], packed[:n],
+                  xpacked[:p], xpacked[:q], xpacked[:n], "abc\0\0\0",
+                  "constant string"],
+                 [multi.p, multi.q, multi.n, multi.a, multi.b, multi.c,
+                  multi.str, multi.const],
+                 'Reading wrapped object gave wrong attributes'
+    assert_equal gold_multi, Abi.to_multi(multi),
+                 'Wrapped object -> array'
+    assert_equal gold_multi.length,
+                 Abi.read_multi_length(@garbage + gold_multi, @garbage.length),
+                 'Reading wrapped object length'
+  end
+
+  def test_object_wrapper_hooks
+    packed = { :p => 2301, :q => 4141, :n => 60 } 
+    gold_packed = Abi.to_packed packed
+    wrapped = Abi.read_wrapped @garbage + gold_packed, @garbage.length
+    assert_equal Wrapped, wrapped.class,
+                 'Reading wrapped object instantiated wrong class'
+    assert_equal [nil, nil, nil, packed[:p] * packed[:q], 'hook-new'],
+                 [wrapped.p, wrapped.q, wrapped.n, wrapped.d, wrapped.c],
+                 'Reading wrapped object with hook gave wrong attributes'
+                 
+    wrapped = Abi.read_wrapped_raw gold_packed, 0
+    packed[:n] *= 100
+    gold_packed = Abi.to_packed packed
+    assert_equal gold_packed, Abi.to_wrapped(wrapped),
+                 'Wrapped object -> array (with hook)'
+
+    assert_equal gold_packed.length,
+                 Abi.read_packed_length(@garbage + gold_packed,
+                                        @garbage.length),
+                 'Reading wrapped object length'
+  end
+  
+  def test_conditional_wrapper
+    [
+     [:conditional, "abcdef", [0x59, 0xAF, ?a, ?b, ?c, ?d, ?e, ?f]],
+     [:conditional, 3, [0x59, 0xAC, 0x00, 0x01, 0x03]],
+     [:conditional, 4, [0x59, 0xAD, 0x00, 0x00, 0x00, 0x04]],     
+     [:conditional, OpenSSL::BN.new('7'), [0x59, 0xAD, 0x00, 0x00, 0x00, 0x07]],
+     [:conditional, 6, nil]
+    ].each do |test_line|
+      type, object, array = *test_line
+      if array
+        assert_equal array, Abi.send(:"to_#{type}", object),
+                     "Object #{object.inspect} -> array"
+        assert_equal object, Abi.send(:"read_#{type}", @garbage + array,
+                                      @garbage.length)
+        assert_equal array.length,
+                     Abi.send(:"read_#{type}_length", @garbage + array,
+                              @garbage.length),
+                     "#{type} failed on read_#{type}_length"
+      else
+        assert_raise RuntimeError do
+          assert_equal array, Abi.send(:"to_#{type}", object)
+        end
+      end
+    end
+  end
+  
+  def test_length
+    [[:byte, 1], [:ubyte, 1],
+     [:word, 2], [:netword, 2],
+     [:dword, 4], [:udword, 4],
+     [:mac_id, 6]
+    ].each do |test_line|
+      assert_equal test_line.last, Abi.send(:"#{test_line.first}_length"),
+                   "length failed for #{test_line.first}"
+    end
+  end
+end

data/test/test_driver.rb

@@ -79,8 +79,8 @@ class DriverTest < TemTestCase
   
   def test_crypto_abi
     ekey = OpenSSL::PKey::RSA.generate(2048, 65537)
-    pubk = @tem.new_key_from_ssl ekey, true
-    privk = @tem.new_key_from_ssl ekey, false
+    pubk = Tem::Key.new_from_ssl_key ekey.public_key
+    privk = Tem::Key.new_from_ssl_key ekey
     
     # array and string encryption/decryption
     garbage = (1...569).map { |i| (i * i * 217 + i * 661 + 393) % 256 }
@@ -95,9 +95,9 @@ class DriverTest < TemTestCase
     
     # test key serialization/deserialization through encryption/decryption
     pubk_ys = pubk.to_yaml_str
-    pubk2 = Tem::CryptoAbi::AsymmetricKey.new_from_yaml_str(pubk_ys)
+    pubk2 = Tem::Keys::Asymmetric.new_from_yaml_str(pubk_ys)
     privk_ys = privk.to_yaml_str
-    privk2 = Tem::CryptoAbi::AsymmetricKey.new_from_yaml_str(privk_ys)
+    privk2 = Tem::Keys::Asymmetric.new_from_yaml_str(privk_ys)
     encrypted_garbage = pubk.encrypt garbage
     decrypted_garbage = privk2.decrypt encrypted_garbage
     assert_equal garbage, decrypted_garbage, 'pub-encryption+priv-decryption messed up the data'

data/test/test_tem.rb

@@ -236,7 +236,8 @@ class TemTest < TemTestCase
     }
     
     result = @tem.execute sec
-    assert_equal [garbage1, garbage2, garbage2].map { |d| @tem.hash_for_tem d}.flatten,
+    assert_equal [garbage1, garbage2, garbage2].map { |d| @tem.tem_hash d}.
+                                                flatten,
                   result, 'cryptographic hashing isn\'t working well'
   end
   
@@ -418,8 +419,8 @@ class TemTest < TemTestCase
     
     # crypto run with an externally generated key
     ekey = OpenSSL::PKey::RSA.generate(2048, 65537)
-    pubk = @tem.new_key_from_ssl ekey, true
-    privk = @tem.new_key_from_ssl ekey, false
+    pubk = Tem::Key.new_from_ssl_key ekey.public_key
+    privk = Tem::Key.new_from_ssl_key ekey
     pubk_id = @tem.tk_post_key pubk, keyd[:authz] 
     privk_id = @tem.tk_post_key privk, keyd[:authz]
     i_test_crypto_pki_ops(pubk_id, privk_id, pubk, privk, keyd[:authz])    

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tem_ruby
 version: !ruby/object:Gem::Version 
-  version: 0.10.0
+  version: 0.10.1
 platform: ruby
 authors: 
 - Victor Costan
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-08 00:00:00 -04:00
+date: 2009-05-26 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,16 +22,6 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 0.3.0
     version: 
-- !ruby/object:Gem::Dependency 
-  name: echoe
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
 description: TEM (Trusted Execution Module) driver, written in and for ruby.
 email: victor@costan.us
 executables: 
@@ -50,21 +40,25 @@ extra_rdoc_files:
 - bin/tem_stat
 - CHANGELOG
 - lib/tem/_cert.rb
-- lib/tem/abi.rb
+- lib/tem/apdus/buffers.rb
+- lib/tem/apdus/keys.rb
+- lib/tem/apdus/lifecycle.rb
+- lib/tem/apdus/tag.rb
 - lib/tem/auto_conf.rb
-- lib/tem/buffers.rb
+- lib/tem/builders/abi.rb
+- lib/tem/builders/crypto.rb
 - lib/tem/ca.rb
-- lib/tem/crypto_abi.rb
+- lib/tem/definitions/abi.rb
 - lib/tem/ecert.rb
 - lib/tem/hive.rb
-- lib/tem/keys.rb
-- lib/tem/lifecycle.rb
+- lib/tem/keys/asymmetric.rb
+- lib/tem/keys/key.rb
+- lib/tem/keys/symmetric.rb
 - lib/tem/sec_assembler.rb
 - lib/tem/sec_exec_error.rb
 - lib/tem/sec_opcodes.rb
 - lib/tem/seclosures.rb
 - lib/tem/secpack.rb
-- lib/tem/tag.rb
 - lib/tem/tem.rb
 - lib/tem/toolkit.rb
 - lib/tem/transport/auto_configurator.rb
@@ -89,21 +83,25 @@ files:
 - dev_ca/ca_key.pem
 - dev_ca/config.yml
 - lib/tem/_cert.rb
-- lib/tem/abi.rb
+- lib/tem/apdus/buffers.rb
+- lib/tem/apdus/keys.rb
+- lib/tem/apdus/lifecycle.rb
+- lib/tem/apdus/tag.rb
 - lib/tem/auto_conf.rb
-- lib/tem/buffers.rb
+- lib/tem/builders/abi.rb
+- lib/tem/builders/crypto.rb
 - lib/tem/ca.rb
-- lib/tem/crypto_abi.rb
+- lib/tem/definitions/abi.rb
 - lib/tem/ecert.rb
 - lib/tem/hive.rb
-- lib/tem/keys.rb
-- lib/tem/lifecycle.rb
+- lib/tem/keys/asymmetric.rb
+- lib/tem/keys/key.rb
+- lib/tem/keys/symmetric.rb
 - lib/tem/sec_assembler.rb
 - lib/tem/sec_exec_error.rb
 - lib/tem/sec_opcodes.rb
 - lib/tem/seclosures.rb
 - lib/tem/secpack.rb
-- lib/tem/tag.rb
 - lib/tem/tem.rb
 - lib/tem/toolkit.rb
 - lib/tem/transport/auto_configurator.rb
@@ -119,6 +117,7 @@ files:
 - Rakefile
 - README
 - test/_test_cert.rb
+- test/builders/test_abi_builder.rb
 - test/tem_test_case.rb
 - test/test_driver.rb
 - test/test_exceptions.rb
@@ -137,6 +136,8 @@ files:
 - tem_ruby.gemspec
 has_rdoc: true
 homepage: http://tem.rubyforge.org
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --line-numbers
@@ -162,11 +163,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: tem
-rubygems_version: 1.3.1
+rubygems_version: 1.3.3
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: TEM (Trusted Execution Module) driver, written in and for ruby.
 test_files: 
+- test/builders/test_abi_builder.rb
 - test/test_driver.rb
 - test/test_exceptions.rb
 - test/test_tem.rb

data/lib/tem/abi.rb

@@ -1,55 +0,0 @@
-module Tem::Abi
-  def self.included(klass)
-    klass.extend MixedMethods
-    
-    klass.tem_value_type :byte, 1, :signed => true, :endian => :big
-    klass.tem_value_type :ubyte, 1, :signed => false, :endian => :big
-    klass.tem_value_type :short, 2, :signed => true, :endian => :big
-    klass.tem_value_type :ushort, 2, :signed => false, :endian => :big    
-    klass.tem_value_type :ps_addr, 20, :signed => false, :endian => :big
-    klass.tem_value_type :ps_value, 20, :signed => false, :endian => :big
-  end
-  
-  module MixedMethods
-    def tem_value_type(name, bytes, options = {:signed => true, :endian => :big})
-      range = 1 << (8 * bytes)
-      if options[:signed]
-        min, max = -(range >> 1), (range >> 1) - 1
-      else
-        min, max = 0, range - 1
-      end
-      
-      badass_defines = Proc.new do 
-        define_method("read_tem_#{name}".to_sym) do |array, offset|
-          array = array.reverse unless options[:endian] == :big
-          n = (0...bytes).inject(0) { |v, i| (v << 8) | array[offset + i] }
-          rv = (options[:signed] and n > max) ? n - range : n
-          # pp [:read, name, array, offset, rv]
-          return rv
-        end
-        define_method("to_tem_#{name}".to_sym) do |n|
-          n = n.to_i
-          raise "Value #{n} not between #{min} and #{max}" unless (n <= max) and (n >= min)
-          n += range if(options[:signed] and n < 0)      
-          array = []
-          bytes.times { array.push(n & 0xFF); n >>= 8 }
-          array.reverse! if options[:endian] == :big
-          # pp [:to, name, n, array]
-          return array
-        end
-        define_method("to_tem_#{name}_reladdr".to_sym) do |n|
-          n = n.to_i
-          n += range if (n < 0 and (not options[:signed]))
-          array = []
-          bytes.times { array.push(n & 0xFF); n >>= 8 }
-          array.reverse! if options[:endian] == :big
-          return array
-        end
-        define_method("tem_#{name}_length".to_sym) { bytes }
-      end
-      
-      self.class_eval(&badass_defines)      
-      (class << self; self; end).module_eval(&badass_defines)
-    end
-  end
-end