# Copyright: (c) 2019, Jordan Borean (@jborean93) # 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)