Club Builder - Foros de discusión Club Builder
Foro de C++Builder en español
 
 FAQFAQ   BuscarBuscar   MiembrosMiembros   Grupos de UsuariosGrupos de Usuarios   RegistrarseRegistrarse 
 PerfilPerfil   Entra para ver tus mensajes privadosEntra para ver tus mensajes privados   EntrarEntrar 

Algoritmo de digestion MD5 y algoritmo de encripcion RSA

 
Publicar nuevo tema   Responder al tema    Foros de discusión -> Consultas
Ver tema anterior :: Ver tema siguiente  
Autor Mensaje
Mensaje    Asunto: Algoritmo de digestion MD5 y algoritmo de encripcion RSA Responder citando

¿Alguien tiene esos algoritmos?
_________________
Ing. Gabriel Góngora Navarrete
TouchSoftwares Inc

http://www.touchsoftwares.com
Volver arriba
Ver perfil de usuario Enviar mensaje privado Visitar sitio web del autor MSN Messenger
Mensaje    Asunto: Responder citando

En la Wiki explican el algoritmo
[url]
http://es.wikipedia.org/wiki/MD5
[/url]

Te paso la clase que utilizo yo:
Código:

//---------------------------------------------------------------------------
#ifndef TMD5H
#define TMD5H
//---------------------------------------------------------------------------
#include <SysUtils>
#include <Classes>
//---------------------------------------------------------------------------
//-----------------------------
#define MD5 5
#ifndef MD
#define MD MD5
#endif

#include <stdio>
#include <string>
#include "global.h"

#if MD == 5
#include "md5.h"
#endif
// Constants for MD5Transform routine.
#define S11 7
#define S12 12
#define S13 17
#define S14 22
#define S21 5
#define S22 9
#define S23 14
#define S24 20
#define S31 4
#define S32 11
#define S33 16
#define S34 23
#define S41 6
#define S42 10
#define S43 15
#define S44 21
static unsigned char 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
};
// F, G, H and I are basic MD5 functions.
#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define I(x, y, z) ((y) ^ ((x) | (~z)))
// ROTATE_LEFT rotates x left n bits.
#define ROTATE_LEFT(x, n) (((x) <<n>> (32-(n))))
/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
Rotation is separate from addition to prevent recomputation.
 */
#define FF(a, b, c, d, x, s, ac) { \
 (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
 (a) = ROTATE_LEFT ((a), (s)); \
 (a) += (b); \
  }
#define GG(a, b, c, d, x, s, ac) { \
 (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
 (a) = ROTATE_LEFT ((a), (s)); \
 (a) += (b); \
  }
#define HH(a, b, c, d, x, s, ac) { \
 (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
 (a) = ROTATE_LEFT ((a), (s)); \
 (a) += (b); \
  }
#define II(a, b, c, d, x, s, ac) { \
 (a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
 (a) = ROTATE_LEFT ((a), (s)); \
 (a) += (b); \
  }

#if MD == 2
#define MD_CTX MD2_CTX
#define MDInit MD2Init
#define MDUpdate MD2Update
#define MDFinal MD2Final
#endif
#if MD == 4
#define MD_CTX MD4_CTX
#define MDInit MD4Init
#define MDUpdate MD4Update
#define MDFinal MD4Final
#endif
#if MD == 5
#define MD_CTX MD5_CTX
#define MDInit MD5Init
#define MDUpdate MD5Update
#define MDFinal MD5Final
#endif
//TMD5 Class
class TMD5
{
private:

protected:
 void __fastcall MD5Init (MD5_CTX *);
 void __fastcall MD5Update (MD5_CTX *, unsigned char *, unsigned int);
 void __fastcall MD5Final (unsigned char [16], MD5_CTX *);
 void __fastcall MD5Transform (UINT4 [4], unsigned char [64]);
 void __fastcall Encode (unsigned char *, UINT4 *, unsigned int);
 void  __fastcall Decode (UINT4 *, unsigned char *, unsigned int);
 void __fastcall MD5_memcpy (POINTER, POINTER, unsigned int);
 void __fastcall MD5_memset (POINTER, int, unsigned int);
 AnsiString __fastcall MDString (char*);
public:
    AnsiString Digest;
         __fastcall TMD5(TComponent* Owner);
    AnsiString __fastcall HashString(AnsiString StringAEncriptar);
};
//---------------------------------------------------------------------------
#endif
Volver arriba
Ver perfil de usuario Enviar mensaje privado Enviar email
Mensaje    Asunto: Responder citando

Código:

//---------------------------------------------------------------------------
#include <vcl>
#pragma hdrstop

#include "TMD5.h"
#pragma package(smart_init)
//---------------------------------------------------------------------------

__fastcall TMD5::TMD5(TComponent* Owner)
       
{
}
//---------------------------------------------------------------------------

AnsiString __fastcall TMD5::MDString (char *string)
{
  MD_CTX context;
  unsigned char digest[16];
  unsigned int len = strlen (string);
  AnsiString Hex;

  MDInit (&context);
  MDUpdate (&context, string, len);
  MDFinal (digest, &context);
  Digest="";
  for (int i = 0; i <16>count[0] = context->count[1] = 0;
 // Load magic initialization constants.
  context->state[0] = 0x67452301;
  context->state[1] = 0xefcdab89;
  context->state[2] = 0x98badcfe;
  context->state[3] = 0x10325476;
}
/* MD5 block update operation. Continues an MD5 message-digest
  operation, processing another message block, and updating the
  context.
 */
void __fastcall TMD5::MD5Update (MD5_CTX *context,unsigned char * input, unsigned int inputLen)
{
  unsigned int i, index, partLen;

  // Compute number of bytes mod 64
  index = (unsigned int)((context->count[0] >> 3) & 0x3F);

  // Update number of bits
  if ((context->count[0] += ((UINT4)inputLen << 3))

   < ((UINT4)inputLen <<3>count[1]++;
  context->count[1] += ((UINT4)inputLen >> 29);

  partLen = 64 - index;

  // Transform as many times as possible.
  if (inputLen >= partLen) {
 MD5_memcpy
   ((POINTER)&context->buffer[index], (POINTER)input, partLen);
 MD5Transform (context->state, context->buffer);

 for (i = partLen; i + 63 <inputLen>state, &input[i]);

 index = 0;
  }
  else
 i = 0;

  // Buffer remaining input
  MD5_memcpy
 ((POINTER)&context->buffer[index], (POINTER)&input[i],
  inputLen-i);
}

/* MD5 finalization. Ends an MD5 message-digest operation, writing the
  the message digest and zeroizing the context.
 */
void __fastcall TMD5::MD5Final (unsigned char digest[16], MD5_CTX *context)
{
  unsigned char bits[8];
  unsigned int index, padLen;

  /* Save number of bits */
  Encode (bits, context->count, 8);

  /* Pad out to 56 mod 64.*/
  index = (unsigned int)((context->count[0] >> 3) & 0x3f);
  padLen = (index <56>state, 16);
  /* Zeroize sensitive information.*/
  MD5_memset ((POINTER)context, 0, sizeof (*context));
}
/* MD5 basic transformation. Transforms state based on block. */
void __fastcall TMD5::MD5Transform (UINT4 state[4], unsigned char block[64])
{
  UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
  Decode (x, block, 64);
  /* Round 1 */
  FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
  FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
  FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
  FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
  FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
  FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
  FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
  FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
  FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
  FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
  FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
  FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
  FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
  FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
  FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
  FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
 /* Round 2 */
  GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
  GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
  GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
  GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
  GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
  GG (d, a, b, c, x[10], S22,  0x2441453); /* 22 */
  GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
  GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
  GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
  GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
  GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
  GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
  GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
  GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
  GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
  GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
  /* Round 3 */
  HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
  HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
  HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
  HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
  HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
  HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
  HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
  HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
  HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
  HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
  HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
  HH (b, c, d, a, x[ 6], S34,  0x4881d05); /* 44 */
  HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
  HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
  HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
  HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
  /* Round 4 */
  II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
  II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
  II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
  II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
  II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
  II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
  II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
  II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
  II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
  II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
  II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
  II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
  II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
  II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
  II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
  II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
  state[0] += a;
  state[1] += b;
  state[2] += c;
  state[3] += d;
  /* Zeroize sensitive information.*/
  MD5_memset ((POINTER)x, 0, sizeof (x));
}

/* Encodes input (UINT4) into output (unsigned char). Assumes len is
  a multiple of 4.*/
void __fastcall TMD5::Encode (unsigned char *output, UINT4 *input, unsigned int len)
{
  unsigned int i, j;
 for (i = 0, j = 0; j <len>> 8) & 0xff);
  output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
  output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
 }
}
/* Decodes input (unsigned char) into output (UINT4). Assumes len is
  a multiple of 4.*/
void __fastcall TMD5::Decode (UINT4 *output, unsigned char *input, unsigned int len)
{
  unsigned int i, j;
  for (i = 0, j = 0; j < len; i++, j += 4)
   output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) |
   (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
}
/* Note: Replace "for loop" with standard memcpy if possible.*/
void __fastcall TMD5::MD5_memcpy (POINTER output, POINTER input, unsigned int len)
{
  unsigned int i;
  for (i = 0; i < len; i++)
   output[i] = input[i];
}
/* Note: Replace "for loop" with standard memset if possible.*/
void __fastcall TMD5::MD5_memset (POINTER output, int value, unsigned int len)
{
  unsigned int i;
  for (i = 0; i < len; i++)
 ((char *)output)[i] = (char)value;
}
AnsiString __fastcall TMD5::HashString(AnsiString StringAEncriptar)
{
    AnsiString MD5Digest;
    MD5Digest=MDString(StringAEncriptar.c_str());
    return MD5Digest;
}
Volver arriba
Ver perfil de usuario Enviar mensaje privado Enviar email
Mensaje    Asunto: Responder citando

... y se utiliza

Código:

    // Creo un puntero a la clase del Encriptador y lo inicializo
    TMD5    *MMD5;
    MMD5=new TMD5(this);

    ClaveAEncriptar="Cualquier texto";

    // Capturo la clave anterior encriptada, llamando a la función del encriptador
    // pasándole la clave capturada
    ClaveEncriptada=MMD5->HashString(ClaveAEncriptar);
Volver arriba
Ver perfil de usuario Enviar mensaje privado Enviar email
Mensaje    Asunto: Responder citando

Gracias, los pensaba para hacer lo de facturacion electronica CFD, termine comprando una dll que y alo hacia.
GRACIAS POR CONTESTAR!
_________________
Ing. Gabriel Góngora Navarrete
TouchSoftwares Inc

http://www.touchsoftwares.com
Volver arriba
Ver perfil de usuario Enviar mensaje privado Visitar sitio web del autor MSN Messenger
Mensaje    Asunto: Responder citando

Saludos a todos.

Disculpa por revivir este tema, pero no puedo hacer que compile me marca errores que no soy capaz de solucionar.


Cita:

[C++ Error] MD5.h(98): E2293 ) expected
[C++ Error] MD5.h(100): E2303 Type name expected


