Merge the pimp_my_sip branch into trunk.
[asterisk/asterisk.git] / res / res_sip_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_sip.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_sip</depend>
31         <support_level>core</support_level>
32  ***/
33
34 AO2_GLOBAL_OBJ_STATIC(entity_id);
35
36 /*!
37  * \brief Determine if authentication is required
38  *
39  * Authentication is required if the endpoint has at least one auth
40  * section specified
41  */
42 static int digest_requires_authentication(struct ast_sip_endpoint *endpoint, pjsip_rx_data *rdata)
43 {
44         return endpoint->num_inbound_auths > 0;
45 }
46
47 static void auth_store_cleanup(void *data)
48 {
49         struct ast_sip_auth **auth = data;
50
51         ao2_cleanup(*auth);
52         ast_free(data);
53 }
54
55 /*!
56  * \brief Thread-local storage for \ref ast_sip_auth
57  *
58  * The PJSIP authentication API is a bit annoying. When you set
59  * up an authentication server, you specify a lookup callback to
60  * call into when verifying incoming credentials. The problem
61  * with this callback is that it only gives you the realm and
62  * authentication username. In 2.0.5, there is a new version of
63  * the callback you can use that gives the pjsip_rx_data in
64  * addition.
65  *
66  * Unfortunately, the data we actually \b need is the
67  * \ref ast_sip_auth we are currently observing. So we have two
68  * choices:
69  * 1) Use the current PJSIP API and use thread-local storage
70  * to temporarily store our SIP authentication information. Then
71  * in the callback, we can retrieve the authentication info and
72  * use as needed. Given our threading model, this is safe.
73  * 2) Use the 2.0.5 API and temporarily store the authentication
74  * information in the rdata's endpoint_info. Then in the callback,
75  * we can retrieve the authentication info from the rdata.
76  *
77  * I've chosen option 1 since it does not require backporting
78  * any APIs from future versions of PJSIP, plus I feel the
79  * thread-local option is a bit cleaner.
80  */
81 AST_THREADSTORAGE_CUSTOM(auth_store, NULL, auth_store_cleanup);
82
83 /*!
84  * \brief Store authentication information in thread-local storage
85  */
86 static int store_auth(struct ast_sip_auth *auth)
87 {
88         struct ast_sip_auth **pointing;
89         pointing = ast_threadstorage_get(&auth_store, sizeof(pointing));
90         if (!pointing || *pointing) {
91                 return -1;
92         }
93
94         ao2_ref(auth, +1);
95         *pointing = auth;
96         return 0;
97 }
98
99 /*!
100  * \brief Remove authentication information from thread-local storage
101  */
102 static int remove_auth(void)
103 {
104         struct ast_sip_auth **pointing;
105         pointing = ast_threadstorage_get(&auth_store, sizeof(pointing));
106         if (!pointing) {
107                 return -1;
108         }
109
110         ao2_cleanup(*pointing);
111         *pointing = NULL;
112         return 0;
113 }
114
115 /*!
116  * \brief Retrieve authentication information from thread-local storage
117  */
118 static struct ast_sip_auth *get_auth(void)
119 {
120         struct ast_sip_auth **auth;
121         auth = ast_threadstorage_get(&auth_store, sizeof(auth));
122         if (auth && *auth) {
123                 ao2_ref(*auth, +1);
124                 return *auth;
125         }
126         return NULL;
127 }
128
129 /*!
130  * \brief Lookup callback for authentication verification
131  *
132  * This function is called when we call pjsip_auth_srv_verify(). It
133  * expects us to verify that the realm and account name from the
134  * Authorization header is correct. We are then supposed to supply
135  * a password or MD5 sum of credentials.
136  *
137  * \param pool A memory pool we can use for allocations
138  * \param realm The realm from the Authorization header
139  * \param acc_name the user from the Authorization header
140  * \param[out] info The credentials we need to fill in
141  * \retval PJ_SUCCESS Successful authentication
142  * \retval other Unsuccessful
143  */
144 static pj_status_t digest_lookup(pj_pool_t *pool, const pj_str_t *realm,
145                 const pj_str_t *acc_name, pjsip_cred_info *info)
146 {
147         RAII_VAR(struct ast_sip_auth *, auth, get_auth(), ao2_cleanup);
148         if (!auth) {
149                 return PJSIP_SC_FORBIDDEN;
150         }
151
152         if (pj_strcmp2(realm, auth->realm)) {
153                 return PJSIP_SC_FORBIDDEN;
154         }
155         if (pj_strcmp2(acc_name, auth->auth_user)) {
156                 return PJSIP_SC_FORBIDDEN;
157         }
158
159         pj_strdup2(pool, &info->realm, auth->realm);
160         pj_strdup2(pool, &info->username, auth->auth_user);
161
162         switch (auth->type) {
163         case AST_SIP_AUTH_TYPE_USER_PASS:
164                 pj_strdup2(pool, &info->data, auth->auth_pass);
165                 info->data_type = PJSIP_CRED_DATA_PLAIN_PASSWD;
166                 break;
167         case AST_SIP_AUTH_TYPE_MD5:
168                 pj_strdup2(pool, &info->data, auth->md5_creds);
169                 info->data_type = PJSIP_CRED_DATA_DIGEST;
170                 break;
171         default:
172                 return PJSIP_SC_FORBIDDEN;
173         }
174         return PJ_SUCCESS;
175 }
176
177 /*!
178  * \brief Calculate a nonce
179  *
180  * We use this in order to create authentication challenges. We also use this in order
181  * to verify that an incoming request with credentials could be in response to one
182  * of our challenges.
183  *
184  * The nonce is calculated from a timestamp, the source IP address, the source port, a
185  * unique ID for us, and the realm. This helps to ensure that the incoming request
186  * is from the same source that the nonce was calculated for. Including the realm
187  * ensures that multiple challenges to the same request have different nonces.
188  *
189  * \param A UNIX timestamp expressed as a string
190  * \param rdata The incoming request
191  * \param realm The realm for which authentication should occur
192  */
193 static int build_nonce(struct ast_str **nonce, const char *timestamp, const pjsip_rx_data *rdata, const char *realm)
194 {
195         struct ast_str *str = ast_str_alloca(256);
196         RAII_VAR(char *, eid, ao2_global_obj_ref(entity_id), ao2_cleanup);
197         char hash[32];
198
199         ast_str_append(&str, 0, "%s", timestamp);
200         ast_str_append(&str, 0, ":%s", rdata->pkt_info.src_name);
201         ast_str_append(&str, 0, ":%d", rdata->pkt_info.src_port);
202         ast_str_append(&str, 0, ":%s", eid);
203         ast_str_append(&str, 0, ":%s", realm);
204         ast_md5_hash(hash, ast_str_buffer(str));
205
206         ast_str_append(nonce, 0, "%s/%s", timestamp, hash);
207         return 0;
208 }
209
210 /*!
211  * \brief Ensure that a nonce on an incoming request is sane.
212  *
213  * The nonce in an incoming Authorization header needs to pass some scrutiny in order
214  * for us to consider accepting it. What we do is re-build a nonce based on request
215  * data and a realm and see if it matches the nonce they sent us.
216  * \param candidate The nonce on an incoming request
217  * \param rdata The incoming request
218  * \param auth The auth credentials we are trying to match against.
219  * \retval 0 Nonce does not pass validity checks
220  * \retval 1 Nonce passes validity check
221  */
222 static int check_nonce(const char *candidate, const pjsip_rx_data *rdata, const struct ast_sip_auth *auth)
223 {
224         char *copy = ast_strdupa(candidate);
225         char *timestamp = strsep(&copy, "/");
226         int timestamp_int;
227         time_t now = time(NULL);
228         struct ast_str *calculated = ast_str_alloca(64);
229
230         if (!copy) {
231                 /* Clearly a bad nonce! */
232                 return 0;
233         }
234
235         if (sscanf(timestamp, "%30d", &timestamp_int) != 1) {
236                 return 0;
237         }
238
239         if ((int) now - timestamp_int > auth->nonce_lifetime) {
240                 return 0;
241         }
242
243         build_nonce(&calculated, timestamp, rdata, auth->realm);
244         ast_debug(3, "Calculated nonce %s. Actual nonce is %s\n", ast_str_buffer(calculated), candidate);
245         if (strcmp(ast_str_buffer(calculated), candidate)) {
246                 return 0;
247         }
248         return 1;
249 }
250
251 static int find_challenge(const pjsip_rx_data *rdata, const struct ast_sip_auth *auth)
252 {
253         struct pjsip_authorization_hdr *auth_hdr = (pjsip_authorization_hdr *) &rdata->msg_info.msg->hdr;
254         int challenge_found = 0;
255         char nonce[64];
256
257         while ((auth_hdr = (pjsip_authorization_hdr *) pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_AUTHORIZATION, auth_hdr->next))) {
258                 ast_copy_pj_str(nonce, &auth_hdr->credential.digest.nonce, sizeof(nonce));
259                 if (check_nonce(nonce, rdata, auth) && !pj_strcmp2(&auth_hdr->credential.digest.realm, auth->realm)) {
260                         challenge_found = 1;
261                         break;
262                 }
263         }
264
265         return challenge_found;
266 }
267
268 /*!
269  * \brief Common code for initializing a pjsip_auth_srv
270  */
271 static void setup_auth_srv(pj_pool_t *pool, pjsip_auth_srv *auth_server, const struct ast_sip_auth *auth)
272 {
273         pj_str_t realm;
274         pj_cstr(&realm, auth->realm);
275
276         pjsip_auth_srv_init(pool, auth_server, &realm, digest_lookup, 0);
277 }
278
279 /*!
280  * \brief Result of digest verification
281  */
282 enum digest_verify_result {
283         /*! Authentication credentials incorrect */
284         AUTH_FAIL,
285         /*! Authentication credentials correct */
286         AUTH_SUCCESS,
287         /*! Authentication credentials correct but nonce mismatch */
288         AUTH_STALE,
289 };
290
291 /*!
292  * \brief astobj2 callback for verifying incoming credentials
293  *
294  * \param auth The ast_sip_auth to check against
295  * \param rdata The incoming request
296  * \param pool A pool to use for the auth server
297  * \return CMP_MATCH on successful authentication
298  * \return 0 on failed authentication
299  */
300 static int verify(struct ast_sip_auth *auth, pjsip_rx_data *rdata, pj_pool_t *pool)
301 {
302         pj_status_t authed;
303         int response_code;
304         pjsip_auth_srv auth_server;
305         int stale = 0;
306
307         if (!find_challenge(rdata, auth)) {
308                 /* Couldn't find a challenge with a sane nonce.
309                  * Nonce mismatch may just be due to staleness.
310                  */
311                 stale = 1;
312         }
313
314         setup_auth_srv(pool, &auth_server, auth);
315
316         store_auth(auth);
317
318         authed = pjsip_auth_srv_verify(&auth_server, rdata, &response_code);
319
320         remove_auth();
321
322         if (authed == PJ_SUCCESS) {
323                 if (stale) {
324                         return AUTH_STALE;
325                 } else {
326                         return AUTH_SUCCESS;
327                 }
328         }
329         return AUTH_FAIL;
330 }
331
332 /*!
333  * \brief astobj2 callback for adding digest challenges to responses
334  *
335  * \param auth The ast_aip_auth to build a challenge from
336  * \param tdata The response to add the challenge to
337  * \param rdata The request the challenge is in response to
338  * \param is_stale Indicates whether nonce on incoming request was stale
339  */
340 static void challenge(const struct ast_sip_auth *auth, pjsip_tx_data *tdata, const pjsip_rx_data *rdata, int is_stale)
341 {
342         pj_str_t qop;
343         pj_str_t pj_nonce;
344         pjsip_auth_srv auth_server;
345         struct ast_str *nonce = ast_str_alloca(256);
346         char time_buf[32];
347         time_t timestamp = time(NULL);
348         snprintf(time_buf, sizeof(time_buf), "%d", (int) timestamp);
349
350         build_nonce(&nonce, time_buf, rdata, auth->realm);
351
352         setup_auth_srv(tdata->pool, &auth_server, auth);
353
354         pj_cstr(&pj_nonce, ast_str_buffer(nonce));
355         pj_cstr(&qop, "auth");
356         pjsip_auth_srv_challenge(&auth_server, &qop, &pj_nonce, NULL, is_stale ? PJ_TRUE : PJ_FALSE, tdata);
357 }
358
359 /*!
360  * \brief Check authentication using Digest scheme
361  *
362  * This function will check an incoming message against configured authentication
363  * options. If \b any of the incoming Authorization headers result in successful
364  * authentication, then authentication is considered successful.
365  * 
366  * \see ast_sip_check_authentication
367  */
368 static enum ast_sip_check_auth_result digest_check_auth(struct ast_sip_endpoint *endpoint,
369                 pjsip_rx_data *rdata, pjsip_tx_data *tdata)
370 {
371         struct ast_sip_auth **auths = ast_alloca(endpoint->num_inbound_auths * sizeof(*auths));
372         enum digest_verify_result *verify_res = ast_alloca(endpoint->num_inbound_auths * sizeof(*verify_res));
373         enum ast_sip_check_auth_result res;
374         int i;
375
376         if (!auths) {
377                 return AST_SIP_AUTHENTICATION_ERROR;
378         }
379
380         if (ast_sip_retrieve_auths(endpoint->sip_inbound_auths, endpoint->num_inbound_auths, auths)) {
381                 res = AST_SIP_AUTHENTICATION_ERROR;
382                 goto cleanup;
383         }
384
385         for (i = 0; i < endpoint->num_inbound_auths; ++i) {
386                 verify_res[i] = verify(auths[i], rdata, tdata->pool);
387                 if (verify_res[i] == AUTH_SUCCESS) {
388                         res = AST_SIP_AUTHENTICATION_SUCCESS;
389                         goto cleanup;
390                 }
391         }
392
393         for (i = 0; i < endpoint->num_inbound_auths; ++i) {
394                 challenge(auths[i], tdata, rdata, verify_res[i] == AUTH_STALE);
395         }
396         
397         res = AST_SIP_AUTHENTICATION_CHALLENGE;
398
399 cleanup:
400         ast_sip_cleanup_auths(auths, endpoint->num_inbound_auths);
401         return res;
402 }
403
404 static struct ast_sip_authenticator digest_authenticator = {
405         .requires_authentication = digest_requires_authentication,
406         .check_authentication = digest_check_auth,
407 };
408
409 static int build_entity_id(void)
410 {
411         RAII_VAR(struct ast_uuid *, uu, ast_uuid_generate(), ast_free_ptr);
412         RAII_VAR(char *, eid, ao2_alloc(AST_UUID_STR_LEN, NULL), ao2_cleanup);
413
414         if (!uu || !eid) {
415                 return -1;
416         }
417
418         ast_uuid_to_str(uu, eid, AST_UUID_STR_LEN);
419         ao2_global_obj_replace_unref(entity_id, eid);
420         return 0;
421 }
422
423 static int reload_module(void)
424 {
425         if (build_entity_id()) {
426                 return -1;
427         }
428         return 0;
429 }
430
431 static int load_module(void)
432 {
433         if (build_entity_id()) {
434                 return AST_MODULE_LOAD_DECLINE;
435         }
436         if (ast_sip_register_authenticator(&digest_authenticator)) {
437                 ao2_global_obj_release(entity_id);
438                 return AST_MODULE_LOAD_DECLINE;
439         }
440         return AST_MODULE_LOAD_SUCCESS;
441 }
442
443 static int unload_module(void)
444 {
445         ast_sip_unregister_authenticator(&digest_authenticator);
446         ao2_global_obj_release(entity_id);
447         return 0;
448 }
449
450 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "SIP authentication resource",
451                 .load = load_module,
452                 .unload = unload_module,
453                 .reload = reload_module,
454                 .load_pri = AST_MODPRI_CHANNEL_DEPEND,
455 );