• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* -*- mode: C; c-file-style: "gnu" -*- */
2 /* dbus-auth.c Authentication
3  *
4  * Copyright (C) 2002, 2003, 2004 Red Hat Inc.
5  *
6  * Licensed under the Academic Free License version 2.1
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21  *
22  */
23 #include "dbus-auth.h"
24 #include "dbus-string.h"
25 #include "dbus-list.h"
26 #include "dbus-internals.h"
27 #include "dbus-keyring.h"
28 #include "dbus-sha.h"
29 #include "dbus-protocol.h"
30 #include "dbus-userdb.h"
31 
32 /**
33  * @defgroup DBusAuth Authentication
34  * @ingroup  DBusInternals
35  * @brief DBusAuth object
36  *
37  * DBusAuth manages the authentication negotiation when a connection
38  * is first established, and also manage any encryption used over a
39  * connection.
40  *
41  * @todo some SASL profiles require sending the empty string as a
42  * challenge/response, but we don't currently allow that in our
43  * protocol.
44  *
45  * @todo right now sometimes both ends will block waiting for input
46  * from the other end, e.g. if there's an error during
47  * DBUS_COOKIE_SHA1.
48  *
49  * @todo the cookie keyring needs to be cached globally not just
50  * per-auth (which raises threadsafety issues too)
51  *
52  * @todo grep FIXME in dbus-auth.c
53  */
54 
55 /**
56  * @defgroup DBusAuthInternals Authentication implementation details
57  * @ingroup  DBusInternals
58  * @brief DBusAuth implementation details
59  *
60  * Private details of authentication code.
61  *
62  * @{
63  */
64 
65 /**
66  * This function appends an initial client response to the given string
67  */
68 typedef dbus_bool_t (* DBusInitialResponseFunction)  (DBusAuth         *auth,
69                                                       DBusString       *response);
70 
71 /**
72  * This function processes a block of data received from the peer.
73  * i.e. handles a DATA command.
74  */
75 typedef dbus_bool_t (* DBusAuthDataFunction)     (DBusAuth         *auth,
76                                                   const DBusString *data);
77 
78 /**
79  * This function encodes a block of data from the peer.
80  */
81 typedef dbus_bool_t (* DBusAuthEncodeFunction)   (DBusAuth         *auth,
82                                                   const DBusString *data,
83                                                   DBusString       *encoded);
84 
85 /**
86  * This function decodes a block of data from the peer.
87  */
88 typedef dbus_bool_t (* DBusAuthDecodeFunction)   (DBusAuth         *auth,
89                                                   const DBusString *data,
90                                                   DBusString       *decoded);
91 
92 /**
93  * This function is called when the mechanism is abandoned.
94  */
95 typedef void        (* DBusAuthShutdownFunction) (DBusAuth       *auth);
96 
97 /**
98  * Virtual table representing a particular auth mechanism.
99  */
100 typedef struct
101 {
102   const char *mechanism; /**< Name of the mechanism */
103   DBusAuthDataFunction server_data_func; /**< Function on server side for DATA */
104   DBusAuthEncodeFunction server_encode_func; /**< Function on server side to encode */
105   DBusAuthDecodeFunction server_decode_func; /**< Function on server side to decode */
106   DBusAuthShutdownFunction server_shutdown_func; /**< Function on server side to shut down */
107   DBusInitialResponseFunction client_initial_response_func; /**< Function on client side to handle initial response */
108   DBusAuthDataFunction client_data_func; /**< Function on client side for DATA */
109   DBusAuthEncodeFunction client_encode_func; /**< Function on client side for encode */
110   DBusAuthDecodeFunction client_decode_func; /**< Function on client side for decode */
111   DBusAuthShutdownFunction client_shutdown_func; /**< Function on client side for shutdown */
112 } DBusAuthMechanismHandler;
113 
114 /**
115  * Enumeration for the known authentication commands.
116  */
117 typedef enum {
118   DBUS_AUTH_COMMAND_AUTH,
119   DBUS_AUTH_COMMAND_CANCEL,
120   DBUS_AUTH_COMMAND_DATA,
121   DBUS_AUTH_COMMAND_BEGIN,
122   DBUS_AUTH_COMMAND_REJECTED,
123   DBUS_AUTH_COMMAND_OK,
124   DBUS_AUTH_COMMAND_ERROR,
125   DBUS_AUTH_COMMAND_UNKNOWN
126 } DBusAuthCommand;
127 
128 /**
129  * Auth state function, determines the reaction to incoming events for
130  * a particular state. Returns whether we had enough memory to
131  * complete the operation.
132  */
133 typedef dbus_bool_t (* DBusAuthStateFunction) (DBusAuth         *auth,
134                                                DBusAuthCommand   command,
135                                                const DBusString *args);
136 
137 /**
138  * Information about a auth state.
139  */
140 typedef struct
141 {
142   const char *name;               /**< Name of the state */
143   DBusAuthStateFunction handler;  /**< State function for this state */
144 } DBusAuthStateData;
145 
146 /**
147  * Internal members of DBusAuth.
148  */
149 struct DBusAuth
150 {
151   int refcount;           /**< reference count */
152   const char *side;       /**< Client or server */
153 
154   DBusString incoming;    /**< Incoming data buffer */
155   DBusString outgoing;    /**< Outgoing data buffer */
156 
157   const DBusAuthStateData *state;         /**< Current protocol state */
158 
159   const DBusAuthMechanismHandler *mech;   /**< Current auth mechanism */
160 
161   DBusString identity;                   /**< Current identity we're authorizing
162                                           *   as.
163                                           */
164 
165   DBusCredentials credentials;      /**< Credentials read from socket,
166                                      * fields may be -1
167                                      */
168 
169   DBusCredentials authorized_identity; /**< Credentials that are authorized */
170 
171   DBusCredentials desired_identity;    /**< Identity client has requested */
172 
173   DBusString context;               /**< Cookie scope */
174   DBusKeyring *keyring;             /**< Keyring for cookie mechanism. */
175   int cookie_id;                    /**< ID of cookie to use */
176   DBusString challenge;             /**< Challenge sent to client */
177 
178   char **allowed_mechs;             /**< Mechanisms we're allowed to use,
179                                      * or #NULL if we can use any
180                                      */
181 
182   unsigned int needed_memory : 1;   /**< We needed memory to continue since last
183                                      * successful getting something done
184                                      */
185   unsigned int already_got_mechanisms : 1;       /**< Client already got mech list */
186   unsigned int already_asked_for_initial_response : 1; /**< Already sent a blank challenge to get an initial response */
187   unsigned int buffer_outstanding : 1; /**< Buffer is "checked out" for reading data into */
188 };
189 
190 /**
191  * "Subclass" of DBusAuth for client side
192  */
193 typedef struct
194 {
195   DBusAuth base;    /**< Parent class */
196 
197   DBusList *mechs_to_try; /**< Mechanisms we got from the server that we're going to try using */
198 
199   DBusString guid_from_server; /**< GUID received from server */
200 
201 } DBusAuthClient;
202 
203 /**
204  * "Subclass" of DBusAuth for server side.
205  */
206 typedef struct
207 {
208   DBusAuth base;    /**< Parent class */
209 
210   int failures;     /**< Number of times client has been rejected */
211   int max_failures; /**< Number of times we reject before disconnect */
212 
213   DBusString guid;  /**< Our globally unique ID in hex encoding */
214 
215 } DBusAuthServer;
216 
217 static void        goto_state                (DBusAuth                       *auth,
218                                               const DBusAuthStateData        *new_state);
219 static dbus_bool_t send_auth                 (DBusAuth *auth,
220                                               const DBusAuthMechanismHandler *mech);
221 static dbus_bool_t send_data                 (DBusAuth *auth,
222                                               DBusString *data);
223 static dbus_bool_t send_rejected             (DBusAuth *auth);
224 static dbus_bool_t send_error                (DBusAuth *auth,
225                                               const char *message);
226 static dbus_bool_t send_ok                   (DBusAuth *auth);
227 static dbus_bool_t send_begin                (DBusAuth *auth,
228                                               const DBusString *args_from_ok);
229 static dbus_bool_t send_cancel               (DBusAuth *auth);
230 
231 /**
232  * Client states
233  */
234 
235 static dbus_bool_t handle_server_state_waiting_for_auth  (DBusAuth         *auth,
236                                                           DBusAuthCommand   command,
237                                                           const DBusString *args);
238 static dbus_bool_t handle_server_state_waiting_for_data  (DBusAuth         *auth,
239                                                           DBusAuthCommand   command,
240                                                           const DBusString *args);
241 static dbus_bool_t handle_server_state_waiting_for_begin (DBusAuth         *auth,
242                                                           DBusAuthCommand   command,
243                                                           const DBusString *args);
244 
245 static const DBusAuthStateData server_state_waiting_for_auth = {
246   "WaitingForAuth", handle_server_state_waiting_for_auth
247 };
248 static const DBusAuthStateData server_state_waiting_for_data = {
249   "WaitingForData", handle_server_state_waiting_for_data
250 };
251 static const DBusAuthStateData server_state_waiting_for_begin = {
252   "WaitingForBegin", handle_server_state_waiting_for_begin
253 };
254 
255 /**
256  * Client states
257  */
258 
259 static dbus_bool_t handle_client_state_waiting_for_data   (DBusAuth         *auth,
260                                                            DBusAuthCommand   command,
261                                                            const DBusString *args);
262 static dbus_bool_t handle_client_state_waiting_for_ok     (DBusAuth         *auth,
263                                                            DBusAuthCommand   command,
264                                                            const DBusString *args);
265 static dbus_bool_t handle_client_state_waiting_for_reject (DBusAuth         *auth,
266                                                            DBusAuthCommand   command,
267                                                            const DBusString *args);
268 
269 static const DBusAuthStateData client_state_need_send_auth = {
270   "NeedSendAuth", NULL
271 };
272 static const DBusAuthStateData client_state_waiting_for_data = {
273   "WaitingForData", handle_client_state_waiting_for_data
274 };
275 static const DBusAuthStateData client_state_waiting_for_ok = {
276   "WaitingForOK", handle_client_state_waiting_for_ok
277 };
278 static const DBusAuthStateData client_state_waiting_for_reject = {
279   "WaitingForReject", handle_client_state_waiting_for_reject
280 };
281 
282 /**
283  * Common terminal states.  Terminal states have handler == NULL.
284  */
285 
286 static const DBusAuthStateData common_state_authenticated = {
287   "Authenticated",  NULL
288 };
289 
290 static const DBusAuthStateData common_state_need_disconnect = {
291   "NeedDisconnect",  NULL
292 };
293 
294 static const char auth_side_client[] = "client";
295 static const char auth_side_server[] = "server";
296 /**
297  * @param auth the auth conversation
298  * @returns #TRUE if the conversation is the server side
299  */
300 #define DBUS_AUTH_IS_SERVER(auth) ((auth)->side == auth_side_server)
301 /**
302  * @param auth the auth conversation
303  * @returns #TRUE if the conversation is the client side
304  */
305 #define DBUS_AUTH_IS_CLIENT(auth) ((auth)->side == auth_side_client)
306 /**
307  * @param auth the auth conversation
308  * @returns auth cast to DBusAuthClient
309  */
310 #define DBUS_AUTH_CLIENT(auth)    ((DBusAuthClient*)(auth))
311 /**
312  * @param auth the auth conversation
313  * @returns auth cast to DBusAuthServer
314  */
315 #define DBUS_AUTH_SERVER(auth)    ((DBusAuthServer*)(auth))
316 
317 /**
318  * The name of the auth ("client" or "server")
319  * @param auth the auth conversation
320  * @returns a string
321  */
322 #define DBUS_AUTH_NAME(auth)      ((auth)->side)
323 
324 static DBusAuth*
_dbus_auth_new(int size)325 _dbus_auth_new (int size)
326 {
327   DBusAuth *auth;
328 
329   auth = dbus_malloc0 (size);
330   if (auth == NULL)
331     return NULL;
332 
333   auth->refcount = 1;
334 
335   _dbus_credentials_clear (&auth->credentials);
336   _dbus_credentials_clear (&auth->authorized_identity);
337   _dbus_credentials_clear (&auth->desired_identity);
338 
339   auth->keyring = NULL;
340   auth->cookie_id = -1;
341 
342   /* note that we don't use the max string length feature,
343    * because you can't use that feature if you're going to
344    * try to recover from out-of-memory (it creates
345    * what looks like unrecoverable inability to alloc
346    * more space in the string). But we do handle
347    * overlong buffers in _dbus_auth_do_work().
348    */
349 
350   if (!_dbus_string_init (&auth->incoming))
351     goto enomem_0;
352 
353   if (!_dbus_string_init (&auth->outgoing))
354     goto enomem_1;
355 
356   if (!_dbus_string_init (&auth->identity))
357     goto enomem_2;
358 
359   if (!_dbus_string_init (&auth->context))
360     goto enomem_3;
361 
362   if (!_dbus_string_init (&auth->challenge))
363     goto enomem_4;
364 
365   /* default context if none is specified */
366   if (!_dbus_string_append (&auth->context, "org_freedesktop_general"))
367     goto enomem_5;
368 
369   return auth;
370 
371  enomem_5:
372   _dbus_string_free (&auth->challenge);
373  enomem_4:
374   _dbus_string_free (&auth->context);
375  enomem_3:
376   _dbus_string_free (&auth->identity);
377  enomem_2:
378   _dbus_string_free (&auth->outgoing);
379  enomem_1:
380   _dbus_string_free (&auth->incoming);
381  enomem_0:
382   dbus_free (auth);
383   return NULL;
384 }
385 
386 static void
shutdown_mech(DBusAuth * auth)387 shutdown_mech (DBusAuth *auth)
388 {
389   /* Cancel any auth */
390   auth->already_asked_for_initial_response = FALSE;
391   _dbus_string_set_length (&auth->identity, 0);
392 
393   _dbus_credentials_clear (&auth->authorized_identity);
394   _dbus_credentials_clear (&auth->desired_identity);
395 
396   if (auth->mech != NULL)
397     {
398       _dbus_verbose ("%s: Shutting down mechanism %s\n",
399                      DBUS_AUTH_NAME (auth), auth->mech->mechanism);
400 
401       if (DBUS_AUTH_IS_CLIENT (auth))
402         (* auth->mech->client_shutdown_func) (auth);
403       else
404         (* auth->mech->server_shutdown_func) (auth);
405 
406       auth->mech = NULL;
407     }
408 }
409 
410 /* Returns TRUE but with an empty string hash if the
411  * cookie_id isn't known. As with all this code
412  * TRUE just means we had enough memory.
413  */
414 static dbus_bool_t
sha1_compute_hash(DBusAuth * auth,int cookie_id,const DBusString * server_challenge,const DBusString * client_challenge,DBusString * hash)415 sha1_compute_hash (DBusAuth         *auth,
416                    int               cookie_id,
417                    const DBusString *server_challenge,
418                    const DBusString *client_challenge,
419                    DBusString       *hash)
420 {
421   DBusString cookie;
422   DBusString to_hash;
423   dbus_bool_t retval;
424 
425   _dbus_assert (auth->keyring != NULL);
426 
427   retval = FALSE;
428 
429   if (!_dbus_string_init (&cookie))
430     return FALSE;
431 
432   if (!_dbus_keyring_get_hex_key (auth->keyring, cookie_id,
433                                   &cookie))
434     goto out_0;
435 
436   if (_dbus_string_get_length (&cookie) == 0)
437     {
438       retval = TRUE;
439       goto out_0;
440     }
441 
442   if (!_dbus_string_init (&to_hash))
443     goto out_0;
444 
445   if (!_dbus_string_copy (server_challenge, 0,
446                           &to_hash, _dbus_string_get_length (&to_hash)))
447     goto out_1;
448 
449   if (!_dbus_string_append (&to_hash, ":"))
450     goto out_1;
451 
452   if (!_dbus_string_copy (client_challenge, 0,
453                           &to_hash, _dbus_string_get_length (&to_hash)))
454     goto out_1;
455 
456   if (!_dbus_string_append (&to_hash, ":"))
457     goto out_1;
458 
459   if (!_dbus_string_copy (&cookie, 0,
460                           &to_hash, _dbus_string_get_length (&to_hash)))
461     goto out_1;
462 
463   if (!_dbus_sha_compute (&to_hash, hash))
464     goto out_1;
465 
466   retval = TRUE;
467 
468  out_1:
469   _dbus_string_zero (&to_hash);
470   _dbus_string_free (&to_hash);
471  out_0:
472   _dbus_string_zero (&cookie);
473   _dbus_string_free (&cookie);
474   return retval;
475 }
476 
477 /** http://www.ietf.org/rfc/rfc2831.txt suggests at least 64 bits of
478  * entropy, we use 128. This is the number of bytes in the random
479  * challenge.
480  */
481 #define N_CHALLENGE_BYTES (128/8)
482 
483 static dbus_bool_t
sha1_handle_first_client_response(DBusAuth * auth,const DBusString * data)484 sha1_handle_first_client_response (DBusAuth         *auth,
485                                    const DBusString *data)
486 {
487   /* We haven't sent a challenge yet, we're expecting a desired
488    * username from the client.
489    */
490   DBusString tmp;
491   DBusString tmp2;
492   dbus_bool_t retval;
493   DBusError error;
494 
495   retval = FALSE;
496 
497   _dbus_string_set_length (&auth->challenge, 0);
498 
499   if (_dbus_string_get_length (data) > 0)
500     {
501       if (_dbus_string_get_length (&auth->identity) > 0)
502         {
503           /* Tried to send two auth identities, wtf */
504           _dbus_verbose ("%s: client tried to send auth identity, but we already have one\n",
505                          DBUS_AUTH_NAME (auth));
506           return send_rejected (auth);
507         }
508       else
509         {
510           /* this is our auth identity */
511           if (!_dbus_string_copy (data, 0, &auth->identity, 0))
512             return FALSE;
513         }
514     }
515 
516   if (!_dbus_credentials_from_username (data, &auth->desired_identity))
517     {
518       _dbus_verbose ("%s: Did not get a valid username from client\n",
519                      DBUS_AUTH_NAME (auth));
520       return send_rejected (auth);
521     }
522 
523   if (!_dbus_string_init (&tmp))
524     return FALSE;
525 
526   if (!_dbus_string_init (&tmp2))
527     {
528       _dbus_string_free (&tmp);
529       return FALSE;
530     }
531 
532   /* we cache the keyring for speed, so here we drop it if it's the
533    * wrong one. FIXME caching the keyring here is useless since we use
534    * a different DBusAuth for every connection.
535    */
536   if (auth->keyring &&
537       !_dbus_keyring_is_for_user (auth->keyring,
538                                   data))
539     {
540       _dbus_keyring_unref (auth->keyring);
541       auth->keyring = NULL;
542     }
543 
544   if (auth->keyring == NULL)
545     {
546       dbus_error_init (&error);
547       auth->keyring = _dbus_keyring_new_homedir (data,
548                                                  &auth->context,
549                                                  &error);
550 
551       if (auth->keyring == NULL)
552         {
553           if (dbus_error_has_name (&error,
554                                    DBUS_ERROR_NO_MEMORY))
555             {
556               dbus_error_free (&error);
557               goto out;
558             }
559           else
560             {
561               _DBUS_ASSERT_ERROR_IS_SET (&error);
562               _dbus_verbose ("%s: Error loading keyring: %s\n",
563                              DBUS_AUTH_NAME (auth), error.message);
564               if (send_rejected (auth))
565                 retval = TRUE; /* retval is only about mem */
566               dbus_error_free (&error);
567               goto out;
568             }
569         }
570       else
571         {
572           _dbus_assert (!dbus_error_is_set (&error));
573         }
574     }
575 
576   _dbus_assert (auth->keyring != NULL);
577 
578   dbus_error_init (&error);
579   auth->cookie_id = _dbus_keyring_get_best_key (auth->keyring, &error);
580   if (auth->cookie_id < 0)
581     {
582       _DBUS_ASSERT_ERROR_IS_SET (&error);
583       _dbus_verbose ("%s: Could not get a cookie ID to send to client: %s\n",
584                      DBUS_AUTH_NAME (auth), error.message);
585       if (send_rejected (auth))
586         retval = TRUE;
587       dbus_error_free (&error);
588       goto out;
589     }
590   else
591     {
592       _dbus_assert (!dbus_error_is_set (&error));
593     }
594 
595   if (!_dbus_string_copy (&auth->context, 0,
596                           &tmp2, _dbus_string_get_length (&tmp2)))
597     goto out;
598 
599   if (!_dbus_string_append (&tmp2, " "))
600     goto out;
601 
602   if (!_dbus_string_append_int (&tmp2, auth->cookie_id))
603     goto out;
604 
605   if (!_dbus_string_append (&tmp2, " "))
606     goto out;
607 
608   if (!_dbus_generate_random_bytes (&tmp, N_CHALLENGE_BYTES))
609     goto out;
610 
611   _dbus_string_set_length (&auth->challenge, 0);
612   if (!_dbus_string_hex_encode (&tmp, 0, &auth->challenge, 0))
613     goto out;
614 
615   if (!_dbus_string_hex_encode (&tmp, 0, &tmp2,
616                                 _dbus_string_get_length (&tmp2)))
617     goto out;
618 
619   if (!send_data (auth, &tmp2))
620     goto out;
621 
622   goto_state (auth, &server_state_waiting_for_data);
623   retval = TRUE;
624 
625  out:
626   _dbus_string_zero (&tmp);
627   _dbus_string_free (&tmp);
628   _dbus_string_zero (&tmp2);
629   _dbus_string_free (&tmp2);
630 
631   return retval;
632 }
633 
634 static dbus_bool_t
sha1_handle_second_client_response(DBusAuth * auth,const DBusString * data)635 sha1_handle_second_client_response (DBusAuth         *auth,
636                                     const DBusString *data)
637 {
638   /* We are expecting a response which is the hex-encoded client
639    * challenge, space, then SHA-1 hash of the concatenation of our
640    * challenge, ":", client challenge, ":", secret key, all
641    * hex-encoded.
642    */
643   int i;
644   DBusString client_challenge;
645   DBusString client_hash;
646   dbus_bool_t retval;
647   DBusString correct_hash;
648 
649   retval = FALSE;
650 
651   if (!_dbus_string_find_blank (data, 0, &i))
652     {
653       _dbus_verbose ("%s: no space separator in client response\n",
654                      DBUS_AUTH_NAME (auth));
655       return send_rejected (auth);
656     }
657 
658   if (!_dbus_string_init (&client_challenge))
659     goto out_0;
660 
661   if (!_dbus_string_init (&client_hash))
662     goto out_1;
663 
664   if (!_dbus_string_copy_len (data, 0, i, &client_challenge,
665                               0))
666     goto out_2;
667 
668   _dbus_string_skip_blank (data, i, &i);
669 
670   if (!_dbus_string_copy_len (data, i,
671                               _dbus_string_get_length (data) - i,
672                               &client_hash,
673                               0))
674     goto out_2;
675 
676   if (_dbus_string_get_length (&client_challenge) == 0 ||
677       _dbus_string_get_length (&client_hash) == 0)
678     {
679       _dbus_verbose ("%s: zero-length client challenge or hash\n",
680                      DBUS_AUTH_NAME (auth));
681       if (send_rejected (auth))
682         retval = TRUE;
683       goto out_2;
684     }
685 
686   if (!_dbus_string_init (&correct_hash))
687     goto out_2;
688 
689   if (!sha1_compute_hash (auth, auth->cookie_id,
690                           &auth->challenge,
691                           &client_challenge,
692                           &correct_hash))
693     goto out_3;
694 
695   /* if cookie_id was invalid, then we get an empty hash */
696   if (_dbus_string_get_length (&correct_hash) == 0)
697     {
698       if (send_rejected (auth))
699         retval = TRUE;
700       goto out_3;
701     }
702 
703   if (!_dbus_string_equal (&client_hash, &correct_hash))
704     {
705       if (send_rejected (auth))
706         retval = TRUE;
707       goto out_3;
708     }
709 
710   if (!send_ok (auth))
711     goto out_3;
712 
713   _dbus_verbose ("%s: authenticated client with UID "DBUS_UID_FORMAT" using DBUS_COOKIE_SHA1\n",
714                  DBUS_AUTH_NAME (auth), auth->desired_identity.uid);
715 
716   auth->authorized_identity = auth->desired_identity;
717   retval = TRUE;
718 
719  out_3:
720   _dbus_string_zero (&correct_hash);
721   _dbus_string_free (&correct_hash);
722  out_2:
723   _dbus_string_zero (&client_hash);
724   _dbus_string_free (&client_hash);
725  out_1:
726   _dbus_string_free (&client_challenge);
727  out_0:
728   return retval;
729 }
730 
731 static dbus_bool_t
handle_server_data_cookie_sha1_mech(DBusAuth * auth,const DBusString * data)732 handle_server_data_cookie_sha1_mech (DBusAuth         *auth,
733                                      const DBusString *data)
734 {
735   if (auth->cookie_id < 0)
736     return sha1_handle_first_client_response (auth, data);
737   else
738     return sha1_handle_second_client_response (auth, data);
739 }
740 
741 static void
handle_server_shutdown_cookie_sha1_mech(DBusAuth * auth)742 handle_server_shutdown_cookie_sha1_mech (DBusAuth *auth)
743 {
744   auth->cookie_id = -1;
745   _dbus_string_set_length (&auth->challenge, 0);
746 }
747 
748 static dbus_bool_t
handle_client_initial_response_cookie_sha1_mech(DBusAuth * auth,DBusString * response)749 handle_client_initial_response_cookie_sha1_mech (DBusAuth   *auth,
750                                                  DBusString *response)
751 {
752   const DBusString *username;
753   dbus_bool_t retval;
754 
755   retval = FALSE;
756 
757   if (!_dbus_username_from_current_process (&username))
758     goto out_0;
759 
760   if (!_dbus_string_hex_encode (username, 0,
761 				response,
762 				_dbus_string_get_length (response)))
763     goto out_0;
764 
765   retval = TRUE;
766 
767  out_0:
768   return retval;
769 }
770 
771 static dbus_bool_t
handle_client_data_cookie_sha1_mech(DBusAuth * auth,const DBusString * data)772 handle_client_data_cookie_sha1_mech (DBusAuth         *auth,
773                                      const DBusString *data)
774 {
775   /* The data we get from the server should be the cookie context
776    * name, the cookie ID, and the server challenge, separated by
777    * spaces. We send back our challenge string and the correct hash.
778    */
779   dbus_bool_t retval;
780   DBusString context;
781   DBusString cookie_id_str;
782   DBusString server_challenge;
783   DBusString client_challenge;
784   DBusString correct_hash;
785   DBusString tmp;
786   int i, j;
787   long val;
788 
789   retval = FALSE;
790 
791   if (!_dbus_string_find_blank (data, 0, &i))
792     {
793       if (send_error (auth,
794                       "Server did not send context/ID/challenge properly"))
795         retval = TRUE;
796       goto out_0;
797     }
798 
799   if (!_dbus_string_init (&context))
800     goto out_0;
801 
802   if (!_dbus_string_copy_len (data, 0, i,
803                               &context, 0))
804     goto out_1;
805 
806   _dbus_string_skip_blank (data, i, &i);
807   if (!_dbus_string_find_blank (data, i, &j))
808     {
809       if (send_error (auth,
810                       "Server did not send context/ID/challenge properly"))
811         retval = TRUE;
812       goto out_1;
813     }
814 
815   if (!_dbus_string_init (&cookie_id_str))
816     goto out_1;
817 
818   if (!_dbus_string_copy_len (data, i, j - i,
819                               &cookie_id_str, 0))
820     goto out_2;
821 
822   if (!_dbus_string_init (&server_challenge))
823     goto out_2;
824 
825   i = j;
826   _dbus_string_skip_blank (data, i, &i);
827   j = _dbus_string_get_length (data);
828 
829   if (!_dbus_string_copy_len (data, i, j - i,
830                               &server_challenge, 0))
831     goto out_3;
832 
833   if (!_dbus_keyring_validate_context (&context))
834     {
835       if (send_error (auth, "Server sent invalid cookie context"))
836         retval = TRUE;
837       goto out_3;
838     }
839 
840   if (!_dbus_string_parse_int (&cookie_id_str, 0, &val, NULL))
841     {
842       if (send_error (auth, "Could not parse cookie ID as an integer"))
843         retval = TRUE;
844       goto out_3;
845     }
846 
847   if (_dbus_string_get_length (&server_challenge) == 0)
848     {
849       if (send_error (auth, "Empty server challenge string"))
850         retval = TRUE;
851       goto out_3;
852     }
853 
854   if (auth->keyring == NULL)
855     {
856       DBusError error;
857 
858       dbus_error_init (&error);
859       auth->keyring = _dbus_keyring_new_homedir (NULL,
860                                                  &context,
861                                                  &error);
862 
863       if (auth->keyring == NULL)
864         {
865           if (dbus_error_has_name (&error,
866                                    DBUS_ERROR_NO_MEMORY))
867             {
868               dbus_error_free (&error);
869               goto out_3;
870             }
871           else
872             {
873               _DBUS_ASSERT_ERROR_IS_SET (&error);
874 
875               _dbus_verbose ("%s: Error loading keyring: %s\n",
876                              DBUS_AUTH_NAME (auth), error.message);
877 
878               if (send_error (auth, "Could not load cookie file"))
879                 retval = TRUE; /* retval is only about mem */
880 
881               dbus_error_free (&error);
882               goto out_3;
883             }
884         }
885       else
886         {
887           _dbus_assert (!dbus_error_is_set (&error));
888         }
889     }
890 
891   _dbus_assert (auth->keyring != NULL);
892 
893   if (!_dbus_string_init (&tmp))
894     goto out_3;
895 
896   if (!_dbus_generate_random_bytes (&tmp, N_CHALLENGE_BYTES))
897     goto out_4;
898 
899   if (!_dbus_string_init (&client_challenge))
900     goto out_4;
901 
902   if (!_dbus_string_hex_encode (&tmp, 0, &client_challenge, 0))
903     goto out_5;
904 
905   if (!_dbus_string_init (&correct_hash))
906     goto out_5;
907 
908   if (!sha1_compute_hash (auth, val,
909                           &server_challenge,
910                           &client_challenge,
911                           &correct_hash))
912     goto out_6;
913 
914   if (_dbus_string_get_length (&correct_hash) == 0)
915     {
916       /* couldn't find the cookie ID or something */
917       if (send_error (auth, "Don't have the requested cookie ID"))
918         retval = TRUE;
919       goto out_6;
920     }
921 
922   _dbus_string_set_length (&tmp, 0);
923 
924   if (!_dbus_string_copy (&client_challenge, 0, &tmp,
925                           _dbus_string_get_length (&tmp)))
926     goto out_6;
927 
928   if (!_dbus_string_append (&tmp, " "))
929     goto out_6;
930 
931   if (!_dbus_string_copy (&correct_hash, 0, &tmp,
932                           _dbus_string_get_length (&tmp)))
933     goto out_6;
934 
935   if (!send_data (auth, &tmp))
936     goto out_6;
937 
938   retval = TRUE;
939 
940  out_6:
941   _dbus_string_zero (&correct_hash);
942   _dbus_string_free (&correct_hash);
943  out_5:
944   _dbus_string_free (&client_challenge);
945  out_4:
946   _dbus_string_zero (&tmp);
947   _dbus_string_free (&tmp);
948  out_3:
949   _dbus_string_free (&server_challenge);
950  out_2:
951   _dbus_string_free (&cookie_id_str);
952  out_1:
953   _dbus_string_free (&context);
954  out_0:
955   return retval;
956 }
957 
958 static void
handle_client_shutdown_cookie_sha1_mech(DBusAuth * auth)959 handle_client_shutdown_cookie_sha1_mech (DBusAuth *auth)
960 {
961   auth->cookie_id = -1;
962   _dbus_string_set_length (&auth->challenge, 0);
963 }
964 
965 static dbus_bool_t
handle_server_data_external_mech(DBusAuth * auth,const DBusString * data)966 handle_server_data_external_mech (DBusAuth         *auth,
967                                   const DBusString *data)
968 {
969   if (auth->credentials.uid == DBUS_UID_UNSET)
970     {
971       _dbus_verbose ("%s: no credentials, mechanism EXTERNAL can't authenticate\n",
972                      DBUS_AUTH_NAME (auth));
973       return send_rejected (auth);
974     }
975 
976   if (_dbus_string_get_length (data) > 0)
977     {
978       if (_dbus_string_get_length (&auth->identity) > 0)
979         {
980           /* Tried to send two auth identities, wtf */
981           _dbus_verbose ("%s: client tried to send auth identity, but we already have one\n",
982                          DBUS_AUTH_NAME (auth));
983           return send_rejected (auth);
984         }
985       else
986         {
987           /* this is our auth identity */
988           if (!_dbus_string_copy (data, 0, &auth->identity, 0))
989             return FALSE;
990         }
991     }
992 
993   /* Poke client for an auth identity, if none given */
994   if (_dbus_string_get_length (&auth->identity) == 0 &&
995       !auth->already_asked_for_initial_response)
996     {
997       if (send_data (auth, NULL))
998         {
999           _dbus_verbose ("%s: sending empty challenge asking client for auth identity\n",
1000                          DBUS_AUTH_NAME (auth));
1001           auth->already_asked_for_initial_response = TRUE;
1002           return TRUE;
1003         }
1004       else
1005         return FALSE;
1006     }
1007 
1008   _dbus_credentials_clear (&auth->desired_identity);
1009 
1010   /* If auth->identity is still empty here, then client
1011    * responded with an empty string after we poked it for
1012    * an initial response. This means to try to auth the
1013    * identity provided in the credentials.
1014    */
1015   if (_dbus_string_get_length (&auth->identity) == 0)
1016     {
1017       auth->desired_identity.uid = auth->credentials.uid;
1018     }
1019   else
1020     {
1021       if (!_dbus_parse_uid (&auth->identity,
1022                             &auth->desired_identity.uid))
1023         {
1024           _dbus_verbose ("%s: could not get credentials from uid string\n",
1025                          DBUS_AUTH_NAME (auth));
1026           return send_rejected (auth);
1027         }
1028     }
1029 
1030   if (auth->desired_identity.uid == DBUS_UID_UNSET)
1031     {
1032       _dbus_verbose ("%s: desired user %s is no good\n",
1033                      DBUS_AUTH_NAME (auth),
1034                      _dbus_string_get_const_data (&auth->identity));
1035       return send_rejected (auth);
1036     }
1037 
1038   if (_dbus_credentials_match (&auth->desired_identity,
1039                                &auth->credentials))
1040     {
1041       /* client has authenticated */
1042       if (!send_ok (auth))
1043         return FALSE;
1044 
1045       _dbus_verbose ("%s: authenticated client with UID "DBUS_UID_FORMAT
1046                      " matching socket credentials UID "DBUS_UID_FORMAT"\n",
1047                      DBUS_AUTH_NAME (auth),
1048                      auth->desired_identity.uid,
1049                      auth->credentials.uid);
1050 
1051       auth->authorized_identity.pid = auth->credentials.pid;
1052       auth->authorized_identity.uid = auth->desired_identity.uid;
1053       return TRUE;
1054     }
1055   else
1056     {
1057       _dbus_verbose ("%s: credentials uid="DBUS_UID_FORMAT
1058                      " gid="DBUS_GID_FORMAT
1059                      " do not allow uid="DBUS_UID_FORMAT
1060                      " gid="DBUS_GID_FORMAT"\n",
1061                      DBUS_AUTH_NAME (auth),
1062                      auth->credentials.uid, auth->credentials.gid,
1063                      auth->desired_identity.uid, auth->desired_identity.gid);
1064       return send_rejected (auth);
1065     }
1066 }
1067 
1068 static void
handle_server_shutdown_external_mech(DBusAuth * auth)1069 handle_server_shutdown_external_mech (DBusAuth *auth)
1070 {
1071 
1072 }
1073 
1074 static dbus_bool_t
handle_client_initial_response_external_mech(DBusAuth * auth,DBusString * response)1075 handle_client_initial_response_external_mech (DBusAuth         *auth,
1076                                               DBusString       *response)
1077 {
1078   /* We always append our UID as an initial response, so the server
1079    * doesn't have to send back an empty challenge to check whether we
1080    * want to specify an identity. i.e. this avoids a round trip that
1081    * the spec for the EXTERNAL mechanism otherwise requires.
1082    */
1083   DBusString plaintext;
1084 
1085   if (!_dbus_string_init (&plaintext))
1086     return FALSE;
1087 
1088   if (!_dbus_string_append_uint (&plaintext,
1089                                  _dbus_getuid ()))
1090     goto failed;
1091 
1092   if (!_dbus_string_hex_encode (&plaintext, 0,
1093 				response,
1094 				_dbus_string_get_length (response)))
1095     goto failed;
1096 
1097   _dbus_string_free (&plaintext);
1098 
1099   return TRUE;
1100 
1101  failed:
1102   _dbus_string_free (&plaintext);
1103   return FALSE;
1104 }
1105 
1106 static dbus_bool_t
handle_client_data_external_mech(DBusAuth * auth,const DBusString * data)1107 handle_client_data_external_mech (DBusAuth         *auth,
1108                                   const DBusString *data)
1109 {
1110 
1111   return TRUE;
1112 }
1113 
1114 static void
handle_client_shutdown_external_mech(DBusAuth * auth)1115 handle_client_shutdown_external_mech (DBusAuth *auth)
1116 {
1117 
1118 }
1119 
1120 /* Put mechanisms here in order of preference.
1121  * What I eventually want to have is:
1122  *
1123  *  - a mechanism that checks UNIX domain socket credentials
1124  *  - a simple magic cookie mechanism like X11 or ICE
1125  *  - mechanisms that chain to Cyrus SASL, so we can use anything it
1126  *    offers such as Kerberos, X509, whatever.
1127  *
1128  */
1129 static const DBusAuthMechanismHandler
1130 all_mechanisms[] = {
1131   { "EXTERNAL",
1132     handle_server_data_external_mech,
1133     NULL, NULL,
1134     handle_server_shutdown_external_mech,
1135     handle_client_initial_response_external_mech,
1136     handle_client_data_external_mech,
1137     NULL, NULL,
1138     handle_client_shutdown_external_mech },
1139   { "DBUS_COOKIE_SHA1",
1140     handle_server_data_cookie_sha1_mech,
1141     NULL, NULL,
1142     handle_server_shutdown_cookie_sha1_mech,
1143     handle_client_initial_response_cookie_sha1_mech,
1144     handle_client_data_cookie_sha1_mech,
1145     NULL, NULL,
1146     handle_client_shutdown_cookie_sha1_mech },
1147   { NULL, NULL }
1148 };
1149 
1150 static const DBusAuthMechanismHandler*
find_mech(const DBusString * name,char ** allowed_mechs)1151 find_mech (const DBusString  *name,
1152            char             **allowed_mechs)
1153 {
1154   int i;
1155 
1156   if (allowed_mechs != NULL &&
1157       !_dbus_string_array_contains ((const char**) allowed_mechs,
1158                                     _dbus_string_get_const_data (name)))
1159     return NULL;
1160 
1161   i = 0;
1162   while (all_mechanisms[i].mechanism != NULL)
1163     {
1164       if (_dbus_string_equal_c_str (name,
1165                                     all_mechanisms[i].mechanism))
1166 
1167         return &all_mechanisms[i];
1168 
1169       ++i;
1170     }
1171 
1172   return NULL;
1173 }
1174 
1175 static dbus_bool_t
send_auth(DBusAuth * auth,const DBusAuthMechanismHandler * mech)1176 send_auth (DBusAuth *auth, const DBusAuthMechanismHandler *mech)
1177 {
1178   DBusString auth_command;
1179 
1180   if (!_dbus_string_init (&auth_command))
1181     return FALSE;
1182 
1183   if (!_dbus_string_append (&auth_command,
1184                             "AUTH "))
1185     {
1186       _dbus_string_free (&auth_command);
1187       return FALSE;
1188     }
1189 
1190   if (!_dbus_string_append (&auth_command,
1191                             mech->mechanism))
1192     {
1193       _dbus_string_free (&auth_command);
1194       return FALSE;
1195     }
1196 
1197   if (mech->client_initial_response_func != NULL)
1198     {
1199       if (!_dbus_string_append (&auth_command, " "))
1200         {
1201           _dbus_string_free (&auth_command);
1202           return FALSE;
1203         }
1204 
1205       if (!(* mech->client_initial_response_func) (auth, &auth_command))
1206         {
1207           _dbus_string_free (&auth_command);
1208           return FALSE;
1209         }
1210     }
1211 
1212   if (!_dbus_string_append (&auth_command,
1213                             "\r\n"))
1214     {
1215       _dbus_string_free (&auth_command);
1216       return FALSE;
1217     }
1218 
1219   if (!_dbus_string_copy (&auth_command, 0,
1220                           &auth->outgoing,
1221                           _dbus_string_get_length (&auth->outgoing)))
1222     {
1223       _dbus_string_free (&auth_command);
1224       return FALSE;
1225     }
1226 
1227   _dbus_string_free (&auth_command);
1228   shutdown_mech (auth);
1229   auth->mech = mech;
1230   goto_state (auth, &client_state_waiting_for_data);
1231 
1232   return TRUE;
1233 }
1234 
1235 static dbus_bool_t
send_data(DBusAuth * auth,DBusString * data)1236 send_data (DBusAuth *auth, DBusString *data)
1237 {
1238   int old_len;
1239 
1240   if (data == NULL || _dbus_string_get_length (data) == 0)
1241     return _dbus_string_append (&auth->outgoing, "DATA\r\n");
1242   else
1243     {
1244       old_len = _dbus_string_get_length (&auth->outgoing);
1245       if (!_dbus_string_append (&auth->outgoing, "DATA "))
1246         goto out;
1247 
1248       if (!_dbus_string_hex_encode (data, 0, &auth->outgoing,
1249                                     _dbus_string_get_length (&auth->outgoing)))
1250         goto out;
1251 
1252       if (!_dbus_string_append (&auth->outgoing, "\r\n"))
1253         goto out;
1254 
1255       return TRUE;
1256 
1257     out:
1258       _dbus_string_set_length (&auth->outgoing, old_len);
1259 
1260       return FALSE;
1261     }
1262 }
1263 
1264 static dbus_bool_t
send_rejected(DBusAuth * auth)1265 send_rejected (DBusAuth *auth)
1266 {
1267   DBusString command;
1268   DBusAuthServer *server_auth;
1269   int i;
1270 
1271   if (!_dbus_string_init (&command))
1272     return FALSE;
1273 
1274   if (!_dbus_string_append (&command,
1275                             "REJECTED"))
1276     goto nomem;
1277 
1278   i = 0;
1279   while (all_mechanisms[i].mechanism != NULL)
1280     {
1281       if (!_dbus_string_append (&command,
1282                                 " "))
1283         goto nomem;
1284 
1285       if (!_dbus_string_append (&command,
1286                                 all_mechanisms[i].mechanism))
1287         goto nomem;
1288 
1289       ++i;
1290     }
1291 
1292   if (!_dbus_string_append (&command, "\r\n"))
1293     goto nomem;
1294 
1295   if (!_dbus_string_copy (&command, 0, &auth->outgoing,
1296                           _dbus_string_get_length (&auth->outgoing)))
1297     goto nomem;
1298 
1299   shutdown_mech (auth);
1300 
1301   _dbus_assert (DBUS_AUTH_IS_SERVER (auth));
1302   server_auth = DBUS_AUTH_SERVER (auth);
1303   server_auth->failures += 1;
1304 
1305   if (server_auth->failures >= server_auth->max_failures)
1306     goto_state (auth, &common_state_need_disconnect);
1307   else
1308     goto_state (auth, &server_state_waiting_for_auth);
1309 
1310   _dbus_string_free (&command);
1311 
1312   return TRUE;
1313 
1314  nomem:
1315   _dbus_string_free (&command);
1316   return FALSE;
1317 }
1318 
1319 static dbus_bool_t
send_error(DBusAuth * auth,const char * message)1320 send_error (DBusAuth *auth, const char *message)
1321 {
1322   return _dbus_string_append_printf (&auth->outgoing,
1323                                      "ERROR \"%s\"\r\n", message);
1324 }
1325 
1326 static dbus_bool_t
send_ok(DBusAuth * auth)1327 send_ok (DBusAuth *auth)
1328 {
1329   int orig_len;
1330 
1331   orig_len = _dbus_string_get_length (&auth->outgoing);
1332 
1333   if (_dbus_string_append (&auth->outgoing, "OK ") &&
1334       _dbus_string_copy (& DBUS_AUTH_SERVER (auth)->guid,
1335                          0,
1336                          &auth->outgoing,
1337                          _dbus_string_get_length (&auth->outgoing)) &&
1338       _dbus_string_append (&auth->outgoing, "\r\n"))
1339     {
1340       goto_state (auth, &server_state_waiting_for_begin);
1341       return TRUE;
1342     }
1343   else
1344     {
1345       _dbus_string_set_length (&auth->outgoing, orig_len);
1346       return FALSE;
1347     }
1348 }
1349 
1350 static dbus_bool_t
send_begin(DBusAuth * auth,const DBusString * args_from_ok)1351 send_begin (DBusAuth         *auth,
1352             const DBusString *args_from_ok)
1353 {
1354   int end_of_hex;
1355 
1356   /* "args_from_ok" should be the GUID, whitespace already pulled off the front */
1357   _dbus_assert (_dbus_string_get_length (& DBUS_AUTH_CLIENT (auth)->guid_from_server) == 0);
1358 
1359   /* We decode the hex string to binary, using guid_from_server as scratch... */
1360 
1361   end_of_hex = 0;
1362   if (!_dbus_string_hex_decode (args_from_ok, 0, &end_of_hex,
1363                                 & DBUS_AUTH_CLIENT (auth)->guid_from_server, 0))
1364     return FALSE;
1365 
1366   /* now clear out the scratch */
1367   _dbus_string_set_length (& DBUS_AUTH_CLIENT (auth)->guid_from_server, 0);
1368 
1369   if (end_of_hex != _dbus_string_get_length (args_from_ok) ||
1370       end_of_hex == 0)
1371     {
1372       _dbus_verbose ("Bad GUID from server, parsed %d bytes and had %d bytes from server\n",
1373                      end_of_hex, _dbus_string_get_length (args_from_ok));
1374       goto_state (auth, &common_state_need_disconnect);
1375       return TRUE;
1376     }
1377 
1378   if (_dbus_string_copy (args_from_ok, 0, &DBUS_AUTH_CLIENT (auth)->guid_from_server, 0) &&
1379       _dbus_string_append (&auth->outgoing, "BEGIN\r\n"))
1380     {
1381       _dbus_verbose ("Got GUID '%s' from the server\n",
1382                      _dbus_string_get_const_data (& DBUS_AUTH_CLIENT (auth)->guid_from_server));
1383 
1384       goto_state (auth, &common_state_authenticated);
1385       return TRUE;
1386     }
1387   else
1388     {
1389       _dbus_string_set_length (& DBUS_AUTH_CLIENT (auth)->guid_from_server, 0);
1390       return FALSE;
1391     }
1392 }
1393 
1394 static dbus_bool_t
send_cancel(DBusAuth * auth)1395 send_cancel (DBusAuth *auth)
1396 {
1397   if (_dbus_string_append (&auth->outgoing, "CANCEL\r\n"))
1398     {
1399       goto_state (auth, &client_state_waiting_for_reject);
1400       return TRUE;
1401     }
1402   else
1403     return FALSE;
1404 }
1405 
1406 static dbus_bool_t
process_data(DBusAuth * auth,const DBusString * args,DBusAuthDataFunction data_func)1407 process_data (DBusAuth             *auth,
1408               const DBusString     *args,
1409               DBusAuthDataFunction  data_func)
1410 {
1411   int end;
1412   DBusString decoded;
1413 
1414   if (!_dbus_string_init (&decoded))
1415     return FALSE;
1416 
1417   if (!_dbus_string_hex_decode (args, 0, &end, &decoded, 0))
1418     {
1419       _dbus_string_free (&decoded);
1420       return FALSE;
1421     }
1422 
1423   if (_dbus_string_get_length (args) != end)
1424     {
1425       _dbus_string_free (&decoded);
1426       if (!send_error (auth, "Invalid hex encoding"))
1427         return FALSE;
1428 
1429       return TRUE;
1430     }
1431 
1432 #ifdef DBUS_ENABLE_VERBOSE_MODE
1433   if (_dbus_string_validate_ascii (&decoded, 0,
1434                                    _dbus_string_get_length (&decoded)))
1435     _dbus_verbose ("%s: data: '%s'\n",
1436                    DBUS_AUTH_NAME (auth),
1437                    _dbus_string_get_const_data (&decoded));
1438 #endif
1439 
1440   if (!(* data_func) (auth, &decoded))
1441     {
1442       _dbus_string_free (&decoded);
1443       return FALSE;
1444     }
1445 
1446   _dbus_string_free (&decoded);
1447   return TRUE;
1448 }
1449 
1450 static dbus_bool_t
handle_auth(DBusAuth * auth,const DBusString * args)1451 handle_auth (DBusAuth *auth, const DBusString *args)
1452 {
1453   if (_dbus_string_get_length (args) == 0)
1454     {
1455       /* No args to the auth, send mechanisms */
1456       if (!send_rejected (auth))
1457         return FALSE;
1458 
1459       return TRUE;
1460     }
1461   else
1462     {
1463       int i;
1464       DBusString mech;
1465       DBusString hex_response;
1466 
1467       _dbus_string_find_blank (args, 0, &i);
1468 
1469       if (!_dbus_string_init (&mech))
1470         return FALSE;
1471 
1472       if (!_dbus_string_init (&hex_response))
1473         {
1474           _dbus_string_free (&mech);
1475           return FALSE;
1476         }
1477 
1478       if (!_dbus_string_copy_len (args, 0, i, &mech, 0))
1479         goto failed;
1480 
1481       _dbus_string_skip_blank (args, i, &i);
1482       if (!_dbus_string_copy (args, i, &hex_response, 0))
1483         goto failed;
1484 
1485       auth->mech = find_mech (&mech, auth->allowed_mechs);
1486       if (auth->mech != NULL)
1487         {
1488           _dbus_verbose ("%s: Trying mechanism %s\n",
1489                          DBUS_AUTH_NAME (auth),
1490                          auth->mech->mechanism);
1491 
1492           if (!process_data (auth, &hex_response,
1493                              auth->mech->server_data_func))
1494             goto failed;
1495         }
1496       else
1497         {
1498           /* Unsupported mechanism */
1499           _dbus_verbose ("%s: Unsupported mechanism %s\n",
1500                          DBUS_AUTH_NAME (auth),
1501                          _dbus_string_get_const_data (&mech));
1502 
1503           if (!send_rejected (auth))
1504             goto failed;
1505         }
1506 
1507       _dbus_string_free (&mech);
1508       _dbus_string_free (&hex_response);
1509 
1510       return TRUE;
1511 
1512     failed:
1513       auth->mech = NULL;
1514       _dbus_string_free (&mech);
1515       _dbus_string_free (&hex_response);
1516       return FALSE;
1517     }
1518 }
1519 
1520 static dbus_bool_t
handle_server_state_waiting_for_auth(DBusAuth * auth,DBusAuthCommand command,const DBusString * args)1521 handle_server_state_waiting_for_auth  (DBusAuth         *auth,
1522                                        DBusAuthCommand   command,
1523                                        const DBusString *args)
1524 {
1525   switch (command)
1526     {
1527     case DBUS_AUTH_COMMAND_AUTH:
1528       return handle_auth (auth, args);
1529 
1530     case DBUS_AUTH_COMMAND_CANCEL:
1531     case DBUS_AUTH_COMMAND_DATA:
1532       return send_error (auth, "Not currently in an auth conversation");
1533 
1534     case DBUS_AUTH_COMMAND_BEGIN:
1535       goto_state (auth, &common_state_need_disconnect);
1536       return TRUE;
1537 
1538     case DBUS_AUTH_COMMAND_ERROR:
1539       return send_rejected (auth);
1540 
1541     case DBUS_AUTH_COMMAND_REJECTED:
1542     case DBUS_AUTH_COMMAND_OK:
1543     case DBUS_AUTH_COMMAND_UNKNOWN:
1544     default:
1545       return send_error (auth, "Unknown command");
1546     }
1547 }
1548 
1549 static dbus_bool_t
handle_server_state_waiting_for_data(DBusAuth * auth,DBusAuthCommand command,const DBusString * args)1550 handle_server_state_waiting_for_data  (DBusAuth         *auth,
1551                                        DBusAuthCommand   command,
1552                                        const DBusString *args)
1553 {
1554   switch (command)
1555     {
1556     case DBUS_AUTH_COMMAND_AUTH:
1557       return send_error (auth, "Sent AUTH while another AUTH in progress");
1558 
1559     case DBUS_AUTH_COMMAND_CANCEL:
1560     case DBUS_AUTH_COMMAND_ERROR:
1561       return send_rejected (auth);
1562 
1563     case DBUS_AUTH_COMMAND_DATA:
1564       return process_data (auth, args, auth->mech->server_data_func);
1565 
1566     case DBUS_AUTH_COMMAND_BEGIN:
1567       goto_state (auth, &common_state_need_disconnect);
1568       return TRUE;
1569 
1570     case DBUS_AUTH_COMMAND_REJECTED:
1571     case DBUS_AUTH_COMMAND_OK:
1572     case DBUS_AUTH_COMMAND_UNKNOWN:
1573     default:
1574       return send_error (auth, "Unknown command");
1575     }
1576 }
1577 
1578 static dbus_bool_t
handle_server_state_waiting_for_begin(DBusAuth * auth,DBusAuthCommand command,const DBusString * args)1579 handle_server_state_waiting_for_begin (DBusAuth         *auth,
1580                                        DBusAuthCommand   command,
1581                                        const DBusString *args)
1582 {
1583   switch (command)
1584     {
1585     case DBUS_AUTH_COMMAND_AUTH:
1586       return send_error (auth, "Sent AUTH while expecting BEGIN");
1587 
1588     case DBUS_AUTH_COMMAND_DATA:
1589       return send_error (auth, "Sent DATA while expecting BEGIN");
1590 
1591     case DBUS_AUTH_COMMAND_BEGIN:
1592       goto_state (auth, &common_state_authenticated);
1593       return TRUE;
1594 
1595     case DBUS_AUTH_COMMAND_REJECTED:
1596     case DBUS_AUTH_COMMAND_OK:
1597     case DBUS_AUTH_COMMAND_UNKNOWN:
1598     default:
1599       return send_error (auth, "Unknown command");
1600 
1601     case DBUS_AUTH_COMMAND_CANCEL:
1602     case DBUS_AUTH_COMMAND_ERROR:
1603       return send_rejected (auth);
1604     }
1605 }
1606 
1607 /* return FALSE if no memory, TRUE if all OK */
1608 static dbus_bool_t
get_word(const DBusString * str,int * start,DBusString * word)1609 get_word (const DBusString *str,
1610           int              *start,
1611           DBusString       *word)
1612 {
1613   int i;
1614 
1615   _dbus_string_skip_blank (str, *start, start);
1616   _dbus_string_find_blank (str, *start, &i);
1617 
1618   if (i > *start)
1619     {
1620       if (!_dbus_string_copy_len (str, *start, i - *start, word, 0))
1621         return FALSE;
1622 
1623       *start = i;
1624     }
1625 
1626   return TRUE;
1627 }
1628 
1629 static dbus_bool_t
record_mechanisms(DBusAuth * auth,const DBusString * args)1630 record_mechanisms (DBusAuth         *auth,
1631                    const DBusString *args)
1632 {
1633   int next;
1634   int len;
1635 
1636   if (auth->already_got_mechanisms)
1637     return TRUE;
1638 
1639   len = _dbus_string_get_length (args);
1640 
1641   next = 0;
1642   while (next < len)
1643     {
1644       DBusString m;
1645       const DBusAuthMechanismHandler *mech;
1646 
1647       if (!_dbus_string_init (&m))
1648         goto nomem;
1649 
1650       if (!get_word (args, &next, &m))
1651         {
1652           _dbus_string_free (&m);
1653           goto nomem;
1654         }
1655 
1656       mech = find_mech (&m, auth->allowed_mechs);
1657 
1658       if (mech != NULL)
1659         {
1660           /* FIXME right now we try mechanisms in the order
1661            * the server lists them; should we do them in
1662            * some more deterministic order?
1663            *
1664            * Probably in all_mechanisms order, our order of
1665            * preference. Of course when the server is us,
1666            * it lists things in that order anyhow.
1667            */
1668 
1669           if (mech != &all_mechanisms[0])
1670             {
1671               _dbus_verbose ("%s: Adding mechanism %s to list we will try\n",
1672                              DBUS_AUTH_NAME (auth), mech->mechanism);
1673 
1674               if (!_dbus_list_append (& DBUS_AUTH_CLIENT (auth)->mechs_to_try,
1675                                       (void*) mech))
1676                 {
1677                   _dbus_string_free (&m);
1678                   goto nomem;
1679                 }
1680             }
1681           else
1682             {
1683               _dbus_verbose ("%s: Already tried mechanism %s; not adding to list we will try\n",
1684                              DBUS_AUTH_NAME (auth), mech->mechanism);
1685             }
1686         }
1687       else
1688         {
1689           _dbus_verbose ("%s: Server offered mechanism \"%s\" that we don't know how to use\n",
1690                          DBUS_AUTH_NAME (auth),
1691                          _dbus_string_get_const_data (&m));
1692         }
1693 
1694       _dbus_string_free (&m);
1695     }
1696 
1697   auth->already_got_mechanisms = TRUE;
1698 
1699   return TRUE;
1700 
1701  nomem:
1702   _dbus_list_clear (& DBUS_AUTH_CLIENT (auth)->mechs_to_try);
1703 
1704   return FALSE;
1705 }
1706 
1707 static dbus_bool_t
process_rejected(DBusAuth * auth,const DBusString * args)1708 process_rejected (DBusAuth *auth, const DBusString *args)
1709 {
1710   const DBusAuthMechanismHandler *mech;
1711   DBusAuthClient *client;
1712 
1713   client = DBUS_AUTH_CLIENT (auth);
1714 
1715   if (!auth->already_got_mechanisms)
1716     {
1717       if (!record_mechanisms (auth, args))
1718         return FALSE;
1719     }
1720 
1721   if (DBUS_AUTH_CLIENT (auth)->mechs_to_try != NULL)
1722     {
1723       mech = client->mechs_to_try->data;
1724 
1725       if (!send_auth (auth, mech))
1726         return FALSE;
1727 
1728       _dbus_list_pop_first (&client->mechs_to_try);
1729 
1730       _dbus_verbose ("%s: Trying mechanism %s\n",
1731                      DBUS_AUTH_NAME (auth),
1732                      mech->mechanism);
1733     }
1734   else
1735     {
1736       /* Give up */
1737       _dbus_verbose ("%s: Disconnecting because we are out of mechanisms to try using\n",
1738                      DBUS_AUTH_NAME (auth));
1739       goto_state (auth, &common_state_need_disconnect);
1740     }
1741 
1742   return TRUE;
1743 }
1744 
1745 
1746 static dbus_bool_t
handle_client_state_waiting_for_data(DBusAuth * auth,DBusAuthCommand command,const DBusString * args)1747 handle_client_state_waiting_for_data (DBusAuth         *auth,
1748                                       DBusAuthCommand   command,
1749                                       const DBusString *args)
1750 {
1751   _dbus_assert (auth->mech != NULL);
1752 
1753   switch (command)
1754     {
1755     case DBUS_AUTH_COMMAND_DATA:
1756       return process_data (auth, args, auth->mech->client_data_func);
1757 
1758     case DBUS_AUTH_COMMAND_REJECTED:
1759       return process_rejected (auth, args);
1760 
1761     case DBUS_AUTH_COMMAND_OK:
1762       return send_begin (auth, args);
1763 
1764     case DBUS_AUTH_COMMAND_ERROR:
1765       return send_cancel (auth);
1766 
1767     case DBUS_AUTH_COMMAND_AUTH:
1768     case DBUS_AUTH_COMMAND_CANCEL:
1769     case DBUS_AUTH_COMMAND_BEGIN:
1770     case DBUS_AUTH_COMMAND_UNKNOWN:
1771     default:
1772       return send_error (auth, "Unknown command");
1773     }
1774 }
1775 
1776 static dbus_bool_t
handle_client_state_waiting_for_ok(DBusAuth * auth,DBusAuthCommand command,const DBusString * args)1777 handle_client_state_waiting_for_ok (DBusAuth         *auth,
1778                                     DBusAuthCommand   command,
1779                                     const DBusString *args)
1780 {
1781   switch (command)
1782     {
1783     case DBUS_AUTH_COMMAND_REJECTED:
1784       return process_rejected (auth, args);
1785 
1786     case DBUS_AUTH_COMMAND_OK:
1787       return send_begin (auth, args);
1788 
1789     case DBUS_AUTH_COMMAND_DATA:
1790     case DBUS_AUTH_COMMAND_ERROR:
1791       return send_cancel (auth);
1792 
1793     case DBUS_AUTH_COMMAND_AUTH:
1794     case DBUS_AUTH_COMMAND_CANCEL:
1795     case DBUS_AUTH_COMMAND_BEGIN:
1796     case DBUS_AUTH_COMMAND_UNKNOWN:
1797     default:
1798       return send_error (auth, "Unknown command");
1799     }
1800 }
1801 
1802 static dbus_bool_t
handle_client_state_waiting_for_reject(DBusAuth * auth,DBusAuthCommand command,const DBusString * args)1803 handle_client_state_waiting_for_reject (DBusAuth         *auth,
1804                                         DBusAuthCommand   command,
1805                                         const DBusString *args)
1806 {
1807   switch (command)
1808     {
1809     case DBUS_AUTH_COMMAND_REJECTED:
1810       return process_rejected (auth, args);
1811 
1812     case DBUS_AUTH_COMMAND_AUTH:
1813     case DBUS_AUTH_COMMAND_CANCEL:
1814     case DBUS_AUTH_COMMAND_DATA:
1815     case DBUS_AUTH_COMMAND_BEGIN:
1816     case DBUS_AUTH_COMMAND_OK:
1817     case DBUS_AUTH_COMMAND_ERROR:
1818     case DBUS_AUTH_COMMAND_UNKNOWN:
1819     default:
1820       goto_state (auth, &common_state_need_disconnect);
1821       return TRUE;
1822     }
1823 }
1824 
1825 /**
1826  * Mapping from command name to enum
1827  */
1828 typedef struct {
1829   const char *name;        /**< Name of the command */
1830   DBusAuthCommand command; /**< Corresponding enum */
1831 } DBusAuthCommandName;
1832 
1833 static const DBusAuthCommandName auth_command_names[] = {
1834   { "AUTH",     DBUS_AUTH_COMMAND_AUTH },
1835   { "CANCEL",   DBUS_AUTH_COMMAND_CANCEL },
1836   { "DATA",     DBUS_AUTH_COMMAND_DATA },
1837   { "BEGIN",    DBUS_AUTH_COMMAND_BEGIN },
1838   { "REJECTED", DBUS_AUTH_COMMAND_REJECTED },
1839   { "OK",       DBUS_AUTH_COMMAND_OK },
1840   { "ERROR",    DBUS_AUTH_COMMAND_ERROR }
1841 };
1842 
1843 static DBusAuthCommand
lookup_command_from_name(DBusString * command)1844 lookup_command_from_name (DBusString *command)
1845 {
1846   int i;
1847 
1848   for (i = 0; i < _DBUS_N_ELEMENTS (auth_command_names); i++)
1849     {
1850       if (_dbus_string_equal_c_str (command,
1851                                     auth_command_names[i].name))
1852         return auth_command_names[i].command;
1853     }
1854 
1855   return DBUS_AUTH_COMMAND_UNKNOWN;
1856 }
1857 
1858 static void
goto_state(DBusAuth * auth,const DBusAuthStateData * state)1859 goto_state (DBusAuth *auth, const DBusAuthStateData *state)
1860 {
1861   _dbus_verbose ("%s: going from state %s to state %s\n",
1862                  DBUS_AUTH_NAME (auth),
1863                  auth->state->name,
1864                  state->name);
1865 
1866   auth->state = state;
1867 }
1868 
1869 /* returns whether to call it again right away */
1870 static dbus_bool_t
process_command(DBusAuth * auth)1871 process_command (DBusAuth *auth)
1872 {
1873   DBusAuthCommand command;
1874   DBusString line;
1875   DBusString args;
1876   int eol;
1877   int i, j;
1878   dbus_bool_t retval;
1879 
1880   /* _dbus_verbose ("%s:   trying process_command()\n"); */
1881 
1882   retval = FALSE;
1883 
1884   eol = 0;
1885   if (!_dbus_string_find (&auth->incoming, 0, "\r\n", &eol))
1886     return FALSE;
1887 
1888   if (!_dbus_string_init (&line))
1889     {
1890       auth->needed_memory = TRUE;
1891       return FALSE;
1892     }
1893 
1894   if (!_dbus_string_init (&args))
1895     {
1896       _dbus_string_free (&line);
1897       auth->needed_memory = TRUE;
1898       return FALSE;
1899     }
1900 
1901   if (!_dbus_string_copy_len (&auth->incoming, 0, eol, &line, 0))
1902     goto out;
1903 
1904   if (!_dbus_string_validate_ascii (&line, 0,
1905                                     _dbus_string_get_length (&line)))
1906     {
1907       _dbus_verbose ("%s: Command contained non-ASCII chars or embedded nul\n",
1908                      DBUS_AUTH_NAME (auth));
1909       if (!send_error (auth, "Command contained non-ASCII"))
1910         goto out;
1911       else
1912         goto next_command;
1913     }
1914 
1915   _dbus_verbose ("%s: got command \"%s\"\n",
1916                  DBUS_AUTH_NAME (auth),
1917                  _dbus_string_get_const_data (&line));
1918 
1919   _dbus_string_find_blank (&line, 0, &i);
1920   _dbus_string_skip_blank (&line, i, &j);
1921 
1922   if (j > i)
1923     _dbus_string_delete (&line, i, j - i);
1924 
1925   if (!_dbus_string_move (&line, i, &args, 0))
1926     goto out;
1927 
1928   /* FIXME 1.0 we should probably validate that only the allowed
1929    * chars are in the command name
1930    */
1931 
1932   command = lookup_command_from_name (&line);
1933   if (!(* auth->state->handler) (auth, command, &args))
1934     goto out;
1935 
1936  next_command:
1937 
1938   /* We've succeeded in processing the whole command so drop it out
1939    * of the incoming buffer and return TRUE to try another command.
1940    */
1941 
1942   _dbus_string_delete (&auth->incoming, 0, eol);
1943 
1944   /* kill the \r\n */
1945   _dbus_string_delete (&auth->incoming, 0, 2);
1946 
1947   retval = TRUE;
1948 
1949  out:
1950   _dbus_string_free (&args);
1951   _dbus_string_free (&line);
1952 
1953   if (!retval)
1954     auth->needed_memory = TRUE;
1955   else
1956     auth->needed_memory = FALSE;
1957 
1958   return retval;
1959 }
1960 
1961 
1962 /** @} */
1963 
1964 /**
1965  * @addtogroup DBusAuth
1966  * @{
1967  */
1968 
1969 /**
1970  * Creates a new auth conversation object for the server side.
1971  * See doc/dbus-sasl-profile.txt for full details on what
1972  * this object does.
1973  *
1974  * @returns the new object or #NULL if no memory
1975  */
1976 DBusAuth*
_dbus_auth_server_new(const DBusString * guid)1977 _dbus_auth_server_new (const DBusString *guid)
1978 {
1979   DBusAuth *auth;
1980   DBusAuthServer *server_auth;
1981   DBusString guid_copy;
1982 
1983   if (!_dbus_string_init (&guid_copy))
1984     return NULL;
1985 
1986   if (!_dbus_string_copy (guid, 0, &guid_copy, 0))
1987     {
1988       _dbus_string_free (&guid_copy);
1989       return NULL;
1990     }
1991 
1992   auth = _dbus_auth_new (sizeof (DBusAuthServer));
1993   if (auth == NULL)
1994     {
1995       _dbus_string_free (&guid_copy);
1996       return NULL;
1997     }
1998 
1999   auth->side = auth_side_server;
2000   auth->state = &server_state_waiting_for_auth;
2001 
2002   server_auth = DBUS_AUTH_SERVER (auth);
2003 
2004   server_auth->guid = guid_copy;
2005 
2006   /* perhaps this should be per-mechanism with a lower
2007    * max
2008    */
2009   server_auth->failures = 0;
2010   server_auth->max_failures = 6;
2011 
2012   return auth;
2013 }
2014 
2015 /**
2016  * Creates a new auth conversation object for the client side.
2017  * See doc/dbus-sasl-profile.txt for full details on what
2018  * this object does.
2019  *
2020  * @returns the new object or #NULL if no memory
2021  */
2022 DBusAuth*
_dbus_auth_client_new(void)2023 _dbus_auth_client_new (void)
2024 {
2025   DBusAuth *auth;
2026   DBusString guid_str;
2027 
2028   if (!_dbus_string_init (&guid_str))
2029     return NULL;
2030 
2031   auth = _dbus_auth_new (sizeof (DBusAuthClient));
2032   if (auth == NULL)
2033     {
2034       _dbus_string_free (&guid_str);
2035       return NULL;
2036     }
2037 
2038   DBUS_AUTH_CLIENT (auth)->guid_from_server = guid_str;
2039 
2040   auth->side = auth_side_client;
2041   auth->state = &client_state_need_send_auth;
2042 
2043   /* Start the auth conversation by sending AUTH for our default
2044    * mechanism */
2045   if (!send_auth (auth, &all_mechanisms[0]))
2046     {
2047       _dbus_auth_unref (auth);
2048       return NULL;
2049     }
2050 
2051   return auth;
2052 }
2053 
2054 /**
2055  * Increments the refcount of an auth object.
2056  *
2057  * @param auth the auth conversation
2058  * @returns the auth conversation
2059  */
2060 DBusAuth *
_dbus_auth_ref(DBusAuth * auth)2061 _dbus_auth_ref (DBusAuth *auth)
2062 {
2063   _dbus_assert (auth != NULL);
2064 
2065   auth->refcount += 1;
2066 
2067   return auth;
2068 }
2069 
2070 /**
2071  * Decrements the refcount of an auth object.
2072  *
2073  * @param auth the auth conversation
2074  */
2075 void
_dbus_auth_unref(DBusAuth * auth)2076 _dbus_auth_unref (DBusAuth *auth)
2077 {
2078   _dbus_assert (auth != NULL);
2079   _dbus_assert (auth->refcount > 0);
2080 
2081   auth->refcount -= 1;
2082   if (auth->refcount == 0)
2083     {
2084       shutdown_mech (auth);
2085 
2086       if (DBUS_AUTH_IS_CLIENT (auth))
2087         {
2088           _dbus_string_free (& DBUS_AUTH_CLIENT (auth)->guid_from_server);
2089           _dbus_list_clear (& DBUS_AUTH_CLIENT (auth)->mechs_to_try);
2090         }
2091       else
2092         {
2093           _dbus_assert (DBUS_AUTH_IS_SERVER (auth));
2094 
2095           _dbus_string_free (& DBUS_AUTH_SERVER (auth)->guid);
2096         }
2097 
2098       if (auth->keyring)
2099         _dbus_keyring_unref (auth->keyring);
2100 
2101       _dbus_string_free (&auth->context);
2102       _dbus_string_free (&auth->challenge);
2103       _dbus_string_free (&auth->identity);
2104       _dbus_string_free (&auth->incoming);
2105       _dbus_string_free (&auth->outgoing);
2106 
2107       dbus_free_string_array (auth->allowed_mechs);
2108 
2109       dbus_free (auth);
2110     }
2111 }
2112 
2113 /**
2114  * Sets an array of authentication mechanism names
2115  * that we are willing to use.
2116  *
2117  * @param auth the auth conversation
2118  * @param mechanisms #NULL-terminated array of mechanism names
2119  * @returns #FALSE if no memory
2120  */
2121 dbus_bool_t
_dbus_auth_set_mechanisms(DBusAuth * auth,const char ** mechanisms)2122 _dbus_auth_set_mechanisms (DBusAuth    *auth,
2123                            const char **mechanisms)
2124 {
2125   char **copy;
2126 
2127   if (mechanisms != NULL)
2128     {
2129       copy = _dbus_dup_string_array (mechanisms);
2130       if (copy == NULL)
2131         return FALSE;
2132     }
2133   else
2134     copy = NULL;
2135 
2136   dbus_free_string_array (auth->allowed_mechs);
2137 
2138   auth->allowed_mechs = copy;
2139 
2140   return TRUE;
2141 }
2142 
2143 /**
2144  * @param auth the auth conversation object
2145  * @returns #TRUE if we're in a final state
2146  */
2147 #define DBUS_AUTH_IN_END_STATE(auth) ((auth)->state->handler == NULL)
2148 
2149 /**
2150  * Analyzes buffered input and moves the auth conversation forward,
2151  * returning the new state of the auth conversation.
2152  *
2153  * @param auth the auth conversation
2154  * @returns the new state
2155  */
2156 DBusAuthState
_dbus_auth_do_work(DBusAuth * auth)2157 _dbus_auth_do_work (DBusAuth *auth)
2158 {
2159   auth->needed_memory = FALSE;
2160 
2161   /* Max amount we'll buffer up before deciding someone's on crack */
2162 #define MAX_BUFFER (16 * _DBUS_ONE_KILOBYTE)
2163 
2164   do
2165     {
2166       if (DBUS_AUTH_IN_END_STATE (auth))
2167         break;
2168 
2169       if (_dbus_string_get_length (&auth->incoming) > MAX_BUFFER ||
2170           _dbus_string_get_length (&auth->outgoing) > MAX_BUFFER)
2171         {
2172           goto_state (auth, &common_state_need_disconnect);
2173           _dbus_verbose ("%s: Disconnecting due to excessive data buffered in auth phase\n",
2174                          DBUS_AUTH_NAME (auth));
2175           break;
2176         }
2177     }
2178   while (process_command (auth));
2179 
2180   if (auth->needed_memory)
2181     return DBUS_AUTH_STATE_WAITING_FOR_MEMORY;
2182   else if (_dbus_string_get_length (&auth->outgoing) > 0)
2183     return DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND;
2184   else if (auth->state == &common_state_need_disconnect)
2185     return DBUS_AUTH_STATE_NEED_DISCONNECT;
2186   else if (auth->state == &common_state_authenticated)
2187     return DBUS_AUTH_STATE_AUTHENTICATED;
2188   else return DBUS_AUTH_STATE_WAITING_FOR_INPUT;
2189 }
2190 
2191 /**
2192  * Gets bytes that need to be sent to the peer we're conversing with.
2193  * After writing some bytes, _dbus_auth_bytes_sent() must be called
2194  * to notify the auth object that they were written.
2195  *
2196  * @param auth the auth conversation
2197  * @param str return location for a ref to the buffer to send
2198  * @returns #FALSE if nothing to send
2199  */
2200 dbus_bool_t
_dbus_auth_get_bytes_to_send(DBusAuth * auth,const DBusString ** str)2201 _dbus_auth_get_bytes_to_send (DBusAuth          *auth,
2202                               const DBusString **str)
2203 {
2204   _dbus_assert (auth != NULL);
2205   _dbus_assert (str != NULL);
2206 
2207   *str = NULL;
2208 
2209   if (_dbus_string_get_length (&auth->outgoing) == 0)
2210     return FALSE;
2211 
2212   *str = &auth->outgoing;
2213 
2214   return TRUE;
2215 }
2216 
2217 /**
2218  * Notifies the auth conversation object that
2219  * the given number of bytes of the outgoing buffer
2220  * have been written out.
2221  *
2222  * @param auth the auth conversation
2223  * @param bytes_sent number of bytes written out
2224  */
2225 void
_dbus_auth_bytes_sent(DBusAuth * auth,int bytes_sent)2226 _dbus_auth_bytes_sent (DBusAuth *auth,
2227                        int       bytes_sent)
2228 {
2229   _dbus_verbose ("%s: Sent %d bytes of: %s\n",
2230                  DBUS_AUTH_NAME (auth),
2231                  bytes_sent,
2232                  _dbus_string_get_const_data (&auth->outgoing));
2233 
2234   _dbus_string_delete (&auth->outgoing,
2235                        0, bytes_sent);
2236 }
2237 
2238 /**
2239  * Get a buffer to be used for reading bytes from the peer we're conversing
2240  * with. Bytes should be appended to this buffer.
2241  *
2242  * @param auth the auth conversation
2243  * @param buffer return location for buffer to append bytes to
2244  */
2245 void
_dbus_auth_get_buffer(DBusAuth * auth,DBusString ** buffer)2246 _dbus_auth_get_buffer (DBusAuth     *auth,
2247                        DBusString **buffer)
2248 {
2249   _dbus_assert (auth != NULL);
2250   _dbus_assert (!auth->buffer_outstanding);
2251 
2252   *buffer = &auth->incoming;
2253 
2254   auth->buffer_outstanding = TRUE;
2255 }
2256 
2257 /**
2258  * Returns a buffer with new data read into it.
2259  *
2260  * @param auth the auth conversation
2261  * @param buffer the buffer being returned
2262  * @param bytes_read number of new bytes added
2263  */
2264 void
_dbus_auth_return_buffer(DBusAuth * auth,DBusString * buffer,int bytes_read)2265 _dbus_auth_return_buffer (DBusAuth               *auth,
2266                           DBusString             *buffer,
2267                           int                     bytes_read)
2268 {
2269   _dbus_assert (buffer == &auth->incoming);
2270   _dbus_assert (auth->buffer_outstanding);
2271 
2272   auth->buffer_outstanding = FALSE;
2273 }
2274 
2275 /**
2276  * Returns leftover bytes that were not used as part of the auth
2277  * conversation.  These bytes will be part of the message stream
2278  * instead. This function may not be called until authentication has
2279  * succeeded.
2280  *
2281  * @param auth the auth conversation
2282  * @param str return location for pointer to string of unused bytes
2283  */
2284 void
_dbus_auth_get_unused_bytes(DBusAuth * auth,const DBusString ** str)2285 _dbus_auth_get_unused_bytes (DBusAuth           *auth,
2286                              const DBusString **str)
2287 {
2288   if (!DBUS_AUTH_IN_END_STATE (auth))
2289     return;
2290 
2291   *str = &auth->incoming;
2292 }
2293 
2294 
2295 /**
2296  * Gets rid of unused bytes returned by _dbus_auth_get_unused_bytes()
2297  * after we've gotten them and successfully moved them elsewhere.
2298  *
2299  * @param auth the auth conversation
2300  */
2301 void
_dbus_auth_delete_unused_bytes(DBusAuth * auth)2302 _dbus_auth_delete_unused_bytes (DBusAuth *auth)
2303 {
2304   if (!DBUS_AUTH_IN_END_STATE (auth))
2305     return;
2306 
2307   _dbus_string_set_length (&auth->incoming, 0);
2308 }
2309 
2310 /**
2311  * Called post-authentication, indicates whether we need to encode
2312  * the message stream with _dbus_auth_encode_data() prior to
2313  * sending it to the peer.
2314  *
2315  * @param auth the auth conversation
2316  * @returns #TRUE if we need to encode the stream
2317  */
2318 dbus_bool_t
_dbus_auth_needs_encoding(DBusAuth * auth)2319 _dbus_auth_needs_encoding (DBusAuth *auth)
2320 {
2321   if (auth->state != &common_state_authenticated)
2322     return FALSE;
2323 
2324   if (auth->mech != NULL)
2325     {
2326       if (DBUS_AUTH_IS_CLIENT (auth))
2327         return auth->mech->client_encode_func != NULL;
2328       else
2329         return auth->mech->server_encode_func != NULL;
2330     }
2331   else
2332     return FALSE;
2333 }
2334 
2335 /**
2336  * Called post-authentication, encodes a block of bytes for sending to
2337  * the peer. If no encoding was negotiated, just copies the bytes
2338  * (you can avoid this by checking _dbus_auth_needs_encoding()).
2339  *
2340  * @param auth the auth conversation
2341  * @param plaintext the plain text data
2342  * @param encoded initialized string to where encoded data is appended
2343  * @returns #TRUE if we had enough memory and successfully encoded
2344  */
2345 dbus_bool_t
_dbus_auth_encode_data(DBusAuth * auth,const DBusString * plaintext,DBusString * encoded)2346 _dbus_auth_encode_data (DBusAuth         *auth,
2347                         const DBusString *plaintext,
2348                         DBusString       *encoded)
2349 {
2350   _dbus_assert (plaintext != encoded);
2351 
2352   if (auth->state != &common_state_authenticated)
2353     return FALSE;
2354 
2355   if (_dbus_auth_needs_encoding (auth))
2356     {
2357       if (DBUS_AUTH_IS_CLIENT (auth))
2358         return (* auth->mech->client_encode_func) (auth, plaintext, encoded);
2359       else
2360         return (* auth->mech->server_encode_func) (auth, plaintext, encoded);
2361     }
2362   else
2363     {
2364       return _dbus_string_copy (plaintext, 0, encoded,
2365                                 _dbus_string_get_length (encoded));
2366     }
2367 }
2368 
2369 /**
2370  * Called post-authentication, indicates whether we need to decode
2371  * the message stream with _dbus_auth_decode_data() after
2372  * receiving it from the peer.
2373  *
2374  * @param auth the auth conversation
2375  * @returns #TRUE if we need to encode the stream
2376  */
2377 dbus_bool_t
_dbus_auth_needs_decoding(DBusAuth * auth)2378 _dbus_auth_needs_decoding (DBusAuth *auth)
2379 {
2380   if (auth->state != &common_state_authenticated)
2381     return FALSE;
2382 
2383   if (auth->mech != NULL)
2384     {
2385       if (DBUS_AUTH_IS_CLIENT (auth))
2386         return auth->mech->client_decode_func != NULL;
2387       else
2388         return auth->mech->server_decode_func != NULL;
2389     }
2390   else
2391     return FALSE;
2392 }
2393 
2394 
2395 /**
2396  * Called post-authentication, decodes a block of bytes received from
2397  * the peer. If no encoding was negotiated, just copies the bytes (you
2398  * can avoid this by checking _dbus_auth_needs_decoding()).
2399  *
2400  * @todo 1.0? We need to be able to distinguish "out of memory" error
2401  * from "the data is hosed" error.
2402  *
2403  * @param auth the auth conversation
2404  * @param encoded the encoded data
2405  * @param plaintext initialized string where decoded data is appended
2406  * @returns #TRUE if we had enough memory and successfully decoded
2407  */
2408 dbus_bool_t
_dbus_auth_decode_data(DBusAuth * auth,const DBusString * encoded,DBusString * plaintext)2409 _dbus_auth_decode_data (DBusAuth         *auth,
2410                         const DBusString *encoded,
2411                         DBusString       *plaintext)
2412 {
2413   _dbus_assert (plaintext != encoded);
2414 
2415   if (auth->state != &common_state_authenticated)
2416     return FALSE;
2417 
2418   if (_dbus_auth_needs_decoding (auth))
2419     {
2420       if (DBUS_AUTH_IS_CLIENT (auth))
2421         return (* auth->mech->client_decode_func) (auth, encoded, plaintext);
2422       else
2423         return (* auth->mech->server_decode_func) (auth, encoded, plaintext);
2424     }
2425   else
2426     {
2427       return _dbus_string_copy (encoded, 0, plaintext,
2428                                 _dbus_string_get_length (plaintext));
2429     }
2430 }
2431 
2432 /**
2433  * Sets credentials received via reliable means from the operating
2434  * system.
2435  *
2436  * @param auth the auth conversation
2437  * @param credentials the credentials received
2438  */
2439 void
_dbus_auth_set_credentials(DBusAuth * auth,const DBusCredentials * credentials)2440 _dbus_auth_set_credentials (DBusAuth               *auth,
2441                             const DBusCredentials  *credentials)
2442 {
2443   auth->credentials = *credentials;
2444 }
2445 
2446 /**
2447  * Gets the identity we authorized the client as.  Apps may have
2448  * different policies as to what identities they allow.
2449  *
2450  * @param auth the auth conversation
2451  * @param credentials the credentials we've authorized
2452  */
2453 void
_dbus_auth_get_identity(DBusAuth * auth,DBusCredentials * credentials)2454 _dbus_auth_get_identity (DBusAuth               *auth,
2455                          DBusCredentials        *credentials)
2456 {
2457   if (auth->state == &common_state_authenticated)
2458     *credentials = auth->authorized_identity;
2459   else
2460     _dbus_credentials_clear (credentials);
2461 }
2462 
2463 /**
2464  * Gets the GUID from the server if we've authenticated; gets
2465  * #NULL otherwise.
2466  * @param auth the auth object
2467  * @returns the GUID in ASCII hex format
2468  */
2469 const char*
_dbus_auth_get_guid_from_server(DBusAuth * auth)2470 _dbus_auth_get_guid_from_server (DBusAuth *auth)
2471 {
2472   _dbus_assert (DBUS_AUTH_IS_CLIENT (auth));
2473 
2474   if (auth->state == &common_state_authenticated)
2475     return _dbus_string_get_const_data (& DBUS_AUTH_CLIENT (auth)->guid_from_server);
2476   else
2477     return NULL;
2478 }
2479 
2480 /**
2481  * Sets the "authentication context" which scopes cookies
2482  * with the DBUS_COOKIE_SHA1 auth mechanism for example.
2483  *
2484  * @param auth the auth conversation
2485  * @param context the context
2486  * @returns #FALSE if no memory
2487  */
2488 dbus_bool_t
_dbus_auth_set_context(DBusAuth * auth,const DBusString * context)2489 _dbus_auth_set_context (DBusAuth               *auth,
2490                         const DBusString       *context)
2491 {
2492   return _dbus_string_replace_len (context, 0, _dbus_string_get_length (context),
2493                                    &auth->context, 0, _dbus_string_get_length (context));
2494 }
2495 
2496 /** @} */
2497 
2498 /* tests in dbus-auth-util.c */
2499