Beim einfügen in einen string werden die ersten Zeichen überschrieben !!

Nlreeder

Hi Leute,

Ich versuche gerade einzelne Eingaben in einen string zu packen mit str.inside.
Dabei werden nach acht Stellen die ersten Zeichen aber wieder Überschrieben.
Ab der neunten Stelle sollte in den chars eigentlich nichts mehr gespeichert sein allerdings habe ich herausgefunden, das dort Zeichen eigespeichert sind , die ich nicht kenne.

Entweder bräuchte ich etwas womit ich detecten könnte ob in dem jeweiligen char ein Buchstabe gespeichert ist oder wie die Zeichen in dem string nicht mehr überschrieben werden.

Hier ist noch ein Ausschnitt aus dem Quellcode :

void check(char passwort0, char passwort1, char passwort2, char passwort3, char passwort4, char passwort5, char passwort6, char passwort7, char passwort8, char passwort9, char passwort10, char passwort11, char passwort12, char passwort13, char passwort14) {

	fstream cdata;
	string checkdata;
	string angabe;

	system("cls");

	cin.sync();
	cin.get();

	angabe.insert(angabe.size(), 1, passwort0);
	angabe.insert(angabe.size(), 1, passwort1);
	angabe.insert(angabe.size(), 1, passwort2);
	angabe.insert(angabe.size(), 1, passwort3);
	angabe.insert(angabe.size(), 1, passwort4);
	angabe.insert(angabe.size(), 1, passwort5);
	angabe.insert(angabe.size(), 1, passwort6);
	angabe.insert(angabe.size(), 1, passwort7);
	angabe.insert(angabe.size(), 1, passwort8);
	angabe.insert(angabe.size(), 1, passwort9);
        angabe.insert(angabe.size(), 1, passwort10);
	angabe.insert(angabe.size(), 1, passwort11);
	angabe.insert(angabe.size(), 1, passwort12);
	angabe.insert(angabe.size(), 1, passwort13);
	angabe.insert(angabe.size(), 1, passwort14);

        cdata.open("cdatastring.bin", ios::in|ios::binary);
	cdata.read((char*)&checkdata, sizeof(checkdata));
	cdata.close();

	if(angabe == checkdata) {
		cout << endl << "Zugang gewaehrt\n";

		cin.sync();
		cin.get();

	}

	else {
		cout << endl << "Zugang Verweigert\n";

		cin.sync();
		cin.get();
	}
}

LG Nlreeder

Skym0sh0

1.- Der Code ist schrecklich. (Soviele Parameter, ich glaub du hast einen vergessen)
2.- Ich weis nicht wirklich, was du willst oder vorhast, dafür drückst du dich zu ungenau aus.
3.- statt insert(ende, 1, char) gibt es auch += oder append
4.- Binäre Ein- und Ausgabe von Strings ist nicht so ganz simpel wie man denken mag. Ich hab da einmal was zu gesagt, was etwas falsch war, was daher rührt dass ich keine Ahnung von Serialisierung hab. Da sollten andere was zu beitragen. Aber das was du in Zeile 29 machst, das knallt.
5.- Was soll cin.sync() machen?

Marthog

Du hast du ziemlich alles falsch gemacht.

1. Überleg dir ein vernünftiges Design ohne die 1000 Parameter.
2. Objekte erst dann definieren, wenn du sie brauchst.
3. system() vermeiden
4. Warum cin.synch und cin.get?
5. Siehe Skym0sh0 Punkt 2
6. Statt fstream und ios::in kannst du auch ifstream verwenden.
7. Zeile 29: Wo hast du den Scheiß gelernt? Siehe Skym0sh0
8. endl ist hier wahrscheinlich vollkommen unnütz, aber vor der Ausgabe erst recht.
9. Im if-else-Block verwendest du den gleichen Code zweimal. Schreibe das doch lieber dahinter, außerdem: Warum cin.sync cin.get?

Es ist nicht klar, was du überhaupt vor hast. Als Parameter kannst du jedenfalls auch einen std::string nutzen, das macht die einzelnen Zeichen überflüssig und du kannst aber über den std::string trotzdem noch auf jedes einzelne Zeichen zugreifen.

Ich denke, dass du ein Login bauen willst. Hier mal ein Vorschlag:

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

const std::string PASSWORD_FILE = "password";

char obfuscCh(char ch)
{
	return ch ^ 0xFF;
}

bool savePassowrd(const std::string& password)
{
	std::ofstream out(PASSWORD_FILE.c_str(), std::ios::trunc);

	if (!out.good())
		return false;

	for (std::string::const_iterator it = password.begin(); it != password.end(); ++it)
		out << obfuscCh(*it);

	return true;
}

