costan-tem_ruby 0.10.2

data/lib/tem/hive.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'fileutils'
+
+# The TEM's configuation hive
+module Tem::Hive
+  @@hive_dir = File.join(Gem.user_home, ".tem")
+  
+  def self.path_to(*hive_entry)
+    File.join(@@hive_dir, *hive_entry)
+  end
+    
+  def self.create(*hive_entry)
+    path = File.join(@@hive_dir, *hive_entry)
+    FileUtils.mkdir_p File.dirname(path)
+    File.open(path, "w") { |f| }
+    return path
+  end
+end

data/lib/tem/keys/asymmetric.rb

@@ -0,0 +1,116 @@
+# :nodoc: namespace
+module Tem::Keys
+
+# Wraps a TEM asymmetric key, e.g. an RSA key.
+class Asymmetric < Tem::Key  
+  def self.new_from_array(array)
+    self.new(OpenSSL::PKey::RSA.new(array[0]), *array[1..-1])      
+  end
+  
+  def self.new_from_yaml_str(yaml_str)
+    array = YAML.load yaml_str
+    new_from_array array
+  end
+
+  def to_array
+    [@ssl_key.to_pem, @padding_type]
+  end
+  
+  def to_yaml_str
+    self.to_array.to_yaml.to_s
+  end       
+  
+  # Generate a pair of asymmetric keys.
+  def self.generate_pair
+    ssl_key = OpenSSL::PKey::RSA.generate(2048, 65537)
+    new_pair_from_ssl_key ssl_key
+  end
+  
+  # Creates a pair of asymmetric keys wrapping an OpenSSL private key.
+  def self.new_pair_from_ssl_key(ssl_key)
+    { :public => Tem::Keys::Asymmetric.new(ssl_key.public_key),
+      :private => Tem::Keys::Asymmetric.new(ssl_key) }
+  end
+      
+  def initialize(ssl_key, padding_type = :pkcs1)
+    super ssl_key
+    @is_public = !ssl_key.d
+    @padding_type = padding_type
+    
+    case padding_type
+    when :oaep
+      @padding_id = OpenSSL::PKey::RSA::PKCS1_OAEP_PADDING 
+      @padding_bytes = 42
+    when :pkcs1
+      @padding_id = OpenSSL::PKey::RSA::PKCS1_PADDING
+      @padding_bytes = 11
+    else
+      raise "Unknown padding type #{padding_type}\n"
+    end
+    
+    @size = 0
+    n = @is_public ? @ssl_key.n : (@ssl_key.p * @ssl_key.q)
+    while n != 0 do
+      @size += 1
+      n >>= 8
+    end
+  end
+  public_class_method :new
+    
+  def is_public?
+    @is_public
+  end
+  
+  def encrypt(data)
+    encrypt_or_decrypt data, @size - @padding_bytes,
+                       @is_public ? :public_encrypt : :private_encrypt      
+  end
+  
+  def decrypt(data)
+    encrypt_or_decrypt data, @size,
+                       @is_public ? :public_decrypt : :private_decrypt      
+  end
+
+  def sign(data)
+    data = data.pack 'C*' if data.respond_to? :pack
+    # PKCS1-padding is forced in by openssl... sigh!
+    out_data = @ssl_key.sign OpenSSL::Digest::SHA1.new, data
+    data.respond_to?(:pack) ? out_data : out_data.unpack('C*')
+  end
+  
+  def verify(data, signature)
+    data = data.pack 'C*' if data.respond_to? :pack
+    signature = signature.pack 'C*' if signature.respond_to? :pack
+    # PKCS1-padding is forced in by openssl... sigh!
+    @ssl_key.verify OpenSSL::Digest::SHA1.new, signature, data
+  end
+
+  def encrypt_or_decrypt(data, in_size,  op)
+    chug_data(data, in_size) { |block| @ssl_key.send op, block, @padding_id }    
+  end
+  private :encrypt_or_decrypt
+
+  def chug_data(data, in_size, &chug_block)
+    output = data.class.new
+    i = 0
+    while i < data.length do
+      block_size = (data.length - i < in_size) ? data.length - i : in_size
+      if data.kind_of? String
+        block = data[i...(i+block_size)]
+      else 
+        block = data[i...(i+block_size)].pack('C*')
+      end
+      o_block = yield block
+      if data.kind_of? String
+        output += o_block
+      else
+        output += o_block.unpack('C*')
+      end
+      i += block_size
+    end
+    return output
+  end
+  private :chug_data
+end
+
+end  # namespace Tem::Keys

