Kotlin में क्रिप्टोग्राफी: एन्क्रिप्शन और हैशिंग

Kotlin, जो JVM के ऊपर काम करता है, शक्तिशाली जावा क्रिप्टोग्राफ़िक लाइब्रेरीज़ जैसे Java Cryptography Extension (JCE) और Bouncy Castle तक पूर्ण पहुँच प्रदान करता है। इस लेख में, हम देखेंगे कि Kotlin में सममित (AES), असममित (RSA) एन्क्रिप्शन, साथ ही हैशिंग (SHA-256) को कैसे लागू किया जाए। सभी कोड उदाहरण चलाने के लिए तैयार हैं — आप उन्हें अपने प्रोजेक्ट में कॉपी कर सकते हैं।

प्रोजेक्ट तैयार करना

शुरू करने के लिए, build.gradle.kts में Bouncy Castle (आधुनिक एल्गोरिदम के लिए अनुशंसित प्रदाता) की निर्भरता जोड़ें:

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

Gradle सिंक्रोनाइज़ेशन के बाद, कोड में प्रदाता को आयात करें:

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

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

1. SHA-256 हैशिंग

हैशिंग डेटा का एक अपरिवर्तनीय रूपांतरण है। इसका उपयोग अक्सर फ़ाइलों की अखंडता की जाँच और पासवर्ड संग्रहीत करने के लिए किया जाता है।

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")    // आउटपुट: SHA-256 हैश: a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3}

महत्वपूर्ण: पासवर्ड के लिए bcrypt या scrypt का उपयोग करें — SHA-256 बहुत तेज़ है और ब्रूट-फोर्स हमलों के प्रति संवेदनशील है।

2. सममित एन्क्रिप्शन AES

AES (Advanced Encryption Standard) डेटा एन्क्रिप्शन के लिए सबसे लोकप्रिय एल्गोरिदम है। हम GCM मोड (प्रामाणिकता सुनिश्चित करता है) और रैंडम IV का उपयोग करते हैं।

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())        // IV और सिफरटेक्स्ट को मिलाएं        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 = "गुप्त संदेश"    val encrypted = aes.encrypt(original, key)    val decrypted = aes.decrypt(encrypted, key)    println("मूल: $original")    println("एन्क्रिप्टेड: $encrypted")    println("डिक्रिप्टेड: $decrypted")}