1 /*
2 * Copyright (c) 1998-2011 The TCPDUMP project
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that: (1) source code
6 * distributions retain the above copyright notice and this paragraph
7 * in its entirety, and (2) distributions including binary code include
8 * the above copyright notice and this paragraph in its entirety in
9 * the documentation or other materials provided with the distribution.
10 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND
11 * WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT
12 * LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
13 * FOR A PARTICULAR PURPOSE.
14 *
15 * Original code by Hannes Gredler (hannes@gredler.at)
16 */
17
18 /* \summary: Resource Public Key Infrastructure (RPKI) to Router Protocol printer */
19
20 /* specification: RFC 6810 */
21
22 #include <config.h>
23
24 #include "netdissect-stdinc.h"
25
26 #define ND_LONGJMP_FROM_TCHECK
27 #include "netdissect.h"
28 #include "extract.h"
29 #include "addrtoname.h"
30
31
32 /*
33 * RPKI/Router PDU header
34 *
35 * Here's what the PDU header looks like.
36 * The length does include the version and length fields.
37 */
38 typedef struct rpki_rtr_pdu_ {
39 nd_uint8_t version; /* Version number */
40 nd_uint8_t pdu_type; /* PDU type */
41 union {
42 nd_uint16_t session_id; /* Session id */
43 nd_uint16_t error_code; /* Error code */
44 } u;
45 nd_uint32_t length;
46 } rpki_rtr_pdu;
47
48 /*
49 * IPv4 Prefix PDU.
50 */
51 typedef struct rpki_rtr_pdu_ipv4_prefix_ {
52 rpki_rtr_pdu pdu_header;
53 nd_uint8_t flags;
54 nd_uint8_t prefix_length;
55 nd_uint8_t max_length;
56 nd_uint8_t zero;
57 nd_ipv4 prefix;
58 nd_uint32_t as;
59 } rpki_rtr_pdu_ipv4_prefix;
60
61 /*
62 * IPv6 Prefix PDU.
63 */
64 typedef struct rpki_rtr_pdu_ipv6_prefix_ {
65 rpki_rtr_pdu pdu_header;
66 nd_uint8_t flags;
67 nd_uint8_t prefix_length;
68 nd_uint8_t max_length;
69 nd_uint8_t zero;
70 nd_ipv6 prefix;
71 nd_uint32_t as;
72 } rpki_rtr_pdu_ipv6_prefix;
73
74 /*
75 * Error report PDU.
76 */
77 typedef struct rpki_rtr_pdu_error_report_ {
78 rpki_rtr_pdu pdu_header;
79 nd_uint32_t encapsulated_pdu_length; /* Encapsulated PDU length */
80 /* Copy of Erroneous PDU (variable, optional) */
81 /* Length of Error Text (4 octets in network byte order) */
82 /* Arbitrary Text of Error Diagnostic Message (variable, optional) */
83 } rpki_rtr_pdu_error_report;
84
85 /*
86 * PDU type codes
87 */
88 #define RPKI_RTR_SERIAL_NOTIFY_PDU 0
89 #define RPKI_RTR_SERIAL_QUERY_PDU 1
90 #define RPKI_RTR_RESET_QUERY_PDU 2
91 #define RPKI_RTR_CACHE_RESPONSE_PDU 3
92 #define RPKI_RTR_IPV4_PREFIX_PDU 4
93 #define RPKI_RTR_IPV6_PREFIX_PDU 6
94 #define RPKI_RTR_END_OF_DATA_PDU 7
95 #define RPKI_RTR_CACHE_RESET_PDU 8
96 #define RPKI_RTR_ERROR_REPORT_PDU 10
97
98 static const struct tok rpki_rtr_pdu_values[] = {
99 { RPKI_RTR_SERIAL_NOTIFY_PDU, "Serial Notify" },
100 { RPKI_RTR_SERIAL_QUERY_PDU, "Serial Query" },
101 { RPKI_RTR_RESET_QUERY_PDU, "Reset Query" },
102 { RPKI_RTR_CACHE_RESPONSE_PDU, "Cache Response" },
103 { RPKI_RTR_IPV4_PREFIX_PDU, "IPV4 Prefix" },
104 { RPKI_RTR_IPV6_PREFIX_PDU, "IPV6 Prefix" },
105 { RPKI_RTR_END_OF_DATA_PDU, "End of Data" },
106 { RPKI_RTR_CACHE_RESET_PDU, "Cache Reset" },
107 { RPKI_RTR_ERROR_REPORT_PDU, "Error Report" },
108 { 0, NULL}
109 };
110
111 static const struct tok rpki_rtr_error_codes[] = {
112 { 0, "Corrupt Data" },
113 { 1, "Internal Error" },
114 { 2, "No Data Available" },
115 { 3, "Invalid Request" },
116 { 4, "Unsupported Protocol Version" },
117 { 5, "Unsupported PDU Type" },
118 { 6, "Withdrawal of Unknown Record" },
119 { 7, "Duplicate Announcement Received" },
120 { 0, NULL}
121 };
122
123 /*
124 * Build a indentation string for a given indentation level.
125 * XXX this should be really in util.c
126 */
127 static char *
indent_string(u_int indent)128 indent_string (u_int indent)
129 {
130 static char buf[20];
131 u_int idx;
132
133 idx = 0;
134 buf[idx] = '\0';
135
136 /*
137 * Does the static buffer fit ?
138 */
139 if (sizeof(buf) < ((indent/8) + (indent %8) + 2)) {
140 return buf;
141 }
142
143 /*
144 * Heading newline.
145 */
146 buf[idx] = '\n';
147 idx++;
148
149 while (indent >= 8) {
150 buf[idx] = '\t';
151 idx++;
152 indent -= 8;
153 }
154
155 while (indent > 0) {
156 buf[idx] = ' ';
157 idx++;
158 indent--;
159 }
160
161 /*
162 * Trailing zero.
163 */
164 buf[idx] = '\0';
165
166 return buf;
167 }
168
169 /*
170 * Print a single PDU.
171 */
172 static u_int
rpki_rtr_pdu_print(netdissect_options * ndo,const u_char * tptr,const u_int len,const u_char recurse,const u_int indent)173 rpki_rtr_pdu_print(netdissect_options *ndo, const u_char *tptr, const u_int len,
174 const u_char recurse, const u_int indent)
175 {
176 const rpki_rtr_pdu *pdu_header;
177 u_int pdu_type, pdu_len, hexdump;
178 const u_char *msg;
179 uint8_t pdu_ver;
180
181 if (len < sizeof(rpki_rtr_pdu)) {
182 ND_PRINT("(%u bytes is too few to decode)", len);
183 goto invalid;
184 }
185 pdu_header = (const rpki_rtr_pdu *)tptr;
186 pdu_ver = GET_U_1(pdu_header->version);
187 if (pdu_ver != 0) {
188 /* Skip the rest of the input buffer because even if this is
189 * a well-formed PDU of a future RPKI-Router protocol version
190 * followed by a well-formed PDU of RPKI-Router protocol
191 * version 0, there is no way to know exactly how to skip the
192 * current PDU.
193 */
194 ND_PRINT("%sRPKI-RTRv%u (unknown)", indent_string(8), pdu_ver);
195 return len;
196 }
197 pdu_type = GET_U_1(pdu_header->pdu_type);
198 pdu_len = GET_BE_U_4(pdu_header->length);
199 /* Do not check bounds with pdu_len yet, do it in the case blocks
200 * below to make it possible to decode at least the beginning of
201 * a truncated Error Report PDU or a truncated encapsulated PDU.
202 */
203 hexdump = FALSE;
204
205 ND_PRINT("%sRPKI-RTRv%u, %s PDU (%u), length: %u",
206 indent_string(8),
207 pdu_ver,
208 tok2str(rpki_rtr_pdu_values, "Unknown", pdu_type),
209 pdu_type, pdu_len);
210 if (pdu_len < sizeof(rpki_rtr_pdu) || pdu_len > len)
211 goto invalid;
212
213 switch (pdu_type) {
214
215 /*
216 * The following PDUs share the message format.
217 */
218 case RPKI_RTR_SERIAL_NOTIFY_PDU:
219 case RPKI_RTR_SERIAL_QUERY_PDU:
220 case RPKI_RTR_END_OF_DATA_PDU:
221 if (pdu_len != sizeof(rpki_rtr_pdu) + 4)
222 goto invalid;
223 msg = (const u_char *)(pdu_header + 1);
224 ND_PRINT("%sSession ID: 0x%04x, Serial: %u",
225 indent_string(indent+2),
226 GET_BE_U_2(pdu_header->u.session_id),
227 GET_BE_U_4(msg));
228 break;
229
230 /*
231 * The following PDUs share the message format.
232 */
233 case RPKI_RTR_RESET_QUERY_PDU:
234 case RPKI_RTR_CACHE_RESET_PDU:
235 if (pdu_len != sizeof(rpki_rtr_pdu))
236 goto invalid;
237 /* no additional boundary to check */
238
239 /*
240 * Zero payload PDUs.
241 */
242 break;
243
244 case RPKI_RTR_CACHE_RESPONSE_PDU:
245 if (pdu_len != sizeof(rpki_rtr_pdu))
246 goto invalid;
247 /* no additional boundary to check */
248 ND_PRINT("%sSession ID: 0x%04x",
249 indent_string(indent+2),
250 GET_BE_U_2(pdu_header->u.session_id));
251 break;
252
253 case RPKI_RTR_IPV4_PREFIX_PDU:
254 {
255 const rpki_rtr_pdu_ipv4_prefix *pdu;
256
257 if (pdu_len != sizeof(rpki_rtr_pdu_ipv4_prefix))
258 goto invalid;
259 pdu = (const rpki_rtr_pdu_ipv4_prefix *)tptr;
260 ND_PRINT("%sIPv4 Prefix %s/%u-%u, origin-as %u, flags 0x%02x",
261 indent_string(indent+2),
262 GET_IPADDR_STRING(pdu->prefix),
263 GET_U_1(pdu->prefix_length), GET_U_1(pdu->max_length),
264 GET_BE_U_4(pdu->as), GET_U_1(pdu->flags));
265 }
266 break;
267
268 case RPKI_RTR_IPV6_PREFIX_PDU:
269 {
270 const rpki_rtr_pdu_ipv6_prefix *pdu;
271
272 if (pdu_len != sizeof(rpki_rtr_pdu_ipv6_prefix))
273 goto invalid;
274 pdu = (const rpki_rtr_pdu_ipv6_prefix *)tptr;
275 ND_PRINT("%sIPv6 Prefix %s/%u-%u, origin-as %u, flags 0x%02x",
276 indent_string(indent+2),
277 GET_IP6ADDR_STRING(pdu->prefix),
278 GET_U_1(pdu->prefix_length), GET_U_1(pdu->max_length),
279 GET_BE_U_4(pdu->as), GET_U_1(pdu->flags));
280 }
281 break;
282
283 case RPKI_RTR_ERROR_REPORT_PDU:
284 {
285 const rpki_rtr_pdu_error_report *pdu;
286 u_int encapsulated_pdu_length, text_length, tlen, error_code;
287
288 tlen = sizeof(rpki_rtr_pdu);
289 /* Do not test for the "Length of Error Text" data element yet. */
290 if (pdu_len < tlen + 4)
291 goto invalid;
292 pdu = (const rpki_rtr_pdu_error_report *)tptr;
293 encapsulated_pdu_length = GET_BE_U_4(pdu->encapsulated_pdu_length);
294 tlen += 4;
295 /* Safe up to and including the "Length of Encapsulated PDU"
296 * data element, more data elements may be present.
297 */
298
299 error_code = GET_BE_U_2(pdu->pdu_header.u.error_code);
300 ND_PRINT("%sError code: %s (%u), Encapsulated PDU length: %u",
301 indent_string(indent+2),
302 tok2str(rpki_rtr_error_codes, "Unknown", error_code),
303 error_code, encapsulated_pdu_length);
304
305 if (encapsulated_pdu_length) {
306 /* Section 5.10 of RFC 6810 says:
307 * "An Error Report PDU MUST NOT be sent for an Error Report PDU."
308 *
309 * However, as far as the protocol encoding goes Error Report PDUs can
310 * happen to be nested in each other, however many times, in which case
311 * the decoder should still print such semantically incorrect PDUs.
312 *
313 * That said, "the Erroneous PDU field MAY be truncated" (ibid), thus
314 * to keep things simple this implementation decodes only the two
315 * outermost layers of PDUs and makes bounds checks in the outer and
316 * the inner PDU independently.
317 */
318 if (pdu_len < tlen + encapsulated_pdu_length)
319 goto invalid;
320 if (! recurse) {
321 ND_TCHECK_LEN(tptr, tlen + encapsulated_pdu_length);
322 } else {
323 ND_PRINT("%s-----encapsulated PDU-----", indent_string(indent+4));
324 rpki_rtr_pdu_print(ndo, tptr + tlen,
325 encapsulated_pdu_length, 0, indent + 2);
326 }
327 tlen += encapsulated_pdu_length;
328 }
329
330 if (pdu_len < tlen + 4)
331 goto invalid;
332 /*
333 * Extract, trail-zero and print the Error message.
334 */
335 text_length = GET_BE_U_4(tptr + tlen);
336 tlen += 4;
337 /* Safe up to and including the "Length of Error Text" data element,
338 * one more data element may be present.
339 */
340
341 if (text_length) {
342 if (pdu_len < tlen + text_length)
343 goto invalid;
344 /* nd_printn() makes the bounds check */
345 ND_PRINT("%sError text: ", indent_string(indent+2));
346 (void)nd_printn(ndo, tptr + tlen, text_length, NULL);
347 }
348 }
349 break;
350
351 default:
352 ND_TCHECK_LEN(tptr, pdu_len);
353
354 /*
355 * Unknown data, please hexdump.
356 */
357 hexdump = TRUE;
358 }
359
360 /* do we also want to see a hex dump ? */
361 if (ndo->ndo_vflag > 1 || (ndo->ndo_vflag && hexdump)) {
362 print_unknown_data(ndo,tptr,"\n\t ", pdu_len);
363 }
364 return pdu_len;
365
366 invalid:
367 nd_print_invalid(ndo);
368 ND_TCHECK_LEN(tptr, len);
369 return len;
370 }
371
372 void
rpki_rtr_print(netdissect_options * ndo,const u_char * pptr,u_int len)373 rpki_rtr_print(netdissect_options *ndo, const u_char *pptr, u_int len)
374 {
375 ndo->ndo_protocol = "rpki_rtr";
376 if (!ndo->ndo_vflag) {
377 ND_PRINT(", RPKI-RTR");
378 return;
379 }
380 while (len) {
381 u_int pdu_len = rpki_rtr_pdu_print(ndo, pptr, len, 1, 8);
382 len -= pdu_len;
383 pptr += pdu_len;
384 }
385 }
386