Kleines Programm zur chiffrierung von Dateien mit vigenere

[rustyoldguy]

Hallo Leute,

hier möchte ich ein kleines Programmchen veröffentlichen, was ich selber geschrieben habe.
Es kann nur Text-Dateien verschlüsseln.
zuerst
vigenere.h:

// header vigenere.h von vigenere1f
#ifndef VIGENERE_INC_
#define VIGENERE_INC_ 1

#include <stdio.h>
#include <iostream>
#include <string>
#include <iomanip>  // wegen setw
#include <unistd.h> // wegen getcwd()
#include <fcntl.h>  /// Symbolische Konstanten fuer open
#include <fstream>
#include <sys/stat.h> // getFilesize, stat
#include <stdlib.h> // malloc

//int shift(char c);

void clpuf(void);               // Tastaturpuffer loeschen
short getcharart(char letter);  // stellt Laenge des Zeichens in Byte fest
int atoint(char letter);        // signed char in int 
std::string getstrchar(std::string mot, int pos);
int getletterpos(std::string mot, std::string letter);
int letterlaenge(std::string str); // Stellt die Laenge eines cpp-Strings in Buchstaben fest. string.lengtch() stellt die Laenge in Byte fest
int getfistcharpos(std::string alf, int pos);
unsigned int chartoint(unsigned char intteile[4]);  // 4Byte-unsigned char array zu 4Byte int
void clearchararray(char array[], int lge);         // eindimensionales Array loeschen
std::string getfilestring(std::fstream *datei, int *zeize);
void ZeigeZeichen(int i, std::string char_letter, std::string letter_chiffriert, std::string letter_dechiffriert);

class vigenere
{
 public:
   vigenere();
   ~vigenere();	
   //Menues
   void HAUPTMENUE(void);
   int MenueFrage(void);
   void GetKeyword(void);	
   void GetPlaintext(void);
   
   void ShowVigenereTable(void);
   void SetzeTestVorgaben(void);
   void Buchstabenplatzliste(void);
   void BuchstabenplatzTest(void);
   void Rotiere_plaintext(void);
   void rotiere_Ur_abc(void);
      
   std::string vigens(std::string alf, int pos);
   std::string mkvigboard(std::string zeichen, int xpos);
   std::string get_xpos_Letter(std::string Ur_abc, int pos);
   int get_xLetter_pos(std::string Ur_abc, std::string gesucht);
   std::string RotiereUr_abc(std::string Ur_abc, int i, std::string *keychar);
   std::string chiffrieren(int i,  std::string char_txt, int chiffreart);
   void ShowLaengentafel(void);
   void ShowKey(void);
   void ShowVarib(int i, int j, std::string teile);
   void ShowVari(int i, int j, std::string teile, std::string char_chiffriert);  
   void getcurdir(void);
   void StringToChar(std::string wort, char satz[]);
   long getFilesize(const std::string& filename);
   int ReadValIn(std::string in_File_Name, int modus);
   void putfilestring(std::ofstream *datei, std::string tosend);
   
   //String-Variable
   std::string Ur_abc;
   std::string abc_rotiert = ""; 
   std::string key = "";        // Schluesselwort
   std::string plaintext = "";  // zu schiffrierender Text
   std::string teilb = "";
   std::string keychar = "";    // Buchstabe von  Schluesselwort
   std::string srcfilename = "";
   std::string tarfilename = "";
   char dummy[400];
   int klen;
   int kbulen;
   int txtlen;
   int txtbulen;
   int abclen;
   int Ur_abc_buchslen;
   int ypos;
   long srcdatlen;
   
};


#endif

nun vigenere.cpp

// header vigenere.cpp of vigenere1f
//vigenere::vigenere()
//vigenere::~vigenere(){};	 
//std::string vigenere::vigens(std::string Ur_abc, int pos)
//std::string getstrchar(std::string mot, int pos)
//std::string vigenere::mkvigboard(std::string zeichen, int xpos)	
//int getfistcharpos(std::string alf, int pos)
//void vigenere::getcurdir(void)
//void vigenere::StringToChar(std::string wort, char satz[])
//long vigenere::getFilesize(const std::string& filename)
//int vigenere::ReadValIn(std::string in_File_Name)

#include "vigenere.h"
 
vigenere::vigenere()
{
 std::string Ur_abc_init = "abcdefghijklmnopqrstuvwxyzöäüß ABCDEFGHIJKLMNOPQRSTUVWXYZÖÄÜ0123456789.,!?;:-+*~#'<>|²³€@/^°µ_§${}[]()´`\n"; // mit Newline-sign
 Ur_abc = Ur_abc_init;	
 abclen = Ur_abc.length();
 Ur_abc_buchslen = letterlaenge(Ur_abc); // Laenge Ur_abc in Buchstaben
};
vigenere::~vigenere(){};	 


