1 /*
2  * Copyright (C) 2020 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 #pragma once
18 
19 #include <keymaster/android_keymaster_messages.h>
20 #include <keymaster/serializable.h>
21 
22 namespace keymaster {
23 enum class SerializableType : uint32_t {
24     SUPPORTED_IMPORT_FORMATS_REQUEST,
25     SUPPORTED_EXPORT_FORMATS_REQUEST,
26     SUPPORTED_BLOCK_MODES_REQUEST,
27     SUPPORTED_PADDING_MODES_REQUEST,
28     SUPPORTED_DIGESTS_REQUEST,
29     SUPPORTED_ALGORITHMS_RESPONSE,
30     SUPPORTED_BLOCK_MODES_RESPONSE,
31     SUPPORTED_PADDING_MODES_RESPONSE,
32     SUPPORTED_DIGESTS_RESPONSE,
33     SUPPORTED_IMPORT_FORMATS_RESPONSE,
34     SUPPORTED_EXPORT_FORMATS_RESPONSE,
35     GENERATE_KEY_REQUEST,
36     GENERATE_KEY_RESPONSE,
37     GET_KEY_CHARACTERISTICS_REQUEST,
38     GET_KEY_CHARACTERISTICS_RESPONSE,
39     BEGIN_OPERATION_REQUEST,
40     BEGIN_OPERATION_RESPONSE,
41     UPDATE_OPERATION_REQUEST,
42     UPDATE_OPERATION_RESPONSE,
43     FINISH_OPERATION_REQUEST,
44     FINISH_OPERATION_RESPONSE,
45     ABORT_OPERATION_REQUEST,
46     ABORT_OPERATION_RESPONSE,
47     ADD_ENTROPY_REQUEST,
48     ADD_ENTROPY_RESPONSE,
49     IMPORT_KEY_REQUEST,
50     IMPORT_KEY_RESPONSE,
51     EXPORT_KEY_REQUEST,
52     EXPORT_KEY_RESPONSE,
53     DELETE_KEY_REQUEST,
54     DELETE_KEY_RESPONSE,
55     DELETE_ALL_KEYS_REQUEST,
56     DELETE_ALL_KEYS_RESPONSE,
57     GET_VERSION_REQUEST,
58     GET_VERSION_RESPONSE,
59     GET_VERSION2_REQUEST,
60     GET_VERSION2_RESPONSE,
61     ATTEST_KEY_REQUEST,
62     ATTEST_KEY_RESPONSE,
63     UPGRADE_KEY_REQUEST,
64     UPGRADE_KEY_RESPONSE,
65     CONFIGURE_REQUEST,
66     CONFIGURE_RESPONSE,
67     HMAC_SHARING_PARAMETERS,
68     HMAC_SHARING_PARAMETERS_ARRAY,
69     GET_HMAC_SHARING_PARAMETERS_RESPONSE,
70     COMPUTE_SHARED_HMAC_REQUEST,
71     COMPUTE_SHARED_HMAC_RESPONSE,
72     IMPORT_WRAPPED_KEY_REQUEST,
73     IMPORT_WRAPPED_KEY_RESPONSE,
74     HARDWARE_AUTH_TOKEN,
75     VERIFICATION_TOKEN,
76     VERIFY_AUTHORIZATION_REQUEST,
77     VERIFY_AUTHORIZATION_RESPONSE,
78     DEVICE_LOCKED_REQUEST,
79     BUFFER,
80     // Libfuzzer needs this to always be the last value
81     kMaxValue = BUFFER
82 };
83 
getSerializable(SerializableType serType)84 std::unique_ptr<Serializable> getSerializable(SerializableType serType) {
85     switch (serType) {
86     case SerializableType::SUPPORTED_IMPORT_FORMATS_REQUEST:
87         return std::make_unique<SupportedImportFormatsRequest>(kMaxMessageVersion);
88     case SerializableType::SUPPORTED_EXPORT_FORMATS_REQUEST:
89         return std::make_unique<SupportedExportFormatsRequest>(kMaxMessageVersion);
90     case SerializableType::SUPPORTED_BLOCK_MODES_REQUEST:
91         return std::make_unique<SupportedBlockModesRequest>(kMaxMessageVersion);
92     case SerializableType::SUPPORTED_PADDING_MODES_REQUEST:
93         return std::make_unique<SupportedPaddingModesRequest>(kMaxMessageVersion);
94     case SerializableType::SUPPORTED_DIGESTS_REQUEST:
95         return std::make_unique<SupportedDigestsRequest>(kMaxMessageVersion);
96     case SerializableType::SUPPORTED_ALGORITHMS_RESPONSE:
97         return std::make_unique<SupportedAlgorithmsResponse>(kMaxMessageVersion);
98     case SerializableType::SUPPORTED_BLOCK_MODES_RESPONSE:
99         return std::make_unique<SupportedBlockModesResponse>(kMaxMessageVersion);
100     case SerializableType::SUPPORTED_PADDING_MODES_RESPONSE:
101         return std::make_unique<SupportedPaddingModesResponse>(kMaxMessageVersion);
102     case SerializableType::SUPPORTED_DIGESTS_RESPONSE:
103         return std::make_unique<SupportedDigestsResponse>(kMaxMessageVersion);
104     case SerializableType::SUPPORTED_IMPORT_FORMATS_RESPONSE:
105         return std::make_unique<SupportedImportFormatsResponse>(kMaxMessageVersion);
106     case SerializableType::SUPPORTED_EXPORT_FORMATS_RESPONSE:
107         return std::make_unique<SupportedExportFormatsResponse>(kMaxMessageVersion);
108     case SerializableType::GENERATE_KEY_REQUEST:
109         return std::make_unique<GenerateKeyRequest>(kMaxMessageVersion);
110     case SerializableType::GENERATE_KEY_RESPONSE:
111         return std::make_unique<GenerateKeyResponse>(kMaxMessageVersion);
112     case SerializableType::GET_KEY_CHARACTERISTICS_REQUEST:
113         return std::make_unique<GetKeyCharacteristicsRequest>(kMaxMessageVersion);
114     case SerializableType::GET_KEY_CHARACTERISTICS_RESPONSE:
115         return std::make_unique<GetKeyCharacteristicsResponse>(kMaxMessageVersion);
116     case SerializableType::BEGIN_OPERATION_REQUEST:
117         return std::make_unique<BeginOperationRequest>(kMaxMessageVersion);
118     case SerializableType::BEGIN_OPERATION_RESPONSE:
119         return std::make_unique<BeginOperationResponse>(kMaxMessageVersion);
120     case SerializableType::UPDATE_OPERATION_REQUEST:
121         return std::make_unique<UpdateOperationRequest>(kMaxMessageVersion);
122     case SerializableType::UPDATE_OPERATION_RESPONSE:
123         return std::make_unique<UpdateOperationResponse>(kMaxMessageVersion);
124     case SerializableType::FINISH_OPERATION_REQUEST:
125         return std::make_unique<FinishOperationRequest>(kMaxMessageVersion);
126     case SerializableType::FINISH_OPERATION_RESPONSE:
127         return std::make_unique<FinishOperationResponse>(kMaxMessageVersion);
128     case SerializableType::ABORT_OPERATION_REQUEST:
129         return std::make_unique<AbortOperationRequest>(kMaxMessageVersion);
130     case SerializableType::ABORT_OPERATION_RESPONSE:
131         return std::make_unique<AbortOperationResponse>(kMaxMessageVersion);
132     case SerializableType::ADD_ENTROPY_REQUEST:
133         return std::make_unique<AddEntropyRequest>(kMaxMessageVersion);
134     case SerializableType::ADD_ENTROPY_RESPONSE:
135         return std::make_unique<AddEntropyResponse>(kMaxMessageVersion);
136     case SerializableType::IMPORT_KEY_REQUEST:
137         return std::make_unique<ImportKeyRequest>(kMaxMessageVersion);
138     case SerializableType::IMPORT_KEY_RESPONSE:
139         return std::make_unique<ImportKeyResponse>(kMaxMessageVersion);
140     case SerializableType::EXPORT_KEY_REQUEST:
141         return std::make_unique<ExportKeyRequest>(kMaxMessageVersion);
142     case SerializableType::EXPORT_KEY_RESPONSE:
143         return std::make_unique<ExportKeyResponse>(kMaxMessageVersion);
144     case SerializableType::DELETE_KEY_REQUEST:
145         return std::make_unique<DeleteKeyRequest>(kMaxMessageVersion);
146     case SerializableType::DELETE_KEY_RESPONSE:
147         return std::make_unique<DeleteKeyResponse>(kMaxMessageVersion);
148     case SerializableType::DELETE_ALL_KEYS_REQUEST:
149         return std::make_unique<DeleteAllKeysRequest>(kMaxMessageVersion);
150     case SerializableType::DELETE_ALL_KEYS_RESPONSE:
151         return std::make_unique<DeleteAllKeysResponse>(kMaxMessageVersion);
152     case SerializableType::GET_VERSION_REQUEST:
153         // Not versionable
154         return std::make_unique<GetVersionRequest>();
155     case SerializableType::GET_VERSION_RESPONSE:
156         // Not versionable
157         return std::make_unique<GetVersionResponse>();
158     case SerializableType::GET_VERSION2_REQUEST:
159         // Not versionable
160         return std::make_unique<GetVersion2Request>();
161     case SerializableType::GET_VERSION2_RESPONSE:
162         // Not versionable
163         return std::make_unique<GetVersion2Response>();
164     case SerializableType::ATTEST_KEY_REQUEST:
165         return std::make_unique<AttestKeyRequest>(kMaxMessageVersion);
166     case SerializableType::ATTEST_KEY_RESPONSE:
167         return std::make_unique<AttestKeyResponse>(kMaxMessageVersion);
168     case SerializableType::UPGRADE_KEY_REQUEST:
169         return std::make_unique<UpgradeKeyRequest>(kMaxMessageVersion);
170     case SerializableType::UPGRADE_KEY_RESPONSE:
171         return std::make_unique<UpgradeKeyResponse>(kMaxMessageVersion);
172     case SerializableType::CONFIGURE_REQUEST:
173         return std::make_unique<ConfigureRequest>(kMaxMessageVersion);
174     case SerializableType::CONFIGURE_RESPONSE:
175         return std::make_unique<ConfigureResponse>(kMaxMessageVersion);
176     case SerializableType::DEVICE_LOCKED_REQUEST:
177         return std::make_unique<DeviceLockedRequest>(kMaxMessageVersion);
178     case SerializableType::GET_HMAC_SHARING_PARAMETERS_RESPONSE:
179         return std::make_unique<GetHmacSharingParametersResponse>(kMaxMessageVersion);
180     case SerializableType::COMPUTE_SHARED_HMAC_REQUEST:
181         return std::make_unique<ComputeSharedHmacRequest>(kMaxMessageVersion);
182     case SerializableType::COMPUTE_SHARED_HMAC_RESPONSE:
183         return std::make_unique<ComputeSharedHmacResponse>(kMaxMessageVersion);
184     case SerializableType::IMPORT_WRAPPED_KEY_REQUEST:
185         return std::make_unique<ImportWrappedKeyRequest>(kMaxMessageVersion);
186     case SerializableType::IMPORT_WRAPPED_KEY_RESPONSE:
187         return std::make_unique<ImportWrappedKeyResponse>(kMaxMessageVersion);
188     case SerializableType::VERIFY_AUTHORIZATION_REQUEST:
189         return std::make_unique<VerifyAuthorizationRequest>(kMaxMessageVersion);
190     case SerializableType::VERIFY_AUTHORIZATION_RESPONSE:
191         return std::make_unique<VerifyAuthorizationResponse>(kMaxMessageVersion);
192 
193     // These are not messages, and expect an empty constructor.
194     case SerializableType::HMAC_SHARING_PARAMETERS:
195         return std::make_unique<HmacSharingParameters>();
196     case SerializableType::HMAC_SHARING_PARAMETERS_ARRAY:
197         return std::make_unique<HmacSharingParametersArray>();
198     case SerializableType::HARDWARE_AUTH_TOKEN:
199         return std::make_unique<HardwareAuthToken>();
200     case SerializableType::VERIFICATION_TOKEN:
201         return std::make_unique<VerificationToken>();
202     case SerializableType::BUFFER:
203         return std::make_unique<Buffer>();
204     }
205 }
206 }  // namespace keymaster
207