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