Du Voodoo à RTX : à quoi servent
les GPUs

Evolution des GPU, du Monochrome Display Adapter de 1981 aux unites GPGPU modernes : positionnement par rapport au CPU, acteurs (NVIDIA, AMD, Khronos) et premieres considerations securite.

Maxime J23 septembre 20255 min de lecture

Un doute sur votre exposition ?

On audite votre surface d'attaque externe et on vous dit ce qui est exploitable.

Parler à un pentester

Prérequis

Comprendre le fonctionnement d'un CPU (Central Processing Unit)
- Unités de calcul (ALU, IFU, SFU, FPU, ...)
- Pipelining et exécution spéculative
- Caches

Hello ! o/

Cet article explore le fonctionnement interne des GPU (Graphics Processing Unit), de manière top-down. L'objectif est de découvrir et de synthétiser leur fonctionnement ainsi que leur programmation.

Les GPU sont aujourd'hui au coeur de l'exécution parallèle. Pour simplifier, il s'agit d'un grand nombre d'ALUs (Arithmetic Logic Unit) qui permettent de traiter un énorme flux de données. Cependant, ils ont une latence plus élevée que les CPU (Central Processing Unit) et des caches de plus petite taille pour maximiser le débit mémoire.

cpu-vs-gpu.txt

  CPU                          GPU
  ┌─────────────────────┐       ┌─────────────────────────────────────┐
  │  ┌───┐ ┌───┐        │       │  ┌─┐┌─┐┌─┐┌─┐┌─┐┌─┐┌─┐┌─┐┌─┐┌─┐  │
  │  │ALU│ │ALU│        │       │  └─┘└─┘└─┘└─┘└─┘└─┘└─┘└─┘└─┘└─┘  │
  │  └───┘ └───┘        │       │  ┌─┐┌─┐┌─┐┌─┐┌─┐┌─┐┌─┐┌─┐┌─┐┌─┐  │
  │  ┌───┐ ┌───┐        │       │  └─┘└─┘└─┘└─┘└─┘└─┘└─┘└─┘└─┘└─┘  │
  │  │ALU│ │ALU│        │       │  ┌─┐┌─┐┌─┐┌─┐┌─┐┌─┐┌─┐┌─┐┌─┐┌─┐  │
  │  └───┘ └───┘        │       │  └─┘└─┘└─┘└─┘└─┘└─┘└─┘└─┘└─┘└─┘  │
  │                     │       │  ┌─┐┌─┐┌─┐┌─┐┌─┐┌─┐┌─┐┌─┐┌─┐┌─┐  │
  │  Gros cache L3      │       │  └─┘└─┘└─┘└─┘└─┘└─┘└─┘└─┘└─┘└─┘  │
  │  Contrôle complexe  │       │  ... (des milliers d'ALUs)          │
  │  Branch predictor   │       │  Petits caches, contrôle simple     │
  └─────────────────────┘       └─────────────────────────────────────┘
  Quelques coeurs (4-64)         Des milliers de coeurs (1000-16000+)
  Latence faible                 Débit massif

CPU vs GPU : le CPU optimise la latence (quelques coeurs puissants), le GPU optimise le débit (des milliers de coeurs simples).

Source : Wikipédia

Cette architecture est idéale pour des traitements lourds comme :

Le rendu vidéo.
Le traitement de pools d'objets.
Les simulations physiques.
Les systèmes d'apprentissage par neurones.

Les Acteurs Principaux

Les grands noms qui définissent l'architecture et la programmation des GPU sont :

NVIDIA avec CUDA.
AMD avec ATI Stream.
Khronos Group (Apple) avec OpenCL.

Ces technologies permettent le calcul générique sur GPU, connu sous le nom de GPGPU (General-Purpose Computing on Graphics Processing Unit).

Sécurité et Vulnérabilités

Comme les CPU, les GPU ne sont pas infaillibles. Par exemple, l'isolation mémoire renforcée par un CPU ne s'applique pas automatiquement à la mémoire GPU. Cela peut entraîner des fuites d'informations critiques.

Isolation mémoire GPU

La mémoire GPU n'est pas nettoyée entre deux allocations successives par des processus différents. Un processus malveillant peut lire des données résiduelles laissées par un process précédent. On en parle plus en détail dans la suite de la série.

Historique des GPU

Les Débuts : MDA (1981)

Les premières cartes graphiques, appelées MDA (Monochrome Display Adapter), sont commercialisées en 1981. Elles servaient uniquement à la gestion des caractères pour l'affichage.

mda-1981.txt

  IBM PC (1981)
  ┌─────────────────────────────────────────┐
  │                                         │
  │  ┌──────────────────────────────────┐   │
  │  │  MDA : Monochrome Display Adapter│   │
  │  │                                  │   │
  │  │  - Résolution : 720 x 350        │   │
  │  │  - 80 colonnes x 25 lignes       │   │
  │  │  - Caractères uniquement         │   │
  │  │  - Pas de mode graphique         │   │
  │  │  - Port : DB-9 (TTL monochrome)  │   │
  │  └──────────────────────────────────┘   │
  │              │                          │
  │              ▼                          │
  │       Moniteur monochrome               │
  │       (vert ou ambre sur noir)          │
  └─────────────────────────────────────────┘

IBM MDA (1981) : affichage monochrome 80x25 caractères, pas de pixels, pas de graphiques.

Source : Wikipédia

3Dfx Voodoo 1 (1996)

En 1996, 3Dfx (rachetée par NVIDIA) propose la première carte graphique capable de calculer des opérations en 3D. La 3Dfx Voodoo 1 nécessitait une connexion à une carte graphique 2D via VGA pour afficher les résultats.

3dfx-voodoo1-1996.txt

  Architecture de la machine (1996)
  ┌───────────────────────────────────────────────┐
  │                                               │
  │  ┌──────────────┐      ┌────────────────────┐ │
  │  │ Carte 2D     │      │ 3Dfx Voodoo 1      │ │
  │  │ (VGA/SVGA)   │◄─────│                    │ │
  │  │              │      │  - Rendu 3D         │ │
  │  │  2D uniquement│     │  - Textures         │ │
  │  └──────┬───────┘      │  - Z-buffer         │ │
  │         │              │  - 4 Mo VRAM        │ │
  │         │   pass-through VGA                 │ │
  │         ▼              └────────────────────┘ │
  │    Moniteur                                   │
  └───────────────────────────────────────────────┘
  Le GPU 3D delegue l'affichage final a la carte 2D

3Dfx Voodoo 1 : accélération 3D uniquement, chaînée avec une carte 2D via pass-through VGA.

Source : Fabien Sanglard

Register Combiner (1999)

En 1999, NVIDIA introduit les Register Combiners, permettant de spécialiser des ALUs pour calculer la couleur finale du framebuffer. Cette innovation est intégrée dans la gamme GeForce.

  Pipeline Register Combiner (GeForce 256)
  ┌────────────────────────────────────────────────┐
  │                                                │
  │  Entrees (registres) :                         │
  │  ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐          │
  │  │  A   │ │  B   │ │  C   │ │  D   │          │
  │  └──┬───┘ └──┬───┘ └──┬───┘ └──┬───┘          │
  │     │        │        │        │               │
  │     ▼        ▼        ▼        ▼               │
  │  ┌─────────────────────────────────────────┐   │
  │  │  Combiner Stage N                       │   │
  │  │  out_rgb = A*B + (1-A)*C  (ou autre op) │   │
  │  └──────────────────┬──────────────────────┘   │
  │                     ▼                          │
  │              Couleur finale du pixel           │
  └────────────────────────────────────────────────┘
  Jusqu'a 8 stages enchainees, configurables par l'app

Source : NVIDIA, Programming Register Combiners with nvparse, John Spitzer

Shaders Programmables (2001)

Les shaders programmables apparaissent en 2001. Ce sont des programmes exécutés sur le GPU à différentes étapes du pipeline de rendu.

shader-pipeline-2001.txt

  Pipeline de rendu programmable (2001)
  ┌──────────────────────────────────────────────┐
  │                                              │
  │  Sommets 3D                                  │
  │      │                                       │
  │      ▼                                       │
  │  ┌──────────────────────────────────────┐    │
  │  │  Vertex Shader (programmable)        │    │
  │  │  - Transformations geometriques      │    │
  │  │  - Eclairage par sommet              │    │
  │  └──────────────────┬───────────────────┘    │
  │                     │ Rasterisation          │
  │                     ▼                        │
  │  ┌──────────────────────────────────────┐    │
  │  │  Pixel Shader (programmable)         │    │
  │  │  - Texturing                         │    │
  │  │  - Effets par pixel                  │    │
  │  └──────────────────┬───────────────────┘    │
  │                     ▼                        │
  │              Framebuffer / ecran             │
  └──────────────────────────────────────────────┘

Pipeline de rendu avec shaders programmables (DirectX 8 / OpenGL 1.4, 2001).

Source : Wikipédia

GPGPU et CUDA (2006-2007)

En 2006, avec les NVIDIA GeForce 8000 series, les GPU deviennent des unités de calcul généralistes (GPGPU). Ils sont utilisés pour :

Le calcul matriciel.
Les statistiques.
L'intelligence artificielle.
L'algèbre linéaire.
La cryptomonnaie.

En 2007, NVIDIA lance CUDA (Compute Unified Device Architecture), un modèle de programmation rapidement adopté. Peu après, OpenCL de Khronos Group voit le jour, offrant une portabilité entre CPU et GPU.

CUDA vs OpenCL

CUDA est propriétaire NVIDIA (meilleures performances sur matériel NVIDIA) tandis qu'OpenCL est portable sur CPU, GPU AMD, GPU Intel, FPGA, etc. Dans la pratique, l'écosystème IA/ML a massivement convergé vers CUDA.

Ray-Tracing (2018)

En 2018, NVIDIA introduit des coeurs dédiés au ray-tracing dans son architecture Turing, simplifiant le calcul des effets de lumière.

ray-tracing-2018.txt

  Ray-Tracing (Turing 2018)
  ┌─────────────────────────────────────────────────────┐
  │                                                     │
  │  Camera / oeil                                      │
  │      │                                              │
  │      │  Rayon primaire par pixel                    │
  │      ▼                                              │
  │  ┌───────┐   impact ?    ┌────────────────────┐     │
  │  │ Pixel │──────────────►│ RT Core (materiel) │     │
  │  └───────┘               │ BVH traversal      │     │
  │                          └────────┬───────────┘     │
  │                                   │ surface touchee │
  │                                   ▼                 │
  │                       Rayons secondaires            │
  │                       (ombres, reflets, AO, GI)     │
  │                                   │                 │
  │                                   ▼                 │
  │                           Couleur finale            │
  │                           (accumulation)            │
  └─────────────────────────────────────────────────────┘
  RT Cores : intersection rayon/triangle en materiel
  Tensor Cores : debruitage IA (DLSS)

Ray-tracing : chaque pixel lance des rayons dans la scene pour calculer l'eclairage physiquement correct.

Source : What you need to know about ray tracing and NVIDIA's Turing architecture, Koh Wanzi

Année	Etape clé	Innovation
1981	MDA	Affichage caractères uniquement, monochrome
1996	3Dfx Voodoo 1	1er accélérateur 3D (chainé avec carte 2D)
1999	Register Combiners	ALUs spécialisées, pipeline de couleur configurable (GeForce)
2001	Shaders programmables	Vertex + pixel shaders, pipeline de rendu scriptable
2006-07	GPGPU / CUDA	Calcul généraliste (IA, physique, crypto...), GeForce 8000
2018	Ray-Tracing	RT Cores materiel, eclairage physiquement base (Turing)

Conclusion

Les GPU ont évolué d'unités dédiées à l'affichage à des processeurs polyvalents capables de gérer des calculs complexes dans divers domaines.

Veille sécurité

Ce qui bouge vraiment sur la surface d'attaque externe, NIS2 et la sécurité applicative, écrit par le pentester qui signe ces articles. Un envoi par mois, désinscription en un clic.

Votre adresse ne sert qu'à cet envoi. Voir la politique de confidentialité.

Prérequis

Hello ! o/

Les Acteurs Principaux

Sécurité et Vulnérabilités

Historique des GPU

Les Débuts : MDA (1981)

3Dfx Voodoo 1 (1996)

Register Combiner (1999)

Shaders Programmables (2001)

GPGPU et CUDA (2006-2007)

Ray-Tracing (2018)

Conclusion

La suite, une fois par mois