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 * 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 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 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