Suchergebnisse | lima-city

Suche auf lima-city

Beiträge (32)

in: 'Hooken' von iFrames

geschrieben von sw1tch
Das mit den relativen Pfaden wird natürlich böse aber trotzdem gute Idee. Wenn ich die PHP Klassen fertig hab setz ich mich da mal dran ;)
in: 'Hooken' von iFrames

geschrieben von sw1tch
Guten Abend.

Ich habe mir heute überlegt ein Online Http Request Tool in PHP (+ JS) zu schreiben. Ein ähnliches Projekt habe ich bereits in C++ umgesetzt.

Grundlegend sollte der Nutzer die Möglichkeit haben eine URL, HTTP Header und optional noch Cookies, GET- bzw. POST-Parameter und einen Port anzugeben. Die Response wird gegliedert in Header und Content ausgegeben. Hierbei soll der Content auch als iFrame direkt angezeigt werden.

Wenn nun der Nutzer innerhalb des iFrames agiert und einen Link besuchen möchte, dann würde ich diesen Aufruf gerne hooken, dass heißt die URL (mit Parametern) abgreifen und so simultan die Request- und Response-Header updaten. Lässt sich ein solches Unterfangen mit Javascript/PHP umsetzen?

MfG, 0x2A
in: fread Lese-Fehler

geschrieben von sw1tch
Ja, das wäre eine Möglichkeit.

Ich bin nochmal ordentlich mit dem Debugger durch den Code gestept und nun offenbart sich mir folgendes Problem:

Ich habe eine Verschlüsselung geschrieben die Zufallswerte zwischen 0 und 255 generiert und diese dann mit jedem einzelnen Zeichen des zu verschlüsselnden Strings XORed (Idee einer OTP-Verschlüsselung).

Nun kann es durchaus passieren, dass der User beispielsweise 'Z' (Ascii-Wert ist 90) eingibt und die Verschlüsselung dazu als Wert ebenfalls 90 generiert. XORed man nun beide Werte erhält man als binären Wert 0000 0000, also den "Null Character", der einen String terminiert und damit beendet.

Ich suche nach einer Möglichkeit, diesen Null Character irgendwie zu umgehen oder seiner Funktion zu berauben...
Es ist leider nicht möglich, dass ich den Character irgendwie ersetzen könnte oder so, da meine Verschlüsselung ja jeden ASCII-Wert generieren könnte...

MfG
in: fread Lese-Fehler

geschrieben von sw1tch
Ich konnte dies soweit erstmal lösen...
Inzwischen bereitet mir die binäre Null allerdings einige Probleme.
Als Beispiel habe ich ein Char-Array und dieses enthält die Zeichenfolge "\n". Diese wird nun als Steuerzeichen interpretiert.
Gibt es eine Funktion, die Steuerzeichen automatisch entschärft, also aus dem "\n" ein "\\n" macht?

MfG

in: fread Lese-Fehler

geschrieben von sw1tch

Ich möchte gerne eine binäre Datei einlesen, Source-Code dazu:

char* KeyFile( HWND hWnd ) {
	char szFilePath[MAX_PATH];
	
	uint64 FileSize;
	char *szBuffer;
	
	FILE *File;
	
	OPENFILENAME ofn;
	
	ZeroMemory(&ofn, sizeof(OPENFILENAME));
	ofn.lStructSize = sizeof(OPENFILENAME);
	ofn.hwndOwner = hWnd;
	ofn.lpstrFile = szFilePath;
	ofn.nMaxFile = sizeof(szFilePath);
	ofn.lpstrFilter = "All\0*.*\0";
	ofn.nFilterIndex = 1;
	ofn.lpstrFileTitle = NULL;
	ofn.nMaxFileTitle = 0;
	ofn.lpstrInitialDir = NULL;
	ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;

	if ( GetOpenFileName(&ofn) == TRUE ) {
		File = fopen( szFilePath , "rb" );
		if ( File == NULL )
			return "";

		fseek ( File , 0 , SEEK_END );
		FileSize = ftell( File );
		rewind ( File );

		szBuffer = (char*)malloc( sizeof(char)*FileSize );
		if (szBuffer == NULL)
			return "";

		if( fread(szBuffer, 1, FileSize, File) != FileSize )
			return "";

		fclose( File );
	}
	return szBuffer;
}

