PBC密码库安装及使用教程

tutu-hu

已于 2024-06-23 17:47:59 修改

阅读量2.2k

点赞数 17

分类专栏：密码学文章标签：密码学算法 c++

于 2024-06-17 22:40:06 首次发布

本文链接：https://blog.csdn.net/weixin_42700740/article/details/139609052

版权

密码学专栏收录该内容

6 篇文章 2 订阅

订阅专栏

1.PBC库介绍

PBC（Pairing-Based Cryptography Libarary）是实现双线性对运算的函数库，由Stanford大学Ben Lynn博士用C开发并开源的密码库。 PBC密码库为双线性对实现提供了接口，是基于双线性对密码体制研究的一个非常有用的辅助工具。
库的地址：http://crypto.stanford.edu/pbc/

2.PBC库安装

首先，在官网下载安装包，可以看到有多个不同的包，这里下载pbc-0.5.14.tar.gz，因为安装环境是在Linux平台。
在这里插入图片描述

linux下执行步骤如下：

wget https://crypto.stanford.edu/pbc/files/pbc-0.5.14.tar.gz
tar -zxvf pbc-0.5.14.tar.gz
./configure --prefix=$HOME/.local  
make  
make install

其中--prefix指定了PBC库要安装的目录，您也可以指定到自己喜欢的地方。如果一切正常，您应该会在$HOME/.local中看到新文件，包括include、lib和bin三个文件夹

3.PBC库使用

在需要用到PBC库的源代码包含头文件pbc/pbc.h即可。即#include <pbc/pbc.h>。可以看出pbc.h主要汇总了其他要包含的头文件：

#ifndef __PBC_H__
#define __PBC_H__

#include <stdarg.h>
#include <stdio.h>
#include <stdint.h> // for intptr_t
#include <stdlib.h>
#include <gmp.h>

#if defined (__cplusplus)
extern "C" {
#endif

#include "pbc_utils.h"
#include "pbc_field.h"
#include "pbc_param.h"
#include "pbc_pairing.h"
#include "pbc_curve.h"
#include "pbc_mnt.h"
#include "pbc_a1_param.h"
#include "pbc_a_param.h"
#include "pbc_d_param.h"
#include "pbc_e_param.h"
#include "pbc_f_param.h"
#include "pbc_g_param.h"
#include "pbc_i_param.h"
#include "pbc_random.h"
#include "pbc_memory.h"

#if defined (__cplusplus)
}  // extern "C"
#endif

#endif //__PBC_H__

编译的时候需要链接GMP库和PBC库。即在gcc或者g++命令上加入-lgmp -lpbc；如果使用Cmake构建代码，在CMakeLists.txt上加入link_libraries(gmp)以及link_libraries(pbc)。

test.cpp

#include "pbc.h"

int main(void)
{
   
    /* call PBC functions */
    return 0;
}

编译示例如下：

g++ -o test test.cpp -lgmp -lpbc -L/usr/local/lib/pbc

4.相关API

4.1 配对的初始化和释放

在pbc中，配对的类型为pairing_t，初始化前需要声明变量，如pairing_t pairing。

一般配对的初始化有三个函数：

int pairing_init_set_str（pairing_t pairing，const char * s）
int pairing_init_set_buf（pairing_t pairing，const char * s，size_t len）
void pairing_init_pbc_param(struct pairing_s *pairing, pbc_param_t p)

其中第一第二个函数直接从字符串读取，第三个使用pbc_param_t对象初始化。一般来说第一第二个比较常用。其中pairing为需要初始化的配对变量，s为字符串的参数，len为字符串的长度。
初始化的参数一般也不需要自己手写，在PBC库上已经集成了几个比较常用的配对参数。我们可以在PBC源码的param目录上找到。论文一般都是用Type A配对。我们可以复制param/a.param文件的内容在代码上进行初始化即可：
在这里插入图片描述

#define TYPEA_PARAMS \
"type a\n" \
"q 87807107996633125224377819847540498158068831994142082" \
"1102865339926647563088022295707862517942266222142315585" \
"8769582317459277713367317481324925129998224791\n" \
"h 12016012264891146079388821366740534204802954401251311" \
"822919615131047207289359704531102844802183906537786776\n" \
"r 730750818665451621361119245571504901405976559617\n" \
"exp2 159\n" \
"exp1 107\n" \
"sign1 1\n" \
"sign0 1\n"

pairing_t pairing;
pairing_init_set_buf(pairing, TYPEA_PARAMS, strlen(TYPEA_PARAMS));

也可以使用fopen()读取文件内容初始化：

pairing_t pairing;
char param[1024];
FILE* file = fopen("a.param", "r");
size_t count = fread(param, 1, 1024, file);
fclose(file);
if (!count) pbc_die("input error");
pairing_init_set_buf(pairing, param, count);

当不用这个配对的时候，需要调用void pairing_clear(pairing_t pairing)释放这个变量。

4.2 元素的初始化和释放

