[taler-anastasis] branch master updated: work on challenge selection logic in redux recovery

[gnunet]

This is an automated email from the git hooks/post-receive script.

grothoff pushed a commit to branch master
in repository anastasis.

The following commit(s) were added to refs/heads/master by this push:
     new dcc67e4  work on challenge selection logic in redux recovery
dcc67e4 is described below

commit dcc67e407ee854dcfe95a2251fcb0261f0b3bb56
Author: Christian Grothoff <christian@grothoff.org>
AuthorDate: Sat Feb 20 22:08:49 2021 +0100

    work on challenge selection logic in redux recovery
---
 src/reducer/anastasis_api_recovery_redux.c | 326 ++++++++++++++++++++++-------
 1 file changed, 250 insertions(+), 76 deletions(-)

diff --git a/src/reducer/anastasis_api_recovery_redux.c 
b/src/reducer/anastasis_api_recovery_redux.c
index c31f417..33aa46f 100644
--- a/src/reducer/anastasis_api_recovery_redux.c
+++ b/src/reducer/anastasis_api_recovery_redux.c
@@ -61,6 +61,44 @@ ANASTASIS_recovery_state_to_string_ (enum 
ANASTASIS_RecoveryState rs)
 }
 
 
+static void
+set_state (json_t *state,
+           enum ANASTASIS_RecoveryState new_recovery_state)
+{
+  GNUNET_assert (
+    0 ==
+    json_object_set_new (
+      state,
+      "recovery_state",
+      json_string (ANASTASIS_recovery_state_to_string_ (new_recovery_state))));
+}
+
+
+/**
+ * Returns an initial ANASTASIS recovery state.
+ *
+ * @return NULL on failure
+ */
+json_t *
+ANASTASIS_recovery_start (const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  json_t *initial_state;
+
+  (void) cfg;
+  initial_state = ANASTASIS_REDUX_load_continents_ ();
+  if (NULL == initial_state)
+    return NULL;
+  set_state (initial_state,
+             ANASTASIS_RECOVERY_STATE_CONTINENT_SELECTING);
+  return initial_state;
+}
+
+
+//////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////
+
 /**
  * State for a "challenge answer" CMD.
  */
@@ -133,18 +171,7 @@ struct ChallengeState
 };
 
 
-static void
-set_state (json_t *state,
-           enum ANASTASIS_RecoveryState new_recovery_state)
-{
-  GNUNET_assert (
-    0 ==
-    json_object_set_new (
-      state,
-      "recovery_state",
-      json_string (ANASTASIS_recovery_state_to_string_ (new_recovery_state))));
-}
-
+#if GRAVEYARD
 
 // static
 void
@@ -295,23 +322,130 @@ challenge_start_cb (void *cls,
 }
 
 
+#endif
+// end of graveyard
+//////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////
+
+
 /**
- * Returns an initial ANASTASIS recovery state.
+ * Context for a "select_challenge" operation.
+ */
+struct SelectChallengeContext
+{
+  /**
+   * Handle we returned for cancellation of the operation.
+   */
+  struct ANASTASIS_ReduxAction ra;
+
+  /**
+   * UUID of the challenge selected by the user for solving.
+   */
+  struct ANASTASIS_CRYPTO_TruthUUIDP uuid;
+
+  /**
+   * Overall recovery action.
+   */
+  struct ANASTASIS_Recovery *r;
+
+  /**
+   * Function to call with the next state.
+   */
+  ANASTASIS_ActionCallback cb;
+
+  /**
+   * Closure for @e cb.
+   */
+  void *cb_cls;
+
+  /**
+   * Our state.
+   */
+  json_t *state;
+
+  /**
+   * Our arguments (like answers to the challenge, if already provided).
+   */
+  json_t *args;
+};
+
+
+/**
+ * Cleanup a select challenge context.
  *
- * @return NULL on failure
+ * @param cls a `struct SelectChallengeContext *`
  */
