// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2013 Intel Corporation
 *
 * Author:
 * Dmitry Kasatkin <dmitry.kasatkin@intel.com>
 */

#include <linux/err.h>
#include <linux/ratelimit.h>
#include <linux/key-type.h>
#include <crypto/public_key.h>
#include <crypto/hash_info.h>
#include <keys/asymmetric-type.h>
#include <keys/system_keyring.h>

#include "integrity.h"

/*
 * Request an asymmetric key.
 */
static struct key *request_asymmetric_key(struct key *keyring, uint32_t keyid)
{
	struct key *key;
	char name[12];

	sprintf(name, "id:%08x", keyid);

	pr_debug("key search: \"%s\"\n", name);

	key = get_ima_blacklist_keyring();
	if (key) {
		key_ref_t kref;

		kref = keyring_search(make_key_ref(key, 1),
				      &key_type_asymmetric, name, true);
		if (!IS_ERR(kref)) {
			pr_err("Key '%s' is in ima_blacklist_keyring\n", name);
			return ERR_PTR(-EKEYREJECTED);
		}
	}

	if (keyring) {
		/* search in specific keyring */
		key_ref_t kref;

		kref = keyring_search(make_key_ref(keyring, 1),
				      &key_type_asymmetric, name, true);
		if (IS_ERR(kref))
			key = ERR_CAST(kref);
		else
			key = key_ref_to_ptr(kref);
	} else {
		key = request_key(&key_type_asymmetric, name, NULL);
	}

	if (IS_ERR(key)) {
		if (keyring)
			pr_err_ratelimited("Request for unknown key '%s' in '%s' keyring. err %ld\n",
					   name, keyring->description,
					   PTR_ERR(key));
		else
			pr_err_ratelimited("Request for unknown key '%s' err %ld\n",
					   name, PTR_ERR(key));

		switch (PTR_ERR(key)) {
			/* Hide some search errors */
		case -EACCES:
		case -ENOTDIR:
		case -EAGAIN:
			return ERR_PTR(-ENOKEY);
		default:
			return key;
		}
	}

	pr_debug("%s() = 0 [%x]\n", __func__, key_serial(key));

	return key;
}

/**
 * asymmetric_verify_common -- sigv2 and sigv3 common verify function
 * @key: The key to use for signature verification; caller must free it
 * @pk: The associated public key; must not be NULL
 * @sig: The xattr signature
 * @siglen: The length of the xattr signature; must be at least
 *          sizeof(struct signature_v2_hdr)
 * @data: The data to verify the signature on
 * @datalen: Length of @data
 */
static int asymmetric_verify_common(const struct key *key,
				    const struct public_key *pk,
				    const char *sig, int siglen,
				    const char *data, int datalen)
{
	struct signature_v2_hdr *hdr = (struct signature_v2_hdr *)sig;
	struct public_key_signature pks;
	int ret;

	siglen -= sizeof(*hdr);

	if (siglen != be16_to_cpu(hdr->sig_size))
		return -EBADMSG;

	if (hdr->hash_algo >= HASH_ALGO__LAST)
		return -ENOPKG;

	memset(&pks, 0, sizeof(pks));

	pks.hash_algo = hash_algo_name[hdr->hash_algo];
	pks.pkey_algo = pk->pkey_algo;
	if (!strcmp(pk->pkey_algo, "rsa")) {
		pks.encoding = "pkcs1";
	} else if (!strncmp(pk->pkey_algo, "ecdsa-", 6)) {
		/* edcsa-nist-p192 etc. */
		pks.encoding = "x962";
	} else if (!strcmp(pk->pkey_algo, "ecrdsa")) {
		pks.encoding = "raw";
	} else {
		ret = -ENOPKG;
		goto out;
	}

	pks.m = (u8 *)data;
	pks.m_size = datalen;
	pks.s = hdr->sig;
	pks.s_size = siglen;
	ret = verify_signature(key, &pks);
out:
	pr_debug("%s() = %d\n", __func__, ret);
	return ret;
}

int asymmetric_verify(struct key *keyring, const char *sig,
		      int siglen, const char *data, int datalen)
{
	struct signature_v2_hdr *hdr = (struct signature_v2_hdr *)sig;
	const struct public_key *pk;
	struct key *key;
	int ret;

	if (siglen <= sizeof(*hdr))
		return -EBADMSG;

	key = request_asymmetric_key(keyring, be32_to_cpu(hdr->keyid));
	if (IS_ERR(key))
		return PTR_ERR(key);
	pk = asymmetric_key_public_key(key);
	if (!pk) {
		ret = -ENOKEY;
		goto out;
	}

	ret = asymmetric_verify_common(key, pk, sig, siglen, data, datalen);

out:
	key_put(key);

	return ret;
}