Nun funktioniert alles soweit prima, doch leider liest er (scheinbar?) nur die ersten Bytes einer Datei ein.
Bspw. wird bei einer Portable Executable (.exe) nur das "MZ" des Headers eingelesen.

Hoffe auf hilfreiche Antworten!
MfG

in: Linken mit gcc [InitCommonControlsEx]

geschrieben von sw1tch
Ich habe nun folgendes feststellen können.
Der Befehl zum linken ist korrekt. Möchte ich beispielsweise die Library "libw2_w32.a" einbinden lautet der Befehl "-lw2_32". Der Linker scheint den Befehl korrekt aufgenommen zu haben, da bei einer Veränderung des Namen (zu einer nicht existenten Lib) ein Fehler ausgegeben wird, dass die Library nicht gefunden wurde.
Nun wird der Befehl zwar erkannt, doch die Lib scheinbar nicht korrekt gelinkt. Er gibt mir weiterhin eine "undefined reference to..." Warnung an, wenn ich Befehle aus der libw2_32.a verwenden möchte!

MfG Sw1tch

Edit:
Konnte es selber lösen. Der Linker-Command muss ganz ans ende der Befehlskette gestellt werden!
in: Linken mit gcc [InitCommonControlsEx]

geschrieben von sw1tch
Ich habe eine WINAPI-Anwendung mit C erstellt und möchte diese nun kompilieren. Dies funktioniert prinzipiell super doch ich habe das Gefühl, dass er nicht korrekt linkt.
Ich möchte InitCommonControlsEx() verwenden und hierzu benötige ich den Header commctrl.h und die Library libcomctl32.a.
Weiterhin soll vor dem inkludieren des Headers _WIN32_IE 0x0300 definiert werden. Dies ist ebenfalls in meinem Code vorhanden und bewirkt schonmal, dass der Compiler die Funktion "kennt".

Der eigentliche Compiler-Aufruf sieht (mit UltraEdit) folgendermaßen aus:
C:\MinGW\bin\gcc.exe -lcomctl32 -pipe -mwindows -O3 -s -o %n *.c

Funktioniert auch Prima allerdings gibt der Linker den Fehler " ...undefined reference to `InitCommonControlsEx@4' " aus...

Ich bin ratlos, da eigentlich alles korrekt gelinkt und inkludiert sein sollte.

Danke für eure Hilfe,
Sw1tch
in: g++ Einstellungen

geschrieben von sw1tch
Schonmal vielen Dank für die gute Antwort.
Ich verwende g++ unter Windows und die Notierung hab ich hier natürlich falsch gepostet.
Ich habe als "Fehlerquelle" schonmal die Verwendung von iostream [cout] ausmachen können. Verwende ich lediglich stdio [printf] verringert sich die Größe von besagten 485kb auf ca 16kb.

Könntest du nochmal ein kurzes Bsp. für die Verwendung von strip geben?

MfG Sw1tch

Ah ich glaube ich habs, es müsste einfach nur -s sein...
in: g++ Einstellungen

geschrieben von sw1tch
Ich versuche mich derzeit in der Kompilation mithilfe von g++ einzufinden, doch verwundert mich die Größe der kompilierten Datei.
Ich verwende als Parameter lediglich "-o Filename.cpp" und bei einer einfach HelloWorld-Anwendung verbraucht die Executable knapp 485kb.
Nun frage ich mich, ob ich meine Parameter noch optimieren könnte, damit die Anwendung deutlich kleiner wird.

MfG Sw1tch

E:
Die Optionen -O3 und -Os sind mir bekannt, verringern aber in dem HelloWorld-Programm nicht die Größe.
in: GetTempPath Alternative

geschrieben von sw1tch
Großes Dankeschön!

MfG
in: GetTempPath Alternative

