2025.06.08-基于Chram-Crypto库的医院场景CpabeDemo实现

#### 1.代码结构
代码下载：
[【附件】CPAEB_for_Hospital.zip](/media/attachment/2025/06/CPAEB_for_Hospital.zip)
```mindmap
# src
- node.py
- lssstil.py
- Attribute_authority.py
- CipherEngine.py
- test.py
```
#### 2.node.py
代码实现访问控制树的数据结构。

```
# 定义门限门类 Gate，表示访问策略中的 k-of-n 门限结构
class Gate:
    def __init__(self, k, n) -> None:
        self.k = k
        self.n = n

def __str__(self):
        return f'({self.k}, {self.n})'

# 定义访问策略树的节点类 Node
class Node:
    def __init__(self, gate, children, attr) -> None:
        # gate：当前节点是否为门限节点（非叶子节点）
        # children：子节点列表，仅非叶子节点使用
        # attr：属性字符串，仅叶子节点使用
        self.gate = gate
        self.children = children
        self.attr = attr
        self.secret = None

@staticmethod
    def threshold_node(gate, children):
        # 创建一个门限节点（非叶子节点）
        return Node(gate, children, None)

@staticmethod
    def attr_node(attr):
        # 创建一个属性节点（叶子节点）
        return Node(None, None, attr)

def is_leaf(self):
        return self.gate is None

def __dfs(self, deep):
        s = '\t' * deep
        if self.is_leaf():
            s += str(self.attr) + f': {self.secret}' + '\n'
        else:
            s += str(self.gate) + f': {self.secret}' + '\n'
            for c in self.children:
                s += c.__dfs(deep + 1)
        return s

def __str__(self):
        return self.__dfs(0)

```
#### 3.lssstil.py
布尔访问树转LSSS访问矩阵

```
from queue import Queue

def lewko_waters(root):
    c, max_len, m = 1, 1, []
    q = Queue()
    root.attr = [1]
    q.put(root)
    while not q.empty():
        tmp = q.get()
        v = tmp.attr
        max_len = max(max_len, len(v))
        if tmp.is_leaf():
            m.append(tmp.attr)
            continue
        lc, rc = tmp.children[0], tmp.children[1]
        if tmp.gate.k == 1:
            lc.attr = v
            rc.attr = v
        else:
            v += [0] * (c - len(v))
            lc.attr = [0] * c + [-1]
            rc.attr = v + [1]
            c += 1
        q.put(lc)
        q.put(rc)
    for row in m:
        row += [0] * (max_len - len(row))
    return m
```
#### 5.Attribute_authority.py
AA系统，负责系统初始化Setup（）和用户申请私钥keygen（）
采用charm-crypto中的“SS512”完成。

```
from charm.toolbox.pairinggroup import PairingGroup, G1, G2, GT, ZR, pair as e

# 属性授权中心 Authority：负责系统初始化、公钥发布、私钥生成
class Authority:
    def __init__(self, lambda_sec, U):
        """
        :param lambda_sec: 安全参数
        :param U: 属性全集，例如 ['Doctor', 'Admin', 'Nurse']
        """
        self.group = PairingGroup('SS512')
        self.U = U
        self.params = self.__setup(lambda_sec, U)

def __setup(self, lambda_sec, U):
        """
        系统初始化函数（只在类初始化中调用）
        生成公钥（PK）和主密钥（MSK）
        """
        # 随机选择参数alpha和a
        alpha, a = self.group.random(ZR), self.group.random(ZR)
        # 生成生成元 g ∈ G1
        g = self.group.random(G1)

# 为每个属性 i ∈ U 生成一个随机指数 s_i，对其进行签名
        T = {}
        for i in U:
            s_i = self.group.random(ZR)
            T[i] = g ** s_i

# 计算其他公钥参数
        g_a = g ** a
        egg_alpha = e(g, g) ** alpha

# 返回公钥和主密钥
        PK = {'N': self.group.order(), 'g': g, 'g_a': g_a, 'egg_alpha': egg_alpha, 'T': T}
        MSK = {'alpha': alpha, 'a': a}
        return {'PK': PK, 'MSK': MSK}

def key_generate(self, S):
        """
        为某个用户生成私钥
        :param S: 用户所拥有的属性集合，如 ['Doctor', 'Nurse']
        :return: 用户私钥 SK = {S, K, L, Ki}
        """
        MSK = self.params['MSK']
        PK = self.params['PK']
        group = self.group

# 为该用户生成一个随机参数 t
        t = group.random(ZR)
        g, g_a, alpha, T = PK['g'], PK['g_a'], MSK['alpha'], PK['T']

# 计算用户私钥：
        K = (g ** alpha) * (g_a ** t)
        L = g ** t
        Ki = [(T[i] ** t) for i in S]
        return {'S': S, 'K': K, 'L': L, 'Ki': Ki}

def get_public_params(self):
        # 对外获取公钥的接口
        return self.params['PK']

```
#### 6.CipherEngine.py

