refactoring bls.go

3 files changed, 183 insertions, 274 deletions

diff --git a/go/bls/bls.go b/go/bls/bls.go
index 41e0bc6..2812697 100644
--- a/go/bls/bls.go
+++ b/go/bls/bls.go
@@ -20,41 +20,9 @@ func Init(curve int) error {
 	return nil
 }
 
-// GetMaxOpUnitSize --
-func GetMaxOpUnitSize() int {
-	return int(C.MCLBN_FP_UNIT_SIZE)
-}
-
-// GetOpUnitSize --
-func GetOpUnitSize() int {
-	return int(C.blsGetOpUnitSize())
-}
-
-// GetCurveOrder --
-func GetCurveOrder() string {
-	buf := make([]byte, 1024)
-	// #nosec
-	n := C.blsGetCurveOrder((*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf)))
-	if n == 0 {
-		panic("implementation err. size of buf is small")
-	}
-	return string(buf[:n])
-}
-
-// GetFieldOrder --
-func GetFieldOrder() string {
-	buf := make([]byte, 1024)
-	// #nosec
-	n := C.blsGetFieldOrder((*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf)))
-	if n == 0 {
-		panic("implementation err. size of buf is small")
-	}
-	return string(buf[:n])
-}
-
 // ID --
 type ID struct {
-	v C.mclBnFr
+	v Fr
 }
 
 // getPointer --
@@ -65,77 +33,42 @@ func (id *ID) getPointer() (p *C.blsId) {
 
 // GetLittleEndian --
 func (id *ID) GetLittleEndian() []byte {
-	buf := make([]byte, 1024)
-	// #nosec
-	n := C.blsIdGetLittleEndian(unsafe.Pointer(&buf[0]), C.size_t(len(buf)), id.getPointer())
-	if n == 0 {
-		panic("err blsIdGetLittleEndian")
-	}
-	return buf[:n]
+	return id.v.Serialize()
 }
 
 // SetLittleEndian --
 func (id *ID) SetLittleEndian(buf []byte) error {
-	// #nosec
-	err := C.blsIdSetLittleEndian(id.getPointer(), unsafe.Pointer(&buf[0]), C.size_t(len(buf)))
-	if err != 0 {
-		return fmt.Errorf("err blsIdSetLittleEndian %x", err)
-	}
-	return nil
+	return id.v.SetLittleEndian(buf)
 }
 
 // GetHexString --
 func (id *ID) GetHexString() string {
-	buf := make([]byte, 1024)
-	// #nosec
-	n := C.blsIdGetHexStr((*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf)), id.getPointer())
-	if n == 0 {
-		panic("err blsIdGetHexStr")
-	}
-	return string(buf[:n])
+	return id.v.GetString(16)
 }
 
 // GetDecString --
 func (id *ID) GetDecString() string {
-	buf := make([]byte, 1024)
-	// #nosec
-	n := C.blsIdGetDecStr((*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf)), id.getPointer())
-	if n == 0 {
-		panic("err blsIdGetDecStr")
-	}
-	return string(buf[:n])
+	return id.v.GetString(10)
 }
 
 // SetHexString --
 func (id *ID) SetHexString(s string) error {
-	buf := []byte(s)
-	// #nosec
-	err := C.blsIdSetHexStr(id.getPointer(), (*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf)))
-	if err != 0 {
-		return fmt.Errorf("err blsIdSetHexStr %x", err)
-	}
-	return nil
+	return id.v.SetString(s, 16)
 }
 
 // SetDecString --
 func (id *ID) SetDecString(s string) error {
-	buf := []byte(s)
-	// #nosec
-	err := C.blsIdSetDecStr(id.getPointer(), (*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf)))
-	if err != 0 {
-		return fmt.Errorf("err blsIdSetDecStr %x", buf)
-	}
-	return nil
+	return id.v.SetString(s, 10)
 }
 
 // IsEqual --
 func (id *ID) IsEqual(rhs *ID) bool {
-	return C.blsIdIsEqual(id.getPointer(), rhs.getPointer()) == 1
+	return id.v.IsEqual(&rhs.v)
 }
 
 // SecretKey --
 type SecretKey struct {
-	v C.mclBnFr
+	v Fr
 }
 
 // getPointer --
