simpel encryptie programma

[banaan-X]

Stel ik wil van elke Char die ik inlees, het ASCII-nr van dit char verhogen met 17. Hoe moet dat?

gewoon "teken := tekst[1] + 17; " werkt niet...

edit:

Sorry, het gaat om pascal/delphi, maar ik denk dat de c oplossing ook wel werkt

[ACM]

eerst de asci-waarde pakken, daar 17 bij optellen en dan weer omzetten naar char?

[banaan-X]

Op maandag 17 september 2001 18:15 schreef ACM het volgende:
eerst de asci-waarde pakken, daar 17 bij optellen en dan weer omzetten naar char?

En hoe pak je de ASCII-waarde dan? (met dubbel i )

[Janoz]

Op maandag 17 september 2001 18:56 schreef banaan-X het volgende:

[..]

En hoe pak je de ASCII-waarde dan? (met dubbel i )

Druk eens op F1.. Ik gok dat het iets als ord moet zijn...

[Verwijderd]

Natuurlijk niet vergeten om het antwoord (mod 26) te doen he?

[banaan-X]

Op maandag 17 september 2001 19:09 schreef Janoz het volgende:

[..]

Druk eens op F1.. Ik gok dat het iets als ord moet zijn...

You were right

Op maandag 17 september 2001 19:13 schreef SeWPKiP het volgende:
Natuurlijk niet vergeten om het antwoord (mod 26) te doen he?

Eh, Waarom wil je de rest weten van het antwoord / 26???

[Verwijderd]

Laat maar lullen joh, hij is vast posts voor de huiskamer aan het scoren ofzo..

[banaan-X]

Op maandag 17 september 2001 19:24 schreef Yarvieh het volgende:
Laat maar lullen joh, hij is vast posts voor de huiskamer aan het scoren ofzo..

Check eens wanneer hij iets gepost heeft, best rare verdeling...

[wasigh]

We hoeven je niet te vertellen dat het een erg simpel te ontsteutelen algoritme is?

[Janoz]

Op maandag 17 september 2001 19:30 schreef banaan-X het volgende:

[..]

Check eens wanneer hij iets gepost heeft, best rare verdeling...

offtopic:
Is best duidelijk... Telrekening van Oktober 2000 was zo hoog dat ie pas in juli 2001 afbetaald was

[JoostBaksteen]

Het is dat ik me verveel, hier stukkie code wat ik ooit voor school heb gemaakt:

code:

Procedure zin_encode(zin_invoer : String); {voor encode}
Begin
    zinnieuw := ''; { leeg maken voor als en/de -code al een keer gebruikt is }
    For y := 1 To length(zin_invoer) Do
        Begin
          charac := zin_invoer[y];
          x_geheim := ORD(charac);
          x_geheim := x_geheim + 9234456;
          charac := CHR(x_geheim);
          zinnieuw := zinnieuw + charac;
          
        End;
End;

[ACM]

Op maandag 17 september 2001 19:24 schreef Yarvieh het volgende:
Laat maar lullen joh, hij is vast posts voor de huiskamer aan het scoren ofzo..

Toevallig ken ik hem en ik vermoed dat dat niet het geval is

Maar het idee wat ie brengt zal wel te maken hebben met 127+17 das wat lastig terugvormen naar ascii

[Janoz]

Op maandag 17 september 2001 19:49 schreef ACM het volgende:

[..]

Toevallig ken ik hem en ik vermoed dat dat niet het geval is

Maar het idee wat ie brengt zal wel te maken hebben met 127+17 das wat lastig terugvormen naar ascii

Is het niet tot 256 (of tot en met 255)? Ik denk dat je met gewone tekst niet zo heel ver komt Maar het is wel handig om er iig rekening mee te houden...

[ACM]

Op maandag 17 september 2001 19:52 schreef Janoz het volgende:
Is het niet tot 256 (of tot en met 255)? Ik denk dat je met gewone tekst niet zo heel ver komt Maar het is wel handig om er iig rekening mee te houden...

Ascii is 7bits toch?
En evt 1 foutcheck bit

[banaan-X]

Op maandag 17 september 2001 20:01 schreef ACM het volgende:

[..]

Ascii is 7bits toch?
En evt 1 foutcheck bit

Ik dacht het niet hoor: http://www.asciitable.com
Hoe moet je anders 'é' typen bijvoorbeeld? Maar het is inderdaad wel handig om als je op 127 uitkomt (en daarboven) dan vanaf 33 weer te beginnen. Zie ook die site.

Op maandag 17 september 2001 19:33 schreef wasigh het volgende:
We hoeven je niet te vertellen dat het een erg simpel te ontsteutelen algoritme is?

Nee hoor...

[ACM]

Op maandag 17 september 2001 22:52 schreef banaan-X het volgende:
Ik dacht het niet hoor: http://www.asciitable.com
Hoe moet je anders 'é' typen bijvoorbeeld? Maar het is inderdaad wel handig om als je op 127 uitkomt (en daarboven) dan vanaf 33 weer te beginnen. Zie ook die site.

*kuch*

Je geeft zelf een perfect bewijs dat ascii maar 128 tekens bevat!

En ja, er is een extended ascii table... EBDIC is ook zoiets... Unicode nog iets uitgebreider.

[Verwijderd]

ahum, zou je niet gewoon zoeken op "rot13"?? da's ook veel makkelijker te decrypten (gewoon weer rot13). This type of application is available in your favorite browser is emacs.

/edit
In c zou jouw code (ongeveer) wel gewoon kunnen. Een char wordt daar automatisch omgezet in een int.

[Verwijderd]

ff gekeken op google("pascal function rot13") en dit vond ik:

code:

function rot13 (c : char) : char; (5)
 
  begin (* rot13 *) 
    if c in ['A'..'Z'] then 
    rot13 := chr (((ord (c) - ord ('A') + 13) mod 26) + ord ('A')) 
    else if c in ['a'..'z'] then 
    rot13 := chr (((ord (c) - ord ('a') + 13) mod 26) + ord ('a')) 
    else rot13 := c; 
  end; (* rot13 *)

en dit stuk code husselt alleen de letters a..z en A..Z om.

[banaan-X]

Op dinsdag 18 september 2001 18:09 schreef CBravo het volgende:
ff gekeken op google("pascal function rot13") en dit vond ik:

code:

function rot13 (c : char) : char; (5)
 
  begin (* rot13 *) 
    if c in ['A'..'Z'] then 
    rot13 := chr (((ord (c) - ord ('A') + 13) mod 26) + ord ('A')) 
    else if c in ['a'..'z'] then 
    rot13 := chr (((ord (c) - ord ('a') + 13) mod 26) + ord ('a')) 
    else rot13 := c; 
  end; (* rot13 *)

en dit stuk code husselt alleen de letters a..z en A..Z om.

Dus: bij #letter - #a wordt 13 opgeteld. dan wordt dit door 26 gedeeld en de rest onthouden (waarom??), en daar wordt dan weer #a bij opgeteld...
Ik zou nu echt niet meer weten hoor ik de begintekst terugkrijg

Ik heb trouwens nog een iets minder makkelijk te kraken manier bedacht: een programma neemt random een getal onder de 26, en noteert dit getal met 7 vermenigvuldig als eerste regel. Hierna wordt de tekst opgeschoven met random tekens.
Dat kan toch ook (en een 'z' schijft met 1 plaats op naar 'a', dan is het nog veilig ook: <DEL> enzo )

[banaan-X]

Op dinsdag 18 september 2001 22:40 schreef banaan-X het volgende:

[..]

Dus: bij #letter - #a wordt 13 opgeteld. dan wordt dit door 26 gedeeld en de rest onthouden (waarom??), en daar wordt dan weer #a bij opgeteld...
Ik zou nu echt niet meer weten hoor ik de begintekst terugkrijg

