4 files changed, 62 insertions, 45 deletions

diff --git a/src/identity/gnunet-identity.c b/src/identity/gnunet-identity.c
index 59354a2e1..7adc86eb8 100644
--- a/src/identity/gnunet-identity.c
+++ b/src/identity/gnunet-identity.c
@@ -259,20 +259,20 @@ static void
 write_encrypted_message (void)
 {
   struct GNUNET_IDENTITY_PublicKey recipient;
-  unsigned char ct[strlen (write_msg) + 1024];
+  size_t ct_len = strlen (write_msg) + 1
+                  + GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES;
+  unsigned char ct[ct_len];
   if (GNUNET_IDENTITY_public_key_from_string (pubkey_msg, &recipient) !=
       GNUNET_SYSERR)
   {
     size_t msg_len = strlen (write_msg) + 1;
-    ssize_t res = GNUNET_IDENTITY_encrypt (write_msg,
-                                           msg_len,
-                                           &recipient,
-                                           ct, strlen (write_msg) + 1024);
-    if (-1 != res)
+    if (GNUNET_OK == GNUNET_IDENTITY_encrypt (write_msg,
+                                              msg_len,
+                                              &recipient,
+                                              ct, ct_len))
     {
       char *serialized_msg;
-      serialized_msg = GNUNET_STRINGS_data_to_string_alloc (ct,
-                                                            res);
+      serialized_msg = GNUNET_STRINGS_data_to_string_alloc (ct, ct_len);
       fprintf (stdout,
                "%s\n",
                serialized_msg);
@@ -309,14 +309,13 @@ read_encrypted_message (struct GNUNET_IDENTITY_Ego *ego)
                                                         deserialized_msg,
                                                         &msg_len))
   {
-    ssize_t res = GNUNET_IDENTITY_decrypt (deserialized_msg,
-                                           msg_len,
-                                           GNUNET_IDENTITY_ego_get_private_key (
-                                             ego),
-                                           deserialized_msg, msg_len);
-    if (-1 != res)
+    if (GNUNET_OK == GNUNET_IDENTITY_decrypt (deserialized_msg,
+                                              msg_len,
+                                              GNUNET_IDENTITY_ego_get_private_key (
+                                                ego),
+                                              deserialized_msg, msg_len))
     {
-      deserialized_msg[res - 1] = '\0';
+      deserialized_msg[msg_len - 1] = '\0';
       fprintf (stdout,
                "%s\n",
                deserialized_msg);
diff --git a/src/identity/identity_api.c b/src/identity/identity_api.c
index 8a7e5c10b..81e318d19 100644
--- a/src/identity/identity_api.c
+++ b/src/identity/identity_api.c
@@ -1174,7 +1174,7 @@ GNUNET_IDENTITY_encrypt_old (const void *block,
 }
 
 
-ssize_t
+enum GNUNET_GenericReturnValue
 GNUNET_IDENTITY_encrypt (const void *pt,
                          size_t pt_size,
                          const struct GNUNET_IDENTITY_PublicKey *pub,
@@ -1187,33 +1187,40 @@ GNUNET_IDENTITY_encrypt (const void *pt,
   unsigned char nonce[crypto_secretbox_NONCEBYTES];
   unsigned char key[crypto_secretbox_KEYBYTES];
 
+  if (ct_size < pt_size + GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Output buffer size for ciphertext too small: Got %lu, want >=%lu\n",
+                ct_size, pt_size + GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES);
+    return GNUNET_SYSERR;
+  }
   switch (ntohl (pub->type))
   {
   case GNUNET_IDENTITY_TYPE_ECDSA:
     if (GNUNET_SYSERR == GNUNET_CRYPTO_ecdsa_fo_kem_encaps (&(pub->ecdsa_key),
                                                             kemc,
                                                             &k))
-      return -1;
+      return GNUNET_SYSERR;
     break;
   case GNUNET_IDENTITY_TYPE_EDDSA:
     if (GNUNET_SYSERR == GNUNET_CRYPTO_eddsa_fo_kem_encaps (&pub->eddsa_key,
                                                             kemc,
                                                             &k))
-      return -1;
+      return GNUNET_SYSERR;
     break;
   default:
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Unsupported key type\n");
-    return -1;
+    return GNUNET_SYSERR;
   }
   memcpy (key, &k, crypto_secretbox_KEYBYTES);
   memcpy (nonce, ((char* ) &k) + crypto_secretbox_KEYBYTES,
           crypto_secretbox_NONCEBYTES);
   crypto_secretbox_easy (encrypted_data, pt, pt_size, nonce, key);
-  return pt_size + crypto_secretbox_MACBYTES + sizeof (*kemc);
+  return GNUNET_OK;
 }
 
 
-ssize_t
+enum GNUNET_GenericReturnValue
 GNUNET_IDENTITY_decrypt (const void *ct_buf,
                          size_t ct_size,
                          const struct GNUNET_IDENTITY_PrivateKey *priv,
@@ -1225,31 +1232,39 @@ GNUNET_IDENTITY_decrypt (const void *ct_buf,
   unsigned char *encrypted_data = (unsigned char*) &kemc[1];
   unsigned char nonce[crypto_secretbox_NONCEBYTES];
   unsigned char key[crypto_secretbox_KEYBYTES];
+  size_t expected_pt_len = ct_size - GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES;
 
+  if (pt_size < expected_pt_len)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Output buffer size for plaintext too small: Got %lu, want >=%lu\n",
+                pt_size, expected_pt_len);
+    return GNUNET_SYSERR;
+  }
   switch (ntohl (priv->type))
   {
   case GNUNET_IDENTITY_TYPE_ECDSA:
     if (GNUNET_SYSERR == GNUNET_CRYPTO_ecdsa_fo_kem_decaps (&(priv->ecdsa_key),
                                                             kemc,
                                                             &k))
-      return -1;
+      return GNUNET_SYSERR;
     break;
   case GNUNET_IDENTITY_TYPE_EDDSA:
     if (GNUNET_SYSERR == GNUNET_CRYPTO_eddsa_fo_kem_decaps (&(priv->eddsa_key),
                                                             kemc,
                                                             &k))
-      return -1;
+      return GNUNET_SYSERR;
     break;
   default:
-    return -1;
+    return GNUNET_SYSERR;
   }
   memcpy (key, &k, crypto_secretbox_KEYBYTES);
   memcpy (nonce, ((char* ) &k) + crypto_secretbox_KEYBYTES,
           crypto_secretbox_NONCEBYTES);
   if (crypto_secretbox_open_easy (pt, encrypted_data, ct_size - sizeof (*kemc),
                                   nonce, key))
-    return -1;
-  return ct_size - sizeof (*kemc) - crypto_secretbox_MACBYTES;
+    return GNUNET_SYSERR;
+  return GNUNET_OK;
 }
 
 
diff --git a/src/identity/test_identity.c b/src/identity/test_identity.c
index b9ec59ab3..92c074981 100644
--- a/src/identity/test_identity.c
+++ b/src/identity/test_identity.c
@@ -259,16 +259,20 @@ create_cb (void *cls,
   CHECK (NULL != pk);
   CHECK (GNUNET_EC_NONE == ec);
   struct GNUNET_IDENTITY_PublicKey pub;
-  unsigned char ct[1024];
-  char pt[strlen ("test") + 1];
-  ssize_t len;
+  size_t pt_len = strlen ("test") + 1;
+  unsigned char ct[pt_len + GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES];
+  char pt[pt_len];
+  enum GNUNET_GenericReturnValue res;
 
   GNUNET_IDENTITY_key_get_public (pk, &pub);
-  len = GNUNET_IDENTITY_encrypt ("test", strlen ("test") + 1, &pub, ct,
-                                 sizeof(ct));
-  CHECK (-1 != len);
-  GNUNET_IDENTITY_decrypt (ct, len, pk, pt, sizeof (pt));
-  CHECK (-1 != len);
+  res = GNUNET_IDENTITY_encrypt ("test", pt_len, &pub, ct,
+                                 pt_len
+                                 + GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES);
+  CHECK (GNUNET_OK == res);
+  res = GNUNET_IDENTITY_decrypt (ct, pt_len
+                                 + GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES,
+                                 pk, pt, pt_len);
+  CHECK (GNUNET_OK == res);
   CHECK (0 == strcmp (pt, "test"));
   op =
     GNUNET_IDENTITY_rename (h, "test-id", "test", &success_rename_cont, NULL);
diff --git a/src/include/gnunet_identity_service.h b/src/include/gnunet_identity_service.h
index db39a92eb..fd0458f62 100644
--- a/src/include/gnunet_identity_service.h
+++ b/src/include/gnunet_identity_service.h
@@ -45,6 +45,7 @@
 #ifndef GNUNET_IDENTITY_SERVICE_H
 #define GNUNET_IDENTITY_SERVICE_H
 
+#include "gnunet_common.h"
 #ifdef __cplusplus
 extern "C" {
 #if 0 /* keep Emacsens' auto-indent happy */
@@ -750,26 +751,26 @@ GNUNET_IDENTITY_decrypt_old (
   const struct GNUNET_CRYPTO_EcdhePublicKey *ecc,
   void *result);
 
+#define GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES (crypto_secretbox_MACBYTES \
+                                                + sizeof (struct \
+                                                          GNUNET_CRYPTO_FoKemC))
+
 /**
  * Encrypt a block with #GNUNET_IDENTITY_PublicKey and derives a
  * #GNUNET_CRYPTO_EcdhePublicKey which is required for decryption
  * using ecdh to derive a symmetric key.
  *
  * Note that the result buffer for the ciphertext must be the length of
- * the message to encrypt plus:
- * - Length of a struct GNUNET_CRYPTO_FoKemC
- * - the authentication tag of libsodium, e.g. crypto_secretbox_NONCEBYTES
+ * the message to encrypt plus #GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES.
  *
  * @param block the block to encrypt
  * @param size the size of the @a block
  * @param pub public key to encrypt for
  * @param result the output parameter in which to store the encrypted result
  *               can be the same or overlap with @c block
- * @returns the size of the encrypted block, -1 for errors.
- *          Due to the use of CFB and therefore an effective stream cipher,
- *          this size should be the same as @c len.
+ * @returns GNUNET_OK on success.
  */
-ssize_t
+enum GNUNET_GenericReturnValue
 GNUNET_IDENTITY_encrypt (const void *block,
                          size_t size,
                          const struct GNUNET_IDENTITY_PublicKey *pub,
@@ -786,11 +787,9 @@ GNUNET_IDENTITY_encrypt (const void *block,
  * @param priv private key to use for ecdh
  * @param result address to store the result at
  *               can be the same or overlap with @c block
- * @return -1 on failure, size of decrypted block on success.
- *         Due to the use of CFB and therefore an effective stream cipher,
- *         this size should be the same as @c size.
+ * @returns GNUNET_OK on success.
  */
-ssize_t
+enum GNUNET_GenericReturnValue
 GNUNET_IDENTITY_decrypt (const void *block,
                          size_t size,
                          const struct GNUNET_IDENTITY_PrivateKey *priv,