delphi

README

Go Delphi

Delphi provides primitives needed for Oracles to handle cryptic messages.

Documentation

Index

• Constants
• Variables
• func NewPrincipal(randy io.Reader) principal
• type Certifier
• type Cipherer
• type CryptOpts
• type Encrypter
• type Message
  • func NewMessage(plainTxt []byte) *Message
  • func (msg *Message) Decrypt(recipientPrivKey *ecdh.PrivateKey) error
  • func (msg *Message) Encrypt(randomness io.Reader) error
  • func (m *Message) MarhsalBinary() ([]byte, error)
  • func (m *Message) UnmarshalBinary(p []byte) error
• 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 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 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                 *ecdh.PublicKey
	From               *ecdh.PublicKey
	Metadata           *stablemap.StableMap[string, any] // additional authenticated data (AAD)
	EphemeralPublicKey []byte
	Nonce              []byte
	CipherText         []byte
	PlainText          []byte
	Signature          []byte
}

func NewMessage

func NewMessage(plainTxt []byte) *Message

func (*Message) Decrypt

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

func (*Message) Encrypt

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

func (*Message) MarhsalBinary

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

func (*Message) UnmarshalBinary

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

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, msg []byte, sig []byte) bool
}