/src/openssl32/ssl/tls_srp.c

Source (jump to first uncovered line)
/*
 * Copyright 2004-2021 The OpenSSL Project Authors. All Rights Reserved.
 * Copyright (c) 2004, EdelKey Project. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 *
 * Originally written by Christophe Renou and Peter Sylvester,
 * for the EdelKey project.
 */

/*
 * We need to use the SRP deprecated APIs in order to implement the SSL SRP
 * APIs - which are themselves deprecated.
 */
#define OPENSSL_SUPPRESS_DEPRECATED

#include <openssl/crypto.h>
#include <openssl/rand.h>
#include <openssl/err.h>
#include "ssl_local.h"

#ifndef OPENSSL_NO_SRP
# include <openssl/srp.h>

/*
 * The public API SSL_CTX_SRP_CTX_free() is deprecated so we use
 * ssl_ctx_srp_ctx_free_intern() internally.
 */
int ssl_ctx_srp_ctx_free_intern(SSL_CTX *ctx)
{
    if (ctx == NULL)
        return 0;
    OPENSSL_free(ctx->srp_ctx.login);
    OPENSSL_free(ctx->srp_ctx.info);
    BN_free(ctx->srp_ctx.N);
    BN_free(ctx->srp_ctx.g);
    BN_free(ctx->srp_ctx.s);
    BN_free(ctx->srp_ctx.B);
    BN_free(ctx->srp_ctx.A);
    BN_free(ctx->srp_ctx.a);
    BN_free(ctx->srp_ctx.b);
    BN_free(ctx->srp_ctx.v);
    memset(&ctx->srp_ctx, 0, sizeof(ctx->srp_ctx));
    ctx->srp_ctx.strength = SRP_MINIMAL_N;
    return 1;
}

int SSL_CTX_SRP_CTX_free(SSL_CTX *ctx)
{
    return ssl_ctx_srp_ctx_free_intern(ctx);
}

/*
 * The public API SSL_SRP_CTX_free() is deprecated so we use
 * ssl_srp_ctx_free_intern() internally.
 */
int ssl_srp_ctx_free_intern(SSL_CONNECTION *s)
{
    if (s == NULL)
        return 0;
    OPENSSL_free(s->srp_ctx.login);
    OPENSSL_free(s->srp_ctx.info);
    BN_free(s->srp_ctx.N);
    BN_free(s->srp_ctx.g);
    BN_free(s->srp_ctx.s);
    BN_free(s->srp_ctx.B);
    BN_free(s->srp_ctx.A);
    BN_free(s->srp_ctx.a);
    BN_free(s->srp_ctx.b);
    BN_free(s->srp_ctx.v);
    memset(&s->srp_ctx, 0, sizeof(s->srp_ctx));
    s->srp_ctx.strength = SRP_MINIMAL_N;
    return 1;
}

int SSL_SRP_CTX_free(SSL *s)
{
    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);

    /* the call works with NULL sc */
    return ssl_srp_ctx_free_intern(sc);
}

/*
 * The public API SSL_SRP_CTX_init() is deprecated so we use
 * ssl_srp_ctx_init_intern() internally.
 */
int ssl_srp_ctx_init_intern(SSL_CONNECTION *s)
{
    SSL_CTX *ctx;

    if (s == NULL || (ctx = SSL_CONNECTION_GET_CTX(s)) == NULL)
        return 0;

    memset(&s->srp_ctx, 0, sizeof(s->srp_ctx));

    s->srp_ctx.SRP_cb_arg = ctx->srp_ctx.SRP_cb_arg;
    /* set client Hello login callback */
    s->srp_ctx.TLS_ext_srp_username_callback =
        ctx->srp_ctx.TLS_ext_srp_username_callback;
    /* set SRP N/g param callback for verification */
    s->srp_ctx.SRP_verify_param_callback =
        ctx->srp_ctx.SRP_verify_param_callback;
    /* set SRP client passwd callback */
    s->srp_ctx.SRP_give_srp_client_pwd_callback =
        ctx->srp_ctx.SRP_give_srp_client_pwd_callback;

    s->srp_ctx.strength = ctx->srp_ctx.strength;

    if (((ctx->srp_ctx.N != NULL) &&
         ((s->srp_ctx.N = BN_dup(ctx->srp_ctx.N)) == NULL)) ||
        ((ctx->srp_ctx.g != NULL) &&
         ((s->srp_ctx.g = BN_dup(ctx->srp_ctx.g)) == NULL)) ||
        ((ctx->srp_ctx.s != NULL) &&
         ((s->srp_ctx.s = BN_dup(ctx->srp_ctx.s)) == NULL)) ||
        ((ctx->srp_ctx.B != NULL) &&
         ((s->srp_ctx.B = BN_dup(ctx->srp_ctx.B)) == NULL)) ||
        ((ctx->srp_ctx.A != NULL) &&
         ((s->srp_ctx.A = BN_dup(ctx->srp_ctx.A)) == NULL)) ||
        ((ctx->srp_ctx.a != NULL) &&
         ((s->srp_ctx.a = BN_dup(ctx->srp_ctx.a)) == NULL)) ||
        ((ctx->srp_ctx.v != NULL) &&
         ((s->srp_ctx.v = BN_dup(ctx->srp_ctx.v)) == NULL)) ||
        ((ctx->srp_ctx.b != NULL) &&
         ((s->srp_ctx.b = BN_dup(ctx->srp_ctx.b)) == NULL))) {
        ERR_raise(ERR_LIB_SSL, ERR_R_BN_LIB);
        goto err;
    }
    if ((ctx->srp_ctx.login != NULL) &&
        ((s->srp_ctx.login = OPENSSL_strdup(ctx->srp_ctx.login)) == NULL)) {
        ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
        goto err;
    }
    if ((ctx->srp_ctx.info != NULL) &&
        ((s->srp_ctx.info = OPENSSL_strdup(ctx->srp_ctx.info)) == NULL)) {
        ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
        goto err;
    }
    s->srp_ctx.srp_Mask = ctx->srp_ctx.srp_Mask;

    return 1;
 err:
    OPENSSL_free(s->srp_ctx.login);
    OPENSSL_free(s->srp_ctx.info);
    BN_free(s->srp_ctx.N);
    BN_free(s->srp_ctx.g);
    BN_free(s->srp_ctx.s);
    BN_free(s->srp_ctx.B);
    BN_free(s->srp_ctx.A);
    BN_free(s->srp_ctx.a);
    BN_free(s->srp_ctx.b);
    BN_free(s->srp_ctx.v);
    memset(&s->srp_ctx, 0, sizeof(s->srp_ctx));
    return 0;
}

int SSL_SRP_CTX_init(SSL *s)
{
    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);

    /* the call works with NULL sc */
    return ssl_srp_ctx_init_intern(sc);
}

/*
 * The public API SSL_CTX_SRP_CTX_init() is deprecated so we use
 * ssl_ctx_srp_ctx_init_intern() internally.
 */
int ssl_ctx_srp_ctx_init_intern(SSL_CTX *ctx)
{
    if (ctx == NULL)
        return 0;

    memset(&ctx->srp_ctx, 0, sizeof(ctx->srp_ctx));
    ctx->srp_ctx.strength = SRP_MINIMAL_N;

    return 1;
}

int SSL_CTX_SRP_CTX_init(SSL_CTX *ctx)
{
    return ssl_ctx_srp_ctx_init_intern(ctx);
}

/* server side */
/*
 * The public API SSL_srp_server_param_with_username() is deprecated so we use
 * ssl_srp_server_param_with_username_intern() internally.
 */
int ssl_srp_server_param_with_username_intern(SSL_CONNECTION *s, int *ad)
{
    unsigned char b[SSL_MAX_MASTER_KEY_LENGTH];
    int al;
    SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);

    *ad = SSL_AD_UNKNOWN_PSK_IDENTITY;
    if ((s->srp_ctx.TLS_ext_srp_username_callback != NULL) &&
        ((al =
          s->srp_ctx.TLS_ext_srp_username_callback(SSL_CONNECTION_GET_USER_SSL(s),
                                                   ad,
                                                   s->srp_ctx.SRP_cb_arg)) !=
         SSL_ERROR_NONE))
        return al;

    *ad = SSL_AD_INTERNAL_ERROR;
    if ((s->srp_ctx.N == NULL) ||
        (s->srp_ctx.g == NULL) ||
        (s->srp_ctx.s == NULL) || (s->srp_ctx.v == NULL))
        return SSL3_AL_FATAL;

    if (RAND_priv_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx, b, sizeof(b),
                           0) <= 0)
        return SSL3_AL_FATAL;
    s->srp_ctx.b = BN_bin2bn(b, sizeof(b), NULL);
    OPENSSL_cleanse(b, sizeof(b));

    /* Calculate:  B = (kv + g^b) % N  */

    return ((s->srp_ctx.B =
             SRP_Calc_B_ex(s->srp_ctx.b, s->srp_ctx.N, s->srp_ctx.g,
                           s->srp_ctx.v, sctx->libctx, sctx->propq)) !=
            NULL) ? SSL_ERROR_NONE : SSL3_AL_FATAL;
}

int SSL_srp_server_param_with_username(SSL *s, int *ad)
{
    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);

    if (sc == NULL)
        return SSL3_AL_FATAL;

    return ssl_srp_server_param_with_username_intern(sc, ad);
}

/*
 * If the server just has the raw password, make up a verifier entry on the
 * fly
 */
int SSL_set_srp_server_param_pw(SSL *s, const char *user, const char *pass,
                                const char *grp)
{
    SRP_gN *GN;
    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);

    if (sc == NULL)
        return -1;

    GN = SRP_get_default_gN(grp);
    if (GN == NULL)
        return -1;
    sc->srp_ctx.N = BN_dup(GN->N);
    sc->srp_ctx.g = BN_dup(GN->g);
    BN_clear_free(sc->srp_ctx.v);
    sc->srp_ctx.v = NULL;
    BN_clear_free(sc->srp_ctx.s);
    sc->srp_ctx.s = NULL;
    if (!SRP_create_verifier_BN_ex(user, pass, &sc->srp_ctx.s, &sc->srp_ctx.v,
                                   sc->srp_ctx.N, sc->srp_ctx.g, s->ctx->libctx,
                                   s->ctx->propq))
        return -1;

    return 1;
}

