From nobody Sun Dec 14 14:00:08 2025 Received: from mail-wm1-f51.google.com (mail-wm1-f51.google.com [209.85.128.51]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A38A32652B6 for ; Thu, 4 Dec 2025 14:13:05 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.51 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1764857587; cv=none; b=Wv8rxeIStbWqvNY5W6l+LluIrhEI8RKRfFb5UGxM8IxNdlb3eCjKzk36qIiLYeN1theBdIorunYNFlWXXFIC12v7djEgT0wHrzTw8CrKKljeqJt2MSe+eSzxF2Xet6HX35tAu9CKH9zaNLcx/wlGhqCp8FRVOXeQvg5BsqUx5gk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1764857587; c=relaxed/simple; bh=sPmkDEwwPWrQdJRXFfdzLMoaCivv4pvJuP/ZwzlRc98=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=TQOqduxyqHd7r3shmv4zIpRuHD7uiJ8YstcLbzb/3EZLzOFHBZOF59Tkh8aehVTqc8pmj0UFyARMvMEsYljvvIYy9QAzJSf6SdrOODQtP2SePgAE4zeoJOP4uOFLalpNTMjRbf+e9+A2ZaX5KjCZFifnfOoIWbz6C719iLTomBw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=JuDUMbTz; arc=none smtp.client-ip=209.85.128.51 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="JuDUMbTz" Received: by mail-wm1-f51.google.com with SMTP id 5b1f17b1804b1-477b1cc8fb4so6997595e9.1 for ; Thu, 04 Dec 2025 06:13:05 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1764857584; x=1765462384; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=vvLRPmFVeFXL/FXUoH0yHVRGEwWvQKNGaG9SkVtG73M=; b=JuDUMbTzRHg7EtYfYyfkGNC26E1gxHm3E+RnhS1qsH67E4NPZKcNIx4NJXsUJNnzO5 Z2AjIbuR5Gdf7Mh7d/gRhHwtglZCd3KgJ5dK9cjnWX5nuA0FaxkwDeF0Y+9KGSIPmQ03 Opt5PyrRpDji3+3ynvgaRG04Po2LHlmCJSb1YJ57ua4lSwBUUX1Lv6Ovxk+VRNMTJyjP ze5X0L6KMgFOcj44j8QgAtik7whmf/8IpK2lH5Y9Rz/R2+YXAsmy8klt7roE2EOW9axH cY87Brt8LYuOHYukS3yy/QdBZsOnzHc7U9at16L86H+TVCZd78tbzcsEQGIi5KAM+Mw2 YnuQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1764857584; x=1765462384; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=vvLRPmFVeFXL/FXUoH0yHVRGEwWvQKNGaG9SkVtG73M=; b=Oxo3+JP4UYaKuT/qdQD61Gmu82QTpYdb53sS9DQQ7dyXhfBVyzDYO05VT+MdGiK+2V aItISY7mOVn971sCzlEdWPXYjcPFfnGPbwxxHDG63L/ksassvqs7W2alm7JgbuKGNSTk xpdfPv4y+Z+GcIpN1gOT9pflezVQapqm/S4F06+v+YUrpO/HEPLZXQYfsGuqGBvsG+Vr Y2KR2eeJpPOtZ4gi9KYXET+czH+1occBpQ2YcWXvXC7xWivVHE2H7NTdGwJ6E3x+xKMy 88oM945B+V3mfTd81dBBhY5rf80mS+gDphnRREO/H7qN3TuSmVKansMwwDcm27snoRtO UlHg== X-Forwarded-Encrypted: i=1; AJvYcCX1NHwTpZN5PSEvonSvMUhq4ukcRPlqMlJh+luqGLqEVYh1BThsiPtYeWO76jQPYS2mEwfofIo4mQ7lSNE=@vger.kernel.org X-Gm-Message-State: AOJu0YxIRcOArcc5Rle/rKZPmixwPFgkRtbiLWKYjTFUizsihwBGpPdQ xa8QLWFMXzyK7CaQTterI0BzkfvikMyRWhuti7meRUrYdGS2QxT4W5qc X-Gm-Gg: ASbGnctQUQ97Y+Ugtbba/qZdq9Xe7eRwakphcwmCGuHsixuN/GDGvYfzebVlFKSccBy 6tr5swHwoifJ71wRbgFbpGgtVb2xnSGcVPVEL/GEjSwXqV/zXryxv44k04vSMcHncLRK8QnmLuL VnIfHOVJWQiZxp/PiAvjjtWwZoC0DotDYDnJeAIO1J/eGoaKat4j5KmMxfPPCa6DGwX4RRNSaXu kX/RnnneYu6PHYVEIaBWlVBB2LE7wKsMaIW6EI0wx64i/0BhPRXPze8BE5vvp6Vr9A24tIN+hcY Oe+cYtAQFAkYA50pKUNQ2r8QusU36MrPSdxWuooHjtcFAEyppI1Xqb01YsPQXdTiWDl5ru5+YgQ KJsSb8GhGr5S12EbZw8e+tmieTji0okN/eaR3SBu4aY7Isz2bmEdge5e6fiXxGY8uYWyOO8XiPV +Xwv+LuepiW/4DrbG/9yOCQH+gN8/R2qKFQ5936ae+pVKZVFkbL7C8rQMg8+iobQ2Vpw== X-Google-Smtp-Source: AGHT+IHVRlhcJRejGEsgP4K4cLss0ObE1mVBCmN6UHr1S399d5qS3NN/eNqDmcGxbLusiL5cPl9foQ== X-Received: by 2002:a05:600c:3545:b0:46e:74cc:42b8 with SMTP id 5b1f17b1804b1-4792f3860e4mr28572475e9.17.1764857583596; Thu, 04 Dec 2025 06:13:03 -0800 (PST) Received: from ethan-tp.d.ethz.ch (2001-67c-10ec-5744-8000--626.net6.ethz.ch. [2001:67c:10ec:5744:8000::626]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-42f7cbfeae9sm3605808f8f.13.2025.12.04.06.13.02 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 04 Dec 2025 06:13:03 -0800 (PST) From: Ethan Graham To: ethan.w.s.graham@gmail.com, glider@google.com Cc: andreyknvl@gmail.com, andy@kernel.org, andy.shevchenko@gmail.com, brauner@kernel.org, brendan.higgins@linux.dev, davem@davemloft.net, davidgow@google.com, dhowells@redhat.com, dvyukov@google.com, elver@google.com, herbert@gondor.apana.org.au, ignat@cloudflare.com, jack@suse.cz, jannh@google.com, johannes@sipsolutions.net, kasan-dev@googlegroups.com, kees@kernel.org, kunit-dev@googlegroups.com, linux-crypto@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org, lukas@wunner.de, rmoar@google.com, shuah@kernel.org, sj@kernel.org, tarasmadan@google.com, Ethan Graham Subject: [PATCH 01/10] mm/kasan: implement kasan_poison_range Date: Thu, 4 Dec 2025 15:12:40 +0100 Message-ID: <20251204141250.21114-2-ethan.w.s.graham@gmail.com> X-Mailer: git-send-email 2.51.0 In-Reply-To: <20251204141250.21114-1-ethan.w.s.graham@gmail.com> References: <20251204141250.21114-1-ethan.w.s.graham@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Ethan Graham Introduce a new helper function, kasan_poison_range(), to encapsulate the logic for poisoning an arbitrary memory range of a given size, and expose it publically in . This is a preparatory change for the upcoming KFuzzTest patches, which requires the ability to poison the inter-region padding in its input buffers. No functional change to any other subsystem is intended by this commit. Signed-off-by: Ethan Graham Signed-off-by: Ethan Graham Reviewed-by: Alexander Potapenko --- PR v3: - Move kasan_poison_range into mm/kasan/common.c so that it is built with HW_TAGS mode enabled. - Add a runtime check for kasan_enabled() in kasan_poison_range. - Add two WARN_ON()s in kasan_poison_range when the input is invalid. PR v1: - Enforce KASAN_GRANULE_SIZE alignment for the end of the range in kasan_poison_range(), and return -EINVAL when this isn't respected. --- --- include/linux/kasan.h | 11 +++++++++++ mm/kasan/common.c | 37 +++++++++++++++++++++++++++++++++++++ 2 files changed, 48 insertions(+) diff --git a/include/linux/kasan.h b/include/linux/kasan.h index 890011071f2b..cd6cdf732378 100644 --- a/include/linux/kasan.h +++ b/include/linux/kasan.h @@ -102,6 +102,16 @@ static inline bool kasan_has_integrated_init(void) } =20 #ifdef CONFIG_KASAN + +/** + * kasan_poison_range - poison the memory range [@addr, @addr + @size) + * + * The exact behavior is subject to alignment with KASAN_GRANULE_SIZE, def= ined + * in : if @start is unaligned, the initial partial gran= ule + * at the beginning of the range is only poisoned if CONFIG_KASAN_GENERIC= =3Dy. + */ +int kasan_poison_range(const void *addr, size_t size); + void __kasan_unpoison_range(const void *addr, size_t size); static __always_inline void kasan_unpoison_range(const void *addr, size_t = size) { @@ -402,6 +412,7 @@ static __always_inline bool kasan_check_byte(const void= *addr) =20 #else /* CONFIG_KASAN */ =20 +static inline int kasan_poison_range(const void *start, size_t size) { ret= urn 0; } static inline void kasan_unpoison_range(const void *address, size_t size) = {} static inline void kasan_poison_pages(struct page *page, unsigned int orde= r, bool init) {} diff --git a/mm/kasan/common.c b/mm/kasan/common.c index 9142964ab9c9..c83579ef37c6 100644 --- a/mm/kasan/common.c +++ b/mm/kasan/common.c @@ -570,3 +570,40 @@ bool __kasan_check_byte(const void *address, unsigned = long ip) } return true; } + +int kasan_poison_range(const void *addr, size_t size) +{ + uintptr_t start_addr =3D (uintptr_t)addr; + uintptr_t head_granule_start; + uintptr_t poison_body_start; + uintptr_t poison_body_end; + size_t head_prefix_size; + uintptr_t end_addr; + + if (!kasan_enabled()) + return 0; + + end_addr =3D start_addr + size; + if (WARN_ON(end_addr % KASAN_GRANULE_SIZE)) + return -EINVAL; + + if (WARN_ON(start_addr >=3D end_addr)) + return -EINVAL; + + head_granule_start =3D ALIGN_DOWN(start_addr, KASAN_GRANULE_SIZE); + head_prefix_size =3D start_addr - head_granule_start; + + if (IS_ENABLED(CONFIG_KASAN_GENERIC) && head_prefix_size > 0) + kasan_poison_last_granule((void *)head_granule_start, + head_prefix_size); + + poison_body_start =3D ALIGN(start_addr, KASAN_GRANULE_SIZE); + poison_body_end =3D end_addr; + + if (poison_body_start < poison_body_end) + kasan_poison((void *)poison_body_start, + poison_body_end - poison_body_start, + KASAN_SLAB_REDZONE, false); + return 0; +} +EXPORT_SYMBOL(kasan_poison_range); --=20 2.51.0 From nobody Sun Dec 14 14:00:08 2025 Received: from mail-wr1-f44.google.com (mail-wr1-f44.google.com [209.85.221.44]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 400E223EA95 for ; Thu, 4 Dec 2025 14:13:07 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.221.44 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1764857590; cv=none; b=qs1wx/zqEdBZfHfJQXU9Hn8C6OTtd8WV20KE9rjBRm905I7X6bStCWQ86MUfUhVDIUsbIS0x4AAbuAEl6FC/U0sKgbQOfuj0yhJaN5HpdLjnKeNIKzS7/VOSV4BzusTNm5A9dHdqE1JcpIB5wTTDpO3T5wcGx+KYnm6yW0PXEr8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1764857590; c=relaxed/simple; bh=ETSuX2q6aBqRJwufP4nFQ3iS4q0jKzkgSG63WlRXfOY=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=bD8xRTJ+1yF+iLr9k4yRvV5ZRjeHOxIL6YGV36AE3Ii2TM1TQ7orDVPrQtFqdqsxQ8e/fuvU4qaaPu+BftE6G0TZd7/5exj5Zpk7IxF1Vm2VGpLvUxaEh/jn7lSUsnS0N9BPwPIVXTXdeUVi050gAm58mn7XNUlXJkXUXxxlBao= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=RUmLYfQ5; arc=none smtp.client-ip=209.85.221.44 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="RUmLYfQ5" Received: by mail-wr1-f44.google.com with SMTP id ffacd0b85a97d-42b47f662a0so1102134f8f.0 for ; Thu, 04 Dec 2025 06:13:06 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1764857585; x=1765462385; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=eB/egNHg9loIhoHi7MhcNEE3/MaK1lWrTWkAXOToMjQ=; b=RUmLYfQ5zklSV1+7aloU76Tb9iY6rNNe0uH96Gh78ehwrS5DftBnu2xPjLJ5gOtPno PZqXPVFlBjFXPGO/2KgX+1cYo3IN6scgtJCfpM4vfVarlVwCqgalQRew9swj3vBLmB3T 7jKLG/hlksZZm3nhWo6LHrVt+LQhRI/I3GNYvREtzsdaqFQlF5ltKdWo87FMGnjFDRML xdY3o+j3YAaR7HsiWd2N3GOJLSD3iU1+Pt30Lxq9hbAE9sdyp1UR99mIVkrcDQimLWCi jBSltUs3+aH6K4JGIts8yLQwPYRZHUbjhBYjCqgzwimna1Q1adMFW1w6aKTQCN67eR7W CfBQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1764857585; x=1765462385; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=eB/egNHg9loIhoHi7MhcNEE3/MaK1lWrTWkAXOToMjQ=; b=rCRmQgMOY3Sj6OU5ehOT15pMlkUQHcIabygmR4Y8vxDtv51cUNytLiT0rUmsj1k8GL aNQLn1pdoRIvF5qOPGpKN2vgMZZZjIruK8HTLeT8kJCmN2R4zzFEfAF0LW68cXElVqrp 4g/zkx89DoD49yeUwoUk6c+Bv5b/ECfC4yyED2vXAiF6M3GI6QtmZaChgf6EgTpoy08k s5ekY4/dtSXalaxmMTq+rTP0TaQLEasbbUPxfg5jfi15poN8dcRlgbfeZmUTsUyzjIwD qo1eufQswbWenLC9ogBQqmDcxnDztWh2jG6HEmgm/YAxlM8xSHLtiWHjNQDbsUyA+kF4 5XsA== X-Forwarded-Encrypted: i=1; AJvYcCUq3doQaCyqQsvBbrQjG+RG9n1PbS6UTUQD/7O1SRBqIlWvs2kODfnK59f2BAbzoVfxyaoBzHk3Tb7k2MU=@vger.kernel.org X-Gm-Message-State: AOJu0Yy1vFnCTTe5k2+ZBTTo6c58Td1rCRkaMravz1AZVZs4XRDlsMns i1p7wQ/8AjNNlU6iEgb977jR5VpEMbnRPRnRJan9aUIkqK5XrP/5U85X X-Gm-Gg: ASbGnctt8j0LIQxCcaD4KpjGkFlnHLDVsE+yiAsFYLQT3BTt75hISLK40GcbmlQFIkX E/Vr1FJCBLtnoxKHpYwQUVSJnFmzEADQvHOPRqqCTwcsJL/YvURNUL+y1C1nYIPZDAThfGHfyuQ kYxNBIadaVEkC/8ucrimgbfY3iWbJjgoYkHx/QA89QhBsyiQJM1XWYKGiX4V2PkT0Sdyw4B2COj 4c9nsRGsQCv10vRiEZ8YYUT+QGiE0uimmTbG5Kghw8X8IyhwwVjtz09SkcxEr4u1n2UJefiy87p XRFQcfcWU2DgsuVM8HoSraYpxymRKRFedu3CN23E/Z/DhbEo1zfiWyR4fdz9wpUT/TVi0J5wVDT pn5BR5FcITxzr69ugzDysuuU6OuBje8rvgfrxjDtLp6Lp2y1XcpkoxittT/OI7VweacX1fPwzko mhjxI8x771Yw7IlMX+xOekycSTvOG3XGkbr2rq9sIFPznmj5JIRGaa8O0pua83Z4HAZA== X-Google-Smtp-Source: AGHT+IFkT4+/HKSCxBC0OR4LEFO3iIJWdcvcuQZ4FUyLxnx0AlGCgOOVSXkLQIHCB3LxKmzkitwLKQ== X-Received: by 2002:a5d:4942:0:b0:42b:2a41:f20 with SMTP id ffacd0b85a97d-42f7886d085mr2957881f8f.18.1764857585163; Thu, 04 Dec 2025 06:13:05 -0800 (PST) Received: from ethan-tp.d.ethz.ch (2001-67c-10ec-5744-8000--626.net6.ethz.ch. [2001:67c:10ec:5744:8000::626]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-42f7cbfeae9sm3605808f8f.13.2025.12.04.06.13.03 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 04 Dec 2025 06:13:04 -0800 (PST) From: Ethan Graham To: ethan.w.s.graham@gmail.com, glider@google.com Cc: andreyknvl@gmail.com, andy@kernel.org, andy.shevchenko@gmail.com, brauner@kernel.org, brendan.higgins@linux.dev, davem@davemloft.net, davidgow@google.com, dhowells@redhat.com, dvyukov@google.com, elver@google.com, herbert@gondor.apana.org.au, ignat@cloudflare.com, jack@suse.cz, jannh@google.com, johannes@sipsolutions.net, kasan-dev@googlegroups.com, kees@kernel.org, kunit-dev@googlegroups.com, linux-crypto@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org, lukas@wunner.de, rmoar@google.com, shuah@kernel.org, sj@kernel.org, tarasmadan@google.com, Ethan Graham Subject: [PATCH 02/10] kfuzztest: add user-facing API and data structures Date: Thu, 4 Dec 2025 15:12:41 +0100 Message-ID: <20251204141250.21114-3-ethan.w.s.graham@gmail.com> X-Mailer: git-send-email 2.51.0 In-Reply-To: <20251204141250.21114-1-ethan.w.s.graham@gmail.com> References: <20251204141250.21114-1-ethan.w.s.graham@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Ethan Graham Add the foundational user-facing components for the KFuzzTest framework. This includes the main API header , the Kconfig option to enable the feature, and the required linker script changes which introduce three new ELF sections in vmlinux. Note that KFuzzTest is intended strictly for debug builds only, and should never be enabled in a production build. The fact that it exposes internal kernel functions and state directly to userspace may constitute a serious security vulnerability if used for any reason other than testing. The header defines: - The FUZZ_TEST() macro for creating test targets. - The data structures required for the binary serialization format, which allows passing complex inputs from userspace. - The metadata structures for test targets, constraints and annotations, which are placed in dedicated ELF sections (.kfuzztest_*) for discovery. This patch only adds the public interface and build integration; no runtime logic is included. Signed-off-by: Ethan Graham Signed-off-by: Ethan Graham Reviewed-by: Alexander Potapenko --- PR v3: - Reorder definitions in kfuzztest.h for better flow and readability. - Introduce __KFUZZTEST_CONSTRAINT macro in preparation for the introduction of the FUZZ_TEST_SIMPLE macro in the following patch, which uses it for manually emitting constraint metadata. PR v1: - Move KFuzzTest metadata definitions to generic vmlinux linkage so that the framework isn't bound to x86_64. - Return -EFAULT when simple_write_to_buffer returns a value not equal to the input length in the main FUZZ_TEST macro. - Enforce a maximum input size of 64KiB in the main FUZZ_TEST macro, returning -EINVAL when it isn't respected. - Refactor KFUZZTEST_ANNOTATION_* macros. - Taint the kernel with TAINT_TEST inside the FUZZ_TEST macro when a fuzz target is invoked for the first time. --- --- include/asm-generic/vmlinux.lds.h | 22 +- include/linux/kfuzztest.h | 486 ++++++++++++++++++++++++++++++ lib/Kconfig.debug | 1 + lib/kfuzztest/Kconfig | 20 ++ 4 files changed, 528 insertions(+), 1 deletion(-) create mode 100644 include/linux/kfuzztest.h create mode 100644 lib/kfuzztest/Kconfig diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinu= x.lds.h index ae2d2359b79e..9afe569d013b 100644 --- a/include/asm-generic/vmlinux.lds.h +++ b/include/asm-generic/vmlinux.lds.h @@ -373,7 +373,8 @@ defined(CONFIG_AUTOFDO_CLANG) || defined(CONFIG_PROPELL= ER_CLANG) TRACE_PRINTKS() \ BPF_RAW_TP() \ TRACEPOINT_STR() \ - KUNIT_TABLE() + KUNIT_TABLE() \ + KFUZZTEST_TABLE() =20 /* * Data section helpers @@ -966,6 +967,25 @@ defined(CONFIG_AUTOFDO_CLANG) || defined(CONFIG_PROPEL= LER_CLANG) BOUNDED_SECTION_POST_LABEL(.kunit_init_test_suites, \ __kunit_init_suites, _start, _end) =20 +#ifdef CONFIG_KFUZZTEST +#define KFUZZTEST_TABLE() \ + . =3D ALIGN(PAGE_SIZE); \ + __kfuzztest_targets_start =3D .; \ + KEEP(*(.kfuzztest_target)); \ + __kfuzztest_targets_end =3D .; \ + . =3D ALIGN(PAGE_SIZE); \ + __kfuzztest_constraints_start =3D .; \ + KEEP(*(.kfuzztest_constraint)); \ + __kfuzztest_constraints_end =3D .; \ + . =3D ALIGN(PAGE_SIZE); \ + __kfuzztest_annotations_start =3D .; \ + KEEP(*(.kfuzztest_annotation)); \ + __kfuzztest_annotations_end =3D .; + +#else /* CONFIG_KFUZZTEST */ +#define KFUZZTEST_TABLE() +#endif /* CONFIG_KFUZZTEST */ + #ifdef CONFIG_BLK_DEV_INITRD #define INIT_RAM_FS \ . =3D ALIGN(4); \ diff --git a/include/linux/kfuzztest.h b/include/linux/kfuzztest.h new file mode 100644 index 000000000000..1839fcfeabf5 --- /dev/null +++ b/include/linux/kfuzztest.h @@ -0,0 +1,486 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * The Kernel Fuzz Testing Framework (KFuzzTest) API for defining fuzz tar= gets + * for internal kernel functions. + * + * For more information please see Documentation/dev-tools/kfuzztest.rst. + * + * Copyright 2025 Google LLC + */ +#ifndef KFUZZTEST_H +#define KFUZZTEST_H + +#include +#include +#include + +#define KFUZZTEST_HEADER_MAGIC (0xBFACE) +#define KFUZZTEST_V0 (0) +#define KFUZZTEST_REGIONID_NULL U32_MAX +#define KFUZZTEST_MAX_INPUT_SIZE (PAGE_SIZE * 16) +/** + * The end of the input should be padded by at least this number of bytes = as + * it is poisoned to detect out of bounds accesses at the end of the last + * region. + */ +#define KFUZZTEST_POISON_SIZE 0x8 + +/** + * @brief The KFuzzTest Input Serialization Format + * + * KFuzzTest receives its input from userspace as a single binary blob. Th= is + * format allows for the serialization of complex, pointer-rich C structur= es + * into a flat buffer that can be safely passed into the kernel. This form= at + * requires only a single copy from userspace into a kernel buffer, and no + * further kernel allocations. Pointers are patched internally using a "re= gion" + * system where each region corresponds to some pointed-to data. + * + * Regions should be padded to respect alignment constraints of their unde= rlying + * types, and should be followed by at least 8 bytes of padding. These pad= ded + * regions are poisoned by KFuzzTest to ensure that KASAN catches OOB acce= sses. + * + * The format consists of a header and three main components: + * 1. An 8-byte header: Contains KFUZZTEST_MAGIC in the first 4 bytes, and= the + * version number in the subsequent 4 bytes. This ensures backwards + * compatibility in the event of future format changes. + * 2. A reloc_region_array: Defines the memory layout of the target struct= ure + * by partitioning the payload into logical regions. Each logical region + * should contain the byte representation of the type that it represents, + * including any necessary padding. The region descriptors should be + * ordered by offset ascending. + * 3. A reloc_table: Provides "linking" instructions that tell the kernel = how + * to patch pointer fields to point to the correct regions. By design, + * the first region (index 0) is passed as input into a FUZZ_TEST. + * 4. A Payload: The raw binary data for the target structure and its asso= ciated + * buffers. This should be aligned to the maximum alignment of all + * regions to satisfy alignment requirements of the input types, but this + * isn't checked by the parser. + * + * For a detailed specification of the binary layout see the full document= ation + * at: Documentation/dev-tools/kfuzztest.rst + */ + +/** + * struct reloc_region - single contiguous memory region in the payload + * + * @offset: The byte offset of this region from the start of the payload, = which + * should be aligned to the alignment requirements of the region's + * underlying type. + * @size: The size of this region in bytes. + */ +struct reloc_region { + uint32_t offset; + uint32_t size; +}; + +/** + * struct reloc_region_array - array of regions in an input + * + * @num_regions: The total number of regions defined. + * @regions: A flexible array of `num_regions` region descriptors. + */ +struct reloc_region_array { + uint32_t num_regions; + struct reloc_region regions[]; +}; + +/** + * struct reloc_entry - a single pointer to be patched in an input + * + * @region_id: The index of the region in the `reloc_region_array` that + * contains the pointer. + * @region_offset: The start offset of the pointer inside of the region. + * @value: contains the index of the pointee region, or KFUZZTEST_REGIONID= _NULL + * if the pointer is NULL. + */ +struct reloc_entry { + uint32_t region_id; + uint32_t region_offset; + uint32_t value; +}; + +/** + * struct reloc_table - array of relocations required by an input + * + * @num_entries: the number of pointer relocations. + * @padding_size: the number of padded bytes between the last relocation in + * entries, and the start of the payload data. This should be at least + * 8 bytes, as it is used for poisoning. + * @entries: array of relocations. + */ +struct reloc_table { + uint32_t num_entries; + uint32_t padding_size; + struct reloc_entry entries[]; +}; + +/** + * kfuzztest_parse_and_relocate - validate and relocate a KFuzzTest input + * + * @input: A buffer containing the serialized input for a fuzz target. + * @input_size: the size in bytes of the @input buffer. + * @arg_ret: return pointer for the test case's input structure. + */ +int kfuzztest_parse_and_relocate(void *input, size_t input_size, void **ar= g_ret); + +enum kfuzztest_constraint_type { + EXPECT_EQ, + EXPECT_NE, + EXPECT_LT, + EXPECT_LE, + EXPECT_GT, + EXPECT_GE, + EXPECT_IN_RANGE, +}; + +/** + * struct kfuzztest_constraint - a metadata record for a domain constraint + * + * Domain constraints are rules about the input data that must be satisfie= d for + * a fuzz test to proceed. While they are enforced in the kernel with a ru= ntime + * check, they are primarily intended as a discoverable contract for users= pace + * fuzzers. + * + * Instances of this struct are generated by the KFUZZTEST_EXPECT_* macros + * and placed into the read-only ".kfuzztest_constraint" ELF section of the + * vmlinux binary. A fuzzer can parse this section to learn about the + * constraints and generate valid inputs more intelligently. + * + * For an example of how these constraints are used within a fuzz test, se= e the + * documentation for the FUZZ_TEST() macro. + * + * @input_type: The name of the input struct type, without the leading + * "struct ". + * @field_name: The name of the field within the struct that this constrai= nt + * applies to. + * @value1: The primary value used in the comparison (e.g., the upper + * bound for EXPECT_LE). + * @value2: The secondary value, used only for multi-value comparisons + * (e.g., the upper bound for EXPECT_IN_RANGE). + * @type: The type of the constraint. + */ +struct kfuzztest_constraint { + const char *input_type; + const char *field_name; + uintptr_t value1; + uintptr_t value2; + enum kfuzztest_constraint_type type; +} __aligned(64); + + +#define __KFUZZTEST_CONSTRAINT(arg_type, field, val1, val2, tpe) \ + static struct kfuzztest_constraint __constraint_##arg_type##_##field \ + __section(".kfuzztest_constraint") __used =3D { \ + .input_type =3D "struct " #arg_type, \ + .field_name =3D #field, \ + .value1 =3D (uintptr_t)val1, \ + .value2 =3D (uintptr_t)val2, \ + .type =3D tpe, \ + } + +#define __KFUZZTEST_DEFINE_CONSTRAINT(arg_type, field, val1, val2, tpe, pr= edicate) \ + do { \ + __KFUZZTEST_CONSTRAINT(arg_type, field, val1, val2, tpe); \ + if (!(predicate)) \ + return; \ + } while (0) + +/** + * KFUZZTEST_EXPECT_EQ - constrain a field to be equal to a value + * + * @arg_type: name of the input structure, without the leading "struct ". + * @field: some field that is comparable + * @val: a value of the same type as @arg_type.@field + */ +#define KFUZZTEST_EXPECT_EQ(arg_type, field, val) \ + __KFUZZTEST_DEFINE_CONSTRAINT(arg_type, field, val, 0x0, EXPECT_EQ, arg->= field =3D=3D val) + +/** + * KFUZZTEST_EXPECT_NE - constrain a field to be not equal to a value + * + * @arg_type: name of the input structure, without the leading "struct ". + * @field: some field that is comparable. + * @val: a value of the same type as @arg_type.@field. + */ +#define KFUZZTEST_EXPECT_NE(arg_type, field, val) \ + __KFUZZTEST_DEFINE_CONSTRAINT(arg_type, field, val, 0x0, EXPECT_NE, arg->= field !=3D val) + +/** + * KFUZZTEST_EXPECT_LT - constrain a field to be less than a value + * + * @arg_type: name of the input structure, without the leading "struct ". + * @field: some field that is comparable. + * @val: a value of the same type as @arg_type.@field. + */ +#define KFUZZTEST_EXPECT_LT(arg_type, field, val) \ + __KFUZZTEST_DEFINE_CONSTRAINT(arg_type, field, val, 0x0, EXPECT_LT, arg->= field < val) + +/** + * KFUZZTEST_EXPECT_LE - constrain a field to be less than or equal to a v= alue + * + * @arg_type: name of the input structure, without the leading "struct ". + * @field: some field that is comparable. + * @val: a value of the same type as @arg_type.@field. + */ +#define KFUZZTEST_EXPECT_LE(arg_type, field, val) \ + __KFUZZTEST_DEFINE_CONSTRAINT(arg_type, field, val, 0x0, EXPECT_LE, arg-= >field <=3D val) + +/** + * KFUZZTEST_EXPECT_GT - constrain a field to be greater than a value + * + * @arg_type: name of the input structure, without the leading "struct ". + * @field: some field that is comparable. + * @val: a value of the same type as @arg_type.@field. + */ +#define KFUZZTEST_EXPECT_GT(arg_type, field, val) \ + __KFUZZTEST_DEFINE_CONSTRAINT(arg_type, field, val, 0x0, EXPECT_GT, arg->= field > val) + +/** + * KFUZZTEST_EXPECT_GE - constrain a field to be greater than or equal to = a value + * + * @arg_type: name of the input structure, without the leading "struct ". + * @field: some field that is comparable. + * @val: a value of the same type as @arg_type.@field. + */ +#define KFUZZTEST_EXPECT_GE(arg_type, field, val) \ + __KFUZZTEST_DEFINE_CONSTRAINT(arg_type, field, val, 0x0, EXPECT_GE, arg->= field >=3D val) + +/** + * KFUZZTEST_EXPECT_NOT_NULL - constrain a pointer field to be non-NULL + * + * @arg_type: name of the input structure, without the leading "struct ". + * @field: a pointer field. + */ +#define KFUZZTEST_EXPECT_NOT_NULL(arg_type, field) KFUZZTEST_EXPECT_NE(arg= _type, field, NULL) + +/** + * KFUZZTEST_EXPECT_IN_RANGE - constrain a field to be within a range + * + * @arg_type: name of the input structure, without the leading "struct ". + * @field: some field that is comparable. + * @lower_bound: a lower bound of the same type as @arg_type.@field. + * @upper_bound: an upper bound of the same type as @arg_type.@field. + */ +#define KFUZZTEST_EXPECT_IN_RANGE(arg_type, field, lower_bound, upper_boun= d) \ + __KFUZZTEST_DEFINE_CONSTRAINT(arg_type, field, lower_bound, upper_bound, \ + EXPECT_IN_RANGE, arg->field >=3D lower_bound && arg->field <=3D upper_b= ound) + +/** + * Annotations express attributes about structure fields that can't be eas= ily + * or safely verified at runtime. They are intended as hints to the fuzzing + * engine to help it generate more semantically correct and effective inpu= ts. + * Unlike constraints, annotations do not add any runtime checks and do not + * cause a test to exit early. + * + * For example, a `char *` field could be a raw byte buffer or a C-style + * null-terminated string. A fuzzer that is aware of this distinction can = avoid + * creating inputs that would cause trivial, uninteresting crashes from re= ading + * past the end of a non-null-terminated buffer. + */ +enum kfuzztest_annotation_attribute { + ATTRIBUTE_LEN, + ATTRIBUTE_STRING, + ATTRIBUTE_ARRAY, +}; + +/** + * struct kfuzztest_annotation - a metadata record for a fuzzer hint + * + * This struct captures a single hint about a field in the input structure. + * Instances are generated by the KFUZZTEST_ANNOTATE_* macros and are plac= ed + * into the read-only ".kfuzztest_annotation" ELF section of the vmlinux b= inary. + * + * A userspace fuzzer can parse this section to understand the semantic + * relationships between fields (e.g., which field is a length for which + * buffer) and the expected format of the data (e.g., a null-terminated + * string). This allows the fuzzer to be much more intelligent during input + * generation and mutation. + * + * For an example of how annotations are used within a fuzz test, see the + * documentation for the FUZZ_TEST() macro. + * + * @input_type: The name of the input struct type. + * @field_name: The name of the field being annotated (e.g., the data + * buffer field). + * @linked_field_name: For annotations that link two fields (like + * ATTRIBUTE_LEN), this is the name of the related field (e.g., the + * length field). For others, this may be unused. + * @attrib: The type of the annotation hint. + */ +struct kfuzztest_annotation { + const char *input_type; + const char *field_name; + const char *linked_field_name; + enum kfuzztest_annotation_attribute attrib; +} __aligned(32); + +#define __KFUZZTEST_ANNOTATE(arg_type, field, linked_field, attribute) = \ + static struct kfuzztest_annotation __annotation_##arg_type##_##field __se= ction(".kfuzztest_annotation") \ + __used =3D { \ + .input_type =3D "struct " #arg_type, \ + .field_name =3D #field, \ + .linked_field_name =3D #linked_field, \ + .attrib =3D attribute, \ + } + +/** + * KFUZZTEST_ANNOTATE_STRING - annotate a char* field as a C string + * + * We define a C string as a sequence of non-zero characters followed by e= xactly + * one null terminator. + * + * @arg_type: name of the input structure, without the leading "struct ". + * @field: the name of the field to annotate. + */ +#define KFUZZTEST_ANNOTATE_STRING(arg_type, field) __KFUZZTEST_ANNOTATE(ar= g_type, field, NULL, ATTRIBUTE_STRING) + +/** + * KFUZZTEST_ANNOTATE_ARRAY - annotate a pointer as an array + * + * We define an array as a contiguous memory region containing zero or more + * elements of the same type. + * + * @arg_type: name of the input structure, without the leading "struct ". + * @field: the name of the field to annotate. + */ +#define KFUZZTEST_ANNOTATE_ARRAY(arg_type, field) __KFUZZTEST_ANNOTATE(arg= _type, field, NULL, ATTRIBUTE_ARRAY) + +/** + * KFUZZTEST_ANNOTATE_LEN - annotate a field as the length of another + * + * This expresses the relationship `arg_type.field =3D=3D len(linked_field= )`, where + * `linked_field` is an array. + * + * @arg_type: name of the input structure, without the leading "struct ". + * @field: the name of the field to annotate. + * @linked_field: the name of an array field with length @field. + */ +#define KFUZZTEST_ANNOTATE_LEN(arg_type, field, linked_field) \ + __KFUZZTEST_ANNOTATE(arg_type, field, linked_field, ATTRIBUTE_LEN) + + +/* + * Dump some information on the parsed headers and payload. Can be useful = for + * debugging inputs when writing an encoder for the KFuzzTest input format. + */ +__attribute__((unused)) static inline void kfuzztest_debug_header(struct r= eloc_region_array *regions, + struct reloc_table *rt, void *payload_start, + void *payload_end) +{ + uint32_t i; + + pr_info("regions: { num_regions =3D %u } @ %px", regions->num_regions, re= gions); + for (i =3D 0; i < regions->num_regions; i++) { + pr_info(" region_%u: { start: 0x%x, size: 0x%x }", i, regions->regions[= i].offset, + regions->regions[i].size); + } + + pr_info("reloc_table: { num_entries =3D %u, padding =3D %u } @ offset 0x%= tx", rt->num_entries, rt->padding_size, + (char *)rt - (char *)regions); + for (i =3D 0; i < rt->num_entries; i++) { + pr_info(" reloc_%u: { src: %u, offset: 0x%x, dst: %u }", i, rt->entries= [i].region_id, + rt->entries[i].region_offset, rt->entries[i].value); + } + + pr_info("payload: [0x%lx, 0x%tx)", (char *)payload_start - (char *)region= s, + (char *)payload_end - (char *)regions); +} + +/* Increments a global counter after a successful invocation. */ +void record_invocation(void); + +/* Common code for receiving inputs from userspace. */ +int kfuzztest_write_cb_common(struct file *filp, const char __user *buf, s= ize_t len, loff_t *off, void **test_buffer); + +struct kfuzztest_target { + const char *name; + const char *arg_type_name; + ssize_t (*write_input_cb)(struct file *filp, const char __user *buf, size= _t len, loff_t *off); +} __aligned(32); + +/** + * FUZZ_TEST - defines a KFuzzTest target + * + * @test_name: The unique identifier for the fuzz test, which is used to n= ame + * the debugfs entry, e.g., /sys/kernel/debug/kfuzztest/@test_name. + * @test_arg_type: The struct type that defines the inputs for the test. T= his + * must be the full struct type (e.g., "struct my_inputs"), not a typedef. + * + * Context: + * This macro is the primary entry point for the KFuzzTest framework. It + * generates all the necessary boilerplate for a fuzz test, including: + * - A static `struct kfuzztest_target` instance that is placed in a + * dedicated ELF section for discovery by userspace tools. + * - A `debugfs` write callback that handles receiving serialized data f= rom + * a fuzzer, parsing it, and "hydrating" it into a valid C struct. + * - A function stub where the developer places the test logic. + * + * User-Provided Logic: + * The developer must provide the body of the fuzz test logic within the c= urly + * braces following the macro invocation. Within this scope, the framework + * provides the `arg` variable, which is a pointer of type `@test_arg_type= *` + * to the fully hydrated input structure. All pointer fields within this s= truct + * have been relocated and are valid kernel pointers. This is the primary + * variable to use for accessing fuzzing inputs. + * + * Example Usage: + * + * // 1. The kernel function we want to fuzz. + * int process_data(const char *data, size_t len); + * + * // 2. Define a struct to hold all inputs for the function. + * struct process_data_inputs { + * const char *data; + * size_t len; + * }; + * + * // 3. Define the fuzz test using the FUZZ_TEST macro. + * FUZZ_TEST(process_data_fuzzer, struct process_data_inputs) + * { + * int ret; + * // Use KFUZZTEST_EXPECT_* to enforce preconditions. + * // The test will exit early if data is NULL. + * KFUZZTEST_EXPECT_NOT_NULL(process_data_inputs, data); + * + * // Use KFUZZTEST_ANNOTATE_* to provide hints to the fuzzer. + * // This links the 'len' field to the 'data' buffer. + * KFUZZTEST_ANNOTATE_LEN(process_data_inputs, len, data); + * + * // Call the function under test using the 'arg' variable. OOB memory + * // accesses will be caught by KASAN, but the user can also choose to + * // validate the return value and log any failures. + * ret =3D process_data(arg->data, arg->len); + * } + */ +#define FUZZ_TEST(test_name, test_arg_type) \ + static ssize_t kfuzztest_write_cb_##test_name(struct file *filp, const ch= ar __user *buf, size_t len, \ + loff_t *off); \ + static void kfuzztest_logic_##test_name(test_arg_type *arg); \ + static const struct kfuzztest_target __fuzz_test__##test_name __section("= .kfuzztest_target") __used =3D { \ + .name =3D #test_name, \ + .arg_type_name =3D #test_arg_type, \ + .write_input_cb =3D kfuzztest_write_cb_##test_name, \ + }; \ + static ssize_t kfuzztest_write_cb_##test_name(struct file *filp, const ch= ar __user *buf, size_t len, \ + loff_t *off) \ + { \ + test_arg_type *arg; \ + void *buffer; \ + int ret; \ + ret =3D kfuzztest_write_cb_common(filp, buf, len, off, &buffer); \ + if (ret < 0) \ + goto fail_early; \ + ret =3D kfuzztest_parse_and_relocate(buffer, len, (void **)&arg); \ + if (ret < 0) \ + goto fail_late; \ + kfuzztest_logic_##test_name(arg); \ + record_invocation(); \ + ret =3D len; \ +fail_late: \ + kfree(buffer); \ +fail_early: \ + return ret; \ + } \ + static void kfuzztest_logic_##test_name(test_arg_type *arg) + +#endif /* KFUZZTEST_H */ diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug index dc0e0c6ed075..49a1748b9f24 100644 --- a/lib/Kconfig.debug +++ b/lib/Kconfig.debug @@ -1947,6 +1947,7 @@ endmenu menu "Kernel Testing and Coverage" =20 source "lib/kunit/Kconfig" +source "lib/kfuzztest/Kconfig" =20 config NOTIFIER_ERROR_INJECTION tristate "Notifier error injection" diff --git a/lib/kfuzztest/Kconfig b/lib/kfuzztest/Kconfig new file mode 100644 index 000000000000..f9fb5abf8d27 --- /dev/null +++ b/lib/kfuzztest/Kconfig @@ -0,0 +1,20 @@ +# SPDX-License-Identifier: GPL-2.0-only + +config KFUZZTEST + bool "KFuzzTest - enable support for internal fuzz targets" + depends on DEBUG_FS && DEBUG_KERNEL + help + Enables support for the kernel fuzz testing framework (KFuzzTest), an + interface for exposing internal kernel functions to a userspace fuzzing + engine. KFuzzTest targets are exposed via a debugfs interface that + accepts serialized userspace inputs, and is designed to make it easier + to fuzz deeply nested kernel code that is hard to reach from the system + call boundary. Using a simple macro-based API, developers can add a new + fuzz target with minimal boilerplate code. + + It is strongly recommended to also enable CONFIG_KASAN for byte-accurate + out-of-bounds detection, as KFuzzTest was designed with this in mind. It + is also recommended to enable CONFIG_KCOV for coverage guided fuzzing. + + WARNING: This exposes internal kernel functions directly to userspace + and must NEVER be enabled in production builds. --=20 2.51.0 From nobody Sun Dec 14 14:00:08 2025 Received: from mail-wr1-f47.google.com (mail-wr1-f47.google.com [209.85.221.47]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 7BEAC341ACB for ; Thu, 4 Dec 2025 14:13:08 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.221.47 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1764857591; cv=none; b=G27CWmcbQnbR41mS3d5vBdXd1UXR4Gtje/oi/HDem+bvFwlbYK+mBhIwR3CslQ5DwsLsNil15eFZXsAyOGk5CbKCQZrhL6x3thfEhklYlAO99MKNeFdHV/IfCEZdJjOSthGxYUGU35/GQWrmjnbDHdeP538YfaQN0DfpCQX0Xfk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1764857591; c=relaxed/simple; bh=gGOyyVjVMhMF3sDm6WRBw0+IQtrWF8GPAGIMRplta2c=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=vFcI059wuj1B/MMyh/JLqero4rF7oNlhUu2PsEUwGby+fIYztHeaK6ApZdJRqn1oCJ9WIRqyN0d8cudATqSnxbT4c3ruptXmt16AcShrGCEjCwM1nnhRPltqNCbCw2IqOdZPE3uzROstlLvcDlLX/AvyegkxHMaJccVSJP+th00= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=DnNEoFkd; arc=none smtp.client-ip=209.85.221.47 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="DnNEoFkd" Received: by mail-wr1-f47.google.com with SMTP id ffacd0b85a97d-42b32ff5d10so1398679f8f.1 for ; Thu, 04 Dec 2025 06:13:08 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1764857587; x=1765462387; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=isyNyNcz2cmNMZXUIhi196/Z7TRsBZBkmSpv3VPEYmw=; b=DnNEoFkdX816PUig11YRbjWEMG+GnW0Id+UzFswX/dQVsxjcLb2oj1hi/gyoo6CFIe Sxcwpsu8r42jbEcaw2ZXmcNjhoT4aXlQ9xrtRyYPdieL8c0lKStznZPmFfZPkKR/h2jX E4qEJDayNpRExtVEHItSRQ3ft9evBrb1Kx1Dx8T8gY0ApX0Pp38eTu4KifrEtF+12N5F FAsjtMGbE42JIJJimCh8DBA7mjDVjUBn/SJV1NkTWSkg19JzvZWFIfZH9k5UaaU1U95W qDy+lc5BiS1dPjwnFlr/FHFm8DmdhETuC+FfoiZxO3gLjWfzuLn0mtuL3l0dFpCbCarS kwTw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1764857587; x=1765462387; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=isyNyNcz2cmNMZXUIhi196/Z7TRsBZBkmSpv3VPEYmw=; b=bBVq/WlQ4fpGuXZx6zaHu4eFVdIbPhS7ekk09YJVePKhaRzb9fAhBSWyaa0hYtl6jF FAlPPN0gGj2sOqNlhQ+TgEXpuhN1dnF59VqKtp+1kwOqslF/cQwEIzX5miIsFzDU9+zy QuIrOkH8Y1oGBjx1a6uAmPes6131zKeJvxZQzdBnD4hYAVbQPLWNUenFeiwWBUkDsjkx 1dVfqTxwMBGIUkw1MHt5d3uByqX1f1JknYr5nM4sstStQTwyqz4uUpoX63cuo+qkwYhA lzZ3QEkqo0HlBfs8FFnUlSe2EyiWdkt73RsM29Xa7KCmoPNRTEViniRRtmPRBzRiar75 vODQ== X-Forwarded-Encrypted: i=1; AJvYcCW8AcnXkgP/E8MRKxgJ+Mj77eKxEeQ5Cx9zzVPCQ5Ud+wZm6HqSO9/VBGFiD6XTPW8r77MoYBh7nmeXlz0=@vger.kernel.org X-Gm-Message-State: AOJu0YwkfF5OvLZSW+0HaXm6x8bwhCyWlSPAYOh/+DQpi9fnxTV99M7I dqHCieejdzhfMvidAJbLDl4Xbw6XmUs9wIvL6Jn6QX63CE+RBlvyKe12 X-Gm-Gg: ASbGncvpfEf29k5lvM3Ao7pUBpkYIyEeODVmOcuTdnEKnFkr7fjFXXzwCchZJsydkma UxuC+LwqYxErTvOqLiEoHDgpKZDuzgepUbEnKq17bDl2tzYp1aFAmReTkZIZT6pwkOtTs5kMvcn 81hpXlSQCme3yowsJKx7sA7SBnZZSXgVTuwuKsv/eYxp1hQQIPo3W59NqByv6ndikEh3vMRkJcD NxKjCDDGKutHu9yvxJSxE9ZphlEZPK4QE50iB6lajEYtrhbOrs+/1+tVUlN6ngM3qUjXueC3bMC URkw2SuMpRVpp+hYsLS9Rc5QvbwM7cLHn1GJpSKJ8DuI3QleeCr/2OHUz6L+C/A+zbWhfDRTcsT XeMaJnYFWnsERS5o1Hj1Kvvnl2hFjJ7/YaPe70wv/0B0HYUrrpbboaIBHOrm9qbsGGO8xre4kv8 26aya5xQYJkqwzjWLbfev7mj9tiU8y+JjEgZ9baA1vrcxUWsmfQTu+G4721DgEN/yQZg== X-Google-Smtp-Source: AGHT+IHzNmWdyGZHlpy0d/ld4zER7YnP7X7/VxSK89F6ur9TtLx9dRwcFdqJB8Vqqm6xuvTuLO1sQw== X-Received: by 2002:a05:6000:290c:b0:42b:3661:304e with SMTP id ffacd0b85a97d-42f78874e61mr3830533f8f.16.1764857586521; Thu, 04 Dec 2025 06:13:06 -0800 (PST) Received: from ethan-tp.d.ethz.ch (2001-67c-10ec-5744-8000--626.net6.ethz.ch. [2001:67c:10ec:5744:8000::626]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-42f7cbfeae9sm3605808f8f.13.2025.12.04.06.13.05 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 04 Dec 2025 06:13:06 -0800 (PST) From: Ethan Graham To: ethan.w.s.graham@gmail.com, glider@google.com Cc: andreyknvl@gmail.com, andy@kernel.org, andy.shevchenko@gmail.com, brauner@kernel.org, brendan.higgins@linux.dev, davem@davemloft.net, davidgow@google.com, dhowells@redhat.com, dvyukov@google.com, elver@google.com, herbert@gondor.apana.org.au, ignat@cloudflare.com, jack@suse.cz, jannh@google.com, johannes@sipsolutions.net, kasan-dev@googlegroups.com, kees@kernel.org, kunit-dev@googlegroups.com, linux-crypto@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org, lukas@wunner.de, rmoar@google.com, shuah@kernel.org, sj@kernel.org, tarasmadan@google.com Subject: [PATCH 03/10] kfuzztest: introduce the FUZZ_TEST_SIMPLE macro Date: Thu, 4 Dec 2025 15:12:42 +0100 Message-ID: <20251204141250.21114-4-ethan.w.s.graham@gmail.com> X-Mailer: git-send-email 2.51.0 In-Reply-To: <20251204141250.21114-1-ethan.w.s.graham@gmail.com> References: <20251204141250.21114-1-ethan.w.s.graham@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" The serialization format required by a KFuzzTest target defined with the FUZZ_TEST macro is overkill for simpler cases, in particular the very common pattern of kernel interfaces taking a (data, datalen) pair. Introduce the FUZZ_TEST_SIMPLE for defining simple targets that accept a simpler binary interface without any required serialization. The aim is to make simple targets compatible with a wide variety of userspace fuzzing engines out of the box. A FUZZ_TEST_SIMPLE target also defines an equivalent FUZZ_TEST macro in its expansion maintaining compatibility with the default KFuzzTest interface, using a shared `struct kfuzztest_simple_arg` as input type. In essence, the following equivalence holds: FUZZ_TEST_SIMPLE(test) =3D=3D=3D FUZZ_TEST(test, struct kfuzztest_simple_ar= g) Constraints and annotation metadata for `struct kfuzztest_simple_arg` is defined statically in the header file to avoid duplicate definitions in the compiled vmlinux image. Signed-off-by: Ethan Graham --- include/asm-generic/vmlinux.lds.h | 4 ++ include/linux/kfuzztest.h | 87 +++++++++++++++++++++++++++++++ 2 files changed, 91 insertions(+) diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinu= x.lds.h index 9afe569d013b..2736dd41fba0 100644 --- a/include/asm-generic/vmlinux.lds.h +++ b/include/asm-generic/vmlinux.lds.h @@ -974,6 +974,10 @@ defined(CONFIG_AUTOFDO_CLANG) || defined(CONFIG_PROPEL= LER_CLANG) KEEP(*(.kfuzztest_target)); \ __kfuzztest_targets_end =3D .; \ . =3D ALIGN(PAGE_SIZE); \ + __kfuzztest_simple_targets_start =3D .; \ + KEEP(*(.kfuzztest_simple_target)); \ + __kfuzztest_simple_targets_end =3D .; \ + . =3D ALIGN(PAGE_SIZE); \ __kfuzztest_constraints_start =3D .; \ KEEP(*(.kfuzztest_constraint)); \ __kfuzztest_constraints_end =3D .; \ diff --git a/include/linux/kfuzztest.h b/include/linux/kfuzztest.h index 1839fcfeabf5..284142fa4300 100644 --- a/include/linux/kfuzztest.h +++ b/include/linux/kfuzztest.h @@ -483,4 +483,91 @@ fail_early: \ } \ static void kfuzztest_logic_##test_name(test_arg_type *arg) =20 +struct kfuzztest_simple_target { + const char *name; + ssize_t (*write_input_cb)(struct file *filp, const char __user *buf, size= _t len, loff_t *off); +} __aligned(32); + +struct kfuzztest_simple_arg { + char *data; + size_t datalen; +}; + +/* Define constraint and annotation metadata for reused kfuzztest_simple_a= rg. */ +__KFUZZTEST_CONSTRAINT(kfuzztest_simple_arg, data, NULL, 0x0, EXPECT_NE); +__KFUZZTEST_ANNOTATE(kfuzztest_simple_arg, data, NULL, ATTRIBUTE_ARRAY); +__KFUZZTEST_ANNOTATE(kfuzztest_simple_arg, datalen, data, ATTRIBUTE_LEN); + +/** + * FUZZ_TEST_SIMPLE - defines a simple KFuzzTest target + * + * @test_name: the unique identifier for the fuzz test, which is used to n= ame + * the debugfs entry. + * + * This macro function nearly identically to the standard FUZZ_TEST target= , the + * key difference being that a simple fuzz target is constrained to inputs= of + * the form `(char *data, size_t datalen)` - a common pattern in kernel AP= Is. + * + * The FUZZ_TEST_SIMPLE macro expands to define an equivalent FUZZ_TEST, + * effectively creating two debugfs input files for the fuzz target. In es= sence, + * on top of creating an input file under kfuzztest/@test_name/input, a new + * simple input file is created under kfuzztest/@test_name/input_simple. T= his + * debugfs file takes raw byte buffers as input and doesn't require any sp= ecial + * serialization. + * + * User-provided Logic: + * The developer must provide the body of the fuzz test logic within the c= urly + * braces following the macro invocation. Within this scope, the framework + * provides the `data` and `datalen` variables, where `datalen =3D=3D len(= data)`. + * + * Example Usage: + * + * // 1. The kernel function that we wnat to fuzz. + * int process_data(const char *data, size_t datalen); + * + * // 2. Define a fuzz target using the FUZZ_TEST_SIMPLE macro. + * FUZZ_TEST_SIMPLE(test_process_data) + * { + * // Call the function under test using the `data` and `datalen` + * // variables. + * process_data(data, datalen); + * } + * + */ +#define FUZZ_TEST_SIMPLE(test_name) \ + static ssize_t kfuzztest_simple_write_cb_##test_name(struct file *filp, c= onst char __user *buf, size_t len, \ + loff_t *off); \ + static void kfuzztest_simple_logic_##test_name(char *data, size_t datalen= ); \ + static const struct kfuzztest_simple_target __fuzz_test_simple__##test_na= me __section( \ + ".kfuzztest_simple_target") __used =3D { \ + .name =3D #test_name, \ + .write_input_cb =3D kfuzztest_simple_write_cb_##test_name, \ + }; \ + FUZZ_TEST(test_name, struct kfuzztest_simple_arg) \ + { \ + /* We don't use the KFUZZTEST_EXPECT macro to define the + * non-null constraint on `arg->data` as we only want metadata + * to be emitted once, so we enforce it here manually. */ \ + if (arg->data =3D=3D NULL) \ + return; \ + kfuzztest_simple_logic_##test_name(arg->data, arg->datalen); \ + } \ + static ssize_t kfuzztest_simple_write_cb_##test_name(struct file *filp, c= onst char __user *buf, size_t len, \ + loff_t *off) \ + { \ + void *buffer; \ + int ret; \ + \ + ret =3D kfuzztest_write_cb_common(filp, buf, len, off, &buffer); \ + if (ret < 0) \ + goto out; \ + kfuzztest_simple_logic_##test_name(buffer, len); \ + record_invocation(); \ + ret =3D len; \ + kfree(buffer); \ +out: \ + return ret; \ + } \ + static void kfuzztest_simple_logic_##test_name(char *data, size_t datalen) + #endif /* KFUZZTEST_H */ --=20 2.51.0 From nobody Sun Dec 14 14:00:08 2025 Received: from mail-wm1-f50.google.com (mail-wm1-f50.google.com [209.85.128.50]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id AC063343D69 for ; Thu, 4 Dec 2025 14:13:13 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.50 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1764857640; cv=none; b=S0Ucf5gRpUnlRXlfM9hoGXCjA6OElWEmBj7O7/H5xcyhm0hfozdbDQM4PejhMShRzfFeryZXchcmig4H+4INKLSmfA3r87Rnxz/0TSPDRY+HgswNQQOOV/XOMGUmbVgrgh4+qzABX5ryWCXIQNWr39wghZMaEz0LWe4Q8GK09C4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1764857640; c=relaxed/simple; bh=gWlAKE2EADj37b1nLNGulz9H6p5/l/RYPfgWT1UFlM4=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=gnBWdVazyIsekR+yiIbdEq68TbhvUOzxgnnm83fXIXGYyLwk2DcQzGg5V7MA9R6WWI69BElhe3Z4uHyUxyP/ZH1eWhq6gv/7kjplpDBWN8ZD8rcp6wcXjM11K5X30NE7ZmkLMcSkLgSWTSiR/A2ZK6WjyvIq/Nf9D1pNt/zTTaE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=YNvvul0S; arc=none smtp.client-ip=209.85.128.50 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="YNvvul0S" Received: by mail-wm1-f50.google.com with SMTP id 5b1f17b1804b1-4779a4fc95aso15195215e9.1 for ; Thu, 04 Dec 2025 06:13:13 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1764857592; x=1765462392; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=z1D6mIA8zaDVuYvlZPBQC/reups7ZtEd8Pt1iI+Q1x0=; b=YNvvul0S2Fvi0c2H623RIG3WSg8qe65YfEIXb0oT6rTvWW+tKXZklhQapx6YTVd1zU wSTfQFhErMLChsCTVP5g4EW/1ZsKymqoV0qbjLMcdUIVX9npnJJ+pDgcOVjFQ5f09TLK auDdi4Cta3CRia5bdLBGMX21SF2JoAQyQLR0cr+pIqNvO7wQSgv9WuIM45CXmvF3lmnC 6XFAw77DDVVVdQ974gooqzPtH7Y6wacLDge+HU/XcurMyxyuYmr6n4pUFsNEgzkMbr4W 0txMtUxp1+wet0idx9a8WAcBcjKXcs7XUZQuTezxMT0Bmh8nUrAodTUi91JvYhl6QxT2 dgjA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1764857592; x=1765462392; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=z1D6mIA8zaDVuYvlZPBQC/reups7ZtEd8Pt1iI+Q1x0=; b=dqpEUnd0V56qQicUpUcxG/PKfpMamOloaDaMzOOd00d8cKBn28kFneseAUwv4ubvzA VNgtyC4uRDGRJ/aHEWNivGt1J54iJyrcQigkAykW5bP20aN5d3qZ7POgqLFwo3QTG7D3 OJps4onGh5v2O42KBr8pvTrmeRNu0G73y4DnW5mjmC9VPwbVrYv/lUclq8ZKQiZ7Oq0n AX2DGCWomG3/yELASF+o1wWBJp1dJNzgaYWYHYQkvGXJgeJDgVauepH/Whd/4I+bWuuS wY128hWG6lkuMWWpd5uJ8gaHxxVk920ATJjyuw6qFkJVu0AZ598dBVtl+zw8XjzDXiQd V22Q== X-Forwarded-Encrypted: i=1; AJvYcCVRL2LHCNSkCJePRB45vMVdYLo6SOmppOahCGaOdfDIE10imAGopPAJjxU5nj2OstQJpzq519nciY57r6w=@vger.kernel.org X-Gm-Message-State: AOJu0YzIQ1+XoQj/0xeF2WgBpGqhibLNzCkxWKZhMWfWpoDKexIR7FWy TCFsQA/pBccbVAQVV09hz2XtLprIJfYDVOMvMrjArHgsymvGhnSDqExL X-Gm-Gg: ASbGncvT4W1tKInjwKObp7vnOavixjAPUqqbdatofy15noxGOqV++JiLlnnQBTH+fCX ggOgos+QW9UvYiGRGFLV+ZKCMOOd/HQxlQmCb0mqmJabVxVPynRmYdShKyF3MPI/nw5qLBYCgRO nzWnXfjW1j3zA69BsSBYJwgXPhpsBr+HKqjhUG+NnPygps1f6zGv0T+Fe37d49ZrHxu6k7c4yBY DudJMNFaazlk6pQb9SKi1y3745yuxCBlCciDWB2ZDF6BG45yurpcTj+qDRNQydnYpg+l/3CN2fW pRCzSQUvBCEHvRmIrHtGAoOP9lyEx3BL2zrUWekHtdPio2f4gJv3Xsxf2vi0bDz3PI5NB5LZTFB sW3UqnieVMVQRkKX+DGvkDpWubrs+3tgiNHiM4i5ZsmrX2LBSVggh8iikZlw8EMnwzs1VEbiZp8 zctTjV4MkXtjQzpmuMCR/LNjCCFZyUgZ135TtySVVkraKJg6J9x2iKnODyQbJoSI1Oi3MtlTVsm BpG X-Google-Smtp-Source: AGHT+IH290cp3LGNkaEPMbe+NkkURfvVqRSh/Uj1IH90ikXi89hVDc5Sw8cLNuxF4mEg+msS1l5zcg== X-Received: by 2002:a05:6000:2908:b0:42b:47ef:1d59 with SMTP id ffacd0b85a97d-42f7874f9aemr4343041f8f.4.1764857590090; Thu, 04 Dec 2025 06:13:10 -0800 (PST) Received: from ethan-tp.d.ethz.ch (2001-67c-10ec-5744-8000--626.net6.ethz.ch. [2001:67c:10ec:5744:8000::626]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-42f7cbfeae9sm3605808f8f.13.2025.12.04.06.13.06 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 04 Dec 2025 06:13:07 -0800 (PST) From: Ethan Graham To: ethan.w.s.graham@gmail.com, glider@google.com Cc: andreyknvl@gmail.com, andy@kernel.org, andy.shevchenko@gmail.com, brauner@kernel.org, brendan.higgins@linux.dev, davem@davemloft.net, davidgow@google.com, dhowells@redhat.com, dvyukov@google.com, elver@google.com, herbert@gondor.apana.org.au, ignat@cloudflare.com, jack@suse.cz, jannh@google.com, johannes@sipsolutions.net, kasan-dev@googlegroups.com, kees@kernel.org, kunit-dev@googlegroups.com, linux-crypto@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org, lukas@wunner.de, rmoar@google.com, shuah@kernel.org, sj@kernel.org, tarasmadan@google.com, Ethan Graham Subject: [PATCH 04/10] kfuzztest: implement core module and input processing Date: Thu, 4 Dec 2025 15:12:43 +0100 Message-ID: <20251204141250.21114-5-ethan.w.s.graham@gmail.com> X-Mailer: git-send-email 2.51.0 In-Reply-To: <20251204141250.21114-1-ethan.w.s.graham@gmail.com> References: <20251204141250.21114-1-ethan.w.s.graham@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Ethan Graham Add the core runtime implementation for KFuzzTest. This includes the module initialization, and the logic for receiving and processing user-provided inputs through debugfs. On module load, the framework discovers all test targets (FUZZ_TEST) by iterating over the .kfuzztest_target section, creating a corresponding debugfs directory with a write-only 'input' file for each of them. If an equivalent simple fuzz target (FUZZ_TEST_SIMPLE) is also defined, a write-only `input_simple` file is created under the same directory, accepting raw blobs of binary. Writing to an 'input' file triggers the main fuzzing sequence: 1. The serialized input is copied from userspace into a kernel buffer. 2. The buffer is parsed to validate the region array and relocation table. 3. Pointers are patched based on the relocation entries, and in KASAN builds the inter-region padding is poisoned. 4. The resulting struct is passed to the user-defined test logic. Writing to an 'input_simple' file triggers the following fuzzing sequence: 1. The binary input is copied from userspace into a kernel buffer. 2. The buffer and its length are passed into the user-defined test logic. Signed-off-by: Ethan Graham Signed-off-by: Ethan Graham Reviewed-by: Alexander Potapenko --- PR v3: - Handle FUZZ_TEST_SIMPLE targets by creating a write-only 'input_simple' under the fuzz target's directory. - Add implementation for `kfuzztest_write_input_cb`. PR v2: - Fix build issues identified by the kernel test robot . - Address some nits pointed out by Alexander Potapenko. PR v1: - Update kfuzztest/parse.c interfaces to take `unsigned char *` instead of `void *`, reducing the number of pointer casts. - Expose minimum region alignment via a new debugfs file. - Expose number of successful invocations via a new debugfs file. - Refactor module init function, add _config directory with entries containing KFuzzTest state information. - Account for kasan_poison_range() return value in input parsing logic. - Validate alignment of payload end. - Move static sizeof assertions into /lib/kfuzztest/main.c. - Remove the taint in kfuzztest/main.c. We instead taint the kernel as soon as a fuzz test is invoked for the first time, which is done in the primary FUZZ_TEST macro. RFC v2: - The module's init function now taints the kernel with TAINT_TEST. --- --- lib/Makefile | 2 + lib/kfuzztest/Makefile | 4 + lib/kfuzztest/main.c | 278 ++++++++++++++++++ lib/kfuzztest/parse.c | 236 +++++++++++++++ .../testing/kfuzztest-bridge/kfuzztest-bridge | Bin 0 -> 911160 bytes 5 files changed, 520 insertions(+) create mode 100644 lib/kfuzztest/Makefile create mode 100644 lib/kfuzztest/main.c create mode 100644 lib/kfuzztest/parse.c create mode 100755 tools/testing/kfuzztest-bridge/kfuzztest-bridge diff --git a/lib/Makefile b/lib/Makefile index 392ff808c9b9..02789bf88499 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -325,6 +325,8 @@ obj-$(CONFIG_GENERIC_LIB_CMPDI2) +=3D cmpdi2.o obj-$(CONFIG_GENERIC_LIB_UCMPDI2) +=3D ucmpdi2.o obj-$(CONFIG_OBJAGG) +=3D objagg.o =20 +obj-$(CONFIG_KFUZZTEST) +=3D kfuzztest/ + # pldmfw library obj-$(CONFIG_PLDMFW) +=3D pldmfw/ =20 diff --git a/lib/kfuzztest/Makefile b/lib/kfuzztest/Makefile new file mode 100644 index 000000000000..142d16007eea --- /dev/null +++ b/lib/kfuzztest/Makefile @@ -0,0 +1,4 @@ +# SPDX-License-Identifier: GPL-2.0 + +obj-$(CONFIG_KFUZZTEST) +=3D kfuzztest.o +kfuzztest-objs :=3D main.o parse.o diff --git a/lib/kfuzztest/main.c b/lib/kfuzztest/main.c new file mode 100644 index 000000000000..bb064fd90a25 --- /dev/null +++ b/lib/kfuzztest/main.c @@ -0,0 +1,278 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * KFuzzTest core module initialization and debugfs interface. + * + * Copyright 2025 Google LLC + */ +#include +#include +#include +#include +#include +#include +#include +#include + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Ethan Graham "); +MODULE_AUTHOR("Ethan Graham "); +MODULE_DESCRIPTION("Kernel Fuzz Testing Framework (KFuzzTest)"); + +/* + * Enforce a fixed struct size to ensure a consistent stride when iteratin= g over + * the array of these structs in the dedicated ELF section. + */ +static_assert(sizeof(struct kfuzztest_target) =3D=3D 32, "struct kfuzztest= _target should have size 32"); +static_assert(sizeof(struct kfuzztest_simple_target) =3D=3D 32, "struct kf= uzztest_target should have size 32"); +static_assert(sizeof(struct kfuzztest_constraint) =3D=3D 64, "struct kfuzz= test_constraint should have size 64"); +static_assert(sizeof(struct kfuzztest_annotation) =3D=3D 32, "struct kfuzz= test_annotation should have size 32"); + +extern const struct kfuzztest_target __kfuzztest_targets_start[]; +extern const struct kfuzztest_target __kfuzztest_targets_end[]; +extern const struct kfuzztest_simple_target __kfuzztest_simple_targets_sta= rt[]; +extern const struct kfuzztest_simple_target __kfuzztest_simple_targets_end= []; + +struct target_fops { + struct file_operations target; + struct file_operations target_simple; +}; + +/** + * struct kfuzztest_state - global state for the KFuzzTest module + * + * @kfuzztest_dir: The root debugfs directory, /sys/kernel/debug/kfuzztest= /. + * @num_invocations: total number of target invocations. + * @num_targets: number of registered targets. + * @target_fops: array of file operations for each registered target. + * @minalign_fops: file operations for the /_config/minalign file. + * @num_invocations_fops: file operations for the /_config/num_invocations= file. + */ +struct kfuzztest_state { + struct dentry *kfuzztest_dir; + atomic_t num_invocations; + size_t num_targets; + + struct target_fops *target_fops; + struct file_operations minalign_fops; + struct file_operations num_invocations_fops; +}; + +static struct kfuzztest_state state; + +void record_invocation(void) +{ + atomic_inc(&state.num_invocations); +} + +static void cleanup_kfuzztest_state(struct kfuzztest_state *st) +{ + debugfs_remove_recursive(st->kfuzztest_dir); + st->num_targets =3D 0; + st->num_invocations =3D (atomic_t)ATOMIC_INIT(0); + kfree(st->target_fops); + st->target_fops =3D NULL; +} + +static const umode_t KFUZZTEST_INPUT_PERMS =3D 0222; +static const umode_t KFUZZTEST_MINALIGN_PERMS =3D 0444; + +static ssize_t read_cb_integer(struct file *filp, char __user *buf, size_t= count, loff_t *f_pos, size_t value) +{ + char buffer[64]; + int len; + + len =3D scnprintf(buffer, sizeof(buffer), "%zu\n", value); + return simple_read_from_buffer(buf, count, f_pos, buffer, len); +} + +/* + * Callback for /sys/kernel/debug/kfuzztest/_config/minalign. Minalign + * corresponds to the minimum alignment that regions in a KFuzzTest input = must + * satisfy. This callback returns that value in string format. + */ +static ssize_t minalign_read_cb(struct file *filp, char __user *buf, size_= t count, loff_t *f_pos) +{ + int minalign =3D MAX(KFUZZTEST_POISON_SIZE, ARCH_KMALLOC_MINALIGN); + return read_cb_integer(filp, buf, count, f_pos, minalign); +} + +/* + * Callback for /sys/kernel/debug/kfuzztest/_config/num_invocations, which + * returns the value in string format. + */ +static ssize_t num_invocations_read_cb(struct file *filp, char __user *buf= , size_t count, loff_t *f_pos) +{ + return read_cb_integer(filp, buf, count, f_pos, atomic_read(&state.num_in= vocations)); +} + +static int create_read_only_file(struct dentry *parent, const char *name, = struct file_operations *fops) +{ + struct dentry *file; + int err =3D 0; + + file =3D debugfs_create_file(name, KFUZZTEST_MINALIGN_PERMS, parent, NULL= , fops); + if (!file) + err =3D -ENOMEM; + else if (IS_ERR(file)) + err =3D PTR_ERR(file); + return err; +} + +static int initialize_config_dir(struct kfuzztest_state *st) +{ + struct dentry *dir; + int err =3D 0; + + dir =3D debugfs_create_dir("_config", st->kfuzztest_dir); + if (!dir) + err =3D -ENOMEM; + else if (IS_ERR(dir)) + err =3D PTR_ERR(dir); + if (err) { + pr_info("kfuzztest: failed to create /_config dir"); + goto out; + } + + st->minalign_fops =3D (struct file_operations){ + .owner =3D THIS_MODULE, + .read =3D minalign_read_cb, + }; + err =3D create_read_only_file(dir, "minalign", &st->minalign_fops); + if (err) { + pr_info("kfuzztest: failed to create /_config/minalign"); + goto out; + } + + st->num_invocations_fops =3D (struct file_operations){ + .owner =3D THIS_MODULE, + .read =3D num_invocations_read_cb, + }; + err =3D create_read_only_file(dir, "num_invocations", &st->num_invocation= s_fops); + if (err) + pr_info("kfuzztest: failed to create /_config/num_invocations"); +out: + return err; +} + +static int initialize_target_dir(struct kfuzztest_state *st, const struct = kfuzztest_target *targ, + struct target_fops *fops) +{ + const struct kfuzztest_simple_target *simple_targ; + struct dentry *dir, *input, *input_simple; + int err =3D 0; + + dir =3D debugfs_create_dir(targ->name, st->kfuzztest_dir); + if (!dir) + err =3D -ENOMEM; + else if (IS_ERR(dir)) + err =3D PTR_ERR(dir); + if (err) { + pr_info("kfuzztest: failed to create /kfuzztest/%s dir", targ->name); + goto out; + } + + input =3D debugfs_create_file("input", KFUZZTEST_INPUT_PERMS, dir, NULL, = &fops->target); + if (!input) + err =3D -ENOMEM; + else if (IS_ERR(input)) + err =3D PTR_ERR(input); + if (err) { + pr_info("kfuzztest: failed to create /kfuzztest/%s/input", targ->name); + goto out; + } + + /* Check if a simple target exists for this target. */ + for (simple_targ =3D __kfuzztest_simple_targets_start; simple_targ < __kf= uzztest_simple_targets_end; + simple_targ++) { + if (strcmp(targ->name, simple_targ->name) !=3D 0) + continue; + fops->target_simple =3D (struct file_operations){ + .owner =3D THIS_MODULE, + .write =3D simple_targ->write_input_cb, + }; + input_simple =3D + debugfs_create_file("input_simple", KFUZZTEST_INPUT_PERMS, dir, NULL, &= fops->target_simple); + if (!input_simple) + err =3D -ENOMEM; + else if (IS_ERR(input_simple)) + err =3D PTR_ERR(input_simple); + if (err) { + pr_info("kfuzztest: failed to create /kfuzztest/%s/input_simple", targ-= >name); + goto out; + } + break; + } +out: + return err; +} + +/** + * kfuzztest_init - initializes the debug filesystem for KFuzzTest + * + * Each registered target in the ".kfuzztest_targets" section gets its own + * subdirectory under "/sys/kernel/debug/kfuzztest/" containing= one + * write-only "input" and optional "input_simple" files used for receiving + * inputs from userspace. + * Furthermore, a directory "/sys/kernel/debug/kfuzztest/_config" is creat= ed, + * containing two read-only files "minalign" and "num_invocations", that r= eturn + * the minimum required region alignment and number of successful target + * invocations respectively. + * + * @return 0 on success or an error + */ +static int __init kfuzztest_init(void) +{ + const struct kfuzztest_target *targ; + int err =3D 0; + int i =3D 0; + + state.num_targets =3D __kfuzztest_targets_end - __kfuzztest_targets_start; + state.target_fops =3D kzalloc(sizeof(struct target_fops) * state.num_targ= ets, GFP_KERNEL); + if (!state.target_fops) + return -ENOMEM; + + /* Create the main "kfuzztest" directory in /sys/kernel/debug. */ + state.kfuzztest_dir =3D debugfs_create_dir("kfuzztest", NULL); + if (!state.kfuzztest_dir) { + pr_warn("kfuzztest: could not create 'kfuzztest' debugfs directory"); + return -ENOMEM; + } + if (IS_ERR(state.kfuzztest_dir)) { + pr_warn("kfuzztest: could not create 'kfuzztest' debugfs directory"); + err =3D PTR_ERR(state.kfuzztest_dir); + state.kfuzztest_dir =3D NULL; + return err; + } + + err =3D initialize_config_dir(&state); + if (err) + goto cleanup_failure; + + for (targ =3D __kfuzztest_targets_start; targ < __kfuzztest_targets_end; = targ++, i++) { + state.target_fops[i].target =3D (struct file_operations){ + .owner =3D THIS_MODULE, + .write =3D targ->write_input_cb, + }; + err =3D initialize_target_dir(&state, targ, &state.target_fops[i]); + /* Bail out if a single target fails to initialize. This avoids + * partial setup, and a failure here likely indicates an issue + * with debugfs. */ + if (err) + goto cleanup_failure; + pr_info("kfuzztest: registered target %s", targ->name); + } + return 0; + +cleanup_failure: + cleanup_kfuzztest_state(&state); + return err; +} + +static void __exit kfuzztest_exit(void) +{ + pr_info("kfuzztest: exiting"); + cleanup_kfuzztest_state(&state); +} + +module_init(kfuzztest_init); +module_exit(kfuzztest_exit); diff --git a/lib/kfuzztest/parse.c b/lib/kfuzztest/parse.c new file mode 100644 index 000000000000..22c00c2380c6 --- /dev/null +++ b/lib/kfuzztest/parse.c @@ -0,0 +1,236 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * KFuzzTest input parsing and validation. + * + * Copyright 2025 Google LLC + */ +#include +#include + +static int kfuzztest_relocate_v0(struct reloc_region_array *regions, struc= t reloc_table *rt, + unsigned char *payload_start, unsigned char *payload_end) +{ + unsigned char *poison_start, *poison_end; + struct reloc_region reg, src, dst; + uintptr_t *ptr_location; + struct reloc_entry re; + size_t i; + int ret; + + /* Patch pointers. */ + for (i =3D 0; i < rt->num_entries; i++) { + re =3D rt->entries[i]; + src =3D regions->regions[re.region_id]; + ptr_location =3D (uintptr_t *)(payload_start + src.offset + re.region_of= fset); + if (re.value =3D=3D KFUZZTEST_REGIONID_NULL) + *ptr_location =3D (uintptr_t)NULL; + else if (re.value < regions->num_regions) { + dst =3D regions->regions[re.value]; + *ptr_location =3D (uintptr_t)(payload_start + dst.offset); + } else { + return -EINVAL; + } + } + + /* Poison the padding between regions. */ + for (i =3D 0; i < regions->num_regions; i++) { + reg =3D regions->regions[i]; + + /* Points to the beginning of the inter-region padding */ + poison_start =3D payload_start + reg.offset + reg.size; + if (i < regions->num_regions - 1) + poison_end =3D payload_start + regions->regions[i + 1].offset; + else + poison_end =3D payload_end; + + if (poison_end > payload_end) + return -EINVAL; + + ret =3D kasan_poison_range(poison_start, poison_end - poison_start); + if (ret) + return ret; + } + + /* Poison the padded area preceding the payload. */ + return kasan_poison_range(payload_start - rt->padding_size, rt->padding_s= ize); +} + +static bool kfuzztest_input_is_valid(struct reloc_region_array *regions, s= truct reloc_table *rt, + unsigned char *payload_start, unsigned char *payload_end) +{ + size_t payload_size =3D payload_end - payload_start; + struct reloc_region reg, next_reg; + size_t usable_payload_size; + uint32_t region_end_offset; + struct reloc_entry reloc; + uint32_t i; + + if (payload_start > payload_end) + return false; + if (payload_size < KFUZZTEST_POISON_SIZE) + return false; + if ((uintptr_t)payload_end % KFUZZTEST_POISON_SIZE) + return false; + usable_payload_size =3D payload_size - KFUZZTEST_POISON_SIZE; + + for (i =3D 0; i < regions->num_regions; i++) { + reg =3D regions->regions[i]; + if (check_add_overflow(reg.offset, reg.size, ®ion_end_offset)) + return false; + if ((size_t)region_end_offset > usable_payload_size) + return false; + + if (i < regions->num_regions - 1) { + next_reg =3D regions->regions[i + 1]; + if (reg.offset > next_reg.offset) + return false; + /* Enforce the minimum poisonable gap between + * consecutive regions. */ + if (reg.offset + reg.size + KFUZZTEST_POISON_SIZE > next_reg.offset) + return false; + } + } + + if (rt->padding_size < KFUZZTEST_POISON_SIZE) { + pr_info("validation failed because rt->padding_size =3D %u", rt->padding= _size); + return false; + } + + for (i =3D 0; i < rt->num_entries; i++) { + reloc =3D rt->entries[i]; + if (reloc.region_id >=3D regions->num_regions) + return false; + if (reloc.value !=3D KFUZZTEST_REGIONID_NULL && reloc.value >=3D regions= ->num_regions) + return false; + + reg =3D regions->regions[reloc.region_id]; + if (reloc.region_offset % (sizeof(uintptr_t)) || reloc.region_offset + s= izeof(uintptr_t) > reg.size) + return false; + } + + return true; +} + +static int kfuzztest_parse_input_v0(unsigned char *input, size_t input_siz= e, struct reloc_region_array **ret_regions, + struct reloc_table **ret_reloc_table, unsigned char **ret_payload_= start, + unsigned char **ret_payload_end) +{ + size_t reloc_entries_size, reloc_regions_size; + unsigned char *payload_end, *payload_start; + size_t reloc_table_size, regions_size; + struct reloc_region_array *regions; + struct reloc_table *rt; + size_t curr_offset =3D 0; + + if (input_size < sizeof(struct reloc_region_array) + sizeof(struct reloc_= table)) + return -EINVAL; + + regions =3D (struct reloc_region_array *)input; + if (check_mul_overflow(regions->num_regions, sizeof(struct reloc_region),= &reloc_regions_size)) + return -EINVAL; + if (check_add_overflow(sizeof(*regions), reloc_regions_size, ®ions_siz= e)) + return -EINVAL; + + curr_offset =3D regions_size; + if (curr_offset > input_size) + return -EINVAL; + if (input_size - curr_offset < sizeof(struct reloc_table)) + return -EINVAL; + + rt =3D (struct reloc_table *)(input + curr_offset); + + if (check_mul_overflow((size_t)rt->num_entries, sizeof(struct reloc_entry= ), &reloc_entries_size)) + return -EINVAL; + if (check_add_overflow(sizeof(*rt), reloc_entries_size, &reloc_table_size= )) + return -EINVAL; + if (check_add_overflow(reloc_table_size, rt->padding_size, &reloc_table_s= ize)) + return -EINVAL; + + if (check_add_overflow(curr_offset, reloc_table_size, &curr_offset)) + return -EINVAL; + if (curr_offset > input_size) + return -EINVAL; + + payload_start =3D input + curr_offset; + payload_end =3D input + input_size; + + if (!kfuzztest_input_is_valid(regions, rt, payload_start, payload_end)) + return -EINVAL; + + *ret_regions =3D regions; + *ret_reloc_table =3D rt; + *ret_payload_start =3D payload_start; + *ret_payload_end =3D payload_end; + return 0; +} + +static int kfuzztest_parse_and_relocate_v0(unsigned char *input, size_t in= put_size, void **arg_ret) +{ + unsigned char *payload_start, *payload_end; + struct reloc_region_array *regions; + struct reloc_table *reloc_table; + int ret; + + ret =3D kfuzztest_parse_input_v0(input, input_size, ®ions, &reloc_tabl= e, &payload_start, &payload_end); + if (ret < 0) + return ret; + + ret =3D kfuzztest_relocate_v0(regions, reloc_table, payload_start, payloa= d_end); + if (ret < 0) + return ret; + *arg_ret =3D (void *)payload_start; + return 0; +} + +int kfuzztest_parse_and_relocate(void *input, size_t input_size, void **ar= g_ret) +{ + size_t header_size =3D 2 * sizeof(u32); + u32 version, magic; + + if (input_size < sizeof(u32) + sizeof(u32)) + return -EINVAL; + + magic =3D *(u32 *)input; + if (magic !=3D KFUZZTEST_HEADER_MAGIC) + return -EINVAL; + + version =3D *(u32 *)(input + sizeof(u32)); + switch (version) { + case KFUZZTEST_V0: + return kfuzztest_parse_and_relocate_v0(input + header_size, input_size -= header_size, arg_ret); + } + + return -EINVAL; +} + +int kfuzztest_write_cb_common(struct file *filp, const char __user *buf, s= ize_t len, loff_t *off, void **test_buffer) +{ + void *buffer; + ssize_t ret; + + /* + * Taint the kernel on the first fuzzing invocation. The debugfs + * interface provides a high-risk entry point for userspace to + * call kernel functions with untrusted input. + */ + if (!test_taint(TAINT_TEST)) + add_taint(TAINT_TEST, LOCKDEP_STILL_OK); + + if (len >=3D KFUZZTEST_MAX_INPUT_SIZE) { + pr_warn("kfuzztest: user input of size %zu is too large", len); + return -EINVAL; + } + + buffer =3D (char *)kzalloc(len, GFP_KERNEL); + if (!buffer) + return -ENOMEM; + + ret =3D simple_write_to_buffer(buffer, len, off, buf, len); + if (ret !=3D len) { + kfree(buffer); + return -EFAULT; + } + + *test_buffer =3D buffer; + return 0; +} diff --git a/tools/testing/kfuzztest-bridge/kfuzztest-bridge b/tools/testin= g/kfuzztest-bridge/kfuzztest-bridge new file mode 100755 index 0000000000000000000000000000000000000000..e15ac6486c667416d2c37b63935= 8d71a00149d76 GIT binary patch literal 911160 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

yiyw)f~|@$~Hk=3DNq41 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 T*- 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ð!;rTzHS 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

{!9SRnI3=3D7ZX;Fh7CJN9KdfN9KdfN9Kdf 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 BTp3=3DBcs3=3D9$6 z3=3DDDH3=3DApU3=3DCP^3=3DH|)3=3DGBG3=3DHMm3=3DB2g3=3D9q23=3DA#Y3=3DAFI3=3D= BQo3=3D9*v85pK; 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

#0(8g-7WJSwd9r|kA*15& z{~Mq*ip9;)!wSIe6!6(D0lu#xW+4N^ zg4(~3`8y^TXypSrH@IRU1H+SAsGphK;c}onFl8YFgGSxo|7IZnf%5>UY=3Dy6Da{}4m z1DQeffekW)+;wIl1A{^R-~T)0v0ha=3DrsR@oIwY31G0KignE!OL20UG z5d(up>)-!M>`3Q)Ag>Q*0qX&Erx-x>>=3Duyvp1+VgtYLdK!F9hE_^1cy);OkzATJ}f zXoAnL`LKwAVND;jtpawR8!sF5?ppAH@!*n}0X)tvvzUQFq5tpySdibr`;LQP>zgNl zjCSQ_Y5=3DcLIR_pLhVF<2`HF$z(LE+sW`-XO5-bc1SNIqhWT2ZL9|STmxUGZCTbyBF zU;sriNJqiCui)_q(3y)cv0YFx&>ikDF_!fZb-j!Ty?*Pzg3rd;j3hR9J!Bs85|UUS zRPPTYu^Uh^IVOa8N*f@0O_9WeH+%(;p-x~%sEgYGnLAp;iV(|$iZQVv#7dxIsYqh=3D z8@__?8EHilbJ++9mt{y|c^e^iaIz!JtK0}#OR9<__Hg4@aG7Py&cFbwIzVCiVdGcu zSa&dz*vpMy!Dr+)BkA3=3D2_m)nDLB(eXyzJkv{-Hs$yx(A~79+Ft)K8QM2PKdoA zJKpbysMA3b`+N`*m!42DP`Erf_!T^MTEU43tF%L3!R!5nxFF_%)Xg~r(Hny#)(aK; zizHTe2$Ck_xDk3!K*joy#Doq*)U84ii#hxiT(^Bh65Dt9>wnO_wQqP3<~=3DLq{NUp$SkiP#hgS3Q6M=3DpkknKet#6=3D4@Lom-d|8LStK#mW01MCXe6-* zr@sC-Wnf^4M-sC+4RIgHY>=3DHGddEvhp8=3DFNKtpICu`e&bg3s~>?LPobmx0s@y#5N_ z2MW4t5L6t4#O}QP3LZlT9Y+pQ2htny?kjlT3g}2EkQ$I!%Db=3DNb5lWk4?y;S#2&o+ z3f?aZ+G-24H|G7<|2>Qh450OLAoD=3D_Z+!UrKZ2Qo0W{;E!V1_sdm;4r;6{(SxaRDgj2bQTj#YzyzV|I3*e7(na7 zKyCrq8zAuQ|4T*&h9m(72ADb>p>JTnRUw6`h0r(f`DnEQ3=3DAN>AbY0>eFL9k*Mp>P zg3vecJs14~3=3DE*I6v&P>!r%TsWnf^~3bg~Iw?pI`c%SSEB)u&n-~NAKVqiE8wF9I# zLHrwd{lz^2L|)Ai{|4T_@)AjJh4?q{TIDxLVlCp|z++JFk;Ep5e*^E8`6R%=3D01MMS zvfsdC;v#~G^mjt`8~A)xaU`)TvJiWvki;IyLhO}A5_=3D;Hu~z{}?1${P|FNtL49bFt zaCT9K*lUfXEDh9G+g3dSa`nhvZ zF_3vVy5IhTHrG6aihHqeB9U}t+=3DpJEM+ITSG+kZVK28M}9>i$gn_Fs>YfdO=3D$4=3D4|U{3|i# z8+dHz8j`w{so(x5FflMBA-QG4^l#vOrBz67xikG6xD2aB662Tw5o#w~h8f@f-(qB7m&bx<*ox*xN?fzJv#C~H@;ZL7~vy&&^q=3D6?GRDsQ-jAz=3D^FD>3gIc>SH6FhcK=3DdEdZ&LsKMm3iH2# z*Zq4SiS^9?2JX8=3D3o|f)rbj?_yjTDUzjh=3DslSSXaXN7Er>IJDYSPTh+(@-&xTh=3DW8 z1}=3DB+A-P3k$v5yA(HCJvx=3DLB{?f(e|28QoQ>J*lK1CNdIi6GR)EQRD5K_oGbW#7Q} zeTs-6{5xgYxBrtF85p!gAmIXXpTdf7;5&nypkg5R-GPdQB8kmd`3<}tFaybsEi1qM zKgYnpkd36SVAVJ9y-IZ=3D3=3DE(yC&-R9tH1rXVPs(VgOt{8toio;JOcy64iQBBPFefy zza1k3!)2&>AiW3HLCWmcNcQeo_w9cG69a=3D16Qpbhsr#`3Qm$DtAl5MeN9)3^UcObiS$NMamYzk&C&gYIdE)iYPNLGpeN)Lu|nF>Hs3%|;T_ z+5YYSTLuP(RZIxKaqNJUS4Wv3^$bYwksaT_`>7uz>HV8&~b?LTNO?I$FA zXPo#3zE_Bg1>!!Cc_Jsj{XfIXz#t111L?hR?%V$oMg|5`7Kr;mVm22b=3DYoYp)q(V` zxbO|U?k0-`k?yx#fZTPHizK$;!Z+~zPyv$InhTJ!2{ac8YYW_fs%t`0cjdx2@VIg- zlD!2Nzx@ZLsTnK?|IWGm?Y}e=3D1H(S3I*^-JT>S>VKkgcm*q3YHz-J`CgNlLtk#POn ze;GywhMyvka0cnkxdAD6RYf6T1rpnF>)U@&JlZ0OUAYTs=3DY)zP!r;N(Z~qT7GcZIT zshjfIEf+L_v6Jk@R_m!P<0@^ zTV8$xpN*1?BsSsIH}HD%G98l)NN$OF2T9{ckkm!IgQz=3D> z9?LVlz;Sh&}JxDC%+c)t1 zj)FKMoF{zy_Wvg{1A{)2x|(0#z-NZKizC8M;`cZ3x!-Z(Nb&m{Qnn`|i3R-r_8&B6 zl!7Ey^ZOfk?|eFvn8crN;QP|Ep!R~|cgde`|9>$uFw{WBKyIG!4-!^Wko5NagQT_T zNMapOb+eGfTK+-eV=3Dj_d161zjcD6@*O-L z>?eVU-zhBL!E1B_k;E3TeE)xdiGd+R0^t@P_V3_6QyG%F2=3D?#b{j-%w_O`Hp|L@Dd zz|e!F?g0CD@Elyf1fq`D;rI^T8#hY=3DkxnZ(zJt#JSb-#VgyTE754H`-ybBxpQqVco|7u2vqDEl2`y2#EzRtVlhy4caX$D<{2_DFx*EH zYvKA1u0I|ji9LXt_Y_I&4cB+@-6JoM#C~vn2k)(TjU@I3st$C&Fvt&}IA`F7=3D>3SK zj)(g@xIg^`DNH4}zk~aipa_MH6{v832d`!0l7yrUkeLBI5c8BI5$Pa?=3DR0_=3DSrw`d zWbX@}@8I!M3rR#7VZ!?zJSONbiHOSp-tXY{L6jt-{@ug({eLeT149GUJdnK>qTj*o z$r+N6Gzqffi|BXo+Lzr(>L!SP|1Sb+V@e{@-yDhW|Gk(P7``Bh-H`hJKZt>WK}-ta zJ{9Tj{~xh1Fz8Al{L7&5{r@7+azQDGc_4e|D186_k%56B0jdrp)}i?QKWJRI7^)8B z<|j(u!F%hbB8h!a{{DXl3j@P;B(XUf-@)sFZX${O(ER>ih?#-mH`ET0c`Ul$|Fdy2 zFbGQ{xzFtT|FZ%N4BALyd)&VNf5FJW;4BSsGf3|Y4@exPN+a@&isyImSt=3Dz^y&!)i zcz*vc!_2_YCJhN^klq|0h`LQk>Q?xC2aoq3L9!#n|NH-|j0_CVki--Mzk~OpbI3s4 z04ypjyWA0V+EP%%>(M0}V8LBifg29ee-1bzQMi;023AF3DRzL?PO|H~N} z7}8}Reglb}2>TAc->y=3DIfdO=3D-7D((#)c5~;85tP1$sp3&gqZK(e)4Uo`#|dM#C`|Q zN&kh~0dikP-1q;XtPBhSvJiiO)NM)r4ldh`WD)M$ko+Bd{-Y_9*q!9>;IlX^ki=3Ddj ze+QrIZjB@+lJfn(1``8=3Doh-s125H~H=3Dh6kpLc$7U@12bA;4z8}B)uG&-@$7kvXRuW zWPJy>OPZl#Ab%ueegE&w#K15ODh4udPR{rLos0|&>yZ2=3Dkq61Y7oh4udQbreCwjFH4riob)`=3D$k>sKz>Uof!JXM6$82DOv!ifT5nq`ce^|Nod67!Dwb z?dbjvKIi%flGu{I@8G`G38)w-tQPb^(%NYxu`^J0=3Da9r+^nL$-kBx!hB2*0ImMc>s z=3D3Rw~fy}!w6_P)0Ac_5fs=3DJLOCNb^%|NCqV4ELa7AoHHg`3{~xdIS{%nfG80#Ez#( zVt1hGULc9xnDhO=3DJv#%#Yp58=3DJd-65z3-u7AoC2Cd@K`RW0R&P564QaIW0FUtdyO@aaA8Ff3t0nk9|w|H zz?$#i_A@tyOip2Dv0|84mh7*wHRAay<`zk~O5YC^?8>M~A# z|F6fuz@UR9w&djZ|80y64Ej(pklujP5WU7wF_7Mz)8E14C1yxsD^7n0@1M1Vih=3Da1 zoQ1@PEmRDoSK;jU|DZ7+2dEfG-J0`|Hk=3DDo45V(y`S0L6TiubwST1}ApRMHu6$9y=3D za1mmMA5;vax98$_@K{D5lGurh5IaJU#I9WY{vUK@RXCEE!lm#3n;97xqM%|RJI-AG z4&Lh=3D2NeU^apUrL@EC0(l9*!`ZAkd>UzCY~;el3{?jbGfDpOKbe_<;Tu#8lwKyJ{Q$RZ`4k}Lfz;Kc|M>rsfq_90Nh~7c z2RQATC_vgOAazSJe*BMTW?*oJssow#A^Qh-t|M9jQP#c5{sAt>sut`SLHOwN!0p!GH_NN%af`2pTvH5p0Wl$;;nvThoZ*oK@R z|3Pz{Gofw<*d0(5vbTXB(V#*5PR<;+3_a#2e@8+fF$-J z_Xl`<<1vyQC3z6{eM3?=3D0V?(rNo-Bt5AdALA0)9GP%)4rVf{Cj{2%|9Gcqu6DMI2B z6dwx;e*BLD_3e?w-W2`-ul=3Dxsih;slN6`=3DPo=3DIOMF_q#U;Im2-6dB-iy#Y|MawM^u z;veAqL;DmV_JYjgD1nGAL=3Du})@&jBiY*9p{jSVF~{_kL5VAzgiUQ8)O-B~1c6;QDY zNMch;e}LyiE-NxHfX3NC_9~S9_z#+|eurf5p0XeR>lqjr7?lw2(T431_p+ANMcLs ze}Ko$J|c-7sQ>YQ3n=3DVa5qUbN;m7|Qj0_A4tcX6RMbi)P`Mln&kT?SQV@m4}@L6fe ztcW-&X#4R$o0Wl~5=3Dq^e?jPVigP?PgVCkTu=3DLfj|u>qdJq#5C+0oGV z8A>1M{=3D?C~84>>kSS_7&3GWiF1O@af`dZ~aZKmNaA zVqkDaQl~Th$Nx8s3=3DEl2bs)VQGk^RCjoaiR+3{rKkN=3D>(A)Rax|AN#pZ2s|oD;ER9 zDkODl_Wl6RX&!>A1Nlv2-;e)S7#SFDBB^6J@B`de`=3DSJKGf3Tm13$oH@chaUJ3wMQ z2Y-P3=3DW5D`bl-9C2ly^CO=3DUzJnH>HB9%BquhJ*`9?}5WV{$FKcV90=3Dqf!y44?8pCA zj0_A7$_xykP2M0ejT1k>V_(~p8Q|+TT2B1<|Bj7;;V6>cg!4bZ_l(>{QuhWb_6A9; z;=3D&K`oa=3D8Su`d^Xfaip{R1kJFT!e^8B8l-_g5+rp6+|9fap?zmzQuK)X{{cSV!Ace47LeaK z9{vEYUkgXl>+ z3wibfyq;zXl32pCAOD3|85pJ`xh3cIkN=3D+;7#KD~?FH$Lc=3DH21UvUgc@02%?Gy8X^p8zCzk&mTHjj1G(?T*B{{dRevP0ly5)&?_gwL_=3DuFJ1%CYa|A~u%ftMX& z-XEr);P!?lbX_FKydO+I!DX=3DylGqofpZ}M0Gcf2w#X$a;!1oh;?vx!=3D45XKbA0p<6 zB-X+I6TG)KO$`x8B?3RecbGLo{RYx2AovqJRy74F3~U5{g2Ud09T6@af z>90lbCwRVM8IpMlLO;Rtc{`EJs}cGM4(Ag{VYNaC5(f8?%v%B#dxRvmK*YBLQ_tID`BaqVN-ZhQ2aX45aRX(ogXD=3Dho_wZ~=3D+E zQT_?;OU9}r;@3ju=3Dl?s*3=3DAbmdRa7ng2$VBkn}2O{sfO>u0v91qx%!Q59}C{c{g-_ zg6}W5i=3D^&}!O#Ce%nS@)k;Dv4euCGk@oFH#*~a82_#PwyB(VsSpWwPySOXD9E~Y=3Dh zZIw8rbP!rlkJ-AHd7NkcT98q3GxT zLN*45sYqfrl|TQl!AxHU@^rNMbDAKmSkWW?Z`9Hz! z=3DN70KD6Q?7|MP!1s9b}Jf$U{j`V-tvT#sa)z|x=3DK_Sz;SF`K23ytNfc%wp+JaDBN$ z15%%Z?AWsOCwRTeZKODVu=3DMBupNtF)FQMu{_MTb(6I>RHY9i9mjpaYV=3DU+-_BGQY< zil5+p2kM%L@H1HT6MV0|Cz851tA2v-uaD3~gsH@)pWr*{3!v&i_Nr|832v`7L+u5L zZP@w~+^=3Dniih=3Dwgvkj6?yO6{*pklp9VkS_r2}oiN+kS%YqMwW;RI1ElGu!G zKmUX7p`VH5x0W4{vSc^ZA0W4U*zps5xBNM%7|6{rhkt_akAH?Frg7#cxNqR*uF zD`$R!?}X>oLWGOM`JdpqPgN~MIQN|Y3BKdqkQ1R!;`vYTJ?*|wF_3vrp8o`o-Q!E<-%NcMht_Y-`VdKr?s51%1=3D`;f$PzWxM{ zWh_GytN8vCJYTy{3z27zeE$i)@BA{7x&k)H{jjf*#A?_fca}42BmD7#9dche8vcACzsHMgcT@U)^Pj+mw(#Y2)CSoiX|Yg(}#*BBZ)C^LiDB~iOF#O z0_USlPK3Q4oRIs(osjJK!U?%6JQC^_P}-Ql_X~U4-w^=3DRS%gRw4H5|5XMChPzNPko#Q3A$M+nKq^liq#<`@iy`e_h>`vU zzAJkxGz>uY-jIXbhkX_){7mG3f$zP3f}}1%0dl|fA0%~e6d-q53+o`oha%+uY9$>+ z8d{B(WSN$lcZ2I*9l+P$v?Le8ybT(V`<-35AZ`ZPamE{x2NSp;ZU%|n@PXXJT#KY`i{CHsUCUFs zAmu$M&KLOq0{441AgS9E0J*351XK*9E+Y_fPx5W3UXUFv36MLE8Iks)Oh|y}W#LBH zVUzd^ydFuO8{%e=3Dc{dUv_Z1(7`WIxLOETn6;=3D4K!y&$mzDUdsd|3TveBz7hha<8zo zF2cVj(jf6>p^HdEBI%Gjg57ix<|$-A?g38MMWid4j9=3Dih6|K0HK+{l64vunhSNE=3DJ?Aa~;?A&DgvLhiAh1PyzT-ZLe?z<1fLgNlLN zyrL9x-|RuC7)V`6Ipj{+n@C~|b&&gDzaoj{)I;(DFApR>K<3S;hurt7!h=3D|cY|;d| zyETRf5g!MdA@{S^@j${EWbd4wU*NHuX-MiS`hJ1eBQfY9;%!OaFYvvp%t&Gf`hJ1u zt=3DN#n?)3cv*WH|Y5IaEb>*$Aw$smcDO!x&J%h1^ud&0|3UYYeuIjE-1lZSq|W2hN312eG4B`nUQr)?h?_y`R2KgN?+=3DL6XMm4$ zDJ+4wZ<0PDUCAtg)V158X%b|w$C6+FL1!PH^c;4kFG+aRHYS#S%-?7PIfN;x-O~1f*X(|{% z(lf|?EL$LUI6~Ed^j_EkDN90-#MW&61@5z_8z90|VjHBK%t8`N+4c*(&LbB|?7_BQ z;QKBMki=3D}ZL-ZCSiFIs;q_r|6u_@bsf$zAiG(hCv3)_Ez$M7Z~sk7Pf3%n0#GLpKA z9lyYPWmX~iaN^_sCx|+1F5@k@7I6O9h2{%Vjy*Q zUO?1+f{KCE-FWfqKj@ChuTU|Nx+9+;>V87SKAooRDA&H&whTIitha?u^2e~KG2`UD1%Mw4x9g(hv zh`><7|0(c!H_#3(~-m+LVttrf6PV_n-lgMeD`BM zlGup|$i0unNMb2bkUJmCk;E><{s!OoSdAnWlL)!%u^vgRA{lbeV>6Q2lvKzakL`wt zviLwMhk#l(@s z0-$12NMboqF6s8XLK^~Ng;{NX@K0_XJm}1w>TOhcl3E8sWWMZ z+{2e>j7TpI?GS&YAc^_3L+;^AM-q!@hup)L1vL-kk0tGp^jCwVZb3Wb-o1Jxu{BV! zCM2;P?T|2NHAdvEkdEKrHqsPhL>p;B2jp(O`AF*CbU^OYTL<+oC|&*NgxsBX8cCf=3D z*KhE+-Yq2a9J(NP<2^-kOH3E!ZoC&re*4h{x&Q9BF(lqVc9``42Cqw#H9@#JpdWId zosJ12>}°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

!BAL`k%2+P1l252E;wJ2 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 Thu, 4 Dec 2025 14:13:13 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.43 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1764857598; cv=none; b=dm1ORhsJIMEzetXZJe6g/mg5Be+8Rk7/S7zk5qzh1/BwlAi7nyX4orNtKIVrNE8aLgbbcLPnLi5LCyZE9ao460+MDwrVUDvU9azo2b69BOuGIbFqCIL52FOLIBRsi5oiV9P9VEsnita5pTm7V+07HSWpN642GHd2QBOcJoIVnnQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1764857598; c=relaxed/simple; bh=yJTXGKmxPaPa831sMPuVVJbvuEKV/B/tluXyFivJR+c=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=sskTYFh6Wd1BOpRBgMAqw05azVcdB967wLJNx6nadgmrFOBgzi5pnI1G3nNOESDGKUauNm2lQBEYsPSWkG07wTKmebohWra+GOm5plMVf9HuAvNbkgfHSZnT3lFp/z6KT4hYQL319h9gnYvhwn7ry4Zu37wzPIeXYI/YanSg5Ig= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=ZAfr24wD; arc=none smtp.client-ip=209.85.128.43 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="ZAfr24wD" Received: by mail-wm1-f43.google.com with SMTP id 5b1f17b1804b1-4779a637712so7314565e9.1 for ; Thu, 04 Dec 2025 06:13:13 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1764857592; x=1765462392; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=GDhAaO62GeZEjvcXSV90iEd4Gov/jOXG3fZBUjkgHPA=; b=ZAfr24wD7Q5nP3YQJRURIAkrjZoqRfnBb1BE5LD4RK+5WkzmGEFmrIisRDjkRSg5JE 9TEFUb+ZEZDYd4Ug7GzKuXHaGHtBsGK99VqZmI0epvYsG5FZuiy1BB2Q5UWMr8i41/yT 8pkNGsuqLgO6BO/kNaRwIvJmzy7auuTPOb41rG8IRW3qdv8jMgQHAKN0WfILyx/qWhu/ NsRi4qc9GAQ0h5Uz0WsalWgJU5KAGHY/VRLL/VxzdMRUQPf9nH8sFPXaPwXmSW4zfjCt EsH0JRfcv99xYeNkjVGbDr8VvQBcjsO/UxNFHmqF2XZ2A2uFOL2bv4Xt3V6hiIwYtGJY 0Mog== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1764857592; x=1765462392; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=GDhAaO62GeZEjvcXSV90iEd4Gov/jOXG3fZBUjkgHPA=; b=dmkmW3dyXGMO4jDX1hyF3gEEc749UksbtPaf1sYFSzor9YIjnKrPJUkbgOuEs8rtcO X0AAG5HxwP2MUG5ePu9QhU74gXfJBJt4+z8uUEZtcP/lKzskvMdYvlljSh2ybyARq1nR AmQ5SH9PBpj6lHhKnSGMtEbgZqASD7u5xaNaTWArX3fmmnRFYgerdmZ4QuqBxY6BS6Au 30KP4vb7TqxST0vuLFq6wIowSkS5rexkwnG1KGxOExKh1eX7Ku1lHozeJwR7cUo6uWcy s+7zhc6/nyaaN8Jmf1qjPfPOFnzPXs9L+mS/stNIOcVhF9VsD0fp0JaSw+y2ayQz92AC zToQ== X-Forwarded-Encrypted: i=1; AJvYcCVzFeWB7GKagtiX1THG57QVcSKHwRWicaImXyoZgsVYkVMxp6CB/sQz3nNSa0MZYAqpQhTViDUjskmXTvQ=@vger.kernel.org X-Gm-Message-State: AOJu0YwbidJDFDE8T/ifJ/SEx4r2tAUfgE0nvffHJa8r5Ex3i9pj4G5Z C0NBDSjzGR75uR0xNvpqcXfvDKbK6VX7iUuEVl8pjxu1IBGL6BSiw0RY X-Gm-Gg: ASbGnctqxYLphEeNQ+I9hvoJEPJIdTuj1rJg3GfdnKowdPOaK2DAw1TQ7rpw+OjKM2v VAH0J0KsP4djItWTxxuIjkTxuwqX8ChHy/Ewsx8yEMQHE9am1iel/xPuCtItMDFhzFt6Jc76usH BVfXNw5JYQgyjAFCbmZWifswd1tlywSqU+7s4wDkZdPGmPdNT50/0/g0HChkasqFT/7ohoQ0+n0 NwW0qClQzjHt7245bVnXSG2vmWWh5NbtoR5btiDaXDPnIGohubMRUNq7uI2wXpnk0TVGuhkw0H5 TogffwwTgnLEm8vRXsJdyOhcWvPrP6b9k98UvyUtXpnbFKORZSqWHFQckp7l3WMsFbGpQ8TiRRo P8hHNwNWCiY8dRjSCvgmCt66IcXkJO5Iooh9s5dvnqFaU1TxM12MWsiux7viuUyMLTEdh3QNZuj 7GtfEASpxJ0OrpnAneTHd1ODwTq/A67mTeiF/bd3W/AMH+T8Wwtjl/5nFFHaSg04/ToA== X-Google-Smtp-Source: AGHT+IGxoPT6PorqdmEh0izrFtGIg9tPLm24NqGG8Q+Rxc2Y1AQr/iLL2QXTWy6xRs4AwnObAeOPbg== X-Received: by 2002:a05:600c:154e:b0:477:9cdb:e337 with SMTP id 5b1f17b1804b1-4792aedde78mr66509665e9.7.1764857591594; Thu, 04 Dec 2025 06:13:11 -0800 (PST) Received: from ethan-tp.d.ethz.ch (2001-67c-10ec-5744-8000--626.net6.ethz.ch. [2001:67c:10ec:5744:8000::626]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-42f7cbfeae9sm3605808f8f.13.2025.12.04.06.13.10 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 04 Dec 2025 06:13:11 -0800 (PST) From: Ethan Graham To: ethan.w.s.graham@gmail.com, glider@google.com Cc: andreyknvl@gmail.com, andy@kernel.org, andy.shevchenko@gmail.com, brauner@kernel.org, brendan.higgins@linux.dev, davem@davemloft.net, davidgow@google.com, dhowells@redhat.com, dvyukov@google.com, elver@google.com, herbert@gondor.apana.org.au, ignat@cloudflare.com, jack@suse.cz, jannh@google.com, johannes@sipsolutions.net, kasan-dev@googlegroups.com, kees@kernel.org, kunit-dev@googlegroups.com, linux-crypto@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org, lukas@wunner.de, rmoar@google.com, shuah@kernel.org, sj@kernel.org, tarasmadan@google.com, Ethan Graham Subject: [PATCH 05/10] tools: add kfuzztest-bridge utility Date: Thu, 4 Dec 2025 15:12:44 +0100 Message-ID: <20251204141250.21114-6-ethan.w.s.graham@gmail.com> X-Mailer: git-send-email 2.51.0 In-Reply-To: <20251204141250.21114-1-ethan.w.s.graham@gmail.com> References: <20251204141250.21114-1-ethan.w.s.graham@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Ethan Graham Introduce the kfuzztest-bridge tool, a userspace utility for sending structured inputs to KFuzzTest harnesses via debugfs. The bridge takes a textual description of the expected input format, a file containing random bytes, and the name of the target fuzz test. It parses the description, encodes the random data into the binary format expected by the kernel, and writes the result to the corresponding debugfs entry. This allows for both simple manual testing and integration with userspace fuzzing engines. For example, it can be used for smoke testing by providing data from /dev/urandom, or act as a bridge for blob-based fuzzers (e.g., AFL) to target KFuzzTest harnesses. Signed-off-by: Ethan Graham Signed-off-by: Ethan Graham Reviewed-by: Alexander Potapenko --- PR v2: - Move kfuzztest-bridge tool under tools/testing, as suggested by SeongJae Park. - Cleanup several resource leaks that were pointed out by Alexander Potapenko. PR v1: - Add additional context in header comment of kfuzztest-bridge/parser.c. - Add some missing NULL checks. - Refactor skip_whitespace() function in input_lexer.c. - Use ctx->minalign to compute correct region alignment, which is read from /sys/kernel/debug/kfuzztest/_config/minalign. --- --- tools/Makefile | 18 +- tools/testing/kfuzztest-bridge/.gitignore | 2 + tools/testing/kfuzztest-bridge/Build | 6 + tools/testing/kfuzztest-bridge/Makefile | 49 ++ tools/testing/kfuzztest-bridge/bridge.c | 115 +++++ tools/testing/kfuzztest-bridge/byte_buffer.c | 85 ++++ tools/testing/kfuzztest-bridge/byte_buffer.h | 31 ++ tools/testing/kfuzztest-bridge/encoder.c | 390 ++++++++++++++++ tools/testing/kfuzztest-bridge/encoder.h | 16 + tools/testing/kfuzztest-bridge/input_lexer.c | 256 +++++++++++ tools/testing/kfuzztest-bridge/input_lexer.h | 58 +++ tools/testing/kfuzztest-bridge/input_parser.c | 423 ++++++++++++++++++ tools/testing/kfuzztest-bridge/input_parser.h | 82 ++++ tools/testing/kfuzztest-bridge/rand_stream.c | 77 ++++ tools/testing/kfuzztest-bridge/rand_stream.h | 57 +++ 15 files changed, 1662 insertions(+), 3 deletions(-) create mode 100644 tools/testing/kfuzztest-bridge/.gitignore create mode 100644 tools/testing/kfuzztest-bridge/Build create mode 100644 tools/testing/kfuzztest-bridge/Makefile create mode 100644 tools/testing/kfuzztest-bridge/bridge.c create mode 100644 tools/testing/kfuzztest-bridge/byte_buffer.c create mode 100644 tools/testing/kfuzztest-bridge/byte_buffer.h create mode 100644 tools/testing/kfuzztest-bridge/encoder.c create mode 100644 tools/testing/kfuzztest-bridge/encoder.h create mode 100644 tools/testing/kfuzztest-bridge/input_lexer.c create mode 100644 tools/testing/kfuzztest-bridge/input_lexer.h create mode 100644 tools/testing/kfuzztest-bridge/input_parser.c create mode 100644 tools/testing/kfuzztest-bridge/input_parser.h create mode 100644 tools/testing/kfuzztest-bridge/rand_stream.c create mode 100644 tools/testing/kfuzztest-bridge/rand_stream.h diff --git a/tools/Makefile b/tools/Makefile index c31cbbd12c45..dfb0cd19aeb9 100644 --- a/tools/Makefile +++ b/tools/Makefile @@ -21,6 +21,7 @@ help: @echo ' hv - tools used when in Hyper-V clients' @echo ' iio - IIO tools' @echo ' intel-speed-select - Intel Speed Select tool' + @echo ' kfuzztest-bridge - KFuzzTest userspace utility' @echo ' kvm_stat - top-like utility for displaying kvm sta= tistics' @echo ' leds - LEDs tools' @echo ' nolibc - nolibc headers testing and installation' @@ -98,6 +99,9 @@ sched_ext: FORCE selftests: FORCE $(call descend,testing/$@) =20 +kfuzztest-bridge: FORCE + $(call descend,testing/kfuzztest-bridge) + thermal: FORCE $(call descend,lib/$@) =20 @@ -126,7 +130,8 @@ all: acpi counter cpupower gpio hv firewire \ perf selftests bootconfig spi turbostat usb \ virtio mm bpf x86_energy_perf_policy \ tmon freefall iio objtool kvm_stat wmi \ - debugging tracing thermal thermometer thermal-engine ynl + debugging tracing thermal thermometer thermal-engine ynl \ + kfuzztest-bridge =20 acpi_install: $(call descend,power/$(@:_install=3D),install) @@ -140,6 +145,9 @@ counter_install firewire_install gpio_install hv_instal= l iio_install perf_instal selftests_install: $(call descend,testing/$(@:_install=3D),install) =20 +kfuzztest-bridge_install: + $(call descend,testing/kfuzztest-bridge,install) + thermal_install: $(call descend,lib/$(@:_install=3D),install) =20 @@ -170,7 +178,8 @@ install: acpi_install counter_install cpupower_install = gpio_install \ virtio_install mm_install bpf_install x86_energy_perf_policy_install \ tmon_install freefall_install objtool_install kvm_stat_install \ wmi_install debugging_install intel-speed-select_install \ - tracing_install thermometer_install thermal-engine_install ynl_install + tracing_install thermometer_install thermal-engine_install ynl_install \ + kfuzztest-bridge_install =20 acpi_clean: $(call descend,power/acpi,clean) @@ -200,6 +209,9 @@ sched_ext_clean: selftests_clean: $(call descend,testing/$(@:_clean=3D),clean) =20 +kfuzztest-bridge_clean: + $(call descend,testing/kfuzztest-bridge,clean) + thermal_clean: $(call descend,lib/thermal,clean) =20 @@ -230,6 +242,6 @@ clean: acpi_clean counter_clean cpupower_clean hv_clean= firewire_clean \ freefall_clean build_clean libbpf_clean libsubcmd_clean \ gpio_clean objtool_clean leds_clean wmi_clean firmware_clean debugging_c= lean \ intel-speed-select_clean tracing_clean thermal_clean thermometer_clean t= hermal-engine_clean \ - sched_ext_clean ynl_clean + sched_ext_clean ynl_clean kfuzztest-bridge_clean =20 .PHONY: FORCE diff --git a/tools/testing/kfuzztest-bridge/.gitignore b/tools/testing/kfuz= ztest-bridge/.gitignore new file mode 100644 index 000000000000..4aa9fb0d44e2 --- /dev/null +++ b/tools/testing/kfuzztest-bridge/.gitignore @@ -0,0 +1,2 @@ +# SPDX-License-Identifier: GPL-2.0-only +kfuzztest-bridge diff --git a/tools/testing/kfuzztest-bridge/Build b/tools/testing/kfuzztest= -bridge/Build new file mode 100644 index 000000000000..d07341a226d6 --- /dev/null +++ b/tools/testing/kfuzztest-bridge/Build @@ -0,0 +1,6 @@ +kfuzztest-bridge-y +=3D bridge.o +kfuzztest-bridge-y +=3D byte_buffer.o +kfuzztest-bridge-y +=3D encoder.o +kfuzztest-bridge-y +=3D input_lexer.o +kfuzztest-bridge-y +=3D input_parser.o +kfuzztest-bridge-y +=3D rand_stream.o diff --git a/tools/testing/kfuzztest-bridge/Makefile b/tools/testing/kfuzzt= est-bridge/Makefile new file mode 100644 index 000000000000..6e110bdeaee5 --- /dev/null +++ b/tools/testing/kfuzztest-bridge/Makefile @@ -0,0 +1,49 @@ +# SPDX-License-Identifier: GPL-2.0 +# Makefile for KFuzzTest-Bridge +include ../../scripts/Makefile.include + +bindir ?=3D /usr/bin + +ifeq ($(srctree),) +srctree :=3D $(patsubst %/,%,$(dir $(CURDIR))) +srctree :=3D $(patsubst %/,%,$(dir $(srctree))) +srctree :=3D $(patsubst %/,%,$(dir $(srctree))) +endif + +MAKEFLAGS +=3D -r + +override CFLAGS +=3D -O2 -g +override CFLAGS +=3D -Wall -Wextra +override CFLAGS +=3D -D_GNU_SOURCE +override CFLAGS +=3D -I$(OUTPUT)include -I$(srctree)/tools/include + +ALL_TARGETS :=3D kfuzztest-bridge +ALL_PROGRAMS :=3D $(patsubst %,$(OUTPUT)%,$(ALL_TARGETS)) + +KFUZZTEST_BRIDGE_IN :=3D $(OUTPUT)kfuzztest-bridge-in.o +KFUZZTEST_BRIDGE :=3D $(OUTPUT)kfuzztest-bridge + +all: $(ALL_PROGRAMS) + +export srctree OUTPUT CC LD CFLAGS +include $(srctree)/tools/build/Makefile.include + +$(KFUZZTEST_BRIDGE_IN): FORCE + $(Q)$(MAKE) $(build)=3Dkfuzztest-bridge + +$(KFUZZTEST_BRIDGE): $(KFUZZTEST_BRIDGE_IN) + $(QUIET_LINK)$(CC) $(CFLAGS) $< -o $@ $(LDFLAGS) + +clean: + rm -f $(ALL_PROGRAMS) + find $(or $(OUTPUT),.) -name '*.o' -delete -o -name '\.*.d' -delete -o -n= ame '\.*.o.cmd' -delete + +install: $(ALL_PROGRAMS) + install -d -m 755 $(DESTDIR)$(bindir); \ + for program in $(ALL_PROGRAMS); do \ + install $$program $(DESTDIR)$(bindir); \ + done + +FORCE: + +.PHONY: all install clean FORCE prepare diff --git a/tools/testing/kfuzztest-bridge/bridge.c b/tools/testing/kfuzzt= est-bridge/bridge.c new file mode 100644 index 000000000000..aec0eb4e9ff7 --- /dev/null +++ b/tools/testing/kfuzztest-bridge/bridge.c @@ -0,0 +1,115 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * KFuzzTest tool for sending inputs into a KFuzzTest harness + * + * Copyright 2025 Google LLC + */ +#include +#include +#include +#include +#include + +#include "byte_buffer.h" +#include "encoder.h" +#include "input_lexer.h" +#include "input_parser.h" +#include "rand_stream.h" + +static int invoke_kfuzztest_target(const char *target_name, const char *da= ta, ssize_t data_size) +{ + ssize_t bytes_written; + char *buf =3D NULL; + int ret; + int fd; + + if (asprintf(&buf, "/sys/kernel/debug/kfuzztest/%s/input", target_name) <= 0) + return -ENOMEM; + + fd =3D openat(AT_FDCWD, buf, O_WRONLY, 0); + if (fd < 0) { + ret =3D -errno; + goto out_free; + } + + /* + * A KFuzzTest target's debugfs handler expects the entire input to be + * written in a single contiguous blob. Treat partial writes as errors. + */ + bytes_written =3D write(fd, data, data_size); + if (bytes_written !=3D data_size) { + ret =3D (bytes_written < 0) ? -errno : -EIO; + goto out_close; + } + ret =3D 0; + +out_close: + if (close(fd) !=3D 0 && ret =3D=3D 0) + ret =3D -errno; +out_free: + free(buf); + return ret; +} + +static int invoke_one(const char *input_fmt, const char *fuzz_target, cons= t char *input_filepath) +{ + struct ast_node *ast_prog; + struct byte_buffer *bb; + struct rand_stream *rs; + struct token **tokens; + size_t num_tokens; + size_t num_bytes; + int err; + + err =3D tokenize(input_fmt, &tokens, &num_tokens); + if (err) { + fprintf(stderr, "tokenization failed: %s\n", strerror(-err)); + return err; + } + + err =3D parse(tokens, num_tokens, &ast_prog); + if (err) { + fprintf(stderr, "parsing failed: %s\n", strerror(-err)); + goto cleanup_tokens; + } + + rs =3D new_rand_stream(input_filepath, 1024); + if (!rs) { + err =3D -ENOMEM; + goto cleanup_ast; + } + + err =3D encode(ast_prog, rs, &num_bytes, &bb); + if (err =3D=3D STREAM_EOF) { + fprintf(stderr, "encoding failed: reached EOF in %s\n", input_filepath); + err =3D -EINVAL; + goto cleanup_rs; + } else if (err) { + fprintf(stderr, "encoding failed: %s\n", strerror(-err)); + goto cleanup_rs; + } + + err =3D invoke_kfuzztest_target(fuzz_target, bb->buffer, (ssize_t)num_byt= es); + if (err) + fprintf(stderr, "invocation failed: %s\n", strerror(-err)); + + destroy_byte_buffer(bb); +cleanup_rs: + destroy_rand_stream(rs); +cleanup_ast: + destroy_ast_node(ast_prog); +cleanup_tokens: + destroy_tokens(tokens, num_tokens); + return err; +} + +int main(int argc, char *argv[]) +{ + if (argc !=3D 4) { + printf("Usage: %s \n"= , argv[0]); + printf("For more detailed information see Documentation/dev-tools/kfuzzt= est.rst\n"); + return 1; + } + + return invoke_one(argv[1], argv[2], argv[3]); +} diff --git a/tools/testing/kfuzztest-bridge/byte_buffer.c b/tools/testing/k= fuzztest-bridge/byte_buffer.c new file mode 100644 index 000000000000..1974dbf3862e --- /dev/null +++ b/tools/testing/kfuzztest-bridge/byte_buffer.c @@ -0,0 +1,85 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * A simple byte buffer implementation for encoding binary data + * + * Copyright 2025 Google LLC + */ +#include +#include +#include + +#include "byte_buffer.h" + +struct byte_buffer *new_byte_buffer(size_t initial_size) +{ + struct byte_buffer *ret; + size_t alloc_size =3D initial_size >=3D 8 ? initial_size : 8; + + ret =3D malloc(sizeof(*ret)); + if (!ret) + return NULL; + + ret->alloc_size =3D alloc_size; + ret->buffer =3D malloc(alloc_size); + if (!ret->buffer) { + free(ret); + return NULL; + } + ret->num_bytes =3D 0; + return ret; +} + +void destroy_byte_buffer(struct byte_buffer *buf) +{ + free(buf->buffer); + free(buf); +} + +int append_bytes(struct byte_buffer *buf, const char *bytes, size_t num_by= tes) +{ + size_t req_size; + size_t new_size; + char *new_ptr; + + req_size =3D buf->num_bytes + num_bytes; + new_size =3D buf->alloc_size; + + while (req_size > new_size) + new_size *=3D 2; + if (new_size !=3D buf->alloc_size) { + new_ptr =3D realloc(buf->buffer, new_size); + if (!new_ptr) + return -ENOMEM; + buf->buffer =3D new_ptr; + buf->alloc_size =3D new_size; + } + memcpy(buf->buffer + buf->num_bytes, bytes, num_bytes); + buf->num_bytes +=3D num_bytes; + return 0; +} + +int append_byte(struct byte_buffer *buf, char c) +{ + return append_bytes(buf, &c, 1); +} + +int encode_le(struct byte_buffer *buf, uint64_t value, size_t byte_width) +{ + size_t i; + int ret; + + for (i =3D 0; i < byte_width; ++i) + if ((ret =3D append_byte(buf, (uint8_t)((value >> (i * 8)) & 0xFF)))) + return ret; + return 0; +} + +int pad(struct byte_buffer *buf, size_t num_padding) +{ + int ret; + size_t i; + for (i =3D 0; i < num_padding; i++) + if ((ret =3D append_byte(buf, 0))) + return ret; + return 0; +} diff --git a/tools/testing/kfuzztest-bridge/byte_buffer.h b/tools/testing/k= fuzztest-bridge/byte_buffer.h new file mode 100644 index 000000000000..6a31bfb5e78f --- /dev/null +++ b/tools/testing/kfuzztest-bridge/byte_buffer.h @@ -0,0 +1,31 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * A simple byte buffer implementation for encoding binary data + * + * Copyright 2025 Google LLC + */ +#ifndef KFUZZTEST_BRIDGE_BYTE_BUFFER_H +#define KFUZZTEST_BRIDGE_BYTE_BUFFER_H + +#include +#include + +struct byte_buffer { + char *buffer; + size_t num_bytes; + size_t alloc_size; +}; + +struct byte_buffer *new_byte_buffer(size_t initial_size); + +void destroy_byte_buffer(struct byte_buffer *buf); + +int append_bytes(struct byte_buffer *buf, const char *bytes, size_t num_by= tes); + +int append_byte(struct byte_buffer *buf, char c); + +int encode_le(struct byte_buffer *buf, uint64_t value, size_t byte_width); + +int pad(struct byte_buffer *buf, size_t num_padding); + +#endif /* KFUZZTEST_BRIDGE_BYTE_BUFFER_H */ diff --git a/tools/testing/kfuzztest-bridge/encoder.c b/tools/testing/kfuzz= test-bridge/encoder.c new file mode 100644 index 000000000000..11ff5bd589d3 --- /dev/null +++ b/tools/testing/kfuzztest-bridge/encoder.c @@ -0,0 +1,390 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Encoder for KFuzzTest binary input format + * + * Copyright 2025 Google LLC + */ +#include +#include +#include +#include +#include + +#include "byte_buffer.h" +#include "input_parser.h" +#include "rand_stream.h" + +#define KFUZZTEST_MAGIC 0xBFACE +#define KFUZZTEST_PROTO_VERSION 0 + +/*=20 + * The KFuzzTest binary input format requires at least 8 bytes of padding + * at the head and tail of every region. + */ +#define KFUZZTEST_POISON_SIZE 8 + +#define BUFSIZE_SMALL 32 +#define BUFSIZE_LARGE 128 + +struct region_info { + const char *name; + uint32_t offset; + uint32_t size; +}; + +struct reloc_info { + uint32_t src_reg; + uint32_t offset; + uint32_t dst_reg; +}; + +struct encoder_ctx { + struct byte_buffer *payload; + struct rand_stream *rand; + + struct region_info *regions; + size_t num_regions; + + struct reloc_info *relocations; + size_t num_relocations; + + size_t minalign; + size_t reg_offset; + int curr_reg; +}; + +static void cleanup_ctx(struct encoder_ctx *ctx) +{ + if (ctx->regions) + free(ctx->regions); + if (ctx->relocations) + free(ctx->relocations); + if (ctx->payload) + destroy_byte_buffer(ctx->payload); +} + +static int read_minalign(struct encoder_ctx *ctx) +{ + const char *minalign_file =3D "/sys/kernel/debug/kfuzztest/_config/minali= gn"; + char buffer[64 + 1] =3D { 0 }; + int ret =3D 0; + + FILE *f =3D fopen(minalign_file, "r"); + if (!f) + return -ENOENT; + + fread(&buffer, 1, sizeof(buffer) - 1, f); + if (ferror(f)) + return ferror(f); + + /* + * atoi returns 0 on error. Since we expect a strictly positive + * minalign value on all architectures, any non-positive value + * represents an error. + */ + ret =3D atoi(buffer); + if (ret <=3D 0) { + fclose(f); + return -EINVAL; + } + ctx->minalign =3D ret; + fclose(f); + return 0; +} + +static int pad_payload(struct encoder_ctx *ctx, size_t amount) +{ + int ret; + + if ((ret =3D pad(ctx->payload, amount))) + return ret; + ctx->reg_offset +=3D amount; + return 0; +} + +static int align_payload(struct encoder_ctx *ctx, size_t alignment) +{ + size_t pad_amount =3D ROUND_UP_TO_MULTIPLE(ctx->payload->num_bytes, align= ment) - ctx->payload->num_bytes; + return pad_payload(ctx, pad_amount); +} + +static int lookup_reg(struct encoder_ctx *ctx, const char *name) +{ + size_t i; + + for (i =3D 0; i < ctx->num_regions; i++) { + if (strcmp(ctx->regions[i].name, name) =3D=3D 0) + return i; + } + return -ENOENT; +} + +static int add_reloc(struct encoder_ctx *ctx, struct reloc_info reloc) +{ + void *new_ptr =3D realloc(ctx->relocations, (ctx->num_relocations + 1) * = sizeof(struct reloc_info)); + if (!new_ptr) + return -ENOMEM; + + ctx->relocations =3D new_ptr; + ctx->relocations[ctx->num_relocations] =3D reloc; + ctx->num_relocations++; + return 0; +} + +static int build_region_map(struct encoder_ctx *ctx, struct ast_node *top_= level) +{ + struct ast_program *prog; + struct ast_node *reg; + size_t i; + + if (top_level->type !=3D NODE_PROGRAM) + return -EINVAL; + + prog =3D &top_level->data.program; + ctx->regions =3D malloc(prog->num_members * sizeof(struct region_info)); + if (!ctx->regions) + return -ENOMEM; + + ctx->num_regions =3D prog->num_members; + for (i =3D 0; i < ctx->num_regions; i++) { + reg =3D prog->members[i]; + /* Offset is determined after the second pass. */ + ctx->regions[i] =3D (struct region_info){ + .name =3D reg->data.region.name, + .size =3D node_size(reg), + }; + } + return 0; +} +/** + * Encodes a value node as little-endian. A value node is one that has no + * children, and can therefore be directly written into the payload. + */ +static int encode_value_le(struct encoder_ctx *ctx, struct ast_node *node) +{ + size_t array_size; + char rand_char; + size_t length; + size_t i; + int reg; + int ret; + + switch (node->type) { + case NODE_ARRAY: + array_size =3D node->data.array.num_elems * node->data.array.elem_size; + for (i =3D 0; i < array_size; i++) { + if ((ret =3D next_byte(ctx->rand, &rand_char))) + return ret; + if ((ret =3D append_byte(ctx->payload, rand_char))) + return ret; + } + ctx->reg_offset +=3D array_size; + if (node->data.array.null_terminated) { + if ((ret =3D pad_payload(ctx, 1))) + return ret; + ctx->reg_offset++; + } + break; + case NODE_LENGTH: + reg =3D lookup_reg(ctx, node->data.length.length_of); + if (reg < 0) + return reg; + length =3D ctx->regions[reg].size; + if ((ret =3D encode_le(ctx->payload, length, node->data.length.byte_widt= h))) + return ret; + ctx->reg_offset +=3D node->data.length.byte_width; + break; + case NODE_PRIMITIVE: + for (i =3D 0; i < node->data.primitive.byte_width; i++) { + if ((ret =3D next_byte(ctx->rand, &rand_char))) + return ret; + if ((ret =3D append_byte(ctx->payload, rand_char))) + return ret; + } + ctx->reg_offset +=3D node->data.primitive.byte_width; + break; + case NODE_POINTER: + reg =3D lookup_reg(ctx, node->data.pointer.points_to); + if (reg < 0) + return reg; + if ((ret =3D add_reloc(ctx, (struct reloc_info){ .src_reg =3D ctx->curr_= reg, + .offset =3D ctx->reg_offset, + .dst_reg =3D reg }))) + return ret; + /* Placeholder pointer value, as pointers are patched by KFuzzTest anywa= ys. */ + if ((ret =3D encode_le(ctx->payload, UINTPTR_MAX, sizeof(uintptr_t)))) + return ret; + ctx->reg_offset +=3D sizeof(uintptr_t); + break; + case NODE_PROGRAM: + case NODE_REGION: + default: + return -EINVAL; + } + return 0; +} + +static int encode_region(struct encoder_ctx *ctx, struct ast_region *reg) +{ + struct ast_node *child; + size_t i; + int ret; + + ctx->reg_offset =3D 0; + for (i =3D 0; i < reg->num_members; i++) { + child =3D reg->members[i]; + if ((ret =3D align_payload(ctx, node_alignment(child)))) + return ret; + if ((ret =3D encode_value_le(ctx, child))) + return ret; + } + return 0; +} + +static int encode_payload(struct encoder_ctx *ctx, struct ast_node *top_le= vel) +{ + struct ast_node *reg; + size_t i; + int ret; + + for (i =3D 0; i < ctx->num_regions; i++) { + reg =3D top_level->data.program.members[i]; + if ((ret =3D align_payload(ctx, MAX(ctx->minalign, node_alignment(reg)))= )) + return ret; + + ctx->curr_reg =3D i; + ctx->regions[i].offset =3D ctx->payload->num_bytes; + if ((ret =3D encode_region(ctx, ®->data.region))) + return ret; + if ((ret =3D pad_payload(ctx, KFUZZTEST_POISON_SIZE))) + return ret; + } + return align_payload(ctx, ctx->minalign); +} + +static int encode_region_array(struct encoder_ctx *ctx, struct byte_buffer= **ret) +{ + struct byte_buffer *reg_array; + struct region_info info; + int retcode; + size_t i; + + reg_array =3D new_byte_buffer(BUFSIZE_SMALL); + if (!reg_array) + return -ENOMEM; + + if ((retcode =3D encode_le(reg_array, ctx->num_regions, sizeof(uint32_t))= )) + goto fail; + + for (i =3D 0; i < ctx->num_regions; i++) { + info =3D ctx->regions[i]; + if ((retcode =3D encode_le(reg_array, info.offset, sizeof(uint32_t)))) + goto fail; + if ((retcode =3D encode_le(reg_array, info.size, sizeof(uint32_t)))) + goto fail; + } + *ret =3D reg_array; + return 0; + +fail: + destroy_byte_buffer(reg_array); + return retcode; +} + +static int encode_reloc_table(struct encoder_ctx *ctx, size_t padding_amou= nt, struct byte_buffer **ret) +{ + struct byte_buffer *reloc_table; + struct reloc_info info; + int retcode; + size_t i; + + reloc_table =3D new_byte_buffer(BUFSIZE_SMALL); + if (!reloc_table) + return -ENOMEM; + + if ((retcode =3D encode_le(reloc_table, ctx->num_relocations, sizeof(uint= 32_t))) || + (retcode =3D encode_le(reloc_table, padding_amount, sizeof(uint32_t))= )) + goto fail; + + for (i =3D 0; i < ctx->num_relocations; i++) { + info =3D ctx->relocations[i]; + if ((retcode =3D encode_le(reloc_table, info.src_reg, sizeof(uint32_t)))= || + (retcode =3D encode_le(reloc_table, info.offset, sizeof(uint32_t))) = || + (retcode =3D encode_le(reloc_table, info.dst_reg, sizeof(uint32_t)))) + goto fail; + } + pad(reloc_table, padding_amount); + *ret =3D reloc_table; + return 0; + +fail: + destroy_byte_buffer(reloc_table); + return retcode; +} + +static size_t reloc_table_size(struct encoder_ctx *ctx) +{ + return 2 * sizeof(uint32_t) + 3 * ctx->num_relocations * sizeof(uint32_t); +} + +int encode(struct ast_node *top_level, struct rand_stream *r, size_t *num_= bytes, struct byte_buffer **ret) +{ + struct byte_buffer *region_array =3D NULL; + struct byte_buffer *final_buffer =3D NULL; + struct byte_buffer *reloc_table =3D NULL; + size_t header_size; + int alignment; + int retcode; + + struct encoder_ctx ctx =3D { 0 }; + if ((retcode =3D read_minalign(&ctx))) + return retcode; + + if ((retcode =3D build_region_map(&ctx, top_level))) + goto fail; + + ctx.rand =3D r; + ctx.payload =3D new_byte_buffer(BUFSIZE_SMALL); + if (!ctx.payload) { + retcode =3D -ENOMEM; + goto fail; + } + if ((retcode =3D encode_payload(&ctx, top_level))) + goto fail; + + if ((retcode =3D encode_region_array(&ctx, ®ion_array))) + goto fail; + + header_size =3D sizeof(uint64_t) + region_array->num_bytes + reloc_table_= size(&ctx); + alignment =3D node_alignment(top_level); + if ((retcode =3D encode_reloc_table( + &ctx, ROUND_UP_TO_MULTIPLE(header_size + KFUZZTEST_POISON_SIZE, ali= gnment) - header_size, + &reloc_table))) + goto fail; + + final_buffer =3D new_byte_buffer(BUFSIZE_LARGE); + if (!final_buffer) { + retcode =3D -ENOMEM; + goto fail; + } + + if ((retcode =3D encode_le(final_buffer, KFUZZTEST_MAGIC, sizeof(uint32_t= ))) || + (retcode =3D encode_le(final_buffer, KFUZZTEST_PROTO_VERSION, sizeof(= uint32_t))) || + (retcode =3D append_bytes(final_buffer, region_array->buffer, region_= array->num_bytes)) || + (retcode =3D append_bytes(final_buffer, reloc_table->buffer, reloc_ta= ble->num_bytes)) || + (retcode =3D append_bytes(final_buffer, ctx.payload->buffer, ctx.payl= oad->num_bytes))) { + destroy_byte_buffer(final_buffer); + goto fail; + } + + *num_bytes =3D final_buffer->num_bytes; + *ret =3D final_buffer; + +fail: + if (region_array) + destroy_byte_buffer(region_array); + if (reloc_table) + destroy_byte_buffer(reloc_table); + cleanup_ctx(&ctx); + return retcode; +} diff --git a/tools/testing/kfuzztest-bridge/encoder.h b/tools/testing/kfuzz= test-bridge/encoder.h new file mode 100644 index 000000000000..73f8c4b7893c --- /dev/null +++ b/tools/testing/kfuzztest-bridge/encoder.h @@ -0,0 +1,16 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Encoder for KFuzzTest binary input format + * + * Copyright 2025 Google LLC + */ +#ifndef KFUZZTEST_BRIDGE_ENCODER_H +#define KFUZZTEST_BRIDGE_ENCODER_H + +#include "input_parser.h" +#include "rand_stream.h" +#include "byte_buffer.h" + +int encode(struct ast_node *top_level, struct rand_stream *r, size_t *num_= bytes, struct byte_buffer **ret); + +#endif /* KFUZZTEST_BRIDGE_ENCODER_H */ diff --git a/tools/testing/kfuzztest-bridge/input_lexer.c b/tools/testing/k= fuzztest-bridge/input_lexer.c new file mode 100644 index 000000000000..d0a3e352a265 --- /dev/null +++ b/tools/testing/kfuzztest-bridge/input_lexer.c @@ -0,0 +1,256 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Parser for KFuzzTest textual input format + * + * Copyright 2025 Google LLC + */ +#include +#include +#include +#include +#include +#include + +#include "input_lexer.h" + +struct keyword_map { + const char *keyword; + enum token_type type; +}; + +static struct keyword_map keywords[] =3D { + { "ptr", TOKEN_KEYWORD_PTR }, { "arr", TOKEN_KEYWORD_ARR }, + { "len", TOKEN_KEYWORD_LEN }, { "str", TOKEN_KEYWORD_STR }, + { "u8", TOKEN_KEYWORD_U8 }, { "u16", TOKEN_KEYWORD_U16 }, + { "u32", TOKEN_KEYWORD_U32 }, { "u64", TOKEN_KEYWORD_U64 }, +}; + +static struct token *make_token(enum token_type type, size_t position) +{ + struct token *ret =3D calloc(1, sizeof(*ret)); + ret->position =3D position; + ret->type =3D type; + return ret; +} + +void destroy_tokens(struct token **tokens, size_t num_tokens) +{ + size_t i; + + if (!tokens) + return; + + for (i =3D 0; i < num_tokens; i++) + if (tokens[i]) + free(tokens[i]); + free(tokens); +} + +struct lexer { + const char *start; + const char *current; + size_t position; +}; + +static char advance(struct lexer *l) +{ + l->current++; + l->position++; + return l->current[-1]; +} + +static void retreat(struct lexer *l) +{ + l->position--; + l->current--; +} + +static char peek(struct lexer *l) +{ + return *l->current; +} + +static bool is_digit(char c) +{ + return c >=3D '0' && c <=3D '9'; +} + +static bool is_alpha(char c) +{ + return (c >=3D 'a' && c <=3D 'z') || (c >=3D 'A' && c <=3D 'Z'); +} + +static bool is_whitespace(char c) +{ + switch (c) { + case ' ': + case '\r': + case '\t': + case '\n': + return true; + default: + return false; + } +} + +static void skip_whitespace(struct lexer *l) +{ + while (is_whitespace(peek(l))) + advance(l); +} + +static struct token *number(struct lexer *l) +{ + struct token *tok; + uint64_t value; + while (is_digit(peek(l))) + advance(l); + value =3D strtoull(l->start, NULL, 10); + tok =3D make_token(TOKEN_INTEGER, l->position); + tok->data.integer =3D value; + return tok; +} + +static enum token_type check_keyword(struct lexer *l, const char *keyword, + enum token_type type) +{ + size_t len =3D strlen(keyword); + + if (((size_t)(l->current - l->start) =3D=3D len) && + strncmp(l->start, keyword, len) =3D=3D 0) + return type; + return TOKEN_IDENTIFIER; +} + +static struct token *identifier(struct lexer *l) +{ + enum token_type type =3D TOKEN_IDENTIFIER; + struct token *tok; + size_t i; + + while (is_digit(peek(l)) || is_alpha(peek(l)) || peek(l) =3D=3D '_') + advance(l); + + for (i =3D 0; i < ARRAY_SIZE(keywords); i++) { + if (check_keyword(l, keywords[i].keyword, keywords[i].type) !=3D + TOKEN_IDENTIFIER) { + type =3D keywords[i].type; + break; + } + } + + tok =3D make_token(type, l->position); + if (!tok) + return NULL; + if (type =3D=3D TOKEN_IDENTIFIER) { + tok->data.identifier.start =3D l->start; + tok->data.identifier.length =3D l->current - l->start; + } + return tok; +} + +static struct token *scan_token(struct lexer *l) +{ + char c; + skip_whitespace(l); + + l->start =3D l->current; + c =3D peek(l); + + if (c =3D=3D '\0') + return make_token(TOKEN_EOF, l->position); + + advance(l); + switch (c) { + case '{': + return make_token(TOKEN_LBRACE, l->position); + case '}': + return make_token(TOKEN_RBRACE, l->position); + case '[': + return make_token(TOKEN_LBRACKET, l->position); + case ']': + return make_token(TOKEN_RBRACKET, l->position); + case ',': + return make_token(TOKEN_COMMA, l->position); + case ';': + return make_token(TOKEN_SEMICOLON, l->position); + default: + retreat(l); + if (is_digit(c)) + return number(l); + if (is_alpha(c) || c =3D=3D '_') + return identifier(l); + return make_token(TOKEN_ERROR, l->position); + } +} + +int primitive_byte_width(enum token_type type) +{ + switch (type) { + case TOKEN_KEYWORD_U8: + return 1; + case TOKEN_KEYWORD_U16: + return 2; + case TOKEN_KEYWORD_U32: + return 4; + case TOKEN_KEYWORD_U64: + return 8; + default: + return 0; + } +} + +int tokenize(const char *input, struct token ***tokens, size_t *num_tokens) +{ + struct lexer l =3D { .start =3D input, .current =3D input }; + struct token **ret_tokens; + size_t token_arr_size; + size_t token_count; + struct token *tok; + void *tmp; + int err; + + token_arr_size =3D 128; + ret_tokens =3D calloc(token_arr_size, sizeof(struct token *)); + if (!ret_tokens) + return -ENOMEM; + + token_count =3D 0; + do { + tok =3D scan_token(&l); + if (!tok) { + err =3D -ENOMEM; + goto failure; + } + + if (token_count =3D=3D token_arr_size) { + token_arr_size *=3D 2; + tmp =3D realloc(ret_tokens, token_arr_size); + if (!tmp) { + err =3D -ENOMEM; + goto failure; + } + ret_tokens =3D tmp; + } + + ret_tokens[token_count] =3D tok; + if (tok->type =3D=3D TOKEN_ERROR) { + err =3D -EINVAL; + goto failure; + } + token_count++; + } while (tok->type !=3D TOKEN_EOF); + + *tokens =3D ret_tokens; + *num_tokens =3D token_count; + return 0; + +failure: + destroy_tokens(ret_tokens, token_count); + return err; +} + +bool is_primitive(struct token *tok) +{ + return tok->type >=3D TOKEN_KEYWORD_U8 && tok->type <=3D TOKEN_KEYWORD_U6= 4; +} diff --git a/tools/testing/kfuzztest-bridge/input_lexer.h b/tools/testing/k= fuzztest-bridge/input_lexer.h new file mode 100644 index 000000000000..40814493c24d --- /dev/null +++ b/tools/testing/kfuzztest-bridge/input_lexer.h @@ -0,0 +1,58 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Lexer for KFuzzTest textual input format + * + * Copyright 2025 Google LLC + */ +#ifndef KFUZZTEST_BRIDGE_INPUT_LEXER_H +#define KFUZZTEST_BRIDGE_INPUT_LEXER_H + +#include +#include +#include + +#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) + +enum token_type { + TOKEN_LBRACE, + TOKEN_RBRACE, + TOKEN_LBRACKET, + TOKEN_RBRACKET, + TOKEN_COMMA, + TOKEN_SEMICOLON, + + TOKEN_KEYWORD_PTR, + TOKEN_KEYWORD_ARR, + TOKEN_KEYWORD_LEN, + TOKEN_KEYWORD_STR, + TOKEN_KEYWORD_U8, + TOKEN_KEYWORD_U16, + TOKEN_KEYWORD_U32, + TOKEN_KEYWORD_U64, + + TOKEN_IDENTIFIER, + TOKEN_INTEGER, + + TOKEN_EOF, + TOKEN_ERROR, +}; + +struct token { + enum token_type type; + union { + uint64_t integer; + struct { + const char *start; + size_t length; + } identifier; + } data; + int position; +}; + +int tokenize(const char *input, struct token ***tokens, size_t *num_tokens= ); +void destroy_tokens(struct token **tokens, size_t num_tokens); + +bool is_primitive(struct token *tok); +int primitive_byte_width(enum token_type type); + +#endif /* KFUZZTEST_BRIDGE_INPUT_LEXER_H */ diff --git a/tools/testing/kfuzztest-bridge/input_parser.c b/tools/testing/= kfuzztest-bridge/input_parser.c new file mode 100644 index 000000000000..b1fd8ba5217e --- /dev/null +++ b/tools/testing/kfuzztest-bridge/input_parser.c @@ -0,0 +1,423 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Parser for the KFuzzTest textual input format + * + * This file implements a parser for a simple DSL used to describe C-like = data + * structures. This format allows the kfuzztest-bridge tool to encode a ra= ndom + * byte stream into the structured binary format expected by a KFuzzTest + * harness. + * + * The format consists of semicolon-separated "regions," which are analogo= us to + * C structs. For example: + * + * "my_struct { ptr[buf] len[buf, u64] }; buf { arr[u8, 42] };" + * + * This describes a `my_struct` region that contains a pointer to a `buf` = region + * and its corresponding length encoded over 8 bytes, where `buf` itself + * contains a 42-byte array. + * + * Copyright 2025 Google LLC + */ +#include +#include +#include + +#include "input_lexer.h" +#include "input_parser.h" + +static struct token *peek(struct parser *p) +{ + return p->tokens[p->curr_token]; +} + +static struct token *advance(struct parser *p) +{ + struct token *tok; + if (p->curr_token >=3D p->token_count) + return NULL; + tok =3D peek(p); + p->curr_token++; + return tok; +} + +static struct token *consume(struct parser *p, enum token_type type, const= char *err_msg) +{ + if (peek(p)->type !=3D type) { + printf("parser failure at position %d: %s\n", peek(p)->position, err_msg= ); + return NULL; + } + return advance(p); +} + +static bool match(struct parser *p, enum token_type t) +{ + struct token *tok =3D peek(p); + return tok->type =3D=3D t; +} + +static int parse_primitive(struct parser *p, struct ast_node **node_ret) +{ + struct ast_node *ret; + struct token *tok; + int byte_width; + + tok =3D advance(p); + byte_width =3D primitive_byte_width(tok->type); + if (!byte_width) + return -EINVAL; + + ret =3D malloc(sizeof(*ret)); + if (!ret) + return -ENOMEM; + + ret->type =3D NODE_PRIMITIVE; + ret->data.primitive.byte_width =3D byte_width; + *node_ret =3D ret; + return 0; +} + +static int parse_ptr(struct parser *p, struct ast_node **node_ret) +{ + const char *points_to; + struct ast_node *ret; + struct token *tok; + if (!consume(p, TOKEN_KEYWORD_PTR, "expected 'ptr'")) + return -EINVAL; + if (!consume(p, TOKEN_LBRACKET, "expected '['")) + return -EINVAL; + + tok =3D consume(p, TOKEN_IDENTIFIER, "expected identifier"); + if (!tok) + return -EINVAL; + + if (!consume(p, TOKEN_RBRACKET, "expected ']'")) + return -EINVAL; + + ret =3D malloc(sizeof(*ret)); + ret->type =3D NODE_POINTER; + + points_to =3D strndup(tok->data.identifier.start, tok->data.identifier.le= ngth); + if (!points_to) { + free(ret); + return -EINVAL; + } + + ret->data.pointer.points_to =3D points_to; + *node_ret =3D ret; + return 0; +} + +static int parse_arr(struct parser *p, struct ast_node **node_ret) +{ + struct token *type, *num_elems; + struct ast_node *ret; + + if (!consume(p, TOKEN_KEYWORD_ARR, "expected 'arr'") || !consume(p, TOKEN= _LBRACKET, "expected '['")) + return -EINVAL; + + type =3D advance(p); + if (!is_primitive(type)) + return -EINVAL; + + if (!consume(p, TOKEN_COMMA, "expected ','")) + return -EINVAL; + + num_elems =3D consume(p, TOKEN_INTEGER, "expected integer"); + if (!num_elems) + return -EINVAL; + + if (!consume(p, TOKEN_RBRACKET, "expected ']'")) + return -EINVAL; + + ret =3D malloc(sizeof(*ret)); + if (!ret) + return -ENOMEM; + + ret->type =3D NODE_ARRAY; + ret->data.array.num_elems =3D num_elems->data.integer; + ret->data.array.elem_size =3D primitive_byte_width(type->type); + ret->data.array.null_terminated =3D false; + *node_ret =3D ret; + return 0; +} + +static int parse_str(struct parser *p, struct ast_node **node_ret) +{ + struct ast_node *ret; + struct token *len; + + if (!consume(p, TOKEN_KEYWORD_STR, "expected 'str'") || !consume(p, TOKEN= _LBRACKET, "expected '['")) + return -EINVAL; + + len =3D consume(p, TOKEN_INTEGER, "expected integer"); + if (!len) + return -EINVAL; + + if (!consume(p, TOKEN_RBRACKET, "expected ']'")) + return -EINVAL; + + ret =3D malloc(sizeof(*ret)); + if (!ret) + return -ENOMEM; + + /* A string is the susbet of byte arrays that are null-terminated. */ + ret->type =3D NODE_ARRAY; + ret->data.array.num_elems =3D len->data.integer; + ret->data.array.elem_size =3D sizeof(char); + ret->data.array.null_terminated =3D true; + *node_ret =3D ret; + return 0; +} + +static int parse_len(struct parser *p, struct ast_node **node_ret) +{ + struct token *type, *len; + const char *length_of; + struct ast_node *ret; + + if (!consume(p, TOKEN_KEYWORD_LEN, "expected 'len'") || !consume(p, TOKEN= _LBRACKET, "expected '['")) + return -EINVAL; + + len =3D advance(p); + if (len->type !=3D TOKEN_IDENTIFIER) + return -EINVAL; + + if (!consume(p, TOKEN_COMMA, "expected ','")) + return -EINVAL; + + type =3D advance(p); + if (!is_primitive(type)) + return -EINVAL; + + if (!consume(p, TOKEN_RBRACKET, "expected ']'")) + return -EINVAL; + + ret =3D malloc(sizeof(*ret)); + if (!ret) + return -ENOMEM; + + length_of =3D strndup(len->data.identifier.start, len->data.identifier.le= ngth); + if (!length_of) { + free(ret); + return -ENOMEM; + } + + ret->type =3D NODE_LENGTH; + ret->data.length.length_of =3D length_of; + ret->data.length.byte_width =3D primitive_byte_width(type->type); + + *node_ret =3D ret; + return 0; +} + +static int parse_type(struct parser *p, struct ast_node **node_ret) +{ + if (is_primitive(peek(p))) + return parse_primitive(p, node_ret); + + if (peek(p)->type =3D=3D TOKEN_KEYWORD_PTR) + return parse_ptr(p, node_ret); + + if (peek(p)->type =3D=3D TOKEN_KEYWORD_ARR) + return parse_arr(p, node_ret); + + if (peek(p)->type =3D=3D TOKEN_KEYWORD_STR) + return parse_str(p, node_ret); + + if (peek(p)->type =3D=3D TOKEN_KEYWORD_LEN) + return parse_len(p, node_ret); + + return -EINVAL; +} + +static int parse_region(struct parser *p, struct ast_node **node_ret) +{ + struct token *tok, *identifier; + struct ast_region *region; + struct ast_node *node; + struct ast_node *ret; + void *new_ptr; + int err; + + identifier =3D consume(p, TOKEN_IDENTIFIER, "expected identifier"); + if (!identifier) + return -EINVAL; + + ret =3D malloc(sizeof(*ret)); + if (!ret) + return -ENOMEM; + + tok =3D consume(p, TOKEN_LBRACE, "expected '{'"); + if (!tok) { + err =3D -EINVAL; + goto fail_early; + } + + region =3D &ret->data.region; + region->name =3D strndup(identifier->data.identifier.start, identifier->d= ata.identifier.length); + if (!region->name) { + err =3D -ENOMEM; + goto fail_early; + } + + region->num_members =3D 0; + while (!match(p, TOKEN_RBRACE)) { + err =3D parse_type(p, &node); + if (err) + goto fail; + new_ptr =3D realloc(region->members, (region->num_members + 1) * sizeof(= struct ast_node *)); + if (!new_ptr) { + err =3D -ENOMEM; + goto fail; + } + region->num_members++; + region->members =3D new_ptr; + region->members[region->num_members - 1] =3D node; + } + + if (!consume(p, TOKEN_RBRACE, "expected '}'") || !consume(p, TOKEN_SEMICO= LON, "expected ';'")) { + err =3D -EINVAL; + goto fail; + } + + ret->type =3D NODE_REGION; + *node_ret =3D ret; + return 0; + +fail: + destroy_ast_node(ret); + return err; + +fail_early: + free(ret); + return err; +} + +static int parse_program(struct parser *p, struct ast_node **node_ret) +{ + struct ast_program *prog; + struct ast_node *reg; + struct ast_node *ret; + void *new_ptr; + int err; + + ret =3D malloc(sizeof(*ret)); + if (!ret) + return -ENOMEM; + ret->type =3D NODE_PROGRAM; + + prog =3D &ret->data.program; + prog->num_members =3D 0; + prog->members =3D NULL; + while (!match(p, TOKEN_EOF)) { + err =3D parse_region(p, ®); + if (err) + goto fail; + + new_ptr =3D realloc(prog->members, ++prog->num_members * sizeof(struct a= st_node *)); + if (!new_ptr) { + err =3D -ENOMEM; + goto fail; + } + prog->members =3D new_ptr; + prog->members[prog->num_members - 1] =3D reg; + } + + *node_ret =3D ret; + return 0; + +fail: + destroy_ast_node(ret); + return err; +} + +size_t node_alignment(struct ast_node *node) +{ + size_t max_alignment =3D 1; + size_t i; + + switch (node->type) { + case NODE_PROGRAM: + for (i =3D 0; i < node->data.program.num_members; i++) + max_alignment =3D MAX(max_alignment, node_alignment(node->data.program.= members[i])); + return max_alignment; + case NODE_REGION: + for (i =3D 0; i < node->data.region.num_members; i++) + max_alignment =3D MAX(max_alignment, node_alignment(node->data.region.m= embers[i])); + return max_alignment; + case NODE_ARRAY: + return node->data.array.elem_size; + case NODE_LENGTH: + return node->data.length.byte_width; + case NODE_PRIMITIVE: + /* Primitives are aligned to their size. */ + return node->data.primitive.byte_width; + case NODE_POINTER: + return sizeof(uintptr_t); + } + + /* Anything should be at least 1-byte-aligned. */ + return 1; +} + +size_t node_size(struct ast_node *node) +{ + size_t total =3D 0; + size_t i; + + switch (node->type) { + case NODE_PROGRAM: + for (i =3D 0; i < node->data.program.num_members; i++) + total +=3D node_size(node->data.program.members[i]); + return total; + case NODE_REGION: + for (i =3D 0; i < node->data.region.num_members; i++) { + /* Account for padding within region. */ + total =3D ROUND_UP_TO_MULTIPLE(total, node_alignment(node->data.region.= members[i])); + total +=3D node_size(node->data.region.members[i]); + } + return total; + case NODE_ARRAY: + return node->data.array.elem_size * node->data.array.num_elems + + (node->data.array.null_terminated ? 1 : 0); + case NODE_LENGTH: + return node->data.length.byte_width; + case NODE_PRIMITIVE: + return node->data.primitive.byte_width; + case NODE_POINTER: + return sizeof(uintptr_t); + } + return 0; +} + +int parse(struct token **tokens, size_t token_count, struct ast_node **nod= e_ret) +{ + struct parser p =3D { .tokens =3D tokens, .token_count =3D token_count, .= curr_token =3D 0 }; + return parse_program(&p, node_ret); +} + +void destroy_ast_node(struct ast_node *node) +{ + size_t i; + + switch (node->type) { + case NODE_PROGRAM: + for (i =3D 0; i < node->data.program.num_members; i++) + destroy_ast_node(node->data.program.members[i]); + break; + case NODE_REGION: + for (i =3D 0; i < node->data.region.num_members; i++) + destroy_ast_node(node->data.region.members[i]); + free((void *)node->data.region.name); + break; + case NODE_LENGTH: + free((void *)node->data.length.length_of); + break; + case NODE_POINTER: + free((void *)node->data.pointer.points_to); + break; + default: + break; + } + free(node); +} diff --git a/tools/testing/kfuzztest-bridge/input_parser.h b/tools/testing/= kfuzztest-bridge/input_parser.h new file mode 100644 index 000000000000..5f444b40f672 --- /dev/null +++ b/tools/testing/kfuzztest-bridge/input_parser.h @@ -0,0 +1,82 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Parser for KFuzzTest textual input format + * + * Copyright 2025 Google LLC + */ +#ifndef KFUZZTEST_BRIDGE_INPUT_PARSER_H +#define KFUZZTEST_BRIDGE_INPUT_PARSER_H + +#include + +/* Rounds x up to the nearest multiple of n. */ +#define ROUND_UP_TO_MULTIPLE(x, n) (((n) =3D=3D 0) ? (0) : (((x) + (n) - 1= ) / (n)) * (n)) + +#define MAX(a, b) ((a) > (b) ? (a) : (b)) + +enum ast_node_type { + NODE_PROGRAM, + NODE_REGION, + NODE_ARRAY, + NODE_LENGTH, + NODE_PRIMITIVE, + NODE_POINTER, +}; + +struct ast_node; /* Forward declaration. */ + +struct ast_program { + struct ast_node **members; + size_t num_members; +}; + +struct ast_region { + const char *name; + struct ast_node **members; + size_t num_members; +}; + +struct ast_array { + int elem_size; + int null_terminated; /* True iff the array should always end with 0. */ + size_t num_elems; +}; + +struct ast_length { + size_t byte_width; + const char *length_of; +}; + +struct ast_primitive { + size_t byte_width; +}; + +struct ast_pointer { + const char *points_to; +}; + +struct ast_node { + enum ast_node_type type; + union { + struct ast_program program; + struct ast_region region; + struct ast_array array; + struct ast_length length; + struct ast_primitive primitive; + struct ast_pointer pointer; + } data; +}; + +struct parser { + struct token **tokens; + size_t token_count; + size_t curr_token; +}; + +int parse(struct token **tokens, size_t token_count, struct ast_node **nod= e_ret); +void destroy_ast_node(struct ast_node *node); + +size_t node_size(struct ast_node *node); +size_t node_alignment(struct ast_node *node); + +#endif /* KFUZZTEST_BRIDGE_INPUT_PARSER_H */ diff --git a/tools/testing/kfuzztest-bridge/rand_stream.c b/tools/testing/k= fuzztest-bridge/rand_stream.c new file mode 100644 index 000000000000..bca6b3de5aad --- /dev/null +++ b/tools/testing/kfuzztest-bridge/rand_stream.c @@ -0,0 +1,77 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Implements a cached file-reader for iterating over a byte stream of + * pseudo-random data + * + * Copyright 2025 Google LLC + */ +#include "rand_stream.h" + +static int refill(struct rand_stream *rs) +{ + rs->valid_bytes =3D fread(rs->buffer, sizeof(char), rs->buffer_size, rs->= source); + rs->buffer_pos =3D 0; + if (rs->valid_bytes !=3D rs->buffer_size && ferror(rs->source)) + return ferror(rs->source); + return 0; +} + +struct rand_stream *new_rand_stream(const char *path_to_file, size_t cache= _size) +{ + struct rand_stream *rs; + + rs =3D malloc(sizeof(*rs)); + if (!rs) + return NULL; + + rs->valid_bytes =3D 0; + rs->source =3D fopen(path_to_file, "rb"); + if (!rs->source) { + free(rs); + return NULL; + } + + if (fseek(rs->source, 0, SEEK_END)) { + fclose(rs->source); + free(rs); + return NULL; + } + rs->source_size =3D ftell(rs->source); + + if (fseek(rs->source, 0, SEEK_SET)) { + fclose(rs->source); + free(rs); + return NULL; + } + + rs->buffer =3D malloc(cache_size); + if (!rs->buffer) { + fclose(rs->source); + free(rs); + return NULL; + } + rs->buffer_size =3D cache_size; + return rs; +} + +void destroy_rand_stream(struct rand_stream *rs) +{ + fclose(rs->source); + free(rs->buffer); + free(rs); +} + +int next_byte(struct rand_stream *rs, char *ret) +{ + int res; + + if (rs->buffer_pos >=3D rs->valid_bytes) { + res =3D refill(rs); + if (res) + return res; + if (rs->valid_bytes =3D=3D 0) + return STREAM_EOF; + } + *ret =3D rs->buffer[rs->buffer_pos++]; + return 0; +} diff --git a/tools/testing/kfuzztest-bridge/rand_stream.h b/tools/testing/k= fuzztest-bridge/rand_stream.h new file mode 100644 index 000000000000..acb3271d30ca --- /dev/null +++ b/tools/testing/kfuzztest-bridge/rand_stream.h @@ -0,0 +1,57 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Implements a cached file-reader for iterating over a byte stream of + * pseudo-random data + * + * Copyright 2025 Google LLC + */ +#ifndef KFUZZTEST_BRIDGE_RAND_STREAM_H +#define KFUZZTEST_BRIDGE_RAND_STREAM_H + +#include +#include + +#define STREAM_EOF 1 + +/** + * struct rand_stream - a buffered bytestream reader + * + * Reads and returns bytes from a file, using buffered pre-fetching to amo= rtize + * the cost of reads. + */ +struct rand_stream { + FILE *source; + size_t source_size; + char *buffer; + size_t buffer_size; + size_t buffer_pos; + size_t valid_bytes; +}; + +/** + * new_rand_stream - return a new struct rand_stream + * + * @path_to_file: source of the output byte stream. + * @cache_size: size of the read-ahead cache in bytes. + */ +struct rand_stream *new_rand_stream(const char *path_to_file, size_t cache= _size); + +/** + * destroy_rand_stream - clean up a rand stream's resources + * + * @rs: a struct rand_stream + */ +void destroy_rand_stream(struct rand_stream *rs); + +/** + * next_byte - return the next byte from a struct rand_stream + * + * @rs: an initialized struct rand_stream. + * @ret: return pointer. + * + * @return 0 on success or a negative value on failure. + * + */ +int next_byte(struct rand_stream *rs, char *ret); + +#endif /* KFUZZTEST_BRIDGE_RAND_STREAM_H */ --=20 2.51.0 From nobody Sun Dec 14 14:00:08 2025 Received: from mail-wm1-f41.google.com (mail-wm1-f41.google.com [209.85.128.41]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 11B44342536 for ; Thu, 4 Dec 2025 14:13:14 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.41 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1764857601; cv=none; b=SWjQcR1pgmyti37UhL/EzMBuPjtZCvCuMes6sxVlIrk5aZWcnzCGd4CoN9R/iWN5H2YLxkWnwMUPWF8V8ABGhCC9OsFUlyFRCgrfh3Mq4HkokOYnETb4nfi6NREPxcmz90swb+aMrhZUUNw1zQ4uxvHAZAVx7y6UrI+eP/zOoPU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1764857601; c=relaxed/simple; bh=z3aHyEs3ZWAP5NpNiViU0qInPuzLVq80ZvqAIW8G09A=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=l0znvdUI9Qs4Nz25yHGlljuXyheST14jPm3ILytjWkbuZuIsXjhaboQGeXKYQnmpW9NbAk0QecoSwo2AwJBw8ZlTMsAd0NygCHcIr/lezccg/bKPOn1yZoMQRB30CIPf5apLLu0v3mf3zCngsXpysMttZy+ND2gwqEONDQQM5Js= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=aanenPTE; arc=none smtp.client-ip=209.85.128.41 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="aanenPTE" Received: by mail-wm1-f41.google.com with SMTP id 5b1f17b1804b1-47796a837c7so8067595e9.0 for ; Thu, 04 Dec 2025 06:13:14 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1764857593; x=1765462393; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=xndrRWaQq8ZqeofXDWgQR27UXFeqwFVKyIppt/mk6wo=; b=aanenPTEbbI4IMQwFyki8+Qk2BVelQjcy2KXgmLvRhvMjjuBvZpcYrwmRVWuPlrsov NlL9+U6McoCGAEcQuIVpKgIvJcCEQKCi5IikkgwRr8upBWV4dl5GS0Otn6Sd7Xf2wppi McXnsC73Ob3sKzafdKDIKFygYTSJn0ox+4/b3Grbx5l4ZATuVfe/qdf2KsBE7HjbHqi5 TDtTcDm/P4aVz6Jwl0XtfJDGxQr3jbFJf4tA2mFgPaDjtICSCoMUIQdumk/CS6hU+l3e xsB3CZWCQbRduj+nTnJF9qgDoSovXMWZzkYsE3nXJ8twQ9QBoLeeL0Z/uK53l7ljoLaY 68Fw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1764857593; x=1765462393; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=xndrRWaQq8ZqeofXDWgQR27UXFeqwFVKyIppt/mk6wo=; b=F2RMBePENZ2xw956wvcROr9Fqm0VttFJqUka+wrSIF/KV0biI/Vho8mkzYPBfqzlFt T238m51CewW0pVLUCY6/tKwcE2TutUGdpMICp3hGAOBhN5jxNCrlzIem/9KlKfvgiqt3 KDsfWiK877hZ9/SoXo/GwyLrVxXjg1Q83ellr/GDvZ6lJBy5pUPpXdETNjKg9ju8pvP6 qGO+Yrx44aiZqsagwu9FFuB9UAvT36bK8C3hvfj0w2euj6XwVG0ip6Q0WMv98QIOsdNk a79RrXcuPcEJZ1uyXySPi3H6I4SLT0L2XmQHd6BbWxivNB4MeMUfG4Nedk3EpwFbMARh DvJg== X-Forwarded-Encrypted: i=1; AJvYcCUvOHQB6mEl1lJqnDD8QXYZI77OHJfSzQw4++AGYpWBcToAOvNd2FxMellro7ngcsBC3AhjTOh1+bXUYpI=@vger.kernel.org X-Gm-Message-State: AOJu0Ywd+faX23g1imr8G54hkjn/yoFvBZY0WYYm3RVnESgMvTNqrX49 3OK6IIWNT0gRLoiSPzs2TSD5OaSffiU3uAlvFjPsTTTQ+80rvIlPQXVD X-Gm-Gg: ASbGncs3j1NEOp0PczaTxGCv37uLcNTe30H1gIFFck9zu0HNPsugpNGOpL3xAQ7WSzP uMa+9eX1Syz5ZGph0w9NFY0IV5BfNPn/UnOg+lpKku1N7ubztUZjPabdtbaOs0lkZztbCWN7WB+ uwNuAgJSt4QAOMHxdMoTaURtBAWjqiHfakPL1+zKU/uWTRZaRe8+59s4Va7beY3E4/+yxCvqV5E 5lI6/x/9wP7DYwK028ytZR+uBbXDD3ZxP8USWA/hdLxgi+nXLbw8H/aWARwuFSATRnvpcadfh4r kezK+prOqpX0jNvtDfkpkV/J3dOC9S8fv9DuIDumK+Kq4oevtt/14IO3dGFsyzGCSOWtnvrQXhn dfOXAKopShkPpGSOwH0f4Gq7m1uO/2pXYCpO29cTMmdI6glELLbOi2bzlSSc2tDLeEU4CN5tipd N9HEy4z11E1GsPWIIBlsBhzvXtfnb/UzZ4bIkoxuOBqrM6ugFT7kml9aZrDzK/j5CSEA== X-Google-Smtp-Source: AGHT+IFRhbDpKasWwWYApVFuMv54Qu+HdfdLgM3pZb5GDC8G6Y67aS7ROE6sKmsj8vcmza2Czs/5sA== X-Received: by 2002:a05:600c:3588:b0:479:1348:c61e with SMTP id 5b1f17b1804b1-4792af33a39mr69461685e9.20.1764857592964; Thu, 04 Dec 2025 06:13:12 -0800 (PST) Received: from ethan-tp.d.ethz.ch (2001-67c-10ec-5744-8000--626.net6.ethz.ch. [2001:67c:10ec:5744:8000::626]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-42f7cbfeae9sm3605808f8f.13.2025.12.04.06.13.11 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 04 Dec 2025 06:13:12 -0800 (PST) From: Ethan Graham To: ethan.w.s.graham@gmail.com, glider@google.com Cc: andreyknvl@gmail.com, andy@kernel.org, andy.shevchenko@gmail.com, brauner@kernel.org, brendan.higgins@linux.dev, davem@davemloft.net, davidgow@google.com, dhowells@redhat.com, dvyukov@google.com, elver@google.com, herbert@gondor.apana.org.au, ignat@cloudflare.com, jack@suse.cz, jannh@google.com, johannes@sipsolutions.net, kasan-dev@googlegroups.com, kees@kernel.org, kunit-dev@googlegroups.com, linux-crypto@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org, lukas@wunner.de, rmoar@google.com, shuah@kernel.org, sj@kernel.org, tarasmadan@google.com, Ethan Graham Subject: [PATCH 06/10] kfuzztest: add ReST documentation Date: Thu, 4 Dec 2025 15:12:45 +0100 Message-ID: <20251204141250.21114-7-ethan.w.s.graham@gmail.com> X-Mailer: git-send-email 2.51.0 In-Reply-To: <20251204141250.21114-1-ethan.w.s.graham@gmail.com> References: <20251204141250.21114-1-ethan.w.s.graham@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Ethan Graham Add Documentation/dev-tools/kfuzztest.rst and reference it in the dev-tools index. Signed-off-by: Ethan Graham Signed-off-by: Ethan Graham Acked-by: Alexander Potapenko --- PR v3: - Document newly introduced FUZZ_TEST_SIMPLE targets. - Rework the flow in several sections. PR v2: - Update documentation to reflect new location of kfuzztest-bridge, under tools/testing. PR v1: - Fix some typos and reword some sections. - Correct kfuzztest-bridge grammar description. - Reference documentation in kfuzztest-bridge/input_parser.c header comment. RFC v2: - Add documentation for kfuzztest-bridge tool introduced in patch 4. --- --- Documentation/dev-tools/index.rst | 1 + Documentation/dev-tools/kfuzztest.rst | 491 ++++++++++++++++++ tools/testing/kfuzztest-bridge/input_parser.c | 2 + 3 files changed, 494 insertions(+) create mode 100644 Documentation/dev-tools/kfuzztest.rst diff --git a/Documentation/dev-tools/index.rst b/Documentation/dev-tools/in= dex.rst index 65c54b27a60b..00ccc4da003b 100644 --- a/Documentation/dev-tools/index.rst +++ b/Documentation/dev-tools/index.rst @@ -32,6 +32,7 @@ Documentation/process/debugging/index.rst kfence kselftest kunit/index + kfuzztest ktap checkuapi gpio-sloppy-logic-analyzer diff --git a/Documentation/dev-tools/kfuzztest.rst b/Documentation/dev-tool= s/kfuzztest.rst new file mode 100644 index 000000000000..61f877e8bb10 --- /dev/null +++ b/Documentation/dev-tools/kfuzztest.rst @@ -0,0 +1,491 @@ +.. SPDX-License-Identifier: GPL-2.0 +.. Copyright 2025 Google LLC + +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D +Kernel Fuzz Testing Framework (KFuzzTest) +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D + +Overview +=3D=3D=3D=3D=3D=3D=3D=3D + +The Kernel Fuzz Testing Framework (KFuzzTest) is a framework designed to e= xpose +internal kernel functions to a userspace fuzzing engine. + +It is intended for testing stateless or low-state functions that are diffi= cult +to reach from the system call interface, such as routines involved in file +format parsing or complex data transformations. This provides a method for +in-situ fuzzing of kernel code without requiring that it be built as a sep= arate +userspace library or that its dependencies be stubbed out. + +The framework consists of four main components: + +1. An API, based on the ``FUZZ_TEST`` and ``FUZZ_TEST_SIMPLE`` macros, for + defining test targets directly in the kernel tree. +2. A binary serialization format for passing complex, pointer-rich data + structures from userspace to the kernel. +3. A ``debugfs`` interface through which a userspace fuzzer submits + serialized test inputs. +4. Metadata embedded in dedicated ELF sections of the ``vmlinux`` binary = to + allow for the discovery of available fuzz targets by external tooling. + +.. warning:: + KFuzzTest is a debugging and testing tool. It exposes internal kernel + functions to userspace with minimal sanitization and is designed for + use in controlled test environments only. It must **NEVER** be enabled + in production kernels. + +Supported Architectures +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D + +KFuzzTest is designed for generic architecture support. It has only been +explicitly tested on x86_64. + +Usage +=3D=3D=3D=3D=3D + +To enable KFuzzTest, configure the kernel with:: + + CONFIG_KFUZZTEST=3Dy + +which depends on ``CONFIG_DEBUGFS`` for receiving userspace inputs, and +``CONFIG_DEBUG_KERNEL`` as an additional guardrail for preventing KFuzzTest +from finding its way into a production build accidentally. + +The KFuzzTest sample fuzz targets can be built in with +``CONFIG_SAMPLE_KFUZZTEST``. + +KFuzzTest currently only supports targets that are built into the kernel, = as the +core module's startup process discovers fuzz targets from a dedicated ELF +section during startup. Furthermore, constraints and annotations emit meta= data +that can be scanned from a ``vmlinux`` binary by a userspace fuzzing engin= e. + +Declaring a KFuzzTest target +---------------------------- + +A fuzz target should be defined in a .c file. The recommended place to def= ine +this is under the subsystem's ``/tests`` directory in a ``_kfuz= z.c`` +file, following the convention used by KUnit. The only strict requirement = is +that the function being fuzzed is visible to the fuzz target. + +KFuzzTest provides two macros for defining a target, depending on the comp= lexity +of the input for the function being fuzzed. + +- ``FUZZ_TEST`` for complex, structure-aware fuzzing of functions that take + pointers, nested structures, or other complex inputs. +- ``FUZZ_TEST_SIMPLE`` for the common case of fuzzing a function that acce= pts + a simple data buffer and length. + +Non-trivial Fuzz Targets (``FUZZ_TEST``) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +For functions with more complex arguments such as nested structs, multiple +pointers, or where fine-grained control over inputs it needed, use the +``FUZZ_TEST`` macro. + +Complex fuzz targets enable structure-aware fuzzing, but require more setu= p, +including the definition a ``struct`` wrapping its parameters, and optional +metadata for the fuzzer. + +Defining a fuzz target involves three main parts: defining an input struct= ure, +writing the test body using the ``FUZZ_TEST`` macro, and optionally adding +metadata for the fuzzer. + +The following example illustrates the 6-step process for this macro. + +.. code-block:: c + + /* 1. The kernel function that we want to fuzz. */ + int func(const char *str, char *data, size_t datalen); + + /* + * 2. Define a struct to model the inputs for the function under test. + * Each field corresponds to an argument needed by the function. + */ + struct func_inputs { + const char *str; + char *data; + size_t datalen; + }; + + /* + * 3. Define the fuzz target using the FUZZ_TEST macro. + * The first parameter is a unique name for the target. + * The second parameter is the input struct defined above. + */ + FUZZ_TEST(test_func, struct func_inputs) + { + /* + * Within this body, the `arg` variable is a pointer to a + * fully initialized `struct func_inputs`. + */ + + /* + * 4. (Optional) Add constraints to define preconditions. + * This check ensures `arg->str` and `arg->data` are non-NULL. If + * the conditions are not met, the test exits early. This also + * creates metadata to inform the fuzzing engine. + */ + KFUZZTEST_EXPECT_NOT_NULL(func_inputs, str); + KFUZZTEST_EXPECT_NOT_NULL(func_inputs, data); + + /* + * 5. (Optional) Add annotations to provide semantic hints to the + * fuzzer. These annotations inform the fuzzer that `str` is a + * null-terminated string, that `data` is a pointer to an array + * (i.e., not a pointer to a single value), and that the `len` field + * is the length of the buffer pointed to by `data`. + * Annotations do not add any runtime checks. + */ + KFUZZTEST_ANNOTATE_STRING(func_inputs, str); + KFUZZTEST_ANNOTATE_LEN(func_inputs, datalen, data); + KFUZZTEST_ANNOTATE_ARRAY(func_inputs, data); + + /* + * 6. Call the kernel function with the provided inputs. + * Memory errors like out-of-bounds accesses on 'arg->data' will + * be detected by KASAN or other memory error detection tools. + */ + func(arg->str, arg->data, arg->datalen); + } + +A ``FUZZ_TEST`` creates a debugfs file under +`/sys/kernel/debug/kfuzztest//input` that accepts inputs from a +fuzzing engine. + +KFuzzTest provides two families of macros to improve the quality of fuzzin= g: + +- ``KFUZZTEST_EXPECT_*``: These macros define constraints, which are + preconditions that must be true for the test to proceed. They are enforc= ed + with a runtime check in the kernel. If a check fails, the current test r= un is + aborted. This metadata helps the userspace fuzzer avoid generating inval= id + inputs. + +- ``KFUZZTEST_ANNOTATE_*``: These macros define annotations, which are pur= ely + semantic hints for the fuzzer. They do not add any runtime checks and ex= ist + only to help the fuzzer generate more intelligent and structurally corre= ct + inputs. For example, KFUZZTEST_ANNOTATE_LEN links a size field to a poin= ter + field, which is a common pattern in C APIs. + +A fuzzing engine that aims to effectively fuzz these targets must implement +the following: + +- Serialized inputs following the format introduced in the + `Input Serialization`_ section. +- ``vmlinux`` metadata parsing to become aware of domain constraints and + annotations. + +Simple Fuzz Targets (``FUZZ_TEST_SIMPLE``) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +For the common case of defining a fuzz target for a function that accepts a +buffer and its length (e.g., ``(const char *data, size_t datalen)``), the +``FUZZ_TEST_SIMPLE`` macro should be used. + +This macro simplifies test creation by providing ``data`` and ``datalen`` +variables to the test body. + +.. code-block:: c + + /* 1. The kernel function that we want to fuzz. */ + int process_data(const char *data, size_t len); + + /* 2. Define the fuzz target with the FUZZ_TEST_SIMPLE macro. */ + FUZZ_TEST_SIMPLE(test_process_data) + { + /* 3. Call the kernel function with the provided input. */ + process_data(data, datalen); + } + +A ``FUZZ_TEST_SIMPLE`` target creates two debugfs files in its directory +(``/sys/kernel/debug/kfuzztest/``): + +- ``input_simple``: A simplified interface. Writing a raw byte blob to this + file will invoke the fuzz target, passing the blob as ``(data, datalen)`= `. +- ``input``: Accepts the serialization format described in the + `Input Serialization`_ section. + +The ``input_simple`` file makes it much easier to integrate with userspace +fuzzers (e.g., LibFuzzer, AFL++, honggfuzz) without requiring any knowledge +of KFuzzTest's serialization format or constraint system. + +A LibFuzzer harness may look like so: + +.. code-block:: c + + /* Path to the simple target's input file */ + const char *filepath =3D "/sys/kernel/debug/kfuzztest/test_process_dat= a/input_simple"; + + extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size= ) { + FILE *f =3D fopen(filepath, "w"); + if (!f) { + return 0; /* Fuzzer should not stop. */ + } + /* Write the raw fuzzer input directly. */ + fwrite(Data, 1, Size, f); + fclose(f); + return 0; + } + +Note that despite it being very simple for a fuzzing engine to fuzz simple +KFuzzTest targets, kernel coverage collection is key for the effectiveness +of a coverage-guided fuzzer - this is outside of KFuzzTest's scope. + +Metadata +-------- + +Macros ``FUZZ_TEST``, ``FUZZ_TEST_SIMPLE``, ``KFUZZTEST_EXPECT_*`` and +``KFUZZTEST_ANNOTATE_*`` embed metadata into several sections within the m= ain +``.data`` section of the final ``vmlinux`` binary; ``.kfuzztest_target``, +``.kfuzztest_simple_target``, ``.kfuzztest_constraint`` and +``.kfuzztest_annotation`` respectively. + +Note that simple targets defined with the ``FUZZ_TEST_SIMPLE`` macro impli= citly +define a ``FUZZ_TEST`` to maintain compatibility with fuzzers that assume +structured inputs, allowing both target types to be treated as one and the= same. + +The metadata regions serve a few purposes: + +1. The core module uses the ``.kfuzztest_target`` section at boot to disco= ver + every ``FUZZ_TEST`` instance and create its ``debugfs`` directory and + ``input`` file. +2. If a ``.kfuzztest_simple_target`` is defined for a given fuzz test, an + additional ``input_simple`` file is created in the target's ``debugfs`` + directory to accept inputs that don't require complex serialization. +3. Userspace fuzzers can read this metadata from the ``vmlinux`` binary to + discover targets and learn about their rules and structure in order to + generate correct and effective inputs. + +The metadata in the ``.kfuzztest_*`` sections consists of arrays of fixed-= size C +structs (e.g., ``struct kfuzztest_target``). Fields within these structs t= hat +are pointers, such as ``name`` or ``arg_type_name``, contain addresses that +point to other locations in the ``vmlinux`` binary. A userspace tool that +parses the ``vmlinux`` ELF file must resolve these pointers to read the da= ta +that they reference. For example, to get a target's name, a tool must: + +1. Read the ``struct kfuzztest_target`` from the ``.kfuzztest_target`` sec= tion. +2. Read the address in the ``.name`` field. +3. Use that address to locate and read null-terminated string from its pos= ition + elsewhere in the binary (e.g., ``.rodata``). + +Tooling Dependencies +-------------------- + +For userspace tools to parse the ``vmlinux`` binary and make use of emitted +KFuzzTest metadata, the kernel must be compiled with DWARF debug informati= on. +This is required for tools to understand the layout of C structs, resolve = type +information, and correctly interpret constraints and annotations. + +When using KFuzzTest with automated fuzzing tools, either +``CONFIG_DEBUG_INFO_DWARF4`` or ``CONFIG_DEBUG_INFO_DWARF5`` should be ena= bled. + +Input Serialization +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D + +``FUZZ_TEST`` macros accept serialized inputs representing nested data with +pointers. This section describes the input format for non-trivial inputs. + +KFuzzTest targets receive their inputs from userspace via a write to a ded= icated +debugfs file ``/sys/kernel/debug/kfuzztest//input``. + +The data written to this file must be a single binary blob that follows a +specific serialization format. This format is designed to allow complex, +pointer-rich C structures to be represented in a flat buffer, requiring on= ly a +single kernel allocation and copy from userspace. + +An input is first prefixed by an 8-byte header containing a magic value in= the +first four bytes, defined as ``KFUZZTEST_HEADER_MAGIC`` in +```, and a version number in the subsequent four +bytes. + +Version 0 +--------- + +In version 0 (i.e., when the version number in the 8-byte header is equal = to 0), +the input format consists of three main parts laid out sequentially: a reg= ion +array, a relocation table, and the payload.:: + + +----------------+---------------------+-----------+----------------+ + | region array | relocation table | padding | payload | + +----------------+---------------------+-----------+----------------+ + +Region Array +^^^^^^^^^^^^ + +This component is a header that describes how the raw data in the Payload = is +partitioned into logical memory regions. It consists of a count of regions +followed by an array of ``struct reloc_region``, where each entry defines a +single region with its size and offset from the start of the payload. + +.. code-block:: c + + struct reloc_region { + uint32_t offset; + uint32_t size; + }; + + struct reloc_region_array { + uint32_t num_regions; + struct reloc_region regions[]; + }; + +By convention, region 0 represents the top-level input struct that is pass= ed +as the arg variable to the ``FUZZ_TEST`` body. Subsequent regions typically +represent data buffers or structs pointed to by fields within that struct. +Region array entries must be ordered by ascending offset, and must not ove= rlap +with one another. + +Relocation Table +^^^^^^^^^^^^^^^^ + +The relocation table contains the instructions for the kernel to "hydrate"= the +payload by patching pointer fields. It contains an array of +``struct reloc_entry`` items. Each entry acts as a linking instruction, +specifying: + +- The location of a pointer that needs to be patched (identified by a regi= on + ID and an offset within that region). + +- The target region that the pointer should point to (identified by the + target's region ID) or ``KFUZZTEST_REGIONID_NULL`` if the pointer is ``N= ULL``. + +This table also specifies the amount of padding between its end and the st= art +of the payload, which should be at least 8 bytes. + +.. code-block:: c + + struct reloc_entry { + uint32_t region_id; + uint32_t region_offset; + uint32_t value; + }; + + struct reloc_table { + uint32_t num_entries; + uint32_t padding_size; + struct reloc_entry entries[]; + }; + +Payload +^^^^^^^ + +The payload contains the raw binary data for all regions, concatenated tog= ether +according to their specified offsets. + +- Region specific alignment: The data for each individual region must star= t at + an offset that is aligned to its own C type's requirements. For example,= a + ``uint64_t`` must begin on an 8-byte boundary. + +- Minimum alignment: The offset of each region, as well as the beginning o= f the + payload, must also be a multiple of the overall minimum alignment value.= This + value is determined by the greater of ``ARCH_KMALLOC_MINALIGN`` and + ``KASAN_GRANULE_SIZE`` (which is represented by ``KFUZZTEST_POISON_SIZE`= ` in + ``/include/linux/kfuzztest.h``). This minimum alignment ensures that all + function inputs respect C calling conventions. + +- Padding: The space between the end of one region's data and the beginnin= g of + the next must be sufficient for padding. The padding must also be at lea= st + the same minimum alignment value mentioned above. This is crucial for KA= SAN + builds, as it allows KFuzzTest to poison this unused space enabling prec= ise + detection of out-of-bounds memory accesses between adjacent buffers. + +The minimum alignment value is architecture-dependent and is exposed to +userspace via the read-only file +``/sys/kernel/debug/kfuzztest/_config/minalign``. The framework relies on +userspace tooling to construct the payload correctly, adhering to all thre= e of +these rules for every region. + +KFuzzTest Bridge Tool +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D + +The ``kfuzztest-bridge`` program is a userspace utility that encodes a ran= dom +byte stream into the structured binary format expected by a KFuzzTest harn= ess. +It allows users to describe the target's input structure textually, making= it +easy to perform smoke tests or connect harnesses to blob-based fuzzing eng= ines. + +This tool is intended to be simple, both in usage and implementation. Its +structure and DSL are sufficient for simpler use-cases. For more advanced +coverage-guided fuzzing it is recommended to use +`syzkaller ` which implements deeper +support for KFuzzTest targets. + +Usage +----- + +The tool can be built with ``make tools/testing/kfuzztest-bridge``. In the= case +of libc incompatibilities, the tool will have to be linked statically or b= uilt +on the target system. + +Example: + +.. code-block:: sh + + ./tools/testing/kfuzztest-bridge \ + "foo { u32 ptr[bar] }; bar { ptr[data] len[data, u64]}; data { arr= [u8, 42] };" \ + "my-fuzz-target" /dev/urandom + +The command takes three arguments + +1. A string describing the input structure (see `Textual Format`_ sub-sec= tion). +2. The name of the target test, which corresponds to its directory in + ``/sys/kernel/debug/kfuzztest/``. +3. A path to a file providing a stream of random data, such as + ``/dev/urandom``. + +The structure string in the example corresponds to the following C data +structures: + +.. code-block:: c + + struct foo { + u32 a; + struct bar *b; + }; + + struct bar { + struct data *d; + u64 data_len; /* Equals 42. */ + }; + + struct data { + char arr[42]; + }; + +Textual Format +-------------- + +The textual format is a human-readable representation of the region-based = binary +format used by KFuzzTest. It is described by the following grammar: + +.. code-block:: text + + schema ::=3D region ( ";" region )* [";"] + region ::=3D identifier "{" type ( " " type )* "}" + type ::=3D primitive | pointer | array | length | string + primitive ::=3D "u8" | "u16" | "u32" | "u64" + pointer ::=3D "ptr" "[" identifier "]" + array ::=3D "arr" "[" primitive "," integer "]" + length ::=3D "len" "[" identifier "," primitive "]" + string ::=3D "str" "[" integer "]" + identifier ::=3D [a-zA-Z_][a-zA-Z1-9_]* + integer ::=3D [0-9]+ + +Pointers must reference a named region. + +To fuzz a raw buffer, the buffer must be defined in its own region, as sho= wn +below: + +.. code-block:: c + + struct my_struct { + char *buf; + size_t buflen; + }; + +This would correspond to the following textual description: + +.. code-block:: text + + my_struct { ptr[buf] len[buf, u64] }; buf { arr[u8, n] }; + +Here, ``n`` is some integer value defining the size of the byte array insi= de of +the ``buf`` region. diff --git a/tools/testing/kfuzztest-bridge/input_parser.c b/tools/testing/= kfuzztest-bridge/input_parser.c index b1fd8ba5217e..feaa59de49d7 100644 --- a/tools/testing/kfuzztest-bridge/input_parser.c +++ b/tools/testing/kfuzztest-bridge/input_parser.c @@ -16,6 +16,8 @@ * and its corresponding length encoded over 8 bytes, where `buf` itself * contains a 42-byte array. * + * The full grammar is documented in Documentation/dev-tools/kfuzztest.rst. + * * Copyright 2025 Google LLC */ #include --=20 2.51.0 From nobody Sun Dec 14 14:00:08 2025 Received: from mail-wr1-f42.google.com (mail-wr1-f42.google.com [209.85.221.42]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 8E42E341AAE for ; Thu, 4 Dec 2025 14:13:16 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.221.42 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1764857601; cv=none; b=Iv5cO62RCdJqfYkofqBM73dMXXF4Y7OT+qLV9RnwBU/e7cf+l9yckvnZTMkLVJJSDyaPIWV6NaBKgQvH1m/VLMCXKVkRsdZvjDp1mvT4rBbbXDDZRKKjYmZX7ctvDiExSfY8XUTNCDh7MuqT3DsUdE1q8jMdgmXFfhKkVTljNPA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1764857601; c=relaxed/simple; bh=WuvuYrKJlC5+EVDn+2jK6a/jc6Brt3r9WFpW4nuOaLs=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=cVELMKbDWDP+khMkCXoCG7Q26KwTo6cJ3zrO3mzMI1uejJPSe/sQcFgH6Uxn7OcErrhiM604rZfZ4/bCIDck/WhVXiIEBUwhHV0nsAcgt473VrvVutJm4EwUVEr6UHNMzZxg/+8CC3hQpg/gxl9t0IzuN5s1ZTKwDngeW7lKrbM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=ZTpV/1gG; arc=none smtp.client-ip=209.85.221.42 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="ZTpV/1gG" Received: by mail-wr1-f42.google.com with SMTP id ffacd0b85a97d-42e2b78d45bso491651f8f.0 for ; Thu, 04 Dec 2025 06:13:16 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1764857595; x=1765462395; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=JYb/yPra/VQ92UPtHr69bchv45pj9r5YmHZ7p3XU5gk=; b=ZTpV/1gG26JSBGGdXZZKPLubqM7wG0Fb8nawW46f9jIZyqu+tUJPMwVnv3zKCuvLhD WeZG54HWTBCpIZdOpN1ItgPkwW3fQGolizplG8K/QLnuKc3fO0NgBxSTGrVW5nD0F6G5 eliZH0REpPiaQFkxs6XC+xzUHlCefFZ1jY3AWtPAdtGWSzkhMPVeT5zFVkXeGAcUEGCh dSaDcdPtQTCj8+gpVaOcBUGpTU2Zb8eD8iZ9Q+PgnTwLgoY00tHS7S5zTXlgk5Z/KFd3 rOsKAPNjwDnC1k4COOZXFIIOZH6DQEnElGVBiSdQBCROd1kwpzOioG7KLafNGxGmxkPK 2uPA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1764857595; x=1765462395; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=JYb/yPra/VQ92UPtHr69bchv45pj9r5YmHZ7p3XU5gk=; b=QpncYu6HGRSXs2WB62yYGy85v3YLGt7gXXFr0Nb1d57+p0vrvF7VkBVF9iy/T4hdQI jhYog2aywcycGhahWBRudVPZ9m9U06BkKhl19shRGAnWGQ0vMCElmHoCLlsNAc5iIwCv MmatJ46WHFREyZrkLPeQxGwJvWTwSVOU1yTfRuZiN/1EvvIsJRr01xQrmOpC7ojaQw7D +/iapwdPaEq+FGmO9OtNTYqLjXzj7jDDUWMjG7yuaq5GXNqiXiGobFnXwz/ZxzpBxf2p lQS5VO9R8ZLPV7oZCealm8E8PPrjX/E5djMD42AcgqjnfGqABgfzYS/Svf+hl4610lYx QFjQ== X-Forwarded-Encrypted: i=1; AJvYcCWI8f2lcNjEeqjnLbKdkSIZgmmj7HBu0svWXVaqmAKWX2gI0Kjt1R4+lkK3ht5JkL88Pa3yfAKkTpDNASg=@vger.kernel.org X-Gm-Message-State: AOJu0YzaTIAuY1XiE0Q2x3XWgHFPNtrIbGjgEPH2MsL4YjZwRiYETMyd DE8YrOEs1eOQZIfof8X5Z6AR6lXnyCB6q7STiZrDgxHDu6y5HHWvDO+R X-Gm-Gg: ASbGncsoCJMNJUYBVHfSa2xaPsBx4UsuPaJy5i0LO0eA0ANzWgLT9V9DpIh2zVOoayz WuOZyiarTVKM07Mw1are/AyNp4BRieFoE28NJO9hAYat6SLHxtngXWrAWvJLyaemsLFQsfGLbsA PNT63RFO89jMIch+HwAWXz3TpxMp7SGeLn+wLdAFVsJ31F4rfAaGF7gNLRR+vMNw2j6pi5HYJt4 9ZzFjp6K06xD4QQRns+npahxT+oPLK4tYE175Qo9bN1UdkyCHh8vwYGGRypBhEAj7UWtW7OlaWm RK8nicuk4XW5sLHUoxvjzssAH+fqOX8WoVLtt2UqRevP3gTDTBPkGTwaEcwnUXrERIschTDG2iG ZOyS79Das1ij+f8j4k2rU8JBVQrMOGfne+pPzq2oF4wSlEcRhz1iqmpGJnzz6LoRdO2C0+UsYrG FLDCuVwxP0FB6YciHIEBWrx9xaacdhen3Ro6jy6RdTxzfD0OiVdH0poUoxNPDW38nqba6X0WiU3 PXb X-Google-Smtp-Source: AGHT+IFaN2iuHh8JgUwoVZzKMyn/tcQMjt8qJkVwY5tRzh0K3jG6s9pjH/nYgcBl1jHrMCivejQ75w== X-Received: by 2002:a05:6000:290e:b0:42b:411b:e487 with SMTP id ffacd0b85a97d-42f73174091mr6010345f8f.2.1764857594380; Thu, 04 Dec 2025 06:13:14 -0800 (PST) Received: from ethan-tp.d.ethz.ch (2001-67c-10ec-5744-8000--626.net6.ethz.ch. [2001:67c:10ec:5744:8000::626]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-42f7cbfeae9sm3605808f8f.13.2025.12.04.06.13.13 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 04 Dec 2025 06:13:13 -0800 (PST) From: Ethan Graham To: ethan.w.s.graham@gmail.com, glider@google.com Cc: andreyknvl@gmail.com, andy@kernel.org, andy.shevchenko@gmail.com, brauner@kernel.org, brendan.higgins@linux.dev, davem@davemloft.net, davidgow@google.com, dhowells@redhat.com, dvyukov@google.com, elver@google.com, herbert@gondor.apana.org.au, ignat@cloudflare.com, jack@suse.cz, jannh@google.com, johannes@sipsolutions.net, kasan-dev@googlegroups.com, kees@kernel.org, kunit-dev@googlegroups.com, linux-crypto@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org, lukas@wunner.de, rmoar@google.com, shuah@kernel.org, sj@kernel.org, tarasmadan@google.com, Ethan Graham Subject: [PATCH 07/10] kfuzztest: add KFuzzTest sample fuzz targets Date: Thu, 4 Dec 2025 15:12:46 +0100 Message-ID: <20251204141250.21114-8-ethan.w.s.graham@gmail.com> X-Mailer: git-send-email 2.51.0 In-Reply-To: <20251204141250.21114-1-ethan.w.s.graham@gmail.com> References: <20251204141250.21114-1-ethan.w.s.graham@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Ethan Graham Add two simple fuzz target samples to demonstrate the KFuzzTest API and provide basic self-tests for the framework. These examples showcase how a developer can define a fuzz target using the FUZZ_TEST(), constraint, and annotation macros, and serve as runtime sanity checks for the core logic. For example, they test that out-of-bounds memory accesses into poisoned padding regions are correctly detected in a KASAN build. These have been tested by writing syzkaller-generated inputs into their debugfs 'input' files and verifying that the correct KASAN reports were triggered. Signed-off-by: Ethan Graham Signed-off-by: Ethan Graham Acked-by: Alexander Potapenko --- PR v3: - Use the FUZZ_TEST_SIMPLE macro in the `underflow_on_buffer` sample fuzz target instead of FUZZ_TEST. PR v2: - Fix build issues pointed out by the kernel test robot . --- --- samples/Kconfig | 7 ++ samples/Makefile | 1 + samples/kfuzztest/Makefile | 3 + samples/kfuzztest/overflow_on_nested_buffer.c | 71 +++++++++++++++++++ samples/kfuzztest/underflow_on_buffer.c | 51 +++++++++++++ 5 files changed, 133 insertions(+) create mode 100644 samples/kfuzztest/Makefile create mode 100644 samples/kfuzztest/overflow_on_nested_buffer.c create mode 100644 samples/kfuzztest/underflow_on_buffer.c diff --git a/samples/Kconfig b/samples/Kconfig index 6e072a5f1ed8..5209dd9d7a5c 100644 --- a/samples/Kconfig +++ b/samples/Kconfig @@ -320,6 +320,13 @@ config SAMPLE_HUNG_TASK Reading these files with multiple processes triggers hung task detection by holding locks for a long time (256 seconds). =20 +config SAMPLE_KFUZZTEST + bool "Build KFuzzTest sample targets" + depends on KFUZZTEST + help + Build KFuzzTest sample targets that serve as selftests for input + deserialization and inter-region redzone poisoning logic. + source "samples/rust/Kconfig" =20 source "samples/damon/Kconfig" diff --git a/samples/Makefile b/samples/Makefile index 07641e177bd8..3a0e7f744f44 100644 --- a/samples/Makefile +++ b/samples/Makefile @@ -44,4 +44,5 @@ obj-$(CONFIG_SAMPLE_DAMON_WSSE) +=3D damon/ obj-$(CONFIG_SAMPLE_DAMON_PRCL) +=3D damon/ obj-$(CONFIG_SAMPLE_DAMON_MTIER) +=3D damon/ obj-$(CONFIG_SAMPLE_HUNG_TASK) +=3D hung_task/ +obj-$(CONFIG_SAMPLE_KFUZZTEST) +=3D kfuzztest/ obj-$(CONFIG_SAMPLE_TSM_MR) +=3D tsm-mr/ diff --git a/samples/kfuzztest/Makefile b/samples/kfuzztest/Makefile new file mode 100644 index 000000000000..4f8709876c9e --- /dev/null +++ b/samples/kfuzztest/Makefile @@ -0,0 +1,3 @@ +# SPDX-License-Identifier: GPL-2.0-only + +obj-$(CONFIG_SAMPLE_KFUZZTEST) +=3D overflow_on_nested_buffer.o underflow_= on_buffer.o diff --git a/samples/kfuzztest/overflow_on_nested_buffer.c b/samples/kfuzzt= est/overflow_on_nested_buffer.c new file mode 100644 index 000000000000..2f1c3ff9f750 --- /dev/null +++ b/samples/kfuzztest/overflow_on_nested_buffer.c @@ -0,0 +1,71 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * This file contains a KFuzzTest example target that ensures that a buffer + * overflow on a nested region triggers a KASAN OOB access report. + * + * Copyright 2025 Google LLC + */ + +/** + * DOC: test_overflow_on_nested_buffer + * + * This test uses a struct with two distinct dynamically allocated buffers. + * It checks that KFuzzTest's memory layout correctly poisons the memory + * regions and that KASAN can detect an overflow when reading one byte pas= t the + * end of the first buffer (`a`). + * + * It can be invoked with kfuzztest-bridge using the following command: + * + * ./kfuzztest-bridge \ + * "nested_buffers { ptr[a] len[a, u64] ptr[b] len[b, u64] }; \ + * a { arr[u8, 64] }; b { arr[u8, 64] };" \ + * "test_overflow_on_nested_buffer" /dev/urandom + * + * The first argument describes the C struct `nested_buffers` and specifie= s that + * both `a` and `b` are pointers to arrays of 64 bytes. + */ +#include + +static void overflow_on_nested_buffer(const char *a, size_t a_len, const c= har *b, size_t b_len) +{ + size_t i; + pr_info("a =3D [%px, %px)", a, a + a_len); + pr_info("b =3D [%px, %px)", b, b + b_len); + + /* Ensure that all bytes in arg->b are accessible. */ + for (i =3D 0; i < b_len; i++) + READ_ONCE(b[i]); + /* + * Check that all bytes in arg->a are accessible, and provoke an OOB on + * the first byte to the right of the buffer which will trigger a KASAN + * report. + */ + for (i =3D 0; i <=3D a_len; i++) + READ_ONCE(a[i]); +} + +struct nested_buffers { + const char *a; + size_t a_len; + const char *b; + size_t b_len; +}; + +/** + * The KFuzzTest input format specifies that struct nested buffers should + * be expanded as: + * + * | a | b | pad[8] | *a | pad[8] | *b | + * + * where the padded regions are poisoned. We expect to trigger a KASAN rep= ort by + * overflowing one byte into the `a` buffer. + */ +FUZZ_TEST(test_overflow_on_nested_buffer, struct nested_buffers) +{ + KFUZZTEST_EXPECT_NOT_NULL(nested_buffers, a); + KFUZZTEST_EXPECT_NOT_NULL(nested_buffers, b); + KFUZZTEST_ANNOTATE_LEN(nested_buffers, a_len, a); + KFUZZTEST_ANNOTATE_LEN(nested_buffers, b_len, b); + + overflow_on_nested_buffer(arg->a, arg->a_len, arg->b, arg->b_len); +} diff --git a/samples/kfuzztest/underflow_on_buffer.c b/samples/kfuzztest/un= derflow_on_buffer.c new file mode 100644 index 000000000000..b2f5ff467334 --- /dev/null +++ b/samples/kfuzztest/underflow_on_buffer.c @@ -0,0 +1,51 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * This file contains a KFuzzTest example target that ensures that a buffer + * underflow on a region triggers a KASAN OOB access report. + * + * Copyright 2025 Google LLC + */ + +/** + * DOC: test_underflow_on_buffer + * + * This test ensures that the region between the metadata struct and the + * dynamically allocated buffer is poisoned. It provokes a one-byte underf= low + * on the buffer, which should be caught by KASAN. + * + * It can be invoked with kfuzztest-bridge using the following command: + * + * ./kfuzztest-bridge \ + * "some_buffer { ptr[buf] len[buf, u64]}; buf { arr[u8, 128] };" \ + * "test_underflow_on_buffer" /dev/urandom + * + * The first argument describes the C struct `some_buffer` and specifies t= hat + * `buf` is a pointer to an array of 128 bytes. The second argument is the= test + * name, and the third is a seed file. + */ +#include + +static void underflow_on_buffer(char *buf, size_t buflen) +{ + size_t i; + + pr_info("buf =3D [%px, %px)", buf, buf + buflen); + + /* First ensure that all bytes in arg->b are accessible. */ + for (i =3D 0; i < buflen; i++) + READ_ONCE(buf[i]); + /* + * Provoke a buffer overflow on the first byte preceding b, triggering + * a KASAN report. + */ + READ_ONCE(*((char *)buf - 1)); +} + +/** + * Tests that the region between struct some_buffer and the expanded *buf = field + * is correctly poisoned by accessing the first byte before *buf. + */ +FUZZ_TEST_SIMPLE(test_underflow_on_buffer) +{ + underflow_on_buffer(data, datalen); +} --=20 2.51.0 From nobody Sun Dec 14 14:00:08 2025 Received: from mail-wr1-f45.google.com (mail-wr1-f45.google.com [209.85.221.45]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id EE6E834403C for ; Thu, 4 Dec 2025 14:13:18 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.221.45 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1764857602; cv=none; b=g6q0u0HJ29k9ZJzqZBuKHMAnB2+OHlTx/i7F+zYZdwI1EqVhjiTJJJYzTdoQIBkAPxVqd8eyY8fNNC5z3IUFBL7PJTPurRQmOLGtfZb6npnHFJHibTTSwyLjO6ofZ5LjUMqj0RGMO0iX7QONIFSQ3FRCniAQB2vr6YmkyN3ApKU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1764857602; c=relaxed/simple; bh=TnJsqKSnzKIC0iSPoujmB0qizXCqm6TL46n3TvXH0Io=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=JSm9nI12LPQewotLq4AJzHVGQt7z1qi5mhbOKLsh9MzEY7afE1RQx+cdJ24DVa1Q2H14+/r0OqOJSUDfJBRWX04WgwzhGfzUPbodXMtkcNAHvg4bmsRbvmTOS3iXndrrDM2uj6PZXlArKiY48dmllWpf2Wfz0AJ2ObZLlkUzvvE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=EjzNgMOr; arc=none smtp.client-ip=209.85.221.45 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="EjzNgMOr" Received: by mail-wr1-f45.google.com with SMTP id ffacd0b85a97d-42b38de7940so564607f8f.3 for ; Thu, 04 Dec 2025 06:13:18 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1764857596; x=1765462396; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=RabXc9ZxWPd5N856tl6EMMSdBPz7PelUrbPrIKztc18=; b=EjzNgMOrXM32j0zQjTcDbpsZPHyd1lrvWD4NN3/4aWetz0z4L8mg6qmDWB1pEhaHaY kcnCaVmx4OhUH9xoN35jj54HHeiFQdLkZzoHYQ06ttDXzxOGRymU5SjSLU7KcU6oJsiA zt6wdV/xvIFlBNId3P+P/ERdCc8weseOUImH5E5JyvpD1qKujw0kEM6oO3wxQMOwfeQP UTqr5BU67JkRkdSXj83aCxFIwlLi+wldYyyZlOtN7zljx5qZqRWdwi9tC0a13CTWgLq5 9gJjwMVEal3vVzF5ZALnoCwFimoq0fhWeP9tkzqWO1o0QgZum2Ww314Re+ilmWms4w7j teUw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1764857596; x=1765462396; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=RabXc9ZxWPd5N856tl6EMMSdBPz7PelUrbPrIKztc18=; b=ulwcaX7NNBXNLsGEBNKdYM/d9IU1LISYYzemmIafJqUtGtcFynG+Vf/hYpi/SR/OAP rfEVwznKk6pjRi4wetHmuPP/qiFbD12LffQV2Dg+1jDEC7397cWBCtvGD1jPlyHE6NMb FpzUl/RKHq3BChNtQ0mNZ+cs3llb9vCWxibDp4qTfgorBFuEnfwH8a1jE/R1FP/DY4AB 4TZ3up3kcTO6ewhmdHM7x88sh8/fMDqcsEYiTTDDTFTw9DoQJhHMnBK5Nd/2g+2QtNi4 8tVpe2s0A7xTpNlNsnULKS8NGRCbiLGnS6mornrFtsjYZAAoMpGe1ABtQTtk1pIp/vDq CQSA== X-Forwarded-Encrypted: i=1; AJvYcCUo77HsKM/GxuQMqyqslVftcTzDFrA+PfQEp3hd7rqGc96g9PLVjImAkK6qsd+VYgDTvagDNgSnfXb/9Ao=@vger.kernel.org X-Gm-Message-State: AOJu0YykCjJ3psViTsStHZeTpdSP5HZvo4QPxE84bC7ahjly+HTC+IzF 7s8NPMboIM7pJ8imXSVU9h7iHcPGyuyyT63oQcUZ6oLewH3rkUbP256f X-Gm-Gg: ASbGncuDypdFp8zvJjjbeXC8W8HhdR++8WYwGVmKptyRvlXZCEoxm3cp3zn3rMCUDw2 womFOG503k38zkSeH+1dEe4/fRQZPIAYC7+CJ4/b/jW5pjVDswz1lELvnqZabaCZeefECfEPHzZ UySanPxQggLz8nrHjp7cuheYJFDVE1+KxAWhJUcCvX0lI6FeZNaPaM7SUfc7JtkJNHmIdlX/3jq GjJz26r2rEahA37dcBfPU3WrIPmTZqJlr7H0uJjevPKUMPzfYohGQNhwQ/zdwar66PyENdLv57h aVFQqC6B2Hu7VvyWXhT1h5NznB6xH3gROuze5UJRm5ZrlrVbm/pklVSbky1+2xOYzvvsLpU4KON s6mTGFqNFSLgJBbyS/natwTFaCq4lYvkapo2NmsyNLOJitU7E1DauOJWTca1ITy7MI1jLLYLbSv 13pgIrQ/vkw4St7PVVDWxxICl0Sog3gx3Znxw+T6t5nQugXgrP+TlbXIUhJSi643zQUg== X-Google-Smtp-Source: AGHT+IERDnLFLwOhzCzxM3fAOB4m9Q5P8T4LaKuBCRN+Nt+F4adsNxaxUHUrlib3xIGvfpKFuuE84A== X-Received: by 2002:a05:6000:2306:b0:42b:3963:d08e with SMTP id ffacd0b85a97d-42f731967f8mr6489489f8f.22.1764857595783; Thu, 04 Dec 2025 06:13:15 -0800 (PST) Received: from ethan-tp.d.ethz.ch (2001-67c-10ec-5744-8000--626.net6.ethz.ch. [2001:67c:10ec:5744:8000::626]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-42f7cbfeae9sm3605808f8f.13.2025.12.04.06.13.14 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 04 Dec 2025 06:13:15 -0800 (PST) From: Ethan Graham To: ethan.w.s.graham@gmail.com, glider@google.com Cc: andreyknvl@gmail.com, andy@kernel.org, andy.shevchenko@gmail.com, brauner@kernel.org, brendan.higgins@linux.dev, davem@davemloft.net, davidgow@google.com, dhowells@redhat.com, dvyukov@google.com, elver@google.com, herbert@gondor.apana.org.au, ignat@cloudflare.com, jack@suse.cz, jannh@google.com, johannes@sipsolutions.net, kasan-dev@googlegroups.com, kees@kernel.org, kunit-dev@googlegroups.com, linux-crypto@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org, lukas@wunner.de, rmoar@google.com, shuah@kernel.org, sj@kernel.org, tarasmadan@google.com, Ethan Graham Subject: [PATCH 08/10] crypto: implement KFuzzTest targets for PKCS7 and RSA parsing Date: Thu, 4 Dec 2025 15:12:47 +0100 Message-ID: <20251204141250.21114-9-ethan.w.s.graham@gmail.com> X-Mailer: git-send-email 2.51.0 In-Reply-To: <20251204141250.21114-1-ethan.w.s.graham@gmail.com> References: <20251204141250.21114-1-ethan.w.s.graham@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Ethan Graham Add KFuzzTest targets for pkcs7_parse_message, rsa_parse_pub_key, and rsa_parse_priv_key to serve as real-world examples of how the framework is used. These functions are ideal candidates for KFuzzTest as they perform complex parsing of user-controlled data but are not directly exposed at the syscall boundary. This makes them difficult to exercise with traditional fuzzing tools and showcases the primary strength of the KFuzzTest framework: providing an interface to fuzz internal functions. To validate the effectiveness of the framework on these new targets, we injected two artificial bugs and let syzkaller fuzz the targets in an attempt to catch them. The first of these was calling the asn1 decoder with an incorrect input from pkcs7_parse_message, like so: - ret =3D asn1_ber_decoder(&pkcs7_decoder, ctx, data, datalen); + ret =3D asn1_ber_decoder(&pkcs7_decoder, ctx, data, datalen + 1); The second was bug deeper inside of asn1_ber_decoder itself, like so: - for (len =3D 0; n > 0; n--) + for (len =3D 0; n >=3D 0; n--) syzkaller was able to trigger these bugs, and the associated KASAN slab-out-of-bounds reports, within seconds. The targets are defined within crypto/asymmetric-keys/tests. Signed-off-by: Ethan Graham Signed-off-by: Ethan Graham Reviewed-by: Ignat Korchagin --- PR v3: - Use the FUZZ_TEST_SIMPLE macro for all introduced fuzz targets as they each take `(data, datalen)` pairs. This also removes the need for explicit constraints and annotations which become implicit. PR v2: - Make fuzz targets also depend on the KConfig options needed for the functions they are fuzzing, CONFIG_PKCS7_MESSAGE_PARSER and CONFIG_CRYPTO_RSA respectively. - Fix build issues pointed out by the kernel test robot . - Account for return value of pkcs7_parse_message, and free resources if the function call succeeds. PR v1: - Change the fuzz target build to depend on CONFIG_KFUZZTEST=3Dy, eliminating the need for a separate config option for each individual file as suggested by Ignat Korchagin. - Remove KFUZZTEST_EXPECT_LE on the length of the `key` field inside of the fuzz targets. A maximum length is now set inside of the core input parsing logic. RFC v2: - Move KFuzzTest targets outside of the source files into dedicated _kfuzz.c files under /crypto/asymmetric_keys/tests/ as suggested by Ignat Korchagin and Eric Biggers. --- --- crypto/asymmetric_keys/Makefile | 2 ++ crypto/asymmetric_keys/tests/Makefile | 4 ++++ crypto/asymmetric_keys/tests/pkcs7_kfuzz.c | 17 ++++++++++++++++ .../asymmetric_keys/tests/rsa_helper_kfuzz.c | 20 +++++++++++++++++++ 4 files changed, 43 insertions(+) create mode 100644 crypto/asymmetric_keys/tests/Makefile create mode 100644 crypto/asymmetric_keys/tests/pkcs7_kfuzz.c create mode 100644 crypto/asymmetric_keys/tests/rsa_helper_kfuzz.c diff --git a/crypto/asymmetric_keys/Makefile b/crypto/asymmetric_keys/Makef= ile index bc65d3b98dcb..77b825aee6b2 100644 --- a/crypto/asymmetric_keys/Makefile +++ b/crypto/asymmetric_keys/Makefile @@ -67,6 +67,8 @@ obj-$(CONFIG_PKCS7_TEST_KEY) +=3D pkcs7_test_key.o pkcs7_test_key-y :=3D \ pkcs7_key_type.o =20 +obj-y +=3D tests/ + # # Signed PE binary-wrapped key handling # diff --git a/crypto/asymmetric_keys/tests/Makefile b/crypto/asymmetric_keys= /tests/Makefile new file mode 100644 index 000000000000..023d6a65fb89 --- /dev/null +++ b/crypto/asymmetric_keys/tests/Makefile @@ -0,0 +1,4 @@ +pkcs7-kfuzz-y :=3D $(and $(CONFIG_KFUZZTEST),$(CONFIG_PKCS7_MESSAGE_PARSER= )) +rsa-helper-kfuzz-y :=3D $(and $(CONFIG_KFUZZTEST),$(CONFIG_CRYPTO_RSA)) +obj-$(pkcs7-kfuzz-y) +=3D pkcs7_kfuzz.o +obj-$(rsa-helper-kfuzz-y) +=3D rsa_helper_kfuzz.o diff --git a/crypto/asymmetric_keys/tests/pkcs7_kfuzz.c b/crypto/asymmetric= _keys/tests/pkcs7_kfuzz.c new file mode 100644 index 000000000000..345f99990653 --- /dev/null +++ b/crypto/asymmetric_keys/tests/pkcs7_kfuzz.c @@ -0,0 +1,17 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * PKCS#7 parser KFuzzTest target + * + * Copyright 2025 Google LLC + */ +#include +#include + +FUZZ_TEST_SIMPLE(test_pkcs7_parse_message) +{ + struct pkcs7_message *msg; + + msg =3D pkcs7_parse_message(data, datalen); + if (msg && !IS_ERR(msg)) + kfree(msg); +} diff --git a/crypto/asymmetric_keys/tests/rsa_helper_kfuzz.c b/crypto/asymm= etric_keys/tests/rsa_helper_kfuzz.c new file mode 100644 index 000000000000..dd434f1a21ed --- /dev/null +++ b/crypto/asymmetric_keys/tests/rsa_helper_kfuzz.c @@ -0,0 +1,20 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * RSA key extract helper KFuzzTest targets + * + * Copyright 2025 Google LLC + */ +#include +#include + +FUZZ_TEST_SIMPLE(test_rsa_parse_pub_key) +{ + struct rsa_key out; + rsa_parse_pub_key(&out, data, datalen); +} + +FUZZ_TEST_SIMPLE(test_rsa_parse_priv_key) +{ + struct rsa_key out; + rsa_parse_priv_key(&out, data, datalen); +} --=20 2.51.0 From nobody Sun Dec 14 14:00:08 2025 Received: from mail-wm1-f53.google.com (mail-wm1-f53.google.com [209.85.128.53]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 6E70B34402D for ; Thu, 4 Dec 2025 14:13:19 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.53 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1764857603; cv=none; b=naKOQUqez2zUucrVJN4BQM/ppY1DYSSFyskrE8t+b8JJQq0TmCmTstDnm4EGYtYH4lGGtaTpCQgyqvjsYe9y0OcyXHYvGlxJtTW8cWou81Bn971vHxYzyc11k2lLR+qgue70A23bNvxYTU9RUGZk/Bf14vSHWPDRjYmGTLEcCBI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1764857603; c=relaxed/simple; bh=SLr8BO4ZGW22sZ7mEfPrF/suWJfHfY2rN3bWKeuDZ8k=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=pAla2Ype2tkNsirkWwH8o/Lg+jBmpTrM9iH8wixwropy5RcLKKCvV5NgOeI85v1m6q9ZgnuetB7dlI3zmvXwlxwm+VbTIgb5RGfUI038NOGz0f75pgOT4+RZzb+4ig5uFs+dv6nf9uNb4rHoVDLQBL5jMJQtWIuEXz9NIbESw34= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=bGzW71Bo; arc=none smtp.client-ip=209.85.128.53 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="bGzW71Bo" Received: by mail-wm1-f53.google.com with SMTP id 5b1f17b1804b1-477a1c28778so13925225e9.3 for ; Thu, 04 Dec 2025 06:13:19 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1764857597; x=1765462397; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=Ekn2DBIpCkQXanmNkedEYdcryjYDg+bStsY06P8Miig=; b=bGzW71BoNXtNjjbz1PyhU+5UP6+NttYR8U1PNX0svQjpXNwi/LqJPiQlqcT+JwX1af pa6mFPWQ7aIwqC0W5J98rdB8CktaRgqmLi/9a7mKOP7bIG8K/UPsC7Zx6Jr6BFcI8Ff8 QdVQ6vc74tVQhL7wQNoit7dR+DgQ4T4Wc2wCrw6O9Wo7zzCjOWRmPbA+54LI3lkiSDog TXuKmPaIe7UJ1ilcEGAQQKnoG4ykjs2r/gMDvrd2s2MBbNP2ImqS9NlW/CGo3+6H2UCp DhRpUSJEV3dVxubijbBPAHC5L8IGBMvMu40JwFMd9N5BR0wGOBAS5dpnuL45eVDQ7xZ5 HeHw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1764857597; x=1765462397; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=Ekn2DBIpCkQXanmNkedEYdcryjYDg+bStsY06P8Miig=; b=foPAFyGysFbzQKcOlW78n8XJqxe5lFopDP0i2R3L1vCDv7FPDkv19Rhxb+yb0QWZ+o vrf+hKfXX/oQEPa7hlrV6LJccLHznIi3Ndb7mJ/4uXvyJ9YTIGzz1A/JLSbMtGy6wp7e jmJZo9+8sdwyGK+Z9jP0iuZW3DgWznXRrE+zY75JL3P3QeTcy9Wn808wA2CHlJV9cE0g tP1W5p1xVpZNUJmTKwpIYXbvWVzkvUqBlEtO+ezqqEk600jfZQTOL7jSB2Z/3IS/t8Ai UvVEQqQwvdCz6aocq5Kh/KUbROHjmAcVzLrlmJSxXz3thTR5PtlKLESLOZTZTHw1JdNh NNyQ== X-Forwarded-Encrypted: i=1; AJvYcCXwjPw5dWoXkMqfgVtn+WCXUtSIEMbZHxV9BXwykewKeCUxAiZTnxOPp7iAHoIi0cCOEUtKBAprdZ6vDz0=@vger.kernel.org X-Gm-Message-State: AOJu0YwadYGCAiw5CH5lD432+HCY6loCdIGu4Avyjq2FIxFQhJ2k2B0o fcUHqaw46J9m2Eq9+324cRZBvkKfR07GhnvSNuKZh53rB/6OJFqNrf5I X-Gm-Gg: ASbGncvN48Y1gjzGEx82mDINrWoBg5Ccea8agWwIp68bCGMuKLSEEGgwHrxPFI0A/pE Ycie+kOIEo26v7B/4CXDY4GXMgsGXjMTqnwphNtXGua0mAnpHTmQ8rJau/cNmB43P+7ozgnVDMB 34fNBKkq5ckGM0h4MmIiv55N6JIUBqSybSa4CeuvkY1s9ZBJVqhe4LeFk+1DeUazC3r7pTJ9qlO cughp1hKR4if6XhE4sM8xsnkLkhrxpWVTUoG5I4MG4H8npFlSVznzSvKAMSC9Zgmr3p/94pi3fR vCBCxi0iVTtEkVlOW3aXf6MVxGDZvWW/ees3pzEzmPDNAge24+7pEhpyRrkQu8Np9BsYDAOhl6B 93H0P/0LhCwUfsEqkpYrYWo6zzG4e9m+QaPIPcnCjwcORT3ImVcxDD7PWtQavlt+0wYj/Pfb5Bl RYUl/t4XwS7ZIZnyYeluvbe9SDWxg+BG9GvQY7udAVe1+BeQ5Ar7npp94xoX/D9TnuxA== X-Google-Smtp-Source: AGHT+IF0jf9L5DYl+1CaWZ41zHsxhPYhONOE+2bdn2S71mNR6t6KEufMrADSOSJwyHdeDKC7Wy8upA== X-Received: by 2002:a05:6000:144c:b0:3e8:b4cb:c3dc with SMTP id ffacd0b85a97d-42f79514872mr3363210f8f.3.1764857597333; Thu, 04 Dec 2025 06:13:17 -0800 (PST) Received: from ethan-tp.d.ethz.ch (2001-67c-10ec-5744-8000--626.net6.ethz.ch. [2001:67c:10ec:5744:8000::626]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-42f7cbfeae9sm3605808f8f.13.2025.12.04.06.13.16 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 04 Dec 2025 06:13:16 -0800 (PST) From: Ethan Graham To: ethan.w.s.graham@gmail.com, glider@google.com Cc: andreyknvl@gmail.com, andy@kernel.org, andy.shevchenko@gmail.com, brauner@kernel.org, brendan.higgins@linux.dev, davem@davemloft.net, davidgow@google.com, dhowells@redhat.com, dvyukov@google.com, elver@google.com, herbert@gondor.apana.org.au, ignat@cloudflare.com, jack@suse.cz, jannh@google.com, johannes@sipsolutions.net, kasan-dev@googlegroups.com, kees@kernel.org, kunit-dev@googlegroups.com, linux-crypto@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org, lukas@wunner.de, rmoar@google.com, shuah@kernel.org, sj@kernel.org, tarasmadan@google.com, Ethan Graham Subject: [PATCH 09/10] drivers/auxdisplay: add a KFuzzTest for parse_xy() Date: Thu, 4 Dec 2025 15:12:48 +0100 Message-ID: <20251204141250.21114-10-ethan.w.s.graham@gmail.com> X-Mailer: git-send-email 2.51.0 In-Reply-To: <20251204141250.21114-1-ethan.w.s.graham@gmail.com> References: <20251204141250.21114-1-ethan.w.s.graham@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Ethan Graham Add a KFuzzTest fuzzer for the parse_xy() function, located in a new file under /drivers/auxdisplay/tests. To validate the correctness and effectiveness of this KFuzzTest target, a bug was injected into parse_xy() like so: drivers/auxdisplay/charlcd.c:179 - s =3D p; + s =3D p + 1; Although a simple off-by-one bug, it requires a specific input sequence in order to trigger it, thus demonstrating the power of pairing KFuzzTest with a coverage-guided fuzzer like syzkaller. Signed-off-by: Ethan Graham Signed-off-by: Ethan Graham Acked-by: Alexander Potapenko --- PR v3: - Remove conditional inclusion of charlcd_kfuzz.c from charlcd.c, as requested by Andy Shevchenko. - Update auxdisplay Makefile to conditionally build charlcd_kfuzz.c when CONFIG_KFUZZTEST=3Dy, as suggested by Lukas Wunner and Andy Shevchenko. - Foward declare parse_xy in charlcd_kfuzz.c. --- --- drivers/auxdisplay/Makefile | 3 +++ drivers/auxdisplay/tests/charlcd_kfuzz.c | 22 ++++++++++++++++++++++ 2 files changed, 25 insertions(+) create mode 100644 drivers/auxdisplay/tests/charlcd_kfuzz.c diff --git a/drivers/auxdisplay/Makefile b/drivers/auxdisplay/Makefile index f5c13ed1cd4f..af00b0a173de 100644 --- a/drivers/auxdisplay/Makefile +++ b/drivers/auxdisplay/Makefile @@ -6,6 +6,9 @@ obj-$(CONFIG_ARM_CHARLCD) +=3D arm-charlcd.o obj-$(CONFIG_CFAG12864B) +=3D cfag12864b.o cfag12864bfb.o obj-$(CONFIG_CHARLCD) +=3D charlcd.o +ifeq ($(CONFIG_KFUZZTEST),y) +CFLAGS_charlcd.o +=3D -include $(src)/tests/charlcd_kfuzz.c +endif obj-$(CONFIG_HD44780_COMMON) +=3D hd44780_common.o obj-$(CONFIG_HD44780) +=3D hd44780.o obj-$(CONFIG_HT16K33) +=3D ht16k33.o diff --git a/drivers/auxdisplay/tests/charlcd_kfuzz.c b/drivers/auxdisplay/= tests/charlcd_kfuzz.c new file mode 100644 index 000000000000..3adf510f4356 --- /dev/null +++ b/drivers/auxdisplay/tests/charlcd_kfuzz.c @@ -0,0 +1,22 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * charlcd KFuzzTest target + * + * Copyright 2025 Google LLC + */ +#include + +struct parse_xy_arg { + const char *s; +}; + +static bool parse_xy(const char *s, unsigned long *x, unsigned long *y); + +FUZZ_TEST(test_parse_xy, struct parse_xy_arg) +{ + unsigned long x, y; + + KFUZZTEST_EXPECT_NOT_NULL(parse_xy_arg, s); + KFUZZTEST_ANNOTATE_STRING(parse_xy_arg, s); + parse_xy(arg->s, &x, &y); +} --=20 2.51.0 From nobody Sun Dec 14 14:00:08 2025 Received: from mail-wr1-f42.google.com (mail-wr1-f42.google.com [209.85.221.42]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 381123446B1 for ; Thu, 4 Dec 2025 14:13:21 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.221.42 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1764857607; cv=none; b=g598nHg4bDYDj0dk/rrEBPKebO3nB6PQcFTd5ntftHG0+KECVy4/UT3VdQhbn4mwi9X8NuZ8LAqfDCzQpQEarChqLFmCR09RTBMXHZblWxAWtA+hC+WPjO8cM4qw97e4P69p0Uc1HP7xdj7owjqhdSPD/pAkqkDhMr53bGr6ilo= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1764857607; c=relaxed/simple; bh=sX8tJl3ec5ExcYdWiCDgj7+mGqBJlF+/32yuBkRXzdg=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=nwG7/PM/4g3Kel4F+/Is2wUBxH3j/7ZYPr1uidD2IBKUcT11mhhSAIqU7YF3x7RgvT84xEJ79R2Xp6/w5zFJI30E4pj9/Sqd9kZp0nXR6p7SMY3g+cvXPPXV3CPX2Ai30whhMZMbpbyj23r7Bjqxac3deDS5QVK6U7Ofv/WD8bc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=lesFipEm; arc=none smtp.client-ip=209.85.221.42 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="lesFipEm" Received: by mail-wr1-f42.google.com with SMTP id ffacd0b85a97d-42e2e77f519so786489f8f.2 for ; Thu, 04 Dec 2025 06:13:20 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1764857599; x=1765462399; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=sGnt8bTKaac1K6msaRLVltkt9xGbtE5aMKqhuya716s=; b=lesFipEmw7/uF6wcyTzvp4gLewTJCQ5yanJpPE0A3I05nMMI3hLGNCkoHJKjgJ3xVV cFxZnynvoPO6HIgcjuT4RmHQ8Qyc8VjwTCKX+0ohuOXnGOtskReCVOApEucRIz2hxkPA gM6yWlYf2vgvSmH+yw7SObYGKK8QtywjVvAsoIW1J14rc9vmP2g3F8TCgjWsbD1Kq7fF 9gGni3Gkt0LJuXhCftYBBNFSSnBNChtWf+LlC6Bg9Q29jsWa7iKL0M1orxkmewxz1Evg 0v0Ze/bbyQI9DD0rXJjuCAbp+Jz/5mxPgJp2AAk/VVuS2k6BDjHBC5yhfYYjWTHsxCZY sh2w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1764857599; x=1765462399; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=sGnt8bTKaac1K6msaRLVltkt9xGbtE5aMKqhuya716s=; b=nu4rPaEmUZHEEwImphd6NOQNGG5avkTuj1grehjnGnmjkUxeLWOdeGRUhdsPikFWRj gutxI1bEYCLjKSXyAtb9LdtJAH35FbTdfAljaaWRJCpme5NMzgcdg1YWJG7CmT47Vov1 JNPSbq1OQLXrRZeI9m3NMvhaQR7+2UK7NSpNR2S8FA+d5cPTtpNiI2KCtP8MnFpbqTo/ VfbnRLxOnkabe7792wyGECsFjyvNfsCKttkKvuhezYX8rRBOmAVbQYm8LdDMECrpKJpI eZZBrafSLDT3D3oSIUAIwqDBneVFMVqGmKS3b8kg6nmU0W3VYvJdeRrwRHwJZ/RYaVOB aFOw== X-Forwarded-Encrypted: i=1; AJvYcCVbJ39uQ7zJpHJCZvlc/UChd6OCVh5At/RgBnevZZrsNmSJ8eF5Q7C4f1K8+Tl+E7iSjO16FUgwGLvkF+s=@vger.kernel.org X-Gm-Message-State: AOJu0YyQ3Zu6VLTwLb4z0Q9vqK9ikAVZupZpY4Al/uS6/fkc7wUuO1pO +qvJKPIrYRsA99krQlWS9gIvhh1X8yPJh8nGW2oazZqSFDQVy6wiQaON X-Gm-Gg: ASbGncsDOVL93IiL0Z3ok03s2/a7afMrKr1kzMPFZzgDQXYzwY36yIVFNU2WJTwM/BV KJB8RvR6zPyaQ4pGXfrsyIc4LRPLgOul3v2rut5eINR0xGJSU9/h2jPOlEfKZMojf+WEOXU0S/a TyEzlhEzImcj1aEBuXQ9kAhU7qU57YFRvfU+DMZrx2mKXo8thJP4dbjKnEDREL56h3nEsAhzmRr Z00oaza3Fo0BEwhPXqol3t9qCpI7y7Vixk2uldkIfO7jsMiAWG5Z7/qk8yK/Hayc9TgLTS/BeUI YKfbQ1dUugT6/oA0j/neVGc7BMh8RhiiWY5vISB+DdEmAOy9mDEzLSn4crhuVOMHMV3XxJiGvhW WKDEsojJnw4+HgACTHMoZ7dWM4vvOzV90K1fvMByTi2xzQXN+Q/a3rjTUGxJuIgImzWTHkyo2A5 YuMTIQymEpCqb8ztAPP2suGDAtn2BeGbPeHSyrEZ3hMuN/PITZH36BefYc82zJKC3o3w== X-Google-Smtp-Source: AGHT+IHxDahYGwa5aI52HyW8cxdFR6RMIDSPOdl390+QQfG8ySHaxkFn6koa/YtHAqSa67lSItxZ9w== X-Received: by 2002:a05:6000:2510:b0:42b:3a1b:f71a with SMTP id ffacd0b85a97d-42f79800f02mr3172811f8f.23.1764857598697; Thu, 04 Dec 2025 06:13:18 -0800 (PST) Received: from ethan-tp.d.ethz.ch (2001-67c-10ec-5744-8000--626.net6.ethz.ch. [2001:67c:10ec:5744:8000::626]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-42f7cbfeae9sm3605808f8f.13.2025.12.04.06.13.17 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 04 Dec 2025 06:13:18 -0800 (PST) From: Ethan Graham To: ethan.w.s.graham@gmail.com, glider@google.com Cc: andreyknvl@gmail.com, andy@kernel.org, andy.shevchenko@gmail.com, brauner@kernel.org, brendan.higgins@linux.dev, davem@davemloft.net, davidgow@google.com, dhowells@redhat.com, dvyukov@google.com, elver@google.com, herbert@gondor.apana.org.au, ignat@cloudflare.com, jack@suse.cz, jannh@google.com, johannes@sipsolutions.net, kasan-dev@googlegroups.com, kees@kernel.org, kunit-dev@googlegroups.com, linux-crypto@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org, lukas@wunner.de, rmoar@google.com, shuah@kernel.org, sj@kernel.org, tarasmadan@google.com, Ethan Graham Subject: [PATCH 10/10] MAINTAINERS: add maintainer information for KFuzzTest Date: Thu, 4 Dec 2025 15:12:49 +0100 Message-ID: <20251204141250.21114-11-ethan.w.s.graham@gmail.com> X-Mailer: git-send-email 2.51.0 In-Reply-To: <20251204141250.21114-1-ethan.w.s.graham@gmail.com> References: <20251204141250.21114-1-ethan.w.s.graham@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Ethan Graham Add myself as maintainer and Alexander Potapenko as reviewer for KFuzzTest. Signed-off-by: Ethan Graham Signed-off-by: Ethan Graham Acked-by: Alexander Potapenko --- PR v3: - Update MAINTAINERS to reflect the correct location of kfuzztest-bridge under tools/testing as pointed out by SeongJae Park. --- --- MAINTAINERS | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index 6dcfbd11efef..3ad357477f92 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -13641,6 +13641,14 @@ F: include/linux/kfifo.h F: lib/kfifo.c F: samples/kfifo/ =20 +KFUZZTEST +M: Ethan Graham +R: Alexander Potapenko +F: include/linux/kfuzztest.h +F: lib/kfuzztest/ +F: Documentation/dev-tools/kfuzztest.rst +F: tools/testing/kfuzztest-bridge/ + KGDB / KDB /debug_core M: Jason Wessel M: Daniel Thompson --=20 2.51.0