公私密钥对的概念梳理与常见用法

平时写代码、配服务器,我们几乎每天都在和“公钥、私钥”打交道:把 ~/.ssh/id_ed25519.pub 贴到 GitHub、给网站续期 HTTPS 证书、用 RS256 签发 JWT、或者给 Git Commit 挂个绿色的 Verified 标记。

但真要一下子串起来讲清楚,很多人容易在几个地方犯迷糊:为什么有时是“公钥加密、私钥解密”,有时又是“私钥签名、公钥验签”?SSH 登录时明明私钥没发出去,服务器凭什么放行?HTTPS 既然用了非对称加密,为什么又说传输正文用的是对称加密?

这篇文章不堆数学推导,重点把公私密钥对的心智模型理顺,再顺着这个模型去看它在三个最常见工程场景里是怎么落地的。

一、先想明白:只有一把钥匙时卡在哪里

在有非对称密钥之前,密码学主要靠对称密钥:加密和解密用同一把钥匙(比如 AES),算消息认证码和验证也用同一把钥匙(比如我在HMAC 和普通哈希差在哪里写过的 HMAC)。

对称算法速度极快、强度也很高,但在互联网上直接用它会卡在两个死胡同里:

  1. 密钥怎么安全送出去? 如果你和远端服务器之间没有任何预先共享的秘密,在可能被窃听的网络上,你没法把“用于加密的密码”明文发给对方。
  2. 验证方自己也能伪造。 因为收发双方拿着一模一样的钥匙,凡是你能验证真假的消息,你也有能力自己伪造一份一模一样的。这在“同一家公司的两个后端服务之间”没问题,但放到“认证中心签发登录态、几十个业务服务各自验票”或者“软件作者证明安装包是自己发的”这类场景里就行不通了。

非对称密钥对(Asymmetric Key Pair) 解决的就是这两个问题。

通过特定的数学单向难题(比如大整数质因数分解、椭圆曲线离散对数),我们可以成对生成两把相互关联的钥匙:

  • 私钥(Private Key):绝对保密,永远留在生成者自己手里。
  • 公钥(Public Key):完全公开,贴在网页上、传给陌生人、甚至写进公开仓库都无所谓——因为算力上不可能从公钥反推出私钥。

二、一对钥匙的两种玩法:保密 vs 验真

因为两把钥匙能力不对称,非对称密钥在工程上拆成了两种截然不同的用法。下面这个交互图可以切换两种模式,看清楚到底谁拿什么钥匙、网络上传的是什么:

玩法一:公钥锁,私钥开(解决“别人看不见”)

任何人只要拿到 Bob 的公钥,就能把消息锁起来发给 Bob;哪怕整段密文在公网上被所有人截获,也只有握着私钥的 Bob 能解开。

但这里有一个工程上几乎人人踩过的认知坑:现代协议几乎不用非对称算法直接加密业务数据。

原因很现实:

  • 太慢了:大数模幂或椭圆曲线点乘的计算开销,比 AES-GCM / ChaCha20 慢几个数量级。
  • 有长度限制:例如 RSA 一次能加密的明文长度受限于密钥模长(2048 位 RSA 加上填充后,单次最多也就加密两百来字节)。

所以真实世界采用的是混合加密(Hybrid Encryption):非对称算法只负责“把一把一次性的对称会话密钥安全地送到对面(或由双方协商出来)”,真正传网页、传文件、传视频流,全靠那把对称密钥。

玩法二:私钥签,公钥验(解决“是谁发的、没被改”)

当你需要证明“这条消息确实出自 Alice,且中途没被改过一个字节”时,流程反过来:Alice 用自己的私钥对消息摘要(Hash)做一次签名,把 (原始消息, 签名) 一起发出去;任何拿到 Alice 公钥的人,都能离线验证签名是否成立。

这里顺便澄清两个特别容易弄混的点:

  1. “数字签名”不是“用私钥把消息加密一遍”。 早年教材喜欢拿裸 RSA 举例,因为它的数学形式恰好看起来能互逆(m^d mod n 和 c^e mod n),导致很多人误以为所有签名都能“用公钥解密还原出原文”。实际上现代签名算法(Ed25519、ECDSA、RSA-PSS)和加密完全是两套机制:你不能从一段 Ed25519 签名里“解密”出消息,只能把 (消息, 签名, 公钥) 喂进验证函数,换回一个布尔值 true / false。
  2. 不是每对密钥都能“既加密又签名”。 除了 RSA 在规范上可以分开用于加解密(RSA-OAEP)和签名(RSA-PSS)外,现代椭圆曲线生态是专钥专用的:比如 Ed25519 和 ECDSA 只用来做签名,X25519(ECDH) 只用来做密钥交换,并不直接加密消息。

贯穿所有场景的隐藏前提:你怎么确定这把公钥真是对方的?

这是理解所有现实协议最关键的一把钥匙。

非对称密码学本身只能向你保证一件事:“这份签名确实是由与这把公钥配对的私钥生成的。” 它回答不了“这把公钥到底属不属于张三”。

如果中间人 Mallory 截断了你的网络连接,把自己的公钥递给你并自称是 Bob,后续所有的加密和验签在数学上都会严丝合缝地通过——只不过你是在和 Mallory 安全通信。

因此,SSH、HTTPS、JWT、Git 之间最大的差异,往往不在加解密算法本身,而在于它们各自用什么机制来建立对公钥归属权的信任。

信任机制常见代表核心做法
首次信任(TOFU)SSH (known_hosts)第一次连接时由人确认指纹并记住,之后只要变动就报警
预置白名单SSH (authorized_keys)、Git (allowed_signers)提前把受信任的公钥放进配置文件,登录或验签时查表
第三方权威背书(PKI)HTTPS / TLS操作系统预装根 CA 公钥,由 CA 层层签发证书来证明域名与公钥的绑定关系
统一公钥端点JWT (JWKS)业务服务从认证中心受信任的地址(或内网配置)拉取公钥集合

带着这个视角,再看下面三个最常见的场景,所有零散的文件名和配置项就会自动落回原位。


三、场景一:SSH 免密登录(~/.ssh、ssh-agent 与 known_hosts)

很多人用 ssh-keygen -t ed25519 生成完密钥、把 .pub 塞进服务器,就开始畅通无阻地登录了,甚至以为整个过程只用到了自己电脑上那一对钥匙。

其实一次完整的 ssh user@host 连接,背后同时动用了两对独立的非对称密钥和一次临时密钥交换。下面可以按步骤点开看整个握手流转:

把几个关键文件的分工拆开看,会非常清楚:

1. 先验服务器:ssh_host_* 与 known_hosts

在你把登录凭据发出去之前,客户端得先确定对面真是你的服务器,而不是中间人搭的蜜罐。

服务器在 /etc/ssh/ 下存着它自己的主机密钥对(如 ssh_host_ed25519_key 和 .pub)。握手时,双方先通过临时的 ECDH(常见是 curve25519-sha256)协商出本次连接的对称会话密钥,以及一个全连接唯一的 session_id;随后服务器用主机私钥对这段握手摘要签名。

客户端拿到主机公钥后,翻看本地 ~/.ssh/known_hosts:

  • 第一次连这台机器:表里没有记录,SSH 采用 TOFU(Trust On First Use) 策略,把公钥的 SHA-256 指纹打到屏幕上让你自己核对并输入 yes。确认后写入 known_hosts。
  • 以后再连:只要服务器的主机公钥和 known_hosts 里记的不一致,SSH 会直接报错中断(WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED!)。

2. 再验你本人:id_ed25519 与 authorized_keys

服务器身份确认完毕,才轮到客户端自证身份。

注意:客户端从来不会把私钥发给服务器,也不是把公钥发过去就算登录成功(公钥谁都能拿到)。真正发生的是标准的“挑战—签名”:

  1. 客户端先报上自己打算用的公钥(~/.ssh/id_ed25519.pub 的内容)。
  2. 服务器的 sshd 查一遍目标用户的 ~/.ssh/authorized_keys,确认这把公钥确实在白名单里。
  3. 客户端本地用私钥,对一段包含当前连接 session_id、用户名、公钥在内的握手数据生成数字签名,发给服务器。
  4. 服务器用 authorized_keys 里的公钥验签。通过,放行。

因为签名原文里绑死了本次连接现算出来的 session_id,哪怕有人在半路(甚至在极端的密钥泄露场景下)截到了这段签名,换一条新连接也是完全没用的。

3. ssh-agent 在这里干什么

如果你生成私钥时设了密码(passphrase),私钥文件在硬盘上其实是用对称加密锁住的。为了避免每次 ssh 或 git pull 都重新输一遍密码解锁,通常会把它交给后台进程 ssh-agent。

ssh-agent 把解密后的私钥留在自己的进程内存里,对外只暴露一个 Unix Socket(环境变量 $SSH_AUTH_SOCK 指向它)。当 ssh 客户端需要签名时,只把待签名的挑战摘要发给 ssh-agent,拿回签名结果——ssh 进程自己甚至都不直接碰原始私钥。

顺带提一个常见的安全提醒:尽量不要随便开 Agent Forwarding(ssh -A)连到不完全信任的跳板机。虽然跳板机拷不走你本地的私钥文件,但只要你挂着转发的 socket,跳板机上的 root 就可以在你连着的那段时间里,借用你的 ssh-agent 替它签名去登录你的其他服务器。跨跳板机更稳妥的做法是用 ProxyJump(ssh -J jump target):

# 推荐:由本地直接和目标机端到端握手,跳板机只负责转发加密 TCP 流
ssh -J bastion@jump-host app@target-host

四、场景二:HTTPS / TLS 1.3(CA 证书链与前向保密)

SSH 可以靠 known_hosts 让你人工点一次 yes,但浏览器不行——你每天点开几十个从未访问过的网页,不可能每次都弹窗让你核对一串 SHA-256 指纹。

HTTPS 用 PKI(公钥基础设施)和 CA 证书链 解决了“初次见面就建立信任”的问题,再用 ECDHE + 对称加密 解决传输效率和历史流量安全。下面把 TLS 1.3 的关键几步拆出来看看:

1. 证书到底是什么,信任链怎么串起来

一张 X.509 服务器证书(Certificate)本身并不神秘,拆开看核心就四样东西:

  1. 主体信息(比如绑定的域名 example.com)
  2. 属于这个域名的公钥
  3. 有效期和用途限制
  4. 签发机构(CA)对上面这些内容的数字签名

信任的起点预先埋在你的操作系统或浏览器里(比如 macOS 的钥匙串、Linux 的 /etc/ssl/certs、Firefox 自带的 NSS 根证书库),里面内置了几十上百家受信任根 CA(Root CA)的公钥。

为了降低根私钥的风险,根 CA 一般离线锁在保险库里,平时只用来给中间 CA(Intermediate CA)签名背书;中间 CA 再去给成千上万个网站域名签名。浏览器收到网站发来的一串证书后,从最顶端的根 CA 一级级用上级公钥往下验签:

[系统内置 根 CA 公钥] ──验签──▶ [中间 CA 证书] ──验签──▶ [example.com 证书]
                                                            │
                                                            ▼
                                               提取出 example.com 的公钥

只要这条签名链完整、每张证书都没过期且未被吊销,浏览器就能放心得出结论:“这张证书里写的这把公钥,确实属于 example.com。”

2. 光亮证书不够,还要证明“私钥在我手里”

CA 签发的证书是公开信息,任何人都可以通过 TLS 握手下载到某大厂的完整证书文件。如果攻击者把 example.com 的证书原封不动转发给你,你怎么拆穿他?

答案就在 TLS 1.3 的 CertificateVerify 消息里:服务器必须拿出自己本地保管的域名私钥(这把私钥永远不出现在证书里),对当前已经交换过的整段握手记录(ClientHello、ServerHello、Certificate 等的哈希)做一次数字签名。

浏览器拿出刚才从证书里提取出的域名公钥去验这个签名。哪怕中间人偷到了正版证书,没有域名私钥就签不出合法的 CertificateVerify,冒充立刻穿帮。

