1670 lines
58 KiB
Python
1670 lines
58 KiB
Python
|
|
# Copyright: (c) 2019, Jordan Borean (@jborean93) <jborean93@gmail.com>
|
||
|
|
# MIT License (see LICENSE or https://opensource.org/licenses/MIT)
|
||
|
|
|
||
|
|
import logging
|
||
|
|
from collections import OrderedDict
|
||
|
|
|
||
|
|
from smbprotocol import MAX_PAYLOAD_SIZE, Dialects
|
||
|
|
from smbprotocol.create_contexts import SMB2CreateContextRequest
|
||
|
|
from smbprotocol.exceptions import FileClosed, SMBException, SMBUnsupportedFeature
|
||
|
|
from smbprotocol.file_info import ( # While this shouldn't ever be removed, we need to keep this imported so we stay backwards compat. These were; originally defined here.
|
||
|
|
FileAttributes,
|
||
|
|
FileBothDirectoryInformation,
|
||
|
|
FileDirectoryInformation,
|
||
|
|
FileFullDirectoryInformation,
|
||
|
|
FileFullEaInformation,
|
||
|
|
FileIdBothDirectoryInformation,
|
||
|
|
FileIdFullDirectoryInformation,
|
||
|
|
FileInformationClass,
|
||
|
|
FileNamesInformation,
|
||
|
|
FileStreamInformation,
|
||
|
|
InfoType,
|
||
|
|
)
|
||
|
|
from smbprotocol.header import Commands
|
||
|
|
from smbprotocol.structure import (
|
||
|
|
BytesField,
|
||
|
|
DateTimeField,
|
||
|
|
EnumField,
|
||
|
|
FlagField,
|
||
|
|
IntField,
|
||
|
|
ListField,
|
||
|
|
Structure,
|
||
|
|
StructureField,
|
||
|
|
)
|
||
|
|
|
||
|
|
log = logging.getLogger(__name__)
|
||
|
|
|
||
|
|
|
||
|
|
class RequestedOplockLevel:
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.31 SMB2 CREATE Request RequestedOplockLevel
|
||
|
|
The requested oplock level used when creating/accessing a file.
|
||
|
|
"""
|
||
|
|
|
||
|
|
SMB2_OPLOCK_LEVEL_NONE = 0x00
|
||
|
|
SMB2_OPLOCK_LEVEL_II = 0x01
|
||
|
|
SMB2_OPLOCK_LEVEL_EXCLUSIVE = 0x08
|
||
|
|
SMB2_OPLOCK_LEVEL_BATCH = 0x09
|
||
|
|
SMB2_OPLOCK_LEVEL_LEASE = 0xFF
|
||
|
|
|
||
|
|
|
||
|
|
class ImpersonationLevel:
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.31 SMB2 CREATE Request ImpersonationLevel
|
||
|
|
The impersonation level requested by the application in a create request.
|
||
|
|
"""
|
||
|
|
|
||
|
|
Anonymous = 0x0
|
||
|
|
Identification = 0x1
|
||
|
|
Impersonation = 0x2
|
||
|
|
Delegate = 0x3
|
||
|
|
|
||
|
|
|
||
|
|
class ShareAccess:
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.31 SMB2 CREATE Request ShareAccess
|
||
|
|
The sharing mode for the open
|
||
|
|
"""
|
||
|
|
|
||
|
|
FILE_SHARE_READ = 0x1
|
||
|
|
FILE_SHARE_WRITE = 0x2
|
||
|
|
FILE_SHARE_DELETE = 0x4
|
||
|
|
|
||
|
|
|
||
|
|
class CreateDisposition:
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.31 SMB2 CREATE Request CreateDisposition
|
||
|
|
Defines the action the server must take if the file that is specific
|
||
|
|
already exists.
|
||
|
|
"""
|
||
|
|
|
||
|
|
FILE_SUPERSEDE = 0x0
|
||
|
|
FILE_OPEN = 0x1
|
||
|
|
FILE_CREATE = 0x2
|
||
|
|
FILE_OPEN_IF = 0x3
|
||
|
|
FILE_OVERWRITE = 0x4
|
||
|
|
FILE_OVERWRITE_IF = 0x5
|
||
|
|
|
||
|
|
|
||
|
|
class CreateOptions:
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.31 SMB2 CREATE Request CreateOptions
|
||
|
|
Specifies the options to be applied when creating or opening the file
|
||
|
|
"""
|
||
|
|
|
||
|
|
FILE_DIRECTORY_FILE = 0x00000001
|
||
|
|
FILE_WRITE_THROUGH = 0x00000002
|
||
|
|
FILE_SEQUENTIAL_ONLY = 0x00000004
|
||
|
|
FILE_NO_INTERMEDIATE_BUFFERING = 0x00000008
|
||
|
|
FILE_SYNCHRONOUS_IO_ALERT = 0x00000010
|
||
|
|
FILE_SYNCHRONOUS_IO_NONALERT = 0x00000020
|
||
|
|
FILE_NON_DIRECTORY_FILE = 0x00000040
|
||
|
|
FILE_COMPLETE_IF_OPLOCKED = 0x00000100
|
||
|
|
FILE_NO_EA_KNOWLEDGE = 0x00000200
|
||
|
|
FILE_RANDOM_ACCESS = 0x00000800
|
||
|
|
FILE_DELETE_ON_CLOSE = 0x00001000
|
||
|
|
FILE_OPEN_BY_FILE_ID = 0x00002000
|
||
|
|
FILE_OPEN_FOR_BACKUP_INTENT = 0x00004000
|
||
|
|
FILE_NO_COMPRESSION = 0x00008000
|
||
|
|
FILE_OPEN_REMOTE_INSTANCE = 0x00000400
|
||
|
|
FILE_OPEN_REQUIRING_OPLOCK = 0x00010000
|
||
|
|
FILE_DISALLOW_EXCLUSIVE = 0x00020000
|
||
|
|
FILE_RESERVE_OPFILTER = 0x00100000
|
||
|
|
FILE_OPEN_REPARSE_POINT = 0x00200000
|
||
|
|
FILE_OPEN_NO_RECALL = 0x00400000
|
||
|
|
FILE_OPEN_FOR_FREE_SPACE_QUERY = 0x00800000
|
||
|
|
|
||
|
|
|
||
|
|
class FilePipePrinterAccessMask:
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.13.1.1 File_Pipe_Printer_Access_Mask
|
||
|
|
Access Mask flag values to be used when accessing a file, pipe, or printer
|
||
|
|
"""
|
||
|
|
|
||
|
|
FILE_READ_DATA = 0x00000001
|
||
|
|
FILE_WRITE_DATA = 0x00000002
|
||
|
|
FILE_APPEND_DATA = 0x00000004
|
||
|
|
FILE_READ_EA = 0x00000008
|
||
|
|
FILE_WRITE_EA = 0x00000010
|
||
|
|
FILE_DELETE_CHILD = 0x00000040
|
||
|
|
FILE_EXECUTE = 0x00000020
|
||
|
|
FILE_READ_ATTRIBUTES = 0x00000080
|
||
|
|
FILE_WRITE_ATTRIBUTES = 0x00000100
|
||
|
|
DELETE = 0x00010000
|
||
|
|
READ_CONTROL = 0x00020000
|
||
|
|
WRITE_DAC = 0x00040000
|
||
|
|
WRITE_OWNER = 0x00080000
|
||
|
|
SYNCHRONIZE = 0x00100000
|
||
|
|
ACCESS_SYSTEM_SECURITY = 0x01000000
|
||
|
|
MAXIMUM_ALLOWED = 0x02000000
|
||
|
|
GENERIC_ALL = 0x10000000
|
||
|
|
GENERIC_EXECUTE = 0x20000000
|
||
|
|
GENERIC_WRITE = 0x40000000
|
||
|
|
GENERIC_READ = 0x80000000
|
||
|
|
|
||
|
|
|
||
|
|
class DirectoryAccessMask:
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.13.1.2 Directory_Access_Mask
|
||
|
|
Access Mask flag values to be used when accessing a directory
|
||
|
|
"""
|
||
|
|
|
||
|
|
FILE_LIST_DIRECTORY = 0x00000001
|
||
|
|
FILE_ADD_FILE = 0x00000002
|
||
|
|
FILE_ADD_SUBDIRECTORY = 0x00000004
|
||
|
|
FILE_READ_EA = 0x00000008
|
||
|
|
FILE_WRITE_EA = 0x00000010
|
||
|
|
FILE_TRAVERSE = 0x00000020
|
||
|
|
FILE_DELETE_CHILD = 0x00000040
|
||
|
|
FILE_READ_ATTRIBUTES = 0x00000080
|
||
|
|
FILE_WRITE_ATTRIBUTES = 0x00000100
|
||
|
|
DELETE = 0x00010000
|
||
|
|
READ_CONTROL = 0x00020000
|
||
|
|
WRITE_DAC = 0x00040000
|
||
|
|
WRITE_OWNER = 0x00080000
|
||
|
|
SYNCHRONIZE = 0x00100000
|
||
|
|
ACCESS_SYSTEM_SECURITY = 0x01000000
|
||
|
|
MAXIMUM_ALLOWED = 0x02000000
|
||
|
|
GENERIC_ALL = 0x10000000
|
||
|
|
GENERIC_EXECUTE = 0x20000000
|
||
|
|
GENERIC_WRITE = 0x40000000
|
||
|
|
GENERIC_READ = 0x80000000
|
||
|
|
|
||
|
|
|
||
|
|
class FileFlags:
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.14 SMB2 CREATE Response Flags
|
||
|
|
Flag that details info about the file that was opened.
|
||
|
|
"""
|
||
|
|
|
||
|
|
SMB2_CREATE_FLAG_REPARSEPOINT = 0x1
|
||
|
|
|
||
|
|
|
||
|
|
class CreateAction:
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.14 SMB2 CREATE Response Flags
|
||
|
|
The action taken in establishing the open.
|
||
|
|
"""
|
||
|
|
|
||
|
|
FILE_SUPERSEDED = 0x0
|
||
|
|
FILE_OPENED = 0x1
|
||
|
|
FILE_CREATED = 0x2
|
||
|
|
FILE_OVERWRITTEN = 0x3
|
||
|
|
|
||
|
|
|
||
|
|
class CloseFlags:
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.15 SMB2 CLOSE Request Flags
|
||
|
|
Flags to indicate how to process the operation
|
||
|
|
"""
|
||
|
|
|
||
|
|
SMB2_CLOSE_FLAG_POSTQUERY_ATTRIB = 0x01
|
||
|
|
|
||
|
|
|
||
|
|
class ReadFlags:
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.19 SMB2 READ Request Flags
|
||
|
|
Read flags for SMB 3.0.2 and newer dialects
|
||
|
|
"""
|
||
|
|
|
||
|
|
SMB2_READFLAG_READ_UNBUFFERED = 0x01
|
||
|
|
SMB2_READFLAG_REQUEST_COMPRESSED = 0x02
|
||
|
|
|
||
|
|
|
||
|
|
class ReadWriteChannel:
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.19/21 SMB2 READ/Write Request Channel
|
||
|
|
Channel information for an SMB2 READ Request message
|
||
|
|
"""
|
||
|
|
|
||
|
|
SMB2_CHANNEL_NONE = 0x0
|
||
|
|
SMB2_CHANNEL_RDMA_V1 = 0x1
|
||
|
|
SMB2_CHANNEL_RDMA_V1_INVALIDATE = 0x2
|
||
|
|
|
||
|
|
|
||
|
|
class WriteFlags:
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.21 SMB2 WRITE Request Flags
|
||
|
|
Flags to indicate how to process the operation
|
||
|
|
"""
|
||
|
|
|
||
|
|
SMB2_WRITEFLAG_WRITE_THROUGH = 0x00000001
|
||
|
|
SMB2_WRITEFLAG_WRITE_UNBUFFERED = 0x00000002
|
||
|
|
|
||
|
|
|
||
|
|
class LockFlags:
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.26.1 SMB2 LOCK Request Flags
|
||
|
|
"""
|
||
|
|
|
||
|
|
SMB2_LOCKFLAG_SHARED_LOCK = 0x1
|
||
|
|
SMB2_LOCKFLAG_EXCLUSIVE_LOCK = 0x2
|
||
|
|
SMB2_LOCKFLAG_UNLOCK = 0x4
|
||
|
|
SMB2_LOCKFLAG_FAIL_IMMEDIATELY = 0x10
|
||
|
|
|
||
|
|
|
||
|
|
class QueryDirectoryFlags:
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.33 SMB2 QUERY_DIRECTORY Request Flags
|
||
|
|
Indicates how the query directory operation MUST be processed.
|
||
|
|
"""
|
||
|
|
|
||
|
|
SMB2_RESTART_SCANS = 0x01
|
||
|
|
SMB2_RETURN_SINGLE_ENTRY = 0x02
|
||
|
|
SMB2_INDEX_SPECIFIED = 0x04
|
||
|
|
SMB2_REOPEN = 0x10
|
||
|
|
|
||
|
|
|
||
|
|
class QueryInfoFlags:
|
||
|
|
"""
|
||
|
|
[MS-SMB2] 2.2.37 SMB2 QUERY_INFO Request - Flags
|
||
|
|
https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/d623b2f7-a5cd-4639-8cc9-71fa7d9f9ba9
|
||
|
|
|
||
|
|
Flags to set on a QUERY_INFO request.
|
||
|
|
"""
|
||
|
|
|
||
|
|
SL_RESTART_SCAN = 0x00000001
|
||
|
|
SL_RETURN_SINGLE_ENTRY = 0x00000002
|
||
|
|
SL_INDEX_SPECIFIED = 0x00000004
|
||
|
|
|
||
|
|
|
||
|
|
class InfoAdditionalInformation:
|
||
|
|
"""
|
||
|
|
[MS-SMB2] 2.2.39 SMB2 SET_INFO Request - AdditionalInformation
|
||
|
|
https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/ee9614c4-be54-4a3c-98f1-769a7032a0e4
|
||
|
|
|
||
|
|
If security information is being set, this value must contains one or more of the following flags.
|
||
|
|
"""
|
||
|
|
|
||
|
|
OWNER_SECURTIY_INFORMATION = 0x00000001
|
||
|
|
GROUP_SECURITY_INFORMATION = 0x00000002
|
||
|
|
DACL_SECURITY_INFORMATION = 0x00000004
|
||
|
|
SACL_SECURITY_INFORMATION = 0x00000008
|
||
|
|
LABEL_SECURITY_INFORMATION = 0x00000010
|
||
|
|
ATTRIBUTE_SECURITY_INFORMATION = 0x00000020
|
||
|
|
SCOPE_SECURITY_INFORMATION = 0x00000040
|
||
|
|
BACKUP_SECURITY_INFORMATION = 0x00010000
|
||
|
|
|
||
|
|
|
||
|
|
class SMB2CreateRequest(Structure):
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.13 SMB2 CREATE Request
|
||
|
|
The SMB2 Create Request packet is sent by a client to request either
|
||
|
|
creation of or access to a file.
|
||
|
|
"""
|
||
|
|
|
||
|
|
COMMAND = Commands.SMB2_CREATE
|
||
|
|
|
||
|
|
def __init__(self):
|
||
|
|
# pep 80 char issues force me to define this here
|
||
|
|
create_con_req = SMB2CreateContextRequest
|
||
|
|
self.fields = OrderedDict(
|
||
|
|
[
|
||
|
|
(
|
||
|
|
"structure_size",
|
||
|
|
IntField(
|
||
|
|
size=2,
|
||
|
|
default=57,
|
||
|
|
),
|
||
|
|
),
|
||
|
|
("security_flags", IntField(size=1)),
|
||
|
|
("requested_oplock_level", EnumField(size=1, enum_type=RequestedOplockLevel)),
|
||
|
|
("impersonation_level", EnumField(size=4, enum_type=ImpersonationLevel)),
|
||
|
|
("smb_create_flags", IntField(size=8)),
|
||
|
|
("reserved", IntField(size=8)),
|
||
|
|
("desired_access", IntField(size=4)),
|
||
|
|
("file_attributes", IntField(size=4)),
|
||
|
|
("share_access", FlagField(size=4, flag_type=ShareAccess)),
|
||
|
|
("create_disposition", EnumField(size=4, enum_type=CreateDisposition)),
|
||
|
|
("create_options", FlagField(size=4, flag_type=CreateOptions)),
|
||
|
|
("name_offset", IntField(size=2, default=120)), # (header size 64) + (structure size 56)
|
||
|
|
("name_length", IntField(size=2, default=SMB2CreateRequest._name_length)),
|
||
|
|
("create_contexts_offset", IntField(size=4, default=SMB2CreateRequest._create_contexts_offset)),
|
||
|
|
("create_contexts_length", IntField(size=4, default=lambda s: len(s["buffer_contexts"]))),
|
||
|
|
# Technically these are all under buffer but we split it to make
|
||
|
|
# things easier
|
||
|
|
(
|
||
|
|
"buffer_path",
|
||
|
|
BytesField(
|
||
|
|
size=SMB2CreateRequest._buffer_path_size,
|
||
|
|
),
|
||
|
|
),
|
||
|
|
(
|
||
|
|
"padding",
|
||
|
|
BytesField(size=SMB2CreateRequest._padding_size, default=SMB2CreateRequest._default_padding_size),
|
||
|
|
),
|
||
|
|
(
|
||
|
|
"buffer_contexts",
|
||
|
|
ListField(
|
||
|
|
size=lambda s: s["create_contexts_length"].get_value(),
|
||
|
|
list_type=StructureField(structure_type=create_con_req),
|
||
|
|
unpack_func=SMB2CreateRequest._buffer_context_list,
|
||
|
|
),
|
||
|
|
),
|
||
|
|
]
|
||
|
|
)
|
||
|
|
super().__init__()
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _name_length(structure):
|
||
|
|
buffer_path = structure["buffer_path"].get_value()
|
||
|
|
return len(buffer_path) if buffer_path != b"\x00\x00" else 0
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _create_contexts_offset(structure):
|
||
|
|
if len(structure["buffer_contexts"]) == 0:
|
||
|
|
return 0
|
||
|
|
else:
|
||
|
|
return structure["name_offset"].get_value() + len(structure["padding"]) + len(structure["buffer_path"])
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _buffer_path_size(structure):
|
||
|
|
name_length = structure["name_length"].get_value()
|
||
|
|
return name_length if name_length != 0 else 2
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _padding_size(structure):
|
||
|
|
# no padding is needed if there are no contexts
|
||
|
|
if structure["create_contexts_length"].get_value() == 0:
|
||
|
|
return 0
|
||
|
|
|
||
|
|
mod = len(structure["buffer_path"]) % 8
|
||
|
|
return 0 if mod == 0 else 8 - mod
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _default_padding_size(structure):
|
||
|
|
return b"\x00" * SMB2CreateRequest._padding_size(structure)
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _buffer_context_list(structure, data):
|
||
|
|
context_list = []
|
||
|
|
last_context = data == b""
|
||
|
|
while not last_context:
|
||
|
|
create_context = SMB2CreateContextRequest()
|
||
|
|
data = create_context.unpack(data)
|
||
|
|
context_list.append(create_context)
|
||
|
|
last_context = create_context["next"].get_value() == 0
|
||
|
|
|
||
|
|
return context_list
|
||
|
|
|
||
|
|
|
||
|
|
class SMB2CreateResponse(Structure):
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.14 SMB2 CREATE Response
|
||
|
|
The SMB2 Create Response packet is sent by the server to an SMB2 CREATE
|
||
|
|
Request.
|
||
|
|
"""
|
||
|
|
|
||
|
|
COMMAND = Commands.SMB2_CREATE
|
||
|
|
|
||
|
|
def __init__(self):
|
||
|
|
create_con_req = SMB2CreateContextRequest
|
||
|
|
self.fields = OrderedDict(
|
||
|
|
[
|
||
|
|
("structure_size", IntField(size=2, default=89)),
|
||
|
|
("oplock_level", EnumField(size=1, enum_type=RequestedOplockLevel)),
|
||
|
|
("flag", FlagField(size=1, flag_type=FileFlags)),
|
||
|
|
("create_action", EnumField(size=4, enum_type=CreateAction)),
|
||
|
|
("creation_time", DateTimeField(size=8)),
|
||
|
|
("last_access_time", DateTimeField(size=8)),
|
||
|
|
("last_write_time", DateTimeField(size=8)),
|
||
|
|
("change_time", DateTimeField(size=8)),
|
||
|
|
("allocation_size", IntField(size=8)),
|
||
|
|
("end_of_file", IntField(size=8)),
|
||
|
|
(
|
||
|
|
"file_attributes",
|
||
|
|
FlagField(
|
||
|
|
size=4,
|
||
|
|
flag_type=FileAttributes,
|
||
|
|
flag_strict=False,
|
||
|
|
),
|
||
|
|
),
|
||
|
|
("reserved2", IntField(size=4)),
|
||
|
|
("file_id", BytesField(size=16)),
|
||
|
|
("create_contexts_offset", IntField(size=4, default=SMB2CreateResponse._create_contexts_offset)),
|
||
|
|
("create_contexts_length", IntField(size=4, default=lambda s: len(s["buffer"]))),
|
||
|
|
(
|
||
|
|
"buffer",
|
||
|
|
ListField(
|
||
|
|
size=lambda s: s["create_contexts_length"].get_value(),
|
||
|
|
list_type=StructureField(structure_type=create_con_req),
|
||
|
|
unpack_func=SMB2CreateResponse._buffer_context_list,
|
||
|
|
),
|
||
|
|
),
|
||
|
|
]
|
||
|
|
)
|
||
|
|
super().__init__()
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _create_contexts_offset(structure):
|
||
|
|
if len(structure["buffer"]) == 0:
|
||
|
|
return 0
|
||
|
|
else:
|
||
|
|
return 152
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _buffer_context_list(structure, data):
|
||
|
|
context_list = []
|
||
|
|
last_context = data == b""
|
||
|
|
while not last_context:
|
||
|
|
create_context = SMB2CreateContextRequest()
|
||
|
|
data = create_context.unpack(data)
|
||
|
|
context_list.append(create_context)
|
||
|
|
# Manually make sure the final padding is present
|
||
|
|
create_context["padding2"] = b"\x00" * create_context._padding2_size(create_context)
|
||
|
|
last_context = create_context["next"].get_value() == 0
|
||
|
|
|
||
|
|
return context_list
|
||
|
|
|
||
|
|
|
||
|
|
class SMB2CloseRequest(Structure):
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.15 SMB2 CLOSE Request
|
||
|
|
Used by the client to close an instance of a file
|
||
|
|
"""
|
||
|
|
|
||
|
|
COMMAND = Commands.SMB2_CLOSE
|
||
|
|
|
||
|
|
def __init__(self):
|
||
|
|
self.fields = OrderedDict(
|
||
|
|
[
|
||
|
|
("structure_size", IntField(size=2, default=24)),
|
||
|
|
("flags", FlagField(size=2, flag_type=CloseFlags)),
|
||
|
|
("reserved", IntField(size=4)),
|
||
|
|
("file_id", BytesField(size=16)),
|
||
|
|
]
|
||
|
|
)
|
||
|
|
super().__init__()
|
||
|
|
|
||
|
|
|
||
|
|
class SMB2CloseResponse(Structure):
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.16 SMB2 CLOSE Response
|
||
|
|
The response of a SMB2 CLOSE Request
|
||
|
|
"""
|
||
|
|
|
||
|
|
COMMAND = Commands.SMB2_CLOSE
|
||
|
|
|
||
|
|
def __init__(self):
|
||
|
|
self.fields = OrderedDict(
|
||
|
|
[
|
||
|
|
("structure_size", IntField(size=2, default=60)),
|
||
|
|
("flags", FlagField(size=2, flag_type=CloseFlags)),
|
||
|
|
("reserved", IntField(size=4)),
|
||
|
|
("creation_time", DateTimeField()),
|
||
|
|
("last_access_time", DateTimeField()),
|
||
|
|
("last_write_time", DateTimeField()),
|
||
|
|
("change_time", DateTimeField()),
|
||
|
|
("allocation_size", IntField(size=8)),
|
||
|
|
("end_of_file", IntField(size=8)),
|
||
|
|
(
|
||
|
|
"file_attributes",
|
||
|
|
FlagField(
|
||
|
|
size=4,
|
||
|
|
flag_type=FileAttributes,
|
||
|
|
flag_strict=False,
|
||
|
|
),
|
||
|
|
),
|
||
|
|
]
|
||
|
|
)
|
||
|
|
super().__init__()
|
||
|
|
|
||
|
|
|
||
|
|
class SMB2FlushRequest(Structure):
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.17 SMB2 FLUSH Request
|
||
|
|
Flush all cached file information for a specified open of a file to the
|
||
|
|
persistent store that backs the file.
|
||
|
|
"""
|
||
|
|
|
||
|
|
COMMAND = Commands.SMB2_FLUSH
|
||
|
|
|
||
|
|
def __init__(self):
|
||
|
|
self.fields = OrderedDict(
|
||
|
|
[
|
||
|
|
("structure_size", IntField(size=2, default=24)),
|
||
|
|
("reserved1", IntField(size=2)),
|
||
|
|
("reserved2", IntField(size=4)),
|
||
|
|
("file_id", BytesField(size=16)),
|
||
|
|
]
|
||
|
|
)
|
||
|
|
super().__init__()
|
||
|
|
|
||
|
|
|
||
|
|
class SMB2FlushResponse(Structure):
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.18 SMB2 FLUSH Response
|
||
|
|
SMB2 FLUSH Response packet sent by the server.
|
||
|
|
"""
|
||
|
|
|
||
|
|
COMMAND = Commands.SMB2_FLUSH
|
||
|
|
|
||
|
|
def __init__(self):
|
||
|
|
self.fields = OrderedDict([("structure_size", IntField(size=2, default=4)), ("reserved", IntField(size=2))])
|
||
|
|
super().__init__()
|
||
|
|
|
||
|
|
|
||
|
|
class SMB2ReadRequest(Structure):
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.19 SMB2 READ Request
|
||
|
|
The request is used to run a read operation on the file specified.
|
||
|
|
"""
|
||
|
|
|
||
|
|
COMMAND = Commands.SMB2_READ
|
||
|
|
|
||
|
|
def __init__(self):
|
||
|
|
self.fields = OrderedDict(
|
||
|
|
[
|
||
|
|
("structure_size", IntField(size=2, default=49)),
|
||
|
|
("padding", IntField(size=1)),
|
||
|
|
("flags", FlagField(size=1, flag_type=ReadFlags)),
|
||
|
|
("length", IntField(size=4)),
|
||
|
|
("offset", IntField(size=8)),
|
||
|
|
("file_id", BytesField(size=16)),
|
||
|
|
("minimum_count", IntField(size=4)),
|
||
|
|
("channel", FlagField(size=4, flag_type=ReadWriteChannel)),
|
||
|
|
("remaining_bytes", IntField(size=4)),
|
||
|
|
("read_channel_info_offset", IntField(size=2, default=SMB2ReadRequest._get_read_channel_info_offset)),
|
||
|
|
("read_channel_info_length", IntField(size=2, default=SMB2ReadRequest._get_read_channel_info_length)),
|
||
|
|
("buffer", BytesField(size=SMB2ReadRequest._get_buffer_length, default=b"\x00")),
|
||
|
|
]
|
||
|
|
)
|
||
|
|
super().__init__()
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _get_read_channel_info_offset(structure):
|
||
|
|
if structure["channel"].get_value() == 0:
|
||
|
|
return 0
|
||
|
|
else:
|
||
|
|
return 64 + structure["structure_size"].get_value() - 1
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _get_read_channel_info_length(structure):
|
||
|
|
if structure["channel"].get_value() == 0:
|
||
|
|
return 0
|
||
|
|
else:
|
||
|
|
return len(structure["buffer"].get_value())
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _get_buffer_length(structure):
|
||
|
|
# buffer should contain 1 byte of \x00 and not be empty
|
||
|
|
if structure["channel"].get_value() == 0:
|
||
|
|
return 1
|
||
|
|
else:
|
||
|
|
return structure["read_channel_info_length"].get_value()
|
||
|
|
|
||
|
|
|
||
|
|
class SMB2ReadResponse(Structure):
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.20 SMB2 READ Response
|
||
|
|
Response to an SMB2 READ Request.
|
||
|
|
"""
|
||
|
|
|
||
|
|
COMMAND = Commands.SMB2_READ
|
||
|
|
|
||
|
|
def __init__(self):
|
||
|
|
self.fields = OrderedDict(
|
||
|
|
[
|
||
|
|
("structure_size", IntField(size=2, default=17)),
|
||
|
|
("data_offset", IntField(size=1)),
|
||
|
|
("reserved", IntField(size=1)),
|
||
|
|
("data_length", IntField(size=4, default=lambda s: len(s["buffer"]))),
|
||
|
|
("data_remaining", IntField(size=4)),
|
||
|
|
("reserved2", IntField(size=4)),
|
||
|
|
("buffer", BytesField(size=lambda s: s["data_length"].get_value())),
|
||
|
|
]
|
||
|
|
)
|
||
|
|
super().__init__()
|
||
|
|
|
||
|
|
|
||
|
|
class SMB2WriteRequest(Structure):
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.21 SMB2 WRITE Request
|
||
|
|
A write packet to sent to an open file or named pipe on the server
|
||
|
|
"""
|
||
|
|
|
||
|
|
COMMAND = Commands.SMB2_WRITE
|
||
|
|
|
||
|
|
def __init__(self):
|
||
|
|
self.fields = OrderedDict(
|
||
|
|
[
|
||
|
|
("structure_size", IntField(size=2, default=49)),
|
||
|
|
(
|
||
|
|
"data_offset",
|
||
|
|
IntField(size=2, default=0x70), # offset to the buffer field # seems to be hardcoded to this value
|
||
|
|
),
|
||
|
|
("length", IntField(size=4, default=lambda s: len(s["buffer"]))),
|
||
|
|
("offset", IntField(size=8)), # the offset in the file of the data
|
||
|
|
("file_id", BytesField(size=16)),
|
||
|
|
("channel", FlagField(size=4, flag_type=ReadWriteChannel)),
|
||
|
|
("remaining_bytes", IntField(size=4)),
|
||
|
|
(
|
||
|
|
"write_channel_info_offset",
|
||
|
|
IntField(size=2, default=SMB2WriteRequest._get_write_channel_info_offset),
|
||
|
|
),
|
||
|
|
("write_channel_info_length", IntField(size=2, default=lambda s: len(s["buffer_channel_info"]))),
|
||
|
|
("flags", FlagField(size=4, flag_type=WriteFlags)),
|
||
|
|
("buffer", BytesField(size=lambda s: s["length"].get_value())),
|
||
|
|
("buffer_channel_info", BytesField(size=lambda s: s["write_channel_info_length"].get_value())),
|
||
|
|
]
|
||
|
|
)
|
||
|
|
super().__init__()
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _get_write_channel_info_offset(structure):
|
||
|
|
if len(structure["buffer_channel_info"]) == 0:
|
||
|
|
return 0
|
||
|
|
else:
|
||
|
|
header_size = 64
|
||
|
|
packet_size = structure["structure_size"].get_value() - 1
|
||
|
|
buffer_size = len(structure["buffer"])
|
||
|
|
return header_size + packet_size + buffer_size
|
||
|
|
|
||
|
|
|
||
|
|
class SMB2WriteResponse(Structure):
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.22 SMB2 WRITE Response
|
||
|
|
The response to the SMB2 WRITE Request sent by the server
|
||
|
|
"""
|
||
|
|
|
||
|
|
COMMAND = Commands.SMB2_WRITE
|
||
|
|
|
||
|
|
def __init__(self):
|
||
|
|
self.fields = OrderedDict(
|
||
|
|
[
|
||
|
|
("structure_size", IntField(size=2, default=17)),
|
||
|
|
("reserved", IntField(size=2)),
|
||
|
|
("count", IntField(size=4)),
|
||
|
|
("remaining", IntField(size=4)),
|
||
|
|
("write_channel_info_offset", IntField(size=2)),
|
||
|
|
("write_channel_info_length", IntField(size=2)),
|
||
|
|
]
|
||
|
|
)
|
||
|
|
super().__init__()
|
||
|
|
|
||
|
|
|
||
|
|
class SMB2QueryDirectoryRequest(Structure):
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.33 QUERY_DIRECTORY Request
|
||
|
|
Used by the client to obtain a directory enumeration on a directory open.
|
||
|
|
"""
|
||
|
|
|
||
|
|
COMMAND = Commands.SMB2_QUERY_DIRECTORY
|
||
|
|
|
||
|
|
def __init__(self):
|
||
|
|
self.fields = OrderedDict(
|
||
|
|
[
|
||
|
|
("structure_size", IntField(size=2, default=33)),
|
||
|
|
("file_information_class", EnumField(size=1, enum_type=FileInformationClass)),
|
||
|
|
("flags", FlagField(size=1, flag_type=QueryDirectoryFlags)),
|
||
|
|
("file_index", IntField(size=4)),
|
||
|
|
("file_id", BytesField(size=16)),
|
||
|
|
("file_name_offset", IntField(size=2, default=lambda s: 0 if len(s["buffer"]) == 0 else 96)),
|
||
|
|
("file_name_length", IntField(size=2, default=lambda s: len(s["buffer"]))),
|
||
|
|
("output_buffer_length", IntField(size=4)),
|
||
|
|
# UTF-16-LE encoded search pattern
|
||
|
|
("buffer", BytesField(size=lambda s: s["file_name_length"].get_value())),
|
||
|
|
]
|
||
|
|
)
|
||
|
|
super().__init__()
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def unpack_response(file_information_class, buffer):
|
||
|
|
"""
|
||
|
|
Pass in the buffer value from the response object to unpack it and
|
||
|
|
return a list of query response structures for the request.
|
||
|
|
|
||
|
|
:param file_information_class: The info class that represents the
|
||
|
|
buffer.
|
||
|
|
:param buffer: The raw bytes value of the SMB2QueryDirectoryResponse
|
||
|
|
buffer field.
|
||
|
|
:return: List of query_info.* structures based on the
|
||
|
|
FileInformationClass used in the initial query request.
|
||
|
|
"""
|
||
|
|
resp_structure = {
|
||
|
|
FileInformationClass.FILE_DIRECTORY_INFORMATION: FileDirectoryInformation,
|
||
|
|
FileInformationClass.FILE_NAMES_INFORMATION: FileNamesInformation,
|
||
|
|
FileInformationClass.FILE_BOTH_DIRECTORY_INFORMATION: FileBothDirectoryInformation,
|
||
|
|
FileInformationClass.FILE_ID_BOTH_DIRECTORY_INFORMATION: FileIdBothDirectoryInformation,
|
||
|
|
FileInformationClass.FILE_FULL_DIRECTORY_INFORMATION: FileFullDirectoryInformation,
|
||
|
|
FileInformationClass.FILE_ID_FULL_DIRECTORY_INFORMATION: FileIdFullDirectoryInformation,
|
||
|
|
}[file_information_class]
|
||
|
|
query_results = []
|
||
|
|
|
||
|
|
current_offset = 0
|
||
|
|
is_next = True
|
||
|
|
while is_next:
|
||
|
|
result = resp_structure()
|
||
|
|
result.unpack(buffer[current_offset:])
|
||
|
|
query_results.append(result)
|
||
|
|
current_offset += result["next_entry_offset"].get_value()
|
||
|
|
is_next = result["next_entry_offset"].get_value() != 0
|
||
|
|
|
||
|
|
return query_results
|
||
|
|
|
||
|
|
|
||
|
|
class SMB2LockElement(Structure):
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.26.1 SMB2 LOCK_ELEMENT Structure
|
||
|
|
"""
|
||
|
|
|
||
|
|
def __init__(self):
|
||
|
|
self.fields = OrderedDict(
|
||
|
|
[
|
||
|
|
("offset", IntField(size=8)),
|
||
|
|
("length", IntField(size=8, unsigned=False)),
|
||
|
|
("flags", FlagField(size=4, flag_type=LockFlags)),
|
||
|
|
("reserved", IntField(size=4, default=0)),
|
||
|
|
]
|
||
|
|
)
|
||
|
|
super(SMB2LockElement, self).__init__()
|
||
|
|
|
||
|
|
|
||
|
|
class SMB2LockRequest(Structure):
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.26 SMB2 LOCK Request
|
||
|
|
"""
|
||
|
|
|
||
|
|
COMMAND = Commands.SMB2_LOCK
|
||
|
|
|
||
|
|
def __init__(self):
|
||
|
|
self.fields = OrderedDict(
|
||
|
|
[
|
||
|
|
("structure_size", IntField(size=2, default=48)),
|
||
|
|
("lock_count", IntField(size=2, default=lambda s: len(s["locks"].get_value()))),
|
||
|
|
("lock_sequence", IntField(size=4, default=0)),
|
||
|
|
("file_id", BytesField(size=16)),
|
||
|
|
(
|
||
|
|
"locks",
|
||
|
|
ListField(
|
||
|
|
list_type=StructureField(size=24, structure_type=SMB2LockElement),
|
||
|
|
list_count=lambda s: s["lock_count"].get_value(),
|
||
|
|
),
|
||
|
|
),
|
||
|
|
]
|
||
|
|
)
|
||
|
|
super(SMB2LockRequest, self).__init__()
|
||
|
|
|
||
|
|
|
||
|
|
class SMB2LockResponse(Structure):
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.27 SMB2 LOCK Response
|
||
|
|
"""
|
||
|
|
|
||
|
|
COMMAND = Commands.SMB2_LOCK
|
||
|
|
|
||
|
|
def __init__(self):
|
||
|
|
self.fields = OrderedDict(
|
||
|
|
[
|
||
|
|
("structure_size", IntField(size=2, default=4)),
|
||
|
|
("reserved", IntField(size=2, default=0)),
|
||
|
|
]
|
||
|
|
)
|
||
|
|
super(SMB2LockResponse, self).__init__()
|
||
|
|
|
||
|
|
|
||
|
|
class SMB2QueryDirectoryResponse(Structure):
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
2.2.34 SMB2 QUERY_DIRECTORY Response
|
||
|
|
Response to an SMB2 QUERY_DIRECTORY Request.
|
||
|
|
"""
|
||
|
|
|
||
|
|
COMMAND = Commands.SMB2_QUERY_DIRECTORY
|
||
|
|
|
||
|
|
def __init__(self):
|
||
|
|
self.fields = OrderedDict(
|
||
|
|
[
|
||
|
|
("structure_size", IntField(size=2, default=9)),
|
||
|
|
("output_buffer_offset", IntField(size=2, default=72)),
|
||
|
|
("output_buffer_length", IntField(size=4, default=lambda s: len(s["buffer"]))),
|
||
|
|
# this structure varies based on the requested information class
|
||
|
|
("buffer", BytesField(size=lambda s: s["output_buffer_length"].get_value())),
|
||
|
|
]
|
||
|
|
)
|
||
|
|
super().__init__()
|
||
|
|
|
||
|
|
|
||
|
|
class SMB2QueryInfoRequest(Structure):
|
||
|
|
"""
|
||
|
|
[MS-SMB2] 2.2.37 SMB2 QUERY_INFO Request
|
||
|
|
https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/d623b2f7-a5cd-4639-8cc9-71fa7d9f9ba9
|
||
|
|
|
||
|
|
Sent by a client to request information on a file, named pipe, or underlying volume.
|
||
|
|
"""
|
||
|
|
|
||
|
|
COMMAND = Commands.SMB2_QUERY_INFO
|
||
|
|
|
||
|
|
def __init__(self):
|
||
|
|
self.fields = OrderedDict(
|
||
|
|
[
|
||
|
|
(
|
||
|
|
"structure_size",
|
||
|
|
IntField(
|
||
|
|
size=2,
|
||
|
|
default=41,
|
||
|
|
),
|
||
|
|
),
|
||
|
|
(
|
||
|
|
"info_type",
|
||
|
|
EnumField(
|
||
|
|
size=1,
|
||
|
|
enum_type=InfoType,
|
||
|
|
),
|
||
|
|
),
|
||
|
|
(
|
||
|
|
"file_info_class",
|
||
|
|
EnumField(size=1, enum_type=FileInformationClass, default=FileInformationClass.FILE_NONE),
|
||
|
|
),
|
||
|
|
(
|
||
|
|
"output_buffer_length",
|
||
|
|
IntField(
|
||
|
|
size=4,
|
||
|
|
default=lambda s: 0,
|
||
|
|
),
|
||
|
|
),
|
||
|
|
(
|
||
|
|
"input_buffer_offset",
|
||
|
|
IntField(
|
||
|
|
size=2,
|
||
|
|
default=lambda s: 0 if s["input_buffer_length"].get_value() == 0 else 104,
|
||
|
|
),
|
||
|
|
),
|
||
|
|
("reserved", IntField(size=2)),
|
||
|
|
(
|
||
|
|
"input_buffer_length",
|
||
|
|
IntField(
|
||
|
|
size=4,
|
||
|
|
default=lambda s: len(s["buffer"]),
|
||
|
|
),
|
||
|
|
),
|
||
|
|
("additional_information", IntField(size=4)),
|
||
|
|
(
|
||
|
|
"flags",
|
||
|
|
FlagField(
|
||
|
|
size=4,
|
||
|
|
flag_type=QueryInfoFlags,
|
||
|
|
),
|
||
|
|
),
|
||
|
|
("file_id", BytesField(size=16)),
|
||
|
|
(
|
||
|
|
"buffer",
|
||
|
|
BytesField(
|
||
|
|
size=lambda s: s["input_buffer_length"].get_value(),
|
||
|
|
),
|
||
|
|
),
|
||
|
|
]
|
||
|
|
)
|
||
|
|
super().__init__()
|
||
|
|
|
||
|
|
|
||
|
|
class SMB2QueryInfoResponse(Structure):
|
||
|
|
"""
|
||
|
|
[MS-SMB2] 2.2.38 SMB2 QUERY_INFO Response
|
||
|
|
https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/3b1b3598-a898-44ca-bfac-2dcae065247f
|
||
|
|
|
||
|
|
Sent by the server in response to an SMB2QueryInfoRequest.
|
||
|
|
"""
|
||
|
|
|
||
|
|
COMMAND = Commands.SMB2_QUERY_INFO
|
||
|
|
|
||
|
|
def __init__(self):
|
||
|
|
self.fields = OrderedDict(
|
||
|
|
[
|
||
|
|
(
|
||
|
|
"structure_size",
|
||
|
|
IntField(
|
||
|
|
size=2,
|
||
|
|
default=9,
|
||
|
|
),
|
||
|
|
),
|
||
|
|
(
|
||
|
|
"output_buffer_offset",
|
||
|
|
IntField(
|
||
|
|
size=2,
|
||
|
|
default=72,
|
||
|
|
),
|
||
|
|
),
|
||
|
|
(
|
||
|
|
"output_buffer_length",
|
||
|
|
IntField(
|
||
|
|
size=4,
|
||
|
|
default=lambda s: len(s["buffer"]),
|
||
|
|
),
|
||
|
|
),
|
||
|
|
(
|
||
|
|
"buffer",
|
||
|
|
BytesField(
|
||
|
|
size=lambda s: s["output_buffer_length"].get_value(),
|
||
|
|
),
|
||
|
|
),
|
||
|
|
]
|
||
|
|
)
|
||
|
|
super().__init__()
|
||
|
|
|
||
|
|
def parse_buffer(self, file_info_type):
|
||
|
|
buffer = self["buffer"].get_value()
|
||
|
|
|
||
|
|
def unpack_list(buffer, byte_boundary):
|
||
|
|
info_list = []
|
||
|
|
while buffer:
|
||
|
|
entry = file_info_type()
|
||
|
|
buffer = entry.unpack(buffer)
|
||
|
|
|
||
|
|
padded_size = len(entry) % byte_boundary
|
||
|
|
buffer_offset = (byte_boundary - padded_size) if padded_size else 0
|
||
|
|
buffer = buffer[buffer_offset:]
|
||
|
|
|
||
|
|
info_list.append(entry)
|
||
|
|
|
||
|
|
return info_list
|
||
|
|
|
||
|
|
file_obj = file_info_type()
|
||
|
|
if isinstance(file_obj, FileFullEaInformation):
|
||
|
|
return unpack_list(buffer, 4)
|
||
|
|
elif isinstance(file_obj, FileStreamInformation):
|
||
|
|
return unpack_list(buffer, 8)
|
||
|
|
else:
|
||
|
|
file_obj.unpack(buffer)
|
||
|
|
return file_obj
|
||
|
|
|
||
|
|
|
||
|
|
class SMB2SetInfoRequest(Structure):
|
||
|
|
"""
|
||
|
|
[MS-SMB2] 2.2.39 SMB2 SET_INFO Request
|
||
|
|
https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/ee9614c4-be54-4a3c-98f1-769a7032a0e4
|
||
|
|
|
||
|
|
Sent by a client to set information on a file or underlying object store.
|
||
|
|
"""
|
||
|
|
|
||
|
|
COMMAND = Commands.SMB2_SET_INFO
|
||
|
|
|
||
|
|
def __init__(self):
|
||
|
|
self.fields = OrderedDict(
|
||
|
|
[
|
||
|
|
(
|
||
|
|
"structure_size",
|
||
|
|
IntField(
|
||
|
|
size=2,
|
||
|
|
default=33,
|
||
|
|
),
|
||
|
|
),
|
||
|
|
(
|
||
|
|
"info_type",
|
||
|
|
EnumField(
|
||
|
|
size=1,
|
||
|
|
enum_type=InfoType,
|
||
|
|
),
|
||
|
|
),
|
||
|
|
(
|
||
|
|
"file_info_class",
|
||
|
|
EnumField(size=1, enum_type=FileInformationClass, default=FileInformationClass.FILE_NONE),
|
||
|
|
),
|
||
|
|
(
|
||
|
|
"buffer_length",
|
||
|
|
IntField(
|
||
|
|
size=4,
|
||
|
|
default=lambda s: len(s["buffer"]),
|
||
|
|
),
|
||
|
|
),
|
||
|
|
("buffer_offset", IntField(size=2, default=96)),
|
||
|
|
("reserved", IntField(size=2)),
|
||
|
|
(
|
||
|
|
"additional_information",
|
||
|
|
FlagField(
|
||
|
|
size=4,
|
||
|
|
flag_type=InfoAdditionalInformation,
|
||
|
|
),
|
||
|
|
),
|
||
|
|
("file_id", BytesField(size=16)),
|
||
|
|
("buffer", BytesField(size=lambda s: s["buffer_length"].get_value())),
|
||
|
|
]
|
||
|
|
)
|
||
|
|
super().__init__()
|
||
|
|
|
||
|
|
|
||
|
|
class SMB2SetInfoResponse(Structure):
|
||
|
|
"""
|
||
|
|
[MS-SMB2] 2.2.40 SMB2 SET_INFO Response
|
||
|
|
https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/c4318eb4-bdab-49b7-9352-abd7005c7f19
|
||
|
|
|
||
|
|
Sent by the server in response to an SMB2SetInfoRequest to notify the client that its request has been successfully
|
||
|
|
processed.
|
||
|
|
"""
|
||
|
|
|
||
|
|
COMMAND = Commands.SMB2_SET_INFO
|
||
|
|
|
||
|
|
def __init__(self):
|
||
|
|
self.fields = OrderedDict(
|
||
|
|
[
|
||
|
|
("structure_size", IntField(size=2, default=2)),
|
||
|
|
]
|
||
|
|
)
|
||
|
|
super().__init__()
|
||
|
|
|
||
|
|
|
||
|
|
class Open:
|
||
|
|
# MS-SMB2 3.2.4.1.4 ChainedFileId: 0xFF * 16 signals "use the Open
|
||
|
|
# from the most recent CREATE in this related-compound chain".
|
||
|
|
_RELATED_COMPOUND_FILE_ID = b"\xff" * 16
|
||
|
|
|
||
|
|
def __init__(self, tree, name):
|
||
|
|
"""
|
||
|
|
[MS-SMB2] v53.0 2017-09-15
|
||
|
|
|
||
|
|
3.2.1.6 Per Application Open of a File
|
||
|
|
Attributes per each open of a file. A file can be a File, Pipe,
|
||
|
|
Directory, or Printer
|
||
|
|
|
||
|
|
:param tree: The Tree (share) the file is located in.
|
||
|
|
:param name: The name of the file, excluding the share path.
|
||
|
|
"""
|
||
|
|
# properties available based on the file itself
|
||
|
|
self._connected = False
|
||
|
|
self.create_action = None
|
||
|
|
self.creation_time = None
|
||
|
|
self.last_access_time = None
|
||
|
|
self.last_write_time = None
|
||
|
|
self.change_time = None
|
||
|
|
self.allocation_size = None
|
||
|
|
self.end_of_file = None
|
||
|
|
self.file_attributes = None
|
||
|
|
|
||
|
|
# properties used privately
|
||
|
|
self.file_id = self._RELATED_COMPOUND_FILE_ID
|
||
|
|
self.tree_connect = tree
|
||
|
|
self.connection = tree.session.connection
|
||
|
|
self.oplock_level = None
|
||
|
|
self.durable = None
|
||
|
|
self.file_name = name
|
||
|
|
self.resilient_handle = None
|
||
|
|
self.last_disconnect_time = None
|
||
|
|
self.resilient_timeout = None
|
||
|
|
|
||
|
|
# an array of entries used to maintain information about outstanding
|
||
|
|
# lock and unlock operations performed on resilient Opens. Contains
|
||
|
|
# sequence_number - 4-bit integer modulo 16
|
||
|
|
# free - boolean value where False is no outstanding requests
|
||
|
|
self.operation_buckets = []
|
||
|
|
|
||
|
|
# SMB 3.x+
|
||
|
|
self.durable_timeout = None
|
||
|
|
|
||
|
|
# Table of outstanding requests, lookup by Request.cancel_id,
|
||
|
|
# message_id
|
||
|
|
self.outstanding_requests = {}
|
||
|
|
|
||
|
|
self.create_guid = None
|
||
|
|
self.is_persistent = None
|
||
|
|
self.desired_access = None
|
||
|
|
self.share_mode = None
|
||
|
|
self.create_options = None
|
||
|
|
self.file_attributes = None
|
||
|
|
self.create_disposition = None
|
||
|
|
|
||
|
|
@property
|
||
|
|
def connected(self):
|
||
|
|
return self._connected
|
||
|
|
|
||
|
|
def create(
|
||
|
|
self,
|
||
|
|
impersonation_level,
|
||
|
|
desired_access,
|
||
|
|
file_attributes,
|
||
|
|
share_access,
|
||
|
|
create_disposition,
|
||
|
|
create_options,
|
||
|
|
create_contexts=None,
|
||
|
|
oplock_level=RequestedOplockLevel.SMB2_OPLOCK_LEVEL_NONE,
|
||
|
|
send=True,
|
||
|
|
):
|
||
|
|
"""
|
||
|
|
This will open the file based on the input parameters supplied. Any
|
||
|
|
file open should also be called with Open.close() when it is finished.
|
||
|
|
|
||
|
|
More details on how each option affects the open process can be found
|
||
|
|
here https://msdn.microsoft.com/en-us/library/cc246502.aspx.
|
||
|
|
|
||
|
|
Supports out of band send function, call this function with send=False
|
||
|
|
to return a tuple of (SMB2CreateRequest, receive_func) instead of
|
||
|
|
sending the the request and waiting for the response. The receive_func
|
||
|
|
can be used to get the response from the server by passing in the
|
||
|
|
Request that was used to sent it out of band.
|
||
|
|
|
||
|
|
:param impersonation_level: (ImpersonationLevel) The type of
|
||
|
|
impersonation level that is issuing the create request.
|
||
|
|
:param desired_access: The level of access that is required of the
|
||
|
|
open. FilePipePrinterAccessMask or DirectoryAccessMask should be
|
||
|
|
used depending on the type of file being opened.
|
||
|
|
:param file_attributes: (FileAttributes) attributes to set on the file
|
||
|
|
being opened, this usually is for opens that creates a file.
|
||
|
|
:param share_access: (ShareAccess) Specifies the sharing mode for the
|
||
|
|
open.
|
||
|
|
:param create_disposition: (CreateDisposition) Defines the action the
|
||
|
|
server MUST take if the file already exists.
|
||
|
|
:param create_options: (CreateOptions) Specifies the options to be
|
||
|
|
applied when creating or opening the file.
|
||
|
|
:param create_contexts: (List<SMB2CreateContextRequest>) List of
|
||
|
|
context request values to be applied to the create.
|
||
|
|
|
||
|
|
Create Contexts are used to encode additional flags and attributes when
|
||
|
|
opening files. More details on create context request values can be
|
||
|
|
found here https://msdn.microsoft.com/en-us/library/cc246504.aspx.
|
||
|
|
|
||
|
|
:param oplock_level: The requested oplock level of the request.
|
||
|
|
:param send: Whether to send the request in the same call or return the
|
||
|
|
message to the caller and the unpack function
|
||
|
|
|
||
|
|
:return: List of context response values or None if there are no
|
||
|
|
context response values. If the context response value is not known
|
||
|
|
to smbprotocol then the list value would be raw bytes otherwise
|
||
|
|
it is a Structure defined in create_contexts.py
|
||
|
|
"""
|
||
|
|
create = SMB2CreateRequest()
|
||
|
|
create["requested_oplock_level"] = oplock_level
|
||
|
|
create["impersonation_level"] = impersonation_level
|
||
|
|
create["desired_access"] = desired_access
|
||
|
|
create["file_attributes"] = file_attributes
|
||
|
|
create["share_access"] = share_access
|
||
|
|
create["create_disposition"] = create_disposition
|
||
|
|
create["create_options"] = create_options
|
||
|
|
if self.file_name == "":
|
||
|
|
create["buffer_path"] = b"\x00\x00"
|
||
|
|
else:
|
||
|
|
create["buffer_path"] = self.file_name.encode("utf-16-le")
|
||
|
|
if create_contexts:
|
||
|
|
create["buffer_contexts"] = SMB2CreateContextRequest.pack_multiple(create_contexts)
|
||
|
|
|
||
|
|
if self.connection.dialect >= Dialects.SMB_3_0_0:
|
||
|
|
self.desired_access = desired_access
|
||
|
|
self.share_mode = share_access
|
||
|
|
self.create_options = create_options
|
||
|
|
self.file_attributes = file_attributes
|
||
|
|
self.create_disposition = create_disposition
|
||
|
|
|
||
|
|
if not send:
|
||
|
|
return create, self._create_response
|
||
|
|
|
||
|
|
log.info(
|
||
|
|
"Session: %s, Tree Connect: %s - sending SMB2 Create Request for file %s",
|
||
|
|
self.tree_connect.session.username,
|
||
|
|
self.tree_connect.share_name,
|
||
|
|
self.file_name,
|
||
|
|
)
|
||
|
|
|
||
|
|
log.debug(create)
|
||
|
|
request = self.connection.send(create, self.tree_connect.session.session_id, self.tree_connect.tree_connect_id)
|
||
|
|
return self._create_response(request)
|
||
|
|
|
||
|
|
def _create_response(self, request):
|
||
|
|
log.info(
|
||
|
|
"Session: %s, Tree Connect: %s - receiving SMB2 Create Response",
|
||
|
|
self.tree_connect.session.username,
|
||
|
|
self.tree_connect.share_name,
|
||
|
|
)
|
||
|
|
response = self.connection.receive(request)
|
||
|
|
create_response = SMB2CreateResponse()
|
||
|
|
create_response.unpack(response["data"].get_value())
|
||
|
|
|
||
|
|
# Manually set the length so the debug log won't fail due to some servers returning a padded value which is not
|
||
|
|
# reflected in the padding2 of the context response.
|
||
|
|
create_response["create_contexts_length"] = len(create_response["buffer"])
|
||
|
|
|
||
|
|
self._connected = True
|
||
|
|
log.debug(create_response)
|
||
|
|
|
||
|
|
self.file_id = create_response["file_id"].get_value()
|
||
|
|
self.tree_connect.session.open_table[self.file_id] = self
|
||
|
|
self.oplock_level = create_response["oplock_level"].get_value()
|
||
|
|
self.durable = False
|
||
|
|
self.resilient_handle = False
|
||
|
|
self.last_disconnect_time = 0
|
||
|
|
|
||
|
|
self.create_action = create_response["create_action"].get_value()
|
||
|
|
self.creation_time = create_response["creation_time"].get_value()
|
||
|
|
self.last_access_time = create_response["last_access_time"].get_value()
|
||
|
|
self.last_write_time = create_response["last_write_time"].get_value()
|
||
|
|
self.change_time = create_response["change_time"].get_value()
|
||
|
|
self.allocation_size = create_response["allocation_size"].get_value()
|
||
|
|
self.end_of_file = create_response["end_of_file"].get_value()
|
||
|
|
self.file_attributes = create_response["file_attributes"].get_value()
|
||
|
|
|
||
|
|
create_contexts_response = None
|
||
|
|
if create_response["create_contexts_length"].get_value() > 0:
|
||
|
|
create_contexts_response = []
|
||
|
|
for context in create_response["buffer"].get_value():
|
||
|
|
create_contexts_response.append(context.get_context_data())
|
||
|
|
|
||
|
|
return create_contexts_response
|
||
|
|
|
||
|
|
def read(self, offset, length, min_length=0, unbuffered=False, wait=True, send=True):
|
||
|
|
"""
|
||
|
|
Reads from an opened file or pipe
|
||
|
|
|
||
|
|
Supports out of band send function, call this function with send=False
|
||
|
|
to return a tuple of (SMB2ReadRequest, receive_func) instead of
|
||
|
|
sending the the request and waiting for the response. The receive_func
|
||
|
|
can be used to get the response from the server by passing in the
|
||
|
|
Request that was used to sent it out of band.
|
||
|
|
|
||
|
|
:param offset: The offset to start the read of the file.
|
||
|
|
:param length: The number of bytes to read from the offset.
|
||
|
|
:param min_length: The minimum number of bytes to be read for a
|
||
|
|
successful operation.
|
||
|
|
:param unbuffered: Whether to the server should cache the read data at
|
||
|
|
intermediate layers, only value for SMB 3.0.2 or newer
|
||
|
|
:param wait: If send=True, whether to wait for a response if
|
||
|
|
STATUS_PENDING was received from the server or fail.
|
||
|
|
:param send: Whether to send the request in the same call or return the
|
||
|
|
message to the caller and the unpack function
|
||
|
|
:return: A byte string of the bytes read
|
||
|
|
"""
|
||
|
|
if length > self.connection.max_read_size:
|
||
|
|
raise SMBException(
|
||
|
|
f"The requested read length {length} is greater than "
|
||
|
|
f"the maximum negotiated read size {self.connection.max_read_size}"
|
||
|
|
)
|
||
|
|
|
||
|
|
read = SMB2ReadRequest()
|
||
|
|
read["length"] = length
|
||
|
|
read["offset"] = offset
|
||
|
|
read["minimum_count"] = min_length
|
||
|
|
read["file_id"] = self.file_id
|
||
|
|
read["padding"] = b"\x50"
|
||
|
|
|
||
|
|
if unbuffered:
|
||
|
|
if self.connection.dialect < Dialects.SMB_3_0_2:
|
||
|
|
raise SMBUnsupportedFeature(
|
||
|
|
self.connection.dialect, Dialects.SMB_3_0_2, "SMB2_READFLAG_READ_UNBUFFERED", True
|
||
|
|
)
|
||
|
|
read["flags"].set_flag(ReadFlags.SMB2_READFLAG_READ_UNBUFFERED)
|
||
|
|
|
||
|
|
if not send:
|
||
|
|
return read, self._read_response
|
||
|
|
|
||
|
|
log.info(
|
||
|
|
"Session: %s, Tree Connect ID: %s - sending SMB2 Read Request for file %s",
|
||
|
|
self.tree_connect.session.username,
|
||
|
|
self.tree_connect.share_name,
|
||
|
|
self.file_name,
|
||
|
|
)
|
||
|
|
log.debug(read)
|
||
|
|
request = self.connection.send(read, self.tree_connect.session.session_id, self.tree_connect.tree_connect_id)
|
||
|
|
return self._read_response(request, wait)
|
||
|
|
|
||
|
|
def _read_response(self, request, wait=True):
|
||
|
|
log.info(
|
||
|
|
"Session: %s, Tree Connect ID: %s - receiving SMB2 Read Response",
|
||
|
|
self.tree_connect.session.username,
|
||
|
|
self.tree_connect.share_name,
|
||
|
|
)
|
||
|
|
response = self.connection.receive(request, wait=wait)
|
||
|
|
read_response = SMB2ReadResponse()
|
||
|
|
read_response.unpack(response["data"].get_value())
|
||
|
|
log.debug(read_response)
|
||
|
|
|
||
|
|
return read_response["buffer"].get_value()
|
||
|
|
|
||
|
|
def write(self, data, offset=0, write_through=False, unbuffered=False, wait=True, send=True):
|
||
|
|
"""
|
||
|
|
Writes data to an opened file.
|
||
|
|
|
||
|
|
Supports out of band send function, call this function with send=False
|
||
|
|
to return a tuple of (SMBWriteRequest, receive_func) instead of
|
||
|
|
sending the the request and waiting for the response. The receive_func
|
||
|
|
can be used to get the response from the server by passing in the
|
||
|
|
Request that was used to sent it out of band.
|
||
|
|
|
||
|
|
:param data: The bytes data to write.
|
||
|
|
:param offset: The offset in the file to write the bytes at
|
||
|
|
:param write_through: Whether written data is persisted to the
|
||
|
|
underlying storage, not valid for SMB 2.0.2.
|
||
|
|
:param unbuffered: Whether to the server should cache the write data at
|
||
|
|
intermediate layers, only value for SMB 3.0.2 or newer
|
||
|
|
:param wait: If send=True, whether to wait for a response if
|
||
|
|
STATUS_PENDING was received from the server or fail.
|
||
|
|
:param send: Whether to send the request in the same call or return the
|
||
|
|
message to the caller and the unpack function
|
||
|
|
:return: The number of bytes written
|
||
|
|
"""
|
||
|
|
data_len = len(data)
|
||
|
|
if data_len > self.connection.max_write_size:
|
||
|
|
raise SMBException(
|
||
|
|
f"The requested write length {data_len} is greater than "
|
||
|
|
f"the maximum negotiated write size {self.connection.max_write_size}"
|
||
|
|
)
|
||
|
|
|
||
|
|
write = SMB2WriteRequest()
|
||
|
|
write["length"] = len(data)
|
||
|
|
write["offset"] = offset
|
||
|
|
write["file_id"] = self.file_id
|
||
|
|
write["buffer"] = data
|
||
|
|
|
||
|
|
if write_through:
|
||
|
|
if self.connection.dialect < Dialects.SMB_2_1_0:
|
||
|
|
raise SMBUnsupportedFeature(
|
||
|
|
self.connection.dialect, Dialects.SMB_2_1_0, "SMB2_WRITEFLAG_WRITE_THROUGH", True
|
||
|
|
)
|
||
|
|
write["flags"].set_flag(WriteFlags.SMB2_WRITEFLAG_WRITE_THROUGH)
|
||
|
|
|
||
|
|
if unbuffered:
|
||
|
|
if self.connection.dialect < Dialects.SMB_3_0_2:
|
||
|
|
raise SMBUnsupportedFeature(
|
||
|
|
self.connection.dialect, Dialects.SMB_3_0_2, "SMB2_WRITEFLAG_WRITE_UNBUFFERED", True
|
||
|
|
)
|
||
|
|
write["flags"].set_flag(WriteFlags.SMB2_WRITEFLAG_WRITE_UNBUFFERED)
|
||
|
|
|
||
|
|
if not send:
|
||
|
|
return write, self._write_response
|
||
|
|
|
||
|
|
log.info(
|
||
|
|
"Session: %s, Tree Connect: %s - sending SMB2 Write Request for file %s",
|
||
|
|
self.tree_connect.session.username,
|
||
|
|
self.tree_connect.share_name,
|
||
|
|
self.file_name,
|
||
|
|
)
|
||
|
|
log.debug(write)
|
||
|
|
request = self.connection.send(write, self.tree_connect.session.session_id, self.tree_connect.tree_connect_id)
|
||
|
|
return self._write_response(request, wait)
|
||
|
|
|
||
|
|
def _write_response(self, request, wait=True):
|
||
|
|
log.info(
|
||
|
|
"Session: %s, Tree Connect: %s - receiving SMB2 Write Response",
|
||
|
|
self.tree_connect.session.username,
|
||
|
|
self.tree_connect.share_name,
|
||
|
|
)
|
||
|
|
response = self.connection.receive(request, wait=wait)
|
||
|
|
write_response = SMB2WriteResponse()
|
||
|
|
write_response.unpack(response["data"].get_value())
|
||
|
|
log.debug(write_response)
|
||
|
|
|
||
|
|
return write_response["count"].get_value()
|
||
|
|
|
||
|
|
def flush(self, send=True):
|
||
|
|
"""
|
||
|
|
A command sent by the client to request that a server flush all cached
|
||
|
|
file information for the opened file.
|
||
|
|
|
||
|
|
Supports out of band send function, call this function with send=False
|
||
|
|
to return a tuple of (SMB2FlushRequest, receive_func) instead of
|
||
|
|
sending the the request and waiting for the response. The receive_func
|
||
|
|
can be used to get the response from the server by passing in the
|
||
|
|
Request that was used to sent it out of band.
|
||
|
|
|
||
|
|
:param send: Whether to send the request in the same call or return the
|
||
|
|
message to the caller and the unpack function
|
||
|
|
:return: The SMB2FlushResponse received from the server
|
||
|
|
"""
|
||
|
|
flush = SMB2FlushRequest()
|
||
|
|
flush["file_id"] = self.file_id
|
||
|
|
|
||
|
|
if not send:
|
||
|
|
return flush, self._flush_response
|
||
|
|
|
||
|
|
log.info(
|
||
|
|
"Session: %s, Tree Connect: %s - sending SMB2 Flush Request for file %s",
|
||
|
|
self.tree_connect.session.username,
|
||
|
|
self.tree_connect.share_name,
|
||
|
|
self.file_name,
|
||
|
|
)
|
||
|
|
log.debug(flush)
|
||
|
|
request = self.connection.send(flush, self.tree_connect.session.session_id, self.tree_connect.tree_connect_id)
|
||
|
|
return self._flush_response(request)
|
||
|
|
|
||
|
|
def _flush_response(self, request):
|
||
|
|
log.info(
|
||
|
|
"Session: %s, Tree Connect: %s - receiving SMB2 Flush Response",
|
||
|
|
self.tree_connect.session.username,
|
||
|
|
self.tree_connect.share_name,
|
||
|
|
)
|
||
|
|
response = self.connection.receive(request)
|
||
|
|
flush_response = SMB2FlushResponse()
|
||
|
|
flush_response.unpack(response["data"].get_value())
|
||
|
|
log.debug(flush_response)
|
||
|
|
return flush_response
|
||
|
|
|
||
|
|
def query_directory(
|
||
|
|
self, pattern, file_information_class, flags=None, file_index=0, max_output=MAX_PAYLOAD_SIZE, send=True
|
||
|
|
):
|
||
|
|
"""
|
||
|
|
Run a Query/Find on an opened directory based on the params passed in.
|
||
|
|
|
||
|
|
Supports out of band send function, call this function with send=False
|
||
|
|
to return a tuple of (SMB2QueryDirectoryRequest, receive_func) instead
|
||
|
|
of sending the the request and waiting for the response. The
|
||
|
|
receive_func can be used to get the response from the server by passing
|
||
|
|
in the Request that was used to sent it out of band.
|
||
|
|
|
||
|
|
:param pattern: The string pattern to use for the query, this pattern
|
||
|
|
format is based on the SMB server but * is usually a wildcard
|
||
|
|
:param file_information_class: FileInformationClass that defines the
|
||
|
|
format of the result that is returned
|
||
|
|
:param flags: QueryDirectoryFlags that control how the operation must
|
||
|
|
be processed.
|
||
|
|
:param file_index: If the flags SMB2_INDEX_SPECIFIED, this is the index
|
||
|
|
the query should resume on, otherwise should be 0
|
||
|
|
:param max_output: The maximum output size, defaulted to the max credit
|
||
|
|
size but can be increased to reduced round trip operations.
|
||
|
|
:param send: Whether to send the request in the same call or return the
|
||
|
|
message to the caller and the unpack function
|
||
|
|
:return: A list of structures defined in query_info.py, the list entry
|
||
|
|
structure is based on the value of file_information_class in the
|
||
|
|
request message
|
||
|
|
"""
|
||
|
|
query = SMB2QueryDirectoryRequest()
|
||
|
|
query["file_information_class"] = file_information_class
|
||
|
|
query["flags"] = flags
|
||
|
|
query["file_index"] = file_index
|
||
|
|
query["file_id"] = self.file_id
|
||
|
|
query["output_buffer_length"] = max_output
|
||
|
|
query["buffer"] = pattern.encode("utf-16-le")
|
||
|
|
|
||
|
|
if not send:
|
||
|
|
return query, self._query_directory_response
|
||
|
|
|
||
|
|
log.info(
|
||
|
|
"Session: %s, Tree Connect: %s - sending SMB2 Query Directory Request for directory %s",
|
||
|
|
self.tree_connect.session.username,
|
||
|
|
self.tree_connect.share_name,
|
||
|
|
self.file_name,
|
||
|
|
)
|
||
|
|
log.debug(query)
|
||
|
|
request = self.connection.send(query, self.tree_connect.session.session_id, self.tree_connect.tree_connect_id)
|
||
|
|
return self._query_directory_response(request)
|
||
|
|
|
||
|
|
def _query_directory_response(self, request):
|
||
|
|
log.info(
|
||
|
|
"Session: %s, Tree Connect: %s - receiving SMB2 Query Response",
|
||
|
|
self.tree_connect.session.username,
|
||
|
|
self.tree_connect.share_name,
|
||
|
|
)
|
||
|
|
response = self.connection.receive(request)
|
||
|
|
query_response = SMB2QueryDirectoryResponse()
|
||
|
|
query_response.unpack(response["data"].get_value())
|
||
|
|
log.debug(query_response)
|
||
|
|
|
||
|
|
query_request = SMB2QueryDirectoryRequest()
|
||
|
|
query_request.unpack(request.message["data"].get_value())
|
||
|
|
file_cl = query_request["file_information_class"].get_value()
|
||
|
|
data = query_response["buffer"].get_value()
|
||
|
|
results = SMB2QueryDirectoryRequest.unpack_response(file_cl, data)
|
||
|
|
return results
|
||
|
|
|
||
|
|
def close(self, get_attributes=False, send=True):
|
||
|
|
"""
|
||
|
|
Closes an opened file.
|
||
|
|
|
||
|
|
Supports out of band send function, call this function with send=False
|
||
|
|
to return a tuple of (SMB2CloseRequest, receive_func) instead of
|
||
|
|
sending the the request and waiting for the response. The receive_func
|
||
|
|
can be used to get the response from the server by passing in the
|
||
|
|
Request that was used to sent it out of band.
|
||
|
|
|
||
|
|
:param get_attributes: (Bool) whether to get the latest attributes on
|
||
|
|
the close and set them on the Open object
|
||
|
|
:param send: Whether to send the request in the same call or return the
|
||
|
|
message to the caller and the unpack function
|
||
|
|
:return: SMB2CloseResponse message received from the server
|
||
|
|
"""
|
||
|
|
# it is already closed and this isn't for an out of band request
|
||
|
|
if not self._connected and send:
|
||
|
|
return
|
||
|
|
|
||
|
|
close = SMB2CloseRequest()
|
||
|
|
|
||
|
|
close["file_id"] = self.file_id
|
||
|
|
if get_attributes:
|
||
|
|
close["flags"] = CloseFlags.SMB2_CLOSE_FLAG_POSTQUERY_ATTRIB
|
||
|
|
|
||
|
|
if not send:
|
||
|
|
return close, self._close_response
|
||
|
|
|
||
|
|
log.info(
|
||
|
|
"Session: %s, Tree Connect: %s - sending SMB2 Close Request for file %s",
|
||
|
|
self.tree_connect.session.username,
|
||
|
|
self.tree_connect.share_name,
|
||
|
|
self.file_name,
|
||
|
|
)
|
||
|
|
log.debug(close)
|
||
|
|
request = self.connection.send(close, self.tree_connect.session.session_id, self.tree_connect.tree_connect_id)
|
||
|
|
return self._close_response(request)
|
||
|
|
|
||
|
|
def _close_response(self, request):
|
||
|
|
log.info(
|
||
|
|
"Session: %s, Tree Connect: %s - receiving SMB2 Close Response",
|
||
|
|
self.tree_connect.session.username,
|
||
|
|
self.tree_connect.share_name,
|
||
|
|
)
|
||
|
|
try:
|
||
|
|
response = self.connection.receive(request)
|
||
|
|
except FileClosed:
|
||
|
|
# already closed server-side
|
||
|
|
return
|
||
|
|
else:
|
||
|
|
c_resp = SMB2CloseResponse()
|
||
|
|
c_resp.unpack(response["data"].get_value())
|
||
|
|
log.debug(c_resp)
|
||
|
|
|
||
|
|
# update the attributes if requested
|
||
|
|
close_request = SMB2CloseRequest()
|
||
|
|
close_request.unpack(request.message["data"].get_value())
|
||
|
|
if close_request["flags"].has_flag(CloseFlags.SMB2_CLOSE_FLAG_POSTQUERY_ATTRIB):
|
||
|
|
self.creation_time = c_resp["creation_time"].get_value()
|
||
|
|
self.last_access_time = c_resp["last_access_time"].get_value()
|
||
|
|
self.last_write_time = c_resp["last_write_time"].get_value()
|
||
|
|
self.change_time = c_resp["change_time"].get_value()
|
||
|
|
self.allocation_size = c_resp["allocation_size"].get_value()
|
||
|
|
self.end_of_file = c_resp["end_of_file"].get_value()
|
||
|
|
self.file_attributes = c_resp["file_attributes"].get_value()
|
||
|
|
return c_resp
|
||
|
|
finally:
|
||
|
|
# file_id may be unregistered (unsent compound) or already removed by a prior close
|
||
|
|
self._connected = False
|
||
|
|
self.tree_connect.session.open_table.pop(self.file_id, None)
|
||
|
|
|
||
|
|
def lock(self, locks, lsn=0, lsi=0, wait=True, send=True):
|
||
|
|
"""
|
||
|
|
Locks or unlocks byte regions of a file.
|
||
|
|
|
||
|
|
Supports out of band send function, call this function with send=False
|
||
|
|
to return a tuple of (SMB2LockRequest, receive_func) instead of
|
||
|
|
sending the the request and waiting for the response. The receive_func
|
||
|
|
can be used to get the response from the server by passing in the
|
||
|
|
Request that was used to sent it out of band.
|
||
|
|
|
||
|
|
:param locks: (List<SMB2LockElement>) byte ranges to lock or unlock
|
||
|
|
:param lsn: LockSequenceNumber. Only used for SMB dialects > 2.0.2
|
||
|
|
:param lsi: LockSequenceIndex. Only used for SMB dialects > 2.0.2
|
||
|
|
:param wait: If send=True, whether to wait for a response if
|
||
|
|
STATUS_PENDING was received from the server or fail.
|
||
|
|
:param send: Whether to send the request in the same call or return the
|
||
|
|
message to the caller and the unpack function
|
||
|
|
:return: SMB2LockResponse message received from the server
|
||
|
|
"""
|
||
|
|
|
||
|
|
lock = SMB2LockRequest()
|
||
|
|
lock["file_id"] = self.file_id
|
||
|
|
lock["locks"] = locks
|
||
|
|
|
||
|
|
if self.connection.dialect > Dialects.SMB_2_0_2:
|
||
|
|
if (lsn < 0) or (lsn > 15):
|
||
|
|
raise ValueError("lsn (LockSequenceNumber) must be between 0 and 15")
|
||
|
|
|
||
|
|
# MS-SMB2 2.2.26 requires that 0 <= lsi <= 64
|
||
|
|
if (lsi < 0) or (lsi > 64):
|
||
|
|
raise ValueError("lsi (LockSequenceIndex) must be between 0 and 64")
|
||
|
|
|
||
|
|
lock["lock_sequence"] = (lsn << 28) + lsi
|
||
|
|
|
||
|
|
if not send:
|
||
|
|
return lock, self._lock_response
|
||
|
|
|
||
|
|
request = self.connection.send(lock, self.tree_connect.session.session_id, self.tree_connect.tree_connect_id)
|
||
|
|
return self._lock_response(request, wait)
|
||
|
|
|
||
|
|
def _lock_response(self, request, wait=True):
|
||
|
|
response = self.connection.receive(request, wait=wait)
|
||
|
|
lock_response = SMB2LockResponse()
|
||
|
|
lock_response.unpack(response["data"].get_value())
|
||
|
|
|
||
|
|
return lock_response
|