path: root/go/main.go

package main

import "fmt"
import "./bls"
import "runtime"
import "time"

func verifyTrue(b bool) {
    if !b {
        fmt.Println("ERR")
    }
}
func testRecoverSecretKey() {
    fmt.Println("testRecoverSecretKey")
    k := 3000
    var sec bls.SecretKey
    sec.Init()
    fmt.Println("sec =", sec)

    // make master secret key
    msk := sec.GetMasterSecretKey(k)

    n := k
    secVec := make([]bls.SecretKey, n)
    idVec := make([]bls.Id, n)
    for i := 0; i < n; i++ {
        idVec[i].Set([]uint64{1, 2, 3, uint64(i)})
        secVec[i].Set(msk, &idVec[i])
    }
    // recover sec2 from secVec and idVec
    var sec2 bls.SecretKey
    sec2.Recover(secVec, idVec)
    fmt.Println("sec2=", sec2)
}

func testSign() {
    m := "testSign"
    fmt.Println(m)

    var sec0 bls.SecretKey
    sec0.Init()
    pub0 := sec0.GetPublicKey()
    s0 := sec0.Sign(m)
    verifyTrue(s0.Verify(pub0, m))

    k := 3
    msk := sec0.GetMasterSecretKey(k)
    mpk := bls.GetMasterPublicKey(msk)

    idTbl := []uint64{3, 5, 193, 22, 15}
    n := len(idTbl)

    secVec := make([]bls.SecretKey, n)
    pubVec := make([]bls.PublicKey, n)
    signVec := make([]bls.Sign, n)
    idVec := make([]bls.Id, n)

    for i := 0; i < n; i++ {
        idVec[i].Set([]uint64{idTbl[i], 0, 0, 0})
        fmt.Printf("idVec[%d]=%s\n", i, idVec[i].String())

        secVec[i].Set(msk, &idVec[i])

        pubVec[i].Set(mpk, &idVec[i])
        fmt.Printf("pubVec[%d]=%s\n", i, pubVec[i].String())

        verifyTrue(pubVec[i].String() == secVec[i].GetPublicKey().String())

        signVec[i] = *secVec[i].Sign(m)
        verifyTrue(signVec[i].Verify(&pubVec[i], m))
    }
    var sec1 bls.SecretKey
    sec1.Recover(secVec, idVec)
    verifyTrue(sec0.String() == sec1.String())
    var pub1 bls.PublicKey
    pub1.Recover(pubVec, idVec)
    verifyTrue(pub0.String() == pub1.String())
    var s1 bls.Sign
    s1.Recover(signVec, idVec)
    verifyTrue(s0.String() == s1.String())
}

func testAdd() {
    fmt.Println("testAdd")
    var sec1 bls.SecretKey
    var sec2 bls.SecretKey
    sec1.Init()
    sec2.Init()

    pub1 := sec1.GetPublicKey()
    pub2 := sec2.GetPublicKey()

    m := "test test"
    sign1 := sec1.Sign(m)
    sign2 := sec2.Sign(m)

    fmt.Println("sign1    :", sign1)
    sign1.Add(sign2)
    fmt.Println("sign1 add:", sign1)
    pub1.Add(pub2)
    verifyTrue(sign1.Verify(pub1, m))
}

func testPop() {
    fmt.Println("testPop")
    var sec bls.SecretKey
    sec.Init()
    pop := sec.GetPop()
    verifyTrue(pop.VerifyPop(sec.GetPublicKey()))
    sec.Init()
    verifyTrue(!pop.VerifyPop(sec.GetPublicKey()))
}
func main() {
    fmt.Println("init")
    bls.Init()
    {
        var id bls.Id
        id.Set([]uint64{4, 3, 2, 1})
        fmt.Println("id :", id)
        var id2 bls.Id
        id2.SetStr(id.String())
        fmt.Println("id2:", id2)
    }
    {
        var sec bls.SecretKey
        sec.SetArray([]uint64{1, 2, 3, 4})
        fmt.Println("sec=", sec)
    }

    fmt.Println("create secret key")
    m := "this is a bls sample for go"
    var sec bls.SecretKey
    sec.Init()
    fmt.Println("sec:", sec)
    fmt.Println("create public key")
    pub := sec.GetPublicKey()
    fmt.Println("pub:", pub)
    sign := sec.Sign(m)
    fmt.Println("sign:", sign)
    verifyTrue(sign.Verify(pub, m))

    // How to make array of SecretKey
    {
        sec := make([]bls.SecretKey, 3)
        for i := 0; i < len(sec); i++ {
            sec[i].Init()
            fmt.Println("sec=", sec[i].String())
        }
    }
    testRecoverSecretKey()
    testAdd()
    testSign()
    testPop()

    // put memory status
    runtime.GC()
    time.Sleep(2 * time.Second)
    var mem runtime.MemStats
    runtime.ReadMemStats(&mem)
    fmt.Println("mem=", mem)
}