Let kryptering

kik på pgp der kan downloades gratis på www.pgpi.org

Leder mere efter en meget simpel metode jeg selv kan lave, benytte, forstå

så lav din egen algoritme, men er den let og simpel, bliver den også let og simpel at bryde

havd med at lave en XOR på det der skal krypteres
det der sker er at bitne vendes ikke nogle stærk kryptering
men det gør at det er uforståligt for alm. mennesker.

bufferzone> Så skal du da have et api kald til PGP ...

Du kan enten bruge et crypto bibliotek hvilket giver en høj grad af sikkerhed eller du kan implementere dit eget.

Det letteste er blot at have en nøgle, som du XOR'er indholdet af filen med før skrivning og efter læsning.

Eks:
Key = k1 k2 k3 k4 k5 .... kn, hvor ki er en byte.

Når du læser dine data tager du byte for byte og laver en XOR med k[n]

Lad os antage at der står
hej
med
dig

i filen og key = "dette er min hemmelige xor streng"

h XOR d = første bogstav krypteret = 104 XOR 100 = 12 (104 er ASCII værdien for h og 100 for d)
e XOR e
j XOR t
m XOR t
e XOR e
d XOR e
d XOR r
i XOR m
g XOR i

XOR er sin egen inverse funktion, så dekryptering foregår på samme måde:
12 XOR 100 = 104 = h

osv.

XOR er 100% sikker kryptering hvis nøglen ikke skal genbruges (hvilket den nok skal i dit tilfælde, da den skal ligge i programmet).

Det er umuligt at lægge en nøgle ind i et program og skjule den så den ikke kan findes og bruges til dekryptering. Det kan gøre mere eller mindre let for pilfingre.

Sidder bare og leger og regner ikke med at lave verdens bedste krypterinssystem i første hug.

  Kan du ikke give et eksempel hvis nu "test af kryptering" er en streng jeg skal have krypteret

et lille tillæg
dem er nem at bryde

ved hjælp af en simpel algoritme

kunne det være

char streng[]="Hej";
streng[0]=streng[0]+43

(ville nok gøre det med et loop men princippet)

webshortcut> XOR er 100% sikkert hvis en oberservatør ikke kender plaintexten. Nøglen skal naturligvis have en hvis størrelse, så man ikke blot kan teste med alle kombinationer.

For en bitstreng på n bits er dette 2^n'te muligheder. Man kan så regne på, hvor stor den skal være for at man ikke kan bruteforce nøglen.

Hvis man ved lidt om de krypterede data (ex. at det er genkendelige ord) kan man naturligvis lave et angreb med ex. 8 bogstaver og således gætte en del af nøglen ad gangen...

Lav evt en funktion der blot bytter om på bogstaverne. A -> F, Y -> P osv.

Det er nok det simpleste

char streng[]="Hej med dig";
char key[]="dette er min hemmelige(!) krypteringsnøgle";
int i;

for (int i=0; i<length(streng); i++) {
  streng[i]=streng[i] XOR key[i mod length(key)]
}

.... med forbehold for min ringe c-syntax erfaring :-)

tror lige jeg har fået en ide

jpvj>ja og nej, hvis du vil bruge pgp, så skal du have et api kald, men så svært er det jo heller ikke at lave en krypteringsalgoritme med programmering, hvis den må være simpel

jpvj>

XOR er absolut ikke sikkert. Hvordan man knækker den slags koder har
være alment kendt siden midten af forrige århundrede !

Hvis nøglen er samme størrelse som de data, der skal krypteres, så er den helt sikker :-)

Jeg kan jo prøve at sende dig et dataset krypteret med XOR - hvis du kan bryde dem, så giver jeg 200 points. Er du frisk?

... og det skyldes naturligvis, at output har en uniform fordeling i ciffertext rummet - helt uafhængig af input, når man betragter en enkelt kryptering...

Eneste tilfælde hvor den principielt ikke kan brydes er hvis nøglen er
ligeså lang som plain text.

Det er heller ikke svært at implementere en rigtig crypto algoritme. Det kræver blot at man forstår den. RSA er meget nem f.x.

JP

(nå det nåede du selv at få skrevet)

RSA er er public-private key system.

*ingen* bruger det til rå kryptering.

Man bruger en normal kryptering og bruger så RSA til at kryptere
nøglen til den med.

Principielt set er jeg enig, da et cryptosystem skal være baseret på matematisk sikkerhed og ikke implementeringsmæssige detaljer, der er skjulte.

3DES og AES er nok nogle af de mest brugte krypterinsg algoritmer idag.

arne_v> Og det er jo ganske rigtigt, at det performer dårligt for store datamængder. Lige præcist i dette tilfælde kunne spørgeren måske bruge det, ved at kryptere med den private nøgle, og lade den offentlige ligge i programmet til at dekryptere med. Så kan data læses men ikke ændres...

