API tools faq
paste
balsa0

Multi-Thread Exor cracker with nCurses by Shuffle

balsa0
Apr 5th, 2013
563
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 21.14 KB | None | 0 0
raw download clone embed print report
  1.  
  2. /* GNU GPL LICENSE
  3.  *
  4.  * MultiThread Exor Cracker
  5.  * Copyright (C) 2013; Kóti Balázs (ShuffleSource);
  6.  *
  7.  * Ez a program szabad szoftver; terjeszthető illetve módosítható a
  8.  * Free Software Foundation által kiadott GNU General Public License
  9.  * dokumentumában leírtak; akár a licenc 2-es, akár (tetszőleges) későbbi
  10.  * változata szerint.
  11.  *
  12.  * Ez a program abban a reményben kerül közreadásra, hogy hasznos lesz,
  13.  * de minden egyéb GARANCIA NÉLKÜL, az ELADHATÓSÁGRA vagy VALAMELY CÉLRA
  14.  * VALÓ ALKALMAZHATÓSÁGRA való származtatott garanciát is beleértve.
  15.  * További részleteket a GNU General Public License tartalmaz.
  16.  *
  17.  * A felhasználónak a programmal együtt meg kell kapnia a GNU General
  18.  * Public License egy példányát; ha mégsem kapta meg, akkor
  19.  * ezt a Free Software Foundationnak küldött levélben jelezze
  20.  * (cím: Free Software Foundation Inc., 59 Temple Place, Suite 330,
  21.  * Boston, MA 02111-1307, USA.)
  22.  *
  23.  */
  24.  
  25.  
  26. /* !!!Olvassel!!! (README)
  27.  
  28.     #fordítás:
  29.         g++ exor_fejt.cpp -o exor_fejt -lncurses -fopenmp -O3
  30.     #függőségek:
  31.         nCurses fv. könyvtár (http://ftp.gnu.org/pub/gnu/ncurses/)
  32. */
  33.  
  34.  
  35. /* Version History (changelog)
  36.     Version 0.1
  37.         Alapverzió.
  38.     Version 0.2
  39.         - Feature: minimum és maximum kulcshossz bevezetése.
  40.         - Feature: kulcstípus (charSet) bevezetése.
  41.     Version 0.3
  42.         - Feature: Részltes kiíratások bevezetése.
  43.     Version 0.4
  44.         - Feature: Időmérő bevezetése.
  45.     Version 0.5
  46.         - OpenMP párhuzamosítás bevezetése.
  47.         - Optimalizáció: inline direktíva a tryWithKey
  48.             függvénynek (~20% gyorsulás).
  49.         - Optimalizáció: a cSeed 'critical' OMP direktívát kapott.
  50.         - Optimalizáció: a kiíratások csak mesterszálon hajtódnak végre.
  51.         - Optimalizáció: a cSeed változó regiszter direktívát kapott.
  52.         - Bugfix: az óra (clock) mostantól csak a mesterszálon fut.
  53.     Version 0.6
  54.         - (+) Feature: nCurses alapú felhasználói felület bevezetése.
  55.         - (-) Featire: Karakteres kiíratások kigyomlálva.
  56.     Version 0.7
  57.         - Otimalizáció: hatékonyabb kulcs kiválasztó algoritmus beépítve.
  58.         - Feature: paraméterként megadható folyamat (%-ban)
  59.  
  60.  */
  61.  
  62. #include <iostream>
  63. #include <fstream>
  64. #include <stdlib.h>  
  65. #include <string>
  66. #include <vector>
  67. #include <cmath>
  68. #include <ctime>
  69. #include <omp.h>
  70. #include <ncurses.h>
  71.  
  72. //std névtér globálisan
  73. using namespace std;
  74.  
  75. //Globális rész
  76.     //terminál méretei
  77.     int row,col;
  78.  
  79.     //karakterkészlet
  80.     string charSet = "";
  81.  
  82.     //ablak szövege
  83.     char programTitle[] = "MultiThread Exor Cracker by Shuffle (v0.7)";
  84.  
  85.     //sor felülírása whitespace-el (törlés)
  86.     char wsClear[] = "              ";
  87.  
  88.     //white space érzékenység
  89.     int wsThreshold = 30;
  90.  
  91.     //ablakok
  92.     WINDOW *ui_header;
  93.     WINDOW *ui_main;
  94.     WINDOW *ui_progress;
  95.     WINDOW *ui_details;
  96.     WINDOW *ui_status;
  97.  
  98. //szövegrész dekódolása kulcs alapján
  99. inline string tryWithKey(vector<char> stream, string key, int chkLen = -1){
  100.     //kulcs léptető és kulcshossz
  101.     short keyCnt = 0;
  102.     short keyMax = key.length();
  103.  
  104.     //nem vizsgáljuk a teljes streamet csak egy kis részét
  105.     //a chklen adja meg ezt az értéket
  106.     //ha a teljes stream mérete kisebb mint az ellenőrizendő bájtok száma,
  107.     //akkor a teljes streamet ellenőrizzük
  108.     short checkLength = stream.size();
  109.     if (chkLen != -1)
  110.         checkLength = chkLen;
  111.     if (checkLength > stream.size())
  112.             checkLength = stream.size();
  113.  
  114.     //a deködolt szöveg ebben tárolódik
  115.     string result;
  116.  
  117.     //a stream és a kulcs bájtjai
  118.     char a,k,e;
  119.     //white space hiány figyelése
  120.     unsigned long noWSpace;
  121.     //a stream olvasása
  122.     for (int i = 0; i < stream.size(); ++i){
  123.         // 'a' a stream egy bájltja
  124.         a = stream[i];
  125.         // 'k' a kulcs egy bájtja
  126.         k = key[keyCnt];
  127.         // 'dekódolt bájt (e = a (xor) k)'
  128.         e = a ^ k;
  129.         //ha a karakter nem whitespace,
  130.         //a noWhitespace növelése, ellenkező esetben 0-zása
  131.         if (e != ' ' && e != '\n')
  132.             noWSpace++;
  133.         else
  134.             noWSpace = 0;
  135.  
  136.         //ha a whitespace hiány nagyobb mint az érzékenység,
  137.         //akkor a kulcs eldobása és kilépés a ciklusból
  138.         if (noWSpace > wsThreshold){
  139.             result = '#';
  140.             break;
  141.         }
  142.  
  143.         //dekódolt karakter hozzáírása végeredményhez
  144.         result += e;
  145.         //kulcs léptetése
  146.         keyCnt++;
  147.         //ha túlszaladunk a kulcson, akkor visszaugrasztjuk
  148.         if (keyCnt>=keyMax)
  149.             keyCnt = 0;
  150.     }
  151.  
  152.     return result;
  153. }
  154.  
  155. //kulcs generálása decimális számból
  156. string generateKeyFromSeed(register long long prevKey){
  157.     if(prevKey == 0) return "0";
  158.     //a 'számrendszer' alapszáma
  159.     int base = charSet.length();
  160.     //ebbe lesz tárolva a generált kulcs
  161.     string result = "";
  162.     do{
  163.         //átváltás 'számrendszerek' közt
  164.         //a charSet globális
  165.         result.push_back(charSet[prevKey%base]);
  166.         prevKey /= base;
  167.     }while(prevKey != 0);
  168.     //string megfordítása
  169.     return string(result.rbegin(), result.rend());
  170. }
  171.  
  172. //Felhasználói felület inicializálása
  173. void initUserInterface(){
  174.     //ncurses inicializálása
  175.     initscr();
  176.  
  177.     //terminál méretei
  178.     getmaxyx(stdscr,row,col);
  179.  
  180.     //ha a terminál támogatja, akkor színek bekapcsolása
  181.     if(has_colors())
  182.         start_color();
  183.  
  184.     //színpárok definiálása
  185.     init_pair(1, COLOR_WHITE, COLOR_RED); //fejléc színe
  186.     init_pair(2, COLOR_CYAN, COLOR_BLUE);   //alap szín
  187.     init_pair(3, COLOR_CYAN, COLOR_BLACK);  //statusbar
  188.     init_pair(4, COLOR_MAGENTA, COLOR_WHITE);   //részletek
  189.  
  190.     //fejléc ablak rajzolása
  191.         //új ablak
  192.         ui_header = newwin(3, col, 0, 0);
  193.         box(ui_header, 0 , 0);
  194.         wbkgd(ui_header,COLOR_PAIR(1));
  195.         //félkövér be
  196.         attron(A_BOLD);
  197.         //kiíratás ablakba (program neve és verziószám)
  198.         mvwprintw(ui_header,1,(col-(sizeof(programTitle)/sizeof(char)))/2,"%s",programTitle);
  199.         //félkövér ki
  200.         attroff(A_BOLD);
  201.         //kirajzolás (frissítés)
  202.         wrefresh(ui_header);
  203.  
  204.     //háttér rajzolása
  205.         ui_main = newwin(row-3, col, 3, 0);
  206.         wbkgd(ui_main,COLOR_PAIR(2));
  207.         wrefresh(ui_main);
  208.  
  209.     //progressbar ablak rajzolása
  210.         ui_progress = newwin(3, 52, ((row)/2)-4, (col-52)/2);
  211.         wbkgd(ui_progress,COLOR_PAIR(1));
  212.         box(ui_progress, 0 , 0);
  213.         mvwprintw(ui_progress,0,2,"%s","[Tores folyamatban]");
  214.         wrefresh(ui_progress);
  215.  
  216.     //részletes információk rajzolása
  217.         ui_details = newwin(6, 52, (row)/2, (col-52)/2);
  218.         wbkgd(ui_details,COLOR_PAIR(4));
  219.         box(ui_details, 0 , 0);
  220.             //Amennyiben nincs beérkező stream
  221.             mvwprintw(ui_details,2,2,"Varakozas a bejovo adatokra...");
  222.             mvwprintw(ui_details,3,2,"(Nincs input)");
  223.         wrefresh(ui_details);
  224.  
  225.     //statusbar ablak rajzolása
  226.         ui_status = newwin(1, col, row-1, 0);
  227.         wbkgd(ui_status,COLOR_PAIR(3));
  228.         //GNU GPL License szöveg
  229.         mvwprintw(ui_status,0,1,"%s","Copyright (C) 2013, SuffleSource - GNU General Public License");
  230.         wrefresh(ui_status);
  231. }
  232.  
  233. void stopUserInterface(){
  234.     endwin();
  235. }
  236.  
  237. //Használati utasítás kiírása képernyőre
  238. void help(){
  239.     cout << "==Használat==" << endl;
  240.     cout << "./exor_fejt <bemeneti fájlnév> <kapcsolók>" << endl << endl;
  241.     cout << "==Kapcsolók==" << endl
  242.          << "-o <fájlnév>: kimeneti fájlnév" << endl
  243.          << "\t (alapértelmezett: output.decrypt)" << endl
  244.          << "-l <szám>: legkisebb kulcshossz" << endl
  245.          << "-h <szám>: legnagyobb kulcshossz" << endl
  246.          << "-x <szám>: beolvasandó adat mennyisége" << endl
  247.          << "-t <szám>: keresési érzékenység (a kisebb szám az érzékenyebb) [1-100]" << endl
  248.          << "-p <szám>: kezdés megadott ponttól (százalékban) [1-100]" << endl
  249.          << "-s <szám>: kezdés megadott pontig (százalékban) [1-100]" << endl
  250.          << "-f <fájlnév>: összes talált kulcs kiírása fájlba" << endl
  251.          << "-g <fájlnév>: összes talált kulcs és adat kiírása fájlba" << endl
  252.          << "-c <szám>: eredmény kiírása standard kimenetre [1-2]" << endl
  253.          << "\t (1: kulcs kiírása)" << endl
  254.          << "\t (2: dekódolt szöveg kiírása)" << endl
  255.          << "-d <szám>: vizsgálat mélysége [1-1000]" << endl
  256.          << "\t (a nagyobb szám a részletesebb (lassabb))" << endl
  257.          << "\t (alapértelmezett: 200)" << endl
  258.          << "\t (-1 a maximális mélység)" << endl
  259.          << "-k <szám>: keresendő kulcs típusa [0-7]" << endl;
  260.     cout << "==Kulcs típusok==" << endl
  261.          << "0: számok, betűk és speciális karakterek" << endl
  262.          << "1: csak számok" << endl
  263.          << "2: csak kisbetűk" << endl
  264.          << "3: csak nagybetűk" << endl
  265.          << "4: kis- és nagybetűk" << endl
  266.          << "5: kis- és nagybetűk és számok" << endl
  267.          << "6: bináris számjegyek [0-1]" << endl
  268.          << "7: hexadecimális (nagybetű) [0-F]" << endl;
  269. }
  270.  
  271. //belépési pont (main)
  272. int main(int argc, char const *argv[])
  273. {
  274.     if (argc < 2){
  275.         cout << "Túl kevés argumentum!" << endl;
  276.         help();
  277.         return -1; 
  278.     }
  279.  
  280.     //indítási paraméterek alaphelyzetbe
  281.         //bemeneti fájl beolvasása
  282.         string inputFileName = argv[1];
  283.         //kimeneti fájl alapértelmezett neve
  284.         string outputFileName = "output.decrypt";
  285.         //argumentumok léptetése
  286.         *++argv;
  287.         --argc;
  288.         //beolvasandó karakterek száma
  289.         int charsNo = 300;
  290.         //legkisebb és legnagyobb kulcshossz
  291.         int minKey = 1;
  292.         int maxKey = 8;
  293.         //félbehagyott folyamat folytatása (%-ban)
  294.         int startPerCent = 0;
  295.         int stopPerCent = 101;
  296.         //keresési mélység
  297.         int searchDepth = 250;
  298.         //kulcs típusa
  299.         int keyMode = 0;
  300.         //minden kulcs kiírása fájlba
  301.         bool allKeysOut = false;
  302.         //kulcshoz tartozó adat kiírása fájlba
  303.         bool allKeysOutData = false;
  304.         string keyOutFile = "";
  305.  
  306.         //kiírás coutra (1: kulcs, 2:szöveg)
  307.         int isStdOut = 0;
  308.  
  309.     //paraméterek beolvasása
  310.     char c;
  311.     while (--argc && *(*++argv) == '-'){
  312.           switch (c = *((*argv++) + 1)){
  313.             case 'o':
  314.                 outputFileName = (*argv);
  315.                 break;
  316.             case 'l':
  317.                 minKey = atoi(*argv);
  318.                 break;
  319.             case 'h':
  320.                 maxKey = atoi(*argv);
  321.                 break;
  322.             case 't':
  323.                 wsThreshold = atoi(*argv);
  324.                 break;
  325.             case 'k':
  326.                 keyMode = atoi(*argv);
  327.                 break;
  328.             case 'p':
  329.                 startPerCent = atoi(*argv);
  330.                 break;
  331.             case 's':
  332.                 stopPerCent = atoi(*argv);
  333.                 break;
  334.             case 'd':
  335.                 searchDepth = atoi(*argv);
  336.                 break;
  337.             case 'f':
  338.                 allKeysOut = true;
  339.                 keyOutFile = (*argv);
  340.                 break;
  341.             case 'g':
  342.                 allKeysOut = true;
  343.                 allKeysOutData = true;
  344.                 keyOutFile = (*argv);
  345.                 break;
  346.             case 'c':
  347.                 isStdOut = atoi(*argv);
  348.                 break;
  349.             case 'x':
  350.                 charsNo = atoi(*argv);
  351.                 break;
  352.             case '?':
  353.                 //használati útmutató kiírása
  354.                 help();
  355.                 return -1;
  356.             default:
  357.                 cout << "ismeretlen opció! " << c << endl;
  358.                 help();
  359.                 return -1;
  360.             }
  361.           --argc;
  362.         }
  363.  
  364.     //feladat elnevezése
  365.     string job;
  366.     //kulcsmód alapján karakterkészlet beállítása
  367.     /* keyMode: kulcs típusa
  368.      * 0: számok, betűk és speciális karakterek
  369.      * 1: csak számok
  370.      * 2: csak kisbetűk
  371.      * 3: csak nagybetűk
  372.      * 4: kis- és nagybetűk
  373.      * 5: kis- és nagybetűk és számok
  374.      * 6: bináris
  375.      * 7: hexadecimális (nagybetű)
  376.      */
  377.     switch(keyMode){
  378.         case 0:
  379.             charSet += "0123456789";
  380.             charSet += "abcdefghijklmnopqrstuvwxyz";
  381.             charSet += "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  382.             charSet += "!@#$%^&*/";
  383.             job = "teljes";
  384.             break;
  385.         case 1:
  386.             charSet += "0123456789";
  387.             job = "decimális";
  388.             break;
  389.         case 2:
  390.             charSet += "abcdefghijklmnopqrstuvwxyz";
  391.             job = "kisbetűk";
  392.             break;
  393.         case 3:
  394.             charSet += "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  395.             job = "nagybetűk";
  396.             break;
  397.         case 4:
  398.             charSet += "abcdefghijklmnopqrstuvwxyz";
  399.             charSet += "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  400.             job = "betűk";
  401.             break;
  402.         case 5:
  403.             charSet += "0123456789";
  404.             charSet += "abcdefghijklmnopqrstuvwxyz";
  405.             charSet += "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  406.             job = "számok és betűk";
  407.             break;
  408.         case 6:
  409.             charSet += "01";
  410.             job =  "bináris";
  411.             break;
  412.         case 7:
  413.             charSet += "0123456789ABCDEF";
  414.             job = "hexadecimális";
  415.             break;
  416.         default:
  417.             cout << "Hibás kulcs típus: " << keyMode << endl;
  418.             help();
  419.             return 1;//hibás érték
  420.     }
  421.  
  422.     //kezdő idő megadása
  423.     time_t startTime = time(0);
  424.    
  425.     //felhasználói felület indítása
  426.     initUserInterface();
  427.  
  428.     //aktuális feladat kiírása
  429.     mvwprintw(ui_details,1,2,"Feladat: %d-%d karakter (%s) (t%d)",minKey,maxKey,job.data(),wsThreshold);
  430.     mvwprintw(ui_main,row-6,2,"Fajl: %s >> %s",inputFileName.data(),outputFileName.data());
  431.     wrefresh(ui_main);
  432.     //beolvasás kiírása részletek ablakohoz
  433.     //a sok whitespace az előző szöveg felülírásához kell
  434.     mvwprintw(ui_details,2,2,"Beolvasas...%s",wsClear);
  435.  
  436.     /*
  437.      * Törés kezdete
  438.      */
  439.  
  440.     //stream, a beérkező karakterek vektorba rendezve
  441.     vector<char> stream;
  442.     //a stream egy karaktere
  443.     char input;
  444.  
  445.     //fájl megnyitása
  446.     ifstream inputFile;
  447.     inputFile.open(inputFileName.data(), ios::binary);
  448.  
  449.     //ha a fájl nem létezik
  450.     if (!inputFile.is_open()){
  451.         stopUserInterface();
  452.         cout << "Érvénytelen fájl: " << inputFileName << "!" << endl;
  453.         return 2;
  454.     }
  455.  
  456.     //fájl olvasása
  457.     if (charsNo == -1){
  458.         while(!inputFile.eof()){
  459.             inputFile.get(input);
  460.             stream.push_back(input);
  461.         }
  462.     }else{
  463.         for (int l = 0; l < charsNo; ++l)
  464.         {
  465.             inputFile.get(input);
  466.             stream.push_back(input);
  467.         }
  468.     }
  469.  
  470.     inputFile.close();
  471.  
  472.     //kimeneti fájl megnyitása
  473.     ofstream outputFile;
  474.     outputFile.open (outputFileName.data(),ios::binary);
  475.  
  476.     //lehetséges kulcsok gyűjtése vektorba
  477.     vector<string> possibleKeys;
  478.  
  479.     //ebben tárolódik az éppen aktuális kulcs
  480.     string cKey = "";
  481.  
  482.     //ebben tárolódik az aktuálisan dekódolt szöveg
  483.     string actual;
  484.  
  485.     //talált lehetséges kulcsok száma
  486.     int foundKeys = 0;
  487.  
  488.     //folyamatjelzők
  489.     float progress = 0.0;
  490.     float prevProgress = 0.0;
  491.  
  492.     //ha a kezdőpont nagyobb mint a végpont
  493.     if (startPerCent > stopPerCent){
  494.         stopUserInterface();
  495.         cout << "Hibás kezdő- és végpont (%)! Adjon meg pozitív tartományt!" << endl;
  496.         return 4;
  497.     }
  498.     //a lehető legnagyobb mag értéke az adott paraméterekkel - folyamatszámításhoz szükséges
  499.     long long maxProgress = pow(charSet.length(),maxKey) - pow(charSet.length(),minKey-1);
  500.  
  501.     //ha hibás a keresési tartomány
  502.     if (maxProgress < 0){
  503.         stopUserInterface();
  504.         cout << "Hibás karakterszám! Adjon meg pozitív tartományt!" << endl;
  505.         return 4;
  506.     }
  507.  
  508.     //kezdő 'mag' a kulcsgenerátornak
  509.     register unsigned long long cSeed = 1 + pow(charSet.length(),minKey-1) + ((startPerCent*maxProgress)/100);
  510.  
  511.     //Időszámítással kapcsolatos változók
  512.         clock_t timer, prevTimer;
  513.         //kezdőidő beállítása
  514.         timer = clock();
  515.         //hátralévő idő
  516.         double timeLeft;
  517.  
  518.     //szálak száma
  519.     int threads = 1;
  520.  
  521.     //számláló, mely a néhai kiíratást segíti elő, szándékos túlcsordulással
  522.     short x;
  523.  
  524.     /*
  525.      * OpenMP Blokk (!!!)
  526.      * Parallel blokk kezdete - párhuzamosított rész
  527.      */
  528.     #pragma omp parallel shared(cSeed,x,possibleKeys) private(cKey,actual) firstprivate(timer,prevTimer)
  529.     {
  530.         //szálak száma
  531.         threads = omp_get_num_threads();
  532.         //szálak számának kiírása (csak mesterszálon)
  533.         #pragma omp master
  534.             mvwprintw(ui_details,0,44,"%d szal",threads);
  535.  
  536.         //ciklus kezdete - végtelen ciklus
  537.         //a számláló a kiíratáshoz kell
  538.         for (x = 0;;x++){
  539.  
  540.             //kulcs generálás
  541.             cKey = generateKeyFromSeed(cSeed);
  542.  
  543.             //a kulcs léptetése kritikus művelet, ezért csak egy szálon inkrementálódik!
  544.             #pragma omp critical
  545.                 cSeed++;
  546.  
  547.             //minden lehetséges kombináció meg volt vizsgálva (túlcsordulás)
  548.             if (cKey == "0")
  549.                 break;
  550.             if (cKey.length() > maxKey)
  551.                 break;
  552.  
  553.             //aktuális vizsgálat - visszatérési érték a dekódolt szöveg vagy egy '#' karakter
  554.             actual = tryWithKey(stream, cKey, searchDepth);
  555.             if (actual != "#"){
  556.                 //talált kulcsok számának növelése
  557.                 foundKeys++;
  558.                 //kulcs hozzáadása lehetséges kulcsokhoz
  559.                 #pragma omp critical
  560.                 possibleKeys.push_back(cKey);
  561.             }
  562.  
  563.             //aktuális folyamat kiszámítása (százalékban)
  564.             progress = (cSeed*100/maxProgress);
  565.  
  566.             //folyamatjelző változásakor futó blokk
  567.             #pragma omp master
  568.             {
  569.                 if (progress != prevProgress){
  570.  
  571.                     //ha túlléptük a végpontot, kilépés
  572.                     if (progress > stopPerCent)
  573.                         maxKey = 0;
  574.                     //időzítő mentése
  575.                     prevTimer = timer;
  576.                     //jelenlegi idő mérése
  577.                     timer = clock();
  578.                     //hátralevő idő számítása
  579.                     timeLeft = (((100-progress) * (timer - prevTimer)/CLOCKS_PER_SEC)/threads)+1;
  580.  
  581.                     //kiíratások
  582.                         //aktuális százalék kiírása
  583.                         mvwprintw(ui_progress,2,47,"%.f%s",progress,"%");
  584.                         //progressbar feltöltése
  585.                         mvwhline(ui_progress,1,1,ACS_VLINE,progress/2);
  586.                         //ablak frissítése
  587.                         wrefresh(ui_progress);
  588.                         //idő kiírása
  589.                         mvwprintw(ui_details,4,2,"Hatralevo ido:\t%.f mp ( %.f perc )     ",timeLeft, timeLeft/60,wsClear);
  590.                 }
  591.             }
  592.  
  593.             //folyamatjelző változásakor és megadott ciklusszám után végrehajtódó blokk
  594.             #pragma omp master //csak a mesterszálon
  595.             if (progress != prevProgress || x==0){
  596.  
  597.                 //progress mentése
  598.                 prevProgress = progress;
  599.  
  600.                 //Kiíratások
  601.                     //éppen vizsgált kulcs
  602.                     mvwprintw(ui_details,2,2,"Aktualis kulcs: \t%s%s", cKey.data(),wsClear);
  603.                     //eddig megtalált kulcsok
  604.                     mvwprintw(ui_details,3,2,"Talalt kulcsok: \t%d\t ",foundKeys);
  605.  
  606.                     //ablak frissítése
  607.                     wrefresh(ui_details);
  608.             }
  609.         }
  610.     }  
  611.     //Parallel blokk vége
  612.     #pragma omp end parallel
  613.  
  614.     //ha nem talált kulcsot, kilépés hibával!
  615.     if (foundKeys == 0){
  616.         //kilépés felhasználói felületből
  617.         stopUserInterface();
  618.  
  619.         //eredmény kiírása
  620.         cout << "===" << programTitle << "===" <<  endl;
  621.         cout << "\033[1;31mNem találtam kulcsot!\033[0;0m" << endl;
  622.         cout << "Próbáld újra más paraméterekkel!" << endl;
  623.         return 3;
  624.     }
  625.  
  626.     //találati lista szűkítése
  627.         //ablak átrajzolása
  628.         ui_details = newwin(3, 52, (row)/2, (col-52)/2);
  629.         wbkgd(ui_details,COLOR_PAIR(4));
  630.         box(ui_details, 0 , 0);
  631.         mvwprintw(ui_details,1,2,"Talalati lista csokkentese...");
  632.         refresh();
  633.         //legnagyobb betű arány
  634.         double maxAlphabetRatio = 0;
  635.        
  636.         //legnagyobb betű arányú kulcs
  637.         string idealKey = "";
  638.         string solution;
  639.  
  640.         //kimeneti fájl kulcsok kiírásához
  641.         ofstream allKeysFile;
  642.  
  643.         //fájl nyitása
  644.         if (allKeysOut){
  645.             allKeysFile.open (keyOutFile.data(),ios::binary);
  646.             allKeysFile << "=========" << programTitle << "=========" << endl;
  647.         }
  648.  
  649.         //whitespace treshold kikapcsolása
  650.         wsThreshold = stream.size();
  651.  
  652.         //talált kulcsok további ellenőrzése
  653.         for (int i = 0; i < possibleKeys.size()-1; ++i){
  654.  
  655.             //teljes szöveg dekódolása
  656.             actual = tryWithKey(stream, possibleKeys[i],-1);
  657.  
  658.             //kulcs fájlba írása ha szükséges
  659.             if (allKeysOut){
  660.                 allKeysFile << "Kulcs: " << possibleKeys[i] << endl;
  661.                 if (allKeysOutData){
  662.                     allKeysFile << actual << endl;
  663.                 }
  664.             }
  665.  
  666.             //betűk és egyéb karakterek arányának vizsgálata
  667.             long long fullLength = actual.length();
  668.             int alphabet = 0;
  669.  
  670.             //betűnkénti léptetés
  671.             for (int j = 0; j < actual.length(); ++j){
  672.                 if (    (actual[j] > 'A' && actual[j] < 'Z')
  673.                      || (actual[j] > 'a' && actual[j] < 'z')
  674.                      || actual[j] == ' ' ||  actual[j] == '\n')
  675.                     alphabet++;
  676.             }
  677.             //betű arány
  678.             double alphabetRatio = (double) alphabet/fullLength;
  679.             if (alphabetRatio > maxAlphabetRatio){
  680.                 maxAlphabetRatio = alphabetRatio;
  681.                 idealKey = possibleKeys[i];
  682.                 solution = actual;
  683.             }
  684.         }
  685.  
  686.     //kulcsokat tartalmazó fájl bezárása
  687.     allKeysFile.close();
  688.  
  689.     //találat kíirása
  690.     vector<char> fullStream;
  691.     if (maxAlphabetRatio > 0){
  692.         //ablak frissítése
  693.         mvwprintw(ui_details,1,2,"Eredmeny irasa fajlba...          ");
  694.         wrefresh(ui_details);
  695.  
  696.         //stream beolvasása, ezúttal végig
  697.        
  698.  
  699.         //fájl megnyitása
  700.         inputFile.open(inputFileName.data(), ios::binary);
  701.  
  702.         //beolvasás
  703.         while(!inputFile.eof()){
  704.             inputFile.get(input);
  705.             fullStream.push_back(input);
  706.         }
  707.     }
  708.  
  709.     //felhasználói felület megállítása
  710.     stopUserInterface();
  711.  
  712.     //találat kiírása, ha van
  713.     if (maxAlphabetRatio > 0){
  714.         solution = tryWithKey(fullStream, idealKey, -1);
  715.         outputFile << "=========" << programTitle << "=========" << endl;
  716.         outputFile << "Kulcs: " << idealKey << endl;
  717.         outputFile << solution << endl;
  718.     }else{
  719.         outputFile << "HIBA! Nem találtam megfelelő kulcsot!";
  720.     }
  721.  
  722.     //fájl bezárása 
  723.     outputFile.close();
  724.  
  725.     switch (isStdOut){
  726.         case 0:
  727.             cout << "===" << programTitle << "===" <<  endl;
  728.             cout << "Megvizsgált kulcsok: \t" << cSeed << endl;
  729.             cout << "Talált kulcsok: \t" << foundKeys << endl;
  730.             cout << "Lehetséges kulcs: \t" << idealKey << endl;
  731.             cout << "\033[1;31mFutási idő: " << difftime(time(0),startTime) << "mp\033[0;0m"<< endl;
  732.             break;
  733.         case 1:
  734.             cout << idealKey;
  735.             break;
  736.         case 2:
  737.             cout << solution;
  738.             break;
  739.         default:
  740.             cout << "HIBA! c kapcsoló argumentuma hibás!" << endl;
  741.     }
  742.     //eredmények kiírása
  743.  
  744.  
  745.     //kilépés
  746.     return 0;
  747. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!