diff --git a/lib/mkstemp.c b/lib/mkstemp.c
index 01a531f..f18f10b 100644
--- a/lib/mkstemp.c
+++ b/lib/mkstemp.c
@@ -148,6 +148,6 @@
 	    }
 	}
     }
-	/*NOTREACHED*/
+    /*NOTREACHED*/
 #endif
 }
diff --git a/lib/zip_crypto_commoncrypto.c b/lib/zip_crypto_commoncrypto.c
index 79ce7f9..10f7700 100644
--- a/lib/zip_crypto_commoncrypto.c
+++ b/lib/zip_crypto_commoncrypto.c
@@ -41,10 +41,9 @@
 #include <unistd.h>
 
 void
-_zip_crypto_aes_free(_zip_crypto_aes_t *aes)
-{
+_zip_crypto_aes_free(_zip_crypto_aes_t *aes) {
     if (aes == NULL) {
-        return;
+	return;
     }
 
     CCCryptorRelease(aes);
@@ -52,8 +51,7 @@
 
 
 bool
-_zip_crypto_aes_encrypt_block(_zip_crypto_aes_t *aes, const zip_uint8_t *in, zip_uint8_t *out)
-{
+_zip_crypto_aes_encrypt_block(_zip_crypto_aes_t *aes, const zip_uint8_t *in, zip_uint8_t *out) {
     size_t len;
     CCCryptorUpdate(aes, in, ZIP_CRYPTO_AES_BLOCK_LENGTH, out, ZIP_CRYPTO_AES_BLOCK_LENGTH, &len);
     return true;
@@ -61,8 +59,7 @@
 
 
 _zip_crypto_aes_t *
-_zip_crypto_aes_new(const zip_uint8_t *key, zip_uint16_t key_size, zip_error_t *error)
-{
+_zip_crypto_aes_new(const zip_uint8_t *key, zip_uint16_t key_size, zip_error_t *error) {
     _zip_crypto_aes_t *aes;
     CCCryptorStatus ret;
 
@@ -70,28 +67,27 @@
 
     switch (ret) {
     case kCCSuccess:
-        return aes;
+	return aes;
 
     case kCCMemoryFailure:
-        zip_error_set(error, ZIP_ER_MEMORY, 0);
-        return NULL;
+	zip_error_set(error, ZIP_ER_MEMORY, 0);
+	return NULL;
 
     case kCCParamError:
-        zip_error_set(error, ZIP_ER_INVAL, 0);
-        return NULL;
+	zip_error_set(error, ZIP_ER_INVAL, 0);
+	return NULL;
 
     default:
-        zip_error_set(error, ZIP_ER_INTERNAL, 0);
-        return NULL;
+	zip_error_set(error, ZIP_ER_INTERNAL, 0);
+	return NULL;
     }
 }
 
 
 void
-_zip_crypto_hmac_free(_zip_crypto_hmac_t *hmac)
-{
+_zip_crypto_hmac_free(_zip_crypto_hmac_t *hmac) {
     if (hmac == NULL) {
-        return;
+	return;
     }
 
     _zip_crypto_clear(hmac, sizeof(*hmac));
@@ -100,13 +96,12 @@
 
 
 _zip_crypto_hmac_t *
-_zip_crypto_hmac_new(const zip_uint8_t *secret, zip_uint64_t secret_length, zip_error_t *error)
-{
+_zip_crypto_hmac_new(const zip_uint8_t *secret, zip_uint64_t secret_length, zip_error_t *error) {
     _zip_crypto_hmac_t *hmac;
 
     if ((hmac = (_zip_crypto_hmac_t *)malloc(sizeof(*hmac))) == NULL) {
-        zip_error_set(error, ZIP_ER_MEMORY, 0);
-        return NULL;
+	zip_error_set(error, ZIP_ER_MEMORY, 0);
+	return NULL;
     }
 
     CCHmacInit(hmac, kCCHmacAlgSHA1, secret, secret_length);
@@ -120,12 +115,12 @@
     int fd;
 
     if ((fd = open("/dev/urandom", O_RDONLY)) < 0) {
-        return false;
+	return false;
     }
 
     if (read(fd, buffer, length) != length) {
-        close(fd);
-        return false;
+	close(fd);
+	return false;
     }
 
     close(fd);
diff --git a/lib/zip_crypto_commoncrypto.h b/lib/zip_crypto_commoncrypto.h
index 778341e..1eae1b7 100644
--- a/lib/zip_crypto_commoncrypto.h
+++ b/lib/zip_crypto_commoncrypto.h
@@ -48,7 +48,6 @@
 _zip_crypto_hmac_t *_zip_crypto_hmac_new(const zip_uint8_t *secret, zip_uint64_t secret_length, zip_error_t *error);
 #define _zip_crypto_hmac_output(hmac, data) (CCHmacFinal((hmac), (data)), true)
 
-#define _zip_crypto_pbkdf2(key, key_length, salt, salt_length, iterations, output, output_length) \
-	(CCKeyDerivationPBKDF(kCCPBKDF2, (const char *)(key), (key_length), (salt), (salt_length), kCCPRFHmacAlgSHA1, (iterations), (output), (output_length)) == kCCSuccess)
+#define _zip_crypto_pbkdf2(key, key_length, salt, salt_length, iterations, output, output_length) (CCKeyDerivationPBKDF(kCCPBKDF2, (const char *)(key), (key_length), (salt), (salt_length), kCCPRFHmacAlgSHA1, (iterations), (output), (output_length)) == kCCSuccess)
 
 #endif /* HAD_ZIP_CRYPTO_COMMONCRYPTO_H */
diff --git a/lib/zip_crypto_gnutls.c b/lib/zip_crypto_gnutls.c
index f688eae..d08f2f9 100644
--- a/lib/zip_crypto_gnutls.c
+++ b/lib/zip_crypto_gnutls.c
@@ -33,63 +33,60 @@
 
 #include <stdlib.h>
 
-#include "zipint.h"
 #include "zip_crypto.h"
+#include "zipint.h"
 
 _zip_crypto_aes_t *
-_zip_crypto_aes_new(const zip_uint8_t *key, zip_uint16_t key_size, zip_error_t *error)
-{
+_zip_crypto_aes_new(const zip_uint8_t *key, zip_uint16_t key_size, zip_error_t *error) {
     _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;
+    if ((aes = (_zip_crypto_aes_t *)malloc(sizeof(*aes))) == NULL) {
+	zip_error_set(error, ZIP_ER_MEMORY, 0);
+	return NULL;
     }
 
     aes->key_size = key_size;
 
     switch (aes->key_size) {
     case 128:
-        nettle_aes128_set_encrypt_key(&aes->ctx.ctx_128, key);
-        break;
+	nettle_aes128_set_encrypt_key(&aes->ctx.ctx_128, key);
+	break;
     case 192:
-        nettle_aes192_set_encrypt_key(&aes->ctx.ctx_192, key);
-        break;
+	nettle_aes192_set_encrypt_key(&aes->ctx.ctx_192, key);
+	break;
     case 256:
-        nettle_aes256_set_encrypt_key(&aes->ctx.ctx_256, key);
-        break;
+	nettle_aes256_set_encrypt_key(&aes->ctx.ctx_256, key);
+	break;
     default:
-        zip_error_set(error, ZIP_ER_INVAL, 0);
-        free(aes);
-        return NULL;
+	zip_error_set(error, ZIP_ER_INVAL, 0);
+	free(aes);
+	return NULL;
     }
 
     return aes;
 }
 
 bool
-_zip_crypto_aes_encrypt_block(_zip_crypto_aes_t *aes, const zip_uint8_t *in, zip_uint8_t *out)
-{
+_zip_crypto_aes_encrypt_block(_zip_crypto_aes_t *aes, const zip_uint8_t *in, zip_uint8_t *out) {
     switch (aes->key_size) {
     case 128:
-        nettle_aes128_encrypt(&aes->ctx.ctx_128, ZIP_CRYPTO_AES_BLOCK_LENGTH, out, in);
-        break;
+	nettle_aes128_encrypt(&aes->ctx.ctx_128, ZIP_CRYPTO_AES_BLOCK_LENGTH, out, in);
+	break;
     case 192:
-        nettle_aes192_encrypt(&aes->ctx.ctx_192, ZIP_CRYPTO_AES_BLOCK_LENGTH, out, in);
-        break;
+	nettle_aes192_encrypt(&aes->ctx.ctx_192, ZIP_CRYPTO_AES_BLOCK_LENGTH, out, in);
+	break;
     case 256:
-        nettle_aes256_encrypt(&aes->ctx.ctx_256, ZIP_CRYPTO_AES_BLOCK_LENGTH, out, in);
-        break;
+	nettle_aes256_encrypt(&aes->ctx.ctx_256, ZIP_CRYPTO_AES_BLOCK_LENGTH, out, in);
+	break;
     }
 
     return true;
 }
 
 void
-_zip_crypto_aes_free(_zip_crypto_aes_t *aes)
-{
+_zip_crypto_aes_free(_zip_crypto_aes_t *aes) {
     if (aes == NULL) {
-        return;
+	return;
     }
 
     _zip_crypto_clear(aes, sizeof(*aes));
@@ -98,20 +95,19 @@
 
 
 _zip_crypto_hmac_t *
-_zip_crypto_hmac_new(const zip_uint8_t *secret, zip_uint64_t secret_length, zip_error_t *error)
-{
+_zip_crypto_hmac_new(const zip_uint8_t *secret, zip_uint64_t secret_length, zip_error_t *error) {
     _zip_crypto_hmac_t *hmac;
     int ret;
 
-    if ((hmac  = (_zip_crypto_hmac_t *)malloc(sizeof(*hmac))) == NULL) {
-        zip_error_set(error, ZIP_ER_MEMORY, 0);
-        return NULL;
+    if ((hmac = (_zip_crypto_hmac_t *)malloc(sizeof(*hmac))) == NULL) {
+	zip_error_set(error, ZIP_ER_MEMORY, 0);
+	return NULL;
     }
 
     if ((ret = gnutls_hmac_init(hmac, GNUTLS_MAC_SHA1, secret, secret_length)) < 0) {
-        // TODO: set error
-        free(hmac);
-        return NULL;
+	// TODO: set error
+	free(hmac);
+	return NULL;
     }
 
     return hmac;
@@ -119,12 +115,11 @@
 
 
 void
-_zip_crypto_hmac_free(_zip_crypto_hmac_t *hmac)
-{
+_zip_crypto_hmac_free(_zip_crypto_hmac_t *hmac) {
     zip_uint8_t buf[ZIP_CRYPTO_SHA1_LENGTH];
 
     if (hmac == NULL) {
-        return;
+	return;
     }
 
     gnutls_hmac_deinit(*hmac, buf);
@@ -137,4 +132,3 @@
 zip_random(zip_uint8_t *buffer, zip_uint16_t length) {
     return gnutls_rnd(GNUTLS_RND_KEY, buffer, length) == 0;
 }
-
diff --git a/lib/zip_crypto_gnutls.h b/lib/zip_crypto_gnutls.h
index c3d6a0e..40d34a5 100644
--- a/lib/zip_crypto_gnutls.h
+++ b/lib/zip_crypto_gnutls.h
@@ -37,17 +37,17 @@
 #include <nettle/aes.h>
 #include <nettle/pbkdf2.h>
 
-#include <gnutls/gnutls.h>
 #include <gnutls/crypto.h>
+#include <gnutls/gnutls.h>
 
 typedef struct {
     union {
-        struct aes128_ctx ctx_128;
-        struct aes192_ctx ctx_192;
-        struct aes256_ctx ctx_256;
+	struct aes128_ctx ctx_128;
+	struct aes192_ctx ctx_192;
+	struct aes256_ctx ctx_256;
     } ctx;
     zip_uint16_t key_size;
-}  _zip_crypto_aes_t;
+} _zip_crypto_aes_t;
 
 #define _zip_crypto_hmac_t gnutls_hmac_hd_t
 
@@ -55,12 +55,11 @@
 bool _zip_crypto_aes_encrypt_block(_zip_crypto_aes_t *aes, const zip_uint8_t *in, zip_uint8_t *out);
 _zip_crypto_aes_t *_zip_crypto_aes_new(const zip_uint8_t *key, zip_uint16_t key_size, zip_error_t *error);
 
-#define _zip_crypto_hmac(hmac, data, length)  (gnutls_hmac(*(hmac), (data), (length)) == 0)
+#define _zip_crypto_hmac(hmac, data, length) (gnutls_hmac(*(hmac), (data), (length)) == 0)
 void _zip_crypto_hmac_free(_zip_crypto_hmac_t *hmac);
 _zip_crypto_hmac_t *_zip_crypto_hmac_new(const zip_uint8_t *secret, zip_uint64_t secret_length, zip_error_t *error);
 #define _zip_crypto_hmac_output(hmac, data) (gnutls_hmac_output(*(hmac), (data)), true)
 
-#define _zip_crypto_pbkdf2(key, key_length, salt, salt_length, iterations, output, output_length) \
-	(pbkdf2_hmac_sha1((key_length), (key), (iterations), (salt_length), (salt), (output_length), (output)), true)
+#define _zip_crypto_pbkdf2(key, key_length, salt, salt_length, iterations, output, output_length) (pbkdf2_hmac_sha1((key_length), (key), (iterations), (salt_length), (salt), (output_length), (output)), true)
 
 #endif /*  HAD_ZIP_CRYPTO_GNUTLS_H */
diff --git a/lib/zip_crypto_openssl.c b/lib/zip_crypto_openssl.c
index db32d55..1d256cd 100644
--- a/lib/zip_crypto_openssl.c
+++ b/lib/zip_crypto_openssl.c
@@ -33,8 +33,8 @@
 
 #include <stdlib.h>
 
-#include "zipint.h"
 #include "zip_crypto.h"
+#include "zipint.h"
 
 #include <openssl/rand.h>
 
@@ -44,13 +44,12 @@
 
 
 _zip_crypto_aes_t *
-_zip_crypto_aes_new(const zip_uint8_t *key, zip_uint16_t key_size, zip_error_t *error)
-{
+_zip_crypto_aes_new(const zip_uint8_t *key, zip_uint16_t key_size, zip_error_t *error) {
     _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;
+    if ((aes = (_zip_crypto_aes_t *)malloc(sizeof(*aes))) == NULL) {
+	zip_error_set(error, ZIP_ER_MEMORY, 0);
+	return NULL;
     }
 
     AES_set_encrypt_key(key, key_size, aes);
@@ -59,10 +58,9 @@
 }
 
 void
-_zip_crypto_aes_free(_zip_crypto_aes_t *aes)
-{
+_zip_crypto_aes_free(_zip_crypto_aes_t *aes) {
     if (aes == NULL) {
-        return;
+	return;
     }
 
     _zip_crypto_clear(aes, sizeof(*aes));
@@ -71,37 +69,36 @@
 
 
 _zip_crypto_hmac_t *
-_zip_crypto_hmac_new(const zip_uint8_t *secret, zip_uint64_t secret_length, zip_error_t *error)
-{
+_zip_crypto_hmac_new(const zip_uint8_t *secret, zip_uint64_t secret_length, zip_error_t *error) {
     _zip_crypto_hmac_t *hmac;
 
     if (secret_length > INT_MAX) {
-        zip_error_set(error, ZIP_ER_INVAL, 0);
-        return NULL;
+	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;
+    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;
+	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);
+	zip_error_set(error, ZIP_ER_INTERNAL, 0);
 #ifdef USE_OPENSSL_1_0_API
-        free(hmac);
+	free(hmac);
 #else
-        HMAC_CTX_free(hmac);
+	HMAC_CTX_free(hmac);
 #endif
-        return NULL;
+	return NULL;
     }
 
     return hmac;
@@ -109,10 +106,9 @@
 
 
 void
-_zip_crypto_hmac_free(_zip_crypto_hmac_t *hmac)
-{
+_zip_crypto_hmac_free(_zip_crypto_hmac_t *hmac) {
     if (hmac == NULL) {
-        return;
+	return;
     }
 
 #ifdef USE_OPENSSL_1_0_API
@@ -126,8 +122,7 @@
 
 
 bool
-_zip_crypto_hmac_output(_zip_crypto_hmac_t *hmac, zip_uint8_t *data)
-{
+_zip_crypto_hmac_output(_zip_crypto_hmac_t *hmac, zip_uint8_t *data) {
     unsigned int length;
 
     return HMAC_Final(hmac, data, &length) == 1;
@@ -138,5 +133,3 @@
 zip_random(zip_uint8_t *buffer, zip_uint16_t length) {
     return RAND_bytes(buffer, length) == 1;
 }
-
-
diff --git a/lib/zip_crypto_openssl.h b/lib/zip_crypto_openssl.h
index 937635c..906890e 100644
--- a/lib/zip_crypto_openssl.h
+++ b/lib/zip_crypto_openssl.h
@@ -41,7 +41,7 @@
 #define _zip_crypto_hmac_t HMAC_CTX
 
 void _zip_crypto_aes_free(_zip_crypto_aes_t *aes);
-#define _zip_crypto_aes_encrypt_block(aes, in, out)  (AES_encrypt((in), (out), (aes)), true)
+#define _zip_crypto_aes_encrypt_block(aes, in, out) (AES_encrypt((in), (out), (aes)), true)
 _zip_crypto_aes_t *_zip_crypto_aes_new(const zip_uint8_t *key, zip_uint16_t key_size, zip_error_t *error);
 
 #define _zip_crypto_hmac(hmac, data, length) (HMAC_Update((hmac), (data), (length)) == 1)
@@ -49,7 +49,6 @@
 _zip_crypto_hmac_t *_zip_crypto_hmac_new(const zip_uint8_t *secret, zip_uint64_t secret_length, zip_error_t *error);
 bool _zip_crypto_hmac_output(_zip_crypto_hmac_t *hmac, zip_uint8_t *data);
 
-#define _zip_crypto_pbkdf2(key, key_length, salt, salt_length, iterations, output, output_length) \
-	(PKCS5_PBKDF2_HMAC_SHA1((const char *)(key), (key_length), (salt), (salt_length), (iterations), (output_length), (output)))
+#define _zip_crypto_pbkdf2(key, key_length, salt, salt_length, iterations, output, output_length) (PKCS5_PBKDF2_HMAC_SHA1((const char *)(key), (key_length), (salt), (salt_length), (iterations), (output_length), (output)))
 
 #endif /*  HAD_ZIP_CRYPTO_OPENSSL_H */
diff --git a/lib/zip_crypto_win.c b/lib/zip_crypto_win.c
index 7e50ea4..4d428e2 100644
--- a/lib/zip_crypto_win.c
+++ b/lib/zip_crypto_win.c
@@ -32,8 +32,8 @@
 */
 #include <stdlib.h>
 
-#include "zipint.h"
 #include "zip_crypto.h"
+#include "zipint.h"
 
 #define WIN32_LEAN_AND_MEAN
 #define NOCRYPT
@@ -84,20 +84,19 @@
 
 #ifdef HAS_BCRYPTDERIVEKEYPBKDF2
 
-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)
-{
-	BCRYPT_ALG_HANDLE hAlgorithm = NULL;
+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) {
+    BCRYPT_ALG_HANDLE hAlgorithm = NULL;
 
-	if (!BCRYPT_SUCCESS(BCryptOpenAlgorithmProvider(&hAlgorithm, BCRYPT_SHA1_ALGORITHM, NULL, BCRYPT_ALG_HANDLE_HMAC_FLAG)))
-	{
-		return false;
-	}
+    if (!BCRYPT_SUCCESS(BCryptOpenAlgorithmProvider(&hAlgorithm, BCRYPT_SHA1_ALGORITHM, NULL, BCRYPT_ALG_HANDLE_HMAC_FLAG))) {
+	return false;
+    }
 
-	bool result = BCRYPT_SUCCESS(BCryptDeriveKeyPBKDF2(hAlgorithm, (PUCHAR)key, (ULONG)key_length, (PUCHAR)salt, salt_length, iterations, output, output_length, 0));
+    bool result = BCRYPT_SUCCESS(BCryptDeriveKeyPBKDF2(hAlgorithm, (PUCHAR)key, (ULONG)key_length, (PUCHAR)salt, salt_length, iterations, output, output_length, 0));
 
-	BCryptCloseAlgorithmProvider(hAlgorithm, 0);
+    BCryptCloseAlgorithmProvider(hAlgorithm, 0);
 
-	return result;
+    return result;
 }
 
 #else
@@ -107,421 +106,359 @@
 #define DIGEST_SIZE 20
 #define BLOCK_SIZE 64
 
-typedef struct
-{
-	BCRYPT_ALG_HANDLE hAlgorithm;
-	BCRYPT_HASH_HANDLE hInnerHash;
-	BCRYPT_HASH_HANDLE hOuterHash;
-	ULONG cbHashObject;
-	PUCHAR pbInnerHash;
-	PUCHAR pbOuterHash;
+typedef struct {
+    BCRYPT_ALG_HANDLE hAlgorithm;
+    BCRYPT_HASH_HANDLE hInnerHash;
+    BCRYPT_HASH_HANDLE hOuterHash;
+    ULONG cbHashObject;
+    PUCHAR pbInnerHash;
+    PUCHAR pbOuterHash;
 } PRF_CTX;
 
-static void hmacFree(PRF_CTX* pContext)
-{
-	if (pContext->hOuterHash) BCryptDestroyHash(pContext->hOuterHash);
-	if (pContext->hInnerHash) BCryptDestroyHash(pContext->hInnerHash);
-	free(pContext->pbOuterHash);
-	free(pContext->pbInnerHash);
-	if (pContext->hAlgorithm) BCryptCloseAlgorithmProvider(pContext->hAlgorithm, 0);
+static void
+hmacFree(PRF_CTX *pContext) {
+    if (pContext->hOuterHash)
+	BCryptDestroyHash(pContext->hOuterHash);
+    if (pContext->hInnerHash)
+	BCryptDestroyHash(pContext->hInnerHash);
+    free(pContext->pbOuterHash);
+    free(pContext->pbInnerHash);
+    if (pContext->hAlgorithm)
+	BCryptCloseAlgorithmProvider(pContext->hAlgorithm, 0);
 }
 
-static BOOL hmacPrecomputeDigest(BCRYPT_HASH_HANDLE hHash, PUCHAR pbPassword, DWORD cbPassword, BYTE mask)
-{
-	BYTE buffer[BLOCK_SIZE];
-	DWORD i;
+static BOOL
+hmacPrecomputeDigest(BCRYPT_HASH_HANDLE hHash, PUCHAR pbPassword, DWORD cbPassword, BYTE mask) {
+    BYTE buffer[BLOCK_SIZE];
+    DWORD i;
 
-	if (cbPassword > BLOCK_SIZE)
-	{
-		return FALSE;
-	}
+    if (cbPassword > BLOCK_SIZE) {
+	return FALSE;
+    }
 
-	memset(buffer, mask, sizeof(buffer));
+    memset(buffer, mask, sizeof(buffer));
 
-	for (i = 0; i < cbPassword; ++i)
-	{
-		buffer[i] = (char)(pbPassword[i] ^ mask);
-	}
+    for (i = 0; i < cbPassword; ++i) {
+	buffer[i] = (char)(pbPassword[i] ^ mask);
+    }
 
-	return BCRYPT_SUCCESS(BCryptHashData(hHash, buffer, sizeof(buffer), 0));
+    return BCRYPT_SUCCESS(BCryptHashData(hHash, buffer, sizeof(buffer), 0));
 }
 
-static BOOL hmacInit(PRF_CTX* pContext, PUCHAR pbPassword, DWORD cbPassword)
-{
-	BOOL bStatus = FALSE;
-	ULONG cbResult;
-	BYTE key[DIGEST_SIZE];
+static BOOL
+hmacInit(PRF_CTX *pContext, PUCHAR pbPassword, DWORD cbPassword) {
+    BOOL bStatus = FALSE;
+    ULONG cbResult;
+    BYTE key[DIGEST_SIZE];
 
-	if (!BCRYPT_SUCCESS(BCryptOpenAlgorithmProvider(&pContext->hAlgorithm, BCRYPT_SHA1_ALGORITHM, NULL, 0)) ||
-		!BCRYPT_SUCCESS(BCryptGetProperty(pContext->hAlgorithm, BCRYPT_OBJECT_LENGTH, (PUCHAR)&pContext->cbHashObject, sizeof(pContext->cbHashObject), &cbResult, 0)) ||
-		((pContext->pbInnerHash = malloc(pContext->cbHashObject)) == NULL) ||
-		((pContext->pbOuterHash = malloc(pContext->cbHashObject)) == NULL) ||
-		!BCRYPT_SUCCESS(BCryptCreateHash(pContext->hAlgorithm, &pContext->hInnerHash, pContext->pbInnerHash, pContext->cbHashObject, NULL, 0, 0)) ||
-		!BCRYPT_SUCCESS(BCryptCreateHash(pContext->hAlgorithm, &pContext->hOuterHash, pContext->pbOuterHash, pContext->cbHashObject, NULL, 0, 0)))
-	{
-		goto hmacInit_end;
+    if (!BCRYPT_SUCCESS(BCryptOpenAlgorithmProvider(&pContext->hAlgorithm, BCRYPT_SHA1_ALGORITHM, NULL, 0)) || !BCRYPT_SUCCESS(BCryptGetProperty(pContext->hAlgorithm, BCRYPT_OBJECT_LENGTH, (PUCHAR)&pContext->cbHashObject, sizeof(pContext->cbHashObject), &cbResult, 0)) || ((pContext->pbInnerHash = malloc(pContext->cbHashObject)) == NULL) || ((pContext->pbOuterHash = malloc(pContext->cbHashObject)) == NULL) || !BCRYPT_SUCCESS(BCryptCreateHash(pContext->hAlgorithm, &pContext->hInnerHash, pContext->pbInnerHash, pContext->cbHashObject, NULL, 0, 0)) || !BCRYPT_SUCCESS(BCryptCreateHash(pContext->hAlgorithm, &pContext->hOuterHash, pContext->pbOuterHash, pContext->cbHashObject, NULL, 0, 0))) {
+	goto hmacInit_end;
+    }
+
+    if (cbPassword > BLOCK_SIZE) {
+	BCRYPT_HASH_HANDLE hHash = NULL;
+	PUCHAR pbHashObject = malloc(pContext->cbHashObject);
+
+	bStatus = BCRYPT_SUCCESS(BCryptCreateHash(pContext->hAlgorithm, &hHash, pbHashObject, pContext->cbHashObject, NULL, 0, 0)) && BCRYPT_SUCCESS(BCryptHashData(hHash, pbPassword, cbPassword, 0)) && BCRYPT_SUCCESS(BCryptGetProperty(hHash, BCRYPT_HASH_LENGTH, (PUCHAR)&cbPassword, sizeof(cbPassword), &cbResult, 0)) && BCRYPT_SUCCESS(BCryptFinishHash(hHash, key, cbPassword, 0));
+
+	if (hHash)
+	    BCryptDestroyHash(hHash);
+	free(pbHashObject);
+
+	if (!bStatus) {
+	    goto hmacInit_end;
 	}
 
-	if (cbPassword > BLOCK_SIZE)
-	{
-		BCRYPT_HASH_HANDLE hHash = NULL;
-		PUCHAR pbHashObject = malloc(pContext->cbHashObject);
+	pbPassword = key;
+    }
 
-		bStatus =
-			BCRYPT_SUCCESS(BCryptCreateHash(pContext->hAlgorithm, &hHash, pbHashObject, pContext->cbHashObject, NULL, 0, 0)) &&
-			BCRYPT_SUCCESS(BCryptHashData(hHash, pbPassword, cbPassword, 0)) &&
-			BCRYPT_SUCCESS(BCryptGetProperty(hHash, BCRYPT_HASH_LENGTH, (PUCHAR)&cbPassword, sizeof(cbPassword), &cbResult, 0)) &&
-			BCRYPT_SUCCESS(BCryptFinishHash(hHash, key, cbPassword, 0));
-
-		if (hHash) BCryptDestroyHash(hHash);
-		free(pbHashObject);
-
-		if (!bStatus)
-		{
-			goto hmacInit_end;
-		}
-
-		pbPassword = key;
-	}
-
-	bStatus =
-		hmacPrecomputeDigest(pContext->hInnerHash, pbPassword, cbPassword, 0x36) &&
-		hmacPrecomputeDigest(pContext->hOuterHash, pbPassword, cbPassword, 0x5C);
+    bStatus = hmacPrecomputeDigest(pContext->hInnerHash, pbPassword, cbPassword, 0x36) && hmacPrecomputeDigest(pContext->hOuterHash, pbPassword, cbPassword, 0x5C);
 
 hmacInit_end:
 
-	if (bStatus == FALSE) hmacFree(pContext);
+    if (bStatus == FALSE)
+	hmacFree(pContext);
 
-	return bStatus;
+    return bStatus;
 }
 
-static BOOL hmacCalculateInternal(BCRYPT_HASH_HANDLE hHashTemplate, PUCHAR pbData, DWORD cbData, PUCHAR pbOutput, DWORD cbOutput, DWORD cbHashObject)
-{
-	BOOL success = FALSE;
-	BCRYPT_HASH_HANDLE hHash = NULL;
-	PUCHAR pbHashObject = malloc(cbHashObject);
+static BOOL
+hmacCalculateInternal(BCRYPT_HASH_HANDLE hHashTemplate, PUCHAR pbData, DWORD cbData, PUCHAR pbOutput, DWORD cbOutput, DWORD cbHashObject) {
+    BOOL success = FALSE;
+    BCRYPT_HASH_HANDLE hHash = NULL;
+    PUCHAR pbHashObject = malloc(cbHashObject);
 
-	if (BCRYPT_SUCCESS(BCryptDuplicateHash(hHashTemplate, &hHash, pbHashObject, cbHashObject, 0)))
-	{
-		success =
-			BCRYPT_SUCCESS(BCryptHashData(hHash, pbData, cbData, 0)) &&
-			BCRYPT_SUCCESS(BCryptFinishHash(hHash, pbOutput, cbOutput, 0));
+    if (BCRYPT_SUCCESS(BCryptDuplicateHash(hHashTemplate, &hHash, pbHashObject, cbHashObject, 0))) {
+	success = BCRYPT_SUCCESS(BCryptHashData(hHash, pbData, cbData, 0)) && BCRYPT_SUCCESS(BCryptFinishHash(hHash, pbOutput, cbOutput, 0));
 
-		BCryptDestroyHash(hHash);
-	}
+	BCryptDestroyHash(hHash);
+    }
 
-	free(pbHashObject);
+    free(pbHashObject);
 
-	return success;
+    return success;
 }
 
-static BOOL hmacCalculate(PRF_CTX* pContext, PUCHAR pbData, DWORD cbData, PUCHAR pbDigest)
-{
-	DWORD cbResult;
-	DWORD cbHashObject;
+static BOOL
+hmacCalculate(PRF_CTX *pContext, PUCHAR pbData, DWORD cbData, PUCHAR pbDigest) {
+    DWORD cbResult;
+    DWORD cbHashObject;
 
-	return
-		BCRYPT_SUCCESS(BCryptGetProperty(pContext->hAlgorithm, BCRYPT_OBJECT_LENGTH, (PUCHAR)&cbHashObject, sizeof(cbHashObject), &cbResult, 0)) &&
-		hmacCalculateInternal(pContext->hInnerHash, pbData, cbData, pbDigest, DIGEST_SIZE, cbHashObject) &&
-		hmacCalculateInternal(pContext->hOuterHash, pbDigest, DIGEST_SIZE, pbDigest, DIGEST_SIZE, cbHashObject);
+    return BCRYPT_SUCCESS(BCryptGetProperty(pContext->hAlgorithm, BCRYPT_OBJECT_LENGTH, (PUCHAR)&cbHashObject, sizeof(cbHashObject), &cbResult, 0)) && hmacCalculateInternal(pContext->hInnerHash, pbData, cbData, pbDigest, DIGEST_SIZE, cbHashObject) && hmacCalculateInternal(pContext->hOuterHash, pbDigest, DIGEST_SIZE, pbDigest, DIGEST_SIZE, cbHashObject);
 }
 
-static void xor(LPBYTE ptr1, LPBYTE ptr2, DWORD dwLen)
-{
+static void xor
+    (LPBYTE ptr1, LPBYTE ptr2, DWORD dwLen) {
 	while (dwLen--)
-		*ptr1++ ^= *ptr2++;
-}
+	    *ptr1++ ^= *ptr2++;
+    }
 
-BOOL pbkdf2(
-	PUCHAR pbPassword,
-	ULONG cbPassword,
-	PUCHAR pbSalt,
-	ULONG cbSalt,
-	DWORD cIterations,
-	PUCHAR pbDerivedKey,
-	ULONG cbDerivedKey)
-{
-	BOOL bStatus = FALSE;
-	DWORD l, r, dwULen, i, j;
-	BYTE Ti[DIGEST_SIZE];
-	BYTE V[DIGEST_SIZE];
-	LPBYTE U = malloc(max((cbSalt + 4), DIGEST_SIZE));
-	PRF_CTX prfCtx = { 0 };
+    BOOL pbkdf2(PUCHAR pbPassword, ULONG cbPassword, PUCHAR pbSalt, ULONG cbSalt, DWORD cIterations, PUCHAR pbDerivedKey, ULONG cbDerivedKey) {
+    BOOL bStatus = FALSE;
+    DWORD l, r, dwULen, i, j;
+    BYTE Ti[DIGEST_SIZE];
+    BYTE V[DIGEST_SIZE];
+    LPBYTE U = malloc(max((cbSalt + 4), DIGEST_SIZE));
+    PRF_CTX prfCtx = {0};
 
-	if (pbPassword == NULL || cbPassword == 0 || pbSalt == NULL || cbSalt == 0 || cIterations == 0 || pbDerivedKey == NULL || cbDerivedKey == 0)
-	{
-		free(U);
-		return FALSE;
-	}
+    if (pbPassword == NULL || cbPassword == 0 || pbSalt == NULL || cbSalt == 0 || cIterations == 0 || pbDerivedKey == NULL || cbDerivedKey == 0) {
+	free(U);
+	return FALSE;
+    }
 
-	if (!hmacInit(&prfCtx, pbPassword, cbPassword))
-	{
+    if (!hmacInit(&prfCtx, pbPassword, cbPassword)) {
+	goto PBKDF2_end;
+    }
+
+    l = (DWORD)ceil((double)cbDerivedKey / (double)DIGEST_SIZE);
+    r = cbDerivedKey - (l - 1) * DIGEST_SIZE;
+
+    for (i = 1; i <= l; i++) {
+	ZeroMemory(Ti, DIGEST_SIZE);
+	for (j = 0; j < cIterations; j++) {
+	    if (j == 0) {
+		// construct first input for PRF
+		memcpy(U, pbSalt, cbSalt);
+		U[cbSalt] = (BYTE)((i & 0xFF000000) >> 24);
+		U[cbSalt + 1] = (BYTE)((i & 0x00FF0000) >> 16);
+		U[cbSalt + 2] = (BYTE)((i & 0x0000FF00) >> 8);
+		U[cbSalt + 3] = (BYTE)((i & 0x000000FF));
+		dwULen = cbSalt + 4;
+	    }
+	    else {
+		memcpy(U, V, DIGEST_SIZE);
+		dwULen = DIGEST_SIZE;
+	    }
+
+	    if (!hmacCalculate(&prfCtx, U, dwULen, V)) {
 		goto PBKDF2_end;
+	    }
+
+	    xor(Ti, V, DIGEST_SIZE);
 	}
 
-	l = (DWORD)ceil((double)cbDerivedKey / (double)DIGEST_SIZE);
-	r = cbDerivedKey - (l - 1) * DIGEST_SIZE;
-
-	for (i = 1; i <= l; i++)
-	{
-		ZeroMemory(Ti, DIGEST_SIZE);
-		for (j = 0; j < cIterations; j++)
-		{
-			if (j == 0)
-			{
-				// construct first input for PRF
-				memcpy(U, pbSalt, cbSalt);
-				U[cbSalt] = (BYTE)((i & 0xFF000000) >> 24);
-				U[cbSalt + 1] = (BYTE)((i & 0x00FF0000) >> 16);
-				U[cbSalt + 2] = (BYTE)((i & 0x0000FF00) >> 8);
-				U[cbSalt + 3] = (BYTE)((i & 0x000000FF));
-				dwULen = cbSalt + 4;
-			}
-			else
-			{
-				memcpy(U, V, DIGEST_SIZE);
-				dwULen = DIGEST_SIZE;
-			}
-
-			if (!hmacCalculate(&prfCtx, U, dwULen, V))
-			{
-				goto PBKDF2_end;
-			}
-
-			xor (Ti, V, DIGEST_SIZE);
-		}
-
-		if (i != l)
-		{
-			memcpy(&pbDerivedKey[(i - 1) * DIGEST_SIZE], Ti, DIGEST_SIZE);
-		}
-		else
-		{
-			// Take only the first r bytes
-			memcpy(&pbDerivedKey[(i - 1) * DIGEST_SIZE], Ti, r);
-		}
+	if (i != l) {
+	    memcpy(&pbDerivedKey[(i - 1) * DIGEST_SIZE], Ti, DIGEST_SIZE);
 	}
+	else {
+	    // Take only the first r bytes
+	    memcpy(&pbDerivedKey[(i - 1) * DIGEST_SIZE], Ti, r);
+	}
+    }
 
-	bStatus = TRUE;
+    bStatus = TRUE;
 
 PBKDF2_end:
 
-	hmacFree(&prfCtx);
-	free(U);
-	return bStatus;
+    hmacFree(&prfCtx);
+    free(U);
+    return bStatus;
 }
 
-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)
-{
-	return
-		(key_length <= ZIP_UINT32_MAX) &&
-		pbkdf2((PUCHAR)key, (ULONG)key_length, (PUCHAR)salt, salt_length, iterations, output, output_length);
+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) {
+    return (key_length <= ZIP_UINT32_MAX) && pbkdf2((PUCHAR)key, (ULONG)key_length, (PUCHAR)salt, salt_length, iterations, output, output_length);
 }
 
 #endif
 
 
-struct _zip_crypto_aes_s
-{
-	BCRYPT_ALG_HANDLE hAlgorithm;
-	BCRYPT_KEY_HANDLE hKey;
-	ULONG cbKeyObject;
-	PUCHAR pbKeyObject;
+struct _zip_crypto_aes_s {
+    BCRYPT_ALG_HANDLE hAlgorithm;
+    BCRYPT_KEY_HANDLE hKey;
+    ULONG cbKeyObject;
+    PUCHAR pbKeyObject;
 };
 
-_zip_crypto_aes_t *_zip_crypto_aes_new(const zip_uint8_t *key, zip_uint16_t key_size, zip_error_t *error)
-{
-	_zip_crypto_aes_t *aes = (_zip_crypto_aes_t *)calloc(1, sizeof(*aes));
+_zip_crypto_aes_t *
+_zip_crypto_aes_new(const zip_uint8_t *key, zip_uint16_t key_size, zip_error_t *error) {
+    _zip_crypto_aes_t *aes = (_zip_crypto_aes_t *)calloc(1, sizeof(*aes));
 
-	ULONG cbResult;
-	ULONG key_length = key_size / 8;
+    ULONG cbResult;
+    ULONG key_length = key_size / 8;
 
-	if (aes == NULL)
-	{
-		zip_error_set(error, ZIP_ER_MEMORY, 0);
-		return NULL;
-	}
+    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(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(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;
-	}
+    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);
+    aes->pbKeyObject = malloc(aes->cbKeyObject);
 
-	if (!BCRYPT_SUCCESS(BCryptGenerateSymmetricKey(aes->hAlgorithm, &aes->hKey, aes->pbKeyObject, aes->cbKeyObject, (PUCHAR)key, key_length, 0)))
-	{
-		_zip_crypto_aes_free(aes);
-		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;
+    return aes;
 }
 
-void _zip_crypto_aes_free(_zip_crypto_aes_t *aes)
-{
-	if (aes == NULL)
-	{
-		return;
-	}
+void
+_zip_crypto_aes_free(_zip_crypto_aes_t *aes) {
+    if (aes == NULL) {
+	return;
+    }
 
-	if (aes->hKey != NULL)
-	{
-		BCryptDestroyKey(aes->hKey);
-	}
+    if (aes->hKey != NULL) {
+	BCryptDestroyKey(aes->hKey);
+    }
 
-	if (aes->pbKeyObject != NULL)
-	{
-		free(aes->pbKeyObject);
-	}
+    if (aes->pbKeyObject != NULL) {
+	free(aes->pbKeyObject);
+    }
 
-	if (aes->hAlgorithm != NULL)
-	{
-		BCryptCloseAlgorithmProvider(aes->hAlgorithm, 0);
-	}
+    if (aes->hAlgorithm != NULL) {
+	BCryptCloseAlgorithmProvider(aes->hAlgorithm, 0);
+    }
 
-	free(aes);
+    free(aes);
 }
 
-bool _zip_crypto_aes_encrypt_block(_zip_crypto_aes_t *aes, const zip_uint8_t *in, zip_uint8_t *out)
-{
-	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);
+bool
+_zip_crypto_aes_encrypt_block(_zip_crypto_aes_t *aes, const zip_uint8_t *in, zip_uint8_t *out) {
+    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);
 }
 
-struct _zip_crypto_hmac_s
-{
-	BCRYPT_ALG_HANDLE hAlgorithm;
-	BCRYPT_HASH_HANDLE hHash;
-	DWORD cbHashObject;
-	PUCHAR pbHashObject;
-	DWORD cbHash;
-	PUCHAR pbHash;
+struct _zip_crypto_hmac_s {
+    BCRYPT_ALG_HANDLE hAlgorithm;
+    BCRYPT_HASH_HANDLE hHash;
+    DWORD cbHashObject;
+    PUCHAR pbHashObject;
+    DWORD cbHash;
+    PUCHAR pbHash;
 };
 
 // https://code.msdn.microsoft.com/windowsdesktop/Hmac-Computation-Sample-11fe8ec1/sourcecode?fileId=42820&pathId=283874677
 
-_zip_crypto_hmac_t *_zip_crypto_hmac_new(const zip_uint8_t *secret, zip_uint64_t secret_length, zip_error_t *error)
-{
-	NTSTATUS status;
-	ULONG cbResult;
-	_zip_crypto_hmac_t *hmac;
+_zip_crypto_hmac_t *
+_zip_crypto_hmac_new(const zip_uint8_t *secret, zip_uint64_t secret_length, zip_error_t *error) {
+    NTSTATUS status;
+    ULONG cbResult;
+    _zip_crypto_hmac_t *hmac;
 
-	if (secret_length > INT_MAX)
-	{
-		zip_error_set(error, ZIP_ER_INVAL, 0);
-		return NULL;
-	}
+    if (secret_length > INT_MAX) {
+	zip_error_set(error, ZIP_ER_INVAL, 0);
+	return NULL;
+    }
 
-	hmac = (_zip_crypto_hmac_t *)calloc(1, sizeof(*hmac));
+    hmac = (_zip_crypto_hmac_t *)calloc(1, sizeof(*hmac));
 
-	if (hmac == NULL)
-	{
-		zip_error_set(error, ZIP_ER_MEMORY, 0);
-		return NULL;
-	}
+    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 = 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;
-	}
+    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);
+    hmac->pbHashObject = malloc(hmac->cbHashObject);
 
-	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;
-	}
+    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);
+    hmac->pbHash = malloc(hmac->cbHash);
 
-	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;
-	}
+    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;
+    return hmac;
 }
 
-void _zip_crypto_hmac_free(_zip_crypto_hmac_t *hmac)
-{
-	if (hmac == NULL)
-	{
-		return;
-	}
+void
+_zip_crypto_hmac_free(_zip_crypto_hmac_t *hmac) {
+    if (hmac == NULL) {
+	return;
+    }
 
-	if (hmac->hHash != NULL)
-	{
-		BCryptDestroyHash(hmac->hHash);
-	}
+    if (hmac->hHash != NULL) {
+	BCryptDestroyHash(hmac->hHash);
+    }
 
-	if (hmac->pbHash != NULL)
-	{
-		free(hmac->pbHash);
-	}
+    if (hmac->pbHash != NULL) {
+	free(hmac->pbHash);
+    }
 
-	if (hmac->pbHashObject != NULL)
-	{
-		free(hmac->pbHashObject);
-	}
+    if (hmac->pbHashObject != NULL) {
+	free(hmac->pbHashObject);
+    }
 
-	if (hmac->hAlgorithm)
-	{
-		BCryptCloseAlgorithmProvider(hmac->hAlgorithm, 0);
-	}
+    if (hmac->hAlgorithm) {
+	BCryptCloseAlgorithmProvider(hmac->hAlgorithm, 0);
+    }
 
-	free(hmac);
+    free(hmac);
 }
 
-bool _zip_crypto_hmac(_zip_crypto_hmac_t *hmac, zip_uint8_t *data, zip_uint64_t length)
-{
-	if (hmac == NULL || length > ULONG_MAX)
-	{
-		return false;
-	}
+bool
+_zip_crypto_hmac(_zip_crypto_hmac_t *hmac, zip_uint8_t *data, zip_uint64_t length) {
+    if (hmac == NULL || length > ULONG_MAX) {
+	return false;
+    }
 
-	return BCRYPT_SUCCESS(BCryptHashData(hmac->hHash, data, (ULONG)length, 0));
+    return BCRYPT_SUCCESS(BCryptHashData(hmac->hHash, data, (ULONG)length, 0));
 }
 
-bool _zip_crypto_hmac_output(_zip_crypto_hmac_t *hmac, zip_uint8_t *data)
-{
-	if (hmac == NULL)
-	{
-		return false;
-	}
+bool
+_zip_crypto_hmac_output(_zip_crypto_hmac_t *hmac, zip_uint8_t *data) {
+    if (hmac == NULL) {
+	return false;
+    }
 
-	return BCRYPT_SUCCESS(BCryptFinishHash(hmac->hHash, data, hmac->cbHash, 0));
+    return BCRYPT_SUCCESS(BCryptFinishHash(hmac->hHash, data, hmac->cbHash, 0));
 }
 
 ZIP_EXTERN bool
-zip_random(zip_uint8_t *buffer, zip_uint16_t length)
-{
-	return BCRYPT_SUCCESS(BCryptGenRandom(NULL, buffer, length, BCRYPT_USE_SYSTEM_PREFERRED_RNG));
+zip_random(zip_uint8_t *buffer, zip_uint16_t length) {
+    return BCRYPT_SUCCESS(BCryptGenRandom(NULL, buffer, length, BCRYPT_USE_SYSTEM_PREFERRED_RNG));
 }
diff --git a/lib/zip_crypto_win.h b/lib/zip_crypto_win.h
index 15a2d46..9a239af 100644
--- a/lib/zip_crypto_win.h
+++ b/lib/zip_crypto_win.h
@@ -41,14 +41,7 @@
 _zip_crypto_aes_t *_zip_crypto_aes_new(const zip_uint8_t *key, zip_uint16_t key_size, zip_error_t *error);
 bool _zip_crypto_aes_encrypt_block(_zip_crypto_aes_t *aes, const zip_uint8_t *in, zip_uint8_t *out);
 
-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);
+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_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);
diff --git a/lib/zip_source_buffer.c b/lib/zip_source_buffer.c
index d2bc8ad..32e2fba 100644
--- a/lib/zip_source_buffer.c
+++ b/lib/zip_source_buffer.c
@@ -389,8 +389,8 @@
     }
 
     if ((fragments = realloc(buffer->fragments, sizeof(buffer->fragments[0]) * capacity)) == NULL) {
-        zip_error_set(error, ZIP_ER_MEMORY, 0);
-        return false;
+	zip_error_set(error, ZIP_ER_MEMORY, 0);
+	return false;
     }
     buffer->fragments = fragments;
     if ((offsets = realloc(buffer->fragment_offsets, sizeof(buffer->fragment_offsets[0]) * (capacity + 1))) == NULL) {
diff --git a/lib/zip_source_read.c b/lib/zip_source_read.c
index 83514c6..b3ea57f 100644
--- a/lib/zip_source_read.c
+++ b/lib/zip_source_read.c
@@ -57,7 +57,7 @@
     }
 
     if (len == 0) {
-      return 0;
+	return 0;
     }
 
     bytes_read = 0;
diff --git a/lib/zip_source_winzip_aes_decode.c b/lib/zip_source_winzip_aes_decode.c
index cd76593..c9a88df 100644
--- a/lib/zip_source_winzip_aes_decode.c
+++ b/lib/zip_source_winzip_aes_decode.c
@@ -138,8 +138,8 @@
     }
 
     if (!_zip_winzip_aes_finish(ctx->aes_ctx, computed)) {
-        zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
-        return false;
+	zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
+	return false;
     }
     _zip_winzip_aes_free(ctx->aes_ctx);
     ctx->aes_ctx = NULL;
@@ -186,10 +186,10 @@
 	}
 	ctx->current_position += (zip_uint64_t)n;
 
-        if (!_zip_winzip_aes_decrypt(ctx->aes_ctx, (zip_uint8_t *)data, (zip_uint64_t)n)) {
-            zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
-            return -1;
-        }
+	if (!_zip_winzip_aes_decrypt(ctx->aes_ctx, (zip_uint8_t *)data, (zip_uint64_t)n)) {
+	    zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
+	    return -1;
+	}
 
 	return n;
 
diff --git a/lib/zip_source_winzip_aes_encode.c b/lib/zip_source_winzip_aes_encode.c
index 12ed1b2..cf66da4 100644
--- a/lib/zip_source_winzip_aes_encode.c
+++ b/lib/zip_source_winzip_aes_encode.c
@@ -143,19 +143,19 @@
 	    return -1;
 	}
 
-        if (!_zip_winzip_aes_encrypt(ctx->aes_ctx, data, (zip_uint64_t)ret)) {
-            zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
-            /* TODO: return partial read? */
-            return -1;
-        }
+	if (!_zip_winzip_aes_encrypt(ctx->aes_ctx, data, (zip_uint64_t)ret)) {
+	    zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
+	    /* TODO: return partial read? */
+	    return -1;
+	}
 
 	if ((zip_uint64_t)ret < length) {
 	    ctx->eof = true;
-            if (!_zip_winzip_aes_finish(ctx->aes_ctx, ctx->data)) {
-                zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
-                /* TODO: return partial read? */
-                return -1;
-            }
+	    if (!_zip_winzip_aes_finish(ctx->aes_ctx, ctx->data)) {
+		zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
+		/* TODO: return partial read? */
+		return -1;
+	    }
 	    _zip_winzip_aes_free(ctx->aes_ctx);
 	    ctx->aes_ctx = NULL;
 	    if ((ctx->buffer = _zip_buffer_new(ctx->data, HMAC_LENGTH)) == NULL) {
diff --git a/lib/zip_winzip_aes.c b/lib/zip_winzip_aes.c
index 4f98064..ad2282c 100644
--- a/lib/zip_winzip_aes.c
+++ b/lib/zip_winzip_aes.c
@@ -40,7 +40,6 @@
 #include <string.h>
 
 
-
 #define MAX_KEY_LENGTH 256
 #define PBKDF2_ITERATIONS 1000
 
@@ -53,11 +52,10 @@
 };
 
 static bool
-aes_crypt(zip_winzip_aes_t *ctx, zip_uint8_t *data, zip_uint64_t length)
-{
+aes_crypt(zip_winzip_aes_t *ctx, zip_uint8_t *data, zip_uint64_t length) {
     zip_uint64_t i, j;
 
-    for (i=0; i < length; i++) {
+    for (i = 0; i < length; i++) {
 	if (ctx->pad_offset == AES_BLOCK_SIZE) {
 	    for (j = 0; j < 8; j++) {
 		ctx->counter[j]++;
@@ -65,9 +63,9 @@
 		    break;
 		}
 	    }
-            if (!_zip_crypto_aes_encrypt_block(ctx->aes, ctx->counter, ctx->pad)) {
-                return false;
-            }
+	    if (!_zip_crypto_aes_encrypt_block(ctx->aes, ctx->counter, ctx->pad)) {
+		return false;
+	    }
 	    ctx->pad_offset = 0;
 	}
 	data[i] ^= ctx->pad[ctx->pad_offset++];
@@ -78,12 +76,11 @@
 
 
 zip_winzip_aes_t *
-_zip_winzip_aes_new(const zip_uint8_t *password, zip_uint64_t password_length, const zip_uint8_t *salt, zip_uint16_t encryption_method, zip_uint8_t *password_verify, zip_error_t *error)
-{
+_zip_winzip_aes_new(const zip_uint8_t *password, zip_uint64_t password_length, const zip_uint8_t *salt, zip_uint16_t encryption_method, zip_uint8_t *password_verify, zip_error_t *error) {
     zip_winzip_aes_t *ctx;
     zip_uint8_t buffer[2 * (MAX_KEY_LENGTH / 8) + WINZIP_AES_PASSWORD_VERIFY_LENGTH];
     zip_uint16_t key_size = 0; /* in bits */
-    zip_uint16_t key_length; /* in bytes */
+    zip_uint16_t key_length;   /* in bytes */
 
     switch (encryption_method) {
     case ZIP_EM_AES_128:
@@ -111,21 +108,21 @@
 
     memset(ctx->counter, 0, sizeof(ctx->counter));
     ctx->pad_offset = ZIP_CRYPTO_AES_BLOCK_LENGTH;
-    
+
     if (!_zip_crypto_pbkdf2(password, password_length, salt, key_length / 2, PBKDF2_ITERATIONS, buffer, 2 * key_length + WINZIP_AES_PASSWORD_VERIFY_LENGTH)) {
-        free(ctx);
-        return NULL;
+	free(ctx);
+	return NULL;
     }
 
     if ((ctx->aes = _zip_crypto_aes_new(buffer, key_size, error)) == NULL) {
-        _zip_crypto_clear(ctx, sizeof(*ctx));
-        free(ctx);
-        return NULL;
+	_zip_crypto_clear(ctx, sizeof(*ctx));
+	free(ctx);
+	return NULL;
     }
     if ((ctx->hmac = _zip_crypto_hmac_new(buffer + key_length, key_length, error)) == NULL) {
-        _zip_crypto_aes_free(ctx->aes);
-        free(ctx);
-        return NULL;
+	_zip_crypto_aes_free(ctx->aes);
+	free(ctx);
+	return NULL;
     }
 
     if (password_verify) {
@@ -137,29 +134,25 @@
 
 
 bool
-_zip_winzip_aes_encrypt(zip_winzip_aes_t *ctx, zip_uint8_t *data, zip_uint64_t length)
-{
+_zip_winzip_aes_encrypt(zip_winzip_aes_t *ctx, zip_uint8_t *data, zip_uint64_t length) {
     return aes_crypt(ctx, data, length) && _zip_crypto_hmac(ctx->hmac, data, length);
 }
 
 
 bool
-_zip_winzip_aes_decrypt(zip_winzip_aes_t *ctx, zip_uint8_t *data, zip_uint64_t length)
-{
+_zip_winzip_aes_decrypt(zip_winzip_aes_t *ctx, zip_uint8_t *data, zip_uint64_t length) {
     return _zip_crypto_hmac(ctx->hmac, data, length) && aes_crypt(ctx, data, length);
 }
 
 
 bool
-_zip_winzip_aes_finish(zip_winzip_aes_t *ctx, zip_uint8_t *hmac)
-{
+_zip_winzip_aes_finish(zip_winzip_aes_t *ctx, zip_uint8_t *hmac) {
     return _zip_crypto_hmac_output(ctx->hmac, hmac);
 }
 
 
 void
-_zip_winzip_aes_free(zip_winzip_aes_t *ctx)
-{
+_zip_winzip_aes_free(zip_winzip_aes_t *ctx) {
     if (ctx == NULL) {
 	return;
     }