ksmbd: use SHA-256 library API instead of crypto_shash API

ksmbd_gen_sd_hash() does not support any other algorithm, so the
crypto_shash abstraction provides no value.  Just use the SHA-256
library API instead, which is much simpler and easier to use.

Signed-off-by: Eric Biggers <ebiggers@google.com>
Acked-by: Namjae Jeon <linkinjeon@kernel.org>
Signed-off-by: Steve French <stfrench@microsoft.com>

diff --git a/fs/smb/server/Kconfig b/fs/smb/server/Kconfig
index cf70e96ad4deeb8576b0400895cd40105806cdef..4a23a5e7e8fecd51d807d995f10ece12beebcc5f 100644 (file)
--- a/fs/smb/server/Kconfig
+++ b/fs/smb/server/Kconfig
@@ -11,6 +11,7 @@ config SMB_SERVER
        select CRYPTO_HMAC
        select CRYPTO_ECB
        select CRYPTO_LIB_DES
+       select CRYPTO_LIB_SHA256
        select CRYPTO_SHA256
        select CRYPTO_CMAC
        select CRYPTO_SHA512

diff --git a/fs/smb/server/auth.c b/fs/smb/server/auth.c
index b3d121052408cca062ce72f570e8bff690a0a283..d99871c214518f4e4bd0fd48a6ec51054b8d3eb4 100644 (file)
--- a/fs/smb/server/auth.c
+++ b/fs/smb/server/auth.c
@@ -979,40 +979,6 @@ out:
        return rc;
 }
 
-int ksmbd_gen_sd_hash(struct ksmbd_conn *conn, char *sd_buf, int len,
-                     __u8 *pi_hash)
-{
-       int rc;
-       struct ksmbd_crypto_ctx *ctx = NULL;
-
-       ctx = ksmbd_crypto_ctx_find_sha256();
-       if (!ctx) {
-               ksmbd_debug(AUTH, "could not alloc sha256\n");
-               return -ENOMEM;
-       }
-
-       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_work *work, __u64 ses_id,
                                    int enc, u8 *key)
 {

diff --git a/fs/smb/server/auth.h b/fs/smb/server/auth.h
index 362b6159a6cffbd1c38361e6f695211199866644..6879a1bd1b91f5175ad474db03211ae6dc1de77a 100644 (file)
--- a/fs/smb/server/auth.h
+++ b/fs/smb/server/auth.h
@@ -66,6 +66,4 @@ int ksmbd_gen_smb311_encryptionkey(struct ksmbd_conn *conn,
                                   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/smb/server/crypto_ctx.c b/fs/smb/server/crypto_ctx.c
index ce733dc9a4a35b4aefbf6a0556d77dc92083a7c7..80bd68c8635ea7d301768f502f69fad2c30f2d9b 100644 (file)
--- a/fs/smb/server/crypto_ctx.c
+++ b/fs/smb/server/crypto_ctx.c
@@ -75,9 +75,6 @@ static struct shash_desc *alloc_shash_desc(int id)
        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;
@@ -198,11 +195,6 @@ 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);

diff --git a/fs/smb/server/crypto_ctx.h b/fs/smb/server/crypto_ctx.h
index 4a367c62f6536662979a3cb4caf8ad2a253fcb9a..ac64801d52d38a49ea0a7ee16ba5ea37d7a63c07 100644 (file)
--- a/fs/smb/server/crypto_ctx.h
+++ b/fs/smb/server/crypto_ctx.h
@@ -13,7 +13,6 @@ enum {
        CRYPTO_SHASH_HMACMD5    = 0,
        CRYPTO_SHASH_HMACSHA256,
        CRYPTO_SHASH_CMACAES,
-       CRYPTO_SHASH_SHA256,
        CRYPTO_SHASH_SHA512,
        CRYPTO_SHASH_MAX,
 };
@@ -39,14 +38,12 @@ struct ksmbd_crypto_ctx {
 #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_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_GCM(c)          ((c)->ccmaes[CRYPTO_AEAD_AES_GCM])
@@ -57,7 +54,6 @@ 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_gcm(void);
 struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_ccm(void);
 void ksmbd_crypto_destroy(void);

diff --git a/fs/smb/server/vfs.c b/fs/smb/server/vfs.c
index baf0d3031a44a0b5c46f1c4ad69fe3e02269387b..ba45e809555a722ad1c9ab7466150d82c2f899df 100644 (file)
--- a/fs/smb/server/vfs.c
+++ b/fs/smb/server/vfs.c
@@ -4,6 +4,7 @@
  *   Copyright (C) 2018 Samsung Electronics Co., Ltd.
  */
 
+#include <crypto/sha2.h>
 #include <linux/kernel.h>
 #include <linux/fs.h>
 #include <linux/filelock.h>
@@ -1476,11 +1477,7 @@ int ksmbd_vfs_set_sd_xattr(struct ksmbd_conn *conn,
        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) {
-               pr_err("failed to generate hash for ndr acl\n");
-               return rc;
-       }
+       sha256(acl.sd_buf, acl.sd_size, acl.hash);
 
        smb_acl = ksmbd_vfs_make_xattr_posix_acl(idmap, inode,
                                                 ACL_TYPE_ACCESS);
@@ -1495,12 +1492,7 @@ int ksmbd_vfs_set_sd_xattr(struct ksmbd_conn *conn,
                goto out;
        }
 
-       rc = ksmbd_gen_sd_hash(conn, acl_ndr.data, acl_ndr.offset,
-                              acl.posix_acl_hash);
-       if (rc) {
-               pr_err("failed to generate hash for ndr acl\n");
-               goto out;
-       }
+       sha256(acl_ndr.data, acl_ndr.offset, acl.posix_acl_hash);
 
        rc = ndr_encode_v4_ntacl(&sd_ndr, &acl);
        if (rc) {
@@ -1557,11 +1549,7 @@ int ksmbd_vfs_get_sd_xattr(struct ksmbd_conn *conn,
                goto out_free;
        }
 
-       rc = ksmbd_gen_sd_hash(conn, acl_ndr.data, acl_ndr.offset, cmp_hash);
-       if (rc) {
-               pr_err("failed to generate hash for ndr acl\n");
-               goto out_free;
-       }
+       sha256(acl_ndr.data, acl_ndr.offset, cmp_hash);
 
        if (memcmp(cmp_hash, acl.posix_acl_hash, XATTR_SD_HASH_SIZE)) {
                pr_err("hash value diff\n");