GO语言入门9---AES、DES、RSA算法

最新推荐文章于 2024-05-17 07:32:05 发布
最新推荐文章于 2024-05-17 07:32:05 发布
阅读量555 收藏
点赞数
分类专栏： GO语言快速入门 文章标签： GO GO语言 区块链 物联网 未来技术
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zengraoli/article/details/82262001
版权

目录

AES算法

package main // 固定
import (
    "bytes"
    "fmt"
    "crypto/aes"
    "crypto/cipher"
    "encoding/base32"
)

// 往字符串后面填充0
func ZeroPadding(cipherText []byte, blocksize int) []byte {
    padding := blocksize - len(cipherText) % blocksize
    padText := bytes.Repeat([]byte{0}, padding)
    return append(cipherText, padText...) // 往slice后添加元素
}

// 删除填充数据
func DeleZeroPadding(origData []byte) []byte {
    return bytes.TrimRightFunc(origData, func(r rune) bool {
        return r == rune(0)
    })
}

// 使用加密算法的步骤
// 1、根据密码创建一个cipher
// 2、得到加密块的大小
// 3、按照块的大小把填充原始数据
// 4、用block和key创建加密算法
// 5、用CryptBlocks按照块的大小进行加密
func AesEncrypt(origData, key []byte)([]byte, error) {
    block, err:=aes.NewCipher(key) // 根据key创建密码
    if err != nil {
        return nil, err
    }
    blockSize := block.BlockSize() // 得到加密块的大小
    origData = ZeroPadding(origData, blockSize) // 填充0
    blockMode:=cipher.NewCBCEncrypter(block, key[:blockSize]) // 创建加密算法
    cryped:=make([]byte, len(origData)) // 生成存放加密数据的空间
    blockMode.CryptBlocks(cryped, origData) // 按照块大小加密
    return cryped,nil
}

func AesDecrypt(cryptedData, key []byte)([]byte, error) {
    block, err:=aes.NewCipher(key) // 根据key创建密码
    if err != nil {
        return nil, err
    }
    blockSize := block.BlockSize() // 得到加密块的大小
    blockMode:=cipher.NewCBCDecrypter(block, key[:blockSize]) // 创建解密算法
    origData:=make([]byte, len(cryptedData)) // 创建存放解密串的空间
    blockMode.CryptBlocks(origData, cryptedData) // 解密
    cryptedData=DeleZeroPadding(origData) // 删除填充数据
    return cryptedData, nil
}

func main() { // 大括号的位置是固定的
    ss := "zengraoli"
    // AES128 ,16,24,32,AES128,192,256
    key:=[]byte("1234567891234567")
    // 加密
    ssCryped, aesEncryptErr := AesEncrypt([]byte(ss), key)
    fmt.Println(string(ssCryped), aesEncryptErr)
    // 加密的数据用base64编码
    fmt.Println(base32.StdEncoding.EncodeToString(ssCryped))

    origData, aesDecryptErr := AesDecrypt([]byte(ssCryped), key)
    fmt.Println(string(origData), aesDecryptErr)
}

DES算法

普通版的DES算法

package main // 固定
import (
    "bytes"
    "fmt"
    "crypto/cipher"
    "encoding/base32"
    "crypto/des"
)

// 往字符串后面填充0
func ZeroPadding(cipherText []byte, blocksize int) []byte {
    padding := blocksize - len(cipherText) % blocksize
    padText := bytes.Repeat([]byte{0}, padding)
    return append(cipherText, padText...) // 往slice后添加元素
}

// 删除填充数据
func DeleZeroPadding(origData []byte) []byte {
    return bytes.TrimRightFunc(origData, func(r rune) bool {
        return r == rune(0)
    })
}

// 使用加密算法的步骤
// 1、根据密码创建一个cipher
// 2、得到加密块的大小
// 3、按照块的大小把填充原始数据
// 4、用block和key创建加密算法
// 5、用CryptBlocks按照块的大小进行加密
func DesEncrypt(origData, key []byte)([]byte, error) {
    block, err:=des.NewCipher(key) // 根据key创建密码,和aes不同之处仅仅在这里
    if err != nil {
        return nil, err
    }
    blockSize := block.BlockSize() // 得到加密块的大小
    origData = ZeroPadding(origData, blockSize) // 填充0
    blockMode:=cipher.NewCBCEncrypter(block, key[:blockSize]) // 创建加密算法
    cryped:=make([]byte, len(origData)) // 生成存放加密数据的空间
    blockMode.CryptBlocks(cryped, origData) // 按照块大小加密
    return cryped,nil
}

