[linux-2.6-block.git] / crypto / rsa_helper.c

/*
 * RSA key extract helper
 *
 * Copyright (c) 2015, Intel Corporation
 * Authors: Tadeusz Struk <tadeusz.struk@intel.com>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 *
 */
#include <linux/kernel.h>
#include <linux/export.h>
#include <linux/err.h>
#include <linux/fips.h>
#include <crypto/internal/rsa.h>
#include "rsakey-asn1.h"

int rsa_get_n(void *context, size_t hdrlen, unsigned char tag,
	      const void *value, size_t vlen)
{
	struct rsa_key *key = context;

	key->n = mpi_read_raw_data(value, vlen);

	if (!key->n)
		return -ENOMEM;

	/* In FIPS mode only allow key size 2K & 3K */
	if (fips_enabled && (mpi_get_size(key->n) != 256 ||
			     mpi_get_size(key->n) != 384)) {
		pr_err("RSA: key size not allowed in FIPS mode\n");
		mpi_free(key->n);
		key->n = NULL;
		return -EINVAL;
	}
	return 0;
}

int rsa_get_e(void *context, size_t hdrlen, unsigned char tag,
	      const void *value, size_t vlen)
{
	struct rsa_key *key = context;

	key->e = mpi_read_raw_data(value, vlen);

	if (!key->e)
		return -ENOMEM;

	return 0;
}

int rsa_get_d(void *context, size_t hdrlen, unsigned char tag,
	      const void *value, size_t vlen)
{
	struct rsa_key *key = context;

	key->d = mpi_read_raw_data(value, vlen);

	if (!key->d)
		return -ENOMEM;

	/* In FIPS mode only allow key size 2K & 3K */
	if (fips_enabled && (mpi_get_size(key->d) != 256 ||
			     mpi_get_size(key->d) != 384)) {
		pr_err("RSA: key size not allowed in FIPS mode\n");
		mpi_free(key->d);
		key->d = NULL;
		return -EINVAL;
	}
	return 0;
}

static void free_mpis(struct rsa_key *key)
{
	mpi_free(key->n);
	mpi_free(key->e);
	mpi_free(key->d);
	key->n = NULL;
	key->e = NULL;
	key->d = NULL;
}

/**
 * rsa_free_key() - frees rsa key allocated by rsa_parse_key()
 *
 * @rsa_key:	struct rsa_key key representation
 */
void rsa_free_key(struct rsa_key *key)
{
	free_mpis(key);
}
EXPORT_SYMBOL_GPL(rsa_free_key);

/**
 * rsa_parse_key() - extracts an rsa key from BER encoded buffer
 *		     and stores it in the provided struct rsa_key
 *
 * @rsa_key:	struct rsa_key key representation
 * @key:	key in BER format
 * @key_len:	length of key
 *
 * Return:	0 on success or error code in case of error
 */
int rsa_parse_key(struct rsa_key *rsa_key, const void *key,
		  unsigned int key_len)
{
	int ret;

	free_mpis(rsa_key);
	ret = asn1_ber_decoder(&rsakey_decoder, rsa_key, key, key_len);
	if (ret < 0)
		goto error;

	return 0;
error:
	free_mpis(rsa_key);
	return ret;
}
EXPORT_SYMBOL_GPL(rsa_parse_key);
Commit	Line	Data
cfc2bb32 TS	1	/*
	2	* RSA key extract helper
	3	*
	4	* Copyright (c) 2015, Intel Corporation
	5	* Authors: Tadeusz Struk <tadeusz.struk@intel.com>
	6	*
	7	* This program is free software; you can redistribute it and/or modify it
	8	* under the terms of the GNU General Public License as published by the Free
	9	* Software Foundation; either version 2 of the License, or (at your option)
	10	* any later version.
	11	*
	12	*/
	13	#include <linux/kernel.h>
	14	#include <linux/export.h>
	15	#include <linux/err.h>
	16	#include <linux/fips.h>
	17	#include <crypto/internal/rsa.h>
	18	#include "rsakey-asn1.h"
	19
	20	int rsa_get_n(void *context, size_t hdrlen, unsigned char tag,
	21	const void *value, size_t vlen)
	22	{
	23	struct rsa_key *key = context;
	24
	25	key->n = mpi_read_raw_data(value, vlen);
	26
	27	if (!key->n)
	28	return -ENOMEM;
	29
	30	/* In FIPS mode only allow key size 2K & 3K */
	31	if (fips_enabled && (mpi_get_size(key->n) != 256 \|\|
	32	mpi_get_size(key->n) != 384)) {
	33	pr_err("RSA: key size not allowed in FIPS mode\n");
	34	mpi_free(key->n);
	35	key->n = NULL;
	36	return -EINVAL;
	37	}
	38	return 0;
	39	}
	40
	41	int rsa_get_e(void *context, size_t hdrlen, unsigned char tag,
	42	const void *value, size_t vlen)
	43	{
	44	struct rsa_key *key = context;
	45
	46	key->e = mpi_read_raw_data(value, vlen);
	47
	48	if (!key->e)
	49	return -ENOMEM;
	50
	51	return 0;
	52	}
	53
	54	int rsa_get_d(void *context, size_t hdrlen, unsigned char tag,
	55	const void *value, size_t vlen)
	56	{
	57	struct rsa_key *key = context;
	58
	59	key->d = mpi_read_raw_data(value, vlen);
	60
	61	if (!key->d)
	62	return -ENOMEM;
	63
	64	/* In FIPS mode only allow key size 2K & 3K */
65	if (fips_enabled && (mpi_get_size(key->d) != 256 \|\|
66	mpi_get_size(key->d) != 384)) {
67	pr_err("RSA: key size not allowed in FIPS mode\n");
68	mpi_free(key->d);
69	key->d = NULL;
70	return -EINVAL;
71	}
72	return 0;
73	}
74
75	static void free_mpis(struct rsa_key *key)
76	{
77	mpi_free(key->n);
78	mpi_free(key->e);
79	mpi_free(key->d);
80	key->n = NULL;
81	key->e = NULL;
82	key->d = NULL;
83	}
84
85	/**
86	* rsa_free_key() - frees rsa key allocated by rsa_parse_key()
87	*
88	* @rsa_key: struct rsa_key key representation
89	*/
90	void rsa_free_key(struct rsa_key *key)
91	{
92	free_mpis(key);
93	}
94	EXPORT_SYMBOL_GPL(rsa_free_key);
95
96	/**
97	* rsa_parse_key() - extracts an rsa key from BER encoded buffer
98	* and stores it in the provided struct rsa_key
99	*
100	* @rsa_key: struct rsa_key key representation
101	* @key: key in BER format
102	* @key_len: length of key
103	*
104	* Return: 0 on success or error code in case of error
105	*/
106	int rsa_parse_key(struct rsa_key rsa_key, const void key,
107	unsigned int key_len)
108	{
109	int ret;
110
111	free_mpis(rsa_key);
112	ret = asn1_ber_decoder(&rsakey_decoder, rsa_key, key, key_len);
113	if (ret < 0)
114	goto error;
115
116	return 0;
117	error:
118	free_mpis(rsa_key);
119	return ret;
120	}
121	EXPORT_SYMBOL_GPL(rsa_parse_key);