begin implementation of gns verify and restore

1 files changed, 335 insertions, 10 deletions

diff --git a/src/escrow/plugin_escrow_gns.c b/src/escrow/plugin_escrow_gns.c
index 3e2025b08..4f9ce64a1 100644
--- a/src/escrow/plugin_escrow_gns.c
+++ b/src/escrow/plugin_escrow_gns.c
@@ -30,12 +30,26 @@
 #include "gnunet_escrow_plugin.h"
 #include "escrow_plugin_helper.h"
 #include "gnunet_namestore_service.h"
+#include "gnunet_gns_service.h"
 #include "gnunet_gnsrecord_lib.h"
 #include "../identity/identity.h"
 #include <sss.h>
 #include <inttypes.h>
 
 
+/* declare this function here, as it is used by other functions above the definition */
+char *
+gns_anchor_data_to_string (struct GNUNET_ESCROW_Handle *h,
+                           struct GNUNET_ESCROW_Anchor *escrowAnchor);
+
+
+/**
+ * Continuation with a private key (used for restore_private_key)
+ */
+typedef void (*PkContinuation) (void *cls,
+                                const struct GNUNET_CRYPTO_EcdsaPrivateKey *pk);
+
+
 struct IdentityOperationEntry
 {
   /**
@@ -123,6 +137,35 @@ struct NamestoreQueueEntry
 };
 
 
+struct GnsLookupRequestEntry
+{
+  /**
+   * DLL
+   */
+  struct GnsLookupRequestEntry *prev;
+
+  /**
+   * DLL
+   */
+  struct GnsLookupRequestEntry *next;
+
+  /**
+   * GNS lookup request
+   */
+  struct GNUNET_GNS_LookupRequest *lr;
+
+  /**
+   * Plugin operation that started the lookup
+   */
+  struct ESCROW_PluginOperationWrapper *plugin_op_wrap;
+
+  /**
+   * index of the respective share
+   */
+  uint8_t i;
+};
+
+
 struct ESCROW_GnsPluginOperation
 {
   /**
@@ -141,6 +184,11 @@ struct ESCROW_GnsPluginOperation
   struct GNUNET_NAMESTORE_Handle *ns_h;
 
   /**
+   * GNS handle
+   */
+  struct GNUNET_GNS_Handle *gns_h;
+
+  /**
    * Continuation for a plugin operation (e.g. used for restore, as this
    * callback has to be called from the IDENTITY service after finishing)
    */
@@ -177,11 +225,36 @@ struct ESCROW_GnsPluginOperation
   uint8_t share_threshold;
 
   /**
+   * Continuation to be called with the restored private key
+   */
+  PkContinuation restore_pk_cont;
+
+  /**
+   * Closure for @a cont
+   */
+  void *restore_pk_cont_cls;
+
+  /**
+   * Array for the restored keyshares
+   */
+  sss_Keyshare *restored_keyshares;
+
+  /**
+   * Identity operation for the create of the restored ego
+   */
+  struct GNUNET_IDENTITY_Operation *id_op;
+
+  /**
    * The ego
    */
   struct GNUNET_IDENTITY_Ego *ego;
 
   /**
+   * The name of the ego
+   */
+  const char *egoName;
+
+  /**
    * Private key of the ego
    */
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *pk;
@@ -189,7 +262,7 @@ struct ESCROW_GnsPluginOperation
   /**
    * User secret string
    */
-  const char *userSecret;
+  char *userSecret;
 
   /**
    * DLL head for identity operations
@@ -220,6 +293,16 @@ struct ESCROW_GnsPluginOperation
    * DLL tail for namestore queue entries
    */
   struct NamestoreQueueEntry *ns_qes_tail;
+
+  /**
+   * DLL head for GNS lookup requests
+   */
+  struct GnsLookupRequestEntry *gns_lrs_head;
+
+  /**
+   * DLL tail for GNS lookup requests
+   */
+  struct GnsLookupRequestEntry *gns_lrs_tail;
 };
 
 /**
@@ -244,6 +327,7 @@ cleanup_plugin_operation (struct ESCROW_PluginOperationWrapper *plugin_op_wrap)
   struct IdentityOperationEntry *curr_id_op, *next_id_op;
   struct PkEntry *curr_pk, *next_pk;
   struct NamestoreQueueEntry *curr_ns_qe, *next_ns_qe;
+  struct GnsLookupRequestEntry *curr_gns_lr, *next_gns_lr;
 
   p_op = (struct ESCROW_GnsPluginOperation*)plugin_op_wrap->plugin_op;
 
@@ -256,6 +340,8 @@ cleanup_plugin_operation (struct ESCROW_PluginOperationWrapper *plugin_op_wrap)
     GNUNET_free (p_op->ego_wrap);
   if (NULL != p_op->verify_wrap)
     GNUNET_free (p_op->verify_wrap);
+  if (NULL != p_op->userSecret)
+    GNUNET_free (p_op->userSecret);
   /* clean up identity operation list */
   for (curr_id_op = p_op->id_ops_head; NULL != curr_id_op; curr_id_op = next_id_op)
   {
@@ -286,11 +372,31 @@ cleanup_plugin_operation (struct ESCROW_PluginOperationWrapper *plugin_op_wrap)
     GNUNET_NAMESTORE_cancel (curr_ns_qe->ns_qe);
     GNUNET_free (curr_ns_qe);
   }
