1 /* 2 * Copyright (c) 2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <cstring> 17 #include <fcntl.h> 18 #include <gtest/gtest.h> 19 #include <iostream> 20 #include <unistd.h> 21 #include "log.h" 22 #include "pkg_algorithm.h" 23 #include "pkg_manager.h" 24 #include "pkg_manager_impl.h" 25 #include "pkg_test.h" 26 #include "pkg_utils.h" 27 28 #include "package.h" 29 #include "cert_verify.h" 30 #include "openssl_util.h" 31 #include "pkg_verify_util.h" 32 #include "zip_pkg_parse.h" 33 #include "pkcs7_signed_data.h" 34 35 using namespace std; 36 using namespace Hpackage; 37 using namespace Updater; 38 using namespace testing::ext; 39 40 namespace UpdaterUt { 41 class PackageVerifyTest : public PkgTest { 42 public: PackageVerifyTest()43 PackageVerifyTest() {} ~PackageVerifyTest()44 ~PackageVerifyTest() override {} 45 public: TestGetFileSize(const std::string & testfileName)46 int TestGetFileSize(const std::string &testfileName) 47 { 48 int32_t ret = GetFileSize(testfileName); 49 return ret; 50 } 51 TestExtraPackageFile()52 int TestExtraPackageFile() 53 { 54 int32_t ret = ExtraPackageFile(nullptr, nullptr, nullptr, nullptr); 55 EXPECT_EQ(ret, PKG_INVALID_PARAM); 56 57 std::string packagePath = "invalid_path"; 58 std::string keyPath = "invalid_key"; 59 std::string file = "invalid_file"; 60 std::string outPath = "invalid_path"; 61 ret = ExtraPackageFile(packagePath.c_str(), keyPath.c_str(), file.c_str(), outPath.c_str()); 62 EXPECT_EQ(ret, PKG_INVALID_FILE); 63 64 packagePath = "/data/updater/package/test_package.zip"; 65 keyPath = "/data/updater/src/signing_cert.crt"; 66 file = "updater.bin"; 67 outPath = "/data/updater/package/"; 68 ret = ExtraPackageFile(packagePath.c_str(), keyPath.c_str(), file.c_str(), outPath.c_str()); 69 EXPECT_EQ(ret, PKG_SUCCESS); 70 return 0; 71 } 72 TestExtraPackageDir()73 int TestExtraPackageDir() 74 { 75 int32_t ret = ExtraPackageDir(nullptr, nullptr, nullptr, nullptr); 76 EXPECT_EQ(ret, PKG_INVALID_PARAM); 77 78 std::string packagePath = "invalid_path"; 79 std::string keyPath = "invalid_key"; 80 std::string outPath = "invalid_path"; 81 ret = ExtraPackageDir(packagePath.c_str(), keyPath.c_str(), nullptr, outPath.c_str()); 82 EXPECT_EQ(ret, PKG_INVALID_FILE); 83 84 packagePath = "/data/updater/package/test_package.zip"; 85 keyPath = "/data/updater/src/signing_cert.crt"; 86 outPath = "/data/updater/package/"; 87 ret = ExtraPackageDir(packagePath.c_str(), keyPath.c_str(), nullptr, outPath.c_str()); 88 EXPECT_EQ(ret, PKG_SUCCESS); 89 return 0; 90 } 91 TestCertVerifyFailed()92 int TestCertVerifyFailed() 93 { 94 BIO *certbio = BIO_new_file(GetTestPrivateKeyName(0).c_str(), "r"); 95 X509 *rcert = PEM_read_bio_X509(certbio, nullptr, nullptr, nullptr); 96 if (certbio != nullptr) { 97 BIO_free(certbio); 98 } 99 SingleCertHelper singleCert; 100 int32_t ret = singleCert.CertChainCheck(nullptr, nullptr); 101 EXPECT_EQ(ret, -1); 102 ret = singleCert.CertChainCheck(nullptr, rcert); 103 EXPECT_EQ(ret, -1); 104 105 ret = CertVerify::GetInstance().CheckCertChain(nullptr, nullptr); 106 EXPECT_EQ(ret, -1); 107 108 bool result = VerifyX509CertByIssuerCert(nullptr, nullptr); 109 EXPECT_EQ(result, false); 110 result = VerifyX509CertByIssuerCert(rcert, rcert); 111 EXPECT_EQ(result, false); 112 return 0; 113 } 114 TestOpensslUtilFailed()115 int TestOpensslUtilFailed() 116 { 117 std::vector<uint8_t> asn1Data; 118 int32_t ret = GetASN1OctetStringData(nullptr, asn1Data); 119 EXPECT_EQ(ret, -1); 120 121 int32_t algoNid {}; 122 ret = GetX509AlgorithmNid(nullptr, algoNid); 123 EXPECT_EQ(ret, -1); 124 125 X509 *result = GetX509CertFromPemString(" "); 126 EXPECT_EQ(result, nullptr); 127 result = GetX509CertFromPemFile("invalid_file"); 128 EXPECT_EQ(result, nullptr); 129 130 BIO *certbio = BIO_new_file(GetTestPrivateKeyName(0).c_str(), "r"); 131 X509 *cert = PEM_read_bio_X509(certbio, nullptr, nullptr, nullptr); 132 if (certbio != nullptr) { 133 BIO_free(certbio); 134 } 135 bool boolResult = VerifyX509CertByIssuerCert(nullptr, nullptr); 136 EXPECT_EQ(boolResult, false); 137 boolResult = VerifyX509CertByIssuerCert(cert, cert); 138 EXPECT_EQ(boolResult, false); 139 140 ret = VerifyDigestByPubKey(nullptr, 0, asn1Data, asn1Data); 141 EXPECT_EQ(ret, -1); 142 ret = CalcSha256Digest(nullptr, 0, asn1Data); 143 EXPECT_EQ(ret, -1); 144 145 std::string stringResult = GetStringFromX509Name(nullptr); 146 EXPECT_EQ(stringResult, ""); 147 stringResult = GetX509CertSubjectName(nullptr); 148 EXPECT_EQ(stringResult, ""); 149 stringResult = GetX509CertSubjectName(cert); 150 EXPECT_EQ(stringResult, ""); 151 stringResult = GetX509CertIssuerName(nullptr); 152 EXPECT_EQ(stringResult, ""); 153 stringResult = GetX509CertIssuerName(cert); 154 EXPECT_EQ(stringResult, ""); 155 return 0; 156 } 157 TestPkcs7SignedDataFailed()158 int TestPkcs7SignedDataFailed() 159 { 160 Pkcs7SignedData signedData; 161 uint8_t testData['A']; 162 uint8_t *srcData = testData; 163 std::vector<uint8_t> hash; 164 165 int32_t ret = signedData.Verify(); 166 EXPECT_EQ(ret, -1); 167 ret = signedData.GetHashFromSignBlock(nullptr, 0, hash); 168 EXPECT_EQ(ret, -1); 169 ret = signedData.GetHashFromSignBlock(srcData, 0, hash); 170 EXPECT_EQ(ret, -1); 171 ret = signedData.GetHashFromSignBlock(srcData, 1, hash); 172 EXPECT_EQ(ret, -1); 173 return 0; 174 } 175 TestPkgVerifyFailed()176 int TestPkgVerifyFailed() 177 { 178 PkgVerifyUtil pkgVerify; 179 std::vector<uint8_t> data; 180 size_t testData = 0; 181 int32_t ret = pkgVerify.VerifyPackageSign(nullptr); 182 EXPECT_EQ(ret, PKG_INVALID_PARAM); 183 ret = pkgVerify.GetSignature(nullptr, testData, data); 184 EXPECT_NE(ret, PKG_SUCCESS); 185 ret = pkgVerify.HashCheck(nullptr, testData, data); 186 EXPECT_EQ(ret, PKG_INVALID_PARAM); 187 ret = pkgVerify.ParsePackage(nullptr, testData, testData); 188 EXPECT_NE(ret, PKG_SUCCESS); 189 ret = pkgVerify.Pkcs7verify(data, data); 190 EXPECT_NE(ret, PKG_SUCCESS); 191 return 0; 192 } 193 }; 194 195 HWTEST_F(PackageVerifyTest, TestPkgVerifyFailed, TestSize.Level1) 196 { 197 PackageVerifyTest test; 198 EXPECT_EQ(0, test.TestPkgVerifyFailed()); 199 } 200 201 HWTEST_F(PackageVerifyTest, TestPkcs7SignedDataFailed, TestSize.Level1) 202 { 203 PackageVerifyTest test; 204 EXPECT_EQ(0, test.TestPkcs7SignedDataFailed()); 205 } 206 207 HWTEST_F(PackageVerifyTest, TestOpensslUtilFailed, TestSize.Level1) 208 { 209 PackageVerifyTest test; 210 EXPECT_EQ(0, test.TestOpensslUtilFailed()); 211 } 212 213 HWTEST_F(PackageVerifyTest, TestCertVerifyFailed, TestSize.Level1) 214 { 215 PackageVerifyTest test; 216 EXPECT_EQ(0, test.TestCertVerifyFailed()); 217 } 218 219 HWTEST_F(PackageVerifyTest, TestExtraPackageDir, TestSize.Level1) 220 { 221 PackageVerifyTest test; 222 EXPECT_EQ(0, test.TestExtraPackageDir()); 223 } 224 225 HWTEST_F(PackageVerifyTest, TestExtraPackageFile, TestSize.Level1) 226 { 227 PackageVerifyTest test; 228 EXPECT_EQ(0, test.TestExtraPackageFile()); 229 } 230 231 HWTEST_F(PackageVerifyTest, TestGetFileSize, TestSize.Level1) 232 { 233 PackageVerifyTest test; 234 std::string testFileName = "invalid_path"; 235 EXPECT_EQ(0, test.TestGetFileSize(testFileName)); 236 testFileName = "/data/updater/package/test_package.zip"; 237 EXPECT_EQ(1368949, test.TestGetFileSize(testFileName)); 238 } 239 } 240