Skip to content
KitploitKITPLOIT
HerramientasExploitsBlog
Log in
Enviar
HerramientasExploitsBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

FeedsContactoPrivacidad© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
libsignal — Hogar del Protocolo Signal, así como de otras primitivas criptográficas que hacen posible Signal. | Kitploit
Herramientas/GitHubGitHub/signalapp/libsignal
Herramientas de Cifrado/DescifradoGestión de IdentidadesCriptografíaPrivacidadSeguridad de Hardware
GitHubsignalapp/libsignal

libsignal

Hogar del Protocolo Signal, así como de otras primitivas criptográficas que hacen posible Signal.

Ver Repositorio
5.9k768177hace 1 díaRevisado por Kitploit
Compartir
# Descripción general

libsignal contiene APIs agnósticas a la plataforma utilizadas por los clientes y servidores oficiales de Signal, expuestas
como una biblioteca Java, Swift o TypeScript. Las implementaciones subyacentes están escritas en Rust:

- libsignal-protocol: Implementa el protocolo Signal, incluido el [algoritmo Double Ratchet][]. Un
  reemplazo de [libsignal-protocol-java][] y [libsignal-metadata-java][].
- signal-crypto: Primitivas criptográficas como AES-GCM. Usamos las de [RustCrypto][] cuando podemos
  pero a veces tenemos necesidades diferentes.
- device-transfer: Lógica de soporte para la función de transferencia de dispositivo a dispositivo de Signal.
- attest: Funcionalidad para la atestación remota de [enclaves SGX][] y [HSMs][] del lado del servidor.
- zkgroup: Funcionalidad para [grupos de conocimiento cero][] y características relacionadas disponibles en Signal.
- zkcredential: Una abstracción para el tipo de credenciales de conocimiento cero utilizadas por zkgroup, basada en el artículo "[The Signal Private Group System][]" de Chase, Perrin y Zaverucha.
- poksho: Utilidades para implementar pruebas de conocimiento cero (como las utilizadas por zkgroup); significa "proof-of-knowledge, stateful-hash-object".
- account-keys: Funcionalidad para usar consistentemente [PINs][] como contraseñas en el sistema Secure Value Recovery de Signal, así como otras operaciones de claves a nivel de cuenta.
- usernames: Funcionalidad para la generación, el hashing y las pruebas de nombres de usuario.
- media: Utilidades para manipular medios.

Este repositorio es utilizado por las aplicaciones cliente de Signal ([Android][], [iOS][] y [Desktop][]) así como
del lado del servidor. El uso fuera de Signal no está soportado. En particular, los productos de este repositorio
son las bibliotecas Java, Swift y TypeScript que envuelven las implementaciones subyacentes en Rust. Todas
las APIs e implementaciones están sujetas a cambios sin previo aviso, al igual que las capas de "puente" JNI, C y
add-on de Node. Sin embargo, los cambios incompatibles hacia atrás en las APIs de Java, Swift, TypeScript y
Rust que no son de puente se reflejarán en el número de versión en la medida de lo posible, incluyendo
incrementos en las versiones mínimas de herramientas soportadas.

[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


# Compilación

### Instalación del toolchain

Para compilar cualquier cosa en este repositorio debes tener [Rust](https://rust-lang.org) instalado, así como
versiones recientes de Clang, libclang, [CMake](https://cmake.org), Make, protoc, Python (3.11+),
y git.

#### Linux/Debian

En un sistema similar a Debian, puedes obtener estas dependencias adicionales a través de `apt`:

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

#### macOS

En macOS, disponemos de un script mantenido con el mejor esfuerzo posible para configurar el toolchain de Rust que puedes ejecutar con:

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

## Rust

### Primera compilación y prueba

La compilación actualmente utiliza una versión específica del compilador estable de Rust, que
será descargada automáticamente por cargo. Para compilar y probar las bibliotecas
básicas del protocolo:

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

### Herramientas adicionales de Rust

Las herramientas básicas anteriores deberían ser suficientes para la mayoría del desarrollo de libsignal en Rust.

Con el tiempo, es posible que necesites algunas herramientas adicionales de Rust como `taplo` para el formateo de código.

Siempre debes instalar cualquier herramienta de Rust que necesites y que pueda afectar la compilación desde cargo en lugar de desde tu gestor
de paquetes del sistema (por ejemplo, `apt` o `brew`). Los gestores de paquetes a veces contienen versiones desactualizadas de estas herramientas que pueden romper
la compilación con problemas de incompatibilidad.

Para instalar las principales dependencias adicionales de Rust que coincidan con las versiones que usamos, puedes ejecutar los siguientes 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

### Configuración / Ajuste de la cadena de herramientas

Para compilar para Android debes instalar varios paquetes adicionales, incluyendo un JDK,
el NDK/SDK de Android, y añadir los objetivos de Android al compilador de 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 # si necesitas salidas 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 parte "uri()" solo es necesaria para Kotlin Gradle; Groovy Gradle acepta una cadena simple aquí.
  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  # o usa `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
solo 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
Descargar herramienta

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

Sin datos de popularidad aún.

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →