Named ACLs: Introduces a system for creating and sharing ACLs
[asterisk/asterisk.git] / channels / sip / sdp_crypto.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2006 - 2007, Mikael Magnusson
5  *
6  * Mikael Magnusson <mikma@users.sourceforge.net>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file sdp_crypto.c
20  *
21  * \brief SDP Security descriptions
22  *
23  * Specified in RFC 4568
24  *
25  * \author Mikael Magnusson <mikma@users.sourceforge.net>
26  */
27
28 /*** MODULEINFO
29         <support_level>core</support_level>
30  ***/
31
32 #include "asterisk.h"
33
34 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
35
36 #include "asterisk/options.h"
37 #include "asterisk/utils.h"
38 #include "include/sdp_crypto.h"
39 #include "include/srtp.h"
40
41 #define SRTP_MASTER_LEN 30
42 #define SRTP_MASTERKEY_LEN 16
43 #define SRTP_MASTERSALT_LEN ((SRTP_MASTER_LEN) - (SRTP_MASTERKEY_LEN))
44 #define SRTP_MASTER_LEN64 (((SRTP_MASTER_LEN) * 8 + 5) / 6 + 1)
45
46 extern struct ast_srtp_res *res_srtp;
47 extern struct ast_srtp_policy_res *res_srtp_policy;
48
49 struct sdp_crypto {
50         char *a_crypto;
51         unsigned char local_key[SRTP_MASTER_LEN];
52         char local_key64[SRTP_MASTER_LEN64];
53 };
54
55 static int set_crypto_policy(struct ast_srtp_policy *policy, int suite_val, const unsigned char *master_key, unsigned long ssrc, int inbound);
56
57 static struct sdp_crypto *sdp_crypto_alloc(void)
58 {
59         return ast_calloc(1, sizeof(struct sdp_crypto));
60 }
61
62 void sdp_crypto_destroy(struct sdp_crypto *crypto)
63 {
64         ast_free(crypto->a_crypto);
65         crypto->a_crypto = NULL;
66         ast_free(crypto);
67 }
68
69 struct sdp_crypto *sdp_crypto_setup(void)
70 {
71         struct sdp_crypto *p;
72         int key_len;
73         unsigned char remote_key[SRTP_MASTER_LEN];
74
75         if (!ast_rtp_engine_srtp_is_registered()) {
76                 return NULL;
77         }
78
79         if (!(p = sdp_crypto_alloc())) {
80                 return NULL;
81         }
82
83         if (res_srtp->get_random(p->local_key, sizeof(p->local_key)) < 0) {
84                 sdp_crypto_destroy(p);
85                 return NULL;
86         }
87
88         ast_base64encode(p->local_key64, p->local_key, SRTP_MASTER_LEN, sizeof(p->local_key64));
89
90         key_len = ast_base64decode(remote_key, p->local_key64, sizeof(remote_key));
91
92         if (key_len != SRTP_MASTER_LEN) {
93                 ast_log(LOG_ERROR, "base64 encode/decode bad len %d != %d\n", key_len, SRTP_MASTER_LEN);
94                 ast_free(p);
95                 return NULL;
96         }
97
98         if (memcmp(remote_key, p->local_key, SRTP_MASTER_LEN)) {
99                 ast_log(LOG_ERROR, "base64 encode/decode bad key\n");
100                 ast_free(p);
101                 return NULL;
102         }
103
104         ast_debug(1 , "local_key64 %s len %zu\n", p->local_key64, strlen(p->local_key64));
105
106         return p;
107 }
108
109 static int set_crypto_policy(struct ast_srtp_policy *policy, int suite_val, const unsigned char *master_key, unsigned long ssrc, int inbound)
110 {
111         const unsigned char *master_salt = NULL;
112
113         if (!ast_rtp_engine_srtp_is_registered()) {
114                 return -1;
115         }
116
117         master_salt = master_key + SRTP_MASTERKEY_LEN;
118         if (res_srtp_policy->set_master_key(policy, master_key, SRTP_MASTERKEY_LEN, master_salt, SRTP_MASTERSALT_LEN) < 0) {
119                 return -1;
120         }
121
122         if (res_srtp_policy->set_suite(policy, suite_val)) {
123                 ast_log(LOG_WARNING, "Could not set remote SRTP suite\n");
124                 return -1;
125         }
126
127         res_srtp_policy->set_ssrc(policy, ssrc, inbound);
128
129         return 0;
130 }
131
132 static int sdp_crypto_activate(struct sdp_crypto *p, int suite_val, unsigned char *remote_key, struct ast_rtp_instance *rtp)
133 {
134         struct ast_srtp_policy *local_policy = NULL;
135         struct ast_srtp_policy *remote_policy = NULL;
136         struct ast_rtp_instance_stats stats = {0,};
137         int res = -1;
138
139         if (!ast_rtp_engine_srtp_is_registered()) {
140                 return -1;
141         }
142
143         if (!p) {
144                 return -1;
145         }
146
147         if (!(local_policy = res_srtp_policy->alloc())) {
148                 return -1;
149         }
150
151         if (!(remote_policy = res_srtp_policy->alloc())) {
152                 goto err;
153         }
154
155         if (ast_rtp_instance_get_stats(rtp, &stats, AST_RTP_INSTANCE_STAT_LOCAL_SSRC)) {
156                 goto err;
157         }
158
159         if (set_crypto_policy(local_policy, suite_val, p->local_key, stats.local_ssrc, 0) < 0) {
160                 goto err;
161         }
162
163         if (set_crypto_policy(remote_policy, suite_val, remote_key, 0, 1) < 0) {
164                 goto err;
165         }
166
167         /* Add the SRTP policies */
168         if (ast_rtp_instance_add_srtp_policy(rtp, remote_policy, local_policy)) {
169                 ast_log(LOG_WARNING, "Could not set SRTP policies\n");
170                 goto err;
171         }
172
173         ast_debug(1 , "SRTP policy activated\n");
174         res = 0;
175
176 err:
177         if (local_policy) {
178                 res_srtp_policy->destroy(local_policy);
179         }
180
181         if (remote_policy) {
182                 res_srtp_policy->destroy(remote_policy);
183         }
184
185         return res;
186 }
187
188 int sdp_crypto_process(struct sdp_crypto *p, const char *attr, struct ast_rtp_instance *rtp, struct sip_srtp *srtp)
189 {
190         char *str = NULL;
191         char *tag = NULL;
192         char *suite = NULL;
193         char *key_params = NULL;
194         char *key_param = NULL;
195         char *session_params = NULL;
196         char *key_salt = NULL;
197         char *lifetime = NULL;
198         int found = 0;
199         int attr_len = strlen(attr);
200         int key_len = 0;
201         int suite_val = 0;
202         unsigned char remote_key[SRTP_MASTER_LEN];
203
204         if (!ast_rtp_engine_srtp_is_registered()) {
205                 return -1;
206         }
207
208         str = ast_strdupa(attr);
209
210         strsep(&str, ":");
211         tag = strsep(&str, " ");
212         suite = strsep(&str, " ");
213         key_params = strsep(&str, " ");
214         session_params = strsep(&str, " ");
215
216         if (!tag || !suite) {
217                 ast_log(LOG_WARNING, "Unrecognized a=%s", attr);
218                 return -1;
219         }
220
221         if (session_params) {
222                 ast_log(LOG_WARNING, "Unsupported crypto parameters: %s", session_params);
223                 return -1;
224         }
225
226         if (!strcmp(suite, "AES_CM_128_HMAC_SHA1_80")) {
227                 suite_val = AST_AES_CM_128_HMAC_SHA1_80;
228                 ast_set_flag(srtp, SRTP_CRYPTO_TAG_80);
229         } else if (!strcmp(suite, "AES_CM_128_HMAC_SHA1_32")) {
230                 suite_val = AST_AES_CM_128_HMAC_SHA1_32;
231                 ast_set_flag(srtp, SRTP_CRYPTO_TAG_32);
232         } else {
233                 ast_log(LOG_WARNING, "Unsupported crypto suite: %s\n", suite);
234                 return -1;
235         }
236
237         while ((key_param = strsep(&key_params, ";"))) {
238                 char *method = NULL;
239                 char *info = NULL;
240
241                 method = strsep(&key_param, ":");
242                 info = strsep(&key_param, ";");
243
244                 if (!strcmp(method, "inline")) {
245                         key_salt = strsep(&info, "|");
246                         lifetime = strsep(&info, "|");
247
248                         if (lifetime) {
249                                 ast_log(LOG_NOTICE, "Crypto life time unsupported: %s\n", attr);
250                                 continue;
251                         }
252
253                         found = 1;
254                         break;
255                 }
256         }
257
258         if (!found) {
259                 ast_log(LOG_NOTICE, "SRTP crypto offer not acceptable\n");
260                 return -1;
261         }
262
263
264         if ((key_len = ast_base64decode(remote_key, key_salt, sizeof(remote_key))) != SRTP_MASTER_LEN) {
265                 ast_log(LOG_WARNING, "SRTP sdescriptions key %d != %d\n", key_len, SRTP_MASTER_LEN);
266                 return -1;
267         }
268
269         if (sdp_crypto_activate(p, suite_val, remote_key, rtp) < 0) {
270                 return -1;
271         }
272
273         if (!p->a_crypto) {
274                 if (!(p->a_crypto = ast_calloc(1, attr_len + 11))) {
275                         ast_log(LOG_ERROR, "Could not allocate memory for a_crypto\n");
276                         return -1;
277                 }
278                 snprintf(p->a_crypto, attr_len + 10, "a=crypto:%s %s inline:%s\r\n", tag, suite, p->local_key64);
279         }
280         return 0;
281 }
282
283 int sdp_crypto_offer(struct sdp_crypto *p, int taglen)
284 {
285         char crypto_buf[128];
286
287         if (p->a_crypto) {
288                 ast_free(p->a_crypto);
289         }
290
291         if (snprintf(crypto_buf, sizeof(crypto_buf), "a=crypto:1 AES_CM_128_HMAC_SHA1_%i inline:%s\r\n",
292                         taglen, p->local_key64) < 1) {
293                 return -1;
294         }
295
296         if (!(p->a_crypto = ast_strdup(crypto_buf))) {
297                 return -1;
298         }
299
300         return 0;
301 }
302
303 const char *sdp_crypto_attrib(struct sdp_crypto *p)
304 {
305         return p->a_crypto;
306 }