12 files changed, 106 insertions, 213 deletions

diff --git a/contrib/gana b/contrib/gana
-Subproject d505fecdf8f1339f4115f10f1ae236da7cfea0e
+Subproject 9eddc2cf7b65bb43d285c75ef22fd9bc9cc7020
diff --git a/contrib/handbook b/contrib/handbook
-Subproject 7d66dc1695829f2511f8e8ecc227a64d73d1562
+Subproject 5c20e0aaa95c7cebc225d02231221d18fdcbdb5
diff --git a/src/cli/reclaim/gnunet-reclaim.c b/src/cli/reclaim/gnunet-reclaim.c
index 901dd6bf6..63152d478 100644
--- a/src/cli/reclaim/gnunet-reclaim.c
+++ b/src/cli/reclaim/gnunet-reclaim.c
@@ -155,11 +155,6 @@ static struct GNUNET_RECLAIM_TicketIterator *ticket_iterator;
 static const struct GNUNET_CRYPTO_PrivateKey *pkey;
 
 /**
- * rp public key
- */
-static struct GNUNET_CRYPTO_PublicKey rp_key;
-
-/**
  * Ticket to consume
  */
 static struct GNUNET_RECLAIM_Ticket ticket;
@@ -342,20 +337,14 @@ ticket_iter_fin (void *cls)
 static void
 ticket_iter (void *cls, const struct GNUNET_RECLAIM_Ticket *ticket)
 {
-  char *aud;
   char *ref;
   char *tkt;
 
-  aud =
-    GNUNET_STRINGS_data_to_string_alloc (&ticket->audience,
-                                         sizeof(struct
-                                                GNUNET_CRYPTO_PublicKey));
   ref = GNUNET_STRINGS_data_to_string_alloc (&ticket->rnd, sizeof(ticket->rnd));
   tkt =
     GNUNET_STRINGS_data_to_string_alloc (ticket,
                                          sizeof(struct GNUNET_RECLAIM_Ticket));
-  fprintf (stdout, "Ticket: %s | ID: %s | Audience: %s\n", tkt, ref, aud);
-  GNUNET_free (aud);
+  fprintf (stdout, "Ticket: %s | ID: %s | Audience: %s\n", tkt, ref, ticket->rp_uri);
   GNUNET_free (ref);
   GNUNET_free (tkt);
   GNUNET_RECLAIM_ticket_iteration_next (ticket_iterator);
@@ -447,7 +436,6 @@ iter_finished (void *cls)
         fprintf (stdout, "No such attribute ``%s''\n", attr_str);
         break;
       }
-      
       attr_str = strtok (NULL, ",");
     }
     GNUNET_free (attrs_tmp);
@@ -456,10 +444,9 @@ iter_finished (void *cls)
       GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
       return;
     }
-
     reclaim_op = GNUNET_RECLAIM_ticket_issue (reclaim_handle,
                                               pkey,
-                                              &rp_key,
+                                              rp,
                                               attr_list,
                                               &ticket_issue_cb,
                                               NULL);
@@ -468,7 +455,6 @@ iter_finished (void *cls)
   if (consume_ticket)
   {
     reclaim_op = GNUNET_RECLAIM_ticket_consume (reclaim_handle,
-                                                pkey,
                                                 &ticket,
                                                 &process_attrs,
                                                 NULL);
@@ -767,14 +753,6 @@ start_process ()
     return;
   }
 
