openssl_encrypt.c File Reference

#include "crypto/openssl_encrypt.h"
#include <assert.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <openssl/aes.h>
#include <openssl/err.h>
#include <openssl/evp.h>
#include <openssl/rand.h>
#include "compat/strings.h"
#include "crypto/crc.h"
#include "crypto/md5.h"
#include "debug.h"
#include "lib_common.h"
#include "utils/color_out.h"
#include "utils/macros.h"

Include dependency graph for openssl_encrypt.c:

Go to the source code of this file.

Classes
struct	openssl_encrypt

Macros
#define	CHECK(action, errmsg)
#define	DEFAULT_CIPHER_MODE   MODE_AES128_GCM
#define	GCM_TAG_LEN   16
#define	MOD_NAME   "[encrypt] "

Functions
const void *	get_cipher (enum openssl_mode mode)
static enum openssl_mode	get_cipher_from_str (char *str)
static int	openssl_encrypt (struct openssl_encrypt *encryption, char *plaintext, int data_len, char *aad, int aad_len, char *ciphertext)
static void	openssl_encrypt_destroy (struct openssl_encrypt *s)
static int	openssl_encrypt_init (struct openssl_encrypt **state, const char *passphrase)
static enum openssl_mode	openssl_get_cipher (struct openssl_encrypt *encryption)
static int	openssl_get_overhead (struct openssl_encrypt *s)
	REGISTER_MODULE (openssl_encrypt, &functions, LIBRARY_CLASS_UNDEFINED, OPENSSL_ENCRYPT_ABI_VERSION)
static void	usage (void)

Variables
struct {
const EVP_CIPHER *(*   get_cipher )(void)
enum openssl_mode   mode
const char *   name
}	ciphers []
static const struct openssl_encrypt_info	functions

Detailed Description

Encryption is done on per-packet basis, for every packet, new IV is generated, which is send on the beginning, then length of data (uint32_t), and actual encrypted data with:

1. 32-bit CRC (encryptied) for non-GCM
2. GCM tag after encrypted data

Encryption algorithm is set in transmit.cpp, detected on receiver. Required algorightms are currently GCM (default) and CBC.

Definition in file openssl_encrypt.c.

Macro Definition Documentation

CHECK

#define CHECK	(		action,
			errmsg )

Value:

do { int rc = action; if (rc != 1) { log_msg(LOG_LEVEL_ERROR, MOD_NAME errmsg ": %s\n", ERR_error_string(ERR_get_error(), NULL)); return 0; } } while(0)

Definition at line 198 of file openssl_encrypt.c.

Referenced by openssl_encrypt().

DEFAULT_CIPHER_MODE

#define DEFAULT_CIPHER_MODE   MODE_AES128_GCM

Definition at line 84 of file openssl_encrypt.c.

Referenced by openssl_encrypt_init().

GCM_TAG_LEN

#define GCM_TAG_LEN   16

Definition at line 85 of file openssl_encrypt.c.

Referenced by openssl_encrypt(), and openssl_get_overhead().

MOD_NAME

#define MOD_NAME   "[encrypt] "

Definition at line 86 of file openssl_encrypt.c.

Referenced by openssl_encrypt(), and openssl_encrypt_init().

Function Documentation

get_cipher()

const void * get_cipher

(

enum openssl_mode

mode

)

Definition at line 114 of file openssl_encrypt.c.

                                               {
        for (unsigned i = 0; i < sizeof ciphers / sizeof ciphers[0]; ++i) {
                if (ciphers[i].mode == mode) {
                        return ciphers[i].get_cipher();
                }
        }
        return NULL;
}

References ciphers, and mode.

get_cipher_from_str()

static enum openssl_mode get_cipher_from_str ( char * str )

static

Definition at line 135 of file openssl_encrypt.c.

{
        char *tok = strstr(str, ":cipher=");
        assert(tok != NULL);
        char *cipher = strchr(tok, '=') + 1;
        *tok = '\0';
        for (unsigned i = 0; i < sizeof ciphers / sizeof ciphers[0]; ++i) {
                if (strcasecmp(ciphers[i].name, cipher) == 0) {
                        return ciphers[i].mode;
                }
        }
        MSG(ERROR, "Unknown/unsuppoted/not compiled cipher %s!\n", cipher);
        return MODE_AES128_NONE;
}

