Verwendung von SHA1-Hashing in der C-Programmierung

Ich versuche, ein C-Programm zu schreiben, das beweist, dass SHA1 nahezu kollisionsfrei ist, aber ich kann nicht herausfinden, wie ich den Hash für meine Eingabewerte tatsächlich erstellen soll. Ich muss nur den Hash erstellen und den Hex-Wert in einem Array speichern. Nach einigen Google-Suchen habe ich eine OpenSSL-Dokumentation gefunden, die mich anweist, Folgendes zu verwenden:

 #include <openssl/sha.h>

 unsigned char *SHA1(const unsigned char *d, unsigned long n,
                  unsigned char *md);

 int SHA1_Init(SHA_CTX *c);
 int SHA1_Update(SHA_CTX *c, const void *data,
                  unsigned long len);
 int SHA1_Final(unsigned char *md, SHA_CTX *c);

Ich glaube, ich sollte entweder unsigned char *SHA1 oder SHA1_Init verwenden, aber ich bin mir nicht sicher, was die Argumente wären, da x meine zu hashende Eingabe ist. Würde das bitte jemand für mich klären? Vielen Dank.

Wenn Sie alle Ihre Daten auf einmal haben, verwenden Sie einfach die SHA1 Funktion:

// The data to be hashed
char data[] = "Hello, world!";
size_t length = strlen(data);

unsigned char hash[SHA_DIGEST_LENGTH];
SHA1(data, length, hash);
// hash now contains the 20-byte SHA-1 hash

Wenn Sie andererseits Ihre Daten nur Stück für Stück erhalten und den Hash berechnen möchten, während Sie diese Daten erhalten, verwenden Sie die anderen Funktionen:

// Error checking omitted for expository purposes

// Object to hold the current state of the hash
SHA_CTX ctx;
SHA1_Init(&ctx);

// Hash each piece of data as it comes in:
SHA1_Update(&ctx, "Hello, ", 7);
...
SHA1_Update(&ctx, "world!", 6);
// etc.
...
// When you're done with the data, finalize it:
unsigned char hash[SHA_DIGEST_LENGTH];
SHA1_Final(hash, &ctx);

Es sind zwei verschiedene Wege, um dasselbe zu erreichen.

Genauer gesagt, Sie entweder verwenden SHA_Initdann SHA_Update so oft wie nötig, um Ihre Daten durchzugeben und dann SHA_Final um die Zusammenfassung zu bekommen, oder Sie SHA1.

Der Grund für zwei Modi ist, dass es beim Hashen großer Dateien üblich ist, die Datei in Blöcken zu lesen, da die Alternative viel Speicher verbrauchen würde. Behalten Sie daher den Überblick SHA_CTX – Der SHA-Kontext – as you go ermöglicht es Ihnen, dies zu umgehen. Der Algorithmus passt intern auch zu diesem Modell – das heißt, Daten werden blockweise übergeben.

Das SHA Methode sollte ziemlich einfach sein. Der andere funktioniert so:

unsigned char md[SHA_DIGEST_LENGTH];
SHA_CTX context;
int SHA1_Init(&context);

for ( i = 0; i < numblocks; i++ )
{
    int SHA1_Update(&context, pointer_to_data, data_length);
}
int SHA1_Final(md, &context);

Entscheidend, am Ende md enthält den binären Digest, keine hexadezimale Darstellung – es ist keine Zeichenfolge und sollte nicht als solche verwendet werden.

Die erste Funktion (SHA1()) die übergeordnete ist, ist es wahrscheinlich die, die Sie wollen. Das Dokument ist ziemlich klar in Bezug auf die Verwendung – d eingegeben wird, n ist seine Größe u md Hier wird das Ergebnis platziert (Sie weisen es zu).

Was die anderen 3 Funktionen betrifft – diese sind niedriger und ich bin mir ziemlich sicher, dass sie intern von der ersten verwendet werden. Sie eignen sich besser für größere Eingaben, die blockweise verarbeitet werden müssen.

Ich glaube, ich sollte beide verwenden unsigned char *SHA1 oder SHA1_Init …

Für spätere Versionen der OpenSSL-Bibliothek, wie 1.0.2 und 1.1.0, empfiehlt das Projekt die Verwendung der EVP-Schnittstelle. Ein Anwendungsbeispiel EVP-Nachrichtenzusammenfassungen mit SHA256 ist im OpenSSL-Wiki verfügbar:

#define handleErrors abort

EVP_MD_CTX *ctx;

if((ctx = EVP_MD_CTX_create()) == NULL)
    handleErrors();

if(1 != EVP_DigestInit_ex(ctx, EVP_sha256(), NULL))
    handleErrors();

unsigned char message[] = "abcd .... wxyz";
unsinged int message_len = sizeof(message);

if(1 != EVP_DigestUpdate(ctx, message, message_len))
    handleErrors();

unsigned char digest[EVP_MAX_MD_SIZE];
unsigned int digest_len = sizeof(digest);

if(1 != EVP_DigestFinal_ex(ctx, digest, &digest_len))
    handleErrors();

EVP_MD_CTX_destroy(ctx);

Die Antwort von Adam Rosenfield ist in Ordnung, aber verwenden Sie strlen anstelle von sizeof, da sonst Hash einschließlich Nullterminator berechnet wird. Was in diesem Fall wahrscheinlich in Ordnung ist, aber nicht, wenn Sie Ihren Hash mit einem von einem anderen Tool generierten vergleichen müssen.

// The data to be hashed
char data[] = "Hello, world!";
size_t length = strlen(data);

unsigned char hash[SHA_DIGEST_LENGTH];
SHA1(data, length, hash);
// hash now contains the 20-byte SHA-1 hash

Berechnen Sie Hash wie folgt

// Object to hold the current state of the hash
SHA_CTX ctx;
SHA1_Init(&ctx);

// Hash each piece of data as it comes in:
SHA1_Update(&ctx, "Hello, ", 7);
...
SHA1_Update(&ctx, "world!", 6);
// etc.
...
// When you're done with the data, finalize it:
unsigned char tmphash[SHA_DIGEST_LENGTH];
SHA1_Final(tmphash, &ctx);

Schließlich können Sie Hash mit Code wie diesem in eine für Menschen lesbare Form decodieren.

unsigned char hash[SHA_DIGEST_LENGTH*2];

int i = 0;
for (i=0; i < SHA_DIGEST_LENGTH; i++) {
    sprintf((char*)&(hash[i*2]), "%02x", tmphash[i]);
}
// And print to stdout
printf("Hash: %s\n", hash);

Lassen Sie den Code sprechen

Der SQLite-Entwicklungsbaum enthält eine Quelle für das Tool DBHASH zum Anwenden von SHA1 auf ganze Datenbanken. Komplett mit SHA1-Implementierung.

Vielleicht finden Sie es machbar, diesen Code zu studieren.

ps: Gibt es auch SHA1 als SQLite-benutzerdefiniert implementiert Funktion.