ksmbd Aanvalsoppervlak & SMB2/SMB3 Protokol Fuzzing (syzkaller)

Reading time: 8 minutes

Oorsig

Hierdie bladsy abstraheer praktiese tegnieke om die Linux in-kernel SMB-bediener (ksmbd) met syzkaller te oefen en te fuzz. Dit fokus op die uitbreiding van die protokol-aanvalsoppervlak deur konfigurasie, die bou van ’n staatvolle harness wat SMB2-operasies aaneen kan skakel, die genereer van grammar-valid PDUs, die bevooroordeling van mutasies na swak-gedekte kodepaaie, en die benutting van syzkaller-funksies soos focus_areas en ANYBLOB. Terwyl die oorspronklike navorsing spesifieke CVEs opsom, beklemtoon ons hier die herbruikbare metodologie en konkrete snippers wat jy aan jou eie opstellings kan aanpas.

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

Brei ksmbd-aanvalsoppervlak uit via Konfigurasie

By verstek laat ’n minimale ksmbd-opstelling groot gedeeltes van die bediener ongetoets. Skakel die volgende funksies in om die bediener deur addisionele parsers/handlers te bestuur en dieper kodepaaie te bereik:

• Globale vlak
• Durable handles
• Server multi-channel
• SMB2 leases
• Per-share-vlak
• Oplocks (aan standaard)
• VFS objects

Die aktivering van hierdie elemente 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)

Notas

• 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 lewensduur, en laat dikwels UAF/refcount/OOB-bugs onder gelyktydigheid blyk.

Authentication en koersbeperkings-aanpassings vir Fuzzing

SMB3 benodig ’n geldige sessie. Implementering van Kerberos in harnesses verhoog kompleksiteit, dus beveel ons NTLM/guest vir fuzzing aan:

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

Waarskuwing: Hierdie verslappinge is slegs bedoel om fuzzing te vergemaklik. Moet dit nie in produksie gebruik nie.

Staatvolle Harness: Onttrek Hulpbronne en Skakel Versoeke

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

Voorbeeld-snipper om ’n response buffer te verwerk (skipping the +4B NetBIOS PDU length) en ID's te kash:

// 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 authentication/state deel: beter stabiliteit en dekking met ksmbd’s global/session tables. syzkaller injecteer steeds concurrency deur ops as async te merk, en intern te herhaal.
• Syzkaller’s experimental 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 in 'n fuzzer-grammatika sodat jou generator struktureel geldige PDUs produseer, wat sistematies dispatchers en IOCTL handlers bereik.

Voorbeeld (SMB2 IOCTL request):

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/-offsets af en verbeter dramaties die dekking in vergelyking met blind mutation.

Directed Fuzzing With focus_areas

Gebruik syzkaller’s eksperimentele focus_areas om spesifieke funksies/lêers wat tans swak dekking het, meer gewig te gee. 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 aritmetiese/overflow-paaie in smbacl.c tref. Byvoorbeeld, 'n kwaadwillige Security Descriptor met 'n oorgrootte dacloffset reproduseer 'n integer-overflow.

Reproducer builder (minimal 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 dekkingplateauë met ANYBLOB

syzkaller se anyTypes (ANYBLOB/ANYRES) laat toe om komplekse strukture in blobs in te klap wat op 'n generiese wyse 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 gee 'n vlieënde begin aan verkenning en kan onmiddellik UAFs aktiveer (bv. in ksmbd_sessions_deregister), terwyl dit die dekking met 'n paar persent verhoog.

Sanitizers: Verder as KASAN

• KASAN bly die primêre detektor vir heap-bugs (UAF/OOB).
• KCSAN lewer dikwels vals positiewe of data races met lae erns in hierdie teiken.
• UBSAN/KUBSAN kan foute in verklaarde grense opspoor wat KASAN mis as gevolg van array-indeks-semantiek. 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));

Setting num_subauth = 0 triggers an in-struct OOB read of sub_auth[-1], caught by UBSAN’s declared-bounds checks.

Deurset en Parallelisme Aantekeninge

• Een enkele fuzzer-proses (shared auth/state) is geneig om aansienlik meer stabiel te wees vir ksmbd en toon steeds races/UAFs weens syzkaller’s interne async executor.
• Met meerdere VMs kan jy steeds honderde SMB-opdragte per sekonde bereik. Funksievlak-dekking van ongeveer ~60% van fs/smb/server en ~70% van smb2pdu.c is haalbaar, alhoewel staatsoorgang-dekking deur sulke metrieke onderverteenwoordig word.

Praktiese Kontroleslys

• Skakel durable handles, leases, multi-channel, oplocks en VFS objects in ksmbd aan.
• Laat guest en map-to-guest toe; aanvaar NTLMv2. Patch uit credit limits en verhoog max connections vir fuzzer stabiliteit.
• Bou 'n stateful harness wat SessionId/TreeID/FileIDs cache en create → ioctl → close keten.
• Gebruik 'n grammar vir SMB2 PDUs om strukturele geldigheid te behou.
• Gebruik focus_areas om swak-gedekte funksies meer gewig te gee (bv. smbacl.c-paaie soos smb_check_perm_dacl).
• Seed met ANYBLOB uit werklike pcaps om plateaus te breek; pak seeds met syz-db vir hergebruik.
• Draai met KASAN + UBSAN; triage UBSAN declared-bounds verslae versigtig.

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
• Agtergrondlees: pwning.tech “Tickling ksmbd: fuzzing SMB in the Linux kernel”; Dongliang Mu’s syzkaller notes