Golang实现检测SSL证书有效期

在实际的运维和开发工作中，SSL证书的有效期监控是一件绕不开的事情。证书一旦过期，轻则服务报错，重则影响业务安全——尤其是现在的证书有效期普遍被压缩到90天，手动盯着根本不现实。所以，用程序自动检测就成了刚需。

Go语言在这方面做得相当顺手，标准库 crypto/tls 就提供了直接与TLS握手的能力，拿到证书后，到期时间一目了然。下面就先从最直接的方式说起。

package main

import (
	"crypto/tls"
	"fmt"
)

func main() {
	conn, _ := tls.Dial("tcp", "www.baidu.com:443", nil)
	cert := conn.ConnectionState().PeerCertificates[0]

	// 时间信息
	fmt.Printf("NotBefore: %v\n", cert.NotBefore)
	// NotBefore: 2022-07-05 05:16:02 +0000 UTC

	fmt.Printf("NotAfter: %v\n", cert.NotAfter)
	// NotAfter: 2023-08-06 05:16:01 +0000 UTC

	// 其他信息
	fmt.Printf("IPAddresses: %v\n", cert.IPAddresses)
	// IPAddresses: []
	fmt.Printf("IPAddresses: %v\n", conn.RemoteAddr())
	// IPAddresses: 220.181.38.150:443
	fmt.Printf("Version: %v\n", cert.Version)
	fmt.Printf("SerialNumber: %v\n", cert.SerialNumber)
	fmt.Printf("Issuer: %v\n", cert.Issuer)
	fmt.Printf("Subject: %v\n", cert.Subject)
}

方法一：通过TLS连接获取证书到期时间

如果要写一个能直接用于生产环境的检测函数，核心思路很简单：与目标服务器建立一次TLS连接，拿到证书链，再从 NotAfter 字段解析出到期时间。下面这个 CheckSSLCertExpiry 函数就是完整实现，接受域名，返回剩余天数。

package main
import (
    "crypto/tls"
    "fmt"
    "net"
    "time"
)
// CheckSSLCertExpiry 检查给定域名的 SSL 证书有效期，返回剩余天数
func CheckSSLCertExpiry(domain string) (int, error) {
    // 1. 配置 tls.Config
    // InsecureSkipVerify: true 用来绕过证书本身的校验，否则证书过期或无效时连接会失败，我们反而拿不到证书信息。
    // ServerName: 显式设置 SNI，对于使用 CDN 的网站尤其重要，以防止获取到错误的默认证书。
    conf := &tls.Config{
        InsecureSkipVerify: true,
        ServerName:         domain,
    }
    // 2. 建立 TLS 连接
    // 设置一个连接超时，防止网络问题导致程序长时间阻塞。
    dialer := &net.Dialer{Timeout: 10 * time.Second}
    conn, err := tls.DialWithDialer(dialer, "tcp", fmt.Sprintf("%s:443", domain), conf)
    if err != nil {
        return 0, fmt.Errorf("failed to connect to %s: %w", domain, err)
    }
    defer conn.Close()
    // 3. 获取证书链
    // PeerCertificates 返回的是对端发送的证书链，第一个元素 (索引0) 通常是服务器本身的证书（叶子证书）。
    certs := conn.ConnectionState().PeerCertificates
    if len(certs) == 0 {
        return 0, fmt.Errorf("no certificates found for %s", domain)
    }
    leafCert := certs[0]
    // 4. 计算剩余天数
    // NotAfter 是 UTC 时间，time.Now() 返回的是本地时间，但 Go 的 time 包在比较时会自动转换到同一时区，所以直接相减是安全的。
    // 使用 math.Ceil 确保剩余天数向上取整，避免因精度问题将 "剩余0.9天" 显示为 "0天"。
    remaining := time.Until(leafCert.NotAfter)
    days := int(remaining.Hours() / 24)
    if remaining.Hours() > 0 && days == 0 {
        days = 1
    }
    return days, nil
}
func main() {
    // 示例：检查 example.com 的证书有效期
    domain := "www.baidu.com"
    days, err := CheckSSLCertExpiry(domain)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    fmt.Printf("SSL certificate for %s is valid for %d more days.\n", domain, days)
}

