1//
2// Copyright (C) 2015 The Android Open Source Project
3//
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at
7//
8//      http://www.apache.org/licenses/LICENSE-2.0
9//
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15//
16
17// THIS CODE IS GENERATED.
18
19#include "attestation/common/print_common_proto.h"
20
21#include <string>
22
23#include <base/strings/string_number_conversions.h>
24#include <base/strings/stringprintf.h>
25
26namespace attestation {
27
28std::string GetProtoDebugString(KeyType value) {
29  return GetProtoDebugStringWithIndent(value, 0);
30}
31
32std::string GetProtoDebugStringWithIndent(KeyType value, int indent_size) {
33  if (value == KEY_TYPE_RSA) {
34    return "KEY_TYPE_RSA";
35  }
36  if (value == KEY_TYPE_ECC) {
37    return "KEY_TYPE_ECC";
38  }
39  return "<unknown>";
40}
41
42std::string GetProtoDebugString(KeyUsage value) {
43  return GetProtoDebugStringWithIndent(value, 0);
44}
45
46std::string GetProtoDebugStringWithIndent(KeyUsage value, int indent_size) {
47  if (value == KEY_USAGE_SIGN) {
48    return "KEY_USAGE_SIGN";
49  }
50  if (value == KEY_USAGE_DECRYPT) {
51    return "KEY_USAGE_DECRYPT";
52  }
53  return "<unknown>";
54}
55
56std::string GetProtoDebugString(CertificateProfile value) {
57  return GetProtoDebugStringWithIndent(value, 0);
58}
59
60std::string GetProtoDebugStringWithIndent(CertificateProfile value,
61                                          int indent_size) {
62  if (value == ENTERPRISE_MACHINE_CERTIFICATE) {
63    return "ENTERPRISE_MACHINE_CERTIFICATE";
64  }
65  if (value == ENTERPRISE_USER_CERTIFICATE) {
66    return "ENTERPRISE_USER_CERTIFICATE";
67  }
68  if (value == CONTENT_PROTECTION_CERTIFICATE) {
69    return "CONTENT_PROTECTION_CERTIFICATE";
70  }
71  if (value == CONTENT_PROTECTION_CERTIFICATE_WITH_STABLE_ID) {
72    return "CONTENT_PROTECTION_CERTIFICATE_WITH_STABLE_ID";
73  }
74  if (value == CAST_CERTIFICATE) {
75    return "CAST_CERTIFICATE";
76  }
77  if (value == GFSC_CERTIFICATE) {
78    return "GFSC_CERTIFICATE";
79  }
80  return "<unknown>";
81}
82
83std::string GetProtoDebugString(const Quote& value) {
84  return GetProtoDebugStringWithIndent(value, 0);
85}
86
87std::string GetProtoDebugStringWithIndent(const Quote& value, int indent_size) {
88  std::string indent(indent_size, ' ');
89  std::string output =
90      base::StringPrintf("[%s] {\n", value.GetTypeName().c_str());
91
92  if (value.has_quote()) {
93    output += indent + "  quote: ";
94    base::StringAppendF(
95        &output, "%s",
96        base::HexEncode(value.quote().data(), value.quote().size()).c_str());
97    output += "\n";
98  }
99  if (value.has_quoted_data()) {
100    output += indent + "  quoted_data: ";
101    base::StringAppendF(&output, "%s",
102                        base::HexEncode(value.quoted_data().data(),
103                                        value.quoted_data().size()).c_str());
104    output += "\n";
105  }
106  if (value.has_quoted_pcr_value()) {
107    output += indent + "  quoted_pcr_value: ";
108    base::StringAppendF(
109        &output, "%s",
110        base::HexEncode(value.quoted_pcr_value().data(),
111                        value.quoted_pcr_value().size()).c_str());
112    output += "\n";
113  }
114  if (value.has_pcr_source_hint()) {
115    output += indent + "  pcr_source_hint: ";
116    base::StringAppendF(
117        &output, "%s", base::HexEncode(value.pcr_source_hint().data(),
118                                       value.pcr_source_hint().size()).c_str());
119    output += "\n";
120  }
121  output += indent + "}\n";
122  return output;
123}
124
125std::string GetProtoDebugString(const EncryptedData& value) {
126  return GetProtoDebugStringWithIndent(value, 0);
127}
128
129std::string GetProtoDebugStringWithIndent(const EncryptedData& value,
130                                          int indent_size) {
131  std::string indent(indent_size, ' ');
132  std::string output =
133      base::StringPrintf("[%s] {\n", value.GetTypeName().c_str());
134
135  if (value.has_wrapped_key()) {
136    output += indent + "  wrapped_key: ";
137    base::StringAppendF(&output, "%s",
138                        base::HexEncode(value.wrapped_key().data(),
139                                        value.wrapped_key().size()).c_str());
140    output += "\n";
141  }
142  if (value.has_iv()) {
143    output += indent + "  iv: ";
144    base::StringAppendF(
145        &output, "%s",
146        base::HexEncode(value.iv().data(), value.iv().size()).c_str());
147    output += "\n";
148  }
149  if (value.has_mac()) {
150    output += indent + "  mac: ";
151    base::StringAppendF(
152        &output, "%s",
153        base::HexEncode(value.mac().data(), value.mac().size()).c_str());
154    output += "\n";
155  }
156  if (value.has_encrypted_data()) {
157    output += indent + "  encrypted_data: ";
158    base::StringAppendF(&output, "%s",
159                        base::HexEncode(value.encrypted_data().data(),
160                                        value.encrypted_data().size()).c_str());
161    output += "\n";
162  }
163  if (value.has_wrapping_key_id()) {
164    output += indent + "  wrapping_key_id: ";
165    base::StringAppendF(
166        &output, "%s", base::HexEncode(value.wrapping_key_id().data(),
167                                       value.wrapping_key_id().size()).c_str());
168    output += "\n";
169  }
170  output += indent + "}\n";
171  return output;
172}
173
174std::string GetProtoDebugString(const SignedData& value) {
175  return GetProtoDebugStringWithIndent(value, 0);
176}
177
178std::string GetProtoDebugStringWithIndent(const SignedData& value,
179                                          int indent_size) {
180  std::string indent(indent_size, ' ');
181  std::string output =
182      base::StringPrintf("[%s] {\n", value.GetTypeName().c_str());
183
184  if (value.has_data()) {
185    output += indent + "  data: ";
186    base::StringAppendF(
187        &output, "%s",
188        base::HexEncode(value.data().data(), value.data().size()).c_str());
189    output += "\n";
190  }
191  if (value.has_signature()) {
192    output += indent + "  signature: ";
193    base::StringAppendF(&output, "%s",
194                        base::HexEncode(value.signature().data(),
195                                        value.signature().size()).c_str());
196    output += "\n";
197  }
198  output += indent + "}\n";
199  return output;
200}
201
202std::string GetProtoDebugString(const EncryptedIdentityCredential& value) {
203  return GetProtoDebugStringWithIndent(value, 0);
204}
205
206std::string GetProtoDebugStringWithIndent(
207    const EncryptedIdentityCredential& value,
208    int indent_size) {
209  std::string indent(indent_size, ' ');
210  std::string output =
211      base::StringPrintf("[%s] {\n", value.GetTypeName().c_str());
212
213  if (value.has_asym_ca_contents()) {
214    output += indent + "  asym_ca_contents: ";
215    base::StringAppendF(
216        &output, "%s",
217        base::HexEncode(value.asym_ca_contents().data(),
218                        value.asym_ca_contents().size()).c_str());
219    output += "\n";
220  }
221  if (value.has_sym_ca_attestation()) {
222    output += indent + "  sym_ca_attestation: ";
223    base::StringAppendF(
224        &output, "%s",
225        base::HexEncode(value.sym_ca_attestation().data(),
226                        value.sym_ca_attestation().size()).c_str());
227    output += "\n";
228  }
229  output += indent + "}\n";
230  return output;
231}
232
233}  // namespace attestation
234