golang AES/ECB/PKCS5 加密解密 url-safe-base64

小时？

/*　　
描述 :  golang  AES/ECB/PKCS5  加密解密
　　
date : 2016-04-08
　　

*/　　

　　
package main
　　

　　
import (
　　

"bytes"　　
"crypto/aes"
　　
"crypto/cipher"
　　
"encoding/base64"
　　
"fmt"
　　
"strings"
　　
)
　　

　　
func main() {
　　
/*
　　
*src 要加密的字符串
　　
*key 用来加密的密钥 密钥长度可以是128bit、192bit、256bit中的任意一个
　　
*16位key对应128bit
　　
*/
　　
src := "0.56"
　　
key := "0123456789abcdef"
　　

　　
crypted := AesEncrypt(src, key)
　　
AesDecrypt(crypted, []byte(key))
　　
Base64URLDecode("39W7dWTd_SBOCM8UbnG6qA")
　　
}
　　

　　
func Base64URLDecode(data string) ([]byte, error) {
　　
var missing = (4 - len(data)%4) % 4
　　
data += strings.Repeat("=", missing)
　　
res, err := base64.URLEncoding.DecodeString(data)
　　
fmt.Println("  decodebase64urlsafe is :", string(res), err)
　　
return base64.URLEncoding.DecodeString(data)
　　
}
　　

　　
func Base64UrlSafeEncode(source []byte) string {
　　
// Base64 Url Safe is the same as Base64 but does not contain '/' and '+' (replaced by '_' and '-') and trailing '=' are removed.
　　
bytearr := base64.StdEncoding.EncodeToString(source)
　　
safeurl := strings.Replace(string(bytearr), "/", "_", -1)
　　
safeurl = strings.Replace(safeurl, "+", "-", -1)
　　
safeurl = strings.Replace(safeurl, "=", "", -1)
　　
return safeurl
　　
}
　　

　　
func AesDecrypt(crypted, key []byte) []byte {
　　
block, err := aes.NewCipher(key)
　　
if err != nil {
　　
fmt.Println("err is:", err)
　　
}
　　
blockMode := NewECBDecrypter(block)
　　
origData := make([]byte, len(crypted))
　　
blockMode.CryptBlocks(origData, crypted)
　　
origData = PKCS5UnPadding(origData)
　　
fmt.Println("source is :", origData, string(origData))
　　
return origData
　　
}
　　

　　
func AesEncrypt(src, key string) []byte {
　　
block, err := aes.NewCipher([]byte(key))
　　
if err != nil {
　　
fmt.Println("key error1", err)
　　
}
　　
if src == "" {
　　
fmt.Println("plain content empty")
　　
}
　　
ecb := NewECBEncrypter(block)
　　
content := []byte(src)
　　
content = PKCS5Padding(content, block.BlockSize())
　　
crypted := make([]byte, len(content))
　　
ecb.CryptBlocks(crypted, content)
　　
// 普通base64编码加密 区别于urlsafe base64
　　
fmt.Println("base64 result:", base64.StdEncoding.EncodeToString(crypted))
　　

　　
fmt.Println("base64UrlSafe result:", Base64UrlSafeEncode(crypted))
　　
return crypted
　　
}
　　

　　
func PKCS5Padding(ciphertext []byte, blockSize int) []byte {
　　
padding := blockSize - len(ciphertext)%blockSize
　　
padtext := bytes.Repeat([]byte{byte(padding)}, padding)
　　
return append(ciphertext, padtext...)
　　
}
　　

　　
func PKCS5UnPadding(origData []byte) []byte {
　　
length := len(origData)
　　
// 去掉最后一个字节 unpadding 次
　　
unpadding := int(origData[length-1])
　　
return origData[:(length - unpadding)]
　　
}
　　

　　
type ecb struct {
　　
b         cipher.Block
　　
blockSize int
　　
}
　　

　　
func newECB(b cipher.Block) *ecb {
　　
return &ecb{
　　
b:         b,
　　
blockSize: b.BlockSize(),
　　
}
　　
}
　　

　　
type ecbEncrypter ecb
　　

　　
// NewECBEncrypter returns a BlockMode which encrypts in electronic code book
　　
// mode, using the given Block.
　　
func NewECBEncrypter(b cipher.Block) cipher.BlockMode {
　　
return (*ecbEncrypter)(newECB(b))
　　
}
　　
func (x *ecbEncrypter) BlockSize() int { return x.blockSize }
　　
func (x *ecbEncrypter) CryptBlocks(dst, src []byte) {
　　
if len(src)%x.blockSize != 0 {
　　
panic("crypto/cipher: input not full blocks")
　　
}
　　
if len(dst) < len(src) {
　　
panic("crypto/cipher: output smaller than input")
　　
}
　　
for len(src) > 0 {
　　
x.b.Encrypt(dst, src[:x.blockSize])
　　
src = src[x.blockSize:]
　　
dst = dst[x.blockSize:]
　　
}
　　
}
　　

　　
type ecbDecrypter ecb
　　

　　
// NewECBDecrypter returns a BlockMode which decrypts in electronic code book
　　
// mode, using the given Block.
　　
func NewECBDecrypter(b cipher.Block) cipher.BlockMode {
　　
return (*ecbDecrypter)(newECB(b))
　　
}
　　
func (x *ecbDecrypter) BlockSize() int { return x.blockSize }
　　
func (x *ecbDecrypter) CryptBlocks(dst, src []byte) {
　　
if len(src)%x.blockSize != 0 {
　　
panic("crypto/cipher: input not full blocks")
　　
}
　　
if len(dst) < len(src) {
　　
panic("crypto/cipher: output smaller than input")
　　
}
　　
for len(src) > 0 {
　　
x.b.Decrypt(dst, src[:x.blockSize])
　　
src = src[x.blockSize:]
　　
dst = dst[x.blockSize:]
　　
}
　　
}