C++, biblioteka standardowa. Szyfrowanie pliku.

Question

Witam, już kilka razy robiłem programy xor'ujące pliki, nigdy jednak jeszcze nie próbowałem tego w czystym C++ ( bibliotece standardowej ). Oto mój kod:

#include <iostream>
#include <fstream>
#include <string>
#include <cstdlib>

class StrLoopIterator {
private:
	std::string m_str;
	std::string::iterator m_it; 

public:
	StrLoopIterator(std::string str) : m_str(str), m_it(m_str.begin()) {}
	
	char next() {
		char t = *m_it;
		m_it++; 
		if (m_it >= m_str.end())
			m_it = m_str.begin();
		return t;
	}

	void reset() {
		m_it = m_str.begin();
	}
};

//-------------------------------------------------------------------------------

std::streampos getFileByteSize(std::string filename) {
	std::ifstream bfile(filename);
	if (!bfile.is_open()) 
		return 0; 
	bfile.seekg(0, std::ios_base::end);
	std::streampos size = bfile.tellg(); 
	bfile.clear(); 
	bfile.close();
	return size; 
}

//-------------------------------------------------------------------------------

void fileXOR(std::string filename, std::string key, std::streampos filesize) {
	std::fstream file(filename, std::ios_base::out | std::ios_base::in | std::ios_base::binary);
	if (!file.is_open())
		throw "File not found";

	StrLoopIterator keyit(key);
	for (std::streampos i = 0; i < filesize; i+=1) {
		char ch;
		file.seekg(i);
		file.read(&ch, sizeof ch);
		file.seekg(i);

		ch ^= keyit.next(); 
		file.write(&ch, sizeof ch);
	}

	file.clear();
	file.close();
}

//-------------------------------------------------------------------------------

int main() {

	std::cout << "File name: ";
	std::string filename; 
	std::cin >> filename; 
	std::cout << "Key: ";
	std::string key;
	std::cin >> key; 

	std::streampos filesize = getFileByteSize(filename);

	try {
		fileXOR(filename, key, filesize);
	}
	catch (char* str) {
		std::cout << str << "\n";
	}

	std::cin.get();
	std::cin.get();
}

I tu mam pytanie dotyczące efektywności tego co zrobiłem, tyczy się to oczywiście głównie samego odczytu i zapisu informacji do pliku:

StrLoopIterator keyit(key);
	for (std::streampos i = 0; i < filesize; i+=1) {
		char ch;
		file.seekg(i);
		file.read(&ch, sizeof ch);
		file.seekg(i);

		ch ^= keyit.next(); 
		file.write(&ch, sizeof ch);
	}

zapis i odczyt odbywa się w jednej pętli, bajt po bajcie. Dla małych plików jest ok, ale przetwarzanie zdjęć trwa nawet ponad minutę. Czy jest jakiś bardziej szybki i elegancki sposób w jaki mógłbym to zrealizować? Może pobierać większe bloki danych w zależności od pliku?

Pytanie krótkie, ale zawsze jak coś napiszę to zdaję sobie sprawę że to może być bardzo nieprofesjonalny kod i chcę znać ewentualne lepsze wyjścia z sytuacji ;)

Dziękuje za porady i pozdrawiam :)

Answer 1

Buforowane i z użyciem algorytmu. Jeśli dalej mała wydajność, pozostaną mechanizmy systemowe:

#include <fstream>
#include <string_view>
#include <iterator>
#include <iomanip>
#include <algorithm>

void cryptXOR(std::istream& in, std::ostream& out, std::string_view key) {
    using iItType = std::istream_iterator<char>;
    using oItType = std::ostream_iterator<char>;
    std::transform(iItType(in), iItType(), oItType(out),
        [&key, it = key.begin()](char c) mutable {
            char oVal = c ^ *it;
            if(++it == key.end()) {
                it = key.begin();
            }
            return oVal;
    });
}

constexpr static std::size_t BuffSize = 4096;

int main() {
    char iBuffer[BuffSize];
    char oBuffer[BuffSize];
    // TODO: Check open error...
    {
        std::ifstream iFile;
        std::ofstream oFile;
        iFile.rdbuf()->pubsetbuf(iBuffer, BuffSize);
        oFile.rdbuf()->pubsetbuf(oBuffer, BuffSize);
        iFile.open("input.txt");
        iFile >> std::noskipws;
        oFile.open("output.txt");
        std::string_view key = "tajne";
        cryptXOR(iFile, oFile, key);
    }
}

 

