RETOS C++

[Stakewinner00]

¡Buenas!

¿A que te refieres con un crackeador de MD5? ¿A redibir como argumento un hash y generar una cadena que de el mismo hash?

si

EI: juntando mensajes.

Ok, pero yo gano puntos o no? Se me ha adelantado por segundos

Aqui esta en C++:

Código (cpp) [Seleccionar] Expandir

#include <fstream>

int main()
{
char vars[6];
vars[5]='\n';
ofstream diccionario.open("diccionario", ios::out);
for(vars[0]='a'; vars[0]<'z'; vars[0]++)
{
  for(vars[1]='a'; vars[1]<'z'; vars[1]++)
  {
    for(vars[2]='a'; vars[2]<'z'; vars[2]++)
     {
       for(vars[3]='a';vars[3]<'z'; vars[3]++)
        {

         for(vars[4]='a';vars[4]<'z'; vars[4]++)
          {diccionario.write(vars, 6);}
        }
     }
  }
}
diccionario.close();
return 0;
}

el a echo el 4 tambien

ahora lo k podeis hacer es competir para que vuestro porgrama sea más rapido  por ejemplo haciendo k el script en vez de imprimir por pantalla lo guarde en un fichero y el que lo haga más rapido gana 10 puntos +

EI: juntando mensajes.

0xdani

a.cpp: In function `int main()':
a.cpp:7: parse error before `.'

[0xDani]

0xdani

a.cpp: In function `int main()':
a.cpp:7: parse error before `.'

Código (cpp) [Seleccionar] Expandir

#include <fstream>

using namespace std;

int main()
{
char vars[6];
vars[5]='\n';
ofstream diccionario;
diccionario.open("diccionario", ios::out);
for(vars[0]='a'; vars[0]<'z'; vars[0]++)
{
  for(vars[1]='a'; vars[1]<'z'; vars[1]++)
  {
    for(vars[2]='a'; vars[2]<'z'; vars[2]++)
     {
       for(vars[3]='a';vars[3]<'z'; vars[3]++)
        {

         for(vars[4]='a';vars[4]<'z'; vars[4]++)
          {diccionario.write(vars, 6);}
        }
     }
  }
}
diccionario.close();
return 0;
}


EI: juntando mensajes.

Alguien puede probar esto? No se si las librerias crypt.h y unistd.h funcionan en windows, pero para compilar: gcc md5.c -o md5 -lcrypt.

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <crypt.h>

int main(int argc, char* argv[])
{
    const char salt[] = "$1$........";
    char *buf, pass[30];
    FILE* file = fopen(argv[1], "r");
    printf("Escribe el hash: ");
    fgets(pass, 30, stdin);
    while(!feof(file))
    {
     fgets(buf, 30, file);
     buf = crypt(buf, salt);
     if(!strcmp(pass, buf)) break;
    }
    printf("Password: %s", buf);
    fclose(file);
    getchar();
    return 0;
}

Le tienes que pasar un diccionario como argumento, y escribir el hash.

Saludos.

[Stakewinner00]

no tnego el crypt.h por lo que no compila despues lo busco

el que haga el script de generar el diccionario mas rapido gana 10p

[do-while]

8.

El crackeador de MD5. Compilado utilizando g++ funciona (probad con cadenas cortas y con minusculas). Supongo que podria fallar con otros compiladores o versiones de g++ distintas de la que tengo, a fin de cuentas no deja de ser un popurri de unos cuantos codigos que tenia hechos anteriormente. Mi version de g++ considera unsigned long de 32 bits y unsigned long long de 64. Tampoco se si funcionara en todos los casos, lo que si puedo asegurar es que con cadenas cortas y de minusculas funciona...

Código (cpp) [Seleccionar] Expandir


/*
* Linea de comandos:
*      nombreprograma hash
* Salida: Cadena cuyo hash MD5 es el que se ha recibido
*
*
* Dada una cadena MD5 devuelve una cadena de digitos hexadecimales de 32 bytes
*
*
* Considerando como conjunto de salida las cadenas de digitos hexadecimales de 32 bytes,
* MD5 sera por lo tanto suprayectiva y tendra que existir al menos una cadena de 32 bytes
* hexadecimales cuya imagen sea el valor que recibimos como parametro.
*
*/

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <iostream>

using namespace std;

#ifndef ULL_MAX
    #define ULL_MAX 0xFFFFFFFFFFFFFFFFULL
#endif
/*
*
* Calcula el MD5 del input y devuelve una cadena dinamica que lo contiene.
*
*/

char* md5(char *input, unsigned long  long len);

/* Ajusta la cadena a una longitud multiplo de 512 - 64 bits y añade la longitud en 64 bits */
unsigned long long md5_ajustar_datos(char **datos, unsigned long  long len);

unsigned long md5_extraer_submensaje(char *m , unsigned long sub , unsigned long bloque);

unsigned long md5FF(unsigned long *a,unsigned long b,unsigned long c,unsigned long d,unsigned long m,unsigned long s,unsigned long t);
unsigned long md5GG(unsigned long *a,unsigned long b,unsigned long c,unsigned long d,unsigned long m,unsigned long s,unsigned long t);
unsigned long md5HH(unsigned long *a,unsigned long b,unsigned long c,unsigned long d,unsigned long m,unsigned long s,unsigned long t);
unsigned long md5II(unsigned long *a,unsigned long b,unsigned long c,unsigned long d,unsigned long m,unsigned long s,unsigned long t);

#define MD5_LONGITUD 32

#define md5_extraer_submensaje(m , sub , bloque) (((unsigned long*)(m))[(bloque) * 16 + (sub)])

#define md5F(X,Y,Z)(((X) & (Y)) | ((~(X)) & (Z)))
#define md5G(X,Y,Z)(((X) & (Z)) | ((Y) & (~(Z))))
#define md5H(X,Y,Z)((X) ^ (Y) ^ (Z))
#define md5I(X,Y,Z)((Y) ^ ((X) | (~(Z))))

char* md5(char *input, unsigned long long len)
{
    unsigned long reg[4], aux_reg[4], bloque = 0, i, j;
    unsigned long long longitud;
    char *aux;

    if(!(aux = (char*) malloc(len * sizeof(char))))
        return NULL;

    memmove(aux , input , len * sizeof(char));

    if(!(longitud = md5_ajustar_datos(&aux , len)))
    {
        free(aux);
        return NULL;
    }

    reg[0] = 0x67452301UL;
    reg[1] = 0xEFCDAB89UL;
    reg[2] = 0x98BADCFEUL;
    reg[3] = 0x10325476UL;

    /* mientras haya bloques de 64 bytes (512 bits) */
    while(longitud)
    {
        for(i = 0 ; i < 4 ; i++)
            aux_reg[i] = reg[i];

        md5FF( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,0,bloque) ,7LU ,3614090360LU);
        md5FF( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,1,bloque) ,12LU ,3905402710LU);
        md5FF( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,2,bloque) ,17LU ,606105819LU);
        md5FF( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,3,bloque) ,22LU ,3250441966LU);
        md5FF( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,4,bloque) ,7LU ,4118548399LU);
        md5FF( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,5,bloque) ,12LU ,1200080426LU);
        md5FF( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,6,bloque) ,17LU ,2821735955LU);
        md5FF( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,7,bloque) ,22LU ,4249261313LU);
        md5FF( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,8,bloque) ,7LU ,1770035416LU);
        md5FF( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,9,bloque) ,12LU ,2336552879LU);
        md5FF( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,10,bloque) ,17LU ,4294925233LU);
        md5FF( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,11,bloque) ,22LU ,2304563134LU);
        md5FF( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,12,bloque) ,7LU ,1804603682LU);
        md5FF( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,13,bloque) ,12LU ,4254626195LU);
        md5FF( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,14,bloque) ,17LU ,2792965006LU);
        md5FF( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,15,bloque) ,22LU ,1236535329LU);

        md5GG( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,1,bloque) ,5LU ,4129170786LU);
        md5GG( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,6,bloque) ,9LU ,3225465664LU);
        md5GG( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,11,bloque) ,14LU ,643717713LU);
        md5GG( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,0,bloque) ,20LU ,3921069994LU);
        md5GG( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,5,bloque) ,5LU ,3593408605LU);
        md5GG( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,10,bloque) ,9LU ,38016083LU);
        md5GG( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,15,bloque) ,14LU ,3634488961LU);
        md5GG( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,4,bloque) ,20LU ,3889429448LU);
        md5GG( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,9,bloque) ,5LU ,568446438LU);
        md5GG( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,14,bloque) ,9LU ,3275163606LU);
        md5GG( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,3,bloque) ,14LU ,4107603335LU);
        md5GG( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,8,bloque) ,20LU ,1163531501LU);
        md5GG( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,13,bloque) ,5LU ,2850285829LU);
        md5GG( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,2,bloque) ,9LU ,4243563512LU);
        md5GG( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,7,bloque) ,14LU ,1735328473LU);
        md5GG( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,12,bloque) ,20LU ,2368359562LU);

        md5HH( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,5,bloque) ,4LU ,4294588738LU);
        md5HH( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,8,bloque) ,11LU ,2272392833LU);
        md5HH( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,11,bloque) ,16LU ,1839030562LU);
        md5HH( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,14,bloque) ,23LU ,4259657740LU);
        md5HH( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,1,bloque) ,4LU ,2763975236LU);
        md5HH( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,4,bloque) ,11LU ,1272893353LU);
        md5HH( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,7,bloque) ,16LU ,4139469664LU);
        md5HH( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,10,bloque) ,23LU ,3200236656LU);
        md5HH( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,13,bloque) ,4LU ,681279174LU);
        md5HH( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,0,bloque) ,11LU ,3936430074LU);
        md5HH( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,3,bloque) ,16LU ,3572445317LU);
        md5HH( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,6,bloque) ,23LU ,76029189LU);
        md5HH( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,9,bloque) ,4LU ,3654602809LU);
        md5HH( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,12,bloque) ,11LU ,3873151461LU);
        md5HH( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,15,bloque) ,16LU ,530742520LU);
        md5HH( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,2,bloque) ,23LU ,3299628645LU);

        md5II( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,0,bloque) ,6LU ,4096336452LU);
        md5II( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,7,bloque) ,10LU ,1126891415LU);
        md5II( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,14,bloque) ,15LU ,2878612391LU);
        md5II( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,5,bloque) ,21LU ,4237533241LU);
        md5II( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,12,bloque) ,6LU ,1700485571LU);
        md5II( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,3,bloque) ,10LU ,2399980690LU);
        md5II( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,10,bloque) ,15LU ,4293915773LU);
        md5II( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,1,bloque) ,21LU ,2240044497LU);
        md5II( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,8,bloque) ,6LU ,1873313359LU);
        md5II( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,15,bloque) ,10LU ,4264355552LU);
        md5II( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,6,bloque) ,15LU ,2734768916LU);
        md5II( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,13,bloque) ,21LU ,1309151649LU);
        md5II( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,4,bloque) ,6LU ,4149444226LU);
        md5II( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,11,bloque) ,10LU ,3174756917LU);
        md5II( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,2,bloque) ,15LU ,718787259LU);
        md5II( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,9,bloque) ,21LU ,3951481745LU);


        for(i = 0 ; i < 4 ; i++)
            reg[i] += aux_reg[i];

        bloque++;
        longitud -= 64; /* descontamos un bloque de 64 bytes, 512 bits */
    }

    free(aux);

    if(!(aux = (char*) malloc(33 * sizeof(char))))
        return NULL;

    aux[0] = '\0';

    for(i = 0 ; i < 4 ; i++)
        for(j = 0 ; j < 4 ; j++)
            sprintf(aux,"%s%02X",aux,(unsigned char)((char*)&(reg[i]))[j]);

    return aux;
}

