4. mir reicht's! Kryptostream muß her!

mir reicht's! Kryptostream muß her!

  • ?

    Ok, mach ich.

    0
  • H

    Hallo,
    also ich stelle mir das so vor, dass der Stream mit einem Verschlüsslungstyp parametrisiert wird.

    Jede Verschlüssungsklasse sammelt alle für die Verschlüsselung benötigten externen Informationen über einen Ctor und speichert diese in Instanzvariablen.

    Außerdem bieten sie Methoden zum Ver- und Entschlüsseln an. Als Parameter würde ich statt Zeiger + Länge zwei Iteratoren vorschlagen (begin, end). Letztlich können das natürlich zwei char-Zeiger sein.
    Zeiger + Länge geht aber natürlich auch.

    Der Cryptostream speichert ein Verschlüsselungsobjekt. Wann immer Daten ver-/entschlüsselt werden müssen, werden die entsprechenden Methoden des Verschlüsselungsobjekts aufgerufen.

    0
  • H

    Toll. Da braucht man einmal > 6 Minuten für einen Beitrag und schon ist er überflüssig images/smiles/icon_smile.gif

    0
  • V

    Original erstellt von HumeSikkins:
    ja, ja, ja!

    Klar, zwei Iteratoren, gerne.
    Ähm, nochwas ziemlich wichtiges. Einige Verschlüsseler wünchen bestimmte Blocklängen um so richtig geil abzugehen.
    Kann der Verschlüsseler die bestimmen und der Stream die nehmen?

    Oder würde das die Funktion von flush einfach kaputthauen? Na, und wenn schon, Cryptstreams können genausogut ohne flush leben, ist vielleicht besser so.

    0
  • ?

    @volkard

    da gibt es ein Problem:
    ich war gerade am Verzweifeln, warum folgender Code einen Speicherzugriffsfehler liefert:

    int main ()
{
    char* x = "Hallo, Welt!";
    x[0] = 2;
}

    Habe dann im Stroustrup gelesen, daß ein über ein Zeichenkettenliteral initialisiertes char* immer als const interpretiert wird und das Resultat einer Zuweisung also undefiniert ist. obj.encipher(str,strlen(str); funktioniert also nicht, wenn str über ein Literal initialisiert wurde. Ärgerlich.

    0
  • V

    char* x = "Hallo, Welt!";
    zeigt auf Speicher innerhalb der exe und der shared, discardable und readonly. Also er gehört Dir net.
    char x[] = "Hallo, Welt!";
    ist korrekt.
    Hier wird ein char x[] auf dem Stack angelegt, der Dir gehört und "Hallo, Welt!" gleich reinkopiert. Damit kannste dann machen, was Du magst.

    0
  • ?

    Naja, man muss dann eben Arrays aus char nehmen.

    Der gute Mann hieß Vigenere, habe mich vertan.

    // vigenere.h
#ifndef _VIGENERE_
#define _VIGENERE_

#include <cstddef>

typedef unsigned char byte;

class Vigenere
{
 private:
    byte* key;
    void getBytes (byte* b, unsigned int k, size_t size);
 public:
    static const unsigned long int keySize = 4;
    Vigenere(unsigned int k);
    void encipher (char* data, size_t size);
    void decipher (char* data, size_t size);
};

#endif // _VIGENERE

// vigenere.cpp
#include "vigenere.h"

Vigenere::Vigenere (unsigned int k)
{
    key = new byte[4];
    getBytes(key, k, keySize);
}

void Vigenere::getBytes (byte* b, unsigned int n, size_t s)
{
    unsigned int mask = 0;
    for (unsigned i = 0; i < s; i++)
    {
    mask = (mask + 1) * 0x100 - 1;
    b[i] = (n & mask) >> (8 * i);
    }
}

void Vigenere::encipher (char* data, size_t size)
{
    for (unsigned i = 0, j = 0 ; i < size; i++, (!(i % keySize) ? j = 0 : j++))
    data[i] += key[j];
}

void Vigenere::decipher (char* data, size_t size)
{
    for (unsigned i = 0, j = 0; i < size; i++, (!(i % keySize) ? j = 0 : j++))
    data[i] -= key[j];
}

// main.cpp
#include <iostream>
#include "vigenere.h"
using namespace std;

int main ()
{
    char x[] = "Hallo, Welt!";
    Vigenere a(1230152);
    a.encipher(x,strlen(x));
    cout << x << endl;
    a.decipher(x,strlen(x));
    cout << x << endl;
}

    [ Dieser Beitrag wurde am 17.04.2002 um 21:20 Uhr von Doktor Prokt editiert. ]

    0
  • G

    soll ich nach Doktor Prokt vorlage den crc32 algo schreiben? wolltet ihr nicht iteratoren?
    MD5 algo habe ich schon gefunden, (habe es aber noch nicht versucht zu verstehen) aber umschreiben könnte ich ihn bestimt

    0
  • V

    Original erstellt von Dimah:
    soll ich nach Doktor Prokt vorlage den crc32 algo schreiben? wolltet ihr nicht iteratoren?

    void Vigenere::encipher(char* start,char* end)
{
   encipher(start,end-start);
}

    [ Dieser Beitrag wurde am 17.04.2002 um 23:14 Uhr von volkard editiert. ]

    0
  • V

    Original erstellt von Dimah:
    soll ich nach Doktor Prokt vorlage den crc32 algo schreiben?

    Jetzt wären erstmal die Stream-Sachen dran. Denn klappen die nicht, können wir das Projekt erstmal wegschmeißen.

    0
  • G
     

    Original erstellt von volkard:
void Vigenere::encipher(char* start,char* end)
{
   encipher(start,end-start);
}

    hä? rekrisiv und dan noch pointer mit einander verrächnen (undefieniertes verhalten)
    was soll das bringen?

    e: kein beitrag ohne edit images/smiles/icon_smile.gif

    [ Dieser Beitrag wurde am 17.04.2002 um 23:28 Uhr von Dimah editiert. ]

    0
  • V

    die
    void Vigenere::encipher(char*,char*)
    ruft die
    void Vigenere::encipher(char*,size_t)
    auf.

    end-start==len, wenn start+len==end

    0
  • G

    ok wieder was zu gelernt
    aber wie ich es in erinerung habe ist pointer mit pointer nicht erlaubt
    wenn schon dan reinterpret_cast in ints,

    [ Dieser Beitrag wurde am 17.04.2002 um 23:43 Uhr von Dimah editiert. ]

    0
  • ?

    Mit strlen geht das IMHO nicht, da diese Funktion bei einer \0 aufhört zu zählen. Wenn du jetzt binäre Daten hast wo eine \0 vorkommt, wird nicht alles verschlüsselt. Ich glaube die Länge muss auf jeden Fall übergeben werden!

    0
  • H

    aber wie ich es in erinerung habe ist pointer mit pointer nicht erlaubt

    Ich glaube da hast du was falsches in Erinnerung.

    0
  • V

    Mein Compiler birtet mir speziell für die Differenz von Zeigern sogar nen eigegenen Typen an:

    ptrdiff_t
    0
  • G

    ok, ich lag falsch
    jetz habe ich noch mal nachgekuckt, das addieren von zwei zeigern ist verboten, da habe ich wohl was duch einander gebracht

    [ Dieser Beitrag wurde am 18.04.2002 um 00:04 Uhr von Dimah editiert. ]

    0
  • R

    so ich hab auch mal was geschrieben, basiert zwar nur auf der Caesar Chifre (also einer monoalphabetischen Substitution) ist ja auch nur zur Demo

    #include <iostream>
#include <cstring>
using namespace std;

namespace crypto
{
  class out_crypto_caesar
  {
  private:
    int key;
    ostream& out;

  public:
    out_crypto_caesar(int ckey,ostream& to):key(ckey),out(to) { }
    out_crypto_caesar& operator<<(const char*str)
    {
      for(size_t i=0;*(str+i)!=0;++i)
    out << (char)(*(str+i)+key);
      return *this;
    }
  };
}

using namespace crypto;

int main()
{
  char*d1="hallo";
  out_crypto_caesar ccout(1,cout);
  ccout << d1;
  cout << endl;
}
    0
  • V

    Wer übernimmt Part c) ?

    0
  • H

    Hallo,
    ich habe jetzt mal einen CryptOStream implementiert.
    Eine Anwendung sähe so aus:

    int main()
{
    CryptoStream<Caeser> MyStream("KryptoTest.txt", ios: :out, Caeser('a'));
    MyStream << "Dieser Satz wird verschlüsselt" << endl;
    MyStream << "Schlüssel ist: " << 'a' << " als int: " << int('a') << endl;
    return 0;
}

    Bisher basiert das ganze noch auf basic_filebuf und ist demzufolge nicht sehr performant (doppelt Pufferung usw.).

    Schneller wäre es, wenn der Puffer von basic_streambuf abgeleitet wäre und sich selbst um das Filehandling kümmern würde.

    So war's aber erstmal weniger arbeit images/smiles/icon_wink.gif

    Wenn interesse besteht, würde ich den Code schnell hochladen. Ich denke für's Forum ist er etwas zu lang und unübersichtlich.

    0
Anmelden zum Antworten