base64.RC

#include <iostream>
#include <fstream>
#include <string>
#include <cstdlib>
#include <cstring>
#include <cstddef>
#include <bitset>
#include <sstream>
#include <bitset>

using namespace std;

void decrypt(string plik_do_rozkodowania);
int bace64Encrypt(string plik_do_zakodowania, string plik_zakodowany);
int odszukaj_w_tablicy(char c);
char *toBase64(char *c, int flaga);
char *rozkoduj(char *tmp, int flaga);

const static char encodeLookup[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; // tablca kodu

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ą
    }

    //------------dla 2(==)-----------------------------------------------------------------------------------------------------------------------
    else if (flaga == 2)
    {
        for (int i = 0; i < 2; i++)
        {
            *(kod + i) = encodeLookup[przed_zakodowaniem[i]];
        }
        kod[2] = '=';
        kod[3] = '=';
    }

    return kod;
}

///////////////////////////////////funkcja rozkodowywująca//////////////////////////////////////////////////////////////

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();
}

//--------------------------------------------narzędzie funkcji rozkodowywujący ------------------------------------------------------------------------------
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("1.jpg", "base64");
    decrypt("base64.txt");

    getchar();
}