-  if ((NULL != rp) &&
-      (GNUNET_OK !=
-       GNUNET_CRYPTO_public_key_from_string (rp, &rp_key)) )
-  {
-    fprintf (stderr, "%s is not a public key!\n", rp);
-    cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
-    return;
-  }
   if (NULL != consume_ticket)
     GNUNET_STRINGS_string_to_data (consume_ticket,
                                    strlen (consume_ticket),
diff --git a/src/include/gnunet_reclaim_service.h b/src/include/gnunet_reclaim_service.h
index a8ab8776e..08f3f60a3 100644
--- a/src/include/gnunet_reclaim_service.h
+++ b/src/include/gnunet_reclaim_service.h
@@ -49,7 +49,7 @@ extern "C" {
 /**
  * Version number of the re:claimID API.
  */
-#define GNUNET_RECLAIM_VERSION 0x00000001
+#define GNUNET_RECLAIM_VERSION 0x00000002
 
 /**
  * Opaque handle to access the service.
@@ -62,6 +62,9 @@ struct GNUNET_RECLAIM_Handle;
  */
 struct GNUNET_RECLAIM_Operation;
 
+#define GNUNET_RECLAIM_TICKET_RP_URI_MAX_LEN 256
+
+#define GNUNET_RECLAIM_TICKET_RP_URI_URN_PREFIX "urn:gns:"
 
 /**
  * The authorization ticket. This ticket is meant to be transferred
@@ -77,14 +80,17 @@ struct GNUNET_RECLAIM_Ticket
   struct GNUNET_CRYPTO_PublicKey identity;
 
   /**
-   * The ticket audience (= relying party)
+   * The ticket random identifier
    */
-  struct GNUNET_CRYPTO_PublicKey audience;
+  struct GNUNET_RECLAIM_Identifier rnd;
+
 
   /**
-   * The ticket random identifier
+   * Followed by the ticket audience (= relying party) URI.
+   * 0-terminated string.
+   * Example: "urn:gns:000G002B4RF1XPBXDPGZA0PT16BHQCS427YQK4NC84KZMK7TK8C2Z5GMK8"
    */
-  struct GNUNET_RECLAIM_Identifier rnd;
+  char rp_uri[GNUNET_RECLAIM_TICKET_RP_URI_MAX_LEN];
 };
 
 
@@ -376,7 +382,7 @@ GNUNET_RECLAIM_get_credentials_stop (
  *
  * @param h the identity provider to use
  * @param iss the issuing identity (= the user)
- * @param rp the subject of the ticket (= the relying party)
+ * @param rp the subject of the ticket (= the relying party) see #GNUNET_RECLAIM_Ticket
  * @param attrs the attributes that the relying party is given access to
  * @param cb the callback
  * @param cb_cls the callback closure
@@ -386,7 +392,7 @@ struct GNUNET_RECLAIM_Operation *
 GNUNET_RECLAIM_ticket_issue (
   struct GNUNET_RECLAIM_Handle *h,
   const struct GNUNET_CRYPTO_PrivateKey *iss,
-  const struct GNUNET_CRYPTO_PublicKey *rp,
+  const char *rp,
   const struct GNUNET_RECLAIM_AttributeList *attrs,
   GNUNET_RECLAIM_IssueTicketCallback cb, void *cb_cls);
 
@@ -417,8 +423,6 @@ GNUNET_RECLAIM_ticket_revoke (
  * information from the issuer
  *
  * @param h the identity provider to use
- * @param identity the identity that is the subject of the issued ticket (the
- * relying party)
  * @param ticket the issued ticket to consume
  * @param cb the callback to call
  * @param cb_cls the callback closure
@@ -427,7 +431,6 @@ GNUNET_RECLAIM_ticket_revoke (
 struct GNUNET_RECLAIM_Operation *
 GNUNET_RECLAIM_ticket_consume (
   struct GNUNET_RECLAIM_Handle *h,
-  const struct GNUNET_CRYPTO_PrivateKey *identity,
   const struct GNUNET_RECLAIM_Ticket *ticket,
   GNUNET_RECLAIM_AttributeTicketResult cb, void *cb_cls);
 
diff --git a/src/service/messenger/messenger_api.c b/src/service/messenger/messenger_api.c
index ecdd1feb2..0778d3a48 100644
--- a/src/service/messenger/messenger_api.c
+++ b/src/service/messenger/messenger_api.c
@@ -752,7 +752,7 @@ dequeue_messages_from_room (struct GNUNET_MESSENGER_Room *room)
     else
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                   "Sending transcript aborted: Encryption failed!\n");
-    
+
     destroy_message (transcript);
   } while (message);
 
@@ -960,7 +960,8 @@ iterate_find_room (void *cls,
   if ((find->counter > 0) && ((! find->contact) || (GNUNET_YES ==
                                                     find_room_member (room,
                                                                       find->
-                                                                      contact))))
+                                                                      contact)))
+      )
   {
     find->counter--;
 
@@ -1229,7 +1230,8 @@ GNUNET_MESSENGER_iterate_members (struct GNUNET_MESSENGER_Room *room,
 
 struct GNUNET_MESSENGER_CheckTicket
 {
-  const struct GNUNET_CRYPTO_PublicKey *audience;
+  const char *check_rp;
+  struct GNUNET_CRYPTO_PublicKey key;
   enum GNUNET_GenericReturnValue result;
 };
 
@@ -1240,13 +1242,19 @@ check_ticket_audience (void *cls,
                        const struct GNUNET_MESSENGER_Contact *contact)
 {
   struct GNUNET_MESSENGER_CheckTicket *check = cls;
-
   const struct GNUNET_CRYPTO_PublicKey *key;
-  key = get_non_anonymous_key (get_contact_key (contact));
+  char check_rp[GNUNET_RECLAIM_TICKET_RP_URI_MAX_LEN];
+  char *key_str;
 
-  if ((key) && (0 == GNUNET_memcmp (key, check->audience)))
+  key = get_non_anonymous_key (get_contact_key (contact));
+  key_str = GNUNET_CRYPTO_public_key_to_string(key);
+  GNUNET_snprintf (check_rp, GNUNET_RECLAIM_TICKET_RP_URI_MAX_LEN, "%s%s",
+                   GNUNET_RECLAIM_TICKET_RP_URI_URN_PREFIX, key_str);
+  GNUNET_free (key_str);
+  if ((key) && (0 == strcmp (check_rp, check->check_rp)))
   {
     check->result = GNUNET_YES;
+    check->key = *key;
     return GNUNET_NO;
   }
 
@@ -1272,7 +1280,7 @@ GNUNET_MESSENGER_send_ticket (struct GNUNET_MESSENGER_Room *room,
   }
 
   struct GNUNET_MESSENGER_CheckTicket check;
-  check.audience = &(ticket->audience);
+  check.check_rp = ticket->rp_uri;
   check.result = GNUNET_NO;
 
   const int members = iterate_room_members (
@@ -1298,5 +1306,5 @@ GNUNET_MESSENGER_send_ticket (struct GNUNET_MESSENGER_Room *room,
     return;
   }
 
-  send_message_to_room_with_key (room, message, &(ticket->audience));
+  send_message_to_room_with_key (room, message, &check.key);
 }
diff --git a/src/service/reclaim/gnunet-service-reclaim.c b/src/service/reclaim/gnunet-service-reclaim.c
index 6edd93341..368e39ec3 100644
--- a/src/service/reclaim/gnunet-service-reclaim.c
+++ b/src/service/reclaim/gnunet-service-reclaim.c
@@ -739,14 +739,14 @@ check_issue_ticket_message (void *cls, const struct IssueTicketMessage *im)
   uint16_t size;
   size_t attrs_len;
   size_t key_len;
-  size_t pkey_len;
+  size_t rp_len;
 
   size = ntohs (im->header.size);
   attrs_len = ntohs (im->attr_len);
   key_len = ntohs (im->key_len);
-  pkey_len = ntohs (im->pkey_len);
-  if (size != attrs_len + key_len + pkey_len + sizeof(struct
-                                                      IssueTicketMessage))
+  rp_len = ntohs (im->rp_uri_len);
+  if (size != attrs_len + key_len + rp_len + sizeof(struct
+                                                    IssueTicketMessage))
   {
     GNUNET_break (0);
     return GNUNET_SYSERR;
@@ -769,10 +769,10 @@ handle_issue_ticket_message (void *cls, const struct IssueTicketMessage *im)
   struct GNUNET_RECLAIM_AttributeList *attrs;
   struct GNUNET_RECLAIM_AttributeListEntry *le;
   struct GNUNET_CRYPTO_PrivateKey identity;
-  struct GNUNET_CRYPTO_PublicKey rp;
+  const char *rp;
   size_t attrs_len;
   size_t key_len;
-  size_t pkey_len;
+  size_t rp_len;
   size_t read;
   char *buf;
 
@@ -790,18 +790,9 @@ handle_issue_ticket_message (void *cls, const struct IssueTicketMessage *im)
     return;
   }
   buf += read;
-  pkey_len = ntohs (im->pkey_len);
-  if ((GNUNET_SYSERR ==
-       GNUNET_CRYPTO_read_public_key_from_buffer (buf, pkey_len,
-                                                  &rp, &read)) ||
-      (read != pkey_len))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Failed to read public key\n");
-    GNUNET_SERVICE_client_drop (idp->client);
-    return;
-  }
-  buf += read;
+  rp_len = ntohs (im->rp_uri_len);
+  rp = buf;
+  buf += rp_len;
   tio = GNUNET_new (struct TicketIssueOperation);
   attrs_len = ntohs (im->attr_len);
   attrs = GNUNET_RECLAIM_attribute_list_deserialize (buf,
@@ -815,7 +806,7 @@ handle_issue_ticket_message (void *cls, const struct IssueTicketMessage *im)
   GNUNET_CONTAINER_DLL_insert (idp->issue_op_head, idp->issue_op_tail, tio);
   RECLAIM_TICKETS_issue (&identity,
                          attrs,
-                         &rp,
+                         rp,
                          &issue_ticket_result_cb,
                          tio);
   GNUNET_SERVICE_client_continue (idp->client);
@@ -1027,27 +1018,12 @@ handle_consume_ticket_message (void *cls, const struct ConsumeTicketMessage *cm)
 {
   struct ConsumeTicketOperation *cop;
   struct IdpClient *idp = cls;
-  struct GNUNET_CRYPTO_PrivateKey identity;
   struct GNUNET_RECLAIM_Ticket ticket;
-  size_t key_len;
   size_t tkt_len;
   size_t read;
   char *buf;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received CONSUME_TICKET message\n");
-  key_len = ntohs (cm->key_len);
-  buf = (char *) &cm[1];
-  if ((GNUNET_SYSERR ==
-       GNUNET_CRYPTO_read_private_key_from_buffer (buf, key_len,
-                                                   &identity, &read)) ||
-      (read != key_len))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Failed to read private key\n");
-    GNUNET_SERVICE_client_drop (idp->client);
-    return;
-  }
-  buf += read;
   tkt_len = ntohs (cm->tkt_len);
   if ((GNUNET_SYSERR ==
        GNUNET_RECLAIM_read_ticket_from_buffer (buf, tkt_len,
@@ -1063,7 +1039,7 @@ handle_consume_ticket_message (void *cls, const struct ConsumeTicketMessage *cm)
   cop->r_id = ntohl (cm->id);
   cop->client = idp;
   cop->ch
-    = RECLAIM_TICKETS_consume (&identity, &ticket, &consume_result_cb,
+    = RECLAIM_TICKETS_consume (&ticket, &consume_result_cb,
                                cop);
   GNUNET_CONTAINER_DLL_insert (idp->consume_op_head, idp->consume_op_tail, cop);
   GNUNET_SERVICE_client_continue (idp->client);
diff --git a/src/service/reclaim/gnunet-service-reclaim_tickets.c b/src/service/reclaim/gnunet-service-reclaim_tickets.c
index acd2b6859..637fcfcce 100644
--- a/src/service/reclaim/gnunet-service-reclaim_tickets.c
+++ b/src/service/reclaim/gnunet-service-reclaim_tickets.c
@@ -25,6 +25,7 @@
  *
  */
 #include "gnunet-service-reclaim_tickets.h"
+#include <string.h>
 
 
 /**
@@ -83,16 +84,6 @@ struct RECLAIM_TICKETS_ConsumeHandle
   struct GNUNET_GNS_LookupRequest *lookup_request;
 
   /**
-   * Audience Key
-   */
-  struct GNUNET_CRYPTO_PrivateKey identity;
-
-  /**
-   * Audience Key
-   */
-  struct GNUNET_CRYPTO_PublicKey identity_pub;
-
-  /**
    * Lookup DLL
    */
   struct ParallelLookup *parallel_lookups_head;
@@ -1178,8 +1169,7 @@ lookup_authz_cb (void *cls,
  * @return handle to the operation
  */
 struct RECLAIM_TICKETS_ConsumeHandle *
-RECLAIM_TICKETS_consume (const struct GNUNET_CRYPTO_PrivateKey *id,
-                         const struct GNUNET_RECLAIM_Ticket *ticket,
+RECLAIM_TICKETS_consume (const struct GNUNET_RECLAIM_Ticket *ticket,
                          RECLAIM_TICKETS_ConsumeCallback cb,
                          void *cb_cls)
 {
@@ -1188,8 +1178,6 @@ RECLAIM_TICKETS_consume (const struct GNUNET_CRYPTO_PrivateKey *id,
 
   cth = GNUNET_new (struct RECLAIM_TICKETS_ConsumeHandle);
 
-  cth->identity = *id;
-  GNUNET_CRYPTO_key_get_public (&cth->identity, &cth->identity_pub);
   cth->attrs = GNUNET_new (struct GNUNET_RECLAIM_AttributeList);
   cth->presentations = GNUNET_new (struct GNUNET_RECLAIM_PresentationList);
   cth->ticket = *ticket;
@@ -1513,9 +1501,8 @@ filter_tickets_cb (void *cls,
       // cmp audience
       // FIXME this is ugly, GNUNET_CRYPTO_PublicKey cannot be compared
       // like this
-      if (0 == memcmp (&tih->ticket.audience,
-                       &ticket.audience,
-                       sizeof(struct GNUNET_CRYPTO_PublicKey)))
+      if (0 == strcmp (tih->ticket.rp_uri,
+                       ticket.rp_uri))
       {
         tih->ticket = ticket;
         ticket_found = GNUNET_YES;
@@ -1543,7 +1530,8 @@ filter_tickets_cb (void *cls,
         cred = GNUNET_RECLAIM_credential_deserialize (rd[i].data,
                                                       rd[i].data_size);
         if (GNUNET_YES != GNUNET_RECLAIM_id_is_equal (&cred->id,
-                                                      &le->attribute->credential))
+                                                      &le->attribute->credential
+                                                      ))
         {
           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                       "No match.\n");
@@ -1576,7 +1564,8 @@ filter_tickets_cb (void *cls,
       for (le = tih->attrs->list_head; NULL != le; le = le->next)
       {
         presentation = GNUNET_RECLAIM_presentation_deserialize (rd[i].data,
-                                                                rd[i].data_size);
+                                                                rd[i].data_size)
+        ;
         if (NULL == presentation)
         {
           GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
@@ -1650,7 +1639,7 @@ filter_tickets_finished_cb (void *cls)
 void
 RECLAIM_TICKETS_issue (const struct GNUNET_CRYPTO_PrivateKey *identity,
                        const struct GNUNET_RECLAIM_AttributeList *attrs,
-                       const struct GNUNET_CRYPTO_PublicKey *audience,
+                       const char *rp,
                        RECLAIM_TICKETS_TicketResult cb,
                        void *cb_cls)
 {
@@ -1662,7 +1651,7 @@ RECLAIM_TICKETS_issue (const struct GNUNET_CRYPTO_PrivateKey *identity,
   tih->attrs = GNUNET_RECLAIM_attribute_list_dup (attrs);
   tih->presentations = GNUNET_new (struct GNUNET_RECLAIM_PresentationList);
   tih->identity = *identity;
-  tih->ticket.audience = *audience;
+  memcpy (tih->ticket.rp_uri, rp, strlen (rp) + 1);
 
   // First check whether the ticket has already been issued
   tih->ns_it =
diff --git a/src/service/reclaim/gnunet-service-reclaim_tickets.h b/src/service/reclaim/gnunet-service-reclaim_tickets.h
index 0ec232f49..93e48628a 100644
--- a/src/service/reclaim/gnunet-service-reclaim_tickets.h
+++ b/src/service/reclaim/gnunet-service-reclaim_tickets.h
@@ -186,15 +186,13 @@ RECLAIM_TICKETS_revoke_cancel (struct RECLAIM_TICKETS_RevokeHandle *rh);
  * We first looking attribute references under the label
  * ticket.rnd in GNS.
  *
- * @param id the audience of the ticket
  * @param ticket the ticket to consume
  * @param cb callback to call with attributes of ticket
  * @param cb_cls callback closure
  * @return handle to the operation
  */
 struct RECLAIM_TICKETS_ConsumeHandle *
-RECLAIM_TICKETS_consume (const struct GNUNET_CRYPTO_PrivateKey *id,
-                         const struct GNUNET_RECLAIM_Ticket *ticket,
+RECLAIM_TICKETS_consume (const struct GNUNET_RECLAIM_Ticket *ticket,
                          RECLAIM_TICKETS_ConsumeCallback cb,
                          void *cb_cls);
 
@@ -214,7 +212,7 @@ RECLAIM_TICKETS_consume_cancel (struct RECLAIM_TICKETS_ConsumeHandle *cth);
  *
  * @param identity the issuer
  * @param attrs the attributes to share
- * @param audience the audience to share the attributes with
+ * @param rp the RP URI
  * @param cb the callback to call with the ticket result
  * @param cb_cls the callback closure
  * FIXME: Return handle??
@@ -222,7 +220,7 @@ RECLAIM_TICKETS_consume_cancel (struct RECLAIM_TICKETS_ConsumeHandle *cth);
 void
 RECLAIM_TICKETS_issue (const struct GNUNET_CRYPTO_PrivateKey *identity,
                        const struct GNUNET_RECLAIM_AttributeList *attrs,
-                       const struct GNUNET_CRYPTO_PublicKey *audience,
+                       const char *rp,
                        RECLAIM_TICKETS_TicketResult cb,
                        void *cb_cls);
 
diff --git a/src/service/reclaim/reclaim.h b/src/service/reclaim/reclaim.h
index 9d5118269..eebd39c29 100644
--- a/src/service/reclaim/reclaim.h
+++ b/src/service/reclaim/reclaim.h
@@ -420,13 +420,13 @@ struct IssueTicketMessage
   uint16_t key_len GNUNET_PACKED;
 
   /**
-   * The length of the relying party public key
+   * The length of the relying party URI
    */
-  uint16_t pkey_len GNUNET_PACKED;
+  uint16_t rp_uri_len GNUNET_PACKED;
 
   /**
    * Followed by the private key.
-   * Followed by the public key.
+   * Followed by the RP URI.
    * Followed by a serialized attribute list
    */
 };
@@ -532,17 +532,11 @@ struct ConsumeTicketMessage
   uint32_t id GNUNET_PACKED;
 
   /**
-   * The length of the private key
-   */
-  uint16_t key_len GNUNET_PACKED;
-
-  /**
    * The length of the ticket
    */
   uint16_t tkt_len GNUNET_PACKED;
 
   /**
-   * Followed by the private key.
    * Followed by the serialized ticket.
    */
 };
@@ -583,12 +577,12 @@ struct ConsumeTicketResultMessage
   uint16_t presentations_len;
 
   /**
-   * The length of the private key
+   * The length of the identity public key
    */
   uint16_t key_len GNUNET_PACKED;
 
   /**
-   * Followed by the private key.
+   * Followed by the identity public key.
    * followed by:
    * serialized attributes data
    */
diff --git a/src/service/reclaim/reclaim_api.c b/src/service/reclaim/reclaim_api.c
index d865f0050..0fe49c37d 100644
--- a/src/service/reclaim/reclaim_api.c
+++ b/src/service/reclaim/reclaim_api.c
@@ -621,9 +621,9 @@ handle_consume_ticket_result (void *cls,
     read_ptr = (char *) &msg[1];
     GNUNET_assert (GNUNET_SYSERR !=
                    GNUNET_CRYPTO_read_public_key_from_buffer (read_ptr,
-                                                                key_len,
-                                                                &identity,
-                                                                &read));
+                                                              key_len,
+                                                              &identity,
+                                                              &read));
     read_ptr += read;
     attrs =
       GNUNET_RECLAIM_attribute_list_deserialize (read_ptr, attrs_len);
@@ -646,7 +646,8 @@ handle_consume_ticket_result (void *cls,
             {
               if (GNUNET_YES ==
                   GNUNET_RECLAIM_id_is_equal (&le->attribute->credential,
-                                              &ple->presentation->credential_id))
+                                              &ple->presentation->credential_id)
+                  )
               {
                 op->atr_cb (op->cls, &identity,
                             le->attribute, ple->presentation);
@@ -765,9 +766,9 @@ handle_attribute_result (void *cls, const struct AttributeResultMessage *msg)
     struct GNUNET_RECLAIM_Attribute *attr;
     GNUNET_assert (GNUNET_SYSERR !=
                    GNUNET_CRYPTO_read_public_key_from_buffer (buf,
-                                                                key_len,
-                                                                &identity,
-                                                                &read));
+                                                              key_len,
+                                                              &identity,
+                                                              &read));
     buf += read;
     GNUNET_RECLAIM_attribute_deserialize (buf, attr_len, &attr);
     if (NULL != it)
@@ -854,9 +855,9 @@ handle_credential_result (void *cls, const struct
   {
     GNUNET_assert (GNUNET_SYSERR !=
                    GNUNET_CRYPTO_read_public_key_from_buffer (buf,
-                                                                key_len,
-                                                                &identity,
-                                                                &read));
+                                                              key_len,
+                                                              &identity,
+                                                              &read));
     buf += read;
   }
   if (0 == key_len)
@@ -966,10 +967,10 @@ handle_ticket_result (void *cls, const struct TicketResultMessage *msg)
   if (0 < tkt_len)
   {
     GNUNET_assert (GNUNET_SYSERR !=
-                  GNUNET_RECLAIM_read_ticket_from_buffer (buf,
-                                                          tkt_len,
-                                                          &ticket,
-                                                          &tb_read));
+                   GNUNET_RECLAIM_read_ticket_from_buffer (buf,
+                                                           tkt_len,
+                                                           &ticket,
+                                                           &tb_read));
     buf += tb_read;
   }
   if (NULL != op)
@@ -1440,7 +1441,8 @@ GNUNET_RECLAIM_get_credentials_start (
   env =
     GNUNET_MQ_msg_extra (msg,
                          key_len,
-                         GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_START);
+                         GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_START)
+  ;
   msg->id = htonl (rid);
   msg->key_len = htons (key_len);
   GNUNET_CRYPTO_write_private_key_to_buffer (identity, &msg[1], key_len);
@@ -1491,7 +1493,7 @@ struct GNUNET_RECLAIM_Operation *
 GNUNET_RECLAIM_ticket_issue (
   struct GNUNET_RECLAIM_Handle *h,
   const struct GNUNET_CRYPTO_PrivateKey *iss,
-  const struct GNUNET_CRYPTO_PublicKey *rp,
+  const char *rp,
   const struct GNUNET_RECLAIM_AttributeList *attrs,
   GNUNET_RECLAIM_IssueTicketCallback cb,
   void *cb_cls)
@@ -1510,19 +1512,20 @@ GNUNET_RECLAIM_ticket_issue (
   op->cls = cb_cls;
   op->r_id = h->r_id_gen++;
   key_len = GNUNET_CRYPTO_private_key_get_length (iss);
-  rpk_len = GNUNET_CRYPTO_public_key_get_length (rp);
+  rpk_len = strlen (rp) + 1;
   GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op);
   attr_len = GNUNET_RECLAIM_attribute_list_serialize_get_size (attrs);
   op->env = GNUNET_MQ_msg_extra (tim,
                                  attr_len + key_len + rpk_len,
                                  GNUNET_MESSAGE_TYPE_RECLAIM_ISSUE_TICKET);
   tim->key_len = htons (key_len);
-  tim->pkey_len = htons (rpk_len);
+  tim->rp_uri_len = htons (rpk_len);
   buf = (char *) &tim[1];
   written = GNUNET_CRYPTO_write_private_key_to_buffer (iss, buf, key_len);
   GNUNET_assert (0 <= written);
   buf += written;
-  written = GNUNET_CRYPTO_write_public_key_to_buffer (rp, buf, rpk_len);
+  memcpy (buf, rp, rpk_len);
+  written = rpk_len;
   GNUNET_assert (0 <= written);
   buf += written;
   tim->id = htonl (op->r_id);
@@ -1535,29 +1538,15 @@ GNUNET_RECLAIM_ticket_issue (
 }
 
 
-/**
- * Consumes an issued ticket. The ticket is persisted
- * and used to retrieve identity information from the issuer
- *
- * @param h the reclaim to use
- * @param identity the identity that is the subject of the issued ticket (the
- * relying party)
- * @param ticket the issued ticket to consume
- * @param cb the callback to call
- * @param cb_cls the callback closure
- * @return handle to abort the operation
- */
 struct GNUNET_RECLAIM_Operation *
 GNUNET_RECLAIM_ticket_consume (
   struct GNUNET_RECLAIM_Handle *h,
-  const struct GNUNET_CRYPTO_PrivateKey *identity,
   const struct GNUNET_RECLAIM_Ticket *ticket,
   GNUNET_RECLAIM_AttributeTicketResult cb,
   void *cb_cls)
 {
   struct GNUNET_RECLAIM_Operation *op;
   struct ConsumeTicketMessage *ctm;
-  size_t key_len;
   size_t tkt_len;
   char *buf;
 
@@ -1566,16 +1555,12 @@ GNUNET_RECLAIM_ticket_consume (
   op->atr_cb = cb;
   op->cls = cb_cls;
   op->r_id = h->r_id_gen++;
-  key_len = GNUNET_CRYPTO_private_key_get_length (identity);
   tkt_len = GNUNET_RECLAIM_ticket_serialize_get_size (ticket);
   GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op);
   op->env = GNUNET_MQ_msg_extra (ctm,
-                                 key_len + tkt_len,
+                                 tkt_len,
                                  GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET);
-  ctm->key_len = htons (key_len);
   buf = (char*) &ctm[1];
-  GNUNET_CRYPTO_write_private_key_to_buffer (identity, buf, key_len);
-  buf += key_len;
   ctm->tkt_len = htons (tkt_len);
   GNUNET_RECLAIM_write_ticket_to_buffer (ticket, buf, tkt_len);
   ctm->id = htonl (op->r_id);
@@ -1619,12 +1604,13 @@ GNUNET_RECLAIM_ticket_iteration_start (
   GNUNET_CONTAINER_DLL_insert_tail (h->ticket_it_head, h->ticket_it_tail, it);
   env = GNUNET_MQ_msg_extra (msg,
                              key_len,
-                             GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_START);
+                             GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_START)
+  ;
   msg->id = htonl (rid);
   msg->key_len = htons (key_len);
   GNUNET_CRYPTO_write_private_key_to_buffer (identity,
-                                               &msg[1],
-                                               key_len);
+                                             &msg[1],
+                                             key_len);
   if (NULL == h->mq)
     it->env = env;
   else
@@ -1723,8 +1709,8 @@ GNUNET_RECLAIM_ticket_revoke (
   msg->tkt_len = htons (tkt_len);
   buf = (char*) &msg[1];
   written = GNUNET_CRYPTO_write_private_key_to_buffer (identity,
-                                                         buf,
-                                                         key_len);
+                                                       buf,
+                                                       key_len);
   GNUNET_assert (0 <= written);
   buf += written;
   GNUNET_RECLAIM_write_ticket_to_buffer (ticket,
@@ -1738,16 +1724,18 @@ GNUNET_RECLAIM_ticket_revoke (
   return op;
 }
 
+
 size_t
 GNUNET_RECLAIM_ticket_serialize_get_size (const struct
                                           GNUNET_RECLAIM_Ticket *tkt)
 {
   size_t size = sizeof (tkt->rnd);
   size += GNUNET_CRYPTO_public_key_get_length (&tkt->identity);
-  size += GNUNET_CRYPTO_public_key_get_length (&tkt->audience);
+  size += strlen (tkt->rp_uri) + 1;
   return size;
 }
 
+
 enum GNUNET_GenericReturnValue
 GNUNET_RECLAIM_read_ticket_from_buffer (const void *buffer,
                                         size_t len,
@@ -1759,22 +1747,19 @@ GNUNET_RECLAIM_read_ticket_from_buffer (const void *buffer,
   size_t left = len;
   if (GNUNET_SYSERR ==
       GNUNET_CRYPTO_read_public_key_from_buffer (tmp,
-                                                   left,
-                                                   &tkt->identity,
-                                                   &read))
+                                                 left,
+                                                 &tkt->identity,
+                                                 &read))
     return GNUNET_SYSERR;
   left -= read;
   tmp += read;
-  if (GNUNET_SYSERR ==
-      GNUNET_CRYPTO_read_public_key_from_buffer (tmp,
-                                                   left,
-                                                   &tkt->audience,
-                                                   &read))
+  if (left <= sizeof (tkt->rnd))
     return GNUNET_SYSERR;
-  left -= read;
-  tmp += read;
-  if (left < sizeof (tkt->rnd))
+  if (left - sizeof (tkt->rnd) > GNUNET_RECLAIM_TICKET_RP_URI_MAX_LEN)
     return GNUNET_SYSERR;
+  memcpy (tkt->rp_uri, tmp, left - sizeof (tkt->rnd));
+  tmp += left - sizeof (tkt->rnd);
+  left = sizeof (tkt->rnd);
   memcpy (&tkt->rnd, tmp, sizeof (tkt->rnd));
   *tb_read = tmp - (char*) buffer + sizeof (tkt->rnd);
   return GNUNET_OK;
@@ -1791,17 +1776,14 @@ GNUNET_RECLAIM_write_ticket_to_buffer (const struct
   size_t left = len;
   ssize_t written = 0;
   written = GNUNET_CRYPTO_write_public_key_to_buffer (&tkt->identity,
-                                                        buffer,
-                                                        left);
+                                                      buffer,
+                                                      left);
   if (0 > written)
     return written;
   left -= written;
   tmp += written;
-  written = GNUNET_CRYPTO_write_public_key_to_buffer (&tkt->audience,
-                                                        tmp,
-                                                        left);
-  if (0 > written)
-    return written;
+  memcpy (&tmp, tkt->rp_uri, strlen (tkt->rp_uri) + 1);
+  written = strlen (tkt->rp_uri) + 1;
   left -= written;
   tmp += written;
   if (left < sizeof (tkt->rnd))
@@ -1811,5 +1793,4 @@ GNUNET_RECLAIM_write_ticket_to_buffer (const struct
 }
 
 
-
 /* end of reclaim_api.c */
diff --git a/src/service/rest/json_reclaim.c b/src/service/rest/json_reclaim.c
index b1ca7a4a5..6cbd44adf 100644
--- a/src/service/rest/json_reclaim.c
+++ b/src/service/rest/json_reclaim.c
@@ -219,16 +219,7 @@ parse_ticket (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
     return GNUNET_SYSERR;
   }
 
-  if (GNUNET_OK !=
-      GNUNET_STRINGS_string_to_data (aud_str,
-                                     strlen (aud_str),
-                                     &ticket->audience,
-                                     sizeof(ticket->audience)))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Audience invalid\n");
-    GNUNET_free (ticket);
-    return GNUNET_SYSERR;
-  }
+  strcpy (ticket->rp_uri, aud_str);
 
   *(struct GNUNET_RECLAIM_Ticket **) spec->ptr = ticket;
   return GNUNET_OK;
diff --git a/src/service/rest/reclaim_plugin.c b/src/service/rest/reclaim_plugin.c
index e1afce00b..921faf8ca 100644
--- a/src/service/rest/reclaim_plugin.c
+++ b/src/service/rest/reclaim_plugin.c
@@ -454,12 +454,7 @@ ticket_collect (void *cls, const struct GNUNET_RECLAIM_Ticket *ticket)
   value = json_string (tmp);
   json_object_set_new (json_resource, "issuer", value);
   GNUNET_free (tmp);
-  tmp =
-    GNUNET_STRINGS_data_to_string_alloc (&ticket->audience,
-                                         sizeof(struct
-                                                GNUNET_CRYPTO_PublicKey));
-  value = json_string (tmp);
-  json_object_set_new (json_resource, "audience", value);
+  json_object_set_new (json_resource, "audience", json_string (ticket->rp_uri));
   GNUNET_free (tmp);
   tmp = GNUNET_STRINGS_data_to_string_alloc (&ticket->rnd, sizeof(ticket->rnd));
   value = json_string (tmp);
@@ -1236,11 +1231,8 @@ consume_ticket_cont (struct GNUNET_REST_RequestHandle *con_handle,
                      const char *url,
                      void *cls)
 {
-  const struct GNUNET_CRYPTO_PrivateKey *identity_priv;
   struct RequestHandle *handle = cls;
-  struct EgoEntry *ego_entry;
   struct GNUNET_RECLAIM_Ticket *ticket;
-  struct GNUNET_CRYPTO_PublicKey tmp_pk;
   char term_data[handle->rest_handle->data_size + 1];
   json_t *data_json;
   json_error_t err;
@@ -1274,25 +1266,8 @@ consume_ticket_cont (struct GNUNET_REST_RequestHandle *con_handle,
     json_decref (data_json);
     return;
   }
-  for (ego_entry = ego_head; NULL != ego_entry;
-       ego_entry = ego_entry->next)
-  {
-    GNUNET_IDENTITY_ego_get_public_key (ego_entry->ego, &tmp_pk);
-    if (0 == memcmp (&ticket->audience,
-                     &tmp_pk,
-                     sizeof(struct GNUNET_CRYPTO_PublicKey)))
-      break;
-  }
-  if (NULL == ego_entry)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Identity unknown\n");
-    GNUNET_JSON_parse_free (tktspec);
-    return;
-  }
-  identity_priv = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
   handle->resp_object = json_object ();
   handle->idp_op = GNUNET_RECLAIM_ticket_consume (idp,
-                                                  identity_priv,
                                                   ticket,
                                                   &consume_cont,
                                                   handle);