granicus.if.org Git - shadow/blob - src/chfn.c

   1 /*
   2  * Copyright 1989 - 1994, Julianne Frances Haugh
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of Julianne F. Haugh nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY JULIE HAUGH AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED. IN NO EVENT SHALL JULIE HAUGH OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #include <config.h>
  31
  32 #ident "$Id: chfn.c,v 1.41 2006/05/07 17:44:39 kloczek Exp $"
  33
  34 #include <fcntl.h>
  35 #include <pwd.h>
  36 #include <signal.h>
  37 #include <stdio.h>
  38 #include <sys/types.h>
  39 #ifdef HAVE_SHADOW_H
  40 #include <shadow.h>
  41 #endif
  42 #ifdef WITH_SELINUX
  43 #include <selinux/selinux.h>
  44 #include <selinux/av_permissions.h>
  45 #endif
  46 #include "defines.h"
  47 #include "exitcodes.h"
  48 #include "getdef.h"
  49 #include "nscd.h"
  50 #ifdef USE_PAM
  51 #include "pam_defs.h"
  52 #endif
  53 #include "prototypes.h"
  54 #include "pwauth.h"
  55 #include "pwio.h"
  56 /*
  57  * Global variables.
  58  */
  59 static char *Prog;
  60 static char fullnm[BUFSIZ];
  61 static char roomno[BUFSIZ];
  62 static char workph[BUFSIZ];
  63 static char homeph[BUFSIZ];
  64 static char slop[BUFSIZ];
  65 static int amroot;
  66
  67 /*
  68  * External identifiers
  69  */
  70
  71 /* local function prototypes */
  72 static void usage (void);
  73 static int may_change_field (int);
  74 static void new_fields (void);
  75 static char *copy_field (char *, char *, char *);
  76
  77 /*
  78  * usage - print command line syntax and exit
  79  */
  80 static void usage (void)
  81 {
  82         if (amroot)
  83                 fprintf (stderr,
  84                          _("Usage: %s [-f full_name] [-r room_no] "
  85                            "[-w work_ph]\n"
  86                            "\t[-h home_ph] [-o other] [user]\n"), Prog);
  87         else
  88                 fprintf (stderr,
  89                          _("Usage: %s [-f full_name] [-r room_no] "
  90                            "[-w work_ph] [-h home_ph]\n"), Prog);
  91         exit (E_USAGE);
  92 }
  93
  94
  95 static int may_change_field (int field)
  96 {
  97         const char *cp;
  98
  99         /*
 100          * CHFN_RESTRICT can now specify exactly which fields may be changed
 101          * by regular users, by using any combination of the following
 102          * letters:
 103          *  f - full name
 104          *  r - room number
 105          *  w - work phone
 106          *  h - home phone
 107          *
 108          * This makes it possible to disallow changing the room number
 109          * information, for example - this feature was suggested by Maciej
 110          * 'Tycoon' Majchrowski.
 111          *
 112          * For backward compatibility, "yes" is equivalent to "rwh",
 113          * "no" is equivalent to "frwh". Only root can change anything
 114          * if the string is empty or not defined at all.
 115          */
 116         if (amroot)
 117                 return 1;
 118         cp = getdef_str ("CHFN_RESTRICT");
 119         if (!cp)
 120                 cp = "";
 121         else if (strcmp (cp, "yes") == 0)
 122                 cp = "rwh";
 123         else if (strcmp (cp, "no") == 0)
 124                 cp = "frwh";
 125         if (strchr (cp, field))
 126                 return 1;
 127         return 0;
 128 }
 129
 130 /*
 131  * new_fields - change the user's GECOS information interactively
 132  *
 133  * prompt the user for each of the four fields and fill in the fields from
 134  * the user's response, or leave alone if nothing was entered.
 135  */
 136 static void new_fields (void)
 137 {
 138         printf (_("Enter the new value, or press ENTER for the default\n"));
 139
 140         if (may_change_field ('f'))
 141                 change_field (fullnm, sizeof fullnm, _("Full Name"));
 142         else
 143                 printf (_("\tFull Name: %s\n"), fullnm);
 144
 145         if (may_change_field ('r'))
 146                 change_field (roomno, sizeof roomno, _("Room Number"));
 147         else
 148                 printf (_("\tRoom Number: %s\n"), roomno);
 149
 150         if (may_change_field ('w'))
 151                 change_field (workph, sizeof workph, _("Work Phone"));
 152         else
 153                 printf (_("\tWork Phone: %s\n"), workph);
 154
 155         if (may_change_field ('h'))
 156                 change_field (homeph, sizeof homeph, _("Home Phone"));
 157         else
 158                 printf (_("\tHome Phone: %s\n"), homeph);
 159
 160         if (amroot)
 161                 change_field (slop, sizeof slop, _("Other"));
 162 }
 163
 164 /*
 165  * copy_field - get the next field from the gecos field
 166  *
 167  * copy_field copies the next field from the gecos field, returning a
 168  * pointer to the field which follows, or NULL if there are no more fields.
 169  *
 170  *      in - the current GECOS field
 171  *      out - where to copy the field to
 172  *      extra - fields with '=' get copied here
 173  */
 174 static char *copy_field (char *in, char *out, char *extra)
 175 {
 176         char *cp = NULL;
 177
 178         while (in) {
 179                 if ((cp = strchr (in, ',')))
 180                         *cp++ = '\0';
 181
 182                 if (!strchr (in, '='))
 183                         break;
 184
 185                 if (extra) {
 186                         if (extra[0])
 187                                 strcat (extra, ",");
 188
 189                         strcat (extra, in);
 190                 }
 191                 in = cp;
 192         }
 193         if (in && out)
 194                 strcpy (out, in);
 195
 196         return cp;
 197 }
 198
 199 /*
 200  * chfn - change a user's password file information
 201  *
 202  *      This command controls the GECOS field information in the password
 203  *      file entry.
 204  *
 205  *      The valid options are
 206  *
 207  *      -f      full name
 208  *      -r      room number
 209  *      -w      work phone number
 210  *      -h      home phone number
 211  *      -o      other information (*)
 212  *
 213  *      (*) requires root permission to execute.
 214  */
 215 int main (int argc, char **argv)
 216 {
 217         char *cp;               /* temporary character pointer       */
 218         const struct passwd *pw;        /* password file entry               */
 219         struct passwd pwent;    /* modified password file entry      */
 220         char old_gecos[BUFSIZ]; /* buffer for old GECOS fields       */
 221         char new_gecos[BUFSIZ]; /* buffer for new GECOS fields       */
 222         int flag;               /* flag currently being processed    */
 223         int fflg = 0;           /* -f - set full name                */
 224         int rflg = 0;           /* -r - set room number              */
 225         int wflg = 0;           /* -w - set work phone number        */
 226         int hflg = 0;           /* -h - set home phone number        */
 227         int oflg = 0;           /* -o - set other information        */
 228         char *user;
 229
 230 #ifdef USE_PAM
 231         pam_handle_t *pamh = NULL;
 232         struct passwd *pampw;
 233         int retval;
 234 #endif
 235
 236         sanitize_env ();
 237         setlocale (LC_ALL, "");
 238         bindtextdomain (PACKAGE, LOCALEDIR);
 239         textdomain (PACKAGE);
 240
 241         /*
 242          * This command behaves different for root and non-root
 243          * users.
 244          */
 245         amroot = (getuid () == 0);
 246
 247         /*
 248          * Get the program name. The program name is used as a
 249          * prefix to most error messages.
 250          */
 251         Prog = Basename (argv[0]);
 252
 253         OPENLOG ("chfn");
 254
 255         /*
 256          * The remaining arguments will be processed one by one and executed
 257          * by this command. The name is the last argument if it does not
 258          * begin with a "-", otherwise the name is determined from the
 259          * environment and must agree with the real UID. Also, the UID will
 260          * be checked for any commands which are restricted to root only.
 261          */
 262         while ((flag = getopt (argc, argv, "f:r:w:h:o:")) != EOF) {
 263                 switch (flag) {
 264                 case 'f':
 265                         if (!may_change_field ('f')) {
 266                                 fprintf (stderr,
 267                                          _("%s: Permission denied.\n"), Prog);
 268                                 exit (E_NOPERM);
 269                         }
 270                         fflg++;
 271                         STRFCPY (fullnm, optarg);
 272                         break;
 273                 case 'h':
 274                         if (!may_change_field ('h')) {
 275                                 fprintf (stderr,
 276                                          _("%s: Permission denied.\n"), Prog);
 277                                 exit (E_NOPERM);
 278                         }
 279                         hflg++;
 280                         STRFCPY (homeph, optarg);
 281                         break;
 282                 case 'r':
 283                         if (!may_change_field ('r')) {
 284                                 fprintf (stderr,
 285                                          _("%s: Permission denied.\n"), Prog);
 286                                 exit (E_NOPERM);
 287                         }
 288                         rflg++;
 289                         STRFCPY (roomno, optarg);
 290                         break;
 291                 case 'o':
 292                         if (!amroot) {
 293                                 fprintf (stderr,
 294                                          _("%s: Permission denied.\n"), Prog);
 295                                 exit (E_NOPERM);
 296                         }
 297                         oflg++;
 298                         STRFCPY (slop, optarg);
 299                         break;
 300                 case 'w':
 301                         if (!may_change_field ('w')) {
 302                                 fprintf (stderr,
 303                                          _("%s: Permission denied.\n"), Prog);
 304                                 exit (E_NOPERM);
 305                         }
 306                         wflg++;
 307                         STRFCPY (workph, optarg);
 308                         break;
 309                 default:
 310                         usage ();
 311                 }
 312         }
 313
 314         /*
 315          * Get the name of the user to check. It is either the command line
 316          * name, or the name getlogin() returns.
 317          */
 318         if (optind < argc) {
 319                 user = argv[optind];
 320                 pw = getpwnam (user);
 321                 if (!pw) {
 322                         fprintf (stderr, _("%s: unknown user %s\n"), Prog,
 323                                  user);
 324                         exit (E_NOPERM);
 325                 }
 326         } else {
 327                 pw = get_my_pwent ();
 328                 if (!pw) {
 329                         fprintf (stderr,
 330                                  _
 331                                  ("%s: Cannot determine your user name.\n"),
 332                                  Prog);
 333                         exit (E_NOPERM);
 334                 }
 335                 user = xstrdup (pw->pw_name);
 336         }
 337
 338 #ifdef  USE_NIS
 339         /*
 340          * Now we make sure this is a LOCAL password entry for this user ...
 341          */
 342         if (__ispwNIS ()) {
 343                 char *nis_domain;
 344                 char *nis_master;
 345
 346                 fprintf (stderr,
 347                          _("%s: cannot change user '%s' on NIS client.\n"),
 348                          Prog, user);
 349
 350                 if (!yp_get_default_domain (&nis_domain) &&
 351                     !yp_master (nis_domain, "passwd.byname", &nis_master)) {
 352                         fprintf (stderr,
 353                                  _
 354                                  ("%s: '%s' is the NIS master for this client.\n"),
 355                                  Prog, nis_master);
 356                 }
 357                 exit (E_NOPERM);
 358         }
 359 #endif
 360
 361         /*
 362          * Non-privileged users are only allowed to change the gecos field
 363          * if the UID of the user matches the current real UID.
 364          */
 365         if (!amroot && pw->pw_uid != getuid ()) {
 366                 fprintf (stderr, _("%s: Permission denied.\n"), Prog);
 367                 closelog ();
 368                 exit (E_NOPERM);
 369         }
 370 #ifdef WITH_SELINUX
 371         /*
 372          * If the UID of the user does not match the current real UID,
 373          * check if the change is allowed by SELinux policy.
 374          */
 375         if ((pw->pw_uid != getuid ())
 376             && (is_selinux_enabled () > 0)
 377             && (selinux_check_passwd_access (PASSWD__CHFN) != 0)) {
 378                 fprintf (stderr, _("%s: Permission denied.\n"), Prog);
 379                 closelog ();
 380                 exit (E_NOPERM);
 381         }
 382 #endif
 383
 384 #ifndef USE_PAM
 385         /*
 386          * Non-privileged users are optionally authenticated (must enter the
 387          * password of the user whose information is being changed) before
 388          * any changes can be made. Idea from util-linux chfn/chsh.
 389          * --marekm
 390          */
 391         if (!amroot && getdef_bool ("CHFN_AUTH"))
 392                 passwd_check (pw->pw_name, pw->pw_passwd, "chfn");
 393
 394 #else                           /* !USE_PAM */
 395         retval = PAM_SUCCESS;
 396
 397         pampw = getpwuid (getuid ());
 398         if (pampw == NULL) {
 399                 retval = PAM_USER_UNKNOWN;
 400         }
 401
 402         if (retval == PAM_SUCCESS) {
 403                 retval = pam_start ("chfn", pampw->pw_name, &conv, &pamh);
 404         }
 405
 406         if (retval == PAM_SUCCESS) {
 407                 retval = pam_authenticate (pamh, 0);
 408                 if (retval != PAM_SUCCESS) {
 409                         pam_end (pamh, retval);
 410                 }
 411         }
 412
 413         if (retval == PAM_SUCCESS) {
 414                 retval = pam_acct_mgmt (pamh, 0);
 415                 if (retval != PAM_SUCCESS) {
 416                         pam_end (pamh, retval);
 417                 }
 418         }
 419
 420         if (retval != PAM_SUCCESS) {
 421                 fprintf (stderr, _("%s: PAM authentication failed\n"), Prog);
 422                 exit (E_NOPERM);
 423         }
 424 #endif                          /* USE_PAM */
 425
 426         /*
 427          * Now get the full name. It is the first comma separated field in
 428          * the GECOS field.
 429          */
 430         STRFCPY (old_gecos, pw->pw_gecos);
 431         cp = copy_field (old_gecos, fflg ? (char *) 0 : fullnm, slop);
 432
 433         /*
 434          * Now get the room number. It is the next comma separated field,
 435          * if there is indeed one.
 436          */
 437         if (cp)
 438                 cp = copy_field (cp, rflg ? (char *) 0 : roomno, slop);
 439
 440         /*
 441          * Now get the work phone number. It is the third field.
 442          */
 443         if (cp)
 444                 cp = copy_field (cp, wflg ? (char *) 0 : workph, slop);
 445
 446         /*
 447          * Now get the home phone number. It is the fourth field.
 448          */
 449         if (cp)
 450                 cp = copy_field (cp, hflg ? (char *) 0 : homeph, slop);
 451
 452         /*
 453          * Anything left over is "slop".
 454          */
 455         if (cp && !oflg) {
 456                 if (slop[0])
 457                         strcat (slop, ",");
 458
 459                 strcat (slop, cp);
 460         }
 461
 462         /*
 463          * If none of the fields were changed from the command line, let the
 464          * user interactively change them.
 465          */
 466         if (!fflg && !rflg && !wflg && !hflg && !oflg) {
 467                 printf (_("Changing the user information for %s\n"), user);
 468                 new_fields ();
 469         }
 470
 471         /*
 472          * Check all of the fields for valid information
 473          */
 474         if (valid_field (fullnm, ":,=")) {
 475                 fprintf (stderr, _("%s: invalid name: '%s'\n"), Prog, fullnm);
 476                 closelog ();
 477                 exit (E_NOPERM);
 478         }
 479         if (valid_field (roomno, ":,=")) {
 480                 fprintf (stderr, _("%s: invalid room number: '%s'\n"),
 481                          Prog, roomno);
 482                 closelog ();
 483                 exit (E_NOPERM);
 484         }
 485         if (valid_field (workph, ":,=")) {
 486                 fprintf (stderr, _("%s: invalid work phone: '%s'\n"),
 487                          Prog, workph);
 488                 closelog ();
 489                 exit (E_NOPERM);
 490         }
 491         if (valid_field (homeph, ":,=")) {
 492                 fprintf (stderr, _("%s: invalid home phone: '%s'\n"),
 493                          Prog, homeph);
 494                 closelog ();
 495                 exit (E_NOPERM);
 496         }
 497         if (valid_field (slop, ":")) {
 498                 fprintf (stderr,
 499                          _("%s: '%s' contains illegal characters\n"),
 500                          Prog, slop);
 501                 closelog ();
 502                 exit (E_NOPERM);
 503         }
 504
 505         /*
 506          * Build the new GECOS field by plastering all the pieces together,
 507          * if they will fit ...
 508          */
 509         if (strlen (fullnm) + strlen (roomno) + strlen (workph) +
 510             strlen (homeph) + strlen (slop) > (unsigned int) 80) {
 511                 fprintf (stderr, _("%s: fields too long\n"), Prog);
 512                 closelog ();
 513                 exit (E_NOPERM);
 514         }
 515         snprintf (new_gecos, sizeof new_gecos, "%s,%s,%s,%s%s%s",
 516                   fullnm, roomno, workph, homeph, slop[0] ? "," : "", slop);
 517
 518         /*
 519          * Before going any further, raise the ulimit to prevent colliding
 520          * into a lowered ulimit, and set the real UID to root to protect
 521          * against unexpected signals. Any keyboard signals are set to be
 522          * ignored.
 523          */
 524         if (setuid (0)) {
 525                 fprintf (stderr, _("Cannot change ID to root.\n"));
 526                 SYSLOG ((LOG_ERR, "can't setuid(0)"));
 527                 closelog ();
 528                 exit (E_NOPERM);
 529         }
 530         pwd_init ();
 531
 532         /*
 533          * The passwd entry is now ready to be committed back to the
 534          * password file. Get a lock on the file and open it.
 535          */
 536         if (!pw_lock ()) {
 537                 fprintf (stderr,
 538                          _
 539                          ("Cannot lock the password file; try again later.\n"));
 540                 SYSLOG ((LOG_WARN, "can't lock /etc/passwd"));
 541                 closelog ();
 542                 exit (E_NOPERM);
 543         }
 544         if (!pw_open (O_RDWR)) {
 545                 fprintf (stderr, _("Cannot open the password file.\n"));
 546                 pw_unlock ();
 547                 SYSLOG ((LOG_ERR, "can't open /etc/passwd"));
 548                 closelog ();
 549                 exit (E_NOPERM);
 550         }
 551
 552         /*
 553          * Get the entry to update using pw_locate() - we want the real one
 554          * from /etc/passwd, not the one from getpwnam() which could contain
 555          * the shadow password if (despite the warnings) someone enables
 556          * AUTOSHADOW (or SHADOW_COMPAT in libc).  --marekm
 557          */
 558         pw = pw_locate (user);
 559         if (!pw) {
 560                 pw_unlock ();
 561                 fprintf (stderr,
 562                          _("%s: %s not found in /etc/passwd\n"), Prog, user);
 563                 exit (E_NOPERM);
 564         }
 565
 566         /*
 567          * Make a copy of the entry, then change the gecos field. The other
 568          * fields remain unchanged.
 569          */
 570         pwent = *pw;
 571         pwent.pw_gecos = new_gecos;
 572
 573         /*
 574          * Update the passwd file entry. If there is a DBM file, update that
 575          * entry as well.
 576          */
 577         if (!pw_update (&pwent)) {
 578                 fprintf (stderr, _("Error updating the password entry.\n"));
 579                 pw_unlock ();
 580                 SYSLOG ((LOG_ERR, "error updating passwd entry"));
 581                 closelog ();
 582                 exit (E_NOPERM);
 583         }
 584
 585         /*
 586          * Changes have all been made, so commit them and unlock the file.
 587          */
 588         if (!pw_close ()) {
 589                 fprintf (stderr, _("Cannot commit password file changes.\n"));
 590                 pw_unlock ();
 591                 SYSLOG ((LOG_ERR, "can't rewrite /etc/passwd"));
 592                 closelog ();
 593                 exit (E_NOPERM);
 594         }
 595         if (!pw_unlock ()) {
 596                 fprintf (stderr, _("Cannot unlock the password file.\n"));
 597                 SYSLOG ((LOG_ERR, "can't unlock /etc/passwd"));
 598                 closelog ();
 599                 exit (E_NOPERM);
 600         }
 601         SYSLOG ((LOG_INFO, "changed user `%s' information", user));
 602
 603         nscd_flush_cache ("passwd");
 604
 605 #ifdef USE_PAM
 606         if (retval == PAM_SUCCESS)
 607                 pam_end (pamh, PAM_SUCCESS);
 608 #endif                          /* USE_PAM */
 609
 610         closelog ();
 611         exit (E_SUCCESS);
 612 }