RUrurban·Nov 17, 2025
Just don't mix that up with the real safec.h header from safeclib:
https://github.com/rurban/safeclib/tree/master/include
In Giving C a superpower: custom header file (safe_c.h)rurban
safeclib
C2017–2025
rurban / safeclib
safeclib
safec libc extension with all C11 Annex K functions
5Distinct people
24Mentions
0Explicit recommenders
406GitHub stars
What to know before exploring
What it is
safec libc extension with all C11 Annex K functions
GitHub
Where it is used
No documented product use has been verified yet.
What people are saying
No recommendation phrase was found in the indexed comments.
No classified warning is attached to this page. Read the discussions before treating silence as approval.
Also in these discussions
No other repository is repeatedly linked in the same discussions.
This week on Hacker News
Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 5:04:57 PM UTC.
No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.
Mentions over time
HN mentions by year24 dated mentions
Observed mentions: 2017-04-13 07:56:11 UTC to 2025-11-17 12:46:21 UTC.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 3 | 1 | 2 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 11 | 0 | 11 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2021 | 2021-01-01 00:00:00 UTC | 2022-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2022 | 2022-01-01 00:00:00 UTC | 2023-01-01 00:00:00 UTC | 2 | 1 | 1 |
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2024 | 2024-01-01 00:00:00 UTC | 2025-01-01 00:00:00 UTC | 0 | 0 | 0 |
| 2025 | 2025-01-01 00:00:00 UTC | 2026-01-01 00:00:00 UTC | 1 | 0 | 1 |
What Hacker News says
24 sourcesOf course assembler spezializations are an anti-pattern, because the optimizer should be fixed to do it much better. Better C code is often 2x faster than hand optimized assembler.
Eg my C memcpy with inlined and vectorized clang beats glibc or gcc memcpy in assembler easily. https://github.com/rurban/safeclib/blob/master/tests/perf_me...
In LLVM's Libc Gets Much Faster memcpy For RISC-VSafeclib – C11 Annex K implementation
12 points · Open discussionI've recently implemented the secure variant without any locale support. Took me a day.
Now just the secure scanf family is missing, and this needs locale support unfortunately.
https://github.com/rurban/safeclib/blob/master/src/str/vsnpr...
In Curious lack of sprintf scalingI do it because nobody else implemented a secure memset. What they call secure is just avoiding that the compiler ignores it. A secure memset also cleans the caches with a memory barrier, so that meltdown cannot read it.
explicit_bzero and it's numerous variants are not only insecure, but also slow. (byte wise!)
Only safelibc has a secure memset_s. https://github.com/rurban/safeclib/blob/master/tests/perf_me...
In A 100LOC C impl of memset, that is faster than glibc'sMost of the code I write has a spec of input and output being some form of text. Still, I tend to write that in languages that have safe string handling and drop into C only when the profiler indicates that's useful.
When handling strings in C, it's useful to use the string functions from glib or pull in one of the specifically safe string handling libraries and not use any C stdlib functions for strings at all.
There are a number of C strings libraries safer to use than the standard library, and many of them are simpler, more feature-rich, or both.
* https://github.com/intel/safestringlib (MIT licensed)
* https://github.com/rurban/safeclib (MITish)
* https://github.com/mpedrero/safeString (MIT licensed)
* https://github.com/antirez/sds (BSD 2-clause, and gives you dynamic strings)
* https://github.com/maxim2266/str (BSD 3-clause)
* https
Read the rest
://github.com/xyproto/egcc (GPL 2.0, includes GC on strings)
* https://github.com/composer927/stringstruct (GPL 3.0)
* https://github.com/c-factory/strings (MIT licensed)
* https://github.com/cavaliercoder/c-stringbuilder (MIT licensed, does dynamic)
If one does use the C standard library directly for handling strings, the advisories from CERT, NASA, Github, and others should be welcome advice (CERT's advice, BTW, includes recommending a safer strings library right off).
Checking if a code is secure by counting the usage of memcpy is pretty stupid, but very easy, so it is done by checklist experts to check for security.
memcpy_s is not supported by glibc and most other libc implementations for Linux, I do not expect this to change in the future. Here is a good analyses of this optional extension to the C standard from a glibc developer:
http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1969.htm
All standard Linux tools use the "unsafe" functions from the libc.
You should not use gets(), there are better alternatives in your libc. ;-)
You can link one of these libraries against your code on Linux to get the Safe C functions:
https://github.com/rurban/safeclib
https://sourceforge.net/p/safeclib/code/ci/master/tree/
Changing an existing code base from the normal glibc C functions like memcpy to memcpy_s is n
Read the rest
ot easy, you do it wrong in 10% or more if you are not the original author of this code or do not have very long experience with it. Even when you are an expert a lot of problems are getting introduced, this is from my own experience. This is not a search and replace task for a junior!
Having one team developing something and then an other team making it secure is not working from my point of view. You should teach all your developers what they have to look for and why. I think it is important to not only says, X, Y, Z, is banned, but also why exactly and how to solve the use case X, Y, Z were used for.
A lot of the security work is not to improve the security, but for compliance to some guidelines internally or externally. The compliance is checked with some tools, like checking if "grep memcpy(" finds a result. Then the engineer or his manager will use the cheapest solution to solve this like Huawei did here.
To improve the real security you need some experts looking with the original developer into the real code. These experts do need more experience than just good PPT and Excel skills, but they need some knowledge in such software, probably different people for an embedded controller than a node.js application.
For (2) I guess it depends. Annex K is obviously already a part of the standard so it depends on the implementation. There is a push to eliminate Annex K altogether from the C Standard. If this push fails, it may be the case that more libraries will add support for this optional feature of the language. In the meanwhile, there is the Open Watcom compiler implementation [1], the Safe C Library [2], and Slibc [3].
[1] Watcom C Library Reference Version 1.8. Open Watcom. 2008. ftp://ftp.openwatcom.org/manuals/current/clib.pdf
[2] Safe C Library — A full implementation of Annex K https://github.com/rurban/safeclib/
[3] slibc https://code.google.com/archive/p/slibc/
In Tell HN: C Experts Panel – Ask us anything about CNo, just to test the mingw compiled libraries. The old tea.org CI was doing it similar.
setups: https://github.com/LibreDWG/libredwg/blob/master/build-aux/s...
https://github.com/rurban/safeclib/blob/master/build-tools/s...
In Wine 4.0 releasedAFAIK my own memset_s is the only secure one:
https://github.com/rurban/safeclib/tree/master/src/mem
but nobody cares. It was not mentioned at this years CCC talk about memset. Everybody thinks a simple compiler barrier is enough, it is not.
The strncpy truncating problem is widely known: https://www.google.com/search?q=strncpy+truncating+problem
But conceptually the biggest problem is the inability to deal with strings properly at all. You mentioned the iswalpha problem and the need for external libs, but the standard cannot even search for unicode strings properly (no normalization wcsnorm, no wcsfc, no UTF-8 u8 API), ditto sorting needs an API for the unicode version being used. It's relative and changes every year. And every libc is hopelessly behind. The most basic coreutils still cannot search for foreign strings (grep, sort, wc, c
Read the rest
FWIW, I just hardened my memset_s implementation again, after reading https://fahrplan.events.ccc.de/congress/2018/Fahrplan/events...
> This presentation will start off with a simple problem (how do you clear memory that holds sensitive content). It explores numerous possible solutions, and presents real live facts and figures. bugs in common applications will be shown.
Compiler optimizations are getting too tricky, and I'm not sure when memset-like functions are just optimized away.
https://github.com/rurban/safeclib/commits/smoke
In Schedule – 35th Chaos Communication CongressNot an alternative, but an addon: https://github.com/rurban/safeclib
for the secure Annex K extensions (the _s variants)
The only safer alternatives are the Microsoft Windows msvcrt and ulibc w/ secure API, Android Bionic and Embarcadero C++ libc (embedded).
https://rurban.github.io/safeclib/doc/safec-3.3/d1/dae/md_do... lists the various quirks with them.
glibc and the bsd's libc's are all unsafe on string and memory operations. With __FORTIFY_SOURCE=2 and -O2 they'll catch some bugs on wrong constant sizes, but not all found with the secure extensions or asan/valgrind.
In Ask HN: Safe alternative to the C stdlib?> Not at all, because it doesn't fix out of bounds errors caused by copy-paste errors where the given buffer size doesn't match the actual size of the declared buffer or string.
That's wrong, check the implementation.
C++ only has advantages because there g++ is not as broken as gcc with constexpr, but clang since 5.0 is doing fine.
https://github.com/rurban/safeclib
In C2x: the next real revision of the C standardI'd really like to see a comparison with clang's inliner. In my cases [1] gcc constexpr support was always horrible and clang decent. So I'm not sure if using the builtin assembler would fix the gcc situation.
1: https://github.com/rurban/safeclib/blob/master/tests/perf_me...
In How newlines affect Linux kernel performanceIt is even C11:
https://github.com/rurban/safeclib/blob/master/src/str/strcp...
In Stop using strncpy already (2013)Showing the 15 most recent of 24 sources. Enable JavaScript to search and browse every indexed mention.