]> cvs.zerfleddert.de Git - proxmark3-svn/blob - client/emv/crypto_polarssl.c
projects / proxmark3-svn / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Adding native support for HID long-format
[proxmark3-svn] / client / emv / crypto_polarssl.c
1 /*
2 * libopenemv - a library to work with EMV family of smart cards
3 * Copyright (C) 2015 Dmitry Eremin-Solenikov
4 * Copyright (C) 2017 Merlok
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 */
16
17 #ifdef HAVE_CONFIG_H
18 #include <config.h>
19 #endif
20
21 #include "crypto.h"
22 #include "crypto_backend.h"
23
24 #include <stdarg.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27
28 #include "rsa.h"
29 #include "sha1.h"
30
31 struct crypto_hash_polarssl {
32 struct crypto_hash ch;
33 sha1_context ctx;
34 };
35
36 static void crypto_hash_polarssl_close(struct crypto_hash *_ch)
37 {
38 struct crypto_hash_polarssl *ch = (struct crypto_hash_polarssl *)_ch;
39
40 free(ch);
41 }
42
43 static void crypto_hash_polarssl_write(struct crypto_hash *_ch, const unsigned char *buf, size_t len)
44 {
45 struct crypto_hash_polarssl *ch = (struct crypto_hash_polarssl *)_ch;
46
47 sha1_update(&(ch->ctx), buf, len);
48 }
49
50 static unsigned char *crypto_hash_polarssl_read(struct crypto_hash *_ch)
51 {
52 struct crypto_hash_polarssl *ch = (struct crypto_hash_polarssl *)_ch;
53
54 static unsigned char sha1sum[20];
55 sha1_finish(&(ch->ctx), sha1sum);
56 return sha1sum;
57 }
58
59 static size_t crypto_hash_polarssl_get_size(const struct crypto_hash *ch)
60 {
61 if (ch->algo == HASH_SHA_1)
62 return 20;
63 else
64 return 0;
65 }
66
67 static struct crypto_hash *crypto_hash_polarssl_open(enum crypto_algo_hash hash)
68 {
69 if (hash != HASH_SHA_1)
70 return NULL;
71
72 struct crypto_hash_polarssl *ch = malloc(sizeof(*ch));
73
74 sha1_starts(&(ch->ctx));
75
76 ch->ch.write = crypto_hash_polarssl_write;
77 ch->ch.read = crypto_hash_polarssl_read;
78 ch->ch.close = crypto_hash_polarssl_close;
79 ch->ch.get_size = crypto_hash_polarssl_get_size;
80
81 return &ch->ch;
82 }
83
84 struct crypto_pk_polarssl {
85 struct crypto_pk cp;
86 rsa_context ctx;
87 };
88
89 static struct crypto_pk *crypto_pk_polarssl_open_rsa(va_list vl)
90 {
91 struct crypto_pk_polarssl *cp = malloc(sizeof(*cp));
92 memset(cp, 0x00, sizeof(*cp));
93
94 char *mod = va_arg(vl, char *); // N
95 int modlen = va_arg(vl, size_t);
96 char *exp = va_arg(vl, char *); // E
97 int explen = va_arg(vl, size_t);
98
99 rsa_init(&cp->ctx, RSA_PKCS_V15, 0);
100
101 cp->ctx.len = modlen; // size(N) in bytes
102 mpi_read_binary(&cp->ctx.N, (const unsigned char *)mod, modlen);
103 mpi_read_binary(&cp->ctx.E, (const unsigned char *)exp, explen);
104
105 int res = rsa_check_pubkey(&cp->ctx);
106 if(res != 0) {
107 fprintf(stderr, "PolarSSL public key error res=%x exp=%d mod=%d.\n", res * -1, explen, modlen);
108 free(cp);
109 return NULL;
110 }
111
112 return &cp->cp;
113 }
114
115 static struct crypto_pk *crypto_pk_polarssl_open_priv_rsa(va_list vl)
116 {
117 struct crypto_pk_polarssl *cp = malloc(sizeof(*cp));
118 memset(cp, 0x00, sizeof(*cp));
119 char *mod = va_arg(vl, char *);
120 int modlen = va_arg(vl, size_t);
121 char *exp = va_arg(vl, char *);
122 int explen = va_arg(vl, size_t);
123 char *d = va_arg(vl, char *);
124 int dlen = va_arg(vl, size_t);
125 char *p = va_arg(vl, char *);
126 int plen = va_arg(vl, size_t);
127 char *q = va_arg(vl, char *);
128 int qlen = va_arg(vl, size_t);
129 char *dp = va_arg(vl, char *);
130 int dplen = va_arg(vl, size_t);
131 char *dq = va_arg(vl, char *);
132 int dqlen = va_arg(vl, size_t);
133 // calc QP via Q and P
134 // char *inv = va_arg(vl, char *);
135 // int invlen = va_arg(vl, size_t);
136
137 rsa_init(&cp->ctx, RSA_PKCS_V15, 0);
138
139 cp->ctx.len = modlen; // size(N) in bytes
140 mpi_read_binary(&cp->ctx.N, (const unsigned char *)mod, modlen);
141 mpi_read_binary(&cp->ctx.E, (const unsigned char *)exp, explen);
142
143 mpi_read_binary(&cp->ctx.D, (const unsigned char *)d, dlen);
144 mpi_read_binary(&cp->ctx.P, (const unsigned char *)p, plen);
145 mpi_read_binary(&cp->ctx.Q, (const unsigned char *)q, qlen);
146 mpi_read_binary(&cp->ctx.DP, (const unsigned char *)dp, dplen);
147 mpi_read_binary(&cp->ctx.DQ, (const unsigned char *)dq, dqlen);
148 mpi_inv_mod(&cp->ctx.QP, &cp->ctx.Q, &cp->ctx.P);
149
150 int res = rsa_check_privkey(&cp->ctx);
151 if(res != 0) {
152 fprintf(stderr, "PolarSSL private key error res=%x exp=%d mod=%d.\n", res * -1, explen, modlen);
153 free(cp);
154 return NULL;
155 }
156
157 return &cp->cp;
158 }
159
160 static int myrand(void *rng_state, unsigned char *output, size_t len) {
161 size_t i;
162
163 if(rng_state != NULL)
164 rng_state = NULL;
165
166 for( i = 0; i < len; ++i )
167 output[i] = rand();
168
169 return 0;
170 }
171
172
173 static struct crypto_pk *crypto_pk_polarssl_genkey_rsa(va_list vl)
174 {
175 struct crypto_pk_polarssl *cp = malloc(sizeof(*cp));
176 memset(cp, 0x00, sizeof(*cp));
177
178 int transient = va_arg(vl, int);
179 unsigned int nbits = va_arg(vl, unsigned int);
180 unsigned int exp = va_arg(vl, unsigned int);
181
182 if (transient) {
183 }
184
185 int res = rsa_gen_key(&cp->ctx, &myrand, NULL, nbits, exp);
186 if (res) {
187 fprintf(stderr, "PolarSSL private key generation error res=%x exp=%d nbits=%d.\n", res * -1, exp, nbits);
188 free(cp);
189 return NULL;
190 }
191
192 return &cp->cp;
193 }
194
195 static void crypto_pk_polarssl_close(struct crypto_pk *_cp)
196 {
197 struct crypto_pk_polarssl *cp = (struct crypto_pk_polarssl *)_cp;
198
199 rsa_free(&cp->ctx);
200 free(cp);
201 }
202
203 static unsigned char *crypto_pk_polarssl_encrypt(const struct crypto_pk *_cp, const unsigned char *buf, size_t len, size_t *clen)
204 {
205 struct crypto_pk_polarssl *cp = (struct crypto_pk_polarssl *)_cp;
206 int res;
207 unsigned char *result;
208
209 *clen = 0;
210 size_t keylen = mpi_size(&cp->ctx.N);
211
212 result = malloc(keylen);
213 if (!result) {
214 printf("RSA encrypt failed. Can't allocate result memory.\n");
215 return NULL;
216 }
217
218 res = rsa_public(&cp->ctx, buf, result);
219 if(res) {
220 printf("RSA encrypt failed. Error: %x data len: %zd key len: %zd\n", res * -1, len, keylen);
221 free(result);
222 return NULL;
223 }
224
225 *clen = keylen;
226
227 return result;
228 }
229
230 static unsigned char *crypto_pk_polarssl_decrypt(const struct crypto_pk *_cp, const unsigned char *buf, size_t len, size_t *clen)
231 {
232 struct crypto_pk_polarssl *cp = (struct crypto_pk_polarssl *)_cp;
233 int res;
234 unsigned char *result;
235
236 *clen = 0;
237 size_t keylen = mpi_size(&cp->ctx.N);
238
239 result = malloc(keylen);
240 if (!result) {
241 printf("RSA encrypt failed. Can't allocate result memory.\n");
242 return NULL;
243 }
244
245 res = rsa_private(&cp->ctx, buf, result); // CHECK???
246 if(res) {
247 printf("RSA decrypt failed. Error: %x data len: %zd key len: %zd\n", res * -1, len, keylen);
248 free(result);
249 return NULL;
250 }
251
252 *clen = keylen;
253
254 return result;
255 }
256
257 static size_t crypto_pk_polarssl_get_nbits(const struct crypto_pk *_cp)
258 {
259 struct crypto_pk_polarssl *cp = (struct crypto_pk_polarssl *)_cp;
260
261 return cp->ctx.len * 8;
262 return 0;
263 }
264
265 static unsigned char *crypto_pk_polarssl_get_parameter(const struct crypto_pk *_cp, unsigned param, size_t *plen)
266 {
267 struct crypto_pk_polarssl *cp = (struct crypto_pk_polarssl *)_cp;
268 unsigned char *result = NULL;
269 switch(param){
270 // mod
271 case 0:
272 *plen = mpi_size(&cp->ctx.N);
273 result = malloc(*plen);
274 memset(result, 0x00, *plen);
275 mpi_write_binary(&cp->ctx.N, result, *plen);
276 break;
277 // exp
278 case 1:
279 *plen = mpi_size(&cp->ctx.E);
280 result = malloc(*plen);
281 memset(result, 0x00, *plen);
282 mpi_write_binary(&cp->ctx.E, result, *plen);
283 break;
284 default:
285 printf("Error get parameter. Param=%d", param);
286 break;
287 }
288
289 return result;
290 }
291
292 static struct crypto_pk *crypto_pk_polarssl_open(enum crypto_algo_pk pk, va_list vl)
293 {
294 struct crypto_pk *cp;
295
296 if (pk == PK_RSA)
297 cp = crypto_pk_polarssl_open_rsa(vl);
298 else
299 return NULL;
300
301 cp->close = crypto_pk_polarssl_close;
302 cp->encrypt = crypto_pk_polarssl_encrypt;
303 cp->get_parameter = crypto_pk_polarssl_get_parameter;
304 cp->get_nbits = crypto_pk_polarssl_get_nbits;
305
306 return cp;
307 }
308
309 static struct crypto_pk *crypto_pk_polarssl_open_priv(enum crypto_algo_pk pk, va_list vl)
310 {
311 struct crypto_pk *cp;
312
313 if (pk == PK_RSA)
314 cp = crypto_pk_polarssl_open_priv_rsa(vl);
315 else
316 return NULL;
317
318 cp->close = crypto_pk_polarssl_close;
319 cp->encrypt = crypto_pk_polarssl_encrypt;
320 cp->decrypt = crypto_pk_polarssl_decrypt;
321 cp->get_parameter = crypto_pk_polarssl_get_parameter;
322 cp->get_nbits = crypto_pk_polarssl_get_nbits;
323
324 return cp;
325 }
326
327 static struct crypto_pk *crypto_pk_polarssl_genkey(enum crypto_algo_pk pk, va_list vl)
328 {
329 struct crypto_pk *cp;
330
331 if (pk == PK_RSA)
332 cp = crypto_pk_polarssl_genkey_rsa(vl);
333 else
334 return NULL;
335
336 cp->close = crypto_pk_polarssl_close;
337 cp->encrypt = crypto_pk_polarssl_encrypt;
338 cp->decrypt = crypto_pk_polarssl_decrypt;
339 cp->get_parameter = crypto_pk_polarssl_get_parameter;
340 cp->get_nbits = crypto_pk_polarssl_get_nbits;
341
342 return cp;
343 }
344
345 static struct crypto_backend crypto_polarssl_backend = {
346 .hash_open = crypto_hash_polarssl_open,
347 .pk_open = crypto_pk_polarssl_open,
348 .pk_open_priv = crypto_pk_polarssl_open_priv,
349 .pk_genkey = crypto_pk_polarssl_genkey,
350 };
351
352 struct crypto_backend *crypto_polarssl_init(void)
353 {
354 return &crypto_polarssl_backend;
355 }
Proxmark3 GIT tracking
Impressum, Datenschutz