mfrc522 1.0.6 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6970a8238b5e32859472bec37f4a0c7327dd8bf7
-  data.tar.gz: cbeac674373f82caa74e5fc91179176bb2c40c86
+  metadata.gz: 4c15749e6896a2e58865f9e6639bc829fa717068
+  data.tar.gz: e340cba7fdc0810a3d581b8a14d329bba72886e4
 SHA512:
-  metadata.gz: edbb612b4d103e712eff156431ebdcc55b601cbf74a666d39a34b8246f027d5cfd5d2a938fcb4b33612f7970187bd68983e5d391c05b3eb586a33374e8b9f02e
-  data.tar.gz: 3affc064c30c146115c0c0d1894fd1e71a519af1557700178b07ba1a5e3655e55a0102e989f6c3e4a3da04e1164dbe7a56604b997d46e0c5364aa3a6ba30a753
+  metadata.gz: 7b88ed0c68070b2bafe8e3bd7e25304852a24bd88c609b1688b2c5e1ce830114c3540801482c7aee5276cd357226dfb49884fea1c9c79fba56e6a9c47a73d293
+  data.tar.gz: 94e20de85a0185679b75a2902516406f6e5ed499433f5195f26493621ddac779932ca3c61b88a2c487a044db1e0ac56a489d9ec4a21aae47b842b190d782d98f

data/lib/core_ext.rb

@@ -32,4 +32,42 @@ class Array
     sign = (self.last & 0x80 != 0) ? (-1 ^ ((1 << ((self.size * 8) - 1)) - 1)) : 0
     sign | self.to_uint
   end
+
+  def append_crc16
+    append_uint(crc16, 2)
+  end
+
+  def check_crc16(remove_after_check = false)
+    orig_crc = pop(2)
+    old_crc = (orig_crc[1] << 8) + orig_crc[0]
+    new_crc = crc16
+    concat(orig_crc) unless remove_after_check
+    old_crc == new_crc
+  end
+
+  def xor(array2)
+    zip(array2).map{|x, y| x ^ y }
+  end
+
+  def to_bytehex
+    map{|x| x.to_bytehex}
+  end
+
+  private
+
+  def crc16
+    crc = 0x6363
+    self.each do |byte|
+      bb = (byte ^ crc) & 0xFF
+      bb = (bb ^ (bb << 4)) & 0xFF
+      crc = (crc >> 8) ^ (bb << 8) ^ (bb << 3) ^ (bb >> 4)
+    end
+    crc & 0xFFFF
+  end
+end
+
+class Numeric
+  def to_bytehex
+    self.to_s(16).rjust(2, '0').upcase
+  end
 end

data/lib/exceptions.rb

@@ -5,6 +5,7 @@ class IncorrectCRCError < CommunicationError; end
 class CollisionError < CommunicationError; end
 
 class UnexpectedDataError < StandardError; end
+class UsageError < StandardError; end
 
 class MifareNakError < StandardError; end
 

data/lib/mfrc522.rb

@@ -7,13 +7,14 @@ require 'core_ext'
 require 'exceptions'
 
 require 'picc'
-require 'iso144434'
 
 require 'mifare/key'
 require 'mifare/classic'
+require 'mifare/plus'
+require 'mifare/des_fire'
 require 'mifare/ultralight'
 require 'mifare/ultralight_c'
-require 'mifare/des_fire'
+require 'mifare/ultralight_ev1'
 
 include PiPiper
 
@@ -27,8 +28,6 @@ class MFRC522
   PICC_SEL_CL2      = 0x95  # Anti collision/Select, Cascade Level 2
   PICC_SEL_CL3      = 0x97  # Anti collision/Select, Cascade Level 3
   PICC_HLTA         = 0x50  # HaLT command, Type A. Instructs an ACTIVE PICC to go to state HALT.
-  # Mifare Acknowledge
-  PICC_MF_ACK       = 0x0A
 
   # PCD commands
   PCD_Idle          = 0x00  # no action, cancels current command execution
@@ -135,6 +134,12 @@ class MFRC522
 
   # Reset PCD config to default
   def pcd_config_reset
+    # Stop current command
+    write_spi(CommandReg, PCD_Idle)
+
+    # Stop crypto1 communication
+    mifare_crypto1_deauthenticate
+
     # Clear ValuesAfterColl bit
     write_spi_clear_bitmask(CollReg, 0x80)
 
@@ -159,10 +164,13 @@ class MFRC522
   # value = 0: 106kBd, 1: 212kBd, 2: 424kBd, 3: 848kBd
   def transceiver_baud_rate(direction, value = nil)
     reg = {tx: TxModeReg, rx: RxModeReg}
+    mod = {0 => 0x26, 1 => 0x15, 2 => 0x0A, 3 => 0x05}
 
     if value
+      @built_in_crc_disabled = (value == 0)
+      write_spi(ModWidthReg, mod.fetch(value))
       value <<= 4
-      value |= 0x80 if value != 0
+      value |= 0x80 unless @built_in_crc_disabled
       write_spi(reg.fetch(direction), value)
     end
 
@@ -189,6 +197,10 @@ class MFRC522
     (read_spi(RFCfgReg) & 0x70) >> 4
   end
 
