GNUPG jak k šifrování souborů, aniž by to původní rozšíření ve jménu?

hlasů
3

Musím se automaticky šifrovat soubor např myfile.xls na myfile.gpg. A teď, když se snažím, aby to automaticky nebo s GNU soukromí asistent šifrování, zašifrovaný soubor myfile.xls.gpg. Když jsem odstranit, .xls, má po dešifrování bez přípony. Děkuji.

Položena 22/03/2012 v 07:35
zdroj uživatelem
V jiných jazycích...                            


2 odpovědí

hlasů
10

Tato možnost gpgencrypt.c vypadá příliš mnoho úsilí.

Chcete-li šifrovat to následujícím způsobem:

gpg -er $recipient_id -o myfile.gpg myfile.xls

K dešifrování a obnovit původní název souboru to následujícím způsobem:

gpg --use-embedded-filename -d myfile.gpg

To jméno bylo zakódováno a je uložen s šifrovaným datům. Ta vlajka říká GPG použít původní název souboru namísto vytváření nový název na základě názvu zašifrovaného souboru.

Odpovězeno 22/09/2013 v 04:59
zdroj uživatelem

hlasů
2

To by mohlo být provedeno snadno pomocí jednoduchého C aplikace, která řídí výstup. Níže uvedený soubor může dělat to, co hledáte, stačí zkompilovat (spojený proti libgpgme) a předat jí vstupní soubor, požadované výstupní soubor a pár klíč-id má být použit pro šifrování.

Kompilovat pomocí gcc, jednoduše uložit níže uvedený kód jako gpgencrypt.c a kompilovat gcc gpgencrypt.c -lgpgme -o gpgencrypt. (musíte libgpgme nainstalován)

Syntaxe vyvolání je gpgencrypt <input file> <output file> <encrypt to>. tjgpgencrypt myfile.xls myfile.gpg 01234567 12345678

file: gpgencrypt.c

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stdlib.h>
#include <errno.h>
#include <locale.h>

#include <gpgme.h>

#define fail_if_err(err)                                    \
    do {                                                    \
        if (err) {                                          \
            fprintf (stderr, "%s:%d: %s: %s\n",             \
                __FILE__, __LINE__, gpgme_strsource (err),  \
                gpgme_strerror (err));                      \
            exit (1);                                       \
        }                                                   \
    }                                                       \
    while (0)

typedef char * string;

void gpgEncrypt(const char *fileToEncrypt, const char *outputFileName,
                char *encryptTo[],
                int encryptToLength) {
    gpgme_ctx_t ctx;
    gpgme_error_t err;
    gpgme_data_t in, out;
    gpgme_encrypt_result_t enc_result;
    FILE *outputFile;
    gpgme_key_t keys[encryptToLength];
    int nrecipients = 0;
    int BUF_SIZE = 512;
    char buf[BUF_SIZE + 1];
    int ret;

    /* Begin setup of GPGME */
    gpgme_check_version (NULL);
    setlocale (LC_ALL, "");
    gpgme_set_locale (NULL, LC_CTYPE, setlocale (LC_CTYPE, NULL));
#ifndef HAVE_W32_SYSTEM
    gpgme_set_locale (NULL, LC_MESSAGES, setlocale (LC_MESSAGES, NULL));
#endif
    /* End setup of GPGME */

    // Create the GPGME Context
    err = gpgme_new (&ctx);
    // Error handling
    fail_if_err (err);

    // Set the context to textmode
    gpgme_set_textmode (ctx, 1);
    // Enable ASCII armor on the context
    gpgme_set_armor (ctx, 1);

    // Create a data object pointing to the input file
    err = gpgme_data_new_from_file (&in, fileToEncrypt, 1);
    // Error handling
    fail_if_err (err);

    // Create a data object pointing to the out buffer
    err = gpgme_data_new (&out);
    // Error handling
    fail_if_err (err);

    // Retrieve the keys used to encrypt to
    for (nrecipients=0; nrecipients < encryptToLength; nrecipients++) {
        printf("Retrieving key: %s, %i of %i\n", encryptTo[nrecipients], nrecipients, encryptToLength);
        err = gpgme_get_key (ctx, encryptTo[nrecipients], &keys[nrecipients], 0);

        if(err != GPG_ERR_NO_ERROR)
            printf("error");
    }

    // NULL terminate the key array
    keys[nrecipients] = NULL;

    // Encrypt the contents of "in" using the defined mode and place it into "out"
    err = gpgme_op_encrypt (ctx, keys, GPGME_ENCRYPT_ALWAYS_TRUST, in, out);
    // Error handling
    fail_if_err (err);

    // Retrieve the encrypt result from the context
    enc_result = gpgme_op_encrypt_result (ctx);

    // Check for invalid recipients
    if (enc_result->invalid_recipients) {
        fail_if_err (err);
    }

    // Open the output file
    outputFile = fopen (outputFileName, "w+");

    // Rewind the "out" data object
    ret = gpgme_data_seek (out, 0, SEEK_SET);
    // Error handling
    if (ret)
        fail_if_err (gpgme_err_code_from_errno (errno));

    // Read the contents of "out" and place it into buf
    while ((ret = gpgme_data_read (out, buf, BUF_SIZE)) > 0) {
        // Write the contents of "buf" to "outputFile"
        fwrite (buf, ret, 1, outputFile);
    }

    // Error handling
    if (ret < 0)
        fail_if_err (gpgme_err_code_from_errno (errno));

    // Close "outputFile"
    fclose(outputFile);

    // Unreference the key objects
    for (nrecipients=0; nrecipients < sizeof(&keys) / sizeof(int) + 1; nrecipients++) {
        if (keys[nrecipients]) {
            printf ("Releasing key: %s\n", keys[nrecipients]->subkeys->fpr);
            gpgme_key_unref (keys[nrecipients]);
        }
    }

    // Release the "in" data object
    gpgme_data_release (in);
    // Release the "out" data object
    gpgme_data_release (out);
    // Release the context
    gpgme_release (ctx);
}

int 
main (int argc, char **argv) {
    if (argc < 4) {
        printf ("Usage: gpgencrypt <input file> <output file> <encrypt to>\n");
        exit (1);
    }
    int pos, n;
    string encryptToList[argc - 4];

    printf ("Encrypting %s and placing the result into %s\n",
                argv[1], argv[2]);

    for (pos=3; pos < argc; pos++) {
        encryptToList[n] = argv[pos];
        n++;
    }
    gpgEncrypt (argv[1], argv[2], encryptToList, argc - 3);
    return 0;
}
Odpovězeno 01/07/2012 v 19:42
zdroj uživatelem

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more