00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038 #include "asterisk.h"
00039
00040 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 366880 $")
00041
00042 #include <srtp/srtp.h>
00043
00044 #include "asterisk/lock.h"
00045 #include "asterisk/sched.h"
00046 #include "asterisk/module.h"
00047 #include "asterisk/options.h"
00048 #include "asterisk/rtp_engine.h"
00049 #include "asterisk/astobj2.h"
00050
00051 struct ast_srtp {
00052 struct ast_rtp_instance *rtp;
00053 struct ao2_container *policies;
00054 srtp_t session;
00055 const struct ast_srtp_cb *cb;
00056 void *data;
00057 int warned;
00058 unsigned char buf[8192 + AST_FRIENDLY_OFFSET];
00059 unsigned char rtcpbuf[8192 + AST_FRIENDLY_OFFSET];
00060 };
00061
00062 struct ast_srtp_policy {
00063 srtp_policy_t sp;
00064 };
00065
00066
00067 static int g_initialized = 0;
00068
00069
00070 static int ast_srtp_create(struct ast_srtp **srtp, struct ast_rtp_instance *rtp, struct ast_srtp_policy *policy);
00071 static int ast_srtp_replace(struct ast_srtp **srtp, struct ast_rtp_instance *rtp, struct ast_srtp_policy *policy);
00072 static void ast_srtp_destroy(struct ast_srtp *srtp);
00073 static int ast_srtp_add_stream(struct ast_srtp *srtp, struct ast_srtp_policy *policy);
00074 static int ast_srtp_change_source(struct ast_srtp *srtp, unsigned int from_ssrc, unsigned int to_ssrc);
00075
00076 static int ast_srtp_unprotect(struct ast_srtp *srtp, void *buf, int *len, int rtcp);
00077 static int ast_srtp_protect(struct ast_srtp *srtp, void **buf, int *len, int rtcp);
00078 static void ast_srtp_set_cb(struct ast_srtp *srtp, const struct ast_srtp_cb *cb, void *data);
00079 static int ast_srtp_get_random(unsigned char *key, size_t len);
00080
00081
00082 static struct ast_srtp_policy *ast_srtp_policy_alloc(void);
00083 static void ast_srtp_policy_destroy(struct ast_srtp_policy *policy);
00084 static int ast_srtp_policy_set_suite(struct ast_srtp_policy *policy, enum ast_srtp_suite suite);
00085 static int ast_srtp_policy_set_master_key(struct ast_srtp_policy *policy, const unsigned char *key, size_t key_len, const unsigned char *salt, size_t salt_len);
00086 static void ast_srtp_policy_set_ssrc(struct ast_srtp_policy *policy, unsigned long ssrc, int inbound);
00087
00088 static struct ast_srtp_res srtp_res = {
00089 .create = ast_srtp_create,
00090 .replace = ast_srtp_replace,
00091 .destroy = ast_srtp_destroy,
00092 .add_stream = ast_srtp_add_stream,
00093 .change_source = ast_srtp_change_source,
00094 .set_cb = ast_srtp_set_cb,
00095 .unprotect = ast_srtp_unprotect,
00096 .protect = ast_srtp_protect,
00097 .get_random = ast_srtp_get_random
00098 };
00099
00100 static struct ast_srtp_policy_res policy_res = {
00101 .alloc = ast_srtp_policy_alloc,
00102 .destroy = ast_srtp_policy_destroy,
00103 .set_suite = ast_srtp_policy_set_suite,
00104 .set_master_key = ast_srtp_policy_set_master_key,
00105 .set_ssrc = ast_srtp_policy_set_ssrc
00106 };
00107
00108 static const char *srtp_errstr(int err)
00109 {
00110 switch(err) {
00111 case err_status_ok:
00112 return "nothing to report";
00113 case err_status_fail:
00114 return "unspecified failure";
00115 case err_status_bad_param:
00116 return "unsupported parameter";
00117 case err_status_alloc_fail:
00118 return "couldn't allocate memory";
00119 case err_status_dealloc_fail:
00120 return "couldn't deallocate properly";
00121 case err_status_init_fail:
00122 return "couldn't initialize";
00123 case err_status_terminus:
00124 return "can't process as much data as requested";
00125 case err_status_auth_fail:
00126 return "authentication failure";
00127 case err_status_cipher_fail:
00128 return "cipher failure";
00129 case err_status_replay_fail:
00130 return "replay check failed (bad index)";
00131 case err_status_replay_old:
00132 return "replay check failed (index too old)";
00133 case err_status_algo_fail:
00134 return "algorithm failed test routine";
00135 case err_status_no_such_op:
00136 return "unsupported operation";
00137 case err_status_no_ctx:
00138 return "no appropriate context found";
00139 case err_status_cant_check:
00140 return "unable to perform desired validation";
00141 case err_status_key_expired:
00142 return "can't use key any more";
00143 default:
00144 return "unknown";
00145 }
00146 }
00147
00148 static int policy_hash_fn(const void *obj, const int flags)
00149 {
00150 const struct ast_srtp_policy *policy = obj;
00151
00152 return policy->sp.ssrc.type == ssrc_specific ? policy->sp.ssrc.value : policy->sp.ssrc.type;
00153 }
00154
00155 static int policy_cmp_fn(void *obj, void *arg, int flags)
00156 {
00157 const struct ast_srtp_policy *one = obj, *two = arg;
00158
00159 return one->sp.ssrc.type == two->sp.ssrc.type && one->sp.ssrc.value == two->sp.ssrc.value;
00160 }
00161
00162 static struct ast_srtp_policy *find_policy(struct ast_srtp *srtp, const srtp_policy_t *policy, int flags)
00163 {
00164 struct ast_srtp_policy tmp = {
00165 .sp = {
00166 .ssrc.type = policy->ssrc.type,
00167 .ssrc.value = policy->ssrc.value,
00168 },
00169 };
00170
00171 return ao2_t_find(srtp->policies, &tmp, flags, "Looking for policy");
00172 }
00173
00174 static struct ast_srtp *res_srtp_new(void)
00175 {
00176 struct ast_srtp *srtp;
00177
00178 if (!(srtp = ast_calloc(1, sizeof(*srtp)))) {
00179 ast_log(LOG_ERROR, "Unable to allocate memory for srtp\n");
00180 return NULL;
00181 }
00182
00183 if (!(srtp->policies = ao2_t_container_alloc(5, policy_hash_fn, policy_cmp_fn, "SRTP policy container"))) {
00184 ast_free(srtp);
00185 return NULL;
00186 }
00187
00188 srtp->warned = 1;
00189
00190 return srtp;
00191 }
00192
00193
00194
00195
00196 static void srtp_event_cb(srtp_event_data_t *data)
00197 {
00198 switch (data->event) {
00199 case event_ssrc_collision:
00200 ast_debug(1, "SSRC collision\n");
00201 break;
00202 case event_key_soft_limit:
00203 ast_debug(1, "event_key_soft_limit\n");
00204 break;
00205 case event_key_hard_limit:
00206 ast_debug(1, "event_key_hard_limit\n");
00207 break;
00208 case event_packet_index_limit:
00209 ast_debug(1, "event_packet_index_limit\n");
00210 break;
00211 }
00212 }
00213
00214 static void ast_srtp_policy_set_ssrc(struct ast_srtp_policy *policy,
00215 unsigned long ssrc, int inbound)
00216 {
00217 if (ssrc) {
00218 policy->sp.ssrc.type = ssrc_specific;
00219 policy->sp.ssrc.value = ssrc;
00220 } else {
00221 policy->sp.ssrc.type = inbound ? ssrc_any_inbound : ssrc_any_outbound;
00222 }
00223 }
00224
00225 static void policy_destructor(void *obj)
00226 {
00227 struct ast_srtp_policy *policy = obj;
00228
00229 if (policy->sp.key) {
00230 ast_free(policy->sp.key);
00231 policy->sp.key = NULL;
00232 }
00233 }
00234
00235 static struct ast_srtp_policy *ast_srtp_policy_alloc()
00236 {
00237 struct ast_srtp_policy *tmp;
00238
00239 if (!(tmp = ao2_t_alloc(sizeof(*tmp), policy_destructor, "Allocating policy"))) {
00240 ast_log(LOG_ERROR, "Unable to allocate memory for srtp_policy\n");
00241 }
00242
00243 return tmp;
00244 }
00245
00246 static void ast_srtp_policy_destroy(struct ast_srtp_policy *policy)
00247 {
00248 ao2_t_ref(policy, -1, "Destroying policy");
00249 }
00250
00251 static int policy_set_suite(crypto_policy_t *p, enum ast_srtp_suite suite)
00252 {
00253 switch (suite) {
00254 case AST_AES_CM_128_HMAC_SHA1_80:
00255 p->cipher_type = AES_128_ICM;
00256 p->cipher_key_len = 30;
00257 p->auth_type = HMAC_SHA1;
00258 p->auth_key_len = 20;
00259 p->auth_tag_len = 10;
00260 p->sec_serv = sec_serv_conf_and_auth;
00261 return 0;
00262
00263 case AST_AES_CM_128_HMAC_SHA1_32:
00264 p->cipher_type = AES_128_ICM;
00265 p->cipher_key_len = 30;
00266 p->auth_type = HMAC_SHA1;
00267 p->auth_key_len = 20;
00268 p->auth_tag_len = 4;
00269 p->sec_serv = sec_serv_conf_and_auth;
00270 return 0;
00271
00272 default:
00273 ast_log(LOG_ERROR, "Invalid crypto suite: %d\n", suite);
00274 return -1;
00275 }
00276 }
00277
00278 static int ast_srtp_policy_set_suite(struct ast_srtp_policy *policy, enum ast_srtp_suite suite)
00279 {
00280 return policy_set_suite(&policy->sp.rtp, suite) | policy_set_suite(&policy->sp.rtcp, suite);
00281 }
00282
00283 static int ast_srtp_policy_set_master_key(struct ast_srtp_policy *policy, const unsigned char *key, size_t key_len, const unsigned char *salt, size_t salt_len)
00284 {
00285 size_t size = key_len + salt_len;
00286 unsigned char *master_key;
00287
00288 if (policy->sp.key) {
00289 ast_free(policy->sp.key);
00290 policy->sp.key = NULL;
00291 }
00292
00293 if (!(master_key = ast_calloc(1, size))) {
00294 return -1;
00295 }
00296
00297 memcpy(master_key, key, key_len);
00298 memcpy(master_key + key_len, salt, salt_len);
00299
00300 policy->sp.key = master_key;
00301
00302 return 0;
00303 }
00304
00305 static int ast_srtp_get_random(unsigned char *key, size_t len)
00306 {
00307 return crypto_get_random(key, len) != err_status_ok ? -1: 0;
00308 }
00309
00310 static void ast_srtp_set_cb(struct ast_srtp *srtp, const struct ast_srtp_cb *cb, void *data)
00311 {
00312 if (!srtp) {
00313 return;
00314 }
00315
00316 srtp->cb = cb;
00317 srtp->data = data;
00318 }
00319
00320
00321 static int ast_srtp_unprotect(struct ast_srtp *srtp, void *buf, int *len, int rtcp)
00322 {
00323 int res = 0;
00324 int i;
00325 int retry = 0;
00326 struct ast_rtp_instance_stats stats = {0,};
00327
00328 tryagain:
00329
00330 for (i = 0; i < 2; i++) {
00331 res = rtcp ? srtp_unprotect_rtcp(srtp->session, buf, len) : srtp_unprotect(srtp->session, buf, len);
00332 if (res != err_status_no_ctx) {
00333 break;
00334 }
00335
00336 if (srtp->cb && srtp->cb->no_ctx) {
00337 if (ast_rtp_instance_get_stats(srtp->rtp, &stats, AST_RTP_INSTANCE_STAT_REMOTE_SSRC)) {
00338 break;
00339 }
00340 if (srtp->cb->no_ctx(srtp->rtp, stats.remote_ssrc, srtp->data) < 0) {
00341 break;
00342 }
00343 } else {
00344 break;
00345 }
00346 }
00347
00348 if (retry == 0 && res == err_status_replay_old) {
00349 ast_log(AST_LOG_NOTICE, "SRTP unprotect failed with %s, retrying\n", srtp_errstr(res));
00350
00351 if (srtp->session) {
00352 struct ast_srtp_policy *policy;
00353 struct ao2_iterator it;
00354 int policies_count;
00355
00356
00357 ast_debug(5, "SRTP destroy before re-create\n");
00358 srtp_dealloc(srtp->session);
00359
00360
00361 policies_count = ao2_container_count(srtp->policies);
00362
00363
00364 it = ao2_iterator_init(srtp->policies, 0);
00365 policy = ao2_iterator_next(&it);
00366
00367 ast_debug(5, "SRTP try to re-create\n");
00368 if (policy) {
00369 if (srtp_create(&srtp->session, &policy->sp) == err_status_ok) {
00370 ast_debug(5, "SRTP re-created with first policy\n");
00371 ao2_t_ref(policy, -1, "Unreffing first policy for re-creating srtp session");
00372
00373
00374 if (policies_count > 1) {
00375 ast_debug(5, "Add all the other %d policies\n",
00376 policies_count - 1);
00377 while ((policy = ao2_iterator_next(&it))) {
00378 srtp_add_stream(srtp->session, &policy->sp);
00379 ao2_t_ref(policy, -1, "Unreffing n-th policy for re-creating srtp session");
00380 }
00381 }
00382
00383 retry++;
00384 ao2_iterator_destroy(&it);
00385 goto tryagain;
00386 }
00387 ao2_t_ref(policy, -1, "Unreffing first policy after srtp_create failed");
00388 }
00389 ao2_iterator_destroy(&it);
00390 }
00391 }
00392
00393 if (res != err_status_ok && res != err_status_replay_fail ) {
00394 if ((srtp->warned >= 10) && !((srtp->warned - 10) % 100)) {
00395 ast_log(AST_LOG_WARNING, "SRTP unprotect failed with: %s %d\n", srtp_errstr(res), srtp->warned);
00396 srtp->warned = 11;
00397 } else {
00398 srtp->warned++;
00399 }
00400 errno = EAGAIN;
00401 return -1;
00402 }
00403
00404 return *len;
00405 }
00406
00407 static int ast_srtp_protect(struct ast_srtp *srtp, void **buf, int *len, int rtcp)
00408 {
00409 int res;
00410 unsigned char *localbuf;
00411
00412 if ((*len + SRTP_MAX_TRAILER_LEN) > sizeof(srtp->buf)) {
00413 return -1;
00414 }
00415
00416 localbuf = rtcp ? srtp->rtcpbuf : srtp->buf;
00417
00418 memcpy(localbuf, *buf, *len);
00419
00420 if ((res = rtcp ? srtp_protect_rtcp(srtp->session, localbuf, len) : srtp_protect(srtp->session, localbuf, len)) != err_status_ok && res != err_status_replay_fail) {
00421 ast_log(LOG_WARNING, "SRTP protect: %s\n", srtp_errstr(res));
00422 return -1;
00423 }
00424
00425 *buf = localbuf;
00426 return *len;
00427 }
00428
00429 static int ast_srtp_create(struct ast_srtp **srtp, struct ast_rtp_instance *rtp, struct ast_srtp_policy *policy)
00430 {
00431 struct ast_srtp *temp;
00432
00433 if (!(temp = res_srtp_new())) {
00434 return -1;
00435 }
00436 ast_module_ref(ast_module_info->self);
00437
00438
00439 if (srtp_create(&temp->session, &policy->sp) != err_status_ok) {
00440 ast_srtp_destroy(temp);
00441 return -1;
00442 }
00443
00444 temp->rtp = rtp;
00445 *srtp = temp;
00446
00447 ao2_t_link((*srtp)->policies, policy, "Created initial policy");
00448
00449 return 0;
00450 }
00451
00452 static int ast_srtp_replace(struct ast_srtp **srtp, struct ast_rtp_instance *rtp, struct ast_srtp_policy *policy)
00453 {
00454 if ((*srtp) != NULL) {
00455 ast_srtp_destroy(*srtp);
00456 }
00457 return ast_srtp_create(srtp, rtp, policy);
00458 }
00459
00460 static void ast_srtp_destroy(struct ast_srtp *srtp)
00461 {
00462 if (srtp->session) {
00463 srtp_dealloc(srtp->session);
00464 }
00465
00466 ao2_t_callback(srtp->policies, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, NULL, NULL, "Unallocate policy");
00467 ao2_t_ref(srtp->policies, -1, "Destroying container");
00468
00469 ast_free(srtp);
00470 ast_module_unref(ast_module_info->self);
00471 }
00472
00473 static int ast_srtp_add_stream(struct ast_srtp *srtp, struct ast_srtp_policy *policy)
00474 {
00475 struct ast_srtp_policy *match;
00476
00477
00478 if ((match = find_policy(srtp, &policy->sp, OBJ_POINTER))) {
00479 if (policy->sp.ssrc.type != ssrc_specific) {
00480 ast_log(AST_LOG_WARNING, "Cannot replace an existing wildcard policy\n");
00481 ao2_t_ref(match, -1, "Unreffing already existing policy");
00482 return -1;
00483 } else {
00484 if (srtp_remove_stream(srtp->session, match->sp.ssrc.value) != err_status_ok) {
00485 ast_log(AST_LOG_WARNING, "Failed to remove SRTP stream for SSRC %d\n", match->sp.ssrc.value);
00486 }
00487 ao2_t_unlink(srtp->policies, match, "Remove existing match policy");
00488 ao2_t_ref(match, -1, "Unreffing already existing policy");
00489 }
00490 }
00491
00492 ast_debug(3, "Adding new policy for %s %d\n",
00493 policy->sp.ssrc.type == ssrc_specific ? "SSRC" : "type",
00494 policy->sp.ssrc.type == ssrc_specific ? policy->sp.ssrc.value : policy->sp.ssrc.type);
00495 if (srtp_add_stream(srtp->session, &policy->sp) != err_status_ok) {
00496 ast_log(AST_LOG_WARNING, "Failed to add SRTP stream for %s %d\n",
00497 policy->sp.ssrc.type == ssrc_specific ? "SSRC" : "type",
00498 policy->sp.ssrc.type == ssrc_specific ? policy->sp.ssrc.value : policy->sp.ssrc.type);
00499 return -1;
00500 }
00501
00502 ao2_t_link(srtp->policies, policy, "Added additional stream");
00503
00504 return 0;
00505 }
00506
00507 static int ast_srtp_change_source(struct ast_srtp *srtp, unsigned int from_ssrc, unsigned int to_ssrc)
00508 {
00509 struct ast_srtp_policy *match;
00510 struct srtp_policy_t sp = {
00511 .ssrc.type = ssrc_specific,
00512 .ssrc.value = from_ssrc,
00513 };
00514 err_status_t status;
00515
00516
00517
00518
00519 if ((match = find_policy(srtp, &sp, OBJ_POINTER | OBJ_UNLINK))) {
00520 match->sp.ssrc.value = to_ssrc;
00521 if (ast_srtp_add_stream(srtp, match)) {
00522 ast_log(LOG_WARNING, "Couldn't add stream\n");
00523 } else if ((status = srtp_remove_stream(srtp->session, from_ssrc))) {
00524 ast_debug(3, "Couldn't remove stream (%d)\n", status);
00525 }
00526 ao2_t_ref(match, -1, "Unreffing found policy in change_source");
00527 }
00528
00529 return 0;
00530 }
00531
00532 static void res_srtp_shutdown(void)
00533 {
00534 srtp_install_event_handler(NULL);
00535 ast_rtp_engine_unregister_srtp();
00536 g_initialized = 0;
00537 }
00538
00539 static int res_srtp_init(void)
00540 {
00541 if (g_initialized) {
00542 return 0;
00543 }
00544
00545 if (srtp_init() != err_status_ok) {
00546 ast_log(AST_LOG_WARNING, "Failed to initialize libsrtp\n");
00547 return -1;
00548 }
00549
00550 srtp_install_event_handler(srtp_event_cb);
00551
00552 if (ast_rtp_engine_register_srtp(&srtp_res, &policy_res)) {
00553 ast_log(AST_LOG_WARNING, "Failed to register SRTP with rtp engine\n");
00554 res_srtp_shutdown();
00555 return -1;
00556 }
00557
00558 g_initialized = 1;
00559 return 0;
00560 }
00561
00562
00563
00564
00565
00566 static int load_module(void)
00567 {
00568 return res_srtp_init();
00569 }
00570
00571 static int unload_module(void)
00572 {
00573 res_srtp_shutdown();
00574 return 0;
00575 }
00576
00577 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER, "Secure RTP (SRTP)",
00578 .load = load_module,
00579 .unload = unload_module,
00580 .load_pri = AST_MODPRI_CHANNEL_DEPEND,
00581 );