Überblick

libsignal enthält plattformunabhängige APIs, die von den offiziellen Signal-Clients und -Servern verwendet werden und als Java-, Swift- oder TypeScript-Bibliothek bereitgestellt werden. Die zugrunde liegenden Implementierungen sind in Rust geschrieben:

libsignal-protocol: Implementiert das Signal-Protokoll, einschließlich des Double Ratchet algorithm. Ein Ersatz für libsignal-protocol-java und libsignal-metadata-java.
signal-crypto: Kryptografische Primitive wie AES-GCM. Wir verwenden RustCrypto, wo wir können, haben aber manchmal abweichende Anforderungen.
device-transfer: Unterstützungslogik für Signals Gerät-zu-Gerät-Übertragungsfunktion.
attest: Funktionalität für Remote-Attestierung von SGX enclaves und serverseitigen HSMs.
zkgroup: Funktionalität für zero-knowledge groups und verwandte Funktionen, die in Signal verfügbar sind.
zkcredential: Eine Abstraktion für die Art von Zero-Knowledge-Credentials, die von zkgroup verwendet werden, basierend auf dem Paper "The Signal Private Group System" von Chase, Perrin und Zaverucha.
poksho: Hilfsprogramme zur Implementierung von Zero-Knowledge-Beweisen (wie sie von zkgroup verwendet werden); steht für "proof-of-knowledge, stateful-hash-object".
account-keys: Funktionalität zur konsistenten Verwendung von PINs als Passwörter in Signals Secure Value Recovery-System sowie für andere kontoweite Schlüsseloperationen.
usernames: Funktionalität für Benutzernamengenerierung, Hashing und Beweise.
media: Hilfsprogramme zur Bearbeitung von Medien.

Dieses Repository wird von den Signal-Client-Apps (Android, iOS und Desktop) sowie serverseitig verwendet. Die Verwendung außerhalb von Signal wird nicht unterstützt. Insbesondere sind die Produkte dieses Repositorys die Java-, Swift- und TypeScript-Bibliotheken, die die zugrunde liegenden Rust-Implementierungen umhüllen. Alle APIs und Implementierungen können ohne Vorankündigung geändert werden, ebenso wie die JNI-, C- und Node-Add-on-"Bridge"-Schichten. Rückwärtsinkompatible Änderungen an den Java-, Swift-, TypeScript- und Nicht-Bridge-Rust-APIs werden jedoch nach bestem Bemühen in der Versionsnummer widergespiegelt, einschließlich Erhöhungen der minimal unterstützten Tool-Versionen.

Erstellen

Installation der Toolchain

Um irgendetwas in diesem Repository zu erstellen, muss Rust installiert sein, ebenso wie aktuelle Versionen von Clang, libclang, CMake, Make, protoc, Python (3.9+) und git.

Linux/Debian

Auf einem Debian-ähnlichen System können diese zusätzlichen Abhängigkeiten über apt bezogen werden:

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

macOS

Unter macOS gibt es ein nach bestem Bemühen gepflegtes Skript zur Einrichtung der Rust-Toolchain, das Sie folgendermaßen ausführen können:

$ bin/mac_setup.sh

Rust

Erster Build und Test

Der Build verwendet derzeit eine bestimmte Version des stabilen Rust-Compilers, die automatisch von cargo heruntergeladen wird. Um die grundlegenden Protokoll- Bibliotheken zu bauen und zu testen:

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

Zusätzliche Rust-Tools

Die grundlegenden Tools oben sollten dich für die meisten libsignal-Rust-Entwicklungen einrichten.

Mit der Zeit stellst du möglicherweise fest, dass du einige zusätzliche Rust-Tools wie taplo für die Codeformatierung benötigst.

Du solltest alle Rust-Tools, die du benötigst und die den Build beeinflussen könnten, immer über cargo installieren und nicht über deinen System-Paketmanager (z. B. apt oder brew). Paketmanager enthalten manchmal veraltete Versionen dieser Tools, die den Build durch Inkompatibilitätsprobleme beschädigen können.

Um die wichtigsten zusätzlichen Rust-Abhängigkeiten passend zu den von uns verwendeten Versionen zu installieren, kannst du die folgenden Befehle ausführen:

$ 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

Toolchain-Einrichtung / Konfiguration

Um für Android zu bauen, müssen Sie mehrere zusätzliche Pakete installieren, darunter ein JDK, das Android NDK/SDK, und die Android-Ziele zum Rust-Compiler hinzufügen, mit

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 # wenn Sie AAR-Ausgaben benötigen

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"
  // Der "uri()"-Teil ist nur für Kotlin Gradle erforderlich; Groovy Gradle akzeptiert hier einen einfachen String.
  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")
    }
  }
  // ...
}

You can additionally exclude libsignal_jni_testing.so if you do not plan to use any of the APIs intended for client testing.

libsignal

Beliebteste