+  def buffer_size
+    64
+  end
+
   # Wakes PICC from HALT or IDLE to ACTIVE state
   # Accept PICC_REQA and PICC_WUPA command
   def picc_request(picc_command)
@@ -201,7 +213,7 @@ class MFRC522
 
   # Instruct PICC in ACTIVE state go to HALT state
   def picc_halt
-    buffer = append_crc([PICC_HLTA, 0])
+    buffer = [PICC_HLTA, 0].append_crc16
 
     status, _received_data, _valid_bits = communicate_with_picc(PCD_Transceive, buffer)
 
@@ -213,7 +225,7 @@ class MFRC522
   # Select PICC for further communication
   #
   # PICC must be in state ACTIVE
-  def picc_select
+  def picc_select(disable_anticollision = false)
     #  Description of buffer structure:
     #
     #  Byte 0: SEL   Indicates the Cascade Level: PICC_CMD_SEL_CL1, PICC_CMD_SEL_CL2 or PICC_CMD_SEL_CL3
@@ -281,7 +293,7 @@ class MFRC522
           buffer[6] = (buffer[2] ^ buffer[3] ^ buffer[4] ^ buffer[5]) # Block Check Character
 
           # Append CRC to buffer
-          buffer = append_crc(buffer)
+          buffer.append_crc16
         else
           tx_last_bits = current_level_known_bits % 8
           uid_full_byte = current_level_known_bits / 8
@@ -299,6 +311,8 @@ class MFRC522
 
         if status != :status_ok && status != :status_collision
           raise CommunicationError, status
+        elsif status == :status_collision && disable_anticollision
+          raise CollisionError
         end
 
         if received_data.empty?
@@ -356,7 +370,7 @@ class MFRC522
       # Check the result of full select
       # Select Acknowledge is 1 byte + CRC16
       raise UnexpectedDataError, 'Unknown SAK format' if received_data.size != 3 || valid_bits != 0 
-      raise IncorrectCRCError unless check_crc(received_data)
+      raise IncorrectCRCError unless received_data.check_crc16(true)
 
       sak = received_data[0]
       break if (sak & 0x04) == 0 # No more cascade level
@@ -380,54 +394,6 @@ class MFRC522
     status && uid == new_uid
   end
 
-  # Lookup PICC name using sak
-  def identify_model(sak)
-    # SAK coding separation reference:
-    # http://cache.nxp.com/documents/application_note/AN10833.pdf
-    # http://www.nxp.com/documents/application_note/130830.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
-
   # Start Crypto1 communication between reader and Mifare PICC
   #
   # PICC must be selected before calling for authentication
@@ -455,29 +421,26 @@ class MFRC522
 
   # Append CRC to buffer and check CRC or Mifare acknowledge
   def picc_transceive(send_data, accept_timeout = false)
-    send_data = append_crc(send_data)
+    send_data = send_data.dup
+    send_data.append_crc16 if @built_in_crc_disabled
 
-    puts "Sending Data: #{send_data.map{|x|x.to_s(16).rjust(2,'0').upcase}}" if ENV['DEBUG']
+    puts "Sending Data: #{send_data.to_bytehex}" if ENV['DEBUG']
 
     # Transfer data
     status, received_data, valid_bits = communicate_with_picc(PCD_Transceive, send_data)
-    return [] if status == :status_picc_timeout && accept_timeout
+    return if status == :status_picc_timeout && accept_timeout
     raise PICCTimeoutError if status == :status_picc_timeout
     raise CommunicationError, status if status != :status_ok
 
-    puts "Received Data: #{received_data.map{|x|x.to_s(16).rjust(2,'0').upcase}}" if ENV['DEBUG']
+    puts "Received Data: #{received_data.to_bytehex}" if ENV['DEBUG']
+    puts "Valid bits: #{valid_bits}" if ENV['DEBUG']
 
-    # Data exists, check CRC and return
-    if received_data.size > 1
-      raise IncorrectCRCError unless check_crc(received_data)
-
-      return received_data[0..-3]
+    # Data exists, check CRC
+    if received_data.size > 2 && @built_in_crc_disabled
+      raise IncorrectCRCError unless received_data.check_crc16(true)
     end
 
-    raise UnexpectedDataError, 'Incorrect Mifare ACK format' if received_data.size != 1 || valid_bits != 4 # ACK is 4 bits long
-    raise MifareNakError, received_data[0] if received_data[0] != PICC_MF_ACK
-
-    received_data
+    return received_data, valid_bits
   end
 
   private
@@ -551,7 +514,10 @@ class MFRC522
 
     # Check for error
     error = read_spi(ErrorReg)
-    return :status_error if (error & 0x13) != 0 # BufferOvfl ParityErr ProtocolErr
+    return :status_buffer_overflow if (error & 0x10) != 0
+    return :status_crc_error if (error & 0x04) != 0
+    return :status_parity_error if (error & 0x02) != 0
+    return :status_protocol_error if (error & 0x01) != 0
 
     # Receiving data
     received_data = []
@@ -568,39 +534,4 @@ class MFRC522
 
     return status, received_data, valid_bits
   end
-
-  def calculate_crc(data)
-    write_spi(CommandReg, PCD_Idle)               # Stop any active command.
-    write_spi(DivIrqReg, 0x04)                    # Clear the CRCIRq interrupt request bit
-    write_spi_set_bitmask(FIFOLevelReg, 0x80)     # FlushBuffer = 1, FIFO initialization
-    write_spi(FIFODataReg, data)                  # Write data to the FIFO
-    write_spi(CommandReg, PCD_CalcCRC)            # Start the calculation
-
-    # Wait for the command to complete
-    i = 5000
-    loop do
-      irq = read_spi(DivIrqReg)
-      break if (irq & 0x04) != 0
-      raise PCDTimeoutError, 'Error calculating CRC' if i == 0
-      i -= 1
-    end
-
-    write_spi(CommandReg, PCD_Idle)               # Stop calculating CRC for new content in the FIFO.
-
-    [read_spi(CRCResultRegL), read_spi(CRCResultRegH)]
-  end
-
-  def append_crc(data)
-    data + calculate_crc(data)
-  end
-
-  def check_crc(data)
-    raise UnexpectedDataError, 'Data too short for CRC check' if data.size < 3
-
-    data = data.dup
-    crc = data.pop(2)
-
-    crc == calculate_crc(data)
-  end
-
 end

data/lib/mifare/classic.rb

@@ -1,4 +1,4 @@
-module Mifare
+module MIFARE
   class Classic < ::PICC
     CMD_AUTH_KEY_A  = 0x60  # Perform authentication with Key A
     CMD_AUTH_KEY_B  = 0x61  # Perform authentication with Key B
@@ -8,10 +8,27 @@ module Mifare
     CMD_INCREMENT   = 0xC1  # Increments the contents of a block and stores the result in the internal data register.
     CMD_RESTORE     = 0xC2  # Reads the contents of a block into the internal data register.
     CMD_TRANSFER    = 0xB0  # Writes the contents of the internal data register to a block.
+    MF_ACK          = 0x0A  # Mifare Acknowledge
+
+    def initialize(pcd, uid, sak)
+      super
+      # Set transceive timeout to 15ms
+      @pcd.internal_timer(50)
+    end
+
+    def transceive(send_data, accept_timeout = false)
+      received_data, valid_bits = picc_transceive(send_data, accept_timeout, true)
+      return if received_data.nil? && valid_bits.nil? && accept_timeout
+      unless valid_bits == 0
+        raise UnexpectedDataError, 'Incorrect Mifare ACK format' if received_data.size != 1 || valid_bits != 4 # ACK is 4 bits long
+        raise MifareNakError, "Mifare NAK detected: 0x#{received_data[0].to_bytehex}" if received_data[0] != MF_ACK
+      end
+      received_data
+    end
 
     def auth(block_addr, key = {})
       if key[:a].nil? && key[:b].nil?
-        raise UnexpectedDataError, 'Missing key data'
+        raise UsageError, 'Missing key data'
       end
 
       if key[:a]
@@ -24,7 +41,7 @@ module Mifare
 
       key = [key].pack('H*').bytes
       if key.size != 6
-        raise UnexpectedDataError, "Expect 6 bytes auth key, got: #{key.size} byte"
+        raise UsageError, "Expect 6 bytes auth key, got: #{key.size} byte"
       end
 
       @pcd.mifare_crypto1_authenticate(cmd, block_addr, key, @uid)
@@ -35,29 +52,33 @@ module Mifare
     end
 
     def read(block_addr)
-      buffer = [CMD_READ, block_addr]
-
-      @pcd.picc_transceive(buffer)
+      transceive([CMD_READ, block_addr])
     end
 
     def write(block_addr, send_data)
       if send_data.size != 16
-        raise UnexpectedDataError, "Expect 16 bytes data, got: #{send_data.size} byte"
+        raise UsageError, "Expect 16 bytes data, got: #{send_data.size} byte"
       end
 
-      buffer = [CMD_WRITE, block_addr]
-
       # Ask PICC if we can write to block_addr
-      @pcd.picc_transceive(buffer)
+      transceive([CMD_WRITE, block_addr])
 
       # Then start transfer our data
-      @pcd.picc_transceive(send_data)
+      transceive(send_data)
     end
 
     def read_value(block_addr)
       received_data = read(block_addr)
 
-      received_data[0..3].to_sint
+      value = received_data[0..3].to_sint
+      value1 = ~(received_data[4..7].to_sint)
+      value2 = received_data[8..11].to_sint
+
+      if value != value1 || value != value2
+        raise UnexpectedDataError, 'Invalid value block'
+      end
+
+      value
     end
 
     def write_value(block_addr, value)
@@ -86,9 +107,9 @@ module Mifare
       buffer[10] = buffer[2]
       buffer[11] = buffer[3]
       buffer[12] = block_addr
-      buffer[13] = ~block_addr
+      buffer[13] = ~buffer[12]
       buffer[14] = buffer[12]
-      buffer[15] = buffer[13]
+      buffer[15] = ~buffer[12]
     
       write(block_addr, buffer)
     end
@@ -110,9 +131,7 @@ module Mifare
 
     # Transfer: Writes the contents of the internal Transfer Buffer to a value block
     def transfer(block_addr)
-      buffer = [CMD_TRANSFER, block_addr]
-
-      @pcd.picc_transceive(buffer)
+      transceive([CMD_TRANSFER, block_addr])
     end
 
     private
