smartcard 0.4.11 → 0.5.0

data/CHANGELOG

@@ -1,3 +1,5 @@
+v0.5.0. Dropped C extension in favor of FFI. Hello, jruby and rbx!
+
 v0.4.11. Support for GlobalPlatform's SC01 (Secure Channel 1) protocol.
 
 v0.4.10. Removed hardcoded card manager AID.

data/Manifest

@@ -4,19 +4,6 @@ LICENSE
 Manifest
 README
 Rakefile
-ext/smartcard_pcsc/extconf.rb
-ext/smartcard_pcsc/pcsc.h
-ext/smartcard_pcsc/pcsc_card.c
-ext/smartcard_pcsc/pcsc_constants.c
-ext/smartcard_pcsc/pcsc_context.c
-ext/smartcard_pcsc/pcsc_exception.c
-ext/smartcard_pcsc/pcsc_io_request.c
-ext/smartcard_pcsc/pcsc_main.c
-ext/smartcard_pcsc/pcsc_multi_strings.c
-ext/smartcard_pcsc/pcsc_namespace.c
-ext/smartcard_pcsc/pcsc_reader_states.c
-ext/smartcard_pcsc/pcsc_surrogate_reader.h
-ext/smartcard_pcsc/pcsc_surrogate_wintypes.h
 lib/smartcard.rb
 lib/smartcard/gp/asn1_ber.rb
 lib/smartcard/gp/cap_loader.rb
@@ -30,7 +17,15 @@ lib/smartcard/iso/jcop_remote_server.rb
 lib/smartcard/iso/jcop_remote_transport.rb
 lib/smartcard/iso/pcsc_transport.rb
 lib/smartcard/iso/transport.rb
+lib/smartcard/pcsc/card.rb
+lib/smartcard/pcsc/context.rb
+lib/smartcard/pcsc/ffi_autogen.rb
+lib/smartcard/pcsc/ffi_functions.rb
+lib/smartcard/pcsc/ffi_lib.rb
+lib/smartcard/pcsc/ffi_structs.rb
 lib/smartcard/pcsc/pcsc_exception.rb
+lib/smartcard/pcsc/reader_state_queries.rb
+tasks/ffi_codegen.rb
 test/gp/asn1_ber_test.rb
 test/gp/cap_loader_test.rb
 test/gp/des_test.rb
@@ -42,6 +37,6 @@ test/iso/auto_configurator_test.rb
 test/iso/iso_card_mixin_test.rb
 test/iso/iso_exception_test.rb
 test/iso/jcop_remote_test.rb
-test/pcsc/containers_test.rb
-test/pcsc/smoke_test.rb
-tests/ts_pcsc_ext.rb
+test/pcsc/card_test.rb
+test/pcsc/context_test.rb
+test/pcsc/reader_state_queries_test.rb

data/Rakefile

@@ -1,7 +1,8 @@
 require 'rubygems'
-gem 'echoe'
 require 'echoe'
 
+require 'tasks/ffi_codegen.rb' 
+
 Echoe.new('smartcard') do |p|
   p.project = 'smartcard' # rubyforge project
   
@@ -9,7 +10,8 @@ Echoe.new('smartcard') do |p|
   p.email = 'victor@costan.us'
   p.summary = 'Interface with ISO 7816 smart cards.'
   p.url = 'http://www.costan.us/smartcard'
