Added base error code declaration.
[platform/core/security/key-manager.git] / 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