核心逻辑拆解

代码里的几个关键点值得单独拎出来说一下：

• tls.Config 的配置：InsecureSkipVerify: true 是故意为之。原因很简单——如果证书已经过期，正常的TLS握手会直接失败，我们反而连证书信息都拿不到。所以这一步是为了“绕过验证，获取信息”。同时，ServerName 的显式设置对CDN场景尤为重要，否则可能拿到默认证书。
• 建立连接：用 tls.DialWithDialer 而不是 tls.Dial，主要是为了能灵活设置超时，避免网络卡死影响整个监控流程。
• 获取证书：PeerCertificates 返回的是证书链，索引0对应的就是服务器本身的叶子证书，也是我们最关心的那个。
• 天数计算：time.Until(cert.NotAfter) 直接计算剩余时间，再换算为天数。这里有一个细节：为了避免“还剩0.9天却显示0天”的尴尬，代码里做了向上取整的处理。

注意事项

• 关于 InsecureSkipVerify：从安全角度看，这个设置确实是个“后门”。但在这个场景下，它是合理的——我们只读取证书的元数据，不依赖它做身份认证。换句话说，这是“为了检查而主动豁免检查”。
• 连接错误处理：网络层面的问题（DNS解析失败、连接超时等）在实际运行中很常见。代码里已经加了超时和错误处理，实际使用时建议根据错误类型做更细致的区分。
• 并发检查：如果要对成百上千个域名做批量检测，用 goroutine 并发执行效率会高很多。但注意控制并发数，既要考虑网络带宽，也要对目标服务器保持礼貌。
• 时区问题：NotAfter 是UTC时间，而 time.Now() 是本地时间。好在Go的 time 包在计算 time.Until 时会自动处理时区差异，所以直接减就行，不用手动换算。

方法二：使用Go语言验证证书的有效期

如果证书文件已经在本地（比如从某个路径读取），也可以用另一种方式直接解析PEM文件：

package main
import (
    "crypto/x509"
    "encoding/pem"
    "fmt"
    "io/ioutil"
    "time"
)
func main() {
    certPEM, err := ioutil.ReadFile("path/to/certificate.pem")
    if err != nil {
        fmt.Println("Error reading certificate file:", err)
        return
    }
    block, _ := pem.Decode(certPEM)
    if block == nil {
        fmt.Println("Failed to parse certificate PEM")
        return
    }
    cert, err := x509.ParseCertificate(block.Bytes)
    if err != nil {
        fmt.Println("Error parsing certificate:", err)
        return
    }
    fmt.Println("Certificate Expiry Date:", cert.NotAfter)
    now := time.Now()
    if now.Before(cert.NotBefore) {
        fmt.Println("Certificate is not yet valid")
    } else if now.After(cert.NotAfter) {
        fmt.Println("Certificate has expired")
    } else {
        fmt.Println("Certificate is valid")
    }
}

这段代码的逻辑更直白：读取本地证书文件，解析PEM格式，然后用 x509.ParseCertificate 解析成证书对象，最后比一下时间就行。适合那些你已经拿到证书文件的场景。

方法三：通过系统命令获取过期时间

有时候，用内置命令也是一种快速手段。下面这段代码通过调用 curl 来获取证书的过期信息，适合不想写太多代码、快速验证的场景：

func GetDomainSslExpireDate(domain string) string {
	if !strings.HasPrefix(domain, "http") {
		domain = fmt.Sprint("https://", domain)
	}
	command := fmt.Sprint("curl -v -I -k ", domain)
	cmd := exec.Command("/bin/bash", "-c", command)
	output, err := cmd.CombinedOutput()
	if err != nil {
		return time.Time{}
	}
	outStr := string(output)
	outArr := strings.Split(outStr, "\n")
	for _, out := range outArr {
		if strings.Contains(out, "expire date") {
			return out[strings.Index(out, ":")+1:]
			return StrToDate(dateStr)
		}
	}
	return ""
}

这个方法本质上是“用Go调系统工具”，好处是快，坏处是依赖环境中有 curl，而且输出解析比较脆弱。不过作为临时方案或辅助手段，足够用。