ruby-nfc 1.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YmQ5NDY5MzE2MTUwMDJlMjEwYjNkMjU0ZDkxZTU1YmRjYTAyODUyOA==
+  data.tar.gz: !binary |-
+    M2U3Mjc5ZTY3YWI0MTg3ZTYwZTZmYzExOThhYjNkM2Y5NzVhMWQzZQ==
+SHA512:
+  metadata.gz: !binary |-
+    NzMwMTFlZWVlZmUwNDIzOWEzYWQ5NzIwMDY5N2UzNTViNTYwYTQwYzI1OTQ1
+    ZmFkNzE4NjAzZDk4M2UxMzFjMTFlODliZmVkNjdhN2Y2NDk2ZWJhOWY4ZGE4
+    NDhlYTI2NjY2NGE1NzVhZDRmMTg4NTk2ZDNkMzQwY2UxOWYzZjE=
+  data.tar.gz: !binary |-
+    ZWNjMzUxZGQ2OGEyNDc5OGNlNzgwNzBhMTI5MWQ3MmU1NWRmZTc4ZjA2NWRl
+    M2YzMTc0NGZkMTM1ZDliNDVlNmRlZmU4NjA5NzY1ZmZkYTEzMjRjYmY4NGIy
+    ZWY5ZTc4NjJjYTZlN2QyYzJjMGRmODM2MWFlZDJmNjFhZmMyY2Q=

data/lib/ruby-nfc.rb

@@ -0,0 +1,4 @@
+require_relative './ruby-nfc/reader'
+require_relative './ruby-nfc/tags/mifare/classic'
+require_relative './ruby-nfc/tags/mifare/ultralight'
+require_relative './ruby-nfc/tags/isodep'

data/lib/ruby-nfc/libnfc.rb

@@ -0,0 +1,292 @@
+require 'ffi'
+
+module LibNFC
+  extend FFI::Library
+  ffi_lib ['libnfc', 'libnfc.so', 'libnfc.so.5', '/usr/local/lib/libnfc.so']
+
+  PROPERTIES = [ # please refer to nfc-types.h for description
+  	:NP_TIMEOUT_COMMAND,
+  	:NP_TIMEOUT_ATR,
+  	:NP_TIMEOUT_COM,
+  	:NP_HANDLE_CRC,
+  	:NP_HANDLE_PARITY,
+  	:NP_ACTIVATE_FIELD,
+  	:NP_ACTIVATE_CRYPTO1,
+  	:NP_INFINITE_SELECT,
+  	:NP_ACCEPT_INVALID_FRAMES,
+  	:NP_ACCEPT_MULTIPLE_FRAMES,
+  	:NP_AUTO_ISO14443_4,
+  	:NP_EASY_FRAMING,
+  	:NP_FORCE_ISO14443_A,
+  	:NP_FORCE_ISO14443_B,
+  	:NP_FORCE_SPEED_106
+  ]
+
+  DEP_MODE = [
+    :NDM_UNDEFINED,
+    :NDM_PASSIVE,
+    :NDM_ACTIVE
+  ]
+
+  BAUD_RATE = [
+    :NBR_UNDEFINED,
+    :NBR_106,
+    :NBR_212,
+    :NBR_424,
+    :NBR_847
+  ]
+
+  MODULATION_TYPE = [
+    :NMT_ISO14443A, 1,
+    :NMT_JEWEL,
+    :NMT_ISO14443B,
+    :NMT_ISO14443BI, # pre-ISO14443B aka ISO/IEC 14443 B' or Type B'
+    :NMT_ISO14443B2SR, # ISO14443-2B ST SRx
+    :NMT_ISO14443B2CT, # ISO14443-2B ASK CTx
+    :NMT_FELICA,
+    :NMT_DEP
+  ]
+
+  class ISO14443a < FFI::Struct
+  	pack 1
+    layout(
+      :abtAtqa, [:uint8, 2],
+      :btSak, :uint8,
+      :szUidLen, :size_t,
+      :abtUid, [:uint8, 10],
+      :szAtsLen, :size_t,
+      :abtAts, [:uint8, 254]
+    )
+  end
+
+  class Felica < FFI::Struct
+  	pack 1
+    layout(
+      :szLen, :size_t,
+      :btResCode, :uint8,
+      :abtId, [:uint8, 8],
+      :abtPad, [:uint8, 8],
+      :abtSysCode, [:uint8, 2]
+    )
+  end
+
+  class ISO14443b < FFI::Struct
+  	pack 1
+    layout(
+      :abtPupi, [:uint8, 4],
+      :abtApplicationData, [:uint8, 4],
+      :abtProtocolInfo, [:uint8, 3],
+      :ui8CardIdentifier, :uint8
+    )
+  end
+
+  class ISO14443bi < FFI::Struct
+  	pack 1
+    layout(
+      :abtDIV, [:uint8, 4],
+      :btVerLog, :uint8,
+      :btConfig, :uint8,
+      :szAtrLen, :size_t,
+      :abtAtr, [:uint8, 33]
+    )
+  end
+
+  class ISO14443b2sr < FFI::Struct
+  	pack 1
+    layout(
+      :abtUID, [:uint8, 8]
+    )
+  end
+
+  class ISO14443b2ct < FFI::Struct
+  	pack 1
+    layout(
+      :abtUID, [:uint8, 4],
+      :btProdCode, :uint8,
+      :btFabCode, :uint8
+    )
+  end
+
+  class Jewel < FFI::Struct
+  	pack 1
+    layout(
+      :btSensRes, [:uint8, 2],
+      :btId, [:uint8, 4]
+    )
+  end
+
+  DepEnum = enum(DEP_MODE)
+
+  class DepInfo < FFI::Struct
+  	pack 1
+    layout(
+      :abtNFCID3, [:uint8, 10],#     uint8_t  abtNFCID3[10];
+      :btDID, :uint8,#     uint8_t  btDID;
+      :btBS, :uint8,#     uint8_t  btBS;
+      :btBR, :uint8,#     uint8_t  btBR;
+      :btTO, :uint8,#     uint8_t  btTO;
+      :btPP, :uint8,#     uint8_t  btPP;
+      :abtGB, [:uint8, 48],#     uint8_t  abtGB[48];
+      :szGB, :size_t,#     size_t  szGB;
+      :ndm, DepEnum
+    )
+  end
+
+
+  class TargetInfo < FFI::Union
+  	pack 1
+    layout(
+      :nai, ISO14443a,
+      :nfi, Felica,
+      :nbi, ISO14443b,
+      :nii, ISO14443bi,
+      :nsi, ISO14443b2sr,
+      :nci, ISO14443b2ct,
+      :nji, Jewel,
+      :ndi, DepInfo
+    )
+  end
+
+  ModulationType = enum(MODULATION_TYPE)
+  BaudRate = enum(BAUD_RATE)
+
+  class Modulation < FFI::Struct
+  	pack 1
+    layout(
+      :nmt, ModulationType,
+      :nbr, BaudRate
+    )
+  end
+
+  class Target < FFI::Struct
+  	pack 1
+    layout(
+      :nti, TargetInfo,
+      :nm, Modulation
+    )
+
+    def processed!
+    	@processed = true
+    end
+
+    def processed?
+    	defined?(@processed) && @processed
+    end
+
+    def sak
+			self[:nti][:nai][:btSak]
+    end
+  end
+
+  ###
+  #Version checking before wrapping the rest of the library to prevent
+  #name method matching errors.
+  attach_function :nfc_version, [], :string
+
+  attach_function :nfc_perror, [ :pointer, :string], :void
+  attach_function :nfc_list_devices, [ :pointer, :pointer, :size_t], :size_t
+
+  attach_function :nfc_initiator_init, [:pointer], :int
+
+  attach_function :nfc_device_set_property_bool, [
+  	:pointer, #nfc_device *pnd
+  	enum(PROPERTIES), #property constant
+  	:bool # value
+  ], :int
+
+  attach_function :nfc_open, [ :pointer, :string ], :pointer
+  attach_function :nfc_close, [ :pointer ], :void
+
+  attach_function :iso14443a_crc, [
+  	:pointer, #uint8_t *pbtData
+  	:size_t, #size_t szLen
+  	:pointer #uint8_t *pbtCrc
+  ], :void
+
+  attach_function :nfc_initiator_poll_dep_target, [
+  	:pointer, #nfc_device *pnd
+  	enum(DEP_MODE), #nfc_dep_mode
+    enum(BAUD_RATE), #nfc_baud_rate
+    :pointer, #nfc_dep_info *pndiInitiator
+    :pointer, #nfc_target *pnt
+    :int #timout
+  ], :int
+
+	attach_function :nfc_initiator_poll_target, [
+		:pointer, #device
+		:pointer, #modulations
+		:size_t, #modulations size
+		:uint8, #targets count
+		:uint8, #period
+		:pointer #targets
+	], :int
+
+	attach_function :nfc_initiator_list_passive_targets, [
+	  :pointer, # device
+	  Modulation.by_value, # modulation
+	  :pointer, # array of targets
+	  :size_t # maximum amount of targets
+	], :int
+
+	attach_function :nfc_initiator_select_passive_target, [
+		:pointer, #device
+		Modulation.by_value, # modulation
+		:pointer, # pbInitData (uid)
+		:size_t, # uid size
+		:pointer, #target
+	], :int
+
+	attach_function :nfc_initiator_transceive_bytes, [
+		:pointer, #device
+		:pointer, #byte array to transmit
+		:size_t, #number of bytes to transmit
+		:pointer, #response buffer
+		:size_t, #response buffer size
+		:int, #timeout
+	], :int
+
+	attach_function :nfc_initiator_poll_target, [
+	  :pointer, # device
+	  :pointer, # array of modulations
+	  :size_t, #number of modulations
+	  :uint8, #number of tags for each modulation,
+	  :uint8, #period
+	  :pointer #target
+	], :int
+
+	attach_function :str_nfc_target, [:pointer, :pointer, :bool], :int
+
+	attach_function :nfc_initiator_select_dep_target, [
+		:pointer, 
+		enum(DEP_MODE), 
+		enum(BAUD_RATE), 
+		:pointer, 
+		:pointer, 
+		:int
+	], :int
+
+	attach_function :nfc_initiator_deselect_target, [:pointer], :int
+  attach_function :nfc_init, [ :pointer ], :pointer
+  attach_function :nfc_exit, [ :pointer ], :void
+
+  def self.crc(data)
+		data_ptr = FFI::MemoryPointer.new(:uint8, data.length)
+		data_ptr.put_bytes(0, data)
+
+		crc_ptr = FFI::MemoryPointer.new(:uint8, 2)
+		crc_ptr.put_bytes(0, "\x0\x0")
+
+		iso14443a_crc(data_ptr, data.length, crc_ptr)
+		crc_ptr.get_bytes(0, 2).to_s
+  end
+
+  def self.crc_hex(data)
+  	crc(data).unpack('H*').pop
+  end
+
+  def self.debug_target(target)
+  	str_pointer = FFI::MemoryPointer.new(:pointer)
+		str_nfc_target(str_pointer, target, true)
+		puts str_pointer.get_pointer(0).get_string(0)
+  end
+end

