View difference between Paste ID: vap0DcuF and gDUQLZCs

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <unistd.h>
 #include <math.h>
 #include <openssl/aes.h>
 #include <openssl/evp.h>
 
 #include <assert.h>
 static const char BASE64_CHARS[64] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
 void base64_encode_triple(const unsigned char *src, char *dest)
 {
     int i, v;
 
     v = (((src[0] << 8) + src[1]) << 8) + src[2];
     for (i = 0; i < 4; ++i)
     {
         dest[3 - i] = BASE64_CHARS[v%64];
         v /= 64;
     }
 }
 
-int base64_encode(const unsigned char *src, unsigned int src_len, char *dest, size_t dest_len)
+int base64_encode(const unsigned char *src, size_t src_len, char *dest, size_t dest_len)
 {
     unsigned char tmp[3];
 
     if (4*(src_len + 2)/3 >= dest_len)
     {
         return 0;
     }
     while (src_len >= 3)
     {
         base64_encode_triple(src, dest);
         src     += 3;
         src_len -= 3;
         dest    += 4;
     }
     if (src_len > 0)
     {
         memset(tmp, 0, sizeof(tmp));
         memcpy(tmp, src, src_len);
         base64_encode_triple(tmp, dest);
         dest[3] = '=';
         if (src_len == 1)
         {
             dest[2] = '=';
         }
         dest += 4;
     }
     *dest = '\0';
     return 1;
 }
 
 int base64_char_value(char ch)
 {
     return  (ch >= 'A' && ch <= 'Z') ? ch - 'A'      :
             (ch >= 'a' && ch <= 'z') ? ch - 'a' + 26 :
             (ch >= '0' && ch <= '9') ? ch - '0' + 52 :
             (ch == '+')              ?            62 :
             (ch == '/')              ?            63 : -1;
 }
 
 int base64_decode_triple(const char *src, unsigned char *dest)
 {
     int digits[4], dest_len, junk, i, v;
 
     dest_len = 3;
     junk = 1;
     for (i = 0; i < 4; ++i)
     {
         digits[i] = base64_char_value(src[i]);
     }
     for (i = 3; i >= 0; --i)
     {
         if (digits[i] >= 0)
         {
             junk = 0;
         }
         else
         {
             if (!junk || src[i] != '=')
             {
                 return 0;
             }
             digits[i] = 0;
             --dest_len;
         }
     }
     if (dest_len < 0)
     {
         dest_len = 0;
     }
     v = (((((digits[0] << 6) + digits[1]) << 6) + digits[2]) << 6) + digits[3];
     for (i = dest_len; i < 3; ++i)
     {
         v >>= 8;
     }
     for (i = dest_len - 1; i >= 0; --i)
     {
         dest[i] = v;
         v >>= 8;
     }
     return dest_len;
 }
 
 int base64_decode(const char *src, unsigned char *dest, size_t dest_len)
 {
     int i, decoded, total_decoded;
     char temp_src[4], *copy, *p;
     unsigned char temp_dest[3];
 
     decoded = 3;
     total_decoded = 0;
     copy = malloc(strlen(src) + 5);
     if (copy == NULL)
     {
         return -1;
     }
     strcpy(copy, src);
     strcat(copy, "====");
     p = copy;
     while (decoded == 3)
     {
         for (i = 0; i < 4; ++i)
         {
             while (*p != '=' && base64_char_value(*p) < 0)
             {
                 ++p;
             }
             temp_src[i] = *p++;
         }
         decoded = base64_decode_triple(temp_src, temp_dest);
         if ((size_t)decoded > dest_len)
         {
             free(copy);
             return -1;
         }
         memcpy(dest, temp_dest, decoded);
         dest          += decoded;
         dest_len      -= decoded;
         total_decoded += decoded;
     }
     free(copy);
     return total_decoded;
 }
 
 void encrypt(const unsigned char key[32], const char *src)
 {
     AES_KEY aes_key;
     unsigned char temp[1024], ivec[16];
     char buf[1024];
 
     memset(temp, 0, sizeof(temp));
     memset(temp, 0, sizeof(temp));  /* intended to zero `buf' here? */
     memset(ivec, 0, sizeof(ivec));
     AES_set_encrypt_key(key, 256, &aes_key);
     AES_cbc_encrypt((const unsigned char*)src, temp, strlen(src), &aes_key, ivec, 1);
     base64_encode(temp, (int)(ceil(strlen(src) / 16.0) * 16.0), buf, sizeof(buf));
     printf("encrypted: %s\n", buf);
 }
 
 void decrypt(const unsigned char key[32], const char *src)
 {
     AES_KEY aes_key;
     unsigned char temp[1024], ivec[16];
     char buf[1024];
 
     memset(temp, 0, sizeof(temp));
     memset(buf, 0, sizeof(buf));
     memset(ivec, 0, sizeof(ivec));
     base64_decode(src, temp, sizeof(temp));
     AES_set_decrypt_key(key, 256, &aes_key);
     AES_cbc_encrypt(temp, (unsigned char*)buf, sizeof(buf), &aes_key, ivec, 0);
     printf("decrypted: %s\n", buf);
 }
 
 void menu(const unsigned char key[32])
 {
     char ch, tmp, buf[256];
 
     do {
         puts("\n1. encrypt");
         puts("2. decrypt");
         puts("0. quit\n");
         fwrite("menu: ", 1, 6, stdout);
         fflush(stdout);
         tmp = ch = getchar();
         while (tmp != '\n' && tmp != EOF)
         {
             tmp = getchar();
         }
         if (ch == '1'|| ch == '2')
         {
             memset(buf, 0, sizeof(buf));
             fwrite("\nmsg: ", 1, 6, stdout);
             fflush(stdout);
             fgets(buf, sizeof(buf), stdin);
             if (ch == '1')
             {
                 encrypt(key, buf);
             }
             else
             if (ch == '2')
             {
                 decrypt(key, buf);
             }
         }
     } while (ch != '0');
 }
 
 int fill_buffer_with_random_data(char *buf, int len)
 {
     int i;
 
     for (i = 0; i < len; ++i)
     {
         buf[i] = rand()%90 + 33;
     }
     return i;
 }
 
 void crypto()
 {
     static char *salt = "Ohroowie2eisieQuojiaBoop1chi0wu";
     char *p, pass[128], user[64], prefix[16];
     unsigned char key[32];
 
     fill_buffer_with_random_data(pass, 128);
     fill_buffer_with_random_data(user, 64);
     base64_encode("q1ePg3J1", 8, prefix, 16);  /* "cTFlUGczSjE=" */
     p = getpass("password: ");
     memcpy(user, p, strlen(p));
     memcpy(pass, prefix, strlen(prefix));
     memcpy(pass + strlen(prefix), user, strlen(p));
     PKCS5_PBKDF2_HMAC_SHA1(pass, strlen(prefix) + strlen(p), salt, strlen(salt), 1000, 32, key);
     fill_buffer_with_random_data(p, 4);         /* (intentional) bug? */
     fill_buffer_with_random_data(pass, 128);
     menu(key);
 }
 
 int main()
 {
     srandom(time(NULL));
     crypto();
     return 0;
 }