Skip to contentSkip to conversation

Implement Trampoline File Descriptor

RFC PATCH Superseded [email protected] 11 participants 55 messages Sep 16, 2020 – Oct 3, 2020 1 message not in the archive

Subsystems (9)
Arm (32-bit) x86 VFS arm64 +5 more subsystems
lore
Share & tools
lore

A message that is not in the archive (sent off-list or not yet received): 210d7cd762d5307c2aa1676705b392bd445f1baa

#1 lore raw

v2 cover Implement Trampoline File Descriptor

From: "Madhavan T. Venkataraman" <[email protected]>

Introduction
============

Dynamic code is used in many different user applications. Dynamic code is often generated at runtime. Dynamic code can also just be a pre-defined sequence of machine instructions in a data buffer. Examples of dynamic code are trampolines, JIT code, DBT code, etc.

Dynamic code is placed either in a data page or in a stack page. In order to execute dynamic code, the page it resides in needs to be mapped with execute permissions. Writable pages with execute permissions provide an attack surface for hackers. Attackers can use this to inject malicious code, modify existing code or do other harm.

To mitigate this, LSMs such as SELinux implement W^X. That is, they may not allow pages to have both write and execute permissions. This prevents dynamic code from executing and blocks applications that use it. To allow genuine applications to run, exceptions have to be made for them (by setting execmem, etc) which opens the door to security issues.

The W^X implementation today is not complete. There exist many user level tricks that can be used to load and execute dynamic code. E.g.,

- Load the code into a file and map the file with R-X.

- Load the code in an RW- page. Change the permissions to R--. Then, change the permissions to R-X.

- Load the code in an RW- page. Remap the page with R-X to get a separate mapping to the same underlying physical page.

IMO, these are all security holes as an attacker can exploit them to inject his own code.

In the future, these holes will definitely be closed. For instance, LSMs (such as the IPE proposal [1]) may only allow code in properly signed object files to be mapped with execute permissions. This will do two things:

- user level tricks using anonymous pages will fail as anonymous pages have no file identity

- loading the code in a temporary file and mapping it with R-X will fail as the temporary file would not have a signature

We need a way to execute such code without making security exceptions. Trampolines are a good example of dynamic code. A couple of examples of trampolines are given below. My first use case for this RFC is libffi.

Examples of trampolines
=======================

libffi (A Portable Foreign Function Interface Library):

libffi allows a user to define functions with an arbitrary list of arguments and return value through a feature called "Closures". Closures use trampolines to jump to ABI handlers that handle calling conventions and call a target function. libffi is used by a lot of different applications. To name a few:

- Python
- Java
- Javascript
- Ruby FFI
- Lisp
- Objective C

GCC nested functions:

GCC has traditionally used trampolines for implementing nested functions. The trampoline is placed on the user stack. So, the stack needs to be executable.

Currently available solution
============================

One solution that has been proposed to allow trampolines to be executed without making security exceptions is Trampoline Emulation. See:

https://pax.grsecurity.net/docs/emutramp.txt

In this solution, the kernel recognizes certain sequences of instructions as "well-known" trampolines. When such a trampoline is executed, a page fault happens because the trampoline page does not have execute permission. The kernel recognizes the trampoline and emulates it. Basically, the kernel does the work of the trampoline on behalf of the application.

Currently, the emulated trampolines are the ones used in libffi and GCC nested functions. To my knowledge, only X86 is supported at this time.

As noted in emutramp.txt, this is not a generic solution. For every new trampoline that needs to be supported, new instruction sequences need to be recognized by the kernel and emulated. And this has to be done for every architecture that needs to be supported.

emutramp.txt notes the following:

"... the real solution is not in emulation but by designing a kernel API for runtime code generation and modifying userland to make use of it."

Solution proposed in this RFC
=============================

From this RFC's perspective, there are two scenarios for dynamic code:

Scenario 1
----------

We know what code we need only at runtime. For instance, JIT code generated for frequently executed Java methods. Only at runtime do we know what methods need to be JIT compiled. Such code cannot be statically defined. It has to be generated at runtime.

Scenario 2
----------

We know what code we need in advance. User trampolines are a good example of this. It is possible to define such code statically with some help from the kernel.

This RFC addresses (2). (1) needs a general purpose trusted code generator and is out of scope for this RFC.

For (2), the solution is to convert dynamic code to static code and place it in a source file. The binary generated from the source can be signed. The kernel can use signature verification to authenticate the binary and allow the code to be mapped and executed.

The problem is that the static code has to be able to find the data that it needs when it executes. For functions, the ABI defines the way to pass parameters. But, for arbitrary dynamic code, there isn't a standard ABI compliant way to pass data to the code for most architectures. Each instance of dynamic code defines its own way. For instance, co-location of code and data and PC-relative data referencing are used in cases where the ISA supports it.

We need one standard way that would work for all architectures and ABIs.

The solution proposed here is:

1. Write the static code assuming that the data needed by the code is already pointed to by a designated register.

2. Get the kernel to supply a small universal trampoline that does the following:

- Load the address of the data in a designated register
- Load the address of the static code in a designated register
- Jump to the static code

User code would use a kernel supplied API to create and map the trampoline. The address values would be baked into the code so that no special ISA features are needed.

To conserve memory, the kernel will pack as many trampolines as possible in a page and provide a trampoline table to user code. The table itself is managed by the user.

Trampoline File Descriptor (trampfd)
==========================

I am proposing a kernel API using anonymous file descriptors that can be used to create the trampolines. The API is described in patch 1/4 of this patchset. I provide a summary here:

- Create a trampoline file object

- Write a code descriptor into the trampoline file and specify:

- the number of trampolines desired
- the name of the code register
- user pointer to a table of code addresses, one address per trampoline

- Write a data descriptor into the trampoline file and specify:

- the name of the data register
- user pointer to a table of data addresses, one address per trampoline

- mmap() the trampoline file. The kernel generates a table of trampolines in a page and returns the trampoline table address

- munmap() a trampoline file mapping

- Close the trampoline file

Each mmap() will only map a single base page. Large pages are not supported.

A trampoline file can only be mapped once in an address space.

Trampoline file mappings cannot be shared across address spaces. So, sending the trampoline file descriptor over a unix domain socket and mapping it in another process will not work.

It is recommended that the code descriptor and the code table be placed in the .rodata section so an attacker cannot modify them.

Trampoline use and reuse
========================

The code for trampoline X in the trampoline table is:

load &code_table[X], code_reg
load (code_reg), code_reg
load &data_table[X], data_reg
load (data_reg), data_reg
jump code_reg

The addresses &code_table[X] and &data_table[X] are baked into the trampoline code. So, PC-relative data references are not needed. The user can modify code_table[X] and data_table[X] dynamically.

For instance, within libffi, the same trampoline X can be used for different closures at different times by setting:

	data_table[X] = closure;
	code_table[X] = ABI handling code;

Advantages of the Trampoline File Descriptor approach
=====================================================

- Using this support from the kernel, dynamic code can be converted to static code with a little effort so applications and libraries can move to a more secure model. In the simplest cases such as libffi, dynamic code can even be eliminated.

- This initial work is targeted towards X86 and ARM. But it can be supported easily on all architectures. We don't need any special ISA features such as PC-relative data referencing.

- The only code generation needed is for this small, universal trampoline.

- The kernel does not have to deal with any ABI issues in the generation of this trampoline.

- The kernel provides a trampoline table to conserve memory.

- An SELinux setting called "exectramp" can be implemented along the lines of "execmem", "execstack" and "execheap" to selectively allow the use of trampolines on a per application basis.

- In version 1, a trip to the kernel was required to execute the trampoline. In version 2, that is not required. So, there are no performance concerns in this approach.

libffi
======

I have implemented my solution for libffi and provided the changes for X86 and ARM, 32-bit and 64-bit. Here is the reference patch:

http://linux.microsoft.com/~madvenka/libffi/libffi.v2.txt

If the trampfd patchset gets accepted, I will send the libffi changes to the maintainers for a review. BTW, I have also successfully executed the libffi self tests.

Work that is pending
====================

- I am working on implementing the SELinux setting - "exectramp".

- I have a test program to test the kernel API. I am working on adding it to selftests.

References
==========

[1] https://microsoft.github.io/ipe/
---

Changelog:

v1
Introduced the Trampfd feature.

v2
- Changed the system call. Version 2 does not support different trampoline types and their associated type structures. It only supports a kernel generated trampoline.

The system call now returns information to the user that is used to define trampoline descriptors. E.g., the maximum number of trampolines that can be packed in a single page.

- Removed all the trampoline contexts such as register contexts and stack contexts. This is based on the feedback that the kernel should not have to worry about ABI issues and H/W features that may deal with the context of a process.

- Removed the need to make a trip into the kernel on trampoline invocation. This is based on the feedback about performance.

- Removed the ability to share trampolines across address spaces. This would have made sense to different trampoline types based on their semantics. But since I support only one specific trampoline, sharing does not make sense.

- Added calls to specify trampoline descriptors that the kernel uses to generate trampolines.

- Added architecture-specific code to generate the small, universal trampoline for X86 32 and 64-bit, ARM 32 and 64-bit.

- Implemented the trampoline table in a page.
Madhavan T. Venkataraman (4):
Implement the kernel API for the trampoline file descriptor. Implement i386 and X86 support for the trampoline file descriptor. Implement ARM64 support for the trampoline file descriptor. Implement ARM support for the trampoline file descriptor.

 arch/arm/include/uapi/asm/ptrace.h     |  21 +++
 arch/arm/kernel/Makefile               |   1 +
 arch/arm/kernel/trampfd.c              | 124 +++++++++++++
 arch/arm/tools/syscall.tbl             |   1 +
 arch/arm64/include/asm/unistd.h        |   2 +-
 arch/arm64/include/asm/unistd32.h      |   2 +
 arch/arm64/include/uapi/asm/ptrace.h   |  59 ++++++
 arch/arm64/kernel/Makefile             |   2 +
 arch/arm64/kernel/trampfd.c            | 244 +++++++++++++++++++++++++
 arch/x86/entry/syscalls/syscall_32.tbl |   1 +
 arch/x86/entry/syscalls/syscall_64.tbl |   1 +
 arch/x86/include/uapi/asm/ptrace.h     |  38 ++++
 arch/x86/kernel/Makefile               |   1 +
 arch/x86/kernel/trampfd.c              | 238 ++++++++++++++++++++++++
 fs/Makefile                            |   1 +
 fs/trampfd/Makefile                    |   5 +
 fs/trampfd/trampfd_fops.c              | 241 ++++++++++++++++++++++++
 fs/trampfd/trampfd_map.c               | 142 ++++++++++++++
 include/linux/syscalls.h               |   2 +
 include/linux/trampfd.h                |  49 +++++
 include/uapi/asm-generic/unistd.h      |   4 +-
 include/uapi/linux/trampfd.h           | 184 +++++++++++++++++++
 init/Kconfig                           |   7 +
 kernel/sys_ni.c                        |   3 +
 24 files changed, 1371 insertions(+), 2 deletions(-)
 create mode 100644 arch/arm/kernel/trampfd.c
 create mode 100644 arch/arm64/kernel/trampfd.c
 create mode 100644 arch/x86/kernel/trampfd.c
 create mode 100644 fs/trampfd/Makefile
 create mode 100644 fs/trampfd/trampfd_fops.c
 create mode 100644 fs/trampfd/trampfd_map.c
 create mode 100644 include/linux/trampfd.h
 create mode 100644 include/uapi/linux/trampfd.h
Signature · 1 line
2.17.1
#2 lore raw

RFC PATCH v2 1/4 fs/trampfd: Implement the trampoline file descriptor API

From: "Madhavan T. Venkataraman" <[email protected]>

Introduction
============

Dynamic code is used in many different user applications. Dynamic code is often generated at runtime. Dynamic code can also just be a pre-defined sequence of machine instructions in a data buffer. Examples of dynamic code are trampolines, JIT code, DBT code, etc.

Dynamic code is placed either in a data page or in a stack page. In order to execute dynamic code, the page it resides in needs to be mapped with execute permissions. Writable pages with execute permissions provide an attack surface for hackers. Attackers can use this to inject malicious code, modify existing code or do other harm.

To mitigate this, LSMs such as SELinux implement W^X. That is, they may not allow pages to have both write and execute permissions. This prevents dynamic code from executing and blocks applications that use it. To allow genuine applications to run, exceptions have to be made for them (by setting execmem, etc) which opens the door to security issues.

The W^X implementation today is not complete. There exist many user level tricks that can be used to load and execute dynamic code. E.g.,

- Load the code into a file and map the file with R-X.

- Load the code in an RW- page. Change the permissions to R--. Then, change the permissions to R-X.

- Load the code in an RW- page. Remap the page with R-X to get a separate mapping to the same underlying physical page.

IMO, these are all security holes as an attacker can exploit them to inject his own code.

In the future, these holes will definitely be closed. For instance, LSMs (such as the IPE proposal [1]) may only allow code in properly signed object files to be mapped with execute permissions. This will do two things:

- user level tricks using anonymous pages will fail as anonymous pages have no file identity

- loading the code in a temporary file and mapping it with R-X will fail as the temporary file would not have a signature

We need a way to execute such code without making security exceptions. Trampolines are a good example of dynamic code. A couple of examples of trampolines are given below. My first use case for this RFC is libffi.

Solution
========

The solution is to convert dynamic code to static code and place it in a source file. The binary generated from the source can be signed. The kernel can use signature verification to authenticate the binary and allow the code to be mapped and executed.

The problem is that the static code has to be able to find the data that it needs when it executes. For functions, the ABI defines the way to pass parameters. But, for arbitrary dynamic code, there isn't a standard ABI compliant way to pass data to the code for most architectures. Each instance of dynamic code defines its own way. For instance, co-location of code and data and PC-relative data referencing are used in cases where the ISA supports it.

We need one standard way that would work for all architectures and ABIs.

The solution has two parts:

1. The maintainer of the code writes the static code assuming that the data needed by the code is already pointed to by a designated register.

2. The kernel supplies a small universal trampoline that does the following:

- Load the address of the data in a designated register
- Load the address of the static code in a designated register
- Jump to the static code

User code would use a kernel supplied API to create and map the trampoline. The address values would be baked into the code so that no special ISA features are needed.

To conserve memory, the kernel will pack as many trampolines as possible in a page and provide a trampoline table to user code. The table itself is managed by the user.

Kernel API
==========

A kernel API based on anonymous file descriptors is defined to create trampolines. The following sections describe the API.

Create trampfd
==============

This feature introduces a new trampfd system call.

	struct trampfd_info	info;
	int			trampfd;

	trampfd = syscall(440, &info);

The kernel creates a trampoline file object and returns the following items in info:

ntrampolines
The number of trampolines that can be created with one trampfd. The user may create fewer trampolines if he wishes.

code_size
The size of each trampoline.

code_offset
The file offset to be used in mmap() to map the trampoline code.

Initialize trampfd
==================

A trampfd is initialized in this manner:

	struct trampfd_code	code;
	struct trampfd_data	data;

	/*
	 * Code descriptor.
	 */
	code.ntrampolines = number of desired trampolines;
	code.reg = code register name;
	code.table = array of code addresses

	/*
	 * Data descriptor.
	 */
	data.reg = data register name;
	data.table = array of data addresses

	pwrite(trampfd, &code, sizeof(init), TRAMPFD_CODE);
	pwrite(trampfd, &data, sizeof(init), TRAMPFD_DATA);

The register names are defined in ptrace.h (reg_32_name and reg_64_name).

It is recommended that the code descriptor and code array be placed in the .rodata section so that an attacker cannot modify its contents.

Instead of pwrite(), the user can also do lseek() and write().

Map trampfd
===========

The user uses mmap() to map the trampoline table into user address space.

	len = info.code_size * code.ntrampolines;
	prot = PROT_READ | PROT_EXEC;
	flags = MAP_PRIVATE;
	offset = info.code_offset;

	trampoline_table = mmap(NULL, len, prot, flags, trampfd, offset);

The kernel generates the trampoline table. The code for trampoline X in the table is:

load &code_table[X], code_reg
load (code_reg), code_reg
load &data_table[X], data_reg
load (data_reg), data_reg
jump code_reg

Each mmap() will only map a single base page. Large pages are not supported.

A trampoline file can only be mmapped once in an address space.

Trampoline file mappings cannot be shared across address spaces. So, sending the trampoline file descriptor over a unix domain socket and mapping it in another process will not work.

The trampoline code is generated with &code_table[X] and &data_table[X] hard coded in it. But code_table[X] and data_table[X] can be modified by user code dynamically so supply the code and data to trampoline X.

Trampoline table management
===========================

The user manages the trampoline table. The address of trampoline X is:

	trampoline_table + info.code_size * X;

Prior to invoking trampoline X, the user must initialize code_table[X] and data_table[X].

Unmap trampfd
=============

Once the user is done with the trampoline table, it may be unmapped:

	len = info.code_size * code.ntrampolines;
	munmap(trampoline_table, len);

Remove trampfd
==============

To remove the trampfd:

	close(trampfd);
---
 fs/Makefile                       |   1 +
 fs/trampfd/Makefile               |   5 +
 fs/trampfd/trampfd_fops.c         | 241 ++++++++++++++++++++++++++++++
 fs/trampfd/trampfd_map.c          | 142 ++++++++++++++++++
 include/linux/syscalls.h          |   2 +
 include/linux/trampfd.h           |  49 ++++++
 include/uapi/asm-generic/unistd.h |   4 +-
 include/uapi/linux/trampfd.h      | 184 +++++++++++++++++++++++
 init/Kconfig                      |   7 +
 kernel/sys_ni.c                   |   3 +
 10 files changed, 637 insertions(+), 1 deletion(-)
 create mode 100644 fs/trampfd/Makefile
 create mode 100644 fs/trampfd/trampfd_fops.c
 create mode 100644 fs/trampfd/trampfd_map.c
 create mode 100644 include/linux/trampfd.h
 create mode 100644 include/uapi/linux/trampfd.h
fs/Makefile +1 -0
index 2ce5112b02c8..227761302000 100644
@@ -136,3 +136,4 @@ obj-$(CONFIG_EFIVAR_FS)		+= efivarfs/
 obj-$(CONFIG_EROFS_FS)		+= erofs/
 obj-$(CONFIG_VBOXSF_FS)		+= vboxsf/
 obj-$(CONFIG_ZONEFS_FS)		+= zonefs/
+obj-$(CONFIG_TRAMPFD)		+= trampfd/
fs/trampfd/Makefile new file +5 -0
new file mode 100644
index 000000000000..ae09a0b1f841
@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: GPL-2.0
+
+obj-$(CONFIG_TRAMPFD) += trampfd.o
+
+trampfd-y += trampfd_fops.o trampfd_map.o
fs/trampfd/trampfd_fops.c new file +241 -0

241 lines not on this page · raw message

fs/trampfd/trampfd_map.c new file +142 -0

142 lines not on this page · raw message

include/linux/syscalls.h +2 -0
index b951a87da987..91f55ff3cdac 100644
@@ -69,6 +69,7 @@ union bpf_attr;
 struct io_uring_params;
 struct clone_args;
 struct open_how;
+struct trampfd_info;
 
 #include <linux/types.h>
 #include <linux/aio_abi.h>
@@ -1005,6 +1006,7 @@ asmlinkage long sys_pidfd_send_signal(int pidfd, int sig,
 				       siginfo_t __user *info,
 				       unsigned int flags);
 asmlinkage long sys_pidfd_getfd(int pidfd, int fd, unsigned int flags);
+asmlinkage long sys_trampfd(struct trampfd_info *info);
 
 /*
  * Architecture-specific system calls
include/linux/trampfd.h new file +49 -0

49 lines not on this page · raw message

include/uapi/asm-generic/unistd.h +3 -1
index f4a01305d9a6..3b1ad4b75c7a 100644
@@ -857,9 +857,11 @@ __SYSCALL(__NR_openat2, sys_openat2)
 __SYSCALL(__NR_pidfd_getfd, sys_pidfd_getfd)
 #define __NR_faccessat2 439
 __SYSCALL(__NR_faccessat2, sys_faccessat2)
+#define __NR_trampfd 440
+__SYSCALL(__NR_trampfd, sys_trampfd)
 
 #undef __NR_syscalls
-#define __NR_syscalls 440
+#define __NR_syscalls 441
 
 /*
  * 32 bit systems traditionally used different
include/uapi/linux/trampfd.h new file +184 -0

184 lines not on this page · raw message

init/Kconfig +7 -0
index 0498af567f70..bb3ecca5b8e7 100644
@@ -2313,3 +2313,10 @@ config ARCH_HAS_SYNC_CORE_BEFORE_USERMODE
 # <asm/syscall_wrapper.h>.
 config ARCH_HAS_SYSCALL_WRAPPER
 	def_bool n
+
+config TRAMPFD
+	bool "Enable trampfd() system call"
+	depends on MMU
+	help
+	  Enable the trampfd() system call that allows a process to map
+	  kernel generated trampolines within its address space.
kernel/sys_ni.c +3 -0
index 3b69a560a7ac..93c5972aba85 100644
@@ -349,6 +349,9 @@ COND_SYSCALL(pkey_mprotect);
 COND_SYSCALL(pkey_alloc);
 COND_SYSCALL(pkey_free);
 
+/* Trampoline fd */
+COND_SYSCALL(trampfd);
+
 
 /*
  * Architecture specific weak syscall entries.
Signature · 1 line
2.17.1
#3 lore raw

RFC PATCH v2 2/4 x86/trampfd: Provide support for the trampoline file descriptor

In reply to [email protected]

From: "Madhavan T. Venkataraman" <[email protected]>

- Define architecture specific register names
- Architecture specific functions for:
- system call init
- code descriptor check
- data descriptor check
- Fill a page with a trampoline table for:
- 32-bit user process
- 64-bit user process

---
 arch/x86/entry/syscalls/syscall_32.tbl |   1 +
 arch/x86/entry/syscalls/syscall_64.tbl |   1 +
 arch/x86/include/uapi/asm/ptrace.h     |  38 ++++
 arch/x86/kernel/Makefile               |   1 +
 arch/x86/kernel/trampfd.c              | 238 +++++++++++++++++++++++++
 5 files changed, 279 insertions(+)
 create mode 100644 arch/x86/kernel/trampfd.c
arch/x86/entry/syscalls/syscall_32.tbl +1 -0
index d8f8a1a69ed1..d4f17806c9ab 100644
@@ -443,3 +443,4 @@
 437	i386	openat2			sys_openat2
 438	i386	pidfd_getfd		sys_pidfd_getfd
 439	i386	faccessat2		sys_faccessat2
+440	i386	trampfd			sys_trampfd
arch/x86/entry/syscalls/syscall_64.tbl +1 -0
index 78847b32e137..91b37bc4b6f0 100644
@@ -360,6 +360,7 @@
 437	common	openat2			sys_openat2
 438	common	pidfd_getfd		sys_pidfd_getfd
 439	common	faccessat2		sys_faccessat2
+440	common	trampfd			sys_trampfd
 
 #
 # x32-specific system call numbers start at 512 to avoid cache impact
arch/x86/include/uapi/asm/ptrace.h +38 -0
index 85165c0edafc..b4be362929b3 100644
@@ -9,6 +9,44 @@
 
 #ifndef __ASSEMBLY__
 
+/*
+ * These register names are to be used by 32-bit applications.
+ */
+enum reg_32_name {
+	x32_min = 0,
+	x32_eax = x32_min,
+	x32_ebx,
+	x32_ecx,
+	x32_edx,
+	x32_esi,
+	x32_edi,
+	x32_ebp,
+	x32_max,
+};
+
+/*
+ * These register names are to be used by 64-bit applications.
+ */
+enum reg_64_name {
+	x64_min = x32_max,
+	x64_rax = x64_min,
+	x64_rbx,
+	x64_rcx,
+	x64_rdx,
+	x64_rsi,
+	x64_rdi,
+	x64_rbp,
+	x64_r8,
+	x64_r9,
+	x64_r10,
+	x64_r11,
+	x64_r12,
+	x64_r13,
+	x64_r14,
+	x64_r15,
+	x64_max,
+};
+
 #ifdef __i386__
 /* this struct defines the way the registers are stored on the
    stack during a system call. */
arch/x86/kernel/Makefile +1 -0
index e77261db2391..feb7f4f311fd 100644
@@ -157,3 +157,4 @@ ifeq ($(CONFIG_X86_64),y)
 endif
 
 obj-$(CONFIG_IMA_SECURE_AND_OR_TRUSTED_BOOT)	+= ima_arch.o
+obj-$(CONFIG_TRAMPFD)				+= trampfd.o
arch/x86/kernel/trampfd.c new file +238 -0

238 lines not on this page · raw message

Signature · 1 line
2.17.1
#4 lore raw

Re: [PATCH v2 2/4] [RFC] x86/trampfd: Provide support for the trampoline file descriptor

[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch]

Hi,

