在golang中使用PBC密码库

1. 安装系统

    使用Ubuntu或Mint操作系统

  
    (1) GIT 和Go安装
    安装git    sudo apt-get install git
    安装golang

     从https://www.golangtc.com/download 下载go
     sudo tar -zxf go1.9.linux-amd64.tar.gz  -C  /usr/local

     vim ~/.profile
     在尾部增加以下行：
     export GOROOT=/usr/local/go
     export GOPATH=/home/xxx/go
     export GOBIN=/home/xxx/gobin
     export PATH=$PATH:$GOROOT/bin:$GOBIN:$GOPATH

     执行下面命令，使其当下生效
    source ~/.profile
    echo $PATH  验证

    注：上面的xxx表示用户名

    (2) 下载PBC密码库并编译

    步骤：

    sudo apt-get install libgmp-dev

    sudo apt-get install build-essential flex bison

    到https://crypto.stanford.edu/pbc/download.html 下载 PBC Go Wrapper软件包

    把下载的软件包解压到某个目录，然后编译，步骤如下：

    ./configure
    make
    sudo make install

    安装好后，重新建立搜索库路径

    sudo ldconfig

    (3) Liteide安装
    安装liteide方法
     $ git clone https://github.com/visualfc/liteide.git
     $ sudo apt-get update
     $ sudo apt-get install qt4-dev-tools libqt4-dev libqtcore4 libqtgui4 libqtwebkit-dev g++
     $ cd liteide/build
     $ ./update_pkg.sh
     $ QTDIR=/usr ./build_linux.sh

     ## Run it: ##
     $ cd ~/liteide/build/liteide/bin
     $ ./liteide

     安装完成。

2. 演示

    例1：

package main

import (   
    "fmt"
    "github.com/Nik-U/pbc"
)

func main() {
 // In a real application, generate this once and publish it
 params := pbc.GenerateA(160, 512)

 pairing := params.NewPairing()

 // Initialize group elements. pbc automatically handles garbage collection.
 g := pairing.NewG1()
 h := pairing.NewG2()
 x := pairing.NewGT()

 // Generate random group elements and pair them
 g.Rand()
 h.Rand()
 fmt.Printf("g = %s\n", g)
 fmt.Printf("h = %s\n", h)
 x.Pair(g, h)
 fmt.Printf("e(g,h) = %s\n", x)
}

输出结果

例2：

// This example computes and verifies a Boneh-Lynn-Shacham signature
// in a simulated conversation between Alice and Bob.

package main

import (
    "crypto/sha256"
    "fmt"

    "github.com/Nik-U/pbc"
)

// messageData represents a signed message sent over the network
type messageData struct {
    message   string
    signature []byte
}

// This example computes and verifies a Boneh-Lynn-Shacham signature in a
// simulated conversation between Alice and Bob.
func main() {
    // The authority generates system parameters
 // In a real application, generate this once and publish it
    params := pbc.GenerateA(160, 512)
 fmt.Println(params)
 
    pairing := params.NewPairing()// instantiates a  pairing
 

    g := pairing.NewG2().Rand()

   // The authority distributes params and g to Alice and Bob
    sharedParams := params.String()

   sharedG := g.Bytes()
   // Channel for messages. Normally this would be a network connection.
    messageChannel := make(chan *messageData)

    // Channel for public key distribution. This might be a secure out-of-band
    // channel or something like a web of trust. The public key only needs to
    // be transmitted and verified once. The best way to do this is beyond the
    // scope of this example.
    keyChannel := make(chan []byte)

    // Channel to wait until both simulations are done
    finished := make(chan bool)

    // Simulate the conversation participants
    go alice(sharedParams, sharedG, messageChannel, keyChannel, finished)
    go bob(sharedParams, sharedG, messageChannel, keyChannel, finished)

    // Wait for the communication to finish
    <-finished
    <-finished

}

// Alice generates a keypair and signs a message
func alice(sharedParams string, sharedG []byte, messageChannel chan *messageData, keyChannel chan []byte, finished chan bool) {
    // Alice loads the system parameters
    pairing, _ := pbc.NewPairingFromString(sharedParams) // loads pairing parameters from a string and instantiates a pairing
    g := pairing.NewG2().SetBytes(sharedG)

    // Generate keypair (x, g^x)
    privKey := pairing.NewZr().Rand()
    pubKey := pairing.NewG2().PowZn(g, privKey)

    // Send public key to Bob
    keyChannel <- pubKey.Bytes()

    // Some time later, sign a message, hashed to h, as h^x
    message := "some text to sign"
    h := pairing.NewG1().SetFromStringHash(message, sha256.New())
    signature := pairing.NewG2().PowZn(h, privKey)

    // Send the message and signature to Bob
    messageChannel <- &messageData{message: message, signature: signature.Bytes()}

    finished <- true
}

// Bob verifies a message received from Alice
func bob(sharedParams string, sharedG []byte, messageChannel chan *messageData, keyChannel chan []byte, finished chan bool) {
    // Bob loads the system parameters
    pairing, _ := pbc.NewPairingFromString(sharedParams)
    g := pairing.NewG2().SetBytes(sharedG)

    // Bob receives Alice's public key (and presumably verifies it manually)
    pubKey := pairing.NewG2().SetBytes(<-keyChannel)

    // Some time later, Bob receives a message to verify
    data := <-messageChannel
    signature := pairing.NewG1().SetBytes(data.signature)

    // To verify, Bob checks that e(h,g^x)=e(sig,g)
    h := pairing.NewG1().SetFromStringHash(data.message, sha256.New())
    temp1 := pairing.NewGT().Pair(h, pubKey)
    temp2 := pairing.NewGT().Pair(signature, g)
    if !temp1.Equals(temp2) {
        fmt.Println("*BUG* Signature check failed *BUG*")
    } else {
        fmt.Println("Signature verified correctly")
    }
    finished <- true
}