// schneidet aus cpp-string ab Position 0 bis einschliesslich pos
// den Teilstring aus und stellt ihn ans Ende des cpp-Strings
std::string vigenere::vigens(std::string Ur_abc, int pos)
{
 int Ur_abc_bulen = 0, charpos = 0; 
 std::string Buchstabe = "";
 std::string teila = Ur_abc;
 std::string teilb = Ur_abc;
 
 Ur_abc_bulen = letterlaenge(Ur_abc);
 
 if ((pos > 0) && (pos < (Ur_abc_bulen - 1))) 
  {
   Buchstabe = get_xpos_Letter(Ur_abc, pos);
   charpos = getletterpos(Ur_abc, Buchstabe);	 
   
   teila = Ur_abc.substr(0,  charpos);  // erster Teil von Zeichen 0 an bis einschliesslich pos zu teila kopieren
   teilb.erase (0, charpos);            // Loesche von teilb der ersten Teil
   teilb += teila;                      // geloeschten ersten Teil an teilb anhaengen
   //std::cout << "pos=" << pos << "  charpos = " << charpos << "  Buchstabe=" << Buchstabe <<    "  teila= " << teila << "  teilb=" << teilb << std::endl;
  }	 
   else teilb = Ur_abc;
    
 return teilb;
}

 
// Gibt den Buchstaben an Position pos im String mot zurueck
std::string getstrchar(std::string mot, int pos)
{
 std::string rewer = "";
 int lge, chlen = 0, firstcharpos = 0;
 
 lge = mot.length();            // Laenge von mot in Byte

 firstcharpos = getfistcharpos(mot, pos);  // Position des ersten Bytes bei laengeren Zeichen
 chlen = getcharart(mot[firstcharpos]);	 // Laenge des Zeichens feststellen 

 if(pos < lge)
  rewer = mot.substr(pos,  chlen);  
 	
 return rewer;	
} 


// Dient zur Herstellung des rotierten Alphabets
// vigens schneidet aus cpp-string(arg1) ab Position 0 bis pos
// den Teilstring aus und stellt ihn ans Ende des cpp-Strings
std::string vigenere::mkvigboard(std::string zeichen, int xpos)		 
{
 int txtlen = 0;
 std::string teilc = "";
 
  txtlen = zeichen.length();  // Laenge von zeichen in Byte feststellen
 
  // wenn xpos >= 1 dann xpos -1 bei vigens
  if ((xpos > 0) && (xpos < txtlen)) 
   teilc = vigens(zeichen, xpos); // Nach xpos des Schluesselbuchstabens Originalalphabet rotieren
	 else
      teilc = zeichen;   

 return teilc;	  	  
}

int getfistcharpos(std::string alf, int pos)	 
{
 int i, chlen = 0; 
 chlen = getcharart(alf[pos]); 
 
 if (chlen == 5)//(chlen > 1)
 for (i = pos; i >= 0; i--)
  {
   chlen = getcharart(alf[i]); 
   if (chlen <= 4)
    { 
	 pos = i; 
	 break;
	}
	
  }
  
//std::cout << std::endl; 
 return pos;
} 

void vigenere::getcurdir(void)
{
  char curverz[400] = {0};
  
  if (getcwd(curverz, sizeof(curverz)) == NULL)
    perror("getcwd() error");	
   else std::cout << "current DIR: " << curverz << std::endl;
} 

// converts a cpp string to char
void vigenere::StringToChar(std::string wort, char satz[])
{
int slei, wolen;
wolen = wort.length();

for (slei = 0; slei < wolen; slei++)
 {
 satz[slei] = wort[slei];
 satz[slei +1] = '\0';
 }
}

long vigenere::getFilesize(const std::string& filename)
{
 struct stat st;

  if(stat(filename.c_str(), &st) != 0)
   {
    return 0;
   }

    return st.st_size;   
}

int vigenere::ReadValIn(std::string in_File_Name, int modus)
{
 int rewer = -1, i;
 long bulen = srcdatlen;
 std::fstream dat_ein;
 std::ofstream dat_aus;
 std::string char_letter = "";
 std::string letter_chiffriert = "";
 std::string letter_dechiffriert = "";
 char chararray[8];
 

 if((modus < 0) || (modus > 1)) modus = 0; 
 
 std::cout << "Modus = " << modus << std::endl;
 
 dat_ein.open(in_File_Name, std::fstream::in | std::fstream::binary);

 if (!dat_ein)
  {
   std::cout << "Datei konnte nicht geoeffnet werden!" << std::endl;
   return rewer;
  }
 
 dat_aus.open(tarfilename.c_str(), std::ofstream::out | std::ofstream::binary);
  if (!dat_aus)
   {
    std::cout << "Ziel-Datei kann nicht erstellt werden!" << std::endl;
    return(rewer);
   }
    else 
    std::cout << "Ziel- und Quelldatei wurden geoeffnet, lese Zeichen ein." << std::endl;

 
 
 bulen = 0;
 for (i = 0; i < srcdatlen; i++)
  {
   char_letter = getfilestring(&dat_ein, &i);   // Zuerst UTF8-Zeichen von Quelldatei holen
	
   //In c-String-array konvertieren
   clearchararray(chararray, 8);           
   StringToChar(letter_chiffriert, chararray);	
	
   bulen++; // Zeichenzaehler
     
   letter_chiffriert = chiffrieren(i, char_letter, modus);
     
   //letter_dechiffriert = chiffrieren(i, letter_chiffriert, 1);
   //ZeigeZeichen(i, char_letter, letter_chiffriert, letter_dechiffriert); 
   
   putfilestring(&dat_aus, letter_chiffriert);
   
  }


 dat_ein.close();
 std::cout << std::endl << "Quelldatei wurde geschlossen." << std::endl;
 dat_aus.close();
 std::cout << "Ziel-Datei wurde erstellt und gechlossen." << std::endl;
 rewer = 0;

 return rewer;
}

jetzt varicng.cpp

// header varicng.cpp von vigenere1f
//Inhalt varicng.cpp:
//void clpuf(void)
//int atoint(char letter)
//unsigned int chartoint(unsigned char intteile[4])
//short getcharart(char letter)
//int letterlaenge(std::string str)
//std::string vigenere::get_xpos_Letter(std::string Ur_abc, int pos)
//int getletterpos(std::string mot, std::string letter)
//int vigenere::get_xLetter_pos(std::string Ur_abc, std::string gesucht)
//void vigenere::ShowVari(int i, int j, std::string teile, std::string char_chiffriert) 
//void vigenere::ShowVarib(int i, int j, std::string teile)
//void vigenere::ShowKey(void)
//std::string vigenere::RotiereUr_abc(std::string Ur_abc, int i, std::string *keychar)
//std::string vigenere::chiffrieren(int i, std::string char_txt, int chiffreart)
//void clearchararray(char array[], int lge)
//std::string getfilestring(std::fstream *datei, int *zeize)
//void vigenere::putfilestring(std::ofstream *datei, std::string tosend)
//void ZeigeZeichen(int i, std::string char_letter, std::string letter_chiffriert, std::string letter_dechiffriert) 



#include "vigenere.h"

// loescht Tastaturpuffer
void clpuf(void)
{
 while (getc(stdin) != '\n')
    ;
}
 
//Umwandlung von signed char zu int
int atoint(char letter)
{
 int rewer;
 if ( letter < 0)
  rewer = letter + 256;
   else rewer = (int)letter;
 return rewer;
}  


// Konvertiert ein 4Byte-langes unsigned_char_array in einen unsigned_int-Wert
unsigned int chartoint(unsigned char intteile[4])
{
 union intpart{
 unsigned int erge;
 unsigned char ipart[4];	
} ipt;

 ipt.ipart[0] = intteile[0];
 ipt.ipart[1] = intteile[1];
 ipt.ipart[2] = intteile[2];
 ipt.ipart[3] = intteile[3];
 
return ipt.erge;
}

 
// erkennt bei UTF 8 die Zeichenlaenge in Byte
short getcharart(char letter)
{
 short rewer = -1;
 int bu = atoint(letter);
	if (bu < 192) rewer = 1; // Dann liegt ein einzelnes Zeichen fuer einen Buchstaben vor
	if ((bu >= 192) && (bu < 224)) rewer = 2;  // Erstes Markierunszeichen fuer 2 Byte pro Buchstaben
	if ((bu >= 224) && (bu < 240)) rewer = 3;  // Erstes Markierunszeichen fuer 3 Byte pro Buchstaben
	if (bu >= 240)rewer = 4;                   // Erstes Markierunszeichen fuer 4 Byte pro Buchstaben
	if ((bu >=128) && (bu <= 191)) rewer = 5; // ist Folge-Byte von 2 bis 4 Byte pro Zeichen
 return rewer;
} 

// Stellt die Laenge eines cpp-Strings in Buchstaben fest. string.length() stellt die Laenge in Byte fest
int letterlaenge(std::string str)
{ 
  std::string dummy = "";
  int i, bu = 0, sl = 1, lge = -1, bulen = 0;
  lge = str.length();

  bulen = lge;

 for (i = 0; i < lge; i++)
  {
   bu = str[i];               // Hole einzelnes Char aus str
   sl = getcharart(bu);       // Bestimme Zeichenlaenge
   dummy = str.substr(i,sl);  // Kopiere Zeichen in dummy
   if(sl > 1 ) i += (sl - 1); // Wenn Zeichen laenger als 1 char i += (Zeichenlaenge -1)
   bulen -= (sl - 1);         // Von strlaenge (Zeichenlaenge -1) abziehen
   //std::cout << str.at(i) << " =  " << int atoint(str.at(i)) << std::endl;
   //std::cout << "i: " << i  << " bulen="<< bulen  << "  " << dummy << " = " << std::setw(3) << bu << "   laenge: " << sl << "  =  " << atoint(bu) << std::endl;
  }
 //std::cout << "-----------\n";
 return bulen;
}  




// Holt aus einen cpp-String das Zeichen nach Buchstabennummer, nicht nach Byte-Nummer
std::string vigenere::get_xpos_Letter(std::string Ur_abc, int pos)	
{
 int j, bulen = 0, chlen = 0, abclen = 0; 
 std::string teilb = "";      
 abclen = Ur_abc.length();	

   for (j = 0; j < abclen; j++)
	     { 
		  chlen = getcharart(Ur_abc[j]);    // Bestimme Laenge des Zeichens von Ur_abc
		  if(chlen <= 4) teilb = Ur_abc.substr(j, chlen);  // Kopiere Ur_abc in teilb
		   else teilb = "";
		 
		   if((chlen < 5) && (bulen == pos)) break;
		   	  
           if (chlen <= 4) bulen++;
		 } 

 return teilb;
}	  

