Dwa słowa o kartach Mifare

from smartcard.System import readers
from smartcard.ATR import ATR
from smartcard.util import toHexString
import smartcard.Exceptions


class NoACR122ReaderException(Exception): pass
class CardException(Exception): pass
class UnknownReaderException(Exception): pass
class OperationFailedException(Exception): pass
class FunctionNotSupportedException(Exception): pass
class FunctionArgumentException(Exception): pass

class ACR122_Reader:
    def __init__(self):
        try:
            self.readers = readers()
            self.acr122_readers = [a for a in self.readers if str(a).find('ACR122')]
            if len(self.acr122_readers) == 0:
                raise NoACR122ReaderException()
            self.selected_reader = self.acr122_readers[0]
            self.connection = self.selected_reader.createConnection()
            self.connection.connect()
        except smartcard.Exceptions.NoCardException:
            raise CardException

    def showATRInfo(self):
        atr = ATR(self.connection.getATR())
        print('ATR                        : {}'.format(toHexString(self.connection.getATR())))
        print('historical bytes           : {}'.format(toHexString(atr.getHistoricalBytes())))
        print('checksum                   : {}    ok? {}: '.format(hex(atr.getChecksum()), atr.checksumOK))
        print('support for [T0, T1, T15]  : {}'.format([atr.isT0Supported(), atr.isT1Supported(), atr.isT15Supported()]))

    def getReadersTotalCount(self):
        return len(self.readers)

    def getReader(self):
        return self.selected_reader

    def close(self):
        if self.connection:
            self.connection.disconnect()

    def sendAPDU(self, apdu):
        return self.connection.transmit( apdu )
    #==================================

    def getFirmwareVersion(self):
       APDU = [0xFF, 0x00, 0x48, 0x00, 0x00]
       data, sw1, sw2 = self.sendAPDU(APDU)
       if sw1 != 49 or sw2 != 48: raise OperationFailedException()
       return "".join(map(chr, data))

    def setBuzzerStatus(self, value):
        new_status = [0x00,0xff][int(value)]
        APDU = [0xFF, 0x00, 0x52, new_status, 0x00]
        data, sw1, sw2 = self.sendAPDU(APDU)
        if sw1 != 0x90: raise OperationFailedException()

    #==================================

    def ParseResponce(self, sw1, sw2):
        if sw1 == 0x63 and sw2 == 0x00: raise OperationFailedException()
        if sw1 == 0x6A and sw2 == 0x081: raise FunctionNotSupportedException()
        if sw1 != 0x90 and sw2 == 0x00: raise UnknownReaderException()

    def GetSerialNumber(self):
        APDU = [0xFF, 0xCA, 0x00, 0x00, 0x04]
        data, sw1, sw2 = self.sendAPDU(APDU)
        self.ParseResponce(sw1, sw2)
        return data

    def LoadAuthenticationKeys(self, key, key_location = 0):
        if not isinstance(key, list): raise FunctionArgumentException()
        if len(key) != 6: raise FunctionArgumentException()
        if not key_location in [0x00,0x01]: raise FunctionArgumentException()
        APDU = [0xFF, 0x82, 0x00, key_location, 0x06] + key
        data, sw1, sw2 = self.sendAPDU(APDU)
        self.ParseResponce(sw1, sw2)

    def Authentication(self, block, use_key_A, key_location = 0):
        if not isinstance(block, int): raise FunctionArgumentException()
        if block < 0 or block > 255: raise FunctionArgumentException()
        if not isinstance(use_key_A, bool): raise FunctionArgumentException()
        if not key_location in [0x00,0x01]: raise FunctionArgumentException()

        KEY_TYPE = [0x60, 0x61][int(not use_key_A)]
        AUTHENTICATION_DATA = [0x01, 0x00, block, KEY_TYPE, key_location]
        APDU = [0xFF, 0x86, 0x00, 0x00, 0x05] + AUTHENTICATION_DATA
        data, sw1, sw2 = self.sendAPDU(APDU)
        self.ParseResponce(sw1, sw2)

    def TryAuthentication(self, block, use_key_A, key_location = 0):
        KEY_TYPE = [0x60, 0x61][int(not use_key_A)]
        AUTHENTICATION_DATA = [0x01, 0x00, block, KEY_TYPE, key_location]
        APDU = [0xFF, 0x86, 0x00, 0x00, 0x05] + AUTHENTICATION_DATA
        data, sw1, sw2 = self.sendAPDU(APDU)
        if sw1 != 0x90 and sw2 == 0x00:
            return False
        return True

    def ReadBinaryBlocks(self, block, bytesNum):
        if not isinstance(block, int): raise FunctionArgumentException()
        if block < 0 or block > 255: raise FunctionArgumentException()
        if not isinstance(bytesNum, int): raise FunctionArgumentException()
        if bytesNum < 0: raise FunctionArgumentException()
        APDU = [0xFF, 0xB0, 0x00, block, bytesNum]
        data, sw1, sw2 = self.sendAPDU(APDU)
        self.ParseResponce(sw1, sw2)
        return data

    def WriteBinaryBlocks(self, block, bytes):
        if not isinstance(block, int): raise FunctionArgumentException()
        if block < 0 or block > 255: raise FunctionArgumentException()
        if not isinstance(bytes, list): raise FunctionArgumentException()
        if not len(bytes) in [4, 16]: raise FunctionArgumentException()
        APDU = [0xFF, 0xD6, 0x00, block, len(bytes)] + bytes
        data, sw1, sw2 = self.sendAPDU(APDU)
        self.ParseResponce(sw1, sw2)

from __future__ import print_function
from ACR122_Reader import *

DEFAULT_KEY = [0xff, 0xff, 0xff, 0xff, 0xff, 0xff]

def dump_mifare_sectors(reader, sectors, key = DEFAULT_KEY):
    for sector in sectors:
        dump_mifare_sector(reader, sector, key)

def dump_mifare_sector(reader, sector, key = DEFAULT_KEY):
    print("=========== sector {} ===============".format(sector))
    start_block = sector * 4
    number_of_blocks = 4
    if sector > 31:
        start_block = 32 * 4 + 16 * (sector - 32)
        number_of_blocks = 16

    reader.LoadAuthenticationKeys(key)
    reader.Authentication(start_block, True)
    for i in range(number_of_blocks):
        block_num = start_block + i
        data = reader.ReadBinaryBlocks(block_num, 16)
        data = ' '.join('%02x'%i for i in data)
        print("block [{0:02d} | {1:02d}]     {2}".format(block_num, i, data))

def main():
    try:
        reader = ACR122_Reader()
        print()
        print("Selected reader is: {} ver. {} serial: {}".format(reader.getReader(), reader.getFirmwareVersion(),reader.GetSerialNumber()))
        reader.showATRInfo()

        dump_mifare_sectors(reader, [0, 1])
        reader.close()

    except CardException:
        print('ERROR card problem')
    except NoACR122ReaderException:
        print('ERROR no ACR122 reader connected')
    except OperationFailedException:
        print('ERROR Operation Failed')
    except FunctionNotSupportedException:
        print('ERROR Function Not Supported')
    except UnknownReaderException:
        print('ERROR Unknown Reader Exception')
    except FunctionArgumentException:
        print('ERROR Wrong argument')

if __name__ == "__main__":
    main( )