pypbc双线性对库的使用

pypbc是python中使用双线性配对运算的库，在密码学中双线性对是经常使用到的运算。pypbc的安装请参照ubuntu 16.04安装pypbc库

pypbc中提供了Parameters、Pairing、Element三个类

• Parameters生成参数：由于是在椭圆曲线上生成的双线性对，PBC库提供了几种不同的曲线，pypbc一般取的是a类曲线，具体参照PBC Library Manual 0.5.14。无论哪种曲线需要一定的参数，Parameters就是用来生成这些参数的类。
• Pairing生成双线性对：以Parameters作为参数生成双线性对，用来计算平时所见的e(g,g)计算
• Element群元素操作：该类中包含了大部分的群元素生成、运算等函数

下面我们来详细看以下pypbc中的双线性对运算以及群上元素的操作函数

1、初始化双线性对

参照PBC Library Manual 0.5.14，a类曲线需要以下参数：

exp2, exp1, sign1, sign0, r:
r = 2^exp2 + sign1 * 2^exp1 + sign0 * 1 (Solinas prime)
q, h:
r * h = q + 1
q is a prime, h is a multiple of 12 (thus q = -1 mod 12)
1
2
3
4
5

初始化曲线参数有三种方式:

There are three basic ways to instantiate a Parameters object:
     |  Parameters(param_string=s) -> a set of parameters built according to s.
     |  Parameters(n=x, short=True/False) -> a type A1 or F curve.
     |  Parameters(qbits=q, rbits=r, short=True/False) -> type A or E curve.
1
2
3
4

• 方式1：直接自己设置所有参数进行初始化曲线

stored_params = """type a
q 8780710799663312522437781984754049815806883199414208211028653399266475630880222957078625179422662221423155858769582317459277713367317481324925129998224791
h 12016012264891146079388821366740534204802954401251311822919615131047207289359704531102844802183906537786776
r 730750818665451621361119245571504901405976559617
exp2 159
exp1 107
sign1 1
sign0 1
"""
params = Parameters(param_string=stored_params)	# type a
1
2
3
4
5
6
7
8
9
10

• 方式二：设置群的阶初始化曲线

q_1 = get_random_prime(60)  # 生成一个长度为60的随机素数
q_2 = get_random_prime(60)

#使用的是pbc中的a1_param参数
params = Parameters( n = q_1 * q_2 )
1
2
3
4
5

• 方式三：根据安全参数初始化曲线

qbits=512, rbits=160
params = Parameters(qbits=qbits, rbits=rbits)   #参数初始化
1
2

无论哪种方式最终生成的都是初始化曲线需要的参数，如下

>>> params = Parameters(qbits = 512, rbits = 160)
>>> type(params)
<class 'pypbc.Parameters'>
>>> params
type a
q 2175751064674581406099374097406645153442200188252257926859779680253818547440021425929299096470398592866791046130712029479491519205096196661340888563136531
h 2977418579767164718844528138842806996821652623620150121056657255882751262623191122533591407296172073629716
r 730750818665451459101842416358717970580269694977
exp2 159
exp1 59
sign1 1
sign0 1
1
2
3
4
5
6
7
8
9
10
11
12

2、生成双线性对

有了参数后就可以生成双线性对，如下：

>>> pairing = Pairing(params)
>>> type(pairing)
<class 'pypbc.Pairing'>
1
2
3

以上是使用pypbc库时必定要先执行的初始化语句，双线性对运算如下

# e(g,g)
pairing.apply(g,g)
1
2

那g又是哪儿来的呢，接下来就是pypbc中使用最多的类Element

3、群元素操作

Element类中包含大量群操作方法，使用上面生成的pairing可以生成三个群G1、G2、GT和整数群Zr，a类曲线形成的G1和G2是等价的，即对称群。

双线性对运算只能对椭圆曲线上的点进行配对，所以G1、G2、GT是点群，但是取出的元素却是一个数。这是因为输出一个点的时候会特别长，如，每个数都是512比特，那么一个点就是一千多比特，所以底层输出的时候使用的简化的输出方法，如，只输出x坐标，当使用这个点的时候再使用x计算或坐标。

在最后会给出help(Element)的所有内容，接下来我们一一介绍所有的函数，肯定有你需要的操作.

#初始化一个G1,G2,GT,Zr元素，如果value赋值则进行是运算
Element(pairing, G1||G2||GT||Zr, value=v) -> Element

#初始化一个G1||G2||GT||Zr中的元素并置为1
Element.one(pairing, G1||G2||GT||Zr) -> identity element for the given group.
#初始化一个G1||G2||GT||Zr中的元素并置为0
Element.zero(pairing, G1||G2||GT||Zr) -> identity element for the given group.

#从群中取一个随机数，并初始化一个元素，一般是取g的，也就是生成元。
Element.random(pairing, G1||G2||GT||Zr) -> random element of the given group.

#根据给定的值生成哈希函数，加密中用到哈希函数的时候，一般将哈希值转化为群上的值再进行运算
Element.from_hash(pairing, G1||G2||GT||Zr -> element whose value is determined by the given hash value.
1
2
3
4
5
6
7
8
9
10
11
12
13

各个函数的使用简单的举个例子

#从G2中取一个随机数，并初始化一个元素，一般是取g的，也就是生成元。
g = Element.random( pairing, G2 )

#初始化一个GT元素
a = Element(pairing, GT )
#初始化一个G2元素
b = Element( pairing, G2 )
#初始化一个Zr元素
c = Element( pairing, Zr )
#初始化一个GT中的元素并置为1
Element.one( pairing, GT )
#初始化一个Zr中的元素并置为0
Element.zero( pairing, Zr )

'''对群进行运算一般使用Element，而不是直接在数值上进行运算。（当然直接运算也可以）。其中pairing代表我们初始化的双线性对，G2代表返回值的类型，value=就是值等于多少，G2中的元素做底数，Zr中的元素做指数，其实也能使用b = g ** c是同样的效果，但下面这样写更加工整，看着更明白，减少出错。
'''
b = Element( pairing, G2, value = g ** c )   # b = g^c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

以下是对群元素的其他操作

 |  # 两个群元素相加，Element.__add__(g_1, g_2)，等价于g_1 + g_2
 |  __add__(self, value, /)
 |      Return self+value.
 |  # 判断是都相等,等价于g_1 == g_2
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  # 不常用
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  # 常用，群元素的除法，群元素是不能直接使用g_1/g_2的，想要相除，必须使用
 |  # Element.__ifloordiv__(g_1,g_2)
 |  __ifloordiv__(self, value, /)
 |      Return self//=value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  __int__(self, /)
 |      int(self)
 |
 |  # 常用，求self的逆元，有:
 |  # 将群元素转换为整数型，但只能对Zr群元素进行转换
 |	# Element.__invert__(g_1)* g_1 == Element.one(pairing,G1)	True
 |  __invert__(self, /)
 |      ~self
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  # 生成字符串
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  from_hash(...) from builtins.type
 |      Creates an Element from the given hash value.
 |  
 |  one(...) from builtins.type
 |      Creates an element representing the multiplicative identity for its group.
 |  
 |  random(...) from builtins.type
 |      Creates a random element from the given group.
 |  
 |  zero(...) from builtins.type
 |      Creates an element representing the additive identity for its group.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None
(END)

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