Skip to content
KitploitKITPLOIT
FerramentasExploitsBlog
Log in
Enviar
FerramentasExploitsBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

FeedsContatoPrivacidade© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
libsignal — Lar do Signal Protocol, bem como de outros primitivos criptográficos que tornam o Signal possível. | Kitploit
Ferramentas/GitHubGitHub/signalapp/libsignal
Ferramentas de Criptografia/DescriptografiaGerenciamento de IdentidadesCriptografiaPrivacidadeSegurança de Hardware
GitHubsignalapp/libsignal

libsignal

Lar do Signal Protocol, bem como de outros primitivos criptográficos que tornam o Signal possível.

Ver Repositório
5.9k768177há 1 diaRevisado pelo Kitploit
Compartilhar
# Visão geral

libsignal contém APIs independentes 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:

- libsignal-protocol: Implementa o protocolo Signal, incluindo o [algoritmo Double Ratchet][Double Ratchet algorithm]. Um
  substituto para [libsignal-protocol-java][] e [libsignal-metadata-java][].
- signal-crypto: Primitivas criptográficas como AES-GCM. Usamos as do [RustCrypto][] sempre que possível,
  mas às vezes temos necessidades diferentes.
- device-transfer: Lógica de suporte para o recurso de transferência de dispositivo para dispositivo do Signal.
- attest: Funcionalidade para atestação remota de [enclaves SGX][SGX enclaves] e [HSMs][] do lado do servidor.
- zkgroup: Funcionalidade para [grupos de conhecimento zero][zero-knowledge groups] e recursos relacionados disponíveis no Signal.
- zkcredential: Uma abstração para o tipo de credenciais de conhecimento zero usadas pelo zkgroup, baseada no artigo "[The Signal Private Group System][]" de Chase, Perrin e Zaverucha.
- poksho: Utilitários para implementar provas de conhecimento zero (como as usadas pelo zkgroup); significa "proof-of-knowledge, stateful-hash-object".
- account-keys: Funcionalidade para usar consistentemente [PINs][] como senhas no sistema Secure Value Recovery do Signal, bem como outras operações de chave em toda a conta.
- usernames: Funcionalidade para geração, hashing e provas de nomes de usuário.
- media: Utilitários para manipulação de mídia.

Este repositório é usado pelos aplicativos clientes 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 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 de versão na medida do possível, incluindo
aumentos nas versões mínimas de ferramentas suportadas.

[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


# Compilação

### Instalação do Toolchain

Para compilar qualquer coisa neste repositório, você deve ter o [Rust](https://rust-lang.org) instalado, bem
como versões recentes do Clang, libclang, [CMake](https://cmake.org), Make, protoc, Python (3.11+)
e git.

#### Linux/Debian

Em um sistema semelhante ao Debian, você pode obter essas dependências extras através do `apt`:

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

#### macOS

No macOS, temos um script mantido com o melhor esforço possível para configurar o toolchain do Rust, que você pode executar com:

```shell
$ bin/mac_setup.sh
```

## Rust

### Primeira Compilação e Teste

A compilação atualmente usa uma versão específica do compilador Rust stable, que
será baixada automaticamente pelo cargo. Para compilar e testar as bibliotecas
básicas de protocolo:

```shell
$ cargo build
...
$ cargo test
...
```

### Ferramentas Rust Adicionais

As ferramentas básicas acima devem ser suficientes para a maioria do desenvolvimento em Rust com 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 necessárias que possam afetar a compilação através 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.

Para instalar as principais dependências extras do Rust correspondentes às versões que usamos, você pode executar os seguintes comandos:

```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

### Configuração / Configuração do Toolchain

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```

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 # se você precisar de saídas 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"
  // A parte "uri()" só é necessária para Kotlin Gradle; Groovy Gradle aceita uma string simples aqui.
  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 use `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
apenas format-all
```

You can run more extensive tests as well as linters and clippy by running:

```shell
apenas verifique o pré-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
Baixar ferramenta

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 O kit definitivo de OSINT: grafo de investigação, pontuação de confiança, famílias de alias, mapa, linha do tempo e relatórios. 49 módulos, mais de 400 sites, sem necessidade de chaves de API.

    851
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicativo de Execução em Um Toque GhostLock (CVE-2026-43499)

    538
  • 3

    ARTEX

    baarai/artex

    Plataforma autônoma de testes de penetração multiagente com LLM, com agentes planejador/executor, grafos de ativos e de exploração, registro de tráfego MITM e reteste de vulnerabilidades.

    420
  • 4

    redforge

    cybersecurity91/redforge

    Kit de ferramentas de red team do lado do navegador com 102 ferramentas offline para reconhecimento, geração de payloads, ataques a credenciais, criptografia, codificação e relatórios de engajamento.

    357
  • 5

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingere relatórios do Shadowserver no MongoDB e os reproduz como mapas interativos, análises, descobertas, avisos e painéis executivos.

    297
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    O sistema de ação para cibersegurança nativa em IA—onde a intenção se torna execução governada, a evidência se torna memória operacional, e cada operação melhora a próxima.

    280

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →