Home | History | Annotate | Download | only in keymaster 
      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