ksmbd Aanvalsoppervlak & SMB2/SMB3 Protokol Fuzzing (syzkaller)

Reading time: 8 minutes

Oorsig

Hierdie bladsy som praktiese tegnieke op om die Linux in-kernel SMB-bediener (ksmbd) met syzkaller te oefen en te fuzz. Dit fokus op die uitbreiding van die protokol se aanvalsoppervlak deur konfigurasie, die bou van 'n stateful harness wat SMB2-operasies kan keten, die genereer van grammatika-geldige PDUs, die bevooroordeeling van mutasies na swak-gedekde kodepaaie, en die benutting van syzkaller-funksies soos focus_areas en ANYBLOB. Alhoewel die oorspronklike navorsing spesifieke CVE's opsom, beklemtoon ons hier die herbruikbare metodologie en konkrete snippette wat jy vir jou eie opstellings kan aanpas.

Teikenomvang: SMB2/SMB3 oor TCP. Kerberos en RDMA is doelbewus buite bestek om die harness eenvoudig te hou.

Brei ksmbd-aanvalsoppervlak uit via konfigurasie

By verstek laat 'n minimale ksmbd-opstelling groot dele van die bediener ongetoets. Skakel die volgende funksies in om die bediener deur bykomende parsers/handlers te dwing en dieper kodepaaie te bereik:

• Global-level
• Durable handles
• Server multi-channel
• SMB2 leases
• Per-share-level
• Oplocks (on by default)
• VFS objects

Deur hierdie opsies te aktiveer verhoog die uitvoering in modules soos:

• smb2pdu.c (command parsing/dispatch)
• ndr.c (NDR encode/decode)
• oplock.c (oplock request/break)
• smbacl.c (ACL parsing/enforcement)
• vfs.c (VFS ops)
• vfs_cache.c (lookup cache)

Aantekeninge

• Presiese opsies hang af van jou distro se ksmbd userspace (ksmbd-tools). Hersien /etc/ksmbd/ksmbd.conf en per-share-afdelings om durable handles, leases, oplocks en VFS objects te aktiveer.
• Multi-channel en durable handles verander state machines en lewensduurtens, wat gereeld UAF/refcount/OOB-bugs onder concurrency na vore bring.

Verifikasie en Rate-Limiting-aanpassings vir Fuzzing

SMB3 benodig 'n geldige sessie. Die implementering van Kerberos in harnesses voeg kompleksiteit by, daarom is NTLM/guest vir fuzzing te verkies:

• Laat guest toegang toe en stel map to guest = bad user sodat onbekende gebruikers na GUEST terugval.
• Aanvaar NTLMv2 (patch policy as dit gedeaktiveer is). Dit hou die handshake eenvoudig terwyl dit SMB3-kodepaaie oefen.
• Verwyder streng credit checks tydens eksperimente (post-hardening vir CVE-2024-50285 het simultaneous-op crediting verskerp). Andersins kan rate-limits gefuzzte reekse te vroeg verwerp.
• Verhoog max connections (bv. na 65536) om vroeë verwerping tydens hoë-deursit-fuzzing te voorkom.

Waarskuwing: Hierdie verslappinge is slegs om fuzzing te vergemaklik. Moenie hierdie instellings in produksie gebruik nie.

Stateful Harness: Extract Resources and Chain Requests

SMB is stateful: baie versoeke hang af van identifiseerders wat deur vorige antwoorde teruggegee word (SessionId, TreeID, FileID pairs). Jou harness moet antwoorde parse en IDs binne dieselfde program hergebruik om by dieper handlers uit te kom (bv. smb2_create → smb2_ioctl → smb2_close).

Example snippet to process a response buffer (skipping the +4B NetBIOS PDU length) and cache IDs:

