authd/provider.c

   1 /* authd/provider.c - authentication provider framework
   2  * Copyright (c) 2016 Elizabeth Myers <elizabeth@interlinked.me>
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice is present in all copies.
   7  *
   8  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   9  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  10  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  11  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  12  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  13  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  14  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  15  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  16  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  17  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  18  * POSSIBILITY OF SUCH DAMAGE.
  19  */
  20
  21 /* The basic design here is to have "authentication providers" that do things
  22  * like query ident and blacklists and even open proxies.
  23  *
  24  * Providers are registered in the auth_providers linked list. It is planned to
  25  * use a bitmap to store provider ID's later.
  26  *
  27  * Providers can either return failure immediately, immediate acceptance, or do
  28  * work in the background (calling set_provider to signal this).
  29  *
  30  * Provider-specific data for each client can be kept in an index of the data
  31  * struct member (using the provider's ID).
  32  *
  33  * All providers must implement at a minimum a perform_provider function. You
  34  * don't have to implement the others if you don't need them.
  35  *
  36  * Providers may kick clients off by rejecting them. Upon rejection, all
  37  * providers are cancelled. They can also unconditionally accept them.
  38  *
  39  * When a provider is done and is neutral on accepting/rejecting a client, it
  40  * should call provider_done. Do NOT call this if you have accepted or rejected
  41  * the client.
  42  *
  43  * Eventually, stuff like *:line handling will be moved here, but that means we
  44  * have to talk to bandb directly first.
  45  *
  46  * --Elizafox, 9 March 2016
  47  */
  48
  49 #include "stdinc.h"
  50 #include "rb_dictionary.h"
  51 #include "rb_lib.h"
  52 #include "authd.h"
  53 #include "provider.h"
  54 #include "notice.h"
  55
  56 static EVH provider_timeout_event;
  57
  58 rb_dictionary *auth_clients;
  59 rb_dlink_list auth_providers;
  60
  61 static rb_dlink_list free_pids;
  62 static uint32_t allocated_pids;
  63 static struct ev_entry *timeout_ev;
  64
  65 /* Initalise all providers */
  66 void
  67 init_providers(void)
  68 {
  69         auth_clients = rb_dictionary_create("pending auth clients", rb_uint32cmp);
  70         timeout_ev = rb_event_addish("provider_timeout_event", provider_timeout_event, NULL, 1);
  71
  72         load_provider(&rdns_provider);
  73         load_provider(&ident_provider);
  74         load_provider(&blacklist_provider);
  75         load_provider(&opm_provider);
  76 }
  77
  78 /* Terminate all providers */
  79 void
  80 destroy_providers(void)
  81 {
  82         rb_dlink_node *ptr, *nptr;
  83         rb_dictionary_iter iter;
  84         struct auth_client *auth;
  85
  86         /* Cancel outstanding connections */
  87         RB_DICTIONARY_FOREACH(auth, &iter, auth_clients)
  88         {
  89                 auth_client_ref(auth);
  90
  91                 /* TBD - is this the right thing? */
  92                 reject_client(auth, UINT32_MAX, "destroy",
  93                         "Authentication system is down... try reconnecting in a few seconds");
  94
  95                 auth_client_unref(auth);
  96         }
  97
  98         RB_DLINK_FOREACH_SAFE(ptr, nptr, auth_providers.head)
  99         {
 100                 struct auth_provider *provider = ptr->data;
 101
 102                 if(provider->destroy)
 103                         provider->destroy();
 104
 105                 rb_dlinkDelete(ptr, &auth_providers);
 106         }
 107
 108         rb_dictionary_destroy(auth_clients, NULL, NULL);
 109         rb_event_delete(timeout_ev);
 110 }
 111
 112 /* Load a provider */
 113 void
 114 load_provider(struct auth_provider *provider)
 115 {
 116         /* Assign a PID */
 117         if(rb_dlink_list_length(&free_pids) > 0)
 118         {
 119                 /* use the free list */
 120                 provider->id = RB_POINTER_TO_UINT(free_pids.head->data);
 121                 rb_dlinkDestroy(free_pids.head, &free_pids);
 122         }
 123         else
 124         {
 125                 if(allocated_pids == MAX_PROVIDERS || allocated_pids == UINT32_MAX)
 126                 {
 127                         warn_opers(L_WARN, "Cannot load additional provider, max reached!");
 128                         return;
 129                 }
 130
 131                 provider->id = allocated_pids++;
 132         }
 133
 134         if(provider->opt_handlers != NULL)
 135         {
 136                 struct auth_opts_handler *handler;
 137
 138                 for(handler = provider->opt_handlers; handler->option != NULL; handler++)
 139                         rb_dictionary_add(authd_option_handlers, handler->option, handler);
 140         }
 141
 142         if(provider->stats_handler.letter != '\0')
 143                 authd_stat_handlers[(unsigned char)provider->stats_handler.letter] = provider->stats_handler.handler;
 144
 145         if(provider->init != NULL)
 146                 provider->init();
 147
 148         rb_dlinkAdd(provider, &provider->node, &auth_providers);
 149 }
 150
 151 void
 152 unload_provider(struct auth_provider *provider)
 153 {
 154         if(provider->opt_handlers != NULL)
 155         {
 156                 struct auth_opts_handler *handler;
 157
 158                 for(handler = provider->opt_handlers; handler->option != NULL; handler++)
 159                         rb_dictionary_delete(authd_option_handlers, handler->option);
 160         }
 161
 162         if(provider->stats_handler.letter != '\0')
 163                 authd_stat_handlers[(unsigned char)provider->stats_handler.letter] = NULL;
 164
 165         if(provider->destroy != NULL)
 166                 provider->destroy();
 167
 168         rb_dlinkDelete(&provider->node, &auth_providers);
 169
 170         /* Reclaim ID */
 171         rb_dlinkAddAlloc(RB_UINT_TO_POINTER(provider->id), &free_pids);
 172 }
 173
 174 void
 175 auth_client_free(struct auth_client *auth)
 176 {
 177         rb_dictionary_delete(auth_clients, RB_UINT_TO_POINTER(auth->cid));
 178         rb_free(auth->data);
 179         rb_free(auth);
 180 }
 181
 182 /* Cancel outstanding providers for a client (if any). */
 183 void
 184 cancel_providers(struct auth_client *auth)
 185 {
 186         if(auth->providers_cancelled)
 187                 return;
 188
 189         auth->providers_cancelled = true;
 190
 191         if(auth->providers_active > 0)
 192         {
 193                 rb_dlink_node *ptr;
 194
 195                 RB_DLINK_FOREACH(ptr, auth_providers.head)
 196                 {
 197                         struct auth_provider *provider = ptr->data;
 198
 199                         if(provider->cancel != NULL && is_provider_running(auth, provider->id))
 200                                 /* Cancel if required */
 201                                 provider->cancel(auth);
 202                 }
 203         }
 204 }
 205
 206 /* Provider is done */
 207 void
 208 provider_done(struct auth_client *auth, uint32_t id)
 209 {
 210         rb_dlink_node *ptr;
 211
 212         lrb_assert(is_provider_running(auth, id));
 213         lrb_assert(id != UINT32_MAX);
 214         lrb_assert(id < allocated_pids);
 215
 216         set_provider_done(auth, id);
 217
 218         if(auth->providers_active == 0 && !auth->providers_starting)
 219         {
 220                 /* All done */
 221                 accept_client(auth);
 222                 return;
 223         }
 224
 225         RB_DLINK_FOREACH(ptr, auth_providers.head)
 226         {
 227                 struct auth_provider *provider = ptr->data;
 228
 229                 if(provider->completed != NULL && is_provider_running(auth, provider->id))
 230                         /* Notify pending clients who asked for it */
 231                         provider->completed(auth, id);
 232         }
 233 }
 234
 235 /* Reject a client and cancel any outstanding providers */
 236 void
 237 reject_client(struct auth_client *auth, uint32_t id, const char *data, const char *fmt, ...)
 238 {
 239         char buf[BUFSIZE];
 240         va_list args;
 241
 242         va_start(args, fmt);
 243         vsnprintf(buf, sizeof(buf), fmt, args);
 244         va_end(args);
 245
 246         /* We send back username and hostname in case ircd wants to overrule our decision.
 247          * In the future this may not be the case.
 248          * --Elizafox
 249          */
 250         rb_helper_write(authd_helper, "R %x %c %s %s %s :%s",
 251                 auth->cid, id != UINT32_MAX ? auth->data[id].provider->letter : '*',
 252                 auth->username, auth->hostname,
 253                 data == NULL ? "*" : data, buf);
 254
 255         if(id != UINT32_MAX)
 256                 set_provider_done(auth, id);
 257
 258         cancel_providers(auth);
 259 }
 260
 261 /* Accept a client and cancel outstanding providers if any */
 262 void
 263 accept_client(struct auth_client *auth)
 264 {
 265         rb_helper_write(authd_helper, "A %x %s %s", auth->cid, auth->username, auth->hostname);
 266         cancel_providers(auth);
 267 }
 268
 269 /* Begin authenticating user */
 270 static void
 271 start_auth(const char *cid, const char *l_ip, const char *l_port, const char *c_ip, const char *c_port)
 272 {
 273         struct auth_client *auth;
 274         unsigned long long lcid = strtoull(cid, NULL, 16);
 275         rb_dlink_node *ptr;
 276
 277         if(lcid == 0 || lcid > UINT32_MAX)
 278                 return;
 279
 280         auth = rb_malloc(sizeof(struct auth_client));
 281         auth_client_ref(auth);
 282         auth->cid = (uint32_t)lcid;
 283
 284         if(rb_dictionary_find(auth_clients, RB_UINT_TO_POINTER(auth->cid)) == NULL)
 285                 rb_dictionary_add(auth_clients, RB_UINT_TO_POINTER(auth->cid), auth);
 286         else
 287         {
 288                 warn_opers(L_CRIT, "provider: duplicate client added via start_auth: %s", cid);
 289                 exit(EX_PROVIDER_ERROR);
 290         }
 291
 292         rb_strlcpy(auth->l_ip, l_ip, sizeof(auth->l_ip));
 293         auth->l_port = (uint16_t)atoi(l_port);  /* should be safe */
 294         (void) rb_inet_pton_sock(l_ip, (struct sockaddr *)&auth->l_addr);
 295         SET_SS_PORT(&auth->l_addr, htons(auth->l_port));
 296
 297         rb_strlcpy(auth->c_ip, c_ip, sizeof(auth->c_ip));
 298         auth->c_port = (uint16_t)atoi(c_port);
 299         (void) rb_inet_pton_sock(c_ip, (struct sockaddr *)&auth->c_addr);
 300         SET_SS_PORT(&auth->c_addr, htons(auth->c_port));
 301
 302         rb_strlcpy(auth->hostname, "*", sizeof(auth->hostname));
 303         rb_strlcpy(auth->username, "*", sizeof(auth->username));
 304
 305         auth->data = rb_malloc(allocated_pids * sizeof(struct auth_client_data));
 306
 307         auth->providers_starting = true;
 308         RB_DLINK_FOREACH(ptr, auth_providers.head)
 309         {
 310                 struct auth_provider *provider = ptr->data;
 311
 312                 auth->data[provider->id].provider = provider;
 313
 314                 lrb_assert(provider->start != NULL);
 315
 316                 /* Execute providers */
 317                 if(!provider->start(auth))
 318                         /* Rejected immediately */
 319                         goto done;
 320
 321                 if(auth->providers_cancelled)
 322                         break;
 323         }
 324         auth->providers_starting = false;
 325
 326         /* If no providers are running, accept the client */
 327         if(auth->providers_active == 0)
 328                 accept_client(auth);
 329
 330 done:
 331         auth_client_unref(auth);
 332 }
 333
 334 /* Callback for the initiation */
 335 void
 336 handle_new_connection(int parc, char *parv[])
 337 {
 338         if(parc < 6)
 339         {
 340                 warn_opers(L_CRIT, "provider: received too few params for new connection (6 expected, got %d)", parc);
 341                 exit(EX_PROVIDER_ERROR);
 342         }
 343
 344         start_auth(parv[1], parv[2], parv[3], parv[4], parv[5]);
 345 }
 346
 347 void
 348 handle_cancel_connection(int parc, char *parv[])
 349 {
 350         struct auth_client *auth;
 351         unsigned long long lcid;
 352
 353         if(parc < 2)
 354         {
 355                 warn_opers(L_CRIT, "provider: received too few params for new connection (2 expected, got %d)", parc);
 356                 exit(EX_PROVIDER_ERROR);
 357         }
 358
 359         lcid = strtoull(parv[1], NULL, 16);
 360         if(lcid == 0 || lcid > UINT32_MAX)
 361         {
 362                 warn_opers(L_CRIT, "provider: got a request to cancel a connection that can't exist: %s", parv[1]);
 363                 exit(EX_PROVIDER_ERROR);
 364         }
 365
 366         if((auth = rb_dictionary_retrieve(auth_clients, RB_UINT_TO_POINTER((uint32_t)lcid))) == NULL)
 367         {
 368                 /* This could happen as a race if we've accepted/rejected but they cancel, so don't die here.
 369                  * --Elizafox */
 370                 return;
 371         }
 372
 373         auth_client_ref(auth);
 374         cancel_providers(auth);
 375         auth_client_unref(auth);
 376 }
 377
 378 static void
 379 provider_timeout_event(void *notused __unused)
 380 {
 381         struct auth_client *auth;
 382         rb_dictionary_iter iter;
 383         const time_t curtime = rb_current_time();
 384
 385         RB_DICTIONARY_FOREACH(auth, &iter, auth_clients)
 386         {
 387                 rb_dlink_node *ptr;
 388
 389                 auth_client_ref(auth);
 390
 391                 RB_DLINK_FOREACH(ptr, auth_providers.head)
 392                 {
 393                         struct auth_provider *provider = ptr->data;
 394                         const time_t timeout = get_provider_timeout(auth, provider->id);
 395
 396                         if(is_provider_running(auth, provider->id) && provider->timeout != NULL &&
 397                                 timeout > 0 && timeout < curtime)
 398                         {
 399                                 provider->timeout(auth);
 400                         }
 401                 }
 402
 403                 auth_client_unref(auth);
 404         }
 405 }