RSA: ano ito, algorithm at aplikasyon ng pag-encrypt

Ano ang RSA?

RSA — isang cryptographic algorithm na may pampublikong key na binuo noong 1977 nina Ronald Rivest, Adi Shamir at Leonard Adleman. Ang pangalan ay nabuo mula sa mga unang titik ng mga apelyido ng mga may-akda. Ang algorithm ay naging unang praktikal na naaangkop na asymmetric cryptosystem kung saan ang mga key ng pag-encrypt at pag-decrypt ay magkaiba.

Kasaysayan ng paglikha

Ang RSA algorithm ay inilathala noong 1977 sa journal Scientific American at batay sa mga naunang gawa ni Whitfield Diffie at Martin Hellman sa larangan ng cryptography na may pampublikong key. Ang Massachusetts Institute of Technology ay nakakuha ng patent para sa RSA noong 1983, na may bisa hanggang 2000. Ayon sa ulat ng RSA Laboratories (2023), ang algorithm ay nananatiling isa sa pinakalaganap na cryptographic standard sa mundo — ginagamit ito sa bilyun-bilyong device araw-araw.

Prinsipyo ng asymmetry

Hindi tulad ng symmetric ciphers kung saan ang parehong key ay ginagamit para sa pag-encrypt at pag-decrypt, ang RSA ay nagpapatakbo ng isang mathematically na nauugnay na pares ng key. Ang pampublikong key ay maaaring ilathala para sa lahat nang walang panganib ng kompromiso ng system. Ang pribadong key ay alam lamang ng may-ari at hindi kailanman ipinadala sa network. Ayon sa pag-aaral ng IBM Security X-Force Threat Intelligence Index (2024), ang asymmetric encryption ay ginagamit sa 96% ng modernong secure data transmission protocol.

Mga mathematical na pundasyon

Ang seguridad ng RSA ay batay sa problema ng factorisation — pag-factor ng produkto ng dalawang malalaking prime number. Kung pipiliin ang prime number p at q na may haba na 1024 bit bawat isa, ang kanilang produkto n ay maglalaman ng 2048 bit. Ang pagkalkula ng p at q na alam lamang ang n gamit ang modernong pamamaraan ay praktikal na imposible: ayon sa pagtatasa ng eksperto ng CNRS (2024), ang pag-crack ng RSA-2048 ay mangangailangan ng higit sa 300 bilyong taon ng pag-compute sa isang classical na computer.

Paano gumagana ang RSA algorithm

Suriin natin ang buong ikot ng trabaho ng RSA mula sa pagbuo ng key hanggang sa pag-encrypt at pag-decrypt ng mensahe. Ang pag-unawa sa mga yugtong ito ay kinakailangan para sa tamang implementasyon ng algorithm sa mga mobile application.

Pagbuo ng key

Ang proseso ay nagsisimula sa pagpili ng dalawang malalaking prime number na p at q. Kinakalkula ang modulus n = p x q, na tumutukoy sa haba ng key. Pagkatapos ay kinakalkula ang Euler function phi(n) = (p-1)(q-1). Pinipili ang public exponent e, na relatively prime sa phi(n). Ang private exponent d ay kinakalkula bilang multiplicative inverse ng e modulo phi(n). Ayon sa NIST SP 800-56B Rev. 2, ang minimal na haba ng n ay dapat na 2048 bit para sa sapat na proteksyon.

import java.security.KeyPairGenerator;
import java.security.KeyPair;
import java.security.SecureRandom;

public class RSAKeyGenerator {
    public static KeyPair generateKeyPair() throws Exception {
        KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");
        generator.initialize(2048, new SecureRandom());
        return generator.generateKeyPair();
    }
}

Pag-encrypt at pag-decrypt

Upang i-encrypt ang mensaheng m, ginagawang integer na mas maliit sa n ng nagpadala at kinakalkula ang ciphertext c = m^e mod n. Ginagamit ng receiver ang private key d para ibalik ang orihinal na mensahe: m = c^d mod n. Mahalagang tandaan na ang RSA ay hindi dinisenyo para sa pag-encrypt ng malalaking dami ng data dahil sa mababang performance — ang maximum na laki ng mensahe ay katumbas ng haba ng key na binawasan ang service bytes (humigit-kumulang 190 bytes para sa RSA-2048 na may OAEP).

import javax.crypto.Cipher;
import java.security.PublicKey;
import java.util.Base64;

public class RSAEncryptor {
    public static String encrypt(String data, PublicKey publicKey) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] encrypted = cipher.doFinal(data.getBytes());
        return Base64.getEncoder().encodeToString(encrypted);
    }
}

Digital na lagda sa RSA

Ang RSA ay ginagamit din para sa paglikha ng digital na lagda — isang mekanismo ng pagpapatunay ng authenticity at integridad ng data. Pinipirmahan ng may-ari ang hash ng mensahe gamit ang kanyang private key, at sinuman ay maaaring i-verify ang lagda gamit ang public key. Ayon sa ulat ng Sectigo Certificate Transparency (2025), higit sa 85% ng TLS certificate sa internet ay gumagamit ng RSA para sa digital na lagda, na ginagawang pundasyon ng tiwala ng web communication ang algorithm.

import java.security.Signature

fun signData(data: ByteArray, privateKey: java.security.PrivateKey): ByteArray {
    val signature = Signature.getInstance("SHA256withRSA")
    signature.initSign(privateKey)
    signature.update(data)
    return signature.sign()
}

fun verifySignature(
    data: ByteArray, signedData: ByteArray, publicKey: java.security.PublicKey
): Boolean {
    val signature = Signature.getInstance("SHA256withRSA")
    signature.initVerify(publicKey)
    signature.update(data)
    return signature.verify(signedData)
}

Mga sukat ng key at antas ng seguridad

Ang haba ng key ay direktang nakakaapekto sa cryptographic strength ng RSA. Sa paglaki ng computing power, ang minimal na pinapayagang sukat ng key ay regular na nire-review ng mga international standardization organization. Tingnan natin ang kasalukuyang rekomendasyon ng NIST at iba pang regulator.

Epekto sa performance

Ang pagtaas ng haba ng key ng RSA ay makabuluhang nakakaapekto sa oras ng pagpapatupad ng mga operasyon. Ang pagbuo ng key na may haba na 4096 bit ay tumatagal ng humigit-kumulang 10 beses na mas mahaba kaysa 2048 bit. Ang mga operasyon ng pag-encrypt at pag-decrypt na may mahabang key ay nangangailangan ng mas maraming computing resources, na kritikal para sa mga mobile device na may limitadong konsumo ng kuryente.

Banta ng quantum

Sa pag-unlad ng quantum computing, ang RSA ay maaaring i-crack gamit ang algorithm ni Shor sa polynomial time. Ang algorithm na ito, na iminungkahi ni Peter Shor noong 1994, ay nagpapahintulot sa factorisation ng malalaking numero sa O((log n)^3) na operasyon. Ayon sa IBM Quantum Roadmap (2025), ang praktikal na pag-crack ng RSA-2048 ay inaasahan hindi mas maaga sa 2035, gayunpaman inirerekomenda na ng NIST ang unti-unting paglipat sa post-quantum algorithm na CRYSTALS-Kyber at CRYSTALS-Dilithium.

Aplikasyon ng RSA sa mobile development

Ang RSA ay aktibong ginagamit sa mga mobile application para sa pagtiyak ng secure na pagpapadala ng data, pagpapatunay ng authenticity ng server at proteksyon ng digital na transaksyon. Ang integrasyon ay isinasagawa sa pamamagitan ng standard cryptographic API ng parehong pangunahing platform.

Android Keystore

Ang Android platform ay nagbibigay ng Android Keystore — isang system storage ng cryptographic key na protektado sa hardware level ng Trusted Execution Environment. Ang RSA key na nabuo sa KeyStore ay hindi maaaring makuha mula sa device kahit na ang application ay nakompromiso. Ito ay nagbibigay ng proteksyon laban sa malawak na klase ng atake, kabilang ang malware na may root access.

import android.security.keystore.KeyGenParameterSpec
import android.security.keystore.KeyProperties
import java.security.KeyPairGenerator

fun generateKeyInAndroidKeystore() {
    val generator = KeyPairGenerator.getInstance(
        KeyProperties.KEY_ALGORITHM_RSA,
        "AndroidKeyStore"
    )
    val spec = KeyGenParameterSpec.Builder(
        "rsa_key_pair",
        KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT
    )
        .setKeySize(2048)
        .setBlockModes(KeyProperties.BLOCK_MODE_ECB)
        .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_RSA_OAEP)
        .build()
    generator.initialize(spec)
    val keyPair = generator.generateKeyPair()
}

iOS Security Framework

Sa iOS, para sa pagtatrabaho sa RSA ay ginagamit ang Security Framework na may access sa Secure Enclave sa mga device na may A7 chip at mas bago. Ang Secure Enclave ay isang dedicated coprocessor na nakahiwalay sa pangunahing processor, na nagsasagawa ng cryptographic operations at nag-iimbak ng key sa hardware enclave. Ang RSA key ay maaaring mabuo pareho sa loob ng Secure Enclave at sa software Keychain na may iba't ibang antas ng access.

Hybrid encryption sa praktika

Sa tunay na mobile application, ang RSA ay bihirang ginagamit para sa direktang pag-encrypt ng malaking data. Ang standard na praktika ay hybrid scheme: ang application ay bumubuo ng AES session key, ini-encrypt ito gamit ang public RSA key ng server at ipinapadala sa server. Ang lahat ng kasunod na trapiko ay ini-encrypt ng AES, na 100–1000 beses na mas mabilis kaysa direktang pagpapadala ng data sa pamamagitan ng RSA.

Mga kalamangan at limitasyon ng RSA

Tulad ng anumang cryptographic algorithm, ang RSA ay may malakas at mahinang aspeto na dapat isaalang-alang sa pagdisenyo ng secure na system. Ang obhektibong pagtatasa ay tumutulong sa pagpili ng tamang tool para sa isang partikular na gawain.

Mga pangunahing kalamangan

Ang pangunahing bentahe ng RSA ay ang solusyon sa pangunahing problema ng pamamahagi ng key — ang pampublikong key ay maaaring malayang ilathala nang walang panganib ng kompromiso ng buong system. Ang universality ng algorithm ay makikita sa suporta para sa parehong pag-encrypt at digital na lagda na may parehong pares ng key. Bukod dito, ang RSA ay may malawak na ecosystem ng suporta: ang mga library ay magagamit para sa lahat ng wika at platform.

Mga pangunahing limitasyon

Ang pangunahing disbentaha ng RSA ay mababang performance kumpara sa symmetric algorithm. Ang pag-decrypt ng RSA-2048 sa modernong mobile processor ay tumatagal ng humigit-kumulang 5–15 millisecond, habang ang AES-256 ay nagpoproseso ng gigabytes ng data sa parehong oras. Gayundin, ang RSA ay vulnerable sa quantum attack sa pamamagitan ng algorithm ni Shor, na naglilimita sa aplikasyon nito sa mga system na may pangmatagalang proteksyon ng data.

Mga rekomendasyon sa paggamit

Para sa mga mobile project, inirerekomenda ng mga eksperto ng NIST: gamitin ang RSA lamang para sa pag-encrypt ng key at digital na lagda, pumili ng haba ng key na hindi bababa sa 3072 bit para sa mga bagong project, pagsamahin ang RSA sa AES sa hybrid scheme at subaybayan ang pag-unlad ng post-quantum standard para sa planadong migrasyon sa pangmatagalang pananaw.