bccsp

type AESCBCPKCS7ModeOpts struct {
	IV   []byte
	PRNG io.Reader
}

type AESKeyDerivOpts struct {
	Temporary bool
	Arg       []byte
}

type AESKeyGenOpts struct {
	Temporary bool
}

type AESKeyImportOpts struct {
	Temporary bool
}

type BCCSP interface {
	// KeyGen 提供选项，生成与选项对应的密钥：
	//	- ECDSAKeyGenOpts：&ecdsaPrivateKey{}
	//	- AESKeyGenOpts：&aesKey{}
	KeyGen(opts KeyGenOpts) (Key, error)

	// KeyDeriv 根据密钥衍生算法衍生出新的密钥，需要提供选项，目前支持的选项：
	//	- AESKeyDerivOpts：衍生出新的 AES 密钥
	//	- ECDSAKeyDerivOpts：衍生出新的 ECDSA 密钥
	KeyDeriv(key Key, opts KeyDerivOpts) (Key, error)

	// KeyImport 导入密钥，需要提供选项，目前支持的选项：
	//	- ECDSAPKIXPublicKeyImportOpts：导入 ECDSA 公钥
	//	- ECDSAPrivateKeyImportOpts：导入 ECDSA 私钥
	//	- AESKeyImportOpts：导入 AES 密钥
	//	- X509PublicKeyImportOpts：导入 x509 公钥
	KeyImport(raw interface{}, opts KeyImportOpts) (Key, error)

	// GetKey 根据密钥的唯一标识符获取密钥。
	GetKey(ski []byte) (Key, error)

	// Hash 根据提供的选项，直接对消息进行哈希运算，得到消息的摘要，目前仅支持的选项是：
	//	- SHA256Opts：生成 256 比特的消息摘要。
	Hash(msg []byte, opts HashOpts) ([]byte, error)

	// GetHash 获得一个哈希函数，用于计算消息的哈希值，传入的选项目前仅支持：
	//	- SHA256Opts：获得一个 SHA256 哈希函数的实例
	GetHash(opts HashOpts) (hash.Hash, error)

	// Sign 根据提供的签名密钥，对消息摘要进行签名。
	Sign(key Key, digest []byte, opts SignerOpts) ([]byte, error)

	// Verify 根据提供的密钥：
	//	- *ecdsaPrivateKey：提取其中的公钥，用公钥验证签名的合法性
	//	- *ecdsaPublickey：直接用公钥验证签名的合法性
	Verify(key Key, signature, digest []byte, opts SignerOpts) (bool, error)

	// Encrypt 根据提供的密钥对明文进行加密获得密文，需要提供选项 EncryptOpts，目前仅支持：
	//	- AESCBCPKCS7ModeOpts：要么提供初始向量，要么提供伪随机数生成器，辅助加密过程
	Encrypt(key Key, plaintext []byte, opts EncryptOpts) ([]byte, error)

	// Decrypt 根据提供的密钥对密文进行解密。
	Decrypt(key Key, ciphertext []byte, opts DecryptOpts) ([]byte, error)
}

type CSP struct {
	KeyGenerators map[reflect.Type]KeyGenerator
	KeyDerivers   map[reflect.Type]KeyDeriver
	KeyImporters  map[reflect.Type]KeyImporter
	Encrypters    map[reflect.Type]Encrypter
	Decrypters    map[reflect.Type]Decrypter
	Signers       map[reflect.Type]Signer
	Verifiers     map[reflect.Type]Verifier
	Hashers       map[reflect.Type]Hasher
	// contains filtered or unexported fields
}

type DecryptOpts interface{}

type Decrypter interface {
	Decrypt(key Key, ciphertext []byte, opts DecryptOpts) (plaintext []byte, err error)
}

type ECDSAKeyDerivOpts struct {
	Temporary bool
	Expansion []byte
}

type ECDSAKeyGenOpts struct {
	Temporary bool
}

type ECDSAPKIXPublicKeyImportOpts struct {
	Temporary bool
}

type ECDSAPrivateKeyImportOpts struct {
	Temporary bool
}

type ECDSASignature struct {
	R, S *big.Int
}

type EidNymAuditOpts struct {
	EidIndex     int
	EnrollmentID string
	RNymEid      *mathlib.Zr
}

type EncryptOpts interface{}

type Encrypter interface {
	Encrypt(key Key, plaintext []byte, opts EncryptOpts) (ciphertext []byte, err error)
}

type HashOpts interface {
	Algorithm() string
}

type Hasher interface {
	Hash(msg []byte, opts HashOpts) ([]byte, error)
	GetHash(opts HashOpts) (h hash.Hash, err error)
}

type IdemixAttribute struct {
	// Type is the attribute's type
	Type IdemixAttributeType
	// Value is the attribute's value
	Value interface{}
}

type IdemixAttributeType int

type IdemixCRISignerOpts struct {
	Epoch               int
	RevocationAlgorithm RevocationAlgorithm
	UnrevokedHandles    [][]byte
	// H is the hash function to be used
	H crypto.Hash
}

type IdemixCredentialRequestSignerOpts struct {
	// 证书中包含的属性的索引列表。
	Attributes []int

	// 签发者的公钥。
	IssuerPK Key

	// IssuerNonce 由签发人生成，客户端使用它来生成凭据请求。签发人收到凭据请求后，会检查 nonce 是否相同。
	IssuerNonce []byte

	// 被使用的哈希函数。
	H crypto.Hash
}

type IdemixCredentialSignerOpts struct {
	// Attributes to include in the credentials. IdemixHiddenAttribute is not allowed here
	Attributes []IdemixAttribute
	// IssuerPK is the public-key of the issuer
	IssuerPK Key
	// HashFun is the hash function to be used
	H crypto.Hash
}