data/lib/ruby-nfc/nfc.rb

@@ -0,0 +1,27 @@
+require 'ffi'
+require 'logger'
+require_relative './libnfc'
+
+module NFC
+  class Error < ::Exception;end
+
+  @@context = nil
+  # TODO
+  @@logger = Logger.new(STDERR)
+
+  def self.version
+    LibNFC.nfc_version
+  end
+
+  def self.context
+    unless @@context
+      ptr = FFI::MemoryPointer.new(:pointer, 1)
+      LibNFC.nfc_init(ptr)
+      @@context = ptr.read_pointer
+    end
+  end
+
+  def self.logger
+  	@@logger
+  end
+end

data/lib/ruby-nfc/reader.rb

@@ -0,0 +1,85 @@
+module NFC
+	class Reader
+  	attr_reader :ptr
+
+    def initialize(device_name)
+      @name = device_name
+      @ptr = nil
+    end
+
+    def set_flag(name, value)
+			LibNFC.nfc_device_set_property_bool(@ptr, name, value)
+    end
+
+    def connect
+      @ptr ||= LibNFC.nfc_open(NFC.context, @name)
+      raise NFC::Error.new('Cant connect to ' << @name) if @ptr.null?
+      self
+    end
+
+    # Returns list of tags applied to reader
+    def discover(*card_types)
+      # TODO: по правильному здесь надо делать низкоуровневый
+      card_types.inject([]) do |tags, card_type|
+        raise NFC::Error.new('Wrong card type') unless card_type.respond_to? :discover
+        tags += card_type.discover(connect)
+      end
+    end
+
+    def poll(*card_types)
+    	connect
+
+			LibNFC.nfc_initiator_init(@ptr) # we'll be initiator not a target
+
+      set_flag(:NP_ACTIVATE_FIELD, false)
+ 			set_flag(:NP_HANDLE_CRC, true)
+ 			set_flag(:NP_HANDLE_PARITY, true)
+     	set_flag(:NP_AUTO_ISO14443_4, true)
+ 			set_flag(:NP_ACTIVATE_FIELD, true)
+
+      modulation = LibNFC::Modulation.new
+			modulation[:nmt] = :NMT_ISO14443A 
+			modulation[:nbr] = :NBR_106
+
+      targets = FFI::MemoryPointer.new(:uchar, LibNFC::Target.size * 10)
+
+			loop do
+   			res = LibNFC.nfc_initiator_list_passive_targets(@ptr, modulation, 
+   																											targets, 10)
+			
+				# iterate over all applied targets and iterate
+				0.upto(res - 1) do |i|
+					target = LibNFC::Target.new(targets + i * LibNFC::Target.size)
+					# iterate over requested card types for each target
+					# notice that some targets can match several types i.e.
+					# contactless credit cards (PayPass/payWave) with mifare chip
+					# on board
+					card_types.each do |card_type|
+						if card_type.match?(target)
+							tag = card_type.new(target, self)
+							yield tag
+							# if this tag was marked as processed - continue with next tag
+							break if target.processed?
+						end
+					end
+				end # upto
+			end # loop
+    end
+
+    def to_s
+      @name
+    end
+
+    def self.all
+      ptr = FFI::MemoryPointer.new(:char, 1024 * 10)
+      len = LibNFC.nfc_list_devices(NFC.context, ptr, 10)
+
+      if len <= 0
+        raise NFC::Error, "No compatible NFC readers found"
+      else
+        names = ptr.get_bytes(0, 1024 * len).split("\x00").reject {|e| e.empty?}
+        names.map {|name| Reader.new(name)}
+      end 
+    end
+	end
+end

