vaegram 0.2.0

Telegram MTProto client library for users and bots
Documentation
use num_bigint::BigUint;

use super::{aes, random, random_fill, sha1, sha256, to_be_padded};
use crate::raw::Serializable;
use crate::utils::base64url_decode;

/// Telegram's production server key (`-----BEGIN RSA PUBLIC KEY----- MIIBCgKCAQEA6LszBcC1LGzyr992...`),
/// fingerprint 0xd09d1d85de64fd85. Exponent 65537.
const PRODUCTION_N_HEX: &str = concat!(
    "E8BB3305C0B52C6CF2AFDF7637313489E63E05268E5BADB601AF417786472E5F",
    "93B85438968E20E6729A301C0AFC121BF7151F834436F7FDA680847A66BF64AC",
    "CEC78EE21C0B316F0EDAFE2F41908DA7BD1F4A5107638EEB67040ACE472A14F9",
    "0D9F7C2B7DEF99688BA3073ADB5750BB02964902A359FE745D8170E36876D4FD",
    "8A5D41B2A76CBFF9A13267EB9580B2D06D10357448D20D9DA2191CB5D8C93982",
    "961CDFDEDA629E37F1FB09A0722027696032FE61ED663DB7A37F6F263D370F69",
    "DB53A0DC0A1748BDAAFF6209D5645485E6E001D1953255757E4B8E42813347B1",
    "1DA6AB500FD0ACE7E6DFA3736199CCAF9397ED0745A427DCFA6CD67BCB1ACFF3",
);

/// Test servers' key (PEM body `MIIBCgKCAQEAyMEdY1aR+sCR3ZSJrtztKTKqigvO...`), fingerprint
/// 0xb25898df208d2603. Test DCs don't offer the production key.
const TEST_N_HEX: &str = concat!(
    "C8C11D635691FAC091DD9489AEDCED2932AA8A0BCEFEF05FA800892D9B52ED03",
    "200865C9E97211CB2EE6C7AE96D3FB0E15AEFFD66019B44A08A240CFDD2868A8",
    "5E1F54D6FA5DEAA041F6941DDF302690D61DC476385C2FA655142353CB4E4B59",
    "F6E5B6584DB76FE8B1370263246C010C93D011014113EBDF987D093F9D37C2BE",
    "48352D69A1683F8F6E6C2167983C761E3AB169FDE5DAAA12123FA1BEAB621E4D",
    "A5935E9C198F82F35EAE583A99386D8110EA6BD1ABB0F568759F62694419EA5F",
    "69847C43462ABEF858B4CB5EDC84E7B9226CD7BD7E183AA974A712C079DDE85B",
    "9DC063B8A5C08E8F859C0EE5DCD824C7807F20153361A7F63CFD2A433A1BE7F5",
);

#[derive(Clone)]
pub struct PublicKey {
    n: BigUint,
    e: BigUint,
}

impl PublicKey {
    pub fn production() -> Self {
        Self { n: BigUint::parse_bytes(PRODUCTION_N_HEX.as_bytes(), 16).unwrap(), e: BigUint::from(65537u32) }
    }

    pub fn test() -> Self {
        Self { n: BigUint::parse_bytes(TEST_N_HEX.as_bytes(), 16).unwrap(), e: BigUint::from(65537u32) }
    }

    /// A PKCS#1 PEM key as help.getCdnConfig sends it; only 2048-bit keys, the size RSA_PAD needs.
    pub fn from_pem(pem: &str) -> Option<Self> {
        let body: String = pem.lines().map(str::trim).filter(|l| !l.starts_with("-----")).collect();
        let der = base64url_decode(&body.trim_end_matches('=').replace('+', "-").replace('/', "_"))?;
        let (key, _) = der_item(&der, 0x30)?;
        let (n, rest) = der_item(key, 0x02)?;
        let (e, _) = der_item(rest, 0x02)?;
        let key = Self { n: BigUint::from_bytes_be(n), e: BigUint::from_bytes_be(e) };
        (key.n.bits() == 2048).then_some(key)
    }

    /// `data` read as a big-endian number and raised to the public exponent, with no padding: how a signed blob
    /// such as the DNS config is opened.
    #[cfg(feature = "dns-config")]
    pub(crate) fn raw_public(&self, data: &[u8]) -> [u8; 256] {
        to_be_padded(&BigUint::from_bytes_be(data).modpow(&self.e, &self.n))
    }

    pub fn fingerprint(&self) -> i64 {
        let mut buf = Vec::new();
        self.n.to_bytes_be().serialize(&mut buf);
        self.e.to_bytes_be().serialize(&mut buf);
        i64::from_le_bytes(sha1(&[&buf])[12..].try_into().unwrap())
    }

    pub fn encrypt_pad(&self, data: &[u8]) -> [u8; 256] {
        assert!(data.len() <= 144, "RSA_PAD data is {} bytes; at most 144 fit", data.len());
        let mut padded = [0u8; 192];
        padded[..data.len()].copy_from_slice(data);
        random_fill(&mut padded[data.len()..]);
        let mut reversed = padded;
        reversed.reverse();

        loop {
            let temp_key: [u8; 32] = random();
            let mut aes_encrypted = [0u8; 224];
            aes_encrypted[..192].copy_from_slice(&reversed);
            aes_encrypted[192..].copy_from_slice(&sha256(&[&temp_key, &padded]));
            aes::ige256_encrypt(&mut aes_encrypted, &temp_key, &[0; 32]).unwrap();

            let hash = sha256(&[&aes_encrypted]);
            let mut key_aes_encrypted = [0u8; 256];
            for i in 0..32 {
                key_aes_encrypted[i] = temp_key[i] ^ hash[i];
            }
            key_aes_encrypted[32..].copy_from_slice(&aes_encrypted);

            let x = BigUint::from_bytes_be(&key_aes_encrypted);
            if x < self.n {
                return to_be_padded(&x.modpow(&self.e, &self.n));
            }
        }
    }
}

fn der_item(data: &[u8], tag: u8) -> Option<(&[u8], &[u8])> {
    let [t, len, rest @ ..] = data else { return None };
    if *t != tag {
        return None;
    }
    let (len, rest) = match *len {
        len @ 0..=0x7f => (usize::from(len), rest),
        0x81 | 0x82 => {
            let (bytes, rest) = rest.split_at_checked(usize::from(*len & 0x7f))?;
            (bytes.iter().fold(0, |acc, &b| (acc << 8) | usize::from(b)), rest)
        }
        _ => return None,
    };
    rest.split_at_checked(len)
}

#[cfg(test)]
mod tests {
    use super::PublicKey;

    const PRODUCTION_PEM: &str = "-----BEGIN RSA PUBLIC KEY-----
MIIBCgKCAQEA6LszBcC1LGzyr992NzE0ieY+BSaOW622Aa9Bd4ZHLl+TuFQ4lo4g
5nKaMBwK/BIb9xUfg0Q29/2mgIR6Zr9krM7HjuIcCzFvDtr+L0GQjae9H0pRB2OO
62cECs5HKhT5DZ98K33vmWiLowc621dQuwKWSQKjWf50XYFw42h21P2KXUGyp2y/
+aEyZ+uVgLLQbRA1dEjSDZ2iGRy12Mk5gpYc397aYp438fsJoHIgJ2lgMv5h7WY9
t6N/byY9Nw9p21Og3AoXSL2q/2IJ1WRUhebgAdGVMlV1fkuOQoEzR7EdpqtQD9Cs
5+bfo3Nhmcyvk5ftB0WkJ9z6bNZ7yxrP8wIDAQAB
-----END RSA PUBLIC KEY-----";

    const TEST_PEM: &str = "-----BEGIN RSA PUBLIC KEY-----
MIIBCgKCAQEAyMEdY1aR+sCR3ZSJrtztKTKqigvO/vBfqACJLZtS7QMgCGXJ6XIR
yy7mx66W0/sOFa7/1mAZtEoIokDP3ShoqF4fVNb6XeqgQfaUHd8wJpDWHcR2OFwv
plUUI1PLTktZ9uW2WE23b+ixNwJjJGwBDJPQEQFBE+vfmH0JP503wr5INS1poWg/
j25sIWeYPHYeOrFp/eXaqhISP6G+q2IeTaWTXpwZj4LzXq5YOpk4bYEQ6mvRq7D1
aHWfYmlEGepfaYR8Q0YqvvhYtMte3ITnuSJs171+GDqpdKcSwHnd6FudwGO4pcCO
j4WcDuXc2CTHgH8gFTNhp/Y8/SpDOhvn9QIDAQAB
-----END RSA PUBLIC KEY-----";

    #[test]
    fn server_key_fingerprints() {
        assert_eq!(PublicKey::production().fingerprint(), 0xd09d1d85de64fd85u64 as i64);
        assert_eq!(PublicKey::test().fingerprint(), 0xb25898df208d2603u64 as i64);
    }

    #[test]
    fn reads_pem_keys() {
        let fingerprint = |pem: &str| PublicKey::from_pem(pem).map(|k| k.fingerprint() as u64);
        assert_eq!(fingerprint(PRODUCTION_PEM), Some(0xd09d1d85de64fd85));
        assert_eq!(fingerprint(TEST_PEM), Some(0xb25898df208d2603));
        assert_eq!(fingerprint(&PRODUCTION_PEM.replace("MIIBCg", "MIIBCw")), None);
        assert_eq!(fingerprint(&PRODUCTION_PEM.replace('A', "*")), None);
        assert_eq!(fingerprint(&PRODUCTION_PEM[..200]), None);
    }

    #[test]
    fn rsa_pad_output_is_256_bytes_and_random() {
        let key = PublicKey::production();
        let (a, b) = (key.encrypt_pad(b"hello"), key.encrypt_pad(b"hello"));
        assert_eq!(a.len(), 256);
        assert_ne!(a, b);
    }
}