def main():
while True:
send_message('Enter your command:')
cmd = read_message().strip()
if cmd == 'sign':
send_message('Send cmd to sign:')
cmd = read_message().strip()
if (cmd in ['id', 'uname', 'ls', 'date']):
r = blind(cmd, pubkey)
sig = sign(r, key)
send_message(
f'Here you go: {sig[0].x}|{sig[0].y}|{sig[1]}|{cmd}')
else:
send_message('Not allowed!')
elif cmd == 'run':
send_message('Send sig:')
sig = read_message().strip()
tmp = sig.split('|')
if len(tmp) == 4:
x = int(tmp[0])
y = int(tmp[1])
s = int(tmp[2])
c = tmp[3]
sig = (ECC.EccPoint(x, y, curve='P-256'), s)
if (verify(c, sig, pubkey)):
out = run_cmd(c)
send_message(out)
else:
send_message('Invalid sig!')
else:
send_message('Invalid amount of params!')
elif cmd == 'show':
send_message(pubkey)
elif cmd == 'help':
send_message('Commands: exit, help, show, run, sign')
elif cmd == 'exit':
send_message('Bye :) Have a nice day!')
break
else:
send_message('Invalid command!')
def EC_func(m_dict):
ChameleonHash = ChameleonHash_ECC.ChameleonHash() # 实例化对象，这一步注意不可少！！！
KeyTrans = key_type_transform.KeyTrans()
order = ChameleonHash.order()
# ************************UDP服务器端编程*********************************
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.bind(('127.0.0.1', 12346)) # 绑定端口
data, addr = s.recvfrom(8192) # 接收A3VI发来的消息
# s.close()
data_ST = pickle.loads(
data
) # 收到消息后，反序列化得到 {'CH_UE': message_AUSF['CH_UE'], 'N': message_AUSF['N'], 'RG_Ope': message_AUSF['RG_Ope'], 'RG_A3VI': keys, 'ST': ST}
CH_UE = data_ST['CH_UE'] # 这里假装是用后面接收到的TXID_ST上链查询到的CH_UE值
# print('***EC***参与区块链共识，备份链上数据【包含CH_UE】！！！')
# **********************UDP客户端编程【发送消息给UE，提示其开始认证过程】***************************************
print('EC >> UE 开始认证')
message = b'start'
t = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
t.sendto(message, ('127.0.0.1', 12347))
t.close()
"""
UE_EC = {'Hidden_Allowed_S_NSSAI': Hidden_Allowed_S_NSSAI, 'PID_UE': PID_UE, 'A_UE': A_UE.xy, 'B_UE': B_UE.xy,
'm_UE': m1, 'T_Curr': T_Curr, 'TXID_ST': TXID_ST}
"""
data1, addr1 = s.recvfrom(8192)
UE_EC = pickle.loads(data1)
# print('***EC***收到的UE的认证消息:', UE_EC)
print('***EC***收到的UE的认证消息')
start_auth = time.clock()
s.close()
m = {
'PID_UE': UE_EC['PID_UE'],
'A_UE': UE_EC['A_UE'],
'B_UE': UE_EC['B_UE'],
"T_Curr": UE_EC['T_Curr']
}
b_m = pickle.dumps(m)
h = hashlib.sha3_256()
h.update(b_m)
m_h = h.hexdigest()
b_m_h = bytes(m_h, encoding='utf-8')
gamma = bytes_to_int(b_m_h)
m_UE = UE_EC['m_UE']
A_UE = UE_EC['A_UE']
x = A_UE[0]
y = A_UE[1]
A = ECC.EccPoint(x, y)
B_UE = UE_EC['B_UE']
x_B = B_UE[0]
y_B = B_UE[1]
B = ECC.EccPoint(x_B, y_B)
P = ECC._curves['P-256'].G
CH_EC = P.__mul__(m_UE) + A.__mul__(gamma)
print('***EC***根据用户发送的TXID_ST上链查询到的哈希值：', CH_UE)
print('***EC***根据接收到的消息计算出的哈希值：', CH_EC.xy)
print('****************！！！EC端验证碰撞成功！！！*********************'
) if CH_EC.xy == CH_UE else print('碰撞失败')
end_auth = time.clock()
print('EC端在服务认证阶段的计算开销：', (end_auth - start_auth) * 1000, 'ms')
m_dict['EC_Auth'] = (end_auth - start_auth) * 1000
# 提示A3VI开始密钥协商，并将一些密钥协商材料转交给A3VI
m_EC_A3VI = {
'PID_UE': UE_EC['PID_UE'],
'm_UE': m_UE,
'A_UE': A_UE,
'B_UE': UE_EC['B_UE']
}
b_m_EC_A3VI = pickle.dumps(m_EC_A3VI)
DokeyAgreement = True
b_DokeyAgreement = pickle.dumps(DokeyAgreement)
# **********************UDP客户端编程【发送消息给A3VI，提示其开始密钥协商过程】***************************************
print('+++2+++ UE <<<< EC >>>> A3VI 提示双方开始密钥协商过程')
# print('服务认证阶段消息<ACK,PID_UE,m_UE,A_UE,B_UE>字节数为：', len(UE_EC['PID_UE']) + len(int_to_bytes(m_UE, 5)) + len(A.xy) + len(B.xy))
bytes_sum = A.x.__int__().bit_length() / 8 + A.y.__int__().bit_length(
) / 8 + B.x.__int__().bit_length() / 8 + B.y.__int__().bit_length() / 8
print('服务认证阶段消息<ACK,PID_UE,m_UE,A_UE,B_UE>字节数为：',
len(UE_EC['PID_UE']) + len(int_to_bytes(m_UE, 32)) + bytes_sum)
m_dict['5'] = len(UE_EC['PID_UE']) + len(int_to_bytes(m_UE,
32)) + bytes_sum
tt = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
tt.sendto(b_m_EC_A3VI, ('127.0.0.1', 12345))
tt.sendto(b_DokeyAgreement, ('127.0.0.1', 12347))
tt.close()
def UE_func(m_dict):
print(
'-----------------------------------------切片服务注册过程-----------------------------------------------'
)
start_reg = time.clock()
# ***************************开始计算变色龙哈希值*******************************
ChameleonHash = ChameleonHash_ECC.ChameleonHash() # 实例化对象，这一步注意不可少！！！
KeyTrans = key_type_transform.KeyTrans()
order = ChameleonHash.order()
m0 = random.randint(1, order - 1) # 这里m0 r0 是用户初始的两个变色龙哈希输入值
r0 = random.randint(1,
order - 1) # 从（1，order)中随机选择两个数m0,r0作为我们变色龙哈希函数的初始输入
CH_UE = ChameleonHash.Compute_CH(m0, r0)
# print('计算好的哈希值和陷门', CH_UE.CH()) # CH（m0,r0) = mP + rY
# print('陷门为：', CH_UE.trapdoor()) #陷门信息为（k,x）
N = random.getrandbits(256) # 获取256位随机位(二进制)的整数作为本次会话的会话号
ID_UE = b'123456789abcdef' # 用于模拟15位的SUPI / IMSI
ID_A3VI = b'987654321abcdef' # 类似的给A3VI分配一个ID号
message_UE = {
'CH_UE': CH_UE.CH(),
'N': N,
'ID_UE': ID_UE,
'ID_A3VI': ID_A3VI
} # 这是UE需要发送的消息明文
b_message_UE = pickle.dumps(message_UE) # 消息序列化为字节串
# print(b_message_UE)
# print(type(b_message_UE))
# *************************读取UE的私钥和公钥*************************************
private_key_raw = ECC.import_key(
open(r'D:\PythonProject\FUIH\ECC_file_keys\UE_privatekey.pem').read()
).d.__int__()
sk = KeyTrans.b_private_key(private_key_raw)
# *************************开始加密和签名************************************
# 读取Ope的公钥
public_key_raw_Ope = ECC.import_key(
open(r'D:\PythonProject\FUIH\ECC_file_keys\Ope_publickey.pem').read())
x1 = public_key_raw_Ope.pointQ.x.__int__()
y1 = public_key_raw_Ope.pointQ.y.__int__()
pk_Ope = KeyTrans.b_public_key(x1, y1)
curve = sslcrypto.ecc.get_curve('prime256v1')
ciphertext = curve.encrypt(b_message_UE, pk_Ope,
algo='aes-256-ofb') # 这里要用Ope的公钥来加密
h = hashlib.sha3_256() # 这里利用sha256对密文进行哈希处理
h.update(ciphertext)
cipher_h = h.hexdigest()
b_cipher_h = bytes(cipher_h,
encoding='utf-8') # 这里注意把 16进制的密文摘要转换为字节串，进行处理utf-8编码
signature = curve.sign(b_cipher_h, sk)
m_UE_AMF = {
'ciphertext': ciphertext,
'signature': signature
} # 这是UE需要发送的消息密文和签名
print('服务注册阶段消息<UText, E1, σ>字节数为：', len(ciphertext) + len(signature))
m_dict['1'] = len(ciphertext) + len(signature)
b_m_UE_AMF = pickle.dumps(m_UE_AMF) # 消息序列化为字节串
# print('序列化后的消息<UText, E1, σ>字节数为：', len(b_m_UE_AMF))
end_reg = time.clock()
print('UE端服务注册阶段计算开销：', (end_reg - start_reg) * 1000, 'ms')
m_dict['UE_Reg'] = (end_reg - start_reg) * 1000
# print(m_UE_AMF)
# print(b_m_UE_AMF)
# **********************UDP客户端编程【发送给AMF消息进行注册】***************************************
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.sendto(b_m_UE_AMF, ('127.0.0.1', 9999))
# s.close() 发送完ACK_UE再关闭
print('---1--- UE >>>> AMF 发送消息<UText, E1, σ>')
# print('发送消息成功，消息内容为：', b_m_UE_AMF)
# ************************UDP服务器端编程*********************************
v = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
v.bind(('127.0.0.1', 12347)) # 绑定端口
# print('007data:', pickle.loads(data))
# v.close() 收到密钥协商材料后再close
# TXID_ST = b'8b60004928090023bef4292ed4e0e414a9f1eaa2d734d4b34beb5c6b2f33bb59'
data_A3VI_UE, addr = v.recvfrom(4096) # 接收A3VI返回的注册后的确认消息<TXID_UE, T_Exp>
m_A3VI_UE = pickle.loads(data_A3VI_UE)
# print('007UE收到的注册确认消息TXID_UE：', m_A3VI_UE)
TXID_ST = m_A3VI_UE['TXID_ST']
# end_reg = time.clock()
# print('整个切片服务注册阶段计算开销为：', (end_reg-start_reg) * 1000, 'ms')
# **********************UDP客户端编程【发送给EC消息进行认证】***************************************
start_auth = time.clock()
SST = 0b10110001
w = {'SST': SST, 'ID_A3VI': ID_A3VI}
b_w = pickle.dumps(w)
# 这里生成 Hidden_Alloewed_S_NSSAI
k = hashlib.sha3_256() # 这里利用sha256对密文进行哈希处理
k.update(b_w)
w_h = k.hexdigest()
b_w_h = bytes(w_h, encoding='utf-8') # 这里注意把 16进制的密文摘要转换为字节串，进行处理utf-8编码
Hidden_Allowed_S_NSSAI = b_w_h
print(
'+++++++++++++++++++++++++++++++++++++++++++Inter-slice handover Authenticaion Phase++++++++++++++++++++++++++++++++++++++++++++++++++++++++++'
)
PID_UE = b'123456789abcdef12345' # 用户自己随机选择一个20位的假名
alpha = random.randint(1, order - 1) # 用于计算变色龙哈希碰撞
beta = random.randint(1, order - 1)
Y = ChameleonHash.get_Y()
A_UE = Y.pointQ.__mul__(alpha) # A_UE = alpha * Y
B_UE = Y.pointQ.__mul__(beta) # B_UE = beta * Y
T_Curr = time.clock()
m = {'PID_UE': PID_UE, 'A_UE': A_UE.xy, 'B_UE': B_UE.xy, "T_Curr": T_Curr}
b_m = pickle.dumps(m)
h = hashlib.sha3_256()
h.update(b_m)
m_h = h.hexdigest()
b_m_h = bytes(m_h, encoding='utf-8')
gamma = bytes_to_int(b_m_h)
k = CH_UE.trapdoor()[0]
x = CH_UE.trapdoor()[1]
r1 = alpha * gamma
m1 = (k - r1 * x + order) % order
end_auth = time.clock()
print('UE端在服务认证阶段的计算开销为：', (end_auth - start_auth) * 1000, 'ms')
m_dict['UE_Auth'] = (end_auth - start_auth) * 1000
# # TXID_ST = b'8b60004928090023bef4292ed4e0e414a9f1eaa2d734d4b34beb5c6b2f33bb59'
#
# data_A3VI_UE, addr = v.recvfrom(4096) # 接收A3VI返回的注册后的确认消息<TXID_UE, T_Exp>
#
# m_A3VI_UE = pickle.loads(data_A3VI_UE)
# # print('007UE收到的注册确认消息TXID_UE：', m_A3VI_UE)
# TXID_ST = m_A3VI_UE['TXID_ST']
# end_reg = time.clock()
# print('整个切片服务注册阶段计算开销为：', (end_reg-start_reg) * 1000, 'ms')
data, addr = v.recvfrom(4096)
m_UE_EC = {
'Hidden_Allowed_S_NSSAI': Hidden_Allowed_S_NSSAI,
'PID_UE': PID_UE,
'A_UE': A_UE.xy,
'B_UE': B_UE.xy,
'm_UE': m1,
'T_Curr': T_Curr,
'TXID_ST': TXID_ST
}
b_m_UE_EC = pickle.dumps(m_UE_EC)
print(
'+++1+++ UE >>>> EC 发送认证消息<Hidden_Allowed_S_NSSAI, PID_UE, A_UE, B_UE, m_UE, T_Curr, TXID_ST>'
)
# print('服务认证阶段消息<Hidden_Allowed_S_NSSAI, PID_UE, A_UE, B_UE, m_UE, T_Curr, TXID_ST>字节数：', len(Hidden_Allowed_S_NSSAI) +
# len(PID_UE) + 64 + 64 +len(int_to_bytes(m1, 5))+len(int_to_bytes(T_Curr.__int__(), 5))+len(TXID_ST))
print(
'服务认证阶段消息<Hidden_Allowed_S_NSSAI, PID_UE, A_UE, B_UE, m_UE, T_Curr, TXID_ST>字节数：',
len(Hidden_Allowed_S_NSSAI) + len(PID_UE) + 64 + 64 +
m1.bit_length() / 8 + T_Curr.__int__().bit_length() / 8 + len(TXID_ST))
m_dict['4'] = len(Hidden_Allowed_S_NSSAI) + len(
PID_UE) + 64 + 64 + m1.bit_length() / 8 + T_Curr.__int__().bit_length(
) / 8 + len(TXID_ST)
if data == b'start':
l = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
l.sendto(b_m_UE_EC, ('127.0.0.1', 12346))
l.close()
ack_data, addr = v.recvfrom(1024)
DoKeyAgreement = pickle.loads(ack_data)
if DoKeyAgreement:
print('***UE***收到密钥协商提示为True。')
else:
print('***UE***收到密钥协商提示为False。')
# end_auth =time.clock()
# print('整个服务认证阶段计算开销为：', (end_auth - start_auth) * 1000, 'ms')
# print('发送消息成功，消息内容为：', b_m_UE_EC)
# 接收A3VI密钥协商材料，并计算协商材料K值
agree_data, addr = v.recvfrom(4096)
A3VI_UE = pickle.loads(agree_data) # {'A_A3VI': A_A3VI, 'B_A3VI': B_A3VI}
print('***UE***接收到的A3VI的密钥协商材料为：', A3VI_UE)
start_agree = time.clock()
x_A = A3VI_UE['A_A3VI'][0]
y_A = A3VI_UE['A_A3VI'][1]
A_A3VI = ECC.EccPoint(x_A, y_A)
x_B = A3VI_UE['B_A3VI'][0]
y_B = A3VI_UE['B_A3VI'][1]
B_A3VI = ECC.EccPoint(x_B, y_B)
x_UE = ChameleonHash.get_x().__int__()
K_UE = (A_A3VI + B_A3VI).__mul__(x_UE * (alpha + beta))
print('***UE***计算出的密钥协商材料K为：', K_UE.xy)
# 开始计算协商密钥
hash_m = [PID_UE, m1, K_UE.xy]
# b_hash_m = pickle.dumps(hash_m)
# print('哈希前的长度', len(b_hash_m))
# h.update(b_hash_m[0:16])
# SK_A3VI = h.hexdigest()
# print(b_hash_m)
b_hash_m = bytes_to_int(pickle.dumps(hash_m))
SK_A3VI = hash(b_hash_m)
end_agree = time.clock()
print('UE端密钥协商阶段计算开销为：', (end_agree - start_agree) * 1000, 'ms')
m_dict['UE_KA'] = (end_agree - start_agree) * 1000
# SK = hash(b_hash_m)
print('***UE***计算出的会话密钥[Int类型]为：', SK_A3VI)
# print(SK)
# 【通过EC】发送ACK_UE消息给A3VI
hash_m1 = [K_UE.xy, SK_A3VI]
ACK = hash(bytes_to_int(pickle.dumps(hash_m1)))
b_ACK = pickle.dumps(ACK)
s.sendto(b_ACK, ('127.0.0.1', 12345))
s.close()
print('+++4+++ UE >>>> A3VI 发送消息ACK')
# print(type(ACK))
print('密钥协商阶段消息<ACK>字节数为：', ACK.bit_length() / 8)
m_dict['7'] = ACK.bit_length() / 8
print('++++++++++++++++++++UE端密钥协商完成！！！++++++++++++++++++++++++')
def A3VI_func(m_dict):
curve = sslcrypto.ecc.get_curve('prime256v1')
KeyTrans = key_type_transform.KeyTrans() # 注意示例化！！！
# Ring_Group = Ring_Group() # 记得实例化
ChameleonHash = ChameleonHash_ECC.ChameleonHash()
# ************************UDP服务器端编程*********************************
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.bind(('127.0.0.1', 12345)) # 绑定端口
data, addr = s.recvfrom(4096)
m_AUSF_A3VI = pickle.loads(data) # 收到消息后，反序列化得到 {'ciphertext': ciphertext, 'signature': signature}
signature_AUSF = m_AUSF_A3VI['signature']
ciphertext_AUSF = m_AUSF_A3VI['ciphertext']
print("***A3VI***收到的AUSF发送的消息<CText, E2, β>")
start_reg = time.clock()
# *****************************A3VI读取Ope的公钥进行验签***********************************
public_key_raw = ECC.import_key(open(r'D:\PythonProject\FUIH\ECC_file_keys\Ope_publickey.pem').read())
x = public_key_raw.pointQ.x.__int__()
y = public_key_raw.pointQ.y.__int__()
pk_Ope = KeyTrans.b_public_key(x, y)
s1 = hashlib.sha3_256() # 这里利用sha256对密文进行哈希处理
s1.update(ciphertext_AUSF)
cipher_h = s1.hexdigest()
b_cipher_h_AUSF = bytes(cipher_h, encoding='utf-8') # 这里注意把 16进制的密文摘要转换为字节串，进行处理utf-8编码
# assert True if curve.verify(signature_AUSF, b_cipher_h_AUSF, pk_Ope) else False
# print('A3VI收到的签名为：', signature_AUSF)
print('***A3VI***验签成功！！！') if curve.verify(signature_AUSF, b_cipher_h_AUSF, pk_Ope)is True else print('***A3VI***验签失败！！！')
# ***************************A3VI利用自己的私钥开始解密，获取信息CH_UE,N,RG,PST****************************************
private_key_raw = ECC.import_key(open(r'D:\PythonProject\FUIH\ECC_file_keys\A3VI_privatekey.pem').read()).d.__int__()
sk = KeyTrans.b_private_key(private_key_raw) # 注意！！！这是A3VI的私钥
b_message_AUSF = curve.decrypt(ciphertext_AUSF, sk, algo='aes-256-ofb')
message_AUSF = pickle.loads(b_message_AUSF) # 这里获得AUSF转发的消息{'CH_UE': message_UE['CH_UE'], 'N': message_UE['N'], 'RG_Ope': keys, 'PST': PST}
"""
这里A3VI把自己的公私钥混进环成员这里，在测试的时候，发现aosring的算法是基于secp256k1 (bitcoin)的，而我们其余的代码都是
基于secp256r1的椭圆曲线，所以这里暂时随机生成密钥，用于环签名。
"""
n = 10
keys = aosring_randkeys(n)
PST = message_AUSF['PST']
b_PST = pickle.dumps(PST)
msg = bytes_to_int(b_PST)
# A3VI开始进行环签名，生成一个成品票据ST
ST_all = aosring_sign(*keys, message=msg)
ST = (ST_all[1], ST_all[2])
end_reg = time.clock()
print('A3VI端服务注册阶段计算开销：', (end_reg-start_reg)*1000, 'ms')
m_dict['A3VI_Reg']=(end_reg - start_reg) * 1000
data_ST = {'CH_UE': message_AUSF['CH_UE'], 'N': message_AUSF['N'], 'RG_Ope': message_AUSF['RG_Ope'],
'RG_A3VI': keys, 'ST': ST}
print('***A3VI***生成票据ST，并把消息（CH_UE, N, T_Exp, RG_OPE, RG_A3VI, ST）上链成功！票据注册成功！') # 到这一步后我们假装上链成功
"""
这里A3VI把消息发布给区块链网络，由矿工对消息data_ST进行验证，利用'RG_Ope': message_AUSF['RG_Ope'], 'RG_A3VI'对票据ST进行验签，验签成功后，打包上链存储，
生成交易的记录号 TXID_ST = b'8b60004928090023bef4292ed4e0e414a9f1eaa2d734d4b34beb5c6b2f33bb59'
"""
TXID_ST = b'8b60004928090023bef4292ed4e0e414a9f1eaa2d734d4b34beb5c6b2f33bb59'
T_Exp = time.clock()
"""
关于区块链共识以及上链存储的操作，考虑到我们的工作重点在于协议设计和分析，目前我们暂时不考虑搭建区块链部分的实验
"""
# **********************UDP客户端编程***************************************
# 我们这里把data_ST发送给EC，EC得到消息后，假装自己是上链查询到的数据
b_data_ST = pickle.dumps(data_ST)
m = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
m.sendto(b_data_ST, ('127.0.0.1', 12346))
# A3VI把数据上链成功后，把票据号TXID_ST和时间戳T_Exp发送给UE
m_A3VI_UE = {'TXID_ST': TXID_ST, "T_Exp": T_Exp}
b_m_A3VI_UE = pickle.dumps(m_A3VI_UE)
m.sendto(b_m_A3VI_UE, ('127.0.0.1', 12347))
# print('服务注册阶段消息<TXDI_ST, T_Exp>字节数：', len(TXID_ST)+len(int_to_bytes(T_Exp.__int__(), 5)))
print('服务注册阶段消息<TXDI_ST, T_Exp>字节数：', len(TXID_ST)+ T_Exp.__int__().bit_length()/8)
m_dict['3'] = len(TXID_ST)+len(int_to_bytes(T_Exp.__int__(), 5))
# m.close() m先不要close，等密钥协商材料发给UE后再close
# print('EC根据TXDI_ST上链查询消息【实际是A3VI >> EC】')
# print('发送消息成功，消息内容为：', b_m_AUSF_A3VI)
# 等待接收EC发送给来的密钥协商材料
agree_data, addr = s.recvfrom(4096)
m_EC_A3VI = pickle.loads(agree_data)
print("****A3VI****接收到的密钥协商材料为：", m_EC_A3VI) # {'PID_UE': UE_EC['PID_UE'], 'm_UE': m_UE, 'A_UE': A_UE, 'B_UE': UE_EC['B_UE']}
start_agree1 = time.clock()
x_A = m_EC_A3VI['A_UE'][0]
y_A = m_EC_A3VI['A_UE'][1]
A_UE = ECC.EccPoint(x_A, y_A)
x_B = m_EC_A3VI['B_UE'][0]
y_B = m_EC_A3VI['B_UE'][1]
B_UE = ECC.EccPoint(x_B, y_B)
# 开始计算临时的会话密钥
order = ChameleonHash.order()
alpha = random.randint(1, order - 1) # 用于计算会话密钥
beta = random.randint(1, order - 1)
Y = ECC.import_key(open(r'D:\PythonProject\FUIH\ECC_file_keys\A3VI_publickey.pem').read()) # 这里是Y_A3VI 即是读取的A3VI的公钥，是点值
x_A3VI = private_key_raw # 这里private_key_raw为int值的原始私钥
A_A3VI = Y.pointQ.__mul__(alpha)
B_A3VI = Y.pointQ.__mul__(beta)
temp = x_A3VI * (alpha + beta)
K_A3VI = (A_UE + B_UE).__mul__(temp)
print('***A3VI***计算出的会话密钥材料K为：', K_A3VI.xy)
hash_m = [m_EC_A3VI['PID_UE'], m_EC_A3VI['m_UE'], K_A3VI.xy]
b_hash_m = pickle.dumps(hash_m)
# s1.update(b_hash_m[0:16])
# SK_A3VI = s1.hexdigest()
b_hash_m = bytes_to_int(pickle.dumps(hash_m))
SK_A3VI = hash(b_hash_m)
end_agree1 = time.clock()
print('***A3VI***计算出的会话密钥[Int类型]为：', SK_A3VI)
# 计算出会话密钥后，把消息【假装通过EC】发送给UE
print('+++3+++ A3VI >>>> UE 发送消息<A_A3VI, B_A3VI>')
m_A3VI_UE = {'A_A3VI': A_A3VI.xy, 'B_A3VI': B_A3VI.xy}
bytes_sum = (A_A3VI.x.__int__().bit_length() + A_A3VI.y.__int__().bit_length())/8 + (B_A3VI.x.__int__().bit_length() + B_A3VI.y.__int__().bit_length())/8
print('密钥协商阶段消息<A_A3VI,B_A3VI>字节数为：', bytes_sum) # 这里我们不再计算，因为我们知道A_A3VI.xy B_A3VI.xy 分别为64个字节
m_dict['6'] = bytes_sum
b_A3VI_UE = pickle.dumps(m_A3VI_UE)
m.sendto(b_A3VI_UE, ('127.0.0.1', 12347))
m.close()
# 接收UE发过来的密钥协商应答消息ACK_UE
ACK_data, addr = s.recvfrom(4096)
s.close()
ACK_UE = pickle.loads(ACK_data)
start_agree2 = time.clock()
ACK_A3VI = hash(bytes_to_int(pickle.dumps([K_A3VI.xy, SK_A3VI])))
# print('ACK_UE', ACK_UE)
# print('ACK_A3VI', ACK_A3VI)
if ACK_A3VI == ACK_UE:
print('+++++++++++++++A3VI端密钥协商成功！！！++++++++++++++++++++++++++')
else:
print('++++++++++++++++++++++密钥协商失败！！++++++++++++++++++++++++++++++')
end_agree2 = time.clock()
print('A3VI端密钥协商阶段计算开销为：', ((end_agree2-start_agree2)+(end_agree1-start_agree1)) * 1000, 'ms')
m_dict['A3VI_KA'] = ((end_agree2-start_agree2)+(end_agree1-start_agree1)) * 1000