+  /* clean up GNS lookup request list */
+  for (curr_gns_lr = p_op->gns_lrs_head; NULL != curr_gns_lr; curr_gns_lr = next_gns_lr)
+  {
+    next_gns_lr = curr_gns_lr->next;
+    GNUNET_CONTAINER_DLL_remove (p_op->gns_lrs_head,
+                                 p_op->gns_lrs_tail,
+                                 curr_gns_lr);
+    GNUNET_GNS_lookup_cancel (curr_gns_lr->lr);
+    GNUNET_free (curr_gns_lr);
+  }
+  /* free the keyshares array */
+  if (NULL != p_op->restored_keyshares)
+    GNUNET_free (p_op->restored_keyshares);
   /* disconnect from namestore service */
   if (NULL != p_op->ns_h)
     GNUNET_NAMESTORE_disconnect (p_op->ns_h);
+  /* disconnect from GNS service */
+  if (NULL != p_op->gns_h)
+    GNUNET_GNS_disconnect (p_op->gns_h);
+  /* cancel scheduled task */
   if (NULL != p_op->sched_task)
     GNUNET_SCHEDULER_cancel (p_op->sched_task);
+  /* cancel identity operation */
+  if (NULL != p_op->id_op)
+    GNUNET_IDENTITY_cancel (p_op->id_op);
   GNUNET_free (p_op);
   GNUNET_free (plugin_op_wrap);
 }
@@ -848,7 +954,7 @@ start_gns_key_escrow (struct GNUNET_ESCROW_Handle *h,
     return plugin_op_wrap;
   }
   p_op->pk = GNUNET_IDENTITY_ego_get_private_key (ego);
-  p_op->userSecret = userSecret;
+  p_op->userSecret = GNUNET_strdup (userSecret);
 
   if (ESCROW_PLUGIN_STATE_POST_INIT == ph.state)
   {
@@ -864,6 +970,85 @@ start_gns_key_escrow (struct GNUNET_ESCROW_Handle *h,
 }
 
 
+static void
+process_keyshares (struct ESCROW_PluginOperationWrapper *plugin_op_wrap)
+{
+  struct ESCROW_GnsPluginOperation *p_op;
+  struct GNUNET_CRYPTO_EcdsaPrivateKey *pk;
+
+  p_op = (struct ESCROW_GnsPluginOperation*)plugin_op_wrap->plugin_op;
+
+  // TODO: check if enough keyshares have been restored, combine them
+
+  p_op->restore_pk_cont (p_op->restore_pk_cont_cls, pk);
+}
+
+
+static void
+process_gns_lookup_result (void *cls,
+                           uint32_t rd_count,
+                           const struct GNUNET_GNSRECORD_Data *rd)
+{
+  struct GnsLookupRequestEntry *gns_lr = cls;
+  struct ESCROW_PluginOperationWrapper *plugin_op_wrap;
+  struct ESCROW_GnsPluginOperation *p_op;
+  sss_Keyshare keyshare;
+
+  plugin_op_wrap = gns_lr->plugin_op_wrap;
+  p_op = (struct ESCROW_GnsPluginOperation*)plugin_op_wrap->plugin_op;
+
+  // TODO: handle result, store keyshare, check if this was the last keyshare
+  GNUNET_memcpy (p_op->restored_keyshares[gns_lr->i],
+                 keyshare,
+                 sizeof (sss_Keyshare));
+
+  if (1) // TODO: last keyshare?
+    process_keyshares(plugin_op_wrap);
+}
+
+
+static void
+restore_private_key (struct ESCROW_PluginOperationWrapper *plugin_op_wrap,
+                     struct GNUNET_ESCROW_Anchor *escrowAnchor,
+                     PkContinuation cont,
+                     void *cont_cls)
+{
+  struct ESCROW_GnsPluginOperation *p_op;
+  struct GNUNET_CRYPTO_EcdsaPrivateKey *curr_escrow_pk, *ego_pk;
+  struct GNUNET_CRYPTO_EcdsaPublicKey curr_escrow_pub;
+  char *curr_escrow_name;
+  struct GnsLookupRequestEntry *curr_gns_lr;
+
+  p_op = (struct ESCROW_GnsPluginOperation*)plugin_op_wrap->plugin_op;
+
+  p_op->gns_h = GNUNET_GNS_connect (p_op->h->cfg);
+  p_op->restore_pk_cont = cont;
+  p_op->restore_pk_cont_cls = cont_cls;
+  p_op->restored_keyshares = GNUNET_malloc (sizeof (sss_Keyshare) * p_op->shares);
+
+  for (uint8_t i = 0; i < p_op->shares; i++)
+  {
+    curr_escrow_pk = derive_private_key (p_op->ego->name, p_op->userSecret, i);
+    curr_escrow_name = get_escrow_id_name (p_op->ego->name, i);
+
+    curr_gns_lr = GNUNET_new (struct GnsLookupRequestEntry);
+    curr_gns_lr->plugin_op_wrap = plugin_op_wrap;
+    curr_gns_lr->i = i;
+    GNUNET_CRYPTO_ecdsa_key_get_public (curr_escrow_pk, &curr_escrow_pub);
+    curr_gns_lr->lr = GNUNET_GNS_lookup (p_op->gns_h,
+                                         NULL, // TODO: name
+                                         &curr_escrow_pub,
+                                         GNUNET_GNSRECORD_TYPE_ESCROW_KEYSHARE,
+                                         GNUNET_GNS_LO_DEFAULT,
+                                         &process_gns_lookup_result,
+                                         curr_gns_lr);
+    GNUNET_CONTAINER_DLL_insert_tail (p_op->gns_lrs_head,
+                                      p_op->gns_lrs_tail,
+                                      curr_gns_lr);
+  }
+}
+
+
 void
 verify_cont (void *cls)
 {
@@ -877,6 +1062,30 @@ verify_cont (void *cls)
 }
 
 
+static void
+verify_restored_pk (void *cls,
+                    const struct GNUNET_CRYPTO_EcdsaPrivateKey *pk)
+{
+  struct ESCROW_PluginOperationWrapper *plugin_op_wrap = cls;
+  struct ESCROW_GnsPluginOperation *p_op;
+  const struct GNUNET_CRYPTO_EcdsaPrivateKey *ego_pk;
+  char *ego_pk_string;
+  int verificationResult;
+
+  p_op = (struct ESCROW_GnsPluginOperation *)plugin_op_wrap->plugin_op;
+
+  ego_pk = GNUNET_IDENTITY_ego_get_private_key (p_op->ego);
+  ego_pk_string = GNUNET_CRYPTO_ecdsa_private_key_to_string (ego_pk);
+  verificationResult = memcmp (pk,
+                               ego_pk,
+                               sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey))
+                       == 0 ? GNUNET_ESCROW_VALID : GNUNET_ESCROW_INVALID;
+
+  p_op->verify_wrap->verificationResult = verificationResult;
+  verify_cont (plugin_op_wrap);
+}
+
+
 /**
  * Verify the GNS escrow of the key
  * 
@@ -890,7 +1099,7 @@ verify_cont (void *cls)
  */
 struct ESCROW_PluginOperationWrapper *
 verify_gns_key_escrow (struct GNUNET_ESCROW_Handle *h,
-                       const struct GNUNET_IDENTITY_Ego *ego,
+                       struct GNUNET_IDENTITY_Ego *ego,
                        struct GNUNET_ESCROW_Anchor *escrowAnchor,
                        GNUNET_SCHEDULER_TaskCallback cb,
                        uint32_t op_id)