```
from charm.toolbox.pairinggroup import PairingGroup, GT, pair as e, ZR
from functools import reduce
import numpy as np

# group = PairingGroup("")
class CipherEngine:
    def __init__(self):
        self.group = PairingGroup('SS512')

def encrypt(self, A, rho, PK, M):
        """
        CP-ABE 加密过程（基于 LSSS 策略矩阵）
        :param A: LSSS矩阵，形状为 (l, n)，每行表示一个属性约束
        :param rho: 长度为 l 的属性映射列表，A 的第 i 行对应 rho[i] 属性
        :param PK: 公钥（由 Authority 提供）
        :param M: 明文，GT 中的群元素（可为加密的消息如 e(g,g)^m）
        :return: CT 密文字典
        """
        l, n = A.shape
        group = self.group
        g, g_a, egg_alpha, T = PK['g'], PK['g_a'], PK['egg_alpha'], PK['T']

# Step 1：随机主共享密钥 s ∈ Zp，生成随机向量 v = (s, r₁, r₂, ..., r_{n-1}) ∈ Zpⁿ
        s = group.random(ZR)
        v = [s] + [group.random(ZR) for _ in range(n - 1)]

# Step 2：加密明文
        C = M * (egg_alpha ** s)
        C_minute = g ** s

# Step 3：生成属性相关的密文分量 Cx[i], Dx[i]
        Cx, Dx = [], []
        for i in range(l):
            attr = rho[i]
            rx = group.random(ZR)
            Cx_i = (g_a ** A[i].dot(v)) * (T[attr] ** -rx)  # 用的是属性名索引
            Dx_i = g ** rx
            Cx.append(Cx_i)
            Dx.append(Dx_i)

return {'C': C, 'C_minute': C_minute, 'Cx': Cx, 'Dx': Dx, 'rho': rho}

def decrypt(self,A_matrix, CT, PK, SK):
        """
        CP-ABE 解密过程
        :param A_matrix: 加密所使用的 LSSS 矩阵 A
        :param CT: 密文字典（包括 C, C_minute, Cx, Dx, rho）
        :param PK: 公钥（未使用，可扩展）
        :param SK: 用户私钥（包括 S, K, L, Ki）
        :return: 解密后的 GT 中元素（明文 M）
        """
        
        # 解析密文
        C, C_minute, Cx, Dx, rho = CT['C'], CT['C_minute'], CT['Cx'], CT['Dx'], CT['rho']
        # 解析私钥
        S, K, L, Ki = SK['S'], SK['K'], SK['L'], SK['Ki']

# 找出S属性在rho中的索引，用于取L,Ki对应份额
        indices = np.array([rho.index(attr) for attr in S])
        Ax = A_matrix[indices, :].T

#解线性方程组 Ax · ω = (1, 0, 0, ..., 0)^T 解出重构系数 ω
        row,_ =Ax.shape
        b = np.array([1]+[0 for _ in range(row-1)],dtype=int)
        wx = np.rint(np.linalg.lstsq(Ax,b,rcond=None)[0]).astype(int).tolist()

#执行方案的解密过程
        e_wx=[]
        for j, attr in enumerate(indices):
            e_wx.append((e(Cx[attr], L) * e(Dx[attr], Ki[j])) **  wx[j])

prod = reduce(lambda e1,e2:e1 *e2,e_wx)
        # print("prod=",prod)
        egg_alpha_s = e(C_minute,K)/prod
        return C/egg_alpha_s
```
#### 7.test.py

