package starcrypto

import (
	"io"

	"b612.me/starcrypto/symm"
)

func EncryptSM4(data, key, iv []byte, mode, paddingType string) ([]byte, error) {
	return symm.EncryptSM4(data, key, iv, mode, paddingType)
}

func DecryptSM4(src, key, iv []byte, mode, paddingType string) ([]byte, error) {
	return symm.DecryptSM4(src, key, iv, mode, paddingType)
}

func EncryptSM4Stream(dst io.Writer, src io.Reader, key, iv []byte, mode, paddingType string) error {
	return symm.EncryptSM4Stream(dst, src, key, iv, mode, paddingType)
}

func DecryptSM4Stream(dst io.Writer, src io.Reader, key, iv []byte, mode, paddingType string) error {
	return symm.DecryptSM4Stream(dst, src, key, iv, mode, paddingType)
}

func EncryptSM4WithOptions(data, key []byte, opts *CipherOptions) ([]byte, error) {
	return symm.EncryptSM4WithOptions(data, key, opts)
}

func DecryptSM4WithOptions(src, key []byte, opts *CipherOptions) ([]byte, error) {
	return symm.DecryptSM4WithOptions(src, key, opts)
}

func EncryptSM4StreamWithOptions(dst io.Writer, src io.Reader, key []byte, opts *CipherOptions) error {
	return symm.EncryptSM4StreamWithOptions(dst, src, key, opts)
}

func DecryptSM4StreamWithOptions(dst io.Writer, src io.Reader, key []byte, opts *CipherOptions) error {
	return symm.DecryptSM4StreamWithOptions(dst, src, key, opts)
}

func EncryptSM4GCM(plain, key, nonce, aad []byte) ([]byte, error) {
	return symm.EncryptSM4GCM(plain, key, nonce, aad)
}

func DecryptSM4GCM(ciphertext, key, nonce, aad []byte) ([]byte, error) {
	return symm.DecryptSM4GCM(ciphertext, key, nonce, aad)
}

func EncryptSM4GCMChunk(plain, key, nonce, aad []byte, chunkIndex uint64) ([]byte, error) {
	return symm.EncryptSM4GCMChunk(plain, key, nonce, aad, chunkIndex)
}

func DecryptSM4GCMChunk(ciphertext, key, nonce, aad []byte, chunkIndex uint64) ([]byte, error) {
	return symm.DecryptSM4GCMChunk(ciphertext, key, nonce, aad, chunkIndex)
}

func EncryptSM4GCMStream(dst io.Writer, src io.Reader, key, nonce, aad []byte) error {
	return symm.EncryptSM4GCMStream(dst, src, key, nonce, aad)
}

func DecryptSM4GCMStream(dst io.Writer, src io.Reader, key, nonce, aad []byte) error {
	return symm.DecryptSM4GCMStream(dst, src, key, nonce, aad)
}

func EncryptSM4CCM(plain, key, nonce, aad []byte) ([]byte, error) {
	return symm.EncryptSM4CCM(plain, key, nonce, aad)
}

func DecryptSM4CCM(ciphertext, key, nonce, aad []byte) ([]byte, error) {
	return symm.DecryptSM4CCM(ciphertext, key, nonce, aad)
}

func EncryptSM4CCMChunk(plain, key, nonce, aad []byte, chunkIndex uint64) ([]byte, error) {
	return symm.EncryptSM4CCMChunk(plain, key, nonce, aad, chunkIndex)
}

func DecryptSM4CCMChunk(ciphertext, key, nonce, aad []byte, chunkIndex uint64) ([]byte, error) {
	return symm.DecryptSM4CCMChunk(ciphertext, key, nonce, aad, chunkIndex)
}

func EncryptSM4CCMStream(dst io.Writer, src io.Reader, key, nonce, aad []byte) error {
	return symm.EncryptSM4CCMStream(dst, src, key, nonce, aad)
}

func DecryptSM4CCMStream(dst io.Writer, src io.Reader, key, nonce, aad []byte) error {
	return symm.DecryptSM4CCMStream(dst, src, key, nonce, aad)
}

func EncryptSM4CFB(origData, key []byte) ([]byte, error) {
	return symm.EncryptSM4CFB(origData, key)
}

func DecryptSM4CFB(encrypted, key []byte) ([]byte, error) {
	return symm.DecryptSM4CFB(encrypted, key)
}

func EncryptSM4CFBNoBlock(origData, key, iv []byte) ([]byte, error) {
	return symm.EncryptSM4CFBNoBlock(origData, key, iv)
}

func DecryptSM4CFBNoBlock(encrypted, key, iv []byte) ([]byte, error) {
	return symm.DecryptSM4CFBNoBlock(encrypted, key, iv)
}

func EncryptSM4ECB(data, key []byte, paddingType string) ([]byte, error) {
	return symm.EncryptSM4ECB(data, key, paddingType)
}

func DecryptSM4ECB(src, key []byte, paddingType string) ([]byte, error) {
	return symm.DecryptSM4ECB(src, key, paddingType)
}

func EncryptSM4CBC(data, key, iv []byte, paddingType string) ([]byte, error) {
	return symm.EncryptSM4CBC(data, key, iv, paddingType)
}

func DecryptSM4CBC(src, key, iv []byte, paddingType string) ([]byte, error) {
	return symm.DecryptSM4CBC(src, key, iv, paddingType)
}

func EncryptSM4OFB(data, key, iv []byte) ([]byte, error) {
	return symm.EncryptSM4OFB(data, key, iv)
}

func DecryptSM4OFB(src, key, iv []byte) ([]byte, error) {
	return symm.DecryptSM4OFB(src, key, iv)
}

