2009-02-19 5 views
0

Le commentaire this essay est un commentaire sur un moyen fantasmagorique de battre les mots de passe. Scannez l'ensemble du disque dur d'un utilisateur, y compris l'espace mort, l'espace d'échange, etc., et essayez tout ce qui semble être un mot de passe.Des outils pour réduire les risques liés à la sécurité des mots de passe et à l'espace libre du disque dur

La question: partie 1, existe-t-il des outils autour (un CD live par exemple) qui va scanner un système de fichiers démonté et zéro tout ce qui peut être? (Note Je suis pas essayer de trouver les mots de passe)

Cela comprendrait:

  • espace Slack qui ne fait pas partie d'un fichier
  • parties inutilisées du dernier bloc utilisé par un fichier
  • espace de swap
  • fichiers hibernation
  • espace mort à l'intérieur de certains types de fichiers binaires (comme .DOC)

L'outil (mis à part le dernier cas) ne modifierait rien qui puisse être détecté via l'API du système de fichiers. Je suis pas à la recherche d'un dispositif de bloc trouver/remplacer, mais plutôt quelque chose qui ne fait que nettoyer tout ce qui ne fait pas partie d'un fichier.

partie 2, Dans quelle mesure un tel programme serait-il pratique? Est-ce que ce serait difficile d'écrire? Dans quelle mesure les formats de fichiers contiennent-ils des données non initialisées? Une manière (risquée et coûteuse) de le faire consisterait à utiliser un outil de sauvegarde prenant en charge le système de fichiers (un outil qui copie uniquement les données réelles) pour sauvegarder tout le disque, le nettoyer et le restaurer.

Répondre

1

Je ne comprends pas votre première question (ce que vous voulez modifier le système de fichiers Pourquoi est-ce pas l'espace mort exactement où vous voulez regarder??)

Quoi qu'il en soit, here's an example of such a tool:

#include <stdio.h> 
#include <alloca.h> 
#include <string.h> 
#include <ctype.h> 

/* Number of bytes we read at once, >2*maxlen */ 
#define BUFSIZE (1024*1024) 

/* Replace this with a function that tests the passwort consisting of the first len bytes of pw */ 
int testPassword(const char* pw, int len) { 
    /*char* buf = alloca(len+1); 
    memcpy(buf, pw,len); 
    buf[len] = '\0'; 
    printf("Testing %s\n", buf);*/ 

    int rightLen = strlen("secret"); 
    return len == rightLen && memcmp(pw, "secret", len) == 0; 
} 

int main(int argc, char* argv[]) { 
    int minlen = 5; /* We know the password is at least 5 characters long */ 
    int maxlen = 7; /* ... and at most 7. Modify to find longer ones */ 

    int avlen = 0; /* available length - The number of bytes we already tested and think could belong to a password */ 
    int i; 
    char* curstart; 
    char* curp; 
    FILE* f; 
    size_t bytes_read; 
    char* buf = alloca(BUFSIZE+maxlen); 

    if (argc != 2) { 
     printf ("Usage: %s disk-file\n", argv[0]); 
     return 1; 
    } 

    f = fopen(argv[1], "rb"); 
    if (f == NULL) { 
     printf("Couldn't open %s\n", argv[1]); 
     return 2; 
    } 

    for(;;) { 
     /* Copy the rest of the buffer to the front */ 
     memcpy(buf, buf+BUFSIZE, maxlen); 
     bytes_read = fread(buf+maxlen, 1, BUFSIZE, f); 

     if (bytes_read == 0) { 
      /* Read the whole file */ 
      break; 
     } 

     for (curstart = buf;curstart < buf+bytes_read;) { 
      for (curp = curstart+avlen;curp < curstart + maxlen;curp++) { 
       /* Let's assume the password just contains letters and digits. Use isprint() otherwise. */ 
       if (!isalnum(*curp)) { 
        curstart = curp + 1; 
        break; 
       } 
      } 
      avlen = curp - curstart; 

      if (avlen < minlen) { 
       /* Nothing to test here, move along */ 
       curstart = curp+1; 
       avlen = 0; 
       continue; 
      } 

      for (i = minlen;i <= avlen;i++) { 
       if (testPassword(curstart, i)) { 
        char* found = alloca(i+1); 
        memcpy(found, curstart, i); 
        found[i] = '\0'; 
        printf("Found password: %s\n", found); 
       } 
      } 
      avlen--; 
      curstart++; 
     } 
    } 
    fclose(f); 

    return 0; 
} 

Installation:

  1. Démarrer un live CD Linux
  2. Copiez le programme dans le fichier hddpass.c dans votre h ome répertoire
  3. Ouvrez un terminal et tapez la commande suivante
  4. su || sudo -s # vous rend racine afin que vous puissiez accéder au disque dur
  5. apt-get install -y gcc # Installer gcc

    Cela ne fonctionne que sur Debian/Ubuntu et al, vérifiez votre système documentation pour les autres

  6. gcc -o hddpass hddpass.c # Compile.
  7. ./hddpass /dev/YOURDISK # Le disque est généralement sda, hda sur les anciens systèmes
  8. Regardez la sortie

Test (copie à la console, en tant que root):

gcc -o hddpass hddpass.c 

</dev/zero head -c 10000000 >testdisk # Create an empty 10MB file 
mkfs.ext2 -F testdisk # Create a file system 
rm -rf mountpoint; mkdir -p mountpoint 
mount -o loop testdisk mountpoint # needs root rights 
</dev/urandom head -c 5000000 >mountpoint/f # Write stuff to the disk 
echo asddsasecretads >> mountpoint/f # Write password in our pagefile 
# On some file systems, you could even remove the file. 
umount testdisk 

./hdpass testdisk # prints secret 

Testez vous-même sur un CD Ubuntu Live:

# Start a console and type: 
wget http://phihag.de/2009/so/hddpass-testscript.sh 
sh hddpass-testscript.sh 

Par conséquent, c'est relativement facile. Comme je l'ai découvert, ext2 (le système de fichiers que j'ai utilisé) écrase les fichiers supprimés. Cependant, je suis sûr que certains systèmes de fichiers ne le font pas. Idem pour le fichier d'échange.

+0

Cela me dirait que j'ai un problème (et c'est utile). Cependant, il doit être exécuté avec la connaissance des mots de passe à rechercher. Je suis à la recherche de quelque chose d'un peu plus lourd et cela réglera le problème. – BCS

1
Quelle est la fréquence avec laquelle les formats de fichiers contiennent des données non initialisées?

Moins et moins commun, j'aurais pensé. Le "délinquant" classique est d'anciennes versions d'applications MS Office qui (essentiellement) ont fait un vidage de la mémoire sur le disque comme son format "quicksave". Pas de sérialisation, pas de sélection de ce qui doit être sauvegardé et un allocateur de mémoire qui ne met pas à zéro les pages mémoire nouvellement allouées. Cela conduit non seulement à des choses juteuses des versions précédentes du document (de sorte que l'utilisateur pourrait utiliser annuler), mais aussi des extraits de juteux d'autres applications.

Comment serait-il difficile d'écrire?

Quelque chose qui efface les blocs de disque non alloués ne devrait pas être si difficile. Il doit fonctionner soit en mode déconnecté, soit en tant que module noyau, afin de ne pas interférer avec les opérations normales du système de fichiers, mais la plupart des systèmes de fichiers ont une structure "allouée"/"non allouée" assez simple. analyser. Le swap est plus difficile, mais tant que vous ne l'avez pas autorisé à démarrer (ou à arrêter), ce n'est pas trop compliqué. Effacer le bloc de queue est plus délicat, certainement pas quelque chose que je voudrais essayer de faire en ligne, mais il ne devrait pas être trop difficile de le faire fonctionner pour le nettoyage hors ligne.

Dans quelle mesure un tel programme serait-il pratique?

Dépend de votre modèle de menace, vraiment. Je dirais que d'un côté, cela ne vous donnerait pas grand-chose, mais à l'autre extrémité, c'est une aide certaine pour garder l'information entre de mauvaises mains. Mais je ne peux pas donner une réponse rapide et difficile,

+0

Je pensais à un modèle hors ligne comme un CD Live Linux spécialisé. Boot un CD et attendez qu'il se termine. – BCS

1

Eh bien, si j'allais coder pour un CD de démarrage, je ferais quelque chose comme ceci:

  1. fichier est de 101 octets mais prend un cluster de 4096 octets.
  2. Copiez le fichier "A" à "B" dont les zéros sont ajoutés à la fin.
  3. Supprimer "A" et écraser son cluster (maintenant inutilisé).
  4. Créer à nouveau "A" et utiliser le contenu de "B" sans la queue (rappelez-vous la longueur).
  5. Supprimer "B" et l'écraser.

Pas très efficace, et aurait besoin d'un tweak pour vous assurer que vous n'essayez pas de copier les premiers (et donc complet) des clusters dans un fichier. Sinon, vous risquez de connaître des lenteurs et des échecs s'il n'y a pas assez d'espace libre.

Il existe des outils qui font cela efficacement qui sont open source?

Questions connexes