43be4aced93e255d5f27b4c5085700b3c7c91e69
[dragonfly.git] / sbin / hammer2 / crypto.c
1 /*
2  * Copyright (c) 2011-2012 The DragonFly Project.  All rights reserved.
3  *
4  * This code is derived from software contributed to The DragonFly Project
5  * by Matthew Dillon <dillon@dragonflybsd.org>
6  * by Venkatesh Srinivas <vsrinivas@dragonflybsd.org>
7  * by Alex Hornung <alexh@dragonflybsd.org>
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  *
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in
17  *    the documentation and/or other materials provided with the
18  *    distribution.
19  * 3. Neither the name of The DragonFly Project nor the names of its
20  *    contributors may be used to endorse or promote products derived
21  *    from this software without specific, prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
26  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
27  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
28  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
29  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
30  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
31  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
32  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
33  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.
35  */
36
37 #include "hammer2.h"
38 #include <sys/endian.h>
39
40 /*
41  * Setup crypto for pthreads
42  */
43 static pthread_mutex_t *crypto_locks;
44 int crypto_count;
45
46 static
47 unsigned long
48 hammer2_crypto_id_callback(void)
49 {
50         return ((unsigned long)(uintptr_t)pthread_self());
51 }
52
53 static
54 void
55 hammer2_crypto_locking_callback(int mode, int type,
56                                 const char *file __unused, int line __unused)
57 {
58         assert(type >= 0 && type < crypto_count);
59         if (mode & CRYPTO_LOCK) {
60                 pthread_mutex_lock(&crypto_locks[type]);
61         } else {
62                 pthread_mutex_unlock(&crypto_locks[type]);
63         }
64 }
65
66 void
67 hammer2_crypto_setup(void)
68 {
69         crypto_count = CRYPTO_num_locks();
70         crypto_locks = calloc(crypto_count, sizeof(crypto_locks[0]));
71         CRYPTO_set_id_callback(hammer2_crypto_id_callback);
72         CRYPTO_set_locking_callback(hammer2_crypto_locking_callback);
73 }
74
75 static
76 int
77 _gcm_init(hammer2_ioq_t *ioq, char *key, int klen, char *iv_fixed, int ivlen,
78           int enc)
79 {
80         int i, ok;
81
82         if (klen < 32 /* 256 bits */ || ivlen < 4 /* 32 bits */) {
83                 if (DebugOpt)
84                         fprintf(stderr, "Not enough key or iv material\n");
85                 return -1;
86         }
87
88         printf("%s key: ", enc ? "Encryption" : "Decryption");
89         for (i = 0; i < HAMMER2_AES_KEY_SIZE; ++i)
90                 printf("%02x", (unsigned char)key[i]);
91         printf("\n");
92
93         printf("%s iv:  ", enc ? "Encryption" : "Decryption");
94         for (i = 0; i < HAMMER2_CRYPTO_IV_FIXED_SIZE; ++i)
95                 printf("%02x", (unsigned char)iv_fixed[i]);
96         printf(" (fixed part only)\n");
97
98
99         EVP_CIPHER_CTX_init(&ioq->ctx);
100
101         if (enc)
102                 ok = EVP_EncryptInit_ex(&ioq->ctx, EVP_aes_256_gcm(), NULL,
103                                         key, NULL);
104         else
105                 ok = EVP_DecryptInit_ex(&ioq->ctx, EVP_aes_256_gcm(), NULL,
106                                         key, NULL);
107         if (!ok)
108                 goto fail;
109
110         /*
111          * According to the original Galois/Counter Mode of Operation (GCM)
112          * proposal, only IVs that are exactly 96 bits get used without any
113          * further processing. Other IV sizes cause the GHASH() operation
114          * to be applied to the IV, which is more costly.
115          *
116          * The NIST SP 800-38D also recommends using a 96 bit IV for the same
117          * reasons. We actually follow the deterministic construction
118          * recommended in NIST SP 800-38D with a 64 bit invocation field as an
119          * integer counter and a random, session-specific fixed field.
120          *
121          * This means that we can essentially use the same session key and
122          * IV fixed field for up to 2^64 invocations of the authenticated
123          * encryption or decryption.
124          *
125          * With a chunk size of 64 bytes, this adds up to 1 zettabyte of
126          * traffic.
127          */
128         ok = EVP_CIPHER_CTX_ctrl(&ioq->ctx, EVP_CTRL_GCM_SET_IVLEN,
129                                  HAMMER2_CRYPTO_IV_SIZE, NULL);
130         if (!ok)
131                 goto fail;
132
133         memset(ioq->iv, 0, HAMMER2_CRYPTO_IV_SIZE);
134         memcpy(ioq->iv, iv_fixed, HAMMER2_CRYPTO_IV_FIXED_SIZE);
135
136         /*
137          * Strictly speaking, padding is irrelevant with a counter mode
138          * encryption.
139          *
140          * However, setting padding to 0, even if using a counter mode such
141          * as GCM, will cause an error in _finish if the pt/ct size is not
142          * a multiple of the cipher block size.
143          */
144         EVP_CIPHER_CTX_set_padding(&ioq->ctx, 0);
145
146         return 0;
147
148 fail:
149         if (DebugOpt)
150                 fprintf(stderr, "Error during _gcm_init\n");
151         return -1;
152 }
153
154 static
155 int
156 _gcm_iv_increment(char *iv)
157 {
158         /*
159          * Deterministic construction according to NIST SP 800-38D, with
160          * 64 bit invocation field as integer counter.
161          *
162          * In other words, our 96 bit IV consists of a 32 bit fixed field
163          * unique to the session and a 64 bit integer counter.
164          */
165
166         uint64_t *c = (uint64_t *)(&iv[HAMMER2_CRYPTO_IV_FIXED_SIZE]);
167
168         /* Increment invocation field integer counter */
169         /*
170          * XXX: this should ideally be an atomic update, but we don't have
171          * an atomic_fetchadd_64 for i386 yet
172          */
173         *c = htobe64(be64toh(*c)+1);
174
175         /*
176          * Detect wrap-around, which means it is time to renegotiate
177          * the session to get a new key and/or fixed field.
178          */
179         return (c == 0) ? 0 : 1;
180 }
181
182 static
183 int
184 hammer2_crypto_encrypt_chunk(hammer2_ioq_t *ioq, char *ct, char *pt,
185                              int in_size, int *out_size)
186 {
187         int ok;
188 #ifdef CRYPTO_DEBUG
189         int i;
190 #endif
191         int u_len, f_len;
192
193         *out_size = 0;
194
195         /* Re-initialize with new IV (but without redoing the key schedule) */
196         ok = EVP_EncryptInit_ex(&ioq->ctx, NULL, NULL, NULL, ioq->iv);
197         if (!ok)
198                 goto fail;
199
200         ok = EVP_EncryptUpdate(&ioq->ctx, ct, &u_len, pt, in_size);
201         if (!ok)
202                 goto fail;
203
204         ok = EVP_EncryptFinal(&ioq->ctx, ct + u_len, &f_len);
205         if (!ok)
206                 goto fail;
207
208         /* Retrieve auth tag */
209         ok = EVP_CIPHER_CTX_ctrl(&ioq->ctx, EVP_CTRL_GCM_GET_TAG,
210                                  HAMMER2_CRYPTO_TAG_SIZE,
211                                  ct + u_len + f_len);
212         if (!ok)
213                 goto fail;
214
215 #ifdef CRYPTO_DEBUG
216         printf("enc_chunk iv: ");
217         for (i = 0; i < HAMMER2_CRYPTO_IV_SIZE; i++)
218                 printf("%02x", (unsigned char)ioq->iv[i]);
219         printf("\n");
220
221         printf("enc_chunk pt: ");
222         for (i = 0; i < in_size; i++)
223                 printf("%02x", (unsigned char)pt[i]);
224         printf("\n");
225
226         printf("enc_chunk ct: ");
227         for (i = 0; i < in_size; i++)
228                 printf("%02x", (unsigned char)ct[i]);
229         printf("\n");
230
231         printf("enc_chunk tag: ");
232         for (i = 0; i < HAMMER2_CRYPTO_TAG_SIZE; i++)
233                 printf("%02x", (unsigned char)ct[i + u_len + f_len]);
234         printf("\n");
235 #endif
236
237         ok = _gcm_iv_increment(ioq->iv);
238         if (!ok) {
239                 ioq->error = HAMMER2_IOQ_ERROR_IVWRAP;
240                 goto fail_out;
241         }
242
243         *out_size = u_len + f_len + HAMMER2_CRYPTO_TAG_SIZE;
244
245         return 0;
246
247 fail:
248         ioq->error = HAMMER2_IOQ_ERROR_ALGO;
249 fail_out:
250         if (DebugOpt)
251                 fprintf(stderr, "error during encrypt_chunk\n");
252         return -1;
253 }
254
255 static
256 int
257 hammer2_crypto_decrypt_chunk(hammer2_ioq_t *ioq, char *ct, char *pt,
258                              int out_size, int *consume_size)
259 {
260         int ok;
261 #ifdef CRYPTO_DEBUG
262         int i;
263 #endif
264         int u_len, f_len;
265
266         *consume_size = 0;
267
268         /* Re-initialize with new IV (but without redoing the key schedule) */
269         ok = EVP_DecryptInit_ex(&ioq->ctx, NULL, NULL, NULL, ioq->iv);
270         if (!ok) {
271                 ioq->error = HAMMER2_IOQ_ERROR_ALGO;
272                 goto fail_out;
273         }
274
275 #ifdef CRYPTO_DEBUG
276         printf("dec_chunk iv: ");
277         for (i = 0; i < HAMMER2_CRYPTO_IV_SIZE; i++)
278                 printf("%02x", (unsigned char)ioq->iv[i]);
279         printf("\n");
280
281         printf("dec_chunk ct: ");
282         for (i = 0; i < out_size; i++)
283                 printf("%02x", (unsigned char)ct[i]);
284         printf("\n");
285
286         printf("dec_chunk tag: ");
287         for (i = 0; i < HAMMER2_CRYPTO_TAG_SIZE; i++)
288                 printf("%02x", (unsigned char)ct[out_size + i]);
289         printf("\n");
290 #endif
291
292         ok = EVP_CIPHER_CTX_ctrl(&ioq->ctx, EVP_CTRL_GCM_SET_TAG,
293                                  HAMMER2_CRYPTO_TAG_SIZE,
294                                  ct + out_size);
295         if (!ok) {
296                 ioq->error = HAMMER2_IOQ_ERROR_ALGO;
297                 goto fail_out;
298         }
299
300         ok = EVP_DecryptUpdate(&ioq->ctx, pt, &u_len, ct, out_size);
301         if (!ok)
302                 goto fail;
303
304         ok = EVP_DecryptFinal(&ioq->ctx, pt + u_len, &f_len);
305         if (!ok)
306                 goto fail;
307
308         ok = _gcm_iv_increment(ioq->iv);
309         if (!ok) {
310                 ioq->error = HAMMER2_IOQ_ERROR_IVWRAP;
311                 goto fail_out;
312         }
313
314         *consume_size = u_len + f_len + HAMMER2_CRYPTO_TAG_SIZE;
315
316 #ifdef CRYPTO_DEBUG
317         printf("dec_chunk pt: ");
318         for (i = 0; i < out_size; i++)
319                 printf("%02x", (unsigned char)pt[i]);
320         printf("\n");
321 #endif
322
323         return 0;
324
325 fail:
326         ioq->error = HAMMER2_IOQ_ERROR_MACFAIL;
327 fail_out:
328         if (DebugOpt)
329                 fprintf(stderr, "error during decrypt_chunk (likely authentication error)\n");
330         return -1;
331 }
332
333 /*
334  * Synchronously negotiate crypto for a new session.  This must occur
335  * within 10 seconds or the connection is error'd out.
336  *
337  * We work off the IP address and/or reverse DNS.  The IP address is
338  * checked first, followed by the IP address at various levels of granularity,
339  * followed by the full domain name and domain names at various levels of
340  * granularity.
341  *
342  *      /etc/hammer2/remote/<name>.pub  - Contains a public key
343  *      /etc/hammer2/remote/<name>.none - Indicates no encryption (empty file)
344  *                                        (e.g. localhost.none).
345  *
346  * We first attempt to locate a public key file based on the peer address or
347  * peer FQDN.
348  *
349  *      <name>.none     - No further negotiation is needed.  We simply return.
350  *                        All communication proceeds without encryption.
351  *                        No public key handshake occurs in this situation.
352  *                        (both ends must match).
353  *
354  *      <name>.pub      - We have located the public key for the peer.  Both
355  *                        sides transmit a block encrypted with their private
356  *                        keys and the peer's public key.
357  *
358  *                        Both sides receive a block and decrypt it.
359  *
360  *                        Both sides formulate a reply using the decrypted
361  *                        block and transmit it.
362  *
363  *                        communication proceeds with the negotiated session
364  *                        key (typically AES-256-CBC).
365  *
366  * If we fail to locate the appropriate file and no floating.db exists the
367  * connection is terminated without further action.
368  *
369  * If floating.db exists the connection proceeds with a floating negotiation.
370  */
371 typedef union {
372         struct sockaddr sa;
373         struct sockaddr_in sa_in;
374         struct sockaddr_in6 sa_in6;
375 } sockaddr_any_t;
376
377 void
378 hammer2_crypto_negotiate(hammer2_iocom_t *iocom)
379 {
380         sockaddr_any_t sa;
381         socklen_t salen = sizeof(sa);
382         char peername[128];
383         char realname[128];
384         hammer2_handshake_t handtx;
385         hammer2_handshake_t handrx;
386         char buf1[sizeof(handtx)];
387         char buf2[sizeof(handtx)];
388         char *ptr;
389         char *path;
390         struct stat st;
391         FILE *fp;
392         RSA *keys[3] = { NULL, NULL, NULL };
393         size_t i;
394         size_t blksize;
395         size_t blkmask;
396         ssize_t n;
397         int fd;
398         int error;
399
400         /*
401          * Get the peer IP address for the connection as a string.
402          */
403         if (getpeername(iocom->sock_fd, &sa.sa, &salen) < 0) {
404                 iocom->ioq_rx.error = HAMMER2_IOQ_ERROR_NOPEER;
405                 iocom->flags |= HAMMER2_IOCOMF_EOF;
406                 if (DebugOpt)
407                         fprintf(stderr, "accept: getpeername() failed\n");
408                 goto done;
409         }
410         if (getnameinfo(&sa.sa, salen, peername, sizeof(peername),
411                         NULL, 0, NI_NUMERICHOST) < 0) {
412                 iocom->ioq_rx.error = HAMMER2_IOQ_ERROR_NOPEER;
413                 iocom->flags |= HAMMER2_IOCOMF_EOF;
414                 if (DebugOpt)
415                         fprintf(stderr, "accept: cannot decode sockaddr\n");
416                 goto done;
417         }
418         if (DebugOpt) {
419                 if (realhostname_sa(realname, sizeof(realname),
420                                     &sa.sa, salen) == HOSTNAME_FOUND) {
421                         fprintf(stderr, "accept from %s (%s)\n",
422                                 peername, realname);
423                 } else {
424                         fprintf(stderr, "accept from %s\n", peername);
425                 }
426         }
427
428         /*
429          * Find the remote host's public key
430          *
431          * If the link is not to be encrypted (<ip>.none located) we shortcut
432          * the handshake entirely.  No buffers are exchanged.
433          */
434         asprintf(&path, "%s/%s.pub", HAMMER2_PATH_REMOTE, peername);
435         if ((fp = fopen(path, "r")) == NULL) {
436                 free(path);
437                 asprintf(&path, "%s/%s.none",
438                          HAMMER2_PATH_REMOTE, peername);
439                 if (stat(path, &st) < 0) {
440                         iocom->ioq_rx.error = HAMMER2_IOQ_ERROR_NORKEY;
441                         iocom->flags |= HAMMER2_IOCOMF_EOF;
442                         if (DebugOpt)
443                                 fprintf(stderr, "auth failure: unknown host\n");
444                         goto done;
445                 }
446                 if (DebugOpt)
447                         fprintf(stderr, "auth succeeded, unencrypted link\n");
448                 goto done;
449         }
450         if (fp) {
451                 keys[0] = PEM_read_RSA_PUBKEY(fp, NULL, NULL, NULL);
452                 fclose(fp);
453                 if (keys[0] == NULL) {
454                         iocom->ioq_rx.error = HAMMER2_IOQ_ERROR_KEYFMT;
455                         iocom->flags |= HAMMER2_IOCOMF_EOF;
456                         if (DebugOpt)
457                                 fprintf(stderr,
458                                         "auth failure: bad key format\n");
459                         goto done;
460                 }
461         }
462
463         /*
464          * Get our public and private keys
465          */
466         free(path);
467         asprintf(&path, HAMMER2_DEFAULT_DIR "/rsa.pub");
468         if ((fp = fopen(path, "r")) == NULL) {
469                 iocom->ioq_rx.error = HAMMER2_IOQ_ERROR_NOLKEY;
470                 iocom->flags |= HAMMER2_IOCOMF_EOF;
471                 goto done;
472         }
473         keys[1] = PEM_read_RSA_PUBKEY(fp, NULL, NULL, NULL);
474         fclose(fp);
475         if (keys[1] == NULL) {
476                 iocom->ioq_rx.error = HAMMER2_IOQ_ERROR_KEYFMT;
477                 iocom->flags |= HAMMER2_IOCOMF_EOF;
478                 if (DebugOpt)
479                         fprintf(stderr, "auth failure: bad host key format\n");
480                 goto done;
481         }
482
483         free(path);
484         asprintf(&path, HAMMER2_DEFAULT_DIR "/rsa.prv");
485         if ((fp = fopen(path, "r")) == NULL) {
486                 iocom->ioq_rx.error = HAMMER2_IOQ_ERROR_NOLKEY;
487                 iocom->flags |= HAMMER2_IOCOMF_EOF;
488                 if (DebugOpt)
489                         fprintf(stderr, "auth failure: bad host key format\n");
490                 goto done;
491         }
492         keys[2] = PEM_read_RSAPrivateKey(fp, NULL, NULL, NULL);
493         fclose(fp);
494         if (keys[2] == NULL) {
495                 iocom->ioq_rx.error = HAMMER2_IOQ_ERROR_KEYFMT;
496                 iocom->flags |= HAMMER2_IOCOMF_EOF;
497                 if (DebugOpt)
498                         fprintf(stderr, "auth failure: bad host key format\n");
499                 goto done;
500         }
501         free(path);
502         path = NULL;
503
504         /*
505          * public key encrypt/decrypt block size.
506          */
507         if (keys[0]) {
508                 blksize = (size_t)RSA_size(keys[0]);
509                 if (blksize != (size_t)RSA_size(keys[1]) ||
510                     blksize != (size_t)RSA_size(keys[2]) ||
511                     sizeof(handtx) % blksize != 0) {
512                         iocom->ioq_rx.error = HAMMER2_IOQ_ERROR_KEYFMT;
513                         iocom->flags |= HAMMER2_IOCOMF_EOF;
514                         if (DebugOpt)
515                                 fprintf(stderr, "auth failure: "
516                                                 "key size mismatch\n");
517                         goto done;
518                 }
519         } else {
520                 blksize = sizeof(handtx);
521         }
522         blkmask = blksize - 1;
523
524         bzero(&handrx, sizeof(handrx));
525         bzero(&handtx, sizeof(handtx));
526
527         /*
528          * Fill all unused fields (particular all junk fields) with random
529          * data, and also set the session key.
530          */
531         fd = open("/dev/urandom", O_RDONLY);
532         if (fd < 0 ||
533             fstat(fd, &st) < 0 ||       /* something wrong */
534             S_ISREG(st.st_mode) ||      /* supposed to be a RNG dev! */
535             read(fd, &handtx, sizeof(handtx)) != sizeof(handtx)) {
536 urandfail:
537                 if (fd >= 0)
538                         close(fd);
539                 iocom->ioq_rx.error = HAMMER2_IOQ_ERROR_BADURANDOM;
540                 iocom->flags |= HAMMER2_IOCOMF_EOF;
541                 if (DebugOpt)
542                         fprintf(stderr, "auth failure: bad rng\n");
543                 goto done;
544         }
545         if (bcmp(&handrx, &handtx, sizeof(handtx)) == 0)
546                 goto urandfail;                 /* read all zeros */
547         close(fd);
548         /* ERR_load_crypto_strings(); openssl debugging */
549
550         /*
551          * Handshake with the remote.
552          *
553          *      Encrypt with my private and remote's public
554          *      Decrypt with my private and remote's public
555          *
556          * When encrypting we have to make sure our buffer fits within the
557          * modulus, which typically requires bit 7 o the first byte to be
558          * zero.  To be safe make sure that bit 7 and bit 6 is zero.
559          */
560         snprintf(handtx.quickmsg, sizeof(handtx.quickmsg), "Testing 1 2 3");
561         handtx.magic = HAMMER2_MSGHDR_MAGIC;
562         handtx.version = 1;
563         handtx.flags = 0;
564         assert(sizeof(handtx.verf) * 4 == sizeof(handtx.sess));
565         bzero(handtx.verf, sizeof(handtx.verf));
566
567         handtx.pad1[0] &= 0x3f; /* message must fit within modulus */
568         handtx.pad2[0] &= 0x3f; /* message must fit within modulus */
569
570         for (i = 0; i < sizeof(handtx.sess); ++i)
571                 handtx.verf[i / 4] ^= handtx.sess[i];
572
573         /*
574          * Write handshake buffer to remote
575          */
576         for (i = 0; i < sizeof(handtx); i += blksize) {
577                 ptr = (char *)&handtx + i;
578                 if (keys[0]) {
579                         /*
580                          * Since we are double-encrypting we have to make
581                          * sure that the result of the first stage does
582                          * not blow out the modulus for the second stage.
583                          *
584                          * The pointer is pointing to the pad*[] area so
585                          * we can mess with that until the first stage
586                          * is legal.
587                          */
588                         do {
589                                 ++*(int *)(ptr + 4);
590                                 if (RSA_private_encrypt(blksize, ptr, buf1,
591                                             keys[2], RSA_NO_PADDING) < 0) {
592                                         iocom->ioq_rx.error =
593                                                 HAMMER2_IOQ_ERROR_KEYXCHGFAIL;
594                                 }
595                         } while (buf1[0] & 0xC0);
596
597                         if (RSA_public_encrypt(blksize, buf1, buf2,
598                                             keys[0], RSA_NO_PADDING) < 0) {
599                                 iocom->ioq_rx.error =
600                                         HAMMER2_IOQ_ERROR_KEYXCHGFAIL;
601                         }
602                 }
603                 if (write(iocom->sock_fd, buf2, blksize) != (ssize_t)blksize) {
604                         fprintf(stderr, "WRITE ERROR\n");
605                 }
606         }
607         if (iocom->ioq_rx.error) {
608                 iocom->flags |= HAMMER2_IOCOMF_EOF;
609                 if (DebugOpt)
610                         fprintf(stderr, "auth failure: key exchange failure "
611                                         "during encryption\n");
612                 goto done;
613         }
614
615         /*
616          * Read handshake buffer from remote
617          */
618         i = 0;
619         while (i < sizeof(handrx)) {
620                 ptr = (char *)&handrx + i;
621                 n = read(iocom->sock_fd, ptr, blksize - (i & blkmask));
622                 if (n <= 0)
623                         break;
624                 ptr -= (i & blkmask);
625                 i += n;
626                 if (keys[0] && (i & blkmask) == 0) {
627                         if (RSA_private_decrypt(blksize, ptr, buf1,
628                                            keys[2], RSA_NO_PADDING) < 0)
629                                 iocom->ioq_rx.error =
630                                                 HAMMER2_IOQ_ERROR_KEYXCHGFAIL;
631                         if (RSA_public_decrypt(blksize, buf1, ptr,
632                                            keys[0], RSA_NO_PADDING) < 0)
633                                 iocom->ioq_rx.error =
634                                                 HAMMER2_IOQ_ERROR_KEYXCHGFAIL;
635                 }
636         }
637         if (iocom->ioq_rx.error) {
638                 iocom->flags |= HAMMER2_IOCOMF_EOF;
639                 if (DebugOpt)
640                         fprintf(stderr, "auth failure: key exchange failure "
641                                         "during decryption\n");
642                 goto done;
643         }
644
645         /*
646          * Validate the received data.  Try to make this a constant-time
647          * algorithm.
648          */
649         if (i != sizeof(handrx)) {
650 keyxchgfail:
651                 iocom->ioq_rx.error = HAMMER2_IOQ_ERROR_KEYXCHGFAIL;
652                 iocom->flags |= HAMMER2_IOCOMF_EOF;
653                 if (DebugOpt)
654                         fprintf(stderr, "auth failure: key exchange failure\n");
655                 goto done;
656         }
657
658         if (handrx.magic == HAMMER2_MSGHDR_MAGIC_REV) {
659                 handrx.version = bswap16(handrx.version);
660                 handrx.flags = bswap32(handrx.flags);
661         }
662         for (i = 0; i < sizeof(handrx.sess); ++i)
663                 handrx.verf[i / 4] ^= handrx.sess[i];
664         n = 0;
665         for (i = 0; i < sizeof(handrx.verf); ++i)
666                 n += handrx.verf[i];
667         if (handrx.version != 1)
668                 ++n;
669         if (n != 0)
670                 goto keyxchgfail;
671
672         assert(HAMMER2_AES_KEY_SIZE * 2 == sizeof(handrx.sess));
673         /*
674          * Use separate session keys and session fixed IVs for receive and
675          * transmit.
676          */
677         error = _gcm_init(&iocom->ioq_rx, handrx.sess, HAMMER2_AES_KEY_SIZE,
678             handrx.sess + HAMMER2_AES_KEY_SIZE,
679             sizeof(handrx.sess) - HAMMER2_AES_KEY_SIZE,
680             0 /* decryption */);
681         if (error)
682                 goto keyxchgfail;
683
684         error = _gcm_init(&iocom->ioq_tx, handtx.sess, HAMMER2_AES_KEY_SIZE,
685             handtx.sess + HAMMER2_AES_KEY_SIZE,
686             sizeof(handtx.sess) - HAMMER2_AES_KEY_SIZE,
687             1 /* encryption */);
688         if (error)
689                 goto keyxchgfail;
690
691         iocom->flags |= HAMMER2_IOCOMF_CRYPTED;
692
693         if (DebugOpt)
694                 fprintf(stderr, "auth success: %s\n", handrx.quickmsg);
695 done:
696         if (path)
697                 free(path);
698         if (keys[0])
699                 RSA_free(keys[0]);
700         if (keys[1])
701                 RSA_free(keys[1]);
702         if (keys[1])
703                 RSA_free(keys[2]);
704 }
705
706 /*
707  * Decrypt pending data in the ioq's fifo.  The data is decrypted in-place.
708  */
709 void
710 hammer2_crypto_decrypt(hammer2_iocom_t *iocom __unused, hammer2_ioq_t *ioq)
711 {
712         int p_len;
713         int used;
714         int error;
715         char buf[512];
716
717         /*
718          * fifo_beg to fifo_cdx is data already decrypted.
719          * fifo_cdn to fifo_end is data not yet decrypted.
720          */
721         p_len = ioq->fifo_end - ioq->fifo_cdn; /* data not yet decrypted */
722
723         if (p_len == 0)
724                 return;
725
726         while (p_len >= HAMMER2_CRYPTO_TAG_SIZE + HAMMER2_CRYPTO_CHUNK_SIZE) {
727                 bcopy(ioq->buf + ioq->fifo_cdn, buf,
728                       HAMMER2_CRYPTO_TAG_SIZE + HAMMER2_CRYPTO_CHUNK_SIZE);
729                 error = hammer2_crypto_decrypt_chunk(ioq, buf,
730                                                      ioq->buf + ioq->fifo_cdx,
731                                                      HAMMER2_CRYPTO_CHUNK_SIZE,
732                                                      &used);
733 #ifdef CRYPTO_DEBUG
734                 printf("dec: p_len: %d, used: %d, fifo_cdn: %ju, fifo_cdx: %ju\n",
735                        p_len, used, ioq->fifo_cdn, ioq->fifo_cdx);
736 #endif
737                 p_len -= used;
738                 ioq->fifo_cdn += used;
739                 ioq->fifo_cdx += HAMMER2_CRYPTO_CHUNK_SIZE;
740 #ifdef CRYPTO_DEBUG
741                 printf("dec: p_len: %d, used: %d, fifo_cdn: %ju, fifo_cdx: %ju\n",
742                        p_len, used, ioq->fifo_cdn, ioq->fifo_cdx);
743 #endif
744         }
745 }
746
747 /*
748  * *nactp is set to the number of ORIGINAL bytes consumed by the encrypter.
749  * The FIFO may contain more data.
750  */
751 int
752 hammer2_crypto_encrypt(hammer2_iocom_t *iocom __unused, hammer2_ioq_t *ioq,
753                        struct iovec *iov, int n, size_t *nactp)
754 {
755         int p_len, used, ct_used;
756         int i;
757         int error;
758         size_t nmax;
759
760         nmax = sizeof(ioq->buf) - ioq->fifo_end;        /* max new bytes */
761
762         *nactp = 0;
763         for (i = 0; i < n && nmax; ++i) {
764                 used = 0;
765                 p_len = iov[i].iov_len;
766                 assert((p_len & HAMMER2_AES_KEY_MASK) == 0);
767
768                 while (p_len >= HAMMER2_CRYPTO_CHUNK_SIZE &&
769                     nmax >= HAMMER2_CRYPTO_CHUNK_SIZE + HAMMER2_CRYPTO_TAG_SIZE) {
770                         error = hammer2_crypto_encrypt_chunk(ioq,
771                             ioq->buf + ioq->fifo_cdx,
772                             (char *)iov[i].iov_base + used,
773                             HAMMER2_CRYPTO_CHUNK_SIZE, &ct_used);
774 #ifdef CRYPTO_DEBUG
775                         printf("nactp: %ju, p_len: %d, ct_used: %d, used: %d, nmax: %ju\n",
776                                *nactp, p_len, ct_used, used, nmax);
777 #endif
778
779                         *nactp += (size_t)HAMMER2_CRYPTO_CHUNK_SIZE;    /* plaintext count */
780                         used += HAMMER2_CRYPTO_CHUNK_SIZE;
781                         p_len -= HAMMER2_CRYPTO_CHUNK_SIZE;
782
783                         ioq->fifo_cdx += (size_t)ct_used;       /* crypted count */
784                         ioq->fifo_cdn += (size_t)ct_used;       /* crypted count */
785                         ioq->fifo_end += (size_t)ct_used;
786                         nmax -= (size_t)ct_used;
787 #ifdef CRYPTO_DEBUG
788                         printf("nactp: %ju, p_len: %d, ct_used: %d, used: %d, nmax: %ju\n",
789                                *nactp, p_len, ct_used, used, nmax);
790 #endif
791                 }
792         }
793         iov[0].iov_base = ioq->buf + ioq->fifo_beg;
794         iov[0].iov_len = ioq->fifo_cdx - ioq->fifo_beg;
795
796         return (1);
797 }