[FYI, it's a private test report for your RFC patch.]
[auto build test WARNING on arm64/for-next/core]
[also build test WARNING on arm/for-next tip/x86/core linus/master v5.9-rc5] [cannot apply to next-20200916]
[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]

url:    https://github.com/0day-ci/linux/commits/madvenka-linux-microsoft-com/Implement-Trampoline-File-Descriptor/20200917-023228
base:   https://git.kernel.org/pub/scm/linux/kernel/git/arm64/linux.git for-next/core
config: x86_64-allyesconfig (attached as .config)
compiler: gcc-9 (Debian 9.3.0-15) 9.3.0
reproduce (this is a W=1 build):
        # save the attached .config to linux build tree
        make W=1 ARCH=x86_64 

If you fix the issue, kindly add following tag as appropriate

All warnings (new ones prefixed by >>):

>> arch/x86/kernel/trampfd.c:25:6: warning: no previous prototype for 'trampfd_arch' [-Wmissing-prototypes]
      25 | void trampfd_arch(struct trampfd_info *info)
         |      ^~~~~~~~~~~~
>> arch/x86/kernel/trampfd.c:39:5: warning: no previous prototype for 'trampfd_code_arch' [-Wmissing-prototypes]
      39 | int trampfd_code_arch(struct trampfd_code *code)
         |     ^~~~~~~~~~~~~~~~~
>> arch/x86/kernel/trampfd.c:65:5: warning: no previous prototype for 'trampfd_data_arch' [-Wmissing-prototypes]
      65 | int trampfd_data_arch(struct trampfd_data *data)
         |     ^~~~~~~~~~~~~~~~~
>> arch/x86/kernel/trampfd.c:232:6: warning: no previous prototype for 'trampfd_code_fill' [-Wmissing-prototypes]

232 | void trampfd_code_fill(struct trampfd *trampfd, char *addr)
| ^~~~~~~~~~~~~~~~~

# https://github.com/0day-ci/linux/commit/39793e95da2e549df500290870cd5eea767f66ff
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review madvenka-linux-microsoft-com/Implement-Trampoline-File-Descriptor/20200917-023228 git checkout 39793e95da2e549df500290870cd5eea767f66ff
vim +/trampfd_arch +25 arch/x86/kernel/trampfd.c

    21	
    22	/*
    23	 * trampfd syscall.
    24	 */
  > 25	void trampfd_arch(struct trampfd_info *info)
    26	{
    27		if (is_compat())
    28			info->code_size = TRAMPFD_CODE_32_SIZE;
    29		else
    30			info->code_size = TRAMPFD_CODE_64_SIZE;
    31		info->ntrampolines = PAGE_SIZE / info->code_size;
    32		info->code_offset = TRAMPFD_CODE_PGOFF << PAGE_SHIFT;
    33		info->reserved = 0;
    34	}
    35	
    36	/*
    37	 * trampfd code descriptor check.
    38	 */
  > 39	int trampfd_code_arch(struct trampfd_code *code)
    40	{
    41		int	ntrampolines;
    42		int	min, max;
    43	
    44		if (is_compat()) {
    45			min = x32_min;
    46			max = x32_max;
    47			ntrampolines = PAGE_SIZE / TRAMPFD_CODE_32_SIZE;
    48		} else {
    49			min = x64_min;
    50			max = x64_max;
    51			ntrampolines = PAGE_SIZE / TRAMPFD_CODE_64_SIZE;
    52		}
    53	
    54		if (code->reg < min || code->reg >= max)
    55			return -EINVAL;
    56	
    57		if (!code->ntrampolines || code->ntrampolines > ntrampolines)
    58			return -EINVAL;
    59		return 0;
    60	}
    61	
    62	/*
    63	 * trampfd data descriptor check.
    64	 */
  > 65	int trampfd_data_arch(struct trampfd_data *data)
    66	{
    67		int	min, max;
    68	
    69		if (is_compat()) {
    70			min = x32_min;
    71			max = x32_max;
    72		} else {
    73			min = x64_min;
    74			max = x64_max;
    75		}
    76	
    77		if (data->reg < min || data->reg >= max)
    78			return -EINVAL;
    79		return 0;
    80	}
    81	

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org

#5 lore raw

Re: [PATCH v2 2/4] [RFC] x86/trampfd: Provide support for the trampoline file descriptor

In reply to [email protected]
[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch]

Hi,

[FYI, it's a private test report for your RFC patch.]
[auto build test WARNING on arm64/for-next/core]
[also build test WARNING on arm/for-next linus/master v5.9-rc5] [cannot apply to next-20200916]
[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]

url:    https://github.com/0day-ci/linux/commits/madvenka-linux-microsoft-com/Implement-Trampoline-File-Descriptor/20200917-023228
base:   https://git.kernel.org/pub/scm/linux/kernel/git/arm64/linux.git for-next/core
config: s390-randconfig-r022-20200916 (attached as .config)
compiler: clang version 12.0.0 (https://github.com/llvm/llvm-project 1321160a26e7e489baf9b10d6de90a342f898960)

reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# install s390 cross compiling tool for clang build
# apt-get install binutils-s390x-linux-gnu
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross ARCH=s390

If you fix the issue, kindly add following tag as appropriate

All warnings (new ones prefixed by >>):

>> <stdin>:1526:2: warning: syscall trampfd not implemented [-W#warnings]
   #warning syscall trampfd not implemented
    ^
   1 warning generated.
--
>> <stdin>:1526:2: warning: syscall trampfd not implemented [-W#warnings]
   #warning syscall trampfd not implemented
    ^

1 warning generated.
--
In file included from arch/s390/include/asm/diag.h:12:
In file included from include/linux/if_ether.h:19:
In file included from include/linux/skbuff.h:31:
In file included from include/linux/dma-mapping.h:11:
In file included from include/linux/scatterlist.h:9:
In file included from arch/s390/include/asm/io.h:72:
include/asm-generic/io.h:490:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]

           val = __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + addr));
                                                           ~~~~~~~~~~ ^
   include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from macro '__le32_to_cpu'
   #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x))
                                                             ^
   include/uapi/linux/swab.h:119:21: note: expanded from macro '__swab32'
           ___constant_swab32(x) :                 \
                              ^
   include/uapi/linux/swab.h:21:12: note: expanded from macro '___constant_swab32'
           (((__u32)(x) & (__u32)0x00ff0000UL) >>  8) |            \
                     ^
   In file included from arch/s390/kernel/asm-offsets.c:11:
   In file included from include/linux/kvm_host.h:32:
   In file included from include/linux/kvm_para.h:5:
   In file included from include/uapi/linux/kvm_para.h:36:
   In file included from arch/s390/include/asm/kvm_para.h:25:
   In file included from arch/s390/include/asm/diag.h:12:
   In file included from include/linux/if_ether.h:19:
   In file included from include/linux/skbuff.h:31:
   In file included from include/linux/dma-mapping.h:11:
   In file included from include/linux/scatterlist.h:9:
   In file included from arch/s390/include/asm/io.h:72:
   include/asm-generic/io.h:490:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
           val = __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + addr));
                                                           ~~~~~~~~~~ ^
   include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from macro '__le32_to_cpu'
   #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x))
                                                             ^
   include/uapi/linux/swab.h:119:21: note: expanded from macro '__swab32'
           ___constant_swab32(x) :                 \
                              ^
   include/uapi/linux/swab.h:22:12: note: expanded from macro '___constant_swab32'
           (((__u32)(x) & (__u32)0xff000000UL) >> 24)))
                     ^
   In file included from arch/s390/kernel/asm-offsets.c:11:
   In file included from include/linux/kvm_host.h:32:
   In file included from include/linux/kvm_para.h:5:
   In file included from include/uapi/linux/kvm_para.h:36:
   In file included from arch/s390/include/asm/kvm_para.h:25:
   In file included from arch/s390/include/asm/diag.h:12:
   In file included from include/linux/if_ether.h:19:
   In file included from include/linux/skbuff.h:31:
   In file included from include/linux/dma-mapping.h:11:
   In file included from include/linux/scatterlist.h:9:
   In file included from arch/s390/include/asm/io.h:72:
   include/asm-generic/io.h:490:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
           val = __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + addr));
                                                           ~~~~~~~~~~ ^
   include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from macro '__le32_to_cpu'
   #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x))
                                                             ^
   include/uapi/linux/swab.h:120:12: note: expanded from macro '__swab32'
           __fswab32(x))
                     ^
   In file included from arch/s390/kernel/asm-offsets.c:11:
   In file included from include/linux/kvm_host.h:32:
   In file included from include/linux/kvm_para.h:5:
   In file included from include/uapi/linux/kvm_para.h:36:
   In file included from arch/s390/include/asm/kvm_para.h:25:
   In file included from arch/s390/include/asm/diag.h:12:
   In file included from include/linux/if_ether.h:19:
   In file included from include/linux/skbuff.h:31:
   In file included from include/linux/dma-mapping.h:11:
   In file included from include/linux/scatterlist.h:9:
   In file included from arch/s390/include/asm/io.h:72:
   include/asm-generic/io.h:501:33: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
           __raw_writeb(value, PCI_IOBASE + addr);
                               ~~~~~~~~~~ ^
   include/asm-generic/io.h:511:59: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
           __raw_writew((u16 __force)cpu_to_le16(value), PCI_IOBASE + addr);
                                                         ~~~~~~~~~~ ^
   include/asm-generic/io.h:521:59: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
           __raw_writel((u32 __force)cpu_to_le32(value), PCI_IOBASE + addr);
                                                         ~~~~~~~~~~ ^
   include/asm-generic/io.h:609:20: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
           readsb(PCI_IOBASE + addr, buffer, count);
                  ~~~~~~~~~~ ^
   include/asm-generic/io.h:617:20: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
           readsw(PCI_IOBASE + addr, buffer, count);
                  ~~~~~~~~~~ ^
   include/asm-generic/io.h:625:20: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
           readsl(PCI_IOBASE + addr, buffer, count);
                  ~~~~~~~~~~ ^
   include/asm-generic/io.h:634:21: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
           writesb(PCI_IOBASE + addr, buffer, count);
                   ~~~~~~~~~~ ^
   include/asm-generic/io.h:643:21: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
           writesw(PCI_IOBASE + addr, buffer, count);
                   ~~~~~~~~~~ ^
   include/asm-generic/io.h:652:21: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
           writesl(PCI_IOBASE + addr, buffer, count);
                   ~~~~~~~~~~ ^
   20 warnings generated.
