K1531112

add README

import hashlib
class PCProver:
def __init__(self, g=5, p=2333, s=15):
self.g = g
self.q = 2*p + 1
self.s = s
self.h = pow(g, s, self.q)
def commit(self, M, r):
m = int(hashlib.sha256(M.encode()).hexdigest() ,16)
c = pow(self.g, m, self.q) * pow(self.h, r, self.q) % self.q
return (Message(M, r), Commitment(c))
def getParams(self):
return PCParameters(self.q, self.g, self.h)
class Message:
def __init__(self, M, r):
self.M = M
self.r = r
def __repr__(self):
return """M | {}
r | {}""".format(self.M, self.r)
class Commitment:
def __init__(self, c):
self.c = c
def __repr__(self):
return """c | {}""".format(self.c)
class PCParameters:
def __init__(self, q, g, h):
self.q = q
self.g = g
self.h = h
class PCVerifier:
def __init__(self, params):
self.c = []
self.m = []
self.r = []
self.q = params.q
self.g = params.g
self.h = params.h
def __repr__(self):
returnStr = """Commitments | {}
Messages | {}
q | {}
g | {}
h | {}""".format(len(self.c), len(self.m), self.q, self.g, self.h)
return returnStr
def add(self, dataObject):
if(type(dataObject) is Commitment):
self.c.append(dataObject.c)
if(type(dataObject) is Message):
m = int(hashlib.sha256(dataObject.M.encode()).hexdigest() ,16)
self.m.append(m)
self.r.append(dataObject.r)
def productCommitments(self):
pi = 1
for ci in self.c:
pi *= ci
return pi % self.q
def verify(self):
c = self.productCommitments()
m_sum = 0
r_sum = 0
for i in range(len(self.m)):
m_sum += self.m[i]
r_sum += self.r[i]
cv = pow(self.g, m_sum, self.q) * pow(self.h, r_sum, self.q) % self.q
return c == cv
# Pedersen Commitment
Project includes python implementation of Pedersen Commitment Scheme.
# How to use
example.py contains code examples to perform the RAPPOR algorithm.
### Creating Commitments
```
from PC import PCProver, PCVerifier
```
Initialise the parameters.
```
pc = PCProver(self, g=5, p=2333, s=15)
params = pc.getParams()
verifier = PCVerifier(params)
```
Create commitments with a message and random integer.
```
m1, c1 = pc.commit("Hello!", 7)
m2, c2 = pc.commit("Goodbye!", 9)
```
Send the commitments first.
```
verifier.add(c1)
verifier.add(c2)
```
When the prover wants to reveal messages, they can be sent to the verifier and finally confirms the messages.
```
verifier.add(m1)
verifier.add(m2)
print(verifier.verify())
```
# Parameters
**Name** | **Description** | **Rules**
| --- | --- | --- |
g | Generator value. | Must be a positive integer between 1 and q - 1.
p | Prime number that will produce q = 2p + 1. | Must be a prime.
s | Secret value used to create h = g^s mod q. | Must be a positive integer between 1 and q - 1.
\ No newline at end of file
from PC import PCProver, PCVerifier
#Set up the params
pc = PCProver()
params = pc.getParams()
verifier = PCVerifier(params)
#Dictionary of messages and their respective "random" integers
exchange = [{"M":"Hello!", "r":7},
{"M":"Goodbye!", "r":9}]
commitments = []
messages = []
#Create commitments and keep the results
for i in range(len(exchange)):
ex = exchange[i]
(m, c) = pc.commit(ex["M"], ex["r"])
commitments.append(c)
messages.append(m)
#Send commitments to the verifier
for c in commitments:
verifier.add(c)
#Interim period before prover wants to reveal message
#Send messages to the verifier
for m in messages:
verifier.add(m)
#Verifier computes the challenges with the messages and compares them with the commitments
print(verifier.verify())