Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
Strumenti/GitHubGitHub/signalapp/libsignal
Strumenti di Crittografia/DecrittografiaGestione IdentitàCrittografiaPrivacySicurezza Hardware
GitHubsignalapp/libsignal

libsignal

La casa del Signal Protocol e delle altre primitive crittografiche che rendono possibile Signal.

Vedi Repository
5.9k7681771 giorno faRevisionato da Kitploit
Condividi
# Panoramica

libsignal contiene API indipendenti dalla piattaforma utilizzate dai client e dai server ufficiali di Signal, esposte
come libreria Java, Swift o TypeScript. Le implementazioni sottostanti sono scritte in Rust:

- libsignal-protocol: implementa il protocollo Signal, incluso l'[algoritmo Double Ratchet][]. Un
  sostituto di [libsignal-protocol-java][] e [libsignal-metadata-java][].
- signal-crypto: primitive crittografiche come AES-GCM. Utilizziamo quelle di [RustCrypto][] dove possibile,
  ma a volte abbiamo esigenze diverse.
- device-transfer: logica di supporto per la funzionalità di trasferimento da dispositivo a dispositivo di Signal.
- attest: funzionalità per l'attestazione remota di [enclave SGX][] e [HSM][] lato server.
- zkgroup: funzionalità per i [gruppi a conoscenza zero][] e le relative funzionalità disponibili in Signal.
- zkcredential: un'astrazione per il tipo di credenziali a conoscenza zero utilizzate da zkgroup, basata sul paper "[The Signal Private Group System][]" di Chase, Perrin e Zaverucha.
- poksho: utilità per implementare prove a conoscenza zero (come quelle usate da zkgroup); sta per "proof-of-knowledge, stateful-hash-object".
- account-keys: funzionalità per utilizzare in modo coerente i [PIN][] come password nel sistema Secure Value Recovery di Signal, nonché altre operazioni chiave a livello di account.
- usernames: funzionalità per la generazione, l'hashing e le prove relative ai nomi utente.
- media: utilità per la manipolazione dei media.

Questo repository è utilizzato dalle app client di Signal ([Android][], [iOS][] e [Desktop][]) nonché
lato server. L'uso al di fuori di Signal non è supportato. In particolare, i prodotti di questo repository
sono le librerie Java, Swift e TypeScript che avvolgono le implementazioni Rust sottostanti. Tutte
le API e le implementazioni sono soggette a modifiche senza preavviso, così come i livelli "bridge" JNI, C e
add-on Node. Tuttavia, le modifiche incompatibili con le versioni precedenti delle API Java, Swift, TypeScript e
Rust non-bridge saranno riflesse nel numero di versione su base best-effort, incluse
le aumenti delle versioni minime degli strumenti supportati.

[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


# Compilazione

### Installazione della toolchain

Per compilare qualsiasi cosa in questo repository è necessario avere [Rust](https://rust-lang.org) installato, così
come versioni recenti di Clang, libclang, [CMake](https://cmake.org), Make, protoc, Python (3.11+)
e git.

#### Linux/Debian

Su un sistema simile a Debian, è possibile ottenere queste dipendenze aggiuntive tramite `apt`:

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

#### macOS

Su macOS, abbiamo uno script mantenuto con il miglior sforzo possibile per configurare la toolchain di Rust che puoi eseguire con:

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

## Rust

### Prima build e test

La build attualmente utilizza una versione specifica del compilatore Rust stable, che
verrà scaricata automaticamente da cargo. Per compilare e testare le librerie
di protocollo di base:

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

### Strumenti Rust aggiuntivi

Gli strumenti di base sopra dovrebbero essere sufficienti per la maggior parte dello sviluppo Rust con libsignal.

Con il tempo, potresti scoprire di aver bisogno di alcuni strumenti Rust aggiuntivi come `taplo` per la formattazione del codice.

Dovresti sempre installare tramite cargo qualsiasi strumento Rust di cui hai bisogno che possa influire sulla build, piuttosto che dal gestore di pacchetti di sistema (ad esempio `apt` o `brew`). I gestori di pacchetti a volte contengono versioni obsolete di questi strumenti che possono compromettere la build con problemi di incompatibilità.

Per installare le principali dipendenze Rust aggiuntive corrispondenti alle versioni che utilizziamo, puoi eseguire i seguenti comandi:

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

### Configurazione/Setup della Toolchain

Per compilare per Android è necessario installare diversi pacchetti aggiuntivi, tra cui un JDK,
l'Android NDK/SDK, e aggiungere i target Android al compilatore 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 hai bisogno di output 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()" è necessaria solo per Kotlin Gradle; Groovy Gradle accetta una stringa semplice qui.
  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  # oppure 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
controlla solo 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
Scarica lo strumento

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Il toolkit OSINT definitivo: grafo di indagine, punteggio di affidabilità, famiglie di alias, mappa, timeline e report. 49 moduli, oltre 400 siti, nessuna chiave API richiesta.

    851
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # App di esecuzione con un tocco GhostLock (CVE-2026-43499)

    538
  • 3

    ARTEX

    baarai/artex

    Piattaforma di penetration testing autonoma multi-agente basata su LLM con agenti planner/worker, grafi di asset e di esplorazione, registrazione del traffico MITM e retesting delle vulnerabilità.

    420
  • 4

    redforge

    cybersecurity91/redforge

    Toolkit red team lato browser con 102 strumenti offline per ricognizione, generazione di payload, attacchi alle credenziali, crittografia, codifica e reportistica dell'engagement.

    357
  • 5

    looking-glass

    anonghosty/looking-glass

    Piattaforma CSIRT che importa i report di Shadowserver in MongoDB e li riproduce come mappe interattive, analisi, risultati, avvisi e dashboard executive.

    297
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Il sistema d'azione per la cybersecurity nativa AI—dove l'intento diventa esecuzione governata, le evidenze diventano memoria operativa, e ogni operazione migliora la successiva.

    280

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →