BN254 Pairings Inside Circuit

[shreyas-londhe]

Hi, I have been trying to get a BN254 pairing working inside the Groth16 SNARK by using the sw_bn254 and emulated packages in the develop branch. I'll put the code below to help you understand what I am doing.

Key Generation : pk = sk * g2Gen
Sign : sig = sk * hashToPoint(msg)
Verify : e(sig, g2Gen) = e(hashToPoint(msg), pk)

// main.go
var sig bn254.G1Affine
var hm bn254.G1Affine
var pkG2 bn254.G2Affine

_, _, _, g2Gen := bn254.Generators()

keyPair := utils.GeneratePubKeys()
msg := []byte("Hello World")
hashedMsgPt, signature := utils.BLSSign(msg, keyPair.PrivateKey)

sig.X.SetString(signature.X.String())
sig.Y.SetString(signature.Y.String())

hm.X.SetString(hashedMsgPt.X.String())
hm.Y.SetString(hashedMsgPt.Y.String())

pkG2.X.A0.SetString(keyPair.PublicKeyG2[0])
pkG2.X.A1.SetString(keyPair.PublicKeyG2[1])
pkG2.Y.A0.SetString(keyPair.PublicKeyG2[2])
pkG2.Y.A1.SetString(keyPair.PublicKeyG2[3])

res1, err := bn254.Pair([]bn254.G1Affine{sig}, []bn254.G2Affine{g2Gen})
HandleError(err)

res2, err := bn254.Pair([]bn254.G1Affine{hm}, []bn254.G2Affine{pkG2})
HandleError(err)

check := res1.Equal(&res2)
fmt.Println("Check:", check)

// utils.go
type BLSKeyPair struct {
	PrivateKey  string
	PublicKeyG1 []string
	PublicKeyG2 []string
}

func HandleError(err error) {
	if err != nil {
		panic(err)
	}
}

func GeneratePubKeys() BLSKeyPair {
	// generate a random secret key
	size := 32
	privKeyBytes := make([]byte, size)
	_, err := rand.Read(privKeyBytes)
	if err != nil {
		panic(err)
	}
	privKey := hex.EncodeToString(privKeyBytes)

	// generate public key in G1
	publicKeyG1 := generatePublicKeyG1(privKey)

	// generate public key in G2
	publicKeyG2 := generatePublicKeyG2(privKey)

	keyPair := BLSKeyPair{
		PrivateKey:  privKey,
		PublicKeyG1: []string{publicKeyG1.X.String(), publicKeyG1.Y.String()},
		PublicKeyG2: []string{publicKeyG2.X.A0.String(), publicKeyG2.X.A1.String(), publicKeyG2.Y.A0.String(), publicKeyG2.Y.A1.String()},
	}

	return keyPair
}

func generatePublicKeyG2(privKey string) bn254.G2Affine {
	var pubKeyG2 bn254.G2Affine
	var sk big.Int
	_, _, _, g2Gen := bn254.Generators()
	sk.SetString(privKey, 16)
	pubKeyG2.ScalarMultiplication(&g2Gen, &sk)

	return pubKeyG2
}

func BLSSign(msg []byte, privKey string) (*bn254.G1Affine, *bn254.G1Affine) {
	var hashedMsg []byte
	hashedMsgPt, err := bn254.HashToG1(msg, hashedMsg)
	HandleError(err)

	var sk big.Int
	sk.SetString(privKey, 16)

	sig := hashedMsgPt.ScalarMultiplication(&hashedMsgPt, &sk)

	return &hashedMsgPt, sig
}

But sadly the check is returning false, and I don't see where I am going wrong.

Thanks for reading!