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_CryptoSymCipher_Destroy(decCtx); 261 OH_CryptoSymKeyGenerator_Destroy(genCtx); 262 OH_CryptoSymKey_Destroy(keyCtx); 263 HcfBlobDataClearAndFree((HcfBlob *)&outUpdate); 264 HcfBlobDataClearAndFree(&msgBlob); 265 HcfBlobDataClearAndFree(&ivBlob); 266 HcfBlobDataClearAndFree((HcfBlob *)&decUpdate); 267 HcfObjDestroy(randomObj); 268 } 269 270 /** 271 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0200 272 * @tc.name OHCryptoFrameworkSymCipherGcmNapiTest/SYMCIPHER_GCM_TEST.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0200/x 273 * @tc.desc algorithm is Sym Cipher 274 * @tc.size Medium 275 * @tc.type Func 276 * @tc.level Level0 277 */ 278 HWTEST_P(SYMCIPHER_GCM_TEST, Security_CryptoFramework_NAPI_SymCipher_Test_0200, TestSize.Level0) 279 { 280 SymCipherSpec symCipherAEADData = GetParam(); 281 OH_CryptoSymKeyGenerator *genCtx = nullptr; 282 OH_CryptoSymCipher *encCtx = nullptr; 283 OH_CryptoSymCipher *decCtx = nullptr; 284 OH_CryptoSymKey *keyCtx = nullptr; 285 OH_CryptoSymCipherParams *params = nullptr; 286 int32_t randomLen = symCipherAEADData.msgLen; 287 int32_t ivLen = symCipherAEADData.ivLen; 288 int32_t aadLen = symCipherAEADData.aadLen; 289 HcfRand *randomObj = nullptr; 290 HcfBlob msgBlob = {0}; 291 HcfBlob ivBlob = {0}; 292 HcfBlob aadBlob = {0}; 293 Crypto_DataBlob outUpdate = {.data = nullptr, .len = 0}; 294 Crypto_DataBlob decUpdate = {.data = nullptr, .len = 0}; 295 Crypto_DataBlob tag = {.data = nullptr, .len = 0}; 296 uint8_t tagArr[OH_CRYPTO_GCM_TAG_LEN] = {0}; 297 Crypto_DataBlob tagInit = {.data = reinterpret_cast<uint8_t *>(tagArr), .len = OH_CRYPTO_GCM_TAG_LEN}; 298 299 HcfRandCreate(&randomObj); 300 EXPECT_TRUE(randomObj != nullptr); 301 EXPECT_EQ(randomObj->generateRandom(randomObj, randomLen, &msgBlob), HCF_SUCCESS); 302 EXPECT_EQ(randomObj->generateRandom(randomObj, ivLen, &ivBlob), HCF_SUCCESS); 303 EXPECT_EQ(randomObj->generateRandom(randomObj, aadLen, &aadBlob), HCF_SUCCESS); 304 // generater SymKey 305 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)symCipherAEADData.algName, &genCtx), CRYPTO_SUCCESS); 306 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(genCtx, &keyCtx), CRYPTO_SUCCESS); 307 // params 308 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 309 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_SUCCESS); 310 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_AAD_DATABLOB, (Crypto_DataBlob *)&aadBlob), CRYPTO_SUCCESS); 311 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_TAG_DATABLOB, &tagInit), CRYPTO_SUCCESS); 312 // encrypto 313 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)symCipherAEADData.cipherAlgName, &encCtx), CRYPTO_SUCCESS); 314 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 315 EXPECT_EQ(OH_CryptoSymCipher_Update(encCtx, (Crypto_DataBlob *)&msgBlob, &outUpdate), CRYPTO_SUCCESS); 316 EXPECT_EQ(OH_CryptoSymCipher_Final(encCtx, nullptr, &tag), CRYPTO_SUCCESS); 317 // decrypto 318 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)symCipherAEADData.cipherAlgName, &decCtx), CRYPTO_SUCCESS); 319 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_TAG_DATABLOB, &tag), CRYPTO_SUCCESS); 320 EXPECT_EQ(OH_CryptoSymCipher_Init(decCtx, CRYPTO_DECRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 321 EXPECT_EQ(OH_CryptoSymCipher_Final(decCtx, &outUpdate, &decUpdate), CRYPTO_SUCCESS); 322 EXPECT_TRUE(memcmp(msgBlob.data, decUpdate.data, msgBlob.len) == 0); 323 324 OH_CryptoSymCipherParams_Destroy(params); 325 OH_CryptoSymCipher_Destroy(encCtx); 326 OH_CryptoSymCipher_Destroy(decCtx); 327 OH_CryptoSymKeyGenerator_Destroy(genCtx); 328 OH_CryptoSymKey_Destroy(keyCtx); 329 HcfBlobDataClearAndFree((HcfBlob *)&outUpdate); 330 HcfBlobDataClearAndFree(&msgBlob); 331 HcfBlobDataClearAndFree(&ivBlob); 332 HcfBlobDataClearAndFree(&aadBlob); 333 HcfBlobDataClearAndFree((HcfBlob *)&tag); 334 HcfBlobDataClearAndFree((HcfBlob *)&decUpdate); 335 HcfObjDestroy(randomObj); 336 } 337 338 /** 339 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0300 340 * @tc.name OHCryptoFrameworkSymCipherCcmNapiTest/SYMCIPHER_CCM_TEST.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0300/x 341 * @tc.desc algorithm is Sym Cipher 342 * @tc.size Medium 343 * @tc.type Func 344 * @tc.level Level0 345 */ 346 HWTEST_P(SYMCIPHER_CCM_TEST, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0300, TestSize.Level0) 347 { 348 SymCipherSpec symCipherAEADData = GetParam(); 349 OH_CryptoSymKeyGenerator *genCtx = nullptr; 350 OH_CryptoSymCipher *encCtx = nullptr; 351 OH_CryptoSymCipher *decCtx = nullptr; 352 OH_CryptoSymKey *keyCtx = nullptr; 353 OH_CryptoSymCipherParams *params = nullptr; 354 int32_t randomLen = symCipherAEADData.msgLen; 355 int32_t ivLen = symCipherAEADData.ivLen; 356 int32_t aadLen = symCipherAEADData.aadLen; 357 HcfRand *randomObj = nullptr; 358 HcfBlob msgBlob = {0}; 359 HcfBlob ivBlob = {0}; 360 HcfBlob aadBlob = {0}; 361 Crypto_DataBlob outUpdate = {.data = nullptr, .len = 0}; 362 Crypto_DataBlob decUpdate = {.data = nullptr, .len = 0}; 363 Crypto_DataBlob tag = {.data = nullptr, .len = 0}; 364 uint8_t tagArr[OH_CRYPTO_CCM_TAG_LEN] = {0}; 365 Crypto_DataBlob tagInit = {.data = reinterpret_cast<uint8_t *>(tagArr), .len = OH_CRYPTO_CCM_TAG_LEN}; 366 367 HcfRandCreate(&randomObj); 368 EXPECT_TRUE(randomObj != nullptr); 369 EXPECT_EQ(randomObj->generateRandom(randomObj, randomLen, &msgBlob), HCF_SUCCESS); 370 EXPECT_EQ(randomObj->generateRandom(randomObj, ivLen, &ivBlob), HCF_SUCCESS); 371 EXPECT_EQ(randomObj->generateRandom(randomObj, aadLen, &aadBlob), HCF_SUCCESS); 372 // generater SymKey 373 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)symCipherAEADData.algName, &genCtx), CRYPTO_SUCCESS); 374 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(genCtx, &keyCtx), CRYPTO_SUCCESS); 375 // params 376 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 377 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_SUCCESS); 378 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_AAD_DATABLOB, (Crypto_DataBlob *)&aadBlob), CRYPTO_SUCCESS); 379 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_TAG_DATABLOB, &tagInit), CRYPTO_SUCCESS); 380 // encrypto 381 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)symCipherAEADData.cipherAlgName, &encCtx), CRYPTO_SUCCESS); 382 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 383 EXPECT_EQ(OH_CryptoSymCipher_Update(encCtx, (Crypto_DataBlob *)&msgBlob, &outUpdate), CRYPTO_SUCCESS); 384 EXPECT_EQ(OH_CryptoSymCipher_Final(encCtx, nullptr, &tag), CRYPTO_SUCCESS); 385 // decrypto 386 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)symCipherAEADData.cipherAlgName, &decCtx), CRYPTO_SUCCESS); 387 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_TAG_DATABLOB, &tag), CRYPTO_SUCCESS); 388 EXPECT_EQ(OH_CryptoSymCipher_Init(decCtx, CRYPTO_DECRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 389 EXPECT_EQ(OH_CryptoSymCipher_Final(decCtx, &outUpdate, &decUpdate), CRYPTO_SUCCESS); 390 EXPECT_TRUE(memcmp(msgBlob.data, decUpdate.data, msgBlob.len) == 0); 391 392 OH_CryptoSymCipherParams_Destroy(params); 393 OH_CryptoSymCipher_Destroy(encCtx); 394 OH_CryptoSymCipher_Destroy(decCtx); 395 OH_CryptoSymKeyGenerator_Destroy(genCtx); 396 OH_CryptoSymKey_Destroy(keyCtx); 397 HcfBlobDataClearAndFree((HcfBlob *)&outUpdate); 398 HcfBlobDataClearAndFree(&msgBlob); 399 HcfBlobDataClearAndFree(&ivBlob); 400 HcfBlobDataClearAndFree(&aadBlob); 401 HcfBlobDataClearAndFree((HcfBlob *)&tag); 402 HcfBlobDataClearAndFree((HcfBlob *)&decUpdate); 403 HcfObjDestroy(randomObj); 404 } 405 406 /** 407 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0400 408 * @tc.name OHCryptoFrameworkSymCipherNapiTest/SYMCIPHER_TEST.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0400/x 409 * @tc.desc algorithm is Sym Cipher 410 * @tc.size Medium 411 * @tc.type Func 412 * @tc.level Level0 413 */ 414 HWTEST_P(SYMCIPHER_TEST, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0400, TestSize.Level0) 415 { 416 SymCipherSpec symCipherData = GetParam(); 417 OH_CryptoSymKeyGenerator *genCtx = nullptr; 418 OH_CryptoSymCipher *encCtx = nullptr; 419 OH_CryptoSymCipher *decCtx = nullptr; 420 OH_CryptoSymKey *keyCtx = nullptr; 421 OH_CryptoSymCipherParams *params = nullptr; 422 int32_t randomLen = OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE; 423 int32_t ivLen = symCipherData.ivLen; 424 int32_t cipherLen = 0; 425 426 HcfRand *randomObj = nullptr; 427 HcfBlob msgBlob = {0}; 428 HcfBlob ivBlob = {0}; 429 Crypto_DataBlob outUpdate = {.data = nullptr, .len = 0}; 430 Crypto_DataBlob decUpdate = {.data = nullptr, .len = 0}; 431 int blockSize = 20; 432 int cnt = randomLen / blockSize; 433 int rem = randomLen % blockSize; 434 uint8_t cipherText[OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE + 16] = {0}; 435 436 HcfRandCreate(&randomObj); 437 EXPECT_TRUE(randomObj != nullptr); 438 EXPECT_EQ(randomObj->generateRandom(randomObj, randomLen, &msgBlob), HCF_SUCCESS); 439 if (ivLen != 0) { 440 EXPECT_EQ(randomObj->generateRandom(randomObj, ivLen, &ivBlob), HCF_SUCCESS); 441 } 442 // generater SymKey 443 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)symCipherData.algName, &genCtx), CRYPTO_SUCCESS); 444 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(genCtx, &keyCtx), CRYPTO_SUCCESS); 445 // params 446 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 447 if (ivLen != 0) { 448 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_SUCCESS); 449 } 450 // encrypto 451 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)symCipherData.cipherAlgName, &encCtx), CRYPTO_SUCCESS); 452 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 453 for (int i = 0; i < cnt; i++) { 454 OH_Crypto_FreeDataBlob(&outUpdate); 455 msgBlob.len = blockSize; 456 EXPECT_EQ(OH_CryptoSymCipher_Update(encCtx, (Crypto_DataBlob *)&msgBlob, &outUpdate), CRYPTO_SUCCESS); 457 msgBlob.data += blockSize; 458 memcpy(&cipherText[cipherLen], outUpdate.data, outUpdate.len); 459 cipherLen += outUpdate.len; 460 } 461 if (rem > 0) { 462 msgBlob.len = rem; 463 OH_Crypto_FreeDataBlob(&outUpdate); 464 EXPECT_EQ(OH_CryptoSymCipher_Update(encCtx, (Crypto_DataBlob *)&msgBlob, &outUpdate), CRYPTO_SUCCESS); 465 memcpy(&cipherText[cipherLen], outUpdate.data, outUpdate.len); 466 cipherLen += outUpdate.len; 467 } 468 if (symCipherData.ispadding) { 469 OH_Crypto_FreeDataBlob(&outUpdate); 470 EXPECT_EQ(OH_CryptoSymCipher_Final(encCtx, nullptr, &outUpdate), CRYPTO_SUCCESS); 471 memcpy(&cipherText[cipherLen], outUpdate.data, outUpdate.len); 472 cipherLen += outUpdate.len; 473 } 474 Crypto_DataBlob cipherBlob = { 475 .data = reinterpret_cast<uint8_t *>(cipherText), 476 .len = cipherLen 477 }; 478 // decrypto 479 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)symCipherData.cipherAlgName, &decCtx), CRYPTO_SUCCESS); 480 EXPECT_EQ(OH_CryptoSymCipher_Init(decCtx, CRYPTO_DECRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 481 EXPECT_EQ(OH_CryptoSymCipher_Update(decCtx, &cipherBlob, &decUpdate), CRYPTO_SUCCESS); 482 msgBlob.data -= OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE - rem; 483 msgBlob.len = OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE; 484 EXPECT_TRUE(memcmp(msgBlob.data, decUpdate.data, msgBlob.len) == 0); 485 486 OH_CryptoSymCipherParams_Destroy(params); 487 OH_CryptoSymCipher_Destroy(encCtx); 488 OH_CryptoSymCipher_Destroy(decCtx); 489 OH_CryptoSymKeyGenerator_Destroy(genCtx); 490 OH_CryptoSymKey_Destroy(keyCtx); 491 HcfBlobDataClearAndFree((HcfBlob *)&outUpdate); 492 HcfBlobDataClearAndFree(&msgBlob); 493 HcfBlobDataClearAndFree(&ivBlob); 494 HcfBlobDataClearAndFree((HcfBlob *)&decUpdate); 495 HcfObjDestroy(randomObj); 496 } 497 498 /** 499 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0401 500 * @tc.name OHCryptoFrameworkSymCipherGcmNapiTest/SYMCIPHER_GCM_TEST.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0401/x 501 * @tc.desc algorithm is Sym Cipher 502 * @tc.size Medium 503 * @tc.type Func 504 * @tc.level Level0 505 */ 506 HWTEST_P(SYMCIPHER_GCM_TEST, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0401, TestSize.Level0) 507 { 508 SymCipherSpec symCipherAEADData = GetParam(); 509 OH_CryptoSymKeyGenerator *genCtx = nullptr; 510 OH_CryptoSymCipher *encCtx = nullptr; 511 OH_CryptoSymCipher *decCtx = nullptr; 512 OH_CryptoSymKey *keyCtx = nullptr; 513 OH_CryptoSymCipherParams *params = nullptr; 514 int32_t randomLen = OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE; 515 int32_t ivLen = symCipherAEADData.ivLen; 516 int32_t aadLen = symCipherAEADData.aadLen; 517 HcfRand *randomObj = nullptr; 518 HcfBlob msgBlob = {0}; 519 HcfBlob ivBlob = {0}; 520 HcfBlob aadBlob = {0}; 521 Crypto_DataBlob outUpdate = {.data = nullptr, .len = 0}; 522 Crypto_DataBlob decUpdate = {.data = nullptr, .len = 0}; 523 Crypto_DataBlob tag = {.data = nullptr, .len = 0}; 524 uint8_t tagArr[OH_CRYPTO_GCM_TAG_LEN] = {0}; 525 Crypto_DataBlob tagInit = {.data = reinterpret_cast<uint8_t *>(tagArr), .len = OH_CRYPTO_GCM_TAG_LEN}; 526 int32_t cipherLen = 0; 527 int blockSize = 20; 528 int cnt = randomLen / blockSize; 529 int rem = randomLen % blockSize; 530 uint8_t cipherText[OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE + 16] = {0}; 531 532 HcfRandCreate(&randomObj); 533 EXPECT_TRUE(randomObj != nullptr); 534 EXPECT_EQ(randomObj->generateRandom(randomObj, randomLen, &msgBlob), HCF_SUCCESS); 535 EXPECT_EQ(randomObj->generateRandom(randomObj, ivLen, &ivBlob), HCF_SUCCESS); 536 EXPECT_EQ(randomObj->generateRandom(randomObj, aadLen, &aadBlob), HCF_SUCCESS); 537 // generater SymKey 538 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)symCipherAEADData.algName, &genCtx), CRYPTO_SUCCESS); 539 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(genCtx, &keyCtx), CRYPTO_SUCCESS); 540 // params 541 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 542 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_SUCCESS); 543 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_AAD_DATABLOB, (Crypto_DataBlob *)&aadBlob), CRYPTO_SUCCESS); 544 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_TAG_DATABLOB, &tagInit), CRYPTO_SUCCESS); 545 // encrypto 546 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)symCipherAEADData.cipherAlgName, &encCtx), CRYPTO_SUCCESS); 547 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 548 for (int i = 0; i < cnt; i++) { 549 msgBlob.len = blockSize; 550 OH_Crypto_FreeDataBlob(&outUpdate); 551 EXPECT_EQ(OH_CryptoSymCipher_Update(encCtx, (Crypto_DataBlob *)&msgBlob, &outUpdate), CRYPTO_SUCCESS); 552 msgBlob.data += blockSize; 553 memcpy(&cipherText[cipherLen], outUpdate.data, outUpdate.len); 554 cipherLen += outUpdate.len; 555 } 556 if (rem > 0) { 557 OH_Crypto_FreeDataBlob(&outUpdate); 558 msgBlob.len = rem; 559 EXPECT_EQ(OH_CryptoSymCipher_Update(encCtx, (Crypto_DataBlob *)&msgBlob, &outUpdate), CRYPTO_SUCCESS); 560 memcpy(&cipherText[cipherLen], outUpdate.data, outUpdate.len); 561 cipherLen += outUpdate.len; 562 } 563 if (symCipherAEADData.ispadding) { 564 EXPECT_EQ(OH_CryptoSymCipher_Final(encCtx, nullptr, &tag), CRYPTO_SUCCESS); 565 } 566 Crypto_DataBlob cipherBlob = { 567 .data = reinterpret_cast<uint8_t *>(cipherText), 568 .len = cipherLen 569 }; 570 571 // decrypto 572 msgBlob.data -= OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE - rem; 573 msgBlob.len = OH_CRYPTO_SYM_CIPHER_TEST_DATA_SIZE; 574 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)symCipherAEADData.cipherAlgName, &decCtx), CRYPTO_SUCCESS); 575 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_TAG_DATABLOB, &tag), CRYPTO_SUCCESS); 576 EXPECT_EQ(OH_CryptoSymCipher_Init(decCtx, CRYPTO_DECRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 577 EXPECT_EQ(OH_CryptoSymCipher_Final(decCtx, &cipherBlob, &decUpdate), CRYPTO_SUCCESS); 578 EXPECT_TRUE(memcmp(msgBlob.data, decUpdate.data, msgBlob.len) == 0); 579 580 OH_CryptoSymCipherParams_Destroy(params); 581 OH_CryptoSymCipher_Destroy(encCtx); 582 OH_CryptoSymCipher_Destroy(decCtx); 583 OH_CryptoSymKeyGenerator_Destroy(genCtx); 584 OH_CryptoSymKey_Destroy(keyCtx); 585 HcfBlobDataClearAndFree((HcfBlob *)&outUpdate); 586 HcfBlobDataClearAndFree(&msgBlob); 587 HcfBlobDataClearAndFree(&ivBlob); 588 HcfBlobDataClearAndFree(&aadBlob); 589 HcfBlobDataClearAndFree((HcfBlob *)&tag); 590 HcfBlobDataClearAndFree((HcfBlob *)&decUpdate); 591 HcfObjDestroy(randomObj); 592 } 593 594 /** 595 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0500 596 * @tc.name OHCryptoFrameworkSymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0500 597 * @tc.desc algorithm is Sym Cipher 598 * @tc.size Medium 599 * @tc.type Func 600 * @tc.level Level0 601 */ 602 HWTEST_F(OHCryptoFrameworkSymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0500, TestSize.Level0) 603 { 604 EXPECT_EQ(OH_CryptoSymCipherParams_Create(nullptr), CRYPTO_INVALID_PARAMS); 605 } 606 607 /** 608 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0600 609 * @tc.name OHCryptoFrameworkSymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0600 610 * @tc.desc algorithm is Sym Cipher 611 * @tc.size Medium 612 * @tc.type Func 613 * @tc.level Level0 614 */ 615 HWTEST_F(OHCryptoFrameworkSymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0600, TestSize.Level0) 616 { 617 OH_CryptoSymCipherParams *params = nullptr; 618 HcfBlob ivBlob = {0}; 619 620 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 621 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(nullptr, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_INVALID_PARAMS); 622 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_IV_DATABLOB, nullptr), CRYPTO_INVALID_PARAMS); 623 624 OH_CryptoSymCipherParams_Destroy(params); 625 } 626 627 /** 628 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0700 629 * @tc.name OHCryptoFrameworkSymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0700 630 * @tc.desc algorithm is Sym Cipher 631 * @tc.size Medium 632 * @tc.type Func 633 * @tc.level Level0 634 */ 635 HWTEST_F(OHCryptoFrameworkSymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0700, TestSize.Level0) 636 { 637 OH_CryptoSymCipher *encCtx = nullptr; 638 639 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"AES128|GCM|NoPadding", nullptr), CRYPTO_INVALID_PARAMS); 640 EXPECT_EQ(OH_CryptoSymCipher_Create(nullptr, &encCtx), CRYPTO_INVALID_PARAMS); 641 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"AES128|XTS|NoPadding", &encCtx), CRYPTO_NOT_SUPPORTED); 642 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"aes128|GCM|NoPadding", &encCtx), CRYPTO_NOT_SUPPORTED); 643 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"RSA512", &encCtx), CRYPTO_INVALID_PARAMS); 644 } 645 646 /** 647 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0800 648 * @tc.name OHCryptoFrameworkSymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0800 649 * @tc.desc algorithm is Sym Cipher 650 * @tc.size Medium 651 * @tc.type Func 652 * @tc.level Level0 653 */ 654 HWTEST_F(OHCryptoFrameworkSymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0800, TestSize.Level0) 655 { 656 OH_CryptoSymKeyGenerator *genCtx = nullptr; 657 OH_CryptoSymCipher *encCtx = nullptr; 658 OH_CryptoSymKey *keyCtx = nullptr; 659 OH_CryptoSymCipherParams *params = nullptr; 660 OH_CryptoSymCipherParams *params_gcm = nullptr; 661 HcfRand *randomObj = nullptr; 662 int32_t ivLen = 16; 663 int32_t aadLen = 16; 664 HcfBlob ivBlob = {0}; 665 HcfBlob aadBlob = {0}; 666 uint8_t tagArr[OH_CRYPTO_CCM_TAG_LEN] = {0}; 667 Crypto_DataBlob tagInit = {.data = reinterpret_cast<uint8_t *>(tagArr), .len = OH_CRYPTO_CCM_TAG_LEN}; 668 669 HcfRandCreate(&randomObj); 670 EXPECT_TRUE(randomObj != nullptr); 671 EXPECT_EQ(randomObj->generateRandom(randomObj, aadLen, &aadBlob), HCF_SUCCESS); 672 673 if (ivLen != 0) { 674 EXPECT_EQ(randomObj->generateRandom(randomObj, ivLen, &ivBlob), HCF_SUCCESS); 675 } 676 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)"AES256", &genCtx), CRYPTO_SUCCESS); 677 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(genCtx, &keyCtx), CRYPTO_SUCCESS); 678 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 679 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms_gcm), CRYPTO_SUCCESS); 680 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params_gcm, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_SUCCESS); 681 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params_gcm, CRYPTO_AAD_DATABLOB, (Crypto_DataBlob *)&aadBlob), CRYPTO_SUCCESS); 682 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params_gcm, CRYPTO_TAG_DATABLOB, &tagInit), CRYPTO_SUCCESS); 683 if (ivLen != 0) { 684 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_SUCCESS); 685 } 686 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"AES256|CBC|PKCS7", &encCtx), CRYPTO_SUCCESS); 687 EXPECT_EQ(OH_CryptoSymCipher_Init(nullptr, CRYPTO_ENCRYPT_MODE, keyCtx, params), CRYPTO_INVALID_PARAMS); 688 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, nullptr, params), CRYPTO_INVALID_PARAMS); 689 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, nullptr), CRYPTO_INVALID_PARAMS); 690 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, params_gcm), CRYPTO_SUCCESS); 691 692 OH_CryptoSymCipherParams_Destroy(params); 693 OH_CryptoSymCipherParams_Destroy(params_gcm); 694 OH_CryptoSymCipher_Destroy(encCtx); 695 OH_CryptoSymKeyGenerator_Destroy(genCtx); 696 OH_CryptoSymKey_Destroy(keyCtx); 697 HcfBlobDataClearAndFree(&aadBlob); 698 HcfBlobDataClearAndFree(&ivBlob); 699 HcfObjDestroy(randomObj); 700 } 701 702 /** 703 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0900 704 * @tc.name OHCryptoFrameworkSymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0900 705 * @tc.desc algorithm is Sym Cipher 706 * @tc.size Medium 707 * @tc.type Func 708 * @tc.level Level0 709 */ 710 HWTEST_F(OHCryptoFrameworkSymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_0900, TestSize.Level0) 711 { 712 OH_CryptoSymCipher *encCtx = nullptr; 713 OH_CryptoSymCipherParams *params = nullptr; 714 OH_CryptoSymKeyGenerator *genCtx = nullptr; 715 OH_CryptoSymKey *keyCtx = nullptr; 716 Crypto_DataBlob outUpdate = {.data = nullptr, .len = 0}; 717 uint8_t testData[] = "0123456789"; 718 Crypto_DataBlob msgBlob = { 719 .data = reinterpret_cast<uint8_t *>(testData), 720 .len = sizeof(testData) 721 }; 722 723 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)"AES256", &genCtx), CRYPTO_SUCCESS); 724 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(genCtx, &keyCtx), CRYPTO_SUCCESS); 725 726 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 727 728 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"AES256|ECB|PKCS7", &encCtx), CRYPTO_SUCCESS); 729 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 730 731 EXPECT_EQ(OH_CryptoSymCipher_Update(nullptr, (Crypto_DataBlob *)&msgBlob, &outUpdate), CRYPTO_INVALID_PARAMS); 732 EXPECT_EQ(OH_CryptoSymCipher_Update(encCtx, nullptr, &outUpdate), CRYPTO_INVALID_PARAMS); 733 EXPECT_EQ(OH_CryptoSymCipher_Update(encCtx, (Crypto_DataBlob *)&msgBlob, nullptr), CRYPTO_INVALID_PARAMS); 734 735 OH_CryptoSymCipherParams_Destroy(params); 736 OH_CryptoSymCipher_Destroy(encCtx); 737 OH_CryptoSymKeyGenerator_Destroy(genCtx); 738 OH_CryptoSymKey_Destroy(keyCtx); 739 } 740 741 /** 742 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1000 743 * @tc.name OHCryptoFrameworkSymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1000 744 * @tc.desc algorithm is Sym Cipher 745 * @tc.size Medium 746 * @tc.type Func 747 * @tc.level Level0 748 */ 749 HWTEST_F(OHCryptoFrameworkSymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1000, TestSize.Level0) 750 { 751 OH_CryptoSymCipher *encCtx = nullptr; 752 Crypto_DataBlob out= {.data = nullptr, .len = 0}; 753 uint8_t testData[] = "0123456789"; 754 Crypto_DataBlob msgBlob = { 755 .data = reinterpret_cast<uint8_t *>(testData), 756 .len = sizeof(testData) 757 }; 758 759 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"AES256|ECB|PKCS7", &encCtx), CRYPTO_SUCCESS); 760 EXPECT_EQ(OH_CryptoSymCipher_Final(encCtx, nullptr, &out), CRYPTO_INVALID_PARAMS); 761 EXPECT_EQ(OH_CryptoSymCipher_Final(nullptr, &msgBlob, &out), CRYPTO_INVALID_PARAMS); 762 EXPECT_EQ(OH_CryptoSymCipher_Final(encCtx, &msgBlob, nullptr), CRYPTO_INVALID_PARAMS); 763 EXPECT_EQ(OH_CryptoSymCipher_Final(encCtx, &msgBlob, &out), CRYPTO_INVALID_PARAMS); 764 765 EXPECT_EQ(OH_CryptoSymCipher_GetAlgoName(nullptr), nullptr); 766 767 OH_CryptoSymCipher_Destroy(encCtx); 768 } 769 770 /** 771 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1100 772 * @tc.name OHCryptoFrameworkSymCipherIvErrorNapiTest/SYMCIPHER_IV_ERROR_TEST.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1100/x 773 * @tc.desc algorithm is Sym Cipher 774 * @tc.size Medium 775 * @tc.type Func 776 * @tc.level Level0 777 */ 778 HWTEST_P(SYMCIPHER_IV_ERROR_TEST, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1100, TestSize.Level0) 779 { 780 SymCipherSpec symCipherData = GetParam(); 781 OH_CryptoSymKeyGenerator *genCtx = nullptr; 782 OH_CryptoSymCipher *encCtx = nullptr; 783 OH_CryptoSymKey *keyCtx = nullptr; 784 OH_CryptoSymCipherParams *params = nullptr; 785 int32_t ivLen = symCipherData.ivLen; 786 HcfRand *randomObj = nullptr; 787 HcfBlob ivBlob = {0}; 788 789 HcfRandCreate(&randomObj); 790 EXPECT_TRUE(randomObj != nullptr); 791 EXPECT_EQ(randomObj->generateRandom(randomObj, ivLen, &ivBlob), HCF_SUCCESS); 792 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)symCipherData.algName, &genCtx), CRYPTO_SUCCESS); 793 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(genCtx, &keyCtx), CRYPTO_SUCCESS); 794 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 795 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_SUCCESS); 796 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)symCipherData.cipherAlgName, &encCtx), CRYPTO_SUCCESS); 797 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, params), CRYPTO_INVALID_PARAMS); 798 799 OH_CryptoSymCipherParams_Destroy(params); 800 OH_CryptoSymCipher_Destroy(encCtx); 801 OH_CryptoSymKeyGenerator_Destroy(genCtx); 802 OH_CryptoSymKey_Destroy(keyCtx); 803 HcfBlobDataClearAndFree(&ivBlob); 804 HcfObjDestroy(randomObj); 805 } 806 807 /** 808 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1200 809 * @tc.name OHCryptoFrameworkSymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1200 810 * @tc.desc algorithm is Sym Cipher 811 * @tc.size Medium 812 * @tc.type Func 813 * @tc.level Level0 814 */ 815 HWTEST_F(OHCryptoFrameworkSymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1200, TestSize.Level0) 816 { 817 OH_CryptoSymKeyGenerator *genCtx = nullptr; 818 OH_CryptoSymCipher *encCtx = nullptr; 819 OH_CryptoSymKey *keyCtx = nullptr; 820 OH_CryptoSymCipherParams *params = nullptr; 821 int32_t ivLen = 7; 822 int32_t aadLen = 9; 823 HcfRand *randomObj = nullptr; 824 HcfBlob ivBlob = {0}; 825 HcfBlob aadBlob = {0}; 826 uint8_t tagArr[OH_CRYPTO_CCM_TAG_LEN] = {0}; 827 Crypto_DataBlob tagInit = {.data = reinterpret_cast<uint8_t *>(tagArr), .len = OH_CRYPTO_CCM_TAG_LEN}; 828 829 HcfRandCreate(&randomObj); 830 EXPECT_TRUE(randomObj != nullptr); 831 EXPECT_EQ(randomObj->generateRandom(randomObj, ivLen, &ivBlob), HCF_SUCCESS); 832 EXPECT_EQ(randomObj->generateRandom(randomObj, aadLen, &aadBlob), HCF_SUCCESS); 833 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)"AES128", &genCtx), CRYPTO_SUCCESS); 834 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(genCtx, &keyCtx), CRYPTO_SUCCESS); 835 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 836 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_SUCCESS); 837 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_AAD_DATABLOB, (Crypto_DataBlob *)&aadBlob), CRYPTO_SUCCESS); 838 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_TAG_DATABLOB, &tagInit), CRYPTO_SUCCESS); 839 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"AES128|CCM|PKCS7", &encCtx), CRYPTO_SUCCESS); 840 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 841 842 843 OH_CryptoSymCipherParams_Destroy(params); 844 OH_CryptoSymCipher_Destroy(encCtx); 845 OH_CryptoSymKeyGenerator_Destroy(genCtx); 846 OH_CryptoSymKey_Destroy(keyCtx); 847 HcfBlobDataClearAndFree(&ivBlob); 848 HcfBlobDataClearAndFree(&aadBlob); 849 HcfObjDestroy(randomObj); 850 } 851 852 /** 853 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1300 854 * @tc.name OHCryptoFrameworkSymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1300 855 * @tc.desc algorithm is Sym Cipher 856 * @tc.size Medium 857 * @tc.type Func 858 * @tc.level Level0 859 */ 860 HWTEST_F(OHCryptoFrameworkSymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1300, TestSize.Level0) 861 { 862 OH_CryptoSymKeyGenerator *genCtx = nullptr; 863 OH_CryptoSymCipher *encCtx = nullptr; 864 OH_CryptoSymCipher *decCtx = nullptr; 865 OH_CryptoSymKey *keyCtx = nullptr; 866 OH_CryptoSymCipherParams *params = nullptr; 867 int32_t randomLen = 20; 868 int32_t ivLen = 16; 869 870 HcfRand *randomObj = nullptr; 871 HcfBlob msgBlob = {0}; 872 HcfBlob ivBlob = {0}; 873 Crypto_DataBlob outUpdate = {.data = nullptr, .len = 0}; 874 Crypto_DataBlob decUpdate = {.data = nullptr, .len = 0}; 875 876 HcfRandCreate(&randomObj); 877 EXPECT_TRUE(randomObj != nullptr); 878 EXPECT_EQ(randomObj->generateRandom(randomObj, randomLen, &msgBlob), HCF_SUCCESS); 879 EXPECT_EQ(randomObj->generateRandom(randomObj, ivLen, &ivBlob), HCF_SUCCESS); 880 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)"AES128", &genCtx), CRYPTO_SUCCESS); 881 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(genCtx, &keyCtx), CRYPTO_SUCCESS); 882 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 883 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_SUCCESS); 884 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"AES128|CBC|PKCS7", &encCtx), CRYPTO_SUCCESS); 885 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 886 EXPECT_EQ(OH_CryptoSymCipher_Final(encCtx, (Crypto_DataBlob *)&msgBlob, &outUpdate), CRYPTO_SUCCESS); 887 outUpdate.data[msgBlob.len]++; 888 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"AES128|CBC|PKCS7", &decCtx), CRYPTO_SUCCESS); 889 EXPECT_EQ(OH_CryptoSymCipher_Init(decCtx, CRYPTO_DECRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 890 EXPECT_EQ(OH_CryptoSymCipher_Final(decCtx, &outUpdate, &decUpdate), CRYPTO_OPERTION_ERROR); 891 892 OH_CryptoSymCipherParams_Destroy(params); 893 OH_CryptoSymCipher_Destroy(encCtx); 894 OH_CryptoSymCipher_Destroy(decCtx); 895 OH_CryptoSymKeyGenerator_Destroy(genCtx); 896 OH_CryptoSymKey_Destroy(keyCtx); 897 HcfBlobDataClearAndFree((HcfBlob *)&outUpdate); 898 HcfBlobDataClearAndFree(&msgBlob); 899 HcfBlobDataClearAndFree(&ivBlob); 900 HcfBlobDataClearAndFree((HcfBlob *)&decUpdate); 901 HcfObjDestroy(randomObj); 902 } 903 904 /** 905 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1400 906 * @tc.name OHCryptoFrameworkSymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1400 907 * @tc.desc algorithm is Sym Cipher 908 * @tc.size Medium 909 * @tc.type Func 910 * @tc.level Level0 911 */ 912 HWTEST_F(OHCryptoFrameworkSymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1400, TestSize.Level0) 913 { 914 OH_CryptoSymKeyGenerator *genCtx = nullptr; 915 OH_CryptoSymCipher *encCtx = nullptr; 916 OH_CryptoSymCipher *decCtx = nullptr; 917 OH_CryptoSymKey *keyCtx = nullptr; 918 OH_CryptoSymCipherParams *params = nullptr; 919 int32_t randomLen = 20; 920 int32_t ivLen = 16; 921 922 HcfRand *randomObj = nullptr; 923 HcfBlob msgBlob = {0}; 924 HcfBlob ivBlob = {0}; 925 Crypto_DataBlob outUpdate = {.data = nullptr, .len = 0}; 926 Crypto_DataBlob decUpdate = {.data = nullptr, .len = 0}; 927 928 HcfRandCreate(&randomObj); 929 EXPECT_TRUE(randomObj != nullptr); 930 EXPECT_EQ(randomObj->generateRandom(randomObj, randomLen, &msgBlob), HCF_SUCCESS); 931 EXPECT_EQ(randomObj->generateRandom(randomObj, ivLen, &ivBlob), HCF_SUCCESS); 932 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)"AES128", &genCtx), CRYPTO_SUCCESS); 933 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(genCtx, &keyCtx), CRYPTO_SUCCESS); 934 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 935 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_SUCCESS); 936 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"AES128|CBC|PKCS7", &encCtx), CRYPTO_SUCCESS); 937 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 938 EXPECT_EQ(OH_CryptoSymCipher_Final(encCtx, (Crypto_DataBlob *)&msgBlob, &outUpdate), CRYPTO_SUCCESS); 939 outUpdate.data[randomLen - OH_CRYPTO_AES_BLOCKSIZE - 1]++; 940 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"AES128|CBC|PKCS7", &decCtx), CRYPTO_SUCCESS); 941 EXPECT_EQ(OH_CryptoSymCipher_Init(decCtx, CRYPTO_DECRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 942 EXPECT_EQ(OH_CryptoSymCipher_Final(decCtx, &outUpdate, &decUpdate), CRYPTO_SUCCESS); 943 EXPECT_TRUE(memcmp(msgBlob.data, decUpdate.data, msgBlob.len) != 0); 944 945 OH_CryptoSymCipherParams_Destroy(params); 946 OH_CryptoSymCipher_Destroy(encCtx); 947 OH_CryptoSymCipher_Destroy(decCtx); 948 OH_CryptoSymKeyGenerator_Destroy(genCtx); 949 OH_CryptoSymKey_Destroy(keyCtx); 950 HcfBlobDataClearAndFree((HcfBlob *)&outUpdate); 951 HcfBlobDataClearAndFree(&msgBlob); 952 HcfBlobDataClearAndFree(&ivBlob); 953 HcfBlobDataClearAndFree((HcfBlob *)&decUpdate); 954 HcfObjDestroy(randomObj); 955 } 956 957 /** 958 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1500 959 * @tc.name OHCryptoFrameworkSymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1500 960 * @tc.desc algorithm is Sym Cipher 961 * @tc.size Medium 962 * @tc.type Func 963 * @tc.level Level0 964 */ 965 HWTEST_F(OHCryptoFrameworkSymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1500, TestSize.Level0) 966 { 967 OH_CryptoSymKeyGenerator *genCtx = nullptr; 968 OH_CryptoSymCipher *encCtx = nullptr; 969 OH_CryptoSymCipher *decCtx = nullptr; 970 OH_CryptoSymKey *keyCtx = nullptr; 971 OH_CryptoSymCipherParams *params = nullptr; 972 int32_t randomLen = 20; 973 int32_t ivLen = 16; 974 975 HcfRand *randomObj = nullptr; 976 HcfBlob msgBlob = {0}; 977 HcfBlob ivBlob = {0}; 978 Crypto_DataBlob outUpdate = {.data = nullptr, .len = 0}; 979 Crypto_DataBlob decUpdate = {.data = nullptr, .len = 0}; 980 981 HcfRandCreate(&randomObj); 982 EXPECT_TRUE(randomObj != nullptr); 983 EXPECT_EQ(randomObj->generateRandom(randomObj, randomLen, &msgBlob), HCF_SUCCESS); 984 EXPECT_EQ(randomObj->generateRandom(randomObj, ivLen, &ivBlob), HCF_SUCCESS); 985 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)"AES128", &genCtx), CRYPTO_SUCCESS); 986 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(genCtx, &keyCtx), CRYPTO_SUCCESS); 987 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 988 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_SUCCESS); 989 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"AES128|CBC|PKCS7", &encCtx), CRYPTO_SUCCESS); 990 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 991 EXPECT_EQ(OH_CryptoSymCipher_Final(encCtx, (Crypto_DataBlob *)&msgBlob, &outUpdate), CRYPTO_SUCCESS); 992 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"AES128|CBC|NoPadding", &decCtx), CRYPTO_SUCCESS); 993 EXPECT_EQ(OH_CryptoSymCipher_Init(decCtx, CRYPTO_DECRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 994 EXPECT_EQ(OH_CryptoSymCipher_Final(decCtx, &outUpdate, &decUpdate), CRYPTO_SUCCESS); 995 EXPECT_TRUE(memcmp(msgBlob.data, decUpdate.data, msgBlob.len) == 0); 996 EXPECT_TRUE(msgBlob.len != decUpdate.len); 997 998 OH_CryptoSymCipherParams_Destroy(params); 999 OH_CryptoSymCipher_Destroy(encCtx); 1000 OH_CryptoSymCipher_Destroy(decCtx); 1001 OH_CryptoSymKeyGenerator_Destroy(genCtx); 1002 OH_CryptoSymKey_Destroy(keyCtx); 1003 HcfBlobDataClearAndFree((HcfBlob *)&outUpdate); 1004 HcfBlobDataClearAndFree((HcfBlob *)&decUpdate); 1005 HcfBlobDataClearAndFree(&msgBlob); 1006 HcfBlobDataClearAndFree(&ivBlob); 1007 HcfObjDestroy(randomObj); 1008 } 1009 1010 /** 1011 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1600 1012 * @tc.name OHCryptoFrameworkSymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1600 1013 * @tc.desc algorithm is Sym Cipher 1014 * @tc.size Medium 1015 * @tc.type Func 1016 * @tc.level Level0 1017 */ 1018 HWTEST_F(OHCryptoFrameworkSymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1600, TestSize.Level0) 1019 { 1020 OH_CryptoSymKeyGenerator *genCtx = nullptr; 1021 OH_CryptoSymCipher *encCtx = nullptr; 1022 OH_CryptoSymCipher *decCtx = nullptr; 1023 OH_CryptoSymKey *keyCtx = nullptr; 1024 OH_CryptoSymCipherParams *params = nullptr; 1025 int32_t randomLen = 64; 1026 int32_t ivLen = 16; 1027 1028 HcfRand *randomObj = nullptr; 1029 HcfBlob msgBlob = {0}; 1030 HcfBlob ivBlob = {0}; 1031 Crypto_DataBlob outUpdate = {.data = nullptr, .len = 0}; 1032 Crypto_DataBlob decUpdate = {.data = nullptr, .len = 0}; 1033 1034 HcfRandCreate(&randomObj); 1035 EXPECT_TRUE(randomObj != nullptr); 1036 EXPECT_EQ(randomObj->generateRandom(randomObj, randomLen, &msgBlob), HCF_SUCCESS); 1037 msgBlob.data[63] = 1; // 刚好符合PKCS7填充方式 1038 EXPECT_EQ(randomObj->generateRandom(randomObj, ivLen, &ivBlob), HCF_SUCCESS); 1039 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)"AES128", &genCtx), CRYPTO_SUCCESS); 1040 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(genCtx, &keyCtx), CRYPTO_SUCCESS); 1041 EXPECT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 1042 EXPECT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_SUCCESS); 1043 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"AES256|ECB|NoPadding", &encCtx), CRYPTO_SUCCESS); 1044 EXPECT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 1045 EXPECT_EQ(OH_CryptoSymCipher_Final(encCtx, (Crypto_DataBlob *)&msgBlob, &outUpdate), CRYPTO_SUCCESS); 1046 EXPECT_EQ(OH_CryptoSymCipher_Create((const char *)"AES256|ECB|PKCS7", &decCtx), CRYPTO_SUCCESS); 1047 EXPECT_EQ(OH_CryptoSymCipher_Init(decCtx, CRYPTO_DECRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 1048 EXPECT_EQ(OH_CryptoSymCipher_Final(decCtx, &outUpdate, &decUpdate), CRYPTO_SUCCESS); 1049 EXPECT_TRUE(memcmp(msgBlob.data, decUpdate.data, msgBlob.len) != 0); 1050 EXPECT_TRUE(msgBlob.len == decUpdate.len + 1); 1051 1052 OH_CryptoSymCipherParams_Destroy(params); 1053 OH_CryptoSymCipher_Destroy(encCtx); 1054 OH_CryptoSymCipher_Destroy(decCtx); 1055 OH_CryptoSymKeyGenerator_Destroy(genCtx); 1056 OH_CryptoSymKey_Destroy(keyCtx); 1057 HcfBlobDataClearAndFree((HcfBlob *)&outUpdate); 1058 HcfBlobDataClearAndFree((HcfBlob *)&decUpdate); 1059 HcfBlobDataClearAndFree(&msgBlob); 1060 HcfBlobDataClearAndFree(&ivBlob); 1061 HcfObjDestroy(randomObj); 1062 } 1063 1064 /** 1065 * @tc.number SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1700 1066 * @tc.name OHCryptoFrameworkSymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1700 1067 * @tc.desc algorithm is Sym Cipher 1068 * @tc.size Medium 1069 * @tc.type Func 1070 * @tc.level Level0 1071 */ 1072 HWTEST_F(OHCryptoFrameworkSymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_SymCipher_Test_1700, TestSize.Level0) 1073 { 1074 OH_CryptoSymKeyGenerator *genCtx = nullptr; 1075 OH_CryptoSymCipher *encCtx = nullptr; 1076 1077 OH_CryptoSymCipher *decCtx = nullptr; 1078 OH_CryptoSymKey *keyCtx = nullptr; 1079 OH_CryptoSymCipherParams *params = nullptr; 1080 int32_t randomLen = 16; 1081 int32_t ivLen = 16; 1082 1083 HcfRand *randomObj = nullptr; 1084 HcfBlob msgBlob = {0}; 1085 HcfBlob ivBlob = {0}; 1086 Crypto_DataBlob outUpdate = {.data = nullptr, .len = 0}; 1087 Crypto_DataBlob decUpdate = {.data = nullptr, .len = 0}; 1088 1089 HcfRandCreate(&randomObj); 1090 EXPECT_TRUE(randomObj != nullptr); 1091 ASSERT_EQ(randomObj->generateRandom(randomObj, randomLen, &msgBlob), HCF_SUCCESS); 1092 ASSERT_EQ(randomObj->generateRandom(randomObj, ivLen, &ivBlob), HCF_SUCCESS); 1093 ASSERT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)"AES256", &genCtx), CRYPTO_SUCCESS); 1094 ASSERT_EQ(OH_CryptoSymKeyGenerator_Generate(genCtx, &keyCtx), CRYPTO_SUCCESS); 1095 ASSERT_EQ(OH_CryptoSymCipherParams_Create(¶ms), CRYPTO_SUCCESS); 1096 ASSERT_EQ(OH_CryptoSymCipherParams_SetParam(params, CRYPTO_IV_DATABLOB, (Crypto_DataBlob *)&ivBlob), CRYPTO_SUCCESS); 1097 ASSERT_EQ(OH_CryptoSymCipher_Create((const char *)"AES256|ECB|NoPadding", &encCtx), CRYPTO_SUCCESS); 1098 ASSERT_EQ(OH_CryptoSymCipher_Init(encCtx, CRYPTO_ENCRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 1099 ASSERT_EQ(OH_CryptoSymCipher_Final(encCtx, (Crypto_DataBlob *)&msgBlob, &outUpdate), CRYPTO_SUCCESS); 1100 ASSERT_EQ(OH_CryptoSymCipher_Create((const char *)"AES256|ECB|PKCS7", &decCtx), CRYPTO_SUCCESS); 1101 ASSERT_EQ(OH_CryptoSymCipher_Init(decCtx, CRYPTO_DECRYPT_MODE, keyCtx, params), CRYPTO_SUCCESS); 1102 ASSERT_EQ(OH_CryptoSymCipher_Final(decCtx, &outUpdate, &decUpdate), CRYPTO_OPERTION_ERROR); 1103 1104 OH_CryptoSymCipherParams_Destroy(params); 1105 OH_CryptoSymCipher_Destroy(encCtx); 1106 OH_CryptoSymCipher_Destroy(decCtx); 1107 OH_CryptoSymKeyGenerator_Destroy(genCtx); 1108 OH_CryptoSymKey_Destroy(keyCtx); 1109 HcfBlobDataClearAndFree((HcfBlob *)&outUpdate); 1110 HcfBlobDataClearAndFree((HcfBlob *)&decUpdate); 1111 HcfBlobDataClearAndFree(&msgBlob); 1112 HcfBlobDataClearAndFree(&ivBlob); 1113 HcfObjDestroy(randomObj); 1114 } 1115 1116 1117 } // namespace Unittest::CryptoFrameworkSymCipherNapiTest