Split CIFS_SessSetup()

The functionality provided by free_rsp_buf() is duplicated in a number of places. Replace these instances with a call to free_rsp_buf().

Signed-off-by Sachin Prabhu <[email protected]>

---
 fs/cifs/cifsproto.h |  1 +
 fs/cifs/cifssmb.c   | 20 ++++----------------
 fs/cifs/misc.c      |  9 +++++++++
 fs/cifs/smb2pdu.c   | 10 ----------
 4 files changed, 14 insertions(+), 26 deletions(-)

fs/cifs/cifsproto.h +1 -0

index ca7980a..de49d7a 100644
@@ -36,6 +36,7 @@ extern struct smb_hdr *cifs_buf_get(void);
 extern void cifs_buf_release(void *);
 extern struct smb_hdr *cifs_small_buf_get(void);
 extern void cifs_small_buf_release(void *);
+extern void free_rsp_buf(int, void *);
 extern void cifs_rqst_page_to_kvec(struct smb_rqst *rqst, unsigned int idx,
                                        struct kvec *iov);
 extern int smb_send(struct TCP_Server_Info *, struct smb_hdr *,

fs/cifs/cifssmb.c +4 -16

index 6ce4e09..b7e5b65 100644
@@ -1734,10 +1734,7 @@ CIFSSMBRead(const unsigned int xid, struct cifs_io_parms *io_parms,
 
 /*     cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
        if (*buf) {
-               if (resp_buf_type == CIFS_SMALL_BUFFER)
-                       cifs_small_buf_release(iov[0].iov_base);
-               else if (resp_buf_type == CIFS_LARGE_BUFFER)
-                       cifs_buf_release(iov[0].iov_base);
+               free_rsp_buf(resp_buf_type, iov[0].iov_base);
        } else if (resp_buf_type != CIFS_NO_BUFFER) {
                /* return buffer to caller to free */
                *buf = iov[0].iov_base;

@@ -2203,10 +2200,7 @@ CIFSSMBWrite2(const unsigned int xid, struct cifs_io_parms *io_parms,
        }
 
 /*     cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
-       if (resp_buf_type == CIFS_SMALL_BUFFER)
-               cifs_small_buf_release(iov[0].iov_base);
-       else if (resp_buf_type == CIFS_LARGE_BUFFER)
-               cifs_buf_release(iov[0].iov_base);
+       free_rsp_buf(resp_buf_type, iov[0].iov_base);
 
        /* Note: On -EAGAIN error only caller can retry on handle based calls
                since file handle passed in no longer valid */

@@ -2451,10 +2445,7 @@ plk_err_exit:
        if (pSMB)
                cifs_small_buf_release(pSMB);
 
-       if (resp_buf_type == CIFS_SMALL_BUFFER)
-               cifs_small_buf_release(iov[0].iov_base);
-       else if (resp_buf_type == CIFS_LARGE_BUFFER)
-               cifs_buf_release(iov[0].iov_base);
+       free_rsp_buf(resp_buf_type, iov[0].iov_base);
 
        /* Note: On -EAGAIN error only caller can retry on handle based calls
           since file handle passed in no longer valid */

@@ -3838,10 +3829,7 @@ CIFSSMBGetCIFSACL(const unsigned int xid, struct cifs_tcon *tcon, __u16 fid,
                }
        }
 qsec_out:
-       if (buf_type == CIFS_SMALL_BUFFER)
-               cifs_small_buf_release(iov[0].iov_base);
-       else if (buf_type == CIFS_LARGE_BUFFER)
-               cifs_buf_release(iov[0].iov_base);
+       free_rsp_buf(buf_type, iov[0].iov_base);
 /*     cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
        return rc;
 }

fs/cifs/misc.c +9 -0

index 3b0c62e..64997a0 100644
@@ -226,6 +226,15 @@ cifs_small_buf_release(void *buf_to_free)
        return;
 }
 
+void
+free_rsp_buf(int resp_buftype, void *rsp)
+{
+       if (resp_buftype == CIFS_SMALL_BUFFER)
+               cifs_small_buf_release(rsp);
+       else if (resp_buftype == CIFS_LARGE_BUFFER)
+               cifs_buf_release(rsp);
+}
+
 /* NB: MID can not be set if treeCon not passed in, in that
    case it is responsbility of caller to set the mid */
 void

fs/cifs/smb2pdu.c +0 -11

index b0b260d..0158104 100644
@@ -309,16 +309,6 @@ small_smb2_init(__le16 smb2_command, struct cifs_tcon *tcon,
        return rc;
 }
 
-static void
-free_rsp_buf(int resp_buftype, void *rsp)
-{
-       if (resp_buftype == CIFS_SMALL_BUFFER)
-               cifs_small_buf_release(rsp);
-       else if (resp_buftype == CIFS_LARGE_BUFFER)
-               cifs_buf_release(rsp);
-}
-
-
 /*
  *
  *     SMB2 Worker functions follow:
--

1.9.3

--
To unsubscribe from this list: send the line "unsubscribe linux-cifs" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html

Looks correct.

Reviewed-by Shirish Pargaonkar <spargaonkar-IBi9RG/[email protected]>

Quoted 119 lines · Sachin Prabhu

The functionality provided by free_rsp_buf() is duplicated in a number of places. Replace these instances with a call to free_rsp_buf().

Signed-off-by Sachin Prabhu <[email protected]>

---
 fs/cifs/cifsproto.h |  1 +
 fs/cifs/cifssmb.c   | 20 ++++----------------
 fs/cifs/misc.c      |  9 +++++++++
 fs/cifs/smb2pdu.c   | 10 ----------
 4 files changed, 14 insertions(+), 26 deletions(-)

fs/cifs/cifsproto.h +1 -0

index ca7980a..de49d7a 100644
@@ -36,6 +36,7 @@ extern struct smb_hdr *cifs_buf_get(void);
 extern void cifs_buf_release(void *);
 extern struct smb_hdr *cifs_small_buf_get(void);
 extern void cifs_small_buf_release(void *);
+extern void free_rsp_buf(int, void *);
 extern void cifs_rqst_page_to_kvec(struct smb_rqst *rqst, unsigned int idx,
                                        struct kvec *iov);
 extern int smb_send(struct TCP_Server_Info *, struct smb_hdr *,

fs/cifs/cifssmb.c +4 -16

index 6ce4e09..b7e5b65 100644
@@ -1734,10 +1734,7 @@ CIFSSMBRead(const unsigned int xid, struct cifs_io_parms *io_parms,
 
 /*     cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
        if (*buf) {
-               if (resp_buf_type == CIFS_SMALL_BUFFER)
-                       cifs_small_buf_release(iov[0].iov_base);
-               else if (resp_buf_type == CIFS_LARGE_BUFFER)
-                       cifs_buf_release(iov[0].iov_base);
+               free_rsp_buf(resp_buf_type, iov[0].iov_base);
        } else if (resp_buf_type != CIFS_NO_BUFFER) {
                /* return buffer to caller to free */
                *buf = iov[0].iov_base;

@@ -2203,10 +2200,7 @@ CIFSSMBWrite2(const unsigned int xid, struct cifs_io_parms *io_parms,
        }
 
 /*     cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
-       if (resp_buf_type == CIFS_SMALL_BUFFER)
-               cifs_small_buf_release(iov[0].iov_base);
-       else if (resp_buf_type == CIFS_LARGE_BUFFER)
-               cifs_buf_release(iov[0].iov_base);
+       free_rsp_buf(resp_buf_type, iov[0].iov_base);
 
        /* Note: On -EAGAIN error only caller can retry on handle based calls
                since file handle passed in no longer valid */

@@ -2451,10 +2445,7 @@ plk_err_exit:
        if (pSMB)
                cifs_small_buf_release(pSMB);
 
-       if (resp_buf_type == CIFS_SMALL_BUFFER)
-               cifs_small_buf_release(iov[0].iov_base);
-       else if (resp_buf_type == CIFS_LARGE_BUFFER)
-               cifs_buf_release(iov[0].iov_base);
+       free_rsp_buf(resp_buf_type, iov[0].iov_base);
 
        /* Note: On -EAGAIN error only caller can retry on handle based calls
           since file handle passed in no longer valid */

@@ -3838,10 +3829,7 @@ CIFSSMBGetCIFSACL(const unsigned int xid, struct cifs_tcon *tcon, __u16 fid,
                }
        }
 qsec_out:
-       if (buf_type == CIFS_SMALL_BUFFER)
-               cifs_small_buf_release(iov[0].iov_base);
-       else if (buf_type == CIFS_LARGE_BUFFER)
-               cifs_buf_release(iov[0].iov_base);
+       free_rsp_buf(buf_type, iov[0].iov_base);
 /*     cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
        return rc;
 }

fs/cifs/misc.c +9 -0

index 3b0c62e..64997a0 100644
@@ -226,6 +226,15 @@ cifs_small_buf_release(void *buf_to_free)
        return;
 }
 
+void
+free_rsp_buf(int resp_buftype, void *rsp)
+{
+       if (resp_buftype == CIFS_SMALL_BUFFER)
+               cifs_small_buf_release(rsp);
+       else if (resp_buftype == CIFS_LARGE_BUFFER)
+               cifs_buf_release(rsp);
+}
+
 /* NB: MID can not be set if treeCon not passed in, in that
    case it is responsbility of caller to set the mid */
 void

fs/cifs/smb2pdu.c +0 -11

index b0b260d..0158104 100644
@@ -309,16 +309,6 @@ small_smb2_init(__le16 smb2_command, struct cifs_tcon *tcon,
        return rc;
 }
 
