nfctester 0.0.35__py3-none-any.whl

nfctester/__init__.py

@@ -0,0 +1,4 @@
+from .trace.manager import trace
+from .drivers.pn532_hsu import PN532_HSU
+
+__all__ = ["trace", "PN532_HSU"]

nfctester/cards/__init__.py

@@ -0,0 +1,8 @@
+from .base_card import BaseCard
+from .base_tag import BaseTag
+from .mifare_classic import MifareClassicCard
+from .ntag21x import NTAG21x
+from .ntag224 import NTAG224
+from .type2tag import Type2Tag
+
+__all__ = ["BaseCard", "BaseTag", "MifareClassicCard", "NTAG21x", "NTAG224", "Type2Tag"]

nfctester/cards/base_card.py

@@ -0,0 +1,46 @@
+from abc import ABC, abstractmethod
+
+
+class BaseCard(ABC):
+    """
+    加密卡基类 (如 Mifare Classic)
+    """
+
+    def __init__(self, reader, uid: bytes):
+        self.reader = reader
+        self.uid = uid
+
+    @abstractmethod
+    def authenticate(self, block_addr: int, key: bytes, key_type: int) -> bool:
+        """执行认证逻辑"""
+        pass
+
+    @abstractmethod
+    def read_block(self, block_addr: int) -> bytes:
+        """读取块数据"""
+        pass
+
+    @abstractmethod
+    def write_block(self, block_addr: int, data: bytes) -> bool:
+        """写入块数据"""
+        pass
+
+    @abstractmethod
+    def increment_block(self, block_addr: int, value: int) -> bool:
+        """递增块"""
+        pass
+
+    @abstractmethod
+    def decrement_block(self, block_addr: int, value: int) -> bool:
+        """递减块"""
+        pass
+
+    @abstractmethod
+    def restore_block(self, block_addr: int) -> bool:
+        """恢复块"""
+        pass
+
+    @abstractmethod
+    def transfer_block(self, block_addr: int) -> bool:
+        """传输块"""
+        pass

nfctester/cards/base_tag.py

@@ -0,0 +1,25 @@
+from abc import ABC, abstractmethod
+
+
+class BaseTag(ABC):
+    """
+    RFID 标签基类
+    """
+
+    def __init__(self, reader, uid: bytes):
+        self.reader = reader
+        self.uid = uid
+
+    def transceive(self, data: bytes) -> bytes:
+        """透传数据到读卡器"""
+        return self.reader.transceive(data)
+
+    @abstractmethod
+    def read_page(self, page_addr: int) -> bytes:
+        """读取页数据"""
+        pass
+
+    @abstractmethod
+    def write_page(self, page_addr: int, data: bytes) -> bool:
+        """写入页数据"""
+        pass

nfctester/cards/mifare_classic.py

@@ -0,0 +1,71 @@
+from .base_card import BaseCard
+
+
+class MifareClassicCard(BaseCard):
+    """MIFARE Classic 完整操作实现"""
+    
+    CMD_AUTHENT = 0x40
+    CMD_READ = 0x30
+    CMD_WRITE = 0xA0
+    CMD_INCREMENT = 0xC1
+    CMD_DECREMENT = 0xC0
+    CMD_RESTORE = 0xC2
+    CMD_TRANSFER = 0xB0
+
+    def __init__(self, reader, uid: bytes):
+        super().__init__(reader, uid)
+
+    def authenticate(self, block_addr: int, key: bytes, key_type: int = 0x60) -> bool:
+        """
+        MIFARE Classic 认证 (使用 PN532 硬件实现)
+        :param block_addr: 块地址
+        :param key: 6 字节密钥
+        :param key_type: 0x60 (KeyA) 或 0x61 (KeyB)
+        """
+        if len(key) != 6:
+            raise ValueError("Key must be 6 bytes")
+        
+        # 使用读卡器提供的 exchange (InDataExchange 自动封装)
+        res = self.reader.exchange(bytes([key_type, block_addr]) + key + self.uid)
+        return res is not None
+
+    def increment_block(self, block_addr: int, value: int) -> bool:
+        """对块进行递增操作"""
+        if not (0 <= value < (1 << 32)):
+            raise ValueError("value must be a 32-bit unsigned integer")
+        cmd = bytes([self.CMD_INCREMENT, block_addr]) + value.to_bytes(4, "little")
+        res = self.reader.exchange(cmd)
+        return res is not None
+
+    def decrement_block(self, block_addr: int, value: int) -> bool:
+        """对块进行递减操作"""
+        if not (0 <= value < (1 << 32)):
+            raise ValueError("value must be a 32-bit unsigned integer")
+        cmd = bytes([self.CMD_DECREMENT, block_addr]) + value.to_bytes(4, "little")
+        res = self.reader.exchange(cmd)
+        return res is not None
+
+    def restore_block(self, block_addr: int) -> bool:
+        """恢复块的临时值"""
+        cmd = bytes([self.CMD_RESTORE, block_addr])
+        res = self.reader.exchange(cmd)
+        return res is not None
+
+    def transfer_block(self, block_addr: int) -> bool:
+        """将临时值写回块"""
+        cmd = bytes([self.CMD_TRANSFER, block_addr])
+        res = self.reader.exchange(cmd)
+        return res is not None
+
+    def read_block(self, block_addr: int) -> bytes:
+        """读取块数据"""
+        cmd = bytes([self.CMD_READ, block_addr])
+        return self.reader.exchange(cmd)
+
+    def write_block(self, block_addr: int, data: bytes) -> bool:
+        """写入块数据"""
+        if len(data) != 16:
+            raise ValueError("Data must be 16 bytes")
+        cmd = bytes([self.CMD_WRITE, block_addr]) + data
+        res = self.reader.exchange(cmd)
+        return res is not None