geschrieben von sw1tch
Ich bin auf der Suche nach einem Ersatz für die Funktion GetTempPath, die es dem Anweder ermöglicht, den Temp-Ordner des aktuell angemeldeten Users zu ermitteln (wird durch die User Environment Variable TMP bzw. TEMP ermittelt).
Die Problematik liegt darin, dass die Ausgabe der Funktion nicht die richtige Formatierung hat.
Das bedeutet, dass ich entweder eine andere Funktion benötige oder die User Environment Variable auslesen kann (User, nicht System!). Beim Auslesen der User-Variable möchte ich allerdings nicht auf ExpandEnvironmentStringsForUser zurückgreifen müssen.

Bsp:
Unter Win7: "C:\Users\XXXXXX~1\AppData\Local\Temp\"
Unter WInXP: "C:\DOKUME~1\USERNAME\LOKALE~1\Temp"
Wobei XXXXXX die ersten 6 Buchstaben des Users sind (ohne Leerzeichen) und USERNAME der ausgeschriebene Name ist.

Ich möchte gerne, dass die Pfade voll ausgeschrieben angezeigt werde:

Unter Win7 dann: "C:\Users\USERNAME\AppData\Local\Temp\"
Unter WinXP dann: "C:\Dokumente und Einstellungen\USERNAME\Lokale Einstellungen\Temp"

MfG

Edit:
Nur um der Antwort einmal vorzubeugen, getenv() ist mir durchaus bekannt aber es greift meines Wissens nur auf die System-Variablen zu.
in: WinSock-Programmierung

geschrieben von sw1tch
Liefert kein neues Ergebnis, vllt liegt das Problem ja seitens des Anbieters.
Trotzdem großes Dankeschön!

MfG

in: WinSock-Programmierung

geschrieben von sw1tch

Perfekt!
Funktioniert alles super doch ich hab noch eine Frage.
Ich hab den Content-Part wie folgt abgeändert:

"From: XXXXX@lavabit.com\r\nTo: XXXXX\r\nSubject: Ein Test\r\nMIME-Version: 1.0\r\nContent-Type: multipart/alternative; boundary=foo\r\n\r\n--foo\r\nContent-Type: text/plain\r\n\r\nDas ist der Inhalt\r\n--foo\r\nContent-Type: text/txt\r\nContent-Transfer-Encoding: base64\r\nContent-Disposition: attachment; filename=egal.txt\r\n\r\nBASE_64_Encoded_TEXT\r\n--foo--\r\n\r\n.\r\n");

Das Problem ist nun, dass er 2 Dateianhänge anzeigt, die beide funktionieren und den gleichen Inhalt darstellen, obwohl er nur einen anzeigen sollte..

in: WinSock-Programmierung

geschrieben von sw1tch
Im Prinzip hab ich es nun soweit gebracht, dass ein Attachment vorhanden ist, doch auf dem Dokument geht scheinbar nicht hervor, wie ich nun eine Datei angeben. Es wird dort in Beispielen als "<jpeg data>" bezeichnet. Alles weitere wie z.B. "filename" scheint nicht zu funktionieren bzw. ändert nur den Namen der nicht vorhandenen Datei in dem Anhang (filename wird bei GMail als Datei-Name angezeigt, doch die eig. Datei ist nich dabei)..

Möglicherweise liegt der Fehler an dem verwendeten Text?:

"CONTENT-DISPOSITION: ATTACHMENT; FILENAME=LOL.jpg; MODIFICATION_DATE=\"Wed, 12 Feb 1997 16:29:51 -0500\"\r\n"

MfG
in: WinSock-Programmierung

geschrieben von sw1tch
Auf eine Antwort von dir hab ich ja schon heimlich gehofft
Ja, du hast mich schon richtig verstanden, ich möchte wissen, wie ich nun ein "Attachment"-Part in diesen Code einbinde, der einen Datei-Anhang beim Versenden der Mail ermöglicht.

Vllt könntest du das Ganze noch an einem kleinen Stückchen Code verdeutlichen?

MfG

in: WinSock-Programmierung

geschrieben von sw1tch

Es ist wieder soweit. Ich bin mal wieder überfragt und meine letzte Hilfe seid nun ihr... :biggrin:

Mein Ziel ist es mittels WinSocket-Programmierung eine E-Mail von einem registrierten Konto bei lavabit.com zu einer EMail-Adresse bei GoogleMail zu schicken. Inhalt und "Subject" usw. möchte bzw. kann ich auch schon selber bestimmen. Nun bin ich inzwischen dazu genötigt, der EMail einen Datei-Anhang zu spendieren, doch leider konnte ich nicht in Erfahrung bringen, wie sich das anstellen lässt.

