delphi

README

Go Delphi

Delphi provides primitives needed for Oracles to handle cryptic messages.

Documentation

Index

• Constants
• Variables
• func KeyFromBytes(b []byte) key
• func NewPrincipal(randy io.Reader) *principal
• type Certifier
• type Cipherer
• type CryptOpts
• type Encrypter
• type Message
  • func NewMessage(randy io.Reader, plainTxt []byte) *Message
  • func (msg *Message) Decrypt(recipientPrivKey *ecdh.PrivateKey) error
  • func (msg *Message) Digest() ([]byte, error)
  • func (msg *Message) Encrypt(randomness io.Reader) error
  • func (msg *Message) IsEncrypted() bool
  • func (msg *Message) IsPlain() bool
  • func (msg *Message) IsValid() bool
  • func (m *Message) MarhsalBinary() ([]byte, error)
  • func (msg *Message) Sign(randy io.Reader, signer crypto.Signer) error
  • func (m *Message) UnmarshalBinary(p []byte) error
• type Nonce
  • func (nonce Nonce) IsZero() bool
• type Principal
• type Verifier

Constants

const ByteSize = 128

const GLOBAL_SALT = "oracle/v1"

const NonceSize = chacha20poly1305.NonceSize

Variables

var ErrDecryptionFailed = errors.New("decryption failed")

var ErrDelphi = errors.New("delphi")

var ErrEncryptionFailed = errors.New("encryption failed")

var ErrNoEphemeralKey = errors.New("no ephemeral key")

var ErrNotImplemented = errors.New("not implemented")

var UniversalNonce []byte = make([]byte, chacha20poly1305.NonceSize)

Functions

func KeyFromBytes

func KeyFromBytes(b []byte) key

func NewPrincipal

func NewPrincipal(randy io.Reader) *principal

Types

type Certifier

type Certifier interface {
	crypto.PrivateKey
	crypto.Signer
	Verifier
}

a Certifier can produce and verify signatures

type Cipherer

type Cipherer interface {
	crypto.PrivateKey
	Encrypter
	crypto.Decrypter
}

a Cipherer can encrypt and decrypt an [Envelope]

type CryptOpts

type CryptOpts struct {
	Nonce []byte
	AAED  []byte
}

type Encrypter

type Encrypter interface {
	Encrypt(msg []byte, recipient crypto.PublicKey, opts any) ([]byte, error)
}

type Message

type Message struct {
	To                 key
	From               key
	Metadata           *stablemap.StableMap[string, any] // additional authenticated data (AAD)
	EphemeralPublicKey []byte
	Nonce              Nonce
	CipherText         []byte
	PlainText          []byte
	Signature          []byte
}

func NewMessage

func NewMessage(randy io.Reader, plainTxt []byte) *Message

func (*Message) Decrypt

func (msg *Message) Decrypt(recipientPrivKey *ecdh.PrivateKey) error

func (*Message) Digest

func (msg *Message) Digest() ([]byte, error)

func (*Message) Encrypt

func (msg *Message) Encrypt(randomness io.Reader) error

func (*Message) IsEncrypted

func (msg *Message) IsEncrypted() bool

func (*Message) IsPlain

func (msg *Message) IsPlain() bool

func (*Message) IsValid

func (msg *Message) IsValid() bool

func (*Message) MarhsalBinary

func (m *Message) MarhsalBinary() ([]byte, error)

func (*Message) Sign

func (msg *Message) Sign(randy io.Reader, signer crypto.Signer) error

func (*Message) UnmarshalBinary

func (m *Message) UnmarshalBinary(p []byte) error

type Nonce

type Nonce [NonceSize]byte

func (Nonce) IsZero

func (nonce Nonce) IsZero() bool

type Principal

type Principal interface {
	Cipherer
	Certifier
	encoding.BinaryMarshaler
	encoding.BinaryUnmarshaler
}

a Principal is a holder of a public/private key-pair that can perform encryption, decryption, signing, and verifying operations.

type Verifier

type Verifier interface {
	Verify(pub crypto.PublicKey, digest []byte, sig []byte) bool
}