1 /* Copyright (c) 2014, Google Inc.
2 *
3 * Permission to use, copy, modify, and/or distribute this software for any
4 * purpose with or without fee is hereby granted, provided that the above
5 * copyright notice and this permission notice appear in all copies.
6 *
7 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
8 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
9 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
10 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
11 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
12 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
13 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
14
15 #include <algorithm>
16 #include <string>
17
18 #include <gtest/gtest.h>
19
20 #include <openssl/bio.h>
21 #include <openssl/crypto.h>
22 #include <openssl/err.h>
23 #include <openssl/mem.h>
24
25 #include "../internal.h"
26 #include "../test/test_util.h"
27
28 #if !defined(OPENSSL_WINDOWS)
29 #include <arpa/inet.h>
30 #include <errno.h>
31 #include <fcntl.h>
32 #include <netinet/in.h>
33 #include <string.h>
34 #include <sys/socket.h>
35 #include <unistd.h>
36 #else
37 #include <io.h>
38 OPENSSL_MSVC_PRAGMA(warning(push, 3))
39 #include <winsock2.h>
40 #include <ws2tcpip.h>
OPENSSL_MSVC_PRAGMA(warning (pop))41 OPENSSL_MSVC_PRAGMA(warning(pop))
42 #endif
43
44
45 #if !defined(OPENSSL_WINDOWS)
46 static int closesocket(int sock) { return close(sock); }
LastSocketError()47 static std::string LastSocketError() { return strerror(errno); }
48 #else
49 static std::string LastSocketError() {
50 char buf[DECIMAL_SIZE(int) + 1];
51 BIO_snprintf(buf, sizeof(buf), "%d", WSAGetLastError());
52 return buf;
53 }
54 #endif
55
56 class ScopedSocket {
57 public:
ScopedSocket(int sock)58 explicit ScopedSocket(int sock) : sock_(sock) {}
~ScopedSocket()59 ~ScopedSocket() {
60 closesocket(sock_);
61 }
62
63 private:
64 const int sock_;
65 };
66
TEST(BIOTest,SocketConnect)67 TEST(BIOTest, SocketConnect) {
68 static const char kTestMessage[] = "test";
69 int listening_sock = -1;
70 socklen_t len = 0;
71 sockaddr_storage ss;
72 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) &ss;
73 struct sockaddr_in *sin = (struct sockaddr_in *) &ss;
74 OPENSSL_memset(&ss, 0, sizeof(ss));
75
76 ss.ss_family = AF_INET6;
77 listening_sock = socket(AF_INET6, SOCK_STREAM, 0);
78 ASSERT_NE(-1, listening_sock) << LastSocketError();
79 len = sizeof(*sin6);
80 ASSERT_EQ(1, inet_pton(AF_INET6, "::1", &sin6->sin6_addr))
81 << LastSocketError();
82 if (bind(listening_sock, (struct sockaddr *)sin6, sizeof(*sin6)) == -1) {
83 closesocket(listening_sock);
84
85 ss.ss_family = AF_INET;
86 listening_sock = socket(AF_INET, SOCK_STREAM, 0);
87 ASSERT_NE(-1, listening_sock) << LastSocketError();
88 len = sizeof(*sin);
89 ASSERT_EQ(1, inet_pton(AF_INET, "127.0.0.1", &sin->sin_addr))
90 << LastSocketError();
91 ASSERT_EQ(0, bind(listening_sock, (struct sockaddr *)sin, sizeof(*sin)))
92 << LastSocketError();
93 }
94
95 ScopedSocket listening_sock_closer(listening_sock);
96 ASSERT_EQ(0, listen(listening_sock, 1)) << LastSocketError();
97 ASSERT_EQ(0, getsockname(listening_sock, (struct sockaddr *)&ss, &len))
98 << LastSocketError();
99
100 char hostname[80];
101 if (ss.ss_family == AF_INET6) {
102 BIO_snprintf(hostname, sizeof(hostname), "[::1]:%d",
103 ntohs(sin6->sin6_port));
104 } else if (ss.ss_family == AF_INET) {
105 BIO_snprintf(hostname, sizeof(hostname), "127.0.0.1:%d",
106 ntohs(sin->sin_port));
107 }
108
109 // Connect to it with a connect BIO.
110 bssl::UniquePtr<BIO> bio(BIO_new_connect(hostname));
111 ASSERT_TRUE(bio);
112
113 // Write a test message to the BIO.
114 ASSERT_EQ(static_cast<int>(sizeof(kTestMessage)),
115 BIO_write(bio.get(), kTestMessage, sizeof(kTestMessage)));
116
117 // Accept the socket.
118 int sock = accept(listening_sock, (struct sockaddr *) &ss, &len);
119 ASSERT_NE(-1, sock) << LastSocketError();
120 ScopedSocket sock_closer(sock);
121
122 // Check the same message is read back out.
123 char buf[sizeof(kTestMessage)];
124 ASSERT_EQ(static_cast<int>(sizeof(kTestMessage)),
125 recv(sock, buf, sizeof(buf), 0))
126 << LastSocketError();
127 EXPECT_EQ(Bytes(kTestMessage, sizeof(kTestMessage)), Bytes(buf, sizeof(buf)));
128 }
129
TEST(BIOTest,Printf)130 TEST(BIOTest, Printf) {
131 // Test a short output, a very long one, and various sizes around
132 // 256 (the size of the buffer) to ensure edge cases are correct.
133 static const size_t kLengths[] = {5, 250, 251, 252, 253, 254, 1023};
134
135 bssl::UniquePtr<BIO> bio(BIO_new(BIO_s_mem()));
136 ASSERT_TRUE(bio);
137
138 for (size_t length : kLengths) {
139 SCOPED_TRACE(length);
140
141 std::string in(length, 'a');
142
143 int ret = BIO_printf(bio.get(), "test %s", in.c_str());
144 ASSERT_GE(ret, 0);
145 EXPECT_EQ(5 + length, static_cast<size_t>(ret));
146
147 const uint8_t *contents;
148 size_t len;
149 ASSERT_TRUE(BIO_mem_contents(bio.get(), &contents, &len));
150 EXPECT_EQ("test " + in,
151 std::string(reinterpret_cast<const char *>(contents), len));
152
153 ASSERT_TRUE(BIO_reset(bio.get()));
154 }
155 }
156
157 static const size_t kLargeASN1PayloadLen = 8000;
158
159 struct ASN1TestParam {
160 bool should_succeed;
161 std::vector<uint8_t> input;
162 // suffix_len is the number of zeros to append to |input|.
163 size_t suffix_len;
164 // expected_len, if |should_succeed| is true, is the expected length of the
165 // ASN.1 element.
166 size_t expected_len;
167 size_t max_len;
168 } kASN1TestParams[] = {
169 {true, {0x30, 2, 1, 2, 0, 0}, 0, 4, 100},
170 {false /* truncated */, {0x30, 3, 1, 2}, 0, 0, 100},
171 {false /* should be short len */, {0x30, 0x81, 1, 1}, 0, 0, 100},
172 {false /* zero padded */, {0x30, 0x82, 0, 1, 1}, 0, 0, 100},
173
174 // Test a large payload.
175 {true,
176 {0x30, 0x82, kLargeASN1PayloadLen >> 8, kLargeASN1PayloadLen & 0xff},
177 kLargeASN1PayloadLen,
178 4 + kLargeASN1PayloadLen,
179 kLargeASN1PayloadLen * 2},
180 {false /* max_len too short */,
181 {0x30, 0x82, kLargeASN1PayloadLen >> 8, kLargeASN1PayloadLen & 0xff},
182 kLargeASN1PayloadLen,
183 4 + kLargeASN1PayloadLen,
184 3 + kLargeASN1PayloadLen},
185
186 // Test an indefinite-length input.
187 {true,
188 {0x30, 0x80},
189 kLargeASN1PayloadLen + 2,
190 2 + kLargeASN1PayloadLen + 2,
191 kLargeASN1PayloadLen * 2},
192 {false /* max_len too short */,
193 {0x30, 0x80},
194 kLargeASN1PayloadLen + 2,
195 2 + kLargeASN1PayloadLen + 2,
196 2 + kLargeASN1PayloadLen + 1},
197 };
198
199 class BIOASN1Test : public testing::TestWithParam<ASN1TestParam> {};
200
TEST_P(BIOASN1Test,ReadASN1)201 TEST_P(BIOASN1Test, ReadASN1) {
202 const ASN1TestParam& param = GetParam();
203 std::vector<uint8_t> input = param.input;
204 input.resize(input.size() + param.suffix_len, 0);
205
206 bssl::UniquePtr<BIO> bio(BIO_new_mem_buf(input.data(), input.size()));
207 ASSERT_TRUE(bio);
208
209 uint8_t *out;
210 size_t out_len;
211 int ok = BIO_read_asn1(bio.get(), &out, &out_len, param.max_len);
212 if (!ok) {
213 out = nullptr;
214 }
215 bssl::UniquePtr<uint8_t> out_storage(out);
216
217 ASSERT_EQ(param.should_succeed, (ok == 1));
218 if (param.should_succeed) {
219 EXPECT_EQ(Bytes(input.data(), param.expected_len), Bytes(out, out_len));
220 }
221 }
222
223 INSTANTIATE_TEST_SUITE_P(All, BIOASN1Test, testing::ValuesIn(kASN1TestParams));
224
225 // Run through the tests twice, swapping |bio1| and |bio2|, for symmetry.
226 class BIOPairTest : public testing::TestWithParam<bool> {};
227
TEST_P(BIOPairTest,TestPair)228 TEST_P(BIOPairTest, TestPair) {
229 BIO *bio1, *bio2;
230 ASSERT_TRUE(BIO_new_bio_pair(&bio1, 10, &bio2, 10));
231 bssl::UniquePtr<BIO> free_bio1(bio1), free_bio2(bio2);
232
233 if (GetParam()) {
234 std::swap(bio1, bio2);
235 }
236
237 // Check initial states.
238 EXPECT_EQ(10u, BIO_ctrl_get_write_guarantee(bio1));
239 EXPECT_EQ(0u, BIO_ctrl_get_read_request(bio1));
240
241 // Data written in one end may be read out the other.
242 uint8_t buf[20];
243 EXPECT_EQ(5, BIO_write(bio1, "12345", 5));
244 EXPECT_EQ(5u, BIO_ctrl_get_write_guarantee(bio1));
245 ASSERT_EQ(5, BIO_read(bio2, buf, sizeof(buf)));
246 EXPECT_EQ(Bytes("12345"), Bytes(buf, 5));
247 EXPECT_EQ(10u, BIO_ctrl_get_write_guarantee(bio1));
248
249 // Attempting to write more than 10 bytes will write partially.
250 EXPECT_EQ(10, BIO_write(bio1, "1234567890___", 13));
251 EXPECT_EQ(0u, BIO_ctrl_get_write_guarantee(bio1));
252 EXPECT_EQ(-1, BIO_write(bio1, "z", 1));
253 EXPECT_TRUE(BIO_should_write(bio1));
254 ASSERT_EQ(10, BIO_read(bio2, buf, sizeof(buf)));
255 EXPECT_EQ(Bytes("1234567890"), Bytes(buf, 10));
256 EXPECT_EQ(10u, BIO_ctrl_get_write_guarantee(bio1));
257
258 // Unsuccessful reads update the read request.
259 EXPECT_EQ(-1, BIO_read(bio2, buf, 5));
260 EXPECT_TRUE(BIO_should_read(bio2));
261 EXPECT_EQ(5u, BIO_ctrl_get_read_request(bio1));
262
263 // The read request is clamped to the size of the buffer.
264 EXPECT_EQ(-1, BIO_read(bio2, buf, 20));
265 EXPECT_TRUE(BIO_should_read(bio2));
266 EXPECT_EQ(10u, BIO_ctrl_get_read_request(bio1));
267
268 // Data may be written and read in chunks.
269 EXPECT_EQ(5, BIO_write(bio1, "12345", 5));
270 EXPECT_EQ(5u, BIO_ctrl_get_write_guarantee(bio1));
271 EXPECT_EQ(5, BIO_write(bio1, "67890___", 8));
272 EXPECT_EQ(0u, BIO_ctrl_get_write_guarantee(bio1));
273 ASSERT_EQ(3, BIO_read(bio2, buf, 3));
274 EXPECT_EQ(Bytes("123"), Bytes(buf, 3));
275 EXPECT_EQ(3u, BIO_ctrl_get_write_guarantee(bio1));
276 ASSERT_EQ(7, BIO_read(bio2, buf, sizeof(buf)));
277 EXPECT_EQ(Bytes("4567890"), Bytes(buf, 7));
278 EXPECT_EQ(10u, BIO_ctrl_get_write_guarantee(bio1));
279
280 // Successful reads reset the read request.
281 EXPECT_EQ(0u, BIO_ctrl_get_read_request(bio1));
282
283 // Test writes and reads starting in the middle of the ring buffer and
284 // wrapping to front.
285 EXPECT_EQ(8, BIO_write(bio1, "abcdefgh", 8));
286 EXPECT_EQ(2u, BIO_ctrl_get_write_guarantee(bio1));
287 ASSERT_EQ(3, BIO_read(bio2, buf, 3));
288 EXPECT_EQ(Bytes("abc"), Bytes(buf, 3));
289 EXPECT_EQ(5u, BIO_ctrl_get_write_guarantee(bio1));
290 EXPECT_EQ(5, BIO_write(bio1, "ijklm___", 8));
291 EXPECT_EQ(0u, BIO_ctrl_get_write_guarantee(bio1));
292 ASSERT_EQ(10, BIO_read(bio2, buf, sizeof(buf)));
293 EXPECT_EQ(Bytes("defghijklm"), Bytes(buf, 10));
294 EXPECT_EQ(10u, BIO_ctrl_get_write_guarantee(bio1));
295
296 // Data may flow from both ends in parallel.
297 EXPECT_EQ(5, BIO_write(bio1, "12345", 5));
298 EXPECT_EQ(5, BIO_write(bio2, "67890", 5));
299 ASSERT_EQ(5, BIO_read(bio2, buf, sizeof(buf)));
300 EXPECT_EQ(Bytes("12345"), Bytes(buf, 5));
301 ASSERT_EQ(5, BIO_read(bio1, buf, sizeof(buf)));
302 EXPECT_EQ(Bytes("67890"), Bytes(buf, 5));
303
304 // Closing the write end causes an EOF on the read half, after draining.
305 EXPECT_EQ(5, BIO_write(bio1, "12345", 5));
306 EXPECT_TRUE(BIO_shutdown_wr(bio1));
307 ASSERT_EQ(5, BIO_read(bio2, buf, sizeof(buf)));
308 EXPECT_EQ(Bytes("12345"), Bytes(buf, 5));
309 EXPECT_EQ(0, BIO_read(bio2, buf, sizeof(buf)));
310
311 // A closed write end may not be written to.
312 EXPECT_EQ(0u, BIO_ctrl_get_write_guarantee(bio1));
313 EXPECT_EQ(-1, BIO_write(bio1, "_____", 5));
314
315 uint32_t err = ERR_get_error();
316 EXPECT_EQ(ERR_LIB_BIO, ERR_GET_LIB(err));
317 EXPECT_EQ(BIO_R_BROKEN_PIPE, ERR_GET_REASON(err));
318
319 // The other end is still functional.
320 EXPECT_EQ(5, BIO_write(bio2, "12345", 5));
321 ASSERT_EQ(5, BIO_read(bio1, buf, sizeof(buf)));
322 EXPECT_EQ(Bytes("12345"), Bytes(buf, 5));
323 }
324
325 INSTANTIATE_TEST_SUITE_P(All, BIOPairTest, testing::Values(false, true));
326