along with this program. If not, see <http://www.gnu.org/licenses/>.
SPDX-License-Identifier: AGPL3.0-or-later
- */
+ */
/**
* @file reclaim/oidc_helper.c
#include "gnunet_reclaim_service.h"
#include "gnunet_signatures.h"
#include "oidc_helper.h"
-//#include "benchmark.h"
+// #include "benchmark.h"
#include <gcrypt.h>
GNUNET_NETWORK_STRUCT_BEGIN
replace_char (char *str, char find, char replace)
{
char *current_pos = strchr (str, find);
+
while (current_pos)
{
*current_pos = replace;
// OPTIONAL acr,amr,azp
subject =
GNUNET_STRINGS_data_to_string_alloc (sub_key,
- sizeof (struct
- GNUNET_CRYPTO_EcdsaPublicKey));
+ sizeof(struct
+ GNUNET_CRYPTO_EcdsaPublicKey));
audience =
GNUNET_STRINGS_data_to_string_alloc (aud_key,
- sizeof (struct
- GNUNET_CRYPTO_EcdsaPublicKey));
+ sizeof(struct
+ GNUNET_CRYPTO_EcdsaPublicKey));
header = create_jwt_header ();
body = json_object ();
strlen (signature_target),
&signature);
GNUNET_STRINGS_base64_encode ((const char *) &signature,
- sizeof (struct GNUNET_HashCode),
+ sizeof(struct GNUNET_HashCode),
&signature_base64);
fix_base64 (signature_base64);
to_hex (char code)
{
static char hex[] = "0123456789abcdef";
+
return hex[code & 15];
}
char *pstr = (char *) str;
char *buf = GNUNET_malloc (strlen (str) * 3 + 1);
char *pbuf = buf;
+
while (*pstr)
{
- if (isalnum (*pstr) || *pstr == '-' || *pstr == '_' || *pstr == '.' ||
- *pstr == '~')
+ if (isalnum (*pstr) || (*pstr == '-') || (*pstr == '_') || (*pstr == '.') ||
+ (*pstr == '~') )
*pbuf++ = *pstr;
else if (*pstr == ' ')
*pbuf++ = '+';
char *pstr = (char *) str;
char *buf = GNUNET_malloc (strlen (str) + 1);
char *pbuf = buf;
+
while (*pstr)
{
if (*pstr == '%')
size_t pos;
GNUNET_STRINGS_base64_encode (data, data_size, &enc);
- //Replace with correct characters for base64url
+ // Replace with correct characters for base64url
pos = 0;
while ('\0' != enc[pos])
{
{
static const char ctx_key[] = "reclaim-aes-ctx-key";
static const char ctx_iv[] = "reclaim-aes-ctx-iv";
+
GNUNET_CRYPTO_kdf (key,
- sizeof (struct GNUNET_CRYPTO_SymmetricSessionKey),
+ sizeof(struct GNUNET_CRYPTO_SymmetricSessionKey),
ctx_key,
strlen (ctx_key),
key_material,
- sizeof (struct GNUNET_HashCode),
+ sizeof(struct GNUNET_HashCode),
NULL);
GNUNET_CRYPTO_kdf (iv,
- sizeof (
+ sizeof(
struct GNUNET_CRYPTO_SymmetricInitializationVector),
ctx_iv,
strlen (ctx_iv),
key_material,
- sizeof (struct GNUNET_HashCode),
+ sizeof(struct GNUNET_HashCode),
NULL);
}
const struct GNUNET_CRYPTO_EcdhePublicKey *ecdh_pub)
{
struct GNUNET_HashCode key_material;
+
GNUNET_CRYPTO_ecdsa_ecdh (ecdsa_priv, ecdh_pub, &key_material);
derive_aes_key (key, iv, &key_material);
}
const struct GNUNET_CRYPTO_EcdhePrivateKey *ecdh_priv)
{
struct GNUNET_HashCode key_material;
+
GNUNET_CRYPTO_ecdh_ecdsa (ecdh_priv, ecdsa_pub, &key_material);
derive_aes_key (key, iv, &key_material);
}
/** PLAINTEXT **/
// Assign ticket
- memset (¶ms, 0, sizeof (params));
+ memset (¶ms, 0, sizeof(params));
params.ticket = *ticket;
// Assign nonce
nonce = 0;
- payload_len = sizeof (struct OIDC_Parameters);
- if (NULL != nonce_str && strcmp ("", nonce_str) != 0)
+ payload_len = sizeof(struct OIDC_Parameters);
+ if ((NULL != nonce_str)&& (strcmp ("", nonce_str) != 0))
{
if ((1 != sscanf (nonce_str, "%u", &nonce)) || (nonce > UINT32_MAX))
{
}
// Get plaintext length
payload = GNUNET_malloc (payload_len);
- memcpy (payload, ¶ms, sizeof (params));
- tmp = payload + sizeof (params);
+ memcpy (payload, ¶ms, sizeof(params));
+ tmp = payload + sizeof(params);
if (0 < code_challenge_len)
{
memcpy (tmp, code_challenge, code_challenge_len);
/** ENCRYPT **/
// Get length
- code_payload_len = sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
- sizeof (struct GNUNET_CRYPTO_EcdhePublicKey) +
- payload_len + sizeof (struct GNUNET_CRYPTO_EcdsaSignature);
+ code_payload_len = sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)
+ + sizeof(struct GNUNET_CRYPTO_EcdhePublicKey)
+ + payload_len + sizeof(struct
+ GNUNET_CRYPTO_EcdsaSignature);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Length of data to encode: %lu\n",
code_payload_len);
code_payload = GNUNET_malloc (code_payload_len);
GNUNET_assert (NULL != code_payload);
purpose = (struct GNUNET_CRYPTO_EccSignaturePurpose *) code_payload;
- purpose->size = htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
- sizeof (ecdh_pub) + payload_len);
+ purpose->size = htonl (sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)
+ + sizeof(ecdh_pub) + payload_len);
purpose->purpose = htonl (GNUNET_SIGNATURE_PURPOSE_RECLAIM_CODE_SIGN);
// Store pubkey
buf_ptr = (char *) &purpose[1];
- memcpy (buf_ptr, &ecdh_pub, sizeof (ecdh_pub));
- buf_ptr += sizeof (ecdh_pub);
+ memcpy (buf_ptr, &ecdh_pub, sizeof(ecdh_pub));
+ buf_ptr += sizeof(ecdh_pub);
// Encrypt plaintext and store
encrypt_payload (&ticket->audience, ecdh_priv, payload, payload_len, buf_ptr);
GNUNET_free (ecdh_priv);
GNUNET_CRYPTO_ecdsa_sign (issuer,
purpose,
(struct GNUNET_CRYPTO_EcdsaSignature *)
- buf_ptr))
+ buf_ptr))
{
GNUNET_break (0);
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Unable to sign code\n");
code_payload = NULL;
code_payload_len =
GNUNET_STRINGS_base64_decode (code, strlen (code), (void **) &code_payload);
- if (code_payload_len < sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
- sizeof (struct GNUNET_CRYPTO_EcdhePublicKey) +
- sizeof (struct OIDC_Parameters) +
- sizeof (struct GNUNET_CRYPTO_EcdsaSignature))
+ if (code_payload_len < sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)
+ + sizeof(struct GNUNET_CRYPTO_EcdhePublicKey)
+ + sizeof(struct OIDC_Parameters)
+ + sizeof(struct GNUNET_CRYPTO_EcdsaSignature))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Authorization code malformed\n");
GNUNET_free_non_null (code_payload);
purpose = (struct GNUNET_CRYPTO_EccSignaturePurpose *) code_payload;
plaintext_len = code_payload_len;
- plaintext_len -= sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose);
+ plaintext_len -= sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose);
ptr = (char *) &purpose[1];
// Public ECDH key
ecdh_pub = (struct GNUNET_CRYPTO_EcdhePublicKey *) ptr;
- ptr += sizeof (struct GNUNET_CRYPTO_EcdhePublicKey);
- plaintext_len -= sizeof (struct GNUNET_CRYPTO_EcdhePublicKey);
+ ptr += sizeof(struct GNUNET_CRYPTO_EcdhePublicKey);
+ plaintext_len -= sizeof(struct GNUNET_CRYPTO_EcdhePublicKey);
// Decrypt ciphertext
- plaintext_len -= sizeof (struct GNUNET_CRYPTO_EcdsaSignature);
+ plaintext_len -= sizeof(struct GNUNET_CRYPTO_EcdsaSignature);
plaintext = GNUNET_malloc (plaintext_len);
decrypt_payload (ecdsa_priv, ecdh_pub, ptr, plaintext_len, plaintext);
- //ptr = plaintext;
+ // ptr = plaintext;
ptr += plaintext_len;
signature = (struct GNUNET_CRYPTO_EcdsaSignature *) ptr;
params = (struct OIDC_Parameters *) plaintext;
code_challenge_len = ntohl (params->code_challenge_len);
if (0 != code_challenge_len) /* Only check if this code requires a CV */
{
+ if (NULL == code_verifier)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Expected code verifier!\n");
+ GNUNET_free_non_null (code_payload);
+ return GNUNET_SYSERR;
+ }
code_verifier_hash = GNUNET_malloc (256 / 8);
// hash code verifier
gcry_md_hash_buffer (GCRY_MD_SHA256,
GNUNET_free (expected_code_challenge);
}
// Ticket
- memcpy (ticket, ¶ms->ticket, sizeof (params->ticket));
+ memcpy (ticket, ¶ms->ticket, sizeof(params->ticket));
// Nonce
- nonce = ntohl (params->nonce); //ntohl (*((uint32_t *) ptr));
+ nonce = ntohl (params->nonce); // ntohl (*((uint32_t *) ptr));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got nonce: %u\n", nonce);
// Signature
GNUNET_CRYPTO_ecdsa_key_get_public (ecdsa_priv, &ecdsa_pub);
json_object_set_new (root_json, "token_type", json_string ("Bearer"));
json_object_set_new (root_json,
"expires_in",
- json_integer (expiration_time->rel_value_us /
- (1000 * 1000)));
+ json_integer (expiration_time->rel_value_us
+ / (1000 * 1000)));
json_object_set_new (root_json, "id_token", json_string (id_token));
*token_response = json_dumps (root_json, JSON_INDENT (0) | JSON_COMPACT);
json_decref (root_json);
random_number =
GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_NONCE, UINT64_MAX);
GNUNET_STRINGS_base64_encode (&random_number,
- sizeof (uint64_t),
+ sizeof(uint64_t),
&access_token);
return access_token;
}