starcrypto/aes.go

package starcrypto

import (
	"io"

	"b612.me/starcrypto/symm"
)

type CipherOptions = symm.CipherOptions

const (
	PKCS5PADDING    = symm.PKCS5PADDING
	PKCS7PADDING    = symm.PKCS7PADDING
	ZEROPADDING     = symm.ZEROPADDING
	ANSIX923PADDING = symm.ANSIX923PADDING

	MODEECB = symm.MODEECB
	MODECBC = symm.MODECBC
	MODECFB = symm.MODECFB
	MODEOFB = symm.MODEOFB
	MODECTR = symm.MODECTR
	MODEGCM = symm.MODEGCM
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func PKCS5Padding(cipherText []byte, blockSize int) []byte {
	return symm.PKCS5Padding(cipherText, blockSize)
}

func PKCS5Trimming(encrypt []byte) []byte {
	return symm.PKCS5Trimming(encrypt)
}

func PKCS7Padding(cipherText []byte, blockSize int) []byte {
	return symm.PKCS7Padding(cipherText, blockSize)
}

func PKCS7Trimming(encrypt []byte, blockSize int) []byte {
	return symm.PKCS7Trimming(encrypt, blockSize)
}