* [PATCH v3 00/10] cifsd: introduce new SMB3 kernel server [not found] <CGME20210521063549epcas1p204e171a2ba5a06d1b50e490f5e742b25@epcas1p2.samsung.com> @ 2021-05-21 6:26 ` Namjae Jeon [not found] ` <CGME20210521063551epcas1p4f9c25b83b0088b3631c0860f5f715c52@epcas1p4.samsung.com> ` (7 more replies) 0 siblings, 8 replies; 11+ messages in thread From: Namjae Jeon @ 2021-05-21 6:26 UTC (permalink / raw) To: linux-fsdevel, linux-kernel, linux-cifs Cc: linux-cifsd-devel, smfrench, senozhatsky, hyc.lee, viro, hch, hch, ronniesahlberg, aurelien.aptel, aaptel, sandeen, dan.carpenter, willy, Namjae Jeon This is the patch series for cifsd(ksmbd) kernel server. What is cifsd(ksmbd) ? ====================== The SMB family of protocols is the most widely deployed network filesystem protocol, the default on Windows and Macs (and even on many phones and tablets), with clients and servers on all major operating systems, but lacked a kernel server for Linux. For many cases the current userspace server choices were suboptimal either due to memory footprint, performance or difficulty integrating well with advanced Linux features. ksmbd is a new kernel module which implements the server-side of the SMB3 protocol. The target is to provide optimized performance, GPLv2 SMB server, better lease handling (distributed caching). The bigger goal is to add new features more rapidly (e.g. RDMA aka "smbdirect", and recent encryption and signing improvements to the protocol) which are easier to develop on a smaller, more tightly optimized kernel server than for example in Samba. The Samba project is much broader in scope (tools, security services, LDAP, Active Directory Domain Controller, and a cross platform file server for a wider variety of purposes) but the user space file server portion of Samba has proved hard to optimize for some Linux workloads, including for smaller devices. This is not meant to replace Samba, but rather be an extension to allow better optimizing for Linux, and will continue to integrate well with Samba user space tools and libraries where appropriate. Working with the Samba team we have already made sure that the configuration files and xattrs are in a compatible format between the kernel and user space server. Architecture ============ |--- ... --------|--- ksmbd/3 - Client 3 |-------|--- ksmbd/2 - Client 2 | | ____________________________________________________ | | |- Client 1 | <--- Socket ---|--- ksmbd/1 <<= Authentication : NTLM/NTLM2, Kerberos | | | | | <<= SMB engine : SMB2, SMB2.1, SMB3, SMB3.0.2, | | | | | SMB3.1.1 | | | | |____________________________________________________| | | | | | |--- VFS --- Local Filesystem | | KERNEL |--- ksmbd/0(forker kthread) ---------------||--------------------------------------------------------------- USER || || communication using NETLINK || ______________________________________________ || | | ksmbd.mountd <<= DCE/RPC(srvsvc, wkssvc, samr, lsarpc) | ^ | <<= configure shares setting, user accounts | | |______________________________________________| | |------ smb.conf(config file) | |------ ksmbdpwd.db(user account/password file) ^ ksmbd.adduser ------------| The subset of performance related operations(open/read/write/close etc.) belong in kernelspace(ksmbd) and the other subset which belong to operations(DCE/RPC, user account/share database) which are not really related with performance are handled in userspace(ksmbd.mountd). When the ksmbd.mountd is started, It starts up a forker thread at initialization time and opens a dedicated port 445 for listening to SMB requests. Whenever new clients make request, Forker thread will accept the client connection and fork a new thread for dedicated communication channel between the client and the server. ksmbd feature status ==================== ============================== ================================================= Feature name Status ============================== ================================================= Dialects Supported. SMB2.1 SMB3.0, SMB3.1.1 dialects (intentionally excludes security vulnerable SMB1 dialect). Auto Negotiation Supported. Compound Request Supported. Oplock Cache Mechanism Supported. SMB2 leases(v1 lease) Supported. Directory leases(v2 lease) Planned for future. Multi-credits Supported. NTLM/NTLMv2 Supported. HMAC-SHA256 Signing Supported. Secure negotiate Supported. Signing Update Supported. Pre-authentication integrity Supported. SMB3 encryption(CCM, GCM) Supported. (CCM and GCM128 supported, GCM256 in progress) SMB direct(RDMA) Partially Supported. SMB3 Multi-channel is required to connect to Windows client. SMB3 Multi-channel In Progress. SMB3.1.1 POSIX extension Supported. ACLs Partially Supported. only DACLs available, SACLs (auditing) is planned for the future. For ownership (SIDs) ksmbd generates random subauth values(then store it to disk) and use uid/gid get from inode as RID for local domain SID. The current acl implementation is limited to standalone server, not a domain member. Integration with Samba tools is being worked on to allow future support for running as a domain member. Kerberos Supported. Durable handle v1,v2 Planned for future. Persistent handle Planned for future. SMB2 notify Planned for future. Sparse file support Supported. DCE/RPC support Partially Supported. a few calls(NetShareEnumAll, NetServerGetInfo, SAMR, LSARPC) that are needed for file server handled via netlink interface from ksmbd.mountd. Additional integration with Samba tools and libraries via upcall is being investigated to allow support for additional DCE/RPC management calls (and future support for Witness protocol e.g.) ksmbd/nfsd interoperability Planned for future. The features that ksmbd support are Leases, Notify, ACLs and Share modes. ============================== ================================================= All features required as file server are currently implemented in ksmbd. In particular, the implementation of SMB Direct(RDMA) is only currently possible with ksmbd (among Linux servers) Stability ========= It has been proved to be stable. A significant amount of xfstests pass and are run regularly from Linux to Linux: http://smb3-test-rhel-75.southcentralus.cloudapp.azure.com/#/builders/8/builds/36 In addition regression tests using the broadest SMB3 functional test suite (Samba's "smbtorture") are run on every checkin. It has already been used by many other open source toolkits and commercial companies that need NAS functionality. Their issues have been fixed and contributions are applied into ksmbd. Ksmbd has been well tested and verified in the field and market. Mailing list and repositories ============================= - linux-cifsd-devel@lists.sourceforge.net - https://github.com/smfrench/smb3-kernel/tree/cifsd-for-next - https://github.com/cifsd-team/cifsd (out-of-tree) - https://github.com/cifsd-team/ksmbd-tools How to run ksmbd ================ a. Download ksmbd-tools and compile them. - https://github.com/cifsd-team/ksmbd-tools b. Create user/password for SMB share. # mkdir /etc/ksmbd/ # ksmbd.adduser -a <Enter USERNAME for SMB share access> c. Create /etc/ksmbd/smb.conf file, add SMB share in smb.conf file - Refer smb.conf.example and Documentation/configuration.txt in ksmbd-tools d. Insert ksmbd.ko module # insmod ksmbd.ko e. Start ksmbd user space daemon # ksmbd.mountd f. Access share from Windows or Linux using SMB e.g. "mount -t cifs //server/share /mnt ..." v3: - fix boolreturn.cocci warnings. (kernel test robot) - fix xfstests generic/504 test failure. - do not use 0 or 0xFFFFFFFF for TreeID. (Marios Makassikis) - add support for FSCTL_DUPLICATE_EXTENTS_TO_FILE. - fix build error without CONFIG_OID_REGISTRY. (Wei Yongjun) - fix invalid memory access in smb2_write(). (Coverity Scan) - add support for AES256 encryption. - fix potential null-ptr-deref in destroy_previous_session(). (Marios Makassikis). - update out_buf_len in smb2_populate_readdir_entry(). (Marios Makassikis) - handle ksmbd_session_rpc_open() failure in create_smb2_pipe(). (Marios Makassikis) - call smb2_set_err_rsp() in smb2_read/smb2_write error path. (Marios Makassikis) - add ksmbd/nfsd interoperability to feature table. (Amir Goldstein) - fix regression in smb2_get_info. (Sebastian Gottschall) - remove is_attributes_write_allowed() wrapper. (Marios Makassikis) - update access check in set_file_allocation_info/set_end_of_file_info. (Marios Makassikis) v2: - fix an error code in smb2_read(). (Dan Carpenter) - fix error handling in ksmbd_server_init() (Dan Carpenter) - remove redundant assignment to variable err. (Colin Ian King) - remove unneeded macros. - fix wrong use of rw semaphore in __session_create(). - use kmalloc() for small allocations. - add the check to work file lock and rename behaviors like Windows unless POSIX extensions are negotiated. - clean-up codes using chechpatch.pl --strict. - merge time_wrappers.h into smb_common.h. - fix wrong prototype in comment (kernel test robot). - fix implicit declaration of function 'groups_alloc' (kernel test robot). - fix implicit declaration of function 'locks_alloc_lock' (kernel test robot). - remove smack inherit leftovers. - remove calling d_path in error paths. - handle unhashed dentry in ksmbd_vfs_mkdir. - use file_inode() instead of d_inode(). - remove useless error handling in ksmbd_vfs_read. - use xarray instead of linked list for tree connect list. - remove stale prototype and variables. - fix memory leak when loop ends (coverity-bot, Muhammad Usama Anjum). - use kfree to free memory allocated by kmalloc or kzalloc (Muhammad Usama Anjum). - fix memdup.cocci warnings (kernel test robot) - remove wrappers of kvmalloc/kvfree. - change the reference to configuration.txt (Mauro Carvalho Chehab). - prevent a integer overflow in wm_alloc(). - select SG_POOL for SMB_SERVER_SMBDIRECT. (Zhang Xiaoxu). - remove unused including <linux/version.h> (Tian Tao). - declare ida statically. - add the check if parent is stable by unexpected rename. - get parent dentry from child in ksmbd_vfs_remove_file(). - re-implement ksmbd_vfs_kern_path. - fix reference count decrement of unclaimed file in __ksmbd_lookup_fd. - remove smb2_put_name(). (Marios Makassikis). - remove unused smberr.h, nterr.c and netmisc.c. - fix potential null-ptr-deref in smb2_open() (Marios Makassikis). - use d_inode(). - remove the dead code of unimplemented durable handle. - use the generic one in lib/asn1_decoder.c v1: - fix a handful of spelling mistakes (Colin Ian King) - fix a precedence bug in parse_dacl() (Dan Carpenter) - fix a IS_ERR() vs NULL bug (Dan Carpenter) - fix a use after free on error path (Dan Carpenter) - update cifsd.rst Documentation - remove unneeded FIXME comments - fix static checker warnings (Dan Carpenter) - fix WARNING: unmet direct dependencies detected for CRYPTO_ARC4 (Randy Dunlap) - uniquify extract_sharename() (Stephen Rothwell) - fix WARNING: document isn't included in any toctree (Stephen Rothwell) - fix WARNING: Title overline too short (Stephen Rothwell) - fix warning: variable 'total_ace_size' and 'posix_ccontext'set but not used (kernel test rotbot) - fix incorrect function comments (kernel test robot) Namjae Jeon (10): cifsd: add document cifsd: add server handler cifsd: add trasport layers cifsd: add authentication cifsd: add smb3 engine part 1 cifsd: add smb3 engine part 2 cifsd: add oplock/lease cache mechanism cifsd: add file operations cifsd: add Kconfig and Makefile MAINTAINERS: add cifsd kernel server Documentation/filesystems/cifs/cifsd.rst | 164 + Documentation/filesystems/cifs/index.rst | 10 + Documentation/filesystems/index.rst | 2 +- MAINTAINERS | 12 +- fs/Kconfig | 1 + fs/Makefile | 1 + fs/cifsd/Kconfig | 68 + fs/cifsd/Makefile | 17 + fs/cifsd/asn1.c | 352 + fs/cifsd/asn1.h | 29 + fs/cifsd/auth.c | 1344 ++++ fs/cifsd/auth.h | 90 + fs/cifsd/buffer_pool.c | 264 + fs/cifsd/buffer_pool.h | 20 + fs/cifsd/connection.c | 411 ++ fs/cifsd/connection.h | 208 + fs/cifsd/crypto_ctx.c | 286 + fs/cifsd/crypto_ctx.h | 77 + fs/cifsd/glob.h | 64 + fs/cifsd/ksmbd_server.h | 283 + fs/cifsd/ksmbd_work.c | 93 + fs/cifsd/ksmbd_work.h | 110 + fs/cifsd/mgmt/ksmbd_ida.c | 46 + fs/cifsd/mgmt/ksmbd_ida.h | 34 + fs/cifsd/mgmt/share_config.c | 239 + fs/cifsd/mgmt/share_config.h | 81 + fs/cifsd/mgmt/tree_connect.c | 122 + fs/cifsd/mgmt/tree_connect.h | 56 + fs/cifsd/mgmt/user_config.c | 70 + fs/cifsd/mgmt/user_config.h | 66 + fs/cifsd/mgmt/user_session.c | 328 + fs/cifsd/mgmt/user_session.h | 103 + fs/cifsd/misc.c | 340 + fs/cifsd/misc.h | 44 + fs/cifsd/ndr.c | 347 + fs/cifsd/ndr.h | 21 + fs/cifsd/nterr.h | 545 ++ fs/cifsd/ntlmssp.h | 169 + fs/cifsd/oplock.c | 1667 +++++ fs/cifsd/oplock.h | 133 + fs/cifsd/server.c | 631 ++ fs/cifsd/server.h | 60 + fs/cifsd/smb2misc.c | 435 ++ fs/cifsd/smb2ops.c | 300 + fs/cifsd/smb2pdu.c | 8151 ++++++++++++++++++++++ fs/cifsd/smb2pdu.h | 1664 +++++ fs/cifsd/smb_common.c | 652 ++ fs/cifsd/smb_common.h | 544 ++ fs/cifsd/smbacl.c | 1317 ++++ fs/cifsd/smbacl.h | 201 + fs/cifsd/smbfsctl.h | 91 + fs/cifsd/smbstatus.h | 1822 +++++ fs/cifsd/spnego_negtokeninit.asn1 | 43 + fs/cifsd/spnego_negtokentarg.asn1 | 19 + fs/cifsd/transport_ipc.c | 881 +++ fs/cifsd/transport_ipc.h | 54 + fs/cifsd/transport_rdma.c | 2034 ++++++ fs/cifsd/transport_rdma.h | 61 + fs/cifsd/transport_tcp.c | 618 ++ fs/cifsd/transport_tcp.h | 13 + fs/cifsd/unicode.c | 383 + fs/cifsd/unicode.h | 356 + fs/cifsd/uniupr.h | 268 + fs/cifsd/vfs.c | 1995 ++++++ fs/cifsd/vfs.h | 274 + fs/cifsd/vfs_cache.c | 683 ++ fs/cifsd/vfs_cache.h | 185 + 67 files changed, 32050 insertions(+), 2 deletions(-) create mode 100644 Documentation/filesystems/cifs/cifsd.rst create mode 100644 Documentation/filesystems/cifs/index.rst create mode 100644 fs/cifsd/Kconfig create mode 100644 fs/cifsd/Makefile create mode 100644 fs/cifsd/asn1.c create mode 100644 fs/cifsd/asn1.h create mode 100644 fs/cifsd/auth.c create mode 100644 fs/cifsd/auth.h create mode 100644 fs/cifsd/buffer_pool.c create mode 100644 fs/cifsd/buffer_pool.h create mode 100644 fs/cifsd/connection.c create mode 100644 fs/cifsd/connection.h create mode 100644 fs/cifsd/crypto_ctx.c create mode 100644 fs/cifsd/crypto_ctx.h create mode 100644 fs/cifsd/glob.h create mode 100644 fs/cifsd/ksmbd_server.h create mode 100644 fs/cifsd/ksmbd_work.c create mode 100644 fs/cifsd/ksmbd_work.h create mode 100644 fs/cifsd/mgmt/ksmbd_ida.c create mode 100644 fs/cifsd/mgmt/ksmbd_ida.h create mode 100644 fs/cifsd/mgmt/share_config.c create mode 100644 fs/cifsd/mgmt/share_config.h create mode 100644 fs/cifsd/mgmt/tree_connect.c create mode 100644 fs/cifsd/mgmt/tree_connect.h create mode 100644 fs/cifsd/mgmt/user_config.c create mode 100644 fs/cifsd/mgmt/user_config.h create mode 100644 fs/cifsd/mgmt/user_session.c create mode 100644 fs/cifsd/mgmt/user_session.h create mode 100644 fs/cifsd/misc.c create mode 100644 fs/cifsd/misc.h create mode 100644 fs/cifsd/ndr.c create mode 100644 fs/cifsd/ndr.h create mode 100644 fs/cifsd/nterr.h create mode 100644 fs/cifsd/ntlmssp.h create mode 100644 fs/cifsd/oplock.c create mode 100644 fs/cifsd/oplock.h create mode 100644 fs/cifsd/server.c create mode 100644 fs/cifsd/server.h create mode 100644 fs/cifsd/smb2misc.c create mode 100644 fs/cifsd/smb2ops.c create mode 100644 fs/cifsd/smb2pdu.c create mode 100644 fs/cifsd/smb2pdu.h create mode 100644 fs/cifsd/smb_common.c create mode 100644 fs/cifsd/smb_common.h create mode 100644 fs/cifsd/smbacl.c create mode 100644 fs/cifsd/smbacl.h create mode 100644 fs/cifsd/smbfsctl.h create mode 100644 fs/cifsd/smbstatus.h create mode 100644 fs/cifsd/spnego_negtokeninit.asn1 create mode 100644 fs/cifsd/spnego_negtokentarg.asn1 create mode 100644 fs/cifsd/transport_ipc.c create mode 100644 fs/cifsd/transport_ipc.h create mode 100644 fs/cifsd/transport_rdma.c create mode 100644 fs/cifsd/transport_rdma.h create mode 100644 fs/cifsd/transport_tcp.c create mode 100644 fs/cifsd/transport_tcp.h create mode 100644 fs/cifsd/unicode.c create mode 100644 fs/cifsd/unicode.h create mode 100644 fs/cifsd/uniupr.h create mode 100644 fs/cifsd/vfs.c create mode 100644 fs/cifsd/vfs.h create mode 100644 fs/cifsd/vfs_cache.c create mode 100644 fs/cifsd/vfs_cache.h -- 2.17.1 ^ permalink raw reply [flat|nested] 11+ messages in thread
[parent not found: <CGME20210521063551epcas1p4f9c25b83b0088b3631c0860f5f715c52@epcas1p4.samsung.com>]
* [PATCH v3 01/10] cifsd: add document [not found] ` <CGME20210521063551epcas1p4f9c25b83b0088b3631c0860f5f715c52@epcas1p4.samsung.com> @ 2021-05-21 6:26 ` Namjae Jeon 0 siblings, 0 replies; 11+ messages in thread From: Namjae Jeon @ 2021-05-21 6:26 UTC (permalink / raw) To: linux-fsdevel, linux-kernel, linux-cifs Cc: linux-cifsd-devel, smfrench, senozhatsky, hyc.lee, viro, hch, hch, ronniesahlberg, aurelien.aptel, aaptel, sandeen, dan.carpenter, willy, Namjae Jeon, Sergey Senozhatsky, Steve French This adds a document describing ksmbd design, key features and usage. Signed-off-by: Namjae Jeon <namjae.jeon@samsung.com> Signed-off-by: Sergey Senozhatsky <sergey.senozhatsky@gmail.com> Signed-off-by: Hyunchul Lee <hyc.lee@gmail.com> Acked-by: Ronnie Sahlberg <lsahlber@redhat.com> Signed-off-by: Steve French <stfrench@microsoft.com> --- Documentation/filesystems/cifs/cifsd.rst | 164 +++++++++++++++++++++++ Documentation/filesystems/cifs/index.rst | 10 ++ Documentation/filesystems/index.rst | 2 +- 3 files changed, 175 insertions(+), 1 deletion(-) create mode 100644 Documentation/filesystems/cifs/cifsd.rst create mode 100644 Documentation/filesystems/cifs/index.rst diff --git a/Documentation/filesystems/cifs/cifsd.rst b/Documentation/filesystems/cifs/cifsd.rst new file mode 100644 index 000000000000..01a0be272ce6 --- /dev/null +++ b/Documentation/filesystems/cifs/cifsd.rst @@ -0,0 +1,164 @@ +.. SPDX-License-Identifier: GPL-2.0 + +========================== +CIFSD - SMB3 Kernel Server +========================== + +CIFSD is a linux kernel server which implements SMB3 protocol in kernel space +for sharing files over network. + +CIFSD architecture +================== + +The subset of performance related operations belong in kernelspace and +the other subset which belong to operations which are not really related with +performance in userspace. So, DCE/RPC management that has historically resulted +into number of buffer overflow issues and dangerous security bugs and user +account management are implemented in user space as ksmbd.mountd. +File operations that are related with performance (open/read/write/close etc.) +in kernel space (ksmbd). This also allows for easier integration with VFS +interface for all file operations. + +ksmbd (kernel daemon) +--------------------- + +When the server daemon is started, It starts up a forker thread +(ksmbd/interface name) at initialization time and open a dedicated port 445 +for listening to SMB requests. Whenever new clients make request, Forker +thread will accept the client connection and fork a new thread for dedicated +communication channel between the client and the server. It allows for parallel +processing of SMB requests(commands) from clients as well as allowing for new +clients to make new connections. Each instance is named ksmbd/1~n(port number) +to indicate connected clients. Depending on the SMB request types, each new +thread can decide to pass through the commands to the user space (ksmbd.mountd), +currently DCE/RPC commands are identified to be handled through the user space. +To further utilize the linux kernel, it has been chosen to process the commands +as workitems and to be executed in the handlers of the ksmbd-io kworker threads. +It allows for multiplexing of the handlers as the kernel take care of initiating +extra worker threads if the load is increased and vice versa, if the load is +decreased it destroys the extra worker threads. So, after connection is +established with client. Dedicated ksmbd/1..n(port number) takes complete +ownership of receiving/parsing of SMB commands. Each received command is worked +in parallel i.e., There can be multiple clients commands which are worked in +parallel. After receiving each command a separated kernel workitem is prepared +for each command which is further queued to be handled by ksmbd-io kworkers. +So, each SMB workitem is queued to the kworkers. This allows the benefit of load +sharing to be managed optimally by the default kernel and optimizing client +performance by handling client commands in parallel. + +ksmbd.mountd (user space daemon) +-------------------------------- + +ksmbd.mountd is userspace process to, transfer user account and password that +are registered using ksmbd.adduser(part of utils for user space). Further it +allows sharing information parameters that parsed from smb.conf to ksmbd in +kernel. For the execution part it has a daemon which is continuously running +and connected to the kernel interface using netlink socket, it waits for the +requests(dcerpc and share/user info). It handles RPC calls (at a minimum few +dozen) that are most important for file server from NetShareEnum and +NetServerGetInfo. Complete DCE/RPC response is prepared from the user space +and passed over to the associated kernel thread for the client. + + +CIFSD Feature Status +==================== + +============================== ================================================= +Feature name Status +============================== ================================================= +Dialects Supported. SMB2.1 SMB3.0, SMB3.1.1 dialects + (intentionally excludes security vulnerable SMB1 + dialect). +Auto Negotiation Supported. +Compound Request Supported. +Oplock Cache Mechanism Supported. +SMB2 leases(v1 lease) Supported. +Directory leases(v2 lease) Planned for future. +Multi-credits Supported. +NTLM/NTLMv2 Supported. +HMAC-SHA256 Signing Supported. +Secure negotiate Supported. +Signing Update Supported. +Pre-authentication integrity Supported. +SMB3 encryption(CCM, GCM) Supported. (CCM and GCM128 supported, GCM256 in + progress) +SMB direct(RDMA) Partially Supported. SMB3 Multi-channel is + required to connect to Windows client. +SMB3 Multi-channel In Progress. +SMB3.1.1 POSIX extension Supported. +ACLs Partially Supported. only DACLs available, SACLs + (auditing) is planned for the future. For + ownership (SIDs) ksmbd generates random subauth + values(then store it to disk) and use uid/gid + get from inode as RID for local domain SID. + The current acl implementation is limited to + standalone server, not a domain member. + Integration with Samba tools is being worked on + to allow future support for running as a domain + member. +Kerberos Supported. +Durable handle v1,v2 Planned for future. +Persistent handle Planned for future. +SMB2 notify Planned for future. +Sparse file support Supported. +DCE/RPC support Partially Supported. a few calls(NetShareEnumAll, + NetServerGetInfo, SAMR, LSARPC) that are needed + for file server handled via netlink interface + from ksmbd.mountd. Additional integration with + Samba tools and libraries via upcall is being + investigated to allow support for additional + DCE/RPC management calls (and future support + for Witness protocol e.g.) +ksmbd/nfsd interoperability Planned for future. The features that ksmbd + support are Leases, Notify, ACLs and Share modes. +============================== ================================================= + + +How to run +========== + +1. Download ksmbd-tools and compile them. + - https://github.com/cifsd-team/ksmbd-tools + +2. Create user/password for SMB share. + + # mkdir /etc/ksmbd/ + # ksmbd.adduser -a <Enter USERNAME for SMB share access> + +3. Create /etc/ksmbd/smb.conf file, add SMB share in smb.conf file + - Refer smb.conf.example and + https://github.com/cifsd-team/ksmbd-tools/blob/master/Documentation/configuration.txt + +4. Insert ksmbd.ko module + + # insmod ksmbd.ko + +5. Start ksmbd user space daemon + # ksmbd.mountd + +6. Access share from Windows or Linux using CIFS + +Shutdown CIFSD +============== + +1. kill user and kernel space daemon + # sudo ksmbd.control -s + +How to turn debug print on +========================== + +Each layer +/sys/class/ksmbd-control/debug + +1. Enable all component prints + # sudo ksmbd.control -d "all" + +2. Enable one of components(smb, auth, vfs, oplock, ipc, conn, rdma) + # sudo ksmbd.control -d "smb" + +3. Show what prints are enable. + # cat/sys/class/ksmbd-control/debug + [smb] auth vfs oplock ipc conn [rdma] + +4. Disable prints: + If you try the selected component once more, It is disabled without brackets. diff --git a/Documentation/filesystems/cifs/index.rst b/Documentation/filesystems/cifs/index.rst new file mode 100644 index 000000000000..e762586b5dc7 --- /dev/null +++ b/Documentation/filesystems/cifs/index.rst @@ -0,0 +1,10 @@ +=============================== +CIFS +=============================== + + +.. toctree:: + :maxdepth: 1 + + cifsd + cifsroot diff --git a/Documentation/filesystems/index.rst b/Documentation/filesystems/index.rst index d4853cb919d2..bdba80ae2bb1 100644 --- a/Documentation/filesystems/index.rst +++ b/Documentation/filesystems/index.rst @@ -72,7 +72,7 @@ Documentation for filesystem implementations. befs bfs btrfs - cifs/cifsroot + cifs/index ceph coda configfs -- 2.17.1 ^ permalink raw reply related [flat|nested] 11+ messages in thread
[parent not found: <CGME20210521063552epcas1p3872f5619ef5e9f2f3cad7c0651b5edcb@epcas1p3.samsung.com>]
* [PATCH v3 02/10] cifsd: add server handler [not found] ` <CGME20210521063552epcas1p3872f5619ef5e9f2f3cad7c0651b5edcb@epcas1p3.samsung.com> @ 2021-05-21 6:26 ` Namjae Jeon 0 siblings, 0 replies; 11+ messages in thread From: Namjae Jeon @ 2021-05-21 6:26 UTC (permalink / raw) To: linux-fsdevel, linux-kernel, linux-cifs Cc: linux-cifsd-devel, smfrench, senozhatsky, hyc.lee, viro, hch, hch, ronniesahlberg, aurelien.aptel, aaptel, sandeen, dan.carpenter, willy, Namjae Jeon, Sergey Senozhatsky, Steve French This adds server handler for central processing. Signed-off-by: Namjae Jeon <namjae.jeon@samsung.com> Signed-off-by: Sergey Senozhatsky <sergey.senozhatsky@gmail.com> Signed-off-by: Hyunchul Lee <hyc.lee@gmail.com> Acked-by: Ronnie Sahlberg <lsahlber@redhat.com> Signed-off-by: Steve French <stfrench@microsoft.com> --- fs/cifsd/glob.h | 64 ++++ fs/cifsd/ksmbd_server.h | 283 ++++++++++++++++++ fs/cifsd/ksmbd_work.c | 93 ++++++ fs/cifsd/ksmbd_work.h | 110 +++++++ fs/cifsd/server.c | 631 ++++++++++++++++++++++++++++++++++++++++ fs/cifsd/server.h | 60 ++++ 6 files changed, 1241 insertions(+) create mode 100644 fs/cifsd/glob.h create mode 100644 fs/cifsd/ksmbd_server.h create mode 100644 fs/cifsd/ksmbd_work.c create mode 100644 fs/cifsd/ksmbd_work.h create mode 100644 fs/cifsd/server.c create mode 100644 fs/cifsd/server.h diff --git a/fs/cifsd/glob.h b/fs/cifsd/glob.h new file mode 100644 index 000000000000..ffeaf8aa5595 --- /dev/null +++ b/fs/cifsd/glob.h @@ -0,0 +1,64 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2016 Namjae Jeon <linkinjeon@kernel.org> + * Copyright (C) 2018 Samsung Electronics Co., Ltd. + */ + +#ifndef __KSMBD_GLOB_H +#define __KSMBD_GLOB_H + +#include <linux/ctype.h> + +#include "unicode.h" +#include "vfs_cache.h" + +#define KSMBD_VERSION "3.1.9" + +/* @FIXME clean up this code */ + +extern int ksmbd_debug_types; + +#define DATA_STREAM 1 +#define DIR_STREAM 2 + +#define KSMBD_DEBUG_SMB BIT(0) +#define KSMBD_DEBUG_AUTH BIT(1) +#define KSMBD_DEBUG_VFS BIT(2) +#define KSMBD_DEBUG_OPLOCK BIT(3) +#define KSMBD_DEBUG_IPC BIT(4) +#define KSMBD_DEBUG_CONN BIT(5) +#define KSMBD_DEBUG_RDMA BIT(6) +#define KSMBD_DEBUG_ALL (KSMBD_DEBUG_SMB | KSMBD_DEBUG_AUTH | \ + KSMBD_DEBUG_VFS | KSMBD_DEBUG_OPLOCK | \ + KSMBD_DEBUG_IPC | KSMBD_DEBUG_CONN | \ + KSMBD_DEBUG_RDMA) + +#ifndef ksmbd_pr_fmt +#ifdef SUBMOD_NAME +#define ksmbd_pr_fmt(fmt) "ksmbd: " SUBMOD_NAME ": " fmt +#else +#define ksmbd_pr_fmt(fmt) "ksmbd: " fmt +#endif +#endif + +#define ksmbd_debug(type, fmt, ...) \ + do { \ + if (ksmbd_debug_types & KSMBD_DEBUG_##type) \ + pr_info(ksmbd_pr_fmt("%s:%d: " fmt), \ + __func__, \ + __LINE__, \ + ##__VA_ARGS__); \ + } while (0) + +#define ksmbd_info(fmt, ...) \ + pr_info(ksmbd_pr_fmt(fmt), ##__VA_ARGS__) + +#define ksmbd_err(fmt, ...) \ + pr_err(ksmbd_pr_fmt("%s:%d: " fmt), \ + __func__, \ + __LINE__, \ + ##__VA_ARGS__) + +#define UNICODE_LEN(x) ((x) * 2) + +#endif /* __KSMBD_GLOB_H */ diff --git a/fs/cifsd/ksmbd_server.h b/fs/cifsd/ksmbd_server.h new file mode 100644 index 000000000000..442077a1e77b --- /dev/null +++ b/fs/cifsd/ksmbd_server.h @@ -0,0 +1,283 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2018 Samsung Electronics Co., Ltd. + * + * linux-ksmbd-devel@lists.sourceforge.net + */ + +#ifndef _LINUX_KSMBD_SERVER_H +#define _LINUX_KSMBD_SERVER_H + +#include <linux/types.h> + +#define KSMBD_GENL_NAME "SMBD_GENL" +#define KSMBD_GENL_VERSION 0x01 + +#ifndef ____ksmbd_align +#define ____ksmbd_align __aligned(4) +#endif + +#define KSMBD_REQ_MAX_ACCOUNT_NAME_SZ 48 +#define KSMBD_REQ_MAX_HASH_SZ 18 +#define KSMBD_REQ_MAX_SHARE_NAME 64 + +struct ksmbd_heartbeat { + __u32 handle; +}; + +/* + * Global config flags. + */ +#define KSMBD_GLOBAL_FLAG_INVALID (0) +#define KSMBD_GLOBAL_FLAG_SMB2_LEASES BIT(0) +#define KSMBD_GLOBAL_FLAG_CACHE_TBUF BIT(1) +#define KSMBD_GLOBAL_FLAG_CACHE_RBUF BIT(2) +#define KSMBD_GLOBAL_FLAG_SMB2_ENCRYPTION BIT(3) + +struct ksmbd_startup_request { + __u32 flags; + __s32 signing; + __s8 min_prot[16]; + __s8 max_prot[16]; + __s8 netbios_name[16]; + __s8 work_group[64]; + __s8 server_string[64]; + __u16 tcp_port; + __u16 ipc_timeout; + __u32 deadtime; + __u32 file_max; + __u32 smb2_max_write; + __u32 smb2_max_read; + __u32 smb2_max_trans; + __u32 share_fake_fscaps; + __u32 sub_auth[3]; + __u32 ifc_list_sz; + __s8 ____payload[0]; +} ____ksmbd_align; + +#define KSMBD_STARTUP_CONFIG_INTERFACES(s) ((s)->____payload) + +struct ksmbd_shutdown_request { + __s32 reserved; +} ____ksmbd_align; + +struct ksmbd_login_request { + __u32 handle; + __s8 account[KSMBD_REQ_MAX_ACCOUNT_NAME_SZ]; +} ____ksmbd_align; + +struct ksmbd_login_response { + __u32 handle; + __u32 gid; + __u32 uid; + __s8 account[KSMBD_REQ_MAX_ACCOUNT_NAME_SZ]; + __u16 status; + __u16 hash_sz; + __s8 hash[KSMBD_REQ_MAX_HASH_SZ]; +} ____ksmbd_align; + +struct ksmbd_share_config_request { + __u32 handle; + __s8 share_name[KSMBD_REQ_MAX_SHARE_NAME]; +} ____ksmbd_align; + +struct ksmbd_share_config_response { + __u32 handle; + __u32 flags; + __u16 create_mask; + __u16 directory_mask; + __u16 force_create_mode; + __u16 force_directory_mode; + __u16 force_uid; + __u16 force_gid; + __u32 veto_list_sz; + __s8 ____payload[0]; +} ____ksmbd_align; + +#define KSMBD_SHARE_CONFIG_VETO_LIST(s) ((s)->____payload) +#define KSMBD_SHARE_CONFIG_PATH(s) \ + ({ \ + char *p = (s)->____payload; \ + if ((s)->veto_list_sz) \ + p += (s)->veto_list_sz + 1; \ + p; \ + }) + +struct ksmbd_tree_connect_request { + __u32 handle; + __u16 account_flags; + __u16 flags; + __u64 session_id; + __u64 connect_id; + __s8 account[KSMBD_REQ_MAX_ACCOUNT_NAME_SZ]; + __s8 share[KSMBD_REQ_MAX_SHARE_NAME]; + __s8 peer_addr[64]; +} ____ksmbd_align; + +struct ksmbd_tree_connect_response { + __u32 handle; + __u16 status; + __u16 connection_flags; +} ____ksmbd_align; + +struct ksmbd_tree_disconnect_request { + __u64 session_id; + __u64 connect_id; +} ____ksmbd_align; + +struct ksmbd_logout_request { + __s8 account[KSMBD_REQ_MAX_ACCOUNT_NAME_SZ]; +} ____ksmbd_align; + +struct ksmbd_rpc_command { + __u32 handle; + __u32 flags; + __u32 payload_sz; + __u8 payload[0]; +} ____ksmbd_align; + +struct ksmbd_spnego_authen_request { + __u32 handle; + __u16 spnego_blob_len; + __u8 spnego_blob[0]; +} ____ksmbd_align; + +struct ksmbd_spnego_authen_response { + __u32 handle; + struct ksmbd_login_response login_response; + __u16 session_key_len; + __u16 spnego_blob_len; + __u8 payload[0]; /* session key + AP_REP */ +} ____ksmbd_align; + +/* + * This also used as NETLINK attribute type value. + * + * NOTE: + * Response message type value should be equal to + * request message type value + 1. + */ +enum ksmbd_event { + KSMBD_EVENT_UNSPEC = 0, + KSMBD_EVENT_HEARTBEAT_REQUEST, + + KSMBD_EVENT_STARTING_UP, + KSMBD_EVENT_SHUTTING_DOWN, + + KSMBD_EVENT_LOGIN_REQUEST, + KSMBD_EVENT_LOGIN_RESPONSE = 5, + + KSMBD_EVENT_SHARE_CONFIG_REQUEST, + KSMBD_EVENT_SHARE_CONFIG_RESPONSE, + + KSMBD_EVENT_TREE_CONNECT_REQUEST, + KSMBD_EVENT_TREE_CONNECT_RESPONSE, + + KSMBD_EVENT_TREE_DISCONNECT_REQUEST = 10, + + KSMBD_EVENT_LOGOUT_REQUEST, + + KSMBD_EVENT_RPC_REQUEST, + KSMBD_EVENT_RPC_RESPONSE, + + KSMBD_EVENT_SPNEGO_AUTHEN_REQUEST, + KSMBD_EVENT_SPNEGO_AUTHEN_RESPONSE = 15, + + KSMBD_EVENT_MAX +}; + +enum KSMBD_TREE_CONN_STATUS { + KSMBD_TREE_CONN_STATUS_OK = 0, + KSMBD_TREE_CONN_STATUS_NOMEM, + KSMBD_TREE_CONN_STATUS_NO_SHARE, + KSMBD_TREE_CONN_STATUS_NO_USER, + KSMBD_TREE_CONN_STATUS_INVALID_USER, + KSMBD_TREE_CONN_STATUS_HOST_DENIED = 5, + KSMBD_TREE_CONN_STATUS_CONN_EXIST, + KSMBD_TREE_CONN_STATUS_TOO_MANY_CONNS, + KSMBD_TREE_CONN_STATUS_TOO_MANY_SESSIONS, + KSMBD_TREE_CONN_STATUS_ERROR, +}; + +/* + * User config flags. + */ +#define KSMBD_USER_FLAG_INVALID (0) +#define KSMBD_USER_FLAG_OK BIT(0) +#define KSMBD_USER_FLAG_BAD_PASSWORD BIT(1) +#define KSMBD_USER_FLAG_BAD_UID BIT(2) +#define KSMBD_USER_FLAG_BAD_USER BIT(3) +#define KSMBD_USER_FLAG_GUEST_ACCOUNT BIT(4) + +/* + * Share config flags. + */ +#define KSMBD_SHARE_FLAG_INVALID (0) +#define KSMBD_SHARE_FLAG_AVAILABLE BIT(0) +#define KSMBD_SHARE_FLAG_BROWSEABLE BIT(1) +#define KSMBD_SHARE_FLAG_WRITEABLE BIT(2) +#define KSMBD_SHARE_FLAG_READONLY BIT(3) +#define KSMBD_SHARE_FLAG_GUEST_OK BIT(4) +#define KSMBD_SHARE_FLAG_GUEST_ONLY BIT(5) +#define KSMBD_SHARE_FLAG_STORE_DOS_ATTRS BIT(6) +#define KSMBD_SHARE_FLAG_OPLOCKS BIT(7) +#define KSMBD_SHARE_FLAG_PIPE BIT(8) +#define KSMBD_SHARE_FLAG_HIDE_DOT_FILES BIT(9) +#define KSMBD_SHARE_FLAG_INHERIT_OWNER BIT(10) +#define KSMBD_SHARE_FLAG_STREAMS BIT(11) +#define KSMBD_SHARE_FLAG_FOLLOW_SYMLINKS BIT(12) +#define KSMBD_SHARE_FLAG_ACL_XATTR BIT(13) + +/* + * Tree connect request flags. + */ +#define KSMBD_TREE_CONN_FLAG_REQUEST_SMB1 (0) +#define KSMBD_TREE_CONN_FLAG_REQUEST_IPV6 BIT(0) +#define KSMBD_TREE_CONN_FLAG_REQUEST_SMB2 BIT(1) + +/* + * Tree connect flags. + */ +#define KSMBD_TREE_CONN_FLAG_GUEST_ACCOUNT BIT(0) +#define KSMBD_TREE_CONN_FLAG_READ_ONLY BIT(1) +#define KSMBD_TREE_CONN_FLAG_WRITABLE BIT(2) +#define KSMBD_TREE_CONN_FLAG_ADMIN_ACCOUNT BIT(3) + +/* + * RPC over IPC. + */ +#define KSMBD_RPC_METHOD_RETURN BIT(0) +#define KSMBD_RPC_SRVSVC_METHOD_INVOKE BIT(1) +#define KSMBD_RPC_SRVSVC_METHOD_RETURN (KSMBD_RPC_SRVSVC_METHOD_INVOKE | KSMBD_RPC_METHOD_RETURN) +#define KSMBD_RPC_WKSSVC_METHOD_INVOKE BIT(2) +#define KSMBD_RPC_WKSSVC_METHOD_RETURN (KSMBD_RPC_WKSSVC_METHOD_INVOKE | KSMBD_RPC_METHOD_RETURN) +#define KSMBD_RPC_IOCTL_METHOD (BIT(3) | KSMBD_RPC_METHOD_RETURN) +#define KSMBD_RPC_OPEN_METHOD BIT(4) +#define KSMBD_RPC_WRITE_METHOD BIT(5) +#define KSMBD_RPC_READ_METHOD (BIT(6) | KSMBD_RPC_METHOD_RETURN) +#define KSMBD_RPC_CLOSE_METHOD BIT(7) +#define KSMBD_RPC_RAP_METHOD (BIT(8) | KSMBD_RPC_METHOD_RETURN) +#define KSMBD_RPC_RESTRICTED_CONTEXT BIT(9) +#define KSMBD_RPC_SAMR_METHOD_INVOKE BIT(10) +#define KSMBD_RPC_SAMR_METHOD_RETURN (KSMBD_RPC_SAMR_METHOD_INVOKE | KSMBD_RPC_METHOD_RETURN) +#define KSMBD_RPC_LSARPC_METHOD_INVOKE BIT(11) +#define KSMBD_RPC_LSARPC_METHOD_RETURN (KSMBD_RPC_LSARPC_METHOD_INVOKE | KSMBD_RPC_METHOD_RETURN) + +#define KSMBD_RPC_OK 0 +#define KSMBD_RPC_EBAD_FUNC 0x00000001 +#define KSMBD_RPC_EACCESS_DENIED 0x00000005 +#define KSMBD_RPC_EBAD_FID 0x00000006 +#define KSMBD_RPC_ENOMEM 0x00000008 +#define KSMBD_RPC_EBAD_DATA 0x0000000D +#define KSMBD_RPC_ENOTIMPLEMENTED 0x00000040 +#define KSMBD_RPC_EINVALID_PARAMETER 0x00000057 +#define KSMBD_RPC_EMORE_DATA 0x000000EA +#define KSMBD_RPC_EINVALID_LEVEL 0x0000007C +#define KSMBD_RPC_SOME_NOT_MAPPED 0x00000107 + +#define KSMBD_CONFIG_OPT_DISABLED 0 +#define KSMBD_CONFIG_OPT_ENABLED 1 +#define KSMBD_CONFIG_OPT_AUTO 2 +#define KSMBD_CONFIG_OPT_MANDATORY 3 + +#endif /* _LINUX_KSMBD_SERVER_H */ diff --git a/fs/cifsd/ksmbd_work.c b/fs/cifsd/ksmbd_work.c new file mode 100644 index 000000000000..eb8c8a34acab --- /dev/null +++ b/fs/cifsd/ksmbd_work.c @@ -0,0 +1,93 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * Copyright (C) 2019 Samsung Electronics Co., Ltd. + */ + +#include <linux/list.h> +#include <linux/mm.h> +#include <linux/slab.h> +#include <linux/workqueue.h> + +#include "server.h" +#include "connection.h" +#include "ksmbd_work.h" +#include "buffer_pool.h" +#include "mgmt/ksmbd_ida.h" + +/* @FIXME */ +#include "ksmbd_server.h" + +static struct kmem_cache *work_cache; +static struct workqueue_struct *ksmbd_wq; + +struct ksmbd_work *ksmbd_alloc_work_struct(void) +{ + struct ksmbd_work *work = kmem_cache_zalloc(work_cache, GFP_KERNEL); + + if (work) { + work->compound_fid = KSMBD_NO_FID; + work->compound_pfid = KSMBD_NO_FID; + INIT_LIST_HEAD(&work->request_entry); + INIT_LIST_HEAD(&work->async_request_entry); + INIT_LIST_HEAD(&work->fp_entry); + INIT_LIST_HEAD(&work->interim_entry); + } + return work; +} + +void ksmbd_free_work_struct(struct ksmbd_work *work) +{ + WARN_ON(work->saved_cred != NULL); + if (server_conf.flags & KSMBD_GLOBAL_FLAG_CACHE_TBUF && + work->set_trans_buf) + ksmbd_release_buffer(work->response_buf); + else + kvfree(work->response_buf); + + if (server_conf.flags & KSMBD_GLOBAL_FLAG_CACHE_RBUF && + work->set_read_buf) + ksmbd_release_buffer(work->aux_payload_buf); + else + kvfree(work->aux_payload_buf); + + kfree(work->tr_buf); + kvfree(work->request_buf); + if (work->async_id) + ksmbd_release_id(&work->conn->async_ida, work->async_id); + kmem_cache_free(work_cache, work); +} + +void ksmbd_work_pool_destroy(void) +{ + kmem_cache_destroy(work_cache); +} + +int ksmbd_work_pool_init(void) +{ + work_cache = kmem_cache_create("ksmbd_work_cache", + sizeof(struct ksmbd_work), 0, + SLAB_HWCACHE_ALIGN, NULL); + if (!work_cache) + return -ENOMEM; + return 0; +} + +int ksmbd_workqueue_init(void) +{ + ksmbd_wq = alloc_workqueue("ksmbd-io", 0, 0); + if (!ksmbd_wq) + return -ENOMEM; + return 0; +} + +void ksmbd_workqueue_destroy(void) +{ + flush_workqueue(ksmbd_wq); + destroy_workqueue(ksmbd_wq); + ksmbd_wq = NULL; +} + +bool ksmbd_queue_work(struct ksmbd_work *work) +{ + return queue_work(ksmbd_wq, &work->work); +} diff --git a/fs/cifsd/ksmbd_work.h b/fs/cifsd/ksmbd_work.h new file mode 100644 index 000000000000..28a1692ed37f --- /dev/null +++ b/fs/cifsd/ksmbd_work.h @@ -0,0 +1,110 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2019 Samsung Electronics Co., Ltd. + */ + +#ifndef __KSMBD_WORK_H__ +#define __KSMBD_WORK_H__ + +#include <linux/ctype.h> +#include <linux/workqueue.h> + +struct ksmbd_conn; +struct ksmbd_session; +struct ksmbd_tree_connect; + +enum { + KSMBD_WORK_ACTIVE = 0, + KSMBD_WORK_CANCELLED, + KSMBD_WORK_CLOSED, +}; + +/* one of these for every pending CIFS request at the connection */ +struct ksmbd_work { + /* Server corresponding to this mid */ + struct ksmbd_conn *conn; + struct ksmbd_session *sess; + struct ksmbd_tree_connect *tcon; + + /* Pointer to received SMB header */ + void *request_buf; + /* Response buffer */ + void *response_buf; + + /* Read data buffer */ + void *aux_payload_buf; + + /* Next cmd hdr in compound req buf*/ + int next_smb2_rcv_hdr_off; + /* Next cmd hdr in compound rsp buf*/ + int next_smb2_rsp_hdr_off; + + /* + * Current Local FID assigned compound response if SMB2 CREATE + * command is present in compound request + */ + unsigned int compound_fid; + unsigned int compound_pfid; + unsigned int compound_sid; + + const struct cred *saved_cred; + + /* Number of granted credits */ + unsigned int credits_granted; + + /* response smb header size */ + unsigned int resp_hdr_sz; + unsigned int response_sz; + /* Read data count */ + unsigned int aux_payload_sz; + + void *tr_buf; + + unsigned char state; + /* Multiple responses for one request e.g. SMB ECHO */ + bool multiRsp:1; + /* No response for cancelled request */ + bool send_no_response:1; + /* Request is encrypted */ + bool encrypted:1; + /* Is this SYNC or ASYNC ksmbd_work */ + bool syncronous:1; + bool need_invalidate_rkey:1; + bool set_trans_buf:1; + bool set_read_buf:1; + + unsigned int remote_key; + /* cancel works */ + int async_id; + void **cancel_argv; + void (*cancel_fn)(void **argv); + + struct work_struct work; + /* List head at conn->requests */ + struct list_head request_entry; + /* List head at conn->async_requests */ + struct list_head async_request_entry; + struct list_head fp_entry; + struct list_head interim_entry; +}; + +#define WORK_CANCELLED(w) ((w)->state == KSMBD_WORK_CANCELLED) +#define WORK_CLOSED(w) ((w)->state == KSMBD_WORK_CLOSED) +#define WORK_ACTIVE(w) ((w)->state == KSMBD_WORK_ACTIVE) + +#define RESPONSE_BUF_NEXT(w) \ + (((w)->response_buf + (w)->next_smb2_rsp_hdr_off)) +#define REQUEST_BUF_NEXT(w) \ + (((w)->request_buf + (w)->next_smb2_rcv_hdr_off)) + +struct ksmbd_work *ksmbd_alloc_work_struct(void); +void ksmbd_free_work_struct(struct ksmbd_work *work); + +void ksmbd_work_pool_destroy(void); +int ksmbd_work_pool_init(void); + +int ksmbd_workqueue_init(void); +void ksmbd_workqueue_destroy(void); +bool ksmbd_queue_work(struct ksmbd_work *work); + +#endif /* __KSMBD_WORK_H__ */ diff --git a/fs/cifsd/server.c b/fs/cifsd/server.c new file mode 100644 index 000000000000..a4a4e10cf172 --- /dev/null +++ b/fs/cifsd/server.c @@ -0,0 +1,631 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * Copyright (C) 2016 Namjae Jeon <linkinjeon@kernel.org> + * Copyright (C) 2018 Samsung Electronics Co., Ltd. + */ + +#include "glob.h" +#include "oplock.h" +#include "misc.h" +#include <linux/sched/signal.h> +#include <linux/workqueue.h> +#include <linux/sysfs.h> +#include <linux/module.h> +#include <linux/moduleparam.h> + +#include "server.h" +#include "smb_common.h" +#include "smbstatus.h" +#include "buffer_pool.h" +#include "connection.h" +#include "transport_ipc.h" +#include "mgmt/user_session.h" +#include "crypto_ctx.h" +#include "auth.h" + +int ksmbd_debug_types; + +struct ksmbd_server_config server_conf; + +enum SERVER_CTRL_TYPE { + SERVER_CTRL_TYPE_INIT, + SERVER_CTRL_TYPE_RESET, +}; + +struct server_ctrl_struct { + int type; + struct work_struct ctrl_work; +}; + +static DEFINE_MUTEX(ctrl_lock); + +static int ___server_conf_set(int idx, char *val) +{ + if (idx >= ARRAY_SIZE(server_conf.conf)) + return -EINVAL; + + if (!val || val[0] == 0x00) + return -EINVAL; + + kfree(server_conf.conf[idx]); + server_conf.conf[idx] = kstrdup(val, GFP_KERNEL); + if (!server_conf.conf[idx]) + return -ENOMEM; + return 0; +} + +int ksmbd_set_netbios_name(char *v) +{ + return ___server_conf_set(SERVER_CONF_NETBIOS_NAME, v); +} + +int ksmbd_set_server_string(char *v) +{ + return ___server_conf_set(SERVER_CONF_SERVER_STRING, v); +} + +int ksmbd_set_work_group(char *v) +{ + return ___server_conf_set(SERVER_CONF_WORK_GROUP, v); +} + +char *ksmbd_netbios_name(void) +{ + return server_conf.conf[SERVER_CONF_NETBIOS_NAME]; +} + +char *ksmbd_server_string(void) +{ + return server_conf.conf[SERVER_CONF_SERVER_STRING]; +} + +char *ksmbd_work_group(void) +{ + return server_conf.conf[SERVER_CONF_WORK_GROUP]; +} + +/** + * check_conn_state() - check state of server thread connection + * @work: smb work containing server thread information + * + * Return: 0 on valid connection, otherwise 1 to reconnect + */ +static inline int check_conn_state(struct ksmbd_work *work) +{ + struct smb_hdr *rsp_hdr; + + if (ksmbd_conn_exiting(work) || ksmbd_conn_need_reconnect(work)) { + rsp_hdr = work->response_buf; + rsp_hdr->Status.CifsError = STATUS_CONNECTION_DISCONNECTED; + return 1; + } + return 0; +} + +#define TCP_HANDLER_CONTINUE 0 +#define TCP_HANDLER_ABORT 1 + +static int __process_request(struct ksmbd_work *work, struct ksmbd_conn *conn, + uint16_t *cmd) +{ + struct smb_version_cmds *cmds; + uint16_t command; + int ret; + + if (check_conn_state(work)) + return TCP_HANDLER_CONTINUE; + + if (ksmbd_verify_smb_message(work)) + return TCP_HANDLER_ABORT; + + command = conn->ops->get_cmd_val(work); + *cmd = command; + +andx_again: + if (command >= conn->max_cmds) { + conn->ops->set_rsp_status(work, STATUS_INVALID_PARAMETER); + return TCP_HANDLER_CONTINUE; + } + + cmds = &conn->cmds[command]; + if (!cmds->proc) { + ksmbd_debug(SMB, "*** not implemented yet cmd = %x\n", command); + conn->ops->set_rsp_status(work, STATUS_NOT_IMPLEMENTED); + return TCP_HANDLER_CONTINUE; + } + + if (work->sess && conn->ops->is_sign_req(work, command)) { + ret = conn->ops->check_sign_req(work); + if (!ret) { + conn->ops->set_rsp_status(work, STATUS_ACCESS_DENIED); + return TCP_HANDLER_CONTINUE; + } + } + + ret = cmds->proc(work); + + if (ret < 0) + ksmbd_debug(CONN, "Failed to process %u [%d]\n", command, ret); + /* AndX commands - chained request can return positive values */ + else if (ret > 0) { + command = ret; + *cmd = command; + goto andx_again; + } + + if (work->send_no_response) + return TCP_HANDLER_ABORT; + return TCP_HANDLER_CONTINUE; +} + +static void __handle_ksmbd_work(struct ksmbd_work *work, + struct ksmbd_conn *conn) +{ + u16 command = 0; + int rc; + + if (conn->ops->allocate_rsp_buf(work)) + return; + + if (conn->ops->is_transform_hdr && + conn->ops->is_transform_hdr(work->request_buf)) { + rc = conn->ops->decrypt_req(work); + if (rc < 0) { + conn->ops->set_rsp_status(work, STATUS_DATA_ERROR); + goto send; + } + + work->encrypted = true; + } + + rc = conn->ops->init_rsp_hdr(work); + if (rc) { + /* either uid or tid is not correct */ + conn->ops->set_rsp_status(work, STATUS_INVALID_HANDLE); + goto send; + } + + if (conn->ops->check_user_session) { + rc = conn->ops->check_user_session(work); + if (rc < 0) { + command = conn->ops->get_cmd_val(work); + conn->ops->set_rsp_status(work, + STATUS_USER_SESSION_DELETED); + goto send; + } else if (rc > 0) { + rc = conn->ops->get_ksmbd_tcon(work); + if (rc < 0) { + conn->ops->set_rsp_status(work, + STATUS_NETWORK_NAME_DELETED); + goto send; + } + } + } + + do { + rc = __process_request(work, conn, &command); + if (rc == TCP_HANDLER_ABORT) + break; + + /* + * Call smb2_set_rsp_credits() function to set number of credits + * granted in hdr of smb2 response. + */ + if (conn->ops->set_rsp_credits) { + spin_lock(&conn->credits_lock); + rc = conn->ops->set_rsp_credits(work); + spin_unlock(&conn->credits_lock); + if (rc < 0) { + conn->ops->set_rsp_status(work, + STATUS_INVALID_PARAMETER); + goto send; + } + } + + if (work->sess && (work->sess->sign || + smb3_11_final_sess_setup_resp(work) || + conn->ops->is_sign_req(work, command))) + conn->ops->set_sign_rsp(work); + } while (is_chained_smb2_message(work)); + + if (work->send_no_response) + return; + +send: + smb3_preauth_hash_rsp(work); + if (work->sess && work->sess->enc && work->encrypted && + conn->ops->encrypt_resp) { + rc = conn->ops->encrypt_resp(work); + if (rc < 0) { + conn->ops->set_rsp_status(work, STATUS_DATA_ERROR); + goto send; + } + } + + ksmbd_conn_write(work); +} + +/** + * handle_ksmbd_work() - process pending smb work requests + * @wk: smb work containing request command buffer + * + * called by kworker threads to processing remaining smb work requests + */ +static void handle_ksmbd_work(struct work_struct *wk) +{ + struct ksmbd_work *work = container_of(wk, struct ksmbd_work, work); + struct ksmbd_conn *conn = work->conn; + + atomic64_inc(&conn->stats.request_served); + + __handle_ksmbd_work(work, conn); + + ksmbd_conn_try_dequeue_request(work); + ksmbd_free_work_struct(work); + atomic_dec(&conn->r_count); +} + +/** + * queue_ksmbd_work() - queue a smb request to worker thread queue + * for proccessing smb command and sending response + * @conn: connection instance + * + * read remaining data from socket create and submit work. + */ +static int queue_ksmbd_work(struct ksmbd_conn *conn) +{ + struct ksmbd_work *work; + + work = ksmbd_alloc_work_struct(); + if (!work) { + ksmbd_err("allocation for work failed\n"); + return -ENOMEM; + } + + work->conn = conn; + work->request_buf = conn->request_buf; + conn->request_buf = NULL; + + if (ksmbd_init_smb_server(work)) { + ksmbd_free_work_struct(work); + return -EINVAL; + } + + ksmbd_conn_enqueue_request(work); + atomic_inc(&conn->r_count); + /* update activity on connection */ + conn->last_active = jiffies; + INIT_WORK(&work->work, handle_ksmbd_work); + ksmbd_queue_work(work); + return 0; +} + +static int ksmbd_server_process_request(struct ksmbd_conn *conn) +{ + return queue_ksmbd_work(conn); +} + +static int ksmbd_server_terminate_conn(struct ksmbd_conn *conn) +{ + ksmbd_sessions_deregister(conn); + destroy_lease_table(conn); + return 0; +} + +static void ksmbd_server_tcp_callbacks_init(void) +{ + struct ksmbd_conn_ops ops; + + ops.process_fn = ksmbd_server_process_request; + ops.terminate_fn = ksmbd_server_terminate_conn; + + ksmbd_conn_init_server_callbacks(&ops); +} + +static void server_conf_free(void) +{ + int i; + + for (i = 0; i < ARRAY_SIZE(server_conf.conf); i++) { + kfree(server_conf.conf[i]); + server_conf.conf[i] = NULL; + } +} + +static int server_conf_init(void) +{ + WRITE_ONCE(server_conf.state, SERVER_STATE_STARTING_UP); + server_conf.enforced_signing = 0; + server_conf.min_protocol = ksmbd_min_protocol(); + server_conf.max_protocol = ksmbd_max_protocol(); + server_conf.auth_mechs = KSMBD_AUTH_NTLMSSP; +#ifdef CONFIG_SMB_SERVER_KERBEROS5 + server_conf.auth_mechs |= KSMBD_AUTH_KRB5 | + KSMBD_AUTH_MSKRB5; +#endif + return 0; +} + +static void server_ctrl_handle_init(struct server_ctrl_struct *ctrl) +{ + int ret; + + ret = ksmbd_conn_transport_init(); + if (ret) { + server_queue_ctrl_reset_work(); + return; + } + + WRITE_ONCE(server_conf.state, SERVER_STATE_RUNNING); +} + +static void server_ctrl_handle_reset(struct server_ctrl_struct *ctrl) +{ + ksmbd_ipc_soft_reset(); + ksmbd_conn_transport_destroy(); + server_conf_free(); + server_conf_init(); + WRITE_ONCE(server_conf.state, SERVER_STATE_STARTING_UP); +} + +static void server_ctrl_handle_work(struct work_struct *work) +{ + struct server_ctrl_struct *ctrl; + + ctrl = container_of(work, struct server_ctrl_struct, ctrl_work); + + mutex_lock(&ctrl_lock); + switch (ctrl->type) { + case SERVER_CTRL_TYPE_INIT: + server_ctrl_handle_init(ctrl); + break; + case SERVER_CTRL_TYPE_RESET: + server_ctrl_handle_reset(ctrl); + break; + default: + pr_err("Unknown server work type: %d\n", ctrl->type); + } + mutex_unlock(&ctrl_lock); + kfree(ctrl); + module_put(THIS_MODULE); +} + +static int __queue_ctrl_work(int type) +{ + struct server_ctrl_struct *ctrl; + + ctrl = kmalloc(sizeof(struct server_ctrl_struct), GFP_KERNEL); + if (!ctrl) + return -ENOMEM; + + __module_get(THIS_MODULE); + ctrl->type = type; + INIT_WORK(&ctrl->ctrl_work, server_ctrl_handle_work); + queue_work(system_long_wq, &ctrl->ctrl_work); + return 0; +} + +int server_queue_ctrl_init_work(void) +{ + return __queue_ctrl_work(SERVER_CTRL_TYPE_INIT); +} + +int server_queue_ctrl_reset_work(void) +{ + return __queue_ctrl_work(SERVER_CTRL_TYPE_RESET); +} + +static ssize_t stats_show(struct class *class, struct class_attribute *attr, + char *buf) +{ + /* + * Inc this each time you change stats output format, + * so user space will know what to do. + */ + static int stats_version = 2; + static const char * const state[] = { + "startup", + "running", + "reset", + "shutdown" + }; + + ssize_t sz = scnprintf(buf, + PAGE_SIZE, + "%d %s %d %lu\n", + stats_version, + state[server_conf.state], + server_conf.tcp_port, + server_conf.ipc_last_active / HZ); + return sz; +} + +static ssize_t kill_server_store(struct class *class, + struct class_attribute *attr, const char *buf, + size_t len) +{ + if (!sysfs_streq(buf, "hard")) + return len; + + ksmbd_info("kill command received\n"); + mutex_lock(&ctrl_lock); + WRITE_ONCE(server_conf.state, SERVER_STATE_RESETTING); + __module_get(THIS_MODULE); + server_ctrl_handle_reset(NULL); + module_put(THIS_MODULE); + mutex_unlock(&ctrl_lock); + return len; +} + +static const char * const debug_type_strings[] = {"smb", "auth", "vfs", + "oplock", "ipc", "conn", + "rdma"}; + +static ssize_t debug_show(struct class *class, struct class_attribute *attr, + char *buf) +{ + ssize_t sz = 0; + int i, pos = 0; + + for (i = 0; i < ARRAY_SIZE(debug_type_strings); i++) { + if ((ksmbd_debug_types >> i) & 1) { + pos = scnprintf(buf + sz, + PAGE_SIZE - sz, + "[%s] ", + debug_type_strings[i]); + } else { + pos = scnprintf(buf + sz, + PAGE_SIZE - sz, + "%s ", + debug_type_strings[i]); + } + sz += pos; + } + sz += scnprintf(buf + sz, PAGE_SIZE - sz, "\n"); + return sz; +} + +static ssize_t debug_store(struct class *class, struct class_attribute *attr, + const char *buf, size_t len) +{ + int i; + + for (i = 0; i < ARRAY_SIZE(debug_type_strings); i++) { + if (sysfs_streq(buf, "all")) { + if (ksmbd_debug_types == KSMBD_DEBUG_ALL) + ksmbd_debug_types = 0; + else + ksmbd_debug_types = KSMBD_DEBUG_ALL; + break; + } + + if (sysfs_streq(buf, debug_type_strings[i])) { + if (ksmbd_debug_types & (1 << i)) + ksmbd_debug_types &= ~(1 << i); + else + ksmbd_debug_types |= (1 << i); + break; + } + } + + return len; +} + +static CLASS_ATTR_RO(stats); +static CLASS_ATTR_WO(kill_server); +static CLASS_ATTR_RW(debug); + +static struct attribute *ksmbd_control_class_attrs[] = { + &class_attr_stats.attr, + &class_attr_kill_server.attr, + &class_attr_debug.attr, + NULL, +}; +ATTRIBUTE_GROUPS(ksmbd_control_class); + +static struct class ksmbd_control_class = { + .name = "ksmbd-control", + .owner = THIS_MODULE, + .class_groups = ksmbd_control_class_groups, +}; + +static int ksmbd_server_shutdown(void) +{ + WRITE_ONCE(server_conf.state, SERVER_STATE_SHUTTING_DOWN); + + class_unregister(&ksmbd_control_class); + ksmbd_workqueue_destroy(); + ksmbd_ipc_release(); + ksmbd_conn_transport_destroy(); + ksmbd_crypto_destroy(); + ksmbd_free_global_file_table(); + destroy_lease_table(NULL); + ksmbd_destroy_buffer_pools(); + server_conf_free(); + return 0; +} + +static int __init ksmbd_server_init(void) +{ + int ret; + + ret = class_register(&ksmbd_control_class); + if (ret) { + ksmbd_err("Unable to register ksmbd-control class\n"); + return ret; + } + + ksmbd_server_tcp_callbacks_init(); + + ret = server_conf_init(); + if (ret) + goto err_unregister; + + ret = ksmbd_init_buffer_pools(); + if (ret) + goto err_unregister; + + ret = ksmbd_ipc_init(); + if (ret) + goto err_free_session_table; + + ret = ksmbd_init_global_file_table(); + if (ret) + goto err_ipc_release; + + ret = ksmbd_inode_hash_init(); + if (ret) + goto err_destroy_file_table; + + ret = ksmbd_crypto_create(); + if (ret) + goto err_release_inode_hash; + + ret = ksmbd_workqueue_init(); + if (ret) + goto err_crypto_destroy; + return 0; + +err_crypto_destroy: + ksmbd_crypto_destroy(); +err_release_inode_hash: + ksmbd_release_inode_hash(); +err_destroy_file_table: + ksmbd_free_global_file_table(); +err_ipc_release: + ksmbd_ipc_release(); +err_free_session_table: + ksmbd_destroy_buffer_pools(); +err_unregister: + class_unregister(&ksmbd_control_class); + + return ret; +} + +/** + * ksmbd_server_exit() - shutdown forker thread and free memory at module exit + */ +static void __exit ksmbd_server_exit(void) +{ + ksmbd_server_shutdown(); + ksmbd_release_inode_hash(); +} + +MODULE_AUTHOR("Namjae Jeon <linkinjeon@kernel.org>"); +MODULE_VERSION(KSMBD_VERSION); +MODULE_DESCRIPTION("Linux kernel CIFS/SMB SERVER"); +MODULE_LICENSE("GPL"); +MODULE_SOFTDEP("pre: ecb"); +MODULE_SOFTDEP("pre: hmac"); +MODULE_SOFTDEP("pre: md4"); +MODULE_SOFTDEP("pre: md5"); +MODULE_SOFTDEP("pre: nls"); +MODULE_SOFTDEP("pre: aes"); +MODULE_SOFTDEP("pre: cmac"); +MODULE_SOFTDEP("pre: sha256"); +MODULE_SOFTDEP("pre: sha512"); +MODULE_SOFTDEP("pre: aead2"); +MODULE_SOFTDEP("pre: ccm"); +MODULE_SOFTDEP("pre: gcm"); +module_init(ksmbd_server_init) +module_exit(ksmbd_server_exit) diff --git a/fs/cifsd/server.h b/fs/cifsd/server.h new file mode 100644 index 000000000000..b682d28963e8 --- /dev/null +++ b/fs/cifsd/server.h @@ -0,0 +1,60 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2018 Samsung Electronics Co., Ltd. + */ + +#ifndef __SERVER_H__ +#define __SERVER_H__ + +#include "smbacl.h" + +#define SERVER_STATE_STARTING_UP 0 +#define SERVER_STATE_RUNNING 1 +#define SERVER_STATE_RESETTING 2 +#define SERVER_STATE_SHUTTING_DOWN 3 + +#define SERVER_CONF_NETBIOS_NAME 0 +#define SERVER_CONF_SERVER_STRING 1 +#define SERVER_CONF_WORK_GROUP 2 + +struct ksmbd_server_config { + unsigned int flags; + unsigned int state; + short signing; + short enforced_signing; + short min_protocol; + short max_protocol; + unsigned short tcp_port; + unsigned short ipc_timeout; + unsigned long ipc_last_active; + unsigned long deadtime; + unsigned int share_fake_fscaps; + struct smb_sid domain_sid; + unsigned int auth_mechs; + + char *conf[SERVER_CONF_WORK_GROUP + 1]; +}; + +extern struct ksmbd_server_config server_conf; + +int ksmbd_set_netbios_name(char *v); +int ksmbd_set_server_string(char *v); +int ksmbd_set_work_group(char *v); + +char *ksmbd_netbios_name(void); +char *ksmbd_server_string(void); +char *ksmbd_work_group(void); + +static inline int ksmbd_server_running(void) +{ + return READ_ONCE(server_conf.state) == SERVER_STATE_RUNNING; +} + +static inline int ksmbd_server_configurable(void) +{ + return READ_ONCE(server_conf.state) < SERVER_STATE_RESETTING; +} + +int server_queue_ctrl_init_work(void); +int server_queue_ctrl_reset_work(void); +#endif /* __SERVER_H__ */ -- 2.17.1 ^ permalink raw reply related [flat|nested] 11+ messages in thread
[parent not found: <CGME20210521063554epcas1p2b7c2f4766547f7f3deec29f1fc5b7c3f@epcas1p2.samsung.com>]
* [PATCH v3 04/10] cifsd: add authentication [not found] ` <CGME20210521063554epcas1p2b7c2f4766547f7f3deec29f1fc5b7c3f@epcas1p2.samsung.com> @ 2021-05-21 6:26 ` Namjae Jeon 2021-05-21 10:31 ` Dan Carpenter 0 siblings, 1 reply; 11+ messages in thread From: Namjae Jeon @ 2021-05-21 6:26 UTC (permalink / raw) To: linux-fsdevel, linux-kernel, linux-cifs Cc: linux-cifsd-devel, smfrench, senozhatsky, hyc.lee, viro, hch, hch, ronniesahlberg, aurelien.aptel, aaptel, sandeen, dan.carpenter, willy, Namjae Jeon, Sergey Senozhatsky, Steve French This adds NTLM/NTLMv2/Kerberos authentications and signing/encryption. Signed-off-by: Namjae Jeon <namjae.jeon@samsung.com> Signed-off-by: Sergey Senozhatsky <sergey.senozhatsky@gmail.com> Signed-off-by: Hyunchul Lee <hyc.lee@gmail.com> Acked-by: Ronnie Sahlberg <lsahlber@redhat.com> Signed-off-by: Steve French <stfrench@microsoft.com> --- fs/cifsd/asn1.c | 352 ++++++++ fs/cifsd/asn1.h | 29 + fs/cifsd/auth.c | 1344 +++++++++++++++++++++++++++++ fs/cifsd/auth.h | 90 ++ fs/cifsd/crypto_ctx.c | 286 ++++++ fs/cifsd/crypto_ctx.h | 77 ++ fs/cifsd/ntlmssp.h | 169 ++++ fs/cifsd/spnego_negtokeninit.asn1 | 43 + fs/cifsd/spnego_negtokentarg.asn1 | 19 + 9 files changed, 2409 insertions(+) create mode 100644 fs/cifsd/asn1.c create mode 100644 fs/cifsd/asn1.h create mode 100644 fs/cifsd/auth.c create mode 100644 fs/cifsd/auth.h create mode 100644 fs/cifsd/crypto_ctx.c create mode 100644 fs/cifsd/crypto_ctx.h create mode 100644 fs/cifsd/ntlmssp.h create mode 100644 fs/cifsd/spnego_negtokeninit.asn1 create mode 100644 fs/cifsd/spnego_negtokentarg.asn1 diff --git a/fs/cifsd/asn1.c b/fs/cifsd/asn1.c new file mode 100644 index 000000000000..aa6ea855c422 --- /dev/null +++ b/fs/cifsd/asn1.c @@ -0,0 +1,352 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * The ASB.1/BER parsing code is derived from ip_nat_snmp_basic.c which was in + * turn derived from the gxsnmp package by Gregory McLean & Jochen Friedrich + * + * Copyright (c) 2000 RP Internet (www.rpi.net.au). + */ + +#include <linux/module.h> +#include <linux/types.h> +#include <linux/kernel.h> +#include <linux/mm.h> +#include <linux/slab.h> +#include <linux/oid_registry.h> + +#include "glob.h" + +#include "asn1.h" +#include "connection.h" +#include "auth.h" +#include "spnego_negtokeninit.asn1.h" +#include "spnego_negtokentarg.asn1.h" + +#define SPNEGO_OID_LEN 7 +#define NTLMSSP_OID_LEN 10 +#define KRB5_OID_LEN 7 +#define KRB5U2U_OID_LEN 8 +#define MSKRB5_OID_LEN 7 +static unsigned long SPNEGO_OID[7] = { 1, 3, 6, 1, 5, 5, 2 }; +static unsigned long NTLMSSP_OID[10] = { 1, 3, 6, 1, 4, 1, 311, 2, 2, 10 }; +static unsigned long KRB5_OID[7] = { 1, 2, 840, 113554, 1, 2, 2 }; +static unsigned long KRB5U2U_OID[8] = { 1, 2, 840, 113554, 1, 2, 2, 3 }; +static unsigned long MSKRB5_OID[7] = { 1, 2, 840, 48018, 1, 2, 2 }; + +static char NTLMSSP_OID_STR[NTLMSSP_OID_LEN] = { 0x2b, 0x06, 0x01, 0x04, 0x01, + 0x82, 0x37, 0x02, 0x02, 0x0a }; + +static bool +asn1_subid_decode(const unsigned char **begin, const unsigned char *end, + unsigned long *subid) +{ + const unsigned char *ptr = *begin; + unsigned char ch; + + *subid = 0; + + do { + if (ptr >= end) + return false; + + ch = *ptr++; + *subid <<= 7; + *subid |= ch & 0x7F; + } while ((ch & 0x80) == 0x80); + + *begin = ptr; + return true; +} + +static bool asn1_oid_decode(const unsigned char *value, size_t vlen, + unsigned long **oid, size_t *oidlen) +{ + const unsigned char *iptr = value, *end = value + vlen; + unsigned long *optr; + unsigned long subid; + + vlen += 1; + if (vlen < 2 || vlen > UINT_MAX/sizeof(unsigned long)) + return false; + + *oid = kmalloc(vlen * sizeof(unsigned long), GFP_KERNEL); + if (!*oid) + return false; + + optr = *oid; + + if (!asn1_subid_decode(&iptr, end, &subid)) { + kfree(*oid); + *oid = NULL; + return false; + } + + if (subid < 40) { + optr[0] = 0; + optr[1] = subid; + } else if (subid < 80) { + optr[0] = 1; + optr[1] = subid - 40; + } else { + optr[0] = 2; + optr[1] = subid - 80; + } + + *oidlen = 2; + optr += 2; + + while (iptr < end) { + if (++(*oidlen) > vlen) { + kfree(*oid); + *oid = NULL; + return false; + } + + if (!asn1_subid_decode(&iptr, end, optr++)) { + kfree(*oid); + *oid = NULL; + return false; + } + } + return true; +} + +static bool +oid_eq(unsigned long *oid1, unsigned int oid1len, + unsigned long *oid2, unsigned int oid2len) +{ + unsigned int i; + + if (oid1len != oid2len) + return false; + + for (i = 0; i < oid1len; i++) { + if (oid1[i] != oid2[i]) + return false; + } + return true; +} + +int +ksmbd_decode_negTokenInit(unsigned char *security_blob, int length, + struct ksmbd_conn *conn) +{ + return asn1_ber_decoder(&spnego_negtokeninit_decoder, conn, + security_blob, length); +} + +int +ksmbd_decode_negTokenTarg(unsigned char *security_blob, int length, + struct ksmbd_conn *conn) +{ + return asn1_ber_decoder(&spnego_negtokentarg_decoder, conn, + security_blob, length); +} + +static int compute_asn_hdr_len_bytes(int len) +{ + if (len > 0xFFFFFF) + return 4; + else if (len > 0xFFFF) + return 3; + else if (len > 0xFF) + return 2; + else if (len > 0x7F) + return 1; + else + return 0; +} + +static void encode_asn_tag(char *buf, + unsigned int *ofs, + char tag, + char seq, + int length) +{ + int i; + int index = *ofs; + char hdr_len = compute_asn_hdr_len_bytes(length); + int len = length + 2 + hdr_len; + + /* insert tag */ + buf[index++] = tag; + + if (!hdr_len) + buf[index++] = len; + else { + buf[index++] = 0x80 | hdr_len; + for (i = hdr_len - 1; i >= 0; i--) + buf[index++] = (len >> (i * 8)) & 0xFF; + } + + /* insert seq */ + len = len - (index - *ofs); + buf[index++] = seq; + + if (!hdr_len) + buf[index++] = len; + else { + buf[index++] = 0x80 | hdr_len; + for (i = hdr_len - 1; i >= 0; i--) + buf[index++] = (len >> (i * 8)) & 0xFF; + } + + *ofs += (index - *ofs); +} + +int build_spnego_ntlmssp_neg_blob(unsigned char **pbuffer, u16 *buflen, + char *ntlm_blob, int ntlm_blob_len) +{ + char *buf; + unsigned int ofs = 0; + int neg_result_len = 4 + compute_asn_hdr_len_bytes(1) * 2 + 1; + int oid_len = 4 + compute_asn_hdr_len_bytes(NTLMSSP_OID_LEN) * 2 + + NTLMSSP_OID_LEN; + int ntlmssp_len = 4 + compute_asn_hdr_len_bytes(ntlm_blob_len) * 2 + + ntlm_blob_len; + int total_len = 4 + compute_asn_hdr_len_bytes(neg_result_len + + oid_len + ntlmssp_len) * 2 + + neg_result_len + oid_len + ntlmssp_len; + + buf = kmalloc(total_len, GFP_KERNEL); + if (!buf) + return -ENOMEM; + + /* insert main gss header */ + encode_asn_tag(buf, &ofs, 0xa1, 0x30, neg_result_len + oid_len + + ntlmssp_len); + + /* insert neg result */ + encode_asn_tag(buf, &ofs, 0xa0, 0x0a, 1); + buf[ofs++] = 1; + + /* insert oid */ + encode_asn_tag(buf, &ofs, 0xa1, 0x06, NTLMSSP_OID_LEN); + memcpy(buf + ofs, NTLMSSP_OID_STR, NTLMSSP_OID_LEN); + ofs += NTLMSSP_OID_LEN; + + /* insert response token - ntlmssp blob */ + encode_asn_tag(buf, &ofs, 0xa2, 0x04, ntlm_blob_len); + memcpy(buf + ofs, ntlm_blob, ntlm_blob_len); + ofs += ntlm_blob_len; + + *pbuffer = buf; + *buflen = total_len; + return 0; +} + +int build_spnego_ntlmssp_auth_blob(unsigned char **pbuffer, u16 *buflen, + int neg_result) +{ + char *buf; + unsigned int ofs = 0; + int neg_result_len = 4 + compute_asn_hdr_len_bytes(1) * 2 + 1; + int total_len = 4 + compute_asn_hdr_len_bytes(neg_result_len) * 2 + + neg_result_len; + + buf = kmalloc(total_len, GFP_KERNEL); + if (!buf) + return -ENOMEM; + + /* insert main gss header */ + encode_asn_tag(buf, &ofs, 0xa1, 0x30, neg_result_len); + + /* insert neg result */ + encode_asn_tag(buf, &ofs, 0xa0, 0x0a, 1); + if (neg_result) + buf[ofs++] = 2; + else + buf[ofs++] = 0; + + *pbuffer = buf; + *buflen = total_len; + return 0; +} + +int gssapi_this_mech(void *context, size_t hdrlen, + unsigned char tag, const void *value, size_t vlen) +{ + unsigned long *oid; + size_t oidlen; + int err = 0; + + if (!asn1_oid_decode(value, vlen, &oid, &oidlen)) { + err = -EBADMSG; + goto out; + } + + if (!oid_eq(oid, oidlen, SPNEGO_OID, SPNEGO_OID_LEN)) + err = -EBADMSG; + kfree(oid); +out: + if (err) { + char buf[50]; + + sprint_oid(value, vlen, buf, sizeof(buf)); + ksmbd_debug(AUTH, "Unexpected OID: %s\n", buf); + } + return err; +} + +int neg_token_init_mech_type(void *context, size_t hdrlen, + unsigned char tag, const void *value, size_t vlen) +{ + struct ksmbd_conn *conn = context; + unsigned long *oid; + size_t oidlen; + int mech_type; + + if (!asn1_oid_decode(value, vlen, &oid, &oidlen)) { + char buf[50]; + + sprint_oid(value, vlen, buf, sizeof(buf)); + ksmbd_debug(AUTH, "Unexpected OID: %s\n", buf); + return -EBADMSG; + } + + if (oid_eq(oid, oidlen, NTLMSSP_OID, NTLMSSP_OID_LEN)) + mech_type = KSMBD_AUTH_NTLMSSP; + else if (oid_eq(oid, oidlen, MSKRB5_OID, MSKRB5_OID_LEN)) + mech_type = KSMBD_AUTH_MSKRB5; + else if (oid_eq(oid, oidlen, KRB5_OID, KRB5_OID_LEN)) + mech_type = KSMBD_AUTH_KRB5; + else if (oid_eq(oid, oidlen, KRB5U2U_OID, KRB5U2U_OID_LEN)) + mech_type = KSMBD_AUTH_KRB5U2U; + else + goto out; + + conn->auth_mechs |= mech_type; + if (conn->preferred_auth_mech == 0) + conn->preferred_auth_mech = mech_type; + +out: + kfree(oid); + return 0; +} + +int neg_token_init_mech_token(void *context, size_t hdrlen, + unsigned char tag, const void *value, size_t vlen) +{ + struct ksmbd_conn *conn = context; + + conn->mechToken = kmalloc(vlen + 1, GFP_KERNEL); + if (!conn->mechToken) + return -ENOMEM; + + memcpy(conn->mechToken, value, vlen); + conn->mechToken[vlen] = '\0'; + return 0; +} + +int neg_token_targ_resp_token(void *context, size_t hdrlen, + unsigned char tag, const void *value, size_t vlen) +{ + struct ksmbd_conn *conn = context; + + conn->mechToken = kmalloc(vlen + 1, GFP_KERNEL); + if (!conn->mechToken) + return -ENOMEM; + + memcpy(conn->mechToken, value, vlen); + conn->mechToken[vlen] = '\0'; + return 0; +} diff --git a/fs/cifsd/asn1.h b/fs/cifsd/asn1.h new file mode 100644 index 000000000000..ff2692b502d6 --- /dev/null +++ b/fs/cifsd/asn1.h @@ -0,0 +1,29 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * The ASB.1/BER parsing code is derived from ip_nat_snmp_basic.c which was in + * turn derived from the gxsnmp package by Gregory McLean & Jochen Friedrich + * + * Copyright (c) 2000 RP Internet (www.rpi.net.au). + * Copyright (C) 2018 Samsung Electronics Co., Ltd. + */ + +#ifndef __ASN1_H__ +#define __ASN1_H__ + +int ksmbd_decode_negTokenInit(unsigned char *security_blob, + int length, + struct ksmbd_conn *conn); + +int ksmbd_decode_negTokenTarg(unsigned char *security_blob, + int length, + struct ksmbd_conn *conn); + +int build_spnego_ntlmssp_neg_blob(unsigned char **pbuffer, + u16 *buflen, + char *ntlm_blob, + int ntlm_blob_len); + +int build_spnego_ntlmssp_auth_blob(unsigned char **pbuffer, + u16 *buflen, + int neg_result); +#endif /* __ASN1_H__ */ diff --git a/fs/cifsd/auth.c b/fs/cifsd/auth.c new file mode 100644 index 000000000000..6b90aac86fcc --- /dev/null +++ b/fs/cifsd/auth.c @@ -0,0 +1,1344 @@ +// 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/kernel.h> +#include <linux/fs.h> +#include <linux/uaccess.h> +#include <linux/backing-dev.h> +#include <linux/writeback.h> +#include <linux/uio.h> +#include <linux/xattr.h> +#include <crypto/hash.h> +#include <crypto/aead.h> +#include <linux/random.h> +#include <linux/scatterlist.h> + +#include "auth.h" +#include "glob.h" + +#include <linux/fips.h> +#include <crypto/des.h> + +#include "server.h" +#include "smb_common.h" +#include "connection.h" +#include "mgmt/user_session.h" +#include "mgmt/user_config.h" +#include "crypto_ctx.h" +#include "transport_ipc.h" +#include "buffer_pool.h" + +/* + * Fixed format data defining GSS header and fixed string + * "not_defined_in_RFC4178@please_ignore". + * So sec blob data in neg phase could be generated statically. + */ +static char NEGOTIATE_GSS_HEADER[AUTH_GSS_LENGTH] = { +#ifdef CONFIG_SMB_SERVER_KERBEROS5 + 0x60, 0x5e, 0x06, 0x06, 0x2b, 0x06, 0x01, 0x05, + 0x05, 0x02, 0xa0, 0x54, 0x30, 0x52, 0xa0, 0x24, + 0x30, 0x22, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, + 0xf7, 0x12, 0x01, 0x02, 0x02, 0x06, 0x09, 0x2a, + 0x86, 0x48, 0x82, 0xf7, 0x12, 0x01, 0x02, 0x02, + 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, + 0x37, 0x02, 0x02, 0x0a, 0xa3, 0x2a, 0x30, 0x28, + 0xa0, 0x26, 0x1b, 0x24, 0x6e, 0x6f, 0x74, 0x5f, + 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x5f, + 0x69, 0x6e, 0x5f, 0x52, 0x46, 0x43, 0x34, 0x31, + 0x37, 0x38, 0x40, 0x70, 0x6c, 0x65, 0x61, 0x73, + 0x65, 0x5f, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65 +#else + 0x60, 0x48, 0x06, 0x06, 0x2b, 0x06, 0x01, 0x05, + 0x05, 0x02, 0xa0, 0x3e, 0x30, 0x3c, 0xa0, 0x0e, + 0x30, 0x0c, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, + 0x01, 0x82, 0x37, 0x02, 0x02, 0x0a, 0xa3, 0x2a, + 0x30, 0x28, 0xa0, 0x26, 0x1b, 0x24, 0x6e, 0x6f, + 0x74, 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, + 0x64, 0x5f, 0x69, 0x6e, 0x5f, 0x52, 0x46, 0x43, + 0x34, 0x31, 0x37, 0x38, 0x40, 0x70, 0x6c, 0x65, + 0x61, 0x73, 0x65, 0x5f, 0x69, 0x67, 0x6e, 0x6f, + 0x72, 0x65 +#endif +}; + +void ksmbd_copy_gss_neg_header(void *buf) +{ + memcpy(buf, NEGOTIATE_GSS_HEADER, AUTH_GSS_LENGTH); +} + +static void +str_to_key(unsigned char *str, unsigned char *key) +{ + int i; + + key[0] = str[0] >> 1; + key[1] = ((str[0] & 0x01) << 6) | (str[1] >> 2); + key[2] = ((str[1] & 0x03) << 5) | (str[2] >> 3); + key[3] = ((str[2] & 0x07) << 4) | (str[3] >> 4); + key[4] = ((str[3] & 0x0F) << 3) | (str[4] >> 5); + key[5] = ((str[4] & 0x1F) << 2) | (str[5] >> 6); + key[6] = ((str[5] & 0x3F) << 1) | (str[6] >> 7); + key[7] = str[6] & 0x7F; + for (i = 0; i < 8; i++) + key[i] = (key[i] << 1); +} + +static int +smbhash(unsigned char *out, const unsigned char *in, unsigned char *key) +{ + unsigned char key2[8]; + struct des_ctx ctx; + + str_to_key(key, key2); + + if (fips_enabled) { + ksmbd_debug(AUTH, + "FIPS compliance enabled: DES not permitted\n"); + return -ENOENT; + } + + des_expand_key(&ctx, key2, DES_KEY_SIZE); + des_encrypt(&ctx, out, in); + memzero_explicit(&ctx, sizeof(ctx)); + return 0; +} + +static int ksmbd_enc_p24(unsigned char *p21, const unsigned char *c8, unsigned char *p24) +{ + int rc; + + rc = smbhash(p24, c8, p21); + if (rc) + return rc; + rc = smbhash(p24 + 8, c8, p21 + 7); + if (rc) + return rc; + rc = smbhash(p24 + 16, c8, p21 + 14); + return rc; +} + +/* produce a md4 message digest from data of length n bytes */ +static int ksmbd_enc_md4(unsigned char *md4_hash, unsigned char *link_str, + int link_len) +{ + int rc; + struct ksmbd_crypto_ctx *ctx; + + ctx = ksmbd_crypto_ctx_find_md4(); + if (!ctx) { + ksmbd_debug(AUTH, "Crypto md4 allocation error\n"); + return -EINVAL; + } + + rc = crypto_shash_init(CRYPTO_MD4(ctx)); + if (rc) { + ksmbd_debug(AUTH, "Could not init md4 shash\n"); + goto out; + } + + rc = crypto_shash_update(CRYPTO_MD4(ctx), link_str, link_len); + if (rc) { + ksmbd_debug(AUTH, "Could not update with link_str\n"); + goto out; + } + + rc = crypto_shash_final(CRYPTO_MD4(ctx), md4_hash); + if (rc) + ksmbd_debug(AUTH, "Could not generate md4 hash\n"); +out: + ksmbd_release_crypto_ctx(ctx); + return rc; +} + +static int ksmbd_enc_update_sess_key(unsigned char *md5_hash, char *nonce, + char *server_challenge, int len) +{ + int rc; + struct ksmbd_crypto_ctx *ctx; + + ctx = ksmbd_crypto_ctx_find_md5(); + if (!ctx) { + ksmbd_debug(AUTH, "Crypto md5 allocation error\n"); + return -EINVAL; + } + + rc = crypto_shash_init(CRYPTO_MD5(ctx)); + if (rc) { + ksmbd_debug(AUTH, "Could not init md5 shash\n"); + goto out; + } + + rc = crypto_shash_update(CRYPTO_MD5(ctx), server_challenge, len); + if (rc) { + ksmbd_debug(AUTH, "Could not update with challenge\n"); + goto out; + } + + rc = crypto_shash_update(CRYPTO_MD5(ctx), nonce, len); + if (rc) { + ksmbd_debug(AUTH, "Could not update with nonce\n"); + goto out; + } + + rc = crypto_shash_final(CRYPTO_MD5(ctx), md5_hash); + if (rc) + ksmbd_debug(AUTH, "Could not generate md5 hash\n"); +out: + ksmbd_release_crypto_ctx(ctx); + return rc; +} + +/** + * ksmbd_gen_sess_key() - function to generate session key + * @sess: session of connection + * @hash: source hash value to be used for find session key + * @hmac: source hmac value to be used for finding session key + * + */ +static int ksmbd_gen_sess_key(struct ksmbd_session *sess, char *hash, + char *hmac) +{ + struct ksmbd_crypto_ctx *ctx; + int rc = -EINVAL; + + ctx = ksmbd_crypto_ctx_find_hmacmd5(); + if (!ctx) + goto out; + + rc = crypto_shash_setkey(CRYPTO_HMACMD5_TFM(ctx), + hash, + CIFS_HMAC_MD5_HASH_SIZE); + if (rc) { + ksmbd_debug(AUTH, "hmacmd5 set key fail error %d\n", rc); + goto out; + } + + rc = crypto_shash_init(CRYPTO_HMACMD5(ctx)); + if (rc) { + ksmbd_debug(AUTH, "could not init hmacmd5 error %d\n", rc); + goto out; + } + + rc = crypto_shash_update(CRYPTO_HMACMD5(ctx), + hmac, + SMB2_NTLMV2_SESSKEY_SIZE); + if (rc) { + ksmbd_debug(AUTH, "Could not update with response error %d\n", + rc); + goto out; + } + + rc = crypto_shash_final(CRYPTO_HMACMD5(ctx), sess->sess_key); + if (rc) { + ksmbd_debug(AUTH, "Could not generate hmacmd5 hash error %d\n", + rc); + goto out; + } + +out: + ksmbd_release_crypto_ctx(ctx); + return rc; +} + +static int calc_ntlmv2_hash(struct ksmbd_session *sess, char *ntlmv2_hash, + char *dname) +{ + int ret = -EINVAL, len; + wchar_t *domain = NULL; + __le16 *uniname = NULL; + struct ksmbd_crypto_ctx *ctx; + + ctx = ksmbd_crypto_ctx_find_hmacmd5(); + if (!ctx) { + ksmbd_debug(AUTH, "can't generate ntlmv2 hash\n"); + goto out; + } + + ret = crypto_shash_setkey(CRYPTO_HMACMD5_TFM(ctx), + user_passkey(sess->user), + CIFS_ENCPWD_SIZE); + if (ret) { + ksmbd_debug(AUTH, "Could not set NT Hash as a key\n"); + goto out; + } + + ret = crypto_shash_init(CRYPTO_HMACMD5(ctx)); + if (ret) { + ksmbd_debug(AUTH, "could not init hmacmd5\n"); + goto out; + } + + /* convert user_name to unicode */ + len = strlen(user_name(sess->user)); + uniname = kzalloc(2 + UNICODE_LEN(len), GFP_KERNEL); + if (!uniname) { + ret = -ENOMEM; + goto out; + } + + if (len) { + len = smb_strtoUTF16(uniname, user_name(sess->user), len, + sess->conn->local_nls); + UniStrupr(uniname); + } + + ret = crypto_shash_update(CRYPTO_HMACMD5(ctx), + (char *)uniname, + UNICODE_LEN(len)); + if (ret) { + ksmbd_debug(AUTH, "Could not update with user\n"); + goto out; + } + + /* Convert domain name or conn name to unicode and uppercase */ + len = strlen(dname); + domain = kzalloc(2 + UNICODE_LEN(len), GFP_KERNEL); + if (!domain) { + ret = -ENOMEM; + goto out; + } + + len = smb_strtoUTF16((__le16 *)domain, dname, len, + sess->conn->local_nls); + + ret = crypto_shash_update(CRYPTO_HMACMD5(ctx), + (char *)domain, + UNICODE_LEN(len)); + if (ret) { + ksmbd_debug(AUTH, "Could not update with domain\n"); + goto out; + } + + ret = crypto_shash_final(CRYPTO_HMACMD5(ctx), ntlmv2_hash); +out: + if (ret) + ksmbd_debug(AUTH, "Could not generate md5 hash\n"); + kfree(uniname); + kfree(domain); + ksmbd_release_crypto_ctx(ctx); + return ret; +} + +/** + * ksmbd_auth_ntlm() - NTLM authentication handler + * @sess: session of connection + * @pw_buf: NTLM challenge response + * @passkey: user password + * + * Return: 0 on success, error number on error + */ +int ksmbd_auth_ntlm(struct ksmbd_session *sess, char *pw_buf) +{ + int rc; + unsigned char p21[21]; + char key[CIFS_AUTH_RESP_SIZE]; + + memset(p21, '\0', 21); + memcpy(p21, user_passkey(sess->user), CIFS_NTHASH_SIZE); + rc = ksmbd_enc_p24(p21, sess->ntlmssp.cryptkey, key); + if (rc) { + ksmbd_err("password processing failed\n"); + return rc; + } + + ksmbd_enc_md4(sess->sess_key, + user_passkey(sess->user), + CIFS_SMB1_SESSKEY_SIZE); + memcpy(sess->sess_key + CIFS_SMB1_SESSKEY_SIZE, key, + CIFS_AUTH_RESP_SIZE); + sess->sequence_number = 1; + + if (strncmp(pw_buf, key, CIFS_AUTH_RESP_SIZE) != 0) { + ksmbd_debug(AUTH, "ntlmv1 authentication failed\n"); + rc = -EINVAL; + } else { + ksmbd_debug(AUTH, "ntlmv1 authentication pass\n"); + } + + return rc; +} + +/** + * ksmbd_auth_ntlmv2() - NTLMv2 authentication handler + * @sess: session of connection + * @ntlmv2: NTLMv2 challenge response + * @blen: NTLMv2 blob length + * @domain_name: domain name + * + * Return: 0 on success, error number on error + */ +int ksmbd_auth_ntlmv2(struct ksmbd_session *sess, struct ntlmv2_resp *ntlmv2, + int blen, char *domain_name) +{ + char ntlmv2_hash[CIFS_ENCPWD_SIZE]; + char ntlmv2_rsp[CIFS_HMAC_MD5_HASH_SIZE]; + struct ksmbd_crypto_ctx *ctx; + char *construct = NULL; + int rc = -EINVAL, len; + + ctx = ksmbd_crypto_ctx_find_hmacmd5(); + if (!ctx) { + ksmbd_debug(AUTH, "could not crypto alloc hmacmd5 rc %d\n", rc); + goto out; + } + + rc = calc_ntlmv2_hash(sess, ntlmv2_hash, domain_name); + if (rc) { + ksmbd_debug(AUTH, "could not get v2 hash rc %d\n", rc); + goto out; + } + + rc = crypto_shash_setkey(CRYPTO_HMACMD5_TFM(ctx), + ntlmv2_hash, + CIFS_HMAC_MD5_HASH_SIZE); + if (rc) { + ksmbd_debug(AUTH, "Could not set NTLMV2 Hash as a key\n"); + goto out; + } + + rc = crypto_shash_init(CRYPTO_HMACMD5(ctx)); + if (rc) { + ksmbd_debug(AUTH, "Could not init hmacmd5\n"); + goto out; + } + + len = CIFS_CRYPTO_KEY_SIZE + blen; + construct = kzalloc(len, GFP_KERNEL); + if (!construct) { + rc = -ENOMEM; + goto out; + } + + memcpy(construct, sess->ntlmssp.cryptkey, CIFS_CRYPTO_KEY_SIZE); + memcpy(construct + CIFS_CRYPTO_KEY_SIZE, + (char *)(&ntlmv2->blob_signature), blen); + + rc = crypto_shash_update(CRYPTO_HMACMD5(ctx), construct, len); + if (rc) { + ksmbd_debug(AUTH, "Could not update with response\n"); + goto out; + } + + rc = crypto_shash_final(CRYPTO_HMACMD5(ctx), ntlmv2_rsp); + if (rc) { + ksmbd_debug(AUTH, "Could not generate md5 hash\n"); + goto out; + } + + rc = ksmbd_gen_sess_key(sess, ntlmv2_hash, ntlmv2_rsp); + if (rc) { + ksmbd_debug(AUTH, "Could not generate sess key\n"); + goto out; + } + + rc = memcmp(ntlmv2->ntlmv2_hash, ntlmv2_rsp, CIFS_HMAC_MD5_HASH_SIZE); +out: + ksmbd_release_crypto_ctx(ctx); + kfree(construct); + return rc; +} + +/** + * __ksmbd_auth_ntlmv2() - NTLM2(extended security) authentication handler + * @sess: session of connection + * @client_nonce: client nonce from LM response. + * @ntlm_resp: ntlm response data from client. + * + * Return: 0 on success, error number on error + */ +static int __ksmbd_auth_ntlmv2(struct ksmbd_session *sess, char *client_nonce, + char *ntlm_resp) +{ + char sess_key[CIFS_SMB1_SESSKEY_SIZE] = {0}; + int rc; + unsigned char p21[21]; + char key[CIFS_AUTH_RESP_SIZE]; + + rc = ksmbd_enc_update_sess_key(sess_key, + client_nonce, + (char *)sess->ntlmssp.cryptkey, 8); + if (rc) { + ksmbd_err("password processing failed\n"); + goto out; + } + + memset(p21, '\0', 21); + memcpy(p21, user_passkey(sess->user), CIFS_NTHASH_SIZE); + rc = ksmbd_enc_p24(p21, sess_key, key); + if (rc) { + ksmbd_err("password processing failed\n"); + goto out; + } + + rc = memcmp(ntlm_resp, key, CIFS_AUTH_RESP_SIZE); +out: + return rc; +} + +/** + * ksmbd_decode_ntlmssp_auth_blob() - helper function to construct + * authenticate blob + * @authblob: authenticate blob source pointer + * @usr: user details + * @sess: session of connection + * + * Return: 0 on success, error number on error + */ +int ksmbd_decode_ntlmssp_auth_blob(struct authenticate_message *authblob, + int blob_len, struct ksmbd_session *sess) +{ + char *domain_name; + unsigned int lm_off, nt_off; + unsigned short nt_len; + int ret; + + if (blob_len < sizeof(struct authenticate_message)) { + ksmbd_debug(AUTH, "negotiate blob len %d too small\n", + blob_len); + return -EINVAL; + } + + if (memcmp(authblob->Signature, "NTLMSSP", 8)) { + ksmbd_debug(AUTH, "blob signature incorrect %s\n", + authblob->Signature); + return -EINVAL; + } + + lm_off = le32_to_cpu(authblob->LmChallengeResponse.BufferOffset); + nt_off = le32_to_cpu(authblob->NtChallengeResponse.BufferOffset); + nt_len = le16_to_cpu(authblob->NtChallengeResponse.Length); + + /* process NTLM authentication */ + if (nt_len == CIFS_AUTH_RESP_SIZE) { + if (le32_to_cpu(authblob->NegotiateFlags) & + NTLMSSP_NEGOTIATE_EXTENDED_SEC) + return __ksmbd_auth_ntlmv2(sess, (char *)authblob + + lm_off, (char *)authblob + nt_off); + else + return ksmbd_auth_ntlm(sess, (char *)authblob + + nt_off); + } + + /* TODO : use domain name that imported from configuration file */ + domain_name = smb_strndup_from_utf16((const char *)authblob + + le32_to_cpu(authblob->DomainName.BufferOffset), + le16_to_cpu(authblob->DomainName.Length), true, + sess->conn->local_nls); + if (IS_ERR(domain_name)) + return PTR_ERR(domain_name); + + /* process NTLMv2 authentication */ + ksmbd_debug(AUTH, "decode_ntlmssp_authenticate_blob dname%s\n", + domain_name); + ret = ksmbd_auth_ntlmv2(sess, + (struct ntlmv2_resp *)((char *)authblob + nt_off), + nt_len - CIFS_ENCPWD_SIZE, + domain_name); + kfree(domain_name); + return ret; +} + +/** + * ksmbd_decode_ntlmssp_neg_blob() - helper function to construct + * negotiate blob + * @negblob: negotiate blob source pointer + * @rsp: response header pointer to be updated + * @sess: session of connection + * + */ +int ksmbd_decode_ntlmssp_neg_blob(struct negotiate_message *negblob, + int blob_len, struct ksmbd_session *sess) +{ + if (blob_len < sizeof(struct negotiate_message)) { + ksmbd_debug(AUTH, "negotiate blob len %d too small\n", + blob_len); + return -EINVAL; + } + + if (memcmp(negblob->Signature, "NTLMSSP", 8)) { + ksmbd_debug(AUTH, "blob signature incorrect %s\n", + negblob->Signature); + return -EINVAL; + } + + sess->ntlmssp.client_flags = le32_to_cpu(negblob->NegotiateFlags); + return 0; +} + +/** + * ksmbd_build_ntlmssp_challenge_blob() - helper function to construct + * challenge blob + * @chgblob: challenge blob source pointer to initialize + * @rsp: response header pointer to be updated + * @sess: session of connection + * + */ +unsigned int +ksmbd_build_ntlmssp_challenge_blob(struct challenge_message *chgblob, + struct ksmbd_session *sess) +{ + struct target_info *tinfo; + wchar_t *name; + __u8 *target_name; + unsigned int len, flags, blob_off, blob_len, type, target_info_len = 0; + int cflags = sess->ntlmssp.client_flags; + + memcpy(chgblob->Signature, NTLMSSP_SIGNATURE, 8); + chgblob->MessageType = NtLmChallenge; + + flags = NTLMSSP_NEGOTIATE_UNICODE | + NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_TARGET_TYPE_SERVER | + NTLMSSP_NEGOTIATE_TARGET_INFO; + + if (cflags & NTLMSSP_NEGOTIATE_SIGN) { + flags |= NTLMSSP_NEGOTIATE_SIGN; + flags |= cflags & (NTLMSSP_NEGOTIATE_128 | + NTLMSSP_NEGOTIATE_56); + } + + if (cflags & NTLMSSP_NEGOTIATE_ALWAYS_SIGN) + flags |= NTLMSSP_NEGOTIATE_ALWAYS_SIGN; + + if (cflags & NTLMSSP_REQUEST_TARGET) + flags |= NTLMSSP_REQUEST_TARGET; + + if (sess->conn->use_spnego && + (cflags & NTLMSSP_NEGOTIATE_EXTENDED_SEC)) + flags |= NTLMSSP_NEGOTIATE_EXTENDED_SEC; + + chgblob->NegotiateFlags = cpu_to_le32(flags); + len = strlen(ksmbd_netbios_name()); + name = kmalloc(2 + (len * 2), GFP_KERNEL); + if (!name) + return -ENOMEM; + + len = smb_strtoUTF16((__le16 *)name, ksmbd_netbios_name(), len, + sess->conn->local_nls); + len = UNICODE_LEN(len); + + blob_off = sizeof(struct challenge_message); + blob_len = blob_off + len; + + chgblob->TargetName.Length = cpu_to_le16(len); + chgblob->TargetName.MaximumLength = cpu_to_le16(len); + chgblob->TargetName.BufferOffset = cpu_to_le32(blob_off); + + /* Initialize random conn challenge */ + get_random_bytes(sess->ntlmssp.cryptkey, sizeof(__u64)); + memcpy(chgblob->Challenge, sess->ntlmssp.cryptkey, + CIFS_CRYPTO_KEY_SIZE); + + /* Add Target Information to security buffer */ + chgblob->TargetInfoArray.BufferOffset = cpu_to_le32(blob_len); + + target_name = (__u8 *)chgblob + blob_off; + memcpy(target_name, name, len); + tinfo = (struct target_info *)(target_name + len); + + chgblob->TargetInfoArray.Length = 0; + /* Add target info list for NetBIOS/DNS settings */ + for (type = NTLMSSP_AV_NB_COMPUTER_NAME; + type <= NTLMSSP_AV_DNS_DOMAIN_NAME; type++) { + tinfo->Type = cpu_to_le16(type); + tinfo->Length = cpu_to_le16(len); + memcpy(tinfo->Content, name, len); + tinfo = (struct target_info *)((char *)tinfo + 4 + len); + target_info_len += 4 + len; + } + + /* Add terminator subblock */ + tinfo->Type = 0; + tinfo->Length = 0; + target_info_len += 4; + + chgblob->TargetInfoArray.Length = cpu_to_le16(target_info_len); + chgblob->TargetInfoArray.MaximumLength = cpu_to_le16(target_info_len); + blob_len += target_info_len; + kfree(name); + ksmbd_debug(AUTH, "NTLMSSP SecurityBufferLength %d\n", blob_len); + return blob_len; +} + +#ifdef CONFIG_SMB_SERVER_KERBEROS5 +int ksmbd_krb5_authenticate(struct ksmbd_session *sess, char *in_blob, + int in_len, char *out_blob, int *out_len) +{ + struct ksmbd_spnego_authen_response *resp; + struct ksmbd_user *user = NULL; + int retval; + + resp = ksmbd_ipc_spnego_authen_request(in_blob, in_len); + if (!resp) { + ksmbd_debug(AUTH, "SPNEGO_AUTHEN_REQUEST failure\n"); + return -EINVAL; + } + + if (!(resp->login_response.status & KSMBD_USER_FLAG_OK)) { + ksmbd_debug(AUTH, "krb5 authentication failure\n"); + retval = -EPERM; + goto out; + } + + if (*out_len <= resp->spnego_blob_len) { + ksmbd_debug(AUTH, "buf len %d, but blob len %d\n", + *out_len, resp->spnego_blob_len); + retval = -EINVAL; + goto out; + } + + if (resp->session_key_len > sizeof(sess->sess_key)) { + ksmbd_debug(AUTH, "session key is too long\n"); + retval = -EINVAL; + goto out; + } + + user = ksmbd_alloc_user(&resp->login_response); + if (!user) { + ksmbd_debug(AUTH, "login failure\n"); + retval = -ENOMEM; + goto out; + } + sess->user = user; + + memcpy(sess->sess_key, resp->payload, resp->session_key_len); + memcpy(out_blob, resp->payload + resp->session_key_len, + resp->spnego_blob_len); + *out_len = resp->spnego_blob_len; + retval = 0; +out: + kvfree(resp); + return retval; +} +#else +int ksmbd_krb5_authenticate(struct ksmbd_session *sess, char *in_blob, + int in_len, char *out_blob, int *out_len) +{ + return -EOPNOTSUPP; +} +#endif + +/** + * ksmbd_sign_smb2_pdu() - function to generate packet signing + * @conn: connection + * @key: signing key + * @iov: buffer iov array + * @n_vec: number of iovecs + * @sig: signature value generated for client request packet + * + */ +int ksmbd_sign_smb2_pdu(struct ksmbd_conn *conn, char *key, struct kvec *iov, + int n_vec, char *sig) +{ + struct ksmbd_crypto_ctx *ctx; + int rc = -EINVAL; + int i; + + ctx = ksmbd_crypto_ctx_find_hmacsha256(); + if (!ctx) { + ksmbd_debug(AUTH, "could not crypto alloc hmacmd5 rc %d\n", rc); + goto out; + } + + rc = crypto_shash_setkey(CRYPTO_HMACSHA256_TFM(ctx), + key, + SMB2_NTLMV2_SESSKEY_SIZE); + if (rc) + goto out; + + rc = crypto_shash_init(CRYPTO_HMACSHA256(ctx)); + if (rc) { + ksmbd_debug(AUTH, "hmacsha256 init error %d\n", rc); + goto out; + } + + for (i = 0; i < n_vec; i++) { + rc = crypto_shash_update(CRYPTO_HMACSHA256(ctx), + iov[i].iov_base, + iov[i].iov_len); + if (rc) { + ksmbd_debug(AUTH, "hmacsha256 update error %d\n", rc); + goto out; + } + } + + rc = crypto_shash_final(CRYPTO_HMACSHA256(ctx), sig); + if (rc) + ksmbd_debug(AUTH, "hmacsha256 generation error %d\n", rc); +out: + ksmbd_release_crypto_ctx(ctx); + return rc; +} + +/** + * ksmbd_sign_smb3_pdu() - function to generate packet signing + * @conn: connection + * @key: signing key + * @iov: buffer iov array + * @n_vec: number of iovecs + * @sig: signature value generated for client request packet + * + */ +int ksmbd_sign_smb3_pdu(struct ksmbd_conn *conn, char *key, struct kvec *iov, + int n_vec, char *sig) +{ + struct ksmbd_crypto_ctx *ctx; + int rc = -EINVAL; + int i; + + ctx = ksmbd_crypto_ctx_find_cmacaes(); + if (!ctx) { + ksmbd_debug(AUTH, "could not crypto alloc cmac rc %d\n", rc); + goto out; + } + + rc = crypto_shash_setkey(CRYPTO_CMACAES_TFM(ctx), + key, + SMB2_CMACAES_SIZE); + if (rc) + goto out; + + rc = crypto_shash_init(CRYPTO_CMACAES(ctx)); + if (rc) { + ksmbd_debug(AUTH, "cmaces init error %d\n", rc); + goto out; + } + + for (i = 0; i < n_vec; i++) { + rc = crypto_shash_update(CRYPTO_CMACAES(ctx), + iov[i].iov_base, + iov[i].iov_len); + if (rc) { + ksmbd_debug(AUTH, "cmaces update error %d\n", rc); + goto out; + } + } + + rc = crypto_shash_final(CRYPTO_CMACAES(ctx), sig); + if (rc) + ksmbd_debug(AUTH, "cmaces generation error %d\n", rc); +out: + ksmbd_release_crypto_ctx(ctx); + return rc; +} + +struct derivation { + struct kvec label; + struct kvec context; + bool binding; +}; + +static int generate_key(struct ksmbd_session *sess, struct kvec label, + struct kvec context, __u8 *key, unsigned int key_size) +{ + unsigned char zero = 0x0; + __u8 i[4] = {0, 0, 0, 1}; + __u8 L128[4] = {0, 0, 0, 128}; + __u8 L256[4] = {0, 0, 1, 0}; + int rc = -EINVAL; + unsigned char prfhash[SMB2_HMACSHA256_SIZE]; + unsigned char *hashptr = prfhash; + struct ksmbd_crypto_ctx *ctx; + + memset(prfhash, 0x0, SMB2_HMACSHA256_SIZE); + memset(key, 0x0, key_size); + + ctx = ksmbd_crypto_ctx_find_hmacsha256(); + if (!ctx) { + ksmbd_debug(AUTH, "could not crypto alloc hmacmd5 rc %d\n", rc); + goto smb3signkey_ret; + } + + rc = crypto_shash_setkey(CRYPTO_HMACSHA256_TFM(ctx), + sess->sess_key, + SMB2_NTLMV2_SESSKEY_SIZE); + if (rc) + goto smb3signkey_ret; + + rc = crypto_shash_init(CRYPTO_HMACSHA256(ctx)); + if (rc) { + ksmbd_debug(AUTH, "hmacsha256 init error %d\n", rc); + goto smb3signkey_ret; + } + + rc = crypto_shash_update(CRYPTO_HMACSHA256(ctx), i, 4); + if (rc) { + ksmbd_debug(AUTH, "could not update with n\n"); + goto smb3signkey_ret; + } + + rc = crypto_shash_update(CRYPTO_HMACSHA256(ctx), + label.iov_base, + label.iov_len); + if (rc) { + ksmbd_debug(AUTH, "could not update with label\n"); + goto smb3signkey_ret; + } + + rc = crypto_shash_update(CRYPTO_HMACSHA256(ctx), &zero, 1); + if (rc) { + ksmbd_debug(AUTH, "could not update with zero\n"); + goto smb3signkey_ret; + } + + rc = crypto_shash_update(CRYPTO_HMACSHA256(ctx), + context.iov_base, + context.iov_len); + if (rc) { + ksmbd_debug(AUTH, "could not update with context\n"); + goto smb3signkey_ret; + } + + if (sess->conn->cipher_type == SMB2_ENCRYPTION_AES256_CCM || + sess->conn->cipher_type == SMB2_ENCRYPTION_AES256_GCM) + rc = crypto_shash_update(CRYPTO_HMACSHA256(ctx), L256, 4); + else + rc = crypto_shash_update(CRYPTO_HMACSHA256(ctx), L128, 4); + if (rc) { + ksmbd_debug(AUTH, "could not update with L\n"); + goto smb3signkey_ret; + } + + rc = crypto_shash_final(CRYPTO_HMACSHA256(ctx), hashptr); + if (rc) { + ksmbd_debug(AUTH, "Could not generate hmacmd5 hash error %d\n", + rc); + goto smb3signkey_ret; + } + + memcpy(key, hashptr, key_size); + +smb3signkey_ret: + ksmbd_release_crypto_ctx(ctx); + return rc; +} + +static int generate_smb3signingkey(struct ksmbd_session *sess, + const struct derivation *signing) +{ + int rc; + struct channel *chann; + char *key; + + chann = lookup_chann_list(sess); + if (!chann) + return 0; + + if (sess->conn->dialect >= SMB30_PROT_ID && signing->binding) + key = chann->smb3signingkey; + else + key = sess->smb3signingkey; + + rc = generate_key(sess, signing->label, signing->context, key, + SMB3_SIGN_KEY_SIZE); + if (rc) + return rc; + + if (!(sess->conn->dialect >= SMB30_PROT_ID && signing->binding)) + memcpy(chann->smb3signingkey, key, SMB3_SIGN_KEY_SIZE); + + ksmbd_debug(AUTH, "dumping generated AES signing keys\n"); + ksmbd_debug(AUTH, "Session Id %llu\n", sess->id); + ksmbd_debug(AUTH, "Session Key %*ph\n", + SMB2_NTLMV2_SESSKEY_SIZE, sess->sess_key); + ksmbd_debug(AUTH, "Signing Key %*ph\n", + SMB3_SIGN_KEY_SIZE, key); + return rc; +} + +int ksmbd_gen_smb30_signingkey(struct ksmbd_session *sess) +{ + struct derivation d; + + d.label.iov_base = "SMB2AESCMAC"; + d.label.iov_len = 12; + d.context.iov_base = "SmbSign"; + d.context.iov_len = 8; + d.binding = false; + + return generate_smb3signingkey(sess, &d); +} + +int ksmbd_gen_smb311_signingkey(struct ksmbd_session *sess) +{ + struct derivation d; + + d.label.iov_base = "SMBSigningKey"; + d.label.iov_len = 14; + d.context.iov_base = sess->Preauth_HashValue; + d.context.iov_len = 64; + d.binding = false; + + return generate_smb3signingkey(sess, &d); +} + +struct derivation_twin { + struct derivation encryption; + struct derivation decryption; +}; + +static int generate_smb3encryptionkey(struct ksmbd_session *sess, + const struct derivation_twin *ptwin) +{ + int rc; + + rc = generate_key(sess, ptwin->encryption.label, + ptwin->encryption.context, sess->smb3encryptionkey, + SMB3_ENC_DEC_KEY_SIZE); + if (rc) + return rc; + + rc = generate_key(sess, ptwin->decryption.label, + ptwin->decryption.context, + sess->smb3decryptionkey, SMB3_ENC_DEC_KEY_SIZE); + if (rc) + return rc; + + ksmbd_debug(AUTH, "dumping generated AES encryption keys\n"); + ksmbd_debug(AUTH, "Cipher type %d\n", sess->conn->cipher_type); + ksmbd_debug(AUTH, "Session Id %llu\n", sess->id); + ksmbd_debug(AUTH, "Session Key %*ph\n", + SMB2_NTLMV2_SESSKEY_SIZE, sess->sess_key); + if (sess->conn->cipher_type == SMB2_ENCRYPTION_AES256_CCM || + sess->conn->cipher_type == SMB2_ENCRYPTION_AES256_GCM) { + ksmbd_debug(AUTH, "ServerIn Key %*ph\n", + SMB3_GCM256_CRYPTKEY_SIZE, sess->smb3encryptionkey); + ksmbd_debug(AUTH, "ServerOut Key %*ph\n", + SMB3_GCM256_CRYPTKEY_SIZE, sess->smb3decryptionkey); + } else { + ksmbd_debug(AUTH, "ServerIn Key %*ph\n", + SMB3_GCM128_CRYPTKEY_SIZE, sess->smb3encryptionkey); + ksmbd_debug(AUTH, "ServerOut Key %*ph\n", + SMB3_GCM128_CRYPTKEY_SIZE, sess->smb3decryptionkey); + } + return rc; +} + +int ksmbd_gen_smb30_encryptionkey(struct ksmbd_session *sess) +{ + struct derivation_twin twin; + struct derivation *d; + + d = &twin.encryption; + d->label.iov_base = "SMB2AESCCM"; + d->label.iov_len = 11; + d->context.iov_base = "ServerOut"; + d->context.iov_len = 10; + + d = &twin.decryption; + d->label.iov_base = "SMB2AESCCM"; + d->label.iov_len = 11; + d->context.iov_base = "ServerIn "; + d->context.iov_len = 10; + + return generate_smb3encryptionkey(sess, &twin); +} + +int ksmbd_gen_smb311_encryptionkey(struct ksmbd_session *sess) +{ + struct derivation_twin twin; + struct derivation *d; + + d = &twin.encryption; + d->label.iov_base = "SMBS2CCipherKey"; + d->label.iov_len = 16; + d->context.iov_base = sess->Preauth_HashValue; + d->context.iov_len = 64; + + d = &twin.decryption; + d->label.iov_base = "SMBC2SCipherKey"; + d->label.iov_len = 16; + d->context.iov_base = sess->Preauth_HashValue; + d->context.iov_len = 64; + + return generate_smb3encryptionkey(sess, &twin); +} + +int ksmbd_gen_preauth_integrity_hash(struct ksmbd_conn *conn, char *buf, + __u8 *pi_hash) +{ + int rc = -1; + struct smb2_hdr *rcv_hdr = (struct smb2_hdr *)buf; + char *all_bytes_msg = (char *)&rcv_hdr->ProtocolId; + int msg_size = be32_to_cpu(rcv_hdr->smb2_buf_length); + struct ksmbd_crypto_ctx *ctx = NULL; + + if (conn->preauth_info->Preauth_HashId == + SMB2_PREAUTH_INTEGRITY_SHA512) { + ctx = ksmbd_crypto_ctx_find_sha512(); + if (!ctx) { + ksmbd_debug(AUTH, "could not alloc sha512 rc %d\n", rc); + goto out; + } + } else { + goto out; + } + + rc = crypto_shash_init(CRYPTO_SHA512(ctx)); + if (rc) { + ksmbd_debug(AUTH, "could not init shashn"); + goto out; + } + + rc = crypto_shash_update(CRYPTO_SHA512(ctx), pi_hash, 64); + if (rc) { + ksmbd_debug(AUTH, "could not update with n\n"); + goto out; + } + + rc = crypto_shash_update(CRYPTO_SHA512(ctx), all_bytes_msg, msg_size); + if (rc) { + ksmbd_debug(AUTH, "could not update with n\n"); + goto out; + } + + rc = crypto_shash_final(CRYPTO_SHA512(ctx), pi_hash); + if (rc) { + ksmbd_debug(AUTH, "Could not generate hash err : %d\n", rc); + goto out; + } +out: + ksmbd_release_crypto_ctx(ctx); + return rc; +} + +int ksmbd_gen_sd_hash(struct ksmbd_conn *conn, char *sd_buf, int len, + __u8 *pi_hash) +{ + int rc = -1; + struct ksmbd_crypto_ctx *ctx = NULL; + + ctx = ksmbd_crypto_ctx_find_sha256(); + if (!ctx) { + ksmbd_debug(AUTH, "could not alloc sha256 rc %d\n", rc); + goto out; + } + + rc = crypto_shash_init(CRYPTO_SHA256(ctx)); + if (rc) { + ksmbd_debug(AUTH, "could not init shashn"); + goto out; + } + + rc = crypto_shash_update(CRYPTO_SHA256(ctx), sd_buf, len); + if (rc) { + ksmbd_debug(AUTH, "could not update with n\n"); + goto out; + } + + rc = crypto_shash_final(CRYPTO_SHA256(ctx), pi_hash); + if (rc) { + ksmbd_debug(AUTH, "Could not generate hash err : %d\n", rc); + goto out; + } +out: + ksmbd_release_crypto_ctx(ctx); + return rc; +} + +static int ksmbd_get_encryption_key(struct ksmbd_conn *conn, __u64 ses_id, + int enc, u8 *key) +{ + struct ksmbd_session *sess; + u8 *ses_enc_key; + + sess = ksmbd_session_lookup(conn, ses_id); + if (!sess) + return 1; + + ses_enc_key = enc ? sess->smb3encryptionkey : + sess->smb3decryptionkey; + memcpy(key, ses_enc_key, SMB3_ENC_DEC_KEY_SIZE); + + return 0; +} + +static inline void smb2_sg_set_buf(struct scatterlist *sg, const void *buf, + unsigned int buflen) +{ + void *addr; + + if (is_vmalloc_addr(buf)) + addr = vmalloc_to_page(buf); + else + addr = virt_to_page(buf); + sg_set_page(sg, addr, buflen, offset_in_page(buf)); +} + +static struct scatterlist *ksmbd_init_sg(struct kvec *iov, unsigned int nvec, + u8 *sign) +{ + struct scatterlist *sg; + unsigned int assoc_data_len = sizeof(struct smb2_transform_hdr) - 24; + int i, nr_entries[3] = {0}, total_entries = 0, sg_idx = 0; + + for (i = 0; i < nvec - 1; i++) { + unsigned long kaddr = (unsigned long)iov[i + 1].iov_base; + + if (is_vmalloc_addr(iov[i + 1].iov_base)) { + nr_entries[i] = ((kaddr + iov[i + 1].iov_len + + PAGE_SIZE - 1) >> PAGE_SHIFT) - + (kaddr >> PAGE_SHIFT); + } else { + nr_entries[i]++; + } + total_entries += nr_entries[i]; + } + + /* Add two entries for transform header and signature */ + total_entries += 2; + + sg = kmalloc_array(total_entries, sizeof(struct scatterlist), GFP_KERNEL); + if (!sg) + return NULL; + + sg_init_table(sg, total_entries); + smb2_sg_set_buf(&sg[sg_idx++], iov[0].iov_base + 24, assoc_data_len); + for (i = 0; i < nvec - 1; i++) { + void *data = iov[i + 1].iov_base; + int len = iov[i + 1].iov_len; + + if (is_vmalloc_addr(data)) { + int j, offset = offset_in_page(data); + + for (j = 0; j < nr_entries[i]; j++) { + unsigned int bytes = PAGE_SIZE - offset; + + if (len <= 0) + break; + + if (bytes > len) + bytes = len; + + sg_set_page(&sg[sg_idx++], + vmalloc_to_page(data), bytes, + offset_in_page(data)); + + data += bytes; + len -= bytes; + offset = 0; + } + } else { + sg_set_page(&sg[sg_idx++], virt_to_page(data), len, + offset_in_page(data)); + } + } + smb2_sg_set_buf(&sg[sg_idx], sign, SMB2_SIGNATURE_SIZE); + return sg; +} + +int ksmbd_crypt_message(struct ksmbd_conn *conn, struct kvec *iov, + unsigned int nvec, int enc) +{ + struct smb2_transform_hdr *tr_hdr = + (struct smb2_transform_hdr *)iov[0].iov_base; + unsigned int assoc_data_len = sizeof(struct smb2_transform_hdr) - 24; + int rc = 0; + struct scatterlist *sg; + u8 sign[SMB2_SIGNATURE_SIZE] = {}; + u8 key[SMB3_ENC_DEC_KEY_SIZE]; + struct aead_request *req; + char *iv; + unsigned int iv_len; + struct crypto_aead *tfm; + unsigned int crypt_len = le32_to_cpu(tr_hdr->OriginalMessageSize); + struct ksmbd_crypto_ctx *ctx; + + rc = ksmbd_get_encryption_key(conn, + le64_to_cpu(tr_hdr->SessionId), + enc, + key); + if (rc) { + ksmbd_err("Could not get %scryption key\n", enc ? "en" : "de"); + return 0; + } + + if (conn->cipher_type == SMB2_ENCRYPTION_AES128_GCM || + conn->cipher_type == SMB2_ENCRYPTION_AES256_GCM) + ctx = ksmbd_crypto_ctx_find_gcm(); + else + ctx = ksmbd_crypto_ctx_find_ccm(); + if (!ctx) { + ksmbd_err("crypto alloc failed\n"); + return -EINVAL; + } + + if (conn->cipher_type == SMB2_ENCRYPTION_AES128_GCM || + conn->cipher_type == SMB2_ENCRYPTION_AES256_GCM) + tfm = CRYPTO_GCM(ctx); + else + tfm = CRYPTO_CCM(ctx); + + if (conn->cipher_type == SMB2_ENCRYPTION_AES256_CCM || + conn->cipher_type == SMB2_ENCRYPTION_AES256_GCM) + rc = crypto_aead_setkey(tfm, key, SMB3_GCM256_CRYPTKEY_SIZE); + else + rc = crypto_aead_setkey(tfm, key, SMB3_GCM128_CRYPTKEY_SIZE); + if (rc) { + ksmbd_err("Failed to set aead key %d\n", rc); + goto free_ctx; + } + + rc = crypto_aead_setauthsize(tfm, SMB2_SIGNATURE_SIZE); + if (rc) { + ksmbd_err("Failed to set authsize %d\n", rc); + goto free_ctx; + } + + req = aead_request_alloc(tfm, GFP_KERNEL); + if (!req) { + ksmbd_err("Failed to alloc aead request\n"); + rc = -ENOMEM; + goto free_ctx; + } + + if (!enc) { + memcpy(sign, &tr_hdr->Signature, SMB2_SIGNATURE_SIZE); + crypt_len += SMB2_SIGNATURE_SIZE; + } + + sg = ksmbd_init_sg(iov, nvec, sign); + if (!sg) { + ksmbd_err("Failed to init sg\n"); + rc = -ENOMEM; + goto free_req; + } + + iv_len = crypto_aead_ivsize(tfm); + iv = kzalloc(iv_len, GFP_KERNEL); + if (!iv) { + ksmbd_err("Failed to alloc IV\n"); + rc = -ENOMEM; + goto free_sg; + } + + if (conn->cipher_type == SMB2_ENCRYPTION_AES128_GCM || + conn->cipher_type == SMB2_ENCRYPTION_AES256_GCM) { + memcpy(iv, (char *)tr_hdr->Nonce, SMB3_AES_GCM_NONCE); + } else { + iv[0] = 3; + memcpy(iv + 1, (char *)tr_hdr->Nonce, SMB3_AES_CCM_NONCE); + } + + aead_request_set_crypt(req, sg, sg, crypt_len, iv); + aead_request_set_ad(req, assoc_data_len); + aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_SLEEP, NULL, NULL); + + if (enc) + rc = crypto_aead_encrypt(req); + else + rc = crypto_aead_decrypt(req); + if (!rc && enc) + memcpy(&tr_hdr->Signature, sign, SMB2_SIGNATURE_SIZE); + + kfree(iv); +free_sg: + kfree(sg); +free_req: + kfree(req); +free_ctx: + ksmbd_release_crypto_ctx(ctx); + return rc; +} diff --git a/fs/cifsd/auth.h b/fs/cifsd/auth.h new file mode 100644 index 000000000000..6fcfad5e7e1f --- /dev/null +++ b/fs/cifsd/auth.h @@ -0,0 +1,90 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2018 Samsung Electronics Co., Ltd. + */ + +#ifndef __AUTH_H__ +#define __AUTH_H__ + +#include "ntlmssp.h" + +#ifdef CONFIG_SMB_SERVER_KERBEROS5 +#define AUTH_GSS_LENGTH 96 +#define AUTH_GSS_PADDING 0 +#else +#define AUTH_GSS_LENGTH 74 +#define AUTH_GSS_PADDING 6 +#endif + +#define CIFS_HMAC_MD5_HASH_SIZE (16) +#define CIFS_NTHASH_SIZE (16) + +/* + * Size of the ntlm client response + */ +#define CIFS_AUTH_RESP_SIZE 24 +#define CIFS_SMB1_SIGNATURE_SIZE 8 +#define CIFS_SMB1_SESSKEY_SIZE 16 + +#define KSMBD_AUTH_NTLMSSP 0x0001 +#define KSMBD_AUTH_KRB5 0x0002 +#define KSMBD_AUTH_MSKRB5 0x0004 +#define KSMBD_AUTH_KRB5U2U 0x0008 + +struct ksmbd_session; +struct ksmbd_conn; +struct kvec; + +int ksmbd_crypt_message(struct ksmbd_conn *conn, + struct kvec *iov, + unsigned int nvec, + int enc); + +void ksmbd_copy_gss_neg_header(void *buf); + +int ksmbd_auth_ntlm(struct ksmbd_session *sess, + char *pw_buf); + +int ksmbd_auth_ntlmv2(struct ksmbd_session *sess, + struct ntlmv2_resp *ntlmv2, + int blen, + char *domain_name); + +int ksmbd_decode_ntlmssp_auth_blob(struct authenticate_message *authblob, + int blob_len, + struct ksmbd_session *sess); + +int ksmbd_decode_ntlmssp_neg_blob(struct negotiate_message *negblob, + int blob_len, + struct ksmbd_session *sess); + +unsigned int +ksmbd_build_ntlmssp_challenge_blob(struct challenge_message *chgblob, + struct ksmbd_session *sess); + +int ksmbd_krb5_authenticate(struct ksmbd_session *sess, + char *in_blob, int in_len, + char *out_blob, int *out_len); + +int ksmbd_sign_smb2_pdu(struct ksmbd_conn *conn, + char *key, + struct kvec *iov, + int n_vec, + char *sig); +int ksmbd_sign_smb3_pdu(struct ksmbd_conn *conn, + char *key, + struct kvec *iov, + int n_vec, + char *sig); + +int ksmbd_gen_smb30_signingkey(struct ksmbd_session *sess); +int ksmbd_gen_smb311_signingkey(struct ksmbd_session *sess); +int ksmbd_gen_smb30_encryptionkey(struct ksmbd_session *sess); +int ksmbd_gen_smb311_encryptionkey(struct ksmbd_session *sess); + +int ksmbd_gen_preauth_integrity_hash(struct ksmbd_conn *conn, + char *buf, + __u8 *pi_hash); +int ksmbd_gen_sd_hash(struct ksmbd_conn *conn, char *sd_buf, int len, + __u8 *pi_hash); +#endif diff --git a/fs/cifsd/crypto_ctx.c b/fs/cifsd/crypto_ctx.c new file mode 100644 index 000000000000..1830ae1b5ed3 --- /dev/null +++ b/fs/cifsd/crypto_ctx.c @@ -0,0 +1,286 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * Copyright (C) 2019 Samsung Electronics Co., Ltd. + */ + +#include <linux/kernel.h> +#include <linux/string.h> +#include <linux/err.h> +#include <linux/slab.h> +#include <linux/wait.h> +#include <linux/sched.h> + +#include "glob.h" +#include "crypto_ctx.h" +#include "buffer_pool.h" + +struct crypto_ctx_list { + spinlock_t ctx_lock; + int avail_ctx; + struct list_head idle_ctx; + wait_queue_head_t ctx_wait; +}; + +static struct crypto_ctx_list ctx_list; + +static inline void free_aead(struct crypto_aead *aead) +{ + if (aead) + crypto_free_aead(aead); +} + +static void free_shash(struct shash_desc *shash) +{ + if (shash) { + crypto_free_shash(shash->tfm); + kfree(shash); + } +} + +static struct crypto_aead *alloc_aead(int id) +{ + struct crypto_aead *tfm = NULL; + + switch (id) { + case CRYPTO_AEAD_AES_GCM: + tfm = crypto_alloc_aead("gcm(aes)", 0, 0); + break; + case CRYPTO_AEAD_AES_CCM: + tfm = crypto_alloc_aead("ccm(aes)", 0, 0); + break; + default: + ksmbd_err("Does not support encrypt ahead(id : %d)\n", id); + return NULL; + } + + if (IS_ERR(tfm)) { + ksmbd_err("Failed to alloc encrypt aead : %ld\n", PTR_ERR(tfm)); + return NULL; + } + + return tfm; +} + +static struct shash_desc *alloc_shash_desc(int id) +{ + struct crypto_shash *tfm = NULL; + struct shash_desc *shash; + + switch (id) { + case CRYPTO_SHASH_HMACMD5: + tfm = crypto_alloc_shash("hmac(md5)", 0, 0); + break; + case CRYPTO_SHASH_HMACSHA256: + tfm = crypto_alloc_shash("hmac(sha256)", 0, 0); + break; + case CRYPTO_SHASH_CMACAES: + tfm = crypto_alloc_shash("cmac(aes)", 0, 0); + break; + case CRYPTO_SHASH_SHA256: + tfm = crypto_alloc_shash("sha256", 0, 0); + break; + case CRYPTO_SHASH_SHA512: + tfm = crypto_alloc_shash("sha512", 0, 0); + break; + case CRYPTO_SHASH_MD4: + tfm = crypto_alloc_shash("md4", 0, 0); + break; + case CRYPTO_SHASH_MD5: + tfm = crypto_alloc_shash("md5", 0, 0); + break; + } + + if (IS_ERR(tfm)) + return NULL; + + shash = kzalloc(sizeof(*shash) + crypto_shash_descsize(tfm), + GFP_KERNEL); + if (!shash) + crypto_free_shash(tfm); + else + shash->tfm = tfm; + return shash; +} + +static struct ksmbd_crypto_ctx *ctx_alloc(void) +{ + return kzalloc(sizeof(struct ksmbd_crypto_ctx), GFP_KERNEL); +} + +static void ctx_free(struct ksmbd_crypto_ctx *ctx) +{ + int i; + + for (i = 0; i < CRYPTO_SHASH_MAX; i++) + free_shash(ctx->desc[i]); + for (i = 0; i < CRYPTO_AEAD_MAX; i++) + free_aead(ctx->ccmaes[i]); + kfree(ctx); +} + +static struct ksmbd_crypto_ctx *ksmbd_find_crypto_ctx(void) +{ + struct ksmbd_crypto_ctx *ctx; + + while (1) { + spin_lock(&ctx_list.ctx_lock); + if (!list_empty(&ctx_list.idle_ctx)) { + ctx = list_entry(ctx_list.idle_ctx.next, + struct ksmbd_crypto_ctx, + list); + list_del(&ctx->list); + spin_unlock(&ctx_list.ctx_lock); + return ctx; + } + + if (ctx_list.avail_ctx > num_online_cpus()) { + spin_unlock(&ctx_list.ctx_lock); + wait_event(ctx_list.ctx_wait, + !list_empty(&ctx_list.idle_ctx)); + continue; + } + + ctx_list.avail_ctx++; + spin_unlock(&ctx_list.ctx_lock); + + ctx = ctx_alloc(); + if (!ctx) { + spin_lock(&ctx_list.ctx_lock); + ctx_list.avail_ctx--; + spin_unlock(&ctx_list.ctx_lock); + wait_event(ctx_list.ctx_wait, + !list_empty(&ctx_list.idle_ctx)); + continue; + } + break; + } + return ctx; +} + +void ksmbd_release_crypto_ctx(struct ksmbd_crypto_ctx *ctx) +{ + if (!ctx) + return; + + spin_lock(&ctx_list.ctx_lock); + if (ctx_list.avail_ctx <= num_online_cpus()) { + list_add(&ctx->list, &ctx_list.idle_ctx); + spin_unlock(&ctx_list.ctx_lock); + wake_up(&ctx_list.ctx_wait); + return; + } + + ctx_list.avail_ctx--; + spin_unlock(&ctx_list.ctx_lock); + ctx_free(ctx); +} + +static struct ksmbd_crypto_ctx *____crypto_shash_ctx_find(int id) +{ + struct ksmbd_crypto_ctx *ctx; + + if (id >= CRYPTO_SHASH_MAX) + return NULL; + + ctx = ksmbd_find_crypto_ctx(); + if (ctx->desc[id]) + return ctx; + + ctx->desc[id] = alloc_shash_desc(id); + if (ctx->desc[id]) + return ctx; + ksmbd_release_crypto_ctx(ctx); + return NULL; +} + +struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_hmacmd5(void) +{ + return ____crypto_shash_ctx_find(CRYPTO_SHASH_HMACMD5); +} + +struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_hmacsha256(void) +{ + return ____crypto_shash_ctx_find(CRYPTO_SHASH_HMACSHA256); +} + +struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_cmacaes(void) +{ + return ____crypto_shash_ctx_find(CRYPTO_SHASH_CMACAES); +} + +struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_sha256(void) +{ + return ____crypto_shash_ctx_find(CRYPTO_SHASH_SHA256); +} + +struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_sha512(void) +{ + return ____crypto_shash_ctx_find(CRYPTO_SHASH_SHA512); +} + +struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_md4(void) +{ + return ____crypto_shash_ctx_find(CRYPTO_SHASH_MD4); +} + +struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_md5(void) +{ + return ____crypto_shash_ctx_find(CRYPTO_SHASH_MD5); +} + +static struct ksmbd_crypto_ctx *____crypto_aead_ctx_find(int id) +{ + struct ksmbd_crypto_ctx *ctx; + + if (id >= CRYPTO_AEAD_MAX) + return NULL; + + ctx = ksmbd_find_crypto_ctx(); + if (ctx->ccmaes[id]) + return ctx; + + ctx->ccmaes[id] = alloc_aead(id); + if (ctx->ccmaes[id]) + return ctx; + ksmbd_release_crypto_ctx(ctx); + return NULL; +} + +struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_gcm(void) +{ + return ____crypto_aead_ctx_find(CRYPTO_AEAD_AES_GCM); +} + +struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_ccm(void) +{ + return ____crypto_aead_ctx_find(CRYPTO_AEAD_AES_CCM); +} + +void ksmbd_crypto_destroy(void) +{ + struct ksmbd_crypto_ctx *ctx; + + while (!list_empty(&ctx_list.idle_ctx)) { + ctx = list_entry(ctx_list.idle_ctx.next, + struct ksmbd_crypto_ctx, + list); + list_del(&ctx->list); + ctx_free(ctx); + } +} + +int ksmbd_crypto_create(void) +{ + struct ksmbd_crypto_ctx *ctx; + + spin_lock_init(&ctx_list.ctx_lock); + INIT_LIST_HEAD(&ctx_list.idle_ctx); + init_waitqueue_head(&ctx_list.ctx_wait); + ctx_list.avail_ctx = 1; + + ctx = ctx_alloc(); + if (!ctx) + return -ENOMEM; + list_add(&ctx->list, &ctx_list.idle_ctx); + return 0; +} diff --git a/fs/cifsd/crypto_ctx.h b/fs/cifsd/crypto_ctx.h new file mode 100644 index 000000000000..b0d3cd650485 --- /dev/null +++ b/fs/cifsd/crypto_ctx.h @@ -0,0 +1,77 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2019 Samsung Electronics Co., Ltd. + */ + +#ifndef __CRYPTO_CTX_H__ +#define __CRYPTO_CTX_H__ + +#include <crypto/hash.h> +#include <crypto/aead.h> + +enum { + CRYPTO_SHASH_HMACMD5 = 0, + CRYPTO_SHASH_HMACSHA256, + CRYPTO_SHASH_CMACAES, + CRYPTO_SHASH_SHA256, + CRYPTO_SHASH_SHA512, + CRYPTO_SHASH_MD4, + CRYPTO_SHASH_MD5, + CRYPTO_SHASH_MAX, +}; + +enum { + CRYPTO_AEAD_AES_GCM = 16, + CRYPTO_AEAD_AES_CCM, + CRYPTO_AEAD_MAX, +}; + +enum { + CRYPTO_BLK_ECBDES = 32, + CRYPTO_BLK_MAX, +}; + +struct ksmbd_crypto_ctx { + struct list_head list; + + struct shash_desc *desc[CRYPTO_SHASH_MAX]; + struct crypto_aead *ccmaes[CRYPTO_AEAD_MAX]; +}; + +#define CRYPTO_HMACMD5(c) ((c)->desc[CRYPTO_SHASH_HMACMD5]) +#define CRYPTO_HMACSHA256(c) ((c)->desc[CRYPTO_SHASH_HMACSHA256]) +#define CRYPTO_CMACAES(c) ((c)->desc[CRYPTO_SHASH_CMACAES]) +#define CRYPTO_SHA256(c) ((c)->desc[CRYPTO_SHASH_SHA256]) +#define CRYPTO_SHA512(c) ((c)->desc[CRYPTO_SHASH_SHA512]) +#define CRYPTO_MD4(c) ((c)->desc[CRYPTO_SHASH_MD4]) +#define CRYPTO_MD5(c) ((c)->desc[CRYPTO_SHASH_MD5]) + +#define CRYPTO_HMACMD5_TFM(c) ((c)->desc[CRYPTO_SHASH_HMACMD5]->tfm) +#define CRYPTO_HMACSHA256_TFM(c)\ + ((c)->desc[CRYPTO_SHASH_HMACSHA256]->tfm) +#define CRYPTO_CMACAES_TFM(c) ((c)->desc[CRYPTO_SHASH_CMACAES]->tfm) +#define CRYPTO_SHA256_TFM(c) ((c)->desc[CRYPTO_SHASH_SHA256]->tfm) +#define CRYPTO_SHA512_TFM(c) ((c)->desc[CRYPTO_SHASH_SHA512]->tfm) +#define CRYPTO_MD4_TFM(c) ((c)->desc[CRYPTO_SHASH_MD4]->tfm) +#define CRYPTO_MD5_TFM(c) ((c)->desc[CRYPTO_SHASH_MD5]->tfm) + +#define CRYPTO_GCM(c) ((c)->ccmaes[CRYPTO_AEAD_AES_GCM]) +#define CRYPTO_CCM(c) ((c)->ccmaes[CRYPTO_AEAD_AES_CCM]) + +void ksmbd_release_crypto_ctx(struct ksmbd_crypto_ctx *ctx); + +struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_hmacmd5(void); +struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_hmacsha256(void); +struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_cmacaes(void); +struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_sha512(void); +struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_sha256(void); +struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_md4(void); +struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_md5(void); + +struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_gcm(void); +struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_ccm(void); + +void ksmbd_crypto_destroy(void); +int ksmbd_crypto_create(void); + +#endif /* __CRYPTO_CTX_H__ */ diff --git a/fs/cifsd/ntlmssp.h b/fs/cifsd/ntlmssp.h new file mode 100644 index 000000000000..adaf4c0cbe8f --- /dev/null +++ b/fs/cifsd/ntlmssp.h @@ -0,0 +1,169 @@ +/* SPDX-License-Identifier: LGPL-2.1+ */ +/* + * Copyright (c) International Business Machines Corp., 2002,2007 + * Author(s): Steve French (sfrench@us.ibm.com) + */ + +#ifndef __KSMBD_NTLMSSP_H +#define __KSMBD_NTLMSSP_H + +#define NTLMSSP_SIGNATURE "NTLMSSP" + +/* Security blob target info data */ +#define TGT_Name "KSMBD" + +/* + * Size of the crypto key returned on the negotiate SMB in bytes + */ +#define CIFS_CRYPTO_KEY_SIZE (8) +#define CIFS_KEY_SIZE (40) + +/* + * Size of encrypted user password in bytes + */ +#define CIFS_ENCPWD_SIZE (16) +#define CIFS_CPHTXT_SIZE (16) + +/* Message Types */ +#define NtLmNegotiate cpu_to_le32(1) +#define NtLmChallenge cpu_to_le32(2) +#define NtLmAuthenticate cpu_to_le32(3) +#define UnknownMessage cpu_to_le32(8) + +/* Negotiate Flags */ +#define NTLMSSP_NEGOTIATE_UNICODE 0x01 /* Text strings are unicode */ +#define NTLMSSP_NEGOTIATE_OEM 0x02 /* Text strings are in OEM */ +#define NTLMSSP_REQUEST_TARGET 0x04 /* Srv returns its auth realm */ +/* define reserved9 0x08 */ +#define NTLMSSP_NEGOTIATE_SIGN 0x0010 /* Request signing capability */ +#define NTLMSSP_NEGOTIATE_SEAL 0x0020 /* Request confidentiality */ +#define NTLMSSP_NEGOTIATE_DGRAM 0x0040 +#define NTLMSSP_NEGOTIATE_LM_KEY 0x0080 /* Use LM session key */ +/* defined reserved 8 0x0100 */ +#define NTLMSSP_NEGOTIATE_NTLM 0x0200 /* NTLM authentication */ +#define NTLMSSP_NEGOTIATE_NT_ONLY 0x0400 /* Lanman not allowed */ +#define NTLMSSP_ANONYMOUS 0x0800 +#define NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED 0x1000 /* reserved6 */ +#define NTLMSSP_NEGOTIATE_WORKSTATION_SUPPLIED 0x2000 +#define NTLMSSP_NEGOTIATE_LOCAL_CALL 0x4000 /* client/server same machine */ +#define NTLMSSP_NEGOTIATE_ALWAYS_SIGN 0x8000 /* Sign. All security levels */ +#define NTLMSSP_TARGET_TYPE_DOMAIN 0x10000 +#define NTLMSSP_TARGET_TYPE_SERVER 0x20000 +#define NTLMSSP_TARGET_TYPE_SHARE 0x40000 +#define NTLMSSP_NEGOTIATE_EXTENDED_SEC 0x80000 /* NB:not related to NTLMv2 pwd*/ +/* #define NTLMSSP_REQUEST_INIT_RESP 0x100000 */ +#define NTLMSSP_NEGOTIATE_IDENTIFY 0x100000 +#define NTLMSSP_REQUEST_ACCEPT_RESP 0x200000 /* reserved5 */ +#define NTLMSSP_REQUEST_NON_NT_KEY 0x400000 +#define NTLMSSP_NEGOTIATE_TARGET_INFO 0x800000 +/* #define reserved4 0x1000000 */ +#define NTLMSSP_NEGOTIATE_VERSION 0x2000000 /* we do not set */ +/* #define reserved3 0x4000000 */ +/* #define reserved2 0x8000000 */ +/* #define reserved1 0x10000000 */ +#define NTLMSSP_NEGOTIATE_128 0x20000000 +#define NTLMSSP_NEGOTIATE_KEY_XCH 0x40000000 +#define NTLMSSP_NEGOTIATE_56 0x80000000 + +/* Define AV Pair Field IDs */ +enum av_field_type { + NTLMSSP_AV_EOL = 0, + NTLMSSP_AV_NB_COMPUTER_NAME, + NTLMSSP_AV_NB_DOMAIN_NAME, + NTLMSSP_AV_DNS_COMPUTER_NAME, + NTLMSSP_AV_DNS_DOMAIN_NAME, + NTLMSSP_AV_DNS_TREE_NAME, + NTLMSSP_AV_FLAGS, + NTLMSSP_AV_TIMESTAMP, + NTLMSSP_AV_RESTRICTION, + NTLMSSP_AV_TARGET_NAME, + NTLMSSP_AV_CHANNEL_BINDINGS +}; + +/* Although typedefs are not commonly used for structure definitions */ +/* in the Linux kernel, in this particular case they are useful */ +/* to more closely match the standards document for NTLMSSP from */ +/* OpenGroup and to make the code more closely match the standard in */ +/* appearance */ + +struct security_buffer { + __le16 Length; + __le16 MaximumLength; + __le32 BufferOffset; /* offset to buffer */ +} __packed; + +struct target_info { + __le16 Type; + __le16 Length; + __u8 Content[0]; +} __packed; + +struct negotiate_message { + __u8 Signature[sizeof(NTLMSSP_SIGNATURE)]; + __le32 MessageType; /* NtLmNegotiate = 1 */ + __le32 NegotiateFlags; + struct security_buffer DomainName; /* RFC 1001 style and ASCII */ + struct security_buffer WorkstationName; /* RFC 1001 and ASCII */ + /* + * struct security_buffer for version info not present since we + * do not set the version is present flag + */ + char DomainString[0]; + /* followed by WorkstationString */ +} __packed; + +struct challenge_message { + __u8 Signature[sizeof(NTLMSSP_SIGNATURE)]; + __le32 MessageType; /* NtLmChallenge = 2 */ + struct security_buffer TargetName; + __le32 NegotiateFlags; + __u8 Challenge[CIFS_CRYPTO_KEY_SIZE]; + __u8 Reserved[8]; + struct security_buffer TargetInfoArray; + /* + * struct security_buffer for version info not present since we + * do not set the version is present flag + */ +} __packed; + +struct authenticate_message { + __u8 Signature[sizeof(NTLMSSP_SIGNATURE)]; + __le32 MessageType; /* NtLmsAuthenticate = 3 */ + struct security_buffer LmChallengeResponse; + struct security_buffer NtChallengeResponse; + struct security_buffer DomainName; + struct security_buffer UserName; + struct security_buffer WorkstationName; + struct security_buffer SessionKey; + __le32 NegotiateFlags; + /* + * struct security_buffer for version info not present since we + * do not set the version is present flag + */ + char UserString[0]; +} __packed; + +struct ntlmv2_resp { + char ntlmv2_hash[CIFS_ENCPWD_SIZE]; + __le32 blob_signature; + __u32 reserved; + __le64 time; + __u64 client_chal; /* random */ + __u32 reserved2; + /* array of name entries could follow ending in minimum 4 byte struct */ +} __packed; + +/* per smb session structure/fields */ +struct ntlmssp_auth { + /* whether session key is per smb session */ + bool sesskey_per_smbsess; + /* sent by client in type 1 ntlmsssp exchange */ + __u32 client_flags; + /* sent by server in type 2 ntlmssp exchange */ + __u32 conn_flags; + /* sent to server */ + unsigned char ciphertext[CIFS_CPHTXT_SIZE]; + /* used by ntlmssp */ + char cryptkey[CIFS_CRYPTO_KEY_SIZE]; +}; +#endif /* __KSMBD_NTLMSSP_H */ diff --git a/fs/cifsd/spnego_negtokeninit.asn1 b/fs/cifsd/spnego_negtokeninit.asn1 new file mode 100644 index 000000000000..1b153cb6a39e --- /dev/null +++ b/fs/cifsd/spnego_negtokeninit.asn1 @@ -0,0 +1,43 @@ +GSSAPI ::= + [APPLICATION 0] IMPLICIT SEQUENCE { + thisMech + OBJECT IDENTIFIER ({gssapi_this_mech}), + negotiationToken + NegotiationToken + } + +MechType ::= OBJECT IDENTIFIER ({neg_token_init_mech_type}) + +MechTypeList ::= SEQUENCE OF MechType + +NegTokenInit ::= + SEQUENCE { + mechTypes + [0] MechTypeList, + reqFlags + [1] BIT STRING OPTIONAL, + mechToken + [2] OCTET STRING OPTIONAL ({neg_token_init_mech_token}), + mechListMIC + [3] OCTET STRING OPTIONAL + } + +NegTokenTarg ::= + SEQUENCE { + negResult + [0] ENUMERATED OPTIONAL, + supportedMech + [1] OBJECT IDENTIFIER OPTIONAL, + responseToken + [2] OCTET STRING OPTIONAL ({neg_token_targ_resp_token}), + mechListMIC + [3] OCTET STRING OPTIONAL + } + +NegotiationToken ::= + CHOICE { + negTokenInit + [0] NegTokenInit, + negTokenTarg + [1] ANY + } diff --git a/fs/cifsd/spnego_negtokentarg.asn1 b/fs/cifsd/spnego_negtokentarg.asn1 new file mode 100644 index 000000000000..8324bcd1bbd7 --- /dev/null +++ b/fs/cifsd/spnego_negtokentarg.asn1 @@ -0,0 +1,19 @@ +GSSAPI ::= + CHOICE { + negTokenInit + [0] ANY, + negTokenTarg + [1] NegTokenTarg + } + +NegTokenTarg ::= + SEQUENCE { + negResult + [0] ENUMERATED OPTIONAL, + supportedMech + [1] OBJECT IDENTIFIER OPTIONAL, + responseToken + [2] OCTET STRING OPTIONAL ({neg_token_targ_resp_token}), + mechListMIC + [3] OCTET STRING OPTIONAL + } -- 2.17.1 ^ permalink raw reply related [flat|nested] 11+ messages in thread
* Re: [PATCH v3 04/10] cifsd: add authentication 2021-05-21 6:26 ` [PATCH v3 04/10] cifsd: add authentication Namjae Jeon @ 2021-05-21 10:31 ` Dan Carpenter 2021-05-22 1:00 ` [Linux-cifsd-devel] " Namjae Jeon 0 siblings, 1 reply; 11+ messages in thread From: Dan Carpenter @ 2021-05-21 10:31 UTC (permalink / raw) To: Namjae Jeon Cc: linux-fsdevel, linux-kernel, linux-cifs, linux-cifsd-devel, smfrench, senozhatsky, hyc.lee, viro, hch, hch, ronniesahlberg, aurelien.aptel, aaptel, sandeen, willy, Sergey Senozhatsky, Steve French Didn't someone complain that we already had enough asn1 code in lib and shouldn't add this in the subsystem dir? Mostly trivial stuff. It's still not checkpatch --strict clean. I only noticed the "CHECK: Alignment should match open parenthesis" while reviewing so the rest of the warnings are apparently something I don't care about. ;) The reason why I really like the alignment to be match the open parenthesis is because then it doesn't line up with the code. Generally, I want the success patch indented one tab and the failure path indented two tabs. > + rc = generate_key(sess, signing->label, signing->context, key, > + SMB3_SIGN_KEY_SIZE); Here the SMB3_SIGN_KEY_SIZE is aligned at two tabs. It slightly slows me down when I see code like that which isn't aligned where I expect it. It's the same for if statements and four statements, if you align it with the open parenthesis then it's easy to see what is part of the condition and what is inside because they are indented differently. Bad: if (condition && condition2) frob(); Good: if (condition && condition2) frob(); I noticed a couple error code bugs where we return 1 on failure like in ksmbd_auth_ntlmv2(). Some buffer overflows with smb_strtoUTF16() and UNICODE_LEN(). On Fri, May 21, 2021 at 03:26:31PM +0900, Namjae Jeon wrote: > This adds NTLM/NTLMv2/Kerberos authentications and signing/encryption. > > Signed-off-by: Namjae Jeon <namjae.jeon@samsung.com> > Signed-off-by: Sergey Senozhatsky <sergey.senozhatsky@gmail.com> > Signed-off-by: Hyunchul Lee <hyc.lee@gmail.com> > Acked-by: Ronnie Sahlberg <lsahlber@redhat.com> > Signed-off-by: Steve French <stfrench@microsoft.com> > --- > fs/cifsd/asn1.c | 352 ++++++++ > fs/cifsd/asn1.h | 29 + > fs/cifsd/auth.c | 1344 +++++++++++++++++++++++++++++ > fs/cifsd/auth.h | 90 ++ > fs/cifsd/crypto_ctx.c | 286 ++++++ > fs/cifsd/crypto_ctx.h | 77 ++ > fs/cifsd/ntlmssp.h | 169 ++++ > fs/cifsd/spnego_negtokeninit.asn1 | 43 + > fs/cifsd/spnego_negtokentarg.asn1 | 19 + > 9 files changed, 2409 insertions(+) > create mode 100644 fs/cifsd/asn1.c > create mode 100644 fs/cifsd/asn1.h > create mode 100644 fs/cifsd/auth.c > create mode 100644 fs/cifsd/auth.h > create mode 100644 fs/cifsd/crypto_ctx.c > create mode 100644 fs/cifsd/crypto_ctx.h > create mode 100644 fs/cifsd/ntlmssp.h > create mode 100644 fs/cifsd/spnego_negtokeninit.asn1 > create mode 100644 fs/cifsd/spnego_negtokentarg.asn1 > > diff --git a/fs/cifsd/asn1.c b/fs/cifsd/asn1.c > new file mode 100644 > index 000000000000..aa6ea855c422 > --- /dev/null > +++ b/fs/cifsd/asn1.c > @@ -0,0 +1,352 @@ > +// SPDX-License-Identifier: GPL-2.0-or-later > +/* > + * The ASB.1/BER parsing code is derived from ip_nat_snmp_basic.c which was in > + * turn derived from the gxsnmp package by Gregory McLean & Jochen Friedrich > + * > + * Copyright (c) 2000 RP Internet (http://www.rpi.net.au ). > + */ > + > +#include <linux/module.h> > +#include <linux/types.h> > +#include <linux/kernel.h> > +#include <linux/mm.h> > +#include <linux/slab.h> > +#include <linux/oid_registry.h> > + > +#include "glob.h" > + > +#include "asn1.h" > +#include "connection.h" > +#include "auth.h" > +#include "spnego_negtokeninit.asn1.h" > +#include "spnego_negtokentarg.asn1.h" > + > +#define SPNEGO_OID_LEN 7 > +#define NTLMSSP_OID_LEN 10 > +#define KRB5_OID_LEN 7 > +#define KRB5U2U_OID_LEN 8 > +#define MSKRB5_OID_LEN 7 > +static unsigned long SPNEGO_OID[7] = { 1, 3, 6, 1, 5, 5, 2 }; > +static unsigned long NTLMSSP_OID[10] = { 1, 3, 6, 1, 4, 1, 311, 2, 2, 10 }; > +static unsigned long KRB5_OID[7] = { 1, 2, 840, 113554, 1, 2, 2 }; > +static unsigned long KRB5U2U_OID[8] = { 1, 2, 840, 113554, 1, 2, 2, 3 }; > +static unsigned long MSKRB5_OID[7] = { 1, 2, 840, 48018, 1, 2, 2 }; > + > +static char NTLMSSP_OID_STR[NTLMSSP_OID_LEN] = { 0x2b, 0x06, 0x01, 0x04, 0x01, > + 0x82, 0x37, 0x02, 0x02, 0x0a }; > + > +static bool > +asn1_subid_decode(const unsigned char **begin, const unsigned char *end, > + unsigned long *subid) > +{ > + const unsigned char *ptr = *begin; > + unsigned char ch; > + > + *subid = 0; > + > + do { > + if (ptr >= end) > + return false; > + > + ch = *ptr++; > + *subid <<= 7; > + *subid |= ch & 0x7F; > + } while ((ch & 0x80) == 0x80); > + > + *begin = ptr; > + return true; > +} > + > +static bool asn1_oid_decode(const unsigned char *value, size_t vlen, > + unsigned long **oid, size_t *oidlen) > +{ > + const unsigned char *iptr = value, *end = value + vlen; > + unsigned long *optr; > + unsigned long subid; > + > + vlen += 1; > + if (vlen < 2 || vlen > UINT_MAX/sizeof(unsigned long)) > + return false; > + > + *oid = kmalloc(vlen * sizeof(unsigned long), GFP_KERNEL); > + if (!*oid) > + return false; > + > + optr = *oid; > + > + if (!asn1_subid_decode(&iptr, end, &subid)) { > + kfree(*oid); > + *oid = NULL; > + return false; > + } Make this goto fail; > + > + if (subid < 40) { > + optr[0] = 0; > + optr[1] = subid; > + } else if (subid < 80) { > + optr[0] = 1; > + optr[1] = subid - 40; > + } else { > + optr[0] = 2; > + optr[1] = subid - 80; > + } > + > + *oidlen = 2; > + optr += 2; > + > + while (iptr < end) { > + if (++(*oidlen) > vlen) { > + kfree(*oid); > + *oid = NULL; > + return false; goto fail; > + } > + > + if (!asn1_subid_decode(&iptr, end, optr++)) { > + kfree(*oid); > + *oid = NULL; > + return false; goto fail; > + } > + } > + return true; fail: kfree(*oid); *oid = NULL; return false; > +} > + > +static bool > +oid_eq(unsigned long *oid1, unsigned int oid1len, > + unsigned long *oid2, unsigned int oid2len) > +{ > + unsigned int i; > + > + if (oid1len != oid2len) > + return false; > + > + for (i = 0; i < oid1len; i++) { > + if (oid1[i] != oid2[i]) > + return false; > + } return memcmp(oid1, oid2, oid1len) == 0; > + return true; > +} > + > +int > +ksmbd_decode_negTokenInit(unsigned char *security_blob, int length, > + struct ksmbd_conn *conn) > +{ > + return asn1_ber_decoder(&spnego_negtokeninit_decoder, conn, > + security_blob, length); > +} > + > +int > +ksmbd_decode_negTokenTarg(unsigned char *security_blob, int length, > + struct ksmbd_conn *conn) > +{ > + return asn1_ber_decoder(&spnego_negtokentarg_decoder, conn, > + security_blob, length); > +} > + > +static int compute_asn_hdr_len_bytes(int len) > +{ > + if (len > 0xFFFFFF) > + return 4; > + else if (len > 0xFFFF) > + return 3; > + else if (len > 0xFF) > + return 2; > + else if (len > 0x7F) > + return 1; > + else > + return 0; > +} > + > +static void encode_asn_tag(char *buf, > + unsigned int *ofs, > + char tag, > + char seq, > + int length) > +{ > + int i; > + int index = *ofs; > + char hdr_len = compute_asn_hdr_len_bytes(length); > + int len = length + 2 + hdr_len; > + > + /* insert tag */ > + buf[index++] = tag; > + > + if (!hdr_len) > + buf[index++] = len; > + else { > + buf[index++] = 0x80 | hdr_len; > + for (i = hdr_len - 1; i >= 0; i--) > + buf[index++] = (len >> (i * 8)) & 0xFF; > + } > + > + /* insert seq */ > + len = len - (index - *ofs); > + buf[index++] = seq; > + > + if (!hdr_len) > + buf[index++] = len; > + else { > + buf[index++] = 0x80 | hdr_len; > + for (i = hdr_len - 1; i >= 0; i--) > + buf[index++] = (len >> (i * 8)) & 0xFF; > + } > + > + *ofs += (index - *ofs); > +} > + > +int build_spnego_ntlmssp_neg_blob(unsigned char **pbuffer, u16 *buflen, > + char *ntlm_blob, int ntlm_blob_len) > +{ > + char *buf; > + unsigned int ofs = 0; > + int neg_result_len = 4 + compute_asn_hdr_len_bytes(1) * 2 + 1; > + int oid_len = 4 + compute_asn_hdr_len_bytes(NTLMSSP_OID_LEN) * 2 + > + NTLMSSP_OID_LEN; > + int ntlmssp_len = 4 + compute_asn_hdr_len_bytes(ntlm_blob_len) * 2 + > + ntlm_blob_len; > + int total_len = 4 + compute_asn_hdr_len_bytes(neg_result_len + > + oid_len + ntlmssp_len) * 2 + > + neg_result_len + oid_len + ntlmssp_len; > + > + buf = kmalloc(total_len, GFP_KERNEL); > + if (!buf) > + return -ENOMEM; > + > + /* insert main gss header */ > + encode_asn_tag(buf, &ofs, 0xa1, 0x30, neg_result_len + oid_len + > + ntlmssp_len); > + > + /* insert neg result */ > + encode_asn_tag(buf, &ofs, 0xa0, 0x0a, 1); > + buf[ofs++] = 1; > + > + /* insert oid */ > + encode_asn_tag(buf, &ofs, 0xa1, 0x06, NTLMSSP_OID_LEN); > + memcpy(buf + ofs, NTLMSSP_OID_STR, NTLMSSP_OID_LEN); > + ofs += NTLMSSP_OID_LEN; > + > + /* insert response token - ntlmssp blob */ > + encode_asn_tag(buf, &ofs, 0xa2, 0x04, ntlm_blob_len); > + memcpy(buf + ofs, ntlm_blob, ntlm_blob_len); > + ofs += ntlm_blob_len; > + > + *pbuffer = buf; > + *buflen = total_len; > + return 0; > +} > + > +int build_spnego_ntlmssp_auth_blob(unsigned char **pbuffer, u16 *buflen, > + int neg_result) > +{ > + char *buf; > + unsigned int ofs = 0; > + int neg_result_len = 4 + compute_asn_hdr_len_bytes(1) * 2 + 1; > + int total_len = 4 + compute_asn_hdr_len_bytes(neg_result_len) * 2 + > + neg_result_len; > + > + buf = kmalloc(total_len, GFP_KERNEL); > + if (!buf) > + return -ENOMEM; > + > + /* insert main gss header */ > + encode_asn_tag(buf, &ofs, 0xa1, 0x30, neg_result_len); > + > + /* insert neg result */ > + encode_asn_tag(buf, &ofs, 0xa0, 0x0a, 1); > + if (neg_result) > + buf[ofs++] = 2; > + else > + buf[ofs++] = 0; > + > + *pbuffer = buf; > + *buflen = total_len; > + return 0; > +} > + > +int gssapi_this_mech(void *context, size_t hdrlen, > + unsigned char tag, const void *value, size_t vlen) > +{ > + unsigned long *oid; > + size_t oidlen; > + int err = 0; > + > + if (!asn1_oid_decode(value, vlen, &oid, &oidlen)) { > + err = -EBADMSG; > + goto out; > + } > + > + if (!oid_eq(oid, oidlen, SPNEGO_OID, SPNEGO_OID_LEN)) > + err = -EBADMSG; > + kfree(oid); > +out: > + if (err) { > + char buf[50]; > + > + sprint_oid(value, vlen, buf, sizeof(buf)); > + ksmbd_debug(AUTH, "Unexpected OID: %s\n", buf); > + } > + return err; > +} > + > +int neg_token_init_mech_type(void *context, size_t hdrlen, > + unsigned char tag, const void *value, size_t vlen) > +{ > + struct ksmbd_conn *conn = context; > + unsigned long *oid; > + size_t oidlen; > + int mech_type; > + > + if (!asn1_oid_decode(value, vlen, &oid, &oidlen)) { > + char buf[50]; > + > + sprint_oid(value, vlen, buf, sizeof(buf)); > + ksmbd_debug(AUTH, "Unexpected OID: %s\n", buf); > + return -EBADMSG; > + } > + > + if (oid_eq(oid, oidlen, NTLMSSP_OID, NTLMSSP_OID_LEN)) > + mech_type = KSMBD_AUTH_NTLMSSP; > + else if (oid_eq(oid, oidlen, MSKRB5_OID, MSKRB5_OID_LEN)) > + mech_type = KSMBD_AUTH_MSKRB5; > + else if (oid_eq(oid, oidlen, KRB5_OID, KRB5_OID_LEN)) > + mech_type = KSMBD_AUTH_KRB5; > + else if (oid_eq(oid, oidlen, KRB5U2U_OID, KRB5U2U_OID_LEN)) > + mech_type = KSMBD_AUTH_KRB5U2U; > + else > + goto out; Should this be an error path? > + > + conn->auth_mechs |= mech_type; > + if (conn->preferred_auth_mech == 0) > + conn->preferred_auth_mech = mech_type; > + > +out: > + kfree(oid); > + return 0; > +} > + > +int neg_token_init_mech_token(void *context, size_t hdrlen, > + unsigned char tag, const void *value, size_t vlen) > +{ > + struct ksmbd_conn *conn = context; > + > + conn->mechToken = kmalloc(vlen + 1, GFP_KERNEL); > + if (!conn->mechToken) > + return -ENOMEM; > + > + memcpy(conn->mechToken, value, vlen); > + conn->mechToken[vlen] = '\0'; > + return 0; > +} > + > +int neg_token_targ_resp_token(void *context, size_t hdrlen, > + unsigned char tag, const void *value, size_t vlen) > +{ > + struct ksmbd_conn *conn = context; > + > + conn->mechToken = kmalloc(vlen + 1, GFP_KERNEL); > + if (!conn->mechToken) > + return -ENOMEM; > + > + memcpy(conn->mechToken, value, vlen); > + conn->mechToken[vlen] = '\0'; > + return 0; > +} > diff --git a/fs/cifsd/asn1.h b/fs/cifsd/asn1.h > new file mode 100644 > index 000000000000..ff2692b502d6 > --- /dev/null > +++ b/fs/cifsd/asn1.h > @@ -0,0 +1,29 @@ > +/* SPDX-License-Identifier: GPL-2.0-or-later */ > +/* > + * The ASB.1/BER parsing code is derived from ip_nat_snmp_basic.c which was in > + * turn derived from the gxsnmp package by Gregory McLean & Jochen Friedrich > + * > + * Copyright (c) 2000 RP Internet (http://www.rpi.net.au ). > + * Copyright (C) 2018 Samsung Electronics Co., Ltd. > + */ > + > +#ifndef __ASN1_H__ > +#define __ASN1_H__ > + > +int ksmbd_decode_negTokenInit(unsigned char *security_blob, > + int length, > + struct ksmbd_conn *conn); > + > +int ksmbd_decode_negTokenTarg(unsigned char *security_blob, > + int length, > + struct ksmbd_conn *conn); > + > +int build_spnego_ntlmssp_neg_blob(unsigned char **pbuffer, > + u16 *buflen, > + char *ntlm_blob, > + int ntlm_blob_len); > + > +int build_spnego_ntlmssp_auth_blob(unsigned char **pbuffer, > + u16 *buflen, > + int neg_result); > +#endif /* __ASN1_H__ */ > diff --git a/fs/cifsd/auth.c b/fs/cifsd/auth.c > new file mode 100644 > index 000000000000..6b90aac86fcc > --- /dev/null > +++ b/fs/cifsd/auth.c > @@ -0,0 +1,1344 @@ > +// 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/kernel.h> > +#include <linux/fs.h> > +#include <linux/uaccess.h> > +#include <linux/backing-dev.h> > +#include <linux/writeback.h> > +#include <linux/uio.h> > +#include <linux/xattr.h> > +#include <crypto/hash.h> > +#include <crypto/aead.h> > +#include <linux/random.h> > +#include <linux/scatterlist.h> > + > +#include "auth.h" > +#include "glob.h" > + > +#include <linux/fips.h> > +#include <crypto/des.h> > + > +#include "server.h" > +#include "smb_common.h" > +#include "connection.h" > +#include "mgmt/user_session.h" > +#include "mgmt/user_config.h" > +#include "crypto_ctx.h" > +#include "transport_ipc.h" > +#include "buffer_pool.h" > + > +/* > + * Fixed format data defining GSS header and fixed string > + * "not_defined_in_RFC4178@please_ignore". > + * So sec blob data in neg phase could be generated statically. > + */ > +static char NEGOTIATE_GSS_HEADER[AUTH_GSS_LENGTH] = { > +#ifdef CONFIG_SMB_SERVER_KERBEROS5 > + 0x60, 0x5e, 0x06, 0x06, 0x2b, 0x06, 0x01, 0x05, > + 0x05, 0x02, 0xa0, 0x54, 0x30, 0x52, 0xa0, 0x24, > + 0x30, 0x22, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, > + 0xf7, 0x12, 0x01, 0x02, 0x02, 0x06, 0x09, 0x2a, > + 0x86, 0x48, 0x82, 0xf7, 0x12, 0x01, 0x02, 0x02, > + 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, > + 0x37, 0x02, 0x02, 0x0a, 0xa3, 0x2a, 0x30, 0x28, > + 0xa0, 0x26, 0x1b, 0x24, 0x6e, 0x6f, 0x74, 0x5f, > + 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x5f, > + 0x69, 0x6e, 0x5f, 0x52, 0x46, 0x43, 0x34, 0x31, > + 0x37, 0x38, 0x40, 0x70, 0x6c, 0x65, 0x61, 0x73, > + 0x65, 0x5f, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65 > +#else > + 0x60, 0x48, 0x06, 0x06, 0x2b, 0x06, 0x01, 0x05, > + 0x05, 0x02, 0xa0, 0x3e, 0x30, 0x3c, 0xa0, 0x0e, > + 0x30, 0x0c, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, > + 0x01, 0x82, 0x37, 0x02, 0x02, 0x0a, 0xa3, 0x2a, > + 0x30, 0x28, 0xa0, 0x26, 0x1b, 0x24, 0x6e, 0x6f, > + 0x74, 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, > + 0x64, 0x5f, 0x69, 0x6e, 0x5f, 0x52, 0x46, 0x43, > + 0x34, 0x31, 0x37, 0x38, 0x40, 0x70, 0x6c, 0x65, > + 0x61, 0x73, 0x65, 0x5f, 0x69, 0x67, 0x6e, 0x6f, > + 0x72, 0x65 > +#endif > +}; > + > +void ksmbd_copy_gss_neg_header(void *buf) > +{ > + memcpy(buf, NEGOTIATE_GSS_HEADER, AUTH_GSS_LENGTH); > +} > + > +static void > +str_to_key(unsigned char *str, unsigned char *key) > +{ > + int i; > + > + key[0] = str[0] >> 1; > + key[1] = ((str[0] & 0x01) << 6) | (str[1] >> 2); > + key[2] = ((str[1] & 0x03) << 5) | (str[2] >> 3); > + key[3] = ((str[2] & 0x07) << 4) | (str[3] >> 4); > + key[4] = ((str[3] & 0x0F) << 3) | (str[4] >> 5); > + key[5] = ((str[4] & 0x1F) << 2) | (str[5] >> 6); > + key[6] = ((str[5] & 0x3F) << 1) | (str[6] >> 7); > + key[7] = str[6] & 0x7F; > + for (i = 0; i < 8; i++) > + key[i] = (key[i] << 1); > +} > + > +static int > +smbhash(unsigned char *out, const unsigned char *in, unsigned char *key) > +{ > + unsigned char key2[8]; > + struct des_ctx ctx; > + > + str_to_key(key, key2); > + > + if (fips_enabled) { > + ksmbd_debug(AUTH, > + "FIPS compliance enabled: DES not permitted\n"); > + return -ENOENT; > + } Move this check before the str_to_key(). > + > + des_expand_key(&ctx, key2, DES_KEY_SIZE); > + des_encrypt(&ctx, out, in); > + memzero_explicit(&ctx, sizeof(ctx)); > + return 0; > +} > + > +static int ksmbd_enc_p24(unsigned char *p21, const unsigned char *c8, unsigned char *p24) > +{ > + int rc; > + > + rc = smbhash(p24, c8, p21); > + if (rc) > + return rc; > + rc = smbhash(p24 + 8, c8, p21 + 7); > + if (rc) > + return rc; > + rc = smbhash(p24 + 16, c8, p21 + 14); > + return rc; return smbhash(p24 + 16, c8, p21 + 14); > +} > + > +/* produce a md4 message digest from data of length n bytes */ > +static int ksmbd_enc_md4(unsigned char *md4_hash, unsigned char *link_str, > + int link_len) > +{ > + int rc; > + struct ksmbd_crypto_ctx *ctx; > + > + ctx = ksmbd_crypto_ctx_find_md4(); > + if (!ctx) { > + ksmbd_debug(AUTH, "Crypto md4 allocation error\n"); > + return -EINVAL; It feels like "allocation error" is misleading. Or maybe return -ENOMEM? It's done consistently for all the ksmbd_crypto_ctx_find_ calls, though... > + } > + > + rc = crypto_shash_init(CRYPTO_MD4(ctx)); > + if (rc) { > + ksmbd_debug(AUTH, "Could not init md4 shash\n"); > + goto out; > + } > + > + rc = crypto_shash_update(CRYPTO_MD4(ctx), link_str, link_len); > + if (rc) { > + ksmbd_debug(AUTH, "Could not update with link_str\n"); > + goto out; > + } > + > + rc = crypto_shash_final(CRYPTO_MD4(ctx), md4_hash); > + if (rc) > + ksmbd_debug(AUTH, "Could not generate md4 hash\n"); > +out: > + ksmbd_release_crypto_ctx(ctx); > + return rc; > +} > + > +static int ksmbd_enc_update_sess_key(unsigned char *md5_hash, char *nonce, > + char *server_challenge, int len) > +{ > + int rc; > + struct ksmbd_crypto_ctx *ctx; > + > + ctx = ksmbd_crypto_ctx_find_md5(); > + if (!ctx) { > + ksmbd_debug(AUTH, "Crypto md5 allocation error\n"); > + return -EINVAL; > + } > + > + rc = crypto_shash_init(CRYPTO_MD5(ctx)); > + if (rc) { > + ksmbd_debug(AUTH, "Could not init md5 shash\n"); > + goto out; > + } > + > + rc = crypto_shash_update(CRYPTO_MD5(ctx), server_challenge, len); > + if (rc) { > + ksmbd_debug(AUTH, "Could not update with challenge\n"); > + goto out; > + } > + > + rc = crypto_shash_update(CRYPTO_MD5(ctx), nonce, len); > + if (rc) { > + ksmbd_debug(AUTH, "Could not update with nonce\n"); > + goto out; > + } > + > + rc = crypto_shash_final(CRYPTO_MD5(ctx), md5_hash); > + if (rc) > + ksmbd_debug(AUTH, "Could not generate md5 hash\n"); > +out: > + ksmbd_release_crypto_ctx(ctx); > + return rc; > +} > + > +/** > + * ksmbd_gen_sess_key() - function to generate session key > + * @sess: session of connection > + * @hash: source hash value to be used for find session key > + * @hmac: source hmac value to be used for finding session key > + * > + */ > +static int ksmbd_gen_sess_key(struct ksmbd_session *sess, char *hash, > + char *hmac) > +{ > + struct ksmbd_crypto_ctx *ctx; > + int rc = -EINVAL; > + > + ctx = ksmbd_crypto_ctx_find_hmacmd5(); > + if (!ctx) > + goto out; > + > + rc = crypto_shash_setkey(CRYPTO_HMACMD5_TFM(ctx), > + hash, > + CIFS_HMAC_MD5_HASH_SIZE); > + if (rc) { > + ksmbd_debug(AUTH, "hmacmd5 set key fail error %d\n", rc); > + goto out; > + } > + > + rc = crypto_shash_init(CRYPTO_HMACMD5(ctx)); > + if (rc) { > + ksmbd_debug(AUTH, "could not init hmacmd5 error %d\n", rc); > + goto out; > + } > + > + rc = crypto_shash_update(CRYPTO_HMACMD5(ctx), > + hmac, > + SMB2_NTLMV2_SESSKEY_SIZE); > + if (rc) { > + ksmbd_debug(AUTH, "Could not update with response error %d\n", > + rc); > + goto out; > + } > + > + rc = crypto_shash_final(CRYPTO_HMACMD5(ctx), sess->sess_key); > + if (rc) { > + ksmbd_debug(AUTH, "Could not generate hmacmd5 hash error %d\n", > + rc); > + goto out; > + } > + > +out: > + ksmbd_release_crypto_ctx(ctx); > + return rc; > +} > + > +static int calc_ntlmv2_hash(struct ksmbd_session *sess, char *ntlmv2_hash, > + char *dname) > +{ > + int ret = -EINVAL, len; > + wchar_t *domain = NULL; > + __le16 *uniname = NULL; > + struct ksmbd_crypto_ctx *ctx; > + > + ctx = ksmbd_crypto_ctx_find_hmacmd5(); > + if (!ctx) { > + ksmbd_debug(AUTH, "can't generate ntlmv2 hash\n"); > + goto out; > + } > + > + ret = crypto_shash_setkey(CRYPTO_HMACMD5_TFM(ctx), > + user_passkey(sess->user), > + CIFS_ENCPWD_SIZE); > + if (ret) { > + ksmbd_debug(AUTH, "Could not set NT Hash as a key\n"); > + goto out; > + } > + > + ret = crypto_shash_init(CRYPTO_HMACMD5(ctx)); > + if (ret) { > + ksmbd_debug(AUTH, "could not init hmacmd5\n"); > + goto out; > + } > + > + /* convert user_name to unicode */ > + len = strlen(user_name(sess->user)); > + uniname = kzalloc(2 + UNICODE_LEN(len), GFP_KERNEL); > + if (!uniname) { > + ret = -ENOMEM; > + goto out; > + } > + > + if (len) { > + len = smb_strtoUTF16(uniname, user_name(sess->user), len, > + sess->conn->local_nls); > + UniStrupr(uniname); > + } > + > + ret = crypto_shash_update(CRYPTO_HMACMD5(ctx), > + (char *)uniname, > + UNICODE_LEN(len)); len = smb_strtoUTF16() modifies len so UNICODE_LEN() multiplies it by two and leads to a read overflow. > + if (ret) { > + ksmbd_debug(AUTH, "Could not update with user\n"); > + goto out; > + } > + > + /* Convert domain name or conn name to unicode and uppercase */ > + len = strlen(dname); > + domain = kzalloc(2 + UNICODE_LEN(len), GFP_KERNEL); > + if (!domain) { > + ret = -ENOMEM; > + goto out; > + } > + > + len = smb_strtoUTF16((__le16 *)domain, dname, len, > + sess->conn->local_nls); > + > + ret = crypto_shash_update(CRYPTO_HMACMD5(ctx), > + (char *)domain, > + UNICODE_LEN(len)); The UNICODE_LEN() leads to a buffer overflow. > + if (ret) { > + ksmbd_debug(AUTH, "Could not update with domain\n"); > + goto out; > + } > + > + ret = crypto_shash_final(CRYPTO_HMACMD5(ctx), ntlmv2_hash); > +out: > + if (ret) > + ksmbd_debug(AUTH, "Could not generate md5 hash\n"); I think the if (ret) was intended to go before the out: label. > + kfree(uniname); > + kfree(domain); > + ksmbd_release_crypto_ctx(ctx); > + return ret; > +} > + > +/** > + * ksmbd_auth_ntlm() - NTLM authentication handler > + * @sess: session of connection > + * @pw_buf: NTLM challenge response > + * @passkey: user password > + * > + * Return: 0 on success, error number on error > + */ > +int ksmbd_auth_ntlm(struct ksmbd_session *sess, char *pw_buf) > +{ > + int rc; > + unsigned char p21[21]; > + char key[CIFS_AUTH_RESP_SIZE]; > + > + memset(p21, '\0', 21); > + memcpy(p21, user_passkey(sess->user), CIFS_NTHASH_SIZE); > + rc = ksmbd_enc_p24(p21, sess->ntlmssp.cryptkey, key); > + if (rc) { > + ksmbd_err("password processing failed\n"); > + return rc; > + } > + > + ksmbd_enc_md4(sess->sess_key, > + user_passkey(sess->user), > + CIFS_SMB1_SESSKEY_SIZE); > + memcpy(sess->sess_key + CIFS_SMB1_SESSKEY_SIZE, key, > + CIFS_AUTH_RESP_SIZE); > + sess->sequence_number = 1; > + > + if (strncmp(pw_buf, key, CIFS_AUTH_RESP_SIZE) != 0) { > + ksmbd_debug(AUTH, "ntlmv1 authentication failed\n"); > + rc = -EINVAL; return -EINVAL; > + } else { > + ksmbd_debug(AUTH, "ntlmv1 authentication pass\n"); Pull this in one tab. > + } > + > + return rc; return 0; > +} > + > +/** > + * ksmbd_auth_ntlmv2() - NTLMv2 authentication handler > + * @sess: session of connection > + * @ntlmv2: NTLMv2 challenge response > + * @blen: NTLMv2 blob length > + * @domain_name: domain name > + * > + * Return: 0 on success, error number on error > + */ > +int ksmbd_auth_ntlmv2(struct ksmbd_session *sess, struct ntlmv2_resp *ntlmv2, > + int blen, char *domain_name) > +{ > + char ntlmv2_hash[CIFS_ENCPWD_SIZE]; > + char ntlmv2_rsp[CIFS_HMAC_MD5_HASH_SIZE]; > + struct ksmbd_crypto_ctx *ctx; > + char *construct = NULL; > + int rc = -EINVAL, len; > + > + ctx = ksmbd_crypto_ctx_find_hmacmd5(); > + if (!ctx) { > + ksmbd_debug(AUTH, "could not crypto alloc hmacmd5 rc %d\n", rc); > + goto out; > + } > + > + rc = calc_ntlmv2_hash(sess, ntlmv2_hash, domain_name); > + if (rc) { > + ksmbd_debug(AUTH, "could not get v2 hash rc %d\n", rc); > + goto out; > + } > + > + rc = crypto_shash_setkey(CRYPTO_HMACMD5_TFM(ctx), > + ntlmv2_hash, > + CIFS_HMAC_MD5_HASH_SIZE); > + if (rc) { > + ksmbd_debug(AUTH, "Could not set NTLMV2 Hash as a key\n"); > + goto out; > + } > + > + rc = crypto_shash_init(CRYPTO_HMACMD5(ctx)); > + if (rc) { > + ksmbd_debug(AUTH, "Could not init hmacmd5\n"); > + goto out; > + } > + > + len = CIFS_CRYPTO_KEY_SIZE + blen; > + construct = kzalloc(len, GFP_KERNEL); > + if (!construct) { > + rc = -ENOMEM; > + goto out; > + } > + > + memcpy(construct, sess->ntlmssp.cryptkey, CIFS_CRYPTO_KEY_SIZE); > + memcpy(construct + CIFS_CRYPTO_KEY_SIZE, > + (char *)(&ntlmv2->blob_signature), blen); No need for this (char *) cast. > + > + rc = crypto_shash_update(CRYPTO_HMACMD5(ctx), construct, len); > + if (rc) { > + ksmbd_debug(AUTH, "Could not update with response\n"); > + goto out; > + } > + > + rc = crypto_shash_final(CRYPTO_HMACMD5(ctx), ntlmv2_rsp); > + if (rc) { > + ksmbd_debug(AUTH, "Could not generate md5 hash\n"); > + goto out; > + } > + > + rc = ksmbd_gen_sess_key(sess, ntlmv2_hash, ntlmv2_rsp); > + if (rc) { > + ksmbd_debug(AUTH, "Could not generate sess key\n"); > + goto out; > + } > + > + rc = memcmp(ntlmv2->ntlmv2_hash, ntlmv2_rsp, CIFS_HMAC_MD5_HASH_SIZE); if (memcmp() != 0) rc = -EINVAL; > +out: > + ksmbd_release_crypto_ctx(ctx); > + kfree(construct); > + return rc; > +} > + > +/** > + * __ksmbd_auth_ntlmv2() - NTLM2(extended security) authentication handler > + * @sess: session of connection > + * @client_nonce: client nonce from LM response. > + * @ntlm_resp: ntlm response data from client. > + * > + * Return: 0 on success, error number on error > + */ > +static int __ksmbd_auth_ntlmv2(struct ksmbd_session *sess, char *client_nonce, > + char *ntlm_resp) > +{ > + char sess_key[CIFS_SMB1_SESSKEY_SIZE] = {0}; > + int rc; > + unsigned char p21[21]; > + char key[CIFS_AUTH_RESP_SIZE]; > + > + rc = ksmbd_enc_update_sess_key(sess_key, > + client_nonce, > + (char *)sess->ntlmssp.cryptkey, 8); > + if (rc) { > + ksmbd_err("password processing failed\n"); > + goto out; > + } > + > + memset(p21, '\0', 21); > + memcpy(p21, user_passkey(sess->user), CIFS_NTHASH_SIZE); > + rc = ksmbd_enc_p24(p21, sess_key, key); > + if (rc) { > + ksmbd_err("password processing failed\n"); > + goto out; > + } > + > + rc = memcmp(ntlm_resp, key, CIFS_AUTH_RESP_SIZE); if (memcmp(ntlm_resp, key, CIFS_AUTH_RESP_SIZE) != 0) rc = -EINVAL; > +out: > + return rc; > +} > + > +/** > + * ksmbd_decode_ntlmssp_auth_blob() - helper function to construct > + * authenticate blob > + * @authblob: authenticate blob source pointer > + * @usr: user details > + * @sess: session of connection > + * > + * Return: 0 on success, error number on error > + */ > +int ksmbd_decode_ntlmssp_auth_blob(struct authenticate_message *authblob, > + int blob_len, struct ksmbd_session *sess) > +{ > + char *domain_name; > + unsigned int lm_off, nt_off; > + unsigned short nt_len; > + int ret; > + > + if (blob_len < sizeof(struct authenticate_message)) { > + ksmbd_debug(AUTH, "negotiate blob len %d too small\n", > + blob_len); > + return -EINVAL; > + } > + > + if (memcmp(authblob->Signature, "NTLMSSP", 8)) { > + ksmbd_debug(AUTH, "blob signature incorrect %s\n", > + authblob->Signature); > + return -EINVAL; > + } > + > + lm_off = le32_to_cpu(authblob->LmChallengeResponse.BufferOffset); > + nt_off = le32_to_cpu(authblob->NtChallengeResponse.BufferOffset); > + nt_len = le16_to_cpu(authblob->NtChallengeResponse.Length); > + > + /* process NTLM authentication */ > + if (nt_len == CIFS_AUTH_RESP_SIZE) { > + if (le32_to_cpu(authblob->NegotiateFlags) & > + NTLMSSP_NEGOTIATE_EXTENDED_SEC) > + return __ksmbd_auth_ntlmv2(sess, (char *)authblob + > + lm_off, (char *)authblob + nt_off); > + else > + return ksmbd_auth_ntlm(sess, (char *)authblob + > + nt_off); > + } > + > + /* TODO : use domain name that imported from configuration file */ > + domain_name = smb_strndup_from_utf16((const char *)authblob + > + le32_to_cpu(authblob->DomainName.BufferOffset), > + le16_to_cpu(authblob->DomainName.Length), true, > + sess->conn->local_nls); > + if (IS_ERR(domain_name)) > + return PTR_ERR(domain_name); > + > + /* process NTLMv2 authentication */ > + ksmbd_debug(AUTH, "decode_ntlmssp_authenticate_blob dname%s\n", > + domain_name); > + ret = ksmbd_auth_ntlmv2(sess, > + (struct ntlmv2_resp *)((char *)authblob + nt_off), > + nt_len - CIFS_ENCPWD_SIZE, > + domain_name); > + kfree(domain_name); > + return ret; > +} > + > +/** > + * ksmbd_decode_ntlmssp_neg_blob() - helper function to construct > + * negotiate blob > + * @negblob: negotiate blob source pointer > + * @rsp: response header pointer to be updated > + * @sess: session of connection > + * > + */ > +int ksmbd_decode_ntlmssp_neg_blob(struct negotiate_message *negblob, > + int blob_len, struct ksmbd_session *sess) > +{ > + if (blob_len < sizeof(struct negotiate_message)) { > + ksmbd_debug(AUTH, "negotiate blob len %d too small\n", > + blob_len); > + return -EINVAL; > + } > + > + if (memcmp(negblob->Signature, "NTLMSSP", 8)) { > + ksmbd_debug(AUTH, "blob signature incorrect %s\n", > + negblob->Signature); > + return -EINVAL; > + } > + > + sess->ntlmssp.client_flags = le32_to_cpu(negblob->NegotiateFlags); > + return 0; > +} > + > +/** > + * ksmbd_build_ntlmssp_challenge_blob() - helper function to construct > + * challenge blob > + * @chgblob: challenge blob source pointer to initialize > + * @rsp: response header pointer to be updated > + * @sess: session of connection > + * > + */ > +unsigned int > +ksmbd_build_ntlmssp_challenge_blob(struct challenge_message *chgblob, > + struct ksmbd_session *sess) > +{ > + struct target_info *tinfo; > + wchar_t *name; > + __u8 *target_name; > + unsigned int len, flags, blob_off, blob_len, type, target_info_len = 0; > + int cflags = sess->ntlmssp.client_flags; > + > + memcpy(chgblob->Signature, NTLMSSP_SIGNATURE, 8); > + chgblob->MessageType = NtLmChallenge; > + > + flags = NTLMSSP_NEGOTIATE_UNICODE | > + NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_TARGET_TYPE_SERVER | > + NTLMSSP_NEGOTIATE_TARGET_INFO; > + > + if (cflags & NTLMSSP_NEGOTIATE_SIGN) { > + flags |= NTLMSSP_NEGOTIATE_SIGN; > + flags |= cflags & (NTLMSSP_NEGOTIATE_128 | > + NTLMSSP_NEGOTIATE_56); flags |= cflags & (NTLMSSP_NEGOTIATE_128 | NTLMSSP_NEGOTIATE_56); > + } > + > + if (cflags & NTLMSSP_NEGOTIATE_ALWAYS_SIGN) > + flags |= NTLMSSP_NEGOTIATE_ALWAYS_SIGN; > + > + if (cflags & NTLMSSP_REQUEST_TARGET) > + flags |= NTLMSSP_REQUEST_TARGET; > + > + if (sess->conn->use_spnego && > + (cflags & NTLMSSP_NEGOTIATE_EXTENDED_SEC)) > + flags |= NTLMSSP_NEGOTIATE_EXTENDED_SEC; > + > + chgblob->NegotiateFlags = cpu_to_le32(flags); > + len = strlen(ksmbd_netbios_name()); > + name = kmalloc(2 + (len * 2), GFP_KERNEL); > + if (!name) > + return -ENOMEM; > + > + len = smb_strtoUTF16((__le16 *)name, ksmbd_netbios_name(), len, > + sess->conn->local_nls); > + len = UNICODE_LEN(len); The smb_strtoUTF16() already modifies len so multiplying it by two a second time leads to a buffer overflow? > + > + blob_off = sizeof(struct challenge_message); > + blob_len = blob_off + len; > + > + chgblob->TargetName.Length = cpu_to_le16(len); > + chgblob->TargetName.MaximumLength = cpu_to_le16(len); > + chgblob->TargetName.BufferOffset = cpu_to_le32(blob_off); > + > + /* Initialize random conn challenge */ > + get_random_bytes(sess->ntlmssp.cryptkey, sizeof(__u64)); > + memcpy(chgblob->Challenge, sess->ntlmssp.cryptkey, > + CIFS_CRYPTO_KEY_SIZE); > + > + /* Add Target Information to security buffer */ > + chgblob->TargetInfoArray.BufferOffset = cpu_to_le32(blob_len); > + > + target_name = (__u8 *)chgblob + blob_off; > + memcpy(target_name, name, len); > + tinfo = (struct target_info *)(target_name + len); > + > + chgblob->TargetInfoArray.Length = 0; > + /* Add target info list for NetBIOS/DNS settings */ > + for (type = NTLMSSP_AV_NB_COMPUTER_NAME; > + type <= NTLMSSP_AV_DNS_DOMAIN_NAME; type++) { for (type = NTLMSSP_AV_NB_COMPUTER_NAME; type <= NTLMSSP_AV_DNS_DOMAIN_NAME; type++) { > + tinfo->Type = cpu_to_le16(type); > + tinfo->Length = cpu_to_le16(len); > + memcpy(tinfo->Content, name, len); > + tinfo = (struct target_info *)((char *)tinfo + 4 + len); > + target_info_len += 4 + len; > + } > + > + /* Add terminator subblock */ > + tinfo->Type = 0; > + tinfo->Length = 0; > + target_info_len += 4; > + > + chgblob->TargetInfoArray.Length = cpu_to_le16(target_info_len); > + chgblob->TargetInfoArray.MaximumLength = cpu_to_le16(target_info_len); > + blob_len += target_info_len; > + kfree(name); > + ksmbd_debug(AUTH, "NTLMSSP SecurityBufferLength %d\n", blob_len); > + return blob_len; > +} > + > +#ifdef CONFIG_SMB_SERVER_KERBEROS5 > +int ksmbd_krb5_authenticate(struct ksmbd_session *sess, char *in_blob, > + int in_len, char *out_blob, int *out_len) > +{ > + struct ksmbd_spnego_authen_response *resp; > + struct ksmbd_user *user = NULL; > + int retval; > + > + resp = ksmbd_ipc_spnego_authen_request(in_blob, in_len); > + if (!resp) { > + ksmbd_debug(AUTH, "SPNEGO_AUTHEN_REQUEST failure\n"); > + return -EINVAL; > + } > + > + if (!(resp->login_response.status & KSMBD_USER_FLAG_OK)) { > + ksmbd_debug(AUTH, "krb5 authentication failure\n"); > + retval = -EPERM; > + goto out; > + } > + > + if (*out_len <= resp->spnego_blob_len) { > + ksmbd_debug(AUTH, "buf len %d, but blob len %d\n", > + *out_len, resp->spnego_blob_len); > + retval = -EINVAL; > + goto out; > + } > + > + if (resp->session_key_len > sizeof(sess->sess_key)) { > + ksmbd_debug(AUTH, "session key is too long\n"); > + retval = -EINVAL; > + goto out; > + } > + > + user = ksmbd_alloc_user(&resp->login_response); > + if (!user) { > + ksmbd_debug(AUTH, "login failure\n"); > + retval = -ENOMEM; > + goto out; > + } > + sess->user = user; > + > + memcpy(sess->sess_key, resp->payload, resp->session_key_len); > + memcpy(out_blob, resp->payload + resp->session_key_len, > + resp->spnego_blob_len); > + *out_len = resp->spnego_blob_len; > + retval = 0; > +out: > + kvfree(resp); > + return retval; > +} > +#else > +int ksmbd_krb5_authenticate(struct ksmbd_session *sess, char *in_blob, > + int in_len, char *out_blob, int *out_len) > +{ > + return -EOPNOTSUPP; > +} > +#endif > + > +/** > + * ksmbd_sign_smb2_pdu() - function to generate packet signing > + * @conn: connection > + * @key: signing key > + * @iov: buffer iov array > + * @n_vec: number of iovecs > + * @sig: signature value generated for client request packet > + * > + */ > +int ksmbd_sign_smb2_pdu(struct ksmbd_conn *conn, char *key, struct kvec *iov, > + int n_vec, char *sig) > +{ > + struct ksmbd_crypto_ctx *ctx; > + int rc = -EINVAL; > + int i; > + > + ctx = ksmbd_crypto_ctx_find_hmacsha256(); > + if (!ctx) { > + ksmbd_debug(AUTH, "could not crypto alloc hmacmd5 rc %d\n", rc); > + goto out; > + } > + > + rc = crypto_shash_setkey(CRYPTO_HMACSHA256_TFM(ctx), > + key, > + SMB2_NTLMV2_SESSKEY_SIZE); > + if (rc) > + goto out; > + > + rc = crypto_shash_init(CRYPTO_HMACSHA256(ctx)); > + if (rc) { > + ksmbd_debug(AUTH, "hmacsha256 init error %d\n", rc); > + goto out; > + } > + > + for (i = 0; i < n_vec; i++) { > + rc = crypto_shash_update(CRYPTO_HMACSHA256(ctx), > + iov[i].iov_base, > + iov[i].iov_len); > + if (rc) { > + ksmbd_debug(AUTH, "hmacsha256 update error %d\n", rc); > + goto out; > + } > + } > + > + rc = crypto_shash_final(CRYPTO_HMACSHA256(ctx), sig); > + if (rc) > + ksmbd_debug(AUTH, "hmacsha256 generation error %d\n", rc); > +out: > + ksmbd_release_crypto_ctx(ctx); > + return rc; > +} > + > +/** > + * ksmbd_sign_smb3_pdu() - function to generate packet signing > + * @conn: connection > + * @key: signing key > + * @iov: buffer iov array > + * @n_vec: number of iovecs > + * @sig: signature value generated for client request packet > + * > + */ > +int ksmbd_sign_smb3_pdu(struct ksmbd_conn *conn, char *key, struct kvec *iov, > + int n_vec, char *sig) > +{ > + struct ksmbd_crypto_ctx *ctx; > + int rc = -EINVAL; > + int i; > + > + ctx = ksmbd_crypto_ctx_find_cmacaes(); > + if (!ctx) { > + ksmbd_debug(AUTH, "could not crypto alloc cmac rc %d\n", rc); > + goto out; > + } > + > + rc = crypto_shash_setkey(CRYPTO_CMACAES_TFM(ctx), > + key, > + SMB2_CMACAES_SIZE); > + if (rc) > + goto out; > + > + rc = crypto_shash_init(CRYPTO_CMACAES(ctx)); > + if (rc) { > + ksmbd_debug(AUTH, "cmaces init error %d\n", rc); > + goto out; > + } > + > + for (i = 0; i < n_vec; i++) { > + rc = crypto_shash_update(CRYPTO_CMACAES(ctx), > + iov[i].iov_base, > + iov[i].iov_len); > + if (rc) { > + ksmbd_debug(AUTH, "cmaces update error %d\n", rc); > + goto out; > + } > + } > + > + rc = crypto_shash_final(CRYPTO_CMACAES(ctx), sig); > + if (rc) > + ksmbd_debug(AUTH, "cmaces generation error %d\n", rc); > +out: > + ksmbd_release_crypto_ctx(ctx); > + return rc; > +} > + > +struct derivation { > + struct kvec label; > + struct kvec context; > + bool binding; > +}; > + > +static int generate_key(struct ksmbd_session *sess, struct kvec label, > + struct kvec context, __u8 *key, unsigned int key_size) > +{ > + unsigned char zero = 0x0; > + __u8 i[4] = {0, 0, 0, 1}; > + __u8 L128[4] = {0, 0, 0, 128}; > + __u8 L256[4] = {0, 0, 1, 0}; > + int rc = -EINVAL; > + unsigned char prfhash[SMB2_HMACSHA256_SIZE]; > + unsigned char *hashptr = prfhash; > + struct ksmbd_crypto_ctx *ctx; > + > + memset(prfhash, 0x0, SMB2_HMACSHA256_SIZE); > + memset(key, 0x0, key_size); > + > + ctx = ksmbd_crypto_ctx_find_hmacsha256(); > + if (!ctx) { > + ksmbd_debug(AUTH, "could not crypto alloc hmacmd5 rc %d\n", rc); > + goto smb3signkey_ret; > + } > + > + rc = crypto_shash_setkey(CRYPTO_HMACSHA256_TFM(ctx), > + sess->sess_key, > + SMB2_NTLMV2_SESSKEY_SIZE); > + if (rc) > + goto smb3signkey_ret; > + > + rc = crypto_shash_init(CRYPTO_HMACSHA256(ctx)); > + if (rc) { > + ksmbd_debug(AUTH, "hmacsha256 init error %d\n", rc); > + goto smb3signkey_ret; > + } > + > + rc = crypto_shash_update(CRYPTO_HMACSHA256(ctx), i, 4); > + if (rc) { > + ksmbd_debug(AUTH, "could not update with n\n"); > + goto smb3signkey_ret; > + } > + > + rc = crypto_shash_update(CRYPTO_HMACSHA256(ctx), > + label.iov_base, > + label.iov_len); > + if (rc) { > + ksmbd_debug(AUTH, "could not update with label\n"); > + goto smb3signkey_ret; > + } > + > + rc = crypto_shash_update(CRYPTO_HMACSHA256(ctx), &zero, 1); > + if (rc) { > + ksmbd_debug(AUTH, "could not update with zero\n"); > + goto smb3signkey_ret; > + } > + > + rc = crypto_shash_update(CRYPTO_HMACSHA256(ctx), > + context.iov_base, > + context.iov_len); > + if (rc) { > + ksmbd_debug(AUTH, "could not update with context\n"); > + goto smb3signkey_ret; > + } > + > + if (sess->conn->cipher_type == SMB2_ENCRYPTION_AES256_CCM || > + sess->conn->cipher_type == SMB2_ENCRYPTION_AES256_GCM) > + rc = crypto_shash_update(CRYPTO_HMACSHA256(ctx), L256, 4); > + else > + rc = crypto_shash_update(CRYPTO_HMACSHA256(ctx), L128, 4); > + if (rc) { > + ksmbd_debug(AUTH, "could not update with L\n"); > + goto smb3signkey_ret; > + } > + > + rc = crypto_shash_final(CRYPTO_HMACSHA256(ctx), hashptr); > + if (rc) { > + ksmbd_debug(AUTH, "Could not generate hmacmd5 hash error %d\n", > + rc); > + goto smb3signkey_ret; > + } > + > + memcpy(key, hashptr, key_size); > + > +smb3signkey_ret: > + ksmbd_release_crypto_ctx(ctx); > + return rc; > +} > + > +static int generate_smb3signingkey(struct ksmbd_session *sess, > + const struct derivation *signing) > +{ > + int rc; > + struct channel *chann; > + char *key; > + > + chann = lookup_chann_list(sess); > + if (!chann) > + return 0; > + > + if (sess->conn->dialect >= SMB30_PROT_ID && signing->binding) > + key = chann->smb3signingkey; > + else > + key = sess->smb3signingkey; > + > + rc = generate_key(sess, signing->label, signing->context, key, > + SMB3_SIGN_KEY_SIZE); > + if (rc) > + return rc; > + > + if (!(sess->conn->dialect >= SMB30_PROT_ID && signing->binding)) > + memcpy(chann->smb3signingkey, key, SMB3_SIGN_KEY_SIZE); > + > + ksmbd_debug(AUTH, "dumping generated AES signing keys\n"); > + ksmbd_debug(AUTH, "Session Id %llu\n", sess->id); > + ksmbd_debug(AUTH, "Session Key %*ph\n", > + SMB2_NTLMV2_SESSKEY_SIZE, sess->sess_key); > + ksmbd_debug(AUTH, "Signing Key %*ph\n", > + SMB3_SIGN_KEY_SIZE, key); > + return rc; return 0; > +} > + > +int ksmbd_gen_smb30_signingkey(struct ksmbd_session *sess) > +{ > + struct derivation d; > + > + d.label.iov_base = "SMB2AESCMAC"; > + d.label.iov_len = 12; > + d.context.iov_base = "SmbSign"; > + d.context.iov_len = 8; > + d.binding = false; > + > + return generate_smb3signingkey(sess, &d); > +} > + > +int ksmbd_gen_smb311_signingkey(struct ksmbd_session *sess) > +{ > + struct derivation d; > + > + d.label.iov_base = "SMBSigningKey"; > + d.label.iov_len = 14; > + d.context.iov_base = sess->Preauth_HashValue; > + d.context.iov_len = 64; > + d.binding = false; > + > + return generate_smb3signingkey(sess, &d); > +} > + > +struct derivation_twin { > + struct derivation encryption; > + struct derivation decryption; > +}; > + > +static int generate_smb3encryptionkey(struct ksmbd_session *sess, > + const struct derivation_twin *ptwin) > +{ > + int rc; > + > + rc = generate_key(sess, ptwin->encryption.label, > + ptwin->encryption.context, sess->smb3encryptionkey, > + SMB3_ENC_DEC_KEY_SIZE); > + if (rc) > + return rc; > + > + rc = generate_key(sess, ptwin->decryption.label, > + ptwin->decryption.context, > + sess->smb3decryptionkey, SMB3_ENC_DEC_KEY_SIZE); > + if (rc) > + return rc; > + > + ksmbd_debug(AUTH, "dumping generated AES encryption keys\n"); > + ksmbd_debug(AUTH, "Cipher type %d\n", sess->conn->cipher_type); > + ksmbd_debug(AUTH, "Session Id %llu\n", sess->id); > + ksmbd_debug(AUTH, "Session Key %*ph\n", > + SMB2_NTLMV2_SESSKEY_SIZE, sess->sess_key); > + if (sess->conn->cipher_type == SMB2_ENCRYPTION_AES256_CCM || > + sess->conn->cipher_type == SMB2_ENCRYPTION_AES256_GCM) { > + ksmbd_debug(AUTH, "ServerIn Key %*ph\n", > + SMB3_GCM256_CRYPTKEY_SIZE, sess->smb3encryptionkey); > + ksmbd_debug(AUTH, "ServerOut Key %*ph\n", > + SMB3_GCM256_CRYPTKEY_SIZE, sess->smb3decryptionkey); > + } else { > + ksmbd_debug(AUTH, "ServerIn Key %*ph\n", > + SMB3_GCM128_CRYPTKEY_SIZE, sess->smb3encryptionkey); > + ksmbd_debug(AUTH, "ServerOut Key %*ph\n", > + SMB3_GCM128_CRYPTKEY_SIZE, sess->smb3decryptionkey); > + } > + return rc; return 0; > +} > + > +int ksmbd_gen_smb30_encryptionkey(struct ksmbd_session *sess) > +{ > + struct derivation_twin twin; > + struct derivation *d; > + > + d = &twin.encryption; > + d->label.iov_base = "SMB2AESCCM"; > + d->label.iov_len = 11; > + d->context.iov_base = "ServerOut"; > + d->context.iov_len = 10; > + > + d = &twin.decryption; > + d->label.iov_base = "SMB2AESCCM"; > + d->label.iov_len = 11; > + d->context.iov_base = "ServerIn "; > + d->context.iov_len = 10; > + > + return generate_smb3encryptionkey(sess, &twin); > +} > + > +int ksmbd_gen_smb311_encryptionkey(struct ksmbd_session *sess) > +{ > + struct derivation_twin twin; > + struct derivation *d; > + > + d = &twin.encryption; > + d->label.iov_base = "SMBS2CCipherKey"; > + d->label.iov_len = 16; > + d->context.iov_base = sess->Preauth_HashValue; > + d->context.iov_len = 64; > + > + d = &twin.decryption; > + d->label.iov_base = "SMBC2SCipherKey"; > + d->label.iov_len = 16; > + d->context.iov_base = sess->Preauth_HashValue; > + d->context.iov_len = 64; > + > + return generate_smb3encryptionkey(sess, &twin); > +} > + > +int ksmbd_gen_preauth_integrity_hash(struct ksmbd_conn *conn, char *buf, > + __u8 *pi_hash) > +{ > + int rc = -1; int rc = -EINVAL; > + struct smb2_hdr *rcv_hdr = (struct smb2_hdr *)buf; > + char *all_bytes_msg = (char *)&rcv_hdr->ProtocolId; > + int msg_size = be32_to_cpu(rcv_hdr->smb2_buf_length); > + struct ksmbd_crypto_ctx *ctx = NULL; > + > + if (conn->preauth_info->Preauth_HashId == > + SMB2_PREAUTH_INTEGRITY_SHA512) { Flip this condition around: if (conn->preauth_info->Preauth_HashId != SMB2_PREAUTH_INTEGRITY_SHA512) return -EINVAL; > + ctx = ksmbd_crypto_ctx_find_sha512(); > + if (!ctx) { > + ksmbd_debug(AUTH, "could not alloc sha512 rc %d\n", rc); > + goto out; > + } Pull this code in a tab. > + } else { > + goto out; > + } > + > + rc = crypto_shash_init(CRYPTO_SHA512(ctx)); > + if (rc) { > + ksmbd_debug(AUTH, "could not init shashn"); > + goto out; > + } > + > + rc = crypto_shash_update(CRYPTO_SHA512(ctx), pi_hash, 64); > + if (rc) { > + ksmbd_debug(AUTH, "could not update with n\n"); > + goto out; > + } > + > + rc = crypto_shash_update(CRYPTO_SHA512(ctx), all_bytes_msg, msg_size); > + if (rc) { > + ksmbd_debug(AUTH, "could not update with n\n"); > + goto out; > + } > + > + rc = crypto_shash_final(CRYPTO_SHA512(ctx), pi_hash); > + if (rc) { > + ksmbd_debug(AUTH, "Could not generate hash err : %d\n", rc); > + goto out; > + } > +out: > + ksmbd_release_crypto_ctx(ctx); > + return rc; > +} > + > +int ksmbd_gen_sd_hash(struct ksmbd_conn *conn, char *sd_buf, int len, > + __u8 *pi_hash) > +{ > + int rc = -1; int rc = -EINVAL; > + struct ksmbd_crypto_ctx *ctx = NULL; > + > + ctx = ksmbd_crypto_ctx_find_sha256(); > + if (!ctx) { > + ksmbd_debug(AUTH, "could not alloc sha256 rc %d\n", rc); > + goto out; > + } > + > + rc = crypto_shash_init(CRYPTO_SHA256(ctx)); > + if (rc) { > + ksmbd_debug(AUTH, "could not init shashn"); > + goto out; > + } > + > + rc = crypto_shash_update(CRYPTO_SHA256(ctx), sd_buf, len); > + if (rc) { > + ksmbd_debug(AUTH, "could not update with n\n"); > + goto out; > + } > + > + rc = crypto_shash_final(CRYPTO_SHA256(ctx), pi_hash); > + if (rc) { > + ksmbd_debug(AUTH, "Could not generate hash err : %d\n", rc); > + goto out; > + } > +out: > + ksmbd_release_crypto_ctx(ctx); > + return rc; > +} > + > +static int ksmbd_get_encryption_key(struct ksmbd_conn *conn, __u64 ses_id, > + int enc, u8 *key) > +{ > + struct ksmbd_session *sess; > + u8 *ses_enc_key; > + > + sess = ksmbd_session_lookup(conn, ses_id); > + if (!sess) > + return 1; Please never return 1 on failure... :/ return -EINVAL; > + > + ses_enc_key = enc ? sess->smb3encryptionkey : > + sess->smb3decryptionkey; > + memcpy(key, ses_enc_key, SMB3_ENC_DEC_KEY_SIZE); > + > + return 0; > +} > + > +static inline void smb2_sg_set_buf(struct scatterlist *sg, const void *buf, > + unsigned int buflen) > +{ > + void *addr; > + > + if (is_vmalloc_addr(buf)) > + addr = vmalloc_to_page(buf); > + else > + addr = virt_to_page(buf); > + sg_set_page(sg, addr, buflen, offset_in_page(buf)); > +} > + > +static struct scatterlist *ksmbd_init_sg(struct kvec *iov, unsigned int nvec, > + u8 *sign) > +{ > + struct scatterlist *sg; > + unsigned int assoc_data_len = sizeof(struct smb2_transform_hdr) - 24; > + int i, nr_entries[3] = {0}, total_entries = 0, sg_idx = 0; > + > + for (i = 0; i < nvec - 1; i++) { If "nvec" is zero this loop will corrupt memory until the system crashes. > + unsigned long kaddr = (unsigned long)iov[i + 1].iov_base; > + > + if (is_vmalloc_addr(iov[i + 1].iov_base)) { > + nr_entries[i] = ((kaddr + iov[i + 1].iov_len + > + PAGE_SIZE - 1) >> PAGE_SHIFT) - > + (kaddr >> PAGE_SHIFT); > + } else { > + nr_entries[i]++; > + } > + total_entries += nr_entries[i]; > + } > + > + /* Add two entries for transform header and signature */ > + total_entries += 2; > + > + sg = kmalloc_array(total_entries, sizeof(struct scatterlist), GFP_KERNEL); > + if (!sg) > + return NULL; > + > + sg_init_table(sg, total_entries); > + smb2_sg_set_buf(&sg[sg_idx++], iov[0].iov_base + 24, assoc_data_len); > + for (i = 0; i < nvec - 1; i++) { > + void *data = iov[i + 1].iov_base; > + int len = iov[i + 1].iov_len; > + > + if (is_vmalloc_addr(data)) { > + int j, offset = offset_in_page(data); > + > + for (j = 0; j < nr_entries[i]; j++) { > + unsigned int bytes = PAGE_SIZE - offset; > + > + if (len <= 0) > + break; Can "len" really be negative here? That can't be good at all... > + > + if (bytes > len) > + bytes = len; > + > + sg_set_page(&sg[sg_idx++], > + vmalloc_to_page(data), bytes, > + offset_in_page(data)); > + > + data += bytes; > + len -= bytes; > + offset = 0; > + } > + } else { > + sg_set_page(&sg[sg_idx++], virt_to_page(data), len, > + offset_in_page(data)); > + } > + } > + smb2_sg_set_buf(&sg[sg_idx], sign, SMB2_SIGNATURE_SIZE); > + return sg; > +} > + > +int ksmbd_crypt_message(struct ksmbd_conn *conn, struct kvec *iov, > + unsigned int nvec, int enc) > +{ > + struct smb2_transform_hdr *tr_hdr = > + (struct smb2_transform_hdr *)iov[0].iov_base; > + unsigned int assoc_data_len = sizeof(struct smb2_transform_hdr) - 24; > + int rc = 0; No need. > + struct scatterlist *sg; > + u8 sign[SMB2_SIGNATURE_SIZE] = {}; > + u8 key[SMB3_ENC_DEC_KEY_SIZE]; > + struct aead_request *req; > + char *iv; > + unsigned int iv_len; > + struct crypto_aead *tfm; > + unsigned int crypt_len = le32_to_cpu(tr_hdr->OriginalMessageSize); > + struct ksmbd_crypto_ctx *ctx; > + > + rc = ksmbd_get_encryption_key(conn, > + le64_to_cpu(tr_hdr->SessionId), > + enc, > + key); > + if (rc) { > + ksmbd_err("Could not get %scryption key\n", enc ? "en" : "de"); > + return 0; Please add a comment why this is a return 0. > + } > + > + if (conn->cipher_type == SMB2_ENCRYPTION_AES128_GCM || > + conn->cipher_type == SMB2_ENCRYPTION_AES256_GCM) > + ctx = ksmbd_crypto_ctx_find_gcm(); > + else > + ctx = ksmbd_crypto_ctx_find_ccm(); > + if (!ctx) { > + ksmbd_err("crypto alloc failed\n"); > + return -EINVAL; > + } > + > + if (conn->cipher_type == SMB2_ENCRYPTION_AES128_GCM || > + conn->cipher_type == SMB2_ENCRYPTION_AES256_GCM) > + tfm = CRYPTO_GCM(ctx); > + else > + tfm = CRYPTO_CCM(ctx); > + > + if (conn->cipher_type == SMB2_ENCRYPTION_AES256_CCM || > + conn->cipher_type == SMB2_ENCRYPTION_AES256_GCM) > + rc = crypto_aead_setkey(tfm, key, SMB3_GCM256_CRYPTKEY_SIZE); > + else > + rc = crypto_aead_setkey(tfm, key, SMB3_GCM128_CRYPTKEY_SIZE); > + if (rc) { > + ksmbd_err("Failed to set aead key %d\n", rc); > + goto free_ctx; > + } > + > + rc = crypto_aead_setauthsize(tfm, SMB2_SIGNATURE_SIZE); > + if (rc) { > + ksmbd_err("Failed to set authsize %d\n", rc); > + goto free_ctx; > + } > + > + req = aead_request_alloc(tfm, GFP_KERNEL); > + if (!req) { > + ksmbd_err("Failed to alloc aead request\n"); > + rc = -ENOMEM; > + goto free_ctx; > + } > + > + if (!enc) { > + memcpy(sign, &tr_hdr->Signature, SMB2_SIGNATURE_SIZE); > + crypt_len += SMB2_SIGNATURE_SIZE; > + } > + > + sg = ksmbd_init_sg(iov, nvec, sign); > + if (!sg) { > + ksmbd_err("Failed to init sg\n"); > + rc = -ENOMEM; > + goto free_req; > + } > + > + iv_len = crypto_aead_ivsize(tfm); > + iv = kzalloc(iv_len, GFP_KERNEL); > + if (!iv) { > + ksmbd_err("Failed to alloc IV\n"); > + rc = -ENOMEM; > + goto free_sg; > + } > + > + if (conn->cipher_type == SMB2_ENCRYPTION_AES128_GCM || > + conn->cipher_type == SMB2_ENCRYPTION_AES256_GCM) { > + memcpy(iv, (char *)tr_hdr->Nonce, SMB3_AES_GCM_NONCE); > + } else { > + iv[0] = 3; > + memcpy(iv + 1, (char *)tr_hdr->Nonce, SMB3_AES_CCM_NONCE); > + } > + > + aead_request_set_crypt(req, sg, sg, crypt_len, iv); > + aead_request_set_ad(req, assoc_data_len); > + aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_SLEEP, NULL, NULL); > + > + if (enc) > + rc = crypto_aead_encrypt(req); > + else > + rc = crypto_aead_decrypt(req); > + if (!rc && enc) > + memcpy(&tr_hdr->Signature, sign, SMB2_SIGNATURE_SIZE); Always do failure handling. Don't do sucess handling. Keep the success path at indent level one. Don't make the last function call special. if (enc) rc = crypto_aead_encrypt(req); else rc = crypto_aead_decrypt(req); if (rc) goto free_iv; if (enc) memcpy(&tr_hdr->Signature, sign, SMB2_SIGNATURE_SIZE); free_iv: kfree(iv); > + > + kfree(iv); > +free_sg: > + kfree(sg); > +free_req: > + kfree(req); > +free_ctx: > + ksmbd_release_crypto_ctx(ctx); > + return rc; > +} > diff --git a/fs/cifsd/auth.h b/fs/cifsd/auth.h > new file mode 100644 > index 000000000000..6fcfad5e7e1f > --- /dev/null > +++ b/fs/cifsd/auth.h > @@ -0,0 +1,90 @@ > +/* SPDX-License-Identifier: GPL-2.0-or-later */ > +/* > + * Copyright (C) 2018 Samsung Electronics Co., Ltd. > + */ > + > +#ifndef __AUTH_H__ > +#define __AUTH_H__ > + > +#include "ntlmssp.h" > + > +#ifdef CONFIG_SMB_SERVER_KERBEROS5 > +#define AUTH_GSS_LENGTH 96 > +#define AUTH_GSS_PADDING 0 > +#else > +#define AUTH_GSS_LENGTH 74 > +#define AUTH_GSS_PADDING 6 > +#endif > + > +#define CIFS_HMAC_MD5_HASH_SIZE (16) > +#define CIFS_NTHASH_SIZE (16) > + > +/* > + * Size of the ntlm client response > + */ > +#define CIFS_AUTH_RESP_SIZE 24 > +#define CIFS_SMB1_SIGNATURE_SIZE 8 > +#define CIFS_SMB1_SESSKEY_SIZE 16 > + > +#define KSMBD_AUTH_NTLMSSP 0x0001 > +#define KSMBD_AUTH_KRB5 0x0002 > +#define KSMBD_AUTH_MSKRB5 0x0004 > +#define KSMBD_AUTH_KRB5U2U 0x0008 > + > +struct ksmbd_session; > +struct ksmbd_conn; > +struct kvec; > + > +int ksmbd_crypt_message(struct ksmbd_conn *conn, > + struct kvec *iov, > + unsigned int nvec, > + int enc); > + > +void ksmbd_copy_gss_neg_header(void *buf); > + > +int ksmbd_auth_ntlm(struct ksmbd_session *sess, > + char *pw_buf); > + > +int ksmbd_auth_ntlmv2(struct ksmbd_session *sess, > + struct ntlmv2_resp *ntlmv2, > + int blen, > + char *domain_name); > + > +int ksmbd_decode_ntlmssp_auth_blob(struct authenticate_message *authblob, > + int blob_len, > + struct ksmbd_session *sess); > + > +int ksmbd_decode_ntlmssp_neg_blob(struct negotiate_message *negblob, > + int blob_len, > + struct ksmbd_session *sess); > + > +unsigned int > +ksmbd_build_ntlmssp_challenge_blob(struct challenge_message *chgblob, > + struct ksmbd_session *sess); > + > +int ksmbd_krb5_authenticate(struct ksmbd_session *sess, > + char *in_blob, int in_len, > + char *out_blob, int *out_len); > + > +int ksmbd_sign_smb2_pdu(struct ksmbd_conn *conn, > + char *key, > + struct kvec *iov, > + int n_vec, > + char *sig); > +int ksmbd_sign_smb3_pdu(struct ksmbd_conn *conn, > + char *key, > + struct kvec *iov, > + int n_vec, > + char *sig); > + > +int ksmbd_gen_smb30_signingkey(struct ksmbd_session *sess); > +int ksmbd_gen_smb311_signingkey(struct ksmbd_session *sess); > +int ksmbd_gen_smb30_encryptionkey(struct ksmbd_session *sess); > +int ksmbd_gen_smb311_encryptionkey(struct ksmbd_session *sess); > + > +int ksmbd_gen_preauth_integrity_hash(struct ksmbd_conn *conn, > + char *buf, > + __u8 *pi_hash); > +int ksmbd_gen_sd_hash(struct ksmbd_conn *conn, char *sd_buf, int len, > + __u8 *pi_hash); > +#endif > diff --git a/fs/cifsd/crypto_ctx.c b/fs/cifsd/crypto_ctx.c > new file mode 100644 > index 000000000000..1830ae1b5ed3 > --- /dev/null > +++ b/fs/cifsd/crypto_ctx.c > @@ -0,0 +1,286 @@ > +// SPDX-License-Identifier: GPL-2.0-or-later > +/* > + * Copyright (C) 2019 Samsung Electronics Co., Ltd. > + */ > + > +#include <linux/kernel.h> > +#include <linux/string.h> > +#include <linux/err.h> > +#include <linux/slab.h> > +#include <linux/wait.h> > +#include <linux/sched.h> > + > +#include "glob.h" > +#include "crypto_ctx.h" > +#include "buffer_pool.h" > + > +struct crypto_ctx_list { > + spinlock_t ctx_lock; > + int avail_ctx; > + struct list_head idle_ctx; > + wait_queue_head_t ctx_wait; > +}; > + > +static struct crypto_ctx_list ctx_list; > + > +static inline void free_aead(struct crypto_aead *aead) > +{ > + if (aead) > + crypto_free_aead(aead); > +} > + > +static void free_shash(struct shash_desc *shash) > +{ > + if (shash) { > + crypto_free_shash(shash->tfm); > + kfree(shash); > + } > +} > + > +static struct crypto_aead *alloc_aead(int id) > +{ > + struct crypto_aead *tfm = NULL; > + > + switch (id) { > + case CRYPTO_AEAD_AES_GCM: > + tfm = crypto_alloc_aead("gcm(aes)", 0, 0); > + break; > + case CRYPTO_AEAD_AES_CCM: > + tfm = crypto_alloc_aead("ccm(aes)", 0, 0); > + break; > + default: > + ksmbd_err("Does not support encrypt ahead(id : %d)\n", id); > + return NULL; > + } > + > + if (IS_ERR(tfm)) { > + ksmbd_err("Failed to alloc encrypt aead : %ld\n", PTR_ERR(tfm)); > + return NULL; > + } > + > + return tfm; > +} > + > +static struct shash_desc *alloc_shash_desc(int id) > +{ > + struct crypto_shash *tfm = NULL; > + struct shash_desc *shash; > + > + switch (id) { > + case CRYPTO_SHASH_HMACMD5: > + tfm = crypto_alloc_shash("hmac(md5)", 0, 0); > + break; > + case CRYPTO_SHASH_HMACSHA256: > + tfm = crypto_alloc_shash("hmac(sha256)", 0, 0); > + break; > + case CRYPTO_SHASH_CMACAES: > + tfm = crypto_alloc_shash("cmac(aes)", 0, 0); > + break; > + case CRYPTO_SHASH_SHA256: > + tfm = crypto_alloc_shash("sha256", 0, 0); > + break; > + case CRYPTO_SHASH_SHA512: > + tfm = crypto_alloc_shash("sha512", 0, 0); > + break; > + case CRYPTO_SHASH_MD4: > + tfm = crypto_alloc_shash("md4", 0, 0); > + break; > + case CRYPTO_SHASH_MD5: > + tfm = crypto_alloc_shash("md5", 0, 0); > + break; No default path. > + } > + > + if (IS_ERR(tfm)) > + return NULL; > + > + shash = kzalloc(sizeof(*shash) + crypto_shash_descsize(tfm), > + GFP_KERNEL); > + if (!shash) > + crypto_free_shash(tfm); > + else > + shash->tfm = tfm; > + return shash; > +} > + > +static struct ksmbd_crypto_ctx *ctx_alloc(void) > +{ > + return kzalloc(sizeof(struct ksmbd_crypto_ctx), GFP_KERNEL); > +} Delete this function. Call kzalloc() directly. > + > +static void ctx_free(struct ksmbd_crypto_ctx *ctx) regards, dan carpenter ^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [Linux-cifsd-devel] [PATCH v3 04/10] cifsd: add authentication 2021-05-21 10:31 ` Dan Carpenter @ 2021-05-22 1:00 ` Namjae Jeon 0 siblings, 0 replies; 11+ messages in thread From: Namjae Jeon @ 2021-05-22 1:00 UTC (permalink / raw) To: Dan Carpenter Cc: Namjae Jeon, linux-cifs, willy, aurelien.aptel, linux-cifsd-devel, sandeen, linux-kernel, aaptel, hch, senozhatsky, viro, ronniesahlberg, linux-fsdevel, hch, Steve French 2021-05-21 19:31 GMT+09:00, Dan Carpenter <dan.carpenter@oracle.com>: > Didn't someone complain that we already had enough asn1 code in lib > and shouldn't add this in the subsystem dir? Are you talking about oid code in lib? If yes, We have sent the patch(cifs + updated oid code in lib) to list. If that is applied, ksmbd will also be able to use it. If anything else is a problem, Let me know it. > > Mostly trivial stuff. It's still not checkpatch --strict clean. I only > noticed the "CHECK: Alignment should match open parenthesis" while > reviewing so the rest of the warnings are apparently something I don't > care about. ;) The reason why I really like the alignment to be match > the open parenthesis is because then it doesn't line up with the code. Okay, CHECK: from checkpatch.pl --strict had some things I couldn't understand.(I'll ask you a question below.) > > Generally, I want the success patch indented one tab and the failure > path indented two tabs. Could you please explain more about success path ? > >> + rc = generate_key(sess, signing->label, signing->context, key, >> + SMB3_SIGN_KEY_SIZE); > > Here the SMB3_SIGN_KEY_SIZE is aligned at two tabs. It slightly slows > me down when I see code like that which isn't aligned where I expect it. > It's the same for if statements and four statements, if you align it > with the open parenthesis then it's easy to see what is part of the > condition and what is inside because they are indented differently. > > Bad: > if (condition && > condition2) > frob(); > Good: > if (condition && > condition2) > frob(); Okay.In the case of the if statement, I modified to align it, but there seems to be a part that I am missing. I'll check. checkpatch.pl --strict alarm warnings from function parameter to align with open parenthesis. I have always dealt with this as a two tab. Should I fix this case too? CHECK: Alignment should match open parenthesis #1114: FILE: auth.c:1114: +int ksmbd_gen_preauth_integrity_hash(struct ksmbd_conn *conn, char *buf, + __u8 *pi_hash) And in the case below, one tab or two tab or need to align with open parenthesis? CHECK: Alignment should match open parenthesis #1066: FILE: auth.c:1066: + ksmbd_debug(AUTH, "ServerIn Key %*ph\n", + SMB3_GCM128_CRYPTKEY_SIZE, sess->smb3encryptionkey); > > I noticed a couple error code bugs where we return 1 on failure like in > ksmbd_auth_ntlmv2(). Some buffer overflows with smb_strtoUTF16() and > UNICODE_LEN(). Okay, I will fix all of you pointed out below. Thanks for your review! > > > On Fri, May 21, 2021 at 03:26:31PM +0900, Namjae Jeon wrote: >> This adds NTLM/NTLMv2/Kerberos authentications and signing/encryption. >> >> Signed-off-by: Namjae Jeon <namjae.jeon@samsung.com> >> Signed-off-by: Sergey Senozhatsky <sergey.senozhatsky@gmail.com> >> Signed-off-by: Hyunchul Lee <hyc.lee@gmail.com> >> Acked-by: Ronnie Sahlberg <lsahlber@redhat.com> >> Signed-off-by: Steve French <stfrench@microsoft.com> >> --- >> fs/cifsd/asn1.c | 352 ++++++++ >> fs/cifsd/asn1.h | 29 + >> fs/cifsd/auth.c | 1344 +++++++++++++++++++++++++++++ >> fs/cifsd/auth.h | 90 ++ >> fs/cifsd/crypto_ctx.c | 286 ++++++ >> fs/cifsd/crypto_ctx.h | 77 ++ >> fs/cifsd/ntlmssp.h | 169 ++++ >> fs/cifsd/spnego_negtokeninit.asn1 | 43 + >> fs/cifsd/spnego_negtokentarg.asn1 | 19 + >> 9 files changed, 2409 insertions(+) >> create mode 100644 fs/cifsd/asn1.c >> create mode 100644 fs/cifsd/asn1.h >> create mode 100644 fs/cifsd/auth.c >> create mode 100644 fs/cifsd/auth.h >> create mode 100644 fs/cifsd/crypto_ctx.c >> create mode 100644 fs/cifsd/crypto_ctx.h >> create mode 100644 fs/cifsd/ntlmssp.h >> create mode 100644 fs/cifsd/spnego_negtokeninit.asn1 >> create mode 100644 fs/cifsd/spnego_negtokentarg.asn1 >> >> diff --git a/fs/cifsd/asn1.c b/fs/cifsd/asn1.c >> new file mode 100644 >> index 000000000000..aa6ea855c422 >> --- /dev/null >> +++ b/fs/cifsd/asn1.c >> @@ -0,0 +1,352 @@ >> +// SPDX-License-Identifier: GPL-2.0-or-later >> +/* >> + * The ASB.1/BER parsing code is derived from ip_nat_snmp_basic.c which >> was in >> + * turn derived from the gxsnmp package by Gregory McLean & Jochen >> Friedrich >> + * >> + * Copyright (c) 2000 RP Internet (http://www.rpi.net.au ). >> + */ >> + >> +#include <linux/module.h> >> +#include <linux/types.h> >> +#include <linux/kernel.h> >> +#include <linux/mm.h> >> +#include <linux/slab.h> >> +#include <linux/oid_registry.h> >> + >> +#include "glob.h" >> + >> +#include "asn1.h" >> +#include "connection.h" >> +#include "auth.h" >> +#include "spnego_negtokeninit.asn1.h" >> +#include "spnego_negtokentarg.asn1.h" >> + >> +#define SPNEGO_OID_LEN 7 >> +#define NTLMSSP_OID_LEN 10 >> +#define KRB5_OID_LEN 7 >> +#define KRB5U2U_OID_LEN 8 >> +#define MSKRB5_OID_LEN 7 >> +static unsigned long SPNEGO_OID[7] = { 1, 3, 6, 1, 5, 5, 2 }; >> +static unsigned long NTLMSSP_OID[10] = { 1, 3, 6, 1, 4, 1, 311, 2, 2, 10 >> }; >> +static unsigned long KRB5_OID[7] = { 1, 2, 840, 113554, 1, 2, 2 }; >> +static unsigned long KRB5U2U_OID[8] = { 1, 2, 840, 113554, 1, 2, 2, 3 }; >> +static unsigned long MSKRB5_OID[7] = { 1, 2, 840, 48018, 1, 2, 2 }; >> + >> +static char NTLMSSP_OID_STR[NTLMSSP_OID_LEN] = { 0x2b, 0x06, 0x01, 0x04, >> 0x01, >> + 0x82, 0x37, 0x02, 0x02, 0x0a }; >> + >> +static bool >> +asn1_subid_decode(const unsigned char **begin, const unsigned char *end, >> + unsigned long *subid) >> +{ >> + const unsigned char *ptr = *begin; >> + unsigned char ch; >> + >> + *subid = 0; >> + >> + do { >> + if (ptr >= end) >> + return false; >> + >> + ch = *ptr++; >> + *subid <<= 7; >> + *subid |= ch & 0x7F; >> + } while ((ch & 0x80) == 0x80); >> + >> + *begin = ptr; >> + return true; >> +} >> + >> +static bool asn1_oid_decode(const unsigned char *value, size_t vlen, >> + unsigned long **oid, size_t *oidlen) >> +{ >> + const unsigned char *iptr = value, *end = value + vlen; >> + unsigned long *optr; >> + unsigned long subid; >> + >> + vlen += 1; >> + if (vlen < 2 || vlen > UINT_MAX/sizeof(unsigned long)) >> + return false; >> + >> + *oid = kmalloc(vlen * sizeof(unsigned long), GFP_KERNEL); >> + if (!*oid) >> + return false; >> + >> + optr = *oid; >> + >> + if (!asn1_subid_decode(&iptr, end, &subid)) { >> + kfree(*oid); >> + *oid = NULL; >> + return false; >> + } > > Make this goto fail; > >> + >> + if (subid < 40) { >> + optr[0] = 0; >> + optr[1] = subid; >> + } else if (subid < 80) { >> + optr[0] = 1; >> + optr[1] = subid - 40; >> + } else { >> + optr[0] = 2; >> + optr[1] = subid - 80; >> + } >> + >> + *oidlen = 2; >> + optr += 2; >> + >> + while (iptr < end) { >> + if (++(*oidlen) > vlen) { >> + kfree(*oid); >> + *oid = NULL; >> + return false; > > goto fail; > >> + } >> + >> + if (!asn1_subid_decode(&iptr, end, optr++)) { >> + kfree(*oid); >> + *oid = NULL; >> + return false; > > goto fail; > >> + } >> + } >> + return true; > > > fail: > kfree(*oid); > *oid = NULL; > return false; > >> +} >> + >> +static bool >> +oid_eq(unsigned long *oid1, unsigned int oid1len, >> + unsigned long *oid2, unsigned int oid2len) >> +{ >> + unsigned int i; >> + >> + if (oid1len != oid2len) >> + return false; >> + >> + for (i = 0; i < oid1len; i++) { >> + if (oid1[i] != oid2[i]) >> + return false; >> + } > > return memcmp(oid1, oid2, oid1len) == 0; > >> + return true; >> +} >> + >> +int >> +ksmbd_decode_negTokenInit(unsigned char *security_blob, int length, >> + struct ksmbd_conn *conn) >> +{ >> + return asn1_ber_decoder(&spnego_negtokeninit_decoder, conn, >> + security_blob, length); >> +} >> + >> +int >> +ksmbd_decode_negTokenTarg(unsigned char *security_blob, int length, >> + struct ksmbd_conn *conn) >> +{ >> + return asn1_ber_decoder(&spnego_negtokentarg_decoder, conn, >> + security_blob, length); >> +} >> + >> +static int compute_asn_hdr_len_bytes(int len) >> +{ >> + if (len > 0xFFFFFF) >> + return 4; >> + else if (len > 0xFFFF) >> + return 3; >> + else if (len > 0xFF) >> + return 2; >> + else if (len > 0x7F) >> + return 1; >> + else >> + return 0; >> +} >> + >> +static void encode_asn_tag(char *buf, >> + unsigned int *ofs, >> + char tag, >> + char seq, >> + int length) >> +{ >> + int i; >> + int index = *ofs; >> + char hdr_len = compute_asn_hdr_len_bytes(length); >> + int len = length + 2 + hdr_len; >> + >> + /* insert tag */ >> + buf[index++] = tag; >> + >> + if (!hdr_len) >> + buf[index++] = len; >> + else { >> + buf[index++] = 0x80 | hdr_len; >> + for (i = hdr_len - 1; i >= 0; i--) >> + buf[index++] = (len >> (i * 8)) & 0xFF; >> + } >> + >> + /* insert seq */ >> + len = len - (index - *ofs); >> + buf[index++] = seq; >> + >> + if (!hdr_len) >> + buf[index++] = len; >> + else { >> + buf[index++] = 0x80 | hdr_len; >> + for (i = hdr_len - 1; i >= 0; i--) >> + buf[index++] = (len >> (i * 8)) & 0xFF; >> + } >> + >> + *ofs += (index - *ofs); >> +} >> + >> +int build_spnego_ntlmssp_neg_blob(unsigned char **pbuffer, u16 *buflen, >> + char *ntlm_blob, int ntlm_blob_len) >> +{ >> + char *buf; >> + unsigned int ofs = 0; >> + int neg_result_len = 4 + compute_asn_hdr_len_bytes(1) * 2 + 1; >> + int oid_len = 4 + compute_asn_hdr_len_bytes(NTLMSSP_OID_LEN) * 2 + >> + NTLMSSP_OID_LEN; >> + int ntlmssp_len = 4 + compute_asn_hdr_len_bytes(ntlm_blob_len) * 2 + >> + ntlm_blob_len; >> + int total_len = 4 + compute_asn_hdr_len_bytes(neg_result_len + >> + oid_len + ntlmssp_len) * 2 + >> + neg_result_len + oid_len + ntlmssp_len; >> + >> + buf = kmalloc(total_len, GFP_KERNEL); >> + if (!buf) >> + return -ENOMEM; >> + >> + /* insert main gss header */ >> + encode_asn_tag(buf, &ofs, 0xa1, 0x30, neg_result_len + oid_len + >> + ntlmssp_len); >> + >> + /* insert neg result */ >> + encode_asn_tag(buf, &ofs, 0xa0, 0x0a, 1); >> + buf[ofs++] = 1; >> + >> + /* insert oid */ >> + encode_asn_tag(buf, &ofs, 0xa1, 0x06, NTLMSSP_OID_LEN); >> + memcpy(buf + ofs, NTLMSSP_OID_STR, NTLMSSP_OID_LEN); >> + ofs += NTLMSSP_OID_LEN; >> + >> + /* insert response token - ntlmssp blob */ >> + encode_asn_tag(buf, &ofs, 0xa2, 0x04, ntlm_blob_len); >> + memcpy(buf + ofs, ntlm_blob, ntlm_blob_len); >> + ofs += ntlm_blob_len; >> + >> + *pbuffer = buf; >> + *buflen = total_len; >> + return 0; >> +} >> + >> +int build_spnego_ntlmssp_auth_blob(unsigned char **pbuffer, u16 *buflen, >> + int neg_result) >> +{ >> + char *buf; >> + unsigned int ofs = 0; >> + int neg_result_len = 4 + compute_asn_hdr_len_bytes(1) * 2 + 1; >> + int total_len = 4 + compute_asn_hdr_len_bytes(neg_result_len) * 2 + >> + neg_result_len; >> + >> + buf = kmalloc(total_len, GFP_KERNEL); >> + if (!buf) >> + return -ENOMEM; >> + >> + /* insert main gss header */ >> + encode_asn_tag(buf, &ofs, 0xa1, 0x30, neg_result_len); >> + >> + /* insert neg result */ >> + encode_asn_tag(buf, &ofs, 0xa0, 0x0a, 1); >> + if (neg_result) >> + buf[ofs++] = 2; >> + else >> + buf[ofs++] = 0; >> + >> + *pbuffer = buf; >> + *buflen = total_len; >> + return 0; >> +} >> + >> +int gssapi_this_mech(void *context, size_t hdrlen, >> + unsigned char tag, const void *value, size_t vlen) >> +{ >> + unsigned long *oid; >> + size_t oidlen; >> + int err = 0; >> + >> + if (!asn1_oid_decode(value, vlen, &oid, &oidlen)) { >> + err = -EBADMSG; >> + goto out; >> + } >> + >> + if (!oid_eq(oid, oidlen, SPNEGO_OID, SPNEGO_OID_LEN)) >> + err = -EBADMSG; >> + kfree(oid); >> +out: >> + if (err) { >> + char buf[50]; >> + >> + sprint_oid(value, vlen, buf, sizeof(buf)); >> + ksmbd_debug(AUTH, "Unexpected OID: %s\n", buf); >> + } >> + return err; >> +} >> + >> +int neg_token_init_mech_type(void *context, size_t hdrlen, >> + unsigned char tag, const void *value, size_t vlen) >> +{ >> + struct ksmbd_conn *conn = context; >> + unsigned long *oid; >> + size_t oidlen; >> + int mech_type; >> + >> + if (!asn1_oid_decode(value, vlen, &oid, &oidlen)) { >> + char buf[50]; >> + >> + sprint_oid(value, vlen, buf, sizeof(buf)); >> + ksmbd_debug(AUTH, "Unexpected OID: %s\n", buf); >> + return -EBADMSG; >> + } >> + >> + if (oid_eq(oid, oidlen, NTLMSSP_OID, NTLMSSP_OID_LEN)) >> + mech_type = KSMBD_AUTH_NTLMSSP; >> + else if (oid_eq(oid, oidlen, MSKRB5_OID, MSKRB5_OID_LEN)) >> + mech_type = KSMBD_AUTH_MSKRB5; >> + else if (oid_eq(oid, oidlen, KRB5_OID, KRB5_OID_LEN)) >> + mech_type = KSMBD_AUTH_KRB5; >> + else if (oid_eq(oid, oidlen, KRB5U2U_OID, KRB5U2U_OID_LEN)) >> + mech_type = KSMBD_AUTH_KRB5U2U; >> + else >> + goto out; > > Should this be an error path? > >> + >> + conn->auth_mechs |= mech_type; >> + if (conn->preferred_auth_mech == 0) >> + conn->preferred_auth_mech = mech_type; >> + >> +out: >> + kfree(oid); >> + return 0; >> +} >> + >> +int neg_token_init_mech_token(void *context, size_t hdrlen, >> + unsigned char tag, const void *value, size_t vlen) >> +{ >> + struct ksmbd_conn *conn = context; >> + >> + conn->mechToken = kmalloc(vlen + 1, GFP_KERNEL); >> + if (!conn->mechToken) >> + return -ENOMEM; >> + >> + memcpy(conn->mechToken, value, vlen); >> + conn->mechToken[vlen] = '\0'; >> + return 0; >> +} >> + >> +int neg_token_targ_resp_token(void *context, size_t hdrlen, >> + unsigned char tag, const void *value, size_t vlen) >> +{ >> + struct ksmbd_conn *conn = context; >> + >> + conn->mechToken = kmalloc(vlen + 1, GFP_KERNEL); >> + if (!conn->mechToken) >> + return -ENOMEM; >> + >> + memcpy(conn->mechToken, value, vlen); >> + conn->mechToken[vlen] = '\0'; >> + return 0; >> +} >> diff --git a/fs/cifsd/asn1.h b/fs/cifsd/asn1.h >> new file mode 100644 >> index 000000000000..ff2692b502d6 >> --- /dev/null >> +++ b/fs/cifsd/asn1.h >> @@ -0,0 +1,29 @@ >> +/* SPDX-License-Identifier: GPL-2.0-or-later */ >> +/* >> + * The ASB.1/BER parsing code is derived from ip_nat_snmp_basic.c which >> was in >> + * turn derived from the gxsnmp package by Gregory McLean & Jochen >> Friedrich >> + * >> + * Copyright (c) 2000 RP Internet (http://www.rpi.net.au ). >> + * Copyright (C) 2018 Samsung Electronics Co., Ltd. >> + */ >> + >> +#ifndef __ASN1_H__ >> +#define __ASN1_H__ >> + >> +int ksmbd_decode_negTokenInit(unsigned char *security_blob, >> + int length, >> + struct ksmbd_conn *conn); >> + >> +int ksmbd_decode_negTokenTarg(unsigned char *security_blob, >> + int length, >> + struct ksmbd_conn *conn); >> + >> +int build_spnego_ntlmssp_neg_blob(unsigned char **pbuffer, >> + u16 *buflen, >> + char *ntlm_blob, >> + int ntlm_blob_len); >> + >> +int build_spnego_ntlmssp_auth_blob(unsigned char **pbuffer, >> + u16 *buflen, >> + int neg_result); >> +#endif /* __ASN1_H__ */ >> diff --git a/fs/cifsd/auth.c b/fs/cifsd/auth.c >> new file mode 100644 >> index 000000000000..6b90aac86fcc >> --- /dev/null >> +++ b/fs/cifsd/auth.c >> @@ -0,0 +1,1344 @@ >> +// 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/kernel.h> >> +#include <linux/fs.h> >> +#include <linux/uaccess.h> >> +#include <linux/backing-dev.h> >> +#include <linux/writeback.h> >> +#include <linux/uio.h> >> +#include <linux/xattr.h> >> +#include <crypto/hash.h> >> +#include <crypto/aead.h> >> +#include <linux/random.h> >> +#include <linux/scatterlist.h> >> + >> +#include "auth.h" >> +#include "glob.h" >> + >> +#include <linux/fips.h> >> +#include <crypto/des.h> >> + >> +#include "server.h" >> +#include "smb_common.h" >> +#include "connection.h" >> +#include "mgmt/user_session.h" >> +#include "mgmt/user_config.h" >> +#include "crypto_ctx.h" >> +#include "transport_ipc.h" >> +#include "buffer_pool.h" >> + >> +/* >> + * Fixed format data defining GSS header and fixed string >> + * "not_defined_in_RFC4178@please_ignore". >> + * So sec blob data in neg phase could be generated statically. >> + */ >> +static char NEGOTIATE_GSS_HEADER[AUTH_GSS_LENGTH] = { >> +#ifdef CONFIG_SMB_SERVER_KERBEROS5 >> + 0x60, 0x5e, 0x06, 0x06, 0x2b, 0x06, 0x01, 0x05, >> + 0x05, 0x02, 0xa0, 0x54, 0x30, 0x52, 0xa0, 0x24, >> + 0x30, 0x22, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, >> + 0xf7, 0x12, 0x01, 0x02, 0x02, 0x06, 0x09, 0x2a, >> + 0x86, 0x48, 0x82, 0xf7, 0x12, 0x01, 0x02, 0x02, >> + 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, >> + 0x37, 0x02, 0x02, 0x0a, 0xa3, 0x2a, 0x30, 0x28, >> + 0xa0, 0x26, 0x1b, 0x24, 0x6e, 0x6f, 0x74, 0x5f, >> + 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x5f, >> + 0x69, 0x6e, 0x5f, 0x52, 0x46, 0x43, 0x34, 0x31, >> + 0x37, 0x38, 0x40, 0x70, 0x6c, 0x65, 0x61, 0x73, >> + 0x65, 0x5f, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65 >> +#else >> + 0x60, 0x48, 0x06, 0x06, 0x2b, 0x06, 0x01, 0x05, >> + 0x05, 0x02, 0xa0, 0x3e, 0x30, 0x3c, 0xa0, 0x0e, >> + 0x30, 0x0c, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, >> + 0x01, 0x82, 0x37, 0x02, 0x02, 0x0a, 0xa3, 0x2a, >> + 0x30, 0x28, 0xa0, 0x26, 0x1b, 0x24, 0x6e, 0x6f, >> + 0x74, 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, >> + 0x64, 0x5f, 0x69, 0x6e, 0x5f, 0x52, 0x46, 0x43, >> + 0x34, 0x31, 0x37, 0x38, 0x40, 0x70, 0x6c, 0x65, >> + 0x61, 0x73, 0x65, 0x5f, 0x69, 0x67, 0x6e, 0x6f, >> + 0x72, 0x65 >> +#endif >> +}; >> + >> +void ksmbd_copy_gss_neg_header(void *buf) >> +{ >> + memcpy(buf, NEGOTIATE_GSS_HEADER, AUTH_GSS_LENGTH); >> +} >> + >> +static void >> +str_to_key(unsigned char *str, unsigned char *key) >> +{ >> + int i; >> + >> + key[0] = str[0] >> 1; >> + key[1] = ((str[0] & 0x01) << 6) | (str[1] >> 2); >> + key[2] = ((str[1] & 0x03) << 5) | (str[2] >> 3); >> + key[3] = ((str[2] & 0x07) << 4) | (str[3] >> 4); >> + key[4] = ((str[3] & 0x0F) << 3) | (str[4] >> 5); >> + key[5] = ((str[4] & 0x1F) << 2) | (str[5] >> 6); >> + key[6] = ((str[5] & 0x3F) << 1) | (str[6] >> 7); >> + key[7] = str[6] & 0x7F; >> + for (i = 0; i < 8; i++) >> + key[i] = (key[i] << 1); >> +} >> + >> +static int >> +smbhash(unsigned char *out, const unsigned char *in, unsigned char *key) >> +{ >> + unsigned char key2[8]; >> + struct des_ctx ctx; >> + >> + str_to_key(key, key2); >> + >> + if (fips_enabled) { >> + ksmbd_debug(AUTH, >> + "FIPS compliance enabled: DES not permitted\n"); >> + return -ENOENT; >> + } > > Move this check before the str_to_key(). > >> + >> + des_expand_key(&ctx, key2, DES_KEY_SIZE); >> + des_encrypt(&ctx, out, in); >> + memzero_explicit(&ctx, sizeof(ctx)); >> + return 0; >> +} >> + >> +static int ksmbd_enc_p24(unsigned char *p21, const unsigned char *c8, >> unsigned char *p24) >> +{ >> + int rc; >> + >> + rc = smbhash(p24, c8, p21); >> + if (rc) >> + return rc; >> + rc = smbhash(p24 + 8, c8, p21 + 7); >> + if (rc) >> + return rc; >> + rc = smbhash(p24 + 16, c8, p21 + 14); >> + return rc; > > return smbhash(p24 + 16, c8, p21 + 14); > >> +} >> + >> +/* produce a md4 message digest from data of length n bytes */ >> +static int ksmbd_enc_md4(unsigned char *md4_hash, unsigned char >> *link_str, >> + int link_len) >> +{ >> + int rc; >> + struct ksmbd_crypto_ctx *ctx; >> + >> + ctx = ksmbd_crypto_ctx_find_md4(); >> + if (!ctx) { >> + ksmbd_debug(AUTH, "Crypto md4 allocation error\n"); >> + return -EINVAL; > > It feels like "allocation error" is misleading. Or maybe return > -ENOMEM? It's done consistently for all the ksmbd_crypto_ctx_find_ > calls, though... > >> + } >> + >> + rc = crypto_shash_init(CRYPTO_MD4(ctx)); >> + if (rc) { >> + ksmbd_debug(AUTH, "Could not init md4 shash\n"); >> + goto out; >> + } >> + >> + rc = crypto_shash_update(CRYPTO_MD4(ctx), link_str, link_len); >> + if (rc) { >> + ksmbd_debug(AUTH, "Could not update with link_str\n"); >> + goto out; >> + } >> + >> + rc = crypto_shash_final(CRYPTO_MD4(ctx), md4_hash); >> + if (rc) >> + ksmbd_debug(AUTH, "Could not generate md4 hash\n"); >> +out: >> + ksmbd_release_crypto_ctx(ctx); >> + return rc; >> +} >> + >> +static int ksmbd_enc_update_sess_key(unsigned char *md5_hash, char >> *nonce, >> + char *server_challenge, int len) >> +{ >> + int rc; >> + struct ksmbd_crypto_ctx *ctx; >> + >> + ctx = ksmbd_crypto_ctx_find_md5(); >> + if (!ctx) { >> + ksmbd_debug(AUTH, "Crypto md5 allocation error\n"); >> + return -EINVAL; >> + } >> + >> + rc = crypto_shash_init(CRYPTO_MD5(ctx)); >> + if (rc) { >> + ksmbd_debug(AUTH, "Could not init md5 shash\n"); >> + goto out; >> + } >> + >> + rc = crypto_shash_update(CRYPTO_MD5(ctx), server_challenge, len); >> + if (rc) { >> + ksmbd_debug(AUTH, "Could not update with challenge\n"); >> + goto out; >> + } >> + >> + rc = crypto_shash_update(CRYPTO_MD5(ctx), nonce, len); >> + if (rc) { >> + ksmbd_debug(AUTH, "Could not update with nonce\n"); >> + goto out; >> + } >> + >> + rc = crypto_shash_final(CRYPTO_MD5(ctx), md5_hash); >> + if (rc) >> + ksmbd_debug(AUTH, "Could not generate md5 hash\n"); >> +out: >> + ksmbd_release_crypto_ctx(ctx); >> + return rc; >> +} >> + >> +/** >> + * ksmbd_gen_sess_key() - function to generate session key >> + * @sess: session of connection >> + * @hash: source hash value to be used for find session key >> + * @hmac: source hmac value to be used for finding session key >> + * >> + */ >> +static int ksmbd_gen_sess_key(struct ksmbd_session *sess, char *hash, >> + char *hmac) >> +{ >> + struct ksmbd_crypto_ctx *ctx; >> + int rc = -EINVAL; >> + >> + ctx = ksmbd_crypto_ctx_find_hmacmd5(); >> + if (!ctx) >> + goto out; >> + >> + rc = crypto_shash_setkey(CRYPTO_HMACMD5_TFM(ctx), >> + hash, >> + CIFS_HMAC_MD5_HASH_SIZE); >> + if (rc) { >> + ksmbd_debug(AUTH, "hmacmd5 set key fail error %d\n", rc); >> + goto out; >> + } >> + >> + rc = crypto_shash_init(CRYPTO_HMACMD5(ctx)); >> + if (rc) { >> + ksmbd_debug(AUTH, "could not init hmacmd5 error %d\n", rc); >> + goto out; >> + } >> + >> + rc = crypto_shash_update(CRYPTO_HMACMD5(ctx), >> + hmac, >> + SMB2_NTLMV2_SESSKEY_SIZE); >> + if (rc) { >> + ksmbd_debug(AUTH, "Could not update with response error %d\n", >> + rc); >> + goto out; >> + } >> + >> + rc = crypto_shash_final(CRYPTO_HMACMD5(ctx), sess->sess_key); >> + if (rc) { >> + ksmbd_debug(AUTH, "Could not generate hmacmd5 hash error %d\n", >> + rc); >> + goto out; >> + } >> + >> +out: >> + ksmbd_release_crypto_ctx(ctx); >> + return rc; >> +} >> + >> +static int calc_ntlmv2_hash(struct ksmbd_session *sess, char >> *ntlmv2_hash, >> + char *dname) >> +{ >> + int ret = -EINVAL, len; >> + wchar_t *domain = NULL; >> + __le16 *uniname = NULL; >> + struct ksmbd_crypto_ctx *ctx; >> + >> + ctx = ksmbd_crypto_ctx_find_hmacmd5(); >> + if (!ctx) { >> + ksmbd_debug(AUTH, "can't generate ntlmv2 hash\n"); >> + goto out; >> + } >> + >> + ret = crypto_shash_setkey(CRYPTO_HMACMD5_TFM(ctx), >> + user_passkey(sess->user), >> + CIFS_ENCPWD_SIZE); >> + if (ret) { >> + ksmbd_debug(AUTH, "Could not set NT Hash as a key\n"); >> + goto out; >> + } >> + >> + ret = crypto_shash_init(CRYPTO_HMACMD5(ctx)); >> + if (ret) { >> + ksmbd_debug(AUTH, "could not init hmacmd5\n"); >> + goto out; >> + } >> + >> + /* convert user_name to unicode */ >> + len = strlen(user_name(sess->user)); >> + uniname = kzalloc(2 + UNICODE_LEN(len), GFP_KERNEL); >> + if (!uniname) { >> + ret = -ENOMEM; >> + goto out; >> + } >> + >> + if (len) { >> + len = smb_strtoUTF16(uniname, user_name(sess->user), len, >> + sess->conn->local_nls); >> + UniStrupr(uniname); >> + } >> + >> + ret = crypto_shash_update(CRYPTO_HMACMD5(ctx), >> + (char *)uniname, >> + UNICODE_LEN(len)); > > len = smb_strtoUTF16() modifies len so UNICODE_LEN() multiplies it by > two and leads to a read overflow. > >> + if (ret) { >> + ksmbd_debug(AUTH, "Could not update with user\n"); >> + goto out; >> + } >> + >> + /* Convert domain name or conn name to unicode and uppercase */ >> + len = strlen(dname); >> + domain = kzalloc(2 + UNICODE_LEN(len), GFP_KERNEL); >> + if (!domain) { >> + ret = -ENOMEM; >> + goto out; >> + } >> + >> + len = smb_strtoUTF16((__le16 *)domain, dname, len, >> + sess->conn->local_nls); >> + >> + ret = crypto_shash_update(CRYPTO_HMACMD5(ctx), >> + (char *)domain, >> + UNICODE_LEN(len)); > > The UNICODE_LEN() leads to a buffer overflow. > >> + if (ret) { >> + ksmbd_debug(AUTH, "Could not update with domain\n"); >> + goto out; >> + } >> + >> + ret = crypto_shash_final(CRYPTO_HMACMD5(ctx), ntlmv2_hash); >> +out: >> + if (ret) >> + ksmbd_debug(AUTH, "Could not generate md5 hash\n"); > > I think the if (ret) was intended to go before the out: label. > >> + kfree(uniname); >> + kfree(domain); >> + ksmbd_release_crypto_ctx(ctx); >> + return ret; >> +} >> + >> +/** >> + * ksmbd_auth_ntlm() - NTLM authentication handler >> + * @sess: session of connection >> + * @pw_buf: NTLM challenge response >> + * @passkey: user password >> + * >> + * Return: 0 on success, error number on error >> + */ >> +int ksmbd_auth_ntlm(struct ksmbd_session *sess, char *pw_buf) >> +{ >> + int rc; >> + unsigned char p21[21]; >> + char key[CIFS_AUTH_RESP_SIZE]; >> + >> + memset(p21, '\0', 21); >> + memcpy(p21, user_passkey(sess->user), CIFS_NTHASH_SIZE); >> + rc = ksmbd_enc_p24(p21, sess->ntlmssp.cryptkey, key); >> + if (rc) { >> + ksmbd_err("password processing failed\n"); >> + return rc; >> + } >> + >> + ksmbd_enc_md4(sess->sess_key, >> + user_passkey(sess->user), >> + CIFS_SMB1_SESSKEY_SIZE); >> + memcpy(sess->sess_key + CIFS_SMB1_SESSKEY_SIZE, key, >> + CIFS_AUTH_RESP_SIZE); >> + sess->sequence_number = 1; >> + >> + if (strncmp(pw_buf, key, CIFS_AUTH_RESP_SIZE) != 0) { >> + ksmbd_debug(AUTH, "ntlmv1 authentication failed\n"); >> + rc = -EINVAL; > > return -EINVAL; > >> + } else { >> + ksmbd_debug(AUTH, "ntlmv1 authentication pass\n"); > > Pull this in one tab. > >> + } >> + >> + return rc; > > > return 0; > >> +} >> + >> +/** >> + * ksmbd_auth_ntlmv2() - NTLMv2 authentication handler >> + * @sess: session of connection >> + * @ntlmv2: NTLMv2 challenge response >> + * @blen: NTLMv2 blob length >> + * @domain_name: domain name >> + * >> + * Return: 0 on success, error number on error >> + */ >> +int ksmbd_auth_ntlmv2(struct ksmbd_session *sess, struct ntlmv2_resp >> *ntlmv2, >> + int blen, char *domain_name) >> +{ >> + char ntlmv2_hash[CIFS_ENCPWD_SIZE]; >> + char ntlmv2_rsp[CIFS_HMAC_MD5_HASH_SIZE]; >> + struct ksmbd_crypto_ctx *ctx; >> + char *construct = NULL; >> + int rc = -EINVAL, len; >> + >> + ctx = ksmbd_crypto_ctx_find_hmacmd5(); >> + if (!ctx) { >> + ksmbd_debug(AUTH, "could not crypto alloc hmacmd5 rc %d\n", rc); >> + goto out; >> + } >> + >> + rc = calc_ntlmv2_hash(sess, ntlmv2_hash, domain_name); >> + if (rc) { >> + ksmbd_debug(AUTH, "could not get v2 hash rc %d\n", rc); >> + goto out; >> + } >> + >> + rc = crypto_shash_setkey(CRYPTO_HMACMD5_TFM(ctx), >> + ntlmv2_hash, >> + CIFS_HMAC_MD5_HASH_SIZE); >> + if (rc) { >> + ksmbd_debug(AUTH, "Could not set NTLMV2 Hash as a key\n"); >> + goto out; >> + } >> + >> + rc = crypto_shash_init(CRYPTO_HMACMD5(ctx)); >> + if (rc) { >> + ksmbd_debug(AUTH, "Could not init hmacmd5\n"); >> + goto out; >> + } >> + >> + len = CIFS_CRYPTO_KEY_SIZE + blen; >> + construct = kzalloc(len, GFP_KERNEL); >> + if (!construct) { >> + rc = -ENOMEM; >> + goto out; >> + } >> + >> + memcpy(construct, sess->ntlmssp.cryptkey, CIFS_CRYPTO_KEY_SIZE); >> + memcpy(construct + CIFS_CRYPTO_KEY_SIZE, >> + (char *)(&ntlmv2->blob_signature), blen); > > No need for this (char *) cast. > >> + >> + rc = crypto_shash_update(CRYPTO_HMACMD5(ctx), construct, len); >> + if (rc) { >> + ksmbd_debug(AUTH, "Could not update with response\n"); >> + goto out; >> + } >> + >> + rc = crypto_shash_final(CRYPTO_HMACMD5(ctx), ntlmv2_rsp); >> + if (rc) { >> + ksmbd_debug(AUTH, "Could not generate md5 hash\n"); >> + goto out; >> + } >> + >> + rc = ksmbd_gen_sess_key(sess, ntlmv2_hash, ntlmv2_rsp); >> + if (rc) { >> + ksmbd_debug(AUTH, "Could not generate sess key\n"); >> + goto out; >> + } >> + >> + rc = memcmp(ntlmv2->ntlmv2_hash, ntlmv2_rsp, CIFS_HMAC_MD5_HASH_SIZE); > > if (memcmp() != 0) > rc = -EINVAL; > > >> +out: >> + ksmbd_release_crypto_ctx(ctx); >> + kfree(construct); >> + return rc; >> +} >> + >> +/** >> + * __ksmbd_auth_ntlmv2() - NTLM2(extended security) authentication >> handler >> + * @sess: session of connection >> + * @client_nonce: client nonce from LM response. >> + * @ntlm_resp: ntlm response data from client. >> + * >> + * Return: 0 on success, error number on error >> + */ >> +static int __ksmbd_auth_ntlmv2(struct ksmbd_session *sess, char >> *client_nonce, >> + char *ntlm_resp) >> +{ >> + char sess_key[CIFS_SMB1_SESSKEY_SIZE] = {0}; >> + int rc; >> + unsigned char p21[21]; >> + char key[CIFS_AUTH_RESP_SIZE]; >> + >> + rc = ksmbd_enc_update_sess_key(sess_key, >> + client_nonce, >> + (char *)sess->ntlmssp.cryptkey, 8); >> + if (rc) { >> + ksmbd_err("password processing failed\n"); >> + goto out; >> + } >> + >> + memset(p21, '\0', 21); >> + memcpy(p21, user_passkey(sess->user), CIFS_NTHASH_SIZE); >> + rc = ksmbd_enc_p24(p21, sess_key, key); >> + if (rc) { >> + ksmbd_err("password processing failed\n"); >> + goto out; >> + } >> + >> + rc = memcmp(ntlm_resp, key, CIFS_AUTH_RESP_SIZE); > > if (memcmp(ntlm_resp, key, CIFS_AUTH_RESP_SIZE) != 0) > rc = -EINVAL; > >> +out: >> + return rc; >> +} >> + >> +/** >> + * ksmbd_decode_ntlmssp_auth_blob() - helper function to construct >> + * authenticate blob >> + * @authblob: authenticate blob source pointer >> + * @usr: user details >> + * @sess: session of connection >> + * >> + * Return: 0 on success, error number on error >> + */ >> +int ksmbd_decode_ntlmssp_auth_blob(struct authenticate_message >> *authblob, >> + int blob_len, struct ksmbd_session *sess) >> +{ >> + char *domain_name; >> + unsigned int lm_off, nt_off; >> + unsigned short nt_len; >> + int ret; >> + >> + if (blob_len < sizeof(struct authenticate_message)) { >> + ksmbd_debug(AUTH, "negotiate blob len %d too small\n", >> + blob_len); >> + return -EINVAL; >> + } >> + >> + if (memcmp(authblob->Signature, "NTLMSSP", 8)) { >> + ksmbd_debug(AUTH, "blob signature incorrect %s\n", >> + authblob->Signature); >> + return -EINVAL; >> + } >> + >> + lm_off = le32_to_cpu(authblob->LmChallengeResponse.BufferOffset); >> + nt_off = le32_to_cpu(authblob->NtChallengeResponse.BufferOffset); >> + nt_len = le16_to_cpu(authblob->NtChallengeResponse.Length); >> + >> + /* process NTLM authentication */ >> + if (nt_len == CIFS_AUTH_RESP_SIZE) { >> + if (le32_to_cpu(authblob->NegotiateFlags) & >> + NTLMSSP_NEGOTIATE_EXTENDED_SEC) >> + return __ksmbd_auth_ntlmv2(sess, (char *)authblob + >> + lm_off, (char *)authblob + nt_off); >> + else >> + return ksmbd_auth_ntlm(sess, (char *)authblob + >> + nt_off); >> + } >> + >> + /* TODO : use domain name that imported from configuration file */ >> + domain_name = smb_strndup_from_utf16((const char *)authblob + >> + le32_to_cpu(authblob->DomainName.BufferOffset), >> + le16_to_cpu(authblob->DomainName.Length), true, >> + sess->conn->local_nls); >> + if (IS_ERR(domain_name)) >> + return PTR_ERR(domain_name); >> + >> + /* process NTLMv2 authentication */ >> + ksmbd_debug(AUTH, "decode_ntlmssp_authenticate_blob dname%s\n", >> + domain_name); >> + ret = ksmbd_auth_ntlmv2(sess, >> + (struct ntlmv2_resp *)((char *)authblob + nt_off), >> + nt_len - CIFS_ENCPWD_SIZE, >> + domain_name); >> + kfree(domain_name); >> + return ret; >> +} >> + >> +/** >> + * ksmbd_decode_ntlmssp_neg_blob() - helper function to construct >> + * negotiate blob >> + * @negblob: negotiate blob source pointer >> + * @rsp: response header pointer to be updated >> + * @sess: session of connection >> + * >> + */ >> +int ksmbd_decode_ntlmssp_neg_blob(struct negotiate_message *negblob, >> + int blob_len, struct ksmbd_session *sess) >> +{ >> + if (blob_len < sizeof(struct negotiate_message)) { >> + ksmbd_debug(AUTH, "negotiate blob len %d too small\n", >> + blob_len); >> + return -EINVAL; >> + } >> + >> + if (memcmp(negblob->Signature, "NTLMSSP", 8)) { >> + ksmbd_debug(AUTH, "blob signature incorrect %s\n", >> + negblob->Signature); >> + return -EINVAL; >> + } >> + >> + sess->ntlmssp.client_flags = le32_to_cpu(negblob->NegotiateFlags); >> + return 0; >> +} >> + >> +/** >> + * ksmbd_build_ntlmssp_challenge_blob() - helper function to construct >> + * challenge blob >> + * @chgblob: challenge blob source pointer to initialize >> + * @rsp: response header pointer to be updated >> + * @sess: session of connection >> + * >> + */ >> +unsigned int >> +ksmbd_build_ntlmssp_challenge_blob(struct challenge_message *chgblob, >> + struct ksmbd_session *sess) >> +{ >> + struct target_info *tinfo; >> + wchar_t *name; >> + __u8 *target_name; >> + unsigned int len, flags, blob_off, blob_len, type, target_info_len = 0; >> + int cflags = sess->ntlmssp.client_flags; >> + >> + memcpy(chgblob->Signature, NTLMSSP_SIGNATURE, 8); >> + chgblob->MessageType = NtLmChallenge; >> + >> + flags = NTLMSSP_NEGOTIATE_UNICODE | >> + NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_TARGET_TYPE_SERVER | >> + NTLMSSP_NEGOTIATE_TARGET_INFO; >> + >> + if (cflags & NTLMSSP_NEGOTIATE_SIGN) { >> + flags |= NTLMSSP_NEGOTIATE_SIGN; >> + flags |= cflags & (NTLMSSP_NEGOTIATE_128 | >> + NTLMSSP_NEGOTIATE_56); > > flags |= cflags & (NTLMSSP_NEGOTIATE_128 | > NTLMSSP_NEGOTIATE_56); > > >> + } >> + >> + if (cflags & NTLMSSP_NEGOTIATE_ALWAYS_SIGN) >> + flags |= NTLMSSP_NEGOTIATE_ALWAYS_SIGN; >> + >> + if (cflags & NTLMSSP_REQUEST_TARGET) >> + flags |= NTLMSSP_REQUEST_TARGET; >> + >> + if (sess->conn->use_spnego && >> + (cflags & NTLMSSP_NEGOTIATE_EXTENDED_SEC)) >> + flags |= NTLMSSP_NEGOTIATE_EXTENDED_SEC; >> + >> + chgblob->NegotiateFlags = cpu_to_le32(flags); >> + len = strlen(ksmbd_netbios_name()); >> + name = kmalloc(2 + (len * 2), GFP_KERNEL); >> + if (!name) >> + return -ENOMEM; >> + >> + len = smb_strtoUTF16((__le16 *)name, ksmbd_netbios_name(), len, >> + sess->conn->local_nls); >> + len = UNICODE_LEN(len); > > The smb_strtoUTF16() already modifies len so multiplying it by two a > second time leads to a buffer overflow? > >> + >> + blob_off = sizeof(struct challenge_message); >> + blob_len = blob_off + len; >> + >> + chgblob->TargetName.Length = cpu_to_le16(len); >> + chgblob->TargetName.MaximumLength = cpu_to_le16(len); >> + chgblob->TargetName.BufferOffset = cpu_to_le32(blob_off); >> + >> + /* Initialize random conn challenge */ >> + get_random_bytes(sess->ntlmssp.cryptkey, sizeof(__u64)); >> + memcpy(chgblob->Challenge, sess->ntlmssp.cryptkey, >> + CIFS_CRYPTO_KEY_SIZE); >> + >> + /* Add Target Information to security buffer */ >> + chgblob->TargetInfoArray.BufferOffset = cpu_to_le32(blob_len); >> + >> + target_name = (__u8 *)chgblob + blob_off; >> + memcpy(target_name, name, len); >> + tinfo = (struct target_info *)(target_name + len); >> + >> + chgblob->TargetInfoArray.Length = 0; >> + /* Add target info list for NetBIOS/DNS settings */ >> + for (type = NTLMSSP_AV_NB_COMPUTER_NAME; >> + type <= NTLMSSP_AV_DNS_DOMAIN_NAME; type++) { > > for (type = NTLMSSP_AV_NB_COMPUTER_NAME; > type <= NTLMSSP_AV_DNS_DOMAIN_NAME; type++) { > > >> + tinfo->Type = cpu_to_le16(type); >> + tinfo->Length = cpu_to_le16(len); >> + memcpy(tinfo->Content, name, len); >> + tinfo = (struct target_info *)((char *)tinfo + 4 + len); >> + target_info_len += 4 + len; >> + } >> + >> + /* Add terminator subblock */ >> + tinfo->Type = 0; >> + tinfo->Length = 0; >> + target_info_len += 4; >> + >> + chgblob->TargetInfoArray.Length = cpu_to_le16(target_info_len); >> + chgblob->TargetInfoArray.MaximumLength = cpu_to_le16(target_info_len); >> + blob_len += target_info_len; >> + kfree(name); >> + ksmbd_debug(AUTH, "NTLMSSP SecurityBufferLength %d\n", blob_len); >> + return blob_len; >> +} >> + >> +#ifdef CONFIG_SMB_SERVER_KERBEROS5 >> +int ksmbd_krb5_authenticate(struct ksmbd_session *sess, char *in_blob, >> + int in_len, char *out_blob, int *out_len) >> +{ >> + struct ksmbd_spnego_authen_response *resp; >> + struct ksmbd_user *user = NULL; >> + int retval; >> + >> + resp = ksmbd_ipc_spnego_authen_request(in_blob, in_len); >> + if (!resp) { >> + ksmbd_debug(AUTH, "SPNEGO_AUTHEN_REQUEST failure\n"); >> + return -EINVAL; >> + } >> + >> + if (!(resp->login_response.status & KSMBD_USER_FLAG_OK)) { >> + ksmbd_debug(AUTH, "krb5 authentication failure\n"); >> + retval = -EPERM; >> + goto out; >> + } >> + >> + if (*out_len <= resp->spnego_blob_len) { >> + ksmbd_debug(AUTH, "buf len %d, but blob len %d\n", >> + *out_len, resp->spnego_blob_len); >> + retval = -EINVAL; >> + goto out; >> + } >> + >> + if (resp->session_key_len > sizeof(sess->sess_key)) { >> + ksmbd_debug(AUTH, "session key is too long\n"); >> + retval = -EINVAL; >> + goto out; >> + } >> + >> + user = ksmbd_alloc_user(&resp->login_response); >> + if (!user) { >> + ksmbd_debug(AUTH, "login failure\n"); >> + retval = -ENOMEM; >> + goto out; >> + } >> + sess->user = user; >> + >> + memcpy(sess->sess_key, resp->payload, resp->session_key_len); >> + memcpy(out_blob, resp->payload + resp->session_key_len, >> + resp->spnego_blob_len); >> + *out_len = resp->spnego_blob_len; >> + retval = 0; >> +out: >> + kvfree(resp); >> + return retval; >> +} >> +#else >> +int ksmbd_krb5_authenticate(struct ksmbd_session *sess, char *in_blob, >> + int in_len, char *out_blob, int *out_len) >> +{ >> + return -EOPNOTSUPP; >> +} >> +#endif >> + >> +/** >> + * ksmbd_sign_smb2_pdu() - function to generate packet signing >> + * @conn: connection >> + * @key: signing key >> + * @iov: buffer iov array >> + * @n_vec: number of iovecs >> + * @sig: signature value generated for client request packet >> + * >> + */ >> +int ksmbd_sign_smb2_pdu(struct ksmbd_conn *conn, char *key, struct kvec >> *iov, >> + int n_vec, char *sig) >> +{ >> + struct ksmbd_crypto_ctx *ctx; >> + int rc = -EINVAL; >> + int i; >> + >> + ctx = ksmbd_crypto_ctx_find_hmacsha256(); >> + if (!ctx) { >> + ksmbd_debug(AUTH, "could not crypto alloc hmacmd5 rc %d\n", rc); >> + goto out; >> + } >> + >> + rc = crypto_shash_setkey(CRYPTO_HMACSHA256_TFM(ctx), >> + key, >> + SMB2_NTLMV2_SESSKEY_SIZE); >> + if (rc) >> + goto out; >> + >> + rc = crypto_shash_init(CRYPTO_HMACSHA256(ctx)); >> + if (rc) { >> + ksmbd_debug(AUTH, "hmacsha256 init error %d\n", rc); >> + goto out; >> + } >> + >> + for (i = 0; i < n_vec; i++) { >> + rc = crypto_shash_update(CRYPTO_HMACSHA256(ctx), >> + iov[i].iov_base, >> + iov[i].iov_len); >> + if (rc) { >> + ksmbd_debug(AUTH, "hmacsha256 update error %d\n", rc); >> + goto out; >> + } >> + } >> + >> + rc = crypto_shash_final(CRYPTO_HMACSHA256(ctx), sig); >> + if (rc) >> + ksmbd_debug(AUTH, "hmacsha256 generation error %d\n", rc); >> +out: >> + ksmbd_release_crypto_ctx(ctx); >> + return rc; >> +} >> + >> +/** >> + * ksmbd_sign_smb3_pdu() - function to generate packet signing >> + * @conn: connection >> + * @key: signing key >> + * @iov: buffer iov array >> + * @n_vec: number of iovecs >> + * @sig: signature value generated for client request packet >> + * >> + */ >> +int ksmbd_sign_smb3_pdu(struct ksmbd_conn *conn, char *key, struct kvec >> *iov, >> + int n_vec, char *sig) >> +{ >> + struct ksmbd_crypto_ctx *ctx; >> + int rc = -EINVAL; >> + int i; >> + >> + ctx = ksmbd_crypto_ctx_find_cmacaes(); >> + if (!ctx) { >> + ksmbd_debug(AUTH, "could not crypto alloc cmac rc %d\n", rc); >> + goto out; >> + } >> + >> + rc = crypto_shash_setkey(CRYPTO_CMACAES_TFM(ctx), >> + key, >> + SMB2_CMACAES_SIZE); >> + if (rc) >> + goto out; >> + >> + rc = crypto_shash_init(CRYPTO_CMACAES(ctx)); >> + if (rc) { >> + ksmbd_debug(AUTH, "cmaces init error %d\n", rc); >> + goto out; >> + } >> + >> + for (i = 0; i < n_vec; i++) { >> + rc = crypto_shash_update(CRYPTO_CMACAES(ctx), >> + iov[i].iov_base, >> + iov[i].iov_len); >> + if (rc) { >> + ksmbd_debug(AUTH, "cmaces update error %d\n", rc); >> + goto out; >> + } >> + } >> + >> + rc = crypto_shash_final(CRYPTO_CMACAES(ctx), sig); >> + if (rc) >> + ksmbd_debug(AUTH, "cmaces generation error %d\n", rc); >> +out: >> + ksmbd_release_crypto_ctx(ctx); >> + return rc; >> +} >> + >> +struct derivation { >> + struct kvec label; >> + struct kvec context; >> + bool binding; >> +}; >> + >> +static int generate_key(struct ksmbd_session *sess, struct kvec label, >> + struct kvec context, __u8 *key, unsigned int key_size) >> +{ >> + unsigned char zero = 0x0; >> + __u8 i[4] = {0, 0, 0, 1}; >> + __u8 L128[4] = {0, 0, 0, 128}; >> + __u8 L256[4] = {0, 0, 1, 0}; >> + int rc = -EINVAL; >> + unsigned char prfhash[SMB2_HMACSHA256_SIZE]; >> + unsigned char *hashptr = prfhash; >> + struct ksmbd_crypto_ctx *ctx; >> + >> + memset(prfhash, 0x0, SMB2_HMACSHA256_SIZE); >> + memset(key, 0x0, key_size); >> + >> + ctx = ksmbd_crypto_ctx_find_hmacsha256(); >> + if (!ctx) { >> + ksmbd_debug(AUTH, "could not crypto alloc hmacmd5 rc %d\n", rc); >> + goto smb3signkey_ret; >> + } >> + >> + rc = crypto_shash_setkey(CRYPTO_HMACSHA256_TFM(ctx), >> + sess->sess_key, >> + SMB2_NTLMV2_SESSKEY_SIZE); >> + if (rc) >> + goto smb3signkey_ret; >> + >> + rc = crypto_shash_init(CRYPTO_HMACSHA256(ctx)); >> + if (rc) { >> + ksmbd_debug(AUTH, "hmacsha256 init error %d\n", rc); >> + goto smb3signkey_ret; >> + } >> + >> + rc = crypto_shash_update(CRYPTO_HMACSHA256(ctx), i, 4); >> + if (rc) { >> + ksmbd_debug(AUTH, "could not update with n\n"); >> + goto smb3signkey_ret; >> + } >> + >> + rc = crypto_shash_update(CRYPTO_HMACSHA256(ctx), >> + label.iov_base, >> + label.iov_len); >> + if (rc) { >> + ksmbd_debug(AUTH, "could not update with label\n"); >> + goto smb3signkey_ret; >> + } >> + >> + rc = crypto_shash_update(CRYPTO_HMACSHA256(ctx), &zero, 1); >> + if (rc) { >> + ksmbd_debug(AUTH, "could not update with zero\n"); >> + goto smb3signkey_ret; >> + } >> + >> + rc = crypto_shash_update(CRYPTO_HMACSHA256(ctx), >> + context.iov_base, >> + context.iov_len); >> + if (rc) { >> + ksmbd_debug(AUTH, "could not update with context\n"); >> + goto smb3signkey_ret; >> + } >> + >> + if (sess->conn->cipher_type == SMB2_ENCRYPTION_AES256_CCM || >> + sess->conn->cipher_type == SMB2_ENCRYPTION_AES256_GCM) >> + rc = crypto_shash_update(CRYPTO_HMACSHA256(ctx), L256, 4); >> + else >> + rc = crypto_shash_update(CRYPTO_HMACSHA256(ctx), L128, 4); >> + if (rc) { >> + ksmbd_debug(AUTH, "could not update with L\n"); >> + goto smb3signkey_ret; >> + } >> + >> + rc = crypto_shash_final(CRYPTO_HMACSHA256(ctx), hashptr); >> + if (rc) { >> + ksmbd_debug(AUTH, "Could not generate hmacmd5 hash error %d\n", >> + rc); >> + goto smb3signkey_ret; >> + } >> + >> + memcpy(key, hashptr, key_size); >> + >> +smb3signkey_ret: >> + ksmbd_release_crypto_ctx(ctx); >> + return rc; >> +} >> + >> +static int generate_smb3signingkey(struct ksmbd_session *sess, >> + const struct derivation *signing) >> +{ >> + int rc; >> + struct channel *chann; >> + char *key; >> + >> + chann = lookup_chann_list(sess); >> + if (!chann) >> + return 0; >> + >> + if (sess->conn->dialect >= SMB30_PROT_ID && signing->binding) >> + key = chann->smb3signingkey; >> + else >> + key = sess->smb3signingkey; >> + >> + rc = generate_key(sess, signing->label, signing->context, key, >> + SMB3_SIGN_KEY_SIZE); >> + if (rc) >> + return rc; >> + >> + if (!(sess->conn->dialect >= SMB30_PROT_ID && signing->binding)) >> + memcpy(chann->smb3signingkey, key, SMB3_SIGN_KEY_SIZE); >> + >> + ksmbd_debug(AUTH, "dumping generated AES signing keys\n"); >> + ksmbd_debug(AUTH, "Session Id %llu\n", sess->id); >> + ksmbd_debug(AUTH, "Session Key %*ph\n", >> + SMB2_NTLMV2_SESSKEY_SIZE, sess->sess_key); >> + ksmbd_debug(AUTH, "Signing Key %*ph\n", >> + SMB3_SIGN_KEY_SIZE, key); >> + return rc; > > return 0; > >> +} >> + >> +int ksmbd_gen_smb30_signingkey(struct ksmbd_session *sess) >> +{ >> + struct derivation d; >> + >> + d.label.iov_base = "SMB2AESCMAC"; >> + d.label.iov_len = 12; >> + d.context.iov_base = "SmbSign"; >> + d.context.iov_len = 8; >> + d.binding = false; >> + >> + return generate_smb3signingkey(sess, &d); >> +} >> + >> +int ksmbd_gen_smb311_signingkey(struct ksmbd_session *sess) >> +{ >> + struct derivation d; >> + >> + d.label.iov_base = "SMBSigningKey"; >> + d.label.iov_len = 14; >> + d.context.iov_base = sess->Preauth_HashValue; >> + d.context.iov_len = 64; >> + d.binding = false; >> + >> + return generate_smb3signingkey(sess, &d); >> +} >> + >> +struct derivation_twin { >> + struct derivation encryption; >> + struct derivation decryption; >> +}; >> + >> +static int generate_smb3encryptionkey(struct ksmbd_session *sess, >> + const struct derivation_twin *ptwin) >> +{ >> + int rc; >> + >> + rc = generate_key(sess, ptwin->encryption.label, >> + ptwin->encryption.context, sess->smb3encryptionkey, >> + SMB3_ENC_DEC_KEY_SIZE); >> + if (rc) >> + return rc; >> + >> + rc = generate_key(sess, ptwin->decryption.label, >> + ptwin->decryption.context, >> + sess->smb3decryptionkey, SMB3_ENC_DEC_KEY_SIZE); >> + if (rc) >> + return rc; >> + >> + ksmbd_debug(AUTH, "dumping generated AES encryption keys\n"); >> + ksmbd_debug(AUTH, "Cipher type %d\n", sess->conn->cipher_type); >> + ksmbd_debug(AUTH, "Session Id %llu\n", sess->id); >> + ksmbd_debug(AUTH, "Session Key %*ph\n", >> + SMB2_NTLMV2_SESSKEY_SIZE, sess->sess_key); >> + if (sess->conn->cipher_type == SMB2_ENCRYPTION_AES256_CCM || >> + sess->conn->cipher_type == SMB2_ENCRYPTION_AES256_GCM) { >> + ksmbd_debug(AUTH, "ServerIn Key %*ph\n", >> + SMB3_GCM256_CRYPTKEY_SIZE, sess->smb3encryptionkey); >> + ksmbd_debug(AUTH, "ServerOut Key %*ph\n", >> + SMB3_GCM256_CRYPTKEY_SIZE, sess->smb3decryptionkey); >> + } else { >> + ksmbd_debug(AUTH, "ServerIn Key %*ph\n", >> + SMB3_GCM128_CRYPTKEY_SIZE, sess->smb3encryptionkey); >> + ksmbd_debug(AUTH, "ServerOut Key %*ph\n", >> + SMB3_GCM128_CRYPTKEY_SIZE, sess->smb3decryptionkey); >> + } >> + return rc; > > return 0; > >> +} >> + >> +int ksmbd_gen_smb30_encryptionkey(struct ksmbd_session *sess) >> +{ >> + struct derivation_twin twin; >> + struct derivation *d; >> + >> + d = &twin.encryption; >> + d->label.iov_base = "SMB2AESCCM"; >> + d->label.iov_len = 11; >> + d->context.iov_base = "ServerOut"; >> + d->context.iov_len = 10; >> + >> + d = &twin.decryption; >> + d->label.iov_base = "SMB2AESCCM"; >> + d->label.iov_len = 11; >> + d->context.iov_base = "ServerIn "; >> + d->context.iov_len = 10; >> + >> + return generate_smb3encryptionkey(sess, &twin); >> +} >> + >> +int ksmbd_gen_smb311_encryptionkey(struct ksmbd_session *sess) >> +{ >> + struct derivation_twin twin; >> + struct derivation *d; >> + >> + d = &twin.encryption; >> + d->label.iov_base = "SMBS2CCipherKey"; >> + d->label.iov_len = 16; >> + d->context.iov_base = sess->Preauth_HashValue; >> + d->context.iov_len = 64; >> + >> + d = &twin.decryption; >> + d->label.iov_base = "SMBC2SCipherKey"; >> + d->label.iov_len = 16; >> + d->context.iov_base = sess->Preauth_HashValue; >> + d->context.iov_len = 64; >> + >> + return generate_smb3encryptionkey(sess, &twin); >> +} >> + >> +int ksmbd_gen_preauth_integrity_hash(struct ksmbd_conn *conn, char *buf, >> + __u8 *pi_hash) >> +{ >> + int rc = -1; > > > int rc = -EINVAL; > >> + struct smb2_hdr *rcv_hdr = (struct smb2_hdr *)buf; >> + char *all_bytes_msg = (char *)&rcv_hdr->ProtocolId; >> + int msg_size = be32_to_cpu(rcv_hdr->smb2_buf_length); >> + struct ksmbd_crypto_ctx *ctx = NULL; >> + >> + if (conn->preauth_info->Preauth_HashId == >> + SMB2_PREAUTH_INTEGRITY_SHA512) { > > Flip this condition around: > > if (conn->preauth_info->Preauth_HashId != > SMB2_PREAUTH_INTEGRITY_SHA512) > return -EINVAL; > > >> + ctx = ksmbd_crypto_ctx_find_sha512(); >> + if (!ctx) { >> + ksmbd_debug(AUTH, "could not alloc sha512 rc %d\n", rc); >> + goto out; >> + } > > Pull this code in a tab. > >> + } else { >> + goto out; >> + } >> + >> + rc = crypto_shash_init(CRYPTO_SHA512(ctx)); >> + if (rc) { >> + ksmbd_debug(AUTH, "could not init shashn"); >> + goto out; >> + } >> + >> + rc = crypto_shash_update(CRYPTO_SHA512(ctx), pi_hash, 64); >> + if (rc) { >> + ksmbd_debug(AUTH, "could not update with n\n"); >> + goto out; >> + } >> + >> + rc = crypto_shash_update(CRYPTO_SHA512(ctx), all_bytes_msg, msg_size); >> + if (rc) { >> + ksmbd_debug(AUTH, "could not update with n\n"); >> + goto out; >> + } >> + >> + rc = crypto_shash_final(CRYPTO_SHA512(ctx), pi_hash); >> + if (rc) { >> + ksmbd_debug(AUTH, "Could not generate hash err : %d\n", rc); >> + goto out; >> + } >> +out: >> + ksmbd_release_crypto_ctx(ctx); >> + return rc; >> +} >> + >> +int ksmbd_gen_sd_hash(struct ksmbd_conn *conn, char *sd_buf, int len, >> + __u8 *pi_hash) >> +{ >> + int rc = -1; > > int rc = -EINVAL; > >> + struct ksmbd_crypto_ctx *ctx = NULL; >> + >> + ctx = ksmbd_crypto_ctx_find_sha256(); >> + if (!ctx) { >> + ksmbd_debug(AUTH, "could not alloc sha256 rc %d\n", rc); >> + goto out; >> + } >> + >> + rc = crypto_shash_init(CRYPTO_SHA256(ctx)); >> + if (rc) { >> + ksmbd_debug(AUTH, "could not init shashn"); >> + goto out; >> + } >> + >> + rc = crypto_shash_update(CRYPTO_SHA256(ctx), sd_buf, len); >> + if (rc) { >> + ksmbd_debug(AUTH, "could not update with n\n"); >> + goto out; >> + } >> + >> + rc = crypto_shash_final(CRYPTO_SHA256(ctx), pi_hash); >> + if (rc) { >> + ksmbd_debug(AUTH, "Could not generate hash err : %d\n", rc); >> + goto out; >> + } >> +out: >> + ksmbd_release_crypto_ctx(ctx); >> + return rc; >> +} >> + >> +static int ksmbd_get_encryption_key(struct ksmbd_conn *conn, __u64 >> ses_id, >> + int enc, u8 *key) >> +{ >> + struct ksmbd_session *sess; >> + u8 *ses_enc_key; >> + >> + sess = ksmbd_session_lookup(conn, ses_id); >> + if (!sess) >> + return 1; > > Please never return 1 on failure... :/ return -EINVAL; > >> + >> + ses_enc_key = enc ? sess->smb3encryptionkey : >> + sess->smb3decryptionkey; >> + memcpy(key, ses_enc_key, SMB3_ENC_DEC_KEY_SIZE); >> + >> + return 0; >> +} >> + >> +static inline void smb2_sg_set_buf(struct scatterlist *sg, const void >> *buf, >> + unsigned int buflen) >> +{ >> + void *addr; >> + >> + if (is_vmalloc_addr(buf)) >> + addr = vmalloc_to_page(buf); >> + else >> + addr = virt_to_page(buf); >> + sg_set_page(sg, addr, buflen, offset_in_page(buf)); >> +} >> + >> +static struct scatterlist *ksmbd_init_sg(struct kvec *iov, unsigned int >> nvec, >> + u8 *sign) >> +{ >> + struct scatterlist *sg; >> + unsigned int assoc_data_len = sizeof(struct smb2_transform_hdr) - 24; >> + int i, nr_entries[3] = {0}, total_entries = 0, sg_idx = 0; >> + >> + for (i = 0; i < nvec - 1; i++) { > > If "nvec" is zero this loop will corrupt memory until the system > crashes. > >> + unsigned long kaddr = (unsigned long)iov[i + 1].iov_base; >> + >> + if (is_vmalloc_addr(iov[i + 1].iov_base)) { >> + nr_entries[i] = ((kaddr + iov[i + 1].iov_len + >> + PAGE_SIZE - 1) >> PAGE_SHIFT) - >> + (kaddr >> PAGE_SHIFT); >> + } else { >> + nr_entries[i]++; >> + } >> + total_entries += nr_entries[i]; >> + } >> + >> + /* Add two entries for transform header and signature */ >> + total_entries += 2; >> + >> + sg = kmalloc_array(total_entries, sizeof(struct scatterlist), >> GFP_KERNEL); >> + if (!sg) >> + return NULL; >> + >> + sg_init_table(sg, total_entries); >> + smb2_sg_set_buf(&sg[sg_idx++], iov[0].iov_base + 24, assoc_data_len); >> + for (i = 0; i < nvec - 1; i++) { >> + void *data = iov[i + 1].iov_base; >> + int len = iov[i + 1].iov_len; >> + >> + if (is_vmalloc_addr(data)) { >> + int j, offset = offset_in_page(data); >> + >> + for (j = 0; j < nr_entries[i]; j++) { >> + unsigned int bytes = PAGE_SIZE - offset; >> + >> + if (len <= 0) >> + break; > > Can "len" really be negative here? That can't be good at all... > >> + >> + if (bytes > len) >> + bytes = len; >> + >> + sg_set_page(&sg[sg_idx++], >> + vmalloc_to_page(data), bytes, >> + offset_in_page(data)); >> + >> + data += bytes; >> + len -= bytes; >> + offset = 0; >> + } >> + } else { >> + sg_set_page(&sg[sg_idx++], virt_to_page(data), len, >> + offset_in_page(data)); >> + } >> + } >> + smb2_sg_set_buf(&sg[sg_idx], sign, SMB2_SIGNATURE_SIZE); >> + return sg; >> +} >> + >> +int ksmbd_crypt_message(struct ksmbd_conn *conn, struct kvec *iov, >> + unsigned int nvec, int enc) >> +{ >> + struct smb2_transform_hdr *tr_hdr = >> + (struct smb2_transform_hdr *)iov[0].iov_base; >> + unsigned int assoc_data_len = sizeof(struct smb2_transform_hdr) - 24; >> + int rc = 0; > > No need. > >> + struct scatterlist *sg; >> + u8 sign[SMB2_SIGNATURE_SIZE] = {}; >> + u8 key[SMB3_ENC_DEC_KEY_SIZE]; >> + struct aead_request *req; >> + char *iv; >> + unsigned int iv_len; >> + struct crypto_aead *tfm; >> + unsigned int crypt_len = le32_to_cpu(tr_hdr->OriginalMessageSize); >> + struct ksmbd_crypto_ctx *ctx; >> + >> + rc = ksmbd_get_encryption_key(conn, >> + le64_to_cpu(tr_hdr->SessionId), >> + enc, >> + key); >> + if (rc) { >> + ksmbd_err("Could not get %scryption key\n", enc ? "en" : "de"); >> + return 0; > > Please add a comment why this is a return 0. > >> + } >> + >> + if (conn->cipher_type == SMB2_ENCRYPTION_AES128_GCM || >> + conn->cipher_type == SMB2_ENCRYPTION_AES256_GCM) >> + ctx = ksmbd_crypto_ctx_find_gcm(); >> + else >> + ctx = ksmbd_crypto_ctx_find_ccm(); >> + if (!ctx) { >> + ksmbd_err("crypto alloc failed\n"); >> + return -EINVAL; >> + } >> + >> + if (conn->cipher_type == SMB2_ENCRYPTION_AES128_GCM || >> + conn->cipher_type == SMB2_ENCRYPTION_AES256_GCM) >> + tfm = CRYPTO_GCM(ctx); >> + else >> + tfm = CRYPTO_CCM(ctx); >> + >> + if (conn->cipher_type == SMB2_ENCRYPTION_AES256_CCM || >> + conn->cipher_type == SMB2_ENCRYPTION_AES256_GCM) >> + rc = crypto_aead_setkey(tfm, key, SMB3_GCM256_CRYPTKEY_SIZE); >> + else >> + rc = crypto_aead_setkey(tfm, key, SMB3_GCM128_CRYPTKEY_SIZE); >> + if (rc) { >> + ksmbd_err("Failed to set aead key %d\n", rc); >> + goto free_ctx; >> + } >> + >> + rc = crypto_aead_setauthsize(tfm, SMB2_SIGNATURE_SIZE); >> + if (rc) { >> + ksmbd_err("Failed to set authsize %d\n", rc); >> + goto free_ctx; >> + } >> + >> + req = aead_request_alloc(tfm, GFP_KERNEL); >> + if (!req) { >> + ksmbd_err("Failed to alloc aead request\n"); >> + rc = -ENOMEM; >> + goto free_ctx; >> + } >> + >> + if (!enc) { >> + memcpy(sign, &tr_hdr->Signature, SMB2_SIGNATURE_SIZE); >> + crypt_len += SMB2_SIGNATURE_SIZE; >> + } >> + >> + sg = ksmbd_init_sg(iov, nvec, sign); >> + if (!sg) { >> + ksmbd_err("Failed to init sg\n"); >> + rc = -ENOMEM; >> + goto free_req; >> + } >> + >> + iv_len = crypto_aead_ivsize(tfm); >> + iv = kzalloc(iv_len, GFP_KERNEL); >> + if (!iv) { >> + ksmbd_err("Failed to alloc IV\n"); >> + rc = -ENOMEM; >> + goto free_sg; >> + } >> + >> + if (conn->cipher_type == SMB2_ENCRYPTION_AES128_GCM || >> + conn->cipher_type == SMB2_ENCRYPTION_AES256_GCM) { >> + memcpy(iv, (char *)tr_hdr->Nonce, SMB3_AES_GCM_NONCE); >> + } else { >> + iv[0] = 3; >> + memcpy(iv + 1, (char *)tr_hdr->Nonce, SMB3_AES_CCM_NONCE); >> + } >> + >> + aead_request_set_crypt(req, sg, sg, crypt_len, iv); >> + aead_request_set_ad(req, assoc_data_len); >> + aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_SLEEP, NULL, NULL); >> + >> + if (enc) >> + rc = crypto_aead_encrypt(req); >> + else >> + rc = crypto_aead_decrypt(req); >> + if (!rc && enc) >> + memcpy(&tr_hdr->Signature, sign, SMB2_SIGNATURE_SIZE); > > Always do failure handling. Don't do sucess handling. Keep the success > path at indent level one. Don't make the last function call special. > > if (enc) > rc = crypto_aead_encrypt(req); > else > rc = crypto_aead_decrypt(req); > if (rc) > goto free_iv; > > if (enc) > memcpy(&tr_hdr->Signature, sign, SMB2_SIGNATURE_SIZE); > > free_iv: > kfree(iv); > >> + >> + kfree(iv); >> +free_sg: >> + kfree(sg); >> +free_req: >> + kfree(req); >> +free_ctx: >> + ksmbd_release_crypto_ctx(ctx); >> + return rc; >> +} >> diff --git a/fs/cifsd/auth.h b/fs/cifsd/auth.h >> new file mode 100644 >> index 000000000000..6fcfad5e7e1f >> --- /dev/null >> +++ b/fs/cifsd/auth.h >> @@ -0,0 +1,90 @@ >> +/* SPDX-License-Identifier: GPL-2.0-or-later */ >> +/* >> + * Copyright (C) 2018 Samsung Electronics Co., Ltd. >> + */ >> + >> +#ifndef __AUTH_H__ >> +#define __AUTH_H__ >> + >> +#include "ntlmssp.h" >> + >> +#ifdef CONFIG_SMB_SERVER_KERBEROS5 >> +#define AUTH_GSS_LENGTH 96 >> +#define AUTH_GSS_PADDING 0 >> +#else >> +#define AUTH_GSS_LENGTH 74 >> +#define AUTH_GSS_PADDING 6 >> +#endif >> + >> +#define CIFS_HMAC_MD5_HASH_SIZE (16) >> +#define CIFS_NTHASH_SIZE (16) >> + >> +/* >> + * Size of the ntlm client response >> + */ >> +#define CIFS_AUTH_RESP_SIZE 24 >> +#define CIFS_SMB1_SIGNATURE_SIZE 8 >> +#define CIFS_SMB1_SESSKEY_SIZE 16 >> + >> +#define KSMBD_AUTH_NTLMSSP 0x0001 >> +#define KSMBD_AUTH_KRB5 0x0002 >> +#define KSMBD_AUTH_MSKRB5 0x0004 >> +#define KSMBD_AUTH_KRB5U2U 0x0008 >> + >> +struct ksmbd_session; >> +struct ksmbd_conn; >> +struct kvec; >> + >> +int ksmbd_crypt_message(struct ksmbd_conn *conn, >> + struct kvec *iov, >> + unsigned int nvec, >> + int enc); >> + >> +void ksmbd_copy_gss_neg_header(void *buf); >> + >> +int ksmbd_auth_ntlm(struct ksmbd_session *sess, >> + char *pw_buf); >> + >> +int ksmbd_auth_ntlmv2(struct ksmbd_session *sess, >> + struct ntlmv2_resp *ntlmv2, >> + int blen, >> + char *domain_name); >> + >> +int ksmbd_decode_ntlmssp_auth_blob(struct authenticate_message >> *authblob, >> + int blob_len, >> + struct ksmbd_session *sess); >> + >> +int ksmbd_decode_ntlmssp_neg_blob(struct negotiate_message *negblob, >> + int blob_len, >> + struct ksmbd_session *sess); >> + >> +unsigned int >> +ksmbd_build_ntlmssp_challenge_blob(struct challenge_message *chgblob, >> + struct ksmbd_session *sess); >> + >> +int ksmbd_krb5_authenticate(struct ksmbd_session *sess, >> + char *in_blob, int in_len, >> + char *out_blob, int *out_len); >> + >> +int ksmbd_sign_smb2_pdu(struct ksmbd_conn *conn, >> + char *key, >> + struct kvec *iov, >> + int n_vec, >> + char *sig); >> +int ksmbd_sign_smb3_pdu(struct ksmbd_conn *conn, >> + char *key, >> + struct kvec *iov, >> + int n_vec, >> + char *sig); >> + >> +int ksmbd_gen_smb30_signingkey(struct ksmbd_session *sess); >> +int ksmbd_gen_smb311_signingkey(struct ksmbd_session *sess); >> +int ksmbd_gen_smb30_encryptionkey(struct ksmbd_session *sess); >> +int ksmbd_gen_smb311_encryptionkey(struct ksmbd_session *sess); >> + >> +int ksmbd_gen_preauth_integrity_hash(struct ksmbd_conn *conn, >> + char *buf, >> + __u8 *pi_hash); >> +int ksmbd_gen_sd_hash(struct ksmbd_conn *conn, char *sd_buf, int len, >> + __u8 *pi_hash); >> +#endif >> diff --git a/fs/cifsd/crypto_ctx.c b/fs/cifsd/crypto_ctx.c >> new file mode 100644 >> index 000000000000..1830ae1b5ed3 >> --- /dev/null >> +++ b/fs/cifsd/crypto_ctx.c >> @@ -0,0 +1,286 @@ >> +// SPDX-License-Identifier: GPL-2.0-or-later >> +/* >> + * Copyright (C) 2019 Samsung Electronics Co., Ltd. >> + */ >> + >> +#include <linux/kernel.h> >> +#include <linux/string.h> >> +#include <linux/err.h> >> +#include <linux/slab.h> >> +#include <linux/wait.h> >> +#include <linux/sched.h> >> + >> +#include "glob.h" >> +#include "crypto_ctx.h" >> +#include "buffer_pool.h" >> + >> +struct crypto_ctx_list { >> + spinlock_t ctx_lock; >> + int avail_ctx; >> + struct list_head idle_ctx; >> + wait_queue_head_t ctx_wait; >> +}; >> + >> +static struct crypto_ctx_list ctx_list; >> + >> +static inline void free_aead(struct crypto_aead *aead) >> +{ >> + if (aead) >> + crypto_free_aead(aead); >> +} >> + >> +static void free_shash(struct shash_desc *shash) >> +{ >> + if (shash) { >> + crypto_free_shash(shash->tfm); >> + kfree(shash); >> + } >> +} >> + >> +static struct crypto_aead *alloc_aead(int id) >> +{ >> + struct crypto_aead *tfm = NULL; >> + >> + switch (id) { >> + case CRYPTO_AEAD_AES_GCM: >> + tfm = crypto_alloc_aead("gcm(aes)", 0, 0); >> + break; >> + case CRYPTO_AEAD_AES_CCM: >> + tfm = crypto_alloc_aead("ccm(aes)", 0, 0); >> + break; >> + default: >> + ksmbd_err("Does not support encrypt ahead(id : %d)\n", id); >> + return NULL; >> + } >> + >> + if (IS_ERR(tfm)) { >> + ksmbd_err("Failed to alloc encrypt aead : %ld\n", PTR_ERR(tfm)); >> + return NULL; >> + } >> + >> + return tfm; >> +} >> + >> +static struct shash_desc *alloc_shash_desc(int id) >> +{ >> + struct crypto_shash *tfm = NULL; >> + struct shash_desc *shash; >> + >> + switch (id) { >> + case CRYPTO_SHASH_HMACMD5: >> + tfm = crypto_alloc_shash("hmac(md5)", 0, 0); >> + break; >> + case CRYPTO_SHASH_HMACSHA256: >> + tfm = crypto_alloc_shash("hmac(sha256)", 0, 0); >> + break; >> + case CRYPTO_SHASH_CMACAES: >> + tfm = crypto_alloc_shash("cmac(aes)", 0, 0); >> + break; >> + case CRYPTO_SHASH_SHA256: >> + tfm = crypto_alloc_shash("sha256", 0, 0); >> + break; >> + case CRYPTO_SHASH_SHA512: >> + tfm = crypto_alloc_shash("sha512", 0, 0); >> + break; >> + case CRYPTO_SHASH_MD4: >> + tfm = crypto_alloc_shash("md4", 0, 0); >> + break; >> + case CRYPTO_SHASH_MD5: >> + tfm = crypto_alloc_shash("md5", 0, 0); >> + break; > > No default path. > >> + } >> + >> + if (IS_ERR(tfm)) >> + return NULL; >> + >> + shash = kzalloc(sizeof(*shash) + crypto_shash_descsize(tfm), >> + GFP_KERNEL); >> + if (!shash) >> + crypto_free_shash(tfm); >> + else >> + shash->tfm = tfm; >> + return shash; >> +} >> + >> +static struct ksmbd_crypto_ctx *ctx_alloc(void) >> +{ >> + return kzalloc(sizeof(struct ksmbd_crypto_ctx), GFP_KERNEL); >> +} > > Delete this function. Call kzalloc() directly. > >> + >> +static void ctx_free(struct ksmbd_crypto_ctx *ctx) > > regards, > dan carpenter > > > _______________________________________________ > Linux-cifsd-devel mailing list > Linux-cifsd-devel@lists.sourceforge.net > https://lists.sourceforge.net/lists/listinfo/linux-cifsd-devel > ^ permalink raw reply [flat|nested] 11+ messages in thread
[parent not found: <CGME20210521063557epcas1p20d8b4fc461f05c1a9c638605e85adbd8@epcas1p2.samsung.com>]
* [PATCH v3 07/10] cifsd: add oplock/lease cache mechanism [not found] ` <CGME20210521063557epcas1p20d8b4fc461f05c1a9c638605e85adbd8@epcas1p2.samsung.com> @ 2021-05-21 6:26 ` Namjae Jeon 0 siblings, 0 replies; 11+ messages in thread From: Namjae Jeon @ 2021-05-21 6:26 UTC (permalink / raw) To: linux-fsdevel, linux-kernel, linux-cifs Cc: linux-cifsd-devel, smfrench, senozhatsky, hyc.lee, viro, hch, hch, ronniesahlberg, aurelien.aptel, aaptel, sandeen, dan.carpenter, willy, Namjae Jeon, Sergey Senozhatsky, Steve French This adds oplock and lease cache mechanism. Signed-off-by: Namjae Jeon <namjae.jeon@samsung.com> Signed-off-by: Sergey Senozhatsky <sergey.senozhatsky@gmail.com> Signed-off-by: Hyunchul Lee <hyc.lee@gmail.com> Acked-by: Ronnie Sahlberg <lsahlber@redhat.com> Signed-off-by: Steve French <stfrench@microsoft.com> --- fs/cifsd/oplock.c | 1667 +++++++++++++++++++++++++++++++++++++++++++++ fs/cifsd/oplock.h | 133 ++++ 2 files changed, 1800 insertions(+) create mode 100644 fs/cifsd/oplock.c create mode 100644 fs/cifsd/oplock.h diff --git a/fs/cifsd/oplock.c b/fs/cifsd/oplock.c new file mode 100644 index 000000000000..e77f1385a8c1 --- /dev/null +++ b/fs/cifsd/oplock.c @@ -0,0 +1,1667 @@ +// 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/moduleparam.h> + +#include "glob.h" +#include "oplock.h" + +#include "smb_common.h" +#include "smbstatus.h" +#include "buffer_pool.h" +#include "connection.h" +#include "mgmt/user_session.h" +#include "mgmt/share_config.h" +#include "mgmt/tree_connect.h" + +static LIST_HEAD(lease_table_list); +static DEFINE_RWLOCK(lease_list_lock); + +/** + * alloc_opinfo() - allocate a new opinfo object for oplock info + * @work: smb work + * @id: fid of open file + * @Tid: tree id of connection + * + * Return: allocated opinfo object on success, otherwise NULL + */ +static struct oplock_info *alloc_opinfo(struct ksmbd_work *work, + u64 id, __u16 Tid) +{ + struct ksmbd_session *sess = work->sess; + struct oplock_info *opinfo; + + opinfo = kzalloc(sizeof(struct oplock_info), GFP_KERNEL); + if (!opinfo) + return NULL; + + opinfo->sess = sess; + opinfo->conn = sess->conn; + opinfo->level = OPLOCK_NONE; + opinfo->op_state = OPLOCK_STATE_NONE; + opinfo->pending_break = 0; + opinfo->fid = id; + opinfo->Tid = Tid; + INIT_LIST_HEAD(&opinfo->op_entry); + INIT_LIST_HEAD(&opinfo->interim_list); + init_waitqueue_head(&opinfo->oplock_q); + init_waitqueue_head(&opinfo->oplock_brk); + atomic_set(&opinfo->refcount, 1); + atomic_set(&opinfo->breaking_cnt, 0); + + return opinfo; +} + +static void lease_add_list(struct oplock_info *opinfo) +{ + struct lease_table *lb = opinfo->o_lease->l_lb; + + spin_lock(&lb->lb_lock); + list_add_rcu(&opinfo->lease_entry, &lb->lease_list); + spin_unlock(&lb->lb_lock); +} + +static void lease_del_list(struct oplock_info *opinfo) +{ + struct lease_table *lb = opinfo->o_lease->l_lb; + + if (!lb) + return; + + spin_lock(&lb->lb_lock); + if (list_empty(&opinfo->lease_entry)) { + spin_unlock(&lb->lb_lock); + return; + } + + list_del_init(&opinfo->lease_entry); + opinfo->o_lease->l_lb = NULL; + spin_unlock(&lb->lb_lock); +} + +static void lb_add(struct lease_table *lb) +{ + write_lock(&lease_list_lock); + list_add(&lb->l_entry, &lease_table_list); + write_unlock(&lease_list_lock); +} + +static int alloc_lease(struct oplock_info *opinfo, struct lease_ctx_info *lctx) +{ + struct lease *lease; + + lease = kmalloc(sizeof(struct lease), GFP_KERNEL); + if (!lease) + return -ENOMEM; + + memcpy(lease->lease_key, lctx->lease_key, SMB2_LEASE_KEY_SIZE); + lease->state = lctx->req_state; + lease->new_state = 0; + lease->flags = lctx->flags; + lease->duration = lctx->duration; + INIT_LIST_HEAD(&opinfo->lease_entry); + opinfo->o_lease = lease; + + return 0; +} + +static void free_lease(struct oplock_info *opinfo) +{ + struct lease *lease; + + lease = opinfo->o_lease; + kfree(lease); +} + +static void free_opinfo(struct oplock_info *opinfo) +{ + if (opinfo->is_lease) + free_lease(opinfo); + kfree(opinfo); +} + +static inline void opinfo_free_rcu(struct rcu_head *rcu_head) +{ + struct oplock_info *opinfo; + + opinfo = container_of(rcu_head, struct oplock_info, rcu_head); + free_opinfo(opinfo); +} + +struct oplock_info *opinfo_get(struct ksmbd_file *fp) +{ + struct oplock_info *opinfo; + + rcu_read_lock(); + opinfo = rcu_dereference(fp->f_opinfo); + if (opinfo && !atomic_inc_not_zero(&opinfo->refcount)) + opinfo = NULL; + rcu_read_unlock(); + + return opinfo; +} + +static struct oplock_info *opinfo_get_list(struct ksmbd_inode *ci) +{ + struct oplock_info *opinfo; + + if (list_empty(&ci->m_op_list)) + return NULL; + + rcu_read_lock(); + opinfo = list_first_or_null_rcu(&ci->m_op_list, struct oplock_info, + op_entry); + if (opinfo && !atomic_inc_not_zero(&opinfo->refcount)) + opinfo = NULL; + rcu_read_unlock(); + + return opinfo; +} + +void opinfo_put(struct oplock_info *opinfo) +{ + if (!atomic_dec_and_test(&opinfo->refcount)) + return; + + call_rcu(&opinfo->rcu_head, opinfo_free_rcu); +} + +static void opinfo_add(struct oplock_info *opinfo) +{ + struct ksmbd_inode *ci = opinfo->o_fp->f_ci; + + write_lock(&ci->m_lock); + list_add_rcu(&opinfo->op_entry, &ci->m_op_list); + write_unlock(&ci->m_lock); +} + +static void opinfo_del(struct oplock_info *opinfo) +{ + struct ksmbd_inode *ci = opinfo->o_fp->f_ci; + + if (opinfo->is_lease) { + write_lock(&lease_list_lock); + lease_del_list(opinfo); + write_unlock(&lease_list_lock); + } + write_lock(&ci->m_lock); + list_del_rcu(&opinfo->op_entry); + write_unlock(&ci->m_lock); +} + +static unsigned long opinfo_count(struct ksmbd_file *fp) +{ + if (ksmbd_stream_fd(fp)) + return atomic_read(&fp->f_ci->sop_count); + else + return atomic_read(&fp->f_ci->op_count); +} + +static void opinfo_count_inc(struct ksmbd_file *fp) +{ + if (ksmbd_stream_fd(fp)) + return atomic_inc(&fp->f_ci->sop_count); + else + return atomic_inc(&fp->f_ci->op_count); +} + +static void opinfo_count_dec(struct ksmbd_file *fp) +{ + if (ksmbd_stream_fd(fp)) + return atomic_dec(&fp->f_ci->sop_count); + else + return atomic_dec(&fp->f_ci->op_count); +} + +/** + * opinfo_write_to_read() - convert a write oplock to read oplock + * @opinfo: current oplock info + * + * Return: 0 on success, otherwise -EINVAL + */ +int opinfo_write_to_read(struct oplock_info *opinfo) +{ + struct lease *lease = opinfo->o_lease; + + if (!(opinfo->level == SMB2_OPLOCK_LEVEL_BATCH || + opinfo->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE)) { + ksmbd_err("bad oplock(0x%x)\n", opinfo->level); + if (opinfo->is_lease) + ksmbd_err("lease state(0x%x)\n", lease->state); + return -EINVAL; + } + opinfo->level = SMB2_OPLOCK_LEVEL_II; + + if (opinfo->is_lease) + lease->state = lease->new_state; + return 0; +} + +/** + * opinfo_read_handle_to_read() - convert a read/handle oplock to read oplock + * @opinfo: current oplock info + * + * Return: 0 on success, otherwise -EINVAL + */ +int opinfo_read_handle_to_read(struct oplock_info *opinfo) +{ + struct lease *lease = opinfo->o_lease; + + lease->state = lease->new_state; + opinfo->level = SMB2_OPLOCK_LEVEL_II; + return 0; +} + +/** + * opinfo_write_to_none() - convert a write oplock to none + * @opinfo: current oplock info + * + * Return: 0 on success, otherwise -EINVAL + */ +int opinfo_write_to_none(struct oplock_info *opinfo) +{ + struct lease *lease = opinfo->o_lease; + + if (!(opinfo->level == SMB2_OPLOCK_LEVEL_BATCH || + opinfo->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE)) { + ksmbd_err("bad oplock(0x%x)\n", opinfo->level); + if (opinfo->is_lease) + ksmbd_err("lease state(0x%x)\n", + lease->state); + return -EINVAL; + } + opinfo->level = SMB2_OPLOCK_LEVEL_NONE; + if (opinfo->is_lease) + lease->state = lease->new_state; + return 0; +} + +/** + * opinfo_read_to_none() - convert a write read to none + * @opinfo: current oplock info + * + * Return: 0 on success, otherwise -EINVAL + */ +int opinfo_read_to_none(struct oplock_info *opinfo) +{ + struct lease *lease = opinfo->o_lease; + + if (opinfo->level != SMB2_OPLOCK_LEVEL_II) { + ksmbd_err("bad oplock(0x%x)\n", opinfo->level); + if (opinfo->is_lease) + ksmbd_err("lease state(0x%x)\n", lease->state); + return -EINVAL; + } + opinfo->level = SMB2_OPLOCK_LEVEL_NONE; + if (opinfo->is_lease) + lease->state = lease->new_state; + return 0; +} + +/** + * lease_read_to_write() - upgrade lease state from read to write + * @opinfo: current lease info + * + * Return: 0 on success, otherwise -EINVAL + */ +int lease_read_to_write(struct oplock_info *opinfo) +{ + struct lease *lease = opinfo->o_lease; + + if (!(lease->state & SMB2_LEASE_READ_CACHING_LE)) { + ksmbd_debug(OPLOCK, "bad lease state(0x%x)\n", + lease->state); + return -EINVAL; + } + + lease->new_state = SMB2_LEASE_NONE_LE; + lease->state |= SMB2_LEASE_WRITE_CACHING_LE; + if (lease->state & SMB2_LEASE_HANDLE_CACHING_LE) + opinfo->level = SMB2_OPLOCK_LEVEL_BATCH; + else + opinfo->level = SMB2_OPLOCK_LEVEL_EXCLUSIVE; + return 0; +} + +/** + * lease_none_upgrade() - upgrade lease state from none + * @opinfo: current lease info + * @new_state: new lease state + * + * Return: 0 on success, otherwise -EINVAL + */ +static int lease_none_upgrade(struct oplock_info *opinfo, __le32 new_state) +{ + struct lease *lease = opinfo->o_lease; + + if (!(lease->state == SMB2_LEASE_NONE_LE)) { + ksmbd_debug(OPLOCK, "bad lease state(0x%x)\n", + lease->state); + return -EINVAL; + } + + lease->new_state = SMB2_LEASE_NONE_LE; + lease->state = new_state; + if (lease->state & SMB2_LEASE_HANDLE_CACHING_LE) + if (lease->state & SMB2_LEASE_WRITE_CACHING_LE) + opinfo->level = SMB2_OPLOCK_LEVEL_BATCH; + else + opinfo->level = SMB2_OPLOCK_LEVEL_II; + else if (lease->state & SMB2_LEASE_WRITE_CACHING_LE) + opinfo->level = SMB2_OPLOCK_LEVEL_EXCLUSIVE; + else if (lease->state & SMB2_LEASE_READ_CACHING_LE) + opinfo->level = SMB2_OPLOCK_LEVEL_II; + + return 0; +} + +/** + * close_id_del_oplock() - release oplock object at file close time + * @fp: ksmbd file pointer + */ +void close_id_del_oplock(struct ksmbd_file *fp) +{ + struct oplock_info *opinfo; + + if (S_ISDIR(file_inode(fp->filp)->i_mode)) + return; + + opinfo = opinfo_get(fp); + if (!opinfo) + return; + + opinfo_del(opinfo); + + rcu_assign_pointer(fp->f_opinfo, NULL); + if (opinfo->op_state == OPLOCK_ACK_WAIT) { + opinfo->op_state = OPLOCK_CLOSING; + wake_up_interruptible_all(&opinfo->oplock_q); + if (opinfo->is_lease) { + atomic_set(&opinfo->breaking_cnt, 0); + wake_up_interruptible_all(&opinfo->oplock_brk); + } + } + + opinfo_count_dec(fp); + atomic_dec(&opinfo->refcount); + opinfo_put(opinfo); +} + +/** + * grant_write_oplock() - grant exclusive/batch oplock or write lease + * @opinfo_new: new oplock info object + * @req_oplock: request oplock + * @lctx: lease context information + * + * Return: 0 + */ +static void grant_write_oplock(struct oplock_info *opinfo_new, int req_oplock, + struct lease_ctx_info *lctx) +{ + struct lease *lease = opinfo_new->o_lease; + + if (req_oplock == SMB2_OPLOCK_LEVEL_BATCH) + opinfo_new->level = SMB2_OPLOCK_LEVEL_BATCH; + else + opinfo_new->level = SMB2_OPLOCK_LEVEL_EXCLUSIVE; + + if (lctx) { + lease->state = lctx->req_state; + memcpy(lease->lease_key, lctx->lease_key, + SMB2_LEASE_KEY_SIZE); + } +} + +/** + * grant_read_oplock() - grant level2 oplock or read lease + * @opinfo_new: new oplock info object + * @lctx: lease context information + * + * Return: 0 + */ +static void grant_read_oplock(struct oplock_info *opinfo_new, + struct lease_ctx_info *lctx) +{ + struct lease *lease = opinfo_new->o_lease; + + opinfo_new->level = SMB2_OPLOCK_LEVEL_II; + + if (lctx) { + lease->state = SMB2_LEASE_READ_CACHING_LE; + if (lctx->req_state & SMB2_LEASE_HANDLE_CACHING_LE) + lease->state |= SMB2_LEASE_HANDLE_CACHING_LE; + memcpy(lease->lease_key, lctx->lease_key, + SMB2_LEASE_KEY_SIZE); + } +} + +/** + * grant_none_oplock() - grant none oplock or none lease + * @opinfo_new: new oplock info object + * @lctx: lease context information + * + * Return: 0 + */ +static void grant_none_oplock(struct oplock_info *opinfo_new, + struct lease_ctx_info *lctx) +{ + struct lease *lease = opinfo_new->o_lease; + + opinfo_new->level = SMB2_OPLOCK_LEVEL_NONE; + + if (lctx) { + lease->state = 0; + memcpy(lease->lease_key, lctx->lease_key, + SMB2_LEASE_KEY_SIZE); + } +} + +static inline int compare_guid_key(struct oplock_info *opinfo, + const char *guid1, const char *key1) +{ + const char *guid2, *key2; + + guid2 = opinfo->conn->ClientGUID; + key2 = opinfo->o_lease->lease_key; + if (!memcmp(guid1, guid2, SMB2_CLIENT_GUID_SIZE) && + !memcmp(key1, key2, SMB2_LEASE_KEY_SIZE)) + return 1; + + return 0; +} + +/** + * same_client_has_lease() - check whether current lease request is + * from lease owner of file + * @ci: master file pointer + * @client_guid: Client GUID + * @lctx: lease context information + * + * Return: oplock(lease) object on success, otherwise NULL + */ +static struct oplock_info *same_client_has_lease(struct ksmbd_inode *ci, + char *client_guid, struct lease_ctx_info *lctx) +{ + int ret; + struct lease *lease; + struct oplock_info *opinfo; + struct oplock_info *m_opinfo = NULL; + + if (!lctx) + return NULL; + + /* + * Compare lease key and client_guid to know request from same owner + * of same client + */ + read_lock(&ci->m_lock); + list_for_each_entry(opinfo, &ci->m_op_list, op_entry) { + if (!opinfo->is_lease) + continue; + read_unlock(&ci->m_lock); + lease = opinfo->o_lease; + + ret = compare_guid_key(opinfo, client_guid, lctx->lease_key); + if (ret) { + m_opinfo = opinfo; + /* skip upgrading lease about breaking lease */ + if (atomic_read(&opinfo->breaking_cnt)) { + read_lock(&ci->m_lock); + continue; + } + + /* upgrading lease */ + if ((atomic_read(&ci->op_count) + + atomic_read(&ci->sop_count)) == 1) { + if (lease->state == + (lctx->req_state & lease->state)) { + lease->state |= lctx->req_state; + if (lctx->req_state & + SMB2_LEASE_WRITE_CACHING_LE) + lease_read_to_write(opinfo); + } + } else if ((atomic_read(&ci->op_count) + + atomic_read(&ci->sop_count)) > 1) { + if (lctx->req_state == + (SMB2_LEASE_READ_CACHING_LE | + SMB2_LEASE_HANDLE_CACHING_LE)) + lease->state = lctx->req_state; + } + + if (lctx->req_state && lease->state == + SMB2_LEASE_NONE_LE) + lease_none_upgrade(opinfo, lctx->req_state); + } + read_lock(&ci->m_lock); + } + read_unlock(&ci->m_lock); + + return m_opinfo; +} + +static void wait_for_break_ack(struct oplock_info *opinfo) +{ + int rc = 0; + + rc = wait_event_interruptible_timeout(opinfo->oplock_q, + opinfo->op_state == OPLOCK_STATE_NONE || + opinfo->op_state == OPLOCK_CLOSING, + OPLOCK_WAIT_TIME); + + /* is this a timeout ? */ + if (!rc) { + if (opinfo->is_lease) + opinfo->o_lease->state = SMB2_LEASE_NONE_LE; + opinfo->level = SMB2_OPLOCK_LEVEL_NONE; + opinfo->op_state = OPLOCK_STATE_NONE; + } +} + +static void wake_up_oplock_break(struct oplock_info *opinfo) +{ + clear_bit_unlock(0, &opinfo->pending_break); + /* memory barrier is needed for wake_up_bit() */ + smp_mb__after_atomic(); + wake_up_bit(&opinfo->pending_break, 0); +} + +static int oplock_break_pending(struct oplock_info *opinfo, int req_op_level) +{ + while (test_and_set_bit(0, &opinfo->pending_break)) { + wait_on_bit(&opinfo->pending_break, 0, TASK_UNINTERRUPTIBLE); + + /* Not immediately break to none. */ + opinfo->open_trunc = 0; + + if (opinfo->op_state == OPLOCK_CLOSING) + return -ENOENT; + else if (!opinfo->is_lease && opinfo->level <= req_op_level) + return 1; + } + + if (!opinfo->is_lease && opinfo->level <= req_op_level) { + wake_up_oplock_break(opinfo); + return 1; + } + return 0; +} + +static inline int allocate_oplock_break_buf(struct ksmbd_work *work) +{ + work->response_buf = kzalloc(MAX_CIFS_SMALL_BUFFER_SIZE, GFP_KERNEL); + if (!work->response_buf) + return -ENOMEM; + work->response_sz = MAX_CIFS_SMALL_BUFFER_SIZE; + return 0; +} + +/** + * __smb2_oplock_break_noti() - send smb2 oplock break cmd from conn + * to client + * @wk: smb work object + * + * There are two ways this function can be called. 1- while file open we break + * from exclusive/batch lock to levelII oplock and 2- while file write/truncate + * we break from levelII oplock no oplock. + * work->request_buf contains oplock_info. + */ +static void __smb2_oplock_break_noti(struct work_struct *wk) +{ + struct smb2_oplock_break *rsp = NULL; + struct ksmbd_work *work = container_of(wk, struct ksmbd_work, work); + struct ksmbd_conn *conn = work->conn; + struct oplock_break_info *br_info = work->request_buf; + struct smb2_hdr *rsp_hdr; + struct ksmbd_file *fp; + + fp = ksmbd_lookup_durable_fd(br_info->fid); + if (!fp) { + atomic_dec(&conn->r_count); + ksmbd_free_work_struct(work); + return; + } + + if (allocate_oplock_break_buf(work)) { + ksmbd_err("smb2_allocate_rsp_buf failed! "); + atomic_dec(&conn->r_count); + ksmbd_fd_put(work, fp); + ksmbd_free_work_struct(work); + return; + } + + rsp_hdr = work->response_buf; + memset(rsp_hdr, 0, sizeof(struct smb2_hdr) + 2); + rsp_hdr->smb2_buf_length = cpu_to_be32(HEADER_SIZE_NO_BUF_LEN(conn)); + rsp_hdr->ProtocolId = SMB2_PROTO_NUMBER; + rsp_hdr->StructureSize = SMB2_HEADER_STRUCTURE_SIZE; + rsp_hdr->CreditRequest = cpu_to_le16(0); + rsp_hdr->Command = SMB2_OPLOCK_BREAK; + rsp_hdr->Flags = (SMB2_FLAGS_SERVER_TO_REDIR); + rsp_hdr->NextCommand = 0; + rsp_hdr->MessageId = cpu_to_le64(-1); + rsp_hdr->Id.SyncId.ProcessId = 0; + rsp_hdr->Id.SyncId.TreeId = 0; + rsp_hdr->SessionId = 0; + memset(rsp_hdr->Signature, 0, 16); + + rsp = work->response_buf; + + rsp->StructureSize = cpu_to_le16(24); + if (!br_info->open_trunc && + (br_info->level == SMB2_OPLOCK_LEVEL_BATCH || + br_info->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE)) + rsp->OplockLevel = SMB2_OPLOCK_LEVEL_II; + else + rsp->OplockLevel = SMB2_OPLOCK_LEVEL_NONE; + rsp->Reserved = 0; + rsp->Reserved2 = 0; + rsp->PersistentFid = cpu_to_le64(fp->persistent_id); + rsp->VolatileFid = cpu_to_le64(fp->volatile_id); + + inc_rfc1001_len(rsp, 24); + + ksmbd_debug(OPLOCK, + "sending oplock break v_id %llu p_id = %llu lock level = %d\n", + rsp->VolatileFid, rsp->PersistentFid, rsp->OplockLevel); + + ksmbd_fd_put(work, fp); + ksmbd_conn_write(work); + ksmbd_free_work_struct(work); + atomic_dec(&conn->r_count); +} + +/** + * smb2_oplock_break_noti() - send smb2 exclusive/batch to level2 oplock + * break command from server to client + * @opinfo: oplock info object + * + * Return: 0 on success, otherwise error + */ +static int smb2_oplock_break_noti(struct oplock_info *opinfo) +{ + struct ksmbd_conn *conn = opinfo->conn; + struct oplock_break_info *br_info; + int ret = 0; + struct ksmbd_work *work = ksmbd_alloc_work_struct(); + + if (!work) + return -ENOMEM; + + br_info = kmalloc(sizeof(struct oplock_break_info), GFP_KERNEL); + if (!br_info) { + ksmbd_free_work_struct(work); + return -ENOMEM; + } + + br_info->level = opinfo->level; + br_info->fid = opinfo->fid; + br_info->open_trunc = opinfo->open_trunc; + + work->request_buf = (char *)br_info; + work->conn = conn; + work->sess = opinfo->sess; + + atomic_inc(&conn->r_count); + if (opinfo->op_state == OPLOCK_ACK_WAIT) { + INIT_WORK(&work->work, __smb2_oplock_break_noti); + ksmbd_queue_work(work); + + wait_for_break_ack(opinfo); + } else { + __smb2_oplock_break_noti(&work->work); + if (opinfo->level == SMB2_OPLOCK_LEVEL_II) + opinfo->level = SMB2_OPLOCK_LEVEL_NONE; + } + return ret; +} + +/** + * __smb2_lease_break_noti() - send lease break command from server + * to client + * @wk: smb work object + */ +static void __smb2_lease_break_noti(struct work_struct *wk) +{ + struct smb2_lease_break *rsp = NULL; + struct ksmbd_work *work = container_of(wk, struct ksmbd_work, work); + struct lease_break_info *br_info = work->request_buf; + struct ksmbd_conn *conn = work->conn; + struct smb2_hdr *rsp_hdr; + + if (allocate_oplock_break_buf(work)) { + ksmbd_debug(OPLOCK, "smb2_allocate_rsp_buf failed! "); + ksmbd_free_work_struct(work); + atomic_dec(&conn->r_count); + return; + } + + rsp_hdr = work->response_buf; + memset(rsp_hdr, 0, sizeof(struct smb2_hdr) + 2); + rsp_hdr->smb2_buf_length = cpu_to_be32(HEADER_SIZE_NO_BUF_LEN(conn)); + rsp_hdr->ProtocolId = SMB2_PROTO_NUMBER; + rsp_hdr->StructureSize = SMB2_HEADER_STRUCTURE_SIZE; + rsp_hdr->CreditRequest = cpu_to_le16(0); + rsp_hdr->Command = SMB2_OPLOCK_BREAK; + rsp_hdr->Flags = (SMB2_FLAGS_SERVER_TO_REDIR); + rsp_hdr->NextCommand = 0; + rsp_hdr->MessageId = cpu_to_le64(-1); + rsp_hdr->Id.SyncId.ProcessId = 0; + rsp_hdr->Id.SyncId.TreeId = 0; + rsp_hdr->SessionId = 0; + memset(rsp_hdr->Signature, 0, 16); + + rsp = work->response_buf; + rsp->StructureSize = cpu_to_le16(44); + rsp->Reserved = 0; + rsp->Flags = 0; + + if (br_info->curr_state & (SMB2_LEASE_WRITE_CACHING_LE | + SMB2_LEASE_HANDLE_CACHING_LE)) + rsp->Flags = SMB2_NOTIFY_BREAK_LEASE_FLAG_ACK_REQUIRED; + + memcpy(rsp->LeaseKey, br_info->lease_key, SMB2_LEASE_KEY_SIZE); + rsp->CurrentLeaseState = br_info->curr_state; + rsp->NewLeaseState = br_info->new_state; + rsp->BreakReason = 0; + rsp->AccessMaskHint = 0; + rsp->ShareMaskHint = 0; + + inc_rfc1001_len(rsp, 44); + + ksmbd_conn_write(work); + ksmbd_free_work_struct(work); + atomic_dec(&conn->r_count); +} + +/** + * smb2_lease_break_noti() - break lease when a new client request + * write lease + * @opinfo: conains lease state information + * + * Return: 0 on success, otherwise error + */ +static int smb2_lease_break_noti(struct oplock_info *opinfo) +{ + struct ksmbd_conn *conn = opinfo->conn; + struct list_head *tmp, *t; + struct ksmbd_work *work; + struct lease_break_info *br_info; + struct lease *lease = opinfo->o_lease; + + work = ksmbd_alloc_work_struct(); + if (!work) + return -ENOMEM; + + br_info = kmalloc(sizeof(struct lease_break_info), GFP_KERNEL); + if (!br_info) { + ksmbd_free_work_struct(work); + return -ENOMEM; + } + + br_info->curr_state = lease->state; + br_info->new_state = lease->new_state; + memcpy(br_info->lease_key, lease->lease_key, SMB2_LEASE_KEY_SIZE); + + work->request_buf = (char *)br_info; + work->conn = conn; + work->sess = opinfo->sess; + + atomic_inc(&conn->r_count); + if (opinfo->op_state == OPLOCK_ACK_WAIT) { + list_for_each_safe(tmp, t, &opinfo->interim_list) { + struct ksmbd_work *in_work; + + in_work = list_entry(tmp, struct ksmbd_work, + interim_entry); + setup_async_work(in_work, NULL, NULL); + smb2_send_interim_resp(in_work, STATUS_PENDING); + list_del(&in_work->interim_entry); + } + INIT_WORK(&work->work, __smb2_lease_break_noti); + ksmbd_queue_work(work); + wait_for_break_ack(opinfo); + } else { + __smb2_lease_break_noti(&work->work); + if (opinfo->o_lease->new_state == SMB2_LEASE_NONE_LE) { + opinfo->level = SMB2_OPLOCK_LEVEL_NONE; + opinfo->o_lease->state = SMB2_LEASE_NONE_LE; + } + } + return 0; +} + +static void wait_lease_breaking(struct oplock_info *opinfo) +{ + if (!opinfo->is_lease) + return; + + wake_up_interruptible_all(&opinfo->oplock_brk); + if (atomic_read(&opinfo->breaking_cnt)) { + int ret = 0; + + ret = wait_event_interruptible_timeout(opinfo->oplock_brk, + atomic_read(&opinfo->breaking_cnt) == 0, HZ); + if (!ret) + atomic_set(&opinfo->breaking_cnt, 0); + } +} + +static int oplock_break(struct oplock_info *brk_opinfo, int req_op_level) +{ + int err = 0; + + /* Need to break exclusive/batch oplock, write lease or overwrite_if */ + ksmbd_debug(OPLOCK, + "request to send oplock(level : 0x%x) break notification\n", + brk_opinfo->level); + + if (brk_opinfo->is_lease) { + struct lease *lease = brk_opinfo->o_lease; + + atomic_inc(&brk_opinfo->breaking_cnt); + + err = oplock_break_pending(brk_opinfo, req_op_level); + if (err) + return err < 0 ? err : 0; + + if (brk_opinfo->open_trunc) { + /* + * Create overwrite break trigger the lease break to + * none. + */ + lease->new_state = SMB2_LEASE_NONE_LE; + } else { + if (lease->state & SMB2_LEASE_WRITE_CACHING_LE) { + if (lease->state & SMB2_LEASE_HANDLE_CACHING_LE) + lease->new_state = + SMB2_LEASE_READ_CACHING_LE | + SMB2_LEASE_HANDLE_CACHING_LE; + else + lease->new_state = + SMB2_LEASE_READ_CACHING_LE; + } else { + if (lease->state & SMB2_LEASE_HANDLE_CACHING_LE) + lease->new_state = + SMB2_LEASE_READ_CACHING_LE; + else + lease->new_state = SMB2_LEASE_NONE_LE; + } + } + + if (lease->state & (SMB2_LEASE_WRITE_CACHING_LE | + SMB2_LEASE_HANDLE_CACHING_LE)) + brk_opinfo->op_state = OPLOCK_ACK_WAIT; + else + atomic_dec(&brk_opinfo->breaking_cnt); + } else { + err = oplock_break_pending(brk_opinfo, req_op_level); + if (err) + return err < 0 ? err : 0; + + if (brk_opinfo->level == SMB2_OPLOCK_LEVEL_BATCH || + brk_opinfo->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE) + brk_opinfo->op_state = OPLOCK_ACK_WAIT; + } + + if (brk_opinfo->is_lease) + err = smb2_lease_break_noti(brk_opinfo); + else + err = smb2_oplock_break_noti(brk_opinfo); + + ksmbd_debug(OPLOCK, "oplock granted = %d\n", brk_opinfo->level); + if (brk_opinfo->op_state == OPLOCK_CLOSING) + err = -ENOENT; + wake_up_oplock_break(brk_opinfo); + + wait_lease_breaking(brk_opinfo); + + return err; +} + +void destroy_lease_table(struct ksmbd_conn *conn) +{ + struct lease_table *lb, *lbtmp; + struct oplock_info *opinfo; + + write_lock(&lease_list_lock); + if (list_empty(&lease_table_list)) { + write_unlock(&lease_list_lock); + return; + } + + list_for_each_entry_safe(lb, lbtmp, &lease_table_list, l_entry) { + if (conn && memcmp(lb->client_guid, conn->ClientGUID, + SMB2_CLIENT_GUID_SIZE)) + continue; +again: + rcu_read_lock(); + list_for_each_entry_rcu(opinfo, &lb->lease_list, + lease_entry) { + rcu_read_unlock(); + lease_del_list(opinfo); + goto again; + } + rcu_read_unlock(); + list_del(&lb->l_entry); + kfree(lb); + } + write_unlock(&lease_list_lock); +} + +int find_same_lease_key(struct ksmbd_session *sess, struct ksmbd_inode *ci, + struct lease_ctx_info *lctx) +{ + struct oplock_info *opinfo; + int err = 0; + struct lease_table *lb; + + if (!lctx) + return err; + + read_lock(&lease_list_lock); + if (list_empty(&lease_table_list)) { + read_unlock(&lease_list_lock); + return 0; + } + + list_for_each_entry(lb, &lease_table_list, l_entry) { + if (!memcmp(lb->client_guid, sess->conn->ClientGUID, + SMB2_CLIENT_GUID_SIZE)) + goto found; + } + read_unlock(&lease_list_lock); + + return 0; + +found: + rcu_read_lock(); + list_for_each_entry_rcu(opinfo, &lb->lease_list, + lease_entry) { + if (!atomic_inc_not_zero(&opinfo->refcount)) + continue; + rcu_read_unlock(); + if (opinfo->o_fp->f_ci == ci) + goto op_next; + err = compare_guid_key(opinfo, + sess->conn->ClientGUID, + lctx->lease_key); + if (err) { + err = -EINVAL; + ksmbd_debug(OPLOCK, + "found same lease key is already used in other files\n"); + opinfo_put(opinfo); + goto out; + } +op_next: + opinfo_put(opinfo); + rcu_read_lock(); + } + rcu_read_unlock(); + +out: + read_unlock(&lease_list_lock); + return err; +} + +static void copy_lease(struct oplock_info *op1, struct oplock_info *op2) +{ + struct lease *lease1 = op1->o_lease; + struct lease *lease2 = op2->o_lease; + + op2->level = op1->level; + lease2->state = lease1->state; + memcpy(lease2->lease_key, lease1->lease_key, + SMB2_LEASE_KEY_SIZE); + lease2->duration = lease1->duration; + lease2->flags = lease1->flags; +} + +static int add_lease_global_list(struct oplock_info *opinfo) +{ + struct lease_table *lb; + + read_lock(&lease_list_lock); + list_for_each_entry(lb, &lease_table_list, l_entry) { + if (!memcmp(lb->client_guid, opinfo->conn->ClientGUID, + SMB2_CLIENT_GUID_SIZE)) { + opinfo->o_lease->l_lb = lb; + lease_add_list(opinfo); + read_unlock(&lease_list_lock); + return 0; + } + } + read_unlock(&lease_list_lock); + + lb = kmalloc(sizeof(struct lease_table), GFP_KERNEL); + if (!lb) + return -ENOMEM; + + memcpy(lb->client_guid, opinfo->conn->ClientGUID, + SMB2_CLIENT_GUID_SIZE); + INIT_LIST_HEAD(&lb->lease_list); + spin_lock_init(&lb->lb_lock); + opinfo->o_lease->l_lb = lb; + lease_add_list(opinfo); + lb_add(lb); + return 0; +} + +static void set_oplock_level(struct oplock_info *opinfo, int level, + struct lease_ctx_info *lctx) +{ + switch (level) { + case SMB2_OPLOCK_LEVEL_BATCH: + case SMB2_OPLOCK_LEVEL_EXCLUSIVE: + grant_write_oplock(opinfo, level, lctx); + break; + case SMB2_OPLOCK_LEVEL_II: + grant_read_oplock(opinfo, lctx); + break; + default: + grant_none_oplock(opinfo, lctx); + break; + } +} + +/** + * smb_grant_oplock() - handle oplock/lease request on file open + * @work: smb work + * @req_op_level: oplock level + * @pid: id of open file + * @fp: ksmbd file pointer + * @tid: Tree id of connection + * @lctx: lease context information on file open + * @share_ret: share mode + * + * Return: 0 on success, otherwise error + */ +int smb_grant_oplock(struct ksmbd_work *work, int req_op_level, u64 pid, + struct ksmbd_file *fp, __u16 tid, struct lease_ctx_info *lctx, + int share_ret) +{ + struct ksmbd_session *sess = work->sess; + int err = 0; + struct oplock_info *opinfo = NULL, *prev_opinfo = NULL; + struct ksmbd_inode *ci = fp->f_ci; + bool prev_op_has_lease; + __le32 prev_op_state = 0; + + /* not support directory lease */ + if (S_ISDIR(file_inode(fp->filp)->i_mode)) { + if (lctx) + lctx->dlease = 1; + return 0; + } + + opinfo = alloc_opinfo(work, pid, tid); + if (!opinfo) + return -ENOMEM; + + if (lctx) { + err = alloc_lease(opinfo, lctx); + if (err) + goto err_out; + opinfo->is_lease = 1; + } + + /* ci does not have any oplock */ + if (!opinfo_count(fp)) + goto set_lev; + + /* grant none-oplock if second open is trunc */ + if (ATTR_FP(fp)) { + req_op_level = SMB2_OPLOCK_LEVEL_NONE; + goto set_lev; + } + + if (lctx) { + struct oplock_info *m_opinfo; + + /* is lease already granted ? */ + m_opinfo = same_client_has_lease(ci, sess->conn->ClientGUID, + lctx); + if (m_opinfo) { + copy_lease(m_opinfo, opinfo); + if (atomic_read(&m_opinfo->breaking_cnt)) + opinfo->o_lease->flags = + SMB2_LEASE_FLAG_BREAK_IN_PROGRESS_LE; + goto out; + } + } + prev_opinfo = opinfo_get_list(ci); + if (!prev_opinfo || + (prev_opinfo->level == SMB2_OPLOCK_LEVEL_NONE && lctx)) + goto set_lev; + prev_op_has_lease = prev_opinfo->is_lease; + if (prev_op_has_lease) + prev_op_state = prev_opinfo->o_lease->state; + + if (share_ret < 0 && + prev_opinfo->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE) { + err = share_ret; + opinfo_put(prev_opinfo); + goto err_out; + } + + if (prev_opinfo->level != SMB2_OPLOCK_LEVEL_BATCH && + prev_opinfo->level != SMB2_OPLOCK_LEVEL_EXCLUSIVE) { + opinfo_put(prev_opinfo); + goto op_break_not_needed; + } + + list_add(&work->interim_entry, &prev_opinfo->interim_list); + err = oplock_break(prev_opinfo, SMB2_OPLOCK_LEVEL_II); + opinfo_put(prev_opinfo); + if (err == -ENOENT) + goto set_lev; + /* Check all oplock was freed by close */ + else if (err < 0) + goto err_out; + +op_break_not_needed: + if (share_ret < 0) { + err = share_ret; + goto err_out; + } + + if (req_op_level != SMB2_OPLOCK_LEVEL_NONE) + req_op_level = SMB2_OPLOCK_LEVEL_II; + + /* grant fixed oplock on stacked locking between lease and oplock */ + if (prev_op_has_lease && !lctx) + if (prev_op_state & SMB2_LEASE_HANDLE_CACHING_LE) + req_op_level = SMB2_OPLOCK_LEVEL_NONE; + + if (!prev_op_has_lease && lctx) { + req_op_level = SMB2_OPLOCK_LEVEL_II; + lctx->req_state = SMB2_LEASE_READ_CACHING_LE; + } + +set_lev: + set_oplock_level(opinfo, req_op_level, lctx); + +out: + rcu_assign_pointer(fp->f_opinfo, opinfo); + opinfo->o_fp = fp; + + opinfo_count_inc(fp); + opinfo_add(opinfo); + if (opinfo->is_lease) { + err = add_lease_global_list(opinfo); + if (err) + goto err_out; + } + + return 0; +err_out: + free_opinfo(opinfo); + return err; +} + +/** + * smb_break_all_write_oplock() - break batch/exclusive oplock to level2 + * @work: smb work + * @fp: ksmbd file pointer + * @is_trunc: truncate on open + */ +static void smb_break_all_write_oplock(struct ksmbd_work *work, + struct ksmbd_file *fp, int is_trunc) +{ + struct oplock_info *brk_opinfo; + + brk_opinfo = opinfo_get_list(fp->f_ci); + if (!brk_opinfo) + return; + if (brk_opinfo->level != SMB2_OPLOCK_LEVEL_BATCH && + brk_opinfo->level != SMB2_OPLOCK_LEVEL_EXCLUSIVE) { + opinfo_put(brk_opinfo); + return; + } + + brk_opinfo->open_trunc = is_trunc; + list_add(&work->interim_entry, &brk_opinfo->interim_list); + oplock_break(brk_opinfo, SMB2_OPLOCK_LEVEL_II); + opinfo_put(brk_opinfo); +} + +/** + * smb_break_all_levII_oplock() - send level2 oplock or read lease break command + * from server to client + * @work: smb work + * @fp: ksmbd file pointer + * @is_trunc: truncate on open + */ +void smb_break_all_levII_oplock(struct ksmbd_work *work, struct ksmbd_file *fp, + int is_trunc) +{ + struct oplock_info *op, *brk_op; + struct ksmbd_inode *ci; + struct ksmbd_conn *conn = work->sess->conn; + + if (!test_share_config_flag(work->tcon->share_conf, + KSMBD_SHARE_FLAG_OPLOCKS)) + return; + + ci = fp->f_ci; + op = opinfo_get(fp); + + rcu_read_lock(); + list_for_each_entry_rcu(brk_op, &ci->m_op_list, op_entry) { + if (!atomic_inc_not_zero(&brk_op->refcount)) + continue; + rcu_read_unlock(); + if (brk_op->is_lease && (brk_op->o_lease->state & + (~(SMB2_LEASE_READ_CACHING_LE | + SMB2_LEASE_HANDLE_CACHING_LE)))) { + ksmbd_debug(OPLOCK, "unexpected lease state(0x%x)\n", + brk_op->o_lease->state); + goto next; + } else if (brk_op->level != + SMB2_OPLOCK_LEVEL_II) { + ksmbd_debug(OPLOCK, "unexpected oplock(0x%x)\n", + brk_op->level); + goto next; + } + + /* Skip oplock being break to none */ + if (brk_op->is_lease && (brk_op->o_lease->new_state == + SMB2_LEASE_NONE_LE) && + atomic_read(&brk_op->breaking_cnt)) + goto next; + + if (op && op->is_lease && brk_op->is_lease && + !memcmp(conn->ClientGUID, brk_op->conn->ClientGUID, + SMB2_CLIENT_GUID_SIZE) && + !memcmp(op->o_lease->lease_key, brk_op->o_lease->lease_key, + SMB2_LEASE_KEY_SIZE)) + goto next; + brk_op->open_trunc = is_trunc; + oplock_break(brk_op, SMB2_OPLOCK_LEVEL_NONE); +next: + opinfo_put(brk_op); + rcu_read_lock(); + } + rcu_read_unlock(); + + if (op) + opinfo_put(op); +} + +/** + * smb_break_all_oplock() - break both batch/exclusive and level2 oplock + * @work: smb work + * @fp: ksmbd file pointer + */ +void smb_break_all_oplock(struct ksmbd_work *work, struct ksmbd_file *fp) +{ + if (!test_share_config_flag(work->tcon->share_conf, + KSMBD_SHARE_FLAG_OPLOCKS)) + return; + + smb_break_all_write_oplock(work, fp, 1); + smb_break_all_levII_oplock(work, fp, 1); +} + +/** + * smb2_map_lease_to_oplock() - map lease state to corresponding oplock type + * @lease_state: lease type + * + * Return: 0 if no mapping, otherwise corresponding oplock type + */ +__u8 smb2_map_lease_to_oplock(__le32 lease_state) +{ + if (lease_state == (SMB2_LEASE_HANDLE_CACHING_LE | + SMB2_LEASE_READ_CACHING_LE | + SMB2_LEASE_WRITE_CACHING_LE)) { + return SMB2_OPLOCK_LEVEL_BATCH; + } else if (lease_state != SMB2_LEASE_WRITE_CACHING_LE && + lease_state & SMB2_LEASE_WRITE_CACHING_LE) { + if (!(lease_state & SMB2_LEASE_HANDLE_CACHING_LE)) + return SMB2_OPLOCK_LEVEL_EXCLUSIVE; + } else if (lease_state & SMB2_LEASE_READ_CACHING_LE) { + return SMB2_OPLOCK_LEVEL_II; + } + return 0; +} + +/** + * create_lease_buf() - create lease context for open cmd response + * @rbuf: buffer to create lease context response + * @lease: buffer to stored parsed lease state information + */ +void create_lease_buf(u8 *rbuf, struct lease *lease) +{ + struct create_lease *buf = (struct create_lease *)rbuf; + char *LeaseKey = (char *)&lease->lease_key; + + memset(buf, 0, sizeof(struct create_lease)); + buf->lcontext.LeaseKeyLow = *((__le64 *)LeaseKey); + buf->lcontext.LeaseKeyHigh = *((__le64 *)(LeaseKey + 8)); + buf->lcontext.LeaseFlags = lease->flags; + buf->lcontext.LeaseState = lease->state; + buf->ccontext.DataOffset = cpu_to_le16(offsetof + (struct create_lease, lcontext)); + buf->ccontext.DataLength = cpu_to_le32(sizeof(struct lease_context)); + buf->ccontext.NameOffset = cpu_to_le16(offsetof + (struct create_lease, Name)); + buf->ccontext.NameLength = cpu_to_le16(4); + buf->Name[0] = 'R'; + buf->Name[1] = 'q'; + buf->Name[2] = 'L'; + buf->Name[3] = 's'; +} + +/** + * parse_lease_state() - parse lease context containted in file open request + * @open_req: buffer containing smb2 file open(create) request + * + * Return: oplock state, -ENOENT if create lease context not found + */ +struct lease_ctx_info *parse_lease_state(void *open_req) +{ + char *data_offset; + struct create_context *cc; + unsigned int next = 0; + char *name; + bool found = false; + struct smb2_create_req *req = (struct smb2_create_req *)open_req; + struct lease_ctx_info *lreq = kzalloc(sizeof(struct lease_ctx_info), + GFP_KERNEL); + if (!lreq) + return NULL; + + data_offset = (char *)req + 4 + le32_to_cpu(req->CreateContextsOffset); + cc = (struct create_context *)data_offset; + do { + cc = (struct create_context *)((char *)cc + next); + name = le16_to_cpu(cc->NameOffset) + (char *)cc; + if (le16_to_cpu(cc->NameLength) != 4 || + strncmp(name, SMB2_CREATE_REQUEST_LEASE, 4)) { + next = le32_to_cpu(cc->Next); + continue; + } + found = true; + break; + } while (next != 0); + + if (found) { + struct create_lease *lc = (struct create_lease *)cc; + *((__le64 *)lreq->lease_key) = lc->lcontext.LeaseKeyLow; + *((__le64 *)(lreq->lease_key + 8)) = lc->lcontext.LeaseKeyHigh; + lreq->req_state = lc->lcontext.LeaseState; + lreq->flags = lc->lcontext.LeaseFlags; + lreq->duration = lc->lcontext.LeaseDuration; + return lreq; + } + + kfree(lreq); + return NULL; +} + +/** + * smb2_find_context_vals() - find a particular context info in open request + * @open_req: buffer containing smb2 file open(create) request + * @tag: context name to search for + * + * Return: pointer to requested context, NULL if @str context not found + */ +struct create_context *smb2_find_context_vals(void *open_req, const char *tag) +{ + char *data_offset; + struct create_context *cc; + unsigned int next = 0; + char *name; + struct smb2_create_req *req = (struct smb2_create_req *)open_req; + + data_offset = (char *)req + 4 + le32_to_cpu(req->CreateContextsOffset); + cc = (struct create_context *)data_offset; + do { + int val; + + cc = (struct create_context *)((char *)cc + next); + name = le16_to_cpu(cc->NameOffset) + (char *)cc; + val = le16_to_cpu(cc->NameLength); + if (val < 4) + return ERR_PTR(-EINVAL); + + if (memcmp(name, tag, val) == 0) + return cc; + next = le32_to_cpu(cc->Next); + } while (next != 0); + + return ERR_PTR(-ENOENT); +} + +/** + * create_durable_rsp_buf() - create durable handle context + * @cc: buffer to create durable context response + */ +void create_durable_rsp_buf(char *cc) +{ + struct create_durable_rsp *buf; + + buf = (struct create_durable_rsp *)cc; + memset(buf, 0, sizeof(struct create_durable_rsp)); + buf->ccontext.DataOffset = cpu_to_le16(offsetof + (struct create_durable_rsp, Data)); + buf->ccontext.DataLength = cpu_to_le32(8); + buf->ccontext.NameOffset = cpu_to_le16(offsetof + (struct create_durable_rsp, Name)); + buf->ccontext.NameLength = cpu_to_le16(4); + /* SMB2_CREATE_DURABLE_HANDLE_RESPONSE is "DHnQ" */ + buf->Name[0] = 'D'; + buf->Name[1] = 'H'; + buf->Name[2] = 'n'; + buf->Name[3] = 'Q'; +} + +/** + * create_durable_v2_rsp_buf() - create durable handle v2 context + * @cc: buffer to create durable context response + * @fp: ksmbd file pointer + */ +void create_durable_v2_rsp_buf(char *cc, struct ksmbd_file *fp) +{ + struct create_durable_v2_rsp *buf; + + buf = (struct create_durable_v2_rsp *)cc; + memset(buf, 0, sizeof(struct create_durable_rsp)); + buf->ccontext.DataOffset = cpu_to_le16(offsetof + (struct create_durable_rsp, Data)); + buf->ccontext.DataLength = cpu_to_le32(8); + buf->ccontext.NameOffset = cpu_to_le16(offsetof + (struct create_durable_rsp, Name)); + buf->ccontext.NameLength = cpu_to_le16(4); + /* SMB2_CREATE_DURABLE_HANDLE_RESPONSE_V2 is "DH2Q" */ + buf->Name[0] = 'D'; + buf->Name[1] = 'H'; + buf->Name[2] = '2'; + buf->Name[3] = 'Q'; + + buf->Timeout = cpu_to_le32(fp->durable_timeout); +} + +/** + * create_mxac_rsp_buf() - create query maximal access context + * @cc: buffer to create maximal access context response + * @maximal_access: maximal access + */ +void create_mxac_rsp_buf(char *cc, int maximal_access) +{ + struct create_mxac_rsp *buf; + + buf = (struct create_mxac_rsp *)cc; + memset(buf, 0, sizeof(struct create_mxac_rsp)); + buf->ccontext.DataOffset = cpu_to_le16(offsetof + (struct create_mxac_rsp, QueryStatus)); + buf->ccontext.DataLength = cpu_to_le32(8); + buf->ccontext.NameOffset = cpu_to_le16(offsetof + (struct create_mxac_rsp, Name)); + buf->ccontext.NameLength = cpu_to_le16(4); + /* SMB2_CREATE_QUERY_MAXIMAL_ACCESS_RESPONSE is "MxAc" */ + buf->Name[0] = 'M'; + buf->Name[1] = 'x'; + buf->Name[2] = 'A'; + buf->Name[3] = 'c'; + + buf->QueryStatus = STATUS_SUCCESS; + buf->MaximalAccess = cpu_to_le32(maximal_access); +} + +void create_disk_id_rsp_buf(char *cc, __u64 file_id, __u64 vol_id) +{ + struct create_disk_id_rsp *buf; + + buf = (struct create_disk_id_rsp *)cc; + memset(buf, 0, sizeof(struct create_disk_id_rsp)); + buf->ccontext.DataOffset = cpu_to_le16(offsetof + (struct create_disk_id_rsp, DiskFileId)); + buf->ccontext.DataLength = cpu_to_le32(32); + buf->ccontext.NameOffset = cpu_to_le16(offsetof + (struct create_mxac_rsp, Name)); + buf->ccontext.NameLength = cpu_to_le16(4); + /* SMB2_CREATE_QUERY_ON_DISK_ID_RESPONSE is "QFid" */ + buf->Name[0] = 'Q'; + buf->Name[1] = 'F'; + buf->Name[2] = 'i'; + buf->Name[3] = 'd'; + + buf->DiskFileId = cpu_to_le64(file_id); + buf->VolumeId = cpu_to_le64(vol_id); +} + +/** + * create_posix_rsp_buf() - create posix extension context + * @cc: buffer to create posix on posix response + * @fp: ksmbd file pointer + */ +void create_posix_rsp_buf(char *cc, struct ksmbd_file *fp) +{ + struct create_posix_rsp *buf; + struct inode *inode = FP_INODE(fp); + + buf = (struct create_posix_rsp *)cc; + memset(buf, 0, sizeof(struct create_posix_rsp)); + buf->ccontext.DataOffset = cpu_to_le16(offsetof + (struct create_posix_rsp, nlink)); + buf->ccontext.DataLength = cpu_to_le32(52); + buf->ccontext.NameOffset = cpu_to_le16(offsetof + (struct create_posix_rsp, Name)); + buf->ccontext.NameLength = cpu_to_le16(POSIX_CTXT_DATA_LEN); + /* SMB2_CREATE_TAG_POSIX is "0x93AD25509CB411E7B42383DE968BCD7C" */ + buf->Name[0] = 0x93; + buf->Name[1] = 0xAD; + buf->Name[2] = 0x25; + buf->Name[3] = 0x50; + buf->Name[4] = 0x9C; + buf->Name[5] = 0xB4; + buf->Name[6] = 0x11; + buf->Name[7] = 0xE7; + buf->Name[8] = 0xB4; + buf->Name[9] = 0x23; + buf->Name[10] = 0x83; + buf->Name[11] = 0xDE; + buf->Name[12] = 0x96; + buf->Name[13] = 0x8B; + buf->Name[14] = 0xCD; + buf->Name[15] = 0x7C; + + buf->nlink = cpu_to_le32(inode->i_nlink); + buf->reparse_tag = cpu_to_le32(fp->volatile_id); + buf->mode = cpu_to_le32(inode->i_mode); + id_to_sid(from_kuid(&init_user_ns, inode->i_uid), + SIDNFS_USER, (struct smb_sid *)&buf->SidBuffer[0]); + id_to_sid(from_kgid(&init_user_ns, inode->i_gid), + SIDNFS_GROUP, (struct smb_sid *)&buf->SidBuffer[20]); +} + +/* + * Find lease object(opinfo) for given lease key/fid from lease + * break/file close path. + */ +/** + * lookup_lease_in_table() - find a matching lease info object + * @conn: connection instance + * @lease_key: lease key to be searched for + * + * Return: opinfo if found matching opinfo, otherwise NULL + */ +struct oplock_info *lookup_lease_in_table(struct ksmbd_conn *conn, + char *lease_key) +{ + struct oplock_info *opinfo = NULL, *ret_op = NULL; + struct lease_table *lt; + int ret; + + read_lock(&lease_list_lock); + list_for_each_entry(lt, &lease_table_list, l_entry) { + if (!memcmp(lt->client_guid, conn->ClientGUID, + SMB2_CLIENT_GUID_SIZE)) + goto found; + } + + read_unlock(&lease_list_lock); + return NULL; + +found: + rcu_read_lock(); + list_for_each_entry_rcu(opinfo, <->lease_list, lease_entry) { + if (!atomic_inc_not_zero(&opinfo->refcount)) + continue; + rcu_read_unlock(); + if (!opinfo->op_state || opinfo->op_state == OPLOCK_CLOSING) + goto op_next; + if (!(opinfo->o_lease->state & + (SMB2_LEASE_HANDLE_CACHING_LE | + SMB2_LEASE_WRITE_CACHING_LE))) + goto op_next; + ret = compare_guid_key(opinfo, conn->ClientGUID, + lease_key); + if (ret) { + ksmbd_debug(OPLOCK, "found opinfo\n"); + ret_op = opinfo; + goto out; + } +op_next: + opinfo_put(opinfo); + rcu_read_lock(); + } + rcu_read_unlock(); + +out: + read_unlock(&lease_list_lock); + return ret_op; +} + +int smb2_check_durable_oplock(struct ksmbd_file *fp, + struct lease_ctx_info *lctx, char *name) +{ + struct oplock_info *opinfo = opinfo_get(fp); + int ret = 0; + + if (opinfo && opinfo->is_lease) { + if (!lctx) { + ksmbd_err("open does not include lease\n"); + ret = -EBADF; + goto out; + } + if (memcmp(opinfo->o_lease->lease_key, lctx->lease_key, + SMB2_LEASE_KEY_SIZE)) { + ksmbd_err("invalid lease key\n"); + ret = -EBADF; + goto out; + } + if (name && strcmp(fp->filename, name)) { + ksmbd_err("invalid name reconnect %s\n", name); + ret = -EINVAL; + goto out; + } + } +out: + if (opinfo) + opinfo_put(opinfo); + return ret; +} diff --git a/fs/cifsd/oplock.h b/fs/cifsd/oplock.h new file mode 100644 index 000000000000..f8b4b486eb93 --- /dev/null +++ b/fs/cifsd/oplock.h @@ -0,0 +1,133 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2016 Namjae Jeon <linkinjeon@kernel.org> + * Copyright (C) 2018 Samsung Electronics Co., Ltd. + */ + +#ifndef __KSMBD_OPLOCK_H +#define __KSMBD_OPLOCK_H + +#include "smb_common.h" + +#define OPLOCK_WAIT_TIME (35 * HZ) + +/* SMB Oplock levels */ +#define OPLOCK_NONE 0 +#define OPLOCK_EXCLUSIVE 1 +#define OPLOCK_BATCH 2 +#define OPLOCK_READ 3 /* level 2 oplock */ + +/* SMB2 Oplock levels */ +#define SMB2_OPLOCK_LEVEL_NONE 0x00 +#define SMB2_OPLOCK_LEVEL_II 0x01 +#define SMB2_OPLOCK_LEVEL_EXCLUSIVE 0x08 +#define SMB2_OPLOCK_LEVEL_BATCH 0x09 +#define SMB2_OPLOCK_LEVEL_LEASE 0xFF + +/* Oplock states */ +#define OPLOCK_STATE_NONE 0x00 +#define OPLOCK_ACK_WAIT 0x01 +#define OPLOCK_CLOSING 0x02 + +#define OPLOCK_WRITE_TO_READ 0x01 +#define OPLOCK_READ_HANDLE_TO_READ 0x02 +#define OPLOCK_WRITE_TO_NONE 0x04 +#define OPLOCK_READ_TO_NONE 0x08 + +#define SMB2_LEASE_KEY_SIZE 16 + +struct lease_ctx_info { + __u8 lease_key[SMB2_LEASE_KEY_SIZE]; + __le32 req_state; + __le32 flags; + __le64 duration; + int dlease; +}; + +struct lease_table { + char client_guid[SMB2_CLIENT_GUID_SIZE]; + struct list_head lease_list; + struct list_head l_entry; + spinlock_t lb_lock; +}; + +struct lease { + __u8 lease_key[SMB2_LEASE_KEY_SIZE]; + __le32 state; + __le32 new_state; + __le32 flags; + __le64 duration; + struct lease_table *l_lb; +}; + +struct oplock_info { + struct ksmbd_conn *conn; + struct ksmbd_session *sess; + struct ksmbd_work *work; + struct ksmbd_file *o_fp; + int level; + int op_state; + unsigned long pending_break; + u64 fid; + atomic_t breaking_cnt; + atomic_t refcount; + __u16 Tid; + bool is_lease; + bool open_trunc; /* truncate on open */ + struct lease *o_lease; + struct list_head interim_list; + struct list_head op_entry; + struct list_head lease_entry; + wait_queue_head_t oplock_q; /* Other server threads */ + wait_queue_head_t oplock_brk; /* oplock breaking wait */ + struct rcu_head rcu_head; +}; + +struct lease_break_info { + __le32 curr_state; + __le32 new_state; + char lease_key[SMB2_LEASE_KEY_SIZE]; +}; + +struct oplock_break_info { + int level; + int open_trunc; + int fid; +}; + +int smb_grant_oplock(struct ksmbd_work *work, int req_op_level, + u64 pid, struct ksmbd_file *fp, __u16 tid, + struct lease_ctx_info *lctx, int share_ret); +void smb_break_all_levII_oplock(struct ksmbd_work *work, + struct ksmbd_file *fp, int is_trunc); + +int opinfo_write_to_read(struct oplock_info *opinfo); +int opinfo_read_handle_to_read(struct oplock_info *opinfo); +int opinfo_write_to_none(struct oplock_info *opinfo); +int opinfo_read_to_none(struct oplock_info *opinfo); +void close_id_del_oplock(struct ksmbd_file *fp); +void smb_break_all_oplock(struct ksmbd_work *work, struct ksmbd_file *fp); +struct oplock_info *opinfo_get(struct ksmbd_file *fp); +void opinfo_put(struct oplock_info *opinfo); + +/* Lease related functions */ +void create_lease_buf(u8 *rbuf, struct lease *lease); +struct lease_ctx_info *parse_lease_state(void *open_req); +__u8 smb2_map_lease_to_oplock(__le32 lease_state); +int lease_read_to_write(struct oplock_info *opinfo); + +/* Durable related functions */ +void create_durable_rsp_buf(char *cc); +void create_durable_v2_rsp_buf(char *cc, struct ksmbd_file *fp); +void create_mxac_rsp_buf(char *cc, int maximal_access); +void create_disk_id_rsp_buf(char *cc, __u64 file_id, __u64 vol_id); +void create_posix_rsp_buf(char *cc, struct ksmbd_file *fp); +struct create_context *smb2_find_context_vals(void *open_req, const char *str); +struct oplock_info *lookup_lease_in_table(struct ksmbd_conn *conn, + char *lease_key); +int find_same_lease_key(struct ksmbd_session *sess, struct ksmbd_inode *ci, + struct lease_ctx_info *lctx); +void destroy_lease_table(struct ksmbd_conn *conn); +int smb2_check_durable_oplock(struct ksmbd_file *fp, + struct lease_ctx_info *lctx, char *name); +#endif /* __KSMBD_OPLOCK_H */ -- 2.17.1 ^ permalink raw reply related [flat|nested] 11+ messages in thread
[parent not found: <CGME20210521063558epcas1p495b6140258d943e8db06176fe350ad17@epcas1p4.samsung.com>]
* [PATCH v3 08/10] cifsd: add file operations [not found] ` <CGME20210521063558epcas1p495b6140258d943e8db06176fe350ad17@epcas1p4.samsung.com> @ 2021-05-21 6:26 ` Namjae Jeon 0 siblings, 0 replies; 11+ messages in thread From: Namjae Jeon @ 2021-05-21 6:26 UTC (permalink / raw) To: linux-fsdevel, linux-kernel, linux-cifs Cc: linux-cifsd-devel, smfrench, senozhatsky, hyc.lee, viro, hch, hch, ronniesahlberg, aurelien.aptel, aaptel, sandeen, dan.carpenter, willy, Namjae Jeon, Sergey Senozhatsky, Steve French This adds file operations and buffer pool. Signed-off-by: Namjae Jeon <namjae.jeon@samsung.com> Signed-off-by: Sergey Senozhatsky <sergey.senozhatsky@gmail.com> Signed-off-by: Hyunchul Lee <hyc.lee@gmail.com> Acked-by: Ronnie Sahlberg <lsahlber@redhat.com> Signed-off-by: Steve French <stfrench@microsoft.com> --- fs/cifsd/buffer_pool.c | 264 ++++++ fs/cifsd/buffer_pool.h | 20 + fs/cifsd/vfs.c | 1995 ++++++++++++++++++++++++++++++++++++++++ fs/cifsd/vfs.h | 274 ++++++ fs/cifsd/vfs_cache.c | 683 ++++++++++++++ fs/cifsd/vfs_cache.h | 185 ++++ 6 files changed, 3421 insertions(+) create mode 100644 fs/cifsd/buffer_pool.c create mode 100644 fs/cifsd/buffer_pool.h create mode 100644 fs/cifsd/vfs.c create mode 100644 fs/cifsd/vfs.h create mode 100644 fs/cifsd/vfs_cache.c create mode 100644 fs/cifsd/vfs_cache.h diff --git a/fs/cifsd/buffer_pool.c b/fs/cifsd/buffer_pool.c new file mode 100644 index 000000000000..1ee1feef1bb4 --- /dev/null +++ b/fs/cifsd/buffer_pool.c @@ -0,0 +1,264 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * Copyright (C) 2018 Samsung Electronics Co., Ltd. + */ + +#include <linux/kernel.h> +#include <linux/wait.h> +#include <linux/sched.h> +#include <linux/mm.h> +#include <linux/slab.h> +#include <linux/vmalloc.h> +#include <linux/rwlock.h> + +#include "glob.h" +#include "buffer_pool.h" +#include "connection.h" +#include "mgmt/ksmbd_ida.h" + +static struct kmem_cache *filp_cache; + +struct wm { + struct list_head list; + unsigned int sz; + char buffer[0]; +}; + +struct wm_list { + struct list_head list; + unsigned int sz; + + spinlock_t wm_lock; + int avail_wm; + struct list_head idle_wm; + wait_queue_head_t wm_wait; +}; + +static LIST_HEAD(wm_lists); +static DEFINE_RWLOCK(wm_lists_lock); + +static struct wm *wm_alloc(size_t sz, gfp_t flags) +{ + struct wm *wm; + size_t alloc_sz = sz + sizeof(struct wm); + + if (sz > SIZE_MAX - sizeof(struct wm)) + return NULL; + + wm = kvmalloc(alloc_sz, flags); + if (!wm) + return NULL; + wm->sz = sz; + return wm; +} + +static int register_wm_size_class(size_t sz) +{ + struct wm_list *l, *nl; + + nl = kmalloc(sizeof(struct wm_list), GFP_KERNEL); + if (!nl) + return -ENOMEM; + + nl->sz = sz; + spin_lock_init(&nl->wm_lock); + INIT_LIST_HEAD(&nl->idle_wm); + INIT_LIST_HEAD(&nl->list); + init_waitqueue_head(&nl->wm_wait); + nl->avail_wm = 0; + + write_lock(&wm_lists_lock); + list_for_each_entry(l, &wm_lists, list) { + if (l->sz == sz) { + write_unlock(&wm_lists_lock); + kfree(nl); + return 0; + } + } + + list_add(&nl->list, &wm_lists); + write_unlock(&wm_lists_lock); + return 0; +} + +static struct wm_list *match_wm_list(size_t size) +{ + struct wm_list *l, *rl = NULL; + + read_lock(&wm_lists_lock); + list_for_each_entry(l, &wm_lists, list) { + if (l->sz == size) { + rl = l; + break; + } + } + read_unlock(&wm_lists_lock); + return rl; +} + +static struct wm *find_wm(size_t size) +{ + struct wm_list *wm_list; + struct wm *wm; + + wm_list = match_wm_list(size); + if (!wm_list) { + if (register_wm_size_class(size)) + return NULL; + wm_list = match_wm_list(size); + } + + if (!wm_list) + return NULL; + + while (1) { + spin_lock(&wm_list->wm_lock); + if (!list_empty(&wm_list->idle_wm)) { + wm = list_entry(wm_list->idle_wm.next, + struct wm, + list); + list_del(&wm->list); + spin_unlock(&wm_list->wm_lock); + return wm; + } + + if (wm_list->avail_wm > num_online_cpus()) { + spin_unlock(&wm_list->wm_lock); + wait_event(wm_list->wm_wait, + !list_empty(&wm_list->idle_wm)); + continue; + } + + wm_list->avail_wm++; + spin_unlock(&wm_list->wm_lock); + + wm = wm_alloc(size, GFP_KERNEL); + if (!wm) { + spin_lock(&wm_list->wm_lock); + wm_list->avail_wm--; + spin_unlock(&wm_list->wm_lock); + wait_event(wm_list->wm_wait, + !list_empty(&wm_list->idle_wm)); + continue; + } + break; + } + + return wm; +} + +static void release_wm(struct wm *wm, struct wm_list *wm_list) +{ + if (!wm) + return; + + spin_lock(&wm_list->wm_lock); + if (wm_list->avail_wm <= num_online_cpus()) { + list_add(&wm->list, &wm_list->idle_wm); + spin_unlock(&wm_list->wm_lock); + wake_up(&wm_list->wm_wait); + return; + } + + wm_list->avail_wm--; + spin_unlock(&wm_list->wm_lock); + kvfree(wm); +} + +static void wm_list_free(struct wm_list *l) +{ + struct wm *wm; + + while (!list_empty(&l->idle_wm)) { + wm = list_entry(l->idle_wm.next, struct wm, list); + list_del(&wm->list); + kvfree(wm); + } + kfree(l); +} + +static void wm_lists_destroy(void) +{ + struct wm_list *l; + + while (!list_empty(&wm_lists)) { + l = list_entry(wm_lists.next, struct wm_list, list); + list_del(&l->list); + wm_list_free(l); + } +} + +void *ksmbd_find_buffer(size_t size) +{ + struct wm *wm; + + wm = find_wm(size); + + WARN_ON(!wm); + if (wm) + return wm->buffer; + return NULL; +} + +void ksmbd_release_buffer(void *buffer) +{ + struct wm_list *wm_list; + struct wm *wm; + + if (!buffer) + return; + + wm = container_of(buffer, struct wm, buffer); + wm_list = match_wm_list(wm->sz); + WARN_ON(!wm_list); + if (wm_list) + release_wm(wm, wm_list); +} + +void *ksmbd_realloc_response(void *ptr, size_t old_sz, size_t new_sz) +{ + size_t sz = min(old_sz, new_sz); + void *nptr; + + nptr = kvmalloc(new_sz, GFP_KERNEL | __GFP_ZERO); + if (!nptr) + return ptr; + memcpy(nptr, ptr, sz); + kvfree(ptr); + return nptr; +} + +void ksmbd_free_file_struct(void *filp) +{ + kmem_cache_free(filp_cache, filp); +} + +void *ksmbd_alloc_file_struct(void) +{ + return kmem_cache_zalloc(filp_cache, GFP_KERNEL); +} + +void ksmbd_destroy_buffer_pools(void) +{ + wm_lists_destroy(); + ksmbd_work_pool_destroy(); + kmem_cache_destroy(filp_cache); +} + +int ksmbd_init_buffer_pools(void) +{ + if (ksmbd_work_pool_init()) + goto out; + + filp_cache = kmem_cache_create("ksmbd_file_cache", + sizeof(struct ksmbd_file), 0, SLAB_HWCACHE_ALIGN, NULL); + if (!filp_cache) + goto out; + + return 0; + +out: + ksmbd_err("failed to allocate memory\n"); + ksmbd_destroy_buffer_pools(); + return -ENOMEM; +} diff --git a/fs/cifsd/buffer_pool.h b/fs/cifsd/buffer_pool.h new file mode 100644 index 000000000000..f7157144a92f --- /dev/null +++ b/fs/cifsd/buffer_pool.h @@ -0,0 +1,20 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2018 Samsung Electronics Co., Ltd. + */ + +#ifndef __KSMBD_BUFFER_POOL_H__ +#define __KSMBD_BUFFER_POOL_H__ + +void *ksmbd_find_buffer(size_t size); +void ksmbd_release_buffer(void *buffer); + +void *ksmbd_realloc_response(void *ptr, size_t old_sz, size_t new_sz); + +void ksmbd_free_file_struct(void *filp); +void *ksmbd_alloc_file_struct(void); + +void ksmbd_destroy_buffer_pools(void); +int ksmbd_init_buffer_pools(void); + +#endif /* __KSMBD_BUFFER_POOL_H__ */ diff --git a/fs/cifsd/vfs.c b/fs/cifsd/vfs.c new file mode 100644 index 000000000000..cdbb844fddad --- /dev/null +++ b/fs/cifsd/vfs.c @@ -0,0 +1,1995 @@ +// 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/kernel.h> +#include <linux/fs.h> +#include <linux/uaccess.h> +#include <linux/backing-dev.h> +#include <linux/writeback.h> +#include <linux/xattr.h> +#include <linux/falloc.h> +#include <linux/genhd.h> +#include <linux/blkdev.h> +#include <linux/fsnotify.h> +#include <linux/dcache.h> +#include <linux/slab.h> +#include <linux/vmalloc.h> +#include <linux/sched/xacct.h> +#include <linux/crc32c.h> + +#include "glob.h" +#include "oplock.h" +#include "connection.h" +#include "buffer_pool.h" +#include "vfs.h" +#include "vfs_cache.h" +#include "smbacl.h" +#include "ndr.h" +#include "auth.h" +#include "misc.h" + +#include "smb_common.h" +#include "mgmt/share_config.h" +#include "mgmt/tree_connect.h" +#include "mgmt/user_session.h" +#include "mgmt/user_config.h" + +static char *extract_last_component(char *path) +{ + char *p = strrchr(path, '/'); + + if (p && p[1] != '\0') { + *p = '\0'; + p++; + } else { + p = NULL; + ksmbd_err("Invalid path %s\n", path); + } + return p; +} + +static void ksmbd_vfs_inherit_owner(struct ksmbd_work *work, + struct inode *parent_inode, struct inode *inode) +{ + if (!test_share_config_flag(work->tcon->share_conf, + KSMBD_SHARE_FLAG_INHERIT_OWNER)) + return; + + i_uid_write(inode, i_uid_read(parent_inode)); +} + +int ksmbd_vfs_inode_permission(struct dentry *dentry, int acc_mode, bool delete) +{ + int mask, ret = 0; + + mask = 0; + acc_mode &= O_ACCMODE; + + if (acc_mode == O_RDONLY) + mask = MAY_READ; + else if (acc_mode == O_WRONLY) + mask = MAY_WRITE; + else if (acc_mode == O_RDWR) + mask = MAY_READ | MAY_WRITE; + + if (inode_permission(&init_user_ns, d_inode(dentry), mask | MAY_OPEN)) + return -EACCES; + + if (delete) { + struct dentry *child, *parent; + + parent = dget_parent(dentry); + inode_lock_nested(d_inode(parent), I_MUTEX_PARENT); + child = lookup_one_len(dentry->d_name.name, parent, + dentry->d_name.len); + if (IS_ERR(child)) { + ret = PTR_ERR(child); + goto out_lock; + } + + if (child != dentry) { + ret = -ESTALE; + dput(child); + goto out_lock; + } + dput(child); + + if (inode_permission(&init_user_ns, d_inode(parent), MAY_EXEC | MAY_WRITE)) { + ret = -EACCES; + goto out_lock; + } +out_lock: + inode_unlock(d_inode(parent)); + dput(parent); + } + return ret; +} + +int ksmbd_vfs_query_maximal_access(struct dentry *dentry, __le32 *daccess) +{ + struct dentry *parent, *child; + int ret = 0; + + *daccess = cpu_to_le32(FILE_READ_ATTRIBUTES | READ_CONTROL); + + if (!inode_permission(&init_user_ns, d_inode(dentry), MAY_OPEN | MAY_WRITE)) + *daccess |= cpu_to_le32(WRITE_DAC | WRITE_OWNER | SYNCHRONIZE | + FILE_WRITE_DATA | FILE_APPEND_DATA | + FILE_WRITE_EA | FILE_WRITE_ATTRIBUTES | + FILE_DELETE_CHILD); + + if (!inode_permission(&init_user_ns, d_inode(dentry), MAY_OPEN | MAY_READ)) + *daccess |= FILE_READ_DATA_LE | FILE_READ_EA_LE; + + if (!inode_permission(&init_user_ns, d_inode(dentry), MAY_OPEN | MAY_EXEC)) + *daccess |= FILE_EXECUTE_LE; + + parent = dget_parent(dentry); + inode_lock_nested(d_inode(parent), I_MUTEX_PARENT); + child = lookup_one_len(dentry->d_name.name, parent, + dentry->d_name.len); + if (IS_ERR(child)) { + ret = PTR_ERR(child); + goto out_lock; + } + + if (child != dentry) { + ret = -ESTALE; + dput(child); + goto out_lock; + } + dput(child); + + if (!inode_permission(&init_user_ns, d_inode(parent), MAY_EXEC | MAY_WRITE)) + *daccess |= FILE_DELETE_LE; + +out_lock: + inode_unlock(d_inode(parent)); + dput(parent); + return ret; +} + +/** + * ksmbd_vfs_create() - vfs helper for smb create file + * @work: work + * @name: file name + * @mode: file create mode + * + * Return: 0 on success, otherwise error + */ +int ksmbd_vfs_create(struct ksmbd_work *work, const char *name, umode_t mode) +{ + struct path path; + struct dentry *dentry; + int err; + + dentry = kern_path_create(AT_FDCWD, name, &path, 0); + if (IS_ERR(dentry)) { + err = PTR_ERR(dentry); + if (err != -ENOENT) + ksmbd_err("path create failed for %s, err %d\n", + name, err); + return err; + } + + mode |= S_IFREG; + err = vfs_create(&init_user_ns, d_inode(path.dentry), dentry, mode, true); + if (!err) { + ksmbd_vfs_inherit_owner(work, d_inode(path.dentry), + d_inode(dentry)); + } else { + ksmbd_err("File(%s): creation failed (err:%d)\n", name, err); + } + done_path_create(&path, dentry); + return err; +} + +/** + * ksmbd_vfs_mkdir() - vfs helper for smb create directory + * @work: work + * @name: directory name + * @mode: directory create mode + * + * Return: 0 on success, otherwise error + */ +int ksmbd_vfs_mkdir(struct ksmbd_work *work, const char *name, umode_t mode) +{ + struct path path; + struct dentry *dentry; + int err; + + dentry = kern_path_create(AT_FDCWD, name, &path, LOOKUP_DIRECTORY); + if (IS_ERR(dentry)) { + err = PTR_ERR(dentry); + if (err != -EEXIST) + ksmbd_debug(VFS, "path create failed for %s, err %d\n", + name, err); + return err; + } + + mode |= S_IFDIR; + err = vfs_mkdir(&init_user_ns, d_inode(path.dentry), dentry, mode); + if (err) + goto out; + else if (d_unhashed(dentry)) { + struct dentry *d; + + d = lookup_one_len(dentry->d_name.name, + dentry->d_parent, + dentry->d_name.len); + if (IS_ERR(d)) { + err = PTR_ERR(d); + goto out; + } + if (unlikely(d_is_negative(d))) { + dput(d); + err = -ENOENT; + goto out; + } + + ksmbd_vfs_inherit_owner(work, d_inode(path.dentry), + d_inode(d)); + dput(d); + } +out: + done_path_create(&path, dentry); + if (err) + ksmbd_err("mkdir(%s): creation failed (err:%d)\n", name, err); + return err; +} + +static ssize_t ksmbd_vfs_getcasexattr(struct dentry *dentry, char *attr_name, + int attr_name_len, char **attr_value) +{ + char *name, *xattr_list = NULL; + ssize_t value_len = -ENOENT, xattr_list_len; + + xattr_list_len = ksmbd_vfs_listxattr(dentry, &xattr_list); + if (xattr_list_len <= 0) + goto out; + + for (name = xattr_list; name - xattr_list < xattr_list_len; + name += strlen(name) + 1) { + ksmbd_debug(VFS, "%s, len %zd\n", name, strlen(name)); + if (strncasecmp(attr_name, name, attr_name_len)) + continue; + + value_len = ksmbd_vfs_getxattr(dentry, + name, + attr_value); + if (value_len < 0) + ksmbd_err("failed to get xattr in file\n"); + break; + } + +out: + kvfree(xattr_list); + return value_len; +} + +static int ksmbd_vfs_stream_read(struct ksmbd_file *fp, char *buf, loff_t *pos, + size_t count) +{ + ssize_t v_len; + char *stream_buf = NULL; + int err; + + ksmbd_debug(VFS, "read stream data pos : %llu, count : %zd\n", + *pos, count); + + v_len = ksmbd_vfs_getcasexattr(fp->filp->f_path.dentry, + fp->stream.name, + fp->stream.size, + &stream_buf); + if (v_len == -ENOENT) { + ksmbd_err("not found stream in xattr : %zd\n", v_len); + err = -ENOENT; + return err; + } + + memcpy(buf, &stream_buf[*pos], count); + return v_len > count ? count : v_len; +} + +/** + * check_lock_range() - vfs helper for smb byte range file locking + * @filp: the file to apply the lock to + * @start: lock start byte offset + * @end: lock end byte offset + * @type: byte range type read/write + * + * Return: 0 on success, otherwise error + */ +static int check_lock_range(struct file *filp, loff_t start, loff_t end, + unsigned char type) +{ + struct file_lock *flock; + struct file_lock_context *ctx = file_inode(filp)->i_flctx; + int error = 0; + + if (!ctx || list_empty_careful(&ctx->flc_posix)) + return 0; + + spin_lock(&ctx->flc_lock); + list_for_each_entry(flock, &ctx->flc_posix, fl_list) { + /* check conflict locks */ + if (flock->fl_end >= start && end >= flock->fl_start) { + if (flock->fl_type == F_RDLCK) { + if (type == WRITE) { + ksmbd_err("not allow write by shared lock\n"); + error = 1; + goto out; + } + } else if (flock->fl_type == F_WRLCK) { + /* check owner in lock */ + if (flock->fl_file != filp) { + error = 1; + ksmbd_err("not allow rw access by exclusive lock from other opens\n"); + goto out; + } + } + } + } +out: + spin_unlock(&ctx->flc_lock); + return error; +} + +/** + * ksmbd_vfs_read() - vfs helper for smb file read + * @work: smb work + * @fid: file id of open file + * @count: read byte count + * @pos: file pos + * + * Return: number of read bytes on success, otherwise error + */ +int ksmbd_vfs_read(struct ksmbd_work *work, struct ksmbd_file *fp, size_t count, + loff_t *pos) +{ + struct file *filp; + ssize_t nbytes = 0; + char *rbuf; + struct inode *inode; + + rbuf = work->aux_payload_buf; + filp = fp->filp; + inode = file_inode(filp); + if (S_ISDIR(inode->i_mode)) + return -EISDIR; + + if (unlikely(count == 0)) + return 0; + + if (work->conn->connection_type) { + if (!(fp->daccess & (FILE_READ_DATA_LE | FILE_EXECUTE_LE))) { + ksmbd_err("no right to read(%s)\n", FP_FILENAME(fp)); + return -EACCES; + } + } + + if (ksmbd_stream_fd(fp)) + return ksmbd_vfs_stream_read(fp, rbuf, pos, count); + + if (!work->tcon->posix_extensions) { + int ret; + + ret = check_lock_range(filp, *pos, *pos + count - 1, + READ); + if (ret) { + ksmbd_err("unable to read due to lock\n"); + return -EAGAIN; + } + } + + nbytes = kernel_read(filp, rbuf, count, pos); + if (nbytes < 0) { + ksmbd_err("smb read failed for (%s), err = %zd\n", + fp->filename, nbytes); + return nbytes; + } + + filp->f_pos = *pos; + return nbytes; +} + +static int ksmbd_vfs_stream_write(struct ksmbd_file *fp, char *buf, loff_t *pos, + size_t count) +{ + char *stream_buf = NULL, *wbuf; + size_t size, v_len; + int err = 0; + + ksmbd_debug(VFS, "write stream data pos : %llu, count : %zd\n", + *pos, count); + + size = *pos + count; + if (size > XATTR_SIZE_MAX) { + size = XATTR_SIZE_MAX; + count = (*pos + count) - XATTR_SIZE_MAX; + } + + v_len = ksmbd_vfs_getcasexattr(fp->filp->f_path.dentry, + fp->stream.name, + fp->stream.size, + &stream_buf); + if (v_len == -ENOENT) { + ksmbd_err("not found stream in xattr : %zd\n", v_len); + err = -ENOENT; + goto out; + } + + if (v_len < size) { + wbuf = kvmalloc(size, GFP_KERNEL | __GFP_ZERO); + if (!wbuf) { + err = -ENOMEM; + goto out; + } + + if (v_len > 0) + memcpy(wbuf, stream_buf, v_len); + stream_buf = wbuf; + } + + memcpy(&stream_buf[*pos], buf, count); + + err = ksmbd_vfs_setxattr(fp->filp->f_path.dentry, + fp->stream.name, + (void *)stream_buf, + size, + 0); + if (err < 0) + goto out; + + fp->filp->f_pos = *pos; + err = 0; +out: + kvfree(stream_buf); + return err; +} + +/** + * ksmbd_vfs_write() - vfs helper for smb file write + * @work: work + * @fid: file id of open file + * @buf: buf containing data for writing + * @count: read byte count + * @pos: file pos + * @sync: fsync after write + * @written: number of bytes written + * + * Return: 0 on success, otherwise error + */ +int ksmbd_vfs_write(struct ksmbd_work *work, struct ksmbd_file *fp, + char *buf, size_t count, loff_t *pos, bool sync, + ssize_t *written) +{ + struct ksmbd_session *sess = work->sess; + struct file *filp; + loff_t offset = *pos; + int err = 0; + + if (sess->conn->connection_type) { + if (!(fp->daccess & FILE_WRITE_DATA_LE)) { + ksmbd_err("no right to write(%s)\n", FP_FILENAME(fp)); + err = -EACCES; + goto out; + } + } + + filp = fp->filp; + + if (ksmbd_stream_fd(fp)) { + err = ksmbd_vfs_stream_write(fp, buf, pos, count); + if (!err) + *written = count; + goto out; + } + + if (!work->tcon->posix_extensions) { + err = check_lock_range(filp, *pos, *pos + count - 1, WRITE); + if (err) { + ksmbd_err("unable to write due to lock\n"); + err = -EAGAIN; + goto out; + } + } + + /* Do we need to break any of a levelII oplock? */ + smb_break_all_levII_oplock(work, fp, 1); + + err = kernel_write(filp, buf, count, pos); + if (err < 0) { + ksmbd_debug(VFS, "smb write failed, err = %d\n", err); + goto out; + } + + filp->f_pos = *pos; + *written = err; + err = 0; + if (sync) { + err = vfs_fsync_range(filp, offset, offset + *written, 0); + if (err < 0) + ksmbd_err("fsync failed for filename = %s, err = %d\n", + FP_FILENAME(fp), err); + } + +out: + return err; +} + +/** + * ksmbd_vfs_getattr() - vfs helper for smb getattr + * @work: work + * @fid: file id of open file + * @attrs: inode attributes + * + * Return: 0 on success, otherwise error + */ +int ksmbd_vfs_getattr(struct path *path, struct kstat *stat) +{ + int err; + + err = vfs_getattr(path, stat, STATX_BTIME, AT_STATX_SYNC_AS_STAT); + if (err) + ksmbd_err("getattr failed, err %d\n", err); + return err; +} + +/** + * ksmbd_vfs_fsync() - vfs helper for smb fsync + * @work: work + * @fid: file id of open file + * + * Return: 0 on success, otherwise error + */ +int ksmbd_vfs_fsync(struct ksmbd_work *work, u64 fid, u64 p_id) +{ + struct ksmbd_file *fp; + int err; + + fp = ksmbd_lookup_fd_slow(work, fid, p_id); + if (!fp) { + ksmbd_err("failed to get filp for fid %llu\n", fid); + return -ENOENT; + } + err = vfs_fsync(fp->filp, 0); + if (err < 0) + ksmbd_err("smb fsync failed, err = %d\n", err); + ksmbd_fd_put(work, fp); + return err; +} + +/** + * ksmbd_vfs_remove_file() - vfs helper for smb rmdir or unlink + * @name: absolute directory or file name + * + * Return: 0 on success, otherwise error + */ +int ksmbd_vfs_remove_file(struct ksmbd_work *work, char *name) +{ + struct path path; + struct dentry *dentry, *parent; + int err; + + if (ksmbd_override_fsids(work)) + return -ENOMEM; + + err = kern_path(name, LOOKUP_FOLLOW, &path); + if (err) { + ksmbd_debug(VFS, "can't get %s, err %d\n", name, err); + ksmbd_revert_fsids(work); + return err; + } + + parent = dget_parent(path.dentry); + inode_lock_nested(d_inode(parent), I_MUTEX_PARENT); + dentry = lookup_one_len(path.dentry->d_name.name, parent, + strlen(path.dentry->d_name.name)); + if (IS_ERR(dentry)) { + err = PTR_ERR(dentry); + ksmbd_debug(VFS, "%s: lookup failed, err %d\n", + path.dentry->d_name.name, err); + goto out_err; + } + + if (!d_inode(dentry) || !d_inode(dentry)->i_nlink) { + dput(dentry); + err = -ENOENT; + goto out_err; + } + + if (S_ISDIR(d_inode(dentry)->i_mode)) { + err = vfs_rmdir(&init_user_ns, d_inode(parent), dentry); + if (err && err != -ENOTEMPTY) + ksmbd_debug(VFS, "%s: rmdir failed, err %d\n", name, + err); + } else { + err = vfs_unlink(&init_user_ns, d_inode(parent), dentry, NULL); + if (err) + ksmbd_debug(VFS, "%s: unlink failed, err %d\n", name, + err); + } + + dput(dentry); +out_err: + inode_unlock(d_inode(parent)); + dput(parent); + path_put(&path); + ksmbd_revert_fsids(work); + return err; +} + +/** + * ksmbd_vfs_link() - vfs helper for creating smb hardlink + * @oldname: source file name + * @newname: hardlink name + * + * Return: 0 on success, otherwise error + */ +int ksmbd_vfs_link(struct ksmbd_work *work, const char *oldname, + const char *newname) +{ + struct path oldpath, newpath; + struct dentry *dentry; + int err; + + if (ksmbd_override_fsids(work)) + return -ENOMEM; + + err = kern_path(oldname, LOOKUP_FOLLOW, &oldpath); + if (err) { + ksmbd_err("cannot get linux path for %s, err = %d\n", + oldname, err); + goto out1; + } + + dentry = kern_path_create(AT_FDCWD, newname, &newpath, + LOOKUP_FOLLOW | LOOKUP_REVAL); + if (IS_ERR(dentry)) { + err = PTR_ERR(dentry); + ksmbd_err("path create err for %s, err %d\n", newname, err); + goto out2; + } + + err = -EXDEV; + if (oldpath.mnt != newpath.mnt) { + ksmbd_err("vfs_link failed err %d\n", err); + goto out3; + } + + err = vfs_link(oldpath.dentry, &init_user_ns, d_inode(newpath.dentry), + dentry, NULL); + if (err) + ksmbd_debug(VFS, "vfs_link failed err %d\n", err); + +out3: + done_path_create(&newpath, dentry); +out2: + path_put(&oldpath); +out1: + ksmbd_revert_fsids(work); + return err; +} + +static int __ksmbd_vfs_rename(struct ksmbd_work *work, + struct dentry *src_dent_parent, struct dentry *src_dent, + struct dentry *dst_dent_parent, struct dentry *trap_dent, + char *dst_name) +{ + struct dentry *dst_dent; + int err; + + if (!work->tcon->posix_extensions) { + spin_lock(&src_dent->d_lock); + list_for_each_entry(dst_dent, &src_dent->d_subdirs, d_child) { + struct ksmbd_file *child_fp; + + if (d_really_is_negative(dst_dent)) + continue; + + child_fp = ksmbd_lookup_fd_inode(d_inode(dst_dent)); + if (child_fp) { + spin_unlock(&src_dent->d_lock); + ksmbd_debug(VFS, "Forbid rename, sub file/dir is in use\n"); + return -EACCES; + } + } + spin_unlock(&src_dent->d_lock); + } + + if (d_really_is_negative(src_dent_parent)) + return -ENOENT; + if (d_really_is_negative(dst_dent_parent)) + return -ENOENT; + if (d_really_is_negative(src_dent)) + return -ENOENT; + if (src_dent == trap_dent) + return -EINVAL; + + if (ksmbd_override_fsids(work)) + return -ENOMEM; + + dst_dent = lookup_one_len(dst_name, dst_dent_parent, strlen(dst_name)); + err = PTR_ERR(dst_dent); + if (IS_ERR(dst_dent)) { + ksmbd_err("lookup failed %s [%d]\n", dst_name, err); + goto out; + } + + err = -ENOTEMPTY; + if (dst_dent != trap_dent && !d_really_is_positive(dst_dent)) { + struct renamedata rd = { + .old_mnt_userns = &init_user_ns, + .old_dir = d_inode(src_dent_parent), + .old_dentry = src_dent, + .new_mnt_userns = &init_user_ns, + .new_dir = d_inode(dst_dent_parent), + .new_dentry = dst_dent, + }; + err = vfs_rename(&rd); + } + if (err) + ksmbd_err("vfs_rename failed err %d\n", err); + if (dst_dent) + dput(dst_dent); +out: + ksmbd_revert_fsids(work); + return err; +} + +int ksmbd_vfs_fp_rename(struct ksmbd_work *work, struct ksmbd_file *fp, + char *newname) +{ + struct path dst_path; + struct dentry *src_dent_parent, *dst_dent_parent; + struct dentry *src_dent, *trap_dent, *src_child; + char *dst_name; + int err; + + dst_name = extract_last_component(newname); + if (!dst_name) + return -EINVAL; + + src_dent_parent = dget_parent(fp->filp->f_path.dentry); + src_dent = fp->filp->f_path.dentry; + + err = kern_path(newname, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &dst_path); + if (err) { + ksmbd_debug(VFS, "Cannot get path for %s [%d]\n", newname, err); + goto out; + } + dst_dent_parent = dst_path.dentry; + + trap_dent = lock_rename(src_dent_parent, dst_dent_parent); + dget(src_dent); + dget(dst_dent_parent); + src_child = lookup_one_len(src_dent->d_name.name, src_dent_parent, + src_dent->d_name.len); + if (IS_ERR(src_child)) { + err = PTR_ERR(src_child); + goto out_lock; + } + + if (src_child != src_dent) { + err = -ESTALE; + dput(src_child); + goto out_lock; + } + dput(src_child); + + err = __ksmbd_vfs_rename(work, + src_dent_parent, + src_dent, + dst_dent_parent, + trap_dent, + dst_name); +out_lock: + dput(src_dent); + dput(dst_dent_parent); + unlock_rename(src_dent_parent, dst_dent_parent); + path_put(&dst_path); +out: + dput(src_dent_parent); + return err; +} + +/** + * ksmbd_vfs_truncate() - vfs helper for smb file truncate + * @work: work + * @name: old filename + * @fid: file id of old file + * @size: truncate to given size + * + * Return: 0 on success, otherwise error + */ +int ksmbd_vfs_truncate(struct ksmbd_work *work, const char *name, + struct ksmbd_file *fp, loff_t size) +{ + struct path path; + int err = 0; + + if (name) { + err = kern_path(name, 0, &path); + if (err) { + ksmbd_err("cannot get linux path for %s, err %d\n", + name, err); + return err; + } + err = vfs_truncate(&path, size); + if (err) + ksmbd_err("truncate failed for %s err %d\n", + name, err); + path_put(&path); + } else { + struct file *filp; + + filp = fp->filp; + + /* Do we need to break any of a levelII oplock? */ + smb_break_all_levII_oplock(work, fp, 1); + + if (!work->tcon->posix_extensions) { + struct inode *inode = file_inode(filp); + + if (size < inode->i_size) { + err = check_lock_range(filp, size, + inode->i_size - 1, WRITE); + } else { + err = check_lock_range(filp, inode->i_size, + size - 1, WRITE); + } + + if (err) { + ksmbd_err("failed due to lock\n"); + return -EAGAIN; + } + } + + err = vfs_truncate(&filp->f_path, size); + if (err) + ksmbd_err("truncate failed for filename : %s err %d\n", + fp->filename, err); + } + + return err; +} + +/** + * ksmbd_vfs_listxattr() - vfs helper for smb list extended attributes + * @dentry: dentry of file for listing xattrs + * @list: destination buffer + * @size: destination buffer length + * + * Return: xattr list length on success, otherwise error + */ +ssize_t ksmbd_vfs_listxattr(struct dentry *dentry, char **list) +{ + ssize_t size; + char *vlist = NULL; + + size = vfs_listxattr(dentry, NULL, 0); + if (size <= 0) + return size; + + vlist = kvmalloc(size, GFP_KERNEL | __GFP_ZERO); + if (!vlist) + return -ENOMEM; + + *list = vlist; + size = vfs_listxattr(dentry, vlist, size); + if (size < 0) { + ksmbd_debug(VFS, "listxattr failed\n"); + kvfree(vlist); + *list = NULL; + } + + return size; +} + +static ssize_t ksmbd_vfs_xattr_len(struct dentry *dentry, char *xattr_name) +{ + return vfs_getxattr(&init_user_ns, dentry, xattr_name, NULL, 0); +} + +/** + * ksmbd_vfs_getxattr() - vfs helper for smb get extended attributes value + * @dentry: dentry of file for getting xattrs + * @xattr_name: name of xattr name to query + * @xattr_buf: destination buffer xattr value + * + * Return: read xattr value length on success, otherwise error + */ +ssize_t ksmbd_vfs_getxattr(struct dentry *dentry, char *xattr_name, + char **xattr_buf) +{ + ssize_t xattr_len; + char *buf; + + *xattr_buf = NULL; + xattr_len = ksmbd_vfs_xattr_len(dentry, xattr_name); + if (xattr_len < 0) + return xattr_len; + + buf = kmalloc(xattr_len + 1, GFP_KERNEL); + if (!buf) + return -ENOMEM; + + xattr_len = vfs_getxattr(&init_user_ns, dentry, xattr_name, (void *)buf, + xattr_len); + if (xattr_len > 0) + *xattr_buf = buf; + else + kfree(buf); + return xattr_len; +} + +/** + * ksmbd_vfs_setxattr() - vfs helper for smb set extended attributes value + * @dentry: dentry to set XATTR at + * @name: xattr name for setxattr + * @value: xattr value to set + * @size: size of xattr value + * @flags: destination buffer length + * + * Return: 0 on success, otherwise error + */ +int ksmbd_vfs_setxattr(struct dentry *dentry, const char *attr_name, + const void *attr_value, size_t attr_size, int flags) +{ + int err; + + err = vfs_setxattr(&init_user_ns, dentry, + attr_name, + attr_value, + attr_size, + flags); + if (err) + ksmbd_debug(VFS, "setxattr failed, err %d\n", err); + return err; +} + +/** + * ksmbd_vfs_set_fadvise() - convert smb IO caching options to linux options + * @filp: file pointer for IO + * @options: smb IO options + */ +void ksmbd_vfs_set_fadvise(struct file *filp, __le32 option) +{ + struct address_space *mapping; + + mapping = filp->f_mapping; + + if (!option || !mapping) + return; + + if (option & FILE_WRITE_THROUGH_LE) { + filp->f_flags |= O_SYNC; + } else if (option & FILE_SEQUENTIAL_ONLY_LE) { + filp->f_ra.ra_pages = inode_to_bdi(mapping->host)->ra_pages * 2; + spin_lock(&filp->f_lock); + filp->f_mode &= ~FMODE_RANDOM; + spin_unlock(&filp->f_lock); + } else if (option & FILE_RANDOM_ACCESS_LE) { + spin_lock(&filp->f_lock); + filp->f_mode |= FMODE_RANDOM; + spin_unlock(&filp->f_lock); + } +} + +/** + * ksmbd_vfs_lock() - vfs helper for smb file locking + * @filp: the file to apply the lock to + * @cmd: type of locking operation (F_SETLK, F_GETLK, etc.) + * @flock: The lock to be applied + * + * Return: 0 on success, otherwise error + */ +int ksmbd_vfs_lock(struct file *filp, int cmd, + struct file_lock *flock) +{ + ksmbd_debug(VFS, "calling vfs_lock_file\n"); + return vfs_lock_file(filp, cmd, flock, NULL); +} + +int ksmbd_vfs_readdir(struct file *file, struct ksmbd_readdir_data *rdata) +{ + return iterate_dir(file, &rdata->ctx); +} + +int ksmbd_vfs_alloc_size(struct ksmbd_work *work, struct ksmbd_file *fp, + loff_t len) +{ + smb_break_all_levII_oplock(work, fp, 1); + return vfs_fallocate(fp->filp, FALLOC_FL_KEEP_SIZE, 0, len); +} + +int ksmbd_vfs_zero_data(struct ksmbd_work *work, struct ksmbd_file *fp, + loff_t off, loff_t len) +{ + smb_break_all_levII_oplock(work, fp, 1); + if (fp->f_ci->m_fattr & ATTR_SPARSE_FILE_LE) + return vfs_fallocate(fp->filp, + FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, off, len); + + return vfs_fallocate(fp->filp, FALLOC_FL_ZERO_RANGE, off, len); +} + +int ksmbd_vfs_fqar_lseek(struct ksmbd_file *fp, loff_t start, loff_t length, + struct file_allocated_range_buffer *ranges, + int in_count, int *out_count) +{ + struct file *f = fp->filp; + struct inode *inode = FP_INODE(fp); + loff_t maxbytes = (u64)inode->i_sb->s_maxbytes, end; + loff_t extent_start, extent_end; + int ret = 0; + + if (start > maxbytes) + return -EFBIG; + + if (!in_count) + return 0; + + /* + * Shrink request scope to what the fs can actually handle. + */ + if (length > maxbytes || (maxbytes - length) < start) + length = maxbytes - start; + + if (start + length > inode->i_size) + length = inode->i_size - start; + + *out_count = 0; + end = start + length; + while (start < end && *out_count < in_count) { + extent_start = f->f_op->llseek(f, start, SEEK_DATA); + if (extent_start < 0) { + if (extent_start != -ENXIO) + ret = (int)extent_start; + break; + } + + if (extent_start >= end) + break; + + extent_end = f->f_op->llseek(f, extent_start, SEEK_HOLE); + if (extent_end < 0) { + if (extent_end != -ENXIO) + ret = (int)extent_end; + break; + } else if (extent_start >= extent_end) { + break; + } + + ranges[*out_count].file_offset = cpu_to_le64(extent_start); + ranges[(*out_count)++].length = + cpu_to_le64(min(extent_end, end) - extent_start); + + start = extent_end; + } + + return ret; +} + +int ksmbd_vfs_remove_xattr(struct dentry *dentry, char *attr_name) +{ + return vfs_removexattr(&init_user_ns, dentry, attr_name); +} + +int ksmbd_vfs_unlink(struct dentry *dir, struct dentry *dentry) +{ + struct dentry *child; + int err = 0; + + inode_lock_nested(d_inode(dir), I_MUTEX_PARENT); + dget(dentry); + child = lookup_one_len(dentry->d_name.name, dir, + dentry->d_name.len); + if (IS_ERR(child)) { + err = PTR_ERR(child); + goto out; + } + + if (child != dentry) { + err = -ESTALE; + dput(child); + goto out; + } + dput(child); + + if (S_ISDIR(d_inode(dentry)->i_mode)) + err = vfs_rmdir(&init_user_ns, d_inode(dir), dentry); + else + err = vfs_unlink(&init_user_ns, d_inode(dir), dentry, NULL); + +out: + dput(dentry); + inode_unlock(d_inode(dir)); + if (err) + ksmbd_debug(VFS, "failed to delete, err %d\n", err); + + return err; +} + +/* + * ksmbd_vfs_get_logical_sector_size() - get logical sector size from inode + * @inode: inode + * + * Return: logical sector size + */ +unsigned short ksmbd_vfs_logical_sector_size(struct inode *inode) +{ + struct request_queue *q; + unsigned short ret_val = 512; + + if (!inode->i_sb->s_bdev) + return ret_val; + + q = inode->i_sb->s_bdev->bd_disk->queue; + + if (q && q->limits.logical_block_size) + ret_val = q->limits.logical_block_size; + + return ret_val; +} + +/* + * ksmbd_vfs_get_smb2_sector_size() - get fs sector sizes + * @inode: inode + * @fs_ss: fs sector size struct + */ +void ksmbd_vfs_smb2_sector_size(struct inode *inode, + struct ksmbd_fs_sector_size *fs_ss) +{ + struct request_queue *q; + + fs_ss->logical_sector_size = 512; + fs_ss->physical_sector_size = 512; + fs_ss->optimal_io_size = 512; + + if (!inode->i_sb->s_bdev) + return; + + q = inode->i_sb->s_bdev->bd_disk->queue; + + if (q) { + if (q->limits.logical_block_size) + fs_ss->logical_sector_size = + q->limits.logical_block_size; + if (q->limits.physical_block_size) + fs_ss->physical_sector_size = + q->limits.physical_block_size; + if (q->limits.io_opt) + fs_ss->optimal_io_size = q->limits.io_opt; + } +} + +static int __dir_empty(struct dir_context *ctx, const char *name, int namlen, + loff_t offset, u64 ino, unsigned int d_type) +{ + struct ksmbd_readdir_data *buf; + + buf = container_of(ctx, struct ksmbd_readdir_data, ctx); + buf->dirent_count++; + + if (buf->dirent_count > 2) + return -ENOTEMPTY; + return 0; +} + +/** + * ksmbd_vfs_empty_dir() - check for empty directory + * @fp: ksmbd file pointer + * + * Return: true if directory empty, otherwise false + */ +int ksmbd_vfs_empty_dir(struct ksmbd_file *fp) +{ + int err; + struct ksmbd_readdir_data readdir_data; + + memset(&readdir_data, 0, sizeof(struct ksmbd_readdir_data)); + + set_ctx_actor(&readdir_data.ctx, __dir_empty); + readdir_data.dirent_count = 0; + + err = ksmbd_vfs_readdir(fp->filp, &readdir_data); + if (readdir_data.dirent_count > 2) + err = -ENOTEMPTY; + else + err = 0; + return err; +} + +static int __caseless_lookup(struct dir_context *ctx, const char *name, + int namlen, loff_t offset, u64 ino, unsigned int d_type) +{ + struct ksmbd_readdir_data *buf; + + buf = container_of(ctx, struct ksmbd_readdir_data, ctx); + + if (buf->used != namlen) + return 0; + if (!strncasecmp((char *)buf->private, name, namlen)) { + memcpy((char *)buf->private, name, namlen); + buf->dirent_count = 1; + return -EEXIST; + } + return 0; +} + +/** + * ksmbd_vfs_lookup_in_dir() - lookup a file in a directory + * @dir: path info + * @name: filename to lookup + * @namelen: filename length + * + * Return: 0 on success, otherwise error + */ +static int ksmbd_vfs_lookup_in_dir(struct path *dir, char *name, size_t namelen) +{ + int ret; + struct file *dfilp; + int flags = O_RDONLY | O_LARGEFILE; + struct ksmbd_readdir_data readdir_data = { + .ctx.actor = __caseless_lookup, + .private = name, + .used = namelen, + .dirent_count = 0, + }; + + dfilp = dentry_open(dir, flags, current_cred()); + if (IS_ERR(dfilp)) + return PTR_ERR(dfilp); + + ret = ksmbd_vfs_readdir(dfilp, &readdir_data); + if (readdir_data.dirent_count > 0) + ret = 0; + fput(dfilp); + return ret; +} + +/** + * ksmbd_vfs_kern_path() - lookup a file and get path info + * @name: name of file for lookup + * @flags: lookup flags + * @path: if lookup succeed, return path info + * @caseless: caseless filename lookup + * + * Return: 0 on success, otherwise error + */ +int ksmbd_vfs_kern_path(char *name, unsigned int flags, struct path *path, + bool caseless) +{ + int err; + + if (name[0] != '/') + return -EINVAL; + + err = kern_path(name, flags, path); + if (!err) + return 0; + + if (caseless) { + char *filepath; + struct path parent; + size_t path_len, remain_len; + + filepath = kstrdup(name, GFP_KERNEL); + if (!filepath) + return -ENOMEM; + + path_len = strlen(filepath); + remain_len = path_len - 1; + + err = kern_path("/", flags, &parent); + if (err) + goto out; + + while (d_can_lookup(parent.dentry)) { + char *filename = filepath + path_len - remain_len; + char *next = strchrnul(filename, '/'); + size_t filename_len = next - filename; + bool is_last = !next[0]; + + if (filename_len == 0) + break; + + err = ksmbd_vfs_lookup_in_dir(&parent, filename, + filename_len); + if (err) { + path_put(&parent); + goto out; + } + + path_put(&parent); + next[0] = '\0'; + + err = kern_path(filepath, flags, &parent); + if (err) + goto out; + + if (is_last) { + path->mnt = parent.mnt; + path->dentry = parent.dentry; + goto out; + } + + next[0] = '/'; + remain_len -= filename_len + 1; + } + + path_put(&parent); + err = -EINVAL; +out: + kfree(filepath); + } + return err; +} + +int ksmbd_vfs_remove_acl_xattrs(struct dentry *dentry) +{ + char *name, *xattr_list = NULL; + ssize_t xattr_list_len; + int err = 0; + + xattr_list_len = ksmbd_vfs_listxattr(dentry, &xattr_list); + if (xattr_list_len < 0) { + goto out; + } else if (!xattr_list_len) { + ksmbd_debug(SMB, "empty xattr in the file\n"); + goto out; + } + + for (name = xattr_list; name - xattr_list < xattr_list_len; + name += strlen(name) + 1) { + ksmbd_debug(SMB, "%s, len %zd\n", name, strlen(name)); + + if (!strncmp(name, XATTR_NAME_POSIX_ACL_ACCESS, + sizeof(XATTR_NAME_POSIX_ACL_ACCESS) - 1) || + !strncmp(name, XATTR_NAME_POSIX_ACL_DEFAULT, + sizeof(XATTR_NAME_POSIX_ACL_DEFAULT) - 1)) { + err = ksmbd_vfs_remove_xattr(dentry, name); + if (err) + ksmbd_debug(SMB, + "remove acl xattr failed : %s\n", name); + } + } +out: + kvfree(xattr_list); + return err; +} + +int ksmbd_vfs_remove_sd_xattrs(struct dentry *dentry) +{ + char *name, *xattr_list = NULL; + ssize_t xattr_list_len; + int err = 0; + + xattr_list_len = ksmbd_vfs_listxattr(dentry, &xattr_list); + if (xattr_list_len < 0) { + goto out; + } else if (!xattr_list_len) { + ksmbd_debug(SMB, "empty xattr in the file\n"); + goto out; + } + + for (name = xattr_list; name - xattr_list < xattr_list_len; + name += strlen(name) + 1) { + ksmbd_debug(SMB, "%s, len %zd\n", name, strlen(name)); + + if (!strncmp(name, XATTR_NAME_SD, XATTR_NAME_SD_LEN)) { + err = ksmbd_vfs_remove_xattr(dentry, name); + if (err) + ksmbd_debug(SMB, "remove xattr failed : %s\n", name); + } + } +out: + kvfree(xattr_list); + return err; +} + +static struct xattr_smb_acl *ksmbd_vfs_make_xattr_posix_acl(struct inode *inode, + int acl_type) +{ + struct xattr_smb_acl *smb_acl = NULL; + struct posix_acl *posix_acls; + struct posix_acl_entry *pa_entry; + struct xattr_acl_entry *xa_entry; + int i; + + posix_acls = ksmbd_vfs_get_acl(inode, acl_type); + if (!posix_acls) + return NULL; + + smb_acl = kzalloc(sizeof(struct xattr_smb_acl) + + sizeof(struct xattr_acl_entry) * posix_acls->a_count, + GFP_KERNEL); + if (!smb_acl) + goto out; + + smb_acl->count = posix_acls->a_count; + pa_entry = posix_acls->a_entries; + xa_entry = smb_acl->entries; + for (i = 0; i < posix_acls->a_count; i++, pa_entry++, xa_entry++) { + switch (pa_entry->e_tag) { + case ACL_USER: + xa_entry->type = SMB_ACL_USER; + xa_entry->uid = from_kuid(&init_user_ns, pa_entry->e_uid); + break; + case ACL_USER_OBJ: + xa_entry->type = SMB_ACL_USER_OBJ; + break; + case ACL_GROUP: + xa_entry->type = SMB_ACL_GROUP; + xa_entry->gid = from_kgid(&init_user_ns, pa_entry->e_gid); + break; + case ACL_GROUP_OBJ: + xa_entry->type = SMB_ACL_GROUP_OBJ; + break; + case ACL_OTHER: + xa_entry->type = SMB_ACL_OTHER; + break; + case ACL_MASK: + xa_entry->type = SMB_ACL_MASK; + break; + default: + ksmbd_err("unknown type : 0x%x\n", pa_entry->e_tag); + goto out; + } + + if (pa_entry->e_perm & ACL_READ) + xa_entry->perm |= SMB_ACL_READ; + if (pa_entry->e_perm & ACL_WRITE) + xa_entry->perm |= SMB_ACL_WRITE; + if (pa_entry->e_perm & ACL_EXECUTE) + xa_entry->perm |= SMB_ACL_EXECUTE; + } +out: + posix_acl_release(posix_acls); + return smb_acl; +} + +int ksmbd_vfs_set_sd_xattr(struct ksmbd_conn *conn, struct dentry *dentry, + struct smb_ntsd *pntsd, int len) +{ + int rc; + struct ndr sd_ndr = {0}, acl_ndr = {0}; + struct xattr_ntacl acl = {0}; + struct xattr_smb_acl *smb_acl, *def_smb_acl = NULL; + struct inode *inode = d_inode(dentry); + + acl.version = 4; + acl.hash_type = XATTR_SD_HASH_TYPE_SHA256; + acl.current_time = ksmbd_UnixTimeToNT(current_time(inode)); + + memcpy(acl.desc, "posix_acl", 9); + acl.desc_len = 10; + + pntsd->osidoffset = + cpu_to_le32(le32_to_cpu(pntsd->osidoffset) + NDR_NTSD_OFFSETOF); + pntsd->gsidoffset = + cpu_to_le32(le32_to_cpu(pntsd->gsidoffset) + NDR_NTSD_OFFSETOF); + pntsd->dacloffset = + cpu_to_le32(le32_to_cpu(pntsd->dacloffset) + NDR_NTSD_OFFSETOF); + + acl.sd_buf = (char *)pntsd; + acl.sd_size = len; + + rc = ksmbd_gen_sd_hash(conn, acl.sd_buf, acl.sd_size, acl.hash); + if (rc) { + ksmbd_err("failed to generate hash for ndr acl\n"); + return rc; + } + + smb_acl = ksmbd_vfs_make_xattr_posix_acl(inode, ACL_TYPE_ACCESS); + if (S_ISDIR(inode->i_mode)) + def_smb_acl = ksmbd_vfs_make_xattr_posix_acl(inode, + ACL_TYPE_DEFAULT); + + rc = ndr_encode_posix_acl(&acl_ndr, inode, smb_acl, def_smb_acl); + if (rc) { + ksmbd_err("failed to encode ndr to posix acl\n"); + goto out; + } + + rc = ksmbd_gen_sd_hash(conn, acl_ndr.data, acl_ndr.offset, + acl.posix_acl_hash); + if (rc) { + ksmbd_err("failed to generate hash for ndr acl\n"); + goto out; + } + + rc = ndr_encode_v4_ntacl(&sd_ndr, &acl); + if (rc) { + ksmbd_err("failed to encode ndr to posix acl\n"); + goto out; + } + + rc = ksmbd_vfs_setxattr(dentry, XATTR_NAME_SD, sd_ndr.data, + sd_ndr.offset, 0); + if (rc < 0) + ksmbd_err("Failed to store XATTR ntacl :%d\n", rc); + + kfree(sd_ndr.data); +out: + kfree(acl_ndr.data); + kfree(smb_acl); + kfree(def_smb_acl); + return rc; +} + +int ksmbd_vfs_get_sd_xattr(struct ksmbd_conn *conn, struct dentry *dentry, + struct smb_ntsd **pntsd) +{ + int rc; + struct ndr n; + + rc = ksmbd_vfs_getxattr(dentry, XATTR_NAME_SD, &n.data); + if (rc > 0) { + struct inode *inode = d_inode(dentry); + struct ndr acl_ndr = {0}; + struct xattr_ntacl acl; + struct xattr_smb_acl *smb_acl = NULL, *def_smb_acl = NULL; + __u8 cmp_hash[XATTR_SD_HASH_SIZE] = {0}; + + n.length = rc; + rc = ndr_decode_v4_ntacl(&n, &acl); + if (rc) + return rc; + + smb_acl = ksmbd_vfs_make_xattr_posix_acl(inode, + ACL_TYPE_ACCESS); + if (S_ISDIR(inode->i_mode)) + def_smb_acl = ksmbd_vfs_make_xattr_posix_acl(inode, + ACL_TYPE_DEFAULT); + + rc = ndr_encode_posix_acl(&acl_ndr, inode, smb_acl, def_smb_acl); + if (rc) { + ksmbd_err("failed to encode ndr to posix acl\n"); + goto out; + } + + rc = ksmbd_gen_sd_hash(conn, acl_ndr.data, acl_ndr.offset, + cmp_hash); + if (rc) { + ksmbd_err("failed to generate hash for ndr acl\n"); + goto out; + } + + if (memcmp(cmp_hash, acl.posix_acl_hash, XATTR_SD_HASH_SIZE)) { + ksmbd_err("hash value diff\n"); + rc = -EINVAL; + goto out; + } + + *pntsd = acl.sd_buf; + (*pntsd)->osidoffset = + cpu_to_le32(le32_to_cpu((*pntsd)->osidoffset) - NDR_NTSD_OFFSETOF); + (*pntsd)->gsidoffset = + cpu_to_le32(le32_to_cpu((*pntsd)->gsidoffset) - NDR_NTSD_OFFSETOF); + (*pntsd)->dacloffset = + cpu_to_le32(le32_to_cpu((*pntsd)->dacloffset) - NDR_NTSD_OFFSETOF); + + rc = acl.sd_size; +out: + kfree(n.data); + kfree(acl_ndr.data); + kfree(smb_acl); + kfree(def_smb_acl); + } + + return rc; +} + +int ksmbd_vfs_set_dos_attrib_xattr(struct dentry *dentry, + struct xattr_dos_attrib *da) +{ + struct ndr n; + int err; + + err = ndr_encode_dos_attr(&n, da); + if (err) + return err; + + err = ksmbd_vfs_setxattr(dentry, + XATTR_NAME_DOS_ATTRIBUTE, + (void *)n.data, + n.offset, + 0); + if (err) + ksmbd_debug(SMB, "failed to store dos attribute in xattr\n"); + kfree(n.data); + + return err; +} + +int ksmbd_vfs_get_dos_attrib_xattr(struct dentry *dentry, + struct xattr_dos_attrib *da) +{ + struct ndr n; + int err; + + err = ksmbd_vfs_getxattr(dentry, + XATTR_NAME_DOS_ATTRIBUTE, + (char **)&n.data); + if (err > 0) { + n.length = err; + if (ndr_decode_dos_attr(&n, da)) + err = -EINVAL; + kfree(n.data); + } else { + ksmbd_debug(SMB, "failed to load dos attribute in xattr\n"); + } + + return err; +} + +struct posix_acl *ksmbd_vfs_posix_acl_alloc(int count, gfp_t flags) +{ +#if IS_ENABLED(CONFIG_FS_POSIX_ACL) + return posix_acl_alloc(count, flags); +#else + return NULL; +#endif +} + +struct posix_acl *ksmbd_vfs_get_acl(struct inode *inode, int type) +{ +#if IS_ENABLED(CONFIG_FS_POSIX_ACL) + return get_acl(inode, type); +#else + return NULL; +#endif +} + +int ksmbd_vfs_set_posix_acl(struct inode *inode, int type, + struct posix_acl *acl) +{ +#if IS_ENABLED(CONFIG_FS_POSIX_ACL) + return set_posix_acl(&init_user_ns, inode, type, acl); +#else + return -EOPNOTSUPP; +#endif +} + +/** + * ksmbd_vfs_init_kstat() - convert unix stat information to smb stat format + * @p: destination buffer + * @ksmbd_kstat: ksmbd kstat wrapper + */ +void *ksmbd_vfs_init_kstat(char **p, struct ksmbd_kstat *ksmbd_kstat) +{ + struct file_directory_info *info = (struct file_directory_info *)(*p); + struct kstat *kstat = ksmbd_kstat->kstat; + u64 time; + + info->FileIndex = 0; + info->CreationTime = cpu_to_le64(ksmbd_kstat->create_time); + time = ksmbd_UnixTimeToNT(kstat->atime); + info->LastAccessTime = cpu_to_le64(time); + time = ksmbd_UnixTimeToNT(kstat->mtime); + info->LastWriteTime = cpu_to_le64(time); + time = ksmbd_UnixTimeToNT(kstat->ctime); + info->ChangeTime = cpu_to_le64(time); + + if (ksmbd_kstat->file_attributes & ATTR_DIRECTORY_LE) { + info->EndOfFile = 0; + info->AllocationSize = 0; + } else { + info->EndOfFile = cpu_to_le64(kstat->size); + info->AllocationSize = cpu_to_le64(kstat->blocks << 9); + } + info->ExtFileAttributes = ksmbd_kstat->file_attributes; + + return info; +} + +int ksmbd_vfs_fill_dentry_attrs(struct ksmbd_work *work, struct dentry *dentry, + struct ksmbd_kstat *ksmbd_kstat) +{ + u64 time; + int rc; + + generic_fillattr(&init_user_ns, d_inode(dentry), ksmbd_kstat->kstat); + + time = ksmbd_UnixTimeToNT(ksmbd_kstat->kstat->ctime); + ksmbd_kstat->create_time = time; + + /* + * set default value for the case that store dos attributes is not yes + * or that acl is disable in server's filesystem and the config is yes. + */ + if (S_ISDIR(ksmbd_kstat->kstat->mode)) + ksmbd_kstat->file_attributes = ATTR_DIRECTORY_LE; + else + ksmbd_kstat->file_attributes = ATTR_ARCHIVE_LE; + + if (test_share_config_flag(work->tcon->share_conf, + KSMBD_SHARE_FLAG_STORE_DOS_ATTRS)) { + struct xattr_dos_attrib da; + + rc = ksmbd_vfs_get_dos_attrib_xattr(dentry, &da); + if (rc > 0) { + ksmbd_kstat->file_attributes = cpu_to_le32(da.attr); + ksmbd_kstat->create_time = da.create_time; + } else { + ksmbd_debug(VFS, "fail to load dos attribute.\n"); + } + } + + return 0; +} + +ssize_t ksmbd_vfs_casexattr_len(struct dentry *dentry, char *attr_name, + int attr_name_len) +{ + char *name, *xattr_list = NULL; + ssize_t value_len = -ENOENT, xattr_list_len; + + xattr_list_len = ksmbd_vfs_listxattr(dentry, &xattr_list); + if (xattr_list_len <= 0) + goto out; + + for (name = xattr_list; name - xattr_list < xattr_list_len; + name += strlen(name) + 1) { + ksmbd_debug(VFS, "%s, len %zd\n", name, strlen(name)); + if (strncasecmp(attr_name, name, attr_name_len)) + continue; + + value_len = ksmbd_vfs_xattr_len(dentry, name); + break; + } + +out: + kvfree(xattr_list); + return value_len; +} + +int ksmbd_vfs_xattr_stream_name(char *stream_name, char **xattr_stream_name, + size_t *xattr_stream_name_size, int s_type) +{ + int stream_name_size; + char *xattr_stream_name_buf; + char *type; + int type_len; + + if (s_type == DIR_STREAM) + type = ":$INDEX_ALLOCATION"; + else + type = ":$DATA"; + + type_len = strlen(type); + stream_name_size = strlen(stream_name); + *xattr_stream_name_size = stream_name_size + XATTR_NAME_STREAM_LEN + 1; + xattr_stream_name_buf = kmalloc(*xattr_stream_name_size + type_len, + GFP_KERNEL); + if (!xattr_stream_name_buf) + return -ENOMEM; + + memcpy(xattr_stream_name_buf, + XATTR_NAME_STREAM, + XATTR_NAME_STREAM_LEN); + + if (stream_name_size) { + memcpy(&xattr_stream_name_buf[XATTR_NAME_STREAM_LEN], + stream_name, + stream_name_size); + } + memcpy(&xattr_stream_name_buf[*xattr_stream_name_size - 1], type, type_len); + *xattr_stream_name_size += type_len; + + xattr_stream_name_buf[*xattr_stream_name_size - 1] = '\0'; + *xattr_stream_name = xattr_stream_name_buf; + + return 0; +} + +int ksmbd_vfs_copy_file_range(struct file *file_in, loff_t pos_in, + struct file *file_out, loff_t pos_out, size_t len) +{ + struct inode *inode_in = file_inode(file_in); + struct inode *inode_out = file_inode(file_out); + int ret; + + ret = vfs_copy_file_range(file_in, pos_in, file_out, pos_out, len, 0); + /* do splice for the copy between different file systems */ + if (ret != -EXDEV) + return ret; + + if (S_ISDIR(inode_in->i_mode) || S_ISDIR(inode_out->i_mode)) + return -EISDIR; + if (!S_ISREG(inode_in->i_mode) || !S_ISREG(inode_out->i_mode)) + return -EINVAL; + + if (!(file_in->f_mode & FMODE_READ) || + !(file_out->f_mode & FMODE_WRITE)) + return -EBADF; + + if (len == 0) + return 0; + + file_start_write(file_out); + + /* + * skip the verification of the range of data. it will be done + * in do_splice_direct + */ + ret = do_splice_direct(file_in, &pos_in, file_out, &pos_out, + len > MAX_RW_COUNT ? MAX_RW_COUNT : len, 0); + if (ret > 0) { + fsnotify_access(file_in); + add_rchar(current, ret); + fsnotify_modify(file_out); + add_wchar(current, ret); + } + + inc_syscr(current); + inc_syscw(current); + + file_end_write(file_out); + return ret; +} + +int ksmbd_vfs_copy_file_ranges(struct ksmbd_work *work, + struct ksmbd_file *src_fp, struct ksmbd_file *dst_fp, + struct srv_copychunk *chunks, unsigned int chunk_count, + unsigned int *chunk_count_written, + unsigned int *chunk_size_written, loff_t *total_size_written) +{ + unsigned int i; + loff_t src_off, dst_off, src_file_size; + size_t len; + int ret; + + *chunk_count_written = 0; + *chunk_size_written = 0; + *total_size_written = 0; + + if (!(src_fp->daccess & (FILE_READ_DATA_LE | FILE_EXECUTE_LE))) { + ksmbd_err("no right to read(%s)\n", FP_FILENAME(src_fp)); + return -EACCES; + } + if (!(dst_fp->daccess & (FILE_WRITE_DATA_LE | FILE_APPEND_DATA_LE))) { + ksmbd_err("no right to write(%s)\n", FP_FILENAME(dst_fp)); + return -EACCES; + } + + if (ksmbd_stream_fd(src_fp) || ksmbd_stream_fd(dst_fp)) + return -EBADF; + + smb_break_all_levII_oplock(work, dst_fp, 1); + + if (!work->tcon->posix_extensions) { + for (i = 0; i < chunk_count; i++) { + src_off = le64_to_cpu(chunks[i].SourceOffset); + dst_off = le64_to_cpu(chunks[i].TargetOffset); + len = le32_to_cpu(chunks[i].Length); + + if (check_lock_range(src_fp->filp, src_off, + src_off + len - 1, READ)) + return -EAGAIN; + if (check_lock_range(dst_fp->filp, dst_off, + dst_off + len - 1, WRITE)) + return -EAGAIN; + } + } + + src_file_size = i_size_read(file_inode(src_fp->filp)); + + for (i = 0; i < chunk_count; i++) { + src_off = le64_to_cpu(chunks[i].SourceOffset); + dst_off = le64_to_cpu(chunks[i].TargetOffset); + len = le32_to_cpu(chunks[i].Length); + + if (src_off + len > src_file_size) + return -E2BIG; + + ret = ksmbd_vfs_copy_file_range(src_fp->filp, src_off, + dst_fp->filp, dst_off, len); + if (ret < 0) + return ret; + + *chunk_count_written += 1; + *total_size_written += ret; + } + return 0; +} + +int ksmbd_vfs_posix_lock_wait(struct file_lock *flock) +{ + return wait_event_interruptible(flock->fl_wait, !flock->fl_blocker); +} + +int ksmbd_vfs_posix_lock_wait_timeout(struct file_lock *flock, long timeout) +{ + return wait_event_interruptible_timeout(flock->fl_wait, + !flock->fl_blocker, + timeout); +} + +void ksmbd_vfs_posix_lock_unblock(struct file_lock *flock) +{ + locks_delete_block(flock); +} + +int ksmbd_vfs_set_init_posix_acl(struct inode *inode) +{ + struct posix_acl_state acl_state; + struct posix_acl *acls; + int rc; + + ksmbd_debug(SMB, "Set posix acls\n"); + rc = init_acl_state(&acl_state, 1); + if (rc) + return rc; + + /* Set default owner group */ + acl_state.owner.allow = (inode->i_mode & 0700) >> 6; + acl_state.group.allow = (inode->i_mode & 0070) >> 3; + acl_state.other.allow = inode->i_mode & 0007; + acl_state.users->aces[acl_state.users->n].uid = inode->i_uid; + acl_state.users->aces[acl_state.users->n++].perms.allow = + acl_state.owner.allow; + acl_state.groups->aces[acl_state.groups->n].gid = inode->i_gid; + acl_state.groups->aces[acl_state.groups->n++].perms.allow = + acl_state.group.allow; + acl_state.mask.allow = 0x07; + + acls = ksmbd_vfs_posix_acl_alloc(6, GFP_KERNEL); + if (!acls) { + free_acl_state(&acl_state); + return -ENOMEM; + } + posix_state_to_acl(&acl_state, acls->a_entries); + rc = ksmbd_vfs_set_posix_acl(inode, ACL_TYPE_ACCESS, acls); + if (rc < 0) + ksmbd_debug(SMB, "Set posix acl(ACL_TYPE_ACCESS) failed, rc : %d\n", + rc); + else if (S_ISDIR(inode->i_mode)) { + posix_state_to_acl(&acl_state, acls->a_entries); + rc = ksmbd_vfs_set_posix_acl(inode, ACL_TYPE_DEFAULT, acls); + if (rc < 0) + ksmbd_debug(SMB, "Set posix acl(ACL_TYPE_DEFAULT) failed, rc : %d\n", + rc); + } + free_acl_state(&acl_state); + posix_acl_release(acls); + return rc; +} + +int ksmbd_vfs_inherit_posix_acl(struct inode *inode, struct inode *parent_inode) +{ + struct posix_acl *acls; + struct posix_acl_entry *pace; + int rc, i; + + acls = ksmbd_vfs_get_acl(parent_inode, ACL_TYPE_DEFAULT); + if (!acls) + return -ENOENT; + pace = acls->a_entries; + + for (i = 0; i < acls->a_count; i++, pace++) { + if (pace->e_tag == ACL_MASK) { + pace->e_perm = 0x07; + break; + } + } + + rc = ksmbd_vfs_set_posix_acl(inode, ACL_TYPE_ACCESS, acls); + if (rc < 0) + ksmbd_debug(SMB, "Set posix acl(ACL_TYPE_ACCESS) failed, rc : %d\n", + rc); + if (S_ISDIR(inode->i_mode)) { + rc = ksmbd_vfs_set_posix_acl(inode, ACL_TYPE_DEFAULT, acls); + if (rc < 0) + ksmbd_debug(SMB, "Set posix acl(ACL_TYPE_DEFAULT) failed, rc : %d\n", + rc); + } + posix_acl_release(acls); + return rc; +} diff --git a/fs/cifsd/vfs.h b/fs/cifsd/vfs.h new file mode 100644 index 000000000000..2d19e2bac33a --- /dev/null +++ b/fs/cifsd/vfs.h @@ -0,0 +1,274 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2016 Namjae Jeon <linkinjeon@kernel.org> + * Copyright (C) 2018 Samsung Electronics Co., Ltd. + */ + +#ifndef __KSMBD_VFS_H__ +#define __KSMBD_VFS_H__ + +#include <linux/file.h> +#include <linux/fs.h> +#include <linux/namei.h> +#include <uapi/linux/xattr.h> +#include <linux/posix_acl.h> + +#include "smbacl.h" + +/* STREAM XATTR PREFIX */ +#define STREAM_PREFIX "DosStream." +#define STREAM_PREFIX_LEN (sizeof(STREAM_PREFIX) - 1) +#define XATTR_NAME_STREAM (XATTR_USER_PREFIX STREAM_PREFIX) +#define XATTR_NAME_STREAM_LEN (sizeof(XATTR_NAME_STREAM) - 1) + +enum { + XATTR_DOSINFO_ATTRIB = 0x00000001, + XATTR_DOSINFO_EA_SIZE = 0x00000002, + XATTR_DOSINFO_SIZE = 0x00000004, + XATTR_DOSINFO_ALLOC_SIZE = 0x00000008, + XATTR_DOSINFO_CREATE_TIME = 0x00000010, + XATTR_DOSINFO_CHANGE_TIME = 0x00000020, + XATTR_DOSINFO_ITIME = 0x00000040 +}; + +struct xattr_dos_attrib { + __u16 version; + __u32 flags; + __u32 attr; + __u32 ea_size; + __u64 size; + __u64 alloc_size; + __u64 create_time; + __u64 change_time; + __u64 itime; +}; + +/* DOS ATTRIBUITE XATTR PREFIX */ +#define DOS_ATTRIBUTE_PREFIX "DOSATTRIB" +#define DOS_ATTRIBUTE_PREFIX_LEN (sizeof(DOS_ATTRIBUTE_PREFIX) - 1) +#define XATTR_NAME_DOS_ATTRIBUTE \ + (XATTR_USER_PREFIX DOS_ATTRIBUTE_PREFIX) +#define XATTR_NAME_DOS_ATTRIBUTE_LEN \ + (sizeof(XATTR_USER_PREFIX DOS_ATTRIBUTE_PREFIX) - 1) + +#define XATTR_SD_HASH_TYPE_SHA256 0x1 +#define XATTR_SD_HASH_SIZE 64 + +#define SMB_ACL_READ 4 +#define SMB_ACL_WRITE 2 +#define SMB_ACL_EXECUTE 1 + +enum { + SMB_ACL_TAG_INVALID = 0, + SMB_ACL_USER, + SMB_ACL_USER_OBJ, + SMB_ACL_GROUP, + SMB_ACL_GROUP_OBJ, + SMB_ACL_OTHER, + SMB_ACL_MASK +}; + +struct xattr_acl_entry { + int type; + uid_t uid; + gid_t gid; + mode_t perm; +}; + +struct xattr_smb_acl { + int count; + int next; + struct xattr_acl_entry entries[0]; +}; + +struct xattr_ntacl { + __u16 version; + void *sd_buf; + __u32 sd_size; + __u16 hash_type; + __u8 desc[10]; + __u16 desc_len; + __u64 current_time; + __u8 hash[XATTR_SD_HASH_SIZE]; + __u8 posix_acl_hash[XATTR_SD_HASH_SIZE]; +}; + +/* SECURITY DESCRIPTOR XATTR PREFIX */ +#define SD_PREFIX "NTACL" +#define SD_PREFIX_LEN (sizeof(SD_PREFIX) - 1) +#define XATTR_NAME_SD \ + (XATTR_SECURITY_PREFIX SD_PREFIX) +#define XATTR_NAME_SD_LEN \ + (sizeof(XATTR_SECURITY_PREFIX SD_PREFIX) - 1) + +/* CreateOptions */ +/* Flag is set, it must not be a file , valid for directory only */ +#define FILE_DIRECTORY_FILE_LE cpu_to_le32(0x00000001) +#define FILE_WRITE_THROUGH_LE cpu_to_le32(0x00000002) +#define FILE_SEQUENTIAL_ONLY_LE cpu_to_le32(0x00000004) + +/* Should not buffer on server*/ +#define FILE_NO_INTERMEDIATE_BUFFERING_LE cpu_to_le32(0x00000008) +/* MBZ */ +#define FILE_SYNCHRONOUS_IO_ALERT_LE cpu_to_le32(0x00000010) +/* MBZ */ +#define FILE_SYNCHRONOUS_IO_NONALERT_LE cpu_to_le32(0x00000020) + +/* Flaf must not be set for directory */ +#define FILE_NON_DIRECTORY_FILE_LE cpu_to_le32(0x00000040) + +/* Should be zero */ +#define CREATE_TREE_CONNECTION cpu_to_le32(0x00000080) +#define FILE_COMPLETE_IF_OPLOCKED_LE cpu_to_le32(0x00000100) +#define FILE_NO_EA_KNOWLEDGE_LE cpu_to_le32(0x00000200) +#define FILE_OPEN_REMOTE_INSTANCE cpu_to_le32(0x00000400) + +/** + * Doc says this is obsolete "open for recovery" flag should be zero + * in any case. + */ +#define CREATE_OPEN_FOR_RECOVERY cpu_to_le32(0x00000400) +#define FILE_RANDOM_ACCESS_LE cpu_to_le32(0x00000800) +#define FILE_DELETE_ON_CLOSE_LE cpu_to_le32(0x00001000) +#define FILE_OPEN_BY_FILE_ID_LE cpu_to_le32(0x00002000) +#define FILE_OPEN_FOR_BACKUP_INTENT_LE cpu_to_le32(0x00004000) +#define FILE_NO_COMPRESSION_LE cpu_to_le32(0x00008000) + +/* Should be zero*/ +#define FILE_OPEN_REQUIRING_OPLOCK cpu_to_le32(0x00010000) +#define FILE_DISALLOW_EXCLUSIVE cpu_to_le32(0x00020000) +#define FILE_RESERVE_OPFILTER_LE cpu_to_le32(0x00100000) +#define FILE_OPEN_REPARSE_POINT_LE cpu_to_le32(0x00200000) +#define FILE_OPEN_NO_RECALL_LE cpu_to_le32(0x00400000) + +/* Should be zero */ +#define FILE_OPEN_FOR_FREE_SPACE_QUERY_LE cpu_to_le32(0x00800000) +#define CREATE_OPTIONS_MASK cpu_to_le32(0x00FFFFFF) +#define CREATE_OPTION_READONLY 0x10000000 +/* system. NB not sent over wire */ +#define CREATE_OPTION_SPECIAL 0x20000000 + +struct ksmbd_work; +struct ksmbd_file; +struct ksmbd_conn; + +struct ksmbd_dir_info { + const char *name; + char *wptr; + char *rptr; + int name_len; + int out_buf_len; + int num_entry; + int data_count; + int last_entry_offset; + bool hide_dot_file; + int flags; +}; + +struct ksmbd_readdir_data { + struct dir_context ctx; + union { + void *private; + char *dirent; + }; + + unsigned int used; + unsigned int dirent_count; + unsigned int file_attr; +}; + +/* ksmbd kstat wrapper to get valid create time when reading dir entry */ +struct ksmbd_kstat { + struct kstat *kstat; + unsigned long long create_time; + __le32 file_attributes; +}; + +struct ksmbd_fs_sector_size { + unsigned short logical_sector_size; + unsigned int physical_sector_size; + unsigned int optimal_io_size; +}; + +int ksmbd_vfs_inode_permission(struct dentry *dentry, int acc_mode, + bool delete); +int ksmbd_vfs_query_maximal_access(struct dentry *dentry, __le32 *daccess); +int ksmbd_vfs_create(struct ksmbd_work *work, const char *name, umode_t mode); +int ksmbd_vfs_mkdir(struct ksmbd_work *work, const char *name, umode_t mode); +int ksmbd_vfs_read(struct ksmbd_work *work, struct ksmbd_file *fp, + size_t count, loff_t *pos); +int ksmbd_vfs_write(struct ksmbd_work *work, struct ksmbd_file *fp, + char *buf, size_t count, loff_t *pos, bool sync, + ssize_t *written); +int ksmbd_vfs_fsync(struct ksmbd_work *work, u64 fid, u64 p_id); +int ksmbd_vfs_remove_file(struct ksmbd_work *work, char *name); +int ksmbd_vfs_link(struct ksmbd_work *work, + const char *oldname, const char *newname); +int ksmbd_vfs_getattr(struct path *path, struct kstat *stat); + +int ksmbd_vfs_fp_rename(struct ksmbd_work *work, struct ksmbd_file *fp, + char *newname); + +int ksmbd_vfs_truncate(struct ksmbd_work *work, const char *name, + struct ksmbd_file *fp, loff_t size); + +struct srv_copychunk; +int ksmbd_vfs_copy_file_ranges(struct ksmbd_work *work, + struct ksmbd_file *src_fp, struct ksmbd_file *dst_fp, + struct srv_copychunk *chunks, unsigned int chunk_count, + unsigned int *chunk_count_written, + unsigned int *chunk_size_written, loff_t *total_size_written); +int ksmbd_vfs_copy_file_range(struct file *file_in, loff_t pos_in, + struct file *file_out, loff_t pos_out, size_t len); +ssize_t ksmbd_vfs_listxattr(struct dentry *dentry, char **list); +ssize_t ksmbd_vfs_getxattr(struct dentry *dentry, char *xattr_name, + char **xattr_buf); +ssize_t ksmbd_vfs_casexattr_len(struct dentry *dentry, char *attr_name, + int attr_name_len); +int ksmbd_vfs_setxattr(struct dentry *dentry, const char *attr_name, + const void *attr_value, size_t attr_size, int flags); +int ksmbd_vfs_xattr_stream_name(char *stream_name, char **xattr_stream_name, + size_t *xattr_stream_name_size, int s_type); +int ksmbd_vfs_remove_xattr(struct dentry *dentry, char *attr_name); +int ksmbd_vfs_kern_path(char *name, unsigned int flags, struct path *path, + bool caseless); +int ksmbd_vfs_empty_dir(struct ksmbd_file *fp); +void ksmbd_vfs_set_fadvise(struct file *filp, __le32 option); +int ksmbd_vfs_lock(struct file *filp, int cmd, struct file_lock *flock); +int ksmbd_vfs_readdir(struct file *file, struct ksmbd_readdir_data *rdata); +int ksmbd_vfs_alloc_size(struct ksmbd_work *work, struct ksmbd_file *fp, + loff_t len); +int ksmbd_vfs_zero_data(struct ksmbd_work *work, struct ksmbd_file *fp, + loff_t off, loff_t len); +struct file_allocated_range_buffer; +int ksmbd_vfs_fqar_lseek(struct ksmbd_file *fp, loff_t start, loff_t length, + struct file_allocated_range_buffer *ranges, + int in_count, int *out_count); +int ksmbd_vfs_unlink(struct dentry *dir, struct dentry *dentry); +unsigned short ksmbd_vfs_logical_sector_size(struct inode *inode); +void ksmbd_vfs_smb2_sector_size(struct inode *inode, + struct ksmbd_fs_sector_size *fs_ss); +void *ksmbd_vfs_init_kstat(char **p, struct ksmbd_kstat *ksmbd_kstat); +int ksmbd_vfs_fill_dentry_attrs(struct ksmbd_work *work, struct dentry *dentry, + struct ksmbd_kstat *ksmbd_kstat); +int ksmbd_vfs_posix_lock_wait(struct file_lock *flock); +int ksmbd_vfs_posix_lock_wait_timeout(struct file_lock *flock, long timeout); +void ksmbd_vfs_posix_lock_unblock(struct file_lock *flock); +int ksmbd_vfs_remove_acl_xattrs(struct dentry *dentry); +int ksmbd_vfs_remove_sd_xattrs(struct dentry *dentry); +int ksmbd_vfs_set_sd_xattr(struct ksmbd_conn *conn, struct dentry *dentry, + struct smb_ntsd *pntsd, int len); +int ksmbd_vfs_get_sd_xattr(struct ksmbd_conn *conn, struct dentry *dentry, + struct smb_ntsd **pntsd); +int ksmbd_vfs_set_dos_attrib_xattr(struct dentry *dentry, + struct xattr_dos_attrib *da); +int ksmbd_vfs_get_dos_attrib_xattr(struct dentry *dentry, + struct xattr_dos_attrib *da); +struct posix_acl *ksmbd_vfs_posix_acl_alloc(int count, gfp_t flags); +struct posix_acl *ksmbd_vfs_get_acl(struct inode *inode, int type); +int ksmbd_vfs_set_posix_acl(struct inode *inode, int type, + struct posix_acl *acl); +int ksmbd_vfs_set_init_posix_acl(struct inode *inode); +int ksmbd_vfs_inherit_posix_acl(struct inode *inode, + struct inode *parent_inode); +#endif /* __KSMBD_VFS_H__ */ diff --git a/fs/cifsd/vfs_cache.c b/fs/cifsd/vfs_cache.c new file mode 100644 index 000000000000..3286e74e2a56 --- /dev/null +++ b/fs/cifsd/vfs_cache.c @@ -0,0 +1,683 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * Copyright (C) 2016 Namjae Jeon <linkinjeon@kernel.org> + * Copyright (C) 2019 Samsung Electronics Co., Ltd. + */ + +#include <linux/fs.h> +#include <linux/slab.h> +#include <linux/vmalloc.h> + +#include "glob.h" +#include "vfs_cache.h" +#include "buffer_pool.h" +#include "oplock.h" +#include "vfs.h" +#include "connection.h" +#include "mgmt/tree_connect.h" +#include "mgmt/user_session.h" +#include "smb_common.h" + +#define S_DEL_PENDING 1 +#define S_DEL_ON_CLS 2 +#define S_DEL_ON_CLS_STREAM 8 + +static unsigned int inode_hash_mask __read_mostly; +static unsigned int inode_hash_shift __read_mostly; +static struct hlist_head *inode_hashtable __read_mostly; +static DEFINE_RWLOCK(inode_hash_lock); + +static struct ksmbd_file_table global_ft; +static atomic_long_t fd_limit; + +void ksmbd_set_fd_limit(unsigned long limit) +{ + limit = min(limit, get_max_files()); + atomic_long_set(&fd_limit, limit); +} + +static bool fd_limit_depleted(void) +{ + long v = atomic_long_dec_return(&fd_limit); + + if (v >= 0) + return false; + atomic_long_inc(&fd_limit); + return true; +} + +static void fd_limit_close(void) +{ + atomic_long_inc(&fd_limit); +} + +/* + * INODE hash + */ + +static unsigned long inode_hash(struct super_block *sb, unsigned long hashval) +{ + unsigned long tmp; + + tmp = (hashval * (unsigned long)sb) ^ (GOLDEN_RATIO_PRIME + hashval) / + L1_CACHE_BYTES; + tmp = tmp ^ ((tmp ^ GOLDEN_RATIO_PRIME) >> inode_hash_shift); + return tmp & inode_hash_mask; +} + +static struct ksmbd_inode *__ksmbd_inode_lookup(struct inode *inode) +{ + struct hlist_head *head = inode_hashtable + + inode_hash(inode->i_sb, inode->i_ino); + struct ksmbd_inode *ci = NULL, *ret_ci = NULL; + + hlist_for_each_entry(ci, head, m_hash) { + if (ci->m_inode == inode) { + if (atomic_inc_not_zero(&ci->m_count)) + ret_ci = ci; + break; + } + } + return ret_ci; +} + +static struct ksmbd_inode *ksmbd_inode_lookup(struct ksmbd_file *fp) +{ + return __ksmbd_inode_lookup(FP_INODE(fp)); +} + +static struct ksmbd_inode *ksmbd_inode_lookup_by_vfsinode(struct inode *inode) +{ + struct ksmbd_inode *ci; + + read_lock(&inode_hash_lock); + ci = __ksmbd_inode_lookup(inode); + read_unlock(&inode_hash_lock); + return ci; +} + +int ksmbd_query_inode_status(struct inode *inode) +{ + struct ksmbd_inode *ci; + int ret = KSMBD_INODE_STATUS_UNKNOWN; + + read_lock(&inode_hash_lock); + ci = __ksmbd_inode_lookup(inode); + if (ci) { + ret = KSMBD_INODE_STATUS_OK; + if (ci->m_flags & S_DEL_PENDING) + ret = KSMBD_INODE_STATUS_PENDING_DELETE; + atomic_dec(&ci->m_count); + } + read_unlock(&inode_hash_lock); + return ret; +} + +bool ksmbd_inode_pending_delete(struct ksmbd_file *fp) +{ + return (fp->f_ci->m_flags & S_DEL_PENDING); +} + +void ksmbd_set_inode_pending_delete(struct ksmbd_file *fp) +{ + fp->f_ci->m_flags |= S_DEL_PENDING; +} + +void ksmbd_clear_inode_pending_delete(struct ksmbd_file *fp) +{ + fp->f_ci->m_flags &= ~S_DEL_PENDING; +} + +void ksmbd_fd_set_delete_on_close(struct ksmbd_file *fp, + int file_info) +{ + if (ksmbd_stream_fd(fp)) { + fp->f_ci->m_flags |= S_DEL_ON_CLS_STREAM; + return; + } + + fp->f_ci->m_flags |= S_DEL_ON_CLS; +} + +static void ksmbd_inode_hash(struct ksmbd_inode *ci) +{ + struct hlist_head *b = inode_hashtable + + inode_hash(ci->m_inode->i_sb, ci->m_inode->i_ino); + + hlist_add_head(&ci->m_hash, b); +} + +static void ksmbd_inode_unhash(struct ksmbd_inode *ci) +{ + write_lock(&inode_hash_lock); + hlist_del_init(&ci->m_hash); + write_unlock(&inode_hash_lock); +} + +static int ksmbd_inode_init(struct ksmbd_inode *ci, struct ksmbd_file *fp) +{ + ci->m_inode = FP_INODE(fp); + atomic_set(&ci->m_count, 1); + atomic_set(&ci->op_count, 0); + atomic_set(&ci->sop_count, 0); + ci->m_flags = 0; + ci->m_fattr = 0; + INIT_LIST_HEAD(&ci->m_fp_list); + INIT_LIST_HEAD(&ci->m_op_list); + rwlock_init(&ci->m_lock); + return 0; +} + +static struct ksmbd_inode *ksmbd_inode_get(struct ksmbd_file *fp) +{ + struct ksmbd_inode *ci, *tmpci; + int rc; + + read_lock(&inode_hash_lock); + ci = ksmbd_inode_lookup(fp); + read_unlock(&inode_hash_lock); + if (ci) + return ci; + + ci = kmalloc(sizeof(struct ksmbd_inode), GFP_KERNEL); + if (!ci) + return NULL; + + rc = ksmbd_inode_init(ci, fp); + if (rc) { + ksmbd_err("inode initialized failed\n"); + kfree(ci); + return NULL; + } + + write_lock(&inode_hash_lock); + tmpci = ksmbd_inode_lookup(fp); + if (!tmpci) { + ksmbd_inode_hash(ci); + } else { + kfree(ci); + ci = tmpci; + } + write_unlock(&inode_hash_lock); + return ci; +} + +static void ksmbd_inode_free(struct ksmbd_inode *ci) +{ + ksmbd_inode_unhash(ci); + kfree(ci); +} + +static void ksmbd_inode_put(struct ksmbd_inode *ci) +{ + if (atomic_dec_and_test(&ci->m_count)) + ksmbd_inode_free(ci); +} + +int __init ksmbd_inode_hash_init(void) +{ + unsigned int loop; + unsigned long numentries = 16384; + unsigned long bucketsize = sizeof(struct hlist_head); + unsigned long size; + + inode_hash_shift = ilog2(numentries); + inode_hash_mask = (1 << inode_hash_shift) - 1; + + size = bucketsize << inode_hash_shift; + + /* init master fp hash table */ + inode_hashtable = vmalloc(size); + if (!inode_hashtable) + return -ENOMEM; + + for (loop = 0; loop < (1U << inode_hash_shift); loop++) + INIT_HLIST_HEAD(&inode_hashtable[loop]); + return 0; +} + +void ksmbd_release_inode_hash(void) +{ + vfree(inode_hashtable); +} + +static void __ksmbd_inode_close(struct ksmbd_file *fp) +{ + struct dentry *dir, *dentry; + struct ksmbd_inode *ci = fp->f_ci; + int err; + struct file *filp; + + filp = fp->filp; + if (ksmbd_stream_fd(fp) && (ci->m_flags & S_DEL_ON_CLS_STREAM)) { + ci->m_flags &= ~S_DEL_ON_CLS_STREAM; + err = ksmbd_vfs_remove_xattr(filp->f_path.dentry, + fp->stream.name); + if (err) + ksmbd_err("remove xattr failed : %s\n", + fp->stream.name); + } + + if (atomic_dec_and_test(&ci->m_count)) { + write_lock(&ci->m_lock); + if (ci->m_flags & (S_DEL_ON_CLS | S_DEL_PENDING)) { + dentry = filp->f_path.dentry; + dir = dentry->d_parent; + ci->m_flags &= ~(S_DEL_ON_CLS | S_DEL_PENDING); + write_unlock(&ci->m_lock); + ksmbd_vfs_unlink(dir, dentry); + write_lock(&ci->m_lock); + } + write_unlock(&ci->m_lock); + + ksmbd_inode_free(ci); + } +} + +static void __ksmbd_remove_durable_fd(struct ksmbd_file *fp) +{ + if (!HAS_FILE_ID(fp->persistent_id)) + return; + + write_lock(&global_ft.lock); + idr_remove(global_ft.idr, fp->persistent_id); + write_unlock(&global_ft.lock); +} + +static void __ksmbd_remove_fd(struct ksmbd_file_table *ft, struct ksmbd_file *fp) +{ + if (!HAS_FILE_ID(fp->volatile_id)) + return; + + write_lock(&fp->f_ci->m_lock); + list_del_init(&fp->node); + write_unlock(&fp->f_ci->m_lock); + + write_lock(&ft->lock); + idr_remove(ft->idr, fp->volatile_id); + write_unlock(&ft->lock); +} + +static void __ksmbd_close_fd(struct ksmbd_file_table *ft, struct ksmbd_file *fp) +{ + struct file *filp; + + fd_limit_close(); + __ksmbd_remove_durable_fd(fp); + __ksmbd_remove_fd(ft, fp); + + close_id_del_oplock(fp); + filp = fp->filp; + + __ksmbd_inode_close(fp); + if (!IS_ERR_OR_NULL(filp)) + fput(filp); + kfree(fp->filename); + if (ksmbd_stream_fd(fp)) + kfree(fp->stream.name); + ksmbd_free_file_struct(fp); +} + +static struct ksmbd_file *ksmbd_fp_get(struct ksmbd_file *fp) +{ + if (!atomic_inc_not_zero(&fp->refcount)) + return NULL; + return fp; +} + +static struct ksmbd_file *__ksmbd_lookup_fd(struct ksmbd_file_table *ft, + unsigned int id) +{ + struct ksmbd_file *fp; + + read_lock(&ft->lock); + fp = idr_find(ft->idr, id); + if (fp) + fp = ksmbd_fp_get(fp); + read_unlock(&ft->lock); + return fp; +} + +static void __put_fd_final(struct ksmbd_work *work, struct ksmbd_file *fp) +{ + __ksmbd_close_fd(&work->sess->file_table, fp); + atomic_dec(&work->conn->stats.open_files_count); +} + +static void set_close_state_blocked_works(struct ksmbd_file *fp) +{ + struct ksmbd_work *cancel_work, *ctmp; + + spin_lock(&fp->f_lock); + list_for_each_entry_safe(cancel_work, ctmp, &fp->blocked_works, + fp_entry) { + list_del(&cancel_work->fp_entry); + cancel_work->state = KSMBD_WORK_CLOSED; + cancel_work->cancel_fn(cancel_work->cancel_argv); + } + spin_unlock(&fp->f_lock); +} + +int ksmbd_close_fd(struct ksmbd_work *work, unsigned int id) +{ + struct ksmbd_file *fp; + struct ksmbd_file_table *ft; + + if (!HAS_FILE_ID(id)) + return 0; + + ft = &work->sess->file_table; + read_lock(&ft->lock); + fp = idr_find(ft->idr, id); + if (fp) { + set_close_state_blocked_works(fp); + + if (!atomic_dec_and_test(&fp->refcount)) + fp = NULL; + } + read_unlock(&ft->lock); + + if (!fp) + return -EINVAL; + + __put_fd_final(work, fp); + return 0; +} + +void ksmbd_fd_put(struct ksmbd_work *work, struct ksmbd_file *fp) +{ + if (!fp) + return; + + if (!atomic_dec_and_test(&fp->refcount)) + return; + __put_fd_final(work, fp); +} + +static bool __sanity_check(struct ksmbd_tree_connect *tcon, struct ksmbd_file *fp) +{ + if (!fp) + return false; + if (fp->tcon != tcon) + return false; + return true; +} + +struct ksmbd_file *ksmbd_lookup_foreign_fd(struct ksmbd_work *work, unsigned int id) +{ + return __ksmbd_lookup_fd(&work->sess->file_table, id); +} + +struct ksmbd_file *ksmbd_lookup_fd_fast(struct ksmbd_work *work, unsigned int id) +{ + struct ksmbd_file *fp = __ksmbd_lookup_fd(&work->sess->file_table, id); + + if (__sanity_check(work->tcon, fp)) + return fp; + + ksmbd_fd_put(work, fp); + return NULL; +} + +struct ksmbd_file *ksmbd_lookup_fd_slow(struct ksmbd_work *work, unsigned int id, + unsigned int pid) +{ + struct ksmbd_file *fp; + + if (!HAS_FILE_ID(id)) { + id = work->compound_fid; + pid = work->compound_pfid; + } + + if (!HAS_FILE_ID(id)) + return NULL; + + fp = __ksmbd_lookup_fd(&work->sess->file_table, id); + if (!__sanity_check(work->tcon, fp)) { + ksmbd_fd_put(work, fp); + return NULL; + } + if (fp->persistent_id != pid) { + ksmbd_fd_put(work, fp); + return NULL; + } + return fp; +} + +struct ksmbd_file *ksmbd_lookup_durable_fd(unsigned long long id) +{ + return __ksmbd_lookup_fd(&global_ft, id); +} + +struct ksmbd_file *ksmbd_lookup_fd_cguid(char *cguid) +{ + struct ksmbd_file *fp = NULL; + unsigned int id; + + read_lock(&global_ft.lock); + idr_for_each_entry(global_ft.idr, fp, id) { + if (!memcmp(fp->create_guid, + cguid, + SMB2_CREATE_GUID_SIZE)) { + fp = ksmbd_fp_get(fp); + break; + } + } + read_unlock(&global_ft.lock); + + return fp; +} + +struct ksmbd_file *ksmbd_lookup_fd_inode(struct inode *inode) +{ + struct ksmbd_file *lfp; + struct ksmbd_inode *ci; + struct list_head *cur; + + ci = ksmbd_inode_lookup_by_vfsinode(inode); + if (!ci) + return NULL; + + read_lock(&ci->m_lock); + list_for_each(cur, &ci->m_fp_list) { + lfp = list_entry(cur, struct ksmbd_file, node); + if (inode == FP_INODE(lfp)) { + atomic_dec(&ci->m_count); + read_unlock(&ci->m_lock); + return lfp; + } + } + atomic_dec(&ci->m_count); + read_unlock(&ci->m_lock); + return NULL; +} + +#define OPEN_ID_TYPE_VOLATILE_ID (0) +#define OPEN_ID_TYPE_PERSISTENT_ID (1) + +static void __open_id_set(struct ksmbd_file *fp, unsigned int id, int type) +{ + if (type == OPEN_ID_TYPE_VOLATILE_ID) + fp->volatile_id = id; + if (type == OPEN_ID_TYPE_PERSISTENT_ID) + fp->persistent_id = id; +} + +static int __open_id(struct ksmbd_file_table *ft, struct ksmbd_file *fp, + int type) +{ + unsigned int id = 0; + int ret; + + if (type == OPEN_ID_TYPE_VOLATILE_ID && fd_limit_depleted()) { + __open_id_set(fp, KSMBD_NO_FID, type); + return -EMFILE; + } + + idr_preload(GFP_KERNEL); + write_lock(&ft->lock); + ret = idr_alloc_cyclic(ft->idr, fp, 0, INT_MAX, GFP_NOWAIT); + if (ret >= 0) { + id = ret; + ret = 0; + } else { + id = KSMBD_NO_FID; + fd_limit_close(); + } + + __open_id_set(fp, id, type); + write_unlock(&ft->lock); + idr_preload_end(); + return ret; +} + +unsigned int ksmbd_open_durable_fd(struct ksmbd_file *fp) +{ + __open_id(&global_ft, fp, OPEN_ID_TYPE_PERSISTENT_ID); + return fp->persistent_id; +} + +struct ksmbd_file *ksmbd_open_fd(struct ksmbd_work *work, struct file *filp) +{ + struct ksmbd_file *fp; + int ret; + + fp = ksmbd_alloc_file_struct(); + if (!fp) { + ksmbd_err("Failed to allocate memory\n"); + return ERR_PTR(-ENOMEM); + } + + INIT_LIST_HEAD(&fp->blocked_works); + INIT_LIST_HEAD(&fp->node); + spin_lock_init(&fp->f_lock); + atomic_set(&fp->refcount, 1); + + fp->filp = filp; + fp->conn = work->sess->conn; + fp->tcon = work->tcon; + fp->volatile_id = KSMBD_NO_FID; + fp->persistent_id = KSMBD_NO_FID; + fp->f_ci = ksmbd_inode_get(fp); + + if (!fp->f_ci) { + ksmbd_free_file_struct(fp); + return ERR_PTR(-ENOMEM); + } + + ret = __open_id(&work->sess->file_table, fp, OPEN_ID_TYPE_VOLATILE_ID); + if (ret) { + ksmbd_inode_put(fp->f_ci); + ksmbd_free_file_struct(fp); + return ERR_PTR(ret); + } + + atomic_inc(&work->conn->stats.open_files_count); + return fp; +} + +static int +__close_file_table_ids(struct ksmbd_file_table *ft, struct ksmbd_tree_connect *tcon, + bool (*skip)(struct ksmbd_tree_connect *tcon, struct ksmbd_file *fp)) +{ + unsigned int id; + struct ksmbd_file *fp; + int num = 0; + + idr_for_each_entry(ft->idr, fp, id) { + if (skip(tcon, fp)) + continue; + + set_close_state_blocked_works(fp); + + if (!atomic_dec_and_test(&fp->refcount)) + continue; + __ksmbd_close_fd(ft, fp); + num++; + } + return num; +} + +static bool tree_conn_fd_check(struct ksmbd_tree_connect *tcon, struct ksmbd_file *fp) +{ + return fp->tcon != tcon; +} + +static bool session_fd_check(struct ksmbd_tree_connect *tcon, struct ksmbd_file *fp) +{ + return false; +} + +void ksmbd_close_tree_conn_fds(struct ksmbd_work *work) +{ + int num = __close_file_table_ids(&work->sess->file_table, + work->tcon, + tree_conn_fd_check); + + atomic_sub(num, &work->conn->stats.open_files_count); +} + +void ksmbd_close_session_fds(struct ksmbd_work *work) +{ + int num = __close_file_table_ids(&work->sess->file_table, + work->tcon, + session_fd_check); + + atomic_sub(num, &work->conn->stats.open_files_count); +} + +int ksmbd_init_global_file_table(void) +{ + return ksmbd_init_file_table(&global_ft); +} + +void ksmbd_free_global_file_table(void) +{ + struct ksmbd_file *fp = NULL; + unsigned int id; + + idr_for_each_entry(global_ft.idr, fp, id) { + __ksmbd_remove_durable_fd(fp); + ksmbd_free_file_struct(fp); + } + + ksmbd_destroy_file_table(&global_ft); +} + +int ksmbd_file_table_flush(struct ksmbd_work *work) +{ + struct ksmbd_file *fp = NULL; + unsigned int id; + int ret; + + read_lock(&work->sess->file_table.lock); + idr_for_each_entry(work->sess->file_table.idr, fp, id) { + ret = ksmbd_vfs_fsync(work, fp->volatile_id, KSMBD_NO_FID); + if (ret) + break; + } + read_unlock(&work->sess->file_table.lock); + return ret; +} + +int ksmbd_init_file_table(struct ksmbd_file_table *ft) +{ + ft->idr = kzalloc(sizeof(struct idr), GFP_KERNEL); + if (!ft->idr) + return -ENOMEM; + + idr_init(ft->idr); + rwlock_init(&ft->lock); + return 0; +} + +void ksmbd_destroy_file_table(struct ksmbd_file_table *ft) +{ + if (!ft->idr) + return; + + __close_file_table_ids(ft, NULL, session_fd_check); + idr_destroy(ft->idr); + kfree(ft->idr); + ft->idr = NULL; +} diff --git a/fs/cifsd/vfs_cache.h b/fs/cifsd/vfs_cache.h new file mode 100644 index 000000000000..5638641dd0cf --- /dev/null +++ b/fs/cifsd/vfs_cache.h @@ -0,0 +1,185 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2019 Samsung Electronics Co., Ltd. + */ + +#ifndef __VFS_CACHE_H__ +#define __VFS_CACHE_H__ + +#include <linux/file.h> +#include <linux/fs.h> +#include <linux/rwsem.h> +#include <linux/spinlock.h> +#include <linux/idr.h> +#include <linux/workqueue.h> + +#include "vfs.h" + +/* Windows style file permissions for extended response */ +#define FILE_GENERIC_ALL 0x1F01FF +#define FILE_GENERIC_READ 0x120089 +#define FILE_GENERIC_WRITE 0x120116 +#define FILE_GENERIC_EXECUTE 0X1200a0 + +#define KSMBD_START_FID 0 +#define KSMBD_NO_FID (UINT_MAX) +#define SMB2_NO_FID (0xFFFFFFFFFFFFFFFFULL) + +#define FP_FILENAME(fp) fp->filp->f_path.dentry->d_name.name +#define FP_INODE(fp) d_inode(fp->filp->f_path.dentry) +#define PARENT_INODE(fp) d_inode(fp->filp->f_path.dentry->d_parent) + +#define ATTR_FP(fp) (fp->attrib_only && \ + (fp->cdoption != FILE_OVERWRITE_IF_LE && \ + fp->cdoption != FILE_OVERWRITE_LE && \ + fp->cdoption != FILE_SUPERSEDE_LE)) + +struct ksmbd_conn; +struct ksmbd_session; + +struct ksmbd_lock { + struct file_lock *fl; + struct list_head glist; + struct list_head llist; + unsigned int flags; + int cmd; + int zero_len; + unsigned long long start; + unsigned long long end; +}; + +struct stream { + char *name; + ssize_t size; +}; + +struct ksmbd_inode { + rwlock_t m_lock; + atomic_t m_count; + atomic_t op_count; + /* opinfo count for streams */ + atomic_t sop_count; + struct inode *m_inode; + unsigned int m_flags; + struct hlist_node m_hash; + struct list_head m_fp_list; + struct list_head m_op_list; + struct oplock_info *m_opinfo; + __le32 m_fattr; +}; + +struct ksmbd_file { + struct file *filp; + char *filename; + unsigned int persistent_id; + unsigned int volatile_id; + + spinlock_t f_lock; + + struct ksmbd_inode *f_ci; + struct ksmbd_inode *f_parent_ci; + struct oplock_info __rcu *f_opinfo; + struct ksmbd_conn *conn; + struct ksmbd_tree_connect *tcon; + + atomic_t refcount; + __le32 daccess; + __le32 saccess; + __le32 coption; + __le32 cdoption; + __u64 create_time; + __u64 itime; + + bool is_nt_open; + bool attrib_only; + + char client_guid[16]; + char create_guid[16]; + char app_instance_id[16]; + + struct stream stream; + struct list_head node; + struct list_head blocked_works; + + int durable_timeout; + + /* for SMB1 */ + int pid; + + /* conflict lock fail count for SMB1 */ + unsigned int cflock_cnt; + /* last lock failure start offset for SMB1 */ + unsigned long long llock_fstart; + + int dirent_offset; + + /* if ls is happening on directory, below is valid*/ + struct ksmbd_readdir_data readdir_data; + int dot_dotdot[2]; +}; + +static inline void set_ctx_actor(struct dir_context *ctx, + filldir_t actor) +{ + ctx->actor = actor; +} + +#define KSMBD_NR_OPEN_DEFAULT BITS_PER_LONG + +struct ksmbd_file_table { + rwlock_t lock; + struct idr *idr; +}; + +static inline bool HAS_FILE_ID(unsigned long long req) +{ + unsigned int id = (unsigned int)req; + + return id < KSMBD_NO_FID; +} + +static inline bool ksmbd_stream_fd(struct ksmbd_file *fp) +{ + return fp->stream.name != NULL; +} + +int ksmbd_init_file_table(struct ksmbd_file_table *ft); +void ksmbd_destroy_file_table(struct ksmbd_file_table *ft); +int ksmbd_close_fd(struct ksmbd_work *work, unsigned int id); +struct ksmbd_file *ksmbd_lookup_fd_fast(struct ksmbd_work *work, unsigned int id); +struct ksmbd_file *ksmbd_lookup_foreign_fd(struct ksmbd_work *work, unsigned int id); +struct ksmbd_file *ksmbd_lookup_fd_slow(struct ksmbd_work *work, unsigned int id, + unsigned int pid); +void ksmbd_fd_put(struct ksmbd_work *work, struct ksmbd_file *fp); +struct ksmbd_file *ksmbd_lookup_durable_fd(unsigned long long id); +struct ksmbd_file *ksmbd_lookup_fd_cguid(char *cguid); +struct ksmbd_file *ksmbd_lookup_fd_inode(struct inode *inode); +unsigned int ksmbd_open_durable_fd(struct ksmbd_file *fp); +struct ksmbd_file *ksmbd_open_fd(struct ksmbd_work *work, struct file *filp); +void ksmbd_close_tree_conn_fds(struct ksmbd_work *work); +void ksmbd_close_session_fds(struct ksmbd_work *work); +int ksmbd_close_inode_fds(struct ksmbd_work *work, struct inode *inode); +int ksmbd_init_global_file_table(void); +void ksmbd_free_global_file_table(void); +int ksmbd_file_table_flush(struct ksmbd_work *work); +void ksmbd_set_fd_limit(unsigned long limit); + +/* + * INODE hash + */ +int __init ksmbd_inode_hash_init(void); +void ksmbd_release_inode_hash(void); + +enum KSMBD_INODE_STATUS { + KSMBD_INODE_STATUS_OK, + KSMBD_INODE_STATUS_UNKNOWN, + KSMBD_INODE_STATUS_PENDING_DELETE, +}; + +int ksmbd_query_inode_status(struct inode *inode); +bool ksmbd_inode_pending_delete(struct ksmbd_file *fp); +void ksmbd_set_inode_pending_delete(struct ksmbd_file *fp); +void ksmbd_clear_inode_pending_delete(struct ksmbd_file *fp); +void ksmbd_fd_set_delete_on_close(struct ksmbd_file *fp, + int file_info); +#endif /* __VFS_CACHE_H__ */ -- 2.17.1 ^ permalink raw reply related [flat|nested] 11+ messages in thread
[parent not found: <CGME20210521063559epcas1p2d2b26d889e3cd4945e4a6fea4345c0eb@epcas1p2.samsung.com>]
* [PATCH v3 09/10] cifsd: add Kconfig and Makefile [not found] ` <CGME20210521063559epcas1p2d2b26d889e3cd4945e4a6fea4345c0eb@epcas1p2.samsung.com> @ 2021-05-21 6:26 ` Namjae Jeon 0 siblings, 0 replies; 11+ messages in thread From: Namjae Jeon @ 2021-05-21 6:26 UTC (permalink / raw) To: linux-fsdevel, linux-kernel, linux-cifs Cc: linux-cifsd-devel, smfrench, senozhatsky, hyc.lee, viro, hch, hch, ronniesahlberg, aurelien.aptel, aaptel, sandeen, dan.carpenter, willy, Namjae Jeon, Sergey Senozhatsky, Steve French This adds the Kconfig and Makefile for cifsd. Signed-off-by: Namjae Jeon <namjae.jeon@samsung.com> Signed-off-by: Sergey Senozhatsky <sergey.senozhatsky@gmail.com> Signed-off-by: Hyunchul Lee <hyc.lee@gmail.com> Acked-by: Ronnie Sahlberg <lsahlber@redhat.com> Signed-off-by: Steve French <stfrench@microsoft.com> --- fs/Kconfig | 1 + fs/Makefile | 1 + fs/cifsd/Kconfig | 68 +++++++++++++++++++++++++++++++++++++++++++++++ fs/cifsd/Makefile | 17 ++++++++++++ 4 files changed, 87 insertions(+) create mode 100644 fs/cifsd/Kconfig create mode 100644 fs/cifsd/Makefile diff --git a/fs/Kconfig b/fs/Kconfig index 141a856c50e7..7462761ebd2f 100644 --- a/fs/Kconfig +++ b/fs/Kconfig @@ -344,6 +344,7 @@ config NFS_V4_2_SSC_HELPER source "net/sunrpc/Kconfig" source "fs/ceph/Kconfig" source "fs/cifs/Kconfig" +source "fs/cifsd/Kconfig" source "fs/coda/Kconfig" source "fs/afs/Kconfig" source "fs/9p/Kconfig" diff --git a/fs/Makefile b/fs/Makefile index 9c708e1fbe8f..542a77374d12 100644 --- a/fs/Makefile +++ b/fs/Makefile @@ -98,6 +98,7 @@ obj-$(CONFIG_NLS) += nls/ obj-$(CONFIG_UNICODE) += unicode/ obj-$(CONFIG_SYSV_FS) += sysv/ obj-$(CONFIG_CIFS) += cifs/ +obj-$(CONFIG_SMB_SERVER) += cifsd/ obj-$(CONFIG_HPFS_FS) += hpfs/ obj-$(CONFIG_NTFS_FS) += ntfs/ obj-$(CONFIG_UFS_FS) += ufs/ diff --git a/fs/cifsd/Kconfig b/fs/cifsd/Kconfig new file mode 100644 index 000000000000..e6448b04f46e --- /dev/null +++ b/fs/cifsd/Kconfig @@ -0,0 +1,68 @@ +config SMB_SERVER + tristate "SMB server support (EXPERIMENTAL)" + depends on INET + depends on MULTIUSER + depends on FILE_LOCKING + select NLS + select NLS_UTF8 + select CRYPTO + select CRYPTO_MD4 + select CRYPTO_MD5 + select CRYPTO_HMAC + select CRYPTO_ECB + select CRYPTO_LIB_DES + select CRYPTO_SHA256 + select CRYPTO_CMAC + select CRYPTO_SHA512 + select CRYPTO_AEAD2 + select CRYPTO_CCM + select CRYPTO_GCM + select ASN1 + select OID_REGISTRY + default n + help + Choose Y here if you want to allow SMB3 compliant clients + to access files residing on this system using SMB3 protocol. + To compile the SMB3 server support as a module, + choose M here: the module will be called ksmbd. + + You may choose to use a samba server instead, in which + case you can choose N here. + + You also need to install user space programs which can be found + in cifsd-tools, available from + https://github.com/cifsd-team/cifsd-tools. + More detail about how to run the cifsd kernel server is + available via README file + (https://github.com/cifsd-team/cifsd-tools/blob/master/README). + + cifsd kernel server includes support for auto-negotiation, + Secure negotiate, Pre-authentication integrity, oplock/lease, + compound requests, multi-credit, packet signing, RDMA(smbdirect), + smb3 encryption, copy-offload, secure per-user session + establishment via NTLM or NTLMv2. + +config SMB_SERVER_SMBDIRECT + bool "Support for SMB Direct protocol" + depends on SMB_SERVER=m && INFINIBAND && INFINIBAND_ADDR_TRANS || SMB_SERVER=y && INFINIBAND=y && INFINIBAND_ADDR_TRANS=y + select SG_POOL + default n + + help + Enables SMB Direct support for SMB 3.0, 3.02 and 3.1.1. + + SMB Direct allows transferring SMB packets over RDMA. If unsure, + say N. + +config SMB_SERVER_CHECK_CAP_NET_ADMIN + bool "Enable check network administration capability" + depends on SMB_SERVER + default y + + help + Prevent unprivileged processes to start the cifsd kernel server. + +config SMB_SERVER_KERBEROS5 + bool "Support for Kerberos 5" + depends on SMB_SERVER + default n diff --git a/fs/cifsd/Makefile b/fs/cifsd/Makefile new file mode 100644 index 000000000000..ccacb798a932 --- /dev/null +++ b/fs/cifsd/Makefile @@ -0,0 +1,17 @@ +# SPDX-License-Identifier: GPL-2.0-or-later +# +# Makefile for Linux SMB3 kernel server +# +obj-$(CONFIG_SMB_SERVER) += ksmbd.o + +$(obj)/spnego_negtokeninit.asn1.o: $(obj)/spnego_negtokeninit.asn1.c $(obj)/spnego_negtokeninit.asn1.h +$(obj)/spnego_negtokentarg.asn1.o: $(obj)/spnego_negtokentarg.asn1.c $(obj)/spnego_negtokentarg.asn1.h + +ksmbd-y := unicode.o auth.o vfs.o vfs_cache.o server.o buffer_pool.o \ + misc.o oplock.o connection.o ksmbd_work.o crypto_ctx.o \ + mgmt/ksmbd_ida.o mgmt/user_config.o mgmt/share_config.o \ + mgmt/tree_connect.o mgmt/user_session.o smb_common.o \ + transport_tcp.o transport_ipc.o smbacl.o smb2pdu.o \ + smb2ops.o smb2misc.o spnego_negtokeninit.asn1.o \ + spnego_negtokentarg.asn1.o asn1.o ndr.o +ksmbd-$(CONFIG_SMB_SERVER_SMBDIRECT) += transport_rdma.o -- 2.17.1 ^ permalink raw reply related [flat|nested] 11+ messages in thread
[parent not found: <CGME20210521063600epcas1p4d00e632c185ce7e4896a23f5a4590ad0@epcas1p4.samsung.com>]
* [PATCH v3 10/10] MAINTAINERS: add cifsd kernel server [not found] ` <CGME20210521063600epcas1p4d00e632c185ce7e4896a23f5a4590ad0@epcas1p4.samsung.com> @ 2021-05-21 6:26 ` Namjae Jeon 0 siblings, 0 replies; 11+ messages in thread From: Namjae Jeon @ 2021-05-21 6:26 UTC (permalink / raw) To: linux-fsdevel, linux-kernel, linux-cifs Cc: linux-cifsd-devel, smfrench, senozhatsky, hyc.lee, viro, hch, hch, ronniesahlberg, aurelien.aptel, aaptel, sandeen, dan.carpenter, willy, Namjae Jeon, Sergey Senozhatsky, Steve French Add myself, Steve French, Sergey Senozhatsky and Hyunchul Lee as cifsd maintainer. Signed-off-by: Namjae Jeon <namjae.jeon@samsung.com> Signed-off-by: Sergey Senozhatsky <sergey.senozhatsky@gmail.com> Signed-off-by: Hyunchul Lee <hyc.lee@gmail.com> Acked-by: Ronnie Sahlberg <lsahlber@redhat.com> Signed-off-by: Steve French <stfrench@microsoft.com> --- MAINTAINERS | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/MAINTAINERS b/MAINTAINERS index bd7aff0c120f..f23bb5cbfd70 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -4530,7 +4530,7 @@ F: include/linux/clk/ F: include/linux/of_clk.h X: drivers/clk/clkdev.c -COMMON INTERNET FILE SYSTEM (CIFS) +COMMON INTERNET FILE SYSTEM CLIENT (CIFS) M: Steve French <sfrench@samba.org> L: linux-cifs@vger.kernel.org L: samba-technical@lists.samba.org (moderated for non-subscribers) @@ -4540,6 +4540,16 @@ T: git git://git.samba.org/sfrench/cifs-2.6.git F: Documentation/admin-guide/cifs/ F: fs/cifs/ +COMMON INTERNET FILE SYSTEM SERVER (CIFSD) +M: Namjae Jeon <namjae.jeon@samsung.com> +M: Sergey Senozhatsky <sergey.senozhatsky@gmail.com> +M: Steve French <sfrench@samba.org> +M: Hyunchul Lee <hyc.lee@gmail.com> +L: linux-cifs@vger.kernel.org +L: linux-cifsd-devel@lists.sourceforge.net +S: Maintained +F: fs/cifsd/ + COMPACTPCI HOTPLUG CORE M: Scott Murray <scott@spiteful.org> L: linux-pci@vger.kernel.org -- 2.17.1 ^ permalink raw reply related [flat|nested] 11+ messages in thread
* Re: [PATCH v3 00/10] cifsd: introduce new SMB3 kernel server 2021-05-21 6:26 ` [PATCH v3 00/10] cifsd: introduce new SMB3 kernel server Namjae Jeon ` (6 preceding siblings ...) [not found] ` <CGME20210521063600epcas1p4d00e632c185ce7e4896a23f5a4590ad0@epcas1p4.samsung.com> @ 2021-05-22 1:55 ` Steve French 7 siblings, 0 replies; 11+ messages in thread From: Steve French @ 2021-05-22 1:55 UTC (permalink / raw) To: Namjae Jeon Cc: linux-fsdevel, LKML, CIFS, COMMON INTERNET FILE SYSTEM SERVER, senozhatsky, Hyeoncheol Lee, Al Viro, Christoph Hellwig, Christoph Hellwig, ronnie sahlberg, Aurélien Aptel, Aurélien Aptel, Eric Sandeen, Dan Carpenter, Matthew Wilcox I just reran the regression test suite from Linux client again against current ksmbd. It passed all. http://smb3-test-rhel-75.southcentralus.cloudapp.azure.com/#/builders/8/builds/38 On Fri, May 21, 2021 at 1:35 AM Namjae Jeon <namjae.jeon@samsung.com> wrote: > > This is the patch series for cifsd(ksmbd) kernel server. > > What is cifsd(ksmbd) ? > ====================== > > The SMB family of protocols is the most widely deployed > network filesystem protocol, the default on Windows and Macs (and even > on many phones and tablets), with clients and servers on all major > operating systems, but lacked a kernel server for Linux. For many > cases the current userspace server choices were suboptimal > either due to memory footprint, performance or difficulty integrating > well with advanced Linux features. > > ksmbd is a new kernel module which implements the server-side of the SMB3 protocol. > The target is to provide optimized performance, GPLv2 SMB server, better > lease handling (distributed caching). The bigger goal is to add new > features more rapidly (e.g. RDMA aka "smbdirect", and recent encryption > and signing improvements to the protocol) which are easier to develop > on a smaller, more tightly optimized kernel server than for example > in Samba. The Samba project is much broader in scope (tools, security services, > LDAP, Active Directory Domain Controller, and a cross platform file server > for a wider variety of purposes) but the user space file server portion > of Samba has proved hard to optimize for some Linux workloads, including > for smaller devices. This is not meant to replace Samba, but rather be > an extension to allow better optimizing for Linux, and will continue to > integrate well with Samba user space tools and libraries where appropriate. > Working with the Samba team we have already made sure that the configuration > files and xattrs are in a compatible format between the kernel and > user space server. > > > Architecture > ============ > > |--- ... > --------|--- ksmbd/3 - Client 3 > |-------|--- ksmbd/2 - Client 2 > | | ____________________________________________________ > | | |- Client 1 | > <--- Socket ---|--- ksmbd/1 <<= Authentication : NTLM/NTLM2, Kerberos | > | | | | <<= SMB engine : SMB2, SMB2.1, SMB3, SMB3.0.2, | > | | | | SMB3.1.1 | > | | | |____________________________________________________| > | | | > | | |--- VFS --- Local Filesystem > | | > KERNEL |--- ksmbd/0(forker kthread) > ---------------||--------------------------------------------------------------- > USER || > || communication using NETLINK > || ______________________________________________ > || | | > ksmbd.mountd <<= DCE/RPC(srvsvc, wkssvc, samr, lsarpc) | > ^ | <<= configure shares setting, user accounts | > | |______________________________________________| > | > |------ smb.conf(config file) > | > |------ ksmbdpwd.db(user account/password file) > ^ > ksmbd.adduser ------------| > > The subset of performance related operations(open/read/write/close etc.) belong > in kernelspace(ksmbd) and the other subset which belong to operations(DCE/RPC, > user account/share database) which are not really related with performance are > handled in userspace(ksmbd.mountd). > > When the ksmbd.mountd is started, It starts up a forker thread at initialization > time and opens a dedicated port 445 for listening to SMB requests. Whenever new > clients make request, Forker thread will accept the client connection and fork > a new thread for dedicated communication channel between the client and > the server. > > > ksmbd feature status > ==================== > > ============================== ================================================= > Feature name Status > ============================== ================================================= > Dialects Supported. SMB2.1 SMB3.0, SMB3.1.1 dialects > (intentionally excludes security vulnerable SMB1 dialect). > Auto Negotiation Supported. > Compound Request Supported. > Oplock Cache Mechanism Supported. > SMB2 leases(v1 lease) Supported. > Directory leases(v2 lease) Planned for future. > Multi-credits Supported. > NTLM/NTLMv2 Supported. > HMAC-SHA256 Signing Supported. > Secure negotiate Supported. > Signing Update Supported. > Pre-authentication integrity Supported. > SMB3 encryption(CCM, GCM) Supported. (CCM and GCM128 supported, GCM256 in progress) > SMB direct(RDMA) Partially Supported. SMB3 Multi-channel is required > to connect to Windows client. > SMB3 Multi-channel In Progress. > SMB3.1.1 POSIX extension Supported. > ACLs Partially Supported. only DACLs available, SACLs > (auditing) is planned for the future. For > ownership (SIDs) ksmbd generates random subauth > values(then store it to disk) and use uid/gid > get from inode as RID for local domain SID. > The current acl implementation is limited to > standalone server, not a domain member. > Integration with Samba tools is being worked on to > allow future support for running as a domain member. > Kerberos Supported. > Durable handle v1,v2 Planned for future. > Persistent handle Planned for future. > SMB2 notify Planned for future. > Sparse file support Supported. > DCE/RPC support Partially Supported. a few calls(NetShareEnumAll, > NetServerGetInfo, SAMR, LSARPC) that are needed > for file server handled via netlink interface from > ksmbd.mountd. Additional integration with Samba > tools and libraries via upcall is being investigated > to allow support for additional DCE/RPC management > calls (and future support for Witness protocol e.g.) > ksmbd/nfsd interoperability Planned for future. The features that ksmbd > support are Leases, Notify, ACLs and Share modes. > ============================== ================================================= > > All features required as file server are currently implemented in ksmbd. > In particular, the implementation of SMB Direct(RDMA) is only currently > possible with ksmbd (among Linux servers) > > > Stability > ========= > > It has been proved to be stable. A significant amount of xfstests pass and > are run regularly from Linux to Linux: > > http://smb3-test-rhel-75.southcentralus.cloudapp.azure.com/#/builders/8/builds/36 > > In addition regression tests using the broadest SMB3 functional test suite > (Samba's "smbtorture") are run on every checkin. > It has already been used by many other open source toolkits and commercial companies > that need NAS functionality. Their issues have been fixed and contributions are > applied into ksmbd. Ksmbd has been well tested and verified in the field and market. > > > Mailing list and repositories > ============================= > - linux-cifsd-devel@lists.sourceforge.net > - https://github.com/smfrench/smb3-kernel/tree/cifsd-for-next > - https://github.com/cifsd-team/cifsd (out-of-tree) > - https://github.com/cifsd-team/ksmbd-tools > > > How to run ksmbd > ================ > > a. Download ksmbd-tools and compile them. > - https://github.com/cifsd-team/ksmbd-tools > > b. Create user/password for SMB share. > > # mkdir /etc/ksmbd/ > # ksmbd.adduser -a <Enter USERNAME for SMB share access> > > c. Create /etc/ksmbd/smb.conf file, add SMB share in smb.conf file > - Refer smb.conf.example and Documentation/configuration.txt > in ksmbd-tools > > d. Insert ksmbd.ko module > > # insmod ksmbd.ko > > e. Start ksmbd user space daemon > # ksmbd.mountd > > f. Access share from Windows or Linux using SMB > e.g. "mount -t cifs //server/share /mnt ..." > > > v3: > - fix boolreturn.cocci warnings. (kernel test robot) > - fix xfstests generic/504 test failure. > - do not use 0 or 0xFFFFFFFF for TreeID. (Marios Makassikis) > - add support for FSCTL_DUPLICATE_EXTENTS_TO_FILE. > - fix build error without CONFIG_OID_REGISTRY. (Wei Yongjun) > - fix invalid memory access in smb2_write(). (Coverity Scan) > - add support for AES256 encryption. > - fix potential null-ptr-deref in destroy_previous_session(). (Marios Makassikis). > - update out_buf_len in smb2_populate_readdir_entry(). (Marios Makassikis) > - handle ksmbd_session_rpc_open() failure in create_smb2_pipe(). (Marios Makassikis) > - call smb2_set_err_rsp() in smb2_read/smb2_write error path. (Marios Makassikis) > - add ksmbd/nfsd interoperability to feature table. (Amir Goldstein) > - fix regression in smb2_get_info. (Sebastian Gottschall) > - remove is_attributes_write_allowed() wrapper. (Marios Makassikis) > - update access check in set_file_allocation_info/set_end_of_file_info. (Marios Makassikis) > > v2: > - fix an error code in smb2_read(). (Dan Carpenter) > - fix error handling in ksmbd_server_init() (Dan Carpenter) > - remove redundant assignment to variable err. (Colin Ian King) > - remove unneeded macros. > - fix wrong use of rw semaphore in __session_create(). > - use kmalloc() for small allocations. > - add the check to work file lock and rename behaviors like Windows > unless POSIX extensions are negotiated. > - clean-up codes using chechpatch.pl --strict. > - merge time_wrappers.h into smb_common.h. > - fix wrong prototype in comment (kernel test robot). > - fix implicit declaration of function 'groups_alloc' (kernel test robot). > - fix implicit declaration of function 'locks_alloc_lock' (kernel test robot). > - remove smack inherit leftovers. > - remove calling d_path in error paths. > - handle unhashed dentry in ksmbd_vfs_mkdir. > - use file_inode() instead of d_inode(). > - remove useless error handling in ksmbd_vfs_read. > - use xarray instead of linked list for tree connect list. > - remove stale prototype and variables. > - fix memory leak when loop ends (coverity-bot, Muhammad Usama Anjum). > - use kfree to free memory allocated by kmalloc or kzalloc (Muhammad Usama Anjum). > - fix memdup.cocci warnings (kernel test robot) > - remove wrappers of kvmalloc/kvfree. > - change the reference to configuration.txt (Mauro Carvalho Chehab). > - prevent a integer overflow in wm_alloc(). > - select SG_POOL for SMB_SERVER_SMBDIRECT. (Zhang Xiaoxu). > - remove unused including <linux/version.h> (Tian Tao). > - declare ida statically. > - add the check if parent is stable by unexpected rename. > - get parent dentry from child in ksmbd_vfs_remove_file(). > - re-implement ksmbd_vfs_kern_path. > - fix reference count decrement of unclaimed file in __ksmbd_lookup_fd. > - remove smb2_put_name(). (Marios Makassikis). > - remove unused smberr.h, nterr.c and netmisc.c. > - fix potential null-ptr-deref in smb2_open() (Marios Makassikis). > - use d_inode(). > - remove the dead code of unimplemented durable handle. > - use the generic one in lib/asn1_decoder.c > > v1: > - fix a handful of spelling mistakes (Colin Ian King) > - fix a precedence bug in parse_dacl() (Dan Carpenter) > - fix a IS_ERR() vs NULL bug (Dan Carpenter) > - fix a use after free on error path (Dan Carpenter) > - update cifsd.rst Documentation > - remove unneeded FIXME comments > - fix static checker warnings (Dan Carpenter) > - fix WARNING: unmet direct dependencies detected for CRYPTO_ARC4 (Randy Dunlap) > - uniquify extract_sharename() (Stephen Rothwell) > - fix WARNING: document isn't included in any toctree (Stephen Rothwell) > - fix WARNING: Title overline too short (Stephen Rothwell) > - fix warning: variable 'total_ace_size' and 'posix_ccontext'set but not used (kernel test rotbot) > - fix incorrect function comments (kernel test robot) > > Namjae Jeon (10): > cifsd: add document > cifsd: add server handler > cifsd: add trasport layers > cifsd: add authentication > cifsd: add smb3 engine part 1 > cifsd: add smb3 engine part 2 > cifsd: add oplock/lease cache mechanism > cifsd: add file operations > cifsd: add Kconfig and Makefile > MAINTAINERS: add cifsd kernel server > > Documentation/filesystems/cifs/cifsd.rst | 164 + > Documentation/filesystems/cifs/index.rst | 10 + > Documentation/filesystems/index.rst | 2 +- > MAINTAINERS | 12 +- > fs/Kconfig | 1 + > fs/Makefile | 1 + > fs/cifsd/Kconfig | 68 + > fs/cifsd/Makefile | 17 + > fs/cifsd/asn1.c | 352 + > fs/cifsd/asn1.h | 29 + > fs/cifsd/auth.c | 1344 ++++ > fs/cifsd/auth.h | 90 + > fs/cifsd/buffer_pool.c | 264 + > fs/cifsd/buffer_pool.h | 20 + > fs/cifsd/connection.c | 411 ++ > fs/cifsd/connection.h | 208 + > fs/cifsd/crypto_ctx.c | 286 + > fs/cifsd/crypto_ctx.h | 77 + > fs/cifsd/glob.h | 64 + > fs/cifsd/ksmbd_server.h | 283 + > fs/cifsd/ksmbd_work.c | 93 + > fs/cifsd/ksmbd_work.h | 110 + > fs/cifsd/mgmt/ksmbd_ida.c | 46 + > fs/cifsd/mgmt/ksmbd_ida.h | 34 + > fs/cifsd/mgmt/share_config.c | 239 + > fs/cifsd/mgmt/share_config.h | 81 + > fs/cifsd/mgmt/tree_connect.c | 122 + > fs/cifsd/mgmt/tree_connect.h | 56 + > fs/cifsd/mgmt/user_config.c | 70 + > fs/cifsd/mgmt/user_config.h | 66 + > fs/cifsd/mgmt/user_session.c | 328 + > fs/cifsd/mgmt/user_session.h | 103 + > fs/cifsd/misc.c | 340 + > fs/cifsd/misc.h | 44 + > fs/cifsd/ndr.c | 347 + > fs/cifsd/ndr.h | 21 + > fs/cifsd/nterr.h | 545 ++ > fs/cifsd/ntlmssp.h | 169 + > fs/cifsd/oplock.c | 1667 +++++ > fs/cifsd/oplock.h | 133 + > fs/cifsd/server.c | 631 ++ > fs/cifsd/server.h | 60 + > fs/cifsd/smb2misc.c | 435 ++ > fs/cifsd/smb2ops.c | 300 + > fs/cifsd/smb2pdu.c | 8151 ++++++++++++++++++++++ > fs/cifsd/smb2pdu.h | 1664 +++++ > fs/cifsd/smb_common.c | 652 ++ > fs/cifsd/smb_common.h | 544 ++ > fs/cifsd/smbacl.c | 1317 ++++ > fs/cifsd/smbacl.h | 201 + > fs/cifsd/smbfsctl.h | 91 + > fs/cifsd/smbstatus.h | 1822 +++++ > fs/cifsd/spnego_negtokeninit.asn1 | 43 + > fs/cifsd/spnego_negtokentarg.asn1 | 19 + > fs/cifsd/transport_ipc.c | 881 +++ > fs/cifsd/transport_ipc.h | 54 + > fs/cifsd/transport_rdma.c | 2034 ++++++ > fs/cifsd/transport_rdma.h | 61 + > fs/cifsd/transport_tcp.c | 618 ++ > fs/cifsd/transport_tcp.h | 13 + > fs/cifsd/unicode.c | 383 + > fs/cifsd/unicode.h | 356 + > fs/cifsd/uniupr.h | 268 + > fs/cifsd/vfs.c | 1995 ++++++ > fs/cifsd/vfs.h | 274 + > fs/cifsd/vfs_cache.c | 683 ++ > fs/cifsd/vfs_cache.h | 185 + > 67 files changed, 32050 insertions(+), 2 deletions(-) > create mode 100644 Documentation/filesystems/cifs/cifsd.rst > create mode 100644 Documentation/filesystems/cifs/index.rst > create mode 100644 fs/cifsd/Kconfig > create mode 100644 fs/cifsd/Makefile > create mode 100644 fs/cifsd/asn1.c > create mode 100644 fs/cifsd/asn1.h > create mode 100644 fs/cifsd/auth.c > create mode 100644 fs/cifsd/auth.h > create mode 100644 fs/cifsd/buffer_pool.c > create mode 100644 fs/cifsd/buffer_pool.h > create mode 100644 fs/cifsd/connection.c > create mode 100644 fs/cifsd/connection.h > create mode 100644 fs/cifsd/crypto_ctx.c > create mode 100644 fs/cifsd/crypto_ctx.h > create mode 100644 fs/cifsd/glob.h > create mode 100644 fs/cifsd/ksmbd_server.h > create mode 100644 fs/cifsd/ksmbd_work.c > create mode 100644 fs/cifsd/ksmbd_work.h > create mode 100644 fs/cifsd/mgmt/ksmbd_ida.c > create mode 100644 fs/cifsd/mgmt/ksmbd_ida.h > create mode 100644 fs/cifsd/mgmt/share_config.c > create mode 100644 fs/cifsd/mgmt/share_config.h > create mode 100644 fs/cifsd/mgmt/tree_connect.c > create mode 100644 fs/cifsd/mgmt/tree_connect.h > create mode 100644 fs/cifsd/mgmt/user_config.c > create mode 100644 fs/cifsd/mgmt/user_config.h > create mode 100644 fs/cifsd/mgmt/user_session.c > create mode 100644 fs/cifsd/mgmt/user_session.h > create mode 100644 fs/cifsd/misc.c > create mode 100644 fs/cifsd/misc.h > create mode 100644 fs/cifsd/ndr.c > create mode 100644 fs/cifsd/ndr.h > create mode 100644 fs/cifsd/nterr.h > create mode 100644 fs/cifsd/ntlmssp.h > create mode 100644 fs/cifsd/oplock.c > create mode 100644 fs/cifsd/oplock.h > create mode 100644 fs/cifsd/server.c > create mode 100644 fs/cifsd/server.h > create mode 100644 fs/cifsd/smb2misc.c > create mode 100644 fs/cifsd/smb2ops.c > create mode 100644 fs/cifsd/smb2pdu.c > create mode 100644 fs/cifsd/smb2pdu.h > create mode 100644 fs/cifsd/smb_common.c > create mode 100644 fs/cifsd/smb_common.h > create mode 100644 fs/cifsd/smbacl.c > create mode 100644 fs/cifsd/smbacl.h > create mode 100644 fs/cifsd/smbfsctl.h > create mode 100644 fs/cifsd/smbstatus.h > create mode 100644 fs/cifsd/spnego_negtokeninit.asn1 > create mode 100644 fs/cifsd/spnego_negtokentarg.asn1 > create mode 100644 fs/cifsd/transport_ipc.c > create mode 100644 fs/cifsd/transport_ipc.h > create mode 100644 fs/cifsd/transport_rdma.c > create mode 100644 fs/cifsd/transport_rdma.h > create mode 100644 fs/cifsd/transport_tcp.c > create mode 100644 fs/cifsd/transport_tcp.h > create mode 100644 fs/cifsd/unicode.c > create mode 100644 fs/cifsd/unicode.h > create mode 100644 fs/cifsd/uniupr.h > create mode 100644 fs/cifsd/vfs.c > create mode 100644 fs/cifsd/vfs.h > create mode 100644 fs/cifsd/vfs_cache.c > create mode 100644 fs/cifsd/vfs_cache.h > > -- > 2.17.1 > -- Thanks, Steve ^ permalink raw reply [flat|nested] 11+ messages in thread
end of thread, other threads:[~2021-05-22 1:55 UTC | newest]
Thread overview: 11+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
[not found] <CGME20210521063549epcas1p204e171a2ba5a06d1b50e490f5e742b25@epcas1p2.samsung.com>
2021-05-21 6:26 ` [PATCH v3 00/10] cifsd: introduce new SMB3 kernel server Namjae Jeon
[not found] ` <CGME20210521063551epcas1p4f9c25b83b0088b3631c0860f5f715c52@epcas1p4.samsung.com>
2021-05-21 6:26 ` [PATCH v3 01/10] cifsd: add document Namjae Jeon
[not found] ` <CGME20210521063552epcas1p3872f5619ef5e9f2f3cad7c0651b5edcb@epcas1p3.samsung.com>
2021-05-21 6:26 ` [PATCH v3 02/10] cifsd: add server handler Namjae Jeon
[not found] ` <CGME20210521063554epcas1p2b7c2f4766547f7f3deec29f1fc5b7c3f@epcas1p2.samsung.com>
2021-05-21 6:26 ` [PATCH v3 04/10] cifsd: add authentication Namjae Jeon
2021-05-21 10:31 ` Dan Carpenter
2021-05-22 1:00 ` [Linux-cifsd-devel] " Namjae Jeon
[not found] ` <CGME20210521063557epcas1p20d8b4fc461f05c1a9c638605e85adbd8@epcas1p2.samsung.com>
2021-05-21 6:26 ` [PATCH v3 07/10] cifsd: add oplock/lease cache mechanism Namjae Jeon
[not found] ` <CGME20210521063558epcas1p495b6140258d943e8db06176fe350ad17@epcas1p4.samsung.com>
2021-05-21 6:26 ` [PATCH v3 08/10] cifsd: add file operations Namjae Jeon
[not found] ` <CGME20210521063559epcas1p2d2b26d889e3cd4945e4a6fea4345c0eb@epcas1p2.samsung.com>
2021-05-21 6:26 ` [PATCH v3 09/10] cifsd: add Kconfig and Makefile Namjae Jeon
[not found] ` <CGME20210521063600epcas1p4d00e632c185ce7e4896a23f5a4590ad0@epcas1p4.samsung.com>
2021-05-21 6:26 ` [PATCH v3 10/10] MAINTAINERS: add cifsd kernel server Namjae Jeon
2021-05-22 1:55 ` [PATCH v3 00/10] cifsd: introduce new SMB3 " Steve French
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for NNTP newsgroup(s).