Merge pull request ceph#63051 from pritha-srivastava/wip-71108-tentacle

tentacle: rgw/sts: Implementation of validating JWT using modulus and exponent

Reviewed-by: Casey Bodley <[email protected]>

Author: cbodley

src/rgw/jwt-cpp/jwt.h

@@ -11,6 +11,10 @@
 #include <openssl/pem.h>
 #include <openssl/ec.h>
 #include <openssl/err.h>
+#include <openssl/bn.h>
+#include <openssl/rsa.h>
+
+#include "rgw/rgw_b64.h"
 
 //If openssl version less than 1.1
 #if OPENSSL_VERSION_NUMBER < 269484032
@@ -233,6 +237,17 @@ namespace jwt {
 				} else
 					throw rsa_exception("at least one of public or private key need to be present");
 			}
+
+			rsa(const EVP_MD*(*md)(), const std::string& name) : md(md), alg_name(name)
+			{}
+
+			void setModulusExponentCalcPublicKey(const std::string& modulus, const std::string& exponent)
+			{
+				this->modulus = modulus;
+				this->exponent = exponent;
+				calculatePublicKey();
+			}
+
 			/**
 			 * Sign jwt data
 			 * \param data The data to sign
@@ -296,8 +311,43 @@ namespace jwt {
 			std::shared_ptr<EVP_PKEY> pkey;
 			/// Hash generator
 			const EVP_MD*(*md)();
+			/// Modulus
+			std::string modulus;
+			/// Exponent
+			std::string exponent;
 			/// Algorithmname
 			const std::string alg_name;
+
+			void calculatePublicKey()
+			{
+				std::string n_str = base64_decode_url(modulus);
+				std::string e_str = base64_decode_url(exponent);
+				unsigned char* u_n = (unsigned char *)n_str.c_str();
+				unsigned char* u_e = (unsigned char *)e_str.c_str();
+				BIGNUM *n = BN_bin2bn(u_n, n_str.size(), NULL);
+				BIGNUM *e = BN_bin2bn(u_e, e_str.size(), NULL);
+
+				if (e && n) {
+					EVP_PKEY* pRsaKey = EVP_PKEY_new();
+					RSA* rsa = RSA_new();
+					RSA_set0_key(rsa, n, e, nullptr);
+					EVP_PKEY_assign_RSA(pRsaKey, rsa);
+					std::shared_ptr<EVP_PKEY> p(pRsaKey, EVP_PKEY_free);
+					pkey = p;
+				} else {
+					if (n) BN_free(n);
+					if (e) BN_free(e);
+					throw rsa_exception("Invalid encoding for modulus or exponent\n");
+				}
+			}
+
+			std::string base64_decode_url(const std::string& str) const {
+				std::string s = "====";
+				std::string padded_str = str.length() % 4 == 0 ? str : str + s.substr(0, str.length() % 4);
+				std::replace(padded_str.begin(), padded_str.end(), '_', '/');
+				std::replace(padded_str.begin(), padded_str.end(), '-', '+');
+				return rgw::from_base64(padded_str);
+			}
 		};
 		/**
 		 * Base class for ECDSA family of algorithms
@@ -629,6 +679,15 @@ namespace jwt {
 			explicit rs256(const std::string& public_key, const std::string& private_key = "", const std::string& public_key_password = "", const std::string& private_key_password = "")
 				: rsa(public_key, private_key, public_key_password, private_key_password, EVP_sha256, "RS256")
 			{}
+
+			rs256() : rsa(EVP_sha256, "RS256")
+			{}
+
+			rs256& setModulusAndExponent(const std::string& modulus, const std::string& exponent)
+			{
+				rsa::setModulusExponentCalcPublicKey(modulus, exponent);
+				return *this;
+			}
 		};
 		/**
 		 * RS384 algorithm
@@ -644,6 +703,15 @@ namespace jwt {
 			explicit rs384(const std::string& public_key, const std::string& private_key = "", const std::string& public_key_password = "", const std::string& private_key_password = "")
 				: rsa(public_key, private_key, public_key_password, private_key_password, EVP_sha384, "RS384")
 			{}
+
+			rs384() : rsa(EVP_sha384, "RS384")
+			{}
+
+			rs384& setModulusAndExponent(const std::string& modulus, const std::string& exponent)
+			{
+				rsa::setModulusExponentCalcPublicKey(modulus, exponent);
+				return *this;
+			}
 		};
 		/**
 		 * RS512 algorithm
@@ -659,6 +727,15 @@ namespace jwt {
 			explicit rs512(const std::string& public_key, const std::string& private_key = "", const std::string& public_key_password = "", const std::string& private_key_password = "")
 				: rsa(public_key, private_key, public_key_password, private_key_password, EVP_sha512, "RS512")
 			{}
+
+			rs512() : rsa(EVP_sha512, "RS512")
+			{}
+
+			rs512& setModulusAndExponent(const std::string& modulus, const std::string& exponent)
+			{
+				rsa::setModulusExponentCalcPublicKey(modulus, exponent);
+				return *this;
+			}
 		};
 		/**
 		 * ES256 algorithm

src/rgw/rgw_auth.cc

@@ -701,7 +701,15 @@ auto rgw::auth::WebIdentityApplier::load_acct_info(const DoutPrefixProvider* dpp
 void rgw::auth::WebIdentityApplier::modify_request_state(const DoutPrefixProvider *dpp, req_state* s) const
 {
   s->info.args.append("sub", this->sub);
-  s->info.args.append("aud", this->aud);
+  //this is needed for AssumeRoleWithWebIdentityResponse
+  //but if aud is not present in the token, client id can be used
+  //from AWS docs - "The intended audience (also known as client ID) of the web identity token."
+  //https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html
+  if (this->aud.empty() && !this->client_id.empty()) {
+    s->info.args.append("aud", this->client_id);
+  } else {
+    s->info.args.append("aud", this->aud);
+  }
   s->info.args.append("provider_id", this->iss);
   s->info.args.append("client_id", this->client_id);