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 एक polymorphic बाइनरी एन्कोडर है जो आक्रामक सुरक्षा (offensive security) उद्देश्यों के लिए है, जैसे कि स्टैटिक रूप से अज्ञेय (undetectable) बाइनरी पेलोड उत्पन्न करना। यह दिए गए बाइनरी निर्देशों को [LFSR][lfsr] के समान एन्कोड करने के लिए एक additive feedback loop का उपयोग करता है। यह परियोजना [मूल Shikata ga nai](https://github.com/rapid7/metasploit-framework/blob/master/modules/encoders/x86/shikata_ga_nai.rb) का golang में कई सुधारों के साथ पुनःकार्यान्वयन (reimplementation) है।


> [!WARNING]  
> यह परियोजना हाल ही में Rust में पोर्ट की गई है। यह पोर्ट मूल डिज़ाइन और व्यवहार को बनाए रखता है, लेकिन [keystone](https://www.keystone-engine.org/) टेक्स्ट असेंबलर को शुद्ध-Rust [`iced-x86`](https://docs.rs/iced-x86) असेंबलर से बदल देता है, इसलिए **कोई native library निर्भरता नहीं है** — यह एक साधारण `cargo build` से बिल्ड हो जाता है। पुराने Go संस्करण के लिए [sgn-go](https://github.com/EgeBalci/amber/tree/sgn-go) शाखा देखें।


## क्यों?
आक्रामक सुरक्षा समुदाय के लिए, shikata ga nai एन्कोडर का मूल कार्यान्वयन अब तक का सबसे अच्छा shellcode एन्कोडर माना जाता है (until now)। लेकिन वर्षों से सुरक्षा शोधकर्ताओं ने डिकोडर स्टब (decoder stub) का स्टैटिक रूप से पता लगाने के लिए कई कमियाँ खोजी हैं (संबंधित कार्य [FireEye लेख][fe-article])। इस परियोजना का मुख्य उद्देश्य एक बेहतर एन्कोडर बनाना था जो दिए गए बाइनरी को इस हद तक एन्कोड करे कि वह पूरी तरह से यादृच्छिक डेटा के समान हो और डिकोडर की उपस्थिति का पता लगाना संभव न हो। 

- [x] 64 बिट समर्थन। `आखिरकार x64 shellcode सही ढंग से एन्कोड किए गए!`
- [x] नया छोटा डिकोडर स्टब। `LFSR कुंजी घटाकर 1 बाइट कर दी गई`
- [x] छद्म-यादृच्छिक स्कीमा के साथ एन्कोडेड स्टब। `डिकोडर स्टब भी छद्म-यादृच्छिक स्कीमा के साथ एन्कोड किया गया है`
- [x] कोई दृश्य लूप शर्त नहीं `स्टब बिना किसी लूप शर्त के खुद को डिकोड करता है!!` 
- [x] डिकोडर स्टब अस्पष्टीकरण। `keystone के साथ यादृच्छिक कचरा निर्देश जनरेटर जोड़ा गया`
- [x] सुरक्षित रजिस्टर विकल्प। `कोई भी रजिस्टर क्लोबर नहीं होता (वैकल्पिक प्रस्तावना, polymorphism कम कर सकती है)` 

## यह कैसे काम करता है

प्रत्येक एन्कोडिंग पास:

1. (वैकल्पिक) एक रजिस्टर-पुनर्स्थापना प्रत्यय (safe mode) जोड़ता है;
2. शुरुआत में यादृच्छिक, मान-संरक्षण करने वाले कचरा निर्देश जोड़ता है;
3. पेलोड को **ADFL** (additive feedback loop) सिफर से साइफर करता है और
   एक लूप-मुक्त डिकोडर स्टब जोड़ता है जो इसे रनटाइम पर उलट देता है;
4. जब तक `--plain` न दिया जाए, स्टब को स्वयं एक यादृच्छिक प्रति-रन **स्कीमा
   सिफर** (`XOR/ADD/SUB/ROL/ROR/NOT` DWORDs पर) से एन्क्रिप्ट करता है और एक
   स्व-स्थान-खोज (self-locating) स्कीमा डिकोडर जोड़ता है, ताकि डिकोडर भी
   यादृच्छिक डेटा जैसा दिखे;
5. वैकल्पिक रूप से नए बीजों (seeds) के साथ `--enc` बार दोहराता है;
6. (वैकल्पिक) एक रजिस्टर-सहेज उपसर्ग (safe mode) जोड़ता है।

## स्थापना
```sh
cargo install sgn
```
आप प्री-कंपाइल्ड बाइनरी भी [यहाँ][release] प्राप्त कर सकते हैं। 

**उपयोग**

`-h` काफी स्व-व्याख्यात्मक है, यदि आप देखना चाहते हैं कि पर्दे के पीछे क्या हो रहा है तो `-v` का उपयोग करें `( ͡° ͜ʖ ͡°)_/¯`
<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

```

उदाहरण:

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

## निष्पादन प्रवाह

निम्नलिखित छवि एन्कोडर के लिए एक बुनियादी कार्यप्रवाह आरेख है। लेकिन ध्यान रखें कि कचरा निर्देशों, डिकोडरों और स्कीमा डिकोडरों के आकार, स्थान और क्रम प्रत्येक पुनरावृत्ति पर बदलते रहेंगे। 

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

LFSR प्रायिकता स्थान (probability space) के संदर्भ में काफी शक्तिशाली है। और भी अधिक polymorphism के लिए, अनएन्कोडेड कच्चे पेलोड की शुरुआत में कचरा निर्देश जोड़े जाते हैं। नीचे दी गई छवि LFSR के अभिलक्षणिक बहुपद (characteristic polynomial) का साथी मैट्रिक्स (companion matrix) दिखाती है और बीज को स्तंभ सदिश (column vector) के रूप में दर्शाते हुए, Fibonacci विन्यास में k चरणों के बाद रजिस्टर की स्थिति को प्रदर्शित करती है।

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


## लाइब्रेरी के रूप में उपयोग

```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());
```

`examples/encode_binary.rs` देखें।

## परीक्षण

```sh
cargo test
```

सुइट में सिफर राउंड-ट्रिप यूनिट परीक्षणों के साथ-साथ **वास्तविक निष्पादन परीक्षण** भी शामिल हैं:
एन्कोडेड x64 shellcode को निष्पादन योग्य मैप करके प्रक्रिया में चलाया जाता है, और x86 shellcode
को `cc -m32` हेल्पर हार्नेस के माध्यम से निष्पादित किया जाता है (यदि 32-बिट
टूलचेन मौजूद नहीं है तो स्वचालित रूप से छोड़ दिया जाता है)। दोनों आर्किटेक्चर का परीक्षण plain,
schema, multi-layer और safe-register मोड में किया जाता है, जिसमें एक यादृच्छिक स्ट्रेस लूप भी शामिल है।

## पोर्ट पर नोट्स

* निर्देश निर्माण keystone असेंबली टेक्स्ट के बजाय `iced-x86` के टाइप किए गए असेंबलर API का उपयोग करता है; डिकोडर स्टब को RIP-सापेक्ष
  एड्रेसिंग (x64) और एक `call/pop` दो-पास योजना (x86) के चारों ओर फिर से बनाया गया।
* स्कीमा सिफर सीधे CPU के नेटिव लिटिल-एंडियन DWORD दृश्य में व्यक्त किया गया है,
  जो मूल के मिश्रित बिग/लिटिल-एंडियन अंकगणित के बराबर लेकिन अधिक स्पष्ट है।
* मूल का मृत कोड (अप्रयुक्त ~3k-पंक्ति निर्देश-सेट तालिका और वह
  "असुरक्षित कचरा" (unsafe garbage) जनरेटर जिसे कभी कॉल नहीं किया गया) हटा दिया गया।
* छोटे सुधार: `random_byte` अब पूरी `0..=255` सीमा में फैला हुआ है, और
  कचरा-आकार बजट (`--max`) को प्रति-ब्लॉक सीमा के रूप में लगातार लागू किया जाता है।