mfrc522 1.0.6 → 2.0.0

data/lib/mifare/ultralight_ev1.rb

@@ -0,0 +1,40 @@
+module MIFARE
+  module UltralightEV1
+    def auth(passwd)
+      passwd_bytes = [passwd].pack('H*').bytes
+      if passwd_bytes.size != 4
+        raise UsageError, "Expect 4 bytes password in hex, got: #{passwd_bytes.size} byte"
+      end
+
+      transceive([CMD_PWD_AUTH, *passwd_bytes])
+    end
+
+    def authed?
+      @authed || false
+    end
+
+    def fast_read(from, to)
+      if (to - from + 1) > @max_range
+        raise UsageError, "Reading from #{from} to #{to} exceeds PCD receive buffer"
+      end
+
+      transceive([CMD_FAST_READ, from, to])
+    end
+
+    def read_counter(counter)
+      transceive([CMD_READ_CNT, counter])
+    end
+
+    def increment_counter(counter)
+      transceive([CMD_INCR_CNT, counter])
+    end
+
+    def counter_torn?(counter)
+      transceive([CMD_CHECK_TEARING_EVENT, counter]) != 0xBD
+    end
+
+    def read_signature
+      transceive([CMD_READ_SIG, 0x00])
+    end
+  end
+end

data/lib/picc.rb

@@ -1,4 +1,11 @@
 class PICC
+  FSCI_to_FSC = [16, 24, 32, 40, 48, 64, 96, 128, 256]
+
+  CMD_RATS              = 0xE0
+  CMD_PPS               = 0xD0
+  CMD_DESELECT          = 0xC2
+  CMD_ADDITIONAL_FRAME  = 0xAF
+
   attr_reader :uid
   attr_reader :sak
 
@@ -7,22 +14,319 @@ class PICC
     @uid = uid
     @sak = sak
     @halted = false
+
+    ## ISO mode
+    @cid = 0x00 # We don't support CID, fix it to 0
+    @fsc = 16 # Assume PICC only supports 16 bytes frame
+    @fwt = 256 # 77.33ms(256 ticks) default frame waiting time
+    @picc_support_cid = false # PICC support for CID
+    @picc_support_nad = false # PICC support for NAD
+    @historical_byte = []
+    @block_number = 0 # ISO frame block number
+    @iso_selected = false # If card is in iso mode
   end
 
-  def resume_communication
-    if @pcd.reestablish_picc_communication(@uid)
-      @halted = false
-      true
+  def picc_transceive(send_data, accept_timeout = false, need_bits = false)
+    received_data, valid_bits = @pcd.picc_transceive(send_data, accept_timeout)
+    if need_bits
+      return received_data, valid_bits
     else
-      false
+      return received_data
+    end
+  end
+
+  # Wrapper for handling ISO protocol
+  def iso_transceive(send_data)
+    # Split data according to max buffer size
+    send_data = [send_data] unless send_data.is_a? Array
+    chained_data = send_data.each_slice(@max_inf_size).to_a
+
+    # Initialize I-block
+    pcb = 0x02
+
+    # Send chained data
+    until chained_data.empty?
+      pcb &= 0xEF # Reset chaining indicator
+      pcb |= 0x10 if chained_data.size > 1 # Set chaining
+      pcb |= @block_number # Set block number
+      data = chained_data.shift
+
+      buffer = [pcb] + data
+
+      finished = false
+      until finished
+        received_data = handle_wtx(buffer)
+
+        # Retreive response pcb from data
+        r_pcb = received_data[0]
+
+        # Received ACK
+        if r_pcb & 0xF6 == 0xA2
+          # If ACK matches current block number means success
+          # Otherwise transmit it again
+          if (pcb & 0x01) == (r_pcb & 0x01)
+            finished = true
+          end
+        else
+          finished = true
+        end
+      end
+
+      @block_number ^= 1 # toggle block number for next frame
+    end
+
+    received_chained_data = [received_data]
+
+    # Receive chained data
+    while r_pcb & 0x10 != 0
+      ack = 0xA2 | @block_number # Set block number
+      received_data = handle_wtx([ack]) # Send ACK to receive next frame
+
+      r_pcb = received_data[0]
+
+      received_chained_data << received_data
+
+      @block_number ^= 1 # toggle block number for next frame
+    end
+
+    # Collect INF from chain
+    inf = []
+    received_chained_data.each do |data|
+      inf_position = 1
+      inf_position += 1 if data[0] & 0x08 != 0 # CID present
+      inf_position += 1 if data[0] & 0x04 != 0 # NAD present
+
+      inf.concat(data[inf_position..-1])
+    end
+    inf
+  end
+
+  # ISO/IEC 14443-4 select
+  def iso_select
+    # Send RATS (Request for Answer To Select)
+    buffer = [CMD_RATS, 0x50 | @cid]
+    received_data = picc_transceive(buffer)
+
+    process_ats(received_data)
+
+    # Send PPS (Protocol and Parameter Selection Request)
+    buffer = [CMD_PPS | @cid, 0x11, (@dsi << 2) | @dri]
+    received_data = picc_transceive(buffer)
+    raise UnexpectedDataError, 'Incorrect response' if received_data[0] != (0xD0 | @cid)
+
+    # Set PCD baud rate
+    @pcd.transceiver_baud_rate(:tx, @dri)
+    @pcd.transceiver_baud_rate(:rx, @dsi)
+
+    @block_number = 0
+    @max_frame_size = [@pcd.buffer_size, @fsc].min
+    @max_inf_size = @max_frame_size - 3 # PCB + CRC16
+    @max_inf_size -= 1 if @picc_support_cid
+    @max_inf_size -= 1 if @picc_support_nad
+    @iso_selected = true
+  end
+
+  # Send S(DESELECT)
+  def iso_deselect
+    buffer = [CMD_DESELECT]
+    received_data = picc_transceive(buffer)
+
+    result = received_data[0] & 0xF7 == CMD_DESELECT
+    @iso_selected = !result
+    result
+  end
+
+  def restart_communication
+    picc_was_in_iso_mode = @iso_selected
+    iso_deselect if picc_was_in_iso_mode
+    unless @pcd.reestablish_picc_communication(@uid)
+      halt
+      raise CommunicationError, 'Unable to resume communication or wrong card was presented. Halting cards in the field.'
     end
+    iso_select if picc_was_in_iso_mode
   end
 
   def halt
-    if @pcd.picc_halt
-      @halted = true
-    else
-      @halted = false
+    iso_deselect if @iso_selected
+    @halted = @pcd.picc_halt
+  end
+
+  def self.identify_model(sak)
+    # SAK coding separation reference:
+    # https://www.nxp.com/docs/en/application-note/AN10833.pdf
+    # https://www.nxp.com/docs/en/application-note/AN10834.pdf
+    if sak & 0x04 != 0
+      return :picc_uid_not_complete
+    end
+
+    if sak & 0x02 != 0
+      return :picc_reserved_future_use
+    end
+
+    if sak & 0x08 != 0
+      if sak & 0x10 != 0
+        return :picc_mifare_4k
+      end
+
+      if sak & 0x01 != 0
+        return :picc_mifare_mini
+      end
+
+      return :picc_mifare_1k
+    end
+
+    if sak & 0x10 != 0
+      if sak & 0x01 != 0
+        return :picc_mifare_plus_4k_sl2
+      end
+
+      return :picc_mifare_plus_2k_sl2
     end
+
+    if sak == 0x00
+      return :picc_mifare_ultralight
+    end
+
+    if sak & 0x20 != 0
+      return :picc_iso_14443_4
+    end
+
+    if sak & 0x40 != 0
+      return :picc_iso_18092
+    end
+
+    return :picc_unknown
+  end
+
+  protected
+
+  def crc32(*datas)
+    crc = 0xFFFFFFFF
+
+    datas.each do |data|
+      data = [data] unless data.is_a? Array
+      data.each do |byte|
+        crc ^= byte
+        8.times do
+          flag = crc & 0x01 > 0
+          crc >>= 1
+          crc ^= 0xEDB88320 if flag
+        end
+      end
+    end
+    crc
+  end
+
+private
+
+  def choose_d(value)
+    # ISO DS/DR
+    # 0b000: 106kBd, 0b001: 212kBd, 0b010: 424kBd, 0b100: 848kBd
+    # MFRC522 register & ISO DSI/DRI
+    # 0b000: 106kBd, 0b001: 212kBd, 0b010: 424kBd, 0b011: 848kBd
+    # Find largest bit(fastest baud rate)
+    x = (value >> 2) & 0x01
+    y = (value >> 1) & 0x01
+    z = value & 0x01
+
+    ((x | y) << 1) + (x | (~y & z))
+  end
+
+  # Gether information from ATS (Answer to Select)
+  def process_ats(ats)
+    position = 1
+    t0 = ats[position] # Format byte
+
+    fsci = t0 & 0x0F # PICC buffer size integer
+    y1 = (t0 >> 4) & 0x07 # Optional frame(TA, TB, TC) indicator
+    @fsc = FSCI_to_FSC.fetch(fsci) # Convert buffer size integer to bytes
+
+    # Frame: TA
+    if y1 & 0x01 != 0
+      position += 1
+      ta = ats[position]
+
+      dr = ta & 0x07 # PCD to PICC baud rate
+      ds = (ta >> 4) & 0x07 # PICC to PCD baud rate
+      same_d = (ta >> 7) & 0x01
+
+      if same_d != 0
+        dr &= ds
+        ds &= dr
+      end
+
+      @dri = choose_d(dr)
+      @dsi = choose_d(ds)
+    end
+
+    # Frame: TB
+    if y1 & 0x02 != 0
+      position += 1
+      tb = ats[position]
+
+      fwi = (tb >> 4) & 0x0F # Frame wating integer
+      sgfi = tb & 0x0F # Start-up frame guard integer
+
+      # Convert integers to real time
+      @fwt = (1 << fwi)
+      sgft = (1 << sgfi)
+
+      # Set frame waiting time
+      @pcd.internal_timer(@fwt)
+    end
+
+    # Get info about CID or NAD
+    if y1 & 0x04 != 0
+      position += 1
+      tc = ats[position]
+
+      @picc_support_cid = true if tc & 0x02 != 0
+      @picc_support_nad = true if tc & 0x01 != 0
+    end
+
+    position += 1
+
+    if ats.size - position > 0
+      @historical_byte = ats[position..-1]
+    end
+
+    # Start-up guard time
+    sleep 0.000302 * sgft
+  end
+
+  def handle_wtx(data)
+    24.times do
+      begin
+        received_data = picc_transceive(data)
+      rescue CommunicationError => e
+        raise e unless e.is_a? PICCTimeoutError
+
+        # Try sending NAK when timeout
+        nak = 0xB2 | @block_number
+        data = [nak]
+        next
+      end
+
+      pcb = received_data[0]
+
+      # WTX detected
+      if pcb & 0xF7 == 0xF2
+        inf_position = (pcb & 0x08 != 0) ? 2 : 1
+        wtxm = received_data[inf_position] & 0x3F
+
+        # Set temporary timer
+        @pcd.internal_timer(@fwt * wtxm)
+
+        # Set WTX response
+        data = [0xF2, wtxm]
+      else
+        # Set timer back to FWT
+        @pcd.internal_timer(@fwt)
+
+        return received_data
+      end
+    end
+
+    raise PICCTimeoutError, 'Timeout while handling WTX frame.'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mfrc522
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 2.0.0
 platform: ruby
 authors:
 - atitan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-02 00:00:00.000000000 Z
+date: 2018-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pi_piper
@@ -38,13 +38,17 @@ extra_rdoc_files: []
 files:
 - lib/core_ext.rb
 - lib/exceptions.rb
-- lib/iso144434.rb
 - lib/mfrc522.rb
 - lib/mifare/classic.rb
 - lib/mifare/des_fire.rb
 - lib/mifare/key.rb
