StringEncrypt – polimorficzne szyfrowanie

przez

Zachęcony pozytywnymi komentarzami dotyczącymi mojego projektu StringEncrypt, postanowiłem zaktualizować wszystko, co się dało i spełnić marzenia fanów tego niezwykłego rozwiązania.

Co to jest StringEncrypt?

To aplikacja do szyfrowania stringów i plików, generująca polimorficzny kod dekryptora. Ze stroną, WebAPI, dedykowanym rozszerzeniem do VSCode (ponad 4k instalacji) i aplikacją okienkową. Coś dla prawdziwych hakerów!

Silnik projektu jest wykorzystany w moich pozostałych projektach do masowego, polimorficznego szyfrowania stringów (w AutoIt Obfuscator i JObfuscator).

Szyfrować i generować kod można w następujących językach programowania:

Nowa wersja przynosi ogrom zmian, w tym najważniejsze – wsparcie dla wielu nowych języków programowania, tony bugfixów i najważniejsze – zagnieżdżone pętle polimorficzne.

Zagnieżdżone pętle polimorficzne

Jednym z zarzutów i wektorów ataku na StringEncrypt (w przypadku generatorów np. C/C++) było wykorzystanie narzędzi do ekstrakcji stringów, takich jak flare-floss. Narzędzie to potrafi przeskanować gotowy plik EXE, przeanalizować kod i wyciągnąć nawet zaszyfrowane stringi.

Zgłębiłem temat i cała filozofia tego rozwiązania bazuje na detekcji tzw. tight-loops, czyli ciasnych pętli. flare-floss potrafi rozpoznać krótkie pętle deszyfrujące i poprzez ich emulację wyciągnąć zaszyfrowane stringi, jeśli takie pętle zostały wykorzystane do ich odszyfrowania.

Rozwiązaniem tego problemu było wygenerowanie wielopoziomowo zagnieżdżonych pętli z polimorficznym kodem deszyfrującym co nie wpisuje się już w detekcję prostych pętli.

Przykładowy kod C

// encrypted with https://www.stringencrypt.com (v1.5.0) [C/C++]
// nie_do_wyciagniecia = "Nie tak prosto kolego!"
wchar_t nie_do_wyciagniecia[23] = { 0x0052, 0x71A4, 0x0690, 0x0900, 0x6830, 0x25B1, 0xF185, 0x0009,
                                    0x0074, 0x01D8, 0x82B4, 0x1FC7, 0x5830, 0xFD51, 0x4002, 0xD71F,
                                    0x0073, 0x01C0, 0x0690, 0x18C3, 0xA2D0, 0xD4DE, 0x4000 };

for (volatile unsigned int UCSag = 0, JkERu = 0; UCSag < 23; UCSag++)
{
	JkERu = nie_do_wyciagniecia[UCSag];
	for (unsigned int XptZj = 0; XptZj < 2; XptZj++)
	{
		JkERu = (((JkERu & 0xFFFF) >> (UCSag % 16)) | ((JkERu & 0xFFFF) << (16 - (UCSag % 16)))) & 0xFFFF;
		for (unsigned int HBXqW = 0; HBXqW < 2; HBXqW++)
		{
			JkERu = (((JkERu & 0xFFFF) >> 8) | ((JkERu & 0xFFFF) << 8)) & 0xFFFF;
			JkERu = ((JkERu ^ 0xFFFF) & 0xFFFF);
		}
	}
	for (unsigned int WAUOq = 0; WAUOq < 4; WAUOq++)
	{
		JkERu = ((JkERu & 0xFFFF) - 1) & 0xFFFF;
	}
	for (unsigned int HIbTj = 0; HIbTj < 2; HIbTj++)
	{
		JkERu = (((JkERu & 0xFFFF) << 8) | ((JkERu & 0xFFFF) >> 8)) & 0xFFFF;
		for (unsigned int Dswmt = 0; Dswmt < 2; Dswmt++)
		{
			JkERu = ((JkERu & 0xFFFF) + UCSag) & 0xFFFF;
			JkERu = (JkERu ^ (((JkERu & 0xFFFF) << 9) & 0xFFFF)) & 0xFFFF;
			JkERu = (JkERu ^ UCSag) & 0xFFFF;
		}
	}
	nie_do_wyciagniecia[UCSag] = JkERu;
}

I efekt pracy flare-floss, czyli brak znalezionych stringów metodą skanowania tight-loops:

Poprawki błędów

  • Poprawiłem formatowanie kodu Pythona, żeby było zgodne z regułami PEP.
  • Naprawiłem generator Ruby i sposób zapisywania zaszyfrowanych znaków.
  • Poprawki dotknęły też generatora AutoIt.

6 nowych instrukcji szyfrujących VM:

  • neg — klasyczna negacja (nie not)
  • swap — zamiana bitów w szyfrowanych 8 bitowych bajtach oraz 16 bitowych wartościach dla unicode
  • c_rol / c_ror — rotacje bitowe z użyciem klucza, którym jest licznik pętli
  • xor_shr / xor_shl — szyfrowanie z miksowaniem XOR, tak jak w algorytmach MurmurHash i SplitMix

Kompletna liczba instrukcji VM wykorzystanych do szyfrowania obecnie wynosi 17 (z 11), co jeszcze bardziej urozmaica wygenerowany kod wyjściowy.

Nowe podświetlanie składni

Strona zyskała nowe podświetlanie składni wygenerowanego kodu, porzucony został stary highlighter Syntax Highlighter na rzecz biblioteki Prism.

Pakiety SDK

Przykłady automatyzacji z poziomu Pythona

#!/usr/bin/env python

###############################################################################
#
# String Encrypt WebApi interface usage example.
#
# In this example we will encrypt sample string with default options.
#
# Version        : v1.0.1
# Language       : Python
# Author         : Bartosz Wójcik
# Project page   : https://www.stringencrypt.com
# Web page       : https://www.pelock.com
#
###############################################################################

#
# include StringEncrypt module
#
from stringencrypt import StringEncrypt

#
# if you don't want to use Python module, you can import it directly from the file
#
#from stringencrypt.stringencrypt import StringEncrypt

#
# create StringEncrypt class instance (we are using our activation code)
#
myStringEncrypt = StringEncrypt("YOUR-API-KEY-HERE") # leave empty for demo mode

#
# encrypt a string using all the default options
#
result = myStringEncrypt.encrypt_string("Hello, world!", "label_encrypted")

#
# result[] array holds the encryption results as well as other information
#
# result["error"] (int) - error code
# result["source"] (string) - decryptor source code
# result["expired"] (boolean) - expiration flag
# result["credits_left"] (int) - number of credits left
# result["credits_total"] (int) - initial number of credits

if result and "error" in result:

    # display source code of the decryption code
    if result["error"] == StringEncrypt.ErrorCodes.ERROR_SUCCESS:
        print(result["source"])
    else:
        print(f'An error occurred, error code: {result["error"]} ({result["error_string"]})')

else:
    print("Something unexpected happen while trying to encrypt the string.")

Pełna wersja

Klucz można zakupić za śmieszne pieniądze lub za darmo go zdobyć, pisząc o tym rozwiązaniu na social mediach, artykułach, na forach czy gdziekolwiek się da z linkiem do strony projektu i krótkim opisem oraz screenshotem. Niewiele, prawda?

Na koniec chciałbym jeszcze raz podziękować wszystkim fanom, którzy w dobie AI zmotywowali mnie do tak dużych aktualizacji – bez waszych słów wsparcia by mi się nie chciało aż tak 🙂

Nowa wersja Dekodera AZTec 2D

przez

Zmodernizowana i zaktualizowana wersja dekodera polskich dowodów rejestracyjnych, pozwalająca odczytać wszystkie dane ze zdjęcia kodu AZTEC 2D dowodu rejestracyjnego auta.

AZTec Decoder

Zaktualizowana wersja SDK dla JavaScript i TypeScript (pod Node) dostępna na NPM:

https://www.npmjs.com/package/aztec-decoder

Instalacja przez komendę:

npm install aztec-decoder

Przykłady użycia są banalnie proste. Dekodować można ze zdjęć oraz już zeskanowanych stringów (jeśli masz skaner ręczny).

//
// importuj moduł Dekoder AZTec dla Node.js
//
import { AZTecDecoder } from "aztec-decoder";

// inicjalizuj dekoder (używamy naszego klucza licencyjnego do inicjalizacji)
const decoder = new AZTecDecoder("ABCD-ABCD-ABCD-ABCD");

//
// 1. Dekoduj dane bezpośrednio z pliku graficznego, zwróć wynik jako rozkodowaną tablicę elementów JSON
//
const resultImage = await decoder.decodeImageFromFile("C:\\zdjecie-dowodu.jpg");

