Add rule FFI-MEM-NOSTACKPTR

src/en/07_ffi.md

@@ -656,11 +656,18 @@ impl Drop for Foo {
 > panic handler.
 
 When the foreign language is the one exploiting Rust allocated resources, it is
-a lot more difficult to offer any guarantee.
+a lot more difficult to offer any guarantee. There are notably two things to
+watch for. First, in order to limit the risks of stack buffer overflow,
+the foreign langage should not have access to Rust stack pointers.
 
-In C for instance there is no easy way to check that the appropriate destructor
-is checked. A possible approach is to exploit callbacks to ensure that the
-reclamation is done.
+> ### Rule {{#check FFI-MEM-NOSTACKPTR | Do not provide pointers to stack to foreign langage }}
+>
+> In a secure Rust developement, there must be no pointer nor reference to
+> stack-allocated data passed from Rust to the foreign langage.
+
+Second, often the foreign language provide no easy way to check that the
+appropriate destructor is called. A possible approach is to exploit callbacks to
+ensure that the reclamation is done.
 
 The following Rust code is a **thread-unsafe** example of a C-compatible API
 that provide callback to ensure safe resource

src/fr/07_ffi.md

@@ -713,11 +713,20 @@ impl Drop for Foo {
 > par l'utilisation d'un *handler* de `panic`.
 
 Lorsque le langage externe exploite des ressources allouées depuis le côté Rust,
-il est encore plus difficile d'offrir quelque garantie qui soit.
+il est encore plus difficile d'offrir quelque garantie que ce soit. Il y a
+notamment deux choses à surveiller. D'une part pour limiter les risques de
+débordement sur la pile, le langage externe ne devrait pas avoir accès à des
+pointeurs sur la pile Rust.
 
-En C par exemple, il n'y a pas de moyen simple qui permette de vérifier que le
-destructeur correspondant est appelé. Il est possible d'utiliser des *callbacks*
-pour assurer que la libération est effectivement faite.
+> ### Règle {{#check FFI-MEM-NOSTACKPTR | Non-exportation de pointeurs sur la pile vers le langage externe }}
+>
+> Dans un développent sécurisé en Rust, il ne doit pas y avoir de pointeurs de
+> données allouées sur la pile transmis de Rust vers le langage externe.
+
+D'autre part, souvent le langage externe ne fournit pas de moyen simple qui
+permette de vérifier que le destructeur correspondant est appelé. Il est
+possible d'utiliser des *callbacks* pour assurer que la libération est
+effectivement faite.
 
 Le code Rust suivant est un exemple **unsafe du point de vue des threads** d'une
 API compatible avec le C qui fournit une *callback* pour assurer la libération