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