互联网医院患者隐私保护：双因素认证与SDK代码加固

摘要

互联网医院平台同时面向患者端和医生端，涉及处方开具、在线问诊、健康档案等敏感场景，一旦发生患者隐私泄露将面临严重的法律和声誉风险。本文从双因素认证体系建设、SDK代码防逆向加固两个维度，系统讲解互联网医院患者隐私保护的技术实现方案，包含完整的架构设计、代码示例与落地实践。

一、互联网医院隐私安全威胁模型

1.1 攻击面分析

互联网医院相比传统HIS系统，攻击面显著扩大：

┌─────────────────────────────────────────────────────────┐
│              互联网医院攻击面分析                          │
│                                                         │
│  ┌───────────┐  ┌───────────┐  ┌───────────┐          │
│  │ 患者端App  │  │ 医生端App  │  │ 管理端Web  │          │
│  │           │  │           │  │           │          │
│  │·账号被盗   │  │·UKEY丢失   │  │·弱密码     │          │
│  │·App反编译  │  │·越权开方   │  │·权限滥用   │          │
│  │·中间人攻击 │  │·会话劫持   │  │·SQL注入   │          │
│  └─────┬─────┘  └─────┬─────┘  └─────┬─────┘          │
│        │              │              │                  │
│        └──────────────┼──────────────┘                  │
│                       ▼                                  │
│              ┌────────────────┐                         │
│              │ API网关         │                         │
│              │ ·接口未加密     │                         │
│              │ ·Token伪造     │                         │
│              │ ·数据过度暴露   │                         │
│              └───────┬────────┘                         │
│                      ▼                                   │
│              ┌────────────────┐                         │
│              │ 后端服务集群    │                         │
│              │ ·数据库拖库     │                         │
│              │ ·日志泄露PHI   │                         │
│              │ ·配置文件泄密   │                         │
│              └────────────────┘                         │
└─────────────────────────────────────────────────────────┘

1.2 典型隐私泄露案例

1.3 合规要求

二、双因素认证架构设计

2.1 患者端与医生端差异化认证

互联网医院的双因素认证需要区分患者端和医生端，采用不同的认证组合：

2.2 整体认证架构

┌───────────────────────────────────────────────────────────┐
│              互联网医院双因素认证架构                        │
│                                                           │
│  ┌─────────┐     ┌─────────┐     ┌─────────┐             │
│  │ 患者端App │     │ 医生端App │     │ 管理端Web │             │
│  │         │     │         │     │         │             │
│  │ 短信+   │     │ 密码+   │     │ 密码+   │             │
│  │ 人脸MFA  │     │ UKEY    │     │ UKEY+   │             │
│  │         │     │         │     │ TOTP    │             │
│  └────┬────┘     └────┬────┘     └────┬────┘             │
│       │               │               │                   │
│       ▼               ▼               ▼                   │
│  ┌──────────────────────────────────────────┐             │
│  │           ASP身份认证平台                  │             │
│  │                                          │             │
│  │  ┌─────────┐  ┌─────────┐  ┌─────────┐  │             │
│  │  │ 统一    │  │ 多因素  │  │ 策略    │  │             │
│  │  │ 认证    │  │ 管理    │  │ 引擎    │  │             │
│  │  │ 服务    │  │ (MFA)   │  │ (ABAC)  │  │             │
│  │  └────┬────┘  └────┬────┘  └────┬────┘  │             │
│  └───────┼────────────┼────────────┼────────┘             │
│          │            │            │                       │
│          ▼            ▼            ▼                       │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐                │
│  │ KSP      │  │ UKEY     │  │ RDM      │                │
│  │ 密钥安全  │  │ 证书管理  │  │ 数据脱敏  │                │
│  └──────────┘  └──────────┘  └──────────┘                │
│                                                           │
│  ┌──────────┐  ┌──────────┐                              │
│  │ TDE      │  │ HSM      │                              │
│  │ 数据加密  │  │ 密码机   │                              │
│  └──────────┘  └──────────┘                              │
└───────────────────────────────────────────────────────────┘

2.3 医生端UKEY认证流程

医生端使用UKEY数字证书作为第二因素，确保开方操作的法律效力：

/**
 * 医生端UKEY双因素认证流程
 */
public class DoctorUkeyAuthService {
    
