फ़ाइल डिक्रिप्शन के दौरान "EVP_DecryptFInal_ex: खराब डिक्रिप्ट" को कैसे हल करें




encryption openssl (2)

मुझे लगता है कि कुंजी और चतुर्थ एन्क्रिप्शन के लिए आपके प्रोग्राम का उपयोग करके कमांड लाइन और डिक्रिप्शन का उपयोग करना समान नहीं है I

कृपया ध्यान दें कि जब आप "-के" ("-के" से अलग) का उपयोग करते हैं, तो दिए गए इनपुट को उस पासवर्ड के रूप में माना जाता है, जिससे कुंजी प्राप्त होती है। आम तौर पर इस मामले में, "-क" विकल्प के साथ दिए गए इनपुट से दोनों कुंजी और पासवर्ड के रूप में "-iv" विकल्प की कोई ज़रूरत नहीं है।

यह आपके प्रश्न से स्पष्ट नहीं है, आप यह सुनिश्चित कैसे कर रहे हैं कि कुंजी और IV एन्क्रिप्शन और डिक्रिप्शन के बीच समान हैं

मेरे सुझाव में, एन्क्रिप्शन के दौरान कुंजी और IV को स्पष्ट रूप से निर्दिष्ट करने के लिए "-के" और "-iv" विकल्प का बेहतर उपयोग करें और डिक्रिप्शन के लिए इसका उपयोग करें। यदि आपको "-के" का उपयोग करना है, तो कुंजी को मुद्रित करने के लिए "-p" विकल्प का उपयोग करें और iv एन्क्रिप्शन के लिए उपयोग किया जाता है और अपने डिक्रिप्शन प्रोग्राम में उसी का उपयोग करें।

अधिक विवरण https://www.openssl.org/docs/manmaster/apps/enc.html पर प्राप्त किया जा सकता है

मेरे पास निम्न प्रश्न हैं। कोई भी कृपया मुझे समाधान का सुझाव दे सकता है।

मैं पहली बार फाइल के एन्क्रिप्शन और डिक्रिप्शन पर काम कर रहा हूं

कमांड प्रॉम्प्ट के माध्यम से मैंने कमांड प्रॉम्प्ट पर फ़ाइल को एन्क्रिप्ट किया है:

openssl enc -aes-256-cbc -in file.txt -out file.enc -k "key value" -iv "iv value"

मुझे यह कार्यक्रम को डिक्रिप्ट करना होगा इसलिए मैंने इसके लिए प्रोग्राम लिखा है, लेकिन यह निम्नलिखित त्रुटि फेंक रहा है:

./exe_file enc_file_directory
...
error: 06065064: digital envelope routines: EVP_DecryptFInal_ex: bad decrypt: evp_enc.c

नीचे दिए गए प्रोग्राम निर्देशिका पथ के रूप में इनपुट लेता है और एन्क्रिप्ट की गई फ़ाइल ".enc" के लिए खोज करता है और इसे बफर में पढ़ते समय डिक्रिप्ट करने का प्रयास करता है।

कोड:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <dirent.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <openssl/evp.h>
#include <openssl/err.h>
#include <openssl/conf.h>
#include <libxml/globals.h>

void handleErrors(char *msg)
{
    {
        ERR_print_errors_fp(stderr);
        printf("%s", msg);
        abort(); 
    }
}

void freeMemory(char *mem)
{
    if (NULL != mem)
    {
        free(mem);
        mem = NULL;
    }
}

/* Function to decrypt the XML files */

