Chiffrement de Fichiers Par Mot de Passe(PBE) en Java

Dans ce tutoriel, on va essayer de parler de la plus simple des manières de la mise en d’un petit utilitaire de chiffrement basé sur mot de passe en JAVA. Toutefois je n’entrerai dans les détails de l’architecture JCE/JCA

C’est Quoi PBE : PBE: Password-Based Encryption est une technique de chiffrement symétrique dont la clé est générée à partir d’un Mot de Passe.

Pour des détails cf RFC 2898 , Attention aux primitives cryptographiques obsolètes dans ces Spec qui datent de longtemps.

Pourquoi PBE:   En environnement Symétrique, un problème de partage de clés(données secrètes) se pose car on ne dispose pas encore de canal sûr. C’est le cas pour beaucoup de protocoles réseaux standards sécurisés (dans leur version à secret partagé) : WIFI WPA2, VPN  , PBKDF2 ,  bref partout où on demande un mot de passe pour établir un canal sûr.

Pour éviter (alléger) ce problème, on passe par un chaînage composé de fonctions de Compression et d’expansion pour obtenir un KDF qui permet de dériver une clé à partir d’un mot de passe d’une manière déterministe(mot de passe reproductible ).

Comment PBE?: 

Chiffrement:

  • J’ai un message M à chiffrer (fichier de n’importe quel type),
  • j’appelle le KDF en lui fournissant mon mot de passe  (+salt , +nbre d’Itération :-D) qui me retourne la clé K
  • Je chiffre M avec la clé K pour Obtenir le chiffré C

Déchiffrement:

  • J’ai un message C à déchiffrer,
  • j’appelle le KDF en lui fournissant mon mot de passe  (+salt , +nbre d’Itération :-D) qui me retourne la clé K
  • Je déchiffre C avec la clé K pour Obtenir le clair M

On en vient à la Pratique, génial  😀

Java a mis en place une plateforme de cryptographie (JCA/JCE) permettant d’utiliser les standard cryptographiques du marché sans qu’on ait besoin de ré-implémenter toute la pile: une batterie de spécifications , d’interfaces, d’implémentations, …. nous permettant soit de fournir des services cryptographiques ou bien d’en utiliser.

Je ne parlerai pas d’architecture JCA/JCE encore moins de Provider, même pas de BouncyCastle  pour aujourd’hui  car  je suis au bureau 😀 (Consultance Sonatel 17/11/2017 ).

C’est plus fort que moi il faut que j’en parle:

JCA/JCE se fixe comme principe:

  • Indépendance de l’implémentation
  • Interopérabilité de l’implémentation
  • Extensibilité des algorithmes

Résumé:

  • JCE/JCA = Java Cryptographic Extension / Java Cryptographic
    Architecture
  • Un Provider implémente les interfaces spécifiées par les packages JCE/JCA.
  • Javax.crypto.* fournit les classes et les interfaces pour effectuer des opérations cryptographiques sur les algorithmes symétriques.
  • Java.security.* fournit les classes et les interfaces pour le framework de sécurité Java. Elles permettent entre autres de faire :
    • La génération de nombres aléatoire
    • Le calcul de digests
    • des Signatures a l’aide d’algorithmes asymétriques
    • …………..

Le Programme:

On se propose de réaliser une Application composée essentiellement de trois fonctions:

  • Génération de clé: input: mot-de-passe,  output clé symétrique
  • Chiffrement: input: clé symétrique, fichier source à chiffrer
  • Déchiffrement : input: clé symétrique, fichier source à déchiffrer

Pour se fixer les idées, on spécifie tout ça dans une Interface JAVA. Une fois la clé obtenue nous souhaitons utiliser AES  comme schéma de chiffrement symétrique en mode CBC avec le padding PKCS5  . La clé PBE générée sera convertie en type de représentation opaque avec la transformation: PBEWithHmacSHA256AndAES_128 pour obtenir une instance de SecreteKeyFactory sur JAVA 7 (on a plus de possibilité sur JAVA8). NB. on aurai pu mettre ceci dans un fichier de configuration mais pour faciliter on le met juste dans une interface.

public interface ICryptoSymUtil {
 public final int keysize=128;
 public final byte [] IV="AseizeCaracteres".getBytes();
 public final String keyAlgo="AES";
 public final String algotransform="AES/CBC/PKCS5Padding";
 public final String skftransform="PBEWithHmacSHA256AndAES_128";
 public final String kdf="PBKDF2WithHmacSHA1";
 public final int ieration=1000;
 public final byte [] salt="MO5-°HG3YEH255367gdsjhgd".getBytes();

public void chiffrement(Key k, String inputFile);
 public void dechiffrement(Key k, String inputFile);
 public Key generationPBEKey(String mdp);
}

Ici On passe à une implémentation (des méthodes) de l’interface :

public class CryptoSymUtil implements ICryptoSymUtil {
public Key generationPBEKey(String mdp) {
        Key clepbe=null;
        //on appelle Transforme le mot de passe en tableau de Char
        char[] password = mdp.toCharArray();
        PBEKeySpec pbe = new PBEKeySpec(password, salt, ieration, keysize);
        //on vide le tableau de char password
        mdp="";
	for (int j = 0; j < password.length; j++) {
		password[j] = 0;
	}
	try {  
         //on appelle le KDF: PBEKeySpec pour construire une clé
          SecretKeyFactory kdfFactory = SecretKeyFactory.getInstance(kdf);
          SecretKey keyPBE = kdfFactory.generateSecret(pbe);
          clepbe=new SecretKeySpec(keyPBE.getEncoded(), keyAlgo);
			
       } catch (Exception e) {
	     // TODO Auto-generated catch block
	      e.printStackTrace();
       }
                
       return clepbe;
    }

ICI le fichier chiffré portera le nom que le fichier d’origine mais
avec une extension « cry ». Exemple: document.pdf.cry ou image.iso.cry,

 @Override
 public void chiffrement(Key k, String inputFile) {
 try {
    Cipher cif=Cipher.getInstance(algotransform);
    cif.init(Cipher.ENCRYPT_MODE, k, new IvParameterSpec(IV));
    FileInputStream fis = new FileInputStream(inputFile);
    CipherInputStream cis = new CipherInputStream(fis, cif);
    FileOutputStream fos = new FileOutputStream(inputFile+".cry");
    byte[] buffer = new byte[256];
    int nbBytesLu=0;
    while ((nbBytesLu = cis.read(buffer)) != -1){
         fos.write(buffer, 0, nbBytesLu);
   }
   fis.close();
   fos.close();
   System.out.println("encryption succeed");
   } catch (Exception ex) {
    Logger.getLogger(CryptoSymUtil.class.getName()).log(Level.SEVERE, null, ex);
   }
  }

Le Fichier déchiffré retrouvera son nom d’origine en enlevant le « .cry »

public void dechiffrement(Key k, String inputFile) {
 try {
 Cipher cif=Cipher.getInstance(algotransform);
 cif.init(Cipher.DECRYPT_MODE, k, new IvParameterSpec(IV));
 FileInputStream fis = new FileInputStream(inputFile);
 FileOutputStream fos = new FileOutputStream(inputFile.substring(0,
 inputFile.length()-4));
 CipherOutputStream cos = new CipherOutputStream(fos, cif);
 
 byte[] buffer = new byte[256];
 int nbBytesLu=0;
 while ((nbBytesLu = fis.read(buffer)) != -1){
 cos.write(buffer, 0, nbBytesLu);
 }
 fis.close();
 fos.close();
 
 System.out.println("Decryption succeed!!!!");
 
 } catch (Exception ex) {
 Logger.getLogger(CryptoSymUtil.class.getName()).log(Level.SEVERE, null, ex);
 }
 }

}

Exemple de test:

public static void main(String[] args) {
        // TODO code application logic here
        CryptoSymUtil util = new CryptoSymUtil();
        Key key = util.generationPBEKey("MonMot dePasseFort");
        System.out.println(key.getEncoded().length);
        util.chiffrement(key, "Temp.pdf");
        util.dechiffrement(key, "Temp.pdf.cry");

    }

not the end, but rather the beginning,

Dans un prochain, Post Je montrerai comment peut-on enchaîner  le chiffrement des tous les fichiers d’un dossier.

 

Mise en place d’une autorité de certification racine (Open SSL)

TP : Mise en place d’une autorité de certification racine

Pré requis :

Installer Apache (Ex EasyPHP, WAMP ou bien LAMP server)

Installer OpenSSL (si vous êtes sous Windows)

Mise en place de la CA racine :

Après installation d’OpenSSL, viellez à positionner le chemin du répertoire « bin » d’OpenSSL dans la variable $PATH (si vous êtes sous Windows).

Configuration du mini PKI

Créer un répertoire nommé «PKI » contenant deux sous-répertoires « newcerts » et  « private » et le fichier de configuration nommé « openssl.cnf ».

