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.

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

La structure cryptographique peut vous aider à protéger vos fichiers. La liste des tâches suivante présente les procédures permettant de dresser la liste des algorithmes disponibles et de protéger des fichiers par cryptographie.

Tâche	Description	Voir
Génération d'une clé symétrique	Génère une clé aléatoire à utiliser avec des algorithmes spécifiés par l'utilisateur.	Procédure de génération d'une clé symétrique à l'aide de la commande `dd`
Génération d'une clé symétrique	Génère une clé de la longueur définie par l'utilisateur. Stocke éventuellement la clé dans un fichier, un keystore PKCS #11 ou un keystore NSS.	Procédure de génération d'une clé symétrique à l'aide de la commande `pktool`
Calcul d'une somme de contrôle assurant l'intégrité d'un fichier.	Vérifie que l'exemplaire d'un fichier reçu par le destinataire est identique au fichier qui a été envoyé.	Procédure de calcul d'une synthèse d'un fichier
Protection d'un fichier avec un code d'authentification des messages (MAC).	Atteste au destinataire de votre message que vous en êtes l'expéditeur.	Procédure de calcul du code MAC d'un fichier
Chiffrement d'un fichier, puis déchiffrement du fichier chiffré.	Protège le contenu d'un fichier en chiffrant le fichier. Fournit les paramètres de chiffrement pour déchiffrer le fichier.	Procédure de chiffrement et déchiffrement d'un fichier

Procédure de 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.

Pour créer la clé, vous avez le choix entre trois options :

Si votre site possède un générateur de nombres aléatoires, utilisez-le.
Si vous voulez générer la clé et l'enregistrer, reportez-vous à la section Procédure de génération d'une clé symétrique à l'aide de la commande pktool.
Dans le cas contraire, utilisez cette procédure. Cette procédure requiert que vous fournissiez la taille de clé en bits. En revanche, la commande pktool détermine la taille de la clé appropriée en fonction de l'algorithme que vous indiquez.

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 12-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 12-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 12-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 12-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