data/lib/ruby-nfc/tags/isodep.rb

@@ -0,0 +1,71 @@
+require_relative '../nfc'
+require_relative './tag'
+
+module IsoDep
+	ISO_14443_4_COMPATIBLE = 0x20
+
+	class Error < ::Exception; end
+
+	class Tag < NFC::Tag
+
+		def self.match?(target)
+			target[:nti][:nai][:btSak] & IsoDep::ISO_14443_4_COMPATIBLE > 0
+		end
+
+    def select(aid = nil, &block)
+     	@reader.set_flag(:NP_AUTO_ISO14443_4, true)
+
+			modulation = LibNFC::Modulation.new
+			modulation[:nmt] = :NMT_ISO14443A
+			modulation[:nbr] = :NBR_106
+
+			nai_ptr = @target[:nti][:nai].pointer
+
+			# abt + sak + szUidLen offset
+			uid_ptr = nai_ptr + FFI.type_size(:uint8) * 3 + FFI.type_size(:size_t)
+
+			res = LibNFC.nfc_initiator_select_passive_target(
+				@reader.ptr,
+				modulation,
+				uid_ptr,
+				uid.length,
+				@target.pointer
+			)
+
+			if res > 0
+				# trying to select applet if applet identifier was given
+				if aid
+					sw = send_apdu("\x00\xA4\x04\x00#{aid.size.chr}#{aid}")
+					raise IsoDep::Error, "Application not found: #{aid.unpack('H*').pop}" unless "\x90\x00" == sw
+				end
+
+				super(&block)
+			else
+				raise IsoDep::Error, "Can't select tag: #{res}"
+			end
+    end
+
+    def deselect
+			0 == LibNFC.nfc_initiator_deselect_target(@reader.ptr)
+    end
+
+    def send_apdu(apdu)
+    	cmd = apdu
+    	cmd.force_encoding('ASCII-8BIT')
+			command_buffer = FFI::MemoryPointer.new(:uint8, cmd.length)
+			command_buffer.write_string_length(cmd, cmd.length)
+
+			response_buffer = FFI::MemoryPointer.new(:uint8, 254)
+
+			res_len = LibNFC.nfc_initiator_transceive_bytes(@reader.ptr,
+				command_buffer, cmd.length, response_buffer, 254, 0)
+
+			raise IsoDep::Error, "APDU sending failed: #{res_len}" if res_len < 0
+
+			response_buffer.get_bytes(0, res_len).to_s
+    end
+
+    alias :'<<' :send_apdu
+	end
+
+end

