merchant

taler-merchant-httpd_post-private-otp-devices.c (10645B)

---

 /*
   This file is part of TALER
   (C) 2022 Taler Systems SA
 
   TALER 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,
   or (at your option) any later version.
 
   TALER 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 TALER; see the file COPYING.  If not,
   see <http://www.gnu.org/licenses/>
 */
 
 /**
  * @file src/backend/taler-merchant-httpd_post-private-otp-devices.c
  * @brief implementing POST /otp-devices request handling
  * @author Christian Grothoff
  */
 #include "platform.h"
 #include "taler-merchant-httpd_post-private-otp-devices.h"
 #include "taler-merchant-httpd_helper.h"
 #include <taler/taler_json_lib.h>
 #include "merchant-database/insert_otp_device.h"
 #include "merchant-database/get_otp_device.h"
 #include "merchant-database/start.h"
 
 
 /**
  * How often do we retry the simple INSERT database transaction?
  */
 #define MAX_RETRIES 3
 
 
 /**
  * Check if the two otp-devices are identical.
  *
  * @param t1 device to compare
  * @param t2 other device to compare
  * @return true if they are 'equal', false if not or of payto_uris is not an array
  */
 static bool
 otp_devices_equal (const struct TALER_MERCHANTDB_OtpDeviceDetails *t1,
                    const struct TALER_MERCHANTDB_OtpDeviceDetails *t2)
 {
   if ( (0 != strcmp (t1->otp_description,
                      t2->otp_description)) ||
        (t1->otp_ctr != t2->otp_ctr) ||
        (t1->otp_algorithm != t2->otp_algorithm) )
     return false;
   switch (t1->otp_algorithm)
   {
   case TALER_MCA_ECDSA_CHALLENGE:
   case TALER_MCA_EDDSA_CHALLENGE:
     /* the key was generated here and never shown to the client, so
        there is nothing of theirs left to compare */
     return true;
   case TALER_MCA_NONE:
   case TALER_MCA_WITHOUT_PRICE:
   case TALER_MCA_WITH_PRICE:
     return ( (NULL == t1->otp_key) == (NULL == t2->otp_key) ) &&
            ( (NULL == t1->otp_key) ||
              (0 == strcmp (t1->otp_key,
                            t2->otp_key)) );
   }
   GNUNET_break (0);
   return false;
 }
 
 
 enum MHD_Result
 TMH_private_post_otp_devices (const struct TMH_RequestHandler *rh,
                               struct MHD_Connection *connection,
                               struct TMH_HandlerContext *hc)
 {
   struct TMH_MerchantInstance *mi = hc->instance;
   struct TALER_MERCHANTDB_OtpDeviceDetails tp = { 0 };
   const char *device_id;
   enum GNUNET_DB_QueryStatus qs;
   enum MHD_Result ret;
   bool generated_keys = false;
   struct GNUNET_JSON_Specification spec[] = {
     TALER_JSON_spec_slug ("otp_device_id",
                           &device_id),
     GNUNET_JSON_spec_string ("otp_device_description",
                              (const char **) &tp.otp_description),
     TALER_JSON_spec_otp_type ("otp_algorithm",
                               &tp.otp_algorithm),
     GNUNET_JSON_spec_mark_optional (
       GNUNET_JSON_spec_uint64 ("otp_ctr",
                                &tp.otp_ctr),
       NULL),
     GNUNET_JSON_spec_mark_optional (
       TALER_JSON_spec_otp_key ("otp_key",
                                (const char **) &tp.otp_key),
       NULL),
     GNUNET_JSON_spec_end ()
   };
 
   GNUNET_assert (NULL != mi);
   {
     enum GNUNET_GenericReturnValue res;
 
     res = TALER_MHD_parse_json_data (connection,
                                      hc->request_body,
                                      spec);
     if (GNUNET_OK != res)
     {
       GNUNET_break_op (0);
       return (GNUNET_NO == res)
              ? MHD_YES
              : MHD_NO;
     }
   }
 
   switch (tp.otp_algorithm)
   {
   case TALER_MCA_ECDSA_CHALLENGE:
   case TALER_MCA_EDDSA_CHALLENGE:
     if (NULL != tp.otp_key)
     {
       GNUNET_break_op (0);
       ret = TALER_MHD_reply_with_error (connection,
                                         MHD_HTTP_BAD_REQUEST,
                                         TALER_EC_GENERIC_PARAMETER_MALFORMED,
                                         "otp_key");
       goto cleanup;
     }
     break;
   case TALER_MCA_NONE:
   case TALER_MCA_WITHOUT_PRICE:
   case TALER_MCA_WITH_PRICE:
     /* the merchant shares these with the OTP application itself */
     if (NULL == tp.otp_key)
     {
       GNUNET_break_op (0);
       ret = TALER_MHD_reply_with_error (connection,
                                         MHD_HTTP_BAD_REQUEST,
                                         TALER_EC_GENERIC_PARAMETER_MISSING,
                                         "otp_key");
       goto cleanup;
     }
     break;
   }
 
   /* finally, interact with DB until no serialization error */
   for (unsigned int i = 0; i<MAX_RETRIES; i++)
   {
     /* Test if a OTP device of this id is known */
     struct TALER_MERCHANTDB_OtpDeviceDetails etp;
 
     if (GNUNET_OK !=
         TALER_MERCHANTDB_start (TMH_db,
                                 "/post otp-devices"))
     {
       GNUNET_break (0);
       ret = TALER_MHD_reply_with_error (connection,
                                         MHD_HTTP_INTERNAL_SERVER_ERROR,
                                         TALER_EC_GENERIC_DB_START_FAILED,
                                         NULL);
       goto cleanup;
     }
     qs = TALER_MERCHANTDB_get_otp_device (TMH_db,
                                           mi->settings.id,
                                           device_id,
                                           &etp);
     switch (qs)
     {
     case GNUNET_DB_STATUS_HARD_ERROR:
       /* Clean up and fail hard */
       GNUNET_break (0);
       TALER_MERCHANTDB_rollback (TMH_db);
       ret = TALER_MHD_reply_with_error (connection,
                                         MHD_HTTP_INTERNAL_SERVER_ERROR,
                                         TALER_EC_GENERIC_DB_FETCH_FAILED,
                                         NULL);
       goto cleanup;
     case GNUNET_DB_STATUS_SOFT_ERROR:
       /* restart transaction */
       goto retry;
     case GNUNET_DB_STATUS_SUCCESS_NO_RESULTS:
       /* Good, we can proceed! */
       break;
     case GNUNET_DB_STATUS_SUCCESS_ONE_RESULT:
       /* idempotency check: is etp == tp? */
       {
         bool eq;
 
         eq = otp_devices_equal (&tp,
                                 &etp);
         GNUNET_free (etp.otp_description);
         GNUNET_free (etp.otp_key);
         TALER_MERCHANTDB_rollback (TMH_db);
         if (! eq)
           ret = TALER_MHD_reply_with_error (
             connection,
             MHD_HTTP_CONFLICT,
             TALER_EC_MERCHANT_PRIVATE_POST_OTP_DEVICES_CONFLICT_OTP_DEVICE_EXISTS,
             device_id);
         else if (NULL != etp.otp_device_pub)
           /* repeating the request returns the key generated the first
              time; the merchant is shown it once per request, never a
              new one */
           ret = TALER_MHD_REPLY_JSON_PACK (
             connection,
             MHD_HTTP_OK,
             GNUNET_JSON_pack_string ("otp_device_pub",
                                      etp.otp_device_pub));
         else
           ret = TALER_MHD_reply_static (connection,
                                         MHD_HTTP_NO_CONTENT,
                                         NULL,
                                         NULL,
                                         0);
         GNUNET_free (etp.otp_device_pub);
         goto cleanup;
       }
     } /* end switch (qs) */
 
     switch (tp.otp_algorithm)
     {
     case TALER_MCA_ECDSA_CHALLENGE:
     case TALER_MCA_EDDSA_CHALLENGE:
       /* an insert that hit a serialization failure brings us back here
          with the pair of the previous round still in hand */
       if (NULL != tp.otp_device_pub)
         break;
       if (GNUNET_OK !=
           TALER_otp_device_key_create (tp.otp_algorithm,
                                        &tp.otp_key,
                                        &tp.otp_device_pub))
       {
         GNUNET_break (0);
         TALER_MERCHANTDB_rollback (TMH_db);
         ret = TALER_MHD_reply_with_error (
           connection,
           MHD_HTTP_INTERNAL_SERVER_ERROR,
           TALER_EC_GENERIC_INTERNAL_INVARIANT_FAILURE,
           "failed to generate the OTP device key pair");
         goto cleanup;
       }
       generated_keys = true;
       break;
     default:
       /* the TOTP algorithms use the key the merchant supplied */
       break;
     }
 
     qs = TALER_MERCHANTDB_insert_otp_device (TMH_db,
                                              mi->settings.id,
                                              device_id,
                                              &tp);
     if (GNUNET_DB_STATUS_HARD_ERROR == qs)
     {
       TALER_MERCHANTDB_rollback (TMH_db);
       break;
     }
     if (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS == qs)
     {
       /* A concurrent request created an OTP device with the same ID
          between our lookup above and this INSERT. */
       TALER_MERCHANTDB_rollback (TMH_db);
       ret = TALER_MHD_reply_with_error (
         connection,
         MHD_HTTP_CONFLICT,
         TALER_EC_MERCHANT_PRIVATE_POST_OTP_DEVICES_CONFLICT_OTP_DEVICE_EXISTS,
         device_id);
       goto cleanup;
     }
     if (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT == qs)
     {
       qs = TALER_MERCHANTDB_commit (TMH_db);
       if (GNUNET_DB_STATUS_SOFT_ERROR != qs)
         break;
     }
 retry:
     GNUNET_assert (GNUNET_DB_STATUS_SOFT_ERROR == qs);
     TALER_MERCHANTDB_rollback (TMH_db);
   } /* for RETRIES loop */
   if (qs < 0)
   {
     GNUNET_break (0);
     ret = TALER_MHD_reply_with_error (
       connection,
       MHD_HTTP_INTERNAL_SERVER_ERROR,
       (GNUNET_DB_STATUS_SOFT_ERROR == qs)
       ? TALER_EC_GENERIC_DB_SOFT_FAILURE
       : TALER_EC_GENERIC_DB_COMMIT_FAILED,
       NULL);
     goto cleanup;
   }
   if (NULL != tp.otp_device_pub)
   {
     ret = TALER_MHD_REPLY_JSON_PACK (
       connection,
       MHD_HTTP_OK,
       GNUNET_JSON_pack_string ("otp_device_pub",
                                tp.otp_device_pub));
   }
   else
     ret = TALER_MHD_reply_static (connection,
                                   MHD_HTTP_NO_CONTENT,
                                   NULL,
                                   NULL,
                                   0);
 cleanup:
   /* TOTP keys are borrowed from the request JSON.  Only a successfully
      generated challenge key pair belongs to this handler. */
   if (generated_keys)
   {
     GNUNET_free (tp.otp_key);
     GNUNET_free (tp.otp_device_pub);
   }
   GNUNET_JSON_parse_free (spec);
   return ret;
 }
 
 
 /* end of taler-merchant-httpd_post-private-otp-devices.c */