]>
git.proxmox.com Git - mirror_ubuntu-eoan-kernel.git/blob - crypto/rsa.c
1 /* RSA asymmetric public-key algorithm [RFC3447]
3 * Copyright (c) 2015, Intel Corporation
4 * Authors: Tadeusz Struk <tadeusz.struk@intel.com>
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public Licence
8 * as published by the Free Software Foundation; either version
9 * 2 of the Licence, or (at your option) any later version.
12 #include <linux/module.h>
13 #include <linux/mpi.h>
14 #include <crypto/internal/rsa.h>
15 #include <crypto/internal/akcipher.h>
16 #include <crypto/akcipher.h>
17 #include <crypto/algapi.h>
26 * RSAEP function [RFC3447 sec 5.1.1]
29 static int _rsa_enc(const struct rsa_mpi_key
*key
, MPI c
, MPI m
)
31 /* (1) Validate 0 <= m < n */
32 if (mpi_cmp_ui(m
, 0) < 0 || mpi_cmp(m
, key
->n
) >= 0)
35 /* (2) c = m^e mod n */
36 return mpi_powm(c
, m
, key
->e
, key
->n
);
40 * RSADP function [RFC3447 sec 5.1.2]
43 static int _rsa_dec(const struct rsa_mpi_key
*key
, MPI m
, MPI c
)
45 /* (1) Validate 0 <= c < n */
46 if (mpi_cmp_ui(c
, 0) < 0 || mpi_cmp(c
, key
->n
) >= 0)
49 /* (2) m = c^d mod n */
50 return mpi_powm(m
, c
, key
->d
, key
->n
);
54 * RSASP1 function [RFC3447 sec 5.2.1]
57 static int _rsa_sign(const struct rsa_mpi_key
*key
, MPI s
, MPI m
)
59 /* (1) Validate 0 <= m < n */
60 if (mpi_cmp_ui(m
, 0) < 0 || mpi_cmp(m
, key
->n
) >= 0)
63 /* (2) s = m^d mod n */
64 return mpi_powm(s
, m
, key
->d
, key
->n
);
68 * RSAVP1 function [RFC3447 sec 5.2.2]
71 static int _rsa_verify(const struct rsa_mpi_key
*key
, MPI m
, MPI s
)
73 /* (1) Validate 0 <= s < n */
74 if (mpi_cmp_ui(s
, 0) < 0 || mpi_cmp(s
, key
->n
) >= 0)
77 /* (2) m = s^e mod n */
78 return mpi_powm(m
, s
, key
->e
, key
->n
);
81 static inline struct rsa_mpi_key
*rsa_get_key(struct crypto_akcipher
*tfm
)
83 return akcipher_tfm_ctx(tfm
);
86 static int rsa_enc(struct akcipher_request
*req
)
88 struct crypto_akcipher
*tfm
= crypto_akcipher_reqtfm(req
);
89 const struct rsa_mpi_key
*pkey
= rsa_get_key(tfm
);
90 MPI m
, c
= mpi_alloc(0);
97 if (unlikely(!pkey
->n
|| !pkey
->e
)) {
103 m
= mpi_read_raw_from_sgl(req
->src
, req
->src_len
);
107 ret
= _rsa_enc(pkey
, c
, m
);
111 ret
= mpi_write_to_sgl(c
, req
->dst
, req
->dst_len
, &sign
);
125 static int rsa_dec(struct akcipher_request
*req
)
127 struct crypto_akcipher
*tfm
= crypto_akcipher_reqtfm(req
);
128 const struct rsa_mpi_key
*pkey
= rsa_get_key(tfm
);
129 MPI c
, m
= mpi_alloc(0);
136 if (unlikely(!pkey
->n
|| !pkey
->d
)) {
142 c
= mpi_read_raw_from_sgl(req
->src
, req
->src_len
);
146 ret
= _rsa_dec(pkey
, m
, c
);
150 ret
= mpi_write_to_sgl(m
, req
->dst
, req
->dst_len
, &sign
);
163 static int rsa_sign(struct akcipher_request
*req
)
165 struct crypto_akcipher
*tfm
= crypto_akcipher_reqtfm(req
);
166 const struct rsa_mpi_key
*pkey
= rsa_get_key(tfm
);
167 MPI m
, s
= mpi_alloc(0);
174 if (unlikely(!pkey
->n
|| !pkey
->d
)) {
180 m
= mpi_read_raw_from_sgl(req
->src
, req
->src_len
);
184 ret
= _rsa_sign(pkey
, s
, m
);
188 ret
= mpi_write_to_sgl(s
, req
->dst
, req
->dst_len
, &sign
);
202 static int rsa_verify(struct akcipher_request
*req
)
204 struct crypto_akcipher
*tfm
= crypto_akcipher_reqtfm(req
);
205 const struct rsa_mpi_key
*pkey
= rsa_get_key(tfm
);
206 MPI s
, m
= mpi_alloc(0);
213 if (unlikely(!pkey
->n
|| !pkey
->e
)) {
218 s
= mpi_read_raw_from_sgl(req
->src
, req
->src_len
);
224 ret
= _rsa_verify(pkey
, m
, s
);
228 ret
= mpi_write_to_sgl(m
, req
->dst
, req
->dst_len
, &sign
);
242 static void rsa_free_mpi_key(struct rsa_mpi_key
*key
)
252 static int rsa_check_key_length(unsigned int len
)
267 static int rsa_set_pub_key(struct crypto_akcipher
*tfm
, const void *key
,
270 struct rsa_mpi_key
*mpi_key
= akcipher_tfm_ctx(tfm
);
271 struct rsa_key raw_key
= {0};
274 /* Free the old MPI key if any */
275 rsa_free_mpi_key(mpi_key
);
277 ret
= rsa_parse_pub_key(&raw_key
, key
, keylen
);
281 mpi_key
->e
= mpi_read_raw_data(raw_key
.e
, raw_key
.e_sz
);
285 mpi_key
->n
= mpi_read_raw_data(raw_key
.n
, raw_key
.n_sz
);
289 if (rsa_check_key_length(mpi_get_size(mpi_key
->n
) << 3)) {
290 rsa_free_mpi_key(mpi_key
);
297 rsa_free_mpi_key(mpi_key
);
301 static int rsa_set_priv_key(struct crypto_akcipher
*tfm
, const void *key
,
304 struct rsa_mpi_key
*mpi_key
= akcipher_tfm_ctx(tfm
);
305 struct rsa_key raw_key
= {0};
308 /* Free the old MPI key if any */
309 rsa_free_mpi_key(mpi_key
);
311 ret
= rsa_parse_priv_key(&raw_key
, key
, keylen
);
315 mpi_key
->d
= mpi_read_raw_data(raw_key
.d
, raw_key
.d_sz
);
319 mpi_key
->e
= mpi_read_raw_data(raw_key
.e
, raw_key
.e_sz
);
323 mpi_key
->n
= mpi_read_raw_data(raw_key
.n
, raw_key
.n_sz
);
327 if (rsa_check_key_length(mpi_get_size(mpi_key
->n
) << 3)) {
328 rsa_free_mpi_key(mpi_key
);
335 rsa_free_mpi_key(mpi_key
);
339 static unsigned int rsa_max_size(struct crypto_akcipher
*tfm
)
341 struct rsa_mpi_key
*pkey
= akcipher_tfm_ctx(tfm
);
343 return mpi_get_size(pkey
->n
);
346 static void rsa_exit_tfm(struct crypto_akcipher
*tfm
)
348 struct rsa_mpi_key
*pkey
= akcipher_tfm_ctx(tfm
);
350 rsa_free_mpi_key(pkey
);
353 static struct akcipher_alg rsa
= {
357 .verify
= rsa_verify
,
358 .set_priv_key
= rsa_set_priv_key
,
359 .set_pub_key
= rsa_set_pub_key
,
360 .max_size
= rsa_max_size
,
361 .exit
= rsa_exit_tfm
,
364 .cra_driver_name
= "rsa-generic",
366 .cra_module
= THIS_MODULE
,
367 .cra_ctxsize
= sizeof(struct rsa_mpi_key
),
371 static int rsa_init(void)
375 err
= crypto_register_akcipher(&rsa
);
379 err
= crypto_register_template(&rsa_pkcs1pad_tmpl
);
381 crypto_unregister_akcipher(&rsa
);
388 static void rsa_exit(void)
390 crypto_unregister_template(&rsa_pkcs1pad_tmpl
);
391 crypto_unregister_akcipher(&rsa
);
394 module_init(rsa_init
);
395 module_exit(rsa_exit
);
396 MODULE_ALIAS_CRYPTO("rsa");
397 MODULE_LICENSE("GPL");
398 MODULE_DESCRIPTION("RSA generic algorithm");