Protection des fichiers avec la structure cryptographique (tâches)

Cette section décrit la génération des clés symétriques, la création des sommes de contrôle pour l'intégrité des fichiers et la protection des fichiers contre les risques d'écoute informatique. Les commandes de cette section peuvent être exécutées par des utilisateurs standard. Les développeurs peuvent écrire des scripts qui utilisent ces commandes.

Génération d'une clé symétrique à l'aide de la commande `dd`

Une clé est nécessaire pour chiffrer les fichiers et générer le MAC d'un fichier. La clé doit provenir d'un pool de nombres aléatoires.

Si votre site possède un générateur de nombres aléatoires, utilisez-le. Vous pouvez également utiliser la commande dd avec le périphérique /dev/urandom d'Oracle Solaris en entrée. Pour plus d'informations, reportez-vous à la page de manuel dd(1M).

Déterminez la longueur de clé requise par votre algorithme.

Répertoriez les algorithmes disponibles.

% encrypt -l
Algorithm       Keysize:  Min   Max (bits)
------------------------------------------
aes                       128   128
arcfour                     8   128
des                        64    64
3des                      192   192

% mac -l
Algorithm       Keysize:  Min   Max (bits)
------------------------------------------
des_mac                    64    64
sha1_hmac                   8   512
md5_hmac                    8   512
sha256_hmac                 8   512
sha384_hmac                 8  1024
sha512_hmac                 8  1024

Déterminez la longueur de clé en octets à transmettre à la commande dd.
Divisez les tailles de clé minimale et maximale par 8. Lorsque les tailles de clé minimale et maximale sont différentes, des tailles de clé intermédiaire sont possibles. Par exemple, la valeur 8, 16 ou 64 peut être transmise à la commande dd pour les fonctions sha1_hmac et md5_hmac.

Générez la clé symétrique.
```
% dd if=/dev/urandom of=keyfile bs=n count=n
```
if=file

Fichier d'entrée. Pour une clé aléatoire, utilisez le fichier /dev/urandom.

of=keyfile

Fichier de sortie contenant la clé générée.

bs=n

Taille de clé en octets. Pour obtenir la longueur en octets, divisez la longueur de clé en bits par 8.

count=n

Nombre de blocs d'entrée. Le nombre pour n doit être 1.
Stockez votre clé dans un répertoire protégé.
Le fichier de clés ne doit être lisible que par l'utilisateur.
```
% chmod 400 keyfile
```

Exemple 14-1 Création d'une clé pour l'algorithme AES

Dans l'exemple suivant, une clé secrète pour l'algorithme AES est créée. La clé est également stockée pour un déchiffrement ultérieur. Les mécanismes AES utilisent une clé de 128 bits. La clé est exprimée en tant que clé de 16 octets dans la commande dd.

% ls -al ~/keyf
drwx------   2 jdoe  staff        512 May 3 11:32 ./
% dd if=/dev/urandom of=$HOME/keyf/05.07.aes16 bs=16 count=1
% chmod 400 ~/keyf/05.07.aes16

Exemple 14-2 Création d'une clé pour l'algorithme DES

Dans l'exemple suivant, une clé secrète pour l'algorithme DES est créée. La clé est également stockée pour un déchiffrement ultérieur. Les mécanismes DES utilisent une clé de 64 bits. La clé est exprimée en tant que clé de 8 octets dans la commande dd.

% dd if=/dev/urandom of=$HOME/keyf/05.07.des8 bs=8 count=1
% chmod 400 ~/keyf/05.07.des8

Exemple 14-3 Création d'une clé pour l'algorithme 3DES

Dans l'exemple suivant, une clé secrète pour l'algorithme 3DES est créée. La clé est également stockée pour un déchiffrement ultérieur. Les mécanismes 3DES utilisent une clé de 192 bits. La clé est exprimée en tant que clé de 24 octets dans la commande dd.

