1 /** 2 * Copyright (c) 2012 3 * 4 * Gregory Detal <gregory.detal@uclouvain.be> 5 * Christoph Paasch <christoph.paasch@uclouvain.be> 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 18 * 3. Neither the name of the University nor of the Laboratory may be used 19 * to endorse or promote products derived from this software without 20 * specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 */ 34 35 /* \summary: Multipath TCP (MPTCP) printer */ 36 37 /* specification: RFC 6824 */ 38 39 #ifdef HAVE_CONFIG_H 40 #include <config.h> 41 #endif 42 43 #include "netdissect-stdinc.h" 44 45 #include "netdissect.h" 46 #include "extract.h" 47 #include "addrtoname.h" 48 49 #include "tcp.h" 50 51 #define MPTCP_SUB_CAPABLE 0x0 52 #define MPTCP_SUB_JOIN 0x1 53 #define MPTCP_SUB_DSS 0x2 54 #define MPTCP_SUB_ADD_ADDR 0x3 55 #define MPTCP_SUB_REMOVE_ADDR 0x4 56 #define MPTCP_SUB_PRIO 0x5 57 #define MPTCP_SUB_FAIL 0x6 58 #define MPTCP_SUB_FCLOSE 0x7 59 60 struct mptcp_option { 61 nd_uint8_t kind; 62 nd_uint8_t len; 63 nd_uint8_t sub_etc; /* subtype upper 4 bits, other stuff lower 4 bits */ 64 }; 65 66 #define MPTCP_OPT_SUBTYPE(sub_etc) ((GET_U_1(sub_etc) >> 4) & 0xF) 67 68 struct mp_capable { 69 nd_uint8_t kind; 70 nd_uint8_t len; 71 nd_uint8_t sub_ver; 72 nd_uint8_t flags; 73 nd_uint64_t sender_key; 74 nd_uint64_t receiver_key; 75 }; 76 77 #define MP_CAPABLE_OPT_VERSION(sub_ver) ((GET_U_1(sub_ver) >> 0) & 0xF) 78 #define MP_CAPABLE_C 0x80 79 #define MP_CAPABLE_S 0x01 80 81 struct mp_join { 82 nd_uint8_t kind; 83 nd_uint8_t len; 84 nd_uint8_t sub_b; 85 nd_uint8_t addr_id; 86 union { 87 struct { 88 nd_uint32_t token; 89 nd_uint32_t nonce; 90 } syn; 91 struct { 92 nd_uint64_t mac; 93 nd_uint32_t nonce; 94 } synack; 95 struct { 96 nd_byte mac[20]; 97 } ack; 98 } u; 99 }; 100 101 #define MP_JOIN_B 0x01 102 103 struct mp_dss { 104 nd_uint8_t kind; 105 nd_uint8_t len; 106 nd_uint8_t sub; 107 nd_uint8_t flags; 108 }; 109 110 #define MP_DSS_F 0x10 111 #define MP_DSS_m 0x08 112 #define MP_DSS_M 0x04 113 #define MP_DSS_a 0x02 114 #define MP_DSS_A 0x01 115 116 static const struct tok mptcp_addr_subecho_bits[] = { 117 { 0x6, "v0-ip6" }, 118 { 0x4, "v0-ip4" }, 119 { 0x1, "v1-echo" }, 120 { 0x0, "v1" }, 121 { 0, NULL } 122 }; 123 124 struct mp_add_addr { 125 nd_uint8_t kind; 126 nd_uint8_t len; 127 nd_uint8_t sub_echo; 128 nd_uint8_t addr_id; 129 union { 130 struct { 131 nd_ipv4 addr; 132 nd_uint16_t port; 133 nd_uint64_t mac; 134 } v4; 135 struct { 136 nd_ipv4 addr; 137 nd_uint64_t mac; 138 } v4np; 139 struct { 140 nd_ipv6 addr; 141 nd_uint16_t port; 142 nd_uint64_t mac; 143 } v6; 144 struct { 145 nd_ipv6 addr; 146 nd_uint64_t mac; 147 } v6np; 148 } u; 149 }; 150 151 struct mp_remove_addr { 152 nd_uint8_t kind; 153 nd_uint8_t len; 154 nd_uint8_t sub; 155 /* list of addr_id */ 156 nd_uint8_t addrs_id[1]; 157 }; 158 159 struct mp_fail { 160 nd_uint8_t kind; 161 nd_uint8_t len; 162 nd_uint8_t sub; 163 nd_uint8_t resv; 164 nd_uint64_t data_seq; 165 }; 166 167 struct mp_close { 168 nd_uint8_t kind; 169 nd_uint8_t len; 170 nd_uint8_t sub; 171 nd_uint8_t rsv; 172 nd_byte key[8]; 173 }; 174 175 struct mp_prio { 176 nd_uint8_t kind; 177 nd_uint8_t len; 178 nd_uint8_t sub_b; 179 nd_uint8_t addr_id; 180 }; 181 182 #define MP_PRIO_B 0x01 183 184 static int 185 dummy_print(netdissect_options *ndo _U_, 186 const u_char *opt _U_, u_int opt_len _U_, u_char flags _U_) 187 { 188 return 1; 189 } 190 191 static int 192 mp_capable_print(netdissect_options *ndo, 193 const u_char *opt, u_int opt_len, u_char flags) 194 { 195 const struct mp_capable *mpc = (const struct mp_capable *) opt; 196 uint8_t version; 197 198 if (!((opt_len == 12 || opt_len == 4) && flags & TH_SYN) && 199 !((opt_len == 20 || opt_len == 22) && (flags & (TH_SYN | TH_ACK)) == 200 TH_ACK)) 201 return 0; 202 203 version = MP_CAPABLE_OPT_VERSION(mpc->sub_ver); /* uses GET_U_1() */ 204 switch (version) { 205 case 0: /* fall through */ 206 case 1: 207 ND_PRINT(" v%u", version); 208 break; 209 default: 210 ND_PRINT(" Unknown Version (%u)", version); 211 return 1; 212 } 213 214 if (GET_U_1(mpc->flags) & MP_CAPABLE_C) 215 ND_PRINT(" csum"); 216 if (opt_len == 12 || opt_len >= 20) { 217 ND_PRINT(" {0x%" PRIx64, GET_BE_U_8(mpc->sender_key)); 218 if (opt_len >= 20) 219 ND_PRINT(",0x%" PRIx64, GET_BE_U_8(mpc->receiver_key)); 220 ND_PRINT("}"); 221 } 222 return 1; 223 } 224 225 static int 226 mp_join_print(netdissect_options *ndo, 227 const u_char *opt, u_int opt_len, u_char flags) 228 { 229 const struct mp_join *mpj = (const struct mp_join *) opt; 230 231 if (!(opt_len == 12 && (flags & TH_SYN)) && 232 !(opt_len == 16 && (flags & (TH_SYN | TH_ACK)) == (TH_SYN | TH_ACK)) && 233 !(opt_len == 24 && (flags & TH_ACK))) 234 return 0; 235 236 if (opt_len != 24) { 237 if (GET_U_1(mpj->sub_b) & MP_JOIN_B) 238 ND_PRINT(" backup"); 239 ND_PRINT(" id %u", GET_U_1(mpj->addr_id)); 240 } 241 242 switch (opt_len) { 243 case 12: /* SYN */ 244 ND_PRINT(" token 0x%x" " nonce 0x%x", 245 GET_BE_U_4(mpj->u.syn.token), 246 GET_BE_U_4(mpj->u.syn.nonce)); 247 break; 248 case 16: /* SYN/ACK */ 249 ND_PRINT(" hmac 0x%" PRIx64 " nonce 0x%x", 250 GET_BE_U_8(mpj->u.synack.mac), 251 GET_BE_U_4(mpj->u.synack.nonce)); 252 break; 253 case 24: {/* ACK */ 254 size_t i; 255 ND_PRINT(" hmac 0x"); 256 for (i = 0; i < sizeof(mpj->u.ack.mac); ++i) 257 ND_PRINT("%02x", mpj->u.ack.mac[i]); 258 } 259 default: 260 break; 261 } 262 return 1; 263 } 264 265 static int 266 mp_dss_print(netdissect_options *ndo, 267 const u_char *opt, u_int opt_len, u_char flags) 268 { 269 const struct mp_dss *mdss = (const struct mp_dss *) opt; 270 uint8_t mdss_flags; 271 272 /* We need the flags, at a minimum. */ 273 if (opt_len < 4) 274 return 0; 275 276 if (flags & TH_SYN) 277 return 0; 278 279 mdss_flags = GET_U_1(mdss->flags); 280 if (mdss_flags & MP_DSS_F) 281 ND_PRINT(" fin"); 282 283 opt += 4; 284 opt_len -= 4; 285 if (mdss_flags & MP_DSS_A) { 286 /* Ack present */ 287 ND_PRINT(" ack "); 288 /* 289 * If the a flag is set, we have an 8-byte ack; if it's 290 * clear, we have a 4-byte ack. 291 */ 292 if (mdss_flags & MP_DSS_a) { 293 if (opt_len < 8) 294 return 0; 295 ND_PRINT("%" PRIu64, GET_BE_U_8(opt)); 296 opt += 8; 297 opt_len -= 8; 298 } else { 299 if (opt_len < 4) 300 return 0; 301 ND_PRINT("%u", GET_BE_U_4(opt)); 302 opt += 4; 303 opt_len -= 4; 304 } 305 } 306 307 if (mdss_flags & MP_DSS_M) { 308 /* 309 * Data Sequence Number (DSN), Subflow Sequence Number (SSN), 310 * Data-Level Length present, and Checksum possibly present. 311 */ 312 ND_PRINT(" seq "); 313 /* 314 * If the m flag is set, we have an 8-byte NDS; if it's clear, 315 * we have a 4-byte DSN. 316 */ 317 if (mdss_flags & MP_DSS_m) { 318 if (opt_len < 8) 319 return 0; 320 ND_PRINT("%" PRIu64, GET_BE_U_8(opt)); 321 opt += 8; 322 opt_len -= 8; 323 } else { 324 if (opt_len < 4) 325 return 0; 326 ND_PRINT("%u", GET_BE_U_4(opt)); 327 opt += 4; 328 opt_len -= 4; 329 } 330 if (opt_len < 4) 331 return 0; 332 ND_PRINT(" subseq %u", GET_BE_U_4(opt)); 333 opt += 4; 334 opt_len -= 4; 335 if (opt_len < 2) 336 return 0; 337 ND_PRINT(" len %u", GET_BE_U_2(opt)); 338 opt += 2; 339 opt_len -= 2; 340 341 /* 342 * The Checksum is present only if negotiated. 343 * If there are at least 2 bytes left, process the next 2 344 * bytes as the Checksum. 345 */ 346 if (opt_len >= 2) { 347 ND_PRINT(" csum 0x%x", GET_BE_U_2(opt)); 348 opt_len -= 2; 349 } 350 } 351 if (opt_len != 0) 352 return 0; 353 return 1; 354 } 355 356 static int 357 add_addr_print(netdissect_options *ndo, 358 const u_char *opt, u_int opt_len, u_char flags _U_) 359 { 360 const struct mp_add_addr *add_addr = (const struct mp_add_addr *) opt; 361 362 if (!(opt_len == 8 || opt_len == 10 || opt_len == 16 || opt_len == 18 || 363 opt_len == 20 || opt_len == 22 || opt_len == 28 || opt_len == 30)) 364 return 0; 365 366 ND_PRINT(" %s", 367 tok2str(mptcp_addr_subecho_bits, "[bad version/echo]", 368 GET_U_1(add_addr->sub_echo) & 0xF)); 369 ND_PRINT(" id %u", GET_U_1(add_addr->addr_id)); 370 if (opt_len == 8 || opt_len == 10 || opt_len == 16 || opt_len == 18) { 371 ND_PRINT(" %s", GET_IPADDR_STRING(add_addr->u.v4.addr)); 372 if (opt_len == 10 || opt_len == 18) 373 ND_PRINT(":%u", GET_BE_U_2(add_addr->u.v4.port)); 374 if (opt_len == 16) 375 ND_PRINT(" hmac 0x%" PRIx64, GET_BE_U_8(add_addr->u.v4np.mac)); 376 if (opt_len == 18) 377 ND_PRINT(" hmac 0x%" PRIx64, GET_BE_U_8(add_addr->u.v4.mac)); 378 } 379 380 if (opt_len == 20 || opt_len == 22 || opt_len == 28 || opt_len == 30) { 381 ND_PRINT(" %s", GET_IP6ADDR_STRING(add_addr->u.v6.addr)); 382 if (opt_len == 22 || opt_len == 30) 383 ND_PRINT(":%u", GET_BE_U_2(add_addr->u.v6.port)); 384 if (opt_len == 28) 385 ND_PRINT(" hmac 0x%" PRIx64, GET_BE_U_8(add_addr->u.v6np.mac)); 386 if (opt_len == 30) 387 ND_PRINT(" hmac 0x%" PRIx64, GET_BE_U_8(add_addr->u.v6.mac)); 388 } 389 390 return 1; 391 } 392 393 static int 394 remove_addr_print(netdissect_options *ndo, 395 const u_char *opt, u_int opt_len, u_char flags _U_) 396 { 397 const struct mp_remove_addr *remove_addr = (const struct mp_remove_addr *) opt; 398 u_int i; 399 400 if (opt_len < 4) 401 return 0; 402 403 opt_len -= 3; 404 ND_PRINT(" id"); 405 for (i = 0; i < opt_len; i++) 406 ND_PRINT(" %u", GET_U_1(remove_addr->addrs_id[i])); 407 return 1; 408 } 409 410 static int 411 mp_prio_print(netdissect_options *ndo, 412 const u_char *opt, u_int opt_len, u_char flags _U_) 413 { 414 const struct mp_prio *mpp = (const struct mp_prio *) opt; 415 416 if (opt_len != 3 && opt_len != 4) 417 return 0; 418 419 if (GET_U_1(mpp->sub_b) & MP_PRIO_B) 420 ND_PRINT(" backup"); 421 else 422 ND_PRINT(" non-backup"); 423 if (opt_len == 4) 424 ND_PRINT(" id %u", GET_U_1(mpp->addr_id)); 425 426 return 1; 427 } 428 429 static int 430 mp_fail_print(netdissect_options *ndo, 431 const u_char *opt, u_int opt_len, u_char flags _U_) 432 { 433 if (opt_len != 12) 434 return 0; 435 436 ND_PRINT(" seq %" PRIu64, GET_BE_U_8(opt + 4)); 437 return 1; 438 } 439 440 static int 441 mp_fast_close_print(netdissect_options *ndo, 442 const u_char *opt, u_int opt_len, u_char flags _U_) 443 { 444 if (opt_len != 12) 445 return 0; 446 447 ND_PRINT(" key 0x%" PRIx64, GET_BE_U_8(opt + 4)); 448 return 1; 449 } 450 451 static const struct { 452 const char *name; 453 int (*print)(netdissect_options *, const u_char *, u_int, u_char); 454 } mptcp_options[] = { 455 { "capable", mp_capable_print}, 456 { "join", mp_join_print }, 457 { "dss", mp_dss_print }, 458 { "add-addr", add_addr_print }, 459 { "rem-addr", remove_addr_print }, 460 { "prio", mp_prio_print }, 461 { "fail", mp_fail_print }, 462 { "fast-close", mp_fast_close_print }, 463 { "unknown", dummy_print }, 464 }; 465 466 int 467 mptcp_print(netdissect_options *ndo, 468 const u_char *cp, u_int len, u_char flags) 469 { 470 const struct mptcp_option *opt; 471 u_int subtype; 472 473 ndo->ndo_protocol = "mptcp"; 474 if (len < 3) 475 return 0; 476 477 opt = (const struct mptcp_option *) cp; 478 subtype = MPTCP_OPT_SUBTYPE(opt->sub_etc); /* uses GET_U_1() */ 479 subtype = ND_MIN(subtype, MPTCP_SUB_FCLOSE + 1); 480 481 ND_PRINT(" %s", mptcp_options[subtype].name); 482 return mptcp_options[subtype].print(ndo, cp, len, flags); 483 } 484