На основе работ по декодированию рабочего кода Postino мы создали утилиту, основное предназначение которой:
 - декодирование закодированного рабочего кода Postino, то-есть файлов
     \POSTBUILD\app\dbase\*.txt
     \POSTBUILD\app\ui\*.txt
 - декодирование MDT файлов
     \MACH\resource\postprocessor\vnc_base_v*_tcl.txt

 Утилита восстанавливает исходный код всех PB - от самых ранних (v16.3.3.3), и заканчивая PB8.  Дерзайте.

	Утилита : decrypt1.exe Исходный код утилиты: decrypt1.zip
	В процессе работы утилиты, в папке исходного кодированного файла создается точно такой же раскодированный файл с приставкой _decrypt.tcl Запуск из командной строки: decrypt1.exe file.txt rem file.txt - закодированный файл.

Для приверженцев Tcl\Tk:

• de_crypt_block1.tcl  -  скрипт перекодирует все .txt файлы - в папке куда он был помещен (где был запущен);
• de_crypt_block2.tcl  -  скрипт перекодирует все .txt файлы и проводит "парсинг" текста для установки отступов и облегчения ознакомления с текстом - в папке куда он был помещен (где был запущен).

А также см. ниже.
 

set c '' ;
set sl [ string length $line ] ;
set line2 "";
for { set i 0 } { $i<$sl } { incr i } {
  set j [ expr ($sl - $i - 1) ] ;
  set c [ string index $line $j ] ;
  set c [ expr 158 - [ scan $c "%c" ] ];
  set c [ format "%c" $c ]
  append line2 $c ;
}

1. Реверсируем символы в строке.
2. обратим каждый символ : с=158-с
   В коде (слева) - реверс и перевертыш символа объединены !
   Вот и все кодирование.

Зададим некоторое первоначальное целое число N₀ -  данное число находиться в закодируемом виде в первой строке файла.

Для тех кто хочет ознакомится с теоретическими основами данного вида кодирования, то читайте страницу на Wiki: http://ru.wikipedia.org/wiki/Псевдослучайный_алгоритм
Более умно и запутанно: 20. Методы получения случайных и псевдослучайных последовательностей. Регистры сдвига с обратной связью. Линейный конгруэнтный метод.

   1. Запустите -  tknotepad.tcl , или загрузите в интерпретатор. Откройте необходимый файл.

  2. Нажимая кнопку DeCrypt, получите декодированный файл. Обведенная красным - это первоначальное число N₀.
  Процесс декодирования может занять некоторое время, особенно на маломощных компьютерах, поэтому наберитесь терпения.

  3. Вы можете закодировать файл. Для этого нажмите кнопку Crypt. Появиться диалоговое окно для ввода N_i. Введя его , нажмите Apply - Вы запустите алгоритм кодирования.
Случайную последовательность я создаю простым способом:

set f1 [ UIPB__random ];
set str1 ""
for { set i 0 } { $i<$f1 } { incr i } {
  set rnd [ rand1 ]
  set rnd [ expr $rnd%255 ]
  set c [ format "%c" $rnd ]
  append str1 $c ;
}

  5. Как Вы можете видеть, мы получим закодированный текст. Но его реализация очень страшна, всё дело в том, что для реализации псевдослучайных символов я реализовал генератор случайных чисел, поставляемый с системой. Но! Этот текст Вы сможете снова декодировать, употребляя стандартный алгоритм.

global next
set next 1 ;

proc rand1 { } {
  global next
  set next [ expr $next*1103515245+12345 ] ;
  set t [ expr int(($next/65536)%32768) ] ;
  return $t ;
}

proc srand1 { seed } {
  global next
  set next $seed;
}

; int __cdecl UIPB__decrypt(int interp,char src_file)
UIPB__decrypt proc near ; CODE XREF: _PostBuilder_AppInit+350 p
; _PostBuilder_AppInit+4DB p

sl = dword ptr -0C20h
k = dword ptr -0C1Ch
src = dword ptr -0C18h
j = dword ptr -0C14h
i = dword ptr -0C10h
line2 = dword ptr -0C0Ch
line1 = dword ptr -80Ch
c = dword ptr -40Ch
cseed = dword ptr -408h
var_401 = byte ptr -401h
line = dword ptr -400h
interp = dword ptr 8
src_file = byte ptr 0Ch