type IdemixIssuerKeyGenOpts struct {
	// Temporary tells if the key is ephemeral
	Temporary bool
	// AttributeNames is a list of attributes
	AttributeNames []string
}

type IdemixIssuerKeyImportOpts struct {
	Temporary bool
	// AttributeNames is a list of attributes to ensure the import public key has
	AttributeNames []string
}

type IdemixIssuerPublicKeyImportOpts struct {
	Temporary bool
	// AttributeNames is a list of attributes to ensure the import public key has
	AttributeNames []string
}

type IdemixNymKeyDerivationOpts struct {
	// Temporary tells if the key is ephemeral
	Temporary bool
	// IssuerPK is the public-key of the issuer
	IssuerPK Key
}

type IdemixNymKeyImportOpts struct {
	// Temporary tells if the key is ephemeral
	Temporary bool
}

type IdemixNymPublicKeyImportOpts struct {
	// Temporary tells if the key is ephemeral
	Temporary bool
}

type IdemixNymSignerOpts struct {
	// Nym is the pseudonym to be used
	Nym Key
	// IssuerPK is the public-key of the issuer
	IssuerPK Key
	// H is the hash function to be used
	H crypto.Hash
}

type IdemixRevocationKeyGenOpts struct {
	// Temporary tells if the key is ephemeral
	Temporary bool
}

type IdemixRevocationKeyImportOpts struct {
	Temporary bool
}

type IdemixRevocationPublicKeyImportOpts struct {
	Temporary bool
}

type IdemixSignerMetadata struct {
	NymEIDAuditData *NymEIDAuditData
}

type IdemixSignerOpts struct {
	// Nym is the pseudonym to be used
	Nym Key
	// IssuerPK is the public-key of the issuer
	IssuerPK Key
	// Credential is the byte representation of the credential signed by the issuer
	Credential []byte
	// Attributes specifies which attribute should be disclosed and which not.
	// If Attributes[i].Type = IdemixHiddenAttribute
	// then the i-th credential attribute should not be disclosed, otherwise the i-th
	// credential attribute will be disclosed.
	// At verification time, if the i-th attribute is disclosed (Attributes[i].Type != IdemixHiddenAttribute),
	// then Attributes[i].Value must be set accordingly.
	Attributes []IdemixAttribute
	// RhIndex is the index of attribute containing the revocation handler.
	// Notice that this attributed cannot be discloused
	RhIndex int
	// EidIndex contains the index of the EID attrbiute
	EidIndex int
	// CRI contains the credential revocation information
	CRI []byte
	// Epoch is the revocation epoch the signature should be produced against
	Epoch int
	// RevocationPublicKey is the revocation public key
	RevocationPublicKey Key
	// H is the hash function to be used
	H crypto.Hash
	// SigType is the type of signature that shall be generated
	SigType SignatureType
	// IdemixSignerMetadata contains metadata about the signature
	Metadata *IdemixSignerMetadata
	// VerificationType controls what type of verification the caller expects
	VerificationType VerificationType
}

type IdemixUserSecretKeyGenOpts struct {
	Temporary bool
}

type IdemixUserSecretKeyImportOpts struct {
	Temporary bool
}

type Key interface {
	// Bytes 在允许的情况下，将密钥转换为原始的字节切片形式。
	Bytes() ([]byte, error)

	// SKI 返回该密钥的唯一标识符。
	//	- AES 返回其私钥的哈希值
	//	- ECDSA 返回其公钥的哈希值
	SKI() []byte

	// Symmetric 用来标识该密钥是否是对称密钥，如果是的话，则返回 true，否则返回 false。
	Symmetric() bool

	// IsPrivate 用来标识该密钥是否是私钥，如果是的话，则返回 true，否则返回 false。
	IsPrivate() bool

	// PublicKey 返回非对称密钥中的公钥，如果该密钥是对称密钥，调用该方法会返回错误。
	PublicKey() (Key, error)
}

type KeyDerivOpts interface {
	Algorithm() string
	Ephemeral() bool
}

type KeyDeriver interface {
	KeyDeriv(key Key, opts KeyDerivOpts) (dkey Key, err error)
}

type KeyGenOpts interface {
	Algorithm() string
	Ephemeral() bool
}

type KeyGenerator interface {
	KeyGen(opts KeyGenOpts) (key Key, err error)
}

type KeyImportOpts interface {
	Algorithm() string
	Ephemeral() bool
}

type KeyImporter interface {
	KeyImport(raw interface{}, opts KeyImportOpts) (Key, error)
}

type KeyStore interface {
	// ReadOnly 返回 true 的话，那么该 KeyStore 不可更改。
	ReadOnly() bool

	GetKey(ski []byte) (key Key, err error)

	// StoreKey 存储密钥，该方法在 ReadOnly 方法返回 true 的时候不可用。
	StoreKey(key Key) (err error)
}

type NymEIDAuditData struct {
	// RNymEid is the randomness used to generate the EID Nym
	RNymEid *mathlib.Zr

	// EID is the enrollment id
	EID *mathlib.Zr
}

type RevocationAlgorithm int32

type SHA256Opts struct{}

type SignatureType int

type Signer interface {
	Sign(key Key, digest []byte, opts SignerOpts) (signature []byte, err error)
}

type SignerOpts interface {
	crypto.SignerOpts
}

type VerificationType int

type Verifier interface {
	Verify(key Key, signature []byte, digest []byte, opts SignerOpts) (valid bool, err error)
}

type X509PublicKeyImportOpts struct {
	Temporary bool
}