@@ -123,10 +142,10 @@ module Mifare
       send_data = [].append_uint(value, 4)
 
       # Ask PICC if we can write to block_addr
-      @pcd.picc_transceive(buffer)
+      transceive(buffer)
 
       # Then start transfer our data
-      @pcd.picc_transceive(send_data, true) # Accept timeout
+      transceive(send_data, true) # Accept timeout
     end
   end
 end

data/lib/mifare/des_fire.rb

@@ -1,5 +1,5 @@
-module Mifare
-  class DESFire < ::ISO144434
+module MIFARE
+  class DESFire < ::PICC
     # Security Related Commands
     CMD_DES_AUTH                  = 0x1A # Authenticate with DES, 2K3DES, 3K3DES key
     CMD_AES_AUTH                  = 0xAA # Authenticate with AES-128 key
@@ -7,14 +7,18 @@ module Mifare
     CMD_CHANGE_KEY_SETTING        = 0x54 # Changes the master key settings on PICC and application level.
     CMD_GET_KEY_VERSION           = 0x64 # Reads out the current key version of any key stored on the PICC.
     CMD_CHANGE_KEY                = 0xC4 # Changes any key stored on the PICC.
+    CMD_SET_CONFIGURATION         = 0x5C # Configures and pre-personalizes the card with app default key, UID, and ATS string setup
 
     # PICC Level Commands
     CMD_CREATE_APP                = 0xCA # Creates new applications on the PICC.
     CMD_DELETE_APP                = 0xDA # Permanently deactivates applications on the PICC.
     CMD_GET_APP_IDS               = 0x6A # Returns the Application IDentifiers of all applications on a PICC.
     CMD_SELECT_APP                = 0x5A # Selects one specific application for further access.
+    CMD_FREE_MEMORY               = 0x6E # Returns the free memory available on the card
+    CMD_GET_DF_NAMES              = 0x6D # Returns the DF names
     CMD_GET_CARD_VERSION          = 0x60 # Returns manufacturing related data of the PICC.
     CMD_FORMAT_CARD               = 0xFC # Releases the PICC user memory.
+    CMD_GET_CARD_UID              = 0x51 # Returns the UID
 
     # Application Level Commands
     CMD_GET_FILE_IDS              = 0x6F # Returns the File IDentifiers of all active files within the currently selected application.
@@ -67,45 +71,46 @@ module Mifare
     KEY_TYPE = {'des-ede-cbc' => 0x00, 'des-ede3-cbc' => 0x40, 'aes-128-cbc' => 0x80}
 
     KEY_SETTING = Struct.new(
-      # Key number(0x00~0x0D) required for `change_key`
-      # 0x0E means same key, 0x0F freezes all keys
+      # Key number required for `change_key`
+      # 0x00 means only master key is accepted
+      # 0x01~0x0D chooses an app key to change any key
+      # 0x0E means keys can only change themselves
+      # 0x0F freezes all keys, except master key
+      # to freeze master key, use :masterkey_changeable
       :privileged_key,
       # Set if master key can be modified
-      :mk_changeable,
-      # Set if listing requires master key
-      :listing_without_mk,
-      # Set if create or delete requires master key
-      :create_delete_without_mk,
+      :masterkey_changeable,
+      # Set if file management requires auth
+      :file_management_without_auth,
+      # Set if file configuration requires auth
+      :file_configurable_without_auth,
       # Set if this setting can be modified
-      :configuration_changeable) do
-      def initialize(*data)
+      :key_setting_changeable) do
+      def initialize(*)
         super
-        default
+        self.privileged_key = 0 if self.privileged_key.nil?
+        self.masterkey_changeable = true if self.masterkey_changeable.nil?
+        self.file_management_without_auth = true if self.file_management_without_auth.nil?
+        self.file_configurable_without_auth = true if self.file_configurable_without_auth.nil?
+        self.key_setting_changeable = true if self.key_setting_changeable.nil?
       end
 
-      def default
-        self[:privileged_key] = 0 unless privileged_key
-        self[:mk_changeable] = true unless mk_changeable
-        self[:listing_without_mk] = true unless listing_without_mk
-        self[:create_delete_without_mk] = true unless create_delete_without_mk
-        self[:configuration_changeable] = true unless configuration_changeable
+      def self.import(byte)
+        self.new(
+          (byte >> 4) & 0x0F,
+          byte & 0x01 != 0,
+          byte & 0x02 != 0,
+          byte & 0x04 != 0,
+          byte & 0x08 != 0
+        )
       end
 
-      def import(byte)
-        self[:privileged_key] = (byte >> 4) & 0x0F
-        self[:mk_changeable] = byte & 0x01 != 0
-        self[:listing_without_mk] = (byte >> 1) & 0x01 != 0
-        self[:create_delete_without_mk] = (byte >> 2) & 0x01 != 0
-        self[:configuration_changeable] = (byte >> 3) & 0x01 != 0
-        self
-      end
-
-      def to_uint
-        output = (privileged_key << 4)
-        output |= 0x01 if mk_changeable
-        output |= 0x02 if listing_without_mk
-        output |= 0x04 if create_delete_without_mk
-        output |= 0x08 if configuration_changeable
+      def export
+        output = (self.privileged_key << 4)
+        output |= 0x01 if self.masterkey_changeable
+        output |= 0x02 if self.file_management_without_auth
+        output |= 0x04 if self.file_configurable_without_auth
+        output |= 0x08 if self.key_setting_changeable
         output
       end
     end
@@ -119,15 +124,16 @@ module Mifare
 
     # value 0x00 ~ 0x0D are key numbers, 0x0E grants free access, 0x0F always denies access
     FILE_PERMISSION = Struct.new(:read_access, :write_access, :read_write_access, :change_access) do
-      def import(byte)
-        self[:change_access] = byte & 0x0F
-        self[:read_write_access] = (byte >> 4) & 0x0F
-        self[:write_access] = (byte >> 8) & 0x0F
-        self[:read_access] = (byte >> 12) & 0x0F
-        self
+      def self.import(byte)
+        self.new(
+          (byte >> 12) & 0x0F,
+          (byte >> 8) & 0x0F,
+          (byte >> 4) & 0x0F,
+          byte & 0x0F
+        )
       end
 
-      def to_uint
+      def export
         (read_access << 12) | (write_access << 8) | (read_write_access << 4) | change_access
       end
     end
@@ -160,7 +166,6 @@ module Mifare
     def initialize(pcd, uid, sak)
       super
       invalid_auth
-      @cmac_buffer = []
       @selected_app = false
     end
 
@@ -168,12 +173,16 @@ module Mifare
       @authed.is_a? Numeric
     end
 
+    def select
+      iso_select
+    end
+
     def deselect
-      super
       invalid_auth
+      iso_deselect
     end
 
-    def transceive(cmd: , plain_data: [], data: [], tx: nil, rx: nil, expect: nil, return_data: nil, receive_all: nil, receive_length: nil)
+    def transceive(cmd: , plain_data: [], data: [], tx: nil, rx: nil, expect: nil, return_data: nil, receive_length: nil, encrypt_padding: nil)
       # Session key is needed for encryption
       if (tx == :encrypt || rx == :encrypt) && !@authed
         raise UnauthenticatedError
@@ -185,6 +194,10 @@ module Mifare
 
       buffer = [cmd] + plain_data
 
+      if @authed
+        @session_key.padding_mode(encrypt_padding || 1)
+      end
+
       if tx == :encrypt
         # Calculate CRC on whole frame
         data.append_uint(crc32(buffer, data), 4)
@@ -194,22 +207,21 @@ module Mifare
 
       buffer.concat(data)
 
-      if (tx == :cmac || tx == :send_cmac) && cmd != CMD_ADDITIONAL_FRAME && @authed
-        @cmac_buffer = buffer
-        cmac = @session_key.calculate_cmac(@cmac_buffer)
+      if tx != :encrypt && tx != :none && cmd != CMD_ADDITIONAL_FRAME && @authed
+        cmac = @session_key.calculate_cmac(buffer)
         # Only first 8 bytes of CMAC are transmitted
-        buffer.concat(cmac[0..7]) if tx == :send_cmac
+        buffer.concat(cmac[0..7]) if tx == :mac
       end
 
       received_data = []
       card_status = nil
       loop do
-        receive_buffer = super(buffer.shift(@max_inf_size))
+        receive_buffer = iso_transceive(buffer.shift(@max_inf_size))
 
         card_status = receive_buffer.shift
         received_data.concat(receive_buffer)
 
-        break if card_status != ST_ADDITIONAL_FRAME || (buffer.empty? && !receive_all)
+        break if card_status != ST_ADDITIONAL_FRAME || (buffer.empty? && expect == ST_ADDITIONAL_FRAME)
 
         buffer.unshift(CMD_ADDITIONAL_FRAME)
       end
@@ -218,72 +230,59 @@ module Mifare
 
       unless error_msg.empty?
         invalid_auth
-        raise ReceiptStatusError, "0x#{card_status.to_s(16).rjust(2, '0').upcase} - #{error_msg}"
+        raise ReceiptStatusError, "0x#{card_status.to_bytehex} - #{error_msg}"
       end
 
       if expect && expect != card_status
         raise UnexpectedDataError, 'Card status does not match expected value'
       end
 
-      if (rx == :cmac || rx == :send_cmac) && (card_status == ST_SUCCESS || card_status == ST_ADDITIONAL_FRAME) && @authed
-        @cmac_buffer = [] if cmd != CMD_ADDITIONAL_FRAME
-        @cmac_buffer.concat(received_data) if card_status == ST_ADDITIONAL_FRAME
-
-        if received_data.size >= 8 && card_status == ST_SUCCESS
-          received_cmac = received_data.pop(8)
-          @cmac_buffer.concat(received_data + [card_status])
-          cmac = @session_key.calculate_cmac(@cmac_buffer)
-          # Only first 8 bytes of CMAC are transmitted
-          if cmac[0..7] != received_cmac
-            raise ReceiptIntegrityError
-          end
-        end
-      end
-
       if rx == :encrypt
         if receive_length.nil?
-          raise UnexpectedDataError, 'Lack of receive length for removing padding'
+          raise UsageError, 'Lack of receive length for removing padding'
         end
