Add server-side TLS support, through kTLS.
[cubemap] / tlse / tlse.c
1 /********************************************************************************\r
2  Copyright (c) 2016-2018, Eduard Suica\r
3  All rights reserved.\r
4  \r
5  Redistribution and use in source and binary forms, with or without modification,\r
6  are permitted provided that the following conditions are met:\r
7  \r
8  1. Redistributions of source code must retain the above copyright notice, this\r
9  list of conditions and the following disclaimer.\r
10  \r
11  2. Redistributions in binary form must reproduce the above copyright notice, this\r
12  list of conditions and the following disclaimer in the documentation and/or other\r
13  materials provided with the distribution.\r
14  \r
15  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND\r
16  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r
17  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\r
18  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,\r
19  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\r
20  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\r
21  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,\r
22  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
23  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
24  POSSIBILITY OF SUCH DAMAGE.\r
25  ********************************************************************************/\r
26 #ifndef TLSE_C\r
27 #define TLSE_C\r
28 \r
29 #include <stdlib.h>\r
30 #include <stdio.h>\r
31 #include <string.h>\r
32 #include <stdint.h>\r
33 #include <time.h>\r
34 #ifdef _WIN32\r
35 #include <windows.h>\r
36 #include <wincrypt.h>\r
37 #define strcasecmp stricmp\r
38 #else\r
39 // hton* and ntoh* functions\r
40 #include <arpa/inet.h>\r
41 #include <unistd.h>\r
42 #endif\r
43 \r
44 #ifdef TLS_AMALGAMATION\r
45 #include "libtomcrypt.c"\r
46 #else\r
47 #include <tomcrypt.h>\r
48 #endif\r
49 \r
50 #if (CRYPT <= 0x0117)\r
51     #define LTC_PKCS_1_EMSA LTC_LTC_PKCS_1_EMSA\r
52     #define LTC_PKCS_1_V1_5 LTC_LTC_PKCS_1_V1_5\r
53 #endif\r
54 \r
55 #ifdef WITH_KTLS\r
56     #include <sys/types.h>\r
57     #include <sys/socket.h>\r
58     #include <netinet/tcp.h>\r
59     #include "ktls.h"\r
60 #endif\r
61 // using ChaCha20 implementation by D. J. Bernstein\r
62 \r
63 #include "tlse.h"\r
64 \r
65 #ifndef TLS_FORWARD_SECRECY\r
66 #undef TLS_ECDSA_SUPPORTED\r
67 #endif\r
68 \r
69 #ifndef TLS_ECDSA_SUPPORTED\r
70 // disable client ECDSA if not supported\r
71 #undef TLS_CLIENT_ECDSA\r
72 #endif\r
73 \r
74 #define TLS_DH_DEFAULT_P            "87A8E61DB4B6663CFFBBD19C651959998CEEF608660DD0F25D2CEED4435E3B00E00DF8F1D61957D4FAF7DF4561B2AA3016C3D91134096FAA3BF4296D830E9A7C209E0C6497517ABD5A8A9D306BCF67ED91F9E6725B4758C022E0B1EF4275BF7B6C5BFC11D45F9088B941F54EB1E59BB8BC39A0BF12307F5C4FDB70C581B23F76B63ACAE1CAA6B7902D52526735488A0EF13C6D9A51BFA4AB3AD8347796524D8EF6A167B5A41825D967E144E5140564251CCACB83E6B486F6B3CA3F7971506026C0B857F689962856DED4010ABD0BE621C3A3960A54E710C375F26375D7014103A4B54330C198AF126116D2276E11715F693877FAD7EF09CADB094AE91E1A1597"\r
75 #define TLS_DH_DEFAULT_G            "3FB32C9B73134D0B2E77506660EDBD484CA7B18F21EF205407F4793A1A0BA12510DBC15077BE463FFF4FED4AAC0BB555BE3A6C1B0C6B47B1BC3773BF7E8C6F62901228F8C28CBB18A55AE31341000A650196F931C77A57F2DDF463E5E9EC144B777DE62AAAB8A8628AC376D282D6ED3864E67982428EBC831D14348F6F2F9193B5045AF2767164E1DFC967C1FB3F2E55A4BD1BFFE83B9C80D052B985D182EA0ADB2A3B7313D3FE14C8484B1E052588B9B7D2BBD2DF016199ECD06E1557CD0915B3353BBB64E0EC377FD028370DF92B52C7891428CDC67EB6184B523D1DB246C32F63078490F00EF8D647D148D47954515E2327CFEF98C582664B4C0F6CC41659"\r
76 #define __TLS_DHE_KEY_SIZE          2048\r
77 \r
78 // you should never use weak DH groups (1024 bits)\r
79 // but if you have old devices (like grandstream ip phones)\r
80 // that can't handle 2048bit DHE, uncomment next lines\r
81 // and define TLS_WEAK_DH_LEGACY_DEVICES\r
82 // #ifdef TLS_WEAK_DH_LEGACY_DEVICES\r
83 //     #define TLS_DH_DEFAULT_P            "B10B8F96A080E01DDE92DE5EAE5D54EC52C99FBCFB06A3C69A6A9DCA52D23B616073E28675A23D189838EF1E2EE652C013ECB4AEA906112324975C3CD49B83BFACCBDD7D90C4BD7098488E9C219A73724EFFD6FAE5644738FAA31A4FF55BCCC0A151AF5F0DC8B4BD45BF37DF365C1A65E68CFDA76D4DA708DF1FB2BC2E4A4371"\r
84 //     #define TLS_DH_DEFAULT_G            "A4D1CBD5C3FD34126765A442EFB99905F8104DD258AC507FD6406CFF14266D31266FEA1E5C41564B777E690F5504F213160217B4B01B886A5E91547F9E2749F4D7FBD7D3B9A92EE1909D0D2263F80A76A6A24C087A091F531DBF0A0169B6A28AD662A4D18E73AFA32D779D5918D08BC8858F4DCEF97C2A24855E6EEB22B3B2E5"\r
85 //     #define __TLS_DHE_KEY_SIZE          1024\r
86 // #endif\r
87 \r
88 #ifndef TLS_MALLOC\r
89     #define TLS_MALLOC(size)        malloc(size)\r
90 #endif\r
91 #ifndef TLS_REALLOC\r
92     #define TLS_REALLOC(ptr, size)  realloc(ptr, size)\r
93 #endif\r
94 #ifndef TLS_FREE\r
95     #define TLS_FREE(ptr)           if (ptr) free(ptr)\r
96 #endif\r
97 \r
98 #ifdef DEBUG\r
99 #define DEBUG_PRINT(...)            fprintf(stderr, __VA_ARGS__)\r
100 #define DEBUG_DUMP_HEX(buf, len)    {int i; for (i = 0; i < len; i++) { DEBUG_PRINT("%02X ", (unsigned int)(buf)[i]); } }\r
101 #define DEBUG_INDEX(fields)         print_index(fields)\r
102 #define DEBUG_DUMP(buf, length)     fwrite(buf, 1, length, stderr);\r
103 #define DEBUG_DUMP_HEX_LABEL(title, buf, len)    {fprintf(stderr, "%s (%i): ", title, (int)len); DEBUG_DUMP_HEX(buf, len); fprintf(stderr, "\n");}\r
104 #else\r
105 #define DEBUG_PRINT(...)            { }\r
106 #define DEBUG_DUMP_HEX(buf, len)    { }\r
107 #define DEBUG_INDEX(fields)         { }\r
108 #define DEBUG_DUMP(buf, length)     { }\r
109 #define DEBUG_DUMP_HEX_LABEL(title, buf, len) { }\r
110 #endif\r
111 \r
112 #ifndef htonll\r
113 #define htonll(x) ((1==htonl(1)) ? (x) : ((uint64_t)htonl((x) & 0xFFFFFFFF) << 32) | htonl((x) >> 32))\r
114 #endif\r
115 \r
116 #ifndef ntohll\r
117 #define ntohll(x) ((1==ntohl(1)) ? (x) : ((uint64_t)ntohl((x) & 0xFFFFFFFF) << 32) | ntohl((x) >> 32))\r
118 #endif\r
119 \r
120 #define TLS_CHANGE_CIPHER       0x14\r
121 #define TLS_ALERT               0x15\r
122 #define TLS_HANDSHAKE           0x16\r
123 #define TLS_APPLICATION_DATA    0x17\r
124 \r
125 #define TLS_SERIALIZED_OBJECT   0xFE\r
126 \r
127 #define __TLS_CLIENT_HELLO_MINSIZE  41\r
128 #define __TLS_CLIENT_RANDOM_SIZE    32\r
129 #define __TLS_SERVER_RANDOM_SIZE    32\r
130 #define __TLS_MAX_SESSION_ID        32\r
131 #define __TLS_SHA256_MAC_SIZE       32\r
132 #define __TLS_SHA1_MAC_SIZE         20\r
133 #define __TLS_SHA384_MAC_SIZE       48\r
134 #define __TLS_MAX_MAC_SIZE          __TLS_SHA384_MAC_SIZE\r
135 #define __TLS_MAX_KEY_EXPANSION_SIZE 192 // 160\r
136 // 512bits (sha256) = 64 bytes\r
137 #define __TLS_MAX_HASH_LEN          64\r
138 #define __TLS_AES_IV_LENGTH         16\r
139 #define __TLS_AES_BLOCK_SIZE        16\r
140 #define __TLS_AES_GCM_IV_LENGTH     4\r
141 #define __TLS_GCM_TAG_LEN           16\r
142 #define __TLS_MAX_TAG_LEN           16\r
143 #define __TLS_MIN_FINISHED_OPAQUE_LEN 12\r
144 \r
145 #define __TLS_BLOB_INCREMENT        0xFFF\r
146 #define __TLS_ASN1_MAXLEVEL         0xFF\r
147 \r
148 #define __DTLS_COOKIE_SIZE          32\r
149 \r
150 #define __TLS_MAX_SHA_SIZE 48\r
151 #define __TLS_V11_HASH_SIZE 36      // 16(md5) + 20(sha1)\r
152 #define __TLS_MAX_HASH_SIZE __TLS_MAX_SHA_SIZE\r
153 #define __TLS_MAX_RSA_KEY   2048    // 16kbits\r
154 \r
155 #define __TLS_MAX_TLS_APP_SIZE      0x4000\r
156 // max 1 second sleep\r
157 #define __TLS_MAX_ERROR_SLEEP_uS    1000000\r
158 // max 5 seconds context sleep\r
159 #define __TLS_MAX_ERROR_IDLE_S      5\r
160 \r
161 #define VERSION_SUPPORTED(version, err)  if ((version != TLS_V12) && (version != TLS_V11) && (version != TLS_V10) && (version != DTLS_V12) && (version != DTLS_V10)) { if ((version == SSL_V30) && (context->connection_status == 0)) { version = TLS_V12; } else { DEBUG_PRINT("UNSUPPORTED TLS VERSION %x\n", (int)version); return err;} }\r
162 #define CHECK_SIZE(size, buf_size, err)  if (((int)size > (int)buf_size) || ((int)buf_size < 0)) return err;\r
163 #define TLS_IMPORT_CHECK_SIZE(buf_pos, size, buf_size) if (((int)size > (int)buf_size - buf_pos) || ((int)buf_pos > (int)buf_size)) { DEBUG_PRINT("IMPORT ELEMENT SIZE ERROR\n"); tls_destroy_context(context); return NULL; }\r
164 #define CHECK_HANDSHAKE_STATE(context, n, limit)  { if (context->hs_messages[n] >= limit) { DEBUG_PRINT("* UNEXPECTED MESSAGE (%i)\n", (int)n); payload_res = TLS_UNEXPECTED_MESSAGE; break; } context->hs_messages[n]++; }\r
165 \r
166 #ifdef TLS_WITH_CHACHA20_POLY1305\r
167 #define __TLS_CHACHA20_IV_LENGTH    12\r
168 \r
169 // ChaCha20 implementation by D. J. Bernstein\r
170 // Public domain.\r
171 \r
172 #define CHACHA_MINKEYLEN    16\r
173 #define CHACHA_NONCELEN     8\r
174 #define CHACHA_NONCELEN_96  12\r
175 #define CHACHA_CTRLEN       8\r
176 #define CHACHA_CTRLEN_96    4\r
177 #define CHACHA_STATELEN     (CHACHA_NONCELEN+CHACHA_CTRLEN)\r
178 #define CHACHA_BLOCKLEN     64\r
179 \r
180 #define POLY1305_MAX_AAD    32\r
181 #define POLY1305_KEYLEN     32\r
182 #define POLY1305_TAGLEN     16\r
183 \r
184 #define u_int   unsigned int\r
185 #define uint8_t unsigned char\r
186 #define u_char  unsigned char\r
187 #ifndef NULL\r
188 #define NULL (void *)0\r
189 #endif\r
190 \r
191 #if (CRYPT >= 0x0117) && (0)\r
192     // to do: use ltc chacha/poly1305 implementation (working on big-endian machines)\r
193     #define chacha_ctx                                  chacha20poly1305_state\r
194     #define poly1305_context                            poly1305_state\r
195 \r
196     #define __private_tls_poly1305_init(ctx, key, len)  poly1305_init(ctx, key, len)\r
197     #define __private_tls_poly1305_update(ctx, in, len) poly1305_process(ctx, in, len)\r
198     #define __private_tls_poly1305_finish(ctx, mac)     poly1305_done(ctx, mac, 16)\r
199 #else\r
200 struct chacha_ctx {\r
201     u_int input[16];\r
202     uint8_t ks[CHACHA_BLOCKLEN];\r
203     uint8_t unused;\r
204 };\r
205 \r
206 static inline void chacha_keysetup(struct chacha_ctx *x, const u_char *k, u_int kbits);\r
207 static inline void chacha_ivsetup(struct chacha_ctx *x, const u_char *iv, const u_char *ctr);\r
208 static inline void chacha_ivsetup_96bitnonce(struct chacha_ctx *x, const u_char *iv, const u_char *ctr);\r
209 static inline void chacha_encrypt_bytes(struct chacha_ctx *x, const u_char *m, u_char *c, u_int bytes);\r
210 static inline int poly1305_generate_key(unsigned char *key256, unsigned char *nonce, unsigned int noncelen, unsigned char *poly_key, unsigned int counter);\r
211 \r
212 #define poly1305_block_size 16\r
213 #define poly1305_context poly1305_state_internal_t\r
214 \r
215 //========== ChaCha20 from D. J. Bernstein ========= //\r
216 // Source available at https://cr.yp.to/chacha.html  //\r
217 \r
218 typedef unsigned char u8;\r
219 typedef unsigned int u32;\r
220 \r
221 typedef struct chacha_ctx chacha_ctx;\r
222 \r
223 #define U8C(v) (v##U)\r
224 #define U32C(v) (v##U)\r
225 \r
226 #define U8V(v) ((u8)(v) & U8C(0xFF))\r
227 #define U32V(v) ((u32)(v) & U32C(0xFFFFFFFF))\r
228 \r
229 #define ROTL32(v, n) \\r
230   (U32V((v) << (n)) | ((v) >> (32 - (n))))\r
231 \r
232 #define __private_tls_U8TO32_LITTLE(p) \\r
233   (((u32)((p)[0])) | \\r
234    ((u32)((p)[1]) <<  8) | \\r
235    ((u32)((p)[2]) << 16) | \\r
236    ((u32)((p)[3]) << 24))\r
237 \r
238 #define __private_tls_U32TO8_LITTLE(p, v) \\r
239   do { \\r
240     (p)[0] = U8V((v)); \\r
241     (p)[1] = U8V((v) >>  8); \\r
242     (p)[2] = U8V((v) >> 16); \\r
243     (p)[3] = U8V((v) >> 24); \\r
244   } while (0)\r
245 \r
246 #define ROTATE(v,c) (ROTL32(v,c))\r
247 #define XOR(v,w) ((v) ^ (w))\r
248 #define PLUS(v,w) (U32V((v) + (w)))\r
249 #define PLUSONE(v) (PLUS((v),1))\r
250 \r
251 #define QUARTERROUND(a,b,c,d) \\r
252   a = PLUS(a,b); d = ROTATE(XOR(d,a),16); \\r
253   c = PLUS(c,d); b = ROTATE(XOR(b,c),12); \\r
254   a = PLUS(a,b); d = ROTATE(XOR(d,a), 8); \\r
255   c = PLUS(c,d); b = ROTATE(XOR(b,c), 7);\r
256 \r
257 static const char sigma[] = "expand 32-byte k";\r
258 static const char tau[] = "expand 16-byte k";\r
259 \r
260 static inline void chacha_keysetup(chacha_ctx *x, const u8 *k, u32 kbits) {\r
261     const char *constants;\r
262 \r
263     x->input[4] = __private_tls_U8TO32_LITTLE(k + 0);\r
264     x->input[5] = __private_tls_U8TO32_LITTLE(k + 4);\r
265     x->input[6] = __private_tls_U8TO32_LITTLE(k + 8);\r
266     x->input[7] = __private_tls_U8TO32_LITTLE(k + 12);\r
267     if (kbits == 256) { /* recommended */\r
268         k += 16;\r
269         constants = sigma;\r
270     } else { /* kbits == 128 */\r
271         constants = tau;\r
272     }\r
273     x->input[8] = __private_tls_U8TO32_LITTLE(k + 0);\r
274     x->input[9] = __private_tls_U8TO32_LITTLE(k + 4);\r
275     x->input[10] = __private_tls_U8TO32_LITTLE(k + 8);\r
276     x->input[11] = __private_tls_U8TO32_LITTLE(k + 12);\r
277     x->input[0] = __private_tls_U8TO32_LITTLE(constants + 0);\r
278     x->input[1] = __private_tls_U8TO32_LITTLE(constants + 4);\r
279     x->input[2] = __private_tls_U8TO32_LITTLE(constants + 8);\r
280     x->input[3] = __private_tls_U8TO32_LITTLE(constants + 12);\r
281 }\r
282 \r
283 static inline void chacha_key(chacha_ctx *x, u8 *k) {\r
284     __private_tls_U32TO8_LITTLE(k, x->input[4]);\r
285     __private_tls_U32TO8_LITTLE(k + 4, x->input[5]);\r
286     __private_tls_U32TO8_LITTLE(k + 8, x->input[6]);\r
287     __private_tls_U32TO8_LITTLE(k + 12, x->input[7]);\r
288 \r
289     __private_tls_U32TO8_LITTLE(k + 16, x->input[8]);\r
290     __private_tls_U32TO8_LITTLE(k + 20, x->input[9]);\r
291     __private_tls_U32TO8_LITTLE(k + 24, x->input[10]);\r
292     __private_tls_U32TO8_LITTLE(k + 28, x->input[11]);\r
293 }\r
294 \r
295 static inline void chacha_nonce(chacha_ctx *x, u8 *nonce) {\r
296     __private_tls_U32TO8_LITTLE(nonce + 0, x->input[13]);\r
297     __private_tls_U32TO8_LITTLE(nonce + 4, x->input[14]);\r
298     __private_tls_U32TO8_LITTLE(nonce + 8, x->input[15]);\r
299 }\r
300 \r
301 static inline void chacha_ivsetup(chacha_ctx *x, const u8 *iv, const u8 *counter) {\r
302     x->input[12] = counter == NULL ? 0 : __private_tls_U8TO32_LITTLE(counter + 0);\r
303     x->input[13] = counter == NULL ? 0 : __private_tls_U8TO32_LITTLE(counter + 4);\r
304     if (iv) {\r
305         x->input[14] = __private_tls_U8TO32_LITTLE(iv + 0);\r
306         x->input[15] = __private_tls_U8TO32_LITTLE(iv + 4);\r
307     }\r
308 }\r
309 \r
310 static inline void chacha_ivsetup_96bitnonce(chacha_ctx *x, const u8 *iv, const u8 *counter) {\r
311     x->input[12] = counter == NULL ? 0 : __private_tls_U8TO32_LITTLE(counter + 0);\r
312     if (iv) {\r
313         x->input[13] = __private_tls_U8TO32_LITTLE(iv + 0);\r
314         x->input[14] = __private_tls_U8TO32_LITTLE(iv + 4);\r
315         x->input[15] = __private_tls_U8TO32_LITTLE(iv + 8);\r
316     }\r
317 }\r
318 \r
319 static inline void chacha_ivupdate(chacha_ctx *x, const u8 *iv, const u8 *aad, const u8 *counter) {\r
320     x->input[12] = counter == NULL ? 0 : __private_tls_U8TO32_LITTLE(counter + 0);\r
321     x->input[13] = __private_tls_U8TO32_LITTLE(iv + 0);\r
322     x->input[14] = __private_tls_U8TO32_LITTLE(iv + 4) ^ __private_tls_U8TO32_LITTLE(aad);\r
323     x->input[15] = __private_tls_U8TO32_LITTLE(iv + 8) ^ __private_tls_U8TO32_LITTLE(aad + 4);\r
324 }\r
325 \r
326 static inline void chacha_encrypt_bytes(chacha_ctx *x, const u8 *m, u8 *c, u32 bytes) {\r
327     u32 x0, x1, x2, x3, x4, x5, x6, x7;\r
328     u32 x8, x9, x10, x11, x12, x13, x14, x15;\r
329     u32 j0, j1, j2, j3, j4, j5, j6, j7;\r
330     u32 j8, j9, j10, j11, j12, j13, j14, j15;\r
331     u8 *ctarget = NULL;\r
332     u8 tmp[64];\r
333     u_int i;\r
334 \r
335     if (!bytes)\r
336         return;\r
337 \r
338     j0 = x->input[0];\r
339     j1 = x->input[1];\r
340     j2 = x->input[2];\r
341     j3 = x->input[3];\r
342     j4 = x->input[4];\r
343     j5 = x->input[5];\r
344     j6 = x->input[6];\r
345     j7 = x->input[7];\r
346     j8 = x->input[8];\r
347     j9 = x->input[9];\r
348     j10 = x->input[10];\r
349     j11 = x->input[11];\r
350     j12 = x->input[12];\r
351     j13 = x->input[13];\r
352     j14 = x->input[14];\r
353     j15 = x->input[15];\r
354 \r
355     for (;;) {\r
356         if (bytes < 64) {\r
357             for (i = 0; i < bytes; ++i)\r
358                 tmp[i] = m[i];\r
359             m = tmp;\r
360             ctarget = c;\r
361             c = tmp;\r
362         }\r
363         x0 = j0;\r
364         x1 = j1;\r
365         x2 = j2;\r
366         x3 = j3;\r
367         x4 = j4;\r
368         x5 = j5;\r
369         x6 = j6;\r
370         x7 = j7;\r
371         x8 = j8;\r
372         x9 = j9;\r
373         x10 = j10;\r
374         x11 = j11;\r
375         x12 = j12;\r
376         x13 = j13;\r
377         x14 = j14;\r
378         x15 = j15;\r
379         for (i = 20; i > 0; i -= 2) {\r
380             QUARTERROUND(x0, x4, x8, x12)\r
381             QUARTERROUND(x1, x5, x9, x13)\r
382             QUARTERROUND(x2, x6, x10, x14)\r
383             QUARTERROUND(x3, x7, x11, x15)\r
384             QUARTERROUND(x0, x5, x10, x15)\r
385             QUARTERROUND(x1, x6, x11, x12)\r
386             QUARTERROUND(x2, x7, x8, x13)\r
387             QUARTERROUND(x3, x4, x9, x14)\r
388         }\r
389         x0 = PLUS(x0, j0);\r
390         x1 = PLUS(x1, j1);\r
391         x2 = PLUS(x2, j2);\r
392         x3 = PLUS(x3, j3);\r
393         x4 = PLUS(x4, j4);\r
394         x5 = PLUS(x5, j5);\r
395         x6 = PLUS(x6, j6);\r
396         x7 = PLUS(x7, j7);\r
397         x8 = PLUS(x8, j8);\r
398         x9 = PLUS(x9, j9);\r
399         x10 = PLUS(x10, j10);\r
400         x11 = PLUS(x11, j11);\r
401         x12 = PLUS(x12, j12);\r
402         x13 = PLUS(x13, j13);\r
403         x14 = PLUS(x14, j14);\r
404         x15 = PLUS(x15, j15);\r
405 \r
406         if (bytes < 64) {\r
407             __private_tls_U32TO8_LITTLE(x->ks + 0, x0);\r
408             __private_tls_U32TO8_LITTLE(x->ks + 4, x1);\r
409             __private_tls_U32TO8_LITTLE(x->ks + 8, x2);\r
410             __private_tls_U32TO8_LITTLE(x->ks + 12, x3);\r
411             __private_tls_U32TO8_LITTLE(x->ks + 16, x4);\r
412             __private_tls_U32TO8_LITTLE(x->ks + 20, x5);\r
413             __private_tls_U32TO8_LITTLE(x->ks + 24, x6);\r
414             __private_tls_U32TO8_LITTLE(x->ks + 28, x7);\r
415             __private_tls_U32TO8_LITTLE(x->ks + 32, x8);\r
416             __private_tls_U32TO8_LITTLE(x->ks + 36, x9);\r
417             __private_tls_U32TO8_LITTLE(x->ks + 40, x10);\r
418             __private_tls_U32TO8_LITTLE(x->ks + 44, x11);\r
419             __private_tls_U32TO8_LITTLE(x->ks + 48, x12);\r
420             __private_tls_U32TO8_LITTLE(x->ks + 52, x13);\r
421             __private_tls_U32TO8_LITTLE(x->ks + 56, x14);\r
422             __private_tls_U32TO8_LITTLE(x->ks + 60, x15);\r
423         }\r
424 \r
425         x0 = XOR(x0, __private_tls_U8TO32_LITTLE(m + 0));\r
426         x1 = XOR(x1, __private_tls_U8TO32_LITTLE(m + 4));\r
427         x2 = XOR(x2, __private_tls_U8TO32_LITTLE(m + 8));\r
428         x3 = XOR(x3, __private_tls_U8TO32_LITTLE(m + 12));\r
429         x4 = XOR(x4, __private_tls_U8TO32_LITTLE(m + 16));\r
430         x5 = XOR(x5, __private_tls_U8TO32_LITTLE(m + 20));\r
431         x6 = XOR(x6, __private_tls_U8TO32_LITTLE(m + 24));\r
432         x7 = XOR(x7, __private_tls_U8TO32_LITTLE(m + 28));\r
433         x8 = XOR(x8, __private_tls_U8TO32_LITTLE(m + 32));\r
434         x9 = XOR(x9, __private_tls_U8TO32_LITTLE(m + 36));\r
435         x10 = XOR(x10, __private_tls_U8TO32_LITTLE(m + 40));\r
436         x11 = XOR(x11, __private_tls_U8TO32_LITTLE(m + 44));\r
437         x12 = XOR(x12, __private_tls_U8TO32_LITTLE(m + 48));\r
438         x13 = XOR(x13, __private_tls_U8TO32_LITTLE(m + 52));\r
439         x14 = XOR(x14, __private_tls_U8TO32_LITTLE(m + 56));\r
440         x15 = XOR(x15, __private_tls_U8TO32_LITTLE(m + 60));\r
441 \r
442         j12 = PLUSONE(j12);\r
443         if (!j12) {\r
444             j13 = PLUSONE(j13);\r
445             /*\r
446              * Stopping at 2^70 bytes per nonce is the user's\r
447              * responsibility.\r
448              */\r
449         }\r
450 \r
451         __private_tls_U32TO8_LITTLE(c + 0, x0);\r
452         __private_tls_U32TO8_LITTLE(c + 4, x1);\r
453         __private_tls_U32TO8_LITTLE(c + 8, x2);\r
454         __private_tls_U32TO8_LITTLE(c + 12, x3);\r
455         __private_tls_U32TO8_LITTLE(c + 16, x4);\r
456         __private_tls_U32TO8_LITTLE(c + 20, x5);\r
457         __private_tls_U32TO8_LITTLE(c + 24, x6);\r
458         __private_tls_U32TO8_LITTLE(c + 28, x7);\r
459         __private_tls_U32TO8_LITTLE(c + 32, x8);\r
460         __private_tls_U32TO8_LITTLE(c + 36, x9);\r
461         __private_tls_U32TO8_LITTLE(c + 40, x10);\r
462         __private_tls_U32TO8_LITTLE(c + 44, x11);\r
463         __private_tls_U32TO8_LITTLE(c + 48, x12);\r
464         __private_tls_U32TO8_LITTLE(c + 52, x13);\r
465         __private_tls_U32TO8_LITTLE(c + 56, x14);\r
466         __private_tls_U32TO8_LITTLE(c + 60, x15);\r
467 \r
468         if (bytes <= 64) {\r
469             if (bytes < 64) {\r
470                 for (i = 0; i < bytes; ++i)\r
471                     ctarget[i] = c[i];\r
472             }\r
473             x->input[12] = j12;\r
474             x->input[13] = j13;\r
475             x->unused = 64 - bytes;\r
476             return;\r
477         }\r
478         bytes -= 64;\r
479         c += 64;\r
480         m += 64;\r
481     }\r
482 }\r
483 \r
484 static inline void chacha20_block(chacha_ctx *x, unsigned char *c, int len) {\r
485     u_int i;\r
486 \r
487     unsigned int state[16];\r
488     for (i = 0; i < 16; i++)\r
489         state[i] = x->input[i];\r
490     for (i = 20; i > 0; i -= 2) {\r
491         QUARTERROUND(state[0], state[4], state[8], state[12])\r
492         QUARTERROUND(state[1], state[5], state[9], state[13])\r
493         QUARTERROUND(state[2], state[6], state[10], state[14])\r
494         QUARTERROUND(state[3], state[7], state[11], state[15])\r
495         QUARTERROUND(state[0], state[5], state[10], state[15])\r
496         QUARTERROUND(state[1], state[6], state[11], state[12])\r
497         QUARTERROUND(state[2], state[7], state[8], state[13])\r
498         QUARTERROUND(state[3], state[4], state[9], state[14])\r
499     }\r
500 \r
501     for (i = 0; i < 16; i++)\r
502         x->input[i] = PLUS(x->input[i], state[i]);\r
503 \r
504     for (i = 0; i < len; i += 4) {\r
505         __private_tls_U32TO8_LITTLE(c + i, x->input[i/4]);\r
506     }\r
507 }\r
508 \r
509 static inline int poly1305_generate_key(unsigned char *key256, unsigned char *nonce, unsigned int noncelen, unsigned char *poly_key, unsigned int counter) {\r
510     struct chacha_ctx ctx;\r
511     uint64_t ctr;\r
512     memset(&ctx, 0, sizeof(ctx));\r
513     chacha_keysetup(&ctx, key256, 256);\r
514     switch (noncelen) {\r
515         case 8:\r
516             ctr = counter;\r
517             chacha_ivsetup(&ctx, nonce, (unsigned char *)&ctr);\r
518             break;\r
519         case 12:\r
520             chacha_ivsetup_96bitnonce(&ctx, nonce, (unsigned char *)&counter);\r
521             break;\r
522         default:\r
523             return -1;\r
524     }\r
525     chacha20_block(&ctx, poly_key, POLY1305_KEYLEN);\r
526     return 0;\r
527 }\r
528 \r
529 /* 17 + sizeof(size_t) + 14*sizeof(unsigned long) */\r
530 typedef struct poly1305_state_internal_t {\r
531     unsigned long r[5];\r
532     unsigned long h[5];\r
533     unsigned long pad[4];\r
534     size_t leftover;\r
535     unsigned char buffer[poly1305_block_size];\r
536     unsigned char final;\r
537 } poly1305_state_internal_t;\r
538 \r
539 /* interpret four 8 bit unsigned integers as a 32 bit unsigned integer in little endian */\r
540 static unsigned long __private_tls_U8TO32(const unsigned char *p) {\r
541     return\r
542         (((unsigned long)(p[0] & 0xff)      ) |\r
543          ((unsigned long)(p[1] & 0xff) <<  8) |\r
544          ((unsigned long)(p[2] & 0xff) << 16) |\r
545          ((unsigned long)(p[3] & 0xff) << 24));\r
546 }\r
547 \r
548 /* store a 32 bit unsigned integer as four 8 bit unsigned integers in little endian */\r
549 static void __private_tls_U32TO8(unsigned char *p, unsigned long v) {\r
550     p[0] = (v      ) & 0xff;\r
551     p[1] = (v >>  8) & 0xff;\r
552     p[2] = (v >> 16) & 0xff;\r
553     p[3] = (v >> 24) & 0xff;\r
554 }\r
555 \r
556 void __private_tls_poly1305_init(poly1305_context *ctx, const unsigned char key[32]) {\r
557     poly1305_state_internal_t *st = (poly1305_state_internal_t *)ctx;\r
558 \r
559     /* r &= 0xffffffc0ffffffc0ffffffc0fffffff */\r
560     st->r[0] = (__private_tls_U8TO32(&key[ 0])     ) & 0x3ffffff;\r
561     st->r[1] = (__private_tls_U8TO32(&key[ 3]) >> 2) & 0x3ffff03;\r
562     st->r[2] = (__private_tls_U8TO32(&key[ 6]) >> 4) & 0x3ffc0ff;\r
563     st->r[3] = (__private_tls_U8TO32(&key[ 9]) >> 6) & 0x3f03fff;\r
564     st->r[4] = (__private_tls_U8TO32(&key[12]) >> 8) & 0x00fffff;\r
565 \r
566     /* h = 0 */\r
567     st->h[0] = 0;\r
568     st->h[1] = 0;\r
569     st->h[2] = 0;\r
570     st->h[3] = 0;\r
571     st->h[4] = 0;\r
572 \r
573     /* save pad for later */\r
574     st->pad[0] = __private_tls_U8TO32(&key[16]);\r
575     st->pad[1] = __private_tls_U8TO32(&key[20]);\r
576     st->pad[2] = __private_tls_U8TO32(&key[24]);\r
577     st->pad[3] = __private_tls_U8TO32(&key[28]);\r
578 \r
579     st->leftover = 0;\r
580     st->final = 0;\r
581 }\r
582 \r
583 static void __private_tls_poly1305_blocks(poly1305_state_internal_t *st, const unsigned char *m, size_t bytes) {\r
584     const unsigned long hibit = (st->final) ? 0 : (1UL << 24); /* 1 << 128 */\r
585     unsigned long r0,r1,r2,r3,r4;\r
586     unsigned long s1,s2,s3,s4;\r
587     unsigned long h0,h1,h2,h3,h4;\r
588     unsigned long long d0,d1,d2,d3,d4;\r
589     unsigned long c;\r
590 \r
591     r0 = st->r[0];\r
592     r1 = st->r[1];\r
593     r2 = st->r[2];\r
594     r3 = st->r[3];\r
595     r4 = st->r[4];\r
596 \r
597     s1 = r1 * 5;\r
598     s2 = r2 * 5;\r
599     s3 = r3 * 5;\r
600     s4 = r4 * 5;\r
601 \r
602     h0 = st->h[0];\r
603     h1 = st->h[1];\r
604     h2 = st->h[2];\r
605     h3 = st->h[3];\r
606     h4 = st->h[4];\r
607 \r
608     while (bytes >= poly1305_block_size) {\r
609         /* h += m[i] */\r
610         h0 += (__private_tls_U8TO32(m+ 0)     ) & 0x3ffffff;\r
611         h1 += (__private_tls_U8TO32(m+ 3) >> 2) & 0x3ffffff;\r
612         h2 += (__private_tls_U8TO32(m+ 6) >> 4) & 0x3ffffff;\r
613         h3 += (__private_tls_U8TO32(m+ 9) >> 6) & 0x3ffffff;\r
614         h4 += (__private_tls_U8TO32(m+12) >> 8) | hibit;\r
615 \r
616         /* h *= r */\r
617         d0 = ((unsigned long long)h0 * r0) + ((unsigned long long)h1 * s4) + ((unsigned long long)h2 * s3) + ((unsigned long long)h3 * s2) + ((unsigned long long)h4 * s1);\r
618         d1 = ((unsigned long long)h0 * r1) + ((unsigned long long)h1 * r0) + ((unsigned long long)h2 * s4) + ((unsigned long long)h3 * s3) + ((unsigned long long)h4 * s2);\r
619         d2 = ((unsigned long long)h0 * r2) + ((unsigned long long)h1 * r1) + ((unsigned long long)h2 * r0) + ((unsigned long long)h3 * s4) + ((unsigned long long)h4 * s3);\r
620         d3 = ((unsigned long long)h0 * r3) + ((unsigned long long)h1 * r2) + ((unsigned long long)h2 * r1) + ((unsigned long long)h3 * r0) + ((unsigned long long)h4 * s4);\r
621         d4 = ((unsigned long long)h0 * r4) + ((unsigned long long)h1 * r3) + ((unsigned long long)h2 * r2) + ((unsigned long long)h3 * r1) + ((unsigned long long)h4 * r0);\r
622 \r
623         /* (partial) h %= p */\r
624                       c = (unsigned long)(d0 >> 26); h0 = (unsigned long)d0 & 0x3ffffff;\r
625         d1 += c;      c = (unsigned long)(d1 >> 26); h1 = (unsigned long)d1 & 0x3ffffff;\r
626         d2 += c;      c = (unsigned long)(d2 >> 26); h2 = (unsigned long)d2 & 0x3ffffff;\r
627         d3 += c;      c = (unsigned long)(d3 >> 26); h3 = (unsigned long)d3 & 0x3ffffff;\r
628         d4 += c;      c = (unsigned long)(d4 >> 26); h4 = (unsigned long)d4 & 0x3ffffff;\r
629         h0 += c * 5;  c =                (h0 >> 26); h0 =                h0 & 0x3ffffff;\r
630         h1 += c;\r
631 \r
632         m += poly1305_block_size;\r
633         bytes -= poly1305_block_size;\r
634     }\r
635 \r
636     st->h[0] = h0;\r
637     st->h[1] = h1;\r
638     st->h[2] = h2;\r
639     st->h[3] = h3;\r
640     st->h[4] = h4;\r
641 }\r
642 \r
643 void __private_tls_poly1305_finish(poly1305_context *ctx, unsigned char mac[16]) {\r
644     poly1305_state_internal_t *st = (poly1305_state_internal_t *)ctx;\r
645     unsigned long h0,h1,h2,h3,h4,c;\r
646     unsigned long g0,g1,g2,g3,g4;\r
647     unsigned long long f;\r
648     unsigned long mask;\r
649 \r
650     /* process the remaining block */\r
651     if (st->leftover) {\r
652         size_t i = st->leftover;\r
653         st->buffer[i++] = 1;\r
654         for (; i < poly1305_block_size; i++)\r
655             st->buffer[i] = 0;\r
656         st->final = 1;\r
657         __private_tls_poly1305_blocks(st, st->buffer, poly1305_block_size);\r
658     }\r
659 \r
660     /* fully carry h */\r
661     h0 = st->h[0];\r
662     h1 = st->h[1];\r
663     h2 = st->h[2];\r
664     h3 = st->h[3];\r
665     h4 = st->h[4];\r
666 \r
667                  c = h1 >> 26; h1 = h1 & 0x3ffffff;\r
668     h2 +=     c; c = h2 >> 26; h2 = h2 & 0x3ffffff;\r
669     h3 +=     c; c = h3 >> 26; h3 = h3 & 0x3ffffff;\r
670     h4 +=     c; c = h4 >> 26; h4 = h4 & 0x3ffffff;\r
671     h0 += c * 5; c = h0 >> 26; h0 = h0 & 0x3ffffff;\r
672     h1 +=     c;\r
673 \r
674     /* compute h + -p */\r
675     g0 = h0 + 5; c = g0 >> 26; g0 &= 0x3ffffff;\r
676     g1 = h1 + c; c = g1 >> 26; g1 &= 0x3ffffff;\r
677     g2 = h2 + c; c = g2 >> 26; g2 &= 0x3ffffff;\r
678     g3 = h3 + c; c = g3 >> 26; g3 &= 0x3ffffff;\r
679     g4 = h4 + c - (1UL << 26);\r
680 \r
681     /* select h if h < p, or h + -p if h >= p */\r
682     mask = (g4 >> ((sizeof(unsigned long) * 8) - 1)) - 1;\r
683     g0 &= mask;\r
684     g1 &= mask;\r
685     g2 &= mask;\r
686     g3 &= mask;\r
687     g4 &= mask;\r
688     mask = ~mask;\r
689     h0 = (h0 & mask) | g0;\r
690     h1 = (h1 & mask) | g1;\r
691     h2 = (h2 & mask) | g2;\r
692     h3 = (h3 & mask) | g3;\r
693     h4 = (h4 & mask) | g4;\r
694 \r
695     /* h = h % (2^128) */\r
696     h0 = ((h0      ) | (h1 << 26)) & 0xffffffff;\r
697     h1 = ((h1 >>  6) | (h2 << 20)) & 0xffffffff;\r
698     h2 = ((h2 >> 12) | (h3 << 14)) & 0xffffffff;\r
699     h3 = ((h3 >> 18) | (h4 <<  8)) & 0xffffffff;\r
700 \r
701     /* mac = (h + pad) % (2^128) */\r
702     f = (unsigned long long)h0 + st->pad[0]            ; h0 = (unsigned long)f;\r
703     f = (unsigned long long)h1 + st->pad[1] + (f >> 32); h1 = (unsigned long)f;\r
704     f = (unsigned long long)h2 + st->pad[2] + (f >> 32); h2 = (unsigned long)f;\r
705     f = (unsigned long long)h3 + st->pad[3] + (f >> 32); h3 = (unsigned long)f;\r
706 \r
707     __private_tls_U32TO8(mac +  0, h0);\r
708     __private_tls_U32TO8(mac +  4, h1);\r
709     __private_tls_U32TO8(mac +  8, h2);\r
710     __private_tls_U32TO8(mac + 12, h3);\r
711 \r
712     /* zero out the state */\r
713     st->h[0] = 0;\r
714     st->h[1] = 0;\r
715     st->h[2] = 0;\r
716     st->h[3] = 0;\r
717     st->h[4] = 0;\r
718     st->r[0] = 0;\r
719     st->r[1] = 0;\r
720     st->r[2] = 0;\r
721     st->r[3] = 0;\r
722     st->r[4] = 0;\r
723     st->pad[0] = 0;\r
724     st->pad[1] = 0;\r
725     st->pad[2] = 0;\r
726     st->pad[3] = 0;\r
727 }\r
728 \r
729 void __private_tls_poly1305_update(poly1305_context *ctx, const unsigned char *m, size_t bytes) {\r
730     poly1305_state_internal_t *st = (poly1305_state_internal_t *)ctx;\r
731     size_t i;\r
732     /* handle leftover */\r
733     if (st->leftover) {\r
734         size_t want = (poly1305_block_size - st->leftover);\r
735         if (want > bytes)\r
736             want = bytes;\r
737         for (i = 0; i < want; i++)\r
738             st->buffer[st->leftover + i] = m[i];\r
739         bytes -= want;\r
740         m += want;\r
741         st->leftover += want;\r
742         if (st->leftover < poly1305_block_size)\r
743             return;\r
744         __private_tls_poly1305_blocks(st, st->buffer, poly1305_block_size);\r
745         st->leftover = 0;\r
746     }\r
747 \r
748     /* process full blocks */\r
749     if (bytes >= poly1305_block_size) {\r
750         size_t want = (bytes & ~(poly1305_block_size - 1));\r
751         __private_tls_poly1305_blocks(st, m, want);\r
752         m += want;\r
753         bytes -= want;\r
754     }\r
755 \r
756     /* store leftover */\r
757     if (bytes) {\r
758         for (i = 0; i < bytes; i++)\r
759             st->buffer[st->leftover + i] = m[i];\r
760         st->leftover += bytes;\r
761     }\r
762 }\r
763 \r
764 int poly1305_verify(const unsigned char mac1[16], const unsigned char mac2[16]) {\r
765     size_t i;\r
766     unsigned int dif = 0;\r
767     for (i = 0; i < 16; i++)\r
768         dif |= (mac1[i] ^ mac2[i]);\r
769     dif = (dif - 1) >> ((sizeof(unsigned int) * 8) - 1);\r
770     return (dif & 1);\r
771 }\r
772 \r
773 void chacha20_poly1305_key(struct chacha_ctx *ctx, unsigned char *poly1305_key) {\r
774     unsigned char key[32];\r
775     unsigned char nonce[12];\r
776     chacha_key(ctx, key);\r
777     chacha_nonce(ctx, nonce);\r
778     poly1305_generate_key(key, nonce, sizeof(nonce), poly1305_key, 0);\r
779 }\r
780 \r
781 int chacha20_poly1305_aead(struct chacha_ctx *ctx,  unsigned char *pt, unsigned int len, unsigned char *aad, unsigned int aad_len, unsigned char *poly_key, unsigned char *out) {\r
782     static unsigned char zeropad[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};\r
783     if (aad_len > POLY1305_MAX_AAD)\r
784         return -1;\r
785 \r
786     unsigned int counter = 1;\r
787     chacha_ivsetup_96bitnonce(ctx, NULL, (unsigned char *)&counter);\r
788     chacha_encrypt_bytes(ctx, pt, out, len);\r
789     \r
790     poly1305_context aead_ctx;\r
791     __private_tls_poly1305_init(&aead_ctx, poly_key);\r
792     __private_tls_poly1305_update(&aead_ctx, aad, aad_len);\r
793     int rem = aad_len % 16;\r
794     if (rem)\r
795         __private_tls_poly1305_update(&aead_ctx, zeropad, 16 - rem);\r
796     __private_tls_poly1305_update(&aead_ctx, out, len);\r
797     rem = len % 16;\r
798     if (rem)\r
799         __private_tls_poly1305_update(&aead_ctx, zeropad, 16 - rem);\r
800 \r
801     unsigned char trail[16];\r
802     __private_tls_U32TO8(&trail[0], aad_len);\r
803     *(int *)&trail[4] = 0;\r
804     __private_tls_U32TO8(&trail[8], len);\r
805     *(int *)&trail[12] = 0;\r
806 \r
807     __private_tls_poly1305_update(&aead_ctx, trail, 16);\r
808     __private_tls_poly1305_finish(&aead_ctx, out + len);\r
809     \r
810     return len + POLY1305_TAGLEN;\r
811 }\r
812 #endif\r
813 #endif\r
814 \r
815 typedef enum {\r
816     KEA_dhe_dss,\r
817     KEA_dhe_rsa,\r
818     KEA_dh_anon,\r
819     KEA_rsa,\r
820     KEA_dh_dss,\r
821     KEA_dh_rsa,\r
822     KEA_ec_diffie_hellman\r
823 } KeyExchangeAlgorithm;\r
824 \r
825 typedef enum {\r
826     rsa_sign = 1,\r
827     dss_sign = 2,\r
828     rsa_fixed_dh = 3,\r
829     dss_fixed_dh = 4,\r
830     rsa_ephemeral_dh_RESERVED = 5,\r
831     dss_ephemeral_dh_RESERVED = 6,\r
832     fortezza_dms_RESERVED = 20,\r
833     ecdsa_sign = 64,\r
834     rsa_fixed_ecdh = 65,\r
835     ecdsa_fixed_ecdh = 66\r
836 } TLSClientCertificateType;\r
837 \r
838 typedef enum {\r
839     none = 0,\r
840     md5 = 1,\r
841     sha1 = 2,\r
842     sha224 = 3,\r
843     sha256 = 4,\r
844     sha384 = 5,\r
845     sha512 = 6,\r
846     __md5_sha1 = 255\r
847 } TLSHashAlgorithm;\r
848 \r
849 typedef enum {\r
850     anonymous = 0,\r
851     rsa = 1,\r
852     dsa = 2,\r
853     ecdsa = 3\r
854 } TLSSignatureAlgorithm;\r
855 \r
856 struct __private_OID_chain {\r
857     void *top;\r
858     unsigned char *oid;\r
859 };\r
860 \r
861 struct TLSCertificate {\r
862     unsigned short version;\r
863     unsigned int algorithm;\r
864     unsigned int key_algorithm;\r
865     unsigned int ec_algorithm;\r
866     unsigned char *exponent;\r
867     unsigned int exponent_len;\r
868     unsigned char *pk;\r
869     unsigned int pk_len;\r
870     unsigned char *priv;\r
871     unsigned int priv_len;\r
872     unsigned char *issuer_country;\r
873     unsigned char *issuer_state;\r
874     unsigned char *issuer_location;\r
875     unsigned char *issuer_entity;\r
876     unsigned char *issuer_subject;\r
877     unsigned char *not_before;\r
878     unsigned char *not_after;\r
879     unsigned char *country;\r
880     unsigned char *state;\r
881     unsigned char *location;\r
882     unsigned char *entity;\r
883     unsigned char *subject;\r
884     unsigned char **san;\r
885     unsigned short san_length;\r
886     unsigned char *ocsp;\r
887     unsigned char *serial_number;\r
888     unsigned int serial_len;\r
889     unsigned char *sign_key;\r
890     unsigned int sign_len;\r
891     unsigned char *fingerprint;\r
892     unsigned char *der_bytes;\r
893     unsigned int der_len;\r
894     unsigned char *bytes;\r
895     unsigned int len;\r
896 };\r
897 \r
898 typedef struct {\r
899     union {\r
900         symmetric_CBC aes_local;\r
901         gcm_state aes_gcm_local;\r
902 #ifdef TLS_WITH_CHACHA20_POLY1305\r
903         chacha_ctx chacha_local;\r
904 #endif\r
905     } ctx_local;\r
906     union {\r
907         symmetric_CBC aes_remote;\r
908         gcm_state aes_gcm_remote;\r
909 #ifdef TLS_WITH_CHACHA20_POLY1305\r
910         chacha_ctx chacha_remote;\r
911 #endif\r
912     } ctx_remote;\r
913     union {\r
914         unsigned char local_mac[__TLS_MAX_MAC_SIZE];\r
915         unsigned char local_aead_iv[__TLS_AES_GCM_IV_LENGTH];\r
916 #ifdef TLS_WITH_CHACHA20_POLY1305\r
917         unsigned char local_nonce[__TLS_CHACHA20_IV_LENGTH];\r
918 #endif\r
919     } ctx_local_mac;\r
920     union {\r
921         unsigned char remote_aead_iv[__TLS_AES_GCM_IV_LENGTH];\r
922         unsigned char remote_mac[__TLS_MAX_MAC_SIZE];\r
923 #ifdef TLS_WITH_CHACHA20_POLY1305\r
924         unsigned char remote_nonce[__TLS_CHACHA20_IV_LENGTH];\r
925 #endif\r
926     } ctx_remote_mac;\r
927     unsigned char created;\r
928 } TLSCipher;\r
929 \r
930 typedef struct {\r
931     hash_state hash;\r
932 #ifdef TLS_LEGACY_SUPPORT\r
933     hash_state hash2;\r
934 #endif\r
935     unsigned char created;\r
936 } TLSHash;\r
937 \r
938 #ifdef TLS_FORWARD_SECRECY\r
939 #define mp_init(a)                           ltc_mp.init(a)\r
940 #define mp_init_multi                        ltc_init_multi\r
941 #define mp_clear(a)                          ltc_mp.deinit(a)\r
942 #define mp_clear_multi                       ltc_deinit_multi\r
943 #define mp_count_bits(a)                     ltc_mp.count_bits(a)\r
944 #define mp_read_radix(a, b, c)               ltc_mp.read_radix(a, b, c)\r
945 #define mp_unsigned_bin_size(a)              ltc_mp.unsigned_size(a)\r
946 #define mp_to_unsigned_bin(a, b)             ltc_mp.unsigned_write(a, b)\r
947 #define mp_read_unsigned_bin(a, b, c)        ltc_mp.unsigned_read(a, b, c)\r
948 #define mp_exptmod(a, b, c, d)               ltc_mp.exptmod(a, b, c, d)\r
949 #define mp_add(a, b, c)                      ltc_mp.add(a, b, c)\r
950 #define mp_mul(a, b, c)                      ltc_mp.mul(a, b, c)\r
951 #define mp_cmp(a, b)                         ltc_mp.compare(a, b)\r
952 #define mp_cmp_d(a, b)                       ltc_mp.compare_d(a, b)\r
953 #define mp_sqr(a, b)                         ltc_mp.sqr(a, b)\r
954 #define mp_mod(a, b, c)                      ltc_mp.mpdiv(a, b, NULL, c)\r
955 #define mp_sub(a, b, c)                      ltc_mp.sub(a, b, c)\r
956 #define mp_set(a, b)                         ltc_mp.set_int(a, b)\r
957 \r
958 typedef struct {\r
959     void *x;\r
960     void *y;\r
961     void *p;\r
962     void *g;\r
963 } DHKey;\r
964 \r
965 struct ECCCurveParameters {\r
966     int size;\r
967     int iana;\r
968     const char *name;\r
969     const char *P;\r
970     const char *A;\r
971     const char *B;\r
972     const char *Gx;\r
973     const char *Gy;\r
974     const char *order;\r
975     ltc_ecc_set_type dp;\r
976 };\r
977 \r
978 static struct ECCCurveParameters secp192r1 = {\r
979     24,\r
980     19,\r
981     "secp192r1",\r
982     "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFF", // P\r
983     "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFC", // A\r
984     "64210519E59C80E70FA7E9AB72243049FEB8DEECC146B9B1", // B\r
985     "188DA80EB03090F67CBF20EB43A18800F4FF0AFD82FF1012", // Gx\r
986     "07192B95FFC8DA78631011ED6B24CDD573F977A11E794811", // Gy\r
987     "FFFFFFFFFFFFFFFFFFFFFFFF99DEF836146BC9B1B4D22831"  // order (n)\r
988 };\r
989 \r
990 \r
991 static struct ECCCurveParameters secp224r1 = {\r
992     28,\r
993     21,\r
994     "secp224r1",\r
995     "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000001", // P\r
996     "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFE", // A\r
997     "B4050A850C04B3ABF54132565044B0B7D7BFD8BA270B39432355FFB4", // B\r
998     "B70E0CBD6BB4BF7F321390B94A03C1D356C21122343280D6115C1D21", // Gx\r
999     "BD376388B5F723FB4C22DFE6CD4375A05A07476444D5819985007E34", // Gy\r
1000     "FFFFFFFFFFFFFFFFFFFFFFFFFFFF16A2E0B8F03E13DD29455C5C2A3D"  // order (n)\r
1001 };\r
1002 \r
1003 static struct ECCCurveParameters secp224k1 = {\r
1004     28,\r
1005     20,\r
1006     "secp224k1",\r
1007     "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFE56D", // P\r
1008     "00000000000000000000000000000000000000000000000000000000", // A\r
1009     "00000000000000000000000000000000000000000000000000000005", // B\r
1010     "A1455B334DF099DF30FC28A169A467E9E47075A90F7E650EB6B7A45C", // Gx\r
1011     "7E089FED7FBA344282CAFBD6F7E319F7C0B0BD59E2CA4BDB556D61A5", // Gy\r
1012     "0000000000000000000000000001DCE8D2EC6184CAF0A971769FB1F7"  // order (n)\r
1013 };\r
1014 \r
1015 static struct ECCCurveParameters secp256r1 = {\r
1016     32,\r
1017     23,\r
1018     "secp256r1",\r
1019     "FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF", // P\r
1020     "FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFC", // A\r
1021     "5AC635D8AA3A93E7B3EBBD55769886BC651D06B0CC53B0F63BCE3C3E27D2604B", // B\r
1022     "6B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C296", // Gx\r
1023     "4FE342E2FE1A7F9B8EE7EB4A7C0F9E162BCE33576B315ECECBB6406837BF51F5", // Gy\r
1024     "FFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551"  // order (n)\r
1025 };\r
1026 \r
1027 static struct ECCCurveParameters secp256k1 = {\r
1028     32,\r
1029     22,\r
1030     "secp256k1",\r
1031     "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F", // P\r
1032     "0000000000000000000000000000000000000000000000000000000000000000", // A\r
1033     "0000000000000000000000000000000000000000000000000000000000000007", // B\r
1034     "79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798", // Gx\r
1035     "483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8", // Gy\r
1036     "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141"  // order (n)\r
1037 };\r
1038 \r
1039 static struct ECCCurveParameters secp384r1 = {\r
1040     48,\r
1041     24,\r
1042     "secp384r1",\r
1043     "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFF", // P\r
1044     "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFC", // A\r
1045     "B3312FA7E23EE7E4988E056BE3F82D19181D9C6EFE8141120314088F5013875AC656398D8A2ED19D2A85C8EDD3EC2AEF", // B\r
1046     "AA87CA22BE8B05378EB1C71EF320AD746E1D3B628BA79B9859F741E082542A385502F25DBF55296C3A545E3872760AB7", // Gx\r
1047     "3617DE4A96262C6F5D9E98BF9292DC29F8F41DBD289A147CE9DA3113B5F0B8C00A60B1CE1D7E819D7A431D7C90EA0E5F", // Gy\r
1048     "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC7634D81F4372DDF581A0DB248B0A77AECEC196ACCC52973"  // order (n)\r
1049 };\r
1050 \r
1051 static struct ECCCurveParameters secp521r1 = {\r
1052     66,\r
1053     25,\r
1054     "secp521r1",\r
1055     "01FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", // P\r
1056     "01FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC", // A\r
1057     "0051953EB9618E1C9A1F929A21A0B68540EEA2DA725B99B315F3B8B489918EF109E156193951EC7E937B1652C0BD3BB1BF073573DF883D2C34F1EF451FD46B503F00", // B\r
1058     "00C6858E06B70404E9CD9E3ECB662395B4429C648139053FB521F828AF606B4D3DBAA14B5E77EFE75928FE1DC127A2FFA8DE3348B3C1856A429BF97E7E31C2E5BD66", // Gx\r
1059     "011839296A789A3BC0045C8A5FB42C7D1BD998F54449579B446817AFBD17273E662C97EE72995EF42640C550B9013FAD0761353C7086A272C24088BE94769FD16650", // Gy\r
1060     "01FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFA51868783BF2F966B7FCC0148F709A5D03BB5C9B8899C47AEBB6FB71E91386409"  // order (n)\r
1061 };\r
1062 \r
1063 static struct ECCCurveParameters * const default_curve = &secp256r1;\r
1064 \r
1065 void init_curve(struct ECCCurveParameters *curve) {\r
1066     curve->dp.size = curve->size;\r
1067     curve->dp.name = (char *)curve->name;\r
1068     curve->dp.B = (char *)curve->B;\r
1069     curve->dp.prime = (char *)curve->P;\r
1070     curve->dp.Gx = (char *)curve->Gx;\r
1071     curve->dp.Gy = (char *)curve->Gy;\r
1072     curve->dp.order = (char *)curve->order;\r
1073 }\r
1074 \r
1075 void init_curves() {\r
1076     init_curve(&secp192r1);\r
1077     init_curve(&secp224r1);\r
1078     init_curve(&secp224k1);\r
1079     init_curve(&secp256r1);\r
1080     init_curve(&secp256k1);\r
1081     init_curve(&secp384r1);\r
1082     init_curve(&secp521r1);\r
1083 }\r
1084 #endif\r
1085 \r
1086 struct TLSContext {\r
1087     unsigned char remote_random[__TLS_CLIENT_RANDOM_SIZE];\r
1088     unsigned char local_random[__TLS_SERVER_RANDOM_SIZE];\r
1089     unsigned char session[__TLS_MAX_SESSION_ID];\r
1090     unsigned char session_size;\r
1091     unsigned short cipher;\r
1092     unsigned short version;\r
1093     unsigned char is_server;\r
1094     struct TLSCertificate **certificates;\r
1095     struct TLSCertificate *private_key;\r
1096 #ifdef TLS_ECDSA_SUPPORTED\r
1097     struct TLSCertificate *ec_private_key;\r
1098 #endif\r
1099 #ifdef TLS_FORWARD_SECRECY\r
1100     DHKey *dhe;\r
1101     ecc_key *ecc_dhe;\r
1102     char *default_dhe_p;\r
1103     char *default_dhe_g;\r
1104     const struct ECCCurveParameters *curve;\r
1105 #endif\r
1106     struct TLSCertificate **client_certificates;\r
1107     unsigned int certificates_count;\r
1108     unsigned int client_certificates_count;\r
1109     unsigned char *master_key;\r
1110     unsigned int master_key_len;\r
1111     unsigned char *premaster_key;\r
1112     unsigned int premaster_key_len;\r
1113     unsigned char cipher_spec_set;\r
1114     TLSCipher crypto;\r
1115     TLSHash *handshake_hash;\r
1116     \r
1117     unsigned char *message_buffer;\r
1118     unsigned int message_buffer_len;\r
1119     uint64_t remote_sequence_number;\r
1120     uint64_t local_sequence_number;\r
1121     \r
1122     unsigned char connection_status;\r
1123     unsigned char critical_error;\r
1124     unsigned char error_code;\r
1125     \r
1126     unsigned char *tls_buffer;\r
1127     unsigned int tls_buffer_len;\r
1128     \r
1129     unsigned char *application_buffer;\r
1130     unsigned int application_buffer_len;\r
1131     unsigned char is_child;\r
1132     unsigned char exportable;\r
1133     unsigned char *exportable_keys;\r
1134     unsigned char exportable_size;\r
1135     char *sni;\r
1136     unsigned char request_client_certificate;\r
1137     unsigned char dtls;\r
1138     unsigned short dtls_epoch_local;\r
1139     unsigned short dtls_epoch_remote;\r
1140     unsigned char *dtls_cookie;\r
1141     unsigned char dtls_cookie_len;\r
1142     unsigned char dtls_seq;\r
1143     unsigned char *cached_handshake;\r
1144     unsigned int cached_handshake_len;\r
1145     unsigned char client_verified;\r
1146     // handshake messages flags\r
1147     unsigned char hs_messages[11];\r
1148     void *user_data;\r
1149     struct TLSCertificate **root_certificates;\r
1150     unsigned int root_count;\r
1151 #ifdef TLS_ACCEPT_SECURE_RENEGOTIATION\r
1152     unsigned char *verify_data;\r
1153     unsigned char verify_len;\r
1154 #endif\r
1155     char **alpn;\r
1156     unsigned char alpn_count;\r
1157     char *negotiated_alpn;\r
1158     unsigned int sleep_until;\r
1159 };\r
1160 \r
1161 struct TLSPacket {\r
1162     unsigned char *buf;\r
1163     unsigned int len;\r
1164     unsigned int size;\r
1165     unsigned char broken;\r
1166     struct TLSContext *context;\r
1167 };\r
1168 \r
1169 #ifdef SSL_COMPATIBLE_INTERFACE\r
1170 \r
1171 typedef int (*SOCKET_RECV_CALLBACK)(int socket, void *buffer, size_t length, int flags);\r
1172 typedef int (*SOCKET_SEND_CALLBACK)(int socket, const void *buffer, size_t length, int flags);\r
1173 \r
1174 #ifdef _WIN32\r
1175 #include <winsock2.h>\r
1176 #else\r
1177 #include <sys/socket.h>\r
1178 #endif\r
1179 #endif\r
1180 \r
1181 static const unsigned int version_id[] = {1, 1, 1, 0};\r
1182 static const unsigned int pk_id[] = {1, 1, 7, 0};\r
1183 static const unsigned int serial_id[] = {1, 1, 2, 1, 0};\r
1184 static const unsigned int issurer_id[] = {1, 1, 4, 0};\r
1185 static const unsigned int owner_id[] = {1, 1, 6, 0};\r
1186 static const unsigned int validity_id[] = {1, 1, 5, 0};\r
1187 static const unsigned int algorithm_id[] = {1, 1, 3, 0};\r
1188 static const unsigned int sign_id[] = {1, 3, 2, 1, 0};\r
1189 static const unsigned int priv_id[] = {1, 4, 0};\r
1190 static const unsigned int priv_der_id[] = {1, 3, 1, 0};\r
1191 static const unsigned int ecc_priv_id[] = {1, 2, 0};\r
1192 \r
1193 static const unsigned char country_oid[] = {0x55, 0x04, 0x06, 0x00};\r
1194 static const unsigned char state_oid[] = {0x55, 0x04, 0x08, 0x00};\r
1195 static const unsigned char location_oid[] = {0x55, 0x04, 0x07, 0x00};\r
1196 static const unsigned char entity_oid[] = {0x55, 0x04, 0x0A, 0x00};\r
1197 static const unsigned char subject_oid[] = {0x55, 0x04, 0x03, 0x00};\r
1198 static const unsigned char san_oid[] = {0x55, 0x1D, 0x11, 0x00};\r
1199 static const unsigned char ocsp_oid[] = {0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x30, 0x01, 0x00};\r
1200 \r
1201 static const unsigned char TLS_RSA_SIGN_RSA_OID[] = {0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x00};\r
1202 static const unsigned char TLS_RSA_SIGN_MD5_OID[] = {0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x04, 0x00};\r
1203 static const unsigned char TLS_RSA_SIGN_SHA1_OID[] = {0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x05, 0x00};\r
1204 static const unsigned char TLS_RSA_SIGN_SHA256_OID[] = {0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x0B, 0x00};\r
1205 static const unsigned char TLS_RSA_SIGN_SHA384_OID[] = {0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x0C, 0x00};\r
1206 static const unsigned char TLS_RSA_SIGN_SHA512_OID[] = {0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x0D, 0x00};\r
1207 \r
1208 // static const unsigned char TLS_ECDSA_SIGN_SHA1_OID[] = {0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x01, 0x05, 0x00, 0x00};\r
1209 // static const unsigned char TLS_ECDSA_SIGN_SHA224_OID[] = {0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x01, 0x05, 0x00, 0x00};\r
1210 // static const unsigned char TLS_ECDSA_SIGN_SHA256_OID[] = {0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x02, 0x05, 0x00, 0x00};\r
1211 // static const unsigned char TLS_ECDSA_SIGN_SHA384_OID[] = {0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x03, 0x05, 0x00, 0x00};\r
1212 // static const unsigned char TLS_ECDSA_SIGN_SHA512_OID[] = {0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x04, 0x05, 0x00, 0x00};\r
1213 \r
1214 static const unsigned char TLS_EC_PUBLIC_KEY_OID[] = {0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x02, 0x01, 0x00};\r
1215 \r
1216 static const unsigned char TLS_EC_prime192v1_OID[] = {0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03, 0x01, 0x01, 0x00};\r
1217 static const unsigned char TLS_EC_prime192v2_OID[] = {0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03, 0x01, 0x02, 0x00};\r
1218 static const unsigned char TLS_EC_prime192v3_OID[] = {0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03, 0x01, 0x03, 0x00};\r
1219 static const unsigned char TLS_EC_prime239v1_OID[] = {0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03, 0x01, 0x04, 0x00};\r
1220 static const unsigned char TLS_EC_prime239v2_OID[] = {0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03, 0x01, 0x05, 0x00};\r
1221 static const unsigned char TLS_EC_prime239v3_OID[] = {0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03, 0x01, 0x06, 0x00};\r
1222 static const unsigned char TLS_EC_prime256v1_OID[] = {0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03, 0x01, 0x07, 0x00};\r
1223 \r
1224 #define TLS_EC_secp256r1_OID    TLS_EC_prime256v1_OID\r
1225 static const unsigned char TLS_EC_secp224r1_OID[] = {0x2B, 0x81, 0x04, 0x00, 0x21, 0x00};\r
1226 static const unsigned char TLS_EC_secp384r1_OID[] = {0x2B, 0x81, 0x04, 0x00, 0x22, 0x00};\r
1227 static const unsigned char TLS_EC_secp521r1_OID[] = {0x2B, 0x81, 0x04, 0x00, 0x23, 0x00};\r
1228 \r
1229 struct TLSCertificate *asn1_parse(struct TLSContext *context, const unsigned char *buffer, int size, int client_cert);\r
1230 int __private_tls_update_hash(struct TLSContext *context, const unsigned char *in, unsigned int len);\r
1231 struct TLSPacket *tls_build_finished(struct TLSContext *context);\r
1232 unsigned int __private_tls_hmac_message(unsigned char local, struct TLSContext *context, const unsigned char *buf, int buf_len, const unsigned char *buf2, int buf_len2, unsigned char *out, unsigned int outlen, uint64_t remote_sequence_number);\r
1233 int tls_random(unsigned char *key, int len);\r
1234 void tls_destroy_packet(struct TLSPacket *packet);\r
1235 struct TLSPacket *tls_build_hello(struct TLSContext *context);\r
1236 struct TLSPacket *tls_build_certificate(struct TLSContext *context);\r
1237 struct TLSPacket *tls_build_done(struct TLSContext *context);\r
1238 struct TLSPacket *tls_build_alert(struct TLSContext *context, char critical, unsigned char code);\r
1239 struct TLSPacket *tls_build_change_cipher_spec(struct TLSContext *context);\r
1240 struct TLSPacket *tls_build_verify_request(struct TLSContext *context);\r
1241 int __private_tls_crypto_create(struct TLSContext *context, int key_length, int iv_length, unsigned char *localkey, unsigned char *localiv, unsigned char *remotekey, unsigned char *remoteiv);\r
1242 int __private_tls_get_hash(struct TLSContext *context, unsigned char *hout);\r
1243 int __private_tls_build_random(struct TLSPacket *packet);\r
1244 unsigned int __private_tls_mac_length(struct TLSContext *context);\r
1245 void __private_dtls_handshake_data(struct TLSContext *context, struct TLSPacket *packet, unsigned int dataframe);\r
1246 #ifdef TLS_FORWARD_SECRECY\r
1247 void __private_tls_dhe_free(struct TLSContext *context);\r
1248 void __private_tls_ecc_dhe_free(struct TLSContext *context);\r
1249 void __private_tls_dh_clear_key(DHKey *key);\r
1250 #endif\r
1251 \r
1252 static unsigned char dependecies_loaded = 0;\r
1253 // not supported\r
1254 // static unsigned char TLS_DSA_SIGN_SHA1_OID[] = {0x2A, 0x86, 0x52, 0xCE, 0x38, 0x04, 0x03, 0x00};\r
1255 \r
1256 // base64 stuff\r
1257 static const char cd64[] = "|$$$}rstuvwxyz{$$$$$$$>?@ABCDEFGHIJKLMNOPQRSTUVW$$$$$$XYZ[\\]^_`abcdefghijklmnopq";\r
1258 \r
1259 void __private_b64_decodeblock(unsigned char in[4], unsigned char out[3]) {\r
1260     out[0] = (unsigned char )(in[0] << 2 | in[1] >> 4);\r
1261     out[1] = (unsigned char )(in[1] << 4 | in[2] >> 2);\r
1262     out[2] = (unsigned char )(((in[2] << 6) & 0xc0) | in[3]);\r
1263 }\r
1264 \r
1265 int __private_b64_decode(const char *in_buffer, int in_buffer_size, unsigned char *out_buffer) {\r
1266     unsigned char in[4], out[3], v;\r
1267     int           i, len;\r
1268     \r
1269     const char *ptr     = in_buffer;\r
1270     char *out_ptr = (char *)out_buffer;\r
1271     \r
1272     while (ptr <= in_buffer + in_buffer_size) {\r
1273         for (len = 0, i = 0; i < 4 && (ptr <= in_buffer + in_buffer_size); i++) {\r
1274             v = 0;\r
1275             while ((ptr <= in_buffer + in_buffer_size) && v == 0) {\r
1276                 v = (unsigned char)ptr[0];\r
1277                 ptr++;\r
1278                 v = (unsigned char)((v < 43 || v > 122) ? 0 : cd64[v - 43]);\r
1279                 if (v)\r
1280                     v = (unsigned char)((v == '$') ? 0 : v - 61);\r
1281             }\r
1282             if (ptr <= in_buffer + in_buffer_size) {\r
1283                 len++;\r
1284                 if (v)\r
1285                     in[i] = (unsigned char)(v - 1);\r
1286             } else {\r
1287                 in[i] = 0;\r
1288             }\r
1289         }\r
1290         if (len) {\r
1291             __private_b64_decodeblock(in, out);\r
1292             for (i = 0; i < len - 1; i++) {\r
1293                 out_ptr[0] = out[i];\r
1294                 out_ptr++;\r
1295             }\r
1296         }\r
1297     }\r
1298     return (int)((intptr_t)out_ptr - (intptr_t)out_buffer);\r
1299 }\r
1300 \r
1301 void tls_init() {\r
1302     if (dependecies_loaded)\r
1303         return;\r
1304     DEBUG_PRINT("Initializing dependencies\n");\r
1305     dependecies_loaded = 1;\r
1306 #ifdef LTM_DESC\r
1307     ltc_mp = ltm_desc;\r
1308 #else\r
1309 #ifdef TFM_DESC\r
1310     ltc_mp = tfm_desc;\r
1311 #else\r
1312 #ifdef GMP_DESC\r
1313     ltc_mp = gmp_desc;\r
1314 #endif\r
1315 #endif\r
1316 #endif\r
1317     register_prng(&sprng_desc);\r
1318     register_hash(&sha256_desc);\r
1319     register_hash(&sha1_desc);\r
1320     register_hash(&sha384_desc);\r
1321     register_hash(&sha512_desc);\r
1322     register_hash(&md5_desc);\r
1323     register_cipher(&aes_desc);\r
1324 #ifdef TLS_FORWARD_SECRECY\r
1325     init_curves();\r
1326 #endif\r
1327 }\r
1328 \r
1329 #ifdef TLS_FORWARD_SECRECY\r
1330 int __private_tls_dh_shared_secret(DHKey *private_key, DHKey *public_key, unsigned char *out, unsigned long *outlen) {\r
1331     void *tmp;\r
1332     unsigned long x;\r
1333     int err;\r
1334     \r
1335     if ((!private_key) || (!public_key) || (!out) || (!outlen))\r
1336         return TLS_GENERIC_ERROR;\r
1337     \r
1338     /* compute y^x mod p */\r
1339     if ((err = mp_init(&tmp)) != CRYPT_OK)\r
1340         return err;\r
1341     \r
1342     if ((err = mp_exptmod(public_key->y, private_key->x, private_key->p, tmp)) != CRYPT_OK) {\r
1343         mp_clear(tmp);\r
1344         return err;\r
1345     }\r
1346     \r
1347     x = (unsigned long)mp_unsigned_bin_size(tmp);\r
1348     if (*outlen < x) {\r
1349         err = CRYPT_BUFFER_OVERFLOW;\r
1350         mp_clear(tmp);\r
1351         return err;\r
1352     }\r
1353     \r
1354     if ((err = mp_to_unsigned_bin(tmp, out)) != CRYPT_OK) {\r
1355         mp_clear(tmp);\r
1356         return err;\r
1357     }\r
1358     *outlen = x;\r
1359     mp_clear(tmp);\r
1360     return 0;\r
1361 }\r
1362 \r
1363 unsigned char *__private_tls_decrypt_dhe(struct TLSContext *context, const unsigned char *buffer, unsigned int len, unsigned int *size, int clear_key) {\r
1364     *size = 0;\r
1365     if ((!len) || (!context) || (!context->dhe)) {\r
1366         DEBUG_PRINT("No private DHE key set\n");\r
1367         return NULL;\r
1368     }\r
1369     \r
1370     unsigned char *out = (unsigned char *)TLS_MALLOC(len);\r
1371     unsigned long out_size = len;\r
1372     void *Yc = NULL;\r
1373     \r
1374     if (mp_init(&Yc)) {\r
1375         DEBUG_PRINT("ERROR CREATING Yc\n");\r
1376         return NULL;\r
1377     }\r
1378     if (mp_read_unsigned_bin(Yc, (unsigned char *)buffer, len)) {\r
1379         DEBUG_PRINT("ERROR LOADING DHE Yc\n");\r
1380         mp_clear(Yc);\r
1381         return NULL;\r
1382     }\r
1383     DHKey client_key;\r
1384     memset(&client_key, 0, sizeof(DHKey));\r
1385     \r
1386     client_key.p = context->dhe->p;\r
1387     client_key.g = context->dhe->g;\r
1388     client_key.y = Yc;\r
1389     int err = __private_tls_dh_shared_secret(context->dhe, &client_key, out, &out_size);\r
1390     // don't delete p and g\r
1391     client_key.p = NULL;\r
1392     client_key.g = NULL;\r
1393     __private_tls_dh_clear_key(&client_key);\r
1394     // not needing the dhe key anymore\r
1395     if (clear_key)\r
1396         __private_tls_dhe_free(context);\r
1397     if (err) {\r
1398         DEBUG_PRINT("DHE DECRYPT ERROR %i\n", err);\r
1399         TLS_FREE(out);\r
1400         return NULL;\r
1401     }\r
1402     DEBUG_PRINT("OUT_SIZE: %lu\n", out_size);\r
1403     DEBUG_DUMP_HEX_LABEL("DHE", out, out_size);\r
1404     *size = (unsigned int)out_size;\r
1405     return out;\r
1406 }\r
1407 \r
1408 unsigned char *__private_tls_decrypt_ecc_dhe(struct TLSContext *context, const unsigned char *buffer, unsigned int len, unsigned int *size, int clear_key) {\r
1409     *size = 0;\r
1410     if ((!len) || (!context) || (!context->ecc_dhe)) {\r
1411         DEBUG_PRINT("No private ECC DHE key set\n");\r
1412         return NULL;\r
1413     }\r
1414     \r
1415     const struct ECCCurveParameters *curve;\r
1416     if (context->curve)\r
1417         curve = context->curve;\r
1418     else\r
1419         curve = default_curve;\r
1420     \r
1421     ltc_ecc_set_type *dp = (ltc_ecc_set_type *)&curve->dp;\r
1422     \r
1423     ecc_key client_key;\r
1424     memset(&client_key, 0, sizeof(client_key));\r
1425     if (ecc_ansi_x963_import_ex(buffer, len, &client_key, dp)) {\r
1426         DEBUG_PRINT("Error importing ECC DHE key\n");\r
1427         return NULL;\r
1428     }\r
1429     unsigned char *out = (unsigned char *)TLS_MALLOC(len);\r
1430     unsigned long out_size = len;\r
1431     \r
1432     int err = ecc_shared_secret(context->ecc_dhe, &client_key, out, &out_size);\r
1433     ecc_free(&client_key);\r
1434     if (clear_key)\r
1435         __private_tls_ecc_dhe_free(context);\r
1436     if (err) {\r
1437         DEBUG_PRINT("ECC DHE DECRYPT ERROR %i\n", err);\r
1438         TLS_FREE(out);\r
1439         return NULL;\r
1440     }\r
1441     DEBUG_PRINT("OUT_SIZE: %lu\n", out_size);\r
1442     DEBUG_DUMP_HEX_LABEL("ECC DHE", out, out_size);\r
1443     *size = (unsigned int)out_size;\r
1444     return out;\r
1445 }\r
1446 #endif\r
1447 \r
1448 unsigned char *__private_tls_decrypt_rsa(struct TLSContext *context, const unsigned char *buffer, unsigned int len, unsigned int *size) {\r
1449     *size = 0;\r
1450     if ((!len) || (!context) || (!context->private_key) || (!context->private_key->der_bytes) || (!context->private_key->der_len)) {\r
1451         DEBUG_PRINT("No private key set\n");\r
1452         return NULL;\r
1453     }\r
1454     tls_init();\r
1455     rsa_key key;\r
1456     int err;\r
1457     err = rsa_import(context->private_key->der_bytes, context->private_key->der_len, &key);\r
1458     \r
1459     if (err) {\r
1460         DEBUG_PRINT("Error importing RSA key (code: %i)\n", err);\r
1461         return NULL;\r
1462     }\r
1463     unsigned char *out = (unsigned char *)TLS_MALLOC(len);\r
1464     unsigned long out_size = len;\r
1465     int hash_idx = find_hash("sha256");\r
1466     int res = 0;\r
1467     err = rsa_decrypt_key_ex(buffer, len, out, &out_size, (unsigned char *)"Concept", 7, hash_idx, LTC_PKCS_1_V1_5, &res, &key);\r
1468     rsa_free(&key);\r
1469     if ((err) || (!out_size)) {\r
1470         DEBUG_PRINT("RSA DECRYPT ERROR\n");\r
1471         TLS_FREE(out);\r
1472         return NULL;\r
1473     }\r
1474     *size = (unsigned int)out_size;\r
1475     return out;\r
1476 }\r
1477 \r
1478 unsigned char *__private_tls_encrypt_rsa(struct TLSContext *context, const unsigned char *buffer, unsigned int len, unsigned int *size) {\r
1479     *size = 0;\r
1480     if ((!len) || (!context) || (!context->certificates) || (!context->certificates_count) || (!context->certificates[0]) ||\r
1481         (!context->certificates[0]->der_bytes) || (!context->certificates[0]->der_len)) {\r
1482         DEBUG_PRINT("No certificate set\n");\r
1483         return NULL;\r
1484     }\r
1485     tls_init();\r
1486     rsa_key key;\r
1487     int err;\r
1488     err = rsa_import(context->certificates[0]->der_bytes, context->certificates[0]->der_len, &key);\r
1489     \r
1490     if (err) {\r
1491         DEBUG_PRINT("Error importing RSA certificate (code: %i)\n", err);\r
1492         return NULL;\r
1493     }\r
1494     unsigned long out_size = __TLS_MAX_RSA_KEY;\r
1495     unsigned char *out = (unsigned char *)TLS_MALLOC(out_size);\r
1496     int hash_idx = find_hash("sha256");\r
1497     int prng_idx = find_prng("sprng");\r
1498     err = rsa_encrypt_key_ex(buffer, len, out, &out_size, (unsigned char *)"Concept", 7, NULL, prng_idx, hash_idx, LTC_PKCS_1_V1_5, &key);\r
1499     rsa_free(&key);\r
1500     if ((err) || (!out_size)) {\r
1501         TLS_FREE(out);\r
1502         return NULL;\r
1503     }\r
1504     *size = (unsigned int)out_size;\r
1505     return out;\r
1506 }\r
1507 \r
1508 #ifdef TLS_LEGACY_SUPPORT\r
1509 int __private_rsa_verify_hash_md5sha1(const unsigned char *sig, unsigned long siglen, unsigned char *hash, unsigned long hashlen, int *stat, rsa_key *key) {\r
1510     unsigned long modulus_bitlen, modulus_bytelen, x;\r
1511     int           err;\r
1512     unsigned char *tmpbuf = NULL;\r
1513     \r
1514     if ((hash == NULL) || (sig == NULL) || (stat == NULL) || (key == NULL) || (!siglen) || (!hashlen))\r
1515         return TLS_GENERIC_ERROR;\r
1516     \r
1517     *stat = 0;\r
1518     \r
1519     modulus_bitlen = mp_count_bits((key->N));\r
1520     \r
1521     modulus_bytelen = mp_unsigned_bin_size((key->N));\r
1522     if (modulus_bytelen != siglen)\r
1523         return TLS_GENERIC_ERROR;\r
1524     \r
1525     tmpbuf = (unsigned char *)TLS_MALLOC(siglen);\r
1526     if (!tmpbuf)\r
1527         return TLS_GENERIC_ERROR;\r
1528     \r
1529     x = siglen;\r
1530     if ((err = ltc_mp.rsa_me(sig, siglen, tmpbuf, &x, PK_PUBLIC, key)) != CRYPT_OK) {\r
1531         TLS_FREE(tmpbuf);\r
1532         return err;\r
1533     }\r
1534     \r
1535     if (x != siglen) {\r
1536         TLS_FREE(tmpbuf);\r
1537         return CRYPT_INVALID_PACKET;\r
1538     }\r
1539     unsigned long out_len = siglen;\r
1540     unsigned char *out = (unsigned char *)TLS_MALLOC(siglen);\r
1541     if (!out) {\r
1542         TLS_FREE(tmpbuf);\r
1543         return TLS_GENERIC_ERROR;\r
1544     }\r
1545     \r
1546     int decoded = 0;\r
1547     err = pkcs_1_v1_5_decode(tmpbuf, x, LTC_PKCS_1_EMSA, modulus_bitlen, out, &out_len, &decoded);\r
1548     if (decoded) {\r
1549         if (out_len == hashlen) {\r
1550             if (!memcmp(out, hash, hashlen))\r
1551                 *stat = 1;\r
1552         }\r
1553     }\r
1554     \r
1555     TLS_FREE(tmpbuf);\r
1556     TLS_FREE(out);\r
1557     return err;\r
1558 }\r
1559 #endif\r
1560 \r
1561 int __private_tls_verify_rsa(struct TLSContext *context, unsigned int hash_type, const unsigned char *buffer, unsigned int len, const unsigned char *message, unsigned int message_len) {\r
1562     tls_init();\r
1563     rsa_key key;\r
1564     int err;\r
1565     \r
1566     if (context->is_server) {\r
1567         if ((!len) || (!context) || (!context->client_certificates) || (!context->client_certificates_count) || (!context->client_certificates[0]) ||\r
1568             (!context->client_certificates[0]->der_bytes) || (!context->client_certificates[0]->der_len)) {\r
1569             DEBUG_PRINT("No client certificate set\n");\r
1570             return TLS_GENERIC_ERROR;\r
1571         }\r
1572         err = rsa_import(context->client_certificates[0]->der_bytes, context->client_certificates[0]->der_len, &key);\r
1573     } else {\r
1574         if ((!len) || (!context) || (!context->certificates) || (!context->certificates_count) || (!context->certificates[0]) ||\r
1575             (!context->certificates[0]->der_bytes) || (!context->certificates[0]->der_len)) {\r
1576             DEBUG_PRINT("No server certificate set\n");\r
1577             return TLS_GENERIC_ERROR;\r
1578         }\r
1579         err = rsa_import(context->certificates[0]->der_bytes, context->certificates[0]->der_len, &key);\r
1580     }\r
1581     if (err) {\r
1582         DEBUG_PRINT("Error importing RSA certificate (code: %i)\n", err);\r
1583         return TLS_GENERIC_ERROR;\r
1584     }\r
1585     int hash_idx = -1;\r
1586     unsigned char hash[__TLS_MAX_HASH_LEN];\r
1587     unsigned int hash_len = 0;\r
1588     hash_state state;\r
1589     switch (hash_type) {\r
1590         case md5:\r
1591             hash_idx = find_hash("md5");\r
1592             err = md5_init(&state);\r
1593             if (!err) {\r
1594                 err = md5_process(&state, message, message_len);\r
1595                 if (!err)\r
1596                     err = md5_done(&state, hash);\r
1597             }\r
1598             hash_len = 16;\r
1599             break;\r
1600         case sha1:\r
1601             hash_idx = find_hash("sha1");\r
1602             err = sha1_init(&state);\r
1603             if (!err) {\r
1604                 err = sha1_process(&state, message, message_len);\r
1605                 if (!err)\r
1606                     err = sha1_done(&state, hash);\r
1607             }\r
1608             hash_len = 20;\r
1609             break;\r
1610         case sha256:\r
1611             hash_idx = find_hash("sha256");\r
1612             err = sha256_init(&state);\r
1613             if (!err) {\r
1614                 err = sha256_process(&state, message, message_len);\r
1615                 if (!err)\r
1616                     err = sha256_done(&state, hash);\r
1617             }\r
1618             hash_len = 32;\r
1619             break;\r
1620         case sha384:\r
1621             hash_idx = find_hash("sha384");\r
1622             err = sha384_init(&state);\r
1623             if (!err) {\r
1624                 err = sha384_process(&state, message, message_len);\r
1625                 if (!err)\r
1626                     err = sha384_done(&state, hash);\r
1627             }\r
1628             hash_len = 48;\r
1629             break;\r
1630         case sha512:\r
1631             hash_idx = find_hash("sha512");\r
1632             err = sha512_init(&state);\r
1633             if (!err) {\r
1634                 err = sha512_process(&state, message, message_len);\r
1635                 if (!err)\r
1636                     err = sha512_done(&state, hash);\r
1637             }\r
1638             hash_len = 64;\r
1639             break;\r
1640 #ifdef TLS_LEGACY_SUPPORT\r
1641         case __md5_sha1:\r
1642             hash_idx = find_hash("md5");\r
1643             err = md5_init(&state);\r
1644             if (!err) {\r
1645                 err = md5_process(&state, message, message_len);\r
1646                 if (!err)\r
1647                     err = md5_done(&state, hash);\r
1648             }\r
1649             hash_idx = find_hash("sha1");\r
1650             err = sha1_init(&state);\r
1651             if (!err) {\r
1652                 err = sha1_process(&state, message, message_len);\r
1653                 if (!err)\r
1654                     err = sha1_done(&state, hash + 16);\r
1655             }\r
1656             hash_len = 36;\r
1657             err = sha1_init(&state);\r
1658             if (!err) {\r
1659                 err = sha1_process(&state, message, message_len);\r
1660                 if (!err)\r
1661                     err = sha1_done(&state, hash + 16);\r
1662             }\r
1663             hash_len = 36;\r
1664             break;\r
1665 #endif\r
1666     }\r
1667     if ((hash_idx < 0) || (err)) {\r
1668         DEBUG_PRINT("Unsupported hash type: %i\n", hash_type);\r
1669         return TLS_GENERIC_ERROR;\r
1670     }\r
1671     int rsa_stat = 0;\r
1672 #ifdef TLS_LEGACY_SUPPORT\r
1673     if (hash_type == __md5_sha1)\r
1674         err = __private_rsa_verify_hash_md5sha1(buffer, len, hash, hash_len, &rsa_stat, &key);\r
1675     else\r
1676 #endif\r
1677         err = rsa_verify_hash_ex(buffer, len, hash, hash_len, LTC_PKCS_1_V1_5, hash_idx, 0, &rsa_stat, &key);\r
1678     rsa_free(&key);\r
1679     if (err)\r
1680         return 0;\r
1681     return rsa_stat;\r
1682 }\r
1683 \r
1684 #ifdef TLS_LEGACY_SUPPORT\r
1685 int __private_rsa_sign_hash_md5sha1(const unsigned char *in, unsigned long inlen, unsigned char *out, unsigned long *outlen, prng_state *prng, int prng_idx, unsigned long saltlen, rsa_key *key) {\r
1686     unsigned long modulus_bitlen, modulus_bytelen, x;\r
1687     int err;\r
1688     \r
1689     if ((in == NULL) || (out == NULL) || (outlen == NULL) || (key == NULL))\r
1690         return TLS_GENERIC_ERROR;\r
1691     \r
1692     modulus_bitlen = mp_count_bits((key->N));\r
1693     \r
1694     modulus_bytelen = mp_unsigned_bin_size((key->N));\r
1695     if (modulus_bytelen > *outlen) {\r
1696         *outlen = modulus_bytelen;\r
1697         return CRYPT_BUFFER_OVERFLOW;\r
1698     }\r
1699     x = modulus_bytelen;\r
1700     err = pkcs_1_v1_5_encode(in, inlen, LTC_PKCS_1_EMSA, modulus_bitlen, NULL, 0, out, &x);\r
1701     if (err != CRYPT_OK)\r
1702         return err;\r
1703     \r
1704     return ltc_mp.rsa_me(out, x, out, outlen, PK_PRIVATE, key);\r
1705 }\r
1706 #endif\r
1707 \r
1708 int __private_tls_sign_rsa(struct TLSContext *context, unsigned int hash_type, const unsigned char *message, unsigned int message_len, unsigned char *out, unsigned long *outlen) {\r
1709     if ((!outlen) || (!context) || (!out) || (!outlen) || (!context->private_key) || (!context->private_key->der_bytes) || (!context->private_key->der_len)) {\r
1710         DEBUG_PRINT("No private key set\n");\r
1711         return TLS_GENERIC_ERROR;\r
1712     }\r
1713     tls_init();\r
1714     rsa_key key;\r
1715     int err;\r
1716     err = rsa_import(context->private_key->der_bytes, context->private_key->der_len, &key);\r
1717     \r
1718     if (err) {\r
1719         DEBUG_PRINT("Error importing RSA certificate (code: %i)\n", err);\r
1720         return TLS_GENERIC_ERROR;\r
1721     }\r
1722     int hash_idx = -1;\r
1723     unsigned char hash[__TLS_MAX_HASH_LEN];\r
1724     unsigned int hash_len = 0;\r
1725     hash_state state;\r
1726     switch (hash_type) {\r
1727         case md5:\r
1728             hash_idx = find_hash("md5");\r
1729             err = md5_init(&state);\r
1730             if (!err) {\r
1731                 err = md5_process(&state, message, message_len);\r
1732                 if (!err)\r
1733                     err = md5_done(&state, hash);\r
1734             }\r
1735             hash_len = 16;\r
1736             break;\r
1737         case sha1:\r
1738             hash_idx = find_hash("sha1");\r
1739             err = sha1_init(&state);\r
1740             if (!err) {\r
1741                 err = sha1_process(&state, message, message_len);\r
1742                 if (!err)\r
1743                     err = sha1_done(&state, hash);\r
1744             }\r
1745             hash_len = 20;\r
1746             break;\r
1747         case sha256:\r
1748             hash_idx = find_hash("sha256");\r
1749             err = sha256_init(&state);\r
1750             if (!err) {\r
1751                 err = sha256_process(&state, message, message_len);\r
1752                 if (!err)\r
1753                     err = sha256_done(&state, hash);\r
1754             }\r
1755             hash_len = 32;\r
1756             break;\r
1757         case sha384:\r
1758             hash_idx = find_hash("sha384");\r
1759             err = sha384_init(&state);\r
1760             if (!err) {\r
1761                 err = sha384_process(&state, message, message_len);\r
1762                 if (!err)\r
1763                     err = sha384_done(&state, hash);\r
1764             }\r
1765             hash_len = 48;\r
1766             break;\r
1767         case sha512:\r
1768             hash_idx = find_hash("sha512");\r
1769             err = sha512_init(&state);\r
1770             if (!err) {\r
1771                 err = sha512_process(&state, message, message_len);\r
1772                 if (!err)\r
1773                     err = sha512_done(&state, hash);\r
1774             }\r
1775             hash_len = 64;\r
1776             break;\r
1777         case __md5_sha1:\r
1778             hash_idx = find_hash("md5");\r
1779             err = md5_init(&state);\r
1780             if (!err) {\r
1781                 err = md5_process(&state, message, message_len);\r
1782                 if (!err)\r
1783                     err = md5_done(&state, hash);\r
1784             }\r
1785             hash_idx = find_hash("sha1");\r
1786             err = sha1_init(&state);\r
1787             if (!err) {\r
1788                 err = sha1_process(&state, message, message_len);\r
1789                 if (!err)\r
1790                     err = sha1_done(&state, hash + 16);\r
1791             }\r
1792             hash_len = 36;\r
1793             err = sha1_init(&state);\r
1794             if (!err) {\r
1795                 err = sha1_process(&state, message, message_len);\r
1796                 if (!err)\r
1797                     err = sha1_done(&state, hash + 16);\r
1798             }\r
1799             hash_len = 36;\r
1800             break;\r
1801     }\r
1802 #ifdef TLS_LEGACY_SUPPORT\r
1803     if (hash_type == __md5_sha1) {\r
1804         if (err) {\r
1805             DEBUG_PRINT("Unsupported hash type: %i\n", hash_type);\r
1806             return TLS_GENERIC_ERROR;\r
1807         }\r
1808         err = __private_rsa_sign_hash_md5sha1(hash, hash_len, out, outlen, NULL, find_prng("sprng"), 0, &key);\r
1809     } else\r
1810 #endif\r
1811     {\r
1812         if ((hash_idx < 0) || (err)) {\r
1813             DEBUG_PRINT("Unsupported hash type: %i\n", hash_type);\r
1814             return TLS_GENERIC_ERROR;\r
1815         }\r
1816         err = rsa_sign_hash_ex(hash, hash_len, out, outlen, LTC_PKCS_1_V1_5, NULL, find_prng("sprng"), hash_idx, 0, &key);\r
1817     }\r
1818     rsa_free(&key);\r
1819     if (err)\r
1820         return 0;\r
1821     \r
1822     return 1;\r
1823 }\r
1824 \r
1825 #ifdef TLS_ECDSA_SUPPORTED\r
1826 static int __private_tls_is_point(ecc_key *key) {\r
1827     void *prime, *b, *t1, *t2;\r
1828     int  err;\r
1829     \r
1830     if ((err = mp_init_multi(&prime, &b, &t1, &t2, NULL)) != CRYPT_OK) {\r
1831         return err;\r
1832     }\r
1833     \r
1834     /* load prime and b */\r
1835     if ((err = mp_read_radix(prime, key->dp->prime, 16)) != CRYPT_OK) {\r
1836         goto error;\r
1837     }\r
1838     if ((err = mp_read_radix(b, key->dp->B, 16)) != CRYPT_OK) {\r
1839         goto error;\r
1840     }\r
1841     \r
1842     /* compute y^2 */\r
1843     if ((err = mp_sqr(key->pubkey.y, t1)) != CRYPT_OK) {\r
1844         goto error;\r
1845     }\r
1846     \r
1847     /* compute x^3 */\r
1848     if ((err = mp_sqr(key->pubkey.x, t2)) != CRYPT_OK) {\r
1849         goto error;\r
1850     }\r
1851     if ((err = mp_mod(t2, prime, t2)) != CRYPT_OK) {\r
1852         goto error;\r
1853     }\r
1854     if ((err = mp_mul(key->pubkey.x, t2, t2)) != CRYPT_OK) {\r
1855         goto error;\r
1856     }\r
1857     \r
1858     /* compute y^2 - x^3 */\r
1859     if ((err = mp_sub(t1, t2, t1)) != CRYPT_OK) {\r
1860         goto error;\r
1861     }\r
1862     \r
1863     /* compute y^2 - x^3 + 3x */\r
1864     if ((err = mp_add(t1, key->pubkey.x, t1)) != CRYPT_OK) {\r
1865         goto error;\r
1866     }\r
1867     if ((err = mp_add(t1, key->pubkey.x, t1)) != CRYPT_OK) {\r
1868         goto error;\r
1869     }\r
1870     if ((err = mp_add(t1, key->pubkey.x, t1)) != CRYPT_OK) {\r
1871         goto error;\r
1872     }\r
1873     if ((err = mp_mod(t1, prime, t1)) != CRYPT_OK) {\r
1874         goto error;\r
1875     }\r
1876     while (mp_cmp_d(t1, 0) == LTC_MP_LT) {\r
1877         if ((err = mp_add(t1, prime, t1)) != CRYPT_OK) {\r
1878             goto error;\r
1879         }\r
1880     }\r
1881     while (mp_cmp(t1, prime) != LTC_MP_LT) {\r
1882         if ((err = mp_sub(t1, prime, t1)) != CRYPT_OK) {\r
1883             goto error;\r
1884         }\r
1885     }\r
1886     \r
1887     /* compare to b */\r
1888     if (mp_cmp(t1, b) != LTC_MP_EQ) {\r
1889         err = CRYPT_INVALID_PACKET;\r
1890     } else {\r
1891         err = CRYPT_OK;\r
1892     }\r
1893     \r
1894 error:\r
1895     mp_clear_multi(prime, b, t1, t2, NULL);\r
1896     return err;\r
1897 }\r
1898 \r
1899 int __private_tls_ecc_import_key(const unsigned char *private_key, int private_len, const unsigned char *public_key, int public_len, ecc_key *key, const ltc_ecc_set_type *dp) {\r
1900     int           err;\r
1901     \r
1902     if ((!key) || (!ltc_mp.name))\r
1903         return CRYPT_MEM;\r
1904         \r
1905     key->type = PK_PRIVATE;\r
1906     \r
1907     if (mp_init_multi(&key->pubkey.x, &key->pubkey.y, &key->pubkey.z, &key->k, NULL) != CRYPT_OK)\r
1908         return CRYPT_MEM;\r
1909     \r
1910     if ((public_len) && (!public_key[0])) {\r
1911         public_key++;\r
1912         public_len--;\r
1913     }\r
1914     if ((err = mp_read_unsigned_bin(key->pubkey.x, (unsigned char *)public_key + 1, (public_len - 1) >> 1)) != CRYPT_OK) {\r
1915         mp_clear_multi(key->pubkey.x, key->pubkey.y, key->pubkey.z, key->k, NULL);\r
1916         return err;\r
1917     }\r
1918     \r
1919     if ((err = mp_read_unsigned_bin(key->pubkey.y, (unsigned char *)public_key + 1 + ((public_len - 1) >> 1), (public_len - 1) >> 1)) != CRYPT_OK) {\r
1920         mp_clear_multi(key->pubkey.x, key->pubkey.y, key->pubkey.z, key->k, NULL);\r
1921         return err;\r
1922     }\r
1923     \r
1924     if ((err = mp_read_unsigned_bin(key->k, (unsigned char *)private_key, private_len)) != CRYPT_OK) {\r
1925         mp_clear_multi(key->pubkey.x, key->pubkey.y, key->pubkey.z, key->k, NULL);\r
1926         return err;\r
1927     }\r
1928     \r
1929     key->idx = -1;\r
1930     key->dp  = dp;\r
1931     \r
1932     /* set z */\r
1933     if ((err = mp_set(key->pubkey.z, 1)) != CRYPT_OK) {\r
1934         mp_clear_multi(key->pubkey.x, key->pubkey.y, key->pubkey.z, key->k, NULL);\r
1935         return err;\r
1936     }\r
1937     \r
1938     /* is it a point on the curve?  */\r
1939     if ((err = __private_tls_is_point(key)) != CRYPT_OK) {\r
1940         DEBUG_PRINT("KEY IS NOT ON CURVE\n");\r
1941         mp_clear_multi(key->pubkey.x, key->pubkey.y, key->pubkey.z, key->k, NULL);\r
1942         return err;\r
1943     }\r
1944     \r
1945     /* we're good */\r
1946     return CRYPT_OK;\r
1947 }\r
1948 \r
1949 int __private_tls_sign_ecdsa(struct TLSContext *context, unsigned int hash_type, const unsigned char *message, unsigned int message_len, unsigned char *out, unsigned long *outlen) {\r
1950     if ((!outlen) || (!context) || (!out) || (!outlen) || (!context->ec_private_key) ||\r
1951         (!context->ec_private_key->priv) || (!context->ec_private_key->priv_len) || (!context->ec_private_key->pk) || (!context->ec_private_key->pk_len)) {\r
1952         DEBUG_PRINT("No private ECDSA key set\n");\r
1953         return TLS_GENERIC_ERROR;\r
1954     }\r
1955     \r
1956     const struct ECCCurveParameters *curve = NULL;\r
1957     \r
1958     switch (context->ec_private_key->ec_algorithm) {\r
1959         case 19:\r
1960             curve = &secp192r1;\r
1961             break;\r
1962         case 20:\r
1963             curve = &secp224k1;\r
1964             break;\r
1965         case 21:\r
1966             curve = &secp224r1;\r
1967             break;\r
1968         case 22:\r
1969             curve = &secp256k1;\r
1970             break;\r
1971         case 23:\r
1972             curve = &secp256r1;\r
1973             break;\r
1974         case 24:\r
1975             curve = &secp384r1;\r
1976             break;\r
1977         case 25:\r
1978             curve = &secp521r1;\r
1979             break;\r
1980         default:\r
1981             DEBUG_PRINT("UNSUPPORTED CURVE\n");\r
1982             return TLS_GENERIC_ERROR;\r
1983     }\r
1984     \r
1985     if (!curve)\r
1986         return TLS_GENERIC_ERROR;\r
1987     \r
1988     tls_init();\r
1989     ecc_key key;\r
1990     int err;\r
1991     \r
1992     ltc_ecc_set_type *dp = (ltc_ecc_set_type *)&curve->dp;\r
1993     \r
1994     // broken ... fix this\r
1995     err = __private_tls_ecc_import_key(context->ec_private_key->priv, context->ec_private_key->priv_len, context->ec_private_key->pk, context->ec_private_key->pk_len, &key, dp);\r
1996     if (err) {\r
1997         DEBUG_PRINT("Error importing ECC certificate (code: %i)\n", (int)err);\r
1998         return TLS_GENERIC_ERROR;\r
1999     }\r
2000     int hash_idx = -1;\r
2001     unsigned char hash[__TLS_MAX_HASH_LEN];\r
2002     unsigned int hash_len = 0;\r
2003     hash_state state;\r
2004     switch (hash_type) {\r
2005         case md5:\r
2006             hash_idx = find_hash("md5");\r
2007             err = md5_init(&state);\r
2008             if (!err) {\r
2009                 err = md5_process(&state, message, message_len);\r
2010                 if (!err)\r
2011                     err = md5_done(&state, hash);\r
2012             }\r
2013             hash_len = 16;\r
2014             break;\r
2015         case sha1:\r
2016             hash_idx = find_hash("sha1");\r
2017             err = sha1_init(&state);\r
2018             if (!err) {\r
2019                 err = sha1_process(&state, message, message_len);\r
2020                 if (!err)\r
2021                     err = sha1_done(&state, hash);\r
2022             }\r
2023             hash_len = 20;\r
2024             break;\r
2025         case sha256:\r
2026             hash_idx = find_hash("sha256");\r
2027             err = sha256_init(&state);\r
2028             if (!err) {\r
2029                 err = sha256_process(&state, message, message_len);\r
2030                 if (!err)\r
2031                     err = sha256_done(&state, hash);\r
2032             }\r
2033             hash_len = 32;\r
2034             break;\r
2035         case sha384:\r
2036             hash_idx = find_hash("sha384");\r
2037             err = sha384_init(&state);\r
2038             if (!err) {\r
2039                 err = sha384_process(&state, message, message_len);\r
2040                 if (!err)\r
2041                     err = sha384_done(&state, hash);\r
2042             }\r
2043             hash_len = 48;\r
2044             break;\r
2045         case sha512:\r
2046             hash_idx = find_hash("sha512");\r
2047             err = sha512_init(&state);\r
2048             if (!err) {\r
2049                 err = sha512_process(&state, message, message_len);\r
2050                 if (!err)\r
2051                     err = sha512_done(&state, hash);\r
2052             }\r
2053             hash_len = 64;\r
2054             break;\r
2055         case __md5_sha1:\r
2056             hash_idx = find_hash("md5");\r
2057             err = md5_init(&state);\r
2058             if (!err) {\r
2059                 err = md5_process(&state, message, message_len);\r
2060                 if (!err)\r
2061                     err = md5_done(&state, hash);\r
2062             }\r
2063             hash_idx = find_hash("sha1");\r
2064             err = sha1_init(&state);\r
2065             if (!err) {\r
2066                 err = sha1_process(&state, message, message_len);\r
2067                 if (!err)\r
2068                     err = sha1_done(&state, hash + 16);\r
2069             }\r
2070             hash_len = 36;\r
2071             err = sha1_init(&state);\r
2072             if (!err) {\r
2073                 err = sha1_process(&state, message, message_len);\r
2074                 if (!err)\r
2075                     err = sha1_done(&state, hash + 16);\r
2076             }\r
2077             hash_len = 36;\r
2078             break;\r
2079     }\r
2080     \r
2081     if ((hash_idx < 0) || (err)) {\r
2082         DEBUG_PRINT("Unsupported hash type: %i\n", hash_type);\r
2083         return TLS_GENERIC_ERROR;\r
2084     }\r
2085     // "Let z be the Ln leftmost bits of e, where Ln is the bit length of the group order n."\r
2086     if (hash_len > curve->size)\r
2087         hash_len = curve->size;\r
2088     err = ecc_sign_hash(hash, hash_len, out, outlen, NULL, find_prng("sprng"), &key);\r
2089     DEBUG_DUMP_HEX_LABEL("ECC SIGNATURE", out, *outlen);\r
2090     ecc_free(&key);\r
2091     if (err)\r
2092         return 0;\r
2093     \r
2094     return 1;\r
2095 }\r
2096 \r
2097 #ifdef TLS_CLIENT_ECDSA\r
2098 int __private_tls_ecc_import_pk(const unsigned char *public_key, int public_len, ecc_key *key, const ltc_ecc_set_type *dp) {\r
2099     int           err;\r
2100     \r
2101     if ((!key) || (!ltc_mp.name))\r
2102         return CRYPT_MEM;\r
2103         \r
2104     key->type = PK_PUBLIC;\r
2105     \r
2106     if (mp_init_multi(&key->pubkey.x, &key->pubkey.y, &key->pubkey.z, &key->k, NULL) != CRYPT_OK)\r
2107         return CRYPT_MEM;\r
2108     \r
2109     if ((public_len) && (!public_key[0])) {\r
2110         public_key++;\r
2111         public_len--;\r
2112     }\r
2113     if ((err = mp_read_unsigned_bin(key->pubkey.x, (unsigned char *)public_key + 1, (public_len - 1) >> 1)) != CRYPT_OK) {\r
2114         mp_clear_multi(key->pubkey.x, key->pubkey.y, key->pubkey.z, key->k, NULL);\r
2115         return err;\r
2116     }\r
2117     \r
2118     if ((err = mp_read_unsigned_bin(key->pubkey.y, (unsigned char *)public_key + 1 + ((public_len - 1) >> 1), (public_len - 1) >> 1)) != CRYPT_OK) {\r
2119         mp_clear_multi(key->pubkey.x, key->pubkey.y, key->pubkey.z, key->k, NULL);\r
2120         return err;\r
2121     }\r
2122     \r
2123     \r
2124     key->idx = -1;\r
2125     key->dp  = dp;\r
2126     \r
2127     /* set z */\r
2128     if ((err = mp_set(key->pubkey.z, 1)) != CRYPT_OK) {\r
2129         mp_clear_multi(key->pubkey.x, key->pubkey.y, key->pubkey.z, key->k, NULL);\r
2130         return err;\r
2131     }\r
2132     \r
2133     /* is it a point on the curve?  */\r
2134     if ((err = __private_tls_is_point(key)) != CRYPT_OK) {\r
2135         DEBUG_PRINT("KEY IS NOT ON CURVE\n");\r
2136         mp_clear_multi(key->pubkey.x, key->pubkey.y, key->pubkey.z, key->k, NULL);\r
2137         return err;\r
2138     }\r
2139     \r
2140     /* we're good */\r
2141     return CRYPT_OK;\r
2142 }\r
2143 \r
2144 int __private_tls_verify_ecdsa(struct TLSContext *context, unsigned int hash_type, const unsigned char *buffer, unsigned int len, const unsigned char *message, unsigned int message_len) {\r
2145     tls_init();\r
2146     ecc_key key;\r
2147     int err;\r
2148     \r
2149     if (context->is_server) {\r
2150         if ((!len) || (!context) || (!context->client_certificates) || (!context->client_certificates_count) || (!context->client_certificates[0]) ||\r
2151             (!context->client_certificates[0]->pk) || (!context->client_certificates[0]->pk_len) || (!context->curve)) {\r
2152             DEBUG_PRINT("No client certificate set\n");\r
2153             return TLS_GENERIC_ERROR;\r
2154         }\r
2155         err = __private_tls_ecc_import_pk(context->client_certificates[0]->pk, context->client_certificates[0]->pk_len, &key, (ltc_ecc_set_type *)&context->curve->dp);\r
2156     } else {\r
2157         if ((!len) || (!context) || (!context->certificates) || (!context->certificates_count) || (!context->certificates[0]) ||\r
2158             (!context->certificates[0]->pk) || (!context->certificates[0]->pk_len) || (!context->curve)) {\r
2159             DEBUG_PRINT("No server certificate set\n");\r
2160             return TLS_GENERIC_ERROR;\r
2161         }\r
2162         err = __private_tls_ecc_import_pk(context->certificates[0]->pk, context->certificates[0]->pk_len, &key, (ltc_ecc_set_type *)&context->curve->dp);\r
2163     }\r
2164     if (err) {\r
2165         DEBUG_PRINT("Error importing ECC certificate (code: %i)", err);\r
2166         return TLS_GENERIC_ERROR;\r
2167     }\r
2168     int hash_idx = -1;\r
2169     unsigned char hash[__TLS_MAX_HASH_LEN];\r
2170     unsigned int hash_len = 0;\r
2171     hash_state state;\r
2172     switch (hash_type) {\r
2173         case md5:\r
2174             hash_idx = find_hash("md5");\r
2175             err = md5_init(&state);\r
2176             if (!err) {\r
2177                 err = md5_process(&state, message, message_len);\r
2178                 if (!err)\r
2179                     err = md5_done(&state, hash);\r
2180             }\r
2181             hash_len = 16;\r
2182             break;\r
2183         case sha1:\r
2184             hash_idx = find_hash("sha1");\r
2185             err = sha1_init(&state);\r
2186             if (!err) {\r
2187                 err = sha1_process(&state, message, message_len);\r
2188                 if (!err)\r
2189                     err = sha1_done(&state, hash);\r
2190             }\r
2191             hash_len = 20;\r
2192             break;\r
2193         case sha256:\r
2194             hash_idx = find_hash("sha256");\r
2195             err = sha256_init(&state);\r
2196             if (!err) {\r
2197                 err = sha256_process(&state, message, message_len);\r
2198                 if (!err)\r
2199                     err = sha256_done(&state, hash);\r
2200             }\r
2201             hash_len = 32;\r
2202             break;\r
2203         case sha384:\r
2204             hash_idx = find_hash("sha384");\r
2205             err = sha384_init(&state);\r
2206             if (!err) {\r
2207                 err = sha384_process(&state, message, message_len);\r
2208                 if (!err)\r
2209                     err = sha384_done(&state, hash);\r
2210             }\r
2211             hash_len = 48;\r
2212             break;\r
2213         case sha512:\r
2214             hash_idx = find_hash("sha512");\r
2215             err = sha512_init(&state);\r
2216             if (!err) {\r
2217                 err = sha512_process(&state, message, message_len);\r
2218                 if (!err)\r
2219                     err = sha512_done(&state, hash);\r
2220             }\r
2221             hash_len = 64;\r
2222             break;\r
2223 #ifdef TLS_LEGACY_SUPPORT\r
2224         case __md5_sha1:\r
2225             hash_idx = find_hash("md5");\r
2226             err = md5_init(&state);\r
2227             if (!err) {\r
2228                 err = md5_process(&state, message, message_len);\r
2229                 if (!err)\r
2230                     err = md5_done(&state, hash);\r
2231             }\r
2232             hash_idx = find_hash("sha1");\r
2233             err = sha1_init(&state);\r
2234             if (!err) {\r
2235                 err = sha1_process(&state, message, message_len);\r
2236                 if (!err)\r
2237                     err = sha1_done(&state, hash + 16);\r
2238             }\r
2239             hash_len = 36;\r
2240             err = sha1_init(&state);\r
2241             if (!err) {\r
2242                 err = sha1_process(&state, message, message_len);\r
2243                 if (!err)\r
2244                     err = sha1_done(&state, hash + 16);\r
2245             }\r
2246             hash_len = 36;\r
2247             break;\r
2248 #endif\r
2249     }\r
2250     if ((hash_idx < 0) || (err)) {\r
2251         DEBUG_PRINT("Unsupported hash type: %i\n", hash_type);\r
2252         return TLS_GENERIC_ERROR;\r
2253     }\r
2254     int ecc_stat = 0;\r
2255     err = ecc_verify_hash(buffer, len, hash, hash_len, &ecc_stat, &key);\r
2256     ecc_free(&key);\r
2257     if (err)\r
2258         return 0;\r
2259     return ecc_stat;\r
2260 }\r
2261 #endif\r
2262 \r
2263 #endif\r
2264 \r
2265 unsigned int __private_tls_random_int(int limit) {\r
2266     unsigned int res = 0;\r
2267     tls_random((unsigned char *)&res, sizeof(int));\r
2268     if (limit)\r
2269         res %= limit;\r
2270     return res;\r
2271 }\r
2272 \r
2273 void __private_tls_sleep(unsigned int microseconds) {\r
2274 #ifdef _WIN32\r
2275     Sleep(microseconds/1000);\r
2276 #else\r
2277     struct timespec ts;\r
2278     \r
2279     ts.tv_sec = (unsigned int) (microseconds / 1000000);\r
2280     ts.tv_nsec = (unsigned int) (microseconds % 1000000) * 1000ul;\r
2281     \r
2282     nanosleep(&ts, NULL);\r
2283 #endif\r
2284 }\r
2285 \r
2286 void __private_random_sleep(struct TLSContext *context, int max_microseconds) {\r
2287     if (context)\r
2288         context->sleep_until = time(NULL) + __private_tls_random_int(max_microseconds/1000000 * __TLS_MAX_ERROR_IDLE_S);\r
2289     else\r
2290         __private_tls_sleep(__private_tls_random_int(max_microseconds));\r
2291 }\r
2292 \r
2293 void __private_tls_prf_helper(int hash_idx, unsigned long dlen, unsigned char *output, unsigned int outlen, const unsigned char *secret, const unsigned int secret_len,\r
2294                               const unsigned char *label, unsigned int label_len, unsigned char *seed, unsigned int seed_len,\r
2295                               unsigned char *seed_b, unsigned int seed_b_len) {\r
2296     unsigned char digest_out0[__TLS_MAX_HASH_LEN];\r
2297     unsigned char digest_out1[__TLS_MAX_HASH_LEN];\r
2298     unsigned int i;\r
2299     hmac_state hmac;\r
2300     \r
2301     hmac_init(&hmac, hash_idx, secret, secret_len);\r
2302     hmac_process(&hmac, label, label_len);\r
2303     \r
2304     hmac_process(&hmac, seed, seed_len);\r
2305     if ((seed_b) && (seed_b_len))\r
2306         hmac_process(&hmac, seed_b, seed_b_len);\r
2307     hmac_done(&hmac, digest_out0, &dlen);\r
2308     int idx = 0;\r
2309     while (outlen) {\r
2310         hmac_init(&hmac, hash_idx, secret, secret_len);\r
2311         hmac_process(&hmac, digest_out0, dlen);\r
2312         hmac_process(&hmac, label, label_len);\r
2313         hmac_process(&hmac, seed, seed_len);\r
2314         if ((seed_b) && (seed_b_len))\r
2315             hmac_process(&hmac, seed_b, seed_b_len);\r
2316         hmac_done(&hmac, digest_out1, &dlen);\r
2317         \r
2318         unsigned int copylen = outlen;\r
2319         if (copylen > dlen)\r
2320             copylen = dlen;\r
2321         \r
2322         for (i = 0; i < copylen; i++) {\r
2323             output[idx++] ^= digest_out1[i];\r
2324             outlen--;\r
2325         }\r
2326         \r
2327         if (!outlen)\r
2328             break;\r
2329         \r
2330         hmac_init(&hmac, hash_idx, secret, secret_len);\r
2331         hmac_process(&hmac, digest_out0, dlen);\r
2332         hmac_done(&hmac, digest_out0, &dlen);\r
2333     }\r
2334 }\r
2335 \r
2336 void __private_tls_prf(struct TLSContext *context,\r
2337                        unsigned char *output, unsigned int outlen, const unsigned char *secret, const unsigned int secret_len,\r
2338                        const unsigned char *label, unsigned int label_len, unsigned char *seed, unsigned int seed_len,\r
2339                        unsigned char *seed_b, unsigned int seed_b_len) {\r
2340     if ((!secret) || (!secret_len)) {\r
2341         DEBUG_PRINT("NULL SECRET\n");\r
2342         return;\r
2343     }\r
2344     if ((context->version != TLS_V12) && (context->version != DTLS_V12)) {\r
2345         int md5_hash_idx = find_hash("md5");\r
2346         int sha1_hash_idx = find_hash("sha1");\r
2347         int half_secret = (secret_len + 1) / 2;\r
2348         \r
2349         memset(output, 0, outlen);\r
2350         __private_tls_prf_helper(md5_hash_idx, 16, output, outlen, secret, half_secret, label, label_len, seed, seed_len, seed_b, seed_b_len);\r
2351         __private_tls_prf_helper(sha1_hash_idx, 20, output, outlen, secret + (secret_len - half_secret), secret_len - half_secret, label, label_len, seed, seed_len, seed_b, seed_b_len);\r
2352     } else {\r
2353         // sha256_hmac\r
2354         unsigned char digest_out0[__TLS_MAX_HASH_LEN];\r
2355         unsigned char digest_out1[__TLS_MAX_HASH_LEN];\r
2356         unsigned long dlen = 32;\r
2357         int hash_idx;\r
2358         unsigned int mac_length = __private_tls_mac_length(context);\r
2359         if (mac_length == __TLS_SHA384_MAC_SIZE) {\r
2360             hash_idx = find_hash("sha384");\r
2361             dlen = mac_length;\r
2362         } else\r
2363             hash_idx = find_hash("sha256");\r
2364         unsigned int i;\r
2365         hmac_state hmac;\r
2366         \r
2367         hmac_init(&hmac, hash_idx, secret, secret_len);\r
2368         hmac_process(&hmac, label, label_len);\r
2369         \r
2370         hmac_process(&hmac, seed, seed_len);\r
2371         if ((seed_b) && (seed_b_len))\r
2372             hmac_process(&hmac, seed_b, seed_b_len);\r
2373         hmac_done(&hmac, digest_out0, &dlen);\r
2374         int idx = 0;\r
2375         while (outlen) {\r
2376             hmac_init(&hmac, hash_idx, secret, secret_len);\r
2377             hmac_process(&hmac, digest_out0, dlen);\r
2378             hmac_process(&hmac, label, label_len);\r
2379             hmac_process(&hmac, seed, seed_len);\r
2380             if ((seed_b) && (seed_b_len))\r
2381                 hmac_process(&hmac, seed_b, seed_b_len);\r
2382             hmac_done(&hmac, digest_out1, &dlen);\r
2383             \r
2384             unsigned int copylen = outlen;\r
2385             if (copylen > dlen)\r
2386                 copylen = (unsigned int)dlen;\r
2387             \r
2388             for (i = 0; i < copylen; i++) {\r
2389                 output[idx++] = digest_out1[i];\r
2390                 outlen--;\r
2391             }\r
2392             \r
2393             if (!outlen)\r
2394                 break;\r
2395             \r
2396             hmac_init(&hmac, hash_idx, secret, secret_len);\r
2397             hmac_process(&hmac, digest_out0, dlen);\r
2398             hmac_done(&hmac, digest_out0, &dlen);\r
2399         }\r
2400     }\r
2401 }\r
2402 \r
2403 int __private_tls_key_length(struct TLSContext *context) {\r
2404     switch (context->cipher) {\r
2405         case TLS_RSA_WITH_AES_128_CBC_SHA:\r
2406         case TLS_RSA_WITH_AES_128_CBC_SHA256:\r
2407         case TLS_RSA_WITH_AES_128_GCM_SHA256:\r
2408         case TLS_DHE_RSA_WITH_AES_128_CBC_SHA:\r
2409         case TLS_DHE_RSA_WITH_AES_128_CBC_SHA256:\r
2410         case TLS_DHE_RSA_WITH_AES_128_GCM_SHA256:\r
2411         case TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA:\r
2412         case TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256:\r
2413         case TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256:\r
2414         case TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA:\r
2415         case TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256:\r
2416         case TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256:\r
2417             return 16;\r
2418         case TLS_RSA_WITH_AES_256_CBC_SHA:\r
2419         case TLS_RSA_WITH_AES_256_CBC_SHA256:\r
2420         case TLS_RSA_WITH_AES_256_GCM_SHA384:\r
2421         case TLS_DHE_RSA_WITH_AES_256_CBC_SHA:\r
2422         case TLS_DHE_RSA_WITH_AES_256_CBC_SHA256:\r
2423         case TLS_DHE_RSA_WITH_AES_256_GCM_SHA384:\r
2424         case TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA:\r
2425         case TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384:\r
2426         case TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA:\r
2427         case TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384:\r
2428         case TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384:\r
2429         case TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256:\r
2430         case TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256:\r
2431         case TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256:\r
2432             return 32;\r
2433     }\r
2434     return 0;\r
2435 }\r
2436 \r
2437 int __private_tls_is_aead(struct TLSContext *context) {\r
2438     switch (context->cipher) {\r
2439         case TLS_RSA_WITH_AES_128_GCM_SHA256:\r
2440         case TLS_RSA_WITH_AES_256_GCM_SHA384:\r
2441         case TLS_DHE_RSA_WITH_AES_128_GCM_SHA256:\r
2442         case TLS_DHE_RSA_WITH_AES_256_GCM_SHA384:\r
2443         case TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256:\r
2444         case TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384:\r
2445         case TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256:\r
2446         case TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384:\r
2447             return 1;\r
2448         case TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256:\r
2449         case TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256:\r
2450         case TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256:\r
2451             return 2;\r
2452     }\r
2453     return 0;\r
2454 }\r
2455 \r
2456 \r
2457 \r
2458 unsigned int __private_tls_mac_length(struct TLSContext *context) {\r
2459     switch (context->cipher) {\r
2460         case TLS_RSA_WITH_AES_128_CBC_SHA:\r
2461         case TLS_RSA_WITH_AES_256_CBC_SHA:\r
2462         case TLS_DHE_RSA_WITH_AES_128_CBC_SHA:\r
2463         case TLS_DHE_RSA_WITH_AES_256_CBC_SHA:\r
2464         case TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA:\r
2465         case TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA:\r
2466         case TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA:\r
2467         case TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA:\r
2468             return __TLS_SHA1_MAC_SIZE;\r
2469         case TLS_RSA_WITH_AES_128_CBC_SHA256:\r
2470         case TLS_RSA_WITH_AES_256_CBC_SHA256:\r
2471         case TLS_RSA_WITH_AES_128_GCM_SHA256:\r
2472         case TLS_DHE_RSA_WITH_AES_128_CBC_SHA256:\r
2473         case TLS_DHE_RSA_WITH_AES_256_CBC_SHA256:\r
2474         case TLS_DHE_RSA_WITH_AES_128_GCM_SHA256:\r
2475         case TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256:\r
2476         case TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256:\r
2477         case TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256:\r
2478         case TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256:\r
2479         case TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256:\r
2480         case TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256:\r
2481         case TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256:\r
2482             return __TLS_SHA256_MAC_SIZE;\r
2483         case TLS_RSA_WITH_AES_256_GCM_SHA384:\r
2484         case TLS_DHE_RSA_WITH_AES_256_GCM_SHA384:\r
2485         case TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384:\r
2486         case TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384:\r
2487         case TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384:\r
2488             return __TLS_SHA384_MAC_SIZE;\r
2489     }\r
2490     return 0;\r
2491 }\r
2492 \r
2493 int __private_tls_expand_key(struct TLSContext *context) {\r
2494     unsigned char key[__TLS_MAX_KEY_EXPANSION_SIZE];\r
2495     \r
2496     if ((!context->master_key) || (!context->master_key_len))\r
2497         return 0;\r
2498     \r
2499     int key_length = __private_tls_key_length(context);\r
2500     int mac_length = __private_tls_mac_length(context);\r
2501     \r
2502     if ((!key_length) || (!mac_length)) {\r
2503         DEBUG_PRINT("KEY EXPANSION FAILED, KEY LENGTH: %i, MAC LENGTH: %i\n", key_length, mac_length);\r
2504         return 0;\r
2505     }\r
2506 \r
2507     if (context->is_server)\r
2508         __private_tls_prf(context, key, sizeof(key), context->master_key, context->master_key_len, (unsigned char *)"key expansion", 13, context->local_random, __TLS_SERVER_RANDOM_SIZE, context->remote_random, __TLS_CLIENT_RANDOM_SIZE);\r
2509     else\r
2510         __private_tls_prf(context, key, sizeof(key), context->master_key, context->master_key_len, (unsigned char *)"key expansion", 13, context->remote_random, __TLS_SERVER_RANDOM_SIZE, context->local_random, __TLS_CLIENT_RANDOM_SIZE);\r
2511     \r
2512     DEBUG_DUMP_HEX_LABEL("LOCAL RANDOM ", context->local_random, __TLS_SERVER_RANDOM_SIZE);\r
2513     DEBUG_DUMP_HEX_LABEL("REMOTE RANDOM", context->remote_random, __TLS_CLIENT_RANDOM_SIZE);\r
2514     DEBUG_PRINT("\n=========== EXPANSION ===========\n");\r
2515     DEBUG_DUMP_HEX(key, __TLS_MAX_KEY_EXPANSION_SIZE);\r
2516     DEBUG_PRINT("\n");\r
2517     \r
2518     unsigned char *clientkey = NULL;\r
2519     unsigned char *serverkey = NULL;\r
2520     unsigned char *clientiv = NULL;\r
2521     unsigned char *serveriv = NULL;\r
2522     int iv_length = __TLS_AES_IV_LENGTH;\r
2523     \r
2524     int pos = 0;\r
2525     int is_aead = __private_tls_is_aead(context);\r
2526 #ifdef TLS_WITH_CHACHA20_POLY1305\r
2527     if (is_aead == 2) {\r
2528         iv_length = __TLS_CHACHA20_IV_LENGTH;\r
2529     } else\r
2530 #endif\r
2531     if (is_aead)\r
2532         iv_length = __TLS_AES_GCM_IV_LENGTH;\r
2533     else {\r
2534         if (context->is_server) {\r
2535             memcpy(context->crypto.ctx_remote_mac.remote_mac, &key[pos], mac_length);\r
2536             pos += mac_length;\r
2537             memcpy(context->crypto.ctx_local_mac.local_mac, &key[pos], mac_length);\r
2538             pos += mac_length;\r
2539         } else {\r
2540             memcpy(context->crypto.ctx_local_mac.local_mac, &key[pos], mac_length);\r
2541             pos += mac_length;\r
2542             memcpy(context->crypto.ctx_remote_mac.remote_mac, &key[pos], mac_length);\r
2543             pos += mac_length;\r
2544         }\r
2545     }\r
2546     \r
2547     clientkey = &key[pos];\r
2548     pos += key_length;\r
2549     serverkey = &key[pos];\r
2550     pos += key_length;\r
2551     clientiv = &key[pos];\r
2552     pos += iv_length;\r
2553     serveriv = &key[pos];\r
2554     pos += iv_length;\r
2555     \r
2556     DEBUG_PRINT("EXPANSION %i/%i\n", (int)pos, (int)__TLS_MAX_KEY_EXPANSION_SIZE);\r
2557     DEBUG_DUMP_HEX_LABEL("CLIENT KEY", clientkey, key_length)\r
2558     DEBUG_DUMP_HEX_LABEL("CLIENT IV", clientiv, iv_length)\r
2559     DEBUG_DUMP_HEX_LABEL("CLIENT MAC KEY", context->is_server ? context->crypto.ctx_remote_mac.remote_mac : context->crypto.ctx_local_mac.local_mac, mac_length)\r
2560     DEBUG_DUMP_HEX_LABEL("SERVER KEY", serverkey, key_length)\r
2561     DEBUG_DUMP_HEX_LABEL("SERVER IV", serveriv, iv_length)\r
2562     DEBUG_DUMP_HEX_LABEL("SERVER MAC KEY", context->is_server ? context->crypto.ctx_local_mac.local_mac : context->crypto.ctx_remote_mac.remote_mac, mac_length)\r
2563     \r
2564     if (context->is_server) {\r
2565 #ifdef TLS_WITH_CHACHA20_POLY1305\r
2566         if (is_aead == 2) {\r
2567             memcpy(context->crypto.ctx_remote_mac.remote_nonce, clientiv, iv_length);\r
2568             memcpy(context->crypto.ctx_local_mac.local_nonce, serveriv, iv_length);\r
2569         } else\r
2570 #endif\r
2571         if (is_aead) {\r
2572             memcpy(context->crypto.ctx_remote_mac.remote_aead_iv, clientiv, iv_length);\r
2573             memcpy(context->crypto.ctx_local_mac.local_aead_iv, serveriv, iv_length);\r
2574         }\r
2575         if (__private_tls_crypto_create(context, key_length, iv_length, serverkey, serveriv, clientkey, clientiv))\r
2576             return 0;\r
2577     } else {\r
2578 #ifdef TLS_WITH_CHACHA20_POLY1305\r
2579         if (is_aead == 2) {\r
2580             memcpy(context->crypto.ctx_local_mac.local_nonce, clientiv, iv_length);\r
2581             memcpy(context->crypto.ctx_remote_mac.remote_nonce, serveriv, iv_length);\r
2582         } else\r
2583 #endif\r
2584         if (is_aead) {\r
2585             memcpy(context->crypto.ctx_local_mac.local_aead_iv, clientiv, iv_length);\r
2586             memcpy(context->crypto.ctx_remote_mac.remote_aead_iv, serveriv, iv_length);\r
2587         }\r
2588         if (__private_tls_crypto_create(context, key_length, iv_length, clientkey, clientiv, serverkey, serveriv))\r
2589             return 0;\r
2590     }\r
2591     \r
2592     if (context->exportable) {\r
2593         TLS_FREE(context->exportable_keys);\r
2594         context->exportable_keys = (unsigned char *)TLS_MALLOC(key_length * 2);\r
2595         if (context->exportable_keys) {\r
2596             if (context->is_server) {\r
2597                 memcpy(context->exportable_keys, serverkey, key_length);\r
2598                 memcpy(context->exportable_keys + key_length, clientkey, key_length);\r
2599             } else {\r
2600                 memcpy(context->exportable_keys, clientkey, key_length);\r
2601                 memcpy(context->exportable_keys + key_length, serverkey, key_length);\r
2602             }\r
2603             context->exportable_size = key_length * 2;\r
2604         }\r
2605     }\r
2606     \r
2607     // extract client_mac_key(mac_key_length)\r
2608     // extract server_mac_key(mac_key_length)\r
2609     // extract client_key(enc_key_length)\r
2610     // extract server_key(enc_key_length)\r
2611     // extract client_iv(fixed_iv_lengh)\r
2612     // extract server_iv(fixed_iv_length)\r
2613     return 1;\r
2614 }\r
2615 \r
2616 int __private_tls_compute_key(struct TLSContext *context, unsigned int key_len) {\r
2617     if ((!context) || (!context->premaster_key) || (!context->premaster_key_len) || (key_len < 48)) {\r
2618         DEBUG_PRINT("CANNOT COMPUTE MASTER SECRET\n");\r
2619         return 0;\r
2620     }\r
2621     \r
2622     unsigned char master_secret_label[] = "master secret";\r
2623 #ifdef __TLS_CHECK_PREMASTER_KEY\r
2624     if (!tls_cipher_is_ephemeral(context)) {\r
2625         unsigned short version = ntohs(*(unsigned short *)context->premaster_key);\r
2626         // this check is not true for DHE/ECDHE ciphers\r
2627         if (context->version > version) {\r
2628             DEBUG_PRINT("Mismatch protocol version 0x(%x)\n", version);\r
2629             return 0;\r
2630         }\r
2631     }\r
2632 #endif\r
2633     TLS_FREE(context->master_key);\r
2634     context->master_key_len = 0;\r
2635     context->master_key = NULL;\r
2636     if ((context->version == TLS_V12) || (context->version == TLS_V11) || (context->version == TLS_V10) ||  (context->version == DTLS_V12) || (context->version == DTLS_V10)) {\r
2637         context->master_key = (unsigned char *)TLS_MALLOC(key_len);\r
2638         if (!context->master_key)\r
2639             return 0;\r
2640         context->master_key_len = key_len;\r
2641         if (context->is_server) {\r
2642             __private_tls_prf(context,\r
2643                               context->master_key, context->master_key_len,\r
2644                               context->premaster_key, context->premaster_key_len,\r
2645                               master_secret_label, 13,\r
2646                               context->remote_random, __TLS_CLIENT_RANDOM_SIZE,\r
2647                               context->local_random, __TLS_SERVER_RANDOM_SIZE\r
2648             );\r
2649         } else {\r
2650             __private_tls_prf(context,\r
2651                               context->master_key, context->master_key_len,\r
2652                               context->premaster_key, context->premaster_key_len,\r
2653                               master_secret_label, 13,\r
2654                               context->local_random, __TLS_CLIENT_RANDOM_SIZE,\r
2655                               context->remote_random, __TLS_SERVER_RANDOM_SIZE\r
2656             );\r
2657         }\r
2658         TLS_FREE(context->premaster_key);\r
2659         context->premaster_key = NULL;\r
2660         context->premaster_key_len = 0;\r
2661         DEBUG_PRINT("\n=========== Master key ===========\n");\r
2662         DEBUG_DUMP_HEX(context->master_key, context->master_key_len);\r
2663         DEBUG_PRINT("\n");\r
2664         __private_tls_expand_key(context);\r
2665         return 1;\r
2666     }\r
2667     return 0;\r
2668 }\r
2669 \r
2670 unsigned char *tls_pem_decode(const unsigned char *data_in, unsigned int input_length, int cert_index, unsigned int *output_len) {\r
2671     unsigned int i;\r
2672     *output_len = 0;\r
2673     int alloc_len = input_length / 4 * 3;\r
2674     unsigned char *output = (unsigned char *)TLS_MALLOC(alloc_len);\r
2675     if (!output)\r
2676         return NULL;\r
2677     unsigned int start_at = 0;\r
2678     unsigned int idx = 0;\r
2679     for (i = 0; i < input_length; i++) {\r
2680         if ((data_in[i] == '\n') || (data_in[i] == '\r'))\r
2681             continue;\r
2682         \r
2683         if (data_in[i] != '-')  {\r
2684             // read entire line\r
2685             while ((i < input_length) && (data_in[i] != '\n'))\r
2686                 i++;\r
2687             continue;\r
2688         }\r
2689         \r
2690         if (data_in[i] == '-') {\r
2691             unsigned int end_idx = i;\r
2692             //read until end of line\r
2693             while ((i < input_length) && (data_in[i] != '\n'))\r
2694                 i++;\r
2695             if (start_at) {\r
2696                 if (cert_index > 0) {\r
2697                     cert_index--;\r
2698                     start_at = 0;\r
2699                 } else {\r
2700                     idx = __private_b64_decode((const char *)&data_in[start_at], end_idx - start_at, output);\r
2701                     break;\r
2702                 }\r
2703             } else\r
2704                 start_at = i + 1;\r
2705         }\r
2706     }\r
2707     *output_len = idx;\r
2708     if (!idx) {\r
2709         TLS_FREE(output);\r
2710         return NULL;\r
2711     }\r
2712     return output;\r
2713 }\r
2714 \r
2715 int __is_oid(const unsigned char *oid, const unsigned char *compare_to, int compare_to_len) {\r
2716     int i = 0;\r
2717     while ((oid[i]) && (i < compare_to_len)) {\r
2718         if (oid[i] != compare_to[i])\r
2719             return 0;\r
2720         \r
2721         i++;\r
2722     }\r
2723     return 1;\r
2724 }\r
2725 \r
2726 int __is_oid2(const unsigned char *oid, const unsigned char *compare_to, int compare_to_len, int oid_len) {\r
2727     int i = 0;\r
2728     if (oid_len < compare_to_len)\r
2729         compare_to_len = oid_len;\r
2730     while (i < compare_to_len) {\r
2731         if (oid[i] != compare_to[i])\r
2732             return 0;\r
2733         \r
2734         i++;\r
2735     }\r
2736     return 1;\r
2737 }\r
2738 \r
2739 struct TLSCertificate *tls_create_certificate() {\r
2740     struct TLSCertificate *cert = (struct TLSCertificate *)TLS_MALLOC(sizeof(struct TLSCertificate));\r
2741     if (cert)\r
2742         memset(cert, 0, sizeof(struct TLSCertificate));\r
2743     return cert;\r
2744 }\r
2745 \r
2746 int tls_certificate_valid_subject_name(const unsigned char *cert_subject, const char *subject) {\r
2747     // no subjects ...\r
2748     if (((!cert_subject) || (!cert_subject[0])) && ((!subject) || (!subject[0])))\r
2749         return 0;\r
2750     \r
2751     if ((!subject) || (!subject[0]))\r
2752         return bad_certificate;\r
2753     \r
2754     if ((!cert_subject) || (!cert_subject[0]))\r
2755         return bad_certificate;\r
2756     \r
2757     // exact match\r
2758     if (!strcmp((const char *)cert_subject, subject))\r
2759         return 0;\r
2760     \r
2761     const char *wildcard = strchr((const char *)cert_subject, '*');\r
2762     if (wildcard) {\r
2763         // 6.4.3 (1) The client SHOULD NOT attempt to match a presented identifier in\r
2764         // which the wildcard character comprises a label other than the left-most label\r
2765         if (!wildcard[1]) {\r
2766             // subject is [*]\r
2767             // or\r
2768             // subject is [something*] .. invalid\r
2769             return bad_certificate;\r
2770         }\r
2771         wildcard++;\r
2772         const char *match = strstr(subject, wildcard);\r
2773         if ((!match) && (wildcard[0] == '.')) {\r
2774             // check *.domain.com agains domain.com\r
2775             wildcard++;\r
2776             if (!strcasecmp(subject, wildcard))\r
2777                 return 0;\r
2778         }\r
2779         if (match) {\r
2780             unsigned long offset = (unsigned long)match - (unsigned long)subject;\r
2781             if (offset) {\r
2782                 // check for foo.*.domain.com against *.domain.com (invalid)\r
2783                 if (memchr(subject, '.', offset))\r
2784                     return bad_certificate;\r
2785             }\r
2786             // check if exact match\r
2787             if (!strcasecmp(match, wildcard))\r
2788                 return 0;\r
2789         }\r
2790     }\r
2791     \r
2792     return bad_certificate;\r
2793 }\r
2794 \r
2795 int tls_certificate_valid_subject(struct TLSCertificate *cert, const char *subject) {\r
2796     int i;\r
2797     if (!cert)\r
2798         return certificate_unknown;\r
2799     int err = tls_certificate_valid_subject_name(cert->subject, subject);\r
2800     if ((err) && (cert->san)) {\r
2801         for (i = 0; i < cert->san_length; i++) {\r
2802             err = tls_certificate_valid_subject_name(cert->san[i], subject);\r
2803             if (!err)\r
2804                 return err;\r
2805         }\r
2806     }\r
2807     return err;\r
2808 }\r
2809 \r
2810 int tls_certificate_is_valid(struct TLSCertificate *cert) {\r
2811     if (!cert)\r
2812         return certificate_unknown;\r
2813     if (!cert->not_before)\r
2814         return certificate_unknown;\r
2815     if (!cert->not_after)\r
2816         return certificate_unknown;\r
2817     //20160224182300Z//\r
2818     char current_time[16];\r
2819     time_t t = time(NULL);\r
2820     struct tm *utct = gmtime(&t);\r
2821     if (utct) {\r
2822         current_time[0] = 0;\r
2823         snprintf(current_time, sizeof(current_time), "%04d%02d%02d%02d%02d%02dZ", 1900 + utct->tm_year, utct->tm_mon + 1, utct->tm_mday, utct->tm_hour, utct->tm_min, utct->tm_sec);\r
2824         if (strcasecmp((char *)cert->not_before, current_time) > 0) {\r
2825             DEBUG_PRINT("Certificate is not yer valid, now: %s (validity: %s - %s)\n", current_time, cert->not_before, cert->not_after);\r
2826             return certificate_expired;\r
2827         }\r
2828         if (strcasecmp((char *)cert->not_after, current_time) < 0) {\r
2829             DEBUG_PRINT("Expired certificate, now: %s (validity: %s - %s)\n", current_time, cert->not_before, cert->not_after);\r
2830             return certificate_expired;\r
2831         }\r
2832         DEBUG_PRINT("Valid certificate, now: %s (validity: %s - %s)\n", current_time, cert->not_before, cert->not_after);\r
2833     }\r
2834     return 0;\r
2835 }\r
2836 \r
2837 void tls_certificate_set_copy(unsigned char **member, const unsigned char *val, int len) {\r
2838     if (!member)\r
2839         return;\r
2840     TLS_FREE(*member);\r
2841     if (len) {\r
2842         *member = (unsigned char *)TLS_MALLOC(len + 1);\r
2843         if (*member) {\r
2844             memcpy(*member, val, len);\r
2845             (*member)[len] = 0;\r
2846         }\r
2847     } else\r
2848         *member = NULL;\r
2849 }\r
2850 \r
2851 void tls_certificate_set_copy_date(unsigned char **member, const unsigned char *val, int len) {\r
2852     if (!member)\r
2853         return;\r
2854     TLS_FREE(*member);\r
2855     if (len > 4) {\r
2856         *member = (unsigned char *)TLS_MALLOC(len + 3);\r
2857         if (*member) {\r
2858             if (val[0] == '9') {\r
2859                 (*member)[0]='1';\r
2860                 (*member)[1]='9';\r
2861             } else {\r
2862                 (*member)[0]='2';\r
2863                 (*member)[1]='0';\r
2864             }\r
2865             memcpy(*member + 2, val, len);\r
2866             (*member)[len] = 0;\r
2867         }\r
2868     } else\r
2869         *member = NULL;\r
2870 }\r
2871 \r
2872 void tls_certificate_set_key(struct TLSCertificate *cert, const unsigned char *val, int len) {\r
2873     if ((!val[0]) && (len % 2)) {\r
2874         val++;\r
2875         len--;\r
2876     }\r
2877     tls_certificate_set_copy(&cert->pk, val, len);\r
2878     if (cert->pk)\r
2879         cert->pk_len = len;\r
2880 }\r
2881 \r
2882 void tls_certificate_set_priv(struct TLSCertificate *cert, const unsigned char *val, int len) {\r
2883     tls_certificate_set_copy(&cert->priv, val, len);\r
2884     if (cert->priv)\r
2885         cert->priv_len = len;\r
2886 }\r
2887 \r
2888 void tls_certificate_set_sign_key(struct TLSCertificate *cert, const unsigned char *val, int len) {\r
2889     if ((!val[0]) && (len % 2)) {\r
2890         val++;\r
2891         len--;\r
2892     }\r
2893     tls_certificate_set_copy(&cert->sign_key, val, len);\r
2894     if (cert->sign_key)\r
2895         cert->sign_len = len;\r
2896 }\r
2897 \r
2898 char *tls_certificate_to_string(struct TLSCertificate *cert, char *buffer, int len) {\r
2899     unsigned int i;\r
2900     if (!buffer)\r
2901         return NULL;\r
2902     buffer[0] = 0;\r
2903     if (cert->version) {\r
2904         int res = snprintf(buffer, len, "X.509v%i certificate\n  Issued by: [%s]%s (%s)\n  Issued to: [%s]%s (%s, %s)\n  Subject: %s\n  Validity: %s - %s\n  OCSP: %s\n  Serial number: ",\r
2905                            (int)cert->version,\r
2906                            cert->issuer_country, cert->issuer_entity, cert->issuer_subject,\r
2907                            cert->country, cert->entity, cert->state, cert->location,\r
2908                            cert->subject,\r
2909                            cert->not_before, cert->not_after,\r
2910                            cert->ocsp\r
2911                            );\r
2912         if (res > 0) {\r
2913             for (i = 0; i < cert->serial_len; i++)\r
2914                 res += snprintf(buffer + res, len - res, "%02x", (int)cert->serial_number[i]);\r
2915         }\r
2916         if ((cert->san) && (cert->san_length)) {\r
2917             res += snprintf(buffer + res, len - res, "\n  Alternative subjects: ");\r
2918             for (i = 0; i < cert->san_length; i++) {\r
2919                 if (i)\r
2920                     res += snprintf(buffer + res, len - res, ", %s", cert->san[i]);\r
2921                 else\r
2922                     res += snprintf(buffer + res, len - res, "%s", cert->san[i]);\r
2923             }\r
2924         }\r
2925         res += snprintf(buffer + res, len - res, "\n  Key (%i bits, ", cert->pk_len * 8);\r
2926         if (res > 0) {\r
2927             switch (cert->key_algorithm) {\r
2928                 case TLS_RSA_SIGN_RSA:\r
2929                     res += snprintf(buffer + res, len - res, "RSA_SIGN_RSA");\r
2930                     break;\r
2931                 case TLS_RSA_SIGN_MD5:\r
2932                     res += snprintf(buffer + res, len - res, "RSA_SIGN_MD5");\r
2933                     break;\r
2934                 case TLS_RSA_SIGN_SHA1:\r
2935                     res += snprintf(buffer + res, len - res, "RSA_SIGN_SHA1");\r
2936                     break;\r
2937                 case TLS_RSA_SIGN_SHA256:\r
2938                     res += snprintf(buffer + res, len - res, "RSA_SIGN_SHA256");\r
2939                     break;\r
2940                 case TLS_RSA_SIGN_SHA384:\r
2941                     res += snprintf(buffer + res, len - res, "RSA_SIGN_SHA384");\r
2942                     break;\r
2943                 case TLS_RSA_SIGN_SHA512:\r
2944                     res += snprintf(buffer + res, len - res, "RSA_SIGN_SHA512");\r
2945                     break;\r
2946                 case TLS_EC_PUBLIC_KEY:\r
2947                     res += snprintf(buffer + res, len - res, "EC_PUBLIC_KEY");\r
2948                     break;\r
2949                 default:\r
2950                     res += snprintf(buffer + res, len - res, "not supported (%i)", (int)cert->key_algorithm);\r
2951             }\r
2952         }\r
2953         if ((res > 0) && (cert->ec_algorithm)) {\r
2954             switch (cert->ec_algorithm) {\r
2955                 case TLS_EC_prime192v1:\r
2956                     res += snprintf(buffer + res, len - res, " prime192v1");\r
2957                     break;\r
2958                 case TLS_EC_prime192v2:\r
2959                     res += snprintf(buffer + res, len - res, " prime192v2");\r
2960                     break;\r
2961                 case TLS_EC_prime192v3:\r
2962                     res += snprintf(buffer + res, len - res, " prime192v3");\r
2963                     break;\r
2964                 case TLS_EC_prime239v2:\r
2965                     res += snprintf(buffer + res, len - res, " prime239v2");\r
2966                     break;\r
2967                 case TLS_EC_secp256r1:\r
2968                     res += snprintf(buffer + res, len - res, " EC_secp256r1");\r
2969                     break;\r
2970                 case TLS_EC_secp224r1:\r
2971                     res += snprintf(buffer + res, len - res, " EC_secp224r1");\r
2972                     break;\r
2973                 case TLS_EC_secp384r1:\r
2974                     res += snprintf(buffer + res, len - res, " EC_secp384r1");\r
2975                     break;\r
2976                 case TLS_EC_secp521r1:\r
2977                     res += snprintf(buffer + res, len - res, " EC_secp521r1");\r
2978                     break;\r
2979                 default:\r
2980                     res += snprintf(buffer + res, len - res, " unknown(%i)", (int)cert->ec_algorithm);\r
2981             }\r
2982         }\r
2983         res += snprintf(buffer + res, len - res, "):\n");\r
2984         if (res > 0) {\r
2985             for (i = 0; i < cert->pk_len; i++)\r
2986                 res += snprintf(buffer + res, len - res, "%02x", (int)cert->pk[i]);\r
2987             res += snprintf(buffer + res, len - res, "\n  Signature (%i bits, ", cert->sign_len * 8);\r
2988             switch (cert->algorithm) {\r
2989                 case TLS_RSA_SIGN_RSA:\r
2990                     res += snprintf(buffer + res, len - res, "RSA_SIGN_RSA):\n");\r
2991                     break;\r
2992                 case TLS_RSA_SIGN_MD5:\r
2993                     res += snprintf(buffer + res, len - res, "RSA_SIGN_MD5):\n");\r
2994                     break;\r
2995                 case TLS_RSA_SIGN_SHA1:\r
2996                     res += snprintf(buffer + res, len - res, "RSA_SIGN_SHA1):\n");\r
2997                     break;\r
2998                 case TLS_RSA_SIGN_SHA256:\r
2999                     res += snprintf(buffer + res, len - res, "RSA_SIGN_SHA256):\n");\r
3000                     break;\r
3001                 case TLS_RSA_SIGN_SHA384:\r
3002                     res += snprintf(buffer + res, len - res, "RSA_SIGN_SHA384):\n");\r
3003                     break;\r
3004                 case TLS_RSA_SIGN_SHA512:\r
3005                     res += snprintf(buffer + res, len - res, "RSA_SIGN_SHA512):\n");\r
3006                     break;\r
3007                 case TLS_EC_PUBLIC_KEY:\r
3008                     res += snprintf(buffer + res, len - res, "EC_PUBLIC_KEY):\n");\r
3009                     break;\r
3010                 default:\r
3011                     res += snprintf(buffer + res, len - res, "not supported):\n");\r
3012             }\r
3013             \r
3014             for (i = 0; i < cert->sign_len; i++)\r
3015                 res += snprintf(buffer + res, len - res, "%02x", (int)cert->sign_key[i]);\r
3016         }\r
3017     } else\r
3018     if ((cert->priv) && (cert->priv_len)) {\r
3019         int res = snprintf(buffer, len, "X.509 private key\n");\r
3020         res += snprintf(buffer + res, len - res, "  Private Key: ");\r
3021         if (res > 0) {\r
3022             for (i = 0; i < cert->priv_len; i++)\r
3023                 res += snprintf(buffer + res, len - res, "%02x", (int)cert->priv[i]);\r
3024         }\r
3025     } else\r
3026         snprintf(buffer, len, "Empty ASN1 file");\r
3027     return buffer;\r
3028 }\r
3029 \r
3030 void tls_certificate_set_exponent(struct TLSCertificate *cert, const unsigned char *val, int len) {\r
3031     tls_certificate_set_copy(&cert->exponent, val, len);\r
3032     if (cert->exponent)\r
3033         cert->exponent_len = len;\r
3034 }\r
3035 \r
3036 void tls_certificate_set_serial(struct TLSCertificate *cert, const unsigned char *val, int len) {\r
3037     tls_certificate_set_copy(&cert->serial_number, val, len);\r
3038     if (cert->serial_number)\r
3039         cert->serial_len = len;\r
3040 }\r
3041 \r
3042 void tls_certificate_set_algorithm(unsigned int *algorithm, const unsigned char *val, int len) {\r
3043     if ((len == 7) && (__is_oid(val, TLS_EC_PUBLIC_KEY_OID, 7))) {\r
3044         *algorithm = TLS_EC_PUBLIC_KEY;\r
3045         return;\r
3046     }\r
3047     if (len == 8) {\r
3048         if (__is_oid(val, TLS_EC_prime192v1_OID, len)) {\r
3049             *algorithm = TLS_EC_prime192v1;\r
3050             return;\r
3051         }\r
3052         if (__is_oid(val, TLS_EC_prime192v2_OID, len)) {\r
3053             *algorithm = TLS_EC_prime192v2;\r
3054             return;\r
3055         }\r
3056         if (__is_oid(val, TLS_EC_prime192v3_OID, len)) {\r
3057             *algorithm = TLS_EC_prime192v3;\r
3058             return;\r
3059         }\r
3060         if (__is_oid(val, TLS_EC_prime239v1_OID, len)) {\r
3061             *algorithm = TLS_EC_prime239v1;\r
3062             return;\r
3063         }\r
3064         if (__is_oid(val, TLS_EC_prime239v2_OID, len)) {\r
3065             *algorithm = TLS_EC_prime239v2;\r
3066             return;\r
3067         }\r
3068         if (__is_oid(val, TLS_EC_prime239v3_OID, len)) {\r
3069             *algorithm = TLS_EC_prime239v3;\r
3070             return;\r
3071         }\r
3072         if (__is_oid(val, TLS_EC_prime256v1_OID, len)) {\r
3073             *algorithm = TLS_EC_prime256v1;\r
3074             return;\r
3075         }\r
3076     }\r
3077     if (len == 5) {\r
3078         if (__is_oid2(val, TLS_EC_secp224r1_OID, len, sizeof(TLS_EC_secp224r1_OID) - 1)) {\r
3079             *algorithm = TLS_EC_secp224r1;\r
3080             return;\r
3081         }\r
3082         if (__is_oid2(val, TLS_EC_secp384r1_OID, len, sizeof(TLS_EC_secp384r1_OID) - 1)) {\r
3083             *algorithm = TLS_EC_secp384r1;\r
3084             return;\r
3085         }\r
3086         if (__is_oid2(val, TLS_EC_secp521r1_OID, len, sizeof(TLS_EC_secp521r1_OID) - 1)) {\r
3087             *algorithm = TLS_EC_secp521r1;\r
3088             return;\r
3089         }\r
3090     }\r
3091     if (len != 9)\r
3092         return;\r
3093     \r
3094     if (__is_oid(val, TLS_RSA_SIGN_SHA256_OID, 9)) {\r
3095         *algorithm = TLS_RSA_SIGN_SHA256;\r
3096         return;\r
3097     }\r
3098     \r
3099     if (__is_oid(val, TLS_RSA_SIGN_RSA_OID, 9)) {\r
3100         *algorithm = TLS_RSA_SIGN_RSA;\r
3101         return;\r
3102     }\r
3103     \r
3104     if (__is_oid(val, TLS_RSA_SIGN_SHA1_OID, 9)) {\r
3105         *algorithm = TLS_RSA_SIGN_SHA1;\r
3106         return;\r
3107     }\r
3108     \r
3109     if (__is_oid(val, TLS_RSA_SIGN_SHA512_OID, 9)) {\r
3110         *algorithm = TLS_RSA_SIGN_SHA512;\r
3111         return;\r
3112     }\r
3113     \r
3114     if (__is_oid(val, TLS_RSA_SIGN_SHA384_OID, 9)) {\r
3115         *algorithm = TLS_RSA_SIGN_SHA384;\r
3116         return;\r
3117     }\r
3118     \r
3119     if (__is_oid(val, TLS_RSA_SIGN_MD5_OID, 9)) {\r
3120         *algorithm = TLS_RSA_SIGN_MD5;\r
3121         return;\r
3122     }\r
3123 }\r
3124 \r
3125 void tls_destroy_certificate(struct TLSCertificate *cert) {\r
3126     if (cert) {\r
3127         int i;\r
3128         TLS_FREE(cert->exponent);\r
3129         TLS_FREE(cert->pk);\r
3130         TLS_FREE(cert->issuer_country);\r
3131         TLS_FREE(cert->issuer_state);\r
3132         TLS_FREE(cert->issuer_location);\r
3133         TLS_FREE(cert->issuer_entity);\r
3134         TLS_FREE(cert->issuer_subject);\r
3135         TLS_FREE(cert->country);\r
3136         TLS_FREE(cert->state);\r
3137         TLS_FREE(cert->location);\r
3138         TLS_FREE(cert->subject);\r
3139         for (i = 0; i < cert->san_length; i++) {\r
3140             TLS_FREE(cert->san[i]);\r
3141         }\r
3142         TLS_FREE(cert->san);\r
3143         TLS_FREE(cert->ocsp);\r
3144         TLS_FREE(cert->serial_number);\r
3145         TLS_FREE(cert->entity);\r
3146         TLS_FREE(cert->not_before);\r
3147         TLS_FREE(cert->not_after);\r
3148         TLS_FREE(cert->sign_key);\r
3149         TLS_FREE(cert->priv);\r
3150         TLS_FREE(cert->der_bytes);\r
3151         TLS_FREE(cert->bytes);\r
3152         TLS_FREE(cert->fingerprint);\r
3153         TLS_FREE(cert);\r
3154     }\r
3155 }\r
3156 \r
3157 struct TLSPacket *tls_create_packet(struct TLSContext *context, unsigned char type, unsigned short version, int payload_size_hint) {\r
3158     struct TLSPacket *packet = (struct TLSPacket *)TLS_MALLOC(sizeof(struct TLSPacket));\r
3159     if (!packet)\r
3160         return NULL;\r
3161     packet->broken = 0;\r
3162     if (payload_size_hint > 0)\r
3163         packet->size = payload_size_hint + 10;\r
3164     else\r
3165         packet->size = __TLS_BLOB_INCREMENT;\r
3166     packet->buf = (unsigned char *)TLS_MALLOC(packet->size);\r
3167     packet->context = context;\r
3168     if (!packet->buf) {\r
3169         TLS_FREE(packet);\r
3170         return NULL;\r
3171     }\r
3172     if ((context) && (context->dtls))\r
3173         packet->len = 13;\r
3174     else\r
3175         packet->len = 5;\r
3176     packet->buf[0] = type;\r
3177     *(unsigned short *)&packet->buf[1] = htons(version);\r
3178     return packet;\r
3179 }\r
3180 \r
3181 void tls_destroy_packet(struct TLSPacket *packet) {\r
3182     if (packet) {\r
3183         if (packet->buf)\r
3184             TLS_FREE(packet->buf);\r
3185         TLS_FREE(packet);\r
3186     }\r
3187 }\r
3188 \r
3189 int __private_tls_crypto_create(struct TLSContext *context, int key_length, int iv_length, unsigned char *localkey, unsigned char *localiv, unsigned char *remotekey, unsigned char *remoteiv) {\r
3190     if (context->crypto.created) {\r
3191         if (context->crypto.created == 1) {\r
3192             cbc_done(&context->crypto.ctx_remote.aes_remote);\r
3193             cbc_done(&context->crypto.ctx_local.aes_local);\r
3194         } else {\r
3195 #ifdef TLS_WITH_CHACHA20_POLY1305\r
3196             if (context->crypto.created == 2) {\r
3197 #endif\r
3198             unsigned char dummy_buffer[32];\r
3199             unsigned long tag_len = 0;\r
3200             gcm_done(&context->crypto.ctx_remote.aes_gcm_remote, dummy_buffer, &tag_len);\r
3201             gcm_done(&context->crypto.ctx_local.aes_gcm_local, dummy_buffer, &tag_len);\r
3202 #ifdef TLS_WITH_CHACHA20_POLY1305\r
3203             }\r
3204 #endif\r
3205         }\r
3206         context->crypto.created = 0;\r
3207     }\r
3208     tls_init();\r
3209     int is_aead = __private_tls_is_aead(context);\r
3210     int cipherID = find_cipher("aes");\r
3211     DEBUG_PRINT("Using cipher ID: %x\n", (int)context->cipher);\r
3212 #ifdef TLS_WITH_CHACHA20_POLY1305\r
3213     if (is_aead == 2) {\r
3214         unsigned int counter = 1;\r
3215 \r
3216         chacha_keysetup(&context->crypto.ctx_local.chacha_local, localkey, key_length * 8);\r
3217         chacha_ivsetup_96bitnonce(&context->crypto.ctx_local.chacha_local, localiv, (unsigned char *)&counter);\r
3218 \r
3219         chacha_keysetup(&context->crypto.ctx_remote.chacha_remote, remotekey, key_length * 8);\r
3220         chacha_ivsetup_96bitnonce(&context->crypto.ctx_remote.chacha_remote, remoteiv, (unsigned char *)&counter);\r
3221 \r
3222         context->crypto.created = 3;\r
3223     } else\r
3224 #endif\r
3225     if (is_aead) {\r
3226         int res1 = gcm_init(&context->crypto.ctx_local.aes_gcm_local, cipherID, localkey, key_length);\r
3227         int res2 = gcm_init(&context->crypto.ctx_remote.aes_gcm_remote, cipherID, remotekey, key_length);\r
3228         \r
3229         if ((res1) || (res2))\r
3230             return TLS_GENERIC_ERROR;\r
3231         context->crypto.created = 2;\r
3232     } else {\r
3233         int res1 = cbc_start(cipherID, localiv, localkey, key_length, 0, &context->crypto.ctx_local.aes_local);\r
3234         int res2 = cbc_start(cipherID, remoteiv, remotekey, key_length, 0, &context->crypto.ctx_remote.aes_remote);\r
3235         \r
3236         if ((res1) || (res2))\r
3237             return TLS_GENERIC_ERROR;\r
3238         context->crypto.created = 1;\r
3239     }\r
3240     return 0;\r
3241 }\r
3242 \r
3243 int __private_tls_crypto_encrypt(struct TLSContext *context, unsigned char *buf, unsigned char *ct, unsigned int len) {\r
3244     if (context->crypto.created == 1)\r
3245         return cbc_encrypt(buf, ct, len, &context->crypto.ctx_local.aes_local);\r
3246 \r
3247     memset(ct, 0, len);\r
3248     return TLS_GENERIC_ERROR;\r
3249 }\r
3250 \r
3251 int __private_tls_crypto_decrypt(struct TLSContext *context, unsigned char *buf, unsigned char *pt, unsigned int len) {\r
3252     if (context->crypto.created == 1)\r
3253         return cbc_decrypt(buf, pt, len, &context->crypto.ctx_remote.aes_remote);\r
3254     \r
3255     memset(pt, 0, len);\r
3256     return TLS_GENERIC_ERROR;\r
3257 }\r
3258 \r
3259 void __private_tls_crypto_done(struct TLSContext *context) {\r
3260     unsigned char dummy_buffer[32];\r
3261     unsigned long tag_len = 0;\r
3262     switch (context->crypto.created) {\r
3263         case 1:\r
3264             cbc_done(&context->crypto.ctx_remote.aes_remote);\r
3265             cbc_done(&context->crypto.ctx_local.aes_local);\r
3266             break;\r
3267         case 2:\r
3268             gcm_done(&context->crypto.ctx_remote.aes_gcm_remote, dummy_buffer, &tag_len);\r
3269             gcm_done(&context->crypto.ctx_local.aes_gcm_local, dummy_buffer, &tag_len);\r
3270             break;\r
3271     }\r
3272     context->crypto.created = 0;\r
3273 }\r
3274 \r
3275 void tls_packet_update(struct TLSPacket *packet) {\r
3276     if ((packet) && (!packet->broken)) {\r
3277         unsigned int header_size = 5;\r
3278         if ((packet->context) && (packet->context->dtls)) {\r
3279             header_size = 13;\r
3280             *(unsigned short *)&packet->buf[3] = htons(packet->context->dtls_epoch_local);\r
3281             uint64_t sequence_number = packet->context->local_sequence_number;\r
3282             packet->buf[5] = sequence_number / 0x10000000000LL;\r
3283             sequence_number %= 0x10000000000LL;\r
3284             packet->buf[6] = sequence_number / 0x100000000LL;\r
3285             sequence_number %= 0x100000000LL;\r
3286             packet->buf[7] = sequence_number / 0x1000000;\r
3287             sequence_number %= 0x1000000;\r
3288             packet->buf[8] = sequence_number / 0x10000;\r
3289             sequence_number %= 0x10000;\r
3290             packet->buf[9] = sequence_number / 0x100;\r
3291             sequence_number %= 0x100;\r
3292             packet->buf[10] = sequence_number;\r
3293 \r
3294             *(unsigned short *)&packet->buf[11] = htons(packet->len - header_size);\r
3295         } else\r
3296             *(unsigned short *)&packet->buf[3] = htons(packet->len - header_size);\r
3297         if (packet->context) {\r
3298             if (packet->buf[0] != TLS_CHANGE_CIPHER)  {\r
3299                 if ((packet->buf[0] == TLS_HANDSHAKE) && (packet->len > header_size)) {\r
3300                     unsigned char handshake_type = packet->buf[header_size];\r
3301                     if ((handshake_type != 0x00) && (handshake_type != 0x03))\r
3302                         __private_tls_update_hash(packet->context, packet->buf + header_size, packet->len - header_size);\r
3303                 }\r
3304                 \r
3305                 if ((packet->context->cipher_spec_set) && (packet->context->crypto.created)) {\r
3306                     int block_size = __TLS_AES_BLOCK_SIZE;\r
3307                     int mac_size = 0;\r
3308                     unsigned int length = 0;\r
3309                     unsigned char padding = 0;\r
3310                     unsigned int pt_length = packet->len - header_size;\r
3311                     \r
3312                     if (packet->context->crypto.created == 1) {\r
3313                         mac_size = __private_tls_mac_length(packet->context);\r
3314 #ifdef TLS_LEGACY_SUPPORT\r
3315                         if (packet->context->version == TLS_V10)\r
3316                             length = packet->len - header_size + mac_size;\r
3317                         else\r
3318 #endif\r
3319                             length = packet->len - header_size + __TLS_AES_IV_LENGTH + mac_size;\r
3320                         padding = block_size - length % block_size;\r
3321                         length += padding;\r
3322 #ifdef TLS_WITH_CHACHA20_POLY1305\r
3323                     } else\r
3324                     if (packet->context->crypto.created == 3) {\r
3325                         mac_size = POLY1305_TAGLEN;\r
3326                         length = packet->len - header_size + mac_size;\r
3327 #endif\r
3328                     } else {\r
3329                         mac_size = __TLS_GCM_TAG_LEN;\r
3330                         length = packet->len - header_size + 8 + mac_size;\r
3331                     }\r
3332                     \r
3333                     \r
3334                     if (packet->context->crypto.created == 1) {\r
3335                         unsigned char *buf = (unsigned char *)TLS_MALLOC(length);\r
3336                         if (buf) {\r
3337                             unsigned char *ct = (unsigned char *)TLS_MALLOC(length + header_size);\r
3338                             if (ct) {\r
3339                                 unsigned int buf_pos = 0;\r
3340                                 memcpy(ct, packet->buf, header_size - 2);\r
3341                                 *(unsigned short *)&ct[header_size - 2] = htons(length);\r
3342 #ifdef TLS_LEGACY_SUPPORT\r
3343                                 if (packet->context->version != TLS_V10)\r
3344 #endif\r
3345                                 {\r
3346                                     tls_random(buf, __TLS_AES_IV_LENGTH);\r
3347                                     buf_pos += __TLS_AES_IV_LENGTH;\r
3348                                 }\r
3349                                 // copy payload\r
3350                                 memcpy(buf + buf_pos, packet->buf + header_size, packet->len - header_size);\r
3351                                 buf_pos += packet->len - header_size;\r
3352                                 if (packet->context->dtls) {\r
3353                                     unsigned char temp_buf[5];\r
3354                                     memcpy(temp_buf, packet->buf, 3);\r
3355                                     *(unsigned short *)&temp_buf[3] = *(unsigned short *)&packet->buf[header_size - 2];\r
3356                                     uint64_t dtls_sequence_number = ntohll(*(uint64_t *)&packet->buf[3]);\r
3357                                     __private_tls_hmac_message(1, packet->context, temp_buf, 5, packet->buf + header_size, packet->len  - header_size, buf + buf_pos, mac_size, dtls_sequence_number);\r
3358                                 } else\r
3359                                     __private_tls_hmac_message(1, packet->context, packet->buf, packet->len, NULL, 0, buf + buf_pos, mac_size, 0);\r
3360                                 buf_pos += mac_size;\r
3361                                 \r
3362                                 memset(buf + buf_pos, padding - 1, padding);\r
3363                                 buf_pos += padding;\r
3364                                 \r
3365                                 //DEBUG_DUMP_HEX_LABEL("PT BUFFER", buf, length);\r
3366                                 __private_tls_crypto_encrypt(packet->context, buf, ct + header_size, length);\r
3367                                 TLS_FREE(packet->buf);\r
3368                                 packet->buf = ct;\r
3369                                 packet->len = length + header_size;\r
3370                                 packet->size = packet->len;\r
3371                             } else {\r
3372                                 // invalidate packet\r
3373                                 memset(packet->buf, 0, packet->len);\r
3374                             }\r
3375                             TLS_FREE(buf);\r
3376                         } else {\r
3377                             // invalidate packet\r
3378                             memset(packet->buf, 0, packet->len);\r
3379                         }\r
3380                     } else\r
3381 #ifdef TLS_WITH_CHACHA20_POLY1305\r
3382                     if (packet->context->crypto.created >= 2) {\r
3383 #else\r
3384                     if (packet->context->crypto.created == 2) {\r
3385 #endif\r
3386                         int ct_size = length + header_size + 12 + __TLS_MAX_TAG_LEN;\r
3387                         unsigned char *ct = (unsigned char *)TLS_MALLOC(ct_size);\r
3388                         if (ct) {\r
3389           &n