def get_gateway_ip():
table = []
route = os.popen("route")
i = 0
for r in route:
r = " ".join(re.split("\s+", r, flags=re.UNICODE))
table.append(r)
l = len(table)
for i in range(l):
table[i] = table[i].strip()
table[i] = table[i].split(" ")
#print(table[i])
#lst.split(" ")
for i in range(l - 2):
if table[i + 2][7] == "wlp2s0" and table[i + 2][1] != "*":
gateway_ip = table[i + 2][1]
gateway_ip = str(gateway_ip)
print("gateway_ip : " + gateway_ip)
gateway = arpreq.arpreq(gateway_ip)
print("gateway : " + gateway)
gateway = str(gateway)
#print(table)
tshark(gateway, gateway_ip)
def index():
ip = request.remote_addr
try:
mac = arpreq.arpreq(ip)
except OSError as e:
content = render_template("error.html",
message=_("An error occurred while resolving "
"IP address into a MAC address."))
return content, 500
if mac is None:
content = render_template("error.html",
error=_("No MAC address could be found for "
"your IP address {}".format(ip)))
return content, 500
mac_groups = get_groups(mac)
latest_auth_attempt = get_latest_auth_attempt(mac)
if latest_auth_attempt:
last_auth_groups, last_auth_date = latest_auth_attempt
else:
last_auth_groups, last_auth_date = [], None
reasons = [messages[group] for group in mac_groups if group in messages]
show_mac = False
if not mac_groups:
reasons.append(messages['unknown'])
show_mac = True
if 'unknown' in last_auth_groups and mac_groups:
reasons.append(messages['wrong_port'])
return render_template(
"status.html", reasons=reasons,
mac=mac,
show_mac=show_mac,
)
def scan_network_ips(ip_range):
nm = nmap.PortScanner()
scans = nm.scan(hosts=ip_range, arguments='-sn')
res = {}
for ip, data in scans.get('scan', {}).items():
mac = arpreq.arpreq(ip)
data.setdefault('vendor', {}).setdefault('mac', mac)
res[ip] = data
return res
def index():
ip = request.remote_addr
try:
mac = arpreq.arpreq(ip)
except OSError as e:
logger.exception("Could not resolve IP {} into MAC: {}".format(ip, e))
content = render_template("error.html",
message=_("An unexpected error occurred "
"while resolving your IP address "
"into a MAC address."))
return content, 500
if mac is None:
content = render_template("error.html",
error=_("No MAC address could be found for "
"your IP address {}".format(ip)))
return content, 500
with contextlib.closing(
engine.connect()) as connection, connection.begin():
mac_groups = list(get_groups(connection, mac))
if not mac_groups:
return render_template("status.html",
reasons=[messages['unknown']],
mac=mac,
show_mac=True)
latest_auth_attempt = get_latest_auth_attempt(connection, mac)
if not latest_auth_attempt:
content = render_template("error.html",
error=_(
"No authentication attempt found "
"for your MAC address."))
return content, 500
nas_ip_address, nas_port_id, *ignore = latest_auth_attempt
port_groups = [
group for nai, npi, group in mac_groups
if nas_ip_address == nai and nas_port_id == npi
]
if not port_groups:
return render_template("status.html",
mac=mac,
show_mac=False,
reasons=[messages['wrong_port']])
reasons = [
messages[group] for group in port_groups if group in messages
]
return render_template("status.html",
reasons=reasons,
mac=mac,
show_mac=False)
def whos_home(self):
home_list = [(time.time(), 0)] * self.devices
for ip in range(0, self.devices):
test = arpreq.arpreq('192.168.0.' + str(ip + 51))
if test is not None:
home_list[ip] = time.time(), 1
return home_list
def get_realm_id():
"""Return a unique identifier for the Internet Service Provider
"""
isp_id = get_essid()
if not isp_id:
# Then the network probably isn't wifi. Check ethernet :
import arpreq
#isp_id = arpreq.arpreq(get_ip_address(get_active_interface()))
isp_id = arpreq.arpreq(get_gateway_address())
return isp_id
def get_attendance():
mac_list = []
for i in range(1, 255):
request_mac = arpreq.arpreq(f'192.168.0.{i}')
if request_mac:
student_with_mac = Student.objects.filter(
mac=str(request_mac).strip())
if student_with_mac.exists():
record = Record(student=student_with_mac.first())
record.save()
def getDevStatus():
data = []
lease = []
with open('/var/lib/misc/dnsmasq.leases') as f:
data = f.readlines()
for line in data:
if arpreq.arpreq(line.strip('\n').split()[2]):
lease.append(line.strip('\n').split() + [True])
else:
lease.append(line.strip('\n').split() + [False])
sendresponse(json.dumps(lease))
def __init__(self, target_ip, target_mac, gateway_ip=None):
self.logger = logging.getLogger(__name__)
if gateway_ip is None:
gateway_ip = netifaces.gateways()['default'][AF_INET][1]
self.gateway_ip = gateway_ip
self.gateway_mac = arpreq.arpreq(gateway_ip)
if self.gateway_mac is None:
raise IOError("Unable to get gateway MAC address")
self.target_ip = target_ip
self.target_mac = target_mac
self.__running = True
atexit.register(self.stop)
def mark_attendance(request):
if request.method == 'POST':
print(f"roll_no: {request.POST.get('id')}")
else:
print('*************')
request_mac = arpreq.arpreq(get_client_ip(request))
student_with_mac = Student.objects.filter(mac=request_mac)
if (student_with_mac):
record = Record(student=student_with_mac.first())
record.save()
else:
print('Not a student')
print(' ')
return HttpResponse(status=200)
def ping_sweep_async(self, network=None, callback=None):
if network is None:
network = self.get_current_network()
self.logger.debug(network)
with ThreadPoolExecutor(max_workers=THREAD_LIMIT) as executor:
futures = []
for ip in network:
future = executor.submit(self.ping_host, str(ip))
futures.append(future)
for future in futures:
result = future.result()
if result is not None and callback:
callback((result, arpreq.arpreq(result)))
def add_server(self, ip, port, id=None):
print("Adding server at %s:%d" % (ip, port))
structip = ip2int(ip)
mac = arpreq.arpreq(ip)
if mac is None:
print("COULD NOT FIND MAC ADDRESS FOR IP %s" % ip)
macstr = mac.replace(':', '').decode('hex')
print("Found mac address: {}, {}".format(mac, macstr))
server = DstAddr(macstr, structip, ct.c_uint16(socket.htons(port)))
if id is None:
id = self.n_servers
self.n_servers = max(self.n_servers, id + 1)
self.b['dst_servers'][id] = server
self.b['n_dst_servers'][0] = ct.c_uint(self.n_servers)
def handle_beacon(self, fd, event):
"""
Reads response from nodes
Creates :class:`Peer` objects and tracks them in `self.peers`. Finally
sends messages through pipe to main application thread.
:param fd: not used
:param event: not used
"""
log.debug("Waiting for a beacon.")
try:
data, host = self._next_packet()
except ReceiveTimeout:
msg_parts = [b"RECEIVE_TIMEOUT"]
try:
self._send_to_pipe_multipart(msg_parts)
except Exception:
return
return
if data == PING_MESSAGE:
log.debug("Ignoring ping message received from network from %s.", host)
return
log.debug("Received a beacon from %s.", host)
ip_address, device_id = decode_discovery_response(data)
# if host != ip_address:
# print("Host {} != ip_address {}".format(host, ip_address))
log.debug("Getting hardware address of %s.", ip_address)
hw_address = arpreq(ip_address)
if is_py3 and not isinstance(hw_address, bytes):
hw_address = bytes(hw_address, "utf-8")
if hw_address is None:
log.error("Unable to get HW adress of %s.", ip_address)
msg_parts = [b"ERROR", device_id, ip_address]
try:
self._send_to_pipe_multipart(msg_parts)
except Exception:
return
# print("Host {} has MAC address {}".format(ip_address, hw_address))
if hw_address in self.peers:
log.debug("Peer %s seen before.", hw_address)
return self.process_seen_peer(hw_address, device_id, ip_address)
else:
log.debug("Never seen %s before.", hw_address)
return self.process_new_peer(hw_address, device_id, ip_address)
def arpRequest(dict_arp_table):
dict_mac = {}
for ips in range(255):
mac = arpreq.arpreq(ipaddress.IPv4Address(u'192.168.10.' + str(ips)))
if mac is not None:
dict_arp_table[str('192.168.10.' + str(ips))].append(mac)
dict_arp_table[str('192.168.10.' + str(ips))].append("Normal")
if str(mac) in dict_mac:
for key in dict_arp_table.keys():
if dict_arp_table[key][0] == str(mac):
dict_arp_table[key][1] = "Abnormal"
print(
"Alert !! Duplicate entry found in ARP Table, Duplicate Mac: "
+ mac + " with IP: " + key)
dict_mac[str(mac)] += 1
else:
dict_mac[str(mac)] = 1
def ap_lookup(self, client_ip):
requesting_mac = arpreq.arpreq(client_ip)
if not self.cur.execute(
"SELECT *, CAST(non_member_perdiem AS CHAR) AS non_member_perdiem,CAST(non_member_rate AS CHAR) AS non_member_rate,CAST(member_rate AS CHAR) AS member_rate FROM civicrm_mstk_access_points WHERE mac_address = %s",
(requesting_mac, )):
self.debug_message(
self.log_level, 0,
"UNAUTHORIZED AP REQUEST: by ip address %s with mac address %s"
% (client_ip, requesting_mac))
return {'error_code': 'x10'}
else:
requesting_ap = self.cur.fetchone()
if requesting_ap['ip_address'] == client_ip:
# Ok, this is a legit ap.
if str(requesting_ap['maintenance_mode']) == "1":
error_code = 'x20'
requesting_ap.update({"error_code": str(error_code)})
else:
# adding door comands if this is under an access control device
try:
requesting_ap.update({"dev": str(requesting_ap['dev'])})
requesting_ap.update({"cmd": str(requesting_ap['cmd'])})
except:
pass
# adding a parent if present
try:
requesting_ap.update(
{"parent_ap": str(requesting_ap['parent_id'])})
except:
# no parent
pass
error_code = 'x00'
requesting_ap.update({"error_code": str(error_code)})
return requesting_ap
else:
self.debug_message(
self.log_level, 0,
"UNAUTHORIZED AP REQUEST: ip/mac don't agree. ip %s, mac %s" %
(client_ip, requesting_mac))
return {'error_code': 'x10'}
def getRandomIps(count=1):
# Get all the possible hosts in the network
myip = _getIp()
myip = myip + _getSubnetMaskFromIp(myip) # 192.168.0.4/24
hosts = [
ip.exploded
for ip in ipaddress.IPv4Network(myip, strict=False).hosts()
]
random.shuffle(hosts) # Shuffle the list
print("Discovering {} addresses to use...".format(count))
addresses = set()
# Keep looping until we run out of ip addresses or have found enough
for ip in hosts:
if ip not in addresses:
if not arpreq.arpreq(ip):
addresses.add(ip)
print(".", end="", flush=True)
if len(addresses) == count:
break
return list(addresses)
def pinger(self, host_num):
ni.ifaddresses(interface)
ip = ni.ifaddresses(interface)[ni.AF_INET][0]['addr']
hostadrr = ip.split('.')[:-1]
hostadrr = '.'.join(hostadrr) + '.' + repr(host_num)
line = subprocess.getoutput("ping -n -c 1 %s 2> /dev/null" % hostadrr)
time.sleep(2)
while True:
if line.find(hostadrr) and line.find("bytes from") > -1: # Host Active
is_active = []
is_active.append(hostadrr)
alive_host = is_active.pop()
print("Host %s is \033[92m Active \033[0m" % alive_host)
with open('result_ping.txt', 'a+') as the_file:
the_file.write(alive_host + ' -- ' + arpreq.arpreq(alive_host))
the_file.write("\n")
break
else:
exit(0)
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
serverPort = 20170
server_socket.bind(('', serverPort))
server_socket.listen(1)
read_list = [server_socket]
while (1):
try:
readable, writable, errored = select.select(read_list, [], [])
for s in readable:
if s is server_socket:
client_socket, address = server_socket.accept()
read_list.append(client_socket)
print "Connection from", address, arpreq.arpreq(str(
address[0]))
else:
data = s.recv(1024)
#print data
if data:
#s.send(data)
try:
data = data.split('\n')[0]
if "|" in data:
raw_data = data.split('|')
elif "%7C" in data:
raw_data = data.split('%7C')
import arpreq
mac_list = []
for i in range(1, 255):
request_mac = arpreq.arpreq(f'192.168.0.{i}')
# print(f'192.168.0.{i} ' + str(request_mac))
if request_mac:
mac_list.append(f'192.168.0.{i} ' + str(request_mac))
def test_cached_entries():
for ip, mac in get_arp_cache():
assert arpreq(ip) == mac
def test_localhost(value):
assert arpreq(value) == '00:00:00:00:00:00'
def test_cached_entries():
for ip, mac in get_arp_cache():
assert arpreq(ip) == mac
def test_gateways():
for gateway in get_gateways():
ping(gateway)
assert arpreq(gateway) is not None
print('version of device: {}'.format(response_show_versio_json['version']))
#Get hostname
url_hostname = 'https://192.168.4.164/api/config/settings/host-name'
Response_Show_Hostname = requests.get(
url_hostname,
headers={'Authorization': 'Token ' + token_json['token']},
verify=False,
timeout=30)
Response_Show_Hostname = Response_Show_Hostname.content.decode()
Response_Show_Hostname_json = json.loads(Response_Show_Hostname)
print('Hostname: {}'.format(Response_Show_Hostname_json['data']['value']))
print('===================================================')
# ar = ArpRequest('192.168.50.1', 'enp0s25')
# print(ar.request)
print(arpreq.arpreq('192.168.50.1'))
"""
data_interface= {
"name": "ETH1",
"error": None,
"is_used_in_dhcp": False,
"is_used_in_ha": False,
"mac": "00:0C:29:6C:4D:D0",
"name_sort": "eth00000000",
"description": None,
"alias": "ETH1",
"ip_list": [
{
"ip": "192.168.20.164",
def test_illegal_type(value):
with pytest.raises(TypeError):
arpreq(value)
addr = ip_info[0]["addr"]
netmask = ip_info[0]["netmask"]
network = ipaddress.ip_network("%s/%s" % (addr, netmask), strict=False)
start = network.network_address + 1
end = network.broadcast_address
maclookup = MacLookup()
nmap = nmap.PortScanner()
#for ipint in range(int(start), int(end)):
for ipint in range(int(start), int(start) + 1):
ip = ipaddress.IPv4Address(ipint)
ipstr = str(ip)
hosts_info[ipstr] = {}
mac = arpreq.arpreq(ip)
vendor = None
if mac is not None:
vendor = maclookup.lookup(mac)
scan_result = {}
nmap.scan(hosts=ipstr, ports='1-1000', arguments='-sS -O')
scan_result['os'] = nmap[ipstr]['osmatch'][0]['name']
scan_result['open_tcp'] = [p for p in nmap[ipstr]['tcp']]
#nmap.scan(hosts=ipstr, ports='1-1000', arguments='-sU')
#print(nmap[ipstr]['udp'])
hardware_info = [mac, vendor]
hosts_info[ipstr]['hardware'] = hardware_info
hosts_info[ipstr]['scan_result'] = scan_result
def test_localhost(value):
assert arpreq(value) == '00:00:00:00:00:00'
def get_MAC(ipAddr):
return arpreq.arpreq(ipAddr)
import arpreq
config = configparser.ConfigParser()
secrets_file = 'mstk-secrets.conf'
secrets_path = os.path.realpath(
os.path.join(os.getcwd(), os.path.dirname(__file__)))
config.read(os.path.join(secrets_path, secrets_file))
civicrm_url = config.get('civi-connect', 'url')
civicrm_site_key = config.get('civi-connect', 'site_key')
civicrm_api_key = config.get('civi-connect', 'api_key')
civicrm = CiviCRM(civicrm_url, civicrm_site_key, civicrm_api_key, use_ssl=False, timeout=10 )
ap_ip = config.get('doord','host')
# during testing the server host and "ap" share an ip address
host = ap_ip
port = config.get('doord','port')
ap_mac = arpreq.arpreq(ap_ip)
server = pythonmstk.MstkServer(secrets_path,secrets_file)
class TestMstkServer(unittest.TestCase):
@classmethod
def setUpClass(cls):
contact_dict = {
"first_name":"Testy",
"last_name":"McTesterson",
"contact_type":"Individual"
}
membership_type_dict = {
"domain_id": "Fat Cat Fab Lab",
"member_of_contact_id": "1",
def __verifyArp(self):
return arpreq.arpreq(self.ip) == self.mac
def test_illegal_argument(value):
with pytest.raises(ValueError):
arpreq(value)
def test_illegal_argument(value):
with pytest.raises(ValueError):
arpreq(value)
def handle_beacon(self, fd, event):
"""
Reads response from nodes
Creates :class:`Peer` objects and tracks them in `self.peers`. Finally
sends messages through pipe to main application thread.
:param fd: not used
:param event: not used
"""
log.debug("Waiting for a beacon.")
data, host = self.udp.recv(64)
if data == PING_MESSAGE:
log.debug("Ignoring ping message received from network from %s.",
host)
return
log.debug("Received a beacon from %s.", host)
ip_address, device_name = decode_discovery_response(data)
# if host != ip_address:
# print("Host {} != ip_address {}".format(host, ip_address))
log.debug("Getting hardware address of %s.", ip_address)
hw_address = arpreq(ip_address)
if is_py3 and not isinstance(hw_address, bytes):
hw_address = bytes(hw_address, "utf-8")
if hw_address is None:
log.error("Unable to get HW adress of %s.", ip_address)
msg_parts = [b"ERROR", device_name, ip_address]
try:
self._send_to_pipe_multipart(msg_parts)
except Exception:
return
# print("Host {} has MAC address {}".format(ip_address, hw_address))
if hw_address in self.peers:
log.debug("Peer %s seen before.", hw_address)
self.peers[hw_address].is_alive()
if device_name != self.peers[hw_address].device_name:
old_device_name = self.peers[hw_address].device_name
self.peers[hw_address].device_name = device_name
msg_parts = [
b"RENAMED", hw_address, old_device_name, device_name
]
try:
self._send_to_pipe_multipart(msg_parts)
except Exception:
return
if ip_address != self.peers[hw_address].ip_address:
old_ip_address = self.peers[hw_address].ip_address
self.peers[hw_address].ip_address = ip_address
msg_parts = [
b"ADDRESS_CHANGED", hw_address, old_ip_address, ip_address
]
try:
self._send_to_pipe_multipart(msg_parts)
except Exception:
return
else:
log.debug("Never seen %s before.", hw_address)
self.peers[hw_address] = Peer(hw_address, device_name, ip_address)
msg_parts = [b"JOINED", hw_address, device_name, ip_address]
try:
self._send_to_pipe_multipart(msg_parts)
except Exception:
return
def initHeader(self):
"""Initialize the IP header according to the IP format definition.
"""
# Ethernet header
# Retrieve remote MAC address
dstMacAddr = arpreq.arpreq(self.remoteIP)
if dstMacAddr is not None:
dstMacAddr = dstMacAddr.replace(':', '')
dstMacAddr = binascii.unhexlify(dstMacAddr)
else:
# Force ARP resolution
p = subprocess.Popen(["/bin/ping", "-c1", self.remoteIP])
p.wait()
time.sleep(0.1)
dstMacAddr = arpreq.arpreq(self.remoteIP)
if dstMacAddr is not None:
dstMacAddr = dstMacAddr.replace(':', '')
dstMacAddr = binascii.unhexlify(dstMacAddr)
else:
raise Exception("Cannot resolve IP address to a MAC address for IP: '{}'".format(self.remoteIP))
# Retrieve local MAC address
srcMacAddr = self.get_interface_addr(bytes(self.interface, 'utf-8'))[1]
eth_dst = Field(name='eth.dst', domain=Raw(dstMacAddr))
eth_src = Field(name='eth.src', domain=Raw(srcMacAddr))
eth_type = Field(name='eth.type', domain=Raw(b"\x08\x00"))
# IP header
ip_ver = Field(
name='ip.version', domain=BitArray(
value=bitarray('0100'))) # IP Version 4
ip_ihl = Field(name='ip.hdr_len', domain=BitArray(bitarray('0000')))
ip_tos = Field(
name='ip.tos',
domain=Data(
dataType=BitArray(nbBits=8),
originalValue=bitarray('00000000'),
svas=SVAS.PERSISTENT))
ip_tot_len = Field(
name='ip.len', domain=BitArray(bitarray('0000000000000000')))
ip_id = Field(name='ip.id', domain=BitArray(nbBits=16))
ip_flags = Field(name='ip.flags', domain=Data(dataType=BitArray(nbBits=3), originalValue=bitarray('000'), svas=SVAS.PERSISTENT))
ip_frag_off = Field(name='ip.fragment', domain=Data(dataType=BitArray(nbBits=13), originalValue=bitarray('0000000000000'), svas=SVAS.PERSISTENT))
ip_ttl = Field(name='ip.ttl', domain=Data(dataType=BitArray(nbBits=8), originalValue=bitarray('01000000'), svas=SVAS.PERSISTENT))
ip_proto = Field(name='ip.proto', domain=Integer(value=self.upperProtocol, unitSize=AbstractType.UNITSIZE_8, endianness=AbstractType.ENDIAN_BIG, sign=AbstractType.SIGN_UNSIGNED))
ip_checksum = Field(name='ip.checksum', domain=BitArray(bitarray('0000000000000000')))
ip_saddr = Field(name='ip.src', domain=IPv4(self.localIP))
ip_daddr = Field(
name='ip.dst', domain=IPv4(self.remoteIP))
ip_payload = Field(name='ip.payload', domain=Raw())
ip_ihl.domain = Size([ip_ver,
ip_ihl,
ip_tos,
ip_tot_len,
ip_id, ip_flags,
ip_frag_off,
ip_ttl, ip_proto,
ip_checksum,
ip_saddr,
ip_daddr], dataType=BitArray(nbBits=4), factor=1/float(32))
ip_tot_len.domain = Size([ip_ver,
ip_ihl,
ip_tos,
ip_tot_len,
ip_id,
ip_flags,
ip_frag_off,
ip_ttl,
ip_proto,
ip_checksum,
ip_saddr,
ip_daddr,
ip_payload], dataType=Integer(unitSize=AbstractType.UNITSIZE_16, sign=AbstractType.SIGN_UNSIGNED), factor=1/float(8))
ip_checksum.domain = InternetChecksum(fields=[ip_ver,
ip_ihl,
ip_tos,
ip_tot_len,
ip_id,
ip_flags,
ip_frag_off,
ip_ttl,
ip_proto,
ip_checksum,
ip_saddr,
ip_daddr], dataType=Raw(nbBytes=2, unitSize=AbstractType.UNITSIZE_16))
self.header = Symbol(name='Ethernet layer', fields=[eth_dst,
eth_src,
eth_type,
ip_ver,
ip_ihl,
ip_tos,
ip_tot_len,
ip_id,
ip_flags,
ip_frag_off,
ip_ttl,
ip_proto,
ip_checksum,
ip_saddr,
ip_daddr,
ip_payload])
def test_illegal_type():
with pytest.raises(TypeError):
arpreq(None)
def test_default_gateway():
gateway = get_default_gateway()
if not gateway:
pytest.skip("No default gateway present.")
assert arpreq(gateway) is not None
def initHeader(self):
"""Initialize the IP header according to the IP format definition.
"""
# Ethernet header
# Retrieve remote MAC address
dstMacAddr = arpreq.arpreq(self.remoteIP)
if dstMacAddr is not None:
dstMacAddr = dstMacAddr.replace(':', '')
dstMacAddr = binascii.unhexlify(dstMacAddr)
else:
# Force ARP resolution
p = subprocess.Popen(["/bin/ping", "-c1", self.remoteIP])
p.wait()
time.sleep(0.1)
dstMacAddr = arpreq.arpreq(self.remoteIP)
if dstMacAddr is not None:
dstMacAddr = dstMacAddr.replace(':', '')
dstMacAddr = binascii.unhexlify(dstMacAddr)
else:
raise Exception(
"Cannot resolve IP address to a MAC address for IP: '{}'".
format(self.remoteIP))
# Retrieve local MAC address
srcMacAddr = self.get_interface_addr(bytes(self.interface, 'utf-8'))[1]
eth_dst = Field(name='eth.dst', domain=Raw(dstMacAddr))
eth_src = Field(name='eth.src', domain=Raw(srcMacAddr))
eth_type = Field(name='eth.type', domain=Raw(b"\x08\x00"))
# IP header
ip_ver = Field(name='ip.version',
domain=BitArray(value=bitarray('0100'))) # IP Version 4
ip_ihl = Field(name='ip.hdr_len', domain=BitArray(bitarray('0000')))
ip_tos = Field(name='ip.tos',
domain=Data(dataType=BitArray(nbBits=8),
originalValue=bitarray('00000000'),
svas=SVAS.PERSISTENT))
ip_tot_len = Field(name='ip.len',
domain=BitArray(bitarray('0000000000000000')))
ip_id = Field(name='ip.id', domain=BitArray(nbBits=16))
ip_flags = Field(name='ip.flags',
domain=Data(dataType=BitArray(nbBits=3),
originalValue=bitarray('000'),
svas=SVAS.PERSISTENT))
ip_frag_off = Field(name='ip.fragment',
domain=Data(
dataType=BitArray(nbBits=13),
originalValue=bitarray('0000000000000'),
svas=SVAS.PERSISTENT))
ip_ttl = Field(name='ip.ttl',
domain=Data(dataType=BitArray(nbBits=8),
originalValue=bitarray('01000000'),
svas=SVAS.PERSISTENT))
ip_proto = Field(name='ip.proto',
domain=Integer(value=self.upperProtocol,
unitSize=AbstractType.UNITSIZE_8,
endianness=AbstractType.ENDIAN_BIG,
sign=AbstractType.SIGN_UNSIGNED))
ip_checksum = Field(name='ip.checksum',
domain=BitArray(bitarray('0000000000000000')))
ip_saddr = Field(name='ip.src', domain=IPv4(self.localIP))
ip_daddr = Field(name='ip.dst', domain=IPv4(self.remoteIP))
ip_payload = Field(name='ip.payload', domain=Raw())
ip_ihl.domain = Size([
ip_ver, ip_ihl, ip_tos, ip_tot_len, ip_id, ip_flags, ip_frag_off,
ip_ttl, ip_proto, ip_checksum, ip_saddr, ip_daddr
],
dataType=BitArray(nbBits=4),
factor=1 / float(32))
ip_tot_len.domain = Size([
ip_ver, ip_ihl, ip_tos, ip_tot_len, ip_id, ip_flags, ip_frag_off,
ip_ttl, ip_proto, ip_checksum, ip_saddr, ip_daddr, ip_payload
],
dataType=Integer(
unitSize=AbstractType.UNITSIZE_16,
sign=AbstractType.SIGN_UNSIGNED),
factor=1 / float(8))
ip_checksum.domain = InternetChecksum(
fields=[
ip_ver, ip_ihl, ip_tos, ip_tot_len, ip_id, ip_flags,
ip_frag_off, ip_ttl, ip_proto, ip_checksum, ip_saddr, ip_daddr
],
dataType=Raw(nbBytes=2, unitSize=AbstractType.UNITSIZE_16))
self.header = Symbol(name='Ethernet layer',
fields=[
eth_dst, eth_src, eth_type, ip_ver, ip_ihl,
ip_tos, ip_tot_len, ip_id, ip_flags,
ip_frag_off, ip_ttl, ip_proto, ip_checksum,
ip_saddr, ip_daddr, ip_payload
])