    private AspClient aspClient;          // ASP认证平台客户端
    private KspClient kspClient;          // KSP密钥安全中间件
    private HsmClient hsmClient;          // HSM密码机客户端
    
    /**
     * 医生登录双因素认证
     * @param doctorId  医生工号
     * @param password  登录密码（第一因素）
     * @param ukeyPin   UKEY PIN码（第二因素）
     * @return 认证Token
     */
    public AuthToken authenticate(String doctorId, String password, 
                                   String ukeyPin) {
        // ===== 第一因素：账号密码 =====
        PasswordVerifyResult pwdResult = aspClient.verifyPassword(
            doctorId, password, "DOCTOR"
        );
        if (!pwdResult.isSuccess()) {
            throw new AuthException("账号或密码错误");
        }
        
        // ===== 第二因素：UKEY证书签名 =====
        // 1. 服务器生成随机挑战值
        byte[] challenge = hsmClient.generateRandom(32);
        
        // 2. 读取UKEY中的医生数字证书
        X509Certificate doctorCert = kspClient.readUkeyCertificate(ukeyPin);
        
        // 3. 验证证书是否由医院CA签发
        boolean certValid = aspClient.verifyCertificate(
            doctorCert, "HOSPITAL_CA"
        );
        if (!certValid) {
            throw new AuthException("UKEY证书无效");
        }
        
        // 4. 使用UKEY私钥对挑战值签名
        byte[] signature = kspClient.signWithUkey(
            ukeyPin, challenge, "SM2"
        );
        
        // 5. 服务器验证签名
        boolean signValid = kspClient.verifySignature(
            doctorCert.getPublicKey(), challenge, signature, "SM2"
        );
        if (!signValid) {
            throw new AuthException("UKEY签名验证失败");
        }
        
        // 6. 检查UKEY与医生账号的绑定关系
        boolean bound = aspClient.checkUkeyBinding(
            doctorId, doctorCert.getSerialNumber()
        );
        if (!bound) {
            throw new AuthException("UKEY未绑定到当前医生账号");
        }
        
        // 7. 签发认证Token
        AuthToken token = aspClient.issueToken(
            doctorId, 
            "DOCTOR",
            doctorCert.getSubjectDN().getName(),
            3600  // 1小时有效期
        );
        
        // 8. 记录认证审计日志
        aspClient.logAuthEvent(
            doctorId, "UKEY_MFA_LOGIN", 
            AuthEvent.Result.SUCCESS,
            Map.of("cert_sn", doctorCert.getSerialNumber())
        );
        
        return token;
    }
    
    /**
     * 处方开具时的数字签名
     * 处方数据需医生UKEY签名，确保法律效力
     */
    public SignedPrescription signPrescription(
        String doctorId, String ukeyPin, 
        Prescription prescription
    ) {
        // 1. 序列化处方数据
        String prescriptionJson = prescription.toJson();
        
        // 2. SM3摘要
        byte[] digest = kspClient.sm3Digest(
            prescriptionJson.getBytes(StandardCharsets.UTF_8)
        );
        
        // 3. UKEY SM2签名
        byte[] signature = kspClient.signWithUkey(
            ukeyPin, digest, "SM2"
        );
        
        // 4. 获取时间戳
        Timestamp timestamp = hsmClient.getTimestamp(digest);
        
        return new SignedPrescription(
            prescription,
            signature,
            timestamp,
            kspClient.getUkeyCertSerial(ukeyPin)
        );
    }
}

2.4 患者端MFA流程

患者端采用短信验证码+生物识别的组合：

import random
import time
import hashlib
from datetime import datetime, timedelta

