mbedTLS VS ck

It's work in progress: https://github.com/Mbed-TLS/mbedtls/blob/development/docs/ar...

Newer version have okay-ish support, I'd guess the next OpenWRT release will have it again.

It's related to this Mbed-TLS issue

i've used the entropy generator from MbedTLS which uses multiple sources of randomness, and seeding it additionally with the chip's mac address and the free heap size at time of creation. it would take a lot to recreate all that "noise" consistently, but i'm open to suggestions on how to make it more secure

However on the github page and assuming I found the right source - and this is a HUGE ASSUMPTION - there is a section on porting the library to other platforms.

Rebean is a single executable written in ANSI C that embeds Lua 5.4, MbedTLS and SQLite. The crazy thing about this is that it is a C binary that runs on six operating systems without any cross compiling thanks to leveraging Justine Tunney's cosmopolitan.

it looks like the commands are all built under https://github.com/Mbed-TLS/mbedtls/tree/development/programs and the arch mbedtls package does some extra work to rename them and copy them into /usr/local/bin: https://github.com/archlinux/svntogit-community/blob/packages/mbedtls/trunk/PKGBUILD#L55

If you want to see a real implemention of arbitrary sized integer math, mbedTLS is a great example:

https://github.com/ARMmbed/mbedtls/blob/development/library/...

All of the ECC code in that library relies on this code, which can be accelerated by dedicated hardware.

mbed TLS - Another crypto implementation. Apache-2.0

Definitely, FreeRTOS + LwIP + Mbed TLS is a fairly common combo these days, and Mbed TLS has hardware acceleration where possible.

Maybe I'm missing something, but x is not volatile and the compiler is free to assume that it is not modified concurrently outside the bounds of C's memory model. Compilers can and do hoist out loop invariants, and https://github.com/concurrencykit/ck/commit/b54ae5c4ace9b94442bbb46858449069f566d269 seems like an example of compilers doing what you say they don't. What am I missing?

Recommend checking out http://concurrencykit.org instead.

If you're interested in how other approaches work, or how one achieves concurrency on shared mutable state without mutual exclusion, would recommend checking out concurrency kit.

There are plenty of practical solutions to the safe memory reclamation problem in C. The language just doesn't force one on you.

From epoch-based reclamation (https://github.com/concurrencykit/ck/blob/master/include/ck_..., especially with the multiplexing extension to Fraser's classic scheme), to quiescence schemes (https://liburcu.org/), or hazard pointers (https://github.com/facebook/folly/blob/master/folly/synchron..., or https://pvk.ca/Blog/2020/07/07/flatter-wait-free-hazard-poin...)... or even simple using a type-stable (https://www.usenix.org/legacy/publications/library/proceedin...) memory allocator.

In my experience, it's easier to write code that is resilient to hiccups in C than in Java. Solving SMR with GC only offers something close to lock-freedom when you can guarantee global GC pauses are short enough... and common techniques to bound pauses, like explicitly managed freelists land you back in the same problem space as C.

ck - Concurrency primitives, safe memory reclamation mechanisms and non-blocking data structures. BSD-2-Clause

Indeed they do, https://github.com/concurrencykit/ck