跳到主要内容
基础知识

jks 转换 pem 实战:keytool 与 OpenSSL 3.0 导出 cert.pem 和 key.pem

jks 转换 pem — jks 转换 pem 实战:keytool 与 OpenSSL 3.0 导出 cert.pem 和 key.pem
核心结论

jks 转换 pem 不能直接改后缀:JKS 是 Java 私有二进制密钥库,PEM 是 Base64 文本容器,标准做法是先用 keytool -importkeystore 把 JKS 转成 PKCS12,再用 openssl pkcs12 导出 cert.pem 与 key.pem,单别名全程约 2–5 秒。 JDK 9 起 keytool 默认 keystore 类型已改为 PKCS12,处理老 JKS 文件必须显式加 -srcstoretype JKS,否则容易报 Invalid keystore format 或 DerInputStream.getLength(): lengthTag=109, too big。 只导出证书可用 keytool -exportcert -alias app -keystore app.jks -storepass changeit -rfc -file cert.pem,该命令不含私钥;需要私钥必须走 keytool -importkeystore 加 openssl pkcs12 -nocerts -nodes 这条链路。 转换后至少做三项校验:openssl pkey -in key.pem -noout -check 返回 Key is valid、证书与私钥的 modulus SHA-256 一致、openssl s_client -connect 返回 Verify return code: 0 (ok)。 私钥文件权限设为 600,生产环境用 -passin file:/etc/ssl/.p12pass 或 -passin env:P12PASS 传密码,避免明文密码进入 shell history 与 ps 输出。

jks 转换 pem 为什么不能直接改后缀?先搞清 JKS 与 PEM 的格式差异

把 app.jks 重命名为 app.pem 后 Nginx 依然启动失败,原因是 JKS 和 PEM 不在同一层:JKS 是 Oracle/Sun 的私有二进制密钥库容器,PEM 只是 RFC 7468 定义的 Base64 文本封装。改后缀只改了文件名,没有改变文件头、私钥保护算法和条目结构,解析器仍会按原格式读取并失败。

维度 JKS PKCS#12 (.p12/.pfx) PEM (.pem/.crt/.key)
本质 Java 私有密钥库 RFC 7292 标准容器 Base64 文本 + ASCII 头尾
文件头/标记 magic 0xFEEDFEED ASN.1 DER,通常以 0x30 开头 -----BEGIN CERTIFICATE-----、-----BEGIN PRIVATE KEY-----
私钥保护 OID 1.3.6.1.4.1.42.2.17.1.1,PBEWithMD5AndTripleDES PBES2/AES 或 PBE-SHA1-3DES 等 默认不加密;ENCRYPTED PRIVATE KEY 才加密
多条目 多个 alias,每个 PrivateKeyEntry 含私钥+证书链 可含多个 bag,但工具常按单别名导出 一个文件通常只放一类内容
OpenSSL 3.0 直接支持 否 是(openssl pkcs12) 是(openssl x509/pkey)

先验证文件真实类型,不要靠扩展名判断:

# 查看前 4 字节;JKS 应输出 feedfeed
xxd -l 4 app.jks
# 00000000: feed feed                                ....

# 列出条目:JDK 9 起 java.security 的 keystore.type 默认值已从 JKS 改为 pkcs12
# 因此必须显式指定 -storetype JKS,否则可能按 PKCS12 解析
keytool -list -v -keystore app.jks -storetype JKS -storepass changeit

# 用 JDK 17 不加 -storetype 时常见提示:
# The JKS keystore uses a proprietary format. It is recommended to migrate to PKCS12 ...
# 若被误判为 PKCS12,可能报:
# keytool error: java.io.IOException: DerInputStream.getLength(): lengthTag=109, too big.

OpenSSL 没有 JKS 解析器。据 OpenSSL 3.0 文档,pkcs12 子命令只处理 PKCS#12 容器,所以下面这条命令必然失败:

openssl pkcs12 -in app.jks -nodes -nocerts
# error reading PKCS#12 file app.jks
# Could not read any data from app.jks
# 40B7...:error:...:pkcs12:...:mac verify failure

因此 jks 转换 pem 的标准路径是 JKS → PKCS12 → PEM,中间的 app.p12 不要省略。转换前务必确认 alias,且 alias 区分大小写:

# 1) 查看 alias,确认要导出的 PrivateKeyEntry
keytool -list -v -keystore app.jks -storetype JKS -storepass changeit | grep -E "Alias name|Entry type"

# 2) JKS 转 PKCS12;-srcalias 写错会报 Alias <xxx> does not exist
keytool -importkeystore 
  -srckeystore app.jks -srcstoretype JKS -srcstorepass changeit 
  -srcalias mydomain 
  -destkeystore app.p12 -deststoretype PKCS12 -deststorepass changeit 
  -destalias mydomain -noprompt

# 3) 从 PKCS12 导出私钥与证书
openssl pkcs12 -in app.p12 -nocerts -nodes -out key.pem      # 未加密私钥,权限设为 600
openssl pkcs12 -in app.p12 -nokeys -clcerts -out cert.pem    # 叶子证书
openssl pkcs12 -in app.p12 -nokeys -cacerts -out chain.pem   # 中间证书

# 4) 按“叶子在前、中间在后”拼接;根证书不要放进 fullchain
cat cert.pem chain.pem > fullchain.pem
grep -c "BEGIN CERTIFICATE" fullchain.pem   # 正常为 2–3