*******************************************************************

Le répertoire PKI contiendra les éléments suivants :

  • Le certificat (racine) de notre Autorité de Certification (CA)
  • La base de données des certificats signés
  • Les clés, requêtes et certificats que nous allons générer

Le répertoire PKI/newcerts contiendra :

  • Une copie de chaque certificat signé par le CA

Le répertoire PKI/private contiendra :

  • La clé privée de notre CA (Protégée par un mot de pass Fort)

*****************************************************************************

La prochaine étape est de créer une base de données pour référencer les certificats que nous allons signer. Placez-vous dans le répertoire PKI et tapez cette commande :

Créer un fichier serial (sans extension) et placer 01 au début du fichier.

Ensuite créer un fichier nommé « index.txt » dans ce même répertoire

Ouvrir le fichier de configuration(openssl.cnf) de votre CA et adapter à votre situation en changeant les valeurs.

Pour la génération de certificat, plusieurs paramètres sont en général demandés. Pour faciliter la tâche il est préférable d’éditer un fichier de configuration contenant les valeurs par défaut des certificats à générer.

Ce fichier est divisé en sections, qui sont lues et traitées en fonction des arguments passés sur la ligne de commande. Les sections peuvent inclure une ou plusieurs autres sections en y faisant référence, ce qui augmente la modularité du fichier de configuration. Un nom entre crochets (par exemple [req]) marque le début de chaque section.

Nous avons maintenant la section définissant la manière dont les certificats seront créés, et une section définissant le type de certificat à créer.

##########################################################

#
# OpenSSL configuration file.
#

# Establish working directory.

dir = .

[ ca ]
default_ca = CA_default

[ CA_default ]
serial = $dir/serial
database = $dir/index.txt
new_certs_dir = $dir/newcerts
certificate = $dir/cacert.pem
private_key = $dir/private/cakey.pem
default_days = 365
default_md = sha1
preserve = no
email_in_dn = no
nameopt = default_ca
certopt = default_ca
policy = policy_match

[ policy_match ]
countryName = match
stateOrProvinceName = match
organizationName = match
organizationalUnitName = optional
commonName = supplied
emailAddress = optional

[ req ]
default_bits = 2048 # Size of keys
default_keyfile = client_key.pem # nom par défaut de la clé privée du demander à modifier
default_md = sha1 # message digest algorithm
string_mask = nombstr # permitted characters
distinguished_name = req_distinguished_name
req_extensions = v3_req

[ req_distinguished_name ]
# Variable name Prompt string
#---------------------- ----------------------------------
0.organizationName = Organization Name (company)
organizationalUnitName = Organizational Unit Name (department, division)
emailAddress = Email Address
emailAddress_max = 40
localityName = Locality Name (city, district)
stateOrProvinceName = State or Province Name (full name)
countryName = Country Name (2 letter code)
countryName_min = 2
countryName_max = 2
commonName = Common Name (hostname, IP, or your name)
commonName_max = 64

# Default values for the above, for consistency and less typing.
# Variable name Value
#------------------------------ ------------------------------
0.organizationName_default = DevMaster
localityName_default = Dakar
stateOrProvinceName_default = Senegal
countryName_default = SN

[ v3_ca ]
basicConstraints = CA:TRUE
subjectKeyIdentifier = hash
authorityKeyIdentifier = keyid:always,issuer:always

[ v3_req ]
basicConstraints = CA:FALSE
subjectKeyIdentifier = hash

##########################################################

**********************************************************************************

A chaque fois que vous utiliserez votre certificat de CA pour signer une requête, la phrase de passe vous sera demandée. Choisissez donc une phrase de passe non triviale et assurez-vous de ne pas la perdre. Exemple « 123456 » « Très Mauvais ! je le prends quand même ».

Pour créer notre certificat racine auto-signé, nous  allons pour cela fournir ces paramètres sur la ligne de commande.

Voilà le détail des paramètres que nous allons passer à la commande openssl req :

  • Créer un nouveau certificat auto-signé : -new -x509
  • Créer un certificat de CA : -extensions v3_ca
  • Allonger sa durée de validité à 10 ans : -days 3650
  • Spécifier le nom des fichiers de sortie : -keyout, -out
  • Utiliser notre fichier de configuration : -config ./openssl.cnf

