From patchwork Tue Oct 8 04:09:41 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Jeff Xu X-Patchwork-Id: 13825617 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 kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id A5F6CCED263 for ; Tue, 8 Oct 2024 04:09:53 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 1E4A06B0088; Tue, 8 Oct 2024 00:09:53 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id 16DEA6B008A; Tue, 8 Oct 2024 00:09:53 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id EDAE96B0089; Tue, 8 Oct 2024 00:09:52 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0015.hostedemail.com [216.40.44.15]) by kanga.kvack.org (Postfix) with ESMTP id C9A756B0085 for ; Tue, 8 Oct 2024 00:09:52 -0400 (EDT) Received: from smtpin12.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay10.hostedemail.com (Postfix) with ESMTP id 94192C1075 for ; Tue, 8 Oct 2024 04:09:51 +0000 (UTC) X-FDA: 82649106624.12.3D3FA09 Received: from mail-pf1-f181.google.com (mail-pf1-f181.google.com [209.85.210.181]) by imf15.hostedemail.com (Postfix) with ESMTP id 77F4DA0002 for ; Tue, 8 Oct 2024 04:09:50 +0000 (UTC) Authentication-Results: imf15.hostedemail.com; dkim=pass header.d=chromium.org header.s=google header.b=gkpG6L0A; spf=pass (imf15.hostedemail.com: domain of jeffxu@chromium.org designates 209.85.210.181 as permitted sender) smtp.mailfrom=jeffxu@chromium.org; dmarc=pass (policy=none) header.from=chromium.org ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1728360412; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=90wkvuAWekoK3fpE0nIhFuDYwdiSixPtxvMNgDon0sc=; b=7ecdozR9ttS+pcK8W58TIJLZbNT0yFjdMkuy/WiH23a/9lFD4ZypJ6hJ0m0CxFLfo9PDlo KtVWC7BS6/njUXzjGHogplv/qDL2zVYAMYdVhj/eNXaJ0elSubFa0IYoXYFY35CMvmeAhm GBA/y/eGsQXcuM0Cb4kU9A5z3LXv1UA= ARC-Authentication-Results: i=1; imf15.hostedemail.com; dkim=pass header.d=chromium.org header.s=google header.b=gkpG6L0A; spf=pass (imf15.hostedemail.com: domain of jeffxu@chromium.org designates 209.85.210.181 as permitted sender) smtp.mailfrom=jeffxu@chromium.org; dmarc=pass (policy=none) header.from=chromium.org ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1728360412; a=rsa-sha256; cv=none; b=C5n/vw+w+tJ0nFvkksZYO43IpivXVOk+MGmvnqTQJ224T23xPm62PcXJvkAl9t2XU/REL+ yYVPcDMBWSM7OtbODoAhDYAlPTi1BJMHhInzmwixhaRhd28Pbv2oNc634KpDx9hMnylihY EA+o+i9+lXRx1U50WVxe9qGKLNp5W18= Received: by mail-pf1-f181.google.com with SMTP id d2e1a72fcca58-71e018dfb5fso156174b3a.2 for ; Mon, 07 Oct 2024 21:09:50 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; t=1728360589; x=1728965389; darn=kvack.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=90wkvuAWekoK3fpE0nIhFuDYwdiSixPtxvMNgDon0sc=; b=gkpG6L0AemLr6gh19QuyNevj2jYQMC1MNzNnkbJnXVpnXRCAKAKMec4uFeJDxnz/mM 58uGcTbpEJCm9jqkDgirzgm8iup1AxQ7jv3EFz4NWRc+RU+d1QNxcaounHbOotVUzptr fN8h4RooG2HUwdCjXxEFe9Z8fdLgPAiCxREqk= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1728360589; x=1728965389; 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=90wkvuAWekoK3fpE0nIhFuDYwdiSixPtxvMNgDon0sc=; b=mZMOhiz+EzmSGVC00rjO+uUPjZU9xGFGwIg9/3wYWvvzBzQCAqH+U8wLywHGx846Tb Zia3FNvkG7n0Y6BbFtc8Gx1j6dQrhQN+WAiyU5Vdkkgw3OE8ZI0n9sIfK8Z3xayN7pTc 147yJfpo9W+a890mITGTZw8ndz10+Y4X9E1U5ESB8XmhWuK98FosVD/hQjcmh2ODbD3U mXLGU8xCRT3HZYUEXR7+OaYAr5mj5apA0MT/VAOjcFtTSX9GxRh+EzVoq9HFdwNzpQ6f VBUz71s+X7jhABf+XiCfsfZX+EufBeyV2a7jr6ZVLYn7ncQaFSqQkMCK9IiJ1bNlKmrR ZBLA== X-Forwarded-Encrypted: i=1; AJvYcCXRr7GeOz9+XsCL8BDgEu0cNhHpl/Z0FoKsrRoL1rcQA2lJXqvkFRV4EcsocBZ5BPalpH50S2Sy4g==@kvack.org X-Gm-Message-State: AOJu0YyHEQom7pOFo1e+1Af92T+0bOCO65KzUDSK/V9rlnjlLSC1uLvn IdIaM2J8Ur18GIWoeNhhL284TAr3sPfloIDSbr5CeulFDCOWb0JOibHAUnYdjQ== X-Google-Smtp-Source: AGHT+IHhIw2pHBt0h/VID9GWM+euXYVzwxAlVqV/d2tqJ+8lzREcc45zS7z9y+WNZ1KvQ13t8NzDcw== X-Received: by 2002:a05:6a00:218e:b0:71e:1499:7461 with SMTP id d2e1a72fcca58-71e14997515mr361277b3a.4.1728360588868; Mon, 07 Oct 2024 21:09:48 -0700 (PDT) Received: from localhost (56.4.82.34.bc.googleusercontent.com. [34.82.4.56]) by smtp.gmail.com with UTF8SMTPSA id d2e1a72fcca58-71df0d7b80bsm5217370b3a.185.2024.10.07.21.09.48 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Mon, 07 Oct 2024 21:09:48 -0700 (PDT) From: jeffxu@chromium.org To: akpm@linux-foundation.org, keescook@chromium.org, corbet@lwn.net Cc: jorgelo@chromium.org, groeck@chromium.org, linux-kernel@vger.kernel.org, linux-kselftest@vger.kernel.org, linux-mm@kvack.org, jannh@google.com, sroettger@google.com, pedro.falcato@gmail.com, linux-hardening@vger.kernel.org, willy@infradead.org, gregkh@linuxfoundation.org, torvalds@linux-foundation.org, deraadt@openbsd.org, usama.anjum@collabora.com, surenb@google.com, merimus@google.com, rdunlap@infradead.org, lorenzo.stoakes@oracle.com, Liam.Howlett@oracle.com, enh@google.com, Jeff Xu Subject: [PATCH v3 1/1] mseal: update mseal.rst Date: Tue, 8 Oct 2024 04:09:41 +0000 Message-ID: <20241008040942.1478931-2-jeffxu@chromium.org> X-Mailer: git-send-email 2.47.0.rc0.187.ge670bccf7e-goog In-Reply-To: <20241008040942.1478931-1-jeffxu@chromium.org> References: <20241008040942.1478931-1-jeffxu@chromium.org> MIME-Version: 1.0 X-Rspamd-Server: rspam06 X-Rspamd-Queue-Id: 77F4DA0002 X-Stat-Signature: ea3jthens8om3h7mpq6f8isfupxftwa7 X-Rspam-User: X-HE-Tag: 1728360590-44018 X-HE-Meta: U2FsdGVkX1/rbnnvNV7oOzr1JgMp43ne8xDSO8qK8hA9ztcLAp7dYf2b697W/rjM5/BUWKAcD8N3Nbzc+B1zP2ytObRXAo+yDDQb1tT/XLDs8JV+iNPeoWCxmh0Ubys6Kt1MQVEMz8qZMgKKiijVfX8K5ffF9MqA99VkeZoAECuZjK65es1tWje7HXvGEcaLbQhx6xRjWBECm4Llj8yPvQyBCPasKUq/ErerPjG99xsWnS2x0mAcYIhoK2iqSUbAjwl/PeP72gMvOI513mRRYLIgJO8bTzJcre9vsK5Vrwpz35fFlG2LQnOFx2Jwlh/7SrZ3x6U8jIfqK9DZU6lroW+MBNf0JtC2E8vyGMMEWsOfuArdIURoK27ytTC+Z/88DTmhjx0fxTSuhYaRsJnBxk76RXD7uea01jxGNW0RRU89+JleVUoKg53l4SQkarzephe+GA3+iFKg3f9FAybX8JpbpLQIHeApGTAgiGO5Pk+lG2rKmxwP/VStvGAMpXkMN22kfNwRiKwwlhRw6vblXSDnf8P0FWC+8zMG14cn94yS7yGU7iF1Vz11GTFbYRrMAHqbOPYgdJWlhccwXI8r3EcTzOY3qhQCjziUDJJ1ItKQhYxHwmMjHTs3En/wQVqdAJY7jcSDOCJwcKejJPHqxcj3FkrKGpVemO7yoRLxAxOiYtXUHxx+CtpkEoS5q5LgS1jitB2wK0wCTMOIooWclPgbJa3cOP5ktTd8joJFVCz3ovnjwEP1XLZhOENm+q2zjhAHP/8mjOIlpWMqCVmzJu7miQTUJZ8zU8EVXnrcPMmtGo6jvxinRm/nQY/MAfkLmRmOZWanXcA0W/4fRJojFXoqHHpvO/nEbkek2PtlNR6FiLMbGEFp6wSMxudAJwdH4NAFqSVCapBC93fK/q54xKbcuWUWM685yvieltlEe7HvyhHaA4bQsvFF899LERokfriCgsQMec8CI6cnxEv KIHaIbFZ tXlBMtEdGu4cBiPLCUwTV1sZ1ReFpiOiUYzB0wFdua5yA9oYtqzn3XEivBxJ9GSLeTBBfJDELBlecpBOg+Z+P2T76u4qjWd3YVkG8m/+V31kqq3Rd37479CY9JViHMNwEImWyf305LmAY5wNUQqZtPMA74mlYN1nNOzwh8zB0J/0lCutrtJ9sJ37LIE78UxejOJyyaJ47koBFgLTkQLMI+fKGR+R61w2/Kdg3b6Jf2auMqONxJ9BUaZfFa9ImkpmeVZMZrqt1uBiB8uUVTD9urtLQ5OHmmR+yVhX8Ej/snvSuV0BU+08mBcvDgss09gAL0TkC5q0/UEA+ZaVPd5ZfOpxgCMjuJGSQRjjLWo9Zoh5t+diQv7x2foecz6TWYz9dSxUCZbT8P2VyhkMotCyrNgoQtyqImunIVgKNs6zfTCCL0p+w/Ghn2z1CAPlFTnplOLGqUEA+ntNPArPEQCoh4kslhqUaZmKrYcCL5cF7m+aDg7zgVD/4oZdqorEQ+oer+9M+MRtSEHfoPHArwboaXR6rxHGVWWTZS1rDop4VD2HBghIhX7XjBJ9NHjZ8hU0VhfeaBXhy2ZULw/58KxlTrQmrS1rQQ5JX6Mfe X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: From: Jeff Xu Update doc after in-loop change: mprotect/madvise can have partially updated and munmap is atomic. Fix indentation and clarify some sections to improve readability. Signed-off-by: Jeff Xu Fixes: df2a7df9a9aa ("mm/munmap: replace can_modify_mm with can_modify_vma") Fixes: 4a2dd02b0916 ("mm/mprotect: replace can_modify_mm with can_modify_vma") Fixes: 38075679b5f1 ("mm/mremap: replace can_modify_mm with can_modify_vma") Fixes: 23c57d1fa2b9 ("mseal: replace can_modify_mm_madv with a vma variant") Reviewed-by: Randy Dunlap --- Documentation/userspace-api/mseal.rst | 307 +++++++++++++------------- 1 file changed, 148 insertions(+), 159 deletions(-) diff --git a/Documentation/userspace-api/mseal.rst b/Documentation/userspace-api/mseal.rst index 4132eec995a3..41102f74c5e2 100644 --- a/Documentation/userspace-api/mseal.rst +++ b/Documentation/userspace-api/mseal.rst @@ -23,177 +23,166 @@ applications can additionally seal security critical data at runtime. A similar feature already exists in the XNU kernel with the VM_FLAGS_PERMANENT flag [1] and on OpenBSD with the mimmutable syscall [2]. -User API -======== -mseal() ------------ -The mseal() syscall has the following signature: - -``int mseal(void addr, size_t len, unsigned long flags)`` - -**addr/len**: virtual memory address range. - -The address range set by ``addr``/``len`` must meet: - - The start address must be in an allocated VMA. - - The start address must be page aligned. - - The end address (``addr`` + ``len``) must be in an allocated VMA. - - no gap (unallocated memory) between start and end address. - -The ``len`` will be paged aligned implicitly by the kernel. - -**flags**: reserved for future use. - -**return values**: - -- ``0``: Success. - -- ``-EINVAL``: - - Invalid input ``flags``. - - The start address (``addr``) is not page aligned. - - Address range (``addr`` + ``len``) overflow. - -- ``-ENOMEM``: - - The start address (``addr``) is not allocated. - - The end address (``addr`` + ``len``) is not allocated. - - A gap (unallocated memory) between start and end address. - -- ``-EPERM``: - - sealing is supported only on 64-bit CPUs, 32-bit is not supported. - -- For above error cases, users can expect the given memory range is - unmodified, i.e. no partial update. - -- There might be other internal errors/cases not listed here, e.g. - error during merging/splitting VMAs, or the process reaching the max - number of supported VMAs. In those cases, partial updates to the given - memory range could happen. However, those cases should be rare. - -**Blocked operations after sealing**: - Unmapping, moving to another location, and shrinking the size, - via munmap() and mremap(), can leave an empty space, therefore - can be replaced with a VMA with a new set of attributes. - - Moving or expanding a different VMA into the current location, - via mremap(). - - Modifying a VMA via mmap(MAP_FIXED). - - Size expansion, via mremap(), does not appear to pose any - specific risks to sealed VMAs. It is included anyway because - the use case is unclear. In any case, users can rely on - merging to expand a sealed VMA. - - mprotect() and pkey_mprotect(). - - Some destructive madvice() behaviors (e.g. MADV_DONTNEED) - for anonymous memory, when users don't have write permission to the - memory. Those behaviors can alter region contents by discarding pages, - effectively a memset(0) for anonymous memory. - - Kernel will return -EPERM for blocked operations. - - For blocked operations, one can expect the given address is unmodified, - i.e. no partial update. Note, this is different from existing mm - system call behaviors, where partial updates are made till an error is - found and returned to userspace. To give an example: - - Assume following code sequence: - - - ptr = mmap(null, 8192, PROT_NONE); - - munmap(ptr + 4096, 4096); - - ret1 = mprotect(ptr, 8192, PROT_READ); - - mseal(ptr, 4096); - - ret2 = mprotect(ptr, 8192, PROT_NONE); - - ret1 will be -ENOMEM, the page from ptr is updated to PROT_READ. - - ret2 will be -EPERM, the page remains to be PROT_READ. - -**Note**: - -- mseal() only works on 64-bit CPUs, not 32-bit CPU. - -- users can call mseal() multiple times, mseal() on an already sealed memory - is a no-action (not error). - -- munseal() is not supported. - -Use cases: -========== +SYSCALL +======= +mseal syscall signature +----------------------- + ``int mseal(void \* addr, size_t len, unsigned long flags)`` + + **addr**/**len**: virtual memory address range. + The address range set by **addr**/**len** must meet: + - The start address must be in an allocated VMA. + - The start address must be page aligned. + - The end address (**addr** + **len**) must be in an allocated VMA. + - no gap (unallocated memory) between start and end address. + + The ``len`` will be paged aligned implicitly by the kernel. + + **flags**: reserved for future use. + + **Return values**: + - **0**: Success. + - **-EINVAL**: + * Invalid input ``flags``. + * The start address (``addr``) is not page aligned. + * Address range (``addr`` + ``len``) overflow. + - **-ENOMEM**: + * The start address (``addr``) is not allocated. + * The end address (``addr`` + ``len``) is not allocated. + * A gap (unallocated memory) between start and end address. + - **-EPERM**: + * sealing is supported only on 64-bit CPUs, 32-bit is not supported. + + **Note about error return**: + - For above error cases, users can expect the given memory range is + unmodified, i.e. no partial update. + - There might be other internal errors/cases not listed here, e.g. + error during merging/splitting VMAs, or the process reaching the maximum + number of supported VMAs. In those cases, partial updates to the given + memory range could happen. However, those cases should be rare. + + **Architecture support**: + mseal only works on 64-bit CPUs, not 32-bit CPUs. + + **Idempotent**: + users can call mseal multiple times. mseal on an already sealed memory + is a no-action (not error). + + **no munseal** + Once mapping is sealed, it can't be unsealed. The kernel should never + have munseal, this is consistent with other sealing feature, e.g. + F_SEAL_SEAL for file. + +Blocked mm syscall for sealed mapping +------------------------------------- + It might be important to note: **once the mapping is sealed, it will + stay in the process's memory until the process terminates**. + + Example:: + + *ptr = mmap(0, 4096, PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, 0, 0); + rc = mseal(ptr, 4096, 0); + /* munmap will fail */ + rc = munmap(ptr, 4096); + assert(rc < 0); + + Blocked mm syscall: + - munmap + - mmap + - mremap + - mprotect and pkey_mprotect + - some destructive madvise behaviors: MADV_DONTNEED, MADV_FREE, + MADV_DONTNEED_LOCKED, MADV_FREE, MADV_DONTFORK, MADV_WIPEONFORK + + The first set of syscalls to block is munmap, mremap, mmap. They can + either leave an empty space in the address space, therefore allowing + replacement with a new mapping with new set of attributes, or can + overwrite the existing mapping with another mapping. + + mprotect and pkey_mprotect are blocked because they changes the + protection bits (RWX) of the mapping. + + Certain destructive madvise behaviors, specifically MADV_DONTNEED, + MADV_FREE, MADV_DONTNEED_LOCKED, and MADV_WIPEONFORK, can introduce + risks when applied to anonymous memory by threads lacking write + permissions. Consequently, these operations are prohibited under such + conditions. The aforementioned behaviors have the potential to modify + region contents by discarding pages, effectively performing a memset(0) + operation on the anonymous memory. + + Kernel will return -EPERM for blocked syscalls. + + When blocked syscall return -EPERM due to sealing, the memory regions may + or may not be changed, depends on the syscall being blocked: + + - munmap: munmap is atomic. If one of VMAs in the given range is + sealed, none of VMAs are updated. + - mprotect, pkey_mprotect, madvise: partial update might happen, e.g. + when mprotect over multiple VMAs, mprotect might update the beginning + VMAs before reaching the sealed VMA and return -EPERM. + - mmap and mremap: undefined behavior. + +Use cases +========= - glibc: The dynamic linker, during loading ELF executables, can apply sealing to - non-writable memory segments. - -- Chrome browser: protect some security sensitive data-structures. + mapping segments. -Notes on which memory to seal: -============================== +- Chrome browser: protect some security sensitive data structures. -It might be important to note that sealing changes the lifetime of a mapping, -i.e. the sealed mapping won’t be unmapped till the process terminates or the -exec system call is invoked. Applications can apply sealing to any virtual -memory region from userspace, but it is crucial to thoroughly analyze the -mapping's lifetime prior to apply the sealing. +When not to use mseal +===================== +Applications can apply sealing to any virtual memory region from userspace, +but it is *crucial to thoroughly analyze the mapping's lifetime* prior to +apply the sealing. This is because the sealed mapping *won’t be unmapped* +until the process terminates or the exec system call is invoked. For example: + - aio/shm + aio/shm can call mmap and munmap on behalf of userspace, e.g. + ksys_shmdt() in shm.c. The lifetimes of those mapping are not tied to + the lifetime of the process. If those memories are sealed from userspace, + then munmap will fail, causing leaks in VMA address space during the + lifetime of the process. + + - ptr allocated by malloc (heap) + Don't use mseal on the memory ptr return from malloc(). + malloc() is implemented by allocator, e.g. by glibc. Heap manager might + allocate a ptr from brk or mapping created by mmap. + If an app calls mseal on a ptr returned from malloc(), this can affect + the heap manager's ability to manage the mappings; the outcome is + non-deterministic. + + Example:: + + ptr = malloc(size); + /* don't call mseal on ptr return from malloc. */ + mseal(ptr, size); + /* free will success, allocator can't shrink heap lower than ptr */ + free(ptr); + +mseal doesn't block +=================== +In a nutshell, mseal blocks certain mm syscall from modifying some of VMA's +attributes, such as protection bits (RWX). Sealed mappings doesn't mean the +memory is immutable. -- aio/shm - - aio/shm can call mmap()/munmap() on behalf of userspace, e.g. ksys_shmdt() in - shm.c. The lifetime of those mapping are not tied to the lifetime of the - process. If those memories are sealed from userspace, then munmap() will fail, - causing leaks in VMA address space during the lifetime of the process. - -- Brk (heap) - - Currently, userspace applications can seal parts of the heap by calling - malloc() and mseal(). - let's assume following calls from user space: - - - ptr = malloc(size); - - mprotect(ptr, size, RO); - - mseal(ptr, size); - - free(ptr); - - Technically, before mseal() is added, the user can change the protection of - the heap by calling mprotect(RO). As long as the user changes the protection - back to RW before free(), the memory range can be reused. - - Adding mseal() into the picture, however, the heap is then sealed partially, - the user can still free it, but the memory remains to be RO. If the address - is re-used by the heap manager for another malloc, the process might crash - soon after. Therefore, it is important not to apply sealing to any memory - that might get recycled. - - Furthermore, even if the application never calls the free() for the ptr, - the heap manager may invoke the brk system call to shrink the size of the - heap. In the kernel, the brk-shrink will call munmap(). Consequently, - depending on the location of the ptr, the outcome of brk-shrink is - nondeterministic. - - -Additional notes: -================= As Jann Horn pointed out in [3], there are still a few ways to write -to RO memory, which is, in a way, by design. Those cases are not covered -by mseal(). If applications want to block such cases, sandbox tools (such as -seccomp, LSM, etc) might be considered. +to RO memory, which is, in a way, by design. And those could be blocked +by different security measures. Those cases are: -- Write to read-only memory through /proc/self/mem interface. -- Write to read-only memory through ptrace (such as PTRACE_POKETEXT). -- userfaultfd. + - Write to read-only memory through /proc/self/mem interface (FOLL_FORCE). + - Write to read-only memory through ptrace (such as PTRACE_POKETEXT). + - userfaultfd. The idea that inspired this patch comes from Stephen Röttger’s work in V8 CFI [4]. Chrome browser in ChromeOS will be the first user of this API. -Reference: -========== -[1] https://github.com/apple-oss-distributions/xnu/blob/1031c584a5e37aff177559b9f69dbd3c8c3fd30a/osfmk/mach/vm_statistics.h#L274 - -[2] https://man.openbsd.org/mimmutable.2 - -[3] https://lore.kernel.org/lkml/CAG48ez3ShUYey+ZAFsU2i1RpQn0a5eOs2hzQ426FkcgnfUGLvA@mail.gmail.com - -[4] https://docs.google.com/document/d/1O2jwK4dxI3nRcOJuPYkonhTkNQfbmwdvxQMyXgeaRHo/edit#heading=h.bvaojj9fu6hc +Reference +========= +- [1] https://github.com/apple-oss-distributions/xnu/blob/1031c584a5e37aff177559b9f69dbd3c8c3fd30a/osfmk/mach/vm_statistics.h#L274 +- [2] https://man.openbsd.org/mimmutable.2 +- [3] https://lore.kernel.org/lkml/CAG48ez3ShUYey+ZAFsU2i1RpQn0a5eOs2hzQ426FkcgnfUGLvA@mail.gmail.com +- [4] https://docs.google.com/document/d/1O2jwK4dxI3nRcOJuPYkonhTkNQfbmwdvxQMyXgeaRHo/edit#heading=h.bvaojj9fu6hc