source: EcnlProtoTool/trunk/openssl-1.1.0e/crypto/srp/srp_vfy.c@ 331

Last change on this file since 331 was 331, checked in by coas-nagasima, 6 years ago

prototoolに関連するプロジェクトをnewlibからmuslを使うよう変更・更新
ntshellをnewlibの下位の実装から、muslのsyscallの実装に変更・更新
以下のOSSをアップデート
・mruby-1.3.0
・musl-1.1.18
・onigmo-6.1.3
・tcc-0.9.27
以下のOSSを追加
・openssl-1.1.0e
・curl-7.57.0
・zlib-1.2.11
以下のmrbgemsを追加
・iij/mruby-digest
・iij/mruby-env
・iij/mruby-errno
・iij/mruby-iijson
・iij/mruby-ipaddr
・iij/mruby-mock
・iij/mruby-require
・iij/mruby-tls-openssl
  • Property svn:eol-style set to native
  • Property svn:mime-type set to text/x-csrc
File size: 17.0 KB
Line 
1/*
2 * Copyright 2011-2016 The OpenSSL Project Authors. All Rights Reserved.
3 *
4 * Licensed under the OpenSSL license (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
8 */
9
10#ifndef OPENSSL_NO_SRP
11# include "internal/cryptlib.h"
12# include <openssl/sha.h>
13# include <openssl/srp.h>
14# include <openssl/evp.h>
15# include <openssl/buffer.h>
16# include <openssl/rand.h>
17# include <openssl/txt_db.h>
18
19# define SRP_RANDOM_SALT_LEN 20
20# define MAX_LEN 2500
21
22static char b64table[] =
23 "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz./";
24
25/*
26 * the following two conversion routines have been inspired by code from
27 * Stanford
28 */
29
30/*
31 * Convert a base64 string into raw byte array representation.
32 */
33static int t_fromb64(unsigned char *a, size_t alen, const char *src)
34{
35 char *loc;
36 int i, j;
37 int size;
38
39 while (*src && (*src == ' ' || *src == '\t' || *src == '\n'))
40 ++src;
41 size = strlen(src);
42 if (alen > INT_MAX || size > (int)alen)
43 return -1;
44
45 i = 0;
46 while (i < size) {
47 loc = strchr(b64table, src[i]);
48 if (loc == (char *)0)
49 break;
50 else
51 a[i] = loc - b64table;
52 ++i;
53 }
54 /* if nothing valid to process we have a zero length response */
55 if (i == 0)
56 return 0;
57 size = i;
58 i = size - 1;
59 j = size;
60 while (1) {
61 a[j] = a[i];
62 if (--i < 0)
63 break;
64 a[j] |= (a[i] & 3) << 6;
65 --j;
66 a[j] = (unsigned char)((a[i] & 0x3c) >> 2);
67 if (--i < 0)
68 break;
69 a[j] |= (a[i] & 0xf) << 4;
70 --j;
71 a[j] = (unsigned char)((a[i] & 0x30) >> 4);
72 if (--i < 0)
73 break;
74 a[j] |= (a[i] << 2);
75
76 a[--j] = 0;
77 if (--i < 0)
78 break;
79 }
80 while (a[j] == 0 && j <= size)
81 ++j;
82 i = 0;
83 while (j <= size)
84 a[i++] = a[j++];
85 return i;
86}
87
88/*
89 * Convert a raw byte string into a null-terminated base64 ASCII string.
90 */
91static char *t_tob64(char *dst, const unsigned char *src, int size)
92{
93 int c, pos = size % 3;
94 unsigned char b0 = 0, b1 = 0, b2 = 0, notleading = 0;
95 char *olddst = dst;
96
97 switch (pos) {
98 case 1:
99 b2 = src[0];
100 break;
101 case 2:
102 b1 = src[0];
103 b2 = src[1];
104 break;
105 }
106
107 while (1) {
108 c = (b0 & 0xfc) >> 2;
109 if (notleading || c != 0) {
110 *dst++ = b64table[c];
111 notleading = 1;
112 }
113 c = ((b0 & 3) << 4) | ((b1 & 0xf0) >> 4);
114 if (notleading || c != 0) {
115 *dst++ = b64table[c];
116 notleading = 1;
117 }
118 c = ((b1 & 0xf) << 2) | ((b2 & 0xc0) >> 6);
119 if (notleading || c != 0) {
120 *dst++ = b64table[c];
121 notleading = 1;
122 }
123 c = b2 & 0x3f;
124 if (notleading || c != 0) {
125 *dst++ = b64table[c];
126 notleading = 1;
127 }
128 if (pos >= size)
129 break;
130 else {
131 b0 = src[pos++];
132 b1 = src[pos++];
133 b2 = src[pos++];
134 }
135 }
136
137 *dst++ = '\0';
138 return olddst;
139}
140
141void SRP_user_pwd_free(SRP_user_pwd *user_pwd)
142{
143 if (user_pwd == NULL)
144 return;
145 BN_free(user_pwd->s);
146 BN_clear_free(user_pwd->v);
147 OPENSSL_free(user_pwd->id);
148 OPENSSL_free(user_pwd->info);
149 OPENSSL_free(user_pwd);
150}
151
152static SRP_user_pwd *SRP_user_pwd_new(void)
153{
154 SRP_user_pwd *ret = OPENSSL_malloc(sizeof(*ret));
155 if (ret == NULL)
156 return NULL;
157 ret->N = NULL;
158 ret->g = NULL;
159 ret->s = NULL;
160 ret->v = NULL;
161 ret->id = NULL;
162 ret->info = NULL;
163 return ret;
164}
165
166static void SRP_user_pwd_set_gN(SRP_user_pwd *vinfo, const BIGNUM *g,
167 const BIGNUM *N)
168{
169 vinfo->N = N;
170 vinfo->g = g;
171}
172
173static int SRP_user_pwd_set_ids(SRP_user_pwd *vinfo, const char *id,
174 const char *info)
175{
176 if (id != NULL && NULL == (vinfo->id = OPENSSL_strdup(id)))
177 return 0;
178 return (info == NULL || NULL != (vinfo->info = OPENSSL_strdup(info)));
179}
180
181static int SRP_user_pwd_set_sv(SRP_user_pwd *vinfo, const char *s,
182 const char *v)
183{
184 unsigned char tmp[MAX_LEN];
185 int len;
186
187 vinfo->v = NULL;
188 vinfo->s = NULL;
189
190 len = t_fromb64(tmp, sizeof(tmp), v);
191 if (len < 0)
192 return 0;
193 if (NULL == (vinfo->v = BN_bin2bn(tmp, len, NULL)))
194 return 0;
195 len = t_fromb64(tmp, sizeof(tmp), s);
196 if (len < 0)
197 goto err;
198 vinfo->s = BN_bin2bn(tmp, len, NULL);
199 if (vinfo->s == NULL)
200 goto err;
201 return 1;
202 err:
203 BN_free(vinfo->v);
204 vinfo->v = NULL;
205 return 0;
206}
207
208static int SRP_user_pwd_set_sv_BN(SRP_user_pwd *vinfo, BIGNUM *s, BIGNUM *v)
209{
210 vinfo->v = v;
211 vinfo->s = s;
212 return (vinfo->s != NULL && vinfo->v != NULL);
213}
214
215static SRP_user_pwd *srp_user_pwd_dup(SRP_user_pwd *src)
216{
217 SRP_user_pwd *ret;
218
219 if (src == NULL)
220 return NULL;
221 if ((ret = SRP_user_pwd_new()) == NULL)
222 return NULL;
223
224 SRP_user_pwd_set_gN(ret, src->g, src->N);
225 if (!SRP_user_pwd_set_ids(ret, src->id, src->info)
226 || !SRP_user_pwd_set_sv_BN(ret, BN_dup(src->s), BN_dup(src->v))) {
227 SRP_user_pwd_free(ret);
228 return NULL;
229 }
230 return ret;
231}
232
233SRP_VBASE *SRP_VBASE_new(char *seed_key)
234{
235 SRP_VBASE *vb = OPENSSL_malloc(sizeof(*vb));
236
237 if (vb == NULL)
238 return NULL;
239 if ((vb->users_pwd = sk_SRP_user_pwd_new_null()) == NULL
240 || (vb->gN_cache = sk_SRP_gN_cache_new_null()) == NULL) {
241 OPENSSL_free(vb);
242 return NULL;
243 }
244 vb->default_g = NULL;
245 vb->default_N = NULL;
246 vb->seed_key = NULL;
247 if ((seed_key != NULL) && (vb->seed_key = OPENSSL_strdup(seed_key)) == NULL) {
248 sk_SRP_user_pwd_free(vb->users_pwd);
249 sk_SRP_gN_cache_free(vb->gN_cache);
250 OPENSSL_free(vb);
251 return NULL;
252 }
253 return vb;
254}
255
256void SRP_VBASE_free(SRP_VBASE *vb)
257{
258 if (!vb)
259 return;
260 sk_SRP_user_pwd_pop_free(vb->users_pwd, SRP_user_pwd_free);
261 sk_SRP_gN_cache_free(vb->gN_cache);
262 OPENSSL_free(vb->seed_key);
263 OPENSSL_free(vb);
264}
265
266static SRP_gN_cache *SRP_gN_new_init(const char *ch)
267{
268 unsigned char tmp[MAX_LEN];
269 int len;
270 SRP_gN_cache *newgN = OPENSSL_malloc(sizeof(*newgN));
271
272 if (newgN == NULL)
273 return NULL;
274
275 len = t_fromb64(tmp, sizeof(tmp), ch);
276 if (len < 0)
277 goto err;
278
279 if ((newgN->b64_bn = OPENSSL_strdup(ch)) == NULL)
280 goto err;
281
282 if ((newgN->bn = BN_bin2bn(tmp, len, NULL)))
283 return newgN;
284
285 OPENSSL_free(newgN->b64_bn);
286 err:
287 OPENSSL_free(newgN);
288 return NULL;
289}
290
291static void SRP_gN_free(SRP_gN_cache *gN_cache)
292{
293 if (gN_cache == NULL)
294 return;
295 OPENSSL_free(gN_cache->b64_bn);
296 BN_free(gN_cache->bn);
297 OPENSSL_free(gN_cache);
298}
299
300static SRP_gN *SRP_get_gN_by_id(const char *id, STACK_OF(SRP_gN) *gN_tab)
301{
302 int i;
303
304 SRP_gN *gN;
305 if (gN_tab != NULL)
306 for (i = 0; i < sk_SRP_gN_num(gN_tab); i++) {
307 gN = sk_SRP_gN_value(gN_tab, i);
308 if (gN && (id == NULL || strcmp(gN->id, id) == 0))
309 return gN;
310 }
311
312 return SRP_get_default_gN(id);
313}
314
315static BIGNUM *SRP_gN_place_bn(STACK_OF(SRP_gN_cache) *gN_cache, char *ch)
316{
317 int i;
318 if (gN_cache == NULL)
319 return NULL;
320
321 /* search if we have already one... */
322 for (i = 0; i < sk_SRP_gN_cache_num(gN_cache); i++) {
323 SRP_gN_cache *cache = sk_SRP_gN_cache_value(gN_cache, i);
324 if (strcmp(cache->b64_bn, ch) == 0)
325 return cache->bn;
326 }
327 { /* it is the first time that we find it */
328 SRP_gN_cache *newgN = SRP_gN_new_init(ch);
329 if (newgN) {
330 if (sk_SRP_gN_cache_insert(gN_cache, newgN, 0) > 0)
331 return newgN->bn;
332 SRP_gN_free(newgN);
333 }
334 }
335 return NULL;
336}
337
338/*
339 * this function parses verifier file. Format is:
340 * string(index):base64(N):base64(g):0
341 * string(username):base64(v):base64(salt):int(index)
342 */
343
344int SRP_VBASE_init(SRP_VBASE *vb, char *verifier_file)
345{
346 int error_code;
347 STACK_OF(SRP_gN) *SRP_gN_tab = sk_SRP_gN_new_null();
348 char *last_index = NULL;
349 int i;
350 char **pp;
351
352 SRP_gN *gN = NULL;
353 SRP_user_pwd *user_pwd = NULL;
354
355 TXT_DB *tmpdb = NULL;
356 BIO *in = BIO_new(BIO_s_file());
357
358 error_code = SRP_ERR_OPEN_FILE;
359
360 if (in == NULL || BIO_read_filename(in, verifier_file) <= 0)
361 goto err;
362
363 error_code = SRP_ERR_VBASE_INCOMPLETE_FILE;
364
365 if ((tmpdb = TXT_DB_read(in, DB_NUMBER)) == NULL)
366 goto err;
367
368 error_code = SRP_ERR_MEMORY;
369
370 if (vb->seed_key) {
371 last_index = SRP_get_default_gN(NULL)->id;
372 }
373 for (i = 0; i < sk_OPENSSL_PSTRING_num(tmpdb->data); i++) {
374 pp = sk_OPENSSL_PSTRING_value(tmpdb->data, i);
375 if (pp[DB_srptype][0] == DB_SRP_INDEX) {
376 /*
377 * we add this couple in the internal Stack
378 */
379
380 if ((gN = OPENSSL_malloc(sizeof(*gN))) == NULL)
381 goto err;
382
383 if ((gN->id = OPENSSL_strdup(pp[DB_srpid])) == NULL
384 || (gN->N = SRP_gN_place_bn(vb->gN_cache, pp[DB_srpverifier]))
385 == NULL
386 || (gN->g = SRP_gN_place_bn(vb->gN_cache, pp[DB_srpsalt]))
387 == NULL
388 || sk_SRP_gN_insert(SRP_gN_tab, gN, 0) == 0)
389 goto err;
390
391 gN = NULL;
392
393 if (vb->seed_key != NULL) {
394 last_index = pp[DB_srpid];
395 }
396 } else if (pp[DB_srptype][0] == DB_SRP_VALID) {
397 /* it is a user .... */
398 const SRP_gN *lgN;
399
400 if ((lgN = SRP_get_gN_by_id(pp[DB_srpgN], SRP_gN_tab)) != NULL) {
401 error_code = SRP_ERR_MEMORY;
402 if ((user_pwd = SRP_user_pwd_new()) == NULL)
403 goto err;
404
405 SRP_user_pwd_set_gN(user_pwd, lgN->g, lgN->N);
406 if (!SRP_user_pwd_set_ids
407 (user_pwd, pp[DB_srpid], pp[DB_srpinfo]))
408 goto err;
409
410 error_code = SRP_ERR_VBASE_BN_LIB;
411 if (!SRP_user_pwd_set_sv
412 (user_pwd, pp[DB_srpsalt], pp[DB_srpverifier]))
413 goto err;
414
415 if (sk_SRP_user_pwd_insert(vb->users_pwd, user_pwd, 0) == 0)
416 goto err;
417 user_pwd = NULL; /* abandon responsibility */
418 }
419 }
420 }
421
422 if (last_index != NULL) {
423 /* this means that we want to simulate a default user */
424
425 if (((gN = SRP_get_gN_by_id(last_index, SRP_gN_tab)) == NULL)) {
426 error_code = SRP_ERR_VBASE_BN_LIB;
427 goto err;
428 }
429 vb->default_g = gN->g;
430 vb->default_N = gN->N;
431 gN = NULL;
432 }
433 error_code = SRP_NO_ERROR;
434
435 err:
436 /*
437 * there may be still some leaks to fix, if this fails, the application
438 * terminates most likely
439 */
440
441 if (gN != NULL) {
442 OPENSSL_free(gN->id);
443 OPENSSL_free(gN);
444 }
445
446 SRP_user_pwd_free(user_pwd);
447
448 TXT_DB_free(tmpdb);
449 BIO_free_all(in);
450
451 sk_SRP_gN_free(SRP_gN_tab);
452
453 return error_code;
454
455}
456
457static SRP_user_pwd *find_user(SRP_VBASE *vb, char *username)
458{
459 int i;
460 SRP_user_pwd *user;
461
462 if (vb == NULL)
463 return NULL;
464
465 for (i = 0; i < sk_SRP_user_pwd_num(vb->users_pwd); i++) {
466 user = sk_SRP_user_pwd_value(vb->users_pwd, i);
467 if (strcmp(user->id, username) == 0)
468 return user;
469 }
470
471 return NULL;
472}
473
474 #if OPENSSL_API_COMPAT < 0x10100000L
475/*
476 * DEPRECATED: use SRP_VBASE_get1_by_user instead.
477 * This method ignores the configured seed and fails for an unknown user.
478 * Ownership of the returned pointer is not released to the caller.
479 * In other words, caller must not free the result.
480 */
481SRP_user_pwd *SRP_VBASE_get_by_user(SRP_VBASE *vb, char *username)
482{
483 return find_user(vb, username);
484}
485#endif
486
487/*
488 * Ownership of the returned pointer is released to the caller.
489 * In other words, caller must free the result once done.
490 */
491SRP_user_pwd *SRP_VBASE_get1_by_user(SRP_VBASE *vb, char *username)
492{
493 SRP_user_pwd *user;
494 unsigned char digv[SHA_DIGEST_LENGTH];
495 unsigned char digs[SHA_DIGEST_LENGTH];
496 EVP_MD_CTX *ctxt = NULL;
497
498 if (vb == NULL)
499 return NULL;
500
501 if ((user = find_user(vb, username)) != NULL)
502 return srp_user_pwd_dup(user);
503
504 if ((vb->seed_key == NULL) ||
505 (vb->default_g == NULL) || (vb->default_N == NULL))
506 return NULL;
507
508/* if the user is unknown we set parameters as well if we have a seed_key */
509
510 if ((user = SRP_user_pwd_new()) == NULL)
511 return NULL;
512
513 SRP_user_pwd_set_gN(user, vb->default_g, vb->default_N);
514
515 if (!SRP_user_pwd_set_ids(user, username, NULL))
516 goto err;
517
518 if (RAND_bytes(digv, SHA_DIGEST_LENGTH) <= 0)
519 goto err;
520 ctxt = EVP_MD_CTX_new();
521 if (ctxt == NULL
522 || !EVP_DigestInit_ex(ctxt, EVP_sha1(), NULL)
523 || !EVP_DigestUpdate(ctxt, vb->seed_key, strlen(vb->seed_key))
524 || !EVP_DigestUpdate(ctxt, username, strlen(username))
525 || !EVP_DigestFinal_ex(ctxt, digs, NULL))
526 goto err;
527 EVP_MD_CTX_free(ctxt);
528 ctxt = NULL;
529 if (SRP_user_pwd_set_sv_BN(user,
530 BN_bin2bn(digs, SHA_DIGEST_LENGTH, NULL),
531 BN_bin2bn(digv, SHA_DIGEST_LENGTH, NULL)))
532 return user;
533
534 err:
535 EVP_MD_CTX_free(ctxt);
536 SRP_user_pwd_free(user);
537 return NULL;
538}
539
540/*
541 * create a verifier (*salt,*verifier,g and N are in base64)
542 */
543char *SRP_create_verifier(const char *user, const char *pass, char **salt,
544 char **verifier, const char *N, const char *g)
545{
546 int len;
547 char *result = NULL, *vf = NULL;
548 const BIGNUM *N_bn = NULL, *g_bn = NULL;
549 BIGNUM *N_bn_alloc = NULL, *g_bn_alloc = NULL, *s = NULL, *v = NULL;
550 unsigned char tmp[MAX_LEN];
551 unsigned char tmp2[MAX_LEN];
552 char *defgNid = NULL;
553 int vfsize = 0;
554
555 if ((user == NULL) ||
556 (pass == NULL) || (salt == NULL) || (verifier == NULL))
557 goto err;
558
559 if (N) {
560 if ((len = t_fromb64(tmp, sizeof(tmp), N)) <= 0)
561 goto err;
562 N_bn_alloc = BN_bin2bn(tmp, len, NULL);
563 N_bn = N_bn_alloc;
564 if ((len = t_fromb64(tmp, sizeof(tmp) ,g)) <= 0)
565 goto err;
566 g_bn_alloc = BN_bin2bn(tmp, len, NULL);
567 g_bn = g_bn_alloc;
568 defgNid = "*";
569 } else {
570 SRP_gN *gN = SRP_get_gN_by_id(g, NULL);
571 if (gN == NULL)
572 goto err;
573 N_bn = gN->N;
574 g_bn = gN->g;
575 defgNid = gN->id;
576 }
577
578 if (*salt == NULL) {
579 if (RAND_bytes(tmp2, SRP_RANDOM_SALT_LEN) <= 0)
580 goto err;
581
582 s = BN_bin2bn(tmp2, SRP_RANDOM_SALT_LEN, NULL);
583 } else {
584 if ((len = t_fromb64(tmp2, sizeof(tmp2), *salt)) <= 0)
585 goto err;
586 s = BN_bin2bn(tmp2, len, NULL);
587 }
588
589 if (!SRP_create_verifier_BN(user, pass, &s, &v, N_bn, g_bn))
590 goto err;
591
592 BN_bn2bin(v, tmp);
593 vfsize = BN_num_bytes(v) * 2;
594 if (((vf = OPENSSL_malloc(vfsize)) == NULL))
595 goto err;
596 t_tob64(vf, tmp, BN_num_bytes(v));
597
598 if (*salt == NULL) {
599 char *tmp_salt;
600
601 if ((tmp_salt = OPENSSL_malloc(SRP_RANDOM_SALT_LEN * 2)) == NULL) {
602 goto err;
603 }
604 t_tob64(tmp_salt, tmp2, SRP_RANDOM_SALT_LEN);
605 *salt = tmp_salt;
606 }
607
608 *verifier = vf;
609 vf = NULL;
610 result = defgNid;
611
612 err:
613 BN_free(N_bn_alloc);
614 BN_free(g_bn_alloc);
615 OPENSSL_clear_free(vf, vfsize);
616 BN_clear_free(s);
617 BN_clear_free(v);
618 return result;
619}
620
621/*
622 * create a verifier (*salt,*verifier,g and N are BIGNUMs). If *salt != NULL
623 * then the provided salt will be used. On successful exit *verifier will point
624 * to a newly allocated BIGNUM containing the verifier and (if a salt was not
625 * provided) *salt will be populated with a newly allocated BIGNUM containing a
626 * random salt.
627 * The caller is responsible for freeing the allocated *salt and *verifier
628 * BIGNUMS.
629 */
630int SRP_create_verifier_BN(const char *user, const char *pass, BIGNUM **salt,
631 BIGNUM **verifier, const BIGNUM *N,
632 const BIGNUM *g)
633{
634 int result = 0;
635 BIGNUM *x = NULL;
636 BN_CTX *bn_ctx = BN_CTX_new();
637 unsigned char tmp2[MAX_LEN];
638 BIGNUM *salttmp = NULL;
639
640 if ((user == NULL) ||
641 (pass == NULL) ||
642 (salt == NULL) ||
643 (verifier == NULL) || (N == NULL) || (g == NULL) || (bn_ctx == NULL))
644 goto err;
645
646 if (*salt == NULL) {
647 if (RAND_bytes(tmp2, SRP_RANDOM_SALT_LEN) <= 0)
648 goto err;
649
650 salttmp = BN_bin2bn(tmp2, SRP_RANDOM_SALT_LEN, NULL);
651 } else {
652 salttmp = *salt;
653 }
654
655 x = SRP_Calc_x(salttmp, user, pass);
656
657 *verifier = BN_new();
658 if (*verifier == NULL)
659 goto err;
660
661 if (!BN_mod_exp(*verifier, g, x, N, bn_ctx)) {
662 BN_clear_free(*verifier);
663 goto err;
664 }
665
666 result = 1;
667 *salt = salttmp;
668
669 err:
670 if (salt != NULL && *salt != salttmp)
671 BN_clear_free(salttmp);
672 BN_clear_free(x);
673 BN_CTX_free(bn_ctx);
674 return result;
675}
676
677#endif
Note: See TracBrowser for help on using the repository browser.