238 lines
7.4 KiB
C++
238 lines
7.4 KiB
C++
//
|
|
// Copyright (C) 2015 The Android Open Source Project
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
|
|
// THIS CODE IS GENERATED.
|
|
|
|
#include "attestation/common/print_common_proto.h"
|
|
|
|
#include <string>
|
|
|
|
#include <base/strings/string_number_conversions.h>
|
|
#include <base/strings/stringprintf.h>
|
|
|
|
namespace attestation {
|
|
|
|
std::string GetProtoDebugString(KeyType value) {
|
|
return GetProtoDebugStringWithIndent(value, 0);
|
|
}
|
|
|
|
std::string GetProtoDebugStringWithIndent(KeyType value, int indent_size) {
|
|
if (value == KEY_TYPE_RSA) {
|
|
return "KEY_TYPE_RSA";
|
|
}
|
|
if (value == KEY_TYPE_ECC) {
|
|
return "KEY_TYPE_ECC";
|
|
}
|
|
return "<unknown>";
|
|
}
|
|
|
|
std::string GetProtoDebugString(KeyUsage value) {
|
|
return GetProtoDebugStringWithIndent(value, 0);
|
|
}
|
|
|
|
std::string GetProtoDebugStringWithIndent(KeyUsage value, int indent_size) {
|
|
if (value == KEY_USAGE_SIGN) {
|
|
return "KEY_USAGE_SIGN";
|
|
}
|
|
if (value == KEY_USAGE_DECRYPT) {
|
|
return "KEY_USAGE_DECRYPT";
|
|
}
|
|
return "<unknown>";
|
|
}
|
|
|
|
std::string GetProtoDebugString(CertificateProfile value) {
|
|
return GetProtoDebugStringWithIndent(value, 0);
|
|
}
|
|
|
|
std::string GetProtoDebugStringWithIndent(CertificateProfile value,
|
|
int indent_size) {
|
|
if (value == ENTERPRISE_MACHINE_CERTIFICATE) {
|
|
return "ENTERPRISE_MACHINE_CERTIFICATE";
|
|
}
|
|
if (value == ENTERPRISE_USER_CERTIFICATE) {
|
|
return "ENTERPRISE_USER_CERTIFICATE";
|
|
}
|
|
if (value == CONTENT_PROTECTION_CERTIFICATE) {
|
|
return "CONTENT_PROTECTION_CERTIFICATE";
|
|
}
|
|
if (value == CONTENT_PROTECTION_CERTIFICATE_WITH_STABLE_ID) {
|
|
return "CONTENT_PROTECTION_CERTIFICATE_WITH_STABLE_ID";
|
|
}
|
|
if (value == CAST_CERTIFICATE) {
|
|
return "CAST_CERTIFICATE";
|
|
}
|
|
if (value == GFSC_CERTIFICATE) {
|
|
return "GFSC_CERTIFICATE";
|
|
}
|
|
return "<unknown>";
|
|
}
|
|
|
|
std::string GetProtoDebugString(const Quote& value) {
|
|
return GetProtoDebugStringWithIndent(value, 0);
|
|
}
|
|
|
|
std::string GetProtoDebugStringWithIndent(const Quote& value, int indent_size) {
|
|
std::string indent(indent_size, ' ');
|
|
std::string output =
|
|
base::StringPrintf("[%s] {\n", value.GetTypeName().c_str());
|
|
|
|
if (value.has_quote()) {
|
|
output += indent + " quote: ";
|
|
base::StringAppendF(
|
|
&output, "%s",
|
|
base::HexEncode(value.quote().data(), value.quote().size()).c_str());
|
|
output += "\n";
|
|
}
|
|
if (value.has_quoted_data()) {
|
|
output += indent + " quoted_data: ";
|
|
base::StringAppendF(
|
|
&output, "%s",
|
|
base::HexEncode(value.quoted_data().data(), value.quoted_data().size())
|
|
.c_str());
|
|
output += "\n";
|
|
}
|
|
if (value.has_quoted_pcr_value()) {
|
|
output += indent + " quoted_pcr_value: ";
|
|
base::StringAppendF(&output, "%s",
|
|
base::HexEncode(value.quoted_pcr_value().data(),
|
|
value.quoted_pcr_value().size())
|
|
.c_str());
|
|
output += "\n";
|
|
}
|
|
if (value.has_pcr_source_hint()) {
|
|
output += indent + " pcr_source_hint: ";
|
|
base::StringAppendF(&output, "%s",
|
|
base::HexEncode(value.pcr_source_hint().data(),
|
|
value.pcr_source_hint().size())
|
|
.c_str());
|
|
output += "\n";
|
|
}
|
|
output += indent + "}\n";
|
|
return output;
|
|
}
|
|
|
|
std::string GetProtoDebugString(const EncryptedData& value) {
|
|
return GetProtoDebugStringWithIndent(value, 0);
|
|
}
|
|
|
|
std::string GetProtoDebugStringWithIndent(const EncryptedData& value,
|
|
int indent_size) {
|
|
std::string indent(indent_size, ' ');
|
|
std::string output =
|
|
base::StringPrintf("[%s] {\n", value.GetTypeName().c_str());
|
|
|
|
if (value.has_wrapped_key()) {
|
|
output += indent + " wrapped_key: ";
|
|
base::StringAppendF(
|
|
&output, "%s",
|
|
base::HexEncode(value.wrapped_key().data(), value.wrapped_key().size())
|
|
.c_str());
|
|
output += "\n";
|
|
}
|
|
if (value.has_iv()) {
|
|
output += indent + " iv: ";
|
|
base::StringAppendF(
|
|
&output, "%s",
|
|
base::HexEncode(value.iv().data(), value.iv().size()).c_str());
|
|
output += "\n";
|
|
}
|
|
if (value.has_mac()) {
|
|
output += indent + " mac: ";
|
|
base::StringAppendF(
|
|
&output, "%s",
|
|
base::HexEncode(value.mac().data(), value.mac().size()).c_str());
|
|
output += "\n";
|
|
}
|
|
if (value.has_encrypted_data()) {
|
|
output += indent + " encrypted_data: ";
|
|
base::StringAppendF(&output, "%s",
|
|
base::HexEncode(value.encrypted_data().data(),
|
|
value.encrypted_data().size())
|
|
.c_str());
|
|
output += "\n";
|
|
}
|
|
if (value.has_wrapping_key_id()) {
|
|
output += indent + " wrapping_key_id: ";
|
|
base::StringAppendF(&output, "%s",
|
|
base::HexEncode(value.wrapping_key_id().data(),
|
|
value.wrapping_key_id().size())
|
|
.c_str());
|
|
output += "\n";
|
|
}
|
|
output += indent + "}\n";
|
|
return output;
|
|
}
|
|
|
|
std::string GetProtoDebugString(const SignedData& value) {
|
|
return GetProtoDebugStringWithIndent(value, 0);
|
|
}
|
|
|
|
std::string GetProtoDebugStringWithIndent(const SignedData& value,
|
|
int indent_size) {
|
|
std::string indent(indent_size, ' ');
|
|
std::string output =
|
|
base::StringPrintf("[%s] {\n", value.GetTypeName().c_str());
|
|
|
|
if (value.has_data()) {
|
|
output += indent + " data: ";
|
|
base::StringAppendF(
|
|
&output, "%s",
|
|
base::HexEncode(value.data().data(), value.data().size()).c_str());
|
|
output += "\n";
|
|
}
|
|
if (value.has_signature()) {
|
|
output += indent + " signature: ";
|
|
base::StringAppendF(&output, "%s", base::HexEncode(value.signature().data(),
|
|
value.signature().size())
|
|
.c_str());
|
|
output += "\n";
|
|
}
|
|
output += indent + "}\n";
|
|
return output;
|
|
}
|
|
|
|
std::string GetProtoDebugString(const EncryptedIdentityCredential& value) {
|
|
return GetProtoDebugStringWithIndent(value, 0);
|
|
}
|
|
|
|
std::string GetProtoDebugStringWithIndent(
|
|
const EncryptedIdentityCredential& value,
|
|
int indent_size) {
|
|
std::string indent(indent_size, ' ');
|
|
std::string output =
|
|
base::StringPrintf("[%s] {\n", value.GetTypeName().c_str());
|
|
|
|
if (value.has_asym_ca_contents()) {
|
|
output += indent + " asym_ca_contents: ";
|
|
base::StringAppendF(&output, "%s",
|
|
base::HexEncode(value.asym_ca_contents().data(),
|
|
value.asym_ca_contents().size())
|
|
.c_str());
|
|
output += "\n";
|
|
}
|
|
if (value.has_sym_ca_attestation()) {
|
|
output += indent + " sym_ca_attestation: ";
|
|
base::StringAppendF(&output, "%s",
|
|
base::HexEncode(value.sym_ca_attestation().data(),
|
|
value.sym_ca_attestation().size())
|
|
.c_str());
|
|
output += "\n";
|
|
}
|
|
output += indent + "}\n";
|
|
return output;
|
|
}
|
|
|
|
} // namespace attestation
|