-        received_data = @session_key.decrypt(received_data)
-        received_data = remove_padding_bytes(received_data, receive_length)
+        @session_key.padding_mode((receive_length > 0) ? 1 : 2)
+        receive_length += 4 # CRC32
+        received_data = @session_key.decrypt(received_data, data_length: receive_length)
         received_crc = received_data.pop(4).to_uint
         crc = crc32(received_data, card_status)
         if crc != received_crc
           raise ReceiptIntegrityError
         end
-      end
-
-      if expect
-        if received_data.empty? && !return_data
-          return true
-        else
-          return received_data
+      elsif rx != :none && @authed && received_data.size >= 8 && card_status == ST_SUCCESS
+        received_cmac = received_data.pop(8)
+        cmac = @session_key.calculate_cmac(received_data + [card_status])
+        # Only first 8 bytes of CMAC are transmitted
+        if rx == :mac && cmac[0..7] != received_cmac
+          raise ReceiptIntegrityError
         end
       end
 
-      return card_status, received_data
+      received_data
     end
 
     def auth(key_number, auth_key)
       cmd = (auth_key.type == :des) ? CMD_DES_AUTH : CMD_AES_AUTH
+      rand_size = (auth_key.cipher_suite == 'des-ede-cbc') ? 8 : 16
       auth_key.clear_iv
+      auth_key.padding_mode(1)
 
       # Ask for authentication
-      received_data = transceive(cmd: cmd, data: key_number, expect: ST_ADDITIONAL_FRAME)
+      received_data = transceive(cmd: cmd, data: key_number, expect: ST_ADDITIONAL_FRAME, tx: :none, rx: :none)
 
       # Receive challenge from DESFire
-      challenge = auth_key.decrypt(received_data)
+      challenge = auth_key.decrypt(received_data, data_length: rand_size)
       challenge_rot = challenge.rotate
 
       # Generate random number and encrypt it with rotated challenge
-      random_number = SecureRandom.random_bytes(received_data.size).bytes
+      random_number = SecureRandom.random_bytes(rand_size).bytes
       response = auth_key.encrypt(random_number + challenge_rot)
 
       # Send challenge response
-      received_data = transceive(cmd: CMD_ADDITIONAL_FRAME, data: response, expect: ST_SUCCESS)
+      received_data = transceive(cmd: CMD_ADDITIONAL_FRAME, data: response, tx: :none, rx: :none)
 
       # Check if verification matches rotated random_number
-      verification = auth_key.decrypt(received_data)
+      verification = auth_key.decrypt(received_data, data_length: rand_size)
 
       if random_number.rotate != verification
         halt
@@ -314,7 +313,7 @@ module Mifare
     end
 
     def get_app_ids
-      ids = transceive(cmd: CMD_GET_APP_IDS, tx: :cmac, rx: :cmac, expect: ST_SUCCESS, return_data: true, receive_all: true)
+      ids = transceive(cmd: CMD_GET_APP_IDS, rx: :mac)
 
       return ids if ids.empty?
 
@@ -329,7 +328,7 @@ module Mifare
     end
 
     def select_app(id)
-      transceive(cmd: CMD_SELECT_APP, data: convert_app_id(id), expect: ST_SUCCESS)
+      transceive(cmd: CMD_SELECT_APP, data: convert_app_id(id))
 
       invalid_auth
       @selected_app = id
@@ -337,21 +336,21 @@ module Mifare
 
     def create_app(id, key_setting, key_count, cipher_suite)
       raise UnauthenticatedError unless @authed
-      raise UnexpectedDataError, 'An application can only hold up to 14 keys.' if key_count > 14
+      raise UsageError, 'An application can only hold up to 14 keys.' if key_count > 14
 
-      buffer = convert_app_id(id) + [key_setting.to_uint, KEY_TYPE.fetch(cipher_suite) | key_count]
+      buffer = convert_app_id(id) + [key_setting.export, KEY_TYPE.fetch(cipher_suite) | key_count]
 
-      transceive(cmd: CMD_CREATE_APP, data: buffer, tx: :cmac, rx: :cmac, expect: ST_SUCCESS)
+      transceive(cmd: CMD_CREATE_APP, data: buffer, rx: :mac)
     end
 
     def delete_app(id)
       raise UnauthenticatedError unless @authed
 
-      transceive(cmd: CMD_DELETE_APP, data: convert_app_id(id), tx: :cmac, rx: :cmac, expect: ST_SUCCESS)
+      transceive(cmd: CMD_DELETE_APP, data: convert_app_id(id))
     end
 
     def get_card_version
-      version = transceive(cmd: CMD_GET_CARD_VERSION, tx: :cmac, rx: :cmac, expect: ST_SUCCESS, receive_all: true)
+      version = transceive(cmd: CMD_GET_CARD_VERSION)
 
       CARD_VERSION.new(
         version[0], version[1], version[2], version[3], version[4], 1 << (version[5] / 2), version[6],
@@ -360,22 +359,63 @@ module Mifare
       )
     end
 
+    def get_free_memory
+      transceive(cmd: CMD_FREE_MEMORY)
+    end
+
+    def get_df_names
+      raise UsageError, 'App 0 should be selected before calling' unless @selected_app == 0
+
+      transceive(cmd: CMD_GET_DF_NAMES)
+    end
+
+    def get_card_uid
+      raise UnauthenticatedError unless @authed
+
+      transceive(cmd: CMD_GET_CARD_UID, rx: :encrypt, receive_length: 7)
+    end
+
     def format_card
       raise UnauthenticatedError unless @authed
 
