crypto

type AlgorithmSupport int

type ContentAlgorithmInfo struct {
	Name      string
	Support   AlgorithmSupport
	KeySize   int // Required key size in bytes
	NonceSize int // Required nonce size in bytes
	TagSize   int // Authentication tag size in bytes
}

type ContentEncryptor interface {
	// Encrypt encrypts plaintext with AAD, generating a random nonce
	Encrypt(plaintext, aad []byte) ([]byte, error)

	// EncryptWithNonce encrypts plaintext with a specific nonce
	EncryptWithNonce(nonce, plaintext, aad []byte) ([]byte, error)

	// Decrypt decrypts ciphertext (with prepended nonce) using AAD
	Decrypt(ciphertext, aad []byte) ([]byte, error)

	// DecryptWithNonce decrypts ciphertext with a specific nonce
	DecryptWithNonce(nonce, ciphertext, aad []byte) ([]byte, error)

	// KeySize returns the required key size in bytes
	KeySize() int

	// NonceSize returns the required nonce size in bytes
	NonceSize() int

	// Overhead returns the authentication tag overhead
	Overhead() int
}

type ECDH1PUKeyAgreement struct {
	// SenderPrivateKey is the sender's static private key
	SenderPrivateKey jwk.Key

	// RecipientPublicKey is the recipient's static public key
	RecipientPublicKey jwk.Key

	// EphemeralPrivateKey is the sender's ephemeral private key (generated per message)
	EphemeralPrivateKey jwk.Key

	// Algorithm is the key wrapping algorithm (e.g., "ECDH-1PU+A256KW")
	Algorithm string

	// ContentEncryption is the content encryption algorithm (e.g., "A256CBC-HS512")
	ContentEncryption string

	// APU is Agreement PartyU Info (sender identifier, typically base64url-encoded DID)
	APU []byte

	// APV is Agreement PartyV Info (recipient identifier)
	APV []byte

	// CCTag is the content ciphertext authentication tag (used in ECDH-1PU KDF per draft-madden-jose-ecdh-1pu)
	// This binds the key derivation to the specific ciphertext, providing key commitment.
	CCTag []byte
}

type EncryptedMessage struct {
	// Protected is the base64url-encoded protected header
	Protected string `json:"protected"`

	// Recipients contains per-recipient encrypted key material
	Recipients []Recipient `json:"recipients"`

	// IV is the initialization vector (base64url-encoded)
	IV string `json:"iv"`

	// Ciphertext is the encrypted content (base64url-encoded)
	Ciphertext string `json:"ciphertext"`

	// Tag is the authentication tag (base64url-encoded)
	Tag string `json:"tag"`

	// AAD is additional authenticated data (base64url-encoded), optional
	AAD string `json:"aad,omitempty"`
}

type EncryptionOptions struct {
	// Algorithm is the key agreement algorithm. Default: ECDH-ES (anoncrypt)
	Algorithm string

	// Encryption is the content encryption algorithm. Default: A256GCM
	Encryption string

	// SenderKey is the sender's private key (required for ECDH-1PU authcrypt)
	SenderKey jwk.Key

	// SenderDID is the sender's DID (for APU)
	SenderDID string
}

type JWEHeader struct {
	// Algorithm is the key agreement algorithm (e.g., ECDH-ES, ECDH-1PU)
	Algorithm string `json:"alg"`

	// Encryption is the content encryption algorithm (e.g., A256GCM, A256CBC-HS512)
	Encryption string `json:"enc"`

	// Type is the media type of the JWE (should be "didcomm-encrypted+json")
	Type string `json:"typ,omitempty"`

	// SenderKeyID is the sender's key ID (for ECDH-1PU authcrypt)
	SenderKeyID string `json:"skid,omitempty"`

	// AgreementPartyUInfo is the APU for ECDH (base64url-encoded sender DID)
	AgreementPartyUInfo string `json:"apu,omitempty"`

	// AgreementPartyVInfo is the APV for ECDH (base64url-encoded recipient DIDs hash)
	AgreementPartyVInfo string `json:"apv,omitempty"`

	// EphemeralPublicKey is the ephemeral public key used for ECDH key agreement
	EphemeralPublicKey json.RawMessage `json:"epk,omitempty"`
}

type JWSHeader struct {
	// Algorithm is the signing algorithm (EdDSA, ES256, ES256K)
	Algorithm string `json:"alg"`

	// KeyID identifies the signing key
	KeyID string `json:"kid,omitempty"`

	// Type is the media type (should be "didcomm-signed+json")
	Type string `json:"typ,omitempty"`
}

type KeyAlgorithmInfo struct {
	Name              string
	Support           AlgorithmSupport
	RequiresSenderKey bool // Indicates if the algorithm requires a sender key (authcrypt)
}

type KeyResolver interface {
	ResolveKey(ctx context.Context, kid string) (jwk.Key, error)
}

type KeyStore interface {
	// GetPrivateKey retrieves a private key by key ID
	GetPrivateKey(ctx context.Context, kid string) (jwk.Key, error)

	// ListKeyIDs returns all available key IDs
	ListKeyIDs(ctx context.Context) ([]string, error)
}

type Recipient struct {
	// Header contains per-recipient unprotected header
	Header RecipientHeader `json:"header"`

	// EncryptedKey is the encrypted content encryption key (base64url-encoded)
	EncryptedKey string `json:"encrypted_key"`
}

type RecipientHeader struct {
	// KeyID identifies the recipient's key
	KeyID string `json:"kid"`

	// EphemeralPublicKey is the sender's ephemeral public key
	EphemeralPublicKey json.RawMessage `json:"epk,omitempty"`
}

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

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

type SignOptions struct {
	// Algorithm is the signing algorithm. If empty, inferred from key type.
	Algorithm string

	// Detached indicates whether to use detached payload
	Detached bool
}

type Signature struct {
	// Protected is the base64url-encoded protected header
	Protected string `json:"protected"`

	// Signature is the base64url-encoded signature value
	Signature string `json:"signature"`
}

type SignedMessage struct {
	// Payload is the base64url-encoded message
	Payload string `json:"payload"`

	// Signatures contains one or more signatures
	Signatures []Signature `json:"signatures"`
}

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