def test_set_origin_timestamp(self):
# Arrange
ntp_raw = RawNTP()
# Act
ntp_raw.set_origin_timestamp(_TEST_BIN_64BIT)
# Assert
self.assertEqual(ntp_raw.origin_timestamp(), _TEST_BIN_64BIT)
def handle_incoming_pck(self, pck: Packet):
ntp_pck = pck[NTP]
cp1_pck = CP1Package(ntp_pck)
self.log.info('Received pck bits: ' + str(cp1_pck._raw))
if self.send_session is None:
self.log.debug("Init new session (1).")
self.send_session = CP1Session()
next_pck = self.send_session.generate_init_pck(self.client_address)
self.add_secret_payload(self.payload, self.static_key)
else:
next_bits_to_send = self.send_session.secret_to_send.next_bits(
self.payload_size)
self.log.debug("Next payload bits to send: " +
str(next_bits_to_send))
new_cp1_pck = CP1Package(ntp_pck=init_ntp_client_pck())
new_cp1_pck.add_payload(next_bits_to_send)
next_pck = new_cp1_pck.ntp()
upstream_pck = self.scapy_wrapper.get_upstream_ntp()
upstream_pck[NTP].mode = 4
# upstream_pck[NTP].orig = ntp_pck.sent
upstream_pck[NTP].sent = next_pck[NTP].sent
upstream_pck[NTP].ref = next_pck[NTP].ref
upstream_pck[IP].src = pck[IP].dst
upstream_pck[IP].dst = pck[IP].src
upstream_pck[UDP].sport = pck[UDP].dport
upstream_pck[UDP].dport = pck[UDP].sport
up_raw = RawNTP(upstream_pck[NTP])
pck_raw = RawNTP(ntp_pck)
up_raw.set_origin_timestamp(pck_raw.transmit_timestamp())
upstream_pck[NTP] = up_raw.ntp()
self.log.debug("Created new CP1 packet to send...")
upstream_pck.show()
send(upstream_pck)
if not self.has_next_pck():
self.log.debug("Init new session (2).")
self.send_session = None
def init_ntp_pck(num_of_digits_to_fill_up: int = 12) -> NTP:
"""
Creates a new NTP package, fills all 4 64 bit timestamps with the current time and fills up the last bits
with random values, since they are set to 0 by Scapy
:param num_of_digits_to_fill_up: The amount of digits to fill up.
:return: The newly created NTP package
"""
ntp = NTP()
ntp.ref = ntp_time_now()
ntp.sent = ntp_time_now()
ntp.orig = ntp_time_now()
ntp.recv = ntp_time_now()
raw_ntp = RawNTP(ntp)
f_ref = raw_ntp.reference_timestamp()
f_trans = raw_ntp.transmit_timestamp()
f_orig = raw_ntp.origin_timestamp()
f_recv = raw_ntp.receive_timestamp()
for i in range(num_of_digits_to_fill_up):
pos = 64 - i
f_ref = f_ref[:pos - 1] + str(random.randint(0, 1)) + f_ref[pos:]
f_trans = f_trans[:pos - 1] + str(random.randint(0, 1)) + f_trans[pos:]
f_orig = f_orig[:pos - 1] + str(random.randint(0, 1)) + f_orig[pos:]
f_recv = f_recv[:pos - 1] + str(random.randint(0, 1)) + f_recv[pos:]
assert len(f_ref) == 64
assert len(f_trans) == 64
assert len(f_orig) == 64
assert len(f_recv) == 64
raw_ntp.set_reference_timestamp(f_ref)
raw_ntp.set_transmit_timestamp(f_trans)
raw_ntp.set_origin_timestamp(f_orig)
raw_ntp.set_receive_timestamp(f_recv)
ntp = raw_ntp.ntp()
return ntp