data/lib/tem/keys/key.rb

@@ -0,0 +1,48 @@
+# Base class for the TEM keys.
+#
+# This class consists of stubs describing the interface implemented by
+# subclasses.
+class Tem::Key
+  # The OpenSSL key wrapped by this TEM key.
+  attr_reader :ssl_key
+  
+  # Creates a new key based on an OpenSSL key.
+  def initialize(ssl_key)
+    @ssl_key = ssl_key
+  end
+  # This class should not be instantiated directly.
+  private_class_method :new
+  
+  # Serializes this key to the TEM ABI format.
+  def to_tem_key
+    Tem::Abi.to_tem_key self
+  end
+  
+  # Encrypts a block of data into a TEM-friendly format.
+  def encrypt(data)
+    raise "TEM Key class #{self.class.name} didn't implement encrypt"
+  end
+
+  def decrypt(data)
+    raise "TEM Key class #{self.class.name} didn't implement decrypt"
+  end
+
+  def sign(data)
+    raise "TEM Key class #{self.class.name} didn't implement sign"
+  end
+
+  def verify(data)
+    raise "TEM Key class #{self.class.name} didn't implement verify"
+  end
+
+  # Creates a new TEM key wrapper from a SSL key
+  def self.new_from_ssl_key(ssl_key)
+    if ssl_key.kind_of? OpenSSL::PKey::PKey
+      Tem::Keys::Asymmetric.new ssl_key
+    elsif ssl_key.kind_of? OpenSSL::Cipher::Cipher
+      Tem::Keys::Symmetric.new ssl_key
+    else
+      raise "Can't handle keys of class #{ssl_key.class}"
+    end
+  end
+end

data/lib/tem/keys/symmetric.rb

@@ -0,0 +1,47 @@
+# :nodoc: namespace
+module Tem::Keys
+
+# Wraps a TEM symmetric key, e.g. an AES key.
+class Symmetric < Tem::Key
+  @@cipher_mode = 'ECB'
+  
+  # Generates a new symmetric key.
+  def self.generate
+    cipher = OpenSSL::Cipher::AES128.new @@cipher_mode
+    key = cipher.random_key
+    self.new key
+  end
+  
+  # Creates a new symmetric key based on an OpenSSL Cipher instance, augmented
+  # with a key accessor.
+  def initialize(ssl_key)
+    super ssl_key
+    @key = ssl_key.key
+    @cipher_class = ssl_key.class
+  end
+  public_class_method :new
+
+  def encrypt_or_decrypt(data, do_encrypt)
+    cipher = @cipher_class.new @@cipher_mode
+    do_encrypt ? cipher.encrypt : cipher.decrypt
+    cipher.key = @key
+    cipher.iv = "\0" * 16
+    
+  end
+  
+  def encrypt(data)
+    cipher.encrypt_or_decrypt data, true
+  end
+
+  def decrypt(data)
+    cipher.encrypt_or_decrypt data, false
+  end
+
+  def sign(data)
+  end
+
+  def verify(data)
+  end
+end
+
+end  # namespace Tem::Keys

data/lib/tem/sec_exec_error.rb