/*
 * calc_file_id_hash - calculate the hash of the ima_file_id struct data
 * @type: xattr type [enum evm_ima_xattr_type]
 * @algo: hash algorithm [enum hash_algo]; caller must ensure valid value
 * @digest: pointer to the digest to be hashed
 * @hash: (out) pointer to the hash
 *
 * IMA signature version 3 disambiguates the data that is signed by
 * indirectly signing the hash of the ima_file_id structure data.
 *
 * Return 0 on success, error code otherwise.
 */
static int calc_file_id_hash(enum evm_ima_xattr_type type,
			     enum hash_algo algo, const u8 *digest,
			     struct ima_max_digest_data *hash)
{
	struct ima_file_id file_id = {.hash_type = type, .hash_algorithm = algo};
	size_t digest_size = hash_digest_size[algo];
	struct crypto_shash *tfm;
	size_t file_id_size;
	int rc;

	if (type != IMA_VERITY_DIGSIG && type != EVM_IMA_XATTR_DIGSIG &&
	    type != EVM_XATTR_PORTABLE_DIGSIG)
		return -EINVAL;

	tfm = crypto_alloc_shash(hash_algo_name[algo], 0, 0);
	if (IS_ERR(tfm))
		return PTR_ERR(tfm);

	memcpy(file_id.hash, digest, digest_size);

	/* Calculate the ima_file_id struct hash on the portion used. */
	file_id_size = sizeof(file_id) - (HASH_MAX_DIGESTSIZE - digest_size);

	hash->hdr.algo = algo;
	hash->hdr.length = digest_size;
	rc = crypto_shash_tfm_digest(tfm, (const u8 *)&file_id, file_id_size,
				     hash->digest);

	crypto_free_shash(tfm);
	return rc;
}

/**
 * asymmetric_verify_v3_hashless - Use hashless signature verification on sigv3
 * @key: The key to use for signature verification; caller must free it
 * @pk: The associated public key; must not be NULL
 * @encoding: The encoding the key type uses
 * @sig: The xattr signature
 * @siglen: The length of the xattr signature; must be at least
 *          sizeof(struct signature_v2_hdr)
 * @algo: hash algorithm [enum hash_algo]; caller must ensure valid value
 * @digest: The file digest
 *
 * Create an ima_file_id structure and use it for signature verification
 * directly. This can be used for ML-DSA in pure mode for example.
 */
static int asymmetric_verify_v3_hashless(struct key *key,
					 const struct public_key *pk,
					 const char *encoding,
					 const char *sig, int siglen,
					 u8 algo,
					 const u8 *digest)
{
	struct signature_v2_hdr *hdr = (struct signature_v2_hdr *)sig;
	struct ima_file_id file_id = {
		.hash_type = hdr->type,
		.hash_algorithm = algo,
	};
	size_t digest_size = hash_digest_size[algo];
	struct public_key_signature pks = {
		.m = (u8 *)&file_id,
		.m_size = sizeof(file_id) - (HASH_MAX_DIGESTSIZE - digest_size),
		.s = hdr->sig,
		.s_size = siglen - sizeof(*hdr),
		.pkey_algo = pk->pkey_algo,
		.hash_algo = "none",
		.encoding = encoding,
	};
	int ret;

	if (hdr->type != IMA_VERITY_DIGSIG &&
	    hdr->type != EVM_IMA_XATTR_DIGSIG &&
	    hdr->type != EVM_XATTR_PORTABLE_DIGSIG)
		return -EINVAL;

	if (pks.s_size != be16_to_cpu(hdr->sig_size))
		return -EBADMSG;

	memcpy(file_id.hash, digest, digest_size);

	ret = verify_signature(key, &pks);
	pr_debug("%s() = %d\n", __func__, ret);
	return ret;
}

int asymmetric_verify_v3(struct key *keyring, const char *sig, int siglen,
			 const char *data, int datalen, u8 algo)
{
	struct signature_v2_hdr *hdr = (struct signature_v2_hdr *)sig;
	struct ima_max_digest_data hash;
	const struct public_key *pk;
	struct key *key;
	int rc;

	if (algo >= HASH_ALGO__LAST)
		return -ENOPKG;

	if (siglen <= sizeof(*hdr))
		return -EBADMSG;

	key = request_asymmetric_key(keyring, be32_to_cpu(hdr->keyid));
	if (IS_ERR(key))
		return PTR_ERR(key);

	pk = asymmetric_key_public_key(key);
	if (!pk) {
		rc = -ENOKEY;
		goto out;
	}
	if (!strncmp(pk->pkey_algo, "mldsa", 5)) {
		rc = asymmetric_verify_v3_hashless(key, pk, "raw",
						   sig, siglen, algo, data);
	} else {
		rc = calc_file_id_hash(hdr->type, algo, data, &hash);
		if (rc) {
			rc = -EINVAL;
			goto out;
		}

		rc = asymmetric_verify_common(key, pk, sig, siglen, hash.digest,
					      hash.hdr.length);
	}

out:
	key_put(key);

	return rc;
}