title: How to resolve the "EVP_DecryptFInal_ex: bad decrypt" during file decryption
body: <p>I have the following query.Could any one please suggest me a solution.</p>
  
  <p>I'm working on encryption and decryption of file for first time.</p>
  
  <p>I have encrypted file through command prompt using the command:</p>
  
  <pre><code>openssl enc -aes-256-cbc -in file.txt -out file.enc -k "key value" -iv "iv value"
  </code></pre>
  
  <p>I have to decrypt it programmatically. So I have written the program for it, but it is throwing the following error:</p>
  
  <pre><code>./exe_file enc_file_directory
  ...
  error: 06065064: digital envelope routines: EVP_DecryptFInal_ex: bad decrypt: evp_enc.c
  </code></pre>
  
  <hr>
  
  <p>The program below takes input as directory path and search for encrypted file ".enc" and try to decrypt it read into buffer.</p>
  
  <p>Code:</p>
  
  <pre><code>#include &lt;stdio.h&gt;
  #include &lt;string.h&gt;
  #include &lt;stdlib.h&gt;
  #include &lt;dirent.h&gt;
  #include &lt;sys/stat.h&gt;
  #include &lt;sys/types.h&gt;
  #include &lt;openssl/evp.h&gt;
  #include &lt;openssl/err.h&gt;
  #include &lt;openssl/conf.h&gt;
  #include &lt;libxml/globals.h&gt;
  
  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 &gt;= fsize)
      {
          printf ("file size is zero\n");
          return 0;
      }
  
      outdata = (char *) malloc (sizeof (char) * fsize * 2);
  
      EVP_CIPHER_CTX ctx;
  
      EVP_CIPHER_CTX_init(&amp;ctx);
  
      if (! EVP_DecryptInit_ex (&amp;ctx, EVP_aes_256_cbc(), NULL, ckey, iv))
      {
          EVP_CIPHER_CTX_cleanup(&amp;ctx);
      handleErrors("DInit");
      }
  
      if (! EVP_DecryptUpdate (&amp;ctx, outdata, &amp;outlen1, indata, fsize))
      {
          EVP_CIPHER_CTX_cleanup(&amp;ctx);
          handleErrors("DUpdate");
      }
  
      if (! EVP_DecryptFinal_ex (&amp;ctx, outdata + outlen1, &amp;outlen2))
      {
  
          EVP_CIPHER_CTX_cleanup(&amp;ctx);
          handleErrors("DFinal");
      }
  
      EVP_CIPHER_CTX_cleanup(&amp;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-&gt;d_name, ".") || !strcmp(in_dir-&gt;d_name, ".."))
              continue;
  
          sprintf (buff, "%s/%s", path, in_dir-&gt;d_name);
  
          if (-1 == stat(buff, &amp;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: &lt;executable&gt; 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;
  }
  </code></pre>
  
  <p>Thank you.</p>