int SSL_set_srp_server_param(SSL *s, const BIGNUM *N, const BIGNUM *g,
                             BIGNUM *sa, BIGNUM *v, char *info)
{
    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);

    if (sc == NULL)
        return -1;

    if (N != NULL) {
        if (sc->srp_ctx.N != NULL) {
            if (!BN_copy(sc->srp_ctx.N, N)) {
                BN_free(sc->srp_ctx.N);
                sc->srp_ctx.N = NULL;
            }
        } else
            sc->srp_ctx.N = BN_dup(N);
    }
    if (g != NULL) {
        if (sc->srp_ctx.g != NULL) {
            if (!BN_copy(sc->srp_ctx.g, g)) {
                BN_free(sc->srp_ctx.g);
                sc->srp_ctx.g = NULL;
            }
        } else
            sc->srp_ctx.g = BN_dup(g);
    }
    if (sa != NULL) {
        if (sc->srp_ctx.s != NULL) {
            if (!BN_copy(sc->srp_ctx.s, sa)) {
                BN_free(sc->srp_ctx.s);
                sc->srp_ctx.s = NULL;
            }
        } else
            sc->srp_ctx.s = BN_dup(sa);
    }
    if (v != NULL) {
        if (sc->srp_ctx.v != NULL) {
            if (!BN_copy(sc->srp_ctx.v, v)) {
                BN_free(sc->srp_ctx.v);
                sc->srp_ctx.v = NULL;
            }
        } else
            sc->srp_ctx.v = BN_dup(v);
    }
    if (info != NULL) {
        if (sc->srp_ctx.info)
            OPENSSL_free(sc->srp_ctx.info);
        if ((sc->srp_ctx.info = OPENSSL_strdup(info)) == NULL)
            return -1;
    }

    if (!(sc->srp_ctx.N) ||
        !(sc->srp_ctx.g) || !(sc->srp_ctx.s) || !(sc->srp_ctx.v))
        return -1;

    return 1;
}

int srp_generate_server_master_secret(SSL_CONNECTION *s)
{
    BIGNUM *K = NULL, *u = NULL;
    int ret = 0, tmp_len = 0;
    unsigned char *tmp = NULL;
    SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);

    if (!SRP_Verify_A_mod_N(s->srp_ctx.A, s->srp_ctx.N))
        goto err;
    if ((u = SRP_Calc_u_ex(s->srp_ctx.A, s->srp_ctx.B, s->srp_ctx.N,
                           sctx->libctx, sctx->propq)) == NULL)
        goto err;
    if ((K = SRP_Calc_server_key(s->srp_ctx.A, s->srp_ctx.v, u, s->srp_ctx.b,
                                 s->srp_ctx.N)) == NULL)
        goto err;

    tmp_len = BN_num_bytes(K);
    if ((tmp = OPENSSL_malloc(tmp_len)) == NULL) {
        SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
        goto err;
    }
    BN_bn2bin(K, tmp);
    /* Calls SSLfatal() as required */
    ret = ssl_generate_master_secret(s, tmp, tmp_len, 1);
 err:
    BN_clear_free(K);
    BN_clear_free(u);
    return ret;
}

/* client side */
int srp_generate_client_master_secret(SSL_CONNECTION *s)
{
    BIGNUM *x = NULL, *u = NULL, *K = NULL;
    int ret = 0, tmp_len = 0;
    char *passwd = NULL;
    unsigned char *tmp = NULL;
    SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);

    /*
     * Checks if b % n == 0
     */
    if (SRP_Verify_B_mod_N(s->srp_ctx.B, s->srp_ctx.N) == 0
            || (u = SRP_Calc_u_ex(s->srp_ctx.A, s->srp_ctx.B, s->srp_ctx.N,
                                  sctx->libctx, sctx->propq))
               == NULL
            || s->srp_ctx.SRP_give_srp_client_pwd_callback == NULL) {
        SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
        goto err;
    }
    if ((passwd = s->srp_ctx.SRP_give_srp_client_pwd_callback(SSL_CONNECTION_GET_USER_SSL(s),
                                                              s->srp_ctx.SRP_cb_arg))
            == NULL) {
        SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_CALLBACK_FAILED);
        goto err;
    }
    if ((x = SRP_Calc_x_ex(s->srp_ctx.s, s->srp_ctx.login, passwd,
                           sctx->libctx, sctx->propq)) == NULL
            || (K = SRP_Calc_client_key_ex(s->srp_ctx.N, s->srp_ctx.B,
                                           s->srp_ctx.g, x,
                                           s->srp_ctx.a, u,
                                           sctx->libctx,
                                           sctx->propq)) == NULL) {
        SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
        goto err;
    }

    tmp_len = BN_num_bytes(K);
    if ((tmp = OPENSSL_malloc(tmp_len)) == NULL) {
        SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
        goto err;
    }
    BN_bn2bin(K, tmp);
    /* Calls SSLfatal() as required */
    ret = ssl_generate_master_secret(s, tmp, tmp_len, 1);
 err:
    BN_clear_free(K);
    BN_clear_free(x);
    if (passwd != NULL)
        OPENSSL_clear_free(passwd, strlen(passwd));
    BN_clear_free(u);
    return ret;
}

int srp_verify_server_param(SSL_CONNECTION *s)
{
    SRP_CTX *srp = &s->srp_ctx;
    /*
     * Sanity check parameters: we can quickly check B % N == 0 by checking B
     * != 0 since B < N
     */
    if (BN_ucmp(srp->g, srp->N) >= 0 || BN_ucmp(srp->B, srp->N) >= 0
        || BN_is_zero(srp->B)) {
        SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_DATA);
        return 0;
    }

    if (BN_num_bits(srp->N) < srp->strength) {
        SSLfatal(s, SSL_AD_INSUFFICIENT_SECURITY, SSL_R_INSUFFICIENT_SECURITY);
        return 0;
    }

    if (srp->SRP_verify_param_callback) {
        if (srp->SRP_verify_param_callback(SSL_CONNECTION_GET_USER_SSL(s),
                                           srp->SRP_cb_arg) <= 0) {
            SSLfatal(s, SSL_AD_INSUFFICIENT_SECURITY, SSL_R_CALLBACK_FAILED);
            return 0;
        }
    } else if (!SRP_check_known_gN_param(srp->g, srp->N)) {
        SSLfatal(s, SSL_AD_INSUFFICIENT_SECURITY,
                 SSL_R_INSUFFICIENT_SECURITY);
        return 0;
    }

    return 1;
}

/*
 * The public API SRP_Calc_A_param() is deprecated so we use
 * ssl_srp_calc_a_param_intern() internally.
 */
