suche Verschlüsselung nicht so simpel wie xor

Schau mal auf der englischen Wikipedia-Seite...

http://en.wikipedia.org/wiki/Tiny_Encryption_Algorithm

Dort ist sogar ein Implementierung zu finden. Vlt. findest du zu den anderen Verfahren auch Einträge dort.

CStoll

Der eingehende 64-Bit-Block wird in zwei Hälften, nennen wir sie y und z, aufgeteilt.

Oder auf Deutsch: y und z sind deine zu codierenden Daten, die kannst du z.B. so aus einem String herausfiltern:

while(str.length()%(2*sizeof(long))!=0) str.pusch_back('\0');//auf Blockqröße bringen

unsigned long* lstr = reinterpret_cast<unsigned long*> str.data();

for(int i=0;i<str.data/sizeof(long);i+=2)
{
  //verschlüssle lstr[i] und lstr[i+1]
}

Artchi

Und warum nicht Blowfish?

HaJo.

download123 schrieb:

zu RC 4 habe ich leider nicht wirklich was gefunden
[was warscheinlich an meiner art zu googeln liegt]

RC4 ist eine Stromchiffrierung mit variabler Schlüssellänge (bietet u.a. Vorteile) bis zu imho 2048 Bit. Wird unter anderem in "älteren" SSL Protokoll-Implementationen genutzt. Der IE (128 BIt) nutzt es. Diverse FTP Programme usw...
Implementationen gibt es imho zu Hauf im Netz daher verweise ich jetzt mal z.B. mal hierher (ohne Gewähr).

Mit sogenannten Testvektoren könntest Du die Korrektheit der Implemenation überprüfen.

Artchi schrieb:

Und warum nicht Blowfish?

...oder den AES würde ich dann bei Blockalgorithmen empfehlen. Wofür benötigst du denn Kryptografie?

download123

warum nicht Blowfish ....
weil ich keine ahnung davon habe, und Blowfish sah noch komplizierter aus;
wenn ich mich da jedoch getäuscht haben sollte [ist eigentlich egal wie schwer oder einfach es ist ... wenn ich einfach meinen string reingeben kann und einfach was rauskommen, was man auch wieder zurückverwandeln kann] also wenn ich mich täuschen sollte sagt bescheid

eine frage noch zum wikipedia code
wie müssen die beiden unsigent long's befüllt werde, wie kriege ich meinen string da verarbeitet, muss ich das Zeichenweise machen? jeden buchstaben in seinen ansi code zerlegen oder wie`?

CStoll

Am einfachsten kannst du jeweils vier char-Werte (per Bit-Shift und Oder-Kombination) zu einem long-Wert zusammenfassen (am Ende mit \0 auffüllen). Oder noch einfacher: Du nimmst dir ein char-Array und deutest es per reinterpret_cast<> als long um (siehe mein Code-Beispiel unten).

Jester

HaJo. schrieb:

LangesPasswort schrieb:

XOR ist doch eigentlich recht gut.

Ist keine Verschlüsselung. Lediglich eine Bytemanipulation einfachster Art. Bietet null Sicherheit.

Ja und? Alles andere sind auch nur Bytemanipulationen. Wir arbeiten schließlich auf Digitalrechnern. Wenn die Schlüssellänge gleich der Textlänge ist, dann ist xor ein sehr sicheres Verfahren.

download123

xor ist gut, schön simpel aber wann ist schon mal der key genauso lange wie der text.. /edit ich will mit der verschlüsselung ein bischen mit irc spielen [ja ich weiß ich will keinen standart benutzen] ... dazu dürfte vieleicht sogar xor gehen ...irc nachrichten sind ja nicht so lang naja aber weiß nicht /ende edit

sorry, vieleicht bin ich einfach nur zu blöd aber ich raf nicht wie ich meinen string jetzt verschlüsselt kriege der code von vorher geht nicht [string has no member named push_back ...]

Danke schon mal für eure bemühungen

[leider hilft googel zu diesem Thema auch nicht wirklich weiter]

HaJo.

Jester schrieb:

Ja und? Alles andere sind auch nur Bytemanipulationen. Wir arbeiten schließlich auf Digitalrechnern. Wenn die Schlüssellänge gleich der Textlänge ist, dann ist xor ein sehr sicheres Verfahren.

Gut, mit der Bytemanipulation ist an sich vollkommen korrekt. Ich wollte damit aber nur ausdrücken, dass XOR "Verschlüsselungen", wie sie fälschlicherweise genannt werden, wirklich null Sicherheit bieten. Bei Schlüssellängen, solang wie der Klartext, was an sich ja schon unglaubliche Probleme in der Praxis darstellt und somit keine Anwendung findet, macht es auch noch nicht so sehr sicher. Abhilfe würde ein OTP schaffen.

download123 schrieb:

sorry, vieleicht bin ich einfach nur zu blöd aber ich raf nicht wie ich meinen string jetzt verschlüsselt kriege der code von vorher geht nicht [string has no member named push_back ...]
Danke schon mal für eure bemühungen
[leider hilft googel zu diesem Thema auch nicht wirklich weiter]

