signalapp/libsignalLar do Signal Protocol, bem como de outros primitivos criptográficos que tornam o Signal possível.
libsignal contém APIs agnósticas de plataforma usadas pelos clientes e servidores oficiais do Signal, expostas como uma biblioteca Java, Swift ou TypeScript. As implementações subjacentes são escritas em Rust:
Este repositório é usado pelos aplicativos cliente do Signal (Android, iOS e Desktop) bem como do lado do servidor. O uso fora do Signal não é suportado. Em particular, os produtos deste repositório são as bibliotecas Java, Swift e TypeScript que envolvem as implementações subjacentes em Rust. Todas as APIs e implementações estão sujeitas a alterações sem aviso prévio, assim como as camadas de "ponte" JNI, C e add-on do Node. No entanto, alterações incompatíveis com versões anteriores nas APIs Java, Swift, TypeScript e Rust não-ponte serão refletidas no número da versão na medida do possível, incluindo aumentos nas versões mínimas de ferramentas suportadas.
Para compilar qualquer coisa neste repositório você deve ter o Rust instalado, bem como versões recentes do Clang, libclang, CMake, Make, protoc, Python (3.9+), e git.
Em um sistema similar ao Debian, você pode obter essas dependências extras através do apt:
$ apt-get install clang libclang-dev cmake make protobuf-compiler libprotobuf-dev python3 git
No macOS, temos um script mantido na medida do possível para configurar o toolchain do Rust que você pode executar com:
$ bin/mac_setup.sh
A compilação atualmente usa uma versão específica do compilador estável do Rust, que será baixada automaticamente pelo cargo. Para compilar e testar as bibliotecas básicas do protocolo:
$ cargo build
...
$ cargo test
...
As ferramentas básicas acima devem ser suficientes para a maioria do desenvolvimento em Rust do libsignal.
Eventualmente, você pode descobrir que precisa de algumas ferramentas Rust adicionais como taplo para formatação de código.
Você deve sempre instalar quaisquer ferramentas Rust que possam afetar a compilação a partir do cargo, em vez de
usar o gerenciador de pacotes do seu sistema (por exemplo, apt ou brew). Os gerenciadores de pacotes às vezes contêm versões desatualizadas dessas ferramentas que podem quebrar
a compilação com problemas de incompatibilidade (especialmente o cbindgen).
Para instalar as principais dependências extras do Rust correspondentes às versões que usamos, você pode executar os seguintes comandos:
$ 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
Para compilar para Android você deve instalar vários pacotes adicionais, incluindo um JDK, o Android NDK/SDK, e adicionar os alvos do Android ao compilador Rust, usando
rustup target add armv7-linux-androideabi aarch64-linux-android i686-linux-android x86_64-linux-android
Nossa versão de JDK oficialmente suportada para compilações Android é o JDK 21, então certifique-se de instalar, por exemplo, o OpenJDK 21, e então apontar JAVA_HOME para ele.
Você pode fazer isso facilmente no macOS via:
export JAVA_HOME=$(/usr/libexec/java_home -v 21)
No Linux, a forma de fazer isso varia por distribuição. Para distribuições baseadas em Debian como o Ubuntu, você pode usar:
sudo update-alternatives --config java
Também mantemos um arquivo .tools_version para uso com gerenciadores de versão em tempo de execução.
Para compilar o jar e o aar Java/Android, e executar os testes:
$ cd java
$ ./gradlew test
$ ./gradlew build # if you need AAR outputs
Você pode passar -P debugLevelLogs para o Gradle para compilar sem filtrar os logs de nível debug e verbose
do Rust, e -P jniTypeTagging para habilitar verificações adicionais no código de ponte JNI do Rust.
Alternativamente, um sistema de compilação usando Docker está disponível:
$ cd java
$ make
Ao expor novas APIs para Java, você precisará executar rust/bridge/jni/bin/gen_java_decl.py além
de recompilar. Isso requer a instalação da ferramenta Rust cbindgen, conforme detalhado acima.
O Signal publica pacotes Java para seu próprio uso, sob os nomes org.signal:libsignal-server,
org.signal:libsignal-client e org.signal:libsignal-android. libsignal-client e libsignal-server
contêm bibliotecas nativas para Linux x86_64 com sabor Debian, bem como Windows (x86_64) e macOS
(x86_64 e arm64). libsignal-android contém bibliotecas nativas para armeabi-v7a, arm64-v8a, x86 e
x86_64 Android. Estas estão localizadas em um repositório Maven em
https://build-artifacts.signal.org/libraries/maven/; para uso a partir do Gradle, adicione o seguinte ao seu
bloco 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/")
}
Compilações mais antigas eram publicadas no Maven Central.
Ao compilar para Android você precisa de ambas libsignal-android e libsignal-client, mas as bibliotecas
Windows e macOS em libsignal-client não serão automaticamente excluídas do seu aplicativo final. Você pode
excluí-las explicitamente usando packaging:
android {
// ...
packaging {
resources {
excludes += setOf("libsignal_jni*.dylib", "signal_jni*.dll")
}
}
// ...
}
Você pode adicionalmente excluir libsignal_jni_testing.so se não planeja usar nenhuma das APIs
destinadas a testes de cliente.
O arquivo gradle.properties do Signal-Android tem uma linha comentada para incluir o libsignal como parte da compilação. Descomente-a e ajuste o caminho; opcionalmente, você pode restringir as arquiteturas para as quais deseja compilar adicionando androidArchs=aarch64 ao gradle.properties do libsignal. (O conjunto de arquiteturas reconhecidas está em java/build_jni.sh.) Se você estiver usando uma IDE, precisará reimportar a estrutura do Gradle neste ponto. Quando terminar, reverta as alterações no gradle.properties do aplicativo Android e reimporte mais uma vez.
Observe que isso não importa as partes em Rust do projeto para a IDE. Fazer isso em uma IDE multilinguagem como o IDEA é possível, mas complicado; a partir de 2025, a maneira mais confiável de fazer isso é abrir o projeto Android primeiro, adicionar o diretório raiz do repositório libsignal como projeto Rust em segundo lugar (incluindo apenas o diretório de nível superior), e só então fazer as alterações no gradle.properties.
Para aprender sobre o processo de compilação do Swift, veja swift/README.md
Você precisará do Node instalado para compilar. Se você tiver o nvm, pode executar nvm use para selecionar uma
versão apropriada automaticamente.
Usamos npm como nosso gerenciador de pacotes, e um script Python para controlar a compilação da biblioteca Rust, acessível como npm run build.
$ cd node
$ nvm use
$ npm install
$ npm run build
$ npm run tsc
$ npm run test
Ao testar alterações localmente, você pode usar npm run build para fazer uma recompilação incremental da biblioteca Rust. Alternativamente, npm run build-with-debug-level-logs irá recompilar sem filtrar os logs de nível debug e verbose.
Ao expor novas APIs para o Node, você precisará executar just generate-node além
de recompilar.
O Signal publica o pacote NPM @signalapp/libsignal-client para seu próprio uso, incluindo bibliotecas
nativas para Windows, macOS e Linux com sabor Debian. Compilações x64 e arm64 estão incluídas para
todas as três plataformas, mas as compilações arm64 para Windows e Linux são consideradas experimentais, já que
não há compilações oficiais do Signal para essas arquiteturas.
Depois de executar todos os comandos de compilação acima, ajuste a dependência @signalapp/libsignal-client no package.json do aplicativo Desktop para "link:path/to/libsignal/node" e execute pnpm install. Quando terminar, reverta as alterações no package.json e execute pnpm install novamente.
O Signal aceita contribuições externas para este projeto. No entanto, a menos que a alteração seja simples e facilmente compreendida, por exemplo corrigir um bug ou problema de portabilidade, adicionar um novo teste, ou melhorar o desempenho, primeiro abra uma issue para discutir a alteração pretendida, pois nem todas as alterações podem ser aceitas.
Contribuições que não serão usadas diretamente por um dos aplicativos cliente oficiais do Signal ainda podem ser consideradas, mas apenas se não representarem um ônus de manutenção indevido ou conflitarem com os objetivos do projeto.
Assinar um CLA (Contributor License Agreement) é obrigatório para todas as contribuições.
Você pode executar o formatador em todo o projeto executando:
just format-all
Você pode executar testes mais extensivos, bem como linters e clippy, executando:
just check-pre-commit
Ao fazer um PR que ajusta dependências, você precisará regenerar nossos arquivos de agradecimentos. Veja acknowledgments/README.md.
Esta distribuição inclui software criptográfico. O país no qual você reside atualmente pode ter restrições sobre a importação, posse, uso e/ou reexportação para outro país, de software de criptografia. ANTES de usar qualquer software de criptografia, verifique as leis, regulamentos e políticas do seu país relativas à importação, posse ou uso, e reexportação de software de criptografia, para ver se isso é permitido. Veja http://www.wassenaar.org/ para mais informações.
O Departamento de Comércio do Governo dos EUA, Bureau of Industry and Security (BIS), classificou este software como Export Commodity Control Number (ECCN) 5D002.C.1, que inclui software de segurança da informação que usa ou executa funções criptográficas com algoritmos assimétricos. A forma e a maneira desta distribuição a tornam elegível para exportação sob a exceção License Exception ENC Technology Software Unrestricted (TSU) (veja o BIS Export Administration Regulations, Seção 740.13) tanto para código objeto quanto para código-fonte.
Copyright 2020-2026 Signal Messenger, LLC
Licenciado sob a GNU AGPLv3: https://www.gnu.org/licenses/agpl-3.0.html