Cryptographie en Kotlin : chiffrement et hachage

Kotlin, fonctionnant sur la JVM, donne un accès complet aux puissantes bibliothèques cryptographiques Java, telles que Java Cryptography Extension (JCE) et Bouncy Castle. Dans cet article, nous verrons comment implémenter le chiffrement symétrique (AES), asymétrique (RSA) ainsi que le hachage (SHA-256) en Kotlin. Tous les exemples de code sont prêts à être exécutés — vous pouvez les copier dans votre projet.

Préparation du projet

Pour commencer, ajoutez la dépendance à Bouncy Castle dans build.gradle.kts (fournisseur recommandé pour les algorithmes modernes) :

dependencies {    implementation("org.bouncycastle:bcprov-jdk15on:1.70")}

Après la synchronisation de Gradle, importez le fournisseur dans le code :

import org.bouncycastle.jce.provider.BouncyCastleProviderimport java.security.Security

fun initCrypto() {    Security.addProvider(BouncyCastleProvider())}

1. Hachage SHA-256

Le hachage est une transformation irréversible des données. Il est le plus souvent utilisé pour vérifier l'intégrité des fichiers et stocker les mots de passe.

import java.security.MessageDigest

fun sha256(input: String): String {    val digest = MessageDigest.getInstance("SHA-256")    val hashBytes = digest.digest(input.toByteArray())    return hashBytes.joinToString("") { "%02x".format(it) }}

fun main() {    val password = "mySecret123"    val hash = sha256(password)    println("SHA-256 hash : $hash")    // Sortie : SHA-256 hash : a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3}

Important : Pour les mots de passe, utilisez bcrypt ou scrypt — SHA-256 est trop rapide et vulnérable aux attaques par force brute.

2. Chiffrement symétrique AES

AES (Advanced Encryption Standard) est l'algorithme le plus populaire pour le chiffrement des données. Nous utilisons le mode GCM (garantit l'authenticité) et un IV aléatoire.

import javax.crypto.Cipherimport javax.crypto.KeyGeneratorimport javax.crypto.SecretKeyimport javax.crypto.spec.GCMParameterSpecimport java.util.Base64

class AesGcmEncryption {    companion object {        private const val AES_KEY_SIZE = 256        private const val GCM_IV_LENGTH = 12        private const val GCM_TAG_LENGTH = 128    }

    fun generateKey(): SecretKey {        val keyGen = KeyGenerator.getInstance("AES")        keyGen.init(AES_KEY_SIZE)        return keyGen.generateKey()    }

    fun encrypt(plainText: String, secretKey: SecretKey): String {        val cipher = Cipher.getInstance("AES/GCM/NoPadding")        val iv = ByteArray(GCM_IV_LENGTH).apply {            java.security.SecureRandom().nextBytes(this)        }        cipher.init(Cipher.ENCRYPT_MODE, secretKey, GCMParameterSpec(GCM_TAG_LENGTH, iv))        val cipherText = cipher.doFinal(plainText.toByteArray())        // Combinaison de l'IV et du texte chiffré        val combined = iv + cipherText        return Base64.getEncoder().encodeToString(combined)    }

    fun decrypt(encryptedData: String, secretKey: SecretKey): String {        val combined = Base64.getDecoder().decode(encryptedData)        val iv = combined.copyOfRange(0, GCM_IV_LENGTH)        val cipherText = combined.copyOfRange(GCM_IV_LENGTH, combined.size)        val cipher = Cipher.getInstance("AES/GCM/NoPadding")        cipher.init(Cipher.DECRYPT_MODE, secretKey, GCMParameterSpec(GCM_TAG_LENGTH, iv))        return String(cipher.doFinal(cipherText))    }}

fun main() {    val aes = AesGcmEncryption()    val key = aes.generateKey()    val original = "Message secret"    val encrypted = aes.encrypt(original, key)    val decrypted = aes.decrypt(encrypted, key)    println("Original : $original")    println("Chiffré : $encrypted")    println("Déchiffré : $decrypted")}