Hmm, gib doch einmal falls möglich mehr Informationen preis. Einsatz, Zweck, etc... Ansonsten habe ich doch schon auf RC4 (mit Link) verwiesen oder gab es dabei Probleme?

download123

HaJo ...

ja diverse... allein schon beim compilieren

main.cpp:76: error: `exit' undeclared (first use this function)
main.cpp:76: error: (Each undeclared identifier is reported only once for each function it appears in.)
main.cpp:78: error: `strcpy' undeclared (first use this function)
main.cpp:79: error: `strlen' undeclared (first use this function)
main.cpp:82: error: `strcat' undeclared (first use this function)
main.cpp:95: error: invalid conversion from `char*' to `unsigned char*'
main.cpp:95: error:   initializing argument 1 of `void prepare_key(unsigned char*, int, rc4_key*)'
main.cpp:99: error: invalid conversion from `char*' to `unsigned char*'
main.cpp:99: error:   initializing argument 1 of `void rc4(unsigned char*, int, rc4_key*)'

Außerdem verstehe ich den code nicht ansatzweise

ich will mit der verschlüsselung ein bischen mit irc spielen

allso nachrichten vor dem senden verschlüsseln

HaJo.

download123 schrieb:

Außerdem verstehe ich den code nicht ansatzweise
ich will mit der verschlüsselung ein bischen mit irc spielen
allso nachrichten vor dem senden verschlüsseln

Hmm, gut. Ich versuch dann erstmal den RC4 Algorithmus zu erläutern. Btw: C/C++ Erfahrungen hast du aber, oder?

RC4:
- ein ursprünglich geheimer Algorithmus
- entwickelt von Ron Rivest (Ron's Code) für RSA Data Security
- variable Schlüssellänge (also von 1 Zeichen bis 256 Zeichen)
- arbeitet mit S-Boxen. (Üblich bei Verschlüsselungsalgorithmen. Arrays in denen die Permutationen bearbeiten werden)
- S-Box~0 - 255~

Initialisierung der S-Boxen:
1.) Linear füllen S₀ mit 0 bis S₂₅₅ mit 255
2.) Schlüsselarray der Größe 256 (K₀ bis K₂₅₅) anlegen und mit dem Schlüssel füllen. Falls Schlüssel kürzer als 256 Bytes, dann immer wieder wiederholen
3.) Dann folgt eine Permutation von S-Box und "K-Box"

i = 0, j = 0

Für i = 0 bis 255
    j = (j + S[t]i[/t] + K[t]j[/t]) MOD 256
    vertausche S[t]i[/t] und [t]j[/t]

Eigentliche Verschlüsselung läuft in 2 Schritten ab:
1.) Zufallsbyte erzeugen

i = (i + j) MOD 256
j = (j + S[t]i[/t]) MOD 256
vertausche S[t]i[/t] und S[t]j[/t]
t = (S[t]i[/t] + S[t]j[/t]) MOD 256
Z = S[t]t[/t]

2.) XOR Verknüpfung mit Klartext-/Chiffretextbyte

Z ist das Zufallsbyte aus 1.)
K ist das Klartext-/Chiffretextbyte
B = Z XOR K

Soviel zum Algorithmus.

download123

und schon siehts garnicht mehr so schwer aus
um auf das beispiel zurück zu kommen
ftp://ftp.funet.fi/pub/crypt/cryptography/symmetric/rc4/rc4.c

damit ich den ablauf verstanden habe

mit der prepare_key funktion wird ein struct rc4_key erstellt bzw. gefüllt [state[256] von 0 -255 initialisiert etc]

danach wird in der funktion rc4 das eben erstellte struct verwendet um den text zu verschlüsseln

richtig soweit?

und was verdammt ist ein unsigned char? ... kann man da nicht irgendwie einen string nehmen .... [buffer_ptr[counter] ^= state[xorIndex]; sowas müsste doch auch mit nem string gehen ... das ver xoren]

download123

also...

ich habe das ganze jetzt mal etwas umgebaut

allerdings muss ich irgendetwas falsch gemacht haben, denn entschlüsseln funktioniert nicht

#include <stdio.h>
#include <string>
#include <iostream>

#define buf_size 1024

typedef struct rc4_key
{
   unsigned char state[256];
   unsigned char x;
   unsigned char y;
} rc4_key;

#define swap_byte(x,y) t = *(x); *(x) = *(y); *(y) = t

void prepare_key(std::string key_data_ptr, rc4_key *key)
{
  int key_data_len = key_data_ptr.size();
  int i;
  unsigned char t;
  unsigned char swapByte;
  unsigned char index1;
  unsigned char index2;
  unsigned char* state;
  short counter;

  state = &key->state[0];
  for(counter = 0; counter < 256; counter++)
  {
    state[counter] = counter;
  }
  key->x = 0;
  key->y = 0;
  index1 = 0;
  index2 = 0;
  for(counter = 0; counter < 256; counter++)
  {
    index2 = (key_data_ptr[index1] + state[counter] + index2) % 256;
    swap_byte(&state[counter], &state[index2]);
    index1 = (index1 + 1) % key_data_len;
  }
}

std::string rc4(std::string buffer_ptr, rc4_key *key)
{
  int buffer_len = buffer_ptr.size();
  unsigned char t;
  unsigned char x;
  unsigned char y;
  unsigned char* state;
  unsigned char xorIndex;
  short counter;

  x = key->x;
  y = key->y;
  state = &key->state[0];
  for(counter = 0; counter < buffer_len; counter++)
  {
    x = (x + 1) % 256;
    y = (state[x] + y) % 256;
    swap_byte(&state[x], &state[y]);
    xorIndex = (state[x] + state[y]) % 256;
    buffer_ptr[counter] = buffer_ptr[counter]^state[xorIndex];
  }
  key->x = x;
  key->y = y;
  return buffer_ptr;
}

int main(int argc, char* argv[])
{
  char seed[256];
  char data[512];
  char buf[buf_size];
  char digit[5];
  int hex, rd,i;
  int n;
  rc4_key key;

  std::string pass = "Testpass";
  //unsigned char passabl = "testpass";
  prepare_key( pass, &key);
  std::string str = "Verschlüsselungstes";

  str = rc4(str, &key);
  std::cout << str << std::endl;
  str = rc4(str, &key);
  std::cout << str;
}

HaJo.

download123 schrieb:

also...

ich habe das ganze jetzt mal etwas umgebaut

allerdings muss ich irgendetwas falsch gemacht haben, denn entschlüsseln funktioniert nicht

Ach kleines Problem. Du musst natürlich den Algorithmus VOR Ver-/Entschlüsselung initialieren. In dem Fall prepare_key(...) aufrufen.

Zum Code:
std::string nutzt i.d.R. char als Datentyp. RC4 nutzt aber unsigned char. Also das ganze ohne Vorzeichen was den Wertebereich verändert. Unter Windows gibt i.d.R. (erstmal) keine Probleme. Dafür garantiert aber niemand und adere OS sehen das anders. Also caste deine Strings vorher:

// C++ Cast von char nach unsigned char mit std::string str
unsigned char *pBuf = reinterpret_cast<unsigned char*>(str.c_srt());

Verwende keine "#define"s.

#define buf_size 1024 /* NICHT VERWENDEN */

const int buf_size = 1024; /* SO SOLLS GEMACHT WERDEN */

Es erleichtert unglaublich die Arbeit und ist typsicher.

Ansonsten solltest du die Variablen key_data_len und buffer_len als size_t und nicht als int deklarieren. Ebenso müssten dann die Iterationsvariablen i,... auch als size_t deklariert werden.

Deine Fragen aus dem vorigen Posting hast du dir ja schon beantwortet.

Edit:
Das Makro swap_byte habe ich ganz übersehen.
Hier der C++ Code:

#define swap_byte(x,y) t = *(x); *(x) = *(y); *(y) = t

// C++ Code
inline void swap_byte(unsigned char &x, unsigned char &y)
{
    unsigned char t = x;
    x = y;
    y = t;
}
// x/y sind nun Referenzen. Du musst die zwei Codezeilen ändern

download123

das klingt soweit echt super ...

aber 2 fragen hab ich noch

zum einen wenn ich das reinterpreten versuche bekomme ich immer sowas

error: reinterpret_cast from type `const char*' to type `unsigned char*' casts away constness