@@ -0,0 +1,63 @@
+# raised when executing a SEC 
+class Tem::SecExecError < StandardError
+  attr_reader :line_info
+  attr_reader :buffer_state, :key_state
+  attr_reader :trace
+  
+  def initialize(line_info, tem_trace, buffer_state, key_state)
+    super 'SEC execution failed on the TEM'
+    @line_info = line_info
+    line_ip, atom, backtrace = *line_info
+    @atom = atom
+    if tem_trace and tem_trace[:ip]
+      @ip_delta = tem_trace[:ip] - line_ip
+    else
+      @ip_delta = 0
+    end
+    @trace = tem_trace
+    @buffer_state = buffer_state
+    @key_state = key_state
+    set_backtrace backtrace
+  end
+  
+  def bstat_str
+    if @buffer_state.nil?
+      "no buffer state available"
+    else
+      @buffer_state.inspect
+    end
+  end
+
+  def kstat_str
+    if @key_state.nil?
+      "no key state available"
+    else
+      @key_state.inspect
+    end
+  end
+  
+  def trace_str
+    if @trace.nil?
+      "no trace available"
+    else
+      "ip=#{'%04x' % @trace[:ip]} sp=#{'%04x' % @trace[:sp]} out=#{'%04x' % @trace[:out]} pscell=#{'%04x' % @trace[:pscell]}"
+    end
+  end
+  
+  def to_s
+    string = <<ENDSTRING
+SECpack execution generated an exception on the TEM
+
+TEM Trace: #{trace_str}
+TEM Buffer Status:#{bstat_str}
+TEM Key Status:#{kstat_str}
+
+TEM execution error at #{@atom}+#{@ip_delta}
+ENDSTRING
+    string.strip
+  end
+  
+  def inspect
+    trace_str + "\n" + bstat_str + "\n" + kstat_str
+  end
+end

data/lib/tem/seclosures.rb

@@ -0,0 +1,81 @@
+require 'yaml'
+
+module Tem::SeClosures
+  module MixedMethods
+    def assemble(&block)
+      return Tem::Assembler.assemble(&block)
+    end
+  end
+  
+  include MixedMethods
+  def self.included(klass)
+    klass.extend MixedMethods
+  end
+  
+  def sec_trace
+    #begin      
+      trace = @transport.applet_apdu! :ins => 0x54
+      if trace.length > 2
+        case read_tem_short(trace, 0) # trace version
+        when 1
+          return {:sp => read_tem_short(trace, 2), :ip => read_tem_short(trace, 4),
+                  :out => read_tem_short(trace, 6), :pscell =>  read_tem_short(trace, 8)}
+        end        
+      end
+      return nil # unreadable trace
+    #rescue
+    #  return nil
+    #end
+  end
+  
+  def solve_psfault
+    # TODO: better strategy, lol
+    next_cell = rand(16)
+    @transport.applet_apdu! :ins => 0x53, :p12 => to_tem_ushort(next_cell)
+  end
+  
+  def execute(secpack, key_id = 0)
+    # load SECpack
+    buffer_id = post_buffer(secpack.tem_formatted_body)
+    response = @transport.applet_apdu! :ins => 0x50, :p1 => buffer_id,
+                                                     :p2 => key_id
+    tem_secpack_error(response) if read_tem_byte(response, 0) != 1
+    
+    # execute SEC
+    sec_exception = nil
+    loop do 
+      response = @transport.applet_apdu! :ins => 0x52
+      sec_status = read_tem_byte(response, 0)
+      case sec_status
+      when 2 # success
+        break
+      when 3 # exception
+        # there is an exception, try to collect the trace
+        b_stat = stat_buffers() rescue nil
+        k_stat = stat_keys() rescue nil
+        trace = sec_trace()
+        if trace and trace[:ip]
+          line_info = secpack.line_info_for_ip(trace[:ip])
+        else
+          line_info = [0, :unknown, Kernel.caller]
+        end
+        sec_exception = Tem::SecExecError.new line_info, trace, b_stat, k_stat
+        break
+      when 4 # persistent store fault
+        solve_psfault
+      else
+        raise "Unrecognized execution engine status #{sec_status}"
+      end
+    end
+  
+    # unbind SEC
+    response = @transport.applet_apdu! :ins => 0x51
+    raise sec_exception if sec_exception
+    buffer_id = read_tem_byte(response, 0)
+    buffer_length = read_tem_short(response, 1)
+    data_buffer = read_buffer buffer_id
+    release_buffer buffer_id
+    
+    return data_buffer[0...buffer_length]
+  end
+end

