def Exchange(sock):
PI = [
CardN, CardExp, CCode, SID, Amount,
client_public.export_key(), NC, M
]
pick = pickle.dumps(PI)
PM = sec.encrypt_data(pickle.dumps([pick,
sec.sign(pick, client_private)]),
payment_gateway_public)
data = [OrderDesc, SID, Amount, NC]
PO = [pickle.dumps(data), sec.sign(pickle.dumps(data), client_private)]
# 3. Send {PM,PO}PubKM
send_data = pickle.dumps((PM, PO))
cyper = sec.encrypt_data(send_data, merchant_public)
sock.send(cyper)
st = time.time()
# 6. Recieve Response from Merchant
dataRecv = sock.recv(2048)
end = time.time() - st
# print(end)
if end > 0.03:
data = Resolution(True)
else:
Resolution(False)
data = sec.decrypt_data(dataRecv, client_private)
Response, sid, signuature = pickle.loads(data)
if sid == SID and sec.checksign(pickle.dumps([Response, SID, Amount, NC]),
payment_gateway_public, signuature):
print("Raspuns tranzactie: ", Response)
def Resolution(socket):
data = socket.recv(2048)
if sec.decrypt_data(data, payment_gateway_private) == b'OK':
print("Ok")
return None
else:
socket.send(sec.encrypt_data(resolution, client_public))
def Resolution(cond):
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.connect(("127.0.0.1", 4411))
if not cond:
s.send(sec.encrypt_data(b"OK", payment_gateway_public))
return None
else:
signature = sec.sign(
pickle.dumps([SID, Amount, NC,
client_public.export_key()]), client_private)
message = pickle.dumps(
[SID, Amount, NC,
client_public.export_key(), signature])
s.send(sec.encrypt_data(message, payment_gateway_public))
data = sec.decrypt_data(s.recv(2048), client_private)
return data
def Setup(socket_client):
global merchant_private
global client_public
# 1.Read Client Public key and load it
data = socket_client.recv(1024)
client_public = RSA.import_key(sec.decrypt_data(data, merchant_private))
# 2.Send to Client Sid+Sig(Sid)
data = [Sid, sec.sign(Sid, merchant_private)]
socket_client.send(sec.encrypt_data(pickle.dumps(data), client_public))
def Setup(sock):
global SID
global Sig_SID
# 1.Send Client public key to merchant
sock.send(sec.encrypt_data(client_public.export_key(), merchant_public))
# 2.Read Sid + Sig(Sid) from merchant
data = pickle.loads(sec.decrypt_data(sock.recv(1024), client_private))
SID = data[0]
Sig_SID = data[1]
def Exchange(socket_client, socket_PG):
# 3.Read {PM,PO}
data = sec.decrypt_data(socket_client.recv(2048), merchant_private)
PM, PO = pickle.loads(data)
dataPO, signPO = PO
if sec.checksign(dataPO, client_public, signPO):
dataPO = pickle.loads(dataPO)
signature = sec.sign(
pickle.dumps([dataPO[1],
client_public.export_key(), dataPO[2]]),
merchant_private)
sendData = pickle.dumps((PM, signature))
# 4. Send {PM,SigM{..}} to PG
socket_PG.send(sec.encrypt_data(sendData, payment_gateway_public))
# 5. Recieve Response from PG
dataCr = socket_PG.recv(2048)
data = sec.decrypt_data(dataCr, merchant_private)
# 6. Send Response to CLinet
socket_client.send(sec.encrypt_data(data, client_public))
def Exchange(socket):
global client_public
# 4. Read {PM,SigM
data = pickle.loads(
sec.decrypt_data(socket.recv(2048), payment_gateway_private))
PM, sign = data
PI, signPI = pickle.loads(sec.decrypt_data(PM, payment_gateway_private))
PI = pickle.loads(PI)
# print(PI)
if sec.checksign(pickle.dumps([PI[3], PI[5], PI[4]]), merchant_public,
sign):
client_public = RSA.import_key(PI[5])
if sec.checksign(pickle.dumps(PI), client_public, signPI):
print("semnaturi verificate")
cardN = PI[0]
cardExp = PI[1]
CCode = PI[2]
SID = PI[3]
Amount = PI[4]
NC = PI[6]
M = PI[7]
for i in range(len(banking_data)):
Cid = banking_data[i]['id']
card_data = banking_data[i]['card-data']
balance = banking_data[i]['balance']
if card_data['CardN'] == cardN and card_data[
'CardExp'] == cardExp and card_data['CCode'] == CCode:
global resolution
if Amount <= balance:
Resp = "Tranzactie Acceptata "
banking_data[i]['balance'] -= Amount
json.dump(banking_data, open("banking_data.json", "w"))
else:
Resp = "Tranzactie Refuzata , Fonduri Insuficiente"
signData = [Resp, SID, Amount, NC]
signature = sec.sign(pickle.dumps(signData),
payment_gateway_private)
message = pickle.dumps([Resp, SID, signature])
# 5. Send Response to Merchant
resolution = message
socket.send(sec.encrypt_data(message, merchant_public))
break