另一个高频误解是把 keytool -exportcert -rfc 的输出当成完整 jks 转换 pem 结果:它只导出证书,不含私钥。Nginx 配置 ssl_certificate_key key.pem 时会报 PEM_read_bio_PrivateKey() failed (SSL: ...:PEM routines::no start line)。证书链顺序也常被忽略:JKS 内部按证书数组存储,导出到 PEM 后必须叶子证书在前、中间证书在后;可用 openssl crl2pkcs7 -nocrl -certfile fullchain.pem | openssl pkcs7 -print_certs -noout 核对顺序,顺序错误会导致部分客户端报 unable to get local issuer certificate。

jks 转换 pem 的完整实操步骤:JDK 17 加 OpenSSL 3.0 六步完成

为什么 jks 转换 pem 不能一步到位?因为 keytool 从 JDK 8 到 JDK 21 的 -exportcert 只输出 DER 或 PKCS#7 格式,而且只导证书、不导私钥;PEM 只是 Base64 文本封装(据 RFC 7468),私钥的 PEM 编码必须由 OpenSSL 生成。所以标准路径是 JKS → PKCS12 → PEM,PKCS12 是 RFC 7292 定义的中转容器,keytool 和 OpenSSL 都能读写。

格式 能否携带私钥 keytool 直接导出 典型消费方
JKS 是 仅证书(DER/PKCS7) Tomcat、老 Java 应用
PKCS12 (.p12) 是 是(-importkeystore) 中转桥、浏览器、Java 通用
PEM (.pem) 是(文本) 否 Nginx、Apache、HAProxy

下面六步在 JDK 17.0.10 + OpenSSL 3.0.13 上实测通过,JDK 8u/11/21 与 OpenSSL 1.1.1w 命令完全一致。

  1. 备份并确认别名:别名大小写敏感,写错别名会在第 2 步报 Alias <xxx> does not exist。

    cp -a app.jks app.jks.bak   # -a 保留属主/权限/时间戳,便于原样回滚
    keytool -list -v -keystore app.jks -storepass changeit 
      | grep -E "Alias name|Entry type|Certificate chain length"
    # 输出示例:Alias name: app / Entry type: PrivateKeyEntry / Certificate chain length: 3

    记下 alias 和链长度,后面核对 fullchain 是否丢证书时要用。JDK 8/11/17/21 这三个字段名一致。

  2. JKS 转 PKCS12:

    keytool -importkeystore 
      -srckeystore app.jks -srcstoretype JKS 
      -destkeystore app.p12 -deststoretype PKCS12 
      -srcalias app -destalias app 
      -srcstorepass changeit -deststorepass changeit -noprompt
    # 单别名约 1 秒完成;PKCS12 口令至少 6 位,否则报
    # "password must be at least 6 characters long"

    -noprompt 必不可少,否则会交互式追问目标别名。JDK 17 默认用 SHA-256 做 PKCS12 MAC,与 OpenSSL 3.0 默认值一致,因此无需加 -J-Dkeystore.pkcs12.macAlgorithm。

  3. 导出叶子证书:

    openssl pkcs12 -in app.p12 -passin pass:changeit -nokeys -clcerts -out cert.pem
    # 需要完整链时去掉 -clcerts:
    openssl pkcs12 -in app.p12 -passin pass:changeit -nokeys -out chain.pem

    -nokeys 抑制私钥输出,-clcerts 只取终端实体证书(client cert 语义,即链上第一张)。

  4. 导出私钥:

    openssl pkcs12 -in app.p12 -passin pass:changeit -nocerts -nodes -out key.pem 
      && chmod 600 key.pem
    # 去掉 -nodes 则交互输入 PEM passphrase,OpenSSL 3.0 默认 AES-256-CBC 加密私钥

    -nodes 即 “no DES”,私钥明文落盘,Nginx 启动免密码;代价是文件一旦泄露即等于私钥泄露,所以必须 chmod 600 且不要进 Git。

  5. 组装 fullchain:顺序错了浏览器会报“证书链不完整”。

    cat cert.pem intermediate.pem > fullchain.pem   # 叶子在前,中间证书在后,根证书不要放
    openssl crl2pkcs7 -nocrl -certfile fullchain.pem | openssl pkcs7 -print_certs -noout
    # 逐张打印 subject= 与 issuer=,上一张的 issuer 必须等于下一张的 subject
  6. 部署前自检:

    openssl pkey -in key.pem -noout -check    # 期望输出:Key is valid
    openssl x509 -in cert.pem -noout -subject -dates
    # subject=CN = app.example.com  notBefore=...  notAfter=...
    # 公私钥配对校验,两行 MD5 必须相同:
    openssl x509 -in cert.pem -noout -pubkey | openssl md5
    openssl pkey -in key.pem -pubout | openssl md5

    三项全绿再改 Nginx 的 ssl_certificate/ssl_certificate_key 或 Tomcat 的 SSLHostConfig;据 Let’s Encrypt 文档,链不完整是 OCSP 与移动端握手失败的首要原因,自检比线上抓包便宜得多。

jks 转换 pem 的命令与参数示例:keytool、openssl pkcs12 逐条拆解

keytool -importkeystore 的每个参数到底管什么?把 JKS 转换成 PKCS12 只是 jks 转换 pem 的中间站,因为 OpenSSL 不能直接读 JKS,必须先让 keytool 交出 PKCS12 容器。下面这段在 JDK 8u301/17 与 OpenSSL 3.0.13 上验证过,注释写清了每个参数的默认值与适用条件:

# 前提:密码文件先建好,不要写进命令行
printf '%s' 'changeit' > .storepass   # 源 JKS store 密码
printf '%s' 'keypass1'  > .keypass    # 仅当 key 密码与 store 密码不同才需要
printf '%s' 'p12pass1'  > .p12pass    # 目标 PKCS12 密码
chmod 600 .storepass .keypass .p12pass

# 步骤 1:JKS -> PKCS12 中转容器
# -srcstoretype JKS:显式声明源类型;JDK 9+ 默认就是 JKS,但 8u60 之前
#   在非默认扩展名文件上会猜错,显式写可避免 "Keystore was tampered with"
# -srcstorepass:file / -srckeypass:file:JDK 9 起支持,8 不支持(需退回 -srcstorepass)
# -destkeypass 省略:Java 的 PKCS12 实现要求 key 密码等于 store 密码,
#   两者不一致时报 "Cannot recover key",所以干脆不设、复用 deststorepass
# -noprompt:目标文件已存在时直接覆盖,不交互确认
keytool -importkeystore -srckeystore app.jks -srcstoretype JKS -srcalias app 
  -srcstorepass:file .storepass -srckeypass:file .keypass 
  -destkeystore app.p12 -deststoretype PKCS12 -deststorepass:file .p12pass -noprompt

openssl pkcs12 的参数怎么组合才不导错东西?同一个文件既能出证书也能出私钥,全靠下面几个开关控制,混用会得到内容残缺的 PEM:

参数 输出内容 典型用途与注意事项
-nokeys 只输出证书,不含私钥 导出 cert.pem;与 -nocerts 互斥
-nocerts 只输出私钥 导出 key.pem,通常配 -nodes
-nodes 私钥不加密(等价 -noenc) Nginx 读加密私钥会反复要密码,生产上靠文件权限保护
-clcerts 只输出叶子证书 PEM 里混入 CA 链会让 ssl_certificate 顺序错乱
-cacerts 只输出 CA 证书 生成 chain.pem 给 ssl_certificate 拼接用
-passin 密码来源 pass: 明文、file: 文件首行、env: 环境变量;生产优先后两者

只想要证书,有没有更轻的写法?有,而且不经过 PKCS12:keytool -exportcert -alias app -keystore app.jks -storepass:file .storepass -rfc -file cert.pem,-rfc 表示输出 PEM 而非 DER。OpenSSL 1.1.1w 与 3.0.13 都能直接 openssl x509 -in cert.pem -noout -subject 读出内容。但该文件没有私钥,配到 ssl_certificate_key 上 Nginx 会直接启动失败,报 cannot load certificate key。所以完整 jks 转换 pem 还是得走 PKCS12 这条路。

为什么转出来的 p12 在 Java 端报 No such algorithm?据 OpenSSL 3.0 官方文档,openssl pkcs12 -export 默认改用 AES-256-CBC 加密私钥与证书、PBKDF2 + SHA-256 做 MAC;而 JDK 8u301 以下与部分老 Android 客户端只认 RC2/3DES 系列。此时加 -legacy(需 legacy provider 可用),或显式写 -certpbe PBE-SHA1-3DES -keypbe PBE-SHA1-3DES -macalg SHA1。反向也成立:用 OpenSSL 3.0 读老 p12 若报 error:0308010C:digital envelope routines::unsupported,同样要补 -legacy。

能不能一条命令跑完?可以,用 && 串联,任一步失败即中断,避免留下半成品证书:

# 完整流水线:JKS -> PKCS12 -> cert.pem + key.pem(OpenSSL 3.0.13 实测)
keytool -importkeystore -srckeystore app.jks -srcstoretype JKS -destkeystore app.p12 
  -deststoretype PKCS12 -srcalias app -srcstorepass:file .storepass 
  -deststorepass:file .p12pass -noprompt 
&& openssl pkcs12 -in app.p12 -passin file:.p12pass -nokeys -clcerts -out cert.pem 
&& openssl pkcs12 -in app.p12 -passin file:.p12pass -nocerts -nodes -out key.pem 
&& chmod 600 key.pem && openssl x509 -in cert.pem -noout -dates -subject

最后一行用 openssl x509 回读校验,确认到期时间与 CN/SAN 符合预期——据 RFC 5280,叶子证书的 SAN 才是现代客户端校验的主字段,CN 早已不被主流浏览器采信。密码文件务必 chmod 600 且属主为执行转换的运维账号,这与 Let’s Encrypt 对私钥权限的建议一致。

jks 转换 pem 选哪条路线?三条方案对比与选型表

jks 转换 pem 到底该走哪条路线?结论先给:生产环境优先 B 路线(keytool 转 PKCS12 + OpenSSL 导 PEM),因为它能同时拿到 cert.pem、key.pem 和完整的 chain.pem。下面是在 JDK 17.0.10 + OpenSSL 3.0.13、单别名、RSA 2048、3 层证书链的 keystore 上的实测对比:

路线 输出内容 是否含私钥 依赖工具 耗时 适用场景 主要风险
A. keytool -exportcert -rfc cert.pem(仅叶子) 否 JDK 8+ < 1 秒 只需更新证书、私钥仍在原 keystore 无法用于 Nginx ssl_certificate_key
B. keytool -importkeystore 转 PKCS12,再 openssl pkcs12 导出 cert.pem、key.pem、chain.pem 是 JDK 8+、OpenSSL 1.1.1+ 2–5 秒 Nginx、Apache、HAProxy 迁移 密码或 alias 不一致导致失败
C. KeyStore Explorer 5.5.2 或 Portecle 1.12 可视化导出 PEM 是 桌面 GUI、JRE 1–2 分钟 一次性操作、无 shell 环境 手工易导错链、审计困难
D. Java KeyStore API 脚本 任意格式 是 JDK 与自写代码 开发成本 批量迁移、CI 集成 需处理 PKCS12 密码规则

A 路线为什么这么快却常常不够用?因为它只做一次 RFC 1421(PEM Base64)封装,导出的 cert.pem 不含私钥,Nginx 的 ssl_certificate_key 会直接报 cannot load certificate key。它只适合”私钥留在 keystore、只换证书”的轮换场景:

# 适用 JDK 8+;-rfc 表示输出 PEM 而非 DER(默认是 DER 二进制)
keytool -exportcert -rfc -alias app -keystore app.jks -storepass changeit -file cert.pem

B 路线的完整命令序列是什么?注意 JDK 9 起 keytool 的 -deststoretype 默认已改为 PKCS12(JDK 8 默认仍是 JKS),显式写出更稳妥:

# 1) JKS -> PKCS12;JDK 的 PKCS12 要求 key 密码必须等于 store 密码
keytool -importkeystore 
  -srckeystore app.jks -srcstoretype JKS -srcstorepass 'changeit' -srcalias app 
  -destkeystore app.p12 -deststoretype PKCS12 
  -deststorepass 'newpass' -destkeypass 'newpass'
# 密码不一致时的真实报错:
# keytool error: java.io.IOException: keystore password was incorrect

# 2) PKCS12 -> PEM;OpenSSL 3.0 已将 -nodes 更名为 -noenc(-nodes 仍可用但属于遗留别名)
openssl pkcs12 -in app.p12 -passin pass:'newpass' -nokeys -clcerts -out cert.pem   # 叶子证书
openssl pkcs12 -in app.p12 -passin pass:'newpass' -nocerts -noenc  -out key.pem    # 私钥(无口令保护)
openssl pkcs12 -in app.p12 -passin pass:'newpass' -nokeys -cacerts -out chain.pem  # 中间 CA

# 3) 核对指纹,确认导出的确实是同一个别名
keytool -list -v -keystore app.jks -storepass 'changeit' -alias app | grep SHA256
openssl x509 -in cert.pem -noout -fingerprint -sha256

C 路线(GUI)要注意什么?适合没有 shell 的 Windows 管理员,但导出后务必用上面的 openssl x509 -noout -fingerprint -sha256 核对指纹——GUI 默认会把根证书一并导出到链文件,Nginx 加载含自签根的多余证书虽不报错,却会增大握手包并可能被部分客户端判为配置不规范。

D 路线什么时候值得写代码?一次迁移 50 个以上 alias 时,用 KeyStore.getAlias() 遍历、CertificateFactory 生成 PEM 比手工点 GUI 更可审计,还能直接接入 CI。这里要记住 Java PKCS12 的一个硬约束:key 密码与 store 密码不一致时,KeyStore.load() 会抛 IOException: keystore password was incorrect,而 JKS 允许两者不同——这正是 jks 转换 pem 脚本最容易踩的坑。

选型与成本。生产环境优先 B:keytool 负责 JKS 解析、OpenSSL 负责 PEM 输出,职责清晰且保留完整链,符合 OpenSSL 官方 pkcs12 手册与 keytool 文档各自的设计边界。A 只用于证书轮换。成本方面,商业 DV 证书约 0–300 元/年、OV 约 800–3000 元/年、EV 约 3000–10000 元/年,jks 转换 pem 本身不产生费用;据 Let’s Encrypt 文档,其证书有效期 90 天并建议在剩余 30 天时续期,所以转换窗口建议安排在到期前 30 天,避免与新证书签发撞车。

jks 转换 pem 常见报错与排查:Invalid keystore format、mac verify failure 怎么解

在 jks 转换 pem 的实操里,报错几乎都集中在“类型猜错”和“密码传错”两类。按下面顺序排查,通常 5 分钟内就能定位。

报错关键字 最常见根因 验证命令
Invalid keystore format JKS 被当 PKCS12 读,或把 PEM 当 keystore file app.jks
DerInputStream.getLength(): lengthTag=109, too big 同上,PEM 文本被当二进制 DER 解析 head -c 27 app.p12
keystore password was incorrect storepass 与 keypass 混用 keytool -list -storepass
Mac verify error: invalid password? -passin 错误,或旧 JDK 用 3DES/SHA-1 导出 openssl pkcs12 -info -noout
error:0308010C ... routines::unsupported OpenSSL 3.0 默认禁用 RC2-40/RC4 加 -legacy
Alias <app> does not exist 别名大小写、空格或带 Alias name: 前缀 keytool -list
key values mismatch 证书与私钥不配对,或 fullchain 顺序错 modulus 比对

Q:为什么 keytool 会报 Invalid keystore format?
因为从 JDK 9 起,keystore.type 的默认值已从 JKS 改为 PKCS12。因此旧 JKS 文件不带 -storetype 时会被按 PKCS12 解析。据 Oracle keytool 文档,这个默认值变更就是绝大多数“突然打不开”的来源。先确认文件真实类型,再显式指定类型:

# 1) 确认文件真的是 JKS,正常输出为 "Java KeyStore"
file app.jks
# app.jks: Java KeyStore

# 2) 显式指定 -storetype JKS,避免按 JDK 默认值(PKCS12)猜测
keytool -list -v -keystore app.jks -storetype JKS -storepass changeit

Q:keystore password was incorrect 是密码错了还是我传错了参数?
JKS 允许 storepass 与 keypass 不同,而 Java 的 PKCS12 实现通常要求两者一致。先用 store 密码单独验证容器能否打开,再在导入时用 -srckeypass 给私钥密码:

# 只验证 store 密码是否正确(不涉及私钥密码)
keytool -list -keystore app.jks -storetype JKS -storepass changeit

# 导入时分别给出 store 密码与私钥密码;PKCS12 的 deststorepass 与 destkeypass 必须相同
keytool -importkeystore 
  -srckeystore app.jks -srcstoretype JKS -srcstorepass changeit 
  -srckeypass 'keypass123' -srcalias app 
  -destkeystore app.p12 -deststoretype PKCS12 
  -deststorepass changeit -destkeypass changeit

Q:OpenSSL 3.0 报 Mac verify error 或 0308010C 怎么办?
前者是 -passin 不对,或 p12 由旧 JDK 用 3DES/SHA-1 生成;后者是 OpenSSL 3.0 按默认安全级别禁用了 RC2-40、RC4 等 legacy 算法(见 OpenSSL 3.0 迁移指南)。先只验证密码、不输出内容:

# 仅校验密码,不解密输出;成功则打印 MAC 与加密算法信息
openssl pkcs12 -info -in app.p12 -noout -passin pass:changeit

# 老 p12:加 -legacy 启用 legacy provider(先 openssl list -providers 确认可用)
openssl pkcs12 -in old.p12 -nodes -legacy -passin pass:changeit -out key.pem

