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