nfctester/cards/ntag21x.py

@@ -0,0 +1,55 @@
+from .type2tag import Type2Tag
+
+
+class NTAG21x(Type2Tag):
+    """
+    NXP NTAG21x 系列专用驱动 (如 NTAG213, NTAG215, NTAG216)
+    """
+
+    CMD_GET_VERSION = 0x60
+    CMD_PWD_AUTH = 0x1B
+
+    def __init__(self, reader, uid: bytes):
+        super().__init__(reader, uid)
+
+    def get_version(self) -> bytes:
+        """
+        发送 0x60 指令，获取 8 字节版本信息
+        """
+        cmd = bytes([self.CMD_GET_VERSION])
+        return self.transceive(cmd)
+
+    def auth(self, password: bytes) -> bytes:
+        """
+        发送 0x1B 指令进行密码
+        认证认证流程说明：
+        1. 发送 0x1B + 4字节 PWD。
+        2. 如果 PWD 正确：芯片返回 2 字节的 PACK (Password Acknowledge)。
+            - PACK 的值存储在配置区的特定地址（如 NTAG213 的 Page 0x2C 的 Byte 0-1）。
+            - 默认值通常为 0x00 0x00，取决于生产商或之前的设置。
+        3. 如果 PWD 错误：芯片返回 4-bit 的 NAK (通常为 0x0)。
+            - 注意：驱动会将 NAK 视为传输错误或超时，返回0字节数据包。
+
+        :param password: 4 字节密码
+        :return: 2 字节的 PACK 响应
+        """
+        if len(password) != 4:
+            raise ValueError("NTAG21x password must be 4 bytes")
+
+        # 1. 组装指令: 0x1B + 4字节密码
+        cmd = bytes([self.CMD_PWD_AUTH]) + password
+        
+        # 2. 发送指令
+        # 注意：如果认证失败，芯片会返回 4-bit 的 NAK (0x0)，
+        # 许多读写器驱动（如 PN532）会将 NAK 转换成通信超时或传输错误异常。
+        res = self.transceive(cmd)
+        
+        # 3. 验证响应
+        if res is None or len(res) == 0:
+            raise PermissionError("Authentication failed: No response (NAK)")
+
+        # NTAG21x 认证成功会返回 2 字节的 PACK
+        if len(res) == 2:
+            return res 
+        else:
+            raise PermissionError(f"Authentication failed: Unexpected response length {len(res)}")

nfctester/cards/ntag224.py

