Esempio n. 1
0
def test_ip_tsb(ipval, tsbval, expected):
    f0 = InstantPowerField('test', 0)
    f1 = TSBField('test', 0)
    pkt = Packet()
    pay = f0.addfield(pkt, b'', ipval)
    pay = f1.addfield(pkt, pay, tsbval)
    assert pay == expected
Esempio n. 2
0
def test_tsb(tsbval, expected):
    f = TSBField('test', 0)
    pkt = Packet()
    pay = f.addfield(pkt, b'\x00\x00', tsbval)
    assert pay == expected

    rem, val = f.getfield(pkt, expected[1:])
    assert rem == b''
    assert val == tsbval
Esempio n. 3
0
def test_instant_power(ipval, expected):
    f = InstantPowerField('test', 0)
    pkt = Packet()
    pay = f.addfield(pkt, b'', ipval)
    assert pay == expected

    rem, val = f.getfield(pkt, expected)
    assert rem == expected[1:]
    assert val == ipval & 0xFFF
    def send_batch(self, batches):
        packets_len = len(batches)
        if packets_len == 0:
            return

        packet_list = PacketList()
        for pkt in batches:
            packet_raw = Packet(pkt)
            packet_list.append(packet_raw)

        sendp(packet_list, iface=self._options.iface, verbose=0)
Esempio n. 5
0
def get_packetmod_pcap(nb_headers,
                       nb_fields,
                       mod_type,
                       out_dir,
                       packet_size=256):
    pkt = Packet()
    if mod_type == 'add':
        eth = Ether(src='0C:C4:7A:A3:25:34', dst='0C:C4:7A:A3:25:35')
        ptp = PTP(reserved2=0)
        pkt = eth / ptp / '0x0' * 6
    elif mod_type == 'rm':
        eth = Ether(src='0C:C4:7A:A3:25:34', dst='0C:C4:7A:A3:25:35')
        ptp = PTP(reserved2=1)
        pkt = eth / ptp
        pkt /= add_layers(nb_fields, nb_headers)
        pkt = add_padding(pkt, packet_size)
    elif mod_type == 'mod':
        eth = Ether(src='0C:C4:7A:A3:25:34', dst='0C:C4:7A:A3:25:35')
        ptp = PTP(reserved2=1)
        pkt = eth / ptp
        pkt /= add_layers(nb_fields, nb_headers)
        pkt = add_padding(pkt, packet_size)

    wrpcap('%s/test.pcap' % out_dir, pkt)
Esempio n. 6
0
from struct import pack
from packages.common.utils import gps_week_seconds_to_utc
from scapy.all import (Packet, PacketList, sendp, resolve_iface)
from packages.common import utils
from packages.common import uart_helper
# utc_time = gps_week_seconds_to_utc(2166, 463261.918)
# print(utc_time)

if __name__ == '__main__':
    config = utils.get_config()

    iface = resolve_iface(config['local']['name'])  # 'eth0'
    src_mac = config['local']['mac']  # 'b8:27:eb:04:e0:73'
    dst_mac_addresses = config['devices_mac']

    raw_bytes = uart_helper.build_eth_command()

    packet_list = PacketList()
    for i in range(5):
        packet_list.append(
            Packet(raw_bytes)
        )

    sendp(packet_list, iface=iface, verbose=0)
	print("Press CTRL+C to stop sniffing.\n")

	with open(output_file, 'w') as f:
		f.write('')

	s = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, socket.htons(3))
	s.bind((iface, 3))

	packets = []
	i = 0

	def signal_trap(sig, frame):
		''' theoretically, interrupt could malform last packet '''
		for pkt in packets[:-1]:
			wrpcap(output_file, pkt, append=True)

		print("\nProgram stopped. Packets saved to {}.".format(output_file))
		sys.exit(0)

	signal.signal(signal.SIGINT, signal_trap)

	while True:
		raw_pkt = s.recvfrom(1500)[0]
		packets += Packet(raw_pkt)

		''' print every log in one line '''
		print("\r", end="")
		print("{} packets captured ".format(i), end="")
		sys.stdout.flush()

		i += 1