tkn

type Attribute ¶

type Attribute struct {
	Value *pairing.Scalar
	// contains filtered or unexported fields
}

func (a *Attribute) Equal(b *Attribute) bool

type Attributes ¶

type Attributes map[string]Attribute

func (a *Attributes) Equal(b *Attributes) bool

type AttributesKey ¶

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

func DeriveAttributeKeysCCA(rand io.Reader, sp *SecretParams, attrs *Attributes) (*AttributesKey, error)

func (a *AttributesKey) Equal(b *AttributesKey) bool

func (a *AttributesKey) MarshalBinary() ([]byte, error)

func (a *AttributesKey) UnmarshalBinary(data []byte) error

type Formula ¶

type Formula struct {
	Gates []Gate
}

Formula represents a monotone boolean circuit with Inputs not repeated. The representation is as follows: for n Gates there n+1 input wires, 1 output Wire, and n-1 intermediate wires. That's because there are 2n Inputs to all Gates and n outputs since every Gate is 2:1.

The wires are conceptually in an array. Wires 0 through n are the input wires, and Wire 2n is the output Wire. If there are wires between n and 2n they are intermediate wires.

All intermediate and input wires must be used exactly once as Inputs.

func (f *Formula) Equal(g Formula) bool

func (f *Formula) MarshalBinary() ([]byte, error)

func (f *Formula) UnmarshalBinary(data []byte) error

type Gate ¶

type Gate struct {
	Class int // either Andgate or Orgate
	In0   int // numbering of wires
	In1   int
	Out   int
}

Gate is a Gate in a monotone boolean formula.

func (g Gate) Equal(g2 Gate) bool

type Policy ¶

type Policy struct {
	Inputs []Wire
	F      Formula // monotonic boolean formula
}

func (p *Policy) Equal(p2 *Policy) bool

func (p *Policy) ExtractFromCiphertext(ct []byte) error

func (p *Policy) MarshalBinary() ([]byte, error)

func (p *Policy) Satisfaction(attr *Attributes) (*Satisfaction, error)

func (p *Policy) String() string

func (p *Policy) UnmarshalBinary(data []byte) error

type PublicParams ¶

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

func (p *PublicParams) Equal(p2 *PublicParams) bool

func (p *PublicParams) MarshalBinary() ([]byte, error)

func (p *PublicParams) UnmarshalBinary(data []byte) error

type Satisfaction ¶

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

type SecretParams ¶

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

func (s *SecretParams) Equal(s2 *SecretParams) bool

func (s *SecretParams) MarshalBinary() ([]byte, error)

func (s *SecretParams) UnmarshalBinary(data []byte) error

type Wire ¶

type Wire struct {
	Label    string
	RawValue string
	Value    *pairing.Scalar
	Positive bool
}

func (w *Wire) Equal(w2 *Wire) bool

func (w *Wire) MarshalBinary() ([]byte, error)

func (w *Wire) String() string

func (w *Wire) UnmarshalBinary(data []byte) error