Une note sur la durée de validité des certificats racine : Lorsqu’un certificat racine expire, tous les certificats signés avec ce certificat racine sont invalidés. Pour corriger celà, un nouveau certificat racine doit être créé et distribué. De plus, tous les certificats signés avec le certificat racine périmé doivent être révoqués et signés à nouveau avec le nouveau certificat racine. 

>openssl req -new -x509 -extensions v3_ca -keyout private/cakey.pem -out cacert.pem -days 3650 -config ./openssl.cnf

Ce processus crée deux fichiers de sortie:

  • Une clé privée dans private/cakey.pem
  • Un certificat de CA racine dans cacert.pem

Le fichier cacert.pem est le certificat de CA racine que vous devrez distribuer aux clients.

Question : Taper ces commandes à la console et expliquer ce qu’elles font :

  • openssl x509 -in cacert.pem -noout -text
  • openssl x509 -in cacert.pem -noout -dates
  • openssl x509 -in cacert.pem -noout –purpose

Si vous vouliez que les utilisateurs soient capables d’installer le certificat dans leur navigateur (en le téléchargeant et en l’ouvrant), vous devez créer une version codée DER du certificat :

>openssl x509 -in cacert.pem  -out cacert.der.crt -outform DER

 

Création d’une Requête de Signature de Certificat (CSR) :

Maintenant que nous disposons d’un certificat racine, nous pouvons créer autant de certificats que nous le voulons et les utiliser dans nos applications SSL telles qu’https, FTPS, POP,  VPN,…. La procédure à suivre implique de créer une clé privée et une demande de signature de certificat (Certificate Signing Request ou CSR), puis de faire signer cette demande pour générer un certificat.

Dans cet exemple, nous allons créer une requête de  certification à fournir au CA pour avoir un certificat signé  pour sécuriser le serveur Web du site  «ouzdeville.com ».

Pour cela le demandeur de signature fournit les informations suivantes dans le processus de génération:

  • Organizational Unit: Une description de ce à quoi est destiné le certificat
  • Email Address:
  • Common Name: Le nom d’hôte du serveur

Le Common Name doit être (ou l’adresse IP doit être résolue comme) le nom utilisé par vos clients pour contacter votre serveur(Taper sur les navigateurs). S’il ne correspond pas, vos clients verront à chaque fois qu’ils se connecteront un message leur demandant s’ils veulent utiliser ce serveur. En effet, le logiciel client dira :  » Vous avez tenté d’accéder à ouzdeville.com, mais le serveur a présenté un certificat émis par une entité non approuvée par le système d’exploitation de votre ordinateur.  »

Taper la commande :

>openssl req -new -nodes -out req-ouzdeville.pem -config ./openssl.cnf

Ce processus produira deux fichiers de sortie:

  • Une clé privée dans client_key.pem
  • Une CSR dans req-ouzdeville.pem

Ces fichiers doivent être conservés. Quand le certificat que vous êtes sur le point d’avoir expirera, la CSR pourra être utilisée à nouveau pour créer un nouveau certificat avec une autre date d’expiration. La clé privée est naturellement nécessaire pour le chiffrement SSL. Lorsque vous sauvegarderez ces fichiers, il sera préférable d’utiliser des noms explicites tels que  key-ouzdeville.pem et req-ouzdeville.pem.

Nous pouvons inspecter le contenu de notre requête pour nous assurer qu’elle soit correcte :

>openssl req -in req-ouzdeville.pem -text -verify –noout

 

Signer un certificat

Pour signer la CSR que nous avons créée à l’étape précédente, On n’envoie que le fichier req-ouzdeville.pem au CA pour avoir un certificat signé.

exécutez la commande suivante et répondez aux questions. Notez que la phrase de passe PEM qui vous sera demandée est celle que vous avez définie  plus haut :

>openssl ca -out cert-ouzdeville.pem -config ./openssl.cnf -infiles req-ouzdeville.pem

Celà met à jour la base de données de la CA et produit deux fichiers de sortie :

  • Un certificat dans cert-ouzdeville.pem
  • Une copie de ce certificat dans newcerts/<numéro de série>.pem

Encore une fois, vous pouvez contrôler ce certificat :

>openssl x509 -in cert-ouzdeville.pem -noout -text -purpose | more

Ce certificat contient à la fois la version encodée et une version humainement lisible dans le même fichier. Vous pouvez supprimer la version humainement lisible de la façon suivante:

>mv “(oubien move)” cert-ouzdeville.pem tmp.pem

>openssl x509 -in tmp.pem -out cert-ouzdeville.pem