// czy udało się zdekodować dane?
if (resultImage?.Status === true) {
    // wyświetl rozkodowane dane (są zapisane jako rozkodowana tablica elementów JSON)
    console.log(JSON.stringify(resultImage, null, "\t"));
}

//
// 2. Dekoduj dane bezpośrednio z pliku graficznego i zwróć wynik jako rozkodowaną tablicę elementów JSON
//
const resultPng = await decoder.decodeImageFromFile("C:\\zdjecie-kodu-aztec-2d.png");

if (resultPng) {
    console.log(JSON.stringify(resultPng, null, "\t"));
}

//
// 3. Dekoduj dane z odczytanego już ciągu znaków (np. wykorzystując skaner ręczny)
//
// zakodowane dane z dowodu rejestracyjnego
const szValue = "ggMAANtYAAJD...";

const resultText = await decoder.decodeText(szValue);

if (resultText) {
    console.log(JSON.stringify(resultText, null, "\t"));
}

//
// 4. Dekoduj dane z odczytanego już ciągu znaków zapisanego w pliku (np. wykorzystując skaner ręczny)
//
const resultFile = await decoder.decodeTextFromFile("C:\\odczytany-ciag-znakow-aztec-2d.txt");

if (resultFile) {
    console.log(JSON.stringify(resultFile, null, "\t"));
}

Pełne źródła SDK na GitHubie

https://github.com/PELock/Dekoder-AZTEC-2D-JavaScript

Steganography Online Codec Web API

przez

Dodałem SDK dla mojego kodeka steganograficznego Steganography Online Codec, pierwsza wersja SDK dla Pythona dostępna przez PyPi z kodami źródłowymi na GitHubie.

###############################################################################
#
# Steganography Online Codec WebApi interface usage example.
#
# This example shows how to hide an encrypted secret message in an image file.
#
# Version      : v1.00
# Language     : Python
# Author       : Bartosz Wójcik
# Project      : https://www.pelock.com/products/steganography-online-codec
# Homepage     : https://www.pelock.com
#
###############################################################################

#
# include Steganography Online Codec module
#
from steganography_online_codec import *

#
# create Steganography Online Codec class instance (we are using our activation key)
#
mySteganographyOnlineCodec = SteganographyOnlineCodec("YOUR-CODE-GOES-HERE")

#
# encode a hidden message (encrypted with your password) within an image file
#
result = mySteganographyOnlineCodec.encode("input_file.jpg", "Secret message", "Pa$$word", "output_file_with_hidden_secret_message.png")

#
# result[] array holds the encoding results as well as other information
#
if result and "error" in result:
    if result["error"] == Errors.SUCCESS:
        print(f'Secret messaged encoded and saved to the output PNG file.')
    else:
        print(f'Error code {result["error"]}')
else:
    print("Something unexpected happen while trying to encode the message.")

Sprawdzony w boju, bezpieczny (AES i 20k rund PBKDF2) sprawiają, że nie został jeszcze złamany, wykorzystano go w konkursie, gdzie nagrodą było 20000 USD.

Kolejne wersje SDK dla innych języków programowania oraz wersja okienkowa i z linii komend w drodze.

Sztuczna inteligencja w dekompilatorach

przez

AI wciska się wszędzie, dzisiaj trafiłem na aktualizację starego lecz ciągle udoskonalanego dekompilatora VB Decompiler, który że nie dość obsługuje stare aplikacji VB skompilowane do tzw. p-code, to obecnie potrafi dekompilować aplikacje .NET.

Nowością jest dodany moduł AI bazujący na modelu Ollama, który zdekompilowany kod poddaje analizie AI w celu jego modyfikacji, aby dało się go jeszcze lepiej zrozumieć.

Kod po zwykłej dekompilacji:

Kod po transformacji AI:

Ciekawych czasów dożyliśmy, o których można było tylko marzyć 20 lat temu 🙂

Zemsta Smart-Odkurzacza

przez

Artykuł podesłany przez Fabka (thnx). Przykład jak urządzenia smart i firmy za nimi stojące nie są zainteresowane działaniem sprzętu, a jedynie zbieraniem informacji i co potrafią zrobić jeśli im się tego zabroni.

Smart odkurzacz

Rzadko czytam artykuły od A do Z, ale tym razem było bardzo ciekawie, polecam każdemu:

https://codetiger.github.io/blog/the-day-my-smart-vacuum-turned-against-me