同一个 HTTPS 站点,自己用工具抓包只能看到一堆十六进制的字节,看不出请求路径,更看不到密码;而公司的上网行为管理设备却能列出每个人访问了哪个页面的哪个字段。两个人的疑问是一样的:加密到底加在哪一层,为什么有人能解开,有人不能?

答案分两半。抓包工具看到的是链路上的字节,TLS 把这些字节加密了,所以只能看到握手和一个接一个的加密记录。公司设备能解开,是因为它在中间扮演了另一个“服务端”,并且你信任了它签发的证书。它不是破解了加密,而是让你自愿把加密的终点挪到了它那里。

这篇先搭一个最小的 HTTPS 服务,用自签证书,让流量穿过一个只会记录字节的代理,直观看到“代理能记录多少、能看到多少”。然后再回头解释证书、密钥和握手到底在做什么,以及为什么明文协议换成 HTTPS 之后,抓包这件事的性质变了。

现象:能连上、能看到域名,却看不到内容

先澄清一个常见误解:HTTPS 不是“把整个包加密”。TCP 头、IP 头、甚至 TLS 握手最开始的部分都是明文,抓包工具能清楚看到源地址、目的地址、端口,也能看到 SNI 里的域名。被加密的是握手完成之后的记录内容,也就是真正的请求行、请求头、响应体。

所以“抓包看不到内容”不等于“什么都看不到”。你能知道谁在和谁通信、用了哪个域名、大概传了多少字节、连接持续了多久。这些元数据足以做流量分析,也足以判断服务是否可用。真正被保护的是内容本身和密钥。

另一个现象是证书告警。浏览器打开一个自建服务,弹出“连接不是私密连接”,点继续还能访问。这个告警不是加密失败,而是身份校验失败:加密通道建起来了,但证书不是受信任的机构签发的,或者域名对不上。很多人以为“点继续就不安全”,其实数据仍然加密,只是你无法确认对面是谁。

还有一类现象更隐蔽:某些客户端在特定网络下请求失败,换个网络就正常,报错里带着证书或握手字样。这可能是中间设备替换了证书,也可能是客户端不支持对方的加密套件。两者的排查方向完全不同,一个要查信任链,一个要查协议版本。

HTTPS 到底加了什么

一句话解释:HTTPS 就是 HTTP 外面套了一层 TLS。HTTP 负责“说什么”,TLS 负责“只有双方能听懂,并且确认对面是谁”。TLS 提供三件事:机密性,内容在链路上是密文;完整性,内容被改动能被发现;身份认证,客户端能验证服务端的证书链。

它用的不是一种加密,而是两类配合。握手阶段用非对称加密(公钥和私钥)来协商和验证身份,因为双方还没有共享密钥;协商出会话密钥后,正式数据传输改用对称加密,因为对称加密快得多。这个分工是所有现代安全协议的共同思路:用慢的解决“怎么安全地约定”,用快的解决“怎么大量地传”。

证书的作用是把“公钥”和“身份”绑在一起。证书里写着域名、公钥、有效期、签发机构,以及签发机构对这个内容的签名。客户端拿到证书后,用内置的根证书去验证签名链,确认这张证书确实是被信任的机构签发的,再检查域名是否匹配、时间是否在有效期内。

所以证书不是“密码”,也不是“加密算法”。它解决的是“你连的那个人是不是真的”,加密解决的是“别人能不能看懂”。两者缺一不可:只加密不验证身份,中间人可以冒充服务端;只验证身份不加密,内容照样被看光。

走查:一次 TLS 握手的关键几步

TLS 1.3 握手的顺序
TCP 建连先完成三次握手,得到一个可靠的字节通道
客户端问候列出支持的版本、加密套件、扩展,带上域名指示
服务端问候选定版本和套件,回随机数,随后发送证书链
验证证书客户端沿信任链验签,检查域名、有效期、用途
协商密钥双方用密钥交换算法算出一个共享的会话密钥
加密通信后续记录用会话密钥加密,握手完成

第二步的“客户端问候”是明文,所以抓包能看到域名指示,这也是为什么在只加密内容的情况下,仍然能知道你在访问哪个站点。同一个 IP 上托管多个站点时,服务端靠这个字段决定出示哪张证书,这一步必须在加密之前完成。

第三步的证书链可能很长,会被拆成多个记录发送。抓包时看到一段较长的加密记录,往往就是证书。它是公开信息,本身不加密,任何人都能读,这也是为什么证书内容可以被工具展示。

第五步是现代 TLS 的关键。双方并不是“把密钥发过去”,而是各自算出一个只有对方能算出的共享秘密。即使有人录下了全部握手流量,只要拿不到私钥,也算不出会话密钥,这就是前向保密。TLS 1.3 还把这个过程压缩到一个往返,减少了握手延迟。

第六步之后,所有内容都变成加密记录。每条记录有自己的头部,写明类型和长度,后面是密文。抓包工具能看到记录的边界和长度,但看不到里面的字节,除非它有会话密钥。这也是为什么流量分析只能看“聊了多久、传了多大”,不能看“聊了什么”。

实测:让 TLS 流量穿过一个只记录字节的代理

下面这段程序做了三件事:用自签证书起一个 TLS 服务端;起一个普通的 TCP 代理,记录两个方向的字节;客户端连代理,让 TLS 握手穿过代理。这样代理就站在“中间人”的位置,但它没有密钥。本机用 Python 3.15,证书用 openssl 现场生成。

import socket, ssl, threading, time

CAP = {"c2s": b"", "s2c": b""}
SEEN = []

def tls_server(port_holder):
    ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
    ctx.load_cert_chain("cert.pem", "key.pem")
    s = socket.socket()
    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    s.bind(("127.0.0.1", 0))
    port_holder.append(s.getsockname()[1])
    s.listen(2)
    def loop():
        c, _ = s.accept()
        tls = ctx.wrap_socket(c, server_side=True)
        req = tls.recv(4096)
        SEEN.append(req)
        tls.sendall(b"HTTP/1.1 200 OK\r\nContent-Length: 6\r\n\r\nsecret")
        tls.close()
    threading.Thread(target=loop, daemon=True).start()

def proxy(target_port, listen_holder):
    s = socket.socket()
    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    s.bind(("127.0.0.1", 0))
    listen_holder.append(s.getsockname()[1])
    s.listen(2)
    def loop():
        c, _ = s.accept()
        up = socket.create_connection(("127.0.0.1", target_port))
        def pump(a, b, key, tag):
            while True:
                try:
                    d = a.recv(4096)
                except OSError:
                    break
                if not d:
                    break
                CAP[key] += d
                print("[proxy] %s %3d bytes" % (tag, len(d)))
                b.sendall(d)
            try: b.close()
            except OSError: pass
        threading.Thread(target=pump, args=(c, up, "c2s", "客户端到服务器"), daemon=True).start()
        threading.Thread(target=pump, args=(up, c, "s2c", "服务器到客户端"), daemon=True).start()
    threading.Thread(target=loop, daemon=True).start()

sp, pp = [], []
tls_server(sp); time.sleep(0.2); proxy(sp[0], pp)

info = ssl._ssl._test_decode_cert("cert.pem")
print("证书 subject =", dict(x[0] for x in info["subject"]))
print("证书 notAfter=", info["notAfter"])

ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
ctx.check_hostname = False
ctx.verify_mode = ssl.CERT_NONE
tls = ctx.wrap_socket(socket.create_connection(("127.0.0.1", pp[0])), server_hostname="localhost")
print("TLS 版本   =", tls.version())
print("TLS 密码套件 =", tls.cipher()[0])
print("证书长度   =", len(tls.getpeercert(binary_form=True)))
tls.sendall(b"GET /secret HTTP/1.1\r\nHost: localhost\r\n\r\n")
print("响应       =", tls.recv(4096).decode().replace("\r\n", " | "))
tls.close(); time.sleep(0.3)

print("代理看到的上行前 16 字节 =", CAP["c2s"][:16].hex(" "))
print("代理看到的下行前 16 字节 =", CAP["s2c"][:16].hex(" "))
print("上行总字节 =", len(CAP["c2s"]), "下行总字节 =", len(CAP["s2c"]))
print("代理能否读到 GET /secret :", b"GET /secret" in CAP["c2s"])
print("代理能否读到 secret       :", b"secret" in CAP["s2c"])

一次实际运行的输出如下。代理日志和主线程是并发打印的,顺序会有交错,数字也会随握手包大小略有变化。

证书 subject = {'commonName': 'localhost'}
证书 issuer  = {'commonName': 'localhost'}
证书 notAfter= Nov  8 14:13:15 2026 GMT
[proxy] 客户端到服务器 1516 bytes
[proxy] 服务器到客户端 2425 bytes
TLS 版本   = TLSv1.3
TLS 密码套件 = TLS_AES_256_GCM_SHA384
证书长度   = 781
[proxy] 客户端到服务器  80 bytes
[proxy] 客户端到服务器  63 bytes
[proxy] 服务器到客户端 255 bytes
[proxy] 服务器到客户端 255 bytes
[proxy] 服务器到客户端  66 bytes
响应       = HTTP/1.1 200 OK | Content-Length: 6 |  | secret
代理看到的上行前 16 字节 = 16 03 01 05 e7 01 00 05 e3 03 03 2c cb 30 c2 72
代理看到的下行前 16 字节 = 16 03 03 04 ba 02 00 04 b6 03 03 6d e9 a5 da 29
上行总字节 = 1659 下行总字节 = 3001
代理能否读到 GET /secret : False
代理能否读到 secret       : False

先看前 16 字节。上行以 16 开头,这是 TLS 记录类型“握手”;后面两个字节 03 01 是记录版本;再往后是长度和握手消息类型。下行以 16 03 03 开头,同样是握手记录。也就是说,代理确实看到了握手,但握手之后的内容它只能记录长度,读不出明文。

输出最后两行是关键证据:代理完整转发了上行 1659 字节、下行 3001 字节,却搜不到“GET /secret”这个字符串,也搜不到响应体里的“secret”。它不是没有收到,而是收到的是密文。客户端拿到了正确响应,说明通道正常工作,加密没有妨碍传输。

再看证书那几行。证书的主题和签发者都是 localhost,说明它是自签的,没有第三方背书;有效期到 11 月 8 日,很短。浏览器或默认校验的客户端遇到这种证书会直接拒绝。用默认的客户端上下文连它,本机得到的报错是:[SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: self-signed certificate。这是身份校验失败,不是加密失败。

握手包的大小也值得注意。上行第一个包 1516 字节,带着客户端支持的套件和扩展;下行 2425 字节,带着证书链和协商结果。TLS 1.3 的握手内容比很多人想象的大,因为它们要在最开始把能谈的都谈清楚。公网站点上这些包还会受到 MTU 限制被拆成多段,抓包时看到“握手阶段好几个包”很正常。

证书校验:到底在检查什么

一次完整的校验要过好几关:证书链能不能一路验到受信任的根;签名算法和密钥长度是否被允许;证书里的域名是否和请求的域名匹配,通配符只能覆盖一级;当前时间是否在有效期内;证书用途是否允许做服务端认证;证书是否被吊销。任何一关不过,客户端都应该拒绝连接。

“受信任的根”来自操作系统或浏览器的内置列表。换一台设备、换一个浏览器、甚至换一个运行环境,信任列表都可能不同。这就是为什么同一个自签服务,在命令行里报错,在某个测试工具里却能连上,因为后者把校验关掉了。

把校验关掉是一件很危险的事。它意味着你接受任何证书,中间人可以随便冒充。开发环境图方便可以临时这么做,但绝不能出现在生产配置里。反过来,如果生产环境的报错是证书类错误,正确的做法是修证书链或补根证书,而不是关校验。

证书过期是另一个高频事故。证书有效期通常按年计,到期前需要续签;自动化续签失败、时间不同步、证书链缺中间证书,都会让浏览器报错。排查时先看证书的起止时间,再看链是否完整,最后才怀疑加密套件。

为什么公司代理能看懂你的 HTTPS

因为它不是旁观者,而是参与者。代理收到你的连接请求后,自己先和真正的服务器建一条 TLS 连接,再和你建另一条 TLS 连接,中间用一张由公司根证书签发的证书冒充目标站点。你的设备如果安装了公司的根证书,就会认为这张证书合法,于是两条连接都正常建立,代理在中间看到的是明文。

这套机制叫中间人解密,本身没有攻破 TLS,只是让“终点”提前了。它能成立的前提有两个:设备信任了那张根证书,客户端没有做额外的证书固定。如果应用把证书指纹硬编码,或者使用了双向认证,代理就解不开。

这也解释了为什么“换个网络就能打开”的证书错误,到了公司网络反而“正常”。不是公司网络更安全,而是它替换了证书。企业出于合规做这件事可以理解,但用户应当知道自己的流量在哪里被解密,以及哪些应用绕过了它。

在没有安装公司根证书的设备上,同样的代理只会导致连接失败或证书告警。攻击者做中间人也是同样的道理,区别只在于你有没有信任那张证书。所以证书告警不能随手点“继续”,那不是麻烦,那是唯一的提示。

现象对照表

现象真实原因第一步查什么
抓包只能看到十六进制,看不到请求内容被 TLS 加密,只有握手和记录边界可见看记录类型和长度,确认是否已进入加密阶段
浏览器提示证书不受信任自签证书,或缺少中间证书,链不完整看证书签发者和链的完整性
证书时间正常却仍然报错域名不匹配,或通配符覆盖不到当前子域核对证书里的域名列表和实际访问域名
公司网络能访问,家里不能公司安装了根证书并做了中间人解密看证书签发者是否变成公司自己的机构
握手阶段反复重试后失败协议版本或加密套件不兼容,被中间设备拦截对比两端支持的版本和套件,检查中间设备策略
证书突然过期导致全站不可用续签失败或系统时间错误看证书有效期和服务器时间
只看到域名,没看到路径域名在握手中明文传输,路径在加密记录里这是正常现象,不要误判成抓包不完整
同样内容每次抓到的密文都不同每次连接协商的密钥和随机数不同不要试图对比密文,应对比长度和时序

边界与代价

HTTPS 的第一个代价是握手时间。TCP 建连一个往返,TLS 握手一个往返(1.3)或更多(1.2),叠加起来就是首屏前的固定开销。会话复用、连接复用、预连接能缓解,但没法完全消除。这也是为什么“减少连接数”比“优化加密算法”更有效。

第二个代价是证书运维。签发、部署、续期、吊销、链完整,每一环都可能出错,而且出错时用户看到的是安全警告,不是普通的错误页。自动化能省事,但自动化失败时往往没人发现,直到证书真的过期。

第三个代价是可见性下降。加密保护了用户,也让运维失去了排障手段。以前能直接看到的错误响应,现在只能看到“连接被重置”。于是有了在服务端解密、在网关记录元数据、在客户端埋点这些折中方案,每一种都在隐私和可运维性之间做交换。

第四个代价是“加密不等于安全”。TLS 保护的是传输过程,服务端被攻破、数据库被拖库、应用把密钥写进日志,这些问题它一个都管不了。同样,证书只能证明“这个域名背后的服务端持有私钥”,不能证明“这个服务端值得信任”。安全是一整条链,HTTPS 只是其中一段。

当天能自己验证的练习

  1. 用 openssl 生成一张自签证书,起一个 TLS 服务,用默认校验的客户端连一次,记录完整的报错文字,再把校验关掉连一次,对比两次结果。
  2. 把上面的代理实验跑一遍,确认代理搜不到请求字符串,但能看到上行和下行的总字节数。
  3. 用 ssl 模块打印连接协商出的版本和加密套件,再强制只允许旧版本,观察握手是否失败。
  4. 访问一个真实的 HTTPS 站点,记录证书的签发者、有效期和域名列表,和浏览器地址栏里显示的信息对照。
  5. 在开发者工具的安全面板里看一次连接的协议版本和密钥交换信息,再对比命令行里的握手耗时。本机没有配置企业代理,中间人解密的实际部署未在本机实测。

小结

HTTPS 是 HTTP 套上一层 TLS:握手阶段协商版本、验证证书、算出会话密钥,之后的内容用对称加密传输。抓包能看到地址、端口、域名和记录长度,看不到请求行、请求头和响应体,因为那些已经变成密文。证书解决“对面是谁”,加密解决“别人能不能看懂”,两件事不能互相替代。

公司代理能看懂内容,是因为它把自己插进了两条连接中间,并且你的设备信任了它的证书;这不是破解,是信任被主动交了出去。看到证书告警时,先查链、域名和时间,不要养成点“继续”的习惯。

这一组八篇到这里就结束了。从分层、地址、连接、解析、请求,到路径、抓包和加密,一条请求的每一段都被拆开看过一遍。真正的收获不是记住协议细节,而是遇到问题时能先问一句:现在是哪一层在说话,我手上的证据又来自哪一层。