NtpLayer.h

Go to the documentation of this file.

#pragma once
 
#include "Logger.h"
#include "Layer.h"
#include "IpAddress.h"
 
 
namespace pcpp
{
    class NtpLayer : public Layer
    {
    private:
#pragma pack(push, 1)
        struct ntp_header
        {
#if (BYTE_ORDER == LITTLE_ENDIAN)
            uint8_t mode : 3,
                version : 3,
                leapIndicator : 2;
#else
            uint8_t leapIndicator : 2,
                version : 3,
                mode : 3;
#endif
            uint8_t stratum;
            int8_t pollInterval,
                precision;
            uint32_t rootDelay,
                rootDispersion,
                referenceIdentifier;
            uint64_t referenceTimestamp,
                originTimestamp,
                receiveTimestamp,
                transmitTimestamp;
        };
#pragma pack(pop)
 
#pragma pack(push, 1)
        struct ntp_v3_auth
        {
            uint32_t keyID;
            uint8_t dgst[8];  // 64 bit DES based
        };
#pragma pack(pop)
 
#pragma pack(push, 1)
        struct ntp_v4_auth_md5
        {
            uint32_t keyID;
            uint8_t dgst[16];
        };
#pragma pack(pop)
 
#pragma pack(push, 1)
        struct ntp_v4_auth_sha1
        {
            uint32_t keyID;
            uint8_t dgst[20];
        };
#pragma pack(pop)
 
        ntp_header* getNtpHeader() const
        {
            return (ntp_header*)m_Data;
        }
 
    public:
        enum LeapIndicator
        {
            NoWarning = 0,
            Last61Secs,
            Last59Secs,
            Unknown
        };
 
        enum Mode
        {
            Reserved = 0,
            SymActive,
            SymPassive,
            Client,
            Server,
            Broadcast,
            Control,
            PrivateUse
        };
 
        enum class ClockSource : uint32_t
        {
            // NTPv4
 
            GOES = ('G') | ('O' << 8) | ('E' << 16) | ('S' << 24),
            GPS = ('G') | ('P' << 8) | ('S' << 16),
            GAL = ('G') | ('A' << 8) | ('L' << 16),
            PPS = ('P') | ('P' << 8) | ('S' << 16),
            IRIG = ('I') | ('R' << 8) | ('I' << 16) | ('G' << 24),
            WWVB = ('W') | ('W' << 8) | ('V' << 16) | ('B' << 24),
            DCF = ('D') | ('C' << 8) | ('F' << 16),
            HBG = ('H') | ('B' << 8) | ('G' << 16),
            MSF = ('M') | ('S' << 8) | ('F' << 16),
            JJY = ('J') | ('J' << 8) | ('Y' << 16),
            LORC = ('L') | ('O' << 8) | ('R' << 16) | ('C' << 24),
            TDF = ('T') | ('D' << 8) | ('F' << 16),
            CHU = ('C') | ('H' << 8) | ('U' << 16),
            WWV = ('W') | ('W' << 8) | ('V' << 16),
            WWVH = ('W') | ('W' << 8) | ('V' << 16) | ('H' << 24),
            NIST = ('N') | ('I' << 8) | ('S' << 16) | ('T' << 24),
            ACTS = ('A') | ('C' << 8) | ('T' << 16) | ('S' << 24),
            USNO = ('U') | ('S' << 8) | ('N' << 16) | ('O' << 24),
            PTB = ('P') | ('T' << 8) | ('B' << 16),
            MRS = ('M') | ('R' << 8) | ('S' << 16),
            XFAC = ('X') | ('F' << 8) | ('A' << 16) | ('C' << 24),
            STEP = ('S') | ('T' << 8) | ('E' << 16) | ('P' << 24),
            GOOG = ('G') | ('O' << 8) | ('O' << 16) | ('G' << 24),
            DCFa = ('D') | ('C' << 8) | ('F' << 16) | ('a' << 24),
            DCFp = ('D') | ('C' << 8) | ('F' << 16) | ('p' << 24),
            GPSs = ('G') | ('P' << 8) | ('S' << 16) | ('s' << 24),
            GPSi = ('G') | ('P' << 8) | ('S' << 16) | ('i' << 24),
            GLNs = ('G') | ('L' << 8) | ('N' << 16) | ('s' << 24),
            GLNi = ('G') | ('L' << 8) | ('N' << 16) | ('i' << 24),
            LCL = ('L') | ('C' << 8) | ('L' << 16),
            LOCL = ('L') | ('O' << 8) | ('C' << 16) | ('L' << 24),
 
            // NTPv3
 
            DCN = ('D') | ('C' << 8) | ('N' << 16),
            TSP = ('T') | ('S' << 8) | ('P' << 16),
            DTS = ('D') | ('T' << 8) | ('S' << 16),
            ATOM = ('A') | ('T' << 8) | ('O' << 16) | ('M' << 24),
            VLF = ('V') | ('L' << 8) | ('F' << 16)
        };
 
        enum class KissODeath : uint32_t
        {
            ACST = ('A') | ('C' << 8) | ('S' << 16) | ('T' << 24),
            AUTH = ('A') | ('U' << 8) | ('T' << 16) | ('H' << 24),
            AUTO = ('A') | ('U' << 8) | ('T' << 16) | ('O' << 24),
            BCST = ('B') | ('C' << 8) | ('S' << 16) | ('T' << 24),
            CRYP = ('C') | ('R' << 8) | ('Y' << 16) | ('P' << 24),
            DENY = ('D') | ('E' << 8) | ('N' << 16) | ('Y' << 24),
            DROP = ('D') | ('R' << 8) | ('O' << 16) | ('P' << 24),
            RSTR = ('R') | ('S' << 8) | ('T' << 16) | ('R' << 24),
            INIT = ('I') | ('N' << 8) | ('I' << 16) | ('T' << 24),
            MCST = ('M') | ('C' << 8) | ('S' << 16) | ('T' << 24),
            NKEY = ('N') | ('K' << 8) | ('E' << 16) | ('Y' << 24),
            RATE = ('R') | ('A' << 8) | ('T' << 16) | ('E' << 24),
            RMOT = ('R') | ('M' << 8) | ('O' << 16) | ('T' << 24),
            STEP = ('S') | ('T' << 8) | ('E' << 16) | ('P' << 24),
        };
 
        NtpLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : Layer(data, dataLen, prevLayer, packet, NTP)
        {}
 
        NtpLayer();
 
        LeapIndicator getLeapIndicator() const;
 
        void setLeapIndicator(LeapIndicator val);
 
        uint8_t getVersion() const;
 
        void setVersion(uint8_t val);
 
        Mode getMode() const;
 
        std::string getModeString() const;
 
        void setMode(Mode val);
 
        uint8_t getStratum() const;
 
        void setStratum(uint8_t val);
 
        int8_t getPollInterval() const;
 
        void setPollInterval(int8_t val);
 
        double getPollIntervalInSecs() const;
 
        int8_t getPrecision() const;
 
        void setPrecision(int8_t val);
 
        double getPrecisionInSecs() const;
 
        uint32_t getRootDelay() const;
 
        void setRootDelay(uint32_t val);
 
        double getRootDelayInSecs() const;
 
        void setRootDelayInSecs(double val);
 
        uint32_t getRootDispersion() const;
 
        void setRootDispersion(uint32_t val);
 
        double getRootDispersionInSecs() const;
 
        void setRootDispersionInSecs(double val);
 
        uint32_t getReferenceIdentifier() const;
 
        void setReferenceIdentifier(IPv4Address val);
 
        void setReferenceIdentifier(ClockSource val);
 
        void setReferenceIdentifier(KissODeath val);
 
        std::string getReferenceIdentifierString() const;
 
        uint64_t getReferenceTimestamp() const;
 
        void setReferenceTimestamp(uint64_t val);
 
        double getReferenceTimestampInSecs() const;
 
        void setReferenceTimestampInSecs(double val);
 
        std::string getReferenceTimestampAsString();
 
        uint64_t getOriginTimestamp() const;
 
        void setOriginTimestamp(uint64_t val);
 
        double getOriginTimestampInSecs() const;
 
        void setOriginTimestampInSecs(double val);
 
        std::string getOriginTimestampAsString();
 
        uint64_t getReceiveTimestamp() const;
 
        void setReceiveTimestamp(uint64_t val);
 
        double getReceiveTimestampInSecs() const;
 
        void setReceiveTimestampInSecs(double val);
 
        std::string getReceiveTimestampAsString();
 
        uint64_t getTransmitTimestamp() const;
 
        void setTransmitTimestamp(uint64_t val);
 
        double getTransmitTimestampInSecs() const;
 
        void setTransmitTimestampInSecs(double val);
 
        std::string getTransmitTimestampAsString();
 
        uint32_t getKeyID() const;
 
        std::string getDigest() const;
 
        static double convertFromShortFormat(const uint32_t val);
 
        static double convertFromTimestampFormat(const uint64_t val);
 
        static uint32_t convertToShortFormat(const double val);
 
        static uint64_t convertToTimestampFormat(const double val);
 
        static std::string convertToIsoFormat(const double timestamp);
 
        static std::string convertToIsoFormat(const uint64_t timestampInNTPformat);
 
        static bool isDataValid(const uint8_t* data, size_t dataSize);
 
        static bool isNTPPort(uint16_t port)
        {
            return port == 123;
        }
 
        // overridden methods
 
        void parseNextLayer()
        {}
 
        size_t getHeaderLen() const
        {
            return m_DataLen;
        }
 
        void computeCalculateFields()
        {}
 
        OsiModelLayer getOsiModelLayer() const
        {
            return OsiModelApplicationLayer;
        }
 
        std::string toString() const;
    };
 
}  // namespace pcpp