]> cvs.zerfleddert.de Git - proxmark3-svn/commitdiff
Get rid of polarssl (#717)
authorOleg Moiseenko <807634+merlokk@users.noreply.github.com>
Fri, 23 Nov 2018 18:03:46 +0000 (20:03 +0200)
committerpwpiwi <pwpiwi@users.noreply.github.com>
Fri, 23 Nov 2018 18:03:46 +0000 (19:03 +0100)
13 files changed:
armsrc/Makefile
armsrc/mifareutil.c
client/Makefile
client/cmdhficlass.c
client/loclass/elite_crack.c
client/loclass/ikeys.c
client/obj/polarssl/.dummy [deleted file]
common/Makefile.common
common/mbedtls/platform_util_arm.c [new file with mode: 0644]
common/mbedtls/platform_util_arm.h [new file with mode: 0644]
common/polarssl/des.c [deleted file]
common/polarssl/des.h [deleted file]
common/polarssl/polarssl_config.h [deleted file]

index d230cda1c5c90061d2a41219d546de82a9a86974..7348fda6e13287f80fd5fbfac5ed28451f23cb6a 100644 (file)
@@ -24,7 +24,8 @@ SRC_LF = lfops.c hitag2.c hitagS.c lfsampling.c pcf7931.c lfdemod.c protocols.c
 SRC_ISO15693 = iso15693.c iso15693tools.c
 SRC_ISO14443a = epa.c iso14443a.c mifareutil.c mifarecmd.c mifaresniff.c mifaresim.c
 SRC_ISO14443b = iso14443b.c
-SRC_CRAPTO1 = crypto1.c des.c
+SRC_CRAPTO1 = crypto1.c 
+SRC_DES = platform_util_arm.c des.c
 SRC_CRC = iso14443crc.c crc.c crc16.c crc32.c parity.c
 SRC_SMARTCARD = i2c.c
 
@@ -61,6 +62,7 @@ ARMSRC = fpgaloader.c \
        $(SRC_ISO14443a) \
        $(SRC_ISO14443b) \
        $(SRC_CRAPTO1) \
+       $(SRC_DES) \
        $(SRC_CRC) \
        iclass.c \
        BigBuf.c \
index 684b5e362bdf16db312da24b662d1e8e491b5a11..4b1f16f362ca1f0dedfdda6df4429dd2ae137122 100644 (file)
@@ -21,7 +21,7 @@
 #include "iso14443crc.h"\r
 #include "iso14443a.h"\r
 #include "crapto1/crapto1.h"\r
-#include "polarssl/des.h"\r
+#include "mbedtls/des.h"\r
 \r
 int MF_DBGLEVEL = MF_DBG_ALL;\r
 \r
@@ -296,7 +296,7 @@ int mifare_ultra_auth(uint8_t *keybytes){
 \r
        /// 3des2k\r
 \r
-       des3_context ctx = { 0x00 };\r
+       mbedtls_des3_context ctx = { 0x00 };\r
        uint8_t random_a[8] = {1,1,1,1,1,1,1,1};\r
        uint8_t random_b[8] = {0x00};\r
        uint8_t enc_random_b[8] = {0x00};\r
@@ -321,9 +321,9 @@ int mifare_ultra_auth(uint8_t *keybytes){
 \r
        // decrypt nonce.\r
        // tdes_2key_dec(random_b, enc_random_b, sizeof(random_b), key, IV );\r
-       des3_set2key_dec(&ctx, key);\r
-       des3_crypt_cbc(&ctx     // des3_context\r
-               , DES_DECRYPT           // int mode\r
+       mbedtls_des3_set2key_dec(&ctx, key);\r
+       mbedtls_des3_crypt_cbc(&ctx     // des3_context\r
+               , MBEDTLS_DES_DECRYPT           // int mode\r
                , sizeof(random_b)      // length\r
                , IV                    // iv[8]\r
                , enc_random_b          // input\r
@@ -350,9 +350,9 @@ int mifare_ultra_auth(uint8_t *keybytes){
 \r
        // encrypt    out, in, length, key, iv\r
        //tdes_2key_enc(rnd_ab, rnd_ab, sizeof(rnd_ab), key, enc_random_b);\r
-       des3_set2key_enc(&ctx, key);\r
-       des3_crypt_cbc(&ctx     // des3_context\r
-               , DES_ENCRYPT           // int mode\r
+       mbedtls_des3_set2key_enc(&ctx, key);\r
+       mbedtls_des3_crypt_cbc(&ctx     // des3_context\r
+               , MBEDTLS_DES_ENCRYPT           // int mode\r
                , sizeof(rnd_ab)        // length\r
                , enc_random_b          // iv[8]\r
                , rnd_ab                        // input\r
@@ -372,9 +372,9 @@ int mifare_ultra_auth(uint8_t *keybytes){
 \r
        // decrypt    out, in, length, key, iv \r
        // tdes_2key_dec(resp_random_a, enc_resp, 8, key, enc_random_b);\r
-       des3_set2key_dec(&ctx, key);\r
-       des3_crypt_cbc(&ctx     // des3_context\r
-               , DES_DECRYPT           // int mode\r
+       mbedtls_des3_set2key_dec(&ctx, key);\r
+       mbedtls_des3_crypt_cbc(&ctx     // des3_context\r
+               , MBEDTLS_DES_DECRYPT           // int mode\r
                , 8                                     // length\r
                , enc_random_b          // iv[8]\r
                , enc_resp                      // input\r
index bf884f1f14614628c6f613df212dfa93b02a0b28..a049ae5a663aba058317c8e88a40b00f0e58f061 100644 (file)
@@ -107,7 +107,6 @@ CORESRCS =  uart_posix.c \
 CMDSRCS =      $(SRC_SMARTCARD) \
                        crapto1/crapto1.c\
                        crapto1/crypto1.c\
-                       polarssl/des.c\
                        crypto/libpcrypto.c\
                        crypto/asn1utils.c\
                        cliparser/argtable3.c\
index 499f7aae0e38d20e9874898ab913543d0bd43b82..c97e433caf615b3099184f23836da70b0cc4fcee 100644 (file)
@@ -23,7 +23,7 @@
 #include "common.h"
 #include "util.h"
 #include "cmdmain.h"
-#include "polarssl/des.h"
+#include "mbedtls/des.h"
 #include "loclass/cipherutils.h"
 #include "loclass/cipher.h"
 #include "loclass/ikeys.h"
@@ -414,8 +414,8 @@ int CmdHFiClassDecrypt(const char *Cmd) {
        fseek(f, 0, SEEK_SET);
        uint8_t enc_dump[8] = {0};
        uint8_t *decrypted = malloc(fsize);
-       des3_context ctx = { DES_DECRYPT ,{ 0 } };
-       des3_set2key_dec( &ctx, key);
+       mbedtls_des3_context ctx = { 0 };
+       mbedtls_des3_set2key_dec( &ctx, key);
        size_t bytes_read = fread(enc_dump, 1, 8, f);
 
        //Use the first block (CSN) for filename
@@ -431,7 +431,7 @@ int CmdHFiClassDecrypt(const char *Cmd) {
                {
                        memcpy(decrypted+(blocknum*8), enc_dump, 8);
                }else{
-                       des3_crypt_ecb(&ctx, enc_dump,decrypted +(blocknum*8) );
+                       mbedtls_des3_crypt_ecb(&ctx, enc_dump,decrypted +(blocknum*8) );
                }
                printvar("decrypted block", decrypted +(blocknum*8), 8);
                bytes_read = fread(enc_dump, 1, 8, f);
@@ -466,10 +466,10 @@ static int iClassEncryptBlkData(uint8_t *blkData) {
 
        uint8_t encryptedData[16];
        uint8_t *encrypted = encryptedData;
-       des3_context ctx = { DES_DECRYPT ,{ 0 } };
-       des3_set2key_enc( &ctx, key);
+       mbedtls_des3_context ctx = { 0 };
+       mbedtls_des3_set2key_enc( &ctx, key);
        
-       des3_crypt_ecb(&ctx, blkData,encrypted);
+       mbedtls_des3_crypt_ecb(&ctx, blkData,encrypted);
        //printvar("decrypted block", decrypted, 8);
        memcpy(blkData,encrypted,8);
 
index fe9bf7d1342ef0fb453a99c8548172e7a1dcdb66..f45c55b5cf9f0e80576deef74d9e410995f9df30 100644 (file)
@@ -46,7 +46,7 @@
 #include "ikeys.h"
 #include "elite_crack.h"
 #include "fileutils.h"
-#include "polarssl/des.h"
+#include "mbedtls/des.h"
 
 /**
  * @brief Permutes a key from standard NIST format to Iclass specific format
@@ -179,22 +179,22 @@ void rk(uint8_t *key, uint8_t n, uint8_t *outp_key)
     return;
 }
 
-static des_context ctx_enc = {DES_ENCRYPT,{0}};
-static des_context ctx_dec = {DES_DECRYPT,{0}};
+static mbedtls_des_context ctx_enc = {0};
+static mbedtls_des_context ctx_dec = {0};
 
 void desdecrypt_iclass(uint8_t *iclass_key, uint8_t *input, uint8_t *output)
 {
     uint8_t key_std_format[8] = {0};
     permutekey_rev(iclass_key, key_std_format);
-    des_setkey_dec( &ctx_dec, key_std_format);
-    des_crypt_ecb(&ctx_dec,input,output);
+    mbedtls_des_setkey_dec( &ctx_dec, key_std_format);
+    mbedtls_des_crypt_ecb(&ctx_dec,input,output);
 }
 void desencrypt_iclass(uint8_t *iclass_key, uint8_t *input, uint8_t *output)
 {
     uint8_t key_std_format[8] = {0};
     permutekey_rev(iclass_key, key_std_format);
-    des_setkey_enc( &ctx_enc, key_std_format);
-    des_crypt_ecb(&ctx_enc,input,output);
+    mbedtls_des_setkey_enc( &ctx_enc, key_std_format);
+    mbedtls_des_crypt_ecb(&ctx_enc,input,output);
 }
 
 /**
@@ -449,7 +449,7 @@ int bruteforceItem(dumpdata item, uint16_t keytable[])
  */
 int calculateMasterKey(uint8_t first16bytes[], uint64_t master_key[] )
 {
-       des_context ctx_e = {DES_ENCRYPT,{0}};
+       mbedtls_des_context ctx_e = {0};
 
        uint8_t z_0[8] = {0};
        uint8_t y_0[8] = {0};
@@ -468,8 +468,8 @@ int calculateMasterKey(uint8_t first16bytes[], uint64_t master_key[] )
        permutekey_rev(z_0, z_0_rev);
 
        // ~K_cus = DESenc(z[0], y[0])
-       des_setkey_enc( &ctx_e, z_0_rev );
-       des_crypt_ecb(&ctx_e, y_0, key64_negated);
+       mbedtls_des_setkey_enc( &ctx_e, z_0_rev );
+       mbedtls_des_crypt_ecb(&ctx_e, y_0, key64_negated);
 
        int i;
        for(i = 0; i < 8 ; i++)
@@ -482,8 +482,8 @@ int calculateMasterKey(uint8_t first16bytes[], uint64_t master_key[] )
        uint8_t key64_stdformat[8] = {0};
        permutekey_rev(key64, key64_stdformat);
 
-       des_setkey_enc( &ctx_e, key64_stdformat );
-       des_crypt_ecb(&ctx_e, key64_negated, result);
+       mbedtls_des_setkey_enc( &ctx_e, key64_stdformat );
+       mbedtls_des_crypt_ecb(&ctx_e, key64_negated, result);
        prnlog("\nHigh security custom key (Kcus):");
        printvar("Std format   ", key64_stdformat,8);
        printvar("Iclass format", key64,8);
index 2a6a00109297c72afe47de08426814f37a510f7e..3f90d6ee9d93abdaf64ce9d8728c92efeb725ce7 100644 (file)
@@ -68,12 +68,12 @@ From "Dismantling iclass":
 #include <inttypes.h>
 #include "fileutils.h"
 #include "cipherutils.h"
-#include "polarssl/des.h"
+#include "mbedtls/des.h"
 
 uint8_t pi[35] = {0x0F,0x17,0x1B,0x1D,0x1E,0x27,0x2B,0x2D,0x2E,0x33,0x35,0x39,0x36,0x3A,0x3C,0x47,0x4B,0x4D,0x4E,0x53,0x55,0x56,0x59,0x5A,0x5C,0x63,0x65,0x66,0x69,0x6A,0x6C,0x71,0x72,0x74,0x78};
 
-static des_context ctx_enc = {DES_ENCRYPT,{0}};
-static des_context ctx_dec = {DES_DECRYPT,{0}};
+static mbedtls_des_context ctx_enc = {0};
+static mbedtls_des_context ctx_dec = {0};
 
 static int debug_print = 0;
 
@@ -393,12 +393,12 @@ void diversifyKey(uint8_t csn[8], uint8_t key[8], uint8_t div_key[8])
 {
 
        // Prepare the DES key
-       des_setkey_enc( &ctx_enc, key);
+       mbedtls_des_setkey_enc( &ctx_enc, key);
 
        uint8_t crypted_csn[8] = {0};
 
        // Calculate DES(CSN, KEY)
-       des_crypt_ecb(&ctx_enc,csn, crypted_csn);
+       mbedtls_des_crypt_ecb(&ctx_enc,csn, crypted_csn);
 
        //Calculate HASH0(DES))
     uint64_t crypt_csn = x_bytes_to_num(crypted_csn, 8);
@@ -466,13 +466,13 @@ typedef struct
 } Testcase;
 
 
-int testDES(Testcase testcase, des_context ctx_enc, des_context ctx_dec)
+int testDES(Testcase testcase, mbedtls_des_context ctx_enc, mbedtls_des_context ctx_dec)
 {
        uint8_t des_encrypted_csn[8] = {0};
        uint8_t decrypted[8] = {0};
        uint8_t div_key[8] = {0};
-       int retval = des_crypt_ecb(&ctx_enc,testcase.uid,des_encrypted_csn);
-       retval |= des_crypt_ecb(&ctx_dec,des_encrypted_csn,decrypted);
+       int retval = mbedtls_des_crypt_ecb(&ctx_enc,testcase.uid,des_encrypted_csn);
+       retval |= mbedtls_des_crypt_ecb(&ctx_dec,des_encrypted_csn,decrypted);
 
        if(memcmp(testcase.uid,decrypted,8) != 0)
        {
@@ -678,7 +678,7 @@ int testDES2(uint64_t csn, uint64_t expected)
        print64bits("   csn ", csn);
     x_num_to_bytes(csn, 8,input);
 
-       des_crypt_ecb(&ctx_enc,input, result);
+       mbedtls_des_crypt_ecb(&ctx_enc,input, result);
 
     uint64_t crypt_csn = x_bytes_to_num(result, 8);
        print64bits("   {csn}    ", crypt_csn );
@@ -709,7 +709,7 @@ int doTestsWithKnownInputs()
        prnlog("[+] Testing foo");
        uint8_t key[8] = {0x6c,0x8d,0x44,0xf9,0x2a,0x2d,0x01,0xbf};
 
-       des_setkey_enc( &ctx_enc, key);
+       mbedtls_des_setkey_enc( &ctx_enc, key);
        testDES2(0xbbbbaaaabbbbeeee,0xd6ad3ca619659e6b);
 
        prnlog("[+] Testing hashing algorithm");
@@ -776,8 +776,8 @@ int doKeyTests(uint8_t debuglevel)
 
                        prnlog("[+] Checking key parity...");
                        des_checkParity(key);
-                       des_setkey_enc( &ctx_enc, key);
-                       des_setkey_dec( &ctx_dec, key);
+                       mbedtls_des_setkey_enc( &ctx_enc, key);
+                       mbedtls_des_setkey_dec( &ctx_dec, key);
                        // Test hashing functions
                        prnlog("[+] The following tests require the correct 8-byte master key");
                        testKeyDiversificationWithMasterkeyTestcases();
diff --git a/client/obj/polarssl/.dummy b/client/obj/polarssl/.dummy
deleted file mode 100644 (file)
index e69de29..0000000
index 0ab89b3d399ae368bdb5fe834c1ddd45127c3c66..952a5b9a62d87e4f8465d082fa3c93ff70e95de4 100644 (file)
@@ -63,7 +63,7 @@ endif
 
 
 # Also search prerequisites in the common directory (for usb.c), the fpga directory (for fpga.bit), and the zlib directory
-VPATH = . ../common ../common/crapto1 ../common/polarssl ../fpga ../zlib
+VPATH = . ../common ../common/crapto1 ../common/mbedtls ../fpga ../zlib
 
 INCLUDES = ../include/proxmark3.h ../include/at91sam7s512.h ../include/config_gpio.h ../include/usb_cmd.h $(APP_INCLUDES)
 
diff --git a/common/mbedtls/platform_util_arm.c b/common/mbedtls/platform_util_arm.c
new file mode 100644 (file)
index 0000000..13f3be0
--- /dev/null
@@ -0,0 +1,68 @@
+/*
+ * Common and shared functions used by multiple modules in the Mbed TLS
+ * library.
+ *
+ *  Copyright (C) 2018, Arm Limited, All Rights Reserved
+ *  SPDX-License-Identifier: GPL-2.0
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *  This file is part of Mbed TLS (https://tls.mbed.org)
+ */
+
+#if !defined(MBEDTLS_CONFIG_FILE)
+#include "mbedtls/config.h"
+#else
+#include MBEDTLS_CONFIG_FILE
+#endif
+
+#include "mbedtls/platform_util.h"
+
+#include <stddef.h>
+#include <string.h>
+
+#if !defined(MBEDTLS_PLATFORM_ZEROIZE_ALT)
+/*
+ * This implementation should never be optimized out by the compiler
+ *
+ * This implementation for mbedtls_platform_zeroize() was inspired from Colin
+ * Percival's blog article at:
+ *
+ * http://www.daemonology.net/blog/2014-09-04-how-to-zero-a-buffer.html
+ *
+ * It uses a volatile function pointer to the standard memset(). Because the
+ * pointer is volatile the compiler expects it to change at
+ * any time and will not optimize out the call that could potentially perform
+ * other operations on the input buffer instead of just setting it to 0.
+ * Nevertheless, as pointed out by davidtgoldblatt on Hacker News
+ * (refer to http://www.daemonology.net/blog/2014-09-05-erratum.html for
+ * details), optimizations of the following form are still possible:
+ *
+ * if( memset_func != memset )
+ *     memset_func( buf, 0, len );
+ *
+ * Note that it is extremely difficult to guarantee that
+ * mbedtls_platform_zeroize() will not be optimized out by aggressive compilers
+ * in a portable way. For this reason, Mbed TLS also provides the configuration
+ * option MBEDTLS_PLATFORM_ZEROIZE_ALT, which allows users to configure
+ * mbedtls_platform_zeroize() to use a suitable implementation for their
+ * platform and needs.
+ */
+
+void mbedtls_platform_zeroize( void *buf, size_t len )
+{
+    memset( buf, 0, len );
+}
+#endif /* MBEDTLS_PLATFORM_ZEROIZE_ALT */
diff --git a/common/mbedtls/platform_util_arm.h b/common/mbedtls/platform_util_arm.h
new file mode 100644 (file)
index 0000000..79404ce
--- /dev/null
@@ -0,0 +1,64 @@
+/**
+ * \file platform_util.h
+ *
+ * \brief Common and shared functions used by multiple modules in the Mbed TLS
+ *        library.
+ */
+/*
+ *  Copyright (C) 2018, Arm Limited, All Rights Reserved
+ *  SPDX-License-Identifier: GPL-2.0
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *  This file is part of Mbed TLS (https://tls.mbed.org)
+ */
+#ifndef MBEDTLS_PLATFORM_UTIL_H
+#define MBEDTLS_PLATFORM_UTIL_H
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * \brief       Securely zeroize a buffer
+ *
+ *              The function is meant to wipe the data contained in a buffer so
+ *              that it can no longer be recovered even if the program memory
+ *              is later compromised. Call this function on sensitive data
+ *              stored on the stack before returning from a function, and on
+ *              sensitive data stored on the heap before freeing the heap
+ *              object.
+ *
+ *              It is extremely difficult to guarantee that calls to
+ *              mbedtls_platform_zeroize() are not removed by aggressive
+ *              compiler optimizations in a portable way. For this reason, Mbed
+ *              TLS provides the configuration option
+ *              MBEDTLS_PLATFORM_ZEROIZE_ALT, which allows users to configure
+ *              mbedtls_platform_zeroize() to use a suitable implementation for
+ *              their platform and needs
+ *
+ * \param buf   Buffer to be zeroized
+ * \param len   Length of the buffer in bytes
+ *
+ */
+void mbedtls_platform_zeroize( void *buf, size_t len );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MBEDTLS_PLATFORM_UTIL_H */
diff --git a/common/polarssl/des.c b/common/polarssl/des.c
deleted file mode 100644 (file)
index b33deb6..0000000
+++ /dev/null
@@ -1,1014 +0,0 @@
-/*
- *  FIPS-46-3 compliant Triple-DES implementation
- *
- *  Copyright (C) 2006-2014, Brainspark B.V.
- *
- *  This file is part of PolarSSL (http://www.polarssl.org)
- *  Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org>
- *
- *  All rights reserved.
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along
- *  with this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- */
-/*
- *  DES, on which TDES is based, was originally designed by Horst Feistel
- *  at IBM in 1974, and was adopted as a standard by NIST (formerly NBS).
- *
- *  http://csrc.nist.gov/publications/fips/fips46-3/fips46-3.pdf
- */
-
-#include "polarssl_config.h"
-#define POLARSSL_DES_C
-
-#if defined(POLARSSL_DES_C)
-
-#include "des.h"
-
-#if defined(POLARSSL_PLATFORM_C)
-#include "polarssl/platform.h"
-#else
-#define polarssl_printf printf
-#endif
-
-#if !defined(POLARSSL_DES_ALT)
-
-/*
- * 32-bit integer manipulation macros (big endian)
- */
-#ifndef GET_UINT32_BE
-#define GET_UINT32_BE(n,b,i)                            \
-{                                                       \
-       (n) = ( (uint32_t) (b)[(i)    ] << 24 )             \
-               | ( (uint32_t) (b)[(i) + 1] << 16 )             \
-               | ( (uint32_t) (b)[(i) + 2] <<  8 )             \
-               | ( (uint32_t) (b)[(i) + 3]       );            \
-}
-#endif
-
-#ifndef PUT_UINT32_BE
-#define PUT_UINT32_BE(n,b,i)                            \
-{                                                       \
-       (b)[(i)    ] = (unsigned char) ( (n) >> 24 );       \
-       (b)[(i) + 1] = (unsigned char) ( (n) >> 16 );       \
-       (b)[(i) + 2] = (unsigned char) ( (n) >>  8 );       \
-       (b)[(i) + 3] = (unsigned char) ( (n)       );       \
-}
-#endif
-
-/*
- * Expanded DES S-boxes
- */
-static const uint32_t SB1[64] =
-{
-       0x01010400, 0x00000000, 0x00010000, 0x01010404,
-       0x01010004, 0x00010404, 0x00000004, 0x00010000,
-       0x00000400, 0x01010400, 0x01010404, 0x00000400,
-       0x01000404, 0x01010004, 0x01000000, 0x00000004,
-       0x00000404, 0x01000400, 0x01000400, 0x00010400,
-       0x00010400, 0x01010000, 0x01010000, 0x01000404,
-       0x00010004, 0x01000004, 0x01000004, 0x00010004,
-       0x00000000, 0x00000404, 0x00010404, 0x01000000,
-       0x00010000, 0x01010404, 0x00000004, 0x01010000,
-       0x01010400, 0x01000000, 0x01000000, 0x00000400,
-       0x01010004, 0x00010000, 0x00010400, 0x01000004,
-       0x00000400, 0x00000004, 0x01000404, 0x00010404,
-       0x01010404, 0x00010004, 0x01010000, 0x01000404,
-       0x01000004, 0x00000404, 0x00010404, 0x01010400,
-       0x00000404, 0x01000400, 0x01000400, 0x00000000,
-       0x00010004, 0x00010400, 0x00000000, 0x01010004
-};
-
-static const uint32_t SB2[64] =
-{
-       0x80108020, 0x80008000, 0x00008000, 0x00108020,
-       0x00100000, 0x00000020, 0x80100020, 0x80008020,
-       0x80000020, 0x80108020, 0x80108000, 0x80000000,
-       0x80008000, 0x00100000, 0x00000020, 0x80100020,
-       0x00108000, 0x00100020, 0x80008020, 0x00000000,
-       0x80000000, 0x00008000, 0x00108020, 0x80100000,
-       0x00100020, 0x80000020, 0x00000000, 0x00108000,
-       0x00008020, 0x80108000, 0x80100000, 0x00008020,
-       0x00000000, 0x00108020, 0x80100020, 0x00100000,
-       0x80008020, 0x80100000, 0x80108000, 0x00008000,
-       0x80100000, 0x80008000, 0x00000020, 0x80108020,
-       0x00108020, 0x00000020, 0x00008000, 0x80000000,
-       0x00008020, 0x80108000, 0x00100000, 0x80000020,
-       0x00100020, 0x80008020, 0x80000020, 0x00100020,
-       0x00108000, 0x00000000, 0x80008000, 0x00008020,
-       0x80000000, 0x80100020, 0x80108020, 0x00108000
-};
-
-static const uint32_t SB3[64] =
-{
-       0x00000208, 0x08020200, 0x00000000, 0x08020008,
-       0x08000200, 0x00000000, 0x00020208, 0x08000200,
-       0x00020008, 0x08000008, 0x08000008, 0x00020000,
-       0x08020208, 0x00020008, 0x08020000, 0x00000208,
-       0x08000000, 0x00000008, 0x08020200, 0x00000200,
-       0x00020200, 0x08020000, 0x08020008, 0x00020208,
-       0x08000208, 0x00020200, 0x00020000, 0x08000208,
-       0x00000008, 0x08020208, 0x00000200, 0x08000000,
-       0x08020200, 0x08000000, 0x00020008, 0x00000208,
-       0x00020000, 0x08020200, 0x08000200, 0x00000000,
-       0x00000200, 0x00020008, 0x08020208, 0x08000200,
-       0x08000008, 0x00000200, 0x00000000, 0x08020008,
-       0x08000208, 0x00020000, 0x08000000, 0x08020208,
-       0x00000008, 0x00020208, 0x00020200, 0x08000008,
-       0x08020000, 0x08000208, 0x00000208, 0x08020000,
-       0x00020208, 0x00000008, 0x08020008, 0x00020200
-};
-
-static const uint32_t SB4[64] =
-{
-       0x00802001, 0x00002081, 0x00002081, 0x00000080,
-       0x00802080, 0x00800081, 0x00800001, 0x00002001,
-       0x00000000, 0x00802000, 0x00802000, 0x00802081,
-       0x00000081, 0x00000000, 0x00800080, 0x00800001,
-       0x00000001, 0x00002000, 0x00800000, 0x00802001,
-       0x00000080, 0x00800000, 0x00002001, 0x00002080,
-       0x00800081, 0x00000001, 0x00002080, 0x00800080,
-       0x00002000, 0x00802080, 0x00802081, 0x00000081,
-       0x00800080, 0x00800001, 0x00802000, 0x00802081,
-       0x00000081, 0x00000000, 0x00000000, 0x00802000,
-       0x00002080, 0x00800080, 0x00800081, 0x00000001,
-       0x00802001, 0x00002081, 0x00002081, 0x00000080,
-       0x00802081, 0x00000081, 0x00000001, 0x00002000,
-       0x00800001, 0x00002001, 0x00802080, 0x00800081,
-       0x00002001, 0x00002080, 0x00800000, 0x00802001,
-       0x00000080, 0x00800000, 0x00002000, 0x00802080
-};
-
-static const uint32_t SB5[64] =
-{
-       0x00000100, 0x02080100, 0x02080000, 0x42000100,
-       0x00080000, 0x00000100, 0x40000000, 0x02080000,
-       0x40080100, 0x00080000, 0x02000100, 0x40080100,
-       0x42000100, 0x42080000, 0x00080100, 0x40000000,
-       0x02000000, 0x40080000, 0x40080000, 0x00000000,
-       0x40000100, 0x42080100, 0x42080100, 0x02000100,
-       0x42080000, 0x40000100, 0x00000000, 0x42000000,
-       0x02080100, 0x02000000, 0x42000000, 0x00080100,
-       0x00080000, 0x42000100, 0x00000100, 0x02000000,
-       0x40000000, 0x02080000, 0x42000100, 0x40080100,
-       0x02000100, 0x40000000, 0x42080000, 0x02080100,
-       0x40080100, 0x00000100, 0x02000000, 0x42080000,
-       0x42080100, 0x00080100, 0x42000000, 0x42080100,
-       0x02080000, 0x00000000, 0x40080000, 0x42000000,
-       0x00080100, 0x02000100, 0x40000100, 0x00080000,
-       0x00000000, 0x40080000, 0x02080100, 0x40000100
-};
-
-static const uint32_t SB6[64] =
-{
-       0x20000010, 0x20400000, 0x00004000, 0x20404010,
-       0x20400000, 0x00000010, 0x20404010, 0x00400000,
-       0x20004000, 0x00404010, 0x00400000, 0x20000010,
-       0x00400010, 0x20004000, 0x20000000, 0x00004010,
-       0x00000000, 0x00400010, 0x20004010, 0x00004000,
-       0x00404000, 0x20004010, 0x00000010, 0x20400010,
-       0x20400010, 0x00000000, 0x00404010, 0x20404000,
-       0x00004010, 0x00404000, 0x20404000, 0x20000000,
-       0x20004000, 0x00000010, 0x20400010, 0x00404000,
-       0x20404010, 0x00400000, 0x00004010, 0x20000010,
-       0x00400000, 0x20004000, 0x20000000, 0x00004010,
-       0x20000010, 0x20404010, 0x00404000, 0x20400000,
-       0x00404010, 0x20404000, 0x00000000, 0x20400010,
-       0x00000010, 0x00004000, 0x20400000, 0x00404010,
-       0x00004000, 0x00400010, 0x20004010, 0x00000000,
-       0x20404000, 0x20000000, 0x00400010, 0x20004010
-};
-
-static const uint32_t SB7[64] =
-{
-       0x00200000, 0x04200002, 0x04000802, 0x00000000,
-       0x00000800, 0x04000802, 0x00200802, 0x04200800,
-       0x04200802, 0x00200000, 0x00000000, 0x04000002,
-       0x00000002, 0x04000000, 0x04200002, 0x00000802,
-       0x04000800, 0x00200802, 0x00200002, 0x04000800,
-       0x04000002, 0x04200000, 0x04200800, 0x00200002,
-       0x04200000, 0x00000800, 0x00000802, 0x04200802,
-       0x00200800, 0x00000002, 0x04000000, 0x00200800,
-       0x04000000, 0x00200800, 0x00200000, 0x04000802,
-       0x04000802, 0x04200002, 0x04200002, 0x00000002,
-       0x00200002, 0x04000000, 0x04000800, 0x00200000,
-       0x04200800, 0x00000802, 0x00200802, 0x04200800,
-       0x00000802, 0x04000002, 0x04200802, 0x04200000,
-       0x00200800, 0x00000000, 0x00000002, 0x04200802,
-       0x00000000, 0x00200802, 0x04200000, 0x00000800,
-       0x04000002, 0x04000800, 0x00000800, 0x00200002
-};
-
-static const uint32_t SB8[64] =
-{
-       0x10001040, 0x00001000, 0x00040000, 0x10041040,
-       0x10000000, 0x10001040, 0x00000040, 0x10000000,
-       0x00040040, 0x10040000, 0x10041040, 0x00041000,
-       0x10041000, 0x00041040, 0x00001000, 0x00000040,
-       0x10040000, 0x10000040, 0x10001000, 0x00001040,
-       0x00041000, 0x00040040, 0x10040040, 0x10041000,
-       0x00001040, 0x00000000, 0x00000000, 0x10040040,
-       0x10000040, 0x10001000, 0x00041040, 0x00040000,
-       0x00041040, 0x00040000, 0x10041000, 0x00001000,
-       0x00000040, 0x10040040, 0x00001000, 0x00041040,
-       0x10001000, 0x00000040, 0x10000040, 0x10040000,
-       0x10040040, 0x10000000, 0x00040000, 0x10001040,
-       0x00000000, 0x10041040, 0x00040040, 0x10000040,
-       0x10040000, 0x10001000, 0x10001040, 0x00000000,
-       0x10041040, 0x00041000, 0x00041000, 0x00001040,
-       0x00001040, 0x00040040, 0x10000000, 0x10041000
-};
-
-/*
- * PC1: left and right halves bit-swap
- */
-static const uint32_t LHs[16] =
-{
-       0x00000000, 0x00000001, 0x00000100, 0x00000101,
-       0x00010000, 0x00010001, 0x00010100, 0x00010101,
-       0x01000000, 0x01000001, 0x01000100, 0x01000101,
-       0x01010000, 0x01010001, 0x01010100, 0x01010101
-};
-
-static const uint32_t RHs[16] =
-{
-       0x00000000, 0x01000000, 0x00010000, 0x01010000,
-       0x00000100, 0x01000100, 0x00010100, 0x01010100,
-       0x00000001, 0x01000001, 0x00010001, 0x01010001,
-       0x00000101, 0x01000101, 0x00010101, 0x01010101,
-};
-
-/*
- * Initial Permutation macro
- */
-#define DES_IP(X,Y)                                             \
-{                                                               \
-       T = ((X >>  4) ^ Y) & 0x0F0F0F0F; Y ^= T; X ^= (T <<  4);   \
-       T = ((X >> 16) ^ Y) & 0x0000FFFF; Y ^= T; X ^= (T << 16);   \
-       T = ((Y >>  2) ^ X) & 0x33333333; X ^= T; Y ^= (T <<  2);   \
-       T = ((Y >>  8) ^ X) & 0x00FF00FF; X ^= T; Y ^= (T <<  8);   \
-       Y = ((Y << 1) | (Y >> 31)) & 0xFFFFFFFF;                    \
-       T = (X ^ Y) & 0xAAAAAAAA; Y ^= T; X ^= T;                   \
-       X = ((X << 1) | (X >> 31)) & 0xFFFFFFFF;                    \
-}
-
-/*
- * Final Permutation macro
- */
-#define DES_FP(X,Y)                                             \
-{                                                               \
-       X = ((X << 31) | (X >> 1)) & 0xFFFFFFFF;                    \
-       T = (X ^ Y) & 0xAAAAAAAA; X ^= T; Y ^= T;                   \
-       Y = ((Y << 31) | (Y >> 1)) & 0xFFFFFFFF;                    \
-       T = ((Y >>  8) ^ X) & 0x00FF00FF; X ^= T; Y ^= (T <<  8);   \
-       T = ((Y >>  2) ^ X) & 0x33333333; X ^= T; Y ^= (T <<  2);   \
-       T = ((X >> 16) ^ Y) & 0x0000FFFF; Y ^= T; X ^= (T << 16);   \
-       T = ((X >>  4) ^ Y) & 0x0F0F0F0F; Y ^= T; X ^= (T <<  4);   \
-}
-
-/*
- * DES round macro
- */
-#define DES_ROUND(X,Y)                          \
-{                                               \
-       T = *SK++ ^ X;                              \
-       Y ^= SB8[ (T      ) & 0x3F ] ^              \
-                SB6[ (T >>  8) & 0x3F ] ^              \
-                SB4[ (T >> 16) & 0x3F ] ^              \
-                SB2[ (T >> 24) & 0x3F ];               \
-                                                                                               \
-       T = *SK++ ^ ((X << 28) | (X >> 4));         \
-       Y ^= SB7[ (T      ) & 0x3F ] ^              \
-                SB5[ (T >>  8) & 0x3F ] ^              \
-                SB3[ (T >> 16) & 0x3F ] ^              \
-                SB1[ (T >> 24) & 0x3F ];               \
-}
-
-#define SWAP(a,b) { uint32_t t = a; a = b; b = t; t = 0; }
-
-static const unsigned char odd_parity_table[128] = { 1,  2,  4,  7,  8,
-               11, 13, 14, 16, 19, 21, 22, 25, 26, 28, 31, 32, 35, 37, 38, 41, 42, 44,
-               47, 49, 50, 52, 55, 56, 59, 61, 62, 64, 67, 69, 70, 73, 74, 76, 79, 81,
-               82, 84, 87, 88, 91, 93, 94, 97, 98, 100, 103, 104, 107, 109, 110, 112,
-               115, 117, 118, 121, 122, 124, 127, 128, 131, 133, 134, 137, 138, 140,
-               143, 145, 146, 148, 151, 152, 155, 157, 158, 161, 162, 164, 167, 168,
-               171, 173, 174, 176, 179, 181, 182, 185, 186, 188, 191, 193, 194, 196,
-               199, 200, 203, 205, 206, 208, 211, 213, 214, 217, 218, 220, 223, 224,
-               227, 229, 230, 233, 234, 236, 239, 241, 242, 244, 247, 248, 251, 253,
-               254 };
-
-void des_key_set_parity( unsigned char key[DES_KEY_SIZE] )
-{
-       int i;
-
-       for( i = 0; i < DES_KEY_SIZE; i++ )
-               key[i] = odd_parity_table[key[i] / 2];
-}
-
-/*
- * Check the given key's parity, returns 1 on failure, 0 on SUCCESS
- */
-int des_key_check_key_parity( const unsigned char key[DES_KEY_SIZE] )
-{
-       int i;
-
-       for( i = 0; i < DES_KEY_SIZE; i++ )
-               if ( key[i] != odd_parity_table[key[i] / 2] )
-                       return( 1 );
-
-       return( 0 );
-}
-
-/*
- * Table of weak and semi-weak keys
- *
- * Source: http://en.wikipedia.org/wiki/Weak_key
- *
- * Weak:
- * Alternating ones + zeros (0x0101010101010101)
- * Alternating 'F' + 'E' (0xFEFEFEFEFEFEFEFE)
- * '0xE0E0E0E0F1F1F1F1'
- * '0x1F1F1F1F0E0E0E0E'
- *
- * Semi-weak:
- * 0x011F011F010E010E and 0x1F011F010E010E01
- * 0x01E001E001F101F1 and 0xE001E001F101F101
- * 0x01FE01FE01FE01FE and 0xFE01FE01FE01FE01
- * 0x1FE01FE00EF10EF1 and 0xE01FE01FF10EF10E
- * 0x1FFE1FFE0EFE0EFE and 0xFE1FFE1FFE0EFE0E
- * 0xE0FEE0FEF1FEF1FE and 0xFEE0FEE0FEF1FEF1
- *
- */
-
-#define WEAK_KEY_COUNT 16
-
-static const unsigned char weak_key_table[WEAK_KEY_COUNT][DES_KEY_SIZE] =
-{
-       { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
-       { 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE },
-       { 0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E },
-       { 0xE0, 0xE0, 0xE0, 0xE0, 0xF1, 0xF1, 0xF1, 0xF1 },
-
-       { 0x01, 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E },
-       { 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E, 0x01 },
-       { 0x01, 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1 },
-       { 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1, 0x01 },
-       { 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE },
-       { 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01 },
-       { 0x1F, 0xE0, 0x1F, 0xE0, 0x0E, 0xF1, 0x0E, 0xF1 },
-       { 0xE0, 0x1F, 0xE0, 0x1F, 0xF1, 0x0E, 0xF1, 0x0E },
-       { 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E, 0xFE },
-       { 0xFE, 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E },
-       { 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE },
-       { 0xFE, 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1 }
-};
-
-int des_key_check_weak( const unsigned char key[DES_KEY_SIZE] )
-{
-       int i;
-
-       for( i = 0; i < WEAK_KEY_COUNT; i++ )
-               if( memcmp( weak_key_table[i], key, DES_KEY_SIZE) == 0)
-                       return( 1 );
-
-       return( 0 );
-}
-
-static void des_setkey( uint32_t SK[32], const unsigned char key[DES_KEY_SIZE] )
-{
-       int i;
-       uint32_t X, Y, T;
-
-       GET_UINT32_BE( X, key, 0 );
-       GET_UINT32_BE( Y, key, 4 );
-
-       /*
-        * Permuted Choice 1
-        */
-       T =  ((Y >>  4) ^ X) & 0x0F0F0F0F;  X ^= T; Y ^= (T <<  4);
-       T =  ((Y      ) ^ X) & 0x10101010;  X ^= T; Y ^= (T      );
-
-       X =   (LHs[ (X      ) & 0xF] << 3) | (LHs[ (X >>  8) & 0xF ] << 2)
-               | (LHs[ (X >> 16) & 0xF] << 1) | (LHs[ (X >> 24) & 0xF ]     )
-               | (LHs[ (X >>  5) & 0xF] << 7) | (LHs[ (X >> 13) & 0xF ] << 6)
-               | (LHs[ (X >> 21) & 0xF] << 5) | (LHs[ (X >> 29) & 0xF ] << 4);
-
-       Y =   (RHs[ (Y >>  1) & 0xF] << 3) | (RHs[ (Y >>  9) & 0xF ] << 2)
-               | (RHs[ (Y >> 17) & 0xF] << 1) | (RHs[ (Y >> 25) & 0xF ]     )
-               | (RHs[ (Y >>  4) & 0xF] << 7) | (RHs[ (Y >> 12) & 0xF ] << 6)
-               | (RHs[ (Y >> 20) & 0xF] << 5) | (RHs[ (Y >> 28) & 0xF ] << 4);
-
-       X &= 0x0FFFFFFF;
-       Y &= 0x0FFFFFFF;
-
-       /*
-        * calculate subkeys
-        */
-       for( i = 0; i < 16; i++ )
-       {
-               if( i < 2 || i == 8 || i == 15 )
-               {
-                       X = ((X <<  1) | (X >> 27)) & 0x0FFFFFFF;
-                       Y = ((Y <<  1) | (Y >> 27)) & 0x0FFFFFFF;
-               }
-               else
-               {
-                       X = ((X <<  2) | (X >> 26)) & 0x0FFFFFFF;
-                       Y = ((Y <<  2) | (Y >> 26)) & 0x0FFFFFFF;
-               }
-
-               *SK++ =   ((X <<  4) & 0x24000000) | ((X << 28) & 0x10000000)
-                               | ((X << 14) & 0x08000000) | ((X << 18) & 0x02080000)
-                               | ((X <<  6) & 0x01000000) | ((X <<  9) & 0x00200000)
-                               | ((X >>  1) & 0x00100000) | ((X << 10) & 0x00040000)
-                               | ((X <<  2) & 0x00020000) | ((X >> 10) & 0x00010000)
-                               | ((Y >> 13) & 0x00002000) | ((Y >>  4) & 0x00001000)
-                               | ((Y <<  6) & 0x00000800) | ((Y >>  1) & 0x00000400)
-                               | ((Y >> 14) & 0x00000200) | ((Y      ) & 0x00000100)
-                               | ((Y >>  5) & 0x00000020) | ((Y >> 10) & 0x00000010)
-                               | ((Y >>  3) & 0x00000008) | ((Y >> 18) & 0x00000004)
-                               | ((Y >> 26) & 0x00000002) | ((Y >> 24) & 0x00000001);
-
-               *SK++ =   ((X << 15) & 0x20000000) | ((X << 17) & 0x10000000)
-                               | ((X << 10) & 0x08000000) | ((X << 22) & 0x04000000)
-                               | ((X >>  2) & 0x02000000) | ((X <<  1) & 0x01000000)
-                               | ((X << 16) & 0x00200000) | ((X << 11) & 0x00100000)
-                               | ((X <<  3) & 0x00080000) | ((X >>  6) & 0x00040000)
-                               | ((X << 15) & 0x00020000) | ((X >>  4) & 0x00010000)
-                               | ((Y >>  2) & 0x00002000) | ((Y <<  8) & 0x00001000)
-                               | ((Y >> 14) & 0x00000808) | ((Y >>  9) & 0x00000400)
-                               | ((Y      ) & 0x00000200) | ((Y <<  7) & 0x00000100)
-                               | ((Y >>  7) & 0x00000020) | ((Y >>  3) & 0x00000011)
-                               | ((Y <<  2) & 0x00000004) | ((Y >> 21) & 0x00000002);
-       }
-}
-
-/*
- * DES key schedule (56-bit, encryption)
- */
-int des_setkey_enc( des_context *ctx, const unsigned char key[DES_KEY_SIZE] )
-{
-       des_setkey( ctx->sk, key );
-
-       return( 0 );
-}
-
-/*
- * DES key schedule (56-bit, decryption)
- */
-int des_setkey_dec( des_context *ctx, const unsigned char key[DES_KEY_SIZE] )
-{
-       int i;
-
-       des_setkey( ctx->sk, key );
-
-       for( i = 0; i < 16; i += 2 )
-       {
-               SWAP( ctx->sk[i    ], ctx->sk[30 - i] );
-               SWAP( ctx->sk[i + 1], ctx->sk[31 - i] );
-       }
-
-       return( 0 );
-}
-
-static void des3_set2key( uint32_t esk[96],
-                                                 uint32_t dsk[96],
-                                                 const unsigned char key[DES_KEY_SIZE*2] )
-{
-       int i;
-
-       des_setkey( esk, key );
-       des_setkey( dsk + 32, key + 8 );
-
-       for( i = 0; i < 32; i += 2 )
-       {
-               dsk[i     ] = esk[30 - i];
-               dsk[i +  1] = esk[31 - i];
-
-               esk[i + 32] = dsk[62 - i];
-               esk[i + 33] = dsk[63 - i];
-
-               esk[i + 64] = esk[i    ];
-               esk[i + 65] = esk[i + 1];
-
-               dsk[i + 64] = dsk[i    ];
-               dsk[i + 65] = dsk[i + 1];
-       }
-}
-
-/*
- * Triple-DES key schedule (112-bit, encryption)
- */
-int des3_set2key_enc( des3_context *ctx, const unsigned char key[DES_KEY_SIZE * 2] )
-{
-       uint32_t sk[96];
-
-       des3_set2key( ctx->sk, sk, key );
-       memset( sk,  0, sizeof( sk ) );
-
-       return( 0 );
-}
-
-/*
- * Triple-DES key schedule (112-bit, decryption)
- */
-int des3_set2key_dec( des3_context *ctx, const unsigned char key[DES_KEY_SIZE * 2] )
-{
-       uint32_t sk[96];
-
-       des3_set2key( sk, ctx->sk, key );
-       memset( sk,  0, sizeof( sk ) );
-
-       return( 0 );
-}
-
-static void des3_set3key( uint32_t esk[96],
-                                                 uint32_t dsk[96],
-                                                 const unsigned char key[24] )
-{
-       int i;
-
-       des_setkey( esk, key );
-       des_setkey( dsk + 32, key +  8 );
-       des_setkey( esk + 64, key + 16 );
-
-       for( i = 0; i < 32; i += 2 )
-       {
-               dsk[i     ] = esk[94 - i];
-               dsk[i +  1] = esk[95 - i];
-
-               esk[i + 32] = dsk[62 - i];
-               esk[i + 33] = dsk[63 - i];
-
-               dsk[i + 64] = esk[30 - i];
-               dsk[i + 65] = esk[31 - i];
-       }
-}
-
-/*
- * Triple-DES key schedule (168-bit, encryption)
- */
-int des3_set3key_enc( des3_context *ctx, const unsigned char key[DES_KEY_SIZE * 3] )
-{
-       uint32_t sk[96];
-
-       des3_set3key( ctx->sk, sk, key );
-       memset( sk, 0, sizeof( sk ) );
-
-       return( 0 );
-}
-
-/*
- * Triple-DES key schedule (168-bit, decryption)
- */
-int des3_set3key_dec( des3_context *ctx, const unsigned char key[DES_KEY_SIZE * 3] )
-{
-       uint32_t sk[96];
-
-       des3_set3key( sk, ctx->sk, key );
-       memset( sk, 0, sizeof( sk ) );
-
-       return( 0 );
-}
-
-/*
- * DES-ECB block encryption/decryption
- */
-int des_crypt_ecb( des_context *ctx,
-                                       const unsigned char input[8],
-                                       unsigned char output[8] )
-{
-       int i;
-       uint32_t X, Y, T, *SK;
-
-       SK = ctx->sk;
-
-       GET_UINT32_BE( X, input, 0 );
-       GET_UINT32_BE( Y, input, 4 );
-
-       DES_IP( X, Y );
-
-       for( i = 0; i < 8; i++ )
-       {
-               DES_ROUND( Y, X );
-               DES_ROUND( X, Y );
-       }
-
-       DES_FP( Y, X );
-
-       PUT_UINT32_BE( Y, output, 0 );
-       PUT_UINT32_BE( X, output, 4 );
-
-       return( 0 );
-}
-
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-/*
- * DES-CBC buffer encryption/decryption
- */
-int des_crypt_cbc( des_context *ctx,
-                                       int mode,
-                                       size_t length,
-                                       unsigned char iv[8],
-                                       const unsigned char *input,
-                                       unsigned char *output )
-{
-       int i;
-       unsigned char temp[8];
-
-       if( length % 8 )
-               return( POLARSSL_ERR_DES_INVALID_INPUT_LENGTH );
-
-       if( mode == DES_ENCRYPT )
-       {
-               while( length > 0 )
-               {
-                       for( i = 0; i < 8; i++ )
-                               output[i] = (unsigned char)( input[i] ^ iv[i] );
-
-                       des_crypt_ecb( ctx, output, output );
-                       memcpy( iv, output, 8 );
-
-                       input  += 8;
-                       output += 8;
-                       length -= 8;
-               }
-       }
-       else /* DES_DECRYPT */
-       {
-               while( length > 0 )
-               {
-                       memcpy( temp, input, 8 );
-                       des_crypt_ecb( ctx, input, output );
-
-                       for( i = 0; i < 8; i++ )
-                               output[i] = (unsigned char)( output[i] ^ iv[i] );
-
-                       memcpy( iv, temp, 8 );
-
-                       input  += 8;
-                       output += 8;
-                       length -= 8;
-               }
-       }
-
-       return( 0 );
-}
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-
-/*
- * 3DES-ECB block encryption/decryption
- */
-int des3_crypt_ecb( des3_context *ctx,
-                                        const unsigned char input[8],
-                                        unsigned char output[8] )
-{
-       int i;
-       uint32_t X, Y, T, *SK;
-
-       SK = ctx->sk;
-
-       GET_UINT32_BE( X, input, 0 );
-       GET_UINT32_BE( Y, input, 4 );
-
-       DES_IP( X, Y );
-
-       for( i = 0; i < 8; i++ )
-       {
-               DES_ROUND( Y, X );
-               DES_ROUND( X, Y );
-       }
-
-       for( i = 0; i < 8; i++ )
-       {
-               DES_ROUND( X, Y );
-               DES_ROUND( Y, X );
-       }
-
-       for( i = 0; i < 8; i++ )
-       {
-               DES_ROUND( Y, X );
-               DES_ROUND( X, Y );
-       }
-
-       DES_FP( Y, X );
-
-       PUT_UINT32_BE( Y, output, 0 );
-       PUT_UINT32_BE( X, output, 4 );
-
-       return( 0 );
-}
-
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-/*
- * 3DES-CBC buffer encryption/decryption
- */
-int des3_crypt_cbc( des3_context *ctx,
-                                        int mode,
-                                        size_t length,
-                                        unsigned char iv[8],
-                                        const unsigned char *input,
-                                        unsigned char *output )
-{
-       int i;
-       unsigned char temp[8];
-
-       if( length % 8 )
-               return( POLARSSL_ERR_DES_INVALID_INPUT_LENGTH );
-
-       if( mode == DES_ENCRYPT )
-       {
-               while( length > 0 )
-               {
-                       for( i = 0; i < 8; i++ )
-                               output[i] = (unsigned char)( input[i] ^ iv[i] );
-
-                       des3_crypt_ecb( ctx, output, output );
-                       memcpy( iv, output, 8 );
-
-                       input  += 8;
-                       output += 8;
-                       length -= 8;
-               }
-       }
-       else /* DES_DECRYPT */
-       {
-               while( length > 0 )
-               {
-                       memcpy( temp, input, 8 );
-                       des3_crypt_ecb( ctx, input, output );
-
-                       for( i = 0; i < 8; i++ )
-                               output[i] = (unsigned char)( output[i] ^ iv[i] );
-
-                       memcpy( iv, temp, 8 );
-
-                       input  += 8;
-                       output += 8;
-                       length -= 8;
-               }
-       }
-
-       return( 0 );
-}
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-
-#endif /* !POLARSSL_DES_ALT */
-
-#if defined(POLARSSL_SELF_TEST)
-
-#include <stdio.h>
-
-/*
- * DES and 3DES test vectors from:
- *
- * http://csrc.nist.gov/groups/STM/cavp/documents/des/tripledes-vectors.zip
- */
-static const unsigned char des3_test_keys[24] =
-{
-       0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
-       0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01,
-       0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01, 0x23
-};
-
-static const unsigned char des3_test_buf[8] =
-{
-       0x4E, 0x6F, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74
-};
-
-static const unsigned char des3_test_ecb_dec[3][8] =
-{
-       { 0xCD, 0xD6, 0x4F, 0x2F, 0x94, 0x27, 0xC1, 0x5D },
-       { 0x69, 0x96, 0xC8, 0xFA, 0x47, 0xA2, 0xAB, 0xEB },
-       { 0x83, 0x25, 0x39, 0x76, 0x44, 0x09, 0x1A, 0x0A }
-};
-
-static const unsigned char des3_test_ecb_enc[3][8] =
-{
-       { 0x6A, 0x2A, 0x19, 0xF4, 0x1E, 0xCA, 0x85, 0x4B },
-       { 0x03, 0xE6, 0x9F, 0x5B, 0xFA, 0x58, 0xEB, 0x42 },
-       { 0xDD, 0x17, 0xE8, 0xB8, 0xB4, 0x37, 0xD2, 0x32 }
-};
-
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-static const unsigned char des3_test_iv[8] =
-{
-       0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF,
-};
-
-static const unsigned char des3_test_cbc_dec[3][8] =
-{
-       { 0x12, 0x9F, 0x40, 0xB9, 0xD2, 0x00, 0x56, 0xB3 },
-       { 0x47, 0x0E, 0xFC, 0x9A, 0x6B, 0x8E, 0xE3, 0x93 },
-       { 0xC5, 0xCE, 0xCF, 0x63, 0xEC, 0xEC, 0x51, 0x4C }
-};
-
-static const unsigned char des3_test_cbc_enc[3][8] =
-{
-       { 0x54, 0xF1, 0x5A, 0xF6, 0xEB, 0xE3, 0xA4, 0xB4 },
-       { 0x35, 0x76, 0x11, 0x56, 0x5F, 0xA1, 0x8E, 0x4D },
-       { 0xCB, 0x19, 0x1F, 0x85, 0xD1, 0xED, 0x84, 0x39 }
-};
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-
-/*
- * Checkup routine
- */
-int des_self_test( int verbose )
-{
-       int i, j, u, v;
-       des_context ctx;
-       des3_context ctx3;
-       unsigned char key[24];
-       unsigned char buf[8];
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-       unsigned char prv[8];
-       unsigned char iv[8];
-#endif
-
-       memset( key, 0, 24 );
-
-       /*
-        * ECB mode
-        */
-       for( i = 0; i < 6; i++ )
-       {
-               u = i >> 1;
-               v = i  & 1;
-
-               if( verbose != 0 )
-                       polarssl_printf( "  DES%c-ECB-%3d (%s): ",
-                                                        ( u == 0 ) ? ' ' : '3', 56 + u * 56,
-                                                        ( v == DES_DECRYPT ) ? "dec" : "enc" );
-
-               memcpy( buf, des3_test_buf, 8 );
-
-               switch( i )
-               {
-               case 0:
-                       des_setkey_dec( &ctx, des3_test_keys );
-                       break;
-
-               case 1:
-                       des_setkey_enc( &ctx, des3_test_keys );
-                       break;
-
-               case 2:
-                       des3_set2key_dec( &ctx3, des3_test_keys );
-                       break;
-
-               case 3:
-                       des3_set2key_enc( &ctx3, des3_test_keys );
-                       break;
-
-               case 4:
-                       des3_set3key_dec( &ctx3, des3_test_keys );
-                       break;
-
-               case 5:
-                       des3_set3key_enc( &ctx3, des3_test_keys );
-                       break;
-
-               default:
-                       return( 1 );
-               }
-
-               for( j = 0; j < 10000; j++ )
-               {
-                       if( u == 0 )
-                               des_crypt_ecb( &ctx, buf, buf );
-                       else
-                               des3_crypt_ecb( &ctx3, buf, buf );
-               }
-
-               if( ( v == DES_DECRYPT &&
-                               memcmp( buf, des3_test_ecb_dec[u], 8 ) != 0 ) ||
-                       ( v != DES_DECRYPT &&
-                               memcmp( buf, des3_test_ecb_enc[u], 8 ) != 0 ) )
-               {
-                       if( verbose != 0 )
-                               polarssl_printf( "failed\n" );
-
-                       return( 1 );
-               }
-
-               if( verbose != 0 )
-                       polarssl_printf( "passed\n" );
-       }
-
-       if( verbose != 0 )
-               polarssl_printf( "\n" );
-
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-       /*
-        * CBC mode
-        */
-       for( i = 0; i < 6; i++ )
-       {
-               u = i >> 1;
-               v = i  & 1;
-
-               if( verbose != 0 )
-                       polarssl_printf( "  DES%c-CBC-%3d (%s): ",
-                                                        ( u == 0 ) ? ' ' : '3', 56 + u * 56,
-                                                        ( v == DES_DECRYPT ) ? "dec" : "enc" );
-
-               memcpy( iv,  des3_test_iv,  8 );
-               memcpy( prv, des3_test_iv,  8 );
-               memcpy( buf, des3_test_buf, 8 );
-
-               switch( i )
-               {
-               case 0:
-                       des_setkey_dec( &ctx, des3_test_keys );
-                       break;
-
-               case 1:
-                       des_setkey_enc( &ctx, des3_test_keys );
-                       break;
-
-               case 2:
-                       des3_set2key_dec( &ctx3, des3_test_keys );
-                       break;
-
-               case 3:
-                       des3_set2key_enc( &ctx3, des3_test_keys );
-                       break;
-
-               case 4:
-                       des3_set3key_dec( &ctx3, des3_test_keys );
-                       break;
-
-               case 5:
-                       des3_set3key_enc( &ctx3, des3_test_keys );
-                       break;
-
-               default:
-                       return( 1 );
-               }
-
-               if( v == DES_DECRYPT )
-               {
-                       for( j = 0; j < 10000; j++ )
-                       {
-                               if( u == 0 )
-                                       des_crypt_cbc( &ctx, v, 8, iv, buf, buf );
-                               else
-                                       des3_crypt_cbc( &ctx3, v, 8, iv, buf, buf );
-                       }
-               }
-               else
-               {
-                       for( j = 0; j < 10000; j++ )
-                       {
-                               unsigned char tmp[8];
-
-                               if( u == 0 )
-                                       des_crypt_cbc( &ctx, v, 8, iv, buf, buf );
-                               else
-                                       des3_crypt_cbc( &ctx3, v, 8, iv, buf, buf );
-
-                               memcpy( tmp, prv, 8 );
-                               memcpy( prv, buf, 8 );
-                               memcpy( buf, tmp, 8 );
-                       }
-
-                       memcpy( buf, prv, 8 );
-               }
-
-               if( ( v == DES_DECRYPT &&
-                               memcmp( buf, des3_test_cbc_dec[u], 8 ) != 0 ) ||
-                       ( v != DES_DECRYPT &&
-                               memcmp( buf, des3_test_cbc_enc[u], 8 ) != 0 ) )
-               {
-                       if( verbose != 0 )
-                               polarssl_printf( "failed\n" );
-
-                       return( 1 );
-               }
-
-               if( verbose != 0 )
-                       polarssl_printf( "passed\n" );
-       }
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-
-       if( verbose != 0 )
-               polarssl_printf( "\n" );
-
-       return( 0 );
-}
-
-#endif
-
-#endif
diff --git a/common/polarssl/des.h b/common/polarssl/des.h
deleted file mode 100644 (file)
index 460beaf..0000000
+++ /dev/null
@@ -1,281 +0,0 @@
-/**
- * \file des.h
- *
- * \brief DES block cipher
- *
- *  Copyright (C) 2006-2013, Brainspark B.V.
- *
- *  This file is part of PolarSSL (http://www.polarssl.org)
- *  Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org>
- *
- *  All rights reserved.
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along
- *  with this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- */
-#ifndef POLARSSL_DES_H
-#define POLARSSL_DES_H
-
-//#include "config.h"
-/**
- * \def POLARSSL_CIPHER_MODE_CBC
- *
- * Enable Cipher Block Chaining mode (CBC) for symmetric ciphers.
- */
-#define POLARSSL_CIPHER_MODE_CBC
-#include <string.h>
-
-#if defined(_MSC_VER) && !defined(EFIX64) && !defined(EFI32)
-#include <basetsd.h>
-typedef UINT32 uint32_t;
-#else
-#include <inttypes.h>
-#endif
-
-#define DES_ENCRYPT     1
-#define DES_DECRYPT     0
-
-#define POLARSSL_ERR_DES_INVALID_INPUT_LENGTH              -0x0032  /**< The data input has an invalid length. */
-
-#define DES_KEY_SIZE    8
-
-#if !defined(POLARSSL_DES_ALT)
-// Regular implementation
-//
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * \brief          DES context structure
- */
-typedef struct
-{
-       int mode;                   /*!<  encrypt/decrypt   */
-       uint32_t sk[32];            /*!<  DES subkeys       */
-}
-des_context;
-
-/**
- * \brief          Triple-DES context structure
- */
-typedef struct
-{
-       int mode;                   /*!<  encrypt/decrypt   */
-       uint32_t sk[96];            /*!<  3DES subkeys      */
-}
-des3_context;
-/*
- * Triple-DES key schedule (112-bit, encryption)
- */
-int des3_set2key_enc( des3_context *ctx, const unsigned char key[DES_KEY_SIZE * 2] );
-
-/*
- * Triple-DES key schedule (112-bit, decryption)
- */
-int des3_set2key_dec( des3_context *ctx, const unsigned char key[DES_KEY_SIZE * 2] );
-
-/*
- * Triple-DES key schedule (168-bit, encryption)
- */
-int des3_set3key_enc( des3_context *ctx, const unsigned char key[DES_KEY_SIZE * 3] );
-
-/*
- * Triple-DES key schedule (168-bit, decryption)
- */
-int des3_set3key_dec( des3_context *ctx, const unsigned char key[DES_KEY_SIZE * 3] );
-
-/**
- * \brief          Set key parity on the given key to odd.
- *
- *                 DES keys are 56 bits long, but each byte is padded with
- *                 a parity bit to allow verification.
- *
- * \param key      8-byte secret key
- */
-void des_key_set_parity( unsigned char key[DES_KEY_SIZE] );
-
-/**
- * \brief          Check that key parity on the given key is odd.
- *
- *                 DES keys are 56 bits long, but each byte is padded with
- *                 a parity bit to allow verification.
- *
- * \param key      8-byte secret key
- *
- * \return         0 is parity was ok, 1 if parity was not correct.
- */
-int des_key_check_key_parity( const unsigned char key[DES_KEY_SIZE] );
-
-/**
- * \brief          Check that key is not a weak or semi-weak DES key
- *
- * \param key      8-byte secret key
- *
- * \return         0 if no weak key was found, 1 if a weak key was identified.
- */
-int des_key_check_weak( const unsigned char key[DES_KEY_SIZE] );
-
-/**
- * \brief          DES key schedule (56-bit, encryption)
- *
- * \param ctx      DES context to be initialized
- * \param key      8-byte secret key
- *
- * \return         0
- */
-int des_setkey_enc( des_context *ctx, const unsigned char key[DES_KEY_SIZE] );
-
-/**
- * \brief          DES key schedule (56-bit, decryption)
- *
- * \param ctx      DES context to be initialized
- * \param key      8-byte secret key
- *
- * \return         0
- */
-int des_setkey_dec( des_context *ctx, const unsigned char key[DES_KEY_SIZE] );
-
-/**
- * \brief          Triple-DES key schedule (112-bit, encryption)
- *
- * \param ctx      3DES context to be initialized
- * \param key      16-byte secret key
- *
- * \return         0
- */
-int des3_set2key_enc( des3_context *ctx, const unsigned char key[DES_KEY_SIZE * 2] );
-
-/**
- * \brief          Triple-DES key schedule (112-bit, decryption)
- *
- * \param ctx      3DES context to be initialized
- * \param key      16-byte secret key
- *
- * \return         0
- */
-int des3_set2key_dec( des3_context *ctx, const unsigned char key[DES_KEY_SIZE * 2] );
-
-/**
- * \brief          Triple-DES key schedule (168-bit, encryption)
- *
- * \param ctx      3DES context to be initialized
- * \param key      24-byte secret key
- *
- * \return         0
- */
-int des3_set3key_enc( des3_context *ctx, const unsigned char key[DES_KEY_SIZE * 3] );
-
-/**
- * \brief          Triple-DES key schedule (168-bit, decryption)
- *
- * \param ctx      3DES context to be initialized
- * \param key      24-byte secret key
- *
- * \return         0
- */
-int des3_set3key_dec( des3_context *ctx, const unsigned char key[DES_KEY_SIZE * 3] );
-
-/**
- * \brief          DES-ECB block encryption/decryption
- *
- * \param ctx      DES context
- * \param input    64-bit input block
- * \param output   64-bit output block
- *
- * \return         0 if successful
- */
-int des_crypt_ecb( des_context *ctx,
-                                       const unsigned char input[8],
-                                       unsigned char output[8] );
-
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-/**
- * \brief          DES-CBC buffer encryption/decryption
- *
- * \param ctx      DES context
- * \param mode     DES_ENCRYPT or DES_DECRYPT
- * \param length   length of the input data
- * \param iv       initialization vector (updated after use)
- * \param input    buffer holding the input data
- * \param output   buffer holding the output data
- */
-int des_crypt_cbc( des_context *ctx,
-                                       int mode,
-                                       size_t length,
-                                       unsigned char iv[8],
-                                       const unsigned char *input,
-                                       unsigned char *output );
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-
-/**
- * \brief          3DES-ECB block encryption/decryption
- *
- * \param ctx      3DES context
- * \param input    64-bit input block
- * \param output   64-bit output block
- *
- * \return         0 if successful
- */
-int des3_crypt_ecb( des3_context *ctx,
-                                        const unsigned char input[8],
-                                        unsigned char output[8] );
-
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-/**
- * \brief          3DES-CBC buffer encryption/decryption
- *
- * \param ctx      3DES context
- * \param mode     DES_ENCRYPT or DES_DECRYPT
- * \param length   length of the input data
- * \param iv       initialization vector (updated after use)
- * \param input    buffer holding the input data
- * \param output   buffer holding the output data
- *
- * \return         0 if successful, or POLARSSL_ERR_DES_INVALID_INPUT_LENGTH
- */
-int des3_crypt_cbc( des3_context *ctx,
-                                        int mode,
-                                        size_t length,
-                                        unsigned char iv[8],
-                                        const unsigned char *input,
-                                        unsigned char *output );
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-
-#ifdef __cplusplus
-}
-#endif
-
-#else  /* POLARSSL_DES_ALT */
-#include "des_alt.h"
-#endif /* POLARSSL_DES_ALT */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * \brief          Checkup routine
- *
- * \return         0 if successful, or 1 if the test failed
- */
-int des_self_test( int verbose );
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* des.h */
diff --git a/common/polarssl/polarssl_config.h b/common/polarssl/polarssl_config.h
deleted file mode 100644 (file)
index 3d9a2f6..0000000
+++ /dev/null
@@ -1,2179 +0,0 @@
-/**
- * \file config.h
- *
- * \brief Configuration options (set of defines)
- *
- *  Copyright (C) 2006-2014, Brainspark B.V.
- *
- *  This file is part of PolarSSL (http://www.polarssl.org)
- *  Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org>
- *
- *  All rights reserved.
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along
- *  with this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * This set of compile-time options may be used to enable
- * or disable features selectively, and reduce the global
- * memory footprint.
- */
-#ifndef POLARSSL_CONFIG_H
-#define POLARSSL_CONFIG_H
-
-#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
-#define _CRT_SECURE_NO_DEPRECATE 1
-#endif
-
-/**
- * \name SECTION: System support
- *
- * This section sets system specific settings.
- * \{
- */
-
-/**
- * \def POLARSSL_HAVE_INT8
- *
- * The system uses 8-bit wide native integers.
- *
- * Uncomment if native integers are 8-bit wide.
- */
-//#define POLARSSL_HAVE_INT8
-
-/**
- * \def POLARSSL_HAVE_INT16
- *
- * The system uses 16-bit wide native integers.
- *
- * Uncomment if native integers are 16-bit wide.
- */
-//#define POLARSSL_HAVE_INT16
-
-/**
- * \def POLARSSL_HAVE_LONGLONG
- *
- * The compiler supports the 'long long' type.
- * (Only used on 32-bit platforms)
- */
-#define POLARSSL_HAVE_LONGLONG
-
-/**
- * \def POLARSSL_HAVE_ASM
- *
- * The compiler has support for asm().
- *
- * Requires support for asm() in compiler.
- *
- * Used in:
- *      library/timing.c
- *      library/padlock.c
- *      include/polarssl/bn_mul.h
- *
- * Comment to disable the use of assembly code.
- */
-//#define POLARSSL_HAVE_ASM
-
-/**
- * \def POLARSSL_HAVE_SSE2
- *
- * CPU supports SSE2 instruction set.
- *
- * Uncomment if the CPU supports SSE2 (IA-32 specific).
- */
-//#define POLARSSL_HAVE_SSE2
-
-/**
- * \def POLARSSL_HAVE_TIME
- *
- * System has time.h and time() / localtime()  / gettimeofday().
- *
- * Comment if your system does not support time functions
- */
-#define POLARSSL_HAVE_TIME
-
-/**
- * \def POLARSSL_HAVE_IPV6
- *
- * System supports the basic socket interface for IPv6 (RFC 3493),
- * specifically getaddrinfo(), freeaddrinfo() and struct sockaddr_storage.
- *
- * Note: on Windows/MingW, XP or higher is required.
- *
- * Comment if your system does not support the IPv6 socket interface
- */
-#define POLARSSL_HAVE_IPV6
-
-/**
- * \def POLARSSL_PLATFORM_MEMORY
- *
- * Enable the memory allocation layer.
- *
- * By default PolarSSL uses the system-provided malloc() and free().
- * This allows different allocators (self-implemented or provided) to be
- * provided to the platform abstraction layer.
- *
- * Enabling POLARSSL_PLATFORM_MEMORY will provide "platform_set_malloc_free()"
- * to allow you to set an alternative malloc() and free() function pointer.
- *
- * Requires: POLARSSL_PLATFORM_C
- *
- * Enable this layer to allow use of alternative memory allocators.
- */
-//#define POLARSSL_PLATFORM_MEMORY
-
-/**
- * \def POLARSSL_PLATFORM_NO_STD_FUNCTIONS
- *
- * Do not assign standard functions in the platform layer (e.g. malloc() to
- * POLARSSL_PLATFORM_STD_MALLOC and printf() to POLARSSL_PLATFORM_STD_PRINTF)
- *
- * This makes sure there are no linking errors on platforms that do not support
- * these functions. You will HAVE to provide alternatives, either at runtime
- * via the platform_set_xxx() functions or at compile time by setting
- * the POLARSSL_PLATFORM_STD_XXX defines.
- *
- * Requires: POLARSSL_PLATFORM_C
- *
- * Uncomment to prevent default assignment of standard functions in the
- * platform layer.
- */
-//#define POLARSSL_PLATFORM_NO_STD_FUNCTIONS
-
-/**
- * \def POLARSSL_PLATFORM_XXX_ALT
- *
- * Uncomment a macro to let PolarSSL support the function in the platform
- * abstraction layer.
- *
- * Example: In case you uncomment POLARSSL_PLATFORM_PRINTF_ALT, PolarSSL will
- * provide a function "platform_set_printf()" that allows you to set an
- * alternative printf function pointer.
- *
- * All these define require POLARSSL_PLATFORM_C to be defined!
- *
- * Uncomment a macro to enable alternate implementation of specific base
- * platform function
- */
-//#define POLARSSL_PLATFORM_PRINTF_ALT
-//#define POLARSSL_PLATFORM_FPRINTF_ALT
-/* \} name SECTION: System support */
-
-/**
- * \name SECTION: PolarSSL feature support
- *
- * This section sets support for features that are or are not needed
- * within the modules that are enabled.
- * \{
- */
-
-/**
- * \def POLARSSL_TIMING_ALT
- *
- * Uncomment to provide your own alternate implementation for hardclock(),
- * get_timer(), set_alarm() and m_sleep().
- *
- * Only works if you have POLARSSL_TIMING_C enabled.
- *
- * You will need to provide a header "timing_alt.h" and an implementation at
- * compile time.
- */
-//#define POLARSSL_TIMING_ALT
-
-/**
- * \def POLARSSL_XXX_ALT
- *
- * Uncomment a macro to let PolarSSL use your alternate core implementation of
- * a symmetric or hash algorithm (e.g. platform specific assembly optimized
- * implementations). Keep in mind that the function prototypes should remain
- * the same.
- *
- * Example: In case you uncomment POLARSSL_AES_ALT, PolarSSL will no longer
- * provide the "struct aes_context" definition and omit the base function
- * declarations and implementations. "aes_alt.h" will be included from
- * "aes.h" to include the new function definitions.
- *
- * Uncomment a macro to enable alternate implementation for core algorithm
- * functions
- */
-//#define POLARSSL_AES_ALT
-//#define POLARSSL_ARC4_ALT
-//#define POLARSSL_BLOWFISH_ALT
-//#define POLARSSL_CAMELLIA_ALT
-//#define POLARSSL_DES_ALT
-//#define POLARSSL_XTEA_ALT
-//#define POLARSSL_MD2_ALT
-//#define POLARSSL_MD4_ALT
-//#define POLARSSL_MD5_ALT
-//#define POLARSSL_RIPEMD160_ALT
-//#define POLARSSL_SHA1_ALT
-//#define POLARSSL_SHA256_ALT
-//#define POLARSSL_SHA512_ALT
-
-/**
- * \def POLARSSL_AES_ROM_TABLES
- *
- * Store the AES tables in ROM.
- *
- * Uncomment this macro to store the AES tables in ROM.
- *
- */
-//#define POLARSSL_AES_ROM_TABLES
-
-/**
- * \def POLARSSL_CIPHER_MODE_CBC
- *
- * Enable Cipher Block Chaining mode (CBC) for symmetric ciphers.
- */
-#define POLARSSL_CIPHER_MODE_CBC
-
-/**
- * \def POLARSSL_CIPHER_MODE_CFB
- *
- * Enable Cipher Feedback mode (CFB) for symmetric ciphers.
- */
-#define POLARSSL_CIPHER_MODE_CFB
-
-/**
- * \def POLARSSL_CIPHER_MODE_CTR
- *
- * Enable Counter Block Cipher mode (CTR) for symmetric ciphers.
- */
-#define POLARSSL_CIPHER_MODE_CTR
-
-/**
- * \def POLARSSL_CIPHER_NULL_CIPHER
- *
- * Enable NULL cipher.
- * Warning: Only do so when you know what you are doing. This allows for
- * encryption or channels without any security!
- *
- * Requires POLARSSL_ENABLE_WEAK_CIPHERSUITES as well to enable
- * the following ciphersuites:
- *      TLS_ECDH_ECDSA_WITH_NULL_SHA
- *      TLS_ECDH_RSA_WITH_NULL_SHA
- *      TLS_ECDHE_ECDSA_WITH_NULL_SHA
- *      TLS_ECDHE_RSA_WITH_NULL_SHA
- *      TLS_ECDHE_PSK_WITH_NULL_SHA384
- *      TLS_ECDHE_PSK_WITH_NULL_SHA256
- *      TLS_ECDHE_PSK_WITH_NULL_SHA
- *      TLS_DHE_PSK_WITH_NULL_SHA384
- *      TLS_DHE_PSK_WITH_NULL_SHA256
- *      TLS_DHE_PSK_WITH_NULL_SHA
- *      TLS_RSA_WITH_NULL_SHA256
- *      TLS_RSA_WITH_NULL_SHA
- *      TLS_RSA_WITH_NULL_MD5
- *      TLS_RSA_PSK_WITH_NULL_SHA384
- *      TLS_RSA_PSK_WITH_NULL_SHA256
- *      TLS_RSA_PSK_WITH_NULL_SHA
- *      TLS_PSK_WITH_NULL_SHA384
- *      TLS_PSK_WITH_NULL_SHA256
- *      TLS_PSK_WITH_NULL_SHA
- *
- * Uncomment this macro to enable the NULL cipher and ciphersuites
- */
-//#define POLARSSL_CIPHER_NULL_CIPHER
-
-/**
- * \def POLARSSL_CIPHER_PADDING_XXX
- *
- * Uncomment or comment macros to add support for specific padding modes
- * in the cipher layer with cipher modes that support padding (e.g. CBC)
- *
- * If you disable all padding modes, only full blocks can be used with CBC.
- *
- * Enable padding modes in the cipher layer.
- */
-#define POLARSSL_CIPHER_PADDING_PKCS7
-#define POLARSSL_CIPHER_PADDING_ONE_AND_ZEROS
-#define POLARSSL_CIPHER_PADDING_ZEROS_AND_LEN
-#define POLARSSL_CIPHER_PADDING_ZEROS
-
-/**
- * \def POLARSSL_ENABLE_WEAK_CIPHERSUITES
- *
- * Enable weak ciphersuites in SSL / TLS.
- * Warning: Only do so when you know what you are doing. This allows for
- * channels with virtually no security at all!
- *
- * This enables the following ciphersuites:
- *      TLS_RSA_WITH_DES_CBC_SHA
- *      TLS_DHE_RSA_WITH_DES_CBC_SHA
- *
- * Uncomment this macro to enable weak ciphersuites
- */
-//#define POLARSSL_ENABLE_WEAK_CIPHERSUITES
-
-/**
- * \def POLARSSL_REMOVE_ARC4_CIPHERSUITES
- *
- * Remove RC4 ciphersuites by default in SSL / TLS.
- * This flag removes the ciphersuites based on RC4 from the default list as
- * returned by ssl_list_ciphersuites(). However, it is still possible to
- * enable (some of) them with ssl_set_ciphersuites() by including them
- * explicitly.
- *
- * Uncomment this macro to remove RC4 ciphersuites by default.
- */
-//#define POLARSSL_REMOVE_ARC4_CIPHERSUITES
-
-/**
- * \def POLARSSL_ECP_XXXX_ENABLED
- *
- * Enables specific curves within the Elliptic Curve module.
- * By default all supported curves are enabled.
- *
- * Comment macros to disable the curve and functions for it
- */
-#define POLARSSL_ECP_DP_SECP192R1_ENABLED
-#define POLARSSL_ECP_DP_SECP224R1_ENABLED
-#define POLARSSL_ECP_DP_SECP256R1_ENABLED
-#define POLARSSL_ECP_DP_SECP384R1_ENABLED
-#define POLARSSL_ECP_DP_SECP521R1_ENABLED
-#define POLARSSL_ECP_DP_SECP192K1_ENABLED
-#define POLARSSL_ECP_DP_SECP224K1_ENABLED
-#define POLARSSL_ECP_DP_SECP256K1_ENABLED
-#define POLARSSL_ECP_DP_BP256R1_ENABLED
-#define POLARSSL_ECP_DP_BP384R1_ENABLED
-#define POLARSSL_ECP_DP_BP512R1_ENABLED
-//#define POLARSSL_ECP_DP_M221_ENABLED  // Not implemented yet!
-#define POLARSSL_ECP_DP_M255_ENABLED
-//#define POLARSSL_ECP_DP_M383_ENABLED  // Not implemented yet!
-//#define POLARSSL_ECP_DP_M511_ENABLED  // Not implemented yet!
-
-/**
- * \def POLARSSL_ECP_NIST_OPTIM
- *
- * Enable specific 'modulo p' routines for each NIST prime.
- * Depending on the prime and architecture, makes operations 4 to 8 times
- * faster on the corresponding curve.
- *
- * Comment this macro to disable NIST curves optimisation.
- */
-#define POLARSSL_ECP_NIST_OPTIM
-
-/**
- * \def POLARSSL_ECDSA_DETERMINISTIC
- *
- * Enable deterministic ECDSA (RFC 6979).
- * Standard ECDSA is "fragile" in the sense that lack of entropy when signing
- * may result in a compromise of the long-term signing key. This is avoided by
- * the deterministic variant.
- *
- * Requires: POLARSSL_HMAC_DRBG_C
- *
- * Comment this macro to disable deterministic ECDSA.
- */
-#define POLARSSL_ECDSA_DETERMINISTIC
-
-/**
- * \def POLARSSL_KEY_EXCHANGE_PSK_ENABLED
- *
- * Enable the PSK based ciphersuite modes in SSL / TLS.
- *
- * This enables the following ciphersuites (if other requisites are
- * enabled as well):
- *      TLS_PSK_WITH_AES_256_GCM_SHA384
- *      TLS_PSK_WITH_AES_256_CBC_SHA384
- *      TLS_PSK_WITH_AES_256_CBC_SHA
- *      TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384
- *      TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384
- *      TLS_PSK_WITH_AES_128_GCM_SHA256
- *      TLS_PSK_WITH_AES_128_CBC_SHA256
- *      TLS_PSK_WITH_AES_128_CBC_SHA
- *      TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256
- *      TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256
- *      TLS_PSK_WITH_3DES_EDE_CBC_SHA
- *      TLS_PSK_WITH_RC4_128_SHA
- */
-#define POLARSSL_KEY_EXCHANGE_PSK_ENABLED
-
-/**
- * \def POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED
- *
- * Enable the DHE-PSK based ciphersuite modes in SSL / TLS.
- *
- * Requires: POLARSSL_DHM_C
- *
- * This enables the following ciphersuites (if other requisites are
- * enabled as well):
- *      TLS_DHE_PSK_WITH_AES_256_GCM_SHA384
- *      TLS_DHE_PSK_WITH_AES_256_CBC_SHA384
- *      TLS_DHE_PSK_WITH_AES_256_CBC_SHA
- *      TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384
- *      TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384
- *      TLS_DHE_PSK_WITH_AES_128_GCM_SHA256
- *      TLS_DHE_PSK_WITH_AES_128_CBC_SHA256
- *      TLS_DHE_PSK_WITH_AES_128_CBC_SHA
- *      TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256
- *      TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256
- *      TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA
- *      TLS_DHE_PSK_WITH_RC4_128_SHA
- */
-#define POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED
-
-/**
- * \def POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED
- *
- * Enable the ECDHE-PSK based ciphersuite modes in SSL / TLS.
- *
- * Requires: POLARSSL_ECDH_C
- *
- * This enables the following ciphersuites (if other requisites are
- * enabled as well):
- *      TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384
- *      TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA
- *      TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384
- *      TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256
- *      TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA
- *      TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256
- *      TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA
- *      TLS_ECDHE_PSK_WITH_RC4_128_SHA
- */
-#define POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED
-
-/**
- * \def POLARSSL_KEY_EXCHANGE_RSA_PSK_ENABLED
- *
- * Enable the RSA-PSK based ciphersuite modes in SSL / TLS.
- *
- * Requires: POLARSSL_RSA_C, POLARSSL_PKCS1_V15,
- *           POLARSSL_X509_CRT_PARSE_C
- *
- * This enables the following ciphersuites (if other requisites are
- * enabled as well):
- *      TLS_RSA_PSK_WITH_AES_256_GCM_SHA384
- *      TLS_RSA_PSK_WITH_AES_256_CBC_SHA384
- *      TLS_RSA_PSK_WITH_AES_256_CBC_SHA
- *      TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384
- *      TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384
- *      TLS_RSA_PSK_WITH_AES_128_GCM_SHA256
- *      TLS_RSA_PSK_WITH_AES_128_CBC_SHA256
- *      TLS_RSA_PSK_WITH_AES_128_CBC_SHA
- *      TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256
- *      TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256
- *      TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA
- *      TLS_RSA_PSK_WITH_RC4_128_SHA
- */
-#define POLARSSL_KEY_EXCHANGE_RSA_PSK_ENABLED
-
-/**
- * \def POLARSSL_KEY_EXCHANGE_RSA_ENABLED
- *
- * Enable the RSA-only based ciphersuite modes in SSL / TLS.
- *
- * Requires: POLARSSL_RSA_C, POLARSSL_PKCS1_V15,
- *           POLARSSL_X509_CRT_PARSE_C
- *
- * This enables the following ciphersuites (if other requisites are
- * enabled as well):
- *      TLS_RSA_WITH_AES_256_GCM_SHA384
- *      TLS_RSA_WITH_AES_256_CBC_SHA256
- *      TLS_RSA_WITH_AES_256_CBC_SHA
- *      TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384
- *      TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256
- *      TLS_RSA_WITH_CAMELLIA_256_CBC_SHA
- *      TLS_RSA_WITH_AES_128_GCM_SHA256
- *      TLS_RSA_WITH_AES_128_CBC_SHA256
- *      TLS_RSA_WITH_AES_128_CBC_SHA
- *      TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256
- *      TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256
- *      TLS_RSA_WITH_CAMELLIA_128_CBC_SHA
- *      TLS_RSA_WITH_3DES_EDE_CBC_SHA
- *      TLS_RSA_WITH_RC4_128_SHA
- *      TLS_RSA_WITH_RC4_128_MD5
- */
-#define POLARSSL_KEY_EXCHANGE_RSA_ENABLED
-
-/**
- * \def POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED
- *
- * Enable the DHE-RSA based ciphersuite modes in SSL / TLS.
- *
- * Requires: POLARSSL_DHM_C, POLARSSL_RSA_C, POLARSSL_PKCS1_V15,
- *           POLARSSL_X509_CRT_PARSE_C
- *
- * This enables the following ciphersuites (if other requisites are
- * enabled as well):
- *      TLS_DHE_RSA_WITH_AES_256_GCM_SHA384
- *      TLS_DHE_RSA_WITH_AES_256_CBC_SHA256
- *      TLS_DHE_RSA_WITH_AES_256_CBC_SHA
- *      TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384
- *      TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256
- *      TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA
- *      TLS_DHE_RSA_WITH_AES_128_GCM_SHA256
- *      TLS_DHE_RSA_WITH_AES_128_CBC_SHA256
- *      TLS_DHE_RSA_WITH_AES_128_CBC_SHA
- *      TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256
- *      TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256
- *      TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA
- *      TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA
- */
-#define POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED
-
-/**
- * \def POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED
- *
- * Enable the ECDHE-RSA based ciphersuite modes in SSL / TLS.
- *
- * Requires: POLARSSL_ECDH_C, POLARSSL_RSA_C, POLARSSL_PKCS1_V15,
- *           POLARSSL_X509_CRT_PARSE_C
- *
- * This enables the following ciphersuites (if other requisites are
- * enabled as well):
- *      TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384
- *      TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384
- *      TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA
- *      TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384
- *      TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384
- *      TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
- *      TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256
- *      TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA
- *      TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256
- *      TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256
- *      TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA
- *      TLS_ECDHE_RSA_WITH_RC4_128_SHA
- */
-#define POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED
-
-/**
- * \def POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED
- *
- * Enable the ECDHE-ECDSA based ciphersuite modes in SSL / TLS.
- *
- * Requires: POLARSSL_ECDH_C, POLARSSL_ECDSA_C, POLARSSL_X509_CRT_PARSE_C,
- *
- * This enables the following ciphersuites (if other requisites are
- * enabled as well):
- *      TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384
- *      TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384
- *      TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA
- *      TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384
- *      TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384
- *      TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
- *      TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256
- *      TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA
- *      TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256
- *      TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256
- *      TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA
- *      TLS_ECDHE_ECDSA_WITH_RC4_128_SHA
- */
-#define POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED
-
-/**
- * \def POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED
- *
- * Enable the ECDH-ECDSA based ciphersuite modes in SSL / TLS.
- *
- * Requires: POLARSSL_ECDH_C, POLARSSL_X509_CRT_PARSE_C
- *
- * This enables the following ciphersuites (if other requisites are
- * enabled as well):
- *      TLS_ECDH_ECDSA_WITH_RC4_128_SHA
- *      TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA
- *      TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA
- *      TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA
- *      TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256
- *      TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384
- *      TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256
- *      TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384
- *      TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256
- *      TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384
- *      TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256
- *      TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384
- */
-#define POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED
-
-/**
- * \def POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED
- *
- * Enable the ECDH-RSA based ciphersuite modes in SSL / TLS.
- *
- * Requires: POLARSSL_ECDH_C, POLARSSL_X509_CRT_PARSE_C
- *
- * This enables the following ciphersuites (if other requisites are
- * enabled as well):
- *      TLS_ECDH_RSA_WITH_RC4_128_SHA
- *      TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA
- *      TLS_ECDH_RSA_WITH_AES_128_CBC_SHA
- *      TLS_ECDH_RSA_WITH_AES_256_CBC_SHA
- *      TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256
- *      TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384
- *      TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256
- *      TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384
- *      TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256
- *      TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384
- *      TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256
- *      TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384
- */
-#define POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED
-
-/**
- * \def POLARSSL_PK_PARSE_EC_EXTENDED
- *
- * Enhance support for reading EC keys using variants of SEC1 not allowed by
- * RFC 5915 and RFC 5480.
- *
- * Currently this means parsing the SpecifiedECDomain choice of EC
- * parameters (only known groups are supported, not arbitrary domains, to
- * avoid validation issues).
- *
- * Disable if you only need to support RFC 5915 + 5480 key formats.
- */
-#define POLARSSL_PK_PARSE_EC_EXTENDED
-
-/**
- * \def POLARSSL_ERROR_STRERROR_BC
- *
- * Make available the backward compatible error_strerror() next to the
- * current polarssl_strerror().
- *
- * For new code, it is recommended to use polarssl_strerror() instead and
- * disable this.
- *
- * Disable if you run into name conflicts and want to really remove the
- * error_strerror()
- */
-#define POLARSSL_ERROR_STRERROR_BC
-
-/**
- * \def POLARSSL_ERROR_STRERROR_DUMMY
- *
- * Enable a dummy error function to make use of polarssl_strerror() in
- * third party libraries easier when POLARSSL_ERROR_C is disabled
- * (no effect when POLARSSL_ERROR_C is enabled).
- *
- * You can safely disable this if POLARSSL_ERROR_C is enabled, or if you're
- * not using polarssl_strerror() or error_strerror() in your application.
- *
- * Disable if you run into name conflicts and want to really remove the
- * polarssl_strerror()
- */
-#define POLARSSL_ERROR_STRERROR_DUMMY
-
-/**
- * \def POLARSSL_GENPRIME
- *
- * Enable the prime-number generation code.
- *
- * Requires: POLARSSL_BIGNUM_C
- */
-#define POLARSSL_GENPRIME
-
-/**
- * \def POLARSSL_FS_IO
- *
- * Enable functions that use the filesystem.
- */
-#define POLARSSL_FS_IO
-
-/**
- * \def POLARSSL_NO_DEFAULT_ENTROPY_SOURCES
- *
- * Do not add default entropy sources. These are the platform specific,
- * hardclock and HAVEGE based poll functions.
- *
- * This is useful to have more control over the added entropy sources in an
- * application.
- *
- * Uncomment this macro to prevent loading of default entropy functions.
- */
-//#define POLARSSL_NO_DEFAULT_ENTROPY_SOURCES
-
-/**
- * \def POLARSSL_NO_PLATFORM_ENTROPY
- *
- * Do not use built-in platform entropy functions.
- * This is useful if your platform does not support
- * standards like the /dev/urandom or Windows CryptoAPI.
- *
- * Uncomment this macro to disable the built-in platform entropy functions.
- */
-//#define POLARSSL_NO_PLATFORM_ENTROPY
-
-/**
- * \def POLARSSL_ENTROPY_FORCE_SHA256
- *
- * Force the entropy accumulator to use a SHA-256 accumulator instead of the
- * default SHA-512 based one (if both are available).
- *
- * Requires: POLARSSL_SHA256_C
- *
- * On 32-bit systems SHA-256 can be much faster than SHA-512. Use this option
- * if you have performance concerns.
- *
- * This option is only useful if both POLARSSL_SHA256_C and
- * POLARSSL_SHA512_C are defined. Otherwise the available hash module is used.
- */
-//#define POLARSSL_ENTROPY_FORCE_SHA256
-
-/**
- * \def POLARSSL_MEMORY_DEBUG
- *
- * Enable debugging of buffer allocator memory issues. Automatically prints
- * (to stderr) all (fatal) messages on memory allocation issues. Enables
- * function for 'debug output' of allocated memory.
- *
- * Requires: POLARSSL_MEMORY_BUFFER_ALLOC_C
- *
- * Uncomment this macro to let the buffer allocator print out error messages.
- */
-//#define POLARSSL_MEMORY_DEBUG
-
-/**
- * \def POLARSSL_MEMORY_BACKTRACE
- *
- * Include backtrace information with each allocated block.
- *
- * Requires: POLARSSL_MEMORY_BUFFER_ALLOC_C
- *           GLIBC-compatible backtrace() an backtrace_symbols() support
- *
- * Uncomment this macro to include backtrace information
- */
-//#define POLARSSL_MEMORY_BACKTRACE
-
-/**
- * \def POLARSSL_PKCS1_V15
- *
- * Enable support for PKCS#1 v1.5 encoding.
- *
- * Requires: POLARSSL_RSA_C
- *
- * This enables support for PKCS#1 v1.5 operations.
- */
-#define POLARSSL_PKCS1_V15
-
-/**
- * \def POLARSSL_PKCS1_V21
- *
- * Enable support for PKCS#1 v2.1 encoding.
- *
- * Requires: POLARSSL_MD_C, POLARSSL_RSA_C
- *
- * This enables support for RSAES-OAEP and RSASSA-PSS operations.
- */
-//#define POLARSSL_PKCS1_V21
-
-/**
- * \def POLARSSL_RSA_NO_CRT
- *
- * Do not use the Chinese Remainder Theorem for the RSA private operation.
- *
- * Uncomment this macro to disable the use of CRT in RSA.
- *
- */
-//#define POLARSSL_RSA_NO_CRT
-
-/**
- * \def POLARSSL_SELF_TEST
- *
- * Enable the checkup functions (*_self_test).
- */
-#define POLARSSL_SELF_TEST
-
-/**
- * \def POLARSSL_SSL_ALL_ALERT_MESSAGES
- *
- * Enable sending of alert messages in case of encountered errors as per RFC.
- * If you choose not to send the alert messages, PolarSSL can still communicate
- * with other servers, only debugging of failures is harder.
- *
- * The advantage of not sending alert messages, is that no information is given
- * about reasons for failures thus preventing adversaries of gaining intel.
- *
- * Enable sending of all alert messages
- */
-#define POLARSSL_SSL_ALERT_MESSAGES
-
-/**
- * \def POLARSSL_SSL_DEBUG_ALL
- *
- * Enable the debug messages in SSL module for all issues.
- * Debug messages have been disabled in some places to prevent timing
- * attacks due to (unbalanced) debugging function calls.
- *
- * If you need all error reporting you should enable this during debugging,
- * but remove this for production servers that should log as well.
- *
- * Uncomment this macro to report all debug messages on errors introducing
- * a timing side-channel.
- *
- */
-//#define POLARSSL_SSL_DEBUG_ALL
-
-/**
- * \def POLARSSL_SSL_HW_RECORD_ACCEL
- *
- * Enable hooking functions in SSL module for hardware acceleration of
- * individual records.
- *
- * Uncomment this macro to enable hooking functions.
- */
-//#define POLARSSL_SSL_HW_RECORD_ACCEL
-
-/**
- * \def POLARSSL_SSL_SRV_SUPPORT_SSLV2_CLIENT_HELLO
- *
- * Enable support for receiving and parsing SSLv2 Client Hello messages for the
- * SSL Server module (POLARSSL_SSL_SRV_C).
- *
- * Comment this macro to disable support for SSLv2 Client Hello messages.
- */
-#define POLARSSL_SSL_SRV_SUPPORT_SSLV2_CLIENT_HELLO
-
-/**
- * \def POLARSSL_SSL_SRV_RESPECT_CLIENT_PREFERENCE
- *
- * Pick the ciphersuite according to the client's preferences rather than ours
- * in the SSL Server module (POLARSSL_SSL_SRV_C).
- *
- * Uncomment this macro to respect client's ciphersuite order
- */
-//#define POLARSSL_SSL_SRV_RESPECT_CLIENT_PREFERENCE
-
-/**
- * \def POLARSSL_SSL_MAX_FRAGMENT_LENGTH
- *
- * Enable support for RFC 6066 max_fragment_length extension in SSL.
- *
- * Comment this macro to disable support for the max_fragment_length extension
- */
-#define POLARSSL_SSL_MAX_FRAGMENT_LENGTH
-
-/**
- * \def POLARSSL_SSL_PROTO_SSL3
- *
- * Enable support for SSL 3.0.
- *
- * Requires: POLARSSL_MD5_C
- *           POLARSSL_SHA1_C
- *
- * Comment this macro to disable support for SSL 3.0
- */
-#define POLARSSL_SSL_PROTO_SSL3
-
-/**
- * \def POLARSSL_SSL_PROTO_TLS1
- *
- * Enable support for TLS 1.0.
- *
- * Requires: POLARSSL_MD5_C
- *           POLARSSL_SHA1_C
- *
- * Comment this macro to disable support for TLS 1.0
- */
-#define POLARSSL_SSL_PROTO_TLS1
-
-/**
- * \def POLARSSL_SSL_PROTO_TLS1_1
- *
- * Enable support for TLS 1.1.
- *
- * Requires: POLARSSL_MD5_C
- *           POLARSSL_SHA1_C
- *
- * Comment this macro to disable support for TLS 1.1
- */
-#define POLARSSL_SSL_PROTO_TLS1_1
-
-/**
- * \def POLARSSL_SSL_PROTO_TLS1_2
- *
- * Enable support for TLS 1.2.
- *
- * Requires: POLARSSL_SHA1_C or POLARSSL_SHA256_C or POLARSSL_SHA512_C
- *           (Depends on ciphersuites)
- *
- * Comment this macro to disable support for TLS 1.2
- */
-#define POLARSSL_SSL_PROTO_TLS1_2
-
-/**
- * \def POLARSSL_SSL_ALPN
- *
- * Enable support for Application Layer Protocol Negotiation.
- * draft-ietf-tls-applayerprotoneg-05
- *
- * Comment this macro to disable support for ALPN.
- */
-#define POLARSSL_SSL_ALPN
-
-/**
- * \def POLARSSL_SSL_SESSION_TICKETS
- *
- * Enable support for RFC 5077 session tickets in SSL.
- *
- * Requires: POLARSSL_AES_C
- *           POLARSSL_SHA256_C
- *           POLARSSL_CIPHER_MODE_CBC
- *
- * Comment this macro to disable support for SSL session tickets
- */
-#define POLARSSL_SSL_SESSION_TICKETS
-
-/**
- * \def POLARSSL_SSL_SERVER_NAME_INDICATION
- *
- * Enable support for RFC 6066 server name indication (SNI) in SSL.
- *
- * Comment this macro to disable support for server name indication in SSL
- */
-#define POLARSSL_SSL_SERVER_NAME_INDICATION
-
-/**
- * \def POLARSSL_SSL_TRUNCATED_HMAC
- *
- * Enable support for RFC 6066 truncated HMAC in SSL.
- *
- * Comment this macro to disable support for truncated HMAC in SSL
- */
-#define POLARSSL_SSL_TRUNCATED_HMAC
-
-/**
- * \def POLARSSL_SSL_SET_CURVES
- *
- * Enable ssl_set_curves().
- *
- * This is disabled by default since it breaks binary compatibility with the
- * 1.3.x line. If you choose to enable it, you will need to rebuild your
- * application against the new header files, relinking will not be enough.
- * It will be enabled by default, or no longer an option, in the 1.4 branch.
- *
- * Uncomment to make ssl_set_curves() available.
- */
-//#define POLARSSL_SSL_SET_CURVES
-
-/**
- * \def POLARSSL_THREADING_ALT
- *
- * Provide your own alternate threading implementation.
- *
- * Requires: POLARSSL_THREADING_C
- *
- * Uncomment this to allow your own alternate threading implementation.
- */
-//#define POLARSSL_THREADING_ALT
-
-/**
- * \def POLARSSL_THREADING_PTHREAD
- *
- * Enable the pthread wrapper layer for the threading layer.
- *
- * Requires: POLARSSL_THREADING_C
- *
- * Uncomment this to enable pthread mutexes.
- */
-//#define POLARSSL_THREADING_PTHREAD
-
-/**
- * \def POLARSSL_VERSION_FEATURES
- *
- * Allow run-time checking of compile-time enabled features. Thus allowing users
- * to check at run-time if the library is for instance compiled with threading
- * support via version_check_feature().
- *
- * Requires: POLARSSL_VERSION_C
- *
- * Comment this to disable run-time checking and save ROM space
- */
-#define POLARSSL_VERSION_FEATURES
-
-/**
- * \def POLARSSL_X509_ALLOW_EXTENSIONS_NON_V3
- *
- * If set, the X509 parser will not break-off when parsing an X509 certificate
- * and encountering an extension in a v1 or v2 certificate.
- *
- * Uncomment to prevent an error.
- */
-//#define POLARSSL_X509_ALLOW_EXTENSIONS_NON_V3
-
-/**
- * \def POLARSSL_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION
- *
- * If set, the X509 parser will not break-off when parsing an X509 certificate
- * and encountering an unknown critical extension.
- *
- * Uncomment to prevent an error.
- */
-//#define POLARSSL_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION
-
-/**
- * \def POLARSSL_X509_CHECK_KEY_USAGE
- *
- * Enable verification of the keyUsage extension (CA and leaf certificates).
- *
- * Disabling this avoids problems with mis-issued and/or misused
- * (intermediate) CA and leaf certificates.
- *
- * \warning Depending on your PKI use, disabling this can be a security risk!
- *
- * Comment to skip keyUsage checking for both CA and leaf certificates.
- */
-#define POLARSSL_X509_CHECK_KEY_USAGE
-
-/**
- * \def POLARSSL_X509_CHECK_EXTENDED_KEY_USAGE
- *
- * Enable verification of the extendedKeyUsage extension (leaf certificates).
- *
- * Disabling this avoids problems with mis-issued and/or misused certificates.
- *
- * \warning Depending on your PKI use, disabling this can be a security risk!
- *
- * Comment to skip extendedKeyUsage checking for certificates.
- */
-#define POLARSSL_X509_CHECK_EXTENDED_KEY_USAGE
-
-/**
- * \def POLARSSL_X509_RSASSA_PSS_SUPPORT
- *
- * Enable parsing and verification of X.509 certificates, CRLs and CSRS
- * signed with RSASSA-PSS (aka PKCS#1 v2.1).
- *
- * Comment this macro to disallow using RSASSA-PSS in certificates.
- */
-#define POLARSSL_X509_RSASSA_PSS_SUPPORT
-
-/**
- * \def POLARSSL_ZLIB_SUPPORT
- *
- * If set, the SSL/TLS module uses ZLIB to support compression and
- * decompression of packet data.
- *
- * \warning TLS-level compression MAY REDUCE SECURITY! See for example the
- * CRIME attack. Before enabling this option, you should examine with care if
- * CRIME or similar exploits may be a applicable to your use case.
- *
- * Used in: library/ssl_tls.c
- *          library/ssl_cli.c
- *          library/ssl_srv.c
- *
- * This feature requires zlib library and headers to be present.
- *
- * Uncomment to enable use of ZLIB
- */
-//#define POLARSSL_ZLIB_SUPPORT
-/* \} name SECTION: PolarSSL feature support */
-
-/**
- * \name SECTION: PolarSSL modules
- *
- * This section enables or disables entire modules in PolarSSL
- * \{
- */
-
-/**
- * \def POLARSSL_AESNI_C
- *
- * Enable AES-NI support on x86-64.
- *
- * Module:  library/aesni.c
- * Caller:  library/aes.c
- *
- * Requires: POLARSSL_HAVE_ASM
- *
- * This modules adds support for the AES-NI instructions on x86-64
- */
-//#define POLARSSL_AESNI_C
-
-/**
- * \def POLARSSL_AES_C
- *
- * Enable the AES block cipher.
- *
- * Module:  library/aes.c
- * Caller:  library/ssl_tls.c
- *          library/pem.c
- *          library/ctr_drbg.c
- *
- * This module enables the following ciphersuites (if other requisites are
- * enabled as well):
- *      TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA
- *      TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA
- *      TLS_ECDH_RSA_WITH_AES_128_CBC_SHA
- *      TLS_ECDH_RSA_WITH_AES_256_CBC_SHA
- *      TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256
- *      TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384
- *      TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256
- *      TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384
- *      TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256
- *      TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384
- *      TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256
- *      TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384
- *      TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384
- *      TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384
- *      TLS_DHE_RSA_WITH_AES_256_GCM_SHA384
- *      TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384
- *      TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384
- *      TLS_DHE_RSA_WITH_AES_256_CBC_SHA256
- *      TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA
- *      TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA
- *      TLS_DHE_RSA_WITH_AES_256_CBC_SHA
- *      TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
- *      TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
- *      TLS_DHE_RSA_WITH_AES_128_GCM_SHA256
- *      TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256
- *      TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256
- *      TLS_DHE_RSA_WITH_AES_128_CBC_SHA256
- *      TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA
- *      TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA
- *      TLS_DHE_RSA_WITH_AES_128_CBC_SHA
- *      TLS_DHE_PSK_WITH_AES_256_GCM_SHA384
- *      TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384
- *      TLS_DHE_PSK_WITH_AES_256_CBC_SHA384
- *      TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA
- *      TLS_DHE_PSK_WITH_AES_256_CBC_SHA
- *      TLS_DHE_PSK_WITH_AES_128_GCM_SHA256
- *      TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256
- *      TLS_DHE_PSK_WITH_AES_128_CBC_SHA256
- *      TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA
- *      TLS_DHE_PSK_WITH_AES_128_CBC_SHA
- *      TLS_RSA_WITH_AES_256_GCM_SHA384
- *      TLS_RSA_WITH_AES_256_CBC_SHA256
- *      TLS_RSA_WITH_AES_256_CBC_SHA
- *      TLS_RSA_WITH_AES_128_GCM_SHA256
- *      TLS_RSA_WITH_AES_128_CBC_SHA256
- *      TLS_RSA_WITH_AES_128_CBC_SHA
- *      TLS_RSA_PSK_WITH_AES_256_GCM_SHA384
- *      TLS_RSA_PSK_WITH_AES_256_CBC_SHA384
- *      TLS_RSA_PSK_WITH_AES_256_CBC_SHA
- *      TLS_RSA_PSK_WITH_AES_128_GCM_SHA256
- *      TLS_RSA_PSK_WITH_AES_128_CBC_SHA256
- *      TLS_RSA_PSK_WITH_AES_128_CBC_SHA
- *      TLS_PSK_WITH_AES_256_GCM_SHA384
- *      TLS_PSK_WITH_AES_256_CBC_SHA384
- *      TLS_PSK_WITH_AES_256_CBC_SHA
- *      TLS_PSK_WITH_AES_128_GCM_SHA256
- *      TLS_PSK_WITH_AES_128_CBC_SHA256
- *      TLS_PSK_WITH_AES_128_CBC_SHA
- *
- * PEM_PARSE uses AES for decrypting encrypted keys.
- */
-#define POLARSSL_AES_C
-
-/**
- * \def POLARSSL_ARC4_C
- *
- * Enable the ARCFOUR stream cipher.
- *
- * Module:  library/arc4.c
- * Caller:  library/ssl_tls.c
- *
- * This module enables the following ciphersuites (if other requisites are
- * enabled as well):
- *      TLS_ECDH_ECDSA_WITH_RC4_128_SHA
- *      TLS_ECDH_RSA_WITH_RC4_128_SHA
- *      TLS_ECDHE_ECDSA_WITH_RC4_128_SHA
- *      TLS_ECDHE_RSA_WITH_RC4_128_SHA
- *      TLS_ECDHE_PSK_WITH_RC4_128_SHA
- *      TLS_DHE_PSK_WITH_RC4_128_SHA
- *      TLS_RSA_WITH_RC4_128_SHA
- *      TLS_RSA_WITH_RC4_128_MD5
- *      TLS_RSA_PSK_WITH_RC4_128_SHA
- *      TLS_PSK_WITH_RC4_128_SHA
- */
-#define POLARSSL_ARC4_C
-
-/**
- * \def POLARSSL_ASN1_PARSE_C
- *
- * Enable the generic ASN1 parser.
- *
- * Module:  library/asn1.c
- * Caller:  library/x509.c
- *          library/dhm.c
- *          library/pkcs12.c
- *          library/pkcs5.c
- *          library/pkparse.c
- */
-#define POLARSSL_ASN1_PARSE_C
-
-/**
- * \def POLARSSL_ASN1_WRITE_C
- *
- * Enable the generic ASN1 writer.
- *
- * Module:  library/asn1write.c
- * Caller:  library/ecdsa.c
- *          library/pkwrite.c
- *          library/x509_create.c
- *          library/x509write_crt.c
- *          library/x509write_csr.c
- */
-#define POLARSSL_ASN1_WRITE_C
-
-/**
- * \def POLARSSL_BASE64_C
- *
- * Enable the Base64 module.
- *
- * Module:  library/base64.c
- * Caller:  library/pem.c
- *
- * This module is required for PEM support (required by X.509).
- */
-#define POLARSSL_BASE64_C
-
-/**
- * \def POLARSSL_BIGNUM_C
- *
- * Enable the multi-precision integer library.
- *
- * Module:  library/bignum.c
- * Caller:  library/dhm.c
- *          library/ecp.c
- *          library/ecdsa.c
- *          library/rsa.c
- *          library/ssl_tls.c
- *
- * This module is required for RSA, DHM and ECC (ECDH, ECDSA) support.
- */
-#define POLARSSL_BIGNUM_C
-
-/**
- * \def POLARSSL_BLOWFISH_C
- *
- * Enable the Blowfish block cipher.
- *
- * Module:  library/blowfish.c
- */
-#define POLARSSL_BLOWFISH_C
-
-/**
- * \def POLARSSL_CAMELLIA_C
- *
- * Enable the Camellia block cipher.
- *
- * Module:  library/camellia.c
- * Caller:  library/ssl_tls.c
- *
- * This module enables the following ciphersuites (if other requisites are
- * enabled as well):
- *      TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256
- *      TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384
- *      TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256
- *      TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384
- *      TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256
- *      TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384
- *      TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256
- *      TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384
- *      TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384
- *      TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384
- *      TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384
- *      TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384
- *      TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384
- *      TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256
- *      TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA
- *      TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256
- *      TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256
- *      TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256
- *      TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256
- *      TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256
- *      TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256
- *      TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA
- *      TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384
- *      TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384
- *      TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384
- *      TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256
- *      TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256
- *      TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256
- *      TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384
- *      TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256
- *      TLS_RSA_WITH_CAMELLIA_256_CBC_SHA
- *      TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256
- *      TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256
- *      TLS_RSA_WITH_CAMELLIA_128_CBC_SHA
- *      TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384
- *      TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384
- *      TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256
- *      TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256
- *      TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384
- *      TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384
- *      TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256
- *      TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256
- */
-#define POLARSSL_CAMELLIA_C
-
-/**
- * \def POLARSSL_CCM_C
- *
- * Enable the Counter with CBC-MAC (CCM) mode for 128-bit block cipher.
- *
- * Module:  library/ccm.c
- *
- * Requires: POLARSSL_AES_C or POLARSSL_CAMELLIA_C
- *
- * This module enables the AES-CCM ciphersuites, if other requisites are
- * enabled as well.
- */
-#define POLARSSL_CCM_C
-
-/**
- * \def POLARSSL_CERTS_C
- *
- * Enable the test certificates.
- *
- * Module:  library/certs.c
- * Caller:
- *
- * Requires: POLARSSL_PEM_PARSE_C
- *
- * This module is used for testing (ssl_client/server).
- */
-#define POLARSSL_CERTS_C
-
-/**
- * \def POLARSSL_CIPHER_C
- *
- * Enable the generic cipher layer.
- *
- * Module:  library/cipher.c
- * Caller:  library/ssl_tls.c
- *
- * Uncomment to enable generic cipher wrappers.
- */
-#define POLARSSL_CIPHER_C
-
-/**
- * \def POLARSSL_CTR_DRBG_C
- *
- * Enable the CTR_DRBG AES-256-based random generator.
- *
- * Module:  library/ctr_drbg.c
- * Caller:
- *
- * Requires: POLARSSL_AES_C
- *
- * This module provides the CTR_DRBG AES-256 random number generator.
- */
-#define POLARSSL_CTR_DRBG_C
-
-/**
- * \def POLARSSL_DEBUG_C
- *
- * Enable the debug functions.
- *
- * Module:  library/debug.c
- * Caller:  library/ssl_cli.c
- *          library/ssl_srv.c
- *          library/ssl_tls.c
- *
- * This module provides debugging functions.
- */
-#define POLARSSL_DEBUG_C
-
-/**
- * \def POLARSSL_DES_C
- *
- * Enable the DES block cipher.
- *
- * Module:  library/des.c
- * Caller:  library/pem.c
- *          library/ssl_tls.c
- *
- * This module enables the following ciphersuites (if other requisites are
- * enabled as well):
- *      TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA
- *      TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA
- *      TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA
- *      TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA
- *      TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA
- *      TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA
- *      TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA
- *      TLS_RSA_WITH_3DES_EDE_CBC_SHA
- *      TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA
- *      TLS_PSK_WITH_3DES_EDE_CBC_SHA
- *
- * PEM_PARSE uses DES/3DES for decrypting encrypted keys.
- */
-#define POLARSSL_DES_C
-
-/**
- * \def POLARSSL_DHM_C
- *
- * Enable the Diffie-Hellman-Merkle module.
- *
- * Module:  library/dhm.c
- * Caller:  library/ssl_cli.c
- *          library/ssl_srv.c
- *
- * This module is used by the following key exchanges:
- *      DHE-RSA, DHE-PSK
- */
-#define POLARSSL_DHM_C
-
-/**
- * \def POLARSSL_ECDH_C
- *
- * Enable the elliptic curve Diffie-Hellman library.
- *
- * Module:  library/ecdh.c
- * Caller:  library/ssl_cli.c
- *          library/ssl_srv.c
- *
- * This module is used by the following key exchanges:
- *      ECDHE-ECDSA, ECDHE-RSA, DHE-PSK
- *
- * Requires: POLARSSL_ECP_C
- */
-#define POLARSSL_ECDH_C
-
-/**
- * \def POLARSSL_ECDSA_C
- *
- * Enable the elliptic curve DSA library.
- *
- * Module:  library/ecdsa.c
- * Caller:
- *
- * This module is used by the following key exchanges:
- *      ECDHE-ECDSA
- *
- * Requires: POLARSSL_ECP_C, POLARSSL_ASN1_WRITE_C, POLARSSL_ASN1_PARSE_C
- */
-#define POLARSSL_ECDSA_C
-
-/**
- * \def POLARSSL_ECP_C
- *
- * Enable the elliptic curve over GF(p) library.
- *
- * Module:  library/ecp.c
- * Caller:  library/ecdh.c
- *          library/ecdsa.c
- *
- * Requires: POLARSSL_BIGNUM_C and at least one POLARSSL_ECP_DP_XXX_ENABLED
- */
-#define POLARSSL_ECP_C
-
-/**
- * \def POLARSSL_ENTROPY_C
- *
- * Enable the platform-specific entropy code.
- *
- * Module:  library/entropy.c
- * Caller:
- *
- * Requires: POLARSSL_SHA512_C or POLARSSL_SHA256_C
- *
- * This module provides a generic entropy pool
- */
-#define POLARSSL_ENTROPY_C
-
-/**
- * \def POLARSSL_ERROR_C
- *
- * Enable error code to error string conversion.
- *
- * Module:  library/error.c
- * Caller:
- *
- * This module enables polarssl_strerror().
- */
-#define POLARSSL_ERROR_C
-
-/**
- * \def POLARSSL_GCM_C
- *
- * Enable the Galois/Counter Mode (GCM) for AES.
- *
- * Module:  library/gcm.c
- *
- * Requires: POLARSSL_AES_C or POLARSSL_CAMELLIA_C
- *
- * This module enables the AES-GCM and CAMELLIA-GCM ciphersuites, if other
- * requisites are enabled as well.
- */
-#define POLARSSL_GCM_C
-
-/**
- * \def POLARSSL_HAVEGE_C
- *
- * Enable the HAVEGE random generator.
- *
- * Warning: the HAVEGE random generator is not suitable for virtualized
- *          environments
- *
- * Warning: the HAVEGE random generator is dependent on timing and specific
- *          processor traits. It is therefore not advised to use HAVEGE as
- *          your applications primary random generator or primary entropy pool
- *          input. As a secondary input to your entropy pool, it IS able add
- *          the (limited) extra entropy it provides.
- *
- * Module:  library/havege.c
- * Caller:
- *
- * Requires: POLARSSL_TIMING_C
- *
- * Uncomment to enable the HAVEGE random generator.
- */
-//#define POLARSSL_HAVEGE_C
-
-/**
- * \def POLARSSL_HMAC_DRBG_C
- *
- * Enable the HMAC_DRBG random generator.
- *
- * Module:  library/hmac_drbg.c
- * Caller:
- *
- * Requires: POLARSSL_MD_C
- *
- * Uncomment to enable the HMAC_DRBG random number geerator.
- */
-#define POLARSSL_HMAC_DRBG_C
-
-/**
- * \def POLARSSL_MD_C
- *
- * Enable the generic message digest layer.
- *
- * Module:  library/md.c
- * Caller:
- *
- * Uncomment to enable generic message digest wrappers.
- */
-#define POLARSSL_MD_C
-
-/**
- * \def POLARSSL_MD2_C
- *
- * Enable the MD2 hash algorithm.
- *
- * Module:  library/md2.c
- * Caller:
- *
- * Uncomment to enable support for (rare) MD2-signed X.509 certs.
- */
-//#define POLARSSL_MD2_C
-
-/**
- * \def POLARSSL_MD4_C
- *
- * Enable the MD4 hash algorithm.
- *
- * Module:  library/md4.c
- * Caller:
- *
- * Uncomment to enable support for (rare) MD4-signed X.509 certs.
- */
-//#define POLARSSL_MD4_C
-
-/**
- * \def POLARSSL_MD5_C
- *
- * Enable the MD5 hash algorithm.
- *
- * Module:  library/md5.c
- * Caller:  library/md.c
- *          library/pem.c
- *          library/ssl_tls.c
- *
- * This module is required for SSL/TLS and X.509.
- * PEM_PARSE uses MD5 for decrypting encrypted keys.
- */
-#define POLARSSL_MD5_C
-
-/**
- * \def POLARSSL_MEMORY_C
- * Deprecated since 1.3.5. Please use POLARSSL_PLATFORM_MEMORY instead.
- */
-//#define POLARSSL_MEMORY_C
-
-/**
- * \def POLARSSL_MEMORY_BUFFER_ALLOC_C
- *
- * Enable the buffer allocator implementation that makes use of a (stack)
- * based buffer to 'allocate' dynamic memory. (replaces malloc() and free()
- * calls)
- *
- * Module:  library/memory_buffer_alloc.c
- *
- * Requires: POLARSSL_PLATFORM_C
- *           POLARSSL_PLATFORM_MEMORY (to use it within PolarSSL)
- *
- * Enable this module to enable the buffer memory allocator.
- */
-//#define POLARSSL_MEMORY_BUFFER_ALLOC_C
-
-/**
- * \def POLARSSL_NET_C
- *
- * Enable the TCP/IP networking routines.
- *
- * Module:  library/net.c
- *
- * This module provides TCP/IP networking routines.
- */
-#define POLARSSL_NET_C
-
-/**
- * \def POLARSSL_OID_C
- *
- * Enable the OID database.
- *
- * Module:  library/oid.c
- * Caller:  library/asn1write.c
- *          library/pkcs5.c
- *          library/pkparse.c
- *          library/pkwrite.c
- *          library/rsa.c
- *          library/x509.c
- *          library/x509_create.c
- *          library/x509_crl.c
- *          library/x509_crt.c
- *          library/x509_csr.c
- *          library/x509write_crt.c
- *          library/x509write_csr.c
- *
- * This modules translates between OIDs and internal values.
- */
-#define POLARSSL_OID_C
-
-/**
- * \def POLARSSL_PADLOCK_C
- *
- * Enable VIA Padlock support on x86.
- *
- * Module:  library/padlock.c
- * Caller:  library/aes.c
- *
- * Requires: POLARSSL_HAVE_ASM
- *
- * This modules adds support for the VIA PadLock on x86.
- */
-//#define POLARSSL_PADLOCK_C
-
-/**
- * \def POLARSSL_PBKDF2_C
- *
- * Enable PKCS#5 PBKDF2 key derivation function.
- * DEPRECATED: Use POLARSSL_PKCS5_C instead
- *
- * Module:  library/pbkdf2.c
- *
- * Requires: POLARSSL_PKCS5_C
- *
- * This module adds support for the PKCS#5 PBKDF2 key derivation function.
- */
-#define POLARSSL_PBKDF2_C
-
-/**
- * \def POLARSSL_PEM_PARSE_C
- *
- * Enable PEM decoding / parsing.
- *
- * Module:  library/pem.c
- * Caller:  library/dhm.c
- *          library/pkparse.c
- *          library/x509_crl.c
- *          library/x509_crt.c
- *          library/x509_csr.c
- *
- * Requires: POLARSSL_BASE64_C
- *
- * This modules adds support for decoding / parsing PEM files.
- */
-#define POLARSSL_PEM_PARSE_C
-
-/**
- * \def POLARSSL_PEM_WRITE_C
- *
- * Enable PEM encoding / writing.
- *
- * Module:  library/pem.c
- * Caller:  library/pkwrite.c
- *          library/x509write_crt.c
- *          library/x509write_csr.c
- *
- * Requires: POLARSSL_BASE64_C
- *
- * This modules adds support for encoding / writing PEM files.
- */
-#define POLARSSL_PEM_WRITE_C
-
-/**
- * \def POLARSSL_PK_C
- *
- * Enable the generic public (asymetric) key layer.
- *
- * Module:  library/pk.c
- * Caller:  library/ssl_tls.c
- *          library/ssl_cli.c
- *          library/ssl_srv.c
- *
- * Requires: POLARSSL_RSA_C or POLARSSL_ECP_C
- *
- * Uncomment to enable generic public key wrappers.
- */
-#define POLARSSL_PK_C
-
-/**
- * \def POLARSSL_PK_PARSE_C
- *
- * Enable the generic public (asymetric) key parser.
- *
- * Module:  library/pkparse.c
- * Caller:  library/x509_crt.c
- *          library/x509_csr.c
- *
- * Requires: POLARSSL_PK_C
- *
- * Uncomment to enable generic public key parse functions.
- */
-#define POLARSSL_PK_PARSE_C
-
-/**
- * \def POLARSSL_PK_WRITE_C
- *
- * Enable the generic public (asymetric) key writer.
- *
- * Module:  library/pkwrite.c
- * Caller:  library/x509write.c
- *
- * Requires: POLARSSL_PK_C
- *
- * Uncomment to enable generic public key write functions.
- */
-#define POLARSSL_PK_WRITE_C
-
-/**
- * \def POLARSSL_PKCS5_C
- *
- * Enable PKCS#5 functions.
- *
- * Module:  library/pkcs5.c
- *
- * Requires: POLARSSL_MD_C
- *
- * This module adds support for the PKCS#5 functions.
- */
-#define POLARSSL_PKCS5_C
-
-/**
- * \def POLARSSL_PKCS11_C
- *
- * Enable wrapper for PKCS#11 smartcard support.
- *
- * Module:  library/pkcs11.c
- * Caller:  library/pk.c
- *
- * Requires: POLARSSL_PK_C
- *
- * This module enables SSL/TLS PKCS #11 smartcard support.
- * Requires the presence of the PKCS#11 helper library (libpkcs11-helper)
- */
-//#define POLARSSL_PKCS11_C
-
-/**
- * \def POLARSSL_PKCS12_C
- *
- * Enable PKCS#12 PBE functions.
- * Adds algorithms for parsing PKCS#8 encrypted private keys
- *
- * Module:  library/pkcs12.c
- * Caller:  library/pkparse.c
- *
- * Requires: POLARSSL_ASN1_PARSE_C, POLARSSL_CIPHER_C, POLARSSL_MD_C
- * Can use:  POLARSSL_ARC4_C
- *
- * This module enables PKCS#12 functions.
- */
-#define POLARSSL_PKCS12_C
-
-/**
- * \def POLARSSL_PLATFORM_C
- *
- * Enable the platform abstraction layer that allows you to re-assign
- * functions like malloc(), free(), printf(), fprintf()
- *
- * Module:  library/platform.c
- * Caller:  Most other .c files
- *
- * This module enables abstraction of common (libc) functions.
- */
-//#define POLARSSL_PLATFORM_C
-
-/**
- * \def POLARSSL_RIPEMD160_C
- *
- * Enable the RIPEMD-160 hash algorithm.
- *
- * Module:  library/ripemd160.c
- * Caller:  library/md.c
- *
- */
-#define POLARSSL_RIPEMD160_C
-
-/**
- * \def POLARSSL_RSA_C
- *
- * Enable the RSA public-key cryptosystem.
- *
- * Module:  library/rsa.c
- * Caller:  library/ssl_cli.c
- *          library/ssl_srv.c
- *          library/ssl_tls.c
- *          library/x509.c
- *
- * This module is used by the following key exchanges:
- *      RSA, DHE-RSA, ECDHE-RSA, RSA-PSK
- *
- * Requires: POLARSSL_BIGNUM_C, POLARSSL_OID_C
- */
-#define POLARSSL_RSA_C
-
-/**
- * \def POLARSSL_SHA1_C
- *
- * Enable the SHA1 cryptographic hash algorithm.
- *
- * Module:  library/sha1.c
- * Caller:  library/md.c
- *          library/ssl_cli.c
- *          library/ssl_srv.c
- *          library/ssl_tls.c
- *          library/x509write_crt.c
- *
- * This module is required for SSL/TLS and SHA1-signed certificates.
- */
-#define POLARSSL_SHA1_C
-
-/**
- * \def POLARSSL_SHA256_C
- *
- * Enable the SHA-224 and SHA-256 cryptographic hash algorithms.
- * (Used to be POLARSSL_SHA2_C)
- *
- * Module:  library/sha256.c
- * Caller:  library/entropy.c
- *          library/md.c
- *          library/ssl_cli.c
- *          library/ssl_srv.c
- *          library/ssl_tls.c
- *
- * This module adds support for SHA-224 and SHA-256.
- * This module is required for the SSL/TLS 1.2 PRF function.
- */
-#define POLARSSL_SHA256_C
-
-/**
- * \def POLARSSL_SHA512_C
- *
- * Enable the SHA-384 and SHA-512 cryptographic hash algorithms.
- * (Used to be POLARSSL_SHA4_C)
- *
- * Module:  library/sha512.c
- * Caller:  library/entropy.c
- *          library/md.c
- *          library/ssl_cli.c
- *          library/ssl_srv.c
- *
- * This module adds support for SHA-384 and SHA-512.
- */
-#define POLARSSL_SHA512_C
-
-/**
- * \def POLARSSL_SSL_CACHE_C
- *
- * Enable simple SSL cache implementation.
- *
- * Module:  library/ssl_cache.c
- * Caller:
- *
- * Requires: POLARSSL_SSL_CACHE_C
- */
-#define POLARSSL_SSL_CACHE_C
-
-/**
- * \def POLARSSL_SSL_CLI_C
- *
- * Enable the SSL/TLS client code.
- *
- * Module:  library/ssl_cli.c
- * Caller:
- *
- * Requires: POLARSSL_SSL_TLS_C
- *
- * This module is required for SSL/TLS client support.
- */
-#define POLARSSL_SSL_CLI_C
-
-/**
- * \def POLARSSL_SSL_SRV_C
- *
- * Enable the SSL/TLS server code.
- *
- * Module:  library/ssl_srv.c
- * Caller:
- *
- * Requires: POLARSSL_SSL_TLS_C
- *
- * This module is required for SSL/TLS server support.
- */
-#define POLARSSL_SSL_SRV_C
-
-/**
- * \def POLARSSL_SSL_TLS_C
- *
- * Enable the generic SSL/TLS code.
- *
- * Module:  library/ssl_tls.c
- * Caller:  library/ssl_cli.c
- *          library/ssl_srv.c
- *
- * Requires: POLARSSL_CIPHER_C, POLARSSL_MD_C
- *           and at least one of the POLARSSL_SSL_PROTO_* defines
- *
- * This module is required for SSL/TLS.
- */
-#define POLARSSL_SSL_TLS_C
-
-/**
- * \def POLARSSL_THREADING_C
- *
- * Enable the threading abstraction layer.
- * By default PolarSSL assumes it is used in a non-threaded environment or that
- * contexts are not shared between threads. If you do intend to use contexts
- * between threads, you will need to enable this layer to prevent race
- * conditions.
- *
- * Module:  library/threading.c
- *
- * This allows different threading implementations (self-implemented or
- * provided).
- *
- * You will have to enable either POLARSSL_THREADING_ALT or
- * POLARSSL_THREADING_PTHREAD.
- *
- * Enable this layer to allow use of mutexes within PolarSSL
- */
-//#define POLARSSL_THREADING_C
-
-/**
- * \def POLARSSL_TIMING_C
- *
- * Enable the portable timing interface.
- *
- * Module:  library/timing.c
- * Caller:  library/havege.c
- *
- * This module is used by the HAVEGE random number generator.
- */
-#define POLARSSL_TIMING_C
-
-/**
- * \def POLARSSL_VERSION_C
- *
- * Enable run-time version information.
- *
- * Module:  library/version.c
- *
- * This module provides run-time version information.
- */
-#define POLARSSL_VERSION_C
-
-/**
- * \def POLARSSL_X509_USE_C
- *
- * Enable X.509 core for using certificates.
- *
- * Module:  library/x509.c
- * Caller:  library/x509_crl.c
- *          library/x509_crt.c
- *          library/x509_csr.c
- *
- * Requires: POLARSSL_ASN1_PARSE_C, POLARSSL_BIGNUM_C, POLARSSL_OID_C,
- *           POLARSSL_PK_PARSE_C
- *
- * This module is required for the X.509 parsing modules.
- */
-#define POLARSSL_X509_USE_C
-
-/**
- * \def POLARSSL_X509_CRT_PARSE_C
- *
- * Enable X.509 certificate parsing.
- *
- * Module:  library/x509_crt.c
- * Caller:  library/ssl_cli.c
- *          library/ssl_srv.c
- *          library/ssl_tls.c
- *
- * Requires: POLARSSL_X509_USE_C
- *
- * This module is required for X.509 certificate parsing.
- */
-#define POLARSSL_X509_CRT_PARSE_C
-
-/**
- * \def POLARSSL_X509_CRL_PARSE_C
- *
- * Enable X.509 CRL parsing.
- *
- * Module:  library/x509_crl.c
- * Caller:  library/x509_crt.c
- *
- * Requires: POLARSSL_X509_USE_C
- *
- * This module is required for X.509 CRL parsing.
- */
-#define POLARSSL_X509_CRL_PARSE_C
-
-/**
- * \def POLARSSL_X509_CSR_PARSE_C
- *
- * Enable X.509 Certificate Signing Request (CSR) parsing.
- *
- * Module:  library/x509_csr.c
- * Caller:  library/x509_crt_write.c
- *
- * Requires: POLARSSL_X509_USE_C
- *
- * This module is used for reading X.509 certificate request.
- */
-#define POLARSSL_X509_CSR_PARSE_C
-
-/**
- * \def POLARSSL_X509_CREATE_C
- *
- * Enable X.509 core for creating certificates.
- *
- * Module:  library/x509_create.c
- *
- * Requires: POLARSSL_BIGNUM_C, POLARSSL_OID_C, POLARSSL_PK_WRITE_C
- *
- * This module is the basis for creating X.509 certificates and CSRs.
- */
-#define POLARSSL_X509_CREATE_C
-
-/**
- * \def POLARSSL_X509_CRT_WRITE_C
- *
- * Enable creating X.509 certificates.
- *
- * Module:  library/x509_crt_write.c
- *
- * Requires: POLARSSL_CREATE_C
- *
- * This module is required for X.509 certificate creation.
- */
-#define POLARSSL_X509_CRT_WRITE_C
-
-/**
- * \def POLARSSL_X509_CSR_WRITE_C
- *
- * Enable creating X.509 Certificate Signing Requests (CSR).
- *
- * Module:  library/x509_csr_write.c
- *
- * Requires: POLARSSL_CREATE_C
- *
- * This module is required for X.509 certificate request writing.
- */
-#define POLARSSL_X509_CSR_WRITE_C
-
-/**
- * \def POLARSSL_XTEA_C
- *
- * Enable the XTEA block cipher.
- *
- * Module:  library/xtea.c
- * Caller:
- */
-#define POLARSSL_XTEA_C
-
-/* \} name SECTION: PolarSSL modules */
-
-/**
- * \name SECTION: Module configuration options
- *
- * This section allows for the setting of module specific sizes and
- * configuration options. The default values are already present in the
- * relevant header files and should suffice for the regular use cases.
- *
- * Our advice is to enable options and change their values here
- * only if you have a good reason and know the consequences.
- *
- * Please check the respective header file for documentation on these
- * parameters (to prevent duplicate documentation).
- * \{
- */
-
-/* MPI / BIGNUM options */
-//#define POLARSSL_MPI_WINDOW_SIZE            6 /**< Maximum windows size used. */
-//#define POLARSSL_MPI_MAX_SIZE            1024 /**< Maximum number of bytes for usable MPIs. */
-
-/* CTR_DRBG options */
-//#define CTR_DRBG_ENTROPY_LEN               48 /**< Amount of entropy used per seed by default (48 with SHA-512, 32 with SHA-256) */
-//#define CTR_DRBG_RESEED_INTERVAL        10000 /**< Interval before reseed is performed by default */
-//#define CTR_DRBG_MAX_INPUT                256 /**< Maximum number of additional input bytes */
-//#define CTR_DRBG_MAX_REQUEST             1024 /**< Maximum number of requested bytes per call */
-//#define CTR_DRBG_MAX_SEED_INPUT           384 /**< Maximum size of (re)seed buffer */
-
-/* HMAC_DRBG options */
-//#define POLARSSL_HMAC_DRBG_RESEED_INTERVAL   10000 /**< Interval before reseed is performed by default */
-//#define POLARSSL_HMAC_DRBG_MAX_INPUT           256 /**< Maximum number of additional input bytes */
-//#define POLARSSL_HMAC_DRBG_MAX_REQUEST        1024 /**< Maximum number of requested bytes per call */
-//#define POLARSSL_HMAC_DRBG_MAX_SEED_INPUT      384 /**< Maximum size of (re)seed buffer */
-
-/* ECP options */
-//#define POLARSSL_ECP_MAX_BITS             521 /**< Maximum bit size of groups */
-//#define POLARSSL_ECP_WINDOW_SIZE            6 /**< Maximum window size used */
-//#define POLARSSL_ECP_FIXED_POINT_OPTIM      1 /**< Enable fixed-point speed-up */
-
-/* Entropy options */
-//#define ENTROPY_MAX_SOURCES                20 /**< Maximum number of sources supported */
-//#define ENTROPY_MAX_GATHER                128 /**< Maximum amount requested from entropy sources */
-
-/* Memory buffer allocator options */
-//#define POLARSSL_MEMORY_ALIGN_MULTIPLE      4 /**< Align on multiples of this value */
-
-/* Platform options */
-//#define POLARSSL_PLATFORM_STD_MEM_HDR <stdlib.h> /**< Header to include if POLARSSL_PLATFORM_NO_STD_FUNCTIONS is defined. Don't define if no header is needed. */
-//#define POLARSSL_PLATFORM_STD_MALLOC   malloc /**< Default allocator to use, can be undefined */
-//#define POLARSSL_PLATFORM_STD_FREE       free /**< Default free to use, can be undefined */
-//#define POLARSSL_PLATFORM_STD_PRINTF   printf /**< Default printf to use, can be undefined */
-//#define POLARSSL_PLATFORM_STD_FPRINTF fprintf /**< Default fprintf to use, can be undefined */
-
-/* SSL Cache options */
-//#define SSL_CACHE_DEFAULT_TIMEOUT       86400 /**< 1 day  */
-//#define SSL_CACHE_DEFAULT_MAX_ENTRIES      50 /**< Maximum entries in cache */
-
-/* SSL options */
-//#define SSL_MAX_CONTENT_LEN             16384 /**< Size of the input / output buffer */
-//#define SSL_DEFAULT_TICKET_LIFETIME     86400 /**< Lifetime of session tickets (if enabled) */
-//#define POLARSSL_PSK_MAX_LEN               32 /**< Max size of TLS pre-shared keys, in bytes (default 256 bits) */
-
-/**
- * Complete list of ciphersuites to use, in order of preference.
- *
- * \warning No dependency checking is done on that field! This option can only
- * be used to restrict the set of available ciphersuites. It is your
- * responsibility to make sure the needed modules are active.
- *
- * Use this to save a few hundred bytes of ROM (default ordering of all
- * available ciphersuites) and a few to a few hundred bytes of RAM.
- *
- * The value below is only an example, not the default.
- */
-//#define SSL_CIPHERSUITES TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
-
-/* Debug options */
-//#define POLARSSL_DEBUG_DFL_MODE POLARSSL_DEBUG_LOG_FULL /**< Default log: Full or Raw */
-
-/* \} name SECTION: Module configuration options */
-
-
-#endif /* POLARSSL_CONFIG_H */
Impressum, Datenschutz