224 lines
6.0 KiB
C
224 lines
6.0 KiB
C
/* Convert a DNS packet to a human-readable representation.
|
|
Copyright (C) 2016-2017 Free Software Foundation, Inc.
|
|
This file is part of the GNU C Library.
|
|
|
|
The GNU C Library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2.1 of the License, or (at your option) any later version.
|
|
|
|
The GNU C Library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
License along with the GNU C Library; if not, see
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
#include <support/format_nss.h>
|
|
|
|
#include <arpa/inet.h>
|
|
#include <resolv.h>
|
|
#include <stdbool.h>
|
|
#include <support/check.h>
|
|
#include <support/support.h>
|
|
#include <support/xmemstream.h>
|
|
|
|
struct in_buffer
|
|
{
|
|
const unsigned char *data;
|
|
size_t size;
|
|
};
|
|
|
|
static inline bool
|
|
extract_8 (struct in_buffer *in, unsigned char *value)
|
|
{
|
|
if (in->size == 0)
|
|
return false;
|
|
*value = in->data[0];
|
|
++in->data;
|
|
--in->size;
|
|
return true;
|
|
}
|
|
|
|
static inline bool
|
|
extract_16 (struct in_buffer *in, unsigned short *value)
|
|
{
|
|
if (in->size < 2)
|
|
return false;
|
|
*value = (in->data[0] << 8) | in->data[1];
|
|
in->data += 2;
|
|
in->size -= 2;
|
|
return true;
|
|
}
|
|
|
|
static inline bool
|
|
extract_32 (struct in_buffer *in, unsigned *value)
|
|
{
|
|
if (in->size < 4)
|
|
return false;
|
|
unsigned a = in->data[0];
|
|
unsigned b = in->data[1];
|
|
unsigned c = in->data[2];
|
|
unsigned d = in->data[3];
|
|
*value = (a << 24) | (b << 16) | (c << 8) | d;
|
|
in->data += 4;
|
|
in->size -= 4;
|
|
return true;
|
|
}
|
|
|
|
static inline bool
|
|
extract_bytes (struct in_buffer *in, size_t length, struct in_buffer *value)
|
|
{
|
|
if (in->size < length)
|
|
return false;
|
|
*value = (struct in_buffer) {in->data, length};
|
|
in->data += length;
|
|
in->size -= length;
|
|
return true;
|
|
}
|
|
|
|
struct dname
|
|
{
|
|
char name[MAXDNAME + 1];
|
|
};
|
|
|
|
static bool
|
|
extract_name (struct in_buffer full, struct in_buffer *in, struct dname *value)
|
|
{
|
|
const unsigned char *full_end = full.data + full.size;
|
|
/* Sanity checks; these indicate buffer misuse. */
|
|
TEST_VERIFY_EXIT
|
|
(!(in->data < full.data || in->data > full_end
|
|
|| in->size > (size_t) (full_end - in->data)));
|
|
int ret = dn_expand (full.data, full_end, in->data,
|
|
value->name, sizeof (value->name));
|
|
if (ret < 0)
|
|
return false;
|
|
in->data += ret;
|
|
in->size -= ret;
|
|
return true;
|
|
}
|
|
|
|
char *
|
|
support_format_dns_packet (const unsigned char *buffer, size_t length)
|
|
{
|
|
struct in_buffer full = { buffer, length };
|
|
struct in_buffer in = full;
|
|
struct xmemstream mem;
|
|
xopen_memstream (&mem);
|
|
|
|
unsigned short txnid;
|
|
unsigned short flags;
|
|
unsigned short qdcount;
|
|
unsigned short ancount;
|
|
unsigned short nscount;
|
|
unsigned short adcount;
|
|
if (!(extract_16 (&in, &txnid)
|
|
&& extract_16 (&in, &flags)
|
|
&& extract_16 (&in, &qdcount)
|
|
&& extract_16 (&in, &ancount)
|
|
&& extract_16 (&in, &nscount)
|
|
&& extract_16 (&in, &adcount)))
|
|
{
|
|
fprintf (mem.out, "error: could not parse DNS header\n");
|
|
goto out;
|
|
}
|
|
if (qdcount != 1)
|
|
{
|
|
fprintf (mem.out, "error: question count is %d, not 1\n", qdcount);
|
|
goto out;
|
|
}
|
|
struct dname qname;
|
|
if (!extract_name (full, &in, &qname))
|
|
{
|
|
fprintf (mem.out, "error: malformed QNAME\n");
|
|
goto out;
|
|
}
|
|
unsigned short qtype;
|
|
unsigned short qclass;
|
|
if (!(extract_16 (&in, &qtype)
|
|
&& extract_16 (&in, &qclass)))
|
|
{
|
|
fprintf (mem.out, "error: malformed question\n");
|
|
goto out;
|
|
}
|
|
if (qtype != T_A && qtype != T_AAAA && qtype != T_PTR)
|
|
{
|
|
fprintf (mem.out, "error: unsupported QTYPE %d\n", qtype);
|
|
goto out;
|
|
}
|
|
|
|
fprintf (mem.out, "name: %s\n", qname.name);
|
|
|
|
for (int i = 0; i < ancount; ++i)
|
|
{
|
|
struct dname rname;
|
|
if (!extract_name (full, &in, &rname))
|
|
{
|
|
fprintf (mem.out, "error: malformed record name\n");
|
|
goto out;
|
|
}
|
|
unsigned short rtype;
|
|
unsigned short rclass;
|
|
unsigned ttl;
|
|
unsigned short rdlen;
|
|
struct in_buffer rdata;
|
|
if (!(extract_16 (&in, &rtype)
|
|
&& extract_16 (&in, &rclass)
|
|
&& extract_32 (&in, &ttl)
|
|
&& extract_16 (&in, &rdlen)
|
|
&& extract_bytes (&in, rdlen, &rdata)))
|
|
{
|
|
fprintf (mem.out, "error: malformed record header\n");
|
|
goto out;
|
|
}
|
|
/* Skip non-matching record types. */
|
|
if ((rtype != qtype && rtype != T_CNAME) || rclass != qclass)
|
|
continue;
|
|
switch (rtype)
|
|
{
|
|
case T_A:
|
|
if (rdlen == 4)
|
|
fprintf (mem.out, "address: %d.%d.%d.%d\n",
|
|
rdata.data[0],
|
|
rdata.data[1],
|
|
rdata.data[2],
|
|
rdata.data[3]);
|
|
else
|
|
fprintf (mem.out, "error: A record of size %d: %s\n",
|
|
rdlen, rname.name);
|
|
break;
|
|
case T_AAAA:
|
|
{
|
|
if (rdlen == 16)
|
|
{
|
|
char buf[100];
|
|
if (inet_ntop (AF_INET6, rdata.data, buf, sizeof (buf)) == NULL)
|
|
fprintf (mem.out, "error: AAAA record decoding failed: %m\n");
|
|
else
|
|
fprintf (mem.out, "address: %s\n", buf);
|
|
}
|
|
else
|
|
fprintf (mem.out, "error: AAAA record of size %d: %s\n",
|
|
rdlen, rname.name);
|
|
}
|
|
break;
|
|
case T_CNAME:
|
|
case T_PTR:
|
|
{
|
|
struct dname name;
|
|
if (extract_name (full, &rdata, &name))
|
|
fprintf (mem.out, "name: %s\n", name.name);
|
|
else
|
|
fprintf (mem.out, "error: malformed CNAME/PTR record\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
out:
|
|
xfclose_memstream (&mem);
|
|
return mem.buffer;
|
|
}
|