Delphi oversættelse?

Det må blive noget i denne her stil:

Soepro-> Det var ikke meget kode du fik lagt ind... =)

Oops, nej det var en kikser. Vi prøver lige igen:

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <conio.h>

#define  strLen 256
typedef  char cStr[strLen+1];

char xor(char x, char y)
{
  int  bit;
  char ret;

  /* Logical XOR: if both bits are 1 or 0, the result is 0 */
  /* otherwise the result is 1.                            */
  ret = 0;
  for (bit = 0; bit < sizeof(ret)*8; bit++)
  {
    if (x & (1 << bit) && y & (1 << bit))
      continue;
    ret += (1 << bit);
  };
  return ret;
} /* xor */

int main (void)
{
  cStr  key, text, longkey, result;
  int  i, len;
  char  toto, c;
  FILE* TextFile;

  printf("Enter the key: ");
  gets(key);
  printf("Enter the text: ");
  gets(text);

  len = longkey[0] = '\x0';
  for (i = 0; i < (strlen(text) / strlen(key)); i++)
    len += sprintf(longkey+len, key);

  for (i = 0; i < len; i++)
  {
    toto      = xor(text[i], longkey[i]);
    result[i] = toto;
  };
  result[i] = '\x0';

  printf("The crypted text is: \n");
  printf("%s\n", result);
  printf("Should i save it to result.txt ? ");
  c = getch();
  if (c == 'Y' || c == 'y')
  {
    TextFile = fopen("result.txt", "w+b");
    fprintf(TextFile, result);
    fclose(TextFile);
    printf("Text saved.\n");
  };
  return 0;
} /* main */

Soepro -> Det virker helt fint... HVIS teksten er længere end key'en... Er det meningen? Eller hvordan retter man det...? ;)

Se så er det jo selv algoritmen, vi taler om - og den er ikke kodet ordentligt. Ideen -som jeg kan gennemskue det- er at løbende kryptere teksten vha. den indtastede key. Det kunne man mere enkelt gøre ved at 'loope' rundt i nøglen tegn for tegn:

char * encrypt(char* result char *text, char* key)
{
  int ofs, keyLen, keyOfs;
  keyLen = strlen(key);
  ofs = keyOfs = 0;
  while (text[ofs])
  {
    result[ofs] = xor(text[ofs], key[keyOfs]);
    if (++keyOfs > keyLen)
      keyOfs = 0;
  };
  result[ofs] = '\x0';
  return result;
} /* encrypt */

Denne algorime laver eksakt det samme som der bliver lavet mellem "len = longkey[0]" og "result[i] = '\x0'" ovenfor, og der skal derfor blot stå:

encrypt(result, text, key);

istedet for al den anden kode.

Small detail - while looper uendeligt indtil følgende rettelse er lavet:

char * encrypt(char* result, char*text, char* key)
{
  int ofs, keyLen, keyOfs;
  keyLen = strlen(key);
  ofs = keyOfs = 0;
  while (text[ofs])
  {
    result[ofs] = xor(text[ofs], key[keyOfs]);
    if (++keyOfs > keyLen)
      keyOfs = 0;
    ofs++; // <<<<<<<<<<<<<<< TÆL OP HER !!!
  };
  result[ofs] = '\x0';
  return result;
} /* encrypt */

while (text[ofs++]) //<<<<<<<<<<< ELLER HER...... :-)
  {
    result[ofs] = xor(text[ofs], key[keyOfs]);
    if (++keyOfs > keyLen)
    keyOfs = 0;
  }

Okay... Nu virker det bare fuldstændig som det skal... =) Tusinde tark for hjælpen... =)

- Så skal jeg bare have lavet et program til at dekryptere det igen, men det burde ikke være så svært, vel?? ;)

- Der er lidt point til Soepro! =)

//AciD~HeaD

Jeg har også et stykke delphi/pascal kode til at dekryptere... I de to delphi-koder, bruger de to HELT ens for-loops, men det synes jeg bare ikke jeg kan få til at virke med det du har lavet? Er det logisk, eller er det bare fordi jeg er en klump til C/C++?! =)

kamikaze >> NEJ, ikke i toppen af WHILE løkken !!! Hvad er ofs inde i while loop'et første gang ? Ikke 0 (nul) vel, men derimod 1 (en) !

acid-head >> Decrypt kræver at du har den krypterede tekst og den oprindelige nøgle. Hvis den krypterede text indeholder 1 på en given bit-position, og nøglen også gør det, må den oprindelige tekst have været 0 og omvendt. Hvis den krypterede text indeholder 0, må den oprindelige text have indeholdt det samme som nøglen gør. Hvis man XOR'er den krypterede text og den oprindelige nøgle, vil man derfor komme tilbage til den oprindelige tekst.

Decrypt kunne se sådan her ud:

char * decrypt(char* result, char*text, char* key)
{
  int ofs, keyLen, keyOfs;
  keyLen = strlen(key);
  ofs = keyOfs = 0;
  while (result[ofs])
  {
    text[ofs] = xor(result[ofs], key[keyOfs]);
    if (++keyOfs > keyLen)
      keyOfs = 0;
    ofs++;
  };
  text[ofs] = '\x0';
  return text;
} /* decrypt */

Eneste forskel i fht. encrypt er som du ser, rækkefølgen af parametrene, så du kunne også bare lave en macro:

#define decrypt(result, text, key) encrypt(text, result, key)

Og så kan du ikke få det til at virke, fordi der er en fejl i xor() routinen i 'if' på de to bits:

if (x & (1 << bit) && y & (1 << bit))

ændres til

if ((x & (1 << bit)) == (y & (1 << bit)))

Så funker det.

I fht. kryptering er xor MEGET anvendt (og dermed nem at bryde), så hvis du vil sikre dig yderligere, kan du "rulle" alle tegn med et offset afh. af tegnets position i selve teksten og det foregående tegns værdi - hermed forvanskes teksten både ud fra indhold og kodeord.

Kryptering brydes oftest ved at frekvensen på de almindelige tegn i en tekst (f.eks. gennemsnitligt antal E'er i en alm. dansk tekst) er den samme i den krypterede tekst. Selvom ovenstående koder vha. kodeordet, skal det altså være meget langt, for at yde sikkerhed mod at f.eks. 'E' tildeles samme værdien flere steder i teksten. (128 bits kryptering svarer til min. 16 tegns kodeord - 512 bits, som regnes for sikkert, er altså 64 tegns kodeord !)