1 files changed, 49 insertions, 44 deletions

diff --git a/src/transport/gnunet-communicator-tcp.c b/src/transport/gnunet-communicator-tcp.c
index e2f1e4507..1273465c3 100644
--- a/src/transport/gnunet-communicator-tcp.c
+++ b/src/transport/gnunet-communicator-tcp.c
@@ -82,9 +82,9 @@
 
 /**
  * How often do we rekey based on number of bytes transmitted?
- * (additionally randomized).
+ * (additionally randomized). Currently 400 MB
  */
-#define REKEY_MAX_BYTES (1024LLU * 1024 * 1024 * 4LLU)
+#define REKEY_MAX_BYTES (1024LLU * 1024 * 400)
 
 /**
  * Size of the initial key exchange message sent first in both
@@ -469,12 +469,6 @@ struct Queue
   struct GNUNET_HashCode out_hmac;
 
   /**
-   * Our ephemeral key. Stored here temporarily during rekeying / key
-   * generation.
-   */
-  struct GNUNET_CRYPTO_EcdhePrivateKey ephemeral;
-
-  /**
    * ID of read task for this connection.
    */
   struct GNUNET_SCHEDULER_Task *read_task;
@@ -667,6 +661,17 @@ struct Queue
    * Store Context for retrieving the monotonic time send with the handshake ack.
    */
   struct GNUNET_PEERSTORE_StoreContext *handshake_ack_monotime_sc;
+
+  /**
+   * Size of data received without KX challenge played back.
+   */
+  // TODO remove?
+  size_t unverified_size;
+
+  /**
+   * Has the initial (core) handshake already happened?
+   */
+  int initial_core_kx_done;
 };
 
 
@@ -893,11 +898,6 @@ struct ListenTask *lts_tail;
  */
 int addrs_lens;
 
-/**
- * Size of data received without KX challenge played back.
- */
-// TODO remove?
-size_t unverified_size;
 
 /**
  * Database for peer's HELLOs.
@@ -1357,10 +1357,10 @@ static void
 setup_in_cipher (const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral,
                  struct Queue *queue)
 {
-  struct GNUNET_HashCode dh;
+  struct GNUNET_HashCode k;
 
-  GNUNET_CRYPTO_eddsa_ecdh (my_private_key, ephemeral, &dh);
-  setup_cipher (&dh, &my_identity, &queue->in_cipher, &queue->in_hmac);
+  GNUNET_CRYPTO_eddsa_kem_decaps (my_private_key, ephemeral, &k);
+  setup_cipher (&k, &my_identity, &queue->in_cipher, &queue->in_hmac);
 }
 
 
@@ -1557,14 +1557,9 @@ send_challenge (struct GNUNET_CRYPTO_ChallengeNonceP challenge,
  * @param queue queue to setup outgoing (encryption) cipher for
  */
 static void
-setup_out_cipher (struct Queue *queue)
+setup_out_cipher (struct Queue *queue, struct GNUNET_HashCode *dh)
 {
-  struct GNUNET_HashCode dh;
-
-  GNUNET_CRYPTO_ecdh_eddsa (&queue->ephemeral, &queue->target.public_key, &dh);
-  /* we don't need the private key anymore, drop it! */
-  memset (&queue->ephemeral, 0, sizeof(queue->ephemeral));
-  setup_cipher (&dh, &queue->target, &queue->out_cipher, &queue->out_hmac);
+  setup_cipher (dh, &queue->target, &queue->out_cipher, &queue->out_hmac);
   queue->rekey_time = GNUNET_TIME_relative_to_absolute (rekey_interval);
   queue->rekey_left_bytes =
     GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, REKEY_MAX_BYTES);
@@ -1582,13 +1577,14 @@ inject_rekey (struct Queue *queue)
 {
   struct TCPRekey rekey;
   struct TcpRekeySignature thp;
+  struct GNUNET_HashCode k;
 
   GNUNET_assert (0 == queue->pwrite_off);
   memset (&rekey, 0, sizeof(rekey));
-  GNUNET_CRYPTO_ecdhe_key_create (&queue->ephemeral);
+  GNUNET_CRYPTO_eddsa_kem_encaps (&queue->target.public_key, &rekey.ephemeral,
+                                  &k);
   rekey.header.type = ntohs (GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_REKEY);
   rekey.header.size = ntohs (sizeof(rekey));
-  GNUNET_CRYPTO_ecdhe_key_get_public (&queue->ephemeral, &rekey.ephemeral);
   rekey.monotonic_time =
     GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_monotonic (cfg));
   thp.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_TCP_REKEY);
@@ -1627,9 +1623,10 @@ inject_rekey (struct Queue *queue)
   queue->cwrite_off += sizeof(rekey);
   /* Setup new cipher for successive messages */
   gcry_cipher_close (queue->out_cipher);
-  setup_out_cipher (queue);
+  setup_out_cipher (queue, &k);
 }
 
+
 static int
 pending_reversals_delete_it (void *cls,
                              const struct GNUNET_HashCode *key,
@@ -1829,7 +1826,7 @@ queue_write (void *cls)
   if (((0 == queue->rekey_left_bytes) ||
        (0 == GNUNET_TIME_absolute_get_remaining (
           queue->rekey_time).rel_value_us)) &&
-      (((0 == queue->pwrite_off) || ! we_do_not_need_to_rekey)&&
+      (((0 == queue->pwrite_off) || ! we_do_not_need_to_rekey) &&
        (queue->cwrite_off + sizeof (struct TCPRekey) <= BUF_SIZE)))
   {
     inject_rekey (queue);
@@ -1868,24 +1865,23 @@ queue_write (void *cls)
 static size_t
 try_handle_plaintext (struct Queue *queue)
 {
-  const struct GNUNET_MessageHeader *hdr =
-    (const struct GNUNET_MessageHeader *) queue->pread_buf;
-  const struct TCPConfirmationAck *tca = (const struct
-                                          TCPConfirmationAck *) queue->pread_buf;
-  const struct TCPBox *box = (const struct TCPBox *) queue->pread_buf;
-  const struct TCPRekey *rekey = (const struct TCPRekey *) queue->pread_buf;
-  const struct TCPFinish *fin = (const struct TCPFinish *) queue->pread_buf;
+  const struct GNUNET_MessageHeader *hdr;
+  const struct TCPConfirmationAck *tca;
+  const struct TCPBox *box;
+  const struct TCPRekey *rekey;
+  const struct TCPFinish *fin;
   struct TCPRekey rekeyz;
   struct TCPFinish finz;
   struct GNUNET_ShortHashCode tmac;
   uint16_t type;
-  size_t size = 0; /* make compiler happy */
+  size_t size = 0;
   struct TcpHandshakeAckSignature thas;
   const struct GNUNET_CRYPTO_ChallengeNonceP challenge = queue->challenge;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "try handle plaintext!\n");
 
+  hdr = (const struct GNUNET_MessageHeader *) queue->pread_buf;
   if ((sizeof(*hdr) > queue->pread_off))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -1893,11 +1889,12 @@ try_handle_plaintext (struct Queue *queue)
     return 0; /* not even a header */
   }
 
-  if ((-1 != unverified_size) && (unverified_size > INITIAL_CORE_KX_SIZE))
+  if ((GNUNET_YES != queue->initial_core_kx_done) && (queue->unverified_size >
+                                                      INITIAL_CORE_KX_SIZE))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Already received data of size %lu bigger than KX size %lu!\n",
-                unverified_size,
+                queue->unverified_size,
                 INITIAL_CORE_KX_SIZE);
     GNUNET_break_op (0);
     queue_finish (queue);
@@ -1908,6 +1905,7 @@ try_handle_plaintext (struct Queue *queue)
   switch (type)
   {
   case GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_CONFIRMATION_ACK:
+    tca = (const struct TCPConfirmationAck *) queue->pread_buf;
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "start processing ack\n");
     if (sizeof(*tca) > queue->pread_off)
@@ -1980,7 +1978,11 @@ try_handle_plaintext (struct Queue *queue)
                                          queue->address->sa_family, NULL);
     }
 
-    unverified_size = -1;
+    /**
+     * Once we received this ack, we consider this a verified connection.
+     * FIXME: I am not sure this logic is sane here.
+     */
+    queue->initial_core_kx_done = GNUNET_YES;
 
     char *foreign_addr;
 
@@ -2020,6 +2022,7 @@ try_handle_plaintext (struct Queue *queue)
     break;
   case GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_BOX:
     /* Special case: header size excludes box itself! */
+    box = (const struct TCPBox *) queue->pread_buf;
     if (ntohs (hdr->size) + sizeof(struct TCPBox) > queue->pread_off)
       return 0;
     calculate_hmac (&queue->in_hmac, &box[1], ntohs (hdr->size), &tmac);
@@ -2036,6 +2039,7 @@ try_handle_plaintext (struct Queue *queue)
     break;
 
   case GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_REKEY:
+    rekey = (const struct TCPRekey *) queue->pread_buf;
     if (sizeof(*rekey) > queue->pread_off)
       return 0;
     if (ntohs (hdr->size) != sizeof(*rekey))
@@ -2060,6 +2064,7 @@ try_handle_plaintext (struct Queue *queue)
     break;
 
   case GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_FINISH:
+    fin = (const struct TCPFinish *) queue->pread_buf;
     if (sizeof(*fin) > queue->pread_off)
       return 0;
     if (ntohs (hdr->size) != sizeof(*fin))
@@ -2091,8 +2096,8 @@ try_handle_plaintext (struct Queue *queue)
     return 0;
   }
   GNUNET_assert (0 != size);
-  if (-1 != unverified_size)
-    unverified_size += size;
+  if (-1 != queue->unverified_size)
+    queue->unverified_size += size;
   return size;
 }
 
@@ -2712,10 +2717,10 @@ static void
 start_initial_kx_out (struct Queue *queue)
 {
   struct GNUNET_CRYPTO_EcdhePublicKey epub;
+  struct GNUNET_HashCode k;
 
-  GNUNET_CRYPTO_ecdhe_key_create (&queue->ephemeral);
-  GNUNET_CRYPTO_ecdhe_key_get_public (&queue->ephemeral, &epub);
-  setup_out_cipher (queue);
+  GNUNET_CRYPTO_eddsa_kem_encaps (&queue->target.public_key, &epub, &k);
+  setup_out_cipher (queue, &k);
   transmit_kx (queue, &epub);
 }
 
@@ -3060,6 +3065,7 @@ proto_read_kx (void *cls)
   GNUNET_free (pq);
 }
 
+
 static struct ProtoQueue *
 create_proto_queue (struct GNUNET_NETWORK_Handle *sock,
                     struct sockaddr *in,
@@ -3120,7 +3126,6 @@ listen_cb (void *cls)
   struct sockaddr_storage in;
   socklen_t addrlen;
   struct GNUNET_NETWORK_Handle *sock;
-  struct ProtoQueue *pq;
   struct ListenTask *lt;
   struct sockaddr *in_addr;