src/manager/crypto/tz-backend/tz-serializer.cpp

   1 /*
   2  *  Copyright (c) 2019 Samsung Electronics Co., Ltd. All rights reserved
   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  * @file       tz-serializer.cpp
  18  * @author     Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
  19  * @version    1.0
  20  * @brief
  21  */
  22 #include "tz-serializer.h"
  23
  24 #include <string.h>
  25
  26 #include <generic-backend/crypto-params.h>
  27
  28 namespace CKM {
  29 namespace Crypto {
  30 namespace TZ {
  31 namespace Internals {
  32
  33 // TZSerializable
  34 void TZSerializable::Pull(RawBuffer &) const
  35 {
  36         ThrowErr(Exc::Crypto::InternalError,
  37                  "This serializable does not support conversion to RawBuffer");
  38 }
  39
  40 void TZSerializable::Pull(uint32_t &) const
  41 {
  42         ThrowErr(Exc::Crypto::InternalError,
  43                  "This serializable does not support conversion to uint32_t");
  44 }
  45
  46
  47 // TZSerializableBinary
  48 TZSerializableBinary::TZSerializableBinary(uint32_t data_size)
  49 {
  50         m_data.data = nullptr;
  51         m_data.data_size = data_size;
  52 }
  53
  54 TZSerializableBinary::TZSerializableBinary(const RawBuffer &data)
  55 {
  56         m_data.data = data.empty() ? nullptr : const_cast<unsigned char *>(data.data());
  57         m_data.data_size = data.size();
  58 }
  59
  60 uint32_t TZSerializableBinary::GetSize() const
  61 {
  62         return KM_SizeOfBinaryData(const_cast<KM_BinaryData*>(&m_data));
  63 }
  64
  65 int TZSerializableBinary::Serialize(void **buffer, uint32_t *size_guard) const
  66 {
  67         return KM_SerializeBinaryData(buffer, size_guard, const_cast<KM_BinaryData*>(&m_data));
  68 }
  69
  70 int TZSerializableBinary::Deserialize(void **buffer, uint32_t *size_guard)
  71 {
  72         return KM_DeserializeBinaryData(buffer, size_guard, &m_data);
  73 }
  74
  75 void TZSerializableBinary::Pull(RawBuffer &buffer) const
  76 {
  77         buffer.resize(m_data.data_size);
  78         memcpy(buffer.data(), m_data.data, m_data.data_size);
  79 }
  80
  81
  82 // TZSerializablePwdData
  83 TZSerializablePwdData::TZSerializablePwdData(const RawBuffer &pwd,
  84                                              const RawBuffer &iv,
  85                                              uint32_t tagSizeBits,
  86                                              const RawBuffer &tag)
  87 {
  88         memset(&m_data, 0, sizeof(KM_PwdData));
  89         m_data.pwd = pwd.empty() ? nullptr : const_cast<unsigned char *>(pwd.data());
  90         m_data.pwd_size = pwd.size();
  91         m_data.iv = iv.empty() ? nullptr : const_cast<unsigned char *>(iv.data());
  92         m_data.iv_size = iv.size();
  93         m_data.tag = tag.empty() ? nullptr : const_cast<unsigned char *>(tag.data());
  94         m_data.tag_size = tag.size();
  95         m_data.derive_len_bits = Params::DERIVED_KEY_LENGTH_BITS;
  96         m_data.it_count = Params::DERIVED_KEY_ITERATIONS;
  97         m_data.tag_len_bits = tagSizeBits;
  98 }
  99
 100 uint32_t TZSerializablePwdData::GetSize() const
 101 {
 102         return KM_SizeOfPwdData(const_cast<KM_PwdData*>(&m_data));
 103 }
 104
 105 int TZSerializablePwdData::Serialize(void **buffer, uint32_t *size_guard) const
 106 {
 107         return KM_SerializePwdData(buffer, size_guard, const_cast<KM_PwdData*>(&m_data));
 108 }
 109
 110 int TZSerializablePwdData::Deserialize(void **buffer, uint32_t *size_guard)
 111 {
 112         return KM_DeserializePwdData(buffer, size_guard, &m_data);
 113 }
 114
 115 // TZSerializableFlag
 116 uint32_t TZSerializableFlag::GetSize() const
 117 {
 118         return KM_SizeOfFlag();
 119 }
 120
 121 int TZSerializableFlag::Serialize(void **buffer, uint32_t *size_guard) const
 122 {
 123         return KM_SerializeFlag(buffer, size_guard, m_flag);
 124 }
 125
 126 int TZSerializableFlag::Deserialize(void **buffer, uint32_t *size_guard)
 127 {
 128         return KM_DeserializeFlag(buffer, size_guard, &m_flag);
 129 }
 130
 131 void TZSerializableFlag::Pull(uint32_t &flag) const
 132 {
 133         flag = m_flag;
 134 }
 135
 136
 137 // TZSerializer
 138 void TZSerializer::Push(TZSerializable *serializable)
 139 {
 140         m_serializables.emplace_back(serializable);
 141         m_memorySize += serializable->GetSize();
 142 }
 143
 144 void TZSerializer::Serialize(TrustZoneMemory &memory) const
 145 {
 146         void *inBuffer = memory.Get()->buffer;
 147         uint32_t inBufferGuard = m_memorySize;
 148
 149         for (const auto& s : m_serializables) {
 150                 int ret = s->Serialize(&inBuffer, &inBufferGuard);
 151                 if (ret) {
 152                         ThrowErr(Exc::Crypto::InternalError, "Failed to serialize data, ret: ", ret);
 153                 }
 154         }
 155 }
 156
 157 void TZSerializer::Deserialize(const TrustZoneMemory &memory)
 158 {
 159         void *outBuffer = memory.Get()->buffer;
 160         uint32_t outBufferGuard = m_memorySize;
 161
 162         for (const auto& s : m_serializables) {
 163                 int ret = s->Deserialize(&outBuffer, &outBufferGuard);
 164                 if (ret) {
 165                         ThrowErr(Exc::Crypto::InternalError, "Failed to deserialize data, ret: ", ret);
 166                 }
 167         }
 168 }
 169
 170 } // namespace Internals
 171 } // namespace TZ
 172 } // namespace Crypto
 173 } // namespace CKM