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 {
46 struct GNUNET_RECLAIM_Ticket ticket;
51 uint32_t nonce GNUNET_PACKED;
54 * The length of the PKCE code_challenge
56 uint32_t code_challenge_len GNUNET_PACKED;
59 * The length of the attributes list
61 uint32_t attr_list_len GNUNET_PACKED;
64 GNUNET_NETWORK_STRUCT_END
67 create_jwt_header(void)
73 json_object_set_new(root, JWT_ALG, json_string(JWT_ALG_VALUE));
74 json_object_set_new(root, JWT_TYP, json_string(JWT_TYP_VALUE));
76 json_str = json_dumps(root, JSON_INDENT(0) | JSON_COMPACT);
82 replace_char(char *str, char find, char replace)
84 char *current_pos = strchr(str, find);
88 *current_pos = replace;
89 current_pos = strchr(current_pos, find);
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);
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";
244 return hex[code & 15];
247 /* Returns a url-encoded version of str */
248 /* IMPORTANT: be sure to free() the returned string after use */
250 url_encode(const char *str)
252 char *pstr = (char *)str;
253 char *buf = GNUNET_malloc(strlen(str) * 3 + 1);
258 if (isalnum(*pstr) || *pstr == '-' || *pstr == '_' || *pstr == '.' ||
261 else if (*pstr == ' ')
266 *pbuf++ = to_hex(*pstr >> 4);
267 *pbuf++ = to_hex(*pstr & 15);
276 /* Returns a url-decoded version of str */
277 /* IMPORTANT: be sure to free() the returned string after use */
279 url_decode(const char *str)
281 char *pstr = (char *)str;
282 char *buf = GNUNET_malloc(strlen(str) + 1);
289 if (pstr[1] && pstr[2])
291 *pbuf++ = from_hex(pstr[1]) << 4 | from_hex(pstr[2]);
295 else if (*pstr == '+')
310 * Returns base64 encoded string urlencoded
312 * @param string the string to encode
313 * @return base64 encoded string
316 base64_and_urlencode(const char *data, size_t data_size)
321 GNUNET_STRINGS_base64_encode(data, data_size, &enc);
322 urlenc = url_encode(enc);
329 * Returns base64 encoded string urlencoded
331 * @param string the string to encode
332 * @return base64 encoded string
335 base64url_encode(const char *data, size_t data_size)
340 GNUNET_STRINGS_base64_encode(data, data_size, &enc);
341 //Replace with correct characters for base64url
343 while ('\0' != enc[pos])
361 derive_aes_key(struct GNUNET_CRYPTO_SymmetricSessionKey *key,
362 struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
363 struct GNUNET_HashCode *key_material)
365 static const char ctx_key[] = "reclaim-aes-ctx-key";
366 static const char ctx_iv[] = "reclaim-aes-ctx-iv";
368 GNUNET_CRYPTO_kdf(key,
369 sizeof(struct GNUNET_CRYPTO_SymmetricSessionKey),
373 sizeof(struct GNUNET_HashCode),
375 GNUNET_CRYPTO_kdf(iv,
377 struct GNUNET_CRYPTO_SymmetricInitializationVector),
381 sizeof(struct GNUNET_HashCode),
387 calculate_key_priv(struct GNUNET_CRYPTO_SymmetricSessionKey *key,
388 struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
389 const struct GNUNET_CRYPTO_EcdsaPrivateKey *ecdsa_priv,
390 const struct GNUNET_CRYPTO_EcdhePublicKey *ecdh_pub)
392 struct GNUNET_HashCode key_material;
394 GNUNET_CRYPTO_ecdsa_ecdh(ecdsa_priv, ecdh_pub, &key_material);
395 derive_aes_key(key, iv, &key_material);
400 calculate_key_pub(struct GNUNET_CRYPTO_SymmetricSessionKey *key,
401 struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
402 const struct GNUNET_CRYPTO_EcdsaPublicKey *ecdsa_pub,
403 const struct GNUNET_CRYPTO_EcdhePrivateKey *ecdh_priv)
405 struct GNUNET_HashCode key_material;
407 GNUNET_CRYPTO_ecdh_ecdsa(ecdh_priv, ecdsa_pub, &key_material);
408 derive_aes_key(key, iv, &key_material);
413 decrypt_payload(const struct GNUNET_CRYPTO_EcdsaPrivateKey *ecdsa_priv,
414 const struct GNUNET_CRYPTO_EcdhePublicKey *ecdh_pub,
419 struct GNUNET_CRYPTO_SymmetricSessionKey key;
420 struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
422 calculate_key_priv(&key, &iv, ecdsa_priv, ecdh_pub);
423 GNUNET_break(GNUNET_CRYPTO_symmetric_decrypt(ct, ct_len, &key, &iv, buf));
428 encrypt_payload(const struct GNUNET_CRYPTO_EcdsaPublicKey *ecdsa_pub,
429 const struct GNUNET_CRYPTO_EcdhePrivateKey *ecdh_priv,
434 struct GNUNET_CRYPTO_SymmetricSessionKey key;
435 struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
437 calculate_key_pub(&key, &iv, ecdsa_pub, ecdh_priv);
439 GNUNET_CRYPTO_symmetric_encrypt(payload, payload_len, &key, &iv, buf));
443 * Builds an OIDC authorization code including
444 * a reclaim ticket and nonce
446 * @param issuer the issuer of the ticket, used to sign the ticket and nonce
447 * @param ticket the ticket to include in the code
448 * @param attrs list of attributes which are shared
449 * @param nonce the nonce to include in the code
450 * @param code_challenge PKCE code challenge
451 * @return a new authorization code (caller must free)
454 OIDC_build_authz_code(const struct GNUNET_CRYPTO_EcdsaPrivateKey *issuer,
455 const struct GNUNET_RECLAIM_Ticket *ticket,
456 struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attrs,
457 const char *nonce_str,
458 const char *code_challenge)
460 struct OIDC_Parameters params;
465 char *buf_ptr = NULL;
467 size_t code_payload_len;
468 size_t attr_list_len = 0;
469 size_t code_challenge_len = 0;
472 struct GNUNET_CRYPTO_EccSignaturePurpose *purpose;
473 struct GNUNET_CRYPTO_EcdhePrivateKey *ecdh_priv;
474 struct GNUNET_CRYPTO_EcdhePublicKey ecdh_pub;
478 memset(¶ms, 0, sizeof(params));
479 params.ticket = *ticket;
482 payload_len = sizeof(struct OIDC_Parameters);
483 if (NULL != nonce_str && strcmp("", nonce_str) != 0)
485 if ((1 != sscanf(nonce_str, "%u", &nonce)) || (nonce > UINT32_MAX))
488 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Invalid nonce %s\n", nonce_str);
491 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
492 "Got nonce: %u from %s\n",
496 nonce_tmp = htonl(nonce);
497 params.nonce = nonce_tmp;
498 // Assign code challenge
499 if (NULL != code_challenge)
500 code_challenge_len = strlen(code_challenge);
501 payload_len += code_challenge_len;
502 params.code_challenge_len = htonl(code_challenge_len);
507 attr_list_len = GNUNET_RECLAIM_ATTRIBUTE_list_serialize_get_size(attrs);
508 params.attr_list_len = htonl(attr_list_len);
509 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
510 "Length of serialized attributes: %lu\n",
512 // Get serialized attributes
513 payload_len += attr_list_len;
515 // Get plaintext length
516 payload = GNUNET_malloc(payload_len);
517 memcpy(payload, ¶ms, sizeof(params));
518 tmp = payload + sizeof(params);
519 if (0 < code_challenge_len)
521 memcpy(tmp, code_challenge, code_challenge_len);
522 tmp += code_challenge_len;
524 if (0 < attr_list_len)
525 GNUNET_RECLAIM_ATTRIBUTE_list_serialize(attrs, tmp);
530 code_payload_len = sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose) +
531 sizeof(struct GNUNET_CRYPTO_EcdhePublicKey) +
532 payload_len + sizeof(struct GNUNET_CRYPTO_EcdsaSignature);
533 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
534 "Length of data to encode: %lu\n",
538 ecdh_priv = GNUNET_CRYPTO_ecdhe_key_create();
539 GNUNET_CRYPTO_ecdhe_key_get_public(ecdh_priv, &ecdh_pub);
540 // Initialize code payload
541 code_payload = GNUNET_malloc(code_payload_len);
542 GNUNET_assert(NULL != code_payload);
543 purpose = (struct GNUNET_CRYPTO_EccSignaturePurpose *)code_payload;
544 purpose->size = htonl(sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose) +
545 sizeof(ecdh_pub) + payload_len);
546 purpose->purpose = htonl(GNUNET_SIGNATURE_PURPOSE_RECLAIM_CODE_SIGN);
548 buf_ptr = (char *)&purpose[1];
549 memcpy(buf_ptr, &ecdh_pub, sizeof(ecdh_pub));
550 buf_ptr += sizeof(ecdh_pub);
551 // Encrypt plaintext and store
552 encrypt_payload(&ticket->audience, ecdh_priv, payload, payload_len, buf_ptr);
553 GNUNET_free(ecdh_priv);
554 GNUNET_free(payload);
555 buf_ptr += payload_len;
556 // Sign and store signature
558 GNUNET_CRYPTO_ecdsa_sign(issuer,
560 (struct GNUNET_CRYPTO_EcdsaSignature *)
564 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Unable to sign code\n");
565 GNUNET_free(code_payload);
568 code_str = base64_and_urlencode(code_payload, code_payload_len);
569 GNUNET_free(code_payload);
575 * Parse reclaim ticket and nonce from
576 * authorization code.
577 * This also verifies the signature in the code.
579 * @param audience the expected audience of the code
580 * @param code the string representation of the code
581 * @param code_verfier PKCE code verifier
582 * @param ticket where to store the ticket
583 * @param attrs the attributes in the code
584 * @param nonce where to store the nonce
585 * @return GNUNET_OK if successful, else GNUNET_SYSERR
588 OIDC_parse_authz_code(const struct GNUNET_CRYPTO_EcdsaPrivateKey *ecdsa_priv,
590 const char *code_verifier,
591 struct GNUNET_RECLAIM_Ticket *ticket,
592 struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList **attrs,
599 char *expected_code_challenge;
600 char *code_challenge;
601 char *code_verifier_hash;
602 struct GNUNET_CRYPTO_EccSignaturePurpose *purpose;
603 struct GNUNET_CRYPTO_EcdsaSignature *signature;
604 struct GNUNET_CRYPTO_EcdsaPublicKey ecdsa_pub;
605 struct GNUNET_CRYPTO_EcdhePublicKey *ecdh_pub;
606 uint32_t code_challenge_len;
607 uint32_t attrs_ser_len;
608 size_t plaintext_len;
609 size_t code_payload_len;
611 struct OIDC_Parameters *params;
613 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Trying to decode `%s'\n", code);
616 GNUNET_STRINGS_base64_decode(code, strlen(code), (void **)&code_payload);
617 if (code_payload_len < sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose) +
618 sizeof(struct GNUNET_CRYPTO_EcdhePublicKey) +
619 sizeof(struct OIDC_Parameters) +
620 sizeof(struct GNUNET_CRYPTO_EcdsaSignature))
622 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Authorization code malformed\n");
623 GNUNET_free_non_null(code_payload);
624 return GNUNET_SYSERR;
627 purpose = (struct GNUNET_CRYPTO_EccSignaturePurpose *)code_payload;
628 plaintext_len = code_payload_len;
629 plaintext_len -= sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose);
630 ptr = (char *)&purpose[1];
632 ecdh_pub = (struct GNUNET_CRYPTO_EcdhePublicKey *)ptr;
633 ptr += sizeof(struct GNUNET_CRYPTO_EcdhePublicKey);
634 plaintext_len -= sizeof(struct GNUNET_CRYPTO_EcdhePublicKey);
636 // Decrypt ciphertext
637 plaintext_len -= sizeof(struct GNUNET_CRYPTO_EcdsaSignature);
638 plaintext = GNUNET_malloc(plaintext_len);
639 decrypt_payload(ecdsa_priv, ecdh_pub, ptr, plaintext_len, plaintext);
641 ptr += plaintext_len;
642 signature = (struct GNUNET_CRYPTO_EcdsaSignature *)ptr;
643 params = (struct OIDC_Parameters *)plaintext;
645 // cmp code_challenge code_verifier
646 code_challenge_len = ntohl(params->code_challenge_len);
647 if (0 != code_challenge_len) /* Only check if this code requires a CV */
649 code_verifier_hash = GNUNET_malloc(256 / 8);
650 // hash code verifier
651 gcry_md_hash_buffer(GCRY_MD_SHA256,
654 strlen(code_verifier));
655 // encode code verifier
656 expected_code_challenge = base64url_encode(code_verifier_hash, 256 / 8);
657 code_challenge = (char *)¶ms[1];
658 GNUNET_free(code_verifier_hash);
659 if ((strlen(expected_code_challenge) != code_challenge_len) ||
661 strncmp(expected_code_challenge, code_challenge, code_challenge_len)))
663 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
664 "Invalid code verifier! Expected: %s, Got: %.*s\n",
665 expected_code_challenge,
668 GNUNET_free_non_null(code_payload);
669 GNUNET_free(expected_code_challenge);
670 return GNUNET_SYSERR;
672 GNUNET_free(expected_code_challenge);
675 memcpy(ticket, ¶ms->ticket, sizeof(params->ticket));
677 nonce = ntohl(params->nonce); //ntohl (*((uint32_t *) ptr));
678 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Got nonce: %u\n", nonce);
680 GNUNET_CRYPTO_ecdsa_key_get_public(ecdsa_priv, &ecdsa_pub);
681 if (0 != GNUNET_memcmp(&ecdsa_pub, &ticket->audience))
683 GNUNET_free(code_payload);
684 GNUNET_free(plaintext);
685 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
686 "Audience in ticket does not match client!\n");
687 return GNUNET_SYSERR;
690 GNUNET_CRYPTO_ecdsa_verify(GNUNET_SIGNATURE_PURPOSE_RECLAIM_CODE_SIGN,
695 GNUNET_free(code_payload);
696 GNUNET_free(plaintext);
697 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Signature of AuthZ code invalid!\n");
698 return GNUNET_SYSERR;
701 attrs_ser = ((char *)¶ms[1]) + code_challenge_len;
702 attrs_ser_len = ntohl(params->attr_list_len);
703 *attrs = GNUNET_RECLAIM_ATTRIBUTE_list_deserialize(attrs_ser, attrs_ser_len);
707 GNUNET_asprintf(nonce_str, "%u", nonce);
708 GNUNET_free(code_payload);
709 GNUNET_free(plaintext);
715 * Build a token response for a token request
716 * TODO: Maybe we should add the scope here?
718 * @param access_token the access token to include
719 * @param id_token the id_token to include
720 * @param expiration_time the expiration time of the token(s)
721 * @param token_response where to store the response
724 OIDC_build_token_response(const char *access_token,
725 const char *id_token,
726 const struct GNUNET_TIME_Relative *expiration_time,
727 char **token_response)
731 root_json = json_object();
733 GNUNET_assert(NULL != access_token);
734 GNUNET_assert(NULL != id_token);
735 GNUNET_assert(NULL != expiration_time);
736 json_object_set_new(root_json, "access_token", json_string(access_token));
737 json_object_set_new(root_json, "token_type", json_string("Bearer"));
738 json_object_set_new(root_json,
740 json_integer(expiration_time->rel_value_us /
742 json_object_set_new(root_json, "id_token", json_string(id_token));
743 *token_response = json_dumps(root_json, JSON_INDENT(0) | JSON_COMPACT);
744 json_decref(root_json);
748 * Generate a new access token
751 OIDC_access_token_new()
754 uint64_t random_number;
757 GNUNET_CRYPTO_random_u64(GNUNET_CRYPTO_QUALITY_NONCE, UINT64_MAX);
758 GNUNET_STRINGS_base64_encode(&random_number,