int ssl_srp_calc_a_param_intern(SSL_CONNECTION *s)
{
    unsigned char rnd[SSL_MAX_MASTER_KEY_LENGTH];

    if (RAND_priv_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx,
                           rnd, sizeof(rnd), 0) <= 0)
        return 0;
    s->srp_ctx.a = BN_bin2bn(rnd, sizeof(rnd), s->srp_ctx.a);
    OPENSSL_cleanse(rnd, sizeof(rnd));

    if (!(s->srp_ctx.A = SRP_Calc_A(s->srp_ctx.a, s->srp_ctx.N, s->srp_ctx.g)))
        return 0;

    return 1;
}

int SRP_Calc_A_param(SSL *s)
{
    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);

    if (sc == NULL)
        return 0;

    return ssl_srp_calc_a_param_intern(sc);
}

BIGNUM *SSL_get_srp_g(SSL *s)
{
    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);

    if (sc == NULL)
        return NULL;

    if (sc->srp_ctx.g != NULL)
        return sc->srp_ctx.g;
    return s->ctx->srp_ctx.g;
}

BIGNUM *SSL_get_srp_N(SSL *s)
{
    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);

    if (sc == NULL)
        return NULL;

    if (sc->srp_ctx.N != NULL)
        return sc->srp_ctx.N;
    return s->ctx->srp_ctx.N;
}

char *SSL_get_srp_username(SSL *s)
{
    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);

    if (sc == NULL)
        return NULL;

    if (sc->srp_ctx.login != NULL)
        return sc->srp_ctx.login;
    return s->ctx->srp_ctx.login;
}

char *SSL_get_srp_userinfo(SSL *s)
{
    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);

    if (sc == NULL)
        return NULL;

    if (sc->srp_ctx.info != NULL)
        return sc->srp_ctx.info;
    return s->ctx->srp_ctx.info;
}

# define tls1_ctx_ctrl ssl3_ctx_ctrl
# define tls1_ctx_callback_ctrl ssl3_ctx_callback_ctrl

int SSL_CTX_set_srp_username(SSL_CTX *ctx, char *name)
{
    return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_USERNAME, 0, name);
}

int SSL_CTX_set_srp_password(SSL_CTX *ctx, char *password)
{
    return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_PASSWORD, 0, password);
}

int SSL_CTX_set_srp_strength(SSL_CTX *ctx, int strength)
{
    return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_STRENGTH, strength,
                         NULL);
}

int SSL_CTX_set_srp_verify_param_callback(SSL_CTX *ctx,
                                          int (*cb) (SSL *, void *))
{
    return tls1_ctx_callback_ctrl(ctx, SSL_CTRL_SET_SRP_VERIFY_PARAM_CB,
                                  (void (*)(void))cb);
}

int SSL_CTX_set_srp_cb_arg(SSL_CTX *ctx, void *arg)
{
    return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_SRP_ARG, 0, arg);
}

int SSL_CTX_set_srp_username_callback(SSL_CTX *ctx,
                                      int (*cb) (SSL *, int *, void *))
{
    return tls1_ctx_callback_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_USERNAME_CB,
                                  (void (*)(void))cb);
}

int SSL_CTX_set_srp_client_pwd_callback(SSL_CTX *ctx,
                                        char *(*cb) (SSL *, void *))
{
    return tls1_ctx_callback_ctrl(ctx, SSL_CTRL_SET_SRP_GIVE_CLIENT_PWD_CB,
                                  (void (*)(void))cb);
}

#endif

Coverage Report

Created: 2025-06-13 06:58