@@ -909,22 +1118,122 @@ verify_gns_key_escrow (struct GNUNET_ESCROW_Handle *h,
   p_op = (struct ESCROW_GnsPluginOperation *)plugin_op_wrap->plugin_op;
   p_op->h = h;
   p_op->cont = cb;
+  p_op->ego = ego;
+  p_op->userSecret = gns_anchor_data_to_string (h, escrowAnchor);
 
   w = GNUNET_new (struct ESCROW_Plugin_VerifyContinuationWrapper);
   w->h = h;
   w->op_id = op_id;
   p_op->verify_wrap = w;
 
-  // TODO: implement
-  w->verificationResult = GNUNET_ESCROW_INVALID;
-  p_op->sched_task = GNUNET_SCHEDULER_add_now (&verify_cont, plugin_op_wrap);
+  if (NULL == ego)
+  {
+    w->verificationResult = GNUNET_ESCROW_INVALID;
+    w->emsg = _ ("ESCROW_verify was called with ego == NULL!\n");
+    p_op->sched_task = GNUNET_SCHEDULER_add_now (&verify_cont, plugin_op_wrap);
+    return plugin_op_wrap;
+  }
+
+  restore_private_key (plugin_op_wrap,
+                       escrowAnchor,
+                       &verify_restored_pk,
+                       plugin_op_wrap);
+
   return plugin_op_wrap;
 }
 
