Ashin Walpola
d107534eb2
obu-firmware builds against the vanetza-idf C-ITS library, which until now came from the colleague's microbu-esp32c5 tree beside the repository and was not tracked here, so a clone of this repository could not build the firmware it ships. The library alone is now part of obu-firmware, as obu-firmware/external/vanetza-idf: their external/vanetza-idf at commit cf4b99f, unchanged (9775 files; see its PROVENANCE.md). CMake takes it from there by default; -DVANETZA_IDF_DIR still points the build elsewhere. The rest of the colleague's tree (their own VAM firmware, PKI tooling, station-link Python tools, the V2X2MAP bridge) stays out of this repository and gitignored; nothing is pushed to their repository. NOTES.md, docs/06, TODO.md and the pcap verifier's usage line point at the new location.
519 lines
22 KiB
C++
519 lines
22 KiB
C++
#include <gtest/gtest.h>
|
|
#include <vanetza/btp/header.hpp>
|
|
#include <vanetza/common/its_aid.hpp>
|
|
#include <vanetza/common/manual_runtime.hpp>
|
|
#include <vanetza/geonet/router.hpp>
|
|
#include <vanetza/geonet/tests/fake_interfaces.hpp>
|
|
#include <vanetza/geonet/tests/security_context.hpp>
|
|
|
|
#include "printer.hpp"
|
|
|
|
using namespace vanetza;
|
|
|
|
class RouterIndicate : public ::testing::Test
|
|
{
|
|
public:
|
|
RouterIndicate() :
|
|
// AT certificate is valid at this time
|
|
runtime(Clock::at("2019-11-21 14:27:53")), security(runtime), router(runtime, mib), packet_drop_occurred(false) {}
|
|
|
|
protected:
|
|
virtual void SetUp() override
|
|
{
|
|
runtime.trigger(Clock::at("2019-11-21 14:27:54"));
|
|
geonet::Address gn_addr;
|
|
gn_addr.mid(MacAddress { 0, 0, 0, 0, 0, 1});
|
|
router.set_address(gn_addr);
|
|
router.set_access_interface(&req_ifc);
|
|
router.set_transport_handler(geonet::UpperProtocol::IPv6, &ind_ifc);
|
|
router.set_security_entity(&security.entity());
|
|
packet_drop_occurred = false;
|
|
router.packet_dropped = [this](geonet::Router::PacketDropReason r) {
|
|
drop_reason = r;
|
|
packet_drop_occurred = true;
|
|
};
|
|
test_payload_trans = {47, 11, 1, 4, 42, 85};
|
|
test_payload_sess = {55, 1, 16, 45, 2, 65};
|
|
test_payload_pres = {33, 2, 6, 27, 75, 1};
|
|
send_payload.insert(send_payload.end(), test_payload_trans.begin(), test_payload_trans.end());
|
|
send_payload.insert(send_payload.end(), test_payload_sess.begin(), test_payload_sess.end());
|
|
send_payload.insert(send_payload.end(), test_payload_pres.begin(), test_payload_pres.end());
|
|
}
|
|
|
|
std::unique_ptr<geonet::DownPacket> create_packet()
|
|
{
|
|
std::unique_ptr<geonet::DownPacket> packet { new geonet::DownPacket() };
|
|
packet->layer(OsiLayer::Transport) = ByteBuffer(test_payload_trans);
|
|
packet->layer(OsiLayer::Session) = ByteBuffer(test_payload_sess);
|
|
packet->layer(OsiLayer::Presentation) = ByteBuffer(test_payload_pres);
|
|
return packet;
|
|
}
|
|
|
|
std::unique_ptr<geonet::UpPacket> get_up_packet(const ByteBuffer& sec_packet_buffer)
|
|
{
|
|
// parse the data into UpPacket
|
|
std::unique_ptr<geonet::UpPacket> up_packet(new geonet::UpPacket(CohesivePacket(sec_packet_buffer, OsiLayer::Network)));
|
|
return up_packet;
|
|
}
|
|
|
|
ByteBuffer create_secured_packet()
|
|
{
|
|
// enable security
|
|
mib.itsGnSecurity = true;
|
|
|
|
// create ShbDataRequest
|
|
geonet::ShbDataRequest request(mib, aid::CA);
|
|
request.upper_protocol = geonet::UpperProtocol::IPv6;
|
|
|
|
// Router handles request
|
|
auto confirm = router.request(request, create_packet());
|
|
assert(confirm.accepted());
|
|
|
|
// secured packet on network layer
|
|
ByteBuffer sec_packet_buffer;
|
|
req_ifc.m_last_packet->layer(OsiLayer::Network).convert(sec_packet_buffer);
|
|
assert(req_ifc.m_last_packet->size(OsiLayer::Transport, max_osi_layer()) == 0);
|
|
|
|
assert(!sec_packet_buffer.empty());
|
|
return sec_packet_buffer;
|
|
}
|
|
|
|
ByteBuffer create_plain_packet()
|
|
{
|
|
// disable security
|
|
mib.itsGnSecurity = false;
|
|
|
|
// create ShbDataRequest
|
|
geonet::ShbDataRequest request(mib, aid::CA);
|
|
request.upper_protocol = geonet::UpperProtocol::IPv6;
|
|
|
|
// Router handles request
|
|
auto confirm = router.request(request, create_packet());
|
|
assert(confirm.accepted());
|
|
|
|
// secured packet on network layer
|
|
ByteBuffer plain_packet_buffer;
|
|
for (auto layer : osi_layer_range<OsiLayer::Network, max_osi_layer()>()) {
|
|
ByteBuffer layer_buffer;
|
|
req_ifc.m_last_packet->layer(layer).convert(layer_buffer);
|
|
plain_packet_buffer.insert(plain_packet_buffer.end(), layer_buffer.begin(), layer_buffer.end());
|
|
}
|
|
|
|
assert(!plain_packet_buffer.empty());
|
|
return plain_packet_buffer;
|
|
}
|
|
|
|
bool test_and_reset_packet_drop()
|
|
{
|
|
bool result = packet_drop_occurred;
|
|
packet_drop_occurred = false;
|
|
return result;
|
|
}
|
|
|
|
MacAddress mac_address_sender = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06};
|
|
MacAddress mac_address_destination = {0x07, 0x08, 0x09, 0x00, 0x01, 0x02};
|
|
geonet::ManagementInformationBase mib;
|
|
ManualRuntime runtime;
|
|
SecurityContext security;
|
|
geonet::Router router;
|
|
geonet::Router::PacketDropReason drop_reason;
|
|
FakeRequestInterface req_ifc;
|
|
FakeTransportInterface ind_ifc;
|
|
ByteBuffer test_payload_trans;
|
|
ByteBuffer test_payload_sess;
|
|
ByteBuffer test_payload_pres;
|
|
ByteBuffer send_payload;
|
|
|
|
private:
|
|
bool packet_drop_occurred;
|
|
};
|
|
|
|
TEST_F(RouterIndicate, shb_unsecured_equal_payload)
|
|
{
|
|
// create shb-up-packet by calling request
|
|
ByteBuffer sec_packet_buffer = create_plain_packet();
|
|
std::unique_ptr<geonet::UpPacket> packet_up = get_up_packet(sec_packet_buffer);
|
|
|
|
// call indicate
|
|
router.indicate(std::move(packet_up), mac_address_sender, mac_address_destination);
|
|
|
|
// check hook, it shouldn't have been called
|
|
EXPECT_FALSE(test_and_reset_packet_drop());
|
|
|
|
// check if packet was not discarded
|
|
ASSERT_NE(nullptr, ind_ifc.m_last_packet.get());
|
|
// prepare a packet to check it's payload
|
|
CohesivePacket* received_payload_ptr = boost::get<CohesivePacket>(ind_ifc.m_last_packet.get());
|
|
ASSERT_NE(nullptr, received_payload_ptr);
|
|
// extract received payload
|
|
auto received_payload_range = (*received_payload_ptr)[OsiLayer::Transport];
|
|
const ByteBuffer received_payload = ByteBuffer(received_payload_range.begin(), received_payload_range.end());
|
|
// check payload
|
|
EXPECT_EQ(send_payload, received_payload);
|
|
}
|
|
|
|
TEST_F(RouterIndicate, shb_secured_equal_payload)
|
|
{
|
|
// create shb-up-packet by calling request
|
|
ByteBuffer sec_packet_buffer = create_secured_packet();
|
|
std::unique_ptr<geonet::UpPacket> packet_up = get_up_packet(sec_packet_buffer);
|
|
|
|
// call indicate
|
|
router.indicate(std::move(packet_up), mac_address_sender, mac_address_destination);
|
|
|
|
// check hook, it shouldn't have been called
|
|
EXPECT_FALSE(test_and_reset_packet_drop()) << "Packet drop reason: " << static_cast<int>(drop_reason);
|
|
|
|
// check if packet was not discarded
|
|
ASSERT_NE(nullptr, ind_ifc.m_last_packet.get());
|
|
ASSERT_TRUE(ind_ifc.m_last_indication);
|
|
// prepare a packet to check it's payload
|
|
CohesivePacket* received_payload_ptr = boost::get<CohesivePacket>(ind_ifc.m_last_packet.get());
|
|
ASSERT_NE(nullptr, received_payload_ptr);
|
|
// extract received payload
|
|
auto received_payload_range = (*received_payload_ptr)[OsiLayer::Transport];
|
|
const ByteBuffer received_payload = ByteBuffer(received_payload_range.begin(), received_payload_range.end());
|
|
// check payload
|
|
EXPECT_EQ(send_payload, received_payload);
|
|
// check permissions are exposed correctly, these are set by NaiveCertificateProvider for the aid::CA
|
|
ASSERT_TRUE(ind_ifc.m_last_indication.get().its_aid);
|
|
ASSERT_TRUE(ind_ifc.m_last_indication.get().permissions);
|
|
EXPECT_EQ(ind_ifc.m_last_indication.get().its_aid.get(), aid::CA);
|
|
EXPECT_EQ(ind_ifc.m_last_indication.get().permissions.get(), ByteBuffer({ 1, 0, 0 }));
|
|
}
|
|
|
|
TEST_F(RouterIndicate, shb_secured_hook_its_protocol_version)
|
|
{
|
|
// modify up_packet for negative test
|
|
ByteBuffer broken_packet_buffer = create_secured_packet();
|
|
broken_packet_buffer[0] ^= 0xff;
|
|
|
|
std::unique_ptr<geonet::UpPacket> broken_packet_up = get_up_packet(broken_packet_buffer);
|
|
router.indicate(std::move(broken_packet_up), mac_address_sender, mac_address_destination);
|
|
|
|
// check hook
|
|
EXPECT_TRUE(test_and_reset_packet_drop());
|
|
EXPECT_EQ(geonet::Router::PacketDropReason::ITS_Protocol_Version, drop_reason);
|
|
|
|
// check if packet was dropped
|
|
EXPECT_EQ(nullptr, ind_ifc.m_last_packet.get());
|
|
}
|
|
|
|
TEST_F(RouterIndicate, shb_secured_hook_parse_basic_header)
|
|
{
|
|
// modify up_packet for negative test
|
|
ByteBuffer broken_packet_buffer = create_secured_packet();
|
|
broken_packet_buffer.erase(broken_packet_buffer.begin() + 3, broken_packet_buffer.end());
|
|
|
|
std::unique_ptr<geonet::UpPacket> broken_packet_up = get_up_packet(broken_packet_buffer);
|
|
router.indicate(std::move(broken_packet_up), mac_address_sender, mac_address_destination);
|
|
|
|
// check hook
|
|
EXPECT_TRUE(test_and_reset_packet_drop());
|
|
EXPECT_EQ(geonet::Router::PacketDropReason::Parse_Basic_Header, drop_reason);
|
|
|
|
// check if packet was dropped
|
|
EXPECT_EQ(nullptr, ind_ifc.m_last_packet.get());
|
|
}
|
|
|
|
TEST_F(RouterIndicate, shb_secured_hook_parse_secured_header)
|
|
{
|
|
// modify up_packet for negative test
|
|
ByteBuffer broken_packet_buffer = create_secured_packet();
|
|
broken_packet_buffer[geonet::BasicHeader::length_bytes] = 0x01;
|
|
|
|
std::unique_ptr<geonet::UpPacket> broken_packet_up = get_up_packet(broken_packet_buffer);
|
|
router.indicate(std::move(broken_packet_up), mac_address_sender, mac_address_destination);
|
|
|
|
// check hook
|
|
EXPECT_TRUE(test_and_reset_packet_drop());
|
|
EXPECT_EQ(geonet::Router::PacketDropReason::Parse_Secured_Header, drop_reason);
|
|
|
|
// check if packet was dropped
|
|
EXPECT_EQ(nullptr, ind_ifc.m_last_packet.get());
|
|
}
|
|
|
|
TEST_F(RouterIndicate, shb_secured_hook_decap_unsuccessful_non_strict)
|
|
{
|
|
mib.itsGnSnDecapResultHandling = geonet::SecurityDecapHandling::Non_Strict;
|
|
|
|
// modify up_packet for positive test
|
|
ByteBuffer broken_packet_buffer = create_secured_packet();
|
|
broken_packet_buffer[broken_packet_buffer.size() - 1] ^= 0xff;
|
|
|
|
std::unique_ptr<geonet::UpPacket> broken_packet_up = get_up_packet(broken_packet_buffer);
|
|
router.indicate(std::move(broken_packet_up), mac_address_sender, mac_address_destination);
|
|
|
|
// check hook
|
|
EXPECT_FALSE(test_and_reset_packet_drop());
|
|
|
|
// check if packet arrived at transport layer
|
|
EXPECT_EQ(1, ind_ifc.m_indications);
|
|
EXPECT_NE(nullptr, ind_ifc.m_last_packet.get());
|
|
}
|
|
|
|
TEST_F(RouterIndicate, shb_secured_hook_decap_unsuccessful_strict)
|
|
{
|
|
mib.itsGnSnDecapResultHandling = geonet::SecurityDecapHandling::Strict;
|
|
|
|
// modify up_packet for negative test
|
|
ByteBuffer broken_packet_buffer = create_secured_packet();
|
|
broken_packet_buffer[broken_packet_buffer.size() - 1] ^= 0xff;
|
|
|
|
std::unique_ptr<geonet::UpPacket> broken_packet_up = get_up_packet(broken_packet_buffer);
|
|
router.indicate(std::move(broken_packet_up), mac_address_sender, mac_address_destination);
|
|
|
|
// check hook
|
|
EXPECT_TRUE(test_and_reset_packet_drop());
|
|
EXPECT_EQ(geonet::Router::PacketDropReason::Decap_Unsuccessful_Strict, drop_reason);
|
|
|
|
// check if packet was dropped
|
|
EXPECT_EQ(nullptr, ind_ifc.m_last_packet.get());
|
|
}
|
|
|
|
TEST_F(RouterIndicate, shb_secured_hook_parse_extended_header)
|
|
{
|
|
// modify up_packet for negative test
|
|
ByteBuffer broken_packet_buffer = create_plain_packet();
|
|
// cut extended header partly off (18 bytes payload)
|
|
ASSERT_LT(32, broken_packet_buffer.size());
|
|
broken_packet_buffer.erase(broken_packet_buffer.end() - 32, broken_packet_buffer.end());
|
|
|
|
std::unique_ptr<geonet::UpPacket> broken_packet_up = get_up_packet(broken_packet_buffer);
|
|
router.indicate(std::move(broken_packet_up), mac_address_sender, mac_address_destination);
|
|
|
|
// check hook
|
|
EXPECT_TRUE(test_and_reset_packet_drop());
|
|
EXPECT_EQ(geonet::Router::PacketDropReason::Parse_Extended_Header, drop_reason);
|
|
|
|
// check if packet was dropped
|
|
EXPECT_EQ(nullptr, ind_ifc.m_last_packet.get());
|
|
}
|
|
|
|
TEST_F(RouterIndicate, shb_secured_hook_payload_size)
|
|
{
|
|
// modify up_packet for negative test
|
|
ByteBuffer broken_packet_buffer = create_plain_packet();
|
|
// cut payload partly off (18 bytes payload)
|
|
ASSERT_LT(7, broken_packet_buffer.size());
|
|
broken_packet_buffer.erase(broken_packet_buffer.end() - 7, broken_packet_buffer.end());
|
|
|
|
std::unique_ptr<geonet::UpPacket> broken_packet_up = get_up_packet(broken_packet_buffer);
|
|
router.indicate(std::move(broken_packet_up), mac_address_sender, mac_address_destination);
|
|
|
|
// check hook
|
|
EXPECT_TRUE(test_and_reset_packet_drop());
|
|
EXPECT_EQ(geonet::Router::PacketDropReason::Payload_Size, drop_reason);
|
|
|
|
// check if packet was dropped
|
|
EXPECT_EQ(nullptr, ind_ifc.m_last_packet.get());
|
|
}
|
|
|
|
TEST_F(RouterIndicate, shb_secured_hook_hop_limit)
|
|
{
|
|
// modify up_packet for negative test
|
|
ByteBuffer broken_packet_buffer = create_secured_packet();
|
|
// resest hop limit in basic header
|
|
broken_packet_buffer[geonet::BasicHeader::length_bytes - 1] = mib.itsGnDefaultHopLimit + 1;
|
|
|
|
std::unique_ptr<geonet::UpPacket> broken_packet_up = get_up_packet(broken_packet_buffer);
|
|
router.indicate(std::move(broken_packet_up), mac_address_sender, mac_address_destination);
|
|
|
|
// check hook
|
|
EXPECT_TRUE(test_and_reset_packet_drop());
|
|
EXPECT_EQ(geonet::Router::PacketDropReason::Hop_Limit, drop_reason);
|
|
|
|
// check if packet was dropped
|
|
EXPECT_EQ(nullptr, ind_ifc.m_last_packet.get());
|
|
}
|
|
|
|
TEST_F(RouterIndicate, shb_secured_hook_unsecured_packet)
|
|
{
|
|
// modify up_packet for negative test
|
|
ByteBuffer packet_buffer = create_plain_packet();
|
|
|
|
// enable security after create_plain_packet() disabled it
|
|
mib.itsGnSecurity = true;
|
|
|
|
std::unique_ptr<geonet::UpPacket> packet_up = get_up_packet(packet_buffer);
|
|
router.indicate(std::move(packet_up), mac_address_sender, mac_address_destination);
|
|
|
|
// check hook
|
|
EXPECT_TRUE(test_and_reset_packet_drop());
|
|
EXPECT_EQ(geonet::Router::PacketDropReason::Decap_Unsuccessful_Strict, drop_reason);
|
|
|
|
// check if packet was dropped
|
|
EXPECT_EQ(nullptr, ind_ifc.m_last_packet.get());
|
|
}
|
|
|
|
TEST_F(RouterIndicate, shb_secured_hook_unsecured_packet_nonstrict)
|
|
{
|
|
// modify up_packet for negative test
|
|
ByteBuffer packet_buffer = create_plain_packet();
|
|
|
|
// enable security after create_plain_packet() disabled it
|
|
mib.itsGnSecurity = true;
|
|
mib.itsGnSnDecapResultHandling = geonet::SecurityDecapHandling::Non_Strict;
|
|
|
|
std::unique_ptr<geonet::UpPacket> packet_up = get_up_packet(packet_buffer);
|
|
router.indicate(std::move(packet_up), mac_address_sender, mac_address_destination);
|
|
|
|
// check hook
|
|
EXPECT_FALSE(test_and_reset_packet_drop());
|
|
// check if packet was not discarded
|
|
ASSERT_NE(nullptr, ind_ifc.m_last_packet.get());
|
|
ASSERT_TRUE(ind_ifc.m_last_indication);
|
|
// prepare a packet to check it's payload
|
|
CohesivePacket* received_payload_ptr = boost::get<CohesivePacket>(ind_ifc.m_last_packet.get());
|
|
ASSERT_NE(nullptr, received_payload_ptr);
|
|
// extract received payload
|
|
auto received_payload_range = (*received_payload_ptr)[OsiLayer::Transport];
|
|
const ByteBuffer received_payload = ByteBuffer(received_payload_range.begin(), received_payload_range.end());
|
|
// check payload
|
|
EXPECT_EQ(send_payload, received_payload);
|
|
}
|
|
|
|
TEST_F(RouterIndicate, shb_secured_v3_message_digest)
|
|
{
|
|
mac_address_sender = MacAddress { 0xfe, 0x38, 0x4c, 0xe0, 0xb8, 0x90 };
|
|
mac_address_destination = MacAddress { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
|
|
const ByteBuffer gn_buffer = {
|
|
0x12, 0x00, 0x05, 0x01, 0x03, 0x81, 0x00, 0x40,
|
|
0x03, 0x80, 0x56, 0x20, 0x50, 0x02, 0x80, 0x00,
|
|
0x32, 0x01, 0x00, 0x14, 0x00, 0xfe, 0x38, 0x4c,
|
|
0xe0, 0xb8, 0x90, 0xbf, 0x6b, 0x2b, 0x74, 0x1f,
|
|
0x45, 0x28, 0x68, 0x06, 0x64, 0x09, 0x65, 0x80,
|
|
0x42, 0x03, 0xbf, 0x00, 0x00, 0xa0, 0x00, 0x07,
|
|
0xd1, 0x00, 0x00, 0x02, 0x02, 0x4c, 0xe0, 0xb8,
|
|
0x90, 0x2e, 0x6b, 0x00, 0x5a, 0x9d, 0x42, 0x2b,
|
|
0xce, 0x35, 0xbb, 0x82, 0x02, 0x3c, 0x23, 0x06,
|
|
0xda, 0x35, 0x96, 0xd4, 0x58, 0x3b, 0xe1, 0x20,
|
|
0x6d, 0x03, 0x02, 0x96, 0x8a, 0xcb, 0x33, 0xe6,
|
|
0x61, 0xff, 0xaa, 0x10, 0x3f, 0xe0, 0x14, 0x19,
|
|
0x80, 0x40, 0x01, 0x24, 0x00, 0x01, 0xc8, 0x0b,
|
|
0xba, 0xad, 0xa0, 0x64, 0x80, 0x12, 0x7c, 0xff,
|
|
0x38, 0x4c, 0xe0, 0xb8, 0x90, 0x80, 0x82, 0x9d,
|
|
0xee, 0xde, 0x15, 0x9a, 0x66, 0x08, 0x1d, 0x03,
|
|
0x6f, 0x7b, 0x28, 0x2d, 0x8f, 0xf0, 0x43, 0xc6,
|
|
0x35, 0x5f, 0x51, 0x07, 0x65, 0xb1, 0x42, 0x77,
|
|
0xb7, 0x72, 0x27, 0x15, 0x59, 0x0c, 0x9e, 0x47,
|
|
0x82, 0xfc, 0xbe, 0xe3, 0x3a, 0xbc, 0x51, 0x93,
|
|
0xfb, 0xbd, 0xa7, 0xf0, 0x4f, 0xde, 0xb2, 0xfe,
|
|
0x88, 0xa5, 0x19, 0x5e, 0xa7, 0x03, 0xca, 0xf4,
|
|
0x12, 0x21, 0x32, 0x37, 0xe8, 0x5d, 0xda
|
|
};
|
|
|
|
// gn_buffer contains a CAM using BTP-B transport
|
|
router.set_transport_handler(geonet::UpperProtocol::BTP_B, &ind_ifc);
|
|
router.set_transport_handler(geonet::UpperProtocol::IPv6, nullptr);
|
|
|
|
// message with digest will not be accepted because its certificate is unknown
|
|
EXPECT_EQ(security.certificate_cache_v3().size(), 0);
|
|
router.indicate(get_up_packet(gn_buffer), mac_address_sender, mac_address_destination);
|
|
EXPECT_TRUE(test_and_reset_packet_drop());
|
|
|
|
// add certificate manually to certificate cache
|
|
const ByteBuffer certificate_buffer = {
|
|
0x80, 0x03, 0x00, 0x80, 0x56, 0xdf, 0xd6, 0xd6,
|
|
0x27, 0xa3, 0x62, 0xdc, 0x10, 0x83, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x1d, 0xdf, 0xf7, 0xb5, 0x84,
|
|
0x00, 0xa8, 0x01, 0x02, 0x80, 0x01, 0x24, 0x81,
|
|
0x04, 0x03, 0x01, 0x00, 0x00, 0x80, 0x01, 0x25,
|
|
0x81, 0x05, 0x04, 0x01, 0x90, 0x1a, 0x25, 0x80,
|
|
0x80, 0x82, 0x04, 0x27, 0xbb, 0x27, 0xc9, 0x98,
|
|
0xc1, 0xec, 0xa2, 0xb1, 0x0e, 0x71, 0x07, 0x98,
|
|
0x02, 0x44, 0x51, 0x8b, 0x3c, 0x50, 0xa3, 0xa3,
|
|
0x27, 0xb5, 0xb1, 0x90, 0xd0, 0x90, 0xf1, 0x45,
|
|
0x1f, 0x3d, 0x80, 0x80, 0x83, 0xc2, 0xf3, 0xca,
|
|
0xeb, 0xc7, 0xfa, 0x35, 0x94, 0x5c, 0x03, 0x0a,
|
|
0x5a, 0xe0, 0x1a, 0x41, 0x7a, 0xdf, 0x6d, 0xff,
|
|
0xd5, 0x41, 0xcc, 0xd2, 0xd9, 0x2b, 0xfe, 0xb6,
|
|
0x3d, 0xc1, 0x56, 0x89, 0xcb, 0xd6, 0xb8, 0xe3,
|
|
0x2b, 0xd5, 0xe8, 0x66, 0xd9, 0xfa, 0xa2, 0xfe,
|
|
0x55, 0x95, 0xe2, 0xdb, 0xb9, 0xbe, 0x3e, 0x96,
|
|
0x5a, 0x70, 0x94, 0x25, 0x8b, 0x4a, 0x24, 0x9d,
|
|
0xfb, 0x75, 0x8a, 0x07
|
|
};
|
|
security::v3::Certificate certificate;
|
|
EXPECT_TRUE(certificate.decode(certificate_buffer));
|
|
security.certificate_cache_v3().store(certificate);
|
|
EXPECT_EQ(security.certificate_cache_v3().size(), 1);
|
|
|
|
// expect that same message is now accepted
|
|
router.indicate(get_up_packet(gn_buffer), mac_address_sender, mac_address_destination);
|
|
EXPECT_FALSE(test_and_reset_packet_drop()) << "Packet drop reason: " << static_cast<int>(drop_reason);
|
|
|
|
// assure that packet has been passed to transport layer
|
|
ASSERT_TRUE(ind_ifc.m_last_indication);
|
|
EXPECT_EQ(ind_ifc.m_last_indication->upper_protocol, geonet::UpperProtocol::BTP_B);
|
|
EXPECT_EQ(ind_ifc.m_last_indication->security_report, security::VerificationReport::Success);
|
|
EXPECT_EQ(ind_ifc.m_last_indication->its_aid, aid::CA);
|
|
|
|
ASSERT_TRUE(ind_ifc.m_last_packet);
|
|
}
|
|
|
|
TEST_F(RouterIndicate, shb_secured_v3_message_certificate)
|
|
{
|
|
mac_address_sender = MacAddress { 0xfe, 0x38, 0x4c, 0xe0, 0xb8, 0x90 };
|
|
mac_address_destination = MacAddress { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
|
|
const ByteBuffer gn_buffer = {
|
|
0x12, 0x00, 0x05, 0x01, 0x03, 0x81, 0x00, 0x40,
|
|
0x03, 0x80, 0x56, 0x20, 0x50, 0x02, 0x80, 0x00,
|
|
0x32, 0x01, 0x00, 0x14, 0x00, 0xfe, 0x38, 0x4c,
|
|
0xe0, 0xb8, 0x90, 0xbf, 0x6b, 0x33, 0x44, 0x1f,
|
|
0x45, 0x28, 0x40, 0x06, 0x64, 0x0c, 0x70, 0x81,
|
|
0xae, 0x03, 0xbd, 0x00, 0x00, 0xa0, 0x00, 0x07,
|
|
0xd1, 0x00, 0x00, 0x02, 0x02, 0x4c, 0xe0, 0xb8,
|
|
0x90, 0x35, 0x71, 0x00, 0x5a, 0x9d, 0x42, 0x25,
|
|
0xee, 0x35, 0xbb, 0xfc, 0x82, 0x4a, 0x24, 0x46,
|
|
0xd8, 0x35, 0xa3, 0x54, 0x58, 0x3b, 0xe1, 0x21,
|
|
0x00, 0x83, 0x02, 0x96, 0x8a, 0xaf, 0x33, 0xf0,
|
|
0x81, 0xfe, 0x9a, 0x10, 0x3f, 0xa0, 0x14, 0x19,
|
|
0x80, 0x40, 0x01, 0x24, 0x00, 0x01, 0xc8, 0x0b,
|
|
0xba, 0xc9, 0x16, 0xae, 0x81, 0x01, 0x01, 0x80,
|
|
0x03, 0x00, 0x80, 0x56, 0xdf, 0xd6, 0xd6, 0x27,
|
|
0xa3, 0x62, 0xdc, 0x10, 0x83, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x1d, 0xdf, 0xf7, 0xb5, 0x84, 0x00,
|
|
0xa8, 0x01, 0x02, 0x80, 0x01, 0x24, 0x81, 0x04,
|
|
0x03, 0x01, 0x00, 0x00, 0x80, 0x01, 0x25, 0x81,
|
|
0x05, 0x04, 0x01, 0x90, 0x1a, 0x25, 0x80, 0x80,
|
|
0x82, 0x04, 0x27, 0xbb, 0x27, 0xc9, 0x98, 0xc1,
|
|
0xec, 0xa2, 0xb1, 0x0e, 0x71, 0x07, 0x98, 0x02,
|
|
0x44, 0x51, 0x8b, 0x3c, 0x50, 0xa3, 0xa3, 0x27,
|
|
0xb5, 0xb1, 0x90, 0xd0, 0x90, 0xf1, 0x45, 0x1f,
|
|
0x3d, 0x80, 0x80, 0x83, 0xc2, 0xf3, 0xca, 0xeb,
|
|
0xc7, 0xfa, 0x35, 0x94, 0x5c, 0x03, 0x0a, 0x5a,
|
|
0xe0, 0x1a, 0x41, 0x7a, 0xdf, 0x6d, 0xff, 0xd5,
|
|
0x41, 0xcc, 0xd2, 0xd9, 0x2b, 0xfe, 0xb6, 0x3d,
|
|
0xc1, 0x56, 0x89, 0xcb, 0xd6, 0xb8, 0xe3, 0x2b,
|
|
0xd5, 0xe8, 0x66, 0xd9, 0xfa, 0xa2, 0xfe, 0x55,
|
|
0x95, 0xe2, 0xdb, 0xb9, 0xbe, 0x3e, 0x96, 0x5a,
|
|
0x70, 0x94, 0x25, 0x8b, 0x4a, 0x24, 0x9d, 0xfb,
|
|
0x75, 0x8a, 0x07, 0x80, 0x82, 0xf4, 0x4c, 0xc3,
|
|
0xc3, 0xb1, 0x0c, 0xf7, 0x7c, 0xd9, 0x0c, 0x40,
|
|
0xfe, 0xe7, 0x30, 0x40, 0xad, 0x0b, 0xb4, 0xf8,
|
|
0x34, 0x55, 0x81, 0x37, 0xa6, 0x96, 0x81, 0x78,
|
|
0xe0, 0x53, 0x09, 0x06, 0xf7, 0x4f, 0x14, 0x43,
|
|
0x46, 0x88, 0x29, 0x6e, 0x22, 0xfe, 0xbb, 0x6f,
|
|
0x8e, 0x21, 0xad, 0x51, 0x7e, 0xb0, 0x81, 0x9a,
|
|
0x39, 0xf2, 0xaa, 0xd3, 0x37, 0x51, 0xf3, 0xab,
|
|
0xde, 0xdd, 0x69, 0xfe, 0xaf
|
|
};
|
|
// gn_buffer contains a CAM using BTP-B transport
|
|
router.set_transport_handler(geonet::UpperProtocol::BTP_B, &ind_ifc);
|
|
router.set_transport_handler(geonet::UpperProtocol::IPv6, nullptr);
|
|
|
|
router.indicate(get_up_packet(gn_buffer), mac_address_sender, mac_address_destination);
|
|
|
|
// assure that packet has not been dropped
|
|
EXPECT_FALSE(test_and_reset_packet_drop()) << "Packet drop reason: " << static_cast<int>(drop_reason);
|
|
|
|
// assure that packet has been passed to transport layer
|
|
ASSERT_TRUE(ind_ifc.m_last_indication);
|
|
EXPECT_EQ(ind_ifc.m_last_indication->upper_protocol, geonet::UpperProtocol::BTP_B);
|
|
EXPECT_EQ(ind_ifc.m_last_indication->security_report, security::VerificationReport::Success);
|
|
EXPECT_EQ(ind_ifc.m_last_indication->its_aid, aid::CA);
|
|
|
|
ASSERT_TRUE(ind_ifc.m_last_packet);
|
|
}
|