// process response. does not contain +4B PDU length
void process_buffer(int msg_no, const char *buffer, size_t received) {
uint16_t cmd_rsp = u16((const uint8_t *)(buffer + CMD_OFFSET));
switch (cmd_rsp) {
case SMB2_TREE_CONNECT:
if (received >= TREE_ID_OFFSET + sizeof(uint32_t))
tree_id = u32((const uint8_t *)(buffer + TREE_ID_OFFSET));
break;
case SMB2_SESS_SETUP:
// first session setup response carries session_id
if (msg_no == 0x01 && received >= SESSION_ID_OFFSET + sizeof(uint64_t))
session_id = u64((const uint8_t *)(buffer + SESSION_ID_OFFSET));
break;
case SMB2_CREATE:
if (received >= CREATE_VFID_OFFSET + sizeof(uint64_t)) {
persistent_file_id = u64((const uint8_t *)(buffer + CREATE_PFID_OFFSET));
volatile_file_id   = u64((const uint8_t *)(buffer + CREATE_VFID_OFFSET));
}
break;
default:
break;
}
}

Wenke

• Hou een fuzzer-proses wat authentikasie/staat deel: beter stabiliteit en dekking met ksmbd’s globale/sessie-tabelle. syzkaller injekteer steeds concurrency deur ops as async te merk, intern weer uit te voer.
• Syzkaller’s eksperimentele reset_acc_state kan globale staat terugstel maar kan 'n groot vertraging veroorsaak. Gee voorkeur aan stabiliteit en fokus eerder op fuzzing.

Grammatika-gedrewe SMB2-generering (Geldige PDUs)

Vertaal die Microsoft Open Specifications SMB2-strukture na 'n fuzzer-grammatika sodat jou generator struktureel geldige PDUs produseer, wat sistematies dispatchers en IOCTL handlers bereik.

Voorbeeld (SMB2 IOCTL-versoek):

smb2_ioctl_req {
Header_Prefix           SMB2Header_Prefix
Command                 const[0xb, int16]
Header_Suffix           SMB2Header_Suffix
StructureSize           const[57, int16]
Reserved                const[0, int16]
CtlCode                 union_control_codes
PersistentFileId        const[0x4, int64]
VolatileFileId          const[0x0, int64]
InputOffset             offsetof[Input, int32]
InputCount              bytesize[Input, int32]
MaxInputResponse        const[65536, int32]
OutputOffset            offsetof[Output, int32]
OutputCount             len[Output, int32]
MaxOutputResponse       const[65536, int32]
Flags                   int32[0:1]
Reserved2               const[0, int32]
Input                   array[int8]
Output                  array[int8]
} [packed]

Hierdie styl dwing korrekte struktuurgroottes/-verskuiwings af en verbeter beduidend die dekking teenoor blinde mutasie.

Gerigte Fuzzing Met focus_areas

Gebruik syzkaller’s eksperimentele focus_areas om spesifieke funksies/lêers hoër gewig te gee wat tans swak dekking het. Voorbeeld JSON:

{
"focus_areas": [
{"filter": {"functions": ["smb_check_perm_dacl"]}, "weight": 20.0},
{"filter": {"files": ["^fs/smb/server/"]}, "weight": 2.0},
{"weight": 1.0}
]
}

Dit help om geldige ACLs te konstrueer wat arithmetic/overflow paths in smbacl.c tref. Byvoorbeeld, 'n kwaadwillige Security Descriptor met 'n te groot dacloffset reproduseer 'n integer-overflow.

Reproducer-bouer (minimale Python):

def build_sd():
import struct
sd = bytearray(0x14)
sd[0x00] = 0x00; sd[0x01] = 0x00
struct.pack_into('<H', sd, 0x02, 0x0001)
struct.pack_into('<I', sd, 0x04, 0x78)
struct.pack_into('<I', sd, 0x08, 0x00)
struct.pack_into('<I', sd, 0x0C, 0x10000)
struct.pack_into('<I', sd, 0x10, 0xFFFFFFFF)  # dacloffset
while len(sd) < 0x78:
sd += b'A'
sd += b"\x01\x01\x00\x00\x00\x00\x00\x00"  # minimal DACL
sd += b"\xCC" * 64
return bytes(sd)

Deurbreek dekkingsplateaus met ANYBLOB

syzkaller’s anyTypes (ANYBLOB/ANYRES) laat komplekse strukture inklap tot blobs wat generies muteer. Skep 'n nuwe korpus uit openbare SMB pcaps en omskep payloads in syzkaller-programme wat jou pseudo-syscall aanroep (bv., syz_ksmbd_send_req):

# Extract SMB payloads to JSON
# tshark -r smb2_dac_sample.pcap -Y "smb || smb2" -T json -e tcp.payload > packets.json

