OpenSSL Library - EVP, Digest and Cipher

// gcc -lcrypto -o evp_sn-nid evp_sn-nid.c
#include <stdio.h>
#include <openssl/evp.h>

// program <num or string>
int main(int argc, char *argv[]) {
    int nid = 0;
    const char *digest_method_name = NULL;

    if (argc < 2)
        return 1;

    if (argv[1][0] > '9') {
        digest_method_name = argv[1];
        nid = OBJ_sn2nid(digest_method_name);
    }
    else {
        nid = atoi(argv[1]);
        digest_method_name = OBJ_nid2sn(nid);
    }

    printf("Digest method name: %s\n", digest_method_name);
    printf("NID: %d\n", nid);

    return 0;
}

#include <stdio.h>
#include <openssl/bio.h>
#include <openssl/evp.h>

/**
ths size of dest should be >= EVP_MAX_MD_SIZE.
See also: http://www.openssl.org/docs/crypto/EVP_DigestInit.html
 */
unsigned char *stream_digest(
                    int nid,
                    BIO *bin,
                    unsigned char *dest,
                    int *dest_len)
{
    unsigned char buf[1024];
    int rc;

    *dest_len = 0;

    // select digest module.
    //const EVP_MD *md = EVP_get_digestbyname("SHA256"); // sn
    const EVP_MD *md = EVP_get_digestbynid(nid); // nid

    if (md == NULL)
        return NULL;

    EVP_MD_CTX ctx;

    EVP_MD_CTX_init(&ctx);
    EVP_DigestInit_ex(&ctx, md, NULL); // insert digest module.

    while ((rc = BIO_read(bin, buf, sizeof(buf))) > 0) {
        EVP_DigestUpdate(&ctx, buf, rc);
    }

    EVP_DigestFinal_ex(&ctx, dest, dest_len); // copy digest to dest.
    EVP_MD_CTX_cleanup(&ctx);

    return dest;
}

// gcc -lcrypto -o evp_digest evp_digest.c
// program <nid> [input_filepath]
int main(int argc, char *argv[]) {
    int nid = 0;
    BIO *bin;
    char dest[EVP_MAX_MD_SIZE];
    int dest_len, i;

    // nid: for example NID_md5 = 4, NID_sha256 = 672
    if (argc >= 2) {
        if (argv[1][0] > '9')
            nid = OBJ_sn2nid(argv[1]);
        else
            nid = atoi(argv[1]);
    }
    if (nid == 0) {
        puts("Unknown digest method.");
        return 1;
    }

    if (argc >= 3)
        bin = BIO_new_file(argv[2], "r");
    else
        bin = BIO_new_fp(stdin, BIO_NOCLOSE);
    if (bin == NULL) {
        puts("Failed to open input file.");
        return 1;
    }

    OpenSSL_add_all_digests(); // load all digest modules.

    stream_digest(nid, bin, dest, &dest_len);
    BIO_free_all(bin);

    printf("%d,", nid);
    for (i = 0; i < dest_len; ++i)
        printf("%02X", (unsigned char)dest[i]);
    puts("");

    return 0;
}

#include <stdio.h>
#include <string.h>
#include <openssl/bio.h>
#include <openssl/evp.h>

#define CIPHER_DECRYPT 0
#define CIPHER_ENCRYPT 1
/**
enc: "1 for encryption, 0 for decryption."
See also: http://www.openssl.org/docs/crypto/EVP_EncryptInit.html
 */
int stream_cipher(
        int nid,
        BIO *bin,
        unsigned char *key,
        int key_len,
        unsigned char *iv,
        int iv_len,
        int enc)
{
    unsigned char raw_buf[1024], *encrypt_buf = NULL;
    int total_len = 0, out_len = 0;
    int rc = 0;

    // select cipher module.
    //const EVP_CIPHER *cipher = EVP_get_cipherbybyname("BF-CBC"); // sn
    const EVP_CIPHER *cipher = EVP_get_cipherbynid(nid); // nid

    if (cipher == NULL)
        return 0;

    if (key_len < EVP_CIPHER_key_length(cipher) ||
        iv_len < EVP_CIPHER_iv_length(cipher))
    {
        return 0;
    }

    int cipher_block_size = EVP_CIPHER_block_size(cipher);
    encrypt_buf = (unsigned char*) malloc(cipher_block_size + sizeof(raw_buf));
    /* See http://www.openssl.org/docs/crypto/EVP_EncryptInit.html
      "the amount of data written may be anything from zero bytes
       to (inl + cipher_block_size - 1)"
    */

    EVP_CIPHER_CTX ctx;
    memset(&ctx, 0, sizeof(ctx));

    EVP_CIPHER_CTX_init(&ctx);
    EVP_CipherInit_ex(&ctx, cipher, NULL, key, iv, enc);
    // set cipher module, key, iv and enc.

    while ((rc = BIO_read(bin, raw_buf, sizeof(raw_buf))) > 0) {
        if (!EVP_CipherUpdate(&ctx, encrypt_buf, &out_len, raw_buf, rc)) {
            total_len = 0;
            goto end_func;
        }
        fwrite(encrypt_buf, out_len, 1, stdout);
        total_len += out_len;
    }


    unsigned char *block_ptr = encrypt_buf + out_len;
    if (!EVP_CipherFinal_ex(&ctx, block_ptr, &out_len)) {
        total_len = 0;
        goto end_func;
    }
    fwrite(block_ptr, out_len, 1, stdout);
    total_len += out_len;

  end_func:
    EVP_CIPHER_CTX_cleanup(&ctx);
    free(encrypt_buf);
    return total_len;
}

// gcc -lcrypto -o evp_cipher evp_cipher.c
// program <nid> <key> <iv> <encrypt|decrypt> [input_filepath]
int main(int argc, char *argv[]) {
    int nid = 0, enc = 0, rc;
    BIO *bin;
    unsigned char *key, *iv;

    if (argc < 5)
        return 1;

    if (argv[1][0] > '9')
        nid = OBJ_sn2nid(argv[1]);
    else
        nid = atoi(argv[1]);
    if (nid == 0) {
        puts("Unknown cipher method.");
        return 1;
    }

    key = argv[2];
    iv = argv[3];

    if (argv[4][0] == 'd' || argv[4][0] == 'D')
        enc = CIPHER_DECRYPT;
    else
        enc = CIPHER_ENCRYPT;

    if (argc >= 6)
        bin = BIO_new_file(argv[5], "r");
    else
        bin = BIO_new_fp(stdin, BIO_NOCLOSE);
    if (bin == NULL) {
        puts("Failed to open input file.");
        return 1;
    }

    OpenSSL_add_all_ciphers(); // load all cipher modules.
    //OpenSSL_add_all_algorithms(); // load all algorithms.

    rc = stream_cipher(nid, bin, key, strlen(key), iv, strlen(iv), enc);
    BIO_free_all(bin);
    if (rc > 0)
        return 0;
    return 1;
}