Der Code ist nen bißchen "schlank", da ich nicht RECV zum Empfangen der Server-Replies einsetze.
Ansonsten funktioniert der Code super....

Hier mein bisheriger Code, ohne den Dateianhang.

int transfer::StreamClient(char *szServer, short nPort) {

	int nRet;
	char EHLO[32] = "EHLO lavabit.com\r\n";
	char AUTH[32] = "AUTH LOGIN\r\n";
	char USER[64] = "BASE64_ENCODED_USER\r\n";
	char PASS[64] = "BASE64_ENCODED_PW\r\n";
	char MAIL[64] = "MAIL FROM:<XXXXXXXX@lavabit.com>\r\n";
	char RCPT[64] = "RCPT TO:<XXXXXXXX@googlemail.com>\r\n";
	char DATA[64] = "DATA\r\n";
	char FROM[64] = "From: XXXXXXX@lavabit.com\r\n";
	char TOME[64] = "To: Mein NickName\r\n";
	char SUBJ[64] = "Subject: Mein Betreff\r\n";
	char DATE[64] = "Date:\r\n";
	char TEXT[64] = "Eine Nachricht\r\n";
	char ENDS[16] = ".\r\n";
	char QUIT[16] = "QUIT\r\n";
	//
	//		Find the Server
	//
	LPHOSTENT lpHostEntry;
 
	lpHostEntry = gethostbyname(szServer);
	if (lpHostEntry == NULL) {
        	return 1;
	}
 
	//
	//		Create a TCP/IP Stream Socket
	//
	SOCKET	theSocket;
 
	theSocket = socket(AF_INET,
					   SOCK_STREAM,
					   IPPROTO_TCP);
	if (theSocket == INVALID_SOCKET)
	{
		return 1;
	}

	//
	//		Fill in Address-Structure 
	//
	SOCKADDR_IN saServer;
 
	saServer.sin_family = AF_INET;
	saServer.sin_addr = *((LPIN_ADDR)*lpHostEntry->h_addr_list);

	saServer.sin_port = htons(nPort);
 
	//
	//		Establish Connection
	//
 
	nRet = connect(theSocket,
				   (LPSOCKADDR)&saServer,
				   sizeof(struct sockaddr));

	if (nRet == SOCKET_ERROR)
	{
		closesocket(theSocket);
		return 1;
	}
 
	//
	//		Greetings to the Server
	//
	nRet = send(theSocket,
				EHLO,
				strlen(EHLO),
				0);

	//
	//		Methode: Base64-AUTH-LOGIN
	//
	nRet = send(theSocket,
				AUTH,
				strlen(AUTH),
				0);

	//
	//		Send Base64-Encoded User
	//
	nRet = send(theSocket,
				USER,
				strlen(USER),
				0);

	//
	//		Send Base64-Encoded Password
	//
	nRet = send(theSocket,
				PASS,
				strlen(PASS),
				0);

	//
	//		Submit MailAddress
	//
	nRet = send(theSocket,
				MAIL,
				strlen(MAIL),
				0);

	//
	//		Submit Recipient
	//
	nRet = send(theSocket,
				RCPT,
				strlen(RCPT),
				0);

	//
	//		Start DATA-Section
	//
	nRet = send(theSocket,
				DATA,
				strlen(DATA),
				0);

	//
	//		Send Infos
	//
	nRet = send(theSocket,
				FROM,
				strlen(FROM),
				0);
	nRet = send(theSocket,
				TOME,
				strlen(TOME),
				0);
	nRet = send(theSocket,
				SUBJ,
				strlen(SUBJ),
				0);
	nRet = send(theSocket,
				DATE,
				strlen(DATE),
				0);

	//
	//		Send Text
	//
	nRet = send(theSocket,
				TEXT,
				strlen(TEXT),
				0);

	//
	//		Send End.
	//
	nRet = send(theSocket,
				ENDS,
				strlen(ENDS),
				0);

	//
	//		Quit Connection
	//
	nRet = send(theSocket,
				QUIT,
				strlen(QUIT),
				0);

	//
	//		Close Socket and Return
	//
	closesocket(theSocket);
	return 0;
}

