464 lines
17 KiB
Python
464 lines
17 KiB
Python
# Copyright: (c) 2019, Jordan Borean (@jborean93) <jborean93@gmail.com>
|
|
# MIT License (see LICENSE or https://opensource.org/licenses/MIT)
|
|
|
|
import hashlib
|
|
import logging
|
|
from collections import OrderedDict
|
|
from typing import Literal, Optional
|
|
|
|
import spnego
|
|
from cryptography.hazmat.backends import default_backend
|
|
from cryptography.hazmat.primitives import hashes
|
|
from cryptography.hazmat.primitives.kdf.kbkdf import KBKDFHMAC, CounterLocation, Mode
|
|
|
|
from smbprotocol import Dialects
|
|
from smbprotocol.connection import Capabilities, Ciphers, SecurityMode
|
|
from smbprotocol.exceptions import (
|
|
MoreProcessingRequired,
|
|
SMBAuthenticationError,
|
|
SMBException,
|
|
)
|
|
from smbprotocol.header import Commands, NtStatus
|
|
from smbprotocol.structure import BytesField, EnumField, FlagField, IntField, Structure
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
|
|
class SessionFlags:
|
|
"""
|
|
[MS-SMB2] v53.0 2017-09-15
|
|
|
|
2.2.6 SMB2 SESSION_SETUP Response Flags
|
|
Flags the indicates additional information about the session.
|
|
"""
|
|
|
|
SMB2_SESSION_FLAG_IS_GUEST = 0x0001
|
|
SMB2_SESSION_FLAG_IS_NULL = 0x0002
|
|
SMB2_SESSION_FLAG_ENCRYPT_DATA = 0x0004
|
|
|
|
|
|
class SMB2SessionSetupRequest(Structure):
|
|
"""
|
|
[MS-SMB2] v53.0 2017-09-15
|
|
|
|
2.2.5 SMB2 SESSION_SETUP Request
|
|
The SMB2 SESSION_SETUP Request packet is sent by the client to request a
|
|
new authenticated session within a new or existing SMB 2 connection.
|
|
"""
|
|
|
|
COMMAND = Commands.SMB2_SESSION_SETUP
|
|
|
|
def __init__(self):
|
|
self.fields = OrderedDict(
|
|
[
|
|
(
|
|
"structure_size",
|
|
IntField(
|
|
size=2,
|
|
default=25,
|
|
),
|
|
),
|
|
("flags", IntField(size=1)),
|
|
(
|
|
"security_mode",
|
|
EnumField(
|
|
size=1,
|
|
enum_type=SecurityMode,
|
|
),
|
|
),
|
|
(
|
|
"capabilities",
|
|
FlagField(
|
|
size=4,
|
|
flag_type=Capabilities,
|
|
),
|
|
),
|
|
("channel", IntField(size=4)),
|
|
(
|
|
"security_buffer_offset",
|
|
IntField(
|
|
size=2,
|
|
default=88, # (header size 64) + (response size 24)
|
|
),
|
|
),
|
|
(
|
|
"security_buffer_length",
|
|
IntField(
|
|
size=2,
|
|
default=lambda s: len(s["buffer"]),
|
|
),
|
|
),
|
|
("previous_session_id", IntField(size=8)),
|
|
(
|
|
"buffer",
|
|
BytesField(
|
|
size=lambda s: s["security_buffer_length"].get_value(),
|
|
),
|
|
),
|
|
]
|
|
)
|
|
super().__init__()
|
|
|
|
|
|
class SMB2SessionSetupResponse(Structure):
|
|
"""
|
|
[MS-SMB2] v53.0 2017-09-15
|
|
|
|
2.2.6 SMB2 SESSION_SETUP Response
|
|
The SMB2 SESSION_SETUP Response packet is sent by the server in response to
|
|
an SMB2 SESSION_SETUP Request.
|
|
"""
|
|
|
|
COMMAND = Commands.SMB2_SESSION_SETUP
|
|
|
|
def __init__(self):
|
|
self.fields = OrderedDict(
|
|
[
|
|
(
|
|
"structure_size",
|
|
IntField(
|
|
size=2,
|
|
default=9,
|
|
),
|
|
),
|
|
(
|
|
"session_flags",
|
|
FlagField(
|
|
size=2,
|
|
flag_type=SessionFlags,
|
|
),
|
|
),
|
|
(
|
|
"security_buffer_offset",
|
|
IntField(
|
|
size=2,
|
|
default=72, # (header size 64) + (response size 8)
|
|
),
|
|
),
|
|
(
|
|
"security_buffer_length",
|
|
IntField(
|
|
size=2,
|
|
default=lambda s: len(s["buffer"]),
|
|
),
|
|
),
|
|
(
|
|
"buffer",
|
|
BytesField(
|
|
size=lambda s: s["security_buffer_length"].get_value(),
|
|
),
|
|
),
|
|
]
|
|
)
|
|
super().__init__()
|
|
|
|
|
|
class SMB2Logoff(Structure):
|
|
"""
|
|
[MS-SMB2] v53.0 2017-09-15
|
|
|
|
2.2.7/8 SMB2 LOGOFF Request/Response
|
|
Request and response to request the termination of a particular session as
|
|
specified by the header.
|
|
"""
|
|
|
|
COMMAND = Commands.SMB2_LOGOFF
|
|
|
|
def __init__(self):
|
|
self.fields = OrderedDict([("structure_size", IntField(size=2, default=4)), ("reserved", IntField(size=2))])
|
|
super().__init__()
|
|
|
|
|
|
class Session:
|
|
def __init__(
|
|
self,
|
|
connection,
|
|
username: Optional[str] = None,
|
|
password: Optional[str] = None,
|
|
require_encryption=True,
|
|
hostname_override=None,
|
|
auth_protocol: Literal["negotiate", "ntlm", "kerberos"] = "negotiate",
|
|
):
|
|
"""
|
|
[MS-SMB2] v53.0 2017-09-15
|
|
|
|
3.2.1.3 Per Session
|
|
The Session object that is used to store the details for an
|
|
authenticated SMB session. There are 4 forms of authentication that are
|
|
supported;
|
|
|
|
1. SSPI Auth, Windows only if pywin32 is installed. Uses either
|
|
Kerberos or NTLM auth depending on the environment setup and can
|
|
use the current user's credentials if none are provided here.
|
|
2. NTLM Auth, requires the username and password
|
|
3. Kerberos Auth, only available in certain circumstances
|
|
4. Guest Auth, the credentials were rejected but the server allows a
|
|
fallback to guest authentication (insecure and non-default)
|
|
|
|
NTLM Auth is the fallback as it should be available in most scenarios
|
|
while Kerberos only works on a system where python-gssapi is installed
|
|
and the GGF extension for inquire_sec_context_by_oid is available
|
|
(Linux), or pywin32 is installed (Windows).
|
|
|
|
If using Kerberos Auth, the username and password can be omitted which
|
|
means the default user kerb ticket (if available) is used. If the
|
|
username is specified and not the password then it will get the kerb
|
|
ticket for the principal specified (kinit must be used to get this
|
|
ticket beforehand). If both the user and password are specified then
|
|
it will get a ticket for the user instead of relying on the default
|
|
store.
|
|
|
|
If guest auth was negotiated based on a bad credential then signing
|
|
and encryption is not allowed, for this to ultimately work the user
|
|
must set require_signing=False when creating the Connection and
|
|
require_encryption=False when creating the Session.
|
|
|
|
:param connection: The Connection object that the session will use
|
|
:param username: The username of the user to authenticate with
|
|
:param password: The password of the user to authenticate with
|
|
:param require_encryption: Whether any messages sent over the session
|
|
require encryption regardless of the server settings (Dialects 3+),
|
|
needs to be set to False for older dialects.
|
|
:param hostname_override: Specifies hostname context for Kerberos
|
|
authentication when given IP address to the connection context.
|
|
:param auth_protocol: The protocol to use for authentication. Possible
|
|
values are 'negotiate', 'ntlm' or 'kerberos'. Defaults to
|
|
'negotiate'.
|
|
"""
|
|
log.info("Initialising session with username: %s", username)
|
|
self._connected = False
|
|
self.session_id = 0
|
|
self.require_encryption = require_encryption
|
|
|
|
# Table of tree connection, lookup by TreeConnect.tree_connect_id and
|
|
# by share_name
|
|
self.tree_connect_table = {}
|
|
|
|
# First 16 bytes of the cryptographic key for this authenticated
|
|
# context, right-padded with 0 bytes
|
|
self.session_key = None
|
|
|
|
self.signing_required = connection.require_signing
|
|
self.connection = connection
|
|
self.username = username
|
|
self.password = password
|
|
self._hostname_override = hostname_override
|
|
|
|
# No need to validate this as the spnego library will raise a ValueError
|
|
self.auth_protocol = auth_protocol
|
|
|
|
# Table of OpenFile, lookup by OpenFile.file_id
|
|
self.open_table = {}
|
|
|
|
# SMB 3.x+
|
|
# List of Channel
|
|
self.channel_list = []
|
|
|
|
# 16-bit identifier incremented on a network disconnect that indicates
|
|
# to the server the client's Channel change
|
|
self.channel_sequence = None
|
|
|
|
self.encrypt_data = None
|
|
self.encryption_key = None
|
|
self.decryption_key = None
|
|
self.signing_key = None
|
|
self.application_key = None
|
|
self.full_session_key = None
|
|
|
|
# SMB 3.1.1+
|
|
# Preauth integrity value computed for the exhange of SMB2
|
|
# SESSION_SETUP request and response for this session
|
|
self.preauth_integrity_hash_value = []
|
|
|
|
def connect(self):
|
|
log.debug("Decoding SPNEGO token containing supported auth mechanisms")
|
|
try:
|
|
context = spnego.client(
|
|
self.username,
|
|
self.password,
|
|
service="cifs",
|
|
hostname=self._hostname_override or self.connection.server_name,
|
|
options=spnego.NegotiateOptions.session_key,
|
|
protocol=self.auth_protocol,
|
|
)
|
|
except spnego.exceptions.SpnegoError as err:
|
|
raise SMBAuthenticationError(f"Failed to authenticate with server: {err}") from err
|
|
|
|
in_token = self.connection.gss_negotiate_token
|
|
if self.auth_protocol != "negotiate":
|
|
in_token = None # The GSS Negotiate Token can only be used for Negotiate auth.
|
|
|
|
while not context.complete:
|
|
try:
|
|
out_token = context.step(in_token)
|
|
except spnego.exceptions.SpnegoError as err:
|
|
raise SMBAuthenticationError(f"Failed to authenticate with server: {err}") from err
|
|
|
|
if not out_token:
|
|
break
|
|
|
|
session_setup = SMB2SessionSetupRequest()
|
|
session_setup["capabilities"] = Capabilities.SMB2_GLOBAL_CAP_DFS
|
|
session_setup["security_mode"] = self.connection.client_security_mode
|
|
session_setup["buffer"] = out_token
|
|
|
|
log.info("Sending SMB2_SESSION_SETUP request message")
|
|
request = self.connection.send(session_setup, sid=self.session_id, credit_request=64)
|
|
request_id = request.message["message_id"].get_value()
|
|
|
|
log.info("Receiving SMB2_SESSION_SETUP response message")
|
|
try:
|
|
response = self.connection.receive(request)
|
|
except MoreProcessingRequired as exc:
|
|
response = exc.header
|
|
|
|
request_preauth = self.connection.preauth_integrity_session_hash_value.pop(request_id)
|
|
self.preauth_integrity_hash_value += request_preauth
|
|
|
|
# If this is the first time we received the actual session_id,
|
|
# record the returned id.
|
|
session_id = response["session_id"].get_value()
|
|
if self.session_id == 0 and session_id:
|
|
self.session_id = session_id
|
|
|
|
setup_response = SMB2SessionSetupResponse()
|
|
setup_response.unpack(response["data"].get_value())
|
|
|
|
in_token = setup_response["buffer"].get_value()
|
|
|
|
status = response["status"].get_value()
|
|
if status == NtStatus.STATUS_MORE_PROCESSING_REQUIRED:
|
|
log.info("More processing is required for SMB2_SESSION_SETUP")
|
|
|
|
log.info("Setting session id to %s", self.session_id)
|
|
self._connected = True
|
|
|
|
# Move the session from the preauth table to the actual session table.
|
|
self.connection.session_table[self.session_id] = self
|
|
|
|
# session_key is the first 16 bytes, padded 0 if less than 16
|
|
self.full_session_key = context.session_key
|
|
self.session_key = self.full_session_key[:16].ljust(16, b"\x00")
|
|
|
|
if self.connection.dialect >= Dialects.SMB_3_1_1:
|
|
preauth_hash = b"\x00" * 64
|
|
for hash_list in [self.connection.preauth_integrity_hash_value, self.preauth_integrity_hash_value]:
|
|
for message in hash_list:
|
|
# Technically the algo is based on preauth_integrity_hash_id but we only support the 1
|
|
preauth_hash = hashlib.sha512(preauth_hash + message).digest()
|
|
|
|
self.signing_key = self._smb3kdf(self.session_key, b"SMBSigningKey\x00", preauth_hash)
|
|
self.application_key = self._smb3kdf(self.session_key, b"SMBAppKey\x00", preauth_hash)
|
|
|
|
if self.connection.cipher_id in [
|
|
Ciphers.AES_256_CCM,
|
|
Ciphers.AES_256_GCM,
|
|
]:
|
|
key_length = 32
|
|
key = self.full_session_key
|
|
else:
|
|
key_length = 16
|
|
key = self.session_key
|
|
|
|
self.encryption_key = self._smb3kdf(key, b"SMBC2SCipherKey\x00", preauth_hash, length=key_length)
|
|
self.decryption_key = self._smb3kdf(key, b"SMBS2CCipherKey\x00", preauth_hash, length=key_length)
|
|
|
|
elif self.connection.dialect >= Dialects.SMB_3_0_0:
|
|
self.signing_key = self._smb3kdf(self.session_key, b"SMB2AESCMAC\x00", b"SmbSign\x00")
|
|
self.application_key = self._smb3kdf(self.session_key, b"SMB2APP\x00", b"SmbRpc\x00")
|
|
self.encryption_key = self._smb3kdf(self.session_key, b"SMB2AESCCM\x00", b"ServerIn \x00")
|
|
self.decryption_key = self._smb3kdf(self.session_key, b"SMB2AESCCM\x00", b"ServerOut\x00")
|
|
|
|
else:
|
|
self.signing_key = self.session_key
|
|
self.application_key = self.session_key
|
|
|
|
flags = setup_response["session_flags"]
|
|
if flags.has_flag(SessionFlags.SMB2_SESSION_FLAG_ENCRYPT_DATA) or self.require_encryption:
|
|
# make sure the connection actually supports encryption
|
|
if not self.connection.supports_encryption:
|
|
raise SMBException("SMB encryption is required but the connection does not support it")
|
|
|
|
self.encrypt_data = True
|
|
self.signing_required = False # encryption covers signing
|
|
|
|
else:
|
|
self.encrypt_data = False
|
|
|
|
if flags.has_flag(SessionFlags.SMB2_SESSION_FLAG_IS_GUEST) or flags.has_flag(
|
|
SessionFlags.SMB2_SESSION_FLAG_IS_NULL
|
|
):
|
|
self.session_key = None
|
|
self.signing_key = None
|
|
self.application_key = None
|
|
self.encryption_key = None
|
|
self.decryption_key = None
|
|
|
|
if self.signing_required or self.encrypt_data:
|
|
self.session_id = None
|
|
raise SMBException(
|
|
"SMB encryption or signing was required but session was authenticated as a guest "
|
|
"which does not support encryption or signing"
|
|
)
|
|
|
|
if self.signing_required:
|
|
log.info("Verifying the SMB Setup Session signature as auth is successful")
|
|
self.connection.verify_signature(response, self.session_id, force=True)
|
|
|
|
def disconnect(self, close=True, timeout=None):
|
|
"""
|
|
Logs off the session
|
|
|
|
:param close: Will close all tree connects in a session
|
|
"""
|
|
if not self._connected:
|
|
# already disconnected so let's return
|
|
return
|
|
|
|
if close:
|
|
for open in list(self.open_table.values()):
|
|
open.close(False)
|
|
|
|
for tree in list(self.tree_connect_table.values()):
|
|
tree.disconnect()
|
|
|
|
log.info("Session: %s - Logging off of SMB Session", self.username)
|
|
logoff = SMB2Logoff()
|
|
log.info("Session: %s - Sending Logoff message", self.username)
|
|
log.debug(logoff)
|
|
request = self.connection.send(logoff, sid=self.session_id)
|
|
|
|
log.info("Session: %s - Receiving Logoff response", self.username)
|
|
res = self.connection.receive(request, timeout=timeout)
|
|
res_logoff = SMB2Logoff()
|
|
res_logoff.unpack(res["data"].get_value())
|
|
log.debug(res_logoff)
|
|
self._connected = False
|
|
del self.connection.session_table[self.session_id]
|
|
|
|
def _smb3kdf(self, ki, label, context, length=16):
|
|
"""
|
|
See SMB 3.x key derivation function
|
|
https://blogs.msdn.microsoft.com/openspecification/2017/05/26/smb-2-and-smb-3-security-in-windows-10-the-anatomy-of-signing-and-cryptographic-keys/
|
|
|
|
:param ki: The session key is the KDK used as an input to the KDF
|
|
:param label: The purpose of this derived key as bytes string
|
|
:param context: The context information of this derived key as bytes
|
|
:param length: The length of the key to generate
|
|
string
|
|
:return: Key derived by the KDF as specified by [SP800-108] 5.1
|
|
"""
|
|
kdf = KBKDFHMAC(
|
|
algorithm=hashes.SHA256(),
|
|
mode=Mode.CounterMode,
|
|
length=length,
|
|
rlen=4,
|
|
llen=4,
|
|
location=CounterLocation.BeforeFixed,
|
|
label=label,
|
|
context=context,
|
|
fixed=None,
|
|
backend=default_backend(),
|
|
)
|
|
return kdf.derive(ki)
|