• A
    bpf: Allow variable-offset stack access · 65b36570
    Andrei Matei 提交于
    stable inclusion
    from stable-5.10.33
    commit f3c4b01689d392373301e6e60d1b02c5b4020afc
    bugzilla: 51834
    CVE: NA
    
    --------------------------------
    
    [ Upstream commit 01f810ac ]
    
    Before this patch, variable offset access to the stack was dissalowed
    for regular instructions, but was allowed for "indirect" accesses (i.e.
    helpers). This patch removes the restriction, allowing reading and
    writing to the stack through stack pointers with variable offsets. This
    makes stack-allocated buffers more usable in programs, and brings stack
    pointers closer to other types of pointers.
    
    The motivation is being able to use stack-allocated buffers for data
    manipulation. When the stack size limit is sufficient, allocating
    buffers on the stack is simpler than per-cpu arrays, or other
    alternatives.
    
    In unpriviledged programs, variable-offset reads and writes are
    disallowed (they were already disallowed for the indirect access case)
    because the speculative execution checking code doesn't support them.
    Additionally, when writing through a variable-offset stack pointer, if
    any pointers are in the accessible range, there's possilibities of later
    leaking pointers because the write cannot be tracked precisely.
    
    Writes with variable offset mark the whole range as initialized, even
    though we don't know which stack slots are actually written. This is in
    order to not reject future reads to these slots. Note that this doesn't
    affect writes done through helpers; like before, helpers need the whole
    stack range to be initialized to begin with.
    All the stack slots are in range are considered scalars after the write;
    variable-offset register spills are not tracked.
    
    For reads, all the stack slots in the variable range needs to be
    initialized (but see above about what writes do), otherwise the read is
    rejected. All register spilled in stack slots that might be read are
    marked as having been read, however reads through such pointers don't do
    register filling; the target register will always be either a scalar or
    a constant zero.
    Signed-off-by: NAndrei Matei <andreimatei1@gmail.com>
    Signed-off-by: NAlexei Starovoitov <ast@kernel.org>
    Link: https://lore.kernel.org/bpf/20210207011027.676572-2-andreimatei1@gmail.comSigned-off-by: NSasha Levin <sashal@kernel.org>
    Signed-off-by: NChen Jun <chenjun102@huawei.com>
    Acked-by: NWeilong Chen <chenweilong@huawei.com>
    Signed-off-by: NZheng Zengkai <zhengzengkai@huawei.com>
    65b36570
bpf_verifier.h 16.7 KB