costan-tem_ruby 0.10.2

data/test/tem_test_case.rb

@@ -0,0 +1,26 @@
+require 'test/unit'
+
+require 'tem_ruby'
+
+# Helper methods for TEM tests.
+#
+# This module implements setup and teardown methods that provide an initialized
+# @tem instance variable holding a Tem::Session. Just the right thing for
+# testing :) 
+class TemTestCase < Test::Unit::TestCase
+  def setup
+    @tem = Tem.auto_tem
+    
+    @tem.kill
+    @tem.activate
+  end
+  
+  def teardown
+    @tem.disconnect unless @tem.nil?
+  end
+  
+  def test_smoke
+    # All the required files have been parsed successfully.
+    assert true
+  end
+end

data/test/tem_unit/test_tem_alu.rb

@@ -0,0 +1,33 @@
+require 'test/tem_test_case'
+
+class TemAluTest < TemTestCase
+  def test_alu
+    sec = @tem.assemble { |s|
+      s.ldbc 10
+      s.outnew
+      s.ldwc 0x1234
+      s.ldwc 0x5678
+      s.dupn :n => 2
+      s.add
+      s.outw
+      s.sub
+      s.outw
+      s.ldwc 0x0155
+      s.ldwc 0x02AA
+      s.mul
+      s.outw
+      s.ldwc 0x390C
+      s.ldwc 0x00AA
+      s.dupn :n => 2
+      s.div
+      s.outw
+      s.mod
+      s.outw
+      s.halt
+      s.stack 5
+    }
+    result = @tem.execute sec
+    assert_equal [0x68, 0xAC, 0xBB, 0xBC, 0x8C, 0x72, 0x00, 0x55, 0x00, 0x9A],
+                  result, 'the ALU isn\'t working well'
+  end
+end

data/test/tem_unit/test_tem_bound_secpack.rb

@@ -0,0 +1,51 @@
+require 'test/tem_test_case'
+
+module TemBoundSecpackTestCase
+  # This is also called from TemYamlSecpackTest.
+  def _test_bound_secpack(yaml_roundtrip = false)
+    keyd = @tem.tk_gen_key
+    pubk = @tem.tk_read_key keyd[:pubk_id], keyd[:authz]
+    
+    secret = (0...16).map { |i| (99 * i * i + 51 * i + 33) % 256 }
+    bound_sec = @tem.assemble { |s|
+        s.ldbc secret.length
+        s.outnew
+        s.label :mess_place
+        s.outfxb :size => secret.length, :from => :secret
+        s.halt
+        s.label :secret
+        s.data :tem_ubyte, secret
+        # Make sure the zero_bytes optimization doesn't screw things up.
+        s.zeros :tem_ubyte, 60
+        s.label :plain
+        s.stack 4
+    }
+
+    sb = bound_sec.body
+    secret_found = false
+    0.upto(sb.length - 1) { |i| if secret == sb[i, secret.length] then secret_found = true; break; end }
+    assert secret_found, 'test_bound_secpack needs rethinking: the unbound secpack does not contain the secret'
+
+    bound_sec.bind pubk, :secret, :plain
+    if yaml_roundtrip
+      # same test, except the SECpack is serialized/deserialized
+      yaml_bound_sec = bound_sec.to_yaml_str
+      bound_sec = Tem::SecPack.new_from_yaml_str(yaml_bound_sec)
+    end    
+    result = @tem.execute bound_sec, keyd[:privk_id]
+    assert_equal secret, result, 'TEM failed to decrypt secpack'
+
+    sb = bound_sec.body
+    0.upto(sb.length - 1) { |i| assert_not_equal secret, sb[i, secret.length], 'secret found unencrypted in bound secpack' }
+
+    bound_sec.body[bound_sec.label_address(:mess_place)] += 1
+    assert_raise(RuntimeError, 'secpack validation isn\'t working') { @tem.execute bound_sec }
+  end  
+end
+
+class TemBoundSecpackTest < TemTestCase
+  include TemBoundSecpackTestCase    
+  def test_bound_secpack
+    _test_bound_secpack false
+  end
+end

data/test/tem_unit/test_tem_branching.rb

