zip_crypto_openssl.c File Reference

#include <stdlib.h>
#include "zipint.h"
#include "zip_crypto.h"
#include <limits.h>
#include <openssl/rand.h>

Go to the source code of this file.

Macros
#define	USE_OPENSSL_1_0_API

Functions
_zip_crypto_aes_t *	_zip_crypto_aes_new (const zip_uint8_t *key, zip_uint16_t key_size, zip_error_t *error)
void	_zip_crypto_aes_free (_zip_crypto_aes_t *aes)
bool	_zip_crypto_aes_encrypt_block (_zip_crypto_aes_t *aes, const zip_uint8_t *in, zip_uint8_t *out)
_zip_crypto_hmac_t *	_zip_crypto_hmac_new (const zip_uint8_t *secret, zip_uint64_t secret_length, zip_error_t *error)
void	_zip_crypto_hmac_free (_zip_crypto_hmac_t *hmac)
bool	_zip_crypto_hmac_output (_zip_crypto_hmac_t *hmac, zip_uint8_t *data)
ZIP_EXTERN bool	zip_secure_random (zip_uint8_t *buffer, zip_uint16_t length)

Macro Definition Documentation

USE_OPENSSL_1_0_API

#define USE_OPENSSL_1_0_API

Definition at line 44 of file zip_crypto_openssl.c.

Function Documentation

_zip_crypto_aes_encrypt_block()

bool _zip_crypto_aes_encrypt_block	(	_zip_crypto_aes_t *	aes,
		const zip_uint8_t *	in,
		zip_uint8_t *	out
	)

Definition at line 111 of file zip_crypto_openssl.c.

                                                                                               {
    int len;
    if (EVP_EncryptUpdate(aes, out, &len, in, ZIP_CRYPTO_AES_BLOCK_LENGTH) != 1) {
        return false;
    }
    return true;
}

References in, len, out, and ZIP_CRYPTO_AES_BLOCK_LENGTH.

_zip_crypto_aes_free()

void _zip_crypto_aes_free

(

_zip_crypto_aes_t *

aes

)

Definition at line 95 of file zip_crypto_openssl.c.

                                             {
    if (aes == NULL) {
        return;
    }
 
#ifdef USE_OPENSSL_1_0_API
    EVP_CIPHER_CTX_cleanup(aes);
    _zip_crypto_clear(aes, sizeof(*aes));
    free(aes);
#else
    EVP_CIPHER_CTX_free(aes);
#endif
}

References _zip_crypto_clear, free(), and NULL.

_zip_crypto_aes_new()

_zip_crypto_aes_t* _zip_crypto_aes_new	(	const zip_uint8_t *	key,
		zip_uint16_t	key_size,
		zip_error_t *	error
	)

Definition at line 49 of file zip_crypto_openssl.c.

                                                                                       {
    _zip_crypto_aes_t *aes;
    const EVP_CIPHER* cipher_type;
 
    switch (key_size) {
    case 128:
        cipher_type = EVP_aes_128_ecb();
        break;
    case 192:
        cipher_type = EVP_aes_192_ecb();
        break;
    case 256:
        cipher_type = EVP_aes_256_ecb();
        break;
    default:
        zip_error_set(error, ZIP_ER_INTERNAL, 0);
        return NULL;
    }
 
#ifdef USE_OPENSSL_1_0_API
    if ((aes = (_zip_crypto_aes_t *)malloc(sizeof(*aes))) == NULL) {
        zip_error_set(error, ZIP_ER_MEMORY, 0);
        return NULL;
    }
    memset(aes, 0, sizeof(*aes));
#else
    if ((aes = EVP_CIPHER_CTX_new()) == NULL) {
        zip_error_set(error, ZIP_ER_MEMORY, 0);
        return NULL;
    }
#endif
 
    if (EVP_EncryptInit_ex(aes, cipher_type, NULL, key, NULL) != 1) {
#ifdef USE_OPENSSL_1_0_API
        free(aes);
#else
        EVP_CIPHER_CTX_free(aes);
#endif
        zip_error_set(error, ZIP_ER_INTERNAL, 0);
        return NULL;
    }
 
    return aes;
}

References error(), free(), key, malloc(), memset(), NULL, ZIP_ER_INTERNAL, ZIP_ER_MEMORY, and zip_error_set().

_zip_crypto_hmac_free()

void _zip_crypto_hmac_free

(

_zip_crypto_hmac_t *

hmac

)

Definition at line 158 of file zip_crypto_openssl.c.

                                                {
    if (hmac == NULL) {
        return;
    }
 
#ifdef USE_OPENSSL_1_0_API
    HMAC_CTX_cleanup(hmac);
    _zip_crypto_clear(hmac, sizeof(*hmac));
    free(hmac);
#else
    HMAC_CTX_free(hmac);
#endif
}

References _zip_crypto_clear, free(), and NULL.

_zip_crypto_hmac_new()

_zip_crypto_hmac_t* _zip_crypto_hmac_new	(	const zip_uint8_t *	secret,
		zip_uint64_t	secret_length,
		zip_error_t *	error
	)

Definition at line 121 of file zip_crypto_openssl.c.

                                                                                                {
    _zip_crypto_hmac_t *hmac;
 
    if (secret_length > INT_MAX) {
        zip_error_set(error, ZIP_ER_INVAL, 0);
        return NULL;
    }
 
#ifdef USE_OPENSSL_1_0_API
    if ((hmac = (_zip_crypto_hmac_t *)malloc(sizeof(*hmac))) == NULL) {
        zip_error_set(error, ZIP_ER_MEMORY, 0);
        return NULL;
    }
 
    HMAC_CTX_init(hmac);
#else
    if ((hmac = HMAC_CTX_new()) == NULL) {
        zip_error_set(error, ZIP_ER_MEMORY, 0);
        return NULL;
    }
#endif
 
    if (HMAC_Init_ex(hmac, secret, (int)secret_length, EVP_sha1(), NULL) != 1) {
        zip_error_set(error, ZIP_ER_INTERNAL, 0);
#ifdef USE_OPENSSL_1_0_API
        free(hmac);
#else
        HMAC_CTX_free(hmac);
#endif
        return NULL;
    }
 
    return hmac;
}

References error(), free(), INT_MAX, malloc(), NULL, ZIP_ER_INTERNAL, ZIP_ER_INVAL, ZIP_ER_MEMORY, and zip_error_set().

_zip_crypto_hmac_output()

bool _zip_crypto_hmac_output	(	_zip_crypto_hmac_t *	hmac,
		zip_uint8_t *	data
	)

Definition at line 174 of file zip_crypto_openssl.c.

                                                                     {
    unsigned int length;
 
    return HMAC_Final(hmac, data, &length) == 1;
}

References length.

zip_secure_random()

ZIP_EXTERN bool zip_secure_random	(	zip_uint8_t *	buffer,
		zip_uint16_t	length
	)

Definition at line 182 of file zip_crypto_openssl.c.

                                                            {
    return RAND_bytes(buffer, length) == 1;
}

References length.