Aperçu

libsignal contient des API indépendantes de la plateforme utilisées par les clients et serveurs Signal officiels, exposées sous forme de bibliothèque Java, Swift ou TypeScript. Les implémentations sous-jacentes sont écrites en Rust :

• libsignal-protocol : Implémente le protocole Signal, y compris l'[algorithme Double Ratchet][]. Un remplacement pour libsignal-protocol-java et libsignal-metadata-java.
• signal-crypto : Primitives cryptographiques telles que AES-GCM. Nous utilisons celles de RustCrypto lorsque nous le pouvons mais avons parfois des besoins différents.
• device-transfer : Logique de prise en charge de la fonctionnalité de transfert de périphérique à périphérique de Signal.
• attest : Fonctionnalité d'attestation à distance des [enclaves SGX][] et des [HSM][] côté serveur.
• zkgroup : Fonctionnalité pour les [groupes à connaissance nulle][] et les fonctionnalités associées disponibles dans Signal.
• zkcredential : Une abstraction pour le type d'informations d'identification à connaissance nulle utilisées par zkgroup, basée sur l'article « The Signal Private Group System » de Chase, Perrin et Zaverucha.
• poksho : Utilitaires pour implémenter des preuves à connaissance nulle (telles que celles utilisées par zkgroup) ; signifie « proof-of-knowledge, stateful-hash-object ».
• account-keys : Fonctionnalité pour utiliser de manière cohérente les [PIN][] comme mots de passe dans le système Secure Value Recovery de Signal, ainsi que d'autres opérations de clés à l'échelle du compte.
• usernames : Fonctionnalité pour la génération, le hachage et les preuves de noms d'utilisateur.
• media : Utilitaires pour la manipulation de médias.

Ce dépôt est utilisé par les applications clientes Signal (Android, iOS et Desktop) ainsi que côté serveur. L'utilisation en dehors de Signal n'est pas prise en charge. En particulier, les produits de ce dépôt sont les bibliothèques Java, Swift et TypeScript qui encapsulent les implémentations Rust sous-jacentes. Toutes les API et implémentations sont susceptibles de changer sans préavis, tout comme les couches « pont » JNI, C et Node add-on. Cependant, les changements rétro-incompatibles des API Java, Swift, TypeScript et Rust non-pont seront reflétés dans le numéro de version au mieux, y compris les augmentations des versions minimales d'outils prises en charge.

Compilation

Installation de la chaîne d'outils

Pour compiler quoi que ce soit dans ce dépôt, vous devez avoir Rust installé, ainsi que des versions récentes de Clang, libclang, CMake, Make, protoc, Python (3.9+) et git.

Linux/Debian

Sur un système de type Debian, vous pouvez obtenir ces dépendances supplémentaires via apt :

$ apt-get install clang libclang-dev cmake make protobuf-compiler libprotobuf-dev python3 git

macOS

Sur macOS, nous disposons d'un script maintenu au mieux pour installer la chaîne d'outils Rust que vous pouvez exécuter avec :

$ bin/mac_setup.sh

Rust

Première compilation et test

La compilation utilise actuellement une version spécifique du compilateur Rust stable, qui sera téléchargée automatiquement par cargo. Pour compiler et tester les bibliothèques de protocole de base :

$ cargo build
...
$ cargo test
...

Outils Rust supplémentaires

Les outils de base ci-dessus devraient vous permettre de configurer la plupart des développements Rust de libsignal.

À terme, vous pourriez avoir besoin d'outils Rust supplémentaires comme taplo pour le formatage du code.

Vous devez toujours installer les outils Rust dont vous avez besoin et qui peuvent affecter la compilation depuis cargo plutôt que depuis votre gestionnaire de paquets système (par exemple apt ou brew). Les gestionnaires de paquets contiennent parfois des versions obsolètes de ces outils qui peuvent casser la compilation avec des problèmes d'incompatibilité.

Pour installer les principales dépendances Rust supplémentaires correspondant aux versions que nous utilisons, vous pouvez exécuter les commandes suivantes :

$ 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

Java/Android

Configuration de la chaîne d'outils

Pour compiler pour Android, vous devez installer plusieurs paquets supplémentaires, notamment un JDK, le NDK/SDK Android, et ajouter les cibles Android au compilateur Rust, en utilisant

rustup target add armv7-linux-androideabi aarch64-linux-android i686-linux-android x86_64-linux-android

Our officially supported JDK version for Android builds is JDK 21, so be sure to install e.g. OpenJDK 21, and then point JAVA_HOME to it.

You can easily do this on macOS via:

export JAVA_HOME=$(/usr/libexec/java_home -v 21)

On Linux, the way you do this varies by distribution. For Debian based distributions like Ubuntu, you can use:

sudo update-alternatives --config java

We also check-in a .tools_version file for use with runtime version managers.

Building and Testing

To build the Java/Android jar and aar, and run the tests:

$ cd java
$ ./gradlew test
$ ./gradlew build # si vous avez besoin des sorties AAR

You can pass -P debugLevelLogs to Gradle to build without filtering out debug- and verbose-level logs from Rust, and -P jniTypeTagging to enable additional checks in the Rust JNI bridging code.

Alternately, a build system using Docker is available:

$ cd java
$ make

When exposing new APIs to Java, you will need to run cargo run -p libsignal-jni-native_kt (or just generate-jni) in addition to rebuilding.

Use as a library

Signal publishes Java packages for its own use, under the names org.signal:libsignal-server, org.signal:libsignal-client, and org.signal:libsignal-android. libsignal-client and libsignal-server contain native libraries for Debian-flavored x86_64 Linux as well as Windows (x86_64) and macOS (x86_64 and arm64). libsignal-android contains native libraries for armeabi-v7a, arm64-v8a, x86, and x86_64 Android. These are located in a Maven repository at https://build-artifacts.signal.org/libraries/maven/; for use from Gradle, add the following to your repositories block:

maven {
  name = "SignalBuildArtifacts"
  // La partie "uri()" n'est nécessaire que pour Kotlin Gradle ; Groovy Gradle accepte une chaîne simple ici.
  url = uri("https://build-artifacts.signal.org/libraries/maven/")
}

Older builds were published to Maven Central instead.

When building for Android you need both libsignal-android and libsignal-client, but the Windows and macOS libraries in libsignal-client won't automatically be excluded from your final app. You can explicitly exclude them using packaging:

android {
  // ...
  packaging {
    resources {
      excludes += setOf("libsignal_jni*.dylib", "signal_jni*.dll")
    }
  }
  // ...
}