535.86.05

kernel-open/nvidia/libspdm_hkdf.c

@@ -0,0 +1,158 @@
+/*
+* SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+* SPDX-License-Identifier: MIT
+*
+* Permission is hereby granted, free of charge, to any person obtaining a
+* copy of this software and associated documentation files (the "Software"),
+* to deal in the Software without restriction, including without limitation
+* the rights to use, copy, modify, merge, publish, distribute, sublicense,
+* and/or sell copies of the Software, and to permit persons to whom the
+* Software is furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+* DEALINGS IN THE SOFTWARE.
+*/
+
+#include "internal_crypt_lib.h"
+
+// RFC 5869 has some very non-intuitive points, reading it is advised
+static bool lkca_hkdf_expand_only(struct crypto_shash *alg,
+                                  const uint8_t *prk, size_t prk_size,
+                                  const uint8_t *info, size_t info_size,
+                                  uint8_t *out, size_t out_size)
+{
+#ifndef USE_LKCA
+    return false;
+#else
+    int ret;
+    int i;
+    uint8_t ctr = 1;
+    uint8_t tmp[HASH_MAX_DIGESTSIZE];
+    SHASH_DESC_ON_STACK(desc, alg);
+    desc->tfm = alg;
+
+    ret = crypto_shash_setkey(desc->tfm, prk, prk_size);
+    if (ret != 0) {
+        pr_info("key size mismatch %ld\n", prk_size);
+        return false;
+    }
+
+    for (i = 0, ctr = 1; i < out_size; i += prk_size, ctr++) {
+        ret = crypto_shash_init(desc);
+        if (ret) {
+            return false;
+        }
+
+        if (i != 0) {
+            ret = crypto_shash_update(desc, out + i - prk_size, prk_size);
+            if (ret) {
+                return false;
+            }
+        }
+
+        if (info_size > 0) {
+            ret = crypto_shash_update(desc, info, info_size);
+            if (ret) {
+                return false;
+            }
+        }
+
+        ret = crypto_shash_update(desc, &ctr, 1);
+        if (ret)
+            return false;
+
+        if ((out_size - i) < prk_size) {
+            ret = crypto_shash_final(desc, tmp);
+            if (ret) {
+                return false;
+            }
+            memcpy(out + i, tmp, out_size - i);
+            memzero_explicit(tmp, sizeof(tmp));
+        } else {
+            ret = crypto_shash_final(desc, out + i);
+            if (ret) {
+                return false;
+            }
+        }
+    }
+
+    return true;
+#endif
+}
+
+bool lkca_hkdf_extract_and_expand(const char *alg_name,
+                                  const uint8_t *key, size_t key_size,
+                                  const uint8_t *salt, size_t salt_size,
+                                  const uint8_t *info, size_t info_size,
+                                  uint8_t *out, size_t out_size)
+{
+#ifndef USE_LKCA
+    return false;
+#else
+    int ret = 0;
+    struct crypto_shash *alg;
+    uint8_t prk[HASH_MAX_DIGESTSIZE];
+
+    if (key == NULL || salt == NULL || info == NULL || out == NULL ||
+        key_size > sizeof(prk) || salt_size > INT_MAX || info_size > INT_MAX ||
+        out_size > (sizeof(prk) * 255)) {
+        return false;
+    }
+
+    alg = crypto_alloc_shash(alg_name, 0, 0);
+    if (IS_ERR(alg)) {
+        return false;
+    }
+
+    ret = crypto_shash_setkey(alg, salt, salt_size);
+    if (ret != 0) {
+        goto out;
+    }
+    ret = crypto_shash_tfm_digest(alg, key, key_size, prk);
+    if (ret != 0) {
+        goto out;
+    }
+
+    ret = !lkca_hkdf_expand_only(alg, prk, crypto_shash_digestsize(alg), info, info_size, out, out_size);
+
+out:
+    crypto_free_shash(alg);
+    return ret == 0;
+#endif
+}
+
+bool lkca_hkdf_expand(const char *alg_name,
+                      const uint8_t *prk, size_t prk_size,
+                      const uint8_t *info, size_t info_size,
+                      uint8_t *out, size_t out_size)
+{
+#ifndef USE_LKCA
+    return false;
+#else
+    bool ret = false;
+    struct crypto_shash *alg;
+
+    if (prk == NULL || info == NULL || out == NULL || prk_size > (512 / 8) ||
+        info_size > INT_MAX || (out_size > (prk_size * 255))) {
+        return false;
+    }
+
+    alg = crypto_alloc_shash(alg_name, 0, 0);
+    if (IS_ERR(alg)) {
+        return false;
+    }
+
+    ret = lkca_hkdf_expand_only(alg, prk, prk_size, info, info_size, out, out_size);
+
+    crypto_free_shash(alg);
+    return ret;
+#endif
+}