in: Primitives Polynom in Mathe

geschrieben von sw1tch
Definition:
"Ein normiertes irreduzibles Polynom $Formel: p(x) \in F_q[x]$ vom Grad $Formel: n$ über einem endlichen Körper $Formel: F_q$ , dessen Wurzeln im Zerfällungskörper $Formel: F_{q^n}$ über $Formel: F_q$ primitive Elemente sind, heißt primitives Polynom."

In meinem Fall möchte ich als endlichen Körper $Formel: F_2$ verwenden. Grad des Polynoms darf selber ausgesucht werden $Formel: \ldots$

Edit:
Wo sind nun die Mathe-Cracks?!
in: Primitives Polynom in Mathe

geschrieben von sw1tch
Es ist wieder einmal eure Hilfe von Nöten

Mir ist - trotz Recherche - noch nicht ganz klar, wie genau sich nun so ein primitives Polynom berechnen lässt. Vielleicht würde sich jemand erbarmen und mir das ganze einmal anhand eines Beispiels (am besten 15. Grades) nachvollziehbar durchrechnen..

MfG
in: Lineares Schieberegister

geschrieben von sw1tch
Okay, ich dachte Vollversion. Habe eh schon Seven 32Bit .
Wenn du Lust und Laune hättest würde ich mich sehr freuen!
Ich habe allerdings auch schon einen Ansatz um 64Bit-Ints zu verwenden:
```
void LFSR(string Hash) {
	stringstream ss;
	unsigned __int64 LFSR1_L = 0;
	unsigned __int64 LFSR1_C = 0;
	unsigned __int64 LFSR1_R = 0;
	ss << hex << Hash.substr(0,16);
	cout << ss.str() << endl;
	ss >> LFSR1_L;
	ss.str("");
	ss.clear();
	ss << hex << Hash.substr(16,32);
	cout << ss.str() << endl;
	ss >> LFSR1_C;
	cout << LFSR1_C << endl;
	printf ("Terminated in %d ms.\n",(int)(clock()/(CLOCKS_PER_SEC/1000)));
```
Habe nur die ersten beiden Teile gemacht, dass funzt aber soweit bestens. Am Besten wäre es, wenn du probierst den ASM-Code unter 32Bit lauffähig zu bekommen :-)

Edit:
Jetzt hab ich doch glatt vergessen auf die Frage zu antworten: Intel
in: Lineares Schieberegister

geschrieben von sw1tch
Ich hab auch schon drüber nachgedacht, doch die meisten Programme sind nunmal nicht auf 64Bit optimiert und unter Umständen kommt es sogar zu einer schlechteren Performance (wie Tests zeigen). Deswegen warte ich noch ein wenig...
```
Windows 7 64-bit gibt es kostenlos bei Microsoft.
```
Hab ich was verpasst?
Das gibt es kostenlos, aber nicht bei M$

MfG Switch.
in: Lineares Schieberegister

geschrieben von sw1tch
Ich bin auch ein Genie, heute nachmittag war mir das klar und jetzt hatte ichs wieder vergessen, Schande über mich.
Ich werde dann mal nen neuen Versuch starten das zu programmieren, wird wohl dann nicht so performant werden wie deine Assembly Version
Vielleicht kann ich das ja in etwa der Performance von der C-Version realisieren, da ich das Programm schon für 32Bit kompatibel haben wollte.

MfG Switch.

Edit:
Deine Assembler-Version dementsprechend zu editieren trau ich mir erstmal nicht zu, da ich mich da auch noch gut reinarbeiten müsste ;)
in: Lineares Schieberegister

geschrieben von sw1tch
Jap, an meinem 32Bit Sys wirds wohl dann liegen. Wie schauts mit dem Einbinden von den Assembler-Befehlen bei C++ und den entsprechenden Fehlermeldungen aus?
Achja, wieso hast du bei deinem C-, und ASM-Code das LFSR in 3 Teile eingeteilt?

Edit:
Ups, hab ich glatt übersehen. Ich gestehe ich hab das ganze nur schnell durch nen online-rechner gejagt
in: Lineares Schieberegister

