MTProto crypto core

import opentele2  # before telethon: registers the core's cryptg
from telethon import TelegramClient

Two mechanisms, both set up by import opentele2:

• cryptg. Telethon looks for a cryptg module the first time telethon.crypto.aes is imported. When no real cryptg is installed, opentele2 registers opentele2._native.cryptg under that name, so Telethon’s AES-IGE runs on the core. An installed cryptg is left in charge. This is why opentele2 must be imported before telethon.
• The bridge. opentele2 rebinds the names Telethon looks up at call time: AESModeCTR in the crypto, CDN, obfuscated and MTProxy modules, Factorization.factorize, the sha1 and sha256 imports, and the hashlib used for password and MTProxy hashing. It imports those modules itself and patches them in place, so this part works whether Telethon was imported before or after opentele2. A module or name that is missing is skipped.

The primitives are also callable directly from opentele2._native (aes_ige_encrypt, AesCtr, sha256, pbkdf2, factorize_pq, random_bytes and the others).

import { TelegramClient } from '@mtcute/node'
import { profile } from 'opentele2'
import { createCryptoProvider, initConnectionOptions } from 'opentele2/mtcute'
 
const desktop = profile('TelegramDesktop')
const client = new TelegramClient({
  apiId: desktop.apiId,
  apiHash: desktop.apiHash,
  initConnectionOptions: initConnectionOptions(desktop),
  crypto: await createCryptoProvider(),
})

createCryptoProvider() implements every member of mtcute’s ICryptoProvider on the core: hashes, HMAC, PBKDF2, AES-256-CTR and -IGE, PQ factorisation, gzip and the OS random source. It needs neither Node’s crypto module nor @mtcute/node, and its initialize has nothing to load. Its gzip writes a gzip stream, where mtcute’s own Node provider writes zlib.

The same primitives are exported from the root entry point: aesIgeEncrypt, AesCtr, sha1, sha256, hmacSha256, pbkdf2, factorizePq, gzip, gunzip, randomBytes, randomFill.

use opentele2_core::crypto;
 
fn main() -> opentele2_core::Result<()> {
    let mut nonce = [0u8; 16];
    crypto::random_fill(&mut nonce)?; // the one entry point to the OS random source
    Ok(())
}

grammers already runs on Rust crypto: it uses grammers-crypto, which the core uses too, so nothing needs bridging. The crypto and compress modules of opentele2-core expose the same primitives the bindings use, for your own code.