Tcl_SetVar(interp,"src_file",src_file,0);
;CONST char * Tcl_SetVar(interp, varName, newValue, flags)
Tcl_GlobalEval(interp, "set src_file [file nativename $src_file"]);
Tcl_GetVar(interp,"src_file","r,access=lock")
;CONST char * Tcl_GetVar(interp, varName, flags)
rf=fopen(src_file,r);
Tcl_NewListObj(0,0,src);
;Tcl_Obj * Tcl_NewListObj(objc, objv)


add esp, 8
mov cmdObj, eax
mov [ebp+k], 0FFFFFFFFh

loc_401768: ; CODE XREF: UIPB__decrypt+2B8 j
mov ecx, [ebp+k]
add ecx, 1
mov [ebp+k], ecx
mov edx, [ebp+src]
push edx ; FILE *
push 400h ; int
lea eax, [ebp+line]
push eax ; char *
call ds:__imp__fgets
add esp, 0Ch
mov ecx, [ebp+src]
mov edx, [ecx+0Ch]
and edx, 10h
test edx, edx
jz short loc_4017A8
jmp loc_4019B2
; ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД

loc_4017A8: ; CODE XREF: UIPB__decrypt+AD j
lea eax, [ebp+line]
push eax ; char *
call _strlen
add esp, 4
mov [ebp+eax+var_401], 0
mov byte ptr [ebp+c], 0
cmp [ebp+k], 0
jnz loc_40188C
mov byte ptr [ebp+cseed], 0
mov rseed, 0
lea ecx, [ebp+line]
push ecx ; char *
call _strlen
add esp, 4
mov [ebp+sl], eax
mov [ebp+i], 0
jmp short loc_401814
; ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД

loc_401805: ; CODE XREF: UIPB__decrypt+16E j
mov edx, [ebp+i]
add edx, 1
mov [ebp+i], edx

loc_401814: ; CODE XREF: UIPB__decrypt+10F j
mov eax, [ebp+i]
cmp eax, [ebp+sl]
jge short loc_401864
mov ecx, [ebp+i]
mov dl, byte ptr [ebp+ecx+line]
mov byte ptr [ebp+c], dl
movsx eax, byte ptr [ebp+c]
mov ecx, 9Eh
sub ecx, eax
mov byte ptr [ebp+c], cl
push 1 ; size_t
lea edx, [ebp+c]
push edx ; char *
lea eax, [ebp+cseed]
push eax ; char *
call ds:__imp__strncat
add esp, 0Ch
jmp short loc_401805
; ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД

loc_401864: ; CODE XREF: UIPB__decrypt+12C j
mov ecx, [ebp+sl]
mov byte ptr [ebp+ecx+cseed], 0
lea edx, [ebp+cseed]
push edx ; char *
call ds:__imp__atoi
add esp, 4
mov rseed, eax
jmp loc_40199E
; ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД

loc_40188C: ; CODE XREF: UIPB__decrypt+D9 j
call UIPB__random
lea eax, [ebp+eax+line]
push eax ; char *
lea ecx, [ebp+line1]
push ecx ; char *
call _strcpy
add esp, 8
lea edx, [ebp+line1]
push edx ; char *
call _strlen
add esp, 4
mov [ebp+sl], eax
call UIPB__random
mov ecx, [ebp+sl]
sub ecx, eax
mov [ebp+sl], ecx
mov edx, [ebp+sl]
mov byte ptr [ebp+edx+line1], 0
mov byte ptr [ebp+line2], 0
mov [ebp+i], 1
jmp short loc_401900
; ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД

loc_4018F1: ; CODE XREF: UIPB__decrypt+26F j
mov eax, [ebp+i]
add eax, 1
mov [ebp+i], eax

