# This file is part of Scapy
|
# Scapy is free software: you can redistribute it and/or modify
|
# it under the terms of the GNU General Public License as published by
|
# the Free Software Foundation, either version 2 of the License, or
|
# any later version.
|
#
|
# Scapy is distributed in the hope that it will be useful,
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
# GNU General Public License for more details.
|
#
|
# You should have received a copy of the GNU General Public License
|
# along with Scapy. If not, see <http://www.gnu.org/licenses/>.
|
|
# author: <jellch@harris.com>
|
|
# scapy.contrib.description = PPI GEOLOCATION
|
# scapy.contrib.status = loads
|
|
|
"""
|
PPI-GEOLOCATION tags
|
"""
|
from __future__ import absolute_import
|
import struct, time
|
from scapy.packet import *
|
from scapy.fields import *
|
from scapy.contrib.ppi import PPIGenericFldHdr,addPPIType
|
from scapy.error import warning
|
import scapy.modules.six as six
|
from scapy.modules.six.moves import range
|
|
CURR_GEOTAG_VER = 2 #Major revision of specification
|
|
PPI_GPS = 30002
|
PPI_VECTOR = 30003
|
PPI_SENSOR = 30004
|
PPI_ANTENNA = 30005
|
#The FixedX_Y Fields are used to store fixed point numbers in a variety of fields in the GEOLOCATION-TAGS specification
|
class Fixed3_6Field(LEIntField):
|
def i2h(self, pkt, x):
|
if x is not None:
|
if (x < 0):
|
warning("Fixed3_6: Internal value too negative: %d", x)
|
x = 0
|
elif (x > 999999999):
|
warning("Fixed3_6: Internal value too positive: %d", x)
|
x = 999999999
|
x = x * 1e-6
|
return x
|
def h2i(self, pkt, x):
|
if x is not None:
|
if (x <= -0.5e-6):
|
warning("Fixed3_6: Input value too negative: %.7f", x)
|
x = 0
|
elif (x >= 999.9999995):
|
warning("Fixed3_6: Input value too positive: %.7f", x)
|
x = 999.999999
|
x = int(round(x * 1e6))
|
return x
|
def i2m(self, pkt, x):
|
"""Convert internal value to machine value"""
|
if x is None:
|
#Try to return zero if undefined
|
x = self.h2i(pkt, 0)
|
return x
|
|
def i2repr(self,pkt,x):
|
if x is None:
|
y=0
|
else:
|
y=self.i2h(pkt,x)
|
return "%3.6f"%(y)
|
class Fixed3_7Field(LEIntField):
|
def i2h(self, pkt, x):
|
if x is not None:
|
if (x < 0):
|
warning("Fixed3_7: Internal value too negative: %d", x)
|
x = 0
|
elif (x > 3600000000):
|
warning("Fixed3_7: Internal value too positive: %d", x)
|
x = 3600000000
|
x = (x - 1800000000) * 1e-7
|
return x
|
def h2i(self, pkt, x):
|
if x is not None:
|
if (x <= -180.00000005):
|
warning("Fixed3_7: Input value too negative: %.8f", x)
|
x = -180.0
|
elif (x >= 180.00000005):
|
warning("Fixed3_7: Input value too positive: %.8f", x)
|
x = 180.0
|
x = int(round((x + 180.0) * 1e7))
|
return x
|
def i2m(self, pkt, x):
|
"""Convert internal value to machine value"""
|
if x is None:
|
#Try to return zero if undefined
|
x = self.h2i(pkt, 0)
|
return x
|
def i2repr(self,pkt,x):
|
if x is None:
|
y=0
|
else:
|
y=self.i2h(pkt,x)
|
return "%3.7f"%(y)
|
|
class Fixed6_4Field(LEIntField):
|
def i2h(self, pkt, x):
|
if x is not None:
|
if (x < 0):
|
warning("Fixed6_4: Internal value too negative: %d", x)
|
x = 0
|
elif (x > 3600000000):
|
warning("Fixed6_4: Internal value too positive: %d", x)
|
x = 3600000000
|
x = (x - 1800000000) * 1e-4
|
return x
|
def h2i(self, pkt, x):
|
if x is not None:
|
if (x <= -180000.00005):
|
warning("Fixed6_4: Input value too negative: %.5f", x)
|
x = -180000.0
|
elif (x >= 180000.00005):
|
warning("Fixed6_4: Input value too positive: %.5f", x)
|
x = 180000.0
|
x = int(round((x + 180000.0) * 1e4))
|
return x
|
def i2m(self, pkt, x):
|
"""Convert internal value to machine value"""
|
if x is None:
|
#Try to return zero if undefined
|
x = self.h2i(pkt, 0)
|
return x
|
def i2repr(self,pkt,x):
|
if x is None:
|
y=0
|
else:
|
y=self.i2h(pkt,x)
|
return "%6.4f"%(y)
|
#The GPS timestamps fractional time counter is stored in a 32-bit unsigned ns counter.
|
#The ept field is as well,
|
class NSCounter_Field(LEIntField):
|
def i2h(self, pkt, x): #converts nano-seconds to seconds for output
|
if x is not None:
|
if (x < 0):
|
warning("NSCounter_Field: Internal value too negative: %d", x)
|
x = 0
|
elif (x >= 2**32):
|
warning("NSCounter_Field: Internal value too positive: %d", x)
|
x = 2**32-1
|
x = (x / 1e9)
|
return x
|
def h2i(self, pkt, x): #converts input in seconds into nano-seconds for storage
|
if x is not None:
|
if (x < 0):
|
warning("NSCounter_Field: Input value too negative: %.10f", x)
|
x = 0
|
elif (x >= (2**32) / 1e9):
|
warning("NSCounter_Field: Input value too positive: %.10f", x)
|
x = (2**32-1) / 1e9
|
x = int(round((x * 1e9)))
|
return x
|
def i2repr(self,pkt,x):
|
if x is None:
|
y=0
|
else:
|
y=self.i2h(pkt,x)
|
return "%1.9f"%(y)
|
|
class LETimeField(UTCTimeField,LEIntField):
|
__slots__ = ["epoch", "delta", "strf"]
|
def __init__(self, name, default, epoch=None, strf="%a, %d %b %Y %H:%M:%S +0000"):
|
LEIntField.__init__(self, name, default)
|
UTCTimeField.__init__(self, name, default, epoch=epoch, strf=strf)
|
|
class SignedByteField(Field):
|
def __init__(self, name, default):
|
Field.__init__(self, name, default, "b")
|
def randval(self):
|
return RandSByte()
|
|
class XLEShortField(LEShortField,XShortField):
|
def i2repr(self, pkt, x):
|
return XShortField.i2repr(self, pkt, x)
|
|
class XLEIntField(LEIntField,XIntField):
|
def i2repr(self, pkt, x):
|
return XIntField.i2repr(self, pkt, x)
|
|
class GPSTime_Field(LETimeField):
|
def __init__(self, name, default):
|
return LETimeField.__init__(self, name, default, strf="%a, %d %b %Y %H:%M:%S UTC")
|
|
class VectorFlags_Field(XLEIntField):
|
"""Represents te VectorFlags field. Handles the RelativeTo:sub-field"""
|
_fwdstr = "DefinesForward"
|
_resmask = 0xfffffff8
|
_relmask = 0x6
|
_relnames = ["RelativeToForward", "RelativeToEarth", "RelativeToCurrent", "RelativeToReserved"]
|
_relvals = [0x00, 0x02, 0x04, 0x06]
|
def i2repr(self, pkt, x):
|
if x is None:
|
return str(x)
|
r = []
|
if (x & 0x1):
|
r.append(self._fwdstr)
|
i = (x & self._relmask) >> 1
|
r.append(self._relnames[i])
|
i = x & self._resmask
|
if (i):
|
r.append("ReservedBits:%08X" % i)
|
sout = "+".join(r)
|
return sout
|
def any2i(self, pkt, x):
|
if isinstance(x, str):
|
r = x.split("+")
|
y = 0
|
for value in r:
|
if (value == self._fwdstr):
|
y |= 0x1
|
elif (value in self._relnames):
|
i = self._relnames.index(value)
|
y &= (~self._relmask)
|
y |= self._relvals[i]
|
else:
|
#logging.warning("Unknown VectorFlags Argument: %s", value)
|
pass
|
else:
|
y = x
|
#print "any2i: %s --> %s" % (str(x), str(y))
|
return y
|
|
class HCSIFlagsField(FlagsField):
|
""" A FlagsField where each bit/flag turns a conditional field on or off.
|
If the value is None when building a packet, i2m() will check the value of
|
every field in self.names. If the field's value is not None, the corresponding
|
flag will be set. """
|
def i2m(self, pkt, val):
|
if val is None:
|
val = 0
|
if (pkt):
|
for i, name in enumerate(self.names):
|
value = pkt.getfieldval(name)
|
if value is not None:
|
val |= 1 << i
|
return val
|
|
class HCSINullField(StrFixedLenField):
|
def __init__(self, name, default):
|
return StrFixedLenField.__init__(self, name, default, length=0)
|
|
class HCSIDescField(StrFixedLenField):
|
def __init__(self, name, default):
|
return StrFixedLenField.__init__(self, name, default, length=32)
|
|
class HCSIAppField(StrFixedLenField):
|
def __init__(self, name, default):
|
return StrFixedLenField.__init__(self, name, default, length=60)
|
|
def _FlagsList(myfields):
|
flags = ["Reserved%02d" % i for i in range(32)]
|
for i, value in six.iteritems(myfields):
|
flags[i] = value
|
return flags
|
|
# Define all geolocation-tag flags lists
|
_hcsi_gps_flags = _FlagsList({0:"No Fix Available", 1:"GPS", 2:"Differential GPS",
|
3:"Pulse Per Second", 4:"Real Time Kinematic",
|
5:"Float Real Time Kinematic", 6:"Estimated (Dead Reckoning)",
|
7:"Manual Input", 8:"Simulation"})
|
|
#_hcsi_vector_flags = _FlagsList({0:"ForwardFrame", 1:"RotationsAbsoluteXYZ", 5:"OffsetFromGPS_XYZ"})
|
#This has been replaced with the VectorFlags_Field class, in order to handle the RelativeTo:subfield
|
|
_hcsi_vector_char_flags = _FlagsList({0:"Antenna", 1:"Direction of Travel",
|
2:"Front of Vehicle", 3:"Angle of Arrival", 4:"Transmitter Position",
|
8:"GPS Derived", 9:"INS Derived", 10:"Compass Derived",
|
11:"Acclerometer Derived", 12:"Human Derived"})
|
|
_hcsi_antenna_flags = _FlagsList({ 1:"Horizontal Polarization", 2:"Vertical Polarization",
|
3:"Circular Polarization Left", 4:"Circular Polarization Right",
|
16:"Electronically Steerable", 17:"Mechanically Steerable"})
|
|
""" HCSI PPI Fields are similar to RadioTap. A mask field called "present" specifies if each field
|
is present. All other fields are conditional. When dissecting a packet, each field is present if
|
"present" has the corresponding bit set. When building a packet, if "present" is None, the mask is
|
set to include every field that does not have a value of None. Otherwise, if the mask field is
|
not None, only the fields specified by "present" will be added to the packet.
|
|
To build each Packet type, build a list of the fields normally, excluding the present bitmask field.
|
The code will then construct conditional versions of each field and add the present field.
|
See GPS_Fields as an example. """
|
|
# Conditional test for all HCSI Fields
|
def _HCSITest(pkt, ibit, name):
|
if pkt.present is None:
|
return (pkt.getfieldval(name) is not None)
|
return pkt.present & ibit
|
|
# Wrap optional fields in ConditionalField, add HCSIFlagsField
|
def _HCSIBuildFields(fields):
|
names = [f.name for f in fields]
|
cond_fields = [HCSIFlagsField('present', None, -len(names), names)]
|
for i, name in enumerate(names):
|
ibit = 1 << i
|
seval = "lambda pkt:_HCSITest(pkt,%s,'%s')" % (ibit, name)
|
test = eval(seval)
|
cond_fields.append(ConditionalField(fields[i], test))
|
return cond_fields
|
|
class HCSIPacket(Packet):
|
name = "PPI HCSI"
|
fields_desc = [ LEShortField('pfh_type', None),
|
LEShortField('pfh_length', None),
|
ByteField('geotag_ver', CURR_GEOTAG_VER),
|
ByteField('geotag_pad', 0),
|
LEShortField('geotag_len', None)]
|
def post_build(self, p, pay):
|
if self.pfh_length is None:
|
l = len(p) - 4
|
sl = struct.pack('<H',l)
|
p = p[:2] + sl + p[4:]
|
if self.geotag_len is None:
|
l_g = len(p) - 4
|
sl_g = struct.pack('<H',l_g)
|
p = p[:6] + sl_g + p[8:]
|
p += pay
|
return p
|
def extract_padding(self, p):
|
return b"", p
|
|
#GPS Fields
|
GPS_Fields = [FlagsField("GPSFlags", None, -32, _hcsi_gps_flags),
|
Fixed3_7Field("Latitude", None),
|
Fixed3_7Field("Longitude", None), Fixed6_4Field("Altitude", None),
|
Fixed6_4Field("Altitude_g", None), GPSTime_Field("GPSTime", None),
|
NSCounter_Field("FractionalTime", None), Fixed3_6Field("eph", None),
|
Fixed3_6Field("epv", None), NSCounter_Field("ept", None),
|
HCSINullField("Reserved10", None), HCSINullField("Reserved11", None),
|
HCSINullField("Reserved12", None), HCSINullField("Reserved13", None),
|
HCSINullField("Reserved14", None), HCSINullField("Reserved15", None),
|
HCSINullField("Reserved16", None), HCSINullField("Reserved17", None),
|
HCSINullField("Reserved18", None), HCSINullField("Reserved19", None),
|
HCSINullField("Reserved20", None), HCSINullField("Reserved21", None),
|
HCSINullField("Reserved22", None), HCSINullField("Reserved23", None),
|
HCSINullField("Reserved24", None), HCSINullField("Reserved25", None),
|
HCSINullField("Reserved26", None), HCSINullField("Reserved27", None),
|
HCSIDescField("DescString", None), XLEIntField("AppId", None),
|
HCSIAppField("AppData", None), HCSINullField("Extended", None)]
|
|
class GPS(HCSIPacket):
|
name = "PPI GPS"
|
fields_desc = [ LEShortField('pfh_type', PPI_GPS), #pfh_type
|
LEShortField('pfh_length', None), #pfh_len
|
ByteField('geotag_ver', CURR_GEOTAG_VER), #base_geotag_header.ver
|
ByteField('geotag_pad', 0), #base_geotag_header.pad
|
LEShortField('geotag_len', None)] + _HCSIBuildFields(GPS_Fields)
|
|
|
#Vector Fields
|
VEC_Fields = [VectorFlags_Field("VectorFlags", None),
|
FlagsField("VectorChars", None, -32, _hcsi_vector_char_flags),
|
Fixed3_6Field("Pitch", None), Fixed3_6Field("Roll", None),
|
Fixed3_6Field("Heading", None), Fixed6_4Field("Off_X", None),
|
Fixed6_4Field("Off_Y", None), Fixed6_4Field("Off_Z", None),
|
HCSINullField("Reserved08", None), HCSINullField("Reserved09", None),
|
HCSINullField("Reserved10", None), HCSINullField("Reserved11", None),
|
HCSINullField("Reserved12", None), HCSINullField("Reserved13", None),
|
HCSINullField("Reserved14", None), HCSINullField("Reserved15", None),
|
Fixed3_6Field("Err_Rot", None), Fixed6_4Field("Err_Off", None),
|
HCSINullField("Reserved18", None), HCSINullField("Reserved19", None),
|
HCSINullField("Reserved20", None), HCSINullField("Reserved21", None),
|
HCSINullField("Reserved22", None), HCSINullField("Reserved23", None),
|
HCSINullField("Reserved24", None), HCSINullField("Reserved25", None),
|
HCSINullField("Reserved26", None), HCSINullField("Reserved27", None),
|
HCSIDescField("DescString", None), XLEIntField("AppId", None),
|
HCSIAppField("AppData", None), HCSINullField("Extended", None)]
|
|
class Vector(HCSIPacket):
|
name = "PPI Vector"
|
fields_desc = [ LEShortField('pfh_type', PPI_VECTOR), #pfh_type
|
LEShortField('pfh_length', None), #pfh_len
|
ByteField('geotag_ver', CURR_GEOTAG_VER), #base_geotag_header.ver
|
ByteField('geotag_pad', 0), #base_geotag_header.pad
|
LEShortField('geotag_len', None)] + _HCSIBuildFields(VEC_Fields)
|
|
#Sensor Fields
|
# http://www.iana.org/assignments/icmp-parameters
|
sensor_types= { 1 : "Velocity",
|
2 : "Acceleration",
|
3 : "Jerk",
|
100 : "Rotation",
|
101 : "Magnetic",
|
1000: "Temperature",
|
1001: "Barometer",
|
1002: "Humidity",
|
2000: "TDOA_Clock",
|
2001: "Phase"
|
}
|
SENS_Fields = [ LEShortEnumField('SensorType', None, sensor_types),
|
SignedByteField('ScaleFactor', None),
|
Fixed6_4Field('Val_X', None),
|
Fixed6_4Field('Val_Y', None),
|
Fixed6_4Field('Val_Z', None),
|
Fixed6_4Field('Val_T', None),
|
Fixed6_4Field('Val_E', None),
|
HCSINullField("Reserved07", None), HCSINullField("Reserved08", None),
|
HCSINullField("Reserved09", None), HCSINullField("Reserved10", None),
|
HCSINullField("Reserved11", None), HCSINullField("Reserved12", None),
|
HCSINullField("Reserved13", None), HCSINullField("Reserved14", None),
|
HCSINullField("Reserved15", None), HCSINullField("Reserved16", None),
|
HCSINullField("Reserved17", None), HCSINullField("Reserved18", None),
|
HCSINullField("Reserved19", None), HCSINullField("Reserved20", None),
|
HCSINullField("Reserved21", None), HCSINullField("Reserved22", None),
|
HCSINullField("Reserved23", None), HCSINullField("Reserved24", None),
|
HCSINullField("Reserved25", None), HCSINullField("Reserved26", None),
|
HCSINullField("Reserved27", None),
|
HCSIDescField("DescString", None), XLEIntField("AppId", None),
|
HCSIAppField("AppData", None), HCSINullField("Extended", None)]
|
|
|
|
class Sensor(HCSIPacket):
|
name = "PPI Sensor"
|
fields_desc = [ LEShortField('pfh_type', PPI_SENSOR), #pfh_type
|
LEShortField('pfh_length', None), #pfh_len
|
ByteField('geotag_ver', CURR_GEOTAG_VER ), #base_geotag_header.ver
|
ByteField('geotag_pad', 0), #base_geotag_header.pad
|
LEShortField('geotag_len', None)] + _HCSIBuildFields(SENS_Fields)
|
|
# HCSIAntenna Fields
|
ANT_Fields = [FlagsField("AntennaFlags", None, -32, _hcsi_antenna_flags),
|
ByteField("Gain", None),
|
Fixed3_6Field("HorizBw", None), Fixed3_6Field("VertBw", None),
|
Fixed3_6Field("PrecisionGain",None), XLEShortField("BeamID", None),
|
HCSINullField("Reserved06", None), HCSINullField("Reserved07", None),
|
HCSINullField("Reserved08", None), HCSINullField("Reserved09", None),
|
HCSINullField("Reserved10", None), HCSINullField("Reserved11", None),
|
HCSINullField("Reserved12", None), HCSINullField("Reserved13", None),
|
HCSINullField("Reserved14", None), HCSINullField("Reserved15", None),
|
HCSINullField("Reserved16", None), HCSINullField("Reserved17", None),
|
HCSINullField("Reserved18", None), HCSINullField("Reserved19", None),
|
HCSINullField("Reserved20", None), HCSINullField("Reserved21", None),
|
HCSINullField("Reserved22", None), HCSINullField("Reserved23", None),
|
HCSINullField("Reserved24", None), HCSINullField("Reserved25", None),
|
HCSIDescField("SerialNumber", None), HCSIDescField("ModelName", None),
|
HCSIDescField("DescString", None), XLEIntField("AppId", None),
|
HCSIAppField("AppData", None), HCSINullField("Extended", None)]
|
|
class Antenna(HCSIPacket):
|
name = "PPI Antenna"
|
fields_desc = [ LEShortField('pfh_type', PPI_ANTENNA), #pfh_type
|
LEShortField('pfh_length', None), #pfh_len
|
ByteField('geotag_ver', CURR_GEOTAG_VER), #base_geotag_header.ver
|
ByteField('geotag_pad', 0), #base_geotag_header.pad
|
LEShortField('geotag_len', None)] + _HCSIBuildFields(ANT_Fields)
|
|
addPPIType(PPI_GPS, GPS)
|
addPPIType(PPI_VECTOR, Vector)
|
addPPIType(PPI_SENSOR, Sensor)
|
addPPIType(PPI_ANTENNA,Antenna)
|
