1 /*
2 * Copyright (C) 2024 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 "crypto_sym_cipher.h"
17 #include "memory.h"
18 #include <stdlib.h>
19 #include "sym_key_generator.h"
20 #include "crypto_common.h"
21 #include "cipher.h"
22 #include "blob.h"
23 #include "object_base.h"
24 #include "result.h"
25 #include "native_common.h"
26
27 struct OH_CryptoSymCipher {
28 HcfObjectBase base;
29
30 HcfResult (*init)(HcfCipher *self, enum HcfCryptoMode opMode,
31 HcfKey *key, HcfParamsSpec *params);
32
33 HcfResult (*update)(HcfCipher *self, HcfBlob *input, HcfBlob *output);
34
35 HcfResult (*doFinal)(HcfCipher *self, HcfBlob *input, HcfBlob *output);
36
37 const char *(*getAlgorithm)(HcfCipher *self);
38
39 HcfResult (*setCipherSpecUint8Array)(HcfCipher *self, CipherSpecItem item, HcfBlob blob);
40
41 HcfResult (*getCipherSpecString)(HcfCipher *self, CipherSpecItem item, char **returnString);
42
43 HcfResult (*getCipherSpecUint8Array)(HcfCipher *self, CipherSpecItem item, HcfBlob *returnUint8Array);
44 };
45
46 struct OH_CryptoSymCipherParams {
47 HcfParamsSpec base;
48 HcfBlob iv;
49 HcfBlob aad;
50 HcfBlob tag;
51 };
52
53 struct OH_CryptoSymKey {
54 HcfKey key;
55
56 void (*clearMem)(HcfSymKey *self);
57 };
58
OH_CryptoSymCipherParams_Create(OH_CryptoSymCipherParams ** params)59 OH_Crypto_ErrCode OH_CryptoSymCipherParams_Create(OH_CryptoSymCipherParams **params)
60 {
61 if (params == NULL) {
62 return CRYPTO_INVALID_PARAMS;
63 }
64 *params = (OH_CryptoSymCipherParams *)HcfMalloc(sizeof(OH_CryptoSymCipherParams), 0);
65 if (*params == NULL) {
66 return CRYPTO_MEMORY_ERROR;
67 }
68 return CRYPTO_SUCCESS;
69 }
70
OH_CryptoSymCipherParams_SetParam(OH_CryptoSymCipherParams * params,CryptoSymCipher_ParamsType paramsType,Crypto_DataBlob * value)71 OH_Crypto_ErrCode OH_CryptoSymCipherParams_SetParam(OH_CryptoSymCipherParams *params,
72 CryptoSymCipher_ParamsType paramsType, Crypto_DataBlob *value)
73 {
74 if ((params == NULL) || (value == NULL)) {
75 return CRYPTO_INVALID_PARAMS;
76 }
77 switch (paramsType) {
78 case CRYPTO_IV_DATABLOB:
79 params->iv.data = value->data;
80 params->iv.len = value->len;
81 break;
82 case CRYPTO_AAD_DATABLOB:
83 params->aad.data = value->data;
84 params->aad.len = value->len;
85 break;
86 case CRYPTO_TAG_DATABLOB:
87 params->tag.data = value->data;
88 params->tag.len = value->len;
89 break;
90 default:
91 return CRYPTO_INVALID_PARAMS;
92 }
93 return CRYPTO_SUCCESS;
94 }
95
OH_CryptoSymCipherParams_Destroy(OH_CryptoSymCipherParams * params)96 void OH_CryptoSymCipherParams_Destroy(OH_CryptoSymCipherParams *params)
97 {
98 if (params == NULL) {
99 return;
100 }
101 HcfFree(params);
102 }
103
OH_CryptoSymCipher_Create(const char * algoName,OH_CryptoSymCipher ** ctx)104 OH_Crypto_ErrCode OH_CryptoSymCipher_Create(const char *algoName, OH_CryptoSymCipher **ctx)
105 {
106 if (ctx == NULL) {
107 return CRYPTO_INVALID_PARAMS;
108 }
109 HcfResult ret = HcfCipherCreate(algoName, (HcfCipher **)ctx);
110 return GetOhCryptoErrCode(ret);
111 }
112
OH_CryptoSymCipher_Init(OH_CryptoSymCipher * ctx,Crypto_CipherMode mod,OH_CryptoSymKey * key,OH_CryptoSymCipherParams * params)113 OH_Crypto_ErrCode OH_CryptoSymCipher_Init(OH_CryptoSymCipher *ctx, Crypto_CipherMode mod,
114 OH_CryptoSymKey *key, OH_CryptoSymCipherParams *params)
115 {
116 if ((ctx == NULL) || (ctx->init == NULL) || (key == NULL)) {
117 return CRYPTO_INVALID_PARAMS;
118 }
119 HcfResult ret = ctx->init((HcfCipher *)ctx, (enum HcfCryptoMode)mod, (HcfKey *)key, (HcfParamsSpec *)params);
120 return GetOhCryptoErrCode(ret);
121 }
122
OH_CryptoSymCipher_Update(OH_CryptoSymCipher * ctx,Crypto_DataBlob * in,Crypto_DataBlob * out)123 OH_Crypto_ErrCode OH_CryptoSymCipher_Update(OH_CryptoSymCipher *ctx, Crypto_DataBlob *in, Crypto_DataBlob *out)
124 {
125 if ((ctx == NULL) || (ctx->update == NULL) || (in == NULL) || (out == NULL)) {
126 return CRYPTO_INVALID_PARAMS;
127 }
128 HcfResult ret = ctx->update((HcfCipher *)ctx, (HcfBlob *)in, (HcfBlob *)out);
129 return GetOhCryptoErrCode(ret);
130 }
131
OH_CryptoSymCipher_Final(OH_CryptoSymCipher * ctx,Crypto_DataBlob * in,Crypto_DataBlob * out)132 OH_Crypto_ErrCode OH_CryptoSymCipher_Final(OH_CryptoSymCipher *ctx, Crypto_DataBlob *in, Crypto_DataBlob *out)
133 {
134 if ((ctx == NULL) || (ctx->doFinal == NULL) || (out == NULL)) {
135 return CRYPTO_INVALID_PARAMS;
136 }
137 HcfResult ret = ctx->doFinal((HcfCipher *)ctx, (HcfBlob *)in, (HcfBlob *)out);
138 return GetOhCryptoErrCode(ret);
139 }
140
OH_CryptoSymCipher_GetAlgoName(OH_CryptoSymCipher * ctx)141 const char *OH_CryptoSymCipher_GetAlgoName(OH_CryptoSymCipher *ctx)
142 {
143 if ((ctx == NULL) || (ctx->getAlgorithm == NULL)) {
144 return NULL;
145 }
146 return ctx->getAlgorithm((HcfCipher *)ctx);
147 }
148
OH_CryptoSymCipher_Destroy(OH_CryptoSymCipher * ctx)149 void OH_CryptoSymCipher_Destroy(OH_CryptoSymCipher *ctx)
150 {
151 if ((ctx == NULL) || (ctx->base.destroy == NULL)) {
152 return;
153 }
154 ctx->base.destroy((HcfObjectBase *)ctx);
155 }
156