1 // Copyright 2021 Google LLC
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 //
15 ////////////////////////////////////////////////////////////////////////////////
16
17 #include "tink/jwt/internal/jwt_mac_wrapper.h"
18
19 #include <memory>
20 #include <string>
21 #include <utility>
22 #include <vector>
23
24 #include "gtest/gtest.h"
25 #include "absl/strings/str_split.h"
26 #include "tink/cleartext_keyset_handle.h"
27 #include "tink/jwt/internal/json_util.h"
28 #include "tink/jwt/internal/jwt_format.h"
29 #include "tink/jwt/internal/jwt_hmac_key_manager.h"
30 #include "tink/keyset_manager.h"
31 #include "tink/primitive_set.h"
32 #include "tink/util/status.h"
33 #include "tink/util/test_matchers.h"
34 #include "tink/util/test_util.h"
35 #include "proto/jwt_hmac.pb.h"
36 #include "proto/tink.pb.h"
37
38 using google::crypto::tink::JwtHmacAlgorithm;
39 using google::crypto::tink::JwtHmacKeyFormat;
40 using google::crypto::tink::KeyTemplate;
41 using google::crypto::tink::OutputPrefixType;
42
43 namespace crypto {
44 namespace tink {
45 namespace jwt_internal {
46 namespace {
47
48 using ::crypto::tink::CleartextKeysetHandle;
49 using ::crypto::tink::test::IsOk;
50 using ::crypto::tink::test::IsOkAndHolds;
51 using ::google::crypto::tink::Keyset;
52 using ::testing::Eq;
53 using ::testing::Not;
54
createTemplate(OutputPrefixType output_prefix)55 KeyTemplate createTemplate(OutputPrefixType output_prefix) {
56 KeyTemplate key_template;
57 key_template.set_type_url(
58 "type.googleapis.com/google.crypto.tink.JwtHmacKey");
59 key_template.set_output_prefix_type(output_prefix);
60 JwtHmacKeyFormat key_format;
61 key_format.set_key_size(32);
62 key_format.set_algorithm(JwtHmacAlgorithm::HS256);
63 key_format.SerializeToString(key_template.mutable_value());
64 return key_template;
65 }
66
KeysetHandleWithNewKeyId(const KeysetHandle & keyset_handle)67 std::unique_ptr<KeysetHandle> KeysetHandleWithNewKeyId(
68 const KeysetHandle& keyset_handle) {
69 Keyset keyset(CleartextKeysetHandle::GetKeyset(keyset_handle));
70 uint32_t new_key_id = keyset.mutable_key(0)->key_id() ^ 0xdeadbeef;
71 keyset.mutable_key(0)->set_key_id(new_key_id);
72 keyset.set_primary_key_id(new_key_id);
73 return CleartextKeysetHandle::GetKeysetHandle(keyset);
74 }
75
KeysetHandleWithTinkPrefix(const KeysetHandle & keyset_handle)76 std::unique_ptr<KeysetHandle> KeysetHandleWithTinkPrefix(
77 const KeysetHandle& keyset_handle) {
78 Keyset keyset(CleartextKeysetHandle::GetKeyset(keyset_handle));
79 keyset.mutable_key(0)->set_output_prefix_type(OutputPrefixType::TINK);
80 return CleartextKeysetHandle::GetKeysetHandle(keyset);
81 }
82
83 class JwtMacWrapperTest : public ::testing::Test {
84 protected:
SetUp()85 void SetUp() override {
86 ASSERT_THAT(
87 Registry::RegisterPrimitiveWrapper(absl::make_unique<JwtMacWrapper>()),
88 IsOk());
89 ASSERT_THAT(Registry::RegisterKeyTypeManager(
90 absl::make_unique<JwtHmacKeyManager>(), true),
91 IsOk());
92 }
93 };
94
TEST_F(JwtMacWrapperTest,WrapNullptr)95 TEST_F(JwtMacWrapperTest, WrapNullptr) {
96 util::StatusOr<std::unique_ptr<JwtMac>> mac_result =
97 JwtMacWrapper().Wrap(nullptr);
98 EXPECT_FALSE(mac_result.ok());
99 }
100
TEST_F(JwtMacWrapperTest,WrapEmpty)101 TEST_F(JwtMacWrapperTest, WrapEmpty) {
102 auto jwt_mac_set = absl::make_unique<PrimitiveSet<JwtMacInternal>>();
103 util::StatusOr<std::unique_ptr<crypto::tink::JwtMac>> jwt_mac_result =
104 JwtMacWrapper().Wrap(std::move(jwt_mac_set));
105 EXPECT_FALSE(jwt_mac_result.ok());
106 }
107
TEST_F(JwtMacWrapperTest,CannotWrapPrimitivesFromNonRawOrTinkKeys)108 TEST_F(JwtMacWrapperTest, CannotWrapPrimitivesFromNonRawOrTinkKeys) {
109 KeyTemplate tink_key_template = createTemplate(OutputPrefixType::LEGACY);
110
111 util::StatusOr<std::unique_ptr<KeysetHandle>> keyset_handle =
112 KeysetHandle::GenerateNew(tink_key_template);
113 EXPECT_THAT(keyset_handle, IsOk());
114
115 EXPECT_FALSE((*keyset_handle)->GetPrimitive<JwtMac>().status().ok());
116 }
117
TEST_F(JwtMacWrapperTest,GenerateRawComputeVerifySuccess)118 TEST_F(JwtMacWrapperTest, GenerateRawComputeVerifySuccess) {
119 KeyTemplate key_template = createTemplate(OutputPrefixType::RAW);
120 util::StatusOr<std::unique_ptr<KeysetHandle>> keyset_handle =
121 KeysetHandle::GenerateNew(key_template);
122 EXPECT_THAT(keyset_handle, IsOk());
123 util::StatusOr<std::unique_ptr<JwtMac>> jwt_mac =
124 (*keyset_handle)->GetPrimitive<JwtMac>();
125 EXPECT_THAT(jwt_mac, IsOk());
126
127 util::StatusOr<RawJwt> raw_jwt =
128 RawJwtBuilder().SetIssuer("issuer").WithoutExpiration().Build();
129 ASSERT_THAT(raw_jwt, IsOk());
130
131 util::StatusOr<std::string> compact =
132 (*jwt_mac)->ComputeMacAndEncode(*raw_jwt);
133 ASSERT_THAT(compact, IsOk());
134
135 util::StatusOr<JwtValidator> validator = JwtValidatorBuilder()
136 .ExpectIssuer("issuer")
137 .AllowMissingExpiration()
138 .Build();
139 ASSERT_THAT(validator, IsOk());
140 util::StatusOr<VerifiedJwt> verified_jwt =
141 (*jwt_mac)->VerifyMacAndDecode(*compact, *validator);
142 ASSERT_THAT(verified_jwt, IsOk());
143 EXPECT_THAT(verified_jwt->GetIssuer(), IsOkAndHolds("issuer"));
144
145 util::StatusOr<JwtValidator> validator2 = JwtValidatorBuilder()
146 .ExpectIssuer("unknown")
147 .AllowMissingExpiration()
148 .Build();
149 ASSERT_THAT(validator2, IsOk());
150 util::StatusOr<VerifiedJwt> verified_jwt2 =
151 (*jwt_mac)->VerifyMacAndDecode(*compact, *validator2);
152 EXPECT_FALSE(verified_jwt2.ok());
153 // Make sure the error message is interesting
154 EXPECT_THAT(verified_jwt2.status().message(), Eq("wrong issuer"));
155
156 // Raw primitives don't add a kid header, Tink primitives require a kid
157 // header to be set. Thefore, changing the output prefix to TINK makes the
158 // validation fail.
159 std::unique_ptr<KeysetHandle> tink_keyset_handle =
160 KeysetHandleWithTinkPrefix(**keyset_handle);
161 util::StatusOr<std::unique_ptr<JwtMac>> tink_jwt_mac =
162 tink_keyset_handle->GetPrimitive<JwtMac>();
163 ASSERT_THAT(tink_jwt_mac, IsOk());
164
165 EXPECT_THAT(
166 (*tink_jwt_mac)->VerifyMacAndDecode(*compact, *validator).status(),
167 Not(IsOk()));
168 }
169
TEST_F(JwtMacWrapperTest,GenerateTinkComputeVerifySuccess)170 TEST_F(JwtMacWrapperTest, GenerateTinkComputeVerifySuccess) {
171 KeyTemplate key_template = createTemplate(OutputPrefixType::TINK);
172 util::StatusOr<std::unique_ptr<KeysetHandle>> keyset_handle =
173 KeysetHandle::GenerateNew(key_template);
174 EXPECT_THAT(keyset_handle, IsOk());
175 util::StatusOr<std::unique_ptr<JwtMac>> jwt_mac =
176 (*keyset_handle)->GetPrimitive<JwtMac>();
177 EXPECT_THAT(jwt_mac, IsOk());
178
179 util::StatusOr<RawJwt> raw_jwt =
180 RawJwtBuilder().SetIssuer("issuer").WithoutExpiration().Build();
181 ASSERT_THAT(raw_jwt, IsOk());
182
183 util::StatusOr<std::string> compact =
184 (*jwt_mac)->ComputeMacAndEncode(*raw_jwt);
185 ASSERT_THAT(compact, IsOk());
186
187 util::StatusOr<JwtValidator> validator = JwtValidatorBuilder()
188 .ExpectIssuer("issuer")
189 .AllowMissingExpiration()
190 .Build();
191 ASSERT_THAT(validator, IsOk());
192 util::StatusOr<VerifiedJwt> verified_jwt =
193 (*jwt_mac)->VerifyMacAndDecode(*compact, *validator);
194 ASSERT_THAT(verified_jwt, IsOk());
195 EXPECT_THAT(verified_jwt->GetIssuer(), test::IsOkAndHolds("issuer"));
196
197 // Parse header to make sure that key ID is correctly encoded.
198 google::crypto::tink::KeysetInfo keyset_info =
199 (*keyset_handle)->GetKeysetInfo();
200 uint32_t key_id = keyset_info.key_info(0).key_id();
201 std::vector<absl::string_view> parts = absl::StrSplit(*compact, '.');
202 ASSERT_THAT(parts.size(), Eq(3));
203 std::string json_header;
204 ASSERT_TRUE(DecodeHeader(parts[0], &json_header));
205 util::StatusOr<google::protobuf::Struct> header =
206 JsonStringToProtoStruct(json_header);
207 ASSERT_THAT(header, IsOk());
208 EXPECT_THAT(GetKeyId((*header).fields().find("kid")->second.string_value()),
209 key_id);
210
211 // For Tink primitives, the kid must be correctly set and is verified.
212 // Therefore, changing the key_id makes the validation fail.
213 std::unique_ptr<KeysetHandle> keyset_handle_with_new_key_id =
214 KeysetHandleWithNewKeyId(**keyset_handle);
215 util::StatusOr<std::unique_ptr<JwtMac>> jwt_mac_with_new_key_id =
216 keyset_handle_with_new_key_id->GetPrimitive<JwtMac>();
217 ASSERT_THAT(jwt_mac_with_new_key_id, IsOk());
218
219 util::StatusOr<VerifiedJwt> verified_jwt_2 =
220 (*jwt_mac_with_new_key_id)->VerifyMacAndDecode(*compact, *validator);
221 EXPECT_FALSE(verified_jwt_2.ok());
222 }
223
TEST_F(JwtMacWrapperTest,KeyRotation)224 TEST_F(JwtMacWrapperTest, KeyRotation) {
225 std::vector<OutputPrefixType> prefixes = {OutputPrefixType::RAW,
226 OutputPrefixType::TINK};
227 for (OutputPrefixType prefix : prefixes) {
228 SCOPED_TRACE(absl::StrCat("Testing with prefix ", prefix));
229 KeyTemplate key_template = createTemplate(prefix);
230 KeysetManager manager;
231
232 util::StatusOr<uint32_t> old_id = manager.Add(key_template);
233 ASSERT_THAT(old_id, IsOk());
234 ASSERT_THAT(manager.SetPrimary(*old_id), IsOk());
235 std::unique_ptr<KeysetHandle> handle1 = manager.GetKeysetHandle();
236 util::StatusOr<std::unique_ptr<JwtMac>> jwt_mac1 =
237 handle1->GetPrimitive<JwtMac>();
238 ASSERT_THAT(jwt_mac1, IsOk());
239
240 util::StatusOr<uint32_t> new_id = manager.Add(key_template);
241 ASSERT_THAT(new_id, IsOk());
242 std::unique_ptr<KeysetHandle> handle2 = manager.GetKeysetHandle();
243 util::StatusOr<std::unique_ptr<JwtMac>> jwt_mac2 =
244 handle2->GetPrimitive<JwtMac>();
245 ASSERT_THAT(jwt_mac2, IsOk());
246
247 ASSERT_THAT(manager.SetPrimary(*new_id), IsOk());
248 std::unique_ptr<KeysetHandle> handle3 = manager.GetKeysetHandle();
249 util::StatusOr<std::unique_ptr<JwtMac>> jwt_mac3 =
250 handle3->GetPrimitive<JwtMac>();
251 ASSERT_THAT(jwt_mac3, IsOk());
252
253 ASSERT_THAT(manager.Disable(*old_id), IsOk());
254 std::unique_ptr<KeysetHandle> handle4 = manager.GetKeysetHandle();
255 util::StatusOr<std::unique_ptr<JwtMac>> jwt_mac4 =
256 handle4->GetPrimitive<JwtMac>();
257 ASSERT_THAT(jwt_mac4, IsOk());
258
259 util::StatusOr<RawJwt> raw_jwt =
260 RawJwtBuilder().SetIssuer("issuer").WithoutExpiration().Build();
261 ASSERT_THAT(raw_jwt, IsOk());
262 util::StatusOr<JwtValidator> validator = JwtValidatorBuilder()
263 .ExpectIssuer("issuer")
264 .AllowMissingExpiration()
265 .Build();
266 ASSERT_THAT(validator, IsOk());
267
268 util::StatusOr<std::string> compact1 =
269 (*jwt_mac1)->ComputeMacAndEncode(*raw_jwt);
270 ASSERT_THAT(compact1, IsOk());
271
272 util::StatusOr<std::string> compact2 =
273 (*jwt_mac2)->ComputeMacAndEncode(*raw_jwt);
274 ASSERT_THAT(compact2, IsOk());
275
276 util::StatusOr<std::string> compact3 =
277 (*jwt_mac3)->ComputeMacAndEncode(*raw_jwt);
278 ASSERT_THAT(compact3, IsOk());
279
280 util::StatusOr<std::string> compact4 =
281 (*jwt_mac4)->ComputeMacAndEncode(*raw_jwt);
282 ASSERT_THAT(compact4, IsOk());
283
284 EXPECT_THAT((*jwt_mac1)->VerifyMacAndDecode(*compact1, *validator).status(),
285 IsOk());
286 EXPECT_THAT((*jwt_mac2)->VerifyMacAndDecode(*compact1, *validator).status(),
287 IsOk());
288 EXPECT_THAT((*jwt_mac3)->VerifyMacAndDecode(*compact1, *validator).status(),
289 IsOk());
290 EXPECT_FALSE((*jwt_mac4)->VerifyMacAndDecode(*compact1, *validator).ok());
291
292 EXPECT_THAT((*jwt_mac1)->VerifyMacAndDecode(*compact2, *validator).status(),
293 IsOk());
294 EXPECT_THAT((*jwt_mac2)->VerifyMacAndDecode(*compact2, *validator).status(),
295 IsOk());
296 EXPECT_THAT((*jwt_mac3)->VerifyMacAndDecode(*compact2, *validator).status(),
297 IsOk());
298 EXPECT_FALSE((*jwt_mac4)->VerifyMacAndDecode(*compact2, *validator).ok());
299
300 EXPECT_FALSE((*jwt_mac1)->VerifyMacAndDecode(*compact3, *validator).ok());
301 EXPECT_THAT((*jwt_mac2)->VerifyMacAndDecode(*compact3, *validator).status(),
302 IsOk());
303 EXPECT_THAT((*jwt_mac3)->VerifyMacAndDecode(*compact3, *validator).status(),
304 IsOk());
305 EXPECT_THAT((*jwt_mac4)->VerifyMacAndDecode(*compact3, *validator).status(),
306 IsOk());
307
308 EXPECT_FALSE((*jwt_mac1)->VerifyMacAndDecode(*compact4, *validator).ok());
309 EXPECT_THAT((*jwt_mac2)->VerifyMacAndDecode(*compact4, *validator).status(),
310 IsOk());
311 EXPECT_THAT((*jwt_mac3)->VerifyMacAndDecode(*compact4, *validator).status(),
312 IsOk());
313 EXPECT_THAT((*jwt_mac4)->VerifyMacAndDecode(*compact4, *validator).status(),
314 IsOk());
315 }
316 }
317
318 } // namespace
319 } // namespace jwt_internal
320 } // namespace tink
321 } // namespace crypto
322