ksmbd: accept unspecified volatile ID on durable reconnect
Subsystems (3)
Namjae Jeon
maintainerPATCH 1/1 ksmbd: accept unspecified volatile ID on durable reconnect
BVT_DurableHandleV1_Reconnect_WithBatchOplock, BVT_DurableHandleV1_Reconnect_WithLeaseV1, BVT_DurableHandleV2_Reconnect_WithBatchOplock, and BVT_DurableHandleV2_Reconnect_WithLeaseV1 fail to reconnect a durable handle when the request leaves VolatileFileId unset.
A durable reconnect request may omit VolatileFileId by setting it to zero. Treating zero as an ID makes ksmbd reject the request whenever the saved volatile ID is nonzero.
Only compare the saved and requested volatile IDs when the request contains a nonzero value. Explicit mismatches continue to be rejected.
This allows SMB2 durable handle V1 and V2 reconnects that identify the handle through the persistent ID and reconnect context.
--- fs/smb/server/smb2pdu.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
fs/smb/server/smb2pdu.c +6 -2
@@ -3584,7 +3584,9 @@ static int parse_durable_handle_context(struct ksmbd_work *work, goto out; } -if (dh_info->fp->durable_volatile_id != +/* A zero VolatileFileId means that the client did not specify it. */ +if (recon_v2->dcontext.Fid.VolatileFileId && + dh_info->fp->durable_volatile_id != recon_v2->dcontext.Fid.VolatileFileId) { err = -EBADF ;ksmbd_put_durable_fd (dh_info->fp);
@@ -3637,7 +3639,9 @@ static int parse_durable_handle_context(struct ksmbd_work *work, goto out; } -if (dh_info->fp->durable_volatile_id != +/* A zero VolatileFileId means that the client did not specify it. */ +if (recon->Data.Fid.VolatileFileId && + dh_info->fp->durable_volatile_id != recon->Data.Fid.VolatileFileId) { err = -EBADF ;ksmbd_put_durable_fd (dh_info->fp);
Signature · 1 line
2.25.1
Namjae Jeon
maintainerPATCH 1/1 ksmbd: implement SMB2 AppInstanceVersion takeover
BVT_AppInstanceVersion_SMB311_GreaterVersion, BVT_AppInstanceVersion_SMB311_SameVersion, BVT_AppInstanceVersion_SMB311_LowerAppInstanceVersionHigh, and BVT_AppInstanceVersion_SMB311_LowerAppInstanceVersionLow exercise ordered opens using the same AppInstanceId. ksmbd tracked the AppInstanceId, but did not parse the version context or enforce the version ordering, so versioned opens returned incorrect sharing violations.
Parse and retain the 24-byte AppInstanceVersion context with each open. Reject a version that is lower than or equal to the active version with STATUS_FILE_FORCED_CLOSED, reject an unversioned open against a versioned handle, and close the previous handle for a newer takeover. Do not apply the takeover check to durable reconnect or replay requests.
--- fs/smb/server/smb2pdu.c | 98 +++++++++++++++++++++++++++++++++++++-- fs/smb/server/vfs_cache.c | 7 ++- fs/smb/server/vfs_cache.h | 5 ++ 3 files changed, 101 insertions(+), 9 deletions(-)
fs/smb/server/smb2pdu.c +93 -5
@@ -16,6 +16,7 @@#include <linux/filelock.h> #include <linux/fileattr.h> #include <linux/timekeeping.h> +#include <linux/unaligned.h> #include "glob.h" #include "../common/smbfsctl.h"
@@ -3451,9 +3452,12 @@ struct durable_info {bool replay;bool replay_consumed;bool app_instance_id; +bool app_instance_version_valid;unsigned int timeout;char *CreateGuid;char AppInstanceId[SMB2_CREATE_GUID_SIZE ]; +u64 app_instance_version_high; +u64 app_instance_version_low; }; static int smb2_check_durable_replay(struct ksmbd_work *work,
@@ -3819,6 +3823,68 @@ static int parse_app_instance_id(struct smb2_create_req *req,return 0 ; } +static int parse_app_instance_version (struct smb2_create_req *req, +struct durable_info *dh_info) +{ +struct create_context *context; +char *data; + + context =smb2_find_context_vals (req,SMB2_CREATE_APP_INSTANCE_VERSION , +SMB2_CREATE_GUID_SIZE ); +if (IS_ERR (context)) +return PTR_ERR (context); +if (!context) +return 0 ; + +if (le32_to_cpu (context->DataLength) <24 ) +return -EINVAL ; + + data = (char *)context +le16_to_cpu (context->DataOffset); +if (get_unaligned_le16 (data) !=24 || +get_unaligned_le16 (data +2 ) !=0 ) +return -EINVAL ; + + dh_info->app_instance_version_high =get_unaligned_le64 (data +8 ); + dh_info->app_instance_version_low =get_unaligned_le64 (data +16 ); + dh_info->app_instance_version_valid = true; +return 0 ; +} + +static int smb2_handle_app_instance_id (struct smb2_create_rsp *rsp, +struct durable_info *dh_info) +{ +struct ksmbd_file *old_fp; +bool reject = false; + +if (!dh_info->app_instance_id) +return 0 ; + + old_fp =ksmbd_lookup_fd_app_instance_id (dh_info->AppInstanceId); +if (!old_fp) +return 0 ; + +if (dh_info->app_instance_version_valid) { +if (old_fp->app_instance_version_valid && + (dh_info->app_instance_version_high < + old_fp->app_instance_version_high || + (dh_info->app_instance_version_high == + old_fp->app_instance_version_high && + dh_info->app_instance_version_low <= + old_fp->app_instance_version_low))) + reject = true; + }else if (old_fp->app_instance_version_valid) { + reject = true; + } + +ksmbd_put_durable_fd (old_fp); +if (reject) { + rsp->hdr.Status =STATUS_FILE_FORCED_CLOSED ; +return -EIO ; + } + +return ksmbd_close_fd_app_instance_id (dh_info->AppInstanceId); +} +/** * smb2_open() - handler for smb file open request * @work: smb work containing request buffer
@@ -3946,6 +4012,15 @@ int smb2_open(struct ksmbd_work *work) req_op_level = req->RequestedOplockLevel; +if (req->CreateContextsOffset) { + rc =parse_app_instance_id (req, &dh_info); +if (rc) + goto err_out2; + rc =parse_app_instance_version (req, &dh_info); +if (rc) + goto err_out2; + } +if (server_conf.flags &KSMBD_GLOBAL_FLAG_DURABLE_HANDLE && req->CreateContextsOffset) { lc =parse_lease_state (req);
@@ -3960,9 +4035,6 @@ int smb2_open(struct ksmbd_work *work)if (req_op_level ==SMB2_OPLOCK_LEVEL_LEASE ) req_op_level =SMB2_OPLOCK_LEVEL_NONE ; } - rc =parse_app_instance_id (req, &dh_info); -if (rc) - goto err_out2; rc =parse_durable_handle_context (work, req, lc, &dh_info);if (rc) {ksmbd_debug (SMB ,"error parsing durable handle context\n" );
@@ -4010,8 +4082,6 @@ int smb2_open(struct ksmbd_work *work) goto reconnected_fp; } -if (dh_info.type ==DURABLE_REQ_V2 && dh_info.app_instance_id) -ksmbd_close_fd_app_instance_id (dh_info.AppInstanceId); }else if (req_op_level ==SMB2_OPLOCK_LEVEL_LEASE ) { lc =parse_lease_state (req);if (IS_ERR (lc)) {
@@ -4026,6 +4096,13 @@ int smb2_open(struct ksmbd_work *work) } } +if (dh_info.app_instance_id && !dh_info.reconnected && + !dh_info.replay) { + rc =smb2_handle_app_instance_id (rsp, &dh_info); +if (rc) + goto err_out2; + } +if (le32_to_cpu (req->ImpersonationLevel) >le32_to_cpu (IL_DELEGATE )) {pr_err ("Invalid impersonationlevel : 0x%x\n" ,le32_to_cpu (req->ImpersonationLevel));
@@ -4426,6 +4503,17 @@ int smb2_open(struct ksmbd_work *work)* waiting on the same break again. */ memcpy (fp->client_guid, conn->ClientGUID,SMB2_CLIENT_GUID_SIZE ); +if (dh_info.app_instance_id) { +memcpy (fp->app_instance_id, dh_info.AppInstanceId, +SMB2_CREATE_GUID_SIZE ); + fp->has_app_instance_id = true; + } +if (dh_info.app_instance_version_valid) { + fp->app_instance_version_high = + dh_info.app_instance_version_high; + fp->app_instance_version_low = dh_info.app_instance_version_low; + fp->app_instance_version_valid = true; + }if (dh_info.CreateGuid) {memcpy (fp->create_guid, dh_info.CreateGuid,SMB2_CREATE_GUID_SIZE ); fp->durable_replay_consumed = dh_info.replay_consumed;
fs/smb/server/vfs_cache.c +3 -4
@@ -995,16 +995,15 @@ bool ksmbd_has_other_active_fd(struct ksmbd_file *fp)return ret; } -static struct ksmbd_file *ksmbd_lookup_fd_app_instance_id (char *app_instance_id) +struct ksmbd_file *ksmbd_lookup_fd_app_instance_id (char *app_instance_id) {struct ksmbd_file *fp =NULL ;unsigned int id; -if (!memchr_inv (app_instance_id,0 ,SMB2_CREATE_GUID_SIZE )) -return NULL ; -read_lock (&global_ft.lock);idr_for_each_entry (global_ft.idr, fp, id) { +if (!fp->has_app_instance_id) +continue ;if (!memcmp (fp->app_instance_id, app_instance_id,SMB2_CREATE_GUID_SIZE )) { fp =ksmbd_fp_get (fp);
fs/smb/server/vfs_cache.h +5 -0
@@ -149,6 +149,10 @@ struct ksmbd_file {bool is_durable;bool is_persistent;bool is_resilient; +bool has_app_instance_id; +bool app_instance_version_valid; +u64 app_instance_version_high; +u64 app_instance_version_low;bool durable_reconnect_disabled;bool durable_replay_consumed;
@@ -209,6 +213,7 @@ void ksmbd_put_durable_fd(struct ksmbd_file *fp);int ksmbd_invalidate_durable_fd (unsigned long long id);bool ksmbd_has_other_active_fd (struct ksmbd_file *fp);bool ksmbd_has_stream_without_delete_share (struct ksmbd_file *fp); +struct ksmbd_file *ksmbd_lookup_fd_app_instance_id (char *app_instance_id);int ksmbd_close_fd_app_instance_id (char *app_instance_id);struct ksmbd_file *ksmbd_lookup_fd_cguid (char *cguid);struct ksmbd_file *ksmbd_lookup_fd_inode (struct dentry *dentry);
Signature · 1 line
2.25.1
Namjae Jeon
maintainerPATCH 1/1 ksmbd: notify parent directory leases on child create
In reply to Namjae JeonBVT_DirectoryLeasing_ReadWriteHandleCaching requires a parent directory lease break notification when another client creates a child in the leased directory. A child CREATE without a lease context did not notify the parent lease holders because the notification path expected a non-NULL lease context.
Allow the parent lease notification helper to handle a NULL child lease context and notify matching parent leases. Invoke it after a child is created without a lease context while preserving the existing lease-key filtering for requests that provide one.
--- fs/smb/server/oplock.c | 9 +++++---- fs/smb/server/smb2pdu.c | 3 +++ 2 files changed, 8 insertions(+), 4 deletions(-)
fs/smb/server/oplock.c +5 -4
@@ -1450,7 +1450,7 @@ void smb_send_parent_lease_break_noti(struct ksmbd_file *fp,struct ksmbd_inode *p_ci =NULL ;LIST_HEAD (brk_list); -if (lctx->version !=2 ) +if (lctx && lctx->version !=2 )return ; p_ci =ksmbd_inode_lookup_lock (fp->filp->f_path.dentry->d_parent);
@@ -1463,9 +1463,10 @@ void smb_send_parent_lease_break_noti(struct ksmbd_file *fp,continue ;if (opinfo->o_lease->state !=SMB2_OPLOCK_LEVEL_NONE && - (!(lctx->flags &SMB2_LEASE_FLAG_PARENT_LEASE_KEY_SET_LE ) || - !compare_guid_key (opinfo, fp->conn->ClientGUID, - lctx->parent_lease_key))) { + (!lctx || + (!(lctx->flags &SMB2_LEASE_FLAG_PARENT_LEASE_KEY_SET_LE ) || + !compare_guid_key (opinfo, fp->conn->ClientGUID, + lctx->parent_lease_key)))) {if (!atomic_inc_not_zero (&opinfo->refcount))continue ;
fs/smb/server/smb2pdu.c +3 -0
@@ -4663,6 +4663,9 @@ int smb2_open(struct ksmbd_work *work) goto err_out1; } }else { +if (created && !lc) +smb_send_parent_lease_break_noti (fp,NULL ); +if (req_op_level ==SMB2_OPLOCK_LEVEL_LEASE && lc) {if (S_ISDIR (file_inode (filp)->i_mode)) { lc->req_state &= ~SMB2_LEASE_WRITE_CACHING_LE ;
Signature · 1 line
2.25.1
Namjae Jeon
maintainerPATCH 1/1 ksmbd: add per-share SMB3 encryption enforcement
In reply to Namjae JeonAdd a share flag for requiring SMB3 encryption on an individual share.
Advertise SMB2_SHAREFLAG_ENCRYPT_DATA in TREE_CONNECT responses and reject both unencrypted TREE_CONNECT attempts and plaintext requests for shares carrying the flag.
Keep BIT(19) reserved for the existing ksmbd-tools WIDE_LINKS flag and use BIT(20) for the new netlink ABI flag.
--- fs/smb/common/smb2pdu.h | 3 ++- fs/smb/server/ksmbd_netlink.h | 2 ++ fs/smb/server/mgmt/share_config.c | 1 + fs/smb/server/server.c | 11 +++++++++++ fs/smb/server/smb2pdu.c | 22 ++++++++++++++++++---- 5 files changed, 34 insertions(+), 5 deletions(-)
fs/smb/common/smb2pdu.h +2 -1
@@ -370,7 +370,8 @@ struct smb2_tree_connect_req {#define SMB2_SHAREFLAG_FORCE_LEVELII_OPLOCK 0x00001000#define SMB2_SHAREFLAG_ENABLE_HASH_V1 0x00002000#define SMB2_SHAREFLAG_ENABLE_HASH_V2 0x00004000 -#define SHI1005_FLAGS_ENCRYPT_DATA 0x00008000 +#define SMB2_SHAREFLAG_ENCRYPT_DATA 0x00008000 +#define SHI1005_FLAGS_ENCRYPT_DATA SMB2_SHAREFLAG_ENCRYPT_DATA#define SMB2_SHAREFLAG_IDENTITY_REMOTING 0x00040000/* 3.1.1 */ #define SMB2_SHAREFLAG_COMPRESS_DATA 0x00100000/* 3.1.1 */ #define SMB2_SHAREFLAG_ISOLATED_TRANSPORT 0x00200000
fs/smb/server/ksmbd_netlink.h +2 -0
@@ -381,6 +381,8 @@ enum KSMBD_TREE_CONN_STATUS {#define KSMBD_SHARE_FLAG_CONTINUOUS_AVAILABILITY BIT(16)#define KSMBD_SHARE_FLAG_HIDE_UNREADABLE BIT(17)#define KSMBD_SHARE_FLAG_TIME_MACHINE BIT(18) +/* Keep BIT(19) reserved for the existing ksmbd-tools WIDE_LINKS flag. */ +#define KSMBD_SHARE_FLAG_ENCRYPT_DATA BIT(20)/* * Tree connect request flags.
fs/smb/server/mgmt/share_config.c +1 -0
@@ -47,6 +47,7 @@ static const struct ksmbd_const_name ksmbd_share_flag_names[] = { {KSMBD_SHARE_FLAG_UPDATE, "update"}, {KSMBD_SHARE_FLAG_CROSSMNT, "crossmnt"}, {KSMBD_SHARE_FLAG_CONTINUOUS_AVAILABILITY, "continuous-availability"}, + {KSMBD_SHARE_FLAG_ENCRYPT_DATA, "encrypt-data"}, };static int proc_show_shares (struct seq_file *m,void *v)
fs/smb/server/server.c +11 -0
@@ -24,6 +24,8 @@#include "auth.h" #include "stats.h" #include "compress.h" +#include "mgmt/share_config.h" +#include "mgmt/tree_connect.h" int ksmbd_debug_types;
@@ -236,6 +238,15 @@ static void __handle_ksmbd_work(struct ksmbd_work *work, STATUS_NETWORK_NAME_DELETED); goto send; } + +if (work->tcon && +test_share_config_flag (work->tcon->share_conf, +KSMBD_SHARE_FLAG_ENCRYPT_DATA ) && + !work->encrypted) { + conn->ops->set_rsp_status (work, +STATUS_ACCESS_DENIED ); + goto send; + } } }
fs/smb/server/smb2pdu.c +18 -4
@@ -2636,12 +2636,22 @@ int smb2_tree_connect(struct ksmbd_work *work) name, treename); status =ksmbd_tree_conn_connect (work, name); -if (status.ret ==KSMBD_TREE_CONN_STATUS_OK ) +if (status.ret ==KSMBD_TREE_CONN_STATUS_OK ) { rsp->hdr.Id.SyncId.TreeId =cpu_to_le32 (status.tree_conn->id); -else + share = status.tree_conn->share_conf; + +/* A share that requires encryption needs a negotiated SMB3 cipher. */ +if (test_share_config_flag (share,KSMBD_SHARE_FLAG_ENCRYPT_DATA ) && + !smb3_encryption_negotiated (conn)) { +ksmbd_tree_conn_disconnect (sess, status.tree_conn); + status.tree_conn =NULL ; + share =NULL ; + status.ret =KSMBD_TREE_CONN_STATUS_ERROR ; + goto out_err1; + } + }else goto out_err1; - share = status.tree_conn->share_conf;if (test_share_config_flag (share,KSMBD_SHARE_FLAG_PIPE )) {ksmbd_debug (SMB ,"IPC share path request\n" ); rsp->ShareType =SMB2_SHARE_TYPE_PIPE ;
@@ -2687,9 +2697,13 @@ int smb2_tree_connect(struct ksmbd_work *work) conn->compress_algorithm != SMB3_COMPRESS_NONE) rsp->ShareFlags |= cpu_to_le32(SMB2_SHAREFLAG_COMPRESS_DATA);if (share &&test_share_config_flag (share, -KSMBD_SHARE_FLAG_HIDE_UNREADABLE )) +KSMBD_SHARE_FLAG_HIDE_UNREADABLE )) rsp->ShareFlags |=cpu_to_le32 (SMB2_SHAREFLAG_ACCESS_BASED_DIRECTORY_ENUM ); +if (share &&test_share_config_flag (share, +KSMBD_SHARE_FLAG_ENCRYPT_DATA )) + rsp->ShareFlags |= +cpu_to_le32 (SMB2_SHAREFLAG_ENCRYPT_DATA ); rc =ksmbd_iov_pin_rsp (work, rsp,sizeof (struct smb2_tree_connect_rsp ));if (rc) {
Signature · 1 line
2.25.1
Namjae Jeon
maintainerPATCH 1/1 ksmbd: fix encrypted request lookup on bound channels
In reply to Namjae JeonAn SMB3 multichannel binding registers the secondary connection in the session channel list, but does not insert the session into the secondary connection's session xarray.
The decryption path only searches the connection-local xarray. As a result, every encrypted request received on a bound channel fails with "Could not get decryption key".
Use the channel-aware session lookup for decryption. Also stop using the temporary conn->binding flag to decide whether the global lookup is allowed. Validate the permanent channel association under chann_lock instead.
--- fs/smb/server/auth.c | 2 +- fs/smb/server/mgmt/user_session.c | 11 +++++++++-- 2 files changed, 10 insertions(+), 3 deletions(-)
fs/smb/server/auth.c +1 -1
@@ -729,7 +729,7 @@ static int ksmbd_get_encryption_key(struct ksmbd_work *work, __u64 ses_id,* that the command can reach the session setup handler. Other * commands are rejected there with STATUS_NETWORK_SESSION_EXPIRED. */ - sess =ksmbd_session_lookup (work->conn, ses_id); + sess =ksmbd_session_lookup_all_states (work->conn, ses_id);if (sess && sess->state !=SMB2_SESSION_VALID && (sess->state !=SMB2_SESSION_EXPIRED || !sess->kerberos_expiry)) {
fs/smb/server/mgmt/user_session.c +9 -2
@@ -551,11 +551,18 @@ struct ksmbd_session *ksmbd_session_lookup_all_states(struct ksmbd_conn *conn, unsigned long long id) {struct ksmbd_session *sess; +bool channel_found; sess =ksmbd_session_lookup (conn, id); -if (!sess && conn->binding) { +if (!sess) { sess =ksmbd_session_lookup_slowpath (id); -if (sess && !xa_load (&sess->ksmbd_chann_list, (long )conn)) { +if (!sess) +return NULL ; + +down_read (&sess->chann_lock); + channel_found =xa_load (&sess->ksmbd_chann_list, (long )conn); +up_read (&sess->chann_lock); +if (!channel_found) {ksmbd_user_session_put (sess); sess =NULL ; }
Signature · 1 line
2.25.1
Namjae Jeon
maintainerPATCH 1/1 ksmbd: scope session state changes to bound connections
In reply to Namjae Jeonksmbd_all_conn_set_status() treats every connection whose transient binding flag is set as belonging to the target SessionId. A logoff or session replacement can consequently move an unrelated connection to NEED_RECONNECT or NEED_SETUP.
Pass the target session itself and select connections using either the connection-local session xarray or the session's permanent channel list. Use the same association test while waiting for requests to drain.
Serialize session-wide status changes under request_lock and do not overwrite EXITING or RELEASING. Protect the shutdown transition with the same lock so a concurrent session update cannot revive a closing connection.
--- fs/smb/server/connection.c | 37 ++++++++++++++++++++++++++----- fs/smb/server/connection.h | 6 +++-- fs/smb/server/mgmt/user_session.c | 8 +++---- fs/smb/server/smb2pdu.c | 6 ++--- 4 files changed, 41 insertions(+), 16 deletions(-)
fs/smb/server/connection.c +31 -6
@@ -404,15 +404,37 @@ void ksmbd_conn_unlock(struct ksmbd_conn *conn)mutex_unlock (&conn->srv_mutex); } -void ksmbd_all_conn_set_status (u64 sess_id,u32 status) +static bool ksmbd_session_is_bound_to_conn (struct ksmbd_session *sess, +struct ksmbd_conn *conn) +{ +bool found; + +rcu_read_lock (); + found =xa_load (&conn->sessions, sess->id) == sess; +rcu_read_unlock (); +if (found) +return true; + +down_read (&sess->chann_lock); + found =xa_load (&sess->ksmbd_chann_list, (long )conn); +up_read (&sess->chann_lock); +return found; +} + +void ksmbd_all_conn_set_status (struct ksmbd_session *sess,u32 status) {struct ksmbd_conn *conn;int bkt;down_read (&conn_list_lock);hash_for_each (conn_list, bkt, conn, hlist) { -if (conn->binding ||xa_load (&conn->sessions, sess_id)) -WRITE_ONCE (conn->status, status); +if (ksmbd_session_is_bound_to_conn (sess, conn)) { +spin_lock (&conn->request_lock); +if (!ksmbd_conn_exiting (conn) && + !ksmbd_conn_releasing (conn)) +WRITE_ONCE (conn->status, status); +spin_unlock (&conn->request_lock); + } }up_read (&conn_list_lock); }
@@ -422,7 +444,8 @@ void ksmbd_conn_wait_idle(struct ksmbd_conn *conn)wait_event (conn->req_running_q,atomic_read (&conn->req_running) <2 ); } -int ksmbd_conn_wait_idle_sess_id (struct ksmbd_conn *curr_conn,u64 sess_id) +int ksmbd_conn_wait_idle_sess (struct ksmbd_conn *curr_conn, +struct ksmbd_session *sess) {struct ksmbd_conn *conn;int rc, retry_count =0 , max_timeout =120 ;
@@ -434,7 +457,7 @@ int ksmbd_conn_wait_idle_sess_id(struct ksmbd_conn *curr_conn, u64 sess_id)down_read (&conn_list_lock);hash_for_each (conn_list, bkt, conn, hlist) { -if (conn->binding ||xa_load (&conn->sessions, sess_id)) { +if (ksmbd_session_is_bound_to_conn (sess, conn)) { rcount = (conn == curr_conn) ?2 :1 ;if (atomic_read (&conn->req_running) >= rcount) { rc = wait_event_timeout(conn->req_running_q,
@@ -780,8 +803,10 @@ static void stop_sessions(void)* handler exited its receive loop for an unrelated * reason). */ -if (READ_ONCE (conn->status) !=KSMBD_SESS_RELEASING ) +spin_lock (&conn->request_lock); +if (!ksmbd_conn_releasing (conn))ksmbd_conn_set_exiting (conn); +spin_unlock (&conn->request_lock); target = conn;break ; }
fs/smb/server/connection.h +4 -2
@@ -23,6 +23,7 @@#include "ksmbd_work.h" struct smbdirect_buffer_descriptor_v1 ; +struct ksmbd_session ;#define KSMBD_SOCKET_BACKLOG 16
@@ -196,7 +197,8 @@ extern struct rw_semaphore conn_list_lock;bool ksmbd_conn_alive (struct ksmbd_conn *conn);void ksmbd_conn_wait_idle (struct ksmbd_conn *conn); -int ksmbd_conn_wait_idle_sess_id (struct ksmbd_conn *curr_conn,u64 sess_id); +int ksmbd_conn_wait_idle_sess (struct ksmbd_conn *curr_conn, +struct ksmbd_session *sess);struct ksmbd_conn *ksmbd_conn_alloc (void );void ksmbd_conn_free (struct ksmbd_conn *conn);struct ksmbd_conn *ksmbd_conn_get (struct ksmbd_conn *conn);
@@ -310,5 +312,5 @@ static inline void ksmbd_conn_set_releasing(struct ksmbd_conn *conn) WRITE_ONCE(conn->status, KSMBD_SESS_RELEASING); } -void ksmbd_all_conn_set_status (u64 sess_id,u32 status); +void ksmbd_all_conn_set_status (struct ksmbd_session *sess,u32 status);#endif /* __CONNECTION_H__ */
fs/smb/server/mgmt/user_session.c +4 -4
@@ -647,17 +647,17 @@ void destroy_previous_session(struct ksmbd_conn *conn, memcmp(user->passkey, prev_user->passkey, user->passkey_sz)) goto out; -ksmbd_all_conn_set_status (id,KSMBD_SESS_NEED_RECONNECT ); - err =ksmbd_conn_wait_idle_sess_id (conn, id); +ksmbd_all_conn_set_status (prev_sess,KSMBD_SESS_NEED_RECONNECT ); + err =ksmbd_conn_wait_idle_sess (conn, prev_sess);if (err) { -ksmbd_all_conn_set_status (id,KSMBD_SESS_NEED_SETUP ); +ksmbd_all_conn_set_status (prev_sess,KSMBD_SESS_NEED_SETUP ); goto out; }ksmbd_destroy_file_table (prev_sess); prev_sess->kerberos_expiry =0 ; prev_sess->state =SMB2_SESSION_EXPIRED ; -ksmbd_all_conn_set_status (id,KSMBD_SESS_NEED_SETUP ); +ksmbd_all_conn_set_status (prev_sess,KSMBD_SESS_NEED_SETUP );ksmbd_launch_ksmbd_durable_scavenger (); out:up_write (&conn->session_lock);
fs/smb/server/smb2pdu.c +2 -4
@@ -2899,7 +2899,6 @@ int smb2_session_logoff(struct ksmbd_work *work)struct ksmbd_session *sess = work->sess;struct smb2_logoff_req *req;struct smb2_logoff_rsp *rsp; -u64 sess_id;int err;WORK_BUFFERS (work, req, rsp);
@@ -2913,8 +2912,7 @@ int smb2_session_logoff(struct ksmbd_work *work)smb2_set_err_rsp (work);return -ENOENT ; } - sess_id =le64_to_cpu (req->hdr.SessionId); -ksmbd_all_conn_set_status (sess_id,KSMBD_SESS_NEED_RECONNECT ); +ksmbd_all_conn_set_status (sess,KSMBD_SESS_NEED_RECONNECT );ksmbd_conn_unlock (conn);ksmbd_close_session_fds (work);
@@ -2932,7 +2930,7 @@ int smb2_session_logoff(struct ksmbd_work *work) sess->state =SMB2_SESSION_EXPIRED ;up_write (&conn->session_lock); -ksmbd_all_conn_set_status (sess_id,KSMBD_SESS_NEED_SETUP ); +ksmbd_all_conn_set_status (sess,KSMBD_SESS_NEED_SETUP ); rsp->StructureSize =cpu_to_le16 (4 ); err =ksmbd_iov_pin_rsp (work, rsp,sizeof (struct smb2_logoff_rsp ));
Signature · 1 line
2.25.1
Namjae Jeon
maintainerPATCH 1/1 ksmbd: encrypt interim responses to encrypted requests
In reply to Namjae JeonThe normal response path applies an SMB3 transform when the request was encrypted. Async interim responses, completed compound prefixes and two CHANGE_NOTIFY cleanup paths write their synthetic response work directly, bypassing that encryption step.
A packet capture shows FE SMB2 STATUS_PENDING, CREATE and CHANGE_NOTIFY responses following FD SMB3 requests. The client resets the connection immediately after receiving those plaintext responses.
Send synthetic interim work through a common helper that applies the session encryption transform first. A compound prefix shares the original work's response iov, which encryption would replace in place, so flatten it into an independently owned work before encrypting and sending it.
--- fs/smb/server/smb2pdu.c | 71 ++++++++++++++++++++++++++++++++++++++--- 1 file changed, 67 insertions(+), 4 deletions(-)
fs/smb/server/smb2pdu.c +67 -4
@@ -1124,6 +1124,66 @@ void release_async_work(struct ksmbd_work *work) } } +static int smb2_send_interim_work (struct ksmbd_work *in_work, +struct ksmbd_work *work,bool eor) +{ +int err =0 ; + + in_work->encrypted = work->encrypted; +if (work->encrypted && work->sess && work->sess->enc && + work->conn->ops->encrypt_resp) { + in_work->sess = work->sess; + err = work->conn->ops->encrypt_resp (in_work); + in_work->sess =NULL ; + } +if (err) +return err; + +return eor ?ksmbd_conn_write_eor (in_work) : +ksmbd_conn_write (in_work); +} + +static int smb2_send_interim_prefix_work (struct ksmbd_work *work) +{ +struct ksmbd_work *in_work; +unsigned int len, copied =0 ; +char *dst; +int err = -ENOMEM ; +int i; + + len =get_rfc1002_len (work->iov[0 ].iov_base); + in_work =ksmbd_alloc_work_struct (); +if (!in_work) +return err; + + in_work->response_buf =kvzalloc (len +4 ,KSMBD_DEFAULT_GFP ); +if (!in_work->response_buf) + goto out; + in_work->response_sz = len +4 ; + in_work->conn = work->conn; + dst = in_work->response_buf +4 ; +for (i =1 ; i <= work->iov_idx; i++) { +if (work->iov[i].iov_len > len - copied) { + err = -EINVAL ; + goto out; + } +memcpy (dst + copied, work->iov[i].iov_base, + work->iov[i].iov_len); + copied += work->iov[i].iov_len; + } +if (copied != len) { + err = -EINVAL ; + goto out; + } + + err =ksmbd_iov_pin_rsp (in_work, dst, len); +if (!err) + err =smb2_send_interim_work (in_work, work, true); +out: +ksmbd_free_work_struct (in_work); +return err; +} +static void smb2_send_interim_compound_prefix (struct ksmbd_work *work) {struct smb2_hdr *req_hdr;
@@ -1152,7 +1212,7 @@ static void smb2_send_interim_compound_prefix(struct ksmbd_work *work) work->conn->ops->set_sign_rsp) work->conn->ops->set_sign_rsp (work); - err =ksmbd_conn_write_eor (work); + err =smb2_send_interim_prefix_work (work);if (err)ksmbd_debug (SMB ,"failed to send compound interim prefix: %d\n" , err);
@@ -1193,7 +1253,8 @@ void smb2_send_interim_resp(struct ksmbd_work *work, __le32 status)smb2_set_err_rsp (in_work); rsp_hdr->Status = status; -ksmbd_conn_write_eor (in_work); +if (smb2_send_interim_work (in_work, work, true)) +ksmbd_debug (SMB ,"failed to send interim response\n" );ksmbd_free_work_struct (in_work); }
@@ -11310,7 +11371,8 @@ int smb2_notify(struct ksmbd_work *work) in_work->async_id = work->async_id; work->async_id =0 ;release_async_work (work); -ksmbd_conn_write (in_work); +if (smb2_send_interim_work (in_work, work, false)) +ksmbd_debug (SMB ,"failed to send notify cleanup\n" );ksmbd_free_work_struct (in_work); work->send_no_response =1 ;return 0 ;
@@ -11415,7 +11477,8 @@ int smb2_notify(struct ksmbd_work *work) in_work->cancel_fn =NULL ; in_work->asynchronous = false;ksmbd_fd_put (work, fp); -ksmbd_conn_write (in_work); +if (smb2_send_interim_work (in_work, work, false)) +ksmbd_debug (SMB ,"failed to send notify cleanup\n" );ksmbd_free_work_struct (in_work); work->send_no_response =1 ;return 0 ;
Signature · 1 line
2.25.1
Namjae Jeon
maintainerPATCH 1/1 ksmbd: disconnect on SMB3 decryption failure
In reply to Namjae JeonMS-SMB2 requires the server to disconnect a connection when an encrypted transform cannot be associated with a session or fails authenticated decryption. This includes an encrypted request that still carries a SessionId invalidated through PreviousSessionId.
Move the connection to EXITING and shut down its transport when decrypt_req() fails. Add the missing TCP shutdown callback so a receive blocked in kernel_recvmsg() is released; SMB Direct already provides the corresponding callback.
Plaintext requests using an invalidated SessionId do not take this path and continue to receive STATUS_USER_SESSION_DELETED.
--- fs/smb/server/connection.c | 16 ++++++++++++++++ fs/smb/server/connection.h | 1 + fs/smb/server/server.c | 4 +++- fs/smb/server/transport_tcp.c | 6 ++++++ 4 files changed, 26 insertions(+), 1 deletion(-)
fs/smb/server/connection.c +16 -0
@@ -439,6 +439,22 @@ void ksmbd_all_conn_set_status(struct ksmbd_session *sess, u32 status)up_read (&conn_list_lock); } +void ksmbd_conn_abort (struct ksmbd_conn *conn) +{ +bool shutdown = false; + +spin_lock (&conn->request_lock); +if (!ksmbd_conn_exiting (conn) && !ksmbd_conn_releasing (conn)) { +ksmbd_conn_set_exiting (conn); + shutdown = true; + } +spin_unlock (&conn->request_lock); +wake_up_all (&conn->req_running_q); + +if (shutdown && conn->transport->ops->shutdown) + conn->transport->ops->shutdown (conn->transport); +} +void ksmbd_conn_wait_idle (struct ksmbd_conn *conn) {wait_event (conn->req_running_q,atomic_read (&conn->req_running) <2 );
fs/smb/server/connection.h +1 -0
@@ -203,6 +203,7 @@ struct ksmbd_conn *ksmbd_conn_alloc(void);void ksmbd_conn_free (struct ksmbd_conn *conn);struct ksmbd_conn *ksmbd_conn_get (struct ksmbd_conn *conn);void ksmbd_conn_put (struct ksmbd_conn *conn); +void ksmbd_conn_abort (struct ksmbd_conn *conn);int ksmbd_conn_wq_init (void );void ksmbd_conn_wq_destroy (void );bool ksmbd_conn_lookup_dialect (struct ksmbd_conn *c);
fs/smb/server/server.c +3 -1
@@ -188,8 +188,10 @@ static void __handle_ksmbd_work(struct ksmbd_work *work,if (conn->ops->is_transform_hdr && conn->ops->is_transform_hdr (work->request_buf)) { rc = conn->ops->decrypt_req (work); -if (rc <0 ) +if (rc <0 ) { +ksmbd_conn_abort (conn);return ; + } work->encrypted = true; }
fs/smb/server/transport_tcp.c +6 -0
@@ -435,6 +435,11 @@ static void ksmbd_tcp_disconnect(struct ksmbd_transport *t)atomic_dec (&active_num_conn); } +static void ksmbd_tcp_shutdown (struct ksmbd_transport *t) +{ +kernel_sock_shutdown (TCP_TRANS (t)->sock,SHUT_RDWR ); +} +static void tcp_destroy_socket (struct socket *ksmbd_socket) {int ret;
@@ -681,5 +686,6 @@ static const struct ksmbd_transport_ops ksmbd_tcp_transport_ops = { .read = ksmbd_tcp_read, .writev = ksmbd_tcp_writev, .disconnect = ksmbd_tcp_disconnect, + .shutdown = ksmbd_tcp_shutdown, .free_transport = ksmbd_tcp_free_transport, };
Signature · 1 line
2.25.1
Namjae Jeon
maintainerPATCH 1/1 ksmbd: decrypt requests from expired encrypted sessions
In reply to Namjae JeonPrevious-session replacement marks the old session expired but retains its SMB3 encryption key. An in-flight encrypted request can still arrive on that connection. Rejecting the expired session before decryption made ksmbd treat the request as a key failure and abort the transport, causing reconnect failures.
Allow key lookup for expired sessions that have encryption enabled. Keep the session reference during validation so the normal STATUS_USER_SESSION_DELETED response is encrypted with the old key. The session remains expired and no command is executed.
--- fs/smb/server/auth.c | 12 ++++++------ fs/smb/server/smb2pdu.c | 8 ++++++++ 2 files changed, 14 insertions(+), 6 deletions(-)
fs/smb/server/auth.c +6 -6
@@ -724,15 +724,15 @@ static int ksmbd_get_encryption_key(struct ksmbd_work *work, __u64 ses_id, sess = work->sess; else {/* -* An encrypted SESSION_SETUP request may reauthenticate an expired -* Kerberos session. Keep using the established decryption key so -* that the command can reach the session setup handler. Other -* commands are rejected there with STATUS_NETWORK_SESSION_EXPIRED. +* A previous-session replacement leaves the old encryption key in +* place. Use it to authenticate an encrypted request, then let +* session validation reject the expired session. This preserves the +* encrypted STATUS_USER_SESSION_DELETED response without reviving +* the session. */ sess =ksmbd_session_lookup_all_states (work->conn, ses_id);if (sess && sess->state !=SMB2_SESSION_VALID && - (sess->state !=SMB2_SESSION_EXPIRED || - !sess->kerberos_expiry)) { + (sess->state !=SMB2_SESSION_EXPIRED || !sess->enc)) {ksmbd_user_session_put (sess); sess =NULL ; }
fs/smb/server/smb2pdu.c +8 -0
@@ -1012,6 +1012,14 @@ int smb2_check_user_session(struct ksmbd_work *work) 1 : -EKEYEXPIRED; }if (work->sess->state !=SMB2_SESSION_VALID ) { +/* +* Keep the reference for an encrypted request so the caller can +* return STATUS_USER_SESSION_DELETED encrypted with the old key. +*/ +if (work->encrypted && + work->sess->state ==SMB2_SESSION_EXPIRED && + work->sess->enc) +return -ENOENT ;ksmbd_user_session_put (work->sess); work->sess =NULL ;return -ENOENT ;
Signature · 1 line
2.25.1
Namjae Jeon
maintainerPATCH 1/1 ksmbd: handle encrypted compressed requests
In reply to Namjae JeonSMB3 permits a message to be compressed before it is encrypted. After decrypting such a request, ksmbd must trim the AEAD tag using OriginalMessageSize, decompress the nested compression transform, and validate the resulting SMB2 PDU.
Share the decompression helper between the connection receive path and the post-decryption work path so unencrypted and encrypted compressed requests follow the same validation.
--- fs/smb/server/compress.c | 76 ++++++++++++++++++++++++++++++---------- fs/smb/server/compress.h | 1 + fs/smb/server/server.c | 22 ++++++++++++ fs/smb/server/smb2pdu.c | 22 ++++++++---- 4 files changed, 97 insertions(+), 24 deletions(-)
fs/smb/server/compress.c +58 -18
@@ -14,24 +14,14 @@#define SMB_COMPRESS_MIN_LEN PAGE_SIZE -/** -* ksmbd_decompress_request() - replace a compressed request with its SMB2 PDU -* @conn: connection which owns the current RFC1002 request buffer -* -* Derive the uncompressed size from the transform variant, enforce ksmbd's -* normal message limits, and ask the common decoder to validate every payload. -* On success, replace conn->request_buf with a regular RFC1002-framed SMB2 -* message so the rest of the request path needs no compression awareness. -* -* Return: 0 on success, otherwise a negative errno. -*/ -int ksmbd_decompress_request (struct ksmbd_conn *conn) +static int __ksmbd_decompress_request (struct ksmbd_conn *conn, +void *request_buf,void **out_buf) {struct smb2_compression_hdr *hdr; -unsigned int pdu_size =get_rfc1002_len (conn->request_buf); +unsigned int pdu_size =get_rfc1002_len (request_buf);u32 orig_size, offset, out_size;u32 max_allowed_pdu_size; -char *buf, *out; +char *out;int rc;if (pdu_size <sizeof (struct smb2_compression_hdr ))
@@ -41,7 +31,7 @@ int ksmbd_decompress_request(struct ksmbd_conn *conn) conn->compress_algorithm == SMB3_COMPRESS_NONE)return -EINVAL ; - hdr =smb_get_msg (conn->request_buf); + hdr =smb_get_msg (request_buf);if (hdr->ProtocolId !=SMB2_COMPRESSION_TRANSFORM_ID )return -EINVAL ;
@@ -74,19 +64,69 @@ int ksmbd_decompress_request(struct ksmbd_conn *conn)if (!out)return -ENOMEM ; - buf = (char *)hdr; *(__be32 *)out =cpu_to_be32 (out_size); rc =smb_compression_decompress (conn->compress_algorithm, conn->compress_chained, conn->compress_pattern, - buf, pdu_size, out +4 , out_size); + (char *)hdr, pdu_size, out +4 , out_size);if (rc) {kvfree (out);return rc; } + *out_buf = out; +return 0 ; +} + +/** +* ksmbd_decompress_request() - replace a compressed request with its SMB2 PDU +* @conn: connection which owns the current RFC1002 request buffer +* +* Derive the uncompressed size from the transform variant, enforce ksmbd's +* normal message limits, and ask the common decoder to validate every payload. +* On success, replace conn->request_buf with a regular RFC1002-framed SMB2 +* message so the rest of the request path needs no compression awareness. +* +* Return: 0 on success, otherwise a negative errno. +*/ +int ksmbd_decompress_request (struct ksmbd_conn *conn) +{ +void *out_buf; +int rc; + + rc =__ksmbd_decompress_request (conn, conn->request_buf, &out_buf); +if (rc) +return rc; +kvfree (conn->request_buf); - conn->request_buf = out; + conn->request_buf = out_buf; +return 0 ; +} + +/** +* ksmbd_decompress_work_request() - decompress an encrypted work request +* @work: work item whose request buffer contains a compression transform +* +* SMB3 encrypts a compressed message by applying compression first and +* encryption second. The receive loop can therefore only decode the +* compression transform before work allocation for an unencrypted request; +* an encrypted request must be decompressed after its encryption layer has +* been removed. +* +* Return: 0 on success, otherwise a negative errno. +*/ +int ksmbd_decompress_work_request (struct ksmbd_work *work) +{ +void *out_buf; +int rc; + + rc =__ksmbd_decompress_request (work->conn, work->request_buf, + &out_buf); +if (rc) +return rc; + +kvfree (work->request_buf); + work->request_buf = out_buf;return 0 ; }
fs/smb/server/compress.h +1 -0
@@ -11,6 +11,7 @@#include "../common/compress/compress.h" int ksmbd_decompress_request (struct ksmbd_conn *conn); +int ksmbd_decompress_work_request (struct ksmbd_work *work);int ksmbd_compress_response (struct ksmbd_work *work);#endif /* __KSMBD_COMPRESS_H__ */
fs/smb/server/server.c +22 -0
@@ -193,6 +193,28 @@ static void __handle_ksmbd_work(struct ksmbd_work *work,return ; } work->encrypted = true; + +/* +* SMB3 applies compression before encryption. The receive loop +* handles a plain compression transform before allocating work, but +* an encrypted request exposes that transform only after decryption. +*/ +if (((struct smb2_hdr *)smb_get_msg (work->request_buf))->ProtocolId == +SMB2_COMPRESSION_TRANSFORM_ID ) { + rc =ksmbd_decompress_work_request (work); +if (rc <0 ) { +ksmbd_conn_abort (conn); +return ; + } + } + +/* The decrypted payload must now be a complete SMB2 request. */ +if (((struct smb2_hdr *)smb_get_msg (work->request_buf))->ProtocolId != +SMB2_PROTO_NUMBER || +get_rfc1002_len (work->request_buf) <sizeof (struct smb2_pdu )) { +ksmbd_conn_abort (conn); +return ; + } }if (conn->ops->allocate_rsp_buf (work))
fs/smb/server/smb2pdu.c +16 -6
@@ -11817,18 +11817,27 @@ int smb3_decrypt_req(struct ksmbd_work *work)char *buf = work->request_buf;unsigned int pdu_length =get_rfc1002_len (buf);struct kvec iov[2 ]; -int buf_data_size = pdu_length -sizeof (struct smb2_transform_hdr ); +unsigned int buf_data_size;struct smb2_transform_hdr *tr_hdr =smb_get_msg (buf); +unsigned int original_msg_size;int rc =0 ; -if (pdu_length <sizeof (struct smb2_transform_hdr ) || - buf_data_size <sizeof (struct smb2_hdr )) { +if (pdu_length <sizeof (struct smb2_transform_hdr )) {pr_err ("Transform message is too small (%u)\n" , pdu_length);return -ECONNABORTED ; } -if (buf_data_size <le32_to_cpu (tr_hdr->OriginalMessageSize)) { + buf_data_size = pdu_length -sizeof (struct smb2_transform_hdr ); + original_msg_size =le32_to_cpu (tr_hdr->OriginalMessageSize); +if (buf_data_size <sizeof (struct smb2_compression_hdr ) || + original_msg_size <sizeof (struct smb2_compression_hdr )) { +pr_err ("Transform message is too small (%u)\n" , + pdu_length); +return -ECONNABORTED ; + } + +if (buf_data_size < original_msg_size) {pr_err ("Transform message is broken\n" );return -ECONNABORTED ; }
@@ -11841,8 +11850,9 @@ int smb3_decrypt_req(struct ksmbd_work *work)if (rc)return rc; -memmove (buf +4 , iov[1 ].iov_base, buf_data_size); - *(__be32 *)buf =cpu_to_be32 (buf_data_size); +/* Drop the AEAD authentication tag from the inner RFC1002 frame. */ +memmove (buf +4 , iov[1 ].iov_base, original_msg_size); + *(__be32 *)buf =cpu_to_be32 (original_msg_size);return rc; }
Signature · 1 line
2.25.1
Namjae Jeon
maintainerPATCH 1/1 ksmbd: add SMB Direct RDMA encryption transform
In reply to Namjae JeonPort SMB Direct RDMA payload encryption support to the current ksmbd tree. The current tree already supports all-state lookup for encrypted expired sessions, so the overlapping lookup hunk from the original patch is intentionally omitted.
--- fs/smb/client/smb2pdu.h | 24 -- fs/smb/common/smb2pdu.h | 22 ++ fs/smb/common/smb2status.h | 1 + fs/smb/server/auth.c | 158 +++++++++++ fs/smb/server/auth.h | 4 + fs/smb/server/connection.c | 2 + fs/smb/server/connection.h | 3 + fs/smb/server/smb2pdu.c | 500 ++++++++++++++++++++++++++++++--- fs/smb/server/transport_rdma.c | 10 + fs/smb/server/transport_rdma.h | 2 + 10 files changed, 663 insertions(+), 63 deletions(-)
fs/smb/client/smb2pdu.h +0 -24
@@ -21,30 +21,6 @@/* The total header size for SMB2 read and write */ #define SMB2_READWRITE_PDU_HEADER_SIZE (48 + sizeof(struct smb2_hdr)) -/* See MS-SMB2 2.2.43 */ -struct smb2_rdma_transform { -__le16 RdmaDescriptorOffset; -__le16 RdmaDescriptorLength; -__le32 Channel;/* for values see channel description in smb2 read above */ -__le16 TransformCount; -__le16 Reserved1; -__le32 Reserved2; -} __packed; - -/* TransformType */ -#define SMB2_RDMA_TRANSFORM_TYPE_ENCRYPTION 0x0001 -#define SMB2_RDMA_TRANSFORM_TYPE_SIGNING 0x0002 - -struct smb2_rdma_crypto_transform { -__le16 TransformType; -__le16 SignatureLength; -__le16 NonceLength; -__u16 Reserved; -__u8 Signature[];/* variable length */ -/* u8 Nonce[] */ -/* followed by padding */ -} __packed; -/* * Definitions for SMB2 Protocol Data Units (network frames) *
fs/smb/common/smb2pdu.h +22 -0
@@ -743,6 +743,28 @@ struct smb2_close_rsp {#define SMB2_CHANNEL_RDMA_V1_INVALIDATE cpu_to_le32(0x00000002)#define SMB2_CHANNEL_RDMA_TRANSFORM cpu_to_le32(0x00000003) +/* See MS-SMB2 2.2.43. */ +struct smb2_rdma_transform { +__le16 RdmaDescriptorOffset; +__le16 RdmaDescriptorLength; +__le32 Channel; +__le16 TransformCount; +__le16 Reserved1; +__le32 Reserved2; +} __packed; + +#define SMB2_RDMA_TRANSFORM_TYPE_ENCRYPTION 0x0001 +#define SMB2_RDMA_TRANSFORM_TYPE_SIGNING 0x0002 + +struct smb2_rdma_crypto_transform { +__le16 TransformType; +__le16 SignatureLength; +__le16 NonceLength; +__le16 Reserved; +__u8 Signature[]; +/* Followed by Nonce[] and optional alignment padding. */ +} __packed; +/* SMB2 read request without RFC1001 length at the beginning */ struct smb2_read_req {struct smb2_hdr hdr;
fs/smb/common/smb2status.h +1 -0
@@ -1049,6 +1049,7 @@ struct ntstatus {#define STATUS_WOW_ASSERTION cpu_to_le32(0xC0009898) // -EIO#define STATUS_INVALID_SIGNATURE cpu_to_le32(0xC000A000) // -EIO#define STATUS_HMAC_NOT_SUPPORTED cpu_to_le32(0xC000A001) // -EIO +#define STATUS_AUTH_TAG_MISMATCH cpu_to_le32(0xC000A002) // -EBADMSG#define STATUS_IPSEC_QUEUE_OVERFLOW cpu_to_le32(0xC000A010) // -EIO#define STATUS_ND_QUEUE_OVERFLOW cpu_to_le32(0xC000A011) // -EIO#define STATUS_HOPLIMIT_EXCEEDED cpu_to_le32(0xC000A012) // -EIO
fs/smb/server/auth.c +158 -0
164 lines not on this page · raw message
fs/smb/server/auth.h +4 -0
@@ -38,6 +38,10 @@ struct kvec;int ksmbd_crypt_message (struct ksmbd_work *work,struct kvec *iov,unsigned int nvec,int enc); +int ksmbd_crypt_rdma (struct ksmbd_conn *conn,const u8 *key, +void *buf,unsigned int buflen,const u8 *nonce, +unsigned int nonce_len,u8 *tag,unsigned int tag_len, +bool enc);void ksmbd_copy_gss_neg_header (void *buf); int ksmbd_auth_ntlmv2(struct ksmbd_conn *conn, struct ksmbd_session *sess, struct ntlmv2_resp *ntlmv2, int blen, char *domain_name,
fs/smb/server/connection.c +2 -0
@@ -77,6 +77,8 @@ static void proc_show_conn_features(struct seq_file *m,proc_show_conn_feature (m, &separator, conn->compress_algorithm !=SMB3_COMPRESS_NONE ,"compress" ); +proc_show_conn_feature (m, &separator, conn->rdma_transform_ids, +"rdma-transform" );proc_show_conn_feature (m, &separator, conn->posix_ext_supported,"posix" );if (!separator)seq_puts (m,"none" );
fs/smb/server/connection.h +3 -0
@@ -139,6 +139,9 @@ struct ksmbd_conn {/* Negotiated SMB 3.1.1 compression capabilities. */ bool compress_chained;bool compress_pattern; +/* Bitmap indexed by SMB2_RDMA_TRANSFORM_* IDs. */ +unsigned long rdma_transform_ids; +bool rdma_transform_negotiated;bool posix_ext_supported;bool signing_negotiated;__le16 signing_algorithm;
fs/smb/server/smb2pdu.c +461 -39
644 lines not on this page · raw message
fs/smb/server/transport_rdma.c +10 -0
@@ -76,6 +76,8 @@ static int smb_direct_max_receive_size = 1364;static int smb_direct_max_read_write_size =SMBD_DEFAULT_IOSIZE ; +static bool smb_direct_enabled; + static struct smb_direct_listener { int port;
@@ -512,18 +514,26 @@ int ksmbd_rdma_init(void)ksmbd_debug (RDMA ,"iWarp RDMA listener. socket=%p\n" , smb_direct_iw_listener.socket); +WRITE_ONCE (smb_direct_enabled, true);return 0 ; err: +WRITE_ONCE (smb_direct_enabled, false);ksmbd_rdma_stop_listening ();return ret; }void ksmbd_rdma_stop_listening (void ) { +WRITE_ONCE (smb_direct_enabled, false);smb_direct_listener_destroy (&smb_direct_ib_listener);smb_direct_listener_destroy (&smb_direct_iw_listener); } +bool ksmbd_rdma_enabled (void ) +{ +return READ_ONCE (smb_direct_enabled); +} +bool ksmbd_rdma_capable_netdev (struct net_device *netdev) {u8 node_type =smbdirect_netdev_rdma_capable_node_type (netdev);
fs/smb/server/transport_rdma.h +2 -0
@@ -14,12 +14,14 @@#ifdef CONFIG_SMB_SERVER_SMBDIRECT int ksmbd_rdma_init (void );void ksmbd_rdma_stop_listening (void ); +bool ksmbd_rdma_enabled (void );bool ksmbd_rdma_capable_netdev (struct net_device *netdev);void init_smbd_max_io_size (unsigned int sz);unsigned int get_smbd_max_read_write_size (struct ksmbd_transport *kt);#else static inline int ksmbd_rdma_init (void ) {return 0 ; }static inline void ksmbd_rdma_stop_listening (void ) { } +static inline bool ksmbd_rdma_enabled (void ) {return false; }static inline bool ksmbd_rdma_capable_netdev (struct net_device *netdev) {return false; }static inline void init_smbd_max_io_size (unsigned int sz) { }static inline unsigned int get_smbd_max_read_write_size (struct ksmbd_transport *kt) {return 0 ; }
Signature · 1 line
2.25.1
Namjae Jeon
maintainerPATCH 1/1 ksmbd: make RDMA encryption diagnostics conditional
In reply to Namjae JeonThe temporary RDMA encryption diagnostics logged every SMB3 request and successful payload operation with pr_err(), which made normal traffic too noisy.
Keep only negotiation, RDMA READ preparation, RDMA WRITE transform metadata, crypto completion, and final transfer completion messages as KSMBD_DEBUG_RDMA diagnostics. Keep error reports for malformed metadata, crypto, RDMA transfer, and file write failures at error level.
This preserves the diagnostics needed to verify RDMA transform operation without flooding the kernel error log during normal I/O.
--- fs/smb/server/auth.c | 33 +++++++++++++++--- fs/smb/server/smb2pdu.c | 75 +++++++++++++++++++++++++++++++++-------- 2 files changed, 90 insertions(+), 18 deletions(-)
fs/smb/server/auth.c +29 -4
@@ -911,26 +911,42 @@ int ksmbd_crypt_rdma(struct ksmbd_conn *conn, const u8 *key,unsigned int iv_len, crypt_len;u8 auth_tag[SMB2_SIGNATURE_SIZE ] = {};u8 *iv =NULL ; +u16 cipher =le16_to_cpu (conn->cipher_type);int rc;DECLARE_CRYPTO_WAIT (wait); -if (!buflen || !tag_len || tag_len >SMB2_SIGNATURE_SIZE ) +if (!buflen || !tag_len || tag_len >SMB2_SIGNATURE_SIZE ) { +pr_err ("RDMA %s rejected: cipher=0x%04x payload=%u nonce=%u tag=%u\n" , + enc ?"encryption" :"decryption" , cipher, buflen, + nonce_len, tag_len);return -EINVAL ; + }if (!enc)memcpy (auth_tag, tag, tag_len);if (conn->cipher_type ==SMB2_ENCRYPTION_AES128_GCM || conn->cipher_type ==SMB2_ENCRYPTION_AES256_GCM ) { -if (nonce_len !=SMB3_AES_GCM_NONCE ) +if (nonce_len !=SMB3_AES_GCM_NONCE ) { +pr_err ("RDMA %s rejected: cipher=0x%04x invalid nonce=%u expected=%u\n" , + enc ?"encryption" :"decryption" , cipher, + nonce_len,SMB3_AES_GCM_NONCE );return -EINVAL ; + } ctx =ksmbd_crypto_ctx_find_gcm (); }else { -if (nonce_len !=SMB3_AES_CCM_NONCE ) +if (nonce_len !=SMB3_AES_CCM_NONCE ) { +pr_err ("RDMA %s rejected: cipher=0x%04x invalid nonce=%u expected=%u\n" , + enc ?"encryption" :"decryption" , cipher, + nonce_len,SMB3_AES_CCM_NONCE );return -EINVAL ; + } ctx =ksmbd_crypto_ctx_find_ccm (); } -if (!ctx) +if (!ctx) { +pr_err ("RDMA %s failed: cipher=0x%04x crypto context unavailable\n" , + enc ?"encryption" :"decryption" , cipher);return -ENOMEM ; + } tfm = (conn->cipher_type ==SMB2_ENCRYPTION_AES128_GCM || conn->cipher_type == SMB2_ENCRYPTION_AES256_GCM) ?
@@ -988,6 +1004,15 @@ int ksmbd_crypt_rdma(struct ksmbd_conn *conn, const u8 *key,kfree (sg);aead_request_free (req);ksmbd_release_crypto_ctx (ctx); +if (rc) +pr_err ("RDMA %s failed: cipher=0x%04x payload=%u nonce=%u tag=%u rc=%d\n" , + enc ?"encryption" :"decryption" , cipher, buflen, + nonce_len, tag_len, rc); +else +ksmbd_debug (RDMA , +"RDMA %s completed: cipher=0x%04x payload=%u nonce=%u tag=%u\n" , + enc ?"encryption" :"decryption" , cipher, buflen, + nonce_len, tag_len);return rc; }
fs/smb/server/smb2pdu.c +61 -14
147 lines not on this page · raw message
Signature · 1 line
2.25.1