Librería de Snippets en C/C++

[X3R4CK3R]

    system ("title Longitud De Un Texto");
    system ("color 0f");

Un consejo: deberías acostumbrarte a prescindir de system si vas a programar en C++, para cambiar el title de la cmd tienes la función SetConsoleTitle , y para cambiar el color está SetConsoleTextAttribute, ambos pertenecen a la API de windows:

Código (cpp) [Seleccionar] Expandir

SetConsoleTitle("Longitud De Un Texto");
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_GREEN | BACKGROUND_RED); //Texto en verde, fondo en rojo


Saludos

[Stakewinner00]

Otro snippet de cripto clásica este de el algoritmo Playfair. El código solo soporta mayúsculas pero ya iré editando con las mejoras que le ponga.

Código (cpp) [Seleccionar] Expandir

/*
EXAMPLE

string a;
cin >> a;
string b;
b= playfair_encrypt(a,"CRIPTOPUNK");
cout << b << endl; //playfair_encrypt(mensaje,clave)
cout << playfair_decrypt(b,"CRIPTOPUNK");
*/

#include <string>

using std::string;

inline void generar_matriz(string);
string playfair_encrypt(string, string);
string playfair_decrypt(string, string);

char matriz[5][5];
void generar_matriz(string clave_inprocessada)
{
char ABC[25]={'A','B','C','D','E','F','G','H','I','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
string clave;
bool exist;
for(int i=0;i<clave_inprocessada.size();i++)
{
for(int p=0;p<clave.size();p++)
{
if(clave_inprocessada[i] == clave[p])
exist = true;
}
if(exist==false)
{
clave += clave_inprocessada[i];
} else {
exist = false;
}
}

short temp=0;
bool cual=false;
for(short j=0;j<5;j++)
{
for(short i=0;i<5;i++)
{
for(int p=0;p<25;p++)
{
if(ABC[p] == clave[temp])
ABC[p]='J';
}
if(temp==clave.size() && cual==false)
{
cual = true;
temp=0;
}
if(cual==false)
{
matriz[j][i] = clave[temp];
} else {
while(ABC[temp]=='J')
{
temp++;
}
matriz[j][i] = ABC[temp];
}
temp++;
}
}
/*for(short j=0;j<5;j++)
{
for(short p=0;p<5;p++)
{
std::cout << matriz[j][p];
}
std::cout << std::endl;
}*/
}

string playfair_encrypt(string s, string clave)
{
generar_matriz(clave);
string ct;
short p1;
short p2;
short e1;
short e2;
for(int i=0;i<s.size();i += 2)
{
if(s[i]==s[i+1])
{
ct += s[i];
ct += 'X' + s[i+1];
} else {
ct += s[i];
ct += s[i+1];
}
}
s = ct;
ct="";
for(int i=0;i<s.size();i++)
{
if(s[i]=='J')
s[i]='I';
for(int p=0;p<5;p++)
{
for(int j=0;j<5;j++)
{
if(s[i]==matriz[p][j])
{
p1=p;
p2=j;
}
}
}
i++;
if(i>clave.size())
clave += 'X';
for(int p=0;p<5;p++)
{
for(int j=0;j<5;j++)
{
if(s[i]==matriz[p][j])
{
e1=p;
e2=j;
}
}
}
if(e1!=p1 && e2!=p2)
{
ct += matriz[p1][e2];
ct += matriz[e1][p2];
} else if(e1!=p1 && e2==p2) {
if(p1==4)
{
p1 = -1;
} else if(e1==4) {
e1=-1;
}
ct += matriz[p1+1][p2];
ct += matriz[e1+1][e2];
} else if(e1==p1 && e2!=p2) {
if(p2==4)
{
p2 = -1;
} else if(e2==4) {
e2=-1;
}
ct += matriz[p1][p2+1];
ct += matriz[e1][e2+1];
}
}
return ct;
}

string playfair_decrypt(string s, string clave)
{
generar_matriz(clave);
string ct;
short p1;
short p2;
short e1;
short e2;
for(int i=0;i<s.size();i++)
{
for(int p=0;p<5;p++)
{
for(int j=0;j<5;j++)
{
if(s[i]==matriz[p][j])
{
p1=p;
p2=j;
}
}
}
i++;
if(i>clave.size())
clave += 'X';
for(int p=0;p<5;p++)
{
for(int j=0;j<5;j++)
{
if(s[i]==matriz[p][j])
{
e1=p;
e2=j;
}
}
}
if(e1!=p1 && e2!=p2)
{
ct += matriz[p1][e2];
ct += matriz[e1][p2];
} else if(e1!=p1 && e2==p2) {
if(p1==0)
{
p1 = 1;
} else if(e1==0) {
e1=1;
}
ct += matriz[p1-1][p2];
ct += matriz[e1-1][e2];
} else if(e1==p1 && e2!=p2) {
if(p2==0)
{
p2 = 5;
} else if(e2==0) {
e2= 5;
}
ct += matriz[p1][p2-1];
ct += matriz[e1][e2-1];
}
}
return ct;
}

[do-while]

¡Buenas!

Aquí os dejo unos códigos que acabo de hacer. Han salido a raíz de una pregunta posteada y por fin me he decidido ha hacerlos.

Son funciones para el manejo de la combinatoria (combinaciones, variaciones y permutaciones, tanto con repeticiones como sin repeticiones).

Trabajan con indices de enteros, así que los resultados de las funciones son aplicables a cualquier vector o contenedor lineal al que se pueda acceder por subindices.

Primero os dejo tanto combinatoria.h como combinatoria.c y al final un codigo de ejemplo.

¡Saludos!

Si os resulta mas cómodo aquí os dejo un enlace de descarga.

combinatoria.h

Código (c) [Seleccionar] Expandir


#ifndef COMBINATORIA_H
#define COMBINATORIA_H

/*
* La esctructura t_combinatoria guarda una lista con todos los elementos
* que genera un tipo combinatorio... (lio)
*
* Por ejemplo. Si caltulamos las permutaciones de un conjunto, cada elemento
* de lista sera una de las permutaciones. (mas claro)
*
* n_elementos es el numero de listas. Si hemos calculado permutaciones de n
* elementos n_elementos sera n!...
*
* longitud_elemento es la longitud de cada elemento generado:
* en variaciones de n elementos tomados de k en k, longitud_elemento = k.
*
*/

struct t_combinatoria
{
    unsigned char **lista;
    unsigned long n_elementos;
    unsigned char longitud_elemento;
};
typedef struct t_combinatoria t_combinatoria;

/*
* IMPORTATISIMO UTILIZAR LA FUNCION PARA INICIALIZAR ANTES DE CUALQUIER
* LLAMADA A ALGUNA DE LAS SIGUIENTES FUNCIONES, Y FINALIZAR LOS DATOS
* DESPUES DE TERMINAR DE UTILIZARLOS
*
*/
void inicializar_combinatoria(t_combinatoria *comb);
void finalizar_combinatoria(t_combinatoria *comb);

/* CUALLQUIERA DE LAS SIGUIENTE FUNCIONES DEVUELVE 0 SI HAY ALGUN ERROR Y 1 SI TODO VA BIEN */

/* Combinaciones sin repeticion de n (elementos_conjunto) tomados de k (elementos_combinacion) en k (k <= n)*/
int combinaciones(t_combinatoria *datos, unsigned char elementos_conjunto, unsigned char elementos_combinacion);

/* Combinaciones con repeticion de n (elementos_conjunto) tomados de k (elementos_combinacion) en k (k cualquiera)*/
int combinaciones_repeticion(t_combinatoria *datos, unsigned char elementos_conjutnto, unsigned char elementos_combinacion);

/* variaciones sin repeticion de n (elementos_conjunto) tomados de k (elementos_combinacion) en k (k <= n) */
int variaciones(t_combinatoria *datos, unsigned char elementos_conjunto, unsigned char elementos_variacion);

/* variaciones con repeticion de n (elementos_conjunto) tomados de k (elementos_combinacion) en k (k cualquiera) */
int variaciones_repeticion(t_combinatoria *datos, unsigned char elementos_conjunto, unsigned char elementos_variacion);

/* permutaciones sin repeticion de n (elementos_conjunto) elementos */
int permutaciones(t_combinatoria *datos, unsigned char elementos_conjunto);

/*permutaciones con repeticion de un conjunto de elementos_conjunto elementos, y repeticiones es un vector
* en el que se nos indica cuantas veces se repite el elemento i de la lista
*/
int permutaciones_repeticion(t_combinatoria *datos, unsigned char elementos_conjunto, unsigned char *repeticiones);

#endif // COMBINATORIA_H


combinatoria.c

Código (c) [Seleccionar] Expandir


#include "combinatoria.h"

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

void inicializar_combinatoria(t_combinatoria *c)
{
    c->lista = NULL;
    c->n_elementos = 0;
    c->longitud_elemento = 0;
}

void finalizar_combinatoria(t_combinatoria *c)
{
    unsigned long i;

    for(i = 0 ; i < c->n_elementos ; i++)
        free(c->lista[i]);

    free(c->lista);

    c->lista = NULL;
    c->n_elementos = 0;
    c->longitud_elemento = 0;
}

unsigned long factorial(unsigned long n)
{
    unsigned long ret = 1;

    while(n)
        ret *= (n--);

    return ret;
}

unsigned long variaciones_n_k(unsigned long n, unsigned long k)
{
    unsigned long copia_n = n, ret = 1;

    while(n - (copia_n - k))
        ret *= (n--);

    return ret;
}

unsigned long exponencial(unsigned long base, unsigned long exponente)
{
    unsigned long ret = 1;

    if(exponente)
        while(exponente--)
            ret *= base;

    return ret;
}

unsigned long binomial(unsigned long n, unsigned long k)
{
    return variaciones_n_k(n,k) / factorial(k);
}

unsigned long binomial_generalizado(unsigned char *repeticiones, unsigned long dim)
{
    unsigned long ret = 0,i;

    for(i = 0 ; i < dim ; i++)
        ret += repeticiones[i];

    ret = factorial(ret);

    for(i = 0 ; i < dim ; i++)
        ret /= factorial(repeticiones[i]);

    return ret;
}

int combinaciones(t_combinatoria *datos,unsigned char elementos_conjunto, unsigned char elementos_combinacion)
{
    static unsigned char indice = 0;
    static unsigned long elementos_fijados = 0;
    static unsigned char *aux = NULL;
    unsigned long i;

    if(!elementos_combinacion || !elementos_conjunto)
        return 0;

    if(indice == elementos_combinacion)
    {
        memcpy(*(datos->lista + elementos_fijados), aux, elementos_combinacion * sizeof(unsigned char));

        elementos_fijados++;

        return 1;
    }

    /* si es la primera vez que llamamos a la funcion, reservamos memoria para la tabla de combinaciones */
    if(!indice)
    {
        if(!(aux = (unsigned char *) malloc(elementos_combinacion * sizeof(unsigned char))))
            return 0;

        datos->n_elementos = binomial(elementos_conjunto,elementos_combinacion);
        datos->longitud_elemento = elementos_combinacion;

        if(!(datos->lista = (unsigned char **) malloc(datos->n_elementos * sizeof(unsigned char *))))
        {
            datos->n_elementos = 0;
            datos->longitud_elemento = 0;

            return 0;
        }

        for(i = 0 ; i < datos->n_elementos ; i++)
        {
            if(!(datos->lista[i] = (unsigned char *) malloc(datos->longitud_elemento * sizeof(unsigned char))))
            {
                unsigned long j;

                for(j = 0 ; j < i ; j++)
                    free(datos->lista[i]);

                free(datos->lista);
                datos->lista = NULL;

                datos->n_elementos = 0;
                datos->longitud_elemento = 0;

                return 0;
            }
        }

        for(i = 0 ; i < elementos_conjunto - elementos_combinacion + indice + 1; i++)
        {
            aux[indice] = i;

            indice++;

            combinaciones(datos, elementos_conjunto, elementos_combinacion);

            indice--;
        }

        free(aux);
        aux = NULL;
        elementos_fijados = 0;
        indice = 0;
    }
    else
    {
        for(i = aux[indice - 1] + 1 ; i < elementos_conjunto - elementos_combinacion + indice + 1; i++)
        {
            aux[indice] = i;

            indice++;

            combinaciones(datos, elementos_conjunto, elementos_combinacion);

            indice--;
        }
    }

    return 1;
}

int combinaciones_repeticion(t_combinatoria *datos, unsigned char elementos_conjunto, unsigned char elementos_combinacion)
{
    static unsigned char indice = 0;
    static unsigned long elementos_fijados = 0;
    static unsigned char *aux = NULL;
    unsigned long i;

    if(!elementos_combinacion || !elementos_conjunto)
        return 0;

    if(indice == elementos_combinacion)
    {
        memcpy(*(datos->lista + elementos_fijados), aux, elementos_combinacion * sizeof(unsigned char));

        elementos_fijados++;

        return 1;
    }

    /* si es la primera vez que llamamos a la funcion, reservamos memoria para la tabla de combinaciones */
    if(!indice)
    {
        if(!(aux = (unsigned char *) malloc(elementos_combinacion * sizeof(unsigned char))))
            return 0;

        datos->n_elementos = binomial(elementos_conjunto + elementos_combinacion - 1,elementos_combinacion);
        datos->longitud_elemento = elementos_combinacion;

        if(!(datos->lista = (unsigned char **) malloc(datos->n_elementos * sizeof(unsigned char *))))
        {
            datos->n_elementos = 0;
            datos->longitud_elemento = 0;

            return 0;
        }

        for(i = 0 ; i < datos->n_elementos ; i++)
        {
            if(!(datos->lista[i] = (unsigned char *) malloc(datos->longitud_elemento * sizeof(unsigned char))))
            {
                unsigned long j;

                for(j = 0 ; j < i ; j++)
                    free(datos->lista[i]);

                free(datos->lista);
                datos->lista = NULL;

                datos->n_elementos = 0;
                datos->longitud_elemento = 0;

                return 0;
            }
        }

        for(i = 0 ; i < elementos_conjunto; i++)
        {
            aux[indice] = i;

            indice++;

            combinaciones_repeticion(datos, elementos_conjunto, elementos_combinacion);

            indice--;
        }

        free(aux);
        aux = NULL;
        elementos_fijados = 0;
        indice = 0;
    }
    else
    {
        for(i = aux[indice - 1] ; i < elementos_conjunto ; i++)
        {
            aux[indice] = i;

            indice++;

            combinaciones_repeticion(datos, elementos_conjunto, elementos_combinacion);

            indice--;
        }
    }

    return 1;
}

int variaciones(t_combinatoria *datos, unsigned char elementos_conjunto, unsigned char elementos_variacion)
{
    static unsigned char indice = 0;
    static unsigned long elementos_fijados = 0;
    static unsigned char *aux = NULL;
    static unsigned char *lista_indices = NULL;
    unsigned long i;

    if(!elementos_variacion || !elementos_conjunto)
        return 0;

    if(indice == elementos_variacion)
    {
        memcpy(*(datos->lista + elementos_fijados), aux, elementos_variacion * sizeof(unsigned char));

        elementos_fijados++;

        return 1;
    }

    if(!indice)
    {
        if(!(aux = (unsigned char *) malloc(elementos_variacion * sizeof(unsigned char))))
            return 0;

        if(!(lista_indices = (unsigned char *) malloc(elementos_conjunto * sizeof(unsigned char))))
        {
            free(aux);
            aux = NULL;

            return 0;
        }

        for(i = 0 ; i < elementos_conjunto ; i++)
            lista_indices[i] = i;

        datos->n_elementos = variaciones_n_k(elementos_conjunto , elementos_variacion);
        datos->longitud_elemento = elementos_variacion;

        if(!(datos->lista = (unsigned char **) malloc(datos->n_elementos * sizeof(unsigned char *))))
        {
            free(aux);
            aux = NULL;

            free(lista_indices);
            lista_indices = NULL;

            datos->n_elementos = 0;
            datos->longitud_elemento = 0;

            return 0;
        }

        for(i = 0 ; i < datos->n_elementos ; i++)
        {
            if(!(datos->lista[i] = (unsigned char *) malloc(elementos_variacion * sizeof(unsigned char))))
            {
                unsigned long j;

                for(j = 0 ; j < i ; j++)
                    free(datos->lista[j]);

                free(datos->lista);
                datos->lista = NULL;

                free(aux);
                aux = NULL;

                free(lista_indices);
                lista_indices = NULL;

                datos->n_elementos = 0;
                datos->longitud_elemento = 0;

                return 0;
            }
        }
    }

    aux[indice] = lista_indices[indice];

    indice++;
    variaciones(datos, elementos_conjunto, elementos_variacion);
    indice--;

    for(i = indice + 1; i < elementos_conjunto ; i++)
    {
        aux[indice] = lista_indices[i];

        lista_indices[indice] ^= lista_indices[i];
        lista_indices[i] ^= lista_indices[indice];
        lista_indices[indice] ^= lista_indices[i];

        indice++;

        variaciones(datos , elementos_conjunto , elementos_variacion);

        indice--;

        lista_indices[indice] ^= lista_indices[i];
        lista_indices[i] ^= lista_indices[indice];
        lista_indices[indice] ^= lista_indices[i];
    }

    if(!indice)
    {
        elementos_fijados = 0;
        indice = 0;

        free(aux);
        aux = NULL;

        free(lista_indices);
        lista_indices = NULL;
    }

    return 1;
}

int variaciones_repeticion(t_combinatoria *datos, unsigned char elementos_conjunto, unsigned char elementos_variacion)
{
    static unsigned char indice = 0;
    static unsigned long elementos_fijados = 0;
    static unsigned char *aux = NULL;
    unsigned long i;

    if(!elementos_variacion || !elementos_conjunto)
        return 0;

    if(indice == elementos_variacion)
    {
        memcpy(*(datos->lista + elementos_fijados),aux,elementos_variacion * sizeof(unsigned char));

        elementos_fijados++;

        return 1;
    }

    if(!indice)
    {
        if(!(aux = (unsigned char *) malloc(elementos_variacion * sizeof(unsigned char))))
            return 0;

        datos->n_elementos = exponencial(elementos_conjunto, elementos_variacion);
        datos->longitud_elemento = elementos_variacion;

        if(!(datos->lista = (unsigned char **) malloc(datos->n_elementos * sizeof(unsigned char *))))
        {
            datos->n_elementos = 0;
            datos->longitud_elemento = 0;

            return 0;
        }

        for(i = 0 ; i < datos->n_elementos ; i++)
        {
            if(!(datos->lista[i] = (unsigned char *) malloc(elementos_variacion * sizeof(unsigned char))))
            {
                unsigned long j;

                for(j = 0 ; j < i ; j++)
                    free(datos->lista[j]);

                free(datos->lista);
                datos->lista = NULL;

                datos->n_elementos = 0;
                datos->longitud_elemento = 0;

                return 0;
            }
        }
    }

    for(i = 0 ; i < elementos_conjunto ; i++)
    {
        aux[indice] = i;

        indice++;
        variaciones_repeticion(datos, elementos_conjunto, elementos_variacion);
        indice--;
    }

    if(!indice)
    {
        free(aux);
        aux = NULL;

        elementos_fijados = 0;
    }

    return 1;
}

int permutaciones(t_combinatoria *datos, unsigned char elementos_conjunto)
{
    return variaciones(datos , elementos_conjunto , elementos_conjunto);
}

int permutaciones_repeticion(t_combinatoria *datos, unsigned char elementos_conjunto, unsigned char *repeticiones)
{
    static unsigned char indice = 0;
    static unsigned long elementos_fijados = 0;
    static unsigned char *aux = NULL;
    unsigned long i;

    if(!elementos_conjunto)
        return 0;

    if(!indice)
    {
        for(i = 0 ; i < elementos_conjunto ; i++)
            datos->longitud_elemento += repeticiones[i];

        if(!datos->longitud_elemento)
            return 0;

        if(!(aux = (unsigned char *) malloc(datos->longitud_elemento * sizeof(unsigned char))))
        {
            datos->longitud_elemento = 0;

            return 0;
        }

        datos->n_elementos = binomial_generalizado(repeticiones, elementos_conjunto);

        if(!(datos->lista = (unsigned char **) malloc(datos->n_elementos * sizeof(unsigned char *))))
        {
            free(aux);
            aux = NULL;

            datos->n_elementos = 0;
            datos->longitud_elemento = 0;

            return 0;
        }

        for(i = 0 ; i < datos->n_elementos ; i++)
        {
            if(!(datos->lista[i] = (unsigned char *) malloc(datos->longitud_elemento * sizeof(unsigned char))))
            {
                unsigned long j;

                for(j = 0 ; j < i ; j++)
                    free(datos->lista[j]);

                free(datos->lista);
                datos->lista = NULL;

                free(aux);
                aux = NULL;

                datos->n_elementos = 0;
                datos->longitud_elemento = 0;

                return 0;
            }
        }
    }

    if(indice == datos->longitud_elemento)
    {
        memcpy(*(datos->lista + elementos_fijados), aux, datos->longitud_elemento * sizeof(unsigned char));

        elementos_fijados++;

        return 1;
    }

    for(i = 0; i < elementos_conjunto ; i++)
    {
        if(repeticiones[i])
        {
            aux[indice] = i;
            repeticiones[i]--;

            indice++;
            permutaciones_repeticion(datos,elementos_conjunto,repeticiones);
            indice--;

            repeticiones[i]++;
        }
    }

    if(!indice)
    {
        free(aux);
        aux = NULL;

        elementos_fijados = 0;
    }

    return 1;
}


ejemplo

Código (c) [Seleccionar] Expandir


#include <stdio.h>

#include "combinatoria.h"

int main()
{
   t_combinatoria comb;
   int i, j;
   unsigned long repeticiones[] = {2,1,0,0,2};
   char vector1[] = "aeiou";
   char *vector2[] = {"que","dia","mas","tonto","llevo"};

   inicializar_combinatoria(&comb);

   /* combinaciones sin repeticion de 5 elementos, tomados de 3 en 3 */
   combinaciones(&comb,5,3);

   for(i = 0 ; i < comb.n_elementos ; i++)
   {
       for(j = 0 ; j < comb.longitud_elemento ; j++)
           printf("%c",vector1[comb.lista[i][j]]);

       printf("\n");
   }

   printf("\n");

   for(i = 0 ; i < comb.n_elementos ; i++)
   {
       for(j = 0 ; j < comb.longitud_elemento ; j++)
           printf("%s ",vector2[comb.lista[i][j]]);

       printf("\n");
   }

   printf("\n");

   while(getchar() != '\n');

   finalizar_combinatoria(&comb);

   inicializar_combinatoria(&comb);

   permutaciones(&comb,3);

   for(i = 0 ; i < comb.n_elementos ; i++)
   {
       for(j = 0 ; j < comb.longitud_elemento ; j++)
           printf("%c",vector1[comb.lista[i][j]]);

       printf("\n");
   }

   printf("\n");

   for(i = 0 ; i < comb.n_elementos ; i++)
   {
       for(j = 0 ; j < comb.longitud_elemento ; j++)
           printf("%s ",vector2[comb.lista[i][j]]);

       printf("\n");
   }

   printf("\n");

   while(getchar() != '\n');

   finalizar_combinatoria(&comb);

   inicializar_combinatoria(&comb);

   /*
    * permutaciones con repeticion de 5 elementos donde
    * el prinero se repite 2 veces, el segundo 1 vez y
    * el quinto 2 veces (repeticiones = {2,1,0,0,2})
    */
   permutaciones_repeticion(&comb,5,repeticiones);

   for(i = 0 ; i < comb.n_elementos ; i++)
   {
       for(j = 0 ; j < comb.longitud_elemento ; j++)
           printf("%c",vector1[comb.lista[i][j]]);

       printf("\n");
   }

   printf("\n");

   for(i = 0 ; i < comb.n_elementos ; i++)
   {
       for(j = 0 ; j < comb.longitud_elemento ; j++)
           printf("%s ",vector2[comb.lista[i][j]]);

       printf("\n");
   }

   printf("\n");

   while(getchar() != '\n');

   finalizar_combinatoria(&comb);


   return 0;
}


¡Saludos!

[do-while]

¡Buenas!

Aun arriesgándome a un tirón de orejas por el doble post, os deho aqui el SHA1.

La última vez que me juntaron dos posts con códigos relativamente largos, se perdio parte del código por exceder el límite de caracteres del post... por favor, EI, Littlehorse, no me unáis los posts.

sha1.h

Código (c) [Seleccionar] Expandir


#ifndef SHA1_H
#define SHA1_H

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

#ifndef ULL_MAX
   #define ULL_MAX 0xFFFFFFFFFFFFFFFFULL
#endif

typedef unsigned long (*_funciones)(unsigned long, unsigned long, unsigned long);

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

unsigned long long sha1_ajustar_datos(char **datos, unsigned long  long len);

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

#endif /* SHA1_H */


sha1.c

Código (c) [Seleccionar] Expandir


#include "sha1.h"

#define sha1F(X,Y,Z) (((X) & (Y)) | ((~(X)) & (Z)))
#define sha1G(X,Y,Z) ((X) ^ (Y) ^ (Z))
#define sha1H(X,Y,Z) (((X) & (Y)) | ((X) & (Z)) | ((Y) & (Z)))

char* sha1(char *input, unsigned long long len)
{
   char *aux = NULL;
   unsigned long long longitud, i,j;
   unsigned long reg[5], aux_reg[5], K[4], bloque = 0, sub[80];
   unsigned long tmp;


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

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

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

   reg[0] = 0x67452301;
   reg[1] = 0xEFCDAB89;
   reg[2] = 0x98BADCFE;
   reg[3] = 0x10325476;
   reg[4] = 0xC3D2E1F0;

   K[0] = 0x5A827999;
   K[1] = 0x6ED9EBA1;
   K[2] = 0x8F1BBCDC;
   K[3] = 0xCA62C1D6;

   while(longitud)
   {
       memcpy(aux_reg , reg , 5 * sizeof(unsigned long));

       for(j = 0 ; j < 16 ; j++)
           for(i = 0 ; i < 4 ; i++)
               memset(((char*)&sub[j]) + i, *(aux + bloque * 64 + j * 4 + 3 - i) , sizeof(char));

       for(i = 16 ; i < 80 ; i++)
       {
           sub[i] = sub[i - 3] ^ sub[i - 8] ^ sub[i - 14] ^ sub[i - 16];
           sub[i] = sub[i] << 1 | sub[i] >> 31;
       }

       for(i = 0 ; i < 20 ; i++)
       {
           tmp =  ((aux_reg[0] << 5) | (aux_reg[0] >> 27)) + sha1F(aux_reg[1],aux_reg[2],aux_reg[3]) +
                           aux_reg[4] + sub[i] + K[0];

           aux_reg[4] = aux_reg[3];
           aux_reg[3] = aux_reg[2];
           aux_reg[2] = (aux_reg[1] << 30) | (aux_reg[1] >> 2);
           aux_reg[1] = aux_reg[0];
           aux_reg[0] = tmp;
       }

       for(i = 20 ; i < 40 ; i++)
       {
           tmp =  ((aux_reg[0] << 5) | (aux_reg[0] >> 27)) + sha1G(aux_reg[1],aux_reg[2],aux_reg[3]) +
                           aux_reg[4] + sub[i] + K[1];

           aux_reg[4] = aux_reg[3];
           aux_reg[3] = aux_reg[2];
           aux_reg[2] = (aux_reg[1] << 30) | (aux_reg[1] >> 2);
           aux_reg[1] = aux_reg[0];
           aux_reg[0] = tmp;
       }

       for(i = 40 ; i < 60 ; i++)
       {
           tmp =  ((aux_reg[0] << 5) | (aux_reg[0] >> 27)) + sha1H(aux_reg[1],aux_reg[2],aux_reg[3]) +
                           aux_reg[4] + sub[i] + K[2];

           aux_reg[4] = aux_reg[3];
           aux_reg[3] = aux_reg[2];
           aux_reg[2] = (aux_reg[1] << 30) | (aux_reg[1] >> 2);
           aux_reg[1] = aux_reg[0];
           aux_reg[0] = tmp;
       }

       for(i = 60 ; i < 80 ; i++)
       {
           tmp =  ((aux_reg[0] << 5) | (aux_reg[0] >> 27)) + sha1G(aux_reg[1],aux_reg[2],aux_reg[3]) +
                           aux_reg[4] + sub[i] + K[3];

           aux_reg[4] = aux_reg[3];
           aux_reg[3] = aux_reg[2];
           aux_reg[2] = (aux_reg[1] << 30) | (aux_reg[1] >> 2);
           aux_reg[1] = aux_reg[0];
           aux_reg[0] = tmp;
       }

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

       bloque++;
       longitud -= 64;
   }

   free(aux);

   if(!(aux = malloc(41 * sizeof(unsigned long))))
       return NULL;

   aux[0] = '\0';

   for(i = 0 ; i < 5 ; i++)
       sprintf(aux,"%s%08lX",aux,reg[i]);

   return aux;
}

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

   /* 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;

   for(i = 0 ; i < 8 ; i++)
       memset((*datos) + new_len - 8 + i , ((char*)&len)[7 - i] , sizeof(char));

   return new_len;
}


¡Saludos!

El enlace para la descarga

[Eternal Idol]

¿Y para que necesitamos tanto codigo entonces? Hay lugares especificos donde subirlos, esta claro que el foro no es para eso, ni lo soporta ...

[OmarHack]

Cuando tenga tiempo os dejo "algunos" cifrados que tengo en C++.
Lo subiré a sourcecode para no tumbar la página y a los que abran el tema. xDDD
Increíble el curro de todos.

PD: uso system porque total tengo que recurrir al sistema si o si. La API de windows no sirve para nada que no sea windows, así que creo que da lo mismo. System es menos código.

PD2: Pensé que sha1 era bastante más largo.

PD3: ¿Cuántos gigas tiene el server y cuantos ocupados? Tiene que ser una locura.

Yo pienso que tiene sobre 15 teras.

[X3R4CK3R]

uso system porque total tengo que recurrir al sistema si o si. La API de windows no sirve para nada que no sea windows, así que creo que da lo mismo. System es menos código.

En cuanto a portablidad, claro, da lo mismo, te lo decía porque es un mal hábito llamar al sistema cuando en C++ tienes funciones para la misma tarea, más que nada porque gastas recursos innecesarios (y la diferencia es bien grande).

Saludos

[eferion]

Función que devuelve true si un numero es primo :p

Quizás se pueda optimizar más, pero weno jeje

Código (cpp) [Seleccionar] Expandir


bool primo(unsigned int u){
unsigned int i=0;
if(u<2) return FALSE;   //Comprobar si es 1
for (i=2; u%i!=0; i+=2) {if(i>u/2){ i=u; break;}}  //Rompera cuando se encuentre un divisor, o el 'i' sea mayor que la mitad de el numero (para ahorrar tiempo)
if (u == i) return TRUE; //Si el divisor encontrado es el mismo numero, es primo
else return FALSE; //Sino, no lo es
}

El caso es que mirando el código había algo que no me gustaba... me decidí a probarlo y este es el resultado:

Mi codigo:

Código (c) [Seleccionar] Expandir


void main( )
{
 for ( unsigned int i=2;i<20;++i )
 {
   if ( primo( i ) )
     std::cout << i << " es primo" << std::endl;
 }
}

El resultado:

Código [Seleccionar] Expandir


2  es primo
3  es primo
5  es primo
7  es primo
9  es primo
11  es primo
13  es primo
15  es primo
17  es primo
19  es primo

Me da a mí que tu código necesita un repaso.

EI: juntando mensajes.

Venga vale, no solo me voy a dedicar a criticar... mi versión para los números primos:

Código (cpp) [Seleccionar] Expandir


bool primo(unsigned int u)
{
  bool to_return = true;

  if( u<2 )
    to_return = false; // Comprobar si es 1
  else if ( u != 2 )
  {
    if ( u % 2 == 0 ) // Divisible entre 2
      to_return = false;
    else
    {
      unsigned int tope = u/3;
      for ( unsigned int i=3; i <= tope && to_return; i+=2 )
        to_return = ( u % i != 0 );
    }
  }

  return to_return;
}

[OmarHack]

En cuanto a portablidad, claro, da lo mismo, te lo decía porque es un mal hábito llamar al sistema cuando en C++ tienes funciones para la misma tarea, más que nada porque gastas recursos innecesarios (y la diferencia es bien grande).

Saludos

No creo que haya tanta diferecia, si me lo puedes demostrar las usaré
Gracias, voy a informarme, un saludo.

[X3R4CK3R]

No creo que haya tanta diferecia, si me lo puedes demostrar las usaré
Gracias, voy a informarme, un saludo.

prueba a hacer un bucle infinito donde printeas un mensaje con printf o cout, y otro con system("echo ..."), verás que éste último te consume casi un núcleo entero de CPU.

Saludos