Skriver en enkel NTP-klient

Hej, Habr-anvĂ€ndare. Idag vill jag prata om hur man skriver en enkel NTP-klient. I huvudsak kommer samtalet att handla om paketstrukturen och hur man hanterar svar frĂ„n NTP-servern. Koden kommer att skrivas i Python, eftersom jag anser att det inte finns nĂ„got bĂ€ttre sprĂ„k för sĂ„dana saker. Experterna kommer att mĂ€rka likheten med koden i ntplib – jag har "fĂ„tt inspiration" frĂ„n den.

SÄ, vad Àr egentligen NTP? NTP Àr ett protokoll för interaktion med servrar för exakt tid. Detta protokoll anvÀnds i mÄnga moderna maskiner. Till exempel, tjÀnsten w32tm i Windows.

Det finns totalt 5 versioner av NTP-protokollet. Den första, version 0 (1985, RFC958), anses för nÀrvarande vara förÄldrad. Just nu anvÀnds nyare versioner, 1 (1988, RFC1059), 2 (1989, RFC1119), 3 (1992, RFC1305) och 4 (1996, RFC2030). Versionerna 1-4 Àr kompatibla med varandra, de skiljer sig endast i algoritmerna som anvÀnds. servrar.

Paketformat

Skriver en enkel NTP-klient

Leap indicator (korrektionsindikator) – ett nummer som visar en varning för sekundkoordinering. VĂ€rde:

  • 0 – ingen korrektionsĂ„tgĂ€rd
  • 1 – den sista minuten av dagen innehĂ„ller 61 sekunder
  • 2 – den sista minuten av dagen innehĂ„ller 59 sekunder
  • 3 – serverfel (tiden Ă€r inte synkroniserad)

Versionsnummer (versionsnummer) – versionsnummer av NTP-protokollet (1-4).

LĂ€ge (arbetslĂ€ge) — lĂ€get för avsĂ€ndarens paket. VĂ€rden frĂ„n 0 till 7, de mest frekventa:

  • 3 – klient
  • 4 – server
  • 5 – broadcast-lĂ€ge

Stratum (lagernivĂ„) – antalet mellanlager mellan servern och referenstiderna (1 – servern tar data direkt frĂ„n referenstiderna, 2 – servern tar data frĂ„n en server med nivĂ„ 1, etc.).
Pool – ett heltal med tecken som representerar det maximala intervallet mellan pĂ„ varandra följande meddelanden. NTP-klienten anger hĂ€r det intervall med vilket den planerar att frĂ„ga servern, och NTP-servern – det intervall med vilket den förvĂ€ntar sig att bli frĂ„gad. VĂ€rdet Ă€r lika med den binĂ€ra logaritmen av sekunder.
Precision (noggrannhet) – ett heltal med tecken som representerar noggrannheten hos systemklockan. VĂ€rdet Ă€r lika med den binĂ€ra logaritmen av sekunder.
Root delay (serverfördröjning) – tiden det tar för klocksignalerna att nĂ„ NTP-servern, som ett antal sekunder med fixad punkt.
Root dispersion (spridning av servervĂ€rden) – spridningen av NTP-serverns klockvĂ€rden som ett antal sekunder med fixad punkt.
Ref id (kĂ€lla-ID) – id för klockor. Om servern har stratum 1, sĂ„ Ă€r ref id namnet pĂ„ atomklockorna (4 ASCII-tecken). Om servern anvĂ€nder en annan server, sĂ„ anges adressen för den servern i ref id.
De sista 4 fĂ€lten representerar tiden – 32 bitar – heltalsdel, 32 bitar – brĂ„kdelsdel.
Referens – de senaste mĂ€tvĂ€rdena frĂ„n klockan pĂ„ servern.
Ursprung – tiden nĂ€r paketet skickades (fylls i av servern – mer om detta nedan).
Mottagande – tiden nĂ€r paketet tas emot av servern.
SĂ€ndning – tiden för paketets avsĂ€ndning frĂ„n servern till klienten (fylls i av klienten, mer om detta nedan).

Vi kommer inte att behandla de tvÄ sista fÀlten.

LÄt oss skriva vÄrt paket:

Paketkod

