Golang加密方法大全

发表于 | 分类于

各种加密方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
package secret

import (
    "appback/src/logger"
    "bytes"
    "crypto/aes"
    "crypto/cipher"
    "crypto/hmac"
    "crypto/md5"
    "crypto/rand"
    "crypto/rsa"
    "crypto/sha1"
    "crypto/sha256"
    "crypto/sha512"
    "crypto/x509"
    "encoding/base64"
    "encoding/hex"
    "encoding/pem"
    "fmt"
    "strings"
)

// md5验证
func MD5Str(src string) string {
    h := md5.New()
    h.Write([]byte(src)) // 需要加密的字符串为
    // fmt.Printf("%s\n", hex.EncodeToString(h.Sum(nil))) // 输出加密结果
    return hex.EncodeToString(h.Sum(nil))
}

// hmacsha256验证
func HMAC_SHA256(src, key string) string {
    m := hmac.New(sha256.New, []byte(key))
    m.Write([]byte(src))
    return hex.EncodeToString(m.Sum(nil))
}

// hmacsha512验证
func HMAC_SHA512(src, key string) string {
    m := hmac.New(sha512.New, []byte(key))
    m.Write([]byte(src))
    return hex.EncodeToString(m.Sum(nil))
}

func HMAC_SHA1(src, key string) string {
    m := hmac.New(sha1.New, []byte(key))
    m.Write([]byte(src))
    return hex.EncodeToString(m.Sum(nil))
}

// sha256验证
func SHA256Str(src string) string {
    h := sha256.New()
    h.Write([]byte(src)) // 需要加密的字符串为
    // fmt.Printf("%s\n", hex.EncodeToString(h.Sum(nil))) // 输出加密结果
    return hex.EncodeToString(h.Sum(nil))
}

// sha512验证
func SHA512Str(src string) string {
    h := sha512.New()
    h.Write([]byte(src)) // 需要加密的字符串为
    // fmt.Printf("%s\n", hex.EncodeToString(h.Sum(nil))) // 输出加密结果
    return hex.EncodeToString(h.Sum(nil))
}

// base编码
func BASE64EncodeStr(src string) string {
    return string(base64.StdEncoding.EncodeToString([]byte(src)))
}

// base解码
func BASE64DecodeStr(src string) string {
    a, err := base64.StdEncoding.DecodeString(src)
    if err != nil {
        return ""
    }
    return string(a)
}

var ivspec = []byte("0000000000000000")

func AESEncodeStr(src, key string) string {
    block, err := aes.NewCipher([]byte(key))
    if err != nil {
        fmt.Println("key error1", err)
    }
    if src == "" {
        fmt.Println("plain content empty")
    }
    ecb := cipher.NewCBCEncrypter(block, ivspec)
    content := []byte(src)
    content = PKCS5Padding(content, block.BlockSize())
    crypted := make([]byte, len(content))
    ecb.CryptBlocks(crypted, content)
    return hex.EncodeToString(crypted)
}

func AESDecodeStr(crypt, key string) string {
    crypted, err := hex.DecodeString(strings.ToLower(crypt))
    if err != nil || len(crypted) == 0 {
        fmt.Println("plain content empty")
    }
    block, err := aes.NewCipher([]byte(key))
    if err != nil {
        fmt.Println("key error1", err)
    }
    ecb := cipher.NewCBCDecrypter(block, ivspec)
    decrypted := make([]byte, len(crypted))
    ecb.CryptBlocks(decrypted, crypted)

    return string(PKCS5Trimming(decrypted))
}

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

func PKCS5Trimming(encrypt []byte) []byte {
    padding := encrypt[len(encrypt)-1]
    return encrypt[:len(encrypt)-int(padding)]
}

func RsaEncrypt(src, key string) string {
    block, _ := pem.Decode([]byte(key))
    if block == nil {
        return ""
    }

    pubInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
    if err != nil {
        logger.SysLogger.Err(err.Error())
        return ""
    }

    pub := pubInterface.(*rsa.PublicKey)

    crypted, err := rsa.EncryptPKCS1v15(rand.Reader, pub, []byte(src))
    if err != nil {
        logger.SysLogger.Err(err.Error())
        return ""
    }

    return hex.EncodeToString(crypted)
}