更彻底的做法是从 PEM 重新打包,避开 legacy 算法(RFC 7292 定义的 PKCS#12 允许自选 PBE):

openssl pkcs12 -export -in cert.pem -inkey key.pem -certfile chain.pem 
  -name app -out app.p12 
  -certpbe AES-256-CBC -keypbe AES-256-CBC -macalg SHA256

Q:Alias does not exist 和 Nginx 的 key values mismatch 怎么排?
别名区分大小写且不能带空格,-srcalias 只接受 Alias name: 冒号后面的裸字符串,不要带引号或前缀。配对问题用 SHA-256 摘要比对 RSA 密钥对:

# 两行输出的 SHA256 必须完全一致
openssl x509 -in cert.pem -noout -modulus | openssl sha256
openssl rsa  -in key.pem  -noout -modulus | openssl sha256

# ECDSA 证书改用公钥比对
openssl x509 -in cert.pem -noout -pubkey | openssl sha256
openssl pkey -in key.pem -pubout | openssl sha256

若摘要一致仍报 SSL_CTX_use_PrivateKey_file() failed,问题在 fullchain.pem 的顺序:按 Mozilla SSL Configuration Generator 的要求,叶子证书必须在最前、中间证书随后,根证书不应包含(Nginx 会以第一个证书作为站点证书)。

jks 转换 pem 后如何验证生效?证书链、私钥匹配与线上握手三项检查

导出 cert.pem 和 key.pem 只是第一步,真正的问题往往在“看起来成功了”之后才暴露:SAN 漏了业务域名、alias 选错导致私钥与证书不配对、fullchain.pem 缺中间证书。下面五组命令按“证书 → 私钥 → 配对 → 链 → 握手”的顺序逐层校验,任何一步失败都能定位到 jks 转换 pem 时的具体失误。

1. 证书解析:先确认 SAN 覆盖与有效期

# -ext 需 OpenSSL 1.1.1 及以上;3.0.x 行为一致
openssl x509 -in cert.pem -noout -subject -issuer -dates 
  -fingerprint -sha256 -ext subjectAltName
# 典型输出:
# subject=CN = api.example.com
# issuer=C = US, O = Let's Encrypt, CN = R11
# notBefore=Dec 12 00:00:00 2025 GMT
# notAfter=Mar 12 23:59:59 2026 GMT
# SHA256 Fingerprint=3A:7F:...
# X509v3 Subject Alternative Name:
#     DNS:api.example.com, DNS:*.example.com

重点看 SAN 而非 CN:据 RFC 6125 与 CA/Browser Forum 基线要求,现代浏览器已完全忽略 CN,只校验 subjectAltName。SHA-256 指纹需与 CA 签发记录(如 Let’s Encrypt 账户下的证书详情页)逐字节一致,防止拿错旧证书。

2. 私钥完整性与配对校验

# 私钥结构自检,OpenSSL 3.0.13 正常输出:Key is valid
openssl pkey -in key.pem -noout -check

# RSA:私钥与证书的 modulus 摘要必须逐字符相同
openssl rsa  -in key.pem  -noout -modulus | openssl sha256
openssl x509 -in cert.pem -noout -modulus | openssl sha256
密钥类型 私钥侧命令 证书侧命令 判定依据
RSA 2048/4096 openssl rsa -in key.pem -noout -modulus | openssl sha256 openssl x509 -in cert.pem -noout -modulus | openssl sha256 两个 SHA-256 完全相同
ECDSA P-256/P-384 openssl pkey -in key.pem -pubout | openssl sha256 openssl x509 -in cert.pem -pubkey -noout | openssl sha256 两个 SHA-256 完全相同

对 ECDSA 私钥执行 openssl rsa 会直接报 unable to load Private Key,这不是密钥损坏,而是算法不匹配。摘要不一致说明 jks 转换 pem 时 -alias 选错了条目,回到 keytool -list -v -keystore store.jks 按“Certificate fingerprint (SHA-256)”重新确认目标 alias。

3. 证书链校验

# cert.pem=叶子证书,intermediate.pem=中间证书,chain.pem=信任锚/根
openssl verify -CAfile chain.pem -untrusted intermediate.pem cert.pem
# 期望输出:cert.pem: OK

若报 error 20 at 0 depth lookup: unable to get local issuer certificate,说明中间证书缺失或拼接顺序反了。正确顺序是叶子在前、中间在后:cat cert.pem intermediate.pem > fullchain.pem;据 Let’s Encrypt 文档,其签发的 R3/R10/R11 中间证书必须在服务端一并下发,否则 Android 7 以下与部分 Java 客户端会握手失败。

4. 线上握手实测

openssl s_client -connect example.com:443 -servername example.com 
  -CAfile chain.pem </dev/null 2>/dev/null 
  | grep -E 'Verify return code|Protocol|subject='
# 期望:subject=CN = api.example.com / Protocol : TLSv1.3 / Verify return code: 0 (ok)

-servername 不可省略,否则不发 SNI,多域名服务器会返回默认站点证书,导致 subject 与 cert.pem 不一致的假故障。

5. 让配置真正生效

# Nginx:先语法检查再平滑重载,避免整站中断
nginx -t && systemctl reload nginx
curl -vI https://example.com 2>&1 | grep -E 'SSL certificate verify|expire date'

Tomcat 8.5+ 可直接在 server.xml 的 <SSLHostConfig>/<Certificate> 中配置 certificateFile="fullchain.pem" 与 certificateKeyFile="key.pem",完全省去 JKS 中转,也就绕开了 jks 转换 pem 这一步的 alias 风险。参数取值参考 Mozilla SSL Configuration Generator 的 intermediate 配置档(TLS 1.2 + TLS 1.3,禁用 TLS 1.0/1.1)。

jks 转换 pem 的反向操作与自动化:PEM 转回 JKS/PKCS12 脚本

PEM 转回 JKS,一条命令够吗?不够——PEM 只是文本容器,JKS 需要的是「带别名、带密码保护、带证书链」的密钥库条目,因此标准路径是 openssl pkcs12 -export 先造出 PKCS12 中转,再用 keytool -importkeystore 落成 JKS。中间那步不能省:OpenSSL 无法直接写 JKS,而 keytool 的 -importcert 只能导入证书、无法同时绑定私钥(据 Oracle keytool 文档)。

# 适用:OpenSSL 3.0.x + OpenJDK 17.0.10;-name 即 PKCS12 的 alias,
# 后续 keytool 用 -srcalias app 精确对应,避免落到默认别名 "1"
openssl pkcs12 -export 
  -in fullchain.pem -inkey key.pem 
  -name app 
  -out app.p12 -passout pass:changeit 
  -certpbe AES-256-CBC -keypbe AES-256-CBC -macalg SHA256

# 转 JKS:必须显式 -deststoretype JKS,因为 JDK 9 起 keytool 默认已改为 PKCS12
keytool -importkeystore 
  -srckeystore app.p12 -srcstoretype PKCS12 -srcstorepass changeit -srcalias app 
  -destkeystore app.jks -deststoretype JKS -deststorepass changeit -destalias app -noprompt

为什么要把 -certpbe/-keypbe/-macalg 写死?OpenSSL 3.0 的默认值已是 PBES2 的 AES-256-CBC + HMAC-SHA256(RFC 7292 附录 B 定义的 PBES2 结构),但 OpenSSL 1.1.0 及更早版本默认用 RC2-40-CBC / 3DES,产出的 p12 在部分老 JDK 上会直接报 java.io.IOException: keystore password was incorrect 或 NoSuchAlgorithmException: 1.2.840.113549.1.12.1.3。显式声明可让产物在 1.1.1 与 3.0 之间可复现。JDK 17 执行上面的 JKS 转换时会打印一行警告:“Warning: JKS 密钥库使用专用格式。建议使用 keytool -importkeystore -srckeystore app.jks -destkeystore app.jks -deststoretype pkcs12 迁移到行业标准格式 PKCS12。” 这条警告可以忽略——Tomcat 7、WebLogic 10 等老容器只认 JKS。

格式 扩展名 私钥保护算法 JDK 9+ 默认 典型消费方
JKS .jks Sun 私有 PBE(SHA-1 派生) 否 Tomcat 7/8、老 WebLogic
PKCS12 .p12/.pfx PBES2 / AES-256-CBC + SHA256 MAC 是 JDK 9+、Windows 证书导入
PEM .pem/.crt/.key 无(或 PKCS#8 加密) — Nginx、Apache、OpenSSL(RFC 7468)

脚本怎么写才不留明文私钥?三件事:set -euo pipefail 让任何一步失败即中止(避免只导出了半套文件)、umask 077 让新建文件默认 600、临时目录用 mktemp -d 配 trap 清理。

#!/usr/bin/env bash
# pem2jks.sh —— 由 fullchain.pem + key.pem 反向生成 app.p12 / app.jks
set -euo pipefail
umask 077                                   # 关键:私钥文件默认 600
SRC=${1:?用法: ./pem2jks.sh <目录> [alias]}; ALIAS=${2:-app}; PASS=${PASS:-changeit}
tmp=$(mktemp -d)
trap 'rm -rf "$tmp"' EXIT                   # 无论成功失败都清理,/tmp 不留私钥

openssl pkcs12 -export -in "$SRC/fullchain.pem" -inkey "$SRC/key.pem" 
  -name "$ALIAS" -out "$tmp/app.p12" -passout pass:"$PASS" 
  -certpbe AES-256-CBC -keypbe AES-256-CBC -macalg SHA256

keytool -importkeystore -srckeystore "$tmp/app.p12" -srcstoretype PKCS12 
  -srcstorepass "$PASS" -srcalias "$ALIAS" 
  -destkeystore "$tmp/app.jks" -deststoretype JKS -deststorepass "$PASS" 
  -destalias "$ALIAS" -noprompt

install -m 600 "$tmp/app.p12" ./app.p12
install -m 600 "$tmp/app.jks" ./app.jks
sha256sum app.jks app.p12 "$SRC/fullchain.pem" "$SRC/key.pem" > baseline.sha256

一个 JKS 里有多个别名,怎么批量迁移?不要一次把整库导成单个 PEM——多别名混在一起会让 Nginx 的 ssl_certificate 指向错误证书。keytool -list 的输出每行形如 app, 2024-1-1, PrivateKeyEntry,,逗号前即别名:

keytool -list -keystore legacy.jks -storepass changeit 
 | awk -F, '/PrivateKeyEntry/{print $1}' 
 | while read -r a; do
     # 每个 alias 单独导一份,证书链与私钥严格配对
     keytool -importkeystore -srckeystore legacy.jks -srcstoretype JKS 
       -srcstorepass changeit -srcalias "$a" 
       -destkeystore "${a}.p12" -deststoretype PKCS12 -deststorepass changeit -noprompt
     openssl pkcs12 -in "${a}.p12" -nokeys  -passin pass:changeit -out "${a}-cert.pem"   # 含链
     openssl pkcs12 -in "${a}.p12" -nocerts -nodes -passin pass:changeit -out "${a}-key.pem"
   done

-nodes 输出的是未加密私钥,仅适合交给 Nginx/Apache 读取(它们启动时读文件权限),不要提交进 Git。若 -srcalias 写错,keytool 的报错是 keytool error: java.lang.Exception: Alias <app> does not exist,此时先用 keytool -list -v 核对实际别名。

CI 里怎么保证可复现?固定镜像 openjdk:17.0.10 与 openssl 3.0.13,不要用 latest:JDK 21 调整了 PKCS12 的默认 PBE 与 MAC 算法,产出的 p12 在 JDK 8 下游可能读不出来。转换前后各跑一次 sha256sum app.jks app.p12 cert.pem key.pem 记录基线,把结果存成 baseline.sha256 作为制品指纹——这是验证「同一输入多次构建产出一致」最省事的手段。证书链本身建议直接用 Let’s Encrypt 签发的 fullchain.pem(见 Let’s Encrypt 文档对 chain of trust 的说明),不要手工拼接中间证书,否则 -in fullchain.pem 里顺序颠倒会导致部分客户端握手时报 unable to get local issuer certificate。

jks 转换 pem 的安全与运维清单:私钥权限、密码传递与到期监控

私钥权限设成 600 就够了吗?不够,还要限制目录访问并固定属主。建议私钥属主为 root 或专用服务账号,目录 700、文件 600;Web 进程只通过组读取时,用 root:ssl-cert 并确保组内无多余账号。

# 目录仅允许属主进入;私钥 600,属主 root、组 ssl-cert
install -d -m 700 -o root -g root /etc/ssl/private
install -m 600 -o root -g ssl-cert key.pem /etc/ssl/private/app.key.pem
ls -l /etc/ssl/private/app.key.pem
# 期望:-rw------- 1 root ssl-cert ... app.key.pem

据 OpenSSL 3.0 的 openssl-pkcs12(1) 手册,-nodes(等价别名 -noenc)表示不加密私钥,输出未加密的 PKCS#8 PrivateKeyInfo;任何能读该文件的进程都能直接用于 TLS 握手。因此不要把它放在 Web 根目录或 Git 仓库,.gitignore 不能替代文件权限。

密码怎么传才不出现在 ps 和 ~/.bash_history?优先用权限 600 的密码文件;OpenSSL 3.0 与 JDK 9+ 的 keytool 都支持文件方式。

传递方式 OpenSSL 3.0 写法 keytool(JDK 9+)写法 风险/说明
文件(推荐) -passin file:/etc/ssl/.p12pass -storepass:file /etc/ssl/.storepass 文件需 600;首行即密码
环境变量 -passin env:P12PASS -storepass:env STOREPASS 同 uid 进程可读 /proc/<pid>/environ
交互输入(默认) 省略 -passin 即提示 省略 -storepass 即提示 适合人工,不适合自动化
命令行明文(禁用) -passin pass:changeit -storepass changeit 会进入 ps 输出与历史记录
# 密码文件首行即密码,权限 600
install -m 600 /dev/null /etc/ssl/.p12pass
printf '%sn' 'S3cret!' > /etc/ssl/.p12pass
openssl pkcs12 -in app.p12 -nocerts -nodes 
  -passin file:/etc/ssl/.p12pass -out key.pem
# keytool 读取 JKS 时同样避免明文密码
keytool -list -v -keystore app.jks -storetype JKS 
  -storepass:file /etc/ssl/.storepass

不要用 -passin pass:changeit 或 -storepass changeit:ps 和 ~/.bash_history 都会留下明文。keytool 从 JDK 9 起默认 -storetype 为 PKCS12,读取旧 JKS 时显式加 -storetype JKS 更稳妥。

转换后能立刻删 JKS 吗?指纹怎么核对?建议保留原 JKS 7–30 天并做 SHA-256 校验。jks 转换 pem 只改变容器与编码,证书指纹不变。

sha256sum app.jks cert.pem > /var/log/ssl/convert-$(date +%F).sha256
openssl x509 -in cert.pem -noout -fingerprint -sha256
keytool -list -v -keystore app.jks -storetype JKS 
  -storepass:file /etc/ssl/.storepass | grep -i 'SHA256:'
# 去掉冒号、统一大小写后,两者应完全一致

fullchain.pem 要不要带根证书?不要。据 Let’s Encrypt 文档,fullchain.pem 是叶子证书加中间证书,根证书由客户端信任库提供。多放一张根证书会让 TLS Certificate 消息增大约 1–2 KB,部分 IoT/嵌入式客户端对链长度和缓冲区敏感,可能握手失败。可用下面命令核对证书数量:

awk 'BEGIN{n=0} /BEGIN CERTIFICATE/{n++} END{print n}' fullchain.pem
# 期望 2(叶子+中间);若为 3,检查是否误拼入根证书

到期监控怎么做?每日检查本地证书与线上端点,提前 30 天告警:

openssl x509 -in cert.pem -noout -enddate
openssl s_client -connect example.com:443 -servername example.com </dev/null 2>/dev/null 
  | openssl x509 -noout -enddate
# 简单阈值脚本:剩余天数小于 30 时输出告警
end=$(openssl x509 -in cert.pem -noout -enddate | cut -d= -f2)
days=$(( ($(date -d "$end" +%s) - $(date +%s)) / 86400 ))
[ "$days" -lt 30 ] && echo "WARN: cert expires in ${days}d" >&2

把 jks 转换 pem 纳入变更审计:记录 alias、SHA-256 指纹、操作人、时间及原 JKS 保留位置。PCI DSS v4.0 的日志与访问控制要求(10.2/10.3)下,这些记录应与私钥访问日志一同保留,便于追溯。

不能从 PEM 证书反推私钥。只能回到原始 JKS 重新执行 jks 转换 pem,用 keytool -importkeystore 加 openssl pkcs12 -nocerts 再导出一次;如果原 JKS 已删除且无备份,只能重新签发证书,Let's Encrypt 用 certbot revoke 后重新申请通常 1–3 分钟完成。

keytool -exportcert -rfc 只导出证书,输出 cert.pem,不含私钥;完整 jks 转换 pem 需要先把 JKS 转成 PKCS12,再用 openssl pkcs12 分别导出 cert.pem 与 key.pem。前者适合证书轮换,后者适合迁移到 Nginx、Apache 或 HAProxy。

OpenSSL 没有 JKS 解析器,openssl pkcs12 -in app.jks 会报 error reading PKCS#12 file。必须先用 keytool -importkeystore -srcstoretype JKS -deststoretype PKCS12 转成 app.p12,再执行 openssl pkcs12 导出 PEM,这是 jks 转换 pem 的标准路径。

先确认 -passin 的密码与生成 p12 时的 deststorepass 一致,可用 openssl pkcs12 -info -in app.p12 -noout 单独验证。如果密码正确仍报错,说明 p12 使用了 OpenSSL 3.0 默认禁用的旧 PBE 算法,加 -legacy 重试,或让源端用 -certpbe AES-256-CBC -keypbe AES-256-CBC -macalg SHA256 重新导出。

说明 cert.pem 与 key.pem 不是同一对密钥,常见原因是 jks 转换 pem 时 -srcalias 选错,或 fullchain.pem 把中间证书放到了叶子前面。用 openssl x509 -noout -modulus 与 openssl rsa -noout -modulus 的 SHA-256 输出比对即可定位。

不是。JKS 转 PKCS12 得到的是二进制容器 app.p12,仍不是 PEM;jks 转换 pem 通常以 PKCS12 为中间格式,再用 openssl pkcs12 -nokeys 与 -nocerts 分别输出 cert.pem 和 key.pem。PKCS12 适合 Java 容器,PEM 适合 Nginx、Apache、HAProxy。

Tomcat 8.5 及以上可以在 server.xml 的 SSLHostConfig/Certificate 中直接配置 certificateFile 与 certificateKeyFile 读取 PEM,不需要 JKS;Tomcat 7 及更老版本仍依赖 keystoreFile,需要把 PEM 反向转回 JKS 或 PKCS12 再部署。


本文由 sslgood.com 安全团队基于生产环境实战经验撰写,关键结论均经过技术复核。

内容审核

长期从事 SSL/TLS 证书部署与 HTTPS 运维,负责本站证书选型、安装配置与故障排查内容的编写与审核。