etc/afpd/auth.c

   1 /*
   2  * $Id: auth.c,v 1.29 2002-09-26 00:02:47 didg Exp $
   3  *
   4  * Copyright (c) 1990,1993 Regents of The University of Michigan.
   5  * All Rights Reserved.  See COPYRIGHT.
   6  */
   7
   8 #ifdef HAVE_CONFIG_H
   9 #include "config.h"
  10 #endif /* HAVE_CONFIG_H */
  11
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <errno.h>
  15 #ifdef HAVE_UNISTD_H
  16 #include <unistd.h>
  17 #endif /* HAVE_UNISTD_H */
  18 #include <sys/types.h>
  19 #include <sys/param.h>
  20 #include <sys/stat.h>
  21 #include <netatalk/endian.h>
  22 #include <atalk/afp.h>
  23 #include <atalk/compat.h>
  24 #include <atalk/util.h>
  25 #include <limits.h>
  26 #include <string.h>
  27 #include <ctype.h>
  28
  29 #ifdef SHADOWPW
  30 #include <shadow.h>
  31 #endif /* SHADOWPW */
  32
  33 #include <pwd.h>
  34 #include <grp.h>
  35 #include <atalk/logger.h>
  36
  37 #ifdef TRU64
  38 #include <netdb.h>
  39 #include <arpa/inet.h>
  40 #include <sia.h>
  41 #include <siad.h>
  42
  43 extern void afp_get_cmdline( int *ac, char ***av );
  44 #endif /* TRU64 */
  45
  46 #include "globals.h"
  47 #include "auth.h"
  48 #include "uam_auth.h"
  49 #include "switch.h"
  50 #include "status.h"
  51
  52 int     afp_version = 11;
  53 static int afp_version_index;
  54
  55 uid_t   uuid;
  56 #if defined( __svr4__ ) && !defined( NGROUPS )
  57 #define NGROUPS NGROUPS_MAX
  58 #endif /* __svr4__ NGROUPS */
  59 #if defined( sun ) && !defined( __svr4__ ) || defined( ultrix )
  60 int     groups[ NGROUPS ];
  61 #else /* sun __svr4__ ultrix */
  62 #if defined( __svr4__ ) && !defined( NGROUPS )
  63 #define NGROUPS NGROUPS_MAX
  64 #endif /* __svr4__ NGROUPS */
  65 gid_t   groups[ NGROUPS ];
  66 #endif /* sun ultrix */
  67 int     ngroups;
  68
  69 /*
  70  * These numbers are scattered throughout the code.
  71  */
  72 static struct afp_versions      afp_versions[] = {
  73             { "AFPVersion 1.1", 11 },
  74             { "AFPVersion 2.0", 20 },
  75             { "AFPVersion 2.1", 21 },
  76             { "AFP2.2", 22 }
  77         };
  78
  79 static struct uam_mod uam_modules = {NULL, NULL, &uam_modules, &uam_modules};
  80 static struct uam_obj uam_login = {"", "", 0, {{NULL}}, &uam_login,
  81                                       &uam_login};
  82 static struct uam_obj uam_changepw = {"", "", 0, {{NULL}}, &uam_changepw,
  83                                          &uam_changepw};
  84
  85 static struct uam_obj *afp_uam = NULL;
  86
  87
  88 void status_versions( data )
  89 char    *data;
  90 {
  91     char                *start = data;
  92     u_int16_t           status;
  93     int                 len, num, i;
  94
  95     memcpy(&status, start + AFPSTATUS_VERSOFF, sizeof(status));
  96     num = sizeof( afp_versions ) / sizeof( afp_versions[ 0 ] );
  97     data += ntohs( status );
  98     *data++ = num;
  99     for ( i = 0; i < num; i++ ) {
 100         len = strlen( afp_versions[ i ].av_name );
 101         *data++ = len;
 102         memcpy( data, afp_versions[ i ].av_name , len );
 103         data += len;
 104     }
 105     status = htons( data - start );
 106     memcpy(start + AFPSTATUS_UAMSOFF, &status, sizeof(status));
 107 }
 108
 109 void status_uams(char *data, const char *authlist)
 110 {
 111     char                *start = data;
 112     u_int16_t           status;
 113     struct uam_obj      *uams;
 114     int                 len, num = 0;
 115
 116     memcpy(&status, start + AFPSTATUS_UAMSOFF, sizeof(status));
 117     uams = &uam_login;
 118     while ((uams = uams->uam_prev) != &uam_login) {
 119         if (strstr(authlist, uams->uam_path))
 120             num++;
 121     }
 122
 123     data += ntohs( status );
 124     *data++ = num;
 125     while ((uams = uams->uam_prev) != &uam_login) {
 126         if (strstr(authlist, uams->uam_path)) {
 127             LOG(log_info, logtype_afpd, "uam: \"%s\" available", uams->uam_name);
 128             len = strlen( uams->uam_name);
 129             *data++ = len;
 130             memcpy( data, uams->uam_name, len );
 131             data += len;
 132         }
 133     }
 134
 135     /* icon offset */
 136     status = htons(data - start);
 137     memcpy(start + AFPSTATUS_ICONOFF, &status, sizeof(status));
 138 }
 139
 140 /* handle errors by closing the connection. this is only needed
 141  * by the afp_* functions. */
 142 static int send_reply(const AFPObj *obj, const int err)
 143 {
 144     if ((err == AFP_OK) || (err == AFPERR_AUTHCONT))
 145         return err;
 146
 147     obj->reply(obj->handle, err);
 148     obj->exit(0);
 149
 150     return AFP_OK;
 151 }
 152
 153 static int login(AFPObj *obj, struct passwd *pwd, void (*logout)(void))
 154 {
 155 #ifdef ADMIN_GRP
 156     int admin = 0;
 157 #endif /* ADMIN_GRP */
 158
 159     /* UAM had syslog control; afpd needs to reassert itself */
 160     set_processname("afpd");
 161     syslog_setup(log_debug, logtype_default, logoption_ndelay|logoption_pid, logfacility_daemon);
 162
 163     if ( pwd->pw_uid == 0 ) {   /* don't allow root login */
 164         LOG(log_error, logtype_afpd, "login: root login denied!" );
 165         return AFPERR_NOTAUTH;
 166     }
 167
 168     LOG(log_info, logtype_afpd, "login %s (uid %d, gid %d) %s", pwd->pw_name,
 169         pwd->pw_uid, pwd->pw_gid , afp_versions[afp_version_index]);
 170
 171     if (obj->proto == AFPPROTO_ASP) {
 172         ASP asp = obj->handle;
 173         int addr_net = ntohs( asp->asp_sat.sat_addr.s_net );
 174         int addr_node  = asp->asp_sat.sat_addr.s_node;
 175
 176         if (obj->options.authprintdir) {
 177             if(addr_net && addr_node) { /* Do we have a valid Appletalk address? */
 178                 char nodename[256];
 179                 FILE *fp;
 180                 int mypid = getpid();
 181                 struct stat stat_buf;
 182
 183                 sprintf(nodename, "%s/net%d.%dnode%d", obj->options.authprintdir,
 184                         addr_net / 256, addr_net % 256, addr_node);
 185                 LOG(log_info, logtype_afpd, "registering %s (uid %d) on %u.%u as %s",
 186                     pwd->pw_name, pwd->pw_uid, addr_net, addr_node, nodename);
 187
 188                 if (stat(nodename, &stat_buf) == 0) { /* file exists */
 189                     if (S_ISREG(stat_buf.st_mode)) { /* normal file */
 190                         unlink(nodename);
 191                         fp = fopen(nodename, "w");
 192                         fprintf(fp, "%s:%d\n", pwd->pw_name, mypid);
 193                         fclose(fp);
 194                         chown( nodename, pwd->pw_uid, -1 );
 195                     } else { /* somebody is messing with us */
 196                         LOG(log_error, logtype_afpd, "print authfile %s is not a normal file, it will not be modified", nodename );
 197                     }
 198                 } else { /* file 'nodename' does not exist */
 199                     fp = fopen(nodename, "w");
 200                     fprintf(fp, "%s:%d\n", pwd->pw_name, mypid);
 201                     fclose(fp);
 202                     chown( nodename, pwd->pw_uid, -1 );
 203                 }
 204             } /* if (addr_net && addr_node ) */
 205         } /* if (options->authprintdir) */
 206     } /* if (obj->proto == AFPPROTO_ASP) */
 207
 208     if (initgroups( pwd->pw_name, pwd->pw_gid ) < 0) {
 209 #ifdef RUN_AS_USER
 210         LOG(log_info, logtype_afpd, "running with uid %d", geteuid());
 211 #else /* RUN_AS_USER */
 212         LOG(log_error, logtype_afpd, "login: %s", strerror(errno));
 213         return AFPERR_BADUAM;
 214 #endif /* RUN_AS_USER */
 215
 216     }
 217
 218     /* Basically if the user is in the admin group, we stay root */
 219
 220     if (( ngroups = getgroups( NGROUPS, groups )) < 0 ) {
 221         LOG(log_error, logtype_afpd, "login: getgroups: %s", strerror(errno) );
 222         return AFPERR_BADUAM;
 223     }
 224 #ifdef ADMIN_GRP
 225 #ifdef DEBUG
 226     LOG(log_info, logtype_afpd, "obj->options.admingid == %d", obj->options.admingid);
 227 #endif /* DEBUG */
 228     if (obj->options.admingid != 0) {
 229         int i;
 230         for (i = 0; i < ngroups; i++) {
 231             if (groups[i] == obj->options.admingid) admin = 1;
 232         }
 233     }
 234     if (admin) LOG(log_info, logtype_afpd, "admin login -- %s", pwd->pw_name );
 235     if (!admin)
 236 #endif /* DEBUG */
 237 #ifdef TRU64
 238     {
 239         struct DSI *dsi = obj->handle;
 240         struct hostent *hp;
 241         char *clientname;
 242         int argc;
 243         char **argv;
 244         char hostname[256];
 245
 246         afp_get_cmdline( &argc, &argv );
 247
 248         hp = gethostbyaddr( (char *) &dsi->client.sin_addr,
 249                             sizeof( struct in_addr ),
 250                             dsi->client.sin_family );
 251
 252         if( hp )
 253             clientname = hp->h_name;
 254         else
 255             clientname = inet_ntoa( dsi->client.sin_addr );
 256
 257         sprintf( hostname, "%s@%s", pwd->pw_name, clientname );
 258
 259         if( sia_become_user( NULL, argc, argv, hostname, pwd->pw_name,
 260                              NULL, FALSE, NULL, NULL,
 261                              SIA_BEU_REALLOGIN ) != SIASUCCESS )
 262             return AFPERR_BADUAM;
 263
 264         LOG(log_info, logtype_afpd, "session from %s (%s)", hostname,
 265             inet_ntoa( dsi->client.sin_addr ) );
 266
 267         if (setegid( pwd->pw_gid ) < 0 || seteuid( pwd->pw_uid ) < 0) {
 268             LOG(log_error, logtype_afpd, "login: %s", strerror(errno) );
 269             return AFPERR_BADUAM;
 270         }
 271     }
 272 #else /* TRU64 */
 273         if (setegid( pwd->pw_gid ) < 0 || seteuid( pwd->pw_uid ) < 0) {
 274             LOG(log_error, logtype_afpd, "login: %s", strerror(errno) );
 275             return AFPERR_BADUAM;
 276         }
 277 #endif /* TRU64 */
 278
 279     /* There's probably a better way to do this, but for now, we just
 280     play root */
 281
 282 #ifdef ADMIN_GRP
 283     if (admin) uuid = 0;
 284     else
 285 #endif /* ADMIN_GRP */
 286         uuid = pwd->pw_uid;
 287
 288     afp_switch = postauth_switch;
 289     obj->logout = logout;
 290
 291 #ifdef FORCE_UIDGID
 292     obj->force_uid = 1;
 293     save_uidgid ( &obj->uidgid );
 294 #endif
 295
 296     return( AFP_OK );
 297 }
 298
 299 int afp_login(obj, ibuf, ibuflen, rbuf, rbuflen )
 300 AFPObj      *obj;
 301 char    *ibuf, *rbuf;
 302 int             ibuflen, *rbuflen;
 303 {
 304     struct passwd *pwd = NULL;
 305     int         len, i, num;
 306
 307     *rbuflen = 0;
 308
 309
 310     if ( nologin & 1)
 311         return send_reply(obj, AFPERR_SHUTDOWN );
 312
 313     if (ibuflen <= 1)
 314         return send_reply(obj, AFPERR_BADVERS );
 315
 316     ibuf++;
 317     len = (unsigned char) *ibuf++;
 318
 319     ibuflen -= 2;
 320     if (!len || len > ibuflen)
 321         return send_reply(obj, AFPERR_BADVERS );
 322
 323     num = sizeof( afp_versions ) / sizeof( afp_versions[ 0 ]);
 324     for ( i = 0; i < num; i++ ) {
 325         if ( strncmp( ibuf, afp_versions[ i ].av_name , len ) == 0 ) {
 326             afp_version = afp_versions[ i ].av_number;
 327             afp_version_index = i;
 328             break;
 329         }
 330     }
 331     if ( i == num )                             /* An inappropo version */
 332         return send_reply(obj, AFPERR_BADVERS );
 333     ibuf += len;
 334     ibuflen -= len;
 335
 336     if (ibuflen <= 1)
 337         return send_reply(obj, AFPERR_BADUAM);
 338
 339     len = (unsigned char) *ibuf++;
 340     ibuflen--;
 341
 342     if (!len || len > ibuflen)
 343         return send_reply(obj, AFPERR_BADUAM);
 344
 345     if ((afp_uam = auth_uamfind(UAM_SERVER_LOGIN, ibuf, len)) == NULL)
 346         return send_reply(obj, AFPERR_BADUAM);
 347     ibuf += len;
 348     ibuflen -= len;
 349
 350     i = afp_uam->u.uam_login.login(obj, &pwd, ibuf, ibuflen, rbuf, rbuflen);
 351     if (i || !pwd)
 352         return send_reply(obj, i);
 353
 354     return send_reply(obj, login(obj, pwd, afp_uam->u.uam_login.logout));
 355 }
 356
 357
 358 int afp_logincont(obj, ibuf, ibuflen, rbuf, rbuflen)
 359 AFPObj      *obj;
 360 char    *ibuf, *rbuf;
 361 int             ibuflen, *rbuflen;
 362 {
 363     struct passwd *pwd = NULL;
 364     int err;
 365
 366     if ( afp_uam == NULL || afp_uam->u.uam_login.logincont == NULL ) {
 367         *rbuflen = 0;
 368         return send_reply(obj, AFPERR_NOTAUTH );
 369     }
 370
 371     ibuf += 2;
 372     err = afp_uam->u.uam_login.logincont(obj, &pwd, ibuf, ibuflen,
 373                                          rbuf, rbuflen);
 374     if (err || !pwd)
 375         return send_reply(obj, err);
 376
 377     return send_reply(obj, login(obj, pwd, afp_uam->u.uam_login.logout));
 378 }
 379
 380
 381 int afp_logout(obj, ibuf, ibuflen, rbuf, rbuflen)
 382 AFPObj     *obj;
 383 char       *ibuf, *rbuf;
 384 int        ibuflen, *rbuflen;
 385 {
 386     LOG(log_info, logtype_afpd, "logout %s", obj->username);
 387     obj->exit(0);
 388     return AFP_OK;
 389 }
 390
 391
 392
 393 /* change password  --
 394  * NOTE: an FPLogin must already have completed successfully for this
 395  *       to work. this also does a little pre-processing before it hands
 396  *       it off to the uam.
 397  */
 398 int afp_changepw(obj, ibuf, ibuflen, rbuf, rbuflen )
 399 AFPObj      *obj;
 400 char    *ibuf, *rbuf;
 401 int             ibuflen, *rbuflen;
 402 {
 403     char username[MACFILELEN + 1], *start = ibuf;
 404     struct uam_obj *uam;
 405     struct passwd *pwd;
 406     int len;
 407
 408     *rbuflen = 0;
 409     ibuf += 2;
 410
 411     /* make sure we can deal w/ this uam */
 412     len = (unsigned char) *ibuf++;
 413     if ((uam = auth_uamfind(UAM_SERVER_CHANGEPW, ibuf, len)) == NULL)
 414         return AFPERR_BADUAM;
 415
 416     ibuf += len;
 417     if ((len + 1) & 1) /* pad byte */
 418         ibuf++;
 419
 420     len = (unsigned char) *ibuf++;
 421     if ( len > sizeof(username) - 1) {
 422         return AFPERR_PARAM;
 423     }
 424     memcpy(username, ibuf, len);
 425     username[ len ] = '\0';
 426     ibuf += len;
 427     if ((len + 1) & 1) /* pad byte */
 428         ibuf++;
 429
 430     LOG(log_info, logtype_afpd, "changing password for <%s>", username);
 431
 432     if (( pwd = uam_getname( username, sizeof(username))) == NULL )
 433         return AFPERR_PARAM;
 434
 435     /* send it off to the uam. we really don't use ibuflen right now. */
 436     ibuflen -= (ibuf - start);
 437     len = uam->u.uam_changepw(obj, username, pwd, ibuf, ibuflen,
 438                               rbuf, rbuflen);
 439     LOG(log_info, logtype_afpd, "password change %s.",
 440         (len == AFPERR_AUTHCONT) ? "continued" :
 441         (len ? "failed" : "succeeded"));
 442     return len;
 443 }
 444
 445
 446 /* FPGetUserInfo */
 447 int afp_getuserinfo(obj, ibuf, ibuflen, rbuf, rbuflen )
 448 AFPObj      *obj;
 449 char    *ibuf, *rbuf;
 450 int             ibuflen, *rbuflen;
 451 {
 452     u_int8_t  thisuser;
 453     u_int32_t id;
 454     u_int16_t bitmap;
 455
 456     *rbuflen = 0;
 457     ibuf++;
 458     thisuser = *ibuf++;
 459     ibuf += sizeof(id); /* userid is not used in AFP 2.0 */
 460     memcpy(&bitmap, ibuf, sizeof(bitmap));
 461     bitmap = ntohs(bitmap);
 462
 463     /* deal with error cases. we don't have to worry about
 464      * AFPERR_ACCESS or AFPERR_NOITEM as geteuid and getegid always
 465      * succeed. */
 466     if (!thisuser)
 467         return AFPERR_PARAM;
 468     if ((bitmap & USERIBIT_ALL) != bitmap)
 469         return AFPERR_BITMAP;
 470
 471     /* copy the bitmap back to reply buffer */
 472     memcpy(rbuf, ibuf, sizeof(bitmap));
 473     rbuf += sizeof(bitmap);
 474     *rbuflen = sizeof(bitmap);
 475
 476     /* copy the user/group info */
 477     if (bitmap & USERIBIT_USER) {
 478         id = htonl(geteuid());
 479         memcpy(rbuf, &id, sizeof(id));
 480         rbuf += sizeof(id);
 481         *rbuflen += sizeof(id);
 482     }
 483
 484     if (bitmap & USERIBIT_GROUP) {
 485         id = htonl(getegid());
 486         memcpy(rbuf, &id, sizeof(id));
 487         rbuf += sizeof(id);
 488         *rbuflen += sizeof(id);
 489     }
 490
 491     return AFP_OK;
 492 }
 493
 494 #define UAM_LIST(type) (((type) == UAM_SERVER_LOGIN) ? &uam_login : \
 495                         (((type) == UAM_SERVER_CHANGEPW) ? \
 496                          &uam_changepw : NULL))
 497
 498 /* just do a linked list search. this could be sped up with a hashed
 499  * list, but i doubt anyone's going to have enough uams to matter. */
 500 struct uam_obj *auth_uamfind(const int type, const char *name,
 501                                          const int len)
 502 {
 503     struct uam_obj *prev, *start;
 504
 505     if (!name || !(start = UAM_LIST(type)))
 506         return NULL;
 507
 508     prev = start;
 509     while ((prev = prev->uam_prev) != start)
 510         if (strndiacasecmp(prev->uam_name, name, len) == 0)
 511             return prev;
 512
 513     return NULL;
 514 }
 515
 516 int auth_register(const int type, struct uam_obj *uam)
 517 {
 518     struct uam_obj *start;
 519
 520     if (!uam || !uam->uam_name || (*uam->uam_name == '\0'))
 521         return -1;
 522
 523     if (!(start = UAM_LIST(type)))
 524         return 0; /* silently fail */
 525
 526     uam_attach(start, uam);
 527     return 0;
 528 }
 529
 530 /* load all of the modules */
 531 int auth_load(const char *path, const char *list)
 532 {
 533     char name[MAXPATHLEN + 1], buf[MAXPATHLEN + 1], *p;
 534     struct uam_mod *mod;
 535     struct stat st;
 536     size_t len;
 537
 538     if (!path || !*path || !list || (len = strlen(path)) > sizeof(name) - 2)
 539         return -1;
 540
 541     strncpy(buf, list, sizeof(buf));
 542     if ((p = strtok(buf, ",")) == NULL)
 543         return -1;
 544
 545     strcpy(name, path);
 546     if (name[len - 1] != '/') {
 547         strcat(name, "/");
 548         len++;
 549     }
 550
 551     while (p) {
 552         strncpy(name + len, p, sizeof(name) - len);
 553         LOG(log_debug, logtype_afpd, "uam: loading (%s)", name);
 554         /*
 555         if ((stat(name, &st) == 0) && (mod = uam_load(name, p))) {
 556         */
 557         if (stat(name, &st) == 0) {
 558             if ((mod = uam_load(name, p))) {
 559                 uam_attach(&uam_modules, mod);
 560                 LOG(log_info, logtype_afpd, "uam: %s loaded", p);
 561             } else {
 562                 LOG(log_info, logtype_afpd, "uam: %s load failure",p);
 563             }
 564         } else {
 565             LOG(log_info, logtype_afpd, "uam: uam not found (status=%d)", stat(name, &st));
 566         }
 567         p = strtok(NULL, ",");
 568     }
 569
 570     return 0;
 571 }
 572
 573 /* get rid of all of the uams */
 574 void auth_unload()
 575 {
 576     struct uam_mod *mod, *prev, *start = &uam_modules;
 577
 578     prev = start->uam_prev;
 579     while ((mod = prev) != start) {
 580         prev = prev->uam_prev;
 581         uam_detach(mod);
 582         uam_unload(mod);
 583     }
 584 }