[ Close ]
Enter something in the search box to see results



Issues:[ 1 ][ 2 ][ 3 ][ 4 ][ 5 ][ 6 ][ 7 ][ 8 ][ 9 ][ 10 ][ 11 ][ 12 ][ 13 ][ 14 ][ 15 ][ 16 ][ 17 ][ 18 ][ 19 ][ 20 ][ 21 ][ 22 ][ 23 ][ 24 ][ 25 ][ 26 ][ 27 ][ 28 ][ 29 ][ 30 ][ 31 ][ 32 ][ 33 ][ 34 ][ 35 ][ 36 ][ 37 ][ 38 ][ 39 ][ 40 ][ 41 ][ 42 ][ 43 ][ 44 ][ 45 ][ 46 ][ 47 ][ 48 ][ 49 ][ 50 ][ 51 ][ 52 ][ 53 ][ 54 ][ 55 ][ 56 ][ 57 ][ 58 ][ 59 ][ 60 ][ 61 ][ 62 ][ 63 ][ 64 ][ 65 ][ 66 ][ 67 ][ 68 ][ 69 ][ 70 ][ 71 ][ 72 ][ 73 ]
Current issue : #73 | Release date : 2026-11-17 | Editor : Phrack Staff
IntroductionPhrack Staff
Phrack Prophile on Halvar FlakePhrack Staff
LinenoisePhrack Staff
Escaping from a Docker container through vDSOandersonc0d3
Owning the Truth: Undecidability, unsound kernels, and the forging of proofendrazine, veorq
Cryptographic Ideas for TCC BypassesJonathan Bar Or
Word Machines for Weird Machinesnoperator
Beyond the Facade :: Exposing Smart GiantsLiquidWorm
The Art of Staying HiddenMatheuZSecurity
Reflections on Trusting AI: A Virus Inside an LLMmarver
QNX Userland Shellcode ComponentsClaes M Sjoberg
UAF Exploitation in the Sheaves Eraw1sdom
From PhrackCTF to Two WinFsp 0-daysLucas Tay
fortify-headers: standalone portable header-based implementation of FORTIFY_SOURCE=3jvoisin, sin
Poor Little ChunksAx
The Silent Fleet: AUVs -- Autonomous Underwater VehiclesAmitay Dan
MOLE - A Binary Ninja Plugin for Static Taint AnalysisDamian Pfammatter
Backdoor attacks against Machine Learning IRLG. Cherubin
A Journey Into Kernel Exploit Development in the LLM EraJuefei Pu, Yifan Wu, Kareem Shehada, Zhiyun Qian
Abusing the Windows Smart Card Minidriver ArchitectureMarc Barrantes
Painting Out of the Box: Escaping the Chromium Renderer Sandbox via SkiaQuang Luong
Semantic Abuse of the Linux IIO SubsystemSalah Triki
Disassembly, Flux, and Runtime Hijinksfoosc
Mystique - An x86 Metamorphic CompilerwK
Security is failure: Every Patch Is a GuessTedsig42
The Moon vs The Shield: A Study of Heap Feng Shui Using Lua3nso
HISTORY: Phrack World HistoryPhrack Staff
HISTORY: The 2000 SSH1 exploit that broke the Internetlcamtuf, scut, dvorak, scrippie, portal, gera, skyper
HISTORY: The 2003 Linux Kernel BackdoorAnonymous
HISTORY: BlueBoxing - Myths and Feelingsgamma, skyper
HISTORY: The Proxy That Made No SenseMikko Hypponen

Title : fortify-headers: standalone portable header-based implementation of FORTIFY_SOURCE=3

Author : jvoisin, sin
|=-----------------------------------------------------------------------=|
|=----------------=[ fortify-headers: standalone portable ]=-------------=|
|=-----------=[ header-based implementation of FORTIFY_SOURCE=3 ]=-------=|
|=-----------------------------------------------------------------------=|
|=---------------=[ jvoisin - dustri.org | sin - 2f30.org ]=-------------=|
|=-----------------------------------------------------------------------=|