@@ -0,0 +1,111 @@
+import secrets
+from .type2tag import Type2Tag
+from nfctester.crypto import AES128Crypto
+from nfctester.utils import BitOps
+from nfctester.trace import trace
+
+
+class NTAG224(Type2Tag):
+    """
+    NXP NTAG224 DNA 系列专用驱动
+    """
+
+    CMD_GET_VERSION = 0x60
+    CMD_PWD_AUTH_A = 0x1A
+    CMD_PWD_AUTH_A_RES = 0xAF
+    CMD_PWD_AUTH_B = 0xAF
+    CMD_PWD_AUTH_B_RES = 0x00
+
+    def __init__(self, reader, uid: bytes):
+        super().__init__(reader, uid)
+
+    def get_version(self) -> bytes:
+        """
+        发送 0x60 指令，获取 8 字节版本信息
+        """
+        cmd = bytes([self.CMD_GET_VERSION])
+        return self.transceive(cmd)
+
+    def write_key(self, key: bytes):
+        """
+        写入 16 字节 AES 密钥。
+        根据 NTAG224 规范，密钥需以反向字节序写入 Page 0x40-0x43。
+        """
+        if len(key) != 16:
+            raise ValueError("AES key must be 16 bytes")
+        
+        # 按照规范，字节序需要反转
+        reversed_key = key[::-1]
+        for i in range(4):
+            page_addr = 0x40 + i
+            chunk = reversed_key[i*4 : (i+1)*4]
+            self.write_page(page_addr, chunk)
+
+    def auth(self, password: bytes):
+        """
+        发送 0x1A 指令进行密码认证
+        认证流程说明：
+        1. 发送 0x1A + 0x00。
+        2. 接收 0xAF + 16byte ek(RndB)
+        3. 发送 0xAF + 32byte ek(RndA || RndB')
+        4. 接收 0x00 + 16byte ek(RndA')
+
+        :param password: 16 字节密码
+        """
+        if len(password) != 16:
+            raise ValueError("NTAG224 password must be 16 bytes")
+
+        crypto = AES128Crypto()
+
+        # 1. 获取加密随机数: 发送 0x1A + 0x00
+        cmd = bytes([self.CMD_PWD_AUTH_A, 0x00])
+        res = self.transceive(cmd)
+
+        if not res or res[0] != self.CMD_PWD_AUTH_A_RES or len(res) != 17:
+            raise PermissionError(f"Auth Step 1 failed: {res.hex() if res else 'No response'}")
+
+        ek_rndb = res[1:]
+        trace.debug(f"{'Received ek(RndB)':<25}: {ek_rndb.hex(' ').upper()}")
+
+        # 2. 解密 RndB 并生成 RndA
+        rndb = crypto.decrypt(ek_rndb, password)
+        rndb_prime = BitOps.rol(rndb)
+        trace.debug(f"{'Decrypted RndB':<25}: {rndb.hex(' ').upper()}")
+        trace.debug(f"{'Rotated RndB\'':<25}: {rndb_prime.hex(' ').upper()}")
+
+        # 调试用：固定值或伪随机数
+        # rnda = bytes.fromhex("00112233445566778899AABBCCDDEEFF")
+        rnda = secrets.token_bytes(16)
+        trace.debug(f"{'Generated RndA':<25}: {rnda.hex(' ').upper()}")
+
+        # 3. 加密 RndA || RndB' (使用 AES-128 ECB 模拟 CBC)
+        # Block 1: ek1 = AES_Encrypt(RndA)
+        ek1 = crypto.encrypt(rnda, password)
+        trace.debug(f"{'Encrypted Block 1 (ek1)':<25}: {ek1.hex(' ').upper()}")
+
+        # Block 2: ek2 = AES_Encrypt(RndB' ^ ek1)
+        xor_in = BitOps.xor(rndb_prime, ek1)
+        trace.debug(f"{'XOR Input for Block 2':<25}: {xor_in.hex(' ').upper()}")
+        ek2 = crypto.encrypt(xor_in, password)
+        trace.debug(f"{'Encrypted Block 2 (ek2)':<25}: {ek2.hex(' ').upper()}")
+
+        # 4. 发送 0xAF + ek1 + ek2
+        cmd = bytes([self.CMD_PWD_AUTH_B]) + ek1 + ek2
+        res = self.transceive(cmd)
+
+        if not res or res[0] != self.CMD_PWD_AUTH_B_RES or len(res) != 17:
+            raise PermissionError(f"Auth Step 2 failed: {res.hex() if res else 'No response'}")
+
+        ek_rnda_prime = res[1:]
+        trace.debug(f"{'Received ek(RndA\')':<25}: {ek_rnda_prime.hex(' ').upper()}")
+
+        # 5. 解密并验证 RndA'
+        # 根据 NTAG224 手册，此处解密使用 ECB 模式（或 IV 链重置）
+        rnda_prime_from_tag = crypto.decrypt(ek_rnda_prime, password)
+        expected_rnda_prime = BitOps.rol(rnda)
+
+        trace.debug(f"{'Decrypted RndA\'':<25}: {rnda_prime_from_tag.hex(' ').upper()}")
+        trace.debug(f"{'Expected RndA\'':<25}: {expected_rnda_prime.hex(' ').upper()}")
+
+        if rnda_prime_from_tag != expected_rnda_prime:
+            raise PermissionError("Authentication failed: RndA verification failed")

