crypto

type Cryptor interface {
	Encryptor
	Decryptor
}

type DecKey interface {
	EncKey
	Decrypt(cipher []byte) ([]byte, error)
	Destroy()
}

type Decryptor interface {
	// Decrypt decrypts ciphertext using key k.
	Decrypt(k, cipherText []byte) (plaintext []byte, err error)
}

type EncKey interface {
	GetKeyInfo() int
	Encrypt(msg []byte, reader io.Reader) ([]byte, error)
	//for more information, see  comment of VerifyKey.Bytes
	Bytes() []byte
}

type Encryptor interface {
	// Encrypt encrypts plaintext using key k.
	Encrypt(k, plaintext []byte, reader io.Reader) (cipherText []byte, err error)
}

type Engine interface {
	PluginRandomFunc
	PluginHashFunc
	PluginCryptFunc
	PluginVerifyFunc
	PluginSignFunc
	PluginCreateSignFunc
	PluginEncKeyFunc
	PluginDecKeyFunc
	PluginCreateDecKeyFunc
}

type FlagReader interface {
	io.Reader
	GetFlag() int
}

type Hasher interface {
	hash.Hash
	// Hash hashes messages msg.
	Hash(msg []byte) (hash []byte, err error)
	// BachHash If you need to hash a series of bytes slices, calling BachHash can reduce one copy. BenchHash implies a loop.
	// example: a,b,c,d are four big byte slice
	// BenchHash([][]bytes{a,b,c,d}) faster than Hash(bytes.Join([][]bytes{a,b,c,d},nil))
	// It reduce one join(...). Join implies one copy.
	BatchHash(msg [][]byte) (hash []byte, err error)
}

type Key interface {
	// Bytes converts this key to its byte representation,
	// if this operation is allowed.
	Bytes() ([]byte, error)

	//FromBytes It's revert method to Bytes()
	//K is a byte that needs to be parsed, and the meaning of opt depend on Keys, for example, it's maybe an algorithm type. If the parsing fails, return empty Key or nil.
	FromBytes(k []byte, opt int) error
}

type Level interface {
	GetLevel() ([]int, uint8)
}

type PluginCreateDecKeyFunc interface {
	Level
	//generate a DecKey, and return index or key in raw form
	//if persistent is true, key should be persistent and return index
	//	or persistent is false, key should be persistent and output should in raw form
	CreateDecKey(persistent bool, mode int) (index []byte, k DecKey, err error)
}

type PluginCreateSignFunc interface {
	Level
	//generate a SignKey, and return index or key in raw form
	//if persistent is true, key should be persistent and return index
	//	or persistent is false, key should be persistent and output should in raw form
	CreateSignKey(persistent bool, mode int) (index []byte, k SignKey, err error)
}

type PluginCryptFunc interface {
	Level
	GetSecretKey(mode int, pwd, key []byte) (SecretKey, error)
}

type PluginDecKeyFunc interface {
	Level
	//enter index or raw privat key to generate a DecKey, key will not be persistent
	// a raw private key is a big integer
	GetDecKey(key []byte, mode int) (DecKey, error)
	//enter raw private key, return index, key should be persistent
	ImportDecKey(key []byte, mode int) (index []byte, err error)
}

type PluginEncKeyFunc interface {
	Level
	//enter a raw publicKey and mod, return a VerifyKey
	//see GetVerifyKey's comment for the meaning of a raw publicKey
	GetEncKey(key []byte, mode int) (EncKey, error)
}

type PluginHashFunc interface {
	Level
	GetHash(mode int) (Hasher, error)
}

type PluginRandomFunc interface {
	Level
	Rander() (io.Reader, error)
}

type PluginSignFunc interface {
	Level
	//enter index or raw privat key to generate a SignKey, key will not be persistent
	// a raw private key is a big integer
	GetSignKey(key []byte, mode int) (SignKey, error)
	//enter raw private key, return index, key should be persistent
	ImportSignKey(key []byte, mode int) (index []byte, err error)
}

type PluginVerifyFunc interface {
	Level
	//enter a raw publicKey and mod, return a VerifyKey
	//a raw publicKey means:
	// 1) for sm2, key is 65bytes and in 0x04||X||Y form, see GMT0009-2012 7.1
	//      http://www.gmbz.org.cn/main/viewfile/2018011001400692565.html may help
	// 2) for ecdsa, key is in 0x04||X||Y. The length depends on the curve, for example,
	//		65 bytes for secp256k1 and 133 for secp521r1, see 2.3.3 in [SEC1] uncompressed form.
	//		https://www.rfc-editor.org/rfc/rfc5480.txt may help
	// 3) for rsa, key is in PKCS#1 form, see RFC2313 RSAPublicKey
	//		RSAPublicKey ::= SEQUENCE {
	//     		modulus INTEGER, -- n
	//     		publicExponent INTEGER -- e }
	//		https://www.rfc-editor.org/rfc/rfc2313.txt may help
	GetVerifyKey(key []byte, mode int) (VerifyKey, error)
}

type PrivateKey interface {
	SignKey
	DecKey
}

type PublicKey interface {
	VerifyKey
	EncKey
}

type SecretKey interface {
	Encrypt(src []byte, reader io.Reader) []byte
	Decrypt(src []byte) []byte
	Destroy()
}

type SignKey interface {
	VerifyKey
	Sign(msg []byte, hasher hash.Hash, rand io.Reader) ([]byte, error)
	Destroy()
}

type Signer interface {
	Key
	Sign(k, digest []byte, reader io.Reader) ([]byte, error)
}

type Verifier interface {
	Key
	// Verify verifies signature against key k and digest
	Verify(k, signature, digest []byte) (valid bool, err error)
}

type VerifyKey interface {
	GetKeyInfo() int
	Verify(msg []byte, hasher hash.Hash, sig []byte) bool
	//return a raw
	//sm2: SM2PublicKey::=BIT STRING,	04||X||Y,	65 Bytes,	GMT0009-2012 7.1
	//ecdsa: PublicKeyBytes in PKIX publicKey
	//rsa: asn1{N, e}
	//for more information, see GetVerifyKey's comment
	Bytes() []byte
}