#!/usr/bin/env python3
import random
# Alice's Private/Public key pair, hard coded for simplicity
class PrivateKey():
	lambdA=73842165240981452554905699590449542088961757004289873177979834078905122488912
	mu=14623866067924162049758185900912462985982902037214491087468255488155427133263

class PublicKey():
	n=73842165240981452554905699590449542089513117936657660262085094366199671389241
	n2=5452665367476409421070096932669081750981552257584472365472731868555542659457163641469759175897028833132670904633495629764635203858875472896093430930556081
	g=73842165240981452554905699590449542089513117936657660262085094366199671389242

# Alice's Implementation of a fully homomorphic Paillier cipher
class FullyHomoCipher():
	def __init__(self, a1, b1):
		self.a = a1
		self.b = b1

	def expCalc(self, base,exponent,modulus):
		result = 1
		while exponent > 0:
			if exponent & 1 == 1:
				result = (result * base) % modulus
			exponent = exponent >> 1
			base = (base * base) % modulus
		return result

	def encrypt(self, pub, plain):
		while True: 
			r = random.getrandbits(128)
			if r > 0 and r < pub.n:
				break
		x = self.expCalc(r, pub.n, pub.n2)
		cipher = (self.expCalc(pub.g, plain, pub.n2) * x) % pub.n2
		return cipher
		
	def decrypt(self, priv, pub, cipher):
		x = self.expCalc(cipher, priv.lambdA, pub.n2) - 1
		plain = ((x // pub.n) * priv.mu) % pub.n
		return plain    

	def encrypt_message(self, pub, m):
		r = random.randrange(256, pub.n)
		b = self.encrypt(pub, r)
		a = (m-r) % pub.n
		self.a = a
		self.b = b
       
	def decrypt_message(self, priv, pub):
		val = (self.a + self.decrypt(priv, pub, self.b)) % pub.n
		return val

# Bob's encrypted calculation service
class BobsCalculationService():
	# Add two encrypted numbers
	def encrypted_add(self, pub, a, b):
		return a * b % pub.n2

	def sum (self, c1, c2, pub):
		a = (c1.a + c2.a) % pub.n
		b = self.encrypted_add(pub, c1.b, c2.b)
		c = FullyHomoCipher(a, b)
		return c

	# Multiply two encrypted numbers with a constant (Bob)
	def encrypted_mult(self, pub, a, n):
		return FullyHomoCipher(-1,-1).expCalc(a, n, pub.n2)

	def product(self, const, c1, pub):
		a = (c1.a * const) % pub.n
		b = self.encrypted_mult(pub, c1.b, const)
		c = FullyHomoCipher(a,b)
		return c
		
# THE SAAS EXAMPLE BEGINS HERE
if __name__ == '__main__':
	# Alice's Key Pair
	pub=PublicKey
	priv=PrivateKey
	
	# The top secret numbers Alice wants to use
	secretNumber1=5
	secretNumber2=10
	secretNumber3=6
	const=3
	
	# The Cipher objects Alice uses for encryption
	alice1 = FullyHomoCipher(-1,-1)
	alice2 = FullyHomoCipher(-1,-1)
	alice3 = FullyHomoCipher(-1,-1)
	
	# Alice performs encryption
	print ("SaaS Example:")
	print ("Alice wants to use Bob's calculation service to calculate ",secretNumber1,"+",secretNumber2)
	print ("She encrypts ", secretNumber1)
	alice1.encrypt_message(pub, secretNumber1)
	print ("...and the encrypted value is ",alice1.a,alice1.b)
	print ("She then encrypts ",secretNumber2)
	alice2.encrypt_message(pub, secretNumber2)
	print ("...and the encypted value is ",alice2.a,alice2.b)
	print ("")
	print ("Alice also wants to to multiply ",secretNumber3," with the constant ",const)
	print ("She encrypts ", secretNumber3)
	alice3.encrypt_message(pub, secretNumber3)
	print ("...and the encrypted value is ",alice3.a,alice3.b)
	print ("")
	print ("Then Alice sends the encrypted values to Bob along with her public key")
	print ("")
	
	# These are the encrypted values Alice sends to Bob
	encr1_a=alice1.a
	encr1_b=alice1.b
	encr2_a=alice2.a
	encr2_b=alice2.b
	encr3_a=alice3.a
	encr3_b=alice3.b

	# Bob's Cipher objects, initialized with Alice's encrypted numbers
	# Since Bob doesn't have the private key he can't decrypt the numbers
	bob1 = FullyHomoCipher(encr1_a,encr1_b)
	bob2 = FullyHomoCipher(encr2_a,encr2_b)
	bob3 = FullyHomoCipher(encr3_a,encr3_b)
	
	# Addition 
	print ("Bob adds the two encrypted values without knowing what they are")
	result1=BobsCalculationService().sum(bob1, bob2, pub)
	print ("the encrypted result is ",result1.a,result1.b)
	# Multiplication with a constant
	print ("Bob multiplies the third encrypted value with the constant")
	result2=BobsCalculationService().product(const, bob3, pub)
	print ("the encrypted result is ",result2.a,result2.b)
	print ("")

	print ("Bob sends the encrypted results back to Alice")
	print ("Alice uses her private key to view the plain text results:")
	print ("Addition: ",result1.decrypt_message(priv, pub))
	print ("Multiplication: ",result2.decrypt_message(priv, pub))