/** * @file source/ActivMiddleware/Misc/PcapParser.h * * @brief Header file for the pcap parser class and functions. */ #if (!defined ACTIV_PCAP_PARSER_H) #define ACTIV_PCAP_PARSER_H #include "ActivMiddleware/ActivBase/ActivBase.h" #include "ActivMiddleware/ActivBase/File.h" #include "ActivMiddleware/ActivBase/FieldTypes/DateTime.h" #include "ActivMiddleware/ActivFramework/UiIo.h" #include "ActivMiddleware/Misc/Fmt.h" namespace Activ { namespace Pcap { //! Parser class. class Parser { public: //! List of supported protocols enum LinkLayer { LINK_LAYER_UNDEFINED, // Any other unsupported protocol LINK_LAYER_ETHERNET, // IEEE 802.3 Ethernet protocol LINK_LAYER_ETHERNET_VLAN, // IEEE 802.1Q Ethernet VLAN protocol LINK_LAYER_ETHERNET_QINQ // IEEE 802.1ad Ethernet QinQ protocol }; enum InternetLayer { INTERNET_LAYER_UNDEFINED, // Any other unsupported protocol INTERNET_LAYER_IP_V4, // IPv4 protocol INTERNET_LAYER_IP_V6 // IPv6 protocol (options are currently not supported) }; enum TransportLayer { TRANSPORT_LAYER_UNDEFINED, // Any other unsupported protocol TRANSPORT_LAYER_UDP, // UDP protocol TRANSPORT_LAYER_TCP // TCP protocol }; //! Pcap file header class. class PcapFileHeader { public: //! Clean up old values. void Reset(); uint32_t m_endianNumber; ///< determined if the file is written in big or little endian uint16_t m_versionMajor; ///< major version number of the file format uint16_t m_versionMinor; ///< minor version number of the file format int32_t m_timeZoneOffset; ///< GMT to local time zone correction in seconds, always 0 uint32_t m_accuracy; ///< accuracy of timestamps, always 0 uint32_t m_snapshotLenght; ///< the maximum amount of byte captured for each datagram uint32_t m_linkLayerType; ///< link layer header type (only 1, i.e. ethernet, is supported) bool m_isSameEndian; ///< Whether the file is written in the same endian as this machine bool m_isNanoseconds; ///< Whether timestamps are in nanoseconds or microseconds }; //! Pcap datagram header class. class PcapDatagramHeader { public: //! Clean up old values. void Reset(); DateTime m_timestamp; ///< timestamp of when the packet was captured uint32_t m_savedLength; ///< the number of bytes saves for this datagram uint32_t m_originalLength; ///< the original legth of the datagram }; //! Ethernet header class. class EthernetHeader { public: //! Clean up old values. void Reset(); String m_sourceMacAddress; ///< the MAC address of the source String m_destinationMacAddress; ///< the MAC address of the recipient LinkLayer m_ethernetType; ///< ethernet protocol type (see LinkLayer enum for values) }; //! IP header class. class IpHeader { public: //! Clean up old values. void Reset(); String m_sourceIpAddress; ///< the IP address of the source String m_destinationIpAddress; ///< the IP address of the recipient uint16_t m_packetLength; ///< the packet length. In IPv4 this includes the header, in IPv6 it doesn't InternetLayer m_ipType; ///< IP protocol type (see InternetLayer enum for values) }; //! Transport layer header class. class TransportHeader { public: //! Clean up old values. void Reset(); uint16_t m_sourcePort; ///< the port of the source uint16_t m_destinationPort; ///< the port of the recipient uint16_t m_packetLength; ///< the packet length. UDP has an explicit length that includes the header, for TCP this field is a data offset TransportLayer m_transportType; ///< either UDP or TCP }; //! Headers class, contains a collection of all the other headers. class Headers { public: PcapDatagramHeader m_pcapDatagramHeader; ///< The pcap header. EthernetHeader m_ethernetHeader; ///< Link layer header. IpHeader m_ipHeader; ///< Internet layer header. TransportHeader m_transportHeader; ///< Transport layer header. }; //! Constructor. Parser(); //! Destructor. ~Parser(); /** * @brief Open a pcap file. * * @param fileName the pcap file to open * * @retval STATUS_CODE_SUCCESS * @retval STATUS_CODE_END_OF_DATA * @retval ... */ StatusCode OpenPcapFile(const String &fileName); /** * @brief Open a pcap file. * * @param fileName the pcap file to open * @param pcapFileHeader returns the pcap file header * * @retval STATUS_CODE_SUCCESS * @retval STATUS_CODE_END_OF_DATA * @retval ... */ StatusCode OpenPcapFile(const String &fileName, PcapFileHeader *&pcapFileHeader); //! Close a pcap file. StatusCode ClosePcapFile(); //! Return true if file is open. bool IsPcapFileOpen(); /** * @brief Parse the next datagram in the file and returns the payload. The pPayload pointer returned may be invalidated by successive calls to this method. * * @param pPayload the payload after pcap and all networks layers have been removed * @param payloadLength the length of the payload as recorded in the pcap file * * @retval STAUS_CODE_SUCCESS * @retval STATUS_CODE_END_OF_DATA * @retval STATUS_CODE_NOT_INITIALIZED * @retval STATUS_CODE_INVALID_LENGTH * @retval STATUS_CODE_IGNORED * @retval ... */ StatusCode ParseNextDatagram(const byte_t *&pPayload, size_t &payloadLength); /** * @brief Parse the next datagram in the file and returns the payload. The pPayload and headers pointers returned may be invalidated by successive calls to this method. * * @param pPayload the payload after pcap and all networks layers have been removed * @param payloadLength the length of the payload as recorded in the pcap file * @param headers returns the headers that have been parsed * * @retval STAUS_CODE_SUCCESS * @retval STATUS_CODE_END_OF_DATA * @retval STATUS_CODE_NOT_INITIALIZED * @retval STATUS_CODE_INVALID_LENGTH * @retval STATUS_CODE_IGNORED * @retval ... */ StatusCode ParseNextDatagram(const byte_t *&pPayload, size_t &payloadLength, Headers *&headers); /** * @brief Move to the beginning of the file, but after the pcap file header. * * @retval STATUS_CODE_SUCCESS * @retval ... */ StatusCode MoveToFirstDatagram(); private: /** * @brief Parse the pcap header of the next datagram. * * @param pDatagram the datagram after the pcap header has beeen removed * @param datagramLength the length of the datagram as recorded in the pcap file * * @retval STAUS_CODE_SUCCESS * @retval STATUS_CODE_END_OF_DATA * @retval STATUS_CODE_NOT_INITIALIZED * @retval STATUS_CODE_INVALID_LENGTH * @retval ... */ StatusCode ParsePcapHeader(const byte_t *&pDatagram, size_t &datagramLength); /** * @brief Parse link layer header. * * @param pDatagram the datagram to parse * @param datagramLength the length of the datagram as recorded in the pcap file * @param pPayload the payload after the ethernet header has been removed * @param payloadLength the length of the payload as recorded in the pcap file * * @retval STAUS_CODE_SUCCESS * @retval STATUS_CODE_END_OF_DATA * @retval STATUS_CODE_IGNORED * @retval ... */ StatusCode ParseLinkHeader(const byte_t *pDatagram, size_t datagramLength, const byte_t *&pPayload, size_t &payloadLength); /** * @brief Parse internet layer header. * * @param pDatagram the datagram to parse * @param datagramLength the length of the datagram as recorded in the pcap file * @param pPayload the payload after the IP header has been removed * @param payloadLength the length of the payload as recorded in the pcap file * * @retval STAUS_CODE_SUCCESS * @retval STATUS_CODE_END_OF_DATA * @retval STATUS_CODE_IGNORED * @retval STATUS_CODE_INVALID_LENGTH * @retval ... */ StatusCode ParseInternetHeader(const byte_t *pDatagram, size_t datagramLength, const byte_t *&pPayload, size_t &payloadLength); /** * @brief Parse transport layer header. * * @param pDatagram the datagram to parse * @param datagramLength the length of the datagram as recorded in the pcap file * @param pPayload the payload after the TCP or UDP header has been removed * @param payloadLength the length of the payload as recorded in the pcap file * * @retval STAUS_CODE_SUCCESS * @retval STATUS_CODE_END_OF_DATA * @retval STATUS_CODE_IGNORED * @retval STATUS_CODE_INVALID_LENGTH * @retval ... */ StatusCode ParseTransportHeader(const byte_t *pDatagram, size_t datagramLength, const byte_t *&pPayload, size_t &payloadLength); /** * @brief Refill the buffer from the pcap file. * * @retval STAUS_CODE_SUCCESS * @retval STATUS_CODE_END_OF_DATA * @retval ... */ StatusCode ReadPcapFile(); /** * @brief Parse the fields in the pcap file header. * * @retval STAUS_CODE_SUCCESS * @retval ... */ template StatusCode ParsePcapFileHeader(); /** * @brief Parse the fields in the pcap datagram header. * @retval STAUS_CODE_SUCCESS * @retval ... */ template StatusCode ParsePcapDatagramHeader(); PcapFileHeader m_pcapFileHeader; ///< Pcap file header. Headers m_headers; ///< Datagram headers. // See https://wiki.wireshark.org/Development/LibpcapFileFormat for the meaning of these values. static ACTIV_BOOST_CONSTEXPR_OR_CONST uint32_t SAME_ENDIAN_MICRO = 0xa1b2c3d4; ///< Timestamps in microseconds, same endian as file writer. static ACTIV_BOOST_CONSTEXPR_OR_CONST uint32_t SWAP_ENDIAN_MICRO = 0xd4c3b2a1; ///< Timestamps in microseconds, different endian than the file writer. static ACTIV_BOOST_CONSTEXPR_OR_CONST uint32_t SAME_ENDIAN_NANO = 0xa1b23c4d; ///< Timestamps in nanoseconds, same endian as the file writer. static ACTIV_BOOST_CONSTEXPR_OR_CONST uint32_t SWAP_ENDIAN_NANO = 0x4d3cb2a1; ///< Timestaps in nanoseconds, different endian than the file writer. // See http://www.tcpdump.org/linktypes.html for the complete list of types. static ACTIV_BOOST_CONSTEXPR_OR_CONST uint32_t LINK_TYPE_ETHERNET = 1; ///< The supported link layer protocol. static ACTIV_BOOST_CONSTEXPR_OR_CONST size_t PCAP_FILE_HEADER_SIZE = 24; ///< Size of the pcap file header. static ACTIV_BOOST_CONSTEXPR_OR_CONST size_t PCAP_DATAGRAM_HEADER_SIZE = 16; ///< Size of the pcap datagram header. static ACTIV_BOOST_CONSTEXPR_OR_CONST size_t ETHERNET_HEADER_LEN = 14; ///< Ethernet header size without vlan. static ACTIV_BOOST_CONSTEXPR_OR_CONST size_t IPV4_HEADER_LEN = 20; ///< IPv4 header length without options. static ACTIV_BOOST_CONSTEXPR_OR_CONST size_t IPV6_HEADER_LEN = 40; ///< IPv6 header length without options. static ACTIV_BOOST_CONSTEXPR_OR_CONST size_t UDP_HEADER_LEN = 8; ///< UDP header length. static ACTIV_BOOST_CONSTEXPR_OR_CONST size_t TCP_HEADER_LEN = 20; ///< TCP header length without options. // EtherType field, see https://en.wikipedia.org/wiki/EtherType for all available values. static ACTIV_BOOST_CONSTEXPR_OR_CONST uint16_t VLAN_TAG = 0x8100; ///< Identifies VLAN ethernet headers, protocol IEEE 802.1Q. static ACTIV_BOOST_CONSTEXPR_OR_CONST uint16_t QINQ_TAG = 0x88A8; ///< Identifies VLAN ethernet headers incapsulated into VLAN headers, protocol IEEE 802.1ad. static ACTIV_BOOST_CONSTEXPR_OR_CONST uint16_t IPV4_TAG = 0x0800; ///< The next header is IPv4. static ACTIV_BOOST_CONSTEXPR_OR_CONST uint16_t IPV6_TAG = 0x86DD; ///< The next header is IPv6. // IP protocol byte, see https://en.wikipedia.org/wiki/List_of_IP_protocol_numbers for all available values. // See https://en.wikipedia.org/wiki/IPv4 for the position of the protocol byte in the IPv4 header. // See https://en.wikipedia.org/wiki/IPv6_packet for the position of the protocol byte in the IPv6 header. static ACTIV_BOOST_CONSTEXPR_OR_CONST byte_t TCP_TAG = 0x06; ///< Identifies the TCP protocol. static ACTIV_BOOST_CONSTEXPR_OR_CONST byte_t UDP_TAG = 0x11; ///< Identifies the UDP protocol. static ACTIV_BOOST_CONSTEXPR_OR_CONST size_t BUFFER_SIZE = 1024 * 1024; ///< 1 MB, buffer size. byte_t * m_pBuffer; ///< The buffer used to store datagrams. size_t m_bufferCurrentPosition; ///< Position in the buffer at the start of the current pcap datagram header. size_t m_bufferEndPosition; ///< End of the buffer, can be less than BUFFER_SIZE. File m_pcapFile; ///< File in pcap format. }; // --------------------------------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------------------------------- inline void Parser::PcapFileHeader::Reset() { m_endianNumber = 0; m_versionMajor = 0; m_versionMinor = 0; m_timeZoneOffset = 0; m_accuracy = 0; m_snapshotLenght = 0; m_linkLayerType = 0; m_isSameEndian = true; m_isNanoseconds = false; } // --------------------------------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------------------------------- inline void Parser::PcapDatagramHeader::Reset() { m_timestamp.Reset(); m_savedLength = 0; m_originalLength = 0; } // --------------------------------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------------------------------- inline void Parser::EthernetHeader::Reset() { m_sourceMacAddress = ""; m_destinationMacAddress = ""; m_ethernetType = LINK_LAYER_UNDEFINED; } // --------------------------------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------------------------------- inline void Parser::IpHeader::Reset() { m_sourceIpAddress = ""; m_destinationIpAddress = ""; m_packetLength = 0; m_ipType = INTERNET_LAYER_UNDEFINED; } // --------------------------------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------------------------------- inline void Parser::TransportHeader::Reset() { m_sourcePort = 0; m_destinationPort = 0; m_packetLength = 0; m_transportType = TRANSPORT_LAYER_UNDEFINED; } // --------------------------------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------------------------------- inline Parser::Parser() : m_pBuffer(new byte_t[BUFFER_SIZE]), m_bufferCurrentPosition(0), m_bufferEndPosition(0) { } // --------------------------------------------------------------------------------------------------------------------------------- inline Parser::~Parser() { delete[] m_pBuffer; } // --------------------------------------------------------------------------------------------------------------------------------- inline StatusCode Parser::OpenPcapFile(const String &fileName) { ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, m_pcapFile.Open(fileName, File::AccessFlags::Read(), File::ShareFlags::Read())); // Initialize. m_bufferCurrentPosition = 0; m_bufferEndPosition = 0; ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, ReadPcapFile()); if (PCAP_FILE_HEADER_SIZE > m_bufferEndPosition) return STATUS_CODE_END_OF_DATA; ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, (MessageValidator::CopyUnsignedBinaryIntegralToUnsignedBinaryIntegral( m_pcapFileHeader.m_endianNumber, m_pBuffer, sizeof(uint32_t)))); switch (m_pcapFileHeader.m_endianNumber) { case SAME_ENDIAN_MICRO: m_pcapFileHeader.m_isSameEndian = true; m_pcapFileHeader.m_isNanoseconds = false; break; case SWAP_ENDIAN_MICRO: m_pcapFileHeader.m_isSameEndian = false; m_pcapFileHeader.m_isNanoseconds = false; break; case SAME_ENDIAN_NANO: m_pcapFileHeader.m_isSameEndian = true; m_pcapFileHeader.m_isNanoseconds = true; break; case SWAP_ENDIAN_NANO: m_pcapFileHeader.m_isSameEndian = false; m_pcapFileHeader.m_isNanoseconds = true; break; } // Parse the rest of the header. if (m_pcapFileHeader.m_isSameEndian) ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, ParsePcapFileHeader()); else ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, ParsePcapFileHeader()); m_bufferCurrentPosition = PCAP_FILE_HEADER_SIZE; return STATUS_CODE_SUCCESS; } // --------------------------------------------------------------------------------------------------------------------------------- inline StatusCode Parser::OpenPcapFile(const String &fileName, PcapFileHeader *&pcapFileHeader) { ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, OpenPcapFile(fileName)); pcapFileHeader = &m_pcapFileHeader; return STATUS_CODE_SUCCESS; } // --------------------------------------------------------------------------------------------------------------------------------- inline StatusCode Parser::ClosePcapFile() { return m_pcapFile.Close(); } // --------------------------------------------------------------------------------------------------------------------------------- inline bool Parser::IsPcapFileOpen() { return m_pcapFile.IsOpen(); } // --------------------------------------------------------------------------------------------------------------------------------- inline StatusCode Parser::ParseNextDatagram(const byte_t *&pPayload, size_t &payloadLength) { ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, ParsePcapHeader(pPayload, payloadLength)); const byte_t *pDatagram = pPayload; size_t datagramLength = payloadLength; ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, ParseLinkHeader(pDatagram, datagramLength, pPayload, payloadLength)); pDatagram = pPayload; datagramLength = payloadLength; ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, ParseInternetHeader(pDatagram, datagramLength, pPayload, payloadLength)); pDatagram = pPayload; datagramLength = payloadLength; ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, ParseTransportHeader(pDatagram, datagramLength, pPayload, payloadLength)); return STATUS_CODE_SUCCESS; } // --------------------------------------------------------------------------------------------------------------------------------- inline StatusCode Parser::ParseNextDatagram(const byte_t *&pPayload, size_t &payloadLength, Headers *&headers) { ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, ParseNextDatagram(pPayload, payloadLength)); headers = &m_headers; return STATUS_CODE_SUCCESS; } // --------------------------------------------------------------------------------------------------------------------------------- inline StatusCode Parser::ParsePcapHeader(const byte_t *&pDatagram, size_t &datagramLength) { if (!m_pcapFile.IsOpen()) return STATUS_CODE_NOT_INITIALIZED; // Reset previous values. m_headers.m_pcapDatagramHeader.Reset(); // Parse Pcap datagram header. if ((m_bufferCurrentPosition + PCAP_DATAGRAM_HEADER_SIZE) > m_bufferEndPosition) ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, ReadPcapFile()); if (m_pcapFileHeader.m_isSameEndian) ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, ParsePcapDatagramHeader()); else ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, ParsePcapDatagramHeader()); // The datagram must have a valid length. if (m_headers.m_pcapDatagramHeader.m_savedLength > m_pcapFileHeader.m_snapshotLenght) return STATUS_CODE_INVALID_LENGTH; if (m_headers.m_pcapDatagramHeader.m_savedLength > m_headers.m_pcapDatagramHeader.m_originalLength) return STATUS_CODE_INVALID_LENGTH; m_bufferCurrentPosition += PCAP_DATAGRAM_HEADER_SIZE; // Read the datagram. if ((m_bufferCurrentPosition + m_headers.m_pcapDatagramHeader.m_savedLength) > m_bufferEndPosition) ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, ReadPcapFile()); size_t datagramStart = m_bufferCurrentPosition; m_bufferCurrentPosition += m_headers.m_pcapDatagramHeader.m_savedLength; datagramLength = m_headers.m_pcapDatagramHeader.m_savedLength; pDatagram = &m_pBuffer[datagramStart]; return STATUS_CODE_SUCCESS; } // --------------------------------------------------------------------------------------------------------------------------------- inline StatusCode Parser::ParseLinkHeader(const byte_t *pDatagram, size_t datagramLength, const byte_t *&pPayload, size_t &payloadLength) { if (LINK_TYPE_ETHERNET != m_pcapFileHeader.m_linkLayerType) return STATUS_CODE_IGNORED; uint16_t headerLength = 0; // Reset old values. m_headers.m_ethernetHeader.Reset(); // Parse ethernet header. if (ETHERNET_HEADER_LEN > datagramLength) { pPayload = 0; payloadLength = 0; return STATUS_CODE_END_OF_DATA; } uint16_t ethernetTag = 0; ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, (MessageValidator::CopyUnsignedBinaryIntegralToUnsignedBinaryIntegral(ethernetTag, &pDatagram[ETHERNET_HEADER_LEN - 2], sizeof(uint16_t)))); headerLength += ETHERNET_HEADER_LEN; m_headers.m_ethernetHeader.m_ethernetType = LINK_LAYER_ETHERNET; // IEEE 802.1Q ethernet header there are 4 additional bytes to parse. if (VLAN_TAG == ethernetTag) { if (datagramLength < static_cast(headerLength + 4)) { pPayload = 0; payloadLength = 0; return STATUS_CODE_END_OF_DATA; } ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, (MessageValidator::CopyUnsignedBinaryIntegralToUnsignedBinaryIntegral(ethernetTag, &pDatagram[ETHERNET_HEADER_LEN + 2], sizeof(uint16_t)))); headerLength += 4; m_headers.m_ethernetHeader.m_ethernetType = LINK_LAYER_ETHERNET_VLAN; } // IEEE 802.1ad ethernet header there are 8 additional bytes to parse. if (QINQ_TAG == ethernetTag) { if (datagramLength < static_cast(headerLength + 8)) { pPayload = 0; payloadLength = 0; return STATUS_CODE_END_OF_DATA; } ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, (MessageValidator::CopyUnsignedBinaryIntegralToUnsignedBinaryIntegral(ethernetTag, &pDatagram[ETHERNET_HEADER_LEN + 6], sizeof(uint16_t)))); headerLength += 8; m_headers.m_ethernetHeader.m_ethernetType = LINK_LAYER_ETHERNET_QINQ; } // Parse the MAC addresses. m_headers.m_ethernetHeader.m_destinationMacAddress = Fmt::Format("{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}", pDatagram[0], pDatagram[1], pDatagram[2], pDatagram[3], pDatagram[4], pDatagram[5]); m_headers.m_ethernetHeader.m_sourceMacAddress = Fmt::Format("{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}", pDatagram[6], pDatagram[7], pDatagram[8], pDatagram[9], pDatagram[10], pDatagram[11]); // Reset the Ip header and update the protocol type. m_headers.m_ipHeader.Reset(); if (IPV4_TAG == ethernetTag) m_headers.m_ipHeader.m_ipType = INTERNET_LAYER_IP_V4; if (IPV6_TAG == ethernetTag) m_headers.m_ipHeader.m_ipType = INTERNET_LAYER_IP_V6; payloadLength = datagramLength - headerLength; pPayload = ((payloadLength > 0) ? &pDatagram[headerLength] : 0); return STATUS_CODE_SUCCESS; } // --------------------------------------------------------------------------------------------------------------------------------- inline StatusCode Parser::ParseInternetHeader(const byte_t *pDatagram, size_t datagramLength, const byte_t *&pPayload, size_t &payloadLength) { if (INTERNET_LAYER_UNDEFINED == m_headers.m_ipHeader.m_ipType) return STATUS_CODE_IGNORED; uint16_t headerLength = 0; // Resets transport header. m_headers.m_transportHeader.Reset(); if (INTERNET_LAYER_IP_V4 == m_headers.m_ipHeader.m_ipType) { if (IPV4_HEADER_LEN > datagramLength) { pPayload = 0; payloadLength = 0; return STATUS_CODE_END_OF_DATA; } if (TCP_TAG == pDatagram[9]) m_headers.m_transportHeader.m_transportType = TRANSPORT_LAYER_TCP; if (UDP_TAG == pDatagram[9]) m_headers.m_transportHeader.m_transportType = TRANSPORT_LAYER_UDP; // Check if the ip header contains options and skip them. byte_t ihl = 15 & pDatagram[0]; if (5 > ihl) return STATUS_CODE_INVALID_LENGTH; if (datagramLength < (ihl * sizeof(uint32_t))) { pPayload = 0; payloadLength = 0; return STATUS_CODE_END_OF_DATA; } headerLength += ihl * sizeof(uint32_t); // Parse IP addresses. m_headers.m_ipHeader.m_sourceIpAddress = Fmt::Format("{}.{}.{}.{}", pDatagram[12], pDatagram[13], pDatagram[14], pDatagram[15]); m_headers.m_ipHeader.m_destinationIpAddress = Fmt::Format("{}.{}.{}.{}", pDatagram[16], pDatagram[17], pDatagram[18], pDatagram[19]); // Parse packet length. ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, (MessageValidator::CopyUnsignedBinaryIntegralToUnsignedBinaryIntegral( m_headers.m_ipHeader.m_packetLength, &pDatagram[2], sizeof(uint16_t)))); } // NOTE: does not support optional fields in IPv6, the packets with options will be ignored. if (INTERNET_LAYER_IP_V6 == m_headers.m_ipHeader.m_ipType) { if (IPV6_HEADER_LEN > datagramLength) { pPayload = 0; payloadLength = 0; return STATUS_CODE_END_OF_DATA; } if (TCP_TAG == pDatagram[6]) m_headers.m_transportHeader.m_transportType = TRANSPORT_LAYER_TCP; if (UDP_TAG == pDatagram[6]) m_headers.m_transportHeader.m_transportType = TRANSPORT_LAYER_UDP; headerLength += IPV6_HEADER_LEN; // Parse IP addresses, 16 bytes format. m_headers.m_ipHeader.m_sourceIpAddress = (Fmt::Format("{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}", pDatagram[8], pDatagram[9], pDatagram[10], pDatagram[11], pDatagram[12], pDatagram[13], pDatagram[14], pDatagram[15], pDatagram[16], pDatagram[17], pDatagram[18], pDatagram[19], pDatagram[20], pDatagram[21], pDatagram[22], pDatagram[23])); m_headers.m_ipHeader.m_destinationIpAddress = (Fmt::Format("{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}", pDatagram[24], pDatagram[25], pDatagram[26], pDatagram[27], pDatagram[28], pDatagram[29], pDatagram[30], pDatagram[31], pDatagram[32], pDatagram[33], pDatagram[34], pDatagram[35], pDatagram[36], pDatagram[37], pDatagram[38], pDatagram[39])); // Parse the packet length. ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, (MessageValidator::CopyUnsignedBinaryIntegralToUnsignedBinaryIntegral( m_headers.m_ipHeader.m_packetLength, &pDatagram[4], sizeof(uint16_t)))); } // Use the length from the IP header, rather than datagramLength to calculate the real payload length. // This will remove any padding bytes from the end of the payload. payloadLength = m_headers.m_ipHeader.m_packetLength - headerLength; pPayload = ((payloadLength > 0) ? &pDatagram[headerLength] : 0); return STATUS_CODE_SUCCESS; } // --------------------------------------------------------------------------------------------------------------------------------- inline StatusCode Parser::ParseTransportHeader(const byte_t *pDatagram, size_t datagramLength, const byte_t *&pPayload, size_t &payloadLength) { if (TRANSPORT_LAYER_UNDEFINED == m_headers.m_transportHeader.m_transportType) return STATUS_CODE_IGNORED; uint16_t headerLength = 0; // Parse source and destination port, they are in the same locations in both TCP and UDP. ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, (MessageValidator::CopyUnsignedBinaryIntegralToUnsignedBinaryIntegral( m_headers.m_transportHeader.m_sourcePort, pDatagram, sizeof(uint16_t)))); ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, (MessageValidator::CopyUnsignedBinaryIntegralToUnsignedBinaryIntegral( m_headers.m_transportHeader.m_destinationPort, &pDatagram[2], sizeof(uint16_t)))); if (TRANSPORT_LAYER_UDP == m_headers.m_transportHeader.m_transportType) { if (datagramLength < UDP_HEADER_LEN) { pPayload = 0; payloadLength = 0; return STATUS_CODE_END_OF_DATA; } ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, (MessageValidator::CopyUnsignedBinaryIntegralToUnsignedBinaryIntegral( m_headers.m_transportHeader.m_packetLength, &pDatagram[4], sizeof(uint16_t)))); headerLength += UDP_HEADER_LEN; } if (TRANSPORT_LAYER_TCP == m_headers.m_transportHeader.m_transportType) { if (datagramLength < TCP_HEADER_LEN) { pPayload = 0; payloadLength = 0; return STATUS_CODE_END_OF_DATA; } // Check if the TCP header contains options and skip them. byte_t dataOffset = pDatagram[12] >> 4; if (5 > dataOffset) return STATUS_CODE_INVALID_LENGTH; if (datagramLength < dataOffset * sizeof(uint32_t)) { pPayload = 0; payloadLength = 0; return STATUS_CODE_END_OF_DATA; } headerLength += (dataOffset * sizeof(uint32_t)); m_headers.m_transportHeader.m_packetLength = dataOffset; } payloadLength = datagramLength - headerLength; pPayload = ((payloadLength > 0) ? &pDatagram[headerLength] : 0); return STATUS_CODE_SUCCESS; } // --------------------------------------------------------------------------------------------------------------------------------- inline StatusCode Parser::ReadPcapFile() { // If there are bytes left at the end of the buffer, copy them to the start of the buffer. if ((0 < m_bufferCurrentPosition) && (m_bufferCurrentPosition < m_bufferEndPosition)) std::memcpy(m_pBuffer, &m_pBuffer[m_bufferCurrentPosition], m_bufferEndPosition - m_bufferCurrentPosition); size_t bytesRead = 0; size_t bytesToMove = m_bufferEndPosition - m_bufferCurrentPosition; StatusCode statusCode = m_pcapFile.Read(&m_pBuffer[bytesToMove], BUFFER_SIZE - bytesToMove, bytesRead); // Reached the end of the file. if ((0 == bytesRead) && (STATUS_CODE_SUCCESS == statusCode)) statusCode = STATUS_CODE_END_OF_DATA; if ((STATUS_CODE_SUCCESS != statusCode) && (STATUS_CODE_END_OF_DATA != statusCode)) { m_bufferCurrentPosition = 0; m_bufferEndPosition = 0; } m_bufferEndPosition = bytesRead + bytesToMove; m_bufferCurrentPosition = 0; return statusCode; } // --------------------------------------------------------------------------------------------------------------------------------- inline StatusCode Parser::MoveToFirstDatagram() { m_bufferCurrentPosition = 0; m_bufferEndPosition = 0; return m_pcapFile.SetPosition(PCAP_FILE_HEADER_SIZE); } // --------------------------------------------------------------------------------------------------------------------------------- template inline StatusCode Parser::ParsePcapFileHeader() { size_t bufferIndex = sizeof(uint32_t); ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, (MessageValidator::CopyUnsignedBinaryIntegralToUnsignedBinaryIntegral(m_pcapFileHeader.m_versionMajor, &m_pBuffer[bufferIndex], sizeof(uint16_t)))); bufferIndex += sizeof(uint16_t); ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, (MessageValidator::CopyUnsignedBinaryIntegralToUnsignedBinaryIntegral(m_pcapFileHeader.m_versionMinor, &m_pBuffer[bufferIndex], sizeof(uint16_t)))); bufferIndex += sizeof(uint16_t); ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, (MessageValidator::CopySignedBinaryIntegralToSignedBinaryIntegral(m_pcapFileHeader.m_timeZoneOffset, &m_pBuffer[bufferIndex], sizeof(int32_t)))); bufferIndex += sizeof(int32_t); ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, (MessageValidator::CopyUnsignedBinaryIntegralToUnsignedBinaryIntegral(m_pcapFileHeader.m_accuracy, &m_pBuffer[bufferIndex], sizeof(uint32_t)))); bufferIndex += sizeof(uint32_t); ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, (MessageValidator::CopyUnsignedBinaryIntegralToUnsignedBinaryIntegral(m_pcapFileHeader.m_snapshotLenght, &m_pBuffer[bufferIndex], sizeof(uint32_t)))); bufferIndex += sizeof(uint32_t); ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, (MessageValidator::CopyUnsignedBinaryIntegralToUnsignedBinaryIntegral(m_pcapFileHeader.m_linkLayerType, &m_pBuffer[bufferIndex], sizeof(uint32_t)))); return STATUS_CODE_SUCCESS; } // --------------------------------------------------------------------------------------------------------------------------------- template inline StatusCode Parser::ParsePcapDatagramHeader() { size_t bufferIndex = m_bufferCurrentPosition; uint32_t time = 0; ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, (MessageValidator::CopyUnsignedBinaryIntegralToUnsignedBinaryIntegral(time, &m_pBuffer[bufferIndex], sizeof(uint32_t)))); m_headers.m_pcapDatagramHeader.m_timestamp.SetEpoch(time); bufferIndex += sizeof(uint32_t); ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, (MessageValidator::CopyUnsignedBinaryIntegralToUnsignedBinaryIntegral(time, &m_pBuffer[bufferIndex], sizeof(uint32_t)))); if (m_pcapFileHeader.m_isNanoseconds) m_headers.m_pcapDatagramHeader.m_timestamp.AddMilliseconds(time / 1000000); else m_headers.m_pcapDatagramHeader.m_timestamp.AddMilliseconds(time / 1000); bufferIndex += sizeof(uint32_t); ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, (MessageValidator::CopyUnsignedBinaryIntegralToUnsignedBinaryIntegral( m_headers.m_pcapDatagramHeader.m_savedLength, &m_pBuffer[bufferIndex], sizeof(uint32_t)))); bufferIndex += sizeof(uint32_t); ACTIV_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, (MessageValidator::CopyUnsignedBinaryIntegralToUnsignedBinaryIntegral( m_headers.m_pcapDatagramHeader.m_originalLength, &m_pBuffer[bufferIndex], sizeof(uint32_t)))); return STATUS_CODE_SUCCESS; } } // namespace Pcap } // namespace Activ #endif // (!defined ACTIV_PCAP_PARSER_H)