Merge "res_pjsip: New endpoint option "refer_blind_progress""
[asterisk/asterisk.git] / res / res_pjsip_authenticator_digest.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2013, Digium, Inc.
5  *
6  * Mark Michelson <mmichelson@digium.com>
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 #include "asterisk.h"
20
21 #include <pjsip.h>
22
23 #include "asterisk/res_pjsip.h"
24 #include "asterisk/logger.h"
25 #include "asterisk/module.h"
26 #include "asterisk/strings.h"
27
28 /*** MODULEINFO
29         <depend>pjproject</depend>
30         <depend>res_pjsip</depend>
31         <support_level>core</support_level>
32  ***/
33
34 /* From the auth/realm realtime column size */
35 #define MAX_REALM_LENGTH 40
36 static char default_realm[MAX_REALM_LENGTH + 1];
37
38 AO2_GLOBAL_OBJ_STATIC(entity_id);
39
40 /*!
41  * \brief Determine if authentication is required
42  *
43  * Authentication is required if the endpoint has at least one auth
44  * section specified
45  */
46 static int digest_requires_authentication(struct ast_sip_endpoint *endpoint, pjsip_rx_data *rdata)
47 {
48         RAII_VAR(struct ast_sip_endpoint *, artificial, ast_sip_get_artificial_endpoint(), ao2_cleanup);
49
50         return endpoint == artificial || AST_VECTOR_SIZE(&endpoint->inbound_auths) > 0;
51 }
52
53 static void auth_store_cleanup(void *data)
54 {
55         struct ast_sip_auth **auth = data;
56
57         ao2_cleanup(*auth);
58         ast_free(data);
59 }
60
61 /*!
62  * \brief Thread-local storage for \ref ast_sip_auth
63  *
64  * The PJSIP authentication API is a bit annoying. When you set
65  * up an authentication server, you specify a lookup callback to
66  * call into when verifying incoming credentials. The problem
67  * with this callback is that it only gives you the realm and
68  * authentication username. In 2.0.5, there is a new version of
69  * the callback you can use that gives the pjsip_rx_data in
70  * addition.
71  *
72  * Unfortunately, the data we actually \b need is the
73  * \ref ast_sip_auth we are currently observing. So we have two
74  * choices:
75  * 1) Use the current PJSIP API and use thread-local storage
76  * to temporarily store our SIP authentication information. Then
77  * in the callback, we can retrieve the authentication info and
78  * use as needed. Given our threading model, this is safe.
79  * 2) Use the 2.0.5 API and temporarily store the authentication
80  * information in the rdata's endpoint_info. Then in the callback,
81  * we can retrieve the authentication info from the rdata.
82  *
83  * I've chosen option 1 since it does not require backporting
84  * any APIs from future versions of PJSIP, plus I feel the
85  * thread-local option is a bit cleaner.
86  */
87 AST_THREADSTORAGE_CUSTOM(auth_store, NULL, auth_store_cleanup);
88
89 /*!
90  * \brief Store shallow copy authentication information in thread-local storage
91  */
92 static int store_auth(const struct ast_sip_auth *auth)
93 {
94         const struct ast_sip_auth **pointing;
95
96         pointing = ast_threadstorage_get(&auth_store, sizeof(pointing));
97         if (!pointing) {
98                 return -1;
99         }
100
101         *pointing = auth;
102         return 0;
103 }
104
105 /*!
106  * \brief Remove shallow copy authentication information from thread-local storage
107  */
108 static int remove_auth(void)
109 {
110         struct ast_sip_auth **pointing;
111
112         pointing = ast_threadstorage_get(&auth_store, sizeof(pointing));
113         if (!pointing) {
114                 return -1;
115         }
116
117         *pointing = NULL;
118         return 0;
119 }
120
121 /*!
122  * \brief Retrieve shallow copy authentication information from thread-local storage
123  */
124 static const struct ast_sip_auth *get_auth(void)
125 {
126         struct ast_sip_auth **auth;
127
128         auth = ast_threadstorage_get(&auth_store, sizeof(auth));
129         if (auth) {
130                 return *auth;
131         }
132         return NULL;
133 }
134
135 /*!
136  * \brief Lookup callback for authentication verification
137  *
138  * This function is called when we call pjsip_auth_srv_verify(). It
139  * expects us to verify that the realm and account name from the
140  * Authorization header is correct. We are then supposed to supply
141  * a password or MD5 sum of credentials.
142  *
143  * \param pool A memory pool we can use for allocations
144  * \param realm The realm from the Authorization header
145  * \param acc_name the user from the Authorization header
146  * \param[out] info The credentials we need to fill in
147  * \retval PJ_SUCCESS Successful authentication
148  * \retval other Unsuccessful
149  */
150 static pj_status_t digest_lookup(pj_pool_t *pool, const pj_str_t *realm,
151                 const pj_str_t *acc_name, pjsip_cred_info *info)
152 {
153         const struct ast_sip_auth *auth;
154
155         auth = get_auth();
156         if (!auth) {
157                 return PJSIP_SC_FORBIDDEN;
158         }
159
160         if (auth->type == AST_SIP_AUTH_TYPE_ARTIFICIAL) {
161                 return PJSIP_SC_FORBIDDEN;
162         }
163
164         if (pj_strcmp2(realm, auth->realm)) {
165                 return PJSIP_SC_FORBIDDEN;
166         }
167         if (pj_strcmp2(acc_name, auth->auth_user)) {
168                 return PJSIP_SC_FORBIDDEN;
169         }
170
171         pj_strdup2(pool, &info->realm, auth->realm);
172         pj_strdup2(pool, &info->username, auth->auth_user);
173
174         switch (auth->type) {
175         case AST_SIP_AUTH_TYPE_USER_PASS:
176                 pj_strdup2(pool, &info->data, auth->auth_pass);
177                 info->data_type = PJSIP_CRED_DATA_PLAIN_PASSWD;
178                 break;
179         case AST_SIP_AUTH_TYPE_MD5:
180                 pj_strdup2(pool, &info->data, auth->md5_creds);
181                 info->data_type = PJSIP_CRED_DATA_DIGEST;
182                 break;
183         default:
184                 return PJSIP_SC_FORBIDDEN;
185         }
186         return PJ_SUCCESS;
187 }
188
189 /*!
190  * \brief Calculate a nonce
191  *
192  * We use this in order to create authentication challenges. We also use this in order
193  * to verify that an incoming request with credentials could be in response to one
194  * of our challenges.
195  *
196  * The nonce is calculated from a timestamp, the source IP address, the source port, a
197  * unique ID for us, and the realm. This helps to ensure that the incoming request
198  * is from the same source that the nonce was calculated for. Including the realm
199  * ensures that multiple challenges to the same request have different nonces.
200  *
201  * \param A UNIX timestamp expressed as a string
202  * \param rdata The incoming request
203  * \param realm The realm for which authentication should occur
204  */
205 static int build_nonce(struct ast_str **nonce, const char *timestamp, const pjsip_rx_data *rdata, const char *realm)
206 {
207         struct ast_str *str = ast_str_alloca(256);
208         RAII_VAR(char *, eid, ao2_global_obj_ref(entity_id), ao2_cleanup);
209         char hash[33];
210
211         /*
212          * Note you may be tempted to think why not include the port. The reason
213          * is that when using TCP the port can potentially differ from before.
214          */
215         ast_str_append(&str, 0, "%s", timestamp);
216         ast_str_append(&str, 0, ":%s", rdata->pkt_info.src_name);
217         ast_str_append(&str, 0, ":%s", eid);
218         ast_str_append(&str, 0, ":%s", realm);
219         ast_md5_hash(hash, ast_str_buffer(str));
220
221         ast_str_append(nonce, 0, "%s/%s", timestamp, hash);
222         return 0;
223 }
224
225 /*!
226  * \brief Ensure that a nonce on an incoming request is sane.
227  *
228  * The nonce in an incoming Authorization header needs to pass some scrutiny in order
229  * for us to consider accepting it. What we do is re-build a nonce based on request
230  * data and a realm and see if it matches the nonce they sent us.
231  * \param candidate The nonce on an incoming request
232  * \param rdata The incoming request
233  * \param auth The auth credentials we are trying to match against.
234  * \retval 0 Nonce does not pass validity checks
235  * \retval 1 Nonce passes validity check
236  */
237 static int check_nonce(const char *candidate, const pjsip_rx_data *rdata, const struct ast_sip_auth *auth)
238 {
239         char *copy = ast_strdupa(candidate);
240         char *timestamp = strsep(&copy, "/");
241         int timestamp_int;
242         time_t now = time(NULL);
243         struct ast_str *calculated = ast_str_alloca(64);
244
245         if (!copy) {
246                 /* Clearly a bad nonce! */
247                 return 0;
248         }
249
250         if (sscanf(timestamp, "%30d", &timestamp_int) != 1) {
251                 return 0;
252         }
253
254         if ((int) now - timestamp_int > auth->nonce_lifetime) {
255                 return 0;
256         }
257
258         build_nonce(&calculated, timestamp, rdata, auth->realm);
259         ast_debug(3, "Calculated nonce %s. Actual nonce is %s\n", ast_str_buffer(calculated), candidate);
260         if (strcmp(ast_str_buffer(calculated), candidate)) {
261                 return 0;
262         }
263         return 1;
264 }
265
266 static int find_challenge(const pjsip_rx_data *rdata, const struct ast_sip_auth *auth)
267 {
268         struct pjsip_authorization_hdr *auth_hdr = (pjsip_authorization_hdr *) &rdata->msg_info.msg->hdr;
269         int challenge_found = 0;
270         char nonce[64];
271
272         while ((auth_hdr = (pjsip_authorization_hdr *) pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_AUTHORIZATION, auth_hdr->next))) {
273                 ast_copy_pj_str(nonce, &auth_hdr->credential.digest.nonce, sizeof(nonce));
274                 if (check_nonce(nonce, rdata, auth) && !pj_strcmp2(&auth_hdr->credential.digest.realm, auth->realm)) {
275                         challenge_found = 1;
276                         break;
277                 }
278         }
279
280         return challenge_found;
281 }
282
283 /*!
284  * \brief Common code for initializing a pjsip_auth_srv
285  */
286 static void setup_auth_srv(pj_pool_t *pool, pjsip_auth_srv *auth_server, const char *realm)
287 {
288         pj_str_t realm_str;
289         pj_cstr(&realm_str, realm);
290
291         pjsip_auth_srv_init(pool, auth_server, &realm_str, digest_lookup, 0);
292 }
293
294 /*!
295  * \brief Result of digest verification
296  */
297 enum digest_verify_result {
298         /*! Authentication credentials incorrect */
299         AUTH_FAIL,
300         /*! Authentication credentials correct */
301         AUTH_SUCCESS,
302         /*! Authentication credentials correct but nonce mismatch */
303         AUTH_STALE,
304         /*! Authentication credentials were not provided */
305         AUTH_NOAUTH,
306 };
307
308 /*!
309  * \brief astobj2 callback for verifying incoming credentials
310  *
311  * \param auth The ast_sip_auth to check against
312  * \param rdata The incoming request
313  * \param pool A pool to use for the auth server
314  * \return CMP_MATCH on successful authentication
315  * \return 0 on failed authentication
316  */
317 static int verify(const struct ast_sip_auth *auth, pjsip_rx_data *rdata, pj_pool_t *pool)
318 {
319         pj_status_t authed;
320         int response_code;
321         pjsip_auth_srv auth_server;
322         int stale = 0;
323
324         if (!find_challenge(rdata, auth)) {
325                 /* Couldn't find a challenge with a sane nonce.
326                  * Nonce mismatch may just be due to staleness.
327                  */
328                 stale = 1;
329         }
330
331         setup_auth_srv(pool, &auth_server, auth->realm);
332
333         store_auth(auth);
334         authed = pjsip_auth_srv_verify(&auth_server, rdata, &response_code);
335         remove_auth();
336
337         if (authed == PJ_SUCCESS) {
338                 if (stale) {
339                         return AUTH_STALE;
340                 } else {
341                         return AUTH_SUCCESS;
342                 }
343         }
344
345         if (authed == PJSIP_EAUTHNOAUTH) {
346                 return AUTH_NOAUTH;
347         }
348
349         return AUTH_FAIL;
350 }
351
352 /*!
353  * \brief astobj2 callback for adding digest challenges to responses
354  *
355  * \param realm An auth's realm to build a challenge from
356  * \param tdata The response to add the challenge to
357  * \param rdata The request the challenge is in response to
358  * \param is_stale Indicates whether nonce on incoming request was stale
359  */
360 static void challenge(const char *realm, pjsip_tx_data *tdata, const pjsip_rx_data *rdata, int is_stale)
361 {
362         pj_str_t qop;
363         pj_str_t pj_nonce;
364         pjsip_auth_srv auth_server;
365         struct ast_str *nonce = ast_str_alloca(256);
366         char time_buf[32];
367         time_t timestamp = time(NULL);
368         snprintf(time_buf, sizeof(time_buf), "%d", (int) timestamp);
369
370         build_nonce(&nonce, time_buf, rdata, realm);
371
372         setup_auth_srv(tdata->pool, &auth_server, realm);
373
374         pj_cstr(&pj_nonce, ast_str_buffer(nonce));
375         pj_cstr(&qop, "auth");
376         pjsip_auth_srv_challenge(&auth_server, &qop, &pj_nonce, NULL, is_stale ? PJ_TRUE : PJ_FALSE, tdata);
377 }
378
379 /*!
380  * \brief Check authentication using Digest scheme
381  *
382  * This function will check an incoming message against configured authentication
383  * options. If \b any of the incoming Authorization headers result in successful
384  * authentication, then authentication is considered successful.
385  *
386  * \see ast_sip_check_authentication
387  */
388 static enum ast_sip_check_auth_result digest_check_auth(struct ast_sip_endpoint *endpoint,
389                 pjsip_rx_data *rdata, pjsip_tx_data *tdata)
390 {
391         struct ast_sip_auth **auths;
392         struct ast_sip_auth **auths_shallow;
393         enum digest_verify_result *verify_res;
394         struct ast_sip_endpoint *artificial_endpoint;
395         enum ast_sip_check_auth_result res;
396         int idx;
397         int is_artificial;
398         int failures = 0;
399         size_t auth_size;
400
401         auth_size = AST_VECTOR_SIZE(&endpoint->inbound_auths);
402         ast_assert(0 < auth_size);
403
404         auths = ast_alloca(auth_size * sizeof(*auths));
405         verify_res = ast_alloca(auth_size * sizeof(*verify_res));
406
407         artificial_endpoint = ast_sip_get_artificial_endpoint();
408         if (!artificial_endpoint) {
409                 /* Should not happen except possibly if we are shutting down. */
410                 return AST_SIP_AUTHENTICATION_ERROR;
411         }
412
413         is_artificial = endpoint == artificial_endpoint;
414         ao2_ref(artificial_endpoint, -1);
415         if (is_artificial) {
416                 ast_assert(auth_size == 1);
417                 auths[0] = ast_sip_get_artificial_auth();
418                 if (!auths[0]) {
419                         /* Should not happen except possibly if we are shutting down. */
420                         return AST_SIP_AUTHENTICATION_ERROR;
421                 }
422         } else {
423                 memset(auths, 0, auth_size * sizeof(*auths));
424                 if (ast_sip_retrieve_auths(&endpoint->inbound_auths, auths)) {
425                         res = AST_SIP_AUTHENTICATION_ERROR;
426                         goto cleanup;
427                 }
428         }
429
430         /* Setup shallow copy of auths */
431         if (ast_strlen_zero(default_realm)) {
432                 auths_shallow = auths;
433         } else {
434                 /*
435                  * Set default realm on a shallow copy of the authentication
436                  * objects that don't have a realm set.
437                  */
438                 auths_shallow = ast_alloca(auth_size * sizeof(*auths_shallow));
439                 for (idx = 0; idx < auth_size; ++idx) {
440                         if (ast_strlen_zero(auths[idx]->realm)) {
441                                 /*
442                                  * Make a shallow copy and set the default realm on it.
443                                  *
444                                  * The stack allocation is OK here.  Normally this will
445                                  * loop one time.  If you have multiple auths then you
446                                  * shouldn't need more auths than the normal complement
447                                  * of fingers and toes.  Otherwise, you should check
448                                  * your sanity for setting up your system up that way.
449                                  */
450                                 auths_shallow[idx] = ast_alloca(sizeof(**auths_shallow));
451                                 memcpy(auths_shallow[idx], auths[idx], sizeof(**auths_shallow));
452                                 *((char **) (&auths_shallow[idx]->realm)) = default_realm;
453                                 ast_debug(3, "Using default realm '%s' on incoming auth '%s'.\n",
454                                         default_realm, ast_sorcery_object_get_id(auths_shallow[idx]));
455                         } else {
456                                 auths_shallow[idx] = auths[idx];
457                         }
458                 }
459         }
460
461         for (idx = 0; idx < auth_size; ++idx) {
462                 verify_res[idx] = verify(auths_shallow[idx], rdata, tdata->pool);
463                 if (verify_res[idx] == AUTH_SUCCESS) {
464                         res = AST_SIP_AUTHENTICATION_SUCCESS;
465                         goto cleanup;
466                 }
467                 if (verify_res[idx] == AUTH_FAIL) {
468                         failures++;
469                 }
470         }
471
472         for (idx = 0; idx < auth_size; ++idx) {
473                 challenge(auths_shallow[idx]->realm, tdata, rdata, verify_res[idx] == AUTH_STALE);
474         }
475
476         if (failures == auth_size) {
477                 res = AST_SIP_AUTHENTICATION_FAILED;
478         } else {
479                 res = AST_SIP_AUTHENTICATION_CHALLENGE;
480         }
481
482 cleanup:
483         ast_sip_cleanup_auths(auths, auth_size);
484         return res;
485 }
486
487 static struct ast_sip_authenticator digest_authenticator = {
488         .requires_authentication = digest_requires_authentication,
489         .check_authentication = digest_check_auth,
490 };
491
492 static int build_entity_id(void)
493 {
494         char *eid;
495
496         eid = ao2_alloc(AST_UUID_STR_LEN, NULL);
497         if (!eid) {
498                 return -1;
499         }
500
501         ast_uuid_generate_str(eid, AST_UUID_STR_LEN);
502         ao2_global_obj_replace_unref(entity_id, eid);
503         ao2_ref(eid, -1);
504         return 0;
505 }
506
507 static void global_loaded(const char *object_type)
508 {
509         ast_sip_get_default_realm(default_realm, sizeof(default_realm));
510 }
511
512 /*! \brief Observer which is used to update our default_realm when the global setting changes */
513 static struct ast_sorcery_observer global_observer = {
514         .loaded = global_loaded,
515 };
516
517 static int reload_module(void)
518 {
519         if (build_entity_id()) {
520                 return -1;
521         }
522         return 0;
523 }
524
525 static int load_module(void)
526 {
527         CHECK_PJSIP_MODULE_LOADED();
528
529         if (build_entity_id()) {
530                 return AST_MODULE_LOAD_DECLINE;
531         }
532
533         ast_sorcery_observer_add(ast_sip_get_sorcery(), "global", &global_observer);
534         ast_sorcery_reload_object(ast_sip_get_sorcery(), "global");
535
536         if (ast_sip_register_authenticator(&digest_authenticator)) {
537                 ao2_global_obj_release(entity_id);
538                 return AST_MODULE_LOAD_DECLINE;
539         }
540         return AST_MODULE_LOAD_SUCCESS;
541 }
542
543 static int unload_module(void)
544 {
545         ast_sorcery_observer_remove(ast_sip_get_sorcery(), "global", &global_observer);
546         ast_sip_unregister_authenticator(&digest_authenticator);
547         ao2_global_obj_release(entity_id);
548         return 0;
549 }
550
551 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "PJSIP authentication resource",
552         .support_level = AST_MODULE_SUPPORT_CORE,
553         .load = load_module,
554         .unload = unload_module,
555         .reload = reload_module,
556         .load_pri = AST_MODPRI_CHANNEL_DEPEND - 5,
557 );