1 /*
2 * This file is part of the openHiTLS project.
3 *
4 * openHiTLS is licensed under the Mulan PSL v2.
5 * You can use this software according to the terms and conditions of the Mulan PSL v2.
6 * You may obtain a copy of Mulan PSL v2 at:
7 *
8 * http://license.coscl.org.cn/MulanPSL2
9 *
10 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
11 * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
12 * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
13 * See the Mulan PSL v2 for more details.
14 */
15
16 /* BEGIN_HEADER */
17
18 #include <stdlib.h>
19 #include <stdio.h>
20 #include <string.h>
21 #include <stdint.h>
22 #include "securec.h"
23 #include "bsl_errno.h"
24 #include "bsl_obj.h"
25 #include "bsl_obj_internal.h"
26 /* END_HEADER */
27
28 extern BslOidInfo g_oidTable[];
29 extern uint32_t g_tableSize;
30 /**
31 * @test SDV_BSL_OBJ_CID_OID_FUNC_TC001
32 * @title check whether the relative sequence of cid and oid tables is corrent
33 * @expect success
34 */
35 /* BEGIN_CASE */
SDV_BSL_OBJ_CID_OID_FUNC_TC001()36 void SDV_BSL_OBJ_CID_OID_FUNC_TC001()
37 {
38 int32_t cidIndex = 0;
39 int32_t oidIndex = 0;
40 int32_t ret = 0;
41 while (cidIndex < BSL_CID_MAX && oidIndex < (int32_t)g_tableSize) {
42 if ((int32_t)g_oidTable[oidIndex].cid == cidIndex) {
43 ret++;
44 cidIndex++;
45 oidIndex++;
46 continue;
47 }
48 if ((int32_t)g_oidTable[oidIndex].cid > cidIndex) {
49 cidIndex++;
50 continue;
51 }
52 oidIndex++;
53 }
54 ASSERT_TRUE(ret == (int32_t)g_tableSize);
55 EXIT:
56 return;
57 }
58
59 /* END_CASE */
60
61 /**
62 * @test SDV_BSL_OBJ_CREATE_SIGN_ID_TC001
63 * @title Test BSL_OBJ_CreateSignId functionality
64 * @expect success
65 */
66 /* BEGIN_CASE */
SDV_BSL_OBJ_CREATE_SIGN_ID_TC001(void)67 void SDV_BSL_OBJ_CREATE_SIGN_ID_TC001(void)
68 {
69 #ifndef HITLS_BSL_HASH
70 SKIP_TEST();
71 #else
72 BslCid signId = BSL_CID_MAX - 1;
73 BslCid asymId = BSL_CID_RSA;
74 BslCid hashId = BSL_CID_MAX - 2;
75
76 TestMemInit();
77 ASSERT_EQ(BSL_OBJ_CreateSignId(signId, asymId, hashId), BSL_SUCCESS);
78
79 BslCid retrievedAsymId = BSL_OBJ_GetAsymAlgIdFromSignId(signId);
80 ASSERT_EQ(asymId, retrievedAsymId);
81
82 BslCid retrievedHashId = BSL_OBJ_GetHashIdFromSignId(signId);
83 ASSERT_EQ(hashId, retrievedHashId);
84
85 BslCid retrievedSignId = BSL_OBJ_GetSignIdFromHashAndAsymId(asymId, hashId);
86 ASSERT_EQ(signId, retrievedSignId);
87
88 ASSERT_EQ(BSL_OBJ_CreateSignId(signId, asymId, hashId), BSL_SUCCESS);
89 signId = BSL_CID_SHA256WITHRSAENCRYPTION;
90 ASSERT_EQ(BSL_OBJ_CreateSignId(signId, asymId, hashId), BSL_SUCCESS);
91
92 ASSERT_EQ(BSL_OBJ_CreateSignId(BSL_CID_UNKNOWN, asymId, hashId), BSL_INVALID_ARG);
93
94 ASSERT_EQ(BSL_OBJ_CreateSignId(signId, BSL_CID_UNKNOWN, hashId), BSL_INVALID_ARG);
95
96 ASSERT_EQ(BSL_OBJ_CreateSignId(signId, asymId, BSL_CID_UNKNOWN), BSL_INVALID_ARG);
97
98 BSL_OBJ_FreeSignHashTable();
99 EXIT:
100 return;
101 #endif
102 }
103 /* END_CASE */
104
105 /**
106 * @test SDV_BSL_OBJ_CREATE_TC001
107 * @title Test BSL_OBJ_Create functionality
108 * @expect success
109 */
110 /* BEGIN_CASE */
SDV_BSL_OBJ_CREATE_TC001()111 void SDV_BSL_OBJ_CREATE_TC001()
112 {
113 #ifndef HITLS_BSL_HASH
114 SKIP_TEST();
115 #else
116 char *testOidName = "TEST-OID";
117 BslCid testCid = BSL_CID_MAX + 1;
118 char testOidData[] = "\52\206\110\206\367\15\1\11\30";
119 BslOidString testOid = {9, testOidData, BSL_OID_GLOBAL};
120
121 const char *aesOidName = "AES128-CBC";
122 BslCid aesCid = BSL_CID_AES128_CBC;
123 char aesOidData[] = "\140\206\110\1\145\3\4\1\2";
124
125 TestMemInit();
126 ASSERT_EQ(BSL_OBJ_Create(aesOidData, 9, aesOidName, aesCid), BSL_SUCCESS);
127
128 ASSERT_EQ(BSL_OBJ_Create(testOidData, 9, testOidName, testCid), BSL_SUCCESS);
129
130 BslCid retrievedCid = BSL_OBJ_GetCID(&testOid);
131 ASSERT_EQ(testCid, retrievedCid);
132
133 BslOidString *retrievedOid = BSL_OBJ_GetOID(testCid);
134 ASSERT_TRUE(retrievedOid != NULL);
135 ASSERT_EQ(testOid.octetLen, retrievedOid->octetLen);
136 ASSERT_EQ(memcmp(testOid.octs, retrievedOid->octs, testOid.octetLen), 0);
137
138 const char *retrievedName = BSL_OBJ_GetOidNameFromOid(&testOid);
139 ASSERT_TRUE(retrievedName != NULL);
140 ASSERT_EQ(strcmp(testOidName, retrievedName), 0);
141
142 ASSERT_EQ(BSL_OBJ_Create(testOidData, 9, testOidName, testCid), BSL_SUCCESS);
143
144 ASSERT_EQ(BSL_OBJ_Create(NULL, 9, testOidName, testCid), BSL_INVALID_ARG);
145
146 ASSERT_EQ(BSL_OBJ_Create(testOidData, 9, NULL, testCid), BSL_INVALID_ARG);
147
148 ASSERT_EQ(BSL_OBJ_Create(testOidData, 9, testOidName, BSL_CID_UNKNOWN), BSL_INVALID_ARG);
149
150 BSL_OBJ_FreeHashTable();
151 EXIT:
152 return;
153 #endif
154 }
155 /* END_CASE */
156
157 /**
158 * @test SDV_BSL_OBJ_HASH_TABLE_LOOKUP_TC001
159 * @title Test hash table lookup functionality for OIDs and CIDs
160 * @expect success
161 */
162 /* BEGIN_CASE */
SDV_BSL_OBJ_HASH_TABLE_LOOKUP_TC001()163 void SDV_BSL_OBJ_HASH_TABLE_LOOKUP_TC001()
164 {
165 #ifndef HITLS_BSL_HASH
166 SKIP_TEST();
167 #else
168 int32_t ret;
169 BslOidString testOid1, testOid2;
170 const char *testOidName1 = "TEST-OID-1";
171 const char *testOidName2 = "TEST-OID-2";
172 BslCid testCid1 = BSL_CID_MAX + 1;
173 BslCid testCid2 = BSL_CID_MAX + 2;
174
175 char testOidData1[] = "\52\206\110\206\367\15\1\11\31";
176 char testOidData2[] = "\52\206\110\206\367\15\1\11\32";
177
178 testOid1.octetLen = sizeof(testOidData1);
179 testOid1.octs = testOidData1;
180 testOid1.flags = BSL_OID_GLOBAL;
181
182 testOid2.octetLen = sizeof(testOidData2);
183 testOid2.octs = testOidData2;
184 testOid2.flags = BSL_OID_GLOBAL;
185
186 TestMemInit();
187 ret = BSL_OBJ_Create(testOidData1, sizeof(testOidData1), testOidName1, testCid1);
188 ASSERT_EQ(BSL_SUCCESS, ret);
189
190 ret = BSL_OBJ_Create(testOidData2, sizeof(testOidData2), testOidName2, testCid2);
191 ASSERT_EQ(BSL_SUCCESS, ret);
192
193 BslCid retrievedCid1 = BSL_OBJ_GetCID(&testOid1);
194 ASSERT_EQ(testCid1, retrievedCid1);
195
196 BslCid retrievedCid2 = BSL_OBJ_GetCID(&testOid2);
197 ASSERT_EQ(testCid2, retrievedCid2);
198
199 BslOidString *retrievedOid1 = BSL_OBJ_GetOID(testCid1);
200 ASSERT_TRUE(retrievedOid1 != NULL);
201 ASSERT_EQ(testOid1.octetLen, retrievedOid1->octetLen);
202 ASSERT_EQ(memcmp(testOid1.octs, retrievedOid1->octs, testOid1.octetLen), 0);
203
204 BslOidString *retrievedOid2 = BSL_OBJ_GetOID(testCid2);
205 ASSERT_TRUE(retrievedOid2 != NULL);
206 ASSERT_EQ(testOid2.octetLen, retrievedOid2->octetLen);
207 ASSERT_EQ(memcmp(testOid2.octs, retrievedOid2->octs, testOid2.octetLen), 0);
208
209 const char *retrievedName1 = BSL_OBJ_GetOidNameFromOid(&testOid1);
210 ASSERT_TRUE(retrievedName1 != NULL);
211 ASSERT_EQ(strcmp(testOidName1, retrievedName1), 0);
212
213 const char *retrievedName2 = BSL_OBJ_GetOidNameFromOid(&testOid2);
214 ASSERT_TRUE(retrievedName2 != NULL);
215 ASSERT_EQ(strcmp(testOidName2, retrievedName2), 0);
216
217 BSL_OBJ_FreeHashTable();
218 EXIT:
219 return;
220 #endif
221 }
222 /* END_CASE */
223