loc_401900: ; CODE XREF: UIPB__decrypt+1FB j
mov ecx, [ebp+sl]
add ecx, 1
cmp [ebp+i], ecx
jge short loc_401965
mov edx, [ebp+sl]
sub edx, [ebp+i]
mov [ebp+j], edx
mov eax, [ebp+j]
mov cl, byte ptr [ebp+eax+line1]
mov byte ptr [ebp+c], cl
movsx edx, byte ptr [ebp+c]
mov eax, 9Eh
sub eax, edx
mov byte ptr [ebp+c], al
push 1 ; size_t
lea ecx, [ebp+c]
push ecx ; char *
lea edx, [ebp+line2]
push edx ; char *
call ds:__imp__strncat
add esp, 0Ch
jmp short loc_4018F1
; ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД

loc_401965: ; CODE XREF: UIPB__decrypt+21B j
mov eax, [ebp+sl]
mov byte ptr [ebp+eax+line2], 0
push offset asc_4068FC ; "\n"
lea ecx, [ebp+line2]
push ecx ; char *
call _strcat

Tcl_AppendStringsToObj(cmdObj,line2);

add esp, 0Ch

loc_40199E: ; CODE XREF: UIPB__decrypt+193 j
mov ecx, [ebp+src]
mov edx, [ecx+0Ch]
and edx, 10h
test edx, edx
jz loc_401768

loc_4019B2: ; CODE XREF: UIPB__decrypt+AF j
mov eax, [ebp+src]
push eax ; int
call __close
add esp, 4
mov esp, ebp
pop ebp
retn
UIPB__decrypt endp

//----- (UIPB__decrypt) --------------------------------------------------------
int UIPB__decrypt(Tcl_Interp *interp, char *src_file)
{
char v3[256]; // eax@1
int v4; // eax@9
FILE *src; // [sp+8h] [bp-C18h]@1
int k; // [sp+4h] [bp-C1Ch]@1
char line[1024]; // [sp+820h] [bp-400h]@2
char c; // [sp+814h] [bp-40Ch]@4
char cseed[7]; // 7 [sp+818h] [bp-408h]@5
int sl; // [sp+0h] [bp-C20h]@5
int i; // [sp+10h] [bp-C10h]@5
char line1[1024]; // [sp+414h] [bp-80Ch]@9
char line2[1024]; // [sp+14h] [bp-C0Ch]@9
int j; // [sp+Ch] [bp-C14h]@11

Tcl_SetVar(interp, "src_file", src_file, 0);
Tcl_GlobalEval(interp, "set src_file [file nativename $src_file]");
sprintf(v3 ,"%s", Tcl_GetVar(interp, "src_file", 0) );
src = fopen(v3, "r,access=lock");
cmdObj = Tcl_NewListObj(0, NULL);
k = -1;
do
{
  ++k;
  fgets(line, 1024, src);
  if (feof(src)) break;
  line[strlen(line)]=0;
  c = 0;
  if ( k )
  {
    v4 = UIPB__random();
    strcpy(line1, &line[v4]);
    sl = strlen(line1);
    sl -= UIPB__random();
    line1[sl] = '\0';
    line2[0] = '\0';
    i = 1;
    while ( i < sl )
    {
      j = sl - i - 1;
      c = line1[j];
      c = 158 - c;
      strncat(line2, &c, 1);
      ++i;
    }
    line2[sl] = '\0';
    strcat(line2, "\n");
    Tcl_AppendStringsToObj(cmdObj, line2, 0);
  }
  else
  {
    cseed[0] = '\0';
    rseed = 0;
    sl = strlen(line);
    i = 0;
    while ( i < sl )
    {
      c = line[i];
      c = 158 - c;
      strncat(cseed, &c, 1);
      ++i;
    }
    cseed[sl] = 0;
    rseed = atoi(cseed);
  }
 } while ( !feof(src) );

 fclose(src);
 return 0;
}

UIPB__random proc near 
 push ebp ; Function has frame pointer omitted
 mov ebp, esp
 mov eax, rseed
 imul eax, 25h
 add eax, 43h
 cdq
 mov ecx, 1Bh
 idiv ecx
 push edx ; int
 call _abs
 add esp, 4
 mov rseed, eax
 mov eax, rseed
 pop ebp
 retn
UIPB__random endp

int UIPB__random ( )
{ 
  rseed = abs((37 * rseed + 67) % 27);
  return rseed;
}