--[ 0 - What's fortifying? ]-----------------------------------------------

Compiler's role has historically been to ingest source code and produce
the fastest possible binary. But as they're getting smarter and smarter,
they're now able to help a great deal with producing non-exploitable code,
even in the presence of vulnerabilities. While they're becoming smarter
over time, compilers can't infer all security-related invariants, and it's
up to the developers to annotate their code to make them explicit.

The 21st of September 2004, Jakub Jelinek from Red Hat sent a patch [1] to
GCC to make it possible to obtain the size of an object from inside the
code, via the newly introduced `__builtin_object_size` builtin function.
The end-goal was to take advantage of it to increase the safety of
strings/pointers manipulating functions in the glibc, by checking for
overflows at compile time when possible, and at runtime otherwise. The
feature was named `FORTIFY_SOURCE`.

To ease adoption, several protection levels were implemented. By default,
on level zero, no checks are done. On GCC 4.0+, and with optimizations
level above 0, two levels are available:

- `-D_FORTIFY_SOURCE=1`: security measures that shouldn't change behaviour
  of conforming programs are taken. In practise, this means checks are
  done only at compile-time.
- `-D_FORTIFY_SOURCE=2`: like level 1, but augmented with more checks, at
  the price of maybe breaking some conforming (but vulnerable) programs.

The 1st of February 2021, glibc 2.33 was released with an additional level
of `FORTIFY_SOURCE`: `FORTIFY_SOURCE=3`. It required LLVM >= 9 (released
in 2019) [2] or GCC >= 12.0 (released in 2022) [3], meaning that the GCC
version at the time (10.2) didn't support this feature. While
`FORTIFY_SOURCE=2` uses `__builtin_object_size`, `FORTIFY_SOURCE=3` uses
the much more powerful `__builtin_dynamic_object_size` [4]: the
computation of the object size is not limited to being a compile time
constant anymore, a small amount of runtime evaluation is permitted.

Now, not everyone is using the glibc, and implementing fortify for every
single libc around sounds like a lot of work. Which is why Dimitris "sin"
Papastamos, from the 2f30 collective [5] implemented `FORTIFY_SOURCE=2`
(now `FORTIFY_SOURCE=3`) [6] for libc that don't implement
`FORTIFY_SOURCE` on their own, by using compiler extensions and black
magic. The point of this article is to look behind the curtain, to
demystify and marvel at the aforementioned black magic.


--[ 1 - Functions hooking ]------------------------------------------------

The C language doesn't have functions hooking mechanism, so how are we
going to fortify interesting libc functions while keeping the amount of
gross hacks to a minimum? 

Self-introspection for runtime patching is gross, so nope. While
overriding function names via macros is legal in C, it's falling apart as
soon as pointers to the overridden functions are used. It's also illegal
in C++.

One might be tempted to mumble about the `overloadable` attribute, that
Clang [7] provides (GCC doesn't [8], but it can be emulated with C11's
`_Generic`.). Unfortunately, it can't help us here as it can only, as its
name implies, do functions overloading. We don't need to declare functions
with the same name but different prototype.

Another mumble might be about the `alias` attribute, but it works the
other way around, to declare functions that are aliasing others, so it's
useless to us.

Another possibility would be to use the GNU flavour of `extern inline`.
The `extern` keyword is pretty simple: it indicates that a variable or a
function has its definition in another file.

The `inline` keyword on the other hand, is subtler. It was introduced in
C99 section 6.7.4 of the C99 standard (ISO/IEC 9899:1999), as a suggestion
for the compiler to inline the function. But it was present in some
compilers, including GCC, before that. The GCC implementation in gnu90
was:

> If the function is declared extern, then this definition of the function
> is used only for inlining. In no case is the function compiled as a
> standalone function, not even if you take its address explicitly. Such
> an address becomes an external reference, as if you had only declared
> the function, and had not defined it. This has almost the effect of a
> macro.  The way to use this is to put a function definition in a header
> file with this attribute, and put another copy of the function, without
> extern, in a library file. The definition in the header file causes most
> calls to the function to be inlined. If any uses of the function remain,
> they refer to the single copy in the library. Note that the two
> definitions of the functions need not be precisely the same, although if
> they do not have the same effect your program may behave oddly.

Which is more or less the behaviour we desire, and fortunately for us it
can be brought back from the past via the `__gnu_inline__` attribute, or,
even better, by marking a function `extern inline`, as it's the very same
behaviour. Now, we saw that `inline` was introduced in C99, but since some
programmers are "clever", it's not that uncommon, in old C89-compatible
codebases to see the `#define inline` hack before the inclusion of
standard headers, for backward compatibility. This is of course an
undefined behaviour in C99 and above (C99/C11 7.1.2/4). To makes things
even spicier, the musl libc is doing `#define __inline inline` for
C++/C99-and-above, meaning that `__inline` will be preprocessed away. So
we're resorting to `__inline__` instead of `inline` and `__inline`, in the
hope that it'll not be defined away, and is supported by the compiler.

To ensure that our implementation is always inlined, we're using the
`__always_inline__` attribute. And to make debugging a bit less tedious,
`__artificial__` is used as well. Of course, the function attributes
`__always_inline__` and `__gnu_inline__` themselves require an inline
specifier on the function to be applied, resulting in this monstrosity:
`extern inline
__attribute__((__always_inline__,__gnu_inline__,__artificial__))`.

Now this is all becoming a bit complicated, so let's recap a bit. In C99
and above:

- `inline` is a hint to the compiler to (possibly) inline a function. No
  externally visible function is emitted. In gnu89, an out-of-line version
  is emitted and externally visible, making it possible to call it from
  other translation units;meaning that this function can only be defined
  in one compilation unit, as other ones need to see it as an out-of-line
  function.
- `extern inline` is the same behaviour as gnu89's `inline`. In gnu89, no
  out-of-line version will be generated, but one might be called.
- `static inline` is the inlining hint with internal linkage. Meaning no
  externally visible out-of-line code will be generated, albeit a file
  static one might be. The "one translation unit" rules doesn't apply,
  since there is no external symbol.

Since we want the behaviour of gnu89 `inline`, we're using `extern
inline`. On the bright side, in C++, there is none of this `static inline`
or `extern inline` shenanigans (although some compilers support them),
things tends to more or less just work, at least in this area. If this is
still unclear, both Wikipedia [9] and Richard Kettlewell [10] have great
articles on the topic.

To call the original function, we're taking advantage of another
nonstandard construct: Wrapper Headers [11], via the `#include_next`
directive. It works similarly to `#include` except that it starts
searching the list of header file directories _after_ the directory in
which the current file was found. To trick the resolution of the original
function, and to not have to care about mangling, we're using an assembly
label. A similar trick [12] is used by `gettext` to override
`gettext`/`textdomain`/... from the libc to the `gettext` ones.

With this in our toolbox, we can use some macros voodoo to implement
hooking:

#define _FORTIFY_INLINE extern __inline__ \
        __attribute__((__always_inline__,__gnu_inline__,__artificial__))
#define _FORTIFY_STR(s) #s
#define _FORTIFY_ORIG(p, fn) __typeof__(fn) __orig_##fn __asm__(_FORTIFY_STR(p) #fn)
#define _FORTIFY_FNB(fn) _FORTIFY_ORIG(__USER_LABEL_PREFIX__, fn)
#define _FORTIFY_FN(fn) _FORTIFY_FNB(fn); _FORTIFY_INLINE

Used like this:

_FORTIFY_FN(realpath) char *realpath(const char *restrict path,
                      char *restrict resolved_path) {
    /* Actual fortified implementation */
}


--[ 2 - Clang ]------------------------------------------------------------

As we've seen, implementing fortify-header for GCC is nontrivial. Piling
clang support on top of it adds another whole level of "fun", as it:

- Doesn't have the `__gnu_inline__` attribute.
- Can't use `__builtin_object_size` in inline functions. [13]
- Doesn't have the `__builtin_va_arg_pack` builtin.
- Has different ideas from GCC about what constitutes portable code.

On GCC, using the `__extension__` [14] keyword before an expression
silences warnings about using extension in it.  It's not a valid keyword
in clang, so it has to be `#ifndef(__clang__)`'ed out.

Clang lacks support for `__builtin_va_arg_pack`, to pass variadic
arguments across functions, meaning that fortifying `snprintf` and
`sprintf` in a nice way isn't possible. Using `va_start`/`va_end` would be
a possibility, as well as using cursed macros, but both would likely
result in a horrible mess. The code of fortify-headers is already complex
enough as it is, so no fortifying the two functions was deemed an
acceptable trade-off.

With those changes, clang is now successfully compiling programs using
fortify-headers, yay. But it's not catching as many memory corruptions as
GCC, what's going on? Well, the way `__builtin_(dynamic_)object_size`
works is by providing an upper or lower bound of the size of an object,
without any requirement on the precision of those values, so providing
`INT_MAX`/`INT_MIN` would be a conforming implementation. The most glaring
difference is the lack of proper sizing for structures members in inline
functions, which is due to an architectural difference between Clang and
GCC: the former has its backend (LLVM) completely unaware of the notion of
C structures members, and has its frontend (Clang) not doing any inlining
itself. So by the time the inlining is happening, the size information is
already gone. Architectural fixes to this issue are pretty likely pretty
involved, so they weren't considered.

Fortunately, clang has a `pass_(dynamic_)object_size` function attribute
[15] to make size information for the marked parameter available in a
function, by calling `__builtin_(dynamic_)object_size` at every call-site
of the function, and passing the result as implicit additional function
parameter, enabling clang to replace any calls to
`__builtin_(dynamic_)object_size` in the function with the parameter. This
way, size information gets properly propagated, no matter if the function
is inlined or not. The attribute has a bunch of limitations, but since
what we're doing is best effort, and because we don't really have a viable
alternative, it's good enough™.

Initial clang support was initially implemented by q66, from the Chimera
Linux project, in 2022. Some minor compatibility fixes later, clang is now
fully supported by fortify-headers!


--[ 3 - Annotations ]------------------------------------------------------

The `__builtin_object_size`/`__builtin_dynamic_object_size` builtins
aren't the only things that are used to help surface security invariants
for the compiler to take advantage of:

- `format`, to indicate that the annotated function takes a format string,
  enabling checks like validating that the number of variadic parameters
  is the same as the number of format specifiers.
- `access`, to annotate what function arguments are read-only, write-only,
  or read-write, as well as which argument act as an index if any. For
  example, the `int fgets (char* s, int size, FILE* stream)` function
  could be annotated with `__attribute__ ((access (write_only, 1, 2),
  access (read_write, 3)))`, to indicate that the parameter `s` is
  accessed only for writing, up to `size` parameter chars (as the type of
  `s` is `char*`), and that the `stream` is only read and never written
  to. This helps to catch overflows, as well a precise diagnostic of
  uninitialized variables.
- `diagnose_if`, to emit a warning/error at compile-time if the condition
  passed as parameter is true, for example a call to `memset(dest, c, 0)`
  is likely a mistake, with the correct one being `memset(dest, 0, n)`
  instead.

For completeness' sake, here are a few that aren't used in
fortify-headers, but could still be handful if you're looking at
annotating a codebase:

- `counted_by`, attached to a C99 flexible array member or a pointer field
  of a structure, telling what variable is holding the actual size of the
  array, to improve object size information.
- `malloc`, to tell the compiler that the annotated function is behaving
  like `malloc`: its return value is a unique pointer, and no valid
  pointers can be found in its addressed storage. The attribute also
  allows pairing a "destructor" to the annotated function, to catch
  mismatched allocation and deallocation functions, but also deallocations
  tentative on statically allocated values.


--[ 4 - Misc hurdles ]-----------------------------------------------------

--[ 4.1 - Writing tests

While fortify-header tries its very best to avoid gross constructs, it
definitely belongs to the category of "horrible hacks". Having tests
increases confidence when changing things, while proving that
fortify-header works across different compilers' versions and platforms.

The implementation is shamelessly based on the glibc's debug/tst-chk1
file:


volatile int chk_fail_ok;
volatile int ret;
jmp_buf chk_fail_buf;

static void
handler (int sig)
{
  if (chk_fail_ok)
    {
      chk_fail_ok = 0;
      longjmp (chk_fail_buf, 1);
    }
  else
    _exit (127);
}

void
__attribute__((constructor))
set_fortify_handler (void)
{
  struct sigaction sa;

  sa.sa_handler = handler;
  sa.sa_flags = 0;
  sigemptyset (&sa.sa_mask);

  sigaction (SIGILL, &sa, NULL);
  sigaction (SIGTRAP, &sa, NULL);
}

#define FAIL() \
  do { fprintf (stderr, "Failure in %s:%d\n", __FILE__, __LINE__); ret = 1; } while (0)
#define CHK_FAIL_START \
  chk_fail_ok = 1;                              \
  if (! setjmp (chk_fail_buf))                  \
    {
#define CHK_FAIL_END \
      chk_fail_ok = 0;                          \
      FAIL ();                                  \
    }

Astute readers will likely wince, as calling `longjmp` from a signal
handler is fraught with perils and can even be an undefined behaviour
in a ton of cases. Fortunately, this piece of code is lifted from the
glibc's own test suite, so that if it doesn't work, we have bigger
problems.

A test would look like this:

#include "common.h"                                       

#include <string.h>

int main(int argc, char** argv) {
  char buffer[12] = {0};
  memcpy(buffer, "1234567890", sizeof(buffer) - 1);
  puts(buffer);
  
  CHK_FAIL_START
  memcpy(buffer, "123456", argc);
  CHK_FAIL_END
  
  puts(buffer);
  return ret;  
}

The usage of `argc` as part of the test is to make it impossible for the
compiler to optimize things away, as it can't predict its value.
Nevertheless, every function has a dynamic (with `argc`) and static (with
a constant) variant of its tests, to check that even with optimizations,
we're still catching issues.

--[ 4.2 - `PATH_MAX`

The `char *realpath(const char *restrict path, char *restrict
resolved_path);` function returns the canonicalized absolute pathname of
its first argument. An important caveat is that "The resulting pathname is
stored as a null-terminated string, up to a maximum of `PATH_MAX` bytes,
in the buffer pointed to by `resolved_path`." Because we can't have nice
things, the `BUGS` section on `realpath`'s manpage states:

> The POSIX.1-2001 standard version of this function is broken by design,
> since it is impossible to determine a suitable size for the output
> buffer, `resolved_path`. According to POSIX.1-2001 a buffer of size
> `PATH_MAX` suffices, but `PATH_MAX` need not be a defined constant, and
> may have to be obtained using `pathconf(3)`. And asking `pathconf(3)`
> does not really help, since, on the one hand POSIX warns that the result
> of `pathconf(3)` may be huge and unsuitable for mallocing memory, and on
> the other hand `pathconf(3)` may return -1 to signify that `PATH_MAX` is
> not bounded. The `resolved_path == NULL feature`, not standardized in
> POSIX.1-2001, but standardized in POSIX.1-2008, allows this design
> problem to be avoided.

Since we _do_ need to check the length of `resolved_path` against
`PATH_MAX`, fortify-header simply defines `PATH_MAX` if it isn't already
to `4096`, which is its value on most operating systems.

--[ 4.3 - Conjuring types

As our wrappers are to be injected pretty much everywhere, including in
weird places, we have to be careful about being stateless. This means,
amongst other things, that we can't include files: we have to do with what
we have, including types.

Our load-bearing builtin, `__builtin_(dynamic_)object_size`, returns a
`size_t` value. In functions taking/returning a `size_t`, it's no issue,
but for those who don't we have to find a way to conjure it. Once again,
the solution to our problems takes the form of a compiler extension:
`__typeof__`. Combined with `sizeof`, it can be used to obtain `size_t`:
`__typeof__ (sizeof 0)`.


--[ 5 - Conclusion ]-------------------------------------------------------

With a small dose of terrible C hacks, it's possible to provide a
production-ready implementation of `FORTIFY_SOURCE` to libc others than
the glibc. Once the hooking implementation has been written, the hard part
is to walk the thin line between Hyrum's law and catching issues, without
introducing any breakage and maintaining portability.


--[ References ]-----------------------------------------------------------

[1] https://gcc.gnu.org/legacy-ml/gcc-patches/2004-09/msg02055.html

[2] https://github.com/llvm/llvm-project/releases/tag/llvmorg-9.0.0

[3] https://gcc.gnu.org/gcc-12/changes.html

[4] https://clang.llvm.org/docs/LanguageExtensions.html#evaluating-object-size

[5] https://2f30.org/

[6] https://git.2f30.org/fortify-headers

[7] https://clang.llvm.org/docs/AttributeReference.html#overloadable

[8] https://gcc.gnu.org/bugzilla/show_bug.cgi?id=71199

[9] https://en.wikipedia.org/wiki/Inline_(C_and_C%2B%2B)

[10] https://www.greenend.org.uk/rjk/tech/inline.html

[11] https://gcc.gnu.org/onlinedocs/cpp/Wrapper-Headers.html

[12] https://github.com/gajgeospatial/gettext-0.19.4/blob/ca5c20acbda839b31047d0c41faecbd6365091c4/libintl.h#L62-L109

[13] https://github.com/llvm/llvm-project/issues/53516

[14] https://gcc.gnu.org/onlinedocs/gcc/Alternate-Keywords.html

[15] https://clang.llvm.org/docs/AttributeReference.html#pass-object-size-pass-dynamic-object-size

|=[ EOF ]=---------------------------------------------------------------=|