42 #include "microhttpd.h"
48 #define GNUNET_REST_API_NS_OIDC "/openid"
53 #define GNUNET_REST_API_NS_OIDC_CONFIG "/.well-known/openid-configuration"
58 #define GNUNET_REST_API_NS_AUTHORIZE "/openid/authorize"
63 #define GNUNET_REST_API_NS_TOKEN "/openid/token"
68 #define GNUNET_REST_API_NS_USERINFO "/openid/userinfo"
73 #define GNUNET_REST_API_NS_LOGIN "/openid/login"
78 #define ID_REST_STATE_INIT 0
83 #define ID_REST_STATE_POST_INIT 1
88 #define OIDC_GRANT_TYPE_KEY "grant_type"
93 #define OIDC_GRANT_TYPE_VALUE "authorization_code"
98 #define OIDC_CODE_KEY "code"
103 #define OIDC_RESPONSE_TYPE_KEY "response_type"
108 #define OIDC_CLIENT_ID_KEY "client_id"
113 #define OIDC_SCOPE_KEY "scope"
118 #define OIDC_REDIRECT_URI_KEY "redirect_uri"
123 #define OIDC_STATE_KEY "state"
128 #define OIDC_NONCE_KEY "nonce"
133 #define OIDC_CLAIMS_KEY "claims"
138 #define OIDC_CODE_CHALLENGE_KEY "code_challenge"
143 #define OIDC_CODE_VERIFIER_KEY "code_verifier"
148 #define OIDC_COOKIE_EXPIRATION 3
153 #define OIDC_COOKIE_HEADER_KEY "cookie"
158 #define OIDC_AUTHORIZATION_HEADER_KEY "authorization"
163 #define OIDC_COOKIE_HEADER_INFORMATION_KEY "Identity="
168 #define OIDC_COOKIE_HEADER_ACCESS_DENIED "Identity=Denied"
173 #define OIDC_EXPECTED_AUTHORIZATION_RESPONSE_TYPE "code"
178 #define OIDC_EXPECTED_AUTHORIZATION_SCOPE "openid"
183 #define OIDC_ERROR_KEY_INVALID_CLIENT "invalid_client"
188 #define OIDC_ERROR_KEY_INVALID_SCOPE "invalid_scope"
193 #define OIDC_ERROR_KEY_INVALID_REQUEST "invalid_request"
198 #define OIDC_ERROR_KEY_INVALID_TOKEN "invalid_token"
203 #define OIDC_ERROR_KEY_INVALID_COOKIE "invalid_cookie"
208 #define OIDC_ERROR_KEY_SERVER_ERROR "server_error"
213 #define OIDC_ERROR_KEY_UNSUPPORTED_GRANT_TYPE "unsupported_grant_type"
218 #define OIDC_ERROR_KEY_UNSUPPORTED_RESPONSE_TYPE "unsupported_response_type"
223 #define OIDC_ERROR_KEY_UNAUTHORIZED_CLIENT "unauthorized_client"
228 #define OIDC_ERROR_KEY_ACCESS_DENIED "access_denied"
233 #define CONSUME_TIMEOUT GNUNET_TIME_relative_multiply ( \
234 GNUNET_TIME_UNIT_SECONDS,2)
584 if (NULL !=
handle->timeout_task)
586 if (NULL !=
handle->attr_it)
588 if (NULL !=
handle->cred_it)
590 if (NULL !=
handle->ticket_it)
592 if (NULL !=
handle->idp_op)
594 if (NULL !=
handle->consume_timeout_op)
602 if (NULL !=
handle->gns_op)
613 if (NULL !=
handle->oidc->claims)
615 if (NULL !=
handle->oidc->code_challenge)
619 if (NULL!=
handle->attr_idtoken_list)
621 if (NULL!=
handle->attr_userinfo_list)
623 if (NULL!=
handle->credentials)
625 if (NULL!=
handle->presentations)
630 if (NULL !=
handle->access_token)
645 struct MHD_Response *resp;
649 "{ \"error\" : \"%s\", \"error_description\" : \"%s\"%s%s%s}",
652 (NULL !=
handle->oidc->state) ?
", \"state\":\"" :
"",
653 (NULL !=
handle->oidc->state) ?
handle->oidc->state :
"",
654 (NULL !=
handle->oidc->state) ?
"\"" :
"");
655 if (0 ==
handle->response_code)
656 handle->response_code = MHD_HTTP_BAD_REQUEST;
658 if (MHD_HTTP_UNAUTHORIZED ==
handle->response_code)
660 MHD_add_response_header (resp,
661 MHD_HTTP_HEADER_WWW_AUTHENTICATE,
663 MHD_add_response_header (resp,
664 MHD_HTTP_HEADER_CONTENT_TYPE,
682 struct MHD_Response *resp;
686 "Error: %s\n",
handle->edesc);
688 "error=\"%s\", error_description=\"%s\"",
693 MHD_add_response_header (resp,
694 MHD_HTTP_HEADER_WWW_AUTHENTICATE,
711 struct MHD_Response *resp;
715 "%s?error=%s&error_description=%s%s%s",
716 handle->oidc->redirect_uri,
719 (NULL !=
handle->oidc->state) ?
"&state=" :
"",
720 (NULL !=
handle->oidc->state) ?
handle->oidc->state :
"");
723 "Location", redirect));
740 handle->timeout_task = NULL;
757 struct MHD_Response *resp;
762 MHD_add_response_header (resp,
"Access-Control-Allow-Methods",
allow_methods);
778 char delimiter[] =
"; ";
799 token = strtok (cookies, delimiter);
801 handle->oidc->login_identity = NULL;
805 "Unable to parse cookie: %s\n",
811 while (NULL != token)
821 token = strtok (NULL, delimiter);
826 "No cookie value to process: %s\n",
837 "Found cookie `%s', but no corresponding expiration entry present...\n",
849 "Found cookie `%s', but it is expired.\n",
867 char *login_base_url;
870 struct MHD_Response *resp;
875 "reclaim-rest-plugin",
883 handle->oidc->response_type);
889 strlen (
handle->oidc->redirect_uri),
897 strlen (
handle->oidc->scope),
904 if (NULL !=
handle->oidc->state)
907 strlen (
handle->oidc->state),
915 if (NULL !=
handle->oidc->code_challenge)
920 handle->oidc->code_challenge);
922 if (NULL !=
handle->oidc->nonce)
929 if (NULL !=
handle->oidc->claims)
932 strlen (
handle->oidc->claims),
942 MHD_add_response_header (resp,
"Location", new_redirect);
949 handle->response_code = MHD_HTTP_INTERNAL_SERVER_ERROR;
968 handle->response_code = MHD_HTTP_INTERNAL_SERVER_ERROR;
984 struct MHD_Response *resp;
1003 handle->attr_idtoken_list,
1006 handle->oidc->code_challenge);
1007 if ((NULL !=
handle->redirect_prefix) && (NULL !=
handle->redirect_suffix) &&
1011 "%s.%s/%s%s%s=%s&state=%s",
1015 (NULL == strchr (
handle->redirect_suffix,
'?') ?
"?" :
1017 handle->oidc->response_type,
1024 "%s%s%s=%s&state=%s",
1025 handle->oidc->redirect_uri,
1026 (NULL == strchr (
handle->oidc->redirect_uri,
'?') ?
"?" :
1028 handle->oidc->response_type,
1034 "Location", redirect_uri));
1053 for (le_a = list_a->
list_head; NULL != le_a; le_a = le_a->
next)
1070 for (le_b = list_b->
list_head; NULL != le_b; le_b = le_b->
next)
1072 for (le_m = merged_list->
list_head; NULL != le_m; le_m = le_m->
next)
1107 handle->attr_userinfo_list);
1108 for (le_m = merged_list->
list_head; NULL != le_m; le_m = le_m->
next)
1110 "List Attribute in ticket to issue: %s\n",
1114 &
handle->oidc->client_pkey,
1134 for (ale =
handle->credentials->list_head; NULL != ale; ale = ale->
next)
1144 for (le =
handle->attr_idtoken_list->list_head; NULL != le; le = le->
next)
1156 handle->credentials->list_tail,
1169 handle->ticket_it = NULL;
1170 if (NULL ==
handle->attr_idtoken_list->list_head)
1194 const char *claims_parameter)
1209 if (NULL !=
handle->oidc->claims)
1211 root = json_loads (
handle->oidc->claims, JSON_DECODE_ANY, &error);
1212 claims_j = json_object_get (root, claims_parameter);
1214 if (NULL != claims_j)
1216 json_object_foreach (claims_j,
key,
value) {
1267 handle->attr_idtoken_list->list_tail,
1282 handle->attr_userinfo_list->list_tail,
1302 char *identity_cookie;
1306 handle->oidc->login_identity);
1326 GNUNET_strdup (
"The cookie of a login identity is not valid");
1339 handle->attr_idtoken_list =
1341 handle->attr_userinfo_list =
1366 struct MHD_Response *resp;
1371 if ((NULL !=
handle->redirect_prefix) &&
1372 (NULL !=
handle->redirect_suffix) && (NULL !=
handle->tld))
1375 "%s.%s/%s?error=%s&error_description=%s&state=%s",
1380 "User denied access",
1386 "%s?error=%s&error_description=%s&state=%s",
1387 handle->oidc->redirect_uri,
1389 "User denied access",
1421 GNUNET_strdup (
"Server cannot generate ticket, redirect uri not found.");
1425 for (
int i = 0; i < rd_count; i++)
1432 if (NULL == strstr (tmp,
handle->oidc->client_id))
1435 "Redirect uri %s does not contain client_id %s\n",
1437 handle->oidc->client_id);
1441 pos = strrchr (tmp, (
unsigned char)
'.');
1445 "Redirect uri %s contains client_id but is malformed\n",
1452 tmp_key_str = pos + 1;
1453 pos = strchr (tmp_key_str, (
unsigned char)
'/');
1457 "Redirect uri %s contains client_id but is malformed\n",
1466 strlen (tmp_key_str),
1468 sizeof(redirect_zone));
1476 GNUNET_strdup (
"Server cannot generate ticket, redirect uri not found.");
1493 &
handle->oidc->client_pkey,
1534 char *expected_scope;
1535 char delimiter[] =
" ";
1536 int number_of_ignored_parameter,
iterator;
1540 handle->oidc->redirect_uri =
1542 if (NULL ==
handle->oidc->redirect_uri)
1551 handle->oidc->response_type =
1553 if (NULL ==
handle->oidc->response_type)
1563 if (NULL ==
handle->oidc->scope)
1578 number_of_ignored_parameter =
1592 "Server will not handle parameter: %s",
1600 if (0 != strcmp (
handle->oidc->response_type,
1605 "obtaining this authorization code.");
1613 test = strtok (expected_scope, delimiter);
1614 while (NULL != test)
1618 test = strtok (NULL, delimiter);
1624 GNUNET_strdup (
"The requested scope is invalid, unknown, or malformed.");
1631 if ((NULL ==
handle->oidc->login_identity) &&
1643 tld_iter (
void *cls,
const char *section,
const char *option,
const char *
value)
1683 if (NULL ==
handle->oidc->client_id)
1687 handle->response_code = MHD_HTTP_INTERNAL_SERVER_ERROR;
1695 if (NULL ==
handle->oidc->code_challenge)
1698 "OAuth authorization request does not contain PKCE parameters!\n");
1703 &
handle->oidc->client_pkey))
1707 "authorization code using this method.");
1708 handle->response_code = MHD_HTTP_INTERNAL_SERVER_ERROR;
1715 for (tmp_ego =
ego_head; NULL != tmp_ego; tmp_ego = tmp_ego->
next)
1755 char term_data[
handle->rest_handle->data_size + 1];
1757 term_data[
handle->rest_handle->data_size] =
'\0';
1759 handle->rest_handle->data,
1760 handle->rest_handle->data_size);
1761 root = json_loads (term_data, JSON_DECODE_ANY, &error);
1762 identity = json_object_get (root,
"identity");
1766 "Error parsing json string from %s\n",
1768 handle->proc (
handle->proc_cls, resp, MHD_HTTP_BAD_REQUEST);
1779 "Set-Cookie", header_val));
1781 MHD_add_response_header (resp,
1782 "Access-Control-Allow-Methods",
1786 if (0 != strcmp (json_string_value (
identity),
"Denied"))
1811 char **client_secret)
1814 char *authorization;
1816 char *basic_authorization;
1817 char *client_id_tmp;
1832 credentials = strtok (authorization,
" ");
1833 if ((NULL == credentials) || (0 != strcmp (
"Basic", credentials)))
1835 credentials = strtok (NULL,
" ");
1836 if (NULL == credentials)
1839 strlen (credentials),
1840 (
void **) &basic_authorization);
1842 if (NULL == basic_authorization)
1844 client_id_tmp = strtok (basic_authorization,
":");
1845 if (NULL == client_id_tmp)
1850 pass = strtok (NULL,
":");
1856 *client_id = strdup (client_id_tmp);
1857 *client_secret = strdup (pass);
1866 char **client_secret)
1869 char *client_id_tmp;
1873 strlen (
"client_id"),
1880 handle->rest_handle->url_param_map,
1882 if (NULL == client_id_tmp)
1884 *client_id = strdup (client_id_tmp);
1886 strlen (
"client_secret"),
1904 *client_secret = strdup (pass);
1913 char *expected_pass;
1923 "Received client credentials in HTTP AuthZ header\n");
1930 "Received client credentials in POST body\n");
1936 if (NULL == pkce_cv)
1939 handle->response_code = MHD_HTTP_UNAUTHORIZED;
1946 strlen (received_cid),
1956 "reclaim-rest-plugin",
1957 "OIDC_CLIENT_SECRET",
1960 if (0 != strcmp (expected_pass, received_cpw))
1964 handle->response_code = MHD_HTTP_UNAUTHORIZED;
1977 handle->response_code = MHD_HTTP_INTERNAL_SERVER_ERROR;
1984 if (0 == strcmp (
handle->ego_entry->keystring, received_cid))
1987 if (NULL ==
handle->ego_entry)
1992 handle->response_code = MHD_HTTP_UNAUTHORIZED;
1996 strlen (received_cid),
2013 for (ego_entry =
ego_head; NULL != ego_entry;
2014 ego_entry = ego_entry->
next)
2044 struct MHD_Response *resp;
2047 char *json_response;
2052 char *code_verifier;
2060 "OIDC authorization for token endpoint failed\n");
2075 if (NULL == grant_type)
2079 handle->response_code = MHD_HTTP_BAD_REQUEST;
2088 handle->response_code = MHD_HTTP_BAD_REQUEST;
2100 handle->response_code = MHD_HTTP_BAD_REQUEST;
2105 if (NULL == ego_entry)
2109 handle->response_code = MHD_HTTP_BAD_REQUEST;
2117 if (NULL == code_verifier)
2120 "OAuth authorization request does not contain PKCE parameters!\n");
2131 handle->response_code = MHD_HTTP_BAD_REQUEST;
2133 if (NULL != code_verifier)
2138 if (NULL != code_verifier)
2143 "reclaim-rest-plugin",
2149 handle->response_code = MHD_HTTP_INTERNAL_SERVER_ERROR;
2162 "reclaim-rest-plugin",
2168 handle->response_code = MHD_HTTP_INTERNAL_SERVER_ERROR;
2182 (NULL != nonce) ? nonce : NULL,
2192 strlen (access_token),
2204 "OIDC access token already issued. Cleanup.\n");
2218 "Pragma",
"no-cache"));
2221 "application/json"));
2244 struct MHD_Response *resp;
2247 if (NULL !=
handle->consume_timeout_op)
2249 handle->consume_timeout_op = NULL;
2255 handle->attr_userinfo_list,
2274 handle->attr_userinfo_list->list_tail,
2276 if (NULL == presentation)
2278 for (atle =
handle->presentations->list_head;
2279 NULL != atle; atle = atle->
next)
2297 handle->presentations->list_tail,
2314 handle->consume_timeout_op = NULL;
2315 if (NULL !=
handle->idp_op)
2320 "Ticket consumptioned timed out. Using cache...\n");
2322 strlen (
handle->access_token),
2326 if (NULL == cached_code)
2330 handle->response_code = MHD_HTTP_UNAUTHORIZED;
2337 cached_code, NULL, &
ticket,
2343 handle->response_code = MHD_HTTP_BAD_REQUEST;
2351 struct MHD_Response *resp;
2383 char delimiter[] =
" ";
2385 char *authorization;
2386 char *authorization_type;
2387 char *authorization_access_token;
2401 handle->response_code = MHD_HTTP_UNAUTHORIZED;
2411 authorization_type = strtok (authorization, delimiter);
2412 if ((NULL == authorization_type) ||
2413 (0 != strcmp (
"Bearer", authorization_type)))
2417 handle->response_code = MHD_HTTP_UNAUTHORIZED;
2422 authorization_access_token = strtok (NULL, delimiter);
2423 if (NULL == authorization_access_token)
2427 handle->response_code = MHD_HTTP_UNAUTHORIZED;
2438 handle->response_code = MHD_HTTP_UNAUTHORIZED;
2448 if (NULL == aud_ego)
2452 handle->response_code = MHD_HTTP_UNAUTHORIZED;
2459 handle->attr_userinfo_list =
2514 const char *identifier)
2530 ego_entry->
ego = ego;
2538 if (identifier != NULL)
2540 for (ego_entry =
ego_head; NULL != ego_entry;
2541 ego_entry = ego_entry->
next)
2543 if (ego_entry->
ego == ego)
2551 if (NULL == ego_entry)
2557 ego_entry->
ego = ego;
2567 for (ego_entry =
ego_head; NULL != ego_entry;
2568 ego_entry = ego_entry->
next)
2570 if (ego_entry->
ego == ego)
2573 if (NULL == ego_entry)
2592 json_t *oidc_config;
2593 json_t *auth_methods;
2596 json_t *response_types;
2598 json_t *claim_types;
2599 char *oidc_config_str;
2600 struct MHD_Response *resp;
2603 oidc_config = json_object ();
2605 json_object_set_new (oidc_config,
2606 "issuer", json_string (
"http://localhost:7776"));
2607 json_object_set_new (oidc_config,
2608 "authorization_endpoint",
2609 json_string (
"https://api.reclaim/openid/authorize"));
2610 json_object_set_new (oidc_config,
2612 json_string (
"http://localhost:7776/openid/token"));
2613 auth_methods = json_array ();
2614 json_array_append_new (auth_methods,
2615 json_string (
"client_secret_basic"));
2616 json_array_append_new (auth_methods,
2617 json_string (
"client_secret_post"));
2618 json_object_set_new (oidc_config,
2619 "token_endpoint_auth_methods_supported",
2621 sig_algs = json_array ();
2622 json_array_append_new (sig_algs,
2623 json_string (
"HS512"));
2624 json_object_set_new (oidc_config,
2625 "id_token_signing_alg_values_supported",
2627 json_object_set_new (oidc_config,
2628 "userinfo_endpoint",
2629 json_string (
"http://localhost:7776/openid/userinfo"));
2630 scopes = json_array ();
2631 json_array_append_new (scopes,
2632 json_string (
"openid"));
2633 json_array_append_new (scopes,
2634 json_string (
"profile"));
2635 json_array_append_new (scopes,
2636 json_string (
"email"));
2637 json_array_append_new (scopes,
2638 json_string (
"address"));
2639 json_array_append_new (scopes,
2640 json_string (
"phone"));
2641 json_object_set_new (oidc_config,
2644 response_types = json_array ();
2645 json_array_append_new (response_types,
2646 json_string (
"code"));
2647 json_object_set_new (oidc_config,
2648 "response_types_supported",
2650 sub_types = json_array ();
2651 json_array_append_new (sub_types,
2652 json_string (
"public"));
2653 json_object_set_new (oidc_config,
2654 "subject_types_supported",
2656 claim_types = json_array ();
2657 json_array_append_new (claim_types,
2658 json_string (
"normal"));
2659 json_array_append_new (claim_types,
2660 json_string (
"aggregated"));
2661 json_object_set_new (oidc_config,
2662 "claim_types_supported",
2664 json_object_set_new (oidc_config,
2665 "claims_parameter_supported",
2667 oidc_config_str = json_dumps (oidc_config, JSON_INDENT (1));
2670 json_decref (oidc_config);
2688 struct MHD_Response *resp;
2694 MHD_add_response_header (resp,
2695 "Access-Control-Allow-Methods",
2698 MHD_add_response_header (resp,
2699 "Access-Control-Allow-Origin",
2716 { MHD_HTTP_METHOD_POST,
2737 handle->response_code = 0;
2739 handle->proc_cls = proc_cls;
2741 handle->rest_handle = rest_handle;
2785 "%s, %s, %s, %s, %s",
2786 MHD_HTTP_METHOD_GET,
2787 MHD_HTTP_METHOD_POST,
2788 MHD_HTTP_METHOD_PUT,
2789 MHD_HTTP_METHOD_DELETE,
2790 MHD_HTTP_METHOD_OPTIONS);
2793 _ (
"OpenID Connect REST API initialized\n"));
2844 while (NULL != (ego_entry =
ego_head))
2855 "OpenID Connect REST plugin is finished\n");
#define GNUNET_GNSRECORD_TYPE_RECLAIM_OIDC_REDIRECT
Used reclaimID OIDC client redirect URIs.
static int ret
Return value of the commandline.
static size_t data_size
Number of bytes in data.
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
struct Plugin * plugin
The process handle to the testbed service.
struct GNUNET_HashCode key
The key used in the DHT.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
uint32_t data
The data value.
struct GNUNET_IDENTITY_PrivateKey pk
Private key from command line option, or NULL.
static char * pkey
Public key of the zone to look in, in ASCII.
static struct GNUNET_IDENTITY_PublicKey pubkey
Public key of the zone to look in.
static char * value
Value of the record to add/remove.
static struct GNUNET_IDENTITY_Handle * identity
Which namespace do we publish to? NULL if we do not publish to a namespace.
static char * attr_name
The attribute.
static struct GNUNET_RECLAIM_Ticket ticket
Ticket to consume.
static struct GNUNET_RECLAIM_Identifier credential
Credential ID.
static struct GNUNET_DNSSTUB_Context * ctx
Context for DNS resolution.
char * GNUNET_buffer_reap_str(struct GNUNET_Buffer *buf)
Clear the buffer and return the string it contained.
void GNUNET_buffer_write_fstr(struct GNUNET_Buffer *buf, const char *fmt,...) __attribute__((format(printf
Write a 0-terminated formatted string to a buffer, excluding the 0-terminator.
void GNUNET_buffer_write_str(struct GNUNET_Buffer *buf, const char *str)
Write a 0-terminated string to a buffer, excluding the 0-terminator.
#define GNUNET_log(kind,...)
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
GNUNET_GenericReturnValue
Named constants for return values.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_time(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, struct GNUNET_TIME_Relative *time)
Get a configuration value that should be a relative time.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
void GNUNET_CONFIGURATION_iterate_section_values(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, GNUNET_CONFIGURATION_Iterator iter, void *iter_cls)
Iterate over values of a section in the configuration.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
struct GNUNET_GNS_LookupRequest * GNUNET_GNS_lookup(struct GNUNET_GNS_Handle *handle, const char *name, const struct GNUNET_IDENTITY_PublicKey *zone, uint32_t type, enum GNUNET_GNS_LocalOptions options, GNUNET_GNS_LookupResultProcessor proc, void *proc_cls)
Perform an asynchronous lookup operation on the GNS.
void GNUNET_GNS_disconnect(struct GNUNET_GNS_Handle *handle)
Shutdown connection with the GNS service.
void * GNUNET_GNS_lookup_cancel(struct GNUNET_GNS_LookupRequest *lr)
Cancel pending lookup request.
struct GNUNET_GNS_Handle * GNUNET_GNS_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize the connection with the GNS service.
@ GNUNET_GNS_LO_DEFAULT
Defaults, look in cache, then in DHT.
#define GNUNET_GNS_EMPTY_LABEL_AT
String we use to indicate an empty label (top-level entry in the zone).
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
int GNUNET_CONTAINER_multihashmap_contains(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Check if the map contains any value under the given key (including values that are NULL).
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
int GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
void * GNUNET_CONTAINER_multihashmap_get(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Given a key find a value in the map matching the key.
static int iterator(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Iterator over hash map entries.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE
If a value with the given key exists, replace it.
const struct GNUNET_IDENTITY_PrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
enum GNUNET_GenericReturnValue GNUNET_IDENTITY_public_key_from_string(const char *str, struct GNUNET_IDENTITY_PublicKey *key)
Parses a (Base32) string representation of the public key.
enum GNUNET_GenericReturnValue GNUNET_IDENTITY_key_get_public(const struct GNUNET_IDENTITY_PrivateKey *privkey, struct GNUNET_IDENTITY_PublicKey *key)
Retrieves the public key representation of a private key.
void GNUNET_IDENTITY_ego_get_public_key(struct GNUNET_IDENTITY_Ego *ego, struct GNUNET_IDENTITY_PublicKey *pk)
Get the identifier (public key) of an ego.
char * GNUNET_IDENTITY_public_key_to_string(const struct GNUNET_IDENTITY_PublicKey *key)
Creates a (Base32) string representation of the public key.
struct GNUNET_IDENTITY_Handle * GNUNET_IDENTITY_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_IDENTITY_Callback cb, void *cb_cls)
Connect to the identity service.
void GNUNET_IDENTITY_disconnect(struct GNUNET_IDENTITY_Handle *h)
Disconnect from identity service.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_strndup(a, length)
Wrapper around GNUNET_xstrndup_.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
#define GNUNET_RECLAIM_id_is_equal(a, b)
void GNUNET_RECLAIM_attribute_list_destroy(struct GNUNET_RECLAIM_AttributeList *attrs)
Destroy claim list.
struct GNUNET_RECLAIM_Credential * GNUNET_RECLAIM_credential_new(const char *name, uint32_t type, const void *data, size_t data_size)
Create a new credential.
void GNUNET_RECLAIM_credential_list_destroy(struct GNUNET_RECLAIM_CredentialList *credentials)
Destroy claim list.
void GNUNET_RECLAIM_presentation_list_destroy(struct GNUNET_RECLAIM_PresentationList *presentations)
Destroy presentations list.
struct GNUNET_RECLAIM_Attribute * GNUNET_RECLAIM_attribute_new(const char *attr_name, const struct GNUNET_RECLAIM_Identifier *credential, uint32_t type, const void *data, size_t data_size)
Create a new attribute claim.
struct GNUNET_RECLAIM_Presentation * GNUNET_RECLAIM_presentation_new(uint32_t type, const void *data, size_t data_size)
void GNUNET_RECLAIM_disconnect(struct GNUNET_RECLAIM_Handle *h)
Disconnect from identity provider service.
struct GNUNET_RECLAIM_AttributeIterator * GNUNET_RECLAIM_get_attributes_start(struct GNUNET_RECLAIM_Handle *h, const struct GNUNET_IDENTITY_PrivateKey *identity, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_RECLAIM_AttributeResult proc, void *proc_cls, GNUNET_SCHEDULER_TaskCallback finish_cb, void *finish_cb_cls)
List all attributes for a local identity.
void GNUNET_RECLAIM_cancel(struct GNUNET_RECLAIM_Operation *op)
Cancel an identity provider operation.
void GNUNET_RECLAIM_get_attributes_stop(struct GNUNET_RECLAIM_AttributeIterator *it)
Stops iteration and releases the handle for further calls.
void GNUNET_RECLAIM_get_credentials_next(struct GNUNET_RECLAIM_CredentialIterator *ait)
Calls the record processor specified in GNUNET_RECLAIM_get_credentials_start for the next record.
struct GNUNET_RECLAIM_CredentialIterator * GNUNET_RECLAIM_get_credentials_start(struct GNUNET_RECLAIM_Handle *h, const struct GNUNET_IDENTITY_PrivateKey *identity, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_RECLAIM_CredentialResult proc, void *proc_cls, GNUNET_SCHEDULER_TaskCallback finish_cb, void *finish_cb_cls)
List all credentials for a local identity.
void GNUNET_RECLAIM_get_attributes_next(struct GNUNET_RECLAIM_AttributeIterator *it)
Calls the record processor specified in GNUNET_RECLAIM_get_attributes_start for the next record.
struct GNUNET_RECLAIM_Operation * GNUNET_RECLAIM_ticket_issue(struct GNUNET_RECLAIM_Handle *h, const struct GNUNET_IDENTITY_PrivateKey *iss, const struct GNUNET_IDENTITY_PublicKey *rp, const struct GNUNET_RECLAIM_AttributeList *attrs, GNUNET_RECLAIM_IssueTicketCallback cb, void *cb_cls)
Issues a ticket to a relying party.
struct GNUNET_RECLAIM_Handle * GNUNET_RECLAIM_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the re:claimID service.
void GNUNET_RECLAIM_get_credentials_stop(struct GNUNET_RECLAIM_CredentialIterator *ait)
Stops iteration and releases the handle for further calls.
struct GNUNET_RECLAIM_Operation * GNUNET_RECLAIM_ticket_consume(struct GNUNET_RECLAIM_Handle *h, const struct GNUNET_IDENTITY_PrivateKey *identity, const struct GNUNET_RECLAIM_Ticket *ticket, GNUNET_RECLAIM_AttributeTicketResult cb, void *cb_cls)
Consumes an issued ticket.
void GNUNET_RECLAIM_ticket_iteration_stop(struct GNUNET_RECLAIM_TicketIterator *it)
Stops iteration and releases the handle for further calls.
struct MHD_Response * GNUNET_REST_create_response(const char *data)
Create REST MHD response.
int GNUNET_REST_handle_request(struct GNUNET_REST_RequestHandle *conn, const struct GNUNET_REST_RequestHandler *handlers, struct GNUNET_REST_RequestHandlerError *err, void *cls)
void(* GNUNET_REST_ResultProcessor)(void *cls, struct MHD_Response *resp, int status)
Iterator called on obtained result for a REST result.
#define GNUNET_REST_HANDLER_END
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
size_t GNUNET_STRINGS_urldecode(const char *data, size_t len, char **out)
url/percent encode (RFC3986).
char * GNUNET_STRINGS_data_to_string_alloc(const void *buf, size_t size)
Return the base32crockford encoding of the given buffer.
size_t GNUNET_STRINGS_urlencode(const char *data, size_t len, char **out)
url/percent encode (RFC3986).
enum GNUNET_GenericReturnValue GNUNET_STRINGS_string_to_data(const char *enc, size_t enclen, void *out, size_t out_size)
Convert CrockfordBase32 encoding back to data.
size_t GNUNET_STRINGS_base64_decode(const char *data, size_t len, void **output)
Decode from Base64.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_get_second_(void)
Return relative time of 1s.
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
char * OIDC_generate_id_token(const struct GNUNET_IDENTITY_PublicKey *aud_key, const struct GNUNET_IDENTITY_PublicKey *sub_key, const struct GNUNET_RECLAIM_AttributeList *attrs, const struct GNUNET_RECLAIM_PresentationList *presentations, const struct GNUNET_TIME_Relative *expiration_time, const char *nonce, const char *secret_key)
Create a JWT from attributes.
char * OIDC_generate_userinfo(const struct GNUNET_IDENTITY_PublicKey *sub_key, const struct GNUNET_RECLAIM_AttributeList *attrs, const struct GNUNET_RECLAIM_PresentationList *presentations)
Generate userinfo JSON as string.
char * OIDC_access_token_new(const struct GNUNET_RECLAIM_Ticket *ticket)
Generate a new access token.
enum GNUNET_GenericReturnValue OIDC_check_scopes_for_claim_request(const char *scopes, const char *attr)
Checks if a claim is implicitly requested through standard scope(s) or explicitly through non-standar...
char * OIDC_build_authz_code(const struct GNUNET_IDENTITY_PrivateKey *issuer, const struct GNUNET_RECLAIM_Ticket *ticket, const struct GNUNET_RECLAIM_AttributeList *attrs, const struct GNUNET_RECLAIM_PresentationList *presentations, const char *nonce_str, const char *code_challenge)
Builds an OIDC authorization code including a reclaim ticket and nonce.
int OIDC_parse_authz_code(const struct GNUNET_IDENTITY_PublicKey *audience, const char *code, const char *code_verifier, struct GNUNET_RECLAIM_Ticket *ticket, struct GNUNET_RECLAIM_AttributeList **attrs, struct GNUNET_RECLAIM_PresentationList **presentations, char **nonce_str, enum OIDC_VerificationOptions opts)
Parse reclaim ticket and nonce from authorization code.
void OIDC_build_token_response(const char *access_token, const char *id_token, const struct GNUNET_TIME_Relative *expiration_time, char **token_response)
Build a token response for a token request TODO: Maybe we should add the scope here?
int OIDC_access_token_parse(const char *token, struct GNUNET_RECLAIM_Ticket **ticket)
Parse an access token.
helper library for OIDC related functions
@ OIDC_VERIFICATION_NO_CODE_VERIFIER
Do not check code verifier even if expected.
@ OIDC_VERIFICATION_DEFAULT
Strict verification.
static struct EgoEntry * ego_tail
Ego list.
#define OIDC_SCOPE_KEY
OIDC scope key.
static int attr_in_userinfo_request(struct RequestHandle *handle, const char *attr_name)
#define OIDC_AUTHORIZATION_HEADER_KEY
OIDC cookie header information key.
#define GNUNET_REST_API_NS_OIDC_CONFIG
OIDC config.
static struct GNUNET_RECLAIM_Handle * idp
Identity Provider.
static void consume_timeout(void *cls)
struct GNUNET_CONTAINER_MultiHashMap * oidc_code_cache
OIDC hashmap for cached access tokens and codes.
static void cookie_identity_interpretation(struct RequestHandle *handle)
Interprets cookie header and pass its identity keystring to handle.
static struct GNUNET_GNS_Handle * gns_handle
GNS handle.
#define OIDC_ERROR_KEY_INVALID_REQUEST
OIDC error key for invalid requests.
static int attr_in_claims_request(struct RequestHandle *handle, const char *attr_name, const char *claims_parameter)
static void oidc_attr_collect(void *cls, const struct GNUNET_IDENTITY_PublicKey *identity, const struct GNUNET_RECLAIM_Attribute *attr)
Collects all attributes for an ego if in scope parameter.
#define GNUNET_REST_API_NS_LOGIN
Login namespace.
#define OIDC_ERROR_KEY_UNAUTHORIZED_CLIENT
OIDC error key for unauthorized clients.
#define GNUNET_REST_API_NS_OIDC
REST root namespace.
static char * OIDC_ignored_parameter_array[]
OIDC ignored parameter array.
static void do_timeout(void *cls)
Task run on timeout, sends error message.
static int parse_credentials_post_body(struct RequestHandle *handle, char **client_id, char **client_secret)
static void token_endpoint(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Responds to token url-encoded POST request.
static void userinfo_endpoint(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Responds to userinfo GET and url-encoded POST request.
#define OIDC_ERROR_KEY_UNSUPPORTED_GRANT_TYPE
OIDC error key for unsupported grants.
#define OIDC_ERROR_KEY_INVALID_TOKEN
OIDC error key for invalid tokens.
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration handle.
#define OIDC_CLAIMS_KEY
OIDC claims key.
struct GNUNET_CONTAINER_MultiHashMap * OIDC_cookie_jar_map
OIDC hashmap that keeps track of issued cookies.
#define OIDC_ERROR_KEY_SERVER_ERROR
OIDC error key for generic server errors.
#define OIDC_COOKIE_EXPIRATION
OIDC cookie expiration (in seconds)
#define OIDC_ERROR_KEY_ACCESS_DENIED
OIDC error key for denied access.
const struct EgoEntry * find_ego(struct RequestHandle *handle, struct GNUNET_IDENTITY_PublicKey *test_key)
static void login_cont(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Combines an identity with a login time and responds OK to login request.
#define OIDC_COOKIE_HEADER_KEY
OIDC cookie header key.
#define ID_REST_STATE_INIT
State while collecting all egos.
#define OIDC_REDIRECT_URI_KEY
OIDC redirect_uri key.
static void do_redirect_error(void *cls)
Task run on error, sends error message and redirects.
static void code_redirect(void *cls)
Checks time and cookie and redirects accordingly.
static struct RequestHandle * requests_head
DLL.
static void options_cont(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Respond to OPTIONS request.
#define OIDC_NONCE_KEY
OIDC nonce key.
#define OIDC_ERROR_KEY_INVALID_CLIENT
OIDC error key for invalid client.
void * libgnunet_plugin_rest_openid_connect_done(void *cls)
Exit point from the plugin.
static int parse_credentials_basic_auth(struct RequestHandle *handle, char **client_id, char **client_secret)
static void oidc_cred_collect(void *cls, const struct GNUNET_IDENTITY_PublicKey *identity, const struct GNUNET_RECLAIM_Credential *cred)
Collects all attributes for an ego if in scope parameter.
#define OIDC_GRANT_TYPE_KEY
OIDC grant_type key.
static int state
The processing state.
#define OIDC_ERROR_KEY_INVALID_COOKIE
OIDC error key for invalid cookies.
static struct EgoEntry * ego_head
Ego list.
static void list_ego(void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *identifier)
If listing is enabled, prints information about the egos.
static void oidc_cred_collect_finished_cb(void *cls)
#define OIDC_CODE_CHALLENGE_KEY
OIDC PKCE code challenge.
static char * allow_methods
HTTP methods allows for this plugin.
static void oidc_config_endpoint(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
static void cleanup_handle(struct RequestHandle *handle)
Cleanup lookup handle.
#define OIDC_COOKIE_HEADER_ACCESS_DENIED
OIDC cookie header if user cancelled.
#define GNUNET_REST_API_NS_TOKEN
Token endpoint.
#define CONSUME_TIMEOUT
How long to wait for a consume in userinfo endpoint.
#define OIDC_EXPECTED_AUTHORIZATION_SCOPE
OIDC expected scope part while authorizing.
static void build_authz_response(void *cls)
Iteration over all results finished, build final response.
static void do_userinfo_error(void *cls)
Task run on error in userinfo endpoint, sends error header.
static void oidc_ticket_issue_cb(void *cls, const struct GNUNET_RECLAIM_Ticket *ticket, const struct GNUNET_RECLAIM_PresentationList *presentation)
Issues ticket and redirects to relying party with the authorization code as parameter.
#define OIDC_RESPONSE_TYPE_KEY
OIDC response_type key.
static struct RequestHandle * requests_tail
DLL.
#define OIDC_COOKIE_HEADER_INFORMATION_KEY
OIDC cookie header information key.
static char * get_url_parameter_copy(const struct RequestHandle *handle, const char *key)
#define OIDC_STATE_KEY
OIDC state key.
static struct GNUNET_IDENTITY_Handle * identity_handle
Handle to Identity service.
static void tld_iter(void *cls, const char *section, const char *option, const char *value)
Iterate over tlds in config.
void * libgnunet_plugin_rest_openid_connect_init(void *cls)
Entry point for the plugin.
#define OIDC_EXPECTED_AUTHORIZATION_RESPONSE_TYPE
OIDC expected response_type while authorizing.
static int check_authorization(struct RequestHandle *handle, struct GNUNET_IDENTITY_PublicKey *cid)
#define GNUNET_REST_API_NS_USERINFO
UserInfo endpoint.
static struct GNUNET_RECLAIM_AttributeList * attribute_list_merge(struct GNUNET_RECLAIM_AttributeList *list_a, struct GNUNET_RECLAIM_AttributeList *list_b)
#define GNUNET_REST_API_NS_AUTHORIZE
Authorize endpoint.
static void oidc_config_cors(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Respond to OPTIONS request.
#define OIDC_CODE_KEY
OIDC code key.
#define OIDC_CODE_VERIFIER_KEY
OIDC PKCE code verifier.
static void authorize_endpoint(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Responds to authorization GET and url-encoded POST request.
#define OIDC_CLIENT_ID_KEY
OIDC client_id key.
#define OIDC_GRANT_TYPE_VALUE
OIDC grant_type key.
#define ID_REST_STATE_POST_INIT
Done collecting egos.
static int cleanup_hashmap(void *cls, const struct GNUNET_HashCode *key, void *value)
static void lookup_redirect_uri_result(void *cls, uint32_t rd_count, const struct GNUNET_GNSRECORD_Data *rd)
static enum GNUNET_GenericReturnValue rest_identity_process_request(struct GNUNET_REST_RequestHandle *rest_handle, GNUNET_REST_ResultProcessor proc, void *proc_cls)
static void build_redirect(void *cls)
static void oidc_attr_collect_finished_cb(void *cls)
#define OIDC_ERROR_KEY_UNSUPPORTED_RESPONSE_TYPE
OIDC error key for unsupported response types.
static void consume_ticket(void *cls, const struct GNUNET_IDENTITY_PublicKey *identity, const struct GNUNET_RECLAIM_Attribute *attr, const struct GNUNET_RECLAIM_Presentation *presentation)
Collects claims and stores them in handle.
#define OIDC_ERROR_KEY_INVALID_SCOPE
OIDC error key for invalid scopes.
static void do_error(void *cls)
Task run on error, sends error message.
static void oidc_iteration_error(void *cls)
Does internal server error when iteration failed.
static void client_redirect(void *cls)
Initiate redirect back to client.
static void login_redirect(void *cls)
Redirects to login page stored in configuration file.
static int attr_in_idtoken_request(struct RequestHandle *handle, const char *attr_name)
char * identifier
Ego Identifier.
struct EgoEntry * prev
DLL.
char * keystring
Public key string.
struct EgoEntry * next
DLL.
struct GNUNET_IDENTITY_Ego * ego
The Ego.
void * cls
Closure for all of the callbacks.
Common buffer management functions.
Internal representation of the hash map.
size_t data_size
Number of bytes in data.
Connection to the GNS service.
Handle to a lookup request.
Handle for an operation with the identity service.
A private key for an identity as per LSD0001.
An identity key as per LSD0001.
Handle for a attribute iterator operation.
struct GNUNET_RECLAIM_Attribute * attribute
The attribute claim.
struct GNUNET_RECLAIM_AttributeListEntry * next
DLL.
A list of GNUNET_RECLAIM_Attribute structures.
struct GNUNET_RECLAIM_AttributeListEntry * list_tail
List tail.
struct GNUNET_RECLAIM_AttributeListEntry * list_head
List head.
const char * name
The name of the attribute.
struct GNUNET_RECLAIM_Identifier credential
Referenced ID of credential (may be GNUNET_RECLAIM_ID_ZERO if self-creded)
struct GNUNET_RECLAIM_Identifier id
ID.
uint32_t type
Type of Claim.
const void * data
Binary value stored as attribute value.
size_t data_size
Number of bytes in data.
Handle for a credential iterator operation.
struct GNUNET_RECLAIM_CredentialListEntry * next
DLL.
struct GNUNET_RECLAIM_Credential * credential
The credential.
A list of GNUNET_RECLAIM_Credential structures.
uint32_t type
Type/Format of Claim.
const char * name
The name of the credential.
const void * data
Binary value stored as credential value.
size_t data_size
Number of bytes in data.
struct GNUNET_RECLAIM_Identifier id
ID.
Handle for an operation with the service.
struct GNUNET_RECLAIM_Presentation * presentation
The credential.
struct GNUNET_RECLAIM_PresentationListEntry * next
DLL.
A list of GNUNET_RECLAIM_Presentation structures.
A credential presentation.
const void * data
Binary value stored as presentation value.
uint32_t type
Type/Format of Claim.
struct GNUNET_RECLAIM_Identifier credential_id
The credential id of which this is a presentation.
Handle for a ticket iterator operation.
The authorization ticket.
struct GNUNET_IDENTITY_PublicKey audience
The ticket audience (= relying party)
struct GNUNET_IDENTITY_PublicKey identity
The ticket issuer (= the user)
struct returned by the initialization function of the plugin
void * cls
The closure of the plugin.
enum GNUNET_GenericReturnValue(* process_request)(struct GNUNET_REST_RequestHandle *handle, GNUNET_REST_ResultProcessor proc, void *proc_cls)
Function to process a REST call.
const char * url
The url as string.
void(* proc)(struct GNUNET_REST_RequestHandle *handle, const char *url, void *cls)
Namespace to handle.
Entry in list of pending tasks.
Time for absolute times used by GNUnet, in microseconds.
uint64_t abs_value_us
The actual value.
Time for relative time used by GNUnet, in microseconds.
char * login_identity
The identity chosen by the user to login.
char * client_id
The OIDC client id of the RP.
char * response_type
The OIDC response type.
int user_cancelled
User cancelled authorization/login.
struct GNUNET_IDENTITY_PublicKey client_pkey
The RP client public key.
char * redirect_uri
The OIDC redirect uri.
char * claims
The OIDC claims.
char * code_challenge
The PKCE code_challenge.
char * scope
The list of oidc scopes.
char * code_verifier
The PKCE code_verifier.
char * nonce
The OIDC nonce.
char * state
The OIDC state.
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
struct GNUNET_RECLAIM_TicketIterator * ticket_it
Ticket iterator.
struct GNUNET_RECLAIM_Ticket ticket
A ticket.
char * emsg
Error response message.
struct GNUNET_IDENTITY_Operation * op
IDENTITY Operation.
struct RequestHandle * prev
DLL.
struct GNUNET_RECLAIM_PresentationList * presentations
Presentations.
struct GNUNET_RECLAIM_Operation * idp_op
Idp Operation.
struct GNUNET_RECLAIM_AttributeList * attr_idtoken_list
Attribute claim list for id_token.
int response_code
Response code.
struct EgoEntry * ego_entry
IDENTITY Operation.
struct GNUNET_SCHEDULER_Task * timeout_task
ID of a task associated with the resolution process.
void * proc_cls
The closure of the result processor.
char * access_token
The passed access token.
char * redirect_prefix
The redirect prefix.
struct GNUNET_RECLAIM_AttributeIterator * attr_it
Attribute iterator.
GNUNET_REST_ResultProcessor proc
The plugin result processor.
char * redirect_suffix
The redirect suffix.
struct RequestHandle * next
DLL.
struct GNUNET_IDENTITY_PrivateKey priv_key
Pointer to ego private key.
struct GNUNET_RECLAIM_CredentialIterator * cred_it
Credential iterator.
struct GNUNET_REST_RequestHandle * rest_handle
Rest connection.
int public_client
Public client.
char * tld
The tld for redirect.
struct OIDC_Variables * oidc
OIDC variables.
struct GNUNET_RECLAIM_AttributeList * attr_userinfo_list
Attribute claim list for userinfo.
struct GNUNET_GNS_LookupRequest * gns_op
GNS lookup op.
struct GNUNET_RECLAIM_CredentialList * credentials
Credentials.
struct GNUNET_SCHEDULER_Task * consume_timeout_op
Timeout task for consume.
struct GNUNET_TIME_Relative timeout
Desired timeout for the lookup (default is no timeout).
char * edesc
Error response description.