package main

import (
    "crypto/rand"
    "crypto/rsa"
    "crypto/x509"
    "crypto/x509/pkix"
    "encoding/pem"
    "fmt"
    "golang.org/x/crypto/pkcs12"
    "os"
)

// 解析PFX文件并提取證書和私鑰
func parsePFXFile(pfxPath, password string) ([]*x509.Certificate, interface{}, error) {
    // 1. 讀取PFX文件內(nèi)容
    pfxData, err := os.ReadFile(pfxPath)
    if err != nil {
        return nil, nil, fmt.Errorf("讀取PFX文件失敗: %v", err)
    }

    // 2. 解碼PFX數(shù)據(jù)（支持帶密碼的加密私鑰）
    certs, privateKey, err := pkcs12.Decode(pfxData, password)
    if err != nil {
        return nil, nil, fmt.Errorf("解碼PFX失敗: %v", err)
    }

    // 3. 解析證書鏈（可能包含多個證書：終端實體+中間CA）
    var certificateChain []*x509.Certificate
    for _, cert := range certs {
        certBytes, err := x509.MarshalCertificate(cert)
        if err != nil {
            return nil, nil, fmt.Errorf("解析證書失敗: %v", err)
        }
        x509Cert, err := x509.ParseCertificate(certBytes)
        if err != nil {
            return nil, nil, fmt.Errorf("解析X.509證書失敗: %v", err)
        }
        certificateChain = append(certificateChain, x509Cert)
    }

    return certificateChain, privateKey, nil
}

func main() {
    pfxPath := "cert.pfx"       // PFX文件路徑
    password := "password123"   // PFX密碼（需替換為實際密碼）

    // 解析PFX文件
    certs, privateKey, err := parsePFXFile(pfxPath, password)
    if err != nil {
        fmt.Printf("解析失敗: %v\n", err)
        return
    }

    // 打印證書信息
    fmt.Println("成功解析到以下證書:")
    for i, cert := range certs {
        fmt.Printf("[%d] 通用名稱: %s\n", i+1, cert.Subject.CommonName)
        fmt.Printf("    有效期: %s ~ %s\n", cert.NotBefore.Format(time.RFC3339), cert.NotAfter.Format(time.RFC3339))
    }

    // 驗證私鑰類型（通常為RSA或ECDSA）
    switch key := privateKey.(type) {
    case *rsa.PrivateKey:
        fmt.Println("私鑰類型: RSA")
        fmt.Printf("密鑰長度: %d bits\n", key.N.BitLen())
    // case *ecdsa.PrivateKey:
    //     fmt.Println("私鑰類型: ECDSA")
    //     fmt.Printf("曲線類型: %s\n", key.Curve.Params().Name)
    default:
        fmt.Printf("未知私鑰類型: %T\n", privateKey)
    }

    // 示例：將私鑰和證書保存為PEM格式（可選）by dev.tekin.cn
    savePrivateKeyToPEM(privateKey, "private_key.pem")
    saveCertificatesToPEM(certs, "cert_chain.pem")
}

// 保存私鑰到PEM文件（支持RSA/ECDSA）
func savePrivateKeyToPEM(key interface{}, filename string) error {
    var pemBytes []byte
    switch k := key.(type) {
    case *rsa.PrivateKey:
        pemBytes = pem.EncodeToMemory(&pem.Block{
            Type:  "RSA PRIVATE KEY",
            Bytes: x509.MarshalPKCS1PrivateKey(k),
        })
    // case *ecdsa.PrivateKey:
    //     derBytes, err := x509.MarshalECPrivateKey(k)
    //     if err != nil { return err }
    //     pemBytes = pem.EncodeToMemory(&pem.Block{Type: "EC PRIVATE KEY", Bytes: derBytes})
    default:
        return fmt.Errorf("不支持的私鑰類型: %T", key)
    }
    return os.WriteFile(filename, pemBytes, 0600) // 僅限所有者可讀
}

// 保存證書鏈到PEM文件
func saveCertificatesToPEM(certs []*x509.Certificate, filename string) error {
    var pemBlocks []pem.Block
    for _, cert := range certs {
        pemBlocks = append(pemBlocks, pem.Block{
            Type:  "CERTIFICATE",
            Bytes: cert.Raw,
        })
    }
    return pem.EncodeAll(os.Stdout, pemBlocks) // 輸出到文件或標準輸出
}
    

package main

import (
    "crypto/rand"
    "crypto/rsa"
    "crypto/x509"
    "crypto/x509/pkix"
    "encoding/pem"
    "fmt"
    "golang.org/x/crypto/pkcs12"
    "os"
)