func EncryptSM4CTR(data, key, iv []byte) ([]byte, error) {
	return symm.EncryptSM4CTR(data, key, iv)
}

func DecryptSM4CTR(src, key, iv []byte) ([]byte, error) {
	return symm.DecryptSM4CTR(src, key, iv)
}

func EncryptSM4CTRAt(data, key, iv []byte, offset int64) ([]byte, error) {
	return symm.EncryptSM4CTRAt(data, key, iv, offset)
}

func DecryptSM4CTRAt(src, key, iv []byte, offset int64) ([]byte, error) {
	return symm.DecryptSM4CTRAt(src, key, iv, offset)
}

func EncryptSM4ECBStream(dst io.Writer, src io.Reader, key []byte, paddingType string) error {
	return symm.EncryptSM4ECBStream(dst, src, key, paddingType)
}

func DecryptSM4ECBStream(dst io.Writer, src io.Reader, key []byte, paddingType string) error {
	return symm.DecryptSM4ECBStream(dst, src, key, paddingType)
}

func EncryptSM4CFBStream(dst io.Writer, src io.Reader, key, iv []byte) error {
	return symm.EncryptSM4CFBStream(dst, src, key, iv)
}

func DecryptSM4CFBStream(dst io.Writer, src io.Reader, key, iv []byte) error {
	return symm.DecryptSM4CFBStream(dst, src, key, iv)
}

func EncryptSM4CBCStream(dst io.Writer, src io.Reader, key, iv []byte, paddingType string) error {
	return symm.EncryptSM4CBCStream(dst, src, key, iv, paddingType)
}

func DecryptSM4CBCStream(dst io.Writer, src io.Reader, key, iv []byte, paddingType string) error {
	return symm.DecryptSM4CBCStream(dst, src, key, iv, paddingType)
}

func EncryptSM4OFBStream(dst io.Writer, src io.Reader, key, iv []byte) error {
	return symm.EncryptSM4OFBStream(dst, src, key, iv)
}

func DecryptSM4OFBStream(dst io.Writer, src io.Reader, key, iv []byte) error {
	return symm.DecryptSM4OFBStream(dst, src, key, iv)
}

func EncryptSM4CTRStream(dst io.Writer, src io.Reader, key, iv []byte) error {
	return symm.EncryptSM4CTRStream(dst, src, key, iv)
}

func DecryptSM4CTRStream(dst io.Writer, src io.Reader, key, iv []byte) error {
	return symm.DecryptSM4CTRStream(dst, src, key, iv)
}

func EncryptSM4CFB8(data, key, iv []byte) ([]byte, error) {
	return symm.EncryptSM4CFB8(data, key, iv)
}

func DecryptSM4CFB8(src, key, iv []byte) ([]byte, error) {
	return symm.DecryptSM4CFB8(src, key, iv)
}

func EncryptSM4CFB8Stream(dst io.Writer, src io.Reader, key, iv []byte) error {
	return symm.EncryptSM4CFB8Stream(dst, src, key, iv)
}

func DecryptSM4CFB8Stream(dst io.Writer, src io.Reader, key, iv []byte) error {
	return symm.DecryptSM4CFB8Stream(dst, src, key, iv)
}

func DecryptSM4ECBBlocks(src, key []byte) ([]byte, error) {
	return symm.DecryptSM4ECBBlocks(src, key)
}

func DecryptSM4CBCFromSecondBlock(src, key, prevCipherBlock []byte) ([]byte, error) {
	return symm.DecryptSM4CBCFromSecondBlock(src, key, prevCipherBlock)
}

func DecryptSM4CFBFromSecondBlock(src, key, prevCipherBlock []byte) ([]byte, error) {
	return symm.DecryptSM4CFBFromSecondBlock(src, key, prevCipherBlock)
}
func EncryptSM4XTS(plain, key1, key2 []byte, dataUnitSize int) ([]byte, error) {
	return symm.EncryptSM4XTS(plain, key1, key2, dataUnitSize)
}

func DecryptSM4XTS(ciphertext, key1, key2 []byte, dataUnitSize int) ([]byte, error) {
	return symm.DecryptSM4XTS(ciphertext, key1, key2, dataUnitSize)
}

func EncryptSM4XTSAt(plain, key1, key2 []byte, dataUnitSize int, dataUnitIndex uint64) ([]byte, error) {
	return symm.EncryptSM4XTSAt(plain, key1, key2, dataUnitSize, dataUnitIndex)
}

func DecryptSM4XTSAt(ciphertext, key1, key2 []byte, dataUnitSize int, dataUnitIndex uint64) ([]byte, error) {
	return symm.DecryptSM4XTSAt(ciphertext, key1, key2, dataUnitSize, dataUnitIndex)
}

func EncryptSM4XTSStream(dst io.Writer, src io.Reader, key1, key2 []byte, dataUnitSize int) error {
	return symm.EncryptSM4XTSStream(dst, src, key1, key2, dataUnitSize)
}

func DecryptSM4XTSStream(dst io.Writer, src io.Reader, key1, key2 []byte, dataUnitSize int) error {
	return symm.DecryptSM4XTSStream(dst, src, key1, key2, dataUnitSize)
}

func EncryptSM4XTSStreamAt(dst io.Writer, src io.Reader, key1, key2 []byte, dataUnitSize int, dataUnitIndex uint64) error {
	return symm.EncryptSM4XTSStreamAt(dst, src, key1, key2, dataUnitSize, dataUnitIndex)
}

func DecryptSM4XTSStreamAt(dst io.Writer, src io.Reader, key1, key2 []byte, dataUnitSize int, dataUnitIndex uint64) error {
	return symm.DecryptSM4XTSStreamAt(dst, src, key1, key2, dataUnitSize, dataUnitIndex)
}