-static void
-free_rsp_buf(int resp_buftype, void *rsp)
-{
-       if (resp_buftype == CIFS_SMALL_BUFFER)
-               cifs_small_buf_release(rsp);
-       else if (resp_buftype == CIFS_LARGE_BUFFER)
-               cifs_buf_release(rsp);
-}
-
-
 /*
  *
  *     SMB2 Worker functions follow:
--

1.9.3

Quoted 4 lines

--
To unsubscribe from this list: send the line "unsubscribe linux-cifs" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html

--
To unsubscribe from this list: send the line "unsubscribe linux-cifs" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html

In preparation for splitting CIFS_SessSetup() into smaller more manageable chunks, we first add helper functions.

We then proceed to split out lanman auth out of CIFS_SessSetup()

Signed-off-by Sachin Prabhu <[email protected]>

---
 fs/cifs/sess.c | 303 ++++++++++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 258 insertions(+), 45 deletions(-)

fs/cifs/sess.c +258 -46

index e87387d..36d0b90 100644
@@ -520,6 +520,240 @@ select_sectype(struct TCP_Server_Info *server, enum securityEnum requested)
        }
 }
 
+struct sess_data {
+       unsigned int xid;
+       struct cifs_ses *ses;
+       struct nls_table *nls_cp;
+       void (*func)(struct sess_data *);
+       int result;
+
+       /* we will send the SMB in three pieces:
+        * a fixed length beginning part, an optional
+        * SPNEGO blob (which can be zero length), and a
+        * last part which will include the strings
+        * and rest of bcc area. This allows us to avoid
+        * a large buffer 17K allocation
+        */
+       int buf0_type;
+       struct kvec iov[3];
+};
+
+static int
+sess_alloc_buffer(struct sess_data *sess_data, int wct)
+{
+       int rc;
+       struct cifs_ses *ses = sess_data->ses;
+       struct smb_hdr *smb_buf;
+
+       rc = small_smb_init_no_tc(SMB_COM_SESSION_SETUP_ANDX, wct, ses,
+                                 (void **)&smb_buf);
+
+       if (rc)
+               return rc;
+
+       sess_data->iov[0].iov_base = (char *)smb_buf;
+       sess_data->iov[0].iov_len = be32_to_cpu(smb_buf->smb_buf_length) + 4;
+       /*
+        * This variable will be used to clear the buffer
+        * allocated above in case of any error in the calling function.
+        */
+       sess_data->buf0_type = CIFS_SMALL_BUFFER;
+
+       /* 2000 big enough to fit max user, domain, NOS name etc. */
+       sess_data->iov[2].iov_base = kmalloc(2000, GFP_KERNEL);
+       if (!sess_data->iov[2].iov_base) {
+               rc = -ENOMEM;
+               goto out_free_smb_buf;
+       }
+
+       return 0;
+
+out_free_smb_buf:
+       kfree(smb_buf);
+       sess_data->iov[0].iov_base = NULL;
+       sess_data->iov[0].iov_len = 0;
+       sess_data->buf0_type = CIFS_NO_BUFFER;
+       return rc;
+}
+
+static void
+sess_free_buffer(struct sess_data *sess_data)
+{
+
+       free_rsp_buf(sess_data->buf0_type, sess_data->iov[0].iov_base);
+       sess_data->buf0_type = CIFS_NO_BUFFER;
+       kfree(sess_data->iov[2].iov_base);
+}
+
+static int
+sess_establish_session(struct sess_data *sess_data)
+{
+       struct cifs_ses *ses = sess_data->ses;
+
+       mutex_lock(&ses->server->srv_mutex);
+       if (!ses->server->session_estab) {
+               if (ses->server->sign) {
+                       ses->server->session_key.response =
+                               kmemdup(ses->auth_key.response,
+                               ses->auth_key.len, GFP_KERNEL);
+                       if (!ses->server->session_key.response) {
+                               mutex_unlock(&ses->server->srv_mutex);
+                               return -ENOMEM;
+                       }
+                       ses->server->session_key.len =
+                                               ses->auth_key.len;
+               }
+               ses->server->sequence_number = 0x2;
+               ses->server->session_estab = true;
+       }
+       mutex_unlock(&ses->server->srv_mutex);
+
+       cifs_dbg(FYI, "CIFS session established successfully\n");
+       spin_lock(&GlobalMid_Lock);
+       ses->status = CifsGood;
+       ses->need_reconnect = false;
+       spin_unlock(&GlobalMid_Lock);
+
+       return 0;
+}
+
+static int
+sess_sendreceive(struct sess_data *sess_data)
+{
+       int rc;
+       struct smb_hdr *smb_buf = (struct smb_hdr *) sess_data->iov[0].iov_base;
+       __u16 count;
+
+       count = sess_data->iov[1].iov_len + sess_data->iov[2].iov_len;
+       smb_buf->smb_buf_length =
+               cpu_to_be32(be32_to_cpu(smb_buf->smb_buf_length) + count);
+       put_bcc(count, smb_buf);
+
+       rc = SendReceive2(sess_data->xid, sess_data->ses,
+                         sess_data->iov, 3 /* num_iovecs */,
+                         &sess_data->buf0_type,
+                         CIFS_LOG_ERROR);
+
+       return rc;
+}
+
+/*
+ * LANMAN and plaintext are less secure and off by default.
+ * So we make this explicitly be turned on in kconfig (in the
+ * build) and turned on at runtime (changed from the default)
+ * in proc/fs/cifs or via mount parm.  Unfortunately this is
+ * needed for old Win (e.g. Win95), some obscure NAS and OS/2
+ */
+#ifdef CONFIG_CIFS_WEAK_PW_HASH
+static void
+sess_auth_lanman(struct sess_data *sess_data)
+{
+       int rc = 0;
+       struct smb_hdr *smb_buf;
+       SESSION_SETUP_ANDX *pSMB;
+       char *bcc_ptr;
+       struct cifs_ses *ses = sess_data->ses;
+       char lnm_session_key[CIFS_AUTH_RESP_SIZE];
+       __u32 capabilities;
+       __u16 bytes_remaining;
+
+       /* lanman 2 style sessionsetup */
+       /* wct = 10 */
+       rc = sess_alloc_buffer(sess_data, 10);
+       if (rc)
+               goto out;
+
+       pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
+       bcc_ptr = sess_data->iov[2].iov_base;
+       capabilities = cifs_ssetup_hdr(ses, pSMB);
+
+       pSMB->req.hdr.Flags2 &= ~SMBFLG2_UNICODE;
+
+       /* no capabilities flags in old lanman negotiation */
+       pSMB->old_req.PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
+
+       /* Calculate hash with password and copy into bcc_ptr.
+        * Encryption Key (stored as in cryptkey) gets used if the
+        * security mode bit in Negottiate Protocol response states
+        * to use challenge/response method (i.e. Password bit is 1).
+        */
+       rc = calc_lanman_hash(ses->password, ses->server->cryptkey,
+                             ses->server->sec_mode & SECMODE_PW_ENCRYPT ?
+                             true : false, lnm_session_key);
+
+       memcpy(bcc_ptr, (char *)lnm_session_key, CIFS_AUTH_RESP_SIZE);
+       bcc_ptr += CIFS_AUTH_RESP_SIZE;
+
+       /*
+        * can not sign if LANMAN negotiated so no need
+        * to calculate signing key? but what if server
+        * changed to do higher than lanman dialect and
+        * we reconnected would we ever calc signing_key?
+        */
+
+       cifs_dbg(FYI, "Negotiating LANMAN setting up strings\n");
+       /* Unicode not allowed for LANMAN dialects */
+       ascii_ssetup_strings(&bcc_ptr, ses, sess_data->nls_cp);
+
+       sess_data->iov[2].iov_len = (long) bcc_ptr -
+                       (long) sess_data->iov[2].iov_base;
+
+       rc = sess_sendreceive(sess_data);
+       if (rc)
+               goto out;
+
+       pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
+       smb_buf = (struct smb_hdr *)sess_data->iov[0].iov_base;
+
+       /* lanman response has a word count of 3 */
+       if (smb_buf->WordCount != 3) {
+               rc = -EIO;
+               cifs_dbg(VFS, "bad word count %d\n", smb_buf->WordCount);
+               goto out;
+       }
+
+       if (le16_to_cpu(pSMB->resp.Action) & GUEST_LOGIN)
+               cifs_dbg(FYI, "Guest login\n"); /* BB mark SesInfo struct? */
+
+       ses->Suid = smb_buf->Uid;   /* UID left in wire format (le) */
+       cifs_dbg(FYI, "UID = %llu\n", ses->Suid);
+
+       bytes_remaining = get_bcc(smb_buf);
+       bcc_ptr = pByteArea(smb_buf);
+
+       /* BB check if Unicode and decode strings */
+       if (bytes_remaining == 0) {
+               /* no string area to decode, do nothing */
+       } else if (smb_buf->Flags2 & SMBFLG2_UNICODE) {
+               /* unicode string area must be word-aligned */
+               if (((unsigned long) bcc_ptr - (unsigned long) smb_buf) % 2) {
+                       ++bcc_ptr;
+                       --bytes_remaining;
+               }
+               decode_unicode_ssetup(&bcc_ptr, bytes_remaining, ses,
+                                     sess_data->nls_cp);
+       } else {
+               decode_ascii_ssetup(&bcc_ptr, bytes_remaining, ses,
+                                   sess_data->nls_cp);
+       }
+
+       rc = sess_establish_session(sess_data);
+out:
+       sess_data->result = rc;
+       sess_data->func = NULL;
+       sess_free_buffer(sess_data);
+}
+
+#else
+
+static void
+sess_auth_lanman(struct sess_data *sess_data)
+{
+       sess_data->result = -EOPNOTSUPP;
+       sess_data->func = NULL;
+}
+#endif
+
 int
 CIFS_SessSetup(const unsigned int xid, struct cifs_ses *ses,
               const struct nls_table *nls_cp)

@@ -540,12 +774,21 @@ CIFS_SessSetup(const unsigned int xid, struct cifs_ses *ses,
        __le32 phase = NtLmNegotiate; /* NTLMSSP, if needed, is multistage */
        u16 blob_len;
        char *ntlmsspblob = NULL;
+       struct sess_data *sess_data;
 
        if (ses == NULL) {
                WARN(1, "%s: ses == NULL!", __func__);
                return -EINVAL;
        }
 
+       sess_data = kzalloc(sizeof(struct sess_data), GFP_KERNEL);
+       if (!sess_data)
+               return -ENOMEM;
+       sess_data->xid = xid;
+       sess_data->ses = ses;
+       sess_data->buf0_type = CIFS_NO_BUFFER;
+       sess_data->nls_cp = (struct nls_table *) nls_cp;
+
        type = select_sectype(ses->server, ses->sectype);
        cifs_dbg(FYI, "sess setup type %d\n", type);
        if (type == Unspecified) {

@@ -554,6 +797,14 @@ CIFS_SessSetup(const unsigned int xid, struct cifs_ses *ses,
                return -EINVAL;
        }
 
+       switch (type) {
+       case LANMAN:
+               sess_auth_lanman(sess_data);
+               goto out;
+       default:
+               cifs_dbg(FYI, "Continuing with CIFS_SessSetup\n");
+       }
+
        if (type == RawNTLMSSP) {
                /* if memory allocation is successful, caller of this function
                 * frees it.

@@ -569,17 +820,7 @@ ssetup_ntlmssp_authenticate:
        if (phase == NtLmChallenge)
                phase = NtLmAuthenticate; /* if ntlmssp, now final phase */
 
-       if (type == LANMAN) {
-#ifndef CONFIG_CIFS_WEAK_PW_HASH
-               /* LANMAN and plaintext are less secure and off by default.
-               So we make this explicitly be turned on in kconfig (in the
-               build) and turned on at runtime (changed from the default)
-               in proc/fs/cifs or via mount parm.  Unfortunately this is
-               needed for old Win (e.g. Win95), some obscure NAS and OS/2 */
-               return -EOPNOTSUPP;
-#endif
-               wct = 10; /* lanman 2 style sessionsetup */
-       } else if ((type == NTLM) || (type == NTLMv2)) {
+       if ((type == NTLM) || (type == NTLMv2)) {
                /* For NTLMv2 failures eventually may need to retry NTLM */
                wct = 13; /* old style NTLM sessionsetup */
        } else /* same size: negotiate or auth, NTLMSSP or extended security */

@@ -618,39 +859,7 @@ ssetup_ntlmssp_authenticate:
        iov[1].iov_base = NULL;
        iov[1].iov_len = 0;
 
-       if (type == LANMAN) {
-#ifdef CONFIG_CIFS_WEAK_PW_HASH
-               char lnm_session_key[CIFS_AUTH_RESP_SIZE];
-
-               pSMB->req.hdr.Flags2 &= ~SMBFLG2_UNICODE;
-
-               /* no capabilities flags in old lanman negotiation */
-
-               pSMB->old_req.PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
-
-               /* Calculate hash with password and copy into bcc_ptr.
-                * Encryption Key (stored as in cryptkey) gets used if the
-                * security mode bit in Negottiate Protocol response states
-                * to use challenge/response method (i.e. Password bit is 1).
-                */
-
-               rc = calc_lanman_hash(ses->password, ses->server->cryptkey,
-                                ses->server->sec_mode & SECMODE_PW_ENCRYPT ?
-                                       true : false, lnm_session_key);
-
-               memcpy(bcc_ptr, (char *)lnm_session_key, CIFS_AUTH_RESP_SIZE);
-               bcc_ptr += CIFS_AUTH_RESP_SIZE;
-
-               /* can not sign if LANMAN negotiated so no need
-               to calculate signing key? but what if server
-               changed to do higher than lanman dialect and
-               we reconnected would we ever calc signing_key? */
-
-               cifs_dbg(FYI, "Negotiating LANMAN setting up strings\n");
-               /* Unicode not allowed for LANMAN dialects */
-               ascii_ssetup_strings(&bcc_ptr, ses, nls_cp);
-#endif
-       } else if (type == NTLM) {
+       if (type == NTLM) {
                pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
                pSMB->req_no_secext.CaseInsensitivePasswordLength =
                        cpu_to_le16(CIFS_AUTH_RESP_SIZE);

@@ -889,7 +1098,6 @@ ssetup_ntlmssp_authenticate:
                }
                if (phase == NtLmChallenge) {
                        rc = decode_ntlmssp_challenge(bcc_ptr, blob_len, ses);
-                       /* now goto beginning for ntlmssp authenticate phase */
                        if (rc)
                                goto ssetup_exit;
                }

@@ -962,4 +1170,9 @@ keycp_exit:
        kfree(ses->ntlmssp);
 
        return rc;
+
+out:
+       rc = sess_data->result;
+       kfree(sess_data);
+       return rc;
 }
--

1.9.3

--
To unsubscribe from this list: send the line "unsubscribe linux-cifs" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html

Signed-off-by Sachin Prabhu <[email protected]>

---
 fs/cifs/sess.c | 316 ++++++++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 232 insertions(+), 84 deletions(-)

fs/cifs/sess.c +232 -85

index 36d0b90..4f481c1 100644
@@ -754,6 +754,216 @@ sess_auth_lanman(struct sess_data *sess_data)
 }
 #endif
 
+static void
+sess_auth_ntlm(struct sess_data *sess_data)
+{
+       int rc = 0;
+       struct smb_hdr *smb_buf;
+       SESSION_SETUP_ANDX *pSMB;
+       char *bcc_ptr;
+       struct cifs_ses *ses = sess_data->ses;
+       __u32 capabilities;
+       __u16 bytes_remaining;
+
+       /* old style NTLM sessionsetup */
+       /* wct = 13 */
+       rc = sess_alloc_buffer(sess_data, 13);
+       if (rc)
+               goto out;
+
+       pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
+       bcc_ptr = sess_data->iov[2].iov_base;
+       capabilities = cifs_ssetup_hdr(ses, pSMB);
+
+       pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
+       pSMB->req_no_secext.CaseInsensitivePasswordLength =
+                       cpu_to_le16(CIFS_AUTH_RESP_SIZE);
+       pSMB->req_no_secext.CaseSensitivePasswordLength =
+                       cpu_to_le16(CIFS_AUTH_RESP_SIZE);
+
+       /* calculate ntlm response and session key */
+       rc = setup_ntlm_response(ses, sess_data->nls_cp);
+       if (rc) {
+               cifs_dbg(VFS, "Error %d during NTLM authentication\n",
+                                rc);
+               goto out;
+       }
+
+       /* copy ntlm response */
+       memcpy(bcc_ptr, ses->auth_key.response + CIFS_SESS_KEY_SIZE,
+                       CIFS_AUTH_RESP_SIZE);
+       bcc_ptr += CIFS_AUTH_RESP_SIZE;
+       memcpy(bcc_ptr, ses->auth_key.response + CIFS_SESS_KEY_SIZE,
+                       CIFS_AUTH_RESP_SIZE);
+       bcc_ptr += CIFS_AUTH_RESP_SIZE;
+
+       if (ses->capabilities & CAP_UNICODE) {
+               /* unicode strings must be word aligned */
+               if (sess_data->iov[0].iov_len % 2) {
+                       *bcc_ptr = 0;
+                       bcc_ptr++;
+               }
+               unicode_ssetup_strings(&bcc_ptr, ses, sess_data->nls_cp);
+       } else {
+               ascii_ssetup_strings(&bcc_ptr, ses, sess_data->nls_cp);
+       }
+
+
+       sess_data->iov[2].iov_len = (long) bcc_ptr -
+                       (long) sess_data->iov[2].iov_base;
+
+       rc = sess_sendreceive(sess_data);
+       if (rc)
+               goto out;
+
+       pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
+       smb_buf = (struct smb_hdr *)sess_data->iov[0].iov_base;
+
+       if (smb_buf->WordCount != 3) {
+               rc = -EIO;
+               cifs_dbg(VFS, "bad word count %d\n", smb_buf->WordCount);
+               goto out;
+       }
+
+       if (le16_to_cpu(pSMB->resp.Action) & GUEST_LOGIN)
+               cifs_dbg(FYI, "Guest login\n"); /* BB mark SesInfo struct? */
+
+       ses->Suid = smb_buf->Uid;   /* UID left in wire format (le) */
+       cifs_dbg(FYI, "UID = %llu\n", ses->Suid);
+
+       bytes_remaining = get_bcc(smb_buf);
+       bcc_ptr = pByteArea(smb_buf);
+
+       /* BB check if Unicode and decode strings */
+       if (bytes_remaining == 0) {
+               /* no string area to decode, do nothing */
+       } else if (smb_buf->Flags2 & SMBFLG2_UNICODE) {
+               /* unicode string area must be word-aligned */
+               if (((unsigned long) bcc_ptr - (unsigned long) smb_buf) % 2) {
+                       ++bcc_ptr;
+                       --bytes_remaining;
+               }
+               decode_unicode_ssetup(&bcc_ptr, bytes_remaining, ses,
+                                     sess_data->nls_cp);
+       } else {
+               decode_ascii_ssetup(&bcc_ptr, bytes_remaining, ses,
+                                   sess_data->nls_cp);
+       }
+
+       rc = sess_establish_session(sess_data);
+out:
+       sess_data->result = rc;
+       sess_data->func = NULL;
+       sess_free_buffer(sess_data);
+       kfree(ses->auth_key.response);
+       ses->auth_key.response = NULL;
+}
+
+static void
+sess_auth_ntlmv2(struct sess_data *sess_data)
+{
+       int rc = 0;
+       struct smb_hdr *smb_buf;
+       SESSION_SETUP_ANDX *pSMB;
+       char *bcc_ptr;
+       struct cifs_ses *ses = sess_data->ses;
+       __u32 capabilities;
+       __u16 bytes_remaining;
+
+       /* old style NTLM sessionsetup */
+       /* wct = 13 */
+       rc = sess_alloc_buffer(sess_data, 13);
+       if (rc)
+               goto out;
+
+       pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
+       bcc_ptr = sess_data->iov[2].iov_base;
+       capabilities = cifs_ssetup_hdr(ses, pSMB);
+
+       pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
+
+       /* LM2 password would be here if we supported it */
+       pSMB->req_no_secext.CaseInsensitivePasswordLength = 0;
+
+       /* calculate nlmv2 response and session key */
+       rc = setup_ntlmv2_rsp(ses, sess_data->nls_cp);
+       if (rc) {
+               cifs_dbg(VFS, "Error %d during NTLMv2 authentication\n", rc);
+               goto out;
+       }
+
+       memcpy(bcc_ptr, ses->auth_key.response + CIFS_SESS_KEY_SIZE,
+                       ses->auth_key.len - CIFS_SESS_KEY_SIZE);
+       bcc_ptr += ses->auth_key.len - CIFS_SESS_KEY_SIZE;
+
+       /* set case sensitive password length after tilen may get
+        * assigned, tilen is 0 otherwise.
+        */
+       pSMB->req_no_secext.CaseSensitivePasswordLength =
+               cpu_to_le16(ses->auth_key.len - CIFS_SESS_KEY_SIZE);
+
+       if (ses->capabilities & CAP_UNICODE) {
+               if (sess_data->iov[0].iov_len % 2) {
+                       *bcc_ptr = 0;
+                       bcc_ptr++;
+               }
+               unicode_ssetup_strings(&bcc_ptr, ses, sess_data->nls_cp);
+       } else {
+               ascii_ssetup_strings(&bcc_ptr, ses, sess_data->nls_cp);
+       }
+
+
+       sess_data->iov[2].iov_len = (long) bcc_ptr -
+                       (long) sess_data->iov[2].iov_base;
+
+       rc = sess_sendreceive(sess_data);
+       if (rc)
+               goto out;
+
+       pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
+       smb_buf = (struct smb_hdr *)sess_data->iov[0].iov_base;
+
+       if (smb_buf->WordCount != 3) {
+               rc = -EIO;
+               cifs_dbg(VFS, "bad word count %d\n", smb_buf->WordCount);
+               goto out;
+       }
+
+       if (le16_to_cpu(pSMB->resp.Action) & GUEST_LOGIN)
+               cifs_dbg(FYI, "Guest login\n"); /* BB mark SesInfo struct? */
+
+       ses->Suid = smb_buf->Uid;   /* UID left in wire format (le) */
+       cifs_dbg(FYI, "UID = %llu\n", ses->Suid);
+
+       bytes_remaining = get_bcc(smb_buf);
+       bcc_ptr = pByteArea(smb_buf);
+
+       /* BB check if Unicode and decode strings */
+       if (bytes_remaining == 0) {
+               /* no string area to decode, do nothing */
+       } else if (smb_buf->Flags2 & SMBFLG2_UNICODE) {
+               /* unicode string area must be word-aligned */
+               if (((unsigned long) bcc_ptr - (unsigned long) smb_buf) % 2) {
+                       ++bcc_ptr;
+                       --bytes_remaining;
+               }
+               decode_unicode_ssetup(&bcc_ptr, bytes_remaining, ses,
+                                     sess_data->nls_cp);
+       } else {
+               decode_ascii_ssetup(&bcc_ptr, bytes_remaining, ses,
+                                   sess_data->nls_cp);
+       }
+
+       rc = sess_establish_session(sess_data);
+out:
+       sess_data->result = rc;
+       sess_data->func = NULL;
+       sess_free_buffer(sess_data);
+       kfree(ses->auth_key.response);
+       ses->auth_key.response = NULL;
+}
+
+
 int
 CIFS_SessSetup(const unsigned int xid, struct cifs_ses *ses,
               const struct nls_table *nls_cp)

@@ -801,6 +1011,12 @@ CIFS_SessSetup(const unsigned int xid, struct cifs_ses *ses,
        case LANMAN:
                sess_auth_lanman(sess_data);
                goto out;
+       case NTLM:
+               sess_auth_ntlm(sess_data);
+               goto out;
+       case NTLMv2:
+               sess_auth_ntlmv2(sess_data);
+               goto out;
        default:
                cifs_dbg(FYI, "Continuing with CIFS_SessSetup\n");
        }

@@ -820,11 +1036,8 @@ ssetup_ntlmssp_authenticate:
        if (phase == NtLmChallenge)
                phase = NtLmAuthenticate; /* if ntlmssp, now final phase */
 
-       if ((type == NTLM) || (type == NTLMv2)) {
-               /* For NTLMv2 failures eventually may need to retry NTLM */
-               wct = 13; /* old style NTLM sessionsetup */
-       } else /* same size: negotiate or auth, NTLMSSP or extended security */
-               wct = 12;
+       /* same size: negotiate or auth, NTLMSSP or extended security */
+       wct = 12;
 
        rc = small_smb_init_no_tc(SMB_COM_SESSION_SETUP_ANDX, wct, ses,
                            (void **)&smb_buf);

@@ -859,70 +1072,7 @@ ssetup_ntlmssp_authenticate:
        iov[1].iov_base = NULL;
        iov[1].iov_len = 0;
 
-       if (type == NTLM) {
-               pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
-               pSMB->req_no_secext.CaseInsensitivePasswordLength =
-                       cpu_to_le16(CIFS_AUTH_RESP_SIZE);
-               pSMB->req_no_secext.CaseSensitivePasswordLength =
-                       cpu_to_le16(CIFS_AUTH_RESP_SIZE);
-
-               /* calculate ntlm response and session key */
-               rc = setup_ntlm_response(ses, nls_cp);
-               if (rc) {
-                       cifs_dbg(VFS, "Error %d during NTLM authentication\n",
-                                rc);
-                       goto ssetup_exit;
-               }
-
-               /* copy ntlm response */
-               memcpy(bcc_ptr, ses->auth_key.response + CIFS_SESS_KEY_SIZE,
-                               CIFS_AUTH_RESP_SIZE);
-               bcc_ptr += CIFS_AUTH_RESP_SIZE;
-               memcpy(bcc_ptr, ses->auth_key.response + CIFS_SESS_KEY_SIZE,
-                               CIFS_AUTH_RESP_SIZE);
-               bcc_ptr += CIFS_AUTH_RESP_SIZE;
-
-               if (ses->capabilities & CAP_UNICODE) {
-                       /* unicode strings must be word aligned */
-                       if (iov[0].iov_len % 2) {
-                               *bcc_ptr = 0;
-                               bcc_ptr++;
-                       }
-                       unicode_ssetup_strings(&bcc_ptr, ses, nls_cp);
-               } else
-                       ascii_ssetup_strings(&bcc_ptr, ses, nls_cp);
-       } else if (type == NTLMv2) {
-               pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
-
-               /* LM2 password would be here if we supported it */
-               pSMB->req_no_secext.CaseInsensitivePasswordLength = 0;
-
-               /* calculate nlmv2 response and session key */
-               rc = setup_ntlmv2_rsp(ses, nls_cp);
-               if (rc) {
-                       cifs_dbg(VFS, "Error %d during NTLMv2 authentication\n",
-                                rc);
-                       goto ssetup_exit;
-               }
-               memcpy(bcc_ptr, ses->auth_key.response + CIFS_SESS_KEY_SIZE,
-                               ses->auth_key.len - CIFS_SESS_KEY_SIZE);
-               bcc_ptr += ses->auth_key.len - CIFS_SESS_KEY_SIZE;
-
-               /* set case sensitive password length after tilen may get
-                * assigned, tilen is 0 otherwise.
-                */
-               pSMB->req_no_secext.CaseSensitivePasswordLength =
-                       cpu_to_le16(ses->auth_key.len - CIFS_SESS_KEY_SIZE);
-
-               if (ses->capabilities & CAP_UNICODE) {
-                       if (iov[0].iov_len % 2) {
-                               *bcc_ptr = 0;
-                               bcc_ptr++;
-                       }
-                       unicode_ssetup_strings(&bcc_ptr, ses, nls_cp);
-               } else
-                       ascii_ssetup_strings(&bcc_ptr, ses, nls_cp);
-       } else if (type == Kerberos) {
+       if (type == Kerberos) {
 #ifdef CONFIG_CIFS_UPCALL
                struct cifs_spnego_msg *msg;
 

@@ -1073,7 +1223,7 @@ ssetup_ntlmssp_authenticate:
        if (rc)
                goto ssetup_exit;
 
-       if ((smb_buf->WordCount != 3) && (smb_buf->WordCount != 4)) {
+       if (smb_buf->WordCount != 4) {
                rc = -EIO;
                cifs_dbg(VFS, "bad word count %d\n", smb_buf->WordCount);
                goto ssetup_exit;

@@ -1088,22 +1238,20 @@ ssetup_ntlmssp_authenticate:
        bytes_remaining = get_bcc(smb_buf);
        bcc_ptr = pByteArea(smb_buf);
 
-       if (smb_buf->WordCount == 4) {
-               blob_len = le16_to_cpu(pSMB->resp.SecurityBlobLength);
-               if (blob_len > bytes_remaining) {
-                       cifs_dbg(VFS, "bad security blob length %d\n",
-                                blob_len);
-                       rc = -EINVAL;
+       blob_len = le16_to_cpu(pSMB->resp.SecurityBlobLength);
+       if (blob_len > bytes_remaining) {
+               cifs_dbg(VFS, "bad security blob length %d\n",
+                        blob_len);
+               rc = -EINVAL;
+               goto ssetup_exit;
+       }
+       if (phase == NtLmChallenge) {
+               rc = decode_ntlmssp_challenge(bcc_ptr, blob_len, ses);
+               if (rc)
                        goto ssetup_exit;
-               }
-               if (phase == NtLmChallenge) {
-                       rc = decode_ntlmssp_challenge(bcc_ptr, blob_len, ses);
-                       if (rc)
-                               goto ssetup_exit;
-               }
-               bcc_ptr += blob_len;
-               bytes_remaining -= blob_len;
        }
+       bcc_ptr += blob_len;
+       bytes_remaining -= blob_len;
 
        /* BB check if Unicode and decode strings */
        if (bytes_remaining == 0) {
--

1.9.3

--
To unsubscribe from this list: send the line "unsubscribe linux-cifs" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html

Signed-off-by Sachin Prabhu <[email protected]>

---
 fs/cifs/sess.c | 215 ++++++++++++++++++++++++++++++++++++++++-----------------
 1 file changed, 153 insertions(+), 62 deletions(-)

fs/cifs/sess.c +153 -63

index 4f481c1..b413fae 100644
@@ -963,6 +963,155 @@ out:
        ses->auth_key.response = NULL;
 }
 
+#ifdef CONFIG_CIFS_UPCALL
+static void
+sess_auth_kerberos(struct sess_data *sess_data)
+{
+       int rc = 0;
+       struct smb_hdr *smb_buf;
+       SESSION_SETUP_ANDX *pSMB;
+       char *bcc_ptr;
+       struct cifs_ses *ses = sess_data->ses;
+       __u32 capabilities;
+       __u16 bytes_remaining;
+       struct key *spnego_key = NULL;
+       struct cifs_spnego_msg *msg;
+       u16 blob_len;
+
+       /* extended security */
+       /* wct = 12 */
+       rc = sess_alloc_buffer(sess_data, 12);
+       if (rc)
+               goto out;
+
+       pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
+       bcc_ptr = sess_data->iov[2].iov_base;
+       capabilities = cifs_ssetup_hdr(ses, pSMB);
+
+       spnego_key = cifs_get_spnego_key(ses);
+       if (IS_ERR(spnego_key)) {
+               rc = PTR_ERR(spnego_key);
+               spnego_key = NULL;
+               goto out;
+       }
+
+       msg = spnego_key->payload.data;
+       /*
+        * check version field to make sure that cifs.upcall is
+        * sending us a response in an expected form
+        */
+       if (msg->version != CIFS_SPNEGO_UPCALL_VERSION) {
+               cifs_dbg(VFS,
+                 "incorrect version of cifs.upcall (expected %d but got %d)",
+                             CIFS_SPNEGO_UPCALL_VERSION, msg->version);
+               rc = -EKEYREJECTED;
+               goto out_put_spnego_key;
+       }
+
+       ses->auth_key.response = kmemdup(msg->data, msg->sesskey_len,
+                                        GFP_KERNEL);
+       if (!ses->auth_key.response) {
+               cifs_dbg(VFS, "Kerberos can't allocate (%u bytes) memory",
+                               msg->sesskey_len);
+               rc = -ENOMEM;
+               goto out_put_spnego_key;
+       }
+       ses->auth_key.len = msg->sesskey_len;
+
+       pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
+       capabilities |= CAP_EXTENDED_SECURITY;
+       pSMB->req.Capabilities = cpu_to_le32(capabilities);
+       sess_data->iov[1].iov_base = msg->data + msg->sesskey_len;
+       sess_data->iov[1].iov_len = msg->secblob_len;
+       pSMB->req.SecurityBlobLength = cpu_to_le16(sess_data->iov[1].iov_len);
+
+       if (ses->capabilities & CAP_UNICODE) {
+               /* unicode strings must be word aligned */
+               if ((sess_data->iov[0].iov_len
+                       + sess_data->iov[1].iov_len) % 2) {
+                       *bcc_ptr = 0;
+                       bcc_ptr++;
+               }
+               unicode_oslm_strings(&bcc_ptr, sess_data->nls_cp);
+               unicode_domain_string(&bcc_ptr, ses, sess_data->nls_cp);
+       } else {
+               /* BB: is this right? */
+               ascii_ssetup_strings(&bcc_ptr, ses, sess_data->nls_cp);
+       }
+
+       sess_data->iov[2].iov_len = (long) bcc_ptr -
+                       (long) sess_data->iov[2].iov_base;
+
+       rc = sess_sendreceive(sess_data);
+       if (rc)
+               goto out_put_spnego_key;
+
+       pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
+       smb_buf = (struct smb_hdr *)sess_data->iov[0].iov_base;
+
+       if (smb_buf->WordCount != 4) {
+               rc = -EIO;
+               cifs_dbg(VFS, "bad word count %d\n", smb_buf->WordCount);
+               goto out_put_spnego_key;
+       }
+
+       if (le16_to_cpu(pSMB->resp.Action) & GUEST_LOGIN)
+               cifs_dbg(FYI, "Guest login\n"); /* BB mark SesInfo struct? */
+
+       ses->Suid = smb_buf->Uid;   /* UID left in wire format (le) */
+       cifs_dbg(FYI, "UID = %llu\n", ses->Suid);
+
+       bytes_remaining = get_bcc(smb_buf);
+       bcc_ptr = pByteArea(smb_buf);
+
+       blob_len = le16_to_cpu(pSMB->resp.SecurityBlobLength);
+       if (blob_len > bytes_remaining) {
+               cifs_dbg(VFS, "bad security blob length %d\n",
+                               blob_len);
+               rc = -EINVAL;
+               goto out_put_spnego_key;
+       }
+       bcc_ptr += blob_len;
+       bytes_remaining -= blob_len;
+
+       /* BB check if Unicode and decode strings */
+       if (bytes_remaining == 0) {
+               /* no string area to decode, do nothing */
+       } else if (smb_buf->Flags2 & SMBFLG2_UNICODE) {
+               /* unicode string area must be word-aligned */
+               if (((unsigned long) bcc_ptr - (unsigned long) smb_buf) % 2) {
+                       ++bcc_ptr;
+                       --bytes_remaining;
+               }
+               decode_unicode_ssetup(&bcc_ptr, bytes_remaining, ses,
+                                     sess_data->nls_cp);
+       } else {
+               decode_ascii_ssetup(&bcc_ptr, bytes_remaining, ses,
+                                   sess_data->nls_cp);
+       }
+
+       rc = sess_establish_session(sess_data);
+out_put_spnego_key:
+       key_invalidate(spnego_key);
+       key_put(spnego_key);
+out:
+       sess_data->result = rc;
+       sess_data->func = NULL;
+       sess_free_buffer(sess_data);
+       kfree(ses->auth_key.response);
+       ses->auth_key.response = NULL;
+}
+
+#else
+
+static void
+sess_auth_kerberos(struct sess_data *sess_data)
+{
+       cifs_dbg(VFS, "Kerberos negotiated but upcall support disabled!\n");
+       sess_data->result = -ENOSYS;
+       sess_data->func = NULL;
+}
+#endif /* ! CONFIG_CIFS_UPCALL */
 
 int
 CIFS_SessSetup(const unsigned int xid, struct cifs_ses *ses,

@@ -980,7 +1129,6 @@ CIFS_SessSetup(const unsigned int xid, struct cifs_ses *ses,
        struct kvec iov[3];
        enum securityEnum type;
        __u16 action, bytes_remaining;
-       struct key *spnego_key = NULL;
        __le32 phase = NtLmNegotiate; /* NTLMSSP, if needed, is multistage */
        u16 blob_len;
        char *ntlmsspblob = NULL;

@@ -1017,6 +1165,9 @@ CIFS_SessSetup(const unsigned int xid, struct cifs_ses *ses,
        case NTLMv2:
                sess_auth_ntlmv2(sess_data);
                goto out;
+       case Kerberos:
+               sess_auth_kerberos(sess_data);
+               goto out;
        default:
                cifs_dbg(FYI, "Continuing with CIFS_SessSetup\n");
        }

@@ -1072,63 +1223,7 @@ ssetup_ntlmssp_authenticate:
        iov[1].iov_base = NULL;
        iov[1].iov_len = 0;
 
-       if (type == Kerberos) {
-#ifdef CONFIG_CIFS_UPCALL
-               struct cifs_spnego_msg *msg;
-
-               spnego_key = cifs_get_spnego_key(ses);
-               if (IS_ERR(spnego_key)) {
-                       rc = PTR_ERR(spnego_key);
-                       spnego_key = NULL;
-                       goto ssetup_exit;
-               }
-
-               msg = spnego_key->payload.data;
-               /* check version field to make sure that cifs.upcall is
-                  sending us a response in an expected form */
-               if (msg->version != CIFS_SPNEGO_UPCALL_VERSION) {
-                       cifs_dbg(VFS, "incorrect version of cifs.upcall "
-                                  "expected %d but got %d)",
-                                  CIFS_SPNEGO_UPCALL_VERSION, msg->version);
-                       rc = -EKEYREJECTED;
-                       goto ssetup_exit;
-               }
-
-               ses->auth_key.response = kmemdup(msg->data, msg->sesskey_len,
-                                                GFP_KERNEL);
-               if (!ses->auth_key.response) {
-                       cifs_dbg(VFS,
-                               "Kerberos can't allocate (%u bytes) memory",
-                               msg->sesskey_len);
-                       rc = -ENOMEM;
-                       goto ssetup_exit;
-               }
-               ses->auth_key.len = msg->sesskey_len;
-
-               pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
-               capabilities |= CAP_EXTENDED_SECURITY;
-               pSMB->req.Capabilities = cpu_to_le32(capabilities);
-               iov[1].iov_base = msg->data + msg->sesskey_len;
-               iov[1].iov_len = msg->secblob_len;
-               pSMB->req.SecurityBlobLength = cpu_to_le16(iov[1].iov_len);
-
-               if (ses->capabilities & CAP_UNICODE) {
-                       /* unicode strings must be word aligned */
-                       if ((iov[0].iov_len + iov[1].iov_len) % 2) {
-                               *bcc_ptr = 0;
-                               bcc_ptr++;
-                       }
-                       unicode_oslm_strings(&bcc_ptr, nls_cp);
-                       unicode_domain_string(&bcc_ptr, ses, nls_cp);
-               } else
-               /* BB: is this right? */
-                       ascii_ssetup_strings(&bcc_ptr, ses, nls_cp);
-#else /* ! CONFIG_CIFS_UPCALL */
-               cifs_dbg(VFS, "Kerberos negotiated but upcall support disabled!\n");
-               rc = -ENOSYS;
-               goto ssetup_exit;
-#endif /* CONFIG_CIFS_UPCALL */
-       } else if (type == RawNTLMSSP) {
+       if (type == RawNTLMSSP) {
                if ((pSMB->req.hdr.Flags2 & SMBFLG2_UNICODE) == 0) {
                        cifs_dbg(VFS, "NTLMSSP requires Unicode support\n");
                        rc = -ENOSYS;

@@ -1268,10 +1363,6 @@ ssetup_ntlmssp_authenticate:
        }
 
 ssetup_exit:
-       if (spnego_key) {
-               key_invalidate(spnego_key);
-               key_put(spnego_key);
-       }
        kfree(str_area);
        kfree(ntlmsspblob);
        ntlmsspblob = NULL;
--

1.9.3

--
To unsubscribe from this list: send the line "unsubscribe linux-cifs" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html

Separate rawntlmssp authentication from CIFS_SessSetup(). Also cleanup CIFS_SessSetup() since we no longer do any auth within it.

Signed-off-by Sachin Prabhu <[email protected]>

---
 fs/cifs/sess.c | 490 +++++++++++++++++++++++++++++++--------------------------
 1 file changed, 263 insertions(+), 227 deletions(-)

fs/cifs/sess.c +263 -228

index b413fae..c2e7c07 100644
@@ -1113,241 +1113,225 @@ sess_auth_kerberos(struct sess_data *sess_data)
 }
 #endif /* ! CONFIG_CIFS_UPCALL */
 
-int
-CIFS_SessSetup(const unsigned int xid, struct cifs_ses *ses,
-              const struct nls_table *nls_cp)
+/*
+ * The required kvec buffers have to be allocated before calling this
+ * function.
+ */
+static int
+_sess_auth_rawntlmssp_assemble_req(struct sess_data *sess_data)
 {
-       int rc = 0;
-       int wct;
        struct smb_hdr *smb_buf;
-       char *bcc_ptr;
-       char *str_area;
        SESSION_SETUP_ANDX *pSMB;
+       struct cifs_ses *ses = sess_data->ses;
        __u32 capabilities;
-       __u16 count;
-       int resp_buf_type;
-       struct kvec iov[3];
-       enum securityEnum type;
-       __u16 action, bytes_remaining;
-       __le32 phase = NtLmNegotiate; /* NTLMSSP, if needed, is multistage */
-       u16 blob_len;
-       char *ntlmsspblob = NULL;
-       struct sess_data *sess_data;
+       char *bcc_ptr;
 
-       if (ses == NULL) {
-               WARN(1, "%s: ses == NULL!", __func__);
-               return -EINVAL;
+       pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
+       smb_buf = (struct smb_hdr *)pSMB;
+
+       capabilities = cifs_ssetup_hdr(ses, pSMB);
+       if ((pSMB->req.hdr.Flags2 & SMBFLG2_UNICODE) == 0) {
+               cifs_dbg(VFS, "NTLMSSP requires Unicode support\n");
+               return -ENOSYS;
        }
 
-       sess_data = kzalloc(sizeof(struct sess_data), GFP_KERNEL);
-       if (!sess_data)
-               return -ENOMEM;
-       sess_data->xid = xid;
-       sess_data->ses = ses;
-       sess_data->buf0_type = CIFS_NO_BUFFER;
-       sess_data->nls_cp = (struct nls_table *) nls_cp;
+       pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
+       capabilities |= CAP_EXTENDED_SECURITY;
+       pSMB->req.Capabilities |= cpu_to_le32(capabilities);
 
-       type = select_sectype(ses->server, ses->sectype);
-       cifs_dbg(FYI, "sess setup type %d\n", type);
-       if (type == Unspecified) {
-               cifs_dbg(VFS,
-                       "Unable to select appropriate authentication method!");
-               return -EINVAL;
+       bcc_ptr = sess_data->iov[2].iov_base;
+       /* unicode strings must be word aligned */
+       if ((sess_data->iov[0].iov_len + sess_data->iov[1].iov_len) % 2) {
+               *bcc_ptr = 0;
+               bcc_ptr++;
        }
+       unicode_oslm_strings(&bcc_ptr, sess_data->nls_cp);
 
-       switch (type) {
-       case LANMAN:
-               sess_auth_lanman(sess_data);
-               goto out;
-       case NTLM:
-               sess_auth_ntlm(sess_data);
-               goto out;
-       case NTLMv2:
-               sess_auth_ntlmv2(sess_data);
-               goto out;
-       case Kerberos:
-               sess_auth_kerberos(sess_data);
-               goto out;
-       default:
-               cifs_dbg(FYI, "Continuing with CIFS_SessSetup\n");
-       }
+       sess_data->iov[2].iov_len = (long) bcc_ptr -
+                                       (long) sess_data->iov[2].iov_base;
 
-       if (type == RawNTLMSSP) {
-               /* if memory allocation is successful, caller of this function
-                * frees it.
-                */
-               ses->ntlmssp = kmalloc(sizeof(struct ntlmssp_auth), GFP_KERNEL);
-               if (!ses->ntlmssp)
-                       return -ENOMEM;
-               ses->ntlmssp->sesskey_per_smbsess = false;
+       return 0;
+}
+
+static void
+sess_auth_rawntlmssp_authenticate(struct sess_data *sess_data);
+
+static void
+sess_auth_rawntlmssp_negotiate(struct sess_data *sess_data)
+{
+       int rc;
+       struct smb_hdr *smb_buf;
+       SESSION_SETUP_ANDX *pSMB;
+       struct cifs_ses *ses = sess_data->ses;
+       __u16 bytes_remaining;
+       char *bcc_ptr;
+       u16 blob_len;
+
+       cifs_dbg(FYI, "rawntlmssp session setup negotiate phase\n");
 
+       /*
+        * if memory allocation is successful, caller of this function
+        * frees it.
+        */
+       ses->ntlmssp = kmalloc(sizeof(struct ntlmssp_auth), GFP_KERNEL);
+       if (!ses->ntlmssp) {
+               rc = -ENOMEM;
+               goto out;
        }
+       ses->ntlmssp->sesskey_per_smbsess = false;
 
-ssetup_ntlmssp_authenticate:
-       if (phase == NtLmChallenge)
-               phase = NtLmAuthenticate; /* if ntlmssp, now final phase */
+       /* wct = 12 */
+       rc = sess_alloc_buffer(sess_data, 12);
+       if (rc)
+               goto out;
 
-       /* same size: negotiate or auth, NTLMSSP or extended security */
-       wct = 12;
+       pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
 
-       rc = small_smb_init_no_tc(SMB_COM_SESSION_SETUP_ANDX, wct, ses,
-                           (void **)&smb_buf);
+       /* Build security blob before we assemble the request */
+       build_ntlmssp_negotiate_blob(pSMB->req.SecurityBlob, ses);
+       sess_data->iov[1].iov_len = sizeof(NEGOTIATE_MESSAGE);
+       sess_data->iov[1].iov_base = pSMB->req.SecurityBlob;
+       pSMB->req.SecurityBlobLength = cpu_to_le16(sizeof(NEGOTIATE_MESSAGE));
+
+       rc = _sess_auth_rawntlmssp_assemble_req(sess_data);
        if (rc)
-               return rc;
+               goto out;
 
-       pSMB = (SESSION_SETUP_ANDX *)smb_buf;
+       rc = sess_sendreceive(sess_data);
 
-       capabilities = cifs_ssetup_hdr(ses, pSMB);
+       pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
+       smb_buf = (struct smb_hdr *)sess_data->iov[0].iov_base;
 
-       /* we will send the SMB in three pieces:
-       a fixed length beginning part, an optional
-       SPNEGO blob (which can be zero length), and a
-       last part which will include the strings
-       and rest of bcc area. This allows us to avoid
-       a large buffer 17K allocation */
-       iov[0].iov_base = (char *)pSMB;
-       iov[0].iov_len = be32_to_cpu(smb_buf->smb_buf_length) + 4;
-
-       /* setting this here allows the code at the end of the function
-          to free the request buffer if there's an error */
-       resp_buf_type = CIFS_SMALL_BUFFER;
+       /* If true, rc here is expected and not an error */
+       if (sess_data->buf0_type != CIFS_NO_BUFFER &&
+           smb_buf->Status.CifsError ==
+                       cpu_to_le32(NT_STATUS_MORE_PROCESSING_REQUIRED))
+               rc = 0;
 
-       /* 2000 big enough to fit max user, domain, NOS name etc. */
-       str_area = kmalloc(2000, GFP_KERNEL);
-       if (str_area == NULL) {
-               rc = -ENOMEM;
-               goto ssetup_exit;
+       if (rc)
+               goto out;
+
+       cifs_dbg(FYI, "rawntlmssp session setup challenge phase\n");
+
+       if (smb_buf->WordCount != 4) {
+               rc = -EIO;
+               cifs_dbg(VFS, "bad word count %d\n", smb_buf->WordCount);
+               goto out;
        }
-       bcc_ptr = str_area;
 
-       iov[1].iov_base = NULL;
-       iov[1].iov_len = 0;
+       ses->Suid = smb_buf->Uid;   /* UID left in wire format (le) */
+       cifs_dbg(FYI, "UID = %llu\n", ses->Suid);
 
-       if (type == RawNTLMSSP) {
-               if ((pSMB->req.hdr.Flags2 & SMBFLG2_UNICODE) == 0) {
-                       cifs_dbg(VFS, "NTLMSSP requires Unicode support\n");
-                       rc = -ENOSYS;
-                       goto ssetup_exit;
-               }
+       bytes_remaining = get_bcc(smb_buf);
+       bcc_ptr = pByteArea(smb_buf);
 
-               cifs_dbg(FYI, "ntlmssp session setup phase %d\n", phase);
-               pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
-               capabilities |= CAP_EXTENDED_SECURITY;
-               pSMB->req.Capabilities |= cpu_to_le32(capabilities);
-               switch(phase) {
-               case NtLmNegotiate:
-                       build_ntlmssp_negotiate_blob(
-                               pSMB->req.SecurityBlob, ses);
-                       iov[1].iov_len = sizeof(NEGOTIATE_MESSAGE);
-                       iov[1].iov_base = pSMB->req.SecurityBlob;
-                       pSMB->req.SecurityBlobLength =
-                               cpu_to_le16(sizeof(NEGOTIATE_MESSAGE));
-                       break;
-               case NtLmAuthenticate:
-                       /*
-                        * 5 is an empirical value, large enough to hold
-                        * authenticate message plus max 10 of av paris,
-                        * domain, user, workstation names, flags, etc.
-                        */
-                       ntlmsspblob = kzalloc(
-                               5*sizeof(struct _AUTHENTICATE_MESSAGE),
-                               GFP_KERNEL);
-                       if (!ntlmsspblob) {
-                               rc = -ENOMEM;
-                               goto ssetup_exit;
-                       }
+       blob_len = le16_to_cpu(pSMB->resp.SecurityBlobLength);
+       if (blob_len > bytes_remaining) {
+               cifs_dbg(VFS, "bad security blob length %d\n",
+                               blob_len);
+               rc = -EINVAL;
+               goto out;
+       }
 
-                       rc = build_ntlmssp_auth_blob(ntlmsspblob,
-                                               &blob_len, ses, nls_cp);
-                       if (rc)
-                               goto ssetup_exit;
-                       iov[1].iov_len = blob_len;
-                       iov[1].iov_base = ntlmsspblob;
-                       pSMB->req.SecurityBlobLength = cpu_to_le16(blob_len);
-                       /*
-                        * Make sure that we tell the server that we are using
-                        * the uid that it just gave us back on the response
-                        * (challenge)
-                        */
-                       smb_buf->Uid = ses->Suid;
-                       break;
-               default:
-                       cifs_dbg(VFS, "invalid phase %d\n", phase);
-                       rc = -ENOSYS;
-                       goto ssetup_exit;
-               }
-               /* unicode strings must be word aligned */
-               if ((iov[0].iov_len + iov[1].iov_len) % 2) {
-                       *bcc_ptr = 0;
-                       bcc_ptr++;
-               }
-               unicode_oslm_strings(&bcc_ptr, nls_cp);
-       } else {
-               cifs_dbg(VFS, "secType %d not supported!\n", type);
-               rc = -ENOSYS;
-               goto ssetup_exit;
+       rc = decode_ntlmssp_challenge(bcc_ptr, blob_len, ses);
+out:
+       sess_free_buffer(sess_data);
+
+       if (!rc) {
+               sess_data->func = sess_auth_rawntlmssp_authenticate;
+               return;
        }
 
-       iov[2].iov_base = str_area;
-       iov[2].iov_len = (long) bcc_ptr - (long) str_area;
+       /* Else error. Cleanup */
+       kfree(ses->auth_key.response);
+       ses->auth_key.response = NULL;
+       kfree(ses->ntlmssp);
+       ses->ntlmssp = NULL;
 
-       count = iov[1].iov_len + iov[2].iov_len;
-       smb_buf->smb_buf_length =
-               cpu_to_be32(be32_to_cpu(smb_buf->smb_buf_length) + count);
+       sess_data->func = NULL;
+       sess_data->result = rc;
+}
 
-       put_bcc(count, smb_buf);
+static void
+sess_auth_rawntlmssp_authenticate(struct sess_data *sess_data)
+{
+       int rc;
+       struct smb_hdr *smb_buf;
+       SESSION_SETUP_ANDX *pSMB;
+       struct cifs_ses *ses = sess_data->ses;
+       __u16 bytes_remaining;
+       char *bcc_ptr;
+       char *ntlmsspblob = NULL;
+       u16 blob_len;
 
-       rc = SendReceive2(xid, ses, iov, 3 /* num_iovecs */, &resp_buf_type,
-                         CIFS_LOG_ERROR);
-       /* SMB request buf freed in SendReceive2 */
+       cifs_dbg(FYI, "rawntlmssp session setup authenticate phase\n");
 
-       pSMB = (SESSION_SETUP_ANDX *)iov[0].iov_base;
-       smb_buf = (struct smb_hdr *)iov[0].iov_base;
+       /* wct = 12 */
+       rc = sess_alloc_buffer(sess_data, 12);
+       if (rc)
+               goto out;
 
-       if ((type == RawNTLMSSP) && (resp_buf_type != CIFS_NO_BUFFER) &&
-           (smb_buf->Status.CifsError ==
-                       cpu_to_le32(NT_STATUS_MORE_PROCESSING_REQUIRED))) {
-               if (phase != NtLmNegotiate) {
-                       cifs_dbg(VFS, "Unexpected more processing error\n");
-                       goto ssetup_exit;
-               }
-               /* NTLMSSP Negotiate sent now processing challenge (response) */
-               phase = NtLmChallenge; /* process ntlmssp challenge */
-               rc = 0; /* MORE_PROC rc is not an error here, but expected */
+       /* Build security blob before we assemble the request */
+       pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
+       smb_buf = (struct smb_hdr *)pSMB;
+       /*
+        * 5 is an empirical value, large enough to hold
+        * authenticate message plus max 10 of av paris,
+        * domain, user, workstation names, flags, etc.
+        */
+       ntlmsspblob = kzalloc(5*sizeof(struct _AUTHENTICATE_MESSAGE),
+                               GFP_KERNEL);
+       if (!ntlmsspblob) {
+               rc = -ENOMEM;
+               goto out;
        }
+
+       rc = build_ntlmssp_auth_blob(ntlmsspblob,
+                                       &blob_len, ses, sess_data->nls_cp);
+       if (rc)
+               goto out_free_ntlmsspblob;
+       sess_data->iov[1].iov_len = blob_len;
+       sess_data->iov[1].iov_base = ntlmsspblob;
+       pSMB->req.SecurityBlobLength = cpu_to_le16(blob_len);
+       /*
+        * Make sure that we tell the server that we are using
+        * the uid that it just gave us back on the response
+        * (challenge)
+        */
+       smb_buf->Uid = ses->Suid;
+
+       rc = _sess_auth_rawntlmssp_assemble_req(sess_data);
        if (rc)
-               goto ssetup_exit;
+               goto out_free_ntlmsspblob;
 
+       rc = sess_sendreceive(sess_data);
+       if (rc)
+               goto out_free_ntlmsspblob;
+
+       pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
+       smb_buf = (struct smb_hdr *)sess_data->iov[0].iov_base;
        if (smb_buf->WordCount != 4) {
                rc = -EIO;
                cifs_dbg(VFS, "bad word count %d\n", smb_buf->WordCount);
-               goto ssetup_exit;
+               goto out_free_ntlmsspblob;
        }
-       action = le16_to_cpu(pSMB->resp.Action);
-       if (action & GUEST_LOGIN)
+
+       if (le16_to_cpu(pSMB->resp.Action) & GUEST_LOGIN)
                cifs_dbg(FYI, "Guest login\n"); /* BB mark SesInfo struct? */
-       ses->Suid = smb_buf->Uid;   /* UID left in wire format (le) */
-       cifs_dbg(FYI, "UID = %llu\n", ses->Suid);
-       /* response can have either 3 or 4 word count - Samba sends 3 */
-       /* and lanman response is 3 */
+
        bytes_remaining = get_bcc(smb_buf);
        bcc_ptr = pByteArea(smb_buf);
-
        blob_len = le16_to_cpu(pSMB->resp.SecurityBlobLength);
        if (blob_len > bytes_remaining) {
                cifs_dbg(VFS, "bad security blob length %d\n",
-                        blob_len);
+                               blob_len);
                rc = -EINVAL;
-               goto ssetup_exit;
-       }
-       if (phase == NtLmChallenge) {
-               rc = decode_ntlmssp_challenge(bcc_ptr, blob_len, ses);
-               if (rc)
-                       goto ssetup_exit;
+               goto out_free_ntlmsspblob;
        }
        bcc_ptr += blob_len;
        bytes_remaining -= blob_len;
 
+
        /* BB check if Unicode and decode strings */
        if (bytes_remaining == 0) {
                /* no string area to decode, do nothing */

@@ -1357,61 +1341,113 @@ ssetup_ntlmssp_authenticate:
                        ++bcc_ptr;
                        --bytes_remaining;
                }
-               decode_unicode_ssetup(&bcc_ptr, bytes_remaining, ses, nls_cp);
+               decode_unicode_ssetup(&bcc_ptr, bytes_remaining, ses,
+                                     sess_data->nls_cp);
        } else {
-               decode_ascii_ssetup(&bcc_ptr, bytes_remaining, ses, nls_cp);
+               decode_ascii_ssetup(&bcc_ptr, bytes_remaining, ses,
+                                   sess_data->nls_cp);
        }
 
-ssetup_exit:
-       kfree(str_area);
+out_free_ntlmsspblob:
        kfree(ntlmsspblob);
-       ntlmsspblob = NULL;
-       if (resp_buf_type == CIFS_SMALL_BUFFER) {
-               cifs_dbg(FYI, "ssetup freeing small buf %p\n", iov[0].iov_base);
-               cifs_small_buf_release(iov[0].iov_base);
-       } else if (resp_buf_type == CIFS_LARGE_BUFFER)
-               cifs_buf_release(iov[0].iov_base);
-
-       /* if ntlmssp, and negotiate succeeded, proceed to authenticate phase */
-       if ((phase == NtLmChallenge) && (rc == 0))
-               goto ssetup_ntlmssp_authenticate;
-
-       if (!rc) {
-               mutex_lock(&ses->server->srv_mutex);
-               if (!ses->server->session_estab) {
-                       if (ses->server->sign) {
-                               ses->server->session_key.response =
-                                       kmemdup(ses->auth_key.response,
-                                       ses->auth_key.len, GFP_KERNEL);
-                               if (!ses->server->session_key.response) {
-                                       rc = -ENOMEM;
-                                       mutex_unlock(&ses->server->srv_mutex);
-                                       goto keycp_exit;
-                               }
-                               ses->server->session_key.len =
-                                                       ses->auth_key.len;
-                       }
-                       ses->server->sequence_number = 0x2;
-                       ses->server->session_estab = true;
-               }
-               mutex_unlock(&ses->server->srv_mutex);
+out:
+       sess_free_buffer(sess_data);
 
-               cifs_dbg(FYI, "CIFS session established successfully\n");
-               spin_lock(&GlobalMid_Lock);
-               ses->status = CifsGood;
-               ses->need_reconnect = false;
-               spin_unlock(&GlobalMid_Lock);
-       }
+        if (!rc)
+               rc = sess_establish_session(sess_data);
 
-keycp_exit:
+       /* Cleanup */
        kfree(ses->auth_key.response);
        ses->auth_key.response = NULL;
        kfree(ses->ntlmssp);
+       ses->ntlmssp = NULL;
 
-       return rc;
+       sess_data->func = NULL;
+       sess_data->result = rc;
+}
 
-out:
+int select_sec(struct cifs_ses *ses, struct sess_data *sess_data)
+{
+       int type;
+
+       type = select_sectype(ses->server, ses->sectype);
+       cifs_dbg(FYI, "sess setup type %d\n", type);
+       if (type == Unspecified) {
+               cifs_dbg(VFS,
+                       "Unable to select appropriate authentication method!");
+               return -EINVAL;
+       }
+
+       switch (type) {
+       case LANMAN:
+               /* LANMAN and plaintext are less secure and off by default.
+                * So we make this explicitly be turned on in kconfig (in the
+                * build) and turned on at runtime (changed from the default)
+                * in proc/fs/cifs or via mount parm.  Unfortunately this is
+                * needed for old Win (e.g. Win95), some obscure NAS and OS/2 */
+#ifdef CONFIG_CIFS_WEAK_PW_HASH
+               sess_data->func = sess_auth_lanman;
+               break;
+#else
+               return -EOPNOTSUPP;
+#endif
+       case NTLM:
+               sess_data->func = sess_auth_ntlm;
+               break;
+       case NTLMv2:
+               sess_data->func = sess_auth_ntlmv2;
+               break;
+       case Kerberos:
+#ifdef CONFIG_CIFS_UPCALL
+               sess_data->func = sess_auth_kerberos;
+               break;
+#else
+               cifs_dbg(VFS, "Kerberos negotiated but upcall support disabled!\n");
+               return -ENOSYS;
+               break;
+#endif /* CONFIG_CIFS_UPCALL */
+       case RawNTLMSSP:
+               sess_data->func = sess_auth_rawntlmssp_negotiate;
+               break;
+       default:
+               cifs_dbg(VFS, "secType %d not supported!\n", type);
+               return -ENOSYS;
+       }
+
+       return 0;
+}
+
+int CIFS_SessSetup(const unsigned int xid, struct cifs_ses *ses,
+                   const struct nls_table *nls_cp)
+{
+       int rc = 0;
+       struct sess_data *sess_data;
+
+       if (ses == NULL) {
+               WARN(1, "%s: ses == NULL!", __func__);
+               return -EINVAL;
+       }
+
+       sess_data = kzalloc(sizeof(struct sess_data), GFP_KERNEL);
+       if (!sess_data)
+               return -ENOMEM;
+
+       rc = select_sec(ses, sess_data);
+       if (rc)
+               goto out;
+
+       sess_data->xid = xid;
+       sess_data->ses = ses;
+       sess_data->buf0_type = CIFS_NO_BUFFER;
+       sess_data->nls_cp = (struct nls_table *) nls_cp;
+
+       while (sess_data->func)
+               sess_data->func(sess_data);
+
+       /* Store result before we free sess_data */
        rc = sess_data->result;
+
+out:
        kfree(sess_data);
        return rc;
 }
--

1.9.3

--
To unsubscribe from this list: send the line "unsubscribe linux-cifs" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html

Looks good.

Reviewed-by Shirish Pargaonkar <spargaonkar-IBi9RG/[email protected]>

Quoted 582 lines · Sachin Prabhu

Separate rawntlmssp authentication from CIFS_SessSetup(). Also cleanup CIFS_SessSetup() since we no longer do any auth within it.

Signed-off-by Sachin Prabhu <[email protected]>

---
 fs/cifs/sess.c | 490 +++++++++++++++++++++++++++++++--------------------------
 1 file changed, 263 insertions(+), 227 deletions(-)

fs/cifs/sess.c +263 -228

index b413fae..c2e7c07 100644
@@ -1113,241 +1113,225 @@ sess_auth_kerberos(struct sess_data *sess_data)
 }
 #endif /* ! CONFIG_CIFS_UPCALL */
 
-int
-CIFS_SessSetup(const unsigned int xid, struct cifs_ses *ses,
-              const struct nls_table *nls_cp)
+/*
+ * The required kvec buffers have to be allocated before calling this
+ * function.
+ */
+static int
+_sess_auth_rawntlmssp_assemble_req(struct sess_data *sess_data)
 {
-       int rc = 0;
-       int wct;
        struct smb_hdr *smb_buf;
-       char *bcc_ptr;
-       char *str_area;
        SESSION_SETUP_ANDX *pSMB;
+       struct cifs_ses *ses = sess_data->ses;
        __u32 capabilities;
-       __u16 count;
-       int resp_buf_type;
-       struct kvec iov[3];
-       enum securityEnum type;
-       __u16 action, bytes_remaining;
-       __le32 phase = NtLmNegotiate; /* NTLMSSP, if needed, is multistage */
-       u16 blob_len;
-       char *ntlmsspblob = NULL;
-       struct sess_data *sess_data;
+       char *bcc_ptr;
 
-       if (ses == NULL) {
-               WARN(1, "%s: ses == NULL!", __func__);
-               return -EINVAL;
+       pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
+       smb_buf = (struct smb_hdr *)pSMB;
+
+       capabilities = cifs_ssetup_hdr(ses, pSMB);
+       if ((pSMB->req.hdr.Flags2 & SMBFLG2_UNICODE) == 0) {
+               cifs_dbg(VFS, "NTLMSSP requires Unicode support\n");
+               return -ENOSYS;
        }
 
-       sess_data = kzalloc(sizeof(struct sess_data), GFP_KERNEL);
-       if (!sess_data)
-               return -ENOMEM;
-       sess_data->xid = xid;
-       sess_data->ses = ses;
-       sess_data->buf0_type = CIFS_NO_BUFFER;
-       sess_data->nls_cp = (struct nls_table *) nls_cp;
+       pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
+       capabilities |= CAP_EXTENDED_SECURITY;
+       pSMB->req.Capabilities |= cpu_to_le32(capabilities);
 
-       type = select_sectype(ses->server, ses->sectype);
-       cifs_dbg(FYI, "sess setup type %d\n", type);
-       if (type == Unspecified) {
-               cifs_dbg(VFS,
-                       "Unable to select appropriate authentication method!");
-               return -EINVAL;
+       bcc_ptr = sess_data->iov[2].iov_base;
+       /* unicode strings must be word aligned */
+       if ((sess_data->iov[0].iov_len + sess_data->iov[1].iov_len) % 2) {
+               *bcc_ptr = 0;
+               bcc_ptr++;
        }
+       unicode_oslm_strings(&bcc_ptr, sess_data->nls_cp);
 
-       switch (type) {
-       case LANMAN:
-               sess_auth_lanman(sess_data);
-               goto out;
-       case NTLM:
-               sess_auth_ntlm(sess_data);
-               goto out;
-       case NTLMv2:
-               sess_auth_ntlmv2(sess_data);
-               goto out;
-       case Kerberos:
-               sess_auth_kerberos(sess_data);
-               goto out;
-       default:
-               cifs_dbg(FYI, "Continuing with CIFS_SessSetup\n");
-       }
+       sess_data->iov[2].iov_len = (long) bcc_ptr -
+                                       (long) sess_data->iov[2].iov_base;
 
-       if (type == RawNTLMSSP) {
-               /* if memory allocation is successful, caller of this function
-                * frees it.
-                */
-               ses->ntlmssp = kmalloc(sizeof(struct ntlmssp_auth), GFP_KERNEL);
-               if (!ses->ntlmssp)
-                       return -ENOMEM;
-               ses->ntlmssp->sesskey_per_smbsess = false;
+       return 0;
+}
+
+static void
+sess_auth_rawntlmssp_authenticate(struct sess_data *sess_data);
+
+static void
+sess_auth_rawntlmssp_negotiate(struct sess_data *sess_data)
+{
+       int rc;
+       struct smb_hdr *smb_buf;
+       SESSION_SETUP_ANDX *pSMB;
+       struct cifs_ses *ses = sess_data->ses;
+       __u16 bytes_remaining;
+       char *bcc_ptr;
+       u16 blob_len;
+
+       cifs_dbg(FYI, "rawntlmssp session setup negotiate phase\n");
 
+       /*
+        * if memory allocation is successful, caller of this function
+        * frees it.
+        */
+       ses->ntlmssp = kmalloc(sizeof(struct ntlmssp_auth), GFP_KERNEL);
+       if (!ses->ntlmssp) {
+               rc = -ENOMEM;
+               goto out;
        }
+       ses->ntlmssp->sesskey_per_smbsess = false;
 
-ssetup_ntlmssp_authenticate:
-       if (phase == NtLmChallenge)
-               phase = NtLmAuthenticate; /* if ntlmssp, now final phase */
+       /* wct = 12 */
+       rc = sess_alloc_buffer(sess_data, 12);
+       if (rc)
+               goto out;
 
-       /* same size: negotiate or auth, NTLMSSP or extended security */
-       wct = 12;
+       pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
 
-       rc = small_smb_init_no_tc(SMB_COM_SESSION_SETUP_ANDX, wct, ses,
-                           (void **)&smb_buf);
+       /* Build security blob before we assemble the request */
+       build_ntlmssp_negotiate_blob(pSMB->req.SecurityBlob, ses);
+       sess_data->iov[1].iov_len = sizeof(NEGOTIATE_MESSAGE);
+       sess_data->iov[1].iov_base = pSMB->req.SecurityBlob;
+       pSMB->req.SecurityBlobLength = cpu_to_le16(sizeof(NEGOTIATE_MESSAGE));
+
+       rc = _sess_auth_rawntlmssp_assemble_req(sess_data);
        if (rc)
-               return rc;
+               goto out;
 
-       pSMB = (SESSION_SETUP_ANDX *)smb_buf;
+       rc = sess_sendreceive(sess_data);
 
-       capabilities = cifs_ssetup_hdr(ses, pSMB);
+       pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
+       smb_buf = (struct smb_hdr *)sess_data->iov[0].iov_base;
 
-       /* we will send the SMB in three pieces:
-       a fixed length beginning part, an optional
-       SPNEGO blob (which can be zero length), and a
-       last part which will include the strings
-       and rest of bcc area. This allows us to avoid
-       a large buffer 17K allocation */
-       iov[0].iov_base = (char *)pSMB;
-       iov[0].iov_len = be32_to_cpu(smb_buf->smb_buf_length) + 4;
-
-       /* setting this here allows the code at the end of the function
-          to free the request buffer if there's an error */
-       resp_buf_type = CIFS_SMALL_BUFFER;
+       /* If true, rc here is expected and not an error */
+       if (sess_data->buf0_type != CIFS_NO_BUFFER &&
+           smb_buf->Status.CifsError ==
+                       cpu_to_le32(NT_STATUS_MORE_PROCESSING_REQUIRED))
+               rc = 0;
 
-       /* 2000 big enough to fit max user, domain, NOS name etc. */
-       str_area = kmalloc(2000, GFP_KERNEL);
-       if (str_area == NULL) {
-               rc = -ENOMEM;
-               goto ssetup_exit;
+       if (rc)
+               goto out;
+
+       cifs_dbg(FYI, "rawntlmssp session setup challenge phase\n");
+
+       if (smb_buf->WordCount != 4) {
+               rc = -EIO;
+               cifs_dbg(VFS, "bad word count %d\n", smb_buf->WordCount);
+               goto out;
        }
-       bcc_ptr = str_area;
 
-       iov[1].iov_base = NULL;
-       iov[1].iov_len = 0;
+       ses->Suid = smb_buf->Uid;   /* UID left in wire format (le) */
+       cifs_dbg(FYI, "UID = %llu\n", ses->Suid);
 
-       if (type == RawNTLMSSP) {
-               if ((pSMB->req.hdr.Flags2 & SMBFLG2_UNICODE) == 0) {
-                       cifs_dbg(VFS, "NTLMSSP requires Unicode support\n");
-                       rc = -ENOSYS;
-                       goto ssetup_exit;
-               }
+       bytes_remaining = get_bcc(smb_buf);
+       bcc_ptr = pByteArea(smb_buf);
 
-               cifs_dbg(FYI, "ntlmssp session setup phase %d\n", phase);
-               pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
-               capabilities |= CAP_EXTENDED_SECURITY;
-               pSMB->req.Capabilities |= cpu_to_le32(capabilities);
-               switch(phase) {
-               case NtLmNegotiate:
-                       build_ntlmssp_negotiate_blob(
-                               pSMB->req.SecurityBlob, ses);
-                       iov[1].iov_len = sizeof(NEGOTIATE_MESSAGE);
-                       iov[1].iov_base = pSMB->req.SecurityBlob;
-                       pSMB->req.SecurityBlobLength =
-                               cpu_to_le16(sizeof(NEGOTIATE_MESSAGE));
-                       break;
-               case NtLmAuthenticate:
-                       /*
-                        * 5 is an empirical value, large enough to hold
-                        * authenticate message plus max 10 of av paris,
-                        * domain, user, workstation names, flags, etc.
-                        */
-                       ntlmsspblob = kzalloc(
-                               5*sizeof(struct _AUTHENTICATE_MESSAGE),
-                               GFP_KERNEL);
-                       if (!ntlmsspblob) {
-                               rc = -ENOMEM;
-                               goto ssetup_exit;
-                       }
+       blob_len = le16_to_cpu(pSMB->resp.SecurityBlobLength);
+       if (blob_len > bytes_remaining) {
+               cifs_dbg(VFS, "bad security blob length %d\n",
+                               blob_len);
+               rc = -EINVAL;
+               goto out;
+       }
 
-                       rc = build_ntlmssp_auth_blob(ntlmsspblob,
-                                               &blob_len, ses, nls_cp);
-                       if (rc)
-                               goto ssetup_exit;
-                       iov[1].iov_len = blob_len;
-                       iov[1].iov_base = ntlmsspblob;
-                       pSMB->req.SecurityBlobLength = cpu_to_le16(blob_len);
-                       /*
-                        * Make sure that we tell the server that we are using
-                        * the uid that it just gave us back on the response
-                        * (challenge)
-                        */
-                       smb_buf->Uid = ses->Suid;
-                       break;
-               default:
-                       cifs_dbg(VFS, "invalid phase %d\n", phase);
-                       rc = -ENOSYS;
-                       goto ssetup_exit;
-               }
-               /* unicode strings must be word aligned */
-               if ((iov[0].iov_len + iov[1].iov_len) % 2) {
-                       *bcc_ptr = 0;
-                       bcc_ptr++;
-               }
-               unicode_oslm_strings(&bcc_ptr, nls_cp);
-       } else {
-               cifs_dbg(VFS, "secType %d not supported!\n", type);
-               rc = -ENOSYS;
-               goto ssetup_exit;
+       rc = decode_ntlmssp_challenge(bcc_ptr, blob_len, ses);
+out:
+       sess_free_buffer(sess_data);
+
+       if (!rc) {
+               sess_data->func = sess_auth_rawntlmssp_authenticate;
+               return;
        }
 
-       iov[2].iov_base = str_area;
-       iov[2].iov_len = (long) bcc_ptr - (long) str_area;
+       /* Else error. Cleanup */
+       kfree(ses->auth_key.response);
+       ses->auth_key.response = NULL;
+       kfree(ses->ntlmssp);
+       ses->ntlmssp = NULL;
 
-       count = iov[1].iov_len + iov[2].iov_len;
-       smb_buf->smb_buf_length =
-               cpu_to_be32(be32_to_cpu(smb_buf->smb_buf_length) + count);
+       sess_data->func = NULL;
+       sess_data->result = rc;
+}
 
-       put_bcc(count, smb_buf);
+static void
+sess_auth_rawntlmssp_authenticate(struct sess_data *sess_data)
+{
+       int rc;
+       struct smb_hdr *smb_buf;
+       SESSION_SETUP_ANDX *pSMB;
+       struct cifs_ses *ses = sess_data->ses;
+       __u16 bytes_remaining;
+       char *bcc_ptr;
+       char *ntlmsspblob = NULL;
+       u16 blob_len;
 
-       rc = SendReceive2(xid, ses, iov, 3 /* num_iovecs */, &resp_buf_type,
-                         CIFS_LOG_ERROR);
-       /* SMB request buf freed in SendReceive2 */
+       cifs_dbg(FYI, "rawntlmssp session setup authenticate phase\n");
 
-       pSMB = (SESSION_SETUP_ANDX *)iov[0].iov_base;
-       smb_buf = (struct smb_hdr *)iov[0].iov_base;
+       /* wct = 12 */
+       rc = sess_alloc_buffer(sess_data, 12);
+       if (rc)
+               goto out;
 
-       if ((type == RawNTLMSSP) && (resp_buf_type != CIFS_NO_BUFFER) &&
-           (smb_buf->Status.CifsError ==
-                       cpu_to_le32(NT_STATUS_MORE_PROCESSING_REQUIRED))) {
-               if (phase != NtLmNegotiate) {
-                       cifs_dbg(VFS, "Unexpected more processing error\n");
-                       goto ssetup_exit;
-               }
-               /* NTLMSSP Negotiate sent now processing challenge (response) */
-               phase = NtLmChallenge; /* process ntlmssp challenge */
-               rc = 0; /* MORE_PROC rc is not an error here, but expected */
+       /* Build security blob before we assemble the request */
+       pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
+       smb_buf = (struct smb_hdr *)pSMB;
+       /*
+        * 5 is an empirical value, large enough to hold
+        * authenticate message plus max 10 of av paris,
+        * domain, user, workstation names, flags, etc.
+        */
+       ntlmsspblob = kzalloc(5*sizeof(struct _AUTHENTICATE_MESSAGE),
+                               GFP_KERNEL);
+       if (!ntlmsspblob) {
+               rc = -ENOMEM;
+               goto out;
        }
+
+       rc = build_ntlmssp_auth_blob(ntlmsspblob,
+                                       &blob_len, ses, sess_data->nls_cp);
+       if (rc)
+               goto out_free_ntlmsspblob;
+       sess_data->iov[1].iov_len = blob_len;
+       sess_data->iov[1].iov_base = ntlmsspblob;
+       pSMB->req.SecurityBlobLength = cpu_to_le16(blob_len);
+       /*
+        * Make sure that we tell the server that we are using
+        * the uid that it just gave us back on the response
+        * (challenge)
+        */
+       smb_buf->Uid = ses->Suid;
+
+       rc = _sess_auth_rawntlmssp_assemble_req(sess_data);
        if (rc)
-               goto ssetup_exit;
+               goto out_free_ntlmsspblob;
 
+       rc = sess_sendreceive(sess_data);
+       if (rc)
+               goto out_free_ntlmsspblob;
+
+       pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
+       smb_buf = (struct smb_hdr *)sess_data->iov[0].iov_base;
        if (smb_buf->WordCount != 4) {
                rc = -EIO;
                cifs_dbg(VFS, "bad word count %d\n", smb_buf->WordCount);
-               goto ssetup_exit;
+               goto out_free_ntlmsspblob;
        }
-       action = le16_to_cpu(pSMB->resp.Action);
-       if (action & GUEST_LOGIN)
+
+       if (le16_to_cpu(pSMB->resp.Action) & GUEST_LOGIN)
                cifs_dbg(FYI, "Guest login\n"); /* BB mark SesInfo struct? */
-       ses->Suid = smb_buf->Uid;   /* UID left in wire format (le) */
-       cifs_dbg(FYI, "UID = %llu\n", ses->Suid);
-       /* response can have either 3 or 4 word count - Samba sends 3 */
-       /* and lanman response is 3 */
+
        bytes_remaining = get_bcc(smb_buf);
        bcc_ptr = pByteArea(smb_buf);
-
        blob_len = le16_to_cpu(pSMB->resp.SecurityBlobLength);
        if (blob_len > bytes_remaining) {
                cifs_dbg(VFS, "bad security blob length %d\n",
-                        blob_len);
+                               blob_len);
                rc = -EINVAL;
-               goto ssetup_exit;
-       }
-       if (phase == NtLmChallenge) {
-               rc = decode_ntlmssp_challenge(bcc_ptr, blob_len, ses);
-               if (rc)
-                       goto ssetup_exit;
+               goto out_free_ntlmsspblob;
        }
        bcc_ptr += blob_len;
        bytes_remaining -= blob_len;
 
+
        /* BB check if Unicode and decode strings */
        if (bytes_remaining == 0) {
                /* no string area to decode, do nothing */

@@ -1357,61 +1341,113 @@ ssetup_ntlmssp_authenticate:
                        ++bcc_ptr;
                        --bytes_remaining;
                }
-               decode_unicode_ssetup(&bcc_ptr, bytes_remaining, ses, nls_cp);
+               decode_unicode_ssetup(&bcc_ptr, bytes_remaining, ses,
+                                     sess_data->nls_cp);
        } else {
-               decode_ascii_ssetup(&bcc_ptr, bytes_remaining, ses, nls_cp);
+               decode_ascii_ssetup(&bcc_ptr, bytes_remaining, ses,
+                                   sess_data->nls_cp);
        }
 
-ssetup_exit:
-       kfree(str_area);
+out_free_ntlmsspblob:
        kfree(ntlmsspblob);
-       ntlmsspblob = NULL;
-       if (resp_buf_type == CIFS_SMALL_BUFFER) {
-               cifs_dbg(FYI, "ssetup freeing small buf %p\n", iov[0].iov_base);
-               cifs_small_buf_release(iov[0].iov_base);
-       } else if (resp_buf_type == CIFS_LARGE_BUFFER)
-               cifs_buf_release(iov[0].iov_base);
-
-       /* if ntlmssp, and negotiate succeeded, proceed to authenticate phase */
-       if ((phase == NtLmChallenge) && (rc == 0))
-               goto ssetup_ntlmssp_authenticate;
-
-       if (!rc) {
-               mutex_lock(&ses->server->srv_mutex);
-               if (!ses->server->session_estab) {
-                       if (ses->server->sign) {
-                               ses->server->session_key.response =
-                                       kmemdup(ses->auth_key.response,
-                                       ses->auth_key.len, GFP_KERNEL);
-                               if (!ses->server->session_key.response) {
-                                       rc = -ENOMEM;
-                                       mutex_unlock(&ses->server->srv_mutex);
-                                       goto keycp_exit;
-                               }
-                               ses->server->session_key.len =
-                                                       ses->auth_key.len;
-                       }
-                       ses->server->sequence_number = 0x2;
-                       ses->server->session_estab = true;
-               }
-               mutex_unlock(&ses->server->srv_mutex);
+out:
+       sess_free_buffer(sess_data);
 
-               cifs_dbg(FYI, "CIFS session established successfully\n");
-               spin_lock(&GlobalMid_Lock);
-               ses->status = CifsGood;
-               ses->need_reconnect = false;
-               spin_unlock(&GlobalMid_Lock);
-       }
+        if (!rc)
+               rc = sess_establish_session(sess_data);
 
-keycp_exit:
+       /* Cleanup */
        kfree(ses->auth_key.response);
        ses->auth_key.response = NULL;
        kfree(ses->ntlmssp);
+       ses->ntlmssp = NULL;
 
-       return rc;
+       sess_data->func = NULL;
+       sess_data->result = rc;
+}
 
-out:
+int select_sec(struct cifs_ses *ses, struct sess_data *sess_data)
+{
+       int type;
+
+       type = select_sectype(ses->server, ses->sectype);
+       cifs_dbg(FYI, "sess setup type %d\n", type);
+       if (type == Unspecified) {
+               cifs_dbg(VFS,
+                       "Unable to select appropriate authentication method!");
+               return -EINVAL;
+       }
+
+       switch (type) {
+       case LANMAN:
+               /* LANMAN and plaintext are less secure and off by default.
+                * So we make this explicitly be turned on in kconfig (in the
+                * build) and turned on at runtime (changed from the default)
+                * in proc/fs/cifs or via mount parm.  Unfortunately this is
+                * needed for old Win (e.g. Win95), some obscure NAS and OS/2 */
+#ifdef CONFIG_CIFS_WEAK_PW_HASH
+               sess_data->func = sess_auth_lanman;
+               break;
+#else
+               return -EOPNOTSUPP;
+#endif
+       case NTLM:
+               sess_data->func = sess_auth_ntlm;
+               break;
+       case NTLMv2:
+               sess_data->func = sess_auth_ntlmv2;
+               break;
+       case Kerberos:
+#ifdef CONFIG_CIFS_UPCALL
+               sess_data->func = sess_auth_kerberos;
+               break;
+#else
+               cifs_dbg(VFS, "Kerberos negotiated but upcall support disabled!\n");
+               return -ENOSYS;
+               break;
+#endif /* CONFIG_CIFS_UPCALL */
+       case RawNTLMSSP:
+               sess_data->func = sess_auth_rawntlmssp_negotiate;
+               break;
+       default:
+               cifs_dbg(VFS, "secType %d not supported!\n", type);
+               return -ENOSYS;
+       }
+
+       return 0;
+}
+
+int CIFS_SessSetup(const unsigned int xid, struct cifs_ses *ses,
+                   const struct nls_table *nls_cp)
+{
+       int rc = 0;
+       struct sess_data *sess_data;
+
+       if (ses == NULL) {
+               WARN(1, "%s: ses == NULL!", __func__);
+               return -EINVAL;
+       }
+
+       sess_data = kzalloc(sizeof(struct sess_data), GFP_KERNEL);
+       if (!sess_data)
+               return -ENOMEM;
+
+       rc = select_sec(ses, sess_data);
+       if (rc)
+               goto out;
+
+       sess_data->xid = xid;
+       sess_data->ses = ses;
+       sess_data->buf0_type = CIFS_NO_BUFFER;
+       sess_data->nls_cp = (struct nls_table *) nls_cp;
+
+       while (sess_data->func)
+               sess_data->func(sess_data);
+
+       /* Store result before we free sess_data */
        rc = sess_data->result;
+
+out:
        kfree(sess_data);
        return rc;
 }
--

1.9.3

Quoted 4 lines

--
To unsubscribe from this list: send the line "unsubscribe linux-cifs" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html

--
To unsubscribe from this list: send the line "unsubscribe linux-cifs" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html