Exportation Certificat:

Si vous vouliez qu’il soit possible d’installer le certificat dans les navigateurs, vous pouvez créer une version codée DER du certificat :

>openssl x509 -in cert-groupeism.pem -out cert-groupeism.der.crt -outform DER

Installation du certificat et de la clé privée

Vous disposez les deux éléments suivants :

  • Une clé privée dans client_key.pem
  • Un certificat dans cert-ouzdeville.pem

Copiez les fichiers nécessaires aux emplacements indiqués par les instructions spécifiques à votre application et votre système. Redémarrez les applications, et vous utilisez maintenant votre nouveau certificat.

 

Exemple : APACHE (Localhost):

 

Faire une requête de certification pour votre serveur Local (localhost) :

(N’oublier pas de spécifier le nom DNS du serveur pour le Common Name)

>openssl req -new -nodes -out localhost.csr -config ./openssl.cnf

Signer le certificate avac la clé privée de votre CA

>openssl ca -out localhost.pem -config ./openssl.cnf -infiles localhost.csr

Vous disposez les deux éléments suivants :

  • Une clé privée dans client_key.pem
  • Un certificat dans localhost.pem

Pour envoyer le certificat à quelqu’un on utilise un format DER

>openssl x509 -in localhost.pem  -out localhost.der.crt -outform DER

Après avoir obtenu la paire de clés (certificat et clé privée) pour le server, On passe à la configuration de ce dernier pour utiliser SSL.

Ouvrir le fichier de configuration d’Apache (httpd.conf) et changer

# LoadModule ssl_module modules/mod_ssl.so