Procédure de 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 en entrée. La commande dd ne stocke pas la clé. Pour plus d'informations sur cette procédure, reportez-vous à la section Procédure de 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 13-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=generic|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 une clé symétrique de n'importe quelle longueur, la valeur est generic. 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=generic|specific-symmetric-algorithm] [keylen=size-in-bits] \
[token=token] [sensitive=n] [extractable=y] [print=n]
```
  label=key-label
  
  Etiquette 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 une clé symétrique de n'importe quelle longueur, la valeur est generic. 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=generic|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
  
  Etiquette 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 une clé symétrique de n'importe quelle longueur, la valeur est generic. 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 12-5 Création d'une clé symétrique à l'aide de la commande pktool

Dans l'exemple suivant, un utilisateur crée un keystore PKCS#11 pour la première fois, puis génère une longue clé symétrique pour une application. Enfin, l'utilisateur vérifie que la clé se trouve dans le keystore.

# pktool setpin
Create new passphrase:easily-remembered-hard-to-detect-password
Re-enter new passphrase:Retype password
Passphrase changed.
% pktool genkey label=specialappkey keytype=generic keylen=1024
Enter PIN for Sun Software PKCS#11 softtoken  :Type password

% pktool list objtype=key
Enter PIN for Sun Software PKCS#11 softtoken  :Type password

Found 1 keys.
Key #1 - symmetric:  specialappkey (1024 bits)

Exemple 12-6 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

Exemple 12-7 Création d'une clé symétrique pour les associations de sécurité (SA) IPsec

Dans l'exemple suivant, l'administrateur crée manuellement les numéros de clé pour les SA IPsec et les stocke dans des fichiers. Ensuite, l'administrateur copie les clés pour le fichier /etc/inet/secret/ipseckeys et détruit les fichiers d'origine.

Tout d'abord, l'administrateur crée et affiche les clés requises par la stratégie IPsec :

# pktool genkey keystore=file outkey=ipencrin1 keytype=generic keylen=192 print=y
   Key Value ="294979e512cb8e79370dabecadc3fcbb849e78d2d6bd2049"
# pktool genkey keystore=file outkey=ipencrout1 keytype=generic keylen=192 print=y
   Key Value ="9678f80e33406c86e3d1686e50406bd0434819c20d09d204"
# pktool genkey keystore=file outkey=ipspi1 keytype=generic keylen=32 print=y
   Key Value ="acbeaa20"
# pktool genkey keystore=file outkey=ipspi2 keytype=generic keylen=32 print=y
   Key Value ="19174215"
# pktool genkey keystore=file outkey=ipsha21 keytype=generic keylen=256 print=y
   Key Value ="659c20f2d6c3f9570bcee93e96d95e2263aca4eeb3369f72c5c786af4177fe9e"
# pktool genkey keystore=file outkey=ipsha22 keytype=generic keylen=256 print=y
   Key Value ="b041975a0e1fce0503665c3966684d731fa3dbb12fcf87b0a837b2da5d82c810"

Ensuite, l'administrateur crée le fichier suivant /etc/inet/secret/ipseckeys :

##   SPI values require a leading 0x.
##   Backslashes indicate command continuation.
##
## for outbound packets on this system
add esp spi 0xacbeaa20 \
   src 192.168.1.1 dst 192.168.2.1 \
   encr_alg aes auth_alg sha256  \
   encrkey  294979e512cb8e79370dabecadc3fcbb849e78d2d6bd2049 \
   authkey  659c20f2d6c3f9570bcee93e96d95e2263aca4eeb3369f72c5c786af4177fe9e
##
## for inbound packets
add esp spi 0x19174215 \
   src 192.168.2.1 dst 192.168.1.1 \
   encr_alg aes auth_alg sha256  \
   encrkey 9678f80e33406c86e3d1686e50406bd0434819c20d09d204 \
   authkey b041975a0e1fce0503665c3966684d731fa3dbb12fcf87b0a837b2da5d82c810

Après avoir vérifié que la syntaxe du fichier ipseckeys est valide, l'administrateur détruit les fichiers clé d'origine.
```
# ipseckey -c /etc/inet/secret/ipseckeys
# rm ipencrin1 ipencrout1 ipspi1 ipspi2 ipsha21 ipsha22
```
L'administrateur copie le fichier ipseckeys au système de communication en utilisant la commande ssh ou un autre mécanisme sécurisé. Sur le système de communication, les protections sont inversées. La première entrée dans le fichier ipseckeys protège les paquets entrants, et la seconde entrée protège les paquets sortants. Aucune clé n'est générée sur le système de communication.

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 12-8 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 12-9 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

Procédure de 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 Procédure de génération d'une clé symétrique à l'aide de la commande dd. Vous pouvez également exécuter la commande pktool. Pour plus d'informations sur cette procédure et des exemples, reportez-vous à la section Procédure de génération d'une clé symétrique à l'aide de la commande pktool.
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 | -K key-label [-T token]] 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.

-K key-label

Est l'étiquette d'une clé dans le keystore PKCS #11.

-T token

Est le nom du jeton. Par défaut, le jeton est Sun Software PKCS#11 softtoken. Est utilisé uniquement lorsque l'option -K key-label est utilisée.

input-file

Fichier d'entrée pour le MAC.

Exemple 12-10 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 12-11 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 12-12 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

Exemple 12-13 Calcul d'un MAC avec SHA1_HMAC et une étiquette 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 le keystore PKCS #11 de l'utilisateur. L'utilisateur a initialement créé le keystore et le mot de passe pour le keystore à l'aide de la commande pktool setpin.

% mac -a sha1_hmac -K legaldocs0507 docs/*
Enter pin for Sun Software PKCS#11 softtoken:Type password

Pour récupérer le MAC à partir du keystore, l'utilisateur se sert des informations détaillées et fournit l'étiquette clé et le nom du répertoire qui a été authentifié.

% mac -v -a sha1_hmac -K legaldocs0507 docs/*
Enter pin for Sun Software PKCS#11 softtoken:Type password
sha1_hmac (docs/legal1) = 9b31536d3b3c0c6b25d653418db8e765e17fe07a
sha1_hmac (docs/legal2) = 865af61a3002f8a457462a428cdb1a88c1b51ff5
sha1_hmac (docs/legal3) = 076c944cb2528536c9aebd3b9fbe367e07b61dc7
sha1_hmac (docs/legal4) = 7aede27602ef6e4454748cbd3821e0152e45beb4

Procédure de 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 Procédure de génération d'une clé symétrique à l'aide de la commande dd. Vous pouvez également exécuter la commande pktool. Pour plus d'informations sur cette procédure et des exemples, reportez-vous à la section Procédure de génération d'une clé symétrique à l'aide de la commande pktool.
Chiffrez un fichier.
Fournissez une clé et utilisez un algorithme de clé symétrique avec la commande encrypt.
```
% encrypt -a algorithm [-v] \
[-k keyfile | -K key-label [-T token]] [-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.

-K key-label

Etiquette d'une clé dans le keystore PKCS #11.

-T token

Nom du jeton. Par défaut, le jeton est Sun Software PKCS#11 softtoken. Est utilisé uniquement lorsque l'option -K key-label est utilisée.

-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 12-14 Création d'une clé AES pour le chiffrement de vos fichiers

Dans l'exemple suivant, un utilisateur crée et stocke une clé AES dans keystore PKCS #11 existant pour l'utilisation lors du chiffrement et du déchiffrement. L'utilisateur peut vérifier que la clé existe et l'utiliser, mais il ne peut pas l'afficher.

% pktool genkey label=MyAESkeynumber1 keytype=aes keylen=256
Enter PIN for Sun Software PKCS#11 softtoken  :Type password

% pktool list objtype=key
Enter PIN for Sun Software PKCS#11 softtoken  :<Type password>
Found 1 key
Key #1 - Sun Software PKCS#11 softtoken: MyAESkeynumber1 (256)

Pour utiliser la clé pour chiffrer un fichier, l'utilisateur le récupère la clé par son étiquette.

% encrypt -a aes -K MyAESkeynumber1 -i encryptthisfile -o encryptedthisfile

Pour déchiffrer le encryptedthisfile, l'utilisateur récupère la clé par son étiquette.

% decrypt -a aes -K MyAESkeynumber1 -i encryptedthisfile -o sameasencryptthisfile

Exemple 12-15 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 12-16 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 12-17 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 12-18 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
	Administration d'Oracle Solaris : services de sécurité Oracle Solaris 11 Information Library (Français)