phase2: accept beacon as argument

The randomness package generates beacon once at init. This does not make
sense in the offline mode, where the application is ran multiple times.
Such approach will generate a different random value at each run, while
it must be the same at init and at extract-keys.

Change the approach. The extract-keys command now accepts a --beacon
argument. User is expect to pass the same beacon that was generated and
printed on the init command.

Signed-off-by: Wojciech Zmuda <[email protected]>

Author: wzmuda

README.md

@@ -51,6 +51,8 @@ see the [Constraints](#Constraints) section for more information.
 
 The output Phase 2 file can be used for later contributions.
 
+The command outputs a beacon value, which must then be passed as an argument to [`extract-keys`](#extract-keys).
+
 - `--r1cs` - The R1CS file generated from a Gnark circuit,
 - `--phase1` - The Phase 1 file,
 - `--phase2` - The output path for the Phase 2 file,
@@ -92,6 +94,7 @@ The output are binary files containing the keys.
 
 - `--r1cs` - The R1CS file generated from the Gnark circuit the ceremony is held for,
 - `--srscommons` - The circuit-independent components of the Groth16 SRS file generated on the [Phase 2 initialization](#init).
+- `--beacon` - The beacon value output by the [`init`](#init) command.
 - `--phase2` - A list of Phase 2 files to verify the contributions in the order they were created. Contributions are
                verified in pairs, so at least two files must be provided. This DOES NOT INCLUDE the original Phase 2.
                file generated on initialization.

cmd/init.go

@@ -8,25 +8,29 @@ import (
 	"github.com/urfave/cli/v3"
 
 	"github.com/reilabs/trusted-setup/phase2"
+	"github.com/reilabs/trusted-setup/randomness"
 )
 
 func Phase2Init(_ context.Context, cmd *cli.Command) error {
 	phase1FilePath := cmd.String("phase1")
 	r1csFilePath := cmd.String("r1cs")
 	outputPhase2FilePath := cmd.String("phase2")
 	outputSrsCommonsFilePath := cmd.String("srscommons")
+	beacon := randomness.GetBeacon()
 	log.Printf(
 		"Initializing Phase 2:\n"+
-			"\tLoad Phase 1 from:    %s\n"+
-			"\tLoad R1CS from:       %s\n"+
-			"\tStore Phase 2 to:     %s\n"+
-			"\tStore SRS commons to: %s\n",
-
-		phase1FilePath, r1csFilePath, outputPhase2FilePath, outputSrsCommonsFilePath,
+			"\tLoad Phase 1 from:                %s\n"+
+			"\tLoad R1CS from:                   %s\n"+
+			"\tStore Phase 2 to:                 %s\n"+
+			"\tStore SRS commons to:             %s\n"+
+			"\tBeacon (pass it to extract-keys): %x\n",
+		phase1FilePath, r1csFilePath, outputPhase2FilePath, outputSrsCommonsFilePath, beacon,
 	)
 	if phase1FilePath == "" || r1csFilePath == "" || outputPhase2FilePath == "" || outputSrsCommonsFilePath == "" {
 		return fmt.Errorf("one of the required file paths is empty")
 	}
 
-	return phase2.Init(phase1FilePath, r1csFilePath, outputPhase2FilePath, outputSrsCommonsFilePath)
+	return phase2.Init(
+		phase1FilePath, r1csFilePath, outputPhase2FilePath, outputSrsCommonsFilePath, beacon,
+	)
 }

cmd/verify.go

@@ -2,6 +2,7 @@ package cmd
 
 import (
 	"context"
+	"encoding/hex"
 	"fmt"
 	"log"
 
@@ -33,15 +34,20 @@ func Phase2ExtractKeys(_ context.Context, cmd *cli.Command) error {
 	phase2FilePaths := cmd.StringSlice("phase2")
 	pkFilePath := cmd.String("pk")
 	vkFilePath := cmd.String("vk")
+	beacon, err := hex.DecodeString(cmd.String("beacon"))
+	if err != nil {
+		return err
+	}
 	log.Printf(
 		"Verify multiple Phase 2 contributions:\n"+
 			"\tLoad R1CS from:         %s\n"+
-			"\tLoad SRS commons from:  %s\n"+
+			"\tLoad SRS commons from:  %s (beacon: %x)\n"+
 			"\tLoad Phase 2 from:      %s\n"+
 			"\tStore Proving Key to:   %s\n"+
 			"\tStore Verifying Key to: %s\n",
 		r1csFilePath,
 		srsCommonsFilePath,
+		beacon,
 		phase2FilePaths,
 		pkFilePath,
 		vkFilePath,
@@ -50,5 +56,5 @@ func Phase2ExtractKeys(_ context.Context, cmd *cli.Command) error {
 		return fmt.Errorf("one of the required file paths is empty")
 	}
 
-	return phase2.ExtractKeys(r1csFilePath, srsCommonsFilePath, phase2FilePaths, pkFilePath, vkFilePath)
+	return phase2.ExtractKeys(r1csFilePath, srsCommonsFilePath, phase2FilePaths, pkFilePath, vkFilePath, beacon)
 }

main.go

@@ -122,6 +122,11 @@ func main() {
 							" initialization",
 						Required: true,
 					},
+					&cli.StringFlag{
+						Name:     "beacon",
+						Usage:    "Random string generated on the Phase 2 initialization",
+						Required: true,
+					},
 					&cli.StringSliceFlag{
 						Name: "phase2",
 						Usage: "List of Phase 2 files to verify the contributions in the order they were\n" +

phase2/phase2.go

@@ -10,17 +10,18 @@ import (
 
 	"github.com/reilabs/trusted-setup/phase1"
 	"github.com/reilabs/trusted-setup/r1cs"
-	"github.com/reilabs/trusted-setup/randomness"
 )
 
 // Init initializes the multi-party computation Phase 2 object based on a serialized Phase 1 and R1CS objects.
 //
 // The input serialized Phase 1 object is given as phase1FilePath. The input serialized R1CS object is given as r1csFilePath.
-// The output Phase 2 object is written to outputPhase2FilePath.
+// The random value needed to generate SRS commons is given as beacon.
+//
+// The output Phase 2 object is written to outputPhase2FilePath, and the SRS commons file is written to outputSrsCommonsPath.
 //
 // Returns nil on success and error on failure.
 func Init(
-	phase1FilePath, r1csFilePath, outputPhase2FilePath, outputSrsCommonsPath string,
+	phase1FilePath, r1csFilePath, outputPhase2FilePath, outputSrsCommonsPath string, beacon []byte,
 ) error {
 	ccs, err := r1cs.FromFile(r1csFilePath)
 	if err != nil {
@@ -32,8 +33,8 @@ func Init(
 		return err
 	}
 
-	log.Printf("Generating SRS commons form Phase 1 (beacon: %x)", randomness.GetBeacon())
-	srsCommons := p1.Seal(randomness.GetBeacon())
+	log.Print("Generating SRS commons form Phase 1")
+	srsCommons := p1.Seal(beacon)
 	err = SrsCommonsToFile(srsCommons, outputSrsCommonsPath)
 	if err != nil {
 		return err
@@ -109,11 +110,15 @@ func Verify(phase2prevFilePath, phase2nextFilePath string) error {
 // The constraint system used for Phase 2 initialization and the SRS Commons object being the result if the initialization
 // must be provided in the form of file paths.
 //
+// The random value needed to extract keys from contributions is given as beacon. It must be the same value passed
+// to Init when generating SRS that is now being passed to ExtractKeys as srsCommonsFilePath.
+//
 // The output proving key is written to outputPkFilePath. The output verification key is written to outputVkFilePath.
 //
 // Returns nil on success and error on failure.
 func ExtractKeys(
 	r1csFilePath, srsCommonsFilePath string, phase2FilePaths []string, outputPkFilePath, outputVkFilePath string,
+	beacon []byte,
 ) error {
 	if len(phase2FilePaths) < 2 {
 		return fmt.Errorf("at least two phase 2 files must be provided")
@@ -137,8 +142,8 @@ func ExtractKeys(
 		phase2s = append(phase2s, &p2)
 	}
 
-	log.Printf("Verifying all Phase 2 contributions and generating Keys (beacon: %x)", randomness.GetBeacon())
-	pk, vk, err := mpcsetup.VerifyPhase2(ccs.(*cs.R1CS), &srsCommons, randomness.GetBeacon(), phase2s...)
+	log.Print("Verifying all Phase 2 contributions and generating Keys")
+	pk, vk, err := mpcsetup.VerifyPhase2(ccs.(*cs.R1CS), &srsCommons, beacon, phase2s...)
 	if err != nil {
 		return err
 	}

test/offline_ceremony_test.go

@@ -1,6 +1,7 @@
 package test
 
 import (
+	"bytes"
 	"log"
 	"os"
 	"path/filepath"
@@ -41,6 +42,8 @@ const r1csFileName = "test.r1cs"
 const pkFileName = "test.pk"
 const vkFileName = "test.vk"
 
+var beacon = bytes.Repeat([]byte{0x42}, 32)
+
 func setup() {
 	ccs, err := buildCcs()
 	if err != nil {
@@ -98,7 +101,7 @@ func testPtau(t *testing.T) {
 }
 
 func testInit(t *testing.T) {
-	assert.NoError(t, phase2.Init(phase1FileName, r1csFileName, phase2FileName, srsCommonsFileName))
+	assert.NoError(t, phase2.Init(phase1FileName, r1csFileName, phase2FileName, srsCommonsFileName, beacon))
 
 	p2, err := phase2.FromFile(phase2FileName)
 	assert.NoError(t, err)
@@ -155,7 +158,7 @@ func testExtractKeys(t *testing.T) {
 	assert.NoError(
 		t,
 		phase2.ExtractKeys(
-			r1csFileName, srsCommonsFileName, phase2Contributions[1:], pkFileName, vkFileName,
+			r1csFileName, srsCommonsFileName, phase2Contributions[1:], pkFileName, vkFileName, beacon,
 		),
 	)
 }