1 /*
2  * Copyright (C) 2023 Huawei Device Co., Ltd.
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 #include "alg_25519_common_param_spec.h"
17 #include "securec.h"
18 #include "asy_key_generator.h"
19 #include "memory.h"
20 #include "memory_mock.h"
21 
CreateAlg25519KeyPairSpec(bool choose,HcfAlg25519KeyPairParamsSpec ** alg25519KeyPairSpec)22 static HcfResult CreateAlg25519KeyPairSpec(bool choose, HcfAlg25519KeyPairParamsSpec **alg25519KeyPairSpec)
23 {
24     *alg25519KeyPairSpec = (HcfAlg25519KeyPairParamsSpec*)HcfMalloc(sizeof(HcfAlg25519KeyPairParamsSpec), 0);
25     if (*alg25519KeyPairSpec == NULL) {
26         return HCF_ERR_MALLOC;
27     }
28     if (choose) {
29         (*alg25519KeyPairSpec)->base.algName = (char*)HcfMalloc(sizeof("Ed25519"), 0);
30         if ((*alg25519KeyPairSpec)->base.algName == NULL) {
31             HcfFree(*alg25519KeyPairSpec);
32             *alg25519KeyPairSpec = NULL;
33             return HCF_ERR_MALLOC;
34         }
35         (void)memcpy_s((*alg25519KeyPairSpec)->base.algName, sizeof("Ed25519"),
36             "Ed25519", sizeof("Ed25519"));
37     } else {
38         (*alg25519KeyPairSpec)->base.algName = (char*)HcfMalloc(sizeof("X25519"), 0);
39         if ((*alg25519KeyPairSpec)->base.algName == NULL) {
40             HcfFree(*alg25519KeyPairSpec);
41             *alg25519KeyPairSpec = NULL;
42             return HCF_ERR_MALLOC;
43         }
44         (void)memcpy_s((*alg25519KeyPairSpec)->base.algName, sizeof("X25519"),
45             "X25519", sizeof("X25519"));
46     }
47     return HCF_SUCCESS;
48 }
49 
ConstructAlg25519KeyPairParamsSpec(const char * algoName,bool choose,HcfAsyKeyParamsSpec ** spec)50 HcfResult ConstructAlg25519KeyPairParamsSpec(const char *algoName, bool choose, HcfAsyKeyParamsSpec **spec)
51 {
52     HcfResult res = HCF_ERR_CRYPTO_OPERATION;
53     HcfAsyKeyGenerator *generator = NULL;
54     if (HcfAsyKeyGeneratorCreate(algoName, &generator) != HCF_SUCCESS) {
55         return res;
56     }
57 
58     HcfKeyPair *keyPair = NULL;
59     if (generator->generateKeyPair(generator, NULL, &keyPair) != HCF_SUCCESS) {
60         HcfObjDestroy(generator);
61         return res;
62     }
63 
64     HcfAlg25519KeyPairParamsSpec *alg25519KeyPairSpec = NULL;
65     if (CreateAlg25519KeyPairSpec(choose, &alg25519KeyPairSpec) == HCF_SUCCESS) {
66         HcfBigInteger retBigInt = { .data = NULL, .len = 0 };
67         alg25519KeyPairSpec->base.specType = HCF_KEY_PAIR_SPEC;
68         if (choose) {
69             res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ED25519_PK_BN, &retBigInt);
70         } else {
71             res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, X25519_PK_BN, &retBigInt);
72         }
73         if (res == HCF_SUCCESS) {
74             alg25519KeyPairSpec->pk.data = retBigInt.data;
75             alg25519KeyPairSpec->pk.len = retBigInt.len;
76             if (choose) {
77                 res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, ED25519_SK_BN, &retBigInt);
78             } else {
79                 res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, X25519_SK_BN, &retBigInt);
80             }
81             if (res == HCF_SUCCESS) {
82                 alg25519KeyPairSpec->sk.data = retBigInt.data;
83                 alg25519KeyPairSpec->sk.len = retBigInt.len;
84                 *spec = (HcfAsyKeyParamsSpec *)alg25519KeyPairSpec;
85             } else {
86                 HcfFree(alg25519KeyPairSpec->pk.data);
87                 alg25519KeyPairSpec->pk.data = NULL;
88                 alg25519KeyPairSpec->pk.len = 0;
89             }
90         }
91         if (res != HCF_SUCCESS) {
92             DestroyAlg25519KeyPairSpec((HcfAlg25519KeyPairParamsSpec *)alg25519KeyPairSpec);
93         }
94     }
95 
96     HcfObjDestroy(generator);
97     HcfObjDestroy(keyPair);
98     return res;
99 }
100 
CreateAlg25519PubKeySpec(bool choose,HcfAlg25519PubKeyParamsSpec ** alg25519PubKeySpec)101 static HcfResult CreateAlg25519PubKeySpec(bool choose, HcfAlg25519PubKeyParamsSpec **alg25519PubKeySpec)
102 {
103     *alg25519PubKeySpec = (HcfAlg25519PubKeyParamsSpec*)HcfMalloc(sizeof(HcfAlg25519PubKeyParamsSpec), 0);
104     if (*alg25519PubKeySpec == NULL) {
105         return HCF_ERR_MALLOC;
106     }
107     if (choose) {
108         (*alg25519PubKeySpec)->base.algName = (char*)HcfMalloc(sizeof("Ed25519"), 0);
109         if ((*alg25519PubKeySpec)->base.algName == NULL) {
110             HcfFree(*alg25519PubKeySpec);
111             *alg25519PubKeySpec = NULL;
112             return HCF_ERR_MALLOC;
113         }
114         (void)memcpy_s((*alg25519PubKeySpec)->base.algName, sizeof("Ed25519"),
115             "Ed25519", sizeof("Ed25519"));
116     } else {
117         (*alg25519PubKeySpec)->base.algName = (char*)HcfMalloc(sizeof("X25519"), 0);
118         if ((*alg25519PubKeySpec)->base.algName == NULL) {
119             HcfFree(*alg25519PubKeySpec);
120             *alg25519PubKeySpec = NULL;
121             return HCF_ERR_MALLOC;
122         }
123         (void)memcpy_s((*alg25519PubKeySpec)->base.algName, sizeof("X25519"),
124             "X25519", sizeof("X25519"));
125     }
126     return HCF_SUCCESS;
127 }
128 
ConstructAlg25519PubKeyParamsSpec(const char * algoName,bool choose,HcfAsyKeyParamsSpec ** spec)129 HcfResult ConstructAlg25519PubKeyParamsSpec(const char *algoName, bool choose, HcfAsyKeyParamsSpec **spec)
130 {
131     HcfResult res = HCF_ERR_CRYPTO_OPERATION;
132     HcfAsyKeyGenerator *generator = NULL;
133     if (HcfAsyKeyGeneratorCreate(algoName, &generator) != HCF_SUCCESS) {
134         return res;
135     }
136 
137     HcfKeyPair *keyPair = NULL;
138     if (generator->generateKeyPair(generator, NULL, &keyPair) != HCF_SUCCESS) {
139         HcfObjDestroy(generator);
140         return res;
141     }
142 
143     HcfAlg25519PubKeyParamsSpec *alg25519PubKeySpec = NULL;
144     if (CreateAlg25519PubKeySpec(choose, &alg25519PubKeySpec) == HCF_SUCCESS) {
145         HcfBigInteger retBigInt = { .data = NULL, .len = 0 };
146         alg25519PubKeySpec->base.specType = HCF_PUBLIC_KEY_SPEC;
147         if (choose) {
148             res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ED25519_PK_BN, &retBigInt);
149         } else {
150             res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, X25519_PK_BN, &retBigInt);
151         }
152         if (res == HCF_SUCCESS) {
153             alg25519PubKeySpec->pk.data = retBigInt.data;
154             alg25519PubKeySpec->pk.len = retBigInt.len;
155             *spec = (HcfAsyKeyParamsSpec *)alg25519PubKeySpec;
156         } else {
157             DestroyAlg25519PubKeySpec((HcfAlg25519PubKeyParamsSpec *)alg25519PubKeySpec);
158         }
159     }
160 
161     HcfObjDestroy(generator);
162     HcfObjDestroy(keyPair);
163     return res;
164 }
165 
CreateAlg25519PriKeySpec(bool choose,HcfAlg25519PriKeyParamsSpec ** alg25519PriKeySpec)166 static HcfResult CreateAlg25519PriKeySpec(bool choose, HcfAlg25519PriKeyParamsSpec **alg25519PriKeySpec)
167 {
168     *alg25519PriKeySpec = (HcfAlg25519PriKeyParamsSpec*)HcfMalloc(sizeof(HcfAlg25519PriKeyParamsSpec), 0);
169     if (*alg25519PriKeySpec == NULL) {
170         return HCF_ERR_MALLOC;
171     }
172     if (choose) {
173         (*alg25519PriKeySpec)->base.algName = (char*)HcfMalloc(sizeof("Ed25519"), 0);
174         if ((*alg25519PriKeySpec)->base.algName == NULL) {
175             HcfFree(*alg25519PriKeySpec);
176             *alg25519PriKeySpec = NULL;
177             return HCF_ERR_MALLOC;
178         }
179         (void)memcpy_s((*alg25519PriKeySpec)->base.algName, sizeof("Ed25519"),
180             "Ed25519", sizeof("Ed25519"));
181     } else {
182         (*alg25519PriKeySpec)->base.algName = (char*)HcfMalloc(sizeof("X25519"), 0);
183         if ((*alg25519PriKeySpec)->base.algName == NULL) {
184             HcfFree(*alg25519PriKeySpec);
185             *alg25519PriKeySpec = NULL;
186             return HCF_ERR_MALLOC;
187         }
188         (void)memcpy_s((*alg25519PriKeySpec)->base.algName, sizeof("X25519"),
189             "X25519", sizeof("X25519"));
190     }
191     return HCF_SUCCESS;
192 }
193 
ConstructAlg25519PriKeyParamsSpec(const char * algoName,bool choose,HcfAsyKeyParamsSpec ** spec)194 HcfResult ConstructAlg25519PriKeyParamsSpec(const char *algoName, bool choose, HcfAsyKeyParamsSpec **spec)
195 {
196     HcfResult res = HCF_ERR_CRYPTO_OPERATION;
197     HcfAsyKeyGenerator *generator = NULL;
198     if (HcfAsyKeyGeneratorCreate(algoName, &generator) != HCF_SUCCESS) {
199         return res;
200     }
201 
202     HcfKeyPair *keyPair = NULL;
203     if (generator->generateKeyPair(generator, NULL, &keyPair) != HCF_SUCCESS) {
204         HcfObjDestroy(generator);
205         return res;
206     }
207     HcfAlg25519PriKeyParamsSpec *alg25519PriKeySpec = NULL;
208     if (CreateAlg25519PriKeySpec(choose, &alg25519PriKeySpec) == HCF_SUCCESS) {
209         HcfBigInteger retBigInt = { .data = NULL, .len = 0 };
210         alg25519PriKeySpec->base.specType = HCF_PRIVATE_KEY_SPEC;
211         if (choose) {
212             res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, ED25519_SK_BN, &retBigInt);
213         } else {
214             res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, X25519_SK_BN, &retBigInt);
215         }
216         if (res == HCF_SUCCESS) {
217             alg25519PriKeySpec->sk.data = retBigInt.data;
218             alg25519PriKeySpec->sk.len = retBigInt.len;
219             *spec = (HcfAsyKeyParamsSpec *)alg25519PriKeySpec;
220         } else {
221             DestroyAlg25519PriKeySpec((HcfAlg25519PriKeyParamsSpec *)alg25519PriKeySpec);
222         }
223     }
224     HcfObjDestroy(generator);
225     HcfObjDestroy(keyPair);
226     return res;
227 }
228 
TestHcfAsyKeyGeneratorCreate(const char * algName,HcfAsyKeyGenerator ** generator)229 HcfResult TestHcfAsyKeyGeneratorCreate(const char *algName, HcfAsyKeyGenerator **generator)
230 {
231     HcfResult res = HcfAsyKeyGeneratorCreate(algName, generator);
232     if (res != HCF_SUCCESS) {
233         return HCF_ERR_CRYPTO_OPERATION;
234     }
235     if (*generator == NULL) {
236         return HCF_ERR_CRYPTO_OPERATION;
237     }
238     return HCF_SUCCESS;
239 }
240 
TestGenerateKeyPair(HcfAsyKeyGenerator * generator,HcfKeyPair ** keyPair)241 HcfResult TestGenerateKeyPair(HcfAsyKeyGenerator *generator, HcfKeyPair **keyPair)
242 {
243     HcfResult res = generator->generateKeyPair(generator, NULL, keyPair);
244     if (res != HCF_SUCCESS) {
245         return HCF_ERR_CRYPTO_OPERATION;
246     }
247     if (*keyPair == NULL) {
248         return HCF_ERR_CRYPTO_OPERATION;
249     }
250     return HCF_SUCCESS;
251 }
252 
TestKeyGeneratorAndGenerateKeyPair(const char * algName,HcfAsyKeyGenerator ** generator,HcfKeyPair ** keyPair)253 HcfResult TestKeyGeneratorAndGenerateKeyPair(const char *algName, HcfAsyKeyGenerator **generator, HcfKeyPair **keyPair)
254 {
255     HcfResult res = TestHcfAsyKeyGeneratorCreate(algName, generator);
256     if (res != HCF_SUCCESS) {
257         return HCF_ERR_CRYPTO_OPERATION;
258     }
259     res = TestGenerateKeyPair(*generator, keyPair);
260     if (res != HCF_SUCCESS) {
261         return HCF_ERR_CRYPTO_OPERATION;
262     }
263     return HCF_SUCCESS;
264 }
265 
TestGenerateConvertKey(HcfAsyKeyGenerator * generator,HcfBlob * pubKeyBlob,HcfBlob * priKeyBlob,HcfKeyPair ** keyPair)266 HcfResult TestGenerateConvertKey(HcfAsyKeyGenerator *generator, HcfBlob *pubKeyBlob, HcfBlob *priKeyBlob,
267     HcfKeyPair **keyPair)
268 {
269     HcfResult res = generator->convertKey(generator, NULL, pubKeyBlob, priKeyBlob, keyPair);
270     if (res != HCF_SUCCESS) {
271         return HCF_ERR_CRYPTO_OPERATION;
272     }
273     if (*keyPair == NULL) {
274         return HCF_ERR_CRYPTO_OPERATION;
275     }
276     return HCF_SUCCESS;
277 }
278 
TestGenerateKeyPairAndConvertKey(const char * algName,HcfAsyKeyGenerator ** generator,HcfBlob * pubKeyBlob,HcfBlob * priKeyBlob,HcfKeyPair ** keyPair)279 HcfResult TestGenerateKeyPairAndConvertKey(const char *algName, HcfAsyKeyGenerator **generator, HcfBlob *pubKeyBlob,
280     HcfBlob *priKeyBlob, HcfKeyPair **keyPair)
281 {
282     HcfResult res = TestKeyGeneratorAndGenerateKeyPair(algName, generator, keyPair);
283     if (res != HCF_SUCCESS) {
284         return HCF_ERR_CRYPTO_OPERATION;
285     }
286     res = TestGenerateConvertKey(*generator, pubKeyBlob, priKeyBlob, keyPair);
287     if (res != HCF_SUCCESS) {
288         return HCF_ERR_CRYPTO_OPERATION;
289     }
290     return HCF_SUCCESS;
291 }
292 
TestCreateKeyPairParamsSpecAndGeneratorBySpec(const char * algName,bool choose,HcfAsyKeyParamsSpec ** paramSpec,HcfAsyKeyGeneratorBySpec ** generator)293 HcfResult TestCreateKeyPairParamsSpecAndGeneratorBySpec(const char *algName, bool choose,
294     HcfAsyKeyParamsSpec **paramSpec, HcfAsyKeyGeneratorBySpec **generator)
295 {
296     HcfResult res = ConstructAlg25519KeyPairParamsSpec(algName, choose, paramSpec);
297     if (res != HCF_SUCCESS) {
298         return HCF_ERR_CRYPTO_OPERATION;
299     }
300     if (*paramSpec == NULL) {
301         return HCF_ERR_CRYPTO_OPERATION;
302     }
303     res = HcfAsyKeyGeneratorBySpecCreate(*paramSpec, generator);
304     if (res != HCF_SUCCESS) {
305         return HCF_ERR_CRYPTO_OPERATION;
306     }
307     if (*generator == NULL) {
308         return HCF_ERR_CRYPTO_OPERATION;
309     }
310     return HCF_SUCCESS;
311 }
312 
TestCreatePubKeyParamsSpecAndGeneratorBySpec(const char * algName,bool choose,HcfAsyKeyParamsSpec ** paramSpec,HcfAsyKeyGeneratorBySpec ** generator)313 HcfResult TestCreatePubKeyParamsSpecAndGeneratorBySpec(const char *algName, bool choose,
314     HcfAsyKeyParamsSpec **paramSpec, HcfAsyKeyGeneratorBySpec **generator)
315 {
316     HcfResult res = ConstructAlg25519PubKeyParamsSpec(algName, choose, paramSpec);
317     if (res != HCF_SUCCESS) {
318         return HCF_ERR_CRYPTO_OPERATION;
319     }
320     if (*paramSpec == NULL) {
321         return HCF_ERR_CRYPTO_OPERATION;
322     }
323     res = HcfAsyKeyGeneratorBySpecCreate(*paramSpec, generator);
324     if (res != HCF_SUCCESS) {
325         return HCF_ERR_CRYPTO_OPERATION;
326     }
327     if (*generator == NULL) {
328         return HCF_ERR_CRYPTO_OPERATION;
329     }
330     return HCF_SUCCESS;
331 }
332 
TestCreatePriKeyParamsSpecAndGeneratorBySpec(const char * algName,bool choose,HcfAsyKeyParamsSpec ** paramSpec,HcfAsyKeyGeneratorBySpec ** generator)333 HcfResult TestCreatePriKeyParamsSpecAndGeneratorBySpec(const char *algName, bool choose,
334     HcfAsyKeyParamsSpec **paramSpec, HcfAsyKeyGeneratorBySpec **generator)
335 {
336     HcfResult res = ConstructAlg25519PriKeyParamsSpec(algName, choose, paramSpec);
337     if (res != HCF_SUCCESS) {
338         return HCF_ERR_CRYPTO_OPERATION;
339     }
340     if (*paramSpec == NULL) {
341         return HCF_ERR_CRYPTO_OPERATION;
342     }
343     res = HcfAsyKeyGeneratorBySpecCreate(*paramSpec, generator);
344     if (res != HCF_SUCCESS) {
345         return HCF_ERR_CRYPTO_OPERATION;
346     }
347     if (*generator == NULL) {
348         return HCF_ERR_CRYPTO_OPERATION;
349     }
350     return HCF_SUCCESS;
351 }