crypt

type AlgorithmIdentifier struct {
	Algorithm  asn1.ObjectIdentifier
	Parameters asn1.RawValue `asn1:"optional"`
}

type AuthStatus int

type AuthenticatedData struct {
	Version          int
	RecipientInfos   []asn1.RawValue `asn1:"set"`
	MacAlgorithm     AlgorithmIdentifier
	DigestAlgorithm  AlgorithmIdentifier `asn1:"optional,explicit,tag:1"`
	EncapContentInfo EncapsulatedContentInfo
	AuthAttrs        asn1.RawValue `asn1:"optional,implicit,tag:2,set"`
	Mac              []byte
	UnauthAttrs      asn1.RawValue `asn1:"optional,implicit,tag:3,set"`
}

type CMSAlgorithmProtection struct {
	DigestAlgorithm    AlgorithmIdentifier
	SignatureAlgorithm *AlgorithmIdentifier `asn1:"optional,implicit,tag:1"`
	MacAlgorithm       *AlgorithmIdentifier `asn1:"optional,implicit,tag:2"`
}

type CMSAttribute struct {
	Type  asn1.ObjectIdentifier
	Value asn1.RawValue `asn1:"set"`
}

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

type CredentialDeserializer func(data []byte) (SerialisableCredential, error)

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

type CryptFilter struct {
	// Type is the crypt filter type.
	Type CryptFilterType

	// KeyLength is the key length in bytes.
	KeyLength int

	// AuthEvent specifies when authentication occurs.
	AuthEvent string

	// Recipients for public key encryption.
	Recipients [][]byte
}

type CryptFilterType string

type EncapsulatedContentInfo struct {
	ContentType asn1.ObjectIdentifier
	Content     []byte `asn1:"optional,explicit,tag:0"`
}

type EncryptionRevision int

type EncryptionVersion int

type EnvelopeKeyDecrypter interface {
	// Certificate returns the recipient's certificate.
	Certificate() *x509.Certificate
	// Decrypt decrypts using key transport (RSA).
	Decrypt(encryptedKey []byte, algo KeyEncryptionAlgorithm) ([]byte, error)
	// DecryptWithExchange decrypts using key agreement (ECDH).
	DecryptWithExchange(encryptedKey []byte, algo KeyEncryptionAlgorithm,
		originatorKey []byte, ukm []byte) ([]byte, error)
}

type FileEncryptionKeyCredential struct {
	Key []byte
}

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

type KdfAlgorithmId struct {
	Algorithm  asn1.ObjectIdentifier
	Parameters asn1.RawValue `asn1:"optional"`
}

type KeyEncryptionAlgorithm struct {
	Algorithm  asn1.ObjectIdentifier
	Parameters interface{}
}

type MACLocation string

type PasswordCredential struct {
	Password []byte
}

type PasswordRecipientInfo struct {
	Version                int
	KeyDerivationAlgorithm AlgorithmIdentifier `asn1:"optional,implicit,tag:0"`
	KeyEncryptionAlgorithm AlgorithmIdentifier
	EncryptedKey           []byte
}

type PdfMacDataAttribute struct {
	Type   asn1.ObjectIdentifier
	Values SetOfContentInfo `asn1:"set"`
}

type PdfMacIntegrityInfo struct {
	Version         int
	DataDigest      []byte
	SignatureDigest []byte `asn1:"optional,tag:0"`
}

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

type Permissions uint32

type PubKeyAdbeSubFilter string

type PubKeyCryptFilter struct {
	*CryptFilter
	Recipients      [][]byte // CMS EnvelopedData objects
	ActsAsDefault   bool
	EncryptMetadata bool
	// contains filtered or unexported fields
}

type PubKeyPermissions uint32

type PubKeySecurityHandler struct {
	Version         SecurityHandlerVersion
	SubFilter       PubKeyAdbeSubFilter
	KeyLength       int
	EncryptMetadata bool
	KDFSalt         []byte
	// contains filtered or unexported fields
}

type RecipientEncryptionPolicy struct {
	// IgnoreKeyUsage ignores key usage bits in recipient certificate.
	IgnoreKeyUsage bool
	// PreferOAEP uses RSAES-OAEP for RSA recipients (not widely supported).
	PreferOAEP bool
}

type SecurityHandler interface {
	// Authenticate authenticates with a password.
	Authenticate(password []byte) error
	// DecryptString decrypts a string.
	DecryptString(data []byte, objNum, genNum int) ([]byte, error)
	// DecryptStream decrypts a stream.
	DecryptStream(data []byte, objNum, genNum int) ([]byte, error)
	// EncryptString encrypts a string.
	EncryptString(data []byte, objNum, genNum int) ([]byte, error)
	// EncryptStream encrypts a stream.
	EncryptStream(data []byte, objNum, genNum int) ([]byte, error)
}

type SecurityHandlerVersion int

type SerialisableCredential interface {
	// GetName returns the type name of the credential.
	GetName() string

	// SerialiseValue serializes the credential to raw binary data.
	SerialiseValue() ([]byte, error)
}

type SerialisedCredential struct {
	// CredentialType is the registered type name of the credential.
	CredentialType string

	// Data is the credential data as a byte string.
	Data []byte
}

type SetOfContentInfo []ContentInfo

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

type StandalonePdfMac struct {
	ByteRange     []int
	MAC           []byte
	MACLocation   MACLocation
	BytesReserved int
}

type StandardSecurityHandler struct {
	Version     EncryptionVersion
	Revision    EncryptionRevision
	KeyLength   int
	Permissions Permissions
	OwnerKey    []byte // O value
	UserKey     []byte // U value
	OwnerE      []byte // OE value (R6)
	UserE       []byte // UE value (R6)
	Perms       []byte // Perms value (R6)
	FileID      []byte
	// contains filtered or unexported fields
}