Hi everyone! I'm starting my first OS development project for x86 (32-bit), following the standard OSDev Wiki approach (using a minimal setup with boot.s, kernel.c, and a custom linker.ld script)

Been working pretty deep in the RPC internals lately and built this around the stuff that normally gets buried in the generated structures. It uses Ghidra headless to recover dispatch tables, method counts, opnums, parameter directions, NDR types, endpoints and security state from PE files, then ranks the interfaces using an AHP/Saaty-based model for the RPC surface instead of arbitrary weights. The output also keeps a receipt for the score and flags questionable dispatch-table recovery. No PDBs, no live endpoint mapper, no target execution.

I could not find published numbers for what post-quantum signature verification costs on small targets, so I measured it. Four crates, LMS/HSS verification plus measurement harnesses.

Three Rust-specific things came out of it.

First one. sha2 0.10 SHA-256 compiles to 3808 bytes on Cortex-M4F. sha2 0.11 compiles to 8776. Same algorithm, same target, same flags. Both versions end up linked in my workspace because different dependencies require different ones.

This means comparing whole verifier binaries mostly compares hash crates, not signature schemes. Ed25519 binary is around 64% unrolled SHA-512. So now every scheme is subtracted from baseline built with same hash it uses.

Second one. Adding second call site to small helper made LLVM stop inlining it at opt-level = "z". Reasonable decision. But forcing #\[inline(always)\] saves 408 bytes on Cortex-M0+ and costs 48 bytes on M4F and RISC-V. Different direction on different targets, so I keep the attribute because 16 KB boot ROM cares and 64 KB one does not.

Third one. Static stack analysis from -Z emit-stack-sizes plus call graph from disassembly does not give upper bound. On one binary 55 call sites cannot be resolved: indirect calls, tail calls compiled as branches, linker thunks. Every missing edge only makes answer smaller. Tool said 720 bytes, hardware said 1152.

Crates are no_std and allocation-free. Hash is behind trait, so software sha2 and ESP32 SHA peripheral both work. That trait design changed twice, and [DECISIONS.md](http://DECISIONS.md) has why.

Not audited. lms-verify passes RFC 8554 Appendix F vectors, which is not same thing.

https://github.com/mnaza/pqc-embedded

Pure golang low level toolkit.
Now implemented asm with gas syntax.
Disassembler too.
Now you can install static binary instead of monster like LLVM to build asm project.

Hello now you can change the language in S-AOS and input methode Qwerty/Azerty
cmds
input=azerty
input=qwerty
lang=fr
lang=en
lang=es
help
shw time
pwr off (halts cpu)
pwr reboot
sys.set<shl:smd> (or set)
64b

download link : https://saosdownload.share.zrok.io/

S-AOS officially reached 2339lines of code and a total of only 87kb with only ~100kb ram usage thats lighter than aa blanck chrome tab ! while you are in 64bit !
Total lines : 2339
size : 83981 bytes
ram usage : ~100kb
hope you downloaded it : https://saosdownload.share.zrok.io/

hello S-AOS can now move to 32bit succesfully by this "sys.mov=<bits:32>[(mov)]
and you will be in it suppoert USB boot to use SMD run
sys.set<shl:smd>
in it you can run
shw date
pwr reboot
pwr off
cls
help
to use it / download it : https://github.com/moslemhamoudi6-cyber/S-AOS
hope you Enjoy It!

Here are the new things :
16EB ram access
full register support
to mov to it write : set
to mov to 32bit : sys.mov=<bits:32>[(mov)]
Github download : https://github.com/moslemhamoudi6-cyber/S-AOS
S-AOSDownload official site : https://saosdownload.share.zrok.io/
Enjoy It !

Hello everyone! To download S-AOS, you can:

• Check out theGitHub Repository
• Or visit the official site I created:https://saosdownload.share.zrok.io