/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

/***************************************************************************
 * Copyright (C) 2017-2026 ZmartZone Holding BV
 * Copyright (C) 2013-2017 Ping Identity Corporation
 * All rights reserved.
 *
 * DISCLAIMER OF WARRANTIES:
 *
 * THE SOFTWARE PROVIDED HEREUNDER IS PROVIDED ON AN "AS IS" BASIS, WITHOUT
 * ANY WARRANTIES OR REPRESENTATIONS EXPRESS, IMPLIED OR STATUTORY; INCLUDING,
 * WITHOUT LIMITATION, WARRANTIES OF QUALITY, PERFORMANCE, NONINFRINGEMENT,
 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  NOR ARE THERE ANY
 * WARRANTIES CREATED BY A COURSE OR DEALING, COURSE OF PERFORMANCE OR TRADE
 * USAGE.  FURTHERMORE, THERE ARE NO WARRANTIES THAT THE SOFTWARE WILL MEET
 * YOUR NEEDS OR BE FREE FROM ERRORS, OR THAT THE OPERATION OF THE SOFTWARE
 * WILL BE UNINTERRUPTED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * JSON Web Signature (JWS) / JWT signing, parsing and verification
 *
 * @Author: Hans Zandbelt - hans.zandbelt@openidc.com
 */

#include "jose.h"

#include "jose/internal.h"

#include <jansson.h>

#include <cjose/cjose.h>

#include "util/util.h"

/*
 * set a header value in a JWT
 */
void oidc_jwt_hdr_set(oidc_jwt_t *jwt, const char *key, const char *value) {
	json_object_set_new(jwt->header.value.json, key, json_string(value));
}

/*
 * create a new JWT
 */
oidc_jwt_t *oidc_jwt_new(apr_pool_t *pool, int create_header, int create_payload) {
	oidc_jwt_t *jwt = apr_pcalloc(pool, sizeof(oidc_jwt_t));
	if (create_header) {
		jwt->header.value.json = json_object();
	}
	if (create_payload) {
		jwt->payload.value.json = json_object();
	}
	return jwt;
}

/*
 * get a header value from a JWT
 */
const char *oidc_jwt_hdr_get(oidc_jwt_t *jwt, const char *key) {
	cjose_err cjose_err;
	cjose_header_t *hdr = cjose_jws_get_protected(jwt->cjose_jws);
	return hdr ? cjose_header_get(hdr, key, &cjose_err) : NULL;
}

/*
 * set a JWT header member to a raw (pre-serialized) JSON value
 */
apr_byte_t oidc_jwt_hdr_set_json(oidc_jwt_t *jwt, const char *key, const char *raw_json, oidc_jose_error_t *err) {
	json_error_t json_error;
	json_t *value = json_loads(raw_json, 0, &json_error);
	if (value == NULL) {
		oidc_jose_error(err, "json_loads failed: %s", json_error.text);
		return FALSE;
	}
	json_object_set_new(jwt->header.value.json, key, value);
	return TRUE;
}

/* base64url-encoded {"alg":"none"} JOSE header */
#define OIDC_JOSE_HDR_ALG_NONE "eyJhbGciOiJub25lIn0"

/*
 * perform compact serialization on a JWT and return the resulting string
 */
char *oidc_jose_jwt_serialize(apr_pool_t *pool, oidc_jwt_t *jwt, oidc_jose_error_t *err) {
	cjose_err cjose_err;
	char *result = NULL;
	const char *s_payload = NULL;
	char *out = NULL;
	size_t out_len;

	if (_oidc_strcmp(jwt->header.alg, CJOSE_HDR_ALG_NONE) == 0) {

		s_payload =
		    oidc_json_encode(pool, jwt->payload.value.json, OIDC_JSON_PRESERVE_ORDER | OIDC_JSON_COMPACT);
		if (s_payload == NULL) {
			oidc_jose_error(err, "oidc_util_encode_json failed");
			return NULL;
		}

		// out is allocated by cjose and must be freed explicitly by cjose_get_dealloc()()
		if (cjose_base64url_encode((const uint8_t *)s_payload, _oidc_strlen(s_payload), &out, &out_len,
					   &cjose_err) == FALSE) {
			oidc_jose_error(err, "cjose_base64url_encode failed: %s", oidc_cjose_e2s(pool, cjose_err));
			return NULL;
		}

		result = apr_pstrmemdup(pool, out, out_len);
		cjose_get_dealloc()(out);
		result = apr_psprintf(pool, "%s.%s.", OIDC_JOSE_HDR_ALG_NONE, result);

	} else {

		// out: "the returned string pointer is owned by the JWS, the caller should not attempt to free it
		// directly"
		if (cjose_jws_export(jwt->cjose_jws, (const char **)&out, &cjose_err) == FALSE) {
			oidc_jose_error(err, "cjose_jws_export failed: %s", oidc_cjose_e2s(pool, cjose_err));
			return NULL;
		}

		result = apr_pstrdup(pool, out);
	}

	return result;
}

/*
 * return the key type for an algorithm
 */
int oidc_alg2kty(const char *alg) {
	if (_oidc_strcmp(alg, CJOSE_HDR_ALG_DIR) == 0)
		return CJOSE_JWK_KTY_OCT;
	if (_oidc_strncmp(alg, "RS", 2) == 0)
		return CJOSE_JWK_KTY_RSA;
	if (_oidc_strncmp(alg, "PS", 2) == 0)
		return CJOSE_JWK_KTY_RSA;
	if (_oidc_strncmp(alg, "HS", 2) == 0)
		return CJOSE_JWK_KTY_OCT;
#if (OIDC_JOSE_EC_SUPPORT)
	if (_oidc_strncmp(alg, "ES", 2) == 0)
		return CJOSE_JWK_KTY_EC;
#endif
	if ((_oidc_strcmp(alg, CJOSE_HDR_ALG_A128KW) == 0) || (_oidc_strcmp(alg, CJOSE_HDR_ALG_A192KW) == 0) ||
	    (_oidc_strcmp(alg, CJOSE_HDR_ALG_A256KW) == 0))
		return CJOSE_JWK_KTY_OCT;
	if (_oidc_strcmp(alg, CJOSE_HDR_ALG_RSA_OAEP) == 0)
		return CJOSE_JWK_KTY_RSA;
	return -1;
}

/*
 * return the key type of a JWT
 */
int oidc_jwt_alg2kty(const oidc_jwt_t *jwt) {
	return oidc_alg2kty(jwt->header.alg);
}

/*
 * return the key size for an algorithm
 */
unsigned int oidc_alg2keysize(const char *alg) {

	if (alg == NULL)
		return 0;

	if (_oidc_strcmp(alg, CJOSE_HDR_ALG_A128KW) == 0)
		return 16;
	if (_oidc_strcmp(alg, CJOSE_HDR_ALG_A192KW) == 0)
		return 24;
	if (_oidc_strcmp(alg, CJOSE_HDR_ALG_A256KW) == 0)
		return 32;

	if ((_oidc_strcmp(alg, CJOSE_HDR_ALG_RS256) == 0) || (_oidc_strcmp(alg, CJOSE_HDR_ALG_PS256) == 0) ||
	    (_oidc_strcmp(alg, CJOSE_HDR_ALG_HS256) == 0))
		return 32;
	if ((_oidc_strcmp(alg, CJOSE_HDR_ALG_RS384) == 0) || (_oidc_strcmp(alg, CJOSE_HDR_ALG_PS384) == 0) ||
	    (_oidc_strcmp(alg, CJOSE_HDR_ALG_HS384) == 0))
		return 48;
	if ((_oidc_strcmp(alg, CJOSE_HDR_ALG_RS512) == 0) || (_oidc_strcmp(alg, CJOSE_HDR_ALG_PS512) == 0) ||
	    (_oidc_strcmp(alg, CJOSE_HDR_ALG_HS512) == 0))
		return 64;

	return 0;
}

#define OIDC_JOSE_JWT_ISS "iss"
#define OIDC_JOSE_JWT_SUB "sub"
#define OIDC_JOSE_JWT_EXP "exp"
#define OIDC_JOSE_JWT_IAT "iat"

/*
 * parse JWT payload
 */
static apr_byte_t oidc_jose_parse_payload(apr_pool_t *pool, const char *s_payload, size_t s_payload_len,
					  oidc_jwt_payload_t *payload, oidc_jose_error_t *err) {

	/* decode the string in to a JSON structure into value->json */
	json_error_t json_error;
	payload->value.str = apr_pstrndup(pool, s_payload, s_payload_len);
	payload->value.json = json_loads(payload->value.str, 0, &json_error);

	/* check that we've actually got a JSON value back */
	if (payload->value.json == NULL) {
		oidc_jose_error(err, "JSON parsing (json_loads) failed: %s (%s)", json_error.text, payload->value.str);
		return FALSE;
	}

	/* check that the value is a JSON object */
	if (!json_is_object(payload->value.json)) {
		oidc_jose_error(err, "JSON value is not an object");
		return FALSE;
	}

	/* get the (optional) "iss" value from the JSON payload */
	oidc_jose_get_string(pool, payload->value.json, OIDC_JOSE_JWT_ISS, FALSE, &payload->iss, NULL);

	/* get the (optional) "exp" value from the JSON payload */
	oidc_jose_get_timestamp(payload->value.json, OIDC_JOSE_JWT_EXP, FALSE, &payload->exp, NULL);

	/* get the (optional) "iat" value from the JSON payload */
	oidc_jose_get_timestamp(payload->value.json, OIDC_JOSE_JWT_IAT, FALSE, &payload->iat, NULL);

	/* get the (optional) "sub" value from the JSON payload */
	oidc_jose_get_string(pool, payload->value.json, OIDC_JOSE_JWT_SUB, FALSE, &payload->sub, NULL);

	return TRUE;
}