in diesem zusammenhang

void prepare_key(std::string data, rc4_key *key)
{
  unsigned char* key_data_ptr = reinterpret_cast<unsigned char*>(data.c_str());
  size_t key_data_len = data.size();

und zum anderen

HaJo. schrieb:

Ach kleines Problem. Du musst natürlich den Algorithmus VOR Ver-/Entschlüsselung initialieren. In dem Fall prepare_key(...) aufrufen.

hab ich doch in der 10. zeile der main

HaJo.

download123 schrieb:

das klingt soweit echt super ...

aber 2 fragen hab ich noch

zum einen wenn ich das reinterpreten versuche bekomme ich immer sowas
error: reinterpret_cast from type `const char*' to type `unsigned char*' casts away constness
in diesem zusammenhang
void prepare_key(std::string data, rc4_key *key)
{
  unsigned char* key_data_ptr = reinterpret_cast<unsigned char*>(data.c_str());
  size_t key_data_len = data.size();

Stimmt, c_str gibt gibt const Elem_ * zurück.

unsigned char *pBuf = reinterpret_cast<unsigned char*>(const_cast<char*>(str.c_str()));

Dann muss noch die Konstanz des Zeiger entfernt werden.

download123 schrieb:

HaJo. schrieb:

Ach kleines Problem. Du musst natürlich den Algorithmus VOR Ver-/Entschlüsselung initialieren. In dem Fall prepare_key(...) aufrufen.

hab ich doch in der 10. zeile der main

Damit meinte ich, dass der Algorithmus sowohl vor der Verschlüsselung als auch vor der Entschlüsselung initialisiert werden muss.

Verschlüsseln:
1.) prepare_key()
2.) rc4()

Entschlüsselen:
1.) prepare_key()
2.) rc4()

download123

Endlich funktioniert es ...vielen dank!!!!