Ik heb trouwens nog een iets minder makkelijk te kraken manier bedacht: een programma neemt random een getal onder de 26, en noteert dit getal met 7 vermenigvuldig als eerste regel. Hierna wordt de tekst opgeschoven met random tekens.
Dat kan toch ook (en een 'z' schijft met 1 plaats op naar 'a', dan is het nog veilig ook: <DEL> enzo )

Nou snap ik hem ineens! Het best slim eigenlijk, je moet alleen even doorhebben dat je door 26 deelt omdat ons alphabet (...). En dat je zo dus ook alleen maar letters verhusselt. Nu heb ik nog de cijfers even gedaan:

code:

////// Codeer functie ///////////

function Tform1.Codeer(c : char) : char;

  begin
    if c in ['A'..'Z'] then
    codeer := chr (((ord (c) - ord ('A') + code) mod 26) + Ord('A'))   // terugkrijgen door -code te doen
    else if c in ['a'..'z'] then
    codeer := chr (((ord (c) - ord ('a') + code) mod 26) + Ord('a'))
    else if c in ['0'..'9'] then
    codeer := chr (((ord (c) - ord ('0') {getal-1} + code) mod 10) + Ord('a')) // tergkrijgen door -code te doen + een aantal tientallen. + Ord('0')
    else codeer := c;
  end; {codeer}

Zo dus!

[Verwijderd]

Bijna goed...

code:

codeer := chr (((ord (c) - ord ('0') {getal-1} + code) mod 10) + Ord('0'))

ipv

code:

..+ Ord('a')..

lijkt me

[banaan-X]

Op woensdag 19 september 2001 09:56 schreef DiFool het volgende:
Bijna goed...

code:

codeer := chr (((ord (c) - ord ('0') {getal-1} + code) mod 10) + Ord('0'))

ipv

code:

..+ Ord('a')..

lijkt me

Had ik al wel gezien, maar ik dacht ik maak van getalleen ook gewoon letters, maar dat kan natuurlijk niet want dan weet je niet meer of het nou een letter of getal is

Maar goed, waarom wil dit niet:

code:

////// Codeer functie ///////////

function Tform1.Codeer(c : char) : char;

  begin
    if c in ['A'..'Z'] then
    codeer := chr (((ord (c) - ord ('A') + code) mod 26) + Ord('A'))   // terugkrijgen door -code te doen
    else if c in ['a'..'z'] then
    codeer := chr (((ord (c) - ord ('a') + code) mod 26) + Ord('a'))
    else if c in ['0'..'9'] then
    codeer := chr (((ord (c) - ord ('0') {getal-1} + code) mod 10) + Ord('0')) // tergkrijgen door -code te doen + een aantal tientallen. + Ord('0')
    else codeer := c;
  end; {codeer}


////// Codeer zin //////////
function Codeerzin (zin_invoer : string) : String;
var zinnieuw                    : String;
    dummy                    : Integer;
    charac                  : Char;

begin

zinnieuw := ''; { leeg maken voor als en/de -code al een keer gebruikt is }
  For dummy := 1 To length(zin_invoer) Do
  Begin
    charac := zin_invoer[dummy];
    charac := Codeer(charac);
    zinnieuw := zinnieuw + charac;
  End;
end;

Hij geeft nu "[Error] wpenq.pas(284): Undeclared identifier: 'Codeer'" Het gaat dus om de regel "charac := Codeer(charac);"

[Verwijderd]

Hmm. Encryptie. Vroeger m'n grote passie (ok, nu nog eigenlijk wel)

Mijn systeem (simpel en heel effectief: voor bestanden)
(oorspronkelijk in TP7 gemaakt, maar de source kwijtgeraakt door een HD crash)
(Ik geef alleen het principe weer, niet een werkende source)

code:

