RSA加密解密（无数据大小限制go实现）

RSA加解密中必须考虑到的密钥长度、明文长度和密文长度问题。明文长度需要小于密钥长度，而密文长度则等于密钥长度。因此当加密内容长度大于密钥长度时，有效的RSA加解密就需要对内容进行分段。

这是因为，RSA算法本身要求加密内容也就是明文长度m必须0<m<密钥长度n。如果小于这个长度就需要进行padding，因为如果没有padding，用户无法确分解密后内容的真实长度，字符串之类的内容问题还不大，以0作为结束符，但对二进制数据就很难理解，因为不确定后面的0是内容还是内容结束符。而只要用到padding，那么就要占用实际的明文长度，于是实际明文长度需要减去padding字节长度。我们一般使用的padding标准有NoPPadding、OAEPPadding、PKCS1Padding等，其中PKCS#1建议的padding就占用了11个字节。

这样，对于1024长度的密钥。128字节（1024bits）-减去11字节正好是117字节，但对于RSA加密来讲，padding也是参与加密的，所以，依然按照1024bits去理解，但实际的明文只有117字节了。

Go实现

1. package xrsa
   

2. 
   

3. import (
   

4.     "encoding/pem"
   

5.     "encoding/base64"
   

6.     "crypto/x509"
   

7.     "crypto/rsa"
   

8.     "crypto/rand"
   

9.     "errors"
   

10.     "crypto"
    

11.     "io"
    

12.     "bytes"
    

13.     "encoding/asn1"
    

14. )
    

15. 
    

16. const (
    

17.     CHAR_SET = "UTF-8"
    

18.     BASE_64_FORMAT = "UrlSafeNoPadding"
    

19.     RSA_ALGORITHM_KEY_TYPE = "PKCS8"
    

20.     RSA_ALGORITHM_SIGN = crypto.SHA256
    

21. )
    

22. 
    

23. type XRsa struct {
    

24.     publicKey *rsa.PublicKey
    

25.     privateKey *rsa.PrivateKey
    

26. }
    

27. 
    

28. // 生成密钥对
    

29. func CreateKeys(publicKeyWriter, privateKeyWriter io.Writer, keyLength int) error {
    

30.     // 生成私钥文件
    

31.     privateKey, err := rsa.GenerateKey(rand.Reader, keyLength)
    

32.     if err != nil {
    

33.         return err
    

34.     }
    

35.     derStream := MarshalPKCS8PrivateKey(privateKey)
    

36.     block := &pem.Block{
    

37.         Type:  "PRIVATE KEY",
    

38.         Bytes: derStream,
    

39.     }
    

40.     err = pem.Encode(privateKeyWriter, block)
    

41.     if err != nil {
    

42.         return err
    

43.     }
    

44. 
    

45.     // 生成公钥文件
    

46.     publicKey := &privateKey.PublicKey
    

47.     derPkix, err := x509.MarshalPKIXPublicKey(publicKey)
    

48.     if err != nil {
    

49.         return err
    

50.     }
    

51.     block = &pem.Block{
    

52.         Type:  "PUBLIC KEY",
    

53.         Bytes: derPkix,
    

54.     }
    

55.     err = pem.Encode(publicKeyWriter, block)
    

56.     if err != nil {
    

57.         return err
    

58.     }
    

59. 
    

60.     return nil
    

61. }
    

62. 
    

63. func NewXRsa(publicKey []byte, privateKey []byte) (*XRsa, error) {
    

64.     block, _ := pem.Decode(publicKey)
    

65.     if block == nil {
    

66.         return nil, errors.New("public key error")
    

67.     }
    

68.     pubInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
    

69.     if err != nil {
    

70.         return nil, err
    

71.     }
    

72.     pub := pubInterface.(*rsa.PublicKey)
    

73. 
    

74.     block, _ = pem.Decode(privateKey)
    

75.     if block == nil {
    

76.         return nil, errors.New("private key error!")
    

77.     }
    

78.     priv, err := x509.ParsePKCS8PrivateKey(block.Bytes)
    

79.     if err != nil {
    

80.         return nil, err
    

81.     }
    

82. 
    

83.     pri, ok := priv.(*rsa.PrivateKey)
    

84.     if ok {
    

85.         return &XRsa {
    

86.             publicKey: pub,
    

87.             privateKey: pri,
    

88.         }, nil
    

89.     } else {
    

90.         return nil, errors.New("private key not supported")
    

91.     }
    

92. }
    

