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