test.py - pypbc in pypbc

#! /usr/bin/env python3

"""
test.py

Written by Geremy Condra
Licensed under GPLv3
Released 11 October 2009
"""

import unittest

from pypbc import *

stored_params = """type a
q 8780710799663312522437781984754049815806883199414208211028653399266475630880222957078625179422662221423155858769582317459277713367317481324925129998224791
h 12016012264891146079388821366740534204802954401251311822919615131047207289359704531102844802183906537786776
r 730750818665451621361119245571504901405976559617
exp2 159
exp1 107
sign1 1
sign0 1
"""

class TestParameters(unittest.TestCase):
	
	def setUp(self): pass
	
	def test_init(self):
		try:
			# test n-type generation
			params = Parameters(n=3559*3571) 	# type a1
			# not tested because it is *crazy* slow on my old machine...
			#params = Parameters(n=3559*3571, short=True) # type f
			# test s-type generation
			params = Parameters(param_string=stored_params)	# type a
			# test qr-type generation
			params = Parameters(qbits=512, rbits=160) # type a
			#params = Parameters(qbits=512, rbits=160, short=True) # type e, may be renamed
		except Exception:
			fail("Could not instantiate parameters")
			
	def test_bad_init(self):
		# here we try to make it screw up by calling it incorrectly
		# here, param_string and other values are given
		try:
			Parameters(param_string=stored_params, short=True)
			self.fail()
		except: pass
		try:
			Parameters(param_string=stored_params, qbits=512)
			self.fail()
		except: pass
		try:
			Parameters(param_string=stored_params, rbits=512)
			self.fail()
		except: pass
		try:
			Parameters(param_string=stored_params, n=512)
			self.fail()
		except: pass
		try:
			Parameters(param_string=stored_params, rbits=512)
			self.fail()
		except: pass
		#self.assertRaises(Exception, Parameters, "hello world")
		self.assertRaises(Exception, Parameters, 1.0)
		pass

class TestPairing(unittest.TestCase):

	def setUp(self):
		self.params = Parameters(n=3559*3571)
		
	def test_init(self):
		try:
			Pairing(self.params)
		except Exception:
			self.fail("Could not instantiate pairing")

	def test_bad_init(self):
		#self.assertRaises(Exception, Pairing)
		self.assertRaises(Exception, Pairing, "hello world")
		
	def test_apply(self):
		pairing = Pairing(self.params)
		e1 = Element(pairing, G1)
		e2 = Element(pairing, G2)
		try:
			e3 = pairing.apply(e1, e2)
		except:
			self.fail("could not apply pairing.")
			
	def test_bad_apply(self):
		pairing = Pairing(self.params)
		e1 = Element(pairing, G1)
		e2 = Element(pairing, G2)
		self.assertRaises(Exception, pairing.apply)
		self.assertRaises(Exception, pairing.apply, e1)
		self.assertRaises(Exception, pairing.apply, "hi", 1.5)

			
class TestElement(unittest.TestCase):

	def setUp(self):
		self.params = Parameters(n=3559*3571)
		self.pairing = Pairing(self.params)
		
	def test_init(self):
		try:
			self.e1 = Element(self.pairing, G1)
			self.e2 = Element.zero(self.pairing, G2)
			self.e3 = Element.one(self.pairing, G1)
			self.e4 = Element.random(self.pairing, G1)
			self.e5 = Element(self.pairing, Zr, value=3559)
			self.e6 = Element.from_hash(self.pairing, Zr, "hello world!")
			print(self.e6)
		except Exception:
			self.fail("Could not instantiate element")
	
	def test_str(self):
		self.e5 = Element(self.pairing, Zr, value=3559)
		self.failUnlessEqual("3559", str(self.e5))

	def test_bad_init(self):
		self.assertRaises(TypeError, Element)
		self.assertRaises(TypeError, Element, self.pairing)
		self.assertRaises(TypeError, Element, G1)
		self.assertRaises(TypeError, Element, "hidey ho", G1)
		self.assertRaises(TypeError, Element, self.pairing, "snerk")
		try:
			Element.random(self.pairing, GT)
			self.fail()
		except: pass

	def test_add(self):
		self.e1 = Element(self.pairing, Zr, value=3)
		self.e2 = Element(self.pairing, Zr, value=5)
		self.e3 = self.e1 + self.e2
		self.failUnlessEqual(str(self.e3), "8")
		self.e4 = self.e1 + self.e3
		
	def test_sub(self):
		self.e1 = Element(self.pairing, Zr, value=3)
		self.e2 = Element(self.pairing, Zr, value=5)
		self.e3 = self.e2 - self.e1
		self.failUnlessEqual(str(self.e3), "2")
		
	def test_mult(self):
		self.e1 = Element(self.pairing, Zr, value=3)
		self.e2 = Element(self.pairing, Zr, value=5)
		self.e3 = self.e1 * self.e2
		self.failUnlessEqual(str(self.e3), "15")
		try: self.e3 * 5
		except: self.fail()
		self.e4 = self.pairing.apply(Element.random(self.pairing, G1), Element.random(self.pairing, G2))
		self.e5 = self.pairing.apply(Element.random(self.pairing, G1), Element.random(self.pairing, G2))
		try: self.e4 * self.e5
		except: self.fail()
		
	def test_pow(self):
		self.e1 = Element(self.pairing, Zr, value=3)
		self.e2 = Element(self.pairing, Zr, value=2)
		self.e3 = pow(self.e1, self.e2)
		self.failUnlessEqual(str(self.e3), "9")
		try: 
			self.e1**(1,2)
			self.fail()
		except: 
			pass
		
	def test_cmp(self):
		self.e1 = Element.random(self.pairing, G1)
		self.e2 = Element.random(self.pairing, G1)
		self.failUnlessEqual(self.e1 == self.e2, False)
		self.e3 = Element(self.pairing, Zr, value=36)
		self.e4 = Element(self.pairing, Zr, value=36)
		self.failUnlessEqual(self.e3, self.e4)
		self.e5 = Element.zero(self.pairing, G1);
		self.e6 = Element.one(self.pairing, Zr);
		self.failUnlessEqual(self.e5 == 0, True)
		self.failUnlessEqual(self.e5 == 1, True)
		self.failUnlessEqual(self.e6 == 0, False)
		self.failUnlessEqual(self.e6 == 1, True)
		self.e7 = Element.random(self.pairing, G2)
		self.failUnlessEqual(self.e7 == 0, False)
		self.failUnlessEqual(self.e7 == 1, False)		
		try:
			self.e5 < self.e6
			self.fail()
			self.e5 > self.e6
			self.fail()
		except: pass
		
	def test_neg(self):
		self.e1 = Element.random(self.pairing, Zr)
		self.e2 = -self.e1
		try:
			-Element.one(self.pairing, GT)
			self.fail()
		except: pass
		
	def test_inv(self):
		self.e1 = Element.random(self.pairing, Zr)
		self.e2 = ~self.e1
		try:
			~Element.one(self.pairing, GT)
			self.fail()
		except: pass
		
	def test_bls(self):
		stored_params = """type a
		q 8780710799663312522437781984754049815806883199414208211028653399266475630880222957078625179422662221423155858769582317459277713367317481324925129998224791
		h 12016012264891146079388821366740534204802954401251311822919615131047207289359704531102844802183906537786776
		r 730750818665451621361119245571504901405976559617
		exp2 159
		exp1 107
		sign1 1
		sign0 1
		"""

		# this is a test for the BLS short signature system
		params = Parameters(param_string=stored_params)
		pairing = Pairing(params)

		# build the common parameter g
		g = Element.random(pairing, G2)

		# build the public and private keys
		private_key = Element.random(pairing, Zr)
		public_key = Element(pairing, G2, value=g**private_key)

		# set the magic hash value
		hash_value = Element.from_hash(pairing, G1, "hashofmessage")

		# create the signature
		signature = hash_value**private_key

		# build the temps
		temp1 = Element(pairing, GT)
		temp2 = Element(pairing, GT) 

		# fill temp1
		temp1 = pairing.apply(signature, g)

		#fill temp2
		temp2 = pairing.apply(hash_value, public_key)

		# and again...
		temp1 = pairing.apply(signature, g)

		# compare
		self.failUnlessEqual(temp1 == temp2, True)

		# compare to random signature
		rnd = Element.random(pairing, G1)
		temp1 = pairing.apply(rnd, g)

		# compare
		self.failUnlessEqual(temp1 == temp2, False)
		
	def test_auth(self):
		# taken from paul miller's PBC::Crypt module tutorial
		params = Parameters(qbits=512, rbits=160)
		pairing = Pairing(params)
		p = Element.random(pairing, G2)
		s = Element.random(pairing, Zr)
		public_key = p**s
		# not actually from a hash. I don't really care.
		Q_0 = Element.from_hash(pairing, G1, "node_id=22609")
		# ditto
		Q_1 = Element.from_hash(pairing, G1, "node_id=9073")
		d_0 = Q_0**s
		d_1 = Q_1**s
		k_01_a = pairing.apply(Q_0, d_1)
		k_01_b = pairing.apply(d_0, Q_1)
		self.failUnlessEqual(k_01_a, k_01_b)
		k_10_a = pairing.apply(Q_1, d_0)
		k_10_b = pairing.apply(d_1, Q_0)
		self.failUnlessEqual(k_10_a, k_10_b)
		

if __name__ == '__main__':
	unittest.main()

1	#! /usr/bin/env python3
2
3	"""
4	test.py
5
6	Written by Geremy Condra
7	Licensed under GPLv3
8	Released 11 October 2009
9	"""
10
11	import unittest
12
13	from pypbc import *
14
15	stored_params = """type a
16	q 8780710799663312522437781984754049815806883199414208211028653399266475630880222957078625179422662221423155858769582317459277713367317481324925129998224791
17	h 12016012264891146079388821366740534204802954401251311822919615131047207289359704531102844802183906537786776
18	r 730750818665451621361119245571504901405976559617
19	exp2 159
20	exp1 107
21	sign1 1
22	sign0 1
23	"""
24
25	class TestParameters(unittest.TestCase):
26
27	def setUp(self): pass
28
29	def test_init(self):
30	try:
31	# test n-type generation
32	params = Parameters(n=3559*3571) # type a1
33	# not tested because it is crazy slow on my old machine...
34	#params = Parameters(n=3559*3571, short=True) # type f
35	# test s-type generation
36	params = Parameters(param_string=stored_params) # type a
37	# test qr-type generation
38	params = Parameters(qbits=512, rbits=160) # type a
39	#params = Parameters(qbits=512, rbits=160, short=True) # type e, may be renamed
40	except Exception:
41	fail("Could not instantiate parameters")
42
43	def test_bad_init(self):
44	# here we try to make it screw up by calling it incorrectly
45	# here, param_string and other values are given
46	try:
47	Parameters(param_string=stored_params, short=True)
48	self.fail()
49	except: pass
50	try:
51	Parameters(param_string=stored_params, qbits=512)
52	self.fail()
53	except: pass
54	try:
55	Parameters(param_string=stored_params, rbits=512)
56	self.fail()
57	except: pass
58	try:
59	Parameters(param_string=stored_params, n=512)
60	self.fail()
61	except: pass
62	try:
63	Parameters(param_string=stored_params, rbits=512)
64	self.fail()
65	except: pass
66	#self.assertRaises(Exception, Parameters, "hello world")
67	self.assertRaises(Exception, Parameters, 1.0)
68	pass
69
70	class TestPairing(unittest.TestCase):
71
72	def setUp(self):
73	self.params = Parameters(n=3559*3571)
74
75	def test_init(self):
76	try:
77	Pairing(self.params)
78	except Exception:
79	self.fail("Could not instantiate pairing")
80
81	def test_bad_init(self):
82	#self.assertRaises(Exception, Pairing)
83	self.assertRaises(Exception, Pairing, "hello world")
84
85	def test_apply(self):
86	pairing = Pairing(self.params)
87	e1 = Element(pairing, G1)
88	e2 = Element(pairing, G2)
89	try:
90	e3 = pairing.apply(e1, e2)
91	except:
92	self.fail("could not apply pairing.")
93
94	def test_bad_apply(self):
95	pairing = Pairing(self.params)
96	e1 = Element(pairing, G1)
97	e2 = Element(pairing, G2)
98	self.assertRaises(Exception, pairing.apply)
99	self.assertRaises(Exception, pairing.apply, e1)
100	self.assertRaises(Exception, pairing.apply, "hi", 1.5)
101
102
103	class TestElement(unittest.TestCase):
104
105	def setUp(self):
106	self.params = Parameters(n=3559*3571)
107	self.pairing = Pairing(self.params)
108
109	def test_init(self):
110	try:
111	self.e1 = Element(self.pairing, G1)
112	self.e2 = Element.zero(self.pairing, G2)
113	self.e3 = Element.one(self.pairing, G1)
114	self.e4 = Element.random(self.pairing, G1)
115	self.e5 = Element(self.pairing, Zr, value=3559)
116	self.e6 = Element.from_hash(self.pairing, Zr, "hello world!")
117	print(self.e6)
118	except Exception:
119	self.fail("Could not instantiate element")
120
121	def test_str(self):
122	self.e5 = Element(self.pairing, Zr, value=3559)
123	self.failUnlessEqual("3559", str(self.e5))
124
125	def test_bad_init(self):
126	self.assertRaises(TypeError, Element)
127	self.assertRaises(TypeError, Element, self.pairing)
128	self.assertRaises(TypeError, Element, G1)
129	self.assertRaises(TypeError, Element, "hidey ho", G1)
130	self.assertRaises(TypeError, Element, self.pairing, "snerk")
131	try:
132	Element.random(self.pairing, GT)
133	self.fail()
134	except: pass
135
136	def test_add(self):
137	self.e1 = Element(self.pairing, Zr, value=3)
138	self.e2 = Element(self.pairing, Zr, value=5)
139	self.e3 = self.e1 + self.e2
140	self.failUnlessEqual(str(self.e3), "8")
141	self.e4 = self.e1 + self.e3
142
143	def test_sub(self):
144	self.e1 = Element(self.pairing, Zr, value=3)
145	self.e2 = Element(self.pairing, Zr, value=5)
146	self.e3 = self.e2 - self.e1
147	self.failUnlessEqual(str(self.e3), "2")
148
149	def test_mult(self):
150	self.e1 = Element(self.pairing, Zr, value=3)
151	self.e2 = Element(self.pairing, Zr, value=5)
152	self.e3 = self.e1 * self.e2
153	self.failUnlessEqual(str(self.e3), "15")
154	try: self.e3 * 5
155	except: self.fail()
156	self.e4 = self.pairing.apply(Element.random(self.pairing, G1), Element.random(self.pairing, G2))
157	self.e5 = self.pairing.apply(Element.random(self.pairing, G1), Element.random(self.pairing, G2))
158	try: self.e4 * self.e5
159	except: self.fail()
160
161	def test_pow(self):
162	self.e1 = Element(self.pairing, Zr, value=3)
163	self.e2 = Element(self.pairing, Zr, value=2)
164	self.e3 = pow(self.e1, self.e2)
165	self.failUnlessEqual(str(self.e3), "9")
166	try:
167	self.e1**(1,2)
168	self.fail()
169	except:
170	pass
171
172	def test_cmp(self):
173	self.e1 = Element.random(self.pairing, G1)
174	self.e2 = Element.random(self.pairing, G1)
175	self.failUnlessEqual(self.e1 == self.e2, False)
176	self.e3 = Element(self.pairing, Zr, value=36)
177	self.e4 = Element(self.pairing, Zr, value=36)
178	self.failUnlessEqual(self.e3, self.e4)
179	self.e5 = Element.zero(self.pairing, G1);
180	self.e6 = Element.one(self.pairing, Zr);
181	self.failUnlessEqual(self.e5 == 0, True)
182	self.failUnlessEqual(self.e5 == 1, True)
183	self.failUnlessEqual(self.e6 == 0, False)
184	self.failUnlessEqual(self.e6 == 1, True)
185	self.e7 = Element.random(self.pairing, G2)
186	self.failUnlessEqual(self.e7 == 0, False)
187	self.failUnlessEqual(self.e7 == 1, False)
188	try:
189	self.e5 < self.e6
190	self.fail()
191	self.e5 > self.e6
192	self.fail()
193	except: pass
194
195	def test_neg(self):
196	self.e1 = Element.random(self.pairing, Zr)
197	self.e2 = -self.e1
198	try:
199	-Element.one(self.pairing, GT)
200	self.fail()
201	except: pass
202
203	def test_inv(self):
204	self.e1 = Element.random(self.pairing, Zr)
205	self.e2 = ~self.e1
206	try:
207	~Element.one(self.pairing, GT)
208	self.fail()
209	except: pass
210
211	def test_bls(self):
212	stored_params = """type a
213	q 8780710799663312522437781984754049815806883199414208211028653399266475630880222957078625179422662221423155858769582317459277713367317481324925129998224791
214	h 12016012264891146079388821366740534204802954401251311822919615131047207289359704531102844802183906537786776
215	r 730750818665451621361119245571504901405976559617
216	exp2 159
217	exp1 107
218	sign1 1
219	sign0 1
220	"""
221
222	# this is a test for the BLS short signature system
223	params = Parameters(param_string=stored_params)
224	pairing = Pairing(params)
225
226	# build the common parameter g
227	g = Element.random(pairing, G2)
228
229	# build the public and private keys
230	private_key = Element.random(pairing, Zr)
231	public_key = Element(pairing, G2, value=g**private_key)
232
233	# set the magic hash value
234	hash_value = Element.from_hash(pairing, G1, "hashofmessage")
235
236	# create the signature
237	signature = hash_value**private_key
238
239	# build the temps
240	temp1 = Element(pairing, GT)
241	temp2 = Element(pairing, GT)
242
243	# fill temp1
244	temp1 = pairing.apply(signature, g)
245
246	#fill temp2
247	temp2 = pairing.apply(hash_value, public_key)
248
249	# and again...
250	temp1 = pairing.apply(signature, g)
251
252	# compare
253	self.failUnlessEqual(temp1 == temp2, True)
254
255	# compare to random signature
256	rnd = Element.random(pairing, G1)
257	temp1 = pairing.apply(rnd, g)
258
259	# compare
260	self.failUnlessEqual(temp1 == temp2, False)
261
262	def test_auth(self):
263	# taken from paul miller's PBC::Crypt module tutorial
264	params = Parameters(qbits=512, rbits=160)
265	pairing = Pairing(params)
266	p = Element.random(pairing, G2)
267	s = Element.random(pairing, Zr)
268	public_key = p**s
269	# not actually from a hash. I don't really care.
270	Q_0 = Element.from_hash(pairing, G1, "node_id=22609")
271	# ditto
272	Q_1 = Element.from_hash(pairing, G1, "node_id=9073")
273	d_0 = Q_0**s
274	d_1 = Q_1**s
275	k_01_a = pairing.apply(Q_0, d_1)
276	k_01_b = pairing.apply(d_0, Q_1)
277	self.failUnlessEqual(k_01_a, k_01_b)
278	k_10_a = pairing.apply(Q_1, d_0)
279	k_10_b = pairing.apply(d_1, Q_0)
280	self.failUnlessEqual(k_10_a, k_10_b)
281
282
283	if __name__ == '__main__':
284	unittest.main()

Gitorious