zip_crypto_mbedtls.c File Reference

#include <stdlib.h>
#include "zipint.h"
#include "zip_crypto.h"
#include <mbedtls/ctr_drbg.h>
#include <mbedtls/entropy.h>
#include <mbedtls/pkcs5.h>
#include <limits.h>

Go to the source code of this file.

Classes
struct	zip_random_context_t

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)
_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_pbkdf2 (const zip_uint8_t *key, zip_uint64_t key_length, const zip_uint8_t *salt, zip_uint16_t salt_length, int iterations, zip_uint8_t *output, zip_uint64_t output_length)
ZIP_EXTERN bool	zip_secure_random (zip_uint8_t *buffer, zip_uint16_t length)

Function Documentation

_zip_crypto_aes_free()

void _zip_crypto_aes_free

(

_zip_crypto_aes_t *

aes

)

Definition at line 62 of file zip_crypto_mbedtls.c.

                                             {
    if (aes == NULL) {
        return;
    }
 
    mbedtls_aes_free(aes);
    free(aes);
}

References 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 47 of file zip_crypto_mbedtls.c.

                                                                                       {
    _zip_crypto_aes_t *aes;
 
    if ((aes = (_zip_crypto_aes_t *)malloc(sizeof(*aes))) == NULL) {
        zip_error_set(error, ZIP_ER_MEMORY, 0);
        return NULL;
    }
 
    mbedtls_aes_init(aes);
    mbedtls_aes_setkey_enc(aes, (const unsigned char *)key, (unsigned int)key_size);
 
    return aes;
}

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

_zip_crypto_hmac_free()

void _zip_crypto_hmac_free

(

_zip_crypto_hmac_t *

hmac

)

Definition at line 105 of file zip_crypto_mbedtls.c.

                                                {
    if (hmac == NULL) {
        return;
    }
 
    mbedtls_md_free(hmac);
    free(hmac);
}

References 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 73 of file zip_crypto_mbedtls.c.

                                                                                                {
    _zip_crypto_hmac_t *hmac;
 
    if (secret_length > INT_MAX) {
        zip_error_set(error, ZIP_ER_INVAL, 0);
        return NULL;
    }
 
    if ((hmac = (_zip_crypto_hmac_t *)malloc(sizeof(*hmac))) == NULL) {
        zip_error_set(error, ZIP_ER_MEMORY, 0);
        return NULL;
    }
 
    mbedtls_md_init(hmac);
 
    if (mbedtls_md_setup(hmac, mbedtls_md_info_from_type(MBEDTLS_MD_SHA1), 1) != 0) {
        zip_error_set(error, ZIP_ER_INTERNAL, 0);
        free(hmac);
        return NULL;
    }
 
    if (mbedtls_md_hmac_starts(hmac, (const unsigned char *)secret, (size_t)secret_length) != 0) {
        zip_error_set(error, ZIP_ER_INTERNAL, 0);
        free(hmac);
        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_pbkdf2()

bool _zip_crypto_pbkdf2	(	const zip_uint8_t *	key,
		zip_uint64_t	key_length,
		const zip_uint8_t *	salt,
		zip_uint16_t	salt_length,
		int	iterations,
		zip_uint8_t *	output,
		zip_uint64_t	output_length
	)

Definition at line 116 of file zip_crypto_mbedtls.c.

                                                                                                                                                                                        {
    mbedtls_md_context_t sha1_ctx;
    bool ok = true;
 
    mbedtls_md_init(&sha1_ctx);
 
    if (mbedtls_md_setup(&sha1_ctx, mbedtls_md_info_from_type(MBEDTLS_MD_SHA1), 1) != 0) {
        ok = false;
    }
 
    if (ok && mbedtls_pkcs5_pbkdf2_hmac(&sha1_ctx, (const unsigned char *)key, (size_t)key_length, (const unsigned char *)salt, (size_t)salt_length, (unsigned int)iterations, (uint32_t)output_length, (unsigned char *)output) != 0) {
        ok = false;
    }
 
    mbedtls_md_free(&sha1_ctx);
    return ok;
}

References key, ok, and output.

zip_secure_random()

ZIP_EXTERN bool zip_secure_random	(	zip_uint8_t *	buffer,
		zip_uint16_t	length
	)

Definition at line 141 of file zip_crypto_mbedtls.c.

                                                            {
    static zip_random_context_t *ctx = NULL;
    const unsigned char *pers = "zip_crypto_mbedtls";
 
    if (!ctx) {
        ctx = (zip_random_context_t *)malloc(sizeof(zip_random_context_t));
        if (!ctx) {
            return false;
        }
        mbedtls_entropy_init(&ctx->entropy);
        mbedtls_ctr_drbg_init(&ctx->ctr_drbg);
        if (mbedtls_ctr_drbg_seed(&ctx->ctr_drbg, mbedtls_entropy_func, &ctx->entropy, pers, strlen(pers)) != 0) {
            mbedtls_ctr_drbg_free(&ctx->ctr_drbg);
            mbedtls_entropy_free(&ctx->entropy);
            free(ctx);
            ctx = NULL;
            return false;
        }
    }
 
    return mbedtls_ctr_drbg_random(&ctx->ctr_drbg, (unsigned char *)buffer, (size_t)length) == 0;
}

References free(), length, malloc(), and NULL.