>> <stdin>:1526:2: warning: syscall trampfd not implemented [-W#warnings]
   #warning syscall trampfd not implemented
    ^

1 warning generated.

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org

#6 lore raw

RFC PATCH v2 3/4 arm64/trampfd: Provide support for the trampoline file descriptor

In reply to [email protected]

From: "Madhavan T. Venkataraman" <[email protected]>

- Define architecture specific register names
- Architecture specific functions for:
- system call init
- code descriptor check
- data descriptor check
- Fill a page with a trampoline table for:
- 32-bit user process
- 64-bit user process

---
 arch/arm64/include/asm/unistd.h      |   2 +-
 arch/arm64/include/asm/unistd32.h    |   2 +
 arch/arm64/include/uapi/asm/ptrace.h |  59 +++++++
 arch/arm64/kernel/Makefile           |   2 +
 arch/arm64/kernel/trampfd.c          | 244 +++++++++++++++++++++++++++
 5 files changed, 308 insertions(+), 1 deletion(-)
 create mode 100644 arch/arm64/kernel/trampfd.c
arch/arm64/include/asm/unistd.h +1 -1
index 3b859596840d..b3b2019f8d16 100644
@@ -38,7 +38,7 @@
 #define __ARM_NR_compat_set_tls		(__ARM_NR_COMPAT_BASE + 5)
 #define __ARM_NR_COMPAT_END		(__ARM_NR_COMPAT_BASE + 0x800)
 
-#define __NR_compat_syscalls		440
+#define __NR_compat_syscalls		441
 #endif
 
 #define __ARCH_WANT_SYS_CLONE
arch/arm64/include/asm/unistd32.h +2 -0
index 6d95d0c8bf2f..c0493c5322d9 100644
@@ -885,6 +885,8 @@ __SYSCALL(__NR_openat2, sys_openat2)
 __SYSCALL(__NR_pidfd_getfd, sys_pidfd_getfd)
 #define __NR_faccessat2 439
 __SYSCALL(__NR_faccessat2, sys_faccessat2)
+#define __NR_trampfd 440
+__SYSCALL(__NR_trampfd, sys_trampfd)
 
 /*
  * Please add new compat syscalls above this comment and update
arch/arm64/include/uapi/asm/ptrace.h +59 -0

65 lines not on this page · raw message

arch/arm64/kernel/Makefile +2 -0
index a561cbb91d4d..18d373fb1208 100644
@@ -71,3 +71,5 @@ extra-y					+= $(head-y) vmlinux.lds
 ifeq ($(CONFIG_DEBUG_EFI),y)
 AFLAGS_head.o += -DVMLINUX_PATH="\"$(realpath $(objtree)/vmlinux)\""
 endif
+
+obj-$(CONFIG_TRAMPFD)			+= trampfd.o
arch/arm64/kernel/trampfd.c new file +244 -0

244 lines not on this page · raw message

Signature · 1 line
2.17.1
#7 lore raw

RFC PATCH v2 4/4 arm/trampfd: Provide support for the trampoline file descriptor

In reply to [email protected]

From: "Madhavan T. Venkataraman" <[email protected]>

- Define architecture specific register names
- Architecture specific functions for:
- system call init
- code descriptor check
- data descriptor check
- Fill a page with a trampoline table,

---
 arch/arm/include/uapi/asm/ptrace.h |  21 +++++
 arch/arm/kernel/Makefile           |   1 +
 arch/arm/kernel/trampfd.c          | 124 +++++++++++++++++++++++++++++
 arch/arm/tools/syscall.tbl         |   1 +
 4 files changed, 147 insertions(+)
 create mode 100644 arch/arm/kernel/trampfd.c
arch/arm/include/uapi/asm/ptrace.h +21 -0
index e61c65b4018d..598047768f9b 100644
@@ -151,6 +151,27 @@ struct pt_regs {
 #define ARM_r0		uregs[0]
 #define ARM_ORIG_r0	uregs[17]
 
+/*
+ * These register names are to be used by 32-bit applications.
+ */
+enum reg_32_name {
+	arm_min,
+	arm_r0 = arm_min,
+	arm_r1,
+	arm_r2,
+	arm_r3,
+	arm_r4,
+	arm_r5,
+	arm_r6,
+	arm_r7,
+	arm_r8,
+	arm_r9,
+	arm_r10,
+	arm_r11,
+	arm_r12,
+	arm_max,
+};
+
 /*
  * The size of the user-visible VFP state as seen by PTRACE_GET/SETVFPREGS
  * and core dumps.
arch/arm/kernel/Makefile +1 -0
index 89e5d864e923..652c54c2f19a 100644
@@ -105,5 +105,6 @@ obj-$(CONFIG_SMP)		+= psci_smp.o
 endif
 
 obj-$(CONFIG_HAVE_ARM_SMCCC)	+= smccc-call.o
+obj-$(CONFIG_TRAMPFD)		+= trampfd.o
 
 extra-y := $(head-y) vmlinux.lds
arch/arm/kernel/trampfd.c new file +124 -0

124 lines not on this page · raw message

arch/arm/tools/syscall.tbl +1 -0
index d5cae5ffede0..85dcbc9e08ee 100644
@@ -452,3 +452,4 @@
 437	common	openat2				sys_openat2
 438	common	pidfd_getfd			sys_pidfd_getfd
 439	common	faccessat2			sys_faccessat2
+440	common	trampfd				sys_trampfd
Signature · 1 line
2.17.1
#8 lore raw
In reply to [email protected]

* madvenka:

Quoted 11 lines

Examples of trampolines
=======================

libffi (A Portable Foreign Function Interface Library):

libffi allows a user to define functions with an arbitrary list of arguments and return value through a feature called "Closures". Closures use trampolines to jump to ABI handlers that handle calling conventions and call a target function. libffi is used by a lot of different applications. To name a few:

Quoted 6 lines

- Python
- Java
- Javascript
- Ruby FFI
- Lisp
- Objective C

libffi does not actually need this. It currently collocates trampolines and the data they need on the same page, but that's actually unecessary. It's possible to avoid doing this just by changing libffi, without any kernel changes.

I think this has already been done for the iOS port.

Quoted 11 lines

The code for trampoline X in the trampoline table is:

load &code_table[X], code_reg
load (code_reg), code_reg
load &data_table[X], data_reg
load (data_reg), data_reg
jump code_reg

The addresses &code_table[X] and &data_table[X] are baked into the trampoline code. So, PC-relative data references are not needed. The user can modify code_table[X] and data_table[X] dynamically.

You can put this code into the libffi shared object and map it from there, just like the rest of the libffi code. To get more trampolines, you can map the page containing the trampolines multiple times, each instance preceded by a separate data page with the control information.

I think the previous patch submission has also resulted in several comments along those lines, so I'm not sure why you are reposting this.

Quoted 7 lines

libffi
======

I have implemented my solution for libffi and provided the changes for X86 and ARM, 32-bit and 64-bit. Here is the reference patch:

http://linux.microsoft.com/~madvenka/libffi/libffi.v2.txt

The URL does not appear to work, I get a 403 error.

Quoted 3 lines

If the trampfd patchset gets accepted, I will send the libffi changes to the maintainers for a review. BTW, I have also successfully executed the libffi self tests.

I have not seen your libffi changes, but I expect that the complexity is about the same as a userspace-only solution.

Cc:ing libffi upstream for awareness. The start of the thread is here:

<https://lore.kernel.org/linux-api/[email protected]/>

#9 lore raw
Quoted 20 lines · Florian Weimer

* madvenka:

Quoted 11 lines

Examples of trampolines
=======================

libffi (A Portable Foreign Function Interface Library):

libffi allows a user to define functions with an arbitrary list of arguments and return value through a feature called "Closures". Closures use trampolines to jump to ABI handlers that handle calling conventions and call a target function. libffi is used by a lot of different applications. To name a few:

Quoted 6 lines

- Python
- Java
- Javascript
- Ruby FFI
- Lisp
- Objective C

Quoted 7 lines

libffi does not actually need this. It currently collocates trampolines and the data they need on the same page, but that's actually unecessary. It's possible to avoid doing this just by changing libffi, without any kernel changes.

I think this has already been done for the iOS port.

The trampoline table that has been implemented for the iOS port (MACH) is based on PC-relative data referencing. That is, the code and data are placed in adjacent pages so that the code can access the data using an address relative to the current PC.

This is an ISA feature that is not supported on all architectures.

Now, if it is a performance feature, we can include some architectures and exclude others. But this is a security feature. IMO, we cannot exclude any architecture even if it is a legacy one as long as Linux is running on the architecture. So, we need a solution that does not assume any specific ISA feature.

Quoted 12 lines
Quoted 11 lines

The code for trampoline X in the trampoline table is:

load &code_table[X], code_reg
load (code_reg), code_reg
load &data_table[X], data_reg
load (data_reg), data_reg
jump code_reg

The addresses &code_table[X] and &data_table[X] are baked into the trampoline code. So, PC-relative data references are not needed. The user can modify code_table[X] and data_table[X] dynamically.

Quoted 6 lines

You can put this code into the libffi shared object and map it from there, just like the rest of the libffi code. To get more trampolines, you can map the page containing the trampolines multiple times, each instance preceded by a separate data page with the control information.

If you put the code in the libffi shared object, how do you pass data to the code at runtime? If the code we are talking about is a function, then there is an ABI defined way to pass data to the function. But if the code we are talking about is some arbitrary code such as a trampoline, there is no ABI defined way to pass data to it except in a couple of platforms such as HP PA-RISC that have support for function descriptors in the ABI itself.

As mentioned before, if the ISA supports PC-relative data references (e.g., X86 64-bit platforms support RIP-relative data references) then we can pass data to that code by placing the code and data in adjacent pages. So, you can implement the trampoline table for X64. i386 does not support it.

Quoted 3 lines

I think the previous patch submission has also resulted in several comments along those lines, so I'm not sure why you are reposting this.

IIRC, I have answered all of those comments by mentioning the point that we need to support all architectures without requiring special ISA features. Taking the kernel's help in this is one solution.

Quoted 10 lines
Quoted 8 lines

libffi
======

I have implemented my solution for libffi and provided the changes for X86 and ARM, 32-bit and 64-bit. Here is the reference patch:

http://linux.microsoft.com/~madvenka/libffi/libffi.v2.txt

The URL does not appear to work, I get a 403 error.

I apologize for that. That site is supposed to be accessible publicly. I will contact the administrator and get this resolved.

Sorry for the annoyance.

Quoted 9 lines
Quoted 4 lines

If the trampfd patchset gets accepted, I will send the libffi changes to the maintainers for a review. BTW, I have also successfully executed the libffi self tests.

I have not seen your libffi changes, but I expect that the complexity is about the same as a userspace-only solution.

I agree. The complexity is about the same. But the support is for all architectures. Once the common code is in place, the changes for each architecture are trivial.

Madhavan

Quoted 5 lines

Cc:ing libffi upstream for awareness. The start of the thread is here:

<https://lore.kernel.org/linux-api/[email protected]/>

#10 lore raw
Quoted 6 lines · Madhavan T. Venkataraman
Quoted 6 lines
Quoted 6 lines

libffi
======

I have implemented my solution for libffi and provided the changes for X86 and ARM, 32-bit and 64-bit. Here is the reference patch:

Quoted 7 lines
Quoted 2 lines
Quoted 1 line

http://linux.microsoft.com/~madvenka/libffi/libffi.v2.txt

The URL does not appear to work, I get a 403 error.

I apologize for that. That site is supposed to be accessible publicly. I will contact the administrator and get this resolved.

Sorry for the annoyance.

Could you try the link again and confirm that you can access it? Again, sorry for the trouble.

Madhavan

#11 lore raw

* Madhavan T. Venkataraman:

Quoted 8 lines · Madhavan T. Venkataraman
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines

libffi
======

I have implemented my solution for libffi and provided the changes for X86 and ARM, 32-bit and 64-bit. Here is the reference patch:

http://linux.microsoft.com/~madvenka/libffi/libffi.v2.txt

Quoted 8 lines
Quoted 5 lines
Quoted 1 line

The URL does not appear to work, I get a 403 error.

I apologize for that. That site is supposed to be accessible publicly. I will contact the administrator and get this resolved.

Sorry for the annoyance.

Could you try the link again and confirm that you can access it? Again, sorry for the trouble.

Yes, it works now. Thanks for having it fixed.

#12 lore raw
In reply to Madhavan T. Venkataraman
Quoted 36 lines · Madhavan T. Venkataraman
Quoted 20 lines · Florian Weimer

* madvenka:

Quoted 11 lines

Examples of trampolines
=======================

libffi (A Portable Foreign Function Interface Library):

libffi allows a user to define functions with an arbitrary list of arguments and return value through a feature called "Closures". Closures use trampolines to jump to ABI handlers that handle calling conventions and call a target function. libffi is used by a lot of different applications. To name a few:

Quoted 6 lines

- Python
- Java
- Javascript
- Ruby FFI
- Lisp
- Objective C

Quoted 7 lines

libffi does not actually need this. It currently collocates trampolines and the data they need on the same page, but that's actually unecessary. It's possible to avoid doing this just by changing libffi, without any kernel changes.

I think this has already been done for the iOS port.

The trampoline table that has been implemented for the iOS port (MACH) is based on PC-relative data referencing. That is, the code and data are placed in adjacent pages so that the code can access the data using an address relative to the current PC.

Quoted 7 lines

This is an ISA feature that is not supported on all architectures.

Now, if it is a performance feature, we can include some architectures and exclude others. But this is a security feature. IMO, we cannot exclude any architecture even if it is a legacy one as long as Linux is running on the architecture. So, we need a solution that does not assume any specific ISA feature.

Which ISA does not support PIC objects? You mentioned i386 below, but i386 does support them, it just needs to copy the PC into a GPR first (see below).

Quoted 28 lines
Quoted 13 lines
Quoted 9 lines

The code for trampoline X in the trampoline table is:

load &code_table[X], code_reg
load (code_reg), code_reg
load &data_table[X], data_reg
load (data_reg), data_reg
jump code_reg

Quoted 3 lines

The addresses &code_table[X] and &data_table[X] are baked into the trampoline code. So, PC-relative data references are not needed. The user can modify code_table[X] and data_table[X] dynamically.

Quoted 6 lines

You can put this code into the libffi shared object and map it from there, just like the rest of the libffi code. To get more trampolines, you can map the page containing the trampolines multiple times, each instance preceded by a separate data page with the control information.

If you put the code in the libffi shared object, how do you pass data to the code at runtime? If the code we are talking about is a function, then there is an ABI defined way to pass data to the function. But if the code we are talking about is some arbitrary code such as a trampoline, there is no ABI defined way to pass data to it except in a couple of platforms such as HP PA-RISC that have support for function descriptors in the ABI itself.

Quoted 6 lines

As mentioned before, if the ISA supports PC-relative data references (e.g., X86 64-bit platforms support RIP-relative data references) then we can pass data to that code by placing the code and data in adjacent pages. So, you can implement the trampoline table for X64. i386 does not support it.

i386 just needs a tiny bit of code to copy the PC into a GPR first, i.e. the trampoline would be:

	call	1f
1:	pop	%data_reg
	movl	(code_table + X - 1b)(%data_reg), %code_reg
	movl	(data_table + X - 1b)(%data_reg), %data_reg
	jmp	*(%code_reg)

I do not understand the point about passing data at runtime. This trampoline is to achieve exactly that, no?

Thanks.

#13 lore raw
Quoted 93 lines · Arvind Sankar
Quoted 36 lines · Madhavan T. Venkataraman
Quoted 20 lines · Florian Weimer

* madvenka:

Quoted 11 lines

Examples of trampolines
=======================

libffi (A Portable Foreign Function Interface Library):

libffi allows a user to define functions with an arbitrary list of arguments and return value through a feature called "Closures". Closures use trampolines to jump to ABI handlers that handle calling conventions and call a target function. libffi is used by a lot of different applications. To name a few:

Quoted 6 lines

- Python
- Java
- Javascript
- Ruby FFI
- Lisp
- Objective C

Quoted 7 lines

libffi does not actually need this. It currently collocates trampolines and the data they need on the same page, but that's actually unecessary. It's possible to avoid doing this just by changing libffi, without any kernel changes.

I think this has already been done for the iOS port.

The trampoline table that has been implemented for the iOS port (MACH) is based on PC-relative data referencing. That is, the code and data are placed in adjacent pages so that the code can access the data using an address relative to the current PC.

Quoted 7 lines

This is an ISA feature that is not supported on all architectures.

Now, if it is a performance feature, we can include some architectures and exclude others. But this is a security feature. IMO, we cannot exclude any architecture even if it is a legacy one as long as Linux is running on the architecture. So, we need a solution that does not assume any specific ISA feature.

Which ISA does not support PIC objects? You mentioned i386 below, but i386 does support them, it just needs to copy the PC into a GPR first (see below).

Quoted 28 lines
Quoted 13 lines
Quoted 9 lines

The code for trampoline X in the trampoline table is:

load &code_table[X], code_reg
load (code_reg), code_reg
load &data_table[X], data_reg
load (data_reg), data_reg
jump code_reg

Quoted 3 lines

The addresses &code_table[X] and &data_table[X] are baked into the trampoline code. So, PC-relative data references are not needed. The user can modify code_table[X] and data_table[X] dynamically.

Quoted 6 lines

You can put this code into the libffi shared object and map it from there, just like the rest of the libffi code. To get more trampolines, you can map the page containing the trampolines multiple times, each instance preceded by a separate data page with the control information.

If you put the code in the libffi shared object, how do you pass data to the code at runtime? If the code we are talking about is a function, then there is an ABI defined way to pass data to the function. But if the code we are talking about is some arbitrary code such as a trampoline, there is no ABI defined way to pass data to it except in a couple of platforms such as HP PA-RISC that have support for function descriptors in the ABI itself.

Quoted 6 lines

As mentioned before, if the ISA supports PC-relative data references (e.g., X86 64-bit platforms support RIP-relative data references) then we can pass data to that code by placing the code and data in adjacent pages. So, you can implement the trampoline table for X64. i386 does not support it.

i386 just needs a tiny bit of code to copy the PC into a GPR first, i.e. the trampoline would be:

	call	1f
1:	pop	%data_reg
	movl	(code_table + X - 1b)(%data_reg), %code_reg
	movl	(data_table + X - 1b)(%data_reg), %data_reg
	jmp	*(%code_reg)
Quoted 4 lines

I do not understand the point about passing data at runtime. This trampoline is to achieve exactly that, no?

Thanks.

For libffi, I think the proposed standard trampoline won't actually work, because not all ABIs have two scratch registers available to use as code_reg and data_reg. Eg i386 fastcall only has one, and register has zero scratch registers. I believe 32-bit ARM only has one scratch register as well.

For i386 you'd need something that saves a register on the stack first, maybe like the below with a 16-byte trampoline and a 16-byte context structure that has the address of the code to jump to in the first dword:

	.balign 4096
	trampoline_page:

	.rept	4096/16-1
	0:	endbr32
		push	%eax
		call	__x86.get_pc_thunk.ax
	1:	jmp	trampoline
	.balign 16
	.endr

	.org trampoline_page + 4096 - 16
	__x86.get_pc_thunk.ax:
		movl	(%esp), %eax
		ret
	trampoline:
		subl	$(1b-0b), %eax
		jmp	*(table-trampoline_page)(%eax)

	.org trampoline_page + 4096
	table:
#14 lore raw
Quoted 5 lines · Arvind Sankar

For libffi, I think the proposed standard trampoline won't actually work, because not all ABIs have two scratch registers available to use as code_reg and data_reg. Eg i386 fastcall only has one, and register has zero scratch registers. I believe 32-bit ARM only has one scratch register as well.

The trampoline is invoked as a function call in the libffi case. Any caller saved register can be used as code_reg, can it not? And the scratch register is needed only to jump to the code. After that, it can be reused for any other purpose.

However, for ARM, you are quite correct. There is only one scratch register. This means that I have to provide two types of trampolines:

- If an architecture has enough scratch registers, use the currently defined trampoline.

- If the architecture has only one scratch register, but has PC-relative data references, then embed the code address at the bottom of the trampoline and access it using PC-relative addressing.

Thanks for pointing this out.

Madhavan

#15 lore raw
Quoted 20 lines · Madhavan T. Venkataraman
Quoted 5 lines · Arvind Sankar

For libffi, I think the proposed standard trampoline won't actually work, because not all ABIs have two scratch registers available to use as code_reg and data_reg. Eg i386 fastcall only has one, and register has zero scratch registers. I believe 32-bit ARM only has one scratch register as well.

The trampoline is invoked as a function call in the libffi case. Any caller saved register can be used as code_reg, can it not? And the scratch register is needed only to jump to the code. After that, it can be reused for any other purpose.

However, for ARM, you are quite correct. There is only one scratch register. This means that I have to provide two types of trampolines:

- If an architecture has enough scratch registers, use the currently defined trampoline.

Quoted 7 lines

- If the architecture has only one scratch register, but has PC-relative data references, then embed the code address at the bottom of the trampoline and access it using PC-relative addressing.

Thanks for pointing this out.

Madhavan

libffi is trying to provide closures with non-standard ABIs as well: the actual user function is standard ABI, but the closure can be called with a different ABI. If the closure was created with FFI_REGISTER abi, there are no registers available for the trampoline to use: EAX, EDX and ECX contain the first three arguments of the function, and every other register is callee-save.

I provided a sample of the kind of trampoline that would be needed in this case -- it's position-independent and doesn't clobber any registers at all, and you get 255 trampolines per page. If I take another 16-byte slot out of the page for the end trampoline that does the actual work, I'm sure I could even come up with one that can just call a normal C function, only the return might need special handling depending on the return type.

And again, do you actually have any example of an architecture that cannot run position-independent code? PC-relative addressing is an implementation detail: the fact that it's available for x86_64 but not for i386 just makes position-independent code more cumbersome on i386, but it doesn't make it impossible. For the tiny trampolines here, it makes almost no difference.

#16 lore raw
Quoted 44 lines · Arvind Sankar
Quoted 20 lines · Madhavan T. Venkataraman
Quoted 5 lines · Arvind Sankar

For libffi, I think the proposed standard trampoline won't actually work, because not all ABIs have two scratch registers available to use as code_reg and data_reg. Eg i386 fastcall only has one, and register has zero scratch registers. I believe 32-bit ARM only has one scratch register as well.

The trampoline is invoked as a function call in the libffi case. Any caller saved register can be used as code_reg, can it not? And the scratch register is needed only to jump to the code. After that, it can be reused for any other purpose.

However, for ARM, you are quite correct. There is only one scratch register. This means that I have to provide two types of trampolines:

- If an architecture has enough scratch registers, use the currently defined trampoline.

Quoted 7 lines

- If the architecture has only one scratch register, but has PC-relative data references, then embed the code address at the bottom of the trampoline and access it using PC-relative addressing.

Thanks for pointing this out.

Madhavan

libffi is trying to provide closures with non-standard ABIs as well: the actual user function is standard ABI, but the closure can be called with a different ABI. If the closure was created with FFI_REGISTER abi, there are no registers available for the trampoline to use: EAX, EDX and ECX contain the first three arguments of the function, and every other register is callee-save.

I provided a sample of the kind of trampoline that would be needed in this case -- it's position-independent and doesn't clobber any registers at all, and you get 255 trampolines per page. If I take another 16-byte slot out of the page for the end trampoline that does the actual work, I'm sure I could even come up with one that can just call a normal C function, only the return might need special handling depending on the return type.

Quoted 7 lines

And again, do you actually have any example of an architecture that cannot run position-independent code? PC-relative addressing is an implementation detail: the fact that it's available for x86_64 but not for i386 just makes position-independent code more cumbersome on i386, but it doesn't make it impossible. For the tiny trampolines here, it makes almost no difference.

Hi Arvind,

I am preparing a response for all of your comments. I will send it out tomorrow. Sorry for the delay.

Madhavan

#17 lore raw
In reply to Arvind Sankar
Quoted 44 lines · Arvind Sankar
Quoted 20 lines · Madhavan T. Venkataraman
Quoted 5 lines · Arvind Sankar

For libffi, I think the proposed standard trampoline won't actually work, because not all ABIs have two scratch registers available to use as code_reg and data_reg. Eg i386 fastcall only has one, and register has zero scratch registers. I believe 32-bit ARM only has one scratch register as well.

The trampoline is invoked as a function call in the libffi case. Any caller saved register can be used as code_reg, can it not? And the scratch register is needed only to jump to the code. After that, it can be reused for any other purpose.

However, for ARM, you are quite correct. There is only one scratch register. This means that I have to provide two types of trampolines:

- If an architecture has enough scratch registers, use the currently defined trampoline.

Quoted 7 lines

- If the architecture has only one scratch register, but has PC-relative data references, then embed the code address at the bottom of the trampoline and access it using PC-relative addressing.

Thanks for pointing this out.

Madhavan

libffi is trying to provide closures with non-standard ABIs as well: the actual user function is standard ABI, but the closure can be called with a different ABI. If the closure was created with FFI_REGISTER abi, there are no registers available for the trampoline to use: EAX, EDX and ECX contain the first three arguments of the function, and every other register is callee-save.

I provided a sample of the kind of trampoline that would be needed in this case -- it's position-independent and doesn't clobber any registers at all, and you get 255 trampolines per page. If I take another 16-byte slot out of the page for the end trampoline that does the actual work, I'm sure I could even come up with one that can just call a normal C function, only the return might need special handling depending on the return type.

Quoted 7 lines

And again, do you actually have any example of an architecture that cannot run position-independent code? PC-relative addressing is an implementation detail: the fact that it's available for x86_64 but not for i386 just makes position-independent code more cumbersome on i386, but it doesn't make it impossible. For the tiny trampolines here, it makes almost no difference.

I have tried to answer all of your previous comments here. Let me know if I missed anything:

Quoted 3 lines

Which ISA does not support PIC objects? You mentioned i386 below, but i386 does support them, it just needs to copy the PC into a GPR first (see below).

Position Independent Code needs PC-relative branches. I was referring to PC-relative data references. Like RIP-relative data references in X64. i386 ISA does not support this.

Quoted 11 lines

i386 just needs a tiny bit of code to copy the PC into a GPR first, i.e. the trampoline would be:

	call	1f
1:	pop	%data_reg
	movl	(code_table + X - 1b)(%data_reg), %code_reg
	movl	(data_table + X - 1b)(%data_reg), %data_reg
	jmp	*(%code_reg)

I do not understand the point about passing data at runtime. This trampoline is to achieve exactly that, no?

PC-relative data referencing
----------------------------

I agree that the current PC value can be loaded in a GPR using the trick of call, pop on i386.

Perhaps, on other architectures, we can do similar things. For instance, in architectures that load the return address in a designated register instead of pushing it on the stack, the trampoline could call a leaf function that moves the value of that register into data_reg so that at the location after the call instruction, the current PC is already loaded in data_reg. SPARC is one example I can think of.

My take is - if the ISA supports PC-relative data referencing explicitly (like X64 or ARM64), then we can use it. Or, if the ABI specification documents an approved way to load the PC into a GPR, we can use it.

Otherwise, using an ABI quirk or a calling convention side effect to load the PC into a GPR is, IMO, non-standard or non-compliant or non-approved or whatever you want to call it. I would be conservative and not use it. Who knows what incompatibility there will be with some future software or hardware features?

For instance, in the i386 example, we do a call without a matching return. Also, we use a pop to undo the call. Can anyone tell me if this kind of use is an ABI approved one?

Kernel supplied trampoline
--------------------------

One advantage in doing this in the kernel is that we don't need to use non-standard or non-ABI compliant code.

To minimize the number of registers used by the trampoline, I will redefine the kernel generated trampoline as follows:

- The kernel loads the trampoline and the code and the data addresses to be dereferenced like this:

	A ----> -------------------
		| Trampoline code |
	B ---->	-------------------
	        | Data Address    |
		-------------------
		| Code Address    |
		-------------------

So, the trampoline code would be:

mov B, %data_reg
jump (%data_reg + sizeof(Data address))

The kernel will hard code B into the trampoline.

The static code that the trampoline jumps to looks like this:

	load (%data_reg), %data_reg
	rest of the code

Use of scratch registers
------------------------

With this new trampoline, we only use one scratch register. So, the same RFC will work for libffi on ARM.

You pointed out that in the FFI_REGISTER ABI no scratch registers can be used. Read the section "Secure vs Performant trampoline" below where this is addressed.

Standard API for all userland for all architectures
---------------------------------------------------

The next advantage in using the kernel is standardization.

If the kernel supplies this, then all applications and libraries can use it for all architectures with one single, simple API. Without this, each application/library has to roll its own solution for every architecture-ABI combo it wants to support.

Furthermore, if this work gets accepted, I plan to add a glibc wrapper for the kernel API. The glibc API would look something like this:

	Allocate a trampoline
	---------------------

	tramp = alloc_tramp();

	Set trampoline parameters
	-------------------------

	init_tramp(tramp, code, data);

	Free the trampoline
	-------------------

	free_tramp(tramp);

glibc will allocate and manage the code and data tables, handle kernel API details and manage the trampoline table.

As an example, in libffi:

ffi_closure_alloc() would call alloc_tramp()

ffi_prep_closure_loc() would call init_tramp()

ffi_closure_free() would call free_tramp()

That is it! It works on all the architectures supported in the kernel for trampfd.

This makes it really easy for maintainers to adopt the API and move their code to a more secure model (which is the fundamental idea behind this work). For this advantage alone, IMO, it is worth doing it in the kernel.

Secure vs Performant trampoline
-------------------------------

If you recall, in version 1, I presented a trampoline type that is implemented in the kernel. When an application invokes the trampoline, it traps into the kernel and the kernel performs the work of the trampoline.

The disadvantage is that a trip to the kernel is needed. That can be expensive.

The advantage is that the kernel can add security checks before doing the work. Mainly, I am looking at checks that might prevent the trampoline from being used in an ROP/BOP chain. Some half-baked ideas:

- Check that the invocation is at the starting point of the trampoline

- Check if the trampoline is jumping to an allowed PC

- Check if the trampoline is being invoked from an allowed calling PC or PC range

Allowed PCs can be input using the trampfd API mentioned in version 1. Basically, an array of PCs is written into trampfd.

Suggestions for other checks are most welcome!

I would like to implement an option in the trampfd API. The user can choose a secure trampoline or a performant trampoline. For a performant trampoline, the kernel will generate the code. For a secure trampoline, the kernel will do the work itself.

In order to address the FFI_REGISTER ABI in libffi, we could use the secure trampoline. In FFI_REGISTER, the data is pushed on the stack and the code is jumped to without using any registers.

As outlined in version 1, the kernel can push the data address on the stack and write the code address into the PC and return to userland.

For doing all of this, we need trampfd.

Permitting the use of trampfd
-----------------------------

An "exectramp" setting can be implemented in SELinux to selectively allow the use of trampfd for applications.

Madhavan

#18 lore raw

* Madhavan T. Venkataraman:

Quoted 5 lines

Otherwise, using an ABI quirk or a calling convention side effect to load the PC into a GPR is, IMO, non-standard or non-compliant or non-approved or whatever you want to call it. I would be conservative and not use it. Who knows what incompatibility there will be with some future software or hardware features?

AArch64 PAC makes a backwards-incompatible change that touches this area, but we'll see if they can actually get away with it.

In general, these things are baked into the ABI, even if they are not spelled out explicitly in the psABI supplement.

Quoted 3 lines

For instance, in the i386 example, we do a call without a matching return. Also, we use a pop to undo the call. Can anyone tell me if this kind of use is an ABI approved one?

Yes, for i386, this is completely valid from an ABI point of view. It's equally possible to use a regular function call and just read the return address that has been pushed to the stack. Then there's no stack mismatch at all. Return stack predictors (including the one used by SHSTK) also recognize the CALL 0 construct, so that's fine as well. The i386 psABI does not use function descriptors, and either approach (out-of-line thunk or CALL 0) is in common use to materialize the program counter in a register and construct the GOT pointer.

Quoted 4 lines

If the kernel supplies this, then all applications and libraries can use it for all architectures with one single, simple API. Without this, each application/library has to roll its own solution for every architecture-ABI combo it wants to support.

Is there any other user for these type-generic trampolines? Everything else I've seen generates machine code specific to the function being called. libffi is quite the outlier in my experience because the trampoline calls a generic data-driven marshaller/unmarshaller. The other trampoline generators put this marshalling code directly into the generated trampoline.

I'm still not convinced that this can't be done directly in libffi, without kernel help. Hiding the architecture-specific code in the kernel doesn't reduce overall system complexity.

Quoted 10 lines

As an example, in libffi:

ffi_closure_alloc() would call alloc_tramp()

ffi_prep_closure_loc() would call init_tramp()

ffi_closure_free() would call free_tramp()

That is it! It works on all the architectures supported in the kernel for trampfd.

ffi_prep_closure_loc would still need to check whether the trampoline has been allocated by alloc_tramp because some applications supply their own (executable and writable) mapping. ffi_closure_alloc would need to support different sizes (not matching the trampoline). It's also unclear to me to what extent software out there writes to the trampoline data directly, bypassing the libffi API (the structs are not opaque, after all). And all the existing libffi memory management code (including the embedded dlmalloc copy) would be needed to support kernels without trampfd for years to come.

I very much agree that we have a gap in libffi when it comes to JIT-less operation. But I'm not convinced that kernel support is needed to close it, or that it is even the right design.

#19 lore raw
Quoted 39 lines · Florian Weimer

* Madhavan T. Venkataraman:

Quoted 5 lines

Otherwise, using an ABI quirk or a calling convention side effect to load the PC into a GPR is, IMO, non-standard or non-compliant or non-approved or whatever you want to call it. I would be conservative and not use it. Who knows what incompatibility there will be with some future software or hardware features?

AArch64 PAC makes a backwards-incompatible change that touches this area, but we'll see if they can actually get away with it.

In general, these things are baked into the ABI, even if they are not spelled out explicitly in the psABI supplement.

Quoted 3 lines

For instance, in the i386 example, we do a call without a matching return. Also, we use a pop to undo the call. Can anyone tell me if this kind of use is an ABI approved one?

Yes, for i386, this is completely valid from an ABI point of view. It's equally possible to use a regular function call and just read the return address that has been pushed to the stack. Then there's no stack mismatch at all. Return stack predictors (including the one used by SHSTK) also recognize the CALL 0 construct, so that's fine as well. The i386 psABI does not use function descriptors, and either approach (out-of-line thunk or CALL 0) is in common use to materialize the program counter in a register and construct the GOT pointer.

Quoted 4 lines

If the kernel supplies this, then all applications and libraries can use it for all architectures with one single, simple API. Without this, each application/library has to roll its own solution for every architecture-ABI combo it wants to support.

Is there any other user for these type-generic trampolines? Everything else I've seen generates machine code specific to the function being called. libffi is quite the outlier in my experience because the trampoline calls a generic data-driven marshaller/unmarshaller. The other trampoline generators put this marshalling code directly into the generated trampoline.

Quoted 4 lines

I'm still not convinced that this can't be done directly in libffi, without kernel help. Hiding the architecture-specific code in the kernel doesn't reduce overall system complexity.

See below. I have accepted the community's recommendation to implement it in user land. However, this is not just for libffi. It is for all dynamic code. libffi is just the first use case I am addressing with this.

Quoted 11 lines
Quoted 10 lines

As an example, in libffi:

ffi_closure_alloc() would call alloc_tramp()

ffi_prep_closure_loc() would call init_tramp()

ffi_closure_free() would call free_tramp()

That is it! It works on all the architectures supported in the kernel for trampfd.

Quoted 10 lines

ffi_prep_closure_loc would still need to check whether the trampoline has been allocated by alloc_tramp because some applications supply their own (executable and writable) mapping. ffi_closure_alloc would need to support different sizes (not matching the trampoline). It's also unclear to me to what extent software out there writes to the trampoline data directly, bypassing the libffi API (the structs are not opaque, after all). And all the existing libffi memory management code (including the embedded dlmalloc copy) would be needed to support kernels without trampfd for years to come.

In the libffi patch I have included, I have handled this. The closure structure contains a tramp field:

  char tramp[FFI_TRAMPOLINE_SIZE];

If trampfd is not used, this array will contain the actual trampoline code. If trampfd is used, then we don't need the array for storing any trampoline code. That space can be used for storing trampfd related information.

So, there is no change to the closure structure.

Also, the code can tell if the closure has been allocated from dlmalloc() called from ffi_closure_alloc() or has been allocated by the caller directly without calling ffi_closure_alloc(). I have written this function:

int ffi_closure_alloc_called(void *closure) {
msegmentptr seg = segment_holding (gm, closure); return (seg != NULL);
}

Using this function, I can tell how the closure has been allocated. I use trampfd only for closures that have been allocated using ffi_closure_alloc(). So, I believe I have handled all the cases. If I have missed anything, let me know. I will address it.

Quoted 4 lines

I very much agree that we have a gap in libffi when it comes to JIT-less operation. But I'm not convinced that kernel support is needed to close it, or that it is even the right design.

I have taken into account most of the comments received so far and I have come up with a proposal:

I would like to do this in two separate RFCs:

library RFC
-----------

I accept the recommendation of the reviewers about implementing it in user land in a library.

Just for the sake of context, I would like to reiterate the problem being solved and what the library will contain. Bear with me.

My goal is to help convert existing dynamic code to static code as far as possible. The binary generated from the static code can be signed. The kernel can use signature verification to authenticate the code. This way, we don't need to disable W^X or make exceptions for the code (exemem etc) or use any user level methods to somehow map and execute the code.

The dynamic code can be very simple like the libffi trampoline. Or, it can be a lot more complex. E.g., a trampoline that uses data marshaling as Florian mentioned. In all cases, when the code is converted to static code, the static code needs to know where its data will be located at runtime. If static code is a function, then one can just pass parameters. But if it is arbitrary code, then one needs a way to inform the static code where it can find its data.

The code can use PC-relative referencing where available. For the sake of this discussion, let us assume that we can use some trick or the other to load the current PC into a GPR on all architectures. Then, we can use PC-relative referencing. Let us assume that these tricks will not cause ABI compliance issues in the future.

The maintainer of the dynamic code who wishes to convert it to static code should not have to deal with all of these details. The static code should be able to assume that its data is pointed to by a designated register. Or, it should be able to assume that the data pointer has been pushed on the stack. Then, it is easier for maintainers to adopt this and move their code to a more secure model.

This can be achieved by providing a small, minimal trampoline that loads the data pointer in a register or pushes it on the stack and jumps to the static code.

The reviewers felt that the minimal trampoline can be provided in user land. So, I will provide a user library. The user library will:

- define the minimal trampoline statically for different architectures using some flavor of PC-relative data referencing

- provide a table of trampolines in a page

- create and manage code and data pages

- present a simple API to dynamic code maintainers

This overall approach has pretty much been agreed upon by the community so far. I will send out an RFC for the library once I have the code ready.

Which library?
--------------

I need a recommendation from the community on this. Should I just place the code in glibc? Or, should I create a libtramp for this? I prefer glibc as it will make for easier adoption. But I will defer to the community on this. What do you recommend?

trampfd RFC version 3
---------------------

Once the library RFC is accepted, I would, however, like to submit version 3 of trampfd.

The library would support a choice of trampoline:

- fast user trampoline described above

- slow kernel trampoline described below that supports security checks each time the trampoline is invoked

The minimal trampoline mentioned above would also be implemented in the kernel. The mechanism is outlined in version 1. When the application executes the trampoline, it would trap into the kernel and the kernel would do the work (load the data pointer in a user register or push it on the user stack and set the user PC to the target code and return). The kernel will perform security checks when the trampoline is invoked. For instance, to reduce or eliminate the possibility of the trampoline being used in an ROP/BOP chain. The checks are work in progress. But I think I can nail them.

Note that there is no code generation involved in this proposal. The kernel is the trampoline.

Would you guys be willing to consider this approach?

Madhavan

#20 lore raw

Before I implement the user land solution recommended by reviewers, I just want an opinion on where the code should reside.

I am thinking glibc. The other choice would be a separate library, say, libtramp. What do you recommend?

Madhavan

#21 lore raw

 > And this is not just for libffi that we can somehow do this within libffi. > I would like to provide something so that the maintainers of other > dynamic code can use it to convert their dynamic code to static code > when their dynamic code is a lot more complex that the libffi trampoline.

Having worked on stuff "like" this -- removing "arbitrary" codegen from a system and replacing with "templatized" codegen, because the runtime banned runtime codegen,
and despite being a lover of shared source and shared libraries, I'm afraid to say, this is not an area very amenable
to sharing.

Specifically I've done this twice.

Providing examples is good and people will copy/paste.

The problem can be sort of split up into parts:

 - The management of a pool of thunks.

 - The thunks.

Where I mostly give up is:

 - Generalizing the thunks, such as to share them.

the management of the pool is kinda sorta generalizable, but the thunks, again, it is difficult/impossible to share.

I do think, there is *some* opportunity here.

Stuff like, for some function f(x,y), produce
a new function f2(y,x) that swaps params and calls f or a new function f3(x), that sets y to a constant and calls f.

Like my favorite Scheme-ish:

Given a static binary function:
  function add(x, y) (+ x y)

Provide for dynamically creating specialized unary functions:

 function make-add(x):
   return function addx(y) (+ x y)

And then generalized to arbitrary rearrangement and hardcoding of parameters.

I believe this is libffi, and might be able to replace some people's codegens.

It sounds a bit contrived, but I know this actually resembles real world cases.

Consider some library that accepts function pointers but fails to accept an additional void* to pass on to them. qsort/bsearch are the classic broken-ish cases. Wrapping Windows WNDPROCs in C++ are another -- you want a "thunk" to take the Win32-defined parameters, and add a this pointer as well. So you create a new function and when you create the function you give it the this pointer to hardcode within it. i.e. atlthunk.

 > The kernel based solution gives you the opportunity to make additional > security checks at the time a trampoline is invoked. A purely user level > solution cannot do that. E.g., I would like to prevent even the minimal > trampoline from being used in BOP/ROP chains.

Like what? At some point, it is just normal static code.
Once libffi is fixed, so that the iOS solution is available on all platforms, it is all just normal code. There are no checks to apply differently to libffi and its output than any other code, right?

 > Before I implement the user land solution recommended by reviewers, I just want > an opinion on where the code should reside.
 >
 > I am thinking glibc. The other choice would be a separate library, say, libtramp. > What do you recommend?

What functionality does the user land solution provide?

I suggest, other than lobbying the libffi developers to do their part,
and perhaps giving in and doing it yourself, identity some other dynamic but non-arbitrary code generations that you wish to fix and work through fixing it.
See what patterns emerge.

 - Jay

_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

#22 lore raw
In reply to Madhavan T. Venkataraman

Hi!

Quoted 13 lines

PC-relative data referencing
----------------------------

I agree that the current PC value can be loaded in a GPR using the trick of call, pop on i386.

Perhaps, on other architectures, we can do similar things. For instance, in architectures that load the return address in a designated register instead of pushing it on the stack, the trampoline could call a leaf function that moves the value of that register into data_reg so that at the location after the call instruction, the current PC is already loaded in data_reg. SPARC is one example I can think of.

Quoted 7 lines

My take is - if the ISA supports PC-relative data referencing explicitly (like X64 or ARM64), then we can use it. Or, if the ABI specification documents an approved way to load the PC into a GPR, we can use it.

Otherwise, using an ABI quirk or a calling convention side effect to load the PC into a GPR is, IMO, non-standard or non-compliant or non-approved or whatever you want to call it. I would be conservative and not use

ISAs are very well defined, and basically not changing. If you want to argue we should not use something, you should have very clear picture _why_ it is bad. "Non-standard or non-approved or whatever" just does not cut it.

And yes, certain tricks may be seriously slow on modern CPUs, and we might want to avoid those. But other than that... you should have better argument than "it is non-standard".

Best regards,
Pavel

Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
#23 lore raw
In reply to Madhavan T. Venkataraman
Quoted 9 lines · Madhavan T. Venkataraman
Quoted 5 lines

Which ISA does not support PIC objects? You mentioned i386 below, but i386 does support them, it just needs to copy the PC into a GPR first (see below).

Position Independent Code needs PC-relative branches. I was referring to PC-relative data references. Like RIP-relative data references in X64. i386 ISA does not support this.

I was talking about PC-relative data references too: they are a requirement for PIC code that wants to access any global data. They can be implemented easily on i386 even though it doesn't have an addressing mode that uses the PC.

Quoted 9 lines

Otherwise, using an ABI quirk or a calling convention side effect to load the PC into a GPR is, IMO, non-standard or non-compliant or non-approved or whatever you want to call it. I would be conservative and not use it. Who knows what incompatibility there will be with some future software or hardware features?

For instance, in the i386 example, we do a call without a matching return. Also, we use a pop to undo the call. Can anyone tell me if this kind of use is an ABI approved one?

This doesn't have anything to do with the ABI, since what happened here isn't visible to any caller or callee. Any machine instruction sequence that has the effect of copying the PC into a GPR is acceptable, but this is basically the only possible solution on i386. If you don't like the call/pop mismatch (though that's supported by the hardware, and is what clang likes to use), you can use the slightly different technique used in my example, which copies the top of stack into a GPR after a call.

This is how all i386 PIC code has always worked.

Quoted 9 lines

Standard API for all userland for all architectures
---------------------------------------------------

The next advantage in using the kernel is standardization.

If the kernel supplies this, then all applications and libraries can use it for all architectures with one single, simple API. Without this, each application/library has to roll its own solution for every architecture-ABI combo it wants to support.

But you can get even more standardization out of a userspace library, because that can work even on non-linux OS's, as well as versions of linux where the new syscall isn't available.

Quoted 19 lines

Furthermore, if this work gets accepted, I plan to add a glibc wrapper for the kernel API. The glibc API would look something like this:

	Allocate a trampoline
	---------------------

	tramp = alloc_tramp();

	Set trampoline parameters
	-------------------------

	init_tramp(tramp, code, data);

	Free the trampoline
	-------------------

	free_tramp(tramp);
Quoted 2 lines

glibc will allocate and manage the code and data tables, handle kernel API details and manage the trampoline table.

glibc could do this already if it wants, even without the syscall, because this can be done in userspace already.

Quoted 18 lines

Secure vs Performant trampoline
-------------------------------

If you recall, in version 1, I presented a trampoline type that is implemented in the kernel. When an application invokes the trampoline, it traps into the kernel and the kernel performs the work of the trampoline.

The disadvantage is that a trip to the kernel is needed. That can be expensive.

The advantage is that the kernel can add security checks before doing the work. Mainly, I am looking at checks that might prevent the trampoline from being used in an ROP/BOP chain. Some half-baked ideas:

- Check that the invocation is at the starting point of the trampoline

Quoted 7 lines

- Check if the trampoline is jumping to an allowed PC

- Check if the trampoline is being invoked from an allowed calling PC or PC range

Allowed PCs can be input using the trampfd API mentioned in version 1. Basically, an array of PCs is written into trampfd.

The source PC will generally not be available if the compiler decided to tail-call optimize the call to the trampoline into a jump.

What's special about these trampolines anyway? Any indirect function call could have these same problems -- an attacker could have overwritten the pointer the same way, whether it's supposed to point to a normal function or it is the target of this trampoline.

For making them a bit safer, userspace could just map the page holding the data pointers/destination address(es) as read-only after initialization.

Quoted 8 lines

Suggestions for other checks are most welcome!

I would like to implement an option in the trampfd API. The user can choose a secure trampoline or a performant trampoline. For a performant trampoline, the kernel will generate the code. For a secure trampoline, the kernel will do the work itself.

Quoted 8 lines

In order to address the FFI_REGISTER ABI in libffi, we could use the secure trampoline. In FFI_REGISTER, the data is pushed on the stack and the code is jumped to without using any registers.

As outlined in version 1, the kernel can push the data address on the stack and write the code address into the PC and return to userland.

For doing all of this, we need trampfd.

We don't need this for FFI_REGISTER. I presented a solution that works in userspace. Even if you want to use a trampoline created by the kernel, there's no reason it needs to trap into the kernel at trampoline execution time. libffi's trampolines already handle this case today.

Quoted 8 lines

Permitting the use of trampfd
-----------------------------

An "exectramp" setting can be implemented in SELinux to selectively allow the use of trampfd for applications.

Madhavan

Applications can use their own userspace trampolines regardless of this setting, so it doesn't provide any additional security benefit by preventing usage of trampfd.

#24 lore raw
Quoted 34 lines · Arvind Sankar
Quoted 9 lines · Madhavan T. Venkataraman
Quoted 5 lines

Which ISA does not support PIC objects? You mentioned i386 below, but i386 does support them, it just needs to copy the PC into a GPR first (see below).

Position Independent Code needs PC-relative branches. I was referring to PC-relative data references. Like RIP-relative data references in X64. i386 ISA does not support this.

I was talking about PC-relative data references too: they are a requirement for PIC code that wants to access any global data. They can be implemented easily on i386 even though it doesn't have an addressing mode that uses the PC.

Quoted 9 lines

Otherwise, using an ABI quirk or a calling convention side effect to load the PC into a GPR is, IMO, non-standard or non-compliant or non-approved or whatever you want to call it. I would be conservative and not use it. Who knows what incompatibility there will be with some future software or hardware features?

For instance, in the i386 example, we do a call without a matching return. Also, we use a pop to undo the call. Can anyone tell me if this kind of use is an ABI approved one?

This doesn't have anything to do with the ABI, since what happened here isn't visible to any caller or callee. Any machine instruction sequence that has the effect of copying the PC into a GPR is acceptable, but this is basically the only possible solution on i386. If you don't like the call/pop mismatch (though that's supported by the hardware, and is what clang likes to use), you can use the slightly different technique used in my example, which copies the top of stack into a GPR after a call.

Quoted 2 lines

This is how all i386 PIC code has always worked.

I have responded to this in my reply to Florian. Basically, I accept the opinion of the reviewers. I will assume that any trick we use to get the current PC into a GPR will not cause ABI compliance issue in the future.

Quoted 5 lines
Quoted 5 lines

Standard API for all userland for all architectures
---------------------------------------------------

The next advantage in using the kernel is standardization.

Quoted 9 lines
Quoted 4 lines

If the kernel supplies this, then all applications and libraries can use it for all architectures with one single, simple API. Without this, each application/library has to roll its own solution for every architecture-ABI combo it wants to support.

But you can get even more standardization out of a userspace library, because that can work even on non-linux OS's, as well as versions of linux where the new syscall isn't available.

Dealing with old vs new kernels is the same as dealing with old vs new libs.

In any case, what you have suggested above has already been suggested before and I have accepted everyone's opinion. Please see my response to Florian's email.

Quoted 17 lines
Quoted 17 lines

Furthermore, if this work gets accepted, I plan to add a glibc wrapper for the kernel API. The glibc API would look something like this:

	Allocate a trampoline
	---------------------

	tramp = alloc_tramp();

	Set trampoline parameters
	-------------------------

	init_tramp(tramp, code, data);

	Free the trampoline
	-------------------
Quoted 8 lines
Quoted 4 lines
	free_tramp(tramp);

glibc will allocate and manage the code and data tables, handle kernel API details and manage the trampoline table.

glibc could do this already if it wants, even without the syscall, because this can be done in userspace already.

I am wary of using ABI tricks or calling convention side-effects. However, since the reviewers feel it is OK, I have accepted that opinion. I have assumed now that any trick to load the current PC into a GPR can be used without any risk. I hope that assumption is correct.

Quoted 20 lines
Quoted 20 lines

Secure vs Performant trampoline
-------------------------------

If you recall, in version 1, I presented a trampoline type that is implemented in the kernel. When an application invokes the trampoline, it traps into the kernel and the kernel performs the work of the trampoline.

The disadvantage is that a trip to the kernel is needed. That can be expensive.

The advantage is that the kernel can add security checks before doing the work. Mainly, I am looking at checks that might prevent the trampoline from being used in an ROP/BOP chain. Some half-baked ideas:

- Check that the invocation is at the starting point of the trampoline

- Check if the trampoline is jumping to an allowed PC

Quoted 9 lines
Quoted 5 lines

- Check if the trampoline is being invoked from an allowed calling PC or PC range

Allowed PCs can be input using the trampfd API mentioned in version 1. Basically, an array of PCs is written into trampfd.

The source PC will generally not be available if the compiler decided to tail-call optimize the call to the trampoline into a jump.

This is still work in progress. But I am thinking that labels can be used. So, if the code is:

	invoke_tramp:
		(*tramp)();

then, invoke_tramp can be supplied as the calling PC.

Similarly, labels can be used in assembly functions as well.

Like I said, I have to think about this more.

Quoted 9 lines

What's special about these trampolines anyway? Any indirect function call could have these same problems -- an attacker could have overwritten the pointer the same way, whether it's supposed to point to a normal function or it is the target of this trampoline.

For making them a bit safer, userspace could just map the page holding the data pointers/destination address(es) as read-only after initialization.

You need to look at version 1 of trampfd for how to do "allowed pcs". As an example, libffi defines ABI handlers for every arch-ABI combo. These ABI handler pointers could be placed in an array in .rodata. Then, the array can be written into trampfd for setting allowed PCS. When the target PC is set for a trampoline, the kernel will check it against allowed PCs and reject it if it has been overwritten.

Quoted 15 lines
Quoted 15 lines

Suggestions for other checks are most welcome!

I would like to implement an option in the trampfd API. The user can choose a secure trampoline or a performant trampoline. For a performant trampoline, the kernel will generate the code. For a secure trampoline, the kernel will do the work itself.

In order to address the FFI_REGISTER ABI in libffi, we could use the secure trampoline. In FFI_REGISTER, the data is pushed on the stack and the code is jumped to without using any registers.

As outlined in version 1, the kernel can push the data address on the stack and write the code address into the PC and return to userland.

Quoted 7 lines
Quoted 1 line

For doing all of this, we need trampfd.

We don't need this for FFI_REGISTER. I presented a solution that works in userspace. Even if you want to use a trampoline created by the kernel, there's no reason it needs to trap into the kernel at trampoline execution time. libffi's trampolines already handle this case today.

libffi handles this using user level dynamic code which needs to be executed. If the security subsystem prevents that, then the dynamic code cannot execute. That is the whole point of this RFC.

Quoted 4 lines
Quoted 4 lines

Permitting the use of trampfd
-----------------------------

Quoted 9 lines
Quoted 4 lines

An "exectramp" setting can be implemented in SELinux to selectively allow the use of trampfd for applications.

Madhavan

Applications can use their own userspace trampolines regardless of this setting, so it doesn't provide any additional security benefit by preventing usage of trampfd.

The background for all of this is that dynamic code such as trampolines need to be placed in a page with executable permissions so they can execute. If security measures such as W^X are present, this will not be possible. Admitted, today some user level tricks exist to get around W^X. I have alluded to those. IMO, they are all security holes and will get plugged sooner or later. Then, these trampolines cannot execute. Currently, there exist security exceptions such as execmem to let them execute. But we would like to do it without making security exceptions.

Madhavan

#25 lore raw
Quoted 11 lines · Madhavan T. Venkataraman
Quoted 4 lines · Arvind Sankar

The source PC will generally not be available if the compiler decided to tail-call optimize the call to the trampoline into a jump.

This is still work in progress. But I am thinking that labels can be used. So, if the code is:

Quoted 8 lines
	invoke_tramp:
		(*tramp)();

then, invoke_tramp can be supplied as the calling PC.

Similarly, labels can be used in assembly functions as well.

Like I said, I have to think about this more.

What I mean is that the kernel won't have access to the actual source PC. If I followed your v1 correctly, it works by making any branch to the trampoline code trigger a page fault. At this point, the PC has already been updated to the trampoline entry, so the only thing the fault handler can know is the return address on the top of the stack, which (a) might not be where the branch actually originated, either because it was a jump, or you've already been hacked and you got here using a ret; (b) is available to userspace anyway.

Quoted 11 lines
Quoted 10 lines

What's special about these trampolines anyway? Any indirect function call could have these same problems -- an attacker could have overwritten the pointer the same way, whether it's supposed to point to a normal function or it is the target of this trampoline.

For making them a bit safer, userspace could just map the page holding the data pointers/destination address(es) as read-only after initialization.

Quoted 6 lines

You need to look at version 1 of trampfd for how to do "allowed pcs". As an example, libffi defines ABI handlers for every arch-ABI combo. These ABI handler pointers could be placed in an array in .rodata. Then, the array can be written into trampfd for setting allowed PCS. When the target PC is set for a trampoline, the kernel will check it against allowed PCs and reject it if it has been overwritten.

I'm not asking how it's implemented. I'm asking what's the point? On a typical linux system, at least on x86, every library function call is an indirect branch. The protection they get is that the dynamic linker can map the pointer table read-only after initializing it.

For the RO mapping, libffi could be mapping both the entire closure structure, as well as the structure that describes the arguments and return types of the function, read-only once they are initialized.

For libffi, there are three indirect branches for every trampoline call with your suggested trampoline: one to get to the trampoline, one to jump to the handler, and one to call the actual user function. If we are particularly concerned about the trampoline to handler branch for some reason, we could just replace it with a direct branch: if the kernel was generating the code, there's no reason to allow the data pointer or code target to be changed after the trampoline was created. It can just hard-code them in the generated code and be done with it. Even with user-space trampolines, you can use a direct call. All you need is libffi-trampoline.so which contains a few thousand trampolines all jumping to one handler, which then decides what to do based on which trampoline was called. Sure libffi currently dispatches to one of 2-3 handlers based on the ABI, but there's no technical reason it couldn't dispatch to just one that handled all the ABIs, and the trampoline could be boiled down to just:
endbr
call handler
ret

Quoted 16 lines
Quoted 8 lines
Quoted 8 lines

In order to address the FFI_REGISTER ABI in libffi, we could use the secure trampoline. In FFI_REGISTER, the data is pushed on the stack and the code is jumped to without using any registers.

As outlined in version 1, the kernel can push the data address on the stack and write the code address into the PC and return to userland.

Quoted 7 lines
Quoted 1 line

For doing all of this, we need trampfd.

We don't need this for FFI_REGISTER. I presented a solution that works in userspace. Even if you want to use a trampoline created by the kernel, there's no reason it needs to trap into the kernel at trampoline execution time. libffi's trampolines already handle this case today.

Quoted 3 lines

libffi handles this using user level dynamic code which needs to be executed. If the security subsystem prevents that, then the dynamic code cannot execute. That is the whole point of this RFC.

/If/ you are using a trampoline created by the kernel, it can just create the one that libffi is using today; which doesn't need trapping into the kernel at execution time.

And if you aren't, you can use the trampoline I wrote, which has no dynamic code, and doesn't need to trap into the kernel at execution time either.

Quoted 24 lines
Quoted 5 lines
Quoted 5 lines

Permitting the use of trampfd
-----------------------------

Quoted 9 lines
Quoted 4 lines

An "exectramp" setting can be implemented in SELinux to selectively allow the use of trampfd for applications.

Madhavan

Applications can use their own userspace trampolines regardless of this setting, so it doesn't provide any additional security benefit by preventing usage of trampfd.

The background for all of this is that dynamic code such as trampolines need to be placed in a page with executable permissions so they can execute. If security measures such as W^X are present, this will not be possible. Admitted, today some user level tricks exist to get around W^X. I have alluded to those. IMO, they are all security holes and will get plugged sooner or later. Then, these trampolines cannot execute. Currently, there exist security exceptions such as execmem to let them execute. But we would like to do it without making security exceptions.

Quoted 1 line

Madhavan

How can you still say this after this whole discussion? Applications can get the exact same functionality as your proposed trampfd using static code, no W^X tricks needed.

This only matters if you have a trampfd that generates _truly_ dynamic code, not just code that can be trivially made static.

#26 lore raw
Quoted 21 lines · Arvind Sankar
Quoted 11 lines · Madhavan T. Venkataraman
Quoted 4 lines · Arvind Sankar

The source PC will generally not be available if the compiler decided to tail-call optimize the call to the trampoline into a jump.

This is still work in progress. But I am thinking that labels can be used. So, if the code is:

Quoted 8 lines
	invoke_tramp:
		(*tramp)();

then, invoke_tramp can be supplied as the calling PC.

Similarly, labels can be used in assembly functions as well.

Like I said, I have to think about this more.

Quoted 8 lines

What I mean is that the kernel won't have access to the actual source PC. If I followed your v1 correctly, it works by making any branch to the trampoline code trigger a page fault. At this point, the PC has already been updated to the trampoline entry, so the only thing the fault handler can know is the return address on the top of the stack, which (a) might not be where the branch actually originated, either because it was a jump, or you've already been hacked and you got here using a ret; (b) is available to userspace anyway.

Like I said, this is work in progress. I have to spend time to figure out how this would work or if this would work. So, let us brainstorm this a little bit.

There are two ways to invoke the trampoline:

(1) By just branching to the trampoline address.

(2) Or, by treating the address as a function pointer and calling it. In the libffi case, it is (2).

If it is (2), it is easier. We can figure out the return address of the call which would be the location after the call instruction.

If it is (1), it is harder as you point out. So, we can support this at least for (2). The user can inform trampfd as to the type of invocation for the trampoline.

For (1), the return address would be that of the call to the function that contains the branch. If the kernel can get that call instruction and figure out the function address, then we can do something.

I admit this is bit hairy at the moment. I have to work it out.

Quoted 19 lines
Quoted 12 lines
Quoted 11 lines

What's special about these trampolines anyway? Any indirect function call could have these same problems -- an attacker could have overwritten the pointer the same way, whether it's supposed to point to a normal function or it is the target of this trampoline.

For making them a bit safer, userspace could just map the page holding the data pointers/destination address(es) as read-only after initialization.

Quoted 6 lines

You need to look at version 1 of trampfd for how to do "allowed pcs". As an example, libffi defines ABI handlers for every arch-ABI combo. These ABI handler pointers could be placed in an array in .rodata. Then, the array can be written into trampfd for setting allowed PCS. When the target PC is set for a trampoline, the kernel will check it against allowed PCs and reject it if it has been overwritten.

Quoted 5 lines

I'm not asking how it's implemented. I'm asking what's the point? On a typical linux system, at least on x86, every library function call is an indirect branch. The protection they get is that the dynamic linker can map the pointer table read-only after initializing it.

The security subsystem is concerned about dynamic code, not the indirect branches set up for dynamic linking.

Quoted 4 lines

For the RO mapping, libffi could be mapping both the entire closure structure, as well as the structure that describes the arguments and return types of the function, read-only once they are initialized.

This has been suggested in some form before. The general problem with this approach is that when the page is still writable, an attacker can inject his code potentially. Making the page read-only after the fact may not help. In specific use cases, it may work. But it is not OK as a general approach to solving this problem.

Quoted 10 lines

For libffi, there are three indirect branches for every trampoline call with your suggested trampoline: one to get to the trampoline, one to jump to the handler, and one to call the actual user function. If we are particularly concerned about the trampoline to handler branch for some reason, we could just replace it with a direct branch: if the kernel was generating the code, there's no reason to allow the data pointer or code target to be changed after the trampoline was created. It can just hard-code them in the generated code and be done with it. Even with user-space trampolines, you can use a direct call. All you need is libffi-trampoline.so which contains a few thousand trampolines all

Quoted 9 lines

jumping to one handler, which then decides what to do based on which trampoline was called. Sure libffi currently dispatches to one of 2-3 handlers based on the ABI, but there's no technical reason it couldn't dispatch to just one that handled all the ABIs, and the trampoline could be boiled down to just:
endbr
call handler
ret

One still needs this trampoline:

load closure in some register
jump to single_handler

In the kernel based solution, the user would specify to the kernel the target PC in a code context.

	pwrite(trampfd, code_context, size, CODE_OFFSET);

code_context itself can be hacked unless it is in .rodata. The allowed_pcs thing exists for apps/libs that are unable or unwilling to place code_context in .rodata.

I would like to not just focus how to solve things for libffi alone.

Quoted 20 lines
Quoted 16 lines
Quoted 8 lines
Quoted 8 lines

In order to address the FFI_REGISTER ABI in libffi, we could use the secure trampoline. In FFI_REGISTER, the data is pushed on the stack and the code is jumped to without using any registers.

As outlined in version 1, the kernel can push the data address on the stack and write the code address into the PC and return to userland.

Quoted 7 lines
Quoted 1 line

For doing all of this, we need trampfd.

We don't need this for FFI_REGISTER. I presented a solution that works in userspace. Even if you want to use a trampoline created by the kernel, there's no reason it needs to trap into the kernel at trampoline execution time. libffi's trampolines already handle this case today.

Quoted 3 lines

libffi handles this using user level dynamic code which needs to be executed. If the security subsystem prevents that, then the dynamic code cannot execute. That is the whole point of this RFC.

Quoted 8 lines

/If/ you are using a trampoline created by the kernel, it can just create the one that libffi is using today; which doesn't need trapping into the kernel at execution time.

And if you aren't, you can use the trampoline I wrote, which has no dynamic code, and doesn't need to trap into the kernel at execution time either.

The kernel based solution gives you the opportunity to make additional security checks at the time a trampoline is invoked. A purely user level solution cannot do that. E.g., I would like to prevent even the minimal trampoline from being used in BOP/ROP chains.

Quoted 24 lines
Quoted 24 lines
Quoted 5 lines
Quoted 5 lines

Permitting the use of trampfd
-----------------------------

Quoted 9 lines
Quoted 4 lines

An "exectramp" setting can be implemented in SELinux to selectively allow the use of trampfd for applications.

Madhavan

Applications can use their own userspace trampolines regardless of this setting, so it doesn't provide any additional security benefit by preventing usage of trampfd.

The background for all of this is that dynamic code such as trampolines need to be placed in a page with executable permissions so they can execute. If security measures such as W^X are present, this will not be possible. Admitted, today some user level tricks exist to get around W^X. I have alluded to those. IMO, they are all security holes and will get plugged sooner or later. Then, these trampolines cannot execute. Currently, there exist security exceptions such as execmem to let them execute. But we would like to do it without making security exceptions.

Quoted 9 lines
Quoted 1 line

Madhavan

How can you still say this after this whole discussion? Applications can get the exact same functionality as your proposed trampfd using static code, no W^X tricks needed.

This only matters if you have a trampfd that generates _truly_ dynamic code, not just code that can be trivially made static.

How can *you* still say this after all this discussion?

I have already explained all of this. The trivial bootstrap trampoline can be provided in a user library as well the kernel. The user land solution provides a fast trampoline that does the job. The kernel solution is slower but allows for additional security checks that a user land solution does not allow. IMO, it should be a choice what type of trampoline the user wants.

And this is not just for libffi that we can somehow do this within libffi. I would like to provide something so that the maintainers of other dynamic code can use it to convert their dynamic code to static code when their dynamic code is a lot more complex that the libffi trampoline.

I am already willing to implement a user land only solution. I don't see the problem.

Madhavan

#27 lore raw
In reply to Madhavan T. Venkataraman

  > As mentioned before, if the ISA supports PC-relative data references > (e.g., X86 64-bit platforms support RIP-relative data references) > then we can pass data to that code by placing the code and data in > adjacent pages. So, you can implement the trampoline table for X64. > i386 does not support it.

i386 does not need this either.

You make a PC-relative call, read the return address into a register, and then do register-relative data access.

either:
  call get_pc ; PC-relative call
  mov  eax, [eax+x]

get_pc:
  mov eax, [esp]
  ret

or if you don't mind disrupting the return address predictor:

 call +0
 pop eax
 mov eax, [eax+x]

where x is computed by the static linker, and eax can vary. The same way PIC code normally works I think.

Also the data and code do not have to be on adjacent pages in this scheme.

You can just map an entire .dll/.so additional times.
 A little wasteful, yes, but quite convenient. Factor the thunks/trampolines into their own .so/.dll to make it not very wasteful.

The functions do not even have to be a fixed distance from their array element either. Architectures that are "naturally" position independent (amd64, arm64) do not even need any assembly to do this. Just use C and stamp out multiple copies with the C preprocessor.
But arm32 and x86 do tend to need some assembly, depending on compilation model, etc. (i.e. on Windows at least).

Is there any architecture that lacks both PC-relative data access and PC-relative call, with ability to materialize the return address into a register?

Given codegen that is not "arbitrary", you make it "data driven" and you don't need kernel support. Unless there really exists architectures that cannot reasonably synthesize PC-relative data access. ?

As long as you can use mmap or similar to map a .so/.dll any number of times, to produce any number of thunks.

On Windows that this is CreateFileMapping(SEC_IMAGE) + MapViewOfFile. i.e. not dlopen and not LoadLibrary, they just increment a reference count and return the original mapping.

 - Jay

From: Libffi-discuss <[email protected]> on behalf of Madhavan T. Venkataraman via Libffi-discuss <[email protected]>
Sent: Thursday, September 17, 2020 3:36 PM
To: Florian Weimer <[email protected]>
Cc: [email protected] <[email protected]>; [email protected] <[email protected]>; [email protected] <[email protected]>; [email protected] <[email protected]>; [email protected] <[email protected]>; [email protected] <[email protected]>; [email protected] <[email protected]>; [email protected] <[email protected]>; [email protected] <[email protected]>; [email protected] <[email protected]>
Subject: Re: [PATCH v2 0/4] [RFC] Implement Trampoline File Descriptor

Quoted 20 lines · Florian Weimer

* madvenka:

Quoted 11 lines

Examples of trampolines
=======================

libffi (A Portable Foreign Function Interface Library):

libffi allows a user to define functions with an arbitrary list of arguments and return value through a feature called "Closures". Closures use trampolines to jump to ABI handlers that handle calling conventions and call a target function. libffi is used by a lot of different applications. To name a few:

Quoted 6 lines

       - Python
       - Java
       - Javascript
       - Ruby FFI
       - Lisp
       - Objective C

Quoted 7 lines

libffi does not actually need this.  It currently collocates trampolines and the data they need on the same page, but that's actually unecessary.  It's possible to avoid doing this just by changing libffi, without any kernel changes.

I think this has already been done for the iOS port.

The trampoline table that has been implemented for the iOS port (MACH) is based on PC-relative data referencing. That is, the code and data are placed in adjacent pages so that the code can access the data using an address relative to the current PC.

This is an ISA feature that is not supported on all architectures.

Now, if it is a performance feature, we can include some architectures and exclude others. But this is a security feature. IMO, we cannot exclude any architecture even if it is a legacy one as long as Linux is running on the architecture. So, we need a solution that does not assume any specific ISA feature.

Quoted 12 lines
Quoted 11 lines

The code for trampoline X in the trampoline table is:

       load    &code_table[X], code_reg
       load    (code_reg), code_reg
       load    &data_table[X], data_reg
       load    (data_reg), data_reg
       jump    code_reg

The addresses &code_table[X] and &data_table[X] are baked into the trampoline code. So, PC-relative data references are not needed. The user can modify code_table[X] and data_table[X] dynamically.

Quoted 6 lines

You can put this code into the libffi shared object and map it from there, just like the rest of the libffi code.  To get more trampolines, you can map the page containing the trampolines multiple times, each instance preceded by a separate data page with the control information.

If you put the code in the libffi shared object, how do you pass data to the code at runtime? If the code we are talking about is a function, then there is an ABI defined way to pass data to the function. But if the code we are talking about is some arbitrary code such as a trampoline, there is no ABI defined way to pass data to it except in a couple of platforms such as HP PA-RISC that have support for function descriptors in the ABI itself.

As mentioned before, if the ISA supports PC-relative data references (e.g., X86 64-bit platforms support RIP-relative data references) then we can pass data to that code by placing the code and data in adjacent pages. So, you can implement the trampoline table for X64. i386 does not support it.

Quoted 3 lines

I think the previous patch submission has also resulted in several comments along those lines, so I'm not sure why you are reposting this.

IIRC, I have answered all of those comments by mentioning the point that we need to support all architectures without requiring special ISA features. Taking the kernel's help in this is one solution.

Quoted 10 lines
Quoted 8 lines

libffi
======

I have implemented my solution for libffi and provided the changes for X86 and ARM, 32-bit and 64-bit. Here is the reference patch:

https://nam10.safelinks.protection.outlook.com/?url=http:%2F%2Flinux.microsoft.com%2F~madvenka%2Flibffi%2Flibffi.v2.txt&amp;data=02%7C01%7C%7C25b693de3de342e1e02c08d85b1f6af5%7C84df9e7fe9f640afb435aaaaaaaaaaaa%7C1%7C0%7C637359537776320186&amp;sdata=b%2BqpgrUoSy%2FrprtE4xgd0%2FhPiFxTOh69yYjlTkgSQoc%3D&amp;reserved=0

The URL does not appear to work, I get a 403 error.

I apologize for that. That site is supposed to be accessible publicly. I will contact the administrator and get this resolved.

Sorry for the annoyance.

Quoted 9 lines
Quoted 4 lines

If the trampfd patchset gets accepted, I will send the libffi changes to the maintainers for a review. BTW, I have also successfully executed the libffi self tests.

I have not seen your libffi changes, but I expect that the complexity is about the same as a userspace-only solution.

I agree. The complexity is about the same. But the support is for all architectures. Once the common code is in place, the changes for each architecture are trivial.

Madhavan

Quoted 5 lines

Cc:ing libffi upstream for awareness.  The start of the thread is here:

<https://nam10.safelinks.protection.outlook.com/?url=https%3A%2F%2Flore.kernel.org%2Flinux-api%2F20200916150826.5990-1-madvenka%40linux.microsoft.com%2F&amp;data=02%7C01%7C%7C25b693de3de342e1e02c08d85b1f6af5%7C84df9e7fe9f640afb435aaaaaaaaaaaa%7C1%7C0%7C637359537776320186&amp;sdata=nIIDBh6F%2Fit%2BklEWLzuy0iiKCCf%2BxRf4JNZS8LbFkOY%3D&amp;reserved=0>

_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

#28 lore raw

v2 cover Implement Trampoline File Descriptor

In reply to a message not in the archive

From: "Madhavan T. Venkataraman" <[email protected]>

Introduction
============

Dynamic code is used in many different user applications. Dynamic code is often generated at runtime. Dynamic code can also just be a pre-defined sequence of machine instructions in a data buffer. Examples of dynamic code are trampolines, JIT code, DBT code, etc.

Dynamic code is placed either in a data page or in a stack page. In order to execute dynamic code, the page it resides in needs to be mapped with execute permissions. Writable pages with execute permissions provide an attack surface for hackers. Attackers can use this to inject malicious code, modify existing code or do other harm.

To mitigate this, LSMs such as SELinux implement W^X. That is, they may not allow pages to have both write and execute permissions. This prevents dynamic code from executing and blocks applications that use it. To allow genuine applications to run, exceptions have to be made for them (by setting execmem, etc) which opens the door to security issues.

The W^X implementation today is not complete. There exist many user level tricks that can be used to load and execute dynamic code. E.g.,

- Load the code into a file and map the file with R-X.

- Load the code in an RW- page. Change the permissions to R--. Then, change the permissions to R-X.

- Load the code in an RW- page. Remap the page with R-X to get a separate mapping to the same underlying physical page.

IMO, these are all security holes as an attacker can exploit them to inject his own code.

In the future, these holes will definitely be closed. For instance, LSMs (such as the IPE proposal [1]) may only allow code in properly signed object files to be mapped with execute permissions. This will do two things:

- user level tricks using anonymous pages will fail as anonymous pages have no file identity

- loading the code in a temporary file and mapping it with R-X will fail as the temporary file would not have a signature

We need a way to execute such code without making security exceptions. Trampolines are a good example of dynamic code. A couple of examples of trampolines are given below. My first use case for this RFC is libffi.

Examples of trampolines
=======================

libffi (A Portable Foreign Function Interface Library):

libffi allows a user to define functions with an arbitrary list of arguments and return value through a feature called "Closures". Closures use trampolines to jump to ABI handlers that handle calling conventions and call a target function. libffi is used by a lot of different applications. To name a few:

- Python
- Java
- Javascript
- Ruby FFI
- Lisp
- Objective C

GCC nested functions:

GCC has traditionally used trampolines for implementing nested functions. The trampoline is placed on the user stack. So, the stack needs to be executable.

Currently available solution
============================

One solution that has been proposed to allow trampolines to be executed without making security exceptions is Trampoline Emulation. See:

https://pax.grsecurity.net/docs/emutramp.txt

In this solution, the kernel recognizes certain sequences of instructions as "well-known" trampolines. When such a trampoline is executed, a page fault happens because the trampoline page does not have execute permission. The kernel recognizes the trampoline and emulates it. Basically, the kernel does the work of the trampoline on behalf of the application.

Currently, the emulated trampolines are the ones used in libffi and GCC nested functions. To my knowledge, only X86 is supported at this time.

As noted in emutramp.txt, this is not a generic solution. For every new trampoline that needs to be supported, new instruction sequences need to be recognized by the kernel and emulated. And this has to be done for every architecture that needs to be supported.

emutramp.txt notes the following:

"... the real solution is not in emulation but by designing a kernel API for runtime code generation and modifying userland to make use of it."

Solution proposed in this RFC
=============================

From this RFC's perspective, there are two scenarios for dynamic code:

Scenario 1
----------

We know what code we need only at runtime. For instance, JIT code generated for frequently executed Java methods. Only at runtime do we know what methods need to be JIT compiled. Such code cannot be statically defined. It has to be generated at runtime.

Scenario 2
----------

We know what code we need in advance. User trampolines are a good example of this. It is possible to define such code statically with some help from the kernel.

This RFC addresses (2). (1) needs a general purpose trusted code generator and is out of scope for this RFC.

For (2), the solution is to convert dynamic code to static code and place it in a source file. The binary generated from the source can be signed. The kernel can use signature verification to authenticate the binary and allow the code to be mapped and executed.

The problem is that the static code has to be able to find the data that it needs when it executes. For functions, the ABI defines the way to pass parameters. But, for arbitrary dynamic code, there isn't a standard ABI compliant way to pass data to the code for most architectures. Each instance of dynamic code defines its own way. For instance, co-location of code and data and PC-relative data referencing are used in cases where the ISA supports it.

We need one standard way that would work for all architectures and ABIs.

The solution proposed here is:

1. Write the static code assuming that the data needed by the code is already pointed to by a designated register.

2. Get the kernel to supply a small universal trampoline that does the following:

- Load the address of the data in a designated register
- Load the address of the static code in a designated register
- Jump to the static code

User code would use a kernel supplied API to create and map the trampoline. The address values would be baked into the code so that no special ISA features are needed.

To conserve memory, the kernel will pack as many trampolines as possible in a page and provide a trampoline table to user code. The table itself is managed by the user.

Trampoline File Descriptor (trampfd)
==========================

I am proposing a kernel API using anonymous file descriptors that can be used to create the trampolines. The API is described in patch 1/4 of this patchset. I provide a summary here:

- Create a trampoline file object

- Write a code descriptor into the trampoline file and specify:

- the number of trampolines desired
- the name of the code register
- user pointer to a table of code addresses, one address per trampoline

- Write a data descriptor into the trampoline file and specify:

- the name of the data register
- user pointer to a table of data addresses, one address per trampoline

- mmap() the trampoline file. The kernel generates a table of trampolines in a page and returns the trampoline table address

- munmap() a trampoline file mapping

- Close the trampoline file

Each mmap() will only map a single base page. Large pages are not supported.

A trampoline file can only be mapped once in an address space.

Trampoline file mappings cannot be shared across address spaces. So, sending the trampoline file descriptor over a unix domain socket and mapping it in another process will not work.

It is recommended that the code descriptor and the code table be placed in the .rodata section so an attacker cannot modify them.

Trampoline use and reuse
========================

The code for trampoline X in the trampoline table is:

load &code_table[X], code_reg
load (code_reg), code_reg
load &data_table[X], data_reg
load (data_reg), data_reg
jump code_reg

The addresses &code_table[X] and &data_table[X] are baked into the trampoline code. So, PC-relative data references are not needed. The user can modify code_table[X] and data_table[X] dynamically.

For instance, within libffi, the same trampoline X can be used for different closures at different times by setting:

	data_table[X] = closure;
	code_table[X] = ABI handling code;

Advantages of the Trampoline File Descriptor approach
=====================================================

- Using this support from the kernel, dynamic code can be converted to static code with a little effort so applications and libraries can move to a more secure model. In the simplest cases such as libffi, dynamic code can even be eliminated.

- This initial work is targeted towards X86 and ARM. But it can be supported easily on all architectures. We don't need any special ISA features such as PC-relative data referencing.

- The only code generation needed is for this small, universal trampoline.

- The kernel does not have to deal with any ABI issues in the generation of this trampoline.

- The kernel provides a trampoline table to conserve memory.

- An SELinux setting called "exectramp" can be implemented along the lines of "execmem", "execstack" and "execheap" to selectively allow the use of trampolines on a per application basis.

- In version 1, a trip to the kernel was required to execute the trampoline. In version 2, that is not required. So, there are no performance concerns in this approach.

libffi
======

I have implemented my solution for libffi and provided the changes for X86 and ARM, 32-bit and 64-bit. Here is the reference patch:

http://linux.microsoft.com/~madvenka/libffi/libffi.v2.txt

If the trampfd patchset gets accepted, I will send the libffi changes to the maintainers for a review. BTW, I have also successfully executed the libffi self tests.

Work that is pending
====================

- I am working on implementing the SELinux setting - "exectramp".

- I have a test program to test the kernel API. I am working on adding it to selftests.

References
==========

[1] https://microsoft.github.io/ipe/
---

Changelog:

v1
Introduced the Trampfd feature.

v2
- Changed the system call. Version 2 does not support different trampoline types and their associated type structures. It only supports a kernel generated trampoline.

The system call now returns information to the user that is used to define trampoline descriptors. E.g., the maximum number of trampolines that can be packed in a single page.

- Removed all the trampoline contexts such as register contexts and stack contexts. This is based on the feedback that the kernel should not have to worry about ABI issues and H/W features that may deal with the context of a process.

- Removed the need to make a trip into the kernel on trampoline invocation. This is based on the feedback about performance.

- Removed the ability to share trampolines across address spaces. This would have made sense to different trampoline types based on their semantics. But since I support only one specific trampoline, sharing does not make sense.

- Added calls to specify trampoline descriptors that the kernel uses to generate trampolines.

- Added architecture-specific code to generate the small, universal trampoline for X86 32 and 64-bit, ARM 32 and 64-bit.

- Implemented the trampoline table in a page.
Madhavan T. Venkataraman (4):
Implement the kernel API for the trampoline file descriptor. Implement i386 and X86 support for the trampoline file descriptor. Implement ARM64 support for the trampoline file descriptor. Implement ARM support for the trampoline file descriptor.

 arch/arm/include/uapi/asm/ptrace.h     |  21 +++
 arch/arm/kernel/Makefile               |   1 +
 arch/arm/kernel/trampfd.c              | 124 +++++++++++++
 arch/arm/tools/syscall.tbl             |   1 +
 arch/arm64/include/asm/unistd.h        |   2 +-
 arch/arm64/include/asm/unistd32.h      |   2 +
 arch/arm64/include/uapi/asm/ptrace.h   |  59 ++++++
 arch/arm64/kernel/Makefile             |   2 +
 arch/arm64/kernel/trampfd.c            | 244 +++++++++++++++++++++++++
 arch/x86/entry/syscalls/syscall_32.tbl |   1 +
 arch/x86/entry/syscalls/syscall_64.tbl |   1 +
 arch/x86/include/uapi/asm/ptrace.h     |  38 ++++
 arch/x86/kernel/Makefile               |   1 +
 arch/x86/kernel/trampfd.c              | 238 ++++++++++++++++++++++++
 fs/Makefile                            |   1 +
 fs/trampfd/Makefile                    |   5 +
 fs/trampfd/trampfd_fops.c              | 241 ++++++++++++++++++++++++
 fs/trampfd/trampfd_map.c               | 142 ++++++++++++++
 include/linux/syscalls.h               |   2 +
 include/linux/trampfd.h                |  49 +++++
 include/uapi/asm-generic/unistd.h      |   4 +-
 include/uapi/linux/trampfd.h           | 184 +++++++++++++++++++
 init/Kconfig                           |   7 +
 kernel/sys_ni.c                        |   3 +
 24 files changed, 1371 insertions(+), 2 deletions(-)
 create mode 100644 arch/arm/kernel/trampfd.c
 create mode 100644 arch/arm64/kernel/trampfd.c
 create mode 100644 arch/x86/kernel/trampfd.c
 create mode 100644 fs/trampfd/Makefile
 create mode 100644 fs/trampfd/trampfd_fops.c
 create mode 100644 fs/trampfd/trampfd_map.c
 create mode 100644 include/linux/trampfd.h
 create mode 100644 include/uapi/linux/trampfd.h
Signature · 1 line
2.17.1
#29 lore raw

RFC PATCH v2 1/4 fs/trampfd: Implement the trampoline file descriptor API

From: "Madhavan T. Venkataraman" <[email protected]>

Introduction
============

Dynamic code is used in many different user applications. Dynamic code is often generated at runtime. Dynamic code can also just be a pre-defined sequence of machine instructions in a data buffer. Examples of dynamic code are trampolines, JIT code, DBT code, etc.

Dynamic code is placed either in a data page or in a stack page. In order to execute dynamic code, the page it resides in needs to be mapped with execute permissions. Writable pages with execute permissions provide an attack surface for hackers. Attackers can use this to inject malicious code, modify existing code or do other harm.

To mitigate this, LSMs such as SELinux implement W^X. That is, they may not allow pages to have both write and execute permissions. This prevents dynamic code from executing and blocks applications that use it. To allow genuine applications to run, exceptions have to be made for them (by setting execmem, etc) which opens the door to security issues.

The W^X implementation today is not complete. There exist many user level tricks that can be used to load and execute dynamic code. E.g.,

- Load the code into a file and map the file with R-X.

- Load the code in an RW- page. Change the permissions to R--. Then, change the permissions to R-X.

- Load the code in an RW- page. Remap the page with R-X to get a separate mapping to the same underlying physical page.

IMO, these are all security holes as an attacker can exploit them to inject his own code.

In the future, these holes will definitely be closed. For instance, LSMs (such as the IPE proposal [1]) may only allow code in properly signed object files to be mapped with execute permissions. This will do two things:

- user level tricks using anonymous pages will fail as anonymous pages have no file identity

- loading the code in a temporary file and mapping it with R-X will fail as the temporary file would not have a signature

We need a way to execute such code without making security exceptions. Trampolines are a good example of dynamic code. A couple of examples of trampolines are given below. My first use case for this RFC is libffi.

Solution
========

The solution is to convert dynamic code to static code and place it in a source file. The binary generated from the source can be signed. The kernel can use signature verification to authenticate the binary and allow the code to be mapped and executed.

The problem is that the static code has to be able to find the data that it needs when it executes. For functions, the ABI defines the way to pass parameters. But, for arbitrary dynamic code, there isn't a standard ABI compliant way to pass data to the code for most architectures. Each instance of dynamic code defines its own way. For instance, co-location of code and data and PC-relative data referencing are used in cases where the ISA supports it.

We need one standard way that would work for all architectures and ABIs.

The solution has two parts:

1. The maintainer of the code writes the static code assuming that the data needed by the code is already pointed to by a designated register.

2. The kernel supplies a small universal trampoline that does the following:

- Load the address of the data in a designated register
- Load the address of the static code in a designated register
- Jump to the static code

User code would use a kernel supplied API to create and map the trampoline. The address values would be baked into the code so that no special ISA features are needed.

To conserve memory, the kernel will pack as many trampolines as possible in a page and provide a trampoline table to user code. The table itself is managed by the user.

Kernel API
==========

A kernel API based on anonymous file descriptors is defined to create trampolines. The following sections describe the API.

Create trampfd
==============

This feature introduces a new trampfd system call.

	struct trampfd_info	info;
	int			trampfd;

	trampfd = syscall(440, &info);

The kernel creates a trampoline file object and returns the following items in info:

ntrampolines
The number of trampolines that can be created with one trampfd. The user may create fewer trampolines if he wishes.

code_size
The size of each trampoline.

code_offset
The file offset to be used in mmap() to map the trampoline code.

Initialize trampfd
==================

A trampfd is initialized in this manner:

	struct trampfd_code	code;
	struct trampfd_data	data;

	/*
	 * Code descriptor.
	 */
	code.ntrampolines = number of desired trampolines;
	code.reg = code register name;
	code.table = array of code addresses

	/*
	 * Data descriptor.
	 */
	data.reg = data register name;
	data.table = array of data addresses

	pwrite(trampfd, &code, sizeof(init), TRAMPFD_CODE);
	pwrite(trampfd, &data, sizeof(init), TRAMPFD_DATA);

The register names are defined in ptrace.h (reg_32_name and reg_64_name).

It is recommended that the code descriptor and code array be placed in the .rodata section so that an attacker cannot modify its contents.

Instead of pwrite(), the user can also do lseek() and write().

Map trampfd
===========

The user uses mmap() to map the trampoline table into user address space.

	len = info.code_size * code.ntrampolines;
	prot = PROT_READ | PROT_EXEC;
	flags = MAP_PRIVATE;
	offset = info.code_offset;

	trampoline_table = mmap(NULL, len, prot, flags, trampfd, offset);

The kernel generates the trampoline table. The code for trampoline X in the table is:

load &code_table[X], code_reg
load (code_reg), code_reg
load &data_table[X], data_reg
load (data_reg), data_reg
jump code_reg

Each mmap() will only map a single base page. Large pages are not supported.

A trampoline file can only be mmapped once in an address space.

Trampoline file mappings cannot be shared across address spaces. So, sending the trampoline file descriptor over a unix domain socket and mapping it in another process will not work.

The trampoline code is generated with &code_table[X] and &data_table[X] hard coded in it. But code_table[X] and data_table[X] can be modified by user code dynamically so supply the code and data to trampoline X.

Trampoline table management
===========================

The user manages the trampoline table. The address of trampoline X is:

	trampoline_table + info.code_size * X;

Prior to invoking trampoline X, the user must initialize code_table[X] and data_table[X].

Unmap trampfd
=============

Once the user is done with the trampoline table, it may be unmapped:

	len = info.code_size * code.ntrampolines;
	munmap(trampoline_table, len);

Remove trampfd
==============

To remove the trampfd:

	close(trampfd);
---
 fs/Makefile                       |   1 +
 fs/trampfd/Makefile               |   5 +
 fs/trampfd/trampfd_fops.c         | 241 ++++++++++++++++++++++++++++++
 fs/trampfd/trampfd_map.c          | 142 ++++++++++++++++++
 include/linux/syscalls.h          |   2 +
 include/linux/trampfd.h           |  49 ++++++
 include/uapi/asm-generic/unistd.h |   4 +-
 include/uapi/linux/trampfd.h      | 184 +++++++++++++++++++++++
 init/Kconfig                      |   7 +
 kernel/sys_ni.c                   |   3 +
 10 files changed, 637 insertions(+), 1 deletion(-)
 create mode 100644 fs/trampfd/Makefile
 create mode 100644 fs/trampfd/trampfd_fops.c
 create mode 100644 fs/trampfd/trampfd_map.c
 create mode 100644 include/linux/trampfd.h
 create mode 100644 include/uapi/linux/trampfd.h
fs/Makefile +1 -0
index 2ce5112b02c8..227761302000 100644
@@ -136,3 +136,4 @@ obj-$(CONFIG_EFIVAR_FS)		+= efivarfs/
 obj-$(CONFIG_EROFS_FS)		+= erofs/
 obj-$(CONFIG_VBOXSF_FS)		+= vboxsf/
 obj-$(CONFIG_ZONEFS_FS)		+= zonefs/
+obj-$(CONFIG_TRAMPFD)		+= trampfd/
fs/trampfd/Makefile new file +5 -0
new file mode 100644
index 000000000000..ae09a0b1f841
@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: GPL-2.0
+
+obj-$(CONFIG_TRAMPFD) += trampfd.o
+
+trampfd-y += trampfd_fops.o trampfd_map.o
fs/trampfd/trampfd_fops.c new file +241 -0

241 lines not on this page · raw message

fs/trampfd/trampfd_map.c new file +142 -0

142 lines not on this page · raw message

include/linux/syscalls.h +2 -0
index b951a87da987..91f55ff3cdac 100644
@@ -69,6 +69,7 @@ union bpf_attr;
 struct io_uring_params;
 struct clone_args;
 struct open_how;
+struct trampfd_info;
 
 #include <linux/types.h>
 #include <linux/aio_abi.h>
@@ -1005,6 +1006,7 @@ asmlinkage long sys_pidfd_send_signal(int pidfd, int sig,
 				       siginfo_t __user *info,
 				       unsigned int flags);
 asmlinkage long sys_pidfd_getfd(int pidfd, int fd, unsigned int flags);
+asmlinkage long sys_trampfd(struct trampfd_info *info);
 
 /*
  * Architecture-specific system calls
include/linux/trampfd.h new file +49 -0

49 lines not on this page · raw message

include/uapi/asm-generic/unistd.h +3 -1
index f4a01305d9a6..3b1ad4b75c7a 100644
@@ -857,9 +857,11 @@ __SYSCALL(__NR_openat2, sys_openat2)
 __SYSCALL(__NR_pidfd_getfd, sys_pidfd_getfd)
 #define __NR_faccessat2 439
 __SYSCALL(__NR_faccessat2, sys_faccessat2)
+#define __NR_trampfd 440
+__SYSCALL(__NR_trampfd, sys_trampfd)
 
 #undef __NR_syscalls
-#define __NR_syscalls 440
+#define __NR_syscalls 441
 
 /*
  * 32 bit systems traditionally used different
include/uapi/linux/trampfd.h new file +184 -0

184 lines not on this page · raw message

init/Kconfig +7 -0
index 0498af567f70..bb3ecca5b8e7 100644
@@ -2313,3 +2313,10 @@ config ARCH_HAS_SYNC_CORE_BEFORE_USERMODE
 # <asm/syscall_wrapper.h>.
 config ARCH_HAS_SYSCALL_WRAPPER
 	def_bool n
+
+config TRAMPFD
+	bool "Enable trampfd() system call"
+	depends on MMU
+	help
+	  Enable the trampfd() system call that allows a process to map
+	  kernel generated trampolines within its address space.
kernel/sys_ni.c +3 -0
index 3b69a560a7ac..93c5972aba85 100644
@@ -349,6 +349,9 @@ COND_SYSCALL(pkey_mprotect);
 COND_SYSCALL(pkey_alloc);
 COND_SYSCALL(pkey_free);
 
+/* Trampoline fd */
+COND_SYSCALL(trampfd);
+
 
 /*
  * Architecture specific weak syscall entries.
Signature · 1 line
2.17.1
#30 lore raw

RFC PATCH v2 2/4 x86/trampfd: Provide support for the trampoline file descriptor

In reply to [email protected]

From: "Madhavan T. Venkataraman" <[email protected]>

- Define architecture specific register names
- Architecture specific functions for:
- system call init
- code descriptor check
- data descriptor check
- Fill a page with a trampoline table for:
- 32-bit user process
- 64-bit user process

---
 arch/x86/entry/syscalls/syscall_32.tbl |   1 +
 arch/x86/entry/syscalls/syscall_64.tbl |   1 +
 arch/x86/include/uapi/asm/ptrace.h     |  38 ++++
 arch/x86/kernel/Makefile               |   1 +
 arch/x86/kernel/trampfd.c              | 238 +++++++++++++++++++++++++
 5 files changed, 279 insertions(+)
 create mode 100644 arch/x86/kernel/trampfd.c
arch/x86/entry/syscalls/syscall_32.tbl +1 -0
index d8f8a1a69ed1..d4f17806c9ab 100644
@@ -443,3 +443,4 @@
 437	i386	openat2			sys_openat2
 438	i386	pidfd_getfd		sys_pidfd_getfd
 439	i386	faccessat2		sys_faccessat2
+440	i386	trampfd			sys_trampfd
arch/x86/entry/syscalls/syscall_64.tbl +1 -0
index 78847b32e137..91b37bc4b6f0 100644
@@ -360,6 +360,7 @@
 437	common	openat2			sys_openat2
 438	common	pidfd_getfd		sys_pidfd_getfd
 439	common	faccessat2		sys_faccessat2
+440	common	trampfd			sys_trampfd
 
 #
 # x32-specific system call numbers start at 512 to avoid cache impact
arch/x86/include/uapi/asm/ptrace.h +38 -0
index 85165c0edafc..b4be362929b3 100644
@@ -9,6 +9,44 @@
 
 #ifndef __ASSEMBLY__
 
+/*
+ * These register names are to be used by 32-bit applications.
+ */
+enum reg_32_name {
+	x32_min = 0,
+	x32_eax = x32_min,
+	x32_ebx,
+	x32_ecx,
+	x32_edx,
+	x32_esi,
+	x32_edi,
+	x32_ebp,
+	x32_max,
+};
+
+/*
+ * These register names are to be used by 64-bit applications.
+ */
+enum reg_64_name {
+	x64_min = x32_max,
+	x64_rax = x64_min,
+	x64_rbx,
+	x64_rcx,
+	x64_rdx,
+	x64_rsi,
+	x64_rdi,
+	x64_rbp,
+	x64_r8,
+	x64_r9,
+	x64_r10,
+	x64_r11,
+	x64_r12,
+	x64_r13,
+	x64_r14,
+	x64_r15,
+	x64_max,
+};
+
 #ifdef __i386__
 /* this struct defines the way the registers are stored on the
    stack during a system call. */
arch/x86/kernel/Makefile +1 -0
index e77261db2391..feb7f4f311fd 100644
@@ -157,3 +157,4 @@ ifeq ($(CONFIG_X86_64),y)
 endif
 
 obj-$(CONFIG_IMA_SECURE_AND_OR_TRUSTED_BOOT)	+= ima_arch.o
+obj-$(CONFIG_TRAMPFD)				+= trampfd.o
arch/x86/kernel/trampfd.c new file +238 -0

238 lines not on this page · raw message

Signature · 1 line
2.17.1
#31 lore raw

Re: [PATCH v2 2/4] [RFC] x86/trampfd: Provide support for the trampoline file descriptor

[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch]

Hi,

[FYI, it's a private test report for your RFC patch.]
[auto build test WARNING on arm64/for-next/core]
[also build test WARNING on arm/for-next linus/master v5.9-rc6] [cannot apply to next-20200922]
[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]

url:    https://github.com/0day-ci/linux/commits/madvenka-linux-microsoft-com/fs-trampfd-Implement-the-trampoline-file-descriptor-API/20200923-065340
base:   https://git.kernel.org/pub/scm/linux/kernel/git/arm64/linux.git for-next/core
config: s390-randconfig-r001-20200923 (attached as .config)
compiler: clang version 12.0.0 (https://github.com/llvm/llvm-project d6ac649ccda289ecc2d2c0cb51892d57e8ec328c)

reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# install s390 cross compiling tool for clang build
# apt-get install binutils-s390x-linux-gnu
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross ARCH=s390

If you fix the issue, kindly add following tag as appropriate

All warnings (new ones prefixed by >>):

>> <stdin>:1526:2: warning: syscall trampfd not implemented [-W#warnings]
   #warning syscall trampfd not implemented
    ^
   1 warning generated.
--
>> <stdin>:1526:2: warning: syscall trampfd not implemented [-W#warnings]
   #warning syscall trampfd not implemented
    ^

1 warning generated.
--
In file included from arch/s390/include/asm/diag.h:12:
In file included from include/linux/if_ether.h:19:
In file included from include/linux/skbuff.h:31:
In file included from include/linux/dma-mapping.h:11:
In file included from include/linux/scatterlist.h:9:
In file included from arch/s390/include/asm/io.h:72:
include/asm-generic/io.h:490:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]

           val = __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + addr));
                                                           ~~~~~~~~~~ ^
   include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from macro '__le32_to_cpu'
   #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x))
                                                             ^
   include/uapi/linux/swab.h:119:21: note: expanded from macro '__swab32'
           ___constant_swab32(x) :                 \
                              ^
   include/uapi/linux/swab.h:21:12: note: expanded from macro '___constant_swab32'
           (((__u32)(x) & (__u32)0x00ff0000UL) >>  8) |            \
                     ^
   In file included from arch/s390/kernel/asm-offsets.c:11:
   In file included from include/linux/kvm_host.h:32:
   In file included from include/linux/kvm_para.h:5:
   In file included from include/uapi/linux/kvm_para.h:36:
   In file included from arch/s390/include/asm/kvm_para.h:25:
   In file included from arch/s390/include/asm/diag.h:12:
   In file included from include/linux/if_ether.h:19:
   In file included from include/linux/skbuff.h:31:
   In file included from include/linux/dma-mapping.h:11:
   In file included from include/linux/scatterlist.h:9:
   In file included from arch/s390/include/asm/io.h:72:
   include/asm-generic/io.h:490:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
           val = __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + addr));
                                                           ~~~~~~~~~~ ^
   include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from macro '__le32_to_cpu'
   #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x))
                                                             ^
   include/uapi/linux/swab.h:119:21: note: expanded from macro '__swab32'
           ___constant_swab32(x) :                 \
                              ^
   include/uapi/linux/swab.h:22:12: note: expanded from macro '___constant_swab32'
           (((__u32)(x) & (__u32)0xff000000UL) >> 24)))
                     ^
   In file included from arch/s390/kernel/asm-offsets.c:11:
   In file included from include/linux/kvm_host.h:32:
   In file included from include/linux/kvm_para.h:5:
   In file included from include/uapi/linux/kvm_para.h:36:
   In file included from arch/s390/include/asm/kvm_para.h:25:
   In file included from arch/s390/include/asm/diag.h:12:
   In file included from include/linux/if_ether.h:19:
   In file included from include/linux/skbuff.h:31:
   In file included from include/linux/dma-mapping.h:11:
   In file included from include/linux/scatterlist.h:9:
   In file included from arch/s390/include/asm/io.h:72:
   include/asm-generic/io.h:490:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
           val = __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + addr));
                                                           ~~~~~~~~~~ ^
   include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from macro '__le32_to_cpu'
   #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x))
                                                             ^
   include/uapi/linux/swab.h:120:12: note: expanded from macro '__swab32'
           __fswab32(x))
                     ^
   In file included from arch/s390/kernel/asm-offsets.c:11:
   In file included from include/linux/kvm_host.h:32:
   In file included from include/linux/kvm_para.h:5:
   In file included from include/uapi/linux/kvm_para.h:36:
   In file included from arch/s390/include/asm/kvm_para.h:25:
   In file included from arch/s390/include/asm/diag.h:12:
   In file included from include/linux/if_ether.h:19:
   In file included from include/linux/skbuff.h:31:
   In file included from include/linux/dma-mapping.h:11:
   In file included from include/linux/scatterlist.h:9:
   In file included from arch/s390/include/asm/io.h:72:
   include/asm-generic/io.h:501:33: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
           __raw_writeb(value, PCI_IOBASE + addr);
                               ~~~~~~~~~~ ^
   include/asm-generic/io.h:511:59: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
           __raw_writew((u16 __force)cpu_to_le16(value), PCI_IOBASE + addr);
                                                         ~~~~~~~~~~ ^
   include/asm-generic/io.h:521:59: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
           __raw_writel((u32 __force)cpu_to_le32(value), PCI_IOBASE + addr);
                                                         ~~~~~~~~~~ ^
   include/asm-generic/io.h:609:20: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
           readsb(PCI_IOBASE + addr, buffer, count);
                  ~~~~~~~~~~ ^
   include/asm-generic/io.h:617:20: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
           readsw(PCI_IOBASE + addr, buffer, count);
                  ~~~~~~~~~~ ^
   include/asm-generic/io.h:625:20: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
           readsl(PCI_IOBASE + addr, buffer, count);
                  ~~~~~~~~~~ ^
   include/asm-generic/io.h:634:21: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
           writesb(PCI_IOBASE + addr, buffer, count);
                   ~~~~~~~~~~ ^
   include/asm-generic/io.h:643:21: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
           writesw(PCI_IOBASE + addr, buffer, count);
                   ~~~~~~~~~~ ^
   include/asm-generic/io.h:652:21: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
           writesl(PCI_IOBASE + addr, buffer, count);
                   ~~~~~~~~~~ ^
   20 warnings generated.
