NoPaste

v2

von heinz
Beschreibung:
Verschluesselungsprogramm 2
Snippet erstellt:
22.05.2019 20:03:54
Snippet wird automatisch gelöscht:
Niemals

Dein Code:
  1. /*
  2.         Ver-/Entschluesseln von Dateien mit der 'Buch Methode'
  3.  
  4.         19-05-2019 -- heinz
  5.  
  6.  
  7.         Als Schluessel dient eine beliebige Datei.
  8.         Sie sollte gross genug sein und muss aus allen 256 Zeichen bestehen.
  9.  
  10.         Im Moment sollten keine Schluesseldateien verwendet werden die groesser als 900MB sind!
  11.  
  12.  
  13.  
  14.         ToDo:
  15.         -------
  16.         Es werden sicher Probleme auftauchen, wenn die Schluesseldatei so gross ist, dass dabei Positionen herauskommen
  17.         die mehr als 9 Stellen haben. (Also groesser als 999999999)
  18.         Siehe >int Zahllaenge(long long int Z)<
  19.         Man koennte vlt. einfach die Schluesselgroesse auf <1GB beschraenken...
  20. */
  21.  
  22.  
  23.  
  24.  
  25. // Serviceschalter ---------------------------------------------------------------------------------
  26. // Debug-Textausgaben an-/ausschalten.
  27. #define DEBUG false
  28.  
  29.  
  30. /* Tarnung an-/ausschalten.
  31.         Wenn Tarnung aus ist, werden die Adressen nur als eine lange Zeile von Nummern (Fundstellen) ausgegeben.
  32.         Die erste Stelle enthaelt die Anzahl der Stellen der Adresse. Dann kommt die Adresse und dann wieder die Anzahl der Stellen u.s.w.
  33.         Die Tarnung macht aus der langen Liste von Zahlen eine halb so grosse Datei mit Bytewerten
  34.         (Immer 2 Zahlen werden zu zu einem Wert zusammengefasst und gespeichert)
  35. */
  36. #define TARNUNG true
  37.  
  38.  
  39. // Analyse-Modus an-/ausschalten.
  40. // (Wenn Analyse an ist, werden Adressen Zeile fuer Zeile ausgegeben um die ermittelten Adressen besser zu erkennen)
  41. // (!Zur Analyse muss auch die Tarnung ausgeschaltet sein!)
  42. #define ANALYSE false
  43.  
  44.  
  45.  
  46.  
  47.  
  48. // Include -----------------------------------------------------------------------------------------
  49. #include <stdlib.h>
  50. #include <getopt.h>
  51. #include <fstream>
  52. #include <string.h>
  53. #include <sys/stat.h>
  54. #include <errno.h>
  55. #include <iomanip>
  56. #include <iostream>
  57.  
  58. #include "anleitung.h"
  59.  
  60.  
  61.  
  62.  
  63.  
  64. // Typen -------------------------------------------------------------------------------------------
  65. // Programm-Optionen
  66. struct option opts[]={
  67.       {"verschluesseln",         required_argument,0,  'v'},
  68.       {"verschluesseln_extrem",  required_argument,0,  'V'},
  69.       {"entschluesseln",         required_argument,0,  'e'},
  70.       {"zieldatei",              required_argument,0,  'z'},
  71.       {"schluesseldatei",        required_argument,0,  's'},
  72.       {"schluesselfrage",        required_argument,0,  'S'},
  73.       {"schluesseltest",         required_argument,0,  't'},
  74.       {"schluesseltest_frage",   no_argument,      0,  'T'},
  75.       {"keine_ausgaben",         no_argument,      0,  'k'},
  76.       {"anleitung",              no_argument,      0,  'a'},
  77.       {"help",                   no_argument,      0,  'h'},
  78.       {0,                        0,                0,    0}
  79. };
  80.  
  81.  
  82.  
  83.  
  84.  
  85.  
  86.  
  87.  
  88. // Globales ----------------------------------------------------------------------------------------
  89. char VERSION[]={"V 0.11"};
  90.  
  91. // Pools der Schluesseldatei
  92. long long int* pospool[256];
  93. long long int pospool_groesse[256];
  94. char* pool=NULL;
  95. char* tarnpool=NULL;
  96.  
  97. // Schluesselnoten
  98. char schluesselnoten[7][20]={
  99.         "Optimal",
  100.         "Gut",
  101.         "Mittelmaessig",
  102.         "Ausreichend",
  103.         "Schlecht",
  104.         "Sehr Schlecht",
  105.         "Miserabel"};
  106.  
  107. // Dateinamen
  108. const int MAX_ZEILENLAENGE=1024;
  109. char quelldateiname[MAX_ZEILENLAENGE]={""};
  110. char zieldateiname[MAX_ZEILENLAENGE]={""};
  111. char schluesseldateiname[MAX_ZEILENLAENGE]={""};
  112.  
  113. // Tempdatei
  114. char tempdateiname[]={"/tmp/V2_enttarn.bin"};
  115.  
  116. // Groesse der Schluesseldatei
  117. long long int schluesseldatei_groesse=0;
  118.  
  119. // Aktivitaetsanzeige
  120. bool aktiv_anzeige=true;
  121. char aktiv_zeichen[][2]={
  122.         "|",
  123.         "/",
  124.         "-",
  125.         "\\",
  126.         ""};
  127. bool textausgabe=true;
  128.  
  129. // Extrem verschluesseln. (Jedes Zeichen im pool wird nur einmal verwendet)
  130. bool extrem=false;
  131. const int extrem_versuche=4000;// (So oft wird versucht eine passende Position im Pool zu finden)
  132.  
  133.  
  134.  
  135. // Funktionen --------------------------------------------------------------------------------------
  136. bool Schluesseldatei_einlesen(char*);// (dateiname)
  137. void Verschluesseln();
  138. void Entschluesseln();
  139. void Tarnen();
  140. void Enttarnen();
  141.  
  142. bool Schluesseldatei_testen();// Gibt Schluesseldatei=OK zurueck.
  143. void Schluesseldateiname_abfragen();
  144. int Zahllaenge(long long int);// (zahl) Gibt Ziffern-Anzahl zurueck.
  145. void Pospool_erweitern(int,long long int);// (zeichen, position)
  146. void Pools_leeren();
  147. void Programm_beenden();
  148. bool Datei_existenz_test(char*);// (dateiname) Gibt existiert zurueck.
  149. long long int Dateigroesse(char*);// (dateiname) Gibt groesse in Bytes zurueck.
  150. void Datei_loeschen(char*);// (dateiname)
  151.  
  152. void Aktivitaets_anzeige();
  153. void Anleitung_ausgeben();
  154. void Bedienung();
  155.  
  156.  
  157.  
  158.  
  159.  
  160.  
  161.  
  162. // Debug Funktionen --------------------------------------------------------------------------------
  163. #if DEBUG
  164. void Test_pool_ausgabe();
  165. #endif
  166.  
  167.  
  168.  
  169.  
  170.  
  171.  
  172.  
  173. // Hauptteil ---------------------------------------------------------------------------------------
  174. int main(int argc, char *argv[])
  175. {
  176.         if(argc==1){Bedienung();}
  177.  
  178.         bool entschluesseln=false;
  179.         bool verschluesseln=false;
  180.         bool schluesseltest=false;
  181.  
  182.         int optc=0;
  183.         while((optc=getopt_long(argc,argv,"v:V:e:z:s:St:Tkah",opts,NULL))!=EOF)
  184.         {
  185.                 switch(optc)
  186.                 {
  187.                         case'V':
  188.                                 extrem=true;
  189.                         case'v':
  190.                                 strncat(quelldateiname,optarg,MAX_ZEILENLAENGE-1);
  191.                                 verschluesseln=true;
  192.                         break;
  193.                         case'e':
  194.                                 strncat(quelldateiname,optarg,MAX_ZEILENLAENGE-1);
  195.                                 entschluesseln=true;
  196.                         break;
  197.                         case'z':
  198.                                 strncat(zieldateiname,optarg,MAX_ZEILENLAENGE-1);
  199.                         break;
  200.                         case's':
  201.                                 if(strlen(schluesseldateiname)!=0)
  202.                                 {
  203.                                         fprintf(stderr,"\aSie koennen nur eine Schluesseldatei angeben!\n");
  204.                                         exit(1);
  205.                                 }
  206.                                 strncat(schluesseldateiname,optarg,MAX_ZEILENLAENGE-1);
  207.                         break;
  208.                         case'S':
  209.                                 if(strlen(schluesseldateiname)!=0)
  210.                                 {
  211.                                         fprintf(stderr,"\aSie koennen nur eine Schluesseldatei angeben!\n");
  212.                                         exit(1);
  213.                                 }
  214.                                 Schluesseldateiname_abfragen();
  215.                         break;
  216.                         case't':
  217.                                 if(strlen(schluesseldateiname)!=0)
  218.                                 {
  219.                                         fprintf(stderr,"\aSie koennen nur eine Schluesseldatei angeben!\n");
  220.                                         exit(1);
  221.                                 }
  222.                                 strncat(schluesseldateiname,optarg,MAX_ZEILENLAENGE-1);
  223.                                 schluesseltest=true;
  224.                                 fprintf(stderr,"Test der Schluesseldatei >%s<...\n",schluesseldateiname);
  225.                         break;
  226.                         case'T':
  227.                                 if(strlen(schluesseldateiname)!=0)
  228.                                 {
  229.                                         fprintf(stderr,"\aSie koennen nur eine Schluesseldatei angeben!\n");
  230.                                         exit(1);
  231.                                 }
  232.                                 Schluesseldateiname_abfragen();
  233.                                 schluesseltest=true;
  234.                         break;
  235.                         case'k':
  236.                                 textausgabe=false;
  237.                                 aktiv_anzeige=false;
  238.                         break;
  239.                         case'h':
  240.                                 Bedienung();
  241.                         break;
  242.                         case'a':
  243.                                 Anleitung_ausgeben();
  244.                         break;
  245.                 }
  246.         }
  247.  
  248.  
  249. // Man kann nicht Ver- und Entschluesseln gleichzeitig
  250.         if(verschluesseln && entschluesseln)
  251.         {
  252.                 fprintf(stderr,"\aSie muessen sich entscheiden! Wollen Sie Ver- oder Entschluesseln?\n");
  253.                 exit(1);
  254.         }
  255.  
  256.  
  257. // Quell-, Ziel- und Schluesseldatei muessen angegeben sein!
  258.         if(strlen(quelldateiname)==0 && !schluesseltest)
  259.         {
  260.                 fprintf(stderr,"\aSie muessen einen Dateinamen angeben!\n");
  261.                 exit(1);
  262.         }
  263.         if(strlen(zieldateiname)==0 && !schluesseltest)
  264.         {
  265.                 fprintf(stderr,"\aSie muessen einen Ziel-Dateinamen angeben!\n");
  266.                 exit(1);
  267.         }
  268.         if(strlen(schluesseldateiname)==0)
  269.         {
  270.                 fprintf(stderr,"\aSie muessen eine Schluesseldatei angeben!\n");
  271.                 exit(1);
  272.         }
  273.  
  274.  
  275. // Dateien auf existenz pruefen
  276.         if(!Datei_existenz_test(quelldateiname) && !schluesseltest)
  277.         {
  278.                 fprintf(stderr,"\aDie Quelldatei >%s< extstiert nicht!\n",quelldateiname);
  279.                 exit(1);
  280.         }
  281.         if(!Datei_existenz_test(schluesseldateiname))
  282.         {
  283.                 fprintf(stderr,"\aDie Schluesseldatei >%s< extstiert nicht!\n",schluesseldateiname);
  284.                 exit(1);
  285.         }
  286.  
  287.  
  288.  
  289.  
  290.  
  291. // Vorbereitung ------------------------------------------------------------------------------------
  292. // Zufall
  293.         srand48(time(0));
  294.  
  295. // Pool Leeren
  296.         for(int z=0;z<256;z++)
  297.         {
  298.                 pospool[z]=NULL;
  299.                 pospool_groesse[z]=0;
  300.         }
  301.  
  302. // Groesse der Schluesseldatei feststellen
  303.         schluesseldatei_groesse=Dateigroesse(schluesseldateiname);// (dateiname) Gibt groesse in Bytes zurueck.
  304.  
  305. // Speicher fuer Schluesseldatei erstellen
  306.         pool=(char*)calloc(schluesseldatei_groesse,sizeof(char));
  307.  
  308.  
  309. // Schluesseldatei einlesen
  310.         if(Schluesseldatei_einlesen(schluesseldateiname))// (dateiname)
  311.         {
  312.                 if(!Schluesseldatei_testen())
  313.                 {
  314.                         fprintf(stderr,"\aDie Schluesseldatei ist nicht verwendbar!\n");
  315.                         Programm_beenden();
  316.                 }
  317.         }
  318.  
  319. // Schluessel nur testen
  320.         if(schluesseltest){Programm_beenden();}
  321.  
  322. #if ! TARNUNG
  323.         fprintf(stderr,"\a\nAchtung Tarnung ist ausgeschaltet...\n\n");
  324. #endif
  325. #if ANALYSE
  326.         fprintf(stderr,"\a\nAchtung Analyse-Modus ist angeschaltet...\n\n");
  327. #endif
  328.  
  329.  
  330. // Ver-, Entschluesseln ----------------------------------------------------------------------------
  331.         if(verschluesseln)
  332.         {
  333.                 Verschluesseln();
  334.         }
  335.         if(entschluesseln)
  336.         {
  337.                 Entschluesseln();
  338.         }
  339.  
  340.  
  341.  
  342.  
  343. // Ende --------------------------------------------------------------------------------------------
  344.         Programm_beenden();
  345. }
  346.  
  347.  
  348.  
  349.  
  350.  
  351.  
  352.  
  353.  
  354.  
  355.  
  356.  
  357.  
  358. // Funktionen --------------------------------------------------------------------------------------
  359. bool Schluesseldatei_einlesen(char* SDN)// (dateiname)
  360. {
  361. // Schluesseldatei einlesen...
  362. #if DEBUG
  363.         fprintf(stderr,"Schluesseldatei >%s< einlesen...\n",SDN);
  364. #endif
  365.  
  366.         if(textausgabe)fprintf(stderr,"Lese Schluesseldatei >%s\n",schluesseldateiname);
  367.  
  368. // File-Handler erzeugen
  369.         std::ifstream load(SDN,std::ios::in);
  370.         if(load==NULL)
  371.   {
  372.         fprintf(stderr,"\aSchluesseldatei >%s< konnte nicht geoeffnet werden!\n",SDN);
  373.                 return(false);
  374.   }
  375.  
  376. // Schluesseldatei lesen
  377.         long long int pos=0;
  378.         char Z;
  379.         while(true)
  380.         {
  381.                 Aktivitaets_anzeige();
  382.  
  383.                 load.get(Z);
  384.                 if(load.eof()){break;}
  385. // Positionen im Positions-Pool ablegen
  386.                 Pospool_erweitern((unsigned char)Z,pos); // (zeichen, position)
  387. // Schluessel-Werte im Zeichen-Pool ablegen
  388.                 pool[pos]=Z;
  389.                 pos++;
  390.         }
  391.  
  392.         load.close();
  393.  
  394. #if DEBUG
  395.         Test_pool_ausgabe();
  396. #endif
  397.  
  398.  
  399.  
  400.         return(true);
  401. }
  402.  
  403.  
  404.  
  405.  
  406.  
  407.  
  408.  
  409.  
  410.  
  411.  
  412. void Verschluesseln()
  413. {
  414. #if DEBUG
  415.         fprintf(stderr,"Verschluesseln gestartet...\n");
  416. #endif
  417.  
  418. // Quelldatei einlesen...
  419. #if DEBUG
  420.         fprintf(stderr,"Quelldatei >%s< lesen,\nZieldatei >%s< schreiben...\n",quelldateiname,zieldateiname);
  421. #endif
  422.  
  423.         if(textausgabe)fprintf(stderr,"Verschluesseln von >%s<\nMethode >%s...\n",quelldateiname,extrem?"Extrem":"Normal");
  424.  
  425. // File-Handler erzeugen
  426.         std::fstream load(quelldateiname,std::ios::in);
  427.         if(load==NULL)
  428.   {
  429.         fprintf(stderr,"\a>%s< konnte nicht geoeffnet werden!\n",quelldateiname);
  430.                 return;
  431.   }
  432.  
  433.         std::fstream save;
  434.         save.open(zieldateiname,std::ios::out);
  435.         if(save==NULL)
  436.         {
  437.         fprintf(stderr,"\akonnte >%s< nicht anlegen!\n",zieldateiname);
  438.                 return;
  439.         }
  440.  
  441. // Verschluesseln
  442.         char Z;
  443.         long long int zufall=0;
  444.         while(true)
  445.         {
  446.                 Aktivitaets_anzeige();
  447.  
  448.                 load.get(Z);
  449.                 if(load.eof()){break;}
  450.                 if(!extrem)
  451.                 {
  452. // Normal Verschluesseln
  453.                         zufall=lrand48()%pospool_groesse[(unsigned char)Z];
  454. #if ANALYSE
  455.                         save<<pospool[(unsigned char)Z][zufall]<<std::endl;
  456. #else
  457.                         save<<Zahllaenge(pospool[(unsigned char)Z][zufall])<<pospool[(unsigned char)Z][zufall];
  458. #endif
  459.                 }
  460.                 else
  461.                 {
  462. // Extrem Verschluesseln (Jedes Zeichen im pool wird nur einmal verwendet)
  463.                         int versuche=0;
  464.                         bool gefunden=false;
  465.                         while(versuche<extrem_versuche)
  466.                         {
  467.                                 zufall=lrand48()%pospool_groesse[(unsigned char)Z];
  468.                                 if(pospool[(unsigned char)Z][zufall]>=0)
  469.                                 {
  470.                                         gefunden=true;
  471.                                         break;
  472.                                 }
  473.                                 versuche++;
  474.                         }
  475.                         if(gefunden)
  476.                         {
  477. #if ANALYSE
  478.                                 save<<pospool[(unsigned char)Z][zufall]<<std::endl;
  479. #else
  480.                                 save<<Zahllaenge(pospool[(unsigned char)Z][zufall])<<pospool[(unsigned char)Z][zufall];
  481. #endif
  482.                                 pospool[(unsigned char)Z][zufall]=-1;
  483.                         }
  484.                         else
  485.                         {
  486.                                 fprintf(stderr,"\aDie Schluesseldatei >%s< ist nicht gross genug!\n",schluesseldateiname);
  487.                                 load.close();
  488.                                 save.close();
  489.                                 Datei_loeschen(zieldateiname);// (dateiname)
  490.                                 Programm_beenden();
  491.                         }
  492.                 }
  493. //printf("Zeichen=%i # poolgr.=%lli # Z=%lli\n",(unsigned char)Z,pospool_groesse[(unsigned char)Z],zufall);
  494.         }
  495.         load.close();
  496.         save.close();
  497.  
  498. #if TARNUNG
  499.         Tarnen();
  500. #endif
  501.  
  502.  
  503. #if DEBUG
  504.         fprintf(stderr,"Verschluesseln beendet.\n");
  505. #endif
  506. }
  507.  
  508.  
  509.  
  510.  
  511.  
  512.  
  513.  
  514.  
  515.  
  516. void Entschluesseln()
  517. {
  518. #if DEBUG
  519.         fprintf(stderr,"Entschluesseln gestartet...\n");
  520. #endif
  521.  
  522.  
  523. // Quelldatei einlesen...
  524. #if DEBUG
  525.         fprintf(stderr,"Quelldatei >%s< lesen,\nZieldatei >%s< schreiben...\n",quelldateiname,zieldateiname);
  526. #endif
  527.  
  528. #if TARNUNG
  529.         Enttarnen();
  530.  
  531.  
  532. // File-Handler erzeugen
  533.         std::fstream load(tempdateiname,std::ios::in);
  534.         if(load==NULL)
  535.   {
  536.         fprintf(stderr,"\a>%s< konnte nicht geoeffnet werden!\n",tempdateiname);
  537.                 return;
  538.   }
  539. #else
  540.         std::fstream load(quelldateiname,std::ios::in);
  541.         if(load==NULL)
  542.   {
  543.         fprintf(stderr,"\a>%s< konnte nicht geoeffnet werden!\n",quelldateiname);
  544.                 return;
  545.   }
  546. #endif
  547.  
  548.         std::fstream save;
  549.         save.open(zieldateiname,std::ios::out);
  550.         if(save==NULL)
  551.         {
  552.         fprintf(stderr,"\akonnte >%s< nicht anlegen!\n",zieldateiname);
  553.                 return;
  554.         }
  555.  
  556.  
  557. // Entschluesseln
  558.         char Z;
  559.         while(true)
  560.         {
  561.                 Aktivitaets_anzeige();
  562.  
  563. #if ANALYSE
  564.                 long int W=0;
  565.                 char zeichen[MAX_ZEILENLAENGE];
  566.                 load.getline(zeichen,MAX_ZEILENLAENGE);
  567.                 if(load.eof()){break;}
  568.                 W=atol(zeichen);
  569. #else
  570.                 load.get(Z);
  571.                 if(load.eof()){break;}
  572.  
  573.                 int Zm=Z-48;
  574.                 long int W=0;
  575.                 for(int z=0;z<Zm;z++)
  576.                 {
  577.                         load.get(Z);
  578.                         W=W*10+Z-48;
  579.                 }
  580. #endif
  581.  
  582.                 if(W<schluesseldatei_groesse)
  583.                 {
  584.                         save<<pool[W];
  585.                 }
  586.                 else
  587.                 {
  588.                         fprintf(stderr,"\aDer Schluessel scheint falsch zu sein! >%s<\n",schluesseldateiname);
  589.                         Programm_beenden();
  590.                 }
  591. //printf("%c",pool[W]);
  592.         }
  593.         load.close();
  594.         save.close();
  595.  
  596.  
  597. // Tempdatei loeschen
  598. #if ! ANALYSE
  599.         Datei_loeschen(tempdateiname);// (dateiname)
  600. #endif
  601.  
  602. #if DEBUG
  603.         fprintf(stderr,"Entschluesseln beendet.\n");
  604. #endif
  605. }
  606.  
  607.  
  608.  
  609.  
  610.  
  611.  
  612.  
  613.  
  614.  
  615. void Tarnen()
  616. {
  617. #if DEBUG
  618.         fprintf(stderr,"Tarnen...\n");
  619. #endif
  620.  
  621. // Groesse der letzten Ausgabe feststellen
  622.         long long int dg=Dateigroesse(zieldateiname);
  623.  
  624. // Speicher fuer komplette Zieldatei anlegen
  625.         tarnpool=(char*)calloc(dg,sizeof(char));
  626. #if DEBUG
  627.         fprintf(stderr,"Datei- Poolgroesse=%lli\n",dg);
  628. #endif
  629.  
  630.  
  631. // File-Handler erzeugen
  632.         std::fstream load(zieldateiname,std::ios::in);
  633.         if(load==NULL)
  634.   {
  635.         fprintf(stderr,"\a>%s< konnte nicht geoeffnet werden!\n",zieldateiname);
  636.                 return;
  637.   }
  638. // Datei einlesen
  639.         long long int pos=0;
  640.         char Z;
  641.         while(true)
  642.         {
  643.                 Aktivitaets_anzeige();
  644.  
  645.                 load.get(Z);
  646.                 if(load.eof()){break;}
  647.                 tarnpool[pos]=Z;
  648.                 pos++;
  649.         }
  650.         load.close();
  651.  
  652. // Kennung erzeugen plus Marker, ob die Ursprungsdatei eine gerade oder ungerade anzahl von Bytes enthaelt
  653.         char kennung[4]={""};
  654.         sprintf(kennung,"V2%s",(dg%2==0)?"+":"-");
  655.  
  656. // File-Handler erzeugen
  657.         std::fstream save;
  658.         save.open(zieldateiname,std::ios::out);
  659.         if(save==NULL)
  660.         {
  661.         fprintf(stderr,"\akonnte >%s< nicht anlegen!\n",zieldateiname);
  662.                 return;
  663.         }
  664.  
  665. // Datei schreiben
  666.         save<<kennung;
  667.  
  668. // Immer 2 Zahlen aus dem Pool werden zu einem Hex-Wert und der wird geschrieben
  669.         long long int p=0;
  670.         char w=0;
  671.         while(true)
  672.         {
  673.                 Aktivitaets_anzeige();
  674.  
  675.                 w=tarnpool[p]-48;
  676.                 p++;
  677.                 if(p>=pos)
  678.                 {
  679.                         save<<w;
  680.                         break;
  681.                 }
  682.                 w=w*10+tarnpool[p]-48;
  683.                 save<<w;
  684.                 p++;
  685.                 if(p>=pos){break;}
  686.         }
  687.         save.close();
  688.  
  689.  
  690. #if DEBUG
  691.         fprintf(stderr,"Tarnen beendet.\n");
  692. #endif
  693. }
  694.  
  695.  
  696.  
  697.  
  698.  
  699.  
  700.  
  701.  
  702.  
  703. void Enttarnen()
  704. {
  705. #if DEBUG
  706.         fprintf(stderr,"Enttarnen...\n");
  707. #endif
  708.  
  709. // Groesse der Quelldatei feststellen
  710.         long long int dg=Dateigroesse(quelldateiname);
  711.  
  712. // File-Handler erzeugen
  713.         std::fstream load(quelldateiname,std::ios::in);
  714.         if(load==NULL)
  715.   {
  716.         fprintf(stderr,"\a>%s< konnte nicht geoeffnet werden!\n",quelldateiname);
  717.                 return;
  718.   }
  719.  
  720.         std::fstream save;
  721.         save.open(tempdateiname,std::ios::out);
  722.         if(save==NULL)
  723.         {
  724.         fprintf(stderr,"\akonnte >%s< nicht anlegen!\n",tempdateiname);
  725.                 return;
  726.         }
  727.  
  728.  
  729. // Kennung einlesen
  730.         bool gerade=true;
  731.         char Z;
  732.         for(int kp=0;kp<3;kp++)
  733.         {
  734.                 load.get(Z);
  735.                 switch(kp)
  736.                 {
  737.                         case 0:
  738.                                 if(Z!=86)// V
  739.                                 {
  740.                                         fprintf(stderr,"\aKeine gueltige Datei! >%s<\n",quelldateiname);
  741.                                         Programm_beenden();
  742.                                 }
  743.                         break;
  744.                         case 1:
  745.                                 if(Z!=50)// 2
  746.                                 {
  747.                                         fprintf(stderr,"\aKeine gueltige Datei! >%s<\n",quelldateiname);
  748.                                         Programm_beenden();
  749.                                 }
  750.                         break;
  751.                         case 2:
  752.                                 if(Z!=43 && Z!=45)// + -
  753.                                 {
  754.                                         fprintf(stderr,"\aKeine gueltige Datei! >%s<\n",quelldateiname);
  755.                                         Programm_beenden();
  756.                                 }
  757.                                 else
  758.                                 {
  759.                                         if(Z==45){gerade=false;}
  760.                                 }
  761.                         break;
  762.                 }
  763.         }
  764.  
  765.  
  766. // Datei einlesen und enttarnen
  767.         long long int p=0;
  768.         while(true)
  769.         {
  770.                 Aktivitaets_anzeige();
  771.  
  772.                 load.get(Z);
  773.                 if(load.eof()){break;}
  774.                 if(p>=dg-4)
  775.                 {
  776.                         if(gerade)
  777.                         {
  778.                                 save<<std::setw(2)<<std::setfill('0')<<(int)Z;
  779.                         }
  780.                         else
  781.                         {
  782.                                 save<<std::setw(1)<<(int)Z;
  783.                         }
  784.                 }
  785.                 else
  786.                 {
  787.                         save<<std::setw(2)<<std::setfill('0')<<(int)Z;
  788.                 }
  789.                 p++;
  790.         }
  791.         load.close();
  792.         save.close();
  793.  
  794.  
  795. #if DEBUG
  796.         fprintf(stderr,"Enttarnen beendet.\n");
  797. #endif
  798. }
  799.  
  800.  
  801.  
  802.  
  803.  
  804.  
  805.  
  806.  
  807.  
  808. int Zahllaenge(long long int Z)// (zahl) Gibt Ziffern-Anzahl zurueck
  809. {
  810.         char t[50]={""};
  811.         sprintf(t,"%lli",Z);
  812.         return(strlen(t));
  813. }
  814.  
  815.  
  816.  
  817.  
  818.  
  819.  
  820.  
  821.  
  822.  
  823.  
  824. void Pospool_erweitern(int Z,long long int P) // (zeichen, position)
  825. {
  826.         pospool_groesse[Z]++;
  827.         pospool[Z]=(long long int*)realloc(pospool[Z],pospool_groesse[Z]*sizeof(long long int));
  828.         if(pospool[Z]==NULL)
  829.         {
  830.                 fprintf(stderr,"\aKonnte keinen Speicher bekommen!\n");
  831.                 exit(1);
  832.         }
  833.         pospool[Z][pospool_groesse[Z]-1]=P;
  834. }
  835.  
  836.  
  837.  
  838.  
  839.  
  840.  
  841.  
  842.  
  843.  
  844. bool Schluesseldatei_testen()// Gibt Schluesseldatei=OK zurueck
  845. {
  846.         bool ok=true;
  847.  
  848. // Ist von jedem moeglichen Zeichen (0-255) min. 1 Vorhanden?
  849.         int fehlende_zeichen=0;
  850.         for(int z=0;z<256;z++)
  851.         {
  852.                 if(pospool_groesse[z]==0)
  853.                 {
  854.                         fehlende_zeichen++;
  855.                         ok=false;
  856.                 }
  857.         }
  858.         if(textausgabe)
  859.         {
  860.                 if(!ok){fprintf(stderr,"In der Schluesseldatei fehlen >%i< Zeichen!\n",fehlende_zeichen);}
  861. #if DEBUG
  862.                 else{fprintf(stderr,"In der Schluesseldatei sind alle 256 Zeichen vorhanden.\n");}
  863. #endif
  864.         }
  865.  
  866.  
  867. // Mindestanzahl der Auswahlzeichen im Pool ermitteln
  868.         int min_auswahlzeichen=10000;
  869.         for(int z=0;z<256;z++)
  870.         {
  871.                 if(pospool_groesse[z]<min_auswahlzeichen)
  872.                 {
  873.                         min_auswahlzeichen=pospool_groesse[z];
  874.                 }
  875.         }
  876. // Sicherheit schaetzen
  877.         int einschaetzung=0;
  878.         if(min_auswahlzeichen<10000 && min_auswahlzeichen>8000){einschaetzung=1;}
  879.         else if(min_auswahlzeichen<8000 && min_auswahlzeichen>6000){einschaetzung=2;}
  880.         else if(min_auswahlzeichen<6000 && min_auswahlzeichen>4000){einschaetzung=3;}
  881.         else if(min_auswahlzeichen<4000 && min_auswahlzeichen>2000){einschaetzung=4;}
  882.         else if(min_auswahlzeichen<2000 && min_auswahlzeichen>1000){einschaetzung=5;}
  883.         else if(min_auswahlzeichen<1000 && min_auswahlzeichen>800){einschaetzung=6;}
  884.         else if(min_auswahlzeichen<800){einschaetzung=7;ok=false;}
  885.         if(textausgabe && einschaetzung<7)
  886.         {
  887.                 fprintf(stderr,"Der \"Wert\" der Schluesseldatei ist > %s  %i <   (0-6)\n",schluesselnoten[einschaetzung],einschaetzung);
  888.         }
  889.  
  890.  
  891.  
  892.         return(ok);
  893. }
  894.  
  895.  
  896.  
  897.  
  898.  
  899.  
  900.  
  901.  
  902.  
  903.  
  904. void Schluesseldateiname_abfragen()
  905. {
  906.         fprintf(stderr,"Bitte geben Sie den Dateinamen der Schluesseldatei ein:\n");
  907.         std::cin>>schluesseldateiname;
  908. }
  909.  
  910.  
  911.  
  912.  
  913.  
  914.  
  915.  
  916.  
  917.  
  918. void Pools_leeren()
  919. {
  920. // Speicher des Positionspools freigeben
  921. #if DEBUG
  922.         fprintf(stderr,"Freigeben des Positionspools...\n");
  923. #endif
  924.         for(int z=0;z<256;z++)
  925.         {
  926.                 if(pospool[z]!=NULL)
  927.                 {
  928.                         free(pospool[z]);
  929.                         pospool[z]=NULL;
  930.                 }
  931.                 pospool_groesse[z]=0;
  932.         }
  933.  
  934. // Speicher des Zeichenpools freigeben
  935. #if DEBUG
  936.         fprintf(stderr,"Freigeben des Zeichenpools...\n");
  937. #endif
  938.         if(pool!=NULL)
  939.         {
  940.                 free(pool);
  941.                 pool=NULL;
  942.         }
  943.  
  944. // Speicher des Tarnpools freigeben
  945. #if DEBUG
  946.         fprintf(stderr,"Freigeben des Tarnpools...\n");
  947. #endif
  948.         if(tarnpool!=NULL)
  949.         {
  950.                 free(tarnpool);
  951.                 tarnpool=NULL;
  952.         }
  953. }
  954.  
  955.  
  956.  
  957.  
  958.  
  959.  
  960.  
  961.  
  962.  
  963. void Programm_beenden()
  964. {
  965.         Pools_leeren();
  966.  
  967.         if(aktiv_anzeige)
  968.         {
  969.                 fprintf(stderr,"\r");
  970.         }
  971.  
  972. #if DEBUG
  973.         fprintf(stderr,"Programmende.\n");
  974. #endif
  975.  
  976.         exit(0);
  977. }
  978.  
  979.  
  980.  
  981.  
  982.  
  983.  
  984.  
  985.  
  986.  
  987. bool Datei_existenz_test(char* D)// (dateiname) Gibt existiert zurueck.
  988. {
  989. #if DEBUG
  990.         fprintf(stderr,"TEST Datei: >%s< ",D);
  991. #endif
  992.  
  993. // (man 2 stat)
  994.         struct stat sb;
  995.         if(stat(D,&sb)!=0)
  996.         {
  997. #if DEBUG
  998.                 fprintf(stderr,"?? existiert nicht.\n");
  999. #endif
  1000.                 return(false);
  1001.         }
  1002.  
  1003.         if((sb.st_mode&S_IFMT)==S_IFREG)
  1004.         {
  1005. #if DEBUG
  1006.                 fprintf(stderr,"existiert.\n");
  1007. #endif
  1008.                 return(true);
  1009.         }
  1010.         else
  1011.         {
  1012. #if DEBUG
  1013.                 fprintf(stderr,"existiert nicht.\n");
  1014. #endif
  1015.                 return(false);
  1016.         }
  1017. }
  1018.  
  1019.  
  1020.  
  1021.  
  1022.  
  1023.  
  1024.  
  1025.  
  1026. long long int Dateigroesse(char* D)// (dateiname) Gibt groesse in Bytes zurueck.
  1027. {
  1028. #if DEBUG
  1029.         fprintf(stderr,"GROESSE Datei: >%s< ",D);
  1030. #endif
  1031.  
  1032. // (man 2 stat)
  1033.         struct stat sb;
  1034.         stat(D,&sb);
  1035.  
  1036. #if DEBUG
  1037.         fprintf(stderr,"%li\n",sb.st_size);
  1038. #endif
  1039.  
  1040.         return(sb.st_size);
  1041. }
  1042.  
  1043.  
  1044.  
  1045.  
  1046.  
  1047.  
  1048.  
  1049.  
  1050.  
  1051. void Datei_loeschen(char* DN)// (dateiname)
  1052. {
  1053.         if(remove(DN)<0)
  1054.         {
  1055.                 fprintf(stderr,"Konnte >%s< nicht loeschen!\n",DN);
  1056.                 switch(errno)
  1057.                 {
  1058.                         case EACCES:
  1059.                                 fprintf(stderr,">Fehlende Schreibberechtigung.<\n");
  1060.                         break;
  1061.                         case ENOENT:
  1062.                                 fprintf(stderr,">Diese Datei gibt es nicht.<\n");
  1063.                         break;
  1064.                         case EROFS:
  1065.                                 fprintf(stderr,">Datei befindet sich auf einem schreibgeschützten Medium.<\n");
  1066.                         break;
  1067.                 }
  1068.         }
  1069. }
  1070.  
  1071.  
  1072.  
  1073.  
  1074.  
  1075.  
  1076.  
  1077.  
  1078.  
  1079. void Aktivitaets_anzeige()
  1080. {
  1081.         if(!aktiv_anzeige){return;}
  1082.  
  1083.         static int zeichen=0;
  1084.         static int zaehler=0;
  1085.  
  1086.         if(zaehler%100000==0)
  1087.         {
  1088.                 fprintf(stderr,"  %s\r",aktiv_zeichen[zeichen]);
  1089.                 zeichen++;
  1090.                 if(strlen(aktiv_zeichen[zeichen])==0){zeichen=0;}
  1091.         }
  1092.         zaehler++;
  1093. }
  1094.  
  1095.  
  1096.  
  1097.  
  1098.  
  1099.  
  1100.  
  1101.  
  1102.  
  1103. void Anleitung_ausgeben()
  1104. {
  1105.         printf("\n");
  1106.         for(int z=0;z<anleitung_zeilenmenge;z++)
  1107.         {
  1108.                 printf("%s\n",anleitung_zeilen[z]);
  1109.         }
  1110.         exit(0);
  1111. }
  1112.  
  1113.  
  1114.  
  1115.  
  1116.  
  1117.  
  1118.  
  1119.  
  1120.  
  1121. void Bedienung()
  1122. {
  1123.         fprintf(stderr,"\nv2                                   %s\n",VERSION);
  1124.         fprintf(stderr,"\nOptionen:\n");
  1125.         fprintf(stderr,"+--------------------------------+----------+\n");
  1126.         fprintf(stderr,"|  Langform                      | Kurzform |\n");
  1127.         fprintf(stderr,"+--------------------------------+----------+\n");
  1128.         fprintf(stderr,"|  --verschluesseln        Name  | -v Name  |\n");
  1129.         fprintf(stderr,"|  --verschluesseln_extrem Name  | -V Name  |\n");
  1130.         fprintf(stderr,"|  --entschluesseln        Name  | -e Name  |\n");
  1131.         fprintf(stderr,"|  --schluesseldatei       Name  | -s Name  |\n");
  1132.         fprintf(stderr,"|  --schluesselfrage             | -S       |\n");
  1133.         fprintf(stderr,"|  --schluesseltest        Name  | -t Name  |\n");
  1134.         fprintf(stderr,"|  --schluesseltest_frage        | -T       |\n");
  1135.         fprintf(stderr,"|  --zieldatei             Name  | -z Name  |\n");
  1136.         fprintf(stderr,"|  --keine_ausgaben              | -k       |\n");
  1137.         fprintf(stderr,"|  --anleitung                   | -a       |\n");
  1138.         fprintf(stderr,"|  --help                        | -h       |\n");
  1139.         fprintf(stderr,"+--------------------------------+----------+\n\n");
  1140.         exit(0);
  1141. }
  1142.  
  1143.  
  1144.  
  1145.  
  1146.  
  1147.  
  1148.  
  1149.  
  1150.  
  1151.  
  1152. // Debug Funktionen --------------------------------------------------------------------------------
  1153. #if DEBUG
  1154. void Test_pool_ausgabe()
  1155. {
  1156.         fprintf(stderr,"Poolmengen...\n");
  1157.  
  1158.         for(int z=0;z<256;z++)
  1159.         {
  1160.                 fprintf(stderr,"Zeichen %-3i Menge %lli\n",z,pospool_groesse[z]);
  1161. /*              for(long long int p=0;p<pospool_groesse[z];p++)
  1162.                 {
  1163.                         printf("%lli\n",pospool[z][p]);
  1164.                 }*/
  1165.         }
  1166. }
  1167. #endif
  1168.  
  1169.  
  1170.  
  1171.  
  1172.  
  1173.  
  1174.  
  1175.  
  1176.  
  1177.  
  1178.  
  1179.  
  1180.  
  1181.  
  1182.  

Quellcode

Hier kannst du den Code kopieren und ihn in deinen bevorzugten Editor einfügen. Alternativ kannst du den gesamten Eintrag auch als Datei herunterladen.