Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
crypto: starfive - Add RSA algo support
Adding RSA enc/dec and sign/verify feature for StarFive cryptographic
module. The module only supports mod sizes up to 2048, therefore
calculations more than that will use fallback algo.
Co-developed-by: Huan Feng <huan.feng@starfivetech.com>
Signed-off-by: Huan Feng <huan.feng@starfivetech.com>
Signed-off-by: Jia Jie Ho <jiajie.ho@starfivetech.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
authored by
Jia Jie Ho
and committed by
Herbert Xu
445a4aaf
df12284a
+683
-2
+1
drivers/crypto/starfive/Kconfig
+1
drivers/crypto/starfive/Kconfig
+1
-1
drivers/crypto/starfive/Makefile
+1
-1
drivers/crypto/starfive/Makefile
+19
-1
drivers/crypto/starfive/jh7110-cryp.c
+19
-1
drivers/crypto/starfive/jh7110-cryp.c
···
86
86
87
87
status = readl(cryp->base + STARFIVE_IE_FLAG_OFFSET);
88
88
if (status & STARFIVE_IE_FLAG_HASH_DONE) {
89
-
writel(STARFIVE_IE_MASK_HASH_DONE, cryp->base + STARFIVE_IE_MASK_OFFSET);
89
+
status = readl(cryp->base + STARFIVE_IE_MASK_OFFSET);
90
+
status |= STARFIVE_IE_MASK_HASH_DONE;
91
+
writel(status, cryp->base + STARFIVE_IE_MASK_OFFSET);
90
92
tasklet_schedule(&cryp->hash_done);
93
+
}
94
+
95
+
if (status & STARFIVE_IE_FLAG_PKA_DONE) {
96
+
status = readl(cryp->base + STARFIVE_IE_MASK_OFFSET);
97
+
status |= STARFIVE_IE_MASK_PKA_DONE;
98
+
writel(status, cryp->base + STARFIVE_IE_MASK_OFFSET);
99
+
complete(&cryp->pka_done);
91
100
}
92
101
93
102
return IRQ_HANDLED;
···
141
132
return dev_err_probe(&pdev->dev, PTR_ERR(cryp->rst),
142
133
"Error getting hardware reset line\n");
143
134
135
+
init_completion(&cryp->pka_done);
136
+
144
137
irq = platform_get_irq(pdev, 0);
145
138
if (irq < 0)
146
139
return irq;
···
184
173
if (ret)
185
174
goto err_algs_hash;
186
175
176
+
ret = starfive_rsa_register_algs();
177
+
if (ret)
178
+
goto err_algs_rsa;
179
+
187
180
return 0;
188
181
182
+
err_algs_rsa:
183
+
starfive_hash_unregister_algs();
189
184
err_algs_hash:
190
185
crypto_engine_stop(cryp->engine);
191
186
err_engine_start:
···
217
200
struct starfive_cryp_dev *cryp = platform_get_drvdata(pdev);
218
201
219
202
starfive_hash_unregister_algs();
203
+
starfive_rsa_unregister_algs();
220
204
221
205
tasklet_kill(&cryp->hash_done);
222
206
+45
drivers/crypto/starfive/jh7110-cryp.h
+45
drivers/crypto/starfive/jh7110-cryp.h
···
18
18
#define STARFIVE_DMA_OUT_LEN_OFFSET 0x14
19
19
20
20
#define STARFIVE_IE_MASK_HASH_DONE 0x4
21
+
#define STARFIVE_IE_MASK_PKA_DONE 0x8
21
22
#define STARFIVE_IE_FLAG_HASH_DONE 0x4
23
+
#define STARFIVE_IE_FLAG_PKA_DONE 0x8
22
24
23
25
#define STARFIVE_MSG_BUFFER_SIZE SZ_16K
24
26
#define MAX_KEY_SIZE SHA512_BLOCK_SIZE
···
56
54
};
57
55
};
58
56
57
+
union starfive_pka_cacr {
58
+
u32 v;
59
+
struct {
60
+
u32 start :1;
61
+
u32 reset :1;
62
+
u32 ie :1;
63
+
u32 rsvd_0 :1;
64
+
u32 fifo_mode :1;
65
+
u32 not_r2 :1;
66
+
u32 ecc_sub :1;
67
+
u32 pre_expf :1;
68
+
u32 cmd :4;
69
+
u32 rsvd_1 :1;
70
+
u32 ctrl_dummy :1;
71
+
u32 ctrl_false :1;
72
+
u32 cln_done :1;
73
+
u32 opsize :6;
74
+
u32 rsvd_2 :2;
75
+
u32 exposize :6;
76
+
u32 rsvd_3 :1;
77
+
u32 bigendian :1;
78
+
};
79
+
};
80
+
81
+
struct starfive_rsa_key {
82
+
u8 *n;
83
+
u8 *e;
84
+
u8 *d;
85
+
int e_bitlen;
86
+
int d_bitlen;
87
+
int bitlen;
88
+
size_t key_sz;
89
+
};
59
90
60
91
union starfive_alg_cr {
61
92
u32 v;
···
113
78
u8 key[MAX_KEY_SIZE];
114
79
int keylen;
115
80
bool is_hmac;
81
+
struct starfive_rsa_key rsa_key;
82
+
struct crypto_akcipher *akcipher_fbk;
116
83
struct crypto_ahash *ahash_fbk;
117
84
};
118
85
···
135
98
struct dma_slave_config cfg_out;
136
99
struct crypto_engine *engine;
137
100
struct tasklet_struct hash_done;
101
+
struct completion pka_done;
138
102
int err;
139
103
union starfive_alg_cr alg_cr;
140
104
union {
···
146
108
struct starfive_cryp_request_ctx {
147
109
union {
148
110
union starfive_hash_csr hash;
111
+
union starfive_pka_cacr pka;
149
112
} csr;
150
113
151
114
struct scatterlist *in_sg;
115
+
struct scatterlist *out_sg;
152
116
struct ahash_request ahash_fbk_req;
153
117
size_t total;
118
+
size_t nents;
154
119
unsigned int blksize;
155
120
unsigned int digsize;
156
121
unsigned long in_sg_len;
122
+
u8 rsa_data[] __aligned(sizeof(u32));
157
123
};
158
124
159
125
struct starfive_cryp_dev *starfive_cryp_find_dev(struct starfive_cryp_ctx *ctx);
160
126
161
127
int starfive_hash_register_algs(void);
162
128
void starfive_hash_unregister_algs(void);
129
+
130
+
int starfive_rsa_register_algs(void);
131
+
void starfive_rsa_unregister_algs(void);
163
132
164
133
void starfive_hash_done_task(unsigned long param);
165
134
#endif
+617
drivers/crypto/starfive/jh7110-rsa.c
+617
drivers/crypto/starfive/jh7110-rsa.c
···
1
+
// SPDX-License-Identifier: GPL-2.0
2
+
/*
3
+
* StarFive Public Key Algo acceleration driver
4
+
*
5
+
* Copyright (c) 2022 StarFive Technology
6
+
*/
7
+
8
+
#include <linux/crypto.h>
9
+
#include <linux/delay.h>
10
+
#include <linux/device.h>
11
+
#include <linux/dma-direct.h>
12
+
#include <linux/interrupt.h>
13
+
#include <linux/iopoll.h>
14
+
#include <linux/io.h>
15
+
#include <linux/mod_devicetable.h>
16
+
#include <crypto/akcipher.h>
17
+
#include <crypto/algapi.h>
18
+
#include <crypto/internal/akcipher.h>
19
+
#include <crypto/internal/rsa.h>
20
+
#include <crypto/scatterwalk.h>
21
+
22
+
#include "jh7110-cryp.h"
23
+
24
+
#define STARFIVE_PKA_REGS_OFFSET 0x400
25
+
#define STARFIVE_PKA_CACR_OFFSET (STARFIVE_PKA_REGS_OFFSET + 0x0)
26
+
#define STARFIVE_PKA_CASR_OFFSET (STARFIVE_PKA_REGS_OFFSET + 0x4)
27
+
#define STARFIVE_PKA_CAAR_OFFSET (STARFIVE_PKA_REGS_OFFSET + 0x8)
28
+
#define STARFIVE_PKA_CAER_OFFSET (STARFIVE_PKA_REGS_OFFSET + 0x108)
29
+
#define STARFIVE_PKA_CANR_OFFSET (STARFIVE_PKA_REGS_OFFSET + 0x208)
30
+
31
+
// R^2 mod N and N0'
32
+
#define CRYPTO_CMD_PRE 0x0
33
+
// A * R mod N ==> A
34
+
#define CRYPTO_CMD_ARN 0x5
35
+
// A * E * R mod N ==> A
36
+
#define CRYPTO_CMD_AERN 0x6
37
+
// A * A * R mod N ==> A
38
+
#define CRYPTO_CMD_AARN 0x7
39
+
40
+
#define STARFIVE_RSA_MAX_KEYSZ 256
41
+
#define STARFIVE_RSA_RESET 0x2
42
+
43
+
static inline int starfive_pka_wait_done(struct starfive_cryp_ctx *ctx)
44
+
{
45
+
struct starfive_cryp_dev *cryp = ctx->cryp;
46
+
47
+
return wait_for_completion_timeout(&cryp->pka_done,
48
+
usecs_to_jiffies(100000));
49
+
}
50
+
51
+
static inline void starfive_pka_irq_mask_clear(struct starfive_cryp_ctx *ctx)
52
+
{
53
+
struct starfive_cryp_dev *cryp = ctx->cryp;
54
+
u32 stat;
55
+
56
+
stat = readl(cryp->base + STARFIVE_IE_MASK_OFFSET);
57
+
stat &= ~STARFIVE_IE_MASK_PKA_DONE;
58
+
writel(stat, cryp->base + STARFIVE_IE_MASK_OFFSET);
59
+
60
+
reinit_completion(&cryp->pka_done);
61
+
}
62
+
63
+
static void starfive_rsa_free_key(struct starfive_rsa_key *key)
64
+
{
65
+
if (key->d)
66
+
kfree_sensitive(key->d);
67
+
if (key->e)
68
+
kfree_sensitive(key->e);
69
+
if (key->n)
70
+
kfree_sensitive(key->n);
71
+
memset(key, 0, sizeof(*key));
72
+
}
73
+
74
+
static unsigned int starfive_rsa_get_nbit(u8 *pa, u32 snum, int key_sz)
75
+
{
76
+
u32 i;
77
+
u8 value;
78
+
79
+
i = snum >> 3;
80
+
81
+
value = pa[key_sz - i - 1];
82
+
value >>= snum & 0x7;
83
+
value &= 0x1;
84
+
85
+
return value;
86
+
}
87
+
88
+
static int starfive_rsa_montgomery_form(struct starfive_cryp_ctx *ctx,
89
+
u32 *out, u32 *in, u8 mont,
90
+
u32 *mod, int bit_len)
91
+
{
92
+
struct starfive_cryp_dev *cryp = ctx->cryp;
93
+
struct starfive_cryp_request_ctx *rctx = ctx->rctx;
94
+
int count = rctx->total / sizeof(u32) - 1;
95
+
int loop;
96
+
u32 temp;
97
+
u8 opsize;
98
+
99
+
opsize = (bit_len - 1) >> 5;
100
+
rctx->csr.pka.v = 0;
101
+
102
+
writel(rctx->csr.pka.v, cryp->base + STARFIVE_PKA_CACR_OFFSET);
103
+
104
+
for (loop = 0; loop <= opsize; loop++)
105
+
writel(mod[opsize - loop], cryp->base + STARFIVE_PKA_CANR_OFFSET + loop * 4);
106
+
107
+
if (mont) {
108
+
rctx->csr.pka.v = 0;
109
+
rctx->csr.pka.cln_done = 1;
110
+
rctx->csr.pka.opsize = opsize;
111
+
rctx->csr.pka.exposize = opsize;
112
+
rctx->csr.pka.cmd = CRYPTO_CMD_PRE;
113
+
rctx->csr.pka.start = 1;
114
+
rctx->csr.pka.not_r2 = 1;
115
+
rctx->csr.pka.ie = 1;
116
+
117
+
starfive_pka_irq_mask_clear(ctx);
118
+
writel(rctx->csr.pka.v, cryp->base + STARFIVE_PKA_CACR_OFFSET);
119
+
120
+
if (!starfive_pka_wait_done(ctx))
121
+
return -ETIMEDOUT;
122
+
123
+
for (loop = 0; loop <= opsize; loop++)
124
+
writel(in[opsize - loop], cryp->base + STARFIVE_PKA_CAAR_OFFSET + loop * 4);
125
+
126
+
writel(0x1000000, cryp->base + STARFIVE_PKA_CAER_OFFSET);
127
+
128
+
for (loop = 1; loop <= opsize; loop++)
129
+
writel(0, cryp->base + STARFIVE_PKA_CAER_OFFSET + loop * 4);
130
+
131
+
rctx->csr.pka.v = 0;
132
+
rctx->csr.pka.cln_done = 1;
133
+
rctx->csr.pka.opsize = opsize;
134
+
rctx->csr.pka.exposize = opsize;
135
+
rctx->csr.pka.cmd = CRYPTO_CMD_AERN;
136
+
rctx->csr.pka.start = 1;
137
+
rctx->csr.pka.ie = 1;
138
+
139
+
starfive_pka_irq_mask_clear(ctx);
140
+
writel(rctx->csr.pka.v, cryp->base + STARFIVE_PKA_CACR_OFFSET);
141
+
142
+
if (!starfive_pka_wait_done(ctx))
143
+
return -ETIMEDOUT;
144
+
} else {
145
+
rctx->csr.pka.v = 0;
146
+
rctx->csr.pka.cln_done = 1;
147
+
rctx->csr.pka.opsize = opsize;
148
+
rctx->csr.pka.exposize = opsize;
149
+
rctx->csr.pka.cmd = CRYPTO_CMD_PRE;
150
+
rctx->csr.pka.start = 1;
151
+
rctx->csr.pka.pre_expf = 1;
152
+
rctx->csr.pka.ie = 1;
153
+
154
+
starfive_pka_irq_mask_clear(ctx);
155
+
writel(rctx->csr.pka.v, cryp->base + STARFIVE_PKA_CACR_OFFSET);
156
+
157
+
if (!starfive_pka_wait_done(ctx))
158
+
return -ETIMEDOUT;
159
+
160
+
for (loop = 0; loop <= count; loop++)
161
+
writel(in[count - loop], cryp->base + STARFIVE_PKA_CAER_OFFSET + loop * 4);
162
+
163
+
/*pad with 0 up to opsize*/
164
+
for (loop = count + 1; loop <= opsize; loop++)
165
+
writel(0, cryp->base + STARFIVE_PKA_CAER_OFFSET + loop * 4);
166
+
167
+
rctx->csr.pka.v = 0;
168
+
rctx->csr.pka.cln_done = 1;
169
+
rctx->csr.pka.opsize = opsize;
170
+
rctx->csr.pka.exposize = opsize;
171
+
rctx->csr.pka.cmd = CRYPTO_CMD_ARN;
172
+
rctx->csr.pka.start = 1;
173
+
rctx->csr.pka.ie = 1;
174
+
175
+
starfive_pka_irq_mask_clear(ctx);
176
+
writel(rctx->csr.pka.v, cryp->base + STARFIVE_PKA_CACR_OFFSET);
177
+
178
+
if (!starfive_pka_wait_done(ctx))
179
+
return -ETIMEDOUT;
180
+
}
181
+
182
+
for (loop = 0; loop <= opsize; loop++) {
183
+
temp = readl(cryp->base + STARFIVE_PKA_CAAR_OFFSET + 0x4 * loop);
184
+
out[opsize - loop] = temp;
185
+
}
186
+
187
+
return 0;
188
+
}
189
+
190
+
static int starfive_rsa_cpu_start(struct starfive_cryp_ctx *ctx, u32 *result,
191
+
u8 *de, u32 *n, int key_sz)
192
+
{
193
+
struct starfive_cryp_dev *cryp = ctx->cryp;
194
+
struct starfive_cryp_request_ctx *rctx = ctx->rctx;
195
+
struct starfive_rsa_key *key = &ctx->rsa_key;
196
+
u32 temp;
197
+
int ret = 0;
198
+
int opsize, mlen, loop;
199
+
unsigned int *mta;
200
+
201
+
opsize = (key_sz - 1) >> 2;
202
+
203
+
mta = kmalloc(key_sz, GFP_KERNEL);
204
+
if (!mta)
205
+
return -ENOMEM;
206
+
207
+
ret = starfive_rsa_montgomery_form(ctx, mta, (u32 *)rctx->rsa_data,
208
+
0, n, key_sz << 3);
209
+
if (ret) {
210
+
dev_err_probe(cryp->dev, ret, "Conversion to Montgomery failed");
211
+
goto rsa_err;
212
+
}
213
+
214
+
for (loop = 0; loop <= opsize; loop++)
215
+
writel(mta[opsize - loop],
216
+
cryp->base + STARFIVE_PKA_CAER_OFFSET + loop * 4);
217
+
218
+
for (loop = key->bitlen - 1; loop > 0; loop--) {
219
+
mlen = starfive_rsa_get_nbit(de, loop - 1, key_sz);
220
+
221
+
rctx->csr.pka.v = 0;
222
+
rctx->csr.pka.cln_done = 1;
223
+
rctx->csr.pka.opsize = opsize;
224
+
rctx->csr.pka.exposize = opsize;
225
+
rctx->csr.pka.cmd = CRYPTO_CMD_AARN;
226
+
rctx->csr.pka.start = 1;
227
+
rctx->csr.pka.ie = 1;
228
+
229
+
starfive_pka_irq_mask_clear(ctx);
230
+
writel(rctx->csr.pka.v, cryp->base + STARFIVE_PKA_CACR_OFFSET);
231
+
232
+
ret = -ETIMEDOUT;
233
+
if (!starfive_pka_wait_done(ctx))
234
+
goto rsa_err;
235
+
236
+
if (mlen) {
237
+
rctx->csr.pka.v = 0;
238
+
rctx->csr.pka.cln_done = 1;
239
+
rctx->csr.pka.opsize = opsize;
240
+
rctx->csr.pka.exposize = opsize;
241
+
rctx->csr.pka.cmd = CRYPTO_CMD_AERN;
242
+
rctx->csr.pka.start = 1;
243
+
rctx->csr.pka.ie = 1;
244
+
245
+
starfive_pka_irq_mask_clear(ctx);
246
+
writel(rctx->csr.pka.v, cryp->base + STARFIVE_PKA_CACR_OFFSET);
247
+
248
+
if (!starfive_pka_wait_done(ctx))
249
+
goto rsa_err;
250
+
}
251
+
}
252
+
253
+
for (loop = 0; loop <= opsize; loop++) {
254
+
temp = readl(cryp->base + STARFIVE_PKA_CAAR_OFFSET + 0x4 * loop);
255
+
result[opsize - loop] = temp;
256
+
}
257
+
258
+
ret = starfive_rsa_montgomery_form(ctx, result, result, 1, n, key_sz << 3);
259
+
if (ret)
260
+
dev_err_probe(cryp->dev, ret, "Conversion from Montgomery failed");
261
+
rsa_err:
262
+
kfree(mta);
263
+
return ret;
264
+
}
265
+
266
+
static int starfive_rsa_start(struct starfive_cryp_ctx *ctx, u8 *result,
267
+
u8 *de, u8 *n, int key_sz)
268
+
{
269
+
return starfive_rsa_cpu_start(ctx, (u32 *)result, de, (u32 *)n, key_sz);
270
+
}
271
+
272
+
static int starfive_rsa_enc_core(struct starfive_cryp_ctx *ctx, int enc)
273
+
{
274
+
struct starfive_cryp_dev *cryp = ctx->cryp;
275
+
struct starfive_cryp_request_ctx *rctx = ctx->rctx;
276
+
struct starfive_rsa_key *key = &ctx->rsa_key;
277
+
int ret = 0;
278
+
279
+
writel(STARFIVE_RSA_RESET, cryp->base + STARFIVE_PKA_CACR_OFFSET);
280
+
281
+
rctx->total = sg_copy_to_buffer(rctx->in_sg, rctx->nents,
282
+
rctx->rsa_data, rctx->total);
283
+
284
+
if (enc) {
285
+
key->bitlen = key->e_bitlen;
286
+
ret = starfive_rsa_start(ctx, rctx->rsa_data, key->e,
287
+
key->n, key->key_sz);
288
+
} else {
289
+
key->bitlen = key->d_bitlen;
290
+
ret = starfive_rsa_start(ctx, rctx->rsa_data, key->d,
291
+
key->n, key->key_sz);
292
+
}
293
+
294
+
if (ret)
295
+
goto err_rsa_crypt;
296
+
297
+
sg_copy_buffer(rctx->out_sg, sg_nents(rctx->out_sg),
298
+
rctx->rsa_data, key->key_sz, 0, 0);
299
+
300
+
err_rsa_crypt:
301
+
writel(STARFIVE_RSA_RESET, cryp->base + STARFIVE_PKA_CACR_OFFSET);
302
+
kfree(rctx->rsa_data);
303
+
return ret;
304
+
}
305
+
306
+
static int starfive_rsa_enc(struct akcipher_request *req)
307
+
{
308
+
struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req);
309
+
struct starfive_cryp_ctx *ctx = akcipher_tfm_ctx(tfm);
310
+
struct starfive_cryp_dev *cryp = ctx->cryp;
311
+
struct starfive_rsa_key *key = &ctx->rsa_key;
312
+
struct starfive_cryp_request_ctx *rctx = akcipher_request_ctx(req);
313
+
int ret;
314
+
315
+
if (!key->key_sz) {
316
+
akcipher_request_set_tfm(req, ctx->akcipher_fbk);
317
+
ret = crypto_akcipher_encrypt(req);
318
+
akcipher_request_set_tfm(req, tfm);
319
+
return ret;
320
+
}
321
+
322
+
if (unlikely(!key->n || !key->e))
323
+
return -EINVAL;
324
+
325
+
if (req->dst_len < key->key_sz)
326
+
return dev_err_probe(cryp->dev, -EOVERFLOW,
327
+
"Output buffer length less than parameter n\n");
328
+
329
+
rctx->in_sg = req->src;
330
+
rctx->out_sg = req->dst;
331
+
rctx->total = req->src_len;
332
+
rctx->nents = sg_nents(rctx->in_sg);
333
+
ctx->rctx = rctx;
334
+
335
+
return starfive_rsa_enc_core(ctx, 1);
336
+
}
337
+
338
+
static int starfive_rsa_dec(struct akcipher_request *req)
339
+
{
340
+
struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req);
341
+
struct starfive_cryp_ctx *ctx = akcipher_tfm_ctx(tfm);
342
+
struct starfive_cryp_dev *cryp = ctx->cryp;
343
+
struct starfive_rsa_key *key = &ctx->rsa_key;
344
+
struct starfive_cryp_request_ctx *rctx = akcipher_request_ctx(req);
345
+
int ret;
346
+
347
+
if (!key->key_sz) {
348
+
akcipher_request_set_tfm(req, ctx->akcipher_fbk);
349
+
ret = crypto_akcipher_decrypt(req);
350
+
akcipher_request_set_tfm(req, tfm);
351
+
return ret;
352
+
}
353
+
354
+
if (unlikely(!key->n || !key->d))
355
+
return -EINVAL;
356
+
357
+
if (req->dst_len < key->key_sz)
358
+
return dev_err_probe(cryp->dev, -EOVERFLOW,
359
+
"Output buffer length less than parameter n\n");
360
+
361
+
rctx->in_sg = req->src;
362
+
rctx->out_sg = req->dst;
363
+
ctx->rctx = rctx;
364
+
rctx->total = req->src_len;
365
+
366
+
return starfive_rsa_enc_core(ctx, 0);
367
+
}
368
+
369
+
static int starfive_rsa_set_n(struct starfive_rsa_key *rsa_key,
370
+
const char *value, size_t vlen)
371
+
{
372
+
const char *ptr = value;
373
+
unsigned int bitslen;
374
+
int ret;
375
+
376
+
while (!*ptr && vlen) {
377
+
ptr++;
378
+
vlen--;
379
+
}
380
+
rsa_key->key_sz = vlen;
381
+
bitslen = rsa_key->key_sz << 3;
382
+
383
+
/* check valid key size */
384
+
if (bitslen & 0x1f)
385
+
return -EINVAL;
386
+
387
+
ret = -ENOMEM;
388
+
rsa_key->n = kmemdup(ptr, rsa_key->key_sz, GFP_KERNEL);
389
+
if (!rsa_key->n)
390
+
goto err;
391
+
392
+
return 0;
393
+
err:
394
+
rsa_key->key_sz = 0;
395
+
rsa_key->n = NULL;
396
+
starfive_rsa_free_key(rsa_key);
397
+
return ret;
398
+
}
399
+
400
+
static int starfive_rsa_set_e(struct starfive_rsa_key *rsa_key,
401
+
const char *value, size_t vlen)
402
+
{
403
+
const char *ptr = value;
404
+
unsigned char pt;
405
+
int loop;
406
+
407
+
while (!*ptr && vlen) {
408
+
ptr++;
409
+
vlen--;
410
+
}
411
+
pt = *ptr;
412
+
413
+
if (!rsa_key->key_sz || !vlen || vlen > rsa_key->key_sz) {
414
+
rsa_key->e = NULL;
415
+
return -EINVAL;
416
+
}
417
+
418
+
rsa_key->e = kzalloc(rsa_key->key_sz, GFP_KERNEL);
419
+
if (!rsa_key->e)
420
+
return -ENOMEM;
421
+
422
+
for (loop = 8; loop > 0; loop--) {
423
+
if (pt >> (loop - 1))
424
+
break;
425
+
}
426
+
427
+
rsa_key->e_bitlen = (vlen - 1) * 8 + loop;
428
+
429
+
memcpy(rsa_key->e + (rsa_key->key_sz - vlen), ptr, vlen);
430
+
431
+
return 0;
432
+
}
433
+
434
+
static int starfive_rsa_set_d(struct starfive_rsa_key *rsa_key,
435
+
const char *value, size_t vlen)
436
+
{
437
+
const char *ptr = value;
438
+
unsigned char pt;
439
+
int loop;
440
+
int ret;
441
+
442
+
while (!*ptr && vlen) {
443
+
ptr++;
444
+
vlen--;
445
+
}
446
+
pt = *ptr;
447
+
448
+
ret = -EINVAL;
449
+
if (!rsa_key->key_sz || !vlen || vlen > rsa_key->key_sz)
450
+
goto err;
451
+
452
+
ret = -ENOMEM;
453
+
rsa_key->d = kzalloc(rsa_key->key_sz, GFP_KERNEL);
454
+
if (!rsa_key->d)
455
+
goto err;
456
+
457
+
for (loop = 8; loop > 0; loop--) {
458
+
if (pt >> (loop - 1))
459
+
break;
460
+
}
461
+
462
+
rsa_key->d_bitlen = (vlen - 1) * 8 + loop;
463
+
464
+
memcpy(rsa_key->d + (rsa_key->key_sz - vlen), ptr, vlen);
465
+
466
+
return 0;
467
+
err:
468
+
rsa_key->d = NULL;
469
+
return ret;
470
+
}
471
+
472
+
static int starfive_rsa_setkey(struct crypto_akcipher *tfm, const void *key,
473
+
unsigned int keylen, bool private)
474
+
{
475
+
struct starfive_cryp_ctx *ctx = akcipher_tfm_ctx(tfm);
476
+
struct rsa_key raw_key = {NULL};
477
+
struct starfive_rsa_key *rsa_key = &ctx->rsa_key;
478
+
int ret;
479
+
480
+
if (private)
481
+
ret = rsa_parse_priv_key(&raw_key, key, keylen);
482
+
else
483
+
ret = rsa_parse_pub_key(&raw_key, key, keylen);
484
+
if (ret < 0)
485
+
goto err;
486
+
487
+
starfive_rsa_free_key(rsa_key);
488
+
489
+
/* Use fallback for mod > 256 + 1 byte prefix */
490
+
if (raw_key.n_sz > STARFIVE_RSA_MAX_KEYSZ + 1)
491
+
return 0;
492
+
493
+
ret = starfive_rsa_set_n(rsa_key, raw_key.n, raw_key.n_sz);
494
+
if (ret)
495
+
return ret;
496
+
497
+
ret = starfive_rsa_set_e(rsa_key, raw_key.e, raw_key.e_sz);
498
+
if (ret)
499
+
goto err;
500
+
501
+
if (private) {
502
+
ret = starfive_rsa_set_d(rsa_key, raw_key.d, raw_key.d_sz);
503
+
if (ret)
504
+
goto err;
505
+
}
506
+
507
+
if (!rsa_key->n || !rsa_key->e) {
508
+
ret = -EINVAL;
509
+
goto err;
510
+
}
511
+
512
+
if (private && !rsa_key->d) {
513
+
ret = -EINVAL;
514
+
goto err;
515
+
}
516
+
517
+
return 0;
518
+
err:
519
+
starfive_rsa_free_key(rsa_key);
520
+
return ret;
521
+
}
522
+
523
+
static int starfive_rsa_set_pub_key(struct crypto_akcipher *tfm, const void *key,
524
+
unsigned int keylen)
525
+
{
526
+
struct starfive_cryp_ctx *ctx = akcipher_tfm_ctx(tfm);
527
+
int ret;
528
+
529
+
ret = crypto_akcipher_set_pub_key(ctx->akcipher_fbk, key, keylen);
530
+
if (ret)
531
+
return ret;
532
+
533
+
return starfive_rsa_setkey(tfm, key, keylen, false);
534
+
}
535
+
536
+
static int starfive_rsa_set_priv_key(struct crypto_akcipher *tfm, const void *key,
537
+
unsigned int keylen)
538
+
{
539
+
struct starfive_cryp_ctx *ctx = akcipher_tfm_ctx(tfm);
540
+
int ret;
541
+
542
+
ret = crypto_akcipher_set_priv_key(ctx->akcipher_fbk, key, keylen);
543
+
if (ret)
544
+
return ret;
545
+
546
+
return starfive_rsa_setkey(tfm, key, keylen, true);
547
+
}
548
+
549
+
static unsigned int starfive_rsa_max_size(struct crypto_akcipher *tfm)
550
+
{
551
+
struct starfive_cryp_ctx *ctx = akcipher_tfm_ctx(tfm);
552
+
553
+
if (ctx->rsa_key.key_sz)
554
+
return ctx->rsa_key.key_sz;
555
+
556
+
return crypto_akcipher_maxsize(ctx->akcipher_fbk);
557
+
}
558
+
559
+
static int starfive_rsa_init_tfm(struct crypto_akcipher *tfm)
560
+
{
561
+
struct starfive_cryp_ctx *ctx = akcipher_tfm_ctx(tfm);
562
+
563
+
ctx->akcipher_fbk = crypto_alloc_akcipher("rsa-generic", 0, 0);
564
+
if (IS_ERR(ctx->akcipher_fbk))
565
+
return PTR_ERR(ctx->akcipher_fbk);
566
+
567
+
ctx->cryp = starfive_cryp_find_dev(ctx);
568
+
if (!ctx->cryp) {
569
+
crypto_free_akcipher(ctx->akcipher_fbk);
570
+
return -ENODEV;
571
+
}
572
+
573
+
akcipher_set_reqsize(tfm, sizeof(struct starfive_cryp_request_ctx) +
574
+
sizeof(struct crypto_akcipher) + 32);
575
+
576
+
return 0;
577
+
}
578
+
579
+
static void starfive_rsa_exit_tfm(struct crypto_akcipher *tfm)
580
+
{
581
+
struct starfive_cryp_ctx *ctx = akcipher_tfm_ctx(tfm);
582
+
struct starfive_rsa_key *key = (struct starfive_rsa_key *)&ctx->rsa_key;
583
+
584
+
crypto_free_akcipher(ctx->akcipher_fbk);
585
+
starfive_rsa_free_key(key);
586
+
}
587
+
588
+
static struct akcipher_alg starfive_rsa = {
589
+
.encrypt = starfive_rsa_enc,
590
+
.decrypt = starfive_rsa_dec,
591
+
.sign = starfive_rsa_dec,
592
+
.verify = starfive_rsa_enc,
593
+
.set_pub_key = starfive_rsa_set_pub_key,
594
+
.set_priv_key = starfive_rsa_set_priv_key,
595
+
.max_size = starfive_rsa_max_size,
596
+
.init = starfive_rsa_init_tfm,
597
+
.exit = starfive_rsa_exit_tfm,
598
+
.base = {
599
+
.cra_name = "rsa",
600
+
.cra_driver_name = "starfive-rsa",
601
+
.cra_flags = CRYPTO_ALG_TYPE_AKCIPHER |
602
+
CRYPTO_ALG_NEED_FALLBACK,
603
+
.cra_priority = 3000,
604
+
.cra_module = THIS_MODULE,
605
+
.cra_ctxsize = sizeof(struct starfive_cryp_ctx),
606
+
},
607
+
};
608
+
609
+
int starfive_rsa_register_algs(void)
610
+
{
611
+
return crypto_register_akcipher(&starfive_rsa);
612
+
}
613
+
614
+
void starfive_rsa_unregister_algs(void)
615
+
{
616
+
crypto_unregister_akcipher(&starfive_rsa);
617
+
}