class PatientMfaService:
    """患者端多因素认证服务"""
    
    def __init__(self, asp_client, sms_client, redis_client):
        self.asp = asp_client
        self.sms = sms_client
        self.redis = redis_client
        self.tde_client = None  # TDE透明加密客户端
    
    def send_sms_code(self, phone: str) -> dict:
        """发送短信验证码（第一因素）"""
        # 频率限制
        key = f"sms_limit:{phone}"
        count = self.redis.incr(key)
        if count == 1:
            self.redis.expire(key, 3600)  # 1小时窗口
        if count > 5:
            return {"success": False, "msg": "发送频率超限"}
        
        # 生成6位验证码
        code = str(random.randint(100000, 999999))
        
        # 存储验证码（5分钟有效）
        code_key = f"sms_code:{phone}"
        self.redis.setex(code_key, 300, code)
        
        # 发送短信
        self.sms.send(phone, f"您的互联网医院验证码：{code}，5分钟内有效")
        
        return {"success": True, "msg": "验证码已发送"}
    
    def verify_sms_code(self, phone: str, code: str) -> bool:
        """验证短信验证码"""
        code_key = f"sms_code:{phone}"
        stored_code = self.redis.get(code_key)
        
        if stored_code and stored_code.decode() == code:
            self.redis.delete(code_key)
            return True
        return False
    
    def verify_biometric(self, patient_id: str, 
                         biometric_data: dict) -> bool:
        """验证生物特征（第二因素）"""
        # 向ASP认证平台发起生物特征验证
        result = self.asp.verify_biometric(
            patient_id=patient_id,
            face_data=biometric_data.get("face"),
            liveness_data=biometric_data.get("liveness")
        )
        return result.get("verified", False)
    
    def authenticate(self, phone: str, sms_code: str,
                     patient_id: str, biometric_data: dict) -> dict:
        """患者端双因素认证"""
        # 第一因素：短信验证码
        if not self.verify_sms_code(phone, sms_code):
            return {"success": False, "reason": "短信验证码错误"}
        
        # 第二因素：生物识别
        if not self.verify_biometric(patient_id, biometric_data):
            return {"success": False, "reason": "生物识别失败"}
        
        # 签发Token
        token = self.asp.issue_token(
            user_id=patient_id,
            user_type="PATIENT",
            expires_in=7200  # 2小时
        )
        
        return {
            "success": True,
            "token": token,
            "expires_at": (
                datetime.now() + timedelta(seconds=7200)
            ).isoformat()
        }

三、SDK代码加固方案

3.1 互联网医院App SDK安全风险

互联网医院App的SDK中通常包含：

• API密钥/Secret
• 加密算法实现
• 认证流程逻辑
• 业务接口地址

如果SDK未加固，攻击者可以通过反编译获取这些敏感信息：

# 常见的Android SDK逆向操作（仅作风险说明）
# 1. APK反编译
apktool d internet_hospital.apk -o output_dir

# 2. 查找硬编码密钥
grep -rn "api_key\|secret\|password" output_dir/

# 3. Dex反编译为Java
d2j-dex2jar classes.dex

3.2 SDK加固策略

┌──────────────────────────────────────────────────┐
│              SDK代码加固四层策略                    │
│                                                  │
│  ┌────────────────────────────────────────────┐  │
│  │ 第一层：代码混淆                             │  │
│  │ · 类名/方法名/字段名混淆                    │  │
│  │ · 控制流平坦化                              │  │
│  │ · 字符串加密                                │  │
│  └────────────────────────────────────────────┘  │
│  ┌────────────────────────────────────────────┐  │
│  │ 第二层：反调试保护                           │  │
│  │ · 检测调试器附加                             │  │
│  │ · 检测模拟器环境                             │  │
│  │ · 检测Root/越狱                             │  │
│  └────────────────────────────────────────────┘  │
│  ┌────────────────────────────────────────────┐  │
│  │ 第三层：密钥白盒化                           │  │
│  │ · 密钥不硬编码在代码中                       │  │
│  │ · 运行时从安全存储动态获取                    │  │
│  │ · 使用白盒密码学保护密钥                      │  │
│  └────────────────────────────────────────────┘  │
│  ┌────────────────────────────────────────────┐  │
│  │ 第四层：完整性校验                           │  │
│  │ · 签名校验防止重打包                         │  │
│  │ · SO文件CRC校验                             │  │
│  │ · 关键逻辑Native化                          │  │
│  └────────────────────────────────────────────┘  │
└──────────────────────────────────────────────────┘

3.3 密钥白盒化实现

将API密钥从代码中移除，改为运行时从服务端动态获取：

/**
 * 白盒密钥管理器
 * 密钥不在客户端存储，运行时从ASP平台获取
 */
public class WhiteboxKeyManager {
    
    private static final String KEY_SERVICE_URL = 
        BuildConfig.KEY_SERVICE_URL;  // 从编译配置注入
    
