1 /*
2 * Copyright (c) 2022 Rockchip Electronics Co. Ltd.
3 */
4
5 #include "c_model.h"
6 #include "cmode_adapter.h"
7
soft_cipher(uint32_t algo,uint32_t mode,uint32_t operation,uint8_t * key,uint32_t key_len,uint8_t * iv,uint8_t * in,uint32_t in_len,uint8_t * out)8 RK_RES soft_cipher(uint32_t algo, uint32_t mode, uint32_t operation,
9 uint8_t *key, uint32_t key_len, uint8_t *iv,
10 uint8_t *in, uint32_t in_len, uint8_t *out)
11 {
12 int ret;
13 int is_enc = (operation == RK_OP_CIPHER_ENC) ? 1 : 0;
14
15 if (algo == RK_ALGO_DES || algo == RK_ALGO_TDES) {
16 switch (mode) {
17 case RK_CIPHER_MODE_ECB:
18 ret = rk_des_ecb_encrypt(in, out, in_len, key, key_len, is_enc);
19 break;
20 case RK_CIPHER_MODE_CBC:
21 ret = rk_des_cbc_encrypt(in, out, in_len, key, key_len, iv, is_enc);
22 break;
23 case RK_CIPHER_MODE_CFB:
24 ret = rk_des_cfb_encrypt(in, out, in_len, key, key_len, iv, is_enc);
25 break;
26 case RK_CIPHER_MODE_OFB:
27 ret = rk_des_ofb_encrypt(in, out, in_len, key, key_len, iv, is_enc);
28 break;
29 default:
30 return RK_CRYPTO_ERR_PARAMETER;
31 }
32 } else if (algo == RK_ALGO_AES) {
33 switch (mode) {
34 case RK_CIPHER_MODE_ECB:
35 ret = rk_aes_ecb_encrypt(in, out, in_len, key, key_len, is_enc);
36 break;
37 case RK_CIPHER_MODE_CBC:
38 ret = rk_aes_cbc_encrypt(in, out, in_len, key, key_len, iv, is_enc);
39 break;
40 case RK_CIPHER_MODE_CFB:
41 ret = rk_aes_cfb_encrypt(in, out, in_len, key, key_len, iv, is_enc);
42 break;
43 case RK_CIPHER_MODE_OFB:
44 ret = rk_aes_ofb_encrypt(in, out, in_len, key, key_len, iv, is_enc);
45 break;
46 case RK_CIPHER_MODE_CTS:
47 ret = rk_aes_cts_encrypt(in, out, in_len, key, key_len, iv, is_enc);
48 break;
49 case RK_CIPHER_MODE_CTR:
50 ret = rk_aes_ctr_encrypt(in, out, in_len, key, key_len, iv, is_enc);
51 break;
52 case RK_CIPHER_MODE_XTS:
53 ret = rk_aes_xts_encrypt(in, out, in_len, key, key_len, iv, is_enc);
54 break;
55 default:
56 return RK_CRYPTO_ERR_PARAMETER;
57 }
58 } else if (algo == RK_ALGO_SM4) {
59 switch (mode) {
60 case RK_CIPHER_MODE_ECB:
61 ret = rk_sm4_ecb_encrypt(in, out, in_len, key, key_len, is_enc);
62 break;
63 case RK_CIPHER_MODE_CBC:
64 ret = rk_sm4_cbc_encrypt(in, out, in_len, key, key_len, iv, is_enc);
65 break;
66 case RK_CIPHER_MODE_CFB:
67 ret = rk_sm4_cfb_encrypt(in, out, in_len, key, key_len, iv, is_enc);
68 break;
69 case RK_CIPHER_MODE_OFB:
70 ret = rk_sm4_ofb_encrypt(in, out, in_len, key, key_len, iv, is_enc);
71 break;
72 case RK_CIPHER_MODE_CTS:
73 ret = rk_sm4_cts_encrypt(in, out, in_len, key, key_len, iv, is_enc);
74 break;
75 case RK_CIPHER_MODE_CTR:
76 ret = rk_sm4_ctr_encrypt(in, out, in_len, key, key_len, iv, is_enc);
77 break;
78 case RK_CIPHER_MODE_XTS:
79 ret = rk_sm4_xts_encrypt(in, out, in_len, key, key_len, iv, is_enc);
80 break;
81 default:
82 return RK_CRYPTO_ERR_PARAMETER;
83 }
84
85 } else {
86 return RK_CRYPTO_ERR_PARAMETER;
87 }
88
89 return ret == 0 ? RK_CRYPTO_SUCCESS : RK_CRYPTO_ERR_GENERIC;
90 }
91
soft_ae(uint32_t algo,uint32_t mode,uint32_t operation,uint8_t * key,uint32_t key_len,uint8_t * iv,uint32_t iv_len,uint8_t * aad,uint32_t aad_len,uint32_t tag_len,uint8_t * in,uint32_t in_len,uint8_t * out,uint8_t * tag)92 RK_RES soft_ae(uint32_t algo, uint32_t mode, uint32_t operation,
93 uint8_t *key, uint32_t key_len, uint8_t *iv, uint32_t iv_len,
94 uint8_t *aad, uint32_t aad_len, uint32_t tag_len,
95 uint8_t *in, uint32_t in_len, uint8_t *out, uint8_t *tag)
96 {
97 int ret;
98 int is_enc = (operation == RK_OP_CIPHER_ENC) ? 1 : 0;
99 struct aes_ae_in aes_in;
100 struct aes_ae_out aes_out;
101 struct sm4_ae_in sm4_in;
102 struct sm4_ae_out sm4_out;
103
104 aes_in.key = key;
105 aes_in.src = in;
106 aes_in.iv = iv;
107 aes_in.aad = aad;
108 aes_in.key_len = key_len;
109 aes_in.src_len = in_len;
110 aes_in.iv_len = iv_len;
111 aes_in.aad_len = aad_len;
112 aes_in.tag_size = tag_len;
113
114 aes_out.dest = out;
115 aes_out.tag = tag;
116
117 memcpy(&sm4_in, &aes_in, sizeof(aes_in));
118 memcpy(&sm4_out, &aes_out, sizeof(aes_out));
119
120 if (algo == RK_ALGO_AES) {
121 switch (mode) {
122 case RK_CIPHER_MODE_GCM:
123 ret = rk_aes_gcm_encrypt(&aes_in, &aes_out, is_enc);
124 break;
125 case RK_CIPHER_MODE_CCM:
126 ret = rk_aes_ccm_encrypt(&aes_in, &aes_out, is_enc);
127 break;
128 default:
129 return RK_CRYPTO_ERR_PARAMETER;
130 }
131 } else if (algo == RK_ALGO_SM4) {
132 switch (mode) {
133 case RK_CIPHER_MODE_GCM:
134 ret = rk_sm4_gcm_encrypt(&sm4_in, &sm4_out, is_enc);
135 break;
136 case RK_CIPHER_MODE_CCM:
137 ret = rk_sm4_ccm_op(&sm4_in, &sm4_out, is_enc);
138 break;
139 default:
140 return RK_CRYPTO_ERR_PARAMETER;
141 }
142
143 } else {
144 return RK_CRYPTO_ERR_PARAMETER;
145 }
146
147 return ret == 0 ? RK_CRYPTO_SUCCESS : RK_CRYPTO_ERR_GENERIC;
148 }
149
soft_hash(uint32_t algo,const uint8_t * in,uint32_t in_len,uint8_t * out,uint32_t * out_len)150 RK_RES soft_hash(uint32_t algo, const uint8_t *in, uint32_t in_len, uint8_t *out, uint32_t *out_len)
151 {
152 int ret = -1;
153
154 switch (algo) {
155 case RK_ALGO_MD5:
156 ret = rk_hash_md5(in, in_len, out, out_len);
157 break;
158 case RK_ALGO_SHA1:
159 ret = rk_hash_sha1(in, in_len, out, out_len);
160 break;
161 case RK_ALGO_SHA256:
162 ret = rk_hash_sha256(in, in_len, out, out_len);
163 break;
164 case RK_ALGO_SHA224:
165 ret = rk_hash_sha224(in, in_len, out, out_len);
166 break;
167 case RK_ALGO_SHA384:
168 ret = rk_hash_sha384(in, in_len, out, out_len);
169 break;
170 case RK_ALGO_SHA512:
171 ret = rk_hash_sha512(in, in_len, out, out_len);
172 break;
173 case RK_ALGO_SHA512_224:
174 ret = rk_hash_sha512_224(in, in_len, out, out_len);
175 break;
176 case RK_ALGO_SHA512_256:
177 ret = rk_hash_sha512_256(in, in_len, out, out_len);
178 break;
179 case RK_ALGO_SM3:
180 ret = rk_hash_sm3(in, in_len, out, out_len);
181 break;
182 default:
183 return RK_CRYPTO_ERR_PARAMETER;
184 }
185
186 return ret == 0 ? RK_CRYPTO_SUCCESS : RK_CRYPTO_ERR_GENERIC;
187 }
188
soft_hmac(uint32_t algo,const uint8_t * key,uint32_t key_len,const uint8_t * in,uint32_t in_len,uint8_t * out,uint32_t * out_len)189 RK_RES soft_hmac(uint32_t algo, const uint8_t *key, uint32_t key_len,
190 const uint8_t *in, uint32_t in_len, uint8_t *out, uint32_t *out_len)
191 {
192 int ret = -1;
193
194 switch (algo) {
195 case RK_ALGO_HMAC_MD5:
196 ret = rk_hmac_md5(key, key_len, in, in_len, out, out_len);
197 break;
198 case RK_ALGO_HMAC_SHA1:
199 ret = rk_hmac_sha1(key, key_len, in, in_len, out, out_len);
200 break;
201 case RK_ALGO_HMAC_SHA256:
202 ret = rk_hmac_sha256(key, key_len, in, in_len, out, out_len);
203 break;
204 case RK_ALGO_HMAC_SHA512:
205 ret = rk_hmac_sha512(key, key_len, in, in_len, out, out_len);
206 break;
207 case RK_ALGO_HMAC_SM3:
208 ret = rk_hmac_sm3(key, key_len, in, in_len, out, out_len);
209 break;
210 default:
211 return RK_CRYPTO_ERR_PARAMETER;
212 }
213
214 return ret == 0 ? RK_CRYPTO_SUCCESS : RK_CRYPTO_ERR_GENERIC;
215 }
216
217