% dd if=/dev/urandom of=$HOME/keyf/05.07.3des.24 bs=24 count=1
% chmod 400 ~/keyf/05.07.3des.24

Exemple 14-4 Création d'une clé pour l'algorithme MD5

Dans l'exemple suivant, une clé secrète pour l'algorithme MD5 est créée. La clé est également stockée pour un déchiffrement ultérieur. La clé est exprimée en tant que clé de 64 octets dans la commande dd.

% dd if=/dev/urandom of=$HOME/keyf/05.07.mack64 bs=64 count=1
% chmod 400 ~/keyf/05.07.mack64

Génération d'une clé symétrique à l'aide de la commande `pktool`

Certaines applications exigent une clé symétrique pour le chiffrement et le déchiffrement des communications. Dans cette procédure, vous créez une clé symétrique et la stockez.

Si votre site dispose d'un générateur de nombres aléatoires, vous pouvez l'utiliser pour créer un nombre aléatoire pour la clé. Cette procédure n'utilise pas le générateur de nombres aléatoires de votre site Web.
Vous pouvez également utiliser la commande dd avec le périphérique /dev/urandom d'Oracle Solaris en entrée. La commande dd ne stocke pas la clé. Pour plus d'informations sur cette procédure, reportez-vous à la section Génération d'une clé symétrique à l'aide de la commande dd.

(Facultatif) Si vous prévoyez d'utiliser un keystore, créez-le.
- Pour créer et initialiser un keystore PKCS #11, reportez-vous à la section Procédure de génération d'une phrase de passe à l'aide de la commande pktool setpin..
- Pour créer et initialiser une base de données NSS, reportez-vous à l'Exemple 15-5.
Générez un nombre aléatoire pour l'utiliser comme clé symétrique.
Choisissez l'une des méthodes suivantes.
- Générez une clé et stockez-la dans un fichier.
  L'avantage d'une clé stockée dans un fichier est que vous pouvez extraire la clé de ce fichier pour l'utiliser dans le fichier de clés d'une application, tel que le fichier /etc/inet/secret/ipseckeys ou IPsec.
```
% pktool genkey keystore=file outkey=key-fn \ 
[keytype=specific-symmetric-algorithm] [keylen=size-in-bits] \
[dir=directory] [print=n]
```
  keystore
  
  La valeur file spécifie le type de fichier dans l'emplacement de stockage de la clé.
  
  outkey=key-fn
  
  Nom de fichier lorsque keystore=file.
  
  keytype=specific-symmetric-algorithm
  
  Pour un algorithme particulier, spécifiez aes, arcfour, des ou 3des.
  
  keylen=size-in-bits
  
  Longueur de la clé en bits. Le nombre doit être divisible par 8. Ne spécifiez rien pour des ou 3des.
  
  dir=directory
  
  Chemin d'accès au répertoire de key-fn. Par défaut, directory est le répertoire courant.
  
  print=n
  
  Imprime la clé de la fenêtre de terminal. Par défaut, la valeur de print est n.
- Générez une clé et stockez-la dans un keystore PKCS #11.
  L'avantage du keystore PKCS #11 est que vous pouvez extraire la clé par son étiquette. Cette méthode est utile pour les clés qui chiffrent et déchiffrent des fichiers. Vous devez effectuer l'Étape 1 avant d'utiliser cette méthode.
