Log Dejargonizer

Linux Audit Framework · Event ANOM_ABEND

auditd ANOM_ABEND: a process was killed by a signal

A program died on a signal rather than exiting normally — most often a segmentation fault. auditd records it without any rule being configured, which makes it the one crash record you can rely on being present on a stock Linux system.

Also written as type=ANOM_ABENDauditd ANOM_ABENDaudit sig=11 SIGSEGVabnormal end audit record

What it means for you

On a personal computer

A program crashed. On Linux desktops this is usually a browser tab, a media player, or a graphics driver having a bad day, and the system carries on regardless. It is worth noticing only if the same program crashes over and over.

For an analyst

This is your cheapest exploitation-attempt signal and almost nobody watches it. Memory-corruption attempts against a service overwhelmingly fail before they succeed, and each failure is a SIGSEGV or SIGABRT here. A sequence of ANOM_ABEND records for the same network-facing binary within minutes is worth more attention than most IDS alerts, because it is evidence of something actually reaching the process rather than of a signature matching.

What it looks like

Sanitised. Addresses come from the RFC 5737 documentation ranges.

Sample
type=ANOM_ABEND msg=audit(1757251642.915:8331836): auid=4294967295 uid=33 gid=33 ses=4294967295 subj=unconfined pid=24817 comm="nginx" exe="/usr/sbin/nginx" sig=11 res=1

The fields that decide it

Everything else in the log line is context.

sig
The signal that killed the process. The whole record hinges on this.
  • 11 (SIGSEGV)Segmentation fault — the process touched memory it should not have. The classic result of both a bug and a failed memory-corruption attempt.
  • 6 (SIGABRT)The process aborted itself. On modern builds this is usually a compiler or libc hardening check firing — stack smashing detected, heap corruption, a failed assertion — which means a protection worked.
  • 4 (SIGILL)Illegal instruction. Execution reached something that is not code, which is a strong indicator of corrupted control flow.
  • 7 / 10 (SIGBUS)Bus error, often a misaligned access or a truncated memory-mapped file.
  • 9 (SIGKILL)Killed outright. Usually the OOM killer or an administrator rather than a fault.
comm / exe
The short command name and the full path of the binary that died. exe is the one to trust — comm is truncated to 15 characters and is trivially set by the process itself.
auid
The login user ID that owns the session, preserved even when the process has changed user. A crash under auid 4294967295 (unset) came from something with no login session — a daemon or a kernel-started process.
pid / ses
Process and session identifiers, used to tie the crash back to the session that started it and to whatever the same session ran before and after.
res
Whether a core dump was produced. Only useful if core dumps are actually enabled, which they usually are not on servers.

Ordinary reasons this happens

Most of the time it is one of these.

  • An ordinary application bug. Desktop software, browsers, and anything using a proprietary graphics driver crash routinely.
  • A version mismatch after an upgrade — a program running against a library it was not built for.
  • Failing memory. A machine producing crashes across many unrelated binaries usually has bad RAM rather than bad software.
  • A process killed by the out-of-memory killer, which appears here as SIGKILL and is explained fully in the kernel log rather than in the audit record.
  • Hardened builds aborting deliberately: a stack protector or heap consistency check firing produces SIGABRT, which means the protection did its job.

When it is not ordinary

Memory-corruption exploitation attempts against a network service. Failed attempts vastly outnumber successful ones, and each failure lands here.

What gives it awaySeveral ANOM_ABEND records for the same daemon within a short window, especially with sig=11 or sig=4, and connection logs showing the same remote source across all of them.

ATT&CK T1190

Fuzzing or vulnerability probing of a local setuid binary.

What gives it awayRepeated crashes of a setuid program under a single non-root auid, at machine speed rather than human speed.

ATT&CK T1068

A hardening control repeatedly stopping the same attack.

What gives it awayA run of sig=6 SIGABRT records from the same binary. The abort is the protection succeeding, and the repetition is what tells you something kept trying.

ATT&CK T1190

What to do next

  1. Read the signal first. SIGSEGV and SIGILL mean memory was mishandled; SIGABRT usually means a hardening check caught it; SIGKILL usually means resource pressure and belongs in a different investigation.
  2. Decide whether the binary is reachable from a network. A crashing desktop application and a crashing internet-facing daemon are different events with the same record type.
  3. Count occurrences per exe over the last day. One is a bug; five in ten minutes is somebody driving it.
  4. For a network daemon, line the crash timestamps up against its own connection log and find the source that was connected each time.
  5. Check the OOM killer before assuming anything: `journalctl -k | grep -i 'out of memory'`. A SIGKILL here with an OOM message there is memory pressure, not attack.
  6. If crashes span many unrelated binaries, test the memory before investigating software at all.
  7. Preserve evidence if you can. Core dumps are normally disabled on servers, and `coredumpctl list` on systemd systems will tell you quickly whether anything survived.

Queries to run

grep All abnormal terminations today, with numeric identifiers resolved to names.
ausearch -m ANOM_ABEND -ts today -i
grep Groups by binary. A single name repeating is the pattern that matters.
ausearch -m ANOM_ABEND -ts recent -i | grep -oP 'exe=\S+' | sort | uniq -c | sort -rn
grep Narrows to segmentation faults in network-facing daemons, which is the slice with real detection value.
ausearch -m ANOM_ABEND -ts today --raw | grep 'sig=11' | grep -E 'exe="/usr/sbin/(sshd|nginx|httpd|postfix)'
grep On systemd systems, whether any of these crashes left a core dump behind to analyse.
coredumpctl list --since today

Common questions

What does type=ANOM_ABEND mean in the Linux audit log?

A process terminated abnormally — it was killed by a signal rather than exiting on its own. The audit framework writes this record without any audit rule being configured, which is unusual and useful: it means crash records exist on stock systems where nobody has set up auditing at all. The `sig=` field says which signal, and 11 (segmentation fault) is by far the most common.

Does an ANOM_ABEND record mean my server was attacked?

Not by itself — programs crash for ordinary reasons all the time. What raises it is the pattern: the same network-facing daemon crashing several times in a short window, with the same signal, is what a failed memory-corruption attempt looks like from the outside. Attacks of that kind fail far more often than they succeed, and the failures are visible here before the success is visible anywhere.

What is the difference between sig=11 and sig=6 in an audit crash record?

Signal 11 is SIGSEGV, a segmentation fault: the process accessed memory it had no right to. Signal 6 is SIGABRT, which normally means the program deliberately killed itself because an internal check failed — a stack protector detecting a smashed stack, glibc detecting heap corruption, or an assertion failing. A SIGABRT is often a hardening control working correctly, and repeated ones mean something kept triggering it.

How do I see which program crashed and get more detail?

`ausearch -m ANOM_ABEND -ts today -i` lists them with names resolved; the `exe=` field gives the real binary path, which is more trustworthy than `comm=` because comm is truncated at fifteen characters and can be set by the process. For deeper analysis you need a core dump, and on systemd systems `coredumpctl list` will show whether one was captured.

Read next

Vendor documentation

Last reviewed 7 September 2026