geschrieben von sw1tch
Meiner Meinung nach sind mindestens 2 LFSR nötig, da ein Register einem Know-plaintext Angriff doch ausgesetzt wäre.
Angenommen der Angreifer kennt die Länge des Registers (bspw. durch reverse engineering meines Tools) und eine Folge von Klartext-Bits (und dazu dann natürlich die Geheimtext-Bits). Nun kann er daraus die Output-Bits ermittteln und das LFSR ist geknackt.
Verwendet man nun mindestens 2 LFSR, dann kann er zwar genauso vorgehen, weiß aber nicht, aus welchem Register das Output-Bit stammt und kann somit nicht die entsprechenden Seeds ermitteln.
Wobei hier gesagt werden muss, dass - wenn man 2 LFSR verwendet - das Verfahren natürlich anders abläuft (z.B. XORed man beide Output-Bits miteinander und erhält das "finale" Bit. Der Angreifer weiß zwar (auch wieder durch reverse engineering), dass die beiden Output-Bits miteinander geXORed werden und kann somit deren Zustände rekonstruieren, doch weiß er nicht welchem Register er welches Bit zuordnen soll.
Ich hoffe ich hab da keinen Denkfehler drin, aber demnach müsste die Verwendung von einem Register nicht sicher sein.

MfG Switch.

PS:
ich meine ich hätte in einem anderen Thread mal gelesen, dass du Kryptologie (oder in der Richtung) studiert hast, da müssten doch LFSR im Bezug auf PRNG bzw. CSPRNG behandelt worden sein?

PPS:

Kurze Nachfrage:
Bei Hash("test") = a94a8fe5ccb19ba61c4c0873d391e987982fbbd3 sollte doch dieser Code korrekt sein (?):
```
unsigned long left_C = 0x00000000a94a8fe5L; // ist doch equivalent zu 0xa94a8fe5L ?
unsigned long center_C = 0xccb19ba61c4c0873L;
unsigned long right_C = 0xd391e987982fbbd3L;
```
Dann kann ich doch auch die Werte einfachheitshalber zur Basis 10 anstatt 16 angeben:
```
unsigned long left_C = 2840236005;
unsigned long center_C = 14749741392356678000;
unsigned long right_C = 15245222982208932000;
```
Nun ist unsigned long ja ein 32bit Datentyp mit maximaler Größe 4.294.967.295. Ich bräuchte aber doch Speicher für 64bit, müsste also einen long long Datentyp verwenden, oder täusche ich mich?

PPPS:

Habe nun mal (versucht) den ASM-Code in meinem C++ Projekt einzubinden und habs mit folgender C++ konformer Syntax gemacht:
Zum Thema korrekte Einbindung: http://msdn.microsoft.com/en-us/library/45yd4tzz%28VS.80%29.aspx
```
inline void ASM_LFSR() {

		unsigned long left = 0x80000000L;
		unsigned long center = 0L;
		unsigned long right = 0L;
		unsigned long length = 1000000000L;
		unsigned int j;
		char *buffer;

		buffer = (char*) malloc (length);

		__asm mov rsi, buffer
		__asm mov rdi, length
		__asm dec rdi
		__asm mov rbx,left
		__asm mov rcx,center
		__asm mov rdx,right
[...]
```
Als Fehler-Code erhalte ich nun: "improper operand type" bzw. bei dem 2. Assembly-Befehl "inline assembler syntax error in 'second operand'"
Irgendwelche Ideen, Googol hat nicht viel ergeben.
in: Lineares Schieberegister

geschrieben von sw1tch
Tausend dank!

Halt dich bereit, falls noch Fragen aufkommen, da ich bestimmt wieder irgendwas nicht verstehe

MfG Switch.
in: Lineares Schieberegister

geschrieben von sw1tch
Im Prinzip hast du Recht, doch ist das nicht irrelevant wenn der Seed eh nicht zutage kommt? Dieser ist ja durch das verwenden von 3 Schieberegistern geschützt und somit nicht von einem Angriff bedroht.
Ansonsten habe ich meinen Fehler schon bemerkt :)

MfG Switch.

