Für komplexe Windows-API-Aufrufe verwenden Sie die [Winim-Bibliothek](https://github.com/khchen/winim), das spart eine wahnsinnige Menge Zeit und vergrößert die ausführbare Datei nicht zu sehr (siehe unten), je nachdem, wie Sie sie importieren.

Hat sogar COM-Unterstützung!!!

## Erstellen von Windows-DLLs mit einem exportierten `DllMain`

Ein großer Dank an die Person, die [dies](https://forum.nim-lang.org/t/1973) im Nim-Forum gepostet hat.

Der Nim-Compiler versucht, für Sie automatisch eine `DllMain`-Funktion zur Kompilierzeit zu erstellen, wenn Sie ihn anweisen, eine Windows-DLL zu erstellen, aber aus irgendeinem Grund exportiert er sie nicht. Um eine exportierte `DllMain` zu haben, müssen Sie `--nomain` übergeben und selbst eine `DllMain`-Funktion mit den entsprechenden Pragma-Direktiven definieren (`stdcall, exportc, dynlib`).

Sie müssen auch `NimMain` von Ihrer `DllMain` aus aufrufen, um Nims Garbage Collector zu initialisieren. (Sehr wichtig, sonst explodiert Ihr Computer buchstäblich).

Beispiel:

```nim
import winim

proc DllMain(hinstDLL: HINSTANCE, fdwReason: DWORD, lpvReserved: LPVOID): BOOL {.stdcall, exportc, dynlib.} =
  if fdwReason == DLL_PROCESS_ATTACH:
    nimMain()
  return TRUE
``````nim
import winim/lean

proc NimMain() {.cdecl, importc.}

proc DllMain(hinstDLL: HINSTANCE, fdwReason: DWORD, lpvReserved: LPVOID) : BOOL {.stdcall, exportc, dynlib.} =
  NimMain()
  
  if fdwReason == DLL_PROCESS_ATTACH:
    MessageBox(0, "Hello, world !", "Nim is Powerful", 0)

  return true

### Erstellen von XLLs
Sie können eine XLL (eine Excel-DLL, stellen Sie sich das vor) mit einer Auto-Open-Funktion erstellen, die für die Bereitstellung von Payloads verwendet werden kann. Der folgende Code erstellt eine einfache XLL mit einer Auto-Open-Funktion und dem gesamten weiteren Boilerplate-Code, der zum Kompilieren als Link-Bibliothek erforderlich ist. Der POC wird als DLL kompiliert. Sie können dann die Erweiterung in .xll ändern, und die Datei wird in Excel geöffnet und führt den Payload aus, wenn Sie darauf doppelklicken:```nim
#[
    Compile:
        nim c -d=mingw --app=lib --nomain --cpu=amd64 nim_xll.nim
        
    Will compile as a DLL, you can then just change the extension to .xll
]#

import winim/lean

proc xlAutoOpen() {.stdcall, exportc, dynlib.} =
    MessageBox(0, "Hello, world !", "Nim is Powerful", 0)

proc NimMain() {.cdecl, importc.}

proc DllMain(hinstDLL: HINSTANCE, fdwReason: DWORD, lpvReserved: LPVOID) : BOOL {.stdcall, exportc, dynlib.} =
  NimMain()

  return true

## Unterschiede in der ausführbaren Dateigröße bei Verwendung der Winim-Bibliothek im Vergleich zu ohne

Erstaunlicherweise ist der Größenunterschied ziemlich vernachlässigbar. Besonders wenn man die oben beschriebenen Größenoptimierungen anwendet.

Die beiden Beispiele `pop_bin.nim` und `pop_winim_bin.nim` wurden zu diesem Zweck erstellt.

Ersteres definiert den WinAPI-Aufruf `MessageBox` manuell und letzteres verwendet die Winim-Bibliothek (genauer `winim/lean`, das nur das Kern-SDK enthält, siehe [hier](https://github.com/khchen/winim#usage)), Ergebnisse:```
byt3bl33d3r@ecl1ps3 OffensiveNim % ls -lah bin
-rwxr-xr-x  1 byt3bl33d3r  25K Nov 20 18:32 pop_bin_32.exe
-rwxr-xr-x  1 byt3bl33d3r  32K Nov 20 18:32 pop_bin_64.exe
-rwxr-xr-x  1 byt3bl33d3r  26K Nov 20 18:33 pop_winim_bin_32.exe
-rwxr-xr-x  1 byt3bl33d3r  34K Nov 20 18:32 pop_winim_bin_64.exe

## Opsec-Überlegungen

Aufgrund der Art und Weise, wie Nim DLLs dynamisch mit `LoadLibrary` mittels seines FFI auflöst, werden keine Ihrer extern importierten Funktionen in den statischen Importen der ausführbaren Datei angezeigt (siehe [diesen Blogbeitrag](https://web.archive.org/web/20210117002945/https://secbytes.net/implant-roulette-part-1:-nimplant/) für weitere Informationen):

![](https://assets.kitploit.com/production/public/readmes/6566/ae35b71c435c8fe24112a95abb0eca863721c9fde9b14efb7d4f2701bb57b3b9.png)

Wenn Sie Nim-Quellcode in eine DLL kompilieren, scheint es, dass Sie immer ein exportiertes `NimMain` haben, unabhängig davon, ob Sie Ihr eigenes `DllMain` angeben oder nicht (??). Dies könnte potenziell als Signatur verwendet werden, ich weiß nicht, wie viele Unternehmen tatsächlich Nim in ihrem Entwicklungsstack verwenden. Fällt definitiv auf.

![](https://assets.kitploit.com/production/public/readmes/6566/1e291f2b170de9f5728e36cc2c6e489477480fa4b215dcf78341531805781448.png)

## Schreiben von Nim ohne die Nim-Laufzeit

Da Nim von Antivirenlösungen stark markiert wird, besteht eine Möglichkeit darin, Nim-Programme ohne die Nim-Laufzeit zu schreiben. [Writing Nim-less Nim](https://www.youtube.com/watch?v=EXX3HmCG3pw) ist ein Vortrag, der die Schritte beschreibt, wie man Nim-Code ohne die Nim- und C-Laufzeit schreibt. Der Quellcode zu diesem Vortrag ist [hier](https://github.com/m4ul3r/writing_nimless) verfügbar. Der Vortrag folgt und erweitert die Arbeit von [zimawhit3](https://github.com/zimawhit3) mit [Bitmancer](https://github.com/zimawhit3/Bitmancer/tree/main).

Das Prinzip besteht darin, sich auf die Typdefinitionen von `winim` zu verlassen und Code zu schreiben, der nicht zur Nutzung der Nim-Laufzeit führt.

## Konvertieren von C-Code in Nim

https://github.com/nim-lang/c2nim

Habe es verwendet, um eine Reihe kleiner C-Snippets zu übersetzen, habe noch nichts Großes versucht.

## Sprachbrücken

  - Python integration https://github.com/yglukhov/nimpy
    * Das ist tatsächlich super interessant, [insbesondere dieser Teil](https://github.com/yglukhov/nimpy/blob/master/nimpy/py_lib.nim#L330). Könnte dies mit einigen Modifikationen die PythonxXX.dll aus dem Speicher laden?

  - Jave VM integration: https://github.com/yglukhov/jnim

## Debugging

Verwenden Sie die Funktion `repr()` in Kombination mit `echo`, sie unterstützt fast alle (??) Datentypen, sogar Strukturen!

Siehe [diesen Blogbeitrag für mehr](https://nim-lang.org/blog/2017/10/02/documenting-profiling-and-debugging-nim-code.html)

## Einrichten einer Entwicklungsumgebung

Dieses Repository unterstützt [VSCode Devcontainers](https://code.visualstudio.com/docs/remote/create-dev-container), die es Ihnen ermöglichen, in einem Docker-Container zu entwickeln. Dies automatisiert die Einrichtung einer Entwicklungsumgebung für Sie.

1. Installieren Sie VSCode und Docker Desktop
2. Klonen Sie dieses Repository und öffnen Sie es in VSCode
3. Installieren Sie die Erweiterung `Visual Studio Code Remote - Containers`
4. Öffnen Sie die Befehlspalette und wählen Sie den Befehl `Remote-Containers: Reopen in Container`

VSCode wird nun das Docker-Image erstellen (wird etwas dauern) und Sie direkt in Ihre vorgefertigte Nim-Entwicklungsumgebung versetzen!

## Fallstricke, in die ich selbst getappt bin

- Wenn Sie Winapi-Aufrufe mit Winim tätigen und versuchen, einen Nullwert zu übergeben, stellen Sie sicher, dass Sie den Wert `NULL` (innerhalb der Winim-Bibliothek definiert) anstelle von Nims eingebautem `nil`-Wert übergeben. (Ugh)

- Um das Betriebssystem-Handle für die erstellte Datei nach dem Aufruf von `open()` unter Windows zu erhalten, müssen Sie `f.getOsFileHandle()` **nicht** `f.getFileHandle()` aufrufen, aus Gründen.

- Der Nim-Compiler akzeptiert Argumente in der Form `-a=value` oder `--arg=value`, obwohl in der Verwendung nur Argumente als `-a:value` oder `--arg:value` angegeben werden. (Wichtig für Makefiles)

- Wenn Sie ein Byte-Array definieren, müssen Sie zumindest beim ersten Wert angeben, dass es sich um ein Byte-Array handelt, etwas seltsam, aber ok (https://forum.nim-lang.org/t/4322)

Byte-Array in C#:```csharp
byte[] buf = new byte[5] {0xfc,0x48,0x81,0xe4,0xf0,0xff}

## Interessante Nim-Bibliotheken

- https://github.com/dom96/jester
- https://github.com/pragmagic/karax
- https://github.com/Niminem/Neel
- https://github.com/status-im/nim-libp2p
- https://github.com/PMunch/libkeepass
- https://github.com/def-/nim-syscall
- https://github.com/tulayang/asyncdocker
- https://github.com/treeform/ws
- https://github.com/guzba/zippy
- https://github.com/rockcavera/nim-iputils
- https://github.com/FedericoCeratto/nim-socks5
- https://github.com/CORDEA/backoff
- https://github.com/treeform/steganography
- https://github.com/miere43/nim-registry
- https://github.com/status-im/nim-daemon

## Nim für Implant-Entwicklung Links

- https://web.archive.org/web/20210117002945/https://secbytes.net/implant-roulette-part-1:-nimplant/
- https://securelist.com/zebrocys-multilanguage-malware-salad/90680/
- https://github.com/MythicAgents/Nimplant
- https://github.com/elddy/Nim-SMBExec
- https://github.com/elddy/NimScan

## Mitwirkende 

Virtuelle Umarmung an alle, die mitgewirkt haben ❤️

<a href="https://github.com/byt3bl33d3r/OffensiveNim/graphs/contributors">
  <img src="https://contrib.rocks/image?repo=byt3bl33d3r/OffensiveNim" />
</a>