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 #include <stdlib.h> 16 #include <stdio.h> 17 #include <pthread.h> 18 #include <string.h> 19 20 #include "crypto_framework_sym_cipher_test.h" 21 #include "blob.h" 22 #include "log.h" 23 #include "rand.h" 24 25 #include <gtest/gtest.h> 26 27 using namespace testing::ext; 28 namespace Unittest::CryptoFrameworkSymCipherNapiTest { 29 30 class OHCryptoFrameworkSymCipherNapiTest : public testing::Test { 31 public: SetUpTestCase()32 static void SetUpTestCase() {}; 33 TearDownTestCase()34 static void TearDownTestCase() {}; 35 }; 36 37 class SYMCIPHER_TEST : public testing::TestWithParam<SymCipherSpec> { 38 public: SetUpTestCase()39 static void SetUpTestCase() {} TearDownTestCase()40 static void TearDownTestCase() {} 41 }; 42 43 class OHCryptoFrameworkSymCipherIvErrorNapiTest : public testing::Test { 44 public: SetUpTestCase()45 static void SetUpTestCase() {}; 46 TearDownTestCase()47 static void TearDownTestCase() {}; 48 }; 49 50 class SYMCIPHER_IV_ERROR_TEST : public testing::TestWithParam<SymCipherSpec> { 51 public: SetUpTestCase()52 static void SetUpTestCase() {} TearDownTestCase()53 static void TearDownTestCase() {} 54 }; 55 56 class OHCryptoFrameworkSymCipherGcmNapiTest : public testing::Test { 57 public: SetUpTestCase()58 static void SetUpTestCase() {}; 59 TearDownTestCase()60 static void TearDownTestCase() {}; 61 }; 62 63 class OHCryptoFrameworkSymCipherCcmNapiTest : public testing::Test { 64 public: SetUpTestCase()65 static void SetUpTestCase() {}; 66 TearDownTestCase()67 static void TearDownTestCase() {}; 68 }; 69 70 class SYMCIPHER_GCM_TEST : public testing::TestWithParam<SymCipherSpec> { 71 public: SetUpTestCase()72 static void SetUpTestCase() {} TearDownTestCase()73 static void TearDownTestCase() {} 74 }; 75 76 class SYMCIPHER_CCM_TEST : public testing::TestWithParam<SymCipherSpec> { 77 public: SetUpTestCase()78 static void SetUpTestCase() {} TearDownTestCase()79 static void TearDownTestCase() {} 80 }; 81 82 SymCipherSpec g_symCipherData[] = { 83 {(uint8_t *)"AES128", (uint8_t *)"AES128|ECB|NoPadding", 0, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 84 {(uint8_t *)"AES192", (uint8_t *)"AES128|ECB|NoPadding", 0, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 85 {(uint8_t *)"AES256", (uint8_t *)"AES128|ECB|NoPadding", 0, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 86 {(uint8_t *)"AES128", (uint8_t *)"AES128|CBC|NoPadding", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 87 {(uint8_t *)"AES192", (uint8_t *)"AES128|CBC|NoPadding", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 88 {(uint8_t *)"AES256", (uint8_t *)"AES128|CBC|NoPadding", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 89 {(uint8_t *)"AES128", (uint8_t *)"AES128|CTR|NoPadding", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 90 {(uint8_t *)"AES192", (uint8_t *)"AES128|CTR|NoPadding", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 91 {(uint8_t *)"AES256", (uint8_t *)"AES128|CTR|NoPadding", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 92 {(uint8_t *)"AES128", (uint8_t *)"AES128|CFB|NoPadding", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 93 {(uint8_t *)"AES192", (uint8_t *)"AES128|CFB|NoPadding", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 94 {(uint8_t *)"AES256", (uint8_t *)"AES128|CFB|NoPadding", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 95 {(uint8_t *)"AES128", (uint8_t *)"AES128|OFB|NoPadding", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 96 {(uint8_t *)"AES192", (uint8_t *)"AES128|OFB|NoPadding", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 97 {(uint8_t *)"AES256", (uint8_t *)"AES128|OFB|NoPadding", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 98 {(uint8_t *)"3DES192", (uint8_t *)"3DES192|ECB|NoPadding", 0, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 99 {(uint8_t *)"3DES192", (uint8_t *)"3DES192|CBC|NoPadding", 8, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 100 {(uint8_t *)"3DES192", (uint8_t *)"3DES192|OFB|NoPadding", 8, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 101 {(uint8_t *)"3DES192", (uint8_t *)"3DES192|CFB|NoPadding", 8, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 102 {(uint8_t *)"SM4_128", (uint8_t *)"SM4_128|ECB|NoPadding", 0, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 103 {(uint8_t *)"SM4_128", (uint8_t *)"SM4_128|CBC|NoPadding", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 104 {(uint8_t *)"SM4_128", (uint8_t *)"SM4_128|CTR|NoPadding", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 105 {(uint8_t *)"SM4_128", (uint8_t *)"SM4_128|OFB|NoPadding", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 106 {(uint8_t *)"SM4_128", (uint8_t *)"SM4_128|CFB|NoPadding", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 107 {(uint8_t *)"SM4_128", (uint8_t *)"SM4_128|CFB128|NoPadding", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 108 109 {(uint8_t *)"AES128", (uint8_t *)"AES128|ECB|PKCS5", 0, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, // 25 110 {(uint8_t *)"AES192", (uint8_t *)"AES128|ECB|PKCS5", 0, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 111 {(uint8_t *)"AES256", (uint8_t *)"AES128|ECB|PKCS5", 0, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 112 {(uint8_t *)"AES128", (uint8_t *)"AES128|CBC|PKCS5", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 113 {(uint8_t *)"AES192", (uint8_t *)"AES128|CBC|PKCS5", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 114 {(uint8_t *)"AES256", (uint8_t *)"AES128|CBC|PKCS5", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, // 30 115 {(uint8_t *)"AES128", (uint8_t *)"AES128|CTR|PKCS5", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 116 {(uint8_t *)"AES192", (uint8_t *)"AES128|CTR|PKCS5", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 117 {(uint8_t *)"AES256", (uint8_t *)"AES128|CTR|PKCS5", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 118 {(uint8_t *)"AES128", (uint8_t *)"AES128|CFB|PKCS5", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 119 {(uint8_t *)"AES192", (uint8_t *)"AES128|CFB|PKCS5", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 120 {(uint8_t *)"AES256", (uint8_t *)"AES128|CFB|PKCS5", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 121 {(uint8_t *)"AES128", (uint8_t *)"AES128|OFB|PKCS5", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 122 {(uint8_t *)"AES192", (uint8_t *)"AES128|OFB|PKCS5", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 123 {(uint8_t *)"AES256", (uint8_t *)"AES128|OFB|PKCS5", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, // 39 124 {(uint8_t *)"3DES192", (uint8_t *)"3DES192|ECB|PKCS5", 0, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, // 40 125 {(uint8_t *)"3DES192", (uint8_t *)"3DES192|CBC|PKCS5", 8, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 126 {(uint8_t *)"3DES192", (uint8_t *)"3DES192|OFB|PKCS5", 8, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 127 {(uint8_t *)"3DES192", (uint8_t *)"3DES192|CFB|PKCS5", 8, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 128 {(uint8_t *)"SM4_128", (uint8_t *)"SM4_128|ECB|PKCS5", 0, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 129 {(uint8_t *)"SM4_128", (uint8_t *)"SM4_128|CBC|PKCS5", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 130 {(uint8_t *)"SM4_128", (uint8_t *)"SM4_128|CTR|PKCS5", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 131 {(uint8_t *)"SM4_128", (uint8_t *)"SM4_128|OFB|PKCS5", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 132 {(uint8_t *)"SM4_128", (uint8_t *)"SM4_128|CFB|PKCS5", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 133 {(uint8_t *)"SM4_128", (uint8_t *)"SM4_128|CFB128|PKCS5", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, // 49 134 135 {(uint8_t *)"AES128", (uint8_t *)"AES128|ECB|PKCS7", 0, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 136 {(uint8_t *)"AES192", (uint8_t *)"AES128|ECB|PKCS7", 0, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 137 {(uint8_t *)"AES256", (uint8_t *)"AES128|ECB|PKCS7", 0, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 138 {(uint8_t *)"AES128", (uint8_t *)"AES128|CBC|PKCS7", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 139 {(uint8_t *)"AES192", (uint8_t *)"AES128|CBC|PKCS7", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 140 {(uint8_t *)"AES256", (uint8_t *)"AES128|CBC|PKCS7", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 141 {(uint8_t *)"AES128", (uint8_t *)"AES128|CTR|PKCS7", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 142 {(uint8_t *)"AES192", (uint8_t *)"AES128|CTR|PKCS7", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 143 {(uint8_t *)"AES256", (uint8_t *)"AES128|CTR|PKCS7", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 144 {(uint8_t *)"AES128", (uint8_t *)"AES128|CFB|PKCS7", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 145 {(uint8_t *)"AES192", (uint8_t *)"AES128|CFB|PKCS7", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 146 {(uint8_t *)"AES256", (uint8_t *)"AES128|CFB|PKCS7", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 147 {(uint8_t *)"AES128", (uint8_t *)"AES128|OFB|PKCS7", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 148 {(uint8_t *)"AES192", (uint8_t *)"AES128|OFB|PKCS7", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 149 {(uint8_t *)"AES256", (uint8_t *)"AES128|OFB|PKCS7", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 150 {(uint8_t *)"3DES192", (uint8_t *)"3DES192|ECB|PKCS7", 0, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 151 {(uint8_t *)"3DES192", (uint8_t *)"3DES192|CBC|PKCS7", 8, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 152 {(uint8_t *)"3DES192", (uint8_t *)"3DES192|OFB|PKCS7", 8, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 153 {(uint8_t *)"3DES192", (uint8_t *)"3DES192|CFB|PKCS7", 8, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 154 {(uint8_t *)"SM4_128", (uint8_t *)"SM4_128|ECB|PKCS7", 0, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 155 {(uint8_t *)"SM4_128", (uint8_t *)"SM4_128|CBC|PKCS7", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 156 {(uint8_t *)"SM4_128", (uint8_t *)"SM4_128|CTR|PKCS7", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 157 {(uint8_t *)"SM4_128", (uint8_t *)"SM4_128|OFB|PKCS7", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 158 {(uint8_t *)"SM4_128", (uint8_t *)"SM4_128|CFB|PKCS7", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 159 {(uint8_t *)"SM4_128", (uint8_t *)"SM4_128|CFB128|PKCS7", 16, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 160 }; 161 162 SymCipherSpec g_symCipherGCMData[] = { 163 {(uint8_t *)"AES128", (uint8_t *)"AES128|GCM|NoPadding", 12, 16, 16, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 164 {(uint8_t *)"AES192", (uint8_t *)"AES192|GCM|NoPadding", 12, 16, 16, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 165 {(uint8_t *)"AES256", (uint8_t *)"AES256|GCM|NoPadding", 12, 16, 16, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 166 {(uint8_t *)"SM4_128", (uint8_t *)"SM4_128|GCM|NoPadding", 12, 16, 16, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 167 168 {(uint8_t *)"AES128", (uint8_t *)"AES128|GCM|PKCS5", 12, 16, 16, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 169 {(uint8_t *)"AES192", (uint8_t *)"AES192|GCM|PKCS5", 12, 16, 16, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 170 {(uint8_t *)"AES256", (uint8_t *)"AES256|GCM|PKCS5", 12, 16, 16, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 171 {(uint8_t *)"SM4_128", (uint8_t *)"SM4_128|GCM|PKCS5", 12, 16, 16, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 172 173 {(uint8_t *)"AES128", (uint8_t *)"AES128|GCM|PKCS7", 12, 16, 16, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 174 {(uint8_t *)"AES192", (uint8_t *)"AES192|GCM|PKCS7", 12, 16, 16, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 175 {(uint8_t *)"AES256", (uint8_t *)"AES256|GCM|PKCS7", 12, 16, 16, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 176 {(uint8_t *)"SM4_128", (uint8_t *)"SM4_128|GCM|PKCS7", 12, 16, 16, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 177 }; 178 179 SymCipherSpec g_symCipherCCMData[] = { 180 {(uint8_t *)"AES128", (uint8_t *)"AES128|CCM|NoPadding", 7, 8, 12, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 181 {(uint8_t *)"AES192", (uint8_t *)"AES192|CCM|NoPadding", 7, 8, 12, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 182 {(uint8_t *)"AES256", (uint8_t *)"AES256|CCM|NoPadding", 7, 8, 12, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 183 184 {(uint8_t *)"AES128", (uint8_t *)"AES128|CCM|PKCS5", 7, 8, 12, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 185 {(uint8_t *)"AES192", (uint8_t *)"AES192|CCM|PKCS5", 7, 8, 12, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 186 {(uint8_t *)"AES256", (uint8_t *)"AES256|CCM|PKCS5", 7, 8, 12, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 187 188 {(uint8_t *)"AES128", (uint8_t *)"AES128|CCM|PKCS7", 7, 8, 12, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 189 {(uint8_t *)"AES192", (uint8_t *)"AES192|CCM|PKCS7", 7, 8, 12, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 190 {(uint8_t *)"AES256", (uint8_t *)"AES256|CCM|PKCS7", 7, 8, 12, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 191 }; 192 193 SymCipherSpec g_symCipherIvError[] = { 194 {(uint8_t *)"AES128", (uint8_t *)"AES128|CBC|NoPadding", 15, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 195 {(uint8_t *)"AES192", (uint8_t *)"AES128|CBC|NoPadding", 17, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 196 {(uint8_t *)"AES128", (uint8_t *)"AES128|CTR|NoPadding", 15, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 197 {(uint8_t *)"AES192", (uint8_t *)"AES128|CTR|NoPadding", 17, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 198 {(uint8_t *)"AES128", (uint8_t *)"AES128|CFB|NoPadding", 15, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 199 {(uint8_t *)"AES192", (uint8_t *)"AES128|CFB|NoPadding", 17, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 200 {(uint8_t *)"AES128", (uint8_t *)"AES128|OFB|NoPadding", 15, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 201 {(uint8_t *)"AES192", (uint8_t *)"AES128|OFB|NoPadding", 17, 0, 0, OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE, true}, 202 }; 203 204 INSTANTIATE_TEST_CASE_P(OHCryptoFrameworkSymCipherNapiTest, SYMCIPHER_TEST, ::testing::ValuesIn(g_symCipherData)); 205 INSTANTIATE_TEST_CASE_P(OHCryptoFrameworkSymCipherGcmNapiTest, SYMCIPHER_GCM_TEST, ::testing::ValuesIn(g_symCipherGCMData)); 206 INSTANTIATE_TEST_CASE_P(OHCryptoFrameworkSymCipherCcmNapiTest, SYMCIPHER_CCM_TEST, ::testing::ValuesIn(g_symCipherCCMData)); 207 INSTANTIATE_TEST_CASE_P(OHCryptoFrameworkSymCipherIvErrorNapiTest, SYMCIPHER_IV_ERROR_TEST, ::testing::ValuesIn(g_symCipherIvError)); 208 209 /** 210 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0100 211 * @tc.name OHCryptoFrameworkSymCipherNapiTest/SYMCIPHER_TEST.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0100/x 212 * @tc.desc algorithm is Sym Cipher 213 * @tc.size Medium 214 * @tc.type Func 215 * @tc.level Level0 216 */ 217 HWTEST_P(SYMCIPHER_TEST, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0100, TestSize.Level0) 218 { 219 SymCipherSpec symCipherData = GetParam(); 220 OH_CryptoSymKeyGenerator *genCtx = nullptr; 221 OH_CryptoSymCipher *encCtx = nullptr; 222 OH_CryptoSymCipher *decCtx = nullptr; 223 OH_CryptoSymKey *keyCtx = nullptr; 224 OH_CryptoSymCipherParams *params = nullptr; 225 int32_t randomLen = symCipherData.msgLen; 226 int32_t ivLen = symCipherData.ivLen; 227 228 HcfRand *randomObj = nullptr; 229 HcfBlob msgBlob = {0}; 230 HcfBlob ivBlob = {0}; 231 Crypto_DataBlob outUpdate = {.data = nullptr, .len = 0}; 232 Crypto_DataBlob decUpdate = {.data = nullptr, .len = 0}; 233 234 HcfRandCreate(&randomObj); 235 EXPECT_TRUE(randomObj != nullptr); 236 EXPECT_EQ(randomObj->generateRandom(randomObj, randomLen, &msgBlob), HCF_SUCCESS); 237 if (ivLen != 0) { 238 EXPECT_EQ(randomObj->generateRandom(randomObj, ivLen, &ivBlob), HCF_SUCCESS); 239 } 240 // generater SymKey 241 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)symCipherData.algName, &genCtx), CRYPTO_SUCCESS); 242 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(genCtx, &keyCtx), CRYPTO_SUCCESS); 243 // params 244 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 245 if (ivLen != 0) { 246 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_SUCCESS); 247 } 248 // encrypto 249 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)symCipherData.cipherAlgName, &encCtx), CRYPTO_SUCCESS); 250 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 251 EXPECT_EQ(OH_CryptoSymCipher_Final(encCtx, (Crypto_DataBlob *)&msgBlob, &outUpdate), CRYPTO_SUCCESS); 252 // decrypto 253 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)symCipherData.cipherAlgName, &decCtx), CRYPTO_SUCCESS); 254 EXPECT_EQ(OH_CryptoSymCipher_Init(decCtx, CRYPTO_DECRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 255 EXPECT_EQ(OH_CryptoSymCipher_Final(decCtx, &outUpdate, &decUpdate), CRYPTO_SUCCESS); 256 EXPECT_TRUE(memcmp(msgBlob.data, decUpdate.data, msgBlob.len) == 0); 257 258 OH_CryptoSymCipherParams_Destroy(params); 259 OH_CryptoSymCipher_Destroy(encCtx); 260 OH_CryptoSymKeyGenerator_Destroy(genCtx); 261 OH_CryptoSymKey_Destroy(keyCtx); 262 HcfBlobDataClearAndFree((HcfBlob *)&outUpdate); 263 HcfBlobDataClearAndFree(&msgBlob); 264 HcfBlobDataClearAndFree(&ivBlob); 265 HcfBlobDataClearAndFree((HcfBlob *)&decUpdate); 266 HcfObjDestroy(randomObj); 267 } 268 269 /** 270 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0200 271 * @tc.name OHCryptoFrameworkSymCipherGcmNapiTest/SYMCIPHER_GCM_TEST.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0200/x 272 * @tc.desc algorithm is Sym Cipher 273 * @tc.size Medium 274 * @tc.type Func 275 * @tc.level Level0 276 */ 277 HWTEST_P(SYMCIPHER_GCM_TEST, Security_CryptoFramework_NAPI_SymCipher_Test_0200, TestSize.Level0) 278 { 279 SymCipherSpec symCipherAEADData = GetParam(); 280 OH_CryptoSymKeyGenerator *genCtx = nullptr; 281 OH_CryptoSymCipher *encCtx = nullptr; 282 OH_CryptoSymCipher *decCtx = nullptr; 283 OH_CryptoSymKey *keyCtx = nullptr; 284 OH_CryptoSymCipherParams *params = nullptr; 285 int32_t randomLen = symCipherAEADData.msgLen; 286 int32_t ivLen = symCipherAEADData.ivLen; 287 int32_t aadLen = symCipherAEADData.aadLen; 288 HcfRand *randomObj = nullptr; 289 HcfBlob msgBlob = {0}; 290 HcfBlob ivBlob = {0}; 291 HcfBlob aadBlob = {0}; 292 Crypto_DataBlob outUpdate = {.data = nullptr, .len = 0}; 293 Crypto_DataBlob decUpdate = {.data = nullptr, .len = 0}; 294 Crypto_DataBlob tag = {.data = nullptr, .len = 0}; 295 uint8_t tagArr[OH_CRYPTO_GCM_TAG_LEN] = {0}; 296 Crypto_DataBlob tagInit = {.data = reinterpret_cast<uint8_t *>(tagArr), .len = OH_CRYPTO_GCM_TAG_LEN}; 297 298 HcfRandCreate(&randomObj); 299 EXPECT_TRUE(randomObj != nullptr); 300 EXPECT_EQ(randomObj->generateRandom(randomObj, randomLen, &msgBlob), HCF_SUCCESS); 301 EXPECT_EQ(randomObj->generateRandom(randomObj, ivLen, &ivBlob), HCF_SUCCESS); 302 EXPECT_EQ(randomObj->generateRandom(randomObj, aadLen, &aadBlob), HCF_SUCCESS); 303 // generater SymKey 304 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)symCipherAEADData.algName, &genCtx), CRYPTO_SUCCESS); 305 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(genCtx, &keyCtx), CRYPTO_SUCCESS); 306 // params 307 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 308 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_SUCCESS); 309 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_AAD_DATABLOB, (Crypto_DataBlob *)&aadBlob), CRYPTO_SUCCESS); 310 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_TAG_DATABLOB, &tagInit), CRYPTO_SUCCESS); 311 // encrypto 312 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)symCipherAEADData.cipherAlgName, &encCtx), CRYPTO_SUCCESS); 313 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 314 EXPECT_EQ(OH_CryptoSymCipher_Update(encCtx, (Crypto_DataBlob *)&msgBlob, &outUpdate), CRYPTO_SUCCESS); 315 EXPECT_EQ(OH_CryptoSymCipher_Final(encCtx, nullptr, &tag), CRYPTO_SUCCESS); 316 // decrypto 317 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)symCipherAEADData.cipherAlgName, &decCtx), CRYPTO_SUCCESS); 318 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_TAG_DATABLOB, &tag), CRYPTO_SUCCESS); 319 EXPECT_EQ(OH_CryptoSymCipher_Init(decCtx, CRYPTO_DECRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 320 EXPECT_EQ(OH_CryptoSymCipher_Final(decCtx, &outUpdate, &decUpdate), CRYPTO_SUCCESS); 321 EXPECT_TRUE(memcmp(msgBlob.data, decUpdate.data, msgBlob.len) == 0); 322 323 OH_CryptoSymCipherParams_Destroy(params); 324 OH_CryptoSymCipher_Destroy(encCtx); 325 OH_CryptoSymKeyGenerator_Destroy(genCtx); 326 OH_CryptoSymKey_Destroy(keyCtx); 327 HcfBlobDataClearAndFree((HcfBlob *)&outUpdate); 328 HcfBlobDataClearAndFree(&msgBlob); 329 HcfBlobDataClearAndFree(&ivBlob); 330 HcfBlobDataClearAndFree(&aadBlob); 331 HcfBlobDataClearAndFree((HcfBlob *)&tag); 332 HcfBlobDataClearAndFree((HcfBlob *)&decUpdate); 333 HcfObjDestroy(randomObj); 334 } 335 336 /** 337 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0300 338 * @tc.name OHCryptoFrameworkSymCipherCcmNapiTest/SYMCIPHER_CCM_TEST.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0300/x 339 * @tc.desc algorithm is Sym Cipher 340 * @tc.size Medium 341 * @tc.type Func 342 * @tc.level Level0 343 */ 344 HWTEST_P(SYMCIPHER_CCM_TEST, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0300, TestSize.Level0) 345 { 346 SymCipherSpec symCipherAEADData = GetParam(); 347 OH_CryptoSymKeyGenerator *genCtx = nullptr; 348 OH_CryptoSymCipher *encCtx = nullptr; 349 OH_CryptoSymCipher *decCtx = nullptr; 350 OH_CryptoSymKey *keyCtx = nullptr; 351 OH_CryptoSymCipherParams *params = nullptr; 352 int32_t randomLen = symCipherAEADData.msgLen; 353 int32_t ivLen = symCipherAEADData.ivLen; 354 int32_t aadLen = symCipherAEADData.aadLen; 355 HcfRand *randomObj = nullptr; 356 HcfBlob msgBlob = {0}; 357 HcfBlob ivBlob = {0}; 358 HcfBlob aadBlob = {0}; 359 Crypto_DataBlob outUpdate = {.data = nullptr, .len = 0}; 360 Crypto_DataBlob decUpdate = {.data = nullptr, .len = 0}; 361 Crypto_DataBlob tag = {.data = nullptr, .len = 0}; 362 uint8_t tagArr[OH_CRYPTO_CCM_TAG_LEN] = {0}; 363 Crypto_DataBlob tagInit = {.data = reinterpret_cast<uint8_t *>(tagArr), .len = OH_CRYPTO_CCM_TAG_LEN}; 364 365 HcfRandCreate(&randomObj); 366 EXPECT_TRUE(randomObj != nullptr); 367 EXPECT_EQ(randomObj->generateRandom(randomObj, randomLen, &msgBlob), HCF_SUCCESS); 368 EXPECT_EQ(randomObj->generateRandom(randomObj, ivLen, &ivBlob), HCF_SUCCESS); 369 EXPECT_EQ(randomObj->generateRandom(randomObj, aadLen, &aadBlob), HCF_SUCCESS); 370 // generater SymKey 371 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)symCipherAEADData.algName, &genCtx), CRYPTO_SUCCESS); 372 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(genCtx, &keyCtx), CRYPTO_SUCCESS); 373 // params 374 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 375 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_SUCCESS); 376 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_AAD_DATABLOB, (Crypto_DataBlob *)&aadBlob), CRYPTO_SUCCESS); 377 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_TAG_DATABLOB, &tagInit), CRYPTO_SUCCESS); 378 // encrypto 379 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)symCipherAEADData.cipherAlgName, &encCtx), CRYPTO_SUCCESS); 380 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 381 EXPECT_EQ(OH_CryptoSymCipher_Update(encCtx, (Crypto_DataBlob *)&msgBlob, &outUpdate), CRYPTO_SUCCESS); 382 EXPECT_EQ(OH_CryptoSymCipher_Final(encCtx, nullptr, &tag), CRYPTO_SUCCESS); 383 // decrypto 384 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)symCipherAEADData.cipherAlgName, &decCtx), CRYPTO_SUCCESS); 385 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_TAG_DATABLOB, &tag), CRYPTO_SUCCESS); 386 EXPECT_EQ(OH_CryptoSymCipher_Init(decCtx, CRYPTO_DECRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 387 EXPECT_EQ(OH_CryptoSymCipher_Final(decCtx, &outUpdate, &decUpdate), CRYPTO_SUCCESS); 388 EXPECT_TRUE(memcmp(msgBlob.data, decUpdate.data, msgBlob.len) == 0); 389 390 OH_CryptoSymCipherParams_Destroy(params); 391 OH_CryptoSymCipher_Destroy(encCtx); 392 OH_CryptoSymKeyGenerator_Destroy(genCtx); 393 OH_CryptoSymKey_Destroy(keyCtx); 394 HcfBlobDataClearAndFree((HcfBlob *)&outUpdate); 395 HcfBlobDataClearAndFree(&msgBlob); 396 HcfBlobDataClearAndFree(&ivBlob); 397 HcfBlobDataClearAndFree(&aadBlob); 398 HcfBlobDataClearAndFree((HcfBlob *)&tag); 399 HcfBlobDataClearAndFree((HcfBlob *)&decUpdate); 400 HcfObjDestroy(randomObj); 401 } 402 403 /** 404 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0400 405 * @tc.name OHCryptoFrameworkSymCipherNapiTest/SYMCIPHER_TEST.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0400/x 406 * @tc.desc algorithm is Sym Cipher 407 * @tc.size Medium 408 * @tc.type Func 409 * @tc.level Level0 410 */ 411 HWTEST_P(SYMCIPHER_TEST, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0400, TestSize.Level0) 412 { 413 SymCipherSpec symCipherData = GetParam(); 414 OH_CryptoSymKeyGenerator *genCtx = nullptr; 415 OH_CryptoSymCipher *encCtx = nullptr; 416 OH_CryptoSymCipher *decCtx = nullptr; 417 OH_CryptoSymKey *keyCtx = nullptr; 418 OH_CryptoSymCipherParams *params = nullptr; 419 int32_t randomLen = OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE; 420 int32_t ivLen = symCipherData.ivLen; 421 int32_t cipherLen = 0; 422 423 HcfRand *randomObj = nullptr; 424 HcfBlob msgBlob = {0}; 425 HcfBlob ivBlob = {0}; 426 Crypto_DataBlob outUpdate = {.data = nullptr, .len = 0}; 427 Crypto_DataBlob decUpdate = {.data = nullptr, .len = 0}; 428 int blockSize = 20; 429 int cnt = randomLen / blockSize; 430 int rem = randomLen % blockSize; 431 uint8_t cipherText[OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE + 16] = {0}; 432 433 HcfRandCreate(&randomObj); 434 EXPECT_TRUE(randomObj != nullptr); 435 EXPECT_EQ(randomObj->generateRandom(randomObj, randomLen, &msgBlob), HCF_SUCCESS); 436 if (ivLen != 0) { 437 EXPECT_EQ(randomObj->generateRandom(randomObj, ivLen, &ivBlob), HCF_SUCCESS); 438 } 439 // generater SymKey 440 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)symCipherData.algName, &genCtx), CRYPTO_SUCCESS); 441 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(genCtx, &keyCtx), CRYPTO_SUCCESS); 442 // params 443 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 444 if (ivLen != 0) { 445 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_SUCCESS); 446 } 447 // encrypto 448 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)symCipherData.cipherAlgName, &encCtx), CRYPTO_SUCCESS); 449 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 450 for (int i = 0; i < cnt; i++) { 451 msgBlob.len = blockSize; 452 EXPECT_EQ(OH_CryptoSymCipher_Update(encCtx, (Crypto_DataBlob *)&msgBlob, &outUpdate), CRYPTO_SUCCESS); 453 msgBlob.data += blockSize; 454 memcpy(&cipherText[cipherLen], outUpdate.data, outUpdate.len); 455 cipherLen += outUpdate.len; 456 } 457 if (rem > 0) { 458 msgBlob.len = rem; 459 EXPECT_EQ(OH_CryptoSymCipher_Update(encCtx, (Crypto_DataBlob *)&msgBlob, &outUpdate), CRYPTO_SUCCESS); 460 memcpy(&cipherText[cipherLen], outUpdate.data, outUpdate.len); 461 cipherLen += outUpdate.len; 462 } 463 if (symCipherData.ispadding) { 464 EXPECT_EQ(OH_CryptoSymCipher_Final(encCtx, nullptr, &outUpdate), CRYPTO_SUCCESS); 465 memcpy(&cipherText[cipherLen], outUpdate.data, outUpdate.len); 466 cipherLen += outUpdate.len; 467 } 468 Crypto_DataBlob cipherBlob = { 469 .data = reinterpret_cast<uint8_t *>(cipherText), 470 .len = cipherLen 471 }; 472 // decrypto 473 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)symCipherData.cipherAlgName, &decCtx), CRYPTO_SUCCESS); 474 EXPECT_EQ(OH_CryptoSymCipher_Init(decCtx, CRYPTO_DECRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 475 EXPECT_EQ(OH_CryptoSymCipher_Update(decCtx, &cipherBlob, &decUpdate), CRYPTO_SUCCESS); 476 msgBlob.data -= OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE - rem; 477 msgBlob.len = OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE; 478 EXPECT_TRUE(memcmp(msgBlob.data, decUpdate.data, msgBlob.len) == 0); 479 480 OH_CryptoSymCipherParams_Destroy(params); 481 OH_CryptoSymCipher_Destroy(encCtx); 482 OH_CryptoSymKeyGenerator_Destroy(genCtx); 483 OH_CryptoSymKey_Destroy(keyCtx); 484 HcfBlobDataClearAndFree((HcfBlob *)&outUpdate); 485 HcfBlobDataClearAndFree(&msgBlob); 486 HcfBlobDataClearAndFree(&ivBlob); 487 HcfBlobDataClearAndFree((HcfBlob *)&decUpdate); 488 HcfObjDestroy(randomObj); 489 } 490 491 /** 492 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0401 493 * @tc.name OHCryptoFrameworkSymCipherGcmNapiTest/SYMCIPHER_GCM_TEST.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0401/x 494 * @tc.desc algorithm is Sym Cipher 495 * @tc.size Medium 496 * @tc.type Func 497 * @tc.level Level0 498 */ 499 HWTEST_P(SYMCIPHER_GCM_TEST, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0401, TestSize.Level0) 500 { 501 SymCipherSpec symCipherAEADData = GetParam(); 502 OH_CryptoSymKeyGenerator *genCtx = nullptr; 503 OH_CryptoSymCipher *encCtx = nullptr; 504 OH_CryptoSymCipher *decCtx = nullptr; 505 OH_CryptoSymKey *keyCtx = nullptr; 506 OH_CryptoSymCipherParams *params = nullptr; 507 int32_t randomLen = OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE; 508 int32_t ivLen = symCipherAEADData.ivLen; 509 int32_t aadLen = symCipherAEADData.aadLen; 510 HcfRand *randomObj = nullptr; 511 HcfBlob msgBlob = {0}; 512 HcfBlob ivBlob = {0}; 513 HcfBlob aadBlob = {0}; 514 Crypto_DataBlob outUpdate = {.data = nullptr, .len = 0}; 515 Crypto_DataBlob decUpdate = {.data = nullptr, .len = 0}; 516 Crypto_DataBlob tag = {.data = nullptr, .len = 0}; 517 uint8_t tagArr[OH_CRYPTO_GCM_TAG_LEN] = {0}; 518 Crypto_DataBlob tagInit = {.data = reinterpret_cast<uint8_t *>(tagArr), .len = OH_CRYPTO_GCM_TAG_LEN}; 519 int32_t cipherLen = 0; 520 int blockSize = 20; 521 int cnt = randomLen / blockSize; 522 int rem = randomLen % blockSize; 523 uint8_t cipherText[OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE + 16] = {0}; 524 525 HcfRandCreate(&randomObj); 526 EXPECT_TRUE(randomObj != nullptr); 527 EXPECT_EQ(randomObj->generateRandom(randomObj, randomLen, &msgBlob), HCF_SUCCESS); 528 EXPECT_EQ(randomObj->generateRandom(randomObj, ivLen, &ivBlob), HCF_SUCCESS); 529 EXPECT_EQ(randomObj->generateRandom(randomObj, aadLen, &aadBlob), HCF_SUCCESS); 530 // generater SymKey 531 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)symCipherAEADData.algName, &genCtx), CRYPTO_SUCCESS); 532 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(genCtx, &keyCtx), CRYPTO_SUCCESS); 533 // params 534 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 535 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_SUCCESS); 536 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_AAD_DATABLOB, (Crypto_DataBlob *)&aadBlob), CRYPTO_SUCCESS); 537 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_TAG_DATABLOB, &tagInit), CRYPTO_SUCCESS); 538 // encrypto 539 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)symCipherAEADData.cipherAlgName, &encCtx), CRYPTO_SUCCESS); 540 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 541 for (int i = 0; i < cnt; i++) { 542 msgBlob.len = blockSize; 543 EXPECT_EQ(OH_CryptoSymCipher_Update(encCtx, (Crypto_DataBlob *)&msgBlob, &outUpdate), CRYPTO_SUCCESS); 544 msgBlob.data += blockSize; 545 memcpy(&cipherText[cipherLen], outUpdate.data, outUpdate.len); 546 cipherLen += outUpdate.len; 547 } 548 if (rem > 0) { 549 msgBlob.len = rem; 550 EXPECT_EQ(OH_CryptoSymCipher_Update(encCtx, (Crypto_DataBlob *)&msgBlob, &outUpdate), CRYPTO_SUCCESS); 551 memcpy(&cipherText[cipherLen], outUpdate.data, outUpdate.len); 552 cipherLen += outUpdate.len; 553 } 554 if (symCipherAEADData.ispadding) { 555 EXPECT_EQ(OH_CryptoSymCipher_Final(encCtx, nullptr, &tag), CRYPTO_SUCCESS); 556 } 557 Crypto_DataBlob cipherBlob = { 558 .data = reinterpret_cast<uint8_t *>(cipherText), 559 .len = cipherLen 560 }; 561 562 // decrypto 563 msgBlob.data -= OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE - rem; 564 msgBlob.len = OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE; 565 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)symCipherAEADData.cipherAlgName, &decCtx), CRYPTO_SUCCESS); 566 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_TAG_DATABLOB, &tag), CRYPTO_SUCCESS); 567 EXPECT_EQ(OH_CryptoSymCipher_Init(decCtx, CRYPTO_DECRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 568 EXPECT_EQ(OH_CryptoSymCipher_Final(decCtx, &cipherBlob, &decUpdate), CRYPTO_SUCCESS); 569 EXPECT_TRUE(memcmp(msgBlob.data, decUpdate.data, msgBlob.len) == 0); 570 571 OH_CryptoSymCipherParams_Destroy(params); 572 OH_CryptoSymCipher_Destroy(encCtx); 573 OH_CryptoSymKeyGenerator_Destroy(genCtx); 574 OH_CryptoSymKey_Destroy(keyCtx); 575 HcfBlobDataClearAndFree((HcfBlob *)&outUpdate); 576 HcfBlobDataClearAndFree(&msgBlob); 577 HcfBlobDataClearAndFree(&ivBlob); 578 HcfBlobDataClearAndFree(&aadBlob); 579 HcfBlobDataClearAndFree((HcfBlob *)&tag); 580 HcfBlobDataClearAndFree((HcfBlob *)&decUpdate); 581 HcfObjDestroy(randomObj); 582 } 583 584 /** 585 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0500 586 * @tc.name OHCryptoFrameworkSymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0500 587 * @tc.desc algorithm is Sym Cipher 588 * @tc.size Medium 589 * @tc.type Func 590 * @tc.level Level0 591 */ 592 HWTEST_F(OHCryptoFrameworkSymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0500, TestSize.Level0) 593 { 594 EXPECT_EQ(OH_CryptoSymCipherParams_Create(nullptr), CRYPTO_INVALID_PARAMS); 595 } 596 597 /** 598 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0600 599 * @tc.name OHCryptoFrameworkSymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0600 600 * @tc.desc algorithm is Sym Cipher 601 * @tc.size Medium 602 * @tc.type Func 603 * @tc.level Level0 604 */ 605 HWTEST_F(OHCryptoFrameworkSymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0600, TestSize.Level0) 606 { 607 OH_CryptoSymCipherParams *params = nullptr; 608 HcfBlob ivBlob = {0}; 609 610 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 611 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(nullptr, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_INVALID_PARAMS); 612 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_IV_DATABLOB, nullptr), CRYPTO_INVALID_PARAMS); 613 614 OH_CryptoSymCipherParams_Destroy(params); 615 } 616 617 /** 618 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0700 619 * @tc.name OHCryptoFrameworkSymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0700 620 * @tc.desc algorithm is Sym Cipher 621 * @tc.size Medium 622 * @tc.type Func 623 * @tc.level Level0 624 */ 625 HWTEST_F(OHCryptoFrameworkSymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0700, TestSize.Level0) 626 { 627 OH_CryptoSymCipher *encCtx = nullptr; 628 629 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"AES128|GCM|NoPadding", nullptr), CRYPTO_INVALID_PARAMS); 630 EXPECT_EQ(OH_CryptoSymCipher_Create(nullptr, &encCtx), CRYPTO_INVALID_PARAMS); 631 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"AES128|XTS|NoPadding", &encCtx), CRYPTO_NOT_SUPPORTED); 632 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"aes128|GCM|NoPadding", &encCtx), CRYPTO_NOT_SUPPORTED); 633 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"RSA512", &encCtx), CRYPTO_INVALID_PARAMS); 634 } 635 636 /** 637 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0800 638 * @tc.name OHCryptoFrameworkSymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0800 639 * @tc.desc algorithm is Sym Cipher 640 * @tc.size Medium 641 * @tc.type Func 642 * @tc.level Level0 643 */ 644 HWTEST_F(OHCryptoFrameworkSymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0800, TestSize.Level0) 645 { 646 OH_CryptoSymKeyGenerator *genCtx = nullptr; 647 OH_CryptoSymCipher *encCtx = nullptr; 648 OH_CryptoSymKey *keyCtx = nullptr; 649 OH_CryptoSymCipherParams *params = nullptr; 650 OH_CryptoSymCipherParams *params_gcm = nullptr; 651 HcfRand *randomObj = nullptr; 652 int32_t ivLen = 16; 653 int32_t aadLen = 16; 654 HcfBlob ivBlob = {0}; 655 HcfBlob aadBlob = {0}; 656 uint8_t tagArr[OH_CRYPTO_CCM_TAG_LEN] = {0}; 657 Crypto_DataBlob tagInit = {.data = reinterpret_cast<uint8_t *>(tagArr), .len = OH_CRYPTO_CCM_TAG_LEN}; 658 659 HcfRandCreate(&randomObj); 660 EXPECT_TRUE(randomObj != nullptr); 661 EXPECT_EQ(randomObj->generateRandom(randomObj, ivLen, &ivBlob), HCF_SUCCESS); 662 EXPECT_EQ(randomObj->generateRandom(randomObj, aadLen, &aadBlob), HCF_SUCCESS); 663 664 if (ivLen != 0) { 665 EXPECT_EQ(randomObj->generateRandom(randomObj, ivLen, &ivBlob), HCF_SUCCESS); 666 } 667 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)"AES256", &genCtx), CRYPTO_SUCCESS); 668 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(genCtx, &keyCtx), CRYPTO_SUCCESS); 669 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 670 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms_gcm), CRYPTO_SUCCESS); 671 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params_gcm, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_SUCCESS); 672 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params_gcm, CRYPTO_AAD_DATABLOB, (Crypto_DataBlob *)&aadBlob), CRYPTO_SUCCESS); 673 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params_gcm, CRYPTO_TAG_DATABLOB, &tagInit), CRYPTO_SUCCESS); 674 if (ivLen != 0) { 675 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_SUCCESS); 676 } 677 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"AES256|CBC|PKCS7", &encCtx), CRYPTO_SUCCESS); 678 EXPECT_EQ(OH_CryptoSymCipher_Init(nullptr, CRYPTO_ENCRYPT_MODE, keyCtx, params), CRYPTO_INVALID_PARAMS); 679 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, nullptr, params), CRYPTO_INVALID_PARAMS); 680 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, nullptr), CRYPTO_INVALID_PARAMS); 681 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, params_gcm), CRYPTO_SUCCESS); 682 683 OH_CryptoSymCipherParams_Destroy(params); 684 OH_CryptoSymCipherParams_Destroy(params_gcm); 685 OH_CryptoSymCipher_Destroy(encCtx); 686 OH_CryptoSymKeyGenerator_Destroy(genCtx); 687 OH_CryptoSymKey_Destroy(keyCtx); 688 HcfBlobDataClearAndFree(&aadBlob); 689 HcfBlobDataClearAndFree(&ivBlob); 690 HcfObjDestroy(randomObj); 691 } 692 693 /** 694 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0900 695 * @tc.name OHCryptoFrameworkSymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0900 696 * @tc.desc algorithm is Sym Cipher 697 * @tc.size Medium 698 * @tc.type Func 699 * @tc.level Level0 700 */ 701 HWTEST_F(OHCryptoFrameworkSymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0900, TestSize.Level0) 702 { 703 OH_CryptoSymCipher *encCtx = nullptr; 704 OH_CryptoSymCipherParams *params = nullptr; 705 OH_CryptoSymKeyGenerator *genCtx = nullptr; 706 OH_CryptoSymKey *keyCtx = nullptr; 707 Crypto_DataBlob outUpdate = {.data = nullptr, .len = 0}; 708 uint8_t testData[] = "0123456789"; 709 Crypto_DataBlob msgBlob = { 710 .data = reinterpret_cast<uint8_t *>(testData), 711 .len = sizeof(testData) 712 }; 713 714 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)"AES256", &genCtx), CRYPTO_SUCCESS); 715 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(genCtx, &keyCtx), CRYPTO_SUCCESS); 716 717 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 718 719 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"AES256|ECB|PKCS7", &encCtx), CRYPTO_SUCCESS); 720 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 721 722 EXPECT_EQ(OH_CryptoSymCipher_Update(nullptr, (Crypto_DataBlob *)&msgBlob, &outUpdate), CRYPTO_INVALID_PARAMS); 723 EXPECT_EQ(OH_CryptoSymCipher_Update(encCtx, nullptr, &outUpdate), CRYPTO_INVALID_PARAMS); 724 EXPECT_EQ(OH_CryptoSymCipher_Update(encCtx, (Crypto_DataBlob *)&msgBlob, nullptr), CRYPTO_INVALID_PARAMS); 725 726 OH_CryptoSymCipherParams_Destroy(params); 727 OH_CryptoSymCipher_Destroy(encCtx); 728 OH_CryptoSymKeyGenerator_Destroy(genCtx); 729 OH_CryptoSymKey_Destroy(keyCtx); 730 } 731 732 /** 733 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1000 734 * @tc.name OHCryptoFrameworkSymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1000 735 * @tc.desc algorithm is Sym Cipher 736 * @tc.size Medium 737 * @tc.type Func 738 * @tc.level Level0 739 */ 740 HWTEST_F(OHCryptoFrameworkSymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1000, TestSize.Level0) 741 { 742 OH_CryptoSymCipher *encCtx = nullptr; 743 Crypto_DataBlob out= {.data = nullptr, .len = 0}; 744 uint8_t testData[] = "0123456789"; 745 Crypto_DataBlob msgBlob = { 746 .data = reinterpret_cast<uint8_t *>(testData), 747 .len = sizeof(testData) 748 }; 749 750 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"AES256|ECB|PKCS7", &encCtx), CRYPTO_SUCCESS); 751 EXPECT_EQ(OH_CryptoSymCipher_Final(encCtx, nullptr, &out), CRYPTO_INVALID_PARAMS); 752 EXPECT_EQ(OH_CryptoSymCipher_Final(nullptr, &msgBlob, &out), CRYPTO_INVALID_PARAMS); 753 EXPECT_EQ(OH_CryptoSymCipher_Final(encCtx, &msgBlob, nullptr), CRYPTO_INVALID_PARAMS); 754 EXPECT_EQ(OH_CryptoSymCipher_Final(encCtx, &msgBlob, &out), CRYPTO_INVALID_PARAMS); 755 756 EXPECT_EQ(OH_CryptoSymCipher_GetAlgoName(nullptr), nullptr); 757 758 OH_CryptoSymCipher_Destroy(encCtx); 759 } 760 761 /** 762 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1100 763 * @tc.name OHCryptoFrameworkSymCipherIvErrorNapiTest/SYMCIPHER_IV_ERROR_TEST.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1100/x 764 * @tc.desc algorithm is Sym Cipher 765 * @tc.size Medium 766 * @tc.type Func 767 * @tc.level Level0 768 */ 769 HWTEST_P(SYMCIPHER_IV_ERROR_TEST, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1100, TestSize.Level0) 770 { 771 SymCipherSpec symCipherData = GetParam(); 772 OH_CryptoSymKeyGenerator *genCtx = nullptr; 773 OH_CryptoSymCipher *encCtx = nullptr; 774 OH_CryptoSymKey *keyCtx = nullptr; 775 OH_CryptoSymCipherParams *params = nullptr; 776 int32_t ivLen = symCipherData.ivLen; 777 HcfRand *randomObj = nullptr; 778 HcfBlob ivBlob = {0}; 779 780 HcfRandCreate(&randomObj); 781 EXPECT_TRUE(randomObj != nullptr); 782 EXPECT_EQ(randomObj->generateRandom(randomObj, ivLen, &ivBlob), HCF_SUCCESS); 783 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)symCipherData.algName, &genCtx), CRYPTO_SUCCESS); 784 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(genCtx, &keyCtx), CRYPTO_SUCCESS); 785 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 786 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_SUCCESS); 787 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)symCipherData.cipherAlgName, &encCtx), CRYPTO_SUCCESS); 788 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, params), CRYPTO_INVALID_PARAMS); 789 790 OH_CryptoSymCipherParams_Destroy(params); 791 OH_CryptoSymCipher_Destroy(encCtx); 792 OH_CryptoSymKeyGenerator_Destroy(genCtx); 793 OH_CryptoSymKey_Destroy(keyCtx); 794 HcfBlobDataClearAndFree(&ivBlob); 795 HcfObjDestroy(randomObj); 796 } 797 798 /** 799 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1200 800 * @tc.name OHCryptoFrameworkSymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1200 801 * @tc.desc algorithm is Sym Cipher 802 * @tc.size Medium 803 * @tc.type Func 804 * @tc.level Level0 805 */ 806 HWTEST_F(OHCryptoFrameworkSymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1200, TestSize.Level0) 807 { 808 OH_CryptoSymKeyGenerator *genCtx = nullptr; 809 OH_CryptoSymCipher *encCtx = nullptr; 810 OH_CryptoSymKey *keyCtx = nullptr; 811 OH_CryptoSymCipherParams *params = nullptr; 812 int32_t ivLen = 7; 813 int32_t aadLen = 9; 814 HcfRand *randomObj = nullptr; 815 HcfBlob ivBlob = {0}; 816 HcfBlob aadBlob = {0}; 817 uint8_t tagArr[OH_CRYPTO_CCM_TAG_LEN] = {0}; 818 Crypto_DataBlob tagInit = {.data = reinterpret_cast<uint8_t *>(tagArr), .len = OH_CRYPTO_CCM_TAG_LEN}; 819 820 HcfRandCreate(&randomObj); 821 EXPECT_TRUE(randomObj != nullptr); 822 EXPECT_EQ(randomObj->generateRandom(randomObj, ivLen, &ivBlob), HCF_SUCCESS); 823 EXPECT_EQ(randomObj->generateRandom(randomObj, aadLen, &aadBlob), HCF_SUCCESS); 824 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)"AES128", &genCtx), CRYPTO_SUCCESS); 825 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(genCtx, &keyCtx), CRYPTO_SUCCESS); 826 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 827 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_SUCCESS); 828 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_AAD_DATABLOB, (Crypto_DataBlob *)&aadBlob), CRYPTO_SUCCESS); 829 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_TAG_DATABLOB, &tagInit), CRYPTO_SUCCESS); 830 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"AES128|CCM|PKCS7", &encCtx), CRYPTO_SUCCESS); 831 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 832 833 834 OH_CryptoSymCipherParams_Destroy(params); 835 OH_CryptoSymCipher_Destroy(encCtx); 836 OH_CryptoSymKeyGenerator_Destroy(genCtx); 837 OH_CryptoSymKey_Destroy(keyCtx); 838 HcfBlobDataClearAndFree(&ivBlob); 839 HcfBlobDataClearAndFree(&aadBlob); 840 HcfObjDestroy(randomObj); 841 } 842 843 /** 844 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1300 845 * @tc.name OHCryptoFrameworkSymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1300 846 * @tc.desc algorithm is Sym Cipher 847 * @tc.size Medium 848 * @tc.type Func 849 * @tc.level Level0 850 */ 851 HWTEST_F(OHCryptoFrameworkSymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1300, TestSize.Level0) 852 { 853 OH_CryptoSymKeyGenerator *genCtx = nullptr; 854 OH_CryptoSymCipher *encCtx = nullptr; 855 OH_CryptoSymCipher *decCtx = nullptr; 856 OH_CryptoSymKey *keyCtx = nullptr; 857 OH_CryptoSymCipherParams *params = nullptr; 858 int32_t randomLen = 20; 859 int32_t ivLen = 16; 860 861 HcfRand *randomObj = nullptr; 862 HcfBlob msgBlob = {0}; 863 HcfBlob ivBlob = {0}; 864 Crypto_DataBlob outUpdate = {.data = nullptr, .len = 0}; 865 Crypto_DataBlob decUpdate = {.data = nullptr, .len = 0}; 866 867 HcfRandCreate(&randomObj); 868 EXPECT_TRUE(randomObj != nullptr); 869 EXPECT_EQ(randomObj->generateRandom(randomObj, randomLen, &msgBlob), HCF_SUCCESS); 870 EXPECT_EQ(randomObj->generateRandom(randomObj, ivLen, &ivBlob), HCF_SUCCESS); 871 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)"AES128", &genCtx), CRYPTO_SUCCESS); 872 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(genCtx, &keyCtx), CRYPTO_SUCCESS); 873 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 874 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_SUCCESS); 875 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"AES128|CBC|PKCS7", &encCtx), CRYPTO_SUCCESS); 876 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 877 EXPECT_EQ(OH_CryptoSymCipher_Final(encCtx, (Crypto_DataBlob *)&msgBlob, &outUpdate), CRYPTO_SUCCESS); 878 outUpdate.data[msgBlob.len]++; 879 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"AES128|CBC|PKCS7", &decCtx), CRYPTO_SUCCESS); 880 EXPECT_EQ(OH_CryptoSymCipher_Init(decCtx, CRYPTO_DECRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 881 EXPECT_EQ(OH_CryptoSymCipher_Final(decCtx, &outUpdate, &decUpdate), CRYPTO_OPERTION_ERROR); 882 883 OH_CryptoSymCipherParams_Destroy(params); 884 OH_CryptoSymCipher_Destroy(encCtx); 885 OH_CryptoSymKeyGenerator_Destroy(genCtx); 886 OH_CryptoSymKey_Destroy(keyCtx); 887 HcfBlobDataClearAndFree((HcfBlob *)&outUpdate); 888 HcfBlobDataClearAndFree(&msgBlob); 889 HcfBlobDataClearAndFree(&ivBlob); 890 HcfBlobDataClearAndFree((HcfBlob *)&decUpdate); 891 HcfObjDestroy(randomObj); 892 } 893 894 /** 895 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1400 896 * @tc.name OHCryptoFrameworkSymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1400 897 * @tc.desc algorithm is Sym Cipher 898 * @tc.size Medium 899 * @tc.type Func 900 * @tc.level Level0 901 */ 902 HWTEST_F(OHCryptoFrameworkSymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1400, TestSize.Level0) 903 { 904 OH_CryptoSymKeyGenerator *genCtx = nullptr; 905 OH_CryptoSymCipher *encCtx = nullptr; 906 OH_CryptoSymCipher *decCtx = nullptr; 907 OH_CryptoSymKey *keyCtx = nullptr; 908 OH_CryptoSymCipherParams *params = nullptr; 909 int32_t randomLen = 20; 910 int32_t ivLen = 16; 911 912 HcfRand *randomObj = nullptr; 913 HcfBlob msgBlob = {0}; 914 HcfBlob ivBlob = {0}; 915 Crypto_DataBlob outUpdate = {.data = nullptr, .len = 0}; 916 Crypto_DataBlob decUpdate = {.data = nullptr, .len = 0}; 917 918 HcfRandCreate(&randomObj); 919 EXPECT_TRUE(randomObj != nullptr); 920 EXPECT_EQ(randomObj->generateRandom(randomObj, randomLen, &msgBlob), HCF_SUCCESS); 921 EXPECT_EQ(randomObj->generateRandom(randomObj, ivLen, &ivBlob), HCF_SUCCESS); 922 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)"AES128", &genCtx), CRYPTO_SUCCESS); 923 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(genCtx, &keyCtx), CRYPTO_SUCCESS); 924 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 925 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_SUCCESS); 926 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"AES128|CBC|PKCS7", &encCtx), CRYPTO_SUCCESS); 927 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 928 EXPECT_EQ(OH_CryptoSymCipher_Final(encCtx, (Crypto_DataBlob *)&msgBlob, &outUpdate), CRYPTO_SUCCESS); 929 outUpdate.data[randomLen - OH_CRYPTO_AES_BLOCKSIZE - 1]++; 930 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"AES128|CBC|PKCS7", &decCtx), CRYPTO_SUCCESS); 931 EXPECT_EQ(OH_CryptoSymCipher_Init(decCtx, CRYPTO_DECRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 932 EXPECT_EQ(OH_CryptoSymCipher_Final(decCtx, &outUpdate, &decUpdate), CRYPTO_SUCCESS); 933 EXPECT_TRUE(memcmp(msgBlob.data, decUpdate.data, msgBlob.len) != 0); 934 935 OH_CryptoSymCipherParams_Destroy(params); 936 OH_CryptoSymCipher_Destroy(encCtx); 937 OH_CryptoSymKeyGenerator_Destroy(genCtx); 938 OH_CryptoSymKey_Destroy(keyCtx); 939 HcfBlobDataClearAndFree((HcfBlob *)&outUpdate); 940 HcfBlobDataClearAndFree(&msgBlob); 941 HcfBlobDataClearAndFree(&ivBlob); 942 HcfBlobDataClearAndFree((HcfBlob *)&decUpdate); 943 HcfObjDestroy(randomObj); 944 } 945 946 /** 947 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1500 948 * @tc.name OHCryptoFrameworkSymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1500 949 * @tc.desc algorithm is Sym Cipher 950 * @tc.size Medium 951 * @tc.type Func 952 * @tc.level Level0 953 */ 954 HWTEST_F(OHCryptoFrameworkSymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1500, TestSize.Level0) 955 { 956 OH_CryptoSymKeyGenerator *genCtx = nullptr; 957 OH_CryptoSymCipher *encCtx = nullptr; 958 OH_CryptoSymCipher *decCtx = nullptr; 959 OH_CryptoSymKey *keyCtx = nullptr; 960 OH_CryptoSymCipherParams *params = nullptr; 961 int32_t randomLen = 20; 962 int32_t ivLen = 16; 963 964 HcfRand *randomObj = nullptr; 965 HcfBlob msgBlob = {0}; 966 HcfBlob ivBlob = {0}; 967 Crypto_DataBlob outUpdate = {.data = nullptr, .len = 0}; 968 Crypto_DataBlob decUpdate = {.data = nullptr, .len = 0}; 969 970 HcfRandCreate(&randomObj); 971 EXPECT_TRUE(randomObj != nullptr); 972 EXPECT_EQ(randomObj->generateRandom(randomObj, randomLen, &msgBlob), HCF_SUCCESS); 973 EXPECT_EQ(randomObj->generateRandom(randomObj, ivLen, &ivBlob), HCF_SUCCESS); 974 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)"AES128", &genCtx), CRYPTO_SUCCESS); 975 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(genCtx, &keyCtx), CRYPTO_SUCCESS); 976 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 977 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_SUCCESS); 978 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"AES128|CBC|PKCS7", &encCtx), CRYPTO_SUCCESS); 979 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 980 EXPECT_EQ(OH_CryptoSymCipher_Final(encCtx, (Crypto_DataBlob *)&msgBlob, &outUpdate), CRYPTO_SUCCESS); 981 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"AES128|CBC|NoPadding", &decCtx), CRYPTO_SUCCESS); 982 EXPECT_EQ(OH_CryptoSymCipher_Init(decCtx, CRYPTO_DECRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 983 EXPECT_EQ(OH_CryptoSymCipher_Final(decCtx, &outUpdate, &decUpdate), CRYPTO_SUCCESS); 984 EXPECT_TRUE(memcmp(msgBlob.data, decUpdate.data, msgBlob.len) == 0); 985 EXPECT_TRUE(msgBlob.len != decUpdate.len); 986 987 OH_CryptoSymCipherParams_Destroy(params); 988 OH_CryptoSymCipher_Destroy(encCtx); 989 OH_CryptoSymKeyGenerator_Destroy(genCtx); 990 OH_CryptoSymKey_Destroy(keyCtx); 991 HcfBlobDataClearAndFree((HcfBlob *)&outUpdate); 992 HcfBlobDataClearAndFree((HcfBlob *)&decUpdate); 993 HcfBlobDataClearAndFree(&msgBlob); 994 HcfBlobDataClearAndFree(&ivBlob); 995 HcfObjDestroy(randomObj); 996 } 997 998 /** 999 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1600 1000 * @tc.name OHCryptoFrameworkSymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1600 1001 * @tc.desc algorithm is Sym Cipher 1002 * @tc.size Medium 1003 * @tc.type Func 1004 * @tc.level Level0 1005 */ 1006 HWTEST_F(OHCryptoFrameworkSymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1600, TestSize.Level0) 1007 { 1008 OH_CryptoSymKeyGenerator *genCtx = nullptr; 1009 OH_CryptoSymCipher *encCtx = nullptr; 1010 OH_CryptoSymCipher *decCtx = nullptr; 1011 OH_CryptoSymKey *keyCtx = nullptr; 1012 OH_CryptoSymCipherParams *params = nullptr; 1013 int32_t randomLen = 64; 1014 int32_t ivLen = 16; 1015 1016 HcfRand *randomObj = nullptr; 1017 HcfBlob msgBlob = {0}; 1018 HcfBlob ivBlob = {0}; 1019 Crypto_DataBlob outUpdate = {.data = nullptr, .len = 0}; 1020 Crypto_DataBlob decUpdate = {.data = nullptr, .len = 0}; 1021 1022 HcfRandCreate(&randomObj); 1023 EXPECT_TRUE(randomObj != nullptr); 1024 EXPECT_EQ(randomObj->generateRandom(randomObj, randomLen, &msgBlob), HCF_SUCCESS); 1025 msgBlob.data[63] = 1; // 刚好符合PKCS7填充方式 1026 EXPECT_EQ(randomObj->generateRandom(randomObj, ivLen, &ivBlob), HCF_SUCCESS); 1027 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)"AES128", &genCtx), CRYPTO_SUCCESS); 1028 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(genCtx, &keyCtx), CRYPTO_SUCCESS); 1029 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 1030 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_SUCCESS); 1031 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"AES256|ECB|NoPadding", &encCtx), CRYPTO_SUCCESS); 1032 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 1033 EXPECT_EQ(OH_CryptoSymCipher_Final(encCtx, (Crypto_DataBlob *)&msgBlob, &outUpdate), CRYPTO_SUCCESS); 1034 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"AES256|ECB|PKCS7", &decCtx), CRYPTO_SUCCESS); 1035 EXPECT_EQ(OH_CryptoSymCipher_Init(decCtx, CRYPTO_DECRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 1036 EXPECT_EQ(OH_CryptoSymCipher_Final(decCtx, &outUpdate, &decUpdate), CRYPTO_SUCCESS); 1037 EXPECT_TRUE(memcmp(msgBlob.data, decUpdate.data, msgBlob.len) != 0); 1038 EXPECT_TRUE(msgBlob.len == decUpdate.len + 1); 1039 1040 OH_CryptoSymCipherParams_Destroy(params); 1041 OH_CryptoSymCipher_Destroy(encCtx); 1042 OH_CryptoSymKeyGenerator_Destroy(genCtx); 1043 OH_CryptoSymKey_Destroy(keyCtx); 1044 HcfBlobDataClearAndFree((HcfBlob *)&outUpdate); 1045 HcfBlobDataClearAndFree((HcfBlob *)&decUpdate); 1046 HcfBlobDataClearAndFree(&msgBlob); 1047 HcfBlobDataClearAndFree(&ivBlob); 1048 HcfObjDestroy(randomObj); 1049 } 1050 1051 /** 1052 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1700 1053 * @tc.name OHCryptoFrameworkSymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1700 1054 * @tc.desc algorithm is Sym Cipher 1055 * @tc.size Medium 1056 * @tc.type Func 1057 * @tc.level Level0 1058 */ 1059 HWTEST_F(OHCryptoFrameworkSymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1700, TestSize.Level0) 1060 { 1061 OH_CryptoSymKeyGenerator *genCtx = nullptr; 1062 OH_CryptoSymCipher *encCtx = nullptr; 1063 1064 OH_CryptoSymCipher *decCtx = nullptr; 1065 OH_CryptoSymKey *keyCtx = nullptr; 1066 OH_CryptoSymCipherParams *params = nullptr; 1067 int32_t randomLen = 16; 1068 int32_t ivLen = 16; 1069 1070 HcfRand *randomObj = nullptr; 1071 HcfBlob msgBlob = {0}; 1072 HcfBlob ivBlob = {0}; 1073 Crypto_DataBlob outUpdate = {.data = nullptr, .len = 0}; 1074 Crypto_DataBlob decUpdate = {.data = nullptr, .len = 0}; 1075 1076 HcfRandCreate(&randomObj); 1077 EXPECT_TRUE(randomObj != nullptr); 1078 ASSERT_EQ(randomObj->generateRandom(randomObj, randomLen, &msgBlob), HCF_SUCCESS); 1079 ASSERT_EQ(randomObj->generateRandom(randomObj, ivLen, &ivBlob), HCF_SUCCESS); 1080 ASSERT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)"AES256", &genCtx), CRYPTO_SUCCESS); 1081 ASSERT_EQ(OH_CryptoSymKeyGenerator_Generate(genCtx, &keyCtx), CRYPTO_SUCCESS); 1082 ASSERT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 1083 ASSERT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_SUCCESS); 1084 ASSERT_EQ(OH_CryptoSymCipher_Create((const char *)"AES256|ECB|NoPadding", &encCtx), CRYPTO_SUCCESS); 1085 ASSERT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 1086 ASSERT_EQ(OH_CryptoSymCipher_Final(encCtx, (Crypto_DataBlob *)&msgBlob, &outUpdate), CRYPTO_SUCCESS); 1087 ASSERT_EQ(OH_CryptoSymCipher_Create((const char *)"AES256|ECB|PKCS7", &decCtx), CRYPTO_SUCCESS); 1088 ASSERT_EQ(OH_CryptoSymCipher_Init(decCtx, CRYPTO_DECRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 1089 ASSERT_EQ(OH_CryptoSymCipher_Final(decCtx, &outUpdate, &decUpdate), CRYPTO_OPERTION_ERROR); 1090 1091 OH_CryptoSymCipherParams_Destroy(params); 1092 OH_CryptoSymCipher_Destroy(encCtx); 1093 OH_CryptoSymKeyGenerator_Destroy(genCtx); 1094 OH_CryptoSymKey_Destroy(keyCtx); 1095 HcfBlobDataClearAndFree((HcfBlob *)&outUpdate); 1096 HcfBlobDataClearAndFree((HcfBlob *)&decUpdate); 1097 HcfBlobDataClearAndFree(&msgBlob); 1098 HcfBlobDataClearAndFree(&ivBlob); 1099 HcfObjDestroy(randomObj); 1100 } 1101 1102 1103 } // namespace Unittest::CryptoFrameworkSymCipherNapiTest