tem_ruby 0.9.0

data/test/test_tem.rb

@@ -0,0 +1,542 @@
+require 'tem_ruby'
+require 'test/unit'
+
+class TemTest < Test::Unit::TestCase
+  def setup
+    @terminal = Tem::SCard::JCOPRemoteTerminal.new
+    unless @terminal.connect
+      @terminal.disconnect
+      @terminal = Tem::SCard::PCSCTerminal.new
+      @terminal.connect
+    end
+    @javacard = Tem::SCard::JavaCard.new(@terminal)
+    @tem = Tem::Session.new(@javacard)
+    
+    @tem.kill
+    @tem.activate
+  end
+  
+  def teardown
+    @terminal.disconnect unless @terminal.nil?
+  end
+  
+  def test_alu
+    proc = @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.extra 10
+    }
+    result = @tem.execute proc
+    assert_equal [0x68, 0xAC, 0xBB, 0xBC, 0x8C, 0x72, 0x00, 0x55, 0x00, 0x9A],
+                  result, 'the ALU isn\'t working well'
+  end
+  
+  def test_memory
+    proc = @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
+      s.stack
+      s.extra 10
+    }
+    result = @tem.execute proc
+    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
+  
+  def test_output
+    proc = @tem.assemble { |s|
+      s.ldbc 32
+      s.outnew
+      s.outfxb :size => 3, :from => :area1
+      s.ldbc 5
+      s.outvlb :from => :area2
+      s.ldbc 4
+      s.ldwc :area3
+      s.outvb
+      s.ldwc 0x99AA - (1 << 16)
+      s.ldwc 0xFA55 - (1 << 16)
+      s.outb
+      s.outw        
+      s.halt
+      s.label :area1
+      s.immed :ubyte, [0xFE, 0xCD, 0x9A]
+      s.label :area2
+      s.immed :ubyte, [0xAB, 0x95, 0xCE, 0xFD, 0x81]
+      s.label :area3
+      s.immed :ubyte, [0xEC, 0xDE, 0xAD, 0xCF]
+      s.stack
+      s.extra 10
+    }
+    result = @tem.execute proc
+    assert_equal [0xFE, 0xCD, 0x9A, 0xAB, 0x95, 0xCE, 0xFD, 0x81, 0xEC, 0xDE, 0xAD, 0xCF, 0x55, 0x99, 0xAA],
+                  result, 'the output unit isn\'t working well'    
+  end
+  
+  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
+      s.extra 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
+  
+  def test_memory_copy_compare(yaml_roundtrip = false)    
+    sec = @tem.assemble { |s|
+      s.ldwc :const => 16
+      s.outnew
+      s.ldwc :const => 6
+      s.ldwc :cmp_med
+      s.ldwc :cmp_lo
+      s.mcmpvb
+      s.outw
+      s.mcmpfxb :size => 6, :op1 => :cmp_med, :op2 => :cmp_hi
+      s.outw
+      s.ldwc :const => 4
+      s.ldwc :cmp_lo
+      s.ldwc :cmp_med
+      s.mcmpvb
+      s.outw      
+      
+      s.mcfxb :size => 6, :from => :cmp_hi, :to => :copy_buf
+      s.pop
+      s.outfxb :size => 6, :from => :copy_buf      
+      s.ldwc :const => 4
+      s.ldwc :cmp_hi
+      s.ldwc :copy_buf2
+      s.mcvb
+      s.pop      
+      s.outfxb :size => 4, :from => :copy_buf2            
+    
+      s.halt
+      s.label :cmp_lo
+      s.immed :ubyte, [0xA3, 0x2C, 0x51, 0x63, 0x2C, 0x12]
+      s.label :cmp_med
+      s.immed :ubyte, [0xA3, 0x2C, 0x51, 0x63, 0x2D, 0x11]
+      s.label :cmp_hi
+      s.immed :ubyte, [0xA3, 0x2C, 0x51, 0x63, 0x2E, 0x10]
+      s.label :cmp_hi2
+      s.immed :ubyte, [0xA3, 0x2C, 0x51, 0x63, 0x2E, 0x10]
+      s.label :copy_buf
+      s.filler :ubyte, 6
+      s.label :copy_buf2
+      s.filler :ubyte, 4
+      s.stack
+      s.extra 10
+    }
+
+    if yaml_roundtrip
+      # same test, except the SECpack is serialized/deserialized
+      yaml_sec = sec.to_yaml_str
+      sec = Tem::SecPack.new_from_yaml_str(yaml_sec)
+    end
+    result = @tem.execute sec
+    assert_equal [0x00, 0x01, 0xFF, 0xFF, 0x00, 0x00, 0xA3, 0x2C, 0x51, 0x63, 0x2E, 0x10, 0xA3, 0x2C, 0x51, 0x63],
+                  result, 'memory copy/compare isn\'t working well'        
+  end
+  
+  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
+    
+    proc = @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.immed :ubyte, garbage1
+      s.label :garbage2
+      s.immed :ubyte, garbage2
+      s.label :hash_area
+      s.filler :ubyte, hash_size
+      s.stack
+      s.extra 10
+    }
+    
+    result = @tem.execute proc
+    assert_equal [garbage1, garbage2, garbage2].map { |d| @tem.hash_for_tem d}.flatten,
+                  result, 'cryptographic hashing isn\'t working well'
+  end
+  
+  def test_crypto_pstore
+    key1 = (0...(@tem.tem_ps_key_length)).map { |x| (61 * x * x + 62 * x + 10) % 256 }
+    key2 = key1.dup; key2[key2.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_key
+      s.pshkvb
+      s.outw
+          
+      # write to create the location
+      s.pswrfxb :key => :pstore_key, :from => :s_value
+      # check that the location isn't blank anymore
+      s.pshkfxb :key => :pstore_key
+      s.outw
+      # re-read (should get what was written)
+      s.ldwc :pstore_key
+      s.ldwc :s_value2
+      s.psrdvb
+      s.ldwc :s_value2
+      s.outvb
+      
+      # drop the location
+      s.ldwc :pstore_key
+      s.dupn :n => 1
+      s.psrm
+      # check that the location is blank again
+      s.pshkvb
+      s.outw
+            
+      s.halt
+    
+      s.label :pstore_key
+      s.immed :ubyte, key1
+      s.label :s_value
+      s.immed :ubyte, random_value
+      s.label :s_value2
+      s.filler :ps_value
+      s.stack
+      s.extra 16
+    }    
+    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
+  
+  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.filler :ubyte, 8
+      s.stack
+      s.extra 10
+    }
+    
+    result = @tem.execute sec
+    assert_equal 16, result.length, 'monotonic counters aren\'t working well'    
+  end
+  
+  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.immed :ubyte, authz
+      s.label :data
+      s.immed :ubyte, data
+      unless direct_io
+        s.label :outdata
+        s.filler :ubyte, max_output
+      end
+      s.stack
+      s.extra 10
+    }
+    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.immed :ubyte, authz
+      s.label :data
+      s.immed :ubyte, data
+      s.label :signature
+      s.immed :ubyte, signature
+      s.stack
+      s.extra 10
+    }
+    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_pki
+    # 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.new_key_from_ssl ekey, true
+    privk = @tem.new_key_from_ssl ekey, false
+    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
+    
+  def test_crypted_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 }
+    sealed_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.immed :ubyte, secret
+        s.label :plain
+        s.stack
+        s.extra 8
+    }
+
+    sb = sealed_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_crypted_secpack needs rethinking: the raw sec does not contain the secret'
+
+    sealed_sec.seal pubk, :secret, :plain
+    if yaml_roundtrip
+      # same test, except the SECpack is serialized/deserialized
+      yaml_sealed_sec = sealed_sec.to_yaml_str
+      sealed_sec = Tem::SecPack.new_from_yaml_str(yaml_sealed_sec)
+    end    
+    result = @tem.execute sealed_sec, keyd[:privk_id]
+    assert_equal secret, result, 'TEM failed to decrypt secpack'
+
+    sb = sealed_sec.body
+    0.upto(sb.length - 1) { |i| assert_not_equal secret, sb[i, secret.length], 'secret found unencrypted in sealed sec' }
+
+    sealed_sec.body[sealed_sec.label_address(:mess_place)] += 1
+    assert_raise(RuntimeError, 'secpack validation isn\'t working') { @tem.execute sealed_sec }
+  end
+  
+  def test_yaml_secpack
+    # simple test to ensure that the body is preserved
+    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
+      s.extra 10
+    }
+    yaml_sec = sec.to_yaml_str
+    sec2 = Tem::SecPack.new_from_yaml_str(yaml_sec)
+    assert_equal sec.body, sec2.body, 'SECpack body corrupted during serialization'
+    
+    # re-run the memory test (reasonably large SECpack) to ensure that de-serialized SECpacks are equivalent to the originals
+    test_memory_copy_compare(true)
+    # re-run the memory test (reasonably large SECpack) to ensure that serialization works on sealed SECpacks
+    test_crypted_secpack(true)
+  end
+  
+  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/timings/blank_bound_secpack.rb

@@ -0,0 +1,20 @@
+class TemTimings
+  def time_blank_bound_secpack
+    secpack = @tem.assemble { |s|
+      s.ldbc 0
+      s.outnew
+      s.halt
+      s.label :secret
+      s.filler :ubyte, 50
+      s.label :plain
+      s.filler :ubyte, 220
+      s.stack
+      s.extra 2
+    }
+    secpack.seal @tem.pubek, :secret, :plain
+
+    print "SECpack has #{secpack.body.length} bytes, runs 3 instructions and produces 0 bytes\n"
+    do_timing { @tem.execute secpack }
+    
+  end
+end

data/timings/blank_sec.rb

@@ -0,0 +1,15 @@
+class TemTimings
+  def time_blank_sec
+    secpack = @tem.assemble { |s|
+      s.ldbc 0
+      s.outnew
+      s.halt
+      s.filler :ubyte, 70
+      s.stack
+      s.extra 2
+    }
+
+    print "SECpack has #{secpack.body.length} bytes, runs 3 instructions and produces 0 bytes\n"
+    do_timing { @tem.execute secpack }
+  end
+end

data/timings/devchip_decrypt.rb

@@ -0,0 +1,9 @@
+class TemTimings
+  def time_devchip_decrypt
+    pubek = @tem.pubek
+    data = (1...120).map { |i| (i * i * 217 + i * 661 + 393) % 256 }
+    encrypted_data = pubek.encrypt data
+    print "Encrypted blob has #{encrypted_data.length} bytes\n"
+    do_timing { @tem.devchip_decrypt encrypted_data, 0 }
+  end
+end

