2 Unix SMB/CIFS implementation.
4 Copyright (C) Jeremy Allison 2003.
5 Copyright (C) Andrew Bartlett <abartlet@samba.org> 2002-2003
6 Copyright (C) Stefan Metzmacher 2009
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 #include "../lib/crypto/md5.h"
24 #include "smb_signing.h"
26 /* Used by the SMB signing functions. */
28 struct smb_signing_state {
29 /* is signing localy allowed */
32 /* is signing localy mandatory */
35 /* is signing negotiated by the peer */
38 /* send BSRSPYL signatures */
41 bool active; /* Have I ever seen a validly signed packet? */
43 /* mac_key.length > 0 means signing is started */
46 /* the next expected seqnum */
50 void *(*alloc_fn)(TALLOC_CTX *mem_ctx, size_t len);
51 void (*free_fn)(TALLOC_CTX *mem_ctx, void *ptr);
54 static void smb_signing_reset_info(struct smb_signing_state *si)
61 si->free_fn(si->mem_ctx, si->mac_key.data);
63 talloc_free(si->mac_key.data);
65 si->mac_key.data = NULL;
66 si->mac_key.length = 0;
69 struct smb_signing_state *smb_signing_init_ex(TALLOC_CTX *mem_ctx,
72 void *(*alloc_fn)(TALLOC_CTX *, size_t),
73 void (*free_fn)(TALLOC_CTX *, void *))
75 struct smb_signing_state *si;
78 void *p = alloc_fn(mem_ctx, sizeof(struct smb_signing_state));
82 memset(p, 0, sizeof(struct smb_signing_state));
83 si = (struct smb_signing_state *)p;
84 si->mem_ctx = mem_ctx;
85 si->alloc_fn = alloc_fn;
86 si->free_fn = free_fn;
88 si = talloc_zero(mem_ctx, struct smb_signing_state);
98 si->allowed = allowed;
99 si->mandatory = mandatory;
104 struct smb_signing_state *smb_signing_init(TALLOC_CTX *mem_ctx,
108 return smb_signing_init_ex(mem_ctx, allowed, mandatory, NULL, NULL);
111 static bool smb_signing_good(struct smb_signing_state *si,
112 bool good, uint32_t seq)
121 if (!si->mandatory && !si->active) {
122 /* Non-mandatory signing - just turn off if this is the first bad packet.. */
123 DEBUG(5, ("smb_signing_good: signing negotiated but not required and peer\n"
124 "isn't sending correct signatures. Turning off.\n"));
125 smb_signing_reset_info(si);
129 /* Mandatory signing or bad packet after signing started - fail and disconnect. */
130 DEBUG(0, ("smb_signing_good: BAD SIG: seq %u\n", (unsigned int)seq));
134 static void smb_signing_md5(const DATA_BLOB *mac_key,
135 const uint8_t *buf, uint32_t seq_number,
136 uint8_t calc_md5_mac[16])
138 const size_t offset_end_of_sig = (smb_ss_field + 8);
139 uint8_t sequence_buf[8];
140 struct MD5Context md5_ctx;
143 * Firstly put the sequence number into the first 4 bytes.
144 * and zero out the next 4 bytes.
146 * We do this here, to avoid modifying the packet.
149 DEBUG(10,("smb_signing_md5: sequence number %u\n", seq_number ));
151 SIVAL(sequence_buf, 0, seq_number);
152 SIVAL(sequence_buf, 4, 0);
154 /* Calculate the 16 byte MAC - but don't alter the data in the
157 This makes for a bit of fussing about, but it's not too bad.
161 /* intialise with the key */
162 MD5Update(&md5_ctx, mac_key->data, mac_key->length);
164 /* copy in the first bit of the SMB header */
165 MD5Update(&md5_ctx, buf + 4, smb_ss_field - 4);
167 /* copy in the sequence number, instead of the signature */
168 MD5Update(&md5_ctx, sequence_buf, sizeof(sequence_buf));
170 /* copy in the rest of the packet in, skipping the signature */
171 MD5Update(&md5_ctx, buf + offset_end_of_sig,
172 smb_len(buf) - (offset_end_of_sig - 4));
174 /* calculate the MD5 sig */
175 MD5Final(calc_md5_mac, &md5_ctx);
178 uint32_t smb_signing_next_seqnum(struct smb_signing_state *si, bool oneway)
182 if (si->mac_key.length == 0) {
196 void smb_signing_cancel_reply(struct smb_signing_state *si, bool oneway)
198 if (si->mac_key.length == 0) {
209 void smb_signing_sign_pdu(struct smb_signing_state *si,
210 uint8_t *outbuf, uint32_t seqnum)
212 uint8_t calc_md5_mac[16];
215 if (si->mac_key.length == 0) {
221 /* JRA Paranioa test - we should be able to get rid of this... */
222 if (smb_len(outbuf) < (smb_ss_field + 8 - 4)) {
223 DEBUG(1,("smb_signing_sign_pdu: Logic error. "
224 "Can't check signature on short packet! smb_len = %u\n",
229 /* mark the packet as signed - BEFORE we sign it...*/
230 flags2 = SVAL(outbuf,smb_flg2);
231 flags2 |= FLAGS2_SMB_SECURITY_SIGNATURES;
232 SSVAL(outbuf, smb_flg2, flags2);
235 /* I wonder what BSRSPYL stands for - but this is what MS
237 memcpy(calc_md5_mac, "BSRSPYL ", 8);
239 smb_signing_md5(&si->mac_key, outbuf,
240 seqnum, calc_md5_mac);
243 DEBUG(10, ("smb_signing_sign_pdu: sent SMB signature of\n"));
244 dump_data(10, calc_md5_mac, 8);
246 memcpy(&outbuf[smb_ss_field], calc_md5_mac, 8);
248 /* outbuf[smb_ss_field+2]=0;
249 Uncomment this to test if the remote server actually verifies signatures...*/
252 bool smb_signing_check_pdu(struct smb_signing_state *si,
253 const uint8_t *inbuf, uint32_t seqnum)
256 uint8_t calc_md5_mac[16];
257 const uint8_t *reply_sent_mac;
259 if (si->mac_key.length == 0) {
263 if (smb_len(inbuf) < (smb_ss_field + 8 - 4)) {
264 DEBUG(1,("smb_signing_check_pdu: Can't check signature "
265 "on short packet! smb_len = %u\n",
270 smb_signing_md5(&si->mac_key, inbuf,
271 seqnum, calc_md5_mac);
273 reply_sent_mac = &inbuf[smb_ss_field];
274 good = (memcmp(reply_sent_mac, calc_md5_mac, 8) == 0);
278 const int sign_range = 5;
280 DEBUG(5, ("smb_signing_check_pdu: BAD SIG: wanted SMB signature of\n"));
281 dump_data(5, calc_md5_mac, 8);
283 DEBUG(5, ("smb_signing_check_pdu: BAD SIG: got SMB signature of\n"));
284 dump_data(5, reply_sent_mac, 8);
286 for (i = -sign_range; i < sign_range; i++) {
287 smb_signing_md5(&si->mac_key, inbuf,
288 seqnum+i, calc_md5_mac);
289 if (memcmp(reply_sent_mac, calc_md5_mac, 8) == 0) {
290 DEBUG(0,("smb_signing_check_pdu: "
291 "out of seq. seq num %u matches. "
292 "We were expecting seq %u\n",
293 (unsigned int)seqnum+i,
294 (unsigned int)seqnum));
299 DEBUG(10, ("smb_signing_check_pdu: seq %u: "
300 "got good SMB signature of\n",
301 (unsigned int)seqnum));
302 dump_data(10, reply_sent_mac, 8);
305 return smb_signing_good(si, good, seqnum);
308 bool smb_signing_set_bsrspyl(struct smb_signing_state *si)
310 if (!si->negotiated) {
323 bool smb_signing_activate(struct smb_signing_state *si,
324 const DATA_BLOB user_session_key,
325 const DATA_BLOB response)
330 if (!user_session_key.length) {
334 if (!si->negotiated) {
342 if (si->mac_key.length > 0) {
346 smb_signing_reset_info(si);
348 len = response.length + user_session_key.length;
350 si->mac_key.data = (uint8_t *)si->alloc_fn(si->mem_ctx, len);
351 if (si->mac_key.data == NULL) {
355 si->mac_key.data = (uint8_t *)talloc_size(si, len);
356 if (si->mac_key.data == NULL) {
360 si->mac_key.length = len;
363 memcpy(&si->mac_key.data[ofs], user_session_key.data, user_session_key.length);
365 DEBUG(10, ("smb_signing_activate: user_session_key\n"));
366 dump_data(10, user_session_key.data, user_session_key.length);
368 if (response.length) {
369 ofs = user_session_key.length;
370 memcpy(&si->mac_key.data[ofs], response.data, response.length);
371 DEBUG(10, ("smb_signing_activate: response_data\n"));
372 dump_data(10, response.data, response.length);
374 DEBUG(10, ("smb_signing_activate: NULL response_data\n"));
377 dump_data_pw("smb_signing_activate: mac key is:\n",
378 si->mac_key.data, si->mac_key.length);
380 /* Initialise the sequence number */
386 bool smb_signing_is_active(struct smb_signing_state *si)
391 bool smb_signing_is_allowed(struct smb_signing_state *si)
396 bool smb_signing_is_mandatory(struct smb_signing_state *si)
398 return si->mandatory;
401 bool smb_signing_set_negotiated(struct smb_signing_state *si)
407 si->negotiated = true;
412 bool smb_signing_is_negotiated(struct smb_signing_state *si)
414 return si->negotiated;