source3/smbd/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    Copyright (C) Stefan Metzmacher 2009
   7
   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.
  12
  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.
  17
  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/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "smbd/globals.h"
  24 #include "smb_signing.h"
  25
  26 /***********************************************************
  27  Called to validate an incoming packet from the client.
  28 ************************************************************/
  29
  30 bool srv_check_sign_mac(struct smbd_server_connection *conn,
  31                         const char *inbuf, uint32_t *seqnum,
  32                         bool trusted_channel)
  33 {
  34         /* Check if it's a non-session message. */
  35         if(CVAL(inbuf,0)) {
  36                 return true;
  37         }
  38
  39         if (trusted_channel) {
  40                 NTSTATUS status;
  41
  42                 if (smb_len(inbuf) < (smb_ss_field + 8 - 4)) {
  43                         DEBUG(1,("smb_signing_check_pdu: Can't check signature "
  44                                  "on short packet! smb_len = %u\n",
  45                                  smb_len(inbuf)));
  46                         return false;
  47                 }
  48
  49                 status = NT_STATUS(IVAL(inbuf, smb_ss_field + 4));
  50                 if (!NT_STATUS_IS_OK(status)) {
  51                         DEBUG(1,("smb_signing_check_pdu: trusted channel passed %s\n",
  52                                  nt_errstr(status)));
  53                         return false;
  54                 }
  55
  56                 *seqnum = IVAL(inbuf, smb_ss_field);
  57                 return true;
  58         }
  59
  60         *seqnum = smb_signing_next_seqnum(conn->smb1.signing_state, false);
  61         return smb_signing_check_pdu(conn->smb1.signing_state,
  62                                      (const uint8_t *)inbuf,
  63                                      *seqnum);
  64 }
  65
  66 /***********************************************************
  67  Called to sign an outgoing packet to the client.
  68 ************************************************************/
  69
  70 void srv_calculate_sign_mac(struct smbd_server_connection *conn,
  71                             char *outbuf, uint32_t seqnum)
  72 {
  73         /* Check if it's a non-session message. */
  74         if(CVAL(outbuf,0)) {
  75                 return;
  76         }
  77
  78         smb_signing_sign_pdu(conn->smb1.signing_state, (uint8_t *)outbuf, seqnum);
  79 }
  80
  81
  82 /***********************************************************
  83  Called to indicate a oneway request
  84 ************************************************************/
  85 void srv_cancel_sign_response(struct smbd_server_connection *conn)
  86 {
  87         smb_signing_cancel_reply(conn->smb1.signing_state, true);
  88 }
  89
  90 struct smbd_shm_signing {
  91         size_t shm_size;
  92         uint8_t *shm_pointer;
  93
  94         /* we know the signing engine will only allocate 2 chunks */
  95         uint8_t *ptr1;
  96         size_t len1;
  97         uint8_t *ptr2;
  98         size_t len2;
  99 };
 100
 101 static int smbd_shm_signing_destructor(struct smbd_shm_signing *s)
 102 {
 103         anonymous_shared_free(s->shm_pointer);
 104         return 0;
 105 }
 106
 107 static void *smbd_shm_signing_alloc(TALLOC_CTX *mem_ctx, size_t len)
 108 {
 109         struct smbd_shm_signing *s = talloc_get_type_abort(mem_ctx,
 110                                      struct smbd_shm_signing);
 111
 112         if (s->ptr1 == NULL) {
 113                 s->len1 = len;
 114                 if (len % 8) {
 115                         s->len1 += (8 - (len % 8));
 116                 }
 117                 if (s->len1 > s->shm_size) {
 118                         s->len1 = 0;
 119                         errno = ENOMEM;
 120                         return NULL;
 121                 }
 122                 s->ptr1 = s->shm_pointer;
 123                 return s->ptr1;
 124         }
 125
 126         if (s->ptr2 == NULL) {
 127                 s->len2 = len;
 128                 if (s->len2 > (s->shm_size - s->len1)) {
 129                         s->len2 = 0;
 130                         errno = ENOMEM;
 131                         return NULL;
 132                 }
 133                 s->ptr2 = s->shm_pointer + s->len1;
 134                 return s->ptr2;
 135         }
 136
 137         errno = ENOMEM;
 138         return NULL;
 139 }
 140
 141 static void smbd_shm_signing_free(TALLOC_CTX *mem_ctx, void *ptr)
 142 {
 143         struct smbd_shm_signing *s = talloc_get_type_abort(mem_ctx,
 144                                      struct smbd_shm_signing);
 145
 146         if (s->ptr2 == ptr) {
 147                 s->ptr2 = NULL;
 148                 s->len2 = 0;
 149         }
 150 }
 151
 152 /***********************************************************
 153  Called by server negprot when signing has been negotiated.
 154 ************************************************************/
 155
 156 bool srv_init_signing(struct smbd_server_connection *conn)
 157 {
 158         bool allowed = true;
 159         bool mandatory = false;
 160
 161         switch (lp_server_signing()) {
 162         case Required:
 163                 mandatory = true;
 164                 break;
 165         case Auto:
 166                 break;
 167         case True:
 168                 break;
 169         case False:
 170                 allowed = false;
 171                 break;
 172         }
 173
 174         if (lp_async_smb_echo_handler()) {
 175                 struct smbd_shm_signing *s;
 176
 177                 /* setup the signing state in shared memory */
 178                 s = talloc_zero(smbd_event_context(), struct smbd_shm_signing);
 179                 if (s == NULL) {
 180                         return false;
 181                 }
 182                 s->shm_size = 4096;
 183                 s->shm_pointer =
 184                         (uint8_t *)anonymous_shared_allocate(s->shm_size);
 185                 if (s->shm_pointer == NULL) {
 186                         talloc_free(s);
 187                         return false;
 188                 }
 189                 talloc_set_destructor(s, smbd_shm_signing_destructor);
 190                 conn->smb1.signing_state = smb_signing_init_ex(s,
 191                                                         allowed, mandatory,
 192                                                         smbd_shm_signing_alloc,
 193                                                         smbd_shm_signing_free);
 194                 if (!conn->smb1.signing_state) {
 195                         return false;
 196                 }
 197                 return true;
 198         }
 199
 200         conn->smb1.signing_state = smb_signing_init(smbd_event_context(),
 201                                                     allowed, mandatory);
 202         if (!conn->smb1.signing_state) {
 203                 return false;
 204         }
 205
 206         return true;
 207 }
 208
 209 void srv_set_signing_negotiated(struct smbd_server_connection *conn)
 210 {
 211         smb_signing_set_negotiated(conn->smb1.signing_state);
 212 }
 213
 214 /***********************************************************
 215  Returns whether signing is active. We can't use sendfile or raw
 216  reads/writes if it is.
 217 ************************************************************/
 218
 219 bool srv_is_signing_active(struct smbd_server_connection *conn)
 220 {
 221         return smb_signing_is_active(conn->smb1.signing_state);
 222 }
 223
 224
 225 /***********************************************************
 226  Returns whether signing is negotiated. We can't use it unless it was
 227  in the negprot.
 228 ************************************************************/
 229
 230 bool srv_is_signing_negotiated(struct smbd_server_connection *conn)
 231 {
 232         return smb_signing_is_negotiated(conn->smb1.signing_state);
 233 }
 234
 235 /***********************************************************
 236  Turn on signing from this packet onwards.
 237 ************************************************************/
 238
 239 void srv_set_signing(struct smbd_server_connection *conn,
 240                      const DATA_BLOB user_session_key,
 241                      const DATA_BLOB response)
 242 {
 243         bool negotiated;
 244         bool mandatory;
 245
 246         if (!user_session_key.length)
 247                 return;
 248
 249         negotiated = smb_signing_is_negotiated(conn->smb1.signing_state);
 250         mandatory = smb_signing_is_mandatory(conn->smb1.signing_state);
 251
 252         if (!negotiated && !mandatory) {
 253                 DEBUG(5,("srv_set_signing: signing negotiated = %u, "
 254                          "mandatory_signing = %u. Not allowing smb signing.\n",
 255                          negotiated, mandatory));
 256                 return;
 257         }
 258
 259         if (!smb_signing_activate(conn->smb1.signing_state,
 260                                   user_session_key, response)) {
 261                 return;
 262         }
 263
 264         DEBUG(3,("srv_set_signing: turning on SMB signing: "
 265                  "signing negotiated = %u, mandatory_signing = %u.\n",
 266                  negotiated, mandatory));
 267 }
 268