unsigned long long md5_ajustar_datos(char **datos, unsigned long long len)
{
    unsigned long long new_len;
    char *aux;
    int c = 0;

    /* si longitud en bits es mayor que ULL_MAX */
    if(len > ULL_MAX / 8)
        return 0; /* devolvemos falso */

    if(64 - (len % 64) > 8)
    {
        if(ULL_MAX - (64 - (len % 64)) >= len)
            new_len = len + (64 - (len % 64));
        else
            return 0;
    }
    else
    {
        if(ULL_MAX - 64 - (64 - (len % 64)) >= len)
            new_len = len + 64 + (64 - (len % 64));
        else
            return 0;
    }

    if(!(aux = (char*) realloc(*datos , new_len * sizeof(char))))
        return 0;

    (*datos) = aux;

    c = 1 << 7;

    memset((*datos) + len , c , sizeof(char));
    memset((*datos) + len + 1 , 0 , (new_len - len - 1) * sizeof(char));

    /* pasamos la longitud de bytes a bits */
    len *= 8;

    memcpy((*datos) + new_len - 8 , &len , 8 * sizeof(char));

    return new_len;
}

unsigned long md5FF(unsigned long *a,unsigned long b,unsigned long c,unsigned long d,unsigned long m,unsigned long s,unsigned long t)
{
    unsigned long aux;

    aux = (*a + md5F(b, c, d) + m + t);

    *a = b + ((aux << s) | (aux >> (32 - s)));

    return *a;
}

