智能POS机深度分析

一、安全相关深度分析1.1 安全芯片驱动与加密算法树形分析/** * file pos_security_deep.h * brief POS机安全深度分析 */ ​ /** * defgroup POS_SECURITY POS机安全 * { */ ​ /* * 安全芯片架构树形分析 * * * POS机安全体系 * │ * ├── 1. 硬件安全层 * │ │ * │ ├── 安全芯片 (SE) * │ │ ├── 型号: MAXQ1050 / ATECC608A / NXP P71 * │ │ ├── 接口: I2C / SPI * │ │ ├── 功能: * │ │ │ ├── 密钥存储 (永不导出) * │ │ │ ├── 真随机数生成 (TRNG) * │ │ │ ├── 对称加密 (AES-128/192/256, 3DES) * │ │ │ ├── 非对称加密 (RSA 2048/4096, ECC P256) * │ │ │ ├── 哈希运算 (SHA-1/256/384/512) * │ │ │ └── 签名/验签 (ECDSA, RSA-PSS) * │ │ └── 安全特性: * │ │ ├── 物理防拆: 网格检测、温度/电压检测 * │ │ ├── 数据加密: 总线加密 * │ │ └── 自毁机制: 防拆触发后擦除密钥 * │ │ * │ ├── 安全启动 (Secure Boot) * │ │ ├── 原理: 签名链验证 * │ │ ├── 流程: ROM → Bootloader → Kernel → Rootfs * │ │ └── 保护: 防止篡改固件 * │ │ * │ └── 调试接口保护 * │ ├── JTAG/SWD: 烧写熔丝位禁用 * │ ├── UART: 物理断开或密码保护 * │ └── 测试点: 产测后覆盖或销毁 * │ * └── 2. 软件安全层 * │ * ├── 密钥管理 * │ ├── MK (Master Key): 安全芯片存储 * │ ├── KEK (Key Encryption Key): 加密其他密钥 * │ ├── DUKPT: 每笔交易唯一密钥 * │ └── 密钥轮换: 定期更新 * │ * ├── 交易加密 * │ ├── PIN加密: ISO 9564 * │ ├── 磁道加密: ISO 7811 * │ └── MAC校验: HMAC-SHA256 * │ * └── 安全通信 * ├── TLS 1.2/1.3 * ├── 证书锁定 (Certificate Pinning) * └── APN专线/VPN */ ​ /** * brief 安全芯片驱动封装 */ typedef struct { /* 硬件接口 */ int i2c_fd; /** I2C设备文件描述符 */ uint8_t i2c_addr; /** I2C从设备地址 */ /* 安全状态 */ struct { bool tamper_detected; /** 防拆触发 */ bool secure_boot_ok; /** 安全启动验证通过 */ bool debug_disabled; /** 调试接口禁用 */ uint32_t tamper_count; /** 防拆计数 */ time_t last_tamper_time; /** 最后防拆时间 */ } status; /* 密钥信息 */ struct { uint8_t mk_id; /** 主密钥ID */ uint8_t kek_id; /** 密钥加密密钥ID */ uint32_t key_derivation_count; /** 密钥派生计数 */ } keys; /* 互斥锁 (线程安全) */ pthread_mutex_t mutex; /* 统计 */ uint32_t cmd_count; /** 命令计数 */ uint32_t error_count; /** 错误计数 */ } secure_element_t; ​ /** * brief 安全芯片初始化 */ int secure_element_init(secure_element_t* se) { uint8_t status_reg; /* 1. 打开I2C设备 */ se-i2c_fd open(/dev/i2c-0, O_RDWR); if (se-i2c_fd 0) { ALOGE(Failed to open I2C device); return -1; } se-i2c_addr 0x30; /* MAXQ1050默认地址 */ ioctl(se-i2c_fd, I2C_SLAVE, se-i2c_addr); /* 2. 读取安全状态 */ pthread_mutex_lock(se-mutex); int ret secure_element_read_status(se, status_reg); pthread_mutex_unlock(se-mutex); if (ret 0) { ALOGE(Failed to read SE status); return -1; } /* 3. 检查防拆状态 */ if (status_reg 0x01) { se-status.tamper_detected true; se-status.tamper_count; se-status.last_tamper_time time(NULL); ALOGW(!!! TAMPER DETECTED !!!); /* 触发安全响应 */ secure_element_tamper_response(se); } /* 4. 检查安全启动 */ if (status_reg 0x02) { se-status.secure_boot_ok true; ALOGI(Secure boot verified); } else { ALOGE(Secure boot failed!); return -1; } ALOGI(Secure element initialized, status0x%02X, status_reg); return 0; } ​ /** * brief AES-256-CBC加密 */ int secure_element_aes_encrypt(secure_element_t* se, const uint8_t* key, uint32_t key_len, const uint8_t* iv, const uint8_t* plaintext, uint32_t plaintext_len, uint8_t* ciphertext, uint32_t* ciphertext_len) { pthread_mutex_lock(se-mutex); /* 构造APDU命令 */ uint8_t cmd[256]; int cmd_len 0; cmd[cmd_len] 0x80; /* CLA */ cmd[cmd_len] 0x1A; /* INS: AES Encrypt */ cmd[cmd_len] 0x00; /* P1 */ cmd[cmd_len] 0x00; /* P2 */ cmd[cmd_len] key_len; /* Lc */ memcpy(cmd cmd_len, key, key_len); cmd_len key_len; cmd[cmd_len] 16; /* IV长度 */ memcpy(cmd cmd_len, iv, 16); cmd_len 16; cmd[cmd_len] (plaintext_len 8) 0xFF; cmd[cmd_len] plaintext_len 0xFF; memcpy(cmd cmd_len, plaintext, plaintext_len); cmd_len plaintext_len; cmd[cmd_len] 0x00; /* Le */ /* 发送命令并接收响应 */ int ret secure_element_transmit(se, cmd, cmd_len, ciphertext, ciphertext_len); pthread_mutex_unlock(se-mutex); return ret; } ​ /** * brief ECDSA签名 */ int secure_element_ecdsa_sign(secure_element_t* se, uint8_t key_id, const uint8_t* hash, uint32_t hash_len, uint8_t* signature, uint32_t* sig_len) { pthread_mutex_lock(se-mutex); uint8_t cmd[256]; int cmd_len 0; cmd[cmd_len] 0x80; /* CLA */ cmd[cmd_len] 0x2A; /* INS: ECDSA Sign */ cmd[cmd_len] 0x00; /* P1 */ cmd[cmd_len] key_id; /* P2: 密钥ID */ cmd[cmd_len] hash_len; /* Lc */ memcpy(cmd cmd_len, hash, hash_len); cmd_len hash_len; cmd[cmd_len] 0x00; /* Le */ int ret secure_element_transmit(se, cmd, cmd_len, signature, sig_len); pthread_mutex_unlock(se-mutex); return ret; } ​ /** * brief DUKPT密钥派生 */ int secure_element_dukpt_derive(secure_element_t* se, const uint8_t* bdk, uint64_t ksn, uint8_t* pek) { pthread_mutex_lock(se-mutex); uint8_t cmd[256]; int cmd_len 0; cmd[cmd_len] 0x80; /* CLA */ cmd[cmd_len] 0x2C; /* INS: DUKPT Derive */ cmd[cmd_len] 0x00; /* P1 */ cmd[cmd_len] 0x00; /* P2 */ cmd[cmd_len] 16; /* BDK长度 */ memcpy(cmd cmd_len, bdk, 16); cmd_len 16; cmd[cmd_len] 8; /* KSN长度 */ memcpy(cmd cmd_len, ksn, 8); cmd_len 8; uint32_t pek_len 16; int ret secure_element_transmit(se, cmd, cmd_len, pek, pek_len); pthread_mutex_unlock(se-mutex); return ret; } ​ /** * brief 防拆响应 */ void secure_element_tamper_response(secure_element_t* se) { ALOGW(!!! SECURITY TAMPER RESPONSE !!!); /* 1. 擦除所有密钥 */ uint8_t cmd[] {0x80, 0xE0, 0x00, 0x00, 0x00}; uint8_t resp[2]; uint32_t resp_len 2; secure_element_transmit(se, cmd, sizeof(cmd), resp, resp_len); /* 2. 擦除敏感数据区 */ uint8_t erase_cmd[] {0x80, 0xE4, 0x00, 0x00, 0x00}; secure_element_transmit(se, erase_cmd, sizeof(erase_cmd), resp, resp_len); /* 3. 记录事件到安全日志 */ secure_log_event(SECURE_EVENT_TAMPER, Physical tamper detected); /* 4. 可选: 永久锁定设备 */ // uint8_t lock_cmd[] {0x80, 0xE8, 0x00, 0x00, 0x00}; // secure_element_transmit(se, lock_cmd, sizeof(lock_cmd), resp, resp_len); /* 5. 触发系统警报 */ system(echo 1 /sys/class/leds/tamper/brightness); system(aplay /usr/share/sounds/alarm.wav); } ​ /* * PCI PTS标准意识 * */ ​ /** * brief PCI PTS安全要求树形分析 * * PCI PTS (PIN Transaction Security) 标准 * │ * ├── 1. 物理安全 * │ ├── 防拆检测 * │ │ ├── 网格保护层: PCB走线检测 * │ │ ├── 开关检测: 外壳打开触发 * │ │ ├── 温度检测: 超出范围触发 * │ │ └── 电压检测: 异常电压触发 * │ │ * │ ├── 外壳安全 * │ │ ├── 防钻/防撬: 特殊螺丝、密封胶 * │ │ ├── 防窥: PIN输入遮罩 * │ │ └── 防拆标签: 易碎贴纸 * │ │ * │ └── 电路安全 * │ ├── 安全芯片: 专用封装 * │ ├── 总线加密: 敏感信号加密 * │ └── 电源滤波: 防止侧信道攻击 * │ * ├── 2. 逻辑安全 * │ ├── 调试接口 * │ │ ├── JTAG: 熔丝位永久禁用 * │ │ ├── UART: 产测后物理断开 * │ │ └── 测试点: 覆盖或销毁 * │ │ * │ ├── 安全启动 * │ │ ├── 签名验证: 每一级都验证 * │ │ ├── 回滚保护: 禁止降级 * │ │ └── 安全更新: 签名固件 * │ │ * │ └── 密钥管理 * │ ├── 密钥生命周期: 生成→分发→使用→销毁 * │ ├── 密钥隔离: 不同用途不同密钥 * │ └── 密钥轮换: 定期更新 * │ * └── 3. 环境要求 * ├── 温度: 0-70°C * ├── 湿度: 10-90% * └── ESD: ±8kV接触放电 */ ​ /** * brief 禁用调试接口 */ void disable_debug_interfaces(void) { /* 1. 禁用JTAG (写熔丝位) */ FILE* fp fopen(/sys/class/misc/fuse/jtag_disable, w); if (fp) { fprintf(fp, 1); fclose(fp); ALOGI(JTAG disabled); } /* 2. 禁用UART调试口 */ system(stty -F /dev/ttyS0 0); system(echo 0 /sys/class/tty/ttyS0/console); /* 3. 禁用ADB (Android) */ system(setprop persist.adb.enable 0); system(stop adbd); /* 4. 擦除测试点 */ // 硬件: 覆盖测试点或销毁 } ​ /** * brief 防拆检测实现 */ typedef struct { /* 防拆检测引脚 */ int tamper_gpio; /** 防拆GPIO */ int tamper_irq; /** 防拆中断 */ /* 状态 */ bool tamper_triggered; /** 是否已触发 */ uint32_t tamper_count; /** 触发次数 */ time_t last_tamper_time; /** 最后触发时间 */ /* 回调 */ void (*on_tamper)(void); /** 防拆回调 */ } tamper_detector_t; ​ /** * brief 防拆检测初始化 */ void tamper_detector_init(tamper_detector_t* detector) { /* 1. 配置GPIO中断 */ gpio_request(detector-tamper_gpio, tamper); gpio_direction_input(detector-tamper_gpio); gpio_set_debounce(detector-tamper_gpio, 50); /* 50ms去抖 */ /* 2. 注册中断 */ request_irq(detector-tamper_irq, tamper_isr, IRQF_TRIGGER_FALLING, tamper, detector); /* 3. 检查历史状态 */ int val gpio_get_value(detector-tamper_gpio); if (val 0) { /* 防拆已触发 */ detector-tamper_triggered true; detector-tamper_count; detector-last_tamper_time time(NULL); if (detector-on_tamper) { detector-on_tamper(); } } } ​ /** * brief 防拆中断服务程序 */ static irqreturn_t tamper_isr(int irq, void* dev_id) { tamper_detector_t* detector (tamper_detector_t*)dev_id; /* 记录防拆事件 */ detector-tamper_triggered true; detector-tamper_count; detector-last_tamper_time time(NULL); /* 安全日志 */ secure_log_event(SECURE_EVENT_TAMPER, Tamper interrupt triggered); /* 触发安全响应 (立即执行不调度) */ if (detector-on_tamper) { detector-on_tamper(); } return IRQ_HANDLED; } ​ /** } */二、外设驱动稳定性深度分析2.1 磁条卡解码 (ISO 7811)/** * file msr_driver_deep.h * brief 磁条卡驱动深度分析 */ ​ /** * defgroup MSR_DRIVER 磁条卡驱动 * { */ ​ /* * 磁条卡解码树形分析 * * * 磁条卡数据结构 (ISO 7811) * │ * ├── 磁道1 (Track 1) * │ ├── 格式: %B[卡号]^[姓名]^[有效期]? * │ ├── 字符: 79字符, 字母数字 * │ ├── 起始符: % (0x25) * │ └── 结束符: ? (0x3F) * │ * ├── 磁道2 (Track 2) * │ ├── 格式: ;[卡号][有效期]? * │ ├── 字符: 40字符, 数字 * │ ├── 起始符: ; (0x3B) * │ └── 结束符: ? (0x3F) * │ * └── 磁道3 (Track 3) * ├── 格式: [数据]? * ├── 字符: 107字符 * ├── 起始符: (0x2B) * └── 结束符: ? (0x3F) */ ​ /** * brief 磁条卡数据结构 */ typedef struct { /* 磁道数据 */ char track1[80]; /** 磁道1数据 */ char track2[41]; /** 磁道2数据 */ char track3[108]; /** 磁道3数据 */ /* 解析后的字段 */ struct { char card_number[20]; /** 卡号 */ char name[30]; /** 持卡人姓名 */ char expire_date[5]; /** 有效期 (YYMM) */ char service_code[3]; /** 服务代码 */ } parsed; /* 加密数据 */ uint8_t encrypted_track1[128]; /** 加密磁道1 */ uint8_t encrypted_track2[64]; /** 加密磁道2 */ uint32_t encrypted_len; /* 状态 */ bool valid; /** 是否有效 */ uint32_t crc; /** CRC校验 */ } msr_data_t; ​ /** * brief 磁条卡解码器 */ typedef struct { /* UART设备 */ int uart_fd; /** UART文件描述符 */ char dev_path[32]; /** 设备路径 */ /* 接收缓冲区 */ uint8_t rx_buffer[512]; /** 接收缓冲区 */ uint32_t rx_len; /** 已接收长度 */ /* 解码状态机 */ enum { MSR_STATE_IDLE 0, /** 空闲 */ MSR_STATE_TRACK1, /** 接收磁道1 */ MSR_STATE_TRACK2, /** 接收磁道2 */ MSR_STATE_TRACK3 /** 接收磁道3 */ } state; /* 当前磁道数据 */ char current_track[128]; int track_index; /* 安全芯片 */ secure_element_t* se; /** 安全芯片句柄 */ /* 互斥锁 */ pthread_mutex_t mutex; /* 统计 */ uint32_t swipe_count; /** 刷卡次数 */ uint32_t decode_success; /** 解码成功次数 */ uint32_t decode_error; /** 解码错误次数 */ } msr_decoder_t; ​ /** * brief 磁条卡解码 (UART中断驱动) */ int msr_decode(msr_decoder_t* msr, uint8_t data) { pthread_mutex_lock(msr-mutex); int ret 0; switch (msr-state) { case MSR_STATE_IDLE: /* 检测起始符 */ if (data %) { msr-state MSR_STATE_TRACK1; msr-track_index 0; msr-current_track[msr-track_index] data; } else if (data ;) { msr-state MSR_STATE_TRACK2; msr-track_index 0; msr-current_track[msr-track_index] data; } else if (data ) { msr-state MSR_STATE_TRACK3; msr-track_index 0; msr-current_track[msr-track_index] data; } break; case MSR_STATE_TRACK1: msr-current_track[msr-track_index] data; if (data ? msr-track_index 2) { /* 磁道1结束 */ msr-current_track[msr-track_index] \0; strncpy(msr-data.track1, msr-current_track, sizeof(msr-data.track1)); msr-state MSR_STATE_IDLE; msr-data.valid true; ret 1; /* 完整刷卡完成 */ } break; case MSR_STATE_TRACK2: msr-current_track[msr-track_index] data; if (data ? msr-track_index 2) { msr-current_track[msr-track_index] \0; strncpy(msr-data.track2, msr-current_track, sizeof(msr-data.track2)); msr-state MSR_STATE_IDLE; } break; case MSR_STATE_TRACK3: msr-current_track[msr-track_index] data; if (data ? msr-track_index 2) { msr-current_track[msr-track_index] \0; strncpy(msr-data.track3, msr-current_track, sizeof(msr-data.track3)); msr-state MSR_STATE_IDLE; } break; } pthread_mutex_unlock(msr-mutex); return ret; } ​ /** * brief 解析磁条卡数据 */ int msr_parse_data(msr_data_t* data) { /* 解析磁道1: %B1234567890123456^ZHANG/SAN^2512? */ if (data-track1[0] %) { char* start >2.3 热敏打印机驱动/** * file printer_driver_deep.h * brief 热敏打印机驱动深度分析 */ ​ /** * defgroup PRINTER_DRIVER 热敏打印机驱动 * { */ ​ /* * 热敏打印机驱动树形分析 * * * 热敏打印机架构 * │ * ├── 1. 硬件接口 * │ ├── 步进电机: 控制走纸 * │ │ ├── 相序: 2相/4相 * │ │ ├── 步距: 0.125mm/步 * │ │ └── 速度: 50-100mm/s * │ │ * │ ├── 热敏头: 控制加热 * │ │ ├── 分辨率: 8点/mm (203DPI) * │ │ ├── 宽度: 384点 (48mm) * │ │ ├── 电压: 24V * │ │ └── 加热时间: 0.5-2ms * │ │ * │ └── 传感器 * │ ├── 缺纸检测: 光电传感器 * │ ├── 温度检测: NTC热敏电阻 * │ └── 舱门检测: 微动开关 * │ * └── 2. 驱动控制 * ├── 步进电机控制: PWM脉冲序列 * ├── 热敏头控制: 数据锁存加热脉冲 * ├── 缺纸处理: 停止打印并报警 * └── 过热保护: 降低打印速度或暂停 */ ​ /** * brief 打印机控制结构 */ typedef struct { /* GPIO引脚 */ int motor_a_pin; /** 电机A相 */ int motor_b_pin; /** 电机B相 */ int motor_c_pin; /** 电机C相 */ int motor_d_pin; /** 电机D相 */ int strobe_pin; /** 加热选通 */ int data_pin; /** 数据引脚 */ int clock_pin; /** 时钟引脚 */ int paper_detect_pin; /** 缺纸检测 */ int temp_pin; /** 温度检测(ADC) */ /* 打印参数 */ struct { int dot_width; /** 点宽(384) */ int dot_height; /** 点高(8) */ int print_speed; /** 打印速度(mm/s) */ int heating_time_us; /** 加热时间(μs) */ int heating_interval_us;/** 加热间隔(μs) */ } params; /* 状态 */ struct { bool paper_present; /** 有纸 */ bool cover_closed; /** 舱门关闭 */ bool overheating; /** 过热 */ bool printing; /** 打印中 */ } status; /* 打印缓冲区 */ uint8_t print_buffer[384]; /** 一行打印数据 */ /* 互斥锁 */ pthread_mutex_t mutex; pthread_cond_t cond; /* 线程 */ pthread_t print_thread; bool print_thread_running; /* 队列 */ struct print_job { uint8_t* data; /** 打印数据 */ uint32_t lines; /** 行数 */ struct print_job* next; } *job_queue; uint32_t job_count; /* 统计 */ uint32_t print_lines; /** 打印行数 */ uint32_t paper_out_errors; /** 缺纸错误 */ uint32_t overheat_errors; /** 过热错误 */ } printer_driver_t; ​ /** * brief 步进电机控制 (四相八拍) */ void printer_step_motor(printer_driver_t* printer, int steps) { /* 步进电机相序表 (四相八拍) */ static const uint8_t phase_table[8] { 0x01, 0x03, 0x02, 0x06, 0x04, 0x0C, 0x08, 0x09 }; int direction (steps 0) ? 1 : -1; int step_count abs(steps); for (int i 0; i step_count; i) { int phase (phase_index direction 8) % 8; /* 输出相序 */ gpio_set_value(printer-motor_a_pin, phase_table[phase] 0x01); gpio_set_value(printer-motor_b_pin, (phase_table[phase] 1) 0x01); gpio_set_value(printer-motor_c_pin, (phase_table[phase] 2) 0x01); gpio_set_value(printer-motor_d_pin, (phase_table[phase] 3) 0x01); /* 延时 (步进周期) */ usleep(1000000 / (printer-params.print_speed * 8)); phase_index phase; } } ​ /** * brief 打印一行 */ int printer_print_line(printer_driver_t* printer, const uint8_t* data) { /* 1. 检查缺纸 */ int paper_detect gpio_get_value(printer-paper_detect_pin); if (paper_detect 0) { printer-status.paper_present false; printer-paper_out_errors; ALOGE(Paper out!); return -1; } /* 2. 检查温度 */ int temp adc_read(printer-temp_pin); if (temp 70) { /* 70°C过热 */ printer-status.overheating true; printer-overheat_errors; ALOGW(Overheating! temp%d°C, temp); usleep(500000); /* 等待冷却 */ } /* 3. 加载打印数据 (384点 48字节) */ for (int i 0; i 48; i) { /* 移位寄存器加载数据 */ for (int bit 0; bit 8; bit) { int data_bit (data[i] bit) 0x01; gpio_set_value(printer-data_pin, data_bit); gpio_set_value(printer-clock_pin, 1); usleep(1); gpio_set_value(printer-clock_pin, 0); } } /* 4. 加热 */ gpio_set_value(printer-strobe_pin, 1); usleep(printer-params.heating_time_us); gpio_set_value(printer-strobe_pin, 0); usleep(printer-params.heating_interval_us); /* 5. 走纸 (0.125mm) */ printer_step_motor(printer, 1); printer-print_lines; return 0; } ​ /** * brief 打印线程 (异步打印) */ void* printer_print_thread(void* arg) { printer_driver_t* printer (printer_driver_t*)arg; while (printer-print_thread_running) { pthread_mutex_lock(printer-mutex); /* 等待打印任务 */ while (printer-job_queue NULL printer-print_thread_running) { pthread_cond_wait(printer-cond, printer-mutex); } if (!printer-print_thread_running) { pthread_mutex_unlock(printer-mutex); break; } /* 取出任务 */ struct print_job* job printer-job_queue; printer-job_queue job-next; printer-job_count--; pthread_mutex_unlock(printer-mutex); /* 执行打印 */ printer-status.printing true; for (uint32_t line 0; line job-lines; line) { printer_print_line(printer, job-data line * 48); } printer-status.printing false; /* 释放任务内存 */ free(job-data); free(job); } return NULL; } ​ /** * brief 提交打印任务 (异步非阻塞) */ int printer_submit_job(printer_driver_t* printer, uint8_t* data, uint32_t lines) { pthread_mutex_lock(printer-mutex); /* 检查缺纸 */ if (!printer-status.paper_present) { pthread_mutex_unlock(printer-mutex); return -1; } /* 分配任务 */ struct print_job* job malloc(sizeof(struct print_job)); if (!job) { pthread_mutex_unlock(printer-mutex); return -1; } job-data malloc(lines * 48); if (!job-data) { free(job); pthread_mutex_unlock(printer-mutex); return -1; } memcpy(job-data, data, lines * 48); job-lines lines; job-next NULL; /* 加入队列 */ if (printer-job_queue NULL) { printer-job_queue job; } else { struct print_job* last printer-job_queue; while (last-next) last last-next; last-next job; } printer-job_count; /* 唤醒打印线程 */ pthread_cond_signal(printer-cond); pthread_mutex_unlock(printer-mutex); return 0; } ​ /** * brief 缺纸检测中断 */ static irqreturn_t paper_detect_isr(int irq, void* dev_id) { printer_driver_t* printer (printer_driver_t*)dev_id; int paper_present gpio_get_value(printer-paper_detect_pin); if (!paper_present) { /* 缺纸停止打印 */ printer-status.paper_present false; ALOGW(Paper out detected!); /* 清除打印队列 */ pthread_mutex_lock(printer-mutex); while (printer-job_queue) { struct print_job* job printer-job_queue; printer-job_queue job-next; free(job-data); free(job); } printer-job_count 0; pthread_mutex_unlock(printer-mutex); } else { printer-status.paper_present true; ALOGI(Paper inserted); } return IRQ_HANDLED; } ​ /** } */2.4 多线程并发资源互斥/** * file pos_concurrency.h * brief 多线程并发资源管理 */ ​ /** * defgroup POS_CONCURRENCY POS机并发管理 * { */ ​ /* * 多线程并发树形分析 * * * POS机多线程并发场景 * │ * ├── 1. 资源竞争场景 * │ ├── 刷卡同时打印 * │ │ ├── 资源: UART (磁条卡) SPI (打印机) * │ │ └── 风险: 无直接冲突但需要CPU时间片 * │ │ * │ ├── 交易同时上传 * │ │ ├── 资源: 4G模块 (共享) * │ │ └── 风险: 同时使用导致数据混乱 * │ │ * │ ├── 安全芯片同时调用 * │ │ ├── 资源: I2C总线 * │ │ └── 风险: 总线冲突数据损坏 * │ │ * │ └── 日志写入 * │ ├── 资源: 文件系统 * │ └── 风险: 多线程写文件损坏 * │ * ├── 2. 互斥策略 * │ ├── 互斥锁 (Mutex) * │ │ ├── 适用: 保护共享资源 * │ │ ├── 风险: 死锁、优先级反转 * │ │ └── 解决: 固定锁顺序、超时 * │ │ * │ ├── 读写锁 (RWLock) * │ │ ├── 适用: 读多写少场景 * │ │ └── 优势: 提高并发度 * │ │ * │ ├── 信号量 (Semaphore) * │ │ ├── 适用: 资源计数 * │ │ └── 示例: 控制并发数 * │ │ * │ └── 无锁队列 (Lock-free Queue) * │ ├── 适用: 生产者-消费者模式 * │ └── 优势: 避免锁竞争 * │ * └── 3. 死锁预防 * ├── 固定锁顺序: 所有线程按相同顺序获取锁 * ├── 锁超时: pthread_mutex_timedlock * ├── 避免嵌套: 尽量减少锁内调用其他锁 * └── 看门狗: 检测线程卡死并恢复 */ ​ /** * brief 资源管理器 */ typedef struct { /* 互斥锁 */ pthread_mutex_t se_mutex; /** 安全芯片锁 */ pthread_mutex_t msr_mutex; /** 磁条卡锁 */ pthread_mutex_t printer_mutex; /** 打印机锁 */ pthread_mutex_t net_mutex; /** 网络锁 */ pthread_mutex_t log_mutex; /** 日志锁 */ /* 读写锁 (配置信息) */ pthread_rwlock_t config_rwlock; /** 配置读写锁 */ /* 信号量 (限制并发) */ sem_t network_sem; /** 网络并发信号量 */ /* 死锁检测 */ struct { pthread_t owner; /** 锁持有者 */ uint32_t acquire_time; /** 获取时间 */ uint32_t timeout_ms; /** 超时时间 */ } lock_info[5]; /* 统计 */ uint32_t lock_acquire_count; /** 锁获取次数 */ uint32_t lock_timeout_count; /** 锁超时次数 */ uint32_t deadlock_count; /** 死锁次数 */ } resource_manager_t; ​ static resource_manager_t g_res; ​ /** * brief 安全芯片操作 (带超时锁) */ int secure_element_operation_safe(secure_element_t* se, const uint8_t* cmd, uint32_t cmd_len, uint8_t* resp, uint32_t* resp_len) { struct timespec timeout; clock_gettime(CLOCK_REALTIME, timeout); timeout.tv_sec 5; /* 5秒超时 */ /* 使用超时锁 */ int ret pthread_mutex_timedlock(g_res.se_mutex, timeout); if (ret ETIMEDOUT) { g_res.lock_timeout_count; ALOGE(SE mutex timeout after 5 seconds); return -1; } if (ret ! 0) { ALOGE(SE mutex lock failed: %d, ret); return -1; } /* 记录锁持有者 */ g_res.lock_info[0].owner pthread_self(); g_res.lock_info[0].acquire_time time(NULL); /* 执行安全芯片操作 */ ret secure_element_transmit(se, cmd, cmd_len, resp, resp_len); /* 释放锁 */ g_res.lock_info[0].owner 0; pthread_mutex_unlock(g_res.se_mutex); return ret; } ​ /** * brief 磁条卡打印机并发处理 (互斥锁示例) */ void msr_and_printer_concurrent(msr_decoder_t* msr, printer_driver_t* printer) { /* 创建线程: 刷卡线程 */ pthread_t msr_thread; pthread_create(msr_thread, NULL, msr_thread_func, msr); /* 创建线程: 打印线程 */ pthread_t printer_thread; pthread_create(printer_thread, NULL, printer_print_thread, printer); /* 主线程: 处理交易 */ while (1) { /* 等待刷卡事件 */ if (msr_wait_swipe(msr, 30000) 0) { msr_data_t data; msr_get_data(msr, data); /* 解析磁条卡 */ msr_parse_data(data); /* 加密数据 (需要安全芯片锁) */ secure_element_operation_safe(msr-se, ...); /* 打印小票 (异步提交) */ uint8_t* print_data generate_receipt(data); printer_submit_job(printer, print_data, 20); } } } ​ /** * brief 避免死锁: 固定锁顺序 */ void avoid_deadlock_fixed_order(void) { /* 规则: 所有线程按相同顺序获取锁 * 顺序: SE锁 → MSR锁 → 打印机锁 → 网络锁 */ /* ✅ 正确示例 */ void correct_lock_order(void) { pthread_mutex_lock(g_res.se_mutex); /* 1. SE锁 */ pthread_mutex_lock(g_res.msr_mutex); /* 2. MSR锁 */ pthread_mutex_lock(g_res.printer_mutex);/* 3. 打印机锁 */ /* 操作... */ pthread_mutex_unlock(g_res.printer_mutex); pthread_mutex_unlock(g_res.msr_mutex); pthread_mutex_unlock(g_res.se_mutex); } /* ❌ 错误示例 (可能死锁) */ void wrong_lock_order(void) { pthread_mutex_lock(g_res.msr_mutex); /* 先获取MSR锁 */ pthread_mutex_lock(g_res.se_mutex); /* 后获取SE锁 */ /* 如果另一个线程先获取SE锁再等MSR锁就会死锁 */ } } ​ /** * brief 读写锁示例 (配置信息) */ void config_rwlock_example(void) { /* 读配置 (多个线程可同时读) */ void read_config(void) { pthread_rwlock_rdlock(g_res.config_rwlock); char ssid[32]; strcpy(ssid, g_config.ssid); pthread_rwlock_unlock(g_res.config_rwlock); } /* 写配置 (独占) */ void write_config(const char* ssid) { pthread_rwlock_wrlock(g_res.config_rwlock); strcpy(g_config.ssid, ssid); save_config_to_file(); pthread_rwlock_unlock(g_res.config_rwlock); } } ​ /** * brief 信号量示例 (限制并发网络请求) */ void semaphore_example(void) { /* 初始化信号量 (最多3个并发) */ sem_init(g_res.network_sem, 0, 3); /* 网络请求线程 */ void* network_thread(void* arg) { while (1) { /* 等待信号量 */ sem_wait(g_res.network_sem); /* 执行网络请求 */ int ret http_post(...); /* 释放信号量 */ sem_post(g_res.network_sem); } return NULL; } } ​ /** * brief 看门狗线程 (检测死锁) */ void* watchdog_thread(void* arg) { while (1) { time_t now time(NULL); /* 检查各锁持有时间 */ for (int i 0; i 5; i) { if (g_res.lock_info[i].owner ! 0) { time_t elapsed now - g_res.lock_info[i].acquire_time; if (elapsed 10) { ALOGE(Lock %d held by %lx for %ld seconds!, i, g_res.lock_info[i].owner, elapsed); g_res.deadlock_count; /* 可选: 杀死持有线程或重启进程 */ // pthread_cancel(g_res.lock_info[i].owner); } } } sleep(5); } } ​ /** } */三、技术点总结表技术点核心内容思路关键词实战经验安全芯片AES/3DES/RSA/ECC密钥存储、TRNG、防拆检测MAXQ1050, I2C通信防拆响应PCI PTS物理安全、逻辑安全JTAG禁用、熔丝位、安全启动产测后熔断外壳防拆网格磁条卡ISO 7811解码磁道1/2/3、起始符、LRC校验UART中断解码成功率99.9%芯片卡ISO 7816 T0/T1ATR解析、APDU、状态字T1块传输IFSC/IFSD协商打印机步进电机热敏头四相八拍、加热时间、缺纸检测异步打印队列过热保护并发互斥死锁预防、资源管理固定锁顺序、超时锁、读写锁刷卡打印并发信号量限流