/*
 * parse and (optionally) decrypt a JSON Web Token
 */
apr_byte_t oidc_jwt_parse(apr_pool_t *pool, const char *input_json, oidc_jwt_t **j_jwt, apr_hash_t *keys,
			  apr_byte_t compress, oidc_jose_error_t *err) {

	cjose_err cjose_err;
	char *s_json = NULL;

	if (oidc_jwe_decrypt(pool, input_json, keys, &s_json, NULL, err, FALSE) == FALSE)
		return FALSE;

	*j_jwt = oidc_jwt_new(pool, FALSE, FALSE);
	if (*j_jwt == NULL)
		return FALSE;
	oidc_jwt_t *jwt = *j_jwt;

	jwt->cjose_jws = cjose_jws_import(s_json, _oidc_strlen(s_json), &cjose_err);
	if (jwt->cjose_jws == NULL) {
		oidc_jose_error(err, "cjose_jws_import failed: %s", oidc_cjose_e2s(pool, cjose_err));
		oidc_jwt_destroy(jwt);
		*j_jwt = NULL;
		return FALSE;
	}

	cjose_header_t *hdr = cjose_jws_get_protected(jwt->cjose_jws);
	jwt->header.value.json = json_copy((json_t *)hdr);
	jwt->header.value.str =
	    oidc_json_encode(pool, jwt->header.value.json, OIDC_JSON_PRESERVE_ORDER | OIDC_JSON_COMPACT);

	jwt->header.alg = apr_pstrdup(pool, cjose_header_get(hdr, CJOSE_HDR_ALG, &cjose_err));
	jwt->header.enc = apr_pstrdup(pool, cjose_header_get(hdr, CJOSE_HDR_ENC, &cjose_err));
	jwt->header.kid = apr_pstrdup(pool, cjose_header_get(hdr, CJOSE_HDR_KID, &cjose_err));

	uint8_t *plaintext = NULL;
	size_t plaintext_len = 0;
	if (cjose_jws_get_plaintext(jwt->cjose_jws, &plaintext, &plaintext_len, &cjose_err) == FALSE) {
		oidc_jwt_destroy(jwt);
		*j_jwt = NULL;
		oidc_jose_error(err, "cjose_jws_get_plaintext failed: %s", oidc_cjose_e2s(pool, cjose_err));
		return FALSE;
	}

	if (compress == TRUE) {
		char *payload = NULL;
		int payload_len = 0;
		if (oidc_jose_uncompress(pool, (char *)plaintext, (int)plaintext_len, &payload, &payload_len, err) ==
		    FALSE) {
			oidc_jwt_destroy(jwt);
			*j_jwt = NULL;
			return FALSE;
		}
		plaintext = (uint8_t *)payload;
		plaintext_len = payload_len;
	}

	if (oidc_jose_parse_payload(pool, (const char *)plaintext, plaintext_len, &jwt->payload, err) == FALSE) {
		oidc_jwt_destroy(jwt);
		*j_jwt = NULL;
		return FALSE;
	}

	return TRUE;
}

/*
 * destroy resources allocated for JWT
 */
void oidc_jwt_destroy(oidc_jwt_t *jwt) {
	if (jwt) {
		if (jwt->header.value.json) {
			json_decref(jwt->header.value.json);
			jwt->header.value.json = NULL;
			jwt->header.value.str = NULL;
		}
		if (jwt->payload.value.json) {
			json_decref(jwt->payload.value.json);
			jwt->payload.value.json = NULL;
			jwt->payload.value.str = NULL;
		}
		if (jwt->cjose_jws) {
			cjose_jws_release(jwt->cjose_jws);
			jwt->cjose_jws = NULL;
		}
	}
}

/*
 * sign a JWT
 */
