Wie zu verwenden salsa20 (oder ChaCha)?

Davon ausgehen, dass wir eine große Datei, die gelesen werden kann in Blöcken von 1024 bytes oder so, wie kann ich verschlüsseln und entschlüsseln jedes Stück mit Salsa oder Chacha 20?

Außerdem, wo würde ich angeben, die Anzahl der Runden (z.B. 8, 12 oder 20)?

So weit, ich habe nicht in der Lage, um es herauszufinden, indem man die eSTREAM-test-Paket 🙁

Ich heruntergeladen habe die folgenden Dateien über eSTREAM und die Salsa20 homepage:

• chacha.c
• ecrypt-config.h
• ecrypt-Maschine.h
• ecrypt-portable.h
• ecrypt-sync.h

Und ich sehe die Kommentare im verschlüsseln-sync.h sprechen Sie über den Aufruf von Funktionen in dieser Reihenfolge:

• ECRYPT_keysetup();
• ECRYPT_ivsetup();
• ECRYPT_encrypt_bytes();

Aber ich habe absolut keine Ahnung, was genau ich da sein soll, liefert die als Parameter an diese Arbeit machen...

Hier ist mein bester Versuch bisher, beginnend mit einem kleinen string der Klartext (mein C ist rostig... es ist möglich ich habe gemacht einige grundlegende Fehler, obwohl ich es nicht sehen können):

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "ecrypt-sync.h"

#define CHUNKSIZE 1024

void getRandomBytes(u8 **str, u32 len);
void showData(u8 *data, u8 *header);

int main(int argc, char** argv)
{
    char plaintext[CHUNKSIZE] = "THIS IS A TEST";
    ECRYPT_ctx ctx;
    u8 *key, *IV, *ciphertext, *result;

    /*
    Don't use random values till we get it working with zeroes at least
    getRandomBytes(&key, ECRYPT_MAXKEYSIZE/8);
    getRandomBytes(&IV, ECRYPT_MAXIVSIZE/8);
    */

    key = (u8 *)calloc((size_t)ECRYPT_MAXKEYSIZE/8, sizeof(u8));
    IV = (u8 *)calloc((size_t)ECRYPT_MAXIVSIZE/8, sizeof(u8));

    printf("Encrypting [%s] using random %d bit key and %d bit IV:\n", plaintext, ECRYPT_MAXKEYSIZE, ECRYPT_MAXIVSIZE);

    ECRYPT_init();
    ECRYPT_keysetup(&ctx, key, ECRYPT_MAXKEYSIZE, ECRYPT_MAXIVSIZE);
    ECRYPT_ivsetup(&ctx, IV);

    ciphertext = (u8 *)calloc((size_t)CHUNKSIZE, sizeof(u8));

    ECRYPT_encrypt_bytes(&ctx, plaintext, ciphertext, CHUNKSIZE);

    //showData(ciphertext, "CIPHERTEXT");

    result = (u8 *)calloc((size_t)CHUNKSIZE, sizeof(u8));

    ECRYPT_decrypt_bytes(&ctx, ciphertext, result, CHUNKSIZE);
    printf("And now decrypting back: [%s]\n", result);

    return 0;
}

void showData(u8 *data, u8 *header) {
    printf("\n-----BEGIN %s-----\n%s\n-----END %s-----\n", header, data, header);

}

void getRandomBytes(u8 **str, u32 len) {
    int fd = open("/dev/random", O_RDONLY);
    char *ptr = malloc((size_t) + 1);

    read(fd, ptr, len);
    close(fd);

    ptr[len] = '\0';
    *str = ptr; 
}

Ergebnisse werden wie:

Verschlüsseln [DIES IST EIN TEST] mit zufälligen 256-bit-Schlüssel und 64-bit-IV:
Und jetzt Entschlüsselung zurück: [(Reihe von zufälligen Zeichen)]

Wo es sein sollte:

Und jetzt Entschlüsselung zurück: [DIES IST EIN TEST]

Fühlen Sie sich frei, um Ihre Lösung in C oder C++

Danke!