//Sucht im String mot nach der Zeichenfolge letter und gibt bei Erfolg dessen Position zurück
int getletterpos(std::string mot, std::string letter)
{
 std::size_t found;
 int pos = -1;
 
 found = mot.find(letter);
 
 if (found!=std::string::npos)
    pos = found;
  
 return pos; 
}

int vigenere::get_xLetter_pos(std::string Ur_abc, std::string gesucht)	
{
 int j, bulen = 0, chlen = 0, abclen = 0; 
 std::string teilb = "";      
 
 abclen = Ur_abc.length();	// Byte-Laenge von Ur_abc

   for (j = 0; j < abclen; j++)
	     { 
		  chlen = getcharart(Ur_abc[j]);    // Bestimme Laenge des Zeichens von Ur_abc
		  if(chlen <= 4) teilb = Ur_abc.substr(j, chlen);  // Kopiere Ur_abc in teilb
		   else teilb = "";
		 
           if (teilb.compare(gesucht) == 0) break;
		   			  
           if (chlen <= 4) bulen++;
		 } 
  
 return bulen; 
}	  



void vigenere::ShowVari(int i, int j, std::string teile, std::string char_chiffriert)  
{ 
 int keycharlen = 0, teilelen = 0;
 
 keycharlen = keychar.length();
 teilelen = teile.length();
 
 std::cout << "  i=" << std::setw(2) << i << " j=" << std::setw(2) << j;
 std::cout << "  keychar= "<< std::setw(keycharlen) << keychar << "  chiffiert-teile: " << std::setw(teilelen) << teile;
 std::cout << "  unchiffriert[i]="<< char_chiffriert << " text-ypos= "  << std::setw(2)<< ypos;
 std::cout << "  abc rotiert: " << abc_rotiert << std::endl;
}
 
void vigenere::ShowVarib(int i, int j, std::string teile)  
{ 
 int keycharlen = 0, teilelen = 0;
 
 keycharlen = keychar.length();
 teilelen = teile.length();        
 std::cout << "  i=" << std::setw(2) << i << " j=" << std::setw(2) << j;
 std::cout << "  keychar= " << std::setw(keycharlen) << keychar << "  chiffriert-teile: " << std::setw(teilelen) << teile;
 std::cout << "  unchiffriert[i]="<< plaintext[j] << " text-ypos= " << std::setw(2)<< ypos;
 std::cout << "  abc rotiert: " << abc_rotiert << std::endl;
}

void vigenere::ShowKey(void)
{       
 std::cout << "Schluessel......: " << key << std::endl;
 std::cout << "Schluessel-Laenge in Byte......: " << klen << std::endl;
 std::cout << "Schluessel-Laenge in Buchstaben: " << kbulen << std::endl<< std::endl;
}

std::string vigenere::RotiereUr_abc(std::string Ur_abc, int i, std::string *keychar)
{
  int kchpos;
  std::string abc_rotiert;
   
  *keychar = get_xpos_Letter(key, i);        // einzelnes Ur_abc aus Schluesselstring nach teilb holen
  kchpos= get_xLetter_pos(Ur_abc, *keychar); // Originalposition des SchluesselUr_abcs im Originalalphpabet feststellen
  abc_rotiert = mkvigboard(Ur_abc, kchpos);  // Nach Schluesselbuchstabe Originalalphabet rotieren 
   
  //std::cout << "kchpos: " << kchpos << std::endl; 
  return abc_rotiert; 
}

std::string vigenere::chiffrieren(int i, std::string char_txt, int chiffreart)
{
 std::string letter_chiffriert = "";
 
 if (chiffreart == 0)
  {
   abc_rotiert = RotiereUr_abc(Ur_abc, i, &keychar);   // Herstellung des rotierten Alphabets
   ypos = get_xLetter_pos(Ur_abc, char_txt);               // Sucht in Ur_abc nach char_txt und gibt bei Erfolg dessen Position zurück
   letter_chiffriert = get_xpos_Letter(abc_rotiert, ypos); // hole einzelnes Ur_abc von rotierten Alphabet 
  }
  else
  {
   abc_rotiert = RotiereUr_abc(Ur_abc, i, &keychar);   // Herstellung des rotierten Alphabets
   ypos = get_xLetter_pos(abc_rotiert, char_txt);   // Sucht in abc_rotiert nach char_chiffriert und gibt bei Erfolg dessen Position zurück
   letter_chiffriert = get_xpos_Letter(Ur_abc, ypos);    
  }	  
 return letter_chiffriert;
}	

void clearchararray(char array[], int lge)
{
 for (int i = 0; i < lge; i++)
  array[i] = 0;	 
}

std::string getfilestring(std::fstream *datei, int *zeize)
{
 int i, chlen = 0, j;
 char buchs;
 std::string erge = "";
 
 j = *zeize;
 datei->get(buchs);  
 chlen = getcharart(buchs);
 erge += buchs;

 for (i = 1; i < chlen; i++)
  {
   datei->get(buchs);
   erge += buchs;
   j++;
  }

  *zeize = j;

 return erge;
}

void vigenere::putfilestring(std::ofstream *datei, std::string tosend)
{
 char buchs;
 char arrayteile[8];
 int i, tosend_lge = 0;
 
 tosend_lge = tosend.length(); // Laenge von cpp-String tosend in Byte

 clearchararray(arrayteile, 8);
 StringToChar(tosend, arrayteile);

 for (i = 0; i < tosend_lge; i++)
  datei->put(arrayteile[i]);
 
}