// In en uitvoer bestanden openen als binair
// (zodat je teken voor teken kan lezen)
Begin = 128

   While (!EOF(InvoerBestand)) {
    Char = FGet(InvoerBestand, 1)
    
    EncChar = Char Xor Begin
    FPut(UitvoerBestand, EncChar)

    Begin++
    If Begin > 255 Then Begin = 128
   }

// Bestanden sluiten

Dit codeert de tekens dus via de XOR operator. Het werkt beter dan optellen en je krijgt er echt bestanden door die je moeilijk kan decrypten. Het programma dat ik ooit maakte dat volgens dit principe werkte was Titanlock. Ik had er destijds ook nog private en public keys ingebouwd (ik wilde iets bouwen dat volgens een PGP principe werkte, en dat was gelukt)

[Verwijderd]

Probeer dit eens:

Hij kent de procedure codeer niet omdat het een method van een klasse is, je moet dus zeggen <var>.Codeer bv Form1.Codeer of je moet van de procedure Codeerzin ook een method van de klasse TForm1 maken dus bv:

code:

function TForm1.Codeerzin(const ZinInvoer: string): string;
var
  I: Integer;
begin
  SetLength(Result, Length(ZinInvoer));
  for I := 1 to Length(ZinInvoer) do
    Result[I] := Codeer(ZinInvoer[I]);
end;

[CrazyA]

Op woensdag 19 september 2001 10:01 schreef Kyori het volgende:
Hmm. Encryptie. Vroeger m'n grote passie (ok, nu nog eigenlijk wel)

Mijn systeem (simpel en heel effectief: voor bestanden)
(oorspronkelijk in TP7 gemaakt, maar de source kwijtgeraakt door een HD crash)
(Ik geef alleen het principe weer, niet een werkende source)
enz...enz...enz...

Zoiets heb ik nog wel eens is QuickBasic 4.5 gemaakt
Ik ben ook bezig geweest met een encryptor die werkt op basis van een sleutelstring.
Het was de bedoeling om die string dan weer te maken met een random functie, met een nummertje als sleutel. Helaas ben ik nooit verder gekomen dan een coder/decodertje. Verder helemaal niks.
Misschien een ideetje voor iemand anders ?

[banaan-X]

Ik heb nu dit in een procedure opgenomen om van data.dat naar een willekeurig bestand (dat gaat wel goed) te schrijven, alleen er komt bijna niets in te staan. Alleen dit werkt: "writeln(g, (code * code) + 71); // de sleutel"
Er staat in het output bestand nl. alleen een getal, terwijl er dus wel een volledige data.dat is!

code:

  code :=  Trunc(Random(26) +1);
  filename:= teken[1] + teken[2] + teken[3] + teken[4] + teken[5] + teken[6] + teken[7] + teken[8] + '.dat';


  AssignFile(f, 'data.dat');
  Assignfile(g, filename);
  Reset(f);
  Showmessage(filename);
  Rewrite(g);
  writeln(g, (code * code) + 71);  // de sleutel
  While not Eof(f) do
  begin
    Readln(f, tekstin);
    Writeln(g, Codeerzin(tekstin));
  end;

  CloseFile(f);
  CloseFile(g);

Heb net ff wat geprobeerd, en het probleem is dat er men Codeerzin(tekstin) een lege string terugkomt (gewoon helemaal niets!) (voor de procedure TForm1.Codeerzin zie vorige blz)

[Verwijderd]

Op woensdag 19 september 2001 16:05 schreef banaan-X het volgende:
Ik heb nu dit in een procedure opgenomen om van data.dat naar een willekeurig bestand (dat gaat wel goed) te schrijven, alleen er komt bijna niets in te staan. Alleen dit werkt: "writeln(g, (code * code) + 71); // de sleutel"
Er staat in het output bestand nl. alleen een getal, terwijl er dus wel een volledige data.dat is!

[-knip-]