双线性映射 $G_1 \times G_2 \rightarrow G_T$ ，其涉及三个素数阶的循环群， $\mathrm{PBC}$ 中称它们为 $G_1 、 G_2$ 以及 $G_T$ 。它接收两个元素作为输入，一个来自 $G_1$ ，一个来自 $G_2$ 。输出的元素来自 $G_T$ 。如果配对是对称的，则 $G_1 = G_2$ 。
在pbc中，元素变量为element_t类型，初始化前需要声明：element_t e：执行配对运算前需要对元素进行初始化。初始化函数有以下几个：

void element_init_G1(element_t e, pairing_t pairing)
void element_init_G2(element_t e, pairing_t pairing)
void element_init_GT(element_t e, pairing_t pairing)

上面三个函数分别是对将变量 $\mathrm{e}$ 初始化为 $G_1 、 G_2$ 及 $G_T$ 的元素。

void element_init_Zr(element_t e, pairing_t pairing)

这个函数用于将变量 $\mathrm{e}$ 初始化为环 $Z_r$ 的元素，一般用于指数部分。

void element_init_same_as(element_t e, element_t e2)

这个函数将变量e初始化为和变量e2所处的代数结构的元素。即如果e2在 $G_2$ ，那么e也被初始化为 $G_2$ 的元素。

元素变量用完一定要记得使用void element_clear(element_t e)释放，否则会导致内存泄漏！

4.3 元素的赋值

对于元素e，如果想e=0，则调用element_set0（e）。
如果想e=1，则调用element_set1（e）。
如e=i，其中i为一个非负的长整型数(unsigned long int)，则调用element_set_si(e, i)。

4.4 哈希

如果我们需要将某个变量（一般都是字符串）Hash成群上的一个点，则调用void element_from_hash(element_t e, void *data, int len)函数转换即可，其中e为需要赋值的元素，data为变量地址，len为变量的长度。需要注意的是，传进来的数据需要强制转换成(void *)。如：

element_from_hash(h, (void*)"ABCDEF", 6);

4.5 元素的常用运算

加法 $\boldsymbol{n}=a+b:$ void element_add(element_t $n$, element_t a, element_t b)
减法 $n = a - b :$ void element_sub(element_t n, element_t a, element_t b)
乘法 $\boldsymbol{n}=a \times b$ : void element_mul(element_t n, element_t a, element_t b)
连加 $n=\underbrace{a+\cdots+a}_{\mathrm{z} 介}$ : void element_mul_si(element_t n, element_t a, signed long int z)
连加 $n=\underbrace{a+\cdots+a}_{\mathrm{z} \uparrow}$ : void element_mul_zn(element_t c, element_t a, element_t z)，注意这里的元素z 必须为整数mod环，即 $\in Z_n$ 。
除法 $n = a / b$ : void element_div(element_t n, element_t a, element_t b)
倒数 $n=\frac{1}{a}:$ void element_invert(element_t n, element_t a)

4.6 元素的幂运算

在官方文档有详细的介绍。我一般使用比较多的是void element_pow_zn(element_t x, element_t a, element_t n)，即计算 $x=a^n$ ，其中n必须要初始化为环 $Z_n$ ，即element_init_Zr(n, pairing)。

4.7 元素的比较

常用的为函数int element_cmp(element_t a, element_t b)，如果a=b ，则函数输出0，否则输出1。

4.8 从群中随机选取一个元素（常用）

对应的函数为void element_random(element_t e)。

4.9 配对的运算

如果要执行配对运算 $r = e (x, y)$ ，则调用函数 pairing_apply(r, x, y, pairing)。其中 $\mathrm{x}$ 必须为群 $G_1$ 的元素， $\mathrm{y}$ 必须为群 $G_2$ 的元素， $r$ 必须为群 $G_T$ 的元素。
如果出现多次相同 $G_1$ 元素的配对运算，可以通过预处理的手段解决，即声明一个pairing_pp_t 类型的变量，使用固定的 $G_1$ 元素初始化。如官方文档中的代码：

pairing_pp_t pp;
pairing_pp_init(pp, x, pairing); // x is some element of G1
pairing_pp_apply(r1, y1, pp); // r1 = e(x, y1)
pairing_pp_apply(r2, y2, pp); // r2 = e(x, y2)
pairing_pp_clear(pp); // not need pp anymore

另外，计算 $o u t = e (in 1, in 2)$ ，更常用的配对函数如下：

// 配对函数2
element_pairing(element_t out, element_t in1, element_t in2)  //Computes a pairing: 'out' = 'e'('in1', 'in2'),

4.10 小结

PBC库的元素变量的周期一般是“声明–>初始化–>赋值–>释放”。
element_t变量在函数中一般不直接作为返回值return回去，而是在参数中返回即可。
PBC库的调用过程比较繁琐，如果追求代码的简洁和可读性，可以参考使用PBC C++ Wrapper。

5.Some examples

6.PBC Wrapper/C++

可以看出，C语言源码的PBC lib的使用还是相当繁琐的，而且需要手动初始化和释放内存，代码设计不谨慎容易造成内存泄露。而C++封装的PBC Library在代码的可读性上有了不少的提升，而且不用手动调用API释放内存，使用PBC C++ Wrapper能避免不少的弯路。

6.1 PBC C++ Wrapper的安装

安装C++ Wrapper之前需要安装好上述C语言版的PBC Library。
使用git下载源码：git clone git://git-crysp.uwaterloo.ca/pbcwrapper。
进入目录pbcwrapper，在终端输入make编译C++ Wrapper。
编译后输入./Testing执行测试程序看看C++ Wrapper是否正常工作。

6.2 在代码中使用PBC C++ Wrapper

在PBC C++ Wrapper的安装中我们已经使用make将代码编译成了一个静态库libPBC.a，为了能让我们的代码调用这个C++ Wrapper，我们将目录pbcwrapper复制到我们代码所在目录上。
如果我们的项目使用cmake构建，在CMakeLists.txt文件上加入以下内容（需要根据自己的情况更改）：

cmake_minimum_required(VERSION 3.15)
project(pbc_test)  # 项目名，根据自己情况更改

# gmp和pbc是必须要链接上去的
link_libraries(gmp)
link_libraries(pbc)

# 引入pbcwrapper的头文件和静态库
include_directories(${PROJECT_SOURCE_DIR}/pbcwrapper)
link_directories(${PROJECT_SOURCE_DIR}/pbcwrapper)

set(CMAKE_CXX_STANDARD 14)

add_executable(pbc_test main.cpp)

# 静态链接，注意pbc_test是前面add_executable指定的，需要根据自己情况修改。
target_link_libraries(pbc_test PBC)

这样就可以在自己的代码上使用PBC C++ Wrapper了，我们可以用C++重新实现PBC Library官方文档上的示例程序（即BLS签名算法）。

#include "PBC.h" //包含pbcwrapper的头文件PBC.h

int main() {
    //初始化配对变量e
    char param[1024];
    FILE* file = fopen("a.param", "r");
    size_t count = fread(param, 1, 1024, file);
    fclose(file);
    if (!count) pbc_die("input error");
    Pairing e(param, count);

    G2 g(e);
    Zr secret_key(e);

    G2 public_key = g ^ secret_key; //指数运算
    G1 h(e, (void*)"ABCDEF", 6);
    G1 sig = h ^ secret_key;

    GT temp1 = e(sig, g); //配对运算
    GT temp2 = e(h, public_key);
    if (temp1 == temp2) {
        printf("signature verifies\n");
    } else {
        printf("signature does not verify\n");
    }
}

我们可以使用cmake构建代码看看代码能不能正确执行。如果不想要cmake，可以使用g++命令编译代码：g++ main.cpp -o main -lgmp -lpbc -lPBC -I ./pbcwrapper -L ./pbcwrapper。

从上面的代码可以看到，PBC C++ Wrapper有以下几个优点：
1. 不用调用element_init_G1(h, e)等代码来初始化元素，以及使用element_random(e)随机选取元素赋值给e，直接使用G1 h(e)直接完成了元素的定义、初始化、随机选取操作。
2.使用运算符重载等类的机制，使得元素的运算变得直观，比如G2 public_key = g ^ secret_key，在原来的C版本的PBC库需要写成以下的形式：

 element_t public_key;
 element_init_G2(public_key, e);
 element_pow_zn(public_key, g, secret_key);

可见，一行C++代码顶替了三行的C版本代码，使得代码的易读性变强了不少。

3.不用手动调用element_clear()释放变量的内存空间。由于所有的元素都是用使用类封装，一旦对象不再使用，析构函数会负责将元素的内存空间给释放掉，不用头疼内存管理的问题。

6.3 常用的API

因为PBC C++ Wrapper对PBC Library中许多API都进行封装，所以调用起来特别简单。

6.3.1 配对的定义和初始化

调用Pairing类的构造器构造即可。
分析源码我们可以看到构造函数有以下几个：

Pairing(const char * buf, size_t len);
Pairing(const char * buf);
Pairing(const string &buf);
Pairing(const FILE * buf);

可以看到，配对的初始化不仅支持使用C语言的字符串，也支持C++的字符串std::string，以及FILE指针变量。

6.3.2 元素的定义和初始化

元素初始化前需要完成配对的初始化。
我们以G1元素为例介绍元素的初始化：
G1元素的定义和初始化也是使用G1类的构造函数即可：

G1(const Pairing &e);
G1(const Pairing &e, bool identity);
G1(const Pairing &e, const unsigned char *data, unsigned short len, bool compressed = false, unsigned short base = 0);
G1(const Pairing &e, const void *data, unsigned short len);
G1(const G1 &h, bool identity=false):G(h,identity){}

在C++ Wrapper中，构造器一步就完成了元素的定义、初始化等操作，比PBC Library的调用要简洁的多。在第二个构造函数中，参数identity如果设置为true，则该元素设置为1，即调用了PBC Library的element_set1()；如果设置为false，则该元素为随机选取，即相当于调用了element_random()。
第三个构造器则类同于C语言版本的element_from_hash()函数。