source3/libsmb/smb_seal.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    SMB Transport encryption (sealing) code.
   4    Copyright (C) Jeremy Allison 2007.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 #include "includes.h"
  22
  23 /******************************************************************************
  24  Pull out the encryption context for this packet. 0 means global context.
  25 ******************************************************************************/
  26
  27 NTSTATUS get_enc_ctx_num(char *buf, uint16 *p_enc_ctx_num)
  28 {
  29         if (smb_len(buf) < 8) {
  30                 return NT_STATUS_INVALID_BUFFER_SIZE;
  31         }
  32
  33         if (buf[4] == (char)0xFF) {
  34                 if (buf[5] == 'S' && buf [6] == 'M' && buf[7] == 'B') {
  35                         /* Not an encrypted buffer. */
  36                         return NT_STATUS_NOT_FOUND;
  37                 }
  38                 if (buf[5] == 'E') {
  39                         *p_enc_ctx_num = SVAL(buf,6);
  40                         return NT_STATUS_OK;
  41                 }
  42         }
  43         return NT_STATUS_INVALID_NETWORK_RESPONSE;
  44 }
  45
  46 /******************************************************************************
  47  Generic code for client and server.
  48  Is encryption turned on ?
  49 ******************************************************************************/
  50
  51 BOOL common_encryption_on(struct smb_trans_enc_state *es)
  52 {
  53         return ((es != NULL) && es->enc_on);
  54 }
  55
  56 /******************************************************************************
  57  Generic code for client and server.
  58  NTLM decrypt an incoming buffer.
  59  Abartlett tells me that SSPI puts the signature first before the encrypted
  60  output, so cope with the same for compatibility.
  61 ******************************************************************************/
  62
  63 NTSTATUS common_ntlm_decrypt_buffer(NTLMSSP_STATE *ntlmssp_state, char *buf)
  64 {
  65         NTSTATUS status;
  66         size_t buf_len = smb_len(buf) + 4; /* Don't forget the 4 length bytes. */
  67         size_t data_len;
  68         char *inbuf;
  69         DATA_BLOB sig;
  70
  71         if (buf_len < 8 + NTLMSSP_SIG_SIZE) {
  72                 return NT_STATUS_BUFFER_TOO_SMALL;
  73         }
  74
  75         inbuf = smb_xmemdup(buf, buf_len);
  76
  77         /* Adjust for the signature. */
  78         data_len = buf_len - 8 - NTLMSSP_SIG_SIZE;
  79
  80         /* Point at the signature. */
  81         sig = data_blob_const(inbuf+8, NTLMSSP_SIG_SIZE);
  82
  83         status = ntlmssp_unseal_packet(ntlmssp_state,
  84                 (unsigned char *)inbuf + 8 + NTLMSSP_SIG_SIZE, /* 4 byte len + 0xFF 'E' <enc> <ctx> */
  85                 data_len,
  86                 (unsigned char *)inbuf + 8 + NTLMSSP_SIG_SIZE,
  87                 data_len,
  88                 &sig);
  89
  90         if (!NT_STATUS_IS_OK(status)) {
  91                 SAFE_FREE(inbuf);
  92                 return status;
  93         }
  94
  95         memcpy(buf + 8, inbuf + 8 + NTLMSSP_SIG_SIZE, data_len);
  96         SAFE_FREE(inbuf);
  97
  98         /* Reset the length. */
  99         smb_setlen(buf, data_len + 4);
 100         return NT_STATUS_OK;
 101 }
 102
 103 /******************************************************************************
 104  Generic code for client and server.
 105  NTLM encrypt an outgoing buffer. Return the encrypted pointer in ppbuf_out.
 106  Abartlett tells me that SSPI puts the signature first before the encrypted
 107  output, so do the same for compatibility.
 108 ******************************************************************************/
 109
 110 NTSTATUS common_ntlm_encrypt_buffer(NTLMSSP_STATE *ntlmssp_state,
 111                                 uint16 enc_ctx_num,
 112                                 char *buf,
 113                                 char **ppbuf_out)
 114 {
 115         NTSTATUS status;
 116         char *buf_out;
 117         size_t data_len = smb_len(buf) - 4; /* Ignore the 0xFF SMB bytes. */
 118         DATA_BLOB sig;
 119
 120         *ppbuf_out = NULL;
 121
 122         if (data_len == 0) {
 123                 return NT_STATUS_BUFFER_TOO_SMALL;
 124         }
 125
 126         /*
 127          * We know smb_len can't return a value > 128k, so no int overflow
 128          * check needed.
 129          */
 130
 131         buf_out = SMB_XMALLOC_ARRAY(char, 8 + NTLMSSP_SIG_SIZE + data_len);
 132
 133         /* Copy the data from the original buffer. */
 134
 135         memcpy(buf_out + 8 + NTLMSSP_SIG_SIZE, buf + 8, data_len);
 136
 137         smb_set_enclen(buf_out, smb_len(buf) + NTLMSSP_SIG_SIZE, enc_ctx_num);
 138
 139         sig = data_blob(NULL, NTLMSSP_SIG_SIZE);
 140
 141         status = ntlmssp_seal_packet(ntlmssp_state,
 142                 (unsigned char *)buf_out + 8 + NTLMSSP_SIG_SIZE, /* 4 byte len + 0xFF 'S' <enc> <ctx> */
 143                 data_len,
 144                 (unsigned char *)buf_out + 8 + NTLMSSP_SIG_SIZE,
 145                 data_len,
 146                 &sig);
 147
 148         if (!NT_STATUS_IS_OK(status)) {
 149                 data_blob_free(&sig);
 150                 SAFE_FREE(buf_out);
 151                 return status;
 152         }
 153
 154         /* First 16 data bytes are signature for SSPI compatibility. */
 155         memcpy(buf_out + 8, sig.data, NTLMSSP_SIG_SIZE);
 156         *ppbuf_out = buf_out;
 157         return NT_STATUS_OK;
 158 }
 159
 160 /******************************************************************************
 161  Generic code for client and server.
 162  gss-api decrypt an incoming buffer. We insist that the size of the
 163  unwrapped buffer must be smaller or identical to the incoming buffer.
 164 ******************************************************************************/
 165
 166 #if defined(HAVE_GSSAPI) && defined(HAVE_KRB5)
 167 static NTSTATUS common_gss_decrypt_buffer(struct smb_tran_enc_state_gss *gss_state, char *buf)
 168 {
 169         gss_ctx_id_t gss_ctx = gss_state->gss_ctx;
 170         OM_uint32 ret = 0;
 171         OM_uint32 minor = 0;
 172         int flags_got = 0;
 173         gss_buffer_desc in_buf, out_buf;
 174         size_t buf_len = smb_len(buf) + 4; /* Don't forget the 4 length bytes. */
 175
 176         if (buf_len < 8) {
 177                 return NT_STATUS_BUFFER_TOO_SMALL;
 178         }
 179
 180         in_buf.value = buf + 8;
 181         in_buf.length = buf_len - 8;
 182
 183         ret = gss_unwrap(&minor,
 184                         gss_ctx,
 185                         &in_buf,
 186                         &out_buf,
 187                         &flags_got,             /* did we get sign+seal ? */
 188                         (gss_qop_t *) NULL);
 189
 190         if (ret != GSS_S_COMPLETE) {
 191                 ADS_STATUS adss = ADS_ERROR_GSS(ret, minor);
 192                 DEBUG(0,("common_gss_encrypt_buffer: gss_unwrap failed. Error %s\n",
 193                         ads_errstr(adss) ));
 194                 /* Um - no mapping for gss-errs to NTSTATUS yet. */
 195                 return ads_ntstatus(adss);
 196         }
 197
 198         if (out_buf.length > in_buf.length) {
 199                 DEBUG(0,("common_gss_encrypt_buffer: gss_unwrap size (%u) too large (%u) !\n",
 200                         (unsigned int)out_buf.length,
 201                         (unsigned int)in_buf.length ));
 202                 gss_release_buffer(&minor, &out_buf);
 203                 return NT_STATUS_INVALID_PARAMETER;
 204         }
 205
 206         memcpy(buf + 8, out_buf.value, out_buf.length);
 207         smb_setlen(buf, out_buf.length + 4);
 208
 209         gss_release_buffer(&minor, &out_buf);
 210         return NT_STATUS_OK;
 211 }
 212
 213 /******************************************************************************
 214  Generic code for client and server.
 215  gss-api encrypt an outgoing buffer. Return the alloced encrypted pointer in buf_out.
 216 ******************************************************************************/
 217
 218 static NTSTATUS common_gss_encrypt_buffer(struct smb_tran_enc_state_gss *gss_state,
 219                                         uint16 enc_ctx_num,
 220                                         char *buf,
 221                                         char **ppbuf_out)
 222 {
 223         gss_ctx_id_t gss_ctx = gss_state->gss_ctx;
 224         OM_uint32 ret = 0;
 225         OM_uint32 minor = 0;
 226         int flags_got = 0;
 227         gss_buffer_desc in_buf, out_buf;
 228         size_t buf_len = smb_len(buf) + 4; /* Don't forget the 4 length bytes. */
 229
 230         *ppbuf_out = NULL;
 231
 232         if (buf_len < 8) {
 233                 return NT_STATUS_BUFFER_TOO_SMALL;
 234         }
 235
 236         in_buf.value = buf + 8;
 237         in_buf.length = buf_len - 8;
 238
 239         ret = gss_wrap(&minor,
 240                         gss_ctx,
 241                         True,                   /* we want sign+seal. */
 242                         GSS_C_QOP_DEFAULT,
 243                         &in_buf,
 244                         &flags_got,             /* did we get sign+seal ? */
 245                         &out_buf);
 246
 247         if (ret != GSS_S_COMPLETE) {
 248                 ADS_STATUS adss = ADS_ERROR_GSS(ret, minor);
 249                 DEBUG(0,("common_gss_encrypt_buffer: gss_wrap failed. Error %s\n",
 250                         ads_errstr(adss) ));
 251                 /* Um - no mapping for gss-errs to NTSTATUS yet. */
 252                 return ads_ntstatus(adss);
 253         }
 254
 255         if (!flags_got) {
 256                 /* Sign+seal not supported. */
 257                 gss_release_buffer(&minor, &out_buf);
 258                 return NT_STATUS_NOT_SUPPORTED;
 259         }
 260
 261         /* Ya see - this is why I *hate* gss-api. I don't
 262          * want to have to malloc another buffer of the
 263          * same size + 8 bytes just to get a continuous
 264          * header + buffer, but gss won't let me pass in
 265          * a pre-allocated buffer. Bastards (and you know
 266          * who you are....). I might fix this by
 267          * going to "encrypt_and_send" passing in a file
 268          * descriptor and doing scatter-gather write with
 269          * TCP cork on Linux. But I shouldn't have to
 270          * bother :-*(. JRA.
 271          */
 272
 273         *ppbuf_out = SMB_MALLOC(out_buf.length + 8); /* We know this can't wrap. */
 274         if (!*ppbuf_out) {
 275                 gss_release_buffer(&minor, &out_buf);
 276                 return NT_STATUS_NO_MEMORY;
 277         }
 278
 279         memcpy(*ppbuf_out+8, out_buf.value, out_buf.length);
 280         smb_set_enclen(*ppbuf_out, out_buf.length + 4, enc_ctx_num);
 281
 282         gss_release_buffer(&minor, &out_buf);
 283         return NT_STATUS_OK;
 284 }
 285 #endif
 286
 287 /******************************************************************************
 288  Generic code for client and server.
 289  Encrypt an outgoing buffer. Return the alloced encrypted pointer in buf_out.
 290 ******************************************************************************/
 291
 292 NTSTATUS common_encrypt_buffer(struct smb_trans_enc_state *es, char *buffer, char **buf_out)
 293 {
 294         if (!common_encryption_on(es)) {
 295                 /* Not encrypting. */
 296                 *buf_out = buffer;
 297                 return NT_STATUS_OK;
 298         }
 299
 300         switch (es->smb_enc_type) {
 301                 case SMB_TRANS_ENC_NTLM:
 302                         return common_ntlm_encrypt_buffer(es->s.ntlmssp_state, es->enc_ctx_num, buffer, buf_out);
 303 #if defined(HAVE_GSSAPI) && defined(HAVE_KRB5)
 304                 case SMB_TRANS_ENC_GSS:
 305                         return common_gss_encrypt_buffer(es->s.gss_state, es->enc_ctx_num, buffer, buf_out);
 306 #endif
 307                 default:
 308                         return NT_STATUS_NOT_SUPPORTED;
 309         }
 310 }
 311
 312 /******************************************************************************
 313  Generic code for client and server.
 314  Decrypt an incoming SMB buffer. Replaces the data within it.
 315  New data must be less than or equal to the current length.
 316 ******************************************************************************/
 317
 318 NTSTATUS common_decrypt_buffer(struct smb_trans_enc_state *es, char *buf)
 319 {
 320         if (!common_encryption_on(es)) {
 321                 /* Not decrypting. */
 322                 return NT_STATUS_OK;
 323         }
 324
 325         switch (es->smb_enc_type) {
 326                 case SMB_TRANS_ENC_NTLM:
 327                         return common_ntlm_decrypt_buffer(es->s.ntlmssp_state, buf);
 328 #if defined(HAVE_GSSAPI) && defined(HAVE_KRB5)
 329                 case SMB_TRANS_ENC_GSS:
 330                         return common_gss_decrypt_buffer(es->s.gss_state, buf);
 331 #endif
 332                 default:
 333                         return NT_STATUS_NOT_SUPPORTED;
 334         }
 335 }
 336
 337 #if defined(HAVE_GSSAPI) && defined(HAVE_KRB5)
 338 /******************************************************************************
 339  Shutdown a gss encryption state.
 340 ******************************************************************************/
 341
 342 static void common_free_gss_state(struct smb_tran_enc_state_gss **pp_gss_state)
 343 {
 344         OM_uint32 minor = 0;
 345         struct smb_tran_enc_state_gss *gss_state = *pp_gss_state;
 346
 347         if (gss_state->creds != GSS_C_NO_CREDENTIAL) {
 348                 gss_release_cred(&minor, &gss_state->creds);
 349         }
 350         if (gss_state->gss_ctx != GSS_C_NO_CONTEXT) {
 351                 gss_delete_sec_context(&minor, &gss_state->gss_ctx, NULL);
 352         }
 353         SAFE_FREE(*pp_gss_state);
 354 }
 355 #endif
 356
 357 /******************************************************************************
 358  Shutdown an encryption state.
 359 ******************************************************************************/
 360
 361 void common_free_encryption_state(struct smb_trans_enc_state **pp_es)
 362 {
 363         struct smb_trans_enc_state *es = *pp_es;
 364
 365         if (es == NULL) {
 366                 return;
 367         }
 368
 369         if (es->smb_enc_type == SMB_TRANS_ENC_NTLM) {
 370                 if (es->s.ntlmssp_state) {
 371                         ntlmssp_end(&es->s.ntlmssp_state);
 372                 }
 373         }
 374 #if defined(HAVE_GSSAPI) && defined(HAVE_KRB5)
 375         if (es->smb_enc_type == SMB_TRANS_ENC_GSS) {
 376                 /* Free the gss context handle. */
 377                 if (es->s.gss_state) {
 378                         common_free_gss_state(&es->s.gss_state);
 379                 }
 380         }
 381 #endif
 382         SAFE_FREE(es);
 383         *pp_es = NULL;
 384 }
 385
 386 /******************************************************************************
 387  Free an encryption-allocated buffer.
 388 ******************************************************************************/
 389
 390 void common_free_enc_buffer(struct smb_trans_enc_state *es, char *buf)
 391 {
 392         if (!common_encryption_on(es)) {
 393                 return;
 394         }
 395
 396         if (es->smb_enc_type == SMB_TRANS_ENC_NTLM) {
 397                 SAFE_FREE(buf);
 398                 return;
 399         }
 400
 401 #if defined(HAVE_GSSAPI) && defined(HAVE_KRB5)
 402         if (es->smb_enc_type == SMB_TRANS_ENC_GSS) {
 403                 OM_uint32 min;
 404                 gss_buffer_desc rel_buf;
 405                 rel_buf.value = buf;
 406                 rel_buf.length = smb_len(buf) + 4;
 407                 gss_release_buffer(&min, &rel_buf);
 408         }
 409 #endif
 410 }
 411
 412 /******************************************************************************
 413  Client side encryption.
 414 ******************************************************************************/
 415
 416 /******************************************************************************
 417  Is client encryption on ?
 418 ******************************************************************************/
 419
 420 BOOL cli_encryption_on(struct cli_state *cli)
 421 {
 422         /* If we supported multiple encrytion contexts
 423          * here we'd look up based on tid.
 424          */
 425         return common_encryption_on(cli->trans_enc_state);
 426 }
 427
 428 /******************************************************************************
 429  Shutdown a client encryption state.
 430 ******************************************************************************/
 431
 432 void cli_free_encryption_context(struct cli_state *cli)
 433 {
 434         common_free_encryption_state(&cli->trans_enc_state);
 435 }
 436
 437 /******************************************************************************
 438  Free an encryption-allocated buffer.
 439 ******************************************************************************/
 440
 441 void cli_free_enc_buffer(struct cli_state *cli, char *buf)
 442 {
 443         /* We know this is an smb buffer, and we
 444          * didn't malloc, only copy, for a keepalive,
 445          * so ignore session keepalives. */
 446
 447         if(CVAL(buf,0) == SMBkeepalive) {
 448                 return;
 449         }
 450
 451         /* If we supported multiple encrytion contexts
 452          * here we'd look up based on tid.
 453          */
 454         common_free_enc_buffer(cli->trans_enc_state, buf);
 455 }
 456
 457 /******************************************************************************
 458  Decrypt an incoming buffer.
 459 ******************************************************************************/
 460
 461 NTSTATUS cli_decrypt_message(struct cli_state *cli)
 462 {
 463         NTSTATUS status;
 464         uint16 enc_ctx_num;
 465
 466         /* Ignore session keepalives. */
 467         if(CVAL(cli->inbuf,0) == SMBkeepalive) {
 468                 return NT_STATUS_OK;
 469         }
 470
 471         status = get_enc_ctx_num(cli->inbuf, &enc_ctx_num);
 472         if (!NT_STATUS_IS_OK(status)) {
 473                 return status;
 474         }
 475
 476         if (enc_ctx_num != cli->trans_enc_state->enc_ctx_num) {
 477                 return NT_STATUS_INVALID_HANDLE;
 478         }
 479
 480         return common_decrypt_buffer(cli->trans_enc_state, cli->inbuf);
 481 }
 482
 483 /******************************************************************************
 484  Encrypt an outgoing buffer. Return the encrypted pointer in buf_out.
 485 ******************************************************************************/
 486
 487 NTSTATUS cli_encrypt_message(struct cli_state *cli, char **buf_out)
 488 {
 489         /* Ignore session keepalives. */
 490         if(CVAL(cli->outbuf,0) == SMBkeepalive) {
 491                 return NT_STATUS_OK;
 492         }
 493
 494         /* If we supported multiple encrytion contexts
 495          * here we'd look up based on tid.
 496          */
 497         return common_encrypt_buffer(cli->trans_enc_state, cli->outbuf, buf_out);
 498 }