Golang如何解码SHA256私钥和证书

Golang如何解码SHA256私钥和证书 如何使用 MSPKI SHA256 的 PFX 证书文件来建立与服务器的客户端连接。 请尽快提供帮助。

5 回复

我是开发新手，有人能帮我看看这段代码片段吗？

更多关于Golang如何解码SHA256私钥和证书的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


如果可能的话，能否请您提供一个使用pfx证书建立客户端到服务器连接的代码片段？

func main() {
    fmt.Println("hello world")
}

此库用于加载PFX文件：https://godoc.org/golang.org/x/crypto/pkcs12

然后您可以将它用作客户端证书来建立TLS连接，关于此主题有许多指南可供参考。

以下是已验证可用的逻辑：导入 crypto/tls、crypto/x509、encoding/pem、io/ioutil、golang.org/x/crypto/pkcs12、net/http

// 受信任的证书
    caCert, err := ioutil.ReadFile("/<path>/rootCA.pem")
    if err != nil {
    log.Fatal(err)
    } 
    certPool := x509.NewCertPool()
    certPool.AppendCertsFromPEM(caCert)

// 客户端证书解码
    pfx, _ := ioutil.ReadFile("/<path>/<certificate_name>.pfx")
    blocks, err := pkcs12.ToPEM (pfx, "Password")
    if err != nil {
    panic(err)
    }

    var pemData []byte
    for _, b := range blocks {
    pemData = append(pemData, pem.EncodeToMemory(b)...)
    }

// 然后使用PEM数据为TLS构建TLS证书： cert, err := tls.X509KeyPair(pemData, pemData) if err != nil { panic(err) }

// 客户端连接
    client := &http.Client{
    Transport: &http.Transport{
        TLSClientConfig: &tls.Config{
            RootCAs: certPool,
            ServerName: "<authorized server name>",
            Certificates: []tls.Certificate{cert},
            Renegotiation: tls.RenegotiateFreelyAsClient,
        },
    },
}

在Golang中解码SHA256私钥和证书并建立客户端连接，可以使用crypto/x509和crypto/tls包。以下是完整的示例代码：

package main

import (
    "crypto/tls"
    "crypto/x509"
    "encoding/pem"
    "fmt"
    "io/ioutil"
    "net/http"
    "strings"
)

func main() {
    // 1. 读取PFX文件
    pfxData, err := ioutil.ReadFile("client.pfx")
    if err != nil {
        panic(err)
    }

    // 2. 解码PFX（需要密码）
    password := "your-password"
    privateKey, certificate, caCerts, err := decodePfx(pfxData, password)
    if err != nil {
        panic(err)
    }

    // 3. 创建TLS配置
    tlsConfig := &tls.Config{
        Certificates: []tls.Certificate{
            {
                Certificate: [][]byte{certificate.Raw},
                PrivateKey:  privateKey,
                Leaf:        certificate,
            },
        },
        RootCAs:    createCertPool(caCerts),
        ServerName: "your-server.com",
    }

    // 4. 创建HTTP客户端
    client := &http.Client{
        Transport: &http.Transport{
            TLSClientConfig: tlsConfig,
        },
    }

    // 5. 发起请求
    resp, err := client.Get("https://your-server.com/api/endpoint")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}

// 解码PFX文件
func decodePfx(pfxData []byte, password string) (interface{}, *x509.Certificate, []*x509.Certificate, error) {
    // 解码PKCS#12格式
    privateKey, certificate, caCerts, err := pkcs12Decode(pfxData, password)
    if err != nil {
        return nil, nil, nil, err
    }
    return privateKey, certificate, caCerts, nil
}

// PKCS#12解码实现
func pkcs12Decode(pfxData []byte, password string) (interface{}, *x509.Certificate, []*x509.Certificate, error) {
    // 注意：标准库不支持PKCS#12，需要第三方库如"software.sslmate.com/src/go-pkcs12"
    // 以下是使用go-pkcs12库的示例：
    // privateKey, certificate, caCerts, err := pkcs12.Decode(pfxData, password)
    
    // 临时示例：使用PEM格式替代
    return decodePEM()
}

// 解码PEM格式的示例（实际使用时替换为PKCS#12解码）
func decodePEM() (interface{}, *x509.Certificate, []*x509.Certificate, error) {
    // 读取私钥
    keyData, _ := ioutil.ReadFile("key.pem")
    block, _ := pem.Decode(keyData)
    privateKey, _ := x509.ParsePKCS1PrivateKey(block.Bytes)
    
    // 读取证书
    certData, _ := ioutil.ReadFile("cert.pem")
    block, _ = pem.Decode(certData)
    certificate, _ := x509.ParseCertificate(block.Bytes)
    
    // 读取CA证书
    caData, _ := ioutil.ReadFile("ca.pem")
    var caCerts []*x509.Certificate
    for {
        block, rest := pem.Decode(caData)
        if block == nil {
            break
        }
        caCert, _ := x509.ParseCertificate(block.Bytes)
        caCerts = append(caCerts, caCert)
        caData = rest
    }
    
    return privateKey, certificate, caCerts, nil
}

// 创建证书池
func createCertPool(caCerts []*x509.Certificate) *x509.CertPool {
    pool := x509.NewCertPool()
    for _, cert := range caCerts {
        pool.AddCert(cert)
    }
    return pool
}

对于PKCS#12（PFX）文件，需要使用第三方库。首先安装：

go get software.sslmate.com/src/go-pkcs12

然后修改pkcs12Decode函数：

import "software.sslmate.com/src/go-pkcs12"

func pkcs12Decode(pfxData []byte, password string) (interface{}, *x509.Certificate, []*x509.Certificate, error) {
    privateKey, certificate, caCerts, err := pkcs12.Decode(pfxData, password)
    if err != nil {
        return nil, nil, nil, err
    }
    return privateKey, certificate, caCerts, nil
}

如果需要处理加密的私钥，可以使用以下方式：

func parsePrivateKey(keyData []byte, password string) (interface{}, error) {
    block, _ := pem.Decode(keyData)
    if block == nil {
        return nil, fmt.Errorf("failed to parse PEM block")
    }
    
    if x509.IsEncryptedPEMBlock(block) {
        decrypted, err := x509.DecryptPEMBlock(block, []byte(password))
        if err != nil {
            return nil, err
        }
        return x509.ParsePKCS1PrivateKey(decrypted)
    }
    
    return x509.ParsePKCS1PrivateKey(block.Bytes)
}

这个示例展示了如何解码SHA256签名的PFX证书并建立TLS客户端连接。实际使用时需要替换文件路径、密码和服务器地址。

回到顶部