mfrc522 1.0.2 → 3.0.0

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