# Copyright: (c) 2019, Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from __future__ import annotations import binascii import errno import ntpath import os import socket from collections import OrderedDict from typing import Any from smbprotocol import Dialects from smbprotocol._text import to_bytes, to_text from smbprotocol.header import NtStatus, SMB2HeaderResponse from smbprotocol.reparse_point import SymbolicLinkReparseDataBuffer from smbprotocol.structure import ( BytesField, EnumField, IntField, ListField, Structure, StructureField, ) class SMBException(Exception): # Generic SMB Exception with a message pass class SMBAuthenticationError(SMBException): # Used for authentication specific errors pass class SMBConnectionClosed(SMBException): # Used to denote the underlying TCP transport has been closed. pass class SMBOSError(OSError, SMBException): """Wrapper for OSError with smbprotocol specific details. This is a wrapper for OSError for use in smbclient. It is designed to translate the raw SMBResponseException that smbprotocol raises into an error that is compatible with OSError. """ def __init__(self, ntstatus, filename, filename2=None): self.ntstatus = ntstatus self.filename2 = os.fspath(filename2) if filename2 else None ntstatus_name = "STATUS_UNKNOWN" for name, val in vars(NtStatus).items(): if ntstatus == val: ntstatus_name = name break error_details = { NtStatus.STATUS_OBJECT_NAME_NOT_FOUND: errno.ENOENT, NtStatus.STATUS_OBJECT_PATH_NOT_FOUND: errno.ENOENT, NtStatus.STATUS_NOT_FOUND: errno.ENOENT, NtStatus.STATUS_OBJECT_NAME_COLLISION: errno.EEXIST, NtStatus.STATUS_PRIVILEGE_NOT_HELD: (errno.EACCES, "Required privilege not held"), NtStatus.STATUS_SHARING_VIOLATION: ( errno.EPERM, "The process cannot access the file because it is being used by another process", ), NtStatus.STATUS_NOT_A_REPARSE_POINT: (errno.EINVAL, "The file or directory is not a reparse point"), NtStatus.STATUS_FILE_IS_A_DIRECTORY: errno.EISDIR, NtStatus.STATUS_NOT_A_DIRECTORY: errno.ENOTDIR, NtStatus.STATUS_DIRECTORY_NOT_EMPTY: errno.ENOTEMPTY, NtStatus.STATUS_END_OF_FILE: getattr(errno, "ENODATA", 120), # Not present on py2 for Windows. }.get(ntstatus, (0, f"Unknown NtStatus error returned '{ntstatus_name}'")) if not isinstance(error_details, tuple): error_details = (error_details, os.strerror(error_details)) super().__init__(error_details[0], error_details[1], os.fspath(filename)) def __str__(self): status = format(self.ntstatus, "x").zfill(8) msg = f"[Error {self.errno}] [NtStatus 0x{status}] {self.strerror}: '{self.filename}'" if self.filename2: msg += f" -> '{self.filename2}'" return msg class SMBLinkRedirectionError(SMBException): @property def message(self): msg = ( f"Encountered symlink at '{self.path}' that points to " f"'{self.target}' which cannot be redirected: {self.args[0]}" ) return msg @property def path(self): return self.args[1] @property def target(self): return self.args[2] def __str__(self): return self.message class SMBUnsupportedFeature(SMBException): @property def negotiated_dialect(self): return self.args[0] @property def required_dialect(self): return self.args[1] @property def feature_name(self): return self.args[2] @property def requires_newer(self): if len(self.args) > 3: return self.args[3] else: return None @property def message(self): if self.requires_newer is None: msg_suffix = "" elif self.requires_newer: msg_suffix = " or newer" else: msg_suffix = " or older" required_dialect = self._get_dialect_name(self.required_dialect) negotiated_dialect = self._get_dialect_name(self.negotiated_dialect) msg = ( f"{self.feature_name} is not available on the negotiated dialect {negotiated_dialect}, " f"requires dialect {required_dialect}{msg_suffix}" ) return msg def __str__(self): return self.message def _get_dialect_name(self, dialect): dialect_field = EnumField(enum_type=Dialects, enum_strict=False, size=2) dialect_field.set_value(dialect) return str(dialect_field) class _SMBErrorRegistry(type): __registry = {} def __init__(cls, name, bases, attributes): super().__init__(name, bases, attributes) # Special case for the base SMBResponseException doesn't need to have _STATUS_CODE if cls.__module__ == _SMBErrorRegistry.__module__ and cls.__name__ == "SMBResponseException": return if not hasattr(cls, "_STATUS_CODE"): raise ValueError(f"{cls.__module__}.{cls.__name__} does not have the _STATUS_CODE class attribute set") cls.__registry[cls._STATUS_CODE] = cls def __call__(cls, header=None): # intercept construction of new SMBResponseException (and derived) instances if header: new_cls = cls.__registry.get(header["status"].get_value(), cls) else: header = SMB2HeaderResponse() header["status"] = cls._STATUS_CODE header["data"] = SMB2ErrorResponse() new_cls = cls # now use type.__call__ directly to actually construct instance return type.__call__(new_cls, header) class SMBResponseException(SMBException, metaclass=_SMBErrorRegistry): """Base SMB response status exception. This is the base exception that is used when processing the status of an SMB response received from the server. When being called it may create one of the inherited types depending on whether the status is known or not. Each inherited class must implement _STATUS_CODE representing the NtStatus error it is for and may implement _BASE_MESSAGE to provide a better explanation of the error. """ _BASE_MESSAGE = "Unknown error." def __init__(self, header: SMB2HeaderResponse): self.header = header @property def error_details(self) -> list[Any]: # list of error_details returned by the server, currently used in # the SMB 3.1.1 error response for certain situations error = SMB2ErrorResponse() error.unpack(self.header["data"].get_value()) error_details = [] for raw_error_data in error["error_data"].get_value(): error_id = raw_error_data["error_id"].get_value() raw_data = raw_error_data["error_context_data"].get_value() if self.status == NtStatus.STATUS_STOPPED_ON_SYMLINK: error_data = SMB2SymbolicLinkErrorResponse() error_data.unpack(raw_data) elif ( self.status == NtStatus.STATUS_BAD_NETWORK_NAME and error_id == ErrorContextId.SMB2_ERROR_ID_SHARE_REDIRECT ): error_data = SMB2ShareRedirectErrorContext() error_data.unpack(raw_data) else: # unknown context data so we just set it the raw bytes error_data = raw_data error_details.append(error_data) return error_details @property def message(self) -> str: error_details = [] for detail in self.error_details: if isinstance(detail, SMB2SymbolicLinkErrorResponse): flag = str(detail["flags"]) print_name = detail.get_print_name() sub_name = detail.get_substitute_name() error_details.append(f"Flag: {flag}, Print Name: {print_name}, Substitute Name: {sub_name}") elif isinstance(detail, SMB2ShareRedirectErrorContext): ip_addresses = [] for ip_addr in detail["ip_addr_move_list"].get_value(): ip_addresses.append(ip_addr.get_ipaddress()) resource_name = to_text(detail["resource_name"].get_value(), encoding="utf-16-le") addresses = "', '".join(ip_addresses) error_details.append(f"IP Addresses: '{addresses}', Resource Name: {resource_name}") else: # unknown error details in response, output raw bytes error_details.append("Raw: " + to_text(binascii.hexlify(detail))) status = format(self.status, "x").zfill(8) error_msg = f"{self._BASE_MESSAGE} {self.header['status']}: 0x{status}" if error_details: error_msg += " - " + (", ".join(error_details)) return f"Received unexpected status from the server: {error_msg}" @property def status(self): return self.header["status"].get_value() def __str__(self): return self.message class Unsuccessful(SMBResponseException): _BASE_MESSAGE = "The requested operation was unsuccessful." _STATUS_CODE = NtStatus.STATUS_UNSUCCESSFUL class NetworkNameDelegated(SMBResponseException): _BASE_MESSAGE = "The network name was deleted." _STATUS_CODE = NtStatus.STATUS_NETWORK_NAME_DELETED class StatusPending(SMBResponseException): _BASE_MESSAGE = "The operation that was requested is pending completion." _STATUS_CODE = NtStatus.STATUS_PENDING class NotifyCleanup(SMBResponseException): _BASE_MESSAGE = ( "Indicates that a notify change request has been completed due to closing the handle that made " "the notify change request." ) _STATUS_CODE = NtStatus.STATUS_NOTIFY_CLEANUP class NotifyEnumDir(SMBResponseException): _BASE_MESSAGE = ( "Indicates that a notify change request is being completed and that the information is not " "being returned in the caller's buffer. The caller now needs to enumerate the files to find " "the changes." ) _STATUS_CODE = NtStatus.STATUS_NOTIFY_ENUM_DIR class BufferOverflow(SMBResponseException): _BASE_MESSAGE = "The data was too large to fit into the specified buffer." _STATUS_CODE = NtStatus.STATUS_BUFFER_OVERFLOW class NoMoreFiles(SMBResponseException): _BASE_MESSAGE = "No more files were found which match the file specification." _STATUS_CODE = NtStatus.STATUS_NO_MORE_FILES class EndOfFile(SMBResponseException): _BASE_MESSAGE = "The end-of-file marker has been reached. There is no valid data in the file beyond this marker." _STATUS_CODE = NtStatus.STATUS_END_OF_FILE class InvalidEAName(SMBResponseException): _BASE_MESSAGE = "The specified extended attribute (EA) name contains at least one illegal character." _STATUS_CODE = NtStatus.STATUS_INVALID_EA_NAME class EAListInconsistent(SMBResponseException): _BASE_MESSAGE = "The extended attribute (EA) list is inconsistent." _STATUS_CODE = NtStatus.STATUS_EA_LIST_INCONSISTENT class StoppedOnSymlink(SMBResponseException): _BASE_MESSAGE = "The create operation stopped after reaching a symbolic link." _STATUS_CODE = NtStatus.STATUS_STOPPED_ON_SYMLINK class InvalidInfoClass(SMBResponseException): _BASE_MESSAGE = "The specified information class is not a valid information class for the specified object." _STATUS_CODE = NtStatus.STATUS_INVALID_INFO_CLASS class InfoLengthMismatch(SMBResponseException): _BASE_MESSAGE = ( "The specified information record length does not match the length that is required for the " "specified information class." ) _STATUS_CODE = NtStatus.STATUS_INFO_LENGTH_MISMATCH class InvalidParameter(SMBResponseException): _BASE_MESSAGE = "An invalid parameter was passed to a service or function." _STATUS_CODE = NtStatus.STATUS_INVALID_PARAMETER class NoSuchFile(SMBResponseException): _BASE_MESSAGE = "The file does not exist." _STATUS_CODE = NtStatus.STATUS_NO_SUCH_FILE class InvalidDeviceRequest(SMBResponseException): _BASE_MESSAGE = "The specified request is not a valid operation for the target device." _STATUS_CODE = NtStatus.STATUS_INVALID_DEVICE_REQUEST class MoreProcessingRequired(SMBResponseException): _BASE_MESSAGE = ( "The specified I/O request packet (IRP) cannot be disposed of because the I/O operation is not complete." ) _STATUS_CODE = NtStatus.STATUS_MORE_PROCESSING_REQUIRED class AccessDenied(SMBResponseException): _BASE_MESSAGE = "A process has requested access to an object but has not been granted those access rights." _STATUS_CODE = NtStatus.STATUS_ACCESS_DENIED class BufferTooSmall(SMBResponseException): _BASE_MESSAGE = "The buffer is too small to contain the entry. No information has been written to the buffer." _STATUS_CODE = NtStatus.STATUS_BUFFER_TOO_SMALL class ObjectNameInvalid(SMBResponseException): _BASE_MESSAGE = "The object name is invalid." _STATUS_CODE = NtStatus.STATUS_OBJECT_NAME_INVALID class ObjectNameNotFound(SMBResponseException): _BASE_MESSAGE = "The object name is not found." _STATUS_CODE = NtStatus.STATUS_OBJECT_NAME_NOT_FOUND class ObjectNameCollision(SMBResponseException): _BASE_MESSAGE = "The object name already exists." _STATUS_CODE = NtStatus.STATUS_OBJECT_NAME_COLLISION class ObjectPathInvalid(SMBResponseException): _BASE_MESSAGE = "The object path component was not a directory object." _STATUS_CODE = NtStatus.STATUS_OBJECT_PATH_INVALID class ObjectPathNotFound(SMBResponseException): _BASE_MESSAGE = "The path does not exist." _STATUS_CODE = NtStatus.STATUS_OBJECT_PATH_NOT_FOUND class ObjectPathSyntaxBad(SMBResponseException): _BASE_MESSAGE = "The object path component was not a directory object." _STATUS_CODE = NtStatus.STATUS_OBJECT_PATH_SYNTAX_BAD class SharingViolation(SMBResponseException): _BASE_MESSAGE = "A file cannot be opened because the share access flags are incompatible." _STATUS_CODE = NtStatus.STATUS_SHARING_VIOLATION class EASNotSupported(SMBResponseException): _BASE_MESSAGE = "An operation involving EAs failed because the file system does not support EAs." _STATUS_CODE = NtStatus.STATUS_EAS_NOT_SUPPORTED class EATooLarge(SMBResponseException): _BASE_MESSAGE = "An EA operation failed because the EA set is too large." _STATUS_CODE = NtStatus.STATUS_EA_TOO_LARGE class NonExistentEAEntry(SMBResponseException): _BASE_MESSAGE = "An EA operation failed because the name or EA index is invalid." _STATUS_CODE = NtStatus.STATUS_NONEXISTENT_EA_ENTRY class NoEASOnFile(SMBResponseException): _BASE_MESSAGE = "The file for which EAs were requested has no EAs." _STATUS_CODE = NtStatus.STATUS_NO_EAS_ON_FILE class EACorruptError(SMBResponseException): _BASE_MESSAGE = "The EA is corrupt and cannot be read." _STATUS_CODE = NtStatus.STATUS_EA_CORRUPT_ERROR class DeletePending(SMBResponseException): _BASE_MESSAGE = "A non-close operation has been requested of a file object that has a delete pending." _STATUS_CODE = NtStatus.STATUS_DELETE_PENDING class PrivilegeNotHeld(SMBResponseException): _BASE_MESSAGE = "A required privilege is not held by the client." _STATUS_CODE = NtStatus.STATUS_PRIVILEGE_NOT_HELD class WrongPassword(SMBResponseException): _BASE_MESSAGE = "The specified password is not correct or the user is locked out." _STATUS_CODE = NtStatus.STATUS_WRONG_PASSWORD class LogonFailure(SMBResponseException): _BASE_MESSAGE = ( "The attempted logon is invalid. This is either due to a bad username or authentication information." ) _STATUS_CODE = NtStatus.STATUS_LOGON_FAILURE class PasswordExpired(SMBResponseException): _BASE_MESSAGE = "The user account password has expired." _STATUS_CODE = NtStatus.STATUS_PASSWORD_EXPIRED class NoneMapped(SMBResponseException): _BASE_MESSAGE = "None of the information to be translated has been translated." _STATUS_CODE = NtStatus.STATUS_NONE_MAPPED class InsufficientResources(SMBResponseException): _BASE_MESSAGE = "Insufficient system resources exist to complete the API." _STATUS_CODE = NtStatus.STATUS_INSUFFICIENT_RESOURCES class PipeNotAvailable(SMBResponseException): _BASE_MESSAGE = "An instance of a named pipe cannot be found in the listening state." _STATUS_CODE = NtStatus.STATUS_PIPE_NOT_AVAILABLE class PipeBusy(SMBResponseException): _BASE_MESSAGE = ( "The specified pipe is set to complete operations and there are current I/O operations queued " "so that it cannot be changed to queue operations." ) _STATUS_CODE = NtStatus.STATUS_PIPE_BUSY class PipeClosing(SMBResponseException): _BASE_MESSAGE = "The specified named pipe is in the closing state." _STATUS_CODE = NtStatus.STATUS_PIPE_CLOSING class IOTimeout(SMBResponseException): _BASE_MESSAGE = "The specified I/O operation was not completed before the time-out period expired." _STATUS_CODE = NtStatus.STATUS_IO_TIMEOUT class PipeDisconnected(SMBResponseException): _BASE_MESSAGE = "The specified named pipe is in the disconnected state." _STATUS_CODE = NtStatus.STATUS_PIPE_DISCONNECTED class FileIsADirectory(SMBResponseException): _BASE_MESSAGE = ( "The file that was specified as a target is a directory, and the caller specified that it could " "be anything but a directory." ) _STATUS_CODE = NtStatus.STATUS_FILE_IS_A_DIRECTORY class NotSupported(SMBResponseException): _BASE_MESSAGE = "The request is not supported." _STATUS_CODE = NtStatus.STATUS_NOT_SUPPORTED class BadNetworkName(SMBResponseException): _BASE_MESSAGE = "The specified share name cannot be found on the remote server." _STATUS_CODE = NtStatus.STATUS_BAD_NETWORK_NAME class RequestNotAccepted(SMBResponseException): _BASE_MESSAGE = ( "No more connections can be made to this remote computer at this time because the computer has " "already accepted the maximum number of connections." ) _STATUS_CODE = NtStatus.STATUS_REQUEST_NOT_ACCEPTED class PipeEmpty(SMBResponseException): _BASE_MESSAGE = "Used to indicate that a read operation was done on an empty pipe." _STATUS_CODE = NtStatus.STATUS_PIPE_EMPTY class InternalError(SMBResponseException): _BASE_MESSAGE = "An internal error occurred." _STATUS_CODE = NtStatus.STATUS_INTERNAL_ERROR class DirectoryNotEmpty(SMBResponseException): _BASE_MESSAGE = "Indicates that the directory trying to be deleted is not empty." _STATUS_CODE = NtStatus.STATUS_DIRECTORY_NOT_EMPTY class StatusNotADirectory(SMBResponseException): _BASE_MESSAGE = "A requested opened file is not a directory." _STATUS_CODE = NtStatus.STATUS_NOT_A_DIRECTORY class Cancelled(SMBResponseException): _BASE_MESSAGE = "The I/O request was canceled." _STATUS_CODE = NtStatus.STATUS_CANCELLED class CannotDelete(SMBResponseException): _BASE_MESSAGE = "An attempt has been made to remove a file or directory that cannot be deleted." _STATUS_CODE = NtStatus.STATUS_CANNOT_DELETE class FileClosed(SMBResponseException): _BASE_MESSAGE = ( "An I/O request other than close and several other special case operations was attempted using " "a file object that had already been closed." ) _STATUS_CODE = NtStatus.STATUS_FILE_CLOSED class PipeBroken(SMBResponseException): _BASE_MESSAGE = "The pipe operation has failed because the other end of the pipe has been closed." _STATUS_CODE = NtStatus.STATUS_PIPE_BROKEN class FSDriverRequired(SMBResponseException): _BASE_MESSAGE = ( "A volume has been accessed for which a file system driver is required that has not yet been loaded." ) _STATUS_CODE = NtStatus.STATUS_FS_DRIVER_REQUIRED class UserSessionDeleted(SMBResponseException): _BASE_MESSAGE = "The remote user session has been deleted." _STATUS_CODE = NtStatus.STATUS_USER_SESSION_DELETED class InsuffServerResources(SMBResponseException): _BASE_MESSAGE = "Insufficient server resources exist to complete the request." _STATUS_CODE = NtStatus.STATUS_INSUFF_SERVER_RESOURCES class NotFound(SMBResponseException): _BASE_MESSAGE = "The object was not found." _STATUS_CODE = NtStatus.STATUS_NOT_FOUND class PathNotCovered(SMBResponseException): _BASE_MESSAGE = "The contacted server does not support the indicated part of the DFS namespace." _STATUS_CODE = NtStatus.STATUS_PATH_NOT_COVERED class DfsUnavailable(SMBResponseException): _BASE_MESSAGE = "DFS is unavailable on the contacted server." _STATUS_CODE = NtStatus.STATUS_DFS_UNAVAILABLE class NotAReparsePoint(SMBResponseException): _BASE_MESSAGE = "The NTFS file or directory is not a reparse point." _STATUS_CODE = NtStatus.STATUS_NOT_A_REPARSE_POINT class ServerUnavailable(SMBResponseException): _BASE_MESSAGE = "The file server is temporarily unavailable." _STATUS_CODE = NtStatus.STATUS_SERVER_UNAVAILABLE class DiskFull(SMBResponseException): _BASE_MESSAGE = "There is not enough space on the disk." _STATUS_CODE = NtStatus.STATUS_DISK_FULL class ErrorContextId: """ [MS-SMB2] v53.0 2017-09-15 2.2.2.1 SMB2 Error Context Response ErrorId An identifier for the error context, it MUST be set to one of the following values. """ SMB2_ERROR_ID_DEFAULT = 0x00000000 SMB2_ERROR_ID_SHARE_REDIRECT = 0x53526472 class SymbolicLinkErrorFlags: """ [MS-SMB2] v53.0 2017-09-15 2.2.2.2.1 Symbolic Link Error Response Flags Specifies whether the substitute name is an absolute target path or a path name relative to the directory containing the symbolic link """ SYMLINK_FLAG_ABSOLUTE = 0x00000000 SYMLINK_FLAG_RELATIVE = 0x00000001 class IpAddrType: """ [MS-SM2] v53.0 2017-09-15 2.2.2.2.2.1 MOVE_DST_IPADDR structure Type Indicates the type of the destionation IP address. """ MOVE_DST_IPADDR_V4 = 0x00000001 MOVE_DST_IPADDR_V6 = 0x00000002 class SMB2ErrorResponse(Structure): """ [MS-SMB2] v53.0 2017-09-15 2.2.2 SMB2 Error Response The SMB2 Error Response packet is sent by the server to respond to a request that has failed or encountered an error. This is only used in the SMB 3.1.1 dialect and this code won't decode values based on older versions """ def __init__(self): self.fields = OrderedDict( [ ( "structure_size", IntField( size=2, default=9, ), ), ( "error_context_count", IntField( size=1, default=lambda s: len(s["error_data"].get_value()), ), ), ("reserved", IntField(size=1)), ( "byte_count", IntField( size=4, default=lambda s: len(s["error_data"]), ), ), ( "error_data", ListField( size=lambda s: s["byte_count"].get_value(), list_count=lambda s: s["error_context_count"].get_value(), list_type=StructureField(structure_type=SMB2ErrorContextResponse), unpack_func=SMB2ErrorResponse._error_data_value, ), ), ] ) super().__init__() @staticmethod def _error_data_value(structure, data): context_responses = [] while len(data) > 0: response = SMB2ErrorContextResponse() if structure["error_context_count"].get_value() > 0: # Working with SMB 3.1.1+ where the errors are already in an SMB2ErrorContextReponse packet, unpack the # data as usual data = response.unpack(data) else: # Working with an older SMB dialect where the response is set directly in the error_data field, need to # manually craft the SMB2ErrorContextResponse with the data returned. response["error_context_data"] = data data = b"" context_responses.append(response) return context_responses class SMB2ErrorContextResponse(Structure): """ [MS-SMB2] v53.0 2017-09-15 2.2.2.1 SMB2 ERROR Context Response For the SMB dialect 3.1.1, the server formats the error data as an array of SMB2 Error Context structures in the SMB2ErrorResponse message. """ def __init__(self): self.fields = OrderedDict( [ ( "error_data_length", IntField( size=4, default=lambda s: len(s["error_context_data"]), ), ), ( "error_id", EnumField( size=4, default=ErrorContextId.SMB2_ERROR_ID_DEFAULT, enum_type=ErrorContextId, ), ), ( "error_context_data", BytesField( size=lambda s: s["error_data_length"].get_value(), ), ), ] ) super().__init__() class SMB2SymbolicLinkErrorResponse(Structure): """ [MS-SMB2] v53.0 2017-09-15 2.2.2.2.1 Symbolic Link Error Response The Symbolic Link Error Response is used to indicate that a symbolic link was encountered on the create. It describes the target path that the client MUST use if it requires to follow the symbolic link. """ def __init__(self): self.fields = OrderedDict( [ ("symlink_length", IntField(size=4, default=lambda s: len(s) - 4)), ("symlink_error_tag", BytesField(size=4, default=b"\x53\x59\x4d\x4c")), ("reparse_tag", BytesField(size=4, default=b"\x0c\x00\x00\xa0")), ("reparse_data_length", IntField(size=2, default=lambda s: len(s["path_buffer"]) + 12)), # the len in utf-16-le bytes of the path beyond the substitute name # of the original target, e.g. \\server\share\symlink\file.txt # would be length of \file.txt in utf-16-le form, this is used by # the client to find out what part of the original path to append # to the substitute name returned by the server. ("unparsed_path_length", IntField(size=2)), ("substitute_name_offset", IntField(size=2)), ("substitute_name_length", IntField(size=2)), ("print_name_offset", IntField(size=2)), ("print_name_length", IntField(size=2)), ( "flags", EnumField( size=2, enum_type=SymbolicLinkErrorFlags, ), ), # Not in the spec but Windows seems to add \x00\x80 to the end of flags which breaks our parsing. Cannot # seem to figure out why but this just ignored that field. ("reserved", IntField(size=2)), # use the get/set_name functions to get/set these values as they # also (d)encode the text and set the length and offset accordingly ("path_buffer", BytesField(size=SMB2SymbolicLinkErrorResponse._get_name_length)), ] ) super().__init__() @staticmethod def _get_name_length(structure, first=True): print_name_len = structure["print_name_length"].get_value() sub_name_len = structure["substitute_name_length"].get_value() return print_name_len + sub_name_len def set_name(self, print_name, substitute_name): """ Set's the path_buffer and print/substitute name length of the message with the values passed in. These values should be a string and not a byte string as it is encoded in this function. :param print_name: The print name string to set :param substitute_name: The substitute name string to set """ # Ensure that the to_bytes input is an actual text string for py2 compat with native strings. print_bytes = to_bytes(to_text(print_name), encoding="utf-16-le") sub_bytes = to_bytes(to_text(substitute_name), encoding="utf-16-le") path_buffer = print_bytes + sub_bytes self["print_name_offset"].set_value(0) self["print_name_length"].set_value(len(print_bytes)) self["substitute_name_offset"].set_value(len(print_bytes)) self["substitute_name_length"].set_value(len(sub_bytes)) self["path_buffer"].set_value(path_buffer) def get_print_name(self): offset = self["print_name_offset"].get_value() length = self["print_name_length"].get_value() name_bytes = self["path_buffer"].get_value()[offset : offset + length] return to_text(name_bytes, encoding="utf-16-le") def get_substitute_name(self): offset = self["substitute_name_offset"].get_value() length = self["substitute_name_length"].get_value() name_bytes = self["path_buffer"].get_value()[offset : offset + length] return to_text(name_bytes, encoding="utf-16-le") def resolve_path(self, link_path): """ [MS-SMB2] 2.2.2.2.1.1 Handling the Symbolic Link Error Response https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/a8da655c-8b0b-415a-b726-16dc33fa5827 Attempts to resolve the link target path. Will fail if the link is pointing to a local path or a UNC path on another host or share. :param link_path: The original path to the symbolic link to resolve relative paths from. :return: The resolved link target path. """ substitute_name = self.get_substitute_name() print_name = self.get_print_name() unparsed_path_length = self["unparsed_path_length"].get_value() b_link_path = to_bytes(to_text(link_path), encoding="utf-16-le") unparsed_idx = len(b_link_path) - unparsed_path_length base_link_path = to_text(b_link_path[:unparsed_idx], encoding="utf-16-le") unparsed_path = to_text(b_link_path[unparsed_idx:], encoding="utf-16-le") # Use the common code in SymbolicLinkReparseDataBuffer() to resolve the link target. symlink_buffer = SymbolicLinkReparseDataBuffer() symlink_buffer["flags"] = self["flags"].get_value() symlink_buffer.set_name(substitute_name, print_name) target_path = symlink_buffer.resolve_link(base_link_path) + unparsed_path if not target_path.startswith("\\\\"): raise SMBLinkRedirectionError( "Cannot resolve link targets that point to a local path", link_path, print_name ) link_share = ntpath.splitdrive(link_path)[0] target_share = ntpath.splitdrive(target_path)[0] if link_share != target_share: raise SMBLinkRedirectionError( "Cannot resolve link targets that point to a different host/share", link_path, print_name ) return target_path class SMB2ShareRedirectErrorContext(Structure): """ [MS-SMB2] v53.0 2017-09-15 2.2.2.2.2 Share Redirect Error Context Response Response to a Tree Connect with the SMB2_TREE_CONNECT_FLAG_REDIRECT_TO_OWNER flag set. """ def __init__(self): self.fields = OrderedDict( [ ("structure_size", IntField(size=4, default=lambda s: len(s))), ("notification_type", IntField(size=4, default=3)), ("resource_name_offset", IntField(size=4, default=SMB2ShareRedirectErrorContext._resource_name_offset)), ("resource_name_length", IntField(size=4, default=lambda s: len(s["resource_name"]))), ("flags", IntField(size=2, default=0)), ("target_type", IntField(size=2, default=0)), ("ip_addr_count", IntField(size=4, default=lambda s: len(s["ip_addr_move_list"].get_value()))), ( "ip_addr_move_list", ListField( size=lambda s: s["ip_addr_count"].get_value() * 24, list_count=lambda s: s["ip_addr_count"].get_value(), list_type=StructureField(size=24, structure_type=SMB2MoveDstIpAddrStructure), ), ), ("resource_name", BytesField(size=lambda s: s["resource_name_length"].get_value())), ] ) super().__init__() @staticmethod def _resource_name_offset(structure): min_structure_size = 24 addr_list_size = len(structure["ip_addr_move_list"]) return min_structure_size + addr_list_size class SMB2MoveDstIpAddrStructure(Structure): """ [MS-SMB2] c53.0 2017-09-15 2.2.2.2.2.1 MOVE_DST_IPADDR structure Used to indicate the destination IP address. """ def __init__(self): self.fields = OrderedDict( [ ("type", EnumField(size=4, enum_type=IpAddrType)), ("reserved", IntField(size=4)), ("ip_address", BytesField(size=SMB2MoveDstIpAddrStructure._ip_address_size)), ( "reserved2", BytesField( size=SMB2MoveDstIpAddrStructure._reserved2_size, default=SMB2MoveDstIpAddrStructure._default_reserved2_size, ), ), ] ) super().__init__() @staticmethod def _ip_address_size(structure): if structure["type"].get_value() == IpAddrType.MOVE_DST_IPADDR_V4: return 4 else: return 16 @staticmethod def _reserved2_size(structure): if structure["type"].get_value() == IpAddrType.MOVE_DST_IPADDR_V4: return 12 else: return 0 @staticmethod def _default_reserved2_size(structure): return b"\x00" * SMB2MoveDstIpAddrStructure._reserved2_size(structure) def get_ipaddress(self): # get's the IP address in a human readable format ip_address = self["ip_address"].get_value() if self["type"].get_value() == IpAddrType.MOVE_DST_IPADDR_V4: return socket.inet_ntoa(ip_address) else: addr = binascii.hexlify(ip_address).decode("utf-8") return ":".join([addr[i : i + 4] for i in range(0, len(addr), 4)]) def set_ipaddress(self, address): # set's the IP address from a human readable format, for IPv6, this # needs to be the full IPv6 address if self["type"].get_value() == IpAddrType.MOVE_DST_IPADDR_V4: self["ip_address"].set_value(socket.inet_aton(address)) else: addr = address.replace(":", "") if len(addr) != 32: raise ValueError("When setting an IPv6 address, it must be in the full form without concatenation") self["ip_address"].set_value(binascii.unhexlify(addr))