3 files changed, 181 insertions, 35 deletions

diff --git a/src/include/gnunet_common.h b/src/include/gnunet_common.h
index 78aeb3de7..033a68894 100644
--- a/src/include/gnunet_common.h
+++ b/src/include/gnunet_common.h
@@ -1209,7 +1209,10 @@ GNUNET_is_zero_ (const void *a,
  * @param n number of elements in the array
  * @param type name of the struct or union, i.e. pass 'struct Foo'.
  */
-#define GNUNET_new_array(n, type) (type *) GNUNET_malloc ((n) * sizeof(type))
+#define GNUNET_new_array(n, type) ({ \
+    GNUNET_assert (SIZE_MAX / sizeof (type) >= n); \
+    (type *) GNUNET_malloc ((n) * sizeof(type));   \
+  })
 
 /**
  * @ingroup memory
@@ -1284,23 +1287,23 @@ GNUNET_is_zero_ (const void *a,
  * @ingroup memory
  * Wrapper around free. Frees the memory referred to by ptr.
  * Note that it is generally better to free memory that was
- * allocated with #GNUNET_array_grow using #GNUNET_array_grow(mem, size, 0) instead of #GNUNET_free.
+ * allocated with #GNUNET_array_grow using #GNUNET_array_grow(mem, size, 0) instead of #GNUNET_free_nz.
  *
  * @param ptr location where to free the memory. ptr must have
  *     been returned by #GNUNET_strdup, #GNUNET_strndup, #GNUNET_malloc or #GNUNET_array_grow earlier.
  */
-#define GNUNET_free(ptr) GNUNET_xfree_ (ptr, __FILE__, __LINE__)
+#define GNUNET_free_nz(ptr) GNUNET_xfree_ (ptr, __FILE__, __LINE__)
 
 /**
  * @ingroup memory
  * Wrapper around free. Frees the memory referred to by ptr and sets ptr to NULL.
  * Note that it is generally better to free memory that was
- * allocated with #GNUNET_array_grow using #GNUNET_array_grow(mem, size, 0) instead of #GNUNET_freez.
+ * allocated with #GNUNET_array_grow using #GNUNET_array_grow(mem, size, 0) instead of #GNUNET_free.
  *
  * @param ptr location where to free the memory. ptr must have
  *     been returned by #GNUNET_strdup, #GNUNET_strndup, #GNUNET_malloc or #GNUNET_array_grow earlier.
  */
-#define GNUNET_freez(ptr) do { \
+#define GNUNET_free(ptr) do { \
     GNUNET_xfree_ (ptr, __FILE__, __LINE__); \
     ptr = NULL; \
 } while (0)
@@ -1389,22 +1392,58 @@ GNUNET_is_zero_ (const void *a,
 
 /**
  * @ingroup memory
- * Append an element to a list (growing the list by one).
+ * Append an element to an array (growing the array by one).
  *
- * @param arr base-pointer of the vector, may be NULL if size is 0;
+ * @param arr base-pointer of the vector, may be NULL if @a len is 0;
  *        will be updated to reflect the new address. The TYPE of
  *        arr is important since size is the number of elements and
  *        not the size in bytes
- * @param size the number of elements in the existing vector (number
+ * @param len the number of elements in the existing vector (number
  *        of elements to copy over), will be updated with the new
- *        array size
+ *        array length
  * @param element the element that will be appended to the array
  */
-#define GNUNET_array_append(arr, size, element) \
+#define GNUNET_array_append(arr, len, element) \
+  do                                            \
+  {                                             \
+    GNUNET_assert ((len) + 1 > (len)); \
+    GNUNET_array_grow (arr, len, len + 1);    \
+    (arr) [len - 1] = element;                  \
+  } while (0)
+
+
+/**
+ * @ingroup memory
+ * Append @a arr2 to @a arr1 (growing @a arr1
+ * as needed).  The @a arr2 array is left unchanged. Naturally
+ * this function performs a shallow copy. Both arrays must have
+ * the same type for their elements.
+ *
+ * @param arr1 base-pointer of the vector, may be NULL if @a len is 0;
+ *        will be updated to reflect the new address. The TYPE of
+ *        arr is important since size is the number of elements and
+ *        not the size in bytes
+ * @param len1 the number of elements in the existing vector (number
+ *        of elements to copy over), will be updated with the new
+ *        array size
+ * @param arr2 base-pointer a second array to concatenate, may be NULL if @a len2 is 0;
+ *        will be updated to reflect the new address. The TYPE of
+ *        arr is important since size is the number of elements and
+ *        not the size in bytes
+ * @param len the number of elements in the existing vector (number
+ *        of elements to copy over), will be updated with the new
+ *        array size
+
+ */
+#define GNUNET_array_concatenate(arr1, len1, arr2, len2)   \
   do                                            \
   {                                             \
-    GNUNET_array_grow (arr, size, size + 1);    \
-    (arr) [size - 1] = element;                  \
+    const typeof (*arr2) * _a1 = (arr1);  \
+    const typeof (*arr1) * _a2 = (arr2);  \
+    GNUNET_assert ((len1) + (len2) >= (len1));                    \
+    GNUNET_assert (SIZE_MAX / sizeof (*_a1) >= ((len1) + (len2))); \
+    GNUNET_array_grow (arr1, len1, (len1) + (len2));            \
+    memcpy (&(arr1) [(len1) - (len2)], _a2, (len2) * sizeof (*arr1));    \
   } while (0)
 
 /**
diff --git a/src/include/gnunet_json_lib.h b/src/include/gnunet_json_lib.h
index f6cabd589..27996f18d 100644
--- a/src/include/gnunet_json_lib.h
+++ b/src/include/gnunet_json_lib.h
@@ -219,6 +219,17 @@ GNUNET_JSON_spec_json (const char *name, json_t **jsonp);
 
 
 /**
+ * boolean.
+ *
+ * @param name name of the JSON field
+ * @param[out] b where to store the boolean found under @a name
+ */
+struct GNUNET_JSON_Specification
+GNUNET_JSON_spec_bool (const char *name,
+                       bool *b);
+
+
+/**
  * 8-bit integer.
  *
  * @param name name of the JSON field
diff --git a/src/include/gnunet_revocation_service.h b/src/include/gnunet_revocation_service.h
index 7222cedc1..9a8918b43 100644
--- a/src/include/gnunet_revocation_service.h
+++ b/src/include/gnunet_revocation_service.h
@@ -51,6 +51,73 @@ extern "C"
 #define GNUNET_REVOCATION_VERSION 0x00000000
 
 /**
+ * The proof-of-work narrowing factor.
+ * The number of PoWs that are calculates as part of revocation.
+ */
+#define POW_COUNT 32
+
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+struct GNUNET_REVOCATION_Pow
+{
+  /**
+   * The timestamp of the revocation
+   */
+  struct GNUNET_TIME_AbsoluteNBO timestamp;
+
+  /**
+   * The TTL of this revocation (purely informational)
+   */
+  struct GNUNET_TIME_RelativeNBO ttl;
+
+  /**
+   * The PoWs
+   */
+  uint64_t pow[POW_COUNT] GNUNET_PACKED;
+
+  /**
+   * The signature
+   */
+  struct GNUNET_CRYPTO_EcdsaSignature signature;
+
+  /**
+   * The revoked public key
+   */
+  struct GNUNET_CRYPTO_EcdsaPublicKey key;
+};
+
+
+/**
+ * The signature object we use for the PoW
+ */
+struct GNUNET_REVOCATION_SignaturePurpose
+{
+  /**
+   * The signature purpose
+   */
+  struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
+
+  /**
+   * The revoked public key
+   */
+  struct GNUNET_CRYPTO_EcdsaPublicKey key;
+
+  /**
+   * The timestamp of the revocation
+   */
+  struct GNUNET_TIME_AbsoluteNBO timestamp;
+};
+
+GNUNET_NETWORK_STRUCT_END
+
+
+/**
+ * Handle to a running proof-of-work calculation.
+ */
+struct GNUNET_REVOCATION_PowCalculationHandle;
+
+/**
  * Handle for the key revocation query.
  */
 struct GNUNET_REVOCATION_Query;
@@ -65,7 +132,8 @@ struct GNUNET_REVOCATION_Query;
  *
  */
 typedef void (*GNUNET_REVOCATION_Callback) (void *cls,
-                                            int is_valid);
+                                            enum GNUNET_GenericReturnValue
+                                            is_valid);
 
 
 /**
@@ -102,12 +170,9 @@ struct GNUNET_REVOCATION_Handle;
  * Perform key revocation.
  *
  * @param cfg the configuration to use
- * @param key public key of the key to revoke
- * @param sig signature to use on the revocation (should have been
- *            created using #GNUNET_REVOCATION_sign_revocation).
  * @param pow proof of work to use (should have been created by
- *            iteratively calling #GNUNET_REVOCATION_check_pow)
- * @param func funtion to call with the result of the check
+ *            iteratively calling #GNUNET_REVOCATION_pow_round)
+ * @param func function to call with the result of the check
  *             (called with `is_valid` being #GNUNET_NO if
  *              the revocation worked).
  * @param func_cls closure to pass to @a func
@@ -115,9 +180,7 @@ struct GNUNET_REVOCATION_Handle;
  */
 struct GNUNET_REVOCATION_Handle *
 GNUNET_REVOCATION_revoke (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                          const struct GNUNET_CRYPTO_EcdsaPublicKey *key,
-                          const struct GNUNET_CRYPTO_EcdsaSignature *sig,
-                          uint64_t pow,
+                          const struct GNUNET_REVOCATION_Pow *pow,
                           GNUNET_REVOCATION_Callback func, void *func_cls);
 
 