@@ -146,82 +79,47 @@ func (sec *SecretKey) getPointer() (p *C.blsSecretKey) {
 
 // GetLittleEndian --
 func (sec *SecretKey) GetLittleEndian() []byte {
-	buf := make([]byte, 1024)
-	// #nosec
-	n := C.blsSecretKeyGetLittleEndian(unsafe.Pointer(&buf[0]), C.size_t(len(buf)), sec.getPointer())
-	if n == 0 {
-		panic("err blsSecretKeyGetLittleEndian")
-	}
-	return buf[:n]
+	return sec.v.Serialize()
 }
 
 // SetLittleEndian --
 func (sec *SecretKey) SetLittleEndian(buf []byte) error {
-	// #nosec
-	err := C.blsSecretKeySetLittleEndian(sec.getPointer(), unsafe.Pointer(&buf[0]), C.size_t(len(buf)))
-	if err != 0 {
-		return fmt.Errorf("err blsSecretKeySetLittleEndian %x", buf)
-	}
-	return nil
+	return sec.v.SetLittleEndian(buf)
 }
 
 // GetHexString --
 func (sec *SecretKey) GetHexString() string {
-	buf := make([]byte, 1024)
-	// #nosec
-	n := C.blsSecretKeyGetHexStr((*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf)), sec.getPointer())
-	if n == 0 {
-		panic("err blsSecretKeyGetHexStr")
-	}
-	return string(buf[:n])
+	return sec.v.GetString(16)
 }
 
 // GetDecString --
 func (sec *SecretKey) GetDecString() string {
-	buf := make([]byte, 1024)
-	// #nosec
-	n := C.blsSecretKeyGetDecStr((*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf)), sec.getPointer())
-	if n == 0 {
-		panic("err blsSecretKeyGetDecStr")
-	}
-	return string(buf[:n])
+	return sec.v.GetString(10)
 }
 
 // SetHexString --
 func (sec *SecretKey) SetHexString(s string) error {
-	buf := []byte(s)
-	// #nosec
-	err := C.blsSecretKeySetHexStr(sec.getPointer(), (*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf)))
-	if err != 0 {
-		return fmt.Errorf("erre blsSecretKeySetHexStr %s", s)
-	}
-	return nil
+	return sec.v.SetString(s, 16)
 }
 
 // SetDecString --
 func (sec *SecretKey) SetDecString(s string) error {
-	buf := []byte(s)
-	// #nosec
-	err := C.blsSecretKeySetDecStr(sec.getPointer(), (*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf)))
-	if err != 0 {
-		return fmt.Errorf("erre blsSecretKeySetDecStr %s", s)
-	}
-	return nil
+	return sec.v.SetString(s, 10)
 }
 
 // IsEqual --
 func (sec *SecretKey) IsEqual(rhs *SecretKey) bool {
-	return C.blsSecretKeyIsEqual(sec.getPointer(), rhs.getPointer()) == 1
+	return sec.v.IsEqual(&rhs.v)
 }
 
-// Init --
-func (sec *SecretKey) Init() {
-	C.blsSecretKeySetByCSPRNG(sec.getPointer())
+// SetByCSPRNG --
+func (sec *SecretKey) SetByCSPRNG() {
+	sec.v.SetByCSPRNG()
 }
 
 // Add --
 func (sec *SecretKey) Add(rhs *SecretKey) {
-	C.blsSecretKeyAdd(sec.getPointer(), rhs.getPointer())
+	FrAdd(&sec.v, &sec.v, &rhs.v)
 }
 
 // GetMasterSecretKey --
@@ -229,7 +127,7 @@ func (sec *SecretKey) GetMasterSecretKey(k int) (msk []SecretKey) {
 	msk = make([]SecretKey, k)
 	msk[0] = *sec
 	for i := 1; i < k; i++ {
-		msk[i].Init()
+		msk[i].SetByCSPRNG()
 	}
 	return msk
 }
@@ -246,20 +144,14 @@ func GetMasterPublicKey(msk []SecretKey) (mpk []PublicKey) {
 
 // Set --
 func (sec *SecretKey) Set(msk []SecretKey, id *ID) error {
-	err := C.blsSecretKeyShare(sec.getPointer(), msk[0].getPointer(), C.size_t(len(msk)), id.getPointer())
-	if err != 0 {
-		return fmt.Errorf("err blsSecretKeyShare id %s", id.GetHexString())
-	}
-	return nil
+	// #nosec
+	return FrEvaluatePolynomial(&sec.v, *(*[]Fr)(unsafe.Pointer(&msk)), &id.v)
 }
 
 // Recover --
 func (sec *SecretKey) Recover(secVec []SecretKey, idVec []ID) error {
-	err := C.blsSecretKeyRecover(sec.getPointer(), secVec[0].getPointer(), idVec[0].getPointer(), C.size_t(len(secVec)))
-	if err != 0 {
-		return fmt.Errorf("SecretKey.Recover")
-	}
-	return nil
+	// #nosec
+	return FrLagrangeInterpolation(&sec.v, *(*[]Fr)(unsafe.Pointer(&idVec)), *(*[]Fr)(unsafe.Pointer(&secVec)))
 }
 
 // GetPop --
@@ -271,7 +163,7 @@ func (sec *SecretKey) GetPop() (sign *Sign) {
 
 // PublicKey --
 type PublicKey struct {
-	v C.mclBnG2
+	v G2
 }
 
 // getPointer --
@@ -282,78 +174,49 @@ func (pub *PublicKey) getPointer() (p *C.blsPublicKey) {
 
 // Serialize --
 func (pub *PublicKey) Serialize() []byte {
-	buf := make([]byte, 1024)
-	// #nosec
-	n := C.blsPublicKeySerialize(unsafe.Pointer(&buf[0]), C.size_t(len(buf)), pub.getPointer())
-	if n == 0 {
-		panic("err blsPublicKeySerialize")
-	}
-	return buf[:n]
+	return pub.v.Serialize()
 }
 
 // Deserialize --
 func (pub *PublicKey) Deserialize(buf []byte) error {
-	// #nosec
-	err := C.blsPublicKeyDeserialize(pub.getPointer(), unsafe.Pointer(&buf[0]), C.size_t(len(buf)))
-	if err != 0 {
-		return fmt.Errorf("err blsPublicKeyDeserialize %x", buf)
-	}
-	return nil
+	return pub.v.Deserialize(buf)
 }
 
 // GetHexString --
 func (pub *PublicKey) GetHexString() string {
-	buf := make([]byte, 1024)
-	// #nosec
-	n := C.blsPublicKeyGetHexStr((*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf)), pub.getPointer())
-	if n == 0 {
-		panic("err blsPublicKeyGetHexStr")
-	}
-	return string(buf[:n])
+	return pub.v.GetString(16)
 }
 
 // SetHexString --
 func (pub *PublicKey) SetHexString(s string) error {
-	buf := []byte(s)
-	// #nosec
-	err := C.blsPublicKeySetHexStr(pub.getPointer(), (*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf)))
-	if err != 0 {
-		return fmt.Errorf("err blsPublicKeySetHexStr %x", buf)
-	}
-	return nil
+	return pub.v.SetString(s, 16)
 }
 
 // IsEqual --
 func (pub *PublicKey) IsEqual(rhs *PublicKey) bool {
-	return C.blsPublicKeyIsEqual(pub.getPointer(), rhs.getPointer()) == 1
+	return pub.v.IsEqual(&rhs.v)
 }
 
 // Add --
 func (pub *PublicKey) Add(rhs *PublicKey) {
-	C.blsPublicKeyAdd(pub.getPointer(), rhs.getPointer())
+	G2Add(&pub.v, &pub.v, &rhs.v)
 }
 
 // Set --
 func (pub *PublicKey) Set(mpk []PublicKey, id *ID) error {
-	err := C.blsPublicKeyShare(pub.getPointer(), mpk[0].getPointer(), C.size_t(len(mpk)), id.getPointer())
-	if err != 0 {
-		return fmt.Errorf("PublicKey.set")
-	}
-	return nil
+	// #nosec
+	return G2EvaluatePolynomial(&pub.v, *(*[]G2)(unsafe.Pointer(&mpk)), &id.v)
 }
 
 // Recover --
 func (pub *PublicKey) Recover(pubVec []PublicKey, idVec []ID) error {
-	err := C.blsPublicKeyRecover(pub.getPointer(), pubVec[0].getPointer(), idVec[0].getPointer(), C.size_t(len(pubVec)))
-	if err != 0 {
-		return fmt.Errorf("PublicKey.Recover")
-	}
-	return nil
+	// #nosec
+	return G2LagrangeInterpolation(&pub.v, *(*[]Fr)(unsafe.Pointer(&idVec)), *(*[]G2)(unsafe.Pointer(&pubVec)))
 }
 
 // Sign  --
 type Sign struct {
-	v C.mclBnG1
+	v G1
 }
 
 // getPointer --
@@ -364,50 +227,27 @@ func (sign *Sign) getPointer() (p *C.blsSignature) {
 
 // Serialize --
 func (sign *Sign) Serialize() []byte {
-	buf := make([]byte, 1024)
-	// #nosec
-	n := C.blsSignatureSerialize(unsafe.Pointer(&buf[0]), C.size_t(len(buf)), sign.getPointer())
-	if n == 0 {
-		panic("err blsSignatureSerialize")
-	}
-	return buf[:n]
+	return sign.v.Serialize()
 }
 
 // Deserialize --
 func (sign *Sign) Deserialize(buf []byte) error {
-	// #nosec
-	err := C.blsSignatureDeserialize(sign.getPointer(), unsafe.Pointer(&buf[0]), C.size_t(len(buf)))
-	if err != 0 {
-		return fmt.Errorf("err blsSignatureDeserialize %x", buf)
-	}
-	return nil
+	return sign.v.Deserialize(buf)
 }
 
 // GetHexString --
 func (sign *Sign) GetHexString() string {
-	buf := make([]byte, 1024)
-	// #nosec
-	n := C.blsSignatureGetHexStr((*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf)), sign.getPointer())
-	if n == 0 {
-		panic("err blsSignatureGetHexStr")
-	}
-	return string(buf[:n])
+	return sign.v.GetString(16)
 }
 
 // SetHexString --
 func (sign *Sign) SetHexString(s string) error {
-	buf := []byte(s)
-	// #nosec
-	err := C.blsSignatureSetHexStr(sign.getPointer(), (*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf)))
-	if err != 0 {
-		return fmt.Errorf("err blsSignatureSetHexStr %x", buf)
-	}
-	return nil
+	return sign.v.SetString(s, 16)
 }
 
 // IsEqual --
 func (sign *Sign) IsEqual(rhs *Sign) bool {
-	return C.blsSignatureIsEqual(sign.getPointer(), rhs.getPointer()) == 1
+	return sign.v.IsEqual(&rhs.v)
 }
 
 // GetPublicKey --
@@ -433,11 +273,8 @@ func (sign *Sign) Add(rhs *Sign) {
 
 // Recover --
 func (sign *Sign) Recover(signVec []Sign, idVec []ID) error {
-	err := C.blsSignatureRecover(sign.getPointer(), signVec[0].getPointer(), idVec[0].getPointer(), C.size_t(len(signVec)))
-	if err != 0 {
-		return fmt.Errorf("Sign.Recover")
-	}
-	return nil
+	// #nosec
+	return G1LagrangeInterpolation(&sign.v, *(*[]Fr)(unsafe.Pointer(&idVec)), *(*[]G1)(unsafe.Pointer(&signVec)))
 }
 
 // Verify --
diff --git a/go/bls/bls_test.go b/go/bls/bls_test.go
index b88867c..31f7f8a 100644
--- a/go/bls/bls_test.go
+++ b/go/bls/bls_test.go
@@ -2,45 +2,10 @@ package bls
 
 import "testing"
 import "strconv"
-import "fmt"
 
 var unitN = 0
 
 // Tests (for Benchmarks see below)
-func testPairing(t *testing.T) {
-	var a, b, ab Fr
-	a.SetString("123", 10)
-	b.SetString("456", 10)
-	FrMul(&ab, &a, &b)
-	var P, aP G1
-	var Q, bQ G2
-	err := P.HashAndMapTo([]byte("this"))
-	if err != nil {
-		t.Error(err)
-		return
-	}
-	fmt.Printf("P=%s\n", P.GetString(16))
-	G1Mul(&aP, &P, &a)
-	fmt.Printf("aP=%s\n", aP.GetString(16))
-	err = Q.HashAndMapTo([]byte("that"))
-	if err != nil {
-		t.Error(err)
-		return
-	}
-	fmt.Printf("Q=%s\n", Q.GetString(16))
-	G2Mul(&bQ, &Q, &b)
-	fmt.Printf("bQ=%s\n", bQ.GetString(16))
-	var e1, e2 GT
-	Pairing(&e1, &P, &Q)
-	fmt.Printf("e1=%s\n", e1.GetString(16))
-	Pairing(&e2, &aP, &bQ)
-	fmt.Printf("e2=%s\n", e1.GetString(16))
-	GTPow(&e1, &e1, &ab)
-	fmt.Printf("e1=%s\n", e1.GetString(16))
-	if !e1.IsEqual(&e2) {
-		t.Errorf("not equal pairing\n%s\n%s", e1.GetString(16), e2.GetString(16))
-	}
-}
 
 func testPre(t *testing.T) {
 	t.Log("init")
@@ -79,7 +44,7 @@ func testPre(t *testing.T) {
 	t.Log("create secret key")
 	m := "this is a bls sample for go"
 	var sec SecretKey
-	sec.Init()
+	sec.SetByCSPRNG()
 	t.Log("sec:", sec.GetHexString())
 	t.Log("create public key")
 	pub := sec.GetPublicKey()
@@ -94,7 +59,7 @@ func testPre(t *testing.T) {
 	{
 		sec := make([]SecretKey, 3)
 		for i := 0; i < len(sec); i++ {
-			sec[i].Init()
+			sec[i].SetByCSPRNG()
 			t.Log("sec=", sec[i].GetHexString())
 		}
 	}
@@ -131,7 +96,7 @@ func testRecoverSecretKey(t *testing.T) {
 	t.Log("testRecoverSecretKey")
 	k := 3000
 	var sec SecretKey
-	sec.Init()
+	sec.SetByCSPRNG()
 	t.Logf("sec=%s\n", sec.GetHexString())
 
 	// make master secret key
@@ -205,7 +170,7 @@ func testSign(t *testing.T) {
 	t.Log(m)
 
 	var sec0 SecretKey
-	sec0.Init()
+	sec0.SetByCSPRNG()
 	pub0 := sec0.GetPublicKey()
 	s0 := sec0.Sign(m)
 	if !s0.Verify(pub0, m) {
@@ -247,8 +212,8 @@ func testAdd(t *testing.T) {
 	t.Log("testAdd")
 	var sec1 SecretKey
 	var sec2 SecretKey
-	sec1.Init()
-	sec2.Init()
+	sec1.SetByCSPRNG()
+	sec2.SetByCSPRNG()
 
 	pub1 := sec1.GetPublicKey()
 	pub2 := sec2.GetPublicKey()
@@ -269,12 +234,12 @@ func testAdd(t *testing.T) {
 func testPop(t *testing.T) {
 	t.Log("testPop")
 	var sec SecretKey
-	sec.Init()
+	sec.SetByCSPRNG()
 	pop := sec.GetPop()
 	if !pop.VerifyPop(sec.GetPublicKey()) {
 		t.Errorf("Valid Pop does not verify")
 	}
-	sec.Init()
+	sec.SetByCSPRNG()
 	if pop.VerifyPop(sec.GetPublicKey()) {
 		t.Errorf("Invalid Pop verifies")
 	}
@@ -283,7 +248,7 @@ func testPop(t *testing.T) {
 func testData(t *testing.T) {
 	t.Log("testData")
 	var sec1, sec2 SecretKey
-	sec1.Init()
+	sec1.SetByCSPRNG()
 	b := sec1.GetLittleEndian()
 	err := sec2.SetLittleEndian(b)
 	if err != nil {
@@ -384,7 +349,7 @@ func BenchmarkPubkeyFromSeckey(b *testing.B) {
 	}
 	var sec SecretKey
 	for n := 0; n < b.N; n++ {
-		sec.Init()
+		sec.SetByCSPRNG()
 		b.StartTimer()
 		sec.GetPublicKey()
 		b.StopTimer()
@@ -399,7 +364,7 @@ func BenchmarkSigning(b *testing.B) {
 	}
 	var sec SecretKey
 	for n := 0; n < b.N; n++ {
-		sec.Init()
+		sec.SetByCSPRNG()
 		b.StartTimer()
 		sec.Sign(strconv.Itoa(n))
 		b.StopTimer()
@@ -414,7 +379,7 @@ func BenchmarkValidation(b *testing.B) {
 	}
 	var sec SecretKey
 	for n := 0; n < b.N; n++ {
-		sec.Init()
+		sec.SetByCSPRNG()
 		pub := sec.GetPublicKey()
 		m := strconv.Itoa(n)
 		sig := sec.Sign(m)
@@ -431,7 +396,7 @@ func benchmarkDeriveSeckeyShare(k int, b *testing.B) {
 		b.Fatal(err)
 	}
 	var sec SecretKey
-	sec.Init()
+	sec.SetByCSPRNG()
 	msk := sec.GetMasterSecretKey(k)
 	var id ID
 	for n := 0; n < b.N; n++ {
@@ -461,7 +426,7 @@ func benchmarkRecoverSeckey(k int, b *testing.B) {
 		b.Fatal(err)
 	}
 	var sec SecretKey
-	sec.Init()
+	sec.SetByCSPRNG()
 	msk := sec.GetMasterSecretKey(k)
 
 	// derive n shares
@@ -502,7 +467,7 @@ func benchmarkRecoverSignature(k int, b *testing.B) {
 		b.Fatal(err)
 	}
 	var sec SecretKey
-	sec.Init()
+	sec.SetByCSPRNG()
 	msk := sec.GetMasterSecretKey(k)
 
 	// derive n shares
diff --git a/go/bls/mcl.go b/go/bls/mcl.go
index 58ccc37..0e3a09e 100644
--- a/go/bls/mcl.go
+++ b/go/bls/mcl.go
@@ -1,8 +1,9 @@
 package bls
 
 /*
-#cgo CFLAGS:-D"MCLBN_FP_UNIT_SIZE=6"
+#cgo CFLAGS:-DMCLBN_FP_UNIT_SIZE=6
 #include <mcl/bn.h>
+#include <bls/bls.h>
 */
 import "C"
 import "fmt"
@@ -17,7 +18,41 @@ const CurveFp382_1 = C.mclBn_CurveFp382_1
 // CurveFp382_2 -- 382 bit curve 2
 const CurveFp382_2 = C.mclBn_CurveFp382_2
 
-////////////////////////////////////////////////
+// GetMaxOpUnitSize --
+func GetMaxOpUnitSize() int {
+	return int(C.MCLBN_FP_UNIT_SIZE)
+}
+
+// GetOpUnitSize --
+// the length of Fr is GetOpUnitSize() * 8 bytes
+func GetOpUnitSize() int {
+	return int(C.mclBn_getOpUnitSize())
+}
+
+// GetCurveOrder --
+// return the order of G1
+func GetCurveOrder() string {
+	buf := make([]byte, 1024)
+	// #nosec
+	n := C.mclBn_getCurveOrder((*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf)))
+	if n == 0 {
+		panic("implementation err. size of buf is small")
+	}
+	return string(buf[:n])
+}
+
+// GetFieldOrder --
+// return the characteristic of the field where a curve is defined
+func GetFieldOrder() string {
+	buf := make([]byte, 1024)
+	// #nosec
+	n := C.mclBn_getFieldOrder((*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf)))
+	if n == 0 {
+		panic("implementation err. size of buf is small")
+	}
+	return string(buf[:n])
+}
+
 // Fr --
 type Fr struct {
 	v C.mclBnFr
@@ -35,7 +70,7 @@ func (x *Fr) Clear() {
 	C.mclBnFr_clear(x.getPointer())
 }
 
-// SetInt --
+// SetInt64 --
 func (x *Fr) SetInt64(v int64) {
 	// #nosec
 	C.mclBnFr_setInt(x.getPointer(), C.int64_t(v))
@@ -78,7 +113,7 @@ func (x *Fr) IsEqual(rhs *Fr) bool {
 }
 
 // IsZero --
-func (x *Fr) IsZero(rhs *Fr) bool {
+func (x *Fr) IsZero() bool {
 	return C.mclBnFr_isZero(x.getPointer()) == 1
 }
 
@@ -88,16 +123,16 @@ func (x *Fr) IsOne(rhs *Fr) bool {
 }
 
 // SetByCSPRNG --
-func (x *Fr) SetByCSPRNG() error {
+func (x *Fr) SetByCSPRNG() {
 	err := C.mclBnFr_setByCSPRNG(x.getPointer())
 	if err != 0 {
-		return fmt.Errorf("err mclBnFr_setByCSPRNG")
+		panic("err mclBnFr_setByCSPRNG")
 	}
-	return nil
 }
 
 // SetHashOf --
 func (x *Fr) SetHashOf(buf []byte) bool {
+	// #nosec
 	return C.mclBnFr_setHashOf(x.getPointer(), unsafe.Pointer(&buf[0]), C.size_t(len(buf))) == 1
 }
 
@@ -153,7 +188,6 @@ func FrDiv(out *Fr, x *Fr, y *Fr) {
 	C.mclBnFr_div(out.getPointer(), x.getPointer(), y.getPointer())
 }
 
-////////////////////////////////////////////
 // G1 --
 type G1 struct {
 	v C.mclBnG1
@@ -197,8 +231,8 @@ func (x *G1) IsEqual(rhs *G1) bool {
 	return C.mclBnG1_isEqual(x.getPointer(), rhs.getPointer()) == 1
 }
 
-// IsEqual --
-func (x *G1) IsZero(rhs *G1) bool {
+// IsZero --
+func (x *G1) IsZero() bool {
 	return C.mclBnG1_isZero(x.getPointer()) == 1
 }
 
@@ -259,7 +293,11 @@ func G1Mul(out *G1, x *G1, y *Fr) {
 	C.mclBnG1_mul(out.getPointer(), x.getPointer(), y.getPointer())
 }
 
-////////////////////////////////////////////
+// G1MulCT -- constant time (depending on bit lengh of y)
+func G1MulCT(out *G1, x *G1, y *Fr) {
+	C.mclBnG1_mulCT(out.getPointer(), x.getPointer(), y.getPointer())
+}
+
 // G2 --
 type G2 struct {
 	v C.mclBnG2
@@ -303,8 +341,8 @@ func (x *G2) IsEqual(rhs *G2) bool {
 	return C.mclBnG2_isEqual(x.getPointer(), rhs.getPointer()) == 1
 }
 
-// IsEqual --
-func (x *G2) IsZero(rhs *G2) bool {
+// IsZero --
+func (x *G2) IsZero() bool {
 	return C.mclBnG2_isZero(x.getPointer()) == 1
 }
 
@@ -350,7 +388,7 @@ func G2Dbl(out *G2, x *G2) {
 	C.mclBnG2_dbl(out.getPointer(), x.getPointer())
 }
 
-// G1Add --
+// G2Add --
 func G2Add(out *G2, x *G2, y *G2) {
 	C.mclBnG2_add(out.getPointer(), x.getPointer(), y.getPointer())
 }
@@ -365,7 +403,6 @@ func G2Mul(out *G2, x *G2, y *Fr) {
 	C.mclBnG2_mul(out.getPointer(), x.getPointer(), y.getPointer())
 }
 
-///////////////////////////////////////////////////////
 // GT --
 type GT struct {
 	v C.mclBnGT
@@ -410,7 +447,7 @@ func (x *GT) IsEqual(rhs *GT) bool {
 }
 
 // IsZero --
-func (x *GT) IsZero(rhs *GT) bool {
+func (x *GT) IsZero() bool {
 	return C.mclBnGT_isZero(x.getPointer()) == 1
 }
 
@@ -476,7 +513,6 @@ func GTPow(out *GT, x *GT, y *Fr) {
 	C.mclBnGT_pow(out.getPointer(), x.getPointer(), y.getPointer())
 }
 
-//////////////////////
 // Pairing --
 func Pairing(out *GT, x *G1, y *G2) {
 	C.mclBn_pairing(out.getPointer(), x.getPointer(), y.getPointer())
@@ -499,16 +535,87 @@ func GetUint64NumToPrecompute() int {
 
 // PrecomputeG2 --
 func PrecomputeG2(Qbuf []uint64, Q *G2) {
+	// #nosec
 	C.mclBn_precomputeG2((*C.uint64_t)(unsafe.Pointer(&Qbuf[0])), Q.getPointer())
 }
 
 // PrecomputedMillerLoop --
 func PrecomputedMillerLoop(out *GT, P *G1, Qbuf []uint64) {
+	// #nosec
 	C.mclBn_precomputedMillerLoop(out.getPointer(), P.getPointer(), (*C.uint64_t)(unsafe.Pointer(&Qbuf[0])))
 }
 
 // PrecomputedMillerLoop2 --
 func PrecomputedMillerLoop2(out *GT, P1 *G1, Q1buf []uint64, P2 *G1, Q2buf []uint64) {
+	// #nosec
 	C.mclBn_precomputedMillerLoop2(out.getPointer(), P1.getPointer(), (*C.uint64_t)(unsafe.Pointer(&Q1buf[0])), P1.getPointer(), (*C.uint64_t)(unsafe.Pointer(&Q1buf[0])))
 }
 
+// FrEvaluatePolynomial -- y = c[0] + c[1] * x + c[2] * x^2 + ...
+func FrEvaluatePolynomial(y *Fr, c []Fr, x *Fr) error {
+	// #nosec
+	err := C.mclBn_FrEvaluatePolynomial(y.getPointer(), (*C.mclBnFr)(unsafe.Pointer(&c[0])), (C.size_t)(len(c)), x.getPointer())
+	if err != 0 {
+		return fmt.Errorf("err mclBn_FrEvaluatePolynomial")
+	}
+	return nil
+}
+
+// G1EvaluatePolynomial -- y = c[0] + c[1] * x + c[2] * x^2 + ...
+func G1EvaluatePolynomial(y *G1, c []G1, x *Fr) error {
+	// #nosec
+	err := C.mclBn_G1EvaluatePolynomial(y.getPointer(), (*C.mclBnG1)(unsafe.Pointer(&c[0])), (C.size_t)(len(c)), x.getPointer())
+	if err != 0 {
+		return fmt.Errorf("err mclBn_G1EvaluatePolynomial")
+	}
+	return nil
+}
+
+// G2EvaluatePolynomial -- y = c[0] + c[1] * x + c[2] * x^2 + ...
+func G2EvaluatePolynomial(y *G2, c []G2, x *Fr) error {
+	// #nosec
+	err := C.mclBn_G2EvaluatePolynomial(y.getPointer(), (*C.mclBnG2)(unsafe.Pointer(&c[0])), (C.size_t)(len(c)), x.getPointer())
+	if err != 0 {
+		return fmt.Errorf("err mclBn_G2EvaluatePolynomial")
+	}
+	return nil
+}
+
+// FrLagrangeInterpolation --
+func FrLagrangeInterpolation(out *Fr, xVec []Fr, yVec []Fr) error {
+	if len(xVec) != len(yVec) {
+		return fmt.Errorf("err FrLagrangeInterpolation:bad size")
+	}
+	// #nosec
+	err := C.mclBn_FrLagrangeInterpolation(out.getPointer(), (*C.mclBnFr)(unsafe.Pointer(&xVec[0])), (*C.mclBnFr)(unsafe.Pointer(&yVec[0])), (C.size_t)(len(xVec)))
+	if err != 0 {
+		return fmt.Errorf("err FrLagrangeInterpolation")
+	}
+	return nil
+}
+
+// G1LagrangeInterpolation --
+func G1LagrangeInterpolation(out *G1, xVec []Fr, yVec []G1) error {
+	if len(xVec) != len(yVec) {
+		return fmt.Errorf("err G1LagrangeInterpolation:bad size")
+	}
+	// #nosec
+	err := C.mclBn_G1LagrangeInterpolation(out.getPointer(), (*C.mclBnFr)(unsafe.Pointer(&xVec[0])), (*C.mclBnG1)(unsafe.Pointer(&yVec[0])), (C.size_t)(len(xVec)))
+	if err != 0 {
+		return fmt.Errorf("err G1LagrangeInterpolation")
+	}
+	return nil
+}
+
+// G2LagrangeInterpolation --
+func G2LagrangeInterpolation(out *G2, xVec []Fr, yVec []G2) error {
+	if len(xVec) != len(yVec) {
+		return fmt.Errorf("err G2LagrangeInterpolation:bad size")
+	}
+	// #nosec
+	err := C.mclBn_G2LagrangeInterpolation(out.getPointer(), (*C.mclBnFr)(unsafe.Pointer(&xVec[0])), (*C.mclBnG2)(unsafe.Pointer(&yVec[0])), (C.size_t)(len(xVec)))
+	if err != 0 {
+		return fmt.Errorf("err G2LagrangeInterpolation")
+	}
+	return nil
+}