apr_byte_t oidc_jwt_sign(apr_pool_t *pool, oidc_jwt_t *jwt, const oidc_jwk_t *jwk, apr_byte_t compress,
			 oidc_jose_error_t *err) {

	cjose_header_t *hdr = (cjose_header_t *)jwt->header.value.json;

	if (jwt->header.alg)
		oidc_jwt_hdr_set(jwt, CJOSE_HDR_ALG, jwt->header.alg);
	if (jwt->header.kid)
		oidc_jwt_hdr_set(jwt, CJOSE_HDR_KID, jwt->header.kid);
	if (jwt->header.enc)
		oidc_jwt_hdr_set(jwt, CJOSE_HDR_ENC, jwt->header.enc);
	if (jwt->header.x5t)
		oidc_jwt_hdr_set(jwt, OIDC_JOSE_JWK_X5T_STR, jwt->header.x5t);

	if (jwt->cjose_jws)
		cjose_jws_release(jwt->cjose_jws);

	cjose_err cjose_err;
	char *plaintext = oidc_json_encode(pool, jwt->payload.value.json, OIDC_JSON_PRESERVE_ORDER | OIDC_JSON_COMPACT);

	char *s_payload = NULL;
	int payload_len = 0;
	if (compress == TRUE) {
		if (oidc_jose_compress(pool, plaintext, (int)_oidc_strlen(plaintext), &s_payload, &payload_len, err) ==
		    FALSE) {
			return FALSE;
		}
	} else {
		s_payload = plaintext;
		payload_len = (int)_oidc_strlen(plaintext);
		jwt->payload.value.str = plaintext;
	}

	jwt->cjose_jws = cjose_jws_sign(jwk->cjose_jwk, hdr, (const uint8_t *)s_payload, payload_len, &cjose_err);

	if (jwt->cjose_jws == NULL) {
		oidc_jose_error(err, "cjose_jws_sign failed: %s", oidc_cjose_e2s(pool, cjose_err));
		return FALSE;
	}

	return TRUE;
}

/*
 * verify the signature of a JWT
 */
/*
 * verify a JWS against a single JWK, reporting failure into err and clearing
 * jwt->cjose_jws when the linked cjose version is known to leave it in an
 * unusable state after a failed verify
 */
static apr_byte_t oidc_jwt_verify_with_key(apr_pool_t *pool, oidc_jwt_t *jwt, const oidc_jwk_t *jwk,
					   oidc_jose_error_t *err) {
	cjose_err cjose_err;
	apr_byte_t rc = cjose_jws_verify(jwt->cjose_jws, jwk->cjose_jwk, &cjose_err);
	if (rc == FALSE) {
		oidc_jose_error(err, "cjose_jws_verify failed: %s", oidc_cjose_e2s(pool, cjose_err));
		if (oidc_jose_version_deprecated(pool))
			jwt->cjose_jws = NULL;
	}
	return rc;
}

/*
 * verify a JWS by iterating over all configured keys with a matching kty
 */
static apr_byte_t oidc_jwt_verify_any(apr_pool_t *pool, oidc_jwt_t *jwt, apr_hash_t *keys, oidc_jose_error_t *err) {
	oidc_jwk_t *jwk = NULL;
	apr_byte_t rc = FALSE;

	for (apr_hash_index_t *hi = apr_hash_first(pool, keys); hi; hi = apr_hash_next(hi)) {
		apr_hash_this(hi, NULL, NULL, (void **)&jwk);
		if (jwk->kty == oidc_jwt_alg2kty(jwt))
			rc = oidc_jwt_verify_with_key(pool, jwt, jwk, err);
		if ((rc == TRUE) || (jwt->cjose_jws == NULL))
			break;
	}

	if (rc == FALSE)
		oidc_jose_error(
		    err, "could not verify signature against any of the (%d) provided keys%s", apr_hash_count(keys),
		    apr_hash_count(keys) > 0
			? ""
			: apr_psprintf(pool,
				       "; you have probably provided no or incorrect keys/key-types for algorithm: %s",
				       jwt->header.alg));

	return rc;
}

apr_byte_t oidc_jwt_verify(apr_pool_t *pool, oidc_jwt_t *jwt, apr_hash_t *keys, oidc_jose_error_t *err) {

	if (jwt->header.kid == NULL)
		return oidc_jwt_verify_any(pool, jwt, keys, err);

	const oidc_jwk_t *jwk = apr_hash_get(keys, jwt->header.kid, APR_HASH_KEY_STRING);
	if (jwk == NULL) {
		oidc_jose_error(err, "could not find key with kid: %s", jwt->header.kid);
		return FALSE;
	}

	/* make sure the key type is compatible with the algorithm, just as the no-kid path does, rather than
	 * relying solely on cjose to reject a mismatch (defense in depth against key/algorithm confusion) */
	if (jwk->kty != oidc_jwt_alg2kty(jwt)) {
		oidc_jose_error(err, "key type of key with kid \"%s\" does not match the JWT \"alg\" header \"%s\"",
				jwt->header.kid, jwt->header.alg);
		return FALSE;
	}

	return oidc_jwt_verify_with_key(pool, jwt, jwk, err);
}
