1 /* 2 * Copyright 2014 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 #include <keymaster/google_keymaster_messages.h> 18 #include <keymaster/google_keymaster_utils.h> 19 20 namespace keymaster { 21 22 size_t KeymasterResponse::SerializedSize() const { 23 if (error != KM_ERROR_OK) 24 return sizeof(int32_t); 25 else 26 return sizeof(int32_t) + NonErrorSerializedSize(); 27 } 28 29 uint8_t* KeymasterResponse::Serialize(uint8_t* buf, const uint8_t* end) const { 30 buf = append_uint32_to_buf(buf, end, static_cast<uint32_t>(error)); 31 if (error == KM_ERROR_OK) 32 buf = NonErrorSerialize(buf, end); 33 return buf; 34 } 35 36 bool KeymasterResponse::Deserialize(const uint8_t** buf_ptr, const uint8_t* end) { 37 if (!copy_uint32_from_buf(buf_ptr, end, &error)) 38 return false; 39 if (error != KM_ERROR_OK) 40 return true; 41 return NonErrorDeserialize(buf_ptr, end); 42 } 43 44 size_t SupportedAlgorithmsResponse::NonErrorSerializedSize() const { 45 return sizeof(uint32_t) + sizeof(uint32_t) * algorithms_length; 46 } 47 48 uint8_t* SupportedAlgorithmsResponse::NonErrorSerialize(uint8_t* buf, const uint8_t* end) const { 49 return append_uint32_array_to_buf(buf, end, algorithms, algorithms_length); 50 } 51 52 bool SupportedAlgorithmsResponse::NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) { 53 delete[] algorithms; 54 algorithms = NULL; 55 UniquePtr<keymaster_algorithm_t[]> deserialized_algorithms; 56 if (!copy_uint32_array_from_buf(buf_ptr, end, &deserialized_algorithms, &algorithms_length)) 57 return false; 58 algorithms = deserialized_algorithms.release(); 59 return true; 60 } 61 62 GenerateKeyResponse::~GenerateKeyResponse() { 63 delete[] key_blob.key_material; 64 } 65 66 size_t GenerateKeyResponse::NonErrorSerializedSize() const { 67 return sizeof(uint32_t) /* key size */ + key_blob.key_material_size + 68 enforced.SerializedSize() + unenforced.SerializedSize(); 69 } 70 71 uint8_t* GenerateKeyResponse::NonErrorSerialize(uint8_t* buf, const uint8_t* end) const { 72 buf = append_size_and_data_to_buf(buf, end, key_blob.key_material, key_blob.key_material_size); 73 buf = enforced.Serialize(buf, end); 74 return unenforced.Serialize(buf, end); 75 } 76 77 bool GenerateKeyResponse::NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) { 78 delete[] key_blob.key_material; 79 key_blob.key_material = NULL; 80 UniquePtr<uint8_t[]> deserialized_key_material; 81 if (!copy_size_and_data_from_buf(buf_ptr, end, &key_blob.key_material_size, 82 &deserialized_key_material) || 83 !enforced.Deserialize(buf_ptr, end) || !unenforced.Deserialize(buf_ptr, end)) 84 return false; 85 key_blob.key_material = deserialized_key_material.release(); 86 return true; 87 } 88 89 GetKeyCharacteristicsRequest::~GetKeyCharacteristicsRequest() { 90 delete[] key_blob.key_material; 91 } 92 93 void GetKeyCharacteristicsRequest::SetKeyMaterial(const void* key_material, size_t length) { 94 delete[] key_blob.key_material; 95 key_blob.key_material = dup_buffer(key_material, length); 96 key_blob.key_material_size = length; 97 } 98 99 size_t GetKeyCharacteristicsRequest::SerializedSize() const { 100 return sizeof(uint32_t) /* key blob size */ + key_blob.key_material_size + 101 additional_params.SerializedSize(); 102 } 103 104 uint8_t* GetKeyCharacteristicsRequest::Serialize(uint8_t* buf, const uint8_t* end) const { 105 buf = append_size_and_data_to_buf(buf, end, key_blob.key_material, key_blob.key_material_size); 106 return additional_params.Serialize(buf, end); 107 } 108 109 bool GetKeyCharacteristicsRequest::Deserialize(const uint8_t** buf_ptr, const uint8_t* end) { 110 delete[] key_blob.key_material; 111 key_blob.key_material = NULL; 112 UniquePtr<uint8_t[]> deserialized_key_material; 113 if (!copy_size_and_data_from_buf(buf_ptr, end, &key_blob.key_material_size, 114 &deserialized_key_material) || 115 !additional_params.Deserialize(buf_ptr, end)) 116 return false; 117 key_blob.key_material = deserialized_key_material.release(); 118 return true; 119 } 120 121 size_t GetKeyCharacteristicsResponse::NonErrorSerializedSize() const { 122 return enforced.SerializedSize() + unenforced.SerializedSize(); 123 } 124 125 uint8_t* GetKeyCharacteristicsResponse::NonErrorSerialize(uint8_t* buf, const uint8_t* end) const { 126 buf = enforced.Serialize(buf, end); 127 return unenforced.Serialize(buf, end); 128 } 129 130 bool GetKeyCharacteristicsResponse::NonErrorDeserialize(const uint8_t** buf_ptr, 131 const uint8_t* end) { 132 return enforced.Deserialize(buf_ptr, end) && unenforced.Deserialize(buf_ptr, end); 133 } 134 135 void BeginOperationRequest::SetKeyMaterial(const void* key_material, size_t length) { 136 delete[] key_blob.key_material; 137 key_blob.key_material = dup_buffer(key_material, length); 138 key_blob.key_material_size = length; 139 } 140 141 size_t BeginOperationRequest::SerializedSize() const { 142 return sizeof(uint32_t) /* purpose */ + sizeof(uint32_t) /* key length */ + 143 key_blob.key_material_size + additional_params.SerializedSize(); 144 } 145 146 uint8_t* BeginOperationRequest::Serialize(uint8_t* buf, const uint8_t* end) const { 147 buf = append_uint32_to_buf(buf, end, purpose); 148 buf = append_size_and_data_to_buf(buf, end, key_blob.key_material, key_blob.key_material_size); 149 return additional_params.Serialize(buf, end); 150 } 151 152 bool BeginOperationRequest::Deserialize(const uint8_t** buf_ptr, const uint8_t* end) { 153 delete[] key_blob.key_material; 154 key_blob.key_material = 0; 155 UniquePtr<uint8_t[]> deserialized_key_material; 156 if (!copy_uint32_from_buf(buf_ptr, end, &purpose) || 157 !copy_size_and_data_from_buf(buf_ptr, end, &key_blob.key_material_size, 158 &deserialized_key_material) || 159 !additional_params.Deserialize(buf_ptr, end)) 160 return false; 161 key_blob.key_material = deserialized_key_material.release(); 162 return true; 163 } 164 165 size_t BeginOperationResponse::NonErrorSerializedSize() const { 166 return sizeof(op_handle); 167 } 168 169 uint8_t* BeginOperationResponse::NonErrorSerialize(uint8_t* buf, const uint8_t* end) const { 170 return append_uint64_to_buf(buf, end, op_handle); 171 } 172 173 bool BeginOperationResponse::NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) { 174 return copy_uint64_from_buf(buf_ptr, end, &op_handle); 175 } 176 177 size_t UpdateOperationRequest::SerializedSize() const { 178 return sizeof(op_handle) + input.SerializedSize(); 179 } 180 181 uint8_t* UpdateOperationRequest::Serialize(uint8_t* buf, const uint8_t* end) const { 182 buf = append_uint64_to_buf(buf, end, op_handle); 183 return input.Serialize(buf, end); 184 } 185 186 bool UpdateOperationRequest::Deserialize(const uint8_t** buf_ptr, const uint8_t* end) { 187 return copy_uint64_from_buf(buf_ptr, end, &op_handle) && input.Deserialize(buf_ptr, end); 188 } 189 190 size_t UpdateOperationResponse::NonErrorSerializedSize() const { 191 return output.SerializedSize(); 192 } 193 194 uint8_t* UpdateOperationResponse::NonErrorSerialize(uint8_t* buf, const uint8_t* end) const { 195 return output.Serialize(buf, end); 196 } 197 198 bool UpdateOperationResponse::NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) { 199 return output.Deserialize(buf_ptr, end); 200 } 201 202 size_t FinishOperationRequest::SerializedSize() const { 203 return sizeof(op_handle) + signature.SerializedSize(); 204 } 205 206 uint8_t* FinishOperationRequest::Serialize(uint8_t* buf, const uint8_t* end) const { 207 buf = append_uint64_to_buf(buf, end, op_handle); 208 return signature.Serialize(buf, end); 209 } 210 211 bool FinishOperationRequest::Deserialize(const uint8_t** buf_ptr, const uint8_t* end) { 212 return copy_uint64_from_buf(buf_ptr, end, &op_handle) && signature.Deserialize(buf_ptr, end); 213 } 214 215 size_t FinishOperationResponse::NonErrorSerializedSize() const { 216 return output.SerializedSize(); 217 } 218 219 uint8_t* FinishOperationResponse::NonErrorSerialize(uint8_t* buf, const uint8_t* end) const { 220 return output.Serialize(buf, end); 221 } 222 223 bool FinishOperationResponse::NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) { 224 return output.Deserialize(buf_ptr, end); 225 } 226 227 void ImportKeyRequest::SetKeyMaterial(const void* key_material, size_t length) { 228 delete[] key_data; 229 key_data = dup_buffer(key_material, length); 230 key_data_length = length; 231 } 232 233 size_t ImportKeyRequest::SerializedSize() const { 234 return key_description.SerializedSize() + sizeof(uint32_t) /* key_format */ + 235 sizeof(uint32_t) /* key_data_length */ + key_data_length; 236 } 237 238 uint8_t* ImportKeyRequest::Serialize(uint8_t* buf, const uint8_t* end) const { 239 buf = key_description.Serialize(buf, end); 240 buf = append_uint32_to_buf(buf, end, key_format); 241 return append_size_and_data_to_buf(buf, end, key_data, key_data_length); 242 } 243 244 bool ImportKeyRequest::Deserialize(const uint8_t** buf_ptr, const uint8_t* end) { 245 delete[] key_data; 246 key_data = NULL; 247 UniquePtr<uint8_t[]> deserialized_key_material; 248 if (!key_description.Deserialize(buf_ptr, end) || 249 !copy_uint32_from_buf(buf_ptr, end, &key_format) || 250 !copy_size_and_data_from_buf(buf_ptr, end, &key_data_length, &deserialized_key_material)) 251 return false; 252 key_data = deserialized_key_material.release(); 253 return true; 254 } 255 256 void ImportKeyResponse::SetKeyMaterial(const void* key_material, size_t length) { 257 delete[] key_blob.key_material; 258 key_blob.key_material = dup_buffer(key_material, length); 259 key_blob.key_material_size = length; 260 } 261 262 size_t ImportKeyResponse::NonErrorSerializedSize() const { 263 return sizeof(uint32_t) /* key_material length */ + key_blob.key_material_size + 264 enforced.SerializedSize() + unenforced.SerializedSize(); 265 } 266 267 uint8_t* ImportKeyResponse::NonErrorSerialize(uint8_t* buf, const uint8_t* end) const { 268 buf = append_size_and_data_to_buf(buf, end, key_blob.key_material, key_blob.key_material_size); 269 buf = enforced.Serialize(buf, end); 270 return unenforced.Serialize(buf, end); 271 } 272 273 bool ImportKeyResponse::NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) { 274 delete[] key_blob.key_material; 275 key_blob.key_material = NULL; 276 UniquePtr<uint8_t[]> deserialized_key_material; 277 if (!copy_size_and_data_from_buf(buf_ptr, end, &key_blob.key_material_size, 278 &deserialized_key_material) || 279 !enforced.Deserialize(buf_ptr, end) || !unenforced.Deserialize(buf_ptr, end)) 280 return false; 281 key_blob.key_material = deserialized_key_material.release(); 282 return true; 283 } 284 285 void ExportKeyRequest::SetKeyMaterial(const void* key_material, size_t length) { 286 delete[] key_blob.key_material; 287 key_blob.key_material = dup_buffer(key_material, length); 288 key_blob.key_material_size = length; 289 } 290 291 size_t ExportKeyRequest::SerializedSize() const { 292 return additional_params.SerializedSize() + sizeof(uint32_t) /* key_format */ + 293 sizeof(uint32_t) /* key_material_size */ + key_blob.key_material_size; 294 } 295 296 uint8_t* ExportKeyRequest::Serialize(uint8_t* buf, const uint8_t* end) const { 297 buf = additional_params.Serialize(buf, end); 298 buf = append_uint32_to_buf(buf, end, key_format); 299 return append_size_and_data_to_buf(buf, end, key_blob.key_material, key_blob.key_material_size); 300 } 301 302 bool ExportKeyRequest::Deserialize(const uint8_t** buf_ptr, const uint8_t* end) { 303 delete[] key_blob.key_material; 304 key_blob.key_material = NULL; 305 UniquePtr<uint8_t[]> deserialized_key_material; 306 if (!additional_params.Deserialize(buf_ptr, end) || 307 !copy_uint32_from_buf(buf_ptr, end, &key_format) || 308 !copy_size_and_data_from_buf(buf_ptr, end, &key_blob.key_material_size, 309 &deserialized_key_material)) 310 return false; 311 key_blob.key_material = deserialized_key_material.release(); 312 return true; 313 } 314 315 void ExportKeyResponse::SetKeyMaterial(const void* key_material, size_t length) { 316 delete[] key_data; 317 key_data = dup_buffer(key_material, length); 318 key_data_length = length; 319 } 320 321 size_t ExportKeyResponse::NonErrorSerializedSize() const { 322 return sizeof(uint32_t) /* key_data_length */ + key_data_length; 323 } 324 325 uint8_t* ExportKeyResponse::NonErrorSerialize(uint8_t* buf, const uint8_t* end) const { 326 return append_size_and_data_to_buf(buf, end, key_data, key_data_length); 327 } 328 329 bool ExportKeyResponse::NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) { 330 delete[] key_data; 331 key_data = NULL; 332 UniquePtr<uint8_t[]> deserialized_key_material; 333 if (!copy_size_and_data_from_buf(buf_ptr, end, &key_data_length, &deserialized_key_material)) 334 return false; 335 key_data = deserialized_key_material.release(); 336 return true; 337 } 338 339 } // namespace keymaster 340