哪里可以申请短期的https证书 短到一周左右的时间 或者自签证书可能被信任吗

阿里云免费一年不是可以随便申请吗

自己搞一个呗，看看step ca 不过有个缺点就是，根证书肯定没有被系统收录过，所以ca 证书得给每个客户端装一个~

把系统时间调快可以吗

certbot

如果自签证书可以用，那就自己签名吧，记得信任跟证书就行

freessl.cn/ 这里有免费的，3月/1年的证书

刚好有个证书过期了：

我们写了个程序，调用 DNS 的 API 获取配置信息，然后每天请求一次这些域名来获取证书信息，快要过期了就飞书通知。（如果是内网那就没办法了。）

Let's Encrypt

这是什么奇葩需求？难道不是过度需求，正常的API接口HTTPS过期了，你肯定用不了。过期就是无效，和证书是错的一样的东西

通过openssl自己创建证书呗 随便自定义时间

caddy

之前项目做过自签名证书，分享给你一下，不知道你那里有没有 go 环境，或者你留个邮箱我打包发你

// GenerateRootPemFile 是生成根证书 需要被系统信任才可使用 host 为公司名称
func GenerateRootPemFile(host string) (*pem.Block, *pem.Block, error) {
    max := new(big.Int).Lsh(big.NewInt(1), 128)
    serialNumber, _ := rand.Int(rand.Reader, max)
    template := x509.Certificate{
        SerialNumber: serialNumber,
        Subject: pkix.Name{
            Country:            []string{"CN"},         // 证书所属的国家
            Organization:       []string{host},         // 证书存放的公司名称
            OrganizationalUnit: []string{"Technology"}, // 证书所属的部门名称
            Province:           []string{"BeiJing"},    // 证书签发机构所在省
            CommonName:         host,
            Locality:           []string{"BeiJing"}, // 证书签发机构所在市
        },
        NotBefore:             time.Now().AddDate(-1, 0, 0),
        NotAfter:              time.Now().AddDate(99, 0, 0), // 99 年有效期
        KeyUsage:              x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign,
        ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
        EmailAddresses:        []string{"xxxx@163.com"},
        BasicConstraintsValid: true,
        IsCA:                  true,
        Issuer: pkix.Name{
            CommonName: host,
        },
    }
    if ip := net.ParseIP(host); ip != nil {
        template.IPAddresses = []net.IP{ip}
    } else {
        template.DNSNames = []string{host}
    }
    priKey, err := GenerateKeyPair()
    if err != nil {
        return nil, nil, err
    }
    cert, err := x509.CreateCertificate(rand.Reader, &template, &template, &priKey.PublicKey, priKey)
    if err != nil {
        return nil, nil, err
    }

    // 将私钥写入.key文件
    keyFd, _ := os.OpenFile("./cert.key", os.O_WRONLY|os.O_CREATE, os.ModePerm.Perm())
    defer func() {
        err = keyFd.Close()
    }()
    keyBlock := &pem.Block{
        Type:  "RSA PRIVATE KEY",
        Bytes: x509.MarshalPKCS1PrivateKey(priKey),
    }
    _ = pem.Encode(keyFd, keyBlock)
    certBlock := &pem.Block{
        Type:  "CERTIFICATE",
        Bytes: cert,
    }
    // 将证书写入.crt文件
    certFd, _ := os.OpenFile("./cert.crt", os.O_WRONLY|os.O_CREATE, os.ModePerm.Perm())
    defer func() {
        _ = certFd.Close()
    }()
    _ = pem.Encode(certFd, certBlock)
    return certBlock, keyBlock, err
}

func GenerateKeyPair() (*rsa.PrivateKey, error) {
    priKey, err := rsa.GenerateKey(rand.Reader, 2048)
    if err != nil {
       return nil, errors.New("密钥对生成失败")
    }
    return priKey, nil
}

// GeneratePem 用根证书生成新的子证书 返回参数1为公钥，2位私钥
func GeneratePem(host string) ([]byte, []byte, error) {
    max := new(big.Int).Lsh(big.NewInt(1), 128)   //把 1 左移 128 位，返回给 big.Int  
    serialNumber, _ := rand.Int(rand.Reader, max) //返回在 [0, max) 区间均匀随机分布的一个随机值
  template := x509.Certificate{
       SerialNumber: serialNumber, // SerialNumber 是 CA 颁布的唯一序列号，在此使用一个随机数来代表它
  Subject: pkix.Name{ // Name代表一个X.509识别名。只包含识别名的公共属性，额外的属性被忽略。
  Country:            []string{"CN"},         // 证书所属的国家
  Organization:       []string{"company"},    // 证书存放的公司名称
  OrganizationalUnit: []string{"department"}, // 证书所属的部门名称
  Province:           []string{"BeiJing"},    // 证书签发机构所在省
  CommonName:         host,
          Locality:           []string{"BeiJing"}, // 证书签发机构所在市
  },
       NotBefore:             time.Now().AddDate(-1, 0, 0),
       NotAfter:              time.Now().AddDate(1, 0, 0),
       KeyUsage:              x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign,
       ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
       EmailAddresses:        []string{"xxxx@163.com"},
       BasicConstraintsValid: true,
       IsCA:                  true,
       Issuer: pkix.Name{
          CommonName: host,
       },
    }
    if ip := net.ParseIP(host); ip != nil {
       template.IPAddresses = []net.IP{ip}
    } else {
       template.DNSNames = []string{host}
    }
    priKey, err := GenerateKeyPair()
    if err != nil {
       return nil, nil, err
    }
    cert, err := x509.CreateCertificate(rand.Reader, &template, i.RootCa, &priKey.PublicKey, i.RootKey)
    if err != nil {
       return nil, nil, err
    }
    certBlock := &pem.Block{
       Type:  "CERTIFICATE",
       Bytes: cert,
    }
    priKeyBlock := &pem.Block{
       Type:  "RSA PRIVATE KEY",
       Bytes: x509.MarshalPKCS1PrivateKey(priKey),
    }
    return pem.EncodeToMemory(certBlock), pem.EncodeToMemory(priKeyBlock), err
}

windows 信任根证书代码，mac 做不到自动信任，需要自己在“钥匙串访问”操作，流程可以百度

func InstallCert(certName string) error {
    current, _ := os.Getwd()
    certPath := filepath.Join(current, certName)
    cert, err := os.ReadFile(certPath)
    if err != nil {
        return fmt.Errorf("读取证书文件错误：%w", err)
    }
    block, _ := pem.Decode(cert)
    certBytes := block.Bytes
    certContext, err := windows.CertCreateCertificateContext(windows.X509_ASN_ENCODING|windows.PKCS_7_ASN_ENCODING,
        &certBytes[0],
        uint32(len(certBytes)))
    if err != nil {
        return fmt.Errorf("创建证书上下文错误：%w", err)
    }
    defer func() {
        _ = windows.CertFreeCertificateContext(certContext)
    }()
    utf16Ptr, err := windows.UTF16PtrFromString("Root")
    storeHandle, err := windows.CertOpenSystemStore(0, utf16Ptr)
    if err != nil {
        return fmt.Errorf("打开系统证书存储区失败：%w", err)
    }
    defer func() {
        _ = windows.CertCloseStore(storeHandle, windows.CERT_CLOSE_STORE_FORCE_FLAG)
    }()

    err = windows.CertAddCertificateContextToStore(storeHandle, certContext, windows.CERT_STORE_ADD_REPLACE_EXISTING_INHERIT_PROPERTIES, nil)
    if err != nil {
        return fmt.Errorf("安装系统证书失败：%w", err)
    }
    return nil
}