-
Notifications
You must be signed in to change notification settings - Fork 1
/
commit.py
136 lines (111 loc) · 4.79 KB
/
commit.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
import random
from ZeroKnowledge import bbs
class CommitmentScheme(object):
def __init__(self, oneWayPermutation, hardcorePredicate, securityParameter):
'''
oneWayPermutation: int -> int
hardcorePredicate: int -> {0, 1}
'''
self.oneWayPermutation = oneWayPermutation
self.hardcorePredicate = hardcorePredicate
self.securityParameter = securityParameter
# a random string of length `self.securityParameter` used only once per commitment
self.secret = self.generateSecret()
def generateSecret(self):
raise NotImplemented
def commit(self, x):
print('commit Place 1')
raise NotImplemented
def reveal(self):
return self.secret
class BBSBitCommitmentScheme(CommitmentScheme):
def generateSecret(self):
# the secret is a random quadratic residue
self.secret = self.oneWayPermutation(random.getrandbits(self.securityParameter))
return self.secret
def commit(self, bit):
print('commit PLACE 2')
unguessableBit = self.hardcorePredicate(self.secret)
return (
self.oneWayPermutation(self.secret),
unguessableBit ^ bit, # python xor
)
class BBSBitCommitmentVerifier(object):
def __init__(self, oneWayPermutation, hardcorePredicate):
self.oneWayPermutation = oneWayPermutation
self.hardcorePredicate = hardcorePredicate
def verify(self, securityString, claimedCommitment):
trueBit = self.decode(securityString, claimedCommitment)
unguessableBit = self.hardcorePredicate(securityString) # wasteful, whatever
return claimedCommitment == (
self.oneWayPermutation(securityString),
unguessableBit ^ trueBit, # python xor
)
def decode(self, securityString, claimedCommitment):
unguessableBit = self.hardcorePredicate(securityString)
return claimedCommitment[1] ^ unguessableBit
class BBSStringCommitmentScheme(CommitmentScheme):
def __init__(self, numBits, oneWayPermutation, hardcorePredicate, securityParameter=512):
'''
A commitment scheme for integers of a prespecified length `numBits`. Applies the
bit commitment scheme to each bit independently.
'''
self.schemes = [BBSBitCommitmentScheme(oneWayPermutation, hardcorePredicate, securityParameter)
for _ in range(numBits)]
super().__init__(oneWayPermutation, hardcorePredicate, securityParameter)
def generateSecret(self):
self.secret = [x.secret for x in self.schemes]
return self.secret
def commit(self, data):
print('commit PLACE 3: data len: ', len(data))
binaryString = ""
for ch in str(data):
chInBin = format(ord(ch), 'b').zfill(8)
binaryString += str(chInBin)
bits = [int(char) for char in binaryString]
return [scheme.commit(bit) for scheme, bit in zip(self.schemes, bits)]
class BBSStringCommitmentVerifier(object):
def __init__(self, numBits, oneWayPermutation, hardcorePredicate):
self.verifiers = [BBSBitCommitmentVerifier(oneWayPermutation, hardcorePredicate)
for _ in range(numBits)]
def decodeBits(self, secrets, bitCommitments):
return [v.decode(secret, commitment) for (v, secret, commitment) in
zip(self.verifiers, secrets, bitCommitments)]
def verify(self, secrets, bitCommitments):
return all(
bitVerifier.verify(secret, commitment)
for (bitVerifier, secret, commitment) in
zip(self.verifiers, secrets, bitCommitments)
)
def decode(self, secrets, bitCommitments):
decodedBits = self.decodeBits(secrets, bitCommitments)
binary = ''.join(str(bit) for bit in decodedBits)
n = 8;
binarySets = [binary[i:i+n] for i in range(0, len(binary), n)]
chars = [chr(int(charBin, 2)) for charBin in binarySets]
return ''.join(chars)
if __name__ == "__main__":
securityParameter = 10
oneWayPerm = bbs.bbs(securityParameter)
hardcorePred = bbs.parity
scheme = BBSStringCommitmentScheme(512, oneWayPerm, hardcorePred)
verifier = BBSStringCommitmentVerifier(512, oneWayPerm, hardcorePred)
data = {
"fruits":[
"apple",
"banana"
]
}
data = str(data)
tc = ["hello", data]
for string in tc:
commitments = scheme.commit(string)
secrets = scheme.reveal()
trueString = verifier.decode(secrets, commitments)
valid = verifier.verify(secrets, commitments)
print(f"INPUT STRING : {string}")
print(f"DECODED STRING : {trueString}")
print(f"VALIDATION : {valid}")
print(f"SECRET : {secrets}")
print(f"COMMITMENTS : {commitments}")
print("\n\n")