class NTPPacket:
    _FORMAT = "!B B b b 11I"

    def __init__(self, version_number=2, mode=3, transmit=0):
        # NödvÀndigt för att ange skottsekund (2 bitar)
        self.leap_indicator = 0
        # Protokollversion (3 bitar)
        self.version_number = version_number
        # AvsÀndarens lÀge (3 bitar)
        self.mode = mode
        # NivÄn av "lager" som lÀser tiden (1 byte)
        self.stratum = 0
        # Intervall mellan förfrÄgningar (1 byte)
        self.pool = 0
        # Precision (log2) (1 byte)
        self.precision = 0
        # Intervall för klockan att nÄ NTP-server (4 byte)
        self.root_delay = 0
        # Spridning av NTP-serverns klocka (4 byte)
        self.root_dispersion = 0
        # Indikator för klockor (4 byte)
        self.ref_id = 0
        # Senaste uppdateringstid pÄ servern (8 byte)
        self.reference = 0
        # Tid för paketets avsÀndning frÄn lokal maskin (8 byte)
        self.originate = 0
        # Tid för mottagning pÄ server (8 byte)
        self.receive = 0
        # Tid för sÀndning av svar frÄn server (8 byte)
        self.transmit = transmit

För att skicka (och ta emot) ett paket till servern mÄste vi kunna omvandla det till en byte-array.
För denna (och omvĂ€nda) operation kommer vi att skriva tvĂ„ funktioner – pack() och unpack():

Funktionen pack

def pack(self):
        return struct.pack(NTPPacket._FORMAT,
                (self.leap_indicator << 6) + 
                    (self.version_number << 3) + self.mode,
                self.stratum,
                self.pool,
                self.precision,
                int(self.root_delay) + get_fraction(self.root_delay, 16),
                int(self.root_dispersion) + 
                    get_fraction(self.root_dispersion, 16),
                self.ref_id,
                int(self.reference),
                get_fraction(self.reference, 32),
                int(self.originate),
                get_fraction(self.originate, 32),
                int(self.receive),
                get_fraction(self.receive, 32),
                int(self.transmit),
                get_fraction(self.transmit, 32))

Funktionen unpack

def unpack(self, data: bytes):
        unpacked_data = struct.unpack(NTPPacket._FORMAT, data)

        self.leap_indicator = unpacked_data[0] >> 6  # 2 bits
        self.version_number = unpacked_data[0] >> 3 & 0b111  # 3 bits
        self.mode = unpacked_data[0] & 0b111  # 3 bits

        self.stratum = unpacked_data[1]  # 1 byte
        self.pool = unpacked_data[2]  # 1 byte
        self.precision = unpacked_data[3]  # 1 byte

        # 2 bytes | 2 bytes
        self.root_delay = (unpacked_data[4] >> 16) +
            (unpacked_data[4] & 0xFFFF) / 2 ** 16
         # 2 bytes | 2 bytes
        self.root_dispersion = (unpacked_data[5] >> 16) +
            (unpacked_data[5] & 0xFFFF) / 2 ** 16 

        # 4 bytes
        self.ref_id = str((unpacked_data[6] >> 24) & 0xFF) + " " + 
                      str((unpacked_data[6] >> 16) & 0xFF) + " " +  
                      str((unpacked_data[6] >> 8) & 0xFF) + " " +  
                      str(unpacked_data[6] & 0xFF)

        self.reference = unpacked_data[7] + unpacked_data[8] / 2 ** 32  # 8 bytes
        self.originate = unpacked_data[9] + unpacked_data[10] / 2 ** 32  # 8 bytes
        self.receive = unpacked_data[11] + unpacked_data[12] / 2 ** 32  # 8 bytes
        self.transmit = unpacked_data[13] + unpacked_data[14] / 2 ** 32  # 8 bytes

        return self

För latmaskar, som ett tillĂ€gg – kod som omvandlar paketet till en vacker strĂ€ng

def to_display(self):
        return "Leap indicator: {0.leap_indicator}n" 
                "Version number: {0.version_number}n" 
                "Mode: {0.mode}n" 
                "Stratum: {0.stratum}n" 
                "Pool: {0.pool}n" 
                "Precision: {0.precision}n" 
                "Root delay: {0.root_delay}n" 
                "Root dispersion: {0.root_dispersion}n" 
                "Ref id: {0.ref_id}n" 
                "Reference: {0.reference}n" 
                "Originate: {0.originate}n" 
                "Receive: {0.receive}n" 
                "Transmit: {0.transmit}"
                .format(self)

Skicka paketet till servern

Det Ă€r nödvĂ€ndigt att skicka ett paket till servern med ifyllda fĂ€lt Version, LĂ€ge och SĂ€ndning. I SĂ€ndning det Ă€r nödvĂ€ndigt att ange den aktuella tiden pĂ„ den lokala maskinen (antal sekunder frĂ„n 1 januari 1900), version – nĂ„gon av 1-4, lĂ€ge – 3 (klientlĂ€ge).

