KeyStore Classe

Définition

[Android.Runtime.Register("java/security/KeyStore", DoNotGenerateAcw=true)]
public class KeyStore : Java.Lang.Object

[<Android.Runtime.Register("java/security/KeyStore", DoNotGenerateAcw=true)>]
type KeyStore = class
    inherit Object

Héritage

Object

JavaObject

Object

KeyStore

Attributs

RegisterAttribute

Remarques

Cette classe représente une installation de stockage pour les clés de chiffrement et les certificats.

A KeyStore gère différents types d’entrées. Chaque type d’entrée implémente l’interface KeyStore.Entry . Trois implémentations de base KeyStore.Entry sont fournies :

<ul><li><b>KeyStore.PrivateKeyEntry</b>

Ce type d’entrée contient un chiffrement PrivateKey, qui est éventuellement stocké dans un format protégé pour empêcher l’accès non autorisé. Elle est également accompagnée d’une chaîne de certificats pour la clé publique correspondante.

Les clés privées et les chaînes de certificats sont utilisées par une entité donnée pour l’authentification automatique. Les applications pour cette authentification incluent les organisations de distribution de logiciels qui signent des fichiers JAR dans le cadre de la publication et/ou du logiciel de licence.

<li><b>KeyStore.SecretKeyEntry</b>

Ce type d’entrée contient un chiffrement SecretKey, qui est éventuellement stocké dans un format protégé pour empêcher l’accès non autorisé.

<li><b>KeyStore.TrustedCertificateEntry</b>

Ce type d’entrée contient une clé Certificate publique unique appartenant à une autre partie. Il est appelé certificat approuvé , car le propriétaire du magasin de clés approuve que la clé publique dans le certificat appartient effectivement à l’identité identifiée par le sujet (propriétaire) du certificat.

Ce type d’entrée peut être utilisé pour authentifier d’autres parties. </ul>

Chaque entrée d’un magasin de clés est identifiée par une chaîne « alias ». Dans le cas de clés privées et de leurs chaînes de certificats associées, ces chaînes distinguent les différentes façons dont l’entité peut s’authentifier. Par exemple, l’entité peut s’authentifier à l’aide de différentes autorités de certification ou utiliser différents algorithmes de clé publique.

Indique si les alias respectent la casse dépend de l’implémentation. Pour éviter les problèmes, il est recommandé de ne pas utiliser d’alias dans un Magasin de clés qui diffèrent uniquement dans le cas.

Si les magasins de clés sont persistants et les mécanismes utilisés par le magasin de clés s’il est persistant, ne sont pas spécifiés ici. Cela permet d’utiliser diverses techniques pour protéger les clés sensibles (par exemple, privées ou secrètes). Les cartes à puce ou d’autres moteurs de chiffrement intégrés (SafeKeyper) sont une option et des mécanismes plus simples tels que les fichiers peuvent également être utilisés (dans divers formats).

Les méthodes courantes pour demander un objet KeyStore incluent la spécification d’un fichier de magasin de clés existant, en s’appuyant sur le type par défaut et en fournissant un type de magasin de clés spécifique.

<ul><li>Pour spécifier un fichier de magasin de clés existant :

// get keystore password
               char[] password = getPassword();

               // probe the keystore file and load the keystore entries
               KeyStore ks = KeyStore.getInstance(new File("keyStoreName"), password);

Le système sonde le fichier spécifié pour déterminer son type de magasin de clés et retourner une implémentation de magasin de clés avec ses entrées déjà chargées. Lorsque cette approche est utilisée, il n’est pas nécessaire d’appeler la méthode du magasin de #load(java.io.InputStream, char[]) load clés.

<li>Pour vous appuyer sur le type par défaut :

KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());

Le système retourne une implémentation de magasin de clés pour le type par défaut.

<li>Pour fournir un type de magasin de clés spécifique :

KeyStore ks = KeyStore.getInstance("JKS");

Le système retourne l’implémentation la plus préférée du type de magasin de clés spécifié disponible dans l’environnement. </ul>

Avant qu’un magasin de clés soit accessible, il doit être #load(java.io.InputStream, char[]) loaded.

KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());

               // get user password and file input stream
               char[] password = getPassword();

               try (FileInputStream fis = new FileInputStream("keyStoreName")) {
                   ks.load(fis, password);
               }

Pour créer un magasin de clés vide à l’aide de la méthode ci-dessus load , passez null en tant qu’argument InputStream .

Une fois le magasin de clés chargé, il est possible de lire des entrées existantes à partir du magasin de clés ou d’écrire de nouvelles entrées dans le magasin de clés :

KeyStore.ProtectionParameter protParam =
                   new KeyStore.PasswordProtection(password);

               // get my private key
               KeyStore.PrivateKeyEntry pkEntry = (KeyStore.PrivateKeyEntry)
                   ks.getEntry("privateKeyAlias", protParam);
               PrivateKey myPrivateKey = pkEntry.getPrivateKey();

               // save my secret key
               javax.crypto.SecretKey mySecretKey;
               KeyStore.SecretKeyEntry skEntry =
                   new KeyStore.SecretKeyEntry(mySecretKey);
               ks.setEntry("secretKeyAlias", skEntry, protParam);

               // store away the keystore
               try (FileOutputStream fos = new FileOutputStream("newKeyStoreName")) {
                   ks.store(fos, password);
               }

Notez que même si le même mot de passe peut être utilisé pour charger le magasin de clés, protéger l’entrée de clé privée, protéger l’entrée de clé secrète et stocker le magasin de clés (comme indiqué dans l’exemple de code ci-dessus), différents mots de passe ou d’autres paramètres de protection peuvent également être utilisés.

Android fournit les types suivants : tableKeyStorethead<>tr<>th<Algorithm>/th th<><Supported API Levels>/th<>/tr/thead<>tbody<>tr<><> td<AndroidCAStore>/td td<><14+>/td<>/tr tr<><>tr td<AndroidKeyStore>/td td<18+>/td<><>/tr tr<>class="déprécié »<><><>td BCPKCS12</td><td>1-8</td></tr tr><><>td BKS</td td><>1+</td></tr tr><><td>BouncyCastle</td td><>1+</td></tr tr><><>PKCS12</td td 1+>/td<><></tr tr tr><class="déprécié"><td>PKCS12-DEF</td><td>1-8</td></tr></tbody></table>

Ces types sont décrits dans la section KeyStore de la documentation relative au nom d’algorithme standard de l’architecture de chiffrement Java.

Ajouté dans la version 1.2.

Java documentation pour java.security.KeyStore.

Les parties de cette page sont des modifications basées sur le travail créé et partagé par Android Open Source et utilisées en fonction des termes décrits dans la Creative Commons 2.5 Attribution License.