Files

1770 lines
70 KiB
Python

# Copyright: (c) 2019, Jordan Borean (@jborean93) <jborean93@gmail.com>
# MIT License (see LICENSE or https://opensource.org/licenses/MIT)
import binascii
import hashlib
import hmac
import logging
import os
import struct
import threading
import time
import typing as t
from collections import OrderedDict
from datetime import datetime
from threading import Lock
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import cmac
from cryptography.hazmat.primitives.ciphers import aead, algorithms
from smbprotocol import MAX_PAYLOAD_SIZE, Dialects
from smbprotocol._text import to_text
from smbprotocol.exceptions import (
SMB2SymbolicLinkErrorResponse,
SMBConnectionClosed,
SMBException,
SMBResponseException,
)
from smbprotocol.header import (
Commands,
NtStatus,
Smb2Flags,
SMB2HeaderAsync,
SMB2HeaderRequest,
SMB2HeaderResponse,
)
from smbprotocol.open import Open
from smbprotocol.structure import (
BytesField,
DateTimeField,
EnumField,
FlagField,
IntField,
ListField,
Structure,
StructureField,
TextField,
UuidField,
)
from smbprotocol.transport import Tcp
log = logging.getLogger(__name__)
class SecurityMode:
"""
[MS-SMB2] v53.0 2017-09-15
2.2.3 SMB2 NEGOTIATE Request SecurityMode
Indicates whether SMB signing is enabled or required by the client.
"""
SMB2_NEGOTIATE_SIGNING_ENABLED = 0x0001
SMB2_NEGOTIATE_SIGNING_REQUIRED = 0x0002
class Capabilities:
"""
[MS-SMB2] v53.0 2017-09-15
2.2.3 SMB2 NEGOTIATE Request Capabilities
Used in SMB3.x and above, used to specify the capabilities supported.
"""
SMB2_GLOBAL_CAP_DFS = 0x00000001
SMB2_GLOBAL_CAP_LEASING = 0x00000002
SMB2_GLOBAL_CAP_LARGE_MTU = 0x00000004
SMB2_GLOBAL_CAP_MULTI_CHANNEL = 0x00000008
SMB2_GLOBAL_CAP_PERSISTENT_HANDLES = 0x00000010
SMB2_GLOBAL_CAP_DIRECTORY_LEASING = 0x00000020
SMB2_GLOBAL_CAP_ENCRYPTION = 0x00000040
class NegotiateContextType:
"""
[MS-SMB2] v53.0 2017-09-15
2.2.3.1 SMB2 NEGOTIATE_CONTENT Request ContextType
Specifies the type of context in an SMB2 NEGOTIATE_CONTEXT message.
"""
SMB2_PREAUTH_INTEGRITY_CAPABILITIES = 0x0001
SMB2_ENCRYPTION_CAPABILITIES = 0x0002
SMB2_COMPRESSION_CAPABILITIES = 0x0003
SMB2_NETNAME_NEGOTIATE_CONTEXT_ID = 0x0005
SMB2_TRANSPORT_CAPABILITIES = 0x0006
SMB2_RDMA_TRANSFORM_CAPABILITIES = 0x0007
SMB2_SIGNING_CAPABILITIES = 0x0008
class HashAlgorithms:
"""
[MS-SMB2] v53.0 2017-09-15
2.2.3.1.1 SMB2_PREAUTH_INTEGRITY_CAPABILITIES
16-bit integer IDs that specify the integrity hash algorithm supported
"""
SHA_512 = 0x0001
class Ciphers:
"""
[MS-SMB2] v53.0 2017-09-15
2.2.3.1.2 SMB2_ENCRYPTION_CAPABILITIES
16-bit integer IDs that specify the supported encryption algorithms.
"""
AES_128_CCM = 0x0001
AES_128_GCM = 0x0002
AES_256_CCM = 0x0003
AES_256_GCM = 0x0004
class SigningAlgorithms:
"""
[MS-SMB2] 2.2.3.1.7 SMB2_SIGNING_CAPABILITIES
https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/cb9b5d66-b6be-4d18-aa66-8784a871cc10
16-bit integer IDs that specify the supported signing algorithms.
"""
HMAC_SHA256 = 0x0000
AES_CMAC = 0x0001
AES_GMAC = 0x0002
class SMB2NegotiateRequest(Structure):
"""
[MS-SMB2] v53.0 2017-09-15
2.2.3 SMB2 Negotiate Request
The SMB2 NEGOTIATE Request packet is used by the client to notify the
server what dialects of the SMB2 Protocol the client understands. This is
only used if the client explicitly sets the Dialect to use to a version
less than 3.1.1. Dialect 3.1.1 added support for negotiate_context and
SMB3NegotiateRequest should be used to support that.
"""
COMMAND = Commands.SMB2_NEGOTIATE
def __init__(self):
self.fields = OrderedDict(
[
(
"structure_size",
IntField(
size=2,
default=36,
),
),
(
"dialect_count",
IntField(
size=2,
default=lambda s: len(s["dialects"].get_value()),
),
),
("security_mode", FlagField(size=2, flag_type=SecurityMode)),
("reserved", IntField(size=2)),
(
"capabilities",
FlagField(
size=4,
flag_type=Capabilities,
),
),
("client_guid", UuidField()),
("client_start_time", IntField(size=8)),
(
"dialects",
ListField(
size=lambda s: s["dialect_count"].get_value() * 2,
list_count=lambda s: s["dialect_count"].get_value(),
list_type=EnumField(size=2, enum_type=Dialects),
),
),
]
)
super().__init__()
class SMB3NegotiateRequest(Structure):
"""
[MS-SMB2] v53.0 2017-09-15
2.2.3 SMB2 Negotiate Request
Like SMB2NegotiateRequest but with support for setting a list of
Negotiate Context values. This is used by default and is for Dialects 3.1.1
or greater.
"""
COMMAND = Commands.SMB2_NEGOTIATE
def __init__(self):
self.fields = OrderedDict(
[
(
"structure_size",
IntField(
size=2,
default=36,
),
),
(
"dialect_count",
IntField(
size=2,
default=lambda s: len(s["dialects"].get_value()),
),
),
(
"security_mode",
FlagField(
size=2,
flag_type=SecurityMode,
),
),
("reserved", IntField(size=2)),
(
"capabilities",
FlagField(
size=4,
flag_type=Capabilities,
),
),
("client_guid", UuidField()),
(
"negotiate_context_offset",
IntField(
size=4,
default=SMB3NegotiateRequest._negotiate_context_offset_value,
),
),
(
"negotiate_context_count",
IntField(
size=2,
default=lambda s: len(s["negotiate_context_list"].get_value()),
),
),
("reserved2", IntField(size=2)),
(
"dialects",
ListField(
size=lambda s: s["dialect_count"].get_value() * 2,
list_count=lambda s: s["dialect_count"].get_value(),
list_type=EnumField(size=2, enum_type=Dialects),
),
),
(
"padding",
BytesField(
size=SMB3NegotiateRequest._padding_size,
default=SMB3NegotiateRequest._default_padding_size,
),
),
(
"negotiate_context_list",
ListField(
list_count=lambda s: s["negotiate_context_count"].get_value(),
unpack_func=SMB3NegotiateRequest._negotiate_context_list,
),
),
]
)
super().__init__()
@staticmethod
def _negotiate_context_offset_value(structure):
# The offset from the beginning of the SMB2 header to the first, 8-byte
# aligned, negotiate context
header_size = 64
negotiate_size = structure["structure_size"].get_value()
dialect_size = len(structure["dialects"])
padding_size = SMB3NegotiateRequest._padding_size(structure)
return header_size + negotiate_size + dialect_size + padding_size
@staticmethod
def _padding_size(structure):
# Padding between the end of the buffer value and the first Negotiate
# context value so that the first value is 8-byte aligned. Padding is
# 4 is there are no dialects specified
mod = (structure["dialect_count"].get_value() * 2) % 8
return 0 if mod == 0 else mod
@staticmethod
def _default_padding_size(structure):
return b"\x00" * SMB3NegotiateRequest._padding_size(structure)
@staticmethod
def _negotiate_context_list(structure, data):
context_count = structure["negotiate_context_count"].get_value()
context_list = []
for idx in range(0, context_count):
field, data = SMB3NegotiateRequest._parse_negotiate_context_entry(data)
context_list.append(field)
return context_list
@staticmethod
def _parse_negotiate_context_entry(data):
data_length = struct.unpack("<H", data[2:4])[0]
negotiate_context = SMB2NegotiateContextRequest()
negotiate_context.unpack(data[: data_length + 8])
padded_size = 8 - (data_length % 8 or 8)
return negotiate_context, data[8 + data_length + padded_size :]
class SMB2NegotiateContextRequest(Structure):
"""
[MS-SMB2] v53.0 2017-09-15
2.2.3.1 SMB2 NEGOTIATE_CONTEXT Request Values
The SMB2_NEGOTIATE_CONTEXT structure is used by the SMB2 NEGOTIATE Request
and the SMB2 NEGOTIATE Response to encode additional properties.
"""
COMMAND = Commands.SMB2_NEGOTIATE
def __init__(self):
self.fields = OrderedDict(
[
(
"context_type",
EnumField(
size=2,
enum_type=NegotiateContextType,
),
),
(
"data_length",
IntField(
size=2,
default=lambda s: len(s["data"].get_value()),
),
),
("reserved", IntField(size=4)),
(
"data",
StructureField(
size=lambda s: s["data_length"].get_value(),
structure_type=SMB2NegotiateContextRequest._data_structure_type,
),
),
# not actually a field but each list entry must start at the 8 byte
# alignment
(
"padding",
BytesField(
size=SMB2NegotiateContextRequest._padding_size,
default=SMB2NegotiateContextRequest._default_padding_size,
),
),
]
)
super().__init__()
@staticmethod
def _data_structure_type(structure):
con_type = structure["context_type"].get_value()
if con_type == NegotiateContextType.SMB2_PREAUTH_INTEGRITY_CAPABILITIES:
return SMB2PreauthIntegrityCapabilities
elif con_type == NegotiateContextType.SMB2_ENCRYPTION_CAPABILITIES:
return SMB2EncryptionCapabilities
elif con_type == NegotiateContextType.SMB2_NETNAME_NEGOTIATE_CONTEXT_ID:
return SMB2NetnameNegotiateContextId
elif con_type == NegotiateContextType.SMB2_SIGNING_CAPABILITIES:
return SMB2SigningCapabilities
@staticmethod
def _padding_size(structure):
data_size = len(structure["data"])
return 8 - (data_size % 8 or 8)
@staticmethod
def _default_padding_size(structure):
return b"\x00" * SMB2NegotiateContextRequest._padding_size(structure)
class SMB2PreauthIntegrityCapabilities(Structure):
"""
[MS-SMB2] v53.0 2017-09-15
2.2.3.1.1 SMB2_PREAUTH_INTEGRITY_CAPABILITIES
The SMB2_PREAUTH_INTEGRITY_CAPABILITIES context is specified in an SMB2
NEGOTIATE request by the client to indicate which preauthentication
integrity hash algorithms it supports and to optionally supply a
preauthentication integrity hash salt value.
"""
def __init__(self):
self.fields = OrderedDict(
[
(
"hash_algorithm_count",
IntField(
size=2,
default=lambda s: len(s["hash_algorithms"].get_value()),
),
),
(
"salt_length",
IntField(
size=2,
default=lambda s: len(s["salt"]),
),
),
(
"hash_algorithms",
ListField(
size=lambda s: s["hash_algorithm_count"].get_value() * 2,
list_count=lambda s: s["hash_algorithm_count"].get_value(),
list_type=EnumField(size=2, enum_type=HashAlgorithms),
),
),
(
"salt",
BytesField(
size=lambda s: s["salt_length"].get_value(),
),
),
]
)
super().__init__()
class SMB2EncryptionCapabilities(Structure):
"""
[MS-SMB2] v53.0 2017-09-15
2.2.3.1.2 SMB2_ENCRYPTION_CAPABILITIES
The SMB2_ENCRYPTION_CAPABILITIES context is specified in an SMB2 NEGOTIATE
request by the client to indicate which encryption algorithms the client
supports.
"""
def __init__(self):
self.fields = OrderedDict(
[
(
"cipher_count",
IntField(
size=2,
default=lambda s: len(s["ciphers"].get_value()),
),
),
(
"ciphers",
ListField(
size=lambda s: s["cipher_count"].get_value() * 2,
list_count=lambda s: s["cipher_count"].get_value(),
list_type=EnumField(size=2, enum_type=Ciphers),
),
),
]
)
super().__init__()
class SMB2NetnameNegotiateContextId(Structure):
"""
[MS-SMB2] 2.2.3.1.4 SMB2_NETNAME_NEGOTIATE_CONTEXT_ID
https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/ca6726bd-b9cf-43d9-b0bc-d127d3c993b3
The SMB2_NETNAME_NEGOTIATE_CONTEXT_ID context is specified in an SMB2
NEGOTIATE request to indicate the server name the client connects to.
"""
def __init__(self):
self.fields = OrderedDict(
[
("net_name", TextField()),
]
)
super().__init__()
class SMB2SigningCapabilities(Structure):
"""
[MS-SMB2] 2.2.3.1.7 SMB2_SIGNING_CAPABILITIES
https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/cb9b5d66-b6be-4d18-aa66-8784a871cc10
The SMB2_SIGNING_CAPABILITIES context is specified in an SMB2 NEGOTIATE
request by the client to indicate which signing algorithms the client supports.
"""
def __init__(self):
self.fields = OrderedDict(
[
(
"signing_algorithm_count",
IntField(
size=2,
default=lambda s: len(s["signing_algorithms"].get_value()),
),
),
(
"signing_algorithms",
ListField(
size=lambda s: s["signing_algorithm_count"].get_value() * 2,
list_count=lambda s: s["signing_algorithm_count"].get_value(),
list_type=EnumField(size=2, enum_type=SigningAlgorithms),
),
),
]
)
super().__init__()
class SMB2NegotiateResponse(Structure):
"""
[MS-SMB2] v53.0 2017-09-15
2.2.4 SMB2 NEGOTIATE Response
The SMB2 NEGOTIATE Response packet is sent by the server to notify the
client of the preferred common dialect.
"""
COMMAND = Commands.SMB2_NEGOTIATE
def __init__(self):
self.fields = OrderedDict(
[
(
"structure_size",
IntField(
size=2,
default=65,
),
),
(
"security_mode",
FlagField(
size=2,
flag_type=SecurityMode,
),
),
(
"dialect_revision",
EnumField(
size=2,
enum_type=Dialects,
),
),
(
"negotiate_context_count",
IntField(
size=2,
default=SMB2NegotiateResponse._negotiate_context_count_value,
),
),
("server_guid", UuidField()),
("capabilities", FlagField(size=4, flag_type=Capabilities)),
("max_transact_size", IntField(size=4)),
("max_read_size", IntField(size=4)),
("max_write_size", IntField(size=4)),
("system_time", DateTimeField()),
("server_start_time", DateTimeField()),
(
"security_buffer_offset",
IntField(
size=2,
default=128, # (header size 64) + (structure size 64)
),
),
(
"security_buffer_length",
IntField(
size=2,
default=lambda s: len(s["buffer"].get_value()),
),
),
(
"negotiate_context_offset",
IntField(
size=4,
default=SMB2NegotiateResponse._negotiate_context_offset_value,
),
),
(
"buffer",
BytesField(
size=lambda s: s["security_buffer_length"].get_value(),
),
),
(
"padding",
BytesField(
size=SMB2NegotiateResponse._padding_size,
default=SMB2NegotiateResponse._default_padding_size,
),
),
(
"negotiate_context_list",
ListField(
list_count=lambda s: s["negotiate_context_count"].get_value(),
unpack_func=SMB2NegotiateResponse._negotiate_context_list,
),
),
]
)
super().__init__()
@staticmethod
def _negotiate_context_count_value(structure):
# If the dialect_revision is SMBv3.1.1, this field specifies the
# number of negotiate contexts in negotiate_context_list; otherwise
# this field must not be used and must be reserved (0).
if structure["dialect_revision"].get_value() == Dialects.SMB_3_1_1:
return len(structure["negotiate_context_list"].get_value())
else:
return None
@staticmethod
def _negotiate_context_offset_value(structure):
# If the dialect_revision is SMBv3.1.1, this field specifies the offset
# from the beginning of the SMB2 header to the first 8-byte
# aligned negotiate context entry in negotiate_context_list; otherwise
# this field must not be used and must be reserved (0).
if structure["dialect_revision"].get_value() == Dialects.SMB_3_1_1:
buffer_offset = structure["security_buffer_offset"].get_value()
buffer_size = structure["security_buffer_length"].get_value()
padding_size = SMB2NegotiateResponse._padding_size(structure)
return buffer_offset + buffer_size + padding_size
else:
return None
@staticmethod
def _padding_size(structure):
# Padding between the end of the buffer value and the first Negotiate
# context value so that the first value is 8-byte aligned. Padding is
# not required if there are not negotiate contexts
if structure["negotiate_context_count"].get_value() == 0:
return 0
mod = structure["security_buffer_length"].get_value() % 8
return 0 if mod == 0 else 8 - mod
@staticmethod
def _default_padding_size(structure):
return b"\x00" * SMB2NegotiateResponse._padding_size(structure)
@staticmethod
def _negotiate_context_list(structure, data):
context_count = structure["negotiate_context_count"].get_value()
context_list = []
for idx in range(0, context_count):
field, data = SMB2NegotiateResponse._parse_negotiate_context_entry(data)
context_list.append(field)
return context_list
@staticmethod
def _parse_negotiate_context_entry(data):
data_length = struct.unpack("<H", data[2:4])[0]
negotiate_context = SMB2NegotiateContextRequest()
negotiate_context.unpack(data[: data_length + 8])
padded_size = data_length % 8
if padded_size != 0:
padded_size = 8 - padded_size
return negotiate_context, data[8 + data_length + padded_size :]
class SMB2Echo(Structure):
"""
[MS-SMB2] v53.0 2017-09-15
2.2.28 SMB2 Echo Request/Response
Request and response for an SMB ECHO message.
"""
COMMAND = Commands.SMB2_ECHO
def __init__(self):
self.fields = OrderedDict([("structure_size", IntField(size=2, default=4)), ("reserved", IntField(size=2))])
super().__init__()
class SMB2CancelRequest(Structure):
"""
[MS-SMB2] 2.2.30 - SMB2 CANCEL Request
https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/91913fc6-4ec9-4a83-961b-370070067e63
The SMB2 CANCEL Request packet is sent by the client to cancel a previously sent message on the same SMB2 transport
connection.
"""
COMMAND = Commands.SMB2_CANCEL
def __init__(self):
self.fields = OrderedDict(
[
(
"structure_size",
IntField(
size=2,
default=4,
),
),
("reserved", IntField(size=2)),
]
)
super().__init__()
class SMB2TransformHeader(Structure):
"""
[MS-SMB2] v53.0 2017-09-15
2.2.41 SMB2 TRANSFORM_HEADER
The SMB2 Transform Header is used by the client or server when sending
encrypted message. This is only valid for the SMB.x dialect family.
"""
def __init__(self):
self.fields = OrderedDict(
[
("protocol_id", BytesField(size=4, default=b"\xfdSMB")),
("signature", BytesField(size=16, default=b"\x00" * 16)),
("nonce", BytesField(size=16)),
("original_message_size", IntField(size=4)),
("reserved", IntField(size=2, default=0)),
("flags", IntField(size=2, default=1)),
("session_id", IntField(size=8)),
("data", BytesField()), # not in spec
]
)
super().__init__()
class Connection:
def __init__(self, guid, server_name, port=445, require_signing=True):
"""
[MS-SMB2] v53.0 2017-09-15
3.2.1.2 Per SMB2 Transport Connection
Used as the transport interface for a server. Some values have been
omitted as they can be retrieved by the Server object stored in
self.server
:param guid: A unique guid that represents the client
:param server_name: The server to start the connection
:param port: The port to use for the transport, default is 445
:param require_signing: Whether signing is required on SMB messages
sent over this connection
"""
log.info(
"Initialising connection, guid: %s, require_signing: %s, server_name: %s, port: %d",
guid,
require_signing,
server_name,
port,
)
self.server_name = server_name
self.port = port
self.transport = None # Instanciated in .connect()
# Experimental customizable value. Might be removed in the future
self._receive_timeout = int(os.environ.get("SMB_EXPERIMENTAL_TRANSPORT_RECEIVE_TIMEOUT", 600))
# Table of Session entries, the order is important for smbclient.
self.session_table = OrderedDict()
# Table of Requests that have yet to be picked up by the application,
# it MAY contain a response from the server as well
self.outstanding_requests = dict()
# Table of available sequence numbers
self.sequence_window = dict(low=0, high=1)
self.sequence_lock = Lock()
# Byte array containing the negotiate token and remembered for
# authentication
self.gss_negotiate_token = None
self.server_guid = None
self.max_transact_size = None
self.max_read_size = None
self.max_write_size = None
self.require_signing = require_signing
# SMB 2.1+
self.dialect = None
self.supports_file_leasing = None
# just go with False as a default for Dialect 2.0.2
self.supports_multi_credit = False
self.client_guid = guid
# SMB 3.x+
self.salt = None
self.supports_directory_leasing = None
self.supports_multi_channel = None
self.supports_persistent_handles = None
self.supports_encryption = None
# used for SMB 3.x for secure negotiate verification on tree connect
self.negotiated_dialects = []
self.client_capabilities = (
Capabilities.SMB2_GLOBAL_CAP_LARGE_MTU
| Capabilities.SMB2_GLOBAL_CAP_ENCRYPTION
| Capabilities.SMB2_GLOBAL_CAP_DFS
)
self.client_security_mode = (
SecurityMode.SMB2_NEGOTIATE_SIGNING_REQUIRED
if require_signing
else SecurityMode.SMB2_NEGOTIATE_SIGNING_ENABLED
)
self.server_security_mode = None
self.server_capabilities = None
# SMB 3.1.1+
# The hashing algorithm object that was negotiated
self.preauth_integrity_hash_id = None
# Preauth integrity hash value computed for the SMB2 NEGOTIATE request
# contains the messages used to compute the hash
self.preauth_integrity_hash_value = []
# Table of raw header bytes for unauthenticated session setup messages,
# indexed by message_id.
self.preauth_integrity_session_hash_value: t.Dict[int, t.List[bytes]] = {}
# The cipher object that was negotiated
self.cipher_id = None
# The signing algorithm that was negotiated
self.signing_algorithm_id = None
# Keep track of the message processing thread's potential traceback that it may raise.
self._t_exc = None
# The thread that will handle message processing.
self._t_worker = None
def connect(self, dialect=None, timeout=60, preferred_encryption_algos=None, preferred_signing_algos=None):
"""
Will connect to the target server and negotiate the capabilities
with the client. Once setup, the client MUST call the disconnect()
function to close the listener thread. This function will populate
various connection properties that denote the capabilities of the
server.
If no preferred encryption or signing algorithms are specified then
all algorithms are offered during negotiation. Older dialects may not
be offered if a custom encryption or signing algorithm list is
specified without the algorithm required by that dialect.
By default the following encryption algorithms are used:
AES_128_GCM
AES_128_CCM (required for SMB 3.0.x)
AES_256_GCM
AES_256_CCM
By default the following signing algorithms are used:
AES_GMAC
AES_CMAC (required for SMB 3.0.x)
HMAC_SHA256 (required for SMB 2.x)
:param dialect: If specified, forces the dialect that is negotiated
with the server, if not set, then the newest dialect supported by
the server is used up to SMB 3.1.1
:param timeout: The timeout in seconds to wait for the initial
negotiation process to complete
:param preferred_encryption_algos: A list of encryption algorithm ids
in priority order from highest to lowest. See :class:`Ciphers` for
a list of known identifiers.
:param preferred_signing_algos: A list of signing algorithm ids in
priority order from highest to lowest.
See :class:`SigningAlgorithms` for a list of known identifiers.
"""
log.info("Setting up transport connection")
self.transport = Tcp(self.server_name, self.port, timeout)
self.transport.connect()
self._t_worker = threading.Thread(
target=self._process_message_thread, name=f"msg_worker-{self.server_name}:{self.port}"
)
self._t_worker.daemon = True
self._t_worker.start()
log.info("Starting negotiation with SMB server")
enc_algos = preferred_encryption_algos or [
Ciphers.AES_128_GCM,
Ciphers.AES_128_CCM,
Ciphers.AES_256_GCM,
Ciphers.AES_256_CCM,
]
sign_algos = preferred_signing_algos or [
SigningAlgorithms.AES_GMAC,
SigningAlgorithms.AES_CMAC,
SigningAlgorithms.HMAC_SHA256,
]
smb_response = self._send_smb2_negotiate(dialect, timeout, enc_algos, sign_algos)
log.info("Negotiated dialect: %s", smb_response["dialect_revision"])
self.dialect = smb_response["dialect_revision"].get_value()
self.max_transact_size = smb_response["max_transact_size"].get_value()
self.max_read_size = smb_response["max_read_size"].get_value()
self.max_write_size = smb_response["max_write_size"].get_value()
self.server_guid = smb_response["server_guid"].get_value()
self.gss_negotiate_token = smb_response["buffer"].get_value()
if not self.require_signing and smb_response["security_mode"].has_flag(
SecurityMode.SMB2_NEGOTIATE_SIGNING_REQUIRED
):
self.require_signing = True
self.client_security_mode = SecurityMode.SMB2_NEGOTIATE_SIGNING_REQUIRED
log.info("Connection require signing: %s", self.require_signing)
capabilities = smb_response["capabilities"]
self.server_capabilities = capabilities
self.server_security_mode = smb_response["security_mode"].get_value()
# SMB 2.1
if self.dialect >= Dialects.SMB_2_1_0:
self.supports_file_leasing = capabilities.has_flag(Capabilities.SMB2_GLOBAL_CAP_LEASING)
self.supports_multi_credit = capabilities.has_flag(Capabilities.SMB2_GLOBAL_CAP_LARGE_MTU)
# SMB 3.x
if self.dialect >= Dialects.SMB_3_0_0:
self.supports_directory_leasing = capabilities.has_flag(Capabilities.SMB2_GLOBAL_CAP_DIRECTORY_LEASING)
self.supports_multi_channel = capabilities.has_flag(Capabilities.SMB2_GLOBAL_CAP_MULTI_CHANNEL)
# TODO: SMB2_GLOBAL_CAP_PERSISTENT_HANDLES
self.supports_persistent_handles = False
self.supports_encryption = (
capabilities.has_flag(Capabilities.SMB2_GLOBAL_CAP_ENCRYPTION) and self.dialect < Dialects.SMB_3_1_1
)
# TODO: Check/add server to server_list in Client Page 203
# SMB 3.1
if self.dialect >= Dialects.SMB_3_1_1:
for context in smb_response["negotiate_context_list"]:
context_type = context["context_type"].get_value()
if context_type == NegotiateContextType.SMB2_ENCRYPTION_CAPABILITIES:
self.cipher_id = context["data"]["ciphers"][0]
self.supports_encryption = self.cipher_id != 0
elif context_type == NegotiateContextType.SMB2_PREAUTH_INTEGRITY_CAPABILITIES:
self.preauth_integrity_hash_id = context["data"]["hash_algorithms"][0]
elif context_type == NegotiateContextType.SMB2_SIGNING_CAPABILITIES:
self.signing_algorithm_id = context["data"]["signing_algorithms"][0]
def disconnect(self, close=True, timeout=None):
"""
Closes the connection as well as logs off any of the
Disconnects the TCP connection and shuts down the socket listener
running in a thread.
:param close: Will close all sessions in the connection as well as the
tree connections of each session.
"""
# We cannot close the session or tree if the socket has been closed.
if close and self.transport.connected:
for session in list(self.session_table.values()):
session.disconnect(True, timeout=timeout)
log.info("Disconnecting transport connection")
self.transport.close()
if self._t_worker and self._t_worker.ident != threading.get_ident():
self._t_worker.join(timeout=2)
def send(
self, message, sid=None, tid=None, credit_request=None, message_id=None, async_id=None, force_signature=False
):
"""
Will send a message to the server that is passed in. The final unencrypted header is returned to the function
that called this.
:param message: An SMB message structure to send.
:param sid: A session_id that the message is sent for.
:param tid: A tree_id object that the message is sent for.
:param credit_request: Specifies extra credits to be requested with the SMB header.
:param message_id: The message_id for the header, only useful for a cancel request.
:param async_id: The async_id for the header, only useful for a cancel request.
:param force_signature: Force signing the SMB request even if not requested by the client/server.
:return: Request of the message that was sent.
"""
return self._send(
[message],
session_id=sid,
tree_id=tid,
message_id=message_id,
credit_request=credit_request,
async_id=async_id,
force_signature=force_signature,
)[0]
def send_compound(self, messages, sid, tid, related=False):
"""
Sends multiple messages within 1 TCP request, will fail if the size of the total length exceeds the maximum of
the transport max.
:param messages: A list of messages to send to the server.
:param sid: The session_id that the request is sent for.
:param tid: A tree_id object that the message is sent for.
:param related: Whether each message is related to each other, sets the Session, Tree, and File Id to the same
value as the first message.
:return: List<Request> for each request that was sent, each entry in the list is in the same order of the
message list that was passed in.
"""
return self._send(messages, session_id=sid, tree_id=tid, related=related)
def receive(self, request, wait=True, timeout=None, resolve_symlinks=True):
"""
Polls the message buffer of the TCP connection and waits until a valid
message is received based on the message_id passed in.
:param request: The Request object to wait get the response for
:param wait: Wait for the final response in the case of a STATUS_PENDING response, the pending response is
returned in the case of wait=False
:param timeout: Set a timeout used while waiting for the final response from the server.
:param resolve_symlinks: Set to automatically resolve symlinks in the path when opening a file or directory.
:return: SMB2HeaderResponse of the received message
"""
# Only the worker thread delivers responses, so calling receive() from it would wait
# on an event only it can set.
worker = self._t_worker
if worker is not None and threading.get_ident() == worker.ident:
raise SMBException("Connection.receive() called from the SMB worker thread, would self-deadlock")
# Make sure the receiver is still active, if not this raises an exception.
self._check_worker_running()
start_time = time.time()
while True:
iter_timeout = int(max(timeout - (time.time() - start_time), 1)) if timeout is not None else None
if not request.response_event.wait(timeout=iter_timeout):
value = request.message["message_id"].get_value()
raise SMBException(
f"Connection timeout of {timeout} seconds exceeded while waiting for a message id {value} "
"response from the server"
)
# Use a lock on the request so that in the case of a pending response we have exclusive lock on the event
# flag and can clear it without the future pending response taking it over before we first clear the flag.
with request.response_event_lock:
self._check_worker_running() # The worker may have failed while waiting for the response, check again
response = request.response
status = response["status"].get_value()
if status == NtStatus.STATUS_PENDING and wait:
# Received a pending message, clear the response_event flag and wait again.
request.response_event.clear()
continue
elif status == NtStatus.STATUS_STOPPED_ON_SYMLINK and resolve_symlinks:
# Received when we do an Open on a path that contains a symlink. Need to capture all related
# requests and resend the Open + others with the redirected path. First we need to resolve the
# symlink path. This will fail if the symlink is pointing to a location that is not in the same
# tree/share as the original request.
# First wait for the other remaining requests to be processed. Their status will also fail and we
# need to make sure we update the old request with the new one properly.
related_requests = [self.outstanding_requests[i] for i in request.related_ids]
[r.response_event.wait() for r in related_requests]
# Check if the response has the reparse buffer present.
exp = SMBResponseException(response)
reparse_buffer = next(
iter(e for e in exp.error_details if isinstance(e, SMB2SymbolicLinkErrorResponse)), None
)
if reparse_buffer is None:
# Some SMB server don't return a buffer, only thing we
# can do is raise the exception.
message_id = request.message["message_id"].get_value()
self.outstanding_requests.pop(message_id, None)
raise exp
# Now create a new request with the new path the symlink points to.
session = self.session_table[request.session_id]
tree = session.tree_connect_table[request.message["tree_id"].get_value()]
old_create = request.get_message_data()
tree_share_name = tree.share_name + "\\"
original_path = tree_share_name + to_text(
old_create["buffer_path"].get_value(), encoding="utf-16-le"
)
new_path = reparse_buffer.resolve_path(original_path)[len(tree_share_name) :]
new_open = Open(tree, new_path)
create_req = new_open.create(
old_create["impersonation_level"].get_value(),
old_create["desired_access"].get_value(),
old_create["file_attributes"].get_value(),
old_create["share_access"].get_value(),
old_create["create_disposition"].get_value(),
old_create["create_options"].get_value(),
create_contexts=old_create["buffer_contexts"].get_value(),
send=False,
)[0]
# Now add all the related requests (if any) to send as a compound request.
new_msgs = [create_req] + [r.get_message_data() for r in related_requests]
new_requests = self.send_compound(new_msgs, session.session_id, tree.tree_connect_id, related=True)
# Verify that the first request was successful before updating the related requests with the new
# info.
error = None
try:
new_response = self.receive(new_requests[0], wait=wait, timeout=timeout, resolve_symlinks=True)
except SMBResponseException as exc:
# We need to make sure we fix up the remaining responses before throwing this.
error = exc
[r.response_event.wait() for r in new_requests]
# Update the old requests with the new response information
for i, old_request in enumerate([request] + related_requests):
del self.outstanding_requests[old_request.message["message_id"].get_value()]
old_request.update_request(new_requests[i])
if error:
raise error
return new_response
else:
# now we have a retrieval request for the response, we can delete
# the request from the outstanding requests
message_id = request.message["message_id"].get_value()
self.outstanding_requests.pop(message_id, None)
if status not in [NtStatus.STATUS_SUCCESS, NtStatus.STATUS_PENDING]:
raise SMBResponseException(response)
break
return response
def echo(self, sid=0, timeout=60, credit_request=1):
"""
Sends an SMB2 Echo request to the server. This can be used to request
more credits from the server with the credit_request param.
On a Samba server, the sid can be 0 but for a Windows SMB Server, the
sid of an authenticated session must be passed into this function or
else the socket will close.
:param sid: When talking to a Windows host this must be populated with
a valid session_id from a negotiated session
:param timeout: The timeout in seconds to wait for the Echo Response
:param credit_request: The number of credits to request
:return: the credits that were granted by the server
"""
log.info("Sending Echo request with a timeout of %d and credit request of %d" % (timeout, credit_request))
echo_msg = SMB2Echo()
log.debug(echo_msg)
req = self.send(echo_msg, sid=sid, credit_request=credit_request)
log.info("Receiving Echo response")
response = self.receive(req, timeout=timeout)
log.info("Credits granted from the server echo response: %d" % response["credit_response"].get_value())
echo_resp = SMB2Echo()
echo_resp.unpack(response["data"].get_value())
log.debug(echo_resp)
return response["credit_response"].get_value()
def verify_signature(self, header, session_id, force=False):
"""
Verifies the SMB2 Header request/response signature.
:param header: The SMB2Header that will have its signature verified against the signing key specified.
:param session_id: The Session Id to denote what session security verifies the message.
:param force: Force verification of the header even if it does not match the criteria required in normal
scenarios.
"""
message_id = header["message_id"].get_value()
flags = header["flags"]
status = header["status"].get_value()
command = header["command"].get_value()
if not force and (
message_id == 0xFFFFFFFFFFFFFFFF
or not flags.has_flag(Smb2Flags.SMB2_FLAGS_SIGNED)
or status == NtStatus.STATUS_PENDING
or command == Commands.SMB2_SESSION_SETUP
):
return
session = self.session_table.get(session_id, None)
if session is None:
raise SMBException(f"Failed to find session {session_id} for message verification")
expected = self._generate_signature(
header.pack(),
session.signing_key,
message_id,
flags.has_flag(Smb2Flags.SMB2_FLAGS_SERVER_TO_REDIR),
command,
)
actual = header["signature"].get_value()
if actual != expected:
actual_signature = binascii.hexlify(actual).decode()
expected_signature = binascii.hexlify(expected).decode()
raise SMBException(
f"Server message signature could not be verified: {actual_signature} != {expected_signature}",
)
def _check_worker_running(self):
"""Checks that the message worker thread is still running and raises it's exception if it has failed."""
if self._t_exc is not None:
self.disconnect(False)
raise self._t_exc
elif not self.transport.connected:
raise SMBConnectionClosed("SMB socket was closed, cannot send or receive any more data")
def _send(
self,
messages,
session_id=None,
tree_id=None,
message_id=None,
credit_request=None,
related=False,
async_id=None,
force_signature=False,
):
send_data = b""
requests = []
session = self.session_table.get(session_id, None)
tree = None
is_dfs = False
if tree_id and session:
if tree_id not in session.tree_connect_table:
raise SMBException("Cannot find Tree with the ID %d in the session tree table" % tree_id)
tree = session.tree_connect_table[tree_id]
is_dfs = tree.is_dfs_share
total_requests = len(messages)
for i, message in enumerate(messages):
if i == total_requests - 1:
next_command = 0
padding = b""
else:
# each compound message must start at the 8-byte boundary
msg_length = 64 + len(message)
mod = msg_length % 8
padding_length = 8 - mod if mod > 0 else 0
next_command = msg_length + padding_length
padding = b"\x00" * padding_length
# When running with multiple threads we need to ensure that getting the message id and adjusting the
# sequence windows is done in a thread safe manner so we use a lock to ensure only 1 thread accesses the
# sequence window at a time.
with self.sequence_lock:
sequence_window_low = self.sequence_window["low"]
sequence_window_high = self.sequence_window["high"]
credit_charge = self._calculate_credit_charge(message)
credits_available = sequence_window_high - sequence_window_low
if credit_charge > credits_available:
raise SMBException(
f"Request requires {credit_charge} credits but only {credits_available} "
"credits are available"
)
current_id = message_id or sequence_window_low
if message.COMMAND != Commands.SMB2_CANCEL:
self.sequence_window["low"] += credit_charge if credit_charge > 0 else 1
if async_id is None:
header = SMB2HeaderRequest()
header["tree_id"] = tree_id or 0
else:
header = SMB2HeaderAsync()
header["flags"].set_flag(Smb2Flags.SMB2_FLAGS_ASYNC_COMMAND)
header["async_id"] = async_id
header["credit_charge"] = credit_charge
header["command"] = message.COMMAND
header["credit_request"] = credit_request if credit_request else credit_charge
header["message_id"] = current_id
header["session_id"] = session_id
header["data"] = message.pack()
header["next_command"] = next_command
if is_dfs:
header["flags"].set_flag(Smb2Flags.SMB2_FLAGS_DFS_OPERATIONS)
if i != 0 and related:
header["flags"].set_flag(Smb2Flags.SMB2_FLAGS_RELATED_OPERATIONS)
if force_signature or (session and session.signing_required and session.signing_key):
header["flags"].set_flag(Smb2Flags.SMB2_FLAGS_SIGNED)
b_header = header.pack() + padding
signature = self._generate_signature(b_header, session.signing_key, current_id, False, message.COMMAND)
# To save on unpacking and re-packing, manually adjust the signature and update the request object for
# back-referencing.
b_header = b_header[:48] + signature + b_header[64:]
header["signature"] = signature
else:
b_header = header.pack() + padding
send_data += b_header
if message.COMMAND == Commands.SMB2_CANCEL:
request = self.outstanding_requests[header["message_id"].get_value()]
else:
request = Request(header, type(message), self, session_id=session_id)
self.outstanding_requests[header["message_id"].get_value()] = request
# Make sure the preauth integrity values are updated for a negotiate or session setup message.
if message.COMMAND == Commands.SMB2_NEGOTIATE:
self.preauth_integrity_hash_value.append(b_header)
elif message.COMMAND == Commands.SMB2_SESSION_SETUP:
self.preauth_integrity_session_hash_value[current_id] = [b_header]
requests.append(request)
if related:
requests[0].related_ids = [r.message["message_id"].get_value() for r in requests][1:]
if session and session.encrypt_data or tree and tree.encrypt_data:
send_data = self._encrypt(send_data, session)
self._check_worker_running()
self.transport.send(send_data)
return requests
def _process_message_thread(self):
try:
while True:
# Wait for a max of 10 minutes before sending an echo that tells the SMB server the client is still
# available. This stops the server from closing the connection and the associated sessions on a long
# lived connection. A brief test shows Windows kills a connection at ~16 minutes so 10 minutes is a
# safe choice.
# https://github.com/jborean93/smbprotocol/issues/31
try:
b_msg = self.transport.recv(self._receive_timeout)
except TimeoutError as ex:
# Check if the connection has unanswered keepalive echo requests with the reserved field set.
# When unanswered keep alive echo exists, the server did not respond withing two times the timeout.
# We assume that the server connection is dead and close it.
for r in self.outstanding_requests.values():
if (
r.response is None
and r.message["command"].get_value() == Commands.SMB2_ECHO
and r.message["reserved"].get_value() == 1
):
# connection will be closed in finally block
raise SMBConnectionClosed(
"Connection timed out. Server did not respond within timeout."
) from ex
log.debug("Sending SMB2 Echo to keep connection alive")
for sid in self.session_table.keys():
req = self.send(SMB2Echo(), sid=sid)
# Set this reserved field to 1 as we use that internally to check whether the outstanding
# requests queue should be cleared in this thread or not.
req.message["reserved"] = 1
continue
# If recv didn't return any data then the socket is considered to be closed.
if not b_msg:
return
is_encrypted = b_msg[:4] == b"\xfdSMB"
if is_encrypted:
msg = SMB2TransformHeader()
msg.unpack(b_msg)
b_msg = self._decrypt(msg)
next_command = -1
while next_command != 0:
next_command = struct.unpack("<L", b_msg[20:24])[0]
header_length = next_command if next_command != 0 else len(b_msg)
b_header = b_msg[:header_length]
b_msg = b_msg[header_length:]
header = SMB2HeaderResponse()
header.unpack(b_header)
message_id = header["message_id"].get_value()
request = self.outstanding_requests[message_id]
# For SMB2 SESSION_SETUP, the client MUST retrieve SessionId
# from SMB2 header of the response. For all other messages,
# the client MUST retrieve SessionId from the corresponding
# Request.Message.
command = header["command"].get_value()
if command == Commands.SMB2_SESSION_SETUP:
session_id = header["session_id"].get_value()
else:
session_id = request.session_id
# No need to waste CPU cycles to verify the signature if we already decrypted the header.
if not is_encrypted:
self.verify_signature(header, session_id)
credit_response = header["credit_response"].get_value()
if credit_response == 0 and not self.supports_multi_credit:
# If the dialect does not support credits we still need to adjust our sequence window.
# Otherwise the credit response may be 0 in the case of compound responses and the last
# response contains the credits that were granted.
credit_response += 1
with self.sequence_lock:
self.sequence_window["high"] += credit_response
status = header["status"].get_value()
if command == Commands.SMB2_NEGOTIATE:
self.preauth_integrity_hash_value.append(b_header)
elif command == Commands.SMB2_SESSION_SETUP and status == NtStatus.STATUS_MORE_PROCESSING_REQUIRED:
self.preauth_integrity_session_hash_value[message_id].append(b_header)
with request.response_event_lock:
if header["flags"].has_flag(Smb2Flags.SMB2_FLAGS_ASYNC_COMMAND):
request.async_id = b_header[32:40]
request.response = header
request.response_event.set()
# When we send a ping in this thread we want to make sure it doesn't linger in the outstanding
# request queue.
if request.message["reserved"].get_value() == 1:
self.outstanding_requests.pop(message_id, None)
except Exception as exc:
log.exception("SMB receive worker died (outstanding=%d)", len(self.outstanding_requests))
# The exception is raised in _check_worker_running by the caller thread when send/receive is called next.
self._t_exc = exc
# While a caller of send/receive could theoretically catch this exception, we consider any failures
# here a fatal errors and the connection should be closed so we exit the worker thread.
self.disconnect(False)
finally:
# Make sure we fire all the request events to ensure the main thread isn't waiting on a receive.
for request in self.outstanding_requests.values():
request.response_event.set()
def _generate_signature(self, b_header, signing_key, message_id, response, command):
b_header = b_header[:48] + (b"\x00" * 16) + b_header[64:]
if self.dialect >= Dialects.SMB_3_1_1 and self.signing_algorithm_id is not None:
sign_id = self.signing_algorithm_id
elif self.dialect >= Dialects.SMB_3_0_0:
sign_id = SigningAlgorithms.AES_CMAC
else:
sign_id = SigningAlgorithms.HMAC_SHA256
if sign_id == SigningAlgorithms.AES_GMAC:
message_info = 0
if response:
message_info |= 1
if command == Commands.SMB2_CANCEL:
message_info |= 2
nonce = b"".join(
[
message_id.to_bytes(8, byteorder="little"),
message_info.to_bytes(4, byteorder="little"),
]
)
signature = aead.AESGCM(signing_key).encrypt(nonce, b"", b_header)
elif sign_id == SigningAlgorithms.AES_CMAC:
c = cmac.CMAC(algorithms.AES(signing_key), backend=default_backend())
c.update(b_header)
signature = c.finalize()
else:
hmac_algo = hmac.new(signing_key, msg=b_header, digestmod=hashlib.sha256)
signature = hmac_algo.digest()[:16]
return signature
def _encrypt(self, b_data, session):
header = SMB2TransformHeader()
header["original_message_size"] = len(b_data)
header["session_id"] = session.session_id
encryption_key = session.encryption_key
if self.dialect >= Dialects.SMB_3_1_1:
cipher_id = self.cipher_id
else:
cipher_id = Ciphers.AES_128_CCM
if cipher_id in [Ciphers.AES_128_GCM, Ciphers.AES_256_GCM]:
cipher = aead.AESGCM
nonce = os.urandom(12)
header["nonce"] = nonce + (b"\x00" * 4)
else:
cipher = aead.AESCCM
nonce = os.urandom(11)
header["nonce"] = nonce + (b"\x00" * 5)
cipher_text = cipher(encryption_key).encrypt(nonce, b_data, header.pack()[20:])
signature = cipher_text[-16:]
enc_message = cipher_text[:-16]
header["signature"] = signature
header["data"] = enc_message
return header
def _decrypt(self, message):
value = message["flags"].get_value()
if value != 0x0001:
error_msg = f"Expecting flag of 0x0001 but got {value:x} in the SMB Transform Header Response"
raise SMBException(error_msg)
session_id = message["session_id"].get_value()
session = self.session_table.get(session_id, None)
if session is None:
raise SMBException(f"Failed to find valid session {session_id} for message decryption")
if self.dialect >= Dialects.SMB_3_1_1:
cipher_id = self.cipher_id
else:
cipher_id = Ciphers.AES_128_CCM
if cipher_id in [Ciphers.AES_128_GCM, Ciphers.AES_256_GCM]:
cipher = aead.AESGCM
nonce_length = 12
else:
cipher = aead.AESCCM
nonce_length = 11
nonce = message["nonce"].get_value()[:nonce_length]
signature = message["signature"].get_value()
enc_message = message["data"].get_value() + signature
c = cipher(session.decryption_key)
dec_message = c.decrypt(nonce, enc_message, message.pack()[20:52])
return dec_message
def _send_smb2_negotiate(self, dialect, timeout, encryption_algorithms, signing_algorithms):
self.salt = os.urandom(32)
if dialect is None:
neg_req = SMB3NegotiateRequest()
negotiated_dialects = [
Dialects.SMB_2_0_2,
Dialects.SMB_2_1_0,
Dialects.SMB_3_0_0,
Dialects.SMB_3_0_2,
Dialects.SMB_3_1_1,
]
if SigningAlgorithms.HMAC_SHA256 not in signing_algorithms:
if Dialects.SMB_2_0_2 in negotiated_dialects:
negotiated_dialects.remove(Dialects.SMB_2_0_2)
if Dialects.SMB_2_1_0 in negotiated_dialects:
negotiated_dialects.remove(Dialects.SMB_2_1_0)
if SigningAlgorithms.AES_CMAC not in signing_algorithms or Ciphers.AES_128_CCM not in encryption_algorithms:
if Dialects.SMB_3_0_0 in negotiated_dialects:
negotiated_dialects.remove(Dialects.SMB_3_0_0)
if Dialects.SMB_3_0_2 in negotiated_dialects:
negotiated_dialects.remove(Dialects.SMB_3_0_2)
else:
if dialect >= Dialects.SMB_3_1_1:
neg_req = SMB3NegotiateRequest()
else:
neg_req = SMB2NegotiateRequest()
negotiated_dialects = [dialect]
highest_dialect = sorted(negotiated_dialects)[-1]
self.negotiated_dialects = neg_req["dialects"] = negotiated_dialects
log.info(
"Negotiating with SMB2 protocol with highest client dialect of: %s",
[dialect for dialect, v in vars(Dialects).items() if v == highest_dialect][0],
)
neg_req["security_mode"] = self.client_security_mode
if highest_dialect >= Dialects.SMB_2_1_0:
log.debug("Adding client guid %s to negotiate request", self.client_guid)
neg_req["client_guid"] = self.client_guid
else:
# Must be None, this value is used to verify the negotiation info.
self.client_guid = None
if highest_dialect >= Dialects.SMB_3_0_0:
log.debug("Adding client capabilities %d to negotiate request", self.client_capabilities)
neg_req["capabilities"] = self.client_capabilities
else:
# Must be 0, this value is used to verify the negotiation info.
self.client_capabilities = 0
if highest_dialect >= Dialects.SMB_3_1_1:
int_cap = SMB2NegotiateContextRequest()
int_cap["context_type"] = NegotiateContextType.SMB2_PREAUTH_INTEGRITY_CAPABILITIES
int_cap["data"] = SMB2PreauthIntegrityCapabilities()
int_cap["data"]["hash_algorithms"] = [HashAlgorithms.SHA_512]
int_cap["data"]["salt"] = self.salt
log.debug(
"Adding preauth integrity capabilities of hash SHA512 and salt %s to negotiate request",
self.salt,
)
enc_cap = SMB2NegotiateContextRequest()
enc_cap["context_type"] = NegotiateContextType.SMB2_ENCRYPTION_CAPABILITIES
enc_cap["data"] = SMB2EncryptionCapabilities()
supported_ciphers = encryption_algorithms
enc_cap["data"]["ciphers"] = supported_ciphers
log.debug("Adding encryption capabilities of AES128|256 GCM and AES128|256 CCM to negotiate request")
netname_id = SMB2NegotiateContextRequest()
netname_id["context_type"] = NegotiateContextType.SMB2_NETNAME_NEGOTIATE_CONTEXT_ID
netname_id["data"] = SMB2NetnameNegotiateContextId()
netname_id["data"]["net_name"] = self.server_name
log.debug(f"Adding netname context id of {self.server_name} to negotiate request")
signing_cap = SMB2NegotiateContextRequest()
signing_cap["context_type"] = NegotiateContextType.SMB2_SIGNING_CAPABILITIES
signing_cap["data"] = SMB2SigningCapabilities()
signing_cap["data"]["signing_algorithms"] = signing_algorithms
log.debug("Adding signing algorithms AES_GMAC, AES_CMAC, and HMAC_SHA256 to negotiate request")
# remove extra padding for last list entry
signing_cap["padding"].size = 0
signing_cap["padding"] = b""
neg_req["negotiate_context_list"] = [
int_cap,
enc_cap,
netname_id,
signing_cap,
]
log.info("Sending SMB2 Negotiate message")
log.debug(neg_req)
request = self.send(neg_req)
response = self.receive(request, timeout=timeout)
log.info("Receiving SMB2 Negotiate response")
log.debug(response)
smb_response = SMB2NegotiateResponse()
smb_response.unpack(response["data"].get_value())
return smb_response
def _calculate_credit_charge(self, message):
"""
Calculates the credit charge for a request based on the command. If
connection.supports_multi_credit is not True then the credit charge
isn't valid so it returns 0.
The credit charge is the number of credits that are required for
sending/receiving data over 64 kilobytes, in the existing messages only
the Read, Write, Query Directory or IOCTL commands will end in this
scenario and each require their own calculation to get the proper
value. The generic formula for calculating the credit charge is
https://msdn.microsoft.com/en-us/library/dn529312.aspx
(max(SendPayloadSize, Expected ResponsePayloadSize) - 1) / 65536 + 1
:param message: The message being sent
:return: The credit charge to set on the header
"""
if (not self.supports_multi_credit) or (message.COMMAND == Commands.SMB2_CANCEL):
return 0
elif message.COMMAND == Commands.SMB2_READ:
payload_size = message["length"].get_value() + message["read_channel_info_length"].get_value()
elif message.COMMAND == Commands.SMB2_WRITE:
payload_size = message["length"].get_value() + message["write_channel_info_length"].get_value()
elif message.COMMAND == Commands.SMB2_IOCTL:
max_in_size = len(message["buffer"])
max_out_size = message["max_output_response"].get_value()
payload_size = max(max_in_size, max_out_size)
elif message.COMMAND == Commands.SMB2_QUERY_DIRECTORY:
max_in_size = len(message["buffer"])
max_out_size = message["output_buffer_length"].get_value()
payload_size = max(max_in_size, max_out_size)
else:
payload_size = 1
credit_charge = (max(0, payload_size - 1) // MAX_PAYLOAD_SIZE) + 1
return credit_charge
class Request:
def __init__(self, message, message_type, connection, session_id=None):
"""
[MS-SMB2] v53.0 2017-09-15
3.2.1.7 Per Pending Request
For each request that was sent to the server and is await a response
:param message: The message to be sent in the request
:param message_type: The type of message that is set in the header's data field.
:param connection: The Connection the request was sent under.
:param session_id: The Session Id the request was for.
"""
self.async_id = None
self.message = message
self.timestamp = datetime.now()
self.cancelled = False
# Used to contain the corresponding response from the server as the receiving in done in a separate thread.
self.response = None
# Used by the recv processing thread to say the response has been received and is ready for consumption.
self.response_event = threading.Event()
# Used to lock the request when the main thread is processing the PENDING result in case the background thread
# receives the final result and fires the event before main clears it.
self.response_event_lock = threading.Lock()
# Stores the message_ids of related messages that are sent in a compound request. This is only set on the 1st
# message in the request. Used when STATUS_STOPPED_ON_SYMLINK is set and we need to send the whole compound
# request again with the new path.
self.related_ids = []
# Cannot rely on the message values as it could be a related compound msg which does not set these values.
self.session_id = session_id
self._connection = connection
self._message_type = message_type # Used to rehydrate the message data in case it's needed again.
def cancel(self):
if self.cancelled is True:
return
message_id = self.message["message_id"].get_value()
log.info("Cancelling message %s", message_id)
self._connection.send(
SMB2CancelRequest(), sid=self.session_id, credit_request=0, message_id=message_id, async_id=self.async_id
)
self.cancelled = True
def get_message_data(self):
message_obj = self._message_type()
message_obj.unpack(self.message["data"].get_value())
return message_obj
def update_request(self, new_request):
self.async_id = new_request.async_id
self.message = new_request.message
self.timestamp = new_request.timestamp
self.response = new_request.response
self.response_event = new_request.response_event
self.response_event_lock = new_request.response_event_lock
self.related_ids = new_request.related_ids