delphi

Jun 19, 2025

Changes in this version

type KeyPair

+ func (k *KeyPair) UnmarshalBinary(b []byte) error

+ func (k KeyPair) MarshalBinary() ([]byte, error)

+ func (k KeyPair) MarshalJSON() ([]byte, error)

Jun 13, 2025

Changes in this version

+ const KeySize

+ type KeyChain [2]KeyPair

+ func (k KeyChain) Bytes() []byte

+ func (kp KeyChain) IsZero() bool

type KeyPair

+ func (k *KeyPair) UnmarshalJSON(b []byte) error

+ func (k KeyPair) Encryption() key

+ func (k KeyPair) Equal(j KeyPair) bool

+ func (k KeyPair) From(b []byte) KeyPair

+ func (k KeyPair) MarshalJson() ([]byte, error)

+ func (k KeyPair) MarshalText() ([]byte, error)

+ func (k KeyPair) Signing() key

+ func (k KeyPair) ToHex() string

+ func (k KeyPair) ToInt64() int64

Jun 27, 2025

Changes in this version

+ const SubKeySize

type Key

+ func (k *Key) UnmarshalBinary(b []byte) error

+ func (k Key) MarshalBinary() ([]byte, error)

+ func (k Key) MarshalJSON() ([]byte, error)

type Message

+ func ComposeMessage(randy io.Reader, subj Subject, plainTxt []byte) *Message

type Peer

+ func NewPeer() Peer

+ func (p Peer) MarshalPEM() (pem.Block, error)

type Subject

+ func (subj Subject) Equals(str string) bool

+ func (subj Subject) String() string

Jun 11, 2025

Changes in this version

+ var ErrNoMsg = pear.Defer("no message")

+ var ErrNoValid = pear.Defer("no valid signature")

May 9, 2025

Changes in this version

+ var ErrInvalidMsg = pear.Defer("invalid message")

+ var ErrNoNonce = pear.Defer("zero value nonce")

+ var ErrNoSender = pear.Defer("no sender")

+ var ErrNoSign = pear.Defer("could not sign message")

type CryptOpts

+ AAD []byte

type Principal

+ func (p Principal) MarshalPEM() (pem.Block, error)

May 5, 2025

Changes in this version

+ const Keyspace

+ const Version

type KV

+ func (kv KV) Get(keyspace string, key string) string

+ func (kv KV) Set(keyspace string, key string, val string)

type Message

+ Eph []byte

+ RecipientKey Key

+ SenderKey Key

+ Sig []byte

type Nonce

+ func NonceFromBytes(b []byte) Nonce

+ type Peer = Key

+ func (p Peer) Nickname() string

type Principal

+ func (p *Principal) Assert(randy io.Reader) (*Message, error)

+ func (p *Principal) UnmarshalPEM(b pem.Block) error

+ func (p Principal) ComposeMessage(randy io.Reader, body []byte) *Message

+ func (p Principal) MarhsalPEM() (pem.Block, error)

+ func (p Principal) Nickname() string

+ type Subject string

+ const Assertion

+ const EncryptedMessage

+ const PlainMessage

+ const Privkey

+ const Pubkey

Mar 1, 2025

Changes in this version

type KV

+ func (kv *KV) UnmarshalBinary(b []byte) error

+ func (kv KV) LexicalOrder() iter.Seq2[string, string]

+ func (kv KV) MarshalBinary() ([]byte, error)

+ func (kv KV) MarshalJSON() ([]byte, error)

type Key

+ func (k *Key) UnmarshalJSON(b []byte) error

+ func (k Key) MarshalJson() ([]byte, error)

type Message

+ func (m *Message) Write(b []byte) (int, error)

Feb 10, 2025

Changes in this version

+ func NewKV() *omap.OrderedMap[string, string]

+ type KV = omap.OrderedMap[string, string]

type Key

+ func (k Key) MarshalText() ([]byte, error)

+ func (k Key) ToHex() string

+ func (k Key) ToInt64() int64

type Message

+ Subject string

+ func (m *Message) FromPEM(p pem.Block) error

+ func (m *Message) Read(b []byte) (int, error)