data/lib/ruby-nfc/tags/mifare/classic.rb

@@ -0,0 +1,170 @@
+require_relative './tag'
+
+module Mifare
+	# Adding some Classic related stuff to Mifare module
+	
+  # tag
+  attach_function :mifare_classic_connect, [:pointer], :int
+  # tag
+  attach_function :mifare_classic_disconnect, [:pointer], :int
+  # tag, blocknumber, key
+  attach_function :mifare_classic_authenticate, [:pointer, :uchar, :pointer, enum(:key_a, :key_b)], :int
+
+	# tag, blocknumber, block data
+  attach_function :mifare_classic_read, [:pointer, :uchar, :pointer], :int
+
+	# tag, blocknumber, block data
+  attach_function :mifare_classic_write, [:pointer, :uchar, :pointer], :int
+
+	#mifare_classic_init_value (MifareTag tag, const MifareClassicBlockNumber block, const int32_t value, const MifareClassicBlockNumber adr)
+	# tag, blocknumber, value, addr 
+	attach_function :mifare_classic_init_value, [:pointer, :uchar, :int32, :uchar], :int
+
+	#mifare_classic_increment (MifareTag tag, const MifareClassicBlockNumber block, const uint32_t amount)
+	attach_function :mifare_classic_increment, [:pointer, :uchar, :int32], :int
+
+	#mifare_classic_decrement (MifareTag tag, const MifareClassicBlockNumber block, const uint32_t amount)
+	attach_function :mifare_classic_decrement, [:pointer, :uchar, :int32], :int
+
+  #mifare_classic_read_value (MifareTag tag, const MifareClassicBlockNumber block, int32_t *value, MifareClassicBlockNumber *adr)
+	attach_function :mifare_classic_read_value, [:pointer, :uchar, :pointer, :pointer], :int
+
+	#mifare_classic_transfer (MifareTag tag, const MifareClassicBlockNumber block)
+	attach_function :mifare_classic_transfer, [:pointer, :uchar], :int
+
+  module Classic
+    class Tag < Mifare::Tag
+      def initialize(target, reader)
+      	super(target, reader)
+
+      	@auth_block = nil #last authenticated block
+      end
+
+      def select(&block)
+      	@reader.set_flag(:NP_AUTO_ISO14443_4, false)
+
+        res = Mifare.mifare_classic_connect(@pointer)
+        if 0 == res 
+					super
+				else
+					raise Mifare::Error, "Can't select tag: #{res}"
+        end
+      end
+
+      def deselect
+				Mifare.mifare_classic_disconnect(@pointer)
+				super
+      end
+
+      # keytype can be :key_a or :key_b
+      # key - hexadecimal string key representation like "FFFFFFFFFFFF"
+      def auth(block_num, key_type, key)
+        raise Mifare::Error.new('Wrong key type') unless [:key_a, :key_b].include? key_type
+        raise Mifare::Error.new('Wrong key length') unless [6, 12].include? key.size
+
+        key_ptr = FFI::MemoryPointer.new(:uchar, 6)
+       	key_ptr.put_bytes(0, 6 == key.size ? key : [key].pack('H*'))
+
+        res = Mifare.mifare_classic_authenticate(@pointer, block_num, key_ptr,
+        																				 key_type)
+				if 0 == res
+        	@auth_block = block_num
+        else
+					raise Mifare::Error.new("Can't autenticate to block 0x%02x" % block_num)
+				end
+      end
+
+			# block number to read
+      def read(block_num = nil)
+      	block_num ||= @auth_block
+      	raise Mifare::Error.new('Not authenticated') unless block_num
+
+				data_ptr = FFI::MemoryPointer.new(:uchar, 16)
+        res = Mifare.mifare_classic_read(@pointer, block_num, data_ptr)
+
+        raise Mifare::Error.new("Can't read block 0x%02x" % block_num) unless 0 == res
+
+        data_ptr.get_bytes(0, 16).force_encoding('ASCII-8BIT')
+      end
+
+			# @data - 16 bytes represented by hexadecimal string
+			# @block_num - number of block to write to
+      def write(data, block_num = nil)
+				raise Mifare::Error.new('Wrong data given') if data !~ /^[\da-f]{32}$/i
+
+      	block_num ||= @auth_block
+      	raise Mifare::Error.new('Not authenticated') unless block_num
+
+				data_ptr = FFI::MemoryPointer.new(:uchar, 16)
+				data_ptr.put_bytes(0, [data].pack('H*'))
+
+				res = Mifare.mifare_classic_write(@pointer, block_num, data_ptr)
+        (0 == res) || raise(Mifare::Error.new("Can't write block 0x%02x" % block_num))
+      end
+
+			# Create value block structure and write it to block
+      def init_value(value, addr = nil, block_num = nil)
+      	block_num ||= @auth_block
+      	raise Mifare::Error.new('Not authenticated') unless block_num
+
+      	addr ||= 0
+
+				res = Mifare.mifare_classic_init_value(@pointer, block_num, value, addr)
+        (0 == res) || raise(Mifare::Error.new("Can't init value block 0x%02x" % block_num))
+      end
+
+			# returns only value part of value block
+      def value(block_num = nil)
+      	v, _ = value_with_addr(block_num)
+      	v
+      end
+
+			# returns value and addr
+      def value_with_addr(block_num = nil)
+				block_num ||= @auth_block
+      	raise Mifare::Error.new('Not authenticated') unless block_num
+
+				value_ptr = FFI::MemoryPointer.new(:int32, 1)
+				addr_ptr = FFI::MemoryPointer.new(:uchar, 1)
+				res = Mifare.mifare_classic_read_value(@pointer, block_num, value_ptr, addr_ptr)
+        raise Mifare::Error.new("Can't read value block 0x%02x" % block_num) unless 0 == res
+
+				[value_ptr.get_int32(0), addr_ptr.get_uchar(0)]
+      end
+
+			# Mifare classic increment
+      def inc(amount = 1, block_num = nil)
+				block_num ||= @auth_block
+      	raise Mifare::Error.new('Not authenticated') unless block_num
+				
+				res = Mifare.mifare_classic_increment(@pointer, block_num, amount)
+        (0 == res) || raise(Mifare::Error.new("Can't increment block 0x%02x" % block_num))
+      end
+
+			# Mifare classic decrement
+      def dec(amount = 1, block_num = nil)
+				block_num ||= @auth_block
+      	raise Mifare::Error.new('Not authenticated') unless block_num
+				
+				res = Mifare.mifare_classic_decrement(@pointer, block_num, amount)
+        (0 == res) || raise(Mifare::Error.new("Can't decrement block 0x%02x" % block_num))
+      end
+
+      def transfer(block_num = nil)
+				block_num ||= @auth_block
+      	raise Mifare::Error.new('Not authenticated') unless block_num
+
+				res = Mifare.mifare_classic_transfer(@pointer, block_num)
+        (0 == res) || raise(Mifare::Error.new("Can't transfer to block 0x%02x" % block_num))
+      end
+
+			# Check's if our tag class is able to handle this LibNFC::Target
+			def self.match?(target)
+				keys = [:CLASSIC_1K, :CLASSIC_1K_EMULATED, :CLASSIC_1K_ANDROID,
+					:INFINEON_CLASSIC_1k, :CLASSIC_4K, :CLASSIC_4K_EMULATED]
+
+				Mifare::SAKS.values_at(*keys).include? target.sak
+			end
+    end
+  end
+end

data/lib/ruby-nfc/tags/mifare/tag.rb

@@ -0,0 +1,68 @@
+require 'ffi'
+require_relative '../../nfc'
+require_relative '../tag'
+
+module Mifare
+	class Error < Exception; end
+
+  extend FFI::Library
+
+  ffi_lib ['libfreefare', 'libfreefare.so', '/usr/local/lib/libfreefare.so']
+
+	# List of known mifare card's SAKs	
+	SAKS = {
+		CLASSIC_1K: 0x08,
+		CLASSIC_1K_EMULATED: 0x28,
+		CLASSIC_1K_ANDROID: 0x68, # Android with mifare emulated by USIM or eSE
+		INFINEON_CLASSIC_1k: 0x88,
+		CLASSIC_4K: 0x18,
+		CLASSIC_4K_EMULATED: 0x38,
+		ULTRALIGHT: 0x00
+	}
+
+  # common freefare functions prototypes
+	attach_function :freefare_tag_new, [:pointer, LibNFC::ISO14443a.by_value], :pointer
+	attach_function :freefare_free_tag, [:pointer], :void
+
+  # tag
+  attach_function :freefare_get_tag_uid, [:pointer], :string
+  # tag
+  attach_function :freefare_get_tag_friendly_name, [:pointer], :string
+
+  # device, pointer to array of pointers to tags
+  # and we need to go deeper :)
+  attach_function :freefare_get_tags, [:pointer], :pointer
+
+	class Tag < NFC::Tag
+		def initialize(target, reader)
+			super(target, reader)
+
+			@pointer = Mifare.freefare_tag_new(reader.ptr, target[:nti][:nai])
+
+			raise Mifare::Error, "Unknown mifare tag" if @pointer.null?
+		end
+
+		def name
+			Mifare.freefare_get_tag_friendly_name(@pointer)
+		end
+
+		def to_s
+			"#{uid_hex} #{name} SAK: 0x#{@target.sak.to_s(16)}"
+		end
+
+		# frees memory allocated for mifare tag
+		def deselect
+			Mifare.freefare_free_tag(@pointer)
+		end
+
+		def sak
+			target.sak
+		end
+
+		def self.match?(target)
+			SAKS.values.include?(target[:nti][:nai][:btSak])
+		end
+
+	end
+end
+

data/lib/ruby-nfc/tags/mifare/ultralight.rb

@@ -0,0 +1,63 @@
+require_relative './tag'
+
+module Mifare
+  # tag
+  attach_function :mifare_ultralight_connect, [:pointer], :int
+  # tag
+  attach_function :mifare_ultralight_disconnect, [:pointer], :int
+
+	# tag, page number, page data
+  attach_function :mifare_ultralight_read, [:pointer, :uchar, :pointer], :int
+
+	# tag, blocknumber, block data
+  attach_function :mifare_ultralight_write, [:pointer, :uchar, :pointer], :int
+
+  module Ultralight
+    class Tag < Mifare::Tag
+      def select(&block)
+      	@reader.set_flag(:NP_AUTO_ISO14443_4, false)
+
+        res = Mifare.mifare_ultralight_connect(@pointer)
+        if 0 == res 
+					super
+				else
+					raise Mifare::Error, "Can't select tag: #{res}"
+        end
+      end
+
+      def deselect
+				Mifare.mifare_ultralight_disconnect(@pointer)
+				super
+      end
+
+			# block number to read
+      def read(page_num = nil)
+				data_ptr = FFI::MemoryPointer.new(:uchar, 4)
+        res = Mifare.mifare_ultralight_read(@pointer, page_num, data_ptr)
+
+        raise Mifare::Error, ("Can't read page 0x%02x" % page_num) unless 0 == res
+
+        data_ptr.get_bytes(0, 4).force_encoding('ASCII-8BIT')
+      end
+
+			# @data - 16 bytes represented by hexadecimal string
+			# @block_num - number of block to write to
+      def write(data, page_num = nil)
+				raise Mifare::Error, "Wrong data given" if data !~ /^[\da-f]{8}$/i
+
+				data_ptr = FFI::MemoryPointer.new(:uchar, 4)
+				data_ptr.put_bytes(0, [data].pack('H*'))
+
+				res = Mifare.mifare_classic_write(@pointer, block_num, data_ptr)
+				raise Mifare::Error, ("Can't write page 0x%02x" % page_num) unless 0 == res
+
+				res
+      end
+
+			# Check's if our tag class is able to handle this LibNFC::Target
+			def self.match?(target)
+				target.sak == Mifare::SAKS[:ULTRALIGHT]
+			end
+    end
+  end
+end

