Skip to content

Commit 6cd8590

Browse files
maxtropetsmaxtropets
committed
WIP
1 parent c929f24 commit 6cd8590

File tree

12 files changed

+309
-177
lines changed

12 files changed

+309
-177
lines changed

‎include/ccf/crypto/jwk.h

+19-15
Original file line numberDiff line numberDiff line change
@@ -34,21 +34,6 @@ namespace ccf::crypto
3434
DECLARE_JSON_REQUIRED_FIELDS(JsonWebKey, kty);
3535
DECLARE_JSON_OPTIONAL_FIELDS(JsonWebKey, kid, x5c);
3636

37-
struct JsonWebKeyExtended
38-
{
39-
JsonWebKeyType kty;
40-
std::optional<std::string> kid = std::nullopt;
41-
std::optional<std::vector<std::string>> x5c = std::nullopt;
42-
std::optional<std::string> n = std::nullopt;
43-
std::optional<std::string> e = std::nullopt;
44-
std::optional<std::string> issuer = std::nullopt;
45-
46-
bool operator==(const JsonWebKeyExtended&) const = default;
47-
};
48-
DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS(JsonWebKeyExtended);
49-
DECLARE_JSON_REQUIRED_FIELDS(JsonWebKeyExtended, kty);
50-
DECLARE_JSON_OPTIONAL_FIELDS(JsonWebKeyExtended, kid, x5c, n, e, issuer);
51-
5237
enum class JsonWebKeyECCurve
5338
{
5439
P256 = 0,
@@ -61,6 +46,25 @@ namespace ccf::crypto
6146
{JsonWebKeyECCurve::P384, "P-384"},
6247
{JsonWebKeyECCurve::P521, "P-521"}});
6348

