Slides Cours Securite

Vulnérabilités, protections
7 novembre 2022
| 7 novembre 2022 | PAGE 1/97
Première partie I
Vulnérabilité, Risques, Intrusion
| 7 novembre 2022 | PAGE 2/97

Plan de la section
1 Introduction
Règles du jeux
Vulnérabilités cryptographiques
Vulnérabilités logiques
Manipulation des chaînes de caractères
2 Attaque
3 OS Hardening
Introduction | 7 novembre 2022 | PAGE 3/97

Sommaire
1 Introduction
Règles du jeux
2 Attaque
Injections
Corruption mémoire
Programmation sécurisée
3 OS Hardening
La part de l’administrateur
Protections
Règles du jeux | 7 novembre 2022 | PAGE 4/97

Une seule règle : pas de règle
Oublier tout ce que vous savez !

Postulats de base
Règle numéro une | 7 novembre 2022 | PAGE 5/97


Postulats de base
Le développeur a forçément laissé des bugs ;
Il ne peut pas avoir tout prévu
Il ne pense qu’au déroulement normal


Postulats de base
Le développeur a forçément laissé des bugs ;
Il ne peut pas avoir tout prévu
Il ne pense qu’au déroulement normal
L’attaquant n’en a besoin que d’un seul !
Aucune affirmation n’est vraie, tout doit être démontré
Réflexion inverse
Tout est une question de temps.

Définitions
Un bug est un comportement ou un résultat incorrect.

Une vulnérabilité est un bug ayant un impact sur la sécurité du
système d’information.
Son risque peut être minime ou critique ;
Il peut-être exploitable ou non.
Un exploit est un programme utilisant une vulnérabilité pour
enfreindre une règle de sécurité.
Un risque est l’appréciation d’une vulnérabilité en fonction de sa
probabilité d’exploitation et de la gravité de l’impact.
Définitions | 7 novembre 2022 | PAGE 6/97

Quel est l’impact d’une vulnérabilité ?
Denial of Service : le programme plante ;

Exécution de code arbitraire ;
Fuite d’information (fichier, privilège, clefs, tc.) ;
Contournement d’authentification.
Impacts | 7 novembre 2022 | PAGE 7/97

Quel est l’impact d’une vulnérabilité ?
Denial of Service : le programme plante ;

Exécution de code arbitraire ;
Fuite d’information (fichier, privilège, clefs, tc.) ;
Contournement d’authentification.
La gravité dépend de l’environnement.
Impacts | 7 novembre 2022 | PAGE 7/97

Complexité algorithmique
Algorithmique
Les algorithmes sont optimisés pour avoir la complexité la plus faible
possible, parfois en se basant sur des hypothèses de fonctionnement
normal.
Données issues de l’attaquant

En contrôlant les données en entrée, l’attaquant peut déclencher le pire
cas possible.
⇒ DoS
Vulnérabilité par complexité | 7 novembre 2022 | PAGE 8/97

Table de hashage
Propriété
Une table de hashage est une structure de données permettant
l’insertion et la lecture efficace d’un item.
⇒ Utilisation d’une fonction de hashage

Table de hashage
Propriété
Une table de hashage est une structure de données permettant
l’insertion et la lecture efficace d’un item.
⇒ Utilisation d’une fonction de hashage
L’efficacité d’une table de hashage se montre donc dans une distribution
uniforme des items.
Par définition, il y aura toujours des collisions. Des attaques ont été
montées contre :
Bro : 78% de perte de paquet à 160 Kb/s
Squid : ajout de 1.7 ms de latence par accès
Perl : explosion exponentielle du temps de traitement

Expression rationnelle
La puissance des regexps est sous-estimée :

Capacité de backtracking (utilisation des données matchées pour
construire l’expression)
Implémentation des moteurs déterministes ou non.
Possibilité d’exécution de code
CVE-2009-3695 : Vulnérabilité par les données validées

1 − r ’ ) @ ( ? : [ A−Z0 −9]+(?: −∗[A−Z0 − 9 ] + ) ∗\ . ) + [A−Z ] { 2 , 6 } $ ’
2 + r ’ ) @ ( ? : [ A−Z0 − 9 ] ( ? : [ A−Z0 −9 −]{0 ,61}[A−Z0 − 9 ] ) ? \ . ) + [ A−Z ] { 2 , 6 } \ . ? $ ’
Pour chaque caractère après @, on regarde si l’expression (.*)+ matche.

Exploitation d’une attaque logique
1 import datetime as d
2
3 bad_re = r e . c o m p i l e ( r " (^[ −!# $%&’∗+/=?^_‘ { } | ~ 0 − 9A−Z]+(\.[ −!# $%&’∗+/=?^_‘ { }
4 r ’ | ^ " ( [ \0 0 1 −\ 0 1 0 \ 01 3 \ 0 1 4 \ 0 1 6 −\ 0 3 7 ! # −\ [ \ ] −\ 1 7 7 ] | \ \[ \ 0 0
5 r ’ )@ ( ? : [ A−Z0 −9]+(?: −∗[A−Z0 − 9 ] + )∗ \ . ) + [A−Z ] { 2 , 6 } $$ ’ , r e
6
7 def bench_regex ( regexp , data ) :
8 a=d . d a t e t i m e . now ( )
9 r e g e x p . match ( d a t a )
10 r e t u r n d . d a t e t i m e . now() − a
11
12 >>> b e n c h _ r e g e x ( bad_re , ’ aaaaaa@bbbbbbbbbbbbbbbbbbbb ’ )
13 datetime . t i m e d e l t a (0 , 0 , 203858)
14 >>> b e n c h _ r e g e x ( bad_re , ’ aaaaaa@bbbbbbbbbbbbbbbbbbbbb ’ )
16 >>> b e n c h _ r e g e x ( bad_re , ’ aaaaaa@bbbbbbbbbbbbbbbbbbbbbb ’ )
18 >>> b e n c h _ r e g e x ( bad_re , ’ aaaaaa@bbbbbbbbbbbbbbbbbbbbbbb ’ )
20 >>> b e n c h _ r e g e x ( bad_re , ’ aaaaaa@bbbbbbbbbbbbbbbbbbbbbbbb ’ )
22 >>> b e n c h _ r e g e x ( bad_re , ’ aaaaaa@bbbbbbbbbbbbbbbbbbbbbbbbb ’ )
24 >>> b e n c h _ r e g e x ( bad_re , ’ aaaaaa@bbbbbbbbbbbbbbbbbbbbbbbbbb ’ )

Sommaire
1 Introduction
Règles du jeux
2 Attaque
Injections
Corruption mémoire
3 OS Hardening
Protections
Vulnérabilités cryptographiques | 7 novembre 2022 | PAGE 12/97

Cryptographie
La crypto, c’est chaud.

Si vous développez vous même votre système de cryptographie,
c’est que vous êtes dans l’erreur.

Cryptographie

Chiffrement ;
Signature ;
Intégrité.

Cryptographie

Chiffrement ;
Signature ;
Intégrité.
L’utilisation de systèmes crypto existants, libssl, n’est pas triviale
non plus !

Cryptographie

Chiffrement ;
Signature ;
Intégrité.
L’utilisation de systèmes crypto existants, libssl, n’est pas triviale
non plus !
Mauvaise vérification de signature ;
Utilisation de mauvaise entropie ;
Downgrading d’algorithmes ;
Négligence des pré-requis (WEP).

Example
void gen_prime(Big_int* p, int size)
{
int i;
uint8_t rand_buf[4096];
srand(time(NULL));
for (i=0;i<size/8)
rand_buf[i] = rand() & 0xFF;
get_next_prime(p, rand_buf, size);

return;
}

Example
void gen_prime(Big_int* p, int size)
{
int i;
uint8_t rand_buf[4096];
srand(time(NULL));
for (i=0;i<size/8)
rand_buf[i] = rand() & 0xFF;
get_next_prime(p, rand_buf, size);

return;
}
Problème
On a besoin d’une clef RSA 2048 bits
Mais elle est générée en utilisant gen_prime()
Le générateur d’aléa a une graine de 32 bits.
La clef peut être devinée après 232 essais au lieu de 21024

Sommaire
1 Introduction
Règles du jeux
2 Attaque
Injections
Corruption mémoire
3 OS Hardening
Protections
Vulnérabilités logiques | 7 novembre 2022 | PAGE 15/97

Mauvaises hypothèses
Hypothèses du développeur fausses.
Taille de la ligne de commande limitée ;

Vérification du certificat mais pas de la date d’expiration ;
Confondre autorisation et authentification ;
Être trop confiant sur le cercle de confiance.

Race conditions
time-of-check-to-time-of-use, TOCTTOU
C’est faire l’hypothèse qu’une ressource ne sera pas modifiée entre sa
vérification et son utilisation.
(Mauvaises) Hypothèses :
Une séquence d’instruction n’est pas atomique
Une ligne de code source n’est pas atomique
Le flot de programme peut être ralenti ou interrompu par un
attaquant.

Système de fichier : TOCTTOU
Vulnérable
1 s t=o s . s t a t ( ’ /tmp/ t o t o ’ )
2 i f s t . s t _ u i d != o s . g e t u i d ( ) :
3 r a i s e Exception ( ’ Erreur ’ )
4 f d=open ( ’ /tmp/ t o t o ’ )
5 ...
Entre la ligne 1 et 4, le fichier a pu être remplacé.

⇒ Toujours travailler sur des objets « figés »

Système de fichier : TOCTTOU
Vulnérable
1 s t=o s . s t a t ( ’ /tmp/ t o t o ’ )
4 f d=open ( ’ /tmp/ t o t o ’ )
5 ...
Entre la ligne 1 et 4, le fichier a pu être remplacé.

⇒ Toujours travailler sur des objets « figés »
Version correcte
1 f d = open ( ’ /tmp/ t o t o ’ )
2 s t = os . f s t a t ( fd . f i l e n o ( ) )
4 fd . c l o s e ()

Le problème des scripts setuid
Pourquoi les scripts ne peuvent être setuid ?

Il est impossible pour le noyau de vérifier que le script initial sera bien
celui qui sera exécuté par l’interpréteur.
1 u s e r s p a c e >e x e c v e ( " . / myprogram . py " , NULL , NULL ) ;

2 . . . k e r n e l > f = open ( ’ myprogram . py ’ )
3 . . . kernel > i f f i s a s c r i p t :
4 . . . kernel > e x e c v e ( ’ / u s r / b i n / p y t h o n ’ , [ ’ myprogram . py ’ ] )

Fichiers temporaires
1 tmp = open ( ’ / tmp/ myprog .%d ’ % o s . g e t p i d ( ) )

2 ...
Le PID est devinable donc un lien symbolique peut-être créé.

Système de fichier : les liens symboliques
Un lien symbolique peut pointer :

Nulle part
Sur un fichier avec un uid/gid différent
Imaginons que le programme suivant tourne avec des privilèges élévés :

1 f i l e n a m e = ’ /home/ ’ + u s e r n a m e + ’ / . m y c o n f i g f i l e ’
2 f d = open ( f i l e n a m e )
3 ...

Système de fichier : les liens symboliques
Un lien symbolique peut pointer :

Nulle part
Sur un fichier avec un uid/gid différent
Imaginons que le programme suivant tourne avec des privilèges élévés :

1 f i l e n a m e = ’ /home/ ’ + u s e r n a m e + ’ / . m y c o n f i g f i l e ’
2 f d = open ( f i l e n a m e )
3 ...
Si l’utilisateur créé un lien symbolique $HOME/.myconfigfile pointant sur

/etc/shadow. Il peut désormais lire et écrire dedans.

Attaques logiques TOCTTOU : Signaux
Page de manuel d’OpenBSD

« Most functions not in the above lists are considered to be unsafe with
respect to signals. That is to say, the behaviour of such functions when
called from a signal handler is undefined. »
Sendmail
1 v o i d s i g h n d l r ( i n t dummy) {
2 s y s l o g (LOG_NOTICE , u s e r _ d e p e n d e n t _ d a t a ) ;
3 free ( global_ptr2 ) ;
4 free ( global_ptr1 ) ;
5 e x i t (0) ;
6 }

Sommaire
1 Introduction
Règles du jeux
2 Attaque
Injections
Corruption mémoire
3 OS Hardening
Protections
Manipulation des chaînes de caractères | 7 novembre 2022 | PAGE 23/97

Spécificité du C
Définition
En language C, une chaîne de caractères n’est qu’un ensemble de
caractères terminé par NULL.
⇒ Il n’y a pas de notion de taille !
Cette (non-)propriété a de grave conséquences sur la sûreté des

programmes. Et même sur les languages de haut-niveau. . .

Tronquage
1 char buf [ 5 1 2 ] ;
2 s n p r i n t f ( buf , s i z e o f buf , "/ v a r / app/%s . t x t " , u s e r n a m e ) ;
3 i n t f d = open ( buf , O_RDONLY) ;
On prend l’hypothèse que username est contrôlé par l’utilisateur.

Tronquage
1 char buf [ 5 1 2 ] ;
Est-ce que username peut contenir le caractère NULL ?

Tronquage
1 char buf [ 5 1 2 ] ;

Et si username vaut ../../etc/passwd\x00 ?

Tronquage
1 char buf [ 5 1 2 ] ;

Et si username vaut ../../etc/passwd\x00 ?
Et si username a une longueur de 512-len("/var/app/") octets ?

Suppression de méta-caractères
Code supposé retirer tous les ../ dans une chaîne de caractères :
1 i =0
2 w h i l e i +3 <= l e n ( b u f ) :
3 i f b u f [ i ] == ’ . ’ and b u f [ i +1] == ’ . ’ and b u f [ i +2] == ’ / ’ :
4 buf = buf [ : i ] + buf [ i +3:]
5 i += 1

1 i =0
2 w h i l e i +3 <= l e n ( b u f ) :
4 buf = buf [ : i ] + buf [ i +3:]
5 i += 1
Et si buf == ”....//” ?

1 i =0
2 w h i l e i +3 <= l e n ( b u f ) :
4 buf = buf [ : i ] + buf [ i +3:]
5 i += 1
Et si buf == ”....//” ?

Problème de gestion de la mémoire Back in the 80’s
Dépassement de tampon
Écriture en dehors de la zone allouée.
Dans la pile (stack) ;

Dans le tas (heap) ;
N’importe où !
Corruption mémoire | 7 novembre 2022 | PAGE 27/97

Plan de la section
1 Introduction
2 Attaque
Injections
Corruption mémoire
3 OS Hardening
Attaque | 7 novembre 2022 | PAGE 28/97

Sommaire
1 Introduction
Règles du jeux
2 Attaque
Injections
Corruption mémoire
3 OS Hardening
Protections
Injections | 7 novembre 2022 | PAGE 29/97

Injection de code Attaque par inclusion
1 <?php
2 $color = ’ blue ’ ;
3 i f ( _ _ i s s e t ( $_GET [ ’COLOR ’ ] ) )
4 $ c o l o r = $_GET [ ’COLOR ’ ] ;
5 r e q u i r e ( $ c o l o r . ’ . php ’ ) ;
6 ?>
Exécution de code | 7 novembre 2022 | PAGE 30/97

Exécution de code Évaluation dynamique
1 $myvar = ’ s o m e v a l u e ’ ; 1 f o r e a c h ($_GET a s $ k e y => $ v a l u e ) {

2 $x = $_GET [ ’ a r g ’ ] ; 2 $$key = $ v a l u e ;
3 e v a l ( ’ $myvar ␣=␣ ’ . $x . ’ ; ’ ); 3 }
Exécution de code | 7 novembre 2022 | PAGE 31/97

Injection de code SQL
1 <?php
2 $ u s e r=$_GET [ ’ u s e r n a m e ’ ] ;
3 $ p a s s=$_GET [ ’ p a s s w o r d ’ ] ;
4
5 $ r e q = " s e l e c t ␣ p a s s w o r d ␣ from ␣ u s e r "
6 . " w h e r e ␣ u s e r =\" " . $ u s e r . " \" " ;
7 mysql_query ( $req , $ctx ) ;
8 ?>
SQL | 7 novembre 2022 | PAGE 32/97

Injection de code SQL
1 <?php
2 $ u s e r=$_GET [ ’ u s e r n a m e ’ ] ;
3 $ p a s s=$_GET [ ’ p a s s w o r d ’ ] ;
4
5 $ r e q = " s e l e c t ␣ p a s s w o r d ␣ from ␣ u s e r "
6 . " w h e r e ␣ u s e r =\" " . $ u s e r . " \" " ;
7 mysql_query ( $req , $ctx ) ;
8 ?>
$user == "toto\" or 1=1 --"

$user == "toto\"; drop database user; --"
SQL | 7 novembre 2022 | PAGE 32/97

Injection de code Problème d’échappement
man 3 system
system() executes a command specified in command by calling
/bin/sh -c command
Extrait d’un firmware Linksys

1 system (" ping $addr ") ;
Shell | 7 novembre 2022 | PAGE 33/97

Injection de code Problème d’échappement
man 3 system
system() executes a command specified in command by calling
/bin/sh -c command
Extrait d’un firmware Linksys

1 system (" ping $addr ") ;
⇒ addr == "1.2.3.4; rm -fr /"

Problème d’échappement Évasion
Deux méthodes de protection

Liste blanche de tous les caractères autorisés
Liste noire
Caractères dangereux
: > ‘ * ( " " ^ "\\" "\r"
; & ! / ) [ ~ ’ "\n"
< | - ? . ] \ " $

Problème d’échappement Évasion
Deux méthodes de protection

Liste blanche de tous les caractères autorisés
Liste noire
Caractères dangereux
: > ‘ * ( " " ^ "\\" "\r"
; & ! / ) [ ~ ’ "\n"
< | - ? . ] \ " $
Vraie solution
Utilisation directe de execve()

Sommaire
1 Introduction
Règles du jeux
2 Attaque
Injections
Corruption mémoire
3 OS Hardening
Protections

Assembleur 101
Registres sur x86 :
Généraux : eax, ebx, ecx, edx
Segment : cs, ds, es, ss
Pointeurs : eip, ebp, esp, esi, edi
Registres spéciaux (flottants, debug, MMX. . .)

Assembleur 101
Registres sur x86 :
Registres intéressants :
eip pointe sur l’instruction courante ;
ebp pointe sur le haut de la pile ;
esp pointe sur le bas de la pile ;

Assembleur 101
Registres sur x86 :
Registres intéressants :
eip pointe sur l’instruction courante ;
ebp pointe sur le haut de la pile ;
esp pointe sur le bas de la pile ;
Instructions spéciales :
push : empile la valeur et décrémente esp ;
pop dépile la valeur et incrémente esp ;
sub y, esp : alloue de la mémoire sur la pile ;
add y, esp : libère de la mémoire.