+ func (m *Message) RecipientEncryption() crypto.PublicKey

+ func (m *Message) SenderEncryption() crypto.PublicKey

+ func (m *Message) String() string

+ func (m *Message) ToPEM() pem.Block

+ func (msg *Message) Verify() bool

Dec 1, 2024

Changes in this version

+ type IPrincipal interface

+ PrivateKey func() Key

+ PublicKey func() Key

+ type Key [2]subKey

+ func KeyFromHex(str string) Key

+ func (k Key) Bytes() []byte

+ func (k Key) Encryption() subKey

+ func (k Key) Equal(j Key) bool

+ func (k Key) From(b []byte) Key

+ func (k Key) IsZero() bool

+ func (k Key) Signing() subKey

+ type KeyPair [2]Key

+ func (k KeyPair) Bytes() []byte

+ func (kp KeyPair) IsZero() bool

type Message

+ Headers *stablemap.StableMap[string, []byte]

+ Recipient Key

+ Sender Key

type Principal

+ func (Principal) From(b []byte) Principal

+ func (p *Principal) Decrypt(msg *Message, opts crypto.DecrypterOpts) error

+ func (p *Principal) Encrypt(randy io.Reader, msg *Message, opts any) error

+ func (p *Principal) Equal(p2 crypto.PublicKey) bool

+ func (p *Principal) MarshalBinary() ([]byte, error)

+ func (p *Principal) PrivateKey() Key

+ func (p *Principal) Public() crypto.PublicKey

+ func (p *Principal) PublicKey() Key

+ func (p *Principal) Sign(_ io.Reader, digest []byte, opts crypto.SignerOpts) ([]byte, error)

+ func (p *Principal) UnmarshalBinary(b []byte) error

+ func (p *Principal) Verify(delphiPubKey crypto.PublicKey, digest []byte, sig []byte) bool

Nov 2, 2024

Changes in this version

+ var ErrBadKey = errors.New("bad key")

+ func NewKey(randy io.Reader) key

+ func NewKeyPair(randy io.Reader) keyPair

+ func NewSubKey(randy io.Reader) subKey

+ type Decrypter interface

+ Decrypt func(*Message, ed25519.PrivateKey, crypto.DecrypterOpts) error

+ type EncrypterOpts = any

type Message

+ func (m *Message) Ephemeral() crypto.PublicKey

+ func (m *Message) MarshalBinary() ([]byte, error)

+ func (m *Message) Signatory() crypto.PublicKey

+ func (msg *Message) Encrypted() bool

+ func (msg *Message) Plain() bool

+ func (msg *Message) Valid() bool

type Nonce

+ func NewNonce(randy io.Reader) Nonce

+ func (nonce Nonce) Bytes() []byte

Oct 25, 2024

Changes in this version

+ var ErrDelphi = errors.New("delphi")

+ func KeyFromBytes(b []byte) key

type Message

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

+ func (msg *Message) IsEncrypted() bool

+ func (msg *Message) IsPlain() bool

+ func (msg *Message) IsValid() bool

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

+ type Nonce [NonceSize]byte

+ func (nonce Nonce) IsZero() bool

Oct 20, 2024

Changes in this version

+ const ByteSize

+ const GLOBAL_SALT

+ const NonceSize

+ 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)

+ func NewPrincipal(randy io.Reader) principal

+ type Certifier interface

+ type Cipherer interface

+ type CryptOpts struct

+ AAED []byte

+ Nonce []byte

+ type Encrypter interface

+ Encrypt func(msg []byte, recipient crypto.PublicKey, opts any) ([]byte, error)

+ type Message struct

+ CipherText []byte

+ EphemeralPublicKey []byte

+ From *ecdh.PublicKey

+ Metadata *stablemap.StableMap[string, any]

+ Nonce []byte

+ PlainText []byte

+ Signature []byte

+ To *ecdh.PublicKey

+ func NewMessage(plainTxt []byte) *Message

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

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

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

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

+ type Principal interface

+ type Verifier interface

+ Verify func(pub crypto.PublicKey, msg []byte, sig []byte) bool