-      transceive(cmd: CMD_FORMAT_CARD, tx: :cmac, rx: :cmac, expect: ST_SUCCESS)
+      transceive(cmd: CMD_FORMAT_CARD)
+    end
+
+    def set_configuration_byte(disable_format, enable_random_uid)
+      raise UnauthenticatedError unless @authed
+
+      flag = 0
+      flag |= 0x01 if disable_format
+      flag |= 0x02 if enable_random_uid
+
+      transceive(cmd: CMD_SET_CONFIGURATION, plain_data: 0x00, data: [flag], tx: :encrypt)
+    end
+
+    def set_default_key(key)
+      raise UnauthenticatedError unless @authed
+
+      buffer = key.key
+      buffer.append_uint(key.version, 1)
+
+      transceive(cmd: CMD_SET_CONFIGURATION, plain_data: 0x01, data: buffer, tx: :encrypt)
+    end
+
+    def set_ats(ats)
+      raise UnauthenticatedError unless @authed
+
+      transceive(cmd: CMD_SET_CONFIGURATION, plain_data: 0x02, data: ats, tx: :encrypt, encrypt_padding: 2)
     end
 
     def get_key_version(key_number)
-      received_data = transceive(cmd: CMD_GET_KEY_VERSION, data: key_number, tx: :cmac, rx: :cmac, expect: ST_SUCCESS)
+      received_data = transceive(cmd: CMD_GET_KEY_VERSION, data: key_number, rx: :mac)
 
       received_data[0]
     end
 
     def change_key(key_number, new_key, curr_key = nil)
       raise UnauthenticatedError unless @authed
-      raise UnexpectedDataError, 'Invalid key number' if key_number > 13
-      
+      raise UsageError, 'Invalid key number' if key_number > 13
+
       cryptogram = new_key.key
 
       same_key = (key_number == @authed)
@@ -385,7 +425,7 @@ module Mifare
 
       # XOR new key if we're using different one
       unless same_key
-        cryptogram = cryptogram.zip(curr_key.key).map{|x, y| x ^ y }
+        cryptogram = cryptogram.xor(curr_key.key)
       end
 
       # AES stores key version separately
@@ -400,18 +440,19 @@ module Mifare
       end
 
       # Encrypt cryptogram
+      @session_key.padding_mode(1)
       buffer = [key_number] + @session_key.encrypt(cryptogram)
 
+      transceive(cmd: CMD_CHANGE_KEY, data: buffer, tx: :none, rx: :mac)
+
       # Change current used key will revoke authentication
       invalid_auth if same_key
-
-      transceive(cmd: CMD_CHANGE_KEY, data: buffer, rx: :cmac, expect: ST_SUCCESS)
     end
 
     def get_key_setting
-      received_data = transceive(cmd: CMD_GET_KEY_SETTING, tx: :cmac, rx: :cmac, expect: ST_SUCCESS)
+      received_data = transceive(cmd: CMD_GET_KEY_SETTING)
 
