168 lines
6.0 KiB
Python
168 lines
6.0 KiB
Python
|
|
# Copyright: (c) 2019, Jordan Borean (@jborean93) <jborean93@gmail.com>
|
||
|
|
# MIT License (see LICENSE or https://opensource.org/licenses/MIT)
|
||
|
|
|
||
|
|
import errno
|
||
|
|
import logging
|
||
|
|
import select
|
||
|
|
import socket
|
||
|
|
import struct
|
||
|
|
import threading
|
||
|
|
import timeit
|
||
|
|
from collections import OrderedDict
|
||
|
|
|
||
|
|
from smbprotocol.structure import BytesField, IntField, Structure
|
||
|
|
|
||
|
|
log = logging.getLogger(__name__)
|
||
|
|
|
||
|
|
|
||
|
|
class DirectTCPPacket(Structure):
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.1 Transport
|
||
|
|
The Directory TCP transport packet header MUST have the following
|
||
|
|
structure.
|
||
|
|
"""
|
||
|
|
|
||
|
|
def __init__(self):
|
||
|
|
self.fields = OrderedDict(
|
||
|
|
[
|
||
|
|
(
|
||
|
|
"stream_protocol_length",
|
||
|
|
IntField(
|
||
|
|
size=4,
|
||
|
|
little_endian=False,
|
||
|
|
default=lambda s: len(s["smb2_message"]),
|
||
|
|
),
|
||
|
|
),
|
||
|
|
(
|
||
|
|
"smb2_message",
|
||
|
|
BytesField(
|
||
|
|
size=lambda s: s["stream_protocol_length"].get_value(),
|
||
|
|
),
|
||
|
|
),
|
||
|
|
]
|
||
|
|
)
|
||
|
|
super().__init__()
|
||
|
|
|
||
|
|
|
||
|
|
class Tcp:
|
||
|
|
MAX_SIZE = 16777215
|
||
|
|
|
||
|
|
def __init__(self, server, port, timeout=None):
|
||
|
|
self.server = server
|
||
|
|
self.port = port
|
||
|
|
self.timeout = timeout
|
||
|
|
self.connected = False
|
||
|
|
self._sock = None
|
||
|
|
self._sock_lock = threading.Lock()
|
||
|
|
self._close_lock = threading.Lock()
|
||
|
|
|
||
|
|
def connect(self):
|
||
|
|
with self._sock_lock:
|
||
|
|
if not self.connected:
|
||
|
|
log.info("Connecting to DirectTcp socket")
|
||
|
|
try:
|
||
|
|
self._sock = socket.create_connection((self.server, self.port), timeout=self.timeout)
|
||
|
|
except (OSError, socket.gaierror) as err:
|
||
|
|
raise ValueError(f"Failed to connect to '{self.server}:{self.port}': {err}") from err
|
||
|
|
self._sock.settimeout(None) # Make sure the socket is in blocking mode.
|
||
|
|
self.connected = True
|
||
|
|
|
||
|
|
def close(self):
|
||
|
|
with self._sock_lock:
|
||
|
|
if self.connected:
|
||
|
|
log.info("Disconnecting DirectTcp socket")
|
||
|
|
|
||
|
|
# Sending shutdown first will tell the recv thread (for both select and recv) that the socket has data
|
||
|
|
# which returns b'' meaning it was closed.
|
||
|
|
try:
|
||
|
|
self._sock.shutdown(socket.SHUT_RDWR)
|
||
|
|
except OSError as e: # pragma: no cover
|
||
|
|
# Avoid collecting coverage here to avoid CI failing due to race condition differences
|
||
|
|
if e.errno != errno.ENOTCONN:
|
||
|
|
raise
|
||
|
|
|
||
|
|
# This is even more special, we cannot close the socket if we are in the middle of a select or recv().
|
||
|
|
# Doing so causes either a timeout (bad!) or bad fd descriptor (somewhat bad). By shutting down the
|
||
|
|
# socket first then waiting until recv() has exited the critical select/recv section we can ensure we
|
||
|
|
# gracefully handle client side socket closures both here and our recv thread without any extra waits
|
||
|
|
# or exceptions.
|
||
|
|
with self._close_lock:
|
||
|
|
self._sock.close()
|
||
|
|
self.connected = False
|
||
|
|
|
||
|
|
def send(self, header):
|
||
|
|
b_msg = header
|
||
|
|
data_length = len(b_msg)
|
||
|
|
if data_length > self.MAX_SIZE:
|
||
|
|
raise ValueError(
|
||
|
|
f"Data to be sent over Direct TCP size {data_length} exceeds the max length allowed {self.MAX_SIZE}"
|
||
|
|
)
|
||
|
|
|
||
|
|
tcp_packet = DirectTCPPacket()
|
||
|
|
tcp_packet["smb2_message"] = b_msg
|
||
|
|
|
||
|
|
data = tcp_packet.pack()
|
||
|
|
|
||
|
|
with self._sock_lock:
|
||
|
|
while data:
|
||
|
|
sent = self._sock.send(data)
|
||
|
|
data = data[sent:]
|
||
|
|
|
||
|
|
def recv(self, timeout):
|
||
|
|
# We don't need a lock for recv as the receiver is called from 1 thread.
|
||
|
|
b_packet_size, timeout = self._recv(4, timeout)
|
||
|
|
if not b_packet_size:
|
||
|
|
return b""
|
||
|
|
|
||
|
|
packet_size = struct.unpack(">L", b_packet_size)[0]
|
||
|
|
|
||
|
|
return self._recv(packet_size, timeout)[0]
|
||
|
|
|
||
|
|
def _recv(self, length, timeout):
|
||
|
|
buffer = bytearray(length)
|
||
|
|
offset = 0
|
||
|
|
while offset < length:
|
||
|
|
read_len = length - offset
|
||
|
|
log.debug(f"Socket recv({read_len}) (total {length})")
|
||
|
|
|
||
|
|
start_time = timeit.default_timer()
|
||
|
|
|
||
|
|
with self._close_lock:
|
||
|
|
if not self.connected:
|
||
|
|
# The socket was closed - need the no cover to avoid CI failing on race condition differences
|
||
|
|
return None, timeout # pragma: no cover
|
||
|
|
|
||
|
|
read = select.select([self._sock], [], [], max(timeout, 1))[0]
|
||
|
|
elapsed = timeit.default_timer() - start_time
|
||
|
|
timeout = timeout - elapsed
|
||
|
|
if not read:
|
||
|
|
raise TimeoutError(f"recv idle for {elapsed:.1f}s ({offset}/{length} bytes)")
|
||
|
|
|
||
|
|
try:
|
||
|
|
b_data = self._sock.recv(read_len)
|
||
|
|
except OSError as e:
|
||
|
|
# Windows will raise this error if the socket has been shutdown, Linux return returns an empty byte
|
||
|
|
# string so we just replicate that.
|
||
|
|
if e.errno not in [errno.ESHUTDOWN, errno.ECONNRESET, errno.ECONNABORTED]:
|
||
|
|
# Avoid collecting coverage here to avoid CI failing due to race condition differences
|
||
|
|
raise # pragma: no cover
|
||
|
|
log.warning(
|
||
|
|
"socket aborted by peer (%s), treating as EOF",
|
||
|
|
errno.errorcode.get(e.errno, e.errno),
|
||
|
|
)
|
||
|
|
b_data = b""
|
||
|
|
|
||
|
|
read_len = len(b_data)
|
||
|
|
log.debug(f"Socket recv() returned {read_len} bytes (total {length})")
|
||
|
|
|
||
|
|
if read_len == 0:
|
||
|
|
self.close()
|
||
|
|
return None, timeout # The socket has been shutdown
|
||
|
|
|
||
|
|
buffer[offset : offset + read_len] = b_data
|
||
|
|
offset += read_len
|
||
|
|
|
||
|
|
return bytes(buffer), timeout
|