Line	Count	Source (jump to first uncovered line)
1		/*
2		* Copyright 2004-2021 The OpenSSL Project Authors. All Rights Reserved.
3		* Copyright (c) 2004, EdelKey Project. All Rights Reserved.
4		*
5		* Licensed under the Apache License 2.0 (the "License"). You may not use
6		* this file except in compliance with the License. You can obtain a copy
7		* in the file LICENSE in the source distribution or at
8		* https://www.openssl.org/source/license.html
9		*
10		* Originally written by Christophe Renou and Peter Sylvester,
11		* for the EdelKey project.
12		*/
13
14		/*
15		* We need to use the SRP deprecated APIs in order to implement the SSL SRP
16		* APIs - which are themselves deprecated.
17		*/
18		#define OPENSSL_SUPPRESS_DEPRECATED
19
20		#include <openssl/crypto.h>
21		#include <openssl/rand.h>
22		#include <openssl/err.h>
23		#include "ssl_local.h"
24
25		#ifndef OPENSSL_NO_SRP
26		# include <openssl/srp.h>
27
28		/*
29		* The public API SSL_CTX_SRP_CTX_free() is deprecated so we use
30		* ssl_ctx_srp_ctx_free_intern() internally.
31		*/
32		int ssl_ctx_srp_ctx_free_intern(SSL_CTX *ctx)
33	79.3k	{
34	79.3k	if (ctx == NULL)
35	0	return 0;
36	79.3k	OPENSSL_free(ctx->srp_ctx.login);
37	79.3k	OPENSSL_free(ctx->srp_ctx.info);
38	79.3k	BN_free(ctx->srp_ctx.N);
39	79.3k	BN_free(ctx->srp_ctx.g);
40	79.3k	BN_free(ctx->srp_ctx.s);
41	79.3k	BN_free(ctx->srp_ctx.B);
42	79.3k	BN_free(ctx->srp_ctx.A);
43	79.3k	BN_free(ctx->srp_ctx.a);
44	79.3k	BN_free(ctx->srp_ctx.b);
45	79.3k	BN_free(ctx->srp_ctx.v);
46	79.3k	memset(&ctx->srp_ctx, 0, sizeof(ctx->srp_ctx));
47	79.3k	ctx->srp_ctx.strength = SRP_MINIMAL_N;
48	79.3k	return 1;
49	79.3k	}
50
51		int SSL_CTX_SRP_CTX_free(SSL_CTX *ctx)
52	0	{
53	0	return ssl_ctx_srp_ctx_free_intern(ctx);
54	0	}
55
56		/*
57		* The public API SSL_SRP_CTX_free() is deprecated so we use
58		* ssl_srp_ctx_free_intern() internally.
59		*/
60		int ssl_srp_ctx_free_intern(SSL_CONNECTION *s)
61	79.2k	{
62	79.2k	if (s == NULL)
63	0	return 0;
64	79.2k	OPENSSL_free(s->srp_ctx.login);
65	79.2k	OPENSSL_free(s->srp_ctx.info);
66	79.2k	BN_free(s->srp_ctx.N);
67	79.2k	BN_free(s->srp_ctx.g);
68	79.2k	BN_free(s->srp_ctx.s);
69	79.2k	BN_free(s->srp_ctx.B);
70	79.2k	BN_free(s->srp_ctx.A);
71	79.2k	BN_free(s->srp_ctx.a);
72	79.2k	BN_free(s->srp_ctx.b);
73	79.2k	BN_free(s->srp_ctx.v);
74	79.2k	memset(&s->srp_ctx, 0, sizeof(s->srp_ctx));
75	79.2k	s->srp_ctx.strength = SRP_MINIMAL_N;
76	79.2k	return 1;
77	79.2k	}
78
79		int SSL_SRP_CTX_free(SSL *s)
80	0	{
81	0	SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
82
83		/* the call works with NULL sc */
84	0	return ssl_srp_ctx_free_intern(sc);
85	0	}
86
87		/*
88		* The public API SSL_SRP_CTX_init() is deprecated so we use
89		* ssl_srp_ctx_init_intern() internally.
90		*/
91		int ssl_srp_ctx_init_intern(SSL_CONNECTION *s)
92	79.2k	{
93	79.2k	SSL_CTX *ctx;
94
95	79.2k	if (s == NULL \|\| (ctx = SSL_CONNECTION_GET_CTX(s)) == NULL)
96	0	return 0;
97
98	79.2k	memset(&s->srp_ctx, 0, sizeof(s->srp_ctx));
99
100	79.2k	s->srp_ctx.SRP_cb_arg = ctx->srp_ctx.SRP_cb_arg;
101		/* set client Hello login callback */
102	79.2k	s->srp_ctx.TLS_ext_srp_username_callback =
103	79.2k	ctx->srp_ctx.TLS_ext_srp_username_callback;
104		/* set SRP N/g param callback for verification */
105	79.2k	s->srp_ctx.SRP_verify_param_callback =
106	79.2k	ctx->srp_ctx.SRP_verify_param_callback;
107		/* set SRP client passwd callback */
108	79.2k	s->srp_ctx.SRP_give_srp_client_pwd_callback =
109	79.2k	ctx->srp_ctx.SRP_give_srp_client_pwd_callback;
110
111	79.2k	s->srp_ctx.strength = ctx->srp_ctx.strength;
112
113	79.2k	if (((ctx->srp_ctx.N != NULL) &&
114	79.2k	((s->srp_ctx.N = BN_dup(ctx->srp_ctx.N)) == NULL)) \|\|
115	79.2k	((ctx->srp_ctx.g != NULL) &&
116	79.2k	((s->srp_ctx.g = BN_dup(ctx->srp_ctx.g)) == NULL)) \|\|
117	79.2k	((ctx->srp_ctx.s != NULL) &&
118	79.2k	((s->srp_ctx.s = BN_dup(ctx->srp_ctx.s)) == NULL)) \|\|
119	79.2k	((ctx->srp_ctx.B != NULL) &&
120	79.2k	((s->srp_ctx.B = BN_dup(ctx->srp_ctx.B)) == NULL)) \|\|
121	79.2k	((ctx->srp_ctx.A != NULL) &&
122	79.2k	((s->srp_ctx.A = BN_dup(ctx->srp_ctx.A)) == NULL)) \|\|
123	79.2k	((ctx->srp_ctx.a != NULL) &&
124	79.2k	((s->srp_ctx.a = BN_dup(ctx->srp_ctx.a)) == NULL)) \|\|
125	79.2k	((ctx->srp_ctx.v != NULL) &&
126	79.2k	((s->srp_ctx.v = BN_dup(ctx->srp_ctx.v)) == NULL)) \|\|
127	79.2k	((ctx->srp_ctx.b != NULL) &&
128	79.2k	((s->srp_ctx.b = BN_dup(ctx->srp_ctx.b)) == NULL))) {
129	0	ERR_raise(ERR_LIB_SSL, ERR_R_BN_LIB);
130	0	goto err;
131	0	}
132	79.2k	if ((ctx->srp_ctx.login != NULL) &&
133	79.2k	((s->srp_ctx.login = OPENSSL_strdup(ctx->srp_ctx.login)) == NULL)) {
134	0	ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
135	0	goto err;
136	0	}
137	79.2k	if ((ctx->srp_ctx.info != NULL) &&
138	79.2k	((s->srp_ctx.info = OPENSSL_strdup(ctx->srp_ctx.info)) == NULL)) {
139	0	ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
140	0	goto err;
141	0	}
142	79.2k	s->srp_ctx.srp_Mask = ctx->srp_ctx.srp_Mask;
143
144	79.2k	return 1;
145	0	err:
146	0	OPENSSL_free(s->srp_ctx.login);
147	0	OPENSSL_free(s->srp_ctx.info);
148	0	BN_free(s->srp_ctx.N);
149	0	BN_free(s->srp_ctx.g);
150	0	BN_free(s->srp_ctx.s);
151	0	BN_free(s->srp_ctx.B);
152	0	BN_free(s->srp_ctx.A);
153	0	BN_free(s->srp_ctx.a);
154	0	BN_free(s->srp_ctx.b);
155	0	BN_free(s->srp_ctx.v);
156	0	memset(&s->srp_ctx, 0, sizeof(s->srp_ctx));
157	0	return 0;
158	79.2k	}
159
160		int SSL_SRP_CTX_init(SSL *s)
161	0	{
162	0	SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
163
164		/* the call works with NULL sc */
165	0	return ssl_srp_ctx_init_intern(sc);
166	0	}
167
168		/*
169		* The public API SSL_CTX_SRP_CTX_init() is deprecated so we use
170		* ssl_ctx_srp_ctx_init_intern() internally.
171		*/
172		int ssl_ctx_srp_ctx_init_intern(SSL_CTX *ctx)
173	79.3k	{
174	79.3k	if (ctx == NULL)
175	0	return 0;
176
177	79.3k	memset(&ctx->srp_ctx, 0, sizeof(ctx->srp_ctx));
178	79.3k	ctx->srp_ctx.strength = SRP_MINIMAL_N;
179
180	79.3k	return 1;
181	79.3k	}
182
183		int SSL_CTX_SRP_CTX_init(SSL_CTX *ctx)
184	0	{
185	0	return ssl_ctx_srp_ctx_init_intern(ctx);
186	0	}
187
188		/* server side */
189		/*
190		* The public API SSL_srp_server_param_with_username() is deprecated so we use
191		* ssl_srp_server_param_with_username_intern() internally.
192		*/
193		int ssl_srp_server_param_with_username_intern(SSL_CONNECTION s, int ad)
194	0	{
195	0	unsigned char b[SSL_MAX_MASTER_KEY_LENGTH];
196	0	int al;
197	0	SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
198
199	0	*ad = SSL_AD_UNKNOWN_PSK_IDENTITY;
200	0	if ((s->srp_ctx.TLS_ext_srp_username_callback != NULL) &&
201	0	((al =
202	0	s->srp_ctx.TLS_ext_srp_username_callback(SSL_CONNECTION_GET_USER_SSL(s),
203	0	ad,
204	0	s->srp_ctx.SRP_cb_arg)) !=
205	0	SSL_ERROR_NONE))
206	0	return al;
207
208	0	*ad = SSL_AD_INTERNAL_ERROR;
209	0	if ((s->srp_ctx.N == NULL) \|\|
210	0	(s->srp_ctx.g == NULL) \|\|
211	0	(s->srp_ctx.s == NULL) \|\| (s->srp_ctx.v == NULL))
212	0	return SSL3_AL_FATAL;
213
214	0	if (RAND_priv_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx, b, sizeof(b),
215	0	0) <= 0)
216	0	return SSL3_AL_FATAL;
217	0	s->srp_ctx.b = BN_bin2bn(b, sizeof(b), NULL);
218	0	OPENSSL_cleanse(b, sizeof(b));
219
220		/* Calculate: B = (kv + g^b) % N */
221
222	0	return ((s->srp_ctx.B =
223	0	SRP_Calc_B_ex(s->srp_ctx.b, s->srp_ctx.N, s->srp_ctx.g,
224	0	s->srp_ctx.v, sctx->libctx, sctx->propq)) !=
225	0	NULL) ? SSL_ERROR_NONE : SSL3_AL_FATAL;
226	0	}
227
228		int SSL_srp_server_param_with_username(SSL s, int ad)
229	0	{
230	0	SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
231
232	0	if (sc == NULL)
233	0	return SSL3_AL_FATAL;
234
235	0	return ssl_srp_server_param_with_username_intern(sc, ad);
236	0	}
237
238		/*
239		* If the server just has the raw password, make up a verifier entry on the
240		* fly
241		*/
242		int SSL_set_srp_server_param_pw(SSL s, const char user, const char *pass,
243		const char *grp)
244	0	{
245	0	SRP_gN *GN;
246	0	SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
247
248	0	if (sc == NULL)
249	0	return -1;
250
251	0	GN = SRP_get_default_gN(grp);
252	0	if (GN == NULL)
253	0	return -1;
254	0	sc->srp_ctx.N = BN_dup(GN->N);
255	0	sc->srp_ctx.g = BN_dup(GN->g);
256	0	BN_clear_free(sc->srp_ctx.v);
257	0	sc->srp_ctx.v = NULL;
258	0	BN_clear_free(sc->srp_ctx.s);
259	0	sc->srp_ctx.s = NULL;
260	0	if (!SRP_create_verifier_BN_ex(user, pass, &sc->srp_ctx.s, &sc->srp_ctx.v,
261	0	sc->srp_ctx.N, sc->srp_ctx.g, s->ctx->libctx,
262	0	s->ctx->propq))
263	0	return -1;
264
265	0	return 1;
266	0	}
267
268		int SSL_set_srp_server_param(SSL s, const BIGNUM N, const BIGNUM *g,
269		BIGNUM sa, BIGNUM v, char *info)
270	0	{
271	0	SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
272
273	0	if (sc == NULL)
274	0	return -1;
275
276	0	if (N != NULL) {
277	0	if (sc->srp_ctx.N != NULL) {
278	0	if (!BN_copy(sc->srp_ctx.N, N)) {
279	0	BN_free(sc->srp_ctx.N);
280	0	sc->srp_ctx.N = NULL;
281	0	}
282	0	} else
283	0	sc->srp_ctx.N = BN_dup(N);
284	0	}
285	0	if (g != NULL) {
286	0	if (sc->srp_ctx.g != NULL) {
287	0	if (!BN_copy(sc->srp_ctx.g, g)) {
288	0	BN_free(sc->srp_ctx.g);
289	0	sc->srp_ctx.g = NULL;
290	0	}
291	0	} else
292	0	sc->srp_ctx.g = BN_dup(g);
293	0	}
294	0	if (sa != NULL) {
295	0	if (sc->srp_ctx.s != NULL) {
296	0	if (!BN_copy(sc->srp_ctx.s, sa)) {
297	0	BN_free(sc->srp_ctx.s);
298	0	sc->srp_ctx.s = NULL;
299	0	}
300	0	} else
301	0	sc->srp_ctx.s = BN_dup(sa);
302	0	}
303	0	if (v != NULL) {
304	0	if (sc->srp_ctx.v != NULL) {
305	0	if (!BN_copy(sc->srp_ctx.v, v)) {
306	0	BN_free(sc->srp_ctx.v);
307	0	sc->srp_ctx.v = NULL;
308	0	}
309	0	} else
310	0	sc->srp_ctx.v = BN_dup(v);
311	0	}
312	0	if (info != NULL) {
313	0	if (sc->srp_ctx.info)
314	0	OPENSSL_free(sc->srp_ctx.info);
315	0	if ((sc->srp_ctx.info = OPENSSL_strdup(info)) == NULL)
316	0	return -1;
317	0	}
318
319	0	if (!(sc->srp_ctx.N) \|\|
320	0	!(sc->srp_ctx.g) \|\| !(sc->srp_ctx.s) \|\| !(sc->srp_ctx.v))
321	0	return -1;
322
323	0	return 1;
324	0	}
325
326		int srp_generate_server_master_secret(SSL_CONNECTION *s)
327	0	{
328	0	BIGNUM K = NULL, u = NULL;
329	0	int ret = 0, tmp_len = 0;
330	0	unsigned char *tmp = NULL;
331	0	SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
332
333	0	if (!SRP_Verify_A_mod_N(s->srp_ctx.A, s->srp_ctx.N))
334	0	goto err;
335	0	if ((u = SRP_Calc_u_ex(s->srp_ctx.A, s->srp_ctx.B, s->srp_ctx.N,
336	0	sctx->libctx, sctx->propq)) == NULL)
337	0	goto err;
338	0	if ((K = SRP_Calc_server_key(s->srp_ctx.A, s->srp_ctx.v, u, s->srp_ctx.b,
339	0	s->srp_ctx.N)) == NULL)
340	0	goto err;
341
342	0	tmp_len = BN_num_bytes(K);
343	0	if ((tmp = OPENSSL_malloc(tmp_len)) == NULL) {
344	0	SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
345	0	goto err;
346	0	}
347	0	BN_bn2bin(K, tmp);
348		/* Calls SSLfatal() as required */
349	0	ret = ssl_generate_master_secret(s, tmp, tmp_len, 1);
350	0	err:
351	0	BN_clear_free(K);
352	0	BN_clear_free(u);
353	0	return ret;
354	0	}
355
356		/* client side */
357		int srp_generate_client_master_secret(SSL_CONNECTION *s)
358	0	{
359	0	BIGNUM x = NULL, u = NULL, *K = NULL;
360	0	int ret = 0, tmp_len = 0;
361	0	char *passwd = NULL;
362	0	unsigned char *tmp = NULL;
363	0	SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
364
365		/*
366		* Checks if b % n == 0
367		*/
368	0	if (SRP_Verify_B_mod_N(s->srp_ctx.B, s->srp_ctx.N) == 0
369	0	\|\| (u = SRP_Calc_u_ex(s->srp_ctx.A, s->srp_ctx.B, s->srp_ctx.N,
370	0	sctx->libctx, sctx->propq))
371	0	== NULL
372	0	\|\| s->srp_ctx.SRP_give_srp_client_pwd_callback == NULL) {
373	0	SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
374	0	goto err;
375	0	}
376	0	if ((passwd = s->srp_ctx.SRP_give_srp_client_pwd_callback(SSL_CONNECTION_GET_USER_SSL(s),
377	0	s->srp_ctx.SRP_cb_arg))
378	0	== NULL) {
379	0	SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_CALLBACK_FAILED);
380	0	goto err;
381	0	}
382	0	if ((x = SRP_Calc_x_ex(s->srp_ctx.s, s->srp_ctx.login, passwd,
383	0	sctx->libctx, sctx->propq)) == NULL
384	0	\|\| (K = SRP_Calc_client_key_ex(s->srp_ctx.N, s->srp_ctx.B,
385	0	s->srp_ctx.g, x,
386	0	s->srp_ctx.a, u,
387	0	sctx->libctx,
388	0	sctx->propq)) == NULL) {
389	0	SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
390	0	goto err;
391	0	}
392
393	0	tmp_len = BN_num_bytes(K);
394	0	if ((tmp = OPENSSL_malloc(tmp_len)) == NULL) {
395	0	SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
396	0	goto err;
397	0	}
398	0	BN_bn2bin(K, tmp);
399		/* Calls SSLfatal() as required */
400	0	ret = ssl_generate_master_secret(s, tmp, tmp_len, 1);
401	0	err:
402	0	BN_clear_free(K);
403	0	BN_clear_free(x);
404	0	if (passwd != NULL)
405	0	OPENSSL_clear_free(passwd, strlen(passwd));
406	0	BN_clear_free(u);
407	0	return ret;
408	0	}
409
410		int srp_verify_server_param(SSL_CONNECTION *s)
411	0	{
412	0	SRP_CTX *srp = &s->srp_ctx;
413		/*
414		* Sanity check parameters: we can quickly check B % N == 0 by checking B
415		* != 0 since B < N
416		*/
417	0	if (BN_ucmp(srp->g, srp->N) >= 0 \|\| BN_ucmp(srp->B, srp->N) >= 0
418	0	\|\| BN_is_zero(srp->B)) {
419	0	SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_DATA);
420	0	return 0;
421	0	}
422
423	0	if (BN_num_bits(srp->N) < srp->strength) {
424	0	SSLfatal(s, SSL_AD_INSUFFICIENT_SECURITY, SSL_R_INSUFFICIENT_SECURITY);
425	0	return 0;
426	0	}
427
428	0	if (srp->SRP_verify_param_callback) {
429	0	if (srp->SRP_verify_param_callback(SSL_CONNECTION_GET_USER_SSL(s),
430	0	srp->SRP_cb_arg) <= 0) {
431	0	SSLfatal(s, SSL_AD_INSUFFICIENT_SECURITY, SSL_R_CALLBACK_FAILED);
432	0	return 0;
433	0	}
434	0	} else if (!SRP_check_known_gN_param(srp->g, srp->N)) {
435	0	SSLfatal(s, SSL_AD_INSUFFICIENT_SECURITY,
436	0	SSL_R_INSUFFICIENT_SECURITY);
437	0	return 0;
438	0	}
439
440	0	return 1;
441	0	}
442
443		/*
444		* The public API SRP_Calc_A_param() is deprecated so we use
445		* ssl_srp_calc_a_param_intern() internally.
446		*/
447		int ssl_srp_calc_a_param_intern(SSL_CONNECTION *s)
448	0	{
449	0	unsigned char rnd[SSL_MAX_MASTER_KEY_LENGTH];
450
451	0	if (RAND_priv_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx,
452	0	rnd, sizeof(rnd), 0) <= 0)
453	0	return 0;
454	0	s->srp_ctx.a = BN_bin2bn(rnd, sizeof(rnd), s->srp_ctx.a);
455	0	OPENSSL_cleanse(rnd, sizeof(rnd));
456
457	0	if (!(s->srp_ctx.A = SRP_Calc_A(s->srp_ctx.a, s->srp_ctx.N, s->srp_ctx.g)))
458	0	return 0;
459
460	0	return 1;
461	0	}
462
463		int SRP_Calc_A_param(SSL *s)
464	0	{
465	0	SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
466
467	0	if (sc == NULL)
468	0	return 0;
469
470	0	return ssl_srp_calc_a_param_intern(sc);
471	0	}
472
473		BIGNUM SSL_get_srp_g(SSL s)
474	0	{
475	0	SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
476
477	0	if (sc == NULL)
478	0	return NULL;
479
480	0	if (sc->srp_ctx.g != NULL)
481	0	return sc->srp_ctx.g;
482	0	return s->ctx->srp_ctx.g;
483	0	}
484
485		BIGNUM SSL_get_srp_N(SSL s)
486	0	{
487	0	SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
488
489	0	if (sc == NULL)
490	0	return NULL;
491
492	0	if (sc->srp_ctx.N != NULL)
493	0	return sc->srp_ctx.N;
494	0	return s->ctx->srp_ctx.N;
495	0	}
496
497		char SSL_get_srp_username(SSL s)
498	0	{
499	0	SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
500
501	0	if (sc == NULL)
502	0	return NULL;
503
504	0	if (sc->srp_ctx.login != NULL)
505	0	return sc->srp_ctx.login;
506	0	return s->ctx->srp_ctx.login;
507	0	}
508
509		char SSL_get_srp_userinfo(SSL s)
510	0	{
511	0	SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
512
513	0	if (sc == NULL)
514	0	return NULL;
515
516	0	if (sc->srp_ctx.info != NULL)
517	0	return sc->srp_ctx.info;
518	0	return s->ctx->srp_ctx.info;
519	0	}
520
521	0	# define tls1_ctx_ctrl ssl3_ctx_ctrl
522	0	# define tls1_ctx_callback_ctrl ssl3_ctx_callback_ctrl
523
524		int SSL_CTX_set_srp_username(SSL_CTX ctx, char name)
525	0	{
526	0	return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_USERNAME, 0, name);
527	0	}
528
529		int SSL_CTX_set_srp_password(SSL_CTX ctx, char password)
530	0	{
531	0	return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_PASSWORD, 0, password);
532	0	}
533
534		int SSL_CTX_set_srp_strength(SSL_CTX *ctx, int strength)
535	0	{
536	0	return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_STRENGTH, strength,
537	0	NULL);
538	0	}
539
540		int SSL_CTX_set_srp_verify_param_callback(SSL_CTX *ctx,
541		int (cb) (SSL , void *))
542	0	{
543	0	return tls1_ctx_callback_ctrl(ctx, SSL_CTRL_SET_SRP_VERIFY_PARAM_CB,
544	0	(void (*)(void))cb);
545	0	}
546
547		int SSL_CTX_set_srp_cb_arg(SSL_CTX ctx, void arg)
548	0	{
549	0	return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_SRP_ARG, 0, arg);
550	0	}
551
552		int SSL_CTX_set_srp_username_callback(SSL_CTX *ctx,
553		int (cb) (SSL , int , void ))
554	0	{
555	0	return tls1_ctx_callback_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_USERNAME_CB,
556	0	(void (*)(void))cb);
557	0	}
558
559		int SSL_CTX_set_srp_client_pwd_callback(SSL_CTX *ctx,
560		char (cb) (SSL , void ))
561	0	{
562	0	return tls1_ctx_callback_ctrl(ctx, SSL_CTRL_SET_SRP_GIVE_CLIENT_PWD_CB,
563	0	(void (*)(void))cb);
564	0	}
565
566		#endif