1. Golang加密系列之AES

2. Golang加密系列之RSA
   

Golang加密系列的最后一篇，嗯，RSA涉及的概念太多，弄了好久才搞清楚。。。

代码的结构如下图

PS:StarUML这玩意在Mac上所有连到Interface的线都变成直线了...我很惆怅...

定义一个对外开放的接口

packagersa
 
import"crypto"
 
typeCipherinterface{
Encrypt(plaintext[]byte)([]byte,error)
Decrypt(ciphertext[]byte)([]byte,error)
Sign(src[]byte,hashcrypto.Hash)([]byte,error)
Verify(src[]byte,sign[]byte,hashcrypto.Hash)error
}

RSA也是一个块加密算法，总是在一个固定大小的块(block)上进行操作。但跟AES等不同的是，RSA 的block size是跟key length 以及所使用的填充模式有关的。填充方式有以下几种。

1、RSA_PKCS1_PADDING 填充模式，最常用的模式。

输入block长度 :block size比RSA 钥模长(modulus) 短至少11个字节,也就是RSA_size(rsa) – 11

输出结果长度: 和modulus一样长

例如，对于1024bit的密钥，blockSize = 1024/8 – 11 = 117 字节

2、RSA_PKCS1_OAEP_PADDING

输入block长度:RSA_size(rsa) – 41

输出结果长度 : 和modulus一样长

3、RSA_NO_PADDING

不填充

解密的时候，如果密文长度过长，也需要切分成多个块进行解密，block size 和 key length 是相等的。

这里仅支持了第一种填充方式。

packagersa
 
funcpkcs1Padding(src[]byte,keySizeint)[][]byte{
 
srcSize:=len(src)
 
blockSize:=keySize-11
 
varv[][]byte
 
ifsrcSize<=blockSize{
v=append(v,src)
}else{
groups:=len(src)/blockSize
fori:=0;i<groups;i++{
block:=src[:blockSize]
 
v=append(v,block)
src=src[blockSize:]
 
iflen(src)<blockSize{
v=append(v,src)
}
}
}
returnv
}
 
funcunPadding(src[]byte,keySizeint)[][]byte{
 
srcSize:=len(src)
 
blockSize:=keySize
 
varv[][]byte
 
ifsrcSize==blockSize{
v=append(v,block)
src=src[blockSize:]
}
}
returnv
}

定义私有的pkcsClient ，实现Cipher接口， PKCS格式的私钥都使用这个client

packagersa
 
import(
"bytes"
"crypto"
"crypto/rand"
"crypto/rsa"
)
 
typepkcsClientstruct{
privateKey*rsa.PrivateKey
publicKey*rsa.PublicKey
}
 
func(this*pkcsClient)Encrypt(plaintext[]byte)([]byte,error){
 
blocks:=pkcs1Padding(plaintext,this.publicKey.N.BitLen()/8)
 
buffer:=bytes.Buffer{}
for_,block:=rangeblocks{
ciphertextPart,err:=rsa.EncryptPKCS1v15(rand.Reader,this.publicKey,block)
iferr!=nil{
returnnil,err
}
buffer.Write(ciphertextPart)
}
 
returnbuffer.Bytes(),nil
}
 
func(this*pkcsClient)Decrypt(ciphertext[]byte)([]byte,error){
 
ciphertextBlocks:=unPadding(ciphertext,this.privateKey.N.BitLen()/8)
 
buffer:=bytes.Buffer{}
for_,ciphertextBlock:=rangeciphertextBlocks{
plaintextBlock,err:=rsa.DecryptPKCS1v15(rand.Reader,this.privateKey,ciphertextBlock)
iferr!=nil{
returnnil,err
}
buffer.Write(plaintextBlock)
}
 
returnbuffer.Bytes(),nil
}
 
func(this*pkcsClient)Sign(src[]byte,error){
h:=hash.New()
h.Write(src)
hashed:=h.Sum(nil)
returnrsa.SignPKCS1v15(rand.Reader,hash,hashed)
}
 
func(this*pkcsClient)Verify(src[]byte,hashcrypto.Hash)error{
h:=hash.New()
h.Write(src)
hashed:=h.Sum(nil)
returnrsa.VerifyPKCS1v15(this.publicKey,hashed,sign)
}

将私钥类型定义成枚举类型

packageprivatekey
 
typeTypeint64
 
const(
PKCS1Type=iota
PKCS8
)

定义一个New/NewDefault函数，用于创建client

packagersa
 
