Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- #include <iostream>
- #include <fstream>
- #include <string>
- #include <cstdlib>
- #include <cstring>
- #include <cstddef>
- #include <bitset>
- #include <sstream>
- #include <bitset>
- using namespace std;
- int bace64Encrypt(string plik_do_zakodowania, string plik_zakodowany);
- void decrypt(string plik_do_rozkodowania);
- char *toBase64(char *c, int flaga);
- int odszukaj_w_tablicy(char c);
- char *rozkoduj(char *tmp, int flaga);
- const static char encodeLookup[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; // tablca kodu
- ofstream plik_wyjsice;
- int bace64Encrypt(string plik_do_zakodowania, string plik_zakodowany)
- {
- /////////////////////////////////otwierani pliku do zakodawania//////////////////////////////////////////////////////////
- ifstream plik;
- size_t rozmiar = 0;
- plik.open(plik_do_zakodowania, std::ios::binary | ios::in);
- if (plik.good() == true)
- {
- cout << "plik otwarty prawidlowo" << endl;
- }
- else
- {
- cout << "nie udalo sie ";
- return 1;
- }
- plik.seekg(0, ios::end);
- rozmiar = plik.tellg();
- cout << "długosć pliku " << rozmiar << endl;
- plik.seekg(0, ios::beg);
- /////////////////////////////////////tworzenie pliku do zapisu kodu/////////////////////////////////////////////////////////
- fstream zapis;
- string nazwa_pliku_ = plik_zakodowany.append(".txt"); // tworzy plik o podanej nazwie przez urzytkownika
- zapis.open(nazwa_pliku_, ios::out);
- //--------------------------------------------------------------------------------------------------------------------------
- char c[3];
- char *tempo;
- size_t licznik = 0;
- //--------------------------------------------------------------------------------------------------------------------------
- while (licznik + 3 <= rozmiar && plik.read(c, 3))// wczytanie pliku po 3 bajty oraz sprawdzenie długośći tak aby zatrzymać się na baj przed końcem
- {
- licznik += 3;
- tempo = toBase64(c, 0);// wywołanie funkcji kodującje, podanie 3 bajtów oraz flagi ile 6bitowych znaków musi zostać dopisane
- for (int i = 0; i < 4; i++)
- {
- zapis << tempo[i];
- }
- }
- //--------------------------------------------------------------------------------------------------------------------------
- if (rozmiar - licznik == 0) //sprawdzenie czy należy uzupełnić plik bajtam aby były wielokrotnością 3
- {
- return 0;
- }
- //--------------------------------------------------------------------------------------------------------------------------
- else if (rozmiar - licznik == 1)//== // sprawdzanie ile bajtów pozostało nam do wczytania gdy wielkość pliku nie jest wielokrotnością 3 ( jeżeli 1 to mamy 2 puste bajy które musimy dopisać aby wielkość paczki danych wynosiła 3 bajty i zapamiętać informację że dopisalićmy 2. oznaczamy to 2 znakami ==)
- {
- plik.read((c + 0), 1); // wczytujemy ten jedn bajt który nam pozostał do wczytania
- c[1] = 0; // nie możemy odrazu dopisać po rosu znaku = ponieważ bo przy podziale do ostatniego 6bitowego znaku musimy dopisać 2 zera.
- c[2] = 0;//uzupełnienie zerami
- tempo = toBase64(c, 2); // wywołujemy funkcję do kodowani i podajemy jej flagę ile znaków == ma dopisa na końcu
- for (int i = 0; i < 4; i++)
- {
- zapis << tempo[i];
- }
- }
- //--------------------------------------------------------------------------------------------------------------------------
- else if (rozmiar - licznik == 2)//= // sprawdzanie ile bajtów pozostało nam do wczytania gdy wielkość pliku nie jest wielokrotnością 3 ( jeżeli 2 to mamy 1 pusty bajt który musimy dopisać aby wielkość paczki danych wynosiła 3 bajty i zapamiętać informację że dopisalićmy 1. oznaczamy to 1 znakami =)
- {
- plik.read((c + 0), 1);// wczytujemy to co pozostało do wczytania
- plik.read((c + 1), 1);
- c[2] = 0;
- tempo = toBase64(c, 1);
- for (int i = 0; i < 4; i++)
- {
- zapis << tempo[i];
- }
- }
- plik.close();
- zapis.close();
- delete tempo;
- return 0;
- }
- //////////////////////////////////funkcja kodująca /////////////////////////////////////////////////////////////////////////
- char *toBase64(char *c, int flaga)
- {
- int licznik = 0;
- bool bufor[24];
- for (int z = 0; z < 3; z++)
- {
- for (int i = 7; i >= 0; i--, licznik++)
- {
- bufor[licznik] = ((c[z] >> i) & 1); // konwersja z wczytanej tablicy bajtów na tablicę bitów
- }
- }
- licznik = 0;
- unsigned int przed_zakodowaniem[4]; // utworzenie z 3 bajtów 4sześcio bitowych znaków
- for (int z = 0; z < 24; z += 6) // pętla interpretująca 6bitów jako liczbę int
- {
- przed_zakodowaniem[licznik] = (((bufor[z + 0]) ? 1 : 0) * pow(2, 5)) +//
- (((bufor[z + 1]) ? 1 : 0) * pow(2, 4)) +//
- (((bufor[z + 2]) ? 1 : 0) * pow(2, 3)) +// konwersj bulowskoej tablicy na inta
- (((bufor[z + 3]) ? 1 : 0) * pow(2, 2)) +//
- (((bufor[z + 4]) ? 1 : 0) * pow(2, 1)) +//
- (((bufor[z + 5]) ? 1 : 0) * pow(2, 0)); //
- licznik++;
- }
- //------------dla 0-----------------------------------------------------------------------------------------------------------------------
- char *kod = new char[4]; // kodowanie korzystając z wcześniej zdefiniowanej tablicy poprostu podstawinie wcześniej wyliczonej wartości jako element tablicy
- if (flaga == 0)// sprawdzenie czy musimy dopisać =
- {
- for (int i = 0; i < 4; i++)
- {
- *(kod + i) = encodeLookup[przed_zakodowaniem[i]];
- }
- //cout << kod[0] << kod[1] << kod[2] << kod[3] << endl;
- }
- //------------dla 1(=)-----------------------------------------------------------------------------------------------------------------------
- else if (flaga == 1)
- {
- for (int i = 0; i < 3; i++)
- {
- *(kod + i) = encodeLookup[przed_zakodowaniem[i]];
- }
- kod[3] = '=';// dopisanie = jeżeli funkcja została wywołana z taką flagą
- //cout << kod[0] << kod[1] << kod[2] << kod[3] << endl;
- }
- //------------dla 2(==)-----------------------------------------------------------------------------------------------------------------------
- else if (flaga == 2)
- {
- for (int i = 0; i < 2; i++)
- {
- *(kod + i) = encodeLookup[przed_zakodowaniem[i]];
- }
- kod[2] = '=';
- kod[3] = '=';
- // cout << kod[0] << kod[1] << kod[2] << kod[3] << endl;
- }
- return kod;
- }
- ///////////////////////////////////narzędzie funkcji kodującej//////////////////////////////////////////////////////////////
- void decrypt(string plik_do_rozkodowania)
- {
- ifstream plik;
- size_t rozmiar = 0;
- plik.open(plik_do_rozkodowania, ios::in);
- if (plik.good() == true)
- {
- cout << "plik otwarty prawidlowo" << endl;
- }
- else
- {
- cout << "nie udalo sie ";
- return;
- }
- plik.seekg(0, ios::end);
- rozmiar = plik.tellg();
- cout << "długosć pliku " << rozmiar << endl;
- plik.seekg(0, ios::beg);
- //--------------------------------------------------------------------------------------------------------------------------
- ofstream fout;
- fout.open("file.bin", ios::binary | ios::out);
- //--------------------------------------------------------------------------------------------------------------------------
- char *c = new char;
- char *tmp = new char[4];
- char *odkodowane = new char[3];
- int licznik = 0;
- int pomoc = 0;
- //--------------------------------------------------------------------------------------------------------------------------
- while (licznik + 4 <= rozmiar)
- {
- for (int i = 0; i < 4; i++)
- {
- plik.read(c, 1);
- if (*c != '=')
- {
- tmp[i] = *c;
- licznik++;
- }
- else
- {
- if (i == 2)// == czyli mam 2 znaki odkodowany będzie 1
- {
- odkodowane = rozkoduj(tmp, 1);
- char test1[3];
- test1[0] = odkodowane[0];
- fout << test1[0];
- pomoc = 1;
- break;
- }
- else if( i == 3)// = czyli mam 3 znaki zwrot 2 znaki
- {
- odkodowane = rozkoduj(tmp, 2);
- char test1[3];
- test1[0] = odkodowane[0];
- test1[1] = odkodowane[1];
- fout << test1[0];
- fout << test1[1];
- pomoc = 1;
- break;
- }
- }
- }
- if (pomoc == 1)break;
- odkodowane = rozkoduj(tmp,0);
- char test1[3];
- test1[0] = odkodowane[0];
- test1[1] = odkodowane[1];
- test1[2] = odkodowane[2];
- for (int i = 0; i < 3; i++)
- {
- fout << test1[i];
- }
- }
- delete c, tmp, odkodowane;
- plik.close();
- }
- //--------------------------------------------------------------------------------------------------------------------------
- char *rozkoduj(char *tmp_, int flaga)
- {
- char *temp = tmp_;
- int licznik = 0;
- bool bufor[24];
- int tablicaint[4];
- //------------------------------------------flaga 0-------------------------------------------------------------------------
- if (flaga == 0)
- {
- for (int i = 0; i < 4; i++)
- {
- tablicaint[i] = odszukaj_w_tablicy(temp[i]);
- }
- for (int z = 0; z < 4; z++)
- {
- for (int i = 5; i >= 0; i--, licznik++) // 7//0
- {
- bufor[licznik] = ((tablicaint[z] >> i) & 1); // konwersja z wczytanej tablicy bajtów na tablicę bitów
- }
- }
- //--------------------------------------------------------------------------------------------------------------------------
- licznik = 0;
- char rozkodowany[3]; // utworzenie z 3 bajtów
- for (int z = 0; z < 24; z += 8) // pętla interpretująca 8bitów jako liczbę int
- {
- rozkodowany[licznik] =
- (((bufor[z + 0]) ? 1 : 0) * pow(2, 7)) +//
- (((bufor[z + 1]) ? 1 : 0) * pow(2, 6)) +//
- (((bufor[z + 2]) ? 1 : 0) * pow(2, 5)) +// konwersj bulowskoej tablicy na inta
- (((bufor[z + 3]) ? 1 : 0) * pow(2, 4)) +//
- (((bufor[z + 4]) ? 1 : 0) * pow(2, 3)) +//
- (((bufor[z + 5]) ? 1 : 0) * pow(2, 2)) +
- (((bufor[z + 6]) ? 1 : 0) * pow(2, 1)) +
- (((bufor[z + 7]) ? 1 : 0) * pow(2, 0));
- licznik++;
- }
- return rozkodowany;
- }
- //----------------------------------------------flaga1----------------------------------------------------------------------
- if (flaga == 1)
- {
- for (int i = 0; i < 2; i++)
- {
- tablicaint[i] = odszukaj_w_tablicy(temp[i]);
- }
- for (int z = 0; z < 2; z++)
- {
- for (int i = 5; i >= 0; i--, licznik++) // 7//0
- {
- bufor[licznik] = ((tablicaint[z] >> i) & 1); // konwersja z wczytanej tablicy bajtów na tablicę bitów
- }
- }
- //--------------------------------------------------------------------------------------------------------------------------
- licznik = 0;
- char rozkodowany[3]; // utworzenie z 3 bajtów
- for (int z = 0; z < 8; z += 8) // pętla interpretująca 8bitów jako liczbę int
- {
- rozkodowany[licznik] =
- (((bufor[z + 0]) ? 1 : 0) * pow(2, 7)) +//
- (((bufor[z + 1]) ? 1 : 0) * pow(2, 6)) +//
- (((bufor[z + 2]) ? 1 : 0) * pow(2, 5)) +// konwersj bulowskoej tablicy na inta
- (((bufor[z + 3]) ? 1 : 0) * pow(2, 4)) +//
- (((bufor[z + 4]) ? 1 : 0) * pow(2, 3)) +//
- (((bufor[z + 5]) ? 1 : 0) * pow(2, 2)) +
- (((bufor[z + 6]) ? 1 : 0) * pow(2, 1)) +
- (((bufor[z + 7]) ? 1 : 0) * pow(2, 0));
- licznik++;
- }
- return rozkodowany;
- }
- //----------------------------------------------flaga2----------------------------------------------------------------------
- if (flaga == 2)
- {
- for (int i = 0; i < 3; i++)
- {
- tablicaint[i] = odszukaj_w_tablicy(temp[i]);
- }
- for (int z = 0; z < 3; z++)
- {
- for (int i = 5; i >= 0; i--, licznik++) // 7//0
- {
- bufor[licznik] = ((tablicaint[z] >> i) & 1); // konwersja z wczytanej tablicy bajtów na tablicę bitów
- }
- }
- //--------------------------------------------------------------------------------------------------------------------------
- licznik = 0;
- char rozkodowany[3]; // utworzenie z 3 bajtów
- for (int z = 0; z < 9; z += 8) // pętla interpretująca 8bitów jako liczbę int wykona się 2 razy
- {
- rozkodowany[licznik] =
- (((bufor[z + 0]) ? 1 : 0) * pow(2, 7)) +//
- (((bufor[z + 1]) ? 1 : 0) * pow(2, 6)) +//
- (((bufor[z + 2]) ? 1 : 0) * pow(2, 5)) +// konwersj bulowskoej tablicy na inta
- (((bufor[z + 3]) ? 1 : 0) * pow(2, 4)) +//
- (((bufor[z + 4]) ? 1 : 0) * pow(2, 3)) +//
- (((bufor[z + 5]) ? 1 : 0) * pow(2, 2)) +
- (((bufor[z + 6]) ? 1 : 0) * pow(2, 1)) +
- (((bufor[z + 7]) ? 1 : 0) * pow(2, 0));
- licznik++;
- }
- return rozkodowany;
- }
- }
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- int odszukaj_w_tablicy(char c)
- {
- for(int i =0; i<63;i++)
- {
- if (encodeLookup[i] == c)
- {
- return i;
- }
- }
- }
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- int main(void)
- {
- //bace64Encrypt("Capture.png", "base64");
- decrypt("base64.txt");
- cout << endl << encodeLookup[28]<< encodeLookup[23] << encodeLookup[29] << encodeLookup[37];
- getchar();
- }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement