src/manager/common/generic-key.cpp

   1 /* Copyright (c) 2000 - 2013 Samsung Electronics Co., Ltd All Rights Reserved
   2  *
   3  *  Licensed under the Apache License, Version 2.0 (the "License");
   4  *  you may not use this file except in compliance with the License.
   5  *  You may obtain a copy of the License at
   6  *
   7  *      http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  *  Unless required by applicable law or agreed to in writing, software
  10  *  distributed under the License is distributed on an "AS IS" BASIS,
  11  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  *  See the License for the specific language governing permissions and
  13  *  limitations under the License
  14  *
  15  *
  16  * @file        generic-key.cpp
  17  * @author      Bartlomiej Grzelewski (b.grzelewski@samsung.com)
  18  * @version     1.0
  19  * @brief       Key implementation.
  20  */
  21 #include <string.h>
  22
  23 #include <functional>
  24 #include <memory>
  25 #include <sstream>
  26 #include <ios>
  27
  28 #include <openssl/bio.h>
  29 #include <openssl/evp.h>
  30 #include <openssl/pem.h>
  31 #include <openssl/x509.h>
  32
  33 #include <dpl/log/log.h>
  34
  35 #include <ckm/ckm-type.h>
  36 #include <generic-key.h>
  37
  38 namespace CKM {
  39 namespace {
  40
  41 typedef std::unique_ptr<BIO, std::function<void(BIO*)>> BioUniquePtr;
  42
  43 int passcb(char *buff, int size, int rwflag, void *userdata) {
  44     (void) rwflag;
  45     Password *ptr = static_cast<Password*>(userdata);
  46     if (ptr == NULL)
  47         return 0;
  48     if (ptr->empty())
  49         return 0;
  50     if (static_cast<int>(ptr->size()) > size)
  51         return 0;
  52     memcpy(buff, ptr->c_str(), ptr->size());
  53     return ptr->size();
  54 }
  55
  56 typedef int(*I2D_CONV)(BIO*, EVP_PKEY*);
  57
  58 CKM::RawBuffer i2d(I2D_CONV fun, EVP_PKEY* pkey) {
  59     BioUniquePtr bio(BIO_new(BIO_s_mem()), BIO_free_all);
  60
  61     if (NULL == pkey) {
  62         LogDebug("You are trying to read empty key!");
  63         return RawBuffer();
  64     }
  65
  66     if (NULL == bio.get()) {
  67         LogError("Error in memory allocation! Function: BIO_new.");
  68         return RawBuffer();
  69     }
  70
  71     if (1 != fun(bio.get(), pkey)) {
  72         LogError("Error in conversion EVP_PKEY to der");
  73         return RawBuffer();
  74     }
  75
  76     CKM::RawBuffer output(8196);
  77
  78     int size = BIO_read(bio.get(), output.data(), output.size());
  79
  80     if (size <= 0) {
  81         LogError("Error in BIO_read: " << size);
  82         return RawBuffer();
  83     }
  84
  85     output.resize(size);
  86     return output;
  87 }
  88
  89 } // anonymous namespace
  90
  91 GenericKey::GenericKey()
  92   : m_pkey(NULL, EVP_PKEY_free)
  93   , m_type(KeyType::KEY_NONE)
  94 {}
  95
  96 GenericKey::GenericKey(const GenericKey &second) {
  97     m_pkey = second.m_pkey;
  98     m_type = second.m_type;
  99 }
 100
 101 GenericKey::GenericKey(const RawBuffer &buf, const Password &password)
 102   : m_pkey(NULL, EVP_PKEY_free)
 103   , m_type(KeyType::KEY_NONE)
 104 {
 105     bool isPrivate = false;
 106     EVP_PKEY *pkey = NULL;
 107     BioUniquePtr bio(BIO_new(BIO_s_mem()), BIO_free_all);
 108
 109     LogDebug("Start to parse key:");
 110 //    printDER(buf);
 111
 112     if (buf[0] != '-') {
 113         BIO_write(bio.get(), buf.data(), buf.size());
 114         pkey = d2i_PUBKEY_bio(bio.get(), NULL);
 115         isPrivate = false;
 116         LogDebug("Trying d2i_PUBKEY_bio Status: " << (void*)pkey);
 117     }
 118
 119     if (!pkey && buf[0] != '-') {
 120         BIO_reset(bio.get());
 121         BIO_write(bio.get(), buf.data(), buf.size());
 122         pkey = d2i_PrivateKey_bio(bio.get(), NULL);
 123         isPrivate = true;
 124         LogDebug("Trying d2i_PrivateKey_bio Status: " << (void*)pkey);
 125     }
 126
 127     if (!pkey && buf[0] == '-') {
 128         BIO_reset(bio.get());
 129         BIO_write(bio.get(), buf.data(), buf.size());
 130         pkey = PEM_read_bio_PUBKEY(bio.get(), NULL, passcb, const_cast<Password*>(&password));
 131         isPrivate = false;
 132         LogDebug("PEM_read_bio_PUBKEY Status: " << (void*)pkey);
 133     }
 134
 135     if (!pkey && buf[0] == '-') {
 136         BIO_reset(bio.get());
 137         BIO_write(bio.get(), buf.data(), buf.size());
 138         pkey = PEM_read_bio_PrivateKey(bio.get(), NULL, passcb, const_cast<Password*>(&password));
 139         isPrivate = true;
 140         LogDebug("PEM_read_bio_PrivateKey Status: " << (void*)pkey);
 141     }
 142
 143     if (!pkey) {
 144         LogError("Failed to parse key");
 145         return;
 146     }
 147
 148     m_pkey.reset(pkey, EVP_PKEY_free);
 149
 150     int type = EVP_PKEY_type(pkey->type);
 151
 152     if (type == EVP_PKEY_RSA) {
 153         m_type = isPrivate ? KeyType::KEY_RSA_PRIVATE : KeyType::KEY_RSA_PUBLIC;
 154     }
 155
 156     if (type == EVP_PKEY_EC) {
 157         m_type = isPrivate ? KeyType::KEY_ECDSA_PRIVATE : KeyType::KEY_ECDSA_PUBLIC;
 158     }
 159     LogDebug("KeyType is: " << (int)m_type << " isPrivate: " << isPrivate);
 160 }
 161
 162 GenericKey::GenericKey(EvpShPtr pkey, KeyType type)
 163   : m_pkey(pkey)
 164   , m_type(type)
 165 {
 166     if (type == KeyType::KEY_RSA_PRIVATE || type == KeyType::KEY_RSA_PUBLIC)
 167         if (EVP_PKEY_RSA != EVP_PKEY_type(pkey->type)) {
 168             m_pkey.reset();
 169             m_type = KeyType::KEY_NONE;
 170         }
 171     if (type == KeyType::KEY_ECDSA_PRIVATE || type == KeyType::KEY_ECDSA_PUBLIC)
 172         if (EVP_PKEY_EC != EVP_PKEY_type(pkey->type)) {
 173             m_pkey.reset();
 174             m_type = KeyType::KEY_NONE;
 175         }
 176 }
 177
 178 bool GenericKey::empty() const {
 179     return m_pkey.get() == NULL;
 180 }
 181
 182 GenericKey::EvpShPtr GenericKey::getEvpShPtr() const {
 183     return m_pkey;
 184 }
 185
 186 KeyType GenericKey::getType() const {
 187     return m_type;
 188 }
 189
 190 RawBuffer GenericKey::getDERPRV() const {
 191     return i2d(i2d_PrivateKey_bio, m_pkey.get());
 192 }
 193
 194 RawBuffer GenericKey::getDERPUB() const {
 195     return i2d(i2d_PUBKEY_bio, m_pkey.get());
 196 }
 197
 198 RawBuffer GenericKey::getDER() const {
 199     if (m_type == KeyType::KEY_ECDSA_PRIVATE || m_type == KeyType::KEY_RSA_PRIVATE) {
 200         return getDERPRV();
 201     } else if (m_type == KeyType::KEY_RSA_PUBLIC || m_type == KeyType::KEY_ECDSA_PUBLIC) {
 202         return getDERPUB();
 203     }
 204     return RawBuffer();
 205 }
 206
 207 KeyShPtr Key::create(const RawBuffer &raw, const Password &password) {
 208     try {
 209         KeyShPtr output = std::make_shared<GenericKey>(raw, password);
 210         if (output->empty())
 211             output.reset();
 212         return output;
 213     } catch (const std::bad_alloc &) {
 214         LogDebug("Bad alloc was catch during GenericKey creation");
 215     } catch (...) {
 216         LogError("Critical error: Unknown exception was caught during GenericKey creation");
 217     }
 218     return KeyShPtr();
 219 }
 220
 221 } // namespace CKM
 222