En (enlever le #)

LoadModule ssl_module modules/mod_ssl.so

A la fin du fichier ajouter et corriger DocumentRoot, Directory, SSLCertificateFile, SSLCertificateKeyFile

 

<VirtualHost localhost:443>

        DocumentRoot « le_chemin_du_WWW »

        ServerName  localhost

    <Directory « le_chemin_du_WWW« >

        Options Indexes MultiViews FollowSymLinks

        AllowOverride None

        Order deny,allow

        Deny from all

        Allow from all

    </Directory>       

    SSLEngine on

    SSLCertificateFile « chemin_de_localhost.pem »

    SSLCertificateKeyFile « chemin_de_ key.pem »

</VirtualHost>

SYLLABUS – SECURITE DES RESEAUX ET SYSTEMES

LICENCE 3

  • Introduction à la sécurité des SI
    • Les menaces
    • Les vulnérabilités
    • Les risques
    • Les attaques
  • Le vocabulaire de la sécurité informatique.
  • Politique de sécurité
  • Quelques mots sur la Cryptologie

TP sur OpenSSL

  • Scurité systèmes et réseaux, niveau 1é
    • Les différentes attaques sur un système
    • Le protocole TCP/IP
    • Illustration (ARP et IP Spoofing, TCP-SYNflood, SMURF.). Déni de service et déni de service distribué
    • Architectures de sécurité
      • Plan d’adressage sécurisé : RFC 1918.
      • Translation d’adresses (FTP comme exemple).
      • Le rôle des zones démilitarisées.
      • Exemples d’architectures.
      • Sécurisation de l’architecture par la virtualisation
      • Contrôle d’accès
      • Filtrage
      • Actions et limites des Firewall réseaux traditionnels.
      • Evolution technologique des Firewalls (Appliance, VPN, IPS, UTM…).
      • Les firewalls et les environnements virtuels.
      • Proxy ou firewall : concurrence ou complémentarité ?
      • Reverse proxy, filtrage de contenu, cache et authentification.
      • Travaux pratiques

Mise en œuvre d’un proxy Cache/Authentification.

Les Routeurs Cisco ACLs,

Implementation avec IPCop, PFsens, PacketFence , Squid-SquidGuard, smoofwall,

    • Sécurité des données
      • Cryptographie
        • Chiffrements symétrique et asymétrique. Fonctions de hachage.
        • Services cryptographiques.
        • Authentification de l’utilisateur (centralisée)
        • L’importance de l’authentification réciproque.
        • Certificats X509. Signature électronique.
        • Radius.
        • Le protocole Kerberos
        • Le serveur d’authentification type AAA
        • L’annuaire LDAP
        • Le protocole RADIUS
        • Projet : WPA, Radius et serveur AAA, l’implémentation d’entreprise.
      • Travaux pratiques

                                          Déploiement d’un relais SMTP et d’un proxy HTTP/FTP Antivirus. Mise en oeuvre d’un certificat serveur.

    • Sécurité des échanges
      • Sécurité WiFi
        • Risques inhérents aux réseaux sans fils.
        • Les limites du WEP. Le protocole WPA et WPA2.
        • Les types d’attaques.
        • Translation d’adresse NAT
        • IPSec et le protocole SSL/TLS
        • Modes tunnel et transport  ESP et AH.
        • Analyse du protocole et des technologies associées (SA, IKE, ISAKMP, ESP, AH…).
      • Sécurité Basique avec les équipements CISCO
        • Les Réseaux Privé Virtuel VPN
        • Authentifications dans les VPN : PPP, PAP, CHAP, Radius, Tacacs. Implémentation sous Linux et Windows

MASTER 1

  • Sécurité des Système d’exploitation
    • Présentation
      • Insuffisance des installations par défaut.
      • Critères d’évaluation (TCSEC, ITSEC et critères communs).
    • Sécurisation de Windows
      • Gestion des comptes et des autorisations.
      • Contrôle des services.
      • Configuration réseau et audit.
    • Sécurisation de Linux
      • Configuration du noyau.
      • Système de fichiers.
      • Gestion des services et du réseau.
    • Travaux pratiques
      • Présentation du gestionnaire de la sécurité Windows et de Bastille Linux.
    • Méthodes de détections d’intrusions (IDS) & IPS
      • Les IDS les plus connus
      • Snort
      • Nessus
      • Ntop
      • IDSCenter
      • EagleX
    • Les outils de supervision des réseaux
      • EON
      • CommView
      • NetPalplus
      • Nagios
    • Sécurité réseaux avec Cisco, PIX et routeurs….
    • Cisco Firewall ASA, configuration et administration
    • Traiter efficacement les logs pour optimiser votre sécurité SI
    • Audit et sécurité au quotidien, Evaluer le niveau de sécurité du SI

Les outils et techniques disponibles

  • Tests d’intrusion : outils et moyens.
  • Détection des vulnérabilités (scanners, sondes IDS…).
  • Les outils de détection temps réel IDS-IPS, agent, sonde ou coupure.
  • Réagir efficacement en toutes circonstances
  • Supervision et administration.

–   Impacts organisationnels.

–  Veille technologique.

–   Plan de reprise d’activités

  • Sécurisez votre réseau en Open Source
  • Etude de cas
    • Etude préalable
    • Analyse du besoin.
    • Elaborer une architecture.
    • Définir le plan d’action.
  • Déploiement
    • Démarche pour installer les éléments.
    • Mise en oeuvre de la politique de filtrage.

 

 

MASTER 2

  • PKI, mise en œuvre Sign-On (SSO) : EJBCA
  • Cisco Firewall ASA, configuration et administration
  • Sécurité des applications Web PHP 5, sécurité des applications comprendre pour réduire les risques
  • Windows 2008/2003, sécuriser l’infrastructure. Windows 7, sécurité et performance
  • Sécuriser un système Linux/Unix (système, service, réseau)
  • Sécurité IPV6
  • Java/JEE, sécurité des applications
  • Sécurité des bases de données (données applicatives): Oracle & MySQL & PostGres & SQL Server
  • Sécurité des applications Mobiles
  • La voix sur IP et la sécurité
  • Sécurité (des webServices) B2B , C2B
  • Cycle certifiant Responsable Sécurité SI : ISO 270X, ITIL, EBIOS, MEHARI. Lois sur la CRYPTOLOGIE , DONNEES A CARACTERE PERSONNEL et CYBERCRIMINALITE

 

ARPSPOOF

ARP spoofing

Ce type d’attaque est classé parmi les « man in the middle attack ». Elle a pour but de récupérer (rediriger) des paquets destinés à d’autres hôtes en modifiant la table (cache) ARP de la victime.
Pour un premier article je vous présente simplement  comment rediriger des paquets vers soi (hôte).

Après avoir installer le paquet de « arpspoof » sous linux.

Vous tapez sur la console :

$ sudo arpspoof  (-i interface)  –t  ip_gateway ip_victim

Ceci fait, vous allez voir que la victime ne pourra plus accéder internet via ce gateway et que vous continuez à avoir internet ainsi que les autres machines du réseau.

Vous pouvez l’améliorer en attaquant toutes les machines du réseau et mieux en faisant un man in the middle complet pour que les victimes ne sentent pas votre présence. A vos claviers la solution est au bout des doigts.