Привет, Хабр!

В этой статье я хочу рассказать о своем опыте создания DNS сервера. Разрабатывал я его "чисто повеселиться", при разработке будем придерживаться спецификации RFC.

DNS сервер

Сейчас по-быстрому разберемся, в чем принцип работы DNS серверов. Чтобы сейчас читать эту статью, вы зашли на Хабр, для этого в браузере вы ввели www.habr.com, браузер же переводит этот домен в ip адрес, по типу 178.248.237.68:443, чтобы сделать запрос. Домены существуют, чтобы люди не запоминали эти сложные комбинации чисел, а запоминали только привычные нам слова. DNS сервера же переводят эти домены в нормальный для компьютера вид.
Простая аналогия, телефонная книжка. Вместо того, чтобы запоминать мобильные номера каждого человека, мы создаем контакт и ориентируемся по заданым именам в телефонной книжке.

DNS протокол

DNS протокол является прикладным протоколом, который работает поверх UDP. В данном протоколе сущетствуют только один формат, который называется "Сообщение".

То есть DNS-запрос и DNS-ответ имеют одинаковый формат. Размер сообщения - 512 байт, согласно спецификации. Структуру сообщения разберем позже и по порядку.

Начало разработки

Для начала поднимем сервер, принимающий UDP запросы и отдающий пустые ответы, чтобы удостовериться будем просто логировать их.

Код сервера

package main  
  
import (  
    "fmt"  
    "log"    
    "net"
)  
  
const Address = "127.0.0.1:2053"  
  
func main() {  
    udpAddr, err := net.ResolveUDPAddr("udp", Address)  
    if err != nil {  
       log.Fatal("failed to resolve udp address", err)  
    }  
  
    udpConn, err := net.ListenUDP("udp", udpAddr)  
    if err != nil {  
       log.Fatal("failed to to bind to address", err)  
    }  
    defer udpConn.Close()  
  
    log.Printf("started server on %s", Address)  

	// размер бафенра 512 байт согласно спецификации
    buf := make([]byte, 512)  
    for {  
       size, source, err := udpConn.ReadFromUDP(buf)  
       if err != nil {  
          log.Println("failed to receive data", err)  
          break  
       }  
  
       data := string(buf[:size])  
  
       log.Printf("received %d bytes from %s: %s", size, source.String(), data)  
  
       response := []byte{} // пустой ответ  
       _, err = udpConn.WriteToUDP(response, source)  
       if err != nil {  
          fmt.Println("Failed to send response:", err)  
       }  
    }  
}

Результат кода

С помощью утилиты nc подключились к UDP серверу и отправили запрос. Про утилиту подробнее можно узнать здесь

• https://netcat.sourceforge.net/

• https://habr.com/ru/articles/657613/

• https://habr.com/ru/articles/678968/

• https://habr.com/ru/articles/336596/

Заголовок сообщения

Как я указывал выше, в сообщении есть 5 секций, сейчас разберем Header (Заголовок)

Размер заголовка в любом сообщении ВСЕГДА 12 байт, а числа закодированы в формате Big-Endian. Эта информация нам понадобится когда придется парсить и составлять заголовок. Также можно увидеть множество полей в заголовке, но обратим внимание на важные, по-моему мнению:

• ID, 16 битное значение, ID ответа всегда равен ID запроса

• QR, значение 1 для ответа и 0 для запроса

• RCODE, статус ответа, 0 (no error)

• QDCOUNT, количество запросов/вопросов в секции Questions в сообщении

• ANCOUNT, количество ответов в секции Answers в ответе

В Go можем заимплементировать заголовок таким образом:

type Header struct {  
    PacketID uint16  
    QR       uint16  
    OPCODE   uint16  
    AA       uint16  
    TC       uint16  
    RD       uint16  
    RA       uint16  
    Z        uint16  
    RCode    uint16  
    QDCount  uint16  
    ANCount  uint16  
    NSCount  uint16  
    ARCount  uint16  
}

Теперь, когда к нам приходит запрос, нужно распарсить заголовок и перенести данные из заголовка запроса в заголовок ответа. Для этого можем написать функцию для чтения первых 12 байт запроса:

func ReadHeader(buf []byte) Header {  
    h := Header{  
       ID:      uint16(buf[0])<<8 | uint16(buf[1]),  
       QR:      1,  // установили 1, потому что это ответ
       OPCODE:  uint16((buf[2] << 1) >> 4),  
       AA:      uint16((buf[2] << 5) >> 7),  
       TC:      uint16((buf[2] << 6) >> 7),  
       RD:      uint16((buf[2] << 7) >> 7),  
       RA:      uint16(buf[3] >> 7),  
       Z:       uint16((buf[3] << 1) >> 5),  
       QDCOUNT: uint16(buf[4])<<8 | uint16(buf[5]),  
       ANCOUNT: uint16(buf[5])<<8 | uint16(buf[7]),  
       NSCOUNT: uint16(buf[8])<<8 | uint16(buf[9]),  
       ARCOUNT: uint16(buf[10])<<8 | uint16(buf[11]),  
    }

    // если в запросе OPCODE не равен нулю, то отправим ответ с кодом ошибки 4
    if h.OPCODE == 0 {  
       h.RCODE = 0  
    } else {  
       h.RCODE = 4  
    }  
  
    return h  
}

