sgn

<div align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/3551/71476533a52676b901aed0ae0ab78a9dd1cf687fd6360bdaad6e5998b944842f.png">
  <br>
  
  [![GitHub All Releases][release-img]][release]
  [![Build][workflow-img]][workflow]
  [![Issues][issues-img]][issues]
  [![Crates][crates-img]][crates]
  [![License: MIT][license-img]][license]
</div>

[crates]: https://crates.io/crates/sgn
[crates-img]: https://img.shields.io/crates/v/sgn
[release]: https://github.com/EgeBalci/sgn/releases
[release-img]: https://img.shields.io/github/v/release/EgeBalci/sgn
[downloads]: https://github.com/EgeBalci/sgn/releases
[downloads-img]: https://img.shields.io/github/downloads/EgeBalci/sgn/total?logo=github
[issues]: https://github.com/EgeBalci/sgn/issues
[issues-img]: https://img.shields.io/github/issues/EgeBalci/sgn?color=red
[license]: https://raw.githubusercontent.com/EgeBalci/sgn/master/LICENSE
[license-img]: https://img.shields.io/github/license/EgeBalci/sgn.svg
[google-cloud-shell]: https://console.cloud.google.com/cloudshell/open?git_repo=https://github.com/EgeBalci/sgn&tutorial=README.md
[workflow-img]: https://github.com/EgeBalci/sgn/actions/workflows/main.yml/badge.svg
[workflow]: https://github.com/EgeBalci/sgn/actions/workflows/main.yml
[fe-article]: https://www.fireeye.com/blog/threat-research/2019/10/shikata-ga-nai-encoder-still-going-strong.html
[lfsr]: https://en.wikipedia.org/wiki/Linear-feedback_shift_register


