目录
AES算法
package main
import (
"bytes"
"fmt"
"crypto/aes"
"crypto/cipher"
"encoding/base32"
)
func ZeroPadding(cipherText []byte, blocksize int) []byte {
padding := blocksize - len(cipherText) % blocksize
padText := bytes.Repeat([]byte{0}, padding)
return append(cipherText, padText...)
}
func DeleZeroPadding(origData []byte) []byte {
return bytes.TrimRightFunc(origData, func(r rune) bool {
return r == rune(0)
})
}
func AesEncrypt(origData, key []byte)([]byte, error) {
block, err:=aes.NewCipher(key)
if err != nil {
return nil, err
}
blockSize := block.BlockSize()
origData = ZeroPadding(origData, blockSize)
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)
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"
key:=[]byte("1234567891234567")
ssCryped, aesEncryptErr := AesEncrypt([]byte(ss), key)
fmt.Println(string(ssCryped), aesEncryptErr)
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"
)
func ZeroPadding(cipherText []byte, blocksize int) []byte {
padding := blocksize - len(cipherText) % blocksize
padText := bytes.Repeat([]byte{0}, padding)
return append(cipherText, padText...)
}
func DeleZeroPadding(origData []byte) []byte {
return bytes.TrimRightFunc(origData, func(r rune) bool {
return r == rune(0)
})
}
func DesEncrypt(origData, key []byte)([]byte, error) {
block, err:=des.NewCipher(key)
if err != nil {
return nil, err
}
blockSize := block.BlockSize()
origData = ZeroPadding(origData, blockSize)
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)
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"
key:=[]byte("12345678")
ssCryped, aesEncryptErr := DesEncrypt([]byte(ss), key)
fmt.Println(string(ssCryped), aesEncryptErr)
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"
)
func ZeroPadding(cipherText []byte, blocksize int) []byte {
padding := blocksize - len(cipherText) % blocksize
padText := bytes.Repeat([]byte{0}, padding)
return append(cipherText, padText...)
}
func DeleZeroPadding(origData []byte) []byte {
return bytes.TrimRightFunc(origData, func(r rune) bool {
return r == rune(0)
})
}
func DesEncrypt3(origData, key []byte)([]byte, error) {
block, err:=des.NewTripleDESCipher(key)
if err != nil {
return nil, err
}
blockSize := block.BlockSize()
origData = ZeroPadding(origData, blockSize)
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)
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"
key:=[]byte("123456781234567812345678")
ssCryped, aesEncryptErr := DesEncrypt3([]byte(ss), key)
fmt.Println(string(ssCryped), aesEncryptErr)
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"
)
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)
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, err:=x509.MarshalPKIXPublicKey(publicKey)
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-----
`)
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)
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, err:=x509.MarshalPKIXPublicKey(publicKey)
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.")
}
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.")
}
priInterface, err := x509.ParsePKCS1PrivateKey(block.Bytes)
if err != nil {
return nil, err
}
return rsa.DecryptPKCS1v15(rand.Reader, priInterface, ciphertext)
}
func main() {
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))
}