import(
"crypto/rsa"
"crypto/x509"
"encoding/pem"
"errors"
"github.com/89hmdys/toast/rsa/privatekey"
)
 
//默认客户端，pkcs8私钥格式，pem编码
funcNewDefault(privateKey,publicKeystring)(Cipher,error){
blockPri,_:=pem.Decode([]byte(privateKey))
ifblockPri==nil{
returnnil,errors.New("privatekeyerror")
}
 
blockPub,_:=pem.Decode([]byte(publicKey))
ifblockPub==nil{
returnnil,errors.New("publickeyerror")
}
 
returnNew(blockPri.Bytes,blockPub.Bytes,privatekey.PKCS8)
}
 
funcNew(privateKey,publicKey[]byte,privateKeyTypeprivatekey.Type)(Cipher,error){
 
priKey,err:=genPriKey(privateKey,privateKeyType)
iferr!=nil{
returnnil,err
}
pubKey,err:=genPubKey(publicKey)
iferr!=nil{
returnnil,err
}
return&pkcsClient{privateKey:priKey,publicKey:pubKey},nil
}
 
funcgenPubKey(publicKey[]byte)(*rsa.PublicKey,error){
pub,err:=x509.ParsePKIXPublicKey(publicKey)
iferr!=nil{
returnnil,err
}
returnpub.(*rsa.PublicKey),nil
}
 
funcgenPriKey(privateKey[]byte,privateKeyTypeprivatekey.Type)(*rsa.PrivateKey,error){
varpriKey*rsa.PrivateKey
varerrerror
switchprivateKeyType{
caseprivatekey.PKCS1:
{
priKey,err=x509.ParsePKCS1PrivateKey([]byte(privateKey))
iferr!=nil{
returnnil,err
}
}
caseprivatekey.PKCS8:
{
prkI,err:=x509.ParsePKCS8PrivateKey([]byte(privateKey))
iferr!=nil{
returnnil,err
}
priKey=prkI.(*rsa.PrivateKey)
}
default:
{
returnnil,errors.New("unsupportprivatekeytype")
}
}
returnpriKey,nil
}

最后，看看如何使用上面的代码来进行加密/解密，签名验签

packagersa_test
 
import(
"crypto"
"encoding/base64"
"encoding/hex"
"fmt"
"testing"
"toast/rsa"
)
 
varcipherrsa.Cipher
 
funcinit(){
client,err:=rsa.NewDefault(`-----BEGINPRIVATEKEY-----
私钥信息
-----ENDPRIVATEKEY-----`,`-----BEGINPUBLICKEY-----
公钥信息
-----ENDPUBLICKEY-----`)
 
iferr!=nil{
fmt.Println(err)
}
 
cipher=client
}
 
funcTest_DefaultClient(t*testing.T){
 
cp,err:=cipher.Encrypt([]byte("测试加密解密"))
iferr!=nil{
t.Error(err)
}
cpStr:=base64.URLEncoding.EncodeToString(cp)
 
fmt.Println(cpStr)
 
ppBy,err:=base64.URLEncoding.DecodeString(cpStr)
iferr!=nil{
t.Error(err)
}
pp,err:=cipher.Decrypt(ppBy)
 
fmt.Println(string(pp))
}
 
funcTest_Sign_DefaultClient(t*testing.T){
 
src:="测试签名验签"
 
signBytes,err:=cipher.Sign([]byte(src),crypto.SHA256)
iferr!=nil{
t.Error(err)
}
sign:=hex.EncodeToString(signBytes)
fmt.Println(sign)
 
signB,err:=hex.DecodeString(sign)
 
errV:=cipher.Verify([]byte(src),signB,crypto.SHA256)
iferrV!=nil{
t.Error(errV)
}
fmt.Println("verifysuccess")
}

关于RSA相关的一些概念，参见我的另一篇博客.pem引发的血案

这里还有一个已经编写好的AES/RSA加解密的包，可以直接引用，github地址：https://github.com/89hmdys/toast

2月14日补充，

近期公司对接了一个保险平台，对数据进行RSA加密的时候发现当待加密数据长度超过了秘钥长度时，会报错（比如生成了1024bit/128byte的秘钥，那么待加密的数据长度只能是<=128byte，而输出的数据长度是和秘钥长度相等的）

找了些资料，发现rsa加密如果数据过长的时候，需要对数据进行分片，根据所选择的填充方式的不同，每片的数据长度也不一样。例如选择PKCS1填充方式的时候，数据长度=秘钥长度-MIN(11)。