]>
Commit | Line | Data |
---|---|---|
0f113f3e | 1 | /* |
846e33c7 | 2 | * Copyright 2004-2016 The OpenSSL Project Authors. All Rights Reserved. |
edc032b5 | 3 | * |
846e33c7 RS |
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 | |
edc032b5 | 8 | */ |
edc032b5 | 9 | |
b93e331b | 10 | #include <openssl/crypto.h> |
edc032b5 | 11 | #include <openssl/rand.h> |
edc032b5 | 12 | #include <openssl/err.h> |
b93e331b DSH |
13 | #include "ssl_locl.h" |
14 | ||
15 | #ifndef OPENSSL_NO_SRP | |
a230b26e | 16 | # include <openssl/srp.h> |
edc032b5 BL |
17 | |
18 | int SSL_CTX_SRP_CTX_free(struct ssl_ctx_st *ctx) | |
0f113f3e MC |
19 | { |
20 | if (ctx == NULL) | |
21 | return 0; | |
22 | OPENSSL_free(ctx->srp_ctx.login); | |
23 | BN_free(ctx->srp_ctx.N); | |
24 | BN_free(ctx->srp_ctx.g); | |
25 | BN_free(ctx->srp_ctx.s); | |
26 | BN_free(ctx->srp_ctx.B); | |
27 | BN_free(ctx->srp_ctx.A); | |
28 | BN_free(ctx->srp_ctx.a); | |
29 | BN_free(ctx->srp_ctx.b); | |
30 | BN_free(ctx->srp_ctx.v); | |
31 | ctx->srp_ctx.TLS_ext_srp_username_callback = NULL; | |
32 | ctx->srp_ctx.SRP_cb_arg = NULL; | |
33 | ctx->srp_ctx.SRP_verify_param_callback = NULL; | |
34 | ctx->srp_ctx.SRP_give_srp_client_pwd_callback = NULL; | |
35 | ctx->srp_ctx.N = NULL; | |
36 | ctx->srp_ctx.g = NULL; | |
37 | ctx->srp_ctx.s = NULL; | |
38 | ctx->srp_ctx.B = NULL; | |
39 | ctx->srp_ctx.A = NULL; | |
40 | ctx->srp_ctx.a = NULL; | |
41 | ctx->srp_ctx.b = NULL; | |
42 | ctx->srp_ctx.v = NULL; | |
43 | ctx->srp_ctx.login = NULL; | |
44 | ctx->srp_ctx.info = NULL; | |
45 | ctx->srp_ctx.strength = SRP_MINIMAL_N; | |
46 | ctx->srp_ctx.srp_Mask = 0; | |
47 | return (1); | |
48 | } | |
edc032b5 BL |
49 | |
50 | int SSL_SRP_CTX_free(struct ssl_st *s) | |
0f113f3e MC |
51 | { |
52 | if (s == NULL) | |
53 | return 0; | |
54 | OPENSSL_free(s->srp_ctx.login); | |
55 | BN_free(s->srp_ctx.N); | |
56 | BN_free(s->srp_ctx.g); | |
57 | BN_free(s->srp_ctx.s); | |
58 | BN_free(s->srp_ctx.B); | |
59 | BN_free(s->srp_ctx.A); | |
60 | BN_free(s->srp_ctx.a); | |
61 | BN_free(s->srp_ctx.b); | |
62 | BN_free(s->srp_ctx.v); | |
63 | s->srp_ctx.TLS_ext_srp_username_callback = NULL; | |
64 | s->srp_ctx.SRP_cb_arg = NULL; | |
65 | s->srp_ctx.SRP_verify_param_callback = NULL; | |
66 | s->srp_ctx.SRP_give_srp_client_pwd_callback = NULL; | |
67 | s->srp_ctx.N = NULL; | |
68 | s->srp_ctx.g = NULL; | |
69 | s->srp_ctx.s = NULL; | |
70 | s->srp_ctx.B = NULL; | |
71 | s->srp_ctx.A = NULL; | |
72 | s->srp_ctx.a = NULL; | |
73 | s->srp_ctx.b = NULL; | |
74 | s->srp_ctx.v = NULL; | |
75 | s->srp_ctx.login = NULL; | |
76 | s->srp_ctx.info = NULL; | |
77 | s->srp_ctx.strength = SRP_MINIMAL_N; | |
78 | s->srp_ctx.srp_Mask = 0; | |
79 | return (1); | |
80 | } | |
edc032b5 BL |
81 | |
82 | int SSL_SRP_CTX_init(struct ssl_st *s) | |
0f113f3e MC |
83 | { |
84 | SSL_CTX *ctx; | |
85 | ||
86 | if ((s == NULL) || ((ctx = s->ctx) == NULL)) | |
87 | return 0; | |
88 | s->srp_ctx.SRP_cb_arg = ctx->srp_ctx.SRP_cb_arg; | |
89 | /* set client Hello login callback */ | |
90 | s->srp_ctx.TLS_ext_srp_username_callback = | |
91 | ctx->srp_ctx.TLS_ext_srp_username_callback; | |
92 | /* set SRP N/g param callback for verification */ | |
93 | s->srp_ctx.SRP_verify_param_callback = | |
94 | ctx->srp_ctx.SRP_verify_param_callback; | |
95 | /* set SRP client passwd callback */ | |
96 | s->srp_ctx.SRP_give_srp_client_pwd_callback = | |
97 | ctx->srp_ctx.SRP_give_srp_client_pwd_callback; | |
98 | ||
99 | s->srp_ctx.N = NULL; | |
100 | s->srp_ctx.g = NULL; | |
101 | s->srp_ctx.s = NULL; | |
102 | s->srp_ctx.B = NULL; | |
103 | s->srp_ctx.A = NULL; | |
104 | s->srp_ctx.a = NULL; | |
105 | s->srp_ctx.b = NULL; | |
106 | s->srp_ctx.v = NULL; | |
107 | s->srp_ctx.login = NULL; | |
108 | s->srp_ctx.info = ctx->srp_ctx.info; | |
109 | s->srp_ctx.strength = ctx->srp_ctx.strength; | |
110 | ||
111 | if (((ctx->srp_ctx.N != NULL) && | |
112 | ((s->srp_ctx.N = BN_dup(ctx->srp_ctx.N)) == NULL)) || | |
113 | ((ctx->srp_ctx.g != NULL) && | |
114 | ((s->srp_ctx.g = BN_dup(ctx->srp_ctx.g)) == NULL)) || | |
115 | ((ctx->srp_ctx.s != NULL) && | |
116 | ((s->srp_ctx.s = BN_dup(ctx->srp_ctx.s)) == NULL)) || | |
117 | ((ctx->srp_ctx.B != NULL) && | |
118 | ((s->srp_ctx.B = BN_dup(ctx->srp_ctx.B)) == NULL)) || | |
119 | ((ctx->srp_ctx.A != NULL) && | |
120 | ((s->srp_ctx.A = BN_dup(ctx->srp_ctx.A)) == NULL)) || | |
121 | ((ctx->srp_ctx.a != NULL) && | |
122 | ((s->srp_ctx.a = BN_dup(ctx->srp_ctx.a)) == NULL)) || | |
123 | ((ctx->srp_ctx.v != NULL) && | |
124 | ((s->srp_ctx.v = BN_dup(ctx->srp_ctx.v)) == NULL)) || | |
125 | ((ctx->srp_ctx.b != NULL) && | |
126 | ((s->srp_ctx.b = BN_dup(ctx->srp_ctx.b)) == NULL))) { | |
127 | SSLerr(SSL_F_SSL_SRP_CTX_INIT, ERR_R_BN_LIB); | |
128 | goto err; | |
129 | } | |
130 | if ((ctx->srp_ctx.login != NULL) && | |
7644a9ae | 131 | ((s->srp_ctx.login = OPENSSL_strdup(ctx->srp_ctx.login)) == NULL)) { |
0f113f3e MC |
132 | SSLerr(SSL_F_SSL_SRP_CTX_INIT, ERR_R_INTERNAL_ERROR); |
133 | goto err; | |
134 | } | |
135 | s->srp_ctx.srp_Mask = ctx->srp_ctx.srp_Mask; | |
136 | ||
137 | return (1); | |
138 | err: | |
139 | OPENSSL_free(s->srp_ctx.login); | |
140 | BN_free(s->srp_ctx.N); | |
141 | BN_free(s->srp_ctx.g); | |
142 | BN_free(s->srp_ctx.s); | |
143 | BN_free(s->srp_ctx.B); | |
144 | BN_free(s->srp_ctx.A); | |
145 | BN_free(s->srp_ctx.a); | |
146 | BN_free(s->srp_ctx.b); | |
147 | BN_free(s->srp_ctx.v); | |
148 | return (0); | |
149 | } | |
edc032b5 BL |
150 | |
151 | int SSL_CTX_SRP_CTX_init(struct ssl_ctx_st *ctx) | |
0f113f3e MC |
152 | { |
153 | if (ctx == NULL) | |
154 | return 0; | |
155 | ||
156 | ctx->srp_ctx.SRP_cb_arg = NULL; | |
157 | /* set client Hello login callback */ | |
158 | ctx->srp_ctx.TLS_ext_srp_username_callback = NULL; | |
159 | /* set SRP N/g param callback for verification */ | |
160 | ctx->srp_ctx.SRP_verify_param_callback = NULL; | |
161 | /* set SRP client passwd callback */ | |
162 | ctx->srp_ctx.SRP_give_srp_client_pwd_callback = NULL; | |
163 | ||
164 | ctx->srp_ctx.N = NULL; | |
165 | ctx->srp_ctx.g = NULL; | |
166 | ctx->srp_ctx.s = NULL; | |
167 | ctx->srp_ctx.B = NULL; | |
168 | ctx->srp_ctx.A = NULL; | |
169 | ctx->srp_ctx.a = NULL; | |
170 | ctx->srp_ctx.b = NULL; | |
171 | ctx->srp_ctx.v = NULL; | |
172 | ctx->srp_ctx.login = NULL; | |
173 | ctx->srp_ctx.srp_Mask = 0; | |
174 | ctx->srp_ctx.info = NULL; | |
175 | ctx->srp_ctx.strength = SRP_MINIMAL_N; | |
176 | ||
177 | return (1); | |
178 | } | |
edc032b5 BL |
179 | |
180 | /* server side */ | |
181 | int SSL_srp_server_param_with_username(SSL *s, int *ad) | |
0f113f3e MC |
182 | { |
183 | unsigned char b[SSL_MAX_MASTER_KEY_LENGTH]; | |
184 | int al; | |
185 | ||
186 | *ad = SSL_AD_UNKNOWN_PSK_IDENTITY; | |
187 | if ((s->srp_ctx.TLS_ext_srp_username_callback != NULL) && | |
188 | ((al = | |
189 | s->srp_ctx.TLS_ext_srp_username_callback(s, ad, | |
190 | s->srp_ctx.SRP_cb_arg)) != | |
191 | SSL_ERROR_NONE)) | |
192 | return al; | |
193 | ||
194 | *ad = SSL_AD_INTERNAL_ERROR; | |
195 | if ((s->srp_ctx.N == NULL) || | |
196 | (s->srp_ctx.g == NULL) || | |
197 | (s->srp_ctx.s == NULL) || (s->srp_ctx.v == NULL)) | |
198 | return SSL3_AL_FATAL; | |
199 | ||
200 | if (RAND_bytes(b, sizeof(b)) <= 0) | |
201 | return SSL3_AL_FATAL; | |
202 | s->srp_ctx.b = BN_bin2bn(b, sizeof(b), NULL); | |
203 | OPENSSL_cleanse(b, sizeof(b)); | |
204 | ||
205 | /* Calculate: B = (kv + g^b) % N */ | |
206 | ||
207 | return ((s->srp_ctx.B = | |
208 | SRP_Calc_B(s->srp_ctx.b, s->srp_ctx.N, s->srp_ctx.g, | |
209 | s->srp_ctx.v)) != | |
210 | NULL) ? SSL_ERROR_NONE : SSL3_AL_FATAL; | |
211 | } | |
212 | ||
213 | /* | |
214 | * If the server just has the raw password, make up a verifier entry on the | |
215 | * fly | |
216 | */ | |
217 | int SSL_set_srp_server_param_pw(SSL *s, const char *user, const char *pass, | |
218 | const char *grp) | |
219 | { | |
220 | SRP_gN *GN = SRP_get_default_gN(grp); | |
221 | if (GN == NULL) | |
222 | return -1; | |
223 | s->srp_ctx.N = BN_dup(GN->N); | |
224 | s->srp_ctx.g = BN_dup(GN->g); | |
23a1d5e9 RS |
225 | BN_clear_free(s->srp_ctx.v); |
226 | s->srp_ctx.v = NULL; | |
227 | BN_clear_free(s->srp_ctx.s); | |
228 | s->srp_ctx.s = NULL; | |
0f113f3e MC |
229 | if (!SRP_create_verifier_BN |
230 | (user, pass, &s->srp_ctx.s, &s->srp_ctx.v, GN->N, GN->g)) | |
231 | return -1; | |
232 | ||
233 | return 1; | |
234 | } | |
edc032b5 BL |
235 | |
236 | int SSL_set_srp_server_param(SSL *s, const BIGNUM *N, const BIGNUM *g, | |
0f113f3e MC |
237 | BIGNUM *sa, BIGNUM *v, char *info) |
238 | { | |
239 | if (N != NULL) { | |
240 | if (s->srp_ctx.N != NULL) { | |
241 | if (!BN_copy(s->srp_ctx.N, N)) { | |
242 | BN_free(s->srp_ctx.N); | |
243 | s->srp_ctx.N = NULL; | |
244 | } | |
245 | } else | |
246 | s->srp_ctx.N = BN_dup(N); | |
247 | } | |
248 | if (g != NULL) { | |
249 | if (s->srp_ctx.g != NULL) { | |
250 | if (!BN_copy(s->srp_ctx.g, g)) { | |
251 | BN_free(s->srp_ctx.g); | |
252 | s->srp_ctx.g = NULL; | |
253 | } | |
254 | } else | |
255 | s->srp_ctx.g = BN_dup(g); | |
256 | } | |
257 | if (sa != NULL) { | |
258 | if (s->srp_ctx.s != NULL) { | |
259 | if (!BN_copy(s->srp_ctx.s, sa)) { | |
260 | BN_free(s->srp_ctx.s); | |
261 | s->srp_ctx.s = NULL; | |
262 | } | |
263 | } else | |
264 | s->srp_ctx.s = BN_dup(sa); | |
265 | } | |
266 | if (v != NULL) { | |
267 | if (s->srp_ctx.v != NULL) { | |
268 | if (!BN_copy(s->srp_ctx.v, v)) { | |
269 | BN_free(s->srp_ctx.v); | |
270 | s->srp_ctx.v = NULL; | |
271 | } | |
272 | } else | |
273 | s->srp_ctx.v = BN_dup(v); | |
274 | } | |
275 | s->srp_ctx.info = info; | |
276 | ||
277 | if (!(s->srp_ctx.N) || | |
278 | !(s->srp_ctx.g) || !(s->srp_ctx.s) || !(s->srp_ctx.v)) | |
279 | return -1; | |
280 | ||
281 | return 1; | |
282 | } | |
283 | ||
57b272b0 | 284 | int srp_generate_server_master_secret(SSL *s) |
0f113f3e MC |
285 | { |
286 | BIGNUM *K = NULL, *u = NULL; | |
4b45c6e5 | 287 | int ret = -1, tmp_len = 0; |
0f113f3e MC |
288 | unsigned char *tmp = NULL; |
289 | ||
290 | if (!SRP_Verify_A_mod_N(s->srp_ctx.A, s->srp_ctx.N)) | |
291 | goto err; | |
75ebbd9a | 292 | if ((u = SRP_Calc_u(s->srp_ctx.A, s->srp_ctx.B, s->srp_ctx.N)) == NULL) |
0f113f3e | 293 | goto err; |
75ebbd9a RS |
294 | if ((K = SRP_Calc_server_key(s->srp_ctx.A, s->srp_ctx.v, u, s->srp_ctx.b, |
295 | s->srp_ctx.N)) == NULL) | |
0f113f3e MC |
296 | goto err; |
297 | ||
298 | tmp_len = BN_num_bytes(K); | |
299 | if ((tmp = OPENSSL_malloc(tmp_len)) == NULL) | |
300 | goto err; | |
301 | BN_bn2bin(K, tmp); | |
57b272b0 | 302 | ret = ssl_generate_master_secret(s, tmp, tmp_len, 1); |
0f113f3e | 303 | err: |
0f113f3e MC |
304 | BN_clear_free(K); |
305 | BN_clear_free(u); | |
306 | return ret; | |
307 | } | |
edc032b5 BL |
308 | |
309 | /* client side */ | |
57b272b0 | 310 | int srp_generate_client_master_secret(SSL *s) |
0f113f3e MC |
311 | { |
312 | BIGNUM *x = NULL, *u = NULL, *K = NULL; | |
4b45c6e5 | 313 | int ret = -1, tmp_len = 0; |
0f113f3e MC |
314 | char *passwd = NULL; |
315 | unsigned char *tmp = NULL; | |
316 | ||
317 | /* | |
318 | * Checks if b % n == 0 | |
319 | */ | |
320 | if (SRP_Verify_B_mod_N(s->srp_ctx.B, s->srp_ctx.N) == 0) | |
321 | goto err; | |
75ebbd9a | 322 | if ((u = SRP_Calc_u(s->srp_ctx.A, s->srp_ctx.B, s->srp_ctx.N)) == NULL) |
0f113f3e MC |
323 | goto err; |
324 | if (s->srp_ctx.SRP_give_srp_client_pwd_callback == NULL) | |
325 | goto err; | |
326 | if (! | |
327 | (passwd = | |
a230b26e | 328 | s->srp_ctx.SRP_give_srp_client_pwd_callback(s, s->srp_ctx.SRP_cb_arg))) |
0f113f3e | 329 | goto err; |
75ebbd9a | 330 | if ((x = SRP_Calc_x(s->srp_ctx.s, s->srp_ctx.login, passwd)) == NULL) |
0f113f3e | 331 | goto err; |
75ebbd9a RS |
332 | if ((K = SRP_Calc_client_key(s->srp_ctx.N, s->srp_ctx.B, s->srp_ctx.g, x, |
333 | s->srp_ctx.a, u)) == NULL) | |
0f113f3e MC |
334 | goto err; |
335 | ||
336 | tmp_len = BN_num_bytes(K); | |
337 | if ((tmp = OPENSSL_malloc(tmp_len)) == NULL) | |
338 | goto err; | |
339 | BN_bn2bin(K, tmp); | |
57b272b0 | 340 | ret = ssl_generate_master_secret(s, tmp, tmp_len, 1); |
0f113f3e | 341 | err: |
0f113f3e MC |
342 | BN_clear_free(K); |
343 | BN_clear_free(x); | |
d73ca3ef MC |
344 | if (passwd != NULL) |
345 | OPENSSL_clear_free(passwd, strlen(passwd)); | |
0f113f3e MC |
346 | BN_clear_free(u); |
347 | return ret; | |
348 | } | |
edc032b5 | 349 | |
0989790b | 350 | int srp_verify_server_param(SSL *s, int *al) |
0f113f3e MC |
351 | { |
352 | SRP_CTX *srp = &s->srp_ctx; | |
353 | /* | |
354 | * Sanity check parameters: we can quickly check B % N == 0 by checking B | |
355 | * != 0 since B < N | |
356 | */ | |
357 | if (BN_ucmp(srp->g, srp->N) >= 0 || BN_ucmp(srp->B, srp->N) >= 0 | |
358 | || BN_is_zero(srp->B)) { | |
359 | *al = SSL3_AD_ILLEGAL_PARAMETER; | |
360 | return 0; | |
361 | } | |
362 | ||
363 | if (BN_num_bits(srp->N) < srp->strength) { | |
364 | *al = TLS1_AD_INSUFFICIENT_SECURITY; | |
365 | return 0; | |
366 | } | |
367 | ||
368 | if (srp->SRP_verify_param_callback) { | |
369 | if (srp->SRP_verify_param_callback(s, srp->SRP_cb_arg) <= 0) { | |
370 | *al = TLS1_AD_INSUFFICIENT_SECURITY; | |
371 | return 0; | |
372 | } | |
373 | } else if (!SRP_check_known_gN_param(srp->g, srp->N)) { | |
374 | *al = TLS1_AD_INSUFFICIENT_SECURITY; | |
375 | return 0; | |
376 | } | |
377 | ||
378 | return 1; | |
379 | } | |
0989790b DSH |
380 | |
381 | int SRP_Calc_A_param(SSL *s) | |
0f113f3e MC |
382 | { |
383 | unsigned char rnd[SSL_MAX_MASTER_KEY_LENGTH]; | |
edc032b5 | 384 | |
0f113f3e MC |
385 | if (RAND_bytes(rnd, sizeof(rnd)) <= 0) |
386 | return 0; | |
387 | s->srp_ctx.a = BN_bin2bn(rnd, sizeof(rnd), s->srp_ctx.a); | |
388 | OPENSSL_cleanse(rnd, sizeof(rnd)); | |
edc032b5 | 389 | |
a230b26e | 390 | if (!(s->srp_ctx.A = SRP_Calc_A(s->srp_ctx.a, s->srp_ctx.N, s->srp_ctx.g))) |
0f113f3e | 391 | return 0; |
edc032b5 | 392 | |
0f113f3e MC |
393 | return 1; |
394 | } | |
edc032b5 | 395 | |
edc032b5 | 396 | BIGNUM *SSL_get_srp_g(SSL *s) |
0f113f3e MC |
397 | { |
398 | if (s->srp_ctx.g != NULL) | |
399 | return s->srp_ctx.g; | |
400 | return s->ctx->srp_ctx.g; | |
401 | } | |
edc032b5 BL |
402 | |
403 | BIGNUM *SSL_get_srp_N(SSL *s) | |
0f113f3e MC |
404 | { |
405 | if (s->srp_ctx.N != NULL) | |
406 | return s->srp_ctx.N; | |
407 | return s->ctx->srp_ctx.N; | |
408 | } | |
edc032b5 BL |
409 | |
410 | char *SSL_get_srp_username(SSL *s) | |
0f113f3e MC |
411 | { |
412 | if (s->srp_ctx.login != NULL) | |
413 | return s->srp_ctx.login; | |
414 | return s->ctx->srp_ctx.login; | |
415 | } | |
edc032b5 BL |
416 | |
417 | char *SSL_get_srp_userinfo(SSL *s) | |
0f113f3e MC |
418 | { |
419 | if (s->srp_ctx.info != NULL) | |
420 | return s->srp_ctx.info; | |
421 | return s->ctx->srp_ctx.info; | |
422 | } | |
edc032b5 | 423 | |
0f113f3e MC |
424 | # define tls1_ctx_ctrl ssl3_ctx_ctrl |
425 | # define tls1_ctx_callback_ctrl ssl3_ctx_callback_ctrl | |
edc032b5 | 426 | |
0f113f3e MC |
427 | int SSL_CTX_set_srp_username(SSL_CTX *ctx, char *name) |
428 | { | |
429 | return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_USERNAME, 0, name); | |
430 | } | |
edc032b5 | 431 | |
0f113f3e MC |
432 | int SSL_CTX_set_srp_password(SSL_CTX *ctx, char *password) |
433 | { | |
434 | return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_PASSWORD, 0, password); | |
435 | } | |
edc032b5 BL |
436 | |
437 | int SSL_CTX_set_srp_strength(SSL_CTX *ctx, int strength) | |
0f113f3e MC |
438 | { |
439 | return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_STRENGTH, strength, | |
440 | NULL); | |
441 | } | |
442 | ||
443 | int SSL_CTX_set_srp_verify_param_callback(SSL_CTX *ctx, | |
444 | int (*cb) (SSL *, void *)) | |
445 | { | |
446 | return tls1_ctx_callback_ctrl(ctx, SSL_CTRL_SET_SRP_VERIFY_PARAM_CB, | |
447 | (void (*)(void))cb); | |
448 | } | |
edc032b5 BL |
449 | |
450 | int SSL_CTX_set_srp_cb_arg(SSL_CTX *ctx, void *arg) | |
0f113f3e MC |
451 | { |
452 | return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_SRP_ARG, 0, arg); | |
453 | } | |
edc032b5 BL |
454 | |
455 | int SSL_CTX_set_srp_username_callback(SSL_CTX *ctx, | |
0f113f3e MC |
456 | int (*cb) (SSL *, int *, void *)) |
457 | { | |
458 | return tls1_ctx_callback_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_USERNAME_CB, | |
459 | (void (*)(void))cb); | |
460 | } | |
461 | ||
462 | int SSL_CTX_set_srp_client_pwd_callback(SSL_CTX *ctx, | |
463 | char *(*cb) (SSL *, void *)) | |
464 | { | |
465 | return tls1_ctx_callback_ctrl(ctx, SSL_CTRL_SET_SRP_GIVE_CLIENT_PWD_CB, | |
466 | (void (*)(void))cb); | |
467 | } | |
edc032b5 | 468 | |
edc032b5 | 469 | #endif |