-  p.dependencies = ['rubyzip >=0.9.1',
+  p.dependencies = ['ffi >=0.5.3',
+                    'rubyzip >=0.9.1',
                     'zerg_support >=0.1.5']
   p.development_dependencies = ['echoe >=3.2',
                                 'flexmock >=0.8.6']
@@ -18,21 +20,12 @@ Echoe.new('smartcard') do |p|
   p.need_zip = !Gem.win_platform?
   p.clean_pattern += ['ext/**/*.manifest', 'ext/**/*_autogen.h']
   p.rdoc_pattern =
-      /^(lib|bin|tasks|ext)|^BUILD|^README|^CHANGELOG|^TODO|^LICENSE|^COPYING$/
-  
-  p.eval = proc do |p|
-    if Gem.win_platform?
-      p.files += ['lib/smartcard/pcsc.so']
-      p.platform = Gem::Platform::CURRENT
-
-      # take out the extension info from the gemspec
-      task :postcompile_hacks => [:compile] do
-        p.extensions.clear
-      end
+      /^(lib|bin|tasks|ext)|^BUILD|^README|^CHANGELOG|^TODO|^LICENSE|^COPYING$/  
+end
 
-      task :package => [ :clean, :compile, :postcompile_hacks ]
-    end
-  end
+unless FFI::Platform.windows?
+  task :package => :ffi_header
+  task :test => :ffi_header
 end
 
 if $0 == __FILE__

data/lib/smartcard.rb

@@ -1,6 +1,15 @@
-require 'smartcard/pcsc'
-require 'smartcard/pcsc/pcsc_exception.rb'
+# :nodoc: namespace
+module Smartcard
+end
 
+require 'smartcard/pcsc/card.rb'
+require 'smartcard/pcsc/context.rb'
+require 'smartcard/pcsc/ffi_lib.rb'
+require 'smartcard/pcsc/ffi_autogen.rb'
+require 'smartcard/pcsc/ffi_structs.rb'
+require 'smartcard/pcsc/ffi_functions.rb'
+require 'smartcard/pcsc/pcsc_exception.rb'
+require 'smartcard/pcsc/reader_state_queries.rb'
 
 require 'smartcard/iso/apdu_error.rb'
 require 'smartcard/iso/iso_card_mixin.rb'

data/lib/smartcard/iso/pcsc_transport.rb

@@ -24,7 +24,7 @@ class PcscTransport
 
   def exchange_apdu(apdu)
     xmit_apdu_string = apdu.pack('C*')
-    result_string = @card.transmit xmit_apdu_string, @xmit_ioreq, @recv_ioreq
+    result_string = @card.transmit xmit_apdu_string
     return result_string.unpack('C*')
   end
   
@@ -33,51 +33,41 @@ class PcscTransport
   end
   
   def connect
-    @context = PCSC::Context.new(PCSC::SCOPE_SYSTEM) if @context.nil?
+    @context = PCSC::Context.new if @context.nil?
     
     if @options[:reader_name]
       @reader_name = @options[:reader_name]
     else
-      # get the first reader      
-      readers = @context.list_readers nil
+      # Get the first reader.
+      readers = @context.readers
       @reader_name = readers[@options[:reader_index] || 0]
     end
     
-    # get the reader's status
-    reader_states = PCSC::ReaderStates.new(1)
-    reader_states.set_reader_name_of!(0, @reader_name)
-    reader_states.set_current_state_of!(0, PCSC::STATE_UNKNOWN)
-    @context.get_status_change reader_states, 100
-    reader_states.acknowledge_events!
+    # Query the reader's status.
+    queries = PCSC::ReaderStateQueries.new 1
+    queries[0].reader_name = @reader_name
+    queries[0].current_state = :unknown
+    @context.wait_for_status_change queries, 100
+    queries.ack_changes
     
-    # prompt for card insertion unless that already happened
-    if (reader_states.current_state_of(0) & PCSC::STATE_PRESENT) == 0
-      puts "Please insert TEM card in reader #{@reader_name}\n"
-      while (reader_states.current_state_of(0) & PCSC::STATE_PRESENT) == 0 do
-        @context.get_status_change reader_states, PCSC::INFINITE_TIMEOUT
-        reader_states.acknowledge_events!
+    # Prompt for card insertion unless that already happened.
+    unless queries[0].current_state.include? :present
+      puts "Please insert smart-card card in reader #{@reader_name}\n"
+      until queries[0].current_state.include? :presentt do
+        @context.wait_for_status_change queries
+        queries.ack_changes
       end
       puts "Card detected\n"
     end
     
-    # connect to card
-    @card = PCSC::Card.new @context, @reader_name, PCSC::SHARE_EXCLUSIVE,
-                           PCSC::PROTOCOL_ANY
-    
-    # build the transmit / receive IoRequests
-    status = @card.status
-    @xmit_ioreq = @@xmit_iorequest[status[:protocol]]
-    @atr = status[:atr]
-    if RUBY_PLATFORM =~ /win/ and (not RUBY_PLATFORM =~ /darwin/)
-      @recv_ioreq = nil
-    else
-      @recv_ioreq = PCSC::IoRequest.new
-    end
+    # Connect to the card.
+    @card = @context.card @reader_name, :shared 
+    @atr = @card.info[:atr]
   end
   
   def disconnect
     unless @card.nil?
-      @card.disconnect PCSC::DISPOSITION_LEAVE
+      @card.disconnect
       @card = nil
       @atr = nil
     end
@@ -90,12 +80,7 @@ class PcscTransport
   def to_s
     "#<PC/SC Terminal: disconnected>" if @card.nil?
     "#<PC/SC Terminal: #{@reader_name}>"
-  end
-  
-  @@xmit_iorequest = {
-    Smartcard::PCSC::PROTOCOL_T0 => Smartcard::PCSC::IOREQUEST_T0,
-    Smartcard::PCSC::PROTOCOL_T1 => Smartcard::PCSC::IOREQUEST_T1,
-  }
+  end  
 end  # class PcscTransport
 
-end  # module Smartcard::Iso
+end  # module Smartcard::Iso

data/lib/smartcard/pcsc/card.rb

@@ -0,0 +1,281 @@
+# Connects Ruby to a smart-card in a PC/SC reader (wraps SCARDHANDLE).
+#
+# Author:: Victor Costan
+# Copyright:: Copyright (C) 2009 Massachusetts Institute of Technology
+# License:: MIT
+
+require 'set'
+
+# :nodoc: namespace
+module Smartcard::PCSC
+  
+  
+# Connects a smart-card in a PC/SC reader to the Ruby world.
+class Card
+  # Establishes a connection to the card in a PC/SC reader.
+  #
+  # The first connection will power up the card and perform a reset on it.
+  #
+  # Args:
+  #   context:: the Smartcard::PCSC::Context for the PC/SC resource manager
+  #   reader_name:: friendly name of the reader to connect to; reader names can
+  #                 be obtained from Smartcard::PCSC::Context#readers 
+  #   sharing_mode:: whether a shared or exclusive lock will be requested on the
+  #                  reader; the possible values are +:shared+, +:exclusive+ and
+  #                  +:direct+ (see the SCARD_SHARE_ constants in the PC/SC API) 
+  #   preferred_protocols:: the desired communication protocol; the possible
+  #                         values are +:t0+, +:t1+, +:t15+, +:raw+, and +:any+
+  #                         (see the SCARD_PROTOCOL_ constants in the PC/SC API)
+  def initialize(context, reader_name, sharing_mode = :exclusive,
+                 preferred_protocols = :any)
+    handle_ptr = FFILib::WordPtr.new
+    protocol_ptr = FFILib::WordPtr.new
+    status = FFILib.card_connect context._handle, reader_name, sharing_mode,
+                                 preferred_protocols, handle_ptr, protocol_ptr
+    raise Smartcard::PCSC::Exception, status unless status == :success
+    
+    @context = context
+    set_protocol FFILib::Protocol[protocol_ptr[:value]]
+    @_handle = handle_ptr[:value]      
+  end
+  
+  # Updates internal buffers to reflect a change in the communication protocol. 
+  def set_protocol(protocol)
+    @protocol = protocol
+    
+    case protocol
+    when :t0
+      @send_pci = @recv_pci = FFILib::PCI_T0
+    when :t1
+      @send_pci = @recv_pci = FFILib::PCI_T1
+    when :raw
+      @send_pci = @recv_pci = FFILib::PCI_RAW
+    end
+    
+    # Windows really doesn't like a receiving IoRequest.
+    if FFI::Platform.windows? || FFI::Platform.mac?
+      @recv_pci = nil
+    end
+  end
+  private :set_protocol
+  
+  # Reconnects to the smart-card, potentially using a different protocol.
+  #
+  # Args:
+  #   sharing_mode:: whether a shared or exclusive lock will be requested on the
+  #                  reader; the possible values are +:shared+, +:exclusive+ and
+  #                  +:direct+ (see the SCARD_SHARE_ constants in the PC/SC API) 
+  #   preferred_protocols:: the desired communication protocol; the possible
+  #                         values are +:t0+, +:t1+, +:t15+, +:raw+, and +:any+
+  #                         (see the SCARD_PROTOCOL_ constants in the PC/SC API)  
+  #   disposition:: what to do with the smart-card right before disconnecting;
+  #                 the possible values are +:leave+, +:reset+, +:unpower+, and
+  #                 +:eject+ (see the SCARD_*_CARD constants in the PC/SC API)
+  def reconnect(sharing_mode = :exclusive, preferred_protocols = :any,
+                disposition = :leave)
+    protocol_ptr = FFILib::WordPtr.new
+    status = FFILib.card_reconnect @_handle, sharing_mode,
+        preferred_protocols, disposition, protocol_ptr
+    raise Smartcard::PCSC::Exception, status unless status == :success
+  
+    set_protocol FFILib::Protocol[protocol_ptr[:value]]
+  end
+  
+  # Disconnects from the smart-card.
+  #
+  # Future method calls on this object will raise PC/SC errors.
+  #
+  # Args:
+  #   disposition:: what to do with the smart-card right before disconnecting;
+  #                 the possible values are +:leave+, +:reset+, +:unpower+, and
+  #                 +:eject+ (see the SCARD_*_CARD constants in the PC/SC API)
+  def disconnect(disposition = :leave)
+    status = FFILib.card_disconnect @_handle, disposition
+    raise Smartcard::PCSC::Exception, status unless status == :success
+
+    @_handle = nil
+    @protocol = nil
+  end
+
+  # Starts a transaction, obtaining an exclusive lock on the smart-card.
+  def begin_transaction
+    status = FFILib.begin_transaction @_handle
+    raise Smartcard::PCSC::Exception, status unless status == :success    
+  end
+  
+  # Ends a transaction started with begin_transaction.
+  #
+  # The calling application must be the owner of the previously started
+  # transaction or an error will occur.
+  #
+  # Args:
+  #   disposition:: what to do with the smart-card after the transaction; the
+  #                 possible values are +:leave+, +:reset+, +:unpower+, and
+  #                 +:eject+ (see the SCARD_*_CARD constants in the PC/SC API)
+  def end_transaction(disposition = :leave)
+    status = FFILib.end_transaction @_handle, disposition
+    raise Smartcard::PCSC::Exception, status unless status == :success
+  end
+  
+  # Performs a block inside a transaction, with an exclusive smart-card lock.
+  #
+  # Args:
+  #   disposition:: what to do with the smart-card after the transaction; the
+  #                 possible values are +:leave+, +:reset+, +:unpower+, and
+  #                 +:eject+ (see the SCARD_*_CARD constants in the PC/SC API)
+  def transaction(disposition = :leave)
+    begin_transaction
+    yield
+    end_transaction disposition
+  end
+  
+  
+  def [](attribute_name)
+    length_ptr = FFILib::WordPtr.new
+    status = FFILib.get_attrib @_handle, attribute_name, nil, length_ptr
+    raise Smartcard::PCSC::Exception, status unless status == :success
+
+    value_ptr = FFI::MemoryPointer.new :char, length_ptr[:value]
+    begin
+      status = FFILib.get_attrib @_handle, attribute_name, value_ptr,
+                                 length_ptr
+      raise Smartcard::PCSC::Exception, status unless status == :success
+  
+      value_ptr.get_bytes 0, length_ptr[:value]
+    ensure
+      value_ptr.free
+    end      
+  end
+  
+  # Sets the value of an attribute in the interface driver.
+  #
+  # The interface driver may not implement all possible attributes.
+  #
+  # Args:
+  #   attribute_name:: the attribute to be set; possible values are the members
+  #                    of Smartcard::PCSC::FFILib::Attribute, for example
+  #                    +:vendor_name+)
+  #   value:: string containing the value bytes to be assigned to the attribute
+  def []=(attribute_name, value)
+    value_ptr = FFI::MemoryPointer.from_string value
+    begin
+      status = FFILib.set_attrib @_handle, attribute_name, value_ptr,
+                                 value.length
+      raise Smartcard::PCSC::Exception, status unless status == :success    
+      value
+    ensure
+      value_ptr.free    
+    end
+  end
+  
+  # Sends an APDU to the smart card, and returns the card's response.
+  #
+  # Args:
+  #   send_data:: string containing the APDU bytes to be sent to the card
+  #   receive_buffer_size: the maximum number of bytes that can be received  
+  def transmit(data, receive_buffer_size = 65546)
+    send_ptr = FFI::MemoryPointer.from_string data
+    recv_ptr = FFI::MemoryPointer.new receive_buffer_size
+    recv_size_ptr = FFILib::WordPtr.new
+    recv_size_ptr[:value] = receive_buffer_size 
+    begin
+      status = FFILib.transmit @_handle, @send_pci, send_ptr, data.length,
+                               @recv_pci, recv_ptr, recv_size_ptr
+      raise Smartcard::PCSC::Exception, status unless status == :success    
+      recv_ptr.get_bytes 0, recv_size_ptr[:value]
+    ensure
+      send_ptr.free
+      recv_ptr.free
+    end    
+  end
+  
+  # Sends a interface driver command for the smart-card reader.
+  #
+  # This method is useful for creating client side reader drivers for functions
+  # like PIN pads, biometrics, or other smart card reader extensions that are
+  # not normally handled by the PC/SC API.
+  #
+  # Args:
+  #   code:: control code for the operation; a driver-specific integer
+  #   data:: string containing the data bytes to be sent to the driver
+  #   receive_buffer_size:: the maximum number of bytes that can be received
+  #
+  # Returns a string containg the response bytes.
+  def control(code, data, receive_buffer_size = 4096)
+    # NOTE: In general, I tried to avoid specifying receive buffer sizes. This
+    #       is the only case where that is impossible to achieve, because there
+    #       is no well-known maximum buffer size, and the SCardControl call is
+    #       not guaranteed to be idempotent, so it's not OK to re-issue it after
+    #       guessing a buffer size works out.
+    send_ptr = FFI::MemoryPointer.from_string data
+    recv_ptr = FFI::MemoryPointer.new receive_buffer_size
+    recv_size_ptr = FFILib::WordPtr.new
+    recv_size_ptr[:value] = receive_buffer_size 
+    begin
+      status = FFILib.card_control @_handle, code, send_ptr, data.length,
+                                   recv_ptr, receive_buffer_size, recv_size_ptr
+      raise Smartcard::PCSC::Exception, status unless status == :success    
+      recv_ptr.get_bytes 0, recv_size_ptr[:value]
+    ensure
+      send_ptr.free
+      recv_ptr.free
+    end
+  end
+  
+  # Assorted information about this smart-card.
+  # 
+  # Returns a hash with the following keys:
+  #   :state:: reader/card status, as a Set of symbols; the possible values are
+  #            +:present+, +:swallowed+, +:absent+, +:specific+, and +:powered+
+  #            (see the SCARD_* constants in the PC/SC API)
+  #   :protocol:: the protocol established with the card
+  #   :atr:: the card's ATR bytes, wrapped in a string
+  #   :reader_names:: array of strings containing all the names of the reader
+  #                   connected to this smart-card
+  def info
+    readers_length_ptr = FFILib::WordPtr.new
+    state_ptr = FFILib::WordPtr.new
+    protocol_ptr = FFILib::WordPtr.new
+    atr_ptr = FFI::MemoryPointer.new FFILib::Consts::MAX_ATR_SIZE
+    atr_length_ptr = FFILib::WordPtr.new
+    atr_length_ptr[:value] = FFILib::Consts::MAX_ATR_SIZE    
+
+    begin
+      status = FFILib.card_status @_handle, nil, readers_length_ptr, state_ptr,
+          protocol_ptr, atr_ptr, atr_length_ptr
+      raise Smartcard::PCSC::Exception, status unless status == :success    
+
+      readers_ptr = FFI::MemoryPointer.new :char, readers_length_ptr[:value]
+      begin
+        status = FFILib.card_status @_handle, readers_ptr, readers_length_ptr,
+            state_ptr, protocol_ptr, atr_ptr, atr_length_ptr
+        raise Smartcard::PCSC::Exception, status unless status == :success    
+      
+        state_word = state_ptr[:value]
+        state = Set.new
+        FFILib::CardState.to_h.each do |key, mask|
+          state << key if (state_word & mask) == mask && mask != 0
+        end
+        
+        { :readers => Context.decode_multi_string(readers_ptr),
+          :protocol => FFILib::Protocol[protocol_ptr[:value]],
+          :atr => atr_ptr.get_bytes(0, atr_length_ptr[:value]),
+          :state => state }
+      ensure
+        readers_ptr.free
+      end
+    ensure
+      atr_ptr.free
+    end
+  end
+  
+  # The low-level _SCARDHANDLE_ data.
+  #
+  # This should not be used by client code.
+  attr_reader :_handle
+  
+  # The communication protocol in use with this smart-card.
+  attr_reader :protocol
+end  # class Smartcard::PCSC::Card
+
+end  # namespace Smartcard::PCSC