93. 
    

94. // 公钥加密
    

95. func (r *XRsa) PublicEncrypt(data string) (string, error) {
    

96.     partLen := r.publicKey.N.BitLen() / 8 - 11
    

97.     chunks := split([]byte(data), partLen)
    

98. 
    

99.     buffer := bytes.NewBufferString("")
    

100.     for _, chunk := range chunks {
     

101.         bytes, err := rsa.EncryptPKCS1v15(rand.Reader, r.publicKey, chunk)
     

102.         if err != nil {
     

103.             return "", err
     

104.         }
     

105.         buffer.Write(bytes)
     

106.     }
     

107. 
     

108.     return base64.RawURLEncoding.EncodeToString(buffer.Bytes()), nil
     

109. }
     

110. 
     

111. // 私钥解密
     

112. func (r *XRsa) PrivateDecrypt(encrypted string) (string, error) {
     

113.     partLen := r.publicKey.N.BitLen() / 8
     

114.     raw, err := base64.RawURLEncoding.DecodeString(encrypted)
     

115.     chunks := split([]byte(raw), partLen)
     

116. 
     

117.     buffer := bytes.NewBufferString("")
     

118.     for _, chunk := range chunks {
     

119.         decrypted, err := rsa.DecryptPKCS1v15(rand.Reader, r.privateKey, chunk)
     

120.         if err != nil {
     

121.             return "", err
     

122.         }
     

123.         buffer.Write(decrypted)
     

124.     }
     

125. 
     

126.     return buffer.String(), err
     

127. }
     

128. 
     

129. // 数据加签
     

130. func (r *XRsa) Sign(data string) (string, error) {
     

131.     h := RSA_ALGORITHM_SIGN.New()
     

132.     h.Write([]byte(data))
     

133.     hashed := h.Sum(nil)
     

134. 
     

135.     sign, err := rsa.SignPKCS1v15(rand.Reader, r.privateKey, RSA_ALGORITHM_SIGN, hashed)
     

136.     if err != nil {
     

137.         return "", err
     

138.     }
     

139.     return base64.RawURLEncoding.EncodeToString(sign), err
     

140. }
     

141. 
     

142. // 数据验签
     

143. func (r *XRsa) Verify(data string, sign string) error {
     

144.     h := RSA_ALGORITHM_SIGN.New()
     

145.     h.Write([]byte(data))
     

146.     hashed := h.Sum(nil)
     

147. 
     

148.     decodedSign, err := base64.RawURLEncoding.DecodeString(sign)
     

149.     if err != nil {
     

150.         return err
     

151.     }
     

152. 
     

153.     return rsa.VerifyPKCS1v15(r.publicKey, RSA_ALGORITHM_SIGN, hashed, decodedSign)
     

154. }
     

155. 
     

156. func MarshalPKCS8PrivateKey(key *rsa.PrivateKey) []byte {
     

157.     info := struct {
     

158.         Version             int
     

159.         PrivateKeyAlgorithm []asn1.ObjectIdentifier
     

160.         PrivateKey          []byte
     

161.     }{}
     

162.     info.Version = 0
     

163.     info.PrivateKeyAlgorithm = make([]asn1.ObjectIdentifier, 1)
     

164.     info.PrivateKeyAlgorithm[0] = asn1.ObjectIdentifier{1, 2, 840, 113549, 1, 1, 1}
     

165.     info.PrivateKey = x509.MarshalPKCS1PrivateKey(key)
     

166. 
     

167.     k, _ := asn1.Marshal(info)
     

168.     return k
     

169. }
     

170. 
     

171. func split(buf []byte, lim int) [][]byte {
     

172.     var chunk []byte
     

173.     chunks := make([][]byte, 0, len(buf)/lim+1)
     

174.     for len(buf) >= lim {
     

175.         chunk, buf = buf[:lim], buf[lim:]
     

176.         chunks = append(chunks, chunk)
     

177.     }
     

178.     if len(buf) > 0 {
     

179.         chunks = append(chunks, buf[:len(buf)])
     

180.     }
     

181.     return chunks
     

182. }