int decryptXML(unsigned char *indata, unsigned char *outdata, int fsize)
{

    int outlen1 = 0, outlen2 = 0;

    unsigned char iv[] = "b63e541bc9ece19a1339df4f8720dcc3";
    unsigned char ckey[] = "70bbc518c57acca2c2001694648c40ddaf19e3b4fe1376ad656de8887a0a5ec2" ;

    if (NULL == indata)
    {
        printf ("input data is empty\n");
        return 0;
    }

    if (0 >= fsize)
    {
        printf ("file size is zero\n");
        return 0;
    }

    outdata = (char *) malloc (sizeof (char) * fsize * 2);

    EVP_CIPHER_CTX ctx;

    EVP_CIPHER_CTX_init(&ctx);

    if (! EVP_DecryptInit_ex (&ctx, EVP_aes_256_cbc(), NULL, ckey, iv))
    {
        EVP_CIPHER_CTX_cleanup(&ctx);
    handleErrors("DInit");
    }

    if (! EVP_DecryptUpdate (&ctx, outdata, &outlen1, indata, fsize))
    {
        EVP_CIPHER_CTX_cleanup(&ctx);
        handleErrors("DUpdate");
    }

    if (! EVP_DecryptFinal_ex (&ctx, outdata + outlen1, &outlen2))
    {

        EVP_CIPHER_CTX_cleanup(&ctx);
        handleErrors("DFinal");
    }

    EVP_CIPHER_CTX_cleanup(&ctx);

    return outlen1+outlen2;

}

int isDirectory(char *path)
{
    DIR *dir = NULL;
    FILE *fin = NULL, *fout = NULL;
    int enc_len = 0, dec_len = 0, fsize = 0, ksize = 0;
    unsigned char *indata = NULL, *outdata = NULL;
    char buff[BUFFER_SIZE], file_path[BUFFER_SIZE], cur_dir[BUFFER_SIZE];

    struct dirent *in_dir;
    struct stat s;

    if (NULL == (dir = opendir(path)))
    {
        printf ("ERROR: Failed to open the directory %s\n", path);
        perror("cannot open.");
        exit(1);
    }

    while (NULL != (in_dir = readdir(dir)))
    {

        if (!strcmp (in_dir->d_name, ".") || !strcmp(in_dir->d_name, ".."))
            continue;

        sprintf (buff, "%s/%s", path, in_dir->d_name);

        if (-1 == stat(buff, &s))
        {
            perror("stat");
            exit(1);
        }

        if (S_ISDIR(s.st_mode))
        {

            isDirectory(buff);
        }
        else
        {
            strcpy(file_path, buff);

            if (strstr(file_path, ".enc"))
            {

                /* File to be decrypted */

                fout = fopen(file_path,"rb"); 

                fseek (fout, 0L, SEEK_END);
                fsize = ftell(fout);
                fseek (fout, 0L, SEEK_SET);

                indata = (char*)malloc(fsize);

                fread (indata, sizeof(char), fsize, fout);

                if (NULL == fout)
                {
                    perror("Cannot open enc file: ");
                    return 1;
                }


                dec_len = decryptXML (indata, outdata, fsize);
                outdata[dec_len] = '\0';
                printf ("%s\n", outdata);
                fclose (fin);
                fclose (fout);

            }
        }
    }



    closedir(dir);
    freeMemory(outdata);
    freeMemory(indata);

    return 1; 
}


int main(int argc, char *argv[])
{
    int result;

    if (argc != 2)
    {
        printf ("Usage: <executable> path_of_the_files\n");
        return -1;
    }

    ERR_load_crypto_strings();
    OpenSSL_add_all_algorithms();
    OPENSSL_config(NULL);

    /* Checking for the directory existance */

    result = isDirectory(argv[1]);

    EVP_cleanup();
    ERR_free_strings();

    if (0 == result)
        return 1;
    else
       return 0;
}

धन्यवाद।


यह संदेश digital envelope routines: EVP_DecryptFInal_ex: bad decrypt तब भी उत्पन्न हो सकता है जब आप digital envelope routines: EVP_DecryptFInal_ex: bad decrypt असंगत संस्करणों को एन्क्रिप्ट और डिक्रिप्ट करते हैं।

मुझे जो समस्या थी वो था कि मैं विंडोज पर एन्क्रिप्ट कर रहा था, जिसकी संस्करण 1.1.0 थी और उसके बाद एक सामान्य लिनक्स सिस्टम पर डिक्रिप्ट किया गया था जिसमें 1.0.2 जी था।

यह एक बहुत ही उपयोगी त्रुटि संदेश नहीं है!







openssl