Cours d’architecture Appel de fonction
Appel de fonction
1 c a l l myfunc
2 prologue
3 c o d e de l a f u n c t i o n
4 epilogue
5 ret
6 ...
Prologue
1 pu sh ebp ; ; C r e e r une n o u v e l l e s t a c k f r a m e
2 mov ebp , e s p ; ; I n s t a l l e r l a n o u v e l l e s t a c k frame
Épilogue
1 mov esp , ebp
2 pop ebp ; ; Restaure l a s t a c k frame

Dépassement de buffer Généralités
Buffer overflow
Un overflow est un débordement de tableau. Par exemple, une chaîne de
caractère qui est copiée au delà de sa zone allouée.
Cela arrive quand :
On utilise des fonctions non-sûre telles que strcpy, sprintf car
elles n’ont pas la notion de taille maximale.
Problème arithmétique : on calcule mal la longueur d’une chaîne de
caractères.
Problème d’algorithme qui boucle.

Dépassement de buffer Différentes catégories
En fonction de la nature du buffer, on distingue plusieurs types de

débordement :
Stack overflow : variables locales
Heap overflow : variables dynamique (malloc())
Le reste.

Représentation du code
Code
1 int c a l l e e ( int , int , int ); 1 caller :

2 2 sub esp , 4h
3 int c a l l e r ( void ) 3 pu sh 3
4 { 4 pu sh 2
5 int ret ; 5 pu sh 1
6 6 call callee
7 ret = c a l l e e (1 , 2 , 3); 7 add esp , 0Ch
8 r e t += 5 ; 8 mov [ esp ] , eax
9 return ret ; 9 mov eax , [ e s p ]
10 } 10 add eax , 5
11 mov [ esp ] , eax
12 mov eax , [ e s p ]
13 add esp , 4h
14 ret

1000 sub esp, 4h

1003 push 3
1006 push 2
1009 push 1
100C call 0x4010
8234 call 0x1000 1010 add esp, 0Ch
8238 ...
1014 mov [esp], eax
1017 mov eax, [esp]
101A add eax, 5
4010 mov eax, 0x23 1021 mov [esp], eax

oldstk
4089 ret 1023 mov eax, [esp]
1026 add esp, 4h
1028 ret

1000 sub esp, 4h

1003 push 3
1006 push 2
1009 push 1
100C call 0x4010
8234 call 0x1000 1010 add esp, 0Ch
8238 ...
1014 mov [esp], eax
1017 mov eax, [esp]
101A add eax, 5
0x8238
oldstk
1026 add esp, 4h
1028 ret

1000 sub esp, 4h

1003 push 3
1006 push 2
1009 push 1
100C call 0x4010
8234 call 0x1000 1010 add esp, 0Ch
8238 ...
1014 mov [esp], eax
1017 mov eax, [esp]
101A add eax, 5
0x8238
oldstk
1026 add esp, 4h
1028 ret

1000 sub esp, 4h

1003 push 3
1006 push 2
1009 push 1
100C call 0x4010
8234 call 0x1000 1010 add esp, 0Ch
8238 ... 3
1014 mov [esp], eax
1017 mov eax, [esp] ?
101A add eax, 5
0x8238
oldstk
1026 add esp, 4h
1028 ret

1000 sub esp, 4h

1003 push 3
1006 push 2
1009 push 1
100C call 0x4010
8234 call 0x1000 2
1010 add esp, 0Ch
8238 ... 3
1014 mov [esp], eax
101A add eax, 5
0x8238
oldstk
1026 add esp, 4h
1028 ret

1000 sub esp, 4h

1003 push 3
1006 push 2
1009 push 1 1
100C call 0x4010
8234 call 0x1000 2
1010 add esp, 0Ch
8238 ... 3
1014 mov [esp], eax
101A add eax, 5
0x8238
oldstk
1026 add esp, 4h
1028 ret

1000 sub esp, 4h

1003 push 3
1006 push 2 0x1010
1009 push 1 1
100C call 0x4010
8234 call 0x1000 2
1010 add esp, 0Ch
8238 ... 3
1014 mov [esp], eax
101A add eax, 5
0x8238
oldstk
1026 add esp, 4h
1028 ret

1000 sub esp, 4h

1003 push 3
1006 push 2 0x1010
1009 push 1 1
100C call 0x4010
8234 call 0x1000 2
1010 add esp, 0Ch
8238 ... 3
1014 mov [esp], eax
101A add eax, 5
0x8238
oldstk
1026 add esp, 4h
1028 ret

1000 sub esp, 4h

1003 push 3
1006 push 2 0x1010
1009 push 1 1
100C call 0x4010
8234 call 0x1000 2
1010 add esp, 0Ch
8238 ... 3
1014 mov [esp], eax
101A add eax, 5
0x8238
oldstk
1026 add esp, 4h
1028 ret

1000 sub esp, 4h

1003 push 3
1006 push 2 0x1010
1009 push 1 1
100C call 0x4010
8234 call 0x1000 2
1010 add esp, 0Ch
8238 ... 3
1014 mov [esp], eax
101A add eax, 5
0x8238
oldstk
1026 add esp, 4h
1028 ret

1000 sub esp, 4h

1003 push 3
1006 push 2 0x1010
1009 push 1 1
100C call 0x4010
8234 call 0x1000 2
1010 add esp, 0Ch
8238 ... 3
1014 mov [esp], eax
1017 mov eax, [esp] 0x23
101A add eax, 5
0x8238
oldstk
1026 add esp, 4h
1028 ret

1000 sub esp, 4h

1003 push 3
1006 push 2 0x1010
1009 push 1 1
100C call 0x4010
8234 call 0x1000 2
1010 add esp, 0Ch
8238 ... 3
1014 mov [esp], eax
101A add eax, 5
0x8238
oldstk
1026 add esp, 4h
1028 ret

1000 sub esp, 4h

1003 push 3
1006 push 2 0x1010
1009 push 1 1
100C call 0x4010
8234 call 0x1000 2
1010 add esp, 0Ch
8238 ... 3
1014 mov [esp], eax
101A add eax, 5
0x8238
oldstk
1026 add esp, 4h
1028 ret

1000 sub esp, 4h

1003 push 3
1006 push 2 0x1010
1009 push 1 1
100C call 0x4010
8234 call 0x1000 2
1010 add esp, 0Ch
8238 ... 3
1014 mov [esp], eax
101A add eax, 5
0x8238
oldstk
1026 add esp, 4h
1028 ret