+
 void
 ego_created (const struct GNUNET_IDENTITY_Ego *ego)
 {
-  return;
+  struct ESCROW_PluginOperationWrapper *curr;
+  struct ESCROW_GnsPluginOperation *curr_p_op;
+  char *ego_pk_string, *curr_pk_string;
+
+  ego_pk_string = GNUNET_CRYPTO_ecdsa_private_key_to_string (&ego->pk);
+
+  for (curr = ph.plugin_op_head; NULL != curr; curr = curr->next)
+  {
+    curr_p_op = (struct ESCROW_GnsPluginOperation *)curr->plugin_op;
+    curr_pk_string = GNUNET_CRYPTO_ecdsa_private_key_to_string (curr_p_op->pk);
+    // compare the strings of the private keys
+    if (0 == strcmp (ego_pk_string, curr_pk_string))
+    {
+      // the ego was created due to a restore operation that is not yet finished
+      curr_p_op->ego_wrap->ego = ego;
+      curr_p_op->cont (curr_p_op->ego_wrap);
+
+      cleanup_plugin_operation (curr);
+
+      GNUNET_free (curr_pk_string);
+      GNUNET_free (ego_pk_string);
+      return;
+    }
+    GNUNET_free (curr_pk_string);
+  }
+  GNUNET_free (ego_pk_string);
+}
+
+
+static void
+handle_restore_error (void *cls)
+{
+  struct ESCROW_PluginOperationWrapper *plugin_op_wrap = cls;
+  struct ESCROW_GnsPluginOperation *p_op;
+  
+  p_op = (struct ESCROW_GnsPluginOperation*)plugin_op_wrap->plugin_op;
+  p_op->cont (p_op->ego_wrap);
+
+  cleanup_plugin_operation (plugin_op_wrap);
+}
+
+
+static void
+id_create_finished (void *cls,
+                    const struct GNUNET_CRYPTO_EcdsaPrivateKey *pk,
+                    const char *emsg)
+{
+  struct ESCROW_PluginOperationWrapper *plugin_op_wrap = cls;
+  struct ESCROW_GnsPluginOperation *p_op;
+  
+  p_op = (struct ESCROW_GnsPluginOperation*)plugin_op_wrap->plugin_op;
+
+  if (NULL == pk)
+  {
+    if (NULL != emsg)
+    {
+      fprintf (stderr,
+               "Identity create operation returned with error: %s\n",
+               emsg);
+      p_op->ego_wrap->emsg = _ ("Identity create failed!\n");
+    }
+    else
+      p_op->ego_wrap->emsg = _ ("Failed to create ego!\n");
+    p_op->ego_wrap->ego = NULL;
+    p_op->cont (p_op->ego_wrap);
+    return;
+  }
+
+  /* no error occurred, p_op->restore_cont will be called in ego_created, which
+     is called from ESCROW_list_ego after adding the new ego to our list */
+  p_op->pk = pk;
+}
+
+
+static void
+restore_ego_from_pk (void *cls,
+                     const struct GNUNET_CRYPTO_EcdsaPrivateKey *pk)
+{
+  struct ESCROW_PluginOperationWrapper *plugin_op_wrap = cls;
+  struct ESCROW_GnsPluginOperation *p_op;
+
+  p_op = (struct ESCROW_GnsPluginOperation*)plugin_op_wrap->plugin_op;
+
+  p_op->id_op = GNUNET_IDENTITY_create (identity_handle,
+                                        p_op->egoName,
+                                        pk,
+                                        &id_create_finished,
+                                        plugin_op_wrap);
 }
 
 
@@ -959,14 +1268,30 @@ restore_gns_key_escrow (struct GNUNET_ESCROW_Handle *h,
 
   p_op = (struct ESCROW_GnsPluginOperation *)plugin_op_wrap->plugin_op;
   p_op->h = h;
+  // set cont here (has to be scheduled from the IDENTITY service when it finished)
+  p_op->cont = cb;
+  p_op->egoName = egoName;
+  p_op->userSecret = gns_anchor_data_to_string (h, escrowAnchor);
 
   w = GNUNET_new (struct ESCROW_Plugin_EgoContinuationWrapper);
   w->h = h;
   w->op_id = op_id;
+  p_op->ego_wrap = w;
+
+  if (NULL == escrowAnchor)
+  {
+    w->ego = NULL;
+    w->emsg = _ ("ESCROW_get was called with escrowAnchor == NULL!\n");
+    // schedule handle_restore_error, which calls the callback and cleans up
+    p_op->sched_task = GNUNET_SCHEDULER_add_now (&handle_restore_error, plugin_op_wrap);
+    return plugin_op_wrap;
+  }
+
+  restore_private_key (plugin_op_wrap,
+                       escrowAnchor,
+                       &restore_ego_from_pk,
+                       plugin_op_wrap);
 
-  // TODO: implement
-  w->ego = NULL;
-  p_op->sched_task = GNUNET_SCHEDULER_add_now (cb, w);
   return plugin_op_wrap;
 }