@@ -0,0 +1,56 @@
+require 'test/tem_test_case'
+
+class TemBranchingTest < TemTestCase
+  def test_branching
+    secpack = @tem.assemble { |s|
+      s.ldbc 24
+      s.outnew
+      
+      s.jmp :to => :over_halt
+      s.halt  # this gets jumped over
+      s.label :over_halt
+      s.ldbc 4
+      s.label :test_loop
+      s.dupn :n => 1
+      s.outb
+      s.ldbc 1
+      s.sub
+      s.dupn :n=> 1
+      s.jae :to => :test_loop
+
+      failed = 0xFA - (1 << 8)
+      [
+        [:ja,  [1, 1, failed],  [0, failed, 2],  [-1, failed, 3]],
+        [:jae, [1, 4, failed],  [0, 5, failed],  [-1, failed, 6]], 
+        [:jb,  [1, failed, 7],  [0, failed, 8],  [-1, 9, failed]],
+        [:jbe, [1, failed, 10], [0, 11, failed], [-1, 12, failed]],
+        [:jz,  [1, failed, 13], [0, 14, failed], [-1, failed, 15]],
+        [:jne, [1, 16, failed], [0, failed, 17], [-1, 18, failed]], 
+      ].each do |op_line|
+        op = op_line.shift
+        op_line.each_index do |i|
+          then_label = "#{op}_l#{i}_t".to_sym
+          out_label  = "#{op}_l#{i}_o".to_sym
+          
+          s.ldbc op_line[i][0]        
+          s.send op, :to => then_label
+          s.ldbc op_line[i][2]
+          s.jmp :to => out_label
+          s.label then_label
+          s.ldbc op_line[i][1]
+          s.label out_label
+          s.outb          
+        end
+      end
+      
+      s.halt
+      # Test automated stack placement.
+      s.zeros :tem_ubyte, 10
+    }
+    result = @tem.execute secpack
+    assert_equal [0x04, 0x03, 0x02, 0x01, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
+                  0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
+                  0x10, 0x11, 0x12],
+                 result, 'the branching unit isn\'t working well'        
+  end
+end

data/test/tem_unit/test_tem_crypto_asymmetric.rb

@@ -0,0 +1,123 @@
+require 'test/tem_test_case'
+
+class TemCryptoAsymmetricTest < TemTestCase
+  def i_crypt(data, key_id, authz, mode = :encrypt, direct_io = true, max_output = nil)
+    if max_output.nil?
+      max_output = case mode
+      when :encrypt
+        ((data.length + 239) / 240) * 256
+      when :decrypt
+        data.length
+      when :sign
+        256
+      end
+    end
+    
+    crypt_opcode = {:encrypt => :kefxb, :decrypt => :kdfxb, :sign => :ksfxb}[mode]
+    ex_sec = @tem.assemble { |s|
+      # buffer
+      s.ldwc :const => max_output
+      s.outnew
+      s.ldbc :const => key_id
+      s.authk :auth => :key_auth
+      s.send crypt_opcode, :from => :data, :size => data.length, :to => (direct_io ? 0xFFFF : :outdata) 
+      s.outvlb :from => :outdata unless direct_io
+      s.halt
+      
+      s.label :key_auth
+      s.data :tem_ubyte, authz
+      s.label :data
+      s.data :tem_ubyte, data
+      unless direct_io
+        s.label :outdata
+        s.zeros :tem_ubyte, max_output
+      end
+      s.stack 5
+    }
+    return @tem.execute(ex_sec)    
+  end
+  
+  def i_verify(data, signature, key_id, authz)
+    sign_sec = @tem.assemble { |s|
+      # buffer
+      s.ldbc :const => 1
+      s.outnew
+      s.ldbc :const => key_id
+      s.authk :auth => :key_auth
+      s.kvsfxb :from => :data, :size => data.length, :signature => :signature 
+      s.outb
+      s.halt
+      
+      s.label :key_auth
+      s.data :tem_ubyte, authz
+      s.label :data
+      s.data :tem_ubyte, data
+      s.label :signature
+      s.data :tem_ubyte, signature
+      s.stack 5
+    }
+    return @tem.execute(sign_sec)[0] == 1    
+  end
+  
+  def i_test_crypto_pki_ops(pubk_id, privk_id, pubk, privk, authz)
+    garbage = (1...569).map { |i| (i * i * 217 + i * 661 + 393) % 256 }
+
+    # SEC/priv-sign + CPU/pub-verify, direct IO
+    signed_garbage = i_crypt garbage, privk_id, authz, :sign, true
+    assert privk.verify(garbage, signed_garbage),
+           'SEC priv-signing + CPU pub-verify failed on good data'
+
+    # SEC/priv-sign + CPU/pub-verify, indirect IO
+    signed_garbage = i_crypt garbage, privk_id, authz, :sign, false
+    assert privk.verify(garbage, signed_garbage),
+           'SEC priv-signing + CPU pub-verify failed on good data'
+
+    # CPU/priv-sign + SEC/pub-verify
+    signed_garbage = privk.sign garbage 
+    assert i_verify(garbage, signed_garbage, pubk_id, authz),
+           'CPU priv-signing + SEC pub-verify failed on good data'
+
+    # CPU/priv-encrypt + SEC/pub-decrypt, indirect IO
+    encrypted_garbage = privk.encrypt garbage 
+    decrypted_garbage = i_crypt encrypted_garbage, pubk_id, authz, :decrypt,
+                                false
+    assert_equal garbage, decrypted_garbage,
+                 'SEC priv-encryption + CPU pub-decryption messed up the data'  
+
+    # SEC/pub-encrypt + CPU/priv-decrypt, indirect IO
+    encrypted_garbage = i_crypt garbage, pubk_id, authz, :encrypt, false
+    decrypted_garbage = privk.decrypt encrypted_garbage
+    assert_equal garbage, decrypted_garbage,
+                 'SEC priv-encryption + CPU pub-decryption messed up the data'  
+    
+    # CPU/pub-encrypt + SEC/priv-decrypt, direct-IO
+    encrypted_garbage = pubk.encrypt garbage 
+    decrypted_garbage = i_crypt encrypted_garbage, privk_id, authz, :decrypt,
+                                true
+    assert_equal garbage, decrypted_garbage,
+                 'CPU pub-encryption + SEC priv-decryption messed up the data' 
+
+    # SEC/priv-encrypt + CPU/pub-decrypt, direct-IO
+    encrypted_garbage = i_crypt garbage, privk_id, authz, :encrypt, true
+    decrypted_garbage = pubk.decrypt encrypted_garbage
+    assert_equal garbage, decrypted_garbage,
+                 'SEC priv-encryption + CPU pub-decryption messed up the data'    
+  end
+  
+  def test_crypto_asymmetric
+    # crypto run with an internally generated key
+    keyd = @tem.tk_gen_key :asymmetric
+    pubk = @tem.tk_read_key keyd[:pubk_id], keyd[:authz]
+    privk = @tem.tk_read_key keyd[:privk_id], keyd[:authz]
+    i_test_crypto_pki_ops keyd[:pubk_id], keyd[:privk_id], pubk, privk,
+                          keyd[:authz]
+    
+    # crypto run with an externally generated key
+    ekey = OpenSSL::PKey::RSA.generate(2048, 65537)
+    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]
+  end  
+end

