github.com/angenalZZZ/gofunc@v0.0.0-20210507121333-48ff1be3917b/f/crypto_des.go (about)

     1  package f
     2  
     3  import (
     4  	"crypto/cipher"
     5  	"crypto/des"
     6  )
     7  
     8  // CryptoDesCBCEncrypt DES/CBC/PKCS5Padding+key(8bytes)+iv(16bytes)-Encrypt.
     9  // encryptedBytes := CryptoDesCBCEncrypt(origData, key, iv)
    10  // encryptedString := hex.EncodeToString(encryptedBytes)
    11  // encryptedString := base64.StdEncoding.EncodeToString(encryptedBytes)
    12  func CryptoDesCBCEncrypt(origData, key, iv []byte) []byte {
    13  	MustBytes(key, 8)
    14  	MustBytes(iv, 16)
    15  	block, err := des.NewCipher(key)
    16  	Must(err)
    17  	bs := block.BlockSize()
    18  	origData = CryptoPKCS5Padding(origData, bs)
    19  	blockMode := cipher.NewCBCEncrypter(block, iv[:bs])
    20  	encrypted := make([]byte, len(origData))
    21  	blockMode.CryptBlocks(encrypted, origData)
    22  	return encrypted
    23  }
    24  
    25  // CryptoDesCBCDecrypt DES/CBC/PKCS5Padding+key(8bytes)+iv(16bytes)-Decrypt.
    26  // encryptedBytes, err := hex.DecodeString(encryptedString)
    27  // encryptedBytes, err := base64.StdEncoding.DecodeString(encryptedString)
    28  // origData := CryptoDesCBCDecrypt(encryptedBytes, key, iv)
    29  func CryptoDesCBCDecrypt(encrypted, key, iv []byte) []byte {
    30  	MustBytes(key, 8)
    31  	MustBytes(iv, 16)
    32  	block, err := des.NewCipher(key)
    33  	Must(err)
    34  	bs := block.BlockSize()
    35  	mode := cipher.NewCBCDecrypter(block, iv[:bs])
    36  	origData := make([]byte, len(encrypted))
    37  	mode.CryptBlocks(origData, encrypted)
    38  	return CryptoPKCS5UnPadding(origData)
    39  }
    40  
    41  // CryptoDesECBEncrypt DES/ECB/PKCS5Padding+key(8bytes)-Encrypt.
    42  func CryptoDesECBEncrypt(origData, key []byte) []byte {
    43  	MustBytes(key, 8)
    44  	block, err := des.NewCipher(key)
    45  	Must(err)
    46  	bs := block.BlockSize()
    47  	origData = CryptoPKCS5Padding(origData, bs)
    48  	if len(origData)%bs != 0 {
    49  		return nil
    50  	}
    51  	out := make([]byte, len(origData))
    52  	dst := out
    53  	for len(origData) > 0 {
    54  		block.Encrypt(dst, origData[:bs])
    55  		origData = origData[bs:]
    56  		dst = dst[bs:]
    57  	}
    58  	return out
    59  }
    60  
    61  // CryptoDesECBDecrypt DES/ECB/PKCS5Padding+key(8bytes)-Decrypt.
    62  func CryptoDesECBDecrypt(encrypted, key []byte) []byte {
    63  	MustBytes(key, 8)
    64  	block, err := des.NewCipher(key)
    65  	Must(err)
    66  	bs := block.BlockSize()
    67  	if len(encrypted)%bs != 0 {
    68  		return nil
    69  	}
    70  	out := make([]byte, len(encrypted))
    71  	dst := out
    72  	for len(encrypted) > 0 {
    73  		block.Decrypt(dst, encrypted[:bs])
    74  		encrypted = encrypted[bs:]
    75  		dst = dst[bs:]
    76  	}
    77  	return CryptoPKCS5UnPadding(out)
    78  }
    79  
    80  // CryptoDesECBTripleEncrypt DES/ECB/PKCS5Padding+key(24bytes)+Tripled-Encrypt.
    81  func CryptoDesECBTripleEncrypt(origData, key []byte) []byte {
    82  	MustBytes(key, 24)
    83  	tk := make([]byte, 24, 24)
    84  	copy(tk, key)
    85  	k1 := tk[:8]
    86  	k2 := tk[8:16]
    87  	k3 := tk[16:]
    88  	block, err := des.NewCipher(k1)
    89  	Must(err)
    90  	bs := block.BlockSize()
    91  	origData = CryptoPKCS5Padding(origData, bs)
    92  	buf1 := cryptoDesECBEncrypt(origData, k1)
    93  	buf2 := cryptoDesECBDecrypt(buf1, k2)
    94  	buf3 := cryptoDesECBEncrypt(buf2, k3)
    95  	return buf3
    96  }
    97  
    98  func cryptoDesECBEncrypt(origData, key []byte) []byte {
    99  	block, err := des.NewCipher(key)
   100  	Must(err)
   101  	bs := block.BlockSize()
   102  	if len(origData)%bs != 0 {
   103  		return nil
   104  	}
   105  	out := make([]byte, len(origData))
   106  	dst := out
   107  	for len(origData) > 0 {
   108  		block.Encrypt(dst, origData[:bs])
   109  		origData = origData[bs:]
   110  		dst = dst[bs:]
   111  	}
   112  	return out
   113  }
   114  
   115  func cryptoDesECBDecrypt(encrypted, key []byte) []byte {
   116  	block, err := des.NewCipher(key)
   117  	Must(err)
   118  	out := make([]byte, len(encrypted))
   119  	dst := out
   120  	bs := block.BlockSize()
   121  	if len(encrypted)%bs != 0 {
   122  		return nil
   123  	}
   124  	for len(encrypted) > 0 {
   125  		block.Decrypt(dst, encrypted[:bs])
   126  		encrypted = encrypted[bs:]
   127  		dst = dst[bs:]
   128  	}
   129  	return out
   130  }