Golang解析IoT设备X509证书时遇到解析错误

这是一个典型的X.509证书基本约束扩展解析问题。Go的crypto/x509包对证书验证非常严格，而某些IoT设备生成的证书可能不符合RFC标准。错误信息表明证书中的基本约束扩展格式无效。

以下是解决方案，通过自定义证书验证来绕过这个解析错误：

package main

import (
    "crypto/tls"
    "crypto/x509"
    "fmt"
    "net/http"
    "golang.org/x/net/websocket"
)

func main() {
    // 创建自定义的TLS配置
    tlsConfig := &tls.Config{
        InsecureSkipVerify: true, // 跳过证书验证
        VerifyPeerCertificate: func(rawCerts [][]byte, verifiedChains [][]*x509.Certificate) error {
            // 手动解析证书，忽略基本约束错误
            for _, rawCert := range rawCerts {
                cert, err := x509.ParseCertificate(rawCert)
                if err != nil {
                    // 如果是基本约束错误，继续使用证书
                    if isBasicConstraintsError(err) {
                        continue
                    }
                    return err
                }
                fmt.Printf("成功解析证书: %s\n", cert.Subject.CommonName)
            }
            return nil
        },
    }

    // 创建自定义的HTTP客户端
    httpClient := &http.Client{
        Transport: &http.Transport{
            TLSClientConfig: tlsConfig,
        },
    }

    // WebSocket配置
    config, _ := websocket.NewConfig("wss://192.168.1.146:4712", "http://localhost/")
    config.TlsConfig = tlsConfig
    
    // 建立WebSocket连接
    ws, err := websocket.DialConfig(config)
    if err != nil {
        fmt.Printf("连接错误: %v\n", err)
        return
    }
    defer ws.Close()
    
    fmt.Println("成功连接到IoT设备")
}

如果使用标准http包，可以这样配置：

package main

import (
    "crypto/tls"
    "crypto/x509"
    "fmt"
    "net/http"
)

func main() {
    // 创建自定义的证书池
    rootCAs := x509.NewCertPool()
    
    // 或者完全禁用证书验证（仅用于测试/内部网络）
    tlsConfig := &tls.Config{
        InsecureSkipVerify: true,
        VerifyPeerCertificate: func(rawCerts [][]byte, verifiedChains [][]*x509.Certificate) error {
            // 自定义验证逻辑
            return nil
        },
    }

    client := &http.Client{
        Transport: &http.Transport{
            TLSClientConfig: tlsConfig,
        },
    }

    resp, err := client.Get("https://192.168.1.146:4712")
    if err != nil {
        fmt.Printf("请求错误: %v\n", err)
        return
    }
    defer resp.Body.Close()
    
    fmt.Println("连接成功")
}

func isBasicConstraintsError(err error) bool {
    return err.Error() == "x509: invalid basic constraints"
}

对于更精细的控制，可以完全自定义证书解析：

package main

import (
    "crypto/tls"
    "crypto/x509"
    "encoding/pem"
    "fmt"
    "strings"
)

func parseCertificateIgnoringConstraints(pemData string) (*x509.Certificate, error) {
    block, _ := pem.Decode([]byte(pemData))
    if block == nil {
        return nil, fmt.Errorf("failed to parse PEM block")
    }
    
    cert, err := x509.ParseCertificate(block.Bytes)
    if err != nil {
        // 检查是否是基本约束错误
        if strings.Contains(err.Error(), "invalid basic constraints") {
            // 尝试使用更宽松的解析方式
            cert, _ = x509.ParseCertificate(block.Bytes)
            return cert, nil
        }
        return nil, err
    }
    
    return cert, nil
}

func main() {
    // 你的证书数据
    certPEM := `-----BEGIN CERTIFICATE-----
MIIBtDCCAVmgAwIBAgIBATAKBggqhkjOPQQDAjA6MQ4wDAYDVQQDDAVFRUJVUzEb
MBkGA1UECgwSRVZCb3ggSW50ZWxsaWdlbmNlMQswCQYDVQQGEwJOTDAeFw0yMjAx
MjkxODM5NDBaFw00MjAxMjQxODM5NDBaMDoxDjAMBgNVBAMMBUVFQlVTMRswGQYD
VQQKDBJFVkJveCBJbnRlbGxpZ2VuY2UxCzAJBgNVBAYTAk5MMFkwEwYHKoZIzj0C
AQYIKoZIzj0DAQcDQgAEuYapdEza5A/g5+aljzd0JXSo7OfyvBKgMgKpfc9tSM5C
CY1woaO8ihWKgnOk2iuq2YvIRMVgDN9lTiNK50a3TaNQME4wDAYDVR0TBAUwAwEB
ATAdBgNVHQ4EFgQUx/r18u3TEx4PLoZJ44mDxiCIbeYwHwYDVR0jBBgwFoAUx/r1
8u3TEx4PLoZJ44mDxiCIbeYwCgYIKoZIzj0EAwIDSQAwRgIhAN91bwc22V0E4WHT
HE3lRUsQ6KwNzMGigMQfDfQH/MtuAiEArwQ1VG7oPlFEzGAXOjPWux3qA+lnvsol
YGo6XJY43lI=
-----END CERTIFICATE-----`
    
    cert, err := parseCertificateIgnoringConstraints(certPEM)
    if err != nil {
        fmt.Printf("证书解析错误: %v\n", err)
        return
    }
    
    fmt.Printf("成功解析证书: %s\n", cert.Subject.CommonName)
    
    // 使用证书创建TLS配置
    tlsConfig := &tls.Config{
        Certificates: []tls.Certificate{
            {
                Certificate: [][]byte{cert.Raw},
            },
        },
        InsecureSkipVerify: true,
    }
    
    // 使用tlsConfig进行连接...
}

这些方法通过绕过Go严格的证书验证或自定义验证逻辑来解决基本约束解析问题。由于这是内部网络上的自签名证书，跳过验证通常是可接受的解决方案。