Formation Rust : Programmer avec une sécurité mémoire maximale

Programme de la formation
Rust : Programmer avec une sécurité mémoire maximale

• Introduction à Rust et la sécurité mémoire

  - Identifier les principes fondamentaux de Rust.
  - Comparer la gestion mémoire de Rust avec celle du C/C++.
  - Expliquer l'importance de la sécurité mémoire en développement logiciel.

• Ownership : le cœur de la gestion mémoire Rust

  - Appliquer le concept d'ownership aux variables.
  - Gérer le transfert de possession (move semantics) entre fonctions.
  - Prévenir les erreurs de double libération de mémoire.

• Borrowing : accès aux données sans transfert de possession

  - Utiliser les références (emprunts) pour accéder aux données.
  - Distinguer les emprunts mutables et immutables.
  - Respecter les règles du borrowing pour éviter les data races.

• Lifetimes : garantir la validité des références

  - Définir les lifetimes pour les références.
  - Résoudre les erreurs de compilation liées aux lifetimes.
  - Appliquer les annotations de lifetime dans les signatures de fonctions.

• Structures de données et Ownership/Borrowing

  - Implémenter des structures de données avec ownership.
  - Utiliser le borrowing pour manipuler des champs de structures.
  - Gérer la possession de données complexes (vecteurs, chaînes).

• Gestion des erreurs et options

  - Utiliser `Option` pour gérer l'absence de valeur.
  - Utiliser `Result` pour gérer les erreurs récupérables.
  - Éviter les pointeurs nuls et les paniques.

• Concurrence et sécurité thread-safe

  - Comprendre les problématiques de la concurrence.
  - Appliquer les traits `Send` et `Sync` pour la sécurité thread-safe.
  - Utiliser les primitives de concurrence de Rust.

• Prévention des Data Races

  - Identifier les conditions de data races.
  - Utiliser `Mutex` et `RwLock` pour la synchronisation.
  - Écrire du code concurrent sans data races.

• Pointers bruts et code unsafe

  - Identifier les situations nécessitant du code `unsafe`.
  - Manipuler les pointeurs bruts (`*const`, `*mut`).
  - Minimiser l'utilisation du bloc `unsafe`.

• Intégration C/C++ et FFI sécurisé

  - Interfacer Rust avec des bibliothèques C/C++.
  - Gérer la mémoire partagée entre Rust et C/C++.
  - Réduire les vulnérabilités lors de l'intégration FFI.

• Audit et correction de vulnérabilités mémoire

  - Détecter les vulnérabilités potentielles dans du code Rust.
  - Corriger les erreurs de segmentation.
  - Appliquer les principes de sécurité mémoire pour refactoriser du code existant.

• Cas d'usage avancés et bonnes pratiques

  - Développer des composants pour systèmes embarqués critiques.
  - Concevoir des services backend haute performance.
  - Appliquer les bonnes pratiques pour une sécurité mémoire maximale.