unsigned long md5GG(unsigned long *a,unsigned long b,unsigned long c,unsigned long d,unsigned long m,unsigned long s,unsigned long t)
{
    unsigned long aux;

    aux = (*a + md5G(b, c, d) + m + t);

    *a = b + ((aux << s) | (aux >> (32 - s)));

    return *a;
}

unsigned long md5HH(unsigned long *a,unsigned long b,unsigned long c,unsigned long d,unsigned long m,unsigned long s,unsigned long t)
{
    unsigned long aux;

    aux = (*a + md5H(b, c, d) + m + t);

    *a = b + ((aux << s) | (aux >> (32 - s)));

    return *a;
}

unsigned long md5II(unsigned long *a,unsigned long b,unsigned long c,unsigned long d,unsigned long m,unsigned long s,unsigned long t)
{
    unsigned long aux;

    aux = (*a + md5I(b, c, d) + m + t);

    *a = b + ((aux << s) | (aux >> (32 - s)));

    return *a;
}


int MD5_bruteforce(string MD5,unsigned long longitud)
{
    static string cadena;
    static unsigned long posicion = 0;
    static char* alfabeto = "abcdefghijklmnopqrstuvwxyz"; //con este alfabeto abarcamos el espacio imagen en menos iteraciones

    if(posicion == longitud)
    {
        //si hemos llegado a la ultima posicion almacenamos la variacion
        if(string(md5((char*)cadena.c_str(), cadena.length())) == MD5)
        {
            cout << cadena;
            return 1;
        }

        return 0;
    }

    //si es la primera llamada damos la longitud deseada a la cadena
    if(posicion == 0)
        cadena.resize(longitud);

    //para cada uno de los caracteres del alfabeto
    for(int i = 0 ; alfabeto[i] ; i++)
    {
        cadena[posicion] = alfabeto[i]; //asignamos a la posicion correspondiente el caracter del alfabeto.

        //avanzamos una posicion
        posicion++;

        //y calculamos el siguiente caracter
        if(MD5_bruteforce(MD5,longitud))
        {
            posicion = 0;
            cadena.resize(0);
            return 1;
        }

        //volvemos a la posicion original
        posicion--;
    }

    //posicion termina a cero para la siguiente llamada
    if(!posicion)
        cadena.resize(0);

    return 0;
}

int main(int argc, char *argv[])
{
    string MD5;

    if(argc != 2)
    {
        cout << argv[0] << " MD5_hash" << endl;
        return -1;
    }

    if(strlen(argv[1]) != 32)
    {
        cout << argv[0] << " MD5_hash" << endl;
        return -1;
    }

    for(int i = 0 ; i < 32 ; i++)
    {
        argv[1][i] = toupper(argv[1][i]);

        if(!((argv[1][i] >= '0' && argv[1][i] <= '9') || (argv[1][i]>= 'A' && argv[1][i]<='Z')))
        {
            cout << argv[0] << " MD5_hash" << endl;
            return -1;
        }
    }

    MD5 = argv[1];


    if(string(md5("",0)) != MD5)
    {
        for(int i = 1 ; i < 32 ; i++)
            if(MD5_bruteforce(MD5,i))
                break;
    }
    else
        cout <<"Cadena vacia" << endl;

    return 0;
}


[Stakewinner00]

8.

El crackeador de MD5. Compilado utilizando g++ funciona (probad con cadenas cortas y con minusculas). Supongo que podria fallar con otros compiladores o versiones de g++ distintas de la que tengo, a fin de cuentas no deja de ser un popurri de unos cuantos codigos que tenia hechos anteriormente. Mi version de g++ considera unsigned long de 32 bits y unsigned long long de 64. Tampoco se si funcionara en todos los casos, lo que si puedo asegurar es que con cadenas cortas y de minusculas funciona...

ya te sume los puntos ya veo que tendre que poner retos mas dificles de momento intenta completar los que quedan que ya requieren mas tiempo

[ecfisa]

Hola Stakewinner00.

ecfisa, en tu codigo falta un include despues lo añado

Los tres códigos que publiqué están probados y funcionan, lo que sí noto que faltan son los 41 puntos...

Saludos.

[Stakewinner00]

Hola Stakewinner00.

Los tres códigos que publiqué están probados y funcionan, lo que sí noto que faltan son los 41 puntos...

Saludos.

mira un ejemplo

Código (cpp) [Seleccionar] Expandir

#include<iostream>

using namespace std;

int main() {
 string texto;

 cout << "Texto: ";
 getline(cin, texto);
 cout << "El texto tiene " << texto.length() << " caracteres.";
 cin.get();
 return 0;
}

