virgilcrypto

type CMSEnvelope struct {
	ContentType asn1.ObjectIdentifier
	Content     envelopedData `asn1:"tag:0,explicit"`
}

type Cipher interface {
	AddKeyRecipient(key *ed25519PublicKey) error
	AddPasswordRecipient(password []byte)
	Encrypt(data []byte) ([]byte, error)
	DecryptWithPassword(data []byte, password []byte) ([]byte, error)
	DecryptWithPrivateKey(data []byte, key *ed25519PrivateKey) ([]byte, error)
	EncryptStream(in io.Reader, out io.Writer) error
	DecryptStream(in io.Reader, out io.Writer, key *ed25519PrivateKey) error
	SignThenEncrypt(data []byte, signerKey *ed25519PrivateKey) ([]byte, error)
	DecryptThenVerify(data []byte, decryptionKey *ed25519PrivateKey, verifierPublicKeys ...*ed25519PublicKey) ([]byte, error)
}

type Crypto interface {
	SetKeyType(keyType KeyType) error
	GenerateKeypair() (Keypair, error)
	ImportPrivateKey(data []byte, password string) (PrivateKey, error)
	ImportPublicKey(data []byte) (PublicKey, error)
	ExportPrivateKey(key PrivateKey, password string) ([]byte, error)
	ExportPublicKey(key PublicKey) ([]byte, error)
	Encrypt(data []byte, recipients ...PublicKey) ([]byte, error)
	EncryptStream(in io.Reader, out io.Writer, recipients ...PublicKey) error
	Decrypt(data []byte, key PrivateKey) ([]byte, error)
	DecryptStream(in io.Reader, out io.Writer, key PrivateKey) error
	DecryptThenVerify(data []byte, privateKeyForDecryption PrivateKey, verifierKey ...PublicKey) ([]byte, error)
	Sign(data []byte, signer PrivateKey) ([]byte, error)
	SignStream(in io.Reader, signer PrivateKey) ([]byte, error)
	SignThenEncrypt(data []byte, signerKey PrivateKey, recipients ...PublicKey) ([]byte, error)
	//Verify must return non nil error if the result is false
	Verify(data []byte, signature []byte, key PublicKey) (bool, error)
	VerifyStream(in io.Reader, signature []byte, key PublicKey) (bool, error)
	CalculateFingerprint(data []byte) []byte
	ExtractPublicKey(key PrivateKey) (PublicKey, error)
}

type CryptoError string

type CustomParam struct {
	Key   string        `asn1:"utf8"`
	Value asn1.RawValue `asn1:"tag:2,explicit"`
}

type Envelope struct {
	Version      int
	Data         CMSEnvelope
	CustomParams []CustomParam `asn1:"set,explicit,optional"`
}

type KeyType int

type Keypair interface {
	HasPublic() bool
	HasPrivate() bool
	PublicKey() PublicKey
	PrivateKey() PrivateKey
}

type PFS interface {
	StartInitiatorSession(ICb, LTCb, OTCb PublicKey, ICa, EKa PrivateKey, aliceCardId, bobCardId string) (sess *PFSSession, err error)
	StartResponderSession(ICa, EKa PublicKey, ICb, LTCb, OTCb PrivateKey, aliceCardId, bobCardId string) (sess *PFSSession, err error)
}

type PFSSession struct {
	SK, AD, SessionID []byte
}

type PrivateKey interface {
	ReceiverID() []byte
	ExtractPublicKey() (PublicKey, error)
	Encode(password []byte) ([]byte, error)
	Empty() bool
}

type PublicKey interface {
	ReceiverID() []byte
	Encode() ([]byte, error)
	Empty() bool
}

type StructuralError struct {
	Msg string
}

type SyntaxError struct {
	Msg string
}

type VirgilChunkCipher interface {
	Encrypt(key, nonce, ad []byte, chunkSize int, in io.Reader, out io.Writer) error
	Decrypt(key, nonce, ad []byte, chunkSize int, in io.Reader, out io.Writer) error
}

type VirgilCrypto struct {
	Cipher func() Cipher
}

type VirgilHash interface {
	New() hash.Hash
	Sum(data []byte) []byte
}

type VirgilSigner interface {
	Sign(data []byte, signer PrivateKey) ([]byte, error)
	SignStream(data io.Reader, signer PrivateKey) ([]byte, error)
}

type VirgilStreamCipher interface {
	Encrypt(key, nonce, ad []byte, in io.Reader, out io.Writer) error
	Decrypt(key, nonce, ad []byte, in io.Reader, out io.Writer) error
}

type VirgilVerifier interface {
	Verify(data []byte, key PublicKey, signature []byte) (bool, error)
	VerifyStream(data io.Reader, key PublicKey, signature []byte) (bool, error)
}

type WrongPasswordError struct {
	CryptoError
}