crypto.c

#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)
{
    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;
}