mmo-ref/emberemu
1
0
Fork 0
mirror of https://github.com/EmberEmu/Ember synced 2026-08-14 22:32:05 -04:00
Code Issues Projects Releases Packages Wiki Activity
emberemu/tests/Ports.cpp

435 lines
No EOL
15 KiB
C++
Raw Permalink Blame History

/*
* Copyright (c) 2024 Ember
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
#include "PortsVectors.h"
#include <ports/pcp/Serialise.h>
#include <ports/pcp/Deserialise.h>
#include <ports/upnp/HTTPHeaderParser.h>
#include <boost/endian.hpp>
#include <gtest/gtest.h>
#include <boost/asio/ip/address.hpp>
#include <array>
#include <limits>
#include <string>
#include <string_view>
#include <cstdint>
using namespace ember;
using namespace ember::ports;
class Ports : public ::testing::Test {
public:
Ports() : stream(adaptor) {}
const std::array<std::uint8_t, 16> ip {
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11
};
const std::array<std::uint8_t, 12> nonce {
0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x01, 0x02, 0x03, 0x04, 0x05, 0x06
};
std::vector<std::uint8_t> buffer;
spark::io::BufferAdaptor<decltype(buffer)> adaptor = buffer;
spark::io::BinaryStream<
decltype(adaptor),
spark::io::allow_throw_t,
spark::io::endian::as_big_t
> stream;
};
TEST_F(Ports, PCP_RequestHeaderRoundtrip) {
const pcp::RequestHeader input {
.version = PCP_VERSION,
.response = true,
.opcode = pcp::Opcode::map,
.reserved_0 = 0xF00D,
.lifetime = 7200u,
};
ports::serialise(input, stream);
const auto output = deserialise<pcp::RequestHeader>(buffer);
ASSERT_EQ(input.client_ip, output.client_ip);
ASSERT_EQ(input.lifetime, output.lifetime);
ASSERT_EQ(input.opcode, output.opcode);
ASSERT_EQ(input.reserved_0, output.reserved_0);
ASSERT_EQ(input.response, output.response);
ASSERT_EQ(input.version, output.version);
}
TEST_F(Ports, PCP_ResponseHeaderRoundtrip) {
const std::array<std::uint8_t, 12> reserved_1 {
0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
};
const pcp::ResponseHeader input {
.version = PCP_VERSION,
.response = true,
.opcode = pcp::Opcode::map,
.reserved_0 = 0xFF,
.result = pcp::Result::address_mismatch,
.lifetime = 0xAABBCCDD,
.epoch_time = 0x01020304,
.reserved_1 = reserved_1
};
ports::serialise(input, stream);
const auto output = deserialise<pcp::ResponseHeader>(buffer);
ASSERT_EQ(input.version, output.version);
ASSERT_EQ(input.response, output.response);
ASSERT_EQ(input.opcode, output.opcode);
ASSERT_EQ(input.reserved_0, output.reserved_0);
ASSERT_EQ(input.result, output.result);
ASSERT_EQ(input.lifetime, output.lifetime);
ASSERT_EQ(input.epoch_time, output.epoch_time);
ASSERT_EQ(input.reserved_1, output.reserved_1);
}
TEST_F(Ports, PCP_MapResponseRoundtrip) {
const pcp::MapResponse input {
.protocol = pcp::Protocol::tcp,
.reserved = { 0x01, 0x02, 0x03 },
.internal_port = 0xCAFE,
.assigned_external_port = 0xBEEF,
.assigned_external_ip = ip
};
ports::serialise(input, stream);
const auto output = deserialise<pcp::MapResponse>(buffer);
ASSERT_EQ(input.protocol, output.protocol);
ASSERT_EQ(input.reserved, output.reserved);
ASSERT_EQ(input.internal_port, output.internal_port);
ASSERT_EQ(input.assigned_external_ip, output.assigned_external_ip);
ASSERT_EQ(input.assigned_external_port, output.assigned_external_port);
}
TEST_F(Ports, PCP_MapRequestRoundtrip) {
const pcp::MapRequest input {
.nonce = nonce,
.protocol = pcp::Protocol::tcp,
.reserved_0 = { 0x04, 0x05, 0x06 },
.internal_port = 0xBEEF,
.suggested_external_port = 0xCAFE,
.suggested_external_ip = ip
};
ports::serialise(input, stream);
const auto output = deserialise<pcp::MapRequest>(buffer);
ASSERT_EQ(input.nonce, output.nonce);
ASSERT_EQ(input.protocol, output.protocol);
ASSERT_EQ(input.reserved_0, output.reserved_0);
ASSERT_EQ(input.internal_port, output.internal_port);
ASSERT_EQ(input.suggested_external_port, input.suggested_external_port);
ASSERT_EQ(input.suggested_external_ip, input.suggested_external_ip);
}
TEST_F(Ports, PCP_OptionHeaderRoundtrip) {
const pcp::OptionHeader input {
.code = pcp::OptionCode::prefer_failure,
.reserved = 0xFE,
.length = 0xFAFA
};
ports::serialise(input, stream);
const auto output = deserialise<pcp::OptionHeader>(buffer);
ASSERT_EQ(input.code, output.code);
ASSERT_EQ(input.reserved, output.reserved);
ASSERT_EQ(input.length, output.length);
}
TEST_F(Ports, NATPMP_MapRequestRoundtrip) {
const natpmp::MapRequest input {
.version = 0,
.opcode = natpmp::Opcode::resp_tcp,
.reserved = 0xFFFF,
.internal_port = 0xCAFE,
.external_port = 0xBEEF,
.lifetime = 0xABBCCDDE
};
ports::serialise(input, stream);
const auto output = deserialise<natpmp::MapRequest>(buffer);
ASSERT_EQ(input.version, output.version);
ASSERT_EQ(input.opcode, output.opcode);
ASSERT_EQ(input.reserved, output.reserved);
ASSERT_EQ(input.internal_port, output.internal_port);
ASSERT_EQ(input.external_port, output.external_port);
ASSERT_EQ(input.lifetime, output.lifetime);
}
TEST_F(Ports, NATPMP_MapResponseRoundtrip) {
const natpmp::MapResponse input {
.version = 0,
.opcode = natpmp::Opcode::tcp,
.result_code = natpmp::Result::unsupported_opcode,
.secs_since_epoch = 0xBAADF00D,
.internal_port = 0xBEEF,
.external_port = 0xCAFE,
.lifetime = 0xABBCCDDE
};
ports::serialise(input, stream);
const auto output = deserialise<natpmp::MapResponse>(buffer);
ASSERT_EQ(input.version, output.version);
ASSERT_EQ(input.opcode, output.opcode);
ASSERT_EQ(input.result_code, output.result_code);
ASSERT_EQ(input.internal_port, output.internal_port);
ASSERT_EQ(input.external_port, output.external_port);
ASSERT_EQ(input.lifetime, output.lifetime);
}
TEST_F(Ports, NATPMP_ExtAddressRequestRoundtrip) {
const natpmp::ExtAddressRequest input {
.version = 0,
.opcode = natpmp::Opcode::request_external
};
ports::serialise(input, stream);
const auto output = deserialise<natpmp::ExtAddressRequest>(buffer);
ASSERT_EQ(input.version, output.version);
ASSERT_EQ(input.opcode, output.opcode);
}
TEST_F(Ports, NATPMP_ExtAddressResponseRoundtrip) {
const natpmp::ExtAddressResponse input {
.version = 0,
.opcode = natpmp::Opcode::resp_ext,
.result_code = natpmp::Result::success,
.secs_since_epoch = 0xBAADF00D,
.external_ip = 0xC0A80001
};
ports::serialise(input, stream);
const auto output = deserialise<natpmp::ExtAddressResponse>(buffer);
ASSERT_EQ(input.version, output.version);
ASSERT_EQ(input.opcode, output.opcode);
ASSERT_EQ(input.result_code, output.result_code);
ASSERT_EQ(input.secs_since_epoch, output.secs_since_epoch);
ASSERT_EQ(input.external_ip, output.external_ip);
}
TEST_F(Ports, NATPMP_UnsupportedErrorResponseRoundtrip) {
const natpmp::UnsupportedErrorResponse input {
.version = 0,
.opcode = natpmp::Opcode::resp_ext,
.result_code = natpmp::Result::unsupported_version,
.secs_since_epoch = 0xBAADF00D
};
ports::serialise(input, stream);
const auto output = deserialise<natpmp::UnsupportedErrorResponse>(buffer);
ASSERT_EQ(input.version, output.version);
ASSERT_EQ(input.opcode, output.opcode);
ASSERT_EQ(input.result_code, output.result_code);
ASSERT_EQ(input.secs_since_epoch, output.secs_since_epoch);
}
TEST_F(Ports, PCP_TestRequestVector) {
const auto address = boost::asio::ip::make_address("::ffff:192.168.0.4");
const auto v6_bytes = address.to_v6().to_bytes();
const auto request = deserialise<pcp::RequestHeader>(pcp_mapping_request);
ASSERT_EQ(request.version, PCP_VERSION);
ASSERT_EQ(request.response, false);
ASSERT_EQ(request.reserved_0, 0);
ASSERT_EQ(request.opcode, pcp::Opcode::map);
ASSERT_EQ(request.lifetime, 7200);
ASSERT_EQ(request.client_ip, v6_bytes);
const std::array<std::uint8_t, 12> nonce {
0xf0, 0x6e, 0xee, 0xba, 0xd1, 0xf7,
0x1c, 0x65, 0x4b, 0x26, 0x1f, 0x2f
};
const std::array<std::uint8_t, 16> ip {};
const std::array<std::uint8_t, 3> reserved {
0x00, 0x00, 0x00
};
std::span<const std::uint8_t> body_buff = {
pcp_mapping_request.begin() + pcp::HEADER_SIZE, pcp_mapping_request.end()
};
const auto body = deserialise<pcp::MapRequest>(body_buff);
ASSERT_EQ(body.internal_port, 8085);
ASSERT_EQ(body.suggested_external_port, 8085);
ASSERT_EQ(body.suggested_external_ip, ip);
ASSERT_EQ(body.nonce, nonce);
ASSERT_EQ(body.reserved_0, reserved);
}
TEST_F(Ports, PCP_TestResponseVector) {
const std::array<std::uint8_t, 12> res_1{};
const auto header = deserialise<pcp::ResponseHeader>(pcp_mapping_response);
ASSERT_EQ(header.version, PCP_VERSION);
ASSERT_EQ(header.reserved_0, 0);
ASSERT_EQ(header.reserved_1, res_1);
ASSERT_EQ(header.epoch_time, 783343);
ASSERT_EQ(header.opcode, pcp::Opcode::map);
ASSERT_EQ(header.lifetime, 120);
ASSERT_EQ(header.response, true);
const std::array<std::uint8_t, 12> nonce {
0xf0, 0x6e, 0xee, 0xba, 0xd1, 0xf7,
0x1c, 0x65, 0x4b, 0x26, 0x1f, 0x2f
};
const auto address = boost::asio::ip::make_address("::ffff:209.244.0.3");
const auto v6_bytes = address.to_v6().to_bytes();
const std::array<std::uint8_t, 3> reserved {};
std::span<const std::uint8_t> body_buff = {
pcp_mapping_response.begin() + pcp::HEADER_SIZE, pcp_mapping_response.end()
};
const auto body = deserialise<pcp::MapResponse>(body_buff);
ASSERT_EQ(body.assigned_external_port, 8085);
ASSERT_EQ(body.assigned_external_ip, v6_bytes);
ASSERT_EQ(body.internal_port, 8085);
ASSERT_EQ(body.protocol, pcp::Protocol::tcp);
ASSERT_EQ(body.reserved, reserved);
ASSERT_EQ(body.nonce, nonce);
}
TEST(PortsUPnP, HTTPHeader_Parse) {
std::string_view header {
R"(HTTP/1.1 200 OK)" "\r\n"
R"(Cache-Control: max-age=120)" "\r\n"
R"(Connection: Keep-Alive)" "\r\n"
R"(Content-Length: 14813)" "\r\n"
R"(Content-Type: text/xml)" "\r\n"
R"(Date: Tue, 12 Mar 2024 21:42:45 GMT)" "\r\n"
R"(ETag: "5B88239F8043B07A")" "\r\n"
R"(Expires: Tue, 12 Mar 2024 21:44:45 GMT)" "\r\n"
R"(Last-Modified: Fri, 02 Jun 2023 14:34:02 GMT)" "\r\n"
R"(Mime-Version: 1.0)" "\r\n"
R"(Keep-Alive: timeout=60, max=300)" "\r\n"
};
upnp::HTTPHeader parsed{};
ASSERT_TRUE(upnp::parse_http_header(header, parsed));
ASSERT_EQ(parsed.text, "OK");
ASSERT_EQ(parsed.code, upnp::HTTPStatus::ok);
ASSERT_EQ(parsed.fields["Cache-Control"], "max-age=120");
ASSERT_EQ(parsed.fields["Connection"], "Keep-Alive");
ASSERT_EQ(parsed.fields["Content-Length"], "14813");
ASSERT_EQ(parsed.fields["Content-Type"], "text/xml");
ASSERT_EQ(parsed.fields["Date"], "Tue, 12 Mar 2024 21:42:45 GMT");
ASSERT_EQ(parsed.fields["ETag"], R"("5B88239F8043B07A")");
ASSERT_EQ(parsed.fields["Expires"], "Tue, 12 Mar 2024 21:44:45 GMT");
ASSERT_EQ(parsed.fields["Last-Modified"], "Fri, 02 Jun 2023 14:34:02 GMT");
ASSERT_EQ(parsed.fields["Mime-Version"], "1.0");
ASSERT_EQ(parsed.fields["Keep-Alive"], "timeout=60, max=300");
header = std::string_view{
R"(HTTP/1.1 404 Not Found)" "\r\n"
R"(Access-Control-Allow-Origin: *)" "\r\n"
R"(Connection: Keep-Alive)" "\r\n"
R"(Content-Encoding: gzip)" "\r\n"
R"(Content-Type: text/html; charset=utf-8)" "\r\n"
R"(Date: Mon, 18 Jul 2016 16:06:00 GMT)" "\r\n"
R"(Etag: "c561c68d0ba92bbeb8b0f612a9199f722e3a621a")" "\r\n"
R"(Keep-Alive: timeout=5, max=997)" "\r\n"
R"(Last-Modified: Mon, 18 Jul 2016 02:36:04 GMT)" "\r\n"
R"(Server: Apache)" "\r\n"
R"(Set-Cookie: mykey=myvalue; expires=Mon, 17-Jul-2017 16:06:00 GMT; Max-Age=31449600; Path=/; secure)" "\r\n"
R"(Transfer-Encoding: chunked)" "\r\n"
R"(Vary: Cookie, Accept-Encoding)" "\r\n"
R"(X-Backend-Server: developer2.webapp.scl3.mozilla.com)" "\r\n"
R"(X-Cache-Info: not cacheable; meta data too large)" "\r\n"
R"(X-kuma-revision: 1085259)" "\r\n"
R"(x-frame-options: DENY)" "\r\n"
};
parsed = {};
ASSERT_TRUE(upnp::parse_http_header(header, parsed));
ASSERT_EQ(parsed.text, "Not Found");
ASSERT_EQ(parsed.code, upnp::HTTPStatus::not_found);
// make sure the lookup is case-insensitive
ASSERT_EQ(parsed.fields["Access-Control-Allow-Origin"], "*");
ASSERT_EQ(parsed.fields["aCcesS-COntroL-allow-origiN"], "*");
ASSERT_EQ(parsed.fields["ACCESS-CONTROL-ALLOW-ORIGIN"], "*");
ASSERT_EQ(parsed.fields["access-control-allow-origin"], "*");
ASSERT_EQ(parsed.fields["Connection"], "Keep-Alive");
ASSERT_EQ(parsed.fields["Content-Encoding"], "gzip");
ASSERT_EQ(parsed.fields["Content-Type"], "text/html; charset=utf-8");
ASSERT_EQ(parsed.fields["Date"], "Mon, 18 Jul 2016 16:06:00 GMT");
ASSERT_EQ(parsed.fields["Etag"], R"("c561c68d0ba92bbeb8b0f612a9199f722e3a621a")");
ASSERT_EQ(parsed.fields["Keep-Alive"], "timeout=5, max=997");
ASSERT_EQ(parsed.fields["Last-Modified"], "Mon, 18 Jul 2016 02:36:04 GMT");
ASSERT_EQ(parsed.fields["Server"], "Apache");
ASSERT_EQ(parsed.fields["Set-Cookie"], "mykey=myvalue; expires=Mon, 17-Jul-2017 16:06:00 GMT; Max-Age=31449600; Path=/; secure");
ASSERT_EQ(parsed.fields["Transfer-Encoding"], "chunked");
ASSERT_EQ(parsed.fields["Vary"], "Cookie, Accept-Encoding");
ASSERT_EQ(parsed.fields["X-Backend-Server"], "developer2.webapp.scl3.mozilla.com");
ASSERT_EQ(parsed.fields["X-Cache-Info"], "not cacheable; meta data too large");
ASSERT_EQ(parsed.fields["X-kuma-revision"], "1085259");
ASSERT_EQ(parsed.fields["x-frame-options"], "DENY");
}
TEST(PortsUPnP, HTTPHeader_Invalid) {
std::string_view header {
R"(Cache-Control: max-age=120))" "\r\n"
R"(Connection: Keep-Alive)" "\r\n"
R"(Content-Length: 14813)" "\r\n"
R"(Content-Type: text/xml)" "\r\n"
R"(Date: Tue, 12 Mar 2024 21:42:45 GMT)" "\r\n"
R"(ETag: "5B88239F8043B07A")" "\r\n"
R"(Expires: Tue, 12 Mar 2024 21:44:45 GMT)" "\r\n"
R"(Last-Modified: Fri, 02 Jun 2023 14:34:02 GMT)" "\r\n"
R"(Mime-Version: 1.0)" "\r\n"
R"(Keep-Alive: timeout=60, max=300)" "\r\n"
};
upnp::HTTPHeader parsed{};
ASSERT_FALSE(upnp::parse_http_header(header, parsed));
}
TEST(PortsUPnP, SVToInt) {
EXPECT_ANY_THROW(upnp::sv_to_int("test"));
EXPECT_ANY_THROW(upnp::sv_to_int(" 1234567"));
EXPECT_ANY_THROW(upnp::sv_to_int("1234567 "));
EXPECT_ANY_THROW(upnp::sv_to_int("a1234567"));
EXPECT_ANY_THROW(upnp::sv_to_int("1234567a"));
EXPECT_ANY_THROW(upnp::sv_to_int("0xFFFF"));
EXPECT_ANY_THROW(upnp::sv_to_int("0b00000001"));
EXPECT_EQ(123456789, upnp::sv_to_int("0123456789"));
EXPECT_EQ(0, upnp::sv_to_int("0"));
constexpr auto int_max = std::numeric_limits<int>::max();
const auto int_max_str = std::to_string(int_max);
EXPECT_EQ(int_max, upnp::sv_to_int(int_max_str));
constexpr auto int_min = std::numeric_limits<int>::min();
const auto int_min_str = std::to_string(int_min);
EXPECT_EQ(int_min, upnp::sv_to_int(int_min_str));
}
TEST(PortsUPnP, SVToLong) {
constexpr auto max = std::numeric_limits<long>::max();
const auto max_str = std::to_string(max);
EXPECT_EQ(max, upnp::sv_to_long(max_str));
constexpr auto min = std::numeric_limits<long>::min();
const auto min_str = std::to_string(min);
EXPECT_EQ(min, upnp::sv_to_long(min_str));
}
TEST(PortsUPnP, SVToLongLong) {
constexpr auto max = std::numeric_limits<long long>::max();
const auto max_str = std::to_string(max);
EXPECT_EQ(max, upnp::sv_to_ll(max_str));
constexpr auto min = std::numeric_limits<long long>::min();
const auto min_str = std::to_string(min);
EXPECT_EQ(min, upnp::sv_to_ll(min_str));
}
Reference in a new issue View git blame Copy permalink