在GO中使用RSA-SHA进行签名和解码 [英] Signing and decoding with RSA-SHA in GO
本文介绍了在GO中使用RSA-SHA进行签名和解码的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！
问题描述
我试图签署一个字符串，稍后用公钥验证它。我的验证结果是空的。
包主
$ b导入（
加密
crypto / rand
crypto / rsa
crypto / sha256
crypto / x509
编码/ base64
编码/ pem
错误
fmt
io / ioutil
）
func main（）{
签名者， err：= loadPrivateKey（private.pem）;
if err！= nil {
fmt.Errorf（签名者已损坏：％v，err）
}
toSign：=日期：星期四， 05一月2012 21:31:40 GMT;
signed，err：= signer.Sign（[] byte（toSign））
if err！= nil {
fmt.Errorf（无法签名请求：％v ，err）
}
sig：= base64.StdEncoding.EncodeToString（signed）
fmt.Printf（Encoded：％v \ n，sig）
解析器，perr：= loadPublicKey（public.pem）;
if perr！= nil {
fmt.Errorf（无法登录请求：％v，err）
}
无符号，err：= parser.Unsign（signed） ;
if err！= nil {
fmt.Errorf（无法登录请求：％v，err）
}
fmt.Printf（Decrypted： ％v \ n，base64.StdEncoding.EncodeToString（unsigned））
}
// loadPrivateKey加载一个解析PEM编码的私钥文件。
func loadPublicKey（path string）（Unsigner，error）{
data，err：= ioutil.ReadFile（path）
if err！= nil {
return nil，err
}
return parsePublicKey（data）
}
// parsePublicKey分析一个PEM编码的私钥。
func parsePublicKey（pemBytes [] byte）（Unsigner，error）{
block，_：= pem.Decode（pemBytes）
if block == nil {
return nil， errors.New（ssh：no key found）
}
var rawkey interface {}
switch block.Type {
casePUBLIC KEY：
rsa，err：= x509.ParsePKIXPublicKey（block.Bytes）
if err！= nil {
return nil，err
}
rawkey = rsa
默认值：
返回nil，fmt.Errorf（ssh：不支持的键类型％q，block.Type）
}
返回newUnsignerFromKey（rawkey）
}
// loadPrivateKey加载一个解析PEM编码的私钥文件。
func loadPrivateKey（path string）（Signer，error）{
data，err：= ioutil.ReadFile（path）
if err！= nil {
return nil，err
}
返回parsePrivateKey（数据）
}
// parsePublicKey分析一个PEM编码的私钥。
func parsePrivateKey（pemBytes [] byte）（Signer，error）{
block，_：= pem.Decode（pemBytes）
if block == nil {
return nil， errors.New（ssh：no key found）
}
var rawkey interface {}
switch block.Type {
caseRSA PRIVATE KEY：
rsa，err：= x509.ParsePKCS1PrivateKey（block.Bytes）
if err！= nil {
return nil，err
}
rawkey = rsa
default：
return nil，fmt.Errorf（ssh：不支持的键类型％q，block.Type）
}
返回newSignerFromKey（rawkey）
}
//签署者可以创建签名来验证公钥。
型签署者接口{
// Sign为给定数据返回原始签名。这个方法
//会将为keytype指定的散列应用于数据。
签名（数据[]字节）（[]字节，错误）
}
//签名者可以创建签名来验证公钥。
类型Unsigner接口{
// Sign为给定数据返回原始签名。这个方法
//会将为keytype指定的散列应用于数据。
Unsign（data [] byte）（[] byte，error）
}
func newSignerFromKey（k interface {}）（$ sig $ b $ sshKey签名者
switch t：= k。（type）{
case * rsa.PrivateKey：
sshKey =& rsaPrivateKey {t}
默认值：
返回nil ，fmt.Errorf（ssh：不支持的键类型％T，k）
}
返回sshKey，零
}
func newUnsignerFromKey（k interface {} ）（Unsigner，error）{
var sshKey Unsigner
switch t：= k。（type）{
case * rsa.PublicKey：
sshKey =& rsaPublicKey {t}
default：
return nil，fmt.Errorf（ssh：不支持的键类型％T，k）
}
返回sshKey，零
}
类型rsaPublicKey结构{
* rsa.PublicKey
}
类型rsaPrivateKey结构{
* rsa.PrivateKey
}
//用rsa-sha256标志数据
func（r * rsaPrivateKey）Sign（data [] byte）（[] byte，error）{
h：= sha256.New（）
h.Write（data）
d ：= h.Sum（nil）
return rsa.SignPKCS1v15（rand.Reader，r.PrivateKey，crypto.SHA256，d）
}
//使用unsign加密数据rsa-sha256
func（r * rsaPublicKey）unsign（message [] byte）（[] byte，error）{
return rsa.EncryptPKCS1v15（rand.Reader，r.PublicKey，message）
}
private.pem看起来像这样：
----- BEGIN RSA PRIVATE KEY -----
MIICXgIBAAKBgQDCFENGw33yGihy92pDjZQhl0C36rPJj + CvfSC8 + q28hxA161QF
NUd13wuCTUcq0Qd2qsBe / 2hFyc2DCJJg0h1L78 + 6Z4UMR7EOcpfdUE9Hf3m / hs + F
UR45uBJeDK1HSFHD8bHKD6kv8FPGfJTotc + 2xjJwoYi + 1hqp1fIekaxsyQIDAQAB
AoGBAJR8ZkCUvx5kzv + utdl7T5MnordT1TvoXXJGXK7ZZ + UuvMNUCdN2QPc4sBiA
QWvLw1cSKt5DsKZ8UETpYPy8pPYnnDEz2dDYiaew9 + xEpubyeW2oH4Zx71wqBtOK
kqwrXa / pzdpiucRRjk6vE6YY7EBBs / g7uanVpGibOVAEsqH1AkEA7DkjVH28WDUg
f1nqvfn2Kj6CT7nIcE3jGJsZZ7zlZmBmHFDONMLUrXR / Zm3pR5m0tCmBqa5RK95u
412jt1dPIwJBANJT3v8pnkth48bQo / fKel6uEYyboRtA5 / uHuHkZ6FQF7OUkGogc
mSJluOdc5t6hI1VsLn0QZEjQZMEOWr + wKSMCQQCC4kXJEsHAve77oP6HtG / IiEn7
kpyUXRNvFsDE0czpJJBvL / aRFUJxuRK91jhjC68sA7NsKMGg5OXb5I5Jj36xAkEA
gIT7aFOYBFwGgQAQkWNKLvySgKbAZRTeLBacpHMuQdl1DfdntvAyqpAZ0lY0RKmW
G6aFKaqQfOXKCyWoUiVknQJAXrlgySFci / 2ueKlIE1QqIiLSZ8V8OlpFLRnb1pzI
7U1yQXnTAEFYM560yJlzUpOb1V4cScGd365tiSMvxLOvTA ==
-----结束RSA PRIVATE KEY -----
和public.pem：
----- BEGIN PUBLIC KEY -----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDCFENGw33yGihy92pDjZQhl0C3
6rPJj + CvfSC8 + q28hxA161QFNUd13wuCTUcq0Qd2qsBe / 2hFyc2DCJJg0h1L78 + 6
Z4UMR7EOcpfdUE9Hf3m / hs + FUR45uBJeDK1HSFHD8bHKD6kv8FPGfJTotc + 2xjJw
oYi + 1hqp1fIekaxsyQIDAQAB
----- END PUBLIC KEY -----
谢谢。
解决方案
代码中的问题是 Unsign 尝试编码签名，而不是用它来验证原始消息。
需要对接口进行更改并对 Unsign ：
//取消使用rsa-sha256签名验证消息
func（r * rsaPublicKey）Unsign消息[]字节，sig []字节）错误{
h：= sha256.New（）
h.Write（消息）
d：= h.Sum（nil）
return rsa.VerifyPKCS1v15（r.PublicKey，crypto.SHA256，d，sig）
}
以下是验证的操场示例： http://play.golang.org/p/bzpD7Pa9mr
为避免ioutils做了一些修改。
I'm trying to sign a string and later on verifying it with the public key. My verified result is empty. What am I doing wrong?
package main
import (
"crypto"
"crypto/rand"
"crypto/rsa"
"crypto/sha256"
"crypto/x509"
"encoding/base64"
"encoding/pem"
"errors"
"fmt"
"io/ioutil"
)
func main() {
signer, err := loadPrivateKey("private.pem");
if err != nil {
fmt.Errorf("signer is damaged: %v", err)
}
toSign := "date: Thu, 05 Jan 2012 21:31:40 GMT";
signed, err := signer.Sign([]byte(toSign))
if err != nil {
fmt.Errorf("could not sign request: %v", err)
}
sig := base64.StdEncoding.EncodeToString(signed)
fmt.Printf("Encoded: %v\n", sig)
parser, perr := loadPublicKey("public.pem");
if perr != nil {
fmt.Errorf("could not sign request: %v", err)
}
unsigned, err := parser.Unsign(signed);
if err != nil {
fmt.Errorf("could not sign request: %v", err)
}
fmt.Printf("Decrypted: %v\n", base64.StdEncoding.EncodeToString(unsigned))
}
// loadPrivateKey loads an parses a PEM encoded private key file.
func loadPublicKey(path string) (Unsigner, error) {
data, err := ioutil.ReadFile(path)
if err != nil {
return nil, err
}
return parsePublicKey(data)
}
// parsePublicKey parses a PEM encoded private key.
func parsePublicKey(pemBytes []byte) (Unsigner, error) {
block, _ := pem.Decode(pemBytes)
if block == nil {
return nil, errors.New("ssh: no key found")
}
var rawkey interface{}
switch block.Type {
case "PUBLIC KEY":
rsa, err := x509.ParsePKIXPublicKey(block.Bytes)
if err != nil {
return nil, err
}
rawkey = rsa
default:
return nil, fmt.Errorf("ssh: unsupported key type %q", block.Type)
}
return newUnsignerFromKey(rawkey)
}
// loadPrivateKey loads an parses a PEM encoded private key file.
func loadPrivateKey(path string) (Signer, error) {
data, err := ioutil.ReadFile(path)
if err != nil {
return nil, err
}
return parsePrivateKey(data)
}
// parsePublicKey parses a PEM encoded private key.
func parsePrivateKey(pemBytes []byte) (Signer, error) {
block, _ := pem.Decode(pemBytes)
if block == nil {
return nil, errors.New("ssh: no key found")
}
var rawkey interface{}
switch block.Type {
case "RSA PRIVATE KEY":
rsa, err := x509.ParsePKCS1PrivateKey(block.Bytes)
if err != nil {
return nil, err
}
rawkey = rsa
default:
return nil, fmt.Errorf("ssh: unsupported key type %q", block.Type)
}
return newSignerFromKey(rawkey)
}
// A Signer is can create signatures that verify against a public key.
type Signer interface {
// Sign returns raw signature for the given data. This method
// will apply the hash specified for the keytype to the data.
Sign(data []byte) ([]byte, error)
}
// A Signer is can create signatures that verify against a public key.
type Unsigner interface {
// Sign returns raw signature for the given data. This method
// will apply the hash specified for the keytype to the data.
Unsign(data []byte) ([]byte, error)
}
func newSignerFromKey(k interface{}) (Signer, error) {
var sshKey Signer
switch t := k.(type) {
case *rsa.PrivateKey:
sshKey = &rsaPrivateKey{t}
default:
return nil, fmt.Errorf("ssh: unsupported key type %T", k)
}
return sshKey, nil
}
func newUnsignerFromKey(k interface{}) (Unsigner, error) {
var sshKey Unsigner
switch t := k.(type) {
case *rsa.PublicKey:
sshKey = &rsaPublicKey{t}
default:
return nil, fmt.Errorf("ssh: unsupported key type %T", k)
}
return sshKey, nil
}
type rsaPublicKey struct {
*rsa.PublicKey
}
type rsaPrivateKey struct {
*rsa.PrivateKey
}
// Sign signs data with rsa-sha256
func (r *rsaPrivateKey) Sign(data []byte) ([]byte, error) {
h := sha256.New()
h.Write(data)
d := h.Sum(nil)
return rsa.SignPKCS1v15(rand.Reader, r.PrivateKey, crypto.SHA256, d)
}
// Unsign encrypts data with rsa-sha256
func (r *rsaPublicKey) Unsign(message []byte) ([]byte, error) {
return rsa.EncryptPKCS1v15(rand.Reader, r.PublicKey, message)
}
private.pem looks like this:
-----BEGIN RSA PRIVATE KEY-----
MIICXgIBAAKBgQDCFENGw33yGihy92pDjZQhl0C36rPJj+CvfSC8+q28hxA161QF
NUd13wuCTUcq0Qd2qsBe/2hFyc2DCJJg0h1L78+6Z4UMR7EOcpfdUE9Hf3m/hs+F
UR45uBJeDK1HSFHD8bHKD6kv8FPGfJTotc+2xjJwoYi+1hqp1fIekaxsyQIDAQAB
AoGBAJR8ZkCUvx5kzv+utdl7T5MnordT1TvoXXJGXK7ZZ+UuvMNUCdN2QPc4sBiA
QWvLw1cSKt5DsKZ8UETpYPy8pPYnnDEz2dDYiaew9+xEpubyeW2oH4Zx71wqBtOK
kqwrXa/pzdpiucRRjk6vE6YY7EBBs/g7uanVpGibOVAEsqH1AkEA7DkjVH28WDUg
f1nqvfn2Kj6CT7nIcE3jGJsZZ7zlZmBmHFDONMLUrXR/Zm3pR5m0tCmBqa5RK95u
412jt1dPIwJBANJT3v8pnkth48bQo/fKel6uEYyboRtA5/uHuHkZ6FQF7OUkGogc
mSJluOdc5t6hI1VsLn0QZEjQZMEOWr+wKSMCQQCC4kXJEsHAve77oP6HtG/IiEn7
kpyUXRNvFsDE0czpJJBvL/aRFUJxuRK91jhjC68sA7NsKMGg5OXb5I5Jj36xAkEA
gIT7aFOYBFwGgQAQkWNKLvySgKbAZRTeLBacpHMuQdl1DfdntvAyqpAZ0lY0RKmW
G6aFKaqQfOXKCyWoUiVknQJAXrlgySFci/2ueKlIE1QqIiLSZ8V8OlpFLRnb1pzI
7U1yQXnTAEFYM560yJlzUpOb1V4cScGd365tiSMvxLOvTA==
-----END RSA PRIVATE KEY-----
And public.pem:
-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDCFENGw33yGihy92pDjZQhl0C3
6rPJj+CvfSC8+q28hxA161QFNUd13wuCTUcq0Qd2qsBe/2hFyc2DCJJg0h1L78+6
Z4UMR7EOcpfdUE9Hf3m/hs+FUR45uBJeDK1HSFHD8bHKD6kv8FPGfJTotc+2xjJw
oYi+1hqp1fIekaxsyQIDAQAB
-----END PUBLIC KEY-----
Thanks.
解决方案
The problem in your code is that Unsign tries to Encode the signature instead of using it to verify the original message.
There need to be changes made to the Interface and to Unsign:
// Unsign verifies the message using a rsa-sha256 signature
func (r *rsaPublicKey) Unsign(message []byte, sig []byte) error {
h := sha256.New()
h.Write(message)
d := h.Sum(nil)
return rsa.VerifyPKCS1v15(r.PublicKey, crypto.SHA256, d, sig)
}
Here is a playground example of verification: http://play.golang.org/p/bzpD7Pa9mr
Some modifications has also been made to avoid ioutils.
这篇关于在GO中使用RSA-SHA进行签名和解码的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
查看全文