data/lib/ruby-nfc/tags/tag.rb

@@ -0,0 +1,46 @@
+module NFC
+	class Tag
+		def initialize(target, reader)
+			@target = target
+			@reader = reader
+			@processed = false
+		end
+
+		def select(&block)
+			if block_given?
+				begin
+					self.instance_eval(&block)
+				ensure
+					deselect
+				end
+			end
+		end
+
+		def processed!
+			@target.processed!
+		end
+
+		def processed?
+			@target.processed?
+		end
+
+		def uid
+			uid_size = @target[:nti][:nai][:szUidLen]
+			@target[:nti][:nai][:abtUid].to_s[0...uid_size]
+		end
+
+		def uid_hex
+			uid.unpack('H*').pop
+		end
+
+		def to_s
+			uid_hex
+		end
+
+		# Matches any NFC tag
+		def self.match?(target)
+			true
+		end
+
+	end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: ruby-nfc
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Maxim Chechel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! "  \tThis gem is built on top of libnfc and libfreefare using ffi and
+  supports:\n\t\t * Reading and writing Mifare Classic and Ultralight tags\n\t\t *
+  Android HCE / Blackberry VTE emulated tags\n\t\t * Dual-interface smart cards like
+  MasterCard PayPass or Visa payWave\n"
+email: maximchick@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ./lib/ruby-nfc.rb
+- ./lib/ruby-nfc/libnfc.rb
+- ./lib/ruby-nfc/nfc.rb
+- ./lib/ruby-nfc/reader.rb
+- ./lib/ruby-nfc/tags/isodep.rb
+- ./lib/ruby-nfc/tags/mifare/classic.rb
+- ./lib/ruby-nfc/tags/mifare/tag.rb
+- ./lib/ruby-nfc/tags/mifare/ultralight.rb
+- ./lib/ruby-nfc/tags/tag.rb
+homepage: https://github.com/maximchick/ruby-nfc
+licenses:
+- MIT
+metadata: {}
+post_install_message: ! "Don't forget to install libnfc and libfreefare\nsee installation
+  instructions here: \n\t https://github.com/maximchick/ruby-nfc"
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- libnfc, v1.7.x
+- libfreefare
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Provides NFC functionality for Ruby
+test_files: []