Estructura inicial funcional con documentación en el README.md de la FastAPI

This commit is contained in:
2026-09-25 11:20:50 -03:00
parent edc71742fa
commit 774e227642
2710 changed files with 1012769 additions and 0 deletions

View File

@@ -0,0 +1,399 @@
# Copyright: (c) 2019, Jordan Borean (@jborean93) <jborean93@gmail.com>
# MIT License (see LICENSE or https://opensource.org/licenses/MIT)
import struct
from collections import OrderedDict
from smbprotocol.structure import (
BytesField,
EnumField,
FlagField,
IntField,
ListField,
Structure,
StructureField,
)
class AccessMask:
"""
[MS-DTYP]
2.4.3 ACCESS_MASK
32-bit set of flags that are used to encode the user rights to an object.
This is just a generic setup of access mask flags to set an can vary
from the object being set. When setting the AccessMask on an ACE packet,
any 32-bit value can be used and this is just as a guideline.
"""
GENERIC_READ = 0x80000000
GENERIC_WRITE = 0x40000000
GENERIC_EXECUTE = 0x20000000
GENERIC_ALL = 0x10000000
MAXIMUM_ALLOWED = 0x02000000
ACCESS_SYSTEM_SECURITY = 0x01000000
SYNCHRONIZE = 0x00100000
WRITE_OWNER = 0x00080000
WRITE_DACL = 0x00040000
READ_CONTROL = 0x00020000
DELETE = 0x00010000
class AceType:
"""
[MS-DTYP]
2.4.4.1 ACE_HEADER AceType
The type of ACE in the ACE packet.
"""
# Current only have structures for the first 3
ACCESS_ALLOWED_ACE_TYPE = 0x00
ACCESS_DENIED_ACE_TYPE = 0x01
SYSTEM_AUDIT_ACE_TYPE = 0x02
# No structures are defined for the below
SYSTEM_ALARM_ACE_TYPE = 0x03
ACCESS_ALLOWED_COMPOUND_ACE_TYPE = 0x04
ACCESS_ALLOWED_OBJECT_ACE_TYPE = 0x05
ACCESS_DENIED_OBJECT_ACE_TYPE = 0x06
SYSTEM_AUDIT_OBJECT_ACE_TYPE = 0x07
SYSTEM_ALARM_OBJECT_ACE_TYPE = 0x08
ACCESS_ALLOWED_CALLBACK_ACE_TYPE = 0x09
ACCESS_DENIED_CALLBACK_ACE_TYPE = 0x0A
ACCESS_ALLOWED_CALLBACK_OBJECT_ACE_TYPE = 0x0B
ACCESS_DENIED_CALLBACK_OBJECT_ACE_TYPE = 0x0C
SYSTEM_AUDIT_CALLBACK_ACE_TYPE = 0x0D
SYSTEM_ALARM_CALLBACK_ACE_TYPE = 0x0E
SYSTEM_AUDIT_CALLBACK_OBJECT_ACE_TYPE = 0x0F
SYSTEM_ALARM_CALLBACK_OBJECT_ACE_TYPE = 0x10
SYSTEM_MANDATORY_LABEL_ACE_TYPE = 0x11
SYSTEM_RESOURCE_ATTRIBUTE_ACE_TYPE = 0x12
SYSTEM_SCOPED_POLICY_ID_ACE_TYPE = 0x13
class AceFlags:
"""
[MS-DTYP]
2.4.4.1 ACE_HEADER AceFlags
Controls the ACE specified in the ACE packet.
"""
CONTAINER_INHERIT_ACE = 0x02
FAILED_ACCESS_ACE_FLAG = 0x80
INHERIT_ONLY_ACE = 0x08
INHERITED_ACE = 0x10
NO_PROPAGATE_INHERITY_ACE = 0x04
OBJECT_INHERIT_ACE = 0x01
SUCCESSFUL_ACCESS_ACE_FLAG = 0x40
class AclRevision:
"""
[MS-DTYP]
2.4.5 ACL AclRevision
ACL_REVISION - AceType 0, 1, 2, 3, 11, 12, 13 are valid
ACL_REVISION_DS - AceType 5, 6, 7, 8, 11 are valid (Directory Service)
"""
ACL_REVISION = 0x02
ACL_REVISION_DS = 0x04 # not natively supported yet
class SDControl:
"""
[MS-DTYP]
2.4.6 SECURITY_DESCRIPTOR Control
Specifies control access bit flags.
"""
SELF_RELATIVE = 0x8000
RM_CONTROL_VALID = 0x4000
SACL_PROTECTED = 0x2000
DACL_PROTECTED = 0x1000
SACL_AUTO_INHERITED = 0x0800
DACL_AUTO_INHERITED = 0x0400
SACL_COMPUTED_INHERITANCE_REQUIRED = 0x0200
DACL_COMPUTED_INHERITANCE_REQUIRED = 0x0100
SERVER_SECURITY = 0x0080
DACL_TRUSTED = 0x0040
SACL_DEFAULTED = 0x0020
SACL_PRESENT = 0x0010
DACL_DEFAULTED = 0x0008
DACL_PRESENT = 0x0004
GROUP_DEFAULTED = 0x0002
OWNER_DEFAULTED = 0x0001
NONE = 0x0000
class SIDPacket(Structure):
"""
[MS-DTYP] 2.4.2.2 SID--Packet Representation
The packet representation of the SID type for use by block protocols. While
the values can be set explicitly, it may be easier to use the from_string
function store the byte structure from the string format.
"""
def __init__(self):
self.fields = OrderedDict(
[
("revision", IntField(size=1, default=1)),
("sub_authority_count", IntField(size=1, default=lambda s: len(s["sub_authorities"].get_value()))),
("reserved", IntField(size=2)),
("identifier_authority", IntField(size=4, little_endian=False)),
(
"sub_authorities",
ListField(list_type=IntField(size=4), list_count=lambda s: s["sub_authority_count"].get_value()),
),
]
)
super().__init__()
def __str__(self):
revision = self["revision"].get_value()
id_authority = self["identifier_authority"].get_value()
sub_authorities = self["sub_authorities"].get_value()
authorities_string = "-".join(str(x) for x in sub_authorities)
sid_string = f"S-{revision}-{id_authority}-{authorities_string}"
return sid_string
def from_string(self, sid_string):
"""
Used to set the structure parameters based on the input string
:param sid_string: String of the sid in S-x-x-x-x form
"""
if not sid_string.startswith("S-"):
raise ValueError("A SID string must start with S-")
sid_entries = sid_string.split("-")
if len(sid_entries) < 3:
raise ValueError(
"A SID string must start with S and contain a revision and identifier authority, e.g. S-1-0"
)
revision = int(sid_entries[1])
id_authority = int(sid_entries[2])
sub_authorities = [int(i) for i in sid_entries[3:]]
self["revision"].set_value(revision)
self["identifier_authority"].set_value(id_authority)
self["sub_authorities"] = sub_authorities
class AccessAllowedAce(Structure):
"""
[MS-DTYP] 2.4.4.3 ACCESS_ALLOWED_ACE
Used for the DACL that controls access to an object.
"""
def __init__(self):
self.fields = OrderedDict(
[
("ace_type", EnumField(size=1, default=AceType.ACCESS_ALLOWED_ACE_TYPE, enum_type=AceType)),
("ace_flags", FlagField(size=1, flag_type=AceFlags)),
("ace_size", IntField(size=2, default=lambda s: 8 + len(s["sid"]))),
("mask", FlagField(size=4, flag_type=AccessMask, flag_strict=False)),
("sid", StructureField(structure_type=SIDPacket)),
]
)
super().__init__()
class AccessDeniedAce(Structure):
"""
[MS-DTYP] 2.4.4.4 ACCESS_DENIED_ACE
Used for the DACL that controls denies to an object.
"""
def __init__(self):
self.fields = OrderedDict(
[
("ace_type", EnumField(size=1, default=AceType.ACCESS_DENIED_ACE_TYPE, enum_type=AceType)),
("ace_flags", FlagField(size=1, flag_type=AceFlags)),
("ace_size", IntField(size=2, default=lambda s: 8 + len(s["sid"]))),
("mask", FlagField(size=4, flag_type=AccessMask, flag_strict=False)),
("sid", StructureField(structure_type=SIDPacket)),
]
)
super().__init__()
class SystemAuditAce(Structure):
"""
[MS-DTYP] 2.4.4.10 SYSTEM_AUDIT_ACE
Used for the SACL that specifies what types of access cause system-level
notifications.
"""
def __init__(self):
self.fields = OrderedDict(
[
("ace_type", EnumField(size=1, default=AceType.SYSTEM_AUDIT_ACE_TYPE, enum_type=AceType)),
("ace_flags", FlagField(size=1, flag_type=AceFlags)),
("ace_size", IntField(size=2, default=lambda s: 8 + len(s["sid"]))),
("mask", FlagField(size=4, flag_type=AccessMask, flag_strict=False)),
("sid", StructureField(structure_type=SIDPacket)),
]
)
super().__init__()
class AclPacket(Structure):
"""
[MS-DTYP] 2.4.5 ACL
Access Control List packet is used to specify a list of individual ACEs.
An ACL is said to be in canonical form if:
All explicit ACEs are placed before inherited ACEs
Within the explicit ACEs, deny ACEs come before grant ACEs
Deny ACEs on the object come before deny ACEs on a child or property
Grant ACEs on the object come before grant ACEs on a child or property
Inherited ACEs are placed in the order in which they were inherited
"""
def __init__(self):
self.fields = OrderedDict(
[
("acl_revision", EnumField(size=1, default=AclRevision.ACL_REVISION, enum_type=AclRevision)),
("sbz1", IntField(size=1)),
("acl_size", IntField(size=2, default=lambda s: 8 + len(s["aces"]))),
("ace_count", IntField(size=2, default=lambda s: len(s["aces"].get_value()))),
("sbz2", IntField(size=2)),
(
"aces",
ListField(
list_count=lambda s: s["ace_count"].get_value(),
unpack_func=AclPacket._unpack_aces,
),
),
]
)
super().__init__()
@staticmethod
def _unpack_aces(structure, data):
aces = []
while data != b"" and len(aces) < structure["ace_count"].value:
ace_type = struct.unpack("<B", data[:1])[0]
ace_struct = {
AceType.ACCESS_ALLOWED_ACE_TYPE: AccessAllowedAce(),
AceType.ACCESS_DENIED_ACE_TYPE: AccessDeniedAce(),
AceType.SYSTEM_AUDIT_ACE_TYPE: SystemAuditAce(),
}.get(ace_type, None)
if not ace_struct:
ace_size = struct.unpack("<H", data[2:4])[0]
aces.append(data[:ace_size])
data = data[ace_size:]
else:
ace_struct.unpack(data)
aces.append(ace_struct)
data = data[len(ace_struct) :]
return aces
class SMB2CreateSDBuffer(Structure):
"""
[MS-SMB2] 2.2.13.2.2 SMB2_CREATE_SD_BUFFER
[MS-DTYP] 2.4.6 SECURITY_DESCRIPTOR
Used to apply a security descriptor to a newly created file.
"""
def __init__(self):
self.fields = OrderedDict(
[
("revision", IntField(size=1, default=1)),
("sbz1", IntField(size=1)),
("control", FlagField(size=2, flag_type=SDControl)),
("offset_owner", IntField(size=4)),
("offset_group", IntField(size=4)),
("offset_sacl", IntField(size=4)),
("offset_dacl", IntField(size=4)),
# buffer contains owner_sid, owner_group, sacl and dacl at
# different offset, use get/set_* to get and set the individual
# components instead of touching the buffer directly
("buffer", BytesField()),
]
)
# used to store the buffer values so it can easily be rebuilt
self._buffer = OrderedDict()
super().__init__()
def get_owner(self):
return self._get_sid_from_buffer("offset_owner")
def set_owner(self, sid):
self._buffer["owner"] = sid
self._rebuild_buffer()
def get_group(self):
return self._get_sid_from_buffer("offset_group")
def set_group(self, sid):
self._buffer["group"] = sid
self._rebuild_buffer()
def get_sacl(self):
return self._get_acl_from_buffer("offset_sacl", SDControl.SACL_PRESENT)
def set_sacl(self, acl):
if acl:
self["control"].set_flag(SDControl.SACL_PRESENT)
self._buffer["sacl"] = acl
self._rebuild_buffer()
def get_dacl(self):
return self._get_acl_from_buffer("offset_dacl", SDControl.DACL_PRESENT)
def set_dacl(self, acl):
if acl:
self["control"].set_flag(SDControl.DACL_PRESENT)
self._buffer["dacl"] = acl
self._rebuild_buffer()
def _get_sid_from_buffer(self, offset_field):
offset = self[offset_field].get_value()
if offset == 0:
return None
buffer_data = self["buffer"].get_value()[offset - 20 :]
sid = SIDPacket()
sid.unpack(buffer_data)
return sid
def _get_acl_from_buffer(self, offset_field, flag):
if not self["control"].has_flag(flag):
return None
offset = self[offset_field].get_value() - 20
buffer_data = self["buffer"].get_value()[offset:]
length = struct.unpack("<H", buffer_data[2:4])[0]
data = buffer_data[:length]
acl = AclPacket()
acl.unpack(data)
return acl
def _rebuild_buffer(self):
buffer = b""
offset_count = 20
for field, value in self._buffer.items():
if not value:
continue
offset_field = f"offset_{field}"
field_bytes = value.pack()
buffer += field_bytes
self[offset_field].set_value(offset_count)
offset_count += len(field_bytes)
self["buffer"].set_value(buffer)