49+
struct JsonWebKeyData
50+
{
51+
JsonWebKeyType kty;
52+
std::optional<std::string> kid = std::nullopt;
53+
std::optional<std::vector<std::string>> x5c = std::nullopt;
54+
std::optional<std::string> n = std::nullopt;
55+
std::optional<std::string> e = std::nullopt;
56+
std::optional<std::string> x = std::nullopt;
57+
std::optional<std::string> y = std::nullopt;
58+
std::optional<JsonWebKeyECCurve> crv = std::nullopt;
59+
std::optional<std::string> issuer = std::nullopt;
60+
61+
bool operator==(const JsonWebKeyData&) const = default;
62+
};
63+
DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS(JsonWebKeyData);
64+
DECLARE_JSON_REQUIRED_FIELDS(JsonWebKeyData, kty);
65+
DECLARE_JSON_OPTIONAL_FIELDS(
66+
JsonWebKeyData, kid, x5c, n, e, x, y, crv, issuer);
67+
6468
static JsonWebKeyECCurve curve_id_to_jwk_curve(CurveID curve_id)
6569
{
6670
switch (curve_id)

‎include/ccf/service/tables/jwt.h

+1-1
Original file line numberDiff line numberDiff line change
@@ -92,7 +92,7 @@ namespace ccf
9292

9393
struct JsonWebKeySet
9494
{
95-
std::vector<ccf::crypto::JsonWebKeyExtended> keys;
95+
std::vector<ccf::crypto::JsonWebKeyData> keys;
9696

9797
bool operator!=(const JsonWebKeySet& rhs) const
9898
{

‎samples/constitutions/default/actions.js

+4
Original file line numberDiff line numberDiff line change
@@ -144,6 +144,10 @@ function checkJwks(value, field) {
144144
} else if (jwk.n && jwk.e) {
145145
checkType(jwk.n, "string", `${field}.keys[${i}].n`);
146146
checkType(jwk.e, "string", `${field}.keys[${i}].e`);
147+
} else if (jwk.x && jwk.y) {
148+
checkType(jwk.x, "string", `${field}.keys[${i}].x`);
149+
checkType(jwk.y, "string", `${field}.keys[${i}].y`);
150+
checkType(jwk.crv, "string", `${field}.keys[${i}].crv`);
147151
} else {
148152
throw new Error("JWK must contain either x5c or n and e");
149153
}

‎src/crypto/openssl/rsa_public_key.cpp

+11
Original file line numberDiff line numberDiff line change
@@ -54,6 +54,17 @@ namespace ccf::crypto
5454
auto msg = OpenSSL::error_string(ec);
5555
throw std::runtime_error(fmt::format("OpenSSL error: {}", msg));
5656
}
57+
58+
// As it's a common patter to rely on successful key wrapper construction as a
59+
// confirmation of a concrete key type, this must fail for non-RSA keys.
60+
#if defined(OPENSSL_VERSION_MAJOR) && OPENSSL_VERSION_MAJOR >= 3
61+
if (!key || EVP_PKEY_get_base_id(key) != EVP_PKEY_RSA)
62+
#else
63+
if (!key || !EVP_PKEY_get0_RSA(key))
64+
#endif
65+
{
66+
throw std::logic_error("invalid RSA key");
67+
}
5768
}
5869

5970
std::pair<Unique_BIGNUM, Unique_BIGNUM> get_modulus_and_exponent(

‎src/endpoints/authentication/jwt_auth.cpp

+53-9
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,8 @@
33

44
#include "ccf/endpoints/authentication/jwt_auth.h"
55

6+
#include "ccf/crypto/ecdsa.h"
7+
#include "ccf/crypto/public_key.h"
68
#include "ccf/crypto/rsa_key_pair.h"
79
#include "ccf/ds/nonstd.h"
810
#include "ccf/pal/locking.h"
@@ -88,22 +90,67 @@ namespace ccf
8890
static constexpr size_t DEFAULT_MAX_KEYS = 10;
8991

9092
using DER = std::vector<uint8_t>;
93+
using KeyVariant =
94+
std::variant<ccf::crypto::RSAPublicKeyPtr, ccf::crypto::PublicKeyPtr>;
9195
ccf::pal::Mutex keys_lock;
92-
LRU<DER, ccf::crypto::RSAPublicKeyPtr> keys;
96+
LRU<DER, KeyVariant> keys;
9397

9498
PublicKeysCache(size_t max_keys = DEFAULT_MAX_KEYS) : keys(max_keys) {}
9599

96-
ccf::crypto::RSAPublicKeyPtr get_key(const DER& der)
100+
bool verify(
101+
const uint8_t* contents,
102+
size_t contents_size,
103+
const uint8_t* signature,
104+
size_t signature_size,
105+
const DER& der)
97106
{
98107
std::lock_guard<ccf::pal::Mutex> guard(keys_lock);
99108

100109
auto it = keys.find(der);
101110
if (it == keys.end())
102111
{
103-
it = keys.insert(der, ccf::crypto::make_rsa_public_key(der));
112+
try
113+
{
114+
it = keys.insert(der, ccf::crypto::make_rsa_public_key(der));
115+
}
116+
catch (const std::exception&)
117+
{
118+
it = keys.insert(der, ccf::crypto::make_public_key(der));
119+
}
104120
}
105121

106-
return it->second;
122+
const auto& key = it->second;
123+
if (std::holds_alternative<ccf::crypto::RSAPublicKeyPtr>(key))
124+
{
125+
LOG_DEBUG_FMT("Verify der: {} as RSA key", der);
126+
127+
// Obsolote PKCS1 padding is chosen for JWT, as explained in details in
128+
// https://github.com/microsoft/CCF/issues/6601#issuecomment-2512059875.
129+
return std::get<ccf::crypto::RSAPublicKeyPtr>(key)->verify_pkcs1(
130+
contents,
131+
contents_size,
132+
signature,
133+
signature_size,
134+
ccf::crypto::MDType::SHA256);
135+
}
136+
else if (std::holds_alternative<ccf::crypto::PublicKeyPtr>(key))
137+
{
138+
LOG_DEBUG_FMT("Verify der: {} as EC key", der);
139+
140+
const auto sig_der = ccf::crypto::ecdsa_sig_p1363_to_der(
141+
std::vector<uint8_t>(signature, signature + signature_size));
142+
return std::get<ccf::crypto::PublicKeyPtr>(key)->verify(
143+
contents,
144+
contents_size,
145+
sig_der.data(),
146+
sig_der.size(),
147+
ccf::crypto::MDType::SHA256);
148+
}
149+
else
150+
{
151+
LOG_DEBUG_FMT("Key not found for der: {}", der);
152+
return false;
153+
}
107154
}
108155
};
109156

@@ -191,15 +238,12 @@ namespace ccf
191238

192239
for (const auto& metadata : *token_keys)
193240
{
194-
const auto pubkey = keys_cache->get_key(metadata.public_key);
195-
// Obsolote PKCS1 padding is chosen for JWT, as explained in details here:
196-
// https://github.com/microsoft/CCF/issues/6601#issuecomment-2512059875.
197-
if (!pubkey->verify_pkcs1(
241+
if (!keys_cache->verify(
198242
(uint8_t*)token.signed_content.data(),
199243
token.signed_content.size(),
200244
token.signature.data(),
201245
token.signature.size(),
202-
ccf::crypto::MDType::SHA256))
246+
metadata.public_key))
203247
{
204248
error_reason = "Signature verification failed";
205249
continue;

‎src/http/http_jwt.h

+6-2
Original file line numberDiff line numberDiff line change
@@ -16,9 +16,13 @@ namespace http
1616
{
1717
enum class JwtCryptoAlgorithm
1818
{
19-
RS256
19+
RS256,
20+
ES256,
2021
};
21-
DECLARE_JSON_ENUM(JwtCryptoAlgorithm, {{JwtCryptoAlgorithm::RS256, "RS256"}});
22+
DECLARE_JSON_ENUM(
23+
JwtCryptoAlgorithm,
24+
{{JwtCryptoAlgorithm::RS256, "RS256"},
25+
{JwtCryptoAlgorithm::ES256, "ES256"}});
2226

2327
struct JwtHeader
2428
{

‎src/node/rpc/jwt_management.h

+94-45
Original file line numberDiff line numberDiff line change
@@ -15,59 +15,108 @@
1515

1616
namespace
1717
{
18-
std::vector<uint8_t> try_parse_jwk(const ccf::crypto::JsonWebKeyExtended& jwk)
18+
std::vector<uint8_t> try_parse_raw_rsa(const ccf::crypto::JsonWebKeyData& jwk)
1919
{
20-
const auto& kid = jwk.kid.value();
21-
if (
22-
jwk.e.has_value() && !jwk.e->empty() && jwk.n.has_value() &&
23-
!jwk.n->empty())
20+
if (!jwk.e || jwk.e->empty() || !jwk.n || jwk.n->empty())
2421
{
25-
std::vector<uint8_t> der;
26-
ccf::crypto::JsonWebKeyRSAPublic data;
27-
data.kty = ccf::crypto::JsonWebKeyType::RSA;
28-
data.kid = jwk.kid;
29-
data.n = jwk.n.value();
30-
data.e = jwk.e.value();
31-
try
32-
{
33-
const auto pubkey = ccf::crypto::make_rsa_public_key(data);
34-
return pubkey->public_key_der();
35-
}
36-
catch (const std::invalid_argument& exc)
37-
{
38-
throw std::logic_error(
39-
fmt::format("Failed to construct RSA public key: {}", exc.what()));
40-
}
22+
return {};
4123
}
42-
else if (jwk.x5c.has_value() && !jwk.x5c->empty())
24+
25+
std::vector<uint8_t> der;
26+
ccf::crypto::JsonWebKeyRSAPublic data;
27+
data.kty = ccf::crypto::JsonWebKeyType::RSA;
28+
data.kid = jwk.kid.value();
29+
data.n = jwk.n.value();
30+
data.e = jwk.e.value();
31+
try
4332
{
44-
auto& der_base64 = jwk.x5c.value()[0];
45-
ccf::Cert der;
46-
try
47-
{
48-
der = ccf::crypto::raw_from_b64(der_base64);
49-
}
50-
catch (const std::invalid_argument& e)
51-
{
52-
throw std::logic_error(
53-
fmt::format("Could not parse x5c of key id {}: {}", kid, e.what()));
54-
}
55-
try
56-
{
57-
auto verifier = ccf::crypto::make_unique_verifier(der);
58-
return verifier->public_key_der();
59-
}
60-
catch (std::invalid_argument& exc)
61-
{
62-
throw std::logic_error(fmt::format(
63-
"JWKS kid {} has an invalid X.509 certificate: {}", kid, exc.what()));
64-
}
33+
const auto pubkey = ccf::crypto::make_rsa_public_key(data);
34+
return pubkey->public_key_der();
35+
}
36+
catch (const std::invalid_argument& exc)
37+
{
38+
throw std::logic_error(
39+
fmt::format("Failed to construct RSA public key: {}", exc.what()));
40+
}
41+
}
42+
43+
std::vector<uint8_t> try_parse_raw_ec(const ccf::crypto::JsonWebKeyData& jwk)
44+
{
45+
if (!jwk.x || jwk.x->empty() || !jwk.y || jwk.y->empty() || !jwk.crv)
46+
{
47+
return {};
48+
}
49+
50+
ccf::crypto::JsonWebKeyECPublic data;
51+
data.kty = ccf::crypto::JsonWebKeyType::EC;
52+
data.kid = jwk.kid.value();
53+
data.crv = jwk.crv.value();
54+
data.x = jwk.x.value();
55+
data.y = jwk.y.value();
56+
try
57+
{
58+
const auto pubkey = ccf::crypto::make_public_key(data);
59+
return pubkey->public_key_der();
60+
}
61+
catch (const std::invalid_argument& exc)
62+
{
63+
throw std::logic_error(
64+
fmt::format("Failed to construct EC public key: {}", exc.what()));
65+
}
66+
}
67+
68+
std::vector<uint8_t> try_parse_x5c(const ccf::crypto::JsonWebKeyData& jwk)
69+
{
70+
if (!jwk.x5c || jwk.x5c->empty())
71+
{
72+
return {};
6573
}
66-
else
74+
75+
const auto& kid = jwk.kid.value();
76+
auto& der_base64 = jwk.x5c.value()[0];
77+
ccf::Cert der;
78+
try
79+
{
80+
der = ccf::crypto::raw_from_b64(der_base64);
81+
}
82+
catch (const std::invalid_argument& e)
6783
{
6884
throw std::logic_error(
69-
fmt::format("JWKS kid {} has neither x5c or RSA public key", kid));
85+
fmt::format("Could not parse x5c of key id {}: {}", kid, e.what()));
86+
}
87+
try
88+
{
89+
auto verifier = ccf::crypto::make_unique_verifier(der);
90+
return verifier->public_key_der();
91+
}
92+
catch (std::invalid_argument& exc)
93+
{
94+
throw std::logic_error(fmt::format(
95+
"JWKS kid {} has an invalid X.509 certificate: {}", kid, exc.what()));
96+
}
97+
}
98+
99+
std::vector<uint8_t> try_parse_jwk(const ccf::crypto::JsonWebKeyData& jwk)
100+
{
101+
const auto& kid = jwk.kid.value();
102+
auto key = try_parse_raw_rsa(jwk);
103+
if (!key.empty())
104+
{
105+
return key;
106+
}
107+
key = try_parse_raw_ec(jwk);
108+
if (!key.empty())
109+
{
110+
return key;
70111
}
112+
key = try_parse_x5c(jwk);
113+
if (!key.empty())
114+
{
115+
return key;
116+
}
117+
118+
throw std::logic_error(
119+
fmt::format("JWKS kid {} has neither RSA/EC public key or x5c", kid));
71120
}
72121
}
73122

‎tests/infra/crypto.py

+2-4
Original file line numberDiff line numberDiff line change
@@ -307,10 +307,8 @@ def pub_key_pem_to_der(pem: str) -> bytes:
307307
return cert.public_bytes(Encoding.DER, PublicFormat.SubjectPublicKeyInfo)
308308

309309

310-
def create_jwt(body_claims: dict, key_priv_pem: str, key_id: str) -> str:
311-
return jwt.encode(
312-
body_claims, key_priv_pem, algorithm="RS256", headers={"kid": key_id}
313-
)
310+
def create_jwt(body_claims: dict, key_priv_pem: str, key_id: str, alg="RS256") -> str:
311+
return jwt.encode(body_claims, key_priv_pem, algorithm=alg, headers={"kid": key_id})
314312

315313

316314
def cert_pem_to_der(pem: str) -> bytes:

0 commit comments

Comments
 (0)