1000 sub esp, 4h

1003 push 3
1006 push 2 0x1010
1009 push 1 1
100C call 0x4010
8234 call 0x1000 2
1010 add esp, 0Ch
8238 ... 3
1014 mov [esp], eax
101A add eax, 5
0x8238
oldstk
1026 add esp, 4h
1028 ret

1000 sub esp, 4h

1003 push 3
1006 push 2 0x1010
1009 push 1 1
100C call 0x4010
8234 call 0x1000 2
1010 add esp, 0Ch
8238 ... 3
1014 mov [esp], eax
101A add eax, 5
0x8238
oldstk
1026 add esp, 4h
1028 ret

1000 sub esp, 4h

1003 push 3
1006 push 2 0x1010
1009 push 1 1
100C call 0x4010
8234 call 0x1000 2
1010 add esp, 0Ch
8238 ... 3
1014 mov [esp], eax
101A add eax, 5
0x8238
oldstk
1026 add esp, 4h
1028 ret

Dépassement de buffer Code vulnérable
1 char buf [ 1 2 8 ] ;
2
3 s t r c p y ( buf , a r g v [ 1 ] ) ;
Ou à la main :
1 char buf [ 1 2 8 ] ;
2 i n t len = a t o i ( argv [ 1 ] ) ;
3
4 for ( int i = 0 ; i < len ; i ++)
5 b u f [ i ] = ’A ’ ;

Stack overflow
0x00000000 local1
local2
ebp
ret addr
arg1
0xffffffff arg2
Stack overflow | 7 novembre 2022 | PAGE 43/97

Stack overflow
0x00000000 local1
local2
ebp
ret addr
arg1
0xffffffff arg2

Stack overflow
0x00000000 local1
local2
ebp
ret addr
arg1
0xffffffff arg2

Stack overflow
0x00000000 local1
local2
ebp
ret addr
arg1
0xffffffff arg2

Exploitation
Le but du jeu est de remplacer l’adresse de retour (saved eip) pour

pointer sur une zone contrôlée par l’attaquant.
Old school style

Shellcode Stack non exécutable
Ret into libc

Stack frame qui va appeler une suite de fonction . . .
. . .Ou une suite de bout de code de fin de fonction

Heap overflow : Gestion de la mémoire
1 char ∗ buf = malloc ( 1 2 ) ;

2 i f ( b u f == NULL)
3 return 1;
4 f r e e ( buf ) ;
Il y a un système complexe de gestion de la mémoire derrière ces deux

fonctions :
Wrapper autour de brk() et mmap() ;
Pools de chunks prêt à l’usage ;
Optimisation pour certaines tailles (pour éviter la fragmentation) ;
Compromis rapidité/overhead.
Heap overflow | 7 novembre 2022 | PAGE 46/97

Heap overflow Anatomie des structures internes
Pour sa gestion, dlmalloc() utilise :

Des variables globales ;
Chaque chunk est constitué d’une structure de contrôle de la
mémoire allouée.

Heap overflow Anatomie des structures internes
Pour sa gestion, dlmalloc() utilise :

Des variables globales ;
Chaque chunk est constitué d’une structure de contrôle de la
mémoire allouée.
Pour simplifier, on peut la considérer comme une liste doublement
chaînée.

Heap overflow : exploitation par unlink
unlink()
1 #d e f i n e u n l i n k ( P , BK, FD ) { \
2 BK = P−>bk ; \
3 FD = P−>f d ; \
4 FD−>bk = BK ; \
5 BK−>f d = FD ; \
6 }
Ligne 4 : Écrire à *(FD+12) le contenu de BK ;

Ligne 5 : BK est écrasé au milieu du shellcode ;
⇒ Écriture de quatre octets n’importe où !

Heap overflow : exploitation par frontlink
1 #d e f i n e f r o n t l i n k ( A , P , S , IDX , BK, FD ) { \
2 i f ( S < MAX_SMALLBIN_SIZE ) { \
3 ... \
4 } else { \
5 IDX = b i n _ i n d e x ( S ) ; \
6 BK = b i n _ a t ( A , IDX ) ; \
7 FD = BK−>f d ; \
8 i f ( FD == BK ) { \
9 m a r k _ b i n b l o c k (A , IDX ) ; \
10 } else { \
11 w h i l e ( FD != BK && S < c h u n k s i z e (FD) ) { \
12 FD = FD−>f d ; \
13 } \
14 BK = FD−>bk ; \
15 } \
16 P−>bk = BK ; \
17 P−>f d = FD ; \
18 FD−>bk = BK−>f d = P ; \
19 } \
20 }

Double free()
Un double-free() est un programme qui libère deux fois le même

pointeur.
Comportement différent en fonction du status du chunk ;
Situation de désynchronisation ;
Structure différente entre un chunk libre et un en cours d’utilisation
Contraignant à exploiter.
Double free | 7 novembre 2022 | PAGE 50/97

Off-by-one
Erreur fréquence
Utilisation de mauvaises bornes pour le parcours de tableau ;
Écriture d’un ’\0’ trop loin ;
Utilisation de strncat.
Pas de contrôle sur la valeur écrasée ;

Nécessite que le pointeur de pile sauvegardé ait une valeur “haute” ;
Peut être inexploitable à cause d’optimisation du compilateur ;
Off-by-one | 7 novembre 2022 | PAGE 51/97

Off-by-one Exploitation
Écrasement du pointeur de pile

1 mov esp , ebp
2 pop ebp
3 pop e i p
Exemple :
Avant : saved_ebp == 0x804d5f4
Après : saved_ebp == 0x804d500
Si 0x804d500 pointe dans notre buffer, c’est gagné !
Off-by-one | 7 novembre 2022 | PAGE 52/97

Problème d’arithmétique Integer overflow
Rien d’infini
En C, il n’existe pas de type permettant d’avoir des nombres de tailles
« maléables ».
⇒ Débordement de capacité
0xFFFFFFFF + 1 = 0 (1)
0x 40000020 ∗ 4 = 0x 80 (2)
0 − 1 = 0xFFFFFFFF (3)
Problème d’arithmétique | 7 novembre 2022 | PAGE 53/97