void ZeigeZeichen(int i, std::string char_letter, std::string letter_chiffriert, std::string letter_dechiffriert) 
{ 
 std::cout << "i=" << std::setw(3) << i << "  unchiffriert=" << char_letter << "  chiffriert=" << letter_chiffriert;
 std::cout << "  dechiffriert=" << letter_dechiffriert << std::endl;
   //std::cout << "  uisign=" << std::setw(3) << uisign << "   letter=" << char_letter << "  chlen=" << chlen << std::endl;
   //std::cout << "  bulen=" << bulen << std::endl;
}  

nun menues.cpp

// Datei menues.cpp von viegener1f
#include "vigenere.h"
//Inhalt menues.cpp:
//void vigenere::HAUPTMENUE(void)
//int vigenere::MenueFrage(void)
//void vigenere::GetKeyword(void)
//void vigenere::GetPlaintext(void)
//void vigenere::rotiere_Ur_abc(void)
//void vigenere::ShowVigenereTable(void)
//void vigenere::SetzeTestVorgaben(void)
//void vigenere::Buchstabenplatzliste(void)
//void vigenere::BuchstabenplatzTest(void)
//void vigenere::ShowLaengentafel(void)
//void vigenere::Rotiere_plaintext(void)


void vigenere::HAUPTMENUE(void)
{   
  std::cout << std::endl << "Vigenere Versuch" << std::endl;
  std::cout << "Programmende..............0" << std::endl;
  std::cout << "Schluesseleingabe.........1" << std::endl;
  std::cout << "Texteingabe...............2" << std::endl;
  std::cout << "rotiere Ur-Alphabet.......3" << std::endl;
  std::cout << "Texteingabe rotieren......4" << std::endl; //5
  std::cout << "Ur_abc chiffrieren........5" << std::endl; //4
  std::cout << "Ur_abc dechiffrieren......6" << std::endl;
  std::cout << "Zeige vignere-Tafel.......7" << std::endl;
  std::cout << "Vorgabe fuer Test.........8" << std::endl;
  std::cout << "Dateitest................11" << std::endl;
}

int vigenere::MenueFrage(void)
{
 int frage = 18, i;
 std::string wastun = "";
 std::string erge[16] = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10","11","12","13","14","15"};
 
 std::cout << std::endl << "Ihre Wahl: ";
 std::cin >> wastun; // frage 
 
 for (i = 0; i < 16; i++)
  {
   if (wastun.compare(erge[i]) == 0)
   {
	frage = i;
    break;   
   }
 }
 clpuf();
 
 return frage;
}

void vigenere::GetKeyword(void)
{
 int j;	 
    
 std::cout << "Eingabe des Schluessels: ";
 std::cin >> key; 
 clpuf();

 klen = key.length();
 kbulen = letterlaenge(key);
 std::cout << "Schluessel-Laenge in Byte......: " << klen << std::endl;
 std::cout << "Schluessel-Laenge in Buchstaben: " << kbulen << std::endl<< std::endl;   
         
 //Stellt die Position des Ur_abcs Nr. srcpos vom String source im String alphabet fest und gibt diese zurueck
 for (j = 0; j < kbulen; j++)		 	
  {
   keychar = get_xpos_Letter(key, j);  // einzelnes Ur_abc aus Schluesselstring nach teilb holen
   std::cout << " j=" << std::setw(2) << j << "  substr= " << keychar << std::endl;
  }
}  

void vigenere::GetPlaintext(void)
 { 
  std::cout << "Eingabe von plaintext: ";
  std::getline (std::cin, plaintext); 
  
  txtlen = plaintext.length();
  txtbulen = letterlaenge(plaintext);

  std::cout << "plaintext war.................: " << plaintext << std::endl;
  std::cout << "Laenge plaintext in Byte......: "<< txtlen << std::endl;
  std::cout << "plaintext Laenge in Buchstaben: " << txtbulen << std::endl;
 }
 
 
void vigenere::rotiere_Ur_abc(void)
{         
  int xpos = 0;
  std::string teilb = "";

  std::cout << "rotiere Ur-Alphabet" << std::endl;
  // plaintext Position von Teilstring aendern
  std::cout << std::endl << Ur_abc << std::endl;
  ShowLaengentafel();
  abclen = Ur_abc.length();
  std::cout << "Laenge des Ur_abc in byte......: " << abclen << std::endl;
  std::cout << "Laenge des Ur_abc in Buchstaben: " << letterlaenge(Ur_abc) << std::endl;
  std::cout << "\nUr_abc vorher: " << Ur_abc << std::endl;
         
  std::cout << "bis pos: ";
  std::cin >> xpos; 
  std::cout << "Eingabe pos: "  << xpos << std::endl;
  if ((xpos >= 0)  && (xpos < abclen))
   teilb = vigens(Ur_abc, xpos);
   
  std::cout << "rotiertes abc: " << teilb << std::endl;
}


void vigenere::ShowVigenereTable(void)
{   
 int i = 0;
 std::string teilc = "";
 std::string keychar = "";
 
 std::cout << "Zeige Vignere-Tafel" << std::endl;
 ShowKey();
 
 
 klen = letterlaenge(key); 

 for (i = 0; i < klen; i++)
  {
   teilc = RotiereUr_abc(Ur_abc, i, &keychar);
   std::cout << "teilc= " << teilc << std::endl;
  }
}  


 
void vigenere::SetzeTestVorgaben(void)
{   
 std::cout << "Setze Vorgaben fuer Test" << std::endl;  
 key = "asälk";
 klen = key.length();
 kbulen = letterlaenge(key);
	   
 plaintext = "abcdefghijklmnop";
 txtlen = plaintext.length();
 txtbulen = letterlaenge(plaintext);
	   
 ShowKey();
 std::cout << "plaintext.....................: " << plaintext << std::endl; 
 std::cout << "plaintext Laenge in Byte......: " << txtlen << std::endl; 
 std::cout << "plaintext Laenge in Buchstaben: " << txtbulen << std::endl; 
} 
 
void vigenere::Buchstabenplatzliste(void)
{     
 int j,bulen = 0, chlen; 
 std::string teilb;
 
 std::cout << "Buchstabenplatz-Liste" << std::endl;  
 std::cout << std::endl << Ur_abc << std::endl;
 ShowLaengentafel();
 abclen = Ur_abc.length();

 std::cout << "Laenge des Ur_abc in byte......: " << abclen << std::endl;
 std::cout << "Laenge des Ur_abc in Buchstaben: " << letterlaenge(Ur_abc) << std::endl;

 bulen = 0;

    for (j = 0; j < abclen; j++)
	 { 
	  chlen = getcharart(Ur_abc[j]);    // Bestimme Laenge des Zeichens von Ur_abc
	  if(chlen <= 4) teilb = Ur_abc.substr(j, chlen);  // Kopiere Ur_abc in teilb
	    else teilb = "";
	
       std::cout << "Ur_abc[" << std::setw(2) << j << "]="  << "  bulen=" << std::setw(2) << bulen << "   "<< Ur_abc[j];
       std::cout << " dec=" << std::setw(3) << atoint(Ur_abc[j]);
       std::cout << " Ur_abc[" << std::setw(2)<< bulen << "]=" << teilb <<  "  chlen=" << chlen << std::endl;
	  if (chlen <= 4) bulen++;
	} 
}  

void vigenere::BuchstabenplatzTest(void)
{ 
 int j, abclen, Ur_abc_buchslen, xpos = 0;
 std::string teilb = "";
 std::string dummy = "";
 
  std::cout << "Buchstabenplatz-Test" << std::endl;  
  std::cout << std::endl << Ur_abc << std::endl;
  ShowLaengentafel();
 

  abclen = Ur_abc.length();
  Ur_abc_buchslen = letterlaenge(Ur_abc);

  std::cout << "Laenge des Ur_abc in byte......: " << abclen << std::endl;
  std::cout << "Laenge des Ur_abc in Buchstaben: " << Ur_abc_buchslen << std::endl;
	   
	    
   for (j = 0; j < Ur_abc_buchslen; j++)
	{ 
	 teilb = get_xpos_Letter(Ur_abc, j);
	 std::cout << " Ur_abc[" << std::setw(2)<< j << "]=" << teilb << std::endl;
	}  
  
   std::cout << "Suche Buchstabe: ";
   std::cin >> dummy;
	  
   xpos = get_xLetter_pos(Ur_abc, dummy);   	
   std::cout << "an Position: " << xpos << std::endl;
}  
// Gets plaintext from user
void vigenere::ShowLaengentafel(void)
{ std::cout << "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" << std::endl;
  std::cout << "         |         |         |         |         |         |         |         |         |         |" << std::endl;
}

void vigenere::Rotiere_plaintext(void)
{
 int xpos;
 
 std::cout << "Rotiere eingegebenen Text: ";
 std::cout << "Codiert vorher: " << plaintext << std::endl;
 
 std::cout << "Laenge eingegebener Text: " << txtlen << std::endl;
 std::cout << "bis pos: ";
 std::cin >> xpos; 
 teilb = vigens(plaintext, xpos);
 std::cout << "eingegebener Text neu...: " << teilb << std::endl;
}

nun main.cpp

// main.cpp von vigenere1f
// Bei der Herstellung des rotierten ABC muss noch korrigiert werden, da Umlaute doppelt
// in der Vigenere-Tafel dargestellt werden


#include "vigenere.h"


int main(int argc,  char *argv[])
{
 vigenere vig;
 
	
 //std::string Ur_abc = "abcdefghijklmnopqrstuvwxyzöäüß ABCDEFGHIJKLMNOPQRSTUVWXYZÖÄÜ0123456789.,!?;:-+*~#'<>|²³€@/^°µ_§${}[]()´`"; 
 //std::string Ur_abc = "abcdefghijklmnopqrstuvwxyzöäüß ABCDEFGHIJKLMNOPQRSTUVWXYZÖÄÜ0123456789";
 std::string letter_chiffriert = "";
 std::string chiffriert = "";
 std::string dechiffriert = "";
 std::string char_letter = "";
 std::string char_txt = "";
 int frage = 18, i, j, chiflen = 0, modus = 0;
 int lgechiffriert = 0;
   
 do
 switch(frage)
 {
   default: vig.HAUPTMENUE();
		 frage = vig.MenueFrage();
      break;


   case 0:
         //free(lesespeicher);
		 std::cout << "Programmende" << std::endl;  
         return 0;
	  break;
	

   case 1:
         vig.GetKeyword();
         frage = 18;
	  break;
 
   
   case 2:
     	 vig.GetPlaintext(); // Gets plaintext from user
 		 frage = 18;
	  break;
	  
   case 3:
         vig.rotiere_Ur_abc();
         frage = 18;		 
	  break; 

   case 4:
         vig.Rotiere_plaintext();
		 frage = 18;
	  break;   	  
	  
   case 5:
         // Ausgabe von plaintext in Buchstaben
         std::cout << std::endl << "Chiffrieren-Test: " << std::endl;
		 vig.ShowKey();
		 std::cout << "plaintext......................: " << vig.plaintext << std::endl;
		 std::cout << "Laenge plaintext in Byte.......: "<< vig.txtlen << std::endl;
		 std::cout << "plaintext Laenge in Buchstaben.: " << vig.txtbulen << std::endl;
		 std::cout << "Laenge des Ur_abc in byte......: " << vig.abclen << std::endl;
	     std::cout << "Laenge des Ur_abc in Buchstaben: " << vig.Ur_abc_buchslen << std::endl;
		
       i = 0; 
       for (j = 0; j < vig.txtbulen; j++)
	    { 
		 char_letter = vig.get_xpos_Letter(vig.plaintext, j); // Aus String plaintext einen Buchstaben holen
	
         letter_chiffriert = vig.chiffrieren(i, char_letter, 0);
 
		 chiffriert += letter_chiffriert;  
		 		 
	     vig.ShowVarib(i, j, letter_chiffriert);  

		 i++;
         if (i >= vig.kbulen) i = 0;
	    }
		 std::cout << "Text chiffriert: " << chiffriert << std::endl << std::endl;
		 frage = 18;
	  break; 	

   case 6:
        // Ausgabe von plaintext in Buchstaben
         std::cout << "Dechiffrieren Test.............: " << std::endl;
         vig.ShowKey();
		 std::cout << "Text chiffriert................: " << chiffriert << std::endl;
		 chiflen = chiffriert.length();
		 lgechiffriert = letterlaenge(chiffriert); // Laenge von String chiffriert in Buchstaben 
		 std::cout << "chiffriert laenge in Byte......: " << chiflen << std::endl;
		 std::cout << "chiffriert laenge in Buchstaben: " << lgechiffriert << std::endl;
		
       i = 0; 
       for (j = 0; j < lgechiffriert; j++)
	    { 
		 char_letter = vig.get_xpos_Letter(chiffriert, j); // Aus String chiffriert einen Buchstaben holen
		 
		 letter_chiffriert = vig.chiffrieren(i, char_letter, 1);
		    		 
		 dechiffriert += letter_chiffriert;  
  
		 vig.ShowVari(i, j, letter_chiffriert, char_letter);  

		 i++;
         if (i >= vig.kbulen) i = 0;  			 
	    }
		 std::cout << "Text dechiffriert: " << dechiffriert << std::endl << std::endl;
		 frage = 18;
	  break; 	

 case 7:
        vig.ShowVigenereTable(); 
		frage = 18;
	  break; 
 
 case 8:
        vig.SetzeTestVorgaben();
	    frage = 18;
	  break;

  case 9:
        vig.Buchstabenplatzliste();
        frage = 18;
	  break;
  
  case 10:
        vig.BuchstabenplatzTest();
        frage = 18;
	  break;
  
  case 11:
        std::cout << "Dateitest" << std::endl;
		vig.getcurdir();
		std::cout << "chiffrieren(0) oder dechiffrieren(1):";
		modus = vig.MenueFrage();
		vig.ShowKey();
		vig.srcfilename = "test.txt";
		std::cout << "Name der Quelldatei: ";
		std::cin >> vig.srcfilename;
		std::cout << "Name der Zieldatei.: ";
		std::cin >> vig.tarfilename;
		vig.StringToChar(vig.srcfilename, vig.dummy);
		std::cout << "Eingabe: " << vig.dummy << std::endl;
		
	    if( access(vig.dummy, F_OK ) != -1 )
         {
          std::cout << "Datei mit Namen\n" << vig.dummy << "\nwurde gefunden " << std::endl; // file exists
          vig.srcdatlen = vig.getFilesize(vig.srcfilename);
		  std::cout << "Dateilaenge betraegt :" << vig.srcdatlen << " Byte" << std::endl;
		  vig.ReadValIn(vig.srcfilename, modus);
		 }
          else 
		   {
            std::cout << "Datei nicht gefunden" << std::endl; // file doesn't exist
           } 
	    frage = 18;
	  break;
  
  
}while(frage != 0);
 
 
 std::cout << "End of Program" << std::endl;  
 return 0;
}

