]>
Commit | Line | Data |
---|---|---|
5840c75c | 1 | /* Convert a DNS packet to a human-readable representation. |
581c785b | 2 | Copyright (C) 2016-2022 Free Software Foundation, Inc. |
5840c75c FW |
3 | This file is part of the GNU C Library. |
4 | ||
5 | The GNU C Library is free software; you can redistribute it and/or | |
6 | modify it under the terms of the GNU Lesser General Public | |
7 | License as published by the Free Software Foundation; either | |
8 | version 2.1 of the License, or (at your option) any later version. | |
9 | ||
10 | The GNU C Library is distributed in the hope that it will be useful, | |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
13 | Lesser General Public License for more details. | |
14 | ||
15 | You should have received a copy of the GNU Lesser General Public | |
16 | License along with the GNU C Library; if not, see | |
5a82c748 | 17 | <https://www.gnu.org/licenses/>. */ |
5840c75c FW |
18 | |
19 | #include <support/format_nss.h> | |
20 | ||
21 | #include <arpa/inet.h> | |
22 | #include <resolv.h> | |
f58bd7f0 | 23 | #include <stdbool.h> |
5840c75c FW |
24 | #include <support/check.h> |
25 | #include <support/support.h> | |
26 | #include <support/xmemstream.h> | |
27 | ||
28 | struct in_buffer | |
29 | { | |
30 | const unsigned char *data; | |
31 | size_t size; | |
32 | }; | |
33 | ||
5840c75c FW |
34 | static inline bool |
35 | extract_16 (struct in_buffer *in, unsigned short *value) | |
36 | { | |
37 | if (in->size < 2) | |
38 | return false; | |
39 | *value = (in->data[0] << 8) | in->data[1]; | |
40 | in->data += 2; | |
41 | in->size -= 2; | |
42 | return true; | |
43 | } | |
44 | ||
45 | static inline bool | |
46 | extract_32 (struct in_buffer *in, unsigned *value) | |
47 | { | |
48 | if (in->size < 4) | |
49 | return false; | |
50 | unsigned a = in->data[0]; | |
51 | unsigned b = in->data[1]; | |
52 | unsigned c = in->data[2]; | |
53 | unsigned d = in->data[3]; | |
54 | *value = (a << 24) | (b << 16) | (c << 8) | d; | |
55 | in->data += 4; | |
56 | in->size -= 4; | |
57 | return true; | |
58 | } | |
59 | ||
60 | static inline bool | |
61 | extract_bytes (struct in_buffer *in, size_t length, struct in_buffer *value) | |
62 | { | |
63 | if (in->size < length) | |
64 | return false; | |
65 | *value = (struct in_buffer) {in->data, length}; | |
66 | in->data += length; | |
67 | in->size -= length; | |
68 | return true; | |
69 | } | |
70 | ||
71 | struct dname | |
72 | { | |
73 | char name[MAXDNAME + 1]; | |
74 | }; | |
75 | ||
76 | static bool | |
77 | extract_name (struct in_buffer full, struct in_buffer *in, struct dname *value) | |
78 | { | |
79 | const unsigned char *full_end = full.data + full.size; | |
80 | /* Sanity checks; these indicate buffer misuse. */ | |
81 | TEST_VERIFY_EXIT | |
82 | (!(in->data < full.data || in->data > full_end | |
83 | || in->size > (size_t) (full_end - in->data))); | |
84 | int ret = dn_expand (full.data, full_end, in->data, | |
85 | value->name, sizeof (value->name)); | |
86 | if (ret < 0) | |
87 | return false; | |
88 | in->data += ret; | |
89 | in->size -= ret; | |
90 | return true; | |
91 | } | |
92 | ||
62a321b1 FW |
93 | static void |
94 | extract_name_data (struct in_buffer full, struct in_buffer *rdata, | |
95 | const struct dname *owner, const char *typename, FILE *out) | |
96 | { | |
97 | struct dname name; | |
98 | if (extract_name (full, rdata, &name)) | |
99 | fprintf (out, "data: %s %s %s\n", owner->name, typename, name.name); | |
100 | else | |
101 | fprintf (out, "error: malformed CNAME/PTR record\n"); | |
102 | } | |
103 | ||
5840c75c FW |
104 | char * |
105 | support_format_dns_packet (const unsigned char *buffer, size_t length) | |
106 | { | |
107 | struct in_buffer full = { buffer, length }; | |
108 | struct in_buffer in = full; | |
109 | struct xmemstream mem; | |
110 | xopen_memstream (&mem); | |
111 | ||
112 | unsigned short txnid; | |
113 | unsigned short flags; | |
114 | unsigned short qdcount; | |
115 | unsigned short ancount; | |
116 | unsigned short nscount; | |
117 | unsigned short adcount; | |
118 | if (!(extract_16 (&in, &txnid) | |
119 | && extract_16 (&in, &flags) | |
120 | && extract_16 (&in, &qdcount) | |
121 | && extract_16 (&in, &ancount) | |
122 | && extract_16 (&in, &nscount) | |
123 | && extract_16 (&in, &adcount))) | |
124 | { | |
125 | fprintf (mem.out, "error: could not parse DNS header\n"); | |
126 | goto out; | |
127 | } | |
128 | if (qdcount != 1) | |
129 | { | |
130 | fprintf (mem.out, "error: question count is %d, not 1\n", qdcount); | |
131 | goto out; | |
132 | } | |
133 | struct dname qname; | |
134 | if (!extract_name (full, &in, &qname)) | |
135 | { | |
136 | fprintf (mem.out, "error: malformed QNAME\n"); | |
137 | goto out; | |
138 | } | |
139 | unsigned short qtype; | |
140 | unsigned short qclass; | |
141 | if (!(extract_16 (&in, &qtype) | |
142 | && extract_16 (&in, &qclass))) | |
143 | { | |
144 | fprintf (mem.out, "error: malformed question\n"); | |
145 | goto out; | |
146 | } | |
147 | if (qtype != T_A && qtype != T_AAAA && qtype != T_PTR) | |
148 | { | |
149 | fprintf (mem.out, "error: unsupported QTYPE %d\n", qtype); | |
150 | goto out; | |
151 | } | |
152 | ||
153 | fprintf (mem.out, "name: %s\n", qname.name); | |
154 | ||
155 | for (int i = 0; i < ancount; ++i) | |
156 | { | |
157 | struct dname rname; | |
158 | if (!extract_name (full, &in, &rname)) | |
159 | { | |
160 | fprintf (mem.out, "error: malformed record name\n"); | |
161 | goto out; | |
162 | } | |
163 | unsigned short rtype; | |
164 | unsigned short rclass; | |
165 | unsigned ttl; | |
166 | unsigned short rdlen; | |
167 | struct in_buffer rdata; | |
168 | if (!(extract_16 (&in, &rtype) | |
169 | && extract_16 (&in, &rclass) | |
170 | && extract_32 (&in, &ttl) | |
171 | && extract_16 (&in, &rdlen) | |
172 | && extract_bytes (&in, rdlen, &rdata))) | |
173 | { | |
174 | fprintf (mem.out, "error: malformed record header\n"); | |
175 | goto out; | |
176 | } | |
177 | /* Skip non-matching record types. */ | |
f889e73f | 178 | if ((rtype != qtype && rtype != T_CNAME) || rclass != qclass) |
5840c75c FW |
179 | continue; |
180 | switch (rtype) | |
181 | { | |
182 | case T_A: | |
183 | if (rdlen == 4) | |
184 | fprintf (mem.out, "address: %d.%d.%d.%d\n", | |
185 | rdata.data[0], | |
186 | rdata.data[1], | |
187 | rdata.data[2], | |
188 | rdata.data[3]); | |
189 | else | |
f889e73f FW |
190 | fprintf (mem.out, "error: A record of size %d: %s\n", |
191 | rdlen, rname.name); | |
5840c75c FW |
192 | break; |
193 | case T_AAAA: | |
194 | { | |
f889e73f FW |
195 | if (rdlen == 16) |
196 | { | |
197 | char buf[100]; | |
198 | if (inet_ntop (AF_INET6, rdata.data, buf, sizeof (buf)) == NULL) | |
199 | fprintf (mem.out, "error: AAAA record decoding failed: %m\n"); | |
200 | else | |
201 | fprintf (mem.out, "address: %s\n", buf); | |
202 | } | |
5840c75c | 203 | else |
f889e73f FW |
204 | fprintf (mem.out, "error: AAAA record of size %d: %s\n", |
205 | rdlen, rname.name); | |
5840c75c FW |
206 | } |
207 | break; | |
208 | case T_CNAME: | |
62a321b1 FW |
209 | extract_name_data (full, &rdata, &rname, "CNAME", mem.out); |
210 | break; | |
5840c75c | 211 | case T_PTR: |
62a321b1 FW |
212 | extract_name_data (full, &rdata, &rname, "PTR", mem.out); |
213 | break; | |
5840c75c FW |
214 | } |
215 | } | |
216 | ||
217 | out: | |
218 | xfclose_memstream (&mem); | |
219 | return mem.buffer; | |
220 | } |