一、安全相关深度分析
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, status=0x%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 T=0/T=1 | ATR解析、APDU、状态字 | T=1块传输，IFSC/IFSD协商 |
| 打印机 | 步进电机+热敏头 | 四相八拍、加热时间、缺纸检测 | 异步打印队列，过热保护 |
| 并发互斥 | 死锁预防、资源管理 | 固定锁顺序、超时锁、读写锁 | 刷卡+打印并发，信号量限流 |
