afonsofrancof/sdns-proxy
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Made clients for each protocol to reuse connections

Browse Source
This commit is contained in:
Afonso Franco
2025-03-01 05:47:46 +00:00
parent dfdf518ea2
commit f5fa15b701
7 changed files with 233 additions and 222 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
internal/protocols/do53/do53.go
View File

@@ -4,60 +4,62 @@ import (
"fmt"
"net"
"golang.org/x/net/dns/dnsmessage"
"github.com/miekg/dns"
)
func Run(domain, queryType, dest string, dnssec bool) error {
type Do53Client struct {
udpConn *net.UDPConn
}
message, err := MakeDNSMessage(domain, queryType)
if err != nil {
return err
}
func New(dest string) (*Do53Client, error) {
udpAddr, err := net.ResolveUDPAddr("udp", dest)
if err != nil {
return fmt.Errorf("failed to resolve UDP address: %v", err)
return nil, fmt.Errorf("failed to resolve UDP address: %v", err)
}
udpConn, err := net.DialUDP("udp", nil, udpAddr)
if err != nil {
return fmt.Errorf("failed to dial UDP connection: %v", err)
return nil, fmt.Errorf("failed to dial UDP connection: %v", err)
}
defer udpConn.Close()
return &Do53Client{udpConn: udpConn}, nil
}
_, err = udpConn.Write(message)
func (c *Do53Client) Close() {
if c.udpConn != nil {
c.udpConn.Close()
}
}
func (c *Do53Client) Query(domain, queryType, dest string, dnssec bool) error {
message, err := NewDNSMessage(domain, queryType)
if err != nil {
return err
}
_, err = c.udpConn.Write(message)
if err != nil {
return fmt.Errorf("failed to send DNS query: %v", err)
}
buf := make([]byte, 4096)
n, err := udpConn.Read(buf)
n, err := c.udpConn.Read(buf)
if err != nil {
return fmt.Errorf("failed to read DNS response: %v", err)
}
var parser dnsmessage.Parser
_, err = parser.Start(buf[:n])
recvMsg := new(dns.Msg)
err = recvMsg.Unpack(buf[:n])
if err != nil {
return fmt.Errorf("failed to parse DNS response: %v", err)
}
// TODO: Check if the response had no errors or TD bit set
err = parser.SkipAllQuestions()
if err != nil {
return fmt.Errorf("failed to skip questions: %v", err)
}
answers, err := parser.AllAnswers()
if err != nil {
return err
}
for _, answer := range answers {
fmt.Println(answer.GoString())
for _, answer := range recvMsg.Answer {
fmt.Println(answer.String())
}
return nil
}

58
internal/protocols/do53/packet.go
View File

@@ -1,60 +1,40 @@
package do53
import (
"fmt"
"golang.org/x/net/dns/dnsmessage"
"github.com/miekg/dns"
)
func MakeDNSMessage(domain string, queryType string) ([]byte, error) {
messageHeader := dnsmessage.Header{
ID: 1234, // FIX: Use a random ID
Response: false,
OpCode: dnsmessage.OpCode(0),
RecursionDesired: true,
}
func NewDNSMessage(domain string, queryType string) ([]byte, error) {
messageBuilder := dnsmessage.NewBuilder(nil, messageHeader)
queryName, err := dnsmessage.NewName(domain)
if err != nil {
return nil, fmt.Errorf("failed to create query name: %v", err)
}
// Determine query type
var queryTypeValue dnsmessage.Type
// TODO: Move this somewhere else and receive the type already parsed
var queryTypeValue uint16
switch queryType {
case "A":
queryTypeValue = dnsmessage.TypeA
queryTypeValue = dns.TypeA
case "AAAA":
queryTypeValue = dnsmessage.TypeAAAA
queryTypeValue = dns.TypeAAAA
case "MX":
queryTypeValue = dnsmessage.TypeMX
queryTypeValue = dns.TypeMX
case "CNAME":
queryTypeValue = dnsmessage.TypeCNAME
queryTypeValue = dns.TypeCNAME
case "TXT":
queryTypeValue = dnsmessage.TypeTXT
queryTypeValue = dns.TypeTXT
default:
queryTypeValue = dnsmessage.TypeA
queryTypeValue = dns.TypeA
}
messageQuestion := dnsmessage.Question{
Name: queryName,
Type: queryTypeValue,
Class: dnsmessage.ClassINET,
}
message := new(dns.Msg)
err = messageBuilder.StartQuestions()
message.Id = dns.Id()
message.Response = false
message.Opcode = dns.OpcodeQuery
message.Question = make([]dns.Question, 1)
message.Question[0] = dns.Question{Name: domain, Qtype: uint16(queryTypeValue), Qclass: dns.ClassINET}
message.Compress = true
wireMsg, err := message.Pack()
if err != nil {
return nil, err
}
err = messageBuilder.Question(messageQuestion)
if err != nil {
return nil, fmt.Errorf("failed to add question: %v", err)
}
message, err := messageBuilder.Finish()
if err != nil {
return nil, fmt.Errorf("failed to build message: %v", err)
}
return message, nil
return wireMsg, nil
}

125
internal/protocols/doh/doh.go
View File

@@ -11,37 +11,41 @@ import (
"os"
"github.com/afonsofrancof/sdns-perf/internal/protocols/do53"
"golang.org/x/net/dns/dnsmessage"
"github.com/miekg/dns"
)
func Run(domain, queryType, server, path, proxy string, dnssec bool) error {
type DoHClient struct {
tcpConn *net.TCPConn
tlsConn *tls.Conn
keyLogFile *os.File
target string
path string
proxy string
}
DNSMessage, err := do53.MakeDNSMessage(domain, queryType)
func New(target, path, proxy string) (*DoHClient, error) {
tcpAddr, err := net.ResolveTCPAddr("tcp", target)
if err != nil {
return err
return nil, fmt.Errorf("failed to resolve TCP address: %v", err)
}
// Step 1 - Establish a TCP Connection
tcpConn, err := net.Dial("tcp", server)
tcpConn, err := net.DialTCP("tcp", nil, tcpAddr)
if err != nil {
return fmt.Errorf("failed to establish TCP connection: %v", err)
return nil, fmt.Errorf("failed to establish TCP connection: %v", err)
}
defer tcpConn.Close()
// Step 2 - Upgrade it to a TLS Connection
// Temporary keylog file to allow traffic inspection
keyLogFile, err := os.OpenFile(
"tls-key-log.txt",
os.O_APPEND|os.O_CREATE|os.O_WRONLY,
0600,
)
if err != nil {
return fmt.Errorf("failed opening key log file: %v", err)
return nil, fmt.Errorf("failed opening key log file: %v", err)
}
defer keyLogFile.Close()
tlsConfig := &tls.Config{
// FIX: Actually check the domain name
InsecureSkipVerify: true,
MinVersion: tls.VersionTLS12,
KeyLogWriter: keyLogFile,
@@ -50,24 +54,45 @@ func Run(domain, queryType, server, path, proxy string, dnssec bool) error {
tlsConn := tls.Client(tcpConn, tlsConfig)
err = tlsConn.Handshake()
if err != nil {
return fmt.Errorf("failed to execute the TLS handshake: %v", err)
return nil, fmt.Errorf("failed to execute the TLS handshake: %v", err)
}
defer tlsConn.Close()
// Step 3 - Create an HTTP request with the do53 message in the body
httpReq, err := http.NewRequest("POST", "https://"+server+"/"+path, bytes.NewBuffer(DNSMessage))
return &DoHClient{tcpConn: tcpConn, keyLogFile: keyLogFile, tlsConn: tlsConn, target: target, path: path, proxy: proxy}, err
}
func (c *DoHClient) Close() {
if c.tcpConn != nil {
c.tcpConn.Close()
}
if c.keyLogFile != nil {
c.keyLogFile.Close()
}
if c.tlsConn != nil {
c.tlsConn.Close()
}
}
func (c *DoHClient) Query(domain, queryType string, dnssec bool) error {
DNSMessage, err := do53.NewDNSMessage(domain, queryType)
if err != nil {
return err
}
httpReq, err := http.NewRequest("POST", "https://"+c.target+"/"+c.path, bytes.NewBuffer(DNSMessage))
if err != nil {
return fmt.Errorf("failed to create HTTP request: %v", err)
}
httpReq.Header.Add("Content-Type", "application/dns-message")
httpReq.Header.Set("Accept", "application/dns-message")
err = httpReq.Write(tlsConn)
err = httpReq.Write(c.tlsConn)
if err != nil {
return fmt.Errorf("failed writing HTTP request: %v", err)
}
reader := bufio.NewReader(tlsConn)
reader := bufio.NewReader(c.tlsConn)
resp, err := http.ReadResponse(reader, httpReq)
if err != nil {
return fmt.Errorf("failed reading HTTP response: %v", err)
@@ -80,68 +105,16 @@ func Run(domain, queryType, server, path, proxy string, dnssec bool) error {
return fmt.Errorf("failed reading response body: %v", err)
}
// Parse the response
var parser dnsmessage.Parser
header, err := parser.Start(responseBody[:n])
recvMsg := new(dns.Msg)
err = recvMsg.Unpack(responseBody[:n])
if err != nil {
return fmt.Errorf("failed to parse DNS response: %v", err)
}
fmt.Printf("DNS Response Header:\n")
fmt.Printf(" ID: %d\n", header.ID)
fmt.Printf(" Response: %v\n", header.Response)
fmt.Printf(" RCode: %v\n", header.RCode)
// TODO: Check if the response had no errors or TD bit set
// Skip all questions before reading answers
err = parser.SkipAllQuestions()
if err != nil {
return fmt.Errorf("failed to skip questions: %v", err)
}
// Parse answers
fmt.Printf("\nAnswers:\n")
answers, err := parser.AllAnswers()
for i, answer := range answers {
if err != nil {
return fmt.Errorf("failed to parse answer %d: %v", i, err)
}
fmt.Printf(" Answer %d:\n", i+1)
fmt.Printf(" Name: %v\n", answer.Header.Name)
fmt.Printf(" Type: %v\n", answer.Header.Type)
fmt.Printf(" TTL: %v seconds\n", answer.Header.TTL)
// Handle different record types
switch answer.Header.Type {
case dnsmessage.TypeA:
if r, ok := answer.Body.(*dnsmessage.AResource); ok {
fmt.Printf(" IPv4: %d.%d.%d.%d\n", r.A[0], r.A[1], r.A[2], r.A[3])
}
case dnsmessage.TypeAAAA:
if r, ok := answer.Body.(*dnsmessage.AAAAResource); ok {
ip := r.AAAA
fmt.Printf(" IPv6: %02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x\n",
ip[0], ip[1], ip[2], ip[3], ip[4], ip[5], ip[6], ip[7],
ip[8], ip[9], ip[10], ip[11], ip[12], ip[13], ip[14], ip[15])
}
case dnsmessage.TypeCNAME:
if r, ok := answer.Body.(*dnsmessage.CNAMEResource); ok {
fmt.Printf(" CNAME: %v\n", r.CNAME)
}
case dnsmessage.TypeMX:
if r, ok := answer.Body.(*dnsmessage.MXResource); ok {
fmt.Printf(" Preference: %v\n", r.Pref)
fmt.Printf(" MX: %v\n", r.MX)
}
case dnsmessage.TypeTXT:
if r, ok := answer.Body.(*dnsmessage.TXTResource); ok {
fmt.Printf(" TXT: %v\n", r.TXT)
}
default:
fmt.Printf(" [Unsupported record type]\n")
}
for _, answer := range recvMsg.Answer {
fmt.Println(answer.String())
}
return nil

119
internal/protocols/dot/dot.go
View File

@@ -9,35 +9,35 @@ import (
"os"
"github.com/afonsofrancof/sdns-perf/internal/protocols/do53"
"golang.org/x/net/dns/dnsmessage"
"github.com/miekg/dns"
)
func Run(domain, queryType, server string, dnssec bool) error {
type DoTClient struct {
tcpConn *net.TCPConn
tlsConn *tls.Conn
keyLogFile *os.File
}
DNSMessage, err := do53.MakeDNSMessage(domain, queryType)
func New(target string) (*DoTClient, error) {
tcpAddr, err := net.ResolveTCPAddr("tcp", target)
if err != nil {
return err
return nil, fmt.Errorf("failed to resolve TCP address: %v", err)
}
// Step 1 - Establish a TCP Connection
tcpConn, err := net.Dial("tcp", server)
tcpConn, err := net.DialTCP("tcp", nil, tcpAddr)
if err != nil {
return fmt.Errorf("failed to establish TCP connection: %v", err)
return nil, fmt.Errorf("failed to establish TCP connection: %v", err)
}
defer tcpConn.Close()
// Step 2 - Upgrade it to a TLS Connection
// Temporary keylog file to allow traffic inspection
keyLogFile, err := os.OpenFile(
"tls-key-log.txt",
os.O_APPEND|os.O_CREATE|os.O_WRONLY,
0600,
)
if err != nil {
return fmt.Errorf("failed opening key log file: %v", err)
return nil, fmt.Errorf("failed opening key log file: %v", err)
}
defer keyLogFile.Close()
tlsConfig := &tls.Config{
InsecureSkipVerify: true,
@@ -48,22 +48,43 @@ func Run(domain, queryType, server string, dnssec bool) error {
tlsConn := tls.Client(tcpConn, tlsConfig)
err = tlsConn.Handshake()
if err != nil {
return fmt.Errorf("failed to execute the TLS handshake: %v", err)
return nil, fmt.Errorf("failed to execute the TLS handshake: %v", err)
}
return &DoTClient{tcpConn: tcpConn, tlsConn: tlsConn, keyLogFile: keyLogFile}, nil
}
func (c *DoTClient) Close() {
if c.tcpConn != nil {
c.tcpConn.Close()
}
if c.tlsConn != nil {
c.tlsConn.Close()
}
if c.keyLogFile != nil {
c.keyLogFile.Close()
}
}
func (c *DoTClient) Query(domain, queryType, target string, dnssec bool) error {
DNSMessage, err := do53.NewDNSMessage(domain, queryType)
if err != nil {
return err
}
defer tlsConn.Close()
var lengthPrefixedMessage bytes.Buffer
binary.Write(&lengthPrefixedMessage, binary.BigEndian, uint16(len(DNSMessage)))
lengthPrefixedMessage.Write(DNSMessage)
_, err = tlsConn.Write(lengthPrefixedMessage.Bytes())
_, err = c.tlsConn.Write(lengthPrefixedMessage.Bytes())
if err != nil {
return fmt.Errorf("failed writing TLS request: %v", err)
}
// Read the 2-byte length prefix
lengthBuf := make([]byte, 2)
_, err = tlsConn.Read(lengthBuf)
_, err = c.tlsConn.Read(lengthBuf)
if err != nil {
return fmt.Errorf("failed reading response length: %v", err)
}
@@ -71,73 +92,21 @@ func Run(domain, queryType, server string, dnssec bool) error {
messageLength := binary.BigEndian.Uint16(lengthBuf)
responseBuf := make([]byte, messageLength)
n, err := tlsConn.Read(responseBuf)
n, err := c.tlsConn.Read(responseBuf)
if err != nil {
return fmt.Errorf("failed reading TLS response: %v", err)
}
// Parse the response
var parser dnsmessage.Parser
header, err := parser.Start(responseBuf[:n])
recvMsg := new(dns.Msg)
err = recvMsg.Unpack(responseBuf[:n])
if err != nil {
return fmt.Errorf("failed to parse DNS response: %v", err)
}
fmt.Printf("DNS Response Header:\n")
fmt.Printf(" ID: %d\n", header.ID)
fmt.Printf(" Response: %v\n", header.Response)
fmt.Printf(" RCode: %v\n", header.RCode)
// TODO: Check if the response had no errors or TD bit set
// Skip all questions before reading answers
err = parser.SkipAllQuestions()
if err != nil {
return fmt.Errorf("failed to skip questions: %v", err)
}
// Parse answers
fmt.Printf("\nAnswers:\n")
answers, err := parser.AllAnswers()
for i, answer := range answers {
if err != nil {
return fmt.Errorf("failed to parse answer %d: %v", i, err)
}
fmt.Printf(" Answer %d:\n", i+1)
fmt.Printf(" Name: %v\n", answer.Header.Name)
fmt.Printf(" Type: %v\n", answer.Header.Type)
fmt.Printf(" TTL: %v seconds\n", answer.Header.TTL)
// Handle different record types
switch answer.Header.Type {
case dnsmessage.TypeA:
if r, ok := answer.Body.(*dnsmessage.AResource); ok {
fmt.Printf(" IPv4: %d.%d.%d.%d\n", r.A[0], r.A[1], r.A[2], r.A[3])
}
case dnsmessage.TypeAAAA:
if r, ok := answer.Body.(*dnsmessage.AAAAResource); ok {
ip := r.AAAA
fmt.Printf(" IPv6: %02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x\n",
ip[0], ip[1], ip[2], ip[3], ip[4], ip[5], ip[6], ip[7],
ip[8], ip[9], ip[10], ip[11], ip[12], ip[13], ip[14], ip[15])
}
case dnsmessage.TypeCNAME:
if r, ok := answer.Body.(*dnsmessage.CNAMEResource); ok {
fmt.Printf(" CNAME: %v\n", r.CNAME)
}
case dnsmessage.TypeMX:
if r, ok := answer.Body.(*dnsmessage.MXResource); ok {
fmt.Printf(" Preference: %v\n", r.Pref)
fmt.Printf(" MX: %v\n", r.MX)
}
case dnsmessage.TypeTXT:
if r, ok := answer.Body.(*dnsmessage.TXTResource); ok {
fmt.Printf(" TXT: %v\n", r.TXT)
}
default:
fmt.Printf(" [Unsupported record type]\n")
}
for _, answer := range recvMsg.Answer {
fmt.Println(answer.String())
}
return nil