Source til kryptering

Du finder en god krypterings algoritmr som er anerkendt.

Output af den er binært. Men så base64 encoder du bare det krypterede.

Den gode kryptering kunne være AES eller 3DES.

Ok hvor finder jeg en sådan implementering? Også gerne en base64 encoder/decoder i c/c++.

Der er links til noget AES kode her:
  http://www.esat.kuleuven.ac.be/~rijmen/rijndael/

Base 64 må kunne findes mange steder.

Ellers lavede jeg engang noget:

#include "stdafx.h"
#include "B64.h"

#include <stdio.h>
#include <string.h>
#include <sys/stat.h>

BOOL APIENTRY DllMain( HANDLE hModule,
                      DWORD  ul_reason_for_call,
                      LPVOID lpReserved )
{
  switch (ul_reason_for_call)
  {
      case DLL_PROCESS_ATTACH:
      case DLL_THREAD_ATTACH:
      case DLL_THREAD_DETACH:
      case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}

struct sixbits { unsigned sb1:6;
                unsigned sb2:6;
                unsigned sb3:6;
                unsigned sb4:6; };

union overlay { struct sixbits sixs;
                char eigths[3]; };

char enc_b64vals[64] = { 'A','B','C','D','E','F','G','H',
                        'I','J','K','L','M','N','O','P',
                        'Q','R','S','T','U','V','W','X',
                        'Y','Z','a','b','c','d','e','f',
                        'g','h','i','j','k','l','m','n',
                        'o','p','q','r','s','t','u','v',
                        'w','x','y','z','0','1','2','3',
                        '4','5','6','7','8','9','+','/' };

int enc_deb64(char c)
{
  switch (c) {
      case '0':
      case '1':
      case '2':
      case '3':
      case '4':
      case '5':
      case '6':
      case '7':
      case '8':
      case '9':
        return c-'0'+52;
      case 'A':
      case 'B':
      case 'C':
      case 'D':
      case 'E':
      case 'F':
      case 'G':
      case 'H':
      case 'I':
      case 'J':
      case 'K':
      case 'L':
      case 'M':
      case 'N':
      case 'O':
      case 'P':
      case 'Q':
      case 'R':
      case 'S':
      case 'T':
      case 'U':
      case 'V':
      case 'W':
      case 'X':
      case 'Y':
      case 'Z':
        return c-'A';
      case 'a':
      case 'b':
      case 'c':
      case 'd':
      case 'e':
      case 'f':
      case 'g':
      case 'h':
      case 'i':
      case 'j':
      case 'k':
      case 'l':
      case 'm':
      case 'n':
      case 'o':
      case 'p':
      case 'q':
      case 'r':
      case 's':
      case 't':
      case 'u':
      case 'v':
      case 'w':
      case 'x':
      case 'y':
      case 'z':
        return c-'a'+26;
      case '+':
        return 62;
      case '/':
        return 63;
      case '=':
        return 0;
      default:
        return -1;
  }
  return -1;
}

void NormalToB64(char *s1,int l1,char *s2,int *l2)
{
  union overlay Cvt;
  char *p = s1;
  int ltmp = (l1*8+5)/6;
  int extra = 3-(ltmp+3)%4;
  int linlen = 0;
  (*l2) = 0;
  // loop through string
  for(int i=0;i<ltmp;i=i+4) {
      // convert 8->6 bit
      Cvt.eigths[2]=(((p-s1)<l1)?(*p):0);
      p++;
      Cvt.eigths[1]=(((p-s1)<l1)?(*p):0);
      p++;
      Cvt.eigths[0]=(((p-s1)<l1)?(*p):0);
      p++;
      s2[*l2]=enc_b64vals[Cvt.sixs.sb4];
      (*l2)++;
      s2[*l2]=enc_b64vals[Cvt.sixs.sb3];
      (*l2)++;
      s2[*l2]=enc_b64vals[Cvt.sixs.sb2];
      (*l2)++;
      s2[*l2]=enc_b64vals[Cvt.sixs.sb1];
      (*l2)++;
      // append newline if line too long
      linlen=linlen+4;
      if(linlen>75) {
        s2[*l2]='\n';
        (*l2)++;
        linlen=0;
      }
  }
  // append 0,1 or 2 "="
  (*l2)=(*l2)-extra;
  for(int j=0;j<extra;j++) {
      s2[*l2]='=';
      (*l2)++;
  }
  // append newline
  s2[*l2]='\n';
  (*l2)++;
  return;
}

void B64ToNormal(char *s1,int l1,char *s2,int *l2)
{
  union overlay Cvt;
  char *p = s1;
  int skip = 0;
  (*l2) = 0;
  // loop through string
  while(p<(s1+l1)) {
      // convert 6->8 bit
      Cvt.sixs.sb4=enc_deb64(*p);
      p++;
      if((*p)=='=') skip++;
      Cvt.sixs.sb3=enc_deb64(*p);
      p++;
      if((*p)=='=') skip++;
      Cvt.sixs.sb2=enc_deb64(*p);
      p++;
      if((*p)=='=') skip++;
      Cvt.sixs.sb1=enc_deb64(*p);
      p++;
      s2[*l2]=Cvt.eigths[2];
      (*l2)++;
      s2[*l2]=Cvt.eigths[1];
      (*l2)++;
      s2[*l2]=Cvt.eigths[0];
      (*l2)++;
      (*l2)=(*l2)-skip;
      // skip newline
      if((*p)=='\n') p++;
  }
  return;
}

B64_API void WINAPI B64Encode(const char *oldfilename, const char *newfilename)
{
  struct stat stbuf;
  stat(oldfilename,&stbuf);
  int n = stbuf.st_size;
  FILE *fp1 = fopen(oldfilename, "rb");
  char *buf1 = new char[n];
  fread(buf1,n,1,fp1);
  fclose(fp1);
  char *buf2 = new char[(4*n)/3+4+2*n/75];
  int len;
  NormalToB64(buf1,n,buf2,&len);
  buf2[len] = '\0';
  delete[] buf1;
  FILE *fp2 = fopen(newfilename, "w");
  fprintf(fp2,"%s",buf2);
  fclose(fp2);
  delete[] buf2;
}

B64_API void WINAPI B64Decode(const char *oldfilename, const char *newfilename)
{
  struct stat stbuf;
  stat(oldfilename,&stbuf);
  int n = stbuf.st_size;
  FILE *fp1 = fopen(oldfilename, "r");
  char *buf1 = new char[n];
  char *p = buf1;
  while(!feof(fp1) && fgets(p, n, fp1))
  {
      p += strlen(p);
  }
  fclose(fp1);
  char *buf2 = new char[(3*n)/4];
  int len;
  B64ToNormal(buf1, strlen(buf1), buf2, &len);
  delete[] buf1;
  FILE *fp2 = fopen(newfilename, "wb");
  fwrite(buf2, len, 1, fp2);
  fclose(fp2);
  delete[] buf2;
}

Hvad med en kryptering med en symmetrisk nøgle?

Øh ?

AES og DES er symmetriske

Godt. Jeg lærer noge nyt hver dag.

Her er en rimelig ren implentering

http://www.cr0.net:8040/code/crypto/aes/

Den indeholder blandt andet.

void aes_decrypt( aes_context *ctx, uint8 input[16], uint8 output[16] )
void aes_encrypt( aes_context *ctx, uint8 input[16], uint8 output[16] )
int aes_set_key( aes_context *ctx, uint8 *key, int nbits )

Men hvordan kalder jeg den lige. Hvis vi nu siger jeg har

char* text = "Der var engang";
char* key = "hemmelig"

og jeg vil gerne have text krypteret og de-krypteret? Lægger du ikke også et svar?

Jeg forstår nemlig ikke helt test main, som ligger i bunden.

Mit gæt:

aes_context ctx;
aes_set_key(&ctx,key,128);
aes_encrypt(&ctx,text,crypttext);


aes_context ctx;
aes_set_key(&ctx,key,128);
aes_decrypt(&ctx,crypttext,text);

Læg et svar her, så lukker jeg. Tak for hjælpen

svar