1 // Copyright 2020 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "chromeos/dbus/attestation/fake_attestation_client.h"
6
7 #include <utility>
8
9 #include "base/bind.h"
10 #include "base/location.h"
11 #include "base/strings/string_number_conversions.h"
12 #include "base/threading/thread_task_runner_handle.h"
13 #include "base/time/time.h"
14 #include "third_party/cros_system_api/dbus/attestation/dbus-constants.h"
15
16 namespace chromeos {
17 namespace {
18
19 constexpr int kCertificateNotAssigned = 0;
20 constexpr char kFakeCertPrefix[] = "fake cert";
21 constexpr char kResponseSuffix[] = "_response";
22 constexpr char kSignatureSuffix[] = "_signature";
23 constexpr char kEnterpriseChallengeResponseSuffix[] = "enterprise_challenge";
24 constexpr char kIncludeSpkacSuffix[] = "_with_spkac";
25 constexpr char kFakePcaEnrollRequest[] = "fake enroll request";
26 constexpr char kFakePcaEnrollResponse[] = "fake enroll response";
27 constexpr char kFakePcaCertRequest[] = "fake cert request";
28 constexpr char kFakePcaCertResponse[] = "fake cert response";
29 constexpr char kFakeCertificate[] = "fake certificate";
30
31 // Posts `callback` on the current thread's task runner, passing it the
32 // `reply` message.
33 template <class ReplyType>
PostProtoResponse(base::OnceCallback<void (const ReplyType &)> callback,const ReplyType & reply)34 void PostProtoResponse(base::OnceCallback<void(const ReplyType&)> callback,
35 const ReplyType& reply) {
36 base::ThreadTaskRunnerHandle::Get()->PostTask(
37 FROM_HERE, base::BindOnce(std::move(callback), reply));
38 }
39
40 // Posts `callback` on the current thread's task runner, passing it the
41 // `reply` message with `delay`.
42 template <class ReplyType>
PostProtoResponseWithDelay(base::OnceCallback<void (const ReplyType &)> callback,const ReplyType & reply,const base::TimeDelta & delay)43 void PostProtoResponseWithDelay(
44 base::OnceCallback<void(const ReplyType&)> callback,
45 const ReplyType& reply,
46 const base::TimeDelta& delay) {
47 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
48 FROM_HERE, base::BindOnce(std::move(callback), reply), delay);
49 }
50
GetCertificateRequestEqual(::attestation::GetCertificateRequest r1,::attestation::GetCertificateRequest r2)51 bool GetCertificateRequestEqual(::attestation::GetCertificateRequest r1,
52 ::attestation::GetCertificateRequest r2) {
53 // To prevent regression from future expansion to |GetCertificateRequest|, we
54 // compare their serialized results so the difference doesn't get away from
55 // this function. We can't really make use of
56 // |google::protobuf::util::MessageDifferencer|, which doesn't apply to
57 // |MessageLite|.
58
59 // |shall_trigger_enrollment| and |forced| shouldn't affect the whilelisting.
60 r1.clear_forced();
61 r2.clear_forced();
62 r1.clear_shall_trigger_enrollment();
63 r2.clear_shall_trigger_enrollment();
64 return r1.SerializeAsString() == r2.SerializeAsString();
65 }
66
67 } // namespace
68
FakeAttestationClient()69 FakeAttestationClient::FakeAttestationClient() {
70 status_reply_.set_enrolled(true);
71 }
72
73 FakeAttestationClient::~FakeAttestationClient() = default;
74
GetKeyInfo(const::attestation::GetKeyInfoRequest & request,GetKeyInfoCallback callback)75 void FakeAttestationClient::GetKeyInfo(
76 const ::attestation::GetKeyInfoRequest& request,
77 GetKeyInfoCallback callback) {
78 ::attestation::GetKeyInfoReply reply;
79 if (key_info_dbus_error_count_ > 0) {
80 reply.set_status(::attestation::STATUS_DBUS_ERROR);
81 key_info_dbus_error_count_--;
82 } else {
83 auto iter = key_info_database_.find(request);
84 if (iter != key_info_database_.end()) {
85 reply = iter->second;
86 } else {
87 reply.set_status(::attestation::STATUS_INVALID_PARAMETER);
88 }
89 }
90
91 PostProtoResponse(std::move(callback), reply);
92 }
93
GetEndorsementInfo(const::attestation::GetEndorsementInfoRequest & request,GetEndorsementInfoCallback callback)94 void FakeAttestationClient::GetEndorsementInfo(
95 const ::attestation::GetEndorsementInfoRequest& request,
96 GetEndorsementInfoCallback callback) {
97 NOTIMPLEMENTED();
98 }
99
GetAttestationKeyInfo(const::attestation::GetAttestationKeyInfoRequest & request,GetAttestationKeyInfoCallback callback)100 void FakeAttestationClient::GetAttestationKeyInfo(
101 const ::attestation::GetAttestationKeyInfoRequest& request,
102 GetAttestationKeyInfoCallback callback) {
103 NOTIMPLEMENTED();
104 }
105
ActivateAttestationKey(const::attestation::ActivateAttestationKeyRequest & request,ActivateAttestationKeyCallback callback)106 void FakeAttestationClient::ActivateAttestationKey(
107 const ::attestation::ActivateAttestationKeyRequest& request,
108 ActivateAttestationKeyCallback callback) {
109 NOTIMPLEMENTED();
110 }
111
CreateCertifiableKey(const::attestation::CreateCertifiableKeyRequest & request,CreateCertifiableKeyCallback callback)112 void FakeAttestationClient::CreateCertifiableKey(
113 const ::attestation::CreateCertifiableKeyRequest& request,
114 CreateCertifiableKeyCallback callback) {
115 NOTIMPLEMENTED();
116 }
117
Decrypt(const::attestation::DecryptRequest & request,DecryptCallback callback)118 void FakeAttestationClient::Decrypt(
119 const ::attestation::DecryptRequest& request,
120 DecryptCallback callback) {
121 NOTIMPLEMENTED();
122 }
123
Sign(const::attestation::SignRequest & request,SignCallback callback)124 void FakeAttestationClient::Sign(const ::attestation::SignRequest& request,
125 SignCallback callback) {
126 NOTIMPLEMENTED();
127 }
128
RegisterKeyWithChapsToken(const::attestation::RegisterKeyWithChapsTokenRequest & request,RegisterKeyWithChapsTokenCallback callback)129 void FakeAttestationClient::RegisterKeyWithChapsToken(
130 const ::attestation::RegisterKeyWithChapsTokenRequest& request,
131 RegisterKeyWithChapsTokenCallback callback) {
132 ::attestation::RegisterKeyWithChapsTokenReply reply;
133 if (allowlisted_register_keys_.count(
134 {request.username(), request.key_label()}) == 0) {
135 reply.set_status(::attestation::STATUS_INVALID_PARAMETER);
136 } else {
137 reply.set_status(register_key_status_);
138 }
139 PostProtoResponse(std::move(callback), reply);
140 }
141
GetEnrollmentPreparations(const::attestation::GetEnrollmentPreparationsRequest & request,GetEnrollmentPreparationsCallback callback)142 void FakeAttestationClient::GetEnrollmentPreparations(
143 const ::attestation::GetEnrollmentPreparationsRequest& request,
144 GetEnrollmentPreparationsCallback callback) {
145 ::attestation::GetEnrollmentPreparationsReply reply;
146 reply.set_status(preparations_status_);
147
148 if (reply.status() == ::attestation::STATUS_SUCCESS) {
149 bool is_prepared = is_prepared_;
150 // Override the state if there is a customized sequence.
151 if (!preparation_sequences_.empty()) {
152 is_prepared = preparation_sequences_.front();
153 preparation_sequences_.pop_front();
154 }
155 if (is_prepared) {
156 std::vector<::attestation::ACAType> prepared_types;
157 // As we do in the attestation service, if the ACA type is not specified,
158 // returns the statuses with all the possible ACA types.
159 if (request.has_aca_type()) {
160 prepared_types = {request.aca_type()};
161 } else {
162 prepared_types = {::attestation::DEFAULT_ACA, ::attestation::TEST_ACA};
163 }
164 for (const auto& type : prepared_types) {
165 (*reply.mutable_enrollment_preparations())[type] = true;
166 }
167 }
168 }
169
170 PostProtoResponse(std::move(callback), reply);
171 }
172
GetStatus(const::attestation::GetStatusRequest & request,GetStatusCallback callback)173 void FakeAttestationClient::GetStatus(
174 const ::attestation::GetStatusRequest& request,
175 GetStatusCallback callback) {
176 PostProtoResponse(std::move(callback), status_reply_);
177 }
178
Verify(const::attestation::VerifyRequest & request,VerifyCallback callback)179 void FakeAttestationClient::Verify(const ::attestation::VerifyRequest& request,
180 VerifyCallback callback) {
181 NOTIMPLEMENTED();
182 }
183
CreateEnrollRequest(const::attestation::CreateEnrollRequestRequest & request,CreateEnrollRequestCallback callback)184 void FakeAttestationClient::CreateEnrollRequest(
185 const ::attestation::CreateEnrollRequestRequest& request,
186 CreateEnrollRequestCallback callback) {
187 ::attestation::CreateEnrollRequestReply reply;
188 reply.set_status(enroll_request_status_);
189 if (reply.status() == ::attestation::STATUS_SUCCESS) {
190 reply.set_pca_request(GetFakePcaEnrollRequest());
191 }
192 PostProtoResponse(std::move(callback), reply);
193 }
194
FinishEnroll(const::attestation::FinishEnrollRequest & request,FinishEnrollCallback callback)195 void FakeAttestationClient::FinishEnroll(
196 const ::attestation::FinishEnrollRequest& request,
197 FinishEnrollCallback callback) {
198 ::attestation::FinishEnrollReply reply;
199 reply.set_status(request.pca_response() == GetFakePcaEnrollResponse()
200 ? ::attestation::STATUS_SUCCESS
201 : ::attestation::STATUS_UNEXPECTED_DEVICE_ERROR);
202 PostProtoResponse(std::move(callback), reply);
203 }
204
CreateCertificateRequest(const::attestation::CreateCertificateRequestRequest & request,CreateCertificateRequestCallback callback)205 void FakeAttestationClient::CreateCertificateRequest(
206 const ::attestation::CreateCertificateRequestRequest& request,
207 CreateCertificateRequestCallback callback) {
208 ::attestation::CreateCertificateRequestReply reply;
209 reply.set_status(cert_request_status_);
210 if (reply.status() != ::attestation::STATUS_SUCCESS) {
211 PostProtoResponse(std::move(callback), reply);
212 return;
213 }
214 for (const auto& req : allowlisted_create_requests_) {
215 if (req.username() == request.username() &&
216 req.request_origin() == request.request_origin() &&
217 req.certificate_profile() == request.certificate_profile() &&
218 req.key_type() == request.key_type()) {
219 reply.set_pca_request(GetFakePcaCertRequest());
220 PostProtoResponse(std::move(callback), reply);
221 return;
222 }
223 }
224 reply.set_status(::attestation::STATUS_UNEXPECTED_DEVICE_ERROR);
225 PostProtoResponse(std::move(callback), reply);
226 }
227
FinishCertificateRequest(const::attestation::FinishCertificateRequestRequest & request,FinishCertificateRequestCallback callback)228 void FakeAttestationClient::FinishCertificateRequest(
229 const ::attestation::FinishCertificateRequestRequest& request,
230 FinishCertificateRequestCallback callback) {
231 ::attestation::FinishCertificateRequestReply reply;
232 if (request.pca_response() != GetFakePcaCertResponse()) {
233 reply.set_status(::attestation::STATUS_UNEXPECTED_DEVICE_ERROR);
234 }
235 if (reply.status() == ::attestation::STATUS_SUCCESS) {
236 reply.set_certificate(GetFakeCertificate());
237 // Also, insert the certificate into the fake database.
238 GetMutableKeyInfoReply(request.username(), request.key_label())
239 ->set_certificate(GetFakeCertificate());
240 }
241 PostProtoResponse(std::move(callback), reply);
242 }
243
Enroll(const::attestation::EnrollRequest & request,EnrollCallback callback)244 void FakeAttestationClient::Enroll(const ::attestation::EnrollRequest& request,
245 EnrollCallback callback) {
246 NOTIMPLEMENTED();
247 }
248
GetCertificate(const::attestation::GetCertificateRequest & request,GetCertificateCallback callback)249 void FakeAttestationClient::GetCertificate(
250 const ::attestation::GetCertificateRequest& request,
251 GetCertificateCallback callback) {
252 ::attestation::GetCertificateReply reply;
253 reply.set_status(
254 ::attestation::AttestationStatus::STATUS_UNEXPECTED_DEVICE_ERROR);
255
256 if (request.shall_trigger_enrollment()) {
257 status_reply_.set_enrolled(true);
258 }
259 if (!status_reply_.enrolled()) {
260 PostProtoResponse(std::move(callback), reply);
261 return;
262 }
263
264 for (size_t i = 0; i < allowlisted_requests_.size(); ++i) {
265 if (GetCertificateRequestEqual(allowlisted_requests_[i], request)) {
266 if (request.forced() ||
267 certificate_indices_[i] == kCertificateNotAssigned) {
268 ++certificate_count_;
269 certificate_indices_[i] = certificate_count_;
270 }
271 reply.set_status(::attestation::AttestationStatus::STATUS_SUCCESS);
272 reply.set_certificate(kFakeCertPrefix +
273 base::NumberToString(certificate_indices_[i]));
274 break;
275 }
276 }
277
278 PostProtoResponse(std::move(callback), reply);
279 }
280
SignEnterpriseChallenge(const::attestation::SignEnterpriseChallengeRequest & request,SignEnterpriseChallengeCallback callback)281 void FakeAttestationClient::SignEnterpriseChallenge(
282 const ::attestation::SignEnterpriseChallengeRequest& request,
283 SignEnterpriseChallengeCallback callback) {
284 ::attestation::SignEnterpriseChallengeReply reply;
285 if (allowlisted_sign_enterprise_challenge_keys_.count(request) == 0) {
286 reply.set_status(::attestation::STATUS_INVALID_PARAMETER);
287 } else {
288 reply.set_status(sign_enterprise_challenge_status_);
289 }
290 if (reply.status() == ::attestation::STATUS_SUCCESS) {
291 reply.set_challenge_response(GetEnterpriseChallengeFakeSignature(
292 request.challenge(), request.include_signed_public_key()));
293 }
294 PostProtoResponseWithDelay(std::move(callback), reply,
295 sign_enterprise_challenge_delay_);
296 }
297
SignSimpleChallenge(const::attestation::SignSimpleChallengeRequest & request,SignSimpleChallengeCallback callback)298 void FakeAttestationClient::SignSimpleChallenge(
299 const ::attestation::SignSimpleChallengeRequest& request,
300 SignSimpleChallengeCallback callback) {
301 ::attestation::SignSimpleChallengeReply reply;
302 if (allowlisted_sign_simple_challenge_keys_.count(
303 {request.username(), request.key_label()}) == 0) {
304 reply.set_status(::attestation::STATUS_INVALID_PARAMETER);
305 } else {
306 reply.set_status(sign_simple_challenge_status_);
307 }
308 if (reply.status() == ::attestation::STATUS_SUCCESS) {
309 ::attestation::SignedData signed_data;
310 signed_data.set_data(request.challenge() + kResponseSuffix);
311 signed_data.set_signature(request.challenge() + kSignatureSuffix);
312 reply.set_challenge_response(signed_data.SerializeAsString());
313 }
314 PostProtoResponse(std::move(callback), reply);
315 }
316
SetKeyPayload(const::attestation::SetKeyPayloadRequest & request,SetKeyPayloadCallback callback)317 void FakeAttestationClient::SetKeyPayload(
318 const ::attestation::SetKeyPayloadRequest& request,
319 SetKeyPayloadCallback callback) {
320 ::attestation::GetKeyInfoRequest get_key_info_request;
321 get_key_info_request.set_username(request.username());
322 get_key_info_request.set_key_label(request.key_label());
323 auto iter = key_info_database_.find(get_key_info_request);
324 ::attestation::SetKeyPayloadReply reply;
325 if (iter == key_info_database_.end()) {
326 reply.set_status(::attestation::STATUS_INVALID_PARAMETER);
327 } else {
328 iter->second.set_payload(request.payload());
329 }
330 PostProtoResponse(std::move(callback), reply);
331 }
332
DeleteKeys(const::attestation::DeleteKeysRequest & request,DeleteKeysCallback callback)333 void FakeAttestationClient::DeleteKeys(
334 const ::attestation::DeleteKeysRequest& request,
335 DeleteKeysCallback callback) {
336 delete_keys_history_.push_back(request);
337 ::attestation::DeleteKeysReply reply;
338 reply.set_status(::attestation::STATUS_SUCCESS);
339 PostProtoResponse(std::move(callback), reply);
340 }
341
ResetIdentity(const::attestation::ResetIdentityRequest & request,ResetIdentityCallback callback)342 void FakeAttestationClient::ResetIdentity(
343 const ::attestation::ResetIdentityRequest& request,
344 ResetIdentityCallback callback) {
345 NOTIMPLEMENTED();
346 }
347
GetEnrollmentId(const::attestation::GetEnrollmentIdRequest & request,GetEnrollmentIdCallback callback)348 void FakeAttestationClient::GetEnrollmentId(
349 const ::attestation::GetEnrollmentIdRequest& request,
350 GetEnrollmentIdCallback callback) {
351 ::attestation::GetEnrollmentIdReply reply;
352 if (enrollment_id_dbus_error_count_ != 0) {
353 reply.set_status(::attestation::STATUS_DBUS_ERROR);
354 enrollment_id_dbus_error_count_--;
355 } else {
356 reply.set_status(::attestation::STATUS_SUCCESS);
357 reply.set_enrollment_id(request.ignore_cache() ? enrollment_id_ignore_cache_
358 : enrollment_id_);
359 }
360 PostProtoResponse(std::move(callback), reply);
361 }
362
GetCertifiedNvIndex(const::attestation::GetCertifiedNvIndexRequest & request,GetCertifiedNvIndexCallback callback)363 void FakeAttestationClient::GetCertifiedNvIndex(
364 const ::attestation::GetCertifiedNvIndexRequest& request,
365 GetCertifiedNvIndexCallback callback) {
366 NOTIMPLEMENTED();
367 }
368
ConfigureEnrollmentPreparations(bool is_prepared)369 void FakeAttestationClient::ConfigureEnrollmentPreparations(bool is_prepared) {
370 preparations_status_ = ::attestation::STATUS_SUCCESS;
371 is_prepared_ = is_prepared;
372 }
373
ConfigureEnrollmentPreparationsSequence(std::deque<bool> sequence)374 void FakeAttestationClient::ConfigureEnrollmentPreparationsSequence(
375 std::deque<bool> sequence) {
376 preparations_status_ = ::attestation::STATUS_SUCCESS;
377 preparation_sequences_ = std::move(sequence);
378 }
379
ConfigureEnrollmentPreparationsStatus(::attestation::AttestationStatus status)380 void FakeAttestationClient::ConfigureEnrollmentPreparationsStatus(
381 ::attestation::AttestationStatus status) {
382 CHECK_NE(status, ::attestation::STATUS_SUCCESS);
383 preparations_status_ = status;
384 }
385
mutable_status_reply()386 ::attestation::GetStatusReply* FakeAttestationClient::mutable_status_reply() {
387 return &status_reply_;
388 }
389
AllowlistCertificateRequest(const::attestation::GetCertificateRequest & request)390 void FakeAttestationClient::AllowlistCertificateRequest(
391 const ::attestation::GetCertificateRequest& request) {
392 for (const auto& req : allowlisted_requests_) {
393 if (GetCertificateRequestEqual(req, request)) {
394 return;
395 }
396 }
397 allowlisted_requests_.push_back(request);
398 certificate_indices_.push_back(kCertificateNotAssigned);
399 }
400
401 const std::vector<::attestation::DeleteKeysRequest>&
delete_keys_history() const402 FakeAttestationClient::delete_keys_history() const {
403 return delete_keys_history_;
404 }
405
ClearDeleteKeysHistory()406 void FakeAttestationClient::ClearDeleteKeysHistory() {
407 delete_keys_history_.clear();
408 }
409
set_enrollment_id_ignore_cache(const std::string & id)410 void FakeAttestationClient::set_enrollment_id_ignore_cache(
411 const std::string& id) {
412 enrollment_id_ignore_cache_ = id;
413 }
414
set_cached_enrollment_id(const std::string & id)415 void FakeAttestationClient::set_cached_enrollment_id(const std::string& id) {
416 enrollment_id_ = id;
417 }
418
set_enrollment_id_dbus_error_count(int count)419 void FakeAttestationClient::set_enrollment_id_dbus_error_count(int count) {
420 enrollment_id_dbus_error_count_ = count;
421 }
422
GetMutableKeyInfoReply(const std::string & username,const std::string & label)423 ::attestation::GetKeyInfoReply* FakeAttestationClient::GetMutableKeyInfoReply(
424 const std::string& username,
425 const std::string& label) {
426 ::attestation::GetKeyInfoRequest request;
427 request.set_username(username);
428 request.set_key_label(label);
429 // If there doesn't exist the entry yet, just create a new one.
430 return &(key_info_database_[request]);
431 }
432
set_key_info_dbus_error_count(int count)433 void FakeAttestationClient::set_key_info_dbus_error_count(int count) {
434 key_info_dbus_error_count_ = count;
435 }
436
key_info_dbus_error_count() const437 int FakeAttestationClient::key_info_dbus_error_count() const {
438 return key_info_dbus_error_count_;
439 }
440
VerifySimpleChallengeResponse(const std::string & challenge,const::attestation::SignedData & signed_data)441 bool FakeAttestationClient::VerifySimpleChallengeResponse(
442 const std::string& challenge,
443 const ::attestation::SignedData& signed_data) {
444 return signed_data.data() == challenge + kResponseSuffix &&
445 signed_data.signature() == challenge + kSignatureSuffix;
446 }
447
set_sign_simple_challenge_status(::attestation::AttestationStatus status)448 void FakeAttestationClient::set_sign_simple_challenge_status(
449 ::attestation::AttestationStatus status) {
450 sign_simple_challenge_status_ = status;
451 }
452
AllowlistSignSimpleChallengeKey(const std::string & username,const std::string & label)453 void FakeAttestationClient::AllowlistSignSimpleChallengeKey(
454 const std::string& username,
455 const std::string& label) {
456 allowlisted_sign_simple_challenge_keys_.insert({username, label});
457 }
458
set_register_key_status(::attestation::AttestationStatus status)459 void FakeAttestationClient::set_register_key_status(
460 ::attestation::AttestationStatus status) {
461 register_key_status_ = status;
462 }
463
AllowlistRegisterKey(const std::string & username,const std::string & label)464 void FakeAttestationClient::AllowlistRegisterKey(const std::string& username,
465 const std::string& label) {
466 allowlisted_register_keys_.insert({username, label});
467 }
468
set_sign_enterprise_challenge_status(::attestation::AttestationStatus status)469 void FakeAttestationClient::set_sign_enterprise_challenge_status(
470 ::attestation::AttestationStatus status) {
471 sign_enterprise_challenge_status_ = status;
472 }
473
AllowlistSignEnterpriseChallengeKey(const::attestation::SignEnterpriseChallengeRequest & request)474 void FakeAttestationClient::AllowlistSignEnterpriseChallengeKey(
475 const ::attestation::SignEnterpriseChallengeRequest& request) {
476 allowlisted_sign_enterprise_challenge_keys_.insert(request);
477 }
478
GetEnterpriseChallengeFakeSignature(const std::string & challenge,bool include_spkac) const479 std::string FakeAttestationClient::GetEnterpriseChallengeFakeSignature(
480 const std::string& challenge,
481 bool include_spkac) const {
482 std::string challenge_response =
483 challenge + kEnterpriseChallengeResponseSuffix;
484 if (include_spkac) {
485 challenge_response += kIncludeSpkacSuffix;
486 }
487 return challenge_response;
488 }
489
set_sign_enterprise_challenge_delay(const base::TimeDelta & delay)490 void FakeAttestationClient::set_sign_enterprise_challenge_delay(
491 const base::TimeDelta& delay) {
492 sign_enterprise_challenge_delay_ = delay;
493 }
494
set_enroll_request_status(::attestation::AttestationStatus status)495 void FakeAttestationClient::set_enroll_request_status(
496 ::attestation::AttestationStatus status) {
497 enroll_request_status_ = status;
498 }
499
GetFakePcaEnrollRequest() const500 std::string FakeAttestationClient::GetFakePcaEnrollRequest() const {
501 return kFakePcaEnrollRequest;
502 }
503
GetFakePcaEnrollResponse() const504 std::string FakeAttestationClient::GetFakePcaEnrollResponse() const {
505 return kFakePcaEnrollResponse;
506 }
507
AllowlistLegacyCreateCertificateRequest(const std::string & username,const std::string & request_origin,::attestation::CertificateProfile profile,::attestation::KeyType key_type)508 void FakeAttestationClient::AllowlistLegacyCreateCertificateRequest(
509 const std::string& username,
510 const std::string& request_origin,
511 ::attestation::CertificateProfile profile,
512 ::attestation::KeyType key_type) {
513 ::attestation::CreateCertificateRequestRequest request;
514 request.set_username(username);
515 request.set_request_origin(request_origin);
516 request.set_certificate_profile(profile);
517 request.set_key_type(key_type);
518 allowlisted_create_requests_.push_back(request);
519 }
520
set_cert_request_status(::attestation::AttestationStatus status)521 void FakeAttestationClient::set_cert_request_status(
522 ::attestation::AttestationStatus status) {
523 cert_request_status_ = status;
524 }
525
GetFakePcaCertRequest() const526 std::string FakeAttestationClient::GetFakePcaCertRequest() const {
527 return kFakePcaCertRequest;
528 }
529
GetFakePcaCertResponse() const530 std::string FakeAttestationClient::GetFakePcaCertResponse() const {
531 return kFakePcaCertResponse;
532 }
533
GetFakeCertificate() const534 std::string FakeAttestationClient::GetFakeCertificate() const {
535 return kFakeCertificate;
536 }
537
GetTestInterface()538 AttestationClient::TestInterface* FakeAttestationClient::GetTestInterface() {
539 return this;
540 }
541
542 } // namespace chromeos
543