```
% pktool genkey label=key-label \ 
[keytype=specific-symmetric-algorithm] [keylen=size-in-bits] \
[token=token] [sensitive=n] [extractable=y] [print=n]
```
  label=key-label
  
  Étiquette spécifiée par l'utilisateur pour la clé. La clé peut être récupérée à partir du keystore par son étiquette.
  
  keytype=specific-symmetric-algorithm
  
  Pour un algorithme particulier, spécifiez aes, arcfour, des ou 3des.
  
  keylen=size-in-bits
  
  Longueur de la clé en bits. Le nombre doit être divisible par 8. Ne spécifiez rien pour des ou 3des.
  
  token=token
  
  Nom du jeton. Par défaut, le jeton est Sun Software PKCS#11 softtoken.
  
  sensitive=n
  
  Détermine la sensibilité de la clé. Lorsque la valeur est y, la clé ne peut pas être imprimée à l'aide de l'argument print=y. Par défaut, la valeur de sensitive est n.
  
  extractable=y
  
  Indique que la clé peut être extraite du keystore. Spécifiez n afin d'empêcher l'extraction de la clé.
  
  print=n
  
  Imprime la clé de la fenêtre de terminal. Par défaut, la valeur de print est n.
- Générez une clé et stockez-la dans un keystore NSS.
  Vous devez effectuer l'Étape 1 avant d'utiliser cette méthode.
```
% pktool keystore=nss genkey label=key-label \ 
[keytype=[keytype=specific-symmetric-algorithm] [keylen=size-in-bits] [token=token] \
[dir=directory-path] [prefix=database-prefix]
```
  keystore
  
  La valeur nss spécifie le type NSS de l'emplacement de stockage de la clé.
  
  label=key-label
  
  Étiquette spécifiée par l'utilisateur pour la clé. La clé peut être récupérée à partir du keystore par son étiquette.
  
  keytype=specific-symmetric-algorithm
  
  Pour un algorithme particulier, spécifiez aes, arcfour, des ou 3des.
  
  keylen=size-in-bits
  
  Longueur de la clé en bits. Le nombre doit être divisible par 8. Ne spécifiez rien pour des ou 3des.
  
  token=token
  
  Nom du jeton. Par défaut, le jeton est le jeton interne NSS.
  
  dir=directory
  
  Chemin d'accès au répertoire de la base de données NSS. Par défaut, directory est le répertoire courant.
  
  prefix=directory
  
  Préfixe de la base de données NSS. Par défaut, le champ de préfixe est vide.
  
  print=n
  
  Imprime la clé de la fenêtre de terminal. Par défaut, la valeur de print est n.
(Facultatif) Vérifiez que la clé existe.
Utilisez l'une des commandes suivantes, en fonction de l'endroit où vous avez stocké la clé.
- Vérifiez la clé dans le fichier key-fn.
```
% pktool list keystore=file objtype=key infile=key-fn
Found n keys.
Key #1 - keytype:location (keylen)
```
- Vérifiez la clé dans le keystore PKCS #11 ou NSS.
```
$ pktool list objtype=key
Enter PIN for keystore:
Found n keys.
Key #1 - keytype:location (keylen)
```

Exemple 14-5 Création d'une clé DES à l'aide de la commande pktool

Dans l'exemple suivant, une clé secrète pour l'algorithme DES est créée. La clé est stockée dans un fichier local pour un déchiffrement ultérieur. La commande protège le fichier avec 400 autorisations. Si la clé est créée, l'option print=y affiche la clé générée dans la fenêtre de terminal.

Les mécanismes DES utilisent une clé de 64 bits. L'utilisateur propriétaire du fichier de clés récupère la clé à l'aide de la commande od.

% pktool genkey keystore=file outkey=64bit.file1 keytype=des print=y
        Key Value ="a3237b2c0a8ff9b3"
% od -x 64bit.file1
0000000 a323 7b2c 0a8f f9b3

Procédure de calcul d'une synthèse d'un fichier

Lorsque vous calculez la synthèse d'un fichier, vous pouvez vérifier que le fichier n'a pas été altéré en comparant les résultats de la synthèse. Une synthèse n'altère pas le fichier d'origine.

Répertoriez les algorithmes de synthèse disponibles.
```
% digest -l
md5
sha1
sha256
sha384
sha512
```
Calculez la synthèse du fichier et enregistrez la liste des synthèses.
Fournissez un algorithme avec la commande digest.
```
% digest -v -a algorithm input-file > digest-listing
```
-v
Affiche la sortie au format suivant :
```
algorithm (input-file) = digest
```
-a algorithm

Algorithme à utiliser pour calculer une synthèse du fichier. Saisissez l'algorithme lorsqu'il s'affiche dans la sortie de l'Étape 1.

input-file

Fichier d'entrée pour la commande digest.

digest-listing

Fichier de sortie pour la commande digest.

Exemple 14-6 Calcul d'une synthèse avec le mécanisme MD5

Dans l'exemple suivant, la commande digest utilise le mécanisme MD5 pour calculer la synthèse pour une pièce jointe d'un e-mail.

% digest -v -a md5 email.attach >> $HOME/digest.emails.05.07
% cat ~/digest.emails.05.07
md5 (email.attach) = 85c0a53d1a5cc71ea34d9ee7b1b28b01

Lorsque l'option -v n'est pas utilisée, la synthèse est enregistrée sans informations complémentaires :

% digest -a md5 email.attach >> $HOME/digest.emails.05.07
% cat ~/digest.emails.05.07
85c0a53d1a5cc71ea34d9ee7b1b28b01

Exemple 14-7 Calcul d'une synthèse avec le mécanisme SHA1

Dans l'exemple suivant, la commande digest utilise le mécanisme SHA1 pour fournir une liste des répertoires. Les résultats sont placés dans un fichier.

% digest -v -a sha1 docs/* > $HOME/digest.docs.legal.05.07
% more ~/digest.docs.legal.05.07
sha1 (docs/legal1) = 1df50e8ad219e34f0b911e097b7b588e31f9b435
sha1 (docs/legal2) = 68efa5a636291bde8f33e046eb33508c94842c38
sha1 (docs/legal3) = 085d991238d61bd0cfa2946c183be8e32cccf6c9
sha1 (docs/legal4) = f3085eae7e2c8d008816564fdf28027d10e1d983

Calcul du code MAC d'un fichier

Un code d'authentification des messages, ou MAC, calcule la synthèse pour le fichier et utilise une clé secrète pour protéger davantage cette synthèse. Un code MAC n'altère pas le fichier d'origine.

Répertoriez les mécanismes disponibles.

% mac -l
Algorithm       Keysize:  Min   Max
-----------------------------------
des_mac                    64    64
sha1_hmac                   8   512
md5_hmac                    8   512
sha256_hmac                 8   512
sha384_hmac                 8  1024
sha512_hmac                 8  1024

Générez une clé symétrique de la longueur appropriée.
Deux options s'offrent à vous : Vous pouvez fournir une phrase de passe à partir de laquelle une clé sera générée. Ou vous pouvez fournir une clé.
- Si vous fournissez une phrase de passe, vous devez la stocker ou la mémoriser. Si vous la stockez en ligne, le fichier de la phrase de passe ne doit être lisible que par vous.
- Si vous fournissez une clé, elle doit avoir la taille correcte pour le mécanisme. Pour plus d'informations sur cette procédure, reportez-vous à la section Génération d'une clé symétrique à l'aide de la commande dd.
Créez un MAC pour un fichier.
Fournissez une clé et utilisez un algorithme de clé symétrique avec la commande mac.
```
% mac -v -a algorithm [ -k keyfile ] input-file
```
-v
Affiche la sortie au format suivant :
```
algorithm (input-file) = mac
```
-a algorithm

Algorithme à utiliser pour calculer le code MAC. Saisissez l'algorithme lorsqu'il s'affiche dans la sortie de la commande mac -l.

-k keyfile

Fichier contenant une clé de longueur spécifiée par algorithme.

input-file

Fichier d'entrée pour le MAC.

Exemple 14-8 Calcul d'un MAC avec DES_MAC et une phrase de passe

Dans l'exemple suivant, la pièce jointe d'e-mail est authentifiée avec le mécanisme DES_MAC et une clé dérivée d'une phrase de passe. La liste MAC est enregistrée dans un fichier. Si la phrase de passe est stockée dans un fichier, celui-ci doit être lisible uniquement par l'utilisateur.

% mac -v -a des_mac email.attach
Enter passphrase: <Type passphrase>
des_mac (email.attach) = dd27870a
% echo "des_mac (email.attach) = dd27870a" >> ~/desmac.daily.05.07

Exemple 14-9 Calcul d'un MAC avec MD5_HMAC et un fichier de clés

Dans l'exemple suivant, la pièce jointe d'e-mail est authentifiée avec le mécanisme MD5_HMAC et une clé secrète. La liste MAC est enregistrée dans un fichier.

% mac -v -a md5_hmac -k $HOME/keyf/05.07.mack64 email.attach
md5_hmac (email.attach) = 02df6eb6c123ff25d78877eb1d55710c
% echo "md5_hmac (email.attach) = 02df6eb6c123ff25d78877eb1d55710c" \
>> ~/mac.daily.05.07

Exemple 14-10 Calcul d'un MAC avec SHA1_HMAC et un fichier de clés

Dans l'exemple suivant, le manifeste de répertoire est authentifié avec le mécanisme SHA1_HMAC et une clé secrète. Les résultats sont placés dans un fichier.

% mac -v -a sha1_hmac \
-k $HOME/keyf/05.07.mack64 docs/* > $HOME/mac.docs.legal.05.07
% more ~/mac.docs.legal.05.07
sha1_hmac (docs/legal1) = 9b31536d3b3c0c6b25d653418db8e765e17fe07a
sha1_hmac (docs/legal2) = 865af61a3002f8a457462a428cdb1a88c1b51ff5
sha1_hmac (docs/legal3) = 076c944cb2528536c9aebd3b9fbe367e07b61dc7
sha1_hmac (docs/legal4) = 7aede27602ef6e4454748cbd3821e0152e45beb4

Chiffrement et déchiffrement d'un fichier

Lorsque vous chiffrez un fichier, le fichier d'origine n'est ni supprimé, ni modifié. Le fichier de sortie est chiffré.

Pour trouver des solutions aux erreurs courantes générées par la commande encrypt, reportez-vous à la section suivant les exemples.

Créez une clé symétrique de la longueur appropriée.
Deux options s'offrent à vous. Vous pouvez fournir une phrase de passe à partir de laquelle une clé sera générée. Ou vous pouvez fournir une clé.
- Si vous fournissez une phrase de passe, vous devez stocker ou mémoriser la phrase de passe. Si vous la stockez en ligne, le fichier de la phrase de passe ne doit être lisible que par vous.
- Si vous fournissez une clé, elle doit avoir la taille correcte pour le mécanisme. Pour plus d'informations sur cette procédure, reportez-vous à la section Génération d'une clé symétrique à l'aide de la commande dd.
Chiffrez un fichier.
Fournissez une clé et utilisez un algorithme de clé symétrique avec la commande encrypt.
```
% encrypt -a algorithm  [ -k keyfile ] -i input-file -o output-file
```
-a algorithm

Algorithme à utiliser pour chiffrer le fichier. Saisissez l'algorithme lorsqu'il s'affiche dans la sortie de la commande encrypt -l.

-k keyfile

Fichier contenant une clé de longueur spécifiée par algorithme. La longueur de la clé pour chaque algorithme est répertoriée, en bits, dans la sortie de la commande encrypt -l.

-i input-file

Fichier d'entrée que vous voulez chiffrer. Ce fichier n'est pas modifié par la commande.

-o output-file

Fichier de sortie correspondant à la forme chiffrée du fichier d'entrée.

Exemple 14-11 Chiffrement et déchiffrement avec AES et une phrase de passe

Dans l'exemple suivant, un fichier est chiffré avec l'algorithme AES. La clé est générée à partir de la phrase de passe. Si la phrase de passe est stockée dans un fichier, celui-ci doit être lisible uniquement par l'utilisateur.

% encrypt -a aes -i ticket.to.ride -o ~/enc/e.ticket.to.ride
Enter passphrase: <Type passphrase>
Re-enter passphrase: Type passphrase again

Le fichier d'entrée, ticket.to.ride, existe toujours sous sa forme d'origine.

Pour déchiffrer le fichier de sortie, l'utilisateur utilise la même phrase de passe et le même mécanisme de chiffrement que ceux utilisés pour le chiffrement du fichier.

% decrypt -a aes -i ~/enc/e.ticket.to.ride -o ~/d.ticket.to.ride
Enter passphrase: <Type passphrase>

Exemple 14-12 Chiffrement et déchiffrement avec AES et un fichier de clés

Dans l'exemple suivant, un fichier est chiffré avec l'algorithme AES. Les mécanismes AES utilisent une clé de 128 bits, ou 16 octets.

% encrypt -a aes -k ~/keyf/05.07.aes16 \
-i ticket.to.ride -o ~/enc/e.ticket.to.ride

Le fichier d'entrée, ticket.to.ride, existe toujours sous sa forme d'origine.

Pour déchiffrer le fichier de sortie, l'utilisateur utilise la même clé et le même mécanisme de chiffrement que ceux utilisés pour le chiffrement.

% decrypt -a aes -k ~/keyf/05.07.aes16 \
-i ~/enc/e.ticket.to.ride -o ~/d.ticket.to.ride

Exemple 14-13 Chiffrement et déchiffrement avec ARCFOUR et un fichier de clés

Dans l'exemple suivant, un fichier est chiffré avec l'algorithme ARCFOUR. L'algorithme ARCFOUR accepte une clé de 8 bits (1 octet), 64 bits (8 octets) ou 128 bits (16 octets).

% encrypt -a arcfour -i personal.txt \
-k ~/keyf/05.07.rc4.8 -o ~/enc/e.personal.txt

Pour déchiffrer le fichier de sortie, l'utilisateur utilise la même clé et le même mécanisme de chiffrement que ceux utilisés pour le chiffrement.

% decrypt -a arcfour -i ~/enc/e.personal.txt \
-k ~/keyf/05.07.rc4.8 -o ~/personal.txt

Exemple 14-14 Chiffrement et déchiffrement avec 3DES et un fichier de clés

Dans l'exemple suivant, un fichier est chiffré avec l'algorithme 3DES. L'algorithme 3DES requiert une clé de 192 bits, ou 24 octets.

% encrypt -a 3des -k ~/keyf/05.07.des24 \
-i ~/personal2.txt -o ~/enc/e.personal2.txt

Pour déchiffrer le fichier de sortie, l'utilisateur utilise la même clé et le même mécanisme de chiffrement que ceux utilisés pour le chiffrement.

% decrypt -a 3des -k ~/keyf/05.07.des24 \
-i ~/enc/e.personal2.txt -o ~/personal2.txt

Erreurs fréquentes

Les messages suivants indiquent que la clé que vous avez fournie à la commande encrypt n'est pas autorisée par l'algorithme utilisé.

encrypt: unable to create key for crypto operation: CKR_ATTRIBUTE_VALUE_INVALID
encrypt: failed to initialize crypto operation: CKR_KEY_SIZE_RANGE

Si vous transmettez une clé ne répondant pas aux exigences de l'algorithme, vous devez fournir une meilleure clé.

La première option consiste à utiliser une phrase de passe. La structure fournit ensuite une clé qui remplit les conditions requises.
La deuxième option consiste à transmettre une taille de clé acceptée par l'algorithme. Par exemple, l'algorithme DES requiert une clé de 64 bits. L'algorithme 3DES requiert une clé de 192 bits.

Ignorer les liens de navigation
Quitter l'aperu
	Guide d'administration système : Services de sécurité