1 /**
2 * WinPR: Windows Portable Runtime
3 *
4 * Copyright 2015 Marc-Andre Moreau <marcandre.moreau@gmail.com>
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 */
18
19 #ifdef HAVE_CONFIG_H
20 #include "config.h"
21 #endif
22
23 #include <winpr/crt.h>
24
25 #include <winpr/crypto.h>
26
27 #ifdef WITH_OPENSSL
28 #include <openssl/aes.h>
29 #include <openssl/rc4.h>
30 #include <openssl/des.h>
31 #include <openssl/evp.h>
32 #endif
33
34 #ifdef WITH_MBEDTLS
35 #include <mbedtls/md.h>
36 #include <mbedtls/aes.h>
37 #include <mbedtls/arc4.h>
38 #include <mbedtls/des.h>
39 #include <mbedtls/cipher.h>
40 #endif
41
42 /**
43 * RC4
44 */
45
winpr_RC4_New_Internal(const BYTE * key,size_t keylen,BOOL override_fips)46 static WINPR_RC4_CTX* winpr_RC4_New_Internal(const BYTE* key, size_t keylen, BOOL override_fips)
47 {
48 WINPR_RC4_CTX* ctx = NULL;
49 #if defined(WITH_OPENSSL)
50 const EVP_CIPHER* evp = NULL;
51 #endif
52
53 if (!key || (keylen == 0))
54 return NULL;
55
56 #if defined(WITH_OPENSSL)
57
58 if (keylen > INT_MAX)
59 return NULL;
60
61 if (!(ctx = (WINPR_RC4_CTX*)EVP_CIPHER_CTX_new()))
62 return NULL;
63
64 evp = EVP_rc4();
65
66 if (!evp)
67 return NULL;
68
69 EVP_CIPHER_CTX_init((EVP_CIPHER_CTX*)ctx);
70 if (EVP_EncryptInit_ex((EVP_CIPHER_CTX*)ctx, evp, NULL, NULL, NULL) != 1)
71 {
72 EVP_CIPHER_CTX_free ((EVP_CIPHER_CTX*)ctx);
73 return NULL;
74 }
75
76 /* EVP_CIPH_FLAG_NON_FIPS_ALLOW does not exist before openssl 1.0.1 */
77 #if !(OPENSSL_VERSION_NUMBER < 0x10001000L)
78
79 if (override_fips == TRUE)
80 EVP_CIPHER_CTX_set_flags((EVP_CIPHER_CTX*)ctx, EVP_CIPH_FLAG_NON_FIPS_ALLOW);
81
82 #endif
83 EVP_CIPHER_CTX_set_key_length((EVP_CIPHER_CTX*)ctx, (int)keylen);
84 if (EVP_EncryptInit_ex((EVP_CIPHER_CTX*)ctx, NULL, NULL, key, NULL) != 1)
85 {
86 EVP_CIPHER_CTX_free ((EVP_CIPHER_CTX*)ctx);
87 return NULL;
88 }
89 #elif defined(WITH_MBEDTLS) && defined(MBEDTLS_ARC4_C)
90
91 if (!(ctx = (WINPR_RC4_CTX*)calloc(1, sizeof(mbedtls_arc4_context))))
92 return NULL;
93
94 mbedtls_arc4_init((mbedtls_arc4_context*)ctx);
95 mbedtls_arc4_setup((mbedtls_arc4_context*)ctx, key, (unsigned int)keylen);
96 #endif
97 return ctx;
98 }
99
winpr_RC4_New_Allow_FIPS(const BYTE * key,size_t keylen)100 WINPR_RC4_CTX* winpr_RC4_New_Allow_FIPS(const BYTE* key, size_t keylen)
101 {
102 return winpr_RC4_New_Internal(key, keylen, TRUE);
103 }
104
winpr_RC4_New(const BYTE * key,size_t keylen)105 WINPR_RC4_CTX* winpr_RC4_New(const BYTE* key, size_t keylen)
106 {
107 return winpr_RC4_New_Internal(key, keylen, FALSE);
108 }
109
winpr_RC4_Update(WINPR_RC4_CTX * ctx,size_t length,const BYTE * input,BYTE * output)110 BOOL winpr_RC4_Update(WINPR_RC4_CTX* ctx, size_t length, const BYTE* input, BYTE* output)
111 {
112 #if defined(WITH_OPENSSL)
113 int outputLength;
114 EVP_CipherUpdate((EVP_CIPHER_CTX*)ctx, output, &outputLength, input, length);
115 return TRUE;
116 #elif defined(WITH_MBEDTLS) && defined(MBEDTLS_ARC4_C)
117
118 if (mbedtls_arc4_crypt((mbedtls_arc4_context*)ctx, length, input, output) == 0)
119 return TRUE;
120
121 #endif
122 return FALSE;
123 }
124
winpr_RC4_Free(WINPR_RC4_CTX * ctx)125 void winpr_RC4_Free(WINPR_RC4_CTX* ctx)
126 {
127 if (!ctx)
128 return;
129
130 #if defined(WITH_OPENSSL)
131 EVP_CIPHER_CTX_free((EVP_CIPHER_CTX*)ctx);
132 #elif defined(WITH_MBEDTLS) && defined(MBEDTLS_ARC4_C)
133 mbedtls_arc4_free((mbedtls_arc4_context*)ctx);
134 free(ctx);
135 #endif
136 }
137
138 /**
139 * Generic Cipher API
140 */
141
142 #ifdef WITH_OPENSSL
143 extern const EVP_MD* winpr_openssl_get_evp_md(WINPR_MD_TYPE md);
144 #endif
145
146 #ifdef WITH_MBEDTLS
147 extern mbedtls_md_type_t winpr_mbedtls_get_md_type(int md);
148 #endif
149
150 #if defined(WITH_OPENSSL)
winpr_openssl_get_evp_cipher(int cipher)151 static const EVP_CIPHER* winpr_openssl_get_evp_cipher(int cipher)
152 {
153 const EVP_CIPHER* evp = NULL;
154
155 switch (cipher)
156 {
157 case WINPR_CIPHER_NULL:
158 evp = EVP_enc_null();
159 break;
160
161 case WINPR_CIPHER_AES_128_ECB:
162 evp = EVP_get_cipherbyname("aes-128-ecb");
163 break;
164
165 case WINPR_CIPHER_AES_192_ECB:
166 evp = EVP_get_cipherbyname("aes-192-ecb");
167 break;
168
169 case WINPR_CIPHER_AES_256_ECB:
170 evp = EVP_get_cipherbyname("aes-256-ecb");
171 break;
172
173 case WINPR_CIPHER_AES_128_CBC:
174 evp = EVP_get_cipherbyname("aes-128-cbc");
175 break;
176
177 case WINPR_CIPHER_AES_192_CBC:
178 evp = EVP_get_cipherbyname("aes-192-cbc");
179 break;
180
181 case WINPR_CIPHER_AES_256_CBC:
182 evp = EVP_get_cipherbyname("aes-256-cbc");
183 break;
184
185 case WINPR_CIPHER_AES_128_CFB128:
186 evp = EVP_get_cipherbyname("aes-128-cfb128");
187 break;
188
189 case WINPR_CIPHER_AES_192_CFB128:
190 evp = EVP_get_cipherbyname("aes-192-cfb128");
191 break;
192
193 case WINPR_CIPHER_AES_256_CFB128:
194 evp = EVP_get_cipherbyname("aes-256-cfb128");
195 break;
196
197 case WINPR_CIPHER_AES_128_CTR:
198 evp = EVP_get_cipherbyname("aes-128-ctr");
199 break;
200
201 case WINPR_CIPHER_AES_192_CTR:
202 evp = EVP_get_cipherbyname("aes-192-ctr");
203 break;
204
205 case WINPR_CIPHER_AES_256_CTR:
206 evp = EVP_get_cipherbyname("aes-256-ctr");
207 break;
208
209 case WINPR_CIPHER_AES_128_GCM:
210 evp = EVP_get_cipherbyname("aes-128-gcm");
211 break;
212
213 case WINPR_CIPHER_AES_192_GCM:
214 evp = EVP_get_cipherbyname("aes-192-gcm");
215 break;
216
217 case WINPR_CIPHER_AES_256_GCM:
218 evp = EVP_get_cipherbyname("aes-256-gcm");
219 break;
220
221 case WINPR_CIPHER_AES_128_CCM:
222 evp = EVP_get_cipherbyname("aes-128-ccm");
223 break;
224
225 case WINPR_CIPHER_AES_192_CCM:
226 evp = EVP_get_cipherbyname("aes-192-ccm");
227 break;
228
229 case WINPR_CIPHER_AES_256_CCM:
230 evp = EVP_get_cipherbyname("aes-256-ccm");
231 break;
232
233 case WINPR_CIPHER_CAMELLIA_128_ECB:
234 evp = EVP_get_cipherbyname("camellia-128-ecb");
235 break;
236
237 case WINPR_CIPHER_CAMELLIA_192_ECB:
238 evp = EVP_get_cipherbyname("camellia-192-ecb");
239 break;
240
241 case WINPR_CIPHER_CAMELLIA_256_ECB:
242 evp = EVP_get_cipherbyname("camellia-256-ecb");
243 break;
244
245 case WINPR_CIPHER_CAMELLIA_128_CBC:
246 evp = EVP_get_cipherbyname("camellia-128-cbc");
247 break;
248
249 case WINPR_CIPHER_CAMELLIA_192_CBC:
250 evp = EVP_get_cipherbyname("camellia-192-cbc");
251 break;
252
253 case WINPR_CIPHER_CAMELLIA_256_CBC:
254 evp = EVP_get_cipherbyname("camellia-256-cbc");
255 break;
256
257 case WINPR_CIPHER_CAMELLIA_128_CFB128:
258 evp = EVP_get_cipherbyname("camellia-128-cfb128");
259 break;
260
261 case WINPR_CIPHER_CAMELLIA_192_CFB128:
262 evp = EVP_get_cipherbyname("camellia-192-cfb128");
263 break;
264
265 case WINPR_CIPHER_CAMELLIA_256_CFB128:
266 evp = EVP_get_cipherbyname("camellia-256-cfb128");
267 break;
268
269 case WINPR_CIPHER_CAMELLIA_128_CTR:
270 evp = EVP_get_cipherbyname("camellia-128-ctr");
271 break;
272
273 case WINPR_CIPHER_CAMELLIA_192_CTR:
274 evp = EVP_get_cipherbyname("camellia-192-ctr");
275 break;
276
277 case WINPR_CIPHER_CAMELLIA_256_CTR:
278 evp = EVP_get_cipherbyname("camellia-256-ctr");
279 break;
280
281 case WINPR_CIPHER_CAMELLIA_128_GCM:
282 evp = EVP_get_cipherbyname("camellia-128-gcm");
283 break;
284
285 case WINPR_CIPHER_CAMELLIA_192_GCM:
286 evp = EVP_get_cipherbyname("camellia-192-gcm");
287 break;
288
289 case WINPR_CIPHER_CAMELLIA_256_GCM:
290 evp = EVP_get_cipherbyname("camellia-256-gcm");
291 break;
292
293 case WINPR_CIPHER_CAMELLIA_128_CCM:
294 evp = EVP_get_cipherbyname("camellia-128-ccm");
295 break;
296
297 case WINPR_CIPHER_CAMELLIA_192_CCM:
298 evp = EVP_get_cipherbyname("camellia-192-gcm");
299 break;
300
301 case WINPR_CIPHER_CAMELLIA_256_CCM:
302 evp = EVP_get_cipherbyname("camellia-256-gcm");
303 break;
304
305 case WINPR_CIPHER_DES_ECB:
306 evp = EVP_get_cipherbyname("des-ecb");
307 break;
308
309 case WINPR_CIPHER_DES_CBC:
310 evp = EVP_get_cipherbyname("des-cbc");
311 break;
312
313 case WINPR_CIPHER_DES_EDE_ECB:
314 evp = EVP_get_cipherbyname("des-ede-ecb");
315 break;
316
317 case WINPR_CIPHER_DES_EDE_CBC:
318 evp = EVP_get_cipherbyname("des-ede-cbc");
319 break;
320
321 case WINPR_CIPHER_DES_EDE3_ECB:
322 evp = EVP_get_cipherbyname("des-ede3-ecb");
323 break;
324
325 case WINPR_CIPHER_DES_EDE3_CBC:
326 evp = EVP_get_cipherbyname("des-ede3-cbc");
327 break;
328
329 case WINPR_CIPHER_ARC4_128:
330 evp = EVP_get_cipherbyname("rc4");
331 break;
332
333 case WINPR_CIPHER_BLOWFISH_ECB:
334 evp = EVP_get_cipherbyname("blowfish-ecb");
335 break;
336
337 case WINPR_CIPHER_BLOWFISH_CBC:
338 evp = EVP_get_cipherbyname("blowfish-cbc");
339 break;
340
341 case WINPR_CIPHER_BLOWFISH_CFB64:
342 evp = EVP_get_cipherbyname("blowfish-cfb64");
343 break;
344
345 case WINPR_CIPHER_BLOWFISH_CTR:
346 evp = EVP_get_cipherbyname("blowfish-ctr");
347 break;
348 }
349
350 return evp;
351 }
352
353 #elif defined(WITH_MBEDTLS)
winpr_mbedtls_get_cipher_type(int cipher)354 mbedtls_cipher_type_t winpr_mbedtls_get_cipher_type(int cipher)
355 {
356 mbedtls_cipher_type_t type = MBEDTLS_CIPHER_NONE;
357
358 switch (cipher)
359 {
360 case WINPR_CIPHER_NONE:
361 type = MBEDTLS_CIPHER_NONE;
362 break;
363
364 case WINPR_CIPHER_NULL:
365 type = MBEDTLS_CIPHER_NULL;
366 break;
367
368 case WINPR_CIPHER_AES_128_ECB:
369 type = MBEDTLS_CIPHER_AES_128_ECB;
370 break;
371
372 case WINPR_CIPHER_AES_192_ECB:
373 type = MBEDTLS_CIPHER_AES_192_ECB;
374 break;
375
376 case WINPR_CIPHER_AES_256_ECB:
377 type = MBEDTLS_CIPHER_AES_256_ECB;
378 break;
379
380 case WINPR_CIPHER_AES_128_CBC:
381 type = MBEDTLS_CIPHER_AES_128_CBC;
382 break;
383
384 case WINPR_CIPHER_AES_192_CBC:
385 type = MBEDTLS_CIPHER_AES_192_CBC;
386 break;
387
388 case WINPR_CIPHER_AES_256_CBC:
389 type = MBEDTLS_CIPHER_AES_256_CBC;
390 break;
391
392 case WINPR_CIPHER_AES_128_CFB128:
393 type = MBEDTLS_CIPHER_AES_128_CFB128;
394 break;
395
396 case WINPR_CIPHER_AES_192_CFB128:
397 type = MBEDTLS_CIPHER_AES_192_CFB128;
398 break;
399
400 case WINPR_CIPHER_AES_256_CFB128:
401 type = MBEDTLS_CIPHER_AES_256_CFB128;
402 break;
403
404 case WINPR_CIPHER_AES_128_CTR:
405 type = MBEDTLS_CIPHER_AES_128_CTR;
406 break;
407
408 case WINPR_CIPHER_AES_192_CTR:
409 type = MBEDTLS_CIPHER_AES_192_CTR;
410 break;
411
412 case WINPR_CIPHER_AES_256_CTR:
413 type = MBEDTLS_CIPHER_AES_256_CTR;
414 break;
415
416 case WINPR_CIPHER_AES_128_GCM:
417 type = MBEDTLS_CIPHER_AES_128_GCM;
418 break;
419
420 case WINPR_CIPHER_AES_192_GCM:
421 type = MBEDTLS_CIPHER_AES_192_GCM;
422 break;
423
424 case WINPR_CIPHER_AES_256_GCM:
425 type = MBEDTLS_CIPHER_AES_256_GCM;
426 break;
427
428 case WINPR_CIPHER_CAMELLIA_128_ECB:
429 type = MBEDTLS_CIPHER_CAMELLIA_128_ECB;
430 break;
431
432 case WINPR_CIPHER_CAMELLIA_192_ECB:
433 type = MBEDTLS_CIPHER_CAMELLIA_192_ECB;
434 break;
435
436 case WINPR_CIPHER_CAMELLIA_256_ECB:
437 type = MBEDTLS_CIPHER_CAMELLIA_256_ECB;
438 break;
439
440 case WINPR_CIPHER_CAMELLIA_128_CBC:
441 type = MBEDTLS_CIPHER_CAMELLIA_128_CBC;
442 break;
443
444 case WINPR_CIPHER_CAMELLIA_192_CBC:
445 type = MBEDTLS_CIPHER_CAMELLIA_192_CBC;
446 break;
447
448 case WINPR_CIPHER_CAMELLIA_256_CBC:
449 type = MBEDTLS_CIPHER_CAMELLIA_256_CBC;
450 break;
451
452 case WINPR_CIPHER_CAMELLIA_128_CFB128:
453 type = MBEDTLS_CIPHER_CAMELLIA_128_CFB128;
454 break;
455
456 case WINPR_CIPHER_CAMELLIA_192_CFB128:
457 type = MBEDTLS_CIPHER_CAMELLIA_192_CFB128;
458 break;
459
460 case WINPR_CIPHER_CAMELLIA_256_CFB128:
461 type = MBEDTLS_CIPHER_CAMELLIA_256_CFB128;
462 break;
463
464 case WINPR_CIPHER_CAMELLIA_128_CTR:
465 type = MBEDTLS_CIPHER_CAMELLIA_128_CTR;
466 break;
467
468 case WINPR_CIPHER_CAMELLIA_192_CTR:
469 type = MBEDTLS_CIPHER_CAMELLIA_192_CTR;
470 break;
471
472 case WINPR_CIPHER_CAMELLIA_256_CTR:
473 type = MBEDTLS_CIPHER_CAMELLIA_256_CTR;
474 break;
475
476 case WINPR_CIPHER_CAMELLIA_128_GCM:
477 type = MBEDTLS_CIPHER_CAMELLIA_128_GCM;
478 break;
479
480 case WINPR_CIPHER_CAMELLIA_192_GCM:
481 type = MBEDTLS_CIPHER_CAMELLIA_192_GCM;
482 break;
483
484 case WINPR_CIPHER_CAMELLIA_256_GCM:
485 type = MBEDTLS_CIPHER_CAMELLIA_256_GCM;
486 break;
487
488 case WINPR_CIPHER_DES_ECB:
489 type = MBEDTLS_CIPHER_DES_ECB;
490 break;
491
492 case WINPR_CIPHER_DES_CBC:
493 type = MBEDTLS_CIPHER_DES_CBC;
494 break;
495
496 case WINPR_CIPHER_DES_EDE_ECB:
497 type = MBEDTLS_CIPHER_DES_EDE_ECB;
498 break;
499
500 case WINPR_CIPHER_DES_EDE_CBC:
501 type = MBEDTLS_CIPHER_DES_EDE_CBC;
502 break;
503
504 case WINPR_CIPHER_DES_EDE3_ECB:
505 type = MBEDTLS_CIPHER_DES_EDE3_ECB;
506 break;
507
508 case WINPR_CIPHER_DES_EDE3_CBC:
509 type = MBEDTLS_CIPHER_DES_EDE3_CBC;
510 break;
511
512 case WINPR_CIPHER_BLOWFISH_ECB:
513 type = MBEDTLS_CIPHER_BLOWFISH_ECB;
514 break;
515
516 case WINPR_CIPHER_BLOWFISH_CBC:
517 type = MBEDTLS_CIPHER_BLOWFISH_CBC;
518 break;
519
520 case WINPR_CIPHER_BLOWFISH_CFB64:
521 type = MBEDTLS_CIPHER_BLOWFISH_CFB64;
522 break;
523
524 case WINPR_CIPHER_BLOWFISH_CTR:
525 type = MBEDTLS_CIPHER_BLOWFISH_CTR;
526 break;
527
528 case WINPR_CIPHER_ARC4_128:
529 type = MBEDTLS_CIPHER_ARC4_128;
530 break;
531
532 case WINPR_CIPHER_AES_128_CCM:
533 type = MBEDTLS_CIPHER_AES_128_CCM;
534 break;
535
536 case WINPR_CIPHER_AES_192_CCM:
537 type = MBEDTLS_CIPHER_AES_192_CCM;
538 break;
539
540 case WINPR_CIPHER_AES_256_CCM:
541 type = MBEDTLS_CIPHER_AES_256_CCM;
542 break;
543
544 case WINPR_CIPHER_CAMELLIA_128_CCM:
545 type = MBEDTLS_CIPHER_CAMELLIA_128_CCM;
546 break;
547
548 case WINPR_CIPHER_CAMELLIA_192_CCM:
549 type = MBEDTLS_CIPHER_CAMELLIA_192_CCM;
550 break;
551
552 case WINPR_CIPHER_CAMELLIA_256_CCM:
553 type = MBEDTLS_CIPHER_CAMELLIA_256_CCM;
554 break;
555 }
556
557 return type;
558 }
559 #endif
560
winpr_Cipher_New(int cipher,int op,const BYTE * key,const BYTE * iv)561 WINPR_CIPHER_CTX* winpr_Cipher_New(int cipher, int op, const BYTE* key, const BYTE* iv)
562 {
563 WINPR_CIPHER_CTX* ctx = NULL;
564 #if defined(WITH_OPENSSL)
565 int operation;
566 const EVP_CIPHER* evp;
567 EVP_CIPHER_CTX* octx;
568
569 if (!(evp = winpr_openssl_get_evp_cipher(cipher)))
570 return NULL;
571
572 if (!(octx = EVP_CIPHER_CTX_new()))
573 return NULL;
574
575 operation = (op == WINPR_ENCRYPT) ? 1 : 0;
576
577 if (EVP_CipherInit_ex(octx, evp, NULL, key, iv, operation) != 1)
578 {
579 EVP_CIPHER_CTX_free(octx);
580 return NULL;
581 }
582
583 EVP_CIPHER_CTX_set_padding(octx, 0);
584 ctx = (WINPR_CIPHER_CTX*)octx;
585 #elif defined(WITH_MBEDTLS)
586 int key_bitlen;
587 mbedtls_operation_t operation;
588 mbedtls_cipher_context_t* mctx;
589 mbedtls_cipher_type_t cipher_type = winpr_mbedtls_get_cipher_type(cipher);
590 const mbedtls_cipher_info_t* cipher_info = mbedtls_cipher_info_from_type(cipher_type);
591
592 if (!cipher_info)
593 return NULL;
594
595 if (!(mctx = (mbedtls_cipher_context_t*)calloc(1, sizeof(mbedtls_cipher_context_t))))
596 return NULL;
597
598 operation = (op == WINPR_ENCRYPT) ? MBEDTLS_ENCRYPT : MBEDTLS_DECRYPT;
599 mbedtls_cipher_init(mctx);
600
601 if (mbedtls_cipher_setup(mctx, cipher_info) != 0)
602 {
603 free(mctx);
604 return NULL;
605 }
606
607 key_bitlen = mbedtls_cipher_get_key_bitlen(mctx);
608
609 if (mbedtls_cipher_setkey(mctx, key, key_bitlen, operation) != 0)
610 {
611 mbedtls_cipher_free(mctx);
612 free(mctx);
613 return NULL;
614 }
615
616 if (mbedtls_cipher_set_padding_mode(mctx, MBEDTLS_PADDING_NONE) != 0)
617 {
618 mbedtls_cipher_free(mctx);
619 free(mctx);
620 return NULL;
621 }
622
623 ctx = (WINPR_CIPHER_CTX*)mctx;
624 #endif
625 return ctx;
626 }
627
winpr_Cipher_Update(WINPR_CIPHER_CTX * ctx,const BYTE * input,size_t ilen,BYTE * output,size_t * olen)628 BOOL winpr_Cipher_Update(WINPR_CIPHER_CTX* ctx, const BYTE* input, size_t ilen, BYTE* output,
629 size_t* olen)
630 {
631 #if defined(WITH_OPENSSL)
632 int outl = (int)*olen;
633
634 if (EVP_CipherUpdate((EVP_CIPHER_CTX*)ctx, output, &outl, input, ilen) == 1)
635 {
636 *olen = (size_t)outl;
637 return TRUE;
638 }
639
640 #elif defined(WITH_MBEDTLS)
641
642 if (mbedtls_cipher_update((mbedtls_cipher_context_t*)ctx, input, ilen, output, olen) == 0)
643 return TRUE;
644
645 #endif
646 return FALSE;
647 }
648
winpr_Cipher_Final(WINPR_CIPHER_CTX * ctx,BYTE * output,size_t * olen)649 BOOL winpr_Cipher_Final(WINPR_CIPHER_CTX* ctx, BYTE* output, size_t* olen)
650 {
651 #if defined(WITH_OPENSSL)
652 int outl = (int)*olen;
653
654 if (EVP_CipherFinal_ex((EVP_CIPHER_CTX*)ctx, output, &outl) == 1)
655 {
656 *olen = (size_t)outl;
657 return TRUE;
658 }
659
660 #elif defined(WITH_MBEDTLS)
661
662 if (mbedtls_cipher_finish((mbedtls_cipher_context_t*)ctx, output, olen) == 0)
663 return TRUE;
664
665 #endif
666 return FALSE;
667 }
668
winpr_Cipher_Free(WINPR_CIPHER_CTX * ctx)669 void winpr_Cipher_Free(WINPR_CIPHER_CTX* ctx)
670 {
671 if (!ctx)
672 return;
673
674 #if defined(WITH_OPENSSL)
675 EVP_CIPHER_CTX_free((EVP_CIPHER_CTX*)ctx);
676 #elif defined(WITH_MBEDTLS)
677 mbedtls_cipher_free((mbedtls_cipher_context_t*)ctx);
678 free(ctx);
679 #endif
680 }
681
682 /**
683 * Key Generation
684 */
685
winpr_Cipher_BytesToKey(int cipher,int md,const BYTE * salt,const BYTE * data,int datal,int count,BYTE * key,BYTE * iv)686 int winpr_Cipher_BytesToKey(int cipher, int md, const BYTE* salt, const BYTE* data, int datal,
687 int count, BYTE* key, BYTE* iv)
688 {
689 /**
690 * Key and IV generation compatible with OpenSSL EVP_BytesToKey():
691 * https://www.openssl.org/docs/manmaster/crypto/EVP_BytesToKey.html
692 */
693 #if defined(WITH_OPENSSL)
694 const EVP_MD* evp_md;
695 const EVP_CIPHER* evp_cipher;
696 evp_md = winpr_openssl_get_evp_md((WINPR_MD_TYPE)md);
697 evp_cipher = winpr_openssl_get_evp_cipher(cipher);
698 return EVP_BytesToKey(evp_cipher, evp_md, salt, data, datal, count, key, iv);
699 #elif defined(WITH_MBEDTLS)
700 int rv = 0;
701 BYTE md_buf[64];
702 int niv, nkey, addmd = 0;
703 unsigned int mds = 0, i;
704 mbedtls_md_context_t ctx;
705 const mbedtls_md_info_t* md_info;
706 mbedtls_cipher_type_t cipher_type;
707 const mbedtls_cipher_info_t* cipher_info;
708 mbedtls_md_type_t md_type = winpr_mbedtls_get_md_type(md);
709 md_info = mbedtls_md_info_from_type(md_type);
710 cipher_type = winpr_mbedtls_get_cipher_type(cipher);
711 cipher_info = mbedtls_cipher_info_from_type(cipher_type);
712 nkey = cipher_info->key_bitlen / 8;
713 niv = cipher_info->iv_size;
714
715 if ((nkey > 64) || (niv > 64))
716 return 0;
717
718 if (!data)
719 return nkey;
720
721 mbedtls_md_init(&ctx);
722
723 if (mbedtls_md_setup(&ctx, md_info, 0) != 0)
724 goto err;
725
726 while (1)
727 {
728 if (mbedtls_md_starts(&ctx) != 0)
729 goto err;
730
731 if (addmd++)
732 {
733 if (mbedtls_md_update(&ctx, md_buf, mds) != 0)
734 goto err;
735 }
736
737 if (mbedtls_md_update(&ctx, data, datal) != 0)
738 goto err;
739
740 if (salt)
741 {
742 if (mbedtls_md_update(&ctx, salt, 8) != 0)
743 goto err;
744 }
745
746 if (mbedtls_md_finish(&ctx, md_buf) != 0)
747 goto err;
748
749 mds = mbedtls_md_get_size(md_info);
750
751 for (i = 1; i < (unsigned int)count; i++)
752 {
753 if (mbedtls_md_starts(&ctx) != 0)
754 goto err;
755
756 if (mbedtls_md_update(&ctx, md_buf, mds) != 0)
757 goto err;
758
759 if (mbedtls_md_finish(&ctx, md_buf) != 0)
760 goto err;
761 }
762
763 i = 0;
764
765 if (nkey)
766 {
767 while (1)
768 {
769 if (nkey == 0)
770 break;
771
772 if (i == mds)
773 break;
774
775 if (key)
776 *(key++) = md_buf[i];
777
778 nkey--;
779 i++;
780 }
781 }
782
783 if (niv && (i != mds))
784 {
785 while (1)
786 {
787 if (niv == 0)
788 break;
789
790 if (i == mds)
791 break;
792
793 if (iv)
794 *(iv++) = md_buf[i];
795
796 niv--;
797 i++;
798 }
799 }
800
801 if ((nkey == 0) && (niv == 0))
802 break;
803 }
804
805 rv = cipher_info->key_bitlen / 8;
806 err:
807 mbedtls_md_free(&ctx);
808 SecureZeroMemory(md_buf, 64);
809 return rv;
810 #endif
811 return 0;
812 }
813