Edit:
Da scheint mir etwas nicht plausibel. Ich habe folgende Seeds verwendet:
unsigned long left_C = 12198720757830859000; bzw. 0xa94a8fe5ccb19ba6L
unsigned long left_1 = 15245222982208932000; bzw. 0xd391e987982fbbd3L
unsigned long left_2 = 15245222982208932000;
und erhalte diese ersten 100 Bits:
```
0000000000000000000000000000000000000000000000000000000000000000000000000010000100000010000010001111
```
Eig. sollte LFSR_C doch so aussehen:
```
1010100101001010100011111110010111001100101100011011100011010110
```
LFSR_1 und LFSR_2 dementsprechend:
```
1101001110010001111010011000011110011000001011111010010111101011
```
Ich glaube ich brauch erstmal ne Pause und werde später nochmal mit klarem Kopf das Ganze überdenken, man dürfe mich gerne auf meinen Denkfehler aufmerksam machen...
in: Lineares Schieberegister

geschrieben von sw1tch
Bezieht sich auf 10000000 Durchläufe, allerdings nur die Zeit der Speicherung.
Ich bin dir schonmal zu dank verpflichtet für deine deutlich effizientere Lösung! Allerdings hab ich nun noch eine Frage, wie initialisiere ich nun die LFSR korrekt mit meinen Werte?
Als Bsp. hierzu habe ich als Hash "a94a8fe5ccb19ba61c4c0873d391e987982fbbd3" (von "test").
Die ersten 160 Bit, wie aus den ASCII-Werten hervor geht:
```
0110000100111001001101000110000100111000011001100110010100110101011000110110001101100010001100010011100101100010011000010011011000110001011000110011010001100011
```
Diese möchte ich nun als Seed für LFSR_1 verwenden, also müsste ich ja dementsprechend left_1 editieren... nur wie?

MfG Switch.
in: Lineares Schieberegister

geschrieben von sw1tch
Ich generiere von einem eingegebenen Passwort den SHA-1 Hash (40 Zeichen). Nun wandle ich jedes zeichen mithilfe der ASCII-Werte in 8 Bit um und erhalte 320 Bit. Von den 320 Bit werden dann drei verschiedene 160 Bit-Blöcke auf die drei verschiedenen LFSR verteilt und LFSR_C entscheidet, welches der beiden anderen das Output-Bit generiert. Die LFSRs sind einfache bitsets.
Das Prinzip möchte ich in der Art auch behalten, da ein Angriff auf das LFSR unterbunden wird, da der Angreifer nicht weiß aus welchem Schieberegister das Output-Bit kommt und somit nicht die Initialisierungs-Werte herausfinden kann.

MfG Switch.
in: Lineares Schieberegister

geschrieben von sw1tch
Ich poste an dieser Stelle schonmal meine Umsetzung, dann kannst du schonmal vergleichen, ob wir der gleichen Idee nachgegangen sind. Ich werde in der Zeit versuchen deinen Code nen bißchen intensiver zu verstehen, da ich noch nicht lange C++ programmiere und dieses Programm mein Einstieg in die Kryptographie ist und gleichzeitig ein bißchen "learning by doing" sein soll

Ich weiß, dass der Code alles andere als gut ist aber es ging mir ersteinmal nur darum, es überhaupt umzusetzen...
```
bool feed;
bool *Cont = new bool[Length*8];
omp_set_num_threads(2);
#pragma omp parallel for private(j)
for(j = 0; j < Length*8; j++) {
	if(LFSR_C[0] == true){
		Cont[j] = LFSR_1[0];
		feed = (((LFSR_1[0] ^ LFSR_1[1]) ^ LFSR_1[18]) ^ LFSR_1[19]);
		LFSR_1 >>= 1;
		LFSR_1.set(159, feed);
	}
	else {
		Cont[j] = LFSR_2[0];
		feed = (((LFSR_2[0] ^ LFSR_2[1]) ^ LFSR_2[18]) ^ LFSR_2[19]);
		LFSR_2 >>= 1;
		LFSR_2.set(159, feed);
	}
	feed = (((LFSR_C[0] ^ LFSR_C[1]) ^ LFSR_C[18]) ^ LFSR_C[19]);
	LFSR_C >>= 1;
	LFSR_C.set(159, feed);
}
delete[] Cont;
```
Edit 1:
Die Speicherung dauert hier nun nicht mehr sonderlich lange (unter 1 Sekunde bei 10 Millionen).
Edit 2:
Code aktualisiert, hatte den falschen erwischt, sorry :/
Edit 3 (nimmt das mal ein Ende?):
Habe nun das Problem mit dem Multi-Core Support gelöst!
in: Lineares Schieberegister

