zip_crypto_win.c File Reference

#include <stdlib.h>
#include <limits.h>
#include "zipint.h"
#include "zip_crypto.h"
#include <windows.h>
#include <bcrypt.h>

Go to the source code of this file.

Classes
struct	_zip_crypto_aes_s
struct	_zip_crypto_hmac_s

Macros
#define	WIN32_LEAN_AND_MEAN
#define	NOCRYPT
#define	HAS_BCRYPTDERIVEKEYPBKDF2

Functions
bool	_zip_crypto_pbkdf2 (const zip_uint8_t *key, zip_uint64_t key_length, const zip_uint8_t *salt, zip_uint16_t salt_length, zip_uint16_t iterations, zip_uint8_t *output, zip_uint16_t output_length)
_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 (_zip_crypto_hmac_t *hmac, zip_uint8_t *data, zip_uint64_t length)
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

HAS_BCRYPTDERIVEKEYPBKDF2

#define HAS_BCRYPTDERIVEKEYPBKDF2

Definition at line 85 of file zip_crypto_win.c.

NOCRYPT

#define NOCRYPT

Definition at line 41 of file zip_crypto_win.c.

WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

Definition at line 40 of file zip_crypto_win.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 373 of file zip_crypto_win.c.

                                                                                               {
    ULONG cbResult;
    NTSTATUS status = BCryptEncrypt(aes->hKey, (PUCHAR)in, ZIP_CRYPTO_AES_BLOCK_LENGTH, NULL, NULL, 0, (PUCHAR)out, ZIP_CRYPTO_AES_BLOCK_LENGTH, &cbResult, 0);
    return BCRYPT_SUCCESS(status);
}

References in, NULL, out, status, ULONG, and ZIP_CRYPTO_AES_BLOCK_LENGTH.

_zip_crypto_aes_free()

void _zip_crypto_aes_free

(

_zip_crypto_aes_t *

aes

)

Definition at line 352 of file zip_crypto_win.c.

                                             {
    if (aes == NULL) {
        return;
    }
 
    if (aes->hKey != NULL) {
        BCryptDestroyKey(aes->hKey);
    }
 
    if (aes->pbKeyObject != NULL) {
        free(aes->pbKeyObject);
    }
 
    if (aes->hAlgorithm != NULL) {
        BCryptCloseAlgorithmProvider(aes->hAlgorithm, 0);
    }
 
    free(aes);
}

References free(), and NULL.

Referenced by _zip_crypto_aes_new().

_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 310 of file zip_crypto_win.c.

                                                                                       {
    _zip_crypto_aes_t *aes = (_zip_crypto_aes_t *)calloc(1, sizeof(*aes));
 
    ULONG cbResult;
    ULONG key_length = key_size / 8;
 
    if (aes == NULL) {
        zip_error_set(error, ZIP_ER_MEMORY, 0);
        return NULL;
    }
 
    if (!BCRYPT_SUCCESS(BCryptOpenAlgorithmProvider(&aes->hAlgorithm, BCRYPT_AES_ALGORITHM, NULL, 0))) {
        _zip_crypto_aes_free(aes);
        return NULL;
    }
 
    if (!BCRYPT_SUCCESS(BCryptSetProperty(aes->hAlgorithm, BCRYPT_CHAINING_MODE, (PUCHAR)BCRYPT_CHAIN_MODE_ECB, sizeof(BCRYPT_CHAIN_MODE_ECB), 0))) {
        _zip_crypto_aes_free(aes);
        return NULL;
    }
 
    if (!BCRYPT_SUCCESS(BCryptGetProperty(aes->hAlgorithm, BCRYPT_OBJECT_LENGTH, (PUCHAR)&aes->cbKeyObject, sizeof(aes->cbKeyObject), &cbResult, 0))) {
        _zip_crypto_aes_free(aes);
        return NULL;
    }
 
    aes->pbKeyObject = malloc(aes->cbKeyObject);
    if (aes->pbKeyObject == NULL) {
        _zip_crypto_aes_free(aes);
        zip_error_set(error, ZIP_ER_MEMORY, 0);
        return NULL;
    }
 
    if (!BCRYPT_SUCCESS(BCryptGenerateSymmetricKey(aes->hAlgorithm, &aes->hKey, aes->pbKeyObject, aes->cbKeyObject, (PUCHAR)key, key_length, 0))) {
        _zip_crypto_aes_free(aes);
        return NULL;
    }
 
    return aes;
}

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

_zip_crypto_hmac()

bool _zip_crypto_hmac	(	_zip_crypto_hmac_t *	hmac,
		zip_uint8_t *	data,
		zip_uint64_t	length
	)

Definition at line 475 of file zip_crypto_win.c.

                                                                                   {
    if (hmac == NULL || length > ULONG_MAX) {
        return false;
    }
 
    return BCRYPT_SUCCESS(BCryptHashData(hmac->hHash, data, (ULONG)length, 0));
}

References _zip_crypto_hmac_s::hHash, length, NULL, and ULONG.

_zip_crypto_hmac_free()

void _zip_crypto_hmac_free

(

_zip_crypto_hmac_t *

hmac

)

Definition at line 450 of file zip_crypto_win.c.

                                                {
    if (hmac == NULL) {
        return;
    }
 
    if (hmac->hHash != NULL) {
        BCryptDestroyHash(hmac->hHash);
    }
 
    if (hmac->pbHash != NULL) {
        free(hmac->pbHash);
    }
 
    if (hmac->pbHashObject != NULL) {
        free(hmac->pbHashObject);
    }
 
    if (hmac->hAlgorithm) {
        BCryptCloseAlgorithmProvider(hmac->hAlgorithm, 0);
    }
 
    free(hmac);
}

References free(), _zip_crypto_hmac_s::hAlgorithm, _zip_crypto_hmac_s::hHash, NULL, _zip_crypto_hmac_s::pbHash, and _zip_crypto_hmac_s::pbHashObject.

Referenced by _zip_crypto_hmac_new().

_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 391 of file zip_crypto_win.c.

                                                                                                {
    NTSTATUS status;
    ULONG cbResult;
    _zip_crypto_hmac_t *hmac;
 
    if (secret_length > INT_MAX) {
        zip_error_set(error, ZIP_ER_INVAL, 0);
        return NULL;
    }
 
    hmac = (_zip_crypto_hmac_t *)calloc(1, sizeof(*hmac));
 
    if (hmac == NULL) {
        zip_error_set(error, ZIP_ER_MEMORY, 0);
        return NULL;
    }
 
    status = BCryptOpenAlgorithmProvider(&hmac->hAlgorithm, BCRYPT_SHA1_ALGORITHM, NULL, BCRYPT_ALG_HANDLE_HMAC_FLAG);
    if (!BCRYPT_SUCCESS(status)) {
        _zip_crypto_hmac_free(hmac);
        return NULL;
    }
 
    status = BCryptGetProperty(hmac->hAlgorithm, BCRYPT_OBJECT_LENGTH, (PUCHAR)&hmac->cbHashObject, sizeof(hmac->cbHashObject), &cbResult, 0);
    if (!BCRYPT_SUCCESS(status)) {
        _zip_crypto_hmac_free(hmac);
        return NULL;
    }
 
    hmac->pbHashObject = malloc(hmac->cbHashObject);
    if (hmac->pbHashObject == NULL) {
        _zip_crypto_hmac_free(hmac);
        zip_error_set(error, ZIP_ER_MEMORY, 0);
        return NULL;
    }
 
    status = BCryptGetProperty(hmac->hAlgorithm, BCRYPT_HASH_LENGTH, (PUCHAR)&hmac->cbHash, sizeof(hmac->cbHash), &cbResult, 0);
    if (!BCRYPT_SUCCESS(status)) {
        _zip_crypto_hmac_free(hmac);
        return NULL;
    }
 
    hmac->pbHash = malloc(hmac->cbHash);
    if (hmac->pbHash == NULL) {
        _zip_crypto_hmac_free(hmac);
        zip_error_set(error, ZIP_ER_MEMORY, 0);
        return NULL;
    }
 
    status = BCryptCreateHash(hmac->hAlgorithm, &hmac->hHash, hmac->pbHashObject, hmac->cbHashObject, (PUCHAR)secret, (ULONG)secret_length, 0);
    if (!BCRYPT_SUCCESS(status)) {
        _zip_crypto_hmac_free(hmac);
        return NULL;
    }
 
    return hmac;
}

References _zip_crypto_hmac_free(), calloc(), _zip_crypto_hmac_s::cbHash, _zip_crypto_hmac_s::cbHashObject, error(), _zip_crypto_hmac_s::hAlgorithm, _zip_crypto_hmac_s::hHash, INT_MAX, malloc(), NULL, _zip_crypto_hmac_s::pbHash, _zip_crypto_hmac_s::pbHashObject, status, ULONG, 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 484 of file zip_crypto_win.c.

                                                                     {
    if (hmac == NULL) {
        return false;
    }
 
    return BCRYPT_SUCCESS(BCryptFinishHash(hmac->hHash, data, hmac->cbHash, 0));
}

References _zip_crypto_hmac_s::cbHash, _zip_crypto_hmac_s::hHash, and NULL.

_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,
		zip_uint16_t	iterations,
		zip_uint8_t *	output,
		zip_uint16_t	output_length
	)

Definition at line 91 of file zip_crypto_win.c.

                                                                                                                                                                                                 {
    BCRYPT_ALG_HANDLE hAlgorithm = NULL;
    bool result;
 
    if (!BCRYPT_SUCCESS(BCryptOpenAlgorithmProvider(&hAlgorithm, BCRYPT_SHA1_ALGORITHM, NULL, BCRYPT_ALG_HANDLE_HMAC_FLAG))) {
        return false;
    }
 
    result = BCRYPT_SUCCESS(BCryptDeriveKeyPBKDF2(hAlgorithm, (PUCHAR)key, (ULONG)key_length, (PUCHAR)salt, salt_length, iterations, output, output_length, 0));
 
    BCryptCloseAlgorithmProvider(hAlgorithm, 0);
 
    return result;
}

References key, NULL, output, and ULONG.

zip_secure_random()

ZIP_EXTERN bool zip_secure_random	(	zip_uint8_t *	buffer,
		zip_uint16_t	length
	)

Definition at line 493 of file zip_crypto_win.c.

                                                            {
    return BCRYPT_SUCCESS(BCryptGenRandom(NULL, buffer, length, BCRYPT_USE_SYSTEM_PREFERRED_RNG));
}

References length, and NULL.