Return to su.c CVS log

Up to [MW Coherent from dump] / coherent / d / bin

Annotation of coherent/d/bin/su.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Rec'd from Lauren Weinstein, 7-16-84.
        !             3:  * Substitute user-id temporarily or become super user (as you wish).
        !             4:  * Compile -s -n -i.
        !             5:  * Hacked by steve 10/4/90 to correct password bug and for clarity.
        !             6:  */
        !             7: 
        !             8: #include <stdio.h>
        !             9: #include <pwd.h>
        !            10: 
        !            11: extern char *getenv();
        !            12: extern char *getpass();
        !            13: extern char *malloc();
        !            14: 
        !            15: #define ACCNAME "remacc"       /* Remote access password dummy username */
        !            16: #define        DEFSHELL "/bin/sh"      /* Default shell pathname */
        !            17: #define PASSLEN 13             /* Encrypted password length */
        !            18: 
        !            19: #define        bye()   fatal("Sorry")
        !            20: 
        !            21: /* Forward. */
        !            22: extern void    addenviron();
        !            23: extern void    fatal();
        !            24: extern void    getuname();
        !            25: 
        !            26: /* Globals. */
        !            27: char   *defargs[] = { "su", NULL };
        !            28: /* The following are all set by getuname(). */
        !            29: short  gid;
        !            30: char   *password;
        !            31: char   salt[3];
        !            32: short  uid;
        !            33: 
        !            34: main(argc, argv) int argc; char *argv[];
        !            35: {
        !            36:        register int ouid, ogid;
        !            37:        char *command, *prompta, *promptb, *passp;
        !            38:        char **args;
        !            39: 
        !            40:        getuname(argc>1 ? argv[1] : "0");       /* check username */
        !            41:        if (password[0] != '\0' && getuid()) {  /* check password if not already su */
        !            42:                passp = getpass("Password: ");  /* get input password choice */
        !            43:                if ((strlen(password) != PASSLEN)
        !            44:                 || (strcmp(crypt(passp, salt), password) != 0)) {
        !            45:                        ouid = uid;
        !            46:                        ogid = gid;
        !            47:                        getuname("0");          /* check root password too */ 
        !            48:                        if ((strlen(password) != PASSLEN)
        !            49:                         || (strcmp(crypt(passp, salt), password) != 0))
        !            50:                                bye();          /* failure */
        !            51:                        uid = ouid;
        !            52:                        gid = ogid;
        !            53:                }
        !            54:        }
        !            55: 
        !            56:        if (argc > 2) {
        !            57:                command = argv[2];
        !            58:                args = &argv[2];
        !            59:        } else {
        !            60:                command = getenv("SHELL");
        !            61:                if (command == NULL || strlen(command) < 1)
        !            62:                        command = DEFSHELL;
        !            63:                args = defargs;
        !            64:        }
        !            65:        setgid(gid);
        !            66:        setuid(uid);
        !            67:        prompta = getenv("PSN");                /* check for normal prompt */
        !            68:        promptb = getenv("PSS");                /* check for desired su prompt */
        !            69:        addenviron(uid == 0 ? (promptb ? promptb : "# ")
        !            70:                            : (prompta ? prompta : "$ "));
        !            71:                                                /* change prompt as appropriate */
        !            72:        execvp(command, args);
        !            73:        fatal("%s: not found", command);
        !            74: }
        !            75: 
        !            76: /*
        !            77:  * Add string 's' to the environment as "PS1".
        !            78:  */
        !            79: void
        !            80: addenviron(s) char *s;
        !            81: {
        !            82:        extern char **environ;
        !            83:        register char **epp1, **epp2;
        !            84:        register char **newenv;
        !            85:        int n;
        !            86:        char *prompt;
        !            87:        static char prbuf[50];
        !            88: 
        !            89:        for (epp1 = environ; *epp1!=NULL; epp1++)
        !            90:                ;
        !            91:        n = (epp1-environ+2) * sizeof (char *);
        !            92:        if ((newenv = (char **)malloc(n)) == NULL)
        !            93:                fatal("Out of memory for environments");
        !            94:        prompt = prbuf;
        !            95:        strcpy(prompt, "PS1=");
        !            96:        strcat(prompt, s);
        !            97:        for (epp1=environ, epp2=newenv; *epp1 != NULL; epp1++)
        !            98:                if (strncmp(*epp1, "PS1=", 4) != 0)
        !            99:                        *epp2++ = *epp1;
        !           100:                else {
        !           101:                        *epp2++ = prompt;
        !           102:                        prompt = NULL;
        !           103:                }
        !           104:        *epp2++ = prompt;
        !           105:        *epp2 = NULL;
        !           106:        environ = newenv;
        !           107: }
        !           108: 
        !           109: void
        !           110: fatal(s) char *s;
        !           111: {
        !           112:        fprintf(stderr, "%r\n", &s);
        !           113:        exit(1);
        !           114: }
        !           115: 
        !           116: /*
        !           117:  * Get a user-name from string 's'.
        !           118:  * If the string starts with a numeric, use it directly as a uid.
        !           119:  * Set globals password, salt[], gid and uid with the user's password info.
        !           120:  * Die if not found or illegal.
        !           121:  */
        !           122: void
        !           123: getuname(s) register char *s;
        !           124: {
        !           125:        register struct passwd *pwp;
        !           126: 
        !           127:        if (*s >= '0' && *s <= '9') {
        !           128:                uid = atoi(s);
        !           129:                if ((pwp = getpwuid(uid)) == NULL)
        !           130:                        fatal("%d: bad user number", uid);
        !           131:        } else if ((pwp = getpwnam(s)) == NULL)
        !           132:                fatal("%s: not a user name", s);
        !           133:        if (strcmp(pwp->pw_name, ACCNAME) == 0) /* dummy access username? */
        !           134:                bye();                          /* yes, sorry */
        !           135:        password = pwp->pw_passwd;
        !           136:        salt[0] = pwp->pw_passwd[0];
        !           137:        salt[1] = pwp->pw_passwd[1];
        !           138:        salt[2] = '\0';
        !           139:        gid = pwp->pw_gid;
        !           140:        uid = pwp->pw_uid;
        !           141: }
        !           142: 
        !           143: /* end of su.c */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.