def from_bytes(packet_bytes):
scanner = Scanner(packet_bytes)
# skip fixed header
scanner.skip_bytes(2)
# packet_id
packet_id = scanner.next_bytes(2)
return PubrelPacket(packet_id)
def skip_remaining_length_byte(scanner: Scanner):
next_byte = scanner.next_bytes()
flag = next_byte & 0x80
while True:
if not flag:
return
next_byte = scanner.next_bytes()
flag = next_byte & 0x80
def decode_remaining_length(scanner: Scanner):
first_byte = scanner.next_bytes()
remaining_length = first_byte & 0x7F
flag = first_byte & 0x80
multiplier = 1
while True:
if not flag:
return remaining_length
next_byte = scanner.next_bytes()
flag = next_byte & 0x80
remaining_length += (next_byte & 0x7F) * multiplier
def from_bytes(packet_bytes):
scanner = Scanner(packet_bytes)
scanner.mark()
# 跳过前两个字节的固定头部
scanner.skip_bytes(2)
# 读取 Session Present Flag
sp_value = scanner.skip_bits(7).next_bits(1)
sp = True if sp_value == 1 else 0
# 读取 Connect Return code
return_code = scanner.next_bytes()
return ConnackPacket(sp, return_code)
def from_bytes(packet_bytes):
scanner = Scanner(packet_bytes)
# 跳过固定头部第1个字节
scanner.skip_bytes(1)
# Remaining Length
remaining_length = scanner.next_bytes()
# packet_id
packet_id = scanner.next_bytes(2)
# return code array
return_codes = []
for _ in range(remaining_length - 2):
return_codes.append(scanner.next_bytes())
return SubackPacket(packet_id, return_codes)
def run(self):
'''
Main program.
1) Scans for targets, asks user to select targets
2) Attacks each target
'''
s = Scanner()
if s.target:
# We found the target we want
targets = [s.target]
else:
targets = s.select_targets()
attacked_targets = 0
targets_remaining = len(targets)
for idx, t in enumerate(targets, start=1):
attacked_targets += 1
targets_remaining -= 1
Color.pl(
'\n{+} ({G}%d{W}/{G}%d{W})' % (idx, len(targets)) +
' starting attacks against {C}%s{W} ({C}%s{W})' %
(t.bssid, t.essid if t.essid_known else "{O}ESSID unknown"))
if 'WEP' in t.encryption:
attack = AttackWEP(t)
elif 'WPA' in t.encryption:
if t.wps:
attack = AttackWPS(t)
result = False
try:
result = attack.run()
except Exception as e:
Color.pl("\n{!} {R}Error: {O}%s" % str(e))
if Configuration.verbose > 0 or Configuration.print_stack_traces:
Color.pl('\n{!} {O}Full stack trace below')
from traceback import format_exc
Color.p('\n{!} ')
err = format_exc().strip()
err = err.replace('\n', '\n{!} {C} ')
err = err.replace(' File', '{W}File')
err = err.replace(' Exception: ',
'{R}Exception: {O}')
Color.pl(err)
except KeyboardInterrupt:
Color.pl('\n{!} {O}interrupted{W}\n')
if not self.user_wants_to_continue(
targets_remaining, 1):
break
if result and attack.success:
# We cracked it.
attack.crack_result.save()
continue
else:
# WPS failed, try WPA handshake.
attack = AttackWPA(t)
else:
# Not using WPS, try WPA handshake.
attack = AttackWPA(t)
else:
Color.pl(
"{!} {R}Error: {O}unable to attack: encryption not WEP or WPA"
)
continue
try:
attack.run()
except Exception, e:
Color.pl("\n{!} {R}Error: {O}%s" % str(e))
if Configuration.verbose > 0 or True:
Color.pl('\n{!} {O}Full stack trace below')
from traceback import format_exc
Color.p('\n{!} ')
err = format_exc().strip()
err = err.replace('\n', '\n{!} {C} ')
err = err.replace(' File', '{W}File')
err = err.replace(' Exception: ', '{R}Exception: {O}')
Color.pl(err)
except KeyboardInterrupt:
Color.pl('\n{!} {O}interrupted{W}\n')
if not self.user_wants_to_continue(targets_remaining):
break
def from_bytes(packet_bytes):
scanner = Scanner(packet_bytes)
# skip packet type
scanner.skip_bits(4)
# dup
dup = scanner.next_bits()
# qos
qos = scanner.next_bits(2)
# retain
retain = bool(scanner.next_bits())
# skip Remaining Length
skip_remaining_length_byte(scanner)
# topic name length
topic_length = scanner.next_bytes(2)
# topic name
topic_bytes = bytearray()
for i in range(topic_length):
topic_bytes.append(scanner.next_bytes())
topic = bytes(topic_bytes).decode('utf-8')
# packet id
packet_id = None
if not qos == 0:
packet_id = scanner.next_bytes(2)
payload = scanner.remains_bytes()
return PublishPacket(dup, qos, retain, topic, packet_id, payload)