>> <stdin>:1526:2: warning: syscall trampfd not implemented [-W#warnings]
   #warning syscall trampfd not implemented
    ^

1 warning generated.

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org

#32 lore raw

RFC PATCH v2 3/4 arm64/trampfd: Provide support for the trampoline file descriptor

In reply to [email protected]

From: "Madhavan T. Venkataraman" <[email protected]>

- Define architecture specific register names
- Architecture specific functions for:
- system call init
- code descriptor check
- data descriptor check
- Fill a page with a trampoline table for:
- 32-bit user process
- 64-bit user process

---
 arch/arm64/include/asm/unistd.h      |   2 +-
 arch/arm64/include/asm/unistd32.h    |   2 +
 arch/arm64/include/uapi/asm/ptrace.h |  59 +++++++
 arch/arm64/kernel/Makefile           |   2 +
 arch/arm64/kernel/trampfd.c          | 244 +++++++++++++++++++++++++++
 5 files changed, 308 insertions(+), 1 deletion(-)
 create mode 100644 arch/arm64/kernel/trampfd.c
arch/arm64/include/asm/unistd.h +1 -1
index 3b859596840d..b3b2019f8d16 100644
@@ -38,7 +38,7 @@
 #define __ARM_NR_compat_set_tls		(__ARM_NR_COMPAT_BASE + 5)
 #define __ARM_NR_COMPAT_END		(__ARM_NR_COMPAT_BASE + 0x800)
 
-#define __NR_compat_syscalls		440
+#define __NR_compat_syscalls		441
 #endif
 
 #define __ARCH_WANT_SYS_CLONE
arch/arm64/include/asm/unistd32.h +2 -0
index 6d95d0c8bf2f..c0493c5322d9 100644
@@ -885,6 +885,8 @@ __SYSCALL(__NR_openat2, sys_openat2)
 __SYSCALL(__NR_pidfd_getfd, sys_pidfd_getfd)
 #define __NR_faccessat2 439
 __SYSCALL(__NR_faccessat2, sys_faccessat2)
+#define __NR_trampfd 440
+__SYSCALL(__NR_trampfd, sys_trampfd)
 
 /*
  * Please add new compat syscalls above this comment and update
arch/arm64/include/uapi/asm/ptrace.h +59 -0

65 lines not on this page · raw message

arch/arm64/kernel/Makefile +2 -0
index a561cbb91d4d..18d373fb1208 100644
@@ -71,3 +71,5 @@ extra-y					+= $(head-y) vmlinux.lds
 ifeq ($(CONFIG_DEBUG_EFI),y)
 AFLAGS_head.o += -DVMLINUX_PATH="\"$(realpath $(objtree)/vmlinux)\""
 endif
+
+obj-$(CONFIG_TRAMPFD)			+= trampfd.o
arch/arm64/kernel/trampfd.c new file +244 -0

244 lines not on this page · raw message

Signature · 1 line
2.17.1
#33 lore raw

RFC PATCH v2 4/4 arm/trampfd: Provide support for the trampoline file descriptor

In reply to [email protected]

From: "Madhavan T. Venkataraman" <[email protected]>

- Define architecture specific register names
- Architecture specific functions for:
- system call init
- code descriptor check
- data descriptor check
- Fill a page with a trampoline table,

---
 arch/arm/include/uapi/asm/ptrace.h |  21 +++++
 arch/arm/kernel/Makefile           |   1 +
 arch/arm/kernel/trampfd.c          | 124 +++++++++++++++++++++++++++++
 arch/arm/tools/syscall.tbl         |   1 +
 4 files changed, 147 insertions(+)
 create mode 100644 arch/arm/kernel/trampfd.c
arch/arm/include/uapi/asm/ptrace.h +21 -0
index e61c65b4018d..598047768f9b 100644
@@ -151,6 +151,27 @@ struct pt_regs {
 #define ARM_r0		uregs[0]
 #define ARM_ORIG_r0	uregs[17]
 
+/*
+ * These register names are to be used by 32-bit applications.
+ */
+enum reg_32_name {
+	arm_min,
+	arm_r0 = arm_min,
+	arm_r1,
+	arm_r2,
+	arm_r3,
+	arm_r4,
+	arm_r5,
+	arm_r6,
+	arm_r7,
+	arm_r8,
+	arm_r9,
+	arm_r10,
+	arm_r11,
+	arm_r12,
+	arm_max,
+};
+
 /*
  * The size of the user-visible VFP state as seen by PTRACE_GET/SETVFPREGS
  * and core dumps.
arch/arm/kernel/Makefile +1 -0
index 89e5d864e923..652c54c2f19a 100644
@@ -105,5 +105,6 @@ obj-$(CONFIG_SMP)		+= psci_smp.o
 endif
 
 obj-$(CONFIG_HAVE_ARM_SMCCC)	+= smccc-call.o
+obj-$(CONFIG_TRAMPFD)		+= trampfd.o
 
 extra-y := $(head-y) vmlinux.lds
arch/arm/kernel/trampfd.c new file +124 -0

124 lines not on this page · raw message

arch/arm/tools/syscall.tbl +1 -0
index d5cae5ffede0..85dcbc9e08ee 100644
@@ -452,3 +452,4 @@
 437	common	openat2				sys_openat2
 438	common	pidfd_getfd			sys_pidfd_getfd
 439	common	faccessat2			sys_faccessat2
+440	common	trampfd				sys_trampfd
Signature · 1 line
2.17.1
#34 lore raw
In reply to [email protected]

I just resent the trampfd v2 RFC. I forgot to CC the reviewers who provided comments before. So sorry.

Madhavan

Quoted 348 lines · On 9/22/20 4:53 PM, [email protected] wrote:

From: "Madhavan T. Venkataraman" <[email protected]>

Introduction
============

Dynamic code is used in many different user applications. Dynamic code is often generated at runtime. Dynamic code can also just be a pre-defined sequence of machine instructions in a data buffer. Examples of dynamic code are trampolines, JIT code, DBT code, etc.

Dynamic code is placed either in a data page or in a stack page. In order to execute dynamic code, the page it resides in needs to be mapped with execute permissions. Writable pages with execute permissions provide an attack surface for hackers. Attackers can use this to inject malicious code, modify existing code or do other harm.

To mitigate this, LSMs such as SELinux implement W^X. That is, they may not allow pages to have both write and execute permissions. This prevents dynamic code from executing and blocks applications that use it. To allow genuine applications to run, exceptions have to be made for them (by setting execmem, etc) which opens the door to security issues.

The W^X implementation today is not complete. There exist many user level tricks that can be used to load and execute dynamic code. E.g.,

- Load the code into a file and map the file with R-X.

- Load the code in an RW- page. Change the permissions to R--. Then, change the permissions to R-X.

- Load the code in an RW- page. Remap the page with R-X to get a separate mapping to the same underlying physical page.

IMO, these are all security holes as an attacker can exploit them to inject his own code.

In the future, these holes will definitely be closed. For instance, LSMs (such as the IPE proposal [1]) may only allow code in properly signed object files to be mapped with execute permissions. This will do two things:

- user level tricks using anonymous pages will fail as anonymous pages have no file identity

- loading the code in a temporary file and mapping it with R-X will fail as the temporary file would not have a signature

We need a way to execute such code without making security exceptions. Trampolines are a good example of dynamic code. A couple of examples of trampolines are given below. My first use case for this RFC is libffi.

Examples of trampolines
=======================

libffi (A Portable Foreign Function Interface Library):

libffi allows a user to define functions with an arbitrary list of arguments and return value through a feature called "Closures". Closures use trampolines to jump to ABI handlers that handle calling conventions and call a target function. libffi is used by a lot of different applications. To name a few:

- Python
- Java
- Javascript
- Ruby FFI
- Lisp
- Objective C

GCC nested functions:

GCC has traditionally used trampolines for implementing nested functions. The trampoline is placed on the user stack. So, the stack needs to be executable.

Currently available solution
============================

One solution that has been proposed to allow trampolines to be executed without making security exceptions is Trampoline Emulation. See:

https://pax.grsecurity.net/docs/emutramp.txt

In this solution, the kernel recognizes certain sequences of instructions as "well-known" trampolines. When such a trampoline is executed, a page fault happens because the trampoline page does not have execute permission. The kernel recognizes the trampoline and emulates it. Basically, the kernel does the work of the trampoline on behalf of the application.

Currently, the emulated trampolines are the ones used in libffi and GCC nested functions. To my knowledge, only X86 is supported at this time.

As noted in emutramp.txt, this is not a generic solution. For every new trampoline that needs to be supported, new instruction sequences need to be recognized by the kernel and emulated. And this has to be done for every architecture that needs to be supported.

emutramp.txt notes the following:

"... the real solution is not in emulation but by designing a kernel API for runtime code generation and modifying userland to make use of it."

Solution proposed in this RFC
=============================

Quoted 1 line

From this RFC's perspective, there are two scenarios for dynamic code:

Scenario 1
----------

We know what code we need only at runtime. For instance, JIT code generated for frequently executed Java methods. Only at runtime do we know what methods need to be JIT compiled. Such code cannot be statically defined. It has to be generated at runtime.

Scenario 2
----------

We know what code we need in advance. User trampolines are a good example of this. It is possible to define such code statically with some help from the kernel.

This RFC addresses (2). (1) needs a general purpose trusted code generator and is out of scope for this RFC.

For (2), the solution is to convert dynamic code to static code and place it in a source file. The binary generated from the source can be signed. The kernel can use signature verification to authenticate the binary and allow the code to be mapped and executed.

The problem is that the static code has to be able to find the data that it needs when it executes. For functions, the ABI defines the way to pass parameters. But, for arbitrary dynamic code, there isn't a standard ABI compliant way to pass data to the code for most architectures. Each instance of dynamic code defines its own way. For instance, co-location of code and data and PC-relative data referencing are used in cases where the ISA supports it.

We need one standard way that would work for all architectures and ABIs.

The solution proposed here is:

1. Write the static code assuming that the data needed by the code is already pointed to by a designated register.

2. Get the kernel to supply a small universal trampoline that does the following:

- Load the address of the data in a designated register
- Load the address of the static code in a designated register
- Jump to the static code

User code would use a kernel supplied API to create and map the trampoline. The address values would be baked into the code so that no special ISA features are needed.

To conserve memory, the kernel will pack as many trampolines as possible in a page and provide a trampoline table to user code. The table itself is managed by the user.

Trampoline File Descriptor (trampfd)
==========================

I am proposing a kernel API using anonymous file descriptors that can be used to create the trampolines. The API is described in patch 1/4 of this patchset. I provide a summary here:

- Create a trampoline file object

- Write a code descriptor into the trampoline file and specify:

- the number of trampolines desired
- the name of the code register
- user pointer to a table of code addresses, one address per trampoline

- Write a data descriptor into the trampoline file and specify:

- the name of the data register
- user pointer to a table of data addresses, one address per trampoline

- mmap() the trampoline file. The kernel generates a table of trampolines in a page and returns the trampoline table address

- munmap() a trampoline file mapping

- Close the trampoline file

Each mmap() will only map a single base page. Large pages are not supported.

A trampoline file can only be mapped once in an address space.

Trampoline file mappings cannot be shared across address spaces. So, sending the trampoline file descriptor over a unix domain socket and mapping it in another process will not work.

It is recommended that the code descriptor and the code table be placed in the .rodata section so an attacker cannot modify them.

Trampoline use and reuse
========================

The code for trampoline X in the trampoline table is:

load &code_table[X], code_reg
load (code_reg), code_reg
load &data_table[X], data_reg
load (data_reg), data_reg
jump code_reg

The addresses &code_table[X] and &data_table[X] are baked into the trampoline code. So, PC-relative data references are not needed. The user can modify code_table[X] and data_table[X] dynamically.

For instance, within libffi, the same trampoline X can be used for different closures at different times by setting:

	data_table[X] = closure;
	code_table[X] = ABI handling code;

Advantages of the Trampoline File Descriptor approach
=====================================================

- Using this support from the kernel, dynamic code can be converted to static code with a little effort so applications and libraries can move to a more secure model. In the simplest cases such as libffi, dynamic code can even be eliminated.

- This initial work is targeted towards X86 and ARM. But it can be supported easily on all architectures. We don't need any special ISA features such as PC-relative data referencing.

- The only code generation needed is for this small, universal trampoline.

- The kernel does not have to deal with any ABI issues in the generation of this trampoline.

- The kernel provides a trampoline table to conserve memory.

- An SELinux setting called "exectramp" can be implemented along the lines of "execmem", "execstack" and "execheap" to selectively allow the use of trampolines on a per application basis.

- In version 1, a trip to the kernel was required to execute the trampoline. In version 2, that is not required. So, there are no performance concerns in this approach.

libffi
======

I have implemented my solution for libffi and provided the changes for X86 and ARM, 32-bit and 64-bit. Here is the reference patch:

http://linux.microsoft.com/~madvenka/libffi/libffi.v2.txt

If the trampfd patchset gets accepted, I will send the libffi changes to the maintainers for a review. BTW, I have also successfully executed the libffi self tests.

Work that is pending
====================

- I am working on implementing the SELinux setting - "exectramp".

- I have a test program to test the kernel API. I am working on adding it to selftests.

References
==========

[1] https://microsoft.github.io/ipe/
---

Changelog:

v1
Introduced the Trampfd feature.

v2
- Changed the system call. Version 2 does not support different trampoline types and their associated type structures. It only supports a kernel generated trampoline.

The system call now returns information to the user that is used to define trampoline descriptors. E.g., the maximum number of trampolines that can be packed in a single page.

- Removed all the trampoline contexts such as register contexts and stack contexts. This is based on the feedback that the kernel should not have to worry about ABI issues and H/W features that may deal with the context of a process.

- Removed the need to make a trip into the kernel on trampoline invocation. This is based on the feedback about performance.

- Removed the ability to share trampolines across address spaces. This would have made sense to different trampoline types based on their semantics. But since I support only one specific trampoline, sharing does not make sense.

- Added calls to specify trampoline descriptors that the kernel uses to generate trampolines.

- Added architecture-specific code to generate the small, universal trampoline for X86 32 and 64-bit, ARM 32 and 64-bit.

- Implemented the trampoline table in a page.
Madhavan T. Venkataraman (4):
Implement the kernel API for the trampoline file descriptor. Implement i386 and X86 support for the trampoline file descriptor. Implement ARM64 support for the trampoline file descriptor. Implement ARM support for the trampoline file descriptor.

 arch/arm/include/uapi/asm/ptrace.h     |  21 +++
 arch/arm/kernel/Makefile               |   1 +
 arch/arm/kernel/trampfd.c              | 124 +++++++++++++
 arch/arm/tools/syscall.tbl             |   1 +
 arch/arm64/include/asm/unistd.h        |   2 +-
 arch/arm64/include/asm/unistd32.h      |   2 +
 arch/arm64/include/uapi/asm/ptrace.h   |  59 ++++++
 arch/arm64/kernel/Makefile             |   2 +
 arch/arm64/kernel/trampfd.c            | 244 +++++++++++++++++++++++++
 arch/x86/entry/syscalls/syscall_32.tbl |   1 +
 arch/x86/entry/syscalls/syscall_64.tbl |   1 +
 arch/x86/include/uapi/asm/ptrace.h     |  38 ++++
 arch/x86/kernel/Makefile               |   1 +
 arch/x86/kernel/trampfd.c              | 238 ++++++++++++++++++++++++
 fs/Makefile                            |   1 +
 fs/trampfd/Makefile                    |   5 +
 fs/trampfd/trampfd_fops.c              | 241 ++++++++++++++++++++++++
 fs/trampfd/trampfd_map.c               | 142 ++++++++++++++
 include/linux/syscalls.h               |   2 +
 include/linux/trampfd.h                |  49 +++++
 include/uapi/asm-generic/unistd.h      |   4 +-
 include/uapi/linux/trampfd.h           | 184 +++++++++++++++++++
 init/Kconfig                           |   7 +
 kernel/sys_ni.c                        |   3 +
 24 files changed, 1371 insertions(+), 2 deletions(-)
 create mode 100644 arch/arm/kernel/trampfd.c
 create mode 100644 arch/arm64/kernel/trampfd.c
 create mode 100644 arch/x86/kernel/trampfd.c
 create mode 100644 fs/trampfd/Makefile
 create mode 100644 fs/trampfd/trampfd_fops.c
 create mode 100644 fs/trampfd/trampfd_map.c
 create mode 100644 include/linux/trampfd.h
 create mode 100644 include/uapi/linux/trampfd.h
#35 lore raw
In reply to [email protected]

Hi!

Quoted 25 lines

Introduction
============

Dynamic code is used in many different user applications. Dynamic code is often generated at runtime. Dynamic code can also just be a pre-defined sequence of machine instructions in a data buffer. Examples of dynamic code are trampolines, JIT code, DBT code, etc.

Dynamic code is placed either in a data page or in a stack page. In order to execute dynamic code, the page it resides in needs to be mapped with execute permissions. Writable pages with execute permissions provide an attack surface for hackers. Attackers can use this to inject malicious code, modify existing code or do other harm.

To mitigate this, LSMs such as SELinux implement W^X. That is, they may not allow pages to have both write and execute permissions. This prevents dynamic code from executing and blocks applications that use it. To allow genuine applications to run, exceptions have to be made for them (by setting execmem, etc) which opens the door to security issues.

The W^X implementation today is not complete. There exist many user level tricks that can be used to load and execute dynamic code. E.g.,

- Load the code into a file and map the file with R-X.

Quoted 8 lines

- Load the code in an RW- page. Change the permissions to R--. Then, change the permissions to R-X.

- Load the code in an RW- page. Remap the page with R-X to get a separate mapping to the same underlying physical page.

IMO, these are all security holes as an attacker can exploit them to inject his own code.

IMO, you are smoking crack^H^H very seriously misunderstanding what W^X is supposed to protect from.

W^X is not supposed to protect you from attackers that can already do system calls. So loading code into a file then mapping the file as R-X is in no way security hole in W^X.

If you want to provide protection from attackers that _can_ do system calls, fine, but please don't talk about W^X and please specify what types of attacks you want to prevent and why that's good thing.

Hint: attacker that can "Load the code into a file and map the file with R-X." can probably also load the code into /foo and os.system("/usr/bin/python /foo").

This is not first crazy patch from your company. Perhaps you should have a person with strong Unix/Linux experience performing "straight face test" on outgoing patches?

Best regards,
Pavel

Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
#36 lore raw
Quoted 37 lines · Pavel Machek
Quoted 25 lines

Introduction
============

Dynamic code is used in many different user applications. Dynamic code is often generated at runtime. Dynamic code can also just be a pre-defined sequence of machine instructions in a data buffer. Examples of dynamic code are trampolines, JIT code, DBT code, etc.

Dynamic code is placed either in a data page or in a stack page. In order to execute dynamic code, the page it resides in needs to be mapped with execute permissions. Writable pages with execute permissions provide an attack surface for hackers. Attackers can use this to inject malicious code, modify existing code or do other harm.

To mitigate this, LSMs such as SELinux implement W^X. That is, they may not allow pages to have both write and execute permissions. This prevents dynamic code from executing and blocks applications that use it. To allow genuine applications to run, exceptions have to be made for them (by setting execmem, etc) which opens the door to security issues.

The W^X implementation today is not complete. There exist many user level tricks that can be used to load and execute dynamic code. E.g.,

- Load the code into a file and map the file with R-X.

Quoted 8 lines

- Load the code in an RW- page. Change the permissions to R--. Then, change the permissions to R-X.

- Load the code in an RW- page. Remap the page with R-X to get a separate mapping to the same underlying physical page.

IMO, these are all security holes as an attacker can exploit them to inject his own code.

IMO, you are smoking crack^H^H very seriously misunderstanding what W^X is supposed to protect from.

Quoted 7 lines

W^X is not supposed to protect you from attackers that can already do system calls. So loading code into a file then mapping the file as R-X is in no way security hole in W^X.

If you want to provide protection from attackers that _can_ do system calls, fine, but please don't talk about W^X and please specify what types of attacks you want to prevent and why that's good thing.

On one hand, Pavel is absolutely right. It is ridiculous to say that "these are all security holes as an attacker can exploit them to inject his own code."

On the other hand, "what W^X is supposed to protect from" depends on how the term W^X is defined (historically, by PaX and OpenBSD). It may be that W^X is partially not a feature to defeat attacks per se, but also a policy enforcement feature preventing use of dangerous techniques (JIT).

Such policy might or might not make sense. It might make sense for ease of reasoning, e.g. "I've flipped this setting, and now I'm certain the system doesn't have JIT within a process (can still have it through dynamically creating and invoking an entire new program), so there are no opportunities for an attacker to inject code nor generate previously non-existing ROP gadgets into an executable mapping within a process."

I do find it questionable whether such policy and such reasoning make sense beyond academia.

Then, there might be even more ways in which W^X is not perfect enough to enable such reasoning. What about using ptrace(2) to inject code? Should enabling W^X also disable ability to debug programs by non-root? We already have Yama ptrace_scope, which can achieve that at the highest setting, although that's rather inconvenient and is probably unexpected by most to be a requirement for having (ridiculously?) full W^X allowing for the academic reasoning.

Personally, I am for policies that make more practical sense. For example, years ago I advocated here on kernel-hardening that we should have a mode where ELF flags enabling/disabling executable stack are ignored, and non-executable stack is always enforced. This should also be extended to default (at program startup) permissions on more than just stack (but also on .bss, typical libcs' heap allocations, etc.) However, I am not convinced there's enough value in extending the policy to restricting explicit uses of mprotect(2).

Yes, PaX did that, and its emutramp.txt said "runtime code generation is by its nature incompatible with PaX's PAGEEXEC/SEGMEXEC and MPROTECT features, therefore the real solution is not in emulation but by designing a kernel API for runtime code generation and modifying userland to make use of it." However, not being convinced in the MPROTECT feature having enough practical value, I am also not convinced "a kernel API for runtime code generation and modifying userland to make use of it" is the way to go.

Having static instead of dynamically-generated trampolines in userland code where possible (and making other userland/ABI changes to make that possible in more/all cases) is an obvious improvement, and IMO should be a priority over the above.

While I share my opinion here, I don't mean that to block Madhavan's work. I'd rather defer to people more knowledgeable in current userland and ABI issues/limitations and plans on dealing with those, especially to Florian Weimer. I haven't seen Florian say anything specific for or against Madhavan's proposal, and I'd like to. (Have I missed that?) It'd be wrong to introduce a kernel API that userland doesn't need, and it'd be right to introduce one that userland actually intends to use.

I've also added Rich Felker to CC here, for musl libc and its possible intent to use the proposed API. (My guess is there's no such need, and thus no intent, but Rich might want to confirm that or correct me.)

Alexander

_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

#37 lore raw
Quoted 42 lines · Solar Designer
Quoted 41 lines · Pavel Machek
Quoted 25 lines

Introduction
============

Dynamic code is used in many different user applications. Dynamic code is often generated at runtime. Dynamic code can also just be a pre-defined sequence of machine instructions in a data buffer. Examples of dynamic code are trampolines, JIT code, DBT code, etc.

Dynamic code is placed either in a data page or in a stack page. In order to execute dynamic code, the page it resides in needs to be mapped with execute permissions. Writable pages with execute permissions provide an attack surface for hackers. Attackers can use this to inject malicious code, modify existing code or do other harm.

To mitigate this, LSMs such as SELinux implement W^X. That is, they may not allow pages to have both write and execute permissions. This prevents dynamic code from executing and blocks applications that use it. To allow genuine applications to run, exceptions have to be made for them (by setting execmem, etc) which opens the door to security issues.

The W^X implementation today is not complete. There exist many user level tricks that can be used to load and execute dynamic code. E.g.,

- Load the code into a file and map the file with R-X.

Quoted 8 lines

- Load the code in an RW- page. Change the permissions to R--. Then, change the permissions to R-X.

- Load the code in an RW- page. Remap the page with R-X to get a separate mapping to the same underlying physical page.

IMO, these are all security holes as an attacker can exploit them to inject his own code.

IMO, you are smoking crack^H^H very seriously misunderstanding what W^X is supposed to protect from.

W^X is not supposed to protect you from attackers that can already do system calls. So loading code into a file then mapping the file as R-X is in no way security hole in W^X.

Quoted 7 lines
Quoted 3 lines

If you want to provide protection from attackers that _can_ do system calls, fine, but please don't talk about W^X and please specify what types of attacks you want to prevent and why that's good thing.

On one hand, Pavel is absolutely right. It is ridiculous to say that "these are all security holes as an attacker can exploit them to inject his own code."

I stand corrected, due to Brad's tweet and follow-ups here:

https://twitter.com/spendergrsec/status/1308728284390318082

It sure does make sense to combine ret2libc/ROP to mprotect() with one's own injected shellcode. Compared to doing everything from ROP, this is easier and more reliable across versions/builds if the desired payload is non-trivial. My own example: invoking a shell in a local attack on Linux is trivial enough to do via ret2libc only, but a connect-back shell in a remote attack might be easier and more reliably done via mprotect() + shellcode.

Per the follow-ups, this was an established technique on Windows and iOS until further hardening prevented it. So it does make sense for Linux to do the same (as an option because of it breaking existing stuff), and not so much as policy enforcement for the sake of it and ease of reasoning, but mostly to force real-world exploits to be more complex and less reliable.

Quoted 12 lines

On the other hand, "what W^X is supposed to protect from" depends on how the term W^X is defined (historically, by PaX and OpenBSD). It may be that W^X is partially not a feature to defeat attacks per se, but also a policy enforcement feature preventing use of dangerous techniques (JIT).

Such policy might or might not make sense. It might make sense for ease of reasoning, e.g. "I've flipped this setting, and now I'm certain the system doesn't have JIT within a process (can still have it through dynamically creating and invoking an entire new program), so there are no opportunities for an attacker to inject code nor generate previously non-existing ROP gadgets into an executable mapping within a process."

Quoted 2 lines

I do find it questionable whether such policy and such reasoning make sense beyond academia.

I was wrong in the above, focusing on the wrong thing.

Quoted 7 lines

Then, there might be even more ways in which W^X is not perfect enough to enable such reasoning. What about using ptrace(2) to inject code? Should enabling W^X also disable ability to debug programs by non-root? We already have Yama ptrace_scope, which can achieve that at the highest setting, although that's rather inconvenient and is probably unexpected by most to be a requirement for having (ridiculously?) full W^X allowing for the academic reasoning.

Thinking out loud:

Technically, ptrace() is also usable from a ROP chain. It might be too cumbersome to bother using to get a shellcode going, but OTOH it's just one function to be invoked in a similar fashion multiple times, so might be more reliable than having a ROP chain depend on multiple actually needed functions directly (moving that dependency into the shellcode).

Quoted 9 lines

Personally, I am for policies that make more practical sense. For example, years ago I advocated here on kernel-hardening that we should have a mode where ELF flags enabling/disabling executable stack are ignored, and non-executable stack is always enforced. This should also be extended to default (at program startup) permissions on more than just stack (but also on .bss, typical libcs' heap allocations, etc.) However, I am not convinced there's enough value in extending the policy to restricting explicit uses of mprotect(2).

Quoted 6 lines

Yes, PaX did that, and its emutramp.txt said "runtime code generation is by its nature incompatible with PaX's PAGEEXEC/SEGMEXEC and MPROTECT features, therefore the real solution is not in emulation but by designing a kernel API for runtime code generation and modifying userland to make use of it." However, not being convinced in the MPROTECT feature having enough practical value,

I am convinced now, however:

Quoted 3 lines

I am also not convinced
"a kernel API for runtime code generation and modifying userland to make use of it" is the way to go.

doesn't automatically follow from the above, because:

Quoted 13 lines

Having static instead of dynamically-generated trampolines in userland code where possible (and making other userland/ABI changes to make that possible in more/all cases) is an obvious improvement, and IMO should be a priority over the above.

While I share my opinion here, I don't mean that to block Madhavan's work. I'd rather defer to people more knowledgeable in current userland and ABI issues/limitations and plans on dealing with those, especially to Florian Weimer. I haven't seen Florian say anything specific for or against Madhavan's proposal, and I'd like to. (Have I missed that?) It'd be wrong to introduce a kernel API that userland doesn't need, and it'd be right to introduce one that userland actually intends to use.

Quoted 3 lines

I've also added Rich Felker to CC here, for musl libc and its possible intent to use the proposed API. (My guess is there's no such need, and thus no intent, but Rich might want to confirm that or correct me.)

So need to hear more from the userland folks, I guess.

Alexander

#38 lore raw

Hi!

Quoted 29 lines
Quoted 21 lines
Quoted 21 lines
Quoted 5 lines

The W^X implementation today is not complete. There exist many user level tricks that can be used to load and execute dynamic code. E.g.,

- Load the code into a file and map the file with R-X.

Quoted 8 lines

- Load the code in an RW- page. Change the permissions to R--. Then, change the permissions to R-X.

- Load the code in an RW- page. Remap the page with R-X to get a separate mapping to the same underlying physical page.

IMO, these are all security holes as an attacker can exploit them to inject his own code.

IMO, you are smoking crack^H^H very seriously misunderstanding what W^X is supposed to protect from.

W^X is not supposed to protect you from attackers that can already do system calls. So loading code into a file then mapping the file as R-X is in no way security hole in W^X.

Quoted 7 lines
Quoted 3 lines

If you want to provide protection from attackers that _can_ do system calls, fine, but please don't talk about W^X and please specify what types of attacks you want to prevent and why that's good thing.

On one hand, Pavel is absolutely right. It is ridiculous to say that "these are all security holes as an attacker can exploit them to inject his own code."

Quoted 8 lines

I stand corrected, due to Brad's tweet and follow-ups here:

https://twitter.com/spendergrsec/status/1308728284390318082

It sure does make sense to combine ret2libc/ROP to mprotect() with one's own injected shellcode. Compared to doing everything from ROP, this is easier and more reliable across versions/builds if the desired payload

Ok, so this starts to be a bit confusing.

I thought W^X is to protect from attackers that have overflowed buffer somewhere, but can not to do arbitrary syscalls, yet.

You are saying that there's important class of attackers that can do some syscalls but not arbitrary ones.

I'd like to see definition of that attacker (and perhaps description of the system the protection is expected to be useful on -- if it is not close to common Linux distros).

Best regards,

Pavel

Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
#39 lore raw
Quoted 5 lines · Pavel Machek
Quoted 4 lines

It sure does make sense to combine ret2libc/ROP to mprotect() with one's own injected shellcode. Compared to doing everything from ROP, this is easier and more reliable across versions/builds if the desired payload

Quoted 7 lines

Ok, so this starts to be a bit confusing.

I thought W^X is to protect from attackers that have overflowed buffer somewhere, but can not to do arbitrary syscalls, yet.

You are saying that there's important class of attackers that can do some syscalls but not arbitrary ones.

They might be able to do many, most, or all arbitrary syscalls via ret2libc or such. The crucial detail is that each time they do that, they risk incompatibility with the given target system (version, build, maybe ASLR if gadgets from multiple libraries are involved). By using mprotect(), they only take this risk once (need to get the address of an mprotect() gadget and of what to change protections on right), and then they can invoke multiple syscalls from their shellcode more reliably. So for doing a lot of work, mprotect() combined with injected code can be easier and more reliable. It is also an extra option an attacker can use, in addition to doing everything via borrowed code. More flexibility for the attacker means the attacker may choose whichever approach works better in a given case (or try several).

I am embarrassed for not thinking/recalling this when I first posted earlier today. It's actually obvious. I'm just getting old and rusty.

Quoted 3 lines

I'd like to see definition of that attacker (and perhaps description of the system the protection is expected to be useful on -- if it is not close to common Linux distros).

There's nothing unusual about that attacker and the system.

A couple of other things Brad kindly pointed out:

SELinux already has similar protections (execmem, execmod):

http://lkml.iu.edu/hypermail/linux/kernel/0508.2/0194.html
https://danwalsh.livejournal.com/6117.html

PaX MPROTECT is implemented in a way or at a layer that covers ptrace() abuse that I mentioned. (At least that's how I understood Brad.)

Alexander

P.S. Meanwhile, Twitter locked my account "for security purposes". Fun. I'll just let it be for now.

#41 lore raw
In reply to Solar Designer

* Solar Designer:

Quoted 5 lines

While I share my opinion here, I don't mean that to block Madhavan's work. I'd rather defer to people more knowledgeable in current userland and ABI issues/limitations and plans on dealing with those, especially to Florian Weimer. I haven't seen Florian say anything specific for or against Madhavan's proposal, and I'd like to. (Have I missed that?)

There was a previous discussion, where I provided feedback (not much different from the feedback here, given that the mechanism is mostly the same).

I think it's unnecessary for the libffi use case. Precompiled code can be loaded from disk because the libffi trampolines are so regular. On most architectures, it's not even the code that's patched, but some of the data driving it, which happens to be located on the same page due to a libffi quirk.

The libffi use case is a bit strange anyway: its trampolines are type-generic, and the per-call adjustment is data-driven. This means that once you have libffi in the process, you have a generic data-to-function-call mechanism available that can be abused (it's even fully CET compatible in recent versions). And then you need to look at the processes that use libffi. A lot of them contain bytecode interpreters, and those enable data-driven arbitrary code execution as well. I know that there are efforts under way to harden Python, but it's going to be tough to get to the point where things are still difficult for an attacker once they have the ability to make mprotect calls.

It was pointed out to me that libffi is doing things wrong, and the trampolines should not be type-generic, but generated so that they match the function being called. That is, the marshal/unmarshal code would be open-coded in the trampoline, rather than using some generic mechanism plus run-time dispatch on data tables describing the function type. That is a very different design (and typically used by compilers (JIT or not JIT) to implement native calls). Mapping some code page with a repeating pattern would no longer work to defeat anti-JIT measures because it's closer to real JIT. I don't know if kernel support could make sense in this context, but it would be a completely different patch.

Thanks,
Florian

Signature · 3 lines
Red Hat GmbH, https://de.redhat.com/ , Registered seat: Grasbrunn,
Commercial register: Amtsgericht Muenchen, HRB 153243,
Managing Directors: Charles Cachera, Brian Klemm, Laurie Krebs, Michael O'Neill
maintainer
#42 lore raw
Quoted 31 lines · Florian Weimer

* Solar Designer:

Quoted 5 lines

While I share my opinion here, I don't mean that to block Madhavan's work. I'd rather defer to people more knowledgeable in current userland and ABI issues/limitations and plans on dealing with those, especially to Florian Weimer. I haven't seen Florian say anything specific for or against Madhavan's proposal, and I'd like to. (Have I missed that?)

There was a previous discussion, where I provided feedback (not much different from the feedback here, given that the mechanism is mostly the same).

I think it's unnecessary for the libffi use case. Precompiled code can be loaded from disk because the libffi trampolines are so regular. On most architectures, it's not even the code that's patched, but some of the data driving it, which happens to be located on the same page due to a libffi quirk.

The libffi use case is a bit strange anyway: its trampolines are type-generic, and the per-call adjustment is data-driven. This means that once you have libffi in the process, you have a generic data-to-function-call mechanism available that can be abused (it's even fully CET compatible in recent versions). And then you need to look at the processes that use libffi. A lot of them contain bytecode interpreters, and those enable data-driven arbitrary code execution as well. I know that there are efforts under way to harden Python, but it's going to be tough to get to the point where things are still difficult for an attacker once they have the ability to make mprotect calls.

Quoted 11 lines

It was pointed out to me that libffi is doing things wrong, and the trampolines should not be type-generic, but generated so that they match the function being called. That is, the marshal/unmarshal code would be open-coded in the trampoline, rather than using some generic mechanism plus run-time dispatch on data tables describing the function type. That is a very different design (and typically used by compilers (JIT or not JIT) to implement native calls). Mapping some code page with a repeating pattern would no longer work to defeat anti-JIT measures because it's closer to real JIT. I don't know if kernel support could make sense in this context, but it would be a completely different patch.

I would very much like to see a well-designed kernel facility for helping userspace do JIT in a safer manner, but designing such a thing is likely to be distinctly nontrivial. To throw a half-backed idea out there, suppose a program could pre-declare a list of JIT verifiers:

static bool ffi_trampoline_verifier(void *target_address, size_t target_size, void *source_data, void *context);

struct jit_verifier {
.magic = 0xMAGIC_HERE,
.verifier = ffi_trampoline_verifier,
} my_verifier __attribute((section("something special here?)));

and then a system call something like:

instantiate_jit_code(target, source, size, &my_verifier, context);

The idea being that even an attacker that can force a call to instantiate_jit_code() can only create code that passes verification by one of the pre-declared verifiers in the process.

#43 lore raw
In reply to Florian Weimer
Quoted 7 lines · Florian Weimer

* Solar Designer:

Quoted 5 lines

While I share my opinion here, I don't mean that to block Madhavan's work. I'd rather defer to people more knowledgeable in current userland and ABI issues/limitations and plans on dealing with those, especially to Florian Weimer. I haven't seen Florian say anything specific for or against Madhavan's proposal, and I'd like to. (Have I missed that?)

[...]

Quoted 1 line

I think it's unnecessary for the libffi use case.

[...]

Quoted 3 lines

I don't know if kernel support could
make sense in this context, but it would be a completely different patch.

Thanks. Are there currently relevant use cases where the proposed trampfd would be useful and likely actually made use of by userland - e.g., specific userland project developers saying they'd use it, or Madhavan intending to develop and contribute userland patches?

Alexander

#44 lore raw
Quoted 17 lines · Solar Designer
Quoted 7 lines · Florian Weimer

* Solar Designer:

Quoted 5 lines

While I share my opinion here, I don't mean that to block Madhavan's work. I'd rather defer to people more knowledgeable in current userland and ABI issues/limitations and plans on dealing with those, especially to Florian Weimer. I haven't seen Florian say anything specific for or against Madhavan's proposal, and I'd like to. (Have I missed that?)

[...]

Quoted 1 line

I think it's unnecessary for the libffi use case.

[...]

Quoted 3 lines

I don't know if kernel support could
make sense in this context, but it would be a completely different patch.

Quoted 6 lines

Thanks. Are there currently relevant use cases where the proposed trampfd would be useful and likely actually made use of by userland - e.g., specific userland project developers saying they'd use it, or Madhavan intending to develop and contribute userland patches?

Alexander

The trampoline it provides in this version can be implemented completely in userspace. The kernel part of it is essentially just providing a way to do text relocations without needing a WX mapping, but the text relocations would be unnecessary in the first place if the trampoline was position-independent code.

#45 lore raw
In reply to Florian Weimer
Quoted 42 lines · Florian Weimer

* Solar Designer:

Quoted 5 lines

While I share my opinion here, I don't mean that to block Madhavan's work. I'd rather defer to people more knowledgeable in current userland and ABI issues/limitations and plans on dealing with those, especially to Florian Weimer. I haven't seen Florian say anything specific for or against Madhavan's proposal, and I'd like to. (Have I missed that?)

There was a previous discussion, where I provided feedback (not much different from the feedback here, given that the mechanism is mostly the same).

I think it's unnecessary for the libffi use case. Precompiled code can be loaded from disk because the libffi trampolines are so regular. On most architectures, it's not even the code that's patched, but some of the data driving it, which happens to be located on the same page due to a libffi quirk.

The libffi use case is a bit strange anyway: its trampolines are type-generic, and the per-call adjustment is data-driven. This means that once you have libffi in the process, you have a generic data-to-function-call mechanism available that can be abused (it's even fully CET compatible in recent versions). And then you need to look at the processes that use libffi. A lot of them contain bytecode interpreters, and those enable data-driven arbitrary code execution as well. I know that there are efforts under way to harden Python, but it's going to be tough to get to the point where things are still difficult for an attacker once they have the ability to make mprotect calls.

It was pointed out to me that libffi is doing things wrong, and the trampolines should not be type-generic, but generated so that they match the function being called. That is, the marshal/unmarshal code would be open-coded in the trampoline, rather than using some generic mechanism plus run-time dispatch on data tables describing the function type. That is a very different design (and typically used by compilers (JIT or not JIT) to implement native calls). Mapping some code page with a repeating pattern would no longer work to defeat anti-JIT measures because it's closer to real JIT. I don't know if kernel support could make sense in this context, but it would be a completely different patch.

Quoted 3 lines

Thanks,
Florian

Hi Florian,

I am making myself familiar with anti-JIT measures before I can respond to this comment. Bear with me. I will also respond to the above libffi comment.

Madhavan

#46 lore raw
In reply to Solar Designer
Quoted 20 lines · Solar Designer
Quoted 20 lines
Quoted 5 lines

The W^X implementation today is not complete. There exist many user level tricks that can be used to load and execute dynamic code. E.g.,

- Load the code into a file and map the file with R-X.

Quoted 8 lines

- Load the code in an RW- page. Change the permissions to R--. Then, change the permissions to R-X.

- Load the code in an RW- page. Remap the page with R-X to get a separate mapping to the same underlying physical page.

IMO, these are all security holes as an attacker can exploit them to inject his own code.

IMO, you are smoking crack^H^H very seriously misunderstanding what W^X is supposed to protect from.

W^X is not supposed to protect you from attackers that can already do system calls. So loading code into a file then mapping the file as R-X is in no way security hole in W^X.

Quoted 7 lines
Quoted 3 lines

If you want to provide protection from attackers that _can_ do system calls, fine, but please don't talk about W^X and please specify what types of attacks you want to prevent and why that's good thing.

On one hand, Pavel is absolutely right. It is ridiculous to say that "these are all security holes as an attacker can exploit them to inject his own code."

Why? Isn't it possible that an attacker can exploit some vulnerability such as buffer overflow and overwrite the buffer that contains the dynamic code?

Quoted 15 lines

On the other hand, "what W^X is supposed to protect from" depends on how the term W^X is defined (historically, by PaX and OpenBSD). It may be that W^X is partially not a feature to defeat attacks per se, but also a policy enforcement feature preventing use of dangerous techniques (JIT).

Such policy might or might not make sense. It might make sense for ease of reasoning, e.g. "I've flipped this setting, and now I'm certain the system doesn't have JIT within a process (can still have it through dynamically creating and invoking an entire new program), so there are no opportunities for an attacker to inject code nor generate previously non-existing ROP gadgets into an executable mapping within a process."

I do find it questionable whether such policy and such reasoning make sense beyond academia.

Quoted 8 lines

Then, there might be even more ways in which W^X is not perfect enough to enable such reasoning. What about using ptrace(2) to inject code? Should enabling W^X also disable ability to debug programs by non-root? We already have Yama ptrace_scope, which can achieve that at the highest setting, although that's rather inconvenient and is probably unexpected by most to be a requirement for having (ridiculously?) full W^X allowing for the academic reasoning.

I am not suggesting that W^X be fixed. That is up to the maintainers of that code. I am saying that if the security subsystem is enhanced in the future with policies and settings that prevent the user tricks I mentioned, then it becomes impossible to execute dynamic code except by making security exceptions on a case by case basis.

As an alternative to making security exceptions, one could convert dynamic code to static code which can then be authenticated.

Quoted 9 lines

Personally, I am for policies that make more practical sense. For example, years ago I advocated here on kernel-hardening that we should have a mode where ELF flags enabling/disabling executable stack are ignored, and non-executable stack is always enforced. This should also be extended to default (at program startup) permissions on more than just stack (but also on .bss, typical libcs' heap allocations, etc.) However, I am not convinced there's enough value in extending the policy to restricting explicit uses of mprotect(2).

Quoted 9 lines

Yes, PaX did that, and its emutramp.txt said "runtime code generation is by its nature incompatible with PaX's PAGEEXEC/SEGMEXEC and MPROTECT features, therefore the real solution is not in emulation but by designing a kernel API for runtime code generation and modifying userland to make use of it." However, not being convinced in the MPROTECT feature having enough practical value, I am also not convinced "a kernel API for runtime code generation and modifying userland to make use of it" is the way to go.

In a separate email, I will try to answer this and provide justification for why it is better to do it in the kernel.

Quoted 14 lines

Having static instead of dynamically-generated trampolines in userland code where possible (and making other userland/ABI changes to make that possible in more/all cases) is an obvious improvement, and IMO should be a priority over the above.

While I share my opinion here, I don't mean that to block Madhavan's work. I'd rather defer to people more knowledgeable in current userland and ABI issues/limitations and plans on dealing with those, especially to Florian Weimer. I haven't seen Florian say anything specific for or against Madhavan's proposal, and I'd like to. (Have I missed that?) It'd be wrong to introduce a kernel API that userland doesn't need, and it'd be right to introduce one that userland actually intends to use.

Quoted 5 lines

I've also added Rich Felker to CC here, for musl libc and its possible intent to use the proposed API. (My guess is there's no such need, and thus no intent, but Rich might want to confirm that or correct me.)

Alexander

Madhavan

maintainer
#47 lore raw
In reply to Pavel Machek
Quoted 3 lines · Pavel Machek

This is not first crazy patch from your company. Perhaps you should have a person with strong Unix/Linux experience performing "straight face test" on outgoing patches?

Just for the record: the author of the code has 30+ years experience in SunOS, Solaris, Unixware, Realtime, SVR4, and Linux.

Signature · 2 lines
James Morris
<[email protected]>
#48 lore raw
In reply to Pavel Machek

...

Quoted 17 lines
Quoted 5 lines

The W^X implementation today is not complete. There exist many user level tricks that can be used to load and execute dynamic code. E.g.,

- Load the code into a file and map the file with R-X.

Quoted 8 lines

- Load the code in an RW- page. Change the permissions to R--. Then, change the permissions to R-X.

- Load the code in an RW- page. Remap the page with R-X to get a separate mapping to the same underlying physical page.

IMO, these are all security holes as an attacker can exploit them to inject his own code.

IMO, you are smoking crack^H^H very seriously misunderstanding what W^X is supposed to protect from.

Quoted 8 lines

W^X is not supposed to protect you from attackers that can already do system calls. So loading code into a file then mapping the file as R-X is in no way security hole in W^X.

If you want to provide protection from attackers that _can_ do system calls, fine, but please don't talk about W^X and please specify what types of attacks you want to prevent and why that's good thing.

There are two things here - the idea behind W^X and the current realization of that idea in actual implementation. The idea behind W^X, as I understand, is to prevent a user from loading arbitrary code into a page and getting it to execute. If the user code contains a vulnerability, an attacker can exploit it to potentially inject his own code and get it to execute. This cannot be denied.

From that perspective, all of the above tricks I have mentioned are tricks that user code can use to load arbitrary code into a page and get it to execute.

Now, I don't want the discussion to be stuck in a mere name. If what I am suggesting needs a name other than "W^X" in the opinion of the reviewers, that is fine with me. But I don't believe there is any disagreement that the above user tricks are security holes.

Madhavan

#49 lore raw
In reply to [email protected]

Hi!

Quoted 16 lines

Solution proposed in this RFC
=============================

Quoted 1 line

From this RFC's perspective, there are two scenarios for dynamic code:

Scenario 1
----------

We know what code we need only at runtime. For instance, JIT code generated for frequently executed Java methods. Only at runtime do we know what methods need to be JIT compiled. Such code cannot be statically defined. It has to be generated at runtime.

Scenario 2
----------

Quoted 6 lines

We know what code we need in advance. User trampolines are a good example of this. It is possible to define such code statically with some help from the kernel.

This RFC addresses (2). (1) needs a general purpose trusted code generator and is out of scope for this RFC.

This is slightly less crazy talk than introduction talking about holes in W^X. But it is very, very far from normal Unix system, where you have selection of interpretters to run your malware on (sh, python, awk, emacs, ...) and often you can even compile malware from sources.

And as you noted, we don't have "a general purpose trusted code generator" for our systems.

I believe you should simply delete confusing "introduction" and provide details of super-secure system where your patches would be useful, instead.

Best regards,
Pavel

Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
#50 lore raw
Quoted 33 lines · Pavel Machek

Hi!

Quoted 16 lines

Solution proposed in this RFC
=============================

Quoted 1 line

From this RFC's perspective, there are two scenarios for dynamic code:

Scenario 1
----------

We know what code we need only at runtime. For instance, JIT code generated for frequently executed Java methods. Only at runtime do we know what methods need to be JIT compiled. Such code cannot be statically defined. It has to be generated at runtime.

Scenario 2
----------

Quoted 6 lines

We know what code we need in advance. User trampolines are a good example of this. It is possible to define such code statically with some help from the kernel.

This RFC addresses (2). (1) needs a general purpose trusted code generator and is out of scope for this RFC.

This is slightly less crazy talk than introduction talking about holes in W^X. But it is very, very far from normal Unix system, where you have selection of interpretters to run your malware on (sh, python, awk, emacs, ...) and often you can even compile malware from sources.

And as you noted, we don't have "a general purpose trusted code generator" for our systems.

Quoted 7 lines

I believe you should simply delete confusing "introduction" and provide details of super-secure system where your patches would be useful, instead.

Best regards,
Pavel

This RFC talks about converting dynamic code (which cannot be authenticated) to static code that can be authenticated using signature verification. That is the scope of this RFC.

If I have not been clear before, by dynamic code, I mean machine code that is dynamic in nature. Scripts are beyond the scope of this RFC.

Also, malware compiled from sources is not dynamic code. That is orthogonal to this RFC. If such malware has a valid signature that the kernel permits its execution, we have a systemic problem.

I am not saying that script authentication or compiled malware are not problems. I am just saying that this RFC is not trying to solve all of the security problems. It is trying to define one way to convert dynamic code to static code to address one class of problems.

Madhavan

#51 lore raw

Hi!

Quoted 29 lines
Quoted 15 lines
Quoted 9 lines

Scenario 2
----------

We know what code we need in advance. User trampolines are a good example of this. It is possible to define such code statically with some help from the kernel.

This RFC addresses (2). (1) needs a general purpose trusted code generator and is out of scope for this RFC.

This is slightly less crazy talk than introduction talking about holes in W^X. But it is very, very far from normal Unix system, where you have selection of interpretters to run your malware on (sh, python, awk, emacs, ...) and often you can even compile malware from sources.

Quoted 6 lines

And as you noted, we don't have "a general purpose trusted code generator" for our systems.

I believe you should simply delete confusing "introduction" and provide details of super-secure system where your patches would be useful, instead.

This RFC talks about converting dynamic code (which cannot be authenticated) to static code that can be authenticated using signature verification. That is the scope of this RFC.

If I have not been clear before, by dynamic code, I mean machine code that is dynamic in nature. Scripts are beyond the scope of this RFC.

Quoted 8 lines

Also, malware compiled from sources is not dynamic code. That is orthogonal to this RFC. If such malware has a valid signature that the kernel permits its execution, we have a systemic problem.

I am not saying that script authentication or compiled malware are not problems. I am just saying that this RFC is not trying to solve all of the security problems. It is trying to define one way to convert dynamic code to static code to address one class of problems.

Well, you don't have to solve all problems at once.

But solutions have to exist, and AFAIK in this case they don't. You are armoring doors, but ignoring open windows.

Or very probably you are thinking about something different than normal desktop distros (Debian 10). Because on my systems, I have python, gdb and gcc...

It would be nice to specify what other pieces need to be present for this to make sense -- because it makes no sense on Debian 10.

Best regards,
Pavel

Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
#52 lore raw
Quoted 40 lines · Pavel Machek

Hi!

Quoted 29 lines
Quoted 15 lines
Quoted 9 lines

Scenario 2
----------

We know what code we need in advance. User trampolines are a good example of this. It is possible to define such code statically with some help from the kernel.

This RFC addresses (2). (1) needs a general purpose trusted code generator and is out of scope for this RFC.

This is slightly less crazy talk than introduction talking about holes in W^X. But it is very, very far from normal Unix system, where you have selection of interpretters to run your malware on (sh, python, awk, emacs, ...) and often you can even compile malware from sources.

Quoted 6 lines

And as you noted, we don't have "a general purpose trusted code generator" for our systems.

I believe you should simply delete confusing "introduction" and provide details of super-secure system where your patches would be useful, instead.

This RFC talks about converting dynamic code (which cannot be authenticated) to static code that can be authenticated using signature verification. That is the scope of this RFC.

If I have not been clear before, by dynamic code, I mean machine code that is dynamic in nature. Scripts are beyond the scope of this RFC.

Quoted 8 lines

Also, malware compiled from sources is not dynamic code. That is orthogonal to this RFC. If such malware has a valid signature that the kernel permits its execution, we have a systemic problem.

I am not saying that script authentication or compiled malware are not problems. I am just saying that this RFC is not trying to solve all of the security problems. It is trying to define one way to convert dynamic code to static code to address one class of problems.

Quoted 5 lines

Well, you don't have to solve all problems at once.

But solutions have to exist, and AFAIK in this case they don't. You are armoring doors, but ignoring open windows.

I am afraid I don't agree that the other open security issues must be addressed for this RFC to make sense. If you think that any of those issues actually has a bad interaction/intersection with this RFC, let me know how and I will address it.

Quoted 7 lines

Or very probably you are thinking about something different than normal desktop distros (Debian 10). Because on my systems, I have python, gdb and gcc...

It would be nice to specify what other pieces need to be present for this to make sense -- because it makes no sense on Debian 10.

Since this RFC pertains to converting dynamic machine code to static code, it has nothing to do with the other items you have mentioned. I am not disagreeing that the other items need to be addressed. But they are orthogonal.

Madhavan

#53 lore raw
In reply to Pavel Machek
Quoted 40 lines · Pavel Machek

Hi!

Quoted 29 lines
Quoted 15 lines
Quoted 9 lines

Scenario 2
----------

We know what code we need in advance. User trampolines are a good example of this. It is possible to define such code statically with some help from the kernel.

This RFC addresses (2). (1) needs a general purpose trusted code generator and is out of scope for this RFC.

This is slightly less crazy talk than introduction talking about holes in W^X. But it is very, very far from normal Unix system, where you have selection of interpretters to run your malware on (sh, python, awk, emacs, ...) and often you can even compile malware from sources.

Quoted 6 lines

And as you noted, we don't have "a general purpose trusted code generator" for our systems.

I believe you should simply delete confusing "introduction" and provide details of super-secure system where your patches would be useful, instead.

This RFC talks about converting dynamic code (which cannot be authenticated) to static code that can be authenticated using signature verification. That is the scope of this RFC.

If I have not been clear before, by dynamic code, I mean machine code that is dynamic in nature. Scripts are beyond the scope of this RFC.

Quoted 8 lines

Also, malware compiled from sources is not dynamic code. That is orthogonal to this RFC. If such malware has a valid signature that the kernel permits its execution, we have a systemic problem.

I am not saying that script authentication or compiled malware are not problems. I am just saying that this RFC is not trying to solve all of the security problems. It is trying to define one way to convert dynamic code to static code to address one class of problems.

Quoted 4 lines

Well, you don't have to solve all problems at once.

But solutions have to exist, and AFAIK in this case they don't. You are armoring doors, but ignoring open windows.

FYI, script execution is being addressed (for the kernel part) by this patch series:
https://lore.kernel.org/lkml/[email protected]/

Quoted 4 lines

Or very probably you are thinking about something different than normal desktop distros (Debian 10). Because on my systems, I have python, gdb and gcc...

It doesn't make sense for a tailored security system to leave all these tools available to an attacker.

Quoted 3 lines

It would be nice to specify what other pieces need to be present for this to make sense -- because it makes no sense on Debian 10.

Not all kernel features make sense for a generic/undefined usage, especially specific security mechanisms (e.g. SELinux, Smack, Tomoyo, SafeSetID, LoadPin, IMA, IPE, secure/trusted boot, lockdown, etc.), but they can still be definitely useful.

Quoted 4 lines

Best regards,
Pavel

#54 lore raw

Hi!

Quoted 20 lines
Quoted 20 lines
Quoted 19 lines
Quoted 3 lines

I believe you should simply delete confusing "introduction" and provide details of super-secure system where your patches would be useful, instead.

This RFC talks about converting dynamic code (which cannot be authenticated) to static code that can be authenticated using signature verification. That is the scope of this RFC.

If I have not been clear before, by dynamic code, I mean machine code that is dynamic in nature. Scripts are beyond the scope of this RFC.

Also, malware compiled from sources is not dynamic code. That is orthogonal to this RFC. If such malware has a valid signature that the kernel permits its execution, we have a systemic problem.

I am not saying that script authentication or compiled malware are not problems. I am just saying that this RFC is not trying to solve all of the security problems. It is trying to define one way to convert dynamic code to static code to address one class of problems.

Quoted 8 lines
Quoted 4 lines

Well, you don't have to solve all problems at once.

But solutions have to exist, and AFAIK in this case they don't. You are armoring doors, but ignoring open windows.

FYI, script execution is being addressed (for the kernel part) by this patch series:
https://lore.kernel.org/lkml/[email protected]/

Ok.

Quoted 6 lines
Quoted 3 lines

Or very probably you are thinking about something different than normal desktop distros (Debian 10). Because on my systems, I have python, gdb and gcc...

It doesn't make sense for a tailored security system to leave all these tools available to an attacker.

And it also does not make sense to use "trampoline file descriptor" on generic system... while W^X should make sense there.

Quoted 7 lines
Quoted 2 lines

It would be nice to specify what other pieces need to be present for this to make sense -- because it makes no sense on Debian 10.

Not all kernel features make sense for a generic/undefined usage, especially specific security mechanisms (e.g. SELinux, Smack, Tomoyo, SafeSetID, LoadPin, IMA, IPE, secure/trusted boot, lockdown, etc.), but they can still be definitely useful.

Yep... so... I'd expect something like... "so you have single-purpose system with all script interpreters removed, IMA hashing all the files to make sure they are not modified, and W^X enabled. Attacker can still execute code after buffer overflow by .... and trapoline file descriptor addrsses that"... so that people running generic systems can stop reading after first sentence.

Best regards,
Pavel

Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
#55 lore raw
Quoted 37 lines · Pavel Machek

Hi!

Quoted 20 lines
Quoted 20 lines
Quoted 19 lines
Quoted 3 lines

I believe you should simply delete confusing "introduction" and provide details of super-secure system where your patches would be useful, instead.

This RFC talks about converting dynamic code (which cannot be authenticated) to static code that can be authenticated using signature verification. That is the scope of this RFC.

If I have not been clear before, by dynamic code, I mean machine code that is dynamic in nature. Scripts are beyond the scope of this RFC.

Also, malware compiled from sources is not dynamic code. That is orthogonal to this RFC. If such malware has a valid signature that the kernel permits its execution, we have a systemic problem.

I am not saying that script authentication or compiled malware are not problems. I am just saying that this RFC is not trying to solve all of the security problems. It is trying to define one way to convert dynamic code to static code to address one class of problems.

Quoted 8 lines
Quoted 4 lines

Well, you don't have to solve all problems at once.

But solutions have to exist, and AFAIK in this case they don't. You are armoring doors, but ignoring open windows.

FYI, script execution is being addressed (for the kernel part) by this patch series:
https://lore.kernel.org/lkml/[email protected]/

Ok.

Quoted 4 lines
Quoted 3 lines

Or very probably you are thinking about something different than normal desktop distros (Debian 10). Because on my systems, I have python, gdb and gcc...

Quoted 5 lines
Quoted 2 lines

It doesn't make sense for a tailored security system to leave all these tools available to an attacker.

And it also does not make sense to use "trampoline file descriptor" on generic system... while W^X should make sense there.

Well, as said before, (full/original/system-wide) W^X may require trampfd (as well as other building-blocks).

I guess most Linux deployments are not on "generic systems" anyway (even if they may be based on generic distros), and W^X contradicts the fact that users/attackers can do whatever they want on the system.

Quoted 11 lines
Quoted 8 lines
Quoted 3 lines

It would be nice to specify what other pieces need to be present for this to make sense -- because it makes no sense on Debian 10.

Not all kernel features make sense for a generic/undefined usage, especially specific security mechanisms (e.g. SELinux, Smack, Tomoyo, SafeSetID, LoadPin, IMA, IPE, secure/trusted boot, lockdown, etc.), but they can still be definitely useful.

Yep... so... I'd expect something like... "so you have single-purpose system

No one talked about a single-purpose system.

Quoted 1 line

with all script interpreters removed,

Not necessarily with the patch series I pointed out just before.

Quoted 2 lines

IMA hashing all the files
to make sure they are not modified, and W^X enabled.

System-wide W^X is not only for memory, and as Madhavan said: "this RFC pertains to converting dynamic [writable] machine code to static [non-writable] code".

Quoted 4 lines

Attacker can
still execute code after buffer overflow by .... and trapoline file descriptor addrsses that"... so that people running generic systems can stop reading after first sentence.

Are you proposing to add a "[feature-not-useful-without-a-proper-system-configuration]" tag in subjects? :)