3DES eller RC4 er vel de gældende i dag. AES er den ny standard. ECC systemer er lækre med de små nøgler...

Iøvrigt et stykke C/C++ kode med XOR:

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

int main()
{
  int i;
  char plain[] = "ONETIMEPAD";
  char key[] = "TBFRGFARFM";
  char *cipher;
  int l = strlen(plain);
  cipher = (char *)malloc(l);
  for(i=0;i<l;i++) cipher[i] = plain[i] ^ key[i % strlen(key)];
  cipher[l] = '\0';
  printf("%s -> %s\n",plain,cipher);
  for(i=0;i<l;i++) plain[i] = cipher[i] ^ key[i % strlen(key)];
  plain[l] = '\0';
  printf("%s -> %s\n",cipher,plain);
}

Der er vi vist enige, men hvis ikke vi skal tabe spørgeren på gulvet, så skal han enten have noget kan kan forstå, eller også et API tror jeg...

Koden ovenfor er ihvertfald rimelig konkret.

Og hvis det datasæt er "rimeligt" hvilket jeg vil definere som:
  - max. 20 tegn printable i key (key phrase der kan huskes)
  - min. 50 KB plain text i engelsk eller dansk
så er jeg frisk.

Nu strammer du vist kravene *G*.

50KB er da langt mere end nødvendigt...

Med de forudsætninger (specielt plain text) så er det klart muligt.

JP

Med 50KB tager det 5 sekunder og jeg skal ikke tænke.

Med mindre kunne man risikere at skulle tænke.

Men ja formentligt er mindre nok. Key længde x nogle få hundrede
burde være nok.

Og 10000 binære doubles fra en random generator er ikke
meget sjovt at analysere på.

Hvor meget text vil du så give ?

20 KB ?

10 KB ?

Nå der kommer nok ikke noget.

Så jeg vil lige poste 2 programmer.

Et krypterings/dekrypterings program som kaldes med:

encdec input-fil output-fil nøgle

Og et analyse program som laver dekryptering og udskriver
nøglen som kaldes med:

analysis input-fil output-fil

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

#define N 1000000

int main(int argc, char *argv[])
{
  int i,l;
  char key[80];
  char *plain, *cipher;
  FILE *fp1,*fp2;
  strcpy(key,argv[3]);
  plain=(char *)malloc(N);
  fp1=fopen(argv[1],"rb");
  l=fread(plain,1,N,fp1);
  fclose(fp1);
  cipher = (char *)malloc(l);
  for(i=0;i<l;i++) cipher[i] = plain[i] ^ key[i % strlen(key)];
  fp2=fopen(argv[2],"wb");
  fwrite(cipher,1,l,fp2);
  fclose(fp2);
  return 0;
}

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

#define N 1000000
#define MAXKEYLEN 20

int freq[20][256];

char find_key_char(unsigned char *s, int l, int ix,int lkey)
{
  int j,k,maxval,maxix;
  memset(freq,0,sizeof(freq));
  for(j=0;j<l;j++) freq[j%lkey][s[j]]++;
  maxix=-1;
  maxval=0;
  for(k=0;k<256;k++)
  {
      if(freq[ix][k]>maxval)
      {
        maxix=k;
        maxval=freq[ix][k];
      }
  }
  return maxix^' ';
}

void analyse(unsigned char *s, int l,char *key)
{
  int i,j,k,maxval,maxix;
  double sum,xl;
  for(i=1;i<MAXKEYLEN;i++)
  {
      memset(freq,0,sizeof(freq));
      for(j=0;j<l;j++) freq[j%i][s[j]]++;
      xl=l/i;
      sum=0;
      for(k=0;k<256;k++) sum+=(freq[0][k]/xl)*(freq[0][k]/xl);
      if(sum>0.05)
      {
        for(j=0;j<i;j++)
        {
            maxix=-1;
            maxval=0;
            for(k=0;k<256;k++)
            {
              if(freq[j][k]>maxval)
              {
                  maxix=k;
                  maxval=freq[j][k];
              }
            }
            key[j]=maxix^' ';
        }
        key[i]='\0';
        return;
      }
  }
}

int main(int argc, char *argv[])
{
  int i,j,l,lkey;
  char key[80];
  char *plain, *cipher;
  FILE *fp1,*fp2;
  cipher=(char *)malloc(N);
  fp1=fopen(argv[1],"rb");
  l=fread(cipher,1,N,fp1);
  fclose(fp1);
  analyse(cipher,l,key);
  printf("%s\n",key);
  plain = (char *)malloc(l);
  for(i=0;i<l;i++) plain[i] = cipher[i] ^ key[i % strlen(key)];
  fp2=fopen(argv[2],"wb");
  fwrite(plain,1,l,fp2);
  fclose(fp2);
  return 0;
}