hat jemand sowas, bzw. weiß wo man sowas kriegt?

Also ich bin auf der suche nach einer Klasse [mir ist nicht eingefallen wie ich sowas selber machen kann]
mit der ich strings ver und entschlüsseln kann [mit einem passwort]
hat jemand sowas, bzw. weiß wo man sowas kriegt?

Falls nur eine schnell einzubindende und einfache Möglichkeit gewünscht ist, würde ich eine Stromchiffrierung (z.B. RC4) nutzen. Sehr einfach zu implementieren und bietet den Vorteil gegnüber Blockalgorithmen, dass die Eingabedatenlänge nicht ein vielfaches der Blckgröße sein muss.

LangesPasswort schrieb:

XOR ist doch eigentlich recht gut.

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

zu TAE habe ich ein beispiel gefunden,
allerdings kann ich nicht nachvolzihen wo ich meinen text eingeben kann

http://www.kuno-kohn.de/crypto/algo/tea.htm

#define DELTA        0x9e3779b9
#define ROUNDS       32
#define LOG_ROUNDS    5
/* ... */
unsigned long key[4], y, z, sum = 0;
int i;
/* key   - Schlüssel (128 Bit)
 * y, z  - 32-Bit-Blöcke
 * sum   - Variable für DELTA
 * ...
 * Verschlüsselung
 */
for (i = 0; i < ROUNDS; i++)
{
  sum += DELTA;
  y += (z << 4) + key[0] ^ z + sum ^ (z >> 5) + key[1];
  z += (y << 4) + key[2] ^ y + sum ^ (y >> 5) + key[3];
}
/* ...
 * Entschlüsselung
 */
sum = DELTA << LOG_ROUNDS;
for (i = 0; i < ROUNDS; i++)
{
  z -= (y << 4) + key[2] ^ y + sum ^ (y >> 5) + key[3];
  y -= (z << 4) + key[0] ^ z + sum ^ (z >> 5) + key[1];
  sum -= DELTA;
}

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.

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

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?

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`?

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.

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]

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?

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

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.

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]

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

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

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

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