| /* Copyright (c) 2014, Google Inc. |
| * |
| * Permission to use, copy, modify, and/or distribute this software for any |
| * purpose with or without fee is hereby granted, provided that the above |
| * copyright notice and this permission notice appear in all copies. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
| * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY |
| * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
| * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION |
| * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN |
| * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ |
| |
| #if !defined(_POSIX_C_SOURCE) |
| #define _POSIX_C_SOURCE 201410L |
| #endif |
| |
| #include <algorithm> |
| #include <string> |
| |
| #include <gtest/gtest.h> |
| |
| #include <openssl/bio.h> |
| #include <openssl/crypto.h> |
| #include <openssl/err.h> |
| #include <openssl/mem.h> |
| |
| #include "../internal.h" |
| #include "../test/test_util.h" |
| |
| #if !defined(OPENSSL_WINDOWS) |
| #include <arpa/inet.h> |
| #include <fcntl.h> |
| #include <netinet/in.h> |
| #include <string.h> |
| #include <sys/socket.h> |
| #include <unistd.h> |
| #else |
| #include <io.h> |
| OPENSSL_MSVC_PRAGMA(warning(push, 3)) |
| #include <winsock2.h> |
| #include <ws2tcpip.h> |
| OPENSSL_MSVC_PRAGMA(warning(pop)) |
| #endif |
| |
| |
| #if !defined(OPENSSL_WINDOWS) |
| static int closesocket(int sock) { return close(sock); } |
| static std::string LastSocketError() { return strerror(errno); } |
| #else |
| static std::string LastSocketError() { |
| char buf[DECIMAL_SIZE(int) + 1]; |
| BIO_snprintf(buf, sizeof(buf), "%d", WSAGetLastError()); |
| return buf; |
| } |
| #endif |
| |
| class ScopedSocket { |
| public: |
| explicit ScopedSocket(int sock) : sock_(sock) {} |
| ~ScopedSocket() { |
| closesocket(sock_); |
| } |
| |
| private: |
| const int sock_; |
| }; |
| |
| TEST(BIOTest, SocketConnect) { |
| static const char kTestMessage[] = "test"; |
| int listening_sock = -1; |
| socklen_t len = 0; |
| sockaddr_storage ss; |
| struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) &ss; |
| struct sockaddr_in *sin = (struct sockaddr_in *) &ss; |
| OPENSSL_memset(&ss, 0, sizeof(ss)); |
| |
| ss.ss_family = AF_INET6; |
| listening_sock = socket(AF_INET6, SOCK_STREAM, 0); |
| ASSERT_NE(-1, listening_sock) << LastSocketError(); |
| len = sizeof(*sin6); |
| ASSERT_EQ(1, inet_pton(AF_INET6, "::1", &sin6->sin6_addr)) |
| << LastSocketError(); |
| if (bind(listening_sock, (struct sockaddr *)sin6, sizeof(*sin6)) == -1) { |
| closesocket(listening_sock); |
| |
| ss.ss_family = AF_INET; |
| listening_sock = socket(AF_INET, SOCK_STREAM, 0); |
| ASSERT_NE(-1, listening_sock) << LastSocketError(); |
| len = sizeof(*sin); |
| ASSERT_EQ(1, inet_pton(AF_INET, "127.0.0.1", &sin->sin_addr)) |
| << LastSocketError(); |
| ASSERT_EQ(0, bind(listening_sock, (struct sockaddr *)sin, sizeof(*sin))) |
| << LastSocketError(); |
| } |
| |
| ScopedSocket listening_sock_closer(listening_sock); |
| ASSERT_EQ(0, listen(listening_sock, 1)) << LastSocketError(); |
| ASSERT_EQ(0, getsockname(listening_sock, (struct sockaddr *)&ss, &len)) |
| << LastSocketError(); |
| |
| char hostname[80]; |
| if (ss.ss_family == AF_INET6) { |
| BIO_snprintf(hostname, sizeof(hostname), "[::1]:%d", |
| ntohs(sin6->sin6_port)); |
| } else if (ss.ss_family == AF_INET) { |
| BIO_snprintf(hostname, sizeof(hostname), "127.0.0.1:%d", |
| ntohs(sin->sin_port)); |
| } |
| |
| // Connect to it with a connect BIO. |
| bssl::UniquePtr<BIO> bio(BIO_new_connect(hostname)); |
| ASSERT_TRUE(bio); |
| |
| // Write a test message to the BIO. |
| ASSERT_EQ(static_cast<int>(sizeof(kTestMessage)), |
| BIO_write(bio.get(), kTestMessage, sizeof(kTestMessage))); |
| |
| // Accept the socket. |
| int sock = accept(listening_sock, (struct sockaddr *) &ss, &len); |
| ASSERT_NE(-1, sock) << LastSocketError(); |
| ScopedSocket sock_closer(sock); |
| |
| // Check the same message is read back out. |
| char buf[sizeof(kTestMessage)]; |
| ASSERT_EQ(static_cast<int>(sizeof(kTestMessage)), |
| recv(sock, buf, sizeof(buf), 0)) |
| << LastSocketError(); |
| EXPECT_EQ(Bytes(kTestMessage, sizeof(kTestMessage)), Bytes(buf, sizeof(buf))); |
| } |
| |
| TEST(BIOTest, Printf) { |
| // Test a short output, a very long one, and various sizes around |
| // 256 (the size of the buffer) to ensure edge cases are correct. |
| static const size_t kLengths[] = {5, 250, 251, 252, 253, 254, 1023}; |
| |
| bssl::UniquePtr<BIO> bio(BIO_new(BIO_s_mem())); |
| ASSERT_TRUE(bio); |
| |
| for (size_t length : kLengths) { |
| SCOPED_TRACE(length); |
| |
| std::string in(length, 'a'); |
| |
| int ret = BIO_printf(bio.get(), "test %s", in.c_str()); |
| ASSERT_GE(ret, 0); |
| EXPECT_EQ(5 + length, static_cast<size_t>(ret)); |
| |
| const uint8_t *contents; |
| size_t len; |
| ASSERT_TRUE(BIO_mem_contents(bio.get(), &contents, &len)); |
| EXPECT_EQ("test " + in, |
| std::string(reinterpret_cast<const char *>(contents), len)); |
| |
| ASSERT_TRUE(BIO_reset(bio.get())); |
| } |
| } |
| |
| static const size_t kLargeASN1PayloadLen = 8000; |
| |
| struct ASN1TestParam { |
| bool should_succeed; |
| std::vector<uint8_t> input; |
| // suffix_len is the number of zeros to append to |input|. |
| size_t suffix_len; |
| // expected_len, if |should_succeed| is true, is the expected length of the |
| // ASN.1 element. |
| size_t expected_len; |
| size_t max_len; |
| } kASN1TestParams[] = { |
| {true, {0x30, 2, 1, 2, 0, 0}, 0, 4, 100}, |
| {false /* truncated */, {0x30, 3, 1, 2}, 0, 0, 100}, |
| {false /* should be short len */, {0x30, 0x81, 1, 1}, 0, 0, 100}, |
| {false /* zero padded */, {0x30, 0x82, 0, 1, 1}, 0, 0, 100}, |
| |
| // Test a large payload. |
| {true, |
| {0x30, 0x82, kLargeASN1PayloadLen >> 8, kLargeASN1PayloadLen & 0xff}, |
| kLargeASN1PayloadLen, |
| 4 + kLargeASN1PayloadLen, |
| kLargeASN1PayloadLen * 2}, |
| {false /* max_len too short */, |
| {0x30, 0x82, kLargeASN1PayloadLen >> 8, kLargeASN1PayloadLen & 0xff}, |
| kLargeASN1PayloadLen, |
| 4 + kLargeASN1PayloadLen, |
| 3 + kLargeASN1PayloadLen}, |
| |
| // Test an indefinite-length input. |
| {true, |
| {0x30, 0x80}, |
| kLargeASN1PayloadLen + 2, |
| 2 + kLargeASN1PayloadLen + 2, |
| kLargeASN1PayloadLen * 2}, |
| {false /* max_len too short */, |
| {0x30, 0x80}, |
| kLargeASN1PayloadLen + 2, |
| 2 + kLargeASN1PayloadLen + 2, |
| 2 + kLargeASN1PayloadLen + 1}, |
| }; |
| |
| class BIOASN1Test : public testing::TestWithParam<ASN1TestParam> {}; |
| |
| TEST_P(BIOASN1Test, ReadASN1) { |
| const ASN1TestParam& param = GetParam(); |
| std::vector<uint8_t> input = param.input; |
| input.resize(input.size() + param.suffix_len, 0); |
| |
| bssl::UniquePtr<BIO> bio(BIO_new_mem_buf(input.data(), input.size())); |
| ASSERT_TRUE(bio); |
| |
| uint8_t *out; |
| size_t out_len; |
| int ok = BIO_read_asn1(bio.get(), &out, &out_len, param.max_len); |
| if (!ok) { |
| out = nullptr; |
| } |
| bssl::UniquePtr<uint8_t> out_storage(out); |
| |
| ASSERT_EQ(param.should_succeed, (ok == 1)); |
| if (param.should_succeed) { |
| EXPECT_EQ(Bytes(input.data(), param.expected_len), Bytes(out, out_len)); |
| } |
| } |
| |
| INSTANTIATE_TEST_CASE_P(, BIOASN1Test, testing::ValuesIn(kASN1TestParams)); |
| |
| // Run through the tests twice, swapping |bio1| and |bio2|, for symmetry. |
| class BIOPairTest : public testing::TestWithParam<bool> {}; |
| |
| TEST_P(BIOPairTest, TestPair) { |
| BIO *bio1, *bio2; |
| ASSERT_TRUE(BIO_new_bio_pair(&bio1, 10, &bio2, 10)); |
| bssl::UniquePtr<BIO> free_bio1(bio1), free_bio2(bio2); |
| |
| if (GetParam()) { |
| std::swap(bio1, bio2); |
| } |
| |
| // Check initial states. |
| EXPECT_EQ(10u, BIO_ctrl_get_write_guarantee(bio1)); |
| EXPECT_EQ(0u, BIO_ctrl_get_read_request(bio1)); |
| |
| // Data written in one end may be read out the other. |
| uint8_t buf[20]; |
| EXPECT_EQ(5, BIO_write(bio1, "12345", 5)); |
| EXPECT_EQ(5u, BIO_ctrl_get_write_guarantee(bio1)); |
| ASSERT_EQ(5, BIO_read(bio2, buf, sizeof(buf))); |
| EXPECT_EQ(Bytes("12345"), Bytes(buf, 5)); |
| EXPECT_EQ(10u, BIO_ctrl_get_write_guarantee(bio1)); |
| |
| // Attempting to write more than 10 bytes will write partially. |
| EXPECT_EQ(10, BIO_write(bio1, "1234567890___", 13)); |
| EXPECT_EQ(0u, BIO_ctrl_get_write_guarantee(bio1)); |
| EXPECT_EQ(-1, BIO_write(bio1, "z", 1)); |
| EXPECT_TRUE(BIO_should_write(bio1)); |
| ASSERT_EQ(10, BIO_read(bio2, buf, sizeof(buf))); |
| EXPECT_EQ(Bytes("1234567890"), Bytes(buf, 10)); |
| EXPECT_EQ(10u, BIO_ctrl_get_write_guarantee(bio1)); |
| |
| // Unsuccessful reads update the read request. |
| EXPECT_EQ(-1, BIO_read(bio2, buf, 5)); |
| EXPECT_TRUE(BIO_should_read(bio2)); |
| EXPECT_EQ(5u, BIO_ctrl_get_read_request(bio1)); |
| |
| // The read request is clamped to the size of the buffer. |
| EXPECT_EQ(-1, BIO_read(bio2, buf, 20)); |
| EXPECT_TRUE(BIO_should_read(bio2)); |
| EXPECT_EQ(10u, BIO_ctrl_get_read_request(bio1)); |
| |
| // Data may be written and read in chunks. |
| EXPECT_EQ(5, BIO_write(bio1, "12345", 5)); |
| EXPECT_EQ(5u, BIO_ctrl_get_write_guarantee(bio1)); |
| EXPECT_EQ(5, BIO_write(bio1, "67890___", 8)); |
| EXPECT_EQ(0u, BIO_ctrl_get_write_guarantee(bio1)); |
| ASSERT_EQ(3, BIO_read(bio2, buf, 3)); |
| EXPECT_EQ(Bytes("123"), Bytes(buf, 3)); |
| EXPECT_EQ(3u, BIO_ctrl_get_write_guarantee(bio1)); |
| ASSERT_EQ(7, BIO_read(bio2, buf, sizeof(buf))); |
| EXPECT_EQ(Bytes("4567890"), Bytes(buf, 7)); |
| EXPECT_EQ(10u, BIO_ctrl_get_write_guarantee(bio1)); |
| |
| // Successful reads reset the read request. |
| EXPECT_EQ(0u, BIO_ctrl_get_read_request(bio1)); |
| |
| // Test writes and reads starting in the middle of the ring buffer and |
| // wrapping to front. |
| EXPECT_EQ(8, BIO_write(bio1, "abcdefgh", 8)); |
| EXPECT_EQ(2u, BIO_ctrl_get_write_guarantee(bio1)); |
| ASSERT_EQ(3, BIO_read(bio2, buf, 3)); |
| EXPECT_EQ(Bytes("abc"), Bytes(buf, 3)); |
| EXPECT_EQ(5u, BIO_ctrl_get_write_guarantee(bio1)); |
| EXPECT_EQ(5, BIO_write(bio1, "ijklm___", 8)); |
| EXPECT_EQ(0u, BIO_ctrl_get_write_guarantee(bio1)); |
| ASSERT_EQ(10, BIO_read(bio2, buf, sizeof(buf))); |
| EXPECT_EQ(Bytes("defghijklm"), Bytes(buf, 10)); |
| EXPECT_EQ(10u, BIO_ctrl_get_write_guarantee(bio1)); |
| |
| // Data may flow from both ends in parallel. |
| EXPECT_EQ(5, BIO_write(bio1, "12345", 5)); |
| EXPECT_EQ(5, BIO_write(bio2, "67890", 5)); |
| ASSERT_EQ(5, BIO_read(bio2, buf, sizeof(buf))); |
| EXPECT_EQ(Bytes("12345"), Bytes(buf, 5)); |
| ASSERT_EQ(5, BIO_read(bio1, buf, sizeof(buf))); |
| EXPECT_EQ(Bytes("67890"), Bytes(buf, 5)); |
| |
| // Closing the write end causes an EOF on the read half, after draining. |
| EXPECT_EQ(5, BIO_write(bio1, "12345", 5)); |
| EXPECT_TRUE(BIO_shutdown_wr(bio1)); |
| ASSERT_EQ(5, BIO_read(bio2, buf, sizeof(buf))); |
| EXPECT_EQ(Bytes("12345"), Bytes(buf, 5)); |
| EXPECT_EQ(0, BIO_read(bio2, buf, sizeof(buf))); |
| |
| // A closed write end may not be written to. |
| EXPECT_EQ(0u, BIO_ctrl_get_write_guarantee(bio1)); |
| EXPECT_EQ(-1, BIO_write(bio1, "_____", 5)); |
| |
| uint32_t err = ERR_get_error(); |
| EXPECT_EQ(ERR_LIB_BIO, ERR_GET_LIB(err)); |
| EXPECT_EQ(BIO_R_BROKEN_PIPE, ERR_GET_REASON(err)); |
| |
| // The other end is still functional. |
| EXPECT_EQ(5, BIO_write(bio2, "12345", 5)); |
| ASSERT_EQ(5, BIO_read(bio1, buf, sizeof(buf))); |
| EXPECT_EQ(Bytes("12345"), Bytes(buf, 5)); |
| } |
| |
| INSTANTIATE_TEST_CASE_P(, BIOPairTest, testing::Values(false, true)); |