La structure de la commande a la forme générale suivante :

dd if=<source> of=<cible> bs=<taille des blocs> skip= seek= conv=<conversion>

source représente les données à copier, cible est l'endroit où les copier.

bs est habituellement une puissance de 2, pas inférieure à 512, représentant un nombre d'octets (par exemple : 512, 1024, 2048, 4096, 8192, 16384, mais cela peut être tout nombre raisonnable).

Attention ! Si vous inversez la source et la cible, vous pouvez perdre beaucoup de données. Cette caractéristique a inspiré le surnom de dd : le Destructeur de Données !!

Comment choisir bs (block size = taille des blocs) ? Un paramètre bs= correctement choisi accroitra significativement la vitesse d'exécution.

Sur du matériel moderne (moins de 5 ans) bs=4096 est un bon pari.

On peut aussi avoir : bs=16065b qui peut être meilleur. bs=32130b encore meilleur. Ces deux dernières tailles de bloc correspondent à des nombres entiers de cylindres. Un cylindre en mode LBA = 255 têtes * 63 secteurs par piste = 16065 secteurs = 16065 * 512 octets = 16065b. Le b signifie * 512 (512 octets étant la taille d'un secteur). 32130b représente un bloc de deux cylindres. Lorsque vous utilisez des tailles de blocs représentant des nombres entiers de cylindres, vous n'avez jamais à vous soucier de la copie de la dernière fraction de bloc car les partitions sont toujours faites d'un nombre entier de cylindres. Les partitions ne peuvent pas contenir de cylindres partiels. Un cylindre comprend 8 225 280 octets.

Les blocs et les octets peuvent être suivis par les suffixes multiplicateurs suivants (les valeurs numériques représentent des nombres d'octets) : c 1, w 2, b 512, kB 1000, k 1024, MB 1000*1000, M 1024*1024, GB 1000*1000*1000, G 1024*1024*1024

Ainsi :

dd if=/dev/sda of=/dev/sdb bs=1GB

utilisera des blocs de taille un gigaoctet.

bs=4b donnera à dd un bloc de taille de 4 secteurs de disque. 1 secteur=512 octets.

bs=4k indiquera à dd d'utiliser un bloc de taille 4 kiloctets. J'ai trouvé que bs=4k est le plus rapide pour la copie de disques sur une machine moderne.

dd if=/dev/sda2 of=/dev/sdb2 bs=4096 conv=notrunc,noerror

sda2 et sdb2 sont des partitions. Vous voulez copier sda2 dans sdb2. Si sdb2 n'existe pas, dd commencera au début du disque et le créera.

Faites attention à l'ordre de if et of. Vous pouvez écrire un disque vierge sur un disque utilisé si vous êtes désordonné.

dd if=/dev/sda of=/dev/sdb conv=notrunc,noerror

Dans cet exemple, sda est la source. sdb est la cible. N'intervertissez pas les sources et cibles ainsi désignées. Étonnamment, beaucoup de personnes le font !

• notrunc signifie « ne pas tronquer le fichier en sortie » (voir notrunc pour plus de détails).
• noerror signifie de continuer en cas d'erreur. Normalement, dd s'arrête en cas d'erreur. Si vous vous interrogez sur un disque dur, si vous vous demandez s'il fonctionne ou pas, vous pouvez tenter de l'utiliser, à titre de test, comme lecteur source de la commande dd. Vous devriez obtenir une erreur s'il ne fonctionne pas. Les lecteurs cibles en revanche doivent être vraiment en très mauvais état pour provoquer une erreur due à dd.

La seule différence entre une grande partition et une petite partition, hormis la taille, est la table de partition. Si vous copiez sda vers sdb, un disque entier avec une seule partition, sdb étant plus petit que sda, alors vous devez faire :

dd if=/dev/sda skip=2 of=/dev/sdb seek=2 bs=4k conv=noerror

Skip (voir ligne de commande précédente) saute des blocs d'entrée au début du média (sda). Seek saute autant de blocs sur le média de sortie avant d'écrire (sdb). en agissant ainsi, vous laissez intacts les 4 premiers Ko sur chaque disque : vous ne voulez pas dire à un lecteur qu'il est plus gros qu'il n'est en réalité en écrivant une table de partition depuis un lecteur plus gros vers un lecteur plus petit.

Les 63 premiers secteurs d'un lecteur sont vides, sauf le secteur 1, le MBR. Si vous copiez une partition plus petite vers une plus grande, la plus grande partition affichera sa taille correcte avec :

fdisk -l

Mais pas avec :

df -h

Cela parce que fdisk lit la table de partition et df lit l'info de format.

Si vous dd une plus petite partition vers une plus grande, la plus grande sera maintenant formatée identique à la plus petite et il n'y aura aucune place libre sur le lecteur. La façon de régler cela est de construire un fichier image de la partition :

dd if=plus_petite__partition of=/home/sam/plus_petite_partition.img

Montez l'image comme un lecteur en utilisant :

mount -o loop /home/sam/plus_petite_partition.img /mnt/directory
cd /mnt/directory
cp -r * /mnt/plus_grande_partition_deja_partitionée_et_formatée_a_la_taille_desiree

La commande cp a un commutateur -r pour la copie récursive.

Une autre technique fait usage de la commande resize2fs. Cette commande va agrandir le système de fichiers à la taille de la partition :

• 1 - Ne travailler que sur des partitions démontées

• 2 - Ouvrir une console root (ou travailler depuis un live CD) et taper

e2fsck -f /dev/xx

où xx est évidemment le nom de la partition concernée, afin de vérifier l'intégrité du système de fichiers. Pour info, l'option -f force la vérification, sans se contenter d'un simple “check” du journal. De toutes façons, si vous ne ne faites pas, la commande suivante vous l'exigera avant de s'exécuter.

• 3 - agrandir le système de fichiers :

resize2fs /dev/xx

Maintenant, si vous copiez sda3 vers sda2 (plus petit que sda3), c'est différent. Ce que vous désirez faire est alors cela :

dd if=/dev/sda3 of=/dev/sda2 bs=4096 conv=noerror

La toute fin d'un lecteur contient généralement des zéros. Ainsi, si vous avez de la place dans sda2 pour les données de sda3, les zéros de sda3 sont tronqués (les blocs contenant uniquement des zéros sont remplacés par des chaines de cinq caractères astérisque) et c'est OK.

Dans ce cas, il ne faut pas utiliser conv=notrunc, qui copierait tous les blocs contenant uniquement des zéros tels quels, sans les tronquer.

La commande :

dd if=/dev/hdc of=/home/sam/moncd.iso bs=2048 conv=notrunc

Les secteurs de CD ont une taille de 2 048 octets, vous faites donc ainsi une copie secteur par secteur. Le résultat sera un fichier image du CD sur le disque dur. Vous pouvez faire un chmod a+rwx moncd.iso pour permettre d'écrire dans l'image.

Vous pouvez monter l'image avec :

mkdir /mnt/moncd

écrire cette ligne dans le fstab :

/home/sam/moncd.iso   /mnt/moncd  iso9660 rw,user,noauto 0 0

Enregistrer le fstab, et réaliser le montage :

mount -o loop /mnt/moncd

Le système de fichiers est maintenant visible avec ses fichiers et dossiers dans le répertoire /mnt/moncd. Vous pouvez éditer l'image autant que vous le souhaitez, le nouveau fichier sera /home/sam/moncd.iso.

dd ne peut pas écrire dans un CD. Pour cela vous devez avoir recours à un logiciel de gravure ou à la commande cdrdao.

Si vous êtes inquiet au sujet d'espions avec des détecteurs supra-conducteurs à interférences quantiques, vous pouvez toujours ajouter une boucle for pour effacer le disque d'un niveau de sécurité gouvernemental : copier coller les deux lignes suivantes dans un éditeur de texte :

#!/bin/bash
for n in `seq 7`; do dd if=/dev/urandom of=/dev/sda bs=8b conv=notrunc; done

Maintenant vous avez un script shell qui exécute sept passes d'inscriptions aléatoires de caractères sur tout le disque.

Faites :

chmod a+x <fichierscript>

pour le rendre exécutable.

Pour créer une clé USB bootable: télécharger les 50 Mo de la distribution Debian ici

http://sourceforge.net/projects/insert/

Connectez la clé dans le port USB. Faites :

dmesg | tail

Regardez où est le nouveau lecteur, sdb ou quelque chose de similaire (sous une Mandriva il suffira de regarder, dans la fenêtre qui s'ouvre après insertion de la clé, le contenu de la rubrique Emplacement).

Faites :

dd if=/home/sam/insert.iso of=/dev/sdb ibs=4b obs=1b conv=notrunc,noerror

Maintenant modifiez le BIOS pour booter sur l'USB, connectez la clé et bootez la machine.

dd if=/dev/sda of=/home/sam/MBR.image bs=446 count=1

Ceci copiera les 446 premiers octets du disque dur dans un fichier.

Attention ! Si vous ne l'avez pas encore deviné, intervertir les arguments de if= et of=, dans la ligne de commande de dd intervertit le sens de l'écriture !

sur deux disque complètement identiques. Avant de faire quelque chose qui pourrait être dangereux, démarrer à partir dd'un live CD et lancer :

dcfldd   if=/dev/sda    of=/dev/sdb/  bs=4096  conv=notrunc,noerror

(vous pouvez utiliser dd à la place de dcfldd) on copie ici ainsi le lecteur système de travail courant sur le lecteur sdb. Si l'installation est cassée sur sda, démarrer à partir dd'un live CD et lancer :

dcfldd if=/dev/sdb  of=/dev/sda  bs =4096 conv=notrunc,noerror

Notez bien que bs=4096 marche plus rapidement pour des machines ayant au moins 128Mo de RAM. dd utilise pas mal de tampons (buffers). Avec bs=4096, sur des machines modernes, la vitesse de transfert optimal pour les disques durs est atteinte.

Vous devrez booter depuis un CD pour cela, http://www.efense.com/helix est un bon CD de boot (mais il y en a bien d'autres !). L'environnement de boot helix contient la version DoD de dd appelée dcfldd. Elle fonctionne de la même manière que dd, mais possède une barre de progression.

dcfldd if=/dev/zero of=/dev/sda conv=notrunc

Ceci est très utile pour rendre le lecteur presque comme neuf, cela permet de le débarrasser des virus, des chevaux de Troie etc… La plupart des lecteurs ont 0x0000ffh écrit en usine dans chaque secteur.

C'est à dire rendre impossible la récupération des fichiers effacés.

dd if=/dev/urandom > fichieroccupanttoutlespacelibre

Quand dd dit : « plus d'espace libre sur le périphérique », tout l'espace disponible a été réécrit avec des caractères aléatoires. Ensuite, effacez le gros fichier avec :

rm

Nota Bene : Dans les commandes qui suivent, dcfldd peut être remplacé par dd (dcfldd est un programme qui ajoute aux fonctionnalités de dd l'affichage d'une barre de progression).

Je place deux disques identiques dans chacune de mes machines. Avant de faire toute chose pouvant être désastreuse, je fais :

dcfldd if=/dev/sda of=/dev/sdb bs=4096 conv=notrunc,noerror

et copie mon disque de travail en cours sda vers le disque sdb. Si je détruis l'installation sur sda, je n'ai qu'à booter avec le CD helix et :

dcfldd if=/dev/sdb of=/dev/sda bs=4096 conv=notrunc,noerror

et je retrouve chaque chose exactement comme avant qu'un truc idiot que j'essayais de faire ne fonctionne pas. Vous pouvez vraiment, vraiment apprendre Linux de cette manière, car vous ne pouvez absolument pas casser ce dont vous avez une copie exacte. Vous pourriez aussi envisager de faire une partition root séparée de /home, et rendre /home assez grand pour contenir la partition root, Vous pouvez alors faire :

dd if=/dev/sda2 (root) of=/home/sam/root.img bs=4096 conv=notrunc,noerror

pour réaliser un backup de root puis :

dd if=/home/sam/root.img of=/dev/sda2 (root) bs=4096 conv=notrunc,noerror

pour remettre l'image de root dans la partition root si vous avez semé la pagaille et ne pouvez plus lancer le serveur X, ou éditer /etc/fstab, et ne trouvez pas ce que vous avez fait de mal. Cela ne prend que quelques minutes pour restaurer une partition root de 15 Go depuis un fichier image.

dd if=/dev/urandom of=/home/sam/mes_octets_aleatoires bs=1 count=100

Ici urandom est un générateur Linux de nombres aléatoires. mes_octets_aleatoires est un fichier. La taille de bloc est égale à 1 octet (bs=1) et on envoie 100 blocs, donc au total 100 octets (count=100).

gpg a besoin d'une graine (seed) aléatoire pour créer des clés. Créer un fichier de, disons, 4096 octets aléatoires, qu'on peut passer à gpg, permettra d'avoir une graine vraiment aléatoire.

/dev/random génère autant de bits aléatoires que la réserve entropique peut en contenir. Cela produit des valeurs hautement aléatoires pour des clés de cryptographie. Si davantage d'octets aléatoires sont nécessaires, le processus s'arrête jusqu'à ce que la réserve entropique soit remplie de nouveau (bouger la souris aide). /dev/urandom n'a pas cette restriction. Si l'utilisateur exige plus de bits que de présents à ce moment dans la réserve entropique, ils sont produits en utilisant un générateur de nombres pseudo-aléatoires.

d'abord, faire :

ls -l

pour trouver la taille du fichier :

ls -l unfichier
-rw------- ... 3769 Nov 2 13:41 <filename>

dans ce cas elle est de 3769.

dd if=/dev/urandom of=unfichier bs=3769 count=1 conv=notrunc

Ceci écrira des caractères aléatoires par dessus la totalité du fichier .

Ainsi même quelqu'un qui inspectera le contenu du disque avec dd ne retrouvera pas son contenu.

Pour créer un fichier de 50 Mo prenant 0 octets sur le disque lancer la commande :

dd if=/dev/null of=file bs=1M seek=50

Cette commande peut être utile pour créer un gros fichier pour tester un transfert FTP.

Attention!! Ne pas copier une partition sur la même partition.

dd if=/dev/sdb2 of=/home/sam/partition.image bs=4096 conv=notrunc,noerror

Cela créera un fichier qui est l'exacte réplique de la partition sdb2. Vous pouvez remplacer par hdb, sda, hda ou toute autre désignation de votre disque. Ou :

dd if=/dev/sdb2 ibs=4096 | gzip > partition.image.gz conv=noerror

Crée une archive gzip de la partition complète. Pour la restauration, utiliser :

| gunzip >

Pour bzip2 (plus lent, plus petit), remplacer par bzip2 et bunzip2, et nommer le fichier

.bz2

dd if=/home/sam/partition.image of=/dev/sdb2 bs=4096 conv=notrunc,noerror

De cette façon, vous pouvez avoir un grand disque dur et le partitionner, ainsi vous pouvez sauvegarder votre partition root. Si vous semez la pagaille dans votre partition root, vous n'avez qu'à booter depuis le CD helix (ou un live CD quelconque) et restaurer l'image.

dd if=filename of=filename conv=ucase

Le noyau Linux crée généralement nombre de disques virtuels que vous pouvez transformer en lecteurs virtuels. Vous devez d'abord remplir le lecteur avec des zéros comme ceci :

dd if=/dev/zero of=/dev/ram7 bs=1k count=16384

ce qui crée un disque virtuel de 16 Mo plein de zéros…

Ensuite :

mkfs.ext3 -m0 /dev/ram7 4096

place un système de fichiers sur le disque virtuel le transformant en lecteur virtuel.

debian:/home/sam # hdparm -t /dev/ram7
/dev/ram7: Timing buffered disk reads: 16 MB in 0.02 seconds = 913.92 MB/sec
(Débit de lecture du disque bufférisé: 16Mo en 0,02 secondes= 913,92 Mo/s)

Vous pouvez êtes tenté de ne mesurer le débit qu'une fois. Mais, en fait, il vaut mieux lancer plusieurs fois hdparm -t /dev/ram7, car hdparm est un peu difficile avec les lecteurs virtuels.

Vous pouvez monter le disque virtuel avec :

mkdir /mnt/mem 
mount   /dev/ram7 /mnt/mem

Maintenant, vous pouvez utiliser le lecteur virtuel comme un lecteur matériel. Ceci est particulièrement remarquable pour travailler sur des gros documents ou en programmation. Vous pouvez copier le gros document ou le projet de programmation sur le lecteur virtuel, lequel sur ma machine est au moins 27 fois aussi rapide que /dev/sda, et chaque fois que vous enregistrez l'énorme document, ou que vous avez besoin de compiler, c'est comme si votre machine carburait au nitrométhane. La seule chose est que le lecteur virtuel est volatile. Si vous perdez l'alimentation, ou éteignez, les données sur le lecteur virtuel sont perdues. Utilisez une machine fiable, par temps clair, si vous utilisez un lecteur virtuel.

dd if=/dev/mem of=/home/sam/mem.bin bs=1024

Le périphérique :

/dev/mem

est votre mémoire système. Vous pouvez en fait copier tout périphérique de type bloc ou caractère dans un fichier avec dd.