    /**
     * 获取API通信密钥
     * 每次启动App时从服务端获取临时密钥
     */
    public String getApiKey(String appId, String deviceFingerprint) {
        // 1. 生成设备指纹
        String deviceId = DeviceFingerprint.generate(
            getApplicationContext()
        );
        
        // 2. 向ASP平台请求临时密钥
        KeyRequest request = new KeyRequest.Builder()
            .appId(appId)
            .deviceId(deviceId)
            .timestamp(System.currentTimeMillis())
            .nonce(UUID.randomUUID().toString())
            .build();
        
        // 3. 使用设备证书签名请求
        String signature = KeyStoreHelper.signRequest(request);
        request.setSignature(signature);
        
        // 4. 发送请求
        KeyResponse response = httpClient.post(
            KEY_SERVICE_URL + "/api/key/issue",
            request.toJson()
        );
        
        // 5. 验证响应签名（防止中间人篡改）
        if (!verifyResponseSignature(response)) {
            throw new SecurityException("密钥响应签名验证失败");
        }
        
        // 6. 解密密钥（使用设备密钥解密）
        return KeyStoreHelper.decryptKey(
            response.getEncryptedKey()
        );
    }
    
    /**
     * 密钥使用后立即清除
     */
    public void clearKey(String keyId) {
        // 从内存中安全擦除
        Arrays.fill(keyBuffer, (byte) 0);
        
        // 通知服务端密钥已失效
        httpClient.post(
            KEY_SERVICE_URL + "/api/key/revoke",
            new KeyRevokeRequest(keyId)
        );
    }
}

3.4 软件授权管控（SLA）

通过SLA软件授权系统控制App的运行时权限，防止被篡改的App访问后端服务：

# 服务端SLA验证中间件
class SlaVerificationMiddleware:
    """软件授权验证中间件"""
    
    def __init__(self, sla_client):
        self.sla = sla_client
    
    def verify_request(self, request):
        """验证每个API请求的授权状态"""
        # 1. 提取App签名信息
        app_signature = request.headers.get("X-App-Signature")
        app_version = request.headers.get("X-App-Version")
        device_id = request.headers.get("X-Device-ID")
        
        if not app_signature:
            return False, "缺少App签名"
        
        # 2. SLA授权验证
        verify_result = self.sla.verify(
            app_signature=app_signature,
            app_version=app_version,
            device_id=device_id,
            api_path=request.path,
            timestamp=request.timestamp
        )
        
        if not verify_result.is_valid:
            return False, f"授权验证失败: {verify_result.reason}"
        
        # 3. 检查App完整性
        if not self.sla.check_integrity(
            app_signature, 
            expected_hash=verify_result.expected_hash
        ):
            return False, "App完整性校验失败，可能被篡改"
        
        # 4. 频率限制检查
        if self.sla.is_rate_limited(device_id, request.path):
            return False, "请求频率超限"
        
        return True, "验证通过"

3.5 Native层关键逻辑保护

将认证核心逻辑用C/C++实现并编译为SO库，增加逆向难度：

// auth_native.c - 认证核心逻辑Native实现
#include <jni.h>
#include <string.h>
#include "sm2.h"
#include "sm3.h"
#include "hsm_client.h"

// 防调试检测
static int check_debugger() {
    // 检测ptrace附加
    FILE* f = fopen("/proc/self/status", "r");
    if (!f) return 0;
    
    char line[256];
    int traced = 0;
    while (fgets(line, sizeof(line), f)) {
        if (strstr(line, "TracerPid:") != NULL) {
            int pid = atoi(line + 10);
            if (pid != 0) {
                traced = 1;
                break;
            }
        }
    }
    fclose(f);
    return traced;
}

// UKEY签名验证（Native实现）
JNIEXPORT jbyteArray JNICALL
Java_com_hospital_auth_NativeAuth_ukeySign(
    JNIEnv* env, jobject thiz,
    jbyteArray challenge, jstring pin) {
    
    // 反调试检测
    if (check_debugger()) {
        return NULL;  // 检测到调试器，拒绝执行
    }
    
    // 获取挑战值
    jbyte* challenge_bytes = (*env)->GetByteArrayElements(
        env, challenge, NULL
    );
    jsize challenge_len = (*env)->GetArrayLength(env, challenge);
    
    // SM3摘要
    unsigned char digest[32];
    sm3_hash(challenge_bytes, challenge_len, digest);
    
    // 从UKEY读取私钥并签名（通过KSP接口）
    const char* pin_str = (*env)->GetStringUTFChars(env, pin, NULL);
    unsigned char signature[64];
    int sig_len = hsm_ukey_sign(
        pin_str, digest, 32, signature, &sig_len
    );
    (*env)->ReleaseStringUTFChars(env, pin, pin_str);
    
    if (sig_len <= 0) {
        (*env)->ReleaseByteArrayElements(
            env, challenge, challenge_bytes, JNI_ABORT
        );
        return NULL;
    }
    
    // 返回签名结果
    jbyteArray result = (*env)->NewByteArray(env, sig_len);
    (*env)->SetByteArrayRegion(env, result, 0, sig_len, 
                                (jbyte*)signature);
    
    // 安全清除内存
    memset(digest, 0, sizeof(digest));
    memset(signature, 0, sizeof(signature));
    
    (*env)->ReleaseByteArrayElements(
        env, challenge, challenge_bytes, JNI_ABORT
    );
    
    return result;
}

四、患者隐私数据全链路保护

4.1 数据流加密

互联网医院的数据流需要从端到端全程加密：

4.2 患者数据分级保护

# 患者数据分级保护策略
PATIENT_DATA_CLASSIFICATION = {
    "L4_极敏感": {
        "fields": ["身份证号", "病历全文", "基因数据", "处方明细"],
        "protection": {
            "存储加密": "TDE+列级SM4加密",
            "传输加密": "国密TLS+SM2信封",
            "访问控制": "UKEY双因素+RBAC",
            "动态脱敏": "仅主治医生可见原文",
            "审计签名": "SM2签名+时间戳",
            "保留期限": "30年（法规要求）"
        }
    },
    "L3_敏感": {
        "fields": ["患者姓名", "手机号", "检查报告", "诊断结果"],
        "protection": {
            "存储加密": "TDE透明加密",
            "传输加密": "国密TLS",
            "访问控制": "双因素认证+RBAC",
            "动态脱敏": "按角色差异化脱敏",
            "审计签名": "SM2签名",
            "保留期限": "15年"
        }
    },
    "L2_内部": {
        "fields": ["就诊记录", "科室信息", "费用明细"],
        "protection": {
            "存储加密": "TDE透明加密",
            "传输加密": "国密TLS",
            "访问控制": "双因素认证",
            "动态脱敏": "管理员可见",
            "审计签名": "操作日志",
            "保留期限": "10年"
        }
    },
    "L1_公开": {
        "fields": ["科室介绍", "医生排班", "公告通知"],
        "protection": {
            "存储加密": "无",
            "传输加密": "HTTPS",
            "访问控制": "无",
            "动态脱敏": "无",
            "审计签名": "无",
            "保留期限": "按需"
        }
    }
}

4.3 处方数据加密流转

处方从医生开具到药房取药的全链路加密：

/**
 * 处方数据加密流转服务
 */
public class PrescriptionSecurityService {
    
    private KspClient kspClient;
    private TdeClient tdeClient;
    private HsmClient hsmClient;
    
    /**
     * 处方加密存储
     */
    public EncryptedPrescription encrypt(Prescription rx) {
        // 1. 处方明文序列化
        byte[] plaintext = rx.toJson().getBytes(StandardCharsets.UTF_8);
        
        // 2. 生成SM4会话密钥
        byte[] sessionKey = hsmClient.generateSymmetricKey("SM4", 128);
        
        // 3. SM4加密处方内容
        byte[] ciphertext = kspClient.sm4Encrypt(sessionKey, plaintext);
        
        // 4. 使用药房公钥SM2加密会话密钥（信封加密）
        byte[] encryptedKey = kspClient.sm2Encrypt(
            PHARMACY_PUBLIC_KEY, sessionKey
        );
        
        // 5. 医生UKEY签名
        byte[] signature = kspClient.signWithUkey(
            doctorUkeyPin, 
            kspClient.sm3Digest(plaintext)
        );
        
        // 6. 时间戳
        Timestamp ts = hsmClient.getTimestamp(
            kspClient.sm3Digest(plaintext)
        );
        
        return new EncryptedPrescription(
            rx.getPrescriptionId(),
            ciphertext,
            encryptedKey,
            signature,
            ts,
            doctor.getCertSerial()
        );
    }
    
