diff options
author | Martin Schanzenbach <mschanzenbach@posteo.de> | 2020-08-19 23:53:02 +0200 |
---|---|---|
committer | Martin Schanzenbach <mschanzenbach@posteo.de> | 2020-08-20 17:59:02 +0200 |
commit | a57d476abbe857365aff157f389cc1188b5dd090 (patch) | |
tree | e8f7163ef7e6f5426748fed8d2eaa5183038a5d6 /src | |
parent | e75869506cc08e08056168383bd4ab02e1f007de (diff) | |
download | gnunet-a57d476abbe857365aff157f389cc1188b5dd090.tar.gz gnunet-a57d476abbe857365aff157f389cc1188b5dd090.zip |
reclaim: Attestations now called credentials. Credentials are presented to third parties as presentations.
Diffstat (limited to 'src')
-rw-r--r-- | src/include/gnunet_gnsrecord_lib.h | 7 | ||||
-rw-r--r-- | src/include/gnunet_reclaim_lib.h | 13 | ||||
-rw-r--r-- | src/include/gnunet_reclaim_plugin.h | 10 | ||||
-rw-r--r-- | src/include/gnunet_reclaim_service.h | 18 | ||||
-rw-r--r-- | src/reclaim/gnunet-reclaim.c | 5 | ||||
-rw-r--r-- | src/reclaim/gnunet-service-reclaim.c | 33 | ||||
-rw-r--r-- | src/reclaim/gnunet-service-reclaim_tickets.c | 197 | ||||
-rw-r--r-- | src/reclaim/gnunet-service-reclaim_tickets.h | 7 | ||||
-rw-r--r-- | src/reclaim/json_reclaim.c | 12 | ||||
-rw-r--r-- | src/reclaim/json_reclaim.h | 2 | ||||
-rw-r--r-- | src/reclaim/oidc_helper.c | 22 | ||||
-rw-r--r-- | src/reclaim/oidc_helper.h | 16 | ||||
-rw-r--r-- | src/reclaim/plugin_gnsrecord_reclaim.c | 12 | ||||
-rw-r--r-- | src/reclaim/plugin_reclaim_credential_jwt.c | 159 | ||||
-rw-r--r-- | src/reclaim/plugin_rest_openid_connect.c | 68 | ||||
-rw-r--r-- | src/reclaim/plugin_rest_reclaim.c | 6 | ||||
-rw-r--r-- | src/reclaim/reclaim.h | 7 | ||||
-rw-r--r-- | src/reclaim/reclaim_api.c | 58 | ||||
-rw-r--r-- | src/reclaim/reclaim_credential.c | 501 | ||||
-rw-r--r-- | src/reclaim/reclaim_credential.h | 35 |
20 files changed, 1010 insertions, 178 deletions
diff --git a/src/include/gnunet_gnsrecord_lib.h b/src/include/gnunet_gnsrecord_lib.h index c976c89c5..960203fb1 100644 --- a/src/include/gnunet_gnsrecord_lib.h +++ b/src/include/gnunet_gnsrecord_lib.h | |||
@@ -143,12 +143,13 @@ extern "C" { | |||
143 | /** | 143 | /** |
144 | * Record type for an attribute attestation | 144 | * Record type for an attribute attestation |
145 | */ | 145 | */ |
146 | #define GNUNET_GNSRECORD_TYPE_RECLAIM_ATTESTATION 65554 | 146 | #define GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL 65554 |
147 | 147 | ||
148 | /** | 148 | /** |
149 | * Record type for an attestation reference in a ticket | 149 | * Record type for a presentation of a credential (used |
150 | * in a ticket record set) | ||
150 | */ | 151 | */ |
151 | #define GNUNET_GNSRECORD_TYPE_RECLAIM_ATTESTATION_REF 65555 | 152 | #define GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION 65555 |
152 | 153 | ||
153 | 154 | ||
154 | /** | 155 | /** |
diff --git a/src/include/gnunet_reclaim_lib.h b/src/include/gnunet_reclaim_lib.h index f5c3d3864..bbf1c3ad3 100644 --- a/src/include/gnunet_reclaim_lib.h +++ b/src/include/gnunet_reclaim_lib.h | |||
@@ -780,6 +780,11 @@ GNUNET_RECLAIM_presentation_value_to_string (uint32_t type, | |||
780 | const void *data, | 780 | const void *data, |
781 | size_t data_size); | 781 | size_t data_size); |
782 | 782 | ||
783 | struct GNUNET_RECLAIM_Presentation * | ||
784 | GNUNET_RECLAIM_presentation_new (uint32_t type, | ||
785 | const void *data, | ||
786 | size_t data_size); | ||
787 | |||
783 | /** | 788 | /** |
784 | * Convert human-readable version of a 'claim' of a presentation to the binary | 789 | * Convert human-readable version of a 'claim' of a presentation to the binary |
785 | * representation | 790 | * representation |
@@ -828,14 +833,16 @@ GNUNET_RECLAIM_presentation_get_expiration (const struct | |||
828 | * | 833 | * |
829 | * @param cred the credential to use | 834 | * @param cred the credential to use |
830 | * @param attrs the attributes to present from the credential | 835 | * @param attrs the attributes to present from the credential |
831 | * @return the credential presentation presenting the attributes according | 836 | * @param presentation the credential presentation presenting the attributes according |
832 | * to the presentation mechanism of the credential | 837 | * to the presentation mechanism of the credential |
833 | * or NULL on error. | 838 | * or NULL on error. |
839 | * @return GNUNET_OK on success. | ||
834 | */ | 840 | */ |
835 | struct GNUNET_RECLAIM_Presentation* | 841 | int |
836 | GNUNET_RECLAIM_credential_get_presentation ( | 842 | GNUNET_RECLAIM_credential_get_presentation ( |
837 | const struct GNUNET_RECLAIM_Credential *cred, | 843 | const struct GNUNET_RECLAIM_Credential *cred, |
838 | const struct GNUNET_RECLAIM_AttributeList *attrs); | 844 | const struct GNUNET_RECLAIM_AttributeList *attrs, |
845 | struct GNUNET_RECLAIM_Presentation **presentation); | ||
839 | 846 | ||
840 | 847 | ||
841 | #if 0 /* keep Emacsens' auto-indent happy */ | 848 | #if 0 /* keep Emacsens' auto-indent happy */ |
diff --git a/src/include/gnunet_reclaim_plugin.h b/src/include/gnunet_reclaim_plugin.h index af6c74e0b..2ba8fc8a0 100644 --- a/src/include/gnunet_reclaim_plugin.h +++ b/src/include/gnunet_reclaim_plugin.h | |||
@@ -301,6 +301,11 @@ typedef int (*GNUNET_RECLAIM_PresentationGetExpirationFunction) ( | |||
301 | const struct GNUNET_RECLAIM_Presentation *cred, | 301 | const struct GNUNET_RECLAIM_Presentation *cred, |
302 | struct GNUNET_TIME_Absolute *expiration); | 302 | struct GNUNET_TIME_Absolute *expiration); |
303 | 303 | ||
304 | typedef int (*GNUNET_RECLAIM_CredentialToPresentation) ( | ||
305 | void *cls, | ||
306 | const struct GNUNET_RECLAIM_Credential *cred, | ||
307 | const struct GNUNET_RECLAIM_AttributeList *attrs, | ||
308 | struct GNUNET_RECLAIM_Presentation **presentation); | ||
304 | 309 | ||
305 | /** | 310 | /** |
306 | * Each plugin is required to return a pointer to a struct of this | 311 | * Each plugin is required to return a pointer to a struct of this |
@@ -416,6 +421,11 @@ struct GNUNET_RECLAIM_CredentialPluginFunctions | |||
416 | */ | 421 | */ |
417 | GNUNET_RECLAIM_PresentationGetExpirationFunction get_expiration_p; | 422 | GNUNET_RECLAIM_PresentationGetExpirationFunction get_expiration_p; |
418 | 423 | ||
424 | /** | ||
425 | * Get presentation | ||
426 | */ | ||
427 | GNUNET_RECLAIM_CredentialToPresentation create_presentation; | ||
428 | |||
419 | }; | 429 | }; |
420 | 430 | ||
421 | 431 | ||
diff --git a/src/include/gnunet_reclaim_service.h b/src/include/gnunet_reclaim_service.h index 8387c79b0..368058f56 100644 --- a/src/include/gnunet_reclaim_service.h +++ b/src/include/gnunet_reclaim_service.h | |||
@@ -92,7 +92,21 @@ struct GNUNET_RECLAIM_Ticket | |||
92 | * @param ticket the ticket | 92 | * @param ticket the ticket |
93 | */ | 93 | */ |
94 | typedef void (*GNUNET_RECLAIM_TicketCallback) ( | 94 | typedef void (*GNUNET_RECLAIM_TicketCallback) ( |
95 | void *cls, const struct GNUNET_RECLAIM_Ticket *ticket); | 95 | void *cls, |
96 | const struct GNUNET_RECLAIM_Ticket *ticket); | ||
97 | |||
98 | /** | ||
99 | * Method called when a token has been issued. | ||
100 | * On success returns a ticket that can be given to a relying party | ||
101 | * in order for it retrive identity attributes | ||
102 | * | ||
103 | * @param cls closure | ||
104 | * @param ticket the ticket | ||
105 | */ | ||
106 | typedef void (*GNUNET_RECLAIM_IssueTicketCallback) ( | ||
107 | void *cls, | ||
108 | const struct GNUNET_RECLAIM_Ticket *ticket, | ||
109 | const struct GNUNET_RECLAIM_PresentationList *presentations); | ||
96 | 110 | ||
97 | 111 | ||
98 | /** | 112 | /** |
@@ -369,7 +383,7 @@ GNUNET_RECLAIM_ticket_issue ( | |||
369 | const struct GNUNET_CRYPTO_EcdsaPrivateKey *iss, | 383 | const struct GNUNET_CRYPTO_EcdsaPrivateKey *iss, |
370 | const struct GNUNET_CRYPTO_EcdsaPublicKey *rp, | 384 | const struct GNUNET_CRYPTO_EcdsaPublicKey *rp, |
371 | const struct GNUNET_RECLAIM_AttributeList *attrs, | 385 | const struct GNUNET_RECLAIM_AttributeList *attrs, |
372 | GNUNET_RECLAIM_TicketCallback cb, void *cb_cls); | 386 | GNUNET_RECLAIM_IssueTicketCallback cb, void *cb_cls); |
373 | 387 | ||
374 | 388 | ||
375 | /** | 389 | /** |
diff --git a/src/reclaim/gnunet-reclaim.c b/src/reclaim/gnunet-reclaim.c index a59053f5f..ab281a645 100644 --- a/src/reclaim/gnunet-reclaim.c +++ b/src/reclaim/gnunet-reclaim.c | |||
@@ -227,7 +227,9 @@ do_cleanup (void *cls) | |||
227 | 227 | ||
228 | 228 | ||
229 | static void | 229 | static void |
230 | ticket_issue_cb (void *cls, const struct GNUNET_RECLAIM_Ticket *ticket) | 230 | ticket_issue_cb (void *cls, |
231 | const struct GNUNET_RECLAIM_Ticket *ticket, | ||
232 | const struct GNUNET_RECLAIM_PresentationList *presentations) | ||
231 | { | 233 | { |
232 | char *ticket_str; | 234 | char *ticket_str; |
233 | 235 | ||
@@ -456,6 +458,7 @@ iter_finished (void *cls) | |||
456 | if (NULL == attr_to_delete) | 458 | if (NULL == attr_to_delete) |
457 | { | 459 | { |
458 | fprintf (stdout, "No such attribute ``%s''\n", attr_delete); | 460 | fprintf (stdout, "No such attribute ``%s''\n", attr_delete); |
461 | GNUNET_SCHEDULER_add_now (&do_cleanup, NULL); | ||
459 | return; | 462 | return; |
460 | } | 463 | } |
461 | reclaim_op = GNUNET_RECLAIM_attribute_delete (reclaim_handle, | 464 | reclaim_op = GNUNET_RECLAIM_attribute_delete (reclaim_handle, |
diff --git a/src/reclaim/gnunet-service-reclaim.c b/src/reclaim/gnunet-service-reclaim.c index 30a84b3e8..d2cdc62a2 100644 --- a/src/reclaim/gnunet-service-reclaim.c +++ b/src/reclaim/gnunet-service-reclaim.c | |||
@@ -646,19 +646,33 @@ static void | |||
646 | send_ticket_result (const struct IdpClient *client, | 646 | send_ticket_result (const struct IdpClient *client, |
647 | uint32_t r_id, | 647 | uint32_t r_id, |
648 | const struct GNUNET_RECLAIM_Ticket *ticket, | 648 | const struct GNUNET_RECLAIM_Ticket *ticket, |
649 | const struct GNUNET_RECLAIM_PresentationList *presentations, | ||
649 | uint32_t success) | 650 | uint32_t success) |
650 | { | 651 | { |
651 | struct TicketResultMessage *irm; | 652 | struct TicketResultMessage *irm; |
652 | struct GNUNET_MQ_Envelope *env; | 653 | struct GNUNET_MQ_Envelope *env; |
654 | size_t pres_len = 0; | ||
653 | 655 | ||
654 | env = GNUNET_MQ_msg (irm, | 656 | if (NULL != presentations) |
655 | GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT); | 657 | { |
658 | pres_len = | ||
659 | GNUNET_RECLAIM_presentation_list_serialize_get_size (presentations); | ||
660 | } | ||
661 | env = GNUNET_MQ_msg_extra (irm, | ||
662 | pres_len, | ||
663 | GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT); | ||
656 | if (NULL != ticket) | 664 | if (NULL != ticket) |
657 | { | 665 | { |
658 | irm->ticket = *ticket; | 666 | irm->ticket = *ticket; |
659 | } | 667 | } |
660 | // TODO add success member | 668 | // TODO add success member |
661 | irm->id = htonl (r_id); | 669 | irm->id = htonl (r_id); |
670 | irm->presentations_len = htons (pres_len); | ||
671 | if (NULL != presentations) | ||
672 | { | ||
673 | GNUNET_RECLAIM_presentation_list_serialize (presentations, | ||
674 | (char*) &irm[1]); | ||
675 | } | ||
662 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending TICKET_RESULT message\n"); | 676 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending TICKET_RESULT message\n"); |
663 | GNUNET_MQ_send (client->mq, env); | 677 | GNUNET_MQ_send (client->mq, env); |
664 | } | 678 | } |
@@ -669,12 +683,14 @@ send_ticket_result (const struct IdpClient *client, | |||
669 | * | 683 | * |
670 | * @param cls out ticket issue operation handle | 684 | * @param cls out ticket issue operation handle |
671 | * @param ticket the issued ticket | 685 | * @param ticket the issued ticket |
686 | * @param presentations newly created credential presentations (NULL on error) | ||
672 | * @param success issue success status (GNUNET_OK if successful) | 687 | * @param success issue success status (GNUNET_OK if successful) |
673 | * @param emsg error message (NULL of success is GNUNET_OK) | 688 | * @param emsg error message (NULL of success is GNUNET_OK) |
674 | */ | 689 | */ |
675 | static void | 690 | static void |
676 | issue_ticket_result_cb (void *cls, | 691 | issue_ticket_result_cb (void *cls, |
677 | struct GNUNET_RECLAIM_Ticket *ticket, | 692 | struct GNUNET_RECLAIM_Ticket *ticket, |
693 | struct GNUNET_RECLAIM_PresentationList *presentations, | ||
678 | int32_t success, | 694 | int32_t success, |
679 | const char *emsg) | 695 | const char *emsg) |
680 | { | 696 | { |
@@ -682,7 +698,7 @@ issue_ticket_result_cb (void *cls, | |||
682 | 698 | ||
683 | if (GNUNET_OK != success) | 699 | if (GNUNET_OK != success) |
684 | { | 700 | { |
685 | send_ticket_result (tio->client, tio->r_id, NULL, GNUNET_SYSERR); | 701 | send_ticket_result (tio->client, tio->r_id, NULL, NULL, GNUNET_SYSERR); |
686 | GNUNET_CONTAINER_DLL_remove (tio->client->issue_op_head, | 702 | GNUNET_CONTAINER_DLL_remove (tio->client->issue_op_head, |
687 | tio->client->issue_op_tail, | 703 | tio->client->issue_op_tail, |
688 | tio); | 704 | tio); |
@@ -690,7 +706,8 @@ issue_ticket_result_cb (void *cls, | |||
690 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error issuing ticket: %s\n", emsg); | 706 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error issuing ticket: %s\n", emsg); |
691 | return; | 707 | return; |
692 | } | 708 | } |
693 | send_ticket_result (tio->client, tio->r_id, ticket, GNUNET_SYSERR); | 709 | send_ticket_result (tio->client, tio->r_id, |
710 | ticket, presentations, GNUNET_SYSERR); | ||
694 | GNUNET_CONTAINER_DLL_remove (tio->client->issue_op_head, | 711 | GNUNET_CONTAINER_DLL_remove (tio->client->issue_op_head, |
695 | tio->client->issue_op_tail, | 712 | tio->client->issue_op_tail, |
696 | tio); | 713 | tio); |
@@ -871,7 +888,7 @@ consume_result_cb (void *cls, | |||
871 | GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET_RESULT); | 888 | GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET_RESULT); |
872 | crm->id = htonl (cop->r_id); | 889 | crm->id = htonl (cop->r_id); |
873 | crm->attrs_len = htons (attrs_len); | 890 | crm->attrs_len = htons (attrs_len); |
874 | crm->pres_len = htons (pres_len); | 891 | crm->presentations_len = htons (pres_len); |
875 | crm->identity = *identity; | 892 | crm->identity = *identity; |
876 | crm->result = htonl (success); | 893 | crm->result = htonl (success); |
877 | data_tmp = (char *) &crm[1]; | 894 | data_tmp = (char *) &crm[1]; |
@@ -1152,7 +1169,7 @@ cred_add_cb (void *cls, | |||
1152 | 1169 | ||
1153 | buf_size = GNUNET_RECLAIM_credential_serialize_get_size (ash->credential); | 1170 | buf_size = GNUNET_RECLAIM_credential_serialize_get_size (ash->credential); |
1154 | buf = GNUNET_malloc (buf_size); | 1171 | buf = GNUNET_malloc (buf_size); |
1155 | GNUNET_RECLAIM_presentation_serialize (ash->credential, buf); | 1172 | GNUNET_RECLAIM_credential_serialize (ash->credential, buf); |
1156 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1173 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1157 | "Storing new credential under `%s'.\n", | 1174 | "Storing new credential under `%s'.\n", |
1158 | label); | 1175 | label); |
@@ -1611,8 +1628,8 @@ cred_delete_cont (void *cls, int32_t success, const char *emsg) | |||
1611 | * @dam message to check | 1628 | * @dam message to check |
1612 | */ | 1629 | */ |
1613 | static int | 1630 | static int |
1614 | check_cred_delete_message (void *cls, | 1631 | check_credential_delete_message (void *cls, |
1615 | const struct AttributeDeleteMessage *dam) | 1632 | const struct AttributeDeleteMessage *dam) |
1616 | { | 1633 | { |
1617 | uint16_t size; | 1634 | uint16_t size; |
1618 | 1635 | ||
diff --git a/src/reclaim/gnunet-service-reclaim_tickets.c b/src/reclaim/gnunet-service-reclaim_tickets.c index 18b173aaa..4dd8100f9 100644 --- a/src/reclaim/gnunet-service-reclaim_tickets.c +++ b/src/reclaim/gnunet-service-reclaim_tickets.c | |||
@@ -114,9 +114,9 @@ struct RECLAIM_TICKETS_ConsumeHandle | |||
114 | struct GNUNET_RECLAIM_AttributeList *attrs; | 114 | struct GNUNET_RECLAIM_AttributeList *attrs; |
115 | 115 | ||
116 | /** | 116 | /** |
117 | * Credentials | 117 | * Presentations |
118 | */ | 118 | */ |
119 | struct GNUNET_RECLAIM_CredentialList *credentials; | 119 | struct GNUNET_RECLAIM_PresentationList *presentations; |
120 | 120 | ||
121 | /** | 121 | /** |
122 | * Lookup time | 122 | * Lookup time |
@@ -173,6 +173,11 @@ struct TicketIssueHandle | |||
173 | struct GNUNET_RECLAIM_AttributeList *attrs; | 173 | struct GNUNET_RECLAIM_AttributeList *attrs; |
174 | 174 | ||
175 | /** | 175 | /** |
176 | * Presentations to add | ||
177 | */ | ||
178 | struct GNUNET_RECLAIM_PresentationList *presentations; | ||
179 | |||
180 | /** | ||
176 | * Issuer Key | 181 | * Issuer Key |
177 | */ | 182 | */ |
178 | struct GNUNET_CRYPTO_EcdsaPrivateKey identity; | 183 | struct GNUNET_CRYPTO_EcdsaPrivateKey identity; |
@@ -981,8 +986,8 @@ cleanup_cth (struct RECLAIM_TICKETS_ConsumeHandle *cth) | |||
981 | 986 | ||
982 | if (NULL != cth->attrs) | 987 | if (NULL != cth->attrs) |
983 | GNUNET_RECLAIM_attribute_list_destroy (cth->attrs); | 988 | GNUNET_RECLAIM_attribute_list_destroy (cth->attrs); |
984 | if (NULL != cth->credentials) | 989 | if (NULL != cth->presentations) |
985 | GNUNET_RECLAIM_credential_list_destroy (cth->credentials); | 990 | GNUNET_RECLAIM_presentation_list_destroy (cth->presentations); |
986 | GNUNET_free (cth); | 991 | GNUNET_free (cth); |
987 | } | 992 | } |
988 | 993 | ||
@@ -1040,7 +1045,7 @@ process_parallel_lookup_result (void *cls, | |||
1040 | return; // Wait for more | 1045 | return; // Wait for more |
1041 | /* Else we are done */ | 1046 | /* Else we are done */ |
1042 | cth->cb (cth->cb_cls, &cth->ticket.identity, | 1047 | cth->cb (cth->cb_cls, &cth->ticket.identity, |
1043 | cth->attrs, cth->credentials, GNUNET_OK, NULL); | 1048 | cth->attrs, cth->presentations, GNUNET_OK, NULL); |
1044 | cleanup_cth (cth); | 1049 | cleanup_cth (cth); |
1045 | } | 1050 | } |
1046 | 1051 | ||
@@ -1090,6 +1095,7 @@ lookup_authz_cb (void *cls, | |||
1090 | struct RECLAIM_TICKETS_ConsumeHandle *cth = cls; | 1095 | struct RECLAIM_TICKETS_ConsumeHandle *cth = cls; |
1091 | struct ParallelLookup *parallel_lookup; | 1096 | struct ParallelLookup *parallel_lookup; |
1092 | char *lbl; | 1097 | char *lbl; |
1098 | struct GNUNET_RECLAIM_PresentationListEntry *ale; | ||
1093 | 1099 | ||
1094 | cth->lookup_request = NULL; | 1100 | cth->lookup_request = NULL; |
1095 | 1101 | ||
@@ -1113,13 +1119,12 @@ lookup_authz_cb (void *cls, | |||
1113 | switch (rd[i].record_type) | 1119 | switch (rd[i].record_type) |
1114 | { | 1120 | { |
1115 | case GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION: | 1121 | case GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION: |
1116 | struct GNUNET_RECLAIM_CredentialListEntry *ale; | 1122 | ale = GNUNET_new (struct GNUNET_RECLAIM_PresentationListEntry); |
1117 | ale = GNUNET_new (struct GNUNET_RECLAIM_CredentialListEntry); | 1123 | ale->presentation = |
1118 | ale->credential = | 1124 | GNUNET_RECLAIM_presentation_deserialize (rd[i].data, |
1119 | GNUNET_RECLAIM_credential_deserialize (rd[i].data, | 1125 | rd[i].data_size); |
1120 | rd[i].data_size); | 1126 | GNUNET_CONTAINER_DLL_insert (cth->presentations->list_head, |
1121 | GNUNET_CONTAINER_DLL_insert (cth->credentials->list_head, | 1127 | cth->presentations->list_tail, |
1122 | cth->credentials->list_tail, | ||
1123 | ale); | 1128 | ale); |
1124 | break; | 1129 | break; |
1125 | case GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF: | 1130 | case GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF: |
@@ -1162,7 +1167,7 @@ lookup_authz_cb (void *cls, | |||
1162 | * No references found, return empty attribute list | 1167 | * No references found, return empty attribute list |
1163 | */ | 1168 | */ |
1164 | cth->cb (cth->cb_cls, &cth->ticket.identity, | 1169 | cth->cb (cth->cb_cls, &cth->ticket.identity, |
1165 | cth->attrs, cth->credentials, GNUNET_OK, NULL); | 1170 | cth->attrs, NULL, GNUNET_OK, NULL); |
1166 | cleanup_cth (cth); | 1171 | cleanup_cth (cth); |
1167 | } | 1172 | } |
1168 | 1173 | ||
@@ -1192,7 +1197,7 @@ RECLAIM_TICKETS_consume (const struct GNUNET_CRYPTO_EcdsaPrivateKey *id, | |||
1192 | cth->identity = *id; | 1197 | cth->identity = *id; |
1193 | GNUNET_CRYPTO_ecdsa_key_get_public (&cth->identity, &cth->identity_pub); | 1198 | GNUNET_CRYPTO_ecdsa_key_get_public (&cth->identity, &cth->identity_pub); |
1194 | cth->attrs = GNUNET_new (struct GNUNET_RECLAIM_AttributeList); | 1199 | cth->attrs = GNUNET_new (struct GNUNET_RECLAIM_AttributeList); |
1195 | cth->credentials = GNUNET_new (struct GNUNET_RECLAIM_CredentialList); | 1200 | cth->presentations = GNUNET_new (struct GNUNET_RECLAIM_PresentationList); |
1196 | cth->ticket = *ticket; | 1201 | cth->ticket = *ticket; |
1197 | cth->cb = cb; | 1202 | cth->cb = cb; |
1198 | cth->cb_cls = cb_cls; | 1203 | cth->cb_cls = cb_cls; |
@@ -1230,8 +1235,8 @@ RECLAIM_TICKETS_consume_cancel (struct RECLAIM_TICKETS_ConsumeHandle *cth) | |||
1230 | 1235 | ||
1231 | 1236 | ||
1232 | /******************************* | 1237 | /******************************* |
1233 | * Ticket issue | 1238 | * Ticket issue |
1234 | *******************************/ | 1239 | *******************************/ |
1235 | 1240 | ||
1236 | /** | 1241 | /** |
1237 | * Cleanup ticket consume handle | 1242 | * Cleanup ticket consume handle |
@@ -1264,11 +1269,15 @@ store_ticket_issue_cont (void *cls, int32_t success, const char *emsg) | |||
1264 | { | 1269 | { |
1265 | handle->cb (handle->cb_cls, | 1270 | handle->cb (handle->cb_cls, |
1266 | &handle->ticket, | 1271 | &handle->ticket, |
1272 | NULL, | ||
1267 | GNUNET_SYSERR, | 1273 | GNUNET_SYSERR, |
1268 | "Error storing AuthZ ticket in GNS"); | 1274 | "Error storing AuthZ ticket in GNS"); |
1269 | return; | 1275 | return; |
1270 | } | 1276 | } |
1271 | handle->cb (handle->cb_cls, &handle->ticket, GNUNET_OK, NULL); | 1277 | handle->cb (handle->cb_cls, |
1278 | &handle->ticket, | ||
1279 | handle->presentations, | ||
1280 | GNUNET_OK, NULL); | ||
1272 | cleanup_issue_handle (handle); | 1281 | cleanup_issue_handle (handle); |
1273 | } | 1282 | } |
1274 | 1283 | ||
@@ -1284,15 +1293,17 @@ static void | |||
1284 | issue_ticket (struct TicketIssueHandle *ih) | 1293 | issue_ticket (struct TicketIssueHandle *ih) |
1285 | { | 1294 | { |
1286 | struct GNUNET_RECLAIM_AttributeListEntry *le; | 1295 | struct GNUNET_RECLAIM_AttributeListEntry *le; |
1296 | struct GNUNET_RECLAIM_PresentationListEntry *ple; | ||
1287 | struct GNUNET_GNSRECORD_Data *attrs_record; | 1297 | struct GNUNET_GNSRECORD_Data *attrs_record; |
1288 | char *label; | 1298 | char *label; |
1289 | int i; | 1299 | int i; |
1300 | int j; | ||
1290 | int attrs_count = 0; | 1301 | int attrs_count = 0; |
1291 | 1302 | ||
1292 | for (le = ih->attrs->list_head; NULL != le; le = le->next) | 1303 | for (le = ih->attrs->list_head; NULL != le; le = le->next) |
1293 | attrs_count++; | 1304 | attrs_count++; |
1294 | 1305 | ||
1295 | // Worst case we have one credential per attribute | 1306 | // Worst case we have one presentation per attribute |
1296 | attrs_record = | 1307 | attrs_record = |
1297 | GNUNET_malloc (2 * attrs_count * sizeof(struct GNUNET_GNSRECORD_Data)); | 1308 | GNUNET_malloc (2 * attrs_count * sizeof(struct GNUNET_GNSRECORD_Data)); |
1298 | i = 0; | 1309 | i = 0; |
@@ -1309,31 +1320,65 @@ issue_ticket (struct TicketIssueHandle *ih) | |||
1309 | i++; | 1320 | i++; |
1310 | if (GNUNET_NO == GNUNET_RECLAIM_id_is_zero (&le->attribute->credential)) | 1321 | if (GNUNET_NO == GNUNET_RECLAIM_id_is_zero (&le->attribute->credential)) |
1311 | { | 1322 | { |
1312 | struct GNUNET_RECLAIM_Presentation *pres; | 1323 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1313 | int j; | 1324 | "Attribute is backed by credential. Adding...\n"); |
1325 | struct GNUNET_RECLAIM_Presentation *pres = NULL; | ||
1314 | for (j = 0; j < i; j++) | 1326 | for (j = 0; j < i; j++) |
1315 | { | 1327 | { |
1316 | if (attrs_record[j].record_type | 1328 | if (attrs_record[j].record_type |
1317 | != GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION) | 1329 | != GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION) |
1318 | continue; | 1330 | continue; |
1319 | pres = attrs_record[j].data; | 1331 | pres = GNUNET_RECLAIM_presentation_deserialize (attrs_record[j].data, |
1320 | if (0 == memcmp (pres->credential_id, | 1332 | attrs_record[j]. |
1333 | data_size); | ||
1334 | if (NULL == pres) | ||
1335 | { | ||
1336 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | ||
1337 | "Failed to deserialize presentation\n"); | ||
1338 | continue; | ||
1339 | } | ||
1340 | if (0 == memcmp (&pres->credential_id, | ||
1321 | &le->attribute->credential, | 1341 | &le->attribute->credential, |
1322 | sizeof (le->attribute->credential))) | 1342 | sizeof (le->attribute->credential))) |
1323 | break; | 1343 | break; |
1344 | GNUNET_free (pres); | ||
1345 | pres = NULL; | ||
1324 | } | 1346 | } |
1325 | if (j < i) | 1347 | if (NULL != pres) |
1348 | { | ||
1349 | GNUNET_free (pres); | ||
1326 | continue; // Skip as we have already added this credential presentation. | 1350 | continue; // Skip as we have already added this credential presentation. |
1327 | /** | 1351 | } |
1328 | * FIXME: Create a new presentation from the credential. | 1352 | for (ple = ih->presentations->list_head; NULL != ple; ple = ple->next) |
1329 | */ | 1353 | { |
1330 | attrs_record[i].data = &le->attribute->credential; | 1354 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1331 | attrs_record[i].data_size = sizeof(le->attribute->credential); | 1355 | "Checking presentation....\n"); |
1332 | attrs_record[i].expiration_time = ticket_refresh_interval.rel_value_us; | 1356 | |
1333 | attrs_record[i].record_type = | 1357 | if (0 != memcmp (&le->attribute->credential, |
1334 | GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION; | 1358 | &ple->presentation->credential_id, |
1335 | attrs_record[i].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION; | 1359 | sizeof (le->attribute->credential))) |
1336 | i++; | 1360 | { |
1361 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
1362 | "Presentation does not match credential ID.\n"); | ||
1363 | continue; | ||
1364 | } | ||
1365 | char *pres_buf; | ||
1366 | size_t pres_size; | ||
1367 | pres_size = | ||
1368 | GNUNET_RECLAIM_presentation_serialize_get_size (ple->presentation); | ||
1369 | pres_buf = GNUNET_malloc (pres_size); | ||
1370 | GNUNET_RECLAIM_presentation_serialize (ple->presentation, | ||
1371 | pres_buf); | ||
1372 | attrs_record[i].data = pres_buf; | ||
1373 | attrs_record[i].data_size = pres_size; | ||
1374 | attrs_record[i].expiration_time = | ||
1375 | ticket_refresh_interval.rel_value_us; | ||
1376 | attrs_record[i].record_type = | ||
1377 | GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION; | ||
1378 | attrs_record[i].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION; | ||
1379 | i++; | ||
1380 | break; | ||
1381 | } | ||
1337 | } | 1382 | } |
1338 | } | 1383 | } |
1339 | attrs_record[i].data = &ih->ticket; | 1384 | attrs_record[i].data = &ih->ticket; |
@@ -1355,14 +1400,23 @@ issue_ticket (struct TicketIssueHandle *ih) | |||
1355 | attrs_record, | 1400 | attrs_record, |
1356 | &store_ticket_issue_cont, | 1401 | &store_ticket_issue_cont, |
1357 | ih); | 1402 | ih); |
1403 | for (j = 0; j > i; j++) | ||
1404 | { | ||
1405 | if (attrs_record[j].record_type | ||
1406 | != GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION) | ||
1407 | continue; | ||
1408 | // Yes, we are allowed to do this because we allocated it above | ||
1409 | char *ptr = (char*) attrs_record[j].data; | ||
1410 | GNUNET_free (ptr); | ||
1411 | } | ||
1358 | GNUNET_free (attrs_record); | 1412 | GNUNET_free (attrs_record); |
1359 | GNUNET_free (label); | 1413 | GNUNET_free (label); |
1360 | } | 1414 | } |
1361 | 1415 | ||
1362 | 1416 | ||
1363 | /************************************************* | 1417 | /************************************************* |
1364 | * Ticket iteration (finding a specific ticket) | 1418 | * Ticket iteration (finding a specific ticket) |
1365 | *************************************************/ | 1419 | *************************************************/ |
1366 | 1420 | ||
1367 | 1421 | ||
1368 | /** | 1422 | /** |
@@ -1378,6 +1432,7 @@ filter_tickets_error_cb (void *cls) | |||
1378 | tih->ns_it = NULL; | 1432 | tih->ns_it = NULL; |
1379 | tih->cb (tih->cb_cls, | 1433 | tih->cb (tih->cb_cls, |
1380 | &tih->ticket, | 1434 | &tih->ticket, |
1435 | NULL, | ||
1381 | GNUNET_SYSERR, | 1436 | GNUNET_SYSERR, |
1382 | "Error storing AuthZ ticket in GNS"); | 1437 | "Error storing AuthZ ticket in GNS"); |
1383 | cleanup_issue_handle (tih); | 1438 | cleanup_issue_handle (tih); |
@@ -1406,11 +1461,12 @@ filter_tickets_cb (void *cls, | |||
1406 | struct TicketIssueHandle *tih = cls; | 1461 | struct TicketIssueHandle *tih = cls; |
1407 | struct GNUNET_RECLAIM_Ticket *ticket = NULL; | 1462 | struct GNUNET_RECLAIM_Ticket *ticket = NULL; |
1408 | struct GNUNET_RECLAIM_Presentation *pres; | 1463 | struct GNUNET_RECLAIM_Presentation *pres; |
1409 | 1464 | struct GNUNET_RECLAIM_PresentationList *ticket_presentations; | |
1410 | // figure out the number of requested attributes | 1465 | struct GNUNET_RECLAIM_Credential *cred; |
1466 | struct GNUNET_RECLAIM_PresentationListEntry *ple; | ||
1411 | struct GNUNET_RECLAIM_AttributeListEntry *le; | 1467 | struct GNUNET_RECLAIM_AttributeListEntry *le; |
1412 | unsigned int attr_cnt = 0; | 1468 | unsigned int attr_cnt = 0; |
1413 | unsigned int cred_cnt = 0; | 1469 | unsigned int pres_cnt = 0; |
1414 | 1470 | ||
1415 | for (le = tih->attrs->list_head; NULL != le; le = le->next) | 1471 | for (le = tih->attrs->list_head; NULL != le; le = le->next) |
1416 | { | 1472 | { |
@@ -1422,6 +1478,7 @@ filter_tickets_cb (void *cls, | |||
1422 | // ticket search | 1478 | // ticket search |
1423 | unsigned int found_attrs_cnt = 0; | 1479 | unsigned int found_attrs_cnt = 0; |
1424 | unsigned int found_pres_cnt = 0; | 1480 | unsigned int found_pres_cnt = 0; |
1481 | ticket_presentations = GNUNET_new (struct GNUNET_RECLAIM_PresentationList); | ||
1425 | 1482 | ||
1426 | for (int i = 0; i < rd_count; i++) | 1483 | for (int i = 0; i < rd_count; i++) |
1427 | { | 1484 | { |
@@ -1450,15 +1507,65 @@ filter_tickets_cb (void *cls, | |||
1450 | found_attrs_cnt++; | 1507 | found_attrs_cnt++; |
1451 | } | 1508 | } |
1452 | } | 1509 | } |
1510 | if (GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL == rd[i].record_type) | ||
1511 | { | ||
1512 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
1513 | "Found credential...\n"); | ||
1514 | |||
1515 | for (le = tih->attrs->list_head; NULL != le; le = le->next) | ||
1516 | { | ||
1517 | cred = GNUNET_RECLAIM_credential_deserialize (rd[i].data, | ||
1518 | rd[i].data_size); | ||
1519 | if (GNUNET_YES != GNUNET_RECLAIM_id_is_equal (&cred->id, | ||
1520 | &le->attribute->credential)) | ||
1521 | { | ||
1522 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
1523 | "No match.\n"); | ||
1524 | GNUNET_free (cred); | ||
1525 | continue; | ||
1526 | } | ||
1527 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
1528 | "Match, creating presentation...\n"); | ||
1529 | if (GNUNET_OK != GNUNET_RECLAIM_credential_get_presentation ( | ||
1530 | cred, | ||
1531 | tih->attrs, | ||
1532 | &pres)) | ||
1533 | { | ||
1534 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
1535 | "Unable to retrieve presentation from credential\n"); | ||
1536 | GNUNET_free (cred); | ||
1537 | continue; | ||
1538 | } | ||
1539 | ple = GNUNET_new (struct GNUNET_RECLAIM_PresentationListEntry); | ||
1540 | ple->presentation = pres; | ||
1541 | GNUNET_CONTAINER_DLL_insert (tih->presentations->list_head, | ||
1542 | tih->presentations->list_tail, | ||
1543 | ple); | ||
1544 | GNUNET_free (cred); | ||
1545 | } | ||
1546 | } | ||
1453 | if (GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION == rd[i].record_type) | 1547 | if (GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION == rd[i].record_type) |
1454 | { | 1548 | { |
1455 | for (le = tih->attrs->list_head; NULL != le; le = le->next) | 1549 | for (le = tih->attrs->list_head; NULL != le; le = le->next) |
1456 | { | 1550 | { |
1457 | pres = rd[i].data; | 1551 | pres = GNUNET_RECLAIM_presentation_deserialize (rd[i].data, |
1458 | if (GNUNET_YES == GNUNET_RECLAIM_id_is_equal (pres->credential_id, | 1552 | rd[i].data_size); |
1553 | if (NULL == pres) | ||
1554 | { | ||
1555 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | ||
1556 | "Failed to deserialize presentation\n"); | ||
1557 | continue; | ||
1558 | } | ||
1559 | if (GNUNET_YES == GNUNET_RECLAIM_id_is_equal (&pres->credential_id, | ||
1459 | &le->attribute->credential)) | 1560 | &le->attribute->credential)) |
1561 | { | ||
1460 | found_pres_cnt++; | 1562 | found_pres_cnt++; |
1461 | // FIXME should we store credentials here for later use?? | 1563 | ple = GNUNET_new (struct GNUNET_RECLAIM_PresentationListEntry); |
1564 | ple->presentation = pres; | ||
1565 | GNUNET_CONTAINER_DLL_insert (ticket_presentations->list_head, | ||
1566 | ticket_presentations->list_tail, | ||
1567 | ple); | ||
1568 | } | ||
1462 | } | 1569 | } |
1463 | } | 1570 | } |
1464 | } | 1571 | } |
@@ -1472,7 +1579,8 @@ filter_tickets_cb (void *cls, | |||
1472 | (NULL != ticket)) | 1579 | (NULL != ticket)) |
1473 | { | 1580 | { |
1474 | GNUNET_NAMESTORE_zone_iteration_stop (tih->ns_it); | 1581 | GNUNET_NAMESTORE_zone_iteration_stop (tih->ns_it); |
1475 | tih->cb (tih->cb_cls, &tih->ticket, GNUNET_OK, NULL); | 1582 | tih->cb (tih->cb_cls, &tih->ticket, ticket_presentations, GNUNET_OK, NULL); |
1583 | GNUNET_RECLAIM_presentation_list_destroy (ticket_presentations); | ||
1476 | cleanup_issue_handle (tih); | 1584 | cleanup_issue_handle (tih); |
1477 | return; | 1585 | return; |
1478 | } | 1586 | } |
@@ -1524,6 +1632,7 @@ RECLAIM_TICKETS_issue (const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity, | |||
1524 | tih->cb = cb; | 1632 | tih->cb = cb; |
1525 | tih->cb_cls = cb_cls; | 1633 | tih->cb_cls = cb_cls; |
1526 | tih->attrs = GNUNET_RECLAIM_attribute_list_dup (attrs); | 1634 | tih->attrs = GNUNET_RECLAIM_attribute_list_dup (attrs); |
1635 | tih->presentations = GNUNET_new (struct GNUNET_RECLAIM_PresentationList); | ||
1527 | tih->identity = *identity; | 1636 | tih->identity = *identity; |
1528 | tih->ticket.audience = *audience; | 1637 | tih->ticket.audience = *audience; |
1529 | 1638 | ||
@@ -1541,8 +1650,8 @@ RECLAIM_TICKETS_issue (const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity, | |||
1541 | 1650 | ||
1542 | 1651 | ||
1543 | /************************************ | 1652 | /************************************ |
1544 | * Ticket iteration | 1653 | * Ticket iteration |
1545 | ************************************/ | 1654 | ************************************/ |
1546 | 1655 | ||
1547 | /** | 1656 | /** |
1548 | * Cleanup ticket iterator | 1657 | * Cleanup ticket iterator |
diff --git a/src/reclaim/gnunet-service-reclaim_tickets.h b/src/reclaim/gnunet-service-reclaim_tickets.h index 404b9c837..0dd790fc7 100644 --- a/src/reclaim/gnunet-service-reclaim_tickets.h +++ b/src/reclaim/gnunet-service-reclaim_tickets.h | |||
@@ -113,6 +113,7 @@ typedef void (*RECLAIM_TICKETS_TicketIter) ( | |||
113 | * | 113 | * |
114 | * @param cls closure | 114 | * @param cls closure |
115 | * @param ticket the ticket | 115 | * @param ticket the ticket |
116 | * @param presentations new presentations for ticket (NULL on error) | ||
116 | * @param success #GNUNET_SYSERR on failure (including timeout/queue | 117 | * @param success #GNUNET_SYSERR on failure (including timeout/queue |
117 | * drop/failure to validate) #GNUNET_OK on success | 118 | * drop/failure to validate) #GNUNET_OK on success |
118 | * @param emsg NULL on success, otherwise an error message | 119 | * @param emsg NULL on success, otherwise an error message |
@@ -120,6 +121,7 @@ typedef void (*RECLAIM_TICKETS_TicketIter) ( | |||
120 | typedef void (*RECLAIM_TICKETS_TicketResult) ( | 121 | typedef void (*RECLAIM_TICKETS_TicketResult) ( |
121 | void *cls, | 122 | void *cls, |
122 | struct GNUNET_RECLAIM_Ticket *ticket, | 123 | struct GNUNET_RECLAIM_Ticket *ticket, |
124 | struct GNUNET_RECLAIM_PresentationList *presentations, | ||
123 | int32_t success, | 125 | int32_t success, |
124 | const char *emsg); | 126 | const char *emsg); |
125 | 127 | ||
@@ -129,7 +131,8 @@ typedef void (*RECLAIM_TICKETS_TicketResult) ( | |||
129 | * | 131 | * |
130 | * @param cls closure | 132 | * @param cls closure |
131 | * @param identity the issuer of the ticket/attributes | 133 | * @param identity the issuer of the ticket/attributes |
132 | * @param l attribute list retrieved through ticket | 134 | * @param attributes attribute list retrieved through ticket |
135 | * @param presentations attribute presentations (may be NULL) | ||
133 | * @param success GNUNET_OK on success | 136 | * @param success GNUNET_OK on success |
134 | * @param emsg error message (NULL on success) | 137 | * @param emsg error message (NULL on success) |
135 | */ | 138 | */ |
@@ -137,7 +140,7 @@ typedef void (*RECLAIM_TICKETS_ConsumeCallback) ( | |||
137 | void *cls, | 140 | void *cls, |
138 | const struct GNUNET_CRYPTO_EcdsaPublicKey *identity, | 141 | const struct GNUNET_CRYPTO_EcdsaPublicKey *identity, |
139 | const struct GNUNET_RECLAIM_AttributeList *attributes, | 142 | const struct GNUNET_RECLAIM_AttributeList *attributes, |
140 | const struct GNUNET_RECLAIM_CredentialList *credentials, | 143 | const struct GNUNET_RECLAIM_PresentationList *presentations, |
141 | int32_t success, | 144 | int32_t success, |
142 | const char *emsg); | 145 | const char *emsg); |
143 | 146 | ||
diff --git a/src/reclaim/json_reclaim.c b/src/reclaim/json_reclaim.c index c8b944326..8a3479b8a 100644 --- a/src/reclaim/json_reclaim.c +++ b/src/reclaim/json_reclaim.c | |||
@@ -335,16 +335,16 @@ parse_credential (void *cls, json_t *root, struct GNUNET_JSON_Specification *spe | |||
335 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Credential value invalid!\n"); | 335 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Credential value invalid!\n"); |
336 | return GNUNET_SYSERR; | 336 | return GNUNET_SYSERR; |
337 | } | 337 | } |
338 | attr = GNUNET_RECLAIM_credential_new (name_str, type, data, data_size); | 338 | cred = GNUNET_RECLAIM_credential_new (name_str, type, data, data_size); |
339 | if ((NULL == id_str) || (0 == strlen (id_str))) | 339 | if ((NULL == id_str) || (0 == strlen (id_str))) |
340 | memset (&attr->id, 0, sizeof (attr->id)); | 340 | memset (&cred->id, 0, sizeof (cred->id)); |
341 | else | 341 | else |
342 | GNUNET_STRINGS_string_to_data (id_str, | 342 | GNUNET_STRINGS_string_to_data (id_str, |
343 | strlen (id_str), | 343 | strlen (id_str), |
344 | &attr->id, | 344 | &cred->id, |
345 | sizeof(attr->id)); | 345 | sizeof(cred->id)); |
346 | 346 | ||
347 | *(struct GNUNET_RECLAIM_Credential **) spec->ptr = attr; | 347 | *(struct GNUNET_RECLAIM_Credential **) spec->ptr = cred; |
348 | return GNUNET_OK; | 348 | return GNUNET_OK; |
349 | } | 349 | } |
350 | 350 | ||
@@ -383,7 +383,7 @@ GNUNET_RECLAIM_JSON_spec_credential (struct | |||
383 | .cleaner = &clean_credential, | 383 | .cleaner = &clean_credential, |
384 | .cls = NULL, | 384 | .cls = NULL, |
385 | .field = NULL, | 385 | .field = NULL, |
386 | .ptr = attr, | 386 | .ptr = cred, |
387 | .ptr_size = 0, | 387 | .ptr_size = 0, |
388 | .size_ptr = NULL }; | 388 | .size_ptr = NULL }; |
389 | 389 | ||
diff --git a/src/reclaim/json_reclaim.h b/src/reclaim/json_reclaim.h index 8911cf92d..613ddf873 100644 --- a/src/reclaim/json_reclaim.h +++ b/src/reclaim/json_reclaim.h | |||
@@ -54,4 +54,4 @@ GNUNET_RECLAIM_JSON_spec_ticket (struct GNUNET_RECLAIM_Ticket **ticket); | |||
54 | * @return JSON Specification | 54 | * @return JSON Specification |
55 | */ | 55 | */ |
56 | struct GNUNET_JSON_Specification | 56 | struct GNUNET_JSON_Specification |
57 | GNUNET_RECLAIM_JSON_spec_credential (struct GNUNET_RECLAIM_Attestation **cred); | 57 | GNUNET_RECLAIM_JSON_spec_credential (struct GNUNET_RECLAIM_Credential **cred); |
diff --git a/src/reclaim/oidc_helper.c b/src/reclaim/oidc_helper.c index 9c7e79c41..b307a358c 100644 --- a/src/reclaim/oidc_helper.c +++ b/src/reclaim/oidc_helper.c | |||
@@ -156,8 +156,8 @@ fix_base64 (char *str) | |||
156 | 156 | ||
157 | static json_t* | 157 | static json_t* |
158 | generate_userinfo_json(const struct GNUNET_CRYPTO_EcdsaPublicKey *sub_key, | 158 | generate_userinfo_json(const struct GNUNET_CRYPTO_EcdsaPublicKey *sub_key, |
159 | struct GNUNET_RECLAIM_AttributeList *attrs, | 159 | const struct GNUNET_RECLAIM_AttributeList *attrs, |
160 | struct GNUNET_RECLAIM_PresentationList *presentations) | 160 | const struct GNUNET_RECLAIM_PresentationList *presentations) |
161 | { | 161 | { |
162 | struct GNUNET_RECLAIM_AttributeListEntry *le; | 162 | struct GNUNET_RECLAIM_AttributeListEntry *le; |
163 | struct GNUNET_RECLAIM_PresentationListEntry *ple; | 163 | struct GNUNET_RECLAIM_PresentationListEntry *ple; |
@@ -296,8 +296,8 @@ generate_userinfo_json(const struct GNUNET_CRYPTO_EcdsaPublicKey *sub_key, | |||
296 | */ | 296 | */ |
297 | char * | 297 | char * |
298 | OIDC_generate_userinfo (const struct GNUNET_CRYPTO_EcdsaPublicKey *sub_key, | 298 | OIDC_generate_userinfo (const struct GNUNET_CRYPTO_EcdsaPublicKey *sub_key, |
299 | struct GNUNET_RECLAIM_AttributeList *attrs, | 299 | const struct GNUNET_RECLAIM_AttributeList *attrs, |
300 | struct GNUNET_RECLAIM_PresentationList *presentations) | 300 | const struct GNUNET_RECLAIM_PresentationList *presentations) |
301 | { | 301 | { |
302 | char *body_str; | 302 | char *body_str; |
303 | json_t* body = generate_userinfo_json (sub_key, | 303 | json_t* body = generate_userinfo_json (sub_key, |
@@ -323,8 +323,8 @@ OIDC_generate_userinfo (const struct GNUNET_CRYPTO_EcdsaPublicKey *sub_key, | |||
323 | char * | 323 | char * |
324 | OIDC_generate_id_token (const struct GNUNET_CRYPTO_EcdsaPublicKey *aud_key, | 324 | OIDC_generate_id_token (const struct GNUNET_CRYPTO_EcdsaPublicKey *aud_key, |
325 | const struct GNUNET_CRYPTO_EcdsaPublicKey *sub_key, | 325 | const struct GNUNET_CRYPTO_EcdsaPublicKey *sub_key, |
326 | struct GNUNET_RECLAIM_AttributeList *attrs, | 326 | const struct GNUNET_RECLAIM_AttributeList *attrs, |
327 | struct GNUNET_RECLAIM_PresentationList *presentations, | 327 | const struct GNUNET_RECLAIM_PresentationList *presentations, |
328 | const struct GNUNET_TIME_Relative *expiration_time, | 328 | const struct GNUNET_TIME_Relative *expiration_time, |
329 | const char *nonce, | 329 | const char *nonce, |
330 | const char *secret_key) | 330 | const char *secret_key) |
@@ -440,8 +440,8 @@ OIDC_generate_id_token (const struct GNUNET_CRYPTO_EcdsaPublicKey *aud_key, | |||
440 | char * | 440 | char * |
441 | OIDC_build_authz_code (const struct GNUNET_CRYPTO_EcdsaPrivateKey *issuer, | 441 | OIDC_build_authz_code (const struct GNUNET_CRYPTO_EcdsaPrivateKey *issuer, |
442 | const struct GNUNET_RECLAIM_Ticket *ticket, | 442 | const struct GNUNET_RECLAIM_Ticket *ticket, |
443 | struct GNUNET_RECLAIM_AttributeList *attrs, | 443 | const struct GNUNET_RECLAIM_AttributeList *attrs, |
444 | struct GNUNET_RECLAIM_PresentationList *presentations, | 444 | const struct GNUNET_RECLAIM_PresentationList *presentations, |
445 | const char *nonce_str, | 445 | const char *nonce_str, |
446 | const char *code_challenge) | 446 | const char *code_challenge) |
447 | { | 447 | { |
@@ -596,7 +596,7 @@ OIDC_parse_authz_code (const struct GNUNET_CRYPTO_EcdsaPublicKey *audience, | |||
596 | struct GNUNET_CRYPTO_EcdsaSignature *signature; | 596 | struct GNUNET_CRYPTO_EcdsaSignature *signature; |
597 | uint32_t code_challenge_len; | 597 | uint32_t code_challenge_len; |
598 | uint32_t attrs_ser_len; | 598 | uint32_t attrs_ser_len; |
599 | uint32_t presentations_ser_len; | 599 | uint32_t pres_ser_len; |
600 | size_t plaintext_len; | 600 | size_t plaintext_len; |
601 | size_t code_payload_len; | 601 | size_t code_payload_len; |
602 | uint32_t nonce_len = 0; | 602 | uint32_t nonce_len = 0; |
@@ -702,8 +702,8 @@ OIDC_parse_authz_code (const struct GNUNET_CRYPTO_EcdsaPublicKey *audience, | |||
702 | presentations_ser = ((char*) attrs_ser) + attrs_ser_len; | 702 | presentations_ser = ((char*) attrs_ser) + attrs_ser_len; |
703 | pres_ser_len = ntohl (params->pres_list_len); | 703 | pres_ser_len = ntohl (params->pres_list_len); |
704 | *presentations = | 704 | *presentations = |
705 | GNUNET_RECLAIM_presentations_list_deserialize (presentations_ser, | 705 | GNUNET_RECLAIM_presentation_list_deserialize (presentations_ser, |
706 | pres_ser_len); | 706 | pres_ser_len); |
707 | 707 | ||
708 | GNUNET_free (code_payload); | 708 | GNUNET_free (code_payload); |
709 | return GNUNET_OK; | 709 | return GNUNET_OK; |
diff --git a/src/reclaim/oidc_helper.h b/src/reclaim/oidc_helper.h index 789a2acc7..10a6f3d1f 100644 --- a/src/reclaim/oidc_helper.h +++ b/src/reclaim/oidc_helper.h | |||
@@ -52,8 +52,8 @@ | |||
52 | char* | 52 | char* |
53 | OIDC_generate_id_token (const struct GNUNET_CRYPTO_EcdsaPublicKey *aud_key, | 53 | OIDC_generate_id_token (const struct GNUNET_CRYPTO_EcdsaPublicKey *aud_key, |
54 | const struct GNUNET_CRYPTO_EcdsaPublicKey *sub_key, | 54 | const struct GNUNET_CRYPTO_EcdsaPublicKey *sub_key, |
55 | struct GNUNET_RECLAIM_AttributeList *attrs, | 55 | const struct GNUNET_RECLAIM_AttributeList *attrs, |
56 | struct GNUNET_RECLAIM_PresentationList *presentations, | 56 | const struct GNUNET_RECLAIM_PresentationList *presentations, |
57 | const struct GNUNET_TIME_Relative *expiration_time, | 57 | const struct GNUNET_TIME_Relative *expiration_time, |
58 | const char *nonce, | 58 | const char *nonce, |
59 | const char *secret_key); | 59 | const char *secret_key); |
@@ -73,8 +73,8 @@ OIDC_generate_id_token (const struct GNUNET_CRYPTO_EcdsaPublicKey *aud_key, | |||
73 | char* | 73 | char* |
74 | OIDC_build_authz_code (const struct GNUNET_CRYPTO_EcdsaPrivateKey *issuer, | 74 | OIDC_build_authz_code (const struct GNUNET_CRYPTO_EcdsaPrivateKey *issuer, |
75 | const struct GNUNET_RECLAIM_Ticket *ticket, | 75 | const struct GNUNET_RECLAIM_Ticket *ticket, |
76 | struct GNUNET_RECLAIM_AttributeList *attrs, | 76 | const struct GNUNET_RECLAIM_AttributeList *attrs, |
77 | struct GNUNET_RECLAIM_PresentationList *presentations, | 77 | const struct GNUNET_RECLAIM_PresentationList *presentations, |
78 | const char *nonce, | 78 | const char *nonce, |
79 | const char *code_challenge); | 79 | const char *code_challenge); |
80 | 80 | ||
@@ -139,8 +139,8 @@ OIDC_access_token_parse (const char* token, | |||
139 | * @return GNUNET_YES if attribute is implcitly requested | 139 | * @return GNUNET_YES if attribute is implcitly requested |
140 | */ | 140 | */ |
141 | enum GNUNET_GenericReturnValue | 141 | enum GNUNET_GenericReturnValue |
142 | OIDC_check_scopes_for_claim_request (const char*scopes, | 142 | OIDC_check_scopes_for_claim_request (const char *scopes, |
143 | const char*attr); | 143 | const char *attr); |
144 | 144 | ||
145 | 145 | ||
146 | /** | 146 | /** |
@@ -153,7 +153,7 @@ OIDC_check_scopes_for_claim_request (const char*scopes, | |||
153 | */ | 153 | */ |
154 | char * | 154 | char * |
155 | OIDC_generate_userinfo (const struct GNUNET_CRYPTO_EcdsaPublicKey *sub_key, | 155 | OIDC_generate_userinfo (const struct GNUNET_CRYPTO_EcdsaPublicKey *sub_key, |
156 | struct GNUNET_RECLAIM_AttributeList *attrs, | 156 | const struct GNUNET_RECLAIM_AttributeList *attrs, |
157 | struct GNUNET_RECLAIM_PresentationList *presentations); | 157 | const struct GNUNET_RECLAIM_PresentationList *presentations); |
158 | 158 | ||
159 | #endif | 159 | #endif |
diff --git a/src/reclaim/plugin_gnsrecord_reclaim.c b/src/reclaim/plugin_gnsrecord_reclaim.c index b91e123a3..60c49fd6a 100644 --- a/src/reclaim/plugin_gnsrecord_reclaim.c +++ b/src/reclaim/plugin_gnsrecord_reclaim.c | |||
@@ -51,8 +51,8 @@ value_to_string (void *cls, uint32_t type, const void *data, size_t data_size) | |||
51 | case GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF: | 51 | case GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF: |
52 | case GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET: | 52 | case GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET: |
53 | case GNUNET_GNSRECORD_TYPE_RECLAIM_MASTER: | 53 | case GNUNET_GNSRECORD_TYPE_RECLAIM_MASTER: |
54 | case GNUNET_GNSRECORD_TYPE_RECLAIM_ATTESTATION: | 54 | case GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL: |
55 | case GNUNET_GNSRECORD_TYPE_RECLAIM_ATTESTATION_REF: | 55 | case GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION: |
56 | return GNUNET_STRINGS_data_to_string_alloc (data, data_size); | 56 | return GNUNET_STRINGS_data_to_string_alloc (data, data_size); |
57 | 57 | ||
58 | default: | 58 | default: |
@@ -89,8 +89,8 @@ string_to_value (void *cls, uint32_t type, const char *s, void **data, | |||
89 | case GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF: | 89 | case GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF: |
90 | case GNUNET_GNSRECORD_TYPE_RECLAIM_MASTER: | 90 | case GNUNET_GNSRECORD_TYPE_RECLAIM_MASTER: |
91 | case GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET: | 91 | case GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET: |
92 | case GNUNET_GNSRECORD_TYPE_RECLAIM_ATTESTATION: | 92 | case GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL: |
93 | case GNUNET_GNSRECORD_TYPE_RECLAIM_ATTESTATION_REF: | 93 | case GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION: |
94 | return GNUNET_STRINGS_string_to_data (s, strlen (s), *data, *data_size); | 94 | return GNUNET_STRINGS_string_to_data (s, strlen (s), *data, *data_size); |
95 | 95 | ||
96 | default: | 96 | default: |
@@ -110,8 +110,8 @@ static struct | |||
110 | } name_map[] = { | 110 | } name_map[] = { |
111 | { "RECLAIM_ATTRIBUTE", GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE }, | 111 | { "RECLAIM_ATTRIBUTE", GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE }, |
112 | { "RECLAIM_ATTRIBUTE_REF", GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF }, | 112 | { "RECLAIM_ATTRIBUTE_REF", GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF }, |
113 | { "RECLAIM_ATTESTATION", GNUNET_GNSRECORD_TYPE_RECLAIM_ATTESTATION }, | 113 | { "RECLAIM_CREDENTIAL", GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL }, |
114 | { "RECLAIM_ATTESTATION_REF", GNUNET_GNSRECORD_TYPE_RECLAIM_ATTESTATION_REF }, | 114 | { "RECLAIM_PRESENTATION", GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION }, |
115 | { "RECLAIM_MASTER", GNUNET_GNSRECORD_TYPE_RECLAIM_MASTER }, | 115 | { "RECLAIM_MASTER", GNUNET_GNSRECORD_TYPE_RECLAIM_MASTER }, |
116 | { "RECLAIM_OIDC_CLIENT", GNUNET_GNSRECORD_TYPE_RECLAIM_OIDC_CLIENT }, | 116 | { "RECLAIM_OIDC_CLIENT", GNUNET_GNSRECORD_TYPE_RECLAIM_OIDC_CLIENT }, |
117 | { "RECLAIM_OIDC_REDIRECT", GNUNET_GNSRECORD_TYPE_RECLAIM_OIDC_REDIRECT }, | 117 | { "RECLAIM_OIDC_REDIRECT", GNUNET_GNSRECORD_TYPE_RECLAIM_OIDC_REDIRECT }, |
diff --git a/src/reclaim/plugin_reclaim_credential_jwt.c b/src/reclaim/plugin_reclaim_credential_jwt.c index 38effcf78..148865223 100644 --- a/src/reclaim/plugin_reclaim_credential_jwt.c +++ b/src/reclaim/plugin_reclaim_credential_jwt.c | |||
@@ -48,7 +48,7 @@ jwt_value_to_string (void *cls, | |||
48 | { | 48 | { |
49 | switch (type) | 49 | switch (type) |
50 | { | 50 | { |
51 | case GNUNET_RECLAIM_credential_TYPE_JWT: | 51 | case GNUNET_RECLAIM_CREDENTIAL_TYPE_JWT: |
52 | return GNUNET_strndup (data, data_size); | 52 | return GNUNET_strndup (data, data_size); |
53 | 53 | ||
54 | default: | 54 | default: |
@@ -79,7 +79,7 @@ jwt_string_to_value (void *cls, | |||
79 | return GNUNET_SYSERR; | 79 | return GNUNET_SYSERR; |
80 | switch (type) | 80 | switch (type) |
81 | { | 81 | { |
82 | case GNUNET_RECLAIM_credential_TYPE_JWT: | 82 | case GNUNET_RECLAIM_CREDENTIAL_TYPE_JWT: |
83 | *data = GNUNET_strdup (s); | 83 | *data = GNUNET_strdup (s); |
84 | *data_size = strlen (s); | 84 | *data_size = strlen (s); |
85 | return GNUNET_OK; | 85 | return GNUNET_OK; |
@@ -98,8 +98,8 @@ static struct | |||
98 | { | 98 | { |
99 | const char *name; | 99 | const char *name; |
100 | uint32_t number; | 100 | uint32_t number; |
101 | } jwt_cred_name_map[] = { { "JWT", GNUNET_RECLAIM_credential_TYPE_JWT }, | 101 | } jwt_cred_name_map[] = { { "JWT", GNUNET_RECLAIM_CREDENTIAL_TYPE_JWT }, |
102 | { NULL, UINT32_MAX } }; | 102 | { NULL, UINT32_MAX } }; |
103 | 103 | ||
104 | /** | 104 | /** |
105 | * Convert a type name to the corresponding number. | 105 | * Convert a type name to the corresponding number. |
@@ -135,8 +135,8 @@ jwt_number_to_typename (void *cls, uint32_t type) | |||
135 | 135 | ||
136 | i = 0; | 136 | i = 0; |
137 | while ((NULL != jwt_cred_name_map[i].name) && (type != | 137 | while ((NULL != jwt_cred_name_map[i].name) && (type != |
138 | jwt_cred_name_map[i]. | 138 | jwt_cred_name_map[i]. |
139 | number)) | 139 | number)) |
140 | i++; | 140 | i++; |
141 | return jwt_cred_name_map[i].name; | 141 | return jwt_cred_name_map[i].name; |
142 | } | 142 | } |
@@ -151,7 +151,7 @@ jwt_number_to_typename (void *cls, uint32_t type) | |||
151 | */ | 151 | */ |
152 | struct GNUNET_RECLAIM_AttributeList * | 152 | struct GNUNET_RECLAIM_AttributeList * |
153 | jwt_parse_attributes (void *cls, | 153 | jwt_parse_attributes (void *cls, |
154 | const struct GNUNET_RECLAIM_Credential *cred) | 154 | const char *data) |
155 | { | 155 | { |
156 | char *jwt_string; | 156 | char *jwt_string; |
157 | struct GNUNET_RECLAIM_AttributeList *attrs; | 157 | struct GNUNET_RECLAIM_AttributeList *attrs; |
@@ -162,17 +162,14 @@ jwt_parse_attributes (void *cls, | |||
162 | json_t *json_val; | 162 | json_t *json_val; |
163 | json_error_t *json_err = NULL; | 163 | json_error_t *json_err = NULL; |
164 | 164 | ||
165 | /* GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "%s\n", cred->data); (not OK: 'data' is not defined as 0-terminated text, but binary) */ | ||
166 | if (GNUNET_RECLAIM_credential_TYPE_JWT != cred->type) | ||
167 | return NULL; | ||
168 | attrs = GNUNET_new (struct GNUNET_RECLAIM_AttributeList); | 165 | attrs = GNUNET_new (struct GNUNET_RECLAIM_AttributeList); |
169 | 166 | ||
170 | jwt_string = GNUNET_strdup (cred->data); | 167 | jwt_string = GNUNET_strdup (data); |
171 | const char *jwt_body = strtok (jwt_string, delim); | 168 | const char *jwt_body = strtok (jwt_string, delim); |
172 | jwt_body = strtok (NULL, delim); | 169 | jwt_body = strtok (NULL, delim); |
173 | GNUNET_STRINGS_base64url_decode (jwt_body, strlen (jwt_body), | 170 | GNUNET_STRINGS_base64url_decode (jwt_body, strlen (jwt_body), |
174 | (void **) &decoded_jwt); | 171 | (void **) &decoded_jwt); |
175 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s\n", decoded_jwt); | 172 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Decoded JWT: %s\n", decoded_jwt); |
176 | GNUNET_assert (NULL != decoded_jwt); | 173 | GNUNET_assert (NULL != decoded_jwt); |
177 | json_val = json_loads (decoded_jwt, JSON_DECODE_ANY, json_err); | 174 | json_val = json_loads (decoded_jwt, JSON_DECODE_ANY, json_err); |
178 | const char *key; | 175 | const char *key; |
@@ -203,6 +200,36 @@ jwt_parse_attributes (void *cls, | |||
203 | 200 | ||
204 | 201 | ||
205 | /** | 202 | /** |
203 | * Parse a JWT and return the respective claim value as Attribute | ||
204 | * | ||
205 | * @param cls the plugin | ||
206 | * @param cred the jwt credential | ||
207 | * @return a GNUNET_RECLAIM_Attribute, containing the new value | ||
208 | */ | ||
209 | struct GNUNET_RECLAIM_AttributeList * | ||
210 | jwt_parse_attributes_c (void *cls, | ||
211 | const struct GNUNET_RECLAIM_Credential *cred) | ||
212 | { | ||
213 | return jwt_parse_attributes (cls, cred->data); | ||
214 | } | ||
215 | |||
216 | |||
217 | /** | ||
218 | * Parse a JWT and return the respective claim value as Attribute | ||
219 | * | ||
220 | * @param cls the plugin | ||
221 | * @param cred the jwt credential | ||
222 | * @return a GNUNET_RECLAIM_Attribute, containing the new value | ||
223 | */ | ||
224 | struct GNUNET_RECLAIM_AttributeList * | ||
225 | jwt_parse_attributes_p (void *cls, | ||
226 | const struct GNUNET_RECLAIM_Presentation *cred) | ||
227 | { | ||
228 | return jwt_parse_attributes (cls, cred->data); | ||
229 | } | ||
230 | |||
231 | |||
232 | /** | ||
206 | * Parse a JWT and return the issuer | 233 | * Parse a JWT and return the issuer |
207 | * | 234 | * |
208 | * @param cls the plugin | 235 | * @param cls the plugin |
@@ -211,7 +238,7 @@ jwt_parse_attributes (void *cls, | |||
211 | */ | 238 | */ |
212 | char * | 239 | char * |
213 | jwt_get_issuer (void *cls, | 240 | jwt_get_issuer (void *cls, |
214 | const struct GNUNET_RECLAIM_Credential *cred) | 241 | const char *data) |
215 | { | 242 | { |
216 | const char *jwt_body; | 243 | const char *jwt_body; |
217 | char *jwt_string; | 244 | char *jwt_string; |
@@ -223,9 +250,7 @@ jwt_get_issuer (void *cls, | |||
223 | json_t *json_val; | 250 | json_t *json_val; |
224 | json_error_t *json_err = NULL; | 251 | json_error_t *json_err = NULL; |
225 | 252 | ||
226 | if (GNUNET_RECLAIM_credential_TYPE_JWT != cred->type) | 253 | jwt_string = GNUNET_strdup (data); |
227 | return NULL; | ||
228 | jwt_string = GNUNET_strdup (cred->data); | ||
229 | jwt_body = strtok (jwt_string, delim); | 254 | jwt_body = strtok (jwt_string, delim); |
230 | jwt_body = strtok (NULL, delim); | 255 | jwt_body = strtok (NULL, delim); |
231 | GNUNET_STRINGS_base64url_decode (jwt_body, strlen (jwt_body), | 256 | GNUNET_STRINGS_base64url_decode (jwt_body, strlen (jwt_body), |
@@ -241,6 +266,40 @@ jwt_get_issuer (void *cls, | |||
241 | 266 | ||
242 | 267 | ||
243 | /** | 268 | /** |
269 | * Parse a JWT and return the issuer | ||
270 | * | ||
271 | * @param cls the plugin | ||
272 | * @param cred the jwt credential | ||
273 | * @return a string, containing the isser | ||
274 | */ | ||
275 | char * | ||
276 | jwt_get_issuer_c (void *cls, | ||
277 | const struct GNUNET_RECLAIM_Credential *cred) | ||
278 | { | ||
279 | if (GNUNET_RECLAIM_CREDENTIAL_TYPE_JWT != cred->type) | ||
280 | return NULL; | ||
281 | return jwt_get_issuer (cls, cred->data); | ||
282 | } | ||
283 | |||
284 | |||
285 | /** | ||
286 | * Parse a JWT and return the issuer | ||
287 | * | ||
288 | * @param cls the plugin | ||
289 | * @param cred the jwt credential | ||
290 | * @return a string, containing the isser | ||
291 | */ | ||
292 | char * | ||
293 | jwt_get_issuer_p (void *cls, | ||
294 | const struct GNUNET_RECLAIM_Presentation *cred) | ||
295 | { | ||
296 | if (GNUNET_RECLAIM_CREDENTIAL_TYPE_JWT != cred->type) | ||
297 | return NULL; | ||
298 | return jwt_get_issuer (cls, cred->data); | ||
299 | } | ||
300 | |||
301 | |||
302 | /** | ||
244 | * Parse a JWT and return the expiration | 303 | * Parse a JWT and return the expiration |
245 | * | 304 | * |
246 | * @param cls the plugin | 305 | * @param cls the plugin |
@@ -249,7 +308,7 @@ jwt_get_issuer (void *cls, | |||
249 | */ | 308 | */ |
250 | int | 309 | int |
251 | jwt_get_expiration (void *cls, | 310 | jwt_get_expiration (void *cls, |
252 | const struct GNUNET_RECLAIM_Credential *cred, | 311 | const char *data, |
253 | struct GNUNET_TIME_Absolute *exp) | 312 | struct GNUNET_TIME_Absolute *exp) |
254 | { | 313 | { |
255 | const char *jwt_body; | 314 | const char *jwt_body; |
@@ -261,9 +320,7 @@ jwt_get_expiration (void *cls, | |||
261 | json_t *json_val; | 320 | json_t *json_val; |
262 | json_error_t *json_err = NULL; | 321 | json_error_t *json_err = NULL; |
263 | 322 | ||
264 | if (GNUNET_RECLAIM_credential_TYPE_JWT != cred->type) | 323 | jwt_string = GNUNET_strdup (data); |
265 | return GNUNET_NO; | ||
266 | jwt_string = GNUNET_strdup (cred->data); | ||
267 | jwt_body = strtok (jwt_string, delim); | 324 | jwt_body = strtok (jwt_string, delim); |
268 | jwt_body = strtok (NULL, delim); | 325 | jwt_body = strtok (NULL, delim); |
269 | GNUNET_STRINGS_base64url_decode (jwt_body, strlen (jwt_body), | 326 | GNUNET_STRINGS_base64url_decode (jwt_body, strlen (jwt_body), |
@@ -279,6 +336,54 @@ jwt_get_expiration (void *cls, | |||
279 | 336 | ||
280 | 337 | ||
281 | /** | 338 | /** |
339 | * Parse a JWT and return the expiration | ||
340 | * | ||
341 | * @param cls the plugin | ||
342 | * @param cred the jwt credential | ||
343 | * @return a string, containing the isser | ||
344 | */ | ||
345 | int | ||
346 | jwt_get_expiration_c (void *cls, | ||
347 | const struct GNUNET_RECLAIM_Credential *cred, | ||
348 | struct GNUNET_TIME_Absolute *exp) | ||
349 | { | ||
350 | return jwt_get_expiration (cls, cred->data, exp); | ||
351 | } | ||
352 | |||
353 | |||
354 | /** | ||
355 | * Parse a JWT and return the expiration | ||
356 | * | ||
357 | * @param cls the plugin | ||
358 | * @param cred the jwt credential | ||
359 | * @return a string, containing the isser | ||
360 | */ | ||
361 | int | ||
362 | jwt_get_expiration_p (void *cls, | ||
363 | const struct GNUNET_RECLAIM_Presentation *cred, | ||
364 | struct GNUNET_TIME_Absolute *exp) | ||
365 | { | ||
366 | return jwt_get_expiration (cls, cred->data, exp); | ||
367 | } | ||
368 | |||
369 | |||
370 | int | ||
371 | jwt_create_presentation (void *cls, | ||
372 | const struct GNUNET_RECLAIM_Credential *cred, | ||
373 | const struct GNUNET_RECLAIM_AttributeList *attrs, | ||
374 | struct GNUNET_RECLAIM_Presentation **pres) | ||
375 | { | ||
376 | // FIXME sanity checks?? | ||
377 | if (GNUNET_RECLAIM_CREDENTIAL_TYPE_JWT != cred->type) | ||
378 | return GNUNET_NO; | ||
379 | *pres = GNUNET_RECLAIM_presentation_new (GNUNET_RECLAIM_CREDENTIAL_TYPE_JWT, | ||
380 | cred->data, | ||
381 | cred->data_size); | ||
382 | return GNUNET_OK; | ||
383 | } | ||
384 | |||
385 | |||
386 | /** | ||
282 | * Entry point for the plugin. | 387 | * Entry point for the plugin. |
283 | * | 388 | * |
284 | * @param cls NULL | 389 | * @param cls NULL |
@@ -294,9 +399,17 @@ libgnunet_plugin_reclaim_credential_jwt_init (void *cls) | |||
294 | api->string_to_value = &jwt_string_to_value; | 399 | api->string_to_value = &jwt_string_to_value; |
295 | api->typename_to_number = &jwt_typename_to_number; | 400 | api->typename_to_number = &jwt_typename_to_number; |
296 | api->number_to_typename = &jwt_number_to_typename; | 401 | api->number_to_typename = &jwt_number_to_typename; |
297 | api->get_attributes = &jwt_parse_attributes; | 402 | api->get_attributes = &jwt_parse_attributes_c; |
298 | api->get_issuer = &jwt_get_issuer; | 403 | api->get_issuer = &jwt_get_issuer_c; |
299 | api->get_expiration = &jwt_get_expiration; | 404 | api->get_expiration = &jwt_get_expiration_c; |
405 | api->value_to_string_p = &jwt_value_to_string; | ||
406 | api->string_to_value_p = &jwt_string_to_value; | ||
407 | api->typename_to_number_p = &jwt_typename_to_number; | ||
408 | api->number_to_typename_p = &jwt_number_to_typename; | ||
409 | api->get_attributes_p = &jwt_parse_attributes_p; | ||
410 | api->get_issuer_p = &jwt_get_issuer_p; | ||
411 | api->get_expiration_p = &jwt_get_expiration_p; | ||
412 | api->create_presentation = &jwt_create_presentation; | ||
300 | return api; | 413 | return api; |
301 | } | 414 | } |
302 | 415 | ||
diff --git a/src/reclaim/plugin_rest_openid_connect.c b/src/reclaim/plugin_rest_openid_connect.c index 5ae6565af..5b0bb2b6f 100644 --- a/src/reclaim/plugin_rest_openid_connect.c +++ b/src/reclaim/plugin_rest_openid_connect.c | |||
@@ -439,10 +439,14 @@ struct RequestHandle | |||
439 | struct GNUNET_RECLAIM_AttributeList *attr_userinfo_list; | 439 | struct GNUNET_RECLAIM_AttributeList *attr_userinfo_list; |
440 | 440 | ||
441 | /** | 441 | /** |
442 | * Credential list | 442 | * Credentials |
443 | */ | 443 | */ |
444 | struct GNUNET_RECLAIM_CredentialList *creds_list; | 444 | struct GNUNET_RECLAIM_CredentialList *credentials; |
445 | 445 | ||
446 | /** | ||
447 | * Presentations | ||
448 | */ | ||
449 | struct GNUNET_RECLAIM_PresentationList *presentations; | ||
446 | 450 | ||
447 | /** | 451 | /** |
448 | * IDENTITY Operation | 452 | * IDENTITY Operation |
@@ -590,8 +594,10 @@ cleanup_handle (struct RequestHandle *handle) | |||
590 | GNUNET_RECLAIM_attribute_list_destroy (handle->attr_idtoken_list); | 594 | GNUNET_RECLAIM_attribute_list_destroy (handle->attr_idtoken_list); |
591 | if (NULL!=handle->attr_userinfo_list) | 595 | if (NULL!=handle->attr_userinfo_list) |
592 | GNUNET_RECLAIM_attribute_list_destroy (handle->attr_userinfo_list); | 596 | GNUNET_RECLAIM_attribute_list_destroy (handle->attr_userinfo_list); |
593 | if (NULL!=handle->creds_list) | 597 | if (NULL!=handle->credentials) |
594 | GNUNET_RECLAIM_credential_list_destroy (handle->creds_list); | 598 | GNUNET_RECLAIM_credential_list_destroy (handle->credentials); |
599 | if (NULL!=handle->presentations) | ||
600 | GNUNET_RECLAIM_presentation_list_destroy (handle->presentations); | ||
595 | GNUNET_CONTAINER_DLL_remove (requests_head, | 601 | GNUNET_CONTAINER_DLL_remove (requests_head, |
596 | requests_tail, | 602 | requests_tail, |
597 | handle); | 603 | handle); |
@@ -934,7 +940,9 @@ oidc_iteration_error (void *cls) | |||
934 | * parameter. Otherwise redirects with error | 940 | * parameter. Otherwise redirects with error |
935 | */ | 941 | */ |
936 | static void | 942 | static void |
937 | oidc_ticket_issue_cb (void *cls, const struct GNUNET_RECLAIM_Ticket *ticket) | 943 | oidc_ticket_issue_cb (void *cls, |
944 | const struct GNUNET_RECLAIM_Ticket *ticket, | ||
945 | const struct GNUNET_RECLAIM_PresentationList *pres) | ||
938 | { | 946 | { |
939 | struct RequestHandle *handle = cls; | 947 | struct RequestHandle *handle = cls; |
940 | struct MHD_Response *resp; | 948 | struct MHD_Response *resp; |
@@ -957,7 +965,7 @@ oidc_ticket_issue_cb (void *cls, const struct GNUNET_RECLAIM_Ticket *ticket) | |||
957 | code_string = OIDC_build_authz_code (&handle->priv_key, | 965 | code_string = OIDC_build_authz_code (&handle->priv_key, |
958 | &handle->ticket, | 966 | &handle->ticket, |
959 | handle->attr_idtoken_list, | 967 | handle->attr_idtoken_list, |
960 | handle->creds_list, | 968 | pres, |
961 | handle->oidc->nonce, | 969 | handle->oidc->nonce, |
962 | handle->oidc->code_challenge); | 970 | handle->oidc->code_challenge); |
963 | if ((NULL != handle->redirect_prefix) && (NULL != handle->redirect_suffix) && | 971 | if ((NULL != handle->redirect_prefix) && (NULL != handle->redirect_suffix) && |
@@ -1086,7 +1094,7 @@ oidc_cred_collect (void *cls, | |||
1086 | struct GNUNET_RECLAIM_AttributeListEntry *le; | 1094 | struct GNUNET_RECLAIM_AttributeListEntry *le; |
1087 | struct GNUNET_RECLAIM_CredentialListEntry *ale; | 1095 | struct GNUNET_RECLAIM_CredentialListEntry *ale; |
1088 | 1096 | ||
1089 | for (ale = handle->creds_list->list_head; NULL != ale; ale = ale->next) | 1097 | for (ale = handle->credentials->list_head; NULL != ale; ale = ale->next) |
1090 | { | 1098 | { |
1091 | if (GNUNET_NO == GNUNET_RECLAIM_id_is_equal (&ale->credential->id, | 1099 | if (GNUNET_NO == GNUNET_RECLAIM_id_is_equal (&ale->credential->id, |
1092 | &cred->id)) | 1100 | &cred->id)) |
@@ -1107,8 +1115,8 @@ oidc_cred_collect (void *cls, | |||
1107 | cred->type, | 1115 | cred->type, |
1108 | cred->data, | 1116 | cred->data, |
1109 | cred->data_size); | 1117 | cred->data_size); |
1110 | GNUNET_CONTAINER_DLL_insert (handle->creds_list->list_head, | 1118 | GNUNET_CONTAINER_DLL_insert (handle->credentials->list_head, |
1111 | handle->creds_list->list_tail, | 1119 | handle->credentials->list_tail, |
1112 | ale); | 1120 | ale); |
1113 | } | 1121 | } |
1114 | GNUNET_RECLAIM_get_credentials_next (handle->cred_it); | 1122 | GNUNET_RECLAIM_get_credentials_next (handle->cred_it); |
@@ -1129,7 +1137,7 @@ oidc_attr_collect_finished_cb (void *cls) | |||
1129 | GNUNET_SCHEDULER_add_now (&do_redirect_error, handle); | 1137 | GNUNET_SCHEDULER_add_now (&do_redirect_error, handle); |
1130 | return; | 1138 | return; |
1131 | } | 1139 | } |
1132 | handle->creds_list = GNUNET_new (struct GNUNET_RECLAIM_CredentialList); | 1140 | handle->credentials = GNUNET_new (struct GNUNET_RECLAIM_CredentialList); |
1133 | handle->cred_it = | 1141 | handle->cred_it = |
1134 | GNUNET_RECLAIM_get_credentials_start (idp, | 1142 | GNUNET_RECLAIM_get_credentials_start (idp, |
1135 | &handle->priv_key, | 1143 | &handle->priv_key, |
@@ -1982,7 +1990,7 @@ token_endpoint (struct GNUNET_REST_RequestHandle *con_handle, | |||
1982 | const struct EgoEntry *ego_entry; | 1990 | const struct EgoEntry *ego_entry; |
1983 | struct GNUNET_TIME_Relative expiration_time; | 1991 | struct GNUNET_TIME_Relative expiration_time; |
1984 | struct GNUNET_RECLAIM_AttributeList *cl = NULL; | 1992 | struct GNUNET_RECLAIM_AttributeList *cl = NULL; |
1985 | struct GNUNET_RECLAIM_CredentialList *al = NULL; | 1993 | struct GNUNET_RECLAIM_PresentationList *pl = NULL; |
1986 | struct GNUNET_RECLAIM_Ticket ticket; | 1994 | struct GNUNET_RECLAIM_Ticket ticket; |
1987 | struct GNUNET_CRYPTO_EcdsaPublicKey cid; | 1995 | struct GNUNET_CRYPTO_EcdsaPublicKey cid; |
1988 | struct GNUNET_HashCode cache_key; | 1996 | struct GNUNET_HashCode cache_key; |
@@ -2068,7 +2076,7 @@ token_endpoint (struct GNUNET_REST_RequestHandle *con_handle, | |||
2068 | 2076 | ||
2069 | // decode code | 2077 | // decode code |
2070 | if (GNUNET_OK != OIDC_parse_authz_code (&cid, code, code_verifier, &ticket, | 2078 | if (GNUNET_OK != OIDC_parse_authz_code (&cid, code, code_verifier, &ticket, |
2071 | &cl, &al, &nonce)) | 2079 | &cl, &pl, &nonce)) |
2072 | { | 2080 | { |
2073 | handle->emsg = GNUNET_strdup (OIDC_ERROR_KEY_INVALID_REQUEST); | 2081 | handle->emsg = GNUNET_strdup (OIDC_ERROR_KEY_INVALID_REQUEST); |
2074 | handle->edesc = GNUNET_strdup ("invalid code"); | 2082 | handle->edesc = GNUNET_strdup ("invalid code"); |
@@ -2108,7 +2116,7 @@ token_endpoint (struct GNUNET_REST_RequestHandle *con_handle, | |||
2108 | id_token = OIDC_generate_id_token (&ticket.audience, | 2116 | id_token = OIDC_generate_id_token (&ticket.audience, |
2109 | &ticket.identity, | 2117 | &ticket.identity, |
2110 | cl, | 2118 | cl, |
2111 | al, | 2119 | pl, |
2112 | &expiration_time, | 2120 | &expiration_time, |
2113 | (NULL != nonce) ? nonce : NULL, | 2121 | (NULL != nonce) ? nonce : NULL, |
2114 | jwt_secret); | 2122 | jwt_secret); |
@@ -2124,7 +2132,7 @@ token_endpoint (struct GNUNET_REST_RequestHandle *con_handle, | |||
2124 | MHD_add_response_header (resp, "Content-Type", "application/json"); | 2132 | MHD_add_response_header (resp, "Content-Type", "application/json"); |
2125 | handle->proc (handle->proc_cls, resp, MHD_HTTP_OK); | 2133 | handle->proc (handle->proc_cls, resp, MHD_HTTP_OK); |
2126 | GNUNET_RECLAIM_attribute_list_destroy (cl); | 2134 | GNUNET_RECLAIM_attribute_list_destroy (cl); |
2127 | GNUNET_RECLAIM_credential_list_destroy (al); | 2135 | GNUNET_RECLAIM_presentation_list_destroy (pl); |
2128 | GNUNET_free (access_token); | 2136 | GNUNET_free (access_token); |
2129 | GNUNET_free (json_response); | 2137 | GNUNET_free (json_response); |
2130 | GNUNET_free (id_token); | 2138 | GNUNET_free (id_token); |
@@ -2139,11 +2147,11 @@ static void | |||
2139 | consume_ticket (void *cls, | 2147 | consume_ticket (void *cls, |
2140 | const struct GNUNET_CRYPTO_EcdsaPublicKey *identity, | 2148 | const struct GNUNET_CRYPTO_EcdsaPublicKey *identity, |
2141 | const struct GNUNET_RECLAIM_Attribute *attr, | 2149 | const struct GNUNET_RECLAIM_Attribute *attr, |
2142 | const struct GNUNET_RECLAIM_Credential *cred) | 2150 | const struct GNUNET_RECLAIM_Presentation *pres) |
2143 | { | 2151 | { |
2144 | struct RequestHandle *handle = cls; | 2152 | struct RequestHandle *handle = cls; |
2145 | struct GNUNET_RECLAIM_AttributeListEntry *ale; | 2153 | struct GNUNET_RECLAIM_AttributeListEntry *ale; |
2146 | struct GNUNET_RECLAIM_CredentialListEntry *atle; | 2154 | struct GNUNET_RECLAIM_PresentationListEntry *atle; |
2147 | struct MHD_Response *resp; | 2155 | struct MHD_Response *resp; |
2148 | char *result_str; | 2156 | char *result_str; |
2149 | handle->idp_op = NULL; | 2157 | handle->idp_op = NULL; |
@@ -2152,7 +2160,7 @@ consume_ticket (void *cls, | |||
2152 | { | 2160 | { |
2153 | result_str = OIDC_generate_userinfo (&handle->ticket.identity, | 2161 | result_str = OIDC_generate_userinfo (&handle->ticket.identity, |
2154 | handle->attr_userinfo_list, | 2162 | handle->attr_userinfo_list, |
2155 | handle->creds_list); | 2163 | handle->presentations); |
2156 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Userinfo: %s\n", result_str); | 2164 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Userinfo: %s\n", result_str); |
2157 | resp = GNUNET_REST_create_response (result_str); | 2165 | resp = GNUNET_REST_create_response (result_str); |
2158 | handle->proc (handle->proc_cls, resp, MHD_HTTP_OK); | 2166 | handle->proc (handle->proc_cls, resp, MHD_HTTP_OK); |
@@ -2172,25 +2180,25 @@ consume_ticket (void *cls, | |||
2172 | GNUNET_CONTAINER_DLL_insert (handle->attr_userinfo_list->list_head, | 2180 | GNUNET_CONTAINER_DLL_insert (handle->attr_userinfo_list->list_head, |
2173 | handle->attr_userinfo_list->list_tail, | 2181 | handle->attr_userinfo_list->list_tail, |
2174 | ale); | 2182 | ale); |
2175 | if (NULL == cred) | 2183 | if (NULL == pres) |
2176 | return; | 2184 | return; |
2177 | for (atle = handle->creds_list->list_head; NULL != atle; atle = atle->next) | 2185 | for (atle = handle->presentations->list_head; |
2186 | NULL != atle; atle = atle->next) | ||
2178 | { | 2187 | { |
2179 | if (GNUNET_NO == GNUNET_RECLAIM_id_is_equal (&atle->credential->id, | 2188 | if (GNUNET_NO == GNUNET_RECLAIM_id_is_equal (&atle->presentation->credential_id, |
2180 | &cred->id)) | 2189 | &pres->credential_id)) |
2181 | continue; | 2190 | continue; |
2182 | break; /** already in list **/ | 2191 | break; /** already in list **/ |
2183 | } | 2192 | } |
2184 | if (NULL == atle) | 2193 | if (NULL == atle) |
2185 | { | 2194 | { |
2186 | /** Credential matches for attribute, add **/ | 2195 | /** Credential matches for attribute, add **/ |
2187 | atle = GNUNET_new (struct GNUNET_RECLAIM_CredentialListEntry); | 2196 | atle = GNUNET_new (struct GNUNET_RECLAIM_PresentationListEntry); |
2188 | atle->credential = GNUNET_RECLAIM_credential_new (cred->name, | 2197 | atle->presentation = GNUNET_RECLAIM_presentation_new (pres->type, |
2189 | cred->type, | 2198 | pres->data, |
2190 | cred->data, | 2199 | pres->data_size); |
2191 | cred->data_size); | 2200 | GNUNET_CONTAINER_DLL_insert (handle->presentations->list_head, |
2192 | GNUNET_CONTAINER_DLL_insert (handle->creds_list->list_head, | 2201 | handle->presentations->list_tail, |
2193 | handle->creds_list->list_tail, | ||
2194 | atle); | 2202 | atle); |
2195 | } | 2203 | } |
2196 | } | 2204 | } |
@@ -2289,8 +2297,8 @@ userinfo_endpoint (struct GNUNET_REST_RequestHandle *con_handle, | |||
2289 | privkey = GNUNET_IDENTITY_ego_get_private_key (aud_ego->ego); | 2297 | privkey = GNUNET_IDENTITY_ego_get_private_key (aud_ego->ego); |
2290 | handle->attr_userinfo_list = | 2298 | handle->attr_userinfo_list = |
2291 | GNUNET_new (struct GNUNET_RECLAIM_AttributeList); | 2299 | GNUNET_new (struct GNUNET_RECLAIM_AttributeList); |
2292 | handle->creds_list = | 2300 | handle->presentations = |
2293 | GNUNET_new (struct GNUNET_RECLAIM_CredentialList); | 2301 | GNUNET_new (struct GNUNET_RECLAIM_PresentationList); |
2294 | 2302 | ||
2295 | handle->idp_op = GNUNET_RECLAIM_ticket_consume (idp, | 2303 | handle->idp_op = GNUNET_RECLAIM_ticket_consume (idp, |
2296 | privkey, | 2304 | privkey, |
diff --git a/src/reclaim/plugin_rest_reclaim.c b/src/reclaim/plugin_rest_reclaim.c index a51d992e1..ff11d2a56 100644 --- a/src/reclaim/plugin_rest_reclaim.c +++ b/src/reclaim/plugin_rest_reclaim.c | |||
@@ -474,7 +474,7 @@ add_credential_cont (struct GNUNET_REST_RequestHandle *con_handle, | |||
474 | json_t *data_json; | 474 | json_t *data_json; |
475 | json_error_t err; | 475 | json_error_t err; |
476 | struct GNUNET_JSON_Specification attrspec[] = | 476 | struct GNUNET_JSON_Specification attrspec[] = |
477 | { GNUNET_RECLAIM_JSON_spec_claim_cred (&attribute), | 477 | { GNUNET_RECLAIM_JSON_spec_credential (&attribute), |
478 | GNUNET_JSON_spec_end () }; | 478 | GNUNET_JSON_spec_end () }; |
479 | 479 | ||
480 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 480 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
@@ -811,7 +811,7 @@ add_attribute_cont (struct GNUNET_REST_RequestHandle *con_handle, | |||
811 | json_t *data_json; | 811 | json_t *data_json; |
812 | json_error_t err; | 812 | json_error_t err; |
813 | struct GNUNET_JSON_Specification attrspec[] = | 813 | struct GNUNET_JSON_Specification attrspec[] = |
814 | { GNUNET_RECLAIM_JSON_spec_claim (&attribute), GNUNET_JSON_spec_end () }; | 814 | { GNUNET_RECLAIM_JSON_spec_attribute (&attribute), GNUNET_JSON_spec_end () }; |
815 | 815 | ||
816 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 816 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
817 | "Adding an attribute for %s.\n", | 817 | "Adding an attribute for %s.\n", |
@@ -1180,7 +1180,7 @@ static void | |||
1180 | consume_cont (void *cls, | 1180 | consume_cont (void *cls, |
1181 | const struct GNUNET_CRYPTO_EcdsaPublicKey *identity, | 1181 | const struct GNUNET_CRYPTO_EcdsaPublicKey *identity, |
1182 | const struct GNUNET_RECLAIM_Attribute *attr, | 1182 | const struct GNUNET_RECLAIM_Attribute *attr, |
1183 | const struct GNUNET_RECLAIM_Credential *cred) | 1183 | const struct GNUNET_RECLAIM_Presentation *pres) |
1184 | { | 1184 | { |
1185 | struct RequestHandle *handle = cls; | 1185 | struct RequestHandle *handle = cls; |
1186 | char *val_str; | 1186 | char *val_str; |
diff --git a/src/reclaim/reclaim.h b/src/reclaim/reclaim.h index 6ba9fdcd7..bc7f34365 100644 --- a/src/reclaim/reclaim.h +++ b/src/reclaim/reclaim.h | |||
@@ -463,9 +463,16 @@ struct TicketResultMessage | |||
463 | uint32_t id GNUNET_PACKED; | 463 | uint32_t id GNUNET_PACKED; |
464 | 464 | ||
465 | /** | 465 | /** |
466 | * Length of new presentations created | ||
467 | */ | ||
468 | uint32_t presentations_len GNUNET_PACKED; | ||
469 | |||
470 | /** | ||
466 | * The new ticket | 471 | * The new ticket |
467 | */ | 472 | */ |
468 | struct GNUNET_RECLAIM_Ticket ticket; | 473 | struct GNUNET_RECLAIM_Ticket ticket; |
474 | |||
475 | /* Followed by the serialized GNUNET_RECLAIM_PresentationList */ | ||
469 | }; | 476 | }; |
470 | 477 | ||
471 | /** | 478 | /** |
diff --git a/src/reclaim/reclaim_api.c b/src/reclaim/reclaim_api.c index 2cfcbad09..1e0251519 100644 --- a/src/reclaim/reclaim_api.c +++ b/src/reclaim/reclaim_api.c | |||
@@ -92,6 +92,11 @@ struct GNUNET_RECLAIM_Operation | |||
92 | GNUNET_RECLAIM_TicketCallback tr_cb; | 92 | GNUNET_RECLAIM_TicketCallback tr_cb; |
93 | 93 | ||
94 | /** | 94 | /** |
95 | * Ticket issue result callback | ||
96 | */ | ||
97 | GNUNET_RECLAIM_IssueTicketCallback ti_cb; | ||
98 | |||
99 | /** | ||
95 | * Envelope with the message for this queue entry. | 100 | * Envelope with the message for this queue entry. |
96 | */ | 101 | */ |
97 | struct GNUNET_MQ_Envelope *env; | 102 | struct GNUNET_MQ_Envelope *env; |
@@ -866,6 +871,30 @@ handle_credential_result (void *cls, const struct | |||
866 | GNUNET_assert (0); | 871 | GNUNET_assert (0); |
867 | } | 872 | } |
868 | 873 | ||
874 | /** | ||
875 | * Handle an incoming message of type | ||
876 | * #GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT | ||
877 | * | ||
878 | * @param cls | ||
879 | * @param msg the message we received | ||
880 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error | ||
881 | */ | ||
882 | static int | ||
883 | check_ticket_result (void *cls, const struct TicketResultMessage *msg) | ||
884 | { | ||
885 | size_t msg_len; | ||
886 | size_t pres_len; | ||
887 | |||
888 | msg_len = ntohs (msg->header.size); | ||
889 | pres_len = ntohs (msg->presentations_len); | ||
890 | if (msg_len != sizeof(struct TicketResultMessage) + pres_len) | ||
891 | { | ||
892 | GNUNET_break (0); | ||
893 | return GNUNET_SYSERR; | ||
894 | } | ||
895 | return GNUNET_OK; | ||
896 | } | ||
897 | |||
869 | 898 | ||
870 | /** | 899 | /** |
871 | * Handle an incoming message of type | 900 | * Handle an incoming message of type |
@@ -880,8 +909,10 @@ handle_ticket_result (void *cls, const struct TicketResultMessage *msg) | |||
880 | struct GNUNET_RECLAIM_Handle *handle = cls; | 909 | struct GNUNET_RECLAIM_Handle *handle = cls; |
881 | struct GNUNET_RECLAIM_Operation *op; | 910 | struct GNUNET_RECLAIM_Operation *op; |
882 | struct GNUNET_RECLAIM_TicketIterator *it; | 911 | struct GNUNET_RECLAIM_TicketIterator *it; |
912 | struct GNUNET_RECLAIM_PresentationList *pres; | ||
883 | uint32_t r_id = ntohl (msg->id); | 913 | uint32_t r_id = ntohl (msg->id); |
884 | static const struct GNUNET_RECLAIM_Ticket ticket; | 914 | static const struct GNUNET_RECLAIM_Ticket ticket; |
915 | uint32_t pres_len = ntohs (msg->presentations_len); | ||
885 | 916 | ||
886 | for (op = handle->op_head; NULL != op; op = op->next) | 917 | for (op = handle->op_head; NULL != op; op = op->next) |
887 | if (op->r_id == r_id) | 918 | if (op->r_id == r_id) |
@@ -893,18 +924,25 @@ handle_ticket_result (void *cls, const struct TicketResultMessage *msg) | |||
893 | return; | 924 | return; |
894 | if (NULL != op) | 925 | if (NULL != op) |
895 | { | 926 | { |
927 | if (0 < pres_len) | ||
928 | pres = GNUNET_RECLAIM_presentation_list_deserialize ((char*)&msg[1], | ||
929 | pres_len); | ||
896 | GNUNET_CONTAINER_DLL_remove (handle->op_head, handle->op_tail, op); | 930 | GNUNET_CONTAINER_DLL_remove (handle->op_head, handle->op_tail, op); |
897 | if (0 == | 931 | if (0 == |
898 | memcmp (&msg->ticket, &ticket, sizeof(struct GNUNET_RECLAIM_Ticket))) | 932 | memcmp (&msg->ticket, &ticket, sizeof(struct GNUNET_RECLAIM_Ticket))) |
899 | { | 933 | { |
900 | if (NULL != op->tr_cb) | 934 | if (NULL != op->ti_cb) |
901 | op->tr_cb (op->cls, NULL); | 935 | op->ti_cb (op->cls, NULL, NULL); |
902 | } | 936 | } |
903 | else | 937 | else |
904 | { | 938 | { |
905 | if (NULL != op->tr_cb) | 939 | if (NULL != op->ti_cb) |
906 | op->tr_cb (op->cls, &msg->ticket); | 940 | op->ti_cb (op->cls, |
941 | &msg->ticket, | ||
942 | (0 < pres_len) ? pres : NULL); | ||
907 | } | 943 | } |
944 | if (0 < pres_len) | ||
945 | GNUNET_RECLAIM_presentation_list_destroy (pres); | ||
908 | free_op (op); | 946 | free_op (op); |
909 | return; | 947 | return; |
910 | } | 948 | } |
@@ -989,10 +1027,10 @@ reconnect (struct GNUNET_RECLAIM_Handle *h) | |||
989 | GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_RESULT, | 1027 | GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_RESULT, |
990 | struct CredentialResultMessage, | 1028 | struct CredentialResultMessage, |
991 | h), | 1029 | h), |
992 | GNUNET_MQ_hd_fixed_size (ticket_result, | 1030 | GNUNET_MQ_hd_var_size (ticket_result, |
993 | GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT, | 1031 | GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT, |
994 | struct TicketResultMessage, | 1032 | struct TicketResultMessage, |
995 | h), | 1033 | h), |
996 | GNUNET_MQ_hd_var_size (consume_ticket_result, | 1034 | GNUNET_MQ_hd_var_size (consume_ticket_result, |
997 | GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET_RESULT, | 1035 | GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET_RESULT, |
998 | struct ConsumeTicketResultMessage, | 1036 | struct ConsumeTicketResultMessage, |
@@ -1506,7 +1544,7 @@ GNUNET_RECLAIM_ticket_issue ( | |||
1506 | const struct GNUNET_CRYPTO_EcdsaPrivateKey *iss, | 1544 | const struct GNUNET_CRYPTO_EcdsaPrivateKey *iss, |
1507 | const struct GNUNET_CRYPTO_EcdsaPublicKey *rp, | 1545 | const struct GNUNET_CRYPTO_EcdsaPublicKey *rp, |
1508 | const struct GNUNET_RECLAIM_AttributeList *attrs, | 1546 | const struct GNUNET_RECLAIM_AttributeList *attrs, |
1509 | GNUNET_RECLAIM_TicketCallback cb, | 1547 | GNUNET_RECLAIM_IssueTicketCallback cb, |
1510 | void *cb_cls) | 1548 | void *cb_cls) |
1511 | { | 1549 | { |
1512 | struct GNUNET_RECLAIM_Operation *op; | 1550 | struct GNUNET_RECLAIM_Operation *op; |
@@ -1516,7 +1554,7 @@ GNUNET_RECLAIM_ticket_issue ( | |||
1516 | fprintf (stderr, "Issuing ticket\n"); | 1554 | fprintf (stderr, "Issuing ticket\n"); |
1517 | op = GNUNET_new (struct GNUNET_RECLAIM_Operation); | 1555 | op = GNUNET_new (struct GNUNET_RECLAIM_Operation); |
1518 | op->h = h; | 1556 | op->h = h; |
1519 | op->tr_cb = cb; | 1557 | op->ti_cb = cb; |
1520 | op->cls = cb_cls; | 1558 | op->cls = cb_cls; |
1521 | op->r_id = h->r_id_gen++; | 1559 | op->r_id = h->r_id_gen++; |
1522 | GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op); | 1560 | GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op); |
diff --git a/src/reclaim/reclaim_credential.c b/src/reclaim/reclaim_credential.c index 10b17ae96..5c8974400 100644 --- a/src/reclaim/reclaim_credential.c +++ b/src/reclaim/reclaim_credential.c | |||
@@ -165,9 +165,9 @@ GNUNET_RECLAIM_credential_number_to_typename (uint32_t type) | |||
165 | */ | 165 | */ |
166 | int | 166 | int |
167 | GNUNET_RECLAIM_credential_string_to_value (uint32_t type, | 167 | GNUNET_RECLAIM_credential_string_to_value (uint32_t type, |
168 | const char *s, | 168 | const char *s, |
169 | void **data, | 169 | void **data, |
170 | size_t *data_size) | 170 | size_t *data_size) |
171 | { | 171 | { |
172 | unsigned int i; | 172 | unsigned int i; |
173 | struct Plugin *plugin; | 173 | struct Plugin *plugin; |
@@ -197,8 +197,8 @@ GNUNET_RECLAIM_credential_string_to_value (uint32_t type, | |||
197 | */ | 197 | */ |
198 | char * | 198 | char * |
199 | GNUNET_RECLAIM_credential_value_to_string (uint32_t type, | 199 | GNUNET_RECLAIM_credential_value_to_string (uint32_t type, |
200 | const void *data, | 200 | const void *data, |
201 | size_t data_size) | 201 | size_t data_size) |
202 | { | 202 | { |
203 | unsigned int i; | 203 | unsigned int i; |
204 | struct Plugin *plugin; | 204 | struct Plugin *plugin; |
@@ -229,9 +229,9 @@ GNUNET_RECLAIM_credential_value_to_string (uint32_t type, | |||
229 | */ | 229 | */ |
230 | struct GNUNET_RECLAIM_Credential * | 230 | struct GNUNET_RECLAIM_Credential * |
231 | GNUNET_RECLAIM_credential_new (const char *attr_name, | 231 | GNUNET_RECLAIM_credential_new (const char *attr_name, |
232 | uint32_t type, | 232 | uint32_t type, |
233 | const void *data, | 233 | const void *data, |
234 | size_t data_size) | 234 | size_t data_size) |
235 | { | 235 | { |
236 | struct GNUNET_RECLAIM_Credential *attr; | 236 | struct GNUNET_RECLAIM_Credential *attr; |
237 | char *write_ptr; | 237 | char *write_ptr; |
@@ -335,7 +335,7 @@ GNUNET_RECLAIM_credential_list_deserialize (const char *data, size_t data_size) | |||
335 | ale = GNUNET_new (struct GNUNET_RECLAIM_CredentialListEntry); | 335 | ale = GNUNET_new (struct GNUNET_RECLAIM_CredentialListEntry); |
336 | ale->credential = | 336 | ale->credential = |
337 | GNUNET_RECLAIM_credential_deserialize (read_ptr, | 337 | GNUNET_RECLAIM_credential_deserialize (read_ptr, |
338 | data_size - (read_ptr - data)); | 338 | data_size - (read_ptr - data)); |
339 | if (NULL == ale->credential) | 339 | if (NULL == ale->credential) |
340 | { | 340 | { |
341 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 341 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
@@ -371,9 +371,9 @@ GNUNET_RECLAIM_credential_list_dup ( | |||
371 | GNUNET_assert (NULL != ale->credential); | 371 | GNUNET_assert (NULL != ale->credential); |
372 | result_ale->credential = | 372 | result_ale->credential = |
373 | GNUNET_RECLAIM_credential_new (ale->credential->name, | 373 | GNUNET_RECLAIM_credential_new (ale->credential->name, |
374 | ale->credential->type, | 374 | ale->credential->type, |
375 | ale->credential->data, | 375 | ale->credential->data, |
376 | ale->credential->data_size); | 376 | ale->credential->data_size); |
377 | result_ale->credential->id = ale->credential->id; | 377 | result_ale->credential->id = ale->credential->id; |
378 | GNUNET_CONTAINER_DLL_insert (result->list_head, | 378 | GNUNET_CONTAINER_DLL_insert (result->list_head, |
379 | result->list_tail, | 379 | result->list_tail, |
@@ -490,7 +490,7 @@ GNUNET_RECLAIM_credential_deserialize (const char *data, size_t data_size) | |||
490 | return NULL; | 490 | return NULL; |
491 | } | 491 | } |
492 | credential = GNUNET_malloc (sizeof(struct GNUNET_RECLAIM_Credential) | 492 | credential = GNUNET_malloc (sizeof(struct GNUNET_RECLAIM_Credential) |
493 | + data_len + name_len + 1); | 493 | + data_len + name_len + 1); |
494 | credential->type = ntohs (atts->credential_type); | 494 | credential->type = ntohs (atts->credential_type); |
495 | credential->flag = ntohl (atts->credential_flag); | 495 | credential->flag = ntohl (atts->credential_flag); |
496 | credential->id = atts->credential_id; | 496 | credential->id = atts->credential_id; |
@@ -511,7 +511,7 @@ GNUNET_RECLAIM_credential_deserialize (const char *data, size_t data_size) | |||
511 | 511 | ||
512 | struct GNUNET_RECLAIM_AttributeList* | 512 | struct GNUNET_RECLAIM_AttributeList* |
513 | GNUNET_RECLAIM_credential_get_attributes (const struct | 513 | GNUNET_RECLAIM_credential_get_attributes (const struct |
514 | GNUNET_RECLAIM_Credential *credential) | 514 | GNUNET_RECLAIM_Credential *credential) |
515 | { | 515 | { |
516 | unsigned int i; | 516 | unsigned int i; |
517 | struct Plugin *plugin; | 517 | struct Plugin *plugin; |
@@ -531,7 +531,7 @@ GNUNET_RECLAIM_credential_get_attributes (const struct | |||
531 | 531 | ||
532 | char* | 532 | char* |
533 | GNUNET_RECLAIM_credential_get_issuer (const struct | 533 | GNUNET_RECLAIM_credential_get_issuer (const struct |
534 | GNUNET_RECLAIM_Credential *credential) | 534 | GNUNET_RECLAIM_Credential *credential) |
535 | { | 535 | { |
536 | unsigned int i; | 536 | unsigned int i; |
537 | struct Plugin *plugin; | 537 | struct Plugin *plugin; |
@@ -551,8 +551,8 @@ GNUNET_RECLAIM_credential_get_issuer (const struct | |||
551 | 551 | ||
552 | int | 552 | int |
553 | GNUNET_RECLAIM_credential_get_expiration (const struct | 553 | GNUNET_RECLAIM_credential_get_expiration (const struct |
554 | GNUNET_RECLAIM_Credential *credential, | 554 | GNUNET_RECLAIM_Credential *credential, |
555 | struct GNUNET_TIME_Absolute*exp) | 555 | struct GNUNET_TIME_Absolute*exp) |
556 | { | 556 | { |
557 | unsigned int i; | 557 | unsigned int i; |
558 | struct Plugin *plugin; | 558 | struct Plugin *plugin; |
@@ -568,3 +568,470 @@ GNUNET_RECLAIM_credential_get_expiration (const struct | |||
568 | } | 568 | } |
569 | return GNUNET_SYSERR; | 569 | return GNUNET_SYSERR; |
570 | } | 570 | } |
571 | |||
572 | |||
573 | /** | ||
574 | * Convert an presentation type name to the corresponding number | ||
575 | * | ||
576 | * @param typename name to convert | ||
577 | * @return corresponding number, UINT32_MAX on error | ||
578 | */ | ||
579 | uint32_t | ||
580 | GNUNET_RECLAIM_presentation_typename_to_number (const char *typename) | ||
581 | { | ||
582 | unsigned int i; | ||
583 | struct Plugin *plugin; | ||
584 | uint32_t ret; | ||
585 | init (); | ||
586 | for (i = 0; i < num_plugins; i++) | ||
587 | { | ||
588 | plugin = credential_plugins[i]; | ||
589 | if (UINT32_MAX != | ||
590 | (ret = plugin->api->typename_to_number_p (plugin->api->cls, | ||
591 | typename))) | ||
592 | return ret; | ||
593 | } | ||
594 | return UINT32_MAX; | ||
595 | } | ||
596 | |||
597 | |||
598 | /** | ||
599 | * Convert an presentation type number to the corresponding presentation type string | ||
600 | * | ||
601 | * @param type number of a type | ||
602 | * @return corresponding typestring, NULL on error | ||
603 | */ | ||
604 | const char * | ||
605 | GNUNET_RECLAIM_presentation_number_to_typename (uint32_t type) | ||
606 | { | ||
607 | unsigned int i; | ||
608 | struct Plugin *plugin; | ||
609 | const char *ret; | ||
610 | |||
611 | init (); | ||
612 | for (i = 0; i < num_plugins; i++) | ||
613 | { | ||
614 | plugin = credential_plugins[i]; | ||
615 | if (NULL != | ||
616 | (ret = plugin->api->number_to_typename_p (plugin->api->cls, type))) | ||
617 | return ret; | ||
618 | } | ||
619 | return NULL; | ||
620 | } | ||
621 | |||
622 | |||
623 | /** | ||
624 | * Convert human-readable version of a 'claim' of an presentation to the binary | ||
625 | * representation | ||
626 | * | ||
627 | * @param type type of the claim | ||
628 | * @param s human-readable string | ||
629 | * @param data set to value in binary encoding (will be allocated) | ||
630 | * @param data_size set to number of bytes in @a data | ||
631 | * @return #GNUNET_OK on success | ||
632 | */ | ||
633 | int | ||
634 | GNUNET_RECLAIM_presentation_string_to_value (uint32_t type, | ||
635 | const char *s, | ||
636 | void **data, | ||
637 | size_t *data_size) | ||
638 | { | ||
639 | unsigned int i; | ||
640 | struct Plugin *plugin; | ||
641 | |||
642 | init (); | ||
643 | for (i = 0; i < num_plugins; i++) | ||
644 | { | ||
645 | plugin = credential_plugins[i]; | ||
646 | if (GNUNET_OK == plugin->api->string_to_value_p (plugin->api->cls, | ||
647 | type, | ||
648 | s, | ||
649 | data, | ||
650 | data_size)) | ||
651 | return GNUNET_OK; | ||
652 | } | ||
653 | return GNUNET_SYSERR; | ||
654 | } | ||
655 | |||
656 | |||
657 | /** | ||
658 | * Convert the 'claim' of an presentation to a string | ||
659 | * | ||
660 | * @param type the type of presentation | ||
661 | * @param data claim in binary encoding | ||
662 | * @param data_size number of bytes in @a data | ||
663 | * @return NULL on error, otherwise human-readable representation of the claim | ||
664 | */ | ||
665 | char * | ||
666 | GNUNET_RECLAIM_presentation_value_to_string (uint32_t type, | ||
667 | const void *data, | ||
668 | size_t data_size) | ||
669 | { | ||
670 | unsigned int i; | ||
671 | struct Plugin *plugin; | ||
672 | char *ret; | ||
673 | |||
674 | init (); | ||
675 | for (i = 0; i < num_plugins; i++) | ||
676 | { | ||
677 | plugin = credential_plugins[i]; | ||
678 | if (NULL != (ret = plugin->api->value_to_string_p (plugin->api->cls, | ||
679 | type, | ||
680 | data, | ||
681 | data_size))) | ||
682 | return ret; | ||
683 | } | ||
684 | return NULL; | ||
685 | } | ||
686 | |||
687 | |||
688 | struct GNUNET_RECLAIM_Presentation * | ||
689 | GNUNET_RECLAIM_presentation_new (uint32_t type, | ||
690 | const void *data, | ||
691 | size_t data_size) | ||
692 | { | ||
693 | struct GNUNET_RECLAIM_Presentation *attr; | ||
694 | char *write_ptr; | ||
695 | |||
696 | attr = GNUNET_malloc (sizeof(struct GNUNET_RECLAIM_Presentation) | ||
697 | + data_size); | ||
698 | attr->type = type; | ||
699 | attr->data_size = data_size; | ||
700 | write_ptr = (char *) &attr[1]; | ||
701 | GNUNET_memcpy (write_ptr, data, data_size); | ||
702 | attr->data = write_ptr; | ||
703 | return attr; | ||
704 | } | ||
705 | |||
706 | |||
707 | /** | ||
708 | * Get required size for serialization buffer | ||
709 | * | ||
710 | * @param attrs the attribute list to serialize | ||
711 | * @return the required buffer size | ||
712 | */ | ||
713 | size_t | ||
714 | GNUNET_RECLAIM_presentation_list_serialize_get_size ( | ||
715 | const struct GNUNET_RECLAIM_PresentationList *presentations) | ||
716 | { | ||
717 | struct GNUNET_RECLAIM_PresentationListEntry *le; | ||
718 | size_t len = 0; | ||
719 | |||
720 | for (le = presentations->list_head; NULL != le; le = le->next) | ||
721 | { | ||
722 | GNUNET_assert (NULL != le->presentation); | ||
723 | len += GNUNET_RECLAIM_presentation_serialize_get_size (le->presentation); | ||
724 | len += sizeof(struct GNUNET_RECLAIM_PresentationListEntry); | ||
725 | } | ||
726 | return len; | ||
727 | } | ||
728 | |||
729 | |||
730 | /** | ||
731 | * Serialize an attribute list | ||
732 | * | ||
733 | * @param attrs the attribute list to serialize | ||
734 | * @param result the serialized attribute | ||
735 | * @return length of serialized data | ||
736 | */ | ||
737 | size_t | ||
738 | GNUNET_RECLAIM_presentation_list_serialize ( | ||
739 | const struct GNUNET_RECLAIM_PresentationList *presentations, | ||
740 | char *result) | ||
741 | { | ||
742 | struct GNUNET_RECLAIM_PresentationListEntry *le; | ||
743 | size_t len; | ||
744 | size_t total_len; | ||
745 | char *write_ptr; | ||
746 | write_ptr = result; | ||
747 | total_len = 0; | ||
748 | for (le = presentations->list_head; NULL != le; le = le->next) | ||
749 | { | ||
750 | GNUNET_assert (NULL != le->presentation); | ||
751 | len = GNUNET_RECLAIM_presentation_serialize (le->presentation, write_ptr); | ||
752 | total_len += len; | ||
753 | write_ptr += len; | ||
754 | } | ||
755 | return total_len; | ||
756 | } | ||
757 | |||
758 | |||
759 | /** | ||
760 | * Deserialize an presentation list | ||
761 | * | ||
762 | * @param data the serialized attribute list | ||
763 | * @param data_size the length of the serialized data | ||
764 | * @return a GNUNET_IDENTITY_PROVIDER_AttributeList, must be free'd by caller | ||
765 | */ | ||
766 | struct GNUNET_RECLAIM_PresentationList * | ||
767 | GNUNET_RECLAIM_presentation_list_deserialize (const char *data, size_t | ||
768 | data_size) | ||
769 | { | ||
770 | struct GNUNET_RECLAIM_PresentationList *al; | ||
771 | struct GNUNET_RECLAIM_PresentationListEntry *ale; | ||
772 | size_t att_len; | ||
773 | const char *read_ptr; | ||
774 | |||
775 | al = GNUNET_new (struct GNUNET_RECLAIM_PresentationList); | ||
776 | |||
777 | if ((data_size < sizeof(struct Presentation) | ||
778 | + sizeof(struct GNUNET_RECLAIM_PresentationListEntry))) | ||
779 | return al; | ||
780 | |||
781 | read_ptr = data; | ||
782 | while (((data + data_size) - read_ptr) >= sizeof(struct Presentation)) | ||
783 | { | ||
784 | ale = GNUNET_new (struct GNUNET_RECLAIM_PresentationListEntry); | ||
785 | ale->presentation = | ||
786 | GNUNET_RECLAIM_presentation_deserialize (read_ptr, | ||
787 | data_size - (read_ptr - data)); | ||
788 | if (NULL == ale->presentation) | ||
789 | { | ||
790 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | ||
791 | "Failed to deserialize malformed presentation.\n"); | ||
792 | GNUNET_free (ale); | ||
793 | return al; | ||
794 | } | ||
795 | GNUNET_CONTAINER_DLL_insert (al->list_head, al->list_tail, ale); | ||
796 | att_len = GNUNET_RECLAIM_presentation_serialize_get_size ( | ||
797 | ale->presentation); | ||
798 | read_ptr += att_len; | ||
799 | } | ||
800 | return al; | ||
801 | } | ||
802 | |||
803 | |||
804 | /** | ||
805 | * Make a (deep) copy of the presentation list | ||
806 | * @param attrs claim list to copy | ||
807 | * @return copied claim list | ||
808 | */ | ||
809 | struct GNUNET_RECLAIM_PresentationList * | ||
810 | GNUNET_RECLAIM_presentation_list_dup ( | ||
811 | const struct GNUNET_RECLAIM_PresentationList *al) | ||
812 | { | ||
813 | struct GNUNET_RECLAIM_PresentationListEntry *ale; | ||
814 | struct GNUNET_RECLAIM_PresentationListEntry *result_ale; | ||
815 | struct GNUNET_RECLAIM_PresentationList *result; | ||
816 | |||
817 | result = GNUNET_new (struct GNUNET_RECLAIM_PresentationList); | ||
818 | for (ale = al->list_head; NULL != ale; ale = ale->next) | ||
819 | { | ||
820 | result_ale = GNUNET_new (struct GNUNET_RECLAIM_PresentationListEntry); | ||
821 | GNUNET_assert (NULL != ale->presentation); | ||
822 | result_ale->presentation = | ||
823 | GNUNET_RECLAIM_presentation_new (ale->presentation->type, | ||
824 | ale->presentation->data, | ||
825 | ale->presentation->data_size); | ||
826 | result_ale->presentation->credential_id = ale->presentation->credential_id; | ||
827 | GNUNET_CONTAINER_DLL_insert (result->list_head, | ||
828 | result->list_tail, | ||
829 | result_ale); | ||
830 | } | ||
831 | return result; | ||
832 | } | ||
833 | |||
834 | |||
835 | /** | ||
836 | * Destroy presentation list | ||
837 | * | ||
838 | * @param attrs list to destroy | ||
839 | */ | ||
840 | void | ||
841 | GNUNET_RECLAIM_presentation_list_destroy ( | ||
842 | struct GNUNET_RECLAIM_PresentationList *al) | ||
843 | { | ||
844 | struct GNUNET_RECLAIM_PresentationListEntry *ale; | ||
845 | struct GNUNET_RECLAIM_PresentationListEntry *tmp_ale; | ||
846 | |||
847 | for (ale = al->list_head; NULL != ale;) | ||
848 | { | ||
849 | if (NULL != ale->presentation) | ||
850 | GNUNET_free (ale->presentation); | ||
851 | tmp_ale = ale; | ||
852 | ale = ale->next; | ||
853 | GNUNET_free (tmp_ale); | ||
854 | } | ||
855 | GNUNET_free (al); | ||
856 | } | ||
857 | |||
858 | |||
859 | /** | ||
860 | * Get required size for serialization buffer | ||
861 | * | ||
862 | * @param attr the presentation to serialize | ||
863 | * @return the required buffer size | ||
864 | */ | ||
865 | size_t | ||
866 | GNUNET_RECLAIM_presentation_serialize_get_size ( | ||
867 | const struct GNUNET_RECLAIM_Presentation *presentation) | ||
868 | { | ||
869 | return sizeof(struct Presentation) + presentation->data_size; | ||
870 | } | ||
871 | |||
872 | |||
873 | /** | ||
874 | * Serialize an presentation | ||
875 | * | ||
876 | * @param attr the presentation to serialize | ||
877 | * @param result the serialized presentation | ||
878 | * @return length of serialized data | ||
879 | */ | ||
880 | size_t | ||
881 | GNUNET_RECLAIM_presentation_serialize ( | ||
882 | const struct GNUNET_RECLAIM_Presentation *presentation, | ||
883 | char *result) | ||
884 | { | ||
885 | struct Presentation *atts; | ||
886 | char *write_ptr; | ||
887 | |||
888 | atts = (struct Presentation *) result; | ||
889 | atts->presentation_type = htons (presentation->type); | ||
890 | atts->credential_id = presentation->credential_id; | ||
891 | write_ptr = (char *) &atts[1]; | ||
892 | GNUNET_memcpy (write_ptr, presentation->data, presentation->data_size); | ||
893 | atts->data_size = htons (presentation->data_size); | ||
894 | |||
895 | return sizeof(struct Presentation) + presentation->data_size; | ||
896 | } | ||
897 | |||
898 | |||
899 | /** | ||
900 | * Deserialize an presentation | ||
901 | * | ||
902 | * @param data the serialized presentation | ||
903 | * @param data_size the length of the serialized data | ||
904 | * | ||
905 | * @return a GNUNET_IDENTITY_PROVIDER_Attribute, must be free'd by caller | ||
906 | */ | ||
907 | struct GNUNET_RECLAIM_Presentation * | ||
908 | GNUNET_RECLAIM_presentation_deserialize (const char *data, size_t data_size) | ||
909 | { | ||
910 | struct GNUNET_RECLAIM_Presentation *presentation; | ||
911 | struct Presentation *atts; | ||
912 | size_t data_len; | ||
913 | char *write_ptr; | ||
914 | |||
915 | if (data_size < sizeof(struct Presentation)) | ||
916 | return NULL; | ||
917 | |||
918 | atts = (struct Presentation *) data; | ||
919 | data_len = ntohs (atts->data_size); | ||
920 | if (data_size < sizeof(struct Presentation) + data_len) | ||
921 | { | ||
922 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
923 | "Buffer too small to deserialize\n"); | ||
924 | return NULL; | ||
925 | } | ||
926 | presentation = GNUNET_malloc (sizeof(struct GNUNET_RECLAIM_Presentation) | ||
927 | + data_len); | ||
928 | presentation->type = ntohs (atts->presentation_type); | ||
929 | presentation->credential_id = atts->credential_id; | ||
930 | presentation->data_size = data_len; | ||
931 | |||
932 | write_ptr = (char *) &presentation[1]; | ||
933 | GNUNET_memcpy (write_ptr, &atts[1], data_len); | ||
934 | presentation->data = write_ptr; | ||
935 | return presentation; | ||
936 | } | ||
937 | |||
938 | |||
939 | struct GNUNET_RECLAIM_AttributeList* | ||
940 | GNUNET_RECLAIM_presentation_get_attributes (const struct | ||
941 | GNUNET_RECLAIM_Presentation * | ||
942 | presentation) | ||
943 | { | ||
944 | unsigned int i; | ||
945 | struct Plugin *plugin; | ||
946 | struct GNUNET_RECLAIM_AttributeList *ret; | ||
947 | init (); | ||
948 | for (i = 0; i < num_plugins; i++) | ||
949 | { | ||
950 | plugin = credential_plugins[i]; | ||
951 | if (NULL != | ||
952 | (ret = plugin->api->get_attributes_p (plugin->api->cls, | ||
953 | presentation))) | ||
954 | return ret; | ||
955 | } | ||
956 | return NULL; | ||
957 | } | ||
958 | |||
959 | |||
960 | char* | ||
961 | GNUNET_RECLAIM_presentation_get_issuer (const struct | ||
962 | GNUNET_RECLAIM_Presentation * | ||
963 | presentation) | ||
964 | { | ||
965 | unsigned int i; | ||
966 | struct Plugin *plugin; | ||
967 | char *ret; | ||
968 | init (); | ||
969 | for (i = 0; i < num_plugins; i++) | ||
970 | { | ||
971 | plugin = credential_plugins[i]; | ||
972 | if (NULL != | ||
973 | (ret = plugin->api->get_issuer_p (plugin->api->cls, | ||
974 | presentation))) | ||
975 | return ret; | ||
976 | } | ||
977 | return NULL; | ||
978 | } | ||
979 | |||
980 | |||
981 | int | ||
982 | GNUNET_RECLAIM_presentation_get_expiration (const struct | ||
983 | GNUNET_RECLAIM_Presentation * | ||
984 | presentation, | ||
985 | struct GNUNET_TIME_Absolute*exp) | ||
986 | { | ||
987 | unsigned int i; | ||
988 | struct Plugin *plugin; | ||
989 | init (); | ||
990 | for (i = 0; i < num_plugins; i++) | ||
991 | { | ||
992 | plugin = credential_plugins[i]; | ||
993 | if (GNUNET_OK != plugin->api->get_expiration_p (plugin->api->cls, | ||
994 | presentation, | ||
995 | exp)) | ||
996 | continue; | ||
997 | return GNUNET_OK; | ||
998 | } | ||
999 | return GNUNET_SYSERR; | ||
1000 | } | ||
1001 | |||
1002 | /** | ||
1003 | * Create a presentation from a credential and a lift of (selected) | ||
1004 | * attributes in the credential. | ||
1005 | * FIXME not yet implemented | ||
1006 | * | ||
1007 | * @param cred the credential to use | ||
1008 | * @param attrs the attributes to present from the credential | ||
1009 | * @return the credential presentation presenting the attributes according | ||
1010 | * to the presentation mechanism of the credential | ||
1011 | * or NULL on error. | ||
1012 | */ | ||
1013 | int | ||
1014 | GNUNET_RECLAIM_credential_get_presentation ( | ||
1015 | const struct GNUNET_RECLAIM_Credential *cred, | ||
1016 | const struct GNUNET_RECLAIM_AttributeList *attrs, | ||
1017 | struct GNUNET_RECLAIM_Presentation **pres) | ||
1018 | { | ||
1019 | unsigned int i; | ||
1020 | struct Plugin *plugin; | ||
1021 | init (); | ||
1022 | for (i = 0; i < num_plugins; i++) | ||
1023 | { | ||
1024 | plugin = credential_plugins[i]; | ||
1025 | if (GNUNET_OK != plugin->api->create_presentation (plugin->api->cls, | ||
1026 | cred, | ||
1027 | attrs, | ||
1028 | pres)) | ||
1029 | continue; | ||
1030 | (*pres)->credential_id = cred->id; | ||
1031 | return GNUNET_OK; | ||
1032 | } | ||
1033 | return GNUNET_SYSERR; | ||
1034 | } | ||
1035 | |||
1036 | |||
1037 | |||
diff --git a/src/reclaim/reclaim_credential.h b/src/reclaim/reclaim_credential.h index cd3a9539a..7704ed968 100644 --- a/src/reclaim/reclaim_credential.h +++ b/src/reclaim/reclaim_credential.h | |||
@@ -61,4 +61,39 @@ struct Credential | |||
61 | // followed by data_size Credential value data | 61 | // followed by data_size Credential value data |
62 | }; | 62 | }; |
63 | 63 | ||
64 | |||
65 | /** | ||
66 | * Serialized presentation claim | ||
67 | */ | ||
68 | struct Presentation | ||
69 | { | ||
70 | /** | ||
71 | * Presentation type | ||
72 | */ | ||
73 | uint32_t presentation_type; | ||
74 | |||
75 | /** | ||
76 | * Presentation flag | ||
77 | */ | ||
78 | uint32_t presentation_flag; | ||
79 | |||
80 | /** | ||
81 | * Credential ID | ||
82 | */ | ||
83 | struct GNUNET_RECLAIM_Identifier credential_id; | ||
84 | |||
85 | /** | ||
86 | * Name length | ||
87 | */ | ||
88 | uint32_t name_len; | ||
89 | |||
90 | /** | ||
91 | * Data size | ||
92 | */ | ||
93 | uint32_t data_size; | ||
94 | |||
95 | // followed by data_size Presentation value data | ||
96 | }; | ||
97 | |||
98 | |||
64 | #endif | 99 | #endif |