From a4c67e5acd8bc6c4697fb8f63c71cb1a76904161 Mon Sep 17 00:00:00 2001 From: Matias Fontanini Date: Sun, 21 Dec 2014 10:18:59 -0800 Subject: [PATCH] Added PKTAP header. --- include/tins/pdu.h | 1 + include/tins/pktap.h | 109 +++++++++++++++++++++++++++++++++++++++++++ src/CMakeLists.txt | 1 + src/pktap.cpp | 71 ++++++++++++++++++++++++++++ src/sniffer.cpp | 6 +++ 5 files changed, 188 insertions(+) create mode 100644 include/tins/pktap.h create mode 100644 src/pktap.cpp diff --git a/include/tins/pdu.h b/include/tins/pdu.h index 9934125..8067d0b 100644 --- a/include/tins/pdu.h +++ b/include/tins/pdu.h @@ -175,6 +175,7 @@ namespace Tins { PPI, IPSEC_AH, IPSEC_ESP, + PKTAP, USER_DEFINED_PDU = 1000 }; diff --git a/include/tins/pktap.h b/include/tins/pktap.h new file mode 100644 index 0000000..21b1e4a --- /dev/null +++ b/include/tins/pktap.h @@ -0,0 +1,109 @@ +/* + * Copyright (c) 2014, Matias Fontanini + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#ifndef TINS_PKTAP_H +#define TINS_PKTAP_H + +#include "pdu.h" + +namespace Tins { + +class PKTAP : public PDU { +public: + /** + * This PDU's flag. + */ + static const PDU::PDUType pdu_flag = PDU::PKTAP; + + /** + * Default constructor. + */ + PKTAP(); + + /** + * \brief Constructs a PKTAP object from a buffer and adds all + * identifiable PDUs found in the buffer as children of this + * one. + * + * If there is not enough size for an IP header, a + * malformed_packet exception is thrown. + * + * \param buffer The buffer from which this PDU will be constructed. + * \param total_sz The total size of the buffer. + */ + PKTAP(const uint8_t* buffer, uint32_t total_sz); + + /** + * \brief Getter for the PDU's type. + * \sa PDU::pdu_type + */ + PDUType pdu_type() const { return pdu_flag; } + + /** + * \brief Returns the header size. + * + * This metod overrides PDU::header_size. + * \sa PDU::header_size + */ + uint32_t header_size() const; + + /** + * \sa PDU::clone + */ + PKTAP *clone() const { + return new PKTAP(*this); + } +private: + struct pktap_header { + uint32_t length; + uint32_t next; + uint32_t dlt; + uint8_t pth_ifname[24]; + uint32_t flags; + uint32_t protocol_family; + uint32_t header_length; + uint32_t trailer_length; + uint32_t pid; + uint8_t command[20]; + uint32_t service_class; + uint16_t interface_type; + uint16_t interface_unit; + uint32_t epid; + uint8_t ecommand[20]; + }; + + void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent); + + + pktap_header header_; +}; + +} // Tins + +#endif // TINS_PKTAP_H diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 1165c72..25a93ce 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -38,6 +38,7 @@ ADD_LIBRARY( packet_writer.cpp ppi.cpp pdu.cpp + pktap.cpp radiotap.cpp address_range.cpp rawpdu.cpp diff --git a/src/pktap.cpp b/src/pktap.cpp new file mode 100644 index 0000000..c0decf8 --- /dev/null +++ b/src/pktap.cpp @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2014, Matias Fontanini + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#include +#include +#include "exceptions.h" +#include "pktap.h" +#include "internals.h" + +namespace Tins { + +PKTAP::PKTAP(const uint8_t* buffer, uint32_t total_sz) +{ + if (total_sz < sizeof(pktap_header)) { + throw malformed_packet(); + } + memcpy(&header_, buffer, sizeof(header_)); + uint32_t header_length = header_.length; + if (header_length > total_sz) { + throw malformed_packet(); + } + buffer += header_length; + total_sz -= header_length; + if (header_.next && total_sz > 0) { + inner_pdu( + Internals::pdu_from_flag( + (Constants::Ethernet::e)header_.dlt, + buffer, + total_sz + ) + ); + } +} + +uint32_t PKTAP::header_size() const +{ + return sizeof(header_); +} + +void PKTAP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) +{ + throw std::runtime_error("PKTAP cannot be serialized"); +} + +} // Tins diff --git a/src/sniffer.cpp b/src/sniffer.cpp index 40ec1fe..67fef58 100644 --- a/src/sniffer.cpp +++ b/src/sniffer.cpp @@ -42,6 +42,7 @@ #include "loopback.h" #include "rawpdu.h" #include "dot3.h" +#include "pktap.h" #include "sll.h" #include "ppi.h" @@ -159,6 +160,11 @@ PtrPacket BaseSniffer::next_packet() { throw protocol_disabled(); #endif } + #ifdef DLT_PKTAP + else if (iface_type == DLT_PKTAP) { + handler = &sniff_loop_handler(); + } + #endif // DLT_PKTAP else if(iface_type == DLT_NULL) handler = &sniff_loop_handler; else if(iface_type == DLT_LINUX_SLL)