desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'Set 16 bit message ID.'
| def set_transaction_id_tcp(self, value):
| self.header.set_word(2, value)
|
'Get 16 bit flags.'
| def get_flags(self):
| return self.header.get_word(2)
|
'Set 16 bit flags.'
| def set_flags(self, value):
| self.header.set_word(2, value)
|
'Get 16 bit flags.'
| def get_flags_tcp(self):
| return self.header.get_word(4)
|
'Set 16 bit flags.'
| def set_flags_tcp(self, value):
| self.header.set_word(4, value)
|
'Get Unsigned 16 bit integer specifying the number of entries in the question section.'
| def get_qdcount(self):
| return self.header.get_word(4)
|
'Set Unsigned 16 bit integer specifying the number of entries in the question section.'
| def set_qdcount(self, value):
| self.header.set_word(4, value)
|
'Get Unsigned 16 bit integer specifying the number of entries in the question section.'
| def get_qdcount_tcp(self):
| return self.header.get_word(6)
|
'Set Unsigned 16 bit integer specifying the number of entries in the question section.'
| def set_qdcount_tcp(self, value):
| self.header.set_word(6, value)
|
'Get Unsigned 16 bit integer specifying the number of resource records in the answer section'
| def get_ancount(self):
| return self.header.get_word(6)
|
'Set Unsigned 16 bit integer specifying the number of resource records in the answer section'
| def set_ancount(self, value):
| self.header.set_word(6, value)
|
'Get Unsigned 16 bit integer specifying the number of name server resource records in the authority section.'
| def get_nscount(self):
| return self.header.get_word(8)
|
'Set Unsigned 16 bit integer specifying the number of name server resource records in the authority section.'
| def set_nscount(self, value):
| self.header.set_word(8, value)
|
'Get Unsigned 16 bit integer specifying the number of resource records in the additional records section.'
| def get_arcount(self):
| return self.header.get_word(10)
|
'Set Unsigned 16 bit integer specifying the number of resource records in the additional records section.'
| def set_arcount(self, value):
| self.header.set_word(10, value)
|
'Get a list of the DNS Question.'
| def get_questions(self):
| return self.__get_questions()[0]
|
'Get a list of the DNS Question.'
| def get_questions_tcp(self):
| return self.__get_questions_tcp()[0]
|
'Parse compressed message defined on rfc1035 4.1.4.'
| def parseCompressedMessage(self, buf, offset=0):
| if (offset >= len(buf)):
raise Exception('No more data to parse. Offset is bigger than length of buffer.')
byte = struct.unpack('B', buf[offset])[0]
if ((byte & 192) == 192):
pointer = struct.unpack('!H', buf[offset:(offset + 2)])[0]
pointer = ((pointer & 16383) - self.__HEADER_BASE_SIZE)
offset += 2
name = self.parseCompressedMessage(buf, pointer)[1]
return (offset, name)
else:
if (byte == 0):
offset += 1
return (offset, '')
offset += 1
name = buf[offset:(offset + byte)]
offset += byte
(offset, unamed) = self.parseCompressedMessage(buf, offset)
if (not unamed):
return (offset, name)
else:
return (offset, ((name + '.') + unamed))
|
'Get a list of the DNS Authoritative.'
| def __get_authoritative(self):
| offset = self.__get_answers()[1]
nscount = self.get_nscount()
return self.__process_answer_structure(offset, nscount)
|
'Get a list of the DNS Additional Records.'
| def __get_additionals(self):
| offset = self.__get_authoritative()[1]
arcount = self.get_arcount()
return self.__process_answer_structure(offset, arcount)
|
'Add a raw answer'
| def add_answer(self, answer_raw):
| questions_raw = self.__get_questions_raw()
answers_raw = self.__get_answers_raw()
authoritative_raw = self.__get_authoritative_raw()
additionals_raw = self.__get_additionals_raw()
answers_raw += answer_raw
body = (((questions_raw + answers_raw) + authoritative_raw) + additionals_raw)
self.load_body(body)
cur_answer_count = (self.get_ancount() + 1)
self.set_ancount(cur_answer_count)
|
'This method only makes sense before connection for most protocols.'
| def setRemoteName(self, remoteName):
| self.__remoteName = remoteName
|
'This method only makes sense before connection for most protocols.'
| def setRemoteHost(self, remoteHost):
| self.__remoteHost = remoteHost
|
'This method only makes sense before connection for most protocols.'
| def set_dport(self, dport):
| self.__dstport = dport
|
'This method only makes sense before connection for most protocols.'
| def set_addr(self, addr):
| self.setRemoteHost(addr[0])
self.set_dport(addr[1])
|
'Changes anything not dundered or not a descriptor.
If a descriptor is added with the same name as an enum member, the name
is removed from _member_names (this may leave a hole in the numerical
sequence of values).
If an enum member name is used twice, an error is raised; duplicate
values are not checked for.
Single underscore (sunder) names are reserved.
Note: in 3.x __order__ is simply discarded as a not necessary piece
leftover from 2.x'
| def __setitem__(self, key, value):
| if ((pyver >= 3.0) and (key == '__order__')):
return
if _is_sunder(key):
raise ValueError('_names_ are reserved for future Enum use')
elif _is_dunder(key):
pass
elif (key in self._member_names):
raise TypeError(('Attempted to reuse key: %r' % key))
elif (not _is_descriptor(value)):
if (key in self):
raise TypeError(('Key already defined as: %r' % self[key]))
self._member_names.append(key)
super(_EnumDict, self).__setitem__(key, value)
|
'Either returns an existing member, or creates a new enum class.
This method is used both when an enum class is given a value to match
to an enumeration member (i.e. Color(3)) and for the functional API
(i.e. Color = Enum(\'Color\', names=\'red green blue\')).
When used for the functional API: `module`, if set, will be stored in
the new class\' __module__ attribute; `type`, if set, will be mixed in
as the first base class.
Note: if `module` is not set this routine will attempt to discover the
calling module by walking the frame stack; if this is unsuccessful
the resulting class will not be pickleable.'
| def __call__(cls, value, names=None, module=None, type=None):
| if (names is None):
return cls.__new__(cls, value)
return cls._create_(value, names, module=module, type=type)
|
'Returns a mapping of member name->value.
This mapping lists all enum members, including aliases. Note that this
is a copy of the internal mapping.'
| @property
def __members__(cls):
| return cls._member_map_.copy()
|
'Return the enum member matching `name`
We use __getattr__ instead of descriptors or inserting into the enum
class\' __dict__ in order to support `name` and `value` being both
properties for enum members (which live in the class\' __dict__) and
enum members themselves.'
| def __getattr__(cls, name):
| if _is_dunder(name):
raise AttributeError(name)
try:
return cls._member_map_[name]
except KeyError:
raise AttributeError(name)
|
'Block attempts to reassign Enum members.
A simple assignment to the class namespace only changes one of the
several possible ways to get an Enum member from the Enum class,
resulting in an inconsistent Enumeration.'
| def __setattr__(cls, name, value):
| member_map = cls.__dict__.get('_member_map_', {})
if (name in member_map):
raise AttributeError('Cannot reassign members.')
super(EnumMeta, cls).__setattr__(name, value)
|
'Convenience method to create a new Enum class.
`names` can be:
* A string containing member names, separated either with spaces or
commas. Values are auto-numbered from 1.
* An iterable of member names. Values are auto-numbered from 1.
* An iterable of (member name, value) pairs.
* A mapping of member name -> value.'
| def _create_(cls, class_name, names=None, module=None, type=None):
| metacls = cls.__class__
if (type is None):
bases = (cls,)
else:
bases = (type, cls)
classdict = metacls.__prepare__(class_name, bases)
__order__ = []
if isinstance(names, str):
names = names.replace(',', ' ').split()
if (isinstance(names, (tuple, list)) and isinstance(names[0], str)):
names = [(e, (i + 1)) for (i, e) in enumerate(names)]
for item in names:
if isinstance(item, str):
(member_name, member_value) = (item, names[item])
else:
(member_name, member_value) = item
classdict[member_name] = member_value
__order__.append(member_name)
if (not isinstance(item, str)):
classdict['__order__'] = ' '.join(__order__)
enum_class = metacls.__new__(metacls, class_name, bases, classdict)
if (module is None):
try:
module = _sys._getframe(2).f_globals['__name__']
except (AttributeError, ValueError):
pass
if (module is None):
_make_class_unpicklable(enum_class)
else:
enum_class.__module__ = module
return enum_class
|
'Returns the type for creating enum members, and the first inherited
enum class.
bases: the tuple of bases that was given to __new__'
| @staticmethod
def _get_mixins_(bases):
| if ((not bases) or (Enum is None)):
return (object, Enum)
member_type = first_enum = None
for base in bases:
if ((base is not Enum) and issubclass(base, Enum) and base._member_names_):
raise TypeError('Cannot extend enumerations')
if (not issubclass(base, Enum)):
raise TypeError('new enumerations must be created as `ClassName([mixin_type,] enum_type)`')
if (not issubclass(bases[0], Enum)):
member_type = bases[0]
first_enum = bases[(-1)]
else:
for base in bases[0].__mro__:
if issubclass(base, Enum):
if (first_enum is None):
first_enum = base
elif (member_type is None):
member_type = base
return (member_type, first_enum)
|
':param string error_string: A string you want to show explaining the exception. Otherwise the default ones will be used
:param integer error_code: the error_code if we\'re using a dictionary with error\'s descriptions
:param NDR packet: if successfully decoded, the NDR packet of the response call. This could probably have useful
information'
| def __init__(self, error_string=None, error_code=None, packet=None):
| Exception.__init__(self)
self.packet = packet
self.error_string = error_string
if (packet is not None):
try:
self.error_code = packet['ErrorCode']
except:
self.error_code = error_code
else:
self.error_code = error_code
|
'adds a call back to a UUID/opnum call
:param uuid ifaceUUID: the interface UUID
:param string secondaryAddr: the secondary address to answer as part of the bind request (e.g. \\PIPE\\srvsvc)
:param dict callbacks: the callbacks for each opnum. Format is [opnum] = callback'
| def addCallbacks(self, ifaceUUID, secondaryAddr, callbacks):
| self._listenUUIDS[uuidtup_to_bin(ifaceUUID)] = {}
self._listenUUIDS[uuidtup_to_bin(ifaceUUID)]['SecondaryAddr'] = secondaryAddr
self._listenUUIDS[uuidtup_to_bin(ifaceUUID)]['CallBacks'] = callbacks
self.log(('Callback added for UUID %s V:%s' % ifaceUUID))
|
'Test TCP options parsing hangs'
| def test_01(self):
| class it_hangs(Thread, ):
def __init__(self):
Thread.__init__(self)
def run(self):
try:
frame = '\x124\x00P\x00\x00\x00\x01\x00\x00\x00\x00`\x00\x00\x00\x8d\\\x00\x00\x02\x00\x00\x00'
tcp = TCP(frame)
except ImpactPacketException as e:
if (str(e) != "'TCP Option length is too low'"):
raise e
except:
pass
thread_hangs = it_hangs()
thread_hangs.setDaemon(True)
thread_hangs.start()
thread_hangs.join(1.0)
self.assertEqual(thread_hangs.isAlive(), False)
|
'Test Ethernet getters'
| def test_01(self):
| self.assertEqual(self.eth.get_packet(), self.frame)
self.assertEqual(self.eth.get_header_size(), 18)
self.assertEqual(self.eth.get_ether_type(), 2048)
self.assertEqual(self.eth.get_ether_dhost(), array('B', self.frame[0:6]))
self.assertEqual(self.eth.get_ether_shost(), array('B', self.frame[6:12]))
|
'Test Ethernet setters'
| def test_02(self):
| self.eth.set_ether_type(35020)
self.assertEqual(self.eth.get_ether_type(), 35020)
dhost = self.eth.get_ether_dhost()
shost = self.eth.get_ether_shost()
self.eth.set_ether_dhost(shost)
self.eth.set_ether_shost(dhost)
self.assertEqual(self.eth.get_ether_dhost(), array('B', self.frame[6:12]))
self.assertEqual(self.eth.get_ether_shost(), array('B', self.frame[0:6]))
|
'Test EthernetTag getters'
| def test_03(self):
| tag = self.eth.pop_tag()
self.assertEqual(tag.get_buffer_as_string(), '\x81\x00\xac\xf3')
self.assertEqual(tag.get_tpid(), 33024)
self.assertEqual(tag.get_pcp(), 5)
self.assertEqual(tag.get_dei(), 0)
self.assertEqual(tag.get_vid(), 3315)
|
'Test EthernetTag setters'
| def test_04(self):
| tag = self.eth.pop_tag()
tag.set_tpid(34984)
tag.set_pcp(2)
tag.set_dei(1)
tag.set_vid(876)
self.assertEqual(tag.get_buffer_as_string(), '\x88\xa8Sl')
|
'Test manipulation with VLAN tags'
| def test_05(self):
| def check_tags(*tags):
self.assertEqual(self.eth.tag_cnt, len(tags))
self.assertEqual(self.eth.get_header_size(), (14 + (4 * len(tags))))
self.assertEqual(self.eth.get_ether_type(), 2048)
for (i, tag) in enumerate(tags):
self.assertEqual(self.eth.get_tag(i).get_buffer_as_string(), tag)
self.eth.push_tag(EthernetTag(2292731905))
check_tags('\x88\xa8P\x01', '\x81\x00\xac\xf3')
self.eth.set_tag(1, EthernetTag())
check_tags('\x88\xa8P\x01', '\x81\x00\x00\x00')
self.eth.push_tag(EthernetTag(2432718034), index=1)
check_tags('\x88\xa8P\x01', '\x91\x00T\xd2', '\x81\x00\x00\x00')
tags = {}
for i in range((-3), 3):
tags[i] = self.eth.get_tag(i).get_buffer_as_string()
self.assertEqual(tags[(-1)], tags[2])
self.assertEqual(tags[(-2)], tags[1])
self.assertEqual(tags[(-3)], tags[0])
self.assertRaises(IndexError, self.eth.get_tag, 3)
self.assertRaises(IndexError, self.eth.get_tag, (-4))
self.assertRaises(IndexError, self.eth.set_tag, 3, EthernetTag())
self.assertRaises(IndexError, self.eth.set_tag, (-4), EthernetTag())
data = self.eth.get_buffer_as_string()
eth_copy = Ethernet(data)
self.assertEqual(eth_copy.tag_cnt, 3)
self.assertEqual(eth_copy.get_header_size(), 26)
self.assertEqual(eth_copy.get_ether_type(), 2048)
eth_copy.pop_tag(1)
self.assertEqual(eth_copy.tag_cnt, 2)
self.assertEqual(eth_copy.get_packet(), (((self.frame[:12] + tags[0]) + tags[2]) + self.frame[(-2):]))
|
'Test TCP get_packet'
| def test_01(self):
| self.assertEqual(self.tcp.get_packet(), self.frame)
|
'Test TCP getters'
| def test_02(self):
| self.assertEqual(self.tcp.get_th_sport(), 60655)
self.assertEqual(self.tcp.get_th_dport(), 80)
self.assertEqual((self.tcp.get_th_off() * 4), 40)
self.assertEqual(self.tcp.get_th_flags(), 2)
self.assertEqual(self.tcp.get_th_win(), 5840)
self.assertEqual(self.tcp.get_th_sum(), 25803)
self.assertEqual(self.tcp.get_SYN(), 1)
self.assertEqual(self.tcp.get_RST(), 0)
|
'Test TCP port setters'
| def test_03(self):
| self.tcp.set_th_sport(54321)
self.assertEqual(self.tcp.get_th_sport(), 54321)
self.tcp.set_th_dport(81)
self.assertEqual(self.tcp.get_th_dport(), 81)
|
'Test TCP offset setters'
| def test_04(self):
| flags = int('10101010', 2)
self.tcp.set_th_flags(flags)
self.assertEqual(self.tcp.get_th_flags(), flags)
self.tcp.set_th_off(4)
self.assertEqual(self.tcp.get_th_off(), 4)
self.assertEqual(self.tcp.get_th_flags(), flags)
|
'Test TCP win setters'
| def test_05(self):
| self.tcp.set_th_win(12345)
self.assertEqual(self.tcp.get_th_win(), 12345)
|
'Test TCP checksum setters'
| def test_06(self):
| self.tcp.set_th_sum(65278)
self.assertEqual(self.tcp.get_th_sum(), 65278)
|
'Test TCP flags setters'
| def test_07(self):
| self.tcp.set_th_flags(3)
self.assertEqual(self.tcp.get_th_flags(), 3)
self.tcp.set_ACK()
self.assertEqual(self.tcp.get_ACK(), 1)
self.assertEqual(self.tcp.get_SYN(), 1)
self.assertEqual(self.tcp.get_FIN(), 1)
self.assertEqual(self.tcp.get_RST(), 0)
self.assertEqual(self.tcp.get_th_flags(), 19)
|
'Test TCP reset_flags'
| def test_08(self):
| self.tcp.set_th_flags(19)
self.assertEqual(self.tcp.get_th_flags(), 19)
self.assertEqual(self.tcp.get_ACK(), 1)
self.assertEqual(self.tcp.get_SYN(), 1)
self.assertEqual(self.tcp.get_FIN(), 1)
self.assertEqual(self.tcp.get_RST(), 0)
self.tcp.reset_flags(2)
self.assertEqual(self.tcp.get_th_flags(), 17)
flags = int('10011', 2)
self.tcp.set_th_flags(flags)
self.assertEqual(self.tcp.get_th_flags(), 19)
self.tcp.reset_flags(int('000010', 2))
self.assertEqual(self.tcp.get_th_flags(), 17)
flags = int('10011', 2)
self.tcp.set_th_flags(flags)
self.assertEqual(self.tcp.get_th_flags(), 19)
self.tcp.reset_flags(int('010001', 2))
self.assertEqual(self.tcp.get_th_flags(), 2)
|
'Test TCP set_flags'
| def test_09(self):
| flags = int('10101010', 2)
self.tcp.set_flags(flags)
self.assertEqual(self.tcp.get_FIN(), 0)
self.assertEqual(self.tcp.get_SYN(), 1)
self.assertEqual(self.tcp.get_RST(), 0)
self.assertEqual(self.tcp.get_PSH(), 1)
self.assertEqual(self.tcp.get_ACK(), 0)
self.assertEqual(self.tcp.get_URG(), 1)
self.assertEqual(self.tcp.get_ECE(), 0)
self.assertEqual(self.tcp.get_CWR(), 1)
self.assertEqual(self.tcp.get_th_flags(), 170)
|
'Test IP6 Packet decoding.'
| def test_decoding(self):
| d = ImpactDecoder.IP6Decoder()
parsed_packet = d.decode(self.binary_packet)
protocol_version = parsed_packet.get_ip_v()
traffic_class = parsed_packet.get_traffic_class()
flow_label = parsed_packet.get_flow_label()
payload_length = parsed_packet.get_payload_length()
next_header = parsed_packet.get_next_header()
hop_limit = parsed_packet.get_hop_limit()
source_address = parsed_packet.get_ip_src()
destination_address = parsed_packet.get_ip_dst()
self.assertEquals(protocol_version, 6, 'IP6 parsing - Incorrect protocol version')
self.assertEquals(traffic_class, 72, 'IP6 parsing - Incorrect traffic class')
self.assertEquals(flow_label, 148997, 'IP6 parsing - Incorrect flow label')
self.assertEquals(payload_length, 1500, 'IP6 parsing - Incorrect payload length')
self.assertEquals(next_header, 17, 'IP6 parsing - Incorrect next header')
self.assertEquals(hop_limit, 1, 'IP6 parsing - Incorrect hop limit')
self.assertEquals(source_address.as_string(), 'FE80::78F8:89D1:30FF:256B', 'IP6 parsing - Incorrect source address')
self.assertEquals(destination_address.as_string(), 'FF02::1:3', 'IP6 parsing - Incorrect destination address')
|
'Test IP6 Packet creation.'
| def test_creation(self):
| crafted_packet = IP6.IP6()
crafted_packet.set_traffic_class(72)
crafted_packet.set_flow_label(148997)
crafted_packet.set_payload_length(1500)
crafted_packet.set_next_header(17)
crafted_packet.set_hop_limit(1)
crafted_packet.set_ip_src('FE80::78F8:89D1:30FF:256B')
crafted_packet.set_ip_dst('FF02::1:3')
crafted_buffer = crafted_packet.get_bytes().tolist()
self.assertEquals(crafted_buffer, self.binary_packet, 'IP6 creation - Buffer mismatch')
|
'Test IP6 Address construction'
| def test_construction(self):
| normal_text_address = 'FE80:1234:5678:ABCD:EF01:2345:6789:ABCD'
normal_binary_address = [254, 128, 18, 52, 86, 120, 171, 205, 239, 1, 35, 69, 103, 137, 171, 205]
oversized_text_address = 'FE80:1234:5678:ABCD:EF01:2345:6789:ABCD:1234'
oversized_binary_address = [254, 128, 18, 52, 86, 120, 171, 205, 239, 1, 35, 69, 103, 137, 171, 205, 0]
subsized_text_address = 'FE80:1234:5678:ABCD:EF01:2345:6789'
subsized_binary_address = [254, 128, 18, 52, 86, 120, 171, 205, 239, 1, 35, 69, 103, 137, 171]
malformed_text_address_1 = 'FE80:123456788:ABCD:EF01:2345:6789:ABCD'
malformed_text_address_2 = 'ZXYW:1234:5678:ABCD:EF01:2345:6789:ABCD'
malformed_text_address_3 = 'FFFFFF:1234:5678:ABCD:EF01:2345:67:ABCD'
empty_text_address = ''
empty_binary_address = []
self.assert_(IP6_Address.IP6_Address(normal_text_address), 'IP6 address construction with normal text address failed')
self.assert_(IP6_Address.IP6_Address(normal_binary_address), 'IP6 address construction with normal binary address failed')
self.assertRaises(Exception, IP6_Address.IP6_Address, oversized_text_address)
self.assertRaises(Exception, IP6_Address.IP6_Address, oversized_binary_address)
self.assertRaises(Exception, IP6_Address.IP6_Address, subsized_text_address)
self.assertRaises(Exception, IP6_Address.IP6_Address, subsized_binary_address)
self.assertRaises(Exception, IP6_Address.IP6_Address, malformed_text_address_1)
self.assertRaises(Exception, IP6_Address.IP6_Address, malformed_text_address_2)
self.assertRaises(Exception, IP6_Address.IP6_Address, malformed_text_address_3)
self.assertRaises(Exception, IP6_Address.IP6_Address, empty_text_address)
self.assertRaises(Exception, IP6_Address.IP6_Address, empty_binary_address)
|
'Test IP6 Unicode text representations'
| def test_unicode_representation(self):
| unicode_normal_text_address = u'FE80:1234:5678:ABCD:EF01:2345:6789:ABCD'
self.assert_(IP6_Address.IP6_Address(unicode_normal_text_address), 'IP6 address construction with UNICODE normal text address failed')
|
'Test IP6 Address conversions.'
| def test_conversions(self):
| text_address = 'FE80:1234:5678:ABCD:EF01:2345:6789:ABCD'
binary_address = [254, 128, 18, 52, 86, 120, 171, 205, 239, 1, 35, 69, 103, 137, 171, 205]
self.assert_((IP6_Address.IP6_Address(text_address).as_string() == text_address), 'IP6 address conversion text -> text failed')
self.assert_((IP6_Address.IP6_Address(binary_address).as_bytes() == binary_address), 'IP6 address conversion binary -> binary failed')
self.assert_((IP6_Address.IP6_Address(binary_address).as_string() == text_address), 'IP6 address conversion binary -> text failed')
self.assert_((IP6_Address.IP6_Address(text_address).as_bytes().tolist() == binary_address), 'IP6 address conversion text -> binary failed')
|
'Test IP6 Address compressions.'
| def test_compressions(self):
| compressed_addresses = ['::', '1::', '::1', '1::2', '1::1:2:3', 'FE80:234:567:4::1']
full_addresses = ['0000:0000:0000:0000:0000:0000:0000:0000', '0001:0000:0000:0000:0000:0000:0000:0000', '0000:0000:0000:0000:0000:0000:0000:0001', '0001:0000:0000:0000:0000:0000:0000:0002', '0001:0000:0000:0000:0000:0001:0002:0003', 'FE80:0234:0567:0004:0000:0000:0000:0001']
for (f, c) in zip(full_addresses, compressed_addresses):
self.assert_((IP6_Address.IP6_Address(f).as_string() == c), ('IP6 address compression failed with full address: ' + f))
self.assert_((IP6_Address.IP6_Address(c).as_string(False) == f), ('IP6 address compression failed with compressed address:' + c))
|
'Test scoped addresses.'
| def test_scoped_addresses(self):
| numeric_scoped_address = 'FE80::1234:1%12'
self.assert_((IP6_Address.IP6_Address(numeric_scoped_address).as_string() == numeric_scoped_address), ('Numeric scoped address conversion failed on address: ' + numeric_scoped_address))
self.assert_((IP6_Address.IP6_Address(numeric_scoped_address).get_scope_id() == '12'), ('Numeric scope ID fetch failed on address: ' + numeric_scoped_address))
self.assert_((IP6_Address.IP6_Address(numeric_scoped_address).get_unscoped_address() == 'FE80::1234:1'), ('Get unscoped address failed on address: ' + numeric_scoped_address))
unscoped_address = '1::4:1'
self.assert_((IP6_Address.IP6_Address(unscoped_address).as_string() == unscoped_address), ('Unscoped address conversion failed on address: ' + unscoped_address))
self.assert_((IP6_Address.IP6_Address(unscoped_address).get_scope_id() == ''), ('Unscoped address scope ID fetch failed on address: ' + unscoped_address))
self.assert_((IP6_Address.IP6_Address(unscoped_address).get_unscoped_address() == unscoped_address), ('Get unscoped address failed on address: ' + unscoped_address))
text_scoped_address = 'FE80::1234:1%BLAH'
self.assert_((IP6_Address.IP6_Address(text_scoped_address).as_string() == text_scoped_address), ('Text scoped address conversion failed on address: ' + text_scoped_address))
self.assert_((IP6_Address.IP6_Address(text_scoped_address).get_scope_id() == 'BLAH'), ('Text scope ID fetch failed on address: ' + text_scoped_address))
self.assert_((IP6_Address.IP6_Address(text_scoped_address).get_unscoped_address() == 'FE80::1234:1'), ('Get unscoped address failed on address: ' + text_scoped_address))
empty_scoped_address = 'FE80::1234:1%'
self.assertRaises(Exception, IP6_Address.IP6_Address, empty_scoped_address)
|
'Test RadioTap frame sizes'
| def test_01_sizes(self):
| self.assertEqual(self.rt0.get_size(), len(self.frame_0))
self.assertEqual(self.rt0.get_header_size(), 24)
self.assertEqual(self.rt0.get_body_size(), (len(self.frame_0) - 24))
self.assertEqual(self.rt0.get_tail_size(), 0)
self.assertEqual(self.rt1.get_size(), len(self.frame_1))
self.assertEqual(self.rt1.get_header_size(), 32)
self.assertEqual(self.rt1.get_body_size(), (len(self.frame_1) - 32))
self.assertEqual(self.rt1.get_tail_size(), 0)
|
'Test RadioTap version getter/setter'
| def test_02_version(self):
| self.assertEqual(self.rt0.get_version(), 0)
self.rt0.set_version(1)
self.assertEqual(self.rt0.get_version(), 1)
self.assertEqual(self.rt1.get_version(), 0)
self.rt1.set_version(1)
self.assertEqual(self.rt1.get_version(), 1)
|
'Test RadioTap present getter'
| def test_03_present(self):
| self.assertEqual(self.rt0.get_present(), 22542)
self.assertEqual(self.rt1.get_present(), 264295)
|
'Test RadioTap present bits tester'
| def test_04_present_bits(self):
| self.assertEqual(self.rt0.get_present_bit(RadioTap.RTF_TSFT), False)
self.assertEqual(self.rt0.get_present_bit(RadioTap.RTF_FLAGS), True)
self.assertEqual(self.rt0.get_present_bit(RadioTap.RTF_RATE), True)
self.assertEqual(self.rt0.get_present_bit(RadioTap.RTF_CHANNEL), True)
self.assertEqual(self.rt0.get_present_bit(RadioTap.RTF_FHSS), False)
self.assertEqual(self.rt0.get_present_bit(RadioTap.RTF_DBM_ANTSIGNAL), False)
self.assertEqual(self.rt0.get_present_bit(RadioTap.RTF_DBM_ANTNOISE), False)
self.assertEqual(self.rt0.get_present_bit(RadioTap.RTF_LOCK_QUALITY), False)
self.assertEqual(self.rt0.get_present_bit(RadioTap.RTF_TX_ATTENUATION), False)
self.assertEqual(self.rt0.get_present_bit(RadioTap.RTF_DB_TX_ATTENUATION), False)
self.assertEqual(self.rt0.get_present_bit(RadioTap.RTF_DBM_TX_POWER), False)
self.assertEqual(self.rt0.get_present_bit(RadioTap.RTF_ANTENNA), True)
self.assertEqual(self.rt0.get_present_bit(RadioTap.RTF_DB_ANTSIGNAL), True)
self.assertEqual(self.rt0.get_present_bit(RadioTap.RTF_DB_ANTNOISE), False)
self.assertEqual(self.rt0.get_present_bit(RadioTap.RTF_FCS_IN_HEADER), True)
self.assertEqual(self.rt0.get_present_bit(RadioTap.RTF_TX_FLAGS), False)
self.assertEqual(self.rt0.get_present_bit(RadioTap.RTF_RTS_RETRIES), False)
self.assertEqual(self.rt0.get_present_bit(RadioTap.RTF_DATA_RETRIES), False)
self.assertEqual(self.rt0.get_present_bit(RadioTap.RTF_XCHANNEL), False)
self.assertEqual(self.rt0.get_present_bit(RadioTap.RTF_EXT), False)
self.assertEqual(self.rt1.get_present_bit(RadioTap.RTF_TSFT), True)
self.assertEqual(self.rt1.get_present_bit(RadioTap.RTF_FLAGS), True)
self.assertEqual(self.rt1.get_present_bit(RadioTap.RTF_RATE), True)
self.assertEqual(self.rt1.get_present_bit(RadioTap.RTF_CHANNEL), False)
self.assertEqual(self.rt1.get_present_bit(RadioTap.RTF_FHSS), False)
self.assertEqual(self.rt1.get_present_bit(RadioTap.RTF_DBM_ANTSIGNAL), True)
self.assertEqual(self.rt1.get_present_bit(RadioTap.RTF_DBM_ANTNOISE), True)
self.assertEqual(self.rt1.get_present_bit(RadioTap.RTF_LOCK_QUALITY), False)
self.assertEqual(self.rt1.get_present_bit(RadioTap.RTF_TX_ATTENUATION), False)
self.assertEqual(self.rt1.get_present_bit(RadioTap.RTF_DB_TX_ATTENUATION), False)
self.assertEqual(self.rt1.get_present_bit(RadioTap.RTF_DBM_TX_POWER), False)
self.assertEqual(self.rt1.get_present_bit(RadioTap.RTF_ANTENNA), True)
self.assertEqual(self.rt1.get_present_bit(RadioTap.RTF_DB_ANTSIGNAL), False)
self.assertEqual(self.rt1.get_present_bit(RadioTap.RTF_DB_ANTNOISE), False)
self.assertEqual(self.rt1.get_present_bit(RadioTap.RTF_FCS_IN_HEADER), False)
self.assertEqual(self.rt1.get_present_bit(RadioTap.RTF_TX_FLAGS), False)
self.assertEqual(self.rt1.get_present_bit(RadioTap.RTF_RTS_RETRIES), False)
self.assertEqual(self.rt1.get_present_bit(RadioTap.RTF_DATA_RETRIES), False)
self.assertEqual(self.rt1.get_present_bit(RadioTap.RTF_XCHANNEL), True)
self.assertEqual(self.rt1.get_present_bit(RadioTap.RTF_EXT), False)
|
'Test RadioTap tstf getter'
| def test_05_tsft(self):
| self.assertEqual(self.rt0.get_tsft(), None)
self.assertEqual(self.rt1.get_tsft(), 622461744)
|
'Test RadioTap tstf getter/setter'
| def test_06_tsft(self):
| self.assertEqual(self.rt0.get_size(), len(self.frame_0))
self.assertEqual(self.rt0.get_header_size(), 24)
self.rt0.set_tsft(72623859790382856)
self.assertEqual(self.rt0.get_tsft(), 72623859790382856)
self.assertEqual(self.rt0.get_header_size(), (24 + 8))
self.rt0.set_tsft(578437695752307201)
self.assertEqual(self.rt0.get_tsft(), 578437695752307201)
self.assertEqual(self.rt0.get_header_size(), (24 + 8))
|
'Test RadioTap unset field'
| def test_07_unset_fields(self):
| self.assertEqual(self.rt0.get_size(), len(self.frame_0))
self.assertEqual(self.rt0.get_header_size(), 24)
self.assertEqual(self.rt0.get_present_bit(RadioTap.RTF_FLAGS), True)
self.rt0.unset_field(RadioTap.RTF_FLAGS)
self.assertEqual(self.rt0.get_size(), (len(self.frame_0) - 1))
self.assertEqual(self.rt0.get_header_size(), (24 - 1))
self.assertEqual(self.rt0.get_present_bit(RadioTap.RTF_FLAGS), False)
self.assertEqual(self.rt1.get_size(), len(self.frame_1))
self.assertEqual(self.rt1.get_header_size(), 32)
self.assertEqual(self.rt1.get_present_bit(RadioTap.RTF_TSFT), True)
self.rt1.unset_field(RadioTap.RTF_TSFT)
self.assertEqual(self.rt1.get_size(), (len(self.frame_1) - 8))
self.assertEqual(self.rt1.get_header_size(), (32 - 8))
self.assertEqual(self.rt1.get_present_bit(RadioTap.RTF_TSFT), False)
|
'Test RadioTap flags getter/setter'
| def test_08_flags_field(self):
| self.assertEqual(self.rt0.get_size(), len(self.frame_0))
self.assertEqual(self.rt0.get_header_size(), 24)
self.assertEqual(self.rt0.get_flags(), 16)
self.rt0.set_flags(171)
self.assertEqual(self.rt0.get_flags(), 171)
self.assertEqual(self.rt0.get_size(), len(self.frame_0))
self.assertEqual(self.rt0.get_header_size(), 24)
self.assertEqual(self.rt1.get_size(), len(self.frame_1))
self.assertEqual(self.rt1.get_header_size(), 32)
self.assertEqual(self.rt1.get_flags(), 34)
self.rt1.set_flags(171)
self.assertEqual(self.rt1.get_flags(), 171)
self.assertEqual(self.rt1.get_size(), len(self.frame_1))
self.assertEqual(self.rt1.get_header_size(), 32)
|
'Test RadioTap rate getter/setter'
| def test_09_rate_field(self):
| self.assertEqual(self.rt0.get_size(), len(self.frame_0))
self.assertEqual(self.rt0.get_header_size(), 24)
self.assertEqual(self.rt0.get_rate(), 108)
self.rt0.set_rate(171)
self.assertEqual(self.rt0.get_rate(), 171)
self.assertEqual(self.rt0.get_size(), len(self.frame_0))
self.assertEqual(self.rt0.get_header_size(), 24)
self.assertEqual(self.rt1.get_size(), len(self.frame_1))
self.assertEqual(self.rt1.get_header_size(), 32)
self.assertEqual(self.rt1.get_rate(), 12)
self.rt1.set_rate(171)
self.assertEqual(self.rt1.get_rate(), 171)
self.assertEqual(self.rt1.get_size(), len(self.frame_1))
self.assertEqual(self.rt1.get_header_size(), 32)
|
'Test RadioTap channel getter/setter'
| def test_10_channel_field(self):
| self.assertEqual(self.rt0.get_size(), len(self.frame_0))
self.assertEqual(self.rt0.get_header_size(), 24)
self.assertEqual(self.rt0.get_channel(), (2412, 1152))
self.rt0.set_channel(freq=1234, flags=22136)
self.assertEqual(self.rt0.get_channel(), (1234, 22136))
self.assertEqual(self.rt0.get_size(), len(self.frame_0))
self.assertEqual(self.rt0.get_header_size(), 24)
self.assertEqual(self.rt1.get_size(), len(self.frame_1))
self.assertEqual(self.rt1.get_header_size(), 32)
self.assertEqual(self.rt1.get_channel(), None)
self.rt1.set_channel(freq=1234, flags=22136)
self.assertEqual(self.rt1.get_channel(), (1234, 22136))
self.assertEqual(self.rt1.get_size(), (len(self.frame_1) + 4))
self.assertEqual(self.rt1.get_header_size(), (32 + 4))
|
'Test RadioTap FHSS getter/setter'
| def test_11_fhss_field(self):
| self.assertEqual(self.rt1.get_size(), len(self.frame_1))
self.assertEqual(self.rt1.get_header_size(), 32)
self.assertEqual(self.rt1.get_FHSS(), None)
self.rt1.set_FHSS(hop_set=171, hop_pattern=205)
self.assertEqual(self.rt1.get_FHSS(), (171, 205))
self.assertEqual(self.rt1.get_size(), (len(self.frame_1) + 2))
self.assertEqual(self.rt1.get_header_size(), (32 + 2))
|
'Test RadioTap dBm Antenna Signal getter/setter'
| def test_12_dbm_ant_signal_field(self):
| self.assertEqual(self.rt1.get_size(), len(self.frame_1))
self.assertEqual(self.rt1.get_header_size(), 32)
self.assertEqual(self.rt1.get_dBm_ant_signal(), 217)
self.rt1.set_dBm_ant_signal(signal=241)
self.assertEqual(self.rt1.get_dBm_ant_signal(), 241)
self.assertEqual(self.rt1.get_size(), len(self.frame_1))
self.assertEqual(self.rt1.get_header_size(), 32)
self.assertEqual(self.rt0.get_size(), len(self.frame_0))
self.assertEqual(self.rt0.get_header_size(), 24)
self.assertEqual(self.rt0.get_dBm_ant_signal(), None)
self.rt0.set_dBm_ant_signal(signal=241)
self.assertEqual(self.rt0.get_dBm_ant_signal(), 241)
self.assertEqual(self.rt0.get_size(), (len(self.frame_0) + 1))
self.assertEqual(self.rt0.get_header_size(), (24 + 1))
|
'Test RadioTap dBm Antenna Noise getter/setter'
| def test_13_dbm_ant_noise_field(self):
| self.assertEqual(self.rt1.get_size(), len(self.frame_1))
self.assertEqual(self.rt1.get_header_size(), 32)
self.assertEqual(self.rt1.get_dBm_ant_noise(), 160)
self.rt1.set_dBm_ant_noise(signal=241)
self.assertEqual(self.rt1.get_dBm_ant_noise(), 241)
self.assertEqual(self.rt1.get_size(), len(self.frame_1))
self.assertEqual(self.rt1.get_header_size(), 32)
self.assertEqual(self.rt0.get_size(), len(self.frame_0))
self.assertEqual(self.rt0.get_header_size(), 24)
self.assertEqual(self.rt0.get_dBm_ant_noise(), None)
self.rt0.set_dBm_ant_noise(signal=241)
self.assertEqual(self.rt0.get_dBm_ant_noise(), 241)
self.assertEqual(self.rt0.get_size(), (len(self.frame_0) + 1))
self.assertEqual(self.rt0.get_header_size(), (24 + 1))
|
'Test RadioTap Lock Quality getter/setter'
| def test_14_lock_quality_field(self):
| self.assertEqual(self.rt1.get_size(), len(self.frame_1))
self.assertEqual(self.rt1.get_header_size(), 32)
self.assertEqual(self.rt1.get_lock_quality(), None)
self.rt1.set_lock_quality(quality=43962)
self.assertEqual(self.rt1.get_lock_quality(), 43962)
self.assertEqual(self.rt1.get_size(), (len(self.frame_1) + 2))
self.assertEqual(self.rt1.get_header_size(), (32 + 2))
|
'Test RadioTap Tx Attenuation getter/setter'
| def test_15_tx_attenuation_field(self):
| self.assertEqual(self.rt1.get_size(), len(self.frame_1))
self.assertEqual(self.rt1.get_header_size(), 32)
self.assertEqual(self.rt1.get_tx_attenuation(), None)
self.rt1.set_tx_attenuation(power=43962)
self.assertEqual(self.rt1.get_tx_attenuation(), 43962)
self.assertEqual(self.rt1.get_size(), (len(self.frame_1) + 2))
self.assertEqual(self.rt1.get_header_size(), (32 + 2))
|
'Test RadioTap dB Tx Attenuation getter/setter'
| def test_16_dB_tx_attenuation_field(self):
| self.assertEqual(self.rt1.get_size(), len(self.frame_1))
self.assertEqual(self.rt1.get_header_size(), 32)
self.assertEqual(self.rt1.get_dB_tx_attenuation(), None)
self.rt1.set_dB_tx_attenuation(power=43962)
self.assertEqual(self.rt1.get_dB_tx_attenuation(), 43962)
self.assertEqual(self.rt1.get_size(), (len(self.frame_1) + 2))
self.assertEqual(self.rt1.get_header_size(), (32 + 2))
|
'Test RadioTap dBm Tx Power getter/setter'
| def test_17_dbm_tx_power_field(self):
| self.assertEqual(self.rt1.get_size(), len(self.frame_1))
self.assertEqual(self.rt1.get_header_size(), 32)
self.assertEqual(self.rt1.get_dBm_tx_power(), None)
self.rt1.set_dBm_tx_power(power=(-8))
self.assertEqual(self.rt1.get_dBm_tx_power(), (-8))
self.assertEqual(self.rt1.get_size(), (len(self.frame_1) + 1))
self.assertEqual(self.rt1.get_header_size(), (32 + 1))
|
'Test RadioTap Antenna getter/setter'
| def test_18_antenna_field(self):
| self.assertEqual(self.rt1.get_size(), len(self.frame_1))
self.assertEqual(self.rt1.get_header_size(), 32)
self.assertEqual(self.rt1.get_antenna(), 2)
self.rt1.set_antenna(antenna_index=241)
self.assertEqual(self.rt1.get_antenna(), 241)
self.assertEqual(self.rt1.get_size(), len(self.frame_1))
self.assertEqual(self.rt1.get_header_size(), 32)
self.assertEqual(self.rt0.get_size(), len(self.frame_0))
self.assertEqual(self.rt0.get_header_size(), 24)
self.assertEqual(self.rt0.get_antenna(), 0)
self.rt0.set_antenna(antenna_index=241)
self.assertEqual(self.rt0.get_antenna(), 241)
self.assertEqual(self.rt0.get_size(), len(self.frame_0))
self.assertEqual(self.rt0.get_header_size(), 24)
|
'Test RadioTap dB Antenna Signal getter/setter'
| def test_19_db_ant_signal_field(self):
| self.assertEqual(self.rt0.get_size(), len(self.frame_0))
self.assertEqual(self.rt0.get_header_size(), 24)
self.assertEqual(self.rt0.get_dB_ant_signal(), 30)
self.rt0.set_dB_ant_signal(signal=241)
self.assertEqual(self.rt0.get_dB_ant_signal(), 241)
self.assertEqual(self.rt0.get_size(), len(self.frame_0))
self.assertEqual(self.rt0.get_header_size(), 24)
self.assertEqual(self.rt1.get_size(), len(self.frame_1))
self.assertEqual(self.rt1.get_header_size(), 32)
self.assertEqual(self.rt1.get_dB_ant_signal(), None)
self.rt1.set_dB_ant_signal(signal=241)
self.assertEqual(self.rt1.get_dB_ant_signal(), 241)
self.assertEqual(self.rt1.get_size(), (len(self.frame_1) + 1))
self.assertEqual(self.rt1.get_header_size(), (32 + 1))
|
'Test RadioTap dB Antenna Noise getter/setter'
| def test_20_db_ant_noise_field(self):
| self.assertEqual(self.rt1.get_size(), len(self.frame_1))
self.assertEqual(self.rt1.get_header_size(), 32)
self.assertEqual(self.rt1.get_dB_ant_noise(), None)
self.rt1.set_dB_ant_noise(signal=241)
self.assertEqual(self.rt1.get_dB_ant_noise(), 241)
self.assertEqual(self.rt1.get_size(), (len(self.frame_1) + 1))
self.assertEqual(self.rt1.get_header_size(), (32 + 1))
self.assertEqual(self.rt0.get_size(), len(self.frame_0))
self.assertEqual(self.rt0.get_header_size(), 24)
self.assertEqual(self.rt0.get_dB_ant_noise(), None)
self.rt0.set_dB_ant_noise(signal=241)
self.assertEqual(self.rt0.get_dB_ant_noise(), 241)
self.assertEqual(self.rt0.get_size(), (len(self.frame_0) + 1))
self.assertEqual(self.rt0.get_header_size(), (24 + 1))
|
'Test RadioTap FCS in header getter/setter'
| def test_22_fcs_in_header_field(self):
| self.assertEqual(self.rt0.get_size(), len(self.frame_0))
self.assertEqual(self.rt0.get_header_size(), 24)
self.assertEqual(self.rt0.get_FCS_in_header(), 0)
self.rt0.set_FCS_in_header(fcs=2309737967)
self.assertEqual(self.rt0.get_FCS_in_header(), 2309737967)
self.assertEqual(self.rt0.get_size(), len(self.frame_0))
self.assertEqual(self.rt0.get_header_size(), 24)
self.assertEqual(self.rt1.get_size(), len(self.frame_1))
self.assertEqual(self.rt1.get_header_size(), 32)
self.assertEqual(self.rt1.get_FCS_in_header(), None)
self.rt1.set_FCS_in_header(fcs=2309737967)
self.assertEqual(self.rt1.get_FCS_in_header(), 2309737967)
self.assertEqual(self.rt1.get_size(), (len(self.frame_1) + 4))
self.assertEqual(self.rt1.get_header_size(), (32 + 4))
|
'Test RadioTap RTS retries getter/setter'
| def test_24_rts_retries_field(self):
| self.assertEqual(self.rt1.get_size(), len(self.frame_1))
self.assertEqual(self.rt1.get_header_size(), 32)
self.assertEqual(self.rt1.get_RTS_retries(), None)
self.rt1.set_RTS_retries(retries=186)
self.assertEqual(self.rt1.get_RTS_retries(), 186)
self.assertEqual(self.rt1.get_size(), (len(self.frame_1) + 1))
self.assertEqual(self.rt1.get_header_size(), (32 + 1))
|
'Test RadioTap TX flags getter/setter'
| def test_25_tx_flags_field(self):
| self.assertEqual(self.rt1.get_size(), len(self.frame_1))
self.assertEqual(self.rt1.get_header_size(), 32)
self.assertEqual(self.rt1.get_tx_flags(), None)
self.rt1.set_tx_flags(flags=43962)
self.assertEqual(self.rt1.get_tx_flags(), 43962)
self.assertEqual(self.rt1.get_size(), (len(self.frame_1) + 2))
self.assertEqual(self.rt1.get_header_size(), (32 + 2))
|
'Test RadioTap xchannel getter/setter'
| def test_26_xchannel_field(self):
| (ch_type, ch_freq, ch_num, ch_maxpower) = self.rt1.get_xchannel()
self.assertEqual(ch_type, 320)
self.assertEqual(ch_freq, 5180)
self.assertEqual(ch_num, 36)
self.assertEqual(ch_maxpower, 17)
(ch_type, ch_freq, ch_num, ch_maxpower) = (305419896, 1234, 12, 34)
self.rt1.set_xchannel(flags=ch_type, freq=ch_freq, channel=ch_num, maxpower=ch_maxpower)
(nch_type, nch_freq, nch_num, nch_maxpower) = self.rt1.get_xchannel()
self.assertEqual(ch_type, nch_type)
self.assertEqual(ch_freq, nch_freq)
self.assertEqual(ch_num, nch_num)
self.assertEqual(ch_maxpower, nch_maxpower)
|
'Test RadioTap Data retries getter/setter'
| def test_27_data_retries_field(self):
| self.assertEqual(self.rt1.get_size(), len(self.frame_1))
self.assertEqual(self.rt1.get_header_size(), 32)
self.assertEqual(self.rt1.get_data_retries(), None)
self.rt1.set_data_retries(retries=171)
self.assertEqual(self.rt1.get_data_retries(), 171)
self.assertEqual(self.rt1.get_size(), (len(self.frame_1) + 1))
self.assertEqual(self.rt1.get_header_size(), (32 + 1))
|
'Test RadioTap header length field'
| def test_29_radiotap_length_field(self):
| rt = RadioTap()
self.assertEqual(rt.get_header_length(), 8)
raw_packet = rt.get_packet()
self.assertEqual(raw_packet, '\x00\x00\x08\x00\x00\x00\x00\x00')
raw_packet = RadioTap().get_packet()
self.assertEqual(raw_packet, '\x00\x00\x08\x00\x00\x00\x00\x00')
|
'Test RadioTap header length field with payload'
| def test_30_radiotap_length_filed_with_payload(self):
| rt = RadioTap()
self.assertEqual(rt.get_header_length(), 8)
data = Data('aa')
rt.contains(data)
self.assertEqual(rt.get_header_length(), 8)
raw_packet = rt.get_packet()
self.assertEqual(raw_packet, '\x00\x00\x08\x00\x00\x00\x00\x00aa')
|
'Test RadioTap extended present flags'
| def test_31_radiotap_present_flags_extended(self):
| self.assertEqual(self.rt2.get_present_bit(RadioTap.RTF_EXT), True)
self.assertEqual(self.rt2.get_present_bit(RadioTap.RTF_RATE), True)
self.assertEqual(self.rt2.get_present_bit(RadioTap.RTF_CHANNEL), True)
self.assertEqual(self.rt2.get_channel(), (2412, 192))
self.assertEqual(self.rt2.get_rate(), 2)
self.assertEqual(self.rt2.get_dBm_ant_signal(), 166)
self.assertEqual(self.rt3.get_present_bit(RadioTap.RTF_EXT), True)
self.assertEqual(self.rt3.get_present_bit(RadioTap.RTF_RATE), True)
self.assertEqual(self.rt3.get_present_bit(RadioTap.RTF_CHANNEL), True)
self.assertEqual(self.rt3.get_channel(), (2412, 192))
self.assertEqual(self.rt3.get_rate(), 2)
self.assertEqual(self.rt3.get_dBm_ant_signal(), 166)
|
'Test Dot11 decoder'
| def test_01_Dot11Decoder(self):
| self.assertEqual(str(self.in0.__class__), 'dot11.Dot11')
|
'Test Dot11DataFrame decoder'
| def test_02_Dot11DataFrameDecoder(self):
| self.assertEqual(str(self.in1.__class__), 'dot11.Dot11DataFrame')
|
'Test Dot11WEP decoder'
| def test_03_Dot11WEP(self):
| self.assertEqual(str(self.in2.__class__), 'dot11.Dot11WEP')
|
'Test Dot11WEPData decoder'
| def test_04_Dot11WEPData(self):
| if (not self.WEPKey):
return
self.assertEqual(str(self.in3.__class__), 'dot11.Dot11WEPData')
wepdata = 'n\xdf\x9369Z9fk\x96\xd1z\xe1\xae\xb6\x11"\xfd\xf0\xd4\rj\xb8\xb1\xe6.\x1f%}d\x1a\x07\xd5\x86\xd2\x194\xb5\xf7\x8ab3Yn\x89\x01sP\x12\xbb\xde\x17'
self.assertEqual(self.in3.get_packet(), wepdata)
|
'Test LLC decoder'
| def test_05_LLC(self):
| if self.WEPKey:
self.assertEqual(str(self.in4.__class__), 'dot11.LLC')
|
'Test LLC Data decoder'
| def test_06_Data(self):
| if self.WEPKey:
dataclass = self.in4.__class__
else:
dataclass = self.in3.__class__
self.assertTrue((str(dataclass).find('ImpactPacket.Data') > 0))
|
'Test RadioTap decoder'
| def test_00(self):
| self.assertEqual(str(self.in0.__class__), 'dot11.RadioTap')
|
'Test Dot11 decoder'
| def test_01(self):
| self.assertEqual(str(self.in1.__class__), 'dot11.Dot11')
|
'Test Dot11DataFrame decoder'
| def test_02(self):
| self.assertEqual(str(self.in2.__class__), 'dot11.Dot11DataFrame')
|
'Test LLC decoder'
| def test_03(self):
| self.assertEqual(str(self.in3.__class__), 'dot11.LLC')
|
'Test SNAP decoder'
| def test_04(self):
| self.assertEqual(str(self.in4.__class__), 'dot11.SNAP')
|
'Test Protocol Finder'
| def test_06(self):
| p = self.radiotap_decoder.get_protocol(dot11.RadioTap)
self.assertEqual(str(p.__class__), 'dot11.RadioTap')
p = self.radiotap_decoder.get_protocol(dot11.Dot11)
self.assertEqual(str(p.__class__), 'dot11.Dot11')
p = self.radiotap_decoder.get_protocol(dot11.Dot11DataFrame)
self.assertEqual(str(p.__class__), 'dot11.Dot11DataFrame')
p = self.radiotap_decoder.get_protocol(dot11.LLC)
self.assertEqual(str(p.__class__), 'dot11.LLC')
p = self.radiotap_decoder.get_protocol(dot11.SNAP)
self.assertEqual(str(p.__class__), 'dot11.SNAP')
p = self.radiotap_decoder.get_protocol(dot11.Dot11WPA)
self.assertEqual(p, None)
|
'Test WEPHeader is_WEP method'
| def test_01(self):
| self.assertEqual(self.wep_header.is_WEP(), True)
|
'Test Packet Hierarchy'
| def test_02(self):
| dot11_decoder = Dot11Decoder()
dot11_decoder.FCS_at_end(False)
dot11_decoder.set_key_manager(self.km)
in0 = dot11_decoder.decode(self.dot11frame)
self.assertEqual(str(in0.__class__), 'dot11.Dot11')
in1 = in0.child()
self.assertEqual(str(in1.__class__), 'dot11.Dot11DataFrame')
in2 = in1.child()
self.assertEqual(str(in2.__class__), 'dot11.Dot11WEP')
in3 = in2.child()
self.assertEqual(str(in3.__class__), 'dot11.Dot11WEPData')
in4 = in3.child()
self.assertEqual(str(in4.__class__), 'dot11.LLC')
in5 = in4.child()
self.assertEqual(str(in5.__class__), 'dot11.SNAP')
in6 = in5.child()
in7 = in6.child()
in8 = in7.child()
self.assertEqual(in8.get_packet(), 'abcdefghijklmnopqrstuvwabcdefghi')
|
'Test WEPHeader IV getter and setter methods'
| def test_03(self):
| self.assertEqual(self.wep_header.get_iv(), 799077)
self.wep_header.set_iv(1967361)
self.assertEqual(self.wep_header.get_iv(), 1967361)
|
'Test WEPHeader keyID getter and setter methods'
| def test_04(self):
| self.assertEqual(self.wep_header.get_keyid(), 0)
self.wep_header.set_iv(3)
self.assertEqual(self.wep_header.get_iv(), 3)
|
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.