3. 为什么 TLS 1.3 非要单独搞一套 ECDHE 临时密钥

细心看上面这张图,会发现域名那对非对称密钥从头到尾只做了一件事:身份签名,根本没用来加密数据!

真正负责生出对称密钥的,是握手一开始就塞在 ClientHello 和 ServerHello 里的 临时 X25519 密钥对(ECDHE,带 Ephemeral “临时”的 E)。客户端和服务器各自现造一对一次性的密钥,把各自的临时公钥发给对方,随后各自用“自己的临时私钥 + 对方的临时公钥”独立算出同一把对称密钥(比如 AES-256-GCM 或 ChaCha20-Poly1305)。

这样做除了“对称加密跑得快”之外,还有一个极其重要的特性叫前向保密(Forward Secrecy):

握手一结束,双方立刻把那对临时的 X25519 私钥从内存里抹掉。哪怕几年之后服务器被攻破、域名证书对应的长期私钥泄露了,攻击者翻出当年在骨干网上录下来的加密流量,依然解不开哪怕一个字节——因为当年用来算对称密钥的临时私钥早已不存在了。

如果想亲眼看一眼某个网站的证书链和握手用的密钥交换参数,终端里一行 openssl 就能拉出来(这里 -showcerts 会把整条证书链打出来):

$ openssl s_client -connect github.com:443 -tls1_3 -brief
CONNECTION ESTABLISHED
Protocol version: TLSv1.3
Ciphersuite: TLS_AES_128_GCM_SHA256
Peer certificate: CN = github.com
Hash used: SHA256
Signature type: ECDSA
Verification: OK
Server Temp Key: X25519, 253 bits

输出最后两行把两件事分得清清楚楚:Signature type(身份签名用的是证书密钥)和 Server Temp Key: X25519(会话密钥协商靠的是临时椭圆曲线密钥)。


五、场景三:JWT 与 Git Commit 签名(跨边界的“公开可验真”)

把前两个场景的加密和握手剥掉,非对称签名单独拿出来,在日常开发里还有两个高频用法:分布式系统的令牌签发(JWT) 和 代码提交溯源(Git 签名)。它们的共同诉求都是——只有唯一一方能产出,但允许任何一方(甚至完全不信任的第三方)独立验证真伪。

1. 为什么微服务架构更偏爱 RS256 / ES256 / EdDSA

在单体应用里,JWT 常用 HS256(底层就是 HMAC-SHA256)。签发和验签都在同一个进程里,大家共享同一个 JWT_SECRET,简单又快。

一旦拆成微服务或者开放给第三方接入,共享同一个 secret 就会非常别扭:

  • 只要有 20 个下游业务服务需要校验用户 Token,你就得把同一份 JWT_SECRET 分发到 20 个服务的环境变量里;
  • 这不仅意味着密钥轮换得 20 个服务一起协调重启,更致命的是——任何一个边缘非核心服务一旦被攻破泄露了 JWT_SECRET,攻击者立刻就能自己签发超级管理员 Token。

换成非对称签名(比如 ES256 或 EdDSA)后,权限边界立刻干净了:

[认证中心 Auth Service] ──(持有私钥)──▶ 签发 JWT (header.payload.signature)
         │
         │ 公开暴露公钥集合
         ▼
   /.well-known/jwks.json
         │
         ├──▶ [订单服务]  ──(只拿公钥)──▶ 本地离线验签,无法伪造 Token
         ├──▶ [网关服务]  ──(只拿公钥)──▶ 本地离线验签,无法伪造 Token
         └──▶ [第三方 App] ──(只拿公钥)──▶ 本地离线验签,无法伪造 Token

认证中心把公钥按 JWKS(JSON Web Key Set) 格式挂在标准路径上,下游服务定时拉取缓存在内存里即可。每次请求进来直接本地验签,既不需要每次打认证中心的网络接口,也不用担心公钥泄露——公钥本来就是公开的。

顺带一提一个经典的工程安全坑:下游验签代码千万不要盲目相信 JWT Header 里的 alg 字段,一定要在服务端写死自己期望的算法(比如只允许 EdDSA 或 ES256)。历史上有过著名的“算法混淆攻击”:服务端原本用 RS256 验签,攻击者却把公钥文件的内容当成 HMAC 密钥、伪造一个 alg: HS256 的 Token 传过去,结果粗心的 JWT 库真拿那份公开的公钥去跑 HS256 验签,居然给放行了。

2. Git Commit / Tag 签名:别再靠 user.name 认人了

很多人刚知道一件事时会有点吃惊:git config user.name 和 user.email 纯粹是两行毫无校验的普通字符串。任何人只要在本地执行两句 git config,就能以团队 CTO 甚至 Linus Torvalds 的名义提交代码并推到远程仓库。

开启 Commit 签名后,Git 在生成提交对象时,会把 tree 哈希、父提交哈希、作者、提交时间戳和提交说明整块拿去用你的私钥签名,把生成的签名块直接写进 Commit Object 的 header 里(可以用 git cat-file -p HEAD 看到那段 gpgsig)。

过去大家因为觉得配置 GPG(OpenPGP)太繁琐而懒得开;其实从 Git 2.34 开始,已经可以直接复用你本就配好的 SSH 密钥对 来给提交签名了:

# 直接复用现有 SSH 公钥作为 Git 签名密钥
git config --global gpg.format ssh
git config --global user.signingkey ~/.ssh/id_ed25519.pub
git config --global commit.gpgsign true

去 GitHub / GitLab 的 SSH Keys 设置里把同一把公钥类型标成 Signing Key 上传,以后每次提交就会多出绿色的 Verified 标志;如果是团队自建仓库本地校验,维护一份 allowed_signers 文件记录团队成员邮箱与公钥的映射即可。同一对 Ed25519 钥匙,既管 SSH 登录鉴权,又管代码提交防伪。


六、一张表串起全局与几个实用建议

把上面梳理的所有场景收拢到一张表里,可以看到“公钥、私钥、信任从哪来”这三条主线是如何严丝合缝地对上的:

场景用到的核心能力谁拿私钥谁拿公钥公钥的信任从哪来
SSH 识别服务器签名 / 验签目标服务器 (ssh_host_*)你的电脑 (known_hosts)首次连接人工确认指纹(TOFU)
SSH 用户免密登录签名 / 验签你的电脑 (ssh-agent)服务器 (authorized_keys)预先手动写入服务器配置
HTTPS / TLS 1.3临时 ECDHE + 签名Web 服务器(及双方临时密钥)浏览器系统内置根 CA → 证书链签发
JWT (RS256/EdDSA)签名 / 验签认证中心各下游业务服务 / 网关内网配置或 JWKS 端点
Git Commit 签名签名 / 验签提交者本地GitHub / 协作者账号绑定公钥 / allowed_signers
业务正文传输加密对称加密(握手协商出的同一把对称密钥)—非对称握手保护下安全协商得来

最后留四条平时写代码和配系统时最管用的判断准则:

  1. 分清“加密”还是“签名”。想让别人看不见,找加密(或密钥协商 + 对称加密);想证明来源和防篡改,找签名。不要混用概念,也别指望一个只用来签名的密钥去加密正文。
  2. 先想“信任根”,再聊密码学。每次系统里引入公私钥,先问自己一句:“验证方凭什么相信手里这把公钥不是冒名顶替的?”这个问题答不上来,算法再强也能被中间人绕过去。
  3. 私钥不过界。一旦发现某个架构要求把同一把私钥复制给多个不完全同信任域的服务(比如 HS256 的 shared secret 满天飞),通常就是该切到非对称签名的时候了。
  4. 现代工程选型优先 Ed25519 / X25519。新生成 SSH 密钥、新签发服务间 JWT、新系统做签名和密钥交换时,没有历史兼容包袱的话,优先选 Ed25519(签名)和 X25519(密钥交换):公钥短(32 字节)、性能高、且不像传统 ECDSA 那样容易因为随机数质量问题把私钥算穿;需要兼容老硬件或传统网关时再回退到 ECDSA P-256 或 RSA-2048/3072。
#密码学#非对称加密#SSH#HTTPS#数字签名#JWT