nfctester/cards/type2tag.py

@@ -0,0 +1,97 @@
+from .base_tag import BaseTag
+
+
+class Type2Tag(BaseTag):
+    """
+    NFC Forum Type 2 Tag 标准指令集实现 (如 NTAG21x 系列)
+    """
+
+    CMD_READ = 0x30
+    CMD_WRITE = 0xA2
+
+    def __init__(self, reader, uid: bytes):
+        super().__init__(reader, uid)
+
+    def read_page(self, page_addr: int) -> bytes:
+        """
+        读取页数据
+        T2T READ 指令会返回从 page_addr 开始的 16 字节 (即 4 个页的数据)
+        :param page_addr: 页地址
+        """
+        cmd = bytes([self.CMD_READ, page_addr])
+        res = self.transceive(cmd)
+        if not res:
+            raise RuntimeError(f"Type 2 Tag read_page(0x{page_addr:02X}) failed: No response from card")
+        return res
+
+    def write_page(self, page_addr: int, data: bytes):
+        """
+        写入页数据 (T2T 规范每次写入 4 字节)
+        :param page_addr: 页地址
+        :param data: 4 字节待写入数据
+        """
+        if len(data) != 4:
+            raise ValueError("Type 2 Tag write_page requires exactly 4 bytes of data")
+
+        cmd = bytes([self.CMD_WRITE, page_addr]) + data
+        self.reader.set_crc(True, False)
+        res = self.transceive(cmd)
+        self.reader.set_crc(True, True)
+
+        if not res:
+            raise RuntimeError(f"Type 2 Tag write_page(0x{page_addr:02X}) failed: No response from card")
+        if res != b'\x0A':
+            raise RuntimeError(f"Type 2 Tag write_page(0x{page_addr:02X}) failed: NAK(0x{res.hex(' ').upper()}) from card")
+        
+    def read_ndef(self) -> dict:
+        """
+        读取 NDEF 信息
+        逻辑：读取 Page 3 (CC) 获取容量，从 Page 4 开始解析 TLV 结构
+        """
+        # 1. 读取 CC (Page 3)
+        res = self.read_page(3)
+        cc = res[:4]
+        if cc[0] != 0xE1:
+            return {"cc": cc, "ndef": None}
+            
+        # cc[2] 是数据区大小 (ML), 单位 8 字节
+        capacity = cc[2] * 8
+        
+        # 2. 读取数据区并解析 TLV (从 Page 4 开始)
+        data = bytearray()
+        # 按照 4 页 (16 字节) 为单位批量读取
+        for p in range(4, 4 + (capacity // 4), 4):
+            data.extend(self.read_page(p))
+            
+        ndef = None
+        ptr = 0
+        while ptr < len(data):
+            t = data[ptr]
+            if t == 0x00: # NULL TLV
+                ptr += 1
+                continue
+            if t == 0xFE: # Terminator TLV
+                break
+                
+            # 解析 L (长度)
+            ptr += 1
+            if ptr >= len(data): break
+            l = data[ptr]
+            ptr += 1
+            if l == 0xFF: # 3 字节长度格式
+                if ptr + 1 >= len(data): break
+                l = (data[ptr] << 8) | data[ptr+1]
+                ptr += 2
+                
+            # 识别 NDEF TLV (0x03)
+            if t == 0x03:
+                ndef = bytes(data[ptr : ptr + l])
+                break
+                
+            ptr += l
+            
+        return {
+            "cc": cc,
+            "capacity": capacity,
+            "ndef": ndef
+        }

nfctester/crypto/__init__.py

@@ -0,0 +1,5 @@
+from .base_crypto import BaseCrypto
+from .aes128 import AES128Crypto
+from .crypto1 import MifareCrypto1
+
+__all__ = ["BaseCrypto", "AES128Crypto", "MifareCrypto1"]

nfctester/crypto/aes128.py

@@ -0,0 +1,27 @@
+from Crypto.Cipher import AES
+from .base_crypto import BaseCrypto
+
+
+class AES128Crypto(BaseCrypto):
+    """
+    AES-128 ECB 实现
+    """
+    
+    def _validate_params(self, indata: bytes, key: bytes):
+        # 密钥长度：16 bytes
+        if len(key) != 16:
+            raise ValueError(f"AES-128 ECB 密钥为 16 字节，当前长度为 {len(key)}")
+        
+        # 数据块长度：16 bytes
+        if len(indata) != 16:
+            raise ValueError(f"AES-128 ECB 数据为 16 字节，当前长度为 {len(indata)}")
+
+    def encrypt(self, indata: bytes, key: bytes) -> bytes:
+        self._validate_params(indata, key)
+        cipher = AES.new(key, AES.MODE_ECB)
+        return cipher.encrypt(indata)
+
+    def decrypt(self, indata: bytes, key: bytes) -> bytes:
+        self._validate_params(indata, key)
+        cipher = AES.new(key, AES.MODE_ECB)
+        return cipher.decrypt(indata)

nfctester/crypto/base_crypto.py

@@ -0,0 +1,26 @@
+from abc import ABC, abstractmethod
+
+class BaseCrypto(ABC):
+    """
+    加解密抽象基类
+    """
+
+    @abstractmethod
+    def encrypt(self, indata: bytes, key: bytes) -> bytes:
+        """
+        加密数据
+        :param indata: 输入原始数据
+        :param key: 密钥
+        :return: 加密后的字节流
+        """
+        pass
+
+    @abstractmethod
+    def decrypt(self, indata: bytes, key: bytes) -> bytes:
+        """
+        解密数据
+        :param indata: 输入加密数据
+        :param key: 密钥
+        :return: 解密后的原始字节流
+        """
+        pass

nfctester/crypto/crypto1.py

@@ -0,0 +1,163 @@
+from .base_crypto import BaseCrypto
+
+class MifareCrypto1(BaseCrypto):
+    """
+    Mifare Classic Crypto1 算法加解密实现类
+    有状态的流加密引擎
+    """
+    
+    def __init__(self):
+        self._state = None
+    
+    # LFSR 奇数和偶数部分的反馈多项式掩码
+    LF_POLY_ODD = 0x29CE5C
+    LF_POLY_EVEN = 0x870804
+
+    @staticmethod
+    def prng_successor(x_int: int, steps: int) -> int:
+        """
+        Mifare PRNG 后继函数 (算法归口)
+        :param x_int: 当前 PRNG 值
+        :param steps: 步进次数
+        :return: 更新后的 PRNG 值
+        """
+        x = x_int
+        for _ in range(steps):
+            x = (x >> 1) | (((x >> 0) ^ (x >> 2) ^ (x >> 3) ^ (x >> 5)) & 1) << 31
+        return x & 0xFFFFFFFF
+
+    @staticmethod
+    def _bit(x: int, n: int) -> int:
+        """获取整数 x 的第 n 位值 (0 或 1)"""
+        return (x >> n) & 1
+
+    @staticmethod
+    def _parity(x: int) -> int:
+        """计算 LFSR 内部特定的奇偶校验位"""
+        x ^= x >> 16
+        x ^= x >> 8
+        x ^= x >> 4
+        return MifareCrypto1._bit(0x6996, x & 0xf)
+
+    @staticmethod
+    def _filter(x: int) -> int:
+        """
+        Crypto1 算法的 2 级非线性滤波函数（Filter Function）
+        从当前 LFSR 中取出 20 bit，经过多重非线性布尔函数得出 1 bit 密钥流
+        """
+        f = (0xf22c0 >> (x & 0xf)) & 16
+        f |= (0x6c9c0 >> ((x >> 4) & 0xf)) & 8
+        f |= (0x3c8b0 >> ((x >> 8) & 0xf)) & 4
+        f |= (0x1e458 >> ((x >> 12) & 0xf)) & 2
+        f |= (0x0d938 >> ((x >> 16) & 0xf)) & 1
+        return MifareCrypto1._bit(0xEC57E80A, f)
+
+    class State:
+        """Crypto1 内部 LFSR 状态，模拟底层的硬件移位寄存器"""
+        def __init__(self, key: bytes = None, odd: int = None, even: int = None):
+            """
+            初始化 Crypto1 状态
+            :param key: 6 字节 Mifare 密钥 (可选)
+            :param odd: 寄存器奇数部分状态 (可选)
+            :param even: 寄存器偶数部分状态 (可选)
+            """
+            self.odd = odd if odd is not None else 0
+            self.even = even if even is not None else 0
+            
+            if key is not None:
+                # 将 6 bytes 密钥转为整数 (大端序)
+                key_int = int.from_bytes(key, byteorder='big')
+                self.odd = 0
+                self.even = 0
+                # 将 48 位 Mifare 密钥位按照大端与反转顺序交叉分离进入奇/偶寄存器中
+                # i 从 47 递减到 1 (步长为 2)
+                for i in range(47, -1, -2):
+                    self.odd = (self.odd << 1) | MifareCrypto1._bit(key_int, (i - 1) ^ 7)
+                    self.even = (self.even << 1) | MifareCrypto1._bit(key_int, i ^ 7)
+
+        def get_filter_bit(self) -> int:
+            """获取当前状态下的滤波输出位 (Keystream bit)"""
+            return MifareCrypto1._filter(self.odd)
+
+        def _shift(self, bit: int, feedback: bool = True) -> int:
+            """
+            执行单次移位与混淆 (原子操作)
+            :param bit: 输入位 (用于参与反馈或作为输入)
+            :param feedback: 是否启用 LFSR 反馈逻辑
+            :return: 当前生成的密钥流 bit (ks_bit)
+            """
+            # 获取当前的滤波输出位作为密钥流位 (在移位前)
+            ks_bit = self.get_filter_bit()
+
+            # 基础反馈来自于多项式掩码与当前状态的奇偶校验
+            feedin = (MifareCrypto1.LF_POLY_ODD & self.odd) ^ (MifareCrypto1.LF_POLY_EVEN & self.even)
+            # 如果开启反馈（即加密/同步模式），则将输入位混入反馈回路
+            if feedback:
+                feedin ^= bit
+            
+            # 推入反馈位并确保状态字截断在 32 位界限以内
+            new_even = ((self.even << 1) | MifareCrypto1._parity(feedin)) & 0xFFFFFFFF
+            self.odd, self.even = new_even, self.odd
+            
+            return ks_bit
+
+    def initialize(self, key: bytes):
+        """
+        重新实例化加密状态
+        :param key: 6 字节 Mifare 密钥
+        """
+        self._state = self.State(key=key)
+
+    def encrypt(self, indata: bytes, feedback: bool = True) -> bytes:
+        """
+        加密数据
+        :param indata: 输入原始数据 (bytes)
+        :param feedback: 是否启用反馈 (认证 Token 计算时通常为 False)
+        :return: 加密后的字节流 (bytes)
+        """
+        if self._state is None:
+            raise RuntimeError("MifareCrypto1 state not initialized. Call initialize() first.")
+            
+        out = bytearray()
+        for p_byte in indata:
+            c_byte = 0
+            # 在 Mifare 协议中，数据是逐 bit 处理的
+            for i in range(8):
+                # 1. 提取明文位并执行状态移位
+                p_bit = self._bit(p_byte, i)
+                ks_bit = self._state._shift(p_bit, feedback=feedback)
+                
+                # 2. 与流密钥异或得出密文位
+                c_bit = p_bit ^ ks_bit
+                c_byte |= (c_bit << i)
+                
+            out.append(c_byte)
+        return bytes(out)
+
+    def decrypt(self, indata: bytes, feedback: bool = True) -> bytes:
+        """
+        解密数据
+        :param indata: 输入加密数据 (bytes)
+        :param feedback: 是否启用反馈 (解密通常需要反馈以保持同步)
+        :return: 解密后的原始字节流 (bytes)
+        """
+        if self._state is None:
+            raise RuntimeError("MifareCrypto1 state not initialized. Call initialize() first.")
+            
+        out = bytearray()
+        for c_byte in indata:
+            p_byte = 0
+            for i in range(8):
+                # 1. 解密时先获取流密钥
+                ks_bit = self._state.get_filter_bit()
+                
+                # 2. 异或密文位得出明文位
+                c_bit = self._bit(c_byte, i)
+                p_bit = c_bit ^ ks_bit
+                p_byte |= (p_bit << i)
+                
+                # 3. 将明文位混入反馈状态中，保持状态机同步
+                self._state._shift(p_bit, feedback=feedback)
+                
+            out.append(p_byte)
+        return bytes(out)

nfctester/drivers/__init__.py

@@ -0,0 +1,4 @@
+from .card_reader import CardReader
+from .pn532_hsu import PN532_HSU
+
+__all__ = ["CardReader", "PN532_HSU"]