Zaktualizowana została usługa dla programistów – StringEncrypt, która pozwala w prosty sposób zaszyfrować dowolne dane, generując za każdym razem unikalny algorytm szyfrowania oraz tworząca do tego automatycznie kod dekryptora w wybranym języku programowania.
Jak zwykle szyfrujemy dane?
Jeśli zależy nam na czymś co nie wymaga sporych zasobów procesora nie skorzystamy do tak trywialnego celu z szyfrowania np. AES (zapewne wymagana będzie jakaś zewnętrzna biblioteka szyfrująca lub implementacja).
W większości przypadków, każdy normalny programista napisze do tego celu własne oprogramowanie, które pobierze na wejściu ciąg niezakodowanych danych i zwróci zaszyfrowane dane. Dodatkowo zwróci je w formie pozwalającej zapisać dane w postaci kodu źródłowego języka programowania, w którym akurat tworzy oprogramowanie.
Jak szyfrować dane szybciej?
Usługa StringEncrypt pozwala:
- zaoszczędzić czas na tworzenie narzędzi programistycznych
- za każdym razem wygenerować inny algorytm szyfrujący
- wygenerowany kod nie wymaga zewnętrznych bibliotek szyfrujących
- można wybrać spośród wyjścia w C/C++, Delphi/Pascal, Java, JavaScript, Python, MASM/FASM, Haskell
Przykład szyfrowania danych
Przykład, chcemy np. zaszyfrować string „Szyfrowanie danych”. Jak to zrobić? Na stronie głównej StringEncrypt wystarczy wpisać nazwę dla labela oraz sam tekst do zaszyfrowania i kliknąć „Encrypt and Generate Decryptor”.
Dostępnych jest kilka dodatkowych opcji jak np. wybór wyjściowego języka programowania czy sposób kodowania znaków narodowych, jeśli nasze dane takowe zawierają.
Efektem końcowym są listingi z zaszyfrowanymi danymi oraz kodem źródłowym. Przykłady tak wygenerowanych dekryptorów poniżej.
Zaszyfrowane dane oraz kod deszyfrujący w C/C++
// encrypted with www.stringencrypt.com (v1.0.0) [C/C++]
// szZaszyfrowaneDane = "Szyfrowanie danych"
wchar_t szZaszyfrowaneDane[19] = { 0xBEFE, 0xBED8, 0xBEDA, 0xBEBE, 0xBEB9, 0xBED5, 0xBEC0, 0xBEBD,
0xBEB1, 0xBECF, 0xBEBE, 0xB8FC, 0xBEC7, 0xBEB3, 0xBEB7, 0xBECD,
0xBEBE, 0xBEBA, 0xBF01 };
for (unsigned int DwvRZ = 0, sobMk = 0; DwvRZ < 19; DwvRZ++)
{
sobMk = szZaszyfrowaneDane[DwvRZ];
sobMk ^= 0xBCFB;
sobMk -= DwvRZ;
sobMk ++;
sobMk ^= 0x0CFB;
sobMk = ~sobMk;
sobMk += DwvRZ;
sobMk ^= 0x9A0E;
sobMk += 0x4ABC;
sobMk -= DwvRZ;
sobMk ^= 0xB59B;
szZaszyfrowaneDane[DwvRZ] = sobMk;
}
wprintf(szZaszyfrowaneDane);
Kod dekryptora w C# dla platformy .NET
// encrypted with www.stringencrypt.com (v1.0.0) [C#]
// szZaszyfrowaneDane = "Szyfrowanie danych"
String szZaszyfrowaneDane = "\u0236\u020F\u0210\u0227\u021D\u0222\u0226\u0224" +
"\u0239\u0220\u0224\u0279\u022B\u0220\u0231\u021C" +
"\u0226\u0201";
for (int lWdYZ = 0, AtPLU = 0; lWdYZ < 18; lWdYZ++)
{
AtPLU = szZaszyfrowaneDane[lWdYZ];
AtPLU ^= lWdYZ;
AtPLU -= 0x6403;
AtPLU ^= lWdYZ;
AtPLU ^= 0x51FE;
AtPLU += lWdYZ;
AtPLU -= 0xCF7A;
AtPLU ^= lWdYZ;
szZaszyfrowaneDane = szZaszyfrowaneDane.Substring(0, lWdYZ) + (char)(AtPLU & 0xFFFF) + szZaszyfrowaneDane.Substring(lWdYZ + 1);
}
MessageBox.Show(szZaszyfrowaneDane);
Kod dekryptujący w Delphi / Pascal
// encrypted with www.stringencrypt.com (v1.0.0) [Delphi / Pascal]
var
// szZaszyfrowaneDane = "Szyfrowanie danych"
szZaszyfrowaneDane: array[0..19] of WideChar;
VdaMu: Integer;
sveIR: Integer;
begin
szZaszyfrowaneDane[3] := WideChar($0E23); szZaszyfrowaneDane[14] := WideChar($0E36);
szZaszyfrowaneDane[6] := WideChar($0E37); szZaszyfrowaneDane[12] := WideChar($0E1E);
szZaszyfrowaneDane[8] := WideChar($0E34); szZaszyfrowaneDane[9] := WideChar($0E1E);
szZaszyfrowaneDane[11] := WideChar($0DE9); szZaszyfrowaneDane[18] := WideChar($0DD0);
szZaszyfrowaneDane[10] := WideChar($0E1D); szZaszyfrowaneDane[13] := WideChar($0E22);
szZaszyfrowaneDane[0] := WideChar($0E11); szZaszyfrowaneDane[15] := WideChar($0E2C);
szZaszyfrowaneDane[1] := WideChar($0E39); szZaszyfrowaneDane[16] := WideChar($0E31);
szZaszyfrowaneDane[17] := WideChar($0E37); szZaszyfrowaneDane[7] := WideChar($0E1C);
szZaszyfrowaneDane[5] := WideChar($0E30); szZaszyfrowaneDane[4] := WideChar($0E2C);
szZaszyfrowaneDane[2] := WideChar($0E39);
for sveIR := 0 to 19 do
begin
VdaMu := Ord(szZaszyfrowaneDane[sveIR]);
VdaMu := VdaMu - sveIR;
VdaMu := VdaMu + sveIR;
VdaMu := VdaMu - $58FA;
VdaMu := VdaMu xor sveIR;
VdaMu := VdaMu + $4B3C;
VdaMu := VdaMu + sveIR;
VdaMu := VdaMu - sveIR;
szZaszyfrowaneDane[sveIR] := WideChar(VdaMu);
end;
ShowMessage(szZaszyfrowaneDane);
Wyjściowy kod deszyfrujący w Java
// encrypted with www.stringencrypt.com (v1.0.0) [Java]
// szZaszyfrowaneDane = "Szyfrowanie danych"
String szZaszyfrowaneDane = "\uD9CD\uD9F4\uD9EF\uD9E0\uD9E4\uD9E7\uD9F1\uD9D5" +
"\uD9D8\uD9E1\uD9CB\uD986\uD9C6\uD9C9\uD9D8\uD9ED" +
"\uD9BD\uD9E2";
for (int LMSGW = 0, BZYmK = 0; LMSGW < 18; LMSGW++)
{
BZYmK = szZaszyfrowaneDane.charAt(LMSGW);
BZYmK += LMSGW;
BZYmK ^= LMSGW;
BZYmK ++;
BZYmK ^= 0xFFFF;
BZYmK -= LMSGW;
BZYmK ^= 0xFFFF;
BZYmK -= 0xD97B;
BZYmK -= LMSGW;
szZaszyfrowaneDane = szZaszyfrowaneDane.substring(0, LMSGW) + (char)(BZYmK & 0xFFFF) + szZaszyfrowaneDane.substring(LMSGW + 1);
}
System.out.println(szZaszyfrowaneDane);
Zaszyfrowane dane do wykorzystania w JavaScript (HTML)
<script type="text/javascript">
// encrypted with www.stringencrypt.com (v1.0.0) [JavaScript]
// szZaszyfrowaneDane = "Szyfrowanie danych"
var szZaszyfrowaneDane;
szZaszyfrowaneDane = String.fromCharCode(0x8C8D, 0x8C68, 0x8C6B, 0x8C84, 0x8C76, 0x8C7B, 0x8C75, 0x8C89,
0x8C82, 0x8C99, 0x8C8F, 0x8CC2, 0x8C84, 0x8C89, 0x8C9A, 0x8C91,
0x8C9D, 0x8C9A);
for (var UkhdQ = 0, LElnh = 0; UkhdQ < 18; UkhdQ++)
{
LElnh = szZaszyfrowaneDane.charCodeAt(UkhdQ);
LElnh -= UkhdQ;
LElnh -= 0xAA95;
LElnh -= UkhdQ;
LElnh += UkhdQ;
LElnh --;
LElnh ^= UkhdQ;
LElnh += 0x39C5;
LElnh -= UkhdQ;
LElnh = ~LElnh;
LElnh += 0x1C10;
LElnh ^= UkhdQ;
szZaszyfrowaneDane = szZaszyfrowaneDane.substr(0, UkhdQ) + String.fromCharCode(LElnh & 0xFFFF) + szZaszyfrowaneDane.substr(UkhdQ + 1);
}
alert(szZaszyfrowaneDane);
</script>
Szyfrowanie danych w Pythonie nie było prostsze
# encrypted with www.stringencrypt.com (v1.0.0) [Python]
# szZaszyfrowaneDane = "Szyfrowanie danych"
szZaszyfrowaneDane = [ 0x70BA, 0x70D3, 0x70D4, 0x70C7, 0x70D9, 0x70C6, 0x70DE, 0x70CC,
0x70CD, 0x70D0, 0x70C8, 0x710D, 0x70CB, 0x70C8, 0x70D5, 0x70E4,
0x70EA, 0x70E1 ]
for Zmizb in range(18):
FZBAn = szZaszyfrowaneDane[Zmizb]
FZBAn = ~FZBAn
FZBAn -= 0xF5C7
FZBAn = ~FZBAn
FZBAn -= 1
FZBAn -= Zmizb
FZBAn -= 0xF2E1
FZBAn ^= 0x73CC
FZBAn ^= Zmizb
szZaszyfrowaneDane[Zmizb] = FZBAn
szZaszyfrowaneDane = ''.join(chr(FZBAn & 0xFFFF) for FZBAn in szZaszyfrowaneDane)
del Zmizb, FZBAn
print(szZaszyfrowaneDane)
Obsługiwany jest także Haskell
-- encrypted with www.stringencrypt.com (v1.0.0) [Haskell]
module Main where
import qualified Data.Char
import qualified Data.Bits
main = do
putStrLn $ szZaszyfrowaneDane
-- szZaszyfrowaneDane = "Szyfrowanie danych"
szZaszyfrowaneDane = zipWith f [0..] [ 0x5604, 0x55DE, 0x55E0, 0x55F4, 0x55E1, 0x55E3, 0x55DA, 0x55F3,
0x55E1, 0x55E5, 0x55FC, 0x563E, 0x55FF, 0x55F9, 0x55E7, 0x55D3,
0x55E4, 0x5600 ]
where
f wvfax cxdne = let gpmae0 = cxdne
gpmae1 = gpmae0 - 1
gpmae2 = gpmae1 `Data.Bits.xor` wvfax
gpmae3 = gpmae2 - wvfax
gpmae4 = Data.Bits.complement gpmae3
gpmae5 = gpmae4 + 1
gpmae6 = gpmae5 - wvfax
gpmae7 = gpmae6 - 0xA9AA
in Data.Char.chr (gpmae7 Data.Bits..&. 0xFFFF)
Kod dekryptora w MASM
; encrypted with www.stringencrypt.com (v1.0.0) [MASM Assembler (32 bit)]
.data
; szZaszyfrowaneDane = "Szyfrowanie danych"
szZaszyfrowaneDane dw 0C08Dh, 0C078h, 0C06Bh, 0C068h, 0C0B6h, 0C061h, 0C0B9h, 0C06Bh
dw 0C05Ah, 0C067h, 0C077h, 0C042h, 0C074h, 0C077h, 0C05Eh, 0C073h
dw 0C07Dh, 0C07Ah, 0C0D0h
.code
mov edx, offset szZaszyfrowaneDane
mov eax, 19
and ecx, 0
@@:
mov bx, word ptr [edx + ecx]
sub ebx, ecx
xor ebx, 0B1C6h
not ebx
add ebx, 028B2h
not ebx
xor ebx, 0D1D9h
xor ebx, ecx
add ebx, 056FAh
not ebx
sub ebx, 0A3ADh
xor ebx, 00FA0h
add ebx, ecx
sub ebx, ecx
xor ebx, 063EBh
mov word ptr [edx + ecx], bx
inc ecx
dec eax
jne @b
push 0
push edx
push edx
push 0
call MessageBoxW
Zwróćcie uwagę, że dane zostały za każdym razem zaszyfrowane inaczej, z innym zestawem instrukcji szyfrujących, dlatego każdorazowo generowany kod jest inny.
Kod nie wymaga zewnętrznych bibliotek, bazuje na podstawowych funkcjonalnościach jakie oferują obsługiwane języki programowania.
Szyfrowanie plików
StringEncrypt pozwala w równie łatwy sposób szyfrować zawartość dowolnych plików binarnych.
Klient końcowy dla Windows
Szyfrowanie można przeprowadzać bezpośrednio na stronie projektu, jednak istnieje również klient dla systemu Windows, oferujący tą samą funkcjonalność:
Web API
Usługa posiada również interfejs Web API bazujący na prostych zapytaniach POST, dostępne jest SDK w PHP, a jego wykorzystanie jest banalnie proste:
<?php
////////////////////////////////////////////////////////////////////////////////
//
// StringEncrypt.com Web API usage example
//
// Version : v1.1
// Language : PHP
// Author : Bartosz WĂłjcik
// Web page : https://www.stringencrypt.com
//
////////////////////////////////////////////////////////////////////////////////
// include main library
include ("stringencrypt.php");
//
// setup options
//
$options = array();
//
// activation code, you can leave it empty for demo version, but keep in
// mind that there are many limitations in demo version)
//
$options["code"] = "";
//
// API command to execute
//
// "encrypt" - encrypt input string or file bytes, returns array of:
//
// $result["error"] - error code
// $result["source"] - decryptor source code
// $result["expired"] - activation code expiration flag (bool)
// $result["credits_left"] - number of credits left
//
// "is_demo" - checks current activation code and returns array of:
//
// $result["demo"] - demo mode flag (bool)
// $result["label_limit"] - label limit length
// $result["string_limit"] - string/file limit lenght
// $result["credits_left"] - number of credits left
// $result["cmd_min"] - minimum number of encryption commands
// $result["cmd_max"] - maximum number of encryption commands
$options["command"] = "encrypt";
//$options["command"] = "is_demo";
//
// label name
//
// demo mode supports up to 6 chars only (64 in full version),
// if you pass more than this number, service will return
// ERROR_LENGTH_LABEL
//
$options["label"] = "Label";
//
// input string / raw bytes compression enabled, if you set it to
// true, you need to compress input string / raw bytes eg.
//
// $compressed = @base64_encode(@gzcompress($string, 9)
//
// and after encryption you need to decompress encrypted data
//
// $decompressed = @gzuncompress(@base64_decode($source));
//
$options["compression"] = false;
//$options["compression"] = true;
//
// input string in UTF-8 format
//
// demo mode supports up to 6 chars only, if you pass more
// than that, service will return ERROR_LENGTH_STRING
//
$options["string"] = "Hello!";
//$options["string"] = @base64_encode(@gzcompress("Hello!", 9));
//
// raw data bytes to encrypt (you need to specify either
// $options["string"] or this value
//
// demo mode doesn't support this parameter and the service
// will return ERROR_DEMO
//
//$options["bytes"] = file_get_contents("my_file.txt");
//$options["bytes"] = file_get_contents("http://www.example.com/my_file.txt");
//$options["bytes"] = @base64_encode(@gzcompress(file_get_contents("my_file.txt"), 9));
//
// treat input string as a UNICODE string (ANSI otherwise)
//
$options["unicode"] = true;
//
// input string default locale (only those listed below
// are supported currently)
//
$options["lang_locale"] = "en_US.utf8";
//$options["lang_locale"] = "en_GB.utf8";
//$options["lang_locale"] = "de_DE.utf8";
//$options["lang_locale"] = "es_ES.utf8";
//$options["lang_locale"] = "fr_BE.utf8";
//$options["lang_locale"] = "fr_FR.utf8";
//$options["lang_locale"] = "pl_PL.utf8";
//
// how to encode new lines, available values:
//
// "lf" - Unix style
// "crlf" - Windows style
// "cr" - Mac style
//
$options["new_lines"] = "lf";
//$options["new_lines"] = "crlf";
//$options["new_lines"] = "cr";
//
// destination ANSI string encoding (if unicode = false)
//
// only those listed below are supported
//
$options["ansi_encoding"] = "WINDOWS-1250";
//$options["ansi_encoding"] = "WINDOWS-1251";
//$options["ansi_encoding"] = "WINDOWS-1252";
//$options["ansi_encoding"] = "WINDOWS-1253";
//$options["ansi_encoding"] = "WINDOWS-1254";
//$options["ansi_encoding"] = "WINDOWS-1255";
//$options["ansi_encoding"] = "WINDOWS-1256";
//$options["ansi_encoding"] = "WINDOWS-1257";
//$options["ansi_encoding"] = "WINDOWS-1258";
//$options["ansi_encoding"] = "ISO-8859-1";
//$options["ansi_encoding"] = "ISO-8859-2";
//$options["ansi_encoding"] = "ISO-8859-3";
//$options["ansi_encoding"] = "ISO-8859-9";
//$options["ansi_encoding"] = "ISO-8859-10";
//$options["ansi_encoding"] = "ISO-8859-14";
//$options["ansi_encoding"] = "ISO-8859-15";
//$options["ansi_encoding"] = "ISO-8859-16";
//
// output programming language
//
// only those listed below are supported, if you pass
// other name, service will return ERROR_INVALID_LANG
//
$options["lang"] = "cpp";
//$options["lang"] = "csharp";
//$options["lang"] = "delphi";
//$options["lang"] = "java";
//$options["lang"] = "js";
//$options["lang"] = "python";
//$options["lang"] = "haskell";
//$options["lang"] = "masm";
//$options["lang"] = "fasm";
//
// minimum number of encryption commands
//
// demo mode supports only up to 3 commands (50 in full version),
// if you pass more than this number, service will return
// ERROR_CMD_MIN
//
$options["cmd_min"] = 1;
//$options["cmd_min"] = 1;
//
// maximum number of encryption commands
//
// demo mode supports only up to 3 commands (50 in full version),
// if you pass more than this number, service will return
// ERROR_CMD_MAX
//
$options["cmd_max"] = 3;
//$options["cmd_max"] = 50;
//
// store encrypted string as a local variable (if supported
// by the programming language), otherwise it's stored as
// a global variable
//
$options["local"] = false;
//$options["local"] = true;
//
// encrypt string or file contents
//
$result = stringencrypt($options);
if ($result != false)
{
if ($result["error"] == ERROR_SUCCESS)
{
// if compression was enabled, we need to
// decompress the output source code
if ($options["compression"] == true)
{
$source = @gzuncompress(@base64_decode($source));
}
else
{
$source = $result["source"];
}
// display decryptor body
echo "<pre>".$source."</pre>";
// display number of credits left
echo "<p>You have {$result['credits_left']} credits left.</p>";
// display initial number of credits
echo "<p>Initial number of credits {$result['credits_total']}.</p>";
// activation code has expired, notify user
if ($result["expired"] == true)
{
echo "<p>Your activation code has expired!</p>";
}
}
else
{
echo "An error occured (code ".$result["error"].")";
}
}
else
{
echo "Cannot connect to the API interface!";
}
?>
Strona projektu
Zachęcam do odwiedzenia strony usługi i wypróbowania https://stringencrypt.com.
Dzisiaj usługa StringEncrypt została poszerzona o moduł pozwalający zaszyfrować dowolny string lub zawartość pliku i wygenerować kod deszyfrujący w języku skryptowym AutoIt.