629 lines
18 KiB
Python
629 lines
18 KiB
Python
# Copyright: (c) 2019, Jordan Borean (@jborean93) <jborean93@gmail.com>
|
|
# MIT License (see LICENSE or https://opensource.org/licenses/MIT)
|
|
|
|
import binascii
|
|
import socket
|
|
from collections import OrderedDict
|
|
|
|
from smbprotocol import Dialects
|
|
from smbprotocol.connection import Capabilities, SecurityMode
|
|
from smbprotocol.header import Commands
|
|
from smbprotocol.structure import (
|
|
BytesField,
|
|
EnumField,
|
|
FlagField,
|
|
IntField,
|
|
ListField,
|
|
Structure,
|
|
StructureField,
|
|
UuidField,
|
|
)
|
|
|
|
|
|
class CtlCode:
|
|
"""
|
|
[MS-SMB2] v53.0 2017-09-15
|
|
|
|
2.2.31 SMB2 IOCTL Request CtlCode
|
|
The control code of the FSCTL_IOCTL method.
|
|
"""
|
|
|
|
FSCTL_DFS_GET_REFERRALS = 0x00060194
|
|
FSCTL_PIPE_PEEK = 0x0011400C
|
|
FSCTL_PIPE_WAIT = 0x00110018
|
|
FSCTL_PIPE_TRANSCEIVE = 0x0011C017
|
|
FSCTL_SRV_COPYCHUNK = 0x001440F2
|
|
FSCTL_SRV_ENUMERATE_SNAPSHOTS = 0x00144064
|
|
FSCTL_SRV_REQUEST_RESUME_KEY = 0x00140078
|
|
FSCTL_SRV_READ_HASH = 0x001441BB
|
|
FSCTL_SRV_COPYCHUNK_WRITE = 0x001480F2
|
|
FSCTL_LMR_REQUEST_RESILIENCY = 0x001401D4
|
|
FSCTL_QUERY_NETWORK_INTERFACE_INFO = 0x001401FC
|
|
FSCTL_SET_REPARSE_POINT = 0x000900A4
|
|
FSCTL_GET_REPARSE_POINT = 0x000900A8
|
|
FSCTL_DELETE_REPARSE_POINT = 0x000900AC
|
|
FSCTL_CREATE_OR_GET_OBJECT_ID = 0x000900C0
|
|
FSCTL_SET_SPARSE = 0x000900C4
|
|
FSCTL_QUERY_ALLOCATED_RANGES = 0x000940CF
|
|
FSCTL_DFS_GET_REFERRALS_EX = 0x000601B0
|
|
FSCTL_SET_ZERO_DATA = 0x000980C8
|
|
FSCTL_FILE_LEVEL_TRIM = 0x00098208
|
|
FSCTL_VALIDATE_NEGOTIATE_INFO = 0x00140204
|
|
|
|
|
|
class IOCTLFlags:
|
|
"""
|
|
[MS-SMB2] v53.0 2017-09-15
|
|
|
|
2.2.31 SMB2 IOCTL Request Flags
|
|
A flag that indicates how to process the operation
|
|
"""
|
|
|
|
SMB2_0_IOCTL_IS_IOCTL = 0x00000000
|
|
SMB2_0_IOCTL_IS_FSCTL = 0x00000001
|
|
|
|
|
|
class HashVersion:
|
|
"""
|
|
[MS-SMB2] v53.0 2017-09-15
|
|
|
|
2.2.31.2 SRV_READ_HASH Request HashVersion
|
|
The version number of the algorithm used to create the Content Information.
|
|
"""
|
|
|
|
SRV_HASH_VER_1 = 0x00000001
|
|
SRV_HASH_VER_2 = 0x00000002
|
|
|
|
|
|
class HashRetrievalType:
|
|
"""
|
|
[MS-SMB2] v53.0 2017-09-15
|
|
|
|
2.2.31.2 SRV_READ_HASH Request HashRetrievalType
|
|
Indicates the nature of the Offset field in am SMB2SrvReadHashRequest
|
|
packet.
|
|
"""
|
|
|
|
SRV_HASH_RETRIEVE_HASH_BASED = 0x00000001
|
|
SRV_HASH_RETRIEVE_FILE_BASED = 0x00000002
|
|
|
|
|
|
class IfCapability:
|
|
"""
|
|
[MS-SMB2] v53.0 2017-09-15
|
|
|
|
2.2.32.5 NETWORK_INTERFACE_INFO Response Capability
|
|
The capabilities of the network interface
|
|
"""
|
|
|
|
RSS_CAPABLE = 0x00000001
|
|
RDMA_CAPABLE = 0x00000002
|
|
|
|
|
|
class SockAddrFamily:
|
|
"""
|
|
[MS-SMB2] v53.0 2017-09-15
|
|
|
|
2.2.32.5.1 SOCKADDR_STORAGE Family
|
|
The address family of the socket.
|
|
"""
|
|
|
|
INTER_NETWORK = 0x0002
|
|
INTER_NETWORK_V6 = 0x0017
|
|
|
|
|
|
class SMB2IOCTLRequest(Structure):
|
|
"""
|
|
[MS-SMB2] v53.0 2017-09-15
|
|
|
|
2.2.31 SMB2 IOCTL Request
|
|
Send by the client to issue an implementation-specific file system control
|
|
or device control command across the network.
|
|
"""
|
|
|
|
COMMAND = Commands.SMB2_IOCTL
|
|
|
|
def __init__(self):
|
|
self.fields = OrderedDict(
|
|
[
|
|
("structure_size", IntField(size=2, default=57)),
|
|
("reserved", IntField(size=2, default=0)),
|
|
(
|
|
"ctl_code",
|
|
EnumField(
|
|
size=4,
|
|
enum_type=CtlCode,
|
|
),
|
|
),
|
|
("file_id", BytesField(size=16)),
|
|
("input_offset", IntField(size=4, default=SMB2IOCTLRequest._buffer_offset_value)),
|
|
(
|
|
"input_count",
|
|
IntField(
|
|
size=4,
|
|
default=lambda s: len(s["buffer"]),
|
|
),
|
|
),
|
|
("max_input_response", IntField(size=4)),
|
|
("output_offset", IntField(size=4, default=SMB2IOCTLRequest._buffer_offset_value)),
|
|
("output_count", IntField(size=4, default=0)),
|
|
("max_output_response", IntField(size=4)),
|
|
(
|
|
"flags",
|
|
EnumField(
|
|
size=4,
|
|
enum_type=IOCTLFlags,
|
|
),
|
|
),
|
|
("reserved2", IntField(size=4, default=0)),
|
|
("buffer", BytesField(size=lambda s: s["input_count"].get_value())),
|
|
]
|
|
)
|
|
super().__init__()
|
|
|
|
@staticmethod
|
|
def _buffer_offset_value(structure):
|
|
# The offset from the beginning of the SMB2 header to the value of the
|
|
# buffer, 0 if no buffer is set
|
|
if len(structure["buffer"]) > 0:
|
|
header_size = 64
|
|
request_size = structure["structure_size"].get_value()
|
|
return header_size + request_size - 1
|
|
else:
|
|
return 0
|
|
|
|
|
|
class SMB2SrvCopyChunkCopy(Structure):
|
|
"""
|
|
[MS-SMB2] v53.0 2017-09-15
|
|
|
|
2.2.31.1 SRV_COPYCHUNK_COPY
|
|
Sent in an SMB2 IOCTL Request by the client to initiate a server-side copy
|
|
of data.
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.fields = OrderedDict(
|
|
[
|
|
("source_key", BytesField(size=24)),
|
|
("chunk_count", IntField(size=4, default=lambda s: len(s["chunks"].get_value()))),
|
|
("reserved", IntField(size=4)),
|
|
(
|
|
"chunks",
|
|
ListField(
|
|
size=lambda s: s["chunk_count"].get_value() * 24,
|
|
list_count=lambda s: s["chunk_count"].get_value(),
|
|
list_type=StructureField(size=24, structure_type=SMB2SrvCopyChunk),
|
|
),
|
|
),
|
|
]
|
|
)
|
|
super().__init__()
|
|
|
|
|
|
class SMB2SrvCopyChunk(Structure):
|
|
"""
|
|
[MS-SMB2] v53.0 2017-09-15
|
|
|
|
2.2.31.1.1 SRC_COPYCHUNK
|
|
Packet sent in the Chunks array of an SRC_COPY_CHUNK_COPY packet to
|
|
describe an individual data range to copy.
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.fields = OrderedDict(
|
|
[
|
|
("source_offset", IntField(size=8)),
|
|
("target_offset", IntField(size=8)),
|
|
("length", IntField(size=4)),
|
|
("reserved", IntField(size=4)),
|
|
]
|
|
)
|
|
super().__init__()
|
|
|
|
|
|
class SMB2SrvReadHashRequest(Structure):
|
|
"""
|
|
[MS-SMB2] v53.0 2017-09-15
|
|
|
|
2.2.31.2 SRC_READ_HASH Request
|
|
Sent by the client in an SMB2 IOCTL Request to retrieve data from the
|
|
Content Information File associated with a specified file.
|
|
Not valid for the SMB 2.0.2 dialect.
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.fields = OrderedDict(
|
|
[
|
|
("hash_type", IntField(size=4, default=1)), # SRV_HASH_TYPE_PEER_DIST
|
|
("hash_version", EnumField(size=4, enum_type=HashVersion)),
|
|
("hash_retrieval_type", EnumField(size=4, enum_type=HashRetrievalType)),
|
|
("length", IntField(size=4)),
|
|
("offset", IntField(size=8)),
|
|
]
|
|
)
|
|
super().__init__()
|
|
|
|
|
|
class SMB2SrvNetworkResiliencyRequest(Structure):
|
|
"""
|
|
[MS-SMB2] v53.0 2017-09-15
|
|
|
|
2.2.31.3 NETWORK_RESILIENCY_REQUEST Request
|
|
Sent by the client to request resiliency for a specified open file.
|
|
Not valid for the SMB 2.0.2 dialect.
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.fields = OrderedDict(
|
|
[
|
|
# timeout is in milliseconds
|
|
("timeout", IntField(size=4)),
|
|
("reserved", IntField(size=4)),
|
|
]
|
|
)
|
|
super().__init__()
|
|
|
|
|
|
class SMB2ValidateNegotiateInfoRequest(Structure):
|
|
"""
|
|
[MS-SMB2] v53.0 2017-09-15
|
|
|
|
2.2.31.4 VALIDATE_NEGOTIATE_INFO Request
|
|
Packet sent to the server to request validation of a previous SMB 2
|
|
NEGOTIATE request.
|
|
Only valid for the SMB 3.0 and 3.0.2 dialects.
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.fields = OrderedDict(
|
|
[
|
|
(
|
|
"capabilities",
|
|
FlagField(
|
|
size=4,
|
|
flag_type=Capabilities,
|
|
),
|
|
),
|
|
("guid", UuidField()),
|
|
(
|
|
"security_mode",
|
|
EnumField(
|
|
size=2,
|
|
enum_type=SecurityMode,
|
|
),
|
|
),
|
|
("dialect_count", IntField(size=2, default=lambda s: len(s["dialects"].get_value()))),
|
|
(
|
|
"dialects",
|
|
ListField(
|
|
size=lambda s: s["dialect_count"].get_value() * 2,
|
|
list_count=lambda s: s["dialect_count"].get_value(),
|
|
list_type=EnumField(size=2, enum_type=Dialects),
|
|
),
|
|
),
|
|
]
|
|
)
|
|
super().__init__()
|
|
|
|
|
|
class SMB2IOCTLResponse(Structure):
|
|
"""
|
|
[MS-SMB2] v53.0 2017-09-15
|
|
|
|
2.2.32 SMB2 IOCTL Response
|
|
Sent by the server to transmit the results of a client SMB2 IOCTL Request.
|
|
"""
|
|
|
|
COMMAND = Commands.SMB2_IOCTL
|
|
|
|
def __init__(self):
|
|
self.fields = OrderedDict(
|
|
[
|
|
("structure_size", IntField(size=2, default=49)),
|
|
("reserved", IntField(size=2, default=0)),
|
|
(
|
|
"ctl_code",
|
|
EnumField(
|
|
size=4,
|
|
enum_type=CtlCode,
|
|
),
|
|
),
|
|
("file_id", BytesField(size=16)),
|
|
("input_offset", IntField(size=4)),
|
|
("input_count", IntField(size=4)),
|
|
("output_offset", IntField(size=4)),
|
|
("output_count", IntField(size=4)),
|
|
("flags", IntField(size=4, default=0)),
|
|
("reserved2", IntField(size=4, default=0)),
|
|
(
|
|
"buffer",
|
|
BytesField(
|
|
size=lambda s: s["output_count"].get_value(),
|
|
),
|
|
),
|
|
]
|
|
)
|
|
super().__init__()
|
|
|
|
|
|
class SMB2SrvCopyChunkResponse(Structure):
|
|
"""
|
|
[MS-SMB2] v53.0 2017-09-15
|
|
|
|
2.2.32.1 SRV_COPYCHUNK_RESPONSE
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.fields = OrderedDict(
|
|
[
|
|
("chunks_written", IntField(size=4)),
|
|
("chunk_bytes_written", IntField(size=4)),
|
|
("total_bytes_written", IntField(size=4)),
|
|
]
|
|
)
|
|
super().__init__()
|
|
|
|
|
|
class SMB2SrvSnapshotArray(Structure):
|
|
"""
|
|
[MS-SMB2] v53.0 2017-09-15
|
|
|
|
2.2.32.2 SRV_SNAPSHOT_ARRAY
|
|
Sent by the server in response to an SMB2IOCTLResponse for the
|
|
FSCTL_SRV_ENUMERATE_SNAPSHOTS request.
|
|
"""
|
|
|
|
def __init__(self):
|
|
# TODO: validate this further when working with actual snapshots
|
|
self.fields = OrderedDict(
|
|
[
|
|
("number_of_snapshots", IntField(size=4)),
|
|
("number_of_snapshots_returned", IntField(size=4)),
|
|
("snapshot_array_size", IntField(size=4)),
|
|
("snapshots", BytesField()),
|
|
]
|
|
)
|
|
super().__init__()
|
|
|
|
|
|
class SMB2SrvRequestResumeKey(Structure):
|
|
"""
|
|
[MS-SMB2] v53.0 2017-09-15
|
|
|
|
2.2.32.3 SRV_REQUEST_RESUME_KEY Response
|
|
Sent by the server in response to an SMB2IOCTLResponse for the
|
|
FSCTL_SRV_REQUEST_RESUME_KEY request.
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.fields = OrderedDict(
|
|
[
|
|
("resume_key", BytesField(size=24)),
|
|
(
|
|
"context_length",
|
|
IntField(
|
|
size=4,
|
|
default=lambda s: len(s["context"]),
|
|
),
|
|
),
|
|
(
|
|
"context",
|
|
BytesField(
|
|
size=lambda s: s["context_length"].get_value(),
|
|
),
|
|
),
|
|
]
|
|
)
|
|
super().__init__()
|
|
|
|
|
|
class SMB2NetworkInterfaceInfo(Structure):
|
|
"""
|
|
[MS-SMB2] v53.0 2017-09-15
|
|
|
|
2.2.32.5 NETWORK_INTERFACE_INFO Response
|
|
The NETWORK_INTERFACE_INFO returned to the client in an SMB2IOCTLResposne
|
|
for the FSCTL_QUERY_NETWORK_INTERFACE_INFO.
|
|
|
|
Use the pack_multiple and unpack_multiple to handle multiple interfaces
|
|
that are returned in the SMB2IOCTLResponse
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.fields = OrderedDict(
|
|
[
|
|
# 0 if no more network interfaces
|
|
("next", IntField(size=4)),
|
|
("if_index", IntField(size=4)),
|
|
("capability", FlagField(size=4, flag_type=IfCapability)),
|
|
("reserved", IntField(size=4)),
|
|
("link_speed", IntField(size=8)),
|
|
("sock_addr_storage", StructureField(size=128, structure_type=SockAddrStorage)),
|
|
]
|
|
)
|
|
super().__init__()
|
|
|
|
@staticmethod
|
|
def pack_multiple(messages):
|
|
"""
|
|
Packs a list of SMB2NetworkInterfaceInfo messages and set's the next
|
|
value accordingly. The byte value returned is then attached to the
|
|
SMBIOCTLResponse message.
|
|
|
|
:param messages: List of SMB2NetworkInterfaceInfo messages
|
|
:return: bytes of the packed messages
|
|
"""
|
|
data = b""
|
|
msg_count = len(messages)
|
|
for i, msg in enumerate(messages):
|
|
if i == msg_count - 1:
|
|
msg["next"] = 0
|
|
else:
|
|
msg["next"] = 152
|
|
data += msg.pack()
|
|
return data
|
|
|
|
@staticmethod
|
|
def unpack_multiple(data):
|
|
"""
|
|
Get's a list of SMB2NetworkInterfaceInfo messages from the byte value
|
|
passed in. This is the raw buffer value that is set on the
|
|
SMB2IOCTLResponse message.
|
|
|
|
:param data: bytes of the messages
|
|
:return: List of SMB2NetworkInterfaceInfo messages
|
|
"""
|
|
chunks = []
|
|
while data:
|
|
info = SMB2NetworkInterfaceInfo()
|
|
data = info.unpack(data)
|
|
chunks.append(info)
|
|
|
|
return chunks
|
|
|
|
|
|
class SockAddrStorage(Structure):
|
|
"""
|
|
[MS-SMB2] v53.0 2017-09-15
|
|
|
|
2.2.32.5.1 SOCKADDR_STORAGE
|
|
Socket Address information.
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.fields = OrderedDict(
|
|
[
|
|
("family", EnumField(size=2, enum_type=SockAddrFamily)),
|
|
(
|
|
"buffer",
|
|
StructureField(
|
|
size=SockAddrStorage._get_buffer_size,
|
|
structure_type=SockAddrStorage._get_buffer_structure_type,
|
|
),
|
|
),
|
|
(
|
|
"reserved",
|
|
BytesField(
|
|
size=SockAddrStorage._get_reserved_size,
|
|
default=SockAddrStorage._default_get_reserved_size,
|
|
),
|
|
),
|
|
]
|
|
)
|
|
super().__init__()
|
|
|
|
@staticmethod
|
|
def _get_buffer_size(structure):
|
|
if structure["family"].get_value() == SockAddrFamily.INTER_NETWORK:
|
|
return 14
|
|
else:
|
|
return 26
|
|
|
|
@staticmethod
|
|
def _get_buffer_structure_type(structure):
|
|
if structure["family"].get_value() == SockAddrFamily.INTER_NETWORK:
|
|
return SockAddrIn
|
|
else:
|
|
return SockAddrIn6
|
|
|
|
@staticmethod
|
|
def _get_reserved_size(structure):
|
|
if structure["family"].get_value() == SockAddrFamily.INTER_NETWORK:
|
|
return 112
|
|
else:
|
|
return 100
|
|
|
|
@staticmethod
|
|
def _default_get_reserved_size(structure):
|
|
return b"\x00" * SockAddrStorage._get_reserved_size(structure)
|
|
|
|
|
|
class SockAddrIn(Structure):
|
|
"""
|
|
[MS-SMB2] v53.0 2017-09-15
|
|
|
|
2.2.32.5.1.1 SOCKADDR_IN
|
|
Socket address information for an IPv4 address
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.fields = OrderedDict(
|
|
[("port", IntField(size=2)), ("ipv4_address", BytesField(size=4)), ("reserved", IntField(size=8))]
|
|
)
|
|
super().__init__()
|
|
|
|
def get_ipaddress(self):
|
|
addr_bytes = self["ipv4_address"].get_value()
|
|
return socket.inet_ntoa(addr_bytes)
|
|
|
|
def set_ipaddress(self, address):
|
|
# set's the ipv4 address field from the address string passed in, this
|
|
# needs to be the full ipv4 address including periods, e.g.
|
|
# 192.168.1.1
|
|
addr_bytes = socket.inet_aton(address)
|
|
self["ipv4_address"].set_value(addr_bytes)
|
|
|
|
|
|
class SockAddrIn6(Structure):
|
|
"""
|
|
[MS-SMB2] v53.0 2017-09-15
|
|
|
|
2.2.32.5.1.2 SOCKADDR_IN6
|
|
Socket address information for an IPv6 address
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.fields = OrderedDict(
|
|
[
|
|
("port", IntField(size=2)),
|
|
("flow_info", IntField(size=4)),
|
|
("ipv6_address", BytesField(size=16)),
|
|
("scope_id", IntField(size=4)),
|
|
]
|
|
)
|
|
super().__init__()
|
|
|
|
def get_ipaddress(self):
|
|
# get's the full IPv6 Address, note this is the full address and has
|
|
# not been concatenated
|
|
addr_bytes = self["ipv6_address"].get_value()
|
|
address = binascii.hexlify(addr_bytes).decode("utf-8")
|
|
return ":".join([address[i : i + 4] for i in range(0, len(address), 4)])
|
|
|
|
def set_ipaddress(self, address):
|
|
# set's the ipv6_address field from the address passed in, note this
|
|
# needs to be the full ipv6 address,
|
|
# e.g. fe80:0000:0000:0000:0000:0000:0000:0000 and not any short form
|
|
address = address.replace(":", "")
|
|
if len(address) != 32:
|
|
raise ValueError("When setting an IPv6 address, it must be in the full form without concatenation")
|
|
self["ipv6_address"].set_value(binascii.unhexlify(address))
|
|
|
|
|
|
class SMB2ValidateNegotiateInfoResponse(Structure):
|
|
"""
|
|
[MS-SMB2] v53.0 2017-09-15
|
|
|
|
2.2.32.6 VALIDATE_NEGOTIATE_INFO Response
|
|
Packet sent by the server on a request validation of SMB 2 negotiate
|
|
request.
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.fields = OrderedDict(
|
|
[
|
|
(
|
|
"capabilities",
|
|
FlagField(
|
|
size=4,
|
|
flag_type=Capabilities,
|
|
),
|
|
),
|
|
("guid", UuidField()),
|
|
("security_mode", EnumField(size=2, enum_type=SecurityMode, enum_strict=False)),
|
|
("dialect", EnumField(size=2, enum_type=Dialects)),
|
|
]
|
|
)
|
|
super().__init__()
|