no entiendo como declaras un string si no lo has incluido, en los otros pasan cossas similares

[0xDani]

Ya he conseguido que funcione el crackeador:

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <crypt.h>

int main(int argc, char* argv[])
{
    const char salt[] = "$1$.........";
    char *buf, pass[30], *hash;
    hash = (char*) malloc(30);
    buf = (char*) malloc(30);
    FILE* file = fopen(argv[1], "r");
    printf("Escribe el hash: ");
    fgets(pass, 30, stdin);
    while(!feof(file))
    {
     fgets(buf, 30, file);
     hash = crypt(buf, salt);
     if(!strcmp(pass, hash)) break;
    }
    printf("Password: %s", buf);
    fclose(file);
    getchar();
    return 0;
}

[ecfisa]

no entiendo como declaras un string si no lo has incluido, en los otros pasan cossas similares

Hola Stakewinner00.

En Builder C++ 6 funciona perfectamente tál y como lo he publicado, por otro lado las inclusiones de librerías no hacen a la esencia del algorítmo.

Tampoco tomes en serio el comentario que hice sobre los puntos, entendí los desafios como una diversion y bajo ningún motivo esperaba recompensa alguna.

Saludos.

EI: juntando mensajes.

Hola Stakewinner00.

Me quedé con la duda de que fuera una característica del compilador de Borland y tuviera incompatibilidad con otros, por lo que descargué Code::Blocks (GNU GCC Compiler) y probé los códigos que mencionas:
1)

Código (cpp) [Seleccionar] Expandir


#include <iostream>

using namespace std;

int main(int argc, char* argv[]) {
  char frase[100];
  int i=0;
  const char *num[10] = {"cero","uno","dos","tres","cuatro","cinco",
                         "seis","siete","ocho","nueve" };
  cout << "Frase: ";
  cin >> frase;

  while (frase[i]) {
    if (isdigit(frase[i]))
      cout << num[frase[i]-48] << " ";
    i++;
  }

  while(cin.get()!='\n');
  cin.get();
  return 0;
}


2)

Código (cpp) [Seleccionar] Expandir


#include<iostream>

using namespace std;

int main() {
  string texto;

  cout << "Texto: ";
  getline(cin, texto);
  cout << "El texto tiene " << texto.length() << " caracteres.";
  cin.get();
  return 0;
}


3)

Código (cpp) [Seleccionar] Expandir


#include <iostream>
#define MAX_PALABRAS 4

using namespace std;
int main() {
  string vec[MAX_PALABRAS], min;

  cout << "Ingrese " << MAX_PALABRAS << " palabras" << endl;
  cout << "-----------------" << endl;

  min.assign(255,255);
  for(int i = 0; i < MAX_PALABRAS; i++) {
    cout << "Palabra " << i+1 << " :";
    cin >> vec[i];
    if (vec[i] < min)
      min = vec[i];
  }
  cout << endl << "Primer palabra por orden alfabetico: " << min;

  while(cin.get()!='\n');
  cin.get();
  return 0;
}


Los tres se compilan y ejecuntan sin problemas...

¿ Con que compilador tuviste problemas ?

Saludos.

[Stakewinner00]

g++ desde cmd pero da igual igualmente te sumo los puntos pero para codigos posteriores es mejor que el código sea compatible con todos los compiladores.

En el reto 2 le faltaba el #include <string> y estaba esperando que lo pusieras tu pero da igual y en el 3 lo mismo pero aparte me sale estoo

Código [Seleccionar] Expandir

C:/mingw/bin/../lib/gcc-lib/mingw32/2.95.3-6/../../../../include/g++-3/std/bastr
ing.h: In method `class basic_string<char,string_char_traits<char>,__default_all
oc_template<false,0> > & basic_string<char,string_char_traits<char>,__default_al
loc_template<false,0> >::replace<int>(char *, char *, int, int)':
C:/mingw/bin/../lib/gcc-lib/mingw32/2.95.3-6/../../../../include/g++-3/std/bastr
ing.h:229:   instantiated from here
C:/mingw/bin/../lib/gcc-lib/mingw32/2.95.3-6/../../../../include/g++-3/std/bastr
ing.h:453: invalid type argument of `unary *'
C:/mingw/bin/../lib/gcc-lib/mingw32/2.95.3-6/../../../../include/g++-3/std/bastr
ing.h:229:   instantiated from here
C:/mingw/bin/../lib/gcc-lib/mingw32/2.95.3-6/../../../../include/g++-3/std/bastr
ing.h:460: invalid type argument of `unary *'