iso7816 0.0.3

data/lib/7816/atr.rb

@@ -0,0 +1,173 @@
+
+require 'hexy'
+
+module ISO7816
+  class ATR
+#   require 'atr_generated'
+    attr_reader :atr_bytes
+    # provide a string of bytes to init this object.
+    def initialize atr
+      @atr_bytes = atr
+      @string_rep = ATR.stringify atr
+      @desc = ATR.get_description atr
+      @ta=Hash.new
+      @tb=Hash.new
+      @tc=Hash.new
+      @td=Hash.new
+      decode  
+    end
+    
+    # ATR spec:
+    # TS : initial 
+    #   3F = inverse logic
+    #   3B = direct logic
+    # T0 : format
+    #   |7|6|5|4||3|2|1|0|
+    #   bits 4 through 7 indicate presence of TA1, TB1, TC1, TD1 respectively 
+    #   bits 0-3 are the length of the "historical data"
+    #
+    #   TA1...TD1, if present follow T0
+    #
+    #   TAi, TBi, and TCi have codified sematics, a possible TDi field signals the
+    #   existance of further TAi+1... fields.
+    #
+    #   |7|6|5|4||3|2|1|0|
+    #   
+    #   where 4, 5 and 6 signal he presesence of TAx, TBx, TCx, TDx.
+    #
+    #   finally the last bytes are "historical data" followed by a single byte checksum.
+    def decode
+      pos = 0
+      @ts = @atr_bytes[pos]
+      case @ts
+      when 0x3F: @ts_d="inverse"
+      when 0x3B: @ts_d="direct"
+      else  @ts_d = "invalid"
+      end
+
+      @t0 = @atr_bytes[pos+=1]
+      
+      ta, tb, tc,td, @hist_data_len = decode_TD 0, pos
+      
+      i=1
+      @max_i = 0
+      while ta || tb || tc || td
+        @max_i = i
+        decodeTA i, pos+=1 if ta 
+        decodeTB i, pos+=1 if tb 
+        decodeTC i, pos+=1 if tc 
+        if td
+          ta, tb, tc, td = decode_TD i, pos+=1
+        else
+          break   
+        end
+        i+=1
+      end
+      
+      @historical_data = @atr_bytes[pos+=1, @hist_data_len]
+      #puts @historical_data.size
+
+      #puts ATR.stringify(@historical_data)
+    end
+  
+    def decodeTA i, pos
+      @ta ||= Hash.new
+      @ta[i]=@atr_bytes[pos] 
+    end
+    def decodeTB i, pos
+      @tb ||= Hash.new
+      @tb[i]=@atr_bytes[pos] 
+    end
+
+    def decodeTC i, pos
+      @tc ||= Hash.new
+      @tc[i]=@atr_bytes[pos] 
+    end
+
+    # decodes a byte in the form:
+    #   |7|6|5|4||3|2|1|0|
+    # and returns
+    # [TA?, B?, TC?, TD?, num]
+    def decode_TD i, pos
+            byte = @atr_bytes[pos]
+            @td ||= Hash.new
+            @td[i]=byte
+
+            [
+              (byte & 0x10)!=0,
+              (byte & 0x20)!=0,
+              (byte & 0x40)!=0,
+              (byte & 0x80)!=0,
+              byte & 0x0F
+            ]
+    end
+
+    def to_s
+      str = <<HELLO
+ATR #{@string_rep}  
+  TS (#{"%X"%@ts}) : #{@ts_d}
+  T0 (#{"%X"%@t0}) : #{"%08b"%@t0}
+
+  histdatalen: #{@hist_data_len}
+
+HELLO
+    
+      1.upto(@max_i) {|i|
+        str << "i=#{i}\n"
+        str << label_i_hex_bin("TA", i, @ta[i])  
+        str << label_i_hex_bin("TB", i, @tb[i]) 
+        str << label_i_hex_bin("TC", i, @tc[i]) 
+        str << label_i_hex_bin("TD", i, @td[i]) 
+
+      }
+      
+      if @historical_data 
+        str << "Historical Data:\n" 
+        str << Hexy.new(@historical_data).to_s
+      end
+
+      str
+    end
+
+
+    def label_i_hex_bin label, i, byte 
+      byte == nil ? "" : "  %s%d(%02x) = %08b\n" % [label, i, byte, byte]
+    end
+
+    def self.stringify atr
+      atr.unpack("H*")[0].upcase
+    end
+    def self.get_description atr, bytes=false
+      atr = stringify atr if bytes
+      #desc = ATR_HASH[atr]
+      #desc ? desc : "unknown"
+      "unknown"
+    end
+  end
+end
+
+if $0 == __FILE__
+  puts ISO7816::ATR.get_description("3B660000314B01010080")
+  puts ISO7816::ATR.get_description("3B66000;ldskjfalsdkj")
+  bytes = ["3B660000314B01010080"].pack("H*")
+  puts ISO7816::ATR.get_description(bytes , true)
+  atr = ISO7816::ATR.new bytes
+  puts atr
+
+
+  bytes = ["3BFF9500FFC00A1F438031E073F62113574A334861324147D6"].pack("H*")
+  atr = ISO7816::ATR.new bytes
+  puts atr
+
+
+  ISO7816::ATR::ATR_HASH.keys.each{|key|
+          puts key
+    bytes= [key].pack("H*")
+    puts ISO7816::ATR.new(bytes).to_s
+    puts "--------------------------------------"
+
+  } 
+
+
+end
+

data/lib/7816/card.rb

@@ -0,0 +1,278 @@
+require 'smartcard'
+module ISO7816
+module Card
+  
+  # Dummy implementation of `Card` to describe the provided interface
+  class Card
+    attr_reader :atr
+    # Set up a connection to this card and return the ATR String.
+    # May be called with a block which will be passed `self`. Card
+    # will call `disconnect` at the end of the block 
+    def connect
+      raise "not implemented, use a subclass of `Card`!"
+    end
+
+    # disconnect from the card and free all resources.
+    def disconnect
+      raise "not implemented, use a subclass of `Card`!"
+    end
+    
+    # Send bytes to the card.
+    def send bytes=""
+      raise "not implemented, use a subclass of `Card`!"
+    end
+
+    def reconnect
+      disconnect
+      connect
+    end
+  
+    # receive a response from the card, optionally pass in the
+    # number of expected bytes in the response, this value will be 1024
+    # by default, which should be enough to hold most responses sent by
+    # a card.
+    def receive le=1024
+      raise "not implemented, use a subclass of `Card`!"
+    end
+
+    def t0?
+      raise "not implemented, use a subclass of `Card`!"
+    end
+  end #class Card
+  
+  class PCSCCard < Card
+    def initialize()
+    end
+
+    def connect
+      begin 
+        if @connected
+           #puts "!!!!!!!!!!!!!! Already Connected!"
+        else
+           @card = ISO7816::PCSC::Card.new()  
+        end
+      rescue
+        @card.disconnect if @card
+        raise $!
+      end
+      
+      stat = @card.status
+      @connected = true
+      @atr = @card.atr
+      @t0  = stat[:protocol] == Smartcard::PCSC::PROTOCOL_T0
+      if block_given?
+         yield self
+         disconnect
+      end  
+      @atr
+    end
+    
+    def reconnect
+      #puts "calling reconn! #{ (@card && @connected)}"
+      @card.reconnect if (@card && @connected)
+    end
+
+    def disconnect 
+      @card.disconnect() if @card
+      @card = nil
+      @connected = false
+    end
+
+    def send bytes = ""
+      @received = @card.transmit(bytes)
+    end
+
+    def receive len=0
+      ret = @received
+      @received = nil
+      return ret
+    end
+
+    def t0?
+      return @t0
+    end
+
+  end
+
+  class LoggingCard < Card
+    attr_accessor :card
+    def initialize card
+      @card = card
+      @log = []
+    end
+    def atr
+      @card.atr
+    end
+    def connect &block
+      if block_given?
+        @card.connect 
+        @log.push [:atr, @card.atr]
+        yield self
+        disconnect
+      else
+        @card.connect
+        @log.push [:atr, @card.atr]
+      end
+    end
+
+    def disconnect
+      @card.disconnect
+      @log.push [:disco, ""]
+    end
+
+    def send bytes
+      @card.send bytes
+      @log.push [:send, bytes]
+    end
+
+    def receive le=1024
+      recv = @card.receive(le)
+      @log.push [:recv, recv]
+      recv
+    end
+
+    def t0?
+      @card.t0?
+    end
+
+    def comment txt
+      @log.push [:comment, txt]
+    end
+    
+    DEFAULT_DUMP = lambda {|dir, b|
+      prefix = case dir
+               when :atr     then "ATR"
+               when :send    then "  >"
+               when :recv    then "  <"
+               when :disco   then "\nCLIENT DISCONNECT"
+               else               :comment
+               end
+      if prefix == :comment
+        txt = "\n"
+        b.each_line{|line| txt << "      #{line}"}
+        txt << "\n\n"     
+      else
+        "%s %s" % [prefix, ISO7816.b2s(b)]
+      end
+    }
+    def dump io=STDOUT, formater=DEFAULT_DUMP
+      @log.each{ |line|
+        format = DEFAULT_DUMP.call(line[0], line[1])
+        io.puts(format)
+      }        
+      
+    end
+
+
+  end
+
+  # This implementation of card relies on 
+  # socket communication, it expects an atr to be
+  # send on TCP connect
+  class TCPCard < Card
+    SLEEP_TIME = 0.1
+    attr_accessor :addr, :port
+    def initialize addr="127.0.0.1", port=1024
+      @addr = addr
+      @port = port
+    end
+
+    def connect
+      require 'socket'
+      @socket = TCPSocket.new(@addr, @port)
+      @connected = true
+      
+      sleep SLEEP_TIME 
+      @atr = @socket.recv 1024,0 
+      if block_given?
+        yield self
+        disconnect
+      end
+      @atr
+    end
+
+    def disconnect
+      @socket.close if @socket && @connected
+      @connected = false
+      @expect_sw=nil
+      true
+    end
+
+    def connected?
+      return false unless @connected
+      # we're still connected, check if peer is still available
+      true
+    end
+
+    def send bytes, flags=0
+      raise "not connected" unless @connected
+      bytes1 = bytes[0,5]
+      bytes2 = bytes[5,bytes.length]
+      @socket.send bytes1, flags
+      # TCP2 echos back the ins byte, flags
+      # according to ISO 7816-3 10.3.3
+      proc_byte = @socket.recv 1, Socket::MSG_PEEK 
+      # recv 90 60, INS, ...
+      if proc_byte == "\x60" # null byte
+        #
+      elsif in_range(proc_byte, "\x61", "\x6f") || in_range(proc_byte, "\x90", "\x9f")
+        @expect_sw=true
+      else # INS being echoed back
+        @socket.recv 1, 0
+        @socket.send bytes2,flags
+      end
+    end
+    
+    def in_range byte, from, to
+      byte >= from && byte <= to  
+    end
+
+    def receive le=nil
+      raise "not connected" unless @connected
+      
+      if @expect_sw 
+        le=2
+        @expect_sw=nil
+      end
+
+      if le && Socket.const_defined?("MSG_WAITALL")
+        # if we know the num bytes to receive, set MSG_WAIT_ALL
+        flags = Socket::MSG_WAITALL
+      elsif le
+        data = ""
+        data << @socket.recv(le, flags) while data.length < le
+	return data
+      else
+        # set le to 1024 (default) and wait a little bit
+        le = 1024
+        sleep SLEEP_TIME
+        flags = 0
+      end
+
+      #puts "Waiting to receive: #{le}"
+      @socket.recv(le, flags)
+    end
+
+    def t0?
+      true
+    end
+     
+  end # class TCPCard
+end # module Card
+end # module ISO7816
+
+
+
+
+
+# VERY VERY basic tests... Actual testing is in ../test/card_test.rb
+if $0 == __FILE__
+  card = ISO7816::Card::TCPCard.new "172.18.4.27", 1024
+  puts "connecting"
+  atr = card.connect
+  puts "connected"
+  puts atr.unpack("H*")[0]
+  puts "disconnecting"
+  card.disconnect
+  puts "disconnected"
+end