func DesDecrypt(cryptedData, key []byte)([]byte, error) {
    block, err:=des.NewCipher(key) // 根据key创建密码
    if err != nil {
        return nil, err
    }
    blockSize := block.BlockSize() // 得到加密块的大小
    blockMode:=cipher.NewCBCDecrypter(block, key[:blockSize]) // 创建解密算法
    origData:=make([]byte, len(cryptedData)) // 创建存放解密串的空间
    blockMode.CryptBlocks(origData, cryptedData) // 解密
    cryptedData=DeleZeroPadding(origData) // 删除填充数据
    return cryptedData, nil
}

func main() { // 大括号的位置是固定的
    ss := "zengraoli"
    // DES key的长度为8
    key:=[]byte("12345678")
    // 加密
    ssCryped, aesEncryptErr := DesEncrypt([]byte(ss), key)
    fmt.Println(string(ssCryped), aesEncryptErr)
    // 加密的数据用base64编码
    fmt.Println(base32.StdEncoding.EncodeToString(ssCryped))

    origData, aesDecryptErr := DesDecrypt([]byte(ssCryped), key)
    fmt.Println(string(origData), aesDecryptErr)
}

加强版的DES算法

package main // 固定
import (
    "bytes"
    "fmt"
    "crypto/cipher"
    "encoding/base32"
    "crypto/des"
)

// 往字符串后面填充0
func ZeroPadding(cipherText []byte, blocksize int) []byte {
    padding := blocksize - len(cipherText) % blocksize
    padText := bytes.Repeat([]byte{0}, padding)
    return append(cipherText, padText...) // 往slice后添加元素
}

// 删除填充数据
func DeleZeroPadding(origData []byte) []byte {
    return bytes.TrimRightFunc(origData, func(r rune) bool {
        return r == rune(0)
    })
}

// 使用加密算法的步骤
// 1、根据密码创建一个cipher
// 2、得到加密块的大小
// 3、按照块的大小把填充原始数据
// 4、用block和key创建加密算法
// 5、用CryptBlocks按照块的大小进行加密
func DesEncrypt3(origData, key []byte)([]byte, error) {
    block, err:=des.NewTripleDESCipher(key) // 根据key创建密码,NewTripleDESCipher和普通版本的强度不同
    if err != nil {
        return nil, err
    }
    blockSize := block.BlockSize() // 得到加密块的大小
    origData = ZeroPadding(origData, blockSize) // 填充0
    blockMode:=cipher.NewCBCEncrypter(block, key[:blockSize]) // 创建加密算法
    cryped:=make([]byte, len(origData)) // 生成存放加密数据的空间
    blockMode.CryptBlocks(cryped, origData) // 按照块大小加密
    return cryped,nil
}

func DesDecrypt3(cryptedData, key []byte)([]byte, error) {
    block, err:=des.NewTripleDESCipher(key) // 根据key创建密码
    if err != nil {
        return nil, err
    }
    blockSize := block.BlockSize() // 得到加密块的大小
    blockMode:=cipher.NewCBCDecrypter(block, key[:blockSize]) // 创建解密算法
    origData:=make([]byte, len(cryptedData)) // 创建存放解密串的空间
    blockMode.CryptBlocks(origData, cryptedData) // 解密
    cryptedData=DeleZeroPadding(origData) // 删除填充数据
    return cryptedData, nil
}

func main() { // 大括号的位置是固定的
    ss := "zengraoli"
    // DES3 key的长度为24
    key:=[]byte("123456781234567812345678")
    // 加密
    ssCryped, aesEncryptErr := DesEncrypt3([]byte(ss), key)
    fmt.Println(string(ssCryped), aesEncryptErr)
    // 加密的数据用base64编码
    fmt.Println(base32.StdEncoding.EncodeToString(ssCryped))

    origData, aesDecryptErr := DesDecrypt3([]byte(ssCryped), key)
    fmt.Println(string(origData), aesDecryptErr)
}

