From 32acc95f8f9226599210f53d57505589eccd10d4 Mon Sep 17 00:00:00 2001 From: Onkar Shinde Date: Tue, 28 Nov 2023 12:14:13 +0000 Subject: [PATCH] Updated certificate_provisioning_fuzzer Implemented google c++ code style changes for certificate_provisioning_fuzzer exec/s: 97 Test: ./certificate_provisioning_fuzzer Bug: 312374669 Change-Id: I5501a2c2237ea5f2d2931465b4391c29c4500ce3 --- fuzzer/certificate_provisioning_fuzzer.cpp | 148 ++++++++++----------- 1 file changed, 74 insertions(+), 74 deletions(-) diff --git a/fuzzer/certificate_provisioning_fuzzer.cpp b/fuzzer/certificate_provisioning_fuzzer.cpp index 800752b4..5ab9ca5b 100644 --- a/fuzzer/certificate_provisioning_fuzzer.cpp +++ b/fuzzer/certificate_provisioning_fuzzer.cpp @@ -44,147 +44,147 @@ static constexpr uint8_t kProvisioningType[] = { SignedProvisioningMessage_ProvisioningType_INTEL_SIGMA_210}; class CertificateProvisioningFuzzer { -public: + public: CertificateProvisioningFuzzer(const uint8_t *data, size_t size) - : mFdp(data, size){}; - void process(); + : fdp_(data, size){}; + void Process(); -private: - FuzzedDataProvider mFdp; + private: + FuzzedDataProvider fdp_; }; -void createResponseMessage(std::string &responseMessage, - FuzzedDataProvider &mFdp) { - if (mFdp.ConsumeBool()) { - DrmCertificate drmCertificate; +void CreateResponseMessage(std::string &response_message, + FuzzedDataProvider &fdp) { + if (fdp.ConsumeBool()) { + DrmCertificate drm_certificate; DrmCertificate_Algorithm algorithm = - (DrmCertificate_Algorithm)mFdp.ConsumeIntegralInRange( + (DrmCertificate_Algorithm)fdp.ConsumeIntegralInRange( DrmCertificate_Algorithm:: DrmCertificate_Algorithm_UNKNOWN_ALGORITHM, DrmCertificate_Algorithm::DrmCertificate_Algorithm_ECC_SECP521R1); - drmCertificate.set_algorithm(algorithm); + drm_certificate.set_algorithm(algorithm); - std::string setDrm; - if (mFdp.ConsumeBool()) { - drmCertificate.SerializeToString(&setDrm); + std::string set_drm; + if (fdp.ConsumeBool()) { + drm_certificate.SerializeToString(&set_drm); } else { - setDrm = mFdp.ConsumeRandomLengthString(kMaxByte); + set_drm = fdp.ConsumeRandomLengthString(kMaxByte); } - SignedDrmCertificate signedDrmCertificate; - signedDrmCertificate.set_drm_certificate(setDrm); + SignedDrmCertificate signed_drm_certificate; + signed_drm_certificate.set_drm_certificate(set_drm); - std::string setDevice; - if (mFdp.ConsumeBool()) { - signedDrmCertificate.SerializeToString(&setDevice); + std::string set_device; + if (fdp.ConsumeBool()) { + signed_drm_certificate.SerializeToString(&set_device); } else { - setDevice = mFdp.ConsumeRandomLengthString(kMaxByte); + set_device = fdp.ConsumeRandomLengthString(kMaxByte); } - ProvisioningResponse provisioningResponse; + ProvisioningResponse provisioning_response; ProvisioningResponse_ProvisioningStatus status = - (ProvisioningResponse_ProvisioningStatus)mFdp.ConsumeIntegralInRange< + (ProvisioningResponse_ProvisioningStatus)fdp.ConsumeIntegralInRange< int32_t>( ProvisioningResponse_ProvisioningStatus:: ProvisioningResponse_ProvisioningStatus_NO_ERROR, ProvisioningResponse_ProvisioningStatus:: ProvisioningResponse_ProvisioningStatus_REVOKED_DEVICE_SERIES); - provisioningResponse.set_status(status); + provisioning_response.set_status(status); - if (mFdp.ConsumeBool()) { - provisioningResponse.set_device_certificate(setDevice); + if (fdp.ConsumeBool()) { + provisioning_response.set_device_certificate(set_device); } - std::string setMessage; - if (mFdp.ConsumeBool()) { - provisioningResponse.SerializeToString(&setMessage); + std::string set_message; + if (fdp.ConsumeBool()) { + provisioning_response.SerializeToString(&set_message); } else { - setMessage = mFdp.ConsumeRandomLengthString(kMaxByte); + set_message = fdp.ConsumeRandomLengthString(kMaxByte); } - SignedProvisioningMessage signedProvisioningMessage; - if (mFdp.ConsumeBool()) { - signedProvisioningMessage.set_message(setMessage); + SignedProvisioningMessage signed_provisioning_message; + if (fdp.ConsumeBool()) { + signed_provisioning_message.set_message(set_message); } else { - signedProvisioningMessage.set_message( - mFdp.ConsumeRandomLengthString(kMaxByte)); + signed_provisioning_message.set_message( + fdp.ConsumeRandomLengthString(kMaxByte)); } - signedProvisioningMessage.set_signature( - mFdp.ConsumeRandomLengthString(kMaxByte)); - if (mFdp.ConsumeBool()) { - signedProvisioningMessage.set_provisioning_type( - (SignedProvisioningMessage_ProvisioningType)mFdp.PickValueInArray( + signed_provisioning_message.set_signature( + fdp.ConsumeRandomLengthString(kMaxByte)); + if (fdp.ConsumeBool()) { + signed_provisioning_message.set_provisioning_type( + (SignedProvisioningMessage_ProvisioningType)fdp.PickValueInArray( kProvisioningType)); } else { - signedProvisioningMessage.set_provisioning_type( + signed_provisioning_message.set_provisioning_type( (SignedProvisioningMessage_ProvisioningType) - mFdp.ConsumeIntegral()); + fdp.ConsumeIntegral()); } - signedProvisioningMessage.set_oemcrypto_core_message( - mFdp.ConsumeRandomLengthString(kMaxByte)); - if (mFdp.ConsumeBool()) { - signedProvisioningMessage.SerializeToString(&responseMessage); + signed_provisioning_message.set_oemcrypto_core_message( + fdp.ConsumeRandomLengthString(kMaxByte)); + if (fdp.ConsumeBool()) { + signed_provisioning_message.SerializeToString(&response_message); } else { - responseMessage = mFdp.ConsumeRandomLengthString(kMaxByte); + response_message = fdp.ConsumeRandomLengthString(kMaxByte); } } - responseMessage = - (mFdp.ConsumeBool() ? "\"signedResponse\": \"" : "") + - (mFdp.ConsumeBool() ? Base64SafeEncode(responseMessage) : "") + - (mFdp.ConsumeBool() ? "\"" : ""); + response_message = + (fdp.ConsumeBool() ? "\"signedResponse\": \"" : "") + + (fdp.ConsumeBool() ? Base64SafeEncode(response_message) : "") + + (fdp.ConsumeBool() ? "\"" : ""); } -void CertificateProvisioningFuzzer::process() { - FileSystem fileSystem; - metrics::CryptoMetrics cryptoMetrics; - CertificateProvisioning certificateProvisioning(&cryptoMetrics); +void CertificateProvisioningFuzzer::Process() { + FileSystem file_system; + metrics::CryptoMetrics crypto_metrics; + CertificateProvisioning certificateProvisioning(&crypto_metrics); certificateProvisioning.Init( - mFdp.ConsumeRandomLengthString(kMaxByte) /* service_certificate */ + fdp_.ConsumeRandomLengthString(kMaxByte) /* service_certificate */ ); - while (mFdp.remaining_bytes()) { + while (fdp_.remaining_bytes()) { auto invokeCertificateProvisioningAPI = - mFdp.PickValueInArray>( + fdp_.PickValueInArray>( {[&]() { CdmProvisioningRequest request; - std::string defaultUrl; + std::string default_url; certificateProvisioning.GetProvisioningRequest( - &fileSystem, - (RequestedSecurityLevel)mFdp.ConsumeBool() + &file_system, + (RequestedSecurityLevel)fdp_.ConsumeBool() ? kLevelDefault : kLevel3, /* requested_security_level */ - (CdmCertificateType)mFdp.ConsumeIntegralInRange( + (CdmCertificateType)fdp_.ConsumeIntegralInRange( kMinCdmCertificateType, kMaxCdmCertificateType), /* cert_type */ - mFdp.ConsumeRandomLengthString( + fdp_.ConsumeRandomLengthString( kMaxByte), /* cert_authority */ - mFdp.ConsumeRandomLengthString(kMaxByte), /* origin */ - mFdp.ConsumeRandomLengthString(kMaxByte), /* spoid */ - mFdp.ConsumeBool() ? &request : nullptr, &defaultUrl); + fdp_.ConsumeRandomLengthString(kMaxByte), /* origin */ + fdp_.ConsumeRandomLengthString(kMaxByte), /* spoid */ + fdp_.ConsumeBool() ? &request : nullptr, &default_url); }, [&]() { - CdmProvisioningResponse responseMessage; - createResponseMessage(responseMessage, mFdp); + CdmProvisioningResponse response_message; + CreateResponseMessage(response_message, fdp_); std::string cert; - std::string wrappedKey; + std::string wrapped_key; certificateProvisioning.HandleProvisioningResponse( - &fileSystem, responseMessage, &cert, &wrappedKey); + &file_system, response_message, &cert, &wrapped_key); }, [&]() { - std::string defaultUrl; + std::string default_url; CertificateProvisioning::GetProvisioningServerUrl( - mFdp.ConsumeBool() ? &defaultUrl : nullptr); + fdp_.ConsumeBool() ? &default_url : nullptr); }}); invokeCertificateProvisioningAPI(); @@ -192,7 +192,7 @@ void CertificateProvisioningFuzzer::process() { } extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { - CertificateProvisioningFuzzer certificateProvisioningFuzzer(data, size); - certificateProvisioningFuzzer.process(); + CertificateProvisioningFuzzer certificate_provisioning_fuzzer(data, size); + certificate_provisioning_fuzzer.Process(); return 0; }