geschrieben von sw1tch
Danke für die Mühe :)
Zu deinen Fragen: Ja es ist ein Linear Feedback Shift Register und bei dem Polynom handelt es sich um eines mit dem Grad 160. Das primitive Polynom dazu ist x^160 + x^19 + x^18 + x + 1. Wenn du noch meine C++ Umsetzung dazu brauchst, dann nur zu.

MfG Switch.

PS:
Als Seed kannste dir ja einfach welche aussuchen, wenn du doch nen bestimmten willst, dann kann ich dir gerne einen geben.
in: Lineares Schieberegister

geschrieben von sw1tch
Also ich bezweifle, dass ich mein gesamtes Vorhaben in ASM umsetzen könnte, da mir dazu auch einfach die nötigen Kenntnisse fehlen.
Inline-Assembler halte ich selber für die zeitkritischen Abläufe auch am Besten, allerdings bin ich in ASM wie gesagt recht unerfahren und habe keine Ahnung, unter welchem Aufwand ich diese kleine "bitset-Umsetzung" programmieren müsste. Als Kompiler verwende ich Visual C++ 2008 und ich denke durch Inline-ASM sollte da noch Einiges möglich sein?
Vielleicht kannst du mir ein Bißchen unter die Arme greifen und einfach mal auf ein Bespiel verweisen oder selber die Erstellung eines linear rückgekoppelten Schieberegisters unter ASM in einem kleinen Code-Aussschnitt deutlich machen

MfG Switch.

PS:
Bevor ich es vergesse, ich wäre sehr erfreut, wenn jemand kurz die korrekte Verwendung von OpenMP zum Support von mehrkernigen CPUs beschreibt. Ich habe es alles korrekt eingebunden und verwende für eine Schleife den Präprozessor-Befehl "#pragma omp parallel for" und trotzdem berechnet er nur mit 50%iger Auslastung( -> 1 Kernig?). Support von GPU würde mich nun auch interessieren
in: Lineares Schieberegister

geschrieben von sw1tch
Danke für deine Antwort, falls kein Verfahren schneller ist werde ich erstmal so vorgehen.
Mir hat sich nun noch eine weitere Frage ergeben - und zwar wüsste ich gerne, ob man die Funktionalität eines bitset auch mit einer anderen Methodik noch performanter umsetzen kann. Hierbei müsste ich shiften können (>>=) und auf die einzelnen Elemente zugreifen können, um das Erste bei jedem Durchlauf zu entnehmen und einige miteinander zu XORen, wobei das Ergebnis auch wieder eingefügt werden muss.

MfG Switch.
in: Lineares Schieberegister

geschrieben von sw1tch
Hallo Lima-Gemeinde,
erstmal an dieser Stelle eine kurze Begrüßung meinerseits

Nun zu meinem eigentlichen Anliegen. Ich programmiere derzeit eine Linear-Feedback-Shift-Register Umsetzung unter C++ und nutze die entstandenen Pseudo-Bits zur OTP-Verschlüsselung.
Nun habe ich das Problem, dass die Generierung der Bits möglichst schnell ablaufen soll und dies durch die Speicherung in einem Container deutlich verlangsamt wird. Als Bsp. erzeuge ich ohne Speicherung der Bits 10.000.000 in durchschnittlich 5 Sekunden.
Mit Speicherung dauert es doppelt so lange. Als Container habe ich bereits das Konkatenieren mit Strings, deque, list, vector und array getestet und keines war vollkommen zufriedenstellend!
Im Endeffekt bin ich nun auf der Suche nach einem Verfahren und meine Bits möglichst schnell in einem Container oder ähnlichem abzuspeichern (Assembler ebenfalls - falls schneller).
Falls gewollt, kann ich noch den SRC-Code dazu präsentieren. Ich hoffe ihr könnt mir helfen

MfG Switch.