-      { key_setting: KEY_SETTING.new.import(received_data[0]),
+      { key_setting: KEY_SETTING.import(received_data[0]),
         key_count: received_data[1] & 0x0F,
         key_type: KEY_TYPE.key(received_data[1] & 0xF0) }
     end
@@ -419,11 +460,11 @@ module Mifare
     def change_key_setting(key_setting)
       raise UnauthenticatedError unless @authed
 
-      transceive(cmd: CMD_CHANGE_KEY_SETTING, data: key_setting.to_uint, tx: :encrypt, rx: :cmac, expect: ST_SUCCESS)
+      transceive(cmd: CMD_CHANGE_KEY_SETTING, data: key_setting.export, tx: :encrypt, rx: :mac)
     end
 
     def get_file_ids
-      transceive(cmd: CMD_GET_FILE_IDS, tx: :cmac, rx: :cmac, expect: ST_SUCCESS, return_data: true)
+      transceive(cmd: CMD_GET_FILE_IDS)
     end
 
     def file_exist?(id)
@@ -431,12 +472,12 @@ module Mifare
     end
 
     def get_file_setting(id)
-      received_data = transceive(cmd: CMD_GET_FILE_SETTING, data: id, tx: :cmac, rx: :cmac, expect: ST_SUCCESS)
+      received_data = transceive(cmd: CMD_GET_FILE_SETTING, data: id)
 
       file_setting = FILE_SETTING.new
       file_setting.type = FILE_TYPE.key(received_data.shift)
       file_setting.communication = FILE_COMMUNICATION.key(received_data.shift)
-      file_setting.permission = FILE_PERMISSION.new.import(received_data.shift(2).to_uint)
+      file_setting.permission = FILE_PERMISSION.import(received_data.shift(2).to_uint)
 
       case file_setting.type
       when :std_data_file, :backup_data_file
@@ -458,15 +499,15 @@ module Mifare
     def change_file_setting(id, file_setting)
       buffer = []
       buffer.append_uint(FILE_COMMUNICATION.fetch(file_setting.communication), 1)
-      buffer.append_uint(file_setting.permission.to_uint, 2)
+      buffer.append_uint(file_setting.permission.export, 2)
 
-      transceive(cmd: CMD_CHANGE_FILE_SETTING, plain_data: id, data: buffer, tx: :encrypt, rx: :cmac, expect: ST_SUCCESS)
+      transceive(cmd: CMD_CHANGE_FILE_SETTING, plain_data: id, data: buffer, tx: :encrypt)
     end
 
     def create_file(id, file_setting)
       buffer = [id]
       buffer.append_uint(FILE_COMMUNICATION.fetch(file_setting.communication), 1)
-      buffer.append_uint(file_setting.permission.to_uint, 2)
+      buffer.append_uint(file_setting.permission.export, 2)
 
       case file_setting.type
       when :std_data_file, :backup_data_file
@@ -483,22 +524,22 @@ module Mifare
 
       cmd = self.class.const_get("CMD_CREATE_#{file_setting.type.to_s.upcase}")
 
-      transceive(cmd: cmd, data: buffer, tx: :cmac, rx: :cmac, expect: ST_SUCCESS)
+      transceive(cmd: cmd, data: buffer)
     end
 
     def delete_file(id)
-      transceive(cmd: CMD_DELETE_FILE, data: id, tx: :cmac, rx: :cmac, expect: ST_SUCCESS)
+      transceive(cmd: CMD_DELETE_FILE, data: id)
     end
 
     def read_file(id, cmd, data, length)
       file_setting = get_file_setting(id)
       length *= file_setting.record_size if file_setting.record_size
-      transceive(cmd: cmd, data: data, tx: :cmac, rx: convert_file_communication(file_setting.communication), expect: ST_SUCCESS, receive_all: true, receive_length: length)
+      transceive(cmd: cmd, data: data, rx: file_setting.communication, receive_length: length)
     end
 
     def write_file(id, cmd, plain_data, data)
       file_setting = get_file_setting(id)
-      transceive(cmd: cmd, plain_data: plain_data, data: data, tx: convert_file_communication(file_setting.communication), rx: :cmac, expect: ST_SUCCESS)
+      transceive(cmd: cmd, plain_data: plain_data, data: data, tx: file_setting.communication)
     end
 
     def read_data(id, offset, length)
@@ -524,7 +565,7 @@ module Mifare
     end
 
     def credit_value(id, delta)
-      raise UnexpectedDataError, 'Negative number is not allowed.' if delta < 0
+      raise UsageError, 'Negative number is not allowed.' if delta < 0
 
       buffer = []
       buffer.append_sint(delta, 4)
@@ -533,7 +574,7 @@ module Mifare
     end
 
     def debit_value(id, delta)
-      raise UnexpectedDataError, 'Negative number is not allowed.' if delta < 0
+      raise UsageError, 'Negative number is not allowed.' if delta < 0
 
       buffer = []
       buffer.append_sint(delta, 4)
@@ -542,7 +583,7 @@ module Mifare
     end
 
     def limited_credit_value(id, delta)
-      raise UnexpectedDataError, 'Negative number is not allowed.' if delta < 0
+      raise UsageError, 'Negative number is not allowed.' if delta < 0
 
       buffer = []
       buffer.append_sint(delta, 4)
@@ -569,15 +610,15 @@ module Mifare
     end
 
     def clear_record(id)
-      transceive(cmd: CMD_CLEAR_RECORD_FILE, data: id, tx: :cmac, rx: :cmac, expect: ST_SUCCESS)
+      transceive(cmd: CMD_CLEAR_RECORD_FILE, data: id)
     end
 
     def commit_transaction
-      transceive(cmd: CMD_COMMIT_TRANSACTION, tx: :cmac, rx: :cmac, expect: ST_SUCCESS)
+      transceive(cmd: CMD_COMMIT_TRANSACTION)
     end
 
     def abort_transaction
-      transceive(cmd: CMD_ABORT_TRANSACTION, tx: :cmac, rx: :cmac, expect: ST_SUCCESS)
+      transceive(cmd: CMD_ABORT_TRANSACTION)
     end
 
     private
@@ -585,56 +626,14 @@ module Mifare
     def invalid_auth
       @authed = false
       @session_key = nil
-      @cmac_buffer = []
     end
 
     def convert_app_id(id)
-      raise UnexpectedDataError, 'Application ID overflow' if id < 0 || id >= (1 << 24)
+      raise UsageError, 'Application ID overflow' if id < 0 || id >= (1 << 24)
 
       [].append_uint(id, 3)
     end
 
-    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
-
-    # Remove trailing padding bytes
-    def remove_padding_bytes(data, length)
-      if length == 0
-        # padding format according to ISO 9797-1
-        str = data.pack('C*')
-        str.sub! /#{0x80.chr}#{0x00.chr}*\z/, ''
-        str.bytes
-      else
-        # data length + 4 bytes CRC
-        data[0...length + 4]
-      end
-    end
-
-    def convert_file_communication(communication)
-      case communication
-      when :plain
-        :cmac
-      when :mac
-        :send_cmac
-      when :encrypt
-        :encrypt
-      end
-    end
-
     def check_status_code(code)
       case code
       when ST_SUCCESS, ST_ADDITIONAL_FRAME