data/timings/post_buffer.rb

@@ -0,0 +1,10 @@
+class TemTimings
+  def time_post_buffer
+    data = (0...490).map { |i| (39 * i * i + 91 * i + 17) % 256 }
+    p @tem.stat_buffers
+    do_timing do
+      buffer_id = @tem.post_buffer(data)
+      @tem.release_buffer buffer_id
+    end
+  end
+end

data/timings/simple_apdu.rb

@@ -0,0 +1,5 @@
+class TemTimings
+  def time_simple_apdu
+    do_timing { @tem.get_tag_length }
+  end
+end

data/timings/timings.rb

@@ -0,0 +1,66 @@
+require 'tem_ruby'
+
+require 'timings/blank_bound_secpack.rb'
+require 'timings/blank_sec.rb'
+require 'timings/devchip_decrypt.rb'
+require 'timings/post_buffer.rb'
+require 'timings/simple_apdu.rb'
+require 'timings/vm_perf.rb'
+require 'timings/vm_perf_bound.rb'
+
+class TemTimings
+  def setup
+    @terminal = Tem::SCard::JCOPRemoteTerminal.new
+    unless @terminal.connect
+      @terminal.disconnect
+      @terminal = Tem::SCard::PCSCTerminal.new
+      @terminal.connect
+    end
+    @javacard = Tem::SCard::JavaCard.new(@terminal)
+    @tem = Tem::Session.new(@javacard)
+    
+    @tem.kill
+    @tem.activate
+    @tem.emit
+  end
+  
+  def teardown
+    @tem.kill
+    @terminal.disconnect unless @terminal.nil?
+  end
+  
+  def do_timing
+    @tem.flush_buffers
+    
+    n = 10
+    loop do
+      timings = (0...3).map do |i|
+        t_start = Time.now
+        n.times do
+          yield
+        end
+        t_delta = Time.now - t_start
+      end
+      avg_time = timings.inject { |a,v| a + v } / timings.length
+      max_diff = timings.map { |t| (t - avg_time).abs }.max
+      print "%8d: %3.8fs per run, %3.8fs uncertainty (%2.5f%%)\n" % [n, avg_time / n, max_diff / n, 100 * max_diff / avg_time]
+      
+      return avg_time unless max_diff / avg_time >= 0.01
+      n *= 2
+    end
+  end
+  
+  def self.all_timings
+    t = TemTimings.new
+    t.setup
+    t.methods.select { |m| m =~ /time_/ }.each do |m|
+      print "Timing: #{m[5..-1]}...\n"
+      t.send m.to_sym
+    end
+    t.teardown
+  end
+end
+
+if __FILE__ == $0
+  TemTimings.all_timings
+end