DNS解析

最新推荐文章于 2024-02-23 10:00:16 发布
最新推荐文章于 2024-02-23 10:00:16 发布
阅读量1.4k 收藏
点赞数
分类专栏： 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xie__peng/article/details/123237859
版权

前端 服务器 http

1. 背景

最近遇到DNS解析慢的问题，梳理了一下DNS消息结构，用C++写了一个DNS解析过程。

2. 相关数据结构

2.1. DNS消息基类

class dns {
public:
    int hostlen(const unsigned char *buffer)
    {
        int length = 0;

        for (; ; ) {
            if ('\0' == buffer[length]) {
                length++;
                break;
            } else if (0xc0 == (buffer[length] & 0xc0)) {
                length += 2;
                break;
            }

            length++;
        }

        return length;
    }

    const char *hostname(const unsigned char *raw, int len, char *buffer, size_t size)
    {
        for (int res2 = 1; res2 < len - 1; res2++) {
            if ((raw[res2] >= 'a' && raw[res2] <= 'z') || (raw[res2] >= 'A' && raw[res2] <= 'Z')
                || (raw[res2] >= '0' && raw[res2] <= '9') || ('-' == raw[res2])) {
                buffer[res2 - 1] = raw[res2];
            } else {
                buffer[res2 - 1] = '.';
            }
        }

        return buffer;
    }

    const char *ipv4host(const unsigned char *raw, int len, char *buffer, size_t size)
    {
        int length = 0;

        for (int res = 0; res < len; res++) {
            length += snprintf(buffer + length, size - length - 1, "%d.", raw[res]);
        }
        buffer[length - 1] = '\0';

        return buffer;
    }

    const char *ipv6host(const unsigned char *raw, int len, char *buffer, size_t size)
    {
        int length = 0;

        for (int res = 0; res < len; res++) {
            length += snprintf(buffer + length, size - length - 1, "%02x:", raw[res]);
        }
        buffer[length - 1] = '\0';

        return buffer;
    }
protected:
private:
};

2.2. DNS header处理数据结构

class header {
public:
    explicit header(unsigned char *buffer) : head(nullptr)
    {
        ::memcpy(data, buffer, sizeof(data));
        head = (header_msg_t *)data;
    }

    int display() const
    {
        fprintf(stdout, "DNS header information:\n");
        fprintf(stdout, "    binary(%d):\n        ", (int)sizeof(header_msg_t));
        for (int res = 0; res < sizeof(header_msg_t); res++) {
            printf("0x%02x ", data[res]);
        }
        printf("\n\n");
        fprintf(stdout, "    0x%x \t\t Transaction ID\n", head->id);
        fprintf(stdout, "    Flags:\n");
        fprintf(stdout, "        %d \t\t %s\n", head->qr, head->qr ? "Response: Message is a response" : "Request: Message is a query");
        fprintf(stdout, "        %d \t\t %s\n", head->opcode, opcode());
        fprintf(stdout, "        %d \t\t %s\n", head->aa, head->qr ? (head->aa ? "Authoritative server" : "Non authoritative server") : "meaningless for request");
        fprintf(stdout, "        %d \t\t %s\n", head->tc, head->tc ? "Message is not truncated" : "Message is truncated");
        fprintf(stdout, "        %d \t\t %s\n", head->rd, head->rd ? "Do query recursively" : "Not do query recursively");
        fprintf(stdout, "        %d \t\t %s\n", head->ra, head->ra ? "Server can recursive queries" : "Server can not recursive queries");
        fprintf(stdout, "        %d \t\t reserved(0)\n", head->z);
        fprintf(stdout, "        %d \t\t %s\n", head->rcode, rcode());
        fprintf(stdout, "    %3d \t\t Questions\n", ntohs(head->qdcount));
        fprintf(stdout, "    %3d \t\t Answer RRs\n", ntohs(head->ancount));
        fprintf(stdout, "    %3d \t\t Authority RRs\n", ntohs(head->nscount));
        fprintf(stdout, "    %3d \t\t Additional RRs\n\n", ntohs(head->arcount));

        return sizeof(header_msg_t);
    }

    int questions() const
    {
        return ntohs(head->qdcount);
    }

    int answers() const
    {
        return ntohs(head->ancount);
    }

    int authority() const
    {
        return ntohs(head->nscount);
    }

    int additional() const
    {
        return ntohs(head->arcount);
    }
protected:
    const char *opcode(void) const
    {
        switch (head->opcode) {
        case 0:
            return "query: standard query";
        case 1:
            return "iquery: inverse query";
        case 2:
            return "status: DNS request status";
        case 5:
            return "update: DNS request update";
        default:
            break;
        }

        return "reserved for future use";
    }

    const char *rcode(void) const
    {
        switch (head->rcode) {
        case 0:
            return "success";
        case 1:
            return "Format error";
        case 2:
            return "Server failure";
        case 3:
            return "Name Error";
        case 4:
            return "Not Implemented";
        case 5:
            return "Refused";
        default:
            break;
        }

        return "Reserved for future use";
    }
private:
    /*! RFC 1035. */
    typedef struct header_msg {
        short   id;
#if __BYTE_ORDER == __BIG_ENDIAN
        unsigned char    qr:1;
        unsigned char    opcode:4;
        unsigned char    aa:1;
        unsigned char    tc:1;
        unsigned char    rd:1;

        unsigned char    ra:1;
        unsigned char    z:3;
        unsigned char    rcode:4;
#else
        unsigned char    rd:1;
        unsigned char    tc:1;
        unsigned char    aa:1;
        unsigned char    opcode:4;
        unsigned char    qr:1;

        unsigned char    rcode:4;
        unsigned char    z:3;
        unsigned char    ra:1;
#endif
        unsigned short   qdcount;
        unsigned short   ancount;
        unsigned short   nscount;
        unsigned short   arcount;
    } __attribute__((__packed__)) header_msg_t;

    unsigned char data[sizeof(header_msg_t)];
    header_msg_t  *head;
};

2.3. 请求消息处理数据结构

class request : private dns {
public:
    explicit request(unsigned char *buffer, int offset, int num = 1)
        : buffer(buffer), rnum(num), offset(offset)
    {}

    int display()
    {
        unsigned char *raw = buffer + offset;
        int length = 0;
        char binary[1024] = {0};
        int binlen = 0;

        printf("Queries information:\n");
        for (int res = 0; res < rnum; res++) {
            int len = hostlen(raw);
            char name[128] = {0};

            length += len;
            query_t query = {0};
            memcpy(&query, raw + length, sizeof(query));
            binlen += snprintf(binary + binlen, sizeof(binary) - binlen, "    Name: %s\n", hostname(raw, len, name, sizeof(name)));
            binlen += snprintf(binary + binlen, sizeof(binary) - binlen, "    Type: %s (%d)\n", qtype(ntohs(query.qtype)), ntohs(query.qtype));
            binlen += snprintf(binary + binlen, sizeof(binary) - binlen, "    Class: %s (%d)\n", qclass(ntohs(query.qclass)), ntohs(query.qclass));
        }

        printf("    binary(%d):\n        ", (int)sizeof(query_t) + length);
        for (int res = 0, res2 = 1; res < sizeof(query_t) + length; res++, res2++) {
            printf("0x%02x ", raw[res]);
            if (0 == (res2 % 16)) {
                printf("\n        ");
            }
        }
        printf("\n\n%s\n", binary);

        return sizeof(query_t) + length;
    }
protected:
    const char *qtype(unsigned short type) const
    {
        static const char *reqtype[] = {
            "unknow type",
            "a host address",
            "an authoritative name server",
            "a mail destination (Obsolete - use MX)",
            "a mail forwarder (Obsolete - use MX)",
            "the canonical name for an alias",
            "marks the start of a zone of authority",
            "a mailbox domain name (EXPERIMENTAL)",
            "a mail group member (EXPERIMENTAL)",
            "a mail rename domain name (EXPERIMENTAL)",
            "a null RR (EXPERIMENTAL)",
            "a well known service description",
            "a domain name pointer",
            "host information",
            "mailbox or mail list information",
            "mail exchange",
            "text strings"
        };

        return reqtype[type];
    }

    const char *qclass(unsigned short cls) const
    {
        static const char *reqclass[] = {
            "unknow class",
            "the Internet",
            "the CSNET class",
            "the CHAOS class",
            "Hesiod"
        };

        return reqclass[cls];
    }
private:
    typedef struct query {
        unsigned short   qtype;
        unsigned short   qclass;
    } __attribute__((__packed__)) query_t;

    unsigned char   *buffer;
    int             rnum;
    int             offset;
};

2.4. DNS响应处理数据结构

class response  : private dns {
public:
    explicit response(unsigned char *buffer, int offset, int num = 1)
        : buffer(buffer), anum(num), offset(offset)
    {}

    int display()
    {
        unsigned char *raw = buffer + offset;
        char binary[1024] = {0};
        int binlen = 0;
        int length = 0;

        printf("Answers information:\n");
        for (int res = 0; res < anum; res++) {
            if (0xc0 == (raw[0] & 0xc0)) {
                int len = hostlen(buffer + raw[1]);
                answer_t answer;
                char name[128] = {0};

                memset(&answer, 0, sizeof(answer));
                memcpy(&answer, raw + 2, sizeof(answer));
                binlen += snprintf(binary + binlen, sizeof(binary) - binlen, "    Name: %s\n", hostname(buffer + raw[1], len, name, sizeof(name)));
                binlen += snprintf(binary + binlen, sizeof(binary) - binlen, "    Type: %s (%d)\n", rtype(ntohs(answer.rtype)), ntohs(answer.rtype));
                binlen += snprintf(binary + binlen, sizeof(binary) - binlen, "    Class: %s (%d)\n", rclass(ntohs(answer.rclass)), ntohs(answer.rclass));
                binlen += snprintf(binary + binlen, sizeof(binary) - binlen, "    Time to live: %d (%d minutes)\n", ntohl(answer.rttl), ntohl(answer.rttl) / 60);
                binlen += snprintf(binary + binlen, sizeof(binary) - binlen, "    Data length: %d\n", ntohs(answer.rdlen));

                char address[128] = {0};
                switch (ntohs(answer.rtype)) {
                case 1:
                    binlen += snprintf(binary + binlen, sizeof(binary) - binlen, "    %s: %s\n", rtype(ntohs(answer.rtype)), ipv4host(raw + 2 + sizeof(answer), ntohs(answer.rdlen), address, sizeof(address)));
                    break;
                case 28:
                    binlen += snprintf(binary + binlen, sizeof(binary) - binlen, "    %s: %s\n", rtype(ntohs(answer.rtype)), ipv6host(raw + 2 + sizeof(answer), ntohs(answer.rdlen), address, sizeof(address)));
                    break;
                default:
                    binlen += snprintf(binary + binlen, sizeof(binary) - binlen, "    %s: %s\n", rtype(ntohs(answer.rtype)), hostname(raw + 2 + sizeof(answer), ntohs(answer.rdlen) - 1, address, sizeof(address)));
                    break;
                }
                raw += 2 + sizeof(answer) + ntohs(answer.rdlen);
                length += 2 + sizeof(answer) + ntohs(answer.rdlen);
            }
            binlen += snprintf(binary + binlen, sizeof(binary) - binlen, "\n");
        }

        printf("    binary(%d):\n        ", length);
        for (int res = 0, res2 = 1; res < length; res++, res2++) {
            printf("0x%02x ", (buffer + offset)[res]);
            if (0 == (res2 % 16)) {
                printf("\n        ");
            }
        }
        printf("\n\n%s", binary);

        return length;
    }

    virtual ~response()
    {
    }
protected:
    const char *rtype(unsigned short type) const
    {
        switch (type) {
        case 1:
            return "A"; /*! 主机地址记录。在 DNS 域名与 IP 地址之间建立映射关系 */
        case 2:
            return "NS"; /*! Name Server, 域名服务器记录, 用来指定该域名由哪个DNS服务器来进行解析. */
        case 5:
            return "CNAME"; /*! Canonical Name, 别名记录, 允许您将多个名字映射到同一台计算机 */
        case 6:
            return "SOA"; /*! SOA记录表明了DNS服务器之间的关系, SOA记录表明了谁是这个区域的所有者 */
        case 11:
            return "WKS";
        case 12:
            return "PTR"; /*! 指针记录, 用来指向域名空间中的某个位置 */
        case 13:
            return "HINFO"; /*! 主机信息 */
        case 15:
            return "MX"; /*! Mail Exchanger, 记录是邮件交换记录，它指向一个邮件服务器 */
        case 28:
            return "AAAA";
        case 33:
            return "SRV"; /*! 说明一个服务器能够提供什么样的服务 */
        case 252:
            return "AXFR";
        case 255:
            return "ANY";
        default:
            break;
        }

        return "unknow";
    }

    const char *rclass(unsigned short rclass) const
    {
        static const char *reqclass[] = {
            "unknow class",
            "the Internet",
            "the CSNET class",
            "the CHAOS class",
            "Hesiod"
        };

        return reqclass[rclass];
    }
private:
    typedef struct answer {
        unsigned short   rtype;
        unsigned short   rclass;
        unsigned int     rttl;
        unsigned short   rdlen;
    } __attribute__((__packed__)) answer_t;

    unsigned char   *buffer;
    int             anum;
    int             offset;
};

2.5. 主程序

int main(int argc, const char *argv[])
{
    struct          __res_state dns_state = {0};
    unsigned char   buffer[4096] = {0};
    int             offset = 0;

    if (argc < 2) {
        printf("Please input a address:\n");
        return -1;
    }

    res_ninit(&dns_state);
    int res = res_nsearch(&dns_state, argv[1], ns_t_a, ns_c_in, buffer, sizeof(buffer));
    if (res > 0) {
        printf("receive '%d' bytes data\n", res);

        header head(buffer);
        offset += head.display();

        request request(buffer, offset, head.questions());
        offset += request.display();

        response response(buffer, offset, head.answers());
        offset += response.display();

        res_nclose(&dns_state);
    } else {
        printf("Request failure!\n");
    }

    return 0;
}

3. 运行结果（以www.baidu.com为例）

receive '90' bytes data
DNS header information:
    binary(12):
        0xee 0xaf 0x81 0x80 0x00 0x01 0x00 0x03 0x00 0x00 0x00 0x00 

    0xffffafee 		 Transaction ID
    Flags:
        1 		 Response: Message is a response
        0 		 query: standard query
        0 		 Non authoritative server
        0 		 Message is truncated
        1 		 Do query recursively
        1 		 Server can recursive queries
        0 		 reserved(0)
        0 		 success
      1 		 Questions          // 表明发送了一个请求消息
      3 		 Answer RRs         // 表明响应消息有三个
      0 		 Authority RRs
      0 		 Additional RRs

Queries information:
    binary(19):
        0x03 0x77 0x77 0x77 0x05 0x62 0x61 0x69 0x64 0x75 0x03 0x63 0x6f 0x6d 0x00 0x00 
        0x01 0x00 0x01 

    Name: www.baidu.com
    Type: a host address (1)
    Class: the Internet (1)

Answers information:
    binary(59):
        0xc0 0x0c 0x00 0x05 0x00 0x01 0x00 0x00 0x00 0x00 0x00 0x0f 0x03 0x77 0x77 0x77 
        0x01 0x61 0x06 0x73 0x68 0x69 0x66 0x65 0x6e 0xc0 0x16 0xc0 0x2b 0x00 0x01 0x00 
        0x01 0x00 0x00 0x00 0x40 0x00 0x04 0x24 0x98 0x2c 0x5f 0xc0 0x2b 0x00 0x01 0x00 
        0x01 0x00 0x00 0x00 0x40 0x00 0x04 0x24 0x98 0x2c 0x60 

    Name: www.baidu.com
    Type: CNAME (5)
    Class: the Internet (1)
    Time to live: 0 (0 minutes)
    Data length: 15
    CNAME: www.a.shifen

    Name: www.a.shifen.
    Type: A (1)
    Class: the Internet (1)
    Time to live: 64 (1 minutes)
    Data length: 4
    A: 36.152.44.95

    Name: www.a.shifen.
    Type: A (1)
    Class: the Internet (1)
    Time to live: 64 (1 minutes)
    Data length: 4
    A: 36.152.44.96

3.1. Queries information分析

Queries information:
    binary(19):
        0x03 0x77 0x77 0x77 0x05 0x62 0x61 0x69 0x64 0x75 0x03 0x63 0x6f 0x6d 0x00 0x00 
        0x01 0x00 0x01 

    Name: www.baidu.com
    Type: a host address (1)
    Class: the Internet (1)
  • 请求消息的QNAME是变长的，且以标签进行划分的，如上二进制中的：0x03，0x05，0x03表示name的长度
  • QNAME以‘\0’结尾，其后的二进制0x00表示结尾符
  • 0x00 0x01：表示QTYPE类型
  • 0x00 0x01：表示QCLASS类型

3.2. Answers information分析

Answers information:
    binary(59):
        0xc0 0x0c 0x00 0x05 0x00 0x01 0x00 0x00 0x00 0x00 0x00 0x0f 0x03 0x77 0x77 0x77 
        0x01 0x61 0x06 0x73 0x68 0x69 0x66 0x65 0x6e 0xc0 0x16 0xc0 0x2b 0x00 0x01 0x00 
        0x01 0x00 0x00 0x00 0x40 0x00 0x04 0x24 0x98 0x2c 0x5f 0xc0 0x2b 0x00 0x01 0x00 
        0x01 0x00 0x00 0x00 0x40 0x00 0x04 0x24 0x98 0x2c 0x60 

    Name: www.baidu.com
    Type: CNAME (5)
    Class: the Internet (1)
    Time to live: 0 (0 minutes)
    Data length: 15
    CNAME: www.a.shifen

    Name: www.a.shifen.
    Type: A (1)
    Class: the Internet (1)
    Time to live: 64 (1 minutes)
    Data length: 4
    A: 36.152.44.95

    Name: www.a.shifen.
    Type: A (1)
    Class: the Internet (1)
    Time to live: 64 (1 minutes)
    Data length: 4
    A: 36.152.44.96
  • Name：变长，若以0xc0开头，则表示name使用相对位置存放。如：0xc0 0x0c：表示name值相对于头开始偏移0x0c的位置即为name值；否则就是Name值

Amazing9
关注
专栏目录
DDOS之DNS Request Flood攻击和防御
顶峰
03-30 687
1、网络安全理论知识（2天）①了解行业相关背景，前景，确定发展方向。②学习网络安全相关法律法规。③网络安全运营的概念。④等保简介、等保规定、流程和规范。（非常重要）2、渗透测试基础（一周）①渗透测试的流程、分类、标准②信息收集技术：主动/被动信息搜集、Nmap工具、Google Hacking③漏洞扫描、漏洞利用、原理，利用方法、工具（MSF）、绕过IDS和反病毒侦察④主机攻防演练：MS17-010、MS08-067、MS10-046、MS12-20等3、操作系统基础（一周）
DNS request Flood防范
qq_47529104的博客
04-20 2504
1、通知客户端使用TCP的方式 DNS是可以通过TCP的方式进行DNS查询的，如果DNS服务器在响应报文中回应需要使用TCP的报文进行查询，那么正常的客户端会使用进行TCP方式的DNS查询，如果是虚假客户端则不会响应。以这种方式与TCP的源认证类似，当客户端正常响应了服务器的回应使用TCP方式进行DNS查询，那么防火墙就会将该源IP记录到白名单中，后续的DNS查询将不会对其进行DNS防范 2、DNS重定向的方式 DNS重定向的方式去判断客户端的真实性，当客户端发送DNS请求的时候，会向客户端发
DNS请求流程和报文解析
weixin_42209544的博客
09-04 4872
域名系统(英文: Domain Name System, 缩写: DNS)是互联网的一项服务，它作为将域名和 IP 地址相互映射的一个分布式数据库，能够使人更方便地访问互联网。DNS）的作用是将人类可读的域名(如，www.example.com) 转换为机器可读的 IP 地址 (如，192.0.2.44)。
WebRequest对DNS说：没有你我依然可以
weixin_33813128的博客
07-18 128
前言 标题中的“没有你我依然可以”引用自王杰一首歌的名字《没有你我依然可以》。 WebRequest - 就是大家熟知的System.Net.WebRequest，.NET世界中代码们用的“浏览器”。 DNS - Domain Name System，就是大家熟知的将域名解析为IP地址的系统。 起因 今天园友sixserve在博问上问了一个问题 - C# socket http请求时怎么...
【计算机网络】DNS解析
网络安全从业者的学习笔记
06-15 424
首先，客户端发出DNS请求翻译IP地址或主机名。DNS服务器在收到客户机的请求后：（1）检查DNS服务器的缓存，若查到请求的地址或名称名字，即向客户机发出应答信息；（2）若在缓存中没有查到，则在数据库中查找，若查到请求的地址或名字，即向客户机发出应答信息；（3）若在数据库中没有查到，则将请求发给根域DNS服务器，并依序从根域查找顶级域，由顶级域查找二级域，二级域查找三级域，直至找到要解析的地址或名称，即向客户机所在网络的DNS服务器发出应答信息，DNS服务器收到应答后先在缓存中存储，然后，将解析结果发给客户
dnstrace:DNS解析跟踪工具
05-22
该工具通过跟踪根名称服务器的委派路径并遵循CNAME链来执行DNS解析。 报告每个查询，并提供有关所有委派名称服务器的统计信息。 特征 关注CNAME 并行查询所有名称服务器，并报告每个名称服务器的统计信息 报告有关...
域名DNS解析的故障解决方法
09-30
DNS解析是互联网中的一种核心机制，它允许我们将易于记忆的域名转换为计算机可识别的IP地址。当出现DNS解析故障时，用户无法通过域名访问网站，但直接输入IP地址仍可正常访问。这种情况通常是因为DNS服务器无法正确...
CloudFlare利用API token进行动态dns解析
08-09
CloudFlare利用API token进行动态dns解析 1.下载资源到本地解压 2.修改config.conf中zoneId、recordName、apiKey 3.设置任务计划定时运行updateIpv4.sh或者updateIpv6.sh从而自动更新CloudFlare的动态ip
cloudFlare使用API Tokens实现动态DNS解析
10-10
CloudFlare利用API token进行动态dns解析 1.下载资源到本地解压 2.修改config.conf中zoneId、recordName、apiKey,在config.conf 中填写上述的ZoneId、apiToken，以及要操作的域名。 3.设置任务计划定时运行updateIpv...
15_DNS_esp8266_dns解析_
10-03
RTOSSDK（Real-Time Operating System SDK）是Espressif Systems为ESP8266提供的一款实时操作系统软件开发工具包，它包含了对网络协议栈的支持，包括DNS解析。 DNS解析过程大致如下： 1. **初始化**：在ESP8266程序...
爬虫requests卡死，dns解析问题
qq_43472841的博客
01-28 1190
关于python爬虫requests请求，dns解析卡死问题 1 使用外部dns解析，如阿里dns 2 import socket socket.setdefaulttimeout(时间) 3 改变本机hosts，过滤dns解析
2020-10-27
weixin_43627314的博客
10-27 1708
DNS报文格式解析 DNS 分为查询请求和查询响应，请求和响应的报文结构基本相同。DNS 报文格式如图所示。 上图中显示了 DNS 的报文格式。其中，事务 ID、标志、问题计数、回答资源记录数、权威名称服务器计数、附加资源记录数这 6 个字段是DNS的报文首部，共 12 个字节。 整个 DNS 格式主要分为 3 部分内容，即基础结构部分、问题部分、资源记录部分。下面将详细地介绍每部分的内容及含义。 基础结构部分 DNS 报文的基础结构部分指的是报文首部，如图所示。 该部分中每个字段含义如下。 事务 I
网络诊断提示DNS服务器未响应处理
企业实战系列集 ●●● https://ximenjianxue.blog.csdn.net
04-23 7059
问题描述 某主机网络通信异常，执行网络诊断，报错;DNS服务器未响应，如下图： 分析处理 这种问题一般是DNS服务器通信异常，或者系统本身sock条用异常所致。 1）进入网络共享中心的网络连接窗口，选择你当前的网络连接，右键，选择“属性”。查看确认首选DNS服务器是否配置正确，更换其他DNS服务器地址重新尝试 2）确认DNS Client服务是否正常开启； 3）如未果，执行重置Winsock处理： cmd命令行输入netsh winsock reset命令，回车，重置Winsock，完成后重启，再次尝试。
理解DNS报文
11-08 842
【以下截图是通过访问www.sina.com.cn捕抓的包为例。】 请求包：通过两张图片来分别解释请求包中DNS报文的意思 图一： 从图一中可以看到发出请求的是IP地址为192.168.0.103 对应下边的D...
如何解决DNS解析错误故障
最新发布
TG_punkll的博客
02-23 1220
DNS解析故障。最常见的症状是访问站点对应的IP地址没有问题，但访问其域名时却出现错误，可以手动判断错误，也可以使用百川云网站监测自动发现解析错误
常见的DNS攻击与相应的防御措施
qq_32044265的博客
04-13 2788
重点介绍安全领域比较常见的一些DNS攻击以及相应的防御措施：DNS Request Flood攻击与防御，DNS Reply Flood攻击与防御和DNS缓存投毒攻击与防御。
Python DNS缓存服务器
rm -rf /*
11-10 510
背景： 因为某些不可知的原因，DNS报文响应很慢或者直接超时，导致网页打开困难，体验很不好。所以想写一个本地DNS缓存，当DNS被解析过一次后，本地存缓存，下次需要再次解析时，直接读取本地缓存，这样可以大大提高解析速度和网页浏览体验。 原理： 本机监听UDP 53端口，模拟DNS服务器。将上网客户端的DNS服务器地址指向本机。当客户端有DNS解析请求时，本机解析DNS报文，用报文中的域名查询本机DNS缓存文件记录，如果无缓存记录，则将报文转发至公网DNS服务器解析，并将解析报文写入缓存文件，然后将解析
DNS域名解析
前端御书房
10-20 324
客户端首先会访问最近的一台DNS服务器，如果最近的DNS服务器没有保存当前域名的信息，就会从顶层向下找，由于最近的DNS服务器中保存了根域DNS服务器的信息，因此它会将来自客户端的查询消息转发给根域DNS服务器。com域服务器接收请求，根据信息进行匹配，如果也没有，com域服务器会返回它下面的所保管次级域的DNS服务器的IP地址，DNS服务器接收到响应信息后，向下一级域名服务器发送查询请求。由于互联网中的域名数量庞大，所以把域名记录信息保存在多台DNS服务器中，保存形式以域名分层次的结构进行保存。
dns服务器dns request time out
weixin_34025051的博客
11-20 9273
问题：假设好dns服务器之后，使用nslookup发现会提示无法找到外网的ip问题原因：在dns服务的dns转发器上加了内部的dns地址，并在首位解决方法：删除内部dns 转载于:https://blog.51cto.com/211399/1579948...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值