1 files changed, 126 insertions, 32 deletions

diff --git a/src/gnsrecord/gnsrecord_serialization.c b/src/gnsrecord/gnsrecord_serialization.c
index 190f62fc2..934d36102 100644
--- a/src/gnsrecord/gnsrecord_serialization.c
+++ b/src/gnsrecord/gnsrecord_serialization.c
@@ -2,20 +2,18 @@
      This file is part of GNUnet.
      Copyright (C) 2009-2013 GNUnet e.V.
 
-     GNUnet is free software; you can redistribute it and/or modify
-     it under the terms of the GNU General Public License as published
-     by the Free Software Foundation; either version 3, or (at your
-     option) any later version.
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-     General Public License for more details.
-
-     You should have received a copy of the GNU General Public License
-     along with GNUnet; see the file COPYING.  If not, write to the
-     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-     Boston, MA 02110-1301, USA.
+     Affero General Public License for more details.
+    
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 /**
@@ -37,6 +35,12 @@
 
 #define LOG(kind,...) GNUNET_log_from (kind, "gnsrecord",__VA_ARGS__)
 
+/**
+ * Set to 1 to check that all records are well-formed (can be converted
+ * to string) during serialization/deserialization.
+ */
+#define DEBUG_GNSRECORDS 0
+
 GNUNET_NETWORK_STRUCT_BEGIN
 
 
@@ -78,22 +82,63 @@ GNUNET_NETWORK_STRUCT_END
  *
  * @param rd_count number of records in the rd array
  * @param rd array of #GNUNET_GNSRECORD_Data with @a rd_count elements
- * @return the required size to serialize
+ * @return the required size to serialize, -1 on error
  */
-size_t
+ssize_t
 GNUNET_GNSRECORD_records_get_size (unsigned int rd_count,
                                    const struct GNUNET_GNSRECORD_Data *rd)
 {
-  unsigned int i;
   size_t ret;
 
+  if (0 == rd_count)
+    return 0;
+  
   ret = sizeof (struct NetworkRecord) * rd_count;
-  for (i=0;i<rd_count;i++)
+  for (unsigned int i=0;i<rd_count;i++)
   {
-    GNUNET_assert ((ret + rd[i].data_size) >= ret);
+    if ((ret + rd[i].data_size) < ret)
+    {
+      GNUNET_break (0);
+      return -1;
+    }
     ret += rd[i].data_size;
+#if DEBUG_GNSRECORDS
+    {
+      char *str;
+
+      str = GNUNET_GNSRECORD_value_to_string (rd[i].record_type,
+                                              rd[i].data,
+                                              rd[i].data_size);
+      if (NULL == str)
+      {
+        GNUNET_break_op (0);
+        return -1;
+      }
+      GNUNET_free (str);
+    }
+#endif
   }
-  return ret;
+  if (ret > SSIZE_MAX)
+  {
+    GNUNET_break (0);
+    return -1;
+  }
+  //Do not pad PKEY
+  if (GNUNET_GNSRECORD_TYPE_PKEY == rd->record_type)
+    return ret;
+  /**
+   * Efficiently round up to the next
+   * power of 2 for padding
+   * https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
+   */
+  ret--;
+  ret |= ret >> 1;
+  ret |= ret >> 2;
+  ret |= ret >> 4;
+  ret |= ret >> 8;
+  ret |= ret >> 16;
+  ret++;
+  return (ssize_t) ret;
 }
 
 
@@ -108,16 +153,15 @@ GNUNET_GNSRECORD_records_get_size (unsigned int rd_count,
  */
 ssize_t
 GNUNET_GNSRECORD_records_serialize (unsigned int rd_count,
-                                    const struct GNUNET_GNSRECORD_Data *rd,
-                                    size_t dest_size,
-                                    char *dest)
+                                    const struct GNUNET_GNSRECORD_Data *rd,
+                                    size_t dest_size,
+                                    char *dest)
 {
   struct NetworkRecord rec;
-  unsigned int i;
   size_t off;
 
   off = 0;
-  for (i=0;i<rd_count;i++)
+  for (unsigned int i=0;i<rd_count;i++)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Serializing record %u with flags %d and expiration time %llu\n",
@@ -128,20 +172,46 @@ GNUNET_GNSRECORD_records_serialize (unsigned int rd_count,
     rec.data_size = htonl ((uint32_t) rd[i].data_size);
     rec.record_type = htonl (rd[i].record_type);
     rec.flags = htonl (rd[i].flags);
-    if (off + sizeof (rec) > dest_size)
+    if ( (off + sizeof (rec) > dest_size) ||
+         (off + sizeof (rec) < off) )
+    {
+      GNUNET_break (0);
       return -1;
+    }
     GNUNET_memcpy (&dest[off],
                    &rec,
                    sizeof (rec));
     off += sizeof (rec);
-    if (off + rd[i].data_size > dest_size)
+    if ( (off + rd[i].data_size > dest_size) ||
+         (off + rd[i].data_size < off) )
+    {
+      GNUNET_break (0);
       return -1;
+    }
     GNUNET_memcpy (&dest[off],
                    rd[i].data,
                    rd[i].data_size);
     off += rd[i].data_size;
+#if DEBUG_GNSRECORDS
+    {
+      char *str;
+
+      str = GNUNET_GNSRECORD_value_to_string (rd[i].record_type,
+                                              rd[i].data,
+                                              rd[i].data_size);
+      if (NULL == str)
+      {
+        GNUNET_break_op (0);
+        return -1;
+      }
+      GNUNET_free (str);
+    }
+#endif
   }
-  return off;
+  memset (&dest[off],
+          0,
+          dest_size-off);
+  return dest_size;
 }
 
 
@@ -156,29 +226,53 @@ GNUNET_GNSRECORD_records_serialize (unsigned int rd_count,
  */
 int
 GNUNET_GNSRECORD_records_deserialize (size_t len,
-                                      const char *src,
-                                      unsigned int rd_count,
-                                      struct GNUNET_GNSRECORD_Data *dest)
+                                      const char *src,
+                                      unsigned int rd_count,
+                                      struct GNUNET_GNSRECORD_Data *dest)
 {
   struct NetworkRecord rec;
-  unsigned int i;
   size_t off;
 
   off = 0;
-  for (i=0;i<rd_count;i++)
+  for (unsigned int i=0;i<rd_count;i++)
   {
-    if (off + sizeof (rec) > len)
+    if ( (off + sizeof (rec) > len) ||
+         (off + sizeof (rec) < off) )
+    {
+      GNUNET_break_op (0);
       return GNUNET_SYSERR;
-    GNUNET_memcpy (&rec, &src[off], sizeof (rec));
+    }
+    GNUNET_memcpy (&rec,
+                   &src[off],
+                   sizeof (rec));
     dest[i].expiration_time = GNUNET_ntohll (rec.expiration_time);
     dest[i].data_size = ntohl ((uint32_t) rec.data_size);
     dest[i].record_type = ntohl (rec.record_type);
     dest[i].flags = ntohl (rec.flags);
     off += sizeof (rec);
-    if (off + dest[i].data_size > len)
+    if ( (off + dest[i].data_size > len) ||
+         (off + dest[i].data_size < off) )
+    {
+      GNUNET_break_op (0);
       return GNUNET_SYSERR;
+    }
     dest[i].data = &src[off];
     off += dest[i].data_size;
+#if GNUNET_EXTRA_LOGGING
+    {
+      char *str;
+
+      str = GNUNET_GNSRECORD_value_to_string (dest[i].record_type,
+                                              dest[i].data,
+                                              dest[i].data_size);
+      if (NULL == str)
+      {
+        GNUNET_break_op (0);
+        return GNUNET_SYSERR;
+      }
+      GNUNET_free (str);
+    }
+#endif
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Deserialized record %u with flags %d and expiration time %llu\n",
          i,