1 unsigned i n t n ;
2 s t r u c t r e q _ h d r ∗ hdr , ∗∗ r e q s ;
3
4 n = get_number_of_requests ( buf ) ;
5 r e q s = m a l l o c ( n∗ s i z e o f ( ∗ h d r ) ) ; /∗ i n t e g e r o v e r f l o w ∗/
6
7 f o r ( i n t i = 0 ; i < n ; i ++) { /∗ on e c r i t d a n s l e t a b l e a u ∗/
8 reqs [ i ] = foo_bar ( . . . ) ; /∗ de t a i l l e i n s u f f i s a n t e ∗/
9 }

1 i n t l e n g t h = get_from_network ( buf ) ;
2
3 b u f = m a l l o c ( BUFSIZE ) ;
4
5 i f ( l e n g t h < 0 | | l e n g t h +1 > BUFSIZE )
6 r e t u r n −ERR ;
7 else
8 r e a d ( f d , buf , l e n g t h ) ;

2
4
7 else
Et maintenant si length = 0x7FFFFFFF ?

2
4
7 else
Et maintenant si length = 0x7FFFFFFF ?

length+1 ⇒ 0x80000000 < 0

Problème d’arithmétique Conversion, promotion
Promotion des entiers

Si un type entier est plus petit qu’un int, alors la promotion le converti
toujours en entier.
La promotion a lieu partout :
Opérations (binaire, arithmétique, etc.) ;
switch-case, if ;
Appel de fonction.

Problème d’arithmétique Conversion signed/unsigned
Si deux opérandes sont de signes différents, et que le rang de conversion

de l’unsigned est supérieur ou égal à celui du signed, alors le signed
est converti en unsigned.
1 i n t f o o = −1;
2
3 i f ( foo < s i z e o f ( i n t )) {
4 /∗ t o u j o u r s v r a i ? ∗/
5 }

Problème d’arithmétique Conversion signed/unsigned
Si deux opérandes sont de signes différents, et que le rang de conversion

de l’unsigned est supérieur ou égal à celui du signed, alors le signed
est converti en unsigned.
1 i n t f o o = −1; 1 i n t f o o = −1;
2 2
3 i f ( foo < s i z e o f ( i n t )) { 3 i f (0 x f f f f f f f f < s i z e o f ( i n t ) ) {
4 /∗ t o u j o u r s v r a i ? ∗/ 4 /∗ t o u j o u r s f a u x ∗/
5 } 5 }

Problème d’arithmétique Problème de signe
Le pire outil du C est le cast, dans un code propre, on ne devrait pas en

trouver.
Valeur Hexadécimale En signé En non signé
0 0x00000000 0 0
12 0x0000000c 12 12
-1 0xFFFFFFFF -1 4294967295

Format string
man 3 printf
1 int p r i n t f ( co n s t char ∗ format , ...);
format est la chaîne de caractères à afficher, avec des séquences

spéciales (%c, %d, %s mais aussi %n) ;
Nombre variable d’arguments.
Format string | 7 novembre 2022 | PAGE 59/97

Format string Exemple vulnérable : wuftpd
1 char buffer [512];

2 snprintf ( buffer , si zeo f ( buffer ) , user );
3 b u f f e r [ s i z e o f ( b u f f e r ) − 1 ] = ’ \0 ’ ;
user est contrôlé par l’attaquant ;

On peut écrire et lire n’importe où.
Format string | 7 novembre 2022 | PAGE 60/97

Sommaire
1 Introduction
Règles du jeux
2 Attaque
Injections
Corruption mémoire
3 OS Hardening
Protections
Programmation sécurisée | 7 novembre 2022 | PAGE 61/97

Design sécurisé
Roadmap
Identifier :
1 Les ressources ;
2 Les acteurs ;
3 Les relations entre les ressources et les acteurs.
Comme dans les réseaux, le cloisonnement est obligatoire.
Design | 7 novembre 2022 | PAGE 62/97

Compromis performance/sécurité Keep It Simple !
Compromis
Un algorithme simple peut être préférable à une table de hashage même
si les performances ne sont pas les meilleures.
⇒ Savoir relativiser les besoins est important.

Compromis performance/sécurité Keep It Simple !
Compromis
Un algorithme simple peut être préférable à une table de hashage même
si les performances ne sont pas les meilleures.
⇒ Savoir relativiser les besoins est important.
Design de qmail
Combattez les idées reçues aussi ! Par exemple, qmail lance un
programme uniquement pour le parsing d’une adresse mail. Et il fait
partie des logiciels passant le mieux à l’échelle.

Modularité
Chaque module est indépendant des autres et ne fait confiance à

personne d’autre, chaque flux entrant et sortant doit être considéré
comme non sûr.
En considérant que le module :
Tourne avec le moins de privilège(s) possible ;
Cloisonné dans un espace confiné ;
N’a accès qu’au strict minimum.
L’impact d’une vulnérabilité est diminué.

Architecture d’OpenSSH
Un processus écoutant sur le port 22, avec les droits root ;

Authentification par un autre processus non privilégié ;
Exécution d’un nouveau fils sous l’identité de l’utilisateur
authentifié.

Gestion des erreurs
En cas de plantage. . .
En fonction du contexte, différentes actions peuvent être utilisées :
Fail open : plus de protection, tout est autorisé
Fail closed : on bloque tout.

Choix par défaut
Design conservateur
Un design « conservateur » est un design qui a été écrit en se demandant
pourquoi les objets sont accessibles plutôt que pourquoi ils ne le sont
pas.
⇒ Même principe qu’un firewall !
Exemple : l’authentification UNIX.

Code sécurisé
Quatre aspects à prendre en compte :

Les entrées
Les ressources externes
Données internes
Sortie du programme
Code robuste | 7 novembre 2022 | PAGE 68/97

Code sécurisé

Les entrées
Validation des entrées
Intolérance aux erreurs
Données internes
Sortie du programme

Code sécurisé

Les entrées
Effets de bord
Vérification des codes de retour
Données internes
Sortie du programme

Code sécurisé

Les entrées
Données internes
Stockage des données : listes chaînées, tableaux, etc.
Effets de bord, hypothèses.
Sortie du programme

Code sécurisé

Les entrées
Données internes
Sortie du programme
Ne pas trop en dire
Toujours contrôler ce qui est affiché.

Utilisation de fonctions sûres
On a vu que certaines fonctions ne permettent pas de traiter de données