Esos errores me los marca en él .h cada vez que encuentra: "MD5_CTX *" si elimino el "*" ya no me marca error en esas líneas, pero el código ya no funciona.

Código:

void __fastcall MD5Init (MD5_CTX *);


Otra cosa ¿esta línea sirve para algo o se coló ?

Código:
#include "global.h"


He tratado de compilar en BCB6 y RADX2
Gracias por su tiempo.
_________________
[img]http://folding.extremeoverclocking.com/sigs/sigimage.php?un=snupoo&t=86565/sigimage.gif[/img]
A programar se aprende programando
Volver arriba
Ver perfil de usuario Enviar mensaje privado Enviar email MSN Messenger
Mensaje    Asunto: Responder citando

snupoo escribió:
Disculpa por revivir este tema, pero no puedo hacer que compile me marca errores que no soy capaz de solucionar.

Parece que el codigo esta incompleto, probablemente se puso sin usar la opcion "Deshabilitar HTML en este mensaje" al publicarlo en el foro.

Si te sirve esta otra opción usando el API:
Código:
// Añadimos las cabeceras: #include<memory>  #include<vector>

String MD5HashString(const String str, bool isFile = false)
{
    String ret = "";

    HCRYPTPROV hProv = 0;
    HCRYPTHASH hHash = 0;
    DWORD len = 0, i = sizeof(DWORD);

    CryptAcquireContext(&hProv, 0, 0, PROV_DSS, CRYPT_VERIFYCONTEXT);
    CryptCreateHash(hProv, CALG_MD5, 0,0, &hHash);
    // Para obtener SHA1, cambiar CALG_MD5 por CALG_SHA1

    std::auto_ptr<TMemoryStream> stream(new TMemoryStream);
    if (!isFile) {
        std::auto_ptr<TStringStream> streamS(new TStringStream(str));
        stream->LoadFromStream(streamS.get());
    }
    else
        stream->LoadFromFile(str);

    CryptHashData(hHash, static_cast<BYTE*>(stream->Memory), stream->Size, 0);

    CryptGetHashParam(hHash, HP_HASHSIZE, (PBYTE)&len, &i, 0);
    std::vector<BYTE> data(len);
    CryptGetHashParam(hHash, HP_HASHVAL, &data[0], &len, 0);

    CryptDestroyHash(hHash);
    CryptReleaseContext(hProv, 0);

    for (i = 0; i < len; ++i)
        ret += IntToHex(data[i], 2);

    return ret;
}

Ejemplo de uso:
Código:
    // Con una cadena
    String hash = MD5HashString("Prueba");
    // Con un archivo
    String hash = MD5HashString("d:\\prueba.xxx", true);
Volver arriba
Ver perfil de usuario Enviar mensaje privado
Mensaje    Asunto: Responder citando

Gracias _Leo simpre atento.

Saludos.
_________________
[img]http://folding.extremeoverclocking.com/sigs/sigimage.php?un=snupoo&t=86565/sigimage.gif[/img]
A programar se aprende programando
Volver arriba
Ver perfil de usuario Enviar mensaje privado Enviar email MSN Messenger
Mostrar mensajes de anteriores:   
Cambiar a:  
No puedes publicar temas nuevos en este foro
No puedes responder a temas en este foro
No puedes editar tus mensajes en este foro
No puedes borrar tus mensajes en este foro
No puedes votar en las encuestas de este foro


Hosting WordPress Indedmedia desde 3,99 €
© 2002–2026 Club Builder · Funciona con phpBB.