epan/dissectors/packet-corosync-totemnet.c

   1 /* packet-corosync-totemnet.c
   2  * Dissector routines for the lowest level(encryption/decryption) protocol used in Corosync cluster engine
   3  * Copyright 2009 2010 2014 Masatake YAMATO <yamato@redhat.com>
   4  * Copyright (c) 2010 2014 Red Hat, Inc.
   5  *
   6  * Wireshark - Network traffic analyzer
   7  * By Gerald Combs <gerald@wireshark.org>
   8  * Copyright 1998 Gerald Combs
   9  *
  10  * SPDX-License-Identifier: GPL-2.0-or-later
  11  */
  12
  13 #include "config.h"
  14
  15 #include <epan/packet.h>
  16 #include <epan/prefs.h>
  17 #include <wsutil/wsgcrypt.h>
  18 #include <wsutil/sober128.h>
  19
  20 static dissector_handle_t corosync_totemnet_handle;
  21 static dissector_handle_t corosync_totemsrp_handle;
  22
  23 /* This dissector deals packets defined in totemnet.c of corosync
  24    cluster engine. In the totemnet.c the packet is encrypted and decrypted
  25    with LibTomCrypt. This dissector tries decrypting the packet with
  26    sober128 and sha1 functions in wireshark. */
  27
  28 /*
  29  * Dissector body
  30  */
  31
  32 #define PORT_COROSYNC_TOTEMNET_RANGE "5404-5405" /* Not IANA registered */
  33
  34 /* Forward declaration we need below */
  35 void proto_register_corosync_totemnet(void);
  36 void proto_reg_handoff_corosync_totemnet(void);
  37
  38 /* Initialize the protocol and registered fields */
  39 static int proto_corosync_totemnet;
  40
  41 /* field of struct security_header */
  42 static int hf_corosync_totemnet_security_header_hash_digest;
  43 static int hf_corosync_totemnet_security_header_salt;
  44 static int hf_corosync_totemnet_security_crypto_type;
  45 static int hf_corosync_totemnet_security_crypto_key;
  46
  47 /* configurable parameters */
  48 static char*  corosync_totemnet_private_keys;
  49 static char** corosync_totemnet_private_keys_list;
  50
  51 /* Initialize the subtree pointers */
  52 static int ett_corosync_totemnet_security_header;
  53
  54 #define SALT_SIZE          16
  55
  56 #define TOTEM_CRYPTO_SOBER 0
  57 #define TOTEM_CRYPTO_NSS   1
  58
  59 static const value_string corosync_totemnet_crypto_type[] = {
  60   { TOTEM_CRYPTO_SOBER, "SOBER" },
  61   { TOTEM_CRYPTO_NSS,   "NSS"   },
  62   { 0, NULL }
  63 };
  64
  65
  66 static int
  67 dissect_corosync_totemnet_security_header(tvbuff_t *tvb,
  68                                           packet_info *pinfo, proto_tree *parent_tree,
  69                                           bool check_crypt_type,
  70                                           const char* key)
  71 {
  72   proto_item *item;
  73   proto_tree *tree;
  74
  75   col_set_str(pinfo->cinfo, COL_PROTOCOL, "COROSYNC/TOTEMNET");
  76   col_clear(pinfo->cinfo, COL_INFO);
  77
  78   if (parent_tree)
  79     {
  80       item = proto_tree_add_item(parent_tree, proto_corosync_totemnet, tvb, 0,
  81                                  -1, ENC_NA);
  82       tree = proto_item_add_subtree(item, ett_corosync_totemnet_security_header);
  83
  84       proto_tree_add_item(tree,
  85                           hf_corosync_totemnet_security_header_hash_digest,
  86                           tvb, 0, HASH_SHA1_LENGTH, ENC_NA);
  87       proto_tree_add_item(tree,
  88                           hf_corosync_totemnet_security_header_salt,
  89                           tvb, HASH_SHA1_LENGTH, SALT_SIZE, ENC_NA);
  90
  91       if (check_crypt_type)
  92         {
  93           int io_len = tvb_reported_length(tvb);
  94           proto_item * key_item;
  95
  96           proto_tree_add_item(tree,
  97                               hf_corosync_totemnet_security_crypto_type,
  98                               tvb, io_len - 1, 1, ENC_BIG_ENDIAN);
  99           key_item = proto_tree_add_string(tree,
 100                                            hf_corosync_totemnet_security_crypto_key,
 101                                            tvb, 0, 0, key);
 102           proto_item_set_generated(key_item);
 103         }
 104     }
 105   return HASH_SHA1_LENGTH + SALT_SIZE;
 106 }
 107
 108 /* About totemnet.c of corosync cluster engine:
 109  *
 110  * dissect_corosynec_totemnet_with_decryption() is derived from
 111  * totemnet.c in corosync which is licensed under 3-clause BSD license.
 112  * However, to merge this dissector to wireshark official source tree,
 113  * corosync developers permit EXPLICITLY to reuse totemnet.c in GPL.
 114  *
 115  http://permalink.gmane.org/gmane.linux.redhat.cluster/19087
 116  ------------------------------------------------------------
 117   Steven Dake | 4 Jan 2011 22:02
 118   Re: [Openais] packet dissectors for totempg, cman, clvmd, rgmanager, cpg,
 119
 120 On 12/14/2010 08:04 AM, Masatake YAMATO wrote:
 121 > Thank you for replying.
 122 >
 123 >> Masatake,
 124 >>
 125 >> Masatake YAMATO napsal(a):
 126 >>> I'd like to your advice more detail seriously.
 127 >>> I've been developing this code for three years.
 128 >>> I don't want to make this code garbage.
 129 >>>
 130 >>>> Masatake,
 131 >>>> I'm pretty sure that biggest problem of your code was that it was
 132 >>>> licensed under BSD (three clause, same as Corosync has)
 133 >>>> license. Wireshark is licensed under GPL and even I like BSD licenses
 134 >>>> much more, I would recommend you to try to relicense code under GPL
 135 >>>> and send them this code.
 136 >>>>
 137 >>>> Regards,
 138 >>>>   Honza
 139 >>> I got the similar comment from wireshark developer.
 140 >>> Please, read the discussion:
 141 >>>     https://gitlab.com/wireshark/wireshark/-/issues/3232
 142 >>>
 143 >>
 144 >> I've read that thread long time before I've sent previous mail, so
 145 >> thats reason why I think that Wireshark developers just feel MUCH more
 146 >> comfortable with GPL and thats reason why they just ignoring it.
 147 >
 148 > I see.
 149 >
 150 >>> In my understanding there is no legal problem in putting 3-clause BSD
 151 >>> code into GPL code.  Acutally wireshark includes some 3-clause BSD
 152 >>> code:
 153 >>>
 154 nnn>>
 155 >> Actually there is really not. BSD to GPL works without problem, but
 156 >> many people just don't know it...
 157 >
 158 > ...it is too bad. I strongly believe FOSS developers should know the
 159 > intent behind of the both licenses.
 160 >
 161 >>> epan/dissectors/packet-radiotap-defs.h:
 162 >>> *//*-
 163 >>>  * Copyright (c) 2003, 2004 David Young.  All rights reserved.
 164 >>>  *
 165 ...
 166 >>>  *
 167 >>>  * Redistribution and use in source and binary forms, with or without
 168 >>>  * modification, are permitted provided that the following conditions
 169 >>>  * are met:
 170 >>>  * 1. Redistributions of source code must retain the above copyright
 171 >>>  *    notice, this list of conditions and the following disclaimer.
 172 >>>  * 2. Redistributions in binary form must reproduce the above copyright
 173 >>>  *    notice, this list of conditions and the following disclaimer in the
 174 >>>  *    documentation and/or other materials provided with the distribution.
 175 >>>  * 3. The name of David Young may not be used to endorse or promote
 176 >>>  *    products derived from this software without specific prior
 177 >>>  *    written permission.
 178 >>>  *
 179 >>>  * THIS SOFTWARE IS PROVIDED BY DAVID YOUNG ``AS IS'' AND ANY
 180 >>>  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 181 >>>  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 182 >>>  * PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL DAVID
 183 >>>  * YOUNG BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 184 >>>  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 185 >>>  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 186 >>>  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 187 >>>  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 188 >>>  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 189 >>>  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
 190 >>>  * OF SUCH DAMAGE.
 191 >>>  *//*
 192 >>> I'd like to separate the legal issue and preference. I think I
 193 >>> understand the importance of preference of upstream
 194 >>> developers. However, I'd like to clear the legal issue first.
 195 >>>
 196 >>
 197 >> Legally it's ok. But as you said, developers preference are
 198 >> different. And because you are trying to change THEIR code it's
 199 >> sometimes better to play they rules.
 200 >
 201 > I see.
 202 >
 203 >>> I can image there are people who prefer to GPL as the license covering
 204 >>> their software. But here I've taken some corosync code in my
 205 >>> dissector. It is essential part of my dissector. And corosync is
 206 >>
 207 >> ^^^ This may be problem. Question is how big is that part and if it
 208 >> can be possible to make exception there. Can you point that code?
 209 >>
 210 >> Steve, we were able to relicense HUGE portion of code in case of
 211 >> libqb, are we able to make the same for Wireshark dissector?
 212 >
 213 > Could you see https://github.com/masatake/wireshark-plugin-rhcs/blob/master/src/packet-corosync-totemnet.c#L156
 214 > I refer totemnet.c to write dissect_corosynec_totemnet_with_decryption() function.
 215 >
 216 >>> licensed in 3-clause BSD, as you know. I'd like to change the license
 217 >>> to merge my code to upstream project. I cannot do it in this context.
 218 >>> See https://gitlab.com/wireshark/wireshark/-/issues/3232#c13
 219 >>> Thank you.
 220 >>
 221 >> Regards,
 222 >>   Honza
 223 >
 224 > Masatake YAMATO
 225
 226 Masatake,
 227
 228 Red Hat is the author of the totemnet file and can provide that code
 229 under GPL if you like.  We cannot modify the license for libtomcrypt as
 230 we are not the authors.  Feel free to change the license for that
 231 particular code you rewrote in the link
 232
 233 > Could you see
 234 https://github.com/masatake/wireshark-plugin-rhcs/blob/master/src/packet-corosync-totemnet.c#L156
 235
 236 under a GPL license if it helps move things along.
 237
 238 Regards
 239 -steveu
 240        */
 241
 242 static int
 243 dissect_corosynec_totemnet_with_decryption(tvbuff_t *tvb,
 244                                            packet_info *pinfo, proto_tree *parent_tree,
 245                                            bool check_crypt_type,
 246                                            const char* key_for_trial)
 247 {
 248   unsigned char  keys[48];
 249   sober128_prng  keygen_prng_state;
 250   sober128_prng  stream_prng_state;
 251   unsigned char *hmac_key       = &keys[32];
 252   unsigned char *cipher_key     = &keys[16];
 253   unsigned char *initial_vector = &keys[0];
 254   unsigned char  digest_comparison[HASH_SHA1_LENGTH];
 255
 256   int            io_len;
 257   uint8_t       *io_base;
 258
 259 #define PRIVATE_KEY_LEN_MAX 256
 260   char           private_key[PRIVATE_KEY_LEN_MAX];
 261   size_t         private_key_len;
 262   unsigned char* hash_digest;
 263   unsigned char* salt;
 264
 265   io_len = tvb_reported_length(tvb) - (check_crypt_type? 1: 0);
 266   if (io_len < HASH_SHA1_LENGTH + SALT_SIZE) {
 267     return 0;
 268   }
 269
 270   io_base = (uint8_t *)tvb_memdup(pinfo->pool, tvb, 0, io_len + (check_crypt_type? 1: 0));
 271   if (check_crypt_type &&
 272       ( io_base[io_len] != TOTEM_CRYPTO_SOBER )) {
 273     return 0;
 274   }
 275
 276   hash_digest = io_base;
 277   salt        = io_base + HASH_SHA1_LENGTH;
 278
 279
 280   memset(private_key, 0, sizeof(private_key));
 281
 282   private_key_len = (strlen(key_for_trial)+4) & 0xFC;
 283   (void) g_strlcpy(private_key, key_for_trial, private_key_len);
 284
 285   /*
 286    * Generate MAC, CIPHER, IV keys from private key
 287    */
 288   memset(keys, 0, sizeof(keys));
 289   sober128_start(&keygen_prng_state);
 290   sober128_add_entropy(private_key,
 291                        (unsigned long)private_key_len, &keygen_prng_state);
 292   sober128_add_entropy(salt, SALT_SIZE, &keygen_prng_state);
 293   sober128_read(keys, sizeof (keys), &keygen_prng_state);
 294
 295   /*
 296    * Setup stream cipher
 297    */
 298   sober128_start (&stream_prng_state);
 299   sober128_add_entropy (cipher_key, 16, &stream_prng_state);
 300   sober128_add_entropy (initial_vector, 16, &stream_prng_state);
 301
 302   /*
 303    * Authenticate contents of message
 304    */
 305   if (ws_hmac_buffer(GCRY_MD_SHA1, digest_comparison, io_base + HASH_SHA1_LENGTH, io_len - HASH_SHA1_LENGTH, hmac_key, 16)) {
 306     return 0;
 307   }
 308
 309   if (memcmp (digest_comparison, hash_digest, HASH_SHA1_LENGTH) != 0)
 310       return 0;
 311
 312   /*
 313    * Decrypt the contents of the message with the cipher key
 314    */
 315
 316   sober128_read(io_base + HASH_SHA1_LENGTH + SALT_SIZE,
 317                 io_len - (HASH_SHA1_LENGTH + SALT_SIZE),
 318                 &stream_prng_state);
 319
 320
 321   /*
 322    * Dissect the decrypted data
 323    */
 324   {
 325     tvbuff_t *decrypted_tvb;
 326     tvbuff_t *next_tvb;
 327
 328
 329     decrypted_tvb = tvb_new_real_data(io_base, io_len, io_len);
 330
 331     tvb_set_child_real_data_tvbuff(tvb, decrypted_tvb);
 332     add_new_data_source(pinfo, decrypted_tvb, "Decrypted Data");
 333
 334
 335     dissect_corosync_totemnet_security_header(decrypted_tvb, pinfo, parent_tree,
 336                                               check_crypt_type, key_for_trial);
 337
 338     next_tvb = tvb_new_subset_length(decrypted_tvb,
 339                               HASH_SHA1_LENGTH + SALT_SIZE,
 340                               io_len - (HASH_SHA1_LENGTH + SALT_SIZE));
 341
 342     return call_dissector(corosync_totemsrp_handle, next_tvb, pinfo, parent_tree) + HASH_SHA1_LENGTH + SALT_SIZE;
 343   }
 344 }
 345
 346 static int
 347 dissect_corosynec_totemnet(tvbuff_t *tvb,
 348                            packet_info *pinfo, proto_tree *parent_tree,
 349                            void *data _U_)
 350 {
 351   if (corosync_totemnet_private_keys_list)
 352     {
 353       static int last_key_index = -1;
 354       int key_index;
 355
 356       static int last_check_crypt_type_index;
 357       int check_crypt_type_index = -1;
 358       bool check_crypt_type_list[] = {false, true};
 359
 360
 361       if (last_key_index != -1)
 362         {
 363           int r;
 364
 365           r = dissect_corosynec_totemnet_with_decryption(tvb,
 366                                                          pinfo,
 367                                                          parent_tree,
 368                                                          check_crypt_type_list[last_check_crypt_type_index],
 369                                                          corosync_totemnet_private_keys_list[last_key_index]);
 370           if (r > 0)
 371             return r;
 372           else
 373             last_key_index = -1;
 374         }
 375
 376       for (key_index = 0;
 377            corosync_totemnet_private_keys_list[key_index];
 378            key_index++)
 379         {
 380           for (check_crypt_type_index = 0;
 381                check_crypt_type_index < 2;
 382                check_crypt_type_index++)
 383             {
 384               int r;
 385
 386               r = dissect_corosynec_totemnet_with_decryption(tvb,
 387                                                              pinfo,
 388                                                              parent_tree,
 389                                                              check_crypt_type_list[check_crypt_type_index],
 390                                                              corosync_totemnet_private_keys_list[key_index]);
 391               if (r > 0)
 392                 {
 393                   last_key_index = key_index;
 394                   last_check_crypt_type_index = check_crypt_type_index;
 395                   return r;
 396                 }
 397               else if (r < 0)
 398                 break;
 399
 400             }
 401         }
 402     }
 403
 404   /* Not encrypted */
 405   return call_dissector(corosync_totemsrp_handle, tvb, pinfo, parent_tree);
 406 }
 407
 408 static void
 409 corosync_totemnet_shutdown(void)
 410 {
 411   g_strfreev(corosync_totemnet_private_keys_list);
 412 }
 413
 414 void
 415 proto_register_corosync_totemnet(void)
 416 {
 417   module_t *corosync_totemnet_module;
 418
 419   static hf_register_info hf[] = {
 420     { &hf_corosync_totemnet_security_header_hash_digest,
 421       { "Hash digest", "corosync_totemnet.security_header_hash_digest",
 422         FT_BYTES, BASE_NONE, NULL, 0x0,
 423         NULL, HFILL }},
 424     { &hf_corosync_totemnet_security_header_salt,
 425       { "Salt", "corosync_totemnet.security_header_salt",
 426         FT_BYTES, BASE_NONE, NULL, 0x0,
 427         NULL, HFILL }},
 428     { &hf_corosync_totemnet_security_crypto_type,
 429       { "Cryptographic Type", "corosync_totemnet.security_crypto_type",
 430         FT_UINT8, BASE_DEC, VALS(corosync_totemnet_crypto_type), 0x0,
 431         NULL, HFILL }},
 432     { &hf_corosync_totemnet_security_crypto_key,
 433       { "Private Key for decryption", "corosync_totemnet.security_crypto_key",
 434         FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }},
 435   };
 436
 437   static int *ett_corosync_totemnet[] = {
 438     &ett_corosync_totemnet_security_header,
 439   };
 440
 441   proto_corosync_totemnet = proto_register_protocol("Totemnet Layer of Corosync Cluster Engine",
 442                                                     "COROSYNC/TOTEMNET", "corosync_totemnet");
 443   proto_register_field_array(proto_corosync_totemnet, hf, array_length(hf));
 444   proto_register_subtree_array(ett_corosync_totemnet, array_length(ett_corosync_totemnet));
 445
 446   corosync_totemnet_module = prefs_register_protocol(proto_corosync_totemnet,
 447                                                      proto_reg_handoff_corosync_totemnet);
 448
 449   prefs_register_string_preference(corosync_totemnet_module, "private_keys", "Private keys",
 450                                    "Semicolon-separated  list of keys for decryption(e.g. key1;key2;..." ,
 451                                    (const char **)&corosync_totemnet_private_keys);
 452
 453   register_shutdown_routine(corosync_totemnet_shutdown);
 454
 455   corosync_totemnet_handle = register_dissector("corosync_totemnet", dissect_corosynec_totemnet, proto_corosync_totemnet);
 456 }
 457
 458 void
 459 proto_reg_handoff_corosync_totemnet(void)
 460 {
 461   static bool initialized = false;
 462
 463   if (!initialized)
 464   {
 465     corosync_totemsrp_handle = find_dissector_add_dependency("corosync_totemsrp", proto_corosync_totemnet);
 466
 467     dissector_add_uint_range_with_preference("udp.port", PORT_COROSYNC_TOTEMNET_RANGE, corosync_totemnet_handle);
 468     initialized = true;
 469   }
 470
 471   g_strfreev(corosync_totemnet_private_keys_list);
 472   corosync_totemnet_private_keys_list = g_strsplit(corosync_totemnet_private_keys, ";", 0);
 473 }
 474
 475 /*
 476  * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 477  *
 478  * Local variables:
 479  * c-basic-offset: 4
 480  * tab-width: 8
 481  * indent-tabs-mode: nil
 482  * End:
 483  *
 484  * vi: set shiftwidth=4 tabstop=8 expandtab:
 485  * :indentSize=4:tabSize=8:noTabs=true:
 486  */