utilisateur de manière sûre :
N’ont pas de bornes (strcpy()) ;
Ont un comportement non sûr ((strcat()) ;
Ont des effets de bords non négligeables.
La première règle est de bannir ces fonctions.
La deuxième est l’emploi de bibliothèques spécialisées.

Une histoire de style
Tout repose sur l’auteur

Les vulnérabilités proviennent souvent :
Manque de cohérence ;
Manque de clarté ;
Hypothèses invalides ;
Rien ne remplace un programmeur attentif

Tests unitaires
En théorie, les tests unitaires devraient être écrit avant l’écriture du code
par une autre personne.
Ils permettent principalement de se forcer à réfléchir à tous les cas
possibles.
Audit | 7 novembre 2022 | PAGE 71/97

Audit, reviewing
Mode de développement
Un audit permanent est toujours indispensable.
Pendant le développement, l’intégration de modifications devrait être
relues par un nombre minimum de personnes.
Cela assure :
La documentation des modifications (commentaire, messages de
logs) ;
Une certaine cohérence dans le code ;
Une relecture attentive.

Audit, reviewing
Mode de développement
Un audit permanent est toujours indispensable.
Pendant le développement, l’intégration de modifications devrait être
relues par un nombre minimum de personnes.
Cela assure :
La documentation des modifications (commentaire, messages de
logs) ;
Une certaine cohérence dans le code ;
Une relecture attentive.
Repose trop sur l’humain

Fonctionnement de vsftpd
vsftpd est un serveur FTP considéré comme l’un des plus sécurisé.
Audit rigoureux
Chaque fichier a une note de confiance ;
À chaque audit du fichier, sa note est augmentée ;
À chaque moditication du fichier, sa note revient à 0.

Xtrem programming
L’un programme, l’autre supervise.
L’observateur
A une vision globale du projet ;
Joue le rôle de Bernard Pivot ;
Lit la documentation pour vérifier les effets de bords ;
Le programmeur
Code.
La confrontation des deux points de vue est intéressante.

Plan de la section
1 Introduction
2 Attaque
3 OS Hardening
Protections
OS Hardening | 7 novembre 2022 | PAGE 75/97

Sommaire
1 Introduction
Règles du jeux
2 Attaque
Injections
Corruption mémoire
3 OS Hardening
Protections
La part de l’administrateur | 7 novembre 2022 | PAGE 76/97

Operating system
Définition
Un système d’exploitation a la charge d’abstraire le matériel aux
applications en se basant sur des niveaux de privilège.
Il permet de faire tourner de multiples applications en même temps, de
permettre son usage par plusieurs utilisateurs, etc.
Rôle de l’OS | 7 novembre 2022 | PAGE 77/97

Séparation des processus
La grande révolution des années 90

L’après MS-DOS a été magique : chaque processus tourne dans un
espace distinct. Un processus qui plante ne peut plus impacter le reste
du système.
Chaque processus tourne dans un espace mémoire complétement distinct
et les seuls moyens de communiquer entre processus sont les IPC.

IPC
Inter-Process Communication
Signaux ;
Valeur de retour ;
Socket UNIX ou réseau ;
Mémoire partagée ;
Sémaphore.

Système de fichier
Les processus sont libres d’accéder n’importe où sur le système de fichier

tant qu’ils ont les droits nécessaires.
Cela signifie qu’un processus root compromis peut récupérer et modifier
tous les fichiers du système.
Cloisonnement | 7 novembre 2022 | PAGE 80/97

Système de fichier Restrictions supplémentaires
chroot()
Le chrootage permet de modifier la racine (/) d’un processus donné.
Ainsi, il lui est impossible d’accéder en dehors de cet espace.

chroot()
Ce n’est pas un outil de sécurité !

chroot()
Ce n’est pas un outil de sécurité !
Sauf si vous utilisez un patch de sécurité comme grsecurity

Processus et les signaux
Pour envoyer un signal, il faut soit :

Être root ;
Avoir le même ID (effective ou real ID) ;
Être dans la même session.
Cas particulier : le tracage utilise la même règle.

Pour envoyer un signal, il faut soit :

Être root ;
Avoir le même ID (effective ou real ID) ;
Être dans la même session.
Cas particulier : le tracage utilise la même règle.
⇒ Cloisonnement assez faible

Pour se protéger :
Changer d’UID ;
Se tracer soit-même.
Des patches noyau (grsecurity) permettent d’empêcher les processus à
l’intérieur de chroot d’envoyer des signaux en dehors.

Sommaire
1 Introduction
Règles du jeux
2 Attaque
Injections
Corruption mémoire
3 OS Hardening
Protections
Protections | 7 novembre 2022 | PAGE 84/97

Découpage de la mémoire
Un processus est découpé en sections, chacune est définit par :

Une adresse de début et de fin ;
Les permissions (read, write, execute) ;
Etc.
Pourquoi est-ce que les données devraient être exécutables ?
NX, W xor X, execshield, PaX | 7 novembre 2022 | PAGE 85/97

Découpage de la mémoire
Un processus est découpé en sections, chacune est définit par :

Une adresse de début et de fin ;
Les permissions (read, write, execute) ;
Etc.
Pourquoi est-ce que les données devraient être exécutables ?
⇒ Malheureusement, ces permissions étaient virtuelles !
La granularité des permissions n’étaient pas suffisantes.

Bit NX
Fonctionnalité du processeur
L’arrivée de l’architecture 64 bits par AMD a vu l’introduction d’un
nouveau bit, le bit « no execute » qui marque chaque page.

W xor X
Le jeu des attaquants s’est alors modifié, le but est maintenant de

modifier des pages mémoires avec le bit d’exécution activé.
OpenBSD : Writing xor execute

Le noyau s’assure qu’une page ne peut pas avoir à la fois le bit d’écriture
et le bit d’exécution.

New rules
Chat et la souris
À cause des protections précédentes, il n’est plus possible d’exécuter
aussi facilement du code depuis le buffer en train d’être exploiter.
⇒ Car les pages ne sont pas exécutables.
Le jeu est maintenant d’exécuter des instructions « légitimes ». Réussir à
sauter dans les fonctions de la libc par exemple.
ASLR | 7 novembre 2022 | PAGE 88/97

Address Space Layout Randomization
Randomization des adresses

L’ASLR consiste à rendre aléatoire les adresses de section afin
d’empêcher un exploit de sauter dans du code existant.
La randomization est renouvelée à chaque exécution (ou pas) ;

La quantité d’entropie n’est pas toujours parfaite ;
Avoir un information leak devient un atout ;
Un off-by-one peut devenir la méthode facile.
ASLR | 7 novembre 2022 | PAGE 89/97

Padding, réordonnancement
Stack overflow
Les variables sont réordonnancées pour éviter qu’un overflow puisse
déborder dans des pointeurs de données utilisés plus tard.
Off-by-one
Pour des raisons d’optimisation des accès mémoire, les variables sont
alignées en utilisant du padding.
Il y a désormais un peu de place entre deux variables si nécessaire.
Compilateur | 7 novembre 2022 | PAGE 90/97

Canaris
Une valeur aléatoire est placée entre la première variable locale et le

pointeur de pile sauvegardé.
Lorsqu’on sort d’une fonction, le canari est vérifié, s’il n’a pas été écrasé,
on déroule l’épilogue.
Compilateur | 7 novembre 2022 | PAGE 91/97

Vérifications de sécurité dans la libc
GNU libc
Des vérifications supplémentaires sont désormais effectuées avant de
supprimer un chunk.
Toutes les méthodes classiques d’exploitations sont caduques.
Dans Microsoft Vista, toutes les adresses sont XORées avec un nombre
aléatoire.
libc | 7 novembre 2022 | PAGE 92/97

Resistance is futile
Disclaimer
Chaque technique prise indépendamment est contournable, mais
l’utilisation de toutes ces techniques permet d’assurer un niveau de
sécurité suffisant.
⇒ Défense en profondeur

Contrôle d’accès à base de rôle
RBAC
Lors d’un appel système, le noyau vérifie que le processus en cours (qui
tourne sous un rôle donné) a l’autorisation d’effectuer l’opération.
Exemple : SELinux, AppArmor, GrSecurity, RSBAC.

Complexité de configuration.

Et bien d’autre...
Signature des pointeurs par le cpu

Data execution prevention
Protection des pages kernel
KASLR
CFI protection
...

Impact d’un bug noyau
Quel est l’impact d’un bug dans le noyau ?
Bug noyau | 7 novembre 2022 | PAGE 96/97

Réveillez votre voisin
C’est fini.
Bug noyau | 7 novembre 2022 | PAGE 97/97

Slides Cours Securite

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Slides Cours Securite

Transféré par

Droits d'auteur :

Formats disponibles

Vulnérabilités, protections

Vulnérabilité, Risques, Intrusion

| 7 novembre 2022 | PAGE 2/97

Introduction | 7 novembre 2022 | PAGE 3/97

Règles du jeux | 7 novembre 2022 | PAGE 4/97

Oublier tout ce que vous savez !

Règle numéro une | 7 novembre 2022 | PAGE 5/97

Oublier tout ce que vous savez !

Règle numéro une | 7 novembre 2022 | PAGE 5/97

Oublier tout ce que vous savez !

Règle numéro une | 7 novembre 2022 | PAGE 5/97

Un bug est un comportement ou un résultat incorrect.

Définitions | 7 novembre 2022 | PAGE 6/97

Denial of Service : le programme plante ;

Impacts | 7 novembre 2022 | PAGE 7/97

Denial of Service : le programme plante ;

La gravité dépend de l’environnement.

Impacts | 7 novembre 2022 | PAGE 7/97

Données issues de l’attaquant

Vulnérabilité par complexité | 7 novembre 2022 | PAGE 8/97

Vulnérabilité par complexité | 7 novembre 2022 | PAGE 9/97

Vulnérabilité par complexité | 7 novembre 2022 | PAGE 9/97

La puissance des regexps est sous-estimée :

CVE-2009-3695 : Vulnérabilité par les données validées

Pour chaque caractère après @, on regarde si l’expression (.*)+ matche.

Vulnérabilité par complexité | 7 novembre 2022 | PAGE 10/97

Vulnérabilité par complexité | 7 novembre 2022 | PAGE 11/97

Vulnérabilités cryptographiques | 7 novembre 2022 | PAGE 12/97

La crypto, c’est chaud.

Vulnérabilités cryptographiques | 7 novembre 2022 | PAGE 13/97

La crypto, c’est chaud.

Vulnérabilités cryptographiques | 7 novembre 2022 | PAGE 13/97

La crypto, c’est chaud.

Vulnérabilités cryptographiques | 7 novembre 2022 | PAGE 13/97

La crypto, c’est chaud.

Vulnérabilités cryptographiques | 7 novembre 2022 | PAGE 13/97

get_next_prime(p, rand_buf, size);

Vulnérabilités cryptographiques | 7 novembre 2022 | PAGE 14/97

get_next_prime(p, rand_buf, size);

Vulnérabilités cryptographiques | 7 novembre 2022 | PAGE 14/97

Vulnérabilités logiques | 7 novembre 2022 | PAGE 15/97

Hypothèses du développeur fausses.

Taille de la ligne de commande limitée ;

Vulnérabilités logiques | 7 novembre 2022 | PAGE 16/97

Vulnérabilités logiques | 7 novembre 2022 | PAGE 17/97

Entre la ligne 1 et 4, le fichier a pu être remplacé.

Vulnérabilités logiques | 7 novembre 2022 | PAGE 18/97

Entre la ligne 1 et 4, le fichier a pu être remplacé.

Vulnérabilités logiques | 7 novembre 2022 | PAGE 18/97

Pourquoi les scripts ne peuvent être setuid ?

1 u s e r s p a c e >e x e c v e ( " . / myprogram . py " , NULL , NULL ) ;

Vulnérabilités logiques | 7 novembre 2022 | PAGE 19/97

1 tmp = open ( ’ / tmp/ myprog .%d ’ % o s . g e t p i d ( ) )

Le PID est devinable donc un lien symbolique peut-être créé.

Vulnérabilités logiques | 7 novembre 2022 | PAGE 20/97

Un lien symbolique peut pointer :

Imaginons que le programme suivant tourne avec des privilèges élévés :

Vulnérabilités logiques | 7 novembre 2022 | PAGE 21/97

Un lien symbolique peut pointer :

Imaginons que le programme suivant tourne avec des privilèges élévés :

Si l’utilisateur créé un lien symbolique $HOME/.myconfigfile pointant sur

Vulnérabilités logiques | 7 novembre 2022 | PAGE 21/97

Page de manuel d’OpenBSD

Vulnérabilités logiques | 7 novembre 2022 | PAGE 22/97