References ciphers, MODE_AES128_NONE, MSG, and name.

Referenced by openssl_encrypt_init().

openssl_encrypt()

static int openssl_encrypt ( struct openssl_encrypt * encryption, char * plaintext, int data_len, char * aad, int aad_len, char * ciphertext )

static

Definition at line 200 of file openssl_encrypt.c.

{
        memcpy(ciphertext, &data_len, sizeof(uint32_t));
        int total_len = sizeof(uint32_t);
 
        unsigned char ivec[16];
        if (RAND_bytes(ivec, 8) < 0) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Cannot generate random bytes!\n");
                return 0;
        }
        memcpy(ciphertext + total_len, ivec, sizeof ivec);
        total_len += sizeof ivec;
 
        CHECK(EVP_CipherInit(encryption->ctx, encryption->cipher, encryption->key_hash, ivec, 1), "Cannot initialize cipher");
        /* Set IV length if default 12 bytes (96 bits) is not appropriate */
        CHECK(EVP_CIPHER_CTX_ctrl(encryption->ctx, EVP_CTRL_GCM_SET_IVLEN, sizeof ivec, NULL), "set IV len");
        int out_len = 0;
        if (encryption->mode == MODE_AES128_GCM) {
                if (aad_len > 0) {
                        EVP_EncryptUpdate(encryption->ctx, NULL, &out_len, (unsigned char *) aad, aad_len);
                }
        }
        CHECK(EVP_CipherUpdate(encryption->ctx, (unsigned char *) ciphertext + total_len, &out_len, (unsigned char *) plaintext, data_len), "EVP_CipherUpdate");
        total_len += out_len;
        if (encryption->mode != MODE_AES128_GCM) {
                uint32_t crc = crc32buf(aad, aad_len);
                crc = crc32buf_with_oldcrc(plaintext, data_len, crc);
                CHECK(EVP_CipherUpdate(encryption->ctx, (unsigned char *) ciphertext + total_len, &out_len, (unsigned char *) &crc, sizeof crc), "EVP_CipherUpdate CRC");
                total_len += out_len;
        }
        CHECK(EVP_CipherFinal(encryption->ctx, (unsigned char *) ciphertext + total_len, &out_len), "EVP_CipherFinal");
        total_len += out_len;
        if (encryption->mode == MODE_AES128_GCM) {
                CHECK(EVP_CIPHER_CTX_ctrl(encryption->ctx, EVP_CTRL_GCM_GET_TAG, GCM_TAG_LEN, ciphertext + total_len), "GCM get tag");
                total_len += GCM_TAG_LEN;
        }
 
        return total_len;
}

References CHECK, openssl_encrypt::cipher, crc32buf(), crc32buf_with_oldcrc(), openssl_encrypt::ctx, GCM_TAG_LEN, openssl_encrypt::key_hash, LOG_LEVEL_ERROR, log_msg(), MOD_NAME, openssl_encrypt::mode, and MODE_AES128_GCM.

Here is the call graph for this function:

openssl_encrypt_destroy()

static void openssl_encrypt_destroy ( struct openssl_encrypt * s )

static

Definition at line 192 of file openssl_encrypt.c.

{
        EVP_CIPHER_CTX_free(s->ctx);
        free(s);
}

References openssl_encrypt::ctx.

openssl_encrypt_init()

static int openssl_encrypt_init ( struct openssl_encrypt ** state, const char * passphrase )

static

Definition at line 151 of file openssl_encrypt.c.

{
        enum openssl_mode mode = DEFAULT_CIPHER_MODE;
 
        struct openssl_encrypt *s = (struct openssl_encrypt *)
                calloc(1, sizeof(struct openssl_encrypt));
 
        if (strcmp(passphrase, "help") == 0) {
                usage();
                return 1;
        }
 
        char pass[STR_LEN];
        snprintf_ch(pass, "%s", passphrase);
 
        if (strstr(passphrase, ":cipher=")) {
                mode = get_cipher_from_str(pass);
        }
 
        MD5CTX context;
 
        MD5Init(&context);
        MD5Update(&context, (const unsigned char *) pass,
                        strlen(pass));
        MD5Final(s->key_hash, &context);
 
        s->cipher = get_cipher(mode);
        if (s->cipher == NULL) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Cipher %d not available!\n", (int) mode);
                free(s);
                return -1;
        }
 
        s->ctx = EVP_CIPHER_CTX_new();
        s->mode = mode;
        log_msg(LOG_LEVEL_INFO, MOD_NAME "Encryption set to mode %d\n", (int) mode);
 
        *state = s;
        return 0;
}

References openssl_encrypt::cipher, openssl_encrypt::ctx, DEFAULT_CIPHER_MODE, get_cipher, get_cipher_from_str(), openssl_encrypt::key_hash, LOG_LEVEL_ERROR, LOG_LEVEL_INFO, log_msg(), MD5Final(), MD5Init(), MD5Update(), MOD_NAME, mode, openssl_encrypt::mode, snprintf_ch, state, STR_LEN, and usage().

Here is the call graph for this function:

openssl_get_cipher()

static enum openssl_mode openssl_get_cipher ( struct openssl_encrypt * encryption )

static

Definition at line 249 of file openssl_encrypt.c.

{
        return encryption->mode;
}

References openssl_encrypt::mode.

openssl_get_overhead()

static int openssl_get_overhead ( struct openssl_encrypt * s )

static

Definition at line 241 of file openssl_encrypt.c.

{
        return sizeof(uint32_t) /* data_len */ +
                16 /* nonce + counter */ + (s->mode == MODE_AES128_GCM ? GCM_TAG_LEN : sizeof(uint32_t) /* crc */)
                + (s->mode == MODE_AES128_ECB ? 15 : 0 /* padding */);
}

References GCM_TAG_LEN, openssl_encrypt::mode, MODE_AES128_ECB, and MODE_AES128_GCM.

REGISTER_MODULE()

REGISTER_MODULE	(	openssl_encrypt	,
		&	functions,
		LIBRARY_CLASS_UNDEFINED	,
		OPENSSL_ENCRYPT_ABI_VERSION	)

usage()

static void usage ( void )

static

Definition at line 124 of file openssl_encrypt.c.

{
        color_printf("Usage:\n");
        color_printf("\t" TBOLD("-e <passphrase>[:cipher=<c>]") "\n");
        color_printf("\nAvailable ciphers:\n");
        for (unsigned i = 0; i < sizeof ciphers / sizeof ciphers[0]; ++i) {
                color_printf("\t- " TBOLD("%s") "\n", ciphers[i].name);
        }
}

References ciphers, color_printf(), name, and TBOLD.

Referenced by openssl_encrypt_init().

Here is the call graph for this function:

Variable Documentation

[struct]

const struct { ... } ciphers[]

Initial value:

= {
 
 
 
 
 
 
 
 
 
        { MODE_AES128_CBC, "cbc", EVP_aes_128_cbc    },
 
        { MODE_AES128_GCM, "gcm", EVP_aes_128_gcm    },
}

Referenced by get_cipher(), get_cipher_from_str(), and usage().

functions

const struct openssl_encrypt_info functions

static

Initial value:

= {
        openssl_encrypt_init,
        openssl_encrypt_destroy,
        openssl_encrypt,
        openssl_get_overhead,
        openssl_get_cipher,
}

Definition at line 254 of file openssl_encrypt.c.

                                                     {
        openssl_encrypt_init,
        openssl_encrypt_destroy,
        openssl_encrypt,
        openssl_get_overhead,
        openssl_get_cipher,
};

get_cipher

const EVP_CIPHER *(* get_cipher) (void)

(

void

)

Definition at line 98 of file openssl_encrypt.c.

Referenced by openssl_decrypt(), and openssl_encrypt_init().

mode

enum openssl_mode mode

Definition at line 96 of file openssl_encrypt.c.

Referenced by replica::replica(), cipherInit(), detect_format(), display_drm_reconfigure(), display_dvs_init(), display_gl_init_opengl(), display_gl_process_key(), get_cipher(), get_input_modes(), get_refresh_rate(), getVideoModes(), glfw_print_video_mode(), glfw_resize_window(), openssl_decrypt(), openssl_encrypt_init(), qfDES(), AvailableSettings::queryDevice(), resolve_addrinfo(), set_output_buffering(), setup_crtc(), show_help(), UpdateVideoMode(), usage(), vidcap_dvs_init(), and VideoDelegate::VideoInputFormatChanged().

name

const char* name

Definition at line 97 of file openssl_encrypt.c.

Referenced by get_cipher_from_str(), and usage().