RSA算法

RSA依赖于公钥和私钥，所以首先得到两个函数用来生成公钥和私钥

package main // 固定
import (
    "fmt"
    "crypto/rsa"
    "crypto/rand"
    "crypto/x509"
    "encoding/pem"
    "os"
    "flag"
)

// 传入生成key的种子
func GenRsaKey(bits int) error {
     // 传入随机数和种子
    privateKey, err := rsa.GenerateKey(rand.Reader, bits);
    if  err != nil {
        fmt.Println("私钥生成失败")
        return err
    }
    fmt.Println(privateKey)
    derStream:=x509.MarshalPKCS1PrivateKey(privateKey) // 处理privateKey
    block:=&pem.Block{
        Type:"RSA PRIVATE KEY",
        Bytes:derStream,
    }
    privateFile,err:=os.Create("myprivate.pem")
    if  err != nil {
        fmt.Println("私钥生成失败")
        return err
    }
    defer privateFile.Close()
    err = pem.Encode(privateFile, block) // 写入到文件
    if err != nil{
        fmt.Println("私钥生成失败")
        return err
    }

    // 生成公钥
    publicKey:=&privateKey.PublicKey
    fmt.Println(publicKey)//打印公钥
    //derpkix:=x509.MarshalPKCS1PublicKey(publicKey) // MarshalPKCS1PublicKey converts an RSA public key to PKCS#1, ASN.1 DER form.
    derpkix, err:=x509.MarshalPKIXPublicKey(publicKey) // 处理publicKey,MarshalPKIXPublicKey将公钥序列化为 DER 编码的 PKIX 格式。
    if err != nil{
        fmt.Println("公钥生成失败")
        return err
    }
    block=&pem.Block{
        Type:"RSA PUBLIC KEY",
        Bytes:derpkix,
    }
    publicFile, err:=os.Create("mypublic.pem")
    if  err != nil {
        fmt.Println("公钥生成失败")
        return err
    }
    defer publicFile.Close()
    err = pem.Encode(publicFile, block) // 写入到文件
    if err != nil{
        fmt.Println("公钥生成失败")
        return err
    }

    return nil
}

func main() { // 大括号的位置是固定的
    var bits int
    flag.IntVar(&bits, "b", 1024, "密码长度默认为1024")
    if err := GenRsaKey(bits);err != nil {
        fmt.Println("密钥文件生成失败")
    } else {
        fmt.Println("密钥文件生成成功")
    }
}

利用生成出来的公钥和私钥进行数据的加密

package main // 固定
import (
    "fmt"
    "crypto/rsa"
    "crypto/rand"
    "crypto/x509"
    "encoding/pem"
    "os"
    "errors"
    "encoding/base64"
)

var privateKey=[]byte(`
-----BEGIN RSA PRIVATE KEY-----
MIICXQIBAAKBgQDImW7UkM5QdNH1WTz1aGZw7uLJsdzQtzw6hWFfzcx1xCDS0u/Y
TRWWaA5cbitBXgFGzG9b8nAslISmKqyfhq+7QU/DykS7Jqy3Y6EsMlToiZhdGXkF
WWTBWZ2hz9gw+oh7H8cwnYjdB+pn0gol1wGFBkuxWqyitJYXSZE0MZXUjwIDAQAB
AoGBAJy6ZEFoMgnie/h5lIsY2pD50+9KLABWaZQ/iejUXh7U8eBGNmaFM4ykGDRX
TyxvSggKyibIsKPkFg/N37lz/e+nkx7eoABxVubm2gis3x5sJIyXzqSqY/EVWyLo
xY6fMk3fVQpRcrzvG9op3yWghM5cB3Mgrk/ZB0w/Rr0szuKBAkEA/iNuVuS8+ySY
55ykFbv4AhVY4OQVmds3mexdrBbzT0pHhyqQnhJ7ORcsdAaNIfxUNRHsGH7wTXwq
l023Gj4JsQJBAMoRmolb4LnDjaCCmqz8tx4VzSS/RVYaOrp944w0UJ+oxJOeHdsK
PRTgLz1UfiF/6B5pHG5ZDQTabFVgPn+TEj8CQEnqGixxqLlOop4yg9LCcdaBSPFX
xSSTiq9c/L2Ri0CTdQxOB/PBok8ve0FfqmqpDgDFbqqNOO0AYQ7Sjp+2TXECQHkL
4JImKtG9Fmsvsa6s2Jk6ICDCP6vbnJC49wW3FRD/jXqMfoAHex21SjcoFULGF2uY
NcLYr5bXrYvbUrUjigsCQQDIE8wU6vZtHFJx8eVWiTbHY4xwn0nLO0D6jrWcZJD4
E485YmBlqectmXhLkV7bPEMolgxlnpCOloxi6xC/zvSk
-----END RSA PRIVATE KEY-----
`)