Как видно по коду, приходиться использовать побайтовые сдвиги. Все данные для полей фетчим из заголовка запроса.

Но нам также надо и закодировать сообщение в байты. Ответное сообщение кодируется сверху вниз, то есть сначала кодируем заголовок потом другие секции. Вот функция для кодировки заголовка:

func (h Header) Encode() []byte {
	dnsHeader := make([]byte, 12)

	var flags uint16 = 0
	flags = h.QR<<15 | h.OPCODE<<11 | h.AA<<10 | h.TC<<9 | h.RD<<8 | h.RA<<7 | h.Z<<4 | h.RCode

	binary.BigEndian.PutUint16(dnsHeader[0:2], h.PacketID)
	binary.BigEndian.PutUint16(dnsHeader[2:4], flags)
	binary.BigEndian.PutUint16(dnsHeader[4:6], h.QDCount)
	binary.BigEndian.PutUint16(dnsHeader[6:8], h.ANCount)
	binary.BigEndian.PutUint16(dnsHeader[8:10], h.NSCount)
	binary.BigEndian.PutUint16(dnsHeader[10:12], h.ARCount)

	return dnsHeader
}

Битовые сдвиги наше все!
Для того, чтобы не запутаться, можно вернуться к этой картинке, где указаны размеры в байтах каждого поля в загаловке

header := ReadHeader(buf[:12])
log.Printf("ID: %d; QR: %d; QDCount: %d\n", header.PacketID, header.QR, header.QDCount)

response := header.Encode()
_, err = udpConn.WriteToUDP(response, source)

После того, как мы распарсили заголовок запроса и закодировали его для ответа, надо как-то протестить то, что мы реализовали. Для этого есть маленький DNS клиент на Python

import socket


def build_dns_query():
    header = bytearray([
        0x00, 0x01,  # Transaction ID
        0x00, 0x00,  # Flags: Standard query
        0x00, 0x01,  # Questions
        0x00, 0x00,  # Answer RRs
        0x00, 0x00,  # Authority RRs
        0x00, 0x00   # Additional RRs
    ])

    return header


def send_dns_query(query, server, port=2053):
    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
        s.sendto(query, (server, port))
        response, _ = s.recvfrom(1024)
    return response


if __name__ == "__main__":
    dns_server = "127.0.0.1"
    dns_query = build_dns_query()
    dns_response = send_dns_query(dns_query, dns_server)

После запуска скрипта и сервера в логах можно увидеть следующее.
Дебагер, ну чтобы точно удостовериться)

Балдеж

Questions

Запросы (вопросы), как вам удобно, второе поле в каждом DNS запросе, чаще всего количество запросов равно 1, но бывает и несколько запросов/вопросов. Структура запроса имеет куда меньше полей.

Сейчас размеберем каждую в подробности

• QName, доменное имя, представленное в виде лейблов, например для habr.com будет два лейбла: habr и com.

• QType, 16 битное число, которое показывает, что мы хотим получить. Для нашего сервера дефолтом будет значение А, потому что А - адрес хоста, полный список типов тут

• QClass, 16 битное число, которое показывает класс запроса, например, для нашего сервера дефолтом будет значение IN, потому что IN - the Internet полный список классов тут

Но в запросе доменное имя отправляется не сплошным текстом, а кодируется в виде последовательности лейблов <length><label>, где

• <length> - это один байт, указывающий длину последующего лейбла

• <label> - сам лейбл

• \x00 - байт, который указывает на конец последовательности лейблов

Пример, habr.com будет выглядить так

\x04habr\x03com\x00

Теперь можно приступить к имплементации

Для начала создадим тип для QClass и QType. Конечно можно было задать просто две единицы, но мне такой вариант ближе

type Class uint16

const (
	_ Class = iota
	IN
	CS
	CH
	HS
)

type Type uint16

const (
	_ Type = iota
	A
	NS
	MD
	MF
	CNAME
	SOA
	MB
	MG
	MR
	NULL
	WKS
	PTR
	HINFO
	MINFO
	MX
	TXT
)

type Question struct {
	QName  string
	QType  Type
	QClass Class
}

Как и с заголовком нам нужно распарсить запрос и закодировать его для ответа