bool checkPassword(const std::string& password)
{
	std::ifstream in(PASSWORD_FILE.c_str());

	if (!in.good())
		return false;

	in.seekg(0, std::ios::end);
    std::size_t len = in.tellg();
    in.seekg(0, std::ios::beg);

	std::string buf;

	buf.resize(len);

	in.read(&buf[0], len);

	if (password.length() != buf.length())
		return false;

	for (std::size_t i = 0; i < password.length(); ++i)
		if (obfuscCh(password[i]) != buf[i])
			return false;

	return true;
}

int main()
{
	// Passwort festlegen
	savePassowrd("Test");

	for (std::size_t i = 0; i < 3; ++i)
	{
		std::string password;

		std::cout << "Password: ";
		std::getline(std::cin, password);

		if (checkPassword(password))
		{
			std::cout << "Successfully logged in.\n";
		}
		else
		{
			std::cout << "Invalid password.\n";
		}
	}
}

Wirklich sicher ist das aber nicht, weil man auch einfach die Passwortdatei überschreiben könnte, um ein eigenes Passwort festzulegen (wenn man weiß was das Programmg enau macht).

Skym0sh0

Mein Tipp wäre sowas in der Art gewesen...

std::size_t getLength(std::ifstream & ifs)
{
	ifs.seekg(0, ifs.end);
	std::size_t length = ifs.tellg();
	ifs.seekg(0, ifs.beg);

	return length;
}

std::string readPW(std::string const& filename)
{
	std::ifstream ifs(filename.c_str(), std::fstream::binary);
	std::size_t length = getLength(ifs);

	std::string result(length);

	ifs.read(&result[0], length);

	return result;
}

bool check(std::string const& passwort)
{
	if ( passwort.size() != 14 )
		return false;

	return passwort == readPW("cdatastring.bin");
}

Nlreeder

Ja so etwas wollte ich.
Ich habe mir gedacht das man das Passwort in der Queldatei leicht auslesen könnte und wollte es dann binär speichern.
Aber vielen dank für eure Antworten

Nathan

Nlreeder schrieb:

Ja so etwas wollte ich.
Ich habe mir gedacht das man das Passwort in der Queldatei leicht auslesen könnte und wollte es dann binär speichern.
Aber vielen dank für eure Antworten

Binär als Verschlüsselung bringt gar nichts. Null. Nada.
Denn dein Editor interpretiert dann automatisch Zeichen in die Binärefolge rein, und am Ende hast du (fast) das gleiche wie vorher.

Wenn du es so machen willst, dass man das Passwort nicht auslesen kann, dann lies dich mal in Einwegfunktionen/Hashfunktionen ein.

void legePasswortFest(const std::string &pass){
    speichereInPasswortDatei(SHA256(s));
}
bool istPasswortKorrekt(const std::string &pass){
    const std::string &passhash = leseVonPasswortDatei();
    return passhash == SHA256(pass);
}

Man kann zwar leicht den Hash aus der Datei lesen, man kann aber den Hash nicht in ein Passwort umwandeln (Außer man kann das Passwort erraten oder durchprobieren. Gegen Erraten hilft die Wahl eines ordentlichen Passworts, das Durchprobieren dauert extrem lange (Bei ordentlichen Passwörtern)).

Einfache kryptographische Hashfunktionen willst du für den Zweck nicht benutzen; sie sind auf schnelle Berechenbarkeit ausgelegt (was halt auch Bruteforcing schneller macht). Ein häufig benutztes, als sicher geltendes Verfahren ist bcrypt, welches ausdrücklich darauf ausgelegt ist, langsamer berechenbar zu sein. Ein neueres Verfahren, das außerdem viel Speicher braucht, ist scrypt, was vor allem dann spannend ist, wenn du damit rechnest, dass jemand ASICs auf das Problem wirft. Gelegentlich findet man auch noch PBKDF2, aber das gilt inzwischen als veraltet.

seldon schrieb:

Einfache kryptographische Hashfunktionen willst du für den Zweck nicht benutzen; sie sind auf schnelle Berechenbarkeit ausgelegt (was halt auch Bruteforcing schneller macht).

Das ist nicht richtig. Die langsamen Hashfunktionen sind nur um einen Faktor langsamer, sagen wir mal Faktor 1000. Weiterhin sind sie nicht so gut getestet wie SHA und haben möglicherweise Schwächen. Was macht man wenn einem SHA256 zu schnell zu Brute-Forcen geht? Man benutzt SHA266 (Bzw. SHA512/266), das ist um den Faktor 1024 langsamer zu Brute-Forcen bei gleicher Berechnungsgeschwindigkeit (Tatsächlich ist SHA512 auf 64-Bit-Rechnern schneller als SHA256, aber das ist zu vernachlässigen).
Brute-Forcen verhindert man nicht mit einer langsamen Hashfunktion, sondern mit einer großen Wertemenge.