kc3-lang/libffi/src/x86/win64.S

Tag - branch -mastergithub/HEADgithub/androidgithub/appveyorgithub/cskygithub/fixmacgithub/github-actionsgithub/iosgithub/mastergithub/revert-667-mastergithub/th2github/travishackinggithub/v3.3-rc1- tag -v3.4.4v3.4.3v3.4.2v3.4.1v3.4.0-rc2v3.4.0v3.4-rc1v3.3-rc2v3.3-rc1v3.3-rc0v3.3v3.2.1v3.2v3.1v3.0.9v3.0.13v3.0.12v3.0.11v3.0.10

• Show log

  Commit

• Hash : 9ba55921
  Author :
  Date : 2021-03-05T10:07:30
  

  Static tramp v5 (#624) * Static Trampolines Closure Trampoline Security Issue ================================= Currently, the trampoline code used in libffi is not statically defined in a source file (except for MACH). The trampoline is either pre-defined machine code in a data buffer. Or, it is generated at runtime. In order to execute a trampoline, it needs to be placed in a page with executable permissions. Executable data pages are attack surfaces for attackers who may try to inject their own code into the page and contrive to have it executed. The security settings in a system may prevent various tricks used in user land to write code into a page and to have it executed somehow. On such systems, libffi trampolines would not be able to run. Static Trampoline ================= To solve this problem, the trampoline code needs to be defined statically in a source file, compiled and placed in the text segment so it can be mapped and executed naturally without any tricks. However, the trampoline needs to be able to access the closure pointer at runtime. PC-relative data referencing ============================ The solution implemented in this patch set uses PC-relative data references. The trampoline is mapped in a code page. Adjacent to the code page, a data page is mapped that contains the parameters of the trampoline: - the closure pointer - pointer to the ABI handler to jump to The trampoline code uses an offset relative to its current PC to access its data. Some architectures support PC-relative data references in the ISA itself. E.g., X64 supports RIP-relative references. For others, the PC has to somehow be loaded into a general purpose register to do PC-relative data referencing. To do this, we need to define a get_pc() kind of function and call it to load the PC in a desired register. There are two cases: 1. The call instruction pushes the return address on the stack. In this case, get_pc() will extract the return address from the stack and load it in the desired register and return. 2. The call instruction stores the return address in a designated register. In this case, get_pc() will copy the return address to the desired register and return. Either way, the PC next to the call instruction is obtained. Scratch register ================ In order to do its job, the trampoline code would need to use a scratch register. Depending on the ABI, there may not be a register available for scratch. This problem needs to be solved so that all ABIs will work. The trampoline will save two values on the stack: - the closure pointer - the original value of the scratch register This is what the stack will look like: sp before trampoline ------> -------------------- | closure pointer | -------------------- | scratch register | sp after trampoline -------> -------------------- The ABI handler can do the following as needed by the ABI: - the closure pointer can be loaded in a desired register - the scratch register can be restored to its original value - the stack pointer can be restored to its original value (the value when the trampoline was invoked) To do this, I have defined prolog code for each ABI handler. The legacy trampoline jumps to the ABI handler directly. But the static trampoline defined in this patch jumps tp the prolog code which performs the above actions before jumping to the ABI handler. Trampoline Table ================ In order to reduce the trampoline memory footprint, the trampoline code would be defined as a code array in the text segment. This array would be mapped into the address space of the caller. The mapping would, therefore, contain a trampoline table. Adjacent to the trampoline table mapping, there will be a data mapping that contains a parameter table, one parameter block for each trampoline. The parameter block will contain: - a pointer to the closure - a pointer to the ABI handler The static trampoline code would finally look like this: - Make space on the stack for the closure and the scratch register by moving the stack pointer down - Store the original value of the scratch register on the stack - Using PC-relative reference, get the closure pointer - Store the closure pointer on the stack - Using PC-relative reference, get the ABI handler pointer - Jump to the ABI handler Mapping size ============ The size of the code mapping that contains the trampoline table needs to be determined on a per architecture basis. If a particular architecture supports multiple base page sizes, then the largest supported base page size needs to be chosen. E.g., we choose 16K for ARM64. Trampoline allocation and free ============================== Static trampolines are allocated in ffi_closure_alloc() and freed in ffi_closure_free(). Normally, applications use these functions. But there are some cases out there where the user of libffi allocates and manages its own closure memory. In such cases, static trampolines cannot be used. These will fall back to using legacy trampolines. The user has to make sure that the memory is executable. ffi_closure structure ===================== I did not want to make any changes to the size of the closure structure for this feature to guarantee compatibility. But the opaque static trampoline handle needs to be stored in the closure. I have defined it as follows: - char tramp[FFI_TRAMPOLINE_SIZE]; + union { + char tramp[FFI_TRAMPOLINE_SIZE]; + void *ftramp; + }; If static trampolines are used, then tramp[] is not needed to store a dynamic trampoline. That space can be reused to store the handle. Hence, the union. Architecture Support ==================== Support has been added for x64, i386, aarch64 and arm. Support for other architectures can be added very easily in the future. OS Support ========== Support has been added for Linux. Support for other OSes can be added very easily. Signed-off-by: Madhavan T. Venkataraman <madvenka@linux.microsoft.com> * x86: Support for Static Trampolines - Define the arch-specific initialization function ffi_tramp_arch () that returns trampoline size information to common code. - Define the trampoline code mapping and data mapping sizes. - Define the trampoline code table statically. Define two tables, actually, one with CET and one without. - Introduce a tiny prolog for each ABI handling function. The ABI handlers addressed are: - ffi_closure_unix64 - ffi_closure_unix64_sse - ffi_closure_win64 The prolog functions are called: - ffi_closure_unix64_alt - ffi_closure_unix64_sse_alt - ffi_closure_win64_alt The legacy trampoline jumps to the ABI handler. The static trampoline jumps to the prolog function. The prolog function uses the information provided by the static trampoline, sets things up for the ABI handler and then jumps to the ABI handler. - Call ffi_tramp_set_parms () in ffi_prep_closure_loc () to initialize static trampoline parameters. Signed-off-by: Madhavan T. Venkataraman <madvenka@linux.microsoft.com> * i386: Support for Static Trampolines - Define the arch-specific initialization function ffi_tramp_arch () that returns trampoline size information to common code. - Define the trampoline code table statically. Define two tables, actually, one with CET and one without. - Define the trampoline code table statically. - Introduce a tiny prolog for each ABI handling function. The ABI handlers addressed are: - ffi_closure_i386 - ffi_closure_STDCALL - ffi_closure_REGISTER The prolog functions are called: - ffi_closure_i386_alt - ffi_closure_STDCALL_alt - ffi_closure_REGISTER_alt The legacy trampoline jumps to the ABI handler. The static trampoline jumps to the prolog function. The prolog function uses the information provided by the static trampoline, sets things up for the ABI handler and then jumps to the ABI handler. - Call ffi_tramp_set_parms () in ffi_prep_closure_loc () to initialize static trampoline parameters. Signed-off-by: Madhavan T. Venkataraman <madvenka@linux.microsoft.com> * arm64: Support for Static Trampolines - Define the arch-specific initialization function ffi_tramp_arch () that returns trampoline size information to common code. - Define the trampoline code mapping and data mapping sizes. - Define the trampoline code table statically. - Introduce a tiny prolog for each ABI handling function. The ABI handlers addressed are: - ffi_closure_SYSV - ffi_closure_SYSV_V The prolog functions are called: - ffi_closure_SYSV_alt - ffi_closure_SYSV_V_alt The legacy trampoline jumps to the ABI handler. The static trampoline jumps to the prolog function. The prolog function uses the information provided by the static trampoline, sets things up for the ABI handler and then jumps to the ABI handler. - Call ffi_tramp_set_parms () in ffi_prep_closure_loc () to initialize static trampoline parameters. Signed-off-by: Madhavan T. Venkataraman <madvenka@linux.microsoft.com> * arm: Support for Static Trampolines - Define the arch-specific initialization function ffi_tramp_arch () that returns trampoline size information to common code. - Define the trampoline code mapping and data mapping sizes. - Define the trampoline code table statically. - Introduce a tiny prolog for each ABI handling function. The ABI handlers addressed are: - ffi_closure_SYSV - ffi_closure_VFP The prolog functions are called: - ffi_closure_SYSV_alt - ffi_closure_VFP_alt The legacy trampoline jumps to the ABI handler. The static trampoline jumps to the prolog function. The prolog function uses the information provided by the static trampoline, sets things up for the ABI handler and then jumps to the ABI handler. - Call ffi_tramp_set_parms () in ffi_prep_closure_loc () to initialize static trampoline parameters. Signed-off-by: Madhavan T. Venkataraman <madvenka@linux.microsoft.com>

Download

• src/x86/win64.S

• #ifdef __x86_64__
  #define LIBFFI_ASM
  #include <fficonfig.h>
  #include <ffi.h>
  #include <ffi_cfi.h>
  #include "asmnames.h"
  
  #if defined(HAVE_AS_CFI_PSEUDO_OP)
          .cfi_sections   .debug_frame
  #endif
  
  #ifdef X86_WIN64
  #define SEH(...) __VA_ARGS__
  #define arg0	%rcx
  #define arg1	%rdx
  #define arg2	%r8
  #define arg3	%r9
  #else
  #define SEH(...)
  #define arg0	%rdi
  #define arg1	%rsi
  #define arg2	%rdx
  #define arg3	%rcx
  #endif
  
  /* This macro allows the safe creation of jump tables without an
     actual table.  The entry points into the table are all 8 bytes.
     The use of ORG asserts that we're at the correct location.  */
  /* ??? The clang assembler doesn't handle .org with symbolic expressions.  */
  #if defined(__clang__) || defined(__APPLE__) || (defined (__sun__) && defined(__svr4__))
  # define E(BASE, X)	.balign 8
  #else
  # define E(BASE, X)	.balign 8; .org BASE + (X) * 8
  #endif
  
  	.text
  
  /* ffi_call_win64 (void *stack, struct win64_call_frame *frame, void *r10)
  
     Bit o trickiness here -- FRAME is the base of the stack frame
     for this function.  This has been allocated by ffi_call.  We also
     deallocate some of the stack that has been alloca'd.  */
  
  	.align	8
  	.globl	C(ffi_call_win64)
  	FFI_HIDDEN(C(ffi_call_win64))
  
  	SEH(.seh_proc ffi_call_win64)
  C(ffi_call_win64):
  	cfi_startproc
  	_CET_ENDBR
  	/* Set up the local stack frame and install it in rbp/rsp.  */
  	movq	(%rsp), %rax
  	movq	%rbp, (arg1)
  	movq	%rax, 8(arg1)
  	movq	arg1, %rbp
  	cfi_def_cfa(%rbp, 16)
  	cfi_rel_offset(%rbp, 0)
  	SEH(.seh_pushreg %rbp)
  	SEH(.seh_setframe %rbp, 0)
  	SEH(.seh_endprologue)
  	movq	arg0, %rsp
  
  	movq	arg2, %r10
  
  	/* Load all slots into both general and xmm registers.  */
  	movq	(%rsp), %rcx
  	movsd	(%rsp), %xmm0
  	movq	8(%rsp), %rdx
  	movsd	8(%rsp), %xmm1
  	movq	16(%rsp), %r8
  	movsd	16(%rsp), %xmm2
  	movq	24(%rsp), %r9
  	movsd	24(%rsp), %xmm3
  
  	call	*16(%rbp)
  
  	movl	24(%rbp), %ecx
  	movq	32(%rbp), %r8
  	leaq	0f(%rip), %r10
  	cmpl	$FFI_TYPE_SMALL_STRUCT_4B, %ecx
  	leaq	(%r10, %rcx, 8), %r10
  	ja	99f
  	_CET_NOTRACK jmp *%r10
  
  /* Below, we're space constrained most of the time.  Thus we eschew the
     modern "mov, pop, ret" sequence (5 bytes) for "leave, ret" (2 bytes).  */
  .macro epilogue
  	leaveq
  	cfi_remember_state
  	cfi_def_cfa(%rsp, 8)
  	cfi_restore(%rbp)
  	ret
  	cfi_restore_state
  .endm
  
  	.align	8
  0:
  E(0b, FFI_TYPE_VOID)
  	epilogue
  E(0b, FFI_TYPE_INT)
  	movslq	%eax, %rax
  	movq	%rax, (%r8)
  	epilogue
  E(0b, FFI_TYPE_FLOAT)
  	movss	%xmm0, (%r8)
  	epilogue
  E(0b, FFI_TYPE_DOUBLE)
  	movsd	%xmm0, (%r8)
  	epilogue
  // FFI_TYPE_LONGDOUBLE may be FFI_TYPE_DOUBLE but we need a different value here.
  E(0b, FFI_TYPE_DOUBLE + 1)
  	call	PLT(C(abort))
  E(0b, FFI_TYPE_UINT8)
  	movzbl	%al, %eax
  	movq	%rax, (%r8)
  	epilogue
  E(0b, FFI_TYPE_SINT8)
  	movsbq	%al, %rax
  	jmp	98f
  E(0b, FFI_TYPE_UINT16)
  	movzwl	%ax, %eax
  	movq	%rax, (%r8)
  	epilogue
  E(0b, FFI_TYPE_SINT16)
  	movswq	%ax, %rax
  	jmp	98f
  E(0b, FFI_TYPE_UINT32)
  	movl	%eax, %eax
  	movq	%rax, (%r8)
  	epilogue
  E(0b, FFI_TYPE_SINT32)
  	movslq	%eax, %rax
  	movq	%rax, (%r8)
  	epilogue
  E(0b, FFI_TYPE_UINT64)
  98:	movq	%rax, (%r8)
  	epilogue
  E(0b, FFI_TYPE_SINT64)
  	movq	%rax, (%r8)
  	epilogue
  E(0b, FFI_TYPE_STRUCT)
  	epilogue
  E(0b, FFI_TYPE_POINTER)
  	movq	%rax, (%r8)
  	epilogue
  E(0b, FFI_TYPE_COMPLEX)
  	call	PLT(C(abort))
  E(0b, FFI_TYPE_SMALL_STRUCT_1B)
  	movb	%al, (%r8)
  	epilogue
  E(0b, FFI_TYPE_SMALL_STRUCT_2B)
  	movw	%ax, (%r8)
  	epilogue
  E(0b, FFI_TYPE_SMALL_STRUCT_4B)
  	movl	%eax, (%r8)
  	epilogue
  
  	.align	8
  99:	call	PLT(C(abort))
  
  	epilogue
  
  	cfi_endproc
  	SEH(.seh_endproc)
  
  
  /* 32 bytes of outgoing register stack space, 8 bytes of alignment,
     16 bytes of result, 32 bytes of xmm registers.  */
  #define ffi_clo_FS	(32+8+16+32)
  #define ffi_clo_OFF_R	(32+8)
  #define ffi_clo_OFF_X	(32+8+16)
  
  	.align	8
  	.globl	C(ffi_go_closure_win64)
  	FFI_HIDDEN(C(ffi_go_closure_win64))
  
  	SEH(.seh_proc ffi_go_closure_win64)
  C(ffi_go_closure_win64):
  	cfi_startproc
  	_CET_ENDBR
  	/* Save all integer arguments into the incoming reg stack space.  */
  	movq	%rcx, 8(%rsp)
  	movq	%rdx, 16(%rsp)
  	movq	%r8, 24(%rsp)
  	movq	%r9, 32(%rsp)
  
  	movq	8(%r10), %rcx			/* load cif */
  	movq	16(%r10), %rdx			/* load fun */
  	movq	%r10, %r8			/* closure is user_data */
  	jmp	0f
  	cfi_endproc
  	SEH(.seh_endproc)
  
  	.align	8
  	.globl	C(ffi_closure_win64)
  	FFI_HIDDEN(C(ffi_closure_win64))
  
  	SEH(.seh_proc ffi_closure_win64)
  C(ffi_closure_win64):
  	cfi_startproc
  	_CET_ENDBR
  	/* Save all integer arguments into the incoming reg stack space.  */
  	movq	%rcx, 8(%rsp)
  	movq	%rdx, 16(%rsp)
  	movq	%r8, 24(%rsp)
  	movq	%r9, 32(%rsp)
  
  	movq	FFI_TRAMPOLINE_SIZE(%r10), %rcx		/* load cif */
  	movq	FFI_TRAMPOLINE_SIZE+8(%r10), %rdx	/* load fun */
  	movq	FFI_TRAMPOLINE_SIZE+16(%r10), %r8	/* load user_data */
  0:
  	subq	$ffi_clo_FS, %rsp
  	cfi_adjust_cfa_offset(ffi_clo_FS)
  	SEH(.seh_stackalloc ffi_clo_FS)
  	SEH(.seh_endprologue)
  
  	/* Save all sse arguments into the stack frame.  */
  	movsd	%xmm0, ffi_clo_OFF_X(%rsp)
  	movsd	%xmm1, ffi_clo_OFF_X+8(%rsp)
  	movsd	%xmm2, ffi_clo_OFF_X+16(%rsp)
  	movsd	%xmm3, ffi_clo_OFF_X+24(%rsp)
  
  	leaq	ffi_clo_OFF_R(%rsp), %r9
  	call	PLT(C(ffi_closure_win64_inner))
  
  	/* Load the result into both possible result registers.  */
  	movq    ffi_clo_OFF_R(%rsp), %rax
  	movsd   ffi_clo_OFF_R(%rsp), %xmm0
  
  	addq	$ffi_clo_FS, %rsp
  	cfi_adjust_cfa_offset(-ffi_clo_FS)
  	ret
  
  	cfi_endproc
  	SEH(.seh_endproc)
  
  #if defined(FFI_EXEC_STATIC_TRAMP)
  	.align	8
  	.globl	C(ffi_closure_win64_alt)
  	FFI_HIDDEN(C(ffi_closure_win64_alt))
  
  	SEH(.seh_proc ffi_closure_win64_alt)
  C(ffi_closure_win64_alt):
  	_CET_ENDBR
  	movq	8(%rsp), %r10
  	addq	$16, %rsp
  	jmp	C(ffi_closure_win64)
  	SEH(.seh_endproc)
  #endif
  #endif /* __x86_64__ */
  
  #if defined __ELF__ && defined __linux__
  	.section	.note.GNU-stack,"",@progbits
  #endif
  

Download