var publicKey=[]byte(`
-----BEGIN RSA PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDImW7UkM5QdNH1WTz1aGZw7uLJ
sdzQtzw6hWFfzcx1xCDS0u/YTRWWaA5cbitBXgFGzG9b8nAslISmKqyfhq+7QU/D
ykS7Jqy3Y6EsMlToiZhdGXkFWWTBWZ2hz9gw+oh7H8cwnYjdB+pn0gol1wGFBkux
WqyitJYXSZE0MZXUjwIDAQAB
-----END RSA PUBLIC KEY-----
`)

// 传入生成key的种子
func GenRsaKey(bits int) error {
     // 传入随机数和种子
    privateKey, err := rsa.GenerateKey(rand.Reader, bits);
    if  err != nil {
        fmt.Println("私钥生成失败")
        return err
    }
    fmt.Println(privateKey)
    derStream:=x509.MarshalPKCS1PrivateKey(privateKey) // 处理privateKey
    block:=&pem.Block{
        Type:"RSA PRIVATE KEY",
        Bytes:derStream,
    }
    privateFile,err:=os.Create("myprivate.pem")
    if  err != nil {
        fmt.Println("私钥生成失败")
        return err
    }
    defer privateFile.Close()
    err = pem.Encode(privateFile, block) // 写入到文件
    if err != nil{
        fmt.Println("私钥生成失败")
        return err
    }

    // 生成公钥
    publicKey:=&privateKey.PublicKey
    fmt.Println(publicKey)//打印公钥
    //derpkix:=x509.MarshalPKCS1PublicKey(publicKey) // MarshalPKCS1PublicKey converts an RSA public key to PKCS#1, ASN.1 DER form.
    derpkix, err:=x509.MarshalPKIXPublicKey(publicKey) // 处理publicKey,MarshalPKIXPublicKey将公钥序列化为 DER 编码的 PKIX 格式。
    if err != nil{
        fmt.Println("公钥生成失败")
        return err
    }
    block=&pem.Block{
        Type:"RSA PUBLIC KEY",
        Bytes:derpkix,
    }
    publicFile, err:=os.Create("mypublic.pem")
    if  err != nil {
        fmt.Println("公钥生成失败")
        return err
    }
    defer publicFile.Close()
    err = pem.Encode(publicFile, block) // 写入到文件
    if err != nil{
        fmt.Println("公钥生成失败")
        return err
    }

    return nil
}


// 用公钥来加密
func RsaEncrypt(origData []byte)([]byte, error) {
    block, _:=pem.Decode(publicKey)
    if block == nil {
        return nil, errors.New("public key is bad.")
    }
    // 从公钥的bytes中解析得到.PublicKey
    pubInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
    if err != nil {
        return nil, err
    }
    pub:=pubInterface.(*rsa.PublicKey)
    return rsa.EncryptPKCS1v15(rand.Reader, pub, origData) // 加密
}

// 用私钥来解密数据
func RsaDecrypt(ciphertext []byte)([]byte, error) {
    block, _:=pem.Decode(privateKey)
    if block == nil {
        return nil, errors.New("private key is bad.")
    }
    // 从私钥的bytes中解析得到.PublicKey
    priInterface, err := x509.ParsePKCS1PrivateKey(block.Bytes)
    if err != nil {
        return nil, err
    }
    return rsa.DecryptPKCS1v15(rand.Reader, priInterface, ciphertext) // 加密
}

