1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
// Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Unit tests for SecureBlob.
#include "brillo/asan.h"
#include "brillo/secure_blob.h"
#include <algorithm>
#include <iterator>
#include <limits>
#include <numeric>
#include <base/logging.h>
#include <gtest/gtest.h>
namespace brillo {
using std::string;
// Tests BlobToString() and BlobFromString().
TEST(BlobTest, StringConversions) {
const char kTestBytes[] = {'\0', '\x1', 'a', std::numeric_limits<char>::min(),
std::numeric_limits<char>::max()};
const Blob blob(std::begin(kTestBytes), std::end(kTestBytes));
const string obtained_string = BlobToString(blob);
EXPECT_EQ(string(std::begin(kTestBytes), std::end(kTestBytes)),
obtained_string);
const Blob obtained_blob = BlobFromString(obtained_string);
EXPECT_EQ(blob, obtained_blob);
}
class SecureBlobTest : public ::testing::Test {
public:
SecureBlobTest() {}
virtual ~SecureBlobTest() {}
static bool FindBlobInBlob(const brillo::Blob& haystack,
const brillo::Blob& needle) {
auto pos = std::search(
haystack.begin(), haystack.end(), needle.begin(), needle.end());
return (pos != haystack.end());
}
static int FindBlobIndexInBlob(const brillo::Blob& haystack,
const brillo::Blob& needle) {
auto pos = std::search(
haystack.begin(), haystack.end(), needle.begin(), needle.end());
if (pos == haystack.end()) {
return -1;
}
return std::distance(haystack.begin(), pos);
}
private:
DISALLOW_COPY_AND_ASSIGN(SecureBlobTest);
};
// Test construction of SecureBlob from Blob.
TEST_F(SecureBlobTest, BlobConstructorTest) {
const std::vector<uint8_t> bytes = {0, 1, 255};
const Blob blob(bytes);
const SecureBlob secure_blob(blob);
EXPECT_EQ(bytes,
std::vector<uint8_t>(secure_blob.begin(), secure_blob.end()));
}
TEST_F(SecureBlobTest, AllocationSizeTest) {
// Check that allocating a SecureBlob of a specified size works
SecureBlob blob(32);
EXPECT_EQ(32, blob.size());
}
TEST_F(SecureBlobTest, AllocationCopyTest) {
// Check that allocating a SecureBlob with an iterator works
unsigned char from_data[32];
std::iota(std::begin(from_data), std::end(from_data), 0);
SecureBlob blob(std::begin(from_data), std::end(from_data));
EXPECT_EQ(sizeof(from_data), blob.size());
for (unsigned int i = 0; i < sizeof(from_data); i++) {
EXPECT_EQ(from_data[i], blob[i]);
}
}
TEST_F(SecureBlobTest, IteratorConstructorTest) {
// Check that allocating a SecureBlob with an iterator works
brillo::Blob from_blob(32);
for (unsigned int i = 0; i < from_blob.size(); i++) {
from_blob[i] = i;
}
SecureBlob blob(from_blob.begin(), from_blob.end());
EXPECT_EQ(from_blob.size(), blob.size());
EXPECT_TRUE(SecureBlobTest::FindBlobInBlob(from_blob, blob));
}
// Disable ResizeTest with address sanitizer.
// https://crbug.com/806013
#ifndef BRILLO_ASAN_BUILD
TEST_F(SecureBlobTest, ResizeTest) {
// Check that resizing a SecureBlob wipes the excess memory. The test assumes
// that resize() down by one will not re-allocate the memory, so the last byte
// will still be part of the SecureBlob's allocation
size_t length = 1024;
SecureBlob blob(length);
void* original_data = blob.data();
for (size_t i = 0; i < length; i++) {
blob[i] = i;
}
blob.resize(length - 1);
EXPECT_EQ(original_data, blob.data());
EXPECT_EQ(length - 1, blob.size());
EXPECT_EQ(0, blob.data()[length - 1]);
}
#endif
TEST_F(SecureBlobTest, CombineTest) {
SecureBlob blob1(32);
SecureBlob blob2(32);
std::iota(blob1.begin(), blob1.end(), 0);
std::iota(blob2.begin(), blob2.end(), 32);
SecureBlob combined_blob = SecureBlob::Combine(blob1, blob2);
EXPECT_EQ(combined_blob.size(), (blob1.size() + blob2.size()));
EXPECT_TRUE(SecureBlobTest::FindBlobInBlob(combined_blob, blob1));
EXPECT_TRUE(SecureBlobTest::FindBlobInBlob(combined_blob, blob2));
int blob1_index = SecureBlobTest::FindBlobIndexInBlob(combined_blob, blob1);
int blob2_index = SecureBlobTest::FindBlobIndexInBlob(combined_blob, blob2);
EXPECT_EQ(blob1_index, 0);
EXPECT_EQ(blob2_index, 32);
}
TEST_F(SecureBlobTest, BlobToStringTest) {
std::string test_string("Test String");
SecureBlob blob = SecureBlob(test_string.begin(), test_string.end());
EXPECT_EQ(blob.size(), test_string.length());
std::string result_string = blob.to_string();
EXPECT_EQ(test_string.compare(result_string), 0);
}
} // namespace brillo
|