SGN ist ein polymorpher Binärcode-Encoder für offensive Sicherheitszwecke, etwa um statisch nicht erkennbare Binär-Payloads zu erzeugen. Er verwendet eine additive Rückkopplungsschleife, um gegebene Binärbefehle ähnlich wie [LFSR][lfsr] zu kodieren. Dieses Projekt ist die Neuimplementierung des [ursprünglichen Shikata ga nai](https://github.com/rapid7/metasploit-framework/blob/master/modules/encoders/x86/shikata_ga_nai.rb) in Go mit vielen Verbesserungen.


> [!WARNING]  
> Das Projekt wurde kürzlich nach Rust portiert. Dieser Port behält das ursprüngliche Design und Verhalten bei, ersetzt jedoch den [Keystone](https://www.keystone-engine.org/)-Textassembler durch den reinen Rust-[`iced-x86`](https://docs.rs/iced-x86)-Assembler, sodass **keine nativen Bibliotheksabhängigkeiten** bestehen — er lässt sich mit einem einfachen `cargo build` erstellen. Im [sgn-go](https://github.com/EgeBalci/amber/tree/sgn-go)-Zweig finden Sie die alte Go-Version.


## Warum?
Für die Offensive-Security-Community gilt die ursprüngliche Implementierung des Shikata-ga-nai-Encoders als bester Shellcode-Encoder (bisher). Im Laufe der Jahre fanden Sicherheitsforscher jedoch mehrere Fallstricke beim statischen Erkennen des Decoder-Stubs (verwandte Arbeit: [FireEye-Artikel][fe-article]). Das Hauptmotiv für dieses Projekt war es, einen besseren Encoder zu schaffen, der die übergebenen Binärdaten so weit kodiert, dass sie mit völlig zufälligen Daten identisch sind und das Vorhandensein eines Decoders nicht erkannt werden kann.

- [x] 64-Bit-Unterstützung. `Finally properly encoded x64 shellcodes !`
- [x] Neuer kleinerer Decoder-Stub. `LFSR key reduced to 1 byte`
- [x] Kodierter Stub mit pseudozufälligem Schema. `Decoder stub is also encoded with a psudo random schema`
- [x] Keine sichtbare Schleifenbedingung `Stub decodes itself WITHOUT using any loop conditions !!` 
- [x] Verschleierung des Decoder-Stubs. `Random garbage instruction generator added with keystone`
- [x] Option für sichere Register. `Non of the registers are clobbered (optional preable, may reduce polimorphism)` 

## So funktioniert es

Jeder Kodierungsdurchlauf:

1. (optional) fügt ein Register-Wiederherstellungs-Suffix an (sicherer Modus);
2. stellt zufällige, werterhaltende Garbage-Anweisungen voran;
3. verschlüsselt den Payload mit der **ADFL**-Chiffre (additive Rückkopplungsschleife) und
   stellt einen schleifenfreien Decoder-Stub voran, der dies zur Laufzeit rückgängig macht;
4. sofern nicht `--plain` angegeben ist, verschlüsselt es den Stub selbst mit einer zufälligen, pro Lauf erzeugten **Schema-
   Chiffre** (`XOR/ADD/SUB/ROL/ROR/NOT` über DWORDs) und stellt einen selbstlokalisierenden
   Schema-Decoder voran, sodass sogar der Decoder wie Zufallsdaten aussieht;
5. wiederholt optional `--enc`-Mal mit neuen Seeds;
6. (optional) stellt ein Register-Sicherungs-Präfix voran (sicherer Modus).

## Installation
```sh
cargo install sgn
```
Sie können die vorkompilierten Binärdateien auch [HIER][release] erhalten.

**Verwendung**

`-h` ist ziemlich selbsterklärend; verwenden Sie `-v`, wenn Sie sehen möchten, was hinter den Kulissen passiert `( ͡° ͜ʖ ͡°)_/¯`
<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/3551/d7536cd852e99bfd9dfcfb21e7d050a763a678d5bb65a6db80e89d4c4f5a3a8b.gif">
</p>


```
       __   _ __        __                               _ 
  ___ / /  (_) /_____ _/ /____ _  ___ ____ _  ___  ___ _(_)
 (_-</ _ \/ /  '_/ _ `/ __/ _ `/ / _ `/ _ `/ / _ \/ _ `/ / 
/___/_//_/_/_/\_\\_,_/\__/\_,_/  \_, /\_,_/ /_//_/\_,_/_/  
========[Author:-Ege-Balcı-]====/___/=======v2.0.2=========  
    ┻━┻ ︵ヽ(`Д´)ﾉ︵ ┻━┻           (ノ ゜Д゜)ノ ︵ 仕方がない

sgn [OPTIONS]

Options:
  -i, --input <INPUT>        Input binary path
  -o, --out <OUT>            Encoded output binary name (default: <input>.sgn)
  -a, --arch <ARCH>          Binary architecture (32/64) [default: 64]
  -c, --enc <ENC>            Number of times to encode the binary [default: 1]
  -M, --max <MAX>            Maximum bytes per garbage block [default: 50]
      --plain                Do not encode the decoder stub
      --ascii                Generate a fully ASCII-printable payload (slow)
  -S, --safe                 Preserve all register values (no clobber)
      --badchars <BADCHARS>  Avoid these bytes, hex format (e.g. \x00\x0a)
  -v, --verbose              Verbose mode
  -h, --help                 Print help
  -V, --version              Print version

```

Beispiel:

```sh
sgn -i shellcode.bin -o encoded.bin -a 64 --badchars '\x00\x0a\x0d'
```

## Ausführungsablauf

Das folgende Bild ist ein grundlegendes Ablaufdiagramm für den Encoder. Beachten Sie jedoch, dass sich Größen, Positionen und Reihenfolgen der Garbage-Anweisungen, Decoder und Schema-Decoder bei jeder Iteration ändern.

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/3551/1db7423a884b71b9464011392860cb7f32e6f9e3652f5cd26ed443e5297f52fc.png">
</p>

Das LFSR selbst ist im Hinblick auf den Wahrscheinlichkeitsraum ziemlich leistungsfähig. Für noch mehr Polymorphismus werden am Anfang des unkodierten Roh-Payloads Garbage-Anweisungen angehängt. Das folgende Bild zeigt die Begleitmatrix des charakteristischen Polynoms des LFSR und, wenn der Seed als Spaltenvektor angegeben wird, den Zustand des Registers in der Fibonacci-Konfiguration nach k Schritten.

<p align="center">
  <img src="https://raw.githubusercontent.com/egebalci/sgn/HEAD/.github/matrices.svg">
</p>


## Verwendung als Bibliothek

```rust
use sgn::Encoder;

let shellcode = std::fs::read("payload.bin")?;
let mut encoder = sgn::Encoder::new(64)?;
let encoded = encoder.encode(&shellcode)?;
println!("encoded {} bytes", encoded.len());
```

Siehe `examples/encode_binary.rs`.

## Testen

```sh
cargo test
```

Die Suite enthält Unit-Tests für den Chiffre-Roundtrip sowie **echte Ausführungstests**: Kodierter x64-Shellcode wird als ausführbar gemappt und prozessintern ausgeführt, und x86-Shellcode wird über eine `cc -m32`-Hilfsharness ausgeführt (wird automatisch übersprungen, wenn keine 32-Bit-Toolchain vorhanden ist). Beide Architekturen werden in den Modi Plain, Schema, mehrschichtig und Safe-Register getestet, einschließlich einer randomisierten Stress-Schleife.

## Anmerkungen zum Port

* Die Anweisungserzeugung verwendet die typisierte Assembler-API von `iced-x86` anstelle von Keystone-Assemblytext; die Decoder-Stubs wurden um RIP-relative Adressierung (x64) und ein `call/pop`-Zweipass-Schema (x86) neu aufgebaut.
* Die Schema-Chiffre wird direkt in der nativen Little-Endian-DWORD-Sicht der CPU ausgedrückt, was äquivalent, aber klarer ist als die gemischte Big-/Little-Endian-Arithmetik des Originals.
* Nicht mehr verwendeter Code aus dem Original (die ungenutzte, etwa 3000 Zeilen umfassende Befehlssatztabelle und der „unsafe garbage“-Generator, der von nichts aufgerufen wurde) wurde entfernt.
* Kleinere Korrekturen: `random_byte` umfasst jetzt den vollständigen Bereich `0..=255`, und das Garbage-Größenbudget (`--max`) wird konsistent als Obergrenze pro Block angewendet.