간단한 NTP 클라이언트 작성

안녕하세요, Habrausers입니다. 오늘은 간단한 NTP 클라이언트를 작성하는 방법에 대해 이야기하고 싶습니다. 기본적으로 대화는 패킷의 구조와 NTP 서버의 응답이 처리되는 방식으로 전환됩니다. 코드는 Python으로 작성될 것입니다. 왜냐하면 제 생각에는 그러한 작업에 더 좋은 언어가 없기 때문입니다. 전문가들은 이 코드와 ntplib 코드의 유사성에 주목할 것입니다. 저는 이 코드에서 "영감을 얻었습니다".

그렇다면 NTP란 무엇일까요? NTP는 타임 서버와 통신하기 위한 프로토콜입니다. 이 프로토콜은 많은 최신 기계에서 사용됩니다. 예를 들어 Windows의 w32tm 서비스입니다.

NTP 프로토콜에는 총 5가지 버전이 있습니다. 첫 번째 버전 0(1985, RFC958)은 현재 더 이상 사용되지 않는 것으로 간주됩니다. 현재는 1차(1988, RFC1059), 2차(1989, RFC1119), 3차(1992, RFC1305), 4차(1996, RFC2030) 등 최신 버전이 사용되고 있습니다. 버전 1-4는 서로 호환되며 서버 알고리즘만 다릅니다.

패킷 형식

도약 표시기 (수정 표시)는 윤초 경고를 나타내는 숫자입니다. 의미:

• 0 - 수정 없음
• 1 - 하루의 마지막 61분은 XNUMX초입니다.
• 2 - 하루의 마지막 59분은 XNUMX초입니다.
• 3 - 서버 오류(동기화 시간 초과)

버전 번호 (버전 번호) – NTP 프로토콜 버전 번호(1-4)입니다.

모드 (모드) — 패킷 송신자의 작동 모드입니다. 0부터 7까지의 값(가장 일반적임):

• 3 - 클라이언트
• 4 - 서버
• 5 - 방송 모드

지층 (계층화 수준) - 서버와 참조 클록 사이의 중간 계층 수(1 - 서버가 참조 클록에서 직접 데이터를 가져옴, 2 - 서버가 레벨 1의 서버에서 데이터를 가져옴 등).
풀 연속 메시지 사이의 최대 간격을 나타내는 부호 있는 정수입니다. NTP 클라이언트는 여기에서 서버를 폴링할 것으로 예상되는 간격을 지정하고, NTP 서버는 폴링이 예상되는 간격을 지정합니다. 값은 초의 이진 로그와 같습니다.
Precision (정밀도)는 시스템 시계의 정확도를 나타내는 부호 있는 정수입니다. 값은 초의 이진 로그와 같습니다.
루트 지연 (서버 대기 시간)은 시계가 NTP 서버에 도달하는 데 걸리는 시간(초 단위)입니다.
뿌리 분산 (서버 분산) - NTP 서버 시계의 고정 소수점 수(초) 분산입니다.
참조 ID (소스 ID) - 시계 ID입니다. 서버에 Stratum 1이 있는 경우 ref id는 원자 시계의 이름(ASCII 문자 4개)입니다. 서버가 다른 서버를 사용하는 경우 참조 ID에는 이 서버의 주소가 포함됩니다.
마지막 4개 필드는 시간입니다. 32비트는 정수 부분, 32비트는 소수 부분입니다.
참조 - 서버의 최신 시계.
유래 – 패킷이 전송된 시간(서버에 의해 입력됨 – 자세한 내용은 아래 참조)
수신 – 서버가 패킷을 수신한 시간입니다.
전송 – 패킷이 서버에서 클라이언트로 전송된 시간(클라이언트가 입력, 자세한 내용은 아래 참조).

마지막 두 필드는 고려되지 않습니다.

패키지를 작성해 보겠습니다.