Servern som tar emot förfrĂ„gan fyller i alla fĂ€lt i NTP-paketet genom att kopiera in vĂ€rdet Ursprung frĂ„n SĂ€ndning, som kom i förfrĂ„gan. Det Ă€r en gĂ„ta för mig varför klienten inte kan fylla i vĂ€rdet av sin egen tid direkt i fĂ€ltet Ursprung. I slutĂ€ndan, nĂ€r paketet kommer tillbaka har klienten 4 tidsvĂ€rden – tidpunkten för förfrĂ„gan (Ursprung), tiden dĂ„ förfrĂ„gan mottogs av servern (Mottagande), tiden dĂ„ svaret skickades av servern (SĂ€ndning) och tiden dĂ„ svaret mottogs av klienten – AnlĂ€nd (finns inte i paketet). Med dessa vĂ€rden kan vi stĂ€lla in rĂ€tt tid.

Kod för att skicka och ta emot paketet

# Time difference between 1970 and 1900, seconds
FORMAT_DIFF = (datetime.date(1970, 1, 1) - datetime.date(1900, 1, 1)).days * 24 * 3600
# Waiting time for recv (seconds)
WAITING_TIME = 5
server = "pool.ntp.org"
port = 123
    
packet = NTPPacket(version_number=2, mode=3, transmit=time.time() + FORMAT_DIFF)
answer = NTPPacket()
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
    s.settimeout(WAITING_TIME)
    s.sendto(packet.pack(), (server, port))
    data = s.recv(48)
    arrive_time = time.time() + FORMAT_DIFF
    answer.unpack(data)

Bearbeta data frÄn servern

Databehandling frÄn servern liknar handlingarna hos en engelsk gentleman i Raymond M. Smullyans gamla uppgift (1978): "En man hade inga armbandsur, men hemma hÀngde det exakta vÀggur som han ibland glömde att stÀlla. En gÄng, efter att ha glömt att stÀlla klockan igen, Äkte han pÄ besök till en vÀn, tillbringade kvÀllen dÀr och nÀr han kom hem kunde han stÀlla klockan korrekt. Hur lyckades han med det, nÀr tiden för resan i förvÀg var okÀnd?" Svaret Àr: "NÀr han gick hemifrÄn stÀllde mannen klockan och kom ihÄg i vilket lÀge visarna var. NÀr han kom till sin vÀn och lÀmnade gÀsterna noterade han tiden för sitt besök. Detta gör att han kan veta hur lÀnge han var pÄ besök. NÀr han kom hem och sÄg pÄ klockan, kan han avgöra hur lÄng tid han varit borta. Genom att dra ifrÄn tiden han tillbringade pÄ besök frÄn den totala tiden, fÄr han veta hur lÄng tid han spenderat pÄ resan dit och tillbaka. Genom att lÀgga till hÀlften av den tiden till tiden för avfÀrd frÄn gÀsterna fÄr han reda pÄ tiden för sin ankomst hem och kan justera visarna pÄ sin klocka dÀrefter."

Vi berÀknar serverns bearbetningstid för förfrÄgan:

  1. Vi berĂ€knar paketets vĂ€g frĂ„n klienten till servern: ((Ankomst – UtgĂ„ng) — (Överföring – Mottagning)) / 2
  2. Vi berÀknar skillnaden mellan klientens och serverns tid:
    Mottagning — UtgĂ„ng — ((Ankomst – UtgĂ„ng) — (Överföring – Mottagning)) / 2 =
    2 * Mottagning — 2 * UtgĂ„ng – Ankomst + UtgĂ„ng + Överföring – Mottagning =
    Mottagning – UtgĂ„ng – Ankomst + Överföring

Vi lÀgger till det erhÄllna vÀrdet till lokal tid och njuter av livet.

Visa resultatet

time_different = answer.get_time_different(arrive_time)
result = "Tidsdifferens: {}nServer tid: {}n{}".format(
    time_different,
    datetime.datetime.fromtimestamp(time.time() + time_different).strftime("%c"),
    answer.to_display())
print(result)

Nyttig lÀnk.

KĂ€lla: habr.com

Köp pĂ„litlig webbhotell med DDoS-skydd, VPS VDS-servrar đŸ”„ Köp pĂ„litlig webbhotell med DDoS-skydd, VPS VDS-servrar | ProHoster