compat

type CACertificate ¶

type CACertificate struct {
	BlindedA string
	BlindedB string
	R        string
	S        string
}

CACertificate represents an equivalent of pseudsys.CACert, but has string field types to overcome type restrictions of Go language binding tools.

func NewCACertificate(blindedA, blindedB, r, s string) *CACertificate

type CACertificateEC ¶

type CACertificateEC struct {
	BlindedA *ECGroupElement
	BlindedB *ECGroupElement
	R        string
	S        string
}

CACertificateEC represents an equivalent of pseudonymsys.CACertificateEC, but has field types compatible with Go language binding tools.

func NewCACertificateEC(bA, bB *ECGroupElement, r, s string) *CACertificateEC

type CLClient ¶

type CLClient struct {
	*cl.Client
}

func NewCLClient(conn *Connection) *CLClient

func (c *CLClient) GetPublicParams() (*CLPublicParams, error)

func (c *CLClient) IssueCred(cm *CLCredManager, regKey string) (*CLCred,
	error)

func (c *CLClient) ProveCred(cm *CLCredManager, cred *CLCred,
	revealed *CLRevealedAttrs) (string, error)

type CLCred ¶

type CLCred struct {
	*cl.Cred
}

func NewCLCred(bytes []byte) (*CLCred, error)

func (c *CLCred) Bytes() ([]byte, error)

type CLCredManager ¶

type CLCredManager struct {
	*cl.CredManager
}

func NewCLCredManager(params *CLParams, pk *CLPubKey,
	secret []byte, cred *CLRawCred) (*CLCredManager,
	error)

func RestoreCLCredManager(ctx *CLCredManagerContext, secret []byte,
	cred *CLRawCred) (*CLCredManager, error)

func (cm *CLCredManager) GetContext() *CLCredManagerContext

type CLCredManagerContext ¶

type CLCredManagerContext struct {
	*cl.CredManagerCtx
}

func NewCLCredManagerContext(bytes []byte) (*CLCredManagerContext, error)

func (c *CLCredManagerContext) Bytes() ([]byte, error)

type CLLongAttribute ¶

type CLLongAttribute struct {
	*cl.Int64Attr
}

type CLParams ¶

type CLParams struct {
	*clpb.Params
}

type CLPubKey ¶

type CLPubKey struct {
	*cl.PubKey
}

func (k *CLPubKey) GenerateMasterSecret() []byte

type CLPublicParams ¶

type CLPublicParams struct {
	PubKey  *CLPubKey
	Config  *CLParams
	RawCred *CLRawCred
}

type CLRawCred ¶

type CLRawCred struct {
	// contains filtered or unexported fields
}

func NewCLRawCred(bytes []byte) (*CLRawCred, error)

func (c *CLRawCred) Bytes() ([]byte, error)

func (c *CLRawCred) GetAttributeNames() []string

func (c *CLRawCred) SetLongAttribute(name string, val int64) error

func (c *CLRawCred) SetStringAttribute(name, val string) error

type CLRevealedAttrs ¶

type CLRevealedAttrs struct {
	// contains filtered or unexported fields
}

func NewCLRevealedAttrs() *CLRevealedAttrs

func (a *CLRevealedAttrs) Add(attr string)

type CLStringAttribute ¶

type CLStringAttribute struct {
	*cl.StrAttr
}

type Commitment ¶

type Commitment struct {
	// contains filtered or unexported fields
}

type Connection ¶

type Connection struct {
	*grpc.ClientConn
}

Connection wraps *grpc.ClientConn. A Connection should be constructed independently and then passed as an argument to protocol clients. Same Connection can be re-used for many clients.

func NewConnection(cfg *ConnectionConfig) (*Connection, error)

func (c *Connection) Close() error

type ConnectionConfig ¶

type ConnectionConfig struct {
	Endpoint           string // Server's Endpoint
	ServerNameOverride string
	CACertificate      []byte
	TimeoutMillis      int
}

ConnectionConfig wraps client.ConnectionConfig that holds connection information. Clients need to provide these information in order to establish connection to the server. For more details see documentation for the github.com/emmyzkp/emmy/client package.

func NewConnectionConfig(endpoint, serverNameOverride string,
	certificate []byte, timeout int) *ConnectionConfig

type Credential ¶

type Credential struct {
	SmallAToGamma string
	SmallBToGamma string
	AToGamma      string
	BToGamma      string
	T1            *Transcript
	T2            *Transcript
}

Credential represents an equivalent of pseudsys.CLCred, but has field types compatible with Go language binding tools.

func NewCredential(aToGamma, bToGamma, AToGamma, BToGamma string,
	t1, t2 *Transcript) *Credential

type CredentialEC ¶

type CredentialEC struct {
	SmallAToGamma *ECGroupElement
	SmallBToGamma *ECGroupElement
	AToGamma      *ECGroupElement
	BToGamma      *ECGroupElement
	T1            *TranscriptEC
	T2            *TranscriptEC
}

CredentialEC represents an equivalent of ecpseudsys.CLCred, but has field types compatible with Go language binding tools.

func NewCredentialEC(aToGamma, bToGamma, AToGamma, BToGamma *ECGroupElement,
	t1, t2 *TranscriptEC) *CredentialEC

type ECGroupElement ¶

type ECGroupElement struct {
	X string
	Y string
}

ECGroupElement represents an equivalent of ec.GroupElement, but has string field types to overcome type restrictions of Go language binding tools.

func NewECGroupElement(x, y string) *ECGroupElement

type Logger ¶

type Logger struct {
	*log.StdoutLogger
}

Logger wraps a concrete *log.StdoutLogger implementation. It can be constructed by the client application in order to override default logger provided by the client package.