Heb net ff wat geprobeerd, en het probleem is dat er men Codeerzin(tekstin) een lege string terugkomt (gewoon helemaal niets!) (voor de procedure TForm1.Codeerzin zie vorige blz)

Uhm, nou programmeer ik dan zelf niet (meer) in C++, maar moet je niet ergens een waarde returnen?!
Je geeft nu namelijk helemaal nix terug bij die functie.

[Verwijderd]

Van welk type zijn jouw F en G?

[banaan-X]

Op woensdag 19 september 2001 16:23 schreef Kyori het volgende:

[..]

Uhm, nou programmeer ik dan zelf niet (meer) in C++, maar moet je niet ergens een waarde returnen?!
Je geeft nu namelijk helemaal nix terug bij die functie.

Ja was stom... Ik had inmiddels zelf ook al gezien.

F en G zijn de File-variabelen.

Ik trouwens nog een vraag, krijg ik met deze functies nou de originele tekst weer terug?

code:

//// Decodeer een char ////
function Tform1.Decodeer(c : char) : char;
var decnr    : integer;


  begin
    if c in ['A'..'Z'] then
    begin
    decnr := (ord(c) -code);
    while (decnr < 65) do decnr := decnr +26; // in A..Z bereik krijgen
    decodeer := chr(decnr);
    end
    else if c in ['a'..'z'] then
    begin
    decnr := (ord(c) - code);
    while (decnr < 97) do decnr := decnr +26;
    decodeer := chr(decnr);
    end
    else if c in ['0'..'9'] then
    begin
    decnr := (ord(c) - code);
    while (decnr < 48) do decnr := decnr +10;
    decodeer := chr(decnr);
    end
    else decodeer := c;
  end; {codeer}

edit: Het lijkt van wel.

[Verwijderd]

Volgens mij werkt dat wel, dit ook:

code:

function Tform1.Decodeer(c: Char): Char;
begin
  if c in ['A'..'Z'] then
    Result := Chr(((Ord(c) - Ord('A') + 26 - code) mod 26) + Ord('A'))
  else if c in ['a'..'z'] then
    Result := Chr(((Ord(c) - Ord('a') + 26 - code) mod 26) + Ord('a'))
  else if c in ['0'..'9'] then
    Result := Chr(((Ord(c) - Ord('0') + 30 - code) mod 10) + Ord('0'))
  else
    Result := c;
end; {codeer}

Ik vind het mooiere code als je Result gebruikt ipv de functie-naam, eerste is ook gebruikelijker volgens mij..

[Verwijderd]

Zoals hierboven al gezegd is, gebruik het XOR commando, is heel eenvoudig maar niet simpel te decrypteren...

[curry684]

Op maandag 17 september 2001 20:01 schreef ACM het volgende:
Ascii is 7bits toch?
En evt 1 foutcheck bit

Je kunt ASCII zowel 7-bit als 8-bit gebruiken, in 8-bit krijg je inderdaad de 'moeilijke' tekens erbij. Online communicatie en tekstversleutelingen gebruiken echter maar 7 bits, waardoor je in email nog wel eens verneukte tekens terugvind (uitroeptekens ipv valutatekens etc.). Daarom gebruik je UUEncode om binaire data naar 7-bits ASCII om te zetten.

[curry684]

Op woensdag 19 september 2001 17:19 schreef GrAviTy het volgende:
Zoals hierboven al gezegd is, gebruik het XOR commando, is heel eenvoudig maar niet simpel te decrypteren...

Van MD5-encrypte kun je zo op deze pagina versies in iedere programmeertaal van downloaden en is gewoon NIET te decrypten!

[LuCarD]

Op woensdag 19 september 2001 18:30 schreef curry684 het volgende:

[..]

Van MD5-encrypte kun je zo op deze pagina versies in iedere programmeertaal van downloaden en is gewoon NIET te decrypten!

Ermmm maarhe.... hij wil kunnen decrypten.... Dus wat heb je aan een "encryptie" zoals md5?

[Verwijderd]

Uit de Cryde sourcecode ( http://www.demogl.com/sourcecode.asp ):

Crypten:

code:

// Purpopse: this routine crypts the contents of the buffer per 4 bytes. if the length modulo 4 bytes > 0
// then the last bytes are not crypted.
//
// Additional Info: crypting scheme is: (version 1.0)
// source 32bits + cryptkey modulo (2^32)-1. This results in a new 32bit longword that is placed in the
// buffer at the place of the source 32bits.
void 
CCrydeDlg::CryptBuffer(long lBufferLength, byte *pBuffer, long lCryptKey)
{
    long    lSource,lRealLength, lResult;
    int     i, iAmount;
    byte    *pBuf;

    pBuf = pBuffer;
    lRealLength = lBufferLength - (lBufferLength % 4);
    iAmount = (int)(lRealLength / 4);
    for(i=0;i<iAmount;i++)
    {
        lSource = (((long)pBuf[(i*4)]) << 24) |
                    (((long)pBuf[(i*4)+1])<<16) |
                    (((long)pBuf[(i*4)+2])<<8) |
                    ((long)pBuf[(i*4)+3]);
        lResult = (long)(((__int64)lSource + (__int64)lCryptKey) & 0xFFFFFFFF);
        // lResult now contains the 32bits result longword. Put back the bytes.
        pBuf[(i*4)] = (byte)((lResult & 0xFF000000) >> 24);
        pBuf[(i*4)+1] = (byte)((lResult & 0x00FF0000) >> 16);
        pBuf[(i*4)+2] = (byte)((lResult & 0x0000FF00) >> 8);
        pBuf[(i*4)+3] = (byte)(lResult & 0x000000FF);
    }
    // done
}

Decrypten:

code:

// Purpose: decrypts the passed buffer with the given decryptkey.
void 
CCrydeDlg::DecryptBuffer(long lBufferLength, byte *pBuffer, long lDecryptKey)
{
    long    lSource,lRealLength, lResult;
    int     i, iAmount;
    byte    *pBuf;

    pBuf = pBuffer;
    lRealLength = lBufferLength - (lBufferLength % 4);
    iAmount = (int)(lRealLength / 4);
    for(i=0;i<iAmount;i++)
    {
        lSource = (((long)pBuf[(i*4)]) << 24) |
                    (((long)pBuf[(i*4)+1])<<16) |
                    (((long)pBuf[(i*4)+2])<<8) |
                    ((long)pBuf[(i*4)+3]);
        lResult = (long)(((__int64)lSource - (__int64)lDecryptKey) & 0xFFFFFFFF);
        // lResult now contains the 32bits result longword. Put back the bytes.
        pBuf[(i*4)] = (byte)((lResult & 0xFF000000) >> 24);
        pBuf[(i*4)+1] = (byte)((lResult & 0x00FF0000) >> 16);
        pBuf[(i*4)+2] = (byte)((lResult & 0x0000FF00) >> 8);
        pBuf[(i*4)+3] = (byte)(lResult & 0x000000FF);
    }
    // done
}

Key maken (hier 2 bytes die worden ingegeven en 2 random values)

code:

// calculate the needed numbers.
// first set the randomizer
srand((unsigned int)time(NULL));
// get 2 random numbers
byRnd1 = rand() % 255;
byRnd2 = rand() % 255;

// construct cryptkey
lCryptKey = ((((long)(m_byKey1)) * 256) + (long)(m_byKey2)) * ((((long)(byRnd1)) * 256) + (long)(byRnd2));

Dit is echt niet perfect, maar wel simpel.
Codecomments -> /dev/null/

[curry684]

Op woensdag 19 september 2001 18:36 schreef LuCarD het volgende:
Ermmm maarhe.... hij wil kunnen decrypten.... Dus wat heb je aan een "encryptie" zoals md5?

Decrypten? Hallo... decrypten is voor mietjes! Echte bikkels versleutelen hun belangrijke data op zo'n manier dat niemand, incluis zijzelf, er nog bijkan, dat is pas veilig! Want echte paranoia is zelfs jezelf niet vertrouwen, bedenk tenslotte: EEN SCHIZOFREEN IS NOOIT ALLEEN!!!

(ja ik ben in een melige bui, sorry )

[Gerco]

Nog even over rot13, hier mijn eenvoudige bijdrage:

code:

#include <stdio.h>

void main() {
      int c;
      while(c!=EOF) {
            c=getchar();
            if((c>='a' && c<='m') || (c>='A' && c<='M')) {
                c+=13;
            }
            else if((c>='n' && c<='z') || (c>='N' && c<='Z')) {
                c-=13;
            }
            if(c>=0) putchar(c);
      }
}

Leest stdin, doet er rot13 op en gooit naar stdout.

Niet schreeuwen dat het beter kan, het is zo ongeveer mn eerste c progsel.

[LuCarD]

Op woensdag 19 september 2001 20:25 schreef curry684 het volgende:

[..]

Decrypten? Hallo... decrypten is voor mietjes! Echte bikkels versleutelen hun belangrijke data op zo'n manier dat niemand, incluis zijzelf, er nog bijkan, dat is pas veilig! Want echte paranoia is zelfs jezelf niet vertrouwen, bedenk tenslotte: EEN SCHIZOFREEN IS NOOIT ALLEEN!!!

(ja ik ben in een melige bui, sorry )

Maar soms.... heb je de data die je wilt beveiligen nog nodig voor andere doeleinden.....

Geloof me het komt voor.....

En je kan data heeeeeeel goed beveiligen....
* LuCarD heeft net een eigen routine geschreven die nou ja bijna niet te kraken is.... Op bruteforce dan na natuurlijk......

[Verwijderd]

Op woensdag 19 september 2001 20:25 schreef curry684 het volgende:

[..]

Decrypten? Hallo... decrypten is voor mietjes! Echte bikkels versleutelen hun belangrijke data op zo'n manier dat niemand, incluis zijzelf, er nog bijkan, dat is pas veilig! Want echte paranoia is zelfs jezelf niet vertrouwen, bedenk tenslotte: EEN SCHIZOFREEN IS NOOIT ALLEEN!!!

Multi-Person-Syndrom (MPS), geen schizofreen. Schizofrenen hebben last van wanen, denken dat ze iemand anders zijn (bv napoleon ), MPS lijders hebben echt andere persoonlijkheden.

Jaja, nag-posting, maar er bestaat al zoveel misverstand omtrent schizofrenie..

[Verwijderd]

Op maandag 17 september 2001 20:01 schreef ACM het volgende:

[..]

Ascii is 7bits toch?
En evt 1 foutcheck bit

code:

 sorry hoor maar ik ben analoog

[Olaf van der Spek]

Op woensdag 19 september 2001 18:30 schreef curry684 het volgende:

[..]

Van MD5-encrypte kun je zo op deze pagina versies in iedere programmeertaal van downloaden en is gewoon NIET te decrypten!

Dat is een hash, geen cipher.

[wasigh]

Op woensdag 19 september 2001 17:19 schreef GrAviTy het volgende:
Zoals hierboven al gezegd is, gebruik het XOR commando, is heel eenvoudig maar niet simpel te decrypteren...

het probleem bij de meeste XOR implementaties is dat als je als wachtwoord een spatie opgeeft, (of een rij van spaties)
het wachtwoord heel mooi in beeld komt...

[Olaf van der Spek]

Dat moet je dan toch eens proberen met BlowFish, dat ook gebruikt maakt van XOR. Veel andere block ciphers gebruiken ook XOR.

[curry684]

Op donderdag 20 september 2001 16:53 schreef OlafvdSpek het volgende:
Dat is een hash, geen cipher.

HAP!