src/manager/common/protocols.cpp

   1 /*
   2  *  Copyright (c) 2000 - 2013 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *  Contact: Bumjin Im <bj.im@samsung.com>
   5  *
   6  *  Licensed under the Apache License, Version 2.0 (the "License");
   7  *  you may not use this file except in compliance with the License.
   8  *  You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  *  Unless required by applicable law or agreed to in writing, software
  13  *  distributed under the License is distributed on an "AS IS" BASIS,
  14  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  *  See the License for the specific language governing permissions and
  16  *  limitations under the License
  17  *
  18  * @file        protocols.cpp
  19  * @author      Bartlomiej Grzelewski (b.grzelewski@samsung.com)
  20  * @author      Zofia Abramowska (z.abramowska@samsung.com)
  21  * @version     1.0
  22  * @brief       List of all protocols supported by Central Key Manager.
  23  */
  24
  25 #include <protocols.h>
  26
  27 #include <dpl/serialization.h>
  28 #include <ckm/ckm-type.h>
  29
  30 namespace CKM {
  31
  32 char const * const SERVICE_SOCKET_ECHO = "/tmp/.central-key-manager-echo.sock";
  33 char const * const SERVICE_SOCKET_CKM_CONTROL = "/tmp/.central-key-manager-api-control.sock";
  34 char const * const SERVICE_SOCKET_CKM_STORAGE = "/tmp/.central-key-manager-api-storage.sock";
  35 char const * const SERVICE_SOCKET_OCSP = "/tmp/.central-key-manager-api-ocsp.sock";
  36 char const * const LABEL_NAME_SEPARATOR = " ";
  37
  38
  39 PKCS12Serializable::PKCS12Serializable() {}
  40 PKCS12Serializable::PKCS12Serializable(const PKCS12 &pkcs)
  41     : PKCS12Impl(pkcs)
  42 {}
  43
  44 PKCS12Serializable::PKCS12Serializable(IStream &stream)
  45 {
  46     // key
  47     size_t numKeys;
  48     Deserialization::Deserialize(stream, numKeys);
  49     if(numKeys > 0) {
  50         int keyType;
  51         RawBuffer keyData;
  52         Deserialization::Deserialize(stream, keyType);
  53         Deserialization::Deserialize(stream, keyData);
  54         m_pkey = CKM::Key::create(keyData);
  55     }
  56
  57     // cert
  58     size_t numCerts;
  59     Deserialization::Deserialize(stream, numCerts);
  60     if(numCerts > 0) {
  61         RawBuffer certData;
  62         Deserialization::Deserialize(stream, certData);
  63         m_cert = CKM::Certificate::create(certData, DataFormat::FORM_DER);
  64     }
  65
  66     // CA chain
  67     size_t num_CA;
  68     Deserialization::Deserialize(stream, num_CA);
  69     for(size_t i=0; i<num_CA; i++)
  70     {
  71         RawBuffer CAcertData;
  72         Deserialization::Deserialize(stream, CAcertData);
  73         m_ca.push_back(CKM::Certificate::create(CAcertData, DataFormat::FORM_DER));
  74     }
  75 }
  76 PKCS12Serializable::PKCS12Serializable(const KeyShPtr &privKey, const CertificateShPtr &cert, const CertificateShPtrVector &chainCerts)
  77 {
  78     m_pkey = privKey;
  79     m_cert = cert;
  80     m_ca = chainCerts;
  81 }
  82
  83 void PKCS12Serializable::Serialize(IStream &stream) const
  84 {
  85     // key
  86     Key *keyPtr = getKey().get();
  87     bool isAnyKeyPresent = (getKey().get()!=NULL);
  88
  89     // logics if PKCS is correct or not is on the service side.
  90     // sending number of keys and certificates to allow proper parsing on the service side.
  91     // (what if no key or cert present? attempt to deserialize a not present key/cert would
  92     // throw an error and close the connection).
  93     Serialization::Serialize(stream, static_cast<size_t>(isAnyKeyPresent?1:0));
  94     if(keyPtr) {
  95         Serialization::Serialize(stream, DataType(keyPtr->getType()));
  96         Serialization::Serialize(stream, keyPtr->getDER());
  97     }
  98
  99     bool isAnyCertPresent = (getCertificate().get()!=NULL);
 100     Serialization::Serialize(stream, static_cast<size_t>(isAnyCertPresent?1:0));
 101     if(isAnyCertPresent) {
 102         Serialization::Serialize(stream, getCertificate().get()->getDER());
 103     }
 104
 105     // CA chain
 106     Serialization::Serialize(stream, getCaCertificateShPtrVector().size());
 107     for(auto it : getCaCertificateShPtrVector())
 108         Serialization::Serialize(stream, it->getDER());
 109 };
 110
 111
 112 CryptoAlgorithmSerializable::CryptoAlgorithmSerializable() {}
 113 CryptoAlgorithmSerializable::CryptoAlgorithmSerializable(CryptoAlgorithm &&algo) :
 114         CryptoAlgorithm(std::move(algo))
 115 {
 116 }
 117
 118 CryptoAlgorithmSerializable::CryptoAlgorithmSerializable(IStream &stream)
 119 {
 120     size_t plen = 0;
 121     int type;
 122     Deserializer<int,size_t>::Deserialize(stream, type, plen);
 123     m_type = static_cast<AlgoType>(type);
 124     while(plen) {
 125         ParamName name;
 126         uint64_t integer;
 127         RawBuffer buffer;
 128         int tmpName;
 129         Deserializer<int>::Deserialize(stream, tmpName);
 130         name = static_cast<ParamName>(tmpName);
 131         switch (name) {
 132         case ParamName::ED_IV:
 133         case ParamName::ED_CTR:
 134         case ParamName::ED_AAD:
 135         case ParamName::ED_LABEL:
 136             Deserializer<RawBuffer>::Deserialize(stream, buffer);
 137             m_params.emplace(name, BufferParam::create(buffer));
 138             break;
 139
 140         case ParamName::ED_CTR_LEN:
 141         case ParamName::ED_TAG_LEN:
 142         case ParamName::GEN_KEY_LEN:
 143         case ParamName::GEN_EC:
 144         case ParamName::SV_HASH_ALGO:
 145         case ParamName::SV_RSA_PADDING:
 146             Deserializer<uint64_t>::Deserialize(stream, integer);
 147             m_params.emplace(name, IntParam::create(integer));
 148             break;
 149
 150         default:
 151             ThrowMsg(UnsupportedParam, "Unsupported param name");
 152         }
 153         plen--;
 154     }
 155 }
 156
 157 void CryptoAlgorithmSerializable::Serialize(IStream &stream) const
 158 {
 159     Serializer<int,size_t>::Serialize(stream, static_cast<int>(m_type), m_params.size());
 160     for(const auto& it : m_params) {
 161         Serializer<int>::Serialize(stream, static_cast<int>(it.first));
 162         uint64_t integer;
 163         RawBuffer buffer;
 164         if (CKM_API_SUCCESS == it.second->getInt(integer))
 165             Serializer<uint64_t>::Serialize(stream, integer);
 166         else if (CKM_API_SUCCESS == it.second->getBuffer(buffer))
 167             Serializer<RawBuffer>::Serialize(stream, buffer);
 168         else
 169             ThrowMsg(UnsupportedParam, "Unsupported param type");
 170     }
 171
 172 }
 173
 174 } // namespace CKM
 175