
Abrite le Signal Protocol ainsi que d'autres primitives cryptographiques qui rendent Signal possible.
# Aperçu
libsignal contient des API indépendantes de la plateforme utilisées par les clients et serveurs officiels de Signal, 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 de [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 d'appareil à appareil 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é 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é de génération, de hachage et de preuve de noms d'utilisateur.
- media : Utilitaires pour manipuler des 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 d'être modifiées sans préavis, tout comme les couches « pont » JNI, C et
module complémentaire Node. Cependant, les changements rétro-incompatibles apportés aux API Java, Swift, TypeScript et
Rust hors 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.
[Double Ratchet algorithm]: https://signal.org/docs/
[libsignal-protocol-java]: https://github.com/signalapp/libsignal-protocol-java
[libsignal-metadata-java]: https://github.com/signalapp/libsignal-metadata-java
[RustCrypto]: https://github.com/RustCrypto
[Noise protocol]: http://noiseprotocol.org/
[SGX enclaves]: https://www.intel.com/content/www/us/en/architecture-and-technology/software-guard-extensions.html
[HSMs]: https://en.wikipedia.org/wiki/Hardware_security_module
[zero-knowledge groups]: https://signal.org/blog/signal-private-group-system/
[The Signal Private Group System]: https://eprint.iacr.org/2019/1416.pdf
[PINs]: https://signal.org/blog/signal-pins/
[Android]: https://github.com/signalapp/Signal-Android
[iOS]: https://github.com/signalapp/Signal-iOS
[Desktop]: https://github.com/signalapp/Signal-Desktop
# Compilation
### Installation de la chaîne d'outils
Pour compiler quoi que ce soit dans ce dépôt, vous devez avoir [Rust](https://rust-lang.org) installé, ainsi
que des versions récentes de Clang, libclang, [CMake](https://cmake.org), Make, protoc, Python (3.11+),
et git.
#### Linux/Debian
Sur un système de type Debian, vous pouvez obtenir ces dépendances supplémentaires via `apt` :
```shell
$ 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 :
```shell
$ 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 :
```shell
$ 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 :
```shell
$ 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:
```shell
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:
```shell
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:
```shell
$ 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:
```shell
$ 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](https://central.sonatype.org) 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")
}
}
// ...
}
```
You can additionally exclude `libsignal_jni_testing.so` if you do not plan to use any of the APIs
intended for client testing.
### Testing a local build with Signal-Android
The Signal-Android gradle.properties file has a commented-out line to include libsignal as part of the build. Uncomment that and adjust the path; optionally, you can restrict the architectures you want to build for by adding `androidArchs=aarch64` to *libsignal's* gradle.properties. (The set of recognized architectures is in java/build_jni.sh.) If you're using an IDE, you'll need to re-import the Gradle structure at this point. When you're done, revert the changes to the Android app's gradle.properties and re-import once more.
Note that this does not import the *Rust* parts of the project into the IDE. Doing that in a multi-language IDE like IDEA is possible, but finicky; as of 2025 the most reliable way to do it is to open the Android project first, add the libsignal repo root directory as a Rust project second (only including the top-level directory), and only then make the changes to gradle.properties.
## Swift
To learn about the Swift build process see [``swift/README.md``](https://github.com/signalapp/libsignal/blob/main/swift)
## Node
You'll need Node installed to build. If you have [nvm][], you can run `nvm use` to select an
appropriate version automatically.
We use `pnpm` as our package manager, and a Python script to control building the Rust library, accessible as `pnpm run build`.
```shell
$ cd node
$ nvm use
$ npm install -g pnpm # ou utiliser `npx pnpm`
$ pnpm install
$ pnpm run build
$ pnpm run tsc
$ pnpm run test
```
When testing changes locally, you can use `pnpm run build` to do an incremental rebuild of the Rust library. Alternately, `pnpm run build-with-debug-level-logs` will rebuild without filtering out debug- and verbose-level logs.
When exposing new APIs to Node, you will need to run `just generate-node` in
addition to rebuilding.
[nvm]: https://github.com/nvm-sh/nvm
### NPM
Signal publishes the NPM package `@signalapp/libsignal-client` for its own use, including native
libraries for Windows, macOS, and Debian-flavored Linux. Both x64 and arm64 builds are included for
all three platforms, but the arm64 builds for Windows and Linux are considered experimental, since
there are no official builds of Signal for those architectures.
### Testing a local build with Signal-Desktop
After running all the build commands above, adjust the `@signalapp/libsignal-client` dependency in the Desktop app's package.json to "link:path/to/libsignal/node" and run `pnpm install`. When you're done, revert the changes to package.json and run `pnpm install` again.
# Contributions
Signal does accept external contributions to this project. However unless the change is
simple and easily understood, for example fixing a bug or portability issue, adding a new
test, or improving performance, first open an issue to discuss your intended change as not
all changes can be accepted.
Contributions that will not be used directly by one of Signal's official client apps may still be
considered, but only if they do not pose an undue maintenance burden or conflict with the goals of
the project.
Signing a [CLA (Contributor License Agreement)](https://signal.org/cla/) is required for all contributions.
## Code Formatting and Acknowledgments
You can run the styler on the entire project by running:
```shell
just format-all
```
You can run more extensive tests as well as linters and clippy by running:
```shell
just check-pre-commit
```
When making a PR that adjusts dependencies, you'll need to regenerate our acknowledgments files. See [``acknowledgments/README.md``](https://github.com/signalapp/libsignal/blob/main/acknowledgments).
# Legal things
## Cryptography Notice
This distribution includes cryptographic software. The country in which you currently reside may have restrictions on
the import, possession, use, and/or re-export to another country, of encryption software. BEFORE using any encryption
software, please check your country's laws, regulations and policies concerning the import, possession, or use, and
re-export of encryption software, to see if this is permitted. See <http://www.wassenaar.org/> for more information.
The U.S. Government Department of Commerce, Bureau of Industry and Security (BIS), has classified this software as
Export Commodity Control Number (ECCN) 5D002.C.1, which includes information security software using or performing
cryptographic functions with asymmetric algorithms. The form and manner of this distribution makes it eligible for
export under the License Exception ENC Technology Software Unrestricted (TSU) exception (see the BIS Export
Administration Regulations, Section 740.13) for both object code and source code.
## License
Copyright 2020-2026 Signal Messenger, LLC
Licensed under the GNU AGPLv3: https://www.gnu.org/licenses/agpl-3.0.html