data/lib/tem/secpack.rb

@@ -0,0 +1,107 @@
+require 'yaml'
+
+class Tem::SecPack
+  @@serialized_ivars = [:body, :labels, :ep, :sp, :extra_bytes, :signed_bytes,
+                        :encrypted_bytes, :bound, :lines]    
+ 
+  def self.new_from_array(array)
+    arg_hash = { }
+    @@serialized_ivars.each_with_index { |name, i| arg_hash[name] = array[i] }
+    self.new arg_hash
+  end
+  
+  def self.new_from_yaml_str(yaml_str)
+    array = YAML.load yaml_str
+    new_from_array array
+  end
+
+  def to_array
+    @@serialized_ivars.map { |m| self.instance_variable_get :"@#{m}" }
+  end
+  
+  def to_yaml_str
+    self.to_array.to_yaml.to_s
+  end
+  
+  attr_reader :body, :bound
+  attr_reader :lines
+  
+  def trim_extra_bytes
+    @extra_bytes = 0
+    while @extra_bytes < @body.length
+      break if @body[-@extra_bytes - 1] != 0
+      @extra_bytes += 1
+    end
+    @body.slice! @body.length - @extra_bytes, @extra_bytes    
+  end
+  
+  def expand_extra_bytes
+    @body += [0] * @extra_bytes
+    @extra_bytes = 0
+  end
+  
+  def initialize(args)
+    @@serialized_ivars.map { |m| self.instance_variable_set :"@#{m}", args[m] }
+    @bound ||= false
+    
+    @extra_bytes ||= 0
+    # trim_extra_bytes if @extra_bytes == 0
+  end
+  
+  def label_address(label_name)
+    @labels[label_name.to_sym]
+  end
+    
+  def bind(public_key, encrypt_from = 0, plaintext_from = 0)
+    expand_extra_bytes
+    encrypt_from = @labels[encrypt_from.to_sym] unless encrypt_from.kind_of? Numeric
+    plaintext_from = @labels[plaintext_from.to_sym] unless plaintext_from.kind_of? Numeric
+    
+    @signed_bytes = encrypt_from
+    @encrypted_bytes = plaintext_from - encrypt_from
+    
+    secpack_sig = Tem::Abi.tem_hash [tem_header, @body[0...plaintext_from]].flatten
+    crypt = public_key.encrypt [@body[encrypt_from...plaintext_from], secpack_sig].flatten
+    @body = [@body[0...encrypt_from], crypt, @body[plaintext_from..-1]].flatten
+      
+    label_delta = crypt.length - @encrypted_bytes         
+    @labels = Hash[*(@labels.map { |k, v|
+      if v < encrypt_from
+        [k, v] 
+      elsif v < plaintext_from
+        []
+      else
+        [k, v + label_delta]
+      end
+    }.flatten)]
+    
+    #trim_extra_bytes
+    @bound = true
+  end
+  
+  def tem_header
+    # TODO: use 0x0100 (no tracing) depending on options
+    hh = [0x0101, @signed_bytes || 0, @encrypted_bytes || 0, @extra_bytes, @sp,
+          @ep].map { |n| Tem::Abi.to_tem_ushort n }.flatten
+    hh += Array.new((Tem::Abi.tem_hash [0]).length - hh.length, 0)
+    return hh
+  end
+  private :tem_header
+  
+  def tem_formatted_body
+    # HACK: Ideally, we would allocate a bigger buffer, and then only fill part
+    #       of it. Realistically, we'll just send in extra_bytes 0s.
+    [tem_header, @body, [0] * @extra_bytes].flatten
+  end
+  
+  def line_info_for_ip(ip)
+    return nil unless @lines
+
+    @lines.reverse_each do |info|
+      # If something breaks, it's likely to happen after the opcode of the 
+      # offending instruction has been read, so assume offending_ip < ip.
+      return info if ip >= info[0]
+    end
+    return info.first
+  end
+end