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"
34 //#include "benchmark.h"
37 GNUNET_NETWORK_STRUCT_BEGIN
40 * The signature used to generate the authorization code
42 struct OIDC_Parameters
47 const struct GNUNET_RECLAIM_Ticket *ticket;
52 uint32_t nonce GNUNET_PACKED;
55 * The length of the PKCE code_challenge
57 uint32_t code_challenge_len GNUNET_PACKED;
60 * The length of the attributes list
62 uint32_t attr_list_len GNUNET_PACKED;
65 GNUNET_NETWORK_STRUCT_END
68 create_jwt_header (void)
73 root = json_object ();
74 json_object_set_new (root, JWT_ALG, json_string (JWT_ALG_VALUE));
75 json_object_set_new (root, JWT_TYP, json_string (JWT_TYP_VALUE));
77 json_str = json_dumps (root, JSON_INDENT (0) | JSON_COMPACT);
83 replace_char (char *str, char find, char replace)
85 char *current_pos = strchr (str, find);
88 *current_pos = replace;
89 current_pos = strchr (current_pos, find);
95 fix_base64 (char *str)
98 replace_char (str, '+', '-');
101 replace_char (str, '/', '_');
105 * Create a JWT from attributes
107 * @param aud_key the public of the audience
108 * @param sub_key the public key of the subject
109 * @param attrs the attribute list
110 * @param expiration_time the validity of the token
111 * @param secret_key the key used to sign the JWT
112 * @return a new base64-encoded JWT string.
115 OIDC_id_token_new (const struct GNUNET_CRYPTO_EcdsaPublicKey *aud_key,
116 const struct GNUNET_CRYPTO_EcdsaPublicKey *sub_key,
117 const struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attrs,
118 const struct GNUNET_TIME_Relative *expiration_time,
120 const char *secret_key)
122 struct GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry *le;
123 struct GNUNET_HashCode signature;
124 struct GNUNET_TIME_Absolute exp_time;
125 struct GNUNET_TIME_Absolute time_now;
133 char *signature_target;
134 char *signature_base64;
138 // iat REQUIRED time now
139 time_now = GNUNET_TIME_absolute_get ();
140 // exp REQUIRED time expired from config
141 exp_time = GNUNET_TIME_absolute_add (time_now, *expiration_time);
142 // auth_time only if max_age
143 // nonce only if nonce
144 // OPTIONAL acr,amr,azp
146 GNUNET_STRINGS_data_to_string_alloc (sub_key,
148 GNUNET_CRYPTO_EcdsaPublicKey));
150 GNUNET_STRINGS_data_to_string_alloc (aud_key,
152 GNUNET_CRYPTO_EcdsaPublicKey));
153 header = create_jwt_header ();
154 body = json_object ();
156 // iss REQUIRED case sensitive server uri with https
157 // The issuer is the local reclaim instance (e.g.
158 // https://reclaim.id/api/openid)
159 json_object_set_new (body, "iss", json_string (SERVER_ADDRESS));
160 // sub REQUIRED public key identity, not exceed 255 ASCII length
161 json_object_set_new (body, "sub", json_string (subject));
162 // aud REQUIRED public key client_id must be there
163 json_object_set_new (body, "aud", json_string (audience));
165 json_object_set_new (body,
167 json_integer (time_now.abs_value_us / (1000 * 1000)));
169 json_object_set_new (body,
171 json_integer (exp_time.abs_value_us / (1000 * 1000)));
173 json_object_set_new (body,
175 json_integer (time_now.abs_value_us / (1000 * 1000)));
178 json_object_set_new (body, "nonce", json_string (nonce));
180 for (le = attrs->list_head; NULL != le; le = le->next)
183 GNUNET_RECLAIM_ATTRIBUTE_value_to_string (le->claim->type,
185 le->claim->data_size);
186 json_object_set_new (body, le->claim->name, json_string (attr_val_str));
187 GNUNET_free (attr_val_str);
189 body_str = json_dumps (body, JSON_INDENT (0) | JSON_COMPACT);
192 GNUNET_STRINGS_base64_encode (header, strlen (header), &header_base64);
193 fix_base64 (header_base64);
195 GNUNET_STRINGS_base64_encode (body_str, strlen (body_str), &body_base64);
196 fix_base64 (body_base64);
198 GNUNET_free (subject);
199 GNUNET_free (audience);
202 * Creating the JWT signature. This might not be
203 * standards compliant, check.
205 GNUNET_asprintf (&signature_target, "%s.%s", header_base64, body_base64);
206 GNUNET_CRYPTO_hmac_raw (secret_key,
209 strlen (signature_target),
211 GNUNET_STRINGS_base64_encode ((const char *) &signature,
212 sizeof (struct GNUNET_HashCode),
214 fix_base64 (signature_base64);
216 GNUNET_asprintf (&result,
222 GNUNET_free (signature_target);
223 GNUNET_free (header);
224 GNUNET_free (body_str);
225 GNUNET_free (signature_base64);
226 GNUNET_free (body_base64);
227 GNUNET_free (header_base64);
231 /* Converts a hex character to its integer value */
235 return isdigit (ch) ? ch - '0' : tolower (ch) - 'a' + 10;
238 /* Converts an integer value to its hex character*/
242 static char hex[] = "0123456789abcdef";
243 return hex[code & 15];
246 /* Returns a url-encoded version of str */
247 /* IMPORTANT: be sure to free() the returned string after use */
249 url_encode (const char *str)
251 char *pstr = (char *) str;
252 char *buf = GNUNET_malloc (strlen (str) * 3 + 1);
256 if (isalnum (*pstr) || *pstr == '-' || *pstr == '_' || *pstr == '.' ||
259 else if (*pstr == ' ')
264 *pbuf++ = to_hex (*pstr >> 4);
265 *pbuf++ = to_hex (*pstr & 15);
274 /* Returns a url-decoded version of str */
275 /* IMPORTANT: be sure to free() the returned string after use */
277 url_decode (const char *str)
279 char *pstr = (char *) str;
280 char *buf = GNUNET_malloc (strlen (str) + 1);
286 if (pstr[1] && pstr[2])
288 *pbuf++ = from_hex (pstr[1]) << 4 | from_hex (pstr[2]);
292 else if (*pstr == '+')
307 * Returns base64 encoded string urlencoded
309 * @param string the string to encode
310 * @return base64 encoded string
313 base64_and_urlencode (const char *data, size_t data_size)
318 GNUNET_STRINGS_base64_encode (data, data_size, &enc);
319 urlenc = url_encode (enc);
328 * Returns base64 encoded string urlencoded
330 * @param string the string to encode
331 * @return base64 encoded string
334 base64url_encode (const char *data, size_t data_size)
339 GNUNET_STRINGS_base64_encode (data, data_size, &enc);
340 //Replace with correct characters for base64url
342 while ('\0' != enc[pos])
360 derive_aes_key (struct GNUNET_CRYPTO_SymmetricSessionKey *key,
361 struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
362 struct GNUNET_HashCode *key_material)
364 static const char ctx_key[] = "reclaim-aes-ctx-key";
365 static const char ctx_iv[] = "reclaim-aes-ctx-iv";
366 GNUNET_CRYPTO_kdf (key,
367 sizeof (struct GNUNET_CRYPTO_SymmetricSessionKey),
371 sizeof (struct GNUNET_HashCode),
373 GNUNET_CRYPTO_kdf (iv,
375 struct GNUNET_CRYPTO_SymmetricInitializationVector),
379 sizeof (struct GNUNET_HashCode),
385 calculate_key_priv (struct GNUNET_CRYPTO_SymmetricSessionKey *key,
386 struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
387 const struct GNUNET_CRYPTO_EcdsaPrivateKey *ecdsa_priv,
388 const struct GNUNET_CRYPTO_EcdhePublicKey *ecdh_pub)
390 struct GNUNET_HashCode key_material;
391 GNUNET_CRYPTO_ecdsa_ecdh (ecdsa_priv, ecdh_pub, &key_material);
392 derive_aes_key (key, iv, &key_material);
397 calculate_key_pub (struct GNUNET_CRYPTO_SymmetricSessionKey *key,
398 struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
399 const struct GNUNET_CRYPTO_EcdsaPublicKey *ecdsa_pub,
400 const struct GNUNET_CRYPTO_EcdhePrivateKey *ecdh_priv)
402 struct GNUNET_HashCode key_material;
403 GNUNET_CRYPTO_ecdh_ecdsa (ecdh_priv, ecdsa_pub, &key_material);
404 derive_aes_key (key, iv, &key_material);
409 decrypt_payload (const struct GNUNET_CRYPTO_EcdsaPrivateKey *ecdsa_priv,
410 const struct GNUNET_CRYPTO_EcdhePublicKey *ecdh_pub,
415 struct GNUNET_CRYPTO_SymmetricSessionKey key;
416 struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
418 calculate_key_priv (&key, &iv, ecdsa_priv, ecdh_pub);
419 GNUNET_break (GNUNET_CRYPTO_symmetric_decrypt (ct, ct_len, &key, &iv, buf));
424 encrypt_payload (const struct GNUNET_CRYPTO_EcdsaPublicKey *ecdsa_pub,
425 const struct GNUNET_CRYPTO_EcdhePrivateKey *ecdh_priv,
430 struct GNUNET_CRYPTO_SymmetricSessionKey key;
431 struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
433 calculate_key_pub (&key, &iv, ecdsa_pub, ecdh_priv);
435 GNUNET_CRYPTO_symmetric_encrypt (payload, payload_len, &key, &iv, buf));
439 * Builds an OIDC authorization code including
440 * a reclaim ticket and nonce
442 * @param issuer the issuer of the ticket, used to sign the ticket and nonce
443 * @param ticket the ticket to include in the code
444 * @param attrs list of attributes which are shared
445 * @param nonce the nonce to include in the code
446 * @param code_challenge PKCE code challenge
447 * @return a new authorization code (caller must free)
450 OIDC_build_authz_code (const struct GNUNET_CRYPTO_EcdsaPrivateKey *issuer,
451 const struct GNUNET_RECLAIM_Ticket *ticket,
452 struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attrs,
453 const char *nonce_str,
454 const char *code_challenge)
456 struct OIDC_Parameters params;
461 char *buf_ptr = NULL;
463 size_t code_payload_len;
464 size_t attr_list_len = 0;
467 struct GNUNET_CRYPTO_EccSignaturePurpose *purpose;
468 struct GNUNET_CRYPTO_EcdhePrivateKey *ecdh_priv;
469 struct GNUNET_CRYPTO_EcdhePublicKey ecdh_pub;
473 memset (¶ms, 0, sizeof (params));
474 params.ticket = ticket;
477 payload_len = sizeof (struct OIDC_Parameters);
478 if (NULL != nonce_str && strcmp ("", nonce_str) != 0)
480 if ((1 != SSCANF (nonce_str, "%u", &nonce)) || (nonce > UINT32_MAX))
483 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Invalid nonce %s\n", nonce_str);
486 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
487 "Got nonce: %u from %s\n",
491 nonce_tmp = htonl (nonce);
492 params.nonce = nonce_tmp;
493 // Assign code challenge
494 if (NULL == code_challenge || strcmp ("", code_challenge) == 0)
497 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "PKCE: Code challenge missing");
500 payload_len += strlen (code_challenge);
501 params.code_challenge_len = htonl (strlen (code_challenge));
506 attr_list_len = GNUNET_RECLAIM_ATTRIBUTE_list_serialize_get_size (attrs);
507 params.attr_list_len = htonl (attr_list_len);
508 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
509 "Length of serialized attributes: %lu\n",
511 // Get serialized attributes
512 payload_len += attr_list_len;
514 // Get plaintext length
515 payload = GNUNET_malloc (payload_len);
516 memcpy (payload, ¶ms, sizeof (params));
517 tmp = payload + sizeof (params);
518 memcpy (tmp, code_challenge, strlen (code_challenge));
519 tmp += strlen (code_challenge);
520 if (0 < attr_list_len)
521 GNUNET_RECLAIM_ATTRIBUTE_list_serialize (attrs, tmp);
526 code_payload_len = sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
527 sizeof (struct GNUNET_CRYPTO_EcdhePublicKey) +
528 payload_len + sizeof (struct GNUNET_CRYPTO_EcdsaSignature);
529 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
530 "Length of data to encode: %lu\n",
534 ecdh_priv = GNUNET_CRYPTO_ecdhe_key_create ();
535 GNUNET_CRYPTO_ecdhe_key_get_public (ecdh_priv, &ecdh_pub);
536 // Initialize code payload
537 code_payload = GNUNET_malloc (code_payload_len);
538 GNUNET_assert (NULL != code_payload);
539 purpose = (struct GNUNET_CRYPTO_EccSignaturePurpose *) code_payload;
540 purpose->size = htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
541 sizeof (ecdh_pub) + payload_len);
542 purpose->purpose = htonl (GNUNET_SIGNATURE_PURPOSE_RECLAIM_CODE_SIGN);
544 buf_ptr = (char *) &purpose[1];
545 memcpy (buf_ptr, &ecdh_pub, sizeof (ecdh_pub));
546 buf_ptr += sizeof (ecdh_pub);
547 // Encrypt plaintext and store
548 encrypt_payload (&ticket->audience, ecdh_priv, payload, payload_len, buf_ptr);
549 GNUNET_free (ecdh_priv);
550 GNUNET_free (payload);
551 buf_ptr += payload_len;
552 // Sign and store signature
554 GNUNET_CRYPTO_ecdsa_sign (issuer,
556 (struct GNUNET_CRYPTO_EcdsaSignature *)
560 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Unable to sign code\n");
561 GNUNET_free (code_payload);
564 code_str = base64_and_urlencode (code_payload, code_payload_len);
565 GNUNET_free (code_payload);
571 * Parse reclaim ticket and nonce from
572 * authorization code.
573 * This also verifies the signature in the code.
575 * @param audience the expected audience of the code
576 * @param code the string representation of the code
577 * @param code_verfier PKCE code verifier
578 * @param ticket where to store the ticket
579 * @param attrs the attributes in the code
580 * @param nonce where to store the nonce
581 * @return GNUNET_OK if successful, else GNUNET_SYSERR
584 OIDC_parse_authz_code (const struct GNUNET_CRYPTO_EcdsaPrivateKey *ecdsa_priv,
586 const char *code_verifier,
587 struct GNUNET_RECLAIM_Ticket *ticket,
588 struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList **attrs,
595 char *expected_code_challenge;
596 char *code_challenge;
597 char *code_verifier_hash;
598 struct GNUNET_CRYPTO_EccSignaturePurpose *purpose;
599 struct GNUNET_CRYPTO_EcdsaSignature *signature;
600 struct GNUNET_CRYPTO_EcdsaPublicKey ecdsa_pub;
601 struct GNUNET_CRYPTO_EcdhePublicKey *ecdh_pub;
602 uint32_t code_challenge_len;
603 uint32_t attrs_ser_len;
604 size_t plaintext_len;
605 size_t code_payload_len;
607 struct OIDC_Parameters *params;
609 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Trying to decode `%s'\n", code);
612 GNUNET_STRINGS_base64_decode (code, strlen (code), (void **) &code_payload);
613 if (code_payload_len < sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
614 sizeof (struct GNUNET_CRYPTO_EcdhePublicKey) +
615 sizeof (struct OIDC_Parameters) +
616 sizeof (struct GNUNET_CRYPTO_EcdsaSignature))
618 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Authorization code malformed\n");
619 GNUNET_free_non_null (code_payload);
620 return GNUNET_SYSERR;
623 purpose = (struct GNUNET_CRYPTO_EccSignaturePurpose *) code_payload;
624 plaintext_len = code_payload_len;
625 plaintext_len -= sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose);
626 ptr = (char *) &purpose[1];
628 ecdh_pub = (struct GNUNET_CRYPTO_EcdhePublicKey *) ptr;
629 ptr += sizeof (struct GNUNET_CRYPTO_EcdhePublicKey);
630 plaintext_len -= sizeof (struct GNUNET_CRYPTO_EcdhePublicKey);
632 // Decrypt ciphertext
633 plaintext_len -= sizeof (struct GNUNET_CRYPTO_EcdsaSignature);
634 plaintext = GNUNET_malloc (plaintext_len);
635 decrypt_payload (ecdsa_priv, ecdh_pub, ptr, plaintext_len, plaintext);
637 params = (struct OIDC_Parameters *) plaintext;
639 // cmp code_challenge code_verifier
640 code_verifier_hash = GNUNET_malloc (256 / 8);
641 // hash code verifier
642 gcry_md_hash_buffer (GCRY_MD_SHA256,
645 strlen (code_verifier));
646 // encode code verifier
647 expected_code_challenge = base64url_encode (code_verifier_hash, 256 / 8);
648 code_challenge = (char *) ¶ms[1];
649 code_challenge_len = ntohl (params->code_challenge_len);
650 GNUNET_free (code_verifier_hash);
651 if ((strlen (expected_code_challenge) != code_challenge_len) ||
653 strncmp (expected_code_challenge, code_challenge, code_challenge_len)))
655 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
656 "Invalid code verifier! Expected: %s, Got: %.*s\n",
657 expected_code_challenge,
660 GNUNET_free_non_null (code_payload);
661 GNUNET_free (expected_code_challenge);
662 return GNUNET_SYSERR;
664 GNUNET_free (expected_code_challenge);
666 memcpy (ticket, ¶ms->ticket, sizeof (params->ticket));
668 nonce = ntohl (params->nonce); //ntohl (*((uint32_t *) ptr));
669 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got nonce: %u\n", nonce);
671 attrs_ser = ((char *) ¶ms[1]) + code_challenge_len;
672 attrs_ser_len = ntohl (params->attr_list_len);
673 *attrs = GNUNET_RECLAIM_ATTRIBUTE_list_deserialize (attrs_ser, attrs_ser_len);
675 signature = (struct GNUNET_CRYPTO_EcdsaSignature *) attrs_ser + attrs_ser_len;
676 GNUNET_CRYPTO_ecdsa_key_get_public (ecdsa_priv, &ecdsa_pub);
677 if (0 != GNUNET_memcmp (&ecdsa_pub, &ticket->audience))
679 GNUNET_RECLAIM_ATTRIBUTE_list_destroy (*attrs);
680 GNUNET_free (code_payload);
681 GNUNET_free (plaintext);
682 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
683 "Audience in ticket does not match client!\n");
684 return GNUNET_SYSERR;
687 GNUNET_CRYPTO_ecdsa_verify (GNUNET_SIGNATURE_PURPOSE_RECLAIM_CODE_SIGN,
692 GNUNET_RECLAIM_ATTRIBUTE_list_destroy (*attrs);
693 GNUNET_free (code_payload);
694 GNUNET_free (plaintext);
695 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Signature of AuthZ code invalid!\n");
696 return GNUNET_SYSERR;
700 GNUNET_asprintf (nonce_str, "%u", nonce);
701 GNUNET_free (code_payload);
702 GNUNET_free (plaintext);
708 * Build a token response for a token request
709 * TODO: Maybe we should add the scope here?
711 * @param access_token the access token to include
712 * @param id_token the id_token to include
713 * @param expiration_time the expiration time of the token(s)
714 * @param token_response where to store the response
717 OIDC_build_token_response (const char *access_token,
718 const char *id_token,
719 const struct GNUNET_TIME_Relative *expiration_time,
720 char **token_response)
724 root_json = json_object ();
726 GNUNET_assert (NULL != access_token);
727 GNUNET_assert (NULL != id_token);
728 GNUNET_assert (NULL != expiration_time);
729 json_object_set_new (root_json, "access_token", json_string (access_token));
730 json_object_set_new (root_json, "token_type", json_string ("Bearer"));
731 json_object_set_new (root_json,
733 json_integer (expiration_time->rel_value_us /
735 json_object_set_new (root_json, "id_token", json_string (id_token));
736 *token_response = json_dumps (root_json, JSON_INDENT (0) | JSON_COMPACT);
737 json_decref (root_json);
741 * Generate a new access token
744 OIDC_access_token_new ()
747 uint64_t random_number;
750 GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_NONCE, UINT64_MAX);
751 GNUNET_STRINGS_base64_encode (&random_number,