source/libsmb/smb_signing.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    SMB Signing Code
   4    Copyright (C) Jeremy Allison 2003.
   5    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2002-2003
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23
  24 /* Lookup a packet's MID (multiplex id) and figure out it's sequence number */
  25 struct outstanding_packet_lookup {
  26         struct outstanding_packet_lookup *prev, *next;
  27         uint16 mid;
  28         uint32 reply_seq_num;
  29         BOOL can_delete; /* Set to False in trans state. */
  30 };
  31
  32 struct smb_basic_signing_context {
  33         DATA_BLOB mac_key;
  34         uint32 send_seq_num;
  35         struct outstanding_packet_lookup *outstanding_packet_list;
  36 };
  37
  38 static BOOL store_sequence_for_reply(struct outstanding_packet_lookup **list,
  39                                      uint16 mid, uint32 reply_seq_num)
  40 {
  41         struct outstanding_packet_lookup *t;
  42
  43         /* Ensure we only add a mid once. */
  44         for (t = *list; t; t = t->next) {
  45                 if (t->mid == mid) {
  46                         return False;
  47                 }
  48         }
  49
  50         t = SMB_XMALLOC_P(struct outstanding_packet_lookup);
  51         ZERO_STRUCTP(t);
  52
  53         t->mid = mid;
  54         t->reply_seq_num = reply_seq_num;
  55         t->can_delete = True;
  56
  57         /*
  58          * Add to the *start* of the list not the end of the list.
  59          * This ensures that the *last* send sequence with this mid
  60          * is returned by preference.
  61          * This can happen if the mid wraps and one of the early
  62          * mid numbers didn't get a reply and is still lurking on
  63          * the list. JRA. Found by Fran Fabrizio <fran@cis.uab.edu>.
  64          */
  65
  66         DLIST_ADD(*list, t);
  67         DEBUG(10,("store_sequence_for_reply: stored seq = %u mid = %u\n",
  68                         (unsigned int)reply_seq_num, (unsigned int)mid ));
  69         return True;
  70 }
  71
  72 static BOOL get_sequence_for_reply(struct outstanding_packet_lookup **list,
  73                                    uint16 mid, uint32 *reply_seq_num)
  74 {
  75         struct outstanding_packet_lookup *t;
  76
  77         for (t = *list; t; t = t->next) {
  78                 if (t->mid == mid) {
  79                         *reply_seq_num = t->reply_seq_num;
  80                         DEBUG(10,("get_sequence_for_reply: found seq = %u mid = %u\n",
  81                                 (unsigned int)t->reply_seq_num, (unsigned int)t->mid ));
  82                         if (t->can_delete) {
  83                                 DLIST_REMOVE(*list, t);
  84                                 SAFE_FREE(t);
  85                         }
  86                         return True;
  87                 }
  88         }
  89         return False;
  90 }
  91
  92 static BOOL set_sequence_can_delete_flag(struct outstanding_packet_lookup **list, uint16 mid, BOOL can_delete_entry)
  93 {
  94         struct outstanding_packet_lookup *t;
  95
  96         for (t = *list; t; t = t->next) {
  97                 if (t->mid == mid) {
  98                         t->can_delete = can_delete_entry;
  99                         return True;
 100                 }
 101         }
 102         return False;
 103 }
 104
 105 /***********************************************************
 106  SMB signing - Common code before we set a new signing implementation
 107 ************************************************************/
 108
 109 static BOOL cli_set_smb_signing_common(struct cli_state *cli)
 110 {
 111         if (!cli->sign_info.allow_smb_signing) {
 112                 return False;
 113         }
 114
 115         if (!cli->sign_info.negotiated_smb_signing
 116             && !cli->sign_info.mandatory_signing) {
 117                 return False;
 118         }
 119
 120         if (cli->sign_info.doing_signing) {
 121                 return False;
 122         }
 123
 124         if (cli->sign_info.free_signing_context)
 125                 cli->sign_info.free_signing_context(&cli->sign_info);
 126
 127         /* These calls are INCOMPATIBLE with SMB signing */
 128         cli->readbraw_supported = False;
 129         cli->writebraw_supported = False;
 130
 131         return True;
 132 }
 133
 134 /***********************************************************
 135  SMB signing - Common code for 'real' implementations
 136 ************************************************************/
 137
 138 static BOOL set_smb_signing_real_common(struct smb_sign_info *si)
 139 {
 140         if (si->mandatory_signing) {
 141                 DEBUG(5, ("Mandatory SMB signing enabled!\n"));
 142         }
 143
 144         si->doing_signing = True;
 145         DEBUG(5, ("SMB signing enabled!\n"));
 146
 147         return True;
 148 }
 149
 150 static void mark_packet_signed(char *outbuf)
 151 {
 152         uint16 flags2;
 153         flags2 = SVAL(outbuf,smb_flg2);
 154         flags2 |= FLAGS2_SMB_SECURITY_SIGNATURES;
 155         SSVAL(outbuf,smb_flg2, flags2);
 156 }
 157
 158 /***********************************************************
 159  SMB signing - NULL implementation - calculate a MAC to send.
 160 ************************************************************/
 161
 162 static void null_sign_outgoing_message(char *outbuf, struct smb_sign_info *si)
 163 {
 164         /* we can't zero out the sig, as we might be trying to send a
 165            session request - which is NBT-level, not SMB level and doesn't
 166            have the field */
 167         return;
 168 }
 169
 170 /***********************************************************
 171  SMB signing - NULL implementation - check a MAC sent by server.
 172 ************************************************************/
 173
 174 static BOOL null_check_incoming_message(char *inbuf, struct smb_sign_info *si, BOOL must_be_ok)
 175 {
 176         return True;
 177 }
 178
 179 /***********************************************************
 180  SMB signing - NULL implementation - free signing context
 181 ************************************************************/
 182
 183 static void null_free_signing_context(struct smb_sign_info *si)
 184 {
 185         return;
 186 }
 187
 188 /**
 189  SMB signing - NULL implementation - setup the MAC key.
 190
 191  @note Used as an initialisation only - it will not correctly
 192        shut down a real signing mechanism
 193 */
 194
 195 static BOOL null_set_signing(struct smb_sign_info *si)
 196 {
 197         si->signing_context = NULL;
 198
 199         si->sign_outgoing_message = null_sign_outgoing_message;
 200         si->check_incoming_message = null_check_incoming_message;
 201         si->free_signing_context = null_free_signing_context;
 202
 203         return True;
 204 }
 205
 206 /**
 207  * Free the signing context
 208  */
 209
 210 static void free_signing_context(struct smb_sign_info *si)
 211 {
 212         if (si->free_signing_context) {
 213                 si->free_signing_context(si);
 214                 si->signing_context = NULL;
 215         }
 216
 217         null_set_signing(si);
 218 }
 219
 220
 221 static BOOL signing_good(char *inbuf, struct smb_sign_info *si, BOOL good, uint32 seq, BOOL must_be_ok)
 222 {
 223         if (good) {
 224
 225                 if (!si->doing_signing) {
 226                         si->doing_signing = True;
 227                 }
 228
 229                 if (!si->seen_valid) {
 230                         si->seen_valid = True;
 231                 }
 232
 233         } else {
 234                 if (!si->mandatory_signing && !si->seen_valid) {
 235
 236                         if (!must_be_ok) {
 237                                 return True;
 238                         }
 239                         /* Non-mandatory signing - just turn off if this is the first bad packet.. */
 240                         DEBUG(5, ("srv_check_incoming_message: signing negotiated but not required and peer\n"
 241                                   "isn't sending correct signatures. Turning off.\n"));
 242                         si->negotiated_smb_signing = False;
 243                         si->allow_smb_signing = False;
 244                         si->doing_signing = False;
 245                         free_signing_context(si);
 246                         return True;
 247                 } else if (!must_be_ok) {
 248                         /* This packet is known to be unsigned */
 249                         return True;
 250                 } else {
 251                         /* Mandatory signing or bad packet after signing started - fail and disconnect. */
 252                         if (seq)
 253                                 DEBUG(0, ("signing_good: BAD SIG: seq %u\n", (unsigned int)seq));
 254                         return False;
 255                 }
 256         }
 257         return True;
 258 }
 259
 260 /***********************************************************
 261  SMB signing - Simple implementation - calculate a MAC on the packet
 262 ************************************************************/
 263
 264 static void simple_packet_signature(struct smb_basic_signing_context *data,
 265                                     const uchar *buf, uint32 seq_number,
 266                                     unsigned char calc_md5_mac[16])
 267 {
 268         const size_t offset_end_of_sig = (smb_ss_field + 8);
 269         unsigned char sequence_buf[8];
 270         struct MD5Context md5_ctx;
 271 #if 0
 272         /* JRA - apparently this is incorrect. */
 273         unsigned char key_buf[16];
 274 #endif
 275
 276         /*
 277          * Firstly put the sequence number into the first 4 bytes.
 278          * and zero out the next 4 bytes.
 279          *
 280          * We do this here, to avoid modifying the packet.
 281          */
 282
 283         DEBUG(10,("simple_packet_signature: sequence number %u\n", seq_number ));
 284
 285         SIVAL(sequence_buf, 0, seq_number);
 286         SIVAL(sequence_buf, 4, 0);
 287
 288         /* Calculate the 16 byte MAC - but don't alter the data in the
 289            incoming packet.
 290
 291            This makes for a bit of fussing about, but it's not too bad.
 292         */
 293         MD5Init(&md5_ctx);
 294
 295         /* intialise with the key */
 296         MD5Update(&md5_ctx, data->mac_key.data, data->mac_key.length);
 297 #if 0
 298         /* JRA - apparently this is incorrect. */
 299         /* NB. When making and verifying SMB signatures, Windows apparently
 300                 zero-pads the key to 128 bits if it isn't long enough.
 301                 From Nalin Dahyabhai <nalin@redhat.com> */
 302         if (data->mac_key.length < sizeof(key_buf)) {
 303                 memset(key_buf, 0, sizeof(key_buf));
 304                 MD5Update(&md5_ctx, key_buf, sizeof(key_buf) - data->mac_key.length);
 305         }
 306 #endif
 307
 308         /* copy in the first bit of the SMB header */
 309         MD5Update(&md5_ctx, buf + 4, smb_ss_field - 4);
 310
 311         /* copy in the sequence number, instead of the signature */
 312         MD5Update(&md5_ctx, sequence_buf, sizeof(sequence_buf));
 313
 314         /* copy in the rest of the packet in, skipping the signature */
 315         MD5Update(&md5_ctx, buf + offset_end_of_sig,
 316                   smb_len(buf) - (offset_end_of_sig - 4));
 317
 318         /* calculate the MD5 sig */
 319         MD5Final(calc_md5_mac, &md5_ctx);
 320 }
 321
 322
 323 /***********************************************************
 324  SMB signing - Client implementation - send the MAC.
 325 ************************************************************/
 326
 327 static void client_sign_outgoing_message(char *outbuf, struct smb_sign_info *si)
 328 {
 329         unsigned char calc_md5_mac[16];
 330         struct smb_basic_signing_context *data =
 331                 (struct smb_basic_signing_context *)si->signing_context;
 332
 333         if (!si->doing_signing)
 334                 return;
 335
 336         /* JRA Paranioa test - we should be able to get rid of this... */
 337         if (smb_len(outbuf) < (smb_ss_field + 8 - 4)) {
 338                 DEBUG(1, ("client_sign_outgoing_message: Logic error. Can't check signature on short packet! smb_len = %u\n",
 339                                         smb_len(outbuf) ));
 340                 abort();
 341         }
 342
 343         /* mark the packet as signed - BEFORE we sign it...*/
 344         mark_packet_signed(outbuf);
 345
 346         simple_packet_signature(data, (const unsigned char *)outbuf,
 347                                 data->send_seq_num, calc_md5_mac);
 348
 349         DEBUG(10, ("client_sign_outgoing_message: sent SMB signature of\n"));
 350         dump_data(10, calc_md5_mac, 8);
 351
 352         memcpy(&outbuf[smb_ss_field], calc_md5_mac, 8);
 353
 354 /*      cli->outbuf[smb_ss_field+2]=0;
 355         Uncomment this to test if the remote server actually verifies signatures...*/
 356
 357         /* Instead of re-introducing the trans_info_conect we
 358            used to have here, we use the fact that during a
 359            SMBtrans/SMBtrans2/SMBnttrans send that the mid stays
 360            constant. This means that calling store_sequence_for_reply()
 361            will return False for all trans secondaries, as the mid is already
 362            on the stored sequence list. As the send_seqence_number must
 363            remain constant for all primary+secondary trans sends, we
 364            only increment the send sequence number when we successfully
 365            add a new entry to the outstanding sequence list. This means
 366            I can isolate the fix here rather than re-adding the trans
 367            signing on/off calls in libsmb/clitrans2.c JRA.
 368          */
 369
 370         if (store_sequence_for_reply(&data->outstanding_packet_list, SVAL(outbuf,smb_mid), data->send_seq_num + 1)) {
 371                 data->send_seq_num += 2;
 372         }
 373 }
 374
 375 /***********************************************************
 376  SMB signing - Client implementation - check a MAC sent by server.
 377 ************************************************************/
 378
 379 static BOOL client_check_incoming_message(char *inbuf, struct smb_sign_info *si, BOOL must_be_ok)
 380 {
 381         BOOL good;
 382         uint32 reply_seq_number;
 383         unsigned char calc_md5_mac[16];
 384         unsigned char *server_sent_mac;
 385
 386         struct smb_basic_signing_context *data =
 387                 (struct smb_basic_signing_context *)si->signing_context;
 388
 389         if (!si->doing_signing)
 390                 return True;
 391
 392         if (smb_len(inbuf) < (smb_ss_field + 8 - 4)) {
 393                 DEBUG(1, ("client_check_incoming_message: Can't check signature on short packet! smb_len = %u\n", smb_len(inbuf)));
 394                 return False;
 395         }
 396
 397         if (!get_sequence_for_reply(&data->outstanding_packet_list, SVAL(inbuf, smb_mid), &reply_seq_number)) {
 398                 DEBUG(1, ("client_check_incoming_message: received message "
 399                         "with mid %u with no matching send record.\n", (unsigned int)SVAL(inbuf, smb_mid) ));
 400                 return False;
 401         }
 402
 403         simple_packet_signature(data, (const unsigned char *)inbuf,
 404                                 reply_seq_number, calc_md5_mac);
 405
 406         server_sent_mac = (unsigned char *)&inbuf[smb_ss_field];
 407         good = (memcmp(server_sent_mac, calc_md5_mac, 8) == 0);
 408
 409         if (!good) {
 410                 DEBUG(5, ("client_check_incoming_message: BAD SIG: wanted SMB signature of\n"));
 411                 dump_data(5, calc_md5_mac, 8);
 412
 413                 DEBUG(5, ("client_check_incoming_message: BAD SIG: got SMB signature of\n"));
 414                 dump_data(5, server_sent_mac, 8);
 415 #if 1 /* JRATEST */
 416                 {
 417                         int i;
 418                         for (i = -5; i < 5; i++) {
 419                                 simple_packet_signature(data, (const unsigned char *)inbuf, reply_seq_number+i, calc_md5_mac);
 420                                 if (memcmp(server_sent_mac, calc_md5_mac, 8) == 0) {
 421                                         DEBUG(0,("client_check_incoming_message: out of seq. seq num %u matches. \
 422 We were expecting seq %u\n", reply_seq_number+i, reply_seq_number ));
 423                                         break;
 424                                 }
 425                         }
 426                 }
 427 #endif /* JRATEST */
 428
 429         } else {
 430                 DEBUG(10, ("client_check_incoming_message: seq %u: got good SMB signature of\n", (unsigned int)reply_seq_number));
 431                 dump_data(10, server_sent_mac, 8);
 432         }
 433         return signing_good(inbuf, si, good, reply_seq_number, must_be_ok);
 434 }
 435
 436 /***********************************************************
 437  SMB signing - Simple implementation - free signing context
 438 ************************************************************/
 439
 440 static void simple_free_signing_context(struct smb_sign_info *si)
 441 {
 442         struct smb_basic_signing_context *data =
 443                 (struct smb_basic_signing_context *)si->signing_context;
 444         struct outstanding_packet_lookup *list;
 445         struct outstanding_packet_lookup *next;
 446
 447         for (list = data->outstanding_packet_list; list; list = next) {
 448                 next = list->next;
 449                 DLIST_REMOVE(data->outstanding_packet_list, list);
 450                 SAFE_FREE(list);
 451         }
 452
 453         data_blob_free(&data->mac_key);
 454
 455         SAFE_FREE(si->signing_context);
 456
 457         return;
 458 }
 459
 460 /***********************************************************
 461  SMB signing - Simple implementation - setup the MAC key.
 462 ************************************************************/
 463
 464 BOOL cli_simple_set_signing(struct cli_state *cli,
 465                             const DATA_BLOB user_session_key,
 466                             const DATA_BLOB response)
 467 {
 468         struct smb_basic_signing_context *data;
 469
 470         if (!user_session_key.length)
 471                 return False;
 472
 473         if (!cli_set_smb_signing_common(cli)) {
 474                 return False;
 475         }
 476
 477         if (!set_smb_signing_real_common(&cli->sign_info)) {
 478                 return False;
 479         }
 480
 481         data = SMB_XMALLOC_P(struct smb_basic_signing_context);
 482         memset(data, '\0', sizeof(*data));
 483
 484         cli->sign_info.signing_context = data;
 485
 486         data->mac_key = data_blob(NULL, response.length + user_session_key.length);
 487
 488         memcpy(&data->mac_key.data[0], user_session_key.data, user_session_key.length);
 489
 490         DEBUG(10, ("cli_simple_set_signing: user_session_key\n"));
 491         dump_data(10, user_session_key.data, user_session_key.length);
 492
 493         if (response.length) {
 494                 memcpy(&data->mac_key.data[user_session_key.length],response.data, response.length);
 495                 DEBUG(10, ("cli_simple_set_signing: response_data\n"));
 496                 dump_data(10, response.data, response.length);
 497         } else {
 498                 DEBUG(10, ("cli_simple_set_signing: NULL response_data\n"));
 499         }
 500
 501         dump_data_pw("MAC ssession key is:\n", data->mac_key.data, data->mac_key.length);
 502
 503         /* Initialise the sequence number */
 504         data->send_seq_num = 0;
 505
 506         /* Initialise the list of outstanding packets */
 507         data->outstanding_packet_list = NULL;
 508
 509         cli->sign_info.sign_outgoing_message = client_sign_outgoing_message;
 510         cli->sign_info.check_incoming_message = client_check_incoming_message;
 511         cli->sign_info.free_signing_context = simple_free_signing_context;
 512
 513         return True;
 514 }
 515
 516 /***********************************************************
 517  SMB signing - TEMP implementation - calculate a MAC to send.
 518 ************************************************************/
 519
 520 static void temp_sign_outgoing_message(char *outbuf, struct smb_sign_info *si)
 521 {
 522         /* mark the packet as signed - BEFORE we sign it...*/
 523         mark_packet_signed(outbuf);
 524
 525         /* I wonder what BSRSPYL stands for - but this is what MS
 526            actually sends! */
 527         memcpy(&outbuf[smb_ss_field], "BSRSPYL ", 8);
 528         return;
 529 }
 530
 531 /***********************************************************
 532  SMB signing - TEMP implementation - check a MAC sent by server.
 533 ************************************************************/
 534
 535 static BOOL temp_check_incoming_message(char *inbuf, struct smb_sign_info *si, BOOL foo)
 536 {
 537         return True;
 538 }
 539
 540 /***********************************************************
 541  SMB signing - TEMP implementation - free signing context
 542 ************************************************************/
 543
 544 static void temp_free_signing_context(struct smb_sign_info *si)
 545 {
 546         return;
 547 }
 548
 549 /***********************************************************
 550  SMB signing - NULL implementation - setup the MAC key.
 551 ************************************************************/
 552
 553 BOOL cli_null_set_signing(struct cli_state *cli)
 554 {
 555         return null_set_signing(&cli->sign_info);
 556 }
 557
 558 /***********************************************************
 559  SMB signing - temp implementation - setup the MAC key.
 560 ************************************************************/
 561
 562 BOOL cli_temp_set_signing(struct cli_state *cli)
 563 {
 564         if (!cli_set_smb_signing_common(cli)) {
 565                 return False;
 566         }
 567
 568         cli->sign_info.signing_context = NULL;
 569
 570         cli->sign_info.sign_outgoing_message = temp_sign_outgoing_message;
 571         cli->sign_info.check_incoming_message = temp_check_incoming_message;
 572         cli->sign_info.free_signing_context = temp_free_signing_context;
 573
 574         return True;
 575 }
 576
 577 void cli_free_signing_context(struct cli_state *cli)
 578 {
 579         free_signing_context(&cli->sign_info);
 580 }
 581
 582 /**
 583  * Sign a packet with the current mechanism
 584  */
 585
 586 void cli_calculate_sign_mac(struct cli_state *cli)
 587 {
 588         cli->sign_info.sign_outgoing_message(cli->outbuf, &cli->sign_info);
 589 }
 590
 591 /**
 592  * Check a packet with the current mechanism
 593  * @return False if we had an established signing connection
 594  *         which had a bad checksum, True otherwise.
 595  */
 596
 597 BOOL cli_check_sign_mac(struct cli_state *cli)
 598 {
 599         if (!cli->sign_info.check_incoming_message(cli->inbuf, &cli->sign_info, True)) {
 600                 free_signing_context(&cli->sign_info);
 601                 return False;
 602         }
 603         return True;
 604 }
 605
 606 /***********************************************************
 607  Enter trans/trans2/nttrans state.
 608 ************************************************************/
 609
 610 BOOL client_set_trans_sign_state_on(struct cli_state *cli, uint16 mid)
 611 {
 612         struct smb_sign_info *si = &cli->sign_info;
 613         struct smb_basic_signing_context *data = (struct smb_basic_signing_context *)si->signing_context;
 614
 615         if (!si->doing_signing) {
 616                 return True;
 617         }
 618
 619         if (!data) {
 620                 return False;
 621         }
 622
 623         if (!set_sequence_can_delete_flag(&data->outstanding_packet_list, mid, False)) {
 624                 return False;
 625         }
 626
 627         return True;
 628 }
 629
 630 /***********************************************************
 631  Leave trans/trans2/nttrans state.
 632 ************************************************************/
 633
 634 BOOL client_set_trans_sign_state_off(struct cli_state *cli, uint16 mid)
 635 {
 636         uint32 reply_seq_num;
 637         struct smb_sign_info *si = &cli->sign_info;
 638         struct smb_basic_signing_context *data = (struct smb_basic_signing_context *)si->signing_context;
 639
 640         if (!si->doing_signing) {
 641                 return True;
 642         }
 643
 644         if (!data) {
 645                 return False;
 646         }
 647
 648         if (!set_sequence_can_delete_flag(&data->outstanding_packet_list, mid, True)) {
 649                 return False;
 650         }
 651
 652         /* Now delete the stored mid entry. */
 653         if (!get_sequence_for_reply(&data->outstanding_packet_list, mid, &reply_seq_num)) {
 654                 return False;
 655         }
 656
 657         return True;
 658 }
 659
 660 /***********************************************************
 661  Is client signing on ?
 662 ************************************************************/
 663
 664 BOOL client_is_signing_on(struct cli_state *cli)
 665 {
 666         struct smb_sign_info *si = &cli->sign_info;
 667         return si->doing_signing;
 668 }
 669
 670 /***********************************************************
 671  SMB signing - Server implementation - send the MAC.
 672 ************************************************************/
 673
 674 static void srv_sign_outgoing_message(char *outbuf, struct smb_sign_info *si)
 675 {
 676         unsigned char calc_md5_mac[16];
 677         struct smb_basic_signing_context *data =
 678                 (struct smb_basic_signing_context *)si->signing_context;
 679         uint32 send_seq_number = data->send_seq_num-1;
 680         uint16 mid;
 681
 682         if (!si->doing_signing) {
 683                 return;
 684         }
 685
 686         /* JRA Paranioa test - we should be able to get rid of this... */
 687         if (smb_len(outbuf) < (smb_ss_field + 8 - 4)) {
 688                 DEBUG(1, ("srv_sign_outgoing_message: Logic error. Can't send signature on short packet! smb_len = %u\n",
 689                                         smb_len(outbuf) ));
 690                 abort();
 691         }
 692
 693         /* mark the packet as signed - BEFORE we sign it...*/
 694         mark_packet_signed(outbuf);
 695
 696         mid = SVAL(outbuf, smb_mid);
 697
 698         /* See if this is a reply for a deferred packet. */
 699         get_sequence_for_reply(&data->outstanding_packet_list, mid, &send_seq_number);
 700
 701         simple_packet_signature(data, (const unsigned char *)outbuf, send_seq_number, calc_md5_mac);
 702
 703         DEBUG(10, ("srv_sign_outgoing_message: seq %u: sent SMB signature of\n", (unsigned int)send_seq_number));
 704         dump_data(10, calc_md5_mac, 8);
 705
 706         memcpy(&outbuf[smb_ss_field], calc_md5_mac, 8);
 707
 708 /*      cli->outbuf[smb_ss_field+2]=0;
 709         Uncomment this to test if the remote client actually verifies signatures...*/
 710 }
 711
 712 /***********************************************************
 713  SMB signing - Server implementation - check a MAC sent by server.
 714 ************************************************************/
 715
 716 static BOOL srv_check_incoming_message(char *inbuf, struct smb_sign_info *si, BOOL must_be_ok)
 717 {
 718         BOOL good;
 719         struct smb_basic_signing_context *data =
 720                 (struct smb_basic_signing_context *)si->signing_context;
 721         uint32 reply_seq_number = data->send_seq_num;
 722         uint32 saved_seq;
 723         unsigned char calc_md5_mac[16];
 724         unsigned char *server_sent_mac;
 725
 726         if (!si->doing_signing)
 727                 return True;
 728
 729         if (smb_len(inbuf) < (smb_ss_field + 8 - 4)) {
 730                 DEBUG(1, ("srv_check_incoming_message: Can't check signature on short packet! smb_len = %u\n", smb_len(inbuf)));
 731                 return False;
 732         }
 733
 734         /* We always increment the sequence number. */
 735         data->send_seq_num += 2;
 736
 737         saved_seq = reply_seq_number;
 738         simple_packet_signature(data, (const unsigned char *)inbuf, reply_seq_number, calc_md5_mac);
 739
 740         server_sent_mac = (unsigned char *)&inbuf[smb_ss_field];
 741         good = (memcmp(server_sent_mac, calc_md5_mac, 8) == 0);
 742
 743         if (!good) {
 744
 745                 if (saved_seq) {
 746                         DEBUG(0, ("srv_check_incoming_message: BAD SIG: seq %u wanted SMB signature of\n",
 747                                         (unsigned int)saved_seq));
 748                         dump_data(5, calc_md5_mac, 8);
 749
 750                         DEBUG(0, ("srv_check_incoming_message: BAD SIG: seq %u got SMB signature of\n",
 751                                                 (unsigned int)reply_seq_number));
 752                         dump_data(5, server_sent_mac, 8);
 753                 }
 754
 755 #if 1 /* JRATEST */
 756                 {
 757                         int i;
 758                         reply_seq_number -= 5;
 759                         for (i = 0; i < 10; i++, reply_seq_number++) {
 760                                 simple_packet_signature(data, (const unsigned char *)inbuf, reply_seq_number, calc_md5_mac);
 761                                 if (memcmp(server_sent_mac, calc_md5_mac, 8) == 0) {
 762                                         DEBUG(0,("srv_check_incoming_message: out of seq. seq num %u matches. \
 763 We were expecting seq %u\n", reply_seq_number, saved_seq ));
 764                                         break;
 765                                 }
 766                         }
 767                 }
 768 #endif /* JRATEST */
 769
 770         } else {
 771                 DEBUG(10, ("srv_check_incoming_message: seq %u: (current is %u) got good SMB signature of\n", (unsigned int)reply_seq_number, (unsigned int)data->send_seq_num));
 772                 dump_data(10, server_sent_mac, 8);
 773         }
 774
 775         return (signing_good(inbuf, si, good, saved_seq, must_be_ok));
 776 }
 777
 778 /***********************************************************
 779  SMB signing - server API's.
 780 ************************************************************/
 781
 782 static struct smb_sign_info srv_sign_info = {
 783         null_sign_outgoing_message,
 784         null_check_incoming_message,
 785         null_free_signing_context,
 786         NULL,
 787         False,
 788         False,
 789         False,
 790         False
 791 };
 792
 793 /***********************************************************
 794  Turn signing off or on for oplock break code.
 795 ************************************************************/
 796
 797 BOOL srv_oplock_set_signing(BOOL onoff)
 798 {
 799         BOOL ret = srv_sign_info.doing_signing;
 800         srv_sign_info.doing_signing = onoff;
 801         return ret;
 802 }
 803
 804 /***********************************************************
 805  Called to validate an incoming packet from the client.
 806 ************************************************************/
 807
 808 BOOL srv_check_sign_mac(char *inbuf, BOOL must_be_ok)
 809 {
 810         /* Check if it's a session keepalive. */
 811         if(CVAL(inbuf,0) == SMBkeepalive) {
 812                 return True;
 813         }
 814
 815         return srv_sign_info.check_incoming_message(inbuf, &srv_sign_info, must_be_ok);
 816 }
 817
 818 /***********************************************************
 819  Called to sign an outgoing packet to the client.
 820 ************************************************************/
 821
 822 void srv_calculate_sign_mac(char *outbuf)
 823 {
 824         /* Check if it's a session keepalive. */
 825         if(CVAL(outbuf,0) == SMBkeepalive) {
 826                 return;
 827         }
 828
 829         srv_sign_info.sign_outgoing_message(outbuf, &srv_sign_info);
 830 }
 831
 832 /***********************************************************
 833  Called by server to defer an outgoing packet.
 834 ************************************************************/
 835
 836 void srv_defer_sign_response(uint16 mid)
 837 {
 838         struct smb_basic_signing_context *data;
 839
 840         if (!srv_sign_info.doing_signing)
 841                 return;
 842
 843         data = (struct smb_basic_signing_context *)srv_sign_info.signing_context;
 844
 845         if (!data)
 846                 return;
 847
 848         /*
 849          * Ensure we only store this mid reply once...
 850          */
 851
 852         store_sequence_for_reply(&data->outstanding_packet_list, mid,
 853                                  data->send_seq_num-1);
 854 }
 855
 856 /***********************************************************
 857  Called to remove sequence records when a deferred packet is
 858  cancelled by mid. This should never find one....
 859 ************************************************************/
 860
 861 void srv_cancel_sign_response(uint16 mid)
 862 {
 863         struct smb_basic_signing_context *data;
 864         uint32 dummy_seq;
 865
 866         if (!srv_sign_info.doing_signing)
 867                 return;
 868
 869         data = (struct smb_basic_signing_context *)srv_sign_info.signing_context;
 870
 871         if (!data)
 872                 return;
 873
 874         DEBUG(10,("srv_cancel_sign_response: for mid %u\n", (unsigned int)mid ));
 875
 876         while (get_sequence_for_reply(&data->outstanding_packet_list, mid, &dummy_seq))
 877                 ;
 878
 879         /* cancel doesn't send a reply so doesn't burn a sequence number. */
 880         data->send_seq_num -= 1;
 881 }
 882
 883 /***********************************************************
 884  Called by server negprot when signing has been negotiated.
 885 ************************************************************/
 886
 887 void srv_set_signing_negotiated(void)
 888 {
 889         srv_sign_info.allow_smb_signing = True;
 890         srv_sign_info.negotiated_smb_signing = True;
 891         if (lp_server_signing() == Required)
 892                 srv_sign_info.mandatory_signing = True;
 893
 894         srv_sign_info.sign_outgoing_message = temp_sign_outgoing_message;
 895         srv_sign_info.check_incoming_message = temp_check_incoming_message;
 896         srv_sign_info.free_signing_context = temp_free_signing_context;
 897 }
 898
 899 /***********************************************************
 900  Returns whether signing is active. We can't use sendfile or raw
 901  reads/writes if it is.
 902 ************************************************************/
 903
 904 BOOL srv_is_signing_active(void)
 905 {
 906         return srv_sign_info.doing_signing;
 907 }
 908
 909
 910 /***********************************************************
 911  Returns whether signing is negotiated. We can't use it unless it was
 912  in the negprot.
 913 ************************************************************/
 914
 915 BOOL srv_is_signing_negotiated(void)
 916 {
 917         return srv_sign_info.negotiated_smb_signing;
 918 }
 919
 920 /***********************************************************
 921  Returns whether signing is actually happening
 922 ************************************************************/
 923
 924 BOOL srv_signing_started(void)
 925 {
 926         struct smb_basic_signing_context *data;
 927
 928         if (!srv_sign_info.doing_signing) {
 929                 return False;
 930         }
 931
 932         data = (struct smb_basic_signing_context *)srv_sign_info.signing_context;
 933         if (!data)
 934                 return False;
 935
 936         if (data->send_seq_num == 0) {
 937                 return False;
 938         }
 939
 940         return True;
 941 }
 942
 943 /***********************************************************
 944  Turn on signing from this packet onwards.
 945 ************************************************************/
 946
 947 void srv_set_signing(const DATA_BLOB user_session_key, const DATA_BLOB response)
 948 {
 949         struct smb_basic_signing_context *data;
 950
 951         if (!user_session_key.length)
 952                 return;
 953
 954         if (!srv_sign_info.negotiated_smb_signing && !srv_sign_info.mandatory_signing) {
 955                 DEBUG(5,("srv_set_signing: signing negotiated = %u, mandatory_signing = %u. Not allowing smb signing.\n",
 956                         (unsigned int)srv_sign_info.negotiated_smb_signing,
 957                         (unsigned int)srv_sign_info.mandatory_signing ));
 958                 return;
 959         }
 960
 961         /* Once we've turned on, ignore any more sessionsetups. */
 962         if (srv_sign_info.doing_signing) {
 963                 return;
 964         }
 965
 966         if (srv_sign_info.free_signing_context)
 967                 srv_sign_info.free_signing_context(&srv_sign_info);
 968
 969         srv_sign_info.doing_signing = True;
 970
 971         data = SMB_XMALLOC_P(struct smb_basic_signing_context);
 972         memset(data, '\0', sizeof(*data));
 973
 974         srv_sign_info.signing_context = data;
 975
 976         data->mac_key = data_blob(NULL, response.length + user_session_key.length);
 977
 978         memcpy(&data->mac_key.data[0], user_session_key.data, user_session_key.length);
 979         if (response.length)
 980                 memcpy(&data->mac_key.data[user_session_key.length],response.data, response.length);
 981
 982         dump_data_pw("MAC ssession key is:\n", data->mac_key.data, data->mac_key.length);
 983
 984         DEBUG(3,("srv_set_signing: turning on SMB signing: signing negotiated = %s, mandatory_signing = %s.\n",
 985                                 BOOLSTR(srv_sign_info.negotiated_smb_signing),
 986                                 BOOLSTR(srv_sign_info.mandatory_signing) ));
 987
 988         /* Initialise the sequence number */
 989         data->send_seq_num = 0;
 990
 991         /* Initialise the list of outstanding packets */
 992         data->outstanding_packet_list = NULL;
 993
 994         srv_sign_info.sign_outgoing_message = srv_sign_outgoing_message;
 995         srv_sign_info.check_incoming_message = srv_check_incoming_message;
 996         srv_sign_info.free_signing_context = simple_free_signing_context;
 997 }