signalapp/libsignalLa casa del Signal Protocol e delle altre primitive crittografiche che rendono possibile Signal.
libsignal contiene API indipendenti dalla piattaforma usate dai client e dai server ufficiali di Signal, esposte come libreria Java, Swift o TypeScript. Le implementazioni sottostanti sono scritte in Rust:
Questo repository è usato dalle app client di Signal (Android, iOS e Desktop) e anche lato server. L'uso al di fuori di Signal non è supportato. In particolare, i prodotti di questo repository sono le librerie Java, Swift e TypeScript che incapsulano le implementazioni Rust sottostanti. Tutte le API e le implementazioni sono soggette a modifiche senza preavviso, così come i layer "bridge" JNI, C e Node add-on. Tuttavia, le modifiche incompatibili con le versioni precedenti alle API Java, Swift, TypeScript e Rust non-bridge saranno riflesse nel numero di versione su base best-effort, inclusi gli aumenti delle versioni minime degli strumenti supportati.
Per compilare qualsiasi cosa in questo repository devi avere installato Rust, oltre a versioni recenti di Clang, libclang, CMake, Make, protoc, Python (3.9+) e git.
Su un sistema simile a Debian, puoi ottenere queste dipendenze aggiuntive tramite apt:
$ apt-get install clang libclang-dev cmake make protobuf-compiler libprotobuf-dev python3 git
Su macOS, abbiamo uno script mantenuto su base best-effort per configurare la toolchain Rust; puoi eseguirlo con:
$ bin/mac_setup.sh
La compilazione attualmente usa una versione specifica del compilatore nightly di Rust, che verrà scaricata automaticamente da cargo. Per compilare e testare le librerie di base del protocollo:
$ cargo build
...
$ cargo test
...
Gli strumenti di base sopra dovrebbero essere sufficienti per la maggior parte dello sviluppo Rust di libsignal.
Col tempo, potresti scoprire di aver bisogno di alcuni strumenti Rust aggiuntivi come taplo per la formattazione del codice.
Dovresti sempre installare gli eventuali strumenti Rust che possono influenzare la build tramite cargo, piuttosto che tramite il gestore di pacchetti del sistema (ad es. apt o brew). I gestori di pacchetti a volte contengono versioni obsolete di questi strumenti che possono rompere la build con problemi di incompatibilità (soprattutto cbindgen).
Per installare le principali dipendenze Rust aggiuntive corrispondenti alle versioni che usiamo, puoi eseguire i seguenti comandi:
$ cargo +stable install --version "$(cat acknowledgments/cargo-about-version)" --locked cargo-about
$ cargo +stable install --version "$(cat .taplo-cli-version)" --locked taplo-cli
$ cargo +stable install cargo-fuzz
Per compilare per Android devi installare diversi pacchetti aggiuntivi, tra cui un JDK, l'Android NDK/SDK, e aggiungere i target Android al compilatore Rust, usando
rustup target add armv7-linux-androideabi aarch64-linux-android i686-linux-android x86_64-linux-android
La versione ufficialmente supportata del JDK per le build Android è JDK 21, quindi assicurati di installare, ad esempio, OpenJDK 21 e di impostare JAVA_HOME su tale versione.
Puoi farlo facilmente su macOS con:
export JAVA_HOME=$(/usr/libexec/java_home -v 21)
Su Linux, il modo per farlo varia in base alla distribuzione. Per le distribuzioni basate su Debian come Ubuntu, puoi usare:
sudo update-alternatives --config java
Includiamo anche un file .tools_version da usare con i runtime version manager.
Per compilare jar e aar Java/Android ed eseguire i test:
$ cd java
$ ./gradlew test
$ ./gradlew build # if you need AAR outputs
Puoi passare -P debugLevelLogs a Gradle per compilare senza filtrare i log di livello debug e verbose di Rust, e -P jniTypeTagging per abilitare controlli aggiuntivi nel codice di bridging JNI di Rust.
In alternativa, è disponibile un sistema di build basato su Docker:
$ cd java
$ make
Quando esponi nuove API a Java, dovrai eseguire rust/bridge/jni/bin/gen_java_decl.py oltre a ricompilare. Questo richiede l'installazione dello strumento Rust cbindgen, come descritto sopra.
Signal pubblica pacchetti Java per proprio uso, con i nomi org.signal:libsignal-server, org.signal:libsignal-client e org.signal:libsignal-android. libsignal-client e libsignal-server contengono librerie native per Linux x86_64 in stile Debian, oltre che per Windows (x86_64) e macOS (x86_64 e arm64). libsignal-android contiene librerie native per armeabi-v7a, arm64-v8a, x86 e x86_64 Android. Questi pacchetti si trovano in un repository Maven all'indirizzo https://build-artifacts.signal.org/libraries/maven/; per usarli da Gradle, aggiungi quanto segue al blocco repositories:
maven {
name = "SignalBuildArtifacts"
// The "uri()" part is only necessary for Kotlin Gradle; Groovy Gradle accepts a bare string here.
url = uri("https://build-artifacts.signal.org/libraries/maven/")
}
Le build più vecchie venivano invece pubblicate su Maven Central.
Quando compili per Android hai bisogno di entrambe le librerie libsignal-android e libsignal-client, ma le librerie Windows e macOS in libsignal-client non verranno escluse automaticamente dall'app finale. Puoi escluderle esplicitamente usando packaging:
android {
// ...
packaging {
resources {
excludes += setOf("libsignal_jni*.dylib", "signal_jni*.dll")
}
}
// ...
}
Puoi inoltre escludere libsignal_jni_testing.so se non prevedi di usare nessuna delle API destinate ai test client.
Il file gradle.properties di Signal-Android contiene una riga commentata per includere libsignal come parte della build. Decommentala e regola il percorso; facoltativamente, puoi limitare le architetture per cui vuoi compilare aggiungendo androidArchs=aarch64 al file gradle.properties di libsignal. (L'insieme delle architetture riconosciute si trova in java/build_jni.sh.) Se usi un IDE, dovrai reimportare la struttura Gradle a questo punto. Quando hai finito, ripristina le modifiche al gradle.properties dell'app Android e reimporta un'altra volta.
Nota che questo non importa le parti Rust del progetto nell'IDE. Farlo in un IDE multilingua come IDEA è possibile, ma laborioso; nel 2025 il modo più affidabile è aprire prima il progetto Android, aggiungere poi la directory radice del repository libsignal come progetto Rust (includendo solo la directory di primo livello) e solo dopo apportare le modifiche a gradle.properties.
Per informazioni sul processo di build Swift, vedi swift/README.md
Avrai bisogno di Node installato per compilare. Se hai nvm, puoi eseguire nvm use per selezionare automaticamente una versione appropriata.
Usiamo npm come gestore di pacchetti e uno script Python per controllare la compilazione della libreria Rust, accessibile tramite npm run build.
$ cd node
$ nvm use
$ npm install
$ npm run build
$ npm run tsc
$ npm run test
Quando testi modifiche localmente, puoi usare npm run build per fare una ricompilazione incrementale della libreria Rust. In alternativa, npm run build-with-debug-level-logs ricompila senza filtrare i log di livello debug e verbose.
Quando esponi nuove API a Node, dovrai eseguire just generate-node oltre a ricompilare.
Signal pubblica il pacchetto NPM @signalapp/libsignal-client per proprio uso, incluse le librerie native per Windows, macOS e Linux in stile Debian. Per tutte e tre le piattaforme sono incluse sia le build x64 sia quelle arm64, ma le build arm64 per Windows e Linux sono considerate sperimentali, poiché non esistono build ufficiali di Signal per quelle architetture.
Dopo aver eseguito tutti i comandi di build sopra, modifica la dipendenza @signalapp/libsignal-client nel package.json dell'app Desktop in "link:path/to/libsignal/node" ed esegui pnpm install. Quando hai finito, ripristina le modifiche a package.json ed esegui di nuovo pnpm install.
Signal accetta contributi esterni a questo progetto. Tuttavia, a meno che la modifica non sia semplice e facilmente comprensibile, ad esempio la correzione di un bug o di un problema di portabilità, l'aggiunta di un nuovo test o il miglioramento delle prestazioni, apri prima un issue per discutere la modifica che intendi apportare, poiché non tutte le modifiche possono essere accettate.
I contributi che non verranno usati direttamente da una delle app client ufficiali di Signal possono comunque essere presi in considerazione, ma solo se non comportano un onere di manutenzione eccessivo o non entrano in conflitto con gli obiettivi del progetto.
Per tutti i contributi è richiesta la firma di un CLA (Contributor License Agreement).
Puoi eseguire lo styler sull'intero progetto lanciando:
just format-all
Puoi eseguire test più estesi, oltre a linter e clippy, lanciando:
just check-pre-commit
Quando crei una PR che modifica le dipendenze, dovrai rigenerare i nostri file dei riconoscimenti. Vedi acknowledgments/README.md.
Questa distribuzione include software crittografico. Il paese in cui risiedi potrebbe avere restrizioni sull'importazione, il possesso, l'uso e/o la riesportazione verso un altro paese di software di cifratura. PRIMA di usare qualsiasi software di cifratura, controlla le leggi, le normative e le politiche del tuo paese relative all'importazione, al possesso, all'uso e alla riesportazione di software di cifratura, per verificare che sia consentito. Per maggiori informazioni, vedi http://www.wassenaar.org/.
Il Dipartimento del Commercio degli Stati Uniti, Bureau of Industry and Security (BIS), ha classificato questo software come Export Commodity Control Number (ECCN) 5D002.C.1, che include software di sicurezza informatica che utilizza o esegue funzioni crittografiche con algoritmi asimmetrici. La forma e la modalità di questa distribuzione lo rendono idoneo all'esportazione ai sensi dell'eccezione License Exception ENC Technology Software Unrestricted (TSU) (vedi BIS Export Administration Regulations, Sezione 740.13) sia per il codice oggetto che per il codice sorgente.
Copyright 2020-2026 Signal Messenger, LLC
Concesso in licenza secondo GNU AGPLv3: https://www.gnu.org/licenses/agpl-3.0.html