Additional fix required for no-srtp to work
[openssl.git] / ssl / d1_srtp.c
1 /* ssl/t1_lib.c */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3  * All rights reserved.
4  *
5  * This package is an SSL implementation written
6  * by Eric Young (eay@cryptsoft.com).
7  * The implementation was written so as to conform with Netscapes SSL.
8  * 
9  * This library is free for commercial and non-commercial use as long as
10  * the following conditions are aheared to.  The following conditions
11  * apply to all code found in this distribution, be it the RC4, RSA,
12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13  * included with this distribution is covered by the same copyright terms
14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15  * 
16  * Copyright remains Eric Young's, and as such any Copyright notices in
17  * the code are not to be removed.
18  * If this package is used in a product, Eric Young should be given attribution
19  * as the author of the parts of the library used.
20  * This can be in the form of a textual message at program startup or
21  * in documentation (online or textual) provided with the package.
22  * 
23  * Redistribution and use in source and binary forms, with or without
24  * modification, are permitted provided that the following conditions
25  * are met:
26  * 1. Redistributions of source code must retain the copyright
27  *    notice, this list of conditions and the following disclaimer.
28  * 2. Redistributions in binary form must reproduce the above copyright
29  *    notice, this list of conditions and the following disclaimer in the
30  *    documentation and/or other materials provided with the distribution.
31  * 3. All advertising materials mentioning features or use of this software
32  *    must display the following acknowledgement:
33  *    "This product includes cryptographic software written by
34  *     Eric Young (eay@cryptsoft.com)"
35  *    The word 'cryptographic' can be left out if the rouines from the library
36  *    being used are not cryptographic related :-).
37  * 4. If you include any Windows specific code (or a derivative thereof) from 
38  *    the apps directory (application code) you must include an acknowledgement:
39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40  * 
41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51  * SUCH DAMAGE.
52  * 
53  * The licence and distribution terms for any publically available version or
54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
55  * copied and put under another distribution licence
56  * [including the GNU Public Licence.]
57  */
58 /* ====================================================================
59  * Copyright (c) 1998-2006 The OpenSSL Project.  All rights reserved.
60  *
61  * Redistribution and use in source and binary forms, with or without
62  * modification, are permitted provided that the following conditions
63  * are met:
64  *
65  * 1. Redistributions of source code must retain the above copyright
66  *    notice, this list of conditions and the following disclaimer. 
67  *
68  * 2. Redistributions in binary form must reproduce the above copyright
69  *    notice, this list of conditions and the following disclaimer in
70  *    the documentation and/or other materials provided with the
71  *    distribution.
72  *
73  * 3. All advertising materials mentioning features or use of this
74  *    software must display the following acknowledgment:
75  *    "This product includes software developed by the OpenSSL Project
76  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
77  *
78  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
79  *    endorse or promote products derived from this software without
80  *    prior written permission. For written permission, please contact
81  *    openssl-core@openssl.org.
82  *
83  * 5. Products derived from this software may not be called "OpenSSL"
84  *    nor may "OpenSSL" appear in their names without prior written
85  *    permission of the OpenSSL Project.
86  *
87  * 6. Redistributions of any form whatsoever must retain the following
88  *    acknowledgment:
89  *    "This product includes software developed by the OpenSSL Project
90  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
91  *
92  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
93  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
94  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
95  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
96  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
97  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
98  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
99  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
100  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
101  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
102  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
103  * OF THE POSSIBILITY OF SUCH DAMAGE.
104  * ====================================================================
105  *
106  * This product includes cryptographic software written by Eric Young
107  * (eay@cryptsoft.com).  This product includes software written by Tim
108  * Hudson (tjh@cryptsoft.com).
109  *
110  */
111 /*
112   DTLS code by Eric Rescorla <ekr@rtfm.com>
113
114   Copyright (C) 2006, Network Resonance, Inc.
115   Copyright (C) 2011, RTFM, Inc.
116 */
117
118
119 #include <stdio.h>
120 #include <openssl/objects.h>
121 #include "ssl_locl.h"
122
123 #ifndef OPENSSL_NO_SRTP
124
125 static SRTP_PROTECTION_PROFILE srtp_known_profiles[]=
126     {
127     {
128     "SRTP_AES128_CM_SHA1_80",
129     SRTP_AES128_CM_SHA1_80,
130     },
131     {
132     "SRTP_AES128_CM_SHA1_32",
133     SRTP_AES128_CM_SHA1_32,
134     },
135 #if 0
136     {
137     "SRTP_NULL_SHA1_80",
138     SRTP_NULL_SHA1_80,
139     },
140     {
141     "SRTP_NULL_SHA1_32",
142     SRTP_NULL_SHA1_32,
143     },
144 #endif
145     {0}
146     };
147
148 static int find_profile_by_name(char *profile_name,
149                                 SRTP_PROTECTION_PROFILE **pptr,unsigned len)
150         {
151         SRTP_PROTECTION_PROFILE *p;
152
153         p=srtp_known_profiles;
154         while(p->name)
155                 {
156                 if((len == strlen(p->name)) && !strncmp(p->name,profile_name,
157                                                         len))
158                         {
159                         *pptr=p;
160                         return 0;
161                         }
162
163                 p++;
164                 }
165
166         return 1;
167         }
168
169 static int ssl_ctx_make_profiles(const char *profiles_string,STACK_OF(SRTP_PROTECTION_PROFILE) **out)
170         {
171         STACK_OF(SRTP_PROTECTION_PROFILE) *profiles;
172
173         char *col;
174         char *ptr=(char *)profiles_string;
175     
176         SRTP_PROTECTION_PROFILE *p;
177
178         if(!(profiles=sk_SRTP_PROTECTION_PROFILE_new_null()))
179                 {
180                 SSLerr(SSL_F_SSL_CTX_MAKE_PROFILES, SSL_R_SRTP_COULD_NOT_ALLOCATE_PROFILES);
181                 return 1;
182                 }
183     
184         do
185                 {
186                 col=strchr(ptr,':');
187
188                 if(!find_profile_by_name(ptr,&p,
189                                          col ? col-ptr : (int)strlen(ptr)))
190                         {
191                         if (sk_SRTP_PROTECTION_PROFILE_find(profiles,p) >= 0)
192                                 {
193                                 SSLerr(SSL_F_SSL_CTX_MAKE_PROFILES,SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
194                                 sk_SRTP_PROTECTION_PROFILE_free(profiles);
195                                 return 1;
196                                 }
197
198                         sk_SRTP_PROTECTION_PROFILE_push(profiles,p);
199                         }
200                 else
201                         {
202                         SSLerr(SSL_F_SSL_CTX_MAKE_PROFILES,SSL_R_SRTP_UNKNOWN_PROTECTION_PROFILE);
203                         sk_SRTP_PROTECTION_PROFILE_free(profiles);
204                         return 1;
205                         }
206
207                 if(col) ptr=col+1;
208                 } while (col);
209
210         *out=profiles;
211     
212         return 0;
213         }
214     
215 int SSL_CTX_set_tlsext_use_srtp(SSL_CTX *ctx,const char *profiles)
216         {
217         return ssl_ctx_make_profiles(profiles,&ctx->srtp_profiles);
218         }
219
220 int SSL_set_tlsext_use_srtp(SSL *s,const char *profiles)
221         {
222         return ssl_ctx_make_profiles(profiles,&s->srtp_profiles);
223         }
224
225
226 STACK_OF(SRTP_PROTECTION_PROFILE) *SSL_get_srtp_profiles(SSL *s)
227         {
228         if(s != NULL)
229                 {
230                 if(s->srtp_profiles != NULL)
231                         {
232                         return s->srtp_profiles;
233                         }
234                 else if((s->ctx != NULL) &&
235                         (s->ctx->srtp_profiles != NULL))
236                         {
237                         return s->ctx->srtp_profiles;
238                         }
239                 }
240
241         return NULL;
242         }
243
244 SRTP_PROTECTION_PROFILE *SSL_get_selected_srtp_profile(SSL *s)
245         {
246         return s->srtp_profile;
247         }
248
249 /* Note: this function returns 0 length if there are no 
250    profiles specified */
251 int ssl_add_clienthello_use_srtp_ext(SSL *s, unsigned char *p, int *len, int maxlen)
252         {
253         int ct=0;
254         int i;
255         STACK_OF(SRTP_PROTECTION_PROFILE) *clnt=0;
256         SRTP_PROTECTION_PROFILE *prof;
257     
258         clnt=SSL_get_srtp_profiles(s);    
259         ct=sk_SRTP_PROTECTION_PROFILE_num(clnt); /* -1 if clnt == 0 */
260
261         if(p)
262                 {
263                 if(ct==0)
264                         {
265                         SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_USE_SRTP_EXT,SSL_R_EMPTY_SRTP_PROTECTION_PROFILE_LIST);
266                         return 1;
267                         }
268
269                 if((2 + ct*2 + 1) > maxlen)
270                         {
271                         SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_USE_SRTP_EXT,SSL_R_SRTP_PROTECTION_PROFILE_LIST_TOO_LONG);
272                         return 1;
273                         }
274
275                 /* Add the length */
276                 s2n(ct * 2, p);
277                 for(i=0;i<ct;i++)
278                         {
279                         prof=sk_SRTP_PROTECTION_PROFILE_value(clnt,i);
280                         s2n(prof->id,p);
281                         }
282
283                 /* Add an empty use_mki value */
284                 *p++ = 0;
285                 }
286
287         *len=2 + ct*2 + 1;
288     
289         return 0;
290         }
291
292
293 int ssl_parse_clienthello_use_srtp_ext(SSL *s, unsigned char *d, int len,int *al)
294         {
295         SRTP_PROTECTION_PROFILE *sprof;
296         STACK_OF(SRTP_PROTECTION_PROFILE) *srvr;
297         int ct;
298         int mki_len;
299         int i, srtp_pref;
300         unsigned int id;
301
302          /* Length value + the MKI length */
303         if(len < 3)
304                 {            
305                 SSLerr(SSL_F_SSL_PARSE_CLIENTHELLO_USE_SRTP_EXT,SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
306                 *al=SSL_AD_DECODE_ERROR;
307                 return 1;
308                 }
309
310         /* Pull off the length of the cipher suite list */
311         n2s(d, ct);
312         len -= 2;
313         
314         /* Check that it is even */
315         if(ct%2)
316                 {
317                 SSLerr(SSL_F_SSL_PARSE_CLIENTHELLO_USE_SRTP_EXT,SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
318                 *al=SSL_AD_DECODE_ERROR;
319                 return 1;
320                 }
321         
322         /* Check that lengths are consistent */
323         if(len < (ct + 1)) 
324                 {
325                 SSLerr(SSL_F_SSL_PARSE_CLIENTHELLO_USE_SRTP_EXT,SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
326                 *al=SSL_AD_DECODE_ERROR;
327                 return 1;
328                 }
329
330         srvr=SSL_get_srtp_profiles(s);
331         s->srtp_profile = NULL;
332         /* Search all profiles for a match initially */
333         srtp_pref = sk_SRTP_PROTECTION_PROFILE_num(srvr);
334         
335         while(ct)
336                 {
337                 n2s(d,id);
338                 ct-=2;
339                 len-=2;
340
341                 /*
342                  * Only look for match in profiles of higher preference than
343                  * current match.
344                  * If no profiles have been have been configured then this
345                  * does nothing.
346                  */
347                 for (i = 0; i < srtp_pref; i++)
348                         {
349                         sprof = sk_SRTP_PROTECTION_PROFILE_value(srvr, i);
350                         if (sprof->id == id)
351                                 {
352                                 s->srtp_profile = sprof;
353                                 srtp_pref = i;
354                                 break;
355                                 }
356                         }
357                 }
358
359         /* Now extract the MKI value as a sanity check, but discard it for now */
360         mki_len = *d;
361         d++; len--;
362
363         if (mki_len != len)
364                 {
365                 SSLerr(SSL_F_SSL_PARSE_CLIENTHELLO_USE_SRTP_EXT,SSL_R_BAD_SRTP_MKI_VALUE);
366                 *al=SSL_AD_DECODE_ERROR;
367                 return 1;
368                 }
369
370         return 0;
371         }
372
373 int ssl_add_serverhello_use_srtp_ext(SSL *s, unsigned char *p, int *len, int maxlen)
374         {
375         if(p)
376                 {
377                 if(maxlen < 5)
378                         {
379                         SSLerr(SSL_F_SSL_ADD_SERVERHELLO_USE_SRTP_EXT,SSL_R_SRTP_PROTECTION_PROFILE_LIST_TOO_LONG);
380                         return 1;
381                         }
382
383                 if(s->srtp_profile==0)
384                         {
385                         SSLerr(SSL_F_SSL_ADD_SERVERHELLO_USE_SRTP_EXT,SSL_R_USE_SRTP_NOT_NEGOTIATED);
386                         return 1;
387                         }
388                 s2n(2, p);
389                 s2n(s->srtp_profile->id,p);
390                 *p++ = 0;
391                 }
392         *len=5;
393     
394         return 0;
395         }
396     
397
398 int ssl_parse_serverhello_use_srtp_ext(SSL *s, unsigned char *d, int len,int *al)
399         {
400         unsigned id;
401         int i;
402         int ct;
403
404         STACK_OF(SRTP_PROTECTION_PROFILE) *clnt;
405         SRTP_PROTECTION_PROFILE *prof;
406
407         if(len!=5)
408                 {
409                 SSLerr(SSL_F_SSL_PARSE_SERVERHELLO_USE_SRTP_EXT,SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
410                 *al=SSL_AD_DECODE_ERROR;
411                 return 1;
412                 }
413
414         n2s(d, ct);
415         if(ct!=2)
416                 {
417                 SSLerr(SSL_F_SSL_PARSE_SERVERHELLO_USE_SRTP_EXT,SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
418                 *al=SSL_AD_DECODE_ERROR;
419                 return 1;
420                 }
421
422         n2s(d,id);
423         if (*d)  /* Must be no MKI, since we never offer one */
424                 {
425                 SSLerr(SSL_F_SSL_PARSE_SERVERHELLO_USE_SRTP_EXT,SSL_R_BAD_SRTP_MKI_VALUE);
426                 *al=SSL_AD_ILLEGAL_PARAMETER;
427                 return 1;
428                 }
429
430         clnt=SSL_get_srtp_profiles(s);
431
432         /* Throw an error if the server gave us an unsolicited extension */
433         if (clnt == NULL)
434                 {
435                 SSLerr(SSL_F_SSL_PARSE_SERVERHELLO_USE_SRTP_EXT,SSL_R_NO_SRTP_PROFILES);
436                 *al=SSL_AD_DECODE_ERROR;
437                 return 1;
438                 }
439     
440         /* Check to see if the server gave us something we support
441            (and presumably offered)
442         */
443         for(i=0;i<sk_SRTP_PROTECTION_PROFILE_num(clnt);i++)
444                 {
445                 prof=sk_SRTP_PROTECTION_PROFILE_value(clnt,i);
446             
447                 if(prof->id == id)
448                         {
449                         s->srtp_profile=prof;
450                         *al=0;
451                         return 0;
452                         }
453                 }
454
455         SSLerr(SSL_F_SSL_PARSE_SERVERHELLO_USE_SRTP_EXT,SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
456         *al=SSL_AD_DECODE_ERROR;
457         return 1;
458         }
459
460
461 #endif