2 This file is part of GNUnet
3 Copyright (C) 2010-2015 GNUnet e.V.
5 GNUnet is free software: you can redistribute it and/or modify it
6 under the terms of the GNU Affero General Public License as published
7 by the Free Software Foundation, either version 3 of the License,
8 or (at your option) any later version.
10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Affero General Public License for more details.
15 You should have received a copy of the GNU Affero General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>.
18 SPDX-License-Identifier: AGPL3.0-or-later
22 * @file reclaim/oidc_helper.c
23 * @brief helper library for OIDC related functions
24 * @author Martin Schanzenbach
29 #include "gnunet_util_lib.h"
30 #include "gnunet_reclaim_attribute_lib.h"
31 #include "gnunet_reclaim_service.h"
32 #include "gnunet_signatures.h"
33 #include "oidc_helper.h"
37 create_jwt_header (void)
42 root = json_object ();
43 json_object_set_new (root, JWT_ALG, json_string (JWT_ALG_VALUE));
44 json_object_set_new (root, JWT_TYP, json_string (JWT_TYP_VALUE));
46 json_str = json_dumps (root, JSON_INDENT (0) | JSON_COMPACT);
52 replace_char (char *str, char find, char replace)
54 char *current_pos = strchr (str, find);
57 *current_pos = replace;
58 current_pos = strchr (current_pos, find);
64 fix_base64 (char *str)
67 replace_char (str, '+', '-');
70 replace_char (str, '/', '_');
74 * Create a JWT from attributes
76 * @param aud_key the public of the audience
77 * @param sub_key the public key of the subject
78 * @param attrs the attribute list
79 * @param expiration_time the validity of the token
80 * @param secret_key the key used to sign the JWT
81 * @return a new base64-encoded JWT string.
84 OIDC_id_token_new (const struct GNUNET_CRYPTO_EcdsaPublicKey *aud_key,
85 const struct GNUNET_CRYPTO_EcdsaPublicKey *sub_key,
86 const struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attrs,
87 const struct GNUNET_TIME_Relative *expiration_time,
89 const char *secret_key)
91 struct GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry *le;
92 struct GNUNET_HashCode signature;
93 struct GNUNET_TIME_Absolute exp_time;
94 struct GNUNET_TIME_Absolute time_now;
102 char *signature_target;
103 char *signature_base64;
107 // iat REQUIRED time now
108 time_now = GNUNET_TIME_absolute_get ();
109 // exp REQUIRED time expired from config
110 exp_time = GNUNET_TIME_absolute_add (time_now, *expiration_time);
111 // auth_time only if max_age
112 // nonce only if nonce
113 // OPTIONAL acr,amr,azp
115 GNUNET_STRINGS_data_to_string_alloc (sub_key,
117 GNUNET_CRYPTO_EcdsaPublicKey));
119 GNUNET_STRINGS_data_to_string_alloc (aud_key,
121 GNUNET_CRYPTO_EcdsaPublicKey));
122 header = create_jwt_header ();
123 body = json_object ();
125 // iss REQUIRED case sensitive server uri with https
126 // The issuer is the local reclaim instance (e.g.
127 // https://reclaim.id/api/openid)
128 json_object_set_new (body, "iss", json_string (SERVER_ADDRESS));
129 // sub REQUIRED public key identity, not exceed 255 ASCII length
130 json_object_set_new (body, "sub", json_string (subject));
131 // aud REQUIRED public key client_id must be there
132 json_object_set_new (body, "aud", json_string (audience));
134 json_object_set_new (body,
136 json_integer (time_now.abs_value_us / (1000 * 1000)));
138 json_object_set_new (body,
140 json_integer (exp_time.abs_value_us / (1000 * 1000)));
142 json_object_set_new (body,
144 json_integer (time_now.abs_value_us / (1000 * 1000)));
147 json_object_set_new (body, "nonce", json_string (nonce));
149 for (le = attrs->list_head; NULL != le; le = le->next)
152 GNUNET_RECLAIM_ATTRIBUTE_value_to_string (le->claim->type,
154 le->claim->data_size);
155 json_object_set_new (body, le->claim->name, json_string (attr_val_str));
156 GNUNET_free (attr_val_str);
158 body_str = json_dumps (body, JSON_INDENT (0) | JSON_COMPACT);
161 GNUNET_STRINGS_base64_encode (header, strlen (header), &header_base64);
162 fix_base64 (header_base64);
164 GNUNET_STRINGS_base64_encode (body_str, strlen (body_str), &body_base64);
165 fix_base64 (body_base64);
167 GNUNET_free (subject);
168 GNUNET_free (audience);
171 * Creating the JWT signature. This might not be
172 * standards compliant, check.
174 GNUNET_asprintf (&signature_target, "%s.%s", header_base64, body_base64);
175 GNUNET_CRYPTO_hmac_raw (secret_key,
178 strlen (signature_target),
180 GNUNET_STRINGS_base64_encode ((const char *) &signature,
181 sizeof (struct GNUNET_HashCode),
183 fix_base64 (signature_base64);
185 GNUNET_asprintf (&result,
191 GNUNET_free (signature_target);
192 GNUNET_free (header);
193 GNUNET_free (body_str);
194 GNUNET_free (signature_base64);
195 GNUNET_free (body_base64);
196 GNUNET_free (header_base64);
200 /* Converts a hex character to its integer value */
204 return isdigit (ch) ? ch - '0' : tolower (ch) - 'a' + 10;
207 /* Converts an integer value to its hex character*/
211 static char hex[] = "0123456789abcdef";
212 return hex[code & 15];
215 /* Returns a url-encoded version of str */
216 /* IMPORTANT: be sure to free() the returned string after use */
218 url_encode (const char *str)
220 char *pstr = (char *) str;
221 char *buf = GNUNET_malloc (strlen (str) * 3 + 1);
225 if (isalnum (*pstr) || *pstr == '-' || *pstr == '_' || *pstr == '.' ||
228 else if (*pstr == ' ')
233 *pbuf++ = to_hex (*pstr >> 4);
234 *pbuf++ = to_hex (*pstr & 15);
243 /* Returns a url-decoded version of str */
244 /* IMPORTANT: be sure to free() the returned string after use */
246 url_decode (const char *str)
248 char *pstr = (char *) str;
249 char *buf = GNUNET_malloc (strlen (str) + 1);
255 if (pstr[1] && pstr[2])
257 *pbuf++ = from_hex (pstr[1]) << 4 | from_hex (pstr[2]);
261 else if (*pstr == '+')
277 * Returns base64 encoded string urlencoded
279 * @param string the string to encode
280 * @return base64 encoded string
283 base64_encode (const char *data, size_t data_size)
288 GNUNET_STRINGS_base64_encode (data, data_size, &enc);
289 enc_urlencode = url_encode (enc);
291 return enc_urlencode;
296 derive_aes_key (struct GNUNET_CRYPTO_SymmetricSessionKey *key,
297 struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
298 struct GNUNET_HashCode *key_material)
300 static const char ctx_key[] = "reclaim-aes-ctx-key";
301 static const char ctx_iv[] = "reclaim-aes-ctx-iv";
302 GNUNET_CRYPTO_kdf (key,
303 sizeof (struct GNUNET_CRYPTO_SymmetricSessionKey),
307 sizeof (struct GNUNET_HashCode),
309 GNUNET_CRYPTO_kdf (iv,
311 struct GNUNET_CRYPTO_SymmetricInitializationVector),
315 sizeof (struct GNUNET_HashCode),
321 calculate_key_priv (struct GNUNET_CRYPTO_SymmetricSessionKey *key,
322 struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
323 const struct GNUNET_CRYPTO_EcdsaPrivateKey *ecdsa_priv,
324 const struct GNUNET_CRYPTO_EcdhePublicKey *ecdh_pub)
326 struct GNUNET_HashCode key_material;
327 GNUNET_CRYPTO_ecdsa_ecdh (ecdsa_priv, ecdh_pub, &key_material);
328 derive_aes_key (key, iv, &key_material);
333 calculate_key_pub (struct GNUNET_CRYPTO_SymmetricSessionKey *key,
334 struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
335 const struct GNUNET_CRYPTO_EcdsaPublicKey *ecdsa_pub,
336 const struct GNUNET_CRYPTO_EcdhePrivateKey *ecdh_priv)
338 struct GNUNET_HashCode key_material;
339 GNUNET_CRYPTO_ecdh_ecdsa (ecdh_priv, ecdsa_pub, &key_material);
340 derive_aes_key (key, iv, &key_material);
345 decrypt_payload (const struct GNUNET_CRYPTO_EcdsaPrivateKey *ecdsa_priv,
346 const struct GNUNET_CRYPTO_EcdhePublicKey *ecdh_pub,
351 struct GNUNET_CRYPTO_SymmetricSessionKey key;
352 struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
354 calculate_key_priv (&key, &iv, ecdsa_priv, ecdh_pub);
355 GNUNET_break (GNUNET_CRYPTO_symmetric_decrypt (ct, ct_len, &key, &iv, buf));
360 encrypt_payload (const struct GNUNET_CRYPTO_EcdsaPublicKey *ecdsa_pub,
361 const struct GNUNET_CRYPTO_EcdhePrivateKey *ecdh_priv,
366 struct GNUNET_CRYPTO_SymmetricSessionKey key;
367 struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
369 calculate_key_pub (&key, &iv, ecdsa_pub, ecdh_priv);
371 GNUNET_CRYPTO_symmetric_encrypt (payload, payload_len, &key, &iv, buf));
376 * Builds an OIDC authorization code including
377 * a reclaim ticket and nonce
379 * @param issuer the issuer of the ticket, used to sign the ticket and nonce
380 * @param ticket the ticket to include in the code
381 * @param attrs list of attributes whicha re shared
382 * @param nonce the nonce to include in the code
383 * @return a new authorization code (caller must free)
386 OIDC_build_authz_code (const struct GNUNET_CRYPTO_EcdsaPrivateKey *issuer,
387 const struct GNUNET_RECLAIM_Ticket *ticket,
388 struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attrs,
389 const char *nonce_str)
396 size_t signature_payload_len;
397 size_t attr_list_len;
398 size_t code_payload_len;
401 struct GNUNET_CRYPTO_EccSignaturePurpose *purpose;
402 struct GNUNET_CRYPTO_EcdhePrivateKey *ecdh_priv;
403 struct GNUNET_CRYPTO_EcdhePublicKey ecdh_pub;
406 signature_payload_len =
407 sizeof (struct GNUNET_RECLAIM_Ticket) + sizeof (uint32_t);
410 attr_list_len = GNUNET_RECLAIM_ATTRIBUTE_list_serialize_get_size (attrs);
411 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
412 "Length of serialized attributes: %lu\n",
414 signature_payload_len += attr_list_len;
415 attrs_ser = GNUNET_malloc (attr_list_len);
416 GNUNET_RECLAIM_ATTRIBUTE_list_serialize (attrs, attrs_ser);
418 code_payload_len = sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
419 sizeof (struct GNUNET_CRYPTO_EcdhePublicKey) +
420 signature_payload_len +
421 sizeof (struct GNUNET_CRYPTO_EcdsaSignature);
422 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
423 "Length of data to encode: %lu\n",
425 plaintext = GNUNET_malloc (signature_payload_len);
426 // First, copy ticket
428 memcpy (buf_ptr, ticket, sizeof (struct GNUNET_RECLAIM_Ticket));
429 buf_ptr += sizeof (struct GNUNET_RECLAIM_Ticket);
432 if (NULL != nonce_str)
434 if ((1 != SSCANF (nonce_str, "%u", &nonce)) || (nonce > UINT32_MAX))
437 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Invalid nonce %s\n", nonce_str);
438 GNUNET_free (plaintext);
439 GNUNET_free_non_null (attrs_ser);
442 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
443 "Got nonce: %u from %s\n",
447 nonce_tmp = htonl (nonce);
448 memcpy (buf_ptr, &nonce_tmp, sizeof (uint32_t));
449 buf_ptr += sizeof (uint32_t);
450 // Finally, attributes
451 if (NULL != attrs_ser)
453 memcpy (buf_ptr, attrs_ser, attr_list_len);
454 buf_ptr += attr_list_len;
455 GNUNET_free (attrs_ser);
458 ecdh_priv = GNUNET_CRYPTO_ecdhe_key_create ();
459 GNUNET_CRYPTO_ecdhe_key_get_public (ecdh_priv, &ecdh_pub);
460 // Initialize code payload
461 code_payload = GNUNET_malloc (code_payload_len);
462 GNUNET_assert (NULL != code_payload);
463 purpose = (struct GNUNET_CRYPTO_EccSignaturePurpose *) code_payload;
464 purpose->size = htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
465 sizeof (ecdh_pub) + signature_payload_len);
466 purpose->purpose = htonl (GNUNET_SIGNATURE_PURPOSE_RECLAIM_CODE_SIGN);
468 buf_ptr = (char *) &purpose[1];
469 memcpy (buf_ptr, &ecdh_pub, sizeof (ecdh_pub));
470 buf_ptr += sizeof (ecdh_pub);
471 // Encrypt plaintext and store
472 encrypt_payload (&ticket->audience,
475 signature_payload_len,
477 GNUNET_free (ecdh_priv);
478 GNUNET_free (plaintext);
479 buf_ptr += signature_payload_len;
480 // Sign and store signature
482 GNUNET_CRYPTO_ecdsa_sign (issuer,
484 (struct GNUNET_CRYPTO_EcdsaSignature *)
488 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Unable to sign code\n");
489 GNUNET_free (code_payload);
492 code_str = base64_encode (code_payload, code_payload_len);
493 GNUNET_free (code_payload);
499 * Parse reclaim ticket and nonce from
500 * authorization code.
501 * This also verifies the signature in the code.
503 * @param audience the expected audience of the code
504 * @param code the string representation of the code
505 * @param ticket where to store the ticket
506 * @param attrs the attributes in the code
507 * @param nonce where to store the nonce
508 * @return GNUNET_OK if successful, else GNUNET_SYSERR
511 OIDC_parse_authz_code (const struct GNUNET_CRYPTO_EcdsaPrivateKey *ecdsa_priv,
513 struct GNUNET_RECLAIM_Ticket *ticket,
514 struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList **attrs,
520 struct GNUNET_CRYPTO_EccSignaturePurpose *purpose;
521 struct GNUNET_CRYPTO_EcdsaSignature *signature;
522 struct GNUNET_CRYPTO_EcdsaPublicKey ecdsa_pub;
523 struct GNUNET_CRYPTO_EcdhePublicKey *ecdh_pub;
524 size_t code_payload_len;
525 size_t attrs_ser_len;
526 size_t signature_offset;
527 size_t plaintext_len;
530 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Trying to decode `%s'\n", code);
533 GNUNET_STRINGS_base64_decode (code, strlen (code), (void **) &code_payload);
534 if (code_payload_len < sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
535 sizeof (struct GNUNET_CRYPTO_EcdhePublicKey) +
536 sizeof (struct GNUNET_RECLAIM_Ticket) +
538 sizeof (struct GNUNET_CRYPTO_EcdsaSignature))
540 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Authorization code malformed\n");
541 GNUNET_free_non_null (code_payload);
542 return GNUNET_SYSERR;
545 purpose = (struct GNUNET_CRYPTO_EccSignaturePurpose *) code_payload;
546 attrs_ser_len = code_payload_len;
547 attrs_ser_len -= sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose);
548 ptr = (char *) &purpose[1];
550 ecdh_pub = (struct GNUNET_CRYPTO_EcdhePublicKey *) ptr;
551 ptr += sizeof (struct GNUNET_CRYPTO_EcdhePublicKey);
552 attrs_ser_len -= sizeof (struct GNUNET_CRYPTO_EcdhePublicKey);
554 // Decrypt ciphertext
555 plaintext_len = attrs_ser_len - sizeof (struct GNUNET_CRYPTO_EcdsaSignature);
556 plaintext = GNUNET_malloc (plaintext_len);
557 decrypt_payload (ecdsa_priv, ecdh_pub, ptr, plaintext_len, plaintext);
560 *ticket = *((struct GNUNET_RECLAIM_Ticket *) ptr);
561 attrs_ser_len -= sizeof (struct GNUNET_RECLAIM_Ticket);
562 ptr += sizeof (struct GNUNET_RECLAIM_Ticket);
564 nonce = ntohl (*((uint32_t *) ptr));
565 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got nonce: %u\n", nonce);
566 attrs_ser_len -= sizeof (uint32_t);
567 ptr += sizeof (uint32_t);
569 attrs_ser_len -= sizeof (struct GNUNET_CRYPTO_EcdsaSignature);
570 *attrs = GNUNET_RECLAIM_ATTRIBUTE_list_deserialize (ptr, attrs_ser_len);
573 code_payload_len - sizeof (struct GNUNET_CRYPTO_EcdsaSignature);
575 (struct GNUNET_CRYPTO_EcdsaSignature *) &code_payload[signature_offset];
576 GNUNET_CRYPTO_ecdsa_key_get_public (ecdsa_priv, &ecdsa_pub);
577 if (0 != GNUNET_memcmp (&ecdsa_pub, &ticket->audience))
579 GNUNET_RECLAIM_ATTRIBUTE_list_destroy (*attrs);
580 GNUNET_free (code_payload);
581 GNUNET_free (plaintext);
582 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
583 "Audience in ticket does not match client!\n");
584 return GNUNET_SYSERR;
587 GNUNET_CRYPTO_ecdsa_verify (GNUNET_SIGNATURE_PURPOSE_RECLAIM_CODE_SIGN,
592 GNUNET_RECLAIM_ATTRIBUTE_list_destroy (*attrs);
593 GNUNET_free (code_payload);
594 GNUNET_free (plaintext);
595 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Signature of AuthZ code invalid!\n");
596 return GNUNET_SYSERR;
600 GNUNET_asprintf (nonce_str, "%u", nonce);
601 GNUNET_free (code_payload);
602 GNUNET_free (plaintext);
608 * Build a token response for a token request
609 * TODO: Maybe we should add the scope here?
611 * @param access_token the access token to include
612 * @param id_token the id_token to include
613 * @param expiration_time the expiration time of the token(s)
614 * @param token_response where to store the response
617 OIDC_build_token_response (const char *access_token,
618 const char *id_token,
619 const struct GNUNET_TIME_Relative *expiration_time,
620 char **token_response)
624 root_json = json_object ();
626 GNUNET_assert (NULL != access_token);
627 GNUNET_assert (NULL != id_token);
628 GNUNET_assert (NULL != expiration_time);
629 json_object_set_new (root_json, "access_token", json_string (access_token));
630 json_object_set_new (root_json, "token_type", json_string ("Bearer"));
631 json_object_set_new (root_json,
633 json_integer (expiration_time->rel_value_us /
635 json_object_set_new (root_json, "id_token", json_string (id_token));
636 *token_response = json_dumps (root_json, JSON_INDENT (0) | JSON_COMPACT);
637 json_decref (root_json);
641 * Generate a new access token
644 OIDC_access_token_new ()
647 uint64_t random_number;
650 GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_NONCE, UINT64_MAX);
651 GNUNET_STRINGS_base64_encode (&random_number,