    /**
     * 药房解密处方
     */
    public Prescription decrypt(EncryptedPrescription encRx, 
                                  String pharmacistPin) {
        // 1. 验证医生签名
        boolean valid = kspClient.verifySignature(
            getDoctorPublicKey(encRx.getDoctorCertSn()),
            kspClient.sm3Digest(encRx.getCiphertext()),
            encRx.getSignature()
        );
        if (!valid) {
            throw new SecurityException("处方签名验证失败");
        }
        
        // 2. 药房UKEY解密会话密钥
        byte[] sessionKey = kspClient.sm2DecryptWithUkey(
            pharmacistPin, encRx.getEncryptedKey()
        );
        
        // 3. SM4解密处方内容
        byte[] plaintext = kspClient.sm4Decrypt(
            sessionKey, encRx.getCiphertext()
        );
        
        // 4. 反序列化
        return Prescription.fromJson(new String(plaintext, 
            StandardCharsets.UTF_8));
    }
}

五、安全审计与合规

5.1 审计日志设计

-- 互联网医院安全审计日志表
CREATE TABLE ih_security_audit (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    event_time DATETIME NOT NULL,
    event_type VARCHAR(32) NOT NULL,        -- LOGIN/PRESCRIPTION/QUERY/EXPORT
    user_id VARCHAR(64) NOT NULL,
    user_type VARCHAR(16) NOT NULL,          -- PATIENT/DOCTOR/ADMIN
    user_role VARCHAR(32),
    action_detail JSON,
    source_ip VARCHAR(45),
    device_id VARCHAR(128),
    mfa_method VARCHAR(32),                  -- UKEY/FACE/SMS
    mfa_verified TINYINT(1),
    data_accessed VARCHAR(32),               -- L1/L2/L3/L4
    masked_fields TEXT,
    response_status VARCHAR(16),
    signature VARCHAR(128),                  -- SM2签名防篡改
    INDEX idx_user (user_id, event_time),
    INDEX idx_type (event_type, event_time),
    INDEX idx_mfa (mfa_verified, event_time)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- 查询异常访问模式
SELECT 
    user_id,
    user_type,
    COUNT(*) AS access_count,
    COUNT(DISTINCT source_ip) AS ip_count,
    MIN(event_time) AS first_access,
    MAX(event_time) AS last_access
FROM ih_security_audit
WHERE event_time >= DATE_SUB(NOW(), INTERVAL 24 HOUR)
GROUP BY user_id, user_type
HAVING access_count > 100 OR ip_count > 3
ORDER BY access_count DESC;

5.2 合规自检清单

六、落地实施与产品选型

6.1 产品部署清单

6.2 实施周期

在互联网医院患者隐私保护的整体方案中，上海安当提供的ASP身份认证平台与SLA软件授权系统组合方案，能够在App端实现从双因素认证到SDK代码加固的端到端安全防护。其ASP平台支持UKEY+短信+生物识别等多种MFA方式灵活组合，SLA系统提供运行时授权验证和完整性校验，适合互联网医院在等保三级和密评三级双达标场景下统一部署。

七、总结

互联网医院患者隐私保护需要从认证和代码两个维度同时加固：

双因素认证维度：

1. 患者端：短信验证码+人脸识别，降低账号被盗风险
2. 医生端：密码+UKEY数字证书，确保处方法律效力
3. 管理端：密码+UKEY+动态口令，三因素防止权限滥用

SDK代码加固维度：

1. 代码混淆+控制流平坦化，增加逆向难度
2. 白盒密钥管理，密钥不在客户端存储
3. Native层保护关键认证逻辑
4. SLA软件授权管控，运行时完整性校验

数据保护维度：

1. 全链路国密加密（TLS+TDE+SM2信封）
2. L1-L4数据分级保护策略
3. 处方数据加密流转+数字签名
4. 审计日志SM2签名防篡改

三个维度协同工作，才能构建完整的互联网医院患者隐私保护体系。

作者简介：本文由信息安全领域技术团队撰写，专注互联网医疗安全防护方案。安当ASP、UKEY、KSP、TDE、RDM、SLA等产品在互联网医院场景中提供从身份认证到数据加密的完整安全支撑，已服务多家互联网医院平台的安全合规建设。