From patchwork Tue Jun 6 21:42:45 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Maxim Mikityanskiy X-Patchwork-Id: 13269762 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 098EBC7EE2F for ; Tue, 6 Jun 2023 21:43:11 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234384AbjFFVnK (ORCPT ); Tue, 6 Jun 2023 17:43:10 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:46402 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S239760AbjFFVnI (ORCPT ); Tue, 6 Jun 2023 17:43:08 -0400 Received: from mail-pg1-x52c.google.com (mail-pg1-x52c.google.com [IPv6:2607:f8b0:4864:20::52c]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 1501E1702; Tue, 6 Jun 2023 14:43:08 -0700 (PDT) Received: by mail-pg1-x52c.google.com with SMTP id 41be03b00d2f7-5428f63c73aso3376559a12.1; Tue, 06 Jun 2023 14:43:08 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20221208; t=1686087787; x=1688679787; 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=bVp3sxGYYmvDAXqCieOLHVX04weYGZl76ejiM9qiOig=; b=fqET+JlDRntgb32iyH8TFVlq9tCg5tef16N87Ywknv/Aq2IVb8THmvh0ZaEPrvpmvb ItLXX3s1P+GOE833peHemYfag3nF1dNySynWachycA+Vlr0sYxjV9mtu8EiDuijtOTh8 hNE5KaNjDjH8Oo8F+6EFagol7T1stiiEk21nGLK6tvPSvUP6+gjSmUFESAFEORXN1GUM xmhRql0x8ksYfnZSvBfI8xBDbd8lPVUPOQbB5cvt0JVdvrKaYaM5Lh078wGd7PIZkJo8 xwcRtKCfiQxp8l4B3bgUCJXBw6iINzDwsEWHvUtMXVRR8DUkiC6MY4CtUYyJYHeOeI4t 2krQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1686087787; x=1688679787; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=bVp3sxGYYmvDAXqCieOLHVX04weYGZl76ejiM9qiOig=; b=SsVLoVzQr04RXTQqLeaQsvxXy+n0tmPYwSWpLsOv00yYgpp2ihCR2iPevdWfhfUpcz renqdSLGd9NG4zziGqm5616EOfkRNeEOgHeLIl2uMTBWrZl9KyDoXIH+N6hU+wlAqpeD DzuE034H8Rp7YI6vUaQSzlN96qGabGAkVGBPLVCNEwBi31Jwrc//WtPZZKjwmapCRwH3 3nIJqtLGmxy9Wo+oLE+maNn7HTNPsz1rXUyhhJLWYHo0BwghNY8NNnvEIPJBS9M2rBNA 59l29fyUijOGtX63ri9UkcEHyI/TvNUxriSBwgdfrDZUE+9kT/uyaeLBwZ3RB8NEgLPY J/9g== X-Gm-Message-State: AC+VfDxMk6K7sUcLmVZkRa3Yg4AIF/4oU+HNmXzDQGC2BSduhSa13l2W /nG3OCFb5UusFVOSLgDeeTPnphtO+FK6i9yh X-Google-Smtp-Source: ACHHUZ6HTjhIseQC+YX/8i7KuQIZNvRMZxqXKIURAQEx6g1gRz8rkAFe31oux7Yb1V6BKUW61mc4yw== X-Received: by 2002:a05:6a21:9101:b0:103:73a6:5cc1 with SMTP id tn1-20020a056a21910100b0010373a65cc1mr763646pzb.4.1686087787031; Tue, 06 Jun 2023 14:43:07 -0700 (PDT) Received: from localhost ([87.118.116.103]) by smtp.gmail.com with ESMTPSA id z9-20020a170902834900b001b0142908f7sm8880294pln.291.2023.06.06.14.43.05 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 06 Jun 2023 14:43:06 -0700 (PDT) From: Maxim Mikityanskiy To: bpf@vger.kernel.org Cc: netdev@vger.kernel.org, linux-kselftest@vger.kernel.org, Daniel Borkmann , John Fastabend , Alexei Starovoitov , Andrii Nakryiko , Martin KaFai Lau , Eduard Zingerman , Maxim Mikityanskiy , Song Liu , Yonghong Song , KP Singh , Stanislav Fomichev , Hao Luo , Jiri Olsa , Mykola Lysenko , Shuah Khan , "David S. Miller" , Jakub Kicinski , Jesper Dangaard Brouer Subject: [PATCH bpf v3 1/2] bpf: Fix verifier tracking scalars on spill Date: Wed, 7 Jun 2023 00:42:45 +0300 Message-Id: <20230606214246.403579-2-maxtram95@gmail.com> X-Mailer: git-send-email 2.40.1 In-Reply-To: <20230606214246.403579-1-maxtram95@gmail.com> References: <20230606214246.403579-1-maxtram95@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-kselftest@vger.kernel.org From: Maxim Mikityanskiy The following scenario describes a verifier bypass in privileged mode (CAP_BPF or CAP_SYS_ADMIN): 1. Prepare a 32-bit rogue number. 2. Put the rogue number into the upper half of a 64-bit register, and roll a random (unknown to the verifier) bit in the lower half. The rest of the bits should be zero (although variations are possible). 3. Assign an ID to the register by MOVing it to another arbitrary register. 4. Perform a 32-bit spill of the register, then perform a 32-bit fill to another register. Due to a bug in the verifier, the ID will be preserved, although the new register will contain only the lower 32 bits, i.e. all zeros except one random bit. At this point there are two registers with different values but the same ID, which means the integrity of the verifier state has been corrupted. Next steps show the actual bypass: 5. Compare the new 32-bit register with 0. In the branch where it's equal to 0, the verifier will believe that the original 64-bit register is also 0, because it has the same ID, but its actual value still contains the rogue number in the upper half. Some optimizations of the verifier prevent the actual bypass, so extra care is needed: the comparison must be between two registers, and both branches must be reachable (this is why one random bit is needed). Both branches are still suitable for the bypass. 6. Right shift the original register by 32 bits to pop the rogue number. 7. Use the rogue number as an offset with any pointer. The verifier will believe that the offset is 0, while in reality it's the given number. The fix is similar to the 32-bit BPF_MOV handling in check_alu_op for SCALAR_VALUE. If the spill is narrowing the actual register value, don't keep the ID, make sure it's reset to 0. Fixes: 354e8f1970f8 ("bpf: Support <8-byte scalar spill and refill") Signed-off-by: Maxim Mikityanskiy Acked-by: Yonghong Song --- kernel/bpf/verifier.c | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c index 5871aa78d01a..7be23eced561 100644 --- a/kernel/bpf/verifier.c +++ b/kernel/bpf/verifier.c @@ -3856,6 +3856,8 @@ static int check_stack_write_fixed_off(struct bpf_verifier_env *env, mark_stack_slot_scratched(env, spi); if (reg && !(off % BPF_REG_SIZE) && register_is_bounded(reg) && !register_is_null(reg) && env->bpf_capable) { + bool reg_value_fits; + if (dst_reg != BPF_REG_FP) { /* The backtracking logic can only recognize explicit * stack slot address like [fp - 8]. Other spill of @@ -3867,7 +3869,12 @@ static int check_stack_write_fixed_off(struct bpf_verifier_env *env, if (err) return err; } + + reg_value_fits = fls64(reg->umax_value) <= BITS_PER_BYTE * size; save_register_state(state, spi, reg, size); + /* Break the relation on a narrowing spill. */ + if (!reg_value_fits) + state->stack[spi].spilled_ptr.id = 0; } else if (!reg && !(off % BPF_REG_SIZE) && is_bpf_st_mem(insn) && insn->imm != 0 && env->bpf_capable) { struct bpf_reg_state fake_reg = {};