-json_t *
-ANASTASIS_recovery_start (const struct GNUNET_CONFIGURATION_Handle *cfg)
+static void
+sctx_free (void *cls)
 {
-  json_t *initial_state;
+  struct SelectChallengeContext *sctx = cls;
 
-  (void) cfg;
-  initial_state = ANASTASIS_REDUX_load_continents_ ();
-  if (NULL == initial_state)
-    return NULL;
-  set_state (initial_state,
-             ANASTASIS_RECOVERY_STATE_CONTINENT_SELECTING);
-  return initial_state;
+  ANASTASIS_recovery_abort (sctx->r);
+  json_decref (sctx->state);
+  json_decref (sctx->args);
+  GNUNET_free (sctx);
+}
+
+
+/**
+ * This function is called whenever the recovery process ends.
+ * On success, the secret is returned in @a secret.
+ *
+ * @param cls handle for the callback
+ * @param ec error code
+ * @param secret contains the core secret which is passed to the user
+ * @param secret_size defines the size of the core secret
+ */
+static void
+core_secret_cb (void *cls,
+                enum ANASTASIS_RecoveryStatus rc,
+                const void *secret,
+                size_t secret_size)
+{
+  struct SelectChallengeContext *sctx = cls;
+
+  GNUNET_assert (0 ==
+                 json_object_set_new (sctx->state,
+                                      "core_secret",
+                                      GNUNET_JSON_from_data (secret,
+                                                             secret_size)));
+  set_state (sctx->state,
+             ANASTASIS_RECOVERY_STATE_RECOVERY_FINISHED);
+  sctx->cb (sctx->cb_cls,
+            TALER_EC_NONE,
+            sctx->state);
+}
+
+
+/**
+ * Callback which passes back the recovery document and its possible
+ * policies. Also passes back the version of the document for the user
+ * to check.
+ *
+ * We find the selected challenge and try to answer it (or begin
+ * the process).
+ *
+ * @param cls a `struct SelectChallengeContext *`
+ * @param ri recovery information struct which contains the policies
+ */
+static void
+select_challenge_cb (void *cls,
+                     const struct ANASTASIS_RecoveryInformation *ri)
+{
+  struct SelectChallengeContext *sctx = cls;
+
+  // FIXME:
+  // - find challenge by sctx->uuid in ri (if not found, error)
+  // - if secure question, find answer in sctx->args and answer it
+  // - if answer is provided, try to answer it
+  // - if no answer is provided, start challenge without answer
+  // => given answer feedback, report that back to user via state update
+  // => TRICKY: secret recovery success MAY will be reported AFTER
+  //    answer feedback, so need to be prepared for that!
 }
 
 
@@ -321,71 +455,79 @@ select_challenge (json_t *state,
                   ANASTASIS_ActionCallback cb,
                   void *cb_cls)
 {
+  struct SelectChallengeContext *sctx
+    = GNUNET_new (struct SelectChallengeContext);
+  json_t *rd;
+  struct GNUNET_JSON_Specification spec[] = {
+    GNUNET_JSON_spec_fixed_auto ("uuid",
+                                 &sctx->uuid),
+    GNUNET_JSON_spec_end ()
+  };
+
   if (NULL == arguments)
   {
     ANASTASIS_redux_fail_ (cb,
                            cb_cls,
                            TALER_EC_ANASTASIS_REDUCER_INPUT_INVALID,
-                           "select_challenge");
+                           "arguments missing");
     return NULL;
   }
-  json_t *recovery_information;
-  json_t *challenges;
-  struct ChallengeState *cs = GNUNET_new (struct ChallengeState);
-
-  cs->cb = cb;
-  cs->cb_cls = cb_cls;
-  cs->state = state;
-  cs->challenge_index =
-    (unsigned int) json_integer_value (
-      json_object_get (arguments,
-                       "challenge_index"));
-  recovery_information = json_object_get (state,
-                                          "recovery_information");
-  GNUNET_assert (json_is_object (recovery_information));
-  challenges = json_object_get (recovery_information,
-                                "challenges");
-  GNUNET_assert (json_is_array (challenges));
-#if 0
-  const char *method;
-  struct ANASTASIS_Challenge *c;
-  json_t *challenge;
-
-  challenge =
-    json_array_get (challenges,
-                    cs->challenge_index);
-  // FIXME: c->recovery not initialized here! PROBLEM!
-  // FIXME: get challenge via recovery start!
-  c = ANASTASIS_json_to_challenge (challenge);
-
-  method = json_string_value (
-    json_object_get (challenge,
-                     "method"));
-  if (0 == strcmp (method, "question"))
+  if (GNUNET_OK !=
+      GNUNET_JSON_parse (arguments,
+                         spec,
+                         NULL, NULL))
   {
-    cs->mode = 0;
-    cs->answer = json_string_value (
-      json_object_get (arguments,
-                       "answer"));
+    ANASTASIS_redux_fail_ (cb,
+                           cb_cls,
+                           TALER_EC_ANASTASIS_REDUCER_INPUT_INVALID,
+                           "'uuid' missing");
+    return NULL;
   }
-  else
+  rd = json_object_get (state,
+                        "recovery_document");
+  if (NULL == rd)
   {
-    cs->mode = 1;
-    cs->answer = json_string_value (
-      json_object_get (arguments,
-                       "code"));
+    ANASTASIS_redux_fail_ (cb,
+                           cb_cls,
+                           TALER_EC_ANASTASIS_REDUCER_STATE_INVALID,
+                           "select_challenge");
+    return NULL;
   }
-  // CANNOT WORK: derefs c->recovery!
-  ANASTASIS_challenge_start (c,
-                             &challenge_payment_cb,
-                             cs,
-                             &challenge_start_cb,
-                             cs);
-#endif
-  return NULL;
+  sctx->cb = cb;
+  sctx->cb_cls = cb_cls;
+  sctx->state = json_incref (state);
+  sctx->args = json_incref ((json_t*) arguments);
+  sctx->r = ANASTASIS_recovery_deserialize (ANASTASIS_REDUX_ctx_,
+                                            rd,
+                                            &select_challenge_cb,
+                                            sctx,
+                                            &core_secret_cb,
+                                            sctx);
+  if (NULL == sctx->r)
+  {
+    json_decref (sctx->state);
+    json_decref (sctx->args);
+    GNUNET_free (sctx);
+    ANASTASIS_redux_fail_ (cb,
+                           cb_cls,
+                           TALER_EC_ANASTASIS_REDUCER_STATE_INVALID,
+                           "'recovery_document' invalid");
+    return NULL;
+  }
+  sctx->ra.cleanup = &sctx_free;
+  sctx->ra.cleanup_cls = sctx;
+  return &sctx->ra;
 }
 
 
+/////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////
+// 2nd graveyard...
+
+
 static struct ANASTASIS_ReduxAction *
 pay_challenge (json_t *state,
                const json_t *arguments,
@@ -569,6 +711,17 @@ back_challenge_solving (json_t *state,
 }
 
 
+// End of 2nd graveyard...
+/////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////
+
+
 /**
  * Signature of callback function that implements a state transition.
  *
@@ -820,13 +973,13 @@ policy_lookup_cb (void *cls,
   json_t *challenges;
   json_t *recovery_information;
 
-  pd->recovery = NULL;
   if (NULL == ri)
   {
     /* Woopsie, failed hard. */
     GNUNET_CONTAINER_DLL_remove (rss->pd_head,
                                  rss->pd_tail,
                                  pd);
+    ANASTASIS_recovery_abort (pd->recovery);
     GNUNET_free (pd->backend_url);
     GNUNET_free (pd);
     if (NULL != rss->pd_head)
@@ -838,6 +991,7 @@ policy_lookup_cb (void *cls,
              TALER_EC_INVALID, // FIXME: use better code!
              rss->state);
     free_rss (rss);
+    return;
   }
   policies = json_array ();
   GNUNET_assert (NULL != policies);
@@ -902,6 +1056,26 @@ policy_lookup_cb (void *cls,
                  json_object_set_new (rss->state,
                                       "recovery_information",
                                       recovery_information));
+  {
+    json_t *rd;
+
+    rd = ANASTASIS_recovery_serialize (pd->recovery);
+    if (NULL == rd)
+    {
+      GNUNET_break (0);
+      set_state (rss->state,
+                 ANASTASIS_GENERIC_STATE_ERROR);
+      rss->cb (rss->cb_cls,
+               TALER_EC_INVALID, // FIXME: use better code!
+               rss->state);
+      free_rss (rss);
+      return;
+    }
+    GNUNET_assert (0 ==
+                   json_object_set_new (rss->state,
+                                        "recovery_document",
+                                        rd));
+  }
   set_state (rss->state,
              ANASTASIS_RECOVERY_STATE_CHALLENGE_SELECTING);
   rss->cb (rss->cb_cls,

-- 
To stop receiving notification emails like this one, please contact
gnunet@gnunet.org.