import json, os
os.makedirs("corpus", exist_ok=True)

with open("packets.json") as f:
data = json.load(f)
# adjust indexing to your tshark JSON structure
packets = [e["_source"]["layers"]["tcp.payload"] for e in data]

for i, pkt in enumerate(packets):
pdu = pkt[0]
pdu_size = len(pdu) // 2  # hex string length → bytes
with open(f"corpus/packet_{i:03d}.txt", "w") as f:
f.write(
f"syz_ksmbd_send_req(&(&(0x7f0000000340))=ANY=[@ANYBLOB=\"{pdu}\"], {hex(pdu_size)}, 0x0, 0x0)"
)

Dit spring die verkenning aan en kan onmiddellik UAFs (bv. in ksmbd_sessions_deregister) veroorsaak, terwyl dit die dekking met 'n paar persent verhoog.

Sanitizers: Verder as KASAN

• KASAN bly die primêre opsporer vir heap bugs (UAF/OOB).
• KCSAN lewer dikwels false positives of low-severity data races in hierdie teiken.
• UBSAN/KUBSAN kan declared-bounds mistakes vang wat KASAN mis weens array-index semantics. Voorbeeld:

id = le32_to_cpu(psid->sub_auth[psid->num_subauth - 1]);
struct smb_sid {
__u8 revision; __u8 num_subauth; __u8 authority[NUM_AUTHS];
__le32 sub_auth[SID_MAX_SUB_AUTHORITIES]; /* sub_auth[num_subauth] */
} __attribute__((packed));

Die instel van num_subauth = 0 veroorsaak 'n in-struct OOB-lees van sub_auth[-1], wat deur UBSAN se declared-bounds-kontroles gevang word.

Deurset en parallelisme aantekeninge

• 'n Enkele fuzzer-proses (gedeelde auth/state) neig om aansienlik meer stabiel te wees vir ksmbd en ontbloot steeds races/UAFs danksy syzkaller se interne async executor.
• Met meerdere VMs kan jy steeds honderde SMB-opdragte per sekonde bereik. Funksievlakdekking van ~60% van fs/smb/server en ~70% van smb2pdu.c is haalbaar, alhoewel staat-oorgang-dekking deur sulke metrieke onderverteenwoordig word.

Praktiese kontrolelys

• Skakel durable handles, leases, multi-channel, oplocks en VFS objects in ksmbd aan.
• Laat guest en map-to-guest toe; aanvaar NTLMv2. Verwyder kredietlimiete en verhoog die maksimum verbindings vir fuzzer-stabiliteit.
• Bou 'n stateful harness wat SessionId/TreeID/FileIDs kas en create → ioctl → close ketting.
• Gebruik 'n grammatika vir SMB2 PDUs om strukturele geldigheid te behou.
• Gebruik focus_areas om swak-gedekte funksies groter gewig te gee (bv. smbacl.c-paadjies soos smb_check_perm_dacl).
• Gebruik ANYBLOB van werklike pcaps as saailinge om plateau's te breek; pak saailinge met syz-db vir hergebruik.
• Hardloop met KASAN + UBSAN; triage UBSAN declared-bounds-verslae sorgvuldig.

Verwysings

• Doyensec – ksmbd Fuzzing (Part 2): https://blog.doyensec.com/2025/09/02/ksmbd-2.html
• syzkaller: https://github.com/google/syzkaller
• ANYBLOB/anyTypes (commit 9fe8aa4): https://github.com/google/syzkaller/commit/9fe8aa4
• Async executor change (commit fd8caa5): https://github.com/google/syzkaller/commit/fd8caa5
• syz-db: https://github.com/google/syzkaller/tree/master/tools/syz-db
• KASAN: https://docs.kernel.org/dev-tools/kasan.html
• UBSAN/KUBSAN: https://docs.kernel.org/dev-tools/ubsan.html
• KCSAN: https://docs.kernel.org/dev-tools/kcsan.html
• Microsoft Open Specifications (SMB): https://learn.microsoft.com/openspecs/
• Wireshark Sample Captures: https://wiki.wireshark.org/SampleCaptures
• Background reading: pwning.tech “Tickling ksmbd: fuzzing SMB in the Linux kernel”; Dongliang Mu’s syzkaller notes