llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-libcxxabi @llvm/pr-subscribers-libunwind Author: Oliver Hunt (ojhunt) <details> <summary>Changes</summary> This hardens the unwinding logic and datastructures on systems that support pointer authentication. The approach taken to hardening is to harden the schemas of as many high value fields in the myriad structs as possible, and then also explicitly qualify local variables referencing privileged or security critical values. This ABI is exposed to the personality functions, and so updating to conform to that is a mandatory change, but to reduce the risk of oracles, the adoption also hardened the locals and datastructures in compiler-rt and libcxxabi. We're gating these on `defined(__APPLE__)` so other platforms are able to qualify before enabling. An alternative would be an feature flag that could be used instead but I didn't want to force such a change if it was not considered necessary. --- Patch is 51.36 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/143230.diff 14 Files Affected: - (modified) compiler-rt/lib/builtins/gcc_personality_v0.c (+63-6) - (modified) compiler-rt/lib/profile/InstrProfilingValue.c (+7-1) - (modified) libcxxabi/include/__cxxabi_config.h (+47-1) - (modified) libcxxabi/src/cxa_exception.h (+16-14) - (modified) libcxxabi/src/cxa_personality.cpp (+61-8) - (modified) libunwind/include/libunwind.h (+70-8) - (modified) libunwind/src/AddressSpace.hpp (+30-14) - (modified) libunwind/src/DwarfInstructions.hpp (+8-3) - (modified) libunwind/src/DwarfParser.hpp (+40-4) - (modified) libunwind/src/Registers.hpp (+109-4) - (modified) libunwind/src/UnwindCursor.hpp (+55-17) - (modified) libunwind/src/UnwindLevel1.c (+30-6) - (modified) libunwind/src/UnwindRegistersSave.S (+10) - (modified) libunwind/src/libunwind.cpp (+34) ``````````diff diff --git a/compiler-rt/lib/builtins/gcc_personality_v0.c b/compiler-rt/lib/builtins/gcc_personality_v0.c index ef63a5fb83472..42b992949d2cc 100644 --- a/compiler-rt/lib/builtins/gcc_personality_v0.c +++ b/compiler-rt/lib/builtins/gcc_personality_v0.c @@ -30,6 +30,45 @@ EXCEPTION_DISPOSITION _GCC_specific_handler(PEXCEPTION_RECORD, void *, PCONTEXT, _Unwind_Personality_Fn); #endif +#if __has_include(<ptrauth.h>) +#include <ptrauth.h> +#endif + +#if defined(__APPLE__) && __has_feature(ptrauth_qualifier) +#if __has_feature(ptrauth_restricted_intptr_qualifier) +#define PERSONALITY_PTRAUTH_RESTRICTED_INTPTR(key, addressDiscriminated, \ + discriminatorString) \ + __ptrauth_restricted_intptr(key, addressDiscriminated, \ + ptrauth_string_discriminator(discriminatorString)) +#else +#define PERSONALITY_PTRAUTH_RESTRICTED_INTPTR(key, addressDiscriminated, \ + discriminatorString) \ + __ptrauth(key, addressDiscriminated, \ + ptrauth_string_discriminator(discriminatorString)) +#endif +#else +#define PERSONALITY_PTRAUTH_RESTRICTED_INTPTR(key, addressDiscriminated, \ + discriminatorString) +#endif + +// Helper wrappers for pointer auth qualifiers because we use a lot of variants +// Suffixes: +// * PDC : ptrauth_key_process_dependent_code +// * RA : ptrauth_key_return_address +// * FN : ptrauth_key_function_pointer +#define PERSONALITY_PTRAUTH_RI_FN(__discriminator) \ + PERSONALITY_PTRAUTH_RESTRICTED_INTPTR(ptrauth_key_function_pointer, \ + /*__address_discriminated=*/1, \ + __discriminator) +#define PERSONALITY_PTRAUTH_RI_PDC(__discriminator) \ + PERSONALITY_PTRAUTH_RESTRICTED_INTPTR(ptrauth_key_process_dependent_code, \ + /*__address_discriminated=*/1, \ + __discriminator) +#define PERSONALITY_PTRAUTH_RI_RA(__discriminator) \ + PERSONALITY_PTRAUTH_RESTRICTED_INTPTR(ptrauth_key_return_address, \ + /*__address_discriminated=*/1, \ + __discriminator) + // Pointer encodings documented at: // http://refspecs.freestandards.org/LSB_1.3.0/gLSB/gLSB/ehframehdr.html @@ -205,7 +244,8 @@ COMPILER_RT_ABI _Unwind_Reason_Code __gcc_personality_v0( return continueUnwind(exceptionObject, context); uintptr_t pc = (uintptr_t)_Unwind_GetIP(context) - 1; - uintptr_t funcStart = (uintptr_t)_Unwind_GetRegionStart(context); + uintptr_t PERSONALITY_PTRAUTH_RI_FN("__gcc_personality_v0'funcStart") + funcStart = (uintptr_t)_Unwind_GetRegionStart(context); uintptr_t pcOffset = pc - funcStart; // Parse LSDA header. @@ -224,11 +264,14 @@ COMPILER_RT_ABI _Unwind_Reason_Code __gcc_personality_v0( const uint8_t *callSiteTableEnd = callSiteTableStart + callSiteTableLength; const uint8_t *p = callSiteTableStart; while (p < callSiteTableEnd) { - uintptr_t start = readEncodedPointer(&p, callSiteEncoding); - size_t length = readEncodedPointer(&p, callSiteEncoding); - size_t landingPad = readEncodedPointer(&p, callSiteEncoding); + uintptr_t PERSONALITY_PTRAUTH_RI_PDC("__gcc_personality_v0'start") + start = readEncodedPointer(&p, callSiteEncoding); + size_t PERSONALITY_PTRAUTH_RI_PDC("__gcc_personality_v0'length") + length = readEncodedPointer(&p, callSiteEncoding); + size_t PERSONALITY_PTRAUTH_RI_PDC("__gcc_personality_v0'landingPadOffset") + landingPadOffset = readEncodedPointer(&p, callSiteEncoding); readULEB128(&p); // action value not used for C code - if (landingPad == 0) + if (landingPadOffset == 0) continue; // no landing pad for this entry if ((start <= pcOffset) && (pcOffset < (start + length))) { // Found landing pad for the PC. @@ -238,7 +281,21 @@ COMPILER_RT_ABI _Unwind_Reason_Code __gcc_personality_v0( _Unwind_SetGR(context, __builtin_eh_return_data_regno(0), (uintptr_t)exceptionObject); _Unwind_SetGR(context, __builtin_eh_return_data_regno(1), 0); - _Unwind_SetIP(context, (funcStart + landingPad)); +#define LANDING_PAD_DISCRIMINATOR "__gcc_personality_v0'landingPad" + size_t PERSONALITY_PTRAUTH_RI_RA(LANDING_PAD_DISCRIMINATOR) + landingPad = funcStart + landingPadOffset; +#if defined(__APPLE__) && __has_feature(ptrauth_qualifier) + uintptr_t stack_pointer = _Unwind_GetGR(context, -2); + const uintptr_t existingDiscriminator = ptrauth_blend_discriminator( + &landingPad, + ptrauth_string_discriminator(LANDING_PAD_DISCRIMINATOR)); + uintptr_t newIP = (uintptr_t)ptrauth_auth_and_resign( + *(void **)&landingPad, ptrauth_key_function_pointer, + existingDiscriminator, ptrauth_key_return_address, stack_pointer); + _Unwind_SetIP(context, newIP); +#else + _Unwind_SetIP(context, landingPad); +#endif return _URC_INSTALL_CONTEXT; } } diff --git a/compiler-rt/lib/profile/InstrProfilingValue.c b/compiler-rt/lib/profile/InstrProfilingValue.c index a608d41d39e77..cd6ae3d7a4248 100644 --- a/compiler-rt/lib/profile/InstrProfilingValue.c +++ b/compiler-rt/lib/profile/InstrProfilingValue.c @@ -83,7 +83,13 @@ __llvm_profile_iterate_data(const __llvm_profile_data *Data) { /* This method is only used in value profiler mock testing. */ COMPILER_RT_VISIBILITY void * __llvm_get_function_addr(const __llvm_profile_data *Data) { - return Data->FunctionPointer; + void *FP = Data->FunctionPointer; +#if __has_feature(ptrauth_calls) + // This is only used for tests where we compare against what happens to be + // signed pointers. + FP = ptrauth_sign_unauthenticated(FP, VALID_CODE_KEY, 0); +#endif + return FP; } /* Allocate an array that holds the pointers to the linked lists of diff --git a/libcxxabi/include/__cxxabi_config.h b/libcxxabi/include/__cxxabi_config.h index 759445dac91f9..e67d065fe57f3 100644 --- a/libcxxabi/include/__cxxabi_config.h +++ b/libcxxabi/include/__cxxabi_config.h @@ -32,7 +32,8 @@ #endif #if defined(_WIN32) - #if defined(_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS) || (defined(__MINGW32__) && !defined(_LIBCXXABI_BUILDING_LIBRARY)) + #if defined(_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS) || \ + (defined(__MINGW32__) && !defined(_LIBCXXABI_BUILDING_LIBRARY)) #define _LIBCXXABI_HIDDEN #define _LIBCXXABI_DATA_VIS #define _LIBCXXABI_FUNC_VIS @@ -109,4 +110,49 @@ # define _LIBCXXABI_NOEXCEPT noexcept #endif +#if __has_include(<ptrauth.h>) +#include <ptrauth.h> +#endif + +#if defined(__APPLE__) && __has_feature(ptrauth_qualifier) +# define _LIBCXXABI_PTRAUTH(__key, __address_discriminated, __discriminator) \ + __ptrauth(__key,__address_discriminated, \ + ptrauth_string_discriminator(__discriminator)) +// This work around is required to support divergence in spelling +// during the ptrauth upstreaming process. +# if __has_feature(ptrauth_restricted_intptr_qualifier) +# define _LIBCXXABI_PTRAUTH_RESTRICTED_INTPTR(__key, __address_discriminated, \ + __discriminator) \ + __ptrauth_restricted_intptr(__key,__address_discriminated, \ + ptrauth_string_discriminator(__discriminator)) +# else +# define _LIBCXXABI_PTRAUTH_RESTRICTED_INTPTR(__key, __address_discriminated, \ + __discriminator) \ + __ptrauth(__key,__address_discriminated, \ + ptrauth_string_discriminator(__discriminator)) +# endif +#else +# define _LIBCXXABI_PTRAUTH(__key, __address_discriminated, __discriminator) +# define _LIBCXXABI_PTRAUTH_RESTRICTED_INTPTR(__key, __address_discriminated, \ + __discriminator) +#endif + +// Helper wrappers for pointer auth qualifiers because we use a lot of variants +// Suffixes: +// * _RI : qualifier is __ptrauth_restricted_intptr +// * PDD : key is ptrauth_key_process_dependent_data +// * FN : key is ptrauth_key_function_pointer +#define _LIBCXXABI_PTRAUTH_PDD(__discriminator) \ + _LIBCXXABI_PTRAUTH(ptrauth_key_process_dependent_data, \ + /*__address_discriminated=*/1, \ + __discriminator) +#define _LIBCXXABI_PTRAUTH_FN(__discriminator) \ + _LIBCXXABI_PTRAUTH(ptrauth_key_function_pointer, \ + /*__address_discriminated=*/1, \ + __discriminator) +#define _LIBCXXABI_PTRAUTH_RI_PDD(__discriminator) \ + _LIBCXXABI_PTRAUTH_RESTRICTED_INTPTR(ptrauth_key_process_dependent_data, \ + /*__address_discriminated=*/1, \ + __discriminator) + #endif // ____CXXABI_CONFIG_H diff --git a/libcxxabi/src/cxa_exception.h b/libcxxabi/src/cxa_exception.h index aba08f2992103..4c69d48048f02 100644 --- a/libcxxabi/src/cxa_exception.h +++ b/libcxxabi/src/cxa_exception.h @@ -47,10 +47,10 @@ struct _LIBCXXABI_HIDDEN __cxa_exception { // In Wasm, a destructor returns its argument void *(_LIBCXXABI_DTOR_FUNC *exceptionDestructor)(void *); #else - void (_LIBCXXABI_DTOR_FUNC *exceptionDestructor)(void *); + void(_LIBCXXABI_DTOR_FUNC* _LIBCXXABI_PTRAUTH_FN("__cxa_exception::exceptionDestructor") exceptionDestructor)(void*); #endif - std::unexpected_handler unexpectedHandler; - std::terminate_handler terminateHandler; + std::unexpected_handler _LIBCXXABI_PTRAUTH_FN("__cxa_exception::unexpectedHandler") unexpectedHandler; + std::terminate_handler _LIBCXXABI_PTRAUTH_FN("__cxa_exception::terminateHandler") terminateHandler; __cxa_exception *nextException; @@ -61,10 +61,10 @@ struct _LIBCXXABI_HIDDEN __cxa_exception { int propagationCount; #else int handlerSwitchValue; - const unsigned char *actionRecord; - const unsigned char *languageSpecificData; - void *catchTemp; - void *adjustedPtr; + const unsigned char* _LIBCXXABI_PTRAUTH_PDD("__cxa_exception::actionRecord") actionRecord; + const unsigned char* _LIBCXXABI_PTRAUTH_PDD("__cxa_exception::languageSpecificData") languageSpecificData; + void* _LIBCXXABI_PTRAUTH_PDD("__cxa_exception::catchTemp") catchTemp; + void* _LIBCXXABI_PTRAUTH_PDD("__cxa_exception::adjustedPtr") adjustedPtr; #endif #if !defined(__LP64__) && !defined(_WIN64) && !defined(_LIBCXXABI_ARM_EHABI) @@ -79,6 +79,8 @@ struct _LIBCXXABI_HIDDEN __cxa_exception { // http://sourcery.mentor.com/archives/cxx-abi-dev/msg01924.html // The layout of this structure MUST match the layout of __cxa_exception, with // primaryException instead of referenceCount. +// The tags used in the pointer authentication qualifiers also need to match +// those of the corresponding members in __cxa_exception. struct _LIBCXXABI_HIDDEN __cxa_dependent_exception { #if defined(__LP64__) || defined(_WIN64) || defined(_LIBCXXABI_ARM_EHABI) void* reserve; // padding. @@ -86,9 +88,9 @@ struct _LIBCXXABI_HIDDEN __cxa_dependent_exception { #endif std::type_info *exceptionType; - void (_LIBCXXABI_DTOR_FUNC *exceptionDestructor)(void *); - std::unexpected_handler unexpectedHandler; - std::terminate_handler terminateHandler; + void(_LIBCXXABI_DTOR_FUNC* _LIBCXXABI_PTRAUTH_FN("__cxa_exception::exceptionDestructor") exceptionDestructor)(void*); + std::unexpected_handler _LIBCXXABI_PTRAUTH_FN("__cxa_exception::unexpectedHandler") unexpectedHandler; + std::terminate_handler _LIBCXXABI_PTRAUTH_FN("__cxa_exception::terminateHandler") terminateHandler; __cxa_exception *nextException; @@ -99,10 +101,10 @@ struct _LIBCXXABI_HIDDEN __cxa_dependent_exception { int propagationCount; #else int handlerSwitchValue; - const unsigned char *actionRecord; - const unsigned char *languageSpecificData; - void * catchTemp; - void *adjustedPtr; + const unsigned char* _LIBCXXABI_PTRAUTH_PDD("__cxa_exception::actionRecord") actionRecord; + const unsigned char* _LIBCXXABI_PTRAUTH_PDD("__cxa_exception::languageSpecificData") languageSpecificData; + void* _LIBCXXABI_PTRAUTH_PDD("__cxa_exception::catchTemp") catchTemp; + void* _LIBCXXABI_PTRAUTH_PDD("__cxa_exception::adjustedPtr") adjustedPtr; #endif #if !defined(__LP64__) && !defined(_WIN64) && !defined(_LIBCXXABI_ARM_EHABI) diff --git a/libcxxabi/src/cxa_personality.cpp b/libcxxabi/src/cxa_personality.cpp index 5f6e75c5be19c..cbb3f46e0f55c 100644 --- a/libcxxabi/src/cxa_personality.cpp +++ b/libcxxabi/src/cxa_personality.cpp @@ -22,6 +22,12 @@ #include "private_typeinfo.h" #include "unwind.h" +#if __has_include(<ptrauth.h>) +#include <ptrauth.h> +#endif + +#include "libunwind.h" + // TODO: This is a temporary workaround for libc++abi to recognize that it's being // built against LLVM's libunwind. LLVM's libunwind started reporting _LIBUNWIND_VERSION // in LLVM 15 -- we can remove this workaround after shipping LLVM 17. Once we remove @@ -527,12 +533,19 @@ get_thrown_object_ptr(_Unwind_Exception* unwind_exception) namespace { +#define _LIBCXXABI_PTRAUTH_KEY ptrauth_key_process_dependent_code +typedef const uint8_t* _LIBCXXABI_PTRAUTH_PDD("scan_results::languageSpecificData") lsd_ptr_t; +typedef const uint8_t* _LIBCXXABI_PTRAUTH_PDD("scan_results::actionRecord") action_ptr_t; +#define _LIBCXXABI_PTRAUTH_SCANRESULT_LANDINGPAD_DISC "scan_results::landingPad" +typedef uintptr_t _LIBCXXABI_PTRAUTH_RI_PDD(_LIBCXXABI_PTRAUTH_SCANRESULT_LANDINGPAD_DISC) landing_pad_t; +typedef void* _LIBCXXABI_PTRAUTH_PDD(_LIBCXXABI_PTRAUTH_SCANRESULT_LANDINGPAD_DISC) landing_pad_ptr_t; + struct scan_results { int64_t ttypeIndex; // > 0 catch handler, < 0 exception spec handler, == 0 a cleanup - const uint8_t* actionRecord; // Currently unused. Retained to ease future maintenance. - const uint8_t* languageSpecificData; // Needed only for __cxa_call_unexpected - uintptr_t landingPad; // null -> nothing found, else something found + action_ptr_t actionRecord; // Currently unused. Retained to ease future maintenance. + lsd_ptr_t languageSpecificData; // Needed only for __cxa_call_unexpected + landing_pad_t landingPad; // null -> nothing found, else something found void* adjustedPtr; // Used in cxa_exception.cpp _Unwind_Reason_Code reason; // One of _URC_FATAL_PHASE1_ERROR, // _URC_FATAL_PHASE2_ERROR, @@ -541,7 +554,33 @@ struct scan_results }; } // unnamed namespace +} +namespace { +// The logical model for casting authenticated function pointers makes +// it impossible to directly cast them without breaking the authentication, +// as a result we need this pair of helpers. +template <typename PtrType> +void set_landing_pad_as_ptr(scan_results& results, const PtrType& out) { + union { + landing_pad_t* as_landing_pad; + landing_pad_ptr_t* as_pointer; + } u; + u.as_landing_pad = &results.landingPad; + *u.as_pointer = out; +} + +static const landing_pad_ptr_t& get_landing_pad_as_ptr(const scan_results& results) { + union { + const landing_pad_t* as_landing_pad; + const landing_pad_ptr_t* as_pointer; + } u; + u.as_landing_pad = &results.landingPad; + return *u.as_pointer; +} +} // unnamed namespace + +extern "C" { static void set_registers(_Unwind_Exception* unwind_exception, _Unwind_Context* context, @@ -557,7 +596,22 @@ set_registers(_Unwind_Exception* unwind_exception, _Unwind_Context* context, reinterpret_cast<uintptr_t>(unwind_exception)); _Unwind_SetGR(context, __builtin_eh_return_data_regno(1), static_cast<uintptr_t>(results.ttypeIndex)); +#if defined(__APPLE__) && __has_feature(ptrauth_qualifier) + auto stack_pointer = _Unwind_GetGR(context, UNW_REG_SP); + // We manually re-sign the IP as the __ptrauth qualifiers cannot + // express the required relationship with the destination address + const auto existingDiscriminator = ptrauth_blend_discriminator( + &results.landingPad, + ptrauth_string_discriminator(_LIBCXXABI_PTRAUTH_SCANRESULT_LANDINGPAD_DISC)); + unw_word_t newIP = (unw_word_t)ptrauth_auth_and_resign(*(void**)&results.landingPad, + _LIBCXXABI_PTRAUTH_KEY, + existingDiscriminator, + ptrauth_key_return_address, + stack_pointer); + _Unwind_SetIP(context, newIP); +#else _Unwind_SetIP(context, results.landingPad); +#endif } /* @@ -691,12 +745,12 @@ static void scan_eh_tab(scan_results &results, _Unwind_Action actions, // The call sites are ordered in increasing value of start uintptr_t start = readEncodedPointer(&callSitePtr, callSiteEncoding); uintptr_t length = readEncodedPointer(&callSitePtr, callSiteEncoding); - uintptr_t landingPad = readEncodedPointer(&callSitePtr, callSiteEncoding); + landing_pad_t landingPad = readEncodedPointer(&callSitePtr, callSiteEncoding); uintptr_t actionEntry = readULEB128(&callSitePtr); if ((start <= ipOffset) && (ipOffset < (start + length))) #else // __USING_SJLJ_EXCEPTIONS__ || __WASM_EXCEPTIONS__ // ip is 1-based index into this table - uintptr_t landingPad = readULEB128(&callSitePtr); + landing_pad_t landingPad = readULEB128(&callSitePtr); uintptr_t actionEntry = readULEB128(&callSitePtr); if (--ip == 0) #endif // __USING_SJLJ_EXCEPTIONS__ || __WASM_EXCEPTIONS__ @@ -935,8 +989,7 @@ __gxx_personality_v0 results.ttypeIndex = exception_header->handlerSwitchValue; results.actionRecord = exception_header->actionRecord; results.languageSpecificData = exception_header->languageSpecificData; - results.landingPad = - reinterpret_cast<uintptr_t>(exception_header->catchTemp); + set_landing_pad_as_ptr(results, exception_header->catchTemp); results.adjustedPtr = exception_header->adjustedPtr; // Jump to the handler. @@ -970,7 +1023,7 @@ __gxx_personality_v0 exc->handlerSwitchValue = static_cast<int>(results.ttypeIndex); exc->actionRecord = results.actionRecord; exc->languageSpecificData = results.languageSpecificData; - exc->catchTemp = reinterpret_cast<void*>(results.landingPad); + exc->catchTemp = get_landing_pad_as_ptr(results); exc->adjustedPtr = results.adjustedPtr; #ifdef __WASM_EXCEPTIONS__ // Wasm only uses a single phase (_UA_SEARCH_PHASE), so save the diff --git a/libunwind/include/libunwind.h b/libunwind/include/libunwind.h index b2dae8feed9a3..e7375bbca1b3d 100644 --- a/libunwind/include/libunwind.h +++ b/libunwind/include/libunwind.h @@ -43,6 +43,61 @@ #define LIBUNWIND_AVAIL #endif +#if __has_include(<ptrauth.h>) +#include <ptrauth.h> +#endif + +#if defined(__APPLE__) && __has_feature(ptrauth_qualifier) +#define _LIBUNWIND_PTRAUTH(__key, __address_discriminated, __discriminator) \ + __ptrauth(__key, __address_discriminated, \ + ptrauth_string_discriminator(__discriminator)) +// This work around is required to support divergence in spelling +// developed during the ptrauth upstreaming process. +#if __has_feature(ptrauth_restricted_intptr_qualifier) +#define _LIBUNWIND_PTRAUTH_RESTRICTED_INTPTR(__key, __address_discriminated, \ + __discriminator) \ + __ptrauth_restricted_intptr(__key, __address_discriminated, \ + ptrauth_string_discriminator(__discriminator... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/143230 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
