Golang常见加密算法

md5签名算法

md5加密是我们常用的一种加密算法，可以对明文进行处理产生一个128位（16字节）的散列值，为了便于展示和读写一般将128位的二进制数转换成32位16进制数（如：655A6E9A375DF4F82B730833C807AADD）。通常用在密码存储和文件的完整性校验上。

func Md5Str(src string) string {
    has = md5.New()
    has.Write([]byte(src))
    return hex.EncodeToString(has.Sum(nil))
}

哈希sha签名算法

哈希函数，又称散列算法，是一种从任何一种数据中创建小的数字“指纹”的方法。散列函数把消息或数据压缩成摘要，使得数据量变小，将数据的格式固定下来。该函数将数据打乱混合，重新创建一个叫做散列值（或哈希值）的指纹。散列值通常用一个短的随机字母和数字组成的字符串来代表。对于任意长度的消息，SHA256都会产生一个256bit长的哈希值，称作消息摘要。

// 哈希sha256算法
func HmacSha256(src, key string) string {
    has = hmac.New(sha256.New, []byte(key))
    has.Write([]byte(src))
    return hex.EncodeToString(has.Sum(nil))
}
//哈希sha512签名算法
func HmacSha512(src, key string) string {
    has = hmac.New(sha512.New, []byte(key))
    has.Write([]byte(src))
    return hex.EncodeToString(has.Sum(nil))
}
//哈希sha1签名算法
func HmacSha1(src, key string) string {
    has = hmac.New(sha1.New, []byte(key))
    has.Write([]byte(src))
    return hex.EncodeToString(has.Sum(nil))
}

//sha256密码散列函数
func Sha256str(src string) string {
    has = sha256.New()
    has.Write([]byte(src))
    return hex.EncodeToString(has.Sum(nil))
}
//sha512密码散列函数
func Sha512str(src string) string {
    has = sha512.New()
    has.Write([]byte(src))
    return hex.EncodeToString(has.Sum(nil))
}
//sha1密码散列函数
func Sha1str(src string) string {
    has = sha1.New()
    has.Write([]byte(src))
    return hex.EncodeToString(has.Sum(nil))
}

base64 编码、解码函数

规则如下：
- step1、找到每个字母对应的acsii码的二进制（八位表达，1个字节8位）如Man对应的ASCII码值分别为77，97，110，对应的二进制值是01001101、01100001、01101110
- step2、将step1得到的二进制24位每6位二进制位一组（如果不能整除要加一组0直到被6整除为止）分成四组，也就是00010011、00010110、00000101、00101110 （将6位前面补0满足8位）
- step3、再跟base64的编码表做对比，上述也就是19、22、5、46
- step4、用上面的值在Base64编码表中进行查找，分别对应：T、W、F、u。因此“Man”Base64编码之后就变为：TWFu

// base64编码函数
func Base64EncodeStr(src string) string {
    return string(base64.StdEncoding.EncodeToString([]byte(src)))
}

// base64解码函数
func Base64DecodeStr(src string) string {
    data, err = base64.StdEncoding.DecodeString(src)
    if err != nil {
        return ""
    }
    return string(data)
}

非对称加密算法（RSA）

1、乙方生成两把密钥（公钥和私钥）。公钥是公开的，任何人都可以获得，私钥则是保密的。
2、甲方获取乙方的公钥，然后用它对信息加密。
3、乙方得到加密后的信息，用私钥解密。

/**
 * 生成公钥、私钥文件
 */
func GenRsaKey(bits int, privatePath, publicPath string) error {

    /*****生成私钥文件*******/
    privateKey, err = rsa.GenerateKey(rand.Reader, bits)
    if err != nil {
        return err
    }
    data = x509.MarshalPKCS1PrivateKey(privateKey)
    block := pem.Block{
        Type:  "RSA PRIVATE KEY",
        Bytes: data,
    }
    privateFile, err = os.Create(privatePath)
    defer privateFile.Close()
    err = pem.Encode(privateFile, &block)
    if err != nil {
        return err
    }

    /***********生成公钥文件************/
    publicKey = &privateKey.PublicKey
    data = x509.MarshalPKCS1PublicKey(publicKey)
    block = pem.Block{
        Type:  "RSA PUBLIC KEY",
        Bytes: data,
    }
    publicFile, err = os.Create(publicPath)
    defer publicFile.Close()
    if err != nil {
        return err
    }
    err = pem.Encode(publicFile, &block)
    if err != nil {
        return err
    }
    return nil
}

/**
 * 公钥加密函数
 */
func RsaEncrypt(src []byte, filename string) ([]byte, error) {
    publicFile, err = os.Open(filename)
    if err != nil {
        panic(err)
        return nil, err
    }
    defer publicFile.Close()
    data, err = ioutil.ReadAll(publicFile)
    if err != nil {
        panic(err)
        return nil, err
    }
    block, rest = pem.Decode(data)
    if block == nil {
        panic(err)
        return nil, err
    }
    publicKey, err = x509.ParsePKCS1PublicKey(block.Bytes)
    if err != nil {
        return nil, err
    }
    return rsa.EncryptPKCS1v15(rand.Reader, publicKey, src)
}

/**
 * 私钥解密函数
 */
func RsaDecrypt(src []byte, filename string) ([]byte, error) {
    privateFile, err = os.Open(filename)
    if err != nil {
        return nil, err
    }
    defer privateFile.Close()
    data, err = ioutil.ReadAll(privateFile)
    if err != nil {
        return nil, err
    }
    block, rest = pem.Decode(data)
    if block == nil {
        return nil, err
    }
    privateKey, err = x509.ParsePKCS1PrivateKey(block.Bytes)
    if err != nil {
        return nil, err
    }
    return rsa.DecryptPKCS1v15(rand.Reader, privateKey, src)
}

对称加密算法（DES）

简介：加密和解密都使用的是同一个长度为64的密钥，实际上只用到了其中的56位，密钥中的第8、16...64位用来作奇偶校验。DES算法的安全性很高，目前除了穷举搜索破解外， 尚无更好的的办法来破解。其密钥长度越长，破解难度就越大。

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

func ZeroUnPadding(origData []byte) []byte {
    return bytes.TrimFunc(origData, func(r rune) bool {
        return r == rune(0)
    })
}

func DesEncrypt(text string, key []byte) (string, error) {
    data = []byte(text)
    blockDes, err = des.NewCipher(key)
    if err != nil {
        return "", err
    }
    bs = blockDes.BlockSize()
    data = ZeroPadding(data, bs)
    if len(data)%bs != 0 {
        return "", errors.New("Need a multiple of the blocksize")
    }
    out := make([]byte, len(data))
    dst := out
    for len(data) > 0 {
        blockDes.Encrypt(dst, data[:bs])
        data = data[bs:]
        dst = dst[bs:]
    }
    return hex.EncodeToString(out), nil
}

func DesDecrypt(decrypted string, key []byte) (string, error) {
    data, err = hex.DecodeString(decrypted)
    if err != nil {
        return "", nil
    }
    blockDes, err = des.NewCipher(key)
    if err != nil {
        return "", err
    }
    out := make([]byte, len(data))
    dst := out
    bs = blockDes.BlockSize()
    if len(data)%bs != 0 {
        return "", errors.New("crypto/cipher: input not full blocks")
    }
    for len(data) > 0 {
        blockDes.Decrypt(dst, data[:bs])
        data = data[bs:]
        dst = dst[bs:]
    }
    out = ZeroUnPadding(out)
    return string(out), nil
}