func ReadQuestion(buf []byte) Question {
	start := 0
	var nameParts []string

	for len := buf[start]; len != 0; len = buf[start] {
		start++
		nameParts = append(nameParts, string(buf[start:start+int(len)]))
		start += int(len)
	}
	questionName := strings.Join(nameParts, ".")
	start++

	questionType := binary.BigEndian.Uint16(buf[start : start+2])
	questionClass := binary.BigEndian.Uint16(buf[start+2 : start+4])

	q := Question{
		QName:  questionName,
		QType:  Type(questionType),
		QClass: Class(questionClass),
	}

	return q
}

func (q Question) Encode() []byte {
	domain := q.QName
	parts := strings.Split(domain, ".")

	var buf bytes.Buffer

	for _, label := range parts {
		if len(label) > 0 {
			buf.WriteByte(byte(len(label)))
			buf.WriteString(label)
		}
	}
	buf.WriteByte(0x00)
	buf.Write(intToBytes(uint16(q.QType)))
	buf.Write(intToBytes(uint16(q.QClass)))

	return buf.Bytes()
}

А также видоизменим отправку ответа в main функции

header := ReadHeader(buf[:12])
log.Printf("ID: %d; QR: %d; QDCount: %d\n", header.PacketID, header.QR, header.QDCount)

question := ReadQuestion(buf[12:])

var res bytes.Buffer
res.Write(header.Encode())
res.Write(question.Encode())

_, err = udpConn.WriteToUDP(res.Bytes(), source)

И чуток видоизменим python клиент

import socket


def build_dns_query(domain: str):
    header = bytearray([
        0x00, 0x01,  # Transaction ID
        0x00, 0x00,  # Flags: Standard query
        0x00, 0x01,  # Questions
        0x00, 0x00,  # Answer RRs
        0x00, 0x00,  # Authority RRs
        0x00, 0x00   # Additional RRs
    ])

    question = bytearray()
    labels = domain.split('.')
    for label in labels:
        question.append(len(label))
        question.extend(label.encode('utf-8'))
    question.extend([0x00, 0x00, 0x01, 0x00, 0x01])  # QTYPE and QCLASS (A record, Internet)

    return header + question


def send_dns_query(query, server, port=2053):
    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
        s.sendto(query, (server, port))
        response, _ = s.recvfrom(1024)
    return response


def parse_dns_response(response):
    print(response)
    print(response.hex())


if __name__ == "__main__":
    dns_server = "127.0.0.1"
    domain = "habr.com"
    dns_query = build_dns_query(domain)
    dns_response = send_dns_query(dns_query, dns_server)
    parse_dns_response(dns_response)

После запуска скрипта и сервера можно снова удостовериться в работе

Answers

Ответ - последнее поле, которое разберем, и очень важное, потому что именно тут будет возвращаться IP адрес хоста.

В ответе мы встречаем знакомые поля, но из новых тут

• TTL - time-to-live, период времени в секундах, на которое может закеширироваться на сервере, размер 32 бита

• RDLENGHT - длина RDATA, так как IP адрес это 4 байта, то будет равно 4, размер 32 бит

• RDATA - значение, которое является ответом на запрос, в нашем случа IP адрес, к примеру 8.8.8.8

Пример имплементации ответа и, само собой, метод для кодировки

type Answer struct {
	Name string
	Type Type
	Class Class
	TTL uint32
	Length uint32
	Data [4]uint8
}

func (a Answer) Encode() []byte {
	var rrBytes []byte

	domain := a.Name
	parts := strings.Split(domain, ".")

	for _, label := range parts {
		if len(label) > 0 {
			rrBytes = append(rrBytes, byte(len(label)))
			rrBytes = append(rrBytes, []byte(label)...)
		}
	}
	rrBytes = append(rrBytes, 0x00)

	rrBytes = append(rrBytes, intToBytes(uint16(a.Type))...)
	rrBytes = append(rrBytes, intToBytes(uint16(a.Class))...)

	time := make([]byte, 4)
	binary.BigEndian.PutUint32(time, a.TTL)

	rrBytes = append(rrBytes, time...)
	rrBytes = append(rrBytes, intToBytes(a.Length)...)

	ipBytes, err := net.IPv4(a.Data[0], a.Data[1], a.Data[2], a.Data[3]).MarshalText()
	if err != nil {
		return nil
	}

	rrBytes = append(rrBytes, ipBytes...)

	return rrBytes
}

Так как мы не можем запарсить ответ, то мы просто прокинем создание структуры, а также создадим мапу, где будем хранить соотношение домена к его IP

answer := Answer{
    Name:   question.QName,
    Type:   A,
    Class:  IN,
    TTL:    0,
    Length: net.IPv4len,
    Data:   nameToIP[question.QName],
}

var res bytes.Buffer
res.Write(header.Encode())
res.Write(question.Encode())
res.Write(answer.Encode())

_, err = udpConn.WriteToUDP(res.Bytes(), source)

После запуска Python скрипта можно увидеть наш полученный IP адрес

Резюме

Ну подводя итоги, разработали минимальный по умениям рабочий DNS сервер.
Надеюсь вам понравилась эта статья!

P.S. Возможно много опечаток, не судите строго