795c8bc14ca7984ec50bef5f97ad9aab8ac9bb16
[ira/wip.git] / 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 3 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, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "includes.h"
21
22 /******************************************************************************
23  Pull out the encryption context for this packet. 0 means global context.
24 ******************************************************************************/
25
26 NTSTATUS get_enc_ctx_num(const uint8_t *buf, uint16 *p_enc_ctx_num)
27 {
28         if (smb_len(buf) < 8) {
29                 return NT_STATUS_INVALID_BUFFER_SIZE;
30         }
31
32         if (buf[4] == 0xFF) {
33                 if (buf[5] == 'S' && buf [6] == 'M' && buf[7] == 'B') {
34                         /* Not an encrypted buffer. */
35                         return NT_STATUS_NOT_FOUND;
36                 }
37                 if (buf[5] == 'E') {
38                         *p_enc_ctx_num = SVAL(buf,6);
39                         return NT_STATUS_OK;
40                 }
41         }
42         return NT_STATUS_INVALID_NETWORK_RESPONSE;
43 }
44
45 /******************************************************************************
46  Generic code for client and server.
47  Is encryption turned on ?
48 ******************************************************************************/
49
50 bool common_encryption_on(struct smb_trans_enc_state *es)
51 {
52         return ((es != NULL) && es->enc_on);
53 }
54
55 /******************************************************************************
56  Generic code for client and server.
57  NTLM decrypt an incoming buffer.
58  Abartlett tells me that SSPI puts the signature first before the encrypted
59  output, so cope with the same for compatibility.
60 ******************************************************************************/
61
62 NTSTATUS common_ntlm_decrypt_buffer(NTLMSSP_STATE *ntlmssp_state, char *buf)
63 {
64         NTSTATUS status;
65         size_t buf_len = smb_len(buf) + 4; /* Don't forget the 4 length bytes. */
66         size_t data_len;
67         char *inbuf;
68         DATA_BLOB sig;
69
70         if (buf_len < 8 + NTLMSSP_SIG_SIZE) {
71                 return NT_STATUS_BUFFER_TOO_SMALL;
72         }
73
74         inbuf = (char *)smb_xmemdup(buf, buf_len);
75
76         /* Adjust for the signature. */
77         data_len = buf_len - 8 - NTLMSSP_SIG_SIZE;
78
79         /* Point at the signature. */
80         sig = data_blob_const(inbuf+8, NTLMSSP_SIG_SIZE);
81
82         status = ntlmssp_unseal_packet(ntlmssp_state,
83                 (unsigned char *)inbuf + 8 + NTLMSSP_SIG_SIZE, /* 4 byte len + 0xFF 'E' <enc> <ctx> */
84                 data_len,
85                 (unsigned char *)inbuf + 8 + NTLMSSP_SIG_SIZE,
86                 data_len,
87                 &sig);
88
89         if (!NT_STATUS_IS_OK(status)) {
90                 SAFE_FREE(inbuf);
91                 return status;
92         }
93
94         memcpy(buf + 8, inbuf + 8 + NTLMSSP_SIG_SIZE, data_len);
95
96         /* Reset the length and overwrite the header. */
97         smb_setlen(buf,data_len + 4);
98
99         SAFE_FREE(inbuf);
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                 return map_nt_error_from_gss(ret, minor);
195         }
196
197         if (out_buf.length > in_buf.length) {
198                 DEBUG(0,("common_gss_encrypt_buffer: gss_unwrap size (%u) too large (%u) !\n",
199                         (unsigned int)out_buf.length,
200                         (unsigned int)in_buf.length ));
201                 gss_release_buffer(&minor, &out_buf);
202                 return NT_STATUS_INVALID_PARAMETER;
203         }
204
205         memcpy(buf + 8, out_buf.value, out_buf.length);
206         /* Reset the length and overwrite the header. */
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                 return map_nt_error_from_gss(ret, minor);
252         }
253
254         if (!flags_got) {
255                 /* Sign+seal not supported. */
256                 gss_release_buffer(&minor, &out_buf);
257                 return NT_STATUS_NOT_SUPPORTED;
258         }
259
260         /* Ya see - this is why I *hate* gss-api. I don't 
261          * want to have to malloc another buffer of the
262          * same size + 8 bytes just to get a continuous
263          * header + buffer, but gss won't let me pass in
264          * a pre-allocated buffer. Bastards (and you know
265          * who you are....). I might fix this by
266          * going to "encrypt_and_send" passing in a file
267          * descriptor and doing scatter-gather write with
268          * TCP cork on Linux. But I shouldn't have to
269          * bother :-*(. JRA.
270          */
271
272         *ppbuf_out = (char *)SMB_MALLOC(out_buf.length + 8); /* We know this can't wrap. */
273         if (!*ppbuf_out) {
274                 gss_release_buffer(&minor, &out_buf);
275                 return NT_STATUS_NO_MEMORY;
276         }
277
278         memcpy(*ppbuf_out+8, out_buf.value, out_buf.length);
279         smb_set_enclen(*ppbuf_out, out_buf.length + 4, enc_ctx_num);
280
281         gss_release_buffer(&minor, &out_buf);
282         return NT_STATUS_OK;
283 }
284 #endif
285
286 /******************************************************************************
287  Generic code for client and server.
288  Encrypt an outgoing buffer. Return the alloced encrypted pointer in buf_out.
289 ******************************************************************************/
290
291 NTSTATUS common_encrypt_buffer(struct smb_trans_enc_state *es, char *buffer, char **buf_out)
292 {
293         if (!common_encryption_on(es)) {
294                 /* Not encrypting. */
295                 *buf_out = buffer;
296                 return NT_STATUS_OK;
297         }
298
299         switch (es->smb_enc_type) {
300                 case SMB_TRANS_ENC_NTLM:
301                         return common_ntlm_encrypt_buffer(es->s.ntlmssp_state, es->enc_ctx_num, buffer, buf_out);
302 #if defined(HAVE_GSSAPI) && defined(HAVE_KRB5)
303                 case SMB_TRANS_ENC_GSS:
304                         return common_gss_encrypt_buffer(es->s.gss_state, es->enc_ctx_num, buffer, buf_out);
305 #endif
306                 default:
307                         return NT_STATUS_NOT_SUPPORTED;
308         }
309 }
310
311 /******************************************************************************
312  Generic code for client and server.
313  Decrypt an incoming SMB buffer. Replaces the data within it.
314  New data must be less than or equal to the current length.
315 ******************************************************************************/
316
317 NTSTATUS common_decrypt_buffer(struct smb_trans_enc_state *es, char *buf)
318 {
319         if (!common_encryption_on(es)) {
320                 /* Not decrypting. */
321                 return NT_STATUS_OK;
322         }
323
324         switch (es->smb_enc_type) {
325                 case SMB_TRANS_ENC_NTLM:
326                         return common_ntlm_decrypt_buffer(es->s.ntlmssp_state, buf);
327 #if defined(HAVE_GSSAPI) && defined(HAVE_KRB5)
328                 case SMB_TRANS_ENC_GSS:
329                         return common_gss_decrypt_buffer(es->s.gss_state, buf);
330 #endif
331                 default:
332                         return NT_STATUS_NOT_SUPPORTED;
333         }
334 }
335
336 #if defined(HAVE_GSSAPI) && defined(HAVE_KRB5)
337 /******************************************************************************
338  Shutdown a gss encryption state.
339 ******************************************************************************/
340
341 static void common_free_gss_state(struct smb_tran_enc_state_gss **pp_gss_state)
342 {
343         OM_uint32 minor = 0;
344         struct smb_tran_enc_state_gss *gss_state = *pp_gss_state;
345
346         if (gss_state->creds != GSS_C_NO_CREDENTIAL) {
347                 gss_release_cred(&minor, &gss_state->creds);
348         }
349         if (gss_state->gss_ctx != GSS_C_NO_CONTEXT) {
350                 gss_delete_sec_context(&minor, &gss_state->gss_ctx, NULL);
351         }
352         SAFE_FREE(*pp_gss_state);
353 }
354 #endif
355
356 /******************************************************************************
357  Shutdown an encryption state.
358 ******************************************************************************/
359
360 void common_free_encryption_state(struct smb_trans_enc_state **pp_es)
361 {
362         struct smb_trans_enc_state *es = *pp_es;
363
364         if (es == NULL) {
365                 return;
366         }
367
368         if (es->smb_enc_type == SMB_TRANS_ENC_NTLM) {
369                 if (es->s.ntlmssp_state) {
370                         ntlmssp_end(&es->s.ntlmssp_state);
371                 }
372         }
373 #if defined(HAVE_GSSAPI) && defined(HAVE_KRB5)
374         if (es->smb_enc_type == SMB_TRANS_ENC_GSS) {
375                 /* Free the gss context handle. */
376                 if (es->s.gss_state) {
377                         common_free_gss_state(&es->s.gss_state);
378                 }
379         }
380 #endif
381         SAFE_FREE(es);
382         *pp_es = NULL;
383 }
384
385 /******************************************************************************
386  Free an encryption-allocated buffer.
387 ******************************************************************************/
388
389 void common_free_enc_buffer(struct smb_trans_enc_state *es, char *buf)
390 {
391         uint16_t enc_ctx_num;
392
393         if (!common_encryption_on(es)) {
394                 return;
395         }
396
397         if (!NT_STATUS_IS_OK(get_enc_ctx_num((const uint8_t *)buf,
398                         &enc_ctx_num))) {
399                 return;
400         }
401
402         if (es->smb_enc_type == SMB_TRANS_ENC_NTLM) {
403                 SAFE_FREE(buf);
404                 return;
405         }
406
407 #if defined(HAVE_GSSAPI) && defined(HAVE_KRB5)
408         if (es->smb_enc_type == SMB_TRANS_ENC_GSS) {
409                 OM_uint32 min;
410                 gss_buffer_desc rel_buf;
411                 rel_buf.value = buf;
412                 rel_buf.length = smb_len(buf) + 4;
413                 gss_release_buffer(&min, &rel_buf);
414         }
415 #endif
416 }
417
418 /******************************************************************************
419  Client side encryption.
420 ******************************************************************************/
421
422 /******************************************************************************
423  Is client encryption on ?
424 ******************************************************************************/
425
426 bool cli_encryption_on(struct cli_state *cli)
427 {
428         /* If we supported multiple encrytion contexts
429          * here we'd look up based on tid.
430          */
431         return common_encryption_on(cli->trans_enc_state);
432 }
433
434 /******************************************************************************
435  Shutdown a client encryption state.
436 ******************************************************************************/
437
438 void cli_free_encryption_context(struct cli_state *cli)
439 {
440         common_free_encryption_state(&cli->trans_enc_state);
441 }
442
443 /******************************************************************************
444  Free an encryption-allocated buffer.
445 ******************************************************************************/
446
447 void cli_free_enc_buffer(struct cli_state *cli, char *buf)
448 {
449         /* We know this is an smb buffer, and we
450          * didn't malloc, only copy, for a keepalive,
451          * so ignore non-session messages. */
452
453         if(CVAL(buf,0)) {
454                 return;
455         }
456
457         /* If we supported multiple encrytion contexts
458          * here we'd look up based on tid.
459          */
460         common_free_enc_buffer(cli->trans_enc_state, buf);
461 }
462
463 /******************************************************************************
464  Decrypt an incoming buffer.
465 ******************************************************************************/
466
467 NTSTATUS cli_decrypt_message(struct cli_state *cli)
468 {
469         NTSTATUS status;
470         uint16 enc_ctx_num;
471
472         /* Ignore non-session messages. */
473         if(CVAL(cli->inbuf,0)) {
474                 return NT_STATUS_OK;
475         }
476
477         status = get_enc_ctx_num((const uint8_t *)cli->inbuf, &enc_ctx_num);
478         if (!NT_STATUS_IS_OK(status)) {
479                 return status;
480         }
481
482         if (enc_ctx_num != cli->trans_enc_state->enc_ctx_num) {
483                 return NT_STATUS_INVALID_HANDLE;
484         }
485
486         return common_decrypt_buffer(cli->trans_enc_state, cli->inbuf);
487 }
488
489 /******************************************************************************
490  Encrypt an outgoing buffer. Return the encrypted pointer in buf_out.
491 ******************************************************************************/
492
493 NTSTATUS cli_encrypt_message(struct cli_state *cli, char *buf, char **buf_out)
494 {
495         /* Ignore non-session messages. */
496         if (CVAL(buf,0)) {
497                 return NT_STATUS_OK;
498         }
499
500         /* If we supported multiple encrytion contexts
501          * here we'd look up based on tid.
502          */
503         return common_encrypt_buffer(cli->trans_enc_state, buf, buf_out);
504 }