func NewLogger(logLevel string) (*Logger, error)

type PedersenParams ¶

type PedersenParams struct {
	Group SchnorrGroup
	H     []byte
	// contains filtered or unexported fields
}

type Pseudonym ¶

type Pseudonym struct {
	A string
	B string
}

Pseudonym represents an equivalent of pseudsys.Nym, but has string field types to overcome type restrictions of Go language binding tools.

func NewPseudonym(a, b string) *Pseudonym

type PseudonymEC ¶

type PseudonymEC struct {
	A *ECGroupElement
	B *ECGroupElement
}

PseudonymEC represents an equivalent of pseudonymsys.PseudonymEC, but has field types compatible with Go language binding tools.

func NewPseudonymEC(a, b *ECGroupElement) *PseudonymEC

type PseudonymsysCAClient ¶

type PseudonymsysCAClient struct {
	*psys.CAClient
}

CAClient wraps around client.CAClient to conform to type restrictions of Go language binding tools. It exposes the same set of methods as client.CAClient.

func NewPseudonymsysCAClient(g *SchnorrGroup) (*PseudonymsysCAClient, error)

func (c *PseudonymsysCAClient) Connect(conn *Connection)

func (c *PseudonymsysCAClient) GenerateCertificate(userSecret string,
	nym *Pseudonym) (*CACertificate, error)

func (c *PseudonymsysCAClient) GenerateMasterNym(secret string) (*Pseudonym, error)

type PseudonymsysCAClientEC ¶

type PseudonymsysCAClientEC struct {
	*ecpsys.CAClient
}

PseudonymsysCAECClient wraps around client.CAClient to conform to type restrictions of Go language binding tools. It exposes the same set of methods as client.CAClient.

func NewPseudonymsysCAClientEC(curve int) *PseudonymsysCAClientEC

func (c *PseudonymsysCAClientEC) Connect(conn *Connection)

func (c *PseudonymsysCAClientEC) GenerateCertificate(userSecret string,
	nym *PseudonymEC) (*CACertificateEC, error)

func (c *PseudonymsysCAClientEC) GenerateMasterNym(secret string, curve int) (*PseudonymEC,
	error)

type PseudonymsysClient ¶

type PseudonymsysClient struct {
	*psys.Client
}

CLClient wraps around client.CLClient to conform to type restrictions of Go language binding tools. It exposes the same set of methods as client.CLClient.

func NewPseudonymsysClient(conn *Connection, g *SchnorrGroup) (*PseudonymsysClient, error)

func (c *PseudonymsysClient) GenerateMasterKey() string

func (c *PseudonymsysClient) GenerateNym(userSecret string,
	cert *CACertificate, regKey string) (*Pseudonym, error)

func (c *PseudonymsysClient) ObtainCredential(userSecret string,
	nym *Pseudonym, publicKey *PubKey) (*Credential, error)

func (c *PseudonymsysClient) TransferCredential(orgName, userSecret string,
	nym *Pseudonym, cred *Credential) (string, error)

type PseudonymsysClientEC ¶

type PseudonymsysClientEC struct {
	*ecpsys.Client
}

CLClient wraps around client.CLClient to conform to type restrictions of Go language binding tools. It exposes the same set of methods as client.CLClient.

func NewPseudonymsysClientEC(conn *Connection, curve int) (*PseudonymsysClientEC, error)

func (c *PseudonymsysClientEC) GenerateMasterKey() string

func (c *PseudonymsysClientEC) GenerateNym(userSecret string,
	cert *CACertificateEC, regKey string) (*PseudonymEC, error)

func (c *PseudonymsysClientEC) ObtainCredential(userSecret string,
	nym *PseudonymEC, publicKey *PubKeyEC) (*CredentialEC, error)

func (c *PseudonymsysClientEC) TransferCredential(orgName, userSecret string,
	nym *PseudonymEC, cred *CredentialEC) (string, error)

type PubKey ¶

type PubKey struct {
	H1 string
	H2 string
}

CLPubKey represents an equivalent of pseudsys.CLPubKey, but has string field types to overcome type restrictions of Go language binding tools.

func NewPubKey(h1, h2 string) *PubKey

type PubKeyEC ¶

type PubKeyEC struct {
	H1 *ECGroupElement
	H2 *ECGroupElement
}

PubKeyEC represents an equivalent of ecpseudsys.PubKeyEC, but has field types compatible with Go language binding tools.

func NewPubKeyEC(h1, h2 *ECGroupElement) *PubKeyEC

type SchnorrGroup ¶

type SchnorrGroup struct {
	P string
	G string
	Q string
}

SchnorrGroup represents an equivalent of schnorr.Group, but has string field types to overcome type restrictions of Go language binding tools.

func NewSchnorrGroup(p, g, q string) *SchnorrGroup

type ServiceInfo ¶

type ServiceInfo struct {
	Name        string
	Description string
	Provider    string
}

ServiceInfo holds information about the secure service provider and its service offering.

type Transcript ¶

type Transcript struct {
	A      string
	B      string
	Hash   string
	ZAlpha string
}

Transcript represents an equivalent of schnorr.BlindedTrans, but has string field types to overcome type restrictions of Go language binding tools.

func NewTranscript(a, b, hash, zAlpha string) *Transcript

type TranscriptEC ¶

type TranscriptEC struct {
	Alpha_1 string
	Alpha_2 string
	Beta_1  string
	Beta_2  string
	Hash    string
	ZAlpha  string
}

TranscriptEC represents an equivalent of ecschnorr.BlindedTrans, but has string field types to overcome type restrictions of Go language binding tools.

func NewTranscriptEC(alpha_1, alpha_2, beta_1, beta_2, hash, zAlpha string) *TranscriptEC