def _load_from_file(self,source):
self.filename = source
self.wavFile = wavFile = wave_open(self.filename, "rb")
channels = wavFile.getnchannels()
sampleWidth = wavFile.getsampwidth()
samplingRate = wavFile.getframerate()
numSamples = wavFile.getnframes()
compName = wavFile.getcompname()
if (channels not in [1,2]):
msg = "for \"%s\", channels=%d is not supported" \
% (self.filename,channels)
raise UGenError(msg)
if (sampleWidth not in [1,2]):
msg = "for \"%s\", sampleWidth=%d is not supported" \
% (self.filename,sampleWidth)
raise UGenError(msg)
if (samplingRate != UGen.samplingRate):
msg = "for \"%s\", samplingRate=%s does not match %s" \
% (self.filename,samplingRate)
raise UGenError(msg)
if (compName != "not compressed"):
msg = "for \"%s\", compName=\"%s\" is not supported" \
% (self.filename,compName)
raise UGenError(msg)
self.inChannels = 0
self.outChannels = channels
sampleScale = (1<<(8*sampleWidth-1)) - 1
if (sampleWidth == 1): packFormat = "b"
else: packFormat = "h"
if (channels == 2): packFormat = "2%s" % packFormat
self._allocate(numSamples)
if ("Clip" in UGen.debug):
print >>stderr, "Clip.load(%s)" % self
print >>stderr, " channels = %s" % channels
print >>stderr, " numSamples = %s" % numSamples
print >>stderr, " sampleWidth = %s" % sampleWidth
print >>stderr, " sampleScale = %s" % sampleScale
print >>stderr, " packFormat = %s" % packFormat
if (channels == 1):
for ix in xrange(numSamples):
sample = wavFile.readframes(1)
sample = struct_unpack(packFormat,sample)[0]
if (sample < -sampleScale): sample = -sampleScale
self._buffer[ix] = sample / float(sampleScale)
else: # (channels == 2):
for ix in xrange(numSamples):
sample = wavFile.readframes(1)
(sample,sample2) = struct_unpack(packFormat,sample)
if (sample < -sampleScale): sample = -sampleScale
if (sample2 < -sampleScale): sample2 = -sampleScale
self._buffer [ix] = sample / float(sampleScale)
self._buffer2[ix] = sample2 / float(sampleScale)
wavFile.close()
def _read_snappy_java_header(self):
magic = self.fileobj.read(len(SNAPPY_JAVA_MAGIC))
if magic != SNAPPY_JAVA_MAGIC:
raise IOError, 'Not a snappy-java file'
version = struct_unpack("<H", self._read_exact(2))
compatible_version = struct_unpack("<H", self._read_exact(2))
def read_le_bytes(f, n):
s = f.read(n)
if len(s) < n:
raise ValueError("data malformed")
if n == 1:
return ord(s)
elif n == 2:
return struct_unpack("<H", s)[0]
elif n == 3:
return ord(s[0]) | (ord(s[1]) << 8) | (ord(s[2]) << 16)
elif n == 4:
return struct_unpack("<I", s)[0]
else:
raise ValueError("number of bytes must be in range [1..4]")
def intread(buf):
"""Unpacks the given buffer to an integer."""
try:
if isinstance(buf, int):
return buf
length = len(buf)
if length == 1:
return buf[0]
elif length <= 4:
tmp = buf + b"\x00" * (4 - length)
return struct_unpack("<I", tmp)[0]
tmp = buf + b"\x00" * (8 - length)
return struct_unpack("<Q", tmp)[0]
except:
raise
def decode_date(encvalue):
val, = struct_unpack('I', encvalue + b'\x00')
return date(
day=val & 0x1F,
month=(val >> 5) & 0xF,
year=(val >> 9)
)
def _binparse_fixed(self, read):
s = struct_unpack(self._struct_format, read(self.arraysize * 2))[0]
s = s.decode('utf_16_be')
end = s.find('\0')
if end != -1:
return s[:end], False
return s, False
def getAdata(self):
if DNS.LABEL_UTF8:
enc = 'utf8'
else:
enc = DNS.LABEL_ENCODING
x = socket.inet_aton(self.getaddr().decode(enc))
return struct_unpack("!I", x)[0]
def addr2bin(addr):
# Updated from pyspf
"""Convert a string IPv4 address into an unsigned integer.
Examples::
>>> addr2bin('127.0.0.1')
2130706433
>>> addr2bin('127.0.0.1') == socket.INADDR_LOOPBACK
1
>>> addr2bin('255.255.255.254')
4294967294L
>>> addr2bin('192.168.0.1')
3232235521L
Unlike old DNS.addr2bin, the n, n.n, and n.n.n forms for IP addresses
are handled as well::
>>> addr2bin('10.65536')
167837696
>>> 10 * (2 ** 24) + 65536
167837696
>>> addr2bin('10.93.512')
173867520
>>> 10 * (2 ** 24) + 93 * (2 ** 16) + 512
173867520
"""
return struct_unpack("!L", inet_aton(addr))[0]
def decode_time(encvalue):
if len(encvalue) == 6:
val, = struct_unpack('Q', encvalue + b'\x00\x00')
return time(
microsecond=val & 0xFFFFF,
second=(val >> 20) & 0x3F,
minute=(val >> 26) & 0x3F,
hour=(val >> 32)
)
else: # must be 3
val, = struct_unpack('I', encvalue + b'\x00')
return time(
microsecond=0,
second=(val) & 0x3F,
minute=(val >> 6) & 0x3F,
hour=(val >> 12)
)
def ioctl_GWINSZ(fd):
try:
from fcntl import ioctl as fcntl_ioctl
import termios
cr = struct_unpack('hh',
fcntl_ioctl(fd, termios.TIOCGWINSZ, '1234'))
return cr
except:
pass
def parse(self, data):
""" unpacks iwparam"""
size = struct_calcsize(self.fmt)
m, e, i, pad = struct_unpack(self.fmt, data[:size])
# XXX well, its not *the* frequency - we need a better name
if e == 0:
return m
else:
return float(m)*10**e
def __init__(self, data, range):
"""Initialize the scan result with the access point data"""
self.iwstruct = Iwstruct()
self.range = range
self.bssid = "%02X:%02X:%02X:%02X:%02X:%02X" % struct_unpack('BBBBBB', data[2:8])
self.essid = None
self.mode = None
self.rate = []
self.quality = Iwquality()
self.frequency = None
self.encode = None
self.custom = []
self.protocol = None
def __iter__(self):
while 1:
buf = self.__f.read(8)
if len(buf) < 8:
break
blk_type, blk_len = struct_unpack('<II' if self.__le else '>II', buf)
buf += self.__f.read(blk_len - 8)
if blk_type == PCAPNG_BT_EPB:
epb = EnhancedPacketBlockLE(buf) if self.__le else EnhancedPacketBlock(buf)
ts = self._tsoffset + (((epb.ts_high << 32) | epb.ts_low) / self._divisor)
yield (ts, epb.pkt_data)
def _read(self, size=1024*30):
raw_chunk_size = self.fileobj.read(4)
if not raw_chunk_size:
return False
chunk_size = struct_unpack(">L", raw_chunk_size)[0]
chunk = snappy_uncompress(self._read_exact(chunk_size))
self.pos += len(chunk)
if self.extrabuf:
self.extrabuf += chunk
else:
self.extrabuf = chunk
return True
def parse_data(self, fmt, data):
""" unpacks raw C data """
size = struct_calcsize(fmt)
idx = self.idx
str = data[idx:idx + size]
self.idx = idx+size
value = struct_unpack(fmt, str)
# take care of a tuple like (int, )
if len(value) == 1:
return value[0]
else:
return value
def _get_terminal_size_windows():
try:
from ctypes import windll, create_string_buffer
# stdin handle is -10
# stdout handle is -11
# stderr handle is -12
h = windll.kernel32.GetStdHandle(-12)
csbi = create_string_buffer(22)
res = windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
if res:
(bufx, bufy, curx, cury, wattr,
left, top, right, bottom,
maxx, maxy) = struct_unpack("hhhhHhhhhhh", csbi.raw)
sizex = right - left + 1
sizey = bottom - top + 1
return sizex, sizey
except:
pass
def _do_unpack_options(self, buf, oo=None):
self.opts = []
self.data = ''
oo = oo or self.__hdr_len__ - 4 # options offset
ol = self.len - oo - 4 # length
opts_buf = buf[oo:oo + ol]
while opts_buf:
opt = (PcapngOptionLE(opts_buf) if self.__hdr_fmt__[0] == '<'
else PcapngOption(opts_buf))
self.opts.append(opt)
opts_buf = opts_buf[len(opt):]
if opt.code == PCAPNG_OPT_ENDOFOPT:
break
# duplicate total length field
self._len = struct_unpack(self.__hdr_fmt__[0] + 'I', buf[-4:])[0]
if self._len != self.len:
raise dpkt.UnpackError('length fields do not match')
def _read_chunk(self):
size, = struct_unpack(">H", self.wire.read(2))
if size:
return self.wire.read(size)
else:
return b""
def _read_u16be(self):
q = self._offset + 2
n, = struct_unpack(">H", self._data[self._offset:q])
self._offset = q
return n
def __init__(self, fileobj):
self.name = getattr(fileobj, 'name', '<{0}>'.format(fileobj.__class__.__name__))
self.__f = fileobj
shb = SectionHeaderBlock()
buf = self.__f.read(shb.__hdr_len__)
if len(buf) < shb.__hdr_len__:
raise ValueError('invalid pcapng header')
# unpack just the header since endianness is not known
shb.unpack_hdr(buf)
if shb.type != PCAPNG_BT_SHB:
raise ValueError('invalid pcapng header: not a SHB')
# determine the correct byte order and reload full SHB
if shb.bom == BYTE_ORDER_MAGIC_LE:
self.__le = True
buf += self.__f.read(_swap32b(shb.len) - shb.__hdr_len__)
shb = SectionHeaderBlockLE(buf)
elif shb.bom == BYTE_ORDER_MAGIC:
self.__le = False
buf += self.__f.read(shb.len - shb.__hdr_len__)
shb = SectionHeaderBlock(buf)
else:
raise ValueError('unknown endianness')
# check if this version is supported
if shb.v_major != PCAPNG_VERSION_MAJOR:
raise ValueError('unknown pcapng version {0}.{1}'.format(shb.v_major, shb.v_minor,))
# look for a mandatory IDB
idb = None
while 1:
buf = self.__f.read(8)
if len(buf) < 8:
break
blk_type, blk_len = struct_unpack('<II' if self.__le else '>II', buf)
buf += self.__f.read(blk_len - 8)
if blk_type == PCAPNG_BT_IDB:
idb = (InterfaceDescriptionBlockLE(buf) if self.__le
else InterfaceDescriptionBlock(buf))
break
# just skip other blocks
if idb is None:
raise ValueError('IDB not found')
# set timestamp resolution and offset
self._divisor = float(1e6) # defaults
self._tsoffset = 0
for opt in idb.opts:
if opt.code == PCAPNG_OPT_IF_TSRESOL:
# if MSB=0, the remaining bits is a neg power of 10 (e.g. 6 means microsecs)
# if MSB=1, the remaining bits is a neg power of 2 (e.g. 10 means 1/1024 of second)
opt_val = struct_unpack('b', opt.data)[0]
pow_num = 2 if opt_val & 0b10000000 else 10
self._divisor = float(pow_num ** (opt_val & 0b01111111))
elif opt.code == PCAPNG_OPT_IF_TSOFFSET:
# 64-bit int that specifies an offset (in seconds) that must be added to the
# timestamp of each packet
self._tsoffset = struct_unpack('<q' if self.__le else '>q', opt.data)[0]
if idb.linktype in dltoff:
self.dloff = dltoff[idb.linktype]
else:
self.dloff = 0
self.idb = idb
self.snaplen = idb.snaplen
self.filter = ''
self.__iter = iter(self)
def unpack16bit(s):
return struct_unpack('!H', s)[0]
def _swap32b(i):
"""swap endianness of an uint32"""
return struct_unpack('<I', struct_pack('>I', i))[0]
def unpack(self, fmt, packed_data):
""" unpacks data with given format """
return struct_unpack(fmt, packed_data)
def connect(address, ssl_context=None, error_handler=None, **config):
""" Connect and perform a handshake and return a valid Connection object, assuming
a protocol version can be agreed.
"""
# Establish a connection to the host and port specified
# Catches refused connections see:
# https://docs.python.org/2/library/errno.html
log_info("~~ [CONNECT] %s", address)
s = None
try:
if len(address) == 2:
s = socket(AF_INET)
elif len(address) == 4:
s = socket(AF_INET6)
else:
raise ValueError("Unsupported address {!r}".format(address))
t = s.gettimeout()
s.settimeout(
config.get("connection_timeout",
default_config["connection_timeout"]))
s.connect(address)
s.settimeout(t)
s.setsockopt(
SOL_SOCKET, SO_KEEPALIVE,
1 if config.get("keep_alive", default_config["keep_alive"]) else 0)
except SocketTimeout:
if s:
try:
s.close()
except:
pass
raise ServiceUnavailable(
"Timed out trying to establish connection to {!r}".format(address))
except SocketError as error:
if s:
try:
s.close()
except:
pass
if error.errno in (61, 111, 10061):
raise ServiceUnavailable(
"Failed to establish connection to {!r}".format(address))
else:
raise
except ConnectionResetError:
raise ServiceUnavailable(
"Failed to establish connection to {!r}".format(address))
# Secure the connection if an SSL context has been provided
if ssl_context and SSL_AVAILABLE:
host = address[0]
log_info("~~ [SECURE] %s", host)
try:
s = ssl_context.wrap_socket(
s, server_hostname=host if HAS_SNI else None)
except SSLError as cause:
s.close()
error = SecurityError(
"Failed to establish secure connection to {!r}".format(
cause.args[1]))
error.__cause__ = cause
raise error
else:
# Check that the server provides a certificate
der_encoded_server_certificate = s.getpeercert(binary_form=True)
if der_encoded_server_certificate is None:
s.close()
raise ProtocolError(
"When using a secure socket, the server should always "
"provide a certificate")
trust = config.get("trust", default_config["trust"])
if trust == TRUST_ON_FIRST_USE:
from neo4j.bolt.cert import PersonalCertificateStore
store = PersonalCertificateStore()
if not store.match_or_trust(host,
der_encoded_server_certificate):
s.close()
raise ProtocolError(
"Server certificate does not match known certificate "
"for %r; check details in file %r" %
(host, KNOWN_HOSTS))
else:
der_encoded_server_certificate = None
# Send details of the protocol versions supported
supported_versions = [1, 0, 0, 0]
handshake = [MAGIC_PREAMBLE] + supported_versions
log_info("C: [HANDSHAKE] 0x%X %r", MAGIC_PREAMBLE, supported_versions)
data = b"".join(struct_pack(">I", num) for num in handshake)
s.sendall(data)
# Handle the handshake response
ready_to_read, _, _ = select((s, ), (), (), 0)
while not ready_to_read:
ready_to_read, _, _ = select((s, ), (), (), 0)
try:
data = s.recv(4)
except ConnectionResetError:
raise ServiceUnavailable(
"Failed to read any data from server {!r} after connected".format(
address))
data_size = len(data)
if data_size == 0:
# If no data is returned after a successful select
# response, the server has closed the connection
log_error("S: [CLOSE]")
s.close()
raise ProtocolError(
"Connection to %r closed without handshake response" % (address, ))
if data_size != 4:
# Some garbled data has been received
log_error("S: @*#!")
s.close()
raise ProtocolError(
"Expected four byte handshake response, received %r instead" %
data)
agreed_version, = struct_unpack(">I", data)
log_info("S: [HANDSHAKE] %d", agreed_version)
if agreed_version == 0:
log_info("~~ [CLOSE]")
s.shutdown(SHUT_RDWR)
s.close()
elif agreed_version == 1:
connection = Connection(
address,
s,
der_encoded_server_certificate=der_encoded_server_certificate,
error_handler=error_handler,
**config)
connection.init()
return connection
elif agreed_version == 0x48545450:
log_error("S: [CLOSE]")
s.close()
raise ServiceUnavailable("Cannot to connect to Bolt service on {!r} "
"(looks like HTTP)".format(address))
else:
log_error("S: [CLOSE]")
s.close()
raise ProtocolError(
"Unknown Bolt protocol version: {}".format(agreed_version))
def _from_bytes_and_header(cls, data: bytes,
header: Header) -> CloseResponse:
body_data: bytes = data[len(header):]
try:
cls.check_structure_size(
structure_size_to_test=struct_unpack('<H', body_data[:2])[0])
except IncorrectStructureSizeError as e:
raise MalformedCloseResponseError(str(e)) from e
try:
flags = CloseFlag.from_int(struct_unpack('<H', body_data[2:4])[0])
except ValueError as e:
raise InvalidCloseResponseFlagValueError(str(e)) from e
reserved: bytes = body_data[4:8]
if reserved != cls._RESERVED:
raise NonEmptyCloseResponseReservedValueError(
observed_reserved_value=reserved)
creation_time: int = struct_unpack('<Q', body_data[8:16])[0]
last_access_time: int = struct_unpack('<Q', body_data[16:24])[0]
last_write_time: int = struct_unpack('<Q', body_data[24:32])[0]
change_time: int = struct_unpack('<Q', body_data[32:40])[0]
allocation_size: int = struct_unpack('<Q', body_data[40:48])[0]
endof_file: int = struct_unpack('<Q', body_data[48:56])[0]
file_attributes_int_value: int = struct_unpack('<I',
body_data[56:60])[0]
try:
file_attributes = FileAttributes.from_int(
file_attributes_int_value)
except ValueError as e:
raise InvalidCloseResponseFileAttributesValueError(str(e)) from e
if flags.postquery_attrib:
return cls(header=header,
flags=flags,
file_information=FileInformation(
_creation_time=creation_time,
_last_access_time=last_access_time,
_last_write_time=last_write_time,
_change_time=change_time,
allocation_size=allocation_size,
endof_file=endof_file,
file_attributes=file_attributes))
else:
if creation_time != 0:
raise NonEmptyCloseResponseCreationTimeValueError
if last_access_time != 0:
raise NonEmptyCloseResponseLastAccessTimeValueError
if last_write_time != 0:
raise NonEmptyCloseResponseLastWriteTimeValueError
if change_time != 0:
raise NonEmptyCloseResponseChangeTimeValueError
if allocation_size != 0:
raise NonEmptyCloseResponseAllocationSizeValueError
if endof_file != 0:
raise NonEmptyCloseResponseEndofFileValueError
if file_attributes_int_value != 0:
raise NonEmptyCloseResponseFileAttributesValueError
return cls(header=header, flags=flags, file_information=None)
def addr2bin(addr):
return struct_unpack('!l', inet_aton(addr))[0]
def connect(host_port, ssl_context=None, **config):
""" Connect and perform a handshake and return a valid Connection object, assuming
a protocol version can be agreed.
"""
# Establish a connection to the host and port specified
# Catches refused connections see:
# https://docs.python.org/2/library/errno.html
if __debug__: log_info("~~ [CONNECT] %s", host_port)
try:
s = create_connection(host_port)
except SocketError as error:
if error.errno == 111 or error.errno == 61:
raise ProtocolError("Unable to connect to %s on port %d - is the server running?" % host_port)
else:
raise
# Secure the connection if an SSL context has been provided
if ssl_context and SSL_AVAILABLE:
host, port = host_port
if __debug__: log_info("~~ [SECURE] %s", host)
try:
s = ssl_context.wrap_socket(s, server_hostname=host if HAS_SNI else None)
except SSLError as cause:
error = ProtocolError("Cannot establish secure connection; %s" % cause.args[1])
error.__cause__ = cause
raise error
else:
# Check that the server provides a certificate
der_encoded_server_certificate = s.getpeercert(binary_form=True)
if der_encoded_server_certificate is None:
raise ProtocolError("When using a secure socket, the server should always provide a certificate")
trust = config.get("trust", TRUST_DEFAULT)
if trust == TRUST_ON_FIRST_USE:
store = PersonalCertificateStore()
if not store.match_or_trust(host, der_encoded_server_certificate):
raise ProtocolError("Server certificate does not match known certificate for %r; check "
"details in file %r" % (host, KNOWN_HOSTS))
else:
der_encoded_server_certificate = None
# Send details of the protocol versions supported
supported_versions = [1, 0, 0, 0]
handshake = [MAGIC_PREAMBLE] + supported_versions
if __debug__: log_info("C: [HANDSHAKE] 0x%X %r", MAGIC_PREAMBLE, supported_versions)
data = b"".join(struct_pack(">I", num) for num in handshake)
if __debug__: log_debug("C: %s", ":".join(map(hex2, data)))
s.sendall(data)
# Handle the handshake response
ready_to_read, _, _ = select((s,), (), (), 0)
while not ready_to_read:
ready_to_read, _, _ = select((s,), (), (), 0)
data = s.recv(4)
data_size = len(data)
if data_size == 0:
# If no data is returned after a successful select
# response, the server has closed the connection
log_error("S: [CLOSE]")
raise ProtocolError("Server closed connection without responding to handshake")
if data_size == 4:
if __debug__: log_debug("S: %s", ":".join(map(hex2, data)))
else:
# Some other garbled data has been received
log_error("S: @*#!")
raise ProtocolError("Expected four byte handshake response, received %r instead" % data)
agreed_version, = struct_unpack(">I", data)
if __debug__: log_info("S: [HANDSHAKE] %d", agreed_version)
if agreed_version == 0:
if __debug__: log_info("~~ [CLOSE]")
s.shutdown(SHUT_RDWR)
s.close()
elif agreed_version == 1:
return Connection(s, der_encoded_server_certificate=der_encoded_server_certificate, **config)
elif agreed_version == 1213486160:
log_error("S: [CLOSE]")
raise ProtocolError("Server responded HTTP. Make sure you are not trying to connect to the http endpoint " +
"(HTTP defaults to port 7474 whereas BOLT defaults to port 7687)")
else:
log_error("S: [CLOSE]")
raise ProtocolError("Unknown Bolt protocol version: %d", agreed_version)
def connect(address, ssl_context=None, **config):
""" Connect and perform a handshake and return a valid Connection object, assuming
a protocol version can be agreed.
"""
# Establish a connection to the host and port specified
# Catches refused connections see:
# https://docs.python.org/2/library/errno.html
log_info("~~ [CONNECT] %s", address)
try:
s = create_connection(address)
except SocketError as error:
if error.errno in (61, 111, 10061):
raise ServiceUnavailable("Failed to establish connection to %r" %
(address, ))
else:
raise
# Secure the connection if an SSL context has been provided
if ssl_context and SSL_AVAILABLE:
host, port = address
log_info("~~ [SECURE] %s", host)
try:
s = ssl_context.wrap_socket(
s, server_hostname=host if HAS_SNI else None)
except SSLError as cause:
error = ServiceUnavailable("Failed to establish secure "
"connection to %r" % cause.args[1])
error.__cause__ = cause
raise error
else:
from neo4j.v1 import TRUST_DEFAULT, TRUST_ON_FIRST_USE
# Check that the server provides a certificate
der_encoded_server_certificate = s.getpeercert(binary_form=True)
if der_encoded_server_certificate is None:
raise ProtocolError(
"When using a secure socket, the server should always "
"provide a certificate")
trust = config.get("trust", TRUST_DEFAULT)
if trust == TRUST_ON_FIRST_USE:
store = PersonalCertificateStore()
if not store.match_or_trust(host,
der_encoded_server_certificate):
raise ProtocolError(
"Server certificate does not match known certificate "
"for %r; check details in file %r" %
(host, KNOWN_HOSTS))
else:
der_encoded_server_certificate = None
# Send details of the protocol versions supported
supported_versions = [1, 0, 0, 0]
handshake = [MAGIC_PREAMBLE] + supported_versions
log_info("C: [HANDSHAKE] 0x%X %r", MAGIC_PREAMBLE, supported_versions)
data = b"".join(struct_pack(">I", num) for num in handshake)
log_debug("C: b%r", data)
s.sendall(data)
# Handle the handshake response
ready_to_read, _, _ = select((s, ), (), (), 0)
while not ready_to_read:
ready_to_read, _, _ = select((s, ), (), (), 0)
data = s.recv(4)
data_size = len(data)
if data_size == 0:
# If no data is returned after a successful select
# response, the server has closed the connection
log_error("S: [CLOSE]")
raise ProtocolError(
"Connection to %r closed without handshake response" % (address, ))
if data_size == 4:
log_debug("S: b%r", data)
else:
# Some other garbled data has been received
log_error("S: @*#!")
raise ProtocolError(
"Expected four byte handshake response, received %r instead" %
data)
agreed_version, = struct_unpack(">I", data)
log_info("S: [HANDSHAKE] %d", agreed_version)
if agreed_version == 0:
log_info("~~ [CLOSE]")
s.shutdown(SHUT_RDWR)
s.close()
elif agreed_version == 1:
return Connection(
s,
der_encoded_server_certificate=der_encoded_server_certificate,
**config)
elif agreed_version == 0x48545450:
log_error("S: [CLOSE]")
raise ServiceUnavailable("Cannot to connect to Bolt service on %r "
"(looks like HTTP)" % (address, ))
else:
log_error("S: [CLOSE]")
raise ProtocolError("Unknown Bolt protocol version: %d",
agreed_version)
def _handshake(s, resolved_address, der_encoded_server_certificate, **config):
"""
:param s:
:return:
"""
local_port = s.getsockname()[1]
# Send details of the protocol versions supported
supported_versions = [3, 2, 1, 0]
handshake = [MAGIC_PREAMBLE] + supported_versions
log_debug("[#%04X] C: <MAGIC> 0x%08X", local_port, MAGIC_PREAMBLE)
log_debug("[#%04X] C: <HANDSHAKE> 0x%08X 0x%08X 0x%08X 0x%08X",
local_port, *supported_versions)
data = b"".join(struct_pack(">I", num) for num in handshake)
s.sendall(data)
# Handle the handshake response
ready_to_read = False
while not ready_to_read:
ready_to_read, _, _ = select((s, ), (), (), 1)
try:
data = s.recv(4)
except (IOError, OSError): # TODO 2.0: remove IOError alias
raise ServiceUnavailable(
"Failed to read any data from server {!r} after connected".format(
resolved_address))
data_size = len(data)
if data_size == 0:
# If no data is returned after a successful select
# response, the server has closed the connection
log_debug("[#%04X] S: <CLOSE>", local_port)
s.close()
raise ServiceUnavailable(
"Connection to %r closed without handshake response" %
(resolved_address, ))
if data_size != 4:
# Some garbled data has been received
log_debug("[#%04X] S: @*#!", local_port)
s.close()
raise ProtocolError(
"Expected four byte Bolt handshake response from %r, received %r instead; "
"check for incorrect port number" % (resolved_address, data))
agreed_version, = struct_unpack(">I", data)
log_debug("[#%04X] S: <HANDSHAKE> 0x%08X", local_port, agreed_version)
if agreed_version == 0:
log_debug("[#%04X] C: <CLOSE>", local_port)
s.shutdown(SHUT_RDWR)
s.close()
elif agreed_version in (1, 2):
connection = Connection(
agreed_version,
resolved_address,
s,
der_encoded_server_certificate=der_encoded_server_certificate,
**config)
connection.init()
return connection
elif agreed_version in (3, ):
connection = Connection(
agreed_version,
resolved_address,
s,
der_encoded_server_certificate=der_encoded_server_certificate,
**config)
connection.hello()
return connection
elif agreed_version == 0x48545450:
log_debug("[#%04X] S: <CLOSE>", local_port)
s.close()
raise ServiceUnavailable("Cannot to connect to Bolt service on {!r} "
"(looks like HTTP)".format(resolved_address))
else:
log_debug("[#%04X] S: <CLOSE>", local_port)
s.close()
raise ProtocolError(
"Unknown Bolt protocol version: {}".format(agreed_version))
def get16bit(self):
return struct_unpack('!H', self.getbytes(2))[0]
def pop_chunk(self):
chunk_size, = struct_unpack(">H", self.recv_buffer[:2])
print("CHUNK SIZE %r" % chunk_size)
end = 2 + chunk_size
chunk_data, self.recv_buffer = self.recv_buffer[2:end], self.recv_buffer[end:]
return chunk_data
def connect(host, port=None, ssl_context=None, **config):
""" Connect and perform a handshake and return a valid Connection object, assuming
a protocol version can be agreed.
"""
# Establish a connection to the host and port specified
# Catches refused connections see:
# https://docs.python.org/2/library/errno.html
port = port or DEFAULT_PORT
if __debug__: log_info("~~ [CONNECT] %s %d", host, port)
try:
s = create_connection((host, port))
except SocketError as error:
if error.errno == 111 or error.errno == 61 or error.errno == 10061:
raise ProtocolError(
"Unable to connect to %s on port %d - is the server running?" %
(host, port))
else:
raise
# Secure the connection if an SSL context has been provided
if ssl_context and SSL_AVAILABLE:
if __debug__: log_info("~~ [SECURE] %s", host)
try:
s = ssl_context.wrap_socket(
s, server_hostname=host if HAS_SNI else None)
except SSLError as cause:
error = ProtocolError("Cannot establish secure connection; %s" %
cause.args[1])
error.__cause__ = cause
raise error
else:
# Check that the server provides a certificate
der_encoded_server_certificate = s.getpeercert(binary_form=True)
if der_encoded_server_certificate is None:
raise ProtocolError(
"When using a secure socket, the server should always provide a certificate"
)
trust = config.get("trust", TRUST_DEFAULT)
if trust == TRUST_ON_FIRST_USE:
store = PersonalCertificateStore()
if not store.match_or_trust(host,
der_encoded_server_certificate):
raise ProtocolError(
"Server certificate does not match known certificate for %r; check "
"details in file %r" % (host, KNOWN_HOSTS))
else:
der_encoded_server_certificate = None
# Send details of the protocol versions supported
supported_versions = [1, 0, 0, 0]
handshake = [MAGIC_PREAMBLE] + supported_versions
if __debug__:
log_info("C: [HANDSHAKE] 0x%X %r", MAGIC_PREAMBLE, supported_versions)
data = b"".join(struct_pack(">I", num) for num in handshake)
if __debug__: log_debug("C: %s", ":".join(map(hex2, data)))
s.sendall(data)
# Handle the handshake response
ready_to_read, _, _ = select((s, ), (), (), 0)
while not ready_to_read:
ready_to_read, _, _ = select((s, ), (), (), 0)
data = s.recv(4)
data_size = len(data)
if data_size == 0:
# If no data is returned after a successful select
# response, the server has closed the connection
log_error("S: [CLOSE]")
raise ProtocolError(
"Server closed connection without responding to handshake")
if data_size == 4:
if __debug__: log_debug("S: %s", ":".join(map(hex2, data)))
else:
# Some other garbled data has been received
log_error("S: @*#!")
raise ProtocolError(
"Expected four byte handshake response, received %r instead" %
data)
agreed_version, = struct_unpack(">I", data)
if __debug__: log_info("S: [HANDSHAKE] %d", agreed_version)
if agreed_version == 0:
if __debug__: log_info("~~ [CLOSE]")
s.shutdown(SHUT_RDWR)
s.close()
elif agreed_version == 1:
return Connection(
s,
der_encoded_server_certificate=der_encoded_server_certificate,
**config)
elif agreed_version == 1213486160:
log_error("S: [CLOSE]")
raise ProtocolError(
"Server responded HTTP. Make sure you are not trying to connect to the http endpoint "
+
"(HTTP defaults to port 7474 whereas BOLT defaults to port 7687)")
else:
log_error("S: [CLOSE]")
raise ProtocolError("Unknown Bolt protocol version: %d",
agreed_version)
def _read_f64be(self):
q = self._offset + 8
r, = struct_unpack(">d", self._data[self._offset:q])
self._offset = q
return r
def ip_address_to_int(address):
return struct_unpack("!I", inet_aton(address))[0]
[]
"""
iwstruct = Iwstruct()
ifnames = []
buff = array('c', '\0'*1024)
caddr_t, length = buff.buffer_info()
s = iwstruct.pack('iP', length, caddr_t)
try:
result = iwstruct._fcntl(SIOCGIFCONF, s)
except IOError, (i, e):
return i, e
# get the interface names out of the buffer
for i in range(0, 1024, 32):
ifname = buff.tostring()[i:i+32]
ifname = struct_unpack('32s', ifname)[0]
ifname = ifname.split('\0', 1)[0]
if ifname:
# verify if ifnames are really wifi devices
wifi = Wireless(ifname)
result = wifi.getAPaddr()
if result[0] == 0:
ifnames.append(ifname)
return ifnames
def makedict(**kwargs):
return kwargs
class Wireless(object):
def get_domain_cached_credentials(
security_registry: Registry,
cached_credentials_decryption_key: bytes,
use_new_style: bool = True
) -> List[DomainCachedCredentials2]:
iteration_count = 10240
with suppress(RegistryValueNotFoundException):
reg_iteration_count = struct_unpack('<L', security_registry.open(r'Cache').value('NL$IterationCount'))[0]
iteration_count = reg_iteration_count & 0xfffffc00 if reg_iteration_count > 10240 else reg_iteration_count * 1024
registry_cache_entries = (
RegistryCacheEntry.from_bytes(cache_key.raw_data())
for cache_key in security_registry.open('Cache').values()
if cache_key.name() not in {'NL$Control', 'NL$IterationCount'}
)
domain_cached_credentials: List[Union[DomainCachedCredentials, DomainCachedCredentials2]] = list()
for registry_cache_entry in registry_cache_entries:
if registry_cache_entry.initialization_vector == b'\x00' * 16:
continue
# TODO: Make nicer? (and parse flags in class)?
if registry_cache_entry.flags & 1 == 1:
if use_new_style:
decrypted_cached_entry_data = decrypt_aes(
key=cached_credentials_decryption_key,
value=registry_cache_entry.encrypted_data,
initialization_vector=registry_cache_entry.initialization_vector
)
else:
raise NotImplementedError
# TODO: For some reason impacket uses `encrypt()`. Confirm that `decrypt()` is correct.
# decrypted_cached_entry_data = ARC4.new(
# key=HMAC.new(
# key=nlkm_key,
# msg=registry_cache_entry.initialization_vector,
# ).digest()
# ).decrypt(ciphertext=registry_cache_entry.encrypted_data)
else:
# "Plain! Until we figure out what this is, we skip it"
raise NotImplementedError
def calc_padded_length(length: int) -> int:
return length + (length & 0x3) if (length & 0x3) > 0 else length
padded_user_length = calc_padded_length(registry_cache_entry.user_length)
padded_domain_length = calc_padded_length(registry_cache_entry.domain_name_length)
encrypted_hash = decrypted_cached_entry_data[:16]
username = decrypted_cached_entry_data[72:72+registry_cache_entry.user_length].decode(encoding='utf-16le')
dns_domain_name = decrypted_cached_entry_data[
72+padded_user_length+padded_domain_length
:
72+padded_user_length+padded_domain_length+registry_cache_entry.dns_domain_name_length
].decode(encoding='utf-16-le')
if use_new_style:
domain_cached_credentials.append(
DomainCachedCredentials2(
iteration_count=iteration_count,
dns_domain_name=dns_domain_name,
username=username,
encrypted_hash=encrypted_hash
)
)
else:
domain_cached_credentials.append(
DomainCachedCredentials(
dns_domain_name=dns_domain_name,
username=username,
encrypted_hash=encrypted_hash
)
)
return domain_cached_credentials
def _from_bytes_and_header(cls, data: memoryview,
header: Header) -> ReadRequest:
super()._from_bytes_and_header(data=data, header=header)
body_bytes: memoryview = data[len(header):]
read_request_base_args: Dict[str, Any] = dict(
padding=unpack_from('<B', buffer=body_bytes, offset=2)[0],
length=unpack_from('<I', buffer=body_bytes, offset=4)[0],
offset=unpack_from('<Q', buffer=body_bytes, offset=8)[0],
file_id=FileId.from_bytes(data=body_bytes, base_offset=16),
minimum_count=unpack_from('<I', buffer=body_bytes, offset=32)[0],
remaining_bytes=unpack_from('<I', buffer=body_bytes, offset=40)[0])
flags_raw = bytes(body_bytes[3:4])
channel_raw = bytes(body_bytes[36:40])
read_channel_info_offset_raw = bytes(body_bytes[44:46])
read_channel_info_length_raw = bytes(body_bytes[46:48])
if header.DIALECT in {Dialect.SMB_2_0_2, Dialect.SMB_2_1}:
if flags_raw != cls._RESERVED_FLAGS_VALUE:
raise InvalidReadRequestFlagError
if channel_raw != cls._RESERVED_CHANNEL_VALUE:
raise InvalidReadRequestChannelError
if read_channel_info_offset_raw != cls._RESERVED_READ_CHANNEL_OFFSET:
raise InvalidReadRequestReadChannelInfoOffsetError
if read_channel_info_length_raw != cls._RESERVED_READ_CHANNEL_LENGTH:
raise InvalidReadRequestReadChannelLengthError
return cls._DIALECT_TO_CLASS[header.DIALECT](
header=header, **read_request_base_args)
read_channel_info_offset: int = struct_unpack(
'<H', read_channel_info_offset_raw)[0]
read_channel_info_length: int = struct_unpack(
'<H', read_channel_info_length_raw)[0]
read_channel_buffer: bytes = bytes(
data[read_channel_info_offset:read_channel_info_offset +
read_channel_info_length])
channel = ReadRequestChannel(struct_unpack('<I', channel_raw)[0])
if header.DIALECT is Dialect.SMB_3_0:
if flags_raw != cls._RESERVED_FLAGS_VALUE:
raise InvalidReadRequestFlagError
return ReadRequest300(header=header,
**read_request_base_args,
read_channel_buffer=read_channel_buffer,
channel=channel)
try:
flags = ReadRequestFlag.from_int(
unpack_from('<B', buffer=body_bytes, offset=3)[0])
except ValueError as e:
raise InvalidReadRequestFlagError from e
if header.DIALECT in {Dialect.SMB_3_0_2, Dialect.SMB_3_1_1}:
return cls._DIALECT_TO_CLASS[header.DIALECT](
header=header,
**read_request_base_args,
read_channel_buffer=read_channel_buffer,
flags=flags,
channel=channel)
# TODO: Raise proper exception.
raise ValueError
def _parse_length(read):
return struct_unpack(">I", read(4))[0]
def getMAC(self, packed_data):
""" extracts mac addr from packed data and returns it as str """
mac_addr = struct_unpack('xxBBBBBB', packed_data[:8])
return "%02X:%02X:%02X:%02X:%02X:%02X" % mac_addr
def unpack32bit(s):
return struct_unpack('!L', s)[0]
def bin2long6(str):
# Also from pyspf
h, l = struct_unpack("!QQ", str)
return h << 64 | l
def _binparse_fixed(self, read):
s = struct_unpack(self._struct_format, read(self.arraysize))[0]
end = s.find(_zero_byte)
if end != -1:
return s[:end], False
return s, False
def unpack32bit(s):
return struct_unpack('!L', s)[0]
def _read_i8(self):
q = self._offset + 1
z, = struct_unpack(">b", self._data[self._offset:q])
self._offset = q
return z
def _read_u8(self):
q = self._offset + 1
n, = struct_unpack(">B", self._data[self._offset:q])
self._offset = q
return n
def _read_i32be(self):
q = self._offset + 4
z, = struct_unpack(">i", self._data[self._offset:q])
self._offset = q
return z
def _read_u32be(self):
q = self._offset + 4
n, = struct_unpack(">I", self._data[self._offset:q])
self._offset = q
return n
def bin2long6(str):
# Also from pyspf
h, l = struct_unpack("!QQ", str)
return h << 64 | l
def _read_i16be(self):
q = self._offset + 2
z, = struct_unpack(">h", self._data[self._offset:q])
self._offset = q
return z
def _handshake(s, resolved_address, der_encoded_server_certificate,
error_handler, **config):
"""
:param s:
:return:
"""
# Send details of the protocol versions supported
supported_versions = [2, 1, 0, 0]
handshake = [MAGIC_PREAMBLE] + supported_versions
log_debug("C: [HANDSHAKE] 0x%X %r", MAGIC_PREAMBLE, supported_versions)
data = b"".join(struct_pack(">I", num) for num in handshake)
s.sendall(data)
# Handle the handshake response
ready_to_read, _, _ = select((s, ), (), (), 0)
while not ready_to_read:
ready_to_read, _, _ = select((s, ), (), (), 0)
try:
data = s.recv(4)
except ConnectionResetError:
raise ServiceUnavailable(
"Failed to read any data from server {!r} after connected".format(
resolved_address))
data_size = len(data)
if data_size == 0:
# If no data is returned after a successful select
# response, the server has closed the connection
log_error("S: [CLOSE]")
s.close()
raise ProtocolError(
"Connection to %r closed without handshake response" %
(resolved_address, ))
if data_size != 4:
# Some garbled data has been received
log_error("S: @*#!")
s.close()
raise ProtocolError(
"Expected four byte handshake response, received %r instead" %
data)
agreed_version, = struct_unpack(">I", data)
log_debug("S: [HANDSHAKE] %d", agreed_version)
if agreed_version == 0:
log_debug("~~ [CLOSE]")
s.shutdown(SHUT_RDWR)
s.close()
elif agreed_version in (1, 2):
connection = Connection(
resolved_address,
s,
agreed_version,
der_encoded_server_certificate=der_encoded_server_certificate,
error_handler=error_handler,
**config)
connection.init()
return connection
elif agreed_version == 0x48545450:
log_error("S: [CLOSE]")
s.close()
raise ServiceUnavailable("Cannot to connect to Bolt service on {!r} "
"(looks like HTTP)".format(resolved_address))
else:
log_error("S: [CLOSE]")
s.close()
raise ProtocolError(
"Unknown Bolt protocol version: {}".format(agreed_version))
def _read_i64be(self):
q = self._offset + 8
z, = struct_unpack(">q", self._data[self._offset:q])
self._offset = q
return z
def from_bytes(cls, data: bytes) -> PortAny:
length: int = struct_unpack('<H', data[:2])[0]
return cls(port_spec=data[2:2 + length - 1].decode(encoding='ascii'))
def _unpack(self):
marker = self.read_int()
if marker == -1:
raise RuntimeError("Nothing to unpack")
# Tiny Integer
if 0x00 <= marker <= 0x7F:
return marker
elif 0xF0 <= marker <= 0xFF:
return marker - 0x100
# Null
elif marker == 0xC0:
return None
# Float
elif marker == 0xC1:
value, = struct_unpack(">d", self.read(8))
return value
# Boolean
elif marker == 0xC2:
return False
elif marker == 0xC3:
return True
# Integer
elif marker == 0xC8:
return struct_unpack(">b", self.read(1))[0]
elif marker == 0xC9:
return struct_unpack(">h", self.read(2))[0]
elif marker == 0xCA:
return struct_unpack(">i", self.read(4))[0]
elif marker == 0xCB:
return struct_unpack(">q", self.read(8))[0]
# Bytes
elif marker == 0xCC:
size, = struct_unpack(">B", self.read(1))
return self.read(size).tobytes()
elif marker == 0xCD:
size, = struct_unpack(">H", self.read(2))
return self.read(size).tobytes()
elif marker == 0xCE:
size, = struct_unpack(">I", self.read(4))
return self.read(size).tobytes()
else:
marker_high = marker & 0xF0
# String
if marker_high == 0x80: # TINY_STRING
return decode(self.read(marker & 0x0F), "utf-8")
elif marker == 0xD0: # STRING_8:
size, = struct_unpack(">B", self.read(1))
return decode(self.read(size), "utf-8")
elif marker == 0xD1: # STRING_16:
size, = struct_unpack(">H", self.read(2))
return decode(self.read(size), "utf-8")
elif marker == 0xD2: # STRING_32:
size, = struct_unpack(">I", self.read(4))
return decode(self.read(size), "utf-8")
# List
elif 0x90 <= marker <= 0x9F or 0xD4 <= marker <= 0xD7:
return self._unpack_list(marker)
# Map
elif 0xA0 <= marker <= 0xAF or 0xD8 <= marker <= 0xDB:
return self._unpack_map(marker)
# Structure
elif 0xB0 <= marker <= 0xBF or 0xDC <= marker <= 0xDD:
size, tag = self._unpack_structure_header(marker)
value = Structure(tag, *([None] * size))
for i in range(len(value)):
value[i] = self._unpack()
return value
elif marker == 0xDF: # END_OF_STREAM:
return EndOfStream
else:
raise RuntimeError("Unknown PackStream marker %02X" % marker)
def unpack(self):
current_collection = List(INFINITY)
current_capacity = current_collection.capacity
current_size = len(current_collection)
push_item = current_collection.append
collection_stack = []
push_collection = collection_stack.append
pop_collection = collection_stack.pop
stream_read = self.stream.read
while True:
marker_byte = stream_read(1)
if not marker_byte:
break
is_collection = False
try:
value = UNPACKED_MARKERS[
marker_byte] # NULL, TRUE, FALSE and TINY_INT
except KeyError:
marker = UNPACKED_UINT_8[marker_byte]
marker_high = marker & 0xF0
# Float
if marker_byte == FLOAT_64:
value = struct_unpack(DOUBLE_STRUCT, stream_read(8))[0]
# Integer
elif marker_byte == INT_8:
value = UNPACKED_INT_8[stream_read(1)]
elif marker_byte == INT_16:
value = UNPACKED_INT_16[stream_read(2)]
elif marker_byte == INT_32:
value = struct_unpack(INT_32_STRUCT, stream_read(4))[0]
elif marker_byte == INT_64:
value = struct_unpack(INT_64_STRUCT, stream_read(8))[0]
# Bytes
elif marker_byte == BYTES_8:
byte_size = UNPACKED_UINT_8[stream_read(1)]
value = stream_read(byte_size)
elif marker_byte == BYTES_16:
byte_size = UNPACKED_UINT_16[stream_read(2)]
value = stream_read(byte_size)
elif marker_byte == BYTES_32:
byte_size = struct_unpack(UINT_32_STRUCT,
stream_read(4))[0]
value = stream_read(byte_size)
# String
elif marker_high == 0x80:
value = stream_read(marker & 0x0F).decode(ENCODING)
elif marker_byte == STRING_8:
byte_size = UNPACKED_UINT_8[stream_read(1)]
value = stream_read(byte_size).decode(ENCODING)
elif marker_byte == STRING_16:
byte_size = UNPACKED_UINT_16[stream_read(2)]
value = stream_read(byte_size).decode(ENCODING)
elif marker_byte == STRING_32:
byte_size = struct_unpack(UINT_32_STRUCT,
stream_read(4))[0]
value = stream_read(byte_size).decode(ENCODING)
# List
elif marker_high == 0x90:
value = List(marker & 0x0F)
is_collection = True
elif marker_byte == LIST_8:
size = UNPACKED_UINT_8[stream_read(1)]
value = List(size)
is_collection = True
elif marker_byte == LIST_16:
size = UNPACKED_UINT_16[stream_read(2)]
value = List(size)
is_collection = True
elif marker_byte == LIST_32:
size = struct_unpack(UINT_32_STRUCT, stream_read(4))[0]
value = List(size)
is_collection = True
elif marker_byte == LIST_STREAM:
size = INFINITY
value = List(size)
is_collection = True
# Map
elif marker_high == 0xA0:
value = Map(marker & 0x0F)
is_collection = True
elif marker_byte == MAP_8:
size = UNPACKED_UINT_8[stream_read(1)]
value = Map(size)
is_collection = True
elif marker_byte == MAP_16:
size = UNPACKED_UINT_16[stream_read(2)]
value = Map(size)
is_collection = True
elif marker_byte == MAP_32:
size = struct_unpack(UINT_32_STRUCT, stream_read(4))[0]
value = Map(size)
is_collection = True
elif marker_byte == MAP_STREAM:
size = INFINITY
value = Map(size)
is_collection = True
# Structure
elif marker_high == 0xB0:
signature = stream_read(1)
value = Structure(marker & 0x0F, signature)
is_collection = True
elif marker_byte == STRUCT_8:
size, signature = stream_read(2)
value = Structure(UNPACKED_UINT_8[size], signature)
is_collection = True
elif marker_byte == STRUCT_16:
data = stream_read(3)
value = Structure(UNPACKED_UINT_16[data[0:2]], data[2])
is_collection = True
elif marker_byte == END_OF_STREAM:
value = END_OF_STREAM
appended = False
while not appended:
if current_size >= current_capacity:
current_collection = pop_collection()
current_capacity = current_collection.capacity
current_size = len(current_collection)
push_item = current_collection.append
else:
if push_item(value) is not NotImplemented:
current_size += 1
if is_collection:
push_collection(current_collection)
current_collection = value
current_capacity = current_collection.capacity
current_size = len(current_collection)
push_item = current_collection.append
appended = True
if collection_stack:
return iter(collection_stack[0])
else:
return iter(current_collection)
def from_bytes(cls, data: bytes) -> RDeleteServiceResponse:
return cls(
return_code=Win32ErrorCode(struct_unpack('<I', data[:4])[0]))
def _swap32b(i):
"""Swap endianness of an uint32"""
return struct_unpack('<I', struct_pack('>I', i))[0]
def unpack16bit(s):
return struct_unpack('!H', s)[0]
def normalize_ip_subnet(ip, fmt=to_str("!I")):
ip, mask = ip.split("/")
ip = struct_unpack(fmt, inet_aton(ip))[0] & _IP_MASK_CACHES[int(mask)]
return "{}/{}".format(inet_ntoa(struct_pack(fmt, ip)), mask)
def addr2bin(addr):
return struct_unpack('!l', inet_aton(addr))[0]
def __init__(self, fileobj):
self.name = getattr(fileobj, 'name', '<{0}>'.format(fileobj.__class__.__name__))
self.__f = fileobj
shb = SectionHeaderBlock()
buf = self.__f.read(shb.__hdr_len__)
if len(buf) < shb.__hdr_len__:
raise ValueError('invalid pcapng header')
# unpack just the header since endianness is not known
shb.unpack_hdr(buf)
if shb.type != PCAPNG_BT_SHB:
raise ValueError('invalid pcapng header: not a SHB')
# determine the correct byte order and reload full SHB
if shb.bom == BYTE_ORDER_MAGIC_LE:
self.__le = True
buf += self.__f.read(_swap32b(shb.len) - shb.__hdr_len__)
shb = SectionHeaderBlockLE(buf)
elif shb.bom == BYTE_ORDER_MAGIC:
self.__le = False
buf += self.__f.read(shb.len - shb.__hdr_len__)
shb = SectionHeaderBlock(buf)
else:
raise ValueError('unknown endianness')
# check if this version is supported
if shb.v_major != PCAPNG_VERSION_MAJOR:
raise ValueError('unknown pcapng version {0}.{1}'.format(shb.v_major, shb.v_minor,))
# look for a mandatory IDB
idb = None
while 1:
buf = self.__f.read(8)
if len(buf) < 8:
break
blk_type, blk_len = struct_unpack('<II' if self.__le else '>II', buf)
buf += self.__f.read(blk_len - 8)
if blk_type == PCAPNG_BT_IDB:
idb = (InterfaceDescriptionBlockLE(buf) if self.__le
else InterfaceDescriptionBlock(buf))
break
# just skip other blocks
if idb is None:
raise ValueError('IDB not found')
# set timestamp resolution and offset
self._divisor = float(1e6) # defaults
self._tsoffset = 0
for opt in idb.opts:
if opt.code == PCAPNG_OPT_IF_TSRESOL:
# if MSB=0, the remaining bits is a neg power of 10 (e.g. 6 means microsecs)
# if MSB=1, the remaining bits is a neg power of 2 (e.g. 10 means 1/1024 of second)
opt_val = struct_unpack('b', opt.data)[0]
pow_num = 2 if opt_val & 0b10000000 else 10
self._divisor = float(pow_num ** (opt_val & 0b01111111))
elif opt.code == PCAPNG_OPT_IF_TSOFFSET:
# 64-bit int that specifies an offset (in seconds) that must be added to the
# timestamp of each packet
self._tsoffset = struct_unpack('<q' if self.__le else '>q', opt.data)[0]
if idb.linktype in dltoff:
self.dloff = dltoff[idb.linktype]
else:
self.dloff = 0
self.idb = idb
self.snaplen = idb.snaplen
self.filter = ''
self.__iter = iter(self)