func parsePFXFile(pfxPath, password string) error {
    // 1. 讀取PFX文件內(nèi)容
    pfxData, err := os.ReadFile(pfxPath)
    if err != nil {
        return fmt.Errorf("讀取PFX文件失敗: %v", err)
    }

    // 2. 解密并解析PFX（參數(shù)：PFX數(shù)據(jù)、密碼）
    certificates, privateKey, err := pkcs12.Decode(pfxData, password)
    if err != nil {
        return fmt.Errorf("解析PFX失敗: %v", err)
    }
    fmt.Println("成功解析PFX文件！")

    // 3. 處理私鑰（示例：假設為RSA私鑰，根據(jù)實際情況調(diào)整）
    rsaPrivateKey, ok := privateKey.(*rsa.PrivateKey)
    if !ok {
        return fmt.Errorf("不支持的私鑰類型，僅支持RSA/ECDSA")
    }
    fmt.Printf("私鑰類型: RSA，密鑰長度: %d位\n", rsaPrivateKey.N.BitLen())

    // 4. 解析證書鏈
    for i, certData := range certificates {
        cert, err := x509.ParseCertificate(certData)
        if err != nil {
            return fmt.Errorf("解析證書%d失敗: %v", i+1, err)
        }
        fmt.Printf("證書%d主題: %s\n", i+1, cert.Subject.CommonName)
        fmt.Printf("有效期: %s - %s\n", cert.NotBefore.Format(time.RFC3339), cert.NotAfter.Format(time.RFC3339))
    }

    // 5. 提取CA鏈（如有）并構(gòu)建證書池
    caCertPool := x509.NewCertPool()
    for _, certData := range certificates {
        cert, _ := x509.ParseCertificate(certData)
        caCertPool.AddCert(cert) // 添加到證書池，用于驗證
    }
    fmt.Println("證書池已包含", len(caCertPool.Subjects()), "個證書")

    return nil
}

func main() {
    pfxPath := "cert.pfx"
    password := "your-pfx-password" // 需替換為實際密碼

    if err := parsePFXFile(pfxPath, password); err != nil {
        fmt.Printf("錯誤: %v\n", err)
        return
    }
    fmt.Println("解析完成！")
}

import "golang.org/x/crypto/pkcs12" // 非標準庫，需通過go mod下載

go get golang.org/x/crypto

// 處理RSA私鑰
if rsaKey, ok := privateKey.(*rsa.PrivateKey); ok {
    // 使用RSA私鑰進行后續(xù)操作（如簽名、TLS配置）
}

// 處理ECDSA私鑰（示例）
if ecdsaKey, ok := privateKey.(*ecdsa.PrivateKey); ok {
    // ...
}

for _, certData := range certificates {
    cert, err := x509.ParseCertificate(certData)
    // 處理證書字段：主題、有效期、擴展字段等
}

func configureTLSServer(pfxPath, password string) (*tls.Config, error) {
    pfxData, _ := os.ReadFile(pfxPath)
    certs, privateKey, _ := pkcs12.Decode(pfxData, password)

    // 轉(zhuǎn)換為tls.Certificate類型（需包含證書鏈）
    tlsCert := tls.Certificate{
        Certificate: [][]byte{certs[0]}, // 服務器證書（第一個證書通常為終端實體證書）
        PrivateKey:  privateKey,
        // 若有中間CA證書，添加到Certificate字段（按順序）
        // Certificate: append([][]byte{certs[0]}, certs[1:]...),
    }

    return &tls.Config{
        Certificates: []tls.Certificate{tlsCert},
        ServerName:   "example.com", // 按需配置SNI
    }, nil
}

func configureTLSClient(pfxPath, password string) (*tls.Config, error) {
    pfxData, _ := os.ReadFile(pfxPath)
    certs, privateKey, _ := pkcs12.Decode(pfxData, password)

    // 構(gòu)建客戶端證書配置
    clientCert := tls.Certificate{
        Certificate: [][]byte{certs[0]},
        PrivateKey:  privateKey,
    }

    return &tls.Config{
        Certificates: []tls.Certificate{clientCert},
        RootCAs:      x509.NewCertPool(), // 服務端CA證書池（按需加載）
    }, nil
}

// pkcs12.Decode 核心解碼函數(shù)
// 參數(shù)：
// - pfxData: PFX文件字節(jié)數(shù)據(jù)
// - password: 解密私鑰的密碼（無密碼時傳空字符串）
// 返回：
// - certs: 證書鏈（[]pkcs12.Certificate，需轉(zhuǎn)為x509.Certificate）
// - privateKey: 私鑰（interface{}類型，需根據(jù)類型斷言處理）
// - error: 解碼錯誤（如密碼錯誤、文件損壞）
certs, privateKey, err := pkcs12.Decode(pfxData, password)

go get golang.org/x/crypto  

// 解析PFX后配置TLS服務
certChain, privateKey, _ := parsePFXFile("cert.pfx", "password")

// 轉(zhuǎn)換為tls.Certificate格式（適用于https.Server）
tlsCert, err := tls.X509KeyPair(
    pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: certChain[0].Raw}), // 終端實體證書
    pem.EncodeToMemory(pkcs12.MarshalPrivateKeyToPEM(privateKey.(*rsa.PrivateKey))), // 私鑰PEM
)
if err != nil {
    // 處理錯誤
}

server := &http.Server{
    Addr:      ":443",
    TLSConfig: &tls.Config{Certificates: []tls.Certificate{tlsCert}},
}

// 解析客戶端PFX用于雙向TLS
clientCertData, _ := os.ReadFile("client.pfx")
clientCerts, clientKey, _ := pkcs12.Decode(clientCertData, "clientPassword")

// 配置TLS客戶端
tlsConfig := &tls.Config{
    Certificates: []tls.Certificate{{
        Certificate: [][]byte{clientCerts[0].Raw}, // 客戶端證書
        PrivateKey:  clientKey.(*rsa.PrivateKey),
    }},
    RootCAs: x509.NewCertPool(), // 服務端CA證書池
}

// 提取完整證書鏈（用于證書路徑驗證）
var fullChain []*x509.Certificate
fullChain = append(fullChain, certChain...) // 包含終端實體和中間CA

case *ecdsa.PrivateKey:
    fmt.Println("私鑰類型: ECDSA")
    fmt.Printf("曲線類型: %s\n", key.Curve.Params().Name)