data/test/tem_unit/test_tem_crypto_hash.rb

@@ -0,0 +1,35 @@
+require 'test/tem_test_case'
+
+class TemCryptoHashTest < TemTestCase
+  def test_crypto_hash
+    garbage1 = (0...8).map { |x| (31 * x * x + 5 * x + 3) % 256 }
+    garbage2 = (0...11).map { |x| (69 * x * x + 62 * x + 10) % 256 }
+    hash_size = 20
+    
+    sec = @tem.assemble { |s|
+      s.ldwc hash_size * 3
+      s.outnew
+      s.mdfxb :size => garbage1.length, :from => :garbage1, :to => :hash_area
+      s.outfxb :size => hash_size, :from => :hash_area
+      s.mdfxb :size => garbage2.length, :from => :garbage2, :to => 0xFFFF
+      s.ldwc garbage2.length
+      s.ldwc :garbage2
+      s.ldwc :hash_area
+      s.mdvb
+      s.outfxb :size => hash_size, :from => :hash_area
+      s.halt
+      s.label :garbage1
+      s.data :tem_ubyte, garbage1
+      s.label :garbage2
+      s.data :tem_ubyte, garbage2
+      s.label :hash_area
+      s.zeros :tem_ubyte, hash_size
+      s.stack 5
+    }
+    
+    result = @tem.execute sec
+    assert_equal [garbage1, garbage2, garbage2].map { |d| @tem.tem_hash d}.
+                                                flatten,
+                  result, 'cryptographic hashing isn\'t working well'
+  end
+end

data/test/tem_unit/test_tem_crypto_pstore.rb

