// SPDX-License-Identifier: GPL-2.0-or-later /* * Copyright (C) 2016 Namjae Jeon <linkinjeon@kernel.org> * Copyright (C) 2018 Samsung Electronics Co., Ltd. #include <linux/inetdevice.h>#include <net/addrconf.h>#include <linux/syscalls.h>#include <linux/namei.h>#include <linux/statfs.h>#include <linux/ethtool.h>#include <linux/falloc.h>#include <linux/mount.h>#include <linux/filelock.h>#include "glob.h" #include "smbfsctl.h" #include "oplock.h" #include "smbacl.h" #include "auth.h" #include "asn1.h" #include "connection.h" #include "transport_ipc.h" #include "transport_rdma.h" #include "vfs.h" #include "vfs_cache.h" #include "misc.h" #include "server.h" #include "smb_common.h" #include "../common/smb2status.h" #include "ksmbd_work.h" #include "mgmt/user_config.h" #include "mgmt/share_config.h" #include "mgmt/tree_connect.h" #include "mgmt/user_session.h" #include "mgmt/ksmbd_ida.h" #include "ndr.h" #include "transport_tcp.h" static void __wbuf(struct ksmbd_work *work, void **req, void **rsp)if (work->next_smb2_rcv_hdr_off) {else {#define WORK_BUFFERS(w, rq, rs) __wbuf((w), (void **)&(rq), (void **)&(rs))/** * check_session_id() - check for valid session id in smb header * @conn: connection instance * @id: session id from smb header * * Return: 1 if valid session id, otherwise 0 static inline bool check_session_id(struct ksmbd_conn *conn, u64 id)struct ksmbd_session *sess;if (id == 0 || id == -1)return false ;if (sess) {return true ;"Invalid user session id: %llu\n" , id);return false ;struct channel *lookup_chann_list(struct ksmbd_session *sess, struct ksmbd_conn *conn)return xa_load(&sess->ksmbd_chann_list, (long )conn);/** * smb2_get_ksmbd_tcon() - get tree connection information using a tree id. * @work: smb work * * Return: 0 if there is a tree connection matched or these are * skipable commands, otherwise error int smb2_get_ksmbd_tcon(struct ksmbd_work *work)struct smb2_hdr *req_hdr = ksmbd_req_buf_next(work);unsigned int cmd = le16_to_cpu(req_hdr->Command);unsigned int tree_id;if (cmd == SMB2_TREE_CONNECT_HE ||"skip to check tree connect request\n" );return 0;if (xa_empty(&work->sess->tree_conns)) {"NO tree connected\n" );return -ENOENT;/* * If request is not the first in Compound request, * Just validate tree id in header with work->tcon->id. if (work->next_smb2_rcv_hdr_off) {if (!work->tcon) {"The first operation in the compound does not have tcon\n" );return -EINVAL;if (tree_id != UINT_MAX && work->tcon->id != tree_id) {"tree id(%u) is different with id(%u) in first operation\n" ,return -EINVAL;return 1;if (!work->tcon) {"Invalid tid %d\n" , tree_id);return -ENOENT;return 1;/** * smb2_set_err_rsp() - set error response code on smb response * @work: smb work containing response buffer void smb2_set_err_rsp(struct ksmbd_work *work)struct smb2_err_rsp *err_rsp;if (work->next_smb2_rcv_hdr_off)else if (err_rsp->hdr.Status != STATUS_STOPPED_ON_SYMLINK) {int err;void *)err_rsp,if (err)/** * is_smb2_neg_cmd() - is it smb2 negotiation command * @work: smb work containing smb header * * Return: true if smb2 negotiation command, otherwise false bool is_smb2_neg_cmd(struct ksmbd_work *work)struct smb2_hdr *hdr = smb2_get_msg(work->request_buf);/* is it SMB2 header ? */ if (hdr->ProtocolId != SMB2_PROTO_NUMBER)return false ;/* make sure it is request not response message */ if (hdr->Flags & SMB2_FLAGS_SERVER_TO_REDIR)return false ;if (hdr->Command != SMB2_NEGOTIATE)return false ;return true ;/** * is_smb2_rsp() - is it smb2 response * @work: smb work containing smb response buffer * * Return: true if smb2 response, otherwise false bool is_smb2_rsp(struct ksmbd_work *work)struct smb2_hdr *hdr = smb2_get_msg(work->response_buf);/* is it SMB2 header ? */ if (hdr->ProtocolId != SMB2_PROTO_NUMBER)return false ;/* make sure it is response not request message */ if (!(hdr->Flags & SMB2_FLAGS_SERVER_TO_REDIR))return false ;return true ;/** * get_smb2_cmd_val() - get smb command code from smb header * @work: smb work containing smb request buffer * * Return: smb2 request command value struct ksmbd_work *work)struct smb2_hdr *rcv_hdr;if (work->next_smb2_rcv_hdr_off)else return le16_to_cpu(rcv_hdr->Command);/** * set_smb2_rsp_status() - set error response code on smb2 header * @work: smb work containing response buffer * @err: error response code void set_smb2_rsp_status(struct ksmbd_work *work, __le32 err)struct smb2_hdr *rsp_hdr;/** * init_smb2_neg_rsp() - initialize smb2 response for negotiate command * @work: smb work containing smb request buffer * * smb2 negotiate response is sent in reply of smb1 negotiate command for * dialect auto-negotiation. int init_smb2_neg_rsp(struct ksmbd_work *work)struct smb2_hdr *rsp_hdr;struct smb2_negotiate_rsp *rsp;struct ksmbd_conn *conn = work->conn;int err;sizeof (struct smb2_hdr) + 2);"conn->dialect 0x%x\n" , conn->dialect);/* Not setting conn guid rsp->ServerGUID, as it * not used by client for identifying connection /* Default Max Message Size till SMB2.0, 64K*/ char *)(&rsp->hdr) +if (server_conf.signing == KSMBD_CONFIG_OPT_MANDATORY)sizeof (struct smb2_negotiate_rsp) + AUTH_GSS_LENGTH);if (err)return err;true ;return 0;/** * smb2_set_rsp_credits() - set number of credits in response buffer * @work: smb work containing smb response buffer int smb2_set_rsp_credits(struct ksmbd_work *work)struct smb2_hdr *req_hdr = ksmbd_req_buf_next(work);struct smb2_hdr *hdr = ksmbd_resp_buf_next(work);struct ksmbd_conn *conn = work->conn;unsigned short credits_requested, aux_max;unsigned short credit_charge, credits_granted = 0;if (work->send_no_response)return 0;if (conn->total_credits > conn->vals->max_credits) {"Total credits overflow: %d\n" , conn->total_credits);return -EINVAL;unsigned short ,if (credit_charge > conn->total_credits) {"Insufficient credits granted, given: %u, granted: %u\n" ,return -EINVAL;unsigned short ,/* according to smb2.credits smbtorture, Windows server * 2016 or later grant up to 8192 credits at once. * * TODO: Need to adjuct CreditRequest value according to * current cpu load if (hdr->Command == SMB2_NEGOTIATE)else unsigned short , credits_requested, aux_max);if (!req_hdr->NextCommand) {/* Update CreditRequest in last request */ "credits: requested[%d] granted[%d] total_granted[%d]\n" ,return 0;/** * init_chained_smb2_rsp() - initialize smb2 chained response * @work: smb work containing smb response buffer static void init_chained_smb2_rsp(struct ksmbd_work *work)struct smb2_hdr *req = ksmbd_req_buf_next(work);struct smb2_hdr *rsp = ksmbd_resp_buf_next(work);struct smb2_hdr *rsp_hdr;struct smb2_hdr *rcv_hdr;int next_hdr_offset = 0;int len, new_len;/* Len of this response = updated RFC len - offset of previous cmd * in the compound rsp /* Storing the current local FID which may be needed by subsequent * command in the compound request if (req->Command == SMB2_CREATE && rsp->Status == STATUS_SUCCESS) {struct smb2_create_rsp *)rsp)->VolatileFileId;struct smb2_create_rsp *)rsp)->PersistentFileId;"Compound req new_len = %d rcv off = %d rsp off = %d\n" ,if (!(rcv_hdr->Flags & SMB2_FLAGS_RELATED_OPERATIONS)) {"related flag should be set\n" );char *)rsp_hdr, 0, sizeof (struct smb2_hdr) + 2);/* * Message is response. We don't grant oplock yet. /** * is_chained_smb2_message() - check for chained command * @work: smb work containing smb request buffer * * Return: true if chained request, otherwise false bool is_chained_smb2_message(struct ksmbd_work *work)struct smb2_hdr *hdr = smb2_get_msg(work->request_buf);unsigned int len, next_cmd;if (hdr->ProtocolId != SMB2_PROTO_NUMBER)return false ;if (next_cmd > 0) {if ((u64)work->next_smb2_rcv_hdr_off + next_cmd +"next command(%u) offset exceeds smb msg size\n" ,return false ;if ((u64)get_rfc1002_len(work->response_buf) + MAX_CIFS_SMALL_BUFFER_SIZE >"next response offset exceeds response buffer size\n" );return false ;"got SMB2 chained command\n" );return true ;else if (work->next_smb2_rcv_hdr_off) {/* * This is last request in chained command, * align response to 8 byte if (len) {"padding len %u\n" , len);return false ;/** * init_smb2_rsp_hdr() - initialize smb2 response * @work: smb work containing smb request buffer * * Return: 0 int init_smb2_rsp_hdr(struct ksmbd_work *work)struct smb2_hdr *rsp_hdr = smb2_get_msg(work->response_buf);struct smb2_hdr *rcv_hdr = smb2_get_msg(work->request_buf);sizeof (struct smb2_hdr) + 2);/* * Message is response. We don't grant oplock yet. return 0;/** * smb2_allocate_rsp_buf() - allocate smb2 response buffer * @work: smb work containing smb request buffer * * Return: 0 on success, otherwise error int smb2_allocate_rsp_buf(struct ksmbd_work *work)struct smb2_hdr *hdr = smb2_get_msg(work->request_buf);int cmd = le16_to_cpu(hdr->Command);if (cmd == SMB2_IOCTL_HE || cmd == SMB2_QUERY_DIRECTORY_HE)if (cmd == SMB2_QUERY_INFO_HE) {struct smb2_query_info_req *req;if (get_rfc1002_len(work->request_buf) <struct smb2_query_info_req, OutputBufferLength))return -EINVAL;if ((req->InfoType == SMB2_O_INFO_FILE &&/* allocate large response buf for chained commands */ if (le32_to_cpu(hdr->NextCommand) > 0)if (!work->response_buf)return -ENOMEM;return 0;/** * smb2_check_user_session() - check for valid session for a user * @work: smb work containing smb request buffer * * Return: 0 on success, otherwise error int smb2_check_user_session(struct ksmbd_work *work)struct smb2_hdr *req_hdr = ksmbd_req_buf_next(work);struct ksmbd_conn *conn = work->conn;unsigned int cmd = le16_to_cpu(req_hdr->Command);unsigned long long sess_id;/* * SMB2_ECHO, SMB2_NEGOTIATE, SMB2_SESSION_SETUP command do not * require a session id, so no need to validate user session's for * these commands. if (cmd == SMB2_ECHO_HE || cmd == SMB2_NEGOTIATE_HE ||return 0;if (!ksmbd_conn_good(conn))return -EIO;/* * If request is not the first in Compound request, * Just validate session id in header with work->sess->id. if (work->next_smb2_rcv_hdr_off) {if (!work->sess) {"The first operation in the compound does not have sess\n" );return -EINVAL;if (sess_id != ULLONG_MAX && work->sess->id != sess_id) {"session id(%llu) is different with the first operation(%lld)\n" ,return -EINVAL;return 1;/* Check for validity of user session */ if (work->sess)return 1;"Invalid user session, Uid %llu\n" , sess_id);return -ENOENT;/** * smb2_get_name() - get filename string from on the wire smb format * @src: source buffer * @maxlen: maxlen of source string * @local_nls: nls_table pointer * * Return: matching converted filename on success, otherwise error ptr static char *const char *src, const int maxlen, struct nls_table *local_nls)char *name;if (IS_ERR(name)) {"failed to get name %ld\n" , PTR_ERR(name));return name;if (*name == '\0' ) {return ERR_PTR(-EINVAL);if (*name == '\\' ) {"not allow directory name included leading slash\n" );return ERR_PTR(-EINVAL);return name;int setup_async_work(struct ksmbd_work *work, void (*fn)(void **), void **arg)struct ksmbd_conn *conn = work->conn;int id;if (id < 0) {"Failed to alloc async message id\n" );return id;true ;"Send interim Response to inform async request id : %d\n" ,if (list_empty(&work->async_request_entry)) {return 0;void release_async_work(struct ksmbd_work *work)struct ksmbd_conn *conn = work->conn;if (work->async_id) {void smb2_send_interim_resp(struct ksmbd_work *work, __le32 status)struct smb2_hdr *rsp_hdr;struct ksmbd_work *in_work = ksmbd_alloc_work_struct();if (!in_work)return ;if (allocate_interim_rsp_buf(in_work)) {"smb_allocate_rsp_buf failed!\n" );return ;static __le32 smb2_get_reparse_tag_special_file(umode_t mode)if (S_ISDIR(mode) || S_ISREG(mode))return 0;if (S_ISLNK(mode))return IO_REPARSE_TAG_LX_SYMLINK_LE;else if (S_ISFIFO(mode))return IO_REPARSE_TAG_LX_FIFO_LE;else if (S_ISSOCK(mode))return IO_REPARSE_TAG_AF_UNIX_LE;else if (S_ISCHR(mode))return IO_REPARSE_TAG_LX_CHR_LE;else if (S_ISBLK(mode))return IO_REPARSE_TAG_LX_BLK_LE;return 0;/** * smb2_get_dos_mode() - get file mode in dos format from unix mode * @stat: kstat containing file mode * @attribute: attribute flags * * Return: converted dos mode static int smb2_get_dos_mode(struct kstat *stat, int attribute)int attr = 0;if (S_ISDIR(stat->mode)) {else {if (S_ISREG(stat->mode) && (server_conf.share_fake_fscaps &if (smb2_get_reparse_tag_special_file(stat->mode))return attr;static void build_preauth_ctxt(struct smb2_preauth_neg_context *pneg_ctxt,static void build_encrypt_ctxt(struct smb2_encryption_neg_context *pneg_ctxt,static void build_sign_cap_ctxt(struct smb2_signing_capabilities *pneg_ctxt,sizeof (struct smb2_signing_capabilities) + 2)sizeof (struct smb2_neg_context));static void build_posix_ctxt(struct smb2_posix_neg_context *pneg_ctxt)/* SMB2_CREATE_TAG_POSIX is "0x93AD25509CB411E7B42383DE968BCD7C" */ static unsigned int assemble_neg_contexts(struct ksmbd_conn *conn,struct smb2_negotiate_rsp *rsp)char * const pneg_ctxt = (char *)rsp +int neg_ctxt_cnt = 1;int ctxt_size;"assemble SMB2_PREAUTH_INTEGRITY_CAPABILITIES context\n" );struct smb2_preauth_neg_context *)pneg_ctxt,sizeof (struct smb2_preauth_neg_context);if (conn->cipher_type) {/* Round to 8 byte boundary */ "assemble SMB2_ENCRYPTION_CAPABILITIES context\n" );struct smb2_encryption_neg_context *)sizeof (struct smb2_encryption_neg_context) + 2;/* compression context not yet supported */ if (conn->posix_ext_supported) {"assemble SMB2_POSIX_EXTENSIONS_AVAILABLE context\n" );struct smb2_posix_neg_context *)sizeof (struct smb2_posix_neg_context);if (conn->signing_negotiated) {"assemble SMB2_SIGNING_CAPABILITIES context\n" );struct smb2_signing_capabilities *)sizeof (struct smb2_signing_capabilities) + 2;return ctxt_size + AUTH_GSS_PADDING;static __le32 decode_preauth_ctxt(struct ksmbd_conn *conn,struct smb2_preauth_neg_context *pneg_ctxt,int ctxt_len)/* * sizeof(smb2_preauth_neg_context) assumes SMB311_SALT_SIZE Salt, * which may not be present. Only check for used HashAlgorithms[1]. if (ctxt_len <sizeof (struct smb2_neg_context) + MIN_PREAUTH_CTXT_DATA_LEN)return STATUS_INVALID_PARAMETER;if (pneg_ctxt->HashAlgorithms != SMB2_PREAUTH_INTEGRITY_SHA512)return STATUS_NO_PREAUTH_INTEGRITY_HASH_OVERLAP;return STATUS_SUCCESS;static void decode_encrypt_ctxt(struct ksmbd_conn *conn,struct smb2_encryption_neg_context *pneg_ctxt,int ctxt_len)int cph_cnt;int i, cphs_size;if (sizeof (struct smb2_encryption_neg_context) > ctxt_len) {"Invalid SMB2_ENCRYPTION_CAPABILITIES context size\n" );return ;sizeof (__le16);if (sizeof (struct smb2_encryption_neg_context) + cphs_size >"Invalid cipher count(%d)\n" , cph_cnt);return ;if (server_conf.flags & KSMBD_GLOBAL_FLAG_SMB2_ENCRYPTION_OFF)return ;for (i = 0; i < cph_cnt; i++) {if (pneg_ctxt->Ciphers[i] == SMB2_ENCRYPTION_AES128_GCM ||"Cipher ID = 0x%x\n" ,break ;/** * smb3_encryption_negotiated() - checks if server and client agreed on enabling encryption * @conn: smb connection * * Return: true if connection should be encrypted, else false bool smb3_encryption_negotiated(struct ksmbd_conn *conn)if (!conn->ops->generate_encryptionkey)return false ;/* * SMB 3.0 and 3.0.2 dialects use the SMB2_GLOBAL_CAP_ENCRYPTION flag. * SMB 3.1.1 uses the cipher_type field. return (conn->vals->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION) ||static void decode_compress_ctxt(struct ksmbd_conn *conn,struct smb2_compression_capabilities_context *pneg_ctxt)static void decode_sign_cap_ctxt(struct ksmbd_conn *conn,struct smb2_signing_capabilities *pneg_ctxt,int ctxt_len)int sign_algo_cnt;int i, sign_alos_size;if (sizeof (struct smb2_signing_capabilities) > ctxt_len) {"Invalid SMB2_SIGNING_CAPABILITIES context length\n" );return ;false ;sizeof (__le16);if (sizeof (struct smb2_signing_capabilities) + sign_alos_size >"Invalid signing algorithm count(%d)\n" , sign_algo_cnt);return ;for (i = 0; i < sign_algo_cnt; i++) {if (pneg_ctxt->SigningAlgorithms[i] == SIGNING_ALG_HMAC_SHA256_LE ||"Signing Algorithm ID = 0x%x\n" ,true ;break ;static __le32 deassemble_neg_contexts(struct ksmbd_conn *conn,struct smb2_negotiate_req *req,unsigned int len_of_smb)/* +4 is to account for the RFC1001 len field */ struct smb2_neg_context *pctx = (struct smb2_neg_context *)req;int i = 0, len_of_ctxts;unsigned int offset = le32_to_cpu(req->NegotiateContextOffset);unsigned int neg_ctxt_cnt = le16_to_cpu(req->NegotiateContextCount);"decoding %d negotiate contexts\n" , neg_ctxt_cnt);if (len_of_smb <= offset) {"Invalid response: negotiate context offset\n" );return status;while (i++ < neg_ctxt_cnt) {int clen, ctxt_len;if (len_of_ctxts < (int )sizeof (struct smb2_neg_context))break ;struct smb2_neg_context *)((char *)pctx + offset);sizeof (struct smb2_neg_context);if (ctxt_len > len_of_ctxts)break ;if (pctx->ContextType == SMB2_PREAUTH_INTEGRITY_CAPABILITIES) {"deassemble SMB2_PREAUTH_INTEGRITY_CAPABILITIES context\n" );if (conn->preauth_info->Preauth_HashId)break ;struct smb2_preauth_neg_context *)pctx,if (status != STATUS_SUCCESS)break ;else if (pctx->ContextType == SMB2_ENCRYPTION_CAPABILITIES) {"deassemble SMB2_ENCRYPTION_CAPABILITIES context\n" );if (conn->cipher_type)break ;struct smb2_encryption_neg_context *)pctx,else if (pctx->ContextType == SMB2_COMPRESSION_CAPABILITIES) {"deassemble SMB2_COMPRESSION_CAPABILITIES context\n" );if (conn->compress_algorithm)break ;struct smb2_compression_capabilities_context *)pctx);else if (pctx->ContextType == SMB2_NETNAME_NEGOTIATE_CONTEXT_ID) {"deassemble SMB2_NETNAME_NEGOTIATE_CONTEXT_ID context\n" );else if (pctx->ContextType == SMB2_POSIX_EXTENSIONS_AVAILABLE) {"deassemble SMB2_POSIX_EXTENSIONS_AVAILABLE context\n" );true ;else if (pctx->ContextType == SMB2_SIGNING_CAPABILITIES) {"deassemble SMB2_SIGNING_CAPABILITIES context\n" );struct smb2_signing_capabilities *)pctx,/* offsets must be 8 byte aligned */ return status;/** * smb2_handle_negotiate() - handler for smb2 negotiate command * @work: smb work containing smb request buffer * * Return: 0 int smb2_handle_negotiate(struct ksmbd_work *work)struct ksmbd_conn *conn = work->conn;struct smb2_negotiate_req *req = smb2_get_msg(work->request_buf);struct smb2_negotiate_rsp *rsp = smb2_get_msg(work->response_buf);int rc = 0;unsigned int smb2_buf_len, smb2_neg_size, neg_ctxt_len = 0;"Received negotiate request\n" );false ;if (ksmbd_conn_good(conn)) {"conn->tcp_status is already in CifsGood State\n" );return rc;struct smb2_negotiate_req, Dialects);if (smb2_neg_size > smb2_buf_len) {goto err_out;if (req->DialectCount == 0) {"malformed packet\n" );goto err_out;if (conn->dialect == SMB311_PROT_ID) {unsigned int nego_ctxt_off = le32_to_cpu(req->NegotiateContextOffset);if (smb2_buf_len < nego_ctxt_off) {goto err_out;if (smb2_neg_size > nego_ctxt_off) {goto err_out;if (smb2_neg_size + le16_to_cpu(req->DialectCount) * sizeof (__le16) >goto err_out;else {if (smb2_neg_size + le16_to_cpu(req->DialectCount) * sizeof (__le16) >goto err_out;switch (conn->dialect) {case SMB311_PROT_ID:sizeof (struct preauth_integrity_info),if (!conn->preauth_info) {goto err_out;if (status != STATUS_SUCCESS) {"deassemble_neg_contexts error(0x%x)\n" ,goto err_out;if (rc < 0) {goto err_out;break ;case SMB302_PROT_ID:break ;case SMB30_PROT_ID:break ;case SMB21_PROT_ID:break ;case SMB2X_PROT_ID:case BAD_PROT_ID:default :"Server dialect :0x%x not supported\n" ,goto err_out;/* For stats */ /* Not setting conn guid rsp->ServerGUID, as it * not used by client for identifying server "negotiate context offset %d, count %d\n" ,char *)(&rsp->hdr) +true ;if ((server_conf.signing == KSMBD_CONFIG_OPT_AUTO ||true ;else if (server_conf.signing == KSMBD_CONFIG_OPT_MANDATORY) {true ;true ;if (rc)if (!rc)sizeof (struct smb2_negotiate_rsp) +if (rc < 0)return rc;static int alloc_preauth_hash(struct ksmbd_session *sess,struct ksmbd_conn *conn)if (sess->Preauth_HashValue)return 0;if (!conn->preauth_info)return -ENOMEM;if (!sess->Preauth_HashValue)return -ENOMEM;return 0;static int generate_preauth_hash(struct ksmbd_work *work)struct ksmbd_conn *conn = work->conn;struct ksmbd_session *sess = work->sess;if (conn->dialect != SMB311_PROT_ID)return 0;if (conn->binding) {struct preauth_session *preauth_sess;if (!preauth_sess) {if (!preauth_sess)return -ENOMEM;else {if (!sess->Preauth_HashValue)if (alloc_preauth_hash(sess, conn))return -ENOMEM;return 0;static int decode_negotiation_token(struct ksmbd_conn *conn,struct negotiate_message *negblob,if (!conn->use_spnego)return -EINVAL;if (ksmbd_decode_negTokenInit((char *)negblob, sz, conn)) {if (ksmbd_decode_negTokenTarg((char *)negblob, sz, conn)) {false ;return 0;static int ntlm_negotiate(struct ksmbd_work *work,struct negotiate_message *negblob,struct smb2_sess_setup_rsp *rsp)struct challenge_message *chgblob;unsigned char *spnego_blob = NULL;char *neg_blob;int sz, rc;"negotiate phase\n" );if (rc)return rc;struct challenge_message *)rsp->Buffer;sizeof (struct challenge_message));if (!work->conn->use_spnego) {if (sz < 0)return -ENOMEM;return 0;sizeof (struct challenge_message);if (!neg_blob)return -ENOMEM;struct challenge_message *)neg_blob;if (sz < 0) {goto out;if (rc) {goto out;return rc;static struct authenticate_message *user_authblob(struct ksmbd_conn *conn,struct smb2_sess_setup_req *req)int sz;if (conn->use_spnego && conn->mechToken)return (struct authenticate_message *)conn->mechToken;return (struct authenticate_message *)((char *)&req->hdr.ProtocolIdstatic struct ksmbd_user *session_user(struct ksmbd_conn *conn,struct smb2_sess_setup_req *req)struct authenticate_message *authblob;struct ksmbd_user *user;char *name;unsigned int name_off, name_len, secbuf_len;if (conn->use_spnego && conn->mechToken)else if (secbuf_len < sizeof (struct authenticate_message)) {"blob len %d too small\n" , secbuf_len);return NULL;if (secbuf_len < (u64)name_off + name_len)return NULL;const char *)authblob + name_off,true ,if (IS_ERR(name)) {"cannot allocate memory\n" );return NULL;"session setup request for user %s\n" , name);return user;static int ntlm_authenticate(struct ksmbd_work *work,struct smb2_sess_setup_req *req,struct smb2_sess_setup_rsp *rsp)struct ksmbd_conn *conn = work->conn;struct ksmbd_session *sess = work->sess;struct channel *chann = NULL, *old;struct ksmbd_user *user;int sz, rc;"authenticate phase\n" );if (conn->use_spnego) {unsigned char *spnego_blob;if (rc)return -ENOMEM;if (!user) {"Unknown user name or an error\n" );return -EPERM;/* Check for previous session */ if (prev_id && prev_id != sess->id)if (sess->state == SMB2_SESSION_VALID) {/* * Reuse session if anonymous try to connect * on reauthetication. if (conn->binding == false && ksmbd_anonymous_user(user)) {return 0;if (!ksmbd_compare_user(sess->user, user)) {return -EPERM;else {if (conn->binding == false && user_guest(sess->user)) {else {struct authenticate_message *authblob;if (conn->use_spnego && conn->mechToken)else if (rc) {"authentication failed\n" );return -EPERM;/* * If session state is SMB2_SESSION_VALID, We can assume * that it is reauthentication. And the user/password * has been verified, so return it here. if (sess->state == SMB2_SESSION_VALID) {if (conn->binding)goto binding_session;return 0;if ((rsp->SessionFlags != SMB2_SESSION_FLAG_IS_GUEST_LE &&true ;if (smb3_encryption_negotiated(conn) &&if (rc) {"SMB3 encryption key generation failed\n" );return -EINVAL;true ;if (server_conf.flags & KSMBD_GLOBAL_FLAG_SMB2_ENCRYPTION)/* * signing is disable if encryption is enable * on this session false ;if (conn->dialect >= SMB30_PROT_ID) {if (!chann) {sizeof (struct channel), KSMBD_DEFAULT_GFP);if (!chann)return -ENOMEM;long )conn, chann,if (xa_is_err(old)) {return xa_err(old);if (conn->ops->generate_signingkey) {if (rc) {"SMB3 signing key generation failed\n" );return -EINVAL;if (!ksmbd_conn_lookup_dialect(conn)) {"fail to verify the dialect\n" );return -ENOENT;return 0;#ifdef CONFIG_SMB_SERVER_KERBEROS5static int krb5_authenticate(struct ksmbd_work *work,struct smb2_sess_setup_req *req,struct smb2_sess_setup_rsp *rsp)struct ksmbd_conn *conn = work->conn;struct ksmbd_session *sess = work->sess;char *in_blob, *out_blob;struct channel *chann = NULL, *old;int in_len, out_len;int retval;char *)&req->hdr.ProtocolId +char *)&rsp->hdr.ProtocolId +if (retval) {"krb5 authentication failed\n" );return -EINVAL;/* Check previous session */ if (prev_sess_id && prev_sess_id != sess->id)/* * If session state is SMB2_SESSION_VALID, We can assume * that it is reauthentication. And the user/password * has been verified, so return it here. if (sess->state == SMB2_SESSION_VALID) {if (conn->binding)goto binding_session;return 0;if ((rsp->SessionFlags != SMB2_SESSION_FLAG_IS_GUEST_LE &&true ;if (smb3_encryption_negotiated(conn) &&if (retval) {"SMB3 encryption key generation failed\n" );return -EINVAL;true ;if (server_conf.flags & KSMBD_GLOBAL_FLAG_SMB2_ENCRYPTION)false ;if (conn->dialect >= SMB30_PROT_ID) {if (!chann) {sizeof (struct channel), KSMBD_DEFAULT_GFP);if (!chann)return -ENOMEM;long )conn,if (xa_is_err(old)) {return xa_err(old);if (conn->ops->generate_signingkey) {if (retval) {"SMB3 signing key generation failed\n" );return -EINVAL;if (!ksmbd_conn_lookup_dialect(conn)) {"fail to verify the dialect\n" );return -ENOENT;return 0;#else static int krb5_authenticate(struct ksmbd_work *work,struct smb2_sess_setup_req *req,struct smb2_sess_setup_rsp *rsp)return -EOPNOTSUPP;#endif int smb2_sess_setup(struct ksmbd_work *work)struct ksmbd_conn *conn = work->conn;struct smb2_sess_setup_req *req;struct smb2_sess_setup_rsp *rsp;struct ksmbd_session *sess;struct negotiate_message *negblob;unsigned int negblob_len, negblob_off;int rc = 0;"Received smb2 session setup request\n" );if (!ksmbd_conn_need_setup(conn) && !ksmbd_conn_good(conn)) {return rc;if (!req->hdr.SessionId) {if (!sess) {goto out_err;if (rc)goto out_err;false ;else if (conn->dialect >= SMB30_PROT_ID &&if (!sess) {goto out_err;if (conn->dialect != sess->dialect) {goto out_err;if (!(req->hdr.Flags & SMB2_FLAGS_SIGNED)) {goto out_err;if (strncmp(conn->ClientGUID, sess->ClientGUID,goto out_err;if (sess->state == SMB2_SESSION_IN_PROGRESS) {goto out_err;if (sess->state == SMB2_SESSION_EXPIRED) {goto out_err;if (ksmbd_conn_need_reconnect(conn)) {goto out_err;if (is_ksmbd_session_in_connection(conn, sess_id)) {goto out_err;if (user_guest(sess->user)) {goto out_err;true ;else if ((conn->dialect < SMB30_PROT_ID ||goto out_err;else {if (!sess) {goto out_err;if (sess->state == SMB2_SESSION_EXPIRED) {goto out_err;if (ksmbd_conn_need_reconnect(conn)) {goto out_err;false ;if (negblob_off < offsetof(struct smb2_sess_setup_req, Buffer)) {goto out_err;struct negotiate_message *)((char *)&req->hdr.ProtocolId +if (decode_negotiation_token(conn, negblob, negblob_len) == 0) {if (conn->mechToken) {struct negotiate_message *)conn->mechToken;if (negblob_len < offsetof(struct negotiate_message, NegotiateFlags)) {goto out_err;if (server_conf.auth_mechs & conn->auth_mechs) {if (rc)goto out_err;if (conn->preferred_auth_mech &if (rc) {goto out_err;if (!ksmbd_conn_need_reconnect(conn)) {else if (conn->preferred_auth_mech == KSMBD_AUTH_NTLMSSP) {if (negblob->MessageType == NtLmNegotiate) {if (rc)goto out_err;else if (negblob->MessageType == NtLmAuthenticate) {if (rc)goto out_err;if (!ksmbd_conn_need_reconnect(conn)) {if (conn->binding) {struct preauth_session *preauth_sess;if (preauth_sess) {else {"Unknown NTLMSSP message type : 0x%x\n" ,else {/* TODO: need one more negotiation */ "Not support the preferred authentication\n" );else {"Not support authentication\n" );if (rc == -EINVAL)else if (rc == -ENOENT)else if (rc == -EACCES)else if (rc == -EFAULT)else if (rc == -ENOMEM)else if (rc == -EOPNOTSUPP)else if (rc)if (conn->use_spnego && conn->mechToken) {if (rc < 0) {/* * SecurityBufferOffset should be set to zero * in session setup error response. if (sess) {bool try_delay = false ;/* * To avoid dictionary attacks (repeated session setups rapidly sent) to * connect to server, ksmbd make a delay of a 5 seconds on session setup * failure to make it harder to send enough random connection requests * to break into a server. if (sess->user && sess->user->flags & KSMBD_USER_FLAG_DELAY_SESSION)true ;if (try_delay) {else {unsigned int iov_len;if (rsp->SecurityBufferLength)struct smb2_sess_setup_rsp, Buffer) +else sizeof (struct smb2_sess_setup_rsp);if (rc)return rc;/** * smb2_tree_connect() - handler for smb2 tree connect command * @work: smb work containing smb request buffer * * Return: 0 on success, otherwise error int smb2_tree_connect(struct ksmbd_work *work)struct ksmbd_conn *conn = work->conn;struct smb2_tree_connect_req *req;struct smb2_tree_connect_rsp *rsp;struct ksmbd_session *sess = work->sess;char *treename = NULL, *name = NULL;struct ksmbd_tree_conn_status status;struct ksmbd_share_config *share = NULL;int rc = -EINVAL;"Received smb2 tree connect request\n" );char *)req + le16_to_cpu(req->PathOffset),true ,if (IS_ERR(treename)) {"treename is NULL\n" );goto out_err1;if (IS_ERR(name)) {goto out_err1;"tree connect request for tree %s treename %s\n" ,if (status.ret == KSMBD_TREE_CONN_STATUS_OK)else goto out_err1;if (test_share_config_flag(share, KSMBD_SHARE_FLAG_PIPE)) {"IPC share path request\n" );else {if (test_tree_conn_flag(status.tree_conn,if (conn->posix_ext_supported)true ;if (server_conf.flags & KSMBD_GLOBAL_FLAG_DURABLE_HANDLE && share &&else /* default manual caching */ sizeof (struct smb2_tree_connect_rsp));if (rc)if (!IS_ERR(treename))if (!IS_ERR(name))switch (status.ret) {case KSMBD_TREE_CONN_STATUS_OK:break ;case -ESTALE:case -ENOENT:case KSMBD_TREE_CONN_STATUS_NO_SHARE:break ;case -ENOMEM:case KSMBD_TREE_CONN_STATUS_NOMEM:break ;case KSMBD_TREE_CONN_STATUS_ERROR:case KSMBD_TREE_CONN_STATUS_TOO_MANY_CONNS:case KSMBD_TREE_CONN_STATUS_TOO_MANY_SESSIONS:break ;case -EINVAL:break ;default :if (status.ret != KSMBD_TREE_CONN_STATUS_OK)return rc;/** * smb2_create_open_flags() - convert smb open flags to unix open flags * @file_present: is file already present * @access: file access flags * @disposition: file disposition flags * @may_flags: set with MAY_ flags * @coptions: file creation options * @mode: file mode * * Return: file open flags static int smb2_create_open_flags(bool file_present, __le32 access,int *may_flags,int oflags = O_NONBLOCK | O_LARGEFILE;if (coptions & FILE_DIRECTORY_FILE_LE || S_ISDIR(mode)) {"Discard write access to a directory\n" );if (access & FILE_READ_DESIRED_ACCESS_LE &&else if (access & FILE_WRITE_DESIRE_ACCESS_LE) {else {if (access == FILE_READ_ATTRIBUTES_LE || S_ISBLK(mode) || S_ISCHR(mode))if (file_present) {switch (disposition & FILE_CREATE_MASK_LE) {case FILE_OPEN_LE:case FILE_CREATE_LE:break ;case FILE_SUPERSEDE_LE:case FILE_OVERWRITE_LE:case FILE_OVERWRITE_IF_LE:break ;default :break ;else {switch (disposition & FILE_CREATE_MASK_LE) {case FILE_SUPERSEDE_LE:case FILE_CREATE_LE:case FILE_OPEN_IF_LE:case FILE_OVERWRITE_IF_LE:break ;case FILE_OPEN_LE:case FILE_OVERWRITE_LE:break ;default :break ;return oflags;/** * smb2_tree_disconnect() - handler for smb tree connect request * @work: smb work containing request buffer * * Return: 0 int smb2_tree_disconnect(struct ksmbd_work *work)struct smb2_tree_disconnect_rsp *rsp;struct smb2_tree_disconnect_req *req;struct ksmbd_session *sess = work->sess;struct ksmbd_tree_connect *tcon = work->tcon;int err;"Received smb2 tree disconnect request\n" );if (!tcon) {"Invalid tid %d\n" , req->hdr.Id.SyncId.TreeId);goto err_out;if (tcon->t_state == TREE_DISCONNECTED) {goto err_out;if (err) {goto err_out;sizeof (struct smb2_tree_disconnect_rsp));if (err) {goto err_out;return 0;return err;/** * smb2_session_logoff() - handler for session log off request * @work: smb work containing request buffer * * Return: 0 int smb2_session_logoff(struct ksmbd_work *work)struct ksmbd_conn *conn = work->conn;struct ksmbd_session *sess = work->sess;struct smb2_logoff_req *req;struct smb2_logoff_rsp *rsp;int err;"Received smb2 session logoff request\n" );if (!ksmbd_conn_good(conn)) {return -ENOENT;if (ksmbd_tree_conn_session_logoff(sess)) {"Invalid tid %d\n" , req->hdr.Id.SyncId.TreeId);return -ENOENT;sizeof (struct smb2_logoff_rsp));if (err) {return err;return 0;/** * create_smb2_pipe() - create IPC pipe * @work: smb work containing request buffer * * Return: 0 on success, otherwise error static noinline int create_smb2_pipe(struct ksmbd_work *work)struct smb2_create_rsp *rsp;struct smb2_create_req *req;int id;int err;char *name;if (IS_ERR(name)) {goto out;if (id < 0) {"Unable to open RPC pipe: %d\n" , id);goto out;struct smb2_create_rsp, Buffer));if (err)goto out;return 0;switch (err) {case -EINVAL:break ;case -ENOSPC:case -ENOMEM:break ;if (!IS_ERR(name))return err;/** * smb2_set_ea() - handler for setting extended attributes using set * info command * @eabuf: set info command buffer * @buf_len: set info command buffer length * @path: dentry path for get ea * @get_write: get write access to a mount * * Return: 0 on success, otherwise error static int smb2_set_ea(struct smb2_ea_info *eabuf, unsigned int buf_len,const struct path *path, bool get_write)struct mnt_idmap *idmap = mnt_idmap(path->mnt);char *attr_name = NULL, *value;int rc = 0;unsigned int next = 0;if (buf_len < sizeof (struct smb2_ea_info) + eabuf->EaNameLength +return -EINVAL;if (!attr_name)return -ENOMEM;do {if (!eabuf->EaNameLength)goto next;"name : <%s>, name_len : %u, value_len : %u, next : %u\n" ,if (eabuf->EaNameLength >break ;'\0' ;char *)&eabuf->name + eabuf->EaNameLength + 1;if (!eabuf->EaValueLength) {/* delete the EA only when it exits */ if (rc > 0) {if (rc < 0) {"remove xattr failed(%d)\n" ,break ;/* if the EA doesn't exist, just do nothing. */ else {if (rc < 0) {"ksmbd_vfs_setxattr is failed(%d)\n" ,
Messung V0.5 C=96 H=92 G=93
¤ Dauer der Verarbeitung: 0.23 Sekunden
¤ *© Formatika GbR, Deutschland