+- lib/mifare/plus.rb
+- lib/mifare/plus_sl0.rb
+- lib/mifare/plus_sl1.rb
+- lib/mifare/plus_sl3.rb
 - lib/mifare/ultralight.rb
 - lib/mifare/ultralight_c.rb
+- lib/mifare/ultralight_ev1.rb
 - lib/picc.rb
 homepage: https://github.com/atitan/MFRC522_Ruby
 licenses:

data/lib/iso144434.rb

@@ -1,247 +0,0 @@
-class ISO144434 < PICC
-  FSCI_to_FSC = [16, 24, 32, 40, 48, 64, 96, 128, 256]
-
-  CMD_RATS              = 0xE0
-  CMD_PPS               = 0xD0
-  CMD_DESELECT          = 0xC2
-  CMD_SUCCESS           = 0x00
-  CMD_ADDITIONAL_FRAME  = 0xAF
-
-  def initialize(pcd, uid, sak)
-    super
-
-    @cid = 0x00 # We don't support CID
-    @fsc = 16 # Assume PICC only supports 16 bytes frame
-    @fwt = 256 # 77.33ms(256 ticks) default frame waiting time
-
-    @support_cid = false
-    @support_nad = false
-    @block_number = 0
-    @selected = false
-  end
-
-  # ISO/IEC 14443-4 select
-  def select
-    # Send RATS (Request for Answer To Select)
-    buffer = [CMD_RATS, 0x50 | @cid]
-    received_data = @pcd.picc_transceive(buffer)
-
-    dr, ds = process_ats(received_data)
-
-    # Send PPS (Protocol and Parameter Selection Request)
-    buffer = [CMD_PPS | @cid, 0x11, (ds << 2) | dr]
-    received_data = @pcd.picc_transceive(buffer)
-    raise UnexpectedDataError, 'Incorrect response' if received_data[0] != (0xD0 | @cid)
-
-    # Set PCD baud rate
-    @pcd.transceiver_baud_rate(:tx, dr)
-    @pcd.transceiver_baud_rate(:rx, ds)
-
-    @block_number = 0
-    @max_frame_size = [64, @fsc].min
-    @max_inf_size = @max_frame_size - 3 # PCB + CRC16
-    @max_inf_size -= 1 if @support_cid
-    @max_inf_size -= 1 if @support_nad
-    @selected = true
-  end
-
-  # Send S(DESELECT)
-  def deselect
-    buffer = [CMD_DESELECT]
-    received_data = @pcd.picc_transceive(buffer)
-
-    if received_data[0] & 0xF7 == CMD_DESELECT
-      @selected = false
-      true
-    else
-      false
-    end
-  end
-
-  # Wrapper for handling ISO protocol
-  def transceive(send_data)
-    # Split data according to max buffer size
-    send_data = [send_data] unless send_data.is_a? Array
-    chained_data = send_data.each_slice(@max_inf_size).to_a
-
-    # Initialize I-block
-    pcb = 0x02
-
-    # Send chained data
-    until chained_data.empty?
-      pcb &= 0xEF # Reset chaining indicator
-      pcb |= 0x10 if chained_data.size > 1 # Set chaining
-      pcb |= @block_number # Set block number
-      data = chained_data.shift
-
-      buffer = [pcb] + data
-
-      finished = false
-      until finished
-        received_data = handle_wtx(buffer)
-
-        # Retreive response pcb from data
-        r_pcb = received_data[0]
-
-        # Received ACK
-        if r_pcb & 0xF6 == 0xA2
-          # If ACK matches current block number means success
-          # Otherwise transmit it again
-          if (pcb & 0x01) == (r_pcb & 0x01)
-            finished = true
-          end
-        else
-          finished = true
-        end
-      end
-
-      @block_number ^= 1 # toggle block number for next frame
-    end
-
-    received_chained_data = [received_data]
-
-    # Receive chained data
-    while r_pcb & 0x10 != 0
-      ack = 0xA2 | @block_number # Set block number
-      received_data = handle_wtx([ack]) # Send ACK to receive next frame
-
-      r_pcb = received_data[0]
-
-      received_chained_data << received_data
-
-      @block_number ^= 1 # toggle block number for next frame
-    end
-
-    # Collect INF from chain
-    inf = []
-    received_chained_data.each do |data|
-      inf_position = 1
-      inf_position += 1 if data[0] & 0x08 != 0 # CID present
-      inf_position += 1 if data[0] & 0x04 != 0 # NAD present
-
-      inf.concat(data[inf_position..-1])
-    end
-
-    inf
-  end
-
-  def resume_communication
-    deselect rescue nil
-    super
-  end
-
-  def halt
-    deselect rescue nil
-    super
-  end
-
-  private
-
-  def convert_iso_baud_rate_to_pcd_setting(value)
-    # ISO
-    # 0b000: 106kBd, 0b001: 212kBd, 0b010: 424kBd, 0b100: 848kBd
-    # MFRC522 register
-    # 0b000: 106kBd, 0b001: 212kBd, 0b010: 424kBd, 0b011: 848kBd
-    x = (value >> 2) & 0x01
-    y = (value >> 1) & 0x01
-    z = value & 0x01
-
-    ((x | y) << 1) + (x | (~y & z))
-  end
-
-  # Gether information from ATS (Answer to Select)
-  def process_ats(ats)
-    position = 1
-    t0 = ats[position] # Format byte
-
-    fsci = t0 & 0x0F # PICC buffer size integer
-    y1 = (t0 >> 4) & 0x07 # Optional frame(TA, TB, TC) indicator
-    @fsc = FSCI_to_FSC.fetch(fsci) # Convert buffer size integer to bytes
-    dr = 0 # default baud rate 106kBd
-    ds = 0
-
-    # Frame: TA
-    if y1 & 0x01 != 0
-      position += 1
-      ta = ats[position]
-
-      dr = ta & 0x07 # PCD to PICC baud rate
-      ds = (ta >> 4) & 0x07 # PICC to PCD baud rate
-
-      # Convert fastest baud rate to PCD setting
-      # dr = convert_iso_baud_rate_to_pcd_setting(dr)
-      # ds = convert_iso_baud_rate_to_pcd_setting(ds)
-
-      # FIXME: baud rate fixed to 106kBd
-      # until author can confirm negotiation works
-      dr = 0
-      ds = 0
-    end
-
-    # Frame: TB
-    if y1 & 0x02 != 0
-      position += 1
-      tb = ats[position]
-
-      fwi = (tb >> 4) & 0x0F # Frame wating integer
-      sgfi = tb & 0x0F # Start-up frame guard integer
-
-      # Convert integers to real time
-      @fwt = (1 << fwi)
-      sgft = (1 << sgfi)
-
-      # Set frame waiting time
-      @pcd.internal_timer(@fwt)
-    end
-
-    # Get info about CID or NAD
-    if y1 & 0x04 != 0
-      position += 1
-      tc = ats[position]
-
-      @support_cid = true if tc & 0x02 != 0
-      @support_nad = true if tc & 0x01 != 0
-    end
-
-    # Start-up guard time
-    sleep 0.000302 * sgft
-
-    return dr, ds
-  end
-
-  def handle_wtx(data)
-    24.times do
-      begin
-        received_data = @pcd.picc_transceive(data)
-      rescue CommunicationError => e
-        raise e unless e.is_a? PICCTimeoutError
-
-        # Try sending NAK when timeout
-        nak = 0xB2 | @block_number
-        data = [nak]
-        next
-      end
-      
-      pcb = received_data[0]
-
-      # WTX detected
-      if pcb & 0xF7 == 0xF2
-        inf_position = (pcb & 0x08 != 0) ? 2 : 1
-        wtxm = received_data[inf_position] & 0x3F
-
-        # Set temporary timer
-        @pcd.internal_timer(@fwt * wtxm)
-
-        # Set WTX response
-        data = [0xF2, wtxm]
-      else
-        # Set timer back to FWT
-        @pcd.internal_timer(@fwt)
-
-        return received_data
-      end
-    end
-
-    raise PICCTimeoutError
-  end
-end