@@ -0,0 +1,53 @@
+require 'test/tem_test_case'
+
+class TemCryptoPstoreTest < TemTestCase
+  def test_crypto_pstore
+    addr1 = (0...(@tem.tem_ps_addr_length)).map { |x| (61 * x * x + 62 * x + 10) % 256 }
+    addr2 = addr1.dup; addr2[addr2.length - 1] += 1
+    random_value = (0...(@tem.tem_ps_value_length)).map { |x| (69 * x * x + 62 * x + 10) % 256 }
+    
+    sec = @tem.assemble { |s|
+      s.ldwc 3 * @tem.tem_ushort_length + @tem.tem_ps_value_length * 2
+      s.outnew
+      
+      # check that the location is blank
+      s.ldwc :pstore_addr
+      s.pshkvb
+      s.outw
+          
+      # write to create the location
+      s.pswrfxb :addr => :pstore_addr, :from => :s_value
+      # check that the location isn't blank anymore
+      s.pshkfxb :addr => :pstore_addr
+      s.outw
+      # re-read (should get what was written)
+      s.ldwc :pstore_addr
+      s.ldwc :s_value2
+      s.psrdvb
+      s.ldwc :s_value2
+      s.outvb
+      
+      # drop the location
+      s.ldwc :pstore_addr
+      s.dupn :n => 1
+      s.psrm
+      # check that the location is blank again
+      s.pshkvb
+      s.outw
+            
+      s.halt
+    
+      s.label :pstore_addr
+      s.data :tem_ubyte, addr1
+      s.label :s_value
+      s.data :tem_ubyte, random_value
+      s.label :s_value2
+      s.zeros :tem_ps_value
+      s.stack 8
+    }    
+    expected = @tem.to_tem_ushort(0) + @tem.to_tem_ushort(1) + random_value +
+               @tem.to_tem_ushort(0)
+    result = @tem.execute sec
+    assert_equal expected, result, 'persistent store locations aren\'t working well'    
+  end
+end

data/test/tem_unit/test_tem_crypto_random.rb

@@ -0,0 +1,25 @@
+require 'test/tem_test_case'
+
+class TemCryptoRandomTest < TemTestCase
+  def test_crypto_random
+    sec = @tem.assemble { |s|
+      s.ldbc 16
+      s.outnew
+      s.ldbc 8
+      s.dupn :n => 1
+      s.ldwc :rnd_area
+      s.dupn :n => 2
+      s.rnd       
+      s.outvb
+      s.ldbc(-1)
+      s.rnd
+      s.halt
+      s.label :rnd_area
+      s.zeros :tem_ubyte, 8
+      s.stack 5
+    }
+    
+    result = @tem.execute sec
+    assert_equal 16, result.length, 'monotonic counters aren\'t working well'    
+  end
+end

data/test/tem_unit/test_tem_emit.rb

@@ -0,0 +1,23 @@
+require 'test/tem_test_case'
+
+class TemEmitTest < TemTestCase
+  def test_emit
+    # try to emit
+    er = @tem.emit
+    assert er != nil, 'TEM emitting failed'
+    
+    # now verify that the private key is good and the authorization matches
+    privek = @tem.tk_read_key 0, er[:privek_auth]
+    assert((not privek.is_public?), 'TEM emission failed to produce a proper PrivEK')
+
+    # verify that the public key can be read from the ECert
+    pubek = @tem.pubek
+    assert pubek.is_public?, 'TEM emission failed to produce a proper PubEK'
+
+    # verify the PrivEK against the ECert
+    ecert = @tem.endorsement_cert
+    ecert.verify privek.ssl_key
+    
+    @tem.tk_delete_key 0, er[:privek_auth]
+  end  
+end

data/test/tem_unit/test_tem_memory.rb

@@ -0,0 +1,48 @@
+require 'test/tem_test_case'
+
+class TemMemoryTest < TemTestCase
+  def test_memory
+    sec = @tem.assemble { |s|
+      s.label :clobber
+      s.ldbc 32
+      s.label :clobber2
+      s.outnew
+      s.ldwc 0x55AA
+      s.stw :clobber
+      s.ldb :clobber
+      s.outw
+      s.ldw :clobber
+      s.outw
+      s.ldbc 0xA5 - (1 << 8)
+      s.stb :clobber
+      s.ldw :clobber
+      s.outw
+      s.ldwc :clobber2
+      s.dupn :n => 1
+      s.dupn :n => 2
+      s.ldwc 0x9966 - (1 << 16)
+      s.stwv
+      s.ldbv
+      s.outw
+      s.ldbc 0x98 - (1 << 8)
+      s.stbv
+      s.ldwv
+      s.outw
+      s.ldwc 0x1122
+      s.ldwc 0x3344
+      s.ldwc 0x5566
+      s.flipn :n => 3
+      s.outw
+      s.outw
+      s.outw
+      s.halt
+      # Test stack without arguments.
+      s.stack
+      s.zeros :tem_short, 5
+    }
+    result = @tem.execute sec
+    assert_equal [0x00, 0x55, 0x55, 0xAA, 0xA5, 0xAA, 0xFF, 0x99, 0x98, 0x66,
+                  0x11, 0x22, 0x33, 0x44, 0x55, 0x66],
+                 result, 'the memory unit isn\'t working well'    
+  end
+end