```
from node import *
from lssstil import *
from Attribute_authority import *
from CipherEngine import *
import hashlib
from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
from Crypto.Util.Padding import pad, unpad

# Step 1:DO构建访问策略树
root = Node.threshold_node(Gate(1, 2), [
    Node.threshold_node(Gate(1, 2), [
        Node.threshold_node(Gate(1, 2), [
            Node.threshold_node(Gate(2, 2), [
                Node.attr_node("InternalMedicine"),
                Node.threshold_node(Gate(2, 2), [
                    Node.attr_node("Senior"),
                    Node.threshold_node(Gate(1, 2), [
                        Node.attr_node("DoctorEA"),
                        Node.attr_node("Nurse")
                    ])
                ])
            ]),
            Node.attr_node("Researcher")
        ]),
        Node.attr_node("Admin")
    ]),
    Node.threshold_node(Gate(2, 2), [
        Node.attr_node("DoctorEA"),
        Node.attr_node("EmergencyAccess")
    ])
])
print("访问策略树为:",root)

# Step 2: Setup初始化系统AA
# 定义属性集合
U = ["Admin", "DoctorEA", "EmergencyAccess", "Researcher", "InternalMedicine", "Senior", "Doctor", "Nurse"]
AA = Authority(lambda_sec=0, U=U)
PK = AA.get_public_params()
# print(PK)

# Step3:获得LSSS矩阵
A_matrix = lewko_waters(root)
A_matrix = np.array(A_matrix, dtype=int)
print("LSSS矩阵为:", A_matrix)

# Step4:DO加密数据
Message = "病人姓名:JACK;年龄:74;由内科高级医生Alice负责治疗。".encode()
cipher = CipherEngine()#CPABE加密引擎

# 用 CP-ABE 加密 key，返回密文 CT
key = cipher.group.random(GT) 
CT = cipher.encrypt(A_matrix, U, PK, key)
# print(CT)

# AES 加密数据
k_enc = hashlib.sha256(cipher.group.serialize(key)).digest()[:16]#AES-128
cipher_enc = AES.new(k_enc,AES.MODE_ECB)
ciphertext = cipher_enc.encrypt(pad(Message, AES.block_size))
print("病人数据加密密文为:",ciphertext.hex())

# Step5:授权DU获取私钥
EU_attrs = ["DoctorEA", "EmergencyAccess"]#来自急诊的医生Bob
SK_hefa = AA.key_generate(EU_attrs)

# Step6:非法EU获取私钥
EU_attrs = ["Doctor", "Senior"]#不合法的医生
SK_feifa = AA.key_generate(EU_attrs)

# Step6:测试
# key_decrypt = cipher.decrypt(A_matrix, CT, PK, SK_hefa)   #合法
key_decrypt = cipher.decrypt(A_matrix, CT, PK, SK_feifa)    #非法

if key == key_decrypt:
    print("授权用户能够解密:")
    keyAes = hashlib.sha256(cipher.group.serialize(key_decrypt)).digest()[:16]#AES-128
    cipher_dec = AES.new(keyAes,AES.MODE_ECB)
    decrypted_text =unpad(cipher_dec.decrypt(ciphertext), AES.block_size).decode()
    print("解密结果为:",decrypted_text)
else:
    print("未授权用户，不可解密")

```
##### 测试结果
**授权者解密**：

```
访问策略树为: (1, 2): None
	(1, 2): None
		(1, 2): None
			(2, 2): None
				InternalMedicine: None
				(2, 2): None
					Senior: None
					(1, 2): None
						DoctorEA: None
						Nurse: None
			Researcher: None
		Admin: None
	(2, 2): None
		DoctorEA: None
		EmergencyAccess: None

LSSS矩阵为: [[ 1  0  0  0]
 [ 0 -1  0  0]
 [ 1  1  0  0]
 [ 1  0  0  0]
 [ 0  0 -1  0]
 [ 0  0  0 -1]
 [ 1  0  1  1]
 [ 1  0  1  1]]
病人数据加密密文为: adbad10a7cd70c6ac6893cbba0fc08d79c4b71994a241b53b81609801b0ca8cb0fb08202d735955cd158908ca83b756269f29c4da07368768929ed583460a9b74a6a789c31f8669d294dca28f4f761f9
授权用户能够解密:
解密结果为: 病人姓名:JACK;年龄:74;由内科高级医生Alice负责治疗。

进程已结束,退出代码0
```
**未授权者**

```
访问策略树为: (1, 2): None
	(1, 2): None
		(1, 2): None
			(2, 2): None
				InternalMedicine: None
				(2, 2): None
					Senior: None
					(1, 2): None
						DoctorEA: None
						Nurse: None
			Researcher: None
		Admin: None
	(2, 2): None
		DoctorEA: None
		EmergencyAccess: None

LSSS矩阵为: [[ 1  0  0  0]
 [ 0 -1  0  0]
 [ 1  1  0  0]
 [ 1  0  0  0]
 [ 0  0 -1  0]
 [ 0  0  0 -1]
 [ 1  0  1  1]
 [ 1  0  1  1]]
病人数据加密密文为: 1c4a5035323bce8cc787fd55164a59a1d1e75393f789e3e699a3c16913e93fcd9a54027bc26b57ce96ba293b8dd9a6612f817741df5a1e1fe10836b6a1d18f193c5d2e0f22fafc7a1a645e47b1b67fc7
未授权用户，不可解密
```