func main() { // 大括号的位置是固定的
    //var bits int
    //flag.IntVar(&bits, "b", 1024, "密码长度默认为1024")
    //if err := GenRsaKey(bits);err != nil {
    //  fmt.Println("密钥文件生成失败")
    //} else {
    //  fmt.Println("密钥文件生成成功")
    //}
    ss := "zengraoli"
    var encryptData, decryptData []byte
    var err error
    encryptData, err = RsaEncrypt([]byte(ss))
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println("加密后的数据", base64.StdEncoding.EncodeToString(encryptData))

    decryptData, err = RsaDecrypt([]byte(encryptData))
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println("解密后的数据", string(decryptData))
}
每天看一遍，防止恋爱&&堕落
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用Go的标准库（RSA和AES）进行穷人的CLI公钥加密-Golang开发
05-26
概述这是一个简单的示例，该示例使用标准的go库（“包含电池”）通过使用RSA的公钥密码术来加密和解密文件。 编译，构建和测试使用标准go命令，即概述这是使用标准go库（“包含电池”）通过RSA使用公钥密码术对文件进行加密和解密的简单示例。 编译，构建和测试使用标准的go命令，即go test go build生成一个名为keyz的二进制文件。 常规用法首先，使用keyz -k生成您自己的公共和私有密钥对。您的密钥对将分别保存为private.key和public.key。 请注意，该货币对与标准PEM格式兼容，即您可以
Go语言与RSA算法 —— RSA案例实现
The_Reader的博客
11-12 273
package main import ( "crypto/rsa" "crypto/rand" "crypto/x509" "encoding/pem" "os" "fmt" "encoding/hex" ) //生成私钥和公钥 //bits：私钥的长度 func RsaGenKey(bits int) error { //生成公钥和私钥 //
Go语言实现对称加密算法AES、DES、3DES和非对称加密算法RSA_golang 对称加密算法
最新发布
2401_84920056的博客
05-17 1104
消息发送方利用对方的公钥进行加密，消息接受方收到密文时使用自己的私钥进行解密。公钥和密钥生成的时候要有一种关联，要把密钥和公钥保存起来。des——CBC模式，key长度必须为24。AES-128：key长度16 字节。AES-192：key长度24 字节。AES-256：key长度32 字节。对哪一方更重要，哪一方就拿私钥。DES：支持字节长度是8。
Go语言实现对称加密算法AES、DES、3DES和非对称加密算法RSA
面向生活编程
07-10 2567
使用GO语言实现对称加密与非对称加密算法
RSA算法讲解与Go语言实例
码墨
09-19 841
一、RSA算法概述 RSA是"非对称加密算法"，非对称加密算法需要两个密钥：公开密钥（publickey）和私有密钥（privatekey）。公钥与私钥是配对的，用公钥加密的数据只有配对的私钥才能解密，反之亦然。因加解密使用两个不同的密钥，所以这种算法叫作非对称加密算法。 使用RSA加密算法流程如下： 1.消息接收方B先把公钥广播，消息发送方A保存B的公钥 2.当A需要向B发送消息时，先用B的公...
GO写的一份加密包，对称加密AES非对称加密RSA
sgsgy5的博客
11-04 1156
|版权声明：本文为博主原创文章，未经博主允许不得转载。博客地址： https://blog.csdn.net/sgsgy5 前言 ：小弟今日闲暇时间用GO语言简单的封装了几个加密函数，包括对称加密函数DES（虽然被破解很少用，但是可以作为了解），三重DES加密，AES的CBC和CTR模式（对称加密中常使用，推荐使用），非对称加密中的RSA加密解密函数，后期有时间更新椭圆曲线加密的一些内容，还...
RSA-AES-SHA1-DES.rar_DES-SHA1_aes c_des aes_des aes_rsa
09-23
在C++中，可以使用开源库如OpenSSL来实现RSA算法。 3. **SHA1（Secure Hash Algorithm 1）**：SHA1是一种哈希函数，它将任意长度的数据转化为固定长度的摘要，通常用于验证数据的完整性和一致性。SHA1已被发现存在...
AES-RSA-DES加密算法详解
08-25
网络安全中的对称加密AES、DES和非对称加密算法RSA详解
Android利用C++实现RSA-DES-AES-BASE64-MD5
11-05
1. RSA算法：RSA是一种非对称加密算法，基于大整数因子分解的难度。在Android中，C++实现RSA通常涉及以下步骤： - 生成公钥和私钥对：通过随机选择两个大素数p和q，计算n=p*q和欧拉函数φ(n)，然后选取一个e满足1φ...
网络信息安全技术DES-RSA实验报告以及源代码
05-12
在网络安全领域，DES（Data Encryption Standard）和RSA是两种广泛使用的加密算法，它们在保护数据安全、实现数据保密性方面发挥着重要作用。本实验报告主要探讨了这两种算法的原理、实现过程以及源代码分析。 DES...
Java-RSA-DES.rar_des javascript_doc_rsa_rsa des文件加密
09-24
尽管DES在当时被视为安全，但由于其密钥长度较短，现在的计算机可以相对较快地破解DES加密，因此现在通常不单独使用DES，而是采用更强大的版本如3DES（Triple DES），或者转向其他更现代的对称加密算法，如AES...
Go-AES算法详解与代码
关注网络安全、云原生安全
06-11 9736
AES 发展史 概述 AES的Go实现 func NewCipher(key []byte) (cipher.Block, error)
Go语言与AES加密算法 —— 简介、AES算法案例
The_Reader的博客
11-12 758
AES简介 高级加密标准（英语：Advanced Encryption Standard，缩写：AES），在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院（NIST）于2001年11月26日发布于FIPS PUB 197，并在2002年5月26日成...
（八）AES和RSA加解密，附GO语言AES解密代码
chantor7的博客
05-05 693
（八）AES和RSA加解密，附GO语言AES解密代码 ​ 在（学习）爬某网站时发现欸？怎么被加密了？于是… ​ 关于AES、RSA算法看这：https://blog.csdn.net/LC_Liangchao/article/details/121769279，其实当场查资料的时候，看到一篇很好很全的介绍，可惜我又没收藏保存，啊一定要养成变做变记录的习惯。 ​ AES在线解密：https://the-x.cn/zh-cn/cryptography/Aes.aspx 两篇关于某勾新升级安全策略的分析： ​ h
GO实现RSA加密
Enzo
07-25 616
什么是非对称加密 1976年以前，所有的加密方法都使用对称加密算法：加密和解密使用同一套规则。例如：甲使用密钥 A 加密，将密文传递给乙，乙仍使用密钥 A 解密。如果密钥 A 在甲传递给乙的过程中泄露，或者根据已知的几次密文和明文推导出密钥 A，则甲乙之间的通讯将毫无秘密。 1976年，两位美国计算机学家 Whitfield Diffie 和 Martin Hellman，提出了一种崭新构思，可以...
go实现rsa和aes加解密
止语的博客
03-06 978
密码学中两大经典算法，一个是对称加解密，具有代表性的是AES加解密，另一个是非对称加解密，代表性的是RSA加解密。那什么事对称和非对称呢？对称加密算法又称为传统密码算法，加密密钥和解密密钥是相同的。对称加密算法要求通信双方在开始通信前，要首先商定一个用于加密和解密的密钥。算法的安全性就依赖于这个密钥，如果这个密钥被泄露了，就意味着通信不再安全非对称加密算法是现代密码学取得的最大成就之一，也是密码学近20年来能够快速发展和推广应用的主要原因之一。
Go语言实现对称加密DES，3DES和AES算法
萌猫芭乐主人的博客
05-18 328
package main import ( "bytes" aes2 "crypto/aes" "crypto/cipher" "crypto/des" ) //填充最后一个分组的函数 //src 原始数据 //blockSize 每个分组的数据长度 func paddingText(src []byte, blockSize int) []byte { //1...
GO实现对称加密DES/3DES/AES
William Blake
01-12 404
package main import ( "bytes" "crypto/aes" "crypto/cipher" "crypto/des" "encoding/base64" "fmt" ) func main() { //DES密钥 //DES key := "12345678" //3DES //key := "abcdefgh012345671234567...
go加解密系列——AES加解密
agclqq的专栏
08-24 7500
AES是密码学中的高级加密标准（Advanced Encryption Standard，AES），又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES（Data Encryption Standard），已经被多方分析且广为全世界所使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院 （NIST）于2001年11月26日发布于FIPS PUB 197，并在2002年5月26日成为有效的标准。2006年，高级加密标准已然成为对称密钥加密中最流行的算法之一
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值