[PATCH v2 19/19] fit: Add ecdsa support

[Sascha Hauer]

This adds ECDSA signing support to the FIT image code.

Previously we unconditionally called into rsa_verify() as this was the
only option. Now with ECDSA support we first have to check the type of
the signature, so we start evaluating the signature type in given in the
FIT image and call rsa_verify() or ecdsa_verify() depending on it.

Signed-off-by: Sascha Hauer <s.hauer at pengutronix.de>
---
 common/image-fit.c | 112 +++++++++++++++++++++++++++++++++++++--------
 1 file changed, 94 insertions(+), 18 deletions(-)

diff --git a/common/image-fit.c b/common/image-fit.c
index 6002440e7e..599d969a38 100644
--- a/common/image-fit.c
+++ b/common/image-fit.c
@@ -21,6 +21,7 @@
 #include <linux/err.h>
 #include <stringlist.h>
 #include <rsa.h>
+#include <ecdsa.h>
 #include <uncompress.h>
 #include <image-fit.h>
 
@@ -253,13 +254,11 @@ static struct digest *fit_alloc_digest(struct device_node *sig_node,
 	return digest;
 }
 
-static int fit_check_rsa_signature(struct device_node *sig_node,
-				   enum hash_algo algo, void *hash)
+static int fit_check_rsa_signature(const void *signature, size_t sig_len,
+				   enum hash_algo algo, void *hash,
+				   const char *key_name)
 {
 	const struct rsa_public_key *key;
-	const char *key_name = NULL;
-	int sig_len;
-	const char *sig_value;
 	int ret;
 
 	if (!IS_ENABLED(CONFIG_CRYPTO_RSA)) {
@@ -267,17 +266,10 @@ static int fit_check_rsa_signature(struct device_node *sig_node,
 		return -EOPNOTSUPP;
 	}
 
-	sig_value = of_get_property(sig_node, "value", &sig_len);
-	if (!sig_value) {
-		pr_err("signature value not found in %pOF\n", sig_node);
-		return -EINVAL;
-	}
-
-	of_property_read_string(sig_node, "key-name-hint", &key_name);
 	if (key_name) {
 		key = rsa_get_key(key_name);
 		if (key) {
-			ret = rsa_verify(key, sig_value, sig_len, hash, algo);
+			ret = rsa_verify(key, signature, sig_len, hash, algo);
 			if (!ret)
 				goto ok;
 		}
@@ -287,20 +279,104 @@ static int fit_check_rsa_signature(struct device_node *sig_node,
 		if (key_name && !strcmp(key->key_name_hint, key_name))
 			continue;
 
-		ret = rsa_verify(key, sig_value, sig_len, hash, algo);
+		ret = rsa_verify(key, signature, sig_len, hash, algo);
 		if (!ret)
 			goto ok;
 	}
 
-	pr_err("image signature BAD\n");
+	pr_err("image RSA signature BAD\n");
 
 	return -EBADMSG;
 ok:
-	pr_info("image signature OK\n");
+	pr_info("image RSA signature OK\n");
 
 	return 0;
 }
 
+static int fit_check_ecdsa_signature(const void *signature, size_t sig_len,
+				     enum hash_algo algo, void *hash,
+				     const char *key_name)
+{
+	const struct ecdsa_public_key *key;
+	int ret;
+
+	if (!IS_ENABLED(CONFIG_CRYPTO_ECDSA)) {
+		pr_err("ECDSA support is disabled, Cannot verify image\n");
+		return -EOPNOTSUPP;
+	}
+
+	for_each_ecdsa_key(key) {
+		ret = ecdsa_verify(key, signature, sig_len, hash);
+		if (!ret) {
+			pr_info("image ECDSA signature OK\n");
+			return 0;
+		}
+	}
+
+	pr_err("image ECDSA signature BAD\n");
+
+	return -EBADMSG;
+}
+
+struct crypto_algo {
+	const char *name;
+	int (*verify)(const void *signature, size_t sig_len, enum hash_algo algo,
+		      void *hash, const char *key_name);
+};
+
+static struct crypto_algo crypto_algos[] = {
+	{
+		.name = "rsa2048",
+		.verify = fit_check_rsa_signature,
+	}, {
+		.name = "rsa3072",
+		.verify = fit_check_rsa_signature,
+	}, {
+		.name = "rsa4096",
+		.verify = fit_check_rsa_signature,
+	}, {
+		.name = "ecdsa256",
+		.verify = fit_check_ecdsa_signature,
+	},
+};
+
+static int fit_check_signature(struct device_node *sig_node,
+			       enum hash_algo algo, void *hash)
+{
+	int sig_len, i;
+	const char *sig_value;
+	const char *algo_name;
+	const char *key_name = NULL;
+	const char *str;
+
+	sig_value = of_get_property(sig_node, "value", &sig_len);
+	if (!sig_value) {
+		pr_err("signature value not found in %pOF\n", sig_node);
+		return -EINVAL;
+	}
+
+	of_property_read_string(sig_node, "key-name-hint", &key_name);
+
+	if (of_property_read_string(sig_node, "algo", &algo_name)) {
+		pr_err("algo property not found\n");
+		return -EINVAL;
+	}
+
+	str = strchr(algo_name, ',');
+	if (!str)
+		return -EINVAL;
+	str++;
+
+	for (i = 0; i < ARRAY_SIZE(crypto_algos); i++) {
+		struct crypto_algo *ca = &crypto_algos[i];
+
+		if (!strcmp(ca->name, str))
+			return ca->verify(sig_value, sig_len, algo, hash, key_name);
+	}
+
+	return -EINVAL;
+}
+
 /*
  * The consistency of the FTD structure was already checked by of_unflatten_dtb()
  */
@@ -346,7 +422,7 @@ static int fit_verify_signature(struct device_node *sig_node, const void *fit)
 	hash = xzalloc(digest_length(digest));
 	digest_final(digest, hash);
 
-	ret = fit_check_rsa_signature(sig_node, algo, hash);
+	ret = fit_check_signature(sig_node, algo, hash);
 	if (ret)
 		goto out_free_hash;
 
@@ -469,7 +545,7 @@ static int fit_image_verify_signature(struct fit_handle *handle,
 	hash = xzalloc(digest_length(digest));
 	digest_final(digest, hash);
 
-	ret = fit_check_rsa_signature(sig_node, algo, hash);
+	ret = fit_check_signature(sig_node, algo, hash);
 
 	free(hash);
 
-- 
2.39.2