Nach dem Start bitte immer zuerst das Schlüsselwort eingeben.
Danach mit menue-Punkt 11 mal testweise eine TEXT-DATEI verschlüsseln.
Ursprünglich hatte ich mal wissen wollen, wie man es anstellt, das man mit UTF8
auch deutsche Umlaute in eine vigenere-Tafel packen kann. Rest siehe Quellcode.
Das kleine Programmchen wurde mit der Zeit immer größer.
Erstellt mit codelite auf SUSE LINUX tumbleweed mit gcc.
Zum experimentieren, ausprobieren, testen usw.
Da ich zusätzlich zu meinen von Arbeitsunfällen lädierten Händen(Kreissäge, Staphylococcen)
auch noch Handgelenks und Fingergelenksarthrose habe, die Veröffentlichung,bevor ich es nicht mehr kann!

Viel Spaß wünscht rustyoldguy

[Swordfish]

Schau' mal nach was eine Gott-Klasse ist (God Class). Auch SRP (Single Responsibility Principle). Es ist sicher nicht Aufgabe eines Verschlüsselungsalgos ein Menü anzuzeigen und ähnliches.

@rustyoldguy sagte in Kleines Programm zur chiffrierung von Dateien mit vigenere:

char chararray[8];

... tolle Variablennamen teilweise ^^

Ich freu' mich auf Version 2.

[Schlangenmensch]

Und in C++ braucht man kein void in der Parameterliste, wenn man keinen Parameter übergeben möchte.
Du übergibst std::string immer als Kopie. Kann natürlich gewillt sein, aber bei Positions oder Längenbrechnungen sollte eine const reference reichen.
Außerdem, in C++ deklariert man Variablen normalerweise erst da, wo man sie wirklich braucht. (Zum Beispiel Zählvariablen im Schleifenkopf)

[Ein ehemaliger Benutzer]

@rustyoldguy sagte in Kleines Programm zur chiffrierung von Dateien mit vigenere:

unsigned int chartoint(unsigned char intteile[4])
{
union intpart{
unsigned int erge;
unsigned char ipart[4];
} ipt;

ipt.ipart[0] = intteile[0];
ipt.ipart[1] = intteile[1];
ipt.ipart[2] = intteile[2];
ipt.ipart[3] = intteile[3];

return ipt.erge;
}

könnte auch so aussehen:

unsigned int chartoint (unsigned char intteile[4])
{
    return *(unsigned int*)intteile;
}

ist zwar auch nicht portabel, so wie deine funktion, aber auf x86 funktionierts.
um die endianess umzudrehen nehme htonl() aus der socket library.

[Swordfish]

@rustyoldguy Warum schreibst Du einen leeren Destruktor hin? Weißt Du welche konsequenzen das hat? Was bringt es an Mehrwert?

@rustyoldguy sagte in Kleines Programm zur chiffrierung von Dateien mit vigenere:

//Umwandlung von signed char zu int
int atoint(char letter)
{
 int rewer;
 if ( letter < 0)
  rewer = letter + 256;
   else rewer = (int)letter;
 return rewer;
}

Sorry, aber wth?

char /* signed | unsigned */ ch = -42;
int value = static_cast<char unsigned>(ch);

fertig.

[Swordfish]

Dieser Beitrag wurde gelöscht!

[Jockelx]

Wow! Ist das ernst gemeinter Code oder ein maximal kompaktes Beispiel sämtlicher Coding-styles die es gibt!?
upper camel case, lower camel case, komplett in gross, mit '_' als Trenner (Frage: hat das eigentlich einen Namen?) mit folgendem Buchstaben mal gross, mal klein, englisch, deutsch-englisch-gemischt.

[Ein ehemaliger Benutzer]

@rustyoldguy sagte in Kleines Programm zur chiffrierung von Dateien mit vigenere:

void clearchararray(char array[], int lge)
{
for (int i = 0; i < lge; i++)
array[i] = 0;
}

gibt es schon: http://www.cplusplus.com/reference/cstring/memset/

[Bashar]

@Jockelx sagte in Kleines Programm zur chiffrierung von Dateien mit vigenere:

mit '_' als Trenner (Frage: hat das eigentlich einen Namen?)

Snake Case

[Jockelx]

@Bashar Dankeschön

[Ein ehemaliger Benutzer]

@Bashar sagte in Kleines Programm zur chiffrierung von Dateien mit vigenere:

Snake Case

hat aber kein python-programmierer erfunden.

[Swordfish]

@rustyoldguy sagte in Kleines Programm zur chiffrierung von Dateien mit vigenere:

 for (i = 0; i < 16; i++)
  {
   if (wastun.compare(erge[i]) == 0)
   {
	frage = i;
    break;   
   }
 }

Echt? std::find()!?
Aber warum überhaupt Zahlen als Text!?!?

Und so könnte man bei dem Code ewig weitermachen. Bringt halt nix.

[hustbaer]

@Schlangenmensch sagte in Kleines Programm zur chiffrierung von Dateien mit vigenere:

Du übergibst std::string immer als Kopie. Kann natürlich gewillt sein, aber bei Positions oder Längenbrechnungen sollte eine const reference reichen.

Und wenn der C++ Standard dafür reicht (C++17 IIRC), dann könnte man auch gleich eine std::string_view nehmen.

[hustbaer]

void clearchararray(char array[], int lge)

lge kurz für Länge? Bitte beschränk dich auf (in der Softwareentwicklung) übliche Abkürzungen oder gleich noch besser: kauf die eine Familienpackung Nachfüllbuchstaben für deinen Computer damit du nicht so sparen musst.

Und Englisch für Funktionen/Variablennamen schadet auch nicht.