@@ -131,31 +194,64 @@ GNUNET_REVOCATION_revoke_cancel (struct GNUNET_REVOCATION_Handle *h);
 
 
 /**
- * Check if the given proof-of-work value
- * would be acceptable for revoking the given key.
+ * Check if the given proof-of-work is valid.
  *
- * @param key key to check for
- * @param pow proof of work value
+ * @param pow proof of work
  * @param matching_bits how many bits must match (configuration)
+ * @param epoch_duration length of single epoch in configuration
  * @return #GNUNET_YES if the @a pow is acceptable, #GNUNET_NO if not
  */
-int
-GNUNET_REVOCATION_check_pow (const struct GNUNET_CRYPTO_EcdsaPublicKey *key,
-                             uint64_t pow,
-                             unsigned int matching_bits);
+enum GNUNET_GenericReturnValue
+GNUNET_REVOCATION_check_pow (const struct GNUNET_REVOCATION_Pow *pow,
+                             unsigned int matching_bits,
+                             struct GNUNET_TIME_Relative epoch_duration);
 
 
 /**
- * Create a revocation signature.
+ * Initializes a fresh PoW computation.
  *
- * @param key private key of the key to revoke
- * @param sig where to write the revocation signature
+ * @param key the key to calculate the PoW for.
+ * @param pow the pow object to work with in the calculation.
  */
 void
-GNUNET_REVOCATION_sign_revocation (const struct
-                                   GNUNET_CRYPTO_EcdsaPrivateKey *key,
-                                   struct GNUNET_CRYPTO_EcdsaSignature *sig);
+GNUNET_REVOCATION_pow_init (const struct GNUNET_CRYPTO_EcdsaPrivateKey *key,
+                            struct GNUNET_REVOCATION_Pow *pow);
+
+
+/**
+ * Starts a proof-of-work calculation given the pow object as well as
+ * target epochs and difficulty.
+ *
+ * @param pow the PoW to based calculations on.
+ * @param epochs the number of epochs for which the PoW must be valid.
+ * @param difficulty the base difficulty of the PoW.
+ * @return a handle for use in PoW rounds
+ */
+struct GNUNET_REVOCATION_PowCalculationHandle*
+GNUNET_REVOCATION_pow_start (struct GNUNET_REVOCATION_Pow *pow,
+                             int epochs,
+                             unsigned int difficulty);
+
 
+/**
+ * Calculate a single round in the key revocation PoW.
+ *
+ * @param pc handle to the PoW, initially called with NULL.
+ * @return GNUNET_YES if the @a pow is acceptable, GNUNET_NO if not
+ */
+enum GNUNET_GenericReturnValue
+GNUNET_REVOCATION_pow_round (struct GNUNET_REVOCATION_PowCalculationHandle *pc);
+
+
+/**
+ * Stop a PoW calculation
+ *
+ * @param pc the calculation to clean up
+ * @return #GNUNET_YES if pow valid, #GNUNET_NO if pow was set but is not
+ * valid
+ */
+void
+GNUNET_REVOCATION_pow_stop (struct GNUNET_REVOCATION_PowCalculationHandle *pc);
 
 #if 0                           /* keep Emacsens' auto-indent happy */
 {