Ich werde demnächst eine Seite mit Boilerplate und eine mit Jquerymobile umsetzen. Ich finde beide sehr interessant und werde mich etwas mehr damit befassen.
Derzeit habe ich wieder Lust eine Map anzufangen. Ich glaube für das Spiel Half-Life² Deathmatch. Jedoch fehlt es derzeit noch an genug Ideen dafür. Vage Vorstellungen habe ich jedoch, diese müssen aber noch enorm ausgearbeitet werden. Ich hoffe auf baldige Einfälle (die kommen ja eh immer zufällig zu den unmöglichsten Momenten).
Canyoucrackit.co.uk
| C | | copy code | | ? |
| 001 | #include <stdio .h> |
| 002 | #include <stdint .h> |
| 003 | #include <malloc .h> |
| 004 | #include <stdlib .h> |
| 005 | #include <errno .h> |
| 006 | #include <string .h> |
| 007 | #include <time .h> |
| 008 | #include <sys /types.h> |
| 009 | #include </sys><sys /mman.h> |
| 010 | #include </sys><sys /utsname.h> |
| 011 | |
| 012 | #include "part2.h" |
| 013 | |
| 014 | static char part1[] = { |
| 015 | 0xeb, 0x04, 0xaf, 0xc2, 0xbf, 0xa3, 0x81, 0xec, 0x00, 0x01, 0x00, 0x00, 0x31, 0xc9, 0x88, 0x0c, |
| 016 | 0x0c, 0xfe, 0xc1, 0x75, 0xf9, 0x31, 0xc0, 0xba, 0xef, 0xbe, 0xad, 0xde, 0x02, 0x04, 0x0c, 0x00, |
| 017 | 0xd0, 0xc1, 0xca, 0x08, 0x8a, 0x1c, 0x0c, 0x8a, 0x3c, 0x04, 0x88, 0x1c, 0x04, 0x88, 0x3c, 0x0c, |
| 018 | 0xfe, 0xc1, 0x75, 0xe8, 0xe9, 0x5c, 0x00, 0x00, 0x00, 0x89, 0xe3, 0x81, 0xc3, 0x04, 0x00, 0x00, |
| 019 | 0x00, 0x5c, 0x58, 0x3d, 0x41, 0x41, 0x41, 0x41, 0x75, 0x43, 0x58, 0x3d, 0x42, 0x42, 0x42, 0x42, |
| 020 | 0x75, 0x3b, 0x5a, 0x89, 0xd1, 0x89, 0xe6, 0x89, 0xdf, 0x29, 0xcf, 0xf3, 0xa4, 0x89, 0xde, 0x89, |
| 021 | 0xd1, 0x89, 0xdf, 0x29, 0xcf, 0x31, 0xc0, 0x31, 0xdb, 0x31, 0xd2, 0xfe, 0xc0, 0x02, 0x1c, 0x06, |
| 022 | 0x8a, 0x14, 0x06, 0x8a, 0x34, 0x1e, 0x88, 0x34, 0x06, 0x88, 0x14, 0x1e, 0x00, 0xf2, 0x30, 0xf6, |
| 023 | 0x8a, 0x1c, 0x16, 0x8a, 0x17, 0x30, 0xda, 0x88, 0x17, 0x47, 0x49, 0x75, 0xde, 0x31, 0xdb, 0x89, |
| 024 | 0xd8, 0xfe, 0xc0, 0xcd, 0x80, 0x90, 0x90, 0xe8, 0x9d, 0xff, 0xff, 0xff, 0x41, 0x41, 0x41, 0x41, |
| 025 | }; |
| 026 | |
| 027 | // code to dump the decrypted memory: |
| 028 | static const char dump_mem[] = { |
| 029 | 0xba, 0x31, 0x00, 0x00, 0x00, // mov edx, 0x40 |
| 030 | 0x8d, 0x4f, 0xce, // lea ecx, [edi-0x32] |
| 031 | 0x31, 0xdb, // xor ebx, ebx |
| 032 | 0x43, // inc ebx (stdout) |
| 033 | 0x31, 0xc0, // xor eax, eax |
| 034 | 0xb0, 0x04, // add al, 0x4 - sys_write |
| 035 | 0xcd, 0x80, // int 0x80 |
| 036 | 0x31, 0xdb, // xor ebx,ebx |
| 037 | 0x43, // inc ebx |
| 038 | 0x31, 0xd2, // xor edx,edx |
| 039 | 0x42, // inc edx |
| 040 | 0x68, 0x0a, 0x00,0x00, 0x00, // push 0xa |
| 041 | 0x8d, 0x0c, 0x24, // lea ecx,[esp] |
| 042 | 0xb8, 0x04, 0x00,0x00, 0x00, // mov eax, 0x4 |
| 043 | 0xcd, 0x80, // int 0x80 - sys_write |
| 044 | 0x31, 0xdb, // xor ebx,ebx |
| 045 | 0x31, 0xc0, // xor eax,eax |
| 046 | 0x40, // inc eax |
| 047 | 0xcd, 0x80, // int 0x80 - sys_exit |
| 048 | }; |
| 049 | |
| 050 | uint32_t patch_mem(char *ptr, size_t size) |
| 051 | { |
| 052 | uint32_t i; |
| 053 | |
| 054 | for (i = 0; i < size; i++) { |
| 055 | if (*(uint16_t *)&ptr[i] == 0x80cd) { |
| 056 | *(uint16_t *)&ptr[i] = 0x45eb; |
| 057 | return 0; |
| 058 | } |
| 059 | } |
| 060 | return 1; |
| 061 | } |
| 062 | |
| 063 | uint32_t check_arch(void) |
| 064 | { |
| 065 | struct utsname kernel_info; |
| 066 | |
| 067 | uname(&kernel_info); |
| 068 | return strcmp(kernel_info.machine, "i686") ? 1 : 0; |
| 069 | } |
| 070 | |
| 071 | int main(int argc, char **argv) |
| 072 | { |
| 073 | void *mem; |
| 074 | |
| 075 | if (check_arch()) { |
| 076 | printf("[-] this program must run on a 32-bit architecture\n"); |
| 077 | return 1; |
| 078 | } |
| 079 | |
| 080 | printf("[*] allocating page aligned memory\n"); |
| 081 | mem = memalign(4096, 4096); |
| 082 | if (!mem) { |
| 083 | printf("[-] error: %s\n", strerror(errno)); |
| 084 | return 1; |
| 085 | } |
| 086 | memset(mem, 0, 4096); |
| 087 | |
| 088 | printf("[*] setting page permissions\n"); |
| 089 | if (mprotect(mem, 4096, PROT_READ | PROT_WRITE | PROT_EXEC)) { |
| 090 | printf("[-] error: %s\n", strerror(errno)); |
| 091 | return 1; |
| 092 | } |
| 093 | |
| 094 | printf("[*] copying payload\n"); |
| 095 | |
| 096 | memcpy(mem, part1, sizeof(part1)); |
| 097 | memcpy(mem + sizeof(part1), part2, sizeof(part2)); |
| 098 | memcpy(mem + sizeof(part1) + sizeof(part2), dump_mem, sizeof(dump_mem)); |
| 099 | |
| 100 | printf("[*] adding dump_mem payload\n"); |
| 101 | if (patch_mem(mem, sizeof(part1))) { |
| 102 | printf("[-] failed to patch memory\n"); |
| 103 | return 0; |
| 104 | } |
| 105 | |
| 106 | printf("[*] executing payload..\n\n"); |
| 107 | |
| 108 | ((int(*)(void))mem)(); |
| 109 | |
| 110 | return 0; |
| 111 | } |
| C | | copy code | | ? |
| 01 | #ifndef PART2_H |
| 02 | #define PART2_H |
| 03 | |
| 04 | // base64 encoded data in the png header |
| 05 | static char part2[] = { |
| 06 | 0x42, 0x42, 0x42, 0x42, 0x32, 0x00, 0x00, 0x00, 0x91, 0xd8, 0xf1, 0x6d, 0x70, 0x20, 0x3a, 0xab, |
| 07 | 0x67, 0x9a, 0x0b, 0xc4, 0x91, 0xfb, 0xc7, 0x66, 0x0f, 0xfc, 0xcd, 0xcc, 0xb4, 0x02, 0xfa, 0xd7, |
| 08 | 0x77, 0xb4, 0x54, 0x38, 0xab, 0x1f, 0x0e, 0xe3, 0x8e, 0xd3, 0x0d, 0xeb, 0x99, 0xc3, 0x93, 0xfe, |
| 09 | 0xd1, 0x2b, 0x1b, 0x11, 0xc6, 0x11, 0xef, 0xc8, 0xca, 0x2f, |
| 10 | }; |
| 11 | |
| 12 | #endif |
Muss auf einem Linux System ausgeführt werden.
canyoucrackit.co.uk
springsummer.dk
Super gemachte Webseite. Das inspiriert mich gleich für ein neues Projekt. springsummer.dk
Auf Debian Server SSH einstellen
Heute erkläre ich wie man SSH auf seinem Debian Server so einstellt dass man einen korrekten Schlüssel braucht um sich anzumelden. Auch werden wir die normale Benutzername -> Passwort Anmeldung und den Root Login deaktivieren.
Ich gehe von einem frisch installierten Debian minimal System aus und wir benutzen Putty. Desweiteren wird Puttygen.exe und pageant.exe später benötigt.
Als erstes loggen wir uns auf unseren Server als root ein, dazu geben wir einfach die IP zu ihm im IP Eingabefeld ein, den Port lassen wir so wie er ist. Dies ist der Standardport für SSH. Nun sollten wir nach einem Klick auf Open mit dem Server verbunden sein. Login als root, und dann das Passwort eingeben welches ihr für euren root Account habt. Nun legen wir einen neuen Benutzer an den wir fortan zum Login benutzen.
| Bash | | copy code | | ? |
| 1 | adduser markus |
In meinem Beispiel nehme ich meinen Vornamen als Benutzernamen. Nun wird man noch nach dem UNIX Passwort (legt euer Passwort hier fest) und nach zusätzlichen Informationen wie der volle Name, Raumnummer usw. gefragt. Bis auf das Passwort könnt ihr den Rest freilassen. Bestätigt dann mit y und Enter. Startet nun eine neue Session in Putty und gebt bei ‘login as’ euren eben erstellten Benutzer ein, dann noch das eben gewählte Passwort und ihr seid nun angemeldet.
Startet nun puttygen.exe und klickt auf ‘Generate’, bewegt die Maus im Puttygen Fenster etwas herum, euer Schlüssel ist nun generiert. Unter ‘Key comment’ könnt ihr eure Mailadresse eintragen oder auch das Feld frei lassen. Unter ‘Key passphrase’ tragt ihr nun ein sicheres Passwort ein, wiederholt es im Feld darunter. Merkt euch das Passwort! Nun klickt auf ‘Save public key‘ und speichert das als .txt-Datei ab. Dann noch auf ‘Save private key‘ und als .ppk-Datei an einem Ort auf eurem PC abspeichern der sicher ist. Merkt euch wo ihr das gespeichert habt! Kopiert nun das was oben im Feld steht (komplett). Nun gebt in dem Putty Fenster, bei dem ihr als neuer Benutzer (nicht root) angemeldet seid. Gebt nun folgendes ein:
| Bash | | copy code | | ? |
| 1 | mkdir ~/.ssh/ # erstellt in eurem /home/ Verzeichnis den Ordner .ssh |
| 2 | chmod 700 ~/.ssh # Gibt für .ssh Schreibrechte |
| 3 | nano ~/.ssh/authorized_keys2 # öffnet die Datei authorized_keys2 |
Nun fügt den kopierten Inhalt von puttygen.exe hier rein (einfach Rechtsklick in das Fenster, nicht STRG+V). Speichert es mit STRG+O (es muss nun ‘Wrote 1 line‘ unten angezeigt werden, der Key muss in einer Zeile sein). Schliesst nano nun mit STRG+X. Gebt folgendes ein:
| Bash | | copy code | | ? |
| 1 | chmod 600 ~/.ssh/authorized_keys2 # nimmt die Schreibrechte |
Schliesst nun das Putty Fenster mit eurem privaten Benutzer. Nun öffnet wieder putty.exe und klickt im Reiter Connection auf SSH dann auf AUTH. Unten ist nun eine Eingabezeile, klickt auf Browse uns wählt eure vorher gespeicherte .ppk-Datei. Klickt nun auf Open (vergewissert euch dass ihr die IP auch eingegeben habt). Nun gebt euren Benutzernamen ein (in meinem Fall markus). Es sollte nun dastehen dass der Key benutzt wird. Gebt nun das Passwort für den Key ein (nicht für den Account auf eurem Server). Ihr seid nun eingeloggt. Wechselt zu eurem Fenster in dem noch die Anmeldung für root läuft. Gebt folgendes ein:
| Bash | | copy code | | ? |
| 1 | nano /etc/ssh/sshd_config |
Nun ist die Konifguration für ssh in nano geöffnet. Sucht die Zeile für Port, ändert den Port beliebig, jedoch beachtet dass manche Ports schon benutzt werden. Wählt zB.: 777. Scrollt mit der Pfeiltaste nun nach unten bis zur Zeile PermitRootLogin yes, ändert yes zu no. Nun kann man sich beim System nicht mehr als root anmelden (beim herstellen einer Verbindung). Scroll weiter runter bis #PasswordAuthentication yes, unkommentiert diese Zeile (# entfernen) und macht yes zu no. Nun kann man sich nur noch mit der Key Authentifizierung anmelden. Ändert bei UsePAM den Eintrag auch noch zu no. Abspeichern und folgendes eingeben:
| Bash | | copy code | | ? |
| 1 | /etc/init.d/ssh restart # startet ssh neu und übernimmt die neuen Einstellungen |
Nun öffnen wir pageant.exe und öffnen darin unseren Key, gebt nun das Passwort für euren Key ein. Nun schliesst Putty (lasst das root Fenster aber noch offen falsch was schief läuft und ihr etwas ändern müsst, ansonsten kann es sein dass ihr euch gar nicht mehr anmelden könnt). Öffnet ein neues Putty Fenster und gebt eure IP ein, nun gebt euren gewählten Port ein (den ihr vorhin die Config geschrieben habt). Geht nun wieder auf Connection -> SSH -> Auth und öffnet wieder euren Key. Nun geht auf Connection -> Data und gebt bei Auto-Login username euren privaten Benutzernamen ein (in meinem Fall markus). Speichert nun die Einstellungen (Session Reiter, gebt auch einen Namen für die Einstellung ein). Klickt auf Open und ihr solltet nun automatisch bei eurem System angemeldet werden. Warum? Weil pageant.exe automatisch für den jeweiligen Key das Passwort überträgt (solange pageant.exe läuft). Um nun root zu werden gebt das ein:
| Bash | | copy code | | ? |
| 1 | su root |
Ihr werdet nun nach dem root Passwort gefragt, gebt es ein und ihr seid wieder root.
Man kann sich also nicht mehr direkt als root anmelden und man braucht einen Key zur Anmeldung, nicht nur das Passwort. Somit ist euer System einen kleinen Schritt sicherer. Klar, es ist jetzt nicht die top Lösung. Jedoch als erster Schritt schon mal ein guter Anfang. Bitte zerfleischt mich nun nicht, ich weiß es gibt weitere und evtl. bessere Lösungen. Es gibt jedoch schon genug Flamewars darüber im Internet.
Als weitere Lektüre empfehle ich euch diese Seite.