패키지 코드

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

    def __init__(self, version_number=2, mode=3, transmit=0):
        # Necessary of enter leap second (2 bits)
        self.leap_indicator = 0
        # Version of protocol (3 bits)
        self.version_number = version_number
        # Mode of sender (3 bits)
        self.mode = mode
        # The level of "layering" reading time (1 byte)
        self.stratum = 0
        # Interval between requests (1 byte)
        self.pool = 0
        # Precision (log2) (1 byte)
        self.precision = 0
        # Interval for the clock reach NTP server (4 bytes)
        self.root_delay = 0
        # Scatter the clock NTP-server (4 bytes)
        self.root_dispersion = 0
        # Indicator of clocks (4 bytes)
        self.ref_id = 0
        # Last update time on server (8 bytes)
        self.reference = 0
        # Time of sending packet from local machine (8 bytes)
        self.originate = 0
        # Time of receipt on server (8 bytes)
        self.receive = 0
        # Time of sending answer from server (8 bytes)
        self.transmit = transmit

서버에 패킷을 보내고 받으려면 패킷을 바이트 배열로 변환할 수 있어야 합니다.
이 (및 역방향) 작업을 위해 pack() 및 unpack()이라는 두 가지 함수를 작성합니다.

팩 기능

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))

압축 풀기 기능

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

게으른 사람들을 위한 애플리케이션 - 패키지를 아름다운 문자열로 바꾸는 코드

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)

서버에 패키지 보내기

필드가 채워진 패킷을 서버로 보냅니다. 버전, 모드 и 전송. 에 전송 로컬 시스템의 현재 시간(1년 1900월 1일 이후의 초 수), 버전 - 4-3 중 하나, 모드 - XNUMX(클라이언트 모드)을 지정해야 합니다.

요청을 받은 서버는 NTP 패킷의 모든 필드를 채우고 해당 필드에 복사합니다. 유래 가치 전송, 요청에 포함되었습니다. 고객이 현장에서 자신의 시간의 가치를 즉시 채울 수 없는 이유는 나에게 미스터리입니다. 유래. 결과적으로 패킷이 돌아오면 클라이언트는 4개의 시간 값, 즉 요청이 전송된 시간(유래), 서버가 요청을 받은 시간(수신), 서버가 응답을 보낸 시간(전송) 및 클라이언트가 응답을 받은 시간 - 태어나다 (패키지에 없음). 이 값을 사용하여 정확한 시간을 설정할 수 있습니다.

패키지 전송 및 수신 코드

# 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)

서버에서 데이터 처리

서버의 데이터 처리는 Raymond M. Smallian(1978)의 오래된 문제에 대한 영국 신사의 행동과 유사합니다. “한 사람은 손목시계가 없었지만 집에는 정확한 벽시계가 있었는데 때때로 잊어버렸습니다. 바람을 피우다. 어느 날 그는 시계를 다시 시작하는 것을 잊어버리고 친구를 만나러 가서 그와 함께 저녁을 보내고 집에 돌아왔을 때 시계를 정확하게 맞추었습니다. 여행 시간을 미리 알지 못했다면 그는 어떻게 이것을 할 수 있었습니까? 대답은 이렇습니다. “집을 나오면 사람이 시계 태엽을 감고 바늘의 위치를 ​​기억합니다. 친구에게 와서 손님을 떠나면서 그는 도착 및 출발 시간을 기록합니다. 이를 통해 그가 얼마나 오랫동안 자리를 비웠는지 알 수 있습니다. 집에 돌아와 시계를 보면 부재 기간을 결정합니다. 이 시간에서 자신이 방문한 시간을 빼면 그곳을 오가는 길에 보낸 시간을 알 수 있다. 손님을 떠날 시간에 길에서 보낸 시간의 절반을 추가함으로써 그는 집에 도착하는 시간을 확인하고 이에 따라 시계 바늘을 조정할 수 있는 기회를 얻습니다.

서버가 요청을 처리한 시간을 찾으세요.

1. 클라이언트에서 서버까지의 패킷 이동 시간 찾기: ((도착 - 발신) - (송신 - 수신)) / 2
2. 클라이언트 시간과 서버 시간의 차이를 찾으세요.
   수신 - 발신 - ((도착 - 발신) - (전송 - 수신)) / 2 =
   2 * 수신 - 2 * 발신 - 도착 + 발신 + 전송 - 수신 =
   수신 - 발신 - 도착 + 전송

받은 가치를 현지 시간에 더해 인생을 즐깁니다.

결과 출력

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

유능한 링크.

출처 : habr.com