Comme le dit le titre. Je pense qu'il y a diverses choses comme le mettre dans le magasin et le passer sous forme de fichier La paire de clés est une fois encodée en Base64.
Dépendance(maven)
<dependency>
<groupId>org.bouncycastle</groupId>
<artifactId>bcprov-jdk16</artifactId>
<version>1.45</version>
</dependency>
RSAKeyPairSample.java
/**
*Exemples de création, de chiffrement et de déchiffrement RSAKeyPair
* @author ryutaro_hakozaki
*/
public class RSAKeyPairSample {
public static void main(String argv[]){
RSAKeyPairSample sample = new RSAKeyPairSample();
/**
*Créer une paire de clés
*/
String[] keyPair = sample.createKeyPairAsBase64();
System.out.println("Clé publique== " + keyPair[0]);
System.out.println("Clé privée== " + keyPair[1]);
/**
*Chiffré avec clé privée
*Puisqu'il s'agit de RSA, vous pouvez le crypter soit avec
*Dans une communication sécurisée, il est crypté avec une clé publique
*La signature électronique crypte le hachage du document avec la clé privée
*/
final String message = "Qiita est un service de partage d'informations techniques pour les programmeurs.";
byte[] encryptBytes = sample.encryptByBase64Key(message.getBytes(), keyPair[1]);
System.out.println("----------------------------------------");
System.out.println("[Plaine]");
System.out.println(message);
System.out.println("[Résultat du chiffrement]");
System.out.println(new String(encryptBytes));
/**
*Décrypter avec la clé publique
*Le déchiffrement est possible si la clé est une paire
*/
byte[] decryptBytes = sample.decryptBtBase64Key(encryptBytes, keyPair[0]);
System.out.println("[Résultat du décryptage]");
System.out.println(new String(decryptBytes));
}
/**
*Créer une paire de clés RSA
* @retourne les clés publiques et de chiffrement encodées en Base64
*/
public String[] createKeyPairAsBase64(){
String[] keyPair = new String[2];
/**
*Créer une paire de clés
*/
Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
Cipher cipher;
KeyPairGenerator generator;
try {
cipher = Cipher.getInstance("RSA/None/NoPadding", "BC");
generator = KeyPairGenerator.getInstance("RSA", "BC");
} catch (NoSuchAlgorithmException | NoSuchProviderException | NoSuchPaddingException ex) {
return keyPair;
}
SecureRandom random = new SecureRandom();
generator.initialize(2048, random);
KeyPair pair = generator.generateKeyPair();
/**
*Paire de clés encodées en Base64 et renvoyées
*/
keyPair[0] = encodeObjectAsBase64(pair.getPublic());
keyPair[1] = encodeObjectAsBase64(pair.getPrivate());
return keyPair;
}
/**
*Effectuer le cryptage
* @param data
* @param base64Key
* @retour des données cryptées
*/
public byte[] encryptByBase64Key(byte[] data, String base64Key){
Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
try {
Key myKey = (Key) decodeObjectFromBase64(base64Key);
Cipher cipher = Cipher.getInstance("RSA/None/NoPadding", "BC");
cipher.init(Cipher.ENCRYPT_MODE, myKey, new SecureRandom());
return cipher.doFinal(data);
} catch (IOException | NoSuchAlgorithmException | NoSuchProviderException | NoSuchPaddingException | IllegalBlockSizeException | BadPaddingException | InvalidKeyException ex) {
return null;
}
}
/**
*Décrypter
* @param data
* @param base64Key
* @renvoyer des données déchiffrées
*/
private byte[] decryptBtBase64Key(byte[] data, String base64Key){
Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
try {
Key myKey = (Key) decodeObjectFromBase64(base64Key);
Cipher cipher = Cipher.getInstance("RSA/None/NoPadding", "BC");
cipher.init(Cipher.DECRYPT_MODE, myKey, new SecureRandom());
return cipher.doFinal(data);
} catch (IOException | NoSuchAlgorithmException | NoSuchProviderException | NoSuchPaddingException | IllegalBlockSizeException | BadPaddingException | InvalidKeyException ex) {
return null;
}
}
/**
*Objet encodé en Base64
* @param o
* @retourne le résultat du codage
*/
private static String encodeObjectAsBase64(Object o){
//Selon la situation, cette fois je vais compresser les octets et retourner une petite taille
try(ByteArrayOutputStream byteos = new ByteArrayOutputStream();
GZIPOutputStream gos = new GZIPOutputStream(byteos);) {
try(ObjectOutputStream objos = new ObjectOutputStream(gos)){
objos.writeObject(o);
}
byte[] retObject = byteos.toByteArray();
return Base64.getEncoder().encodeToString(retObject);
} catch (IOException ex) {
Logger.getLogger(RSAKeyPairSample.class.getName()).log(Level.SEVERE, null, ex);
return null;
}
}
/**
*Convertir l'encodage Base64 en objet
* @param s
* @return
* @throws IOException
*/
private static Object decodeObjectFromBase64(String s) throws IOException{
byte[] bytes = Base64.getDecoder().decode(s);
try(GZIPInputStream gis = new GZIPInputStream(new ByteArrayInputStream(bytes))) {
return new ObjectInputStream(gis).readObject();
} catch (ClassNotFoundException ex) {
return null;
}
}
}
Résultat d'exécution
Clé publique==H4sIAAAAAAAAAFvzloG1uIhBN78oXS8pvzQvuTI5sbgkJ1UvKzlVr6AovywzJbVI (omis)
Clé privée==H4sIAAAAAAAAAJVVe1QTdxae8AiRhzwiUApUEamAJRBQtx608lBsIArIY4GAOEmGZGJeTiaQAA (omis)
----------------------------------------
[Plaine]
Qiita est un service de partage d'informations techniques pour les programmeurs.
[Résultat du chiffrement]
(réduction)
[Résultat du décryptage]
Qiita est un service de partage d'informations techniques pour les programmeurs.
Recommended Posts