crypto/srp/srp_vfy.c

   1 /* crypto/srp/srp_vfy.c */
   2 /*
   3  * Written by Christophe Renou (christophe.renou@edelweb.fr) with the
   4  * precious help of Peter Sylvester (peter.sylvester@edelweb.fr) for the
   5  * EdelKey project and contributed to the OpenSSL project 2004.
   6  */
   7 /* ====================================================================
   8  * Copyright (c) 2004 The OpenSSL Project.  All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  *
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  *
  17  * 2. Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in
  19  *    the documentation and/or other materials provided with the
  20  *    distribution.
  21  *
  22  * 3. All advertising materials mentioning features or use of this
  23  *    software must display the following acknowledgment:
  24  *    "This product includes software developed by the OpenSSL Project
  25  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  26  *
  27  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  28  *    endorse or promote products derived from this software without
  29  *    prior written permission. For written permission, please contact
  30  *    licensing@OpenSSL.org.
  31  *
  32  * 5. Products derived from this software may not be called "OpenSSL"
  33  *    nor may "OpenSSL" appear in their names without prior written
  34  *    permission of the OpenSSL Project.
  35  *
  36  * 6. Redistributions of any form whatsoever must retain the following
  37  *    acknowledgment:
  38  *    "This product includes software developed by the OpenSSL Project
  39  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  40  *
  41  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  42  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  44  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  45  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  46  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  47  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  48  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  49  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  50  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  51  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  52  * OF THE POSSIBILITY OF SUCH DAMAGE.
  53  * ====================================================================
  54  *
  55  * This product includes cryptographic software written by Eric Young
  56  * (eay@cryptsoft.com).  This product includes software written by Tim
  57  * Hudson (tjh@cryptsoft.com).
  58  *
  59  */
  60 #ifndef OPENSSL_NO_SRP
  61 # include "cryptlib.h"
  62 # include "srp_lcl.h"
  63 # include <openssl/srp.h>
  64 # include <openssl/evp.h>
  65 # include <openssl/buffer.h>
  66 # include <openssl/rand.h>
  67 # include <openssl/txt_db.h>
  68
  69 # define SRP_RANDOM_SALT_LEN 20
  70 # define MAX_LEN 2500
  71
  72 static char b64table[] =
  73     "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz./";
  74
  75 /*
  76  * the following two conversion routines have been inspired by code from
  77  * Stanford
  78  */
  79
  80 /*
  81  * Convert a base64 string into raw byte array representation.
  82  */
  83 static int t_fromb64(unsigned char *a, size_t alen, const char *src)
  84 {
  85     char *loc;
  86     int i, j;
  87     int size;
  88
  89     if (alen == 0 || alen > INT_MAX)
  90         return -1;
  91
  92     while (*src && (*src == ' ' || *src == '\t' || *src == '\n'))
  93         ++src;
  94     size = strlen(src);
  95     if (size < 0 || size >= (int)alen)
  96         return -1;
  97
  98     i = 0;
  99     while (i < size) {
 100         loc = strchr(b64table, src[i]);
 101         if (loc == (char *)0)
 102             break;
 103         else
 104             a[i] = loc - b64table;
 105         ++i;
 106     }
 107     /* if nothing valid to process we have a zero length response */
 108     if (i == 0)
 109         return 0;
 110     size = i;
 111     i = size - 1;
 112     j = size;
 113     while (1) {
 114         a[j] = a[i];
 115         if (--i < 0)
 116             break;
 117         a[j] |= (a[i] & 3) << 6;
 118         --j;
 119         a[j] = (unsigned char)((a[i] & 0x3c) >> 2);
 120         if (--i < 0)
 121             break;
 122         a[j] |= (a[i] & 0xf) << 4;
 123         --j;
 124         a[j] = (unsigned char)((a[i] & 0x30) >> 4);
 125         if (--i < 0)
 126             break;
 127         a[j] |= (a[i] << 2);
 128
 129         a[--j] = 0;
 130         if (--i < 0)
 131             break;
 132     }
 133     while (j <= size && a[j] == 0)
 134         ++j;
 135     i = 0;
 136     while (j <= size)
 137         a[i++] = a[j++];
 138     return i;
 139 }
 140
 141 /*
 142  * Convert a raw byte string into a null-terminated base64 ASCII string.
 143  */
 144 static char *t_tob64(char *dst, const unsigned char *src, int size)
 145 {
 146     int c, pos = size % 3;
 147     unsigned char b0 = 0, b1 = 0, b2 = 0, notleading = 0;
 148     char *olddst = dst;
 149
 150     switch (pos) {
 151     case 1:
 152         b2 = src[0];
 153         break;
 154     case 2:
 155         b1 = src[0];
 156         b2 = src[1];
 157         break;
 158     }
 159
 160     while (1) {
 161         c = (b0 & 0xfc) >> 2;
 162         if (notleading || c != 0) {
 163             *dst++ = b64table[c];
 164             notleading = 1;
 165         }
 166         c = ((b0 & 3) << 4) | ((b1 & 0xf0) >> 4);
 167         if (notleading || c != 0) {
 168             *dst++ = b64table[c];
 169             notleading = 1;
 170         }
 171         c = ((b1 & 0xf) << 2) | ((b2 & 0xc0) >> 6);
 172         if (notleading || c != 0) {
 173             *dst++ = b64table[c];
 174             notleading = 1;
 175         }
 176         c = b2 & 0x3f;
 177         if (notleading || c != 0) {
 178             *dst++ = b64table[c];
 179             notleading = 1;
 180         }
 181         if (pos >= size)
 182             break;
 183         else {
 184             b0 = src[pos++];
 185             b1 = src[pos++];
 186             b2 = src[pos++];
 187         }
 188     }
 189
 190     *dst++ = '\0';
 191     return olddst;
 192 }
 193
 194 void SRP_user_pwd_free(SRP_user_pwd *user_pwd)
 195 {
 196     if (user_pwd == NULL)
 197         return;
 198     BN_free(user_pwd->s);
 199     BN_clear_free(user_pwd->v);
 200     OPENSSL_free(user_pwd->id);
 201     OPENSSL_free(user_pwd->info);
 202     OPENSSL_free(user_pwd);
 203 }
 204
 205 static SRP_user_pwd *SRP_user_pwd_new()
 206 {
 207     SRP_user_pwd *ret = OPENSSL_malloc(sizeof(SRP_user_pwd));
 208     if (ret == NULL)
 209         return NULL;
 210     ret->N = NULL;
 211     ret->g = NULL;
 212     ret->s = NULL;
 213     ret->v = NULL;
 214     ret->id = NULL;
 215     ret->info = NULL;
 216     return ret;
 217 }
 218
 219 static void SRP_user_pwd_set_gN(SRP_user_pwd *vinfo, const BIGNUM *g,
 220                                 const BIGNUM *N)
 221 {
 222     vinfo->N = N;
 223     vinfo->g = g;
 224 }
 225
 226 static int SRP_user_pwd_set_ids(SRP_user_pwd *vinfo, const char *id,
 227                                 const char *info)
 228 {
 229     if (id != NULL && NULL == (vinfo->id = BUF_strdup(id)))
 230         return 0;
 231     return (info == NULL || NULL != (vinfo->info = BUF_strdup(info)));
 232 }
 233
 234 static int SRP_user_pwd_set_sv(SRP_user_pwd *vinfo, const char *s,
 235                                const char *v)
 236 {
 237     unsigned char tmp[MAX_LEN];
 238     int len;
 239
 240     vinfo->v = NULL;
 241     vinfo->s = NULL;
 242
 243     len = t_fromb64(tmp, sizeof(tmp), v);
 244     if (len < 0)
 245         return 0;
 246     if (NULL == (vinfo->v = BN_bin2bn(tmp, len, NULL)))
 247         return 0;
 248     len = t_fromb64(tmp, sizeof(tmp), s);
 249     if (len < 0)
 250         goto err;
 251     vinfo->s = BN_bin2bn(tmp, len, NULL);
 252     if (vinfo->s == NULL)
 253         goto err;
 254     return 1;
 255  err:
 256     BN_free(vinfo->v);
 257     vinfo->v = NULL;
 258     return 0;
 259 }
 260
 261 static int SRP_user_pwd_set_sv_BN(SRP_user_pwd *vinfo, BIGNUM *s, BIGNUM *v)
 262 {
 263     vinfo->v = v;
 264     vinfo->s = s;
 265     return (vinfo->s != NULL && vinfo->v != NULL);
 266 }
 267
 268 static SRP_user_pwd *srp_user_pwd_dup(SRP_user_pwd *src)
 269 {
 270     SRP_user_pwd *ret;
 271
 272     if (src == NULL)
 273         return NULL;
 274     if ((ret = SRP_user_pwd_new()) == NULL)
 275         return NULL;
 276
 277     SRP_user_pwd_set_gN(ret, src->g, src->N);
 278     if (!SRP_user_pwd_set_ids(ret, src->id, src->info)
 279         || !SRP_user_pwd_set_sv_BN(ret, BN_dup(src->s), BN_dup(src->v))) {
 280             SRP_user_pwd_free(ret);
 281             return NULL;
 282     }
 283     return ret;
 284 }
 285
 286 SRP_VBASE *SRP_VBASE_new(char *seed_key)
 287 {
 288     SRP_VBASE *vb = (SRP_VBASE *)OPENSSL_malloc(sizeof(SRP_VBASE));
 289
 290     if (vb == NULL)
 291         return NULL;
 292     if (!(vb->users_pwd = sk_SRP_user_pwd_new_null()) ||
 293         !(vb->gN_cache = sk_SRP_gN_cache_new_null())) {
 294         OPENSSL_free(vb);
 295         return NULL;
 296     }
 297     vb->default_g = NULL;
 298     vb->default_N = NULL;
 299     vb->seed_key = NULL;
 300     if ((seed_key != NULL) && (vb->seed_key = BUF_strdup(seed_key)) == NULL) {
 301         sk_SRP_user_pwd_free(vb->users_pwd);
 302         sk_SRP_gN_cache_free(vb->gN_cache);
 303         OPENSSL_free(vb);
 304         return NULL;
 305     }
 306     return vb;
 307 }
 308
 309 int SRP_VBASE_free(SRP_VBASE *vb)
 310 {
 311     sk_SRP_user_pwd_pop_free(vb->users_pwd, SRP_user_pwd_free);
 312     sk_SRP_gN_cache_free(vb->gN_cache);
 313     OPENSSL_free(vb->seed_key);
 314     OPENSSL_free(vb);
 315     return 0;
 316 }
 317
 318 static SRP_gN_cache *SRP_gN_new_init(const char *ch)
 319 {
 320     unsigned char tmp[MAX_LEN];
 321     int len;
 322
 323     SRP_gN_cache *newgN =
 324         (SRP_gN_cache *)OPENSSL_malloc(sizeof(SRP_gN_cache));
 325     if (newgN == NULL)
 326         return NULL;
 327
 328     len = t_fromb64(tmp, sizeof(tmp), ch);
 329     if (len < 0)
 330         goto err;
 331
 332     if ((newgN->b64_bn = BUF_strdup(ch)) == NULL)
 333         goto err;
 334
 335     if ((newgN->bn = BN_bin2bn(tmp, len, NULL)))
 336         return newgN;
 337
 338     OPENSSL_free(newgN->b64_bn);
 339  err:
 340     OPENSSL_free(newgN);
 341     return NULL;
 342 }
 343
 344 static void SRP_gN_free(SRP_gN_cache *gN_cache)
 345 {
 346     if (gN_cache == NULL)
 347         return;
 348     OPENSSL_free(gN_cache->b64_bn);
 349     BN_free(gN_cache->bn);
 350     OPENSSL_free(gN_cache);
 351 }
 352
 353 static SRP_gN *SRP_get_gN_by_id(const char *id, STACK_OF(SRP_gN) *gN_tab)
 354 {
 355     int i;
 356
 357     SRP_gN *gN;
 358     if (gN_tab != NULL)
 359         for (i = 0; i < sk_SRP_gN_num(gN_tab); i++) {
 360             gN = sk_SRP_gN_value(gN_tab, i);
 361             if (gN && (id == NULL || strcmp(gN->id, id) == 0))
 362                 return gN;
 363         }
 364
 365     return SRP_get_default_gN(id);
 366 }
 367
 368 static BIGNUM *SRP_gN_place_bn(STACK_OF(SRP_gN_cache) *gN_cache, char *ch)
 369 {
 370     int i;
 371     if (gN_cache == NULL)
 372         return NULL;
 373
 374     /* search if we have already one... */
 375     for (i = 0; i < sk_SRP_gN_cache_num(gN_cache); i++) {
 376         SRP_gN_cache *cache = sk_SRP_gN_cache_value(gN_cache, i);
 377         if (strcmp(cache->b64_bn, ch) == 0)
 378             return cache->bn;
 379     }
 380     {                           /* it is the first time that we find it */
 381         SRP_gN_cache *newgN = SRP_gN_new_init(ch);
 382         if (newgN) {
 383             if (sk_SRP_gN_cache_insert(gN_cache, newgN, 0) > 0)
 384                 return newgN->bn;
 385             SRP_gN_free(newgN);
 386         }
 387     }
 388     return NULL;
 389 }
 390
 391 /*
 392  * this function parses verifier file. Format is:
 393  * string(index):base64(N):base64(g):0
 394  * string(username):base64(v):base64(salt):int(index)
 395  */
 396
 397 int SRP_VBASE_init(SRP_VBASE *vb, char *verifier_file)
 398 {
 399     int error_code;
 400     STACK_OF(SRP_gN) *SRP_gN_tab = sk_SRP_gN_new_null();
 401     char *last_index = NULL;
 402     int i;
 403     char **pp;
 404
 405     SRP_gN *gN = NULL;
 406     SRP_user_pwd *user_pwd = NULL;
 407
 408     TXT_DB *tmpdb = NULL;
 409     BIO *in = BIO_new(BIO_s_file());
 410
 411     error_code = SRP_ERR_OPEN_FILE;
 412
 413     if (in == NULL || BIO_read_filename(in, verifier_file) <= 0)
 414         goto err;
 415
 416     error_code = SRP_ERR_VBASE_INCOMPLETE_FILE;
 417
 418     if ((tmpdb = TXT_DB_read(in, DB_NUMBER)) == NULL)
 419         goto err;
 420
 421     error_code = SRP_ERR_MEMORY;
 422
 423     if (vb->seed_key) {
 424         last_index = SRP_get_default_gN(NULL)->id;
 425     }
 426     for (i = 0; i < sk_OPENSSL_PSTRING_num(tmpdb->data); i++) {
 427         pp = sk_OPENSSL_PSTRING_value(tmpdb->data, i);
 428         if (pp[DB_srptype][0] == DB_SRP_INDEX) {
 429             /*
 430              * we add this couple in the internal Stack
 431              */
 432
 433             if ((gN = (SRP_gN *) OPENSSL_malloc(sizeof(SRP_gN))) == NULL)
 434                 goto err;
 435
 436             if (!(gN->id = BUF_strdup(pp[DB_srpid]))
 437                 || !(gN->N =
 438                      SRP_gN_place_bn(vb->gN_cache, pp[DB_srpverifier]))
 439                 || !(gN->g = SRP_gN_place_bn(vb->gN_cache, pp[DB_srpsalt]))
 440                 || sk_SRP_gN_insert(SRP_gN_tab, gN, 0) == 0)
 441                 goto err;
 442
 443             gN = NULL;
 444
 445             if (vb->seed_key != NULL) {
 446                 last_index = pp[DB_srpid];
 447             }
 448         } else if (pp[DB_srptype][0] == DB_SRP_VALID) {
 449             /* it is a user .... */
 450             SRP_gN *lgN;
 451             if ((lgN = SRP_get_gN_by_id(pp[DB_srpgN], SRP_gN_tab)) != NULL) {
 452                 error_code = SRP_ERR_MEMORY;
 453                 if ((user_pwd = SRP_user_pwd_new()) == NULL)
 454                     goto err;
 455
 456                 SRP_user_pwd_set_gN(user_pwd, lgN->g, lgN->N);
 457                 if (!SRP_user_pwd_set_ids
 458                     (user_pwd, pp[DB_srpid], pp[DB_srpinfo]))
 459                     goto err;
 460
 461                 error_code = SRP_ERR_VBASE_BN_LIB;
 462                 if (!SRP_user_pwd_set_sv
 463                     (user_pwd, pp[DB_srpsalt], pp[DB_srpverifier]))
 464                     goto err;
 465
 466                 if (sk_SRP_user_pwd_insert(vb->users_pwd, user_pwd, 0) == 0)
 467                     goto err;
 468                 user_pwd = NULL; /* abandon responsability */
 469             }
 470         }
 471     }
 472
 473     if (last_index != NULL) {
 474         /* this means that we want to simulate a default user */
 475
 476         if (((gN = SRP_get_gN_by_id(last_index, SRP_gN_tab)) == NULL)) {
 477             error_code = SRP_ERR_VBASE_BN_LIB;
 478             goto err;
 479         }
 480         vb->default_g = gN->g;
 481         vb->default_N = gN->N;
 482         gN = NULL;
 483     }
 484     error_code = SRP_NO_ERROR;
 485
 486  err:
 487     /*
 488      * there may be still some leaks to fix, if this fails, the application
 489      * terminates most likely
 490      */
 491
 492     if (gN != NULL) {
 493         OPENSSL_free(gN->id);
 494         OPENSSL_free(gN);
 495     }
 496
 497     SRP_user_pwd_free(user_pwd);
 498
 499     if (tmpdb)
 500         TXT_DB_free(tmpdb);
 501     if (in)
 502         BIO_free_all(in);
 503
 504     sk_SRP_gN_free(SRP_gN_tab);
 505
 506     return error_code;
 507
 508 }
 509
 510 static SRP_user_pwd *find_user(SRP_VBASE *vb, char *username)
 511 {
 512     int i;
 513     SRP_user_pwd *user;
 514
 515     if (vb == NULL)
 516         return NULL;
 517
 518     for (i = 0; i < sk_SRP_user_pwd_num(vb->users_pwd); i++) {
 519         user = sk_SRP_user_pwd_value(vb->users_pwd, i);
 520         if (strcmp(user->id, username) == 0)
 521             return user;
 522     }
 523
 524     return NULL;
 525 }
 526
 527 /*
 528  * This method ignores the configured seed and fails for an unknown user.
 529  * Ownership of the returned pointer is not released to the caller.
 530  * In other words, caller must not free the result.
 531  */
 532 SRP_user_pwd *SRP_VBASE_get_by_user(SRP_VBASE *vb, char *username)
 533 {
 534     return find_user(vb, username);
 535 }
 536
 537 /*
 538  * Ownership of the returned pointer is released to the caller.
 539  * In other words, caller must free the result once done.
 540  */
 541 SRP_user_pwd *SRP_VBASE_get1_by_user(SRP_VBASE *vb, char *username)
 542 {
 543     SRP_user_pwd *user;
 544     unsigned char digv[SHA_DIGEST_LENGTH];
 545     unsigned char digs[SHA_DIGEST_LENGTH];
 546     EVP_MD_CTX ctxt;
 547
 548     if (vb == NULL)
 549         return NULL;
 550
 551     if ((user = find_user(vb, username)) != NULL)
 552         return srp_user_pwd_dup(user);
 553
 554     if ((vb->seed_key == NULL) ||
 555         (vb->default_g == NULL) || (vb->default_N == NULL))
 556         return NULL;
 557
 558 /* if the user is unknown we set parameters as well if we have a seed_key */
 559
 560     if ((user = SRP_user_pwd_new()) == NULL)
 561         return NULL;
 562
 563     SRP_user_pwd_set_gN(user, vb->default_g, vb->default_N);
 564
 565     if (!SRP_user_pwd_set_ids(user, username, NULL))
 566         goto err;
 567
 568     if (RAND_bytes(digv, SHA_DIGEST_LENGTH) <= 0)
 569         goto err;
 570     EVP_MD_CTX_init(&ctxt);
 571     EVP_DigestInit_ex(&ctxt, EVP_sha1(), NULL);
 572     EVP_DigestUpdate(&ctxt, vb->seed_key, strlen(vb->seed_key));
 573     EVP_DigestUpdate(&ctxt, username, strlen(username));
 574     EVP_DigestFinal_ex(&ctxt, digs, NULL);
 575     EVP_MD_CTX_cleanup(&ctxt);
 576     if (SRP_user_pwd_set_sv_BN
 577         (user, BN_bin2bn(digs, SHA_DIGEST_LENGTH, NULL),
 578          BN_bin2bn(digv, SHA_DIGEST_LENGTH, NULL)))
 579         return user;
 580
 581  err:SRP_user_pwd_free(user);
 582     return NULL;
 583 }
 584
 585 /*
 586  * create a verifier (*salt,*verifier,g and N are in base64)
 587  */
 588 char *SRP_create_verifier(const char *user, const char *pass, char **salt,
 589                           char **verifier, const char *N, const char *g)
 590 {
 591     int len;
 592     char *result = NULL, *vf = NULL;
 593     BIGNUM *N_bn = NULL, *g_bn = NULL, *s = NULL, *v = NULL;
 594     unsigned char tmp[MAX_LEN];
 595     unsigned char tmp2[MAX_LEN];
 596     char *defgNid = NULL;
 597     int vfsize = 0;
 598
 599     if ((user == NULL) ||
 600         (pass == NULL) || (salt == NULL) || (verifier == NULL))
 601         goto err;
 602
 603     if (N) {
 604         if (!(len = t_fromb64(tmp, sizeof(tmp), N)))
 605             goto err;
 606         N_bn = BN_bin2bn(tmp, len, NULL);
 607         if (!(len = t_fromb64(tmp, sizeof(tmp), g)))
 608             goto err;
 609         g_bn = BN_bin2bn(tmp, len, NULL);
 610         defgNid = "*";
 611     } else {
 612         SRP_gN *gN = SRP_get_gN_by_id(g, NULL);
 613         if (gN == NULL)
 614             goto err;
 615         N_bn = gN->N;
 616         g_bn = gN->g;
 617         defgNid = gN->id;
 618     }
 619
 620     if (*salt == NULL) {
 621         if (RAND_bytes(tmp2, SRP_RANDOM_SALT_LEN) <= 0)
 622             goto err;
 623
 624         s = BN_bin2bn(tmp2, SRP_RANDOM_SALT_LEN, NULL);
 625     } else {
 626         if (!(len = t_fromb64(tmp2, sizeof(tmp2), *salt)))
 627             goto err;
 628         s = BN_bin2bn(tmp2, len, NULL);
 629     }
 630
 631     if (!SRP_create_verifier_BN(user, pass, &s, &v, N_bn, g_bn))
 632         goto err;
 633
 634     BN_bn2bin(v, tmp);
 635     vfsize = BN_num_bytes(v) * 2;
 636     if (((vf = OPENSSL_malloc(vfsize)) == NULL))
 637         goto err;
 638     t_tob64(vf, tmp, BN_num_bytes(v));
 639
 640     if (*salt == NULL) {
 641         char *tmp_salt;
 642
 643         if ((tmp_salt = OPENSSL_malloc(SRP_RANDOM_SALT_LEN * 2)) == NULL) {
 644             goto err;
 645         }
 646         t_tob64(tmp_salt, tmp2, SRP_RANDOM_SALT_LEN);
 647         *salt = tmp_salt;
 648     }
 649
 650     *verifier = vf;
 651     vf = NULL;
 652     result = defgNid;
 653
 654  err:
 655     if (N) {
 656         BN_free(N_bn);
 657         BN_free(g_bn);
 658     }
 659     if (vf != NULL)
 660         OPENSSL_cleanse(vf, vfsize);
 661     OPENSSL_free(vf);
 662     BN_clear_free(s);
 663     BN_clear_free(v);
 664     return result;
 665 }
 666
 667 /*
 668  * create a verifier (*salt,*verifier,g and N are BIGNUMs). If *salt != NULL
 669  * then the provided salt will be used. On successful exit *verifier will point
 670  * to a newly allocated BIGNUM containing the verifier and (if a salt was not
 671  * provided) *salt will be populated with a newly allocated BIGNUM containing a
 672  * random salt.
 673  * The caller is responsible for freeing the allocated *salt and *verifier
 674  * BIGNUMS.
 675  */
 676 int SRP_create_verifier_BN(const char *user, const char *pass, BIGNUM **salt,
 677                            BIGNUM **verifier, BIGNUM *N, BIGNUM *g)
 678 {
 679     int result = 0;
 680     BIGNUM *x = NULL;
 681     BN_CTX *bn_ctx = BN_CTX_new();
 682     unsigned char tmp2[MAX_LEN];
 683     BIGNUM *salttmp = NULL;
 684
 685     if ((user == NULL) ||
 686         (pass == NULL) ||
 687         (salt == NULL) ||
 688         (verifier == NULL) || (N == NULL) || (g == NULL) || (bn_ctx == NULL))
 689         goto err;
 690
 691     srp_bn_print(N);
 692     srp_bn_print(g);
 693
 694     if (*salt == NULL) {
 695         if (RAND_bytes(tmp2, SRP_RANDOM_SALT_LEN) <= 0)
 696             goto err;
 697
 698         salttmp = BN_bin2bn(tmp2, SRP_RANDOM_SALT_LEN, NULL);
 699     } else {
 700         salttmp = *salt;
 701     }
 702
 703     x = SRP_Calc_x(salttmp, user, pass);
 704
 705     *verifier = BN_new();
 706     if (*verifier == NULL)
 707         goto err;
 708
 709     if (!BN_mod_exp(*verifier, g, x, N, bn_ctx)) {
 710         BN_clear_free(*verifier);
 711         goto err;
 712     }
 713
 714     srp_bn_print(*verifier);
 715
 716     result = 1;
 717     *salt = salttmp;
 718
 719  err:
 720     if (*salt != salttmp)
 721         BN_clear_free(salttmp);
 722     BN_clear_free(x);
 723     BN_CTX_free(bn_ctx);
 724     return result;
 725 }
 726
 727 #endif