voprf

package main

import (
	"encoding/hex"

	"github.com/bytemare/voprf"
)

func main() {
	// We suppose the client sends this blinded element.
	blinded, _ := hex.DecodeString("7eaf3d7cbe43d54637274342ce53578b2aba836f297f4f07997a6e1dced1c058")

	// Set up a new server. A private key is automatically created if none is given.
	server, err := voprf.Ristretto255Sha512.Server(voprf.OPRF, nil)
	if err != nil {
		panic(err)
	}

	// The server evaluates the blinded input.
	evaluation, err := server.Evaluate(blinded, nil)
	if err != nil {
		panic(err)
	}

	// The server encodes the evaluation, and sends it to the client.
	_ = evaluation.Serialize()
}

Output:

package main

import (
	"encoding/hex"

	"github.com/bytemare/voprf"
)

func exchangeWithServer(blinded []byte, verifiable bool) []byte {
	var server *voprf.Server
	var err error
	privateKey, _ := hex.DecodeString("8132542d5ed08594e7522b5eac6bee38bab5868996c25a3fd2a7739be1856b04")

	if verifiable {
		server, err = voprf.Ristretto255Sha512.Server(voprf.VOPRF, privateKey)
		if err != nil {
			panic(err)
		}
	} else {
		server, err = voprf.Ristretto255Sha512.Server(voprf.OPRF, privateKey)
		if err != nil {
			panic(err)
		}
	}

	evaluation, err := server.Evaluate(blinded, nil)
	if err != nil {
		panic(err)
	}

	ev := evaluation.Serialize()

	return ev
}

func main() {
	ciphersuite := voprf.Ristretto255Sha512
	input := []byte("input")
	serverPubKey, _ := hex.DecodeString("066c39841db2ca3c2e83e251e71b619013674149692ca2ab41d1b33a1a4fff38")

	// Instantiate a new client with the preprocessed values.
	client, err := ciphersuite.Client(voprf.VOPRF, serverPubKey)
	if err != nil {
		panic(err)
	}

	// The client blinds the initial input, and sends this to the server.
	blinded := client.Blind(input, nil)

	// Exchange with the server is not covered here. The following call is to mock an exchange with a server.
	ev := exchangeWithServer(blinded, true)

	// The client needs to decode the evaluation to finalize the process.
	eval := new(voprf.Evaluation)
	if err := eval.Deserialize(ev); err != nil {
		panic(err)
	}

	// The client finalizes the protocol execution by reverting the blinding and hashing the protocol transcript.
	// If proof verification fails, an error is returned.
	output, err := client.Finalize(eval, nil)
	if output == nil || err != nil {
		panic(err)
	}
}

Output:

package main

import (
	"encoding/hex"

	"github.com/bytemare/voprf"
)

func main() {
	privateKey, _ := hex.DecodeString("8132542d5ed08594e7522b5eac6bee38bab5868996c25a3fd2a7739be1856b04")

	// We suppose the client sends this blinded element.
	blinded, _ := hex.DecodeString("7eaf3d7cbe43d54637274342ce53578b2aba836f297f4f07997a6e1dced1c058")

	// Set up a new server.
	server, err := voprf.Ristretto255Sha512.Server(voprf.VOPRF, privateKey)
	if err != nil {
		panic(err)
	}

	// The server evaluates the blinded input. Proofs are embedded in the evaluation.
	evaluation, err := server.Evaluate(blinded, nil)
	if err != nil {
		panic(err)
	}

	// The server encodes the evaluation, and sends it to the client.
	_ = evaluation.Serialize()
}

Output: