src/manager/common/key-impl.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        key-impl.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 <key-impl.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 KeyImpl::KeyImpl()
  92   : m_pkey(NULL, EVP_PKEY_free)
  93   , m_type(KeyType::KEY_NONE)
  94 {}
  95
  96 KeyImpl::KeyImpl(const KeyImpl &second) {
  97     m_pkey = second.m_pkey;
  98     m_type = second.m_type;
  99 }
 100
 101 KeyImpl::KeyImpl(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         (void)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         (void)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         (void)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     switch(EVP_PKEY_type(pkey->type))
 151     {
 152         case EVP_PKEY_RSA:
 153             m_type = isPrivate ? KeyType::KEY_RSA_PRIVATE : KeyType::KEY_RSA_PUBLIC;
 154             break;
 155
 156         case EVP_PKEY_DSA:
 157             m_type = isPrivate ? KeyType::KEY_DSA_PRIVATE : KeyType::KEY_DSA_PUBLIC;
 158             break;
 159
 160         case EVP_PKEY_EC:
 161             m_type = isPrivate ? KeyType::KEY_ECDSA_PRIVATE : KeyType::KEY_ECDSA_PUBLIC;
 162             break;
 163     }
 164     LogDebug("KeyType is: " << (int)m_type << " isPrivate: " << isPrivate);
 165 }
 166
 167 KeyImpl::KeyImpl(EvpShPtr pkey, KeyType type) : m_pkey(pkey), m_type(type)
 168 {
 169     int expected_type = EVP_PKEY_NONE;
 170     switch(type)
 171     {
 172         case KeyType::KEY_RSA_PRIVATE:
 173         case KeyType::KEY_RSA_PUBLIC:
 174             expected_type = EVP_PKEY_RSA;
 175             break;
 176
 177         case KeyType::KEY_DSA_PRIVATE:
 178         case KeyType::KEY_DSA_PUBLIC:
 179             expected_type = EVP_PKEY_DSA;
 180             break;
 181
 182         case KeyType::KEY_AES:
 183             LogError("Error, AES keys are not supported yet.");
 184             break;
 185
 186         case KeyType::KEY_ECDSA_PRIVATE:
 187         case KeyType::KEY_ECDSA_PUBLIC:
 188             expected_type = EVP_PKEY_EC;
 189             break;
 190
 191         default:
 192             LogError("Unknown key type provided.");
 193             break;
 194     }
 195
 196     // verify if actual key type matches the expected tpe
 197     int given_key_type = EVP_PKEY_type(pkey->type);
 198     if(given_key_type==EVP_PKEY_NONE || expected_type!=given_key_type)
 199     {
 200         m_pkey.reset();
 201         m_type = KeyType::KEY_NONE;
 202     }
 203 }
 204
 205 bool KeyImpl::empty() const {
 206     return m_pkey.get() == NULL;
 207 }
 208
 209 KeyImpl::EvpShPtr KeyImpl::getEvpShPtr() const {
 210     return m_pkey;
 211 }
 212
 213 KeyType KeyImpl::getType() const {
 214     return m_type;
 215 }
 216
 217 RawBuffer KeyImpl::getDERPRV() const {
 218     return i2d(i2d_PrivateKey_bio, m_pkey.get());
 219 }
 220
 221 RawBuffer KeyImpl::getDERPUB() const {
 222     return i2d(i2d_PUBKEY_bio, m_pkey.get());
 223 }
 224
 225 RawBuffer KeyImpl::getDER() const {
 226     switch(m_type)
 227     {
 228         case KeyType::KEY_RSA_PRIVATE:
 229         case KeyType::KEY_DSA_PRIVATE:
 230         case KeyType::KEY_ECDSA_PRIVATE:
 231             return getDERPRV();
 232
 233         case KeyType::KEY_RSA_PUBLIC:
 234         case KeyType::KEY_DSA_PUBLIC:
 235         case KeyType::KEY_ECDSA_PUBLIC:
 236             return getDERPUB();
 237
 238         default:
 239             break;
 240     }
 241     return RawBuffer();
 242 }
 243
 244 KeyShPtr Key::create(const RawBuffer &raw, const Password &password) {
 245     try {
 246         KeyShPtr output = std::make_shared<KeyImpl>(raw, password);
 247         if (output->empty())
 248             output.reset();
 249         return output;
 250     } catch (const std::bad_alloc &) {
 251         LogDebug("Bad alloc was catch during KeyImpl creation");
 252     } catch (...) {
 253         LogError("Critical error: Unknown exception was caught during KeyImpl creation");
 254     }
 255     return KeyShPtr();
 256 }
 257
 258 } // namespace CKM
 259