Comments

Masz tu jeszcze wersję z iteratorem modulo i użyciem innych buforów. Jest znacząco szybsza:

#include <fstream>
#include <string_view>
#include <iterator>
#include <algorithm>

template<typename Container>
class ModuleIterator {
public:
    using value_type = typename Container::value_type;
    ModuleIterator(const Container& c);
    value_type operator*() const;
    ModuleIterator& operator++();
private:
    using it = typename Container::const_iterator;
    it begin;
    it end;
    it current;
};

template<typename T>
ModuleIterator<T>::ModuleIterator(const T& c)
    : begin{c.begin()}, end{c.end()}, current{c.begin()}
{}

template<typename T>
typename ModuleIterator<T>::value_type ModuleIterator<T>::operator*() const {
    return *current;
}

template<typename T>
ModuleIterator<T>& ModuleIterator<T>::operator++() {
    ++current;
    if (current == end) {
        current = begin;
    }
    return *this;
}

template<typename T>
ModuleIterator<T> make_module_iterator(T const& t) {
    return ModuleIterator<T>(t);
}

void cryptXOR(std::istream& in, std::ostream& out, std::string_view key) {
    using iItType = std::istreambuf_iterator<char>;
    using oItType = std::ostreambuf_iterator<char>;
    auto mIter = make_module_iterator(key);
    std::transform(iItType{in}, {}, oItType{out},
        [&](char c) {
            auto outVal = *mIter ^ c;
            ++mIter;
            return outVal;
    });
}

int main() {
    std::ifstream inFile{"input.txt", std::ios::binary};
    std::ofstream outFile{"output.txt", std::ios::binary};
    std::string_view key{"bardzo tajne"};
    cryptXOR(inFile, outFile, key);
}

 

---

@mokrowski

Dzięki za odpowiedź, przeanalizowałem twój kod ( pierwszy ), nie rozumiem tylko w pełni po co jest linijka:

iFile >> std::noskipws;

przecież skoro plik jest czytany w trybie binarnym to nie trzeba się martwić o białe znaki. Druga sprawa to dlaczego wielkość bufora to akurat 4096.

Z góry dziękuje za wytłumaczenie :)

---

W 1  kodzie nie otwierałem pliku binarnie, stąd skipws. Poprawione w 2 wersji.

4096 to częsta wielkość strony pamięci w typowym OS. Sprawdzają się bufory które są wilelokrornością tej wartości. Można oczywiście pobrać tę wielkość z systemu, ale w każdym robi się to nieco inaczej i stąd uproszczenie.

Answer 2

Zamiast ciągle seekować i nadpisywać ten sam plik, spróbuj po prostu po kolei czytać bajty jednego pliku i pisać do drugiego. (jak chcesz nadpisać plik, po prostu na koniec podmień same pliki).

BTW, IMO ten StrLoopIterator jest przekombinowany, ja bym po prostu zrobił indeks % length :P Ale jak już chcesz używać iteratory, to pisz z normalnym interfejsem iteratorów, z operatorami ++, * etc.

Answer 3

#include <fstream>
#include <string_view>


int main()
{
	std::ifstream iFile("input.txt", std::ios::binary);
	std::ofstream oFile("output.txt", std::ios::binary);
	
	char buffer[4096];
	std::string key = "super tajne haslo";
	size_t kIndex = 0;
	size_t bytesRead;
	
	while ((bytesRead = iFile.read(buffer, 4096).gcount()) > 0) {
		for (size_t i = 0; i < bytesRead; ++i) {
			buffer[i] ^= key[kIndex++];
			if(kIndex == key.size()) kIndex = 0;
		}

		oFile.write(buffer, bytesRead);
	}

	return 0;
}

 

Comments

Kurcze, mam tyle odpowiedzi że nie wiem co najpierw ogarniać ;)

---

Porównaj czasy, bo chyba o wydajność Ci chodziło, i będziesz wiedział co najpierw ogarniać.

 

PS. kod nieco edytowałem.