bn256_test.go

package bn256

import (
	"testing"

	"bytes"
	"crypto/rand"
)

func TestG1(t *testing.T) {
	k, Ga, err := RandomG1(rand.Reader)
	if err != nil {
		t.Fatal(err)
	}
	ma := Ga.Marshal()

	Gb := new(G1).ScalarBaseMult(k)
	mb := Gb.Marshal()

	if !bytes.Equal(ma, mb) {
		t.Fatal("bytes are different")
	}
}

func TestG1Marshal(t *testing.T) {
	_, Ga, err := RandomG1(rand.Reader)
	if err != nil {
		t.Fatal(err)
	}
	ma := Ga.Marshal()

	Gb := new(G1)
	_, err = Gb.Unmarshal(ma)
	if err != nil {
		t.Fatal(err)
	}
	mb := Gb.Marshal()

	if !bytes.Equal(ma, mb) {
		t.Fatal("bytes are different")
	}
}

func TestG1CorrectSubGroup(t *testing.T) {
	_, g1, _ := RandomG1(rand.Reader)

	if !g1.InCorrectSubgroup() {
		t.Fatal("it should be on group")
	}
}

func TestG1Infinity(t *testing.T) {
	_, g1, _ := RandomG1(rand.Reader)
	if g1.IsInfinity() {
		t.Fatal("not point at infinity")
	}

	// point at infinity
	g1.p.SetInfinity()

	if !g1.IsInfinity() {
		t.Fatal("point at infinity expected")
	}

	// point at infinity the bytes are 0
	for _, i := range g1.Marshal() {
		if i != 0 {
			t.Fatal("point at infinity marshal is not 0")
		}
	}

	g1 = new(G1)

	buf := make([]byte, 64)
	if _, err := g1.Unmarshal(buf); err != nil {
		t.Fatal("failed to decode zero point")
	}
	if !g1.IsInfinity() {
		t.Fatal("point at infinity expected")
	}
}

func TestG2(t *testing.T) {
	k, Ga, err := RandomG2(rand.Reader)
	if err != nil {
		t.Fatal(err)
	}
	ma := Ga.Marshal()

	Gb := new(G2).ScalarBaseMult(k)
	mb := Gb.Marshal()

	if !bytes.Equal(ma, mb) {
		t.Fatal("bytes are different")
	}
}

func TestG2Marshal(t *testing.T) {
	_, Ga, err := RandomG2(rand.Reader)
	if err != nil {
		t.Fatal(err)
	}
	ma := Ga.Marshal()

	Gb := new(G2)
	_, err = Gb.Unmarshal(ma)
	if err != nil {
		t.Fatal(err)
	}
	mb := Gb.Marshal()

	if !bytes.Equal(ma, mb) {
		t.Fatal("bytes are different")
	}
}

func TestG2CorrectSubGroup(t *testing.T) {
	_, g2, _ := RandomG2(rand.Reader)

	if !g2.InCorrectSubgroup() {
		t.Fatal("it should be on group")
	}
}

func TestG2Infinity(t *testing.T) {
	_, g2, _ := RandomG2(rand.Reader)
	if g2.IsInfinity() {
		t.Fatal("not point at infinity")
	}

	// point at infinity
	g2.p.SetInfinity()

	if !g2.IsInfinity() {
		t.Fatal("point at infinity expected")
	}

	// point at infinity the bytes are 0
	for _, i := range g2.Marshal() {
		if i != 0 {
			t.Fatal("point at infinity marshal is not 0")
		}
	}

	g2 = new(G2)

	buf := make([]byte, 128)
	if _, err := g2.Unmarshal(buf); err != nil {
		t.Fatal("failed to decode zero point")
	}
	if !g2.IsInfinity() {
		t.Fatal("point at infinity expected")
	}
}

func TestBilinearity(t *testing.T) {
	for i := 0; i < 2; i++ {
		a, p1, _ := RandomG1(rand.Reader)
		b, p2, _ := RandomG2(rand.Reader)
		e1 := Pair(p1, p2)

		e2 := Pair(&G1{curveGen}, &G2{twistGen})
		e2.ScalarMult(e2, a)
		e2.ScalarMult(e2, b)

		if *e1.p != *e2.p {
			t.Fatalf("bad pairing result: %s", e1)
		}
	}
}

func TestTripartiteDiffieHellman(t *testing.T) {
	a, _ := rand.Int(rand.Reader, Order)
	b, _ := rand.Int(rand.Reader, Order)
	c, _ := rand.Int(rand.Reader, Order)

	pa, pb, pc := new(G1), new(G1), new(G1)
	qa, qb, qc := new(G2), new(G2), new(G2)

	pa.Unmarshal(new(G1).ScalarBaseMult(a).Marshal())
	qa.Unmarshal(new(G2).ScalarBaseMult(a).Marshal())
	pb.Unmarshal(new(G1).ScalarBaseMult(b).Marshal())
	qb.Unmarshal(new(G2).ScalarBaseMult(b).Marshal())
	pc.Unmarshal(new(G1).ScalarBaseMult(c).Marshal())
	qc.Unmarshal(new(G2).ScalarBaseMult(c).Marshal())

	k1 := Pair(pb, qc)
	k1.ScalarMult(k1, a)
	k1Bytes := k1.Marshal()

	k2 := Pair(pc, qa)
	k2.ScalarMult(k2, b)
	k2Bytes := k2.Marshal()

	k3 := Pair(pa, qb)
	k3.ScalarMult(k3, c)
	k3Bytes := k3.Marshal()

	if !bytes.Equal(k1Bytes, k2Bytes) || !bytes.Equal(k2Bytes, k3Bytes) {
		t.Errorf("keys didn't agree")
	}
}

func BenchmarkG1(b *testing.B) {
	x, _ := rand.Int(rand.Reader, Order)
	b.ResetTimer()

	for i := 0; i < b.N; i++ {
		new(G1).ScalarBaseMult(x)
	}
}

func BenchmarkG2(b *testing.B) {
	x, _ := rand.Int(rand.Reader, Order)
	b.ResetTimer()

	for i := 0; i < b.N; i++ {
		new(G2).ScalarBaseMult(x)
	}
}

func BenchmarkGT(b *testing.B) {
	x, _ := rand.Int(rand.Reader, Order)
	b.ResetTimer()

	for i := 0; i < b.N; i++ {
		new(GT).ScalarBaseMult(x)
	}
}

func BenchmarkPairing(b *testing.B) {
	for i := 0; i < b.N; i++ {
		Pair(&G1{curveGen}, &G2{twistGen})
	}
}