Problema
Problema #1 a securității software sunt bug-urile de memorie. Peste 70% din vulnerability-urile critice (buffer overflow, use-after-free, type confusion) provin din limbaje fără siguranța memoriei (C, C++).
Soluțiile existente:
- Software: Rust, MISRA, tool-uri statice — nu ajută la codul deja scris (milioane de linii de C/C++)
- OS: ASLR, NX, stack canaries — pot fi ocolite
- Hardware: MMU, MPU — prea grosiere (protejează pagini, nu obiecte)
CHERI atacă problema la nivelul CPU: fiecare pointer devine o capabilitate — un token care specifică exact ce memorie poate accesa și cu ce permisiuni.
Ce e o capabilitate?
În arhitectura clasică (x86, ARM), un pointer e o adresă — un număr de 64 de biți. Poți accesa orice adresă, chiar dacă nu ar trebui.
// Clasic: pointerul e doar o adresă
void *p = malloc(10);
p[100] = 5; // ❌ Poți accesa orice — CPU nu verifică
În CHERI, un pointer e o capabilitate — o structură de 128 de biți care include:
┌────────────────────────────────────────────────────┐
│ Capabilitate CHERI (128 biți) │
├────────────┬────────────┬────────────┬──────────────┤
│ Adresă │ Limită │ Permisiuni│ Tags │
│ (64 biți) │ (64 biți) │ (16 biți) │ (1 bit) │
├────────────┼────────────┼────────────┼──────────────┤
│ 0x7f3e... │ 0..10 │ read/write │ ✅ valid │
└────────────┴────────────┴────────────┴──────────────┘
// CHERI: pointerul e o capabilitate
void *p = malloc(10);
p[100] = 5; // ✅ CPU detectează că 100 > limită → SIGSEGV
Tag-ul (1 bit) e cel mai important: el marchează dacă această capabilitate e autentică sau a fost fabricată. Tag-ul e gestionat exclusiv de CPU — software-ul nu poate scrie peste el. Asta înseamnă că un atacator care controlează complet memoria nu poate fabrica o capabilitate falsă.
Ce previne CHERI
| Clasă de atac | Prevenit de CHERI? | |---|---| | Buffer overflow | ✅ Da — capabilitatea are limită | | Use-after-free | ✅ Da — capabilitatea e revocată la free | | Format string | ✅ Da — pointerii nu pot fi falsificați | | ROP/JOP | Parțial — adresele de retur sunt capabilități | | Type confusion | ✅ Da — capabilitatea are tip asociat | | Integer overflow | ❌ Nu — e problemă de logică |
Arm Morello — primul chip CHERI real
Morello e un board de la Arm (similar cu Raspberry Pi) care implementează CHERI în hardware. 2024-2025 au fost primii ani cu Morello disponibil pentru cercetare.
Specificații Morello:
- CPU: Arm Neoverse N1 + CHERI
- RAM: 32 GB
- SO: CheriBSD (FreeBSD cu CHERI)
- Toolchain: LLVM/Clang cu CHERI
- Cost: $~3,000 (board de cercetare)
Cine investește
| Organizație | Investiție în CHERI | |---|---| | Arm | Dezvoltă Morello, a contribuit cu specificația | | Microsoft | "CHERI e cea mai promițătoare abordare pentru memory safety" | | Google | Explorează CHERI pentru Android | | DARPA | Finanțează cercetarea CHERI | | FreeBSD | CheriBSD e varianta CHERI a FreeBSD | | Linux | Kernel patch-uri experimentale pentru CHERI |
CHERI vs Rust
Nu sunt concurente — sunt complementare:
Bug-uri de memorie
│
┌──────────┴──────────┐
↓ ↓
Software Hardware
(Rust) (CHERI)
│ │
│ Previne bug-urile │ Previne bug-urile
│ la compilare │ la runtime
│ │
│ ✅ Cod nou │ ✅ Cod existent (C/C++)
│ ❌ Biblioteca C │ ❌ Adaugă overhead
└─────────────────────┘
Rust spune: "scrie cod sigur de la zero". CHERI spune: "fă și codul C existent sigur".
Idealul: Rust + CHERI — bug-urile eliminate în software, plus o plasă de siguranță hardware pentru ce scapă.
Costul CHERI
Overhead-ul de performanță CHERI e estimat la 2-15% în funcție de sarcină:
- CAP: ~5%
- Memorie: ~10% (pointeri de 128 biți vs 64)
- CPU: ~3% (verificări suplimentare)
Pentru aplicații critice (HSM, avionică), acest overhead e acceptabil.
Concluzie
CHERI e cea mai promițătoare soluție hardware pentru problema #1 a securității software. Dacă Rust elimină bug-urile de memorie pentru codul nou, CHERI le elimină și pentru codul existent — miliardele de linii de C/C++ care nu vor fi rescrise niciodată. În 2026-2030, CHERI ar putea deveni standard în procesoare, la fel cum NX (non-executable stack) a devenit standard în anii 2000.