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         struct auth_provider *provider;
  86
  87         /* Cancel outstanding connections */
  88         RB_DICTIONARY_FOREACH(auth, &iter, auth_clients)
  89         {
  90                 auth_client_ref(auth);
  91
  92                 /* TBD - is this the right thing? */
  93                 reject_client(auth, UINT32_MAX, "destroy",
  94                         "Authentication system is down... try reconnecting in a few seconds");
  95
  96                 auth_client_unref(auth);
  97         }
  98
  99         RB_DLINK_FOREACH_SAFE(ptr, nptr, auth_providers.head)
 100         {
 101                 struct auth_provider *provider = ptr->data;
 102
 103                 if(provider->destroy)
 104                         provider->destroy();
 105
 106                 rb_dlinkDelete(ptr, &auth_providers);
 107         }
 108
 109         rb_dictionary_destroy(auth_clients, NULL, NULL);
 110         rb_event_delete(timeout_ev);
 111 }
 112
 113 /* Load a provider */
 114 void
 115 load_provider(struct auth_provider *provider)
 116 {
 117         /* Assign a PID */
 118         if(rb_dlink_list_length(&free_pids) > 0)
 119         {
 120                 /* use the free list */
 121                 provider->id = RB_POINTER_TO_UINT(free_pids.head->data);
 122                 rb_dlinkDestroy(free_pids.head, &free_pids);
 123         }
 124         else
 125         {
 126                 if(allocated_pids == MAX_PROVIDERS || allocated_pids == UINT32_MAX)
 127                 {
 128                         warn_opers(L_WARN, "Cannot load additional provider, max reached!");
 129                         return;
 130                 }
 131
 132                 provider->id = allocated_pids++;
 133         }
 134
 135         if(provider->opt_handlers != NULL)
 136         {
 137                 struct auth_opts_handler *handler;
 138
 139                 for(handler = provider->opt_handlers; handler->option != NULL; handler++)
 140                         rb_dictionary_add(authd_option_handlers, handler->option, handler);
 141         }
 142
 143         if(provider->stats_handler.letter != '\0')
 144                 authd_stat_handlers[(unsigned char)provider->stats_handler.letter] = provider->stats_handler.handler;
 145
 146         if(provider->init != NULL)
 147                 provider->init();
 148
 149         rb_dlinkAdd(provider, &provider->node, &auth_providers);
 150 }
 151
 152 void
 153 unload_provider(struct auth_provider *provider)
 154 {
 155         if(provider->opt_handlers != NULL)
 156         {
 157                 struct auth_opts_handler *handler;
 158
 159                 for(handler = provider->opt_handlers; handler->option != NULL; handler++)
 160                         rb_dictionary_delete(authd_option_handlers, handler->option);
 161         }
 162
 163         if(provider->stats_handler.letter != '\0')
 164                 authd_stat_handlers[(unsigned char)provider->stats_handler.letter] = NULL;
 165
 166         if(provider->destroy != NULL)
 167                 provider->destroy();
 168
 169         rb_dlinkDelete(&provider->node, &auth_providers);
 170
 171         /* Reclaim ID */
 172         rb_dlinkAddAlloc(RB_UINT_TO_POINTER(provider->id), &free_pids);
 173 }
 174
 175 void
 176 auth_client_free(struct auth_client *auth)
 177 {
 178         rb_dictionary_delete(auth_clients, RB_UINT_TO_POINTER(auth->cid));
 179         rb_free(auth->data);
 180         rb_free(auth);
 181 }
 182
 183 /* Cancel outstanding providers for a client (if any). */
 184 void
 185 cancel_providers(struct auth_client *auth)
 186 {
 187         if(auth->providers_cancelled)
 188                 return;
 189
 190         auth->providers_cancelled = true;
 191
 192         if(auth->providers_active > 0)
 193         {
 194                 rb_dlink_node *ptr;
 195
 196                 RB_DLINK_FOREACH(ptr, auth_providers.head)
 197                 {
 198                         struct auth_provider *provider = ptr->data;
 199
 200                         if(provider->cancel != NULL && is_provider_running(auth, provider->id))
 201                                 /* Cancel if required */
 202                                 provider->cancel(auth);
 203                 }
 204         }
 205 }
 206
 207 /* Provider is done */
 208 void
 209 provider_done(struct auth_client *auth, uint32_t id)
 210 {
 211         rb_dlink_node *ptr;
 212
 213         lrb_assert(is_provider_running(auth, id));
 214         lrb_assert(id != UINT32_MAX);
 215         lrb_assert(id < allocated_pids);
 216
 217         set_provider_done(auth, id);
 218
 219         if(auth->providers_active == 0 && !auth->providers_starting)
 220         {
 221                 /* All done */
 222                 accept_client(auth);
 223                 return;
 224         }
 225
 226         RB_DLINK_FOREACH(ptr, auth_providers.head)
 227         {
 228                 struct auth_provider *provider = ptr->data;
 229
 230                 if(provider->completed != NULL && is_provider_running(auth, provider->id))
 231                         /* Notify pending clients who asked for it */
 232                         provider->completed(auth, id);
 233         }
 234 }
 235
 236 /* Reject a client and cancel any outstanding providers */
 237 void
 238 reject_client(struct auth_client *auth, uint32_t id, const char *data, const char *fmt, ...)
 239 {
 240         char buf[BUFSIZE];
 241         va_list args;
 242
 243         va_start(args, fmt);
 244         vsnprintf(buf, sizeof(buf), fmt, args);
 245         va_end(args);
 246
 247         /* We send back username and hostname in case ircd wants to overrule our decision.
 248          * In the future this may not be the case.
 249          * --Elizafox
 250          */
 251         rb_helper_write(authd_helper, "R %x %c %s %s %s :%s",
 252                 auth->cid, id != UINT32_MAX ? auth->data[id].provider->letter : '*',
 253                 auth->username, auth->hostname,
 254                 data == NULL ? "*" : data, buf);
 255
 256         if(id != UINT32_MAX)
 257                 set_provider_done(auth, id);
 258
 259         cancel_providers(auth);
 260 }
 261
 262 /* Accept a client and cancel outstanding providers if any */
 263 void
 264 accept_client(struct auth_client *auth)
 265 {
 266         rb_helper_write(authd_helper, "A %x %s %s", auth->cid, auth->username, auth->hostname);
 267         cancel_providers(auth);
 268 }
 269
 270 /* Begin authenticating user */
 271 static void
 272 start_auth(const char *cid, const char *l_ip, const char *l_port, const char *c_ip, const char *c_port)
 273 {
 274         struct auth_client *auth;
 275         unsigned long long lcid = strtoull(cid, NULL, 16);
 276         rb_dlink_node *ptr;
 277
 278         if(lcid == 0 || lcid > UINT32_MAX)
 279                 return;
 280
 281         auth = rb_malloc(sizeof(struct auth_client));
 282         auth_client_ref(auth);
 283         auth->cid = (uint32_t)lcid;
 284
 285         if(rb_dictionary_find(auth_clients, RB_UINT_TO_POINTER(auth->cid)) == NULL)
 286                 rb_dictionary_add(auth_clients, RB_UINT_TO_POINTER(auth->cid), auth);
 287         else
 288         {
 289                 warn_opers(L_CRIT, "provider: duplicate client added via start_auth: %s", cid);
 290                 exit(EX_PROVIDER_ERROR);
 291         }
 292
 293         rb_strlcpy(auth->l_ip, l_ip, sizeof(auth->l_ip));
 294         auth->l_port = (uint16_t)atoi(l_port);  /* should be safe */
 295         (void) rb_inet_pton_sock(l_ip, (struct sockaddr *)&auth->l_addr);
 296         SET_SS_PORT(&auth->l_addr, htons(auth->l_port));
 297
 298         rb_strlcpy(auth->c_ip, c_ip, sizeof(auth->c_ip));
 299         auth->c_port = (uint16_t)atoi(c_port);
 300         (void) rb_inet_pton_sock(c_ip, (struct sockaddr *)&auth->c_addr);
 301         SET_SS_PORT(&auth->c_addr, htons(auth->c_port));
 302
 303         rb_strlcpy(auth->hostname, "*", sizeof(auth->hostname));
 304         rb_strlcpy(auth->username, "*", sizeof(auth->username));
 305
 306         auth->data = rb_malloc(allocated_pids * sizeof(struct auth_client_data));
 307
 308         auth->providers_starting = true;
 309         RB_DLINK_FOREACH(ptr, auth_providers.head)
 310         {
 311                 struct auth_provider *provider = ptr->data;
 312
 313                 auth->data[provider->id].provider = provider;
 314
 315                 lrb_assert(provider->start != NULL);
 316
 317                 /* Execute providers */
 318                 if(!provider->start(auth))
 319                         /* Rejected immediately */
 320                         goto done;
 321
 322                 if(auth->providers_cancelled)
 323                         break;
 324         }
 325         auth->providers_starting = false;
 326
 327         /* If no providers are running, accept the client */
 328         if(auth->providers_active == 0)
 329                 accept_client(auth);
 330
 331 done:
 332         auth_client_unref(auth);
 333 }
 334
 335 /* Callback for the initiation */
 336 void
 337 handle_new_connection(int parc, char *parv[])
 338 {
 339         if(parc < 6)
 340         {
 341                 warn_opers(L_CRIT, "provider: received too few params for new connection (6 expected, got %d)", parc);
 342                 exit(EX_PROVIDER_ERROR);
 343         }
 344
 345         start_auth(parv[1], parv[2], parv[3], parv[4], parv[5]);
 346 }
 347
 348 void
 349 handle_cancel_connection(int parc, char *parv[])
 350 {
 351         struct auth_client *auth;
 352         unsigned long long lcid;
 353
 354         if(parc < 2)
 355         {
 356                 warn_opers(L_CRIT, "provider: received too few params for new connection (2 expected, got %d)", parc);
 357                 exit(EX_PROVIDER_ERROR);
 358         }
 359
 360         lcid = strtoull(parv[1], NULL, 16);
 361         if(lcid == 0 || lcid > UINT32_MAX)
 362         {
 363                 warn_opers(L_CRIT, "provider: got a request to cancel a connection that can't exist: %s", parv[1]);
 364                 exit(EX_PROVIDER_ERROR);
 365         }
 366
 367         if((auth = rb_dictionary_retrieve(auth_clients, RB_UINT_TO_POINTER((uint32_t)lcid))) == NULL)
 368         {
 369                 /* This could happen as a race if we've accepted/rejected but they cancel, so don't die here.
 370                  * --Elizafox */
 371                 return;
 372         }
 373
 374         auth_client_ref(auth);
 375         cancel_providers(auth);
 376         auth_client_unref(auth);
 377 }
 378
 379 static void
 380 provider_timeout_event(void *notused __unused)
 381 {
 382         struct auth_client *auth;
 383         rb_dictionary_iter iter;
 384         const time_t curtime = rb_current_time();
 385
 386         RB_DICTIONARY_FOREACH(auth, &iter, auth_clients)
 387         {
 388                 rb_dlink_node *ptr;
 389
 390                 auth_client_ref(auth);
 391
 392                 RB_DLINK_FOREACH(ptr, auth_providers.head)
 393                 {
 394                         struct auth_provider *provider = ptr->data;
 395                         const time_t timeout = get_provider_timeout(auth, provider->id);
 396
 397                         if(is_provider_running(auth, provider->id) && provider->timeout != NULL &&
 398                                 timeout > 0 && timeout < curtime)
 399                         {
 400                                 provider->timeout(auth);
 401                         }
 402                 }
 403
 404                 auth_client_unref(auth);
 405         }
 406 }