1 // Copyright 2021 Google LLC
2 //
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 "tink/internal/md_util.h"
17
18 #include <string>
19 #include <vector>
20
21 #include "gmock/gmock.h"
22 #include "gtest/gtest.h"
23 #include "absl/strings/escaping.h"
24 #include "absl/strings/string_view.h"
25 #include "openssl/evp.h"
26 #include "tink/subtle/common_enums.h"
27 #include "tink/util/status.h"
28 #include "tink/util/statusor.h"
29 #include "tink/util/test_matchers.h"
30
31 namespace crypto {
32 namespace tink {
33 namespace internal {
34 namespace {
35
36 using ::crypto::tink::subtle::HashType;
37 using ::crypto::tink::test::IsOk;
38 using ::crypto::tink::test::IsOkAndHolds;
39 using ::testing::Not;
40 using ::testing::TestWithParam;
41 using ::testing::ValuesIn;
42
TEST(MdUtil,EvpHashFromHashType)43 TEST(MdUtil, EvpHashFromHashType) {
44 EXPECT_THAT(EvpHashFromHashType(HashType::SHA1), IsOkAndHolds(EVP_sha1()));
45 EXPECT_THAT(EvpHashFromHashType(HashType::SHA224),
46 IsOkAndHolds(EVP_sha224()));
47 EXPECT_THAT(EvpHashFromHashType(HashType::SHA256),
48 IsOkAndHolds(EVP_sha256()));
49 EXPECT_THAT(EvpHashFromHashType(HashType::SHA384),
50 IsOkAndHolds(EVP_sha384()));
51 EXPECT_THAT(EvpHashFromHashType(HashType::SHA512),
52 IsOkAndHolds(EVP_sha512()));
53 EXPECT_THAT(EvpHashFromHashType(HashType::UNKNOWN_HASH).status(),
54 Not(IsOk()));
55 }
56
TEST(MdUtil,IsHashTypeSafeForSignature)57 TEST(MdUtil, IsHashTypeSafeForSignature) {
58 EXPECT_THAT(IsHashTypeSafeForSignature(HashType::SHA256), IsOk());
59 EXPECT_THAT(IsHashTypeSafeForSignature(HashType::SHA384), IsOk());
60 EXPECT_THAT(IsHashTypeSafeForSignature(HashType::SHA512), IsOk());
61 EXPECT_THAT(IsHashTypeSafeForSignature(HashType::SHA1), Not(IsOk()));
62 EXPECT_THAT(IsHashTypeSafeForSignature(HashType::SHA224), Not(IsOk()));
63 EXPECT_THAT(IsHashTypeSafeForSignature(HashType::UNKNOWN_HASH), Not(IsOk()));
64 }
65
TEST(MdUtil,ComputeHashAcceptsNullStringView)66 TEST(MdUtil, ComputeHashAcceptsNullStringView) {
67 util::StatusOr<std::string> null_hash =
68 ComputeHash(absl::string_view(nullptr, 0), *EVP_sha512());
69 util::StatusOr<std::string> empty_hash = ComputeHash("", *EVP_sha512());
70 std::string str;
71 util::StatusOr<std::string> empty_str_hash = ComputeHash(str, *EVP_sha512());
72
73 ASSERT_THAT(null_hash, IsOk());
74 ASSERT_THAT(empty_hash, IsOk());
75 ASSERT_THAT(empty_str_hash, IsOk());
76
77 EXPECT_EQ(*null_hash, *empty_hash);
78 EXPECT_EQ(*null_hash, *empty_str_hash);
79 }
80
81 struct MdUtilComputeHashSamplesTestParam {
82 HashType hash_type;
83 std::string data_hex;
84 std::string expected_digest_hex;
85 };
86
87 using MdUtilComputeHashSamplesTest =
88 TestWithParam<MdUtilComputeHashSamplesTestParam>;
89
90 // Returns the test parameters for MdUtilComputeHashSamplesTest from NIST's
91 // samples.
92 std::vector<MdUtilComputeHashSamplesTestParam>
GetMdUtilComputeHashSamplesTestParams()93 GetMdUtilComputeHashSamplesTestParams() {
94 std::vector<MdUtilComputeHashSamplesTestParam> params;
95 params.push_back({
96 HashType::SHA256,
97 "af397a8b8dd73ab702ce8e53aa9f",
98 "d189498a3463b18e846b8ab1b41583b0b7efc789dad8a7fb885bbf8fb5b45c5c",
99 });
100 params.push_back({
101 HashType::SHA256,
102 "59eb45bbbeb054b0b97334d53580ce03f699",
103 "32c38c54189f2357e96bd77eb00c2b9c341ebebacc2945f97804f59a93238288",
104 });
105 params.push_back({
106 HashType::SHA512,
107 "16b17074d3e3d97557f9ed77d920b4b1bff4e845b345a922",
108 "6884134582a760046433abcbd53db8ff1a89995862f305b887020f6da6c7b903a314721e"
109 "972bf438483f452a8b09596298a576c903c91df4a414c7bd20fd1d07",
110 });
111 params.push_back({
112 HashType::SHA512,
113 "7651ab491b8fa86f969d42977d09df5f8bee3e5899180b52c968b0db057a6f02a886ad61"
114 "7a84915a",
115 "f35e50e2e02b8781345f8ceb2198f068ba103476f715cfb487a452882c9f0de0c720b2a0"
116 "88a39d06a8a6b64ce4d6470dfeadc4f65ae06672c057e29f14c4daf9",
117 });
118 return params;
119 }
120
TEST_P(MdUtilComputeHashSamplesTest,ComputesHash)121 TEST_P(MdUtilComputeHashSamplesTest, ComputesHash) {
122 const MdUtilComputeHashSamplesTestParam& params = GetParam();
123 util::StatusOr<const EVP_MD*> hasher = EvpHashFromHashType(params.hash_type);
124 ASSERT_THAT(hasher, IsOk());
125 std::string data = absl::HexStringToBytes(params.data_hex);
126 std::string expected_digest =
127 absl::HexStringToBytes(params.expected_digest_hex);
128 EXPECT_THAT(ComputeHash(data, **hasher), IsOkAndHolds(expected_digest));
129 }
130
131 INSTANTIATE_TEST_SUITE_P(MdUtilComputeHashSamplesTests,
132 MdUtilComputeHashSamplesTest,
133 ValuesIn(GetMdUtilComputeHashSamplesTestParams()));
134
135 } // namespace
136 } // namespace internal
137 } // namespace tink
138 } // namespace crypto
139