datei verschlüsseln und entschlüsseln

morgen,

kann mir vielleicht jemand zeigen wie ich mit dem c++ builder eine datei verschlüsseln kann und danach wieder entschlüsseln kann? es reicht mir ein einfacher algorithmus, z.b.alle zeichem um 10 erhöhen.

wer hätte eine lösung?

jendrik

int_esskar

#define RND ((rand() ^ ((int)(GetTickCount()))) & 0x7fffffff)

LPSTR LDIGIT="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";

static DWORD crc_32_tab[256]=
{       /* CRC polynomial 0xedb88320 */
0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, 0x706af48fL, 0xe963a535L, 0x9e6495a3L,
0x0edb8832L, 0x79dcb8a4L, 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, 0x90bf1d91L,
0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL, 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L,
0x136c9856L, 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L, 0xfa0f3d63L, 0x8d080df5L,
0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L, 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L,
0x26d930acL, 0x51de003aL, 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, 0xb8bda50fL,
0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L, 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL,
0x76dc4190L, 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL, 0x9fbfe4a5L, 0xe8b8d433L,
0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, 0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL, 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L,
0x65b0d9c6L, 0x12b7e950L, 0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, 0xfbd44c65L,
0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L, 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL,
0x4369e96aL, 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L, 0xaa0a4c5fL, 0xdd0d7cc9L,
0x5005713cL, 0x270241aaL, 0xbe0b1010L, 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L, 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL,
0xedb88320L, 0x9abfb3b6L, 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L, 0x73dc1683L,
0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L, 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L,
0xf00f9344L, 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL, 0x196c3671L, 0x6e6b06e7L,
0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L, 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL,
0xd80d2bdaL, 0xaf0a1b4cL, 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, 0x4669be79L,
0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L, 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL,
0xc5ba3bbeL, 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L, 0x2cd99e8bL, 0x5bdeae1dL,
0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, 0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL, 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L,
0x86d3d2d4L, 0xf1d4e242L, 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, 0x18b74777L,
0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL, 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L,
0xa00ae278L, 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L, 0x4969474dL, 0x3e6e77dbL,
0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, 0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L, 0xcdd70693L, 0x54de5729L, 0x23d967bfL,
0xb3667a2eL, 0xc4614ab8L, 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, 0x2d02ef8dL
};

int WriteYearStamp(LPSTR ss)
{
    char hlp[32];
    WORD w;
    SYSTEMTIME st;
    GetLocalTime(&st);
    memset(ss, '@', 7);
    ss[0] = LDIGIT[st.wMonth % 31];
    ss[1] = LDIGIT[st.wDay % 31];
    ss[2] = LDIGIT[st.wHour % 31];
    w = (18 * ((60 * st.wMinute) + st.wSecond)) + (st.wMilliseconds / 56);
    sprintf(hlp, "%04X", w);
    memcpy(ss+3, hlp, 4);
    return 7;
}

LPSTR CopyOfStr(LPSTR ss)
{
    int len = strlen(ss) + 1;
    LPSTR cc = (LPSTR) malloc(len);
    memcpy(cc, ss, len);
    return cc;
}

LPSTR Unique(DWORD count)
{
    char uni[32];
    LPSTR cc=uni;
    DWORD i;
    if(count>31) count=31;
    for(i=0; i<count; i++) *cc++ = (RND % 26) + 'A';
    if(count>11) WriteYearStamp(uni);
    *cc++=0;
    return CopyOfStr(uni);
}

static BYTE GetRandNum(ULONGLONG* dwlRandNum, ULONGLONG* dwlFixum)
{
    DWORDLONG dwl;
    BYTE bResult, bIndex;
    int i;

    if(*dwlRandNum & 0x8000000000000000) dwl = 1 ^ (*dwlRandNum & 1);
    else dwl = *dwlRandNum & 1;

    *dwlRandNum = Int64ShllMod32(*dwlRandNum, 1);
    *dwlRandNum |= dwl;
    *dwlRandNum ^= *dwlFixum;

    for (bResult = 0, i = 0; i < 8; i++)
    {
        bIndex = (BYTE)(*dwlRandNum >> (i*8));
        bResult ^= (BYTE)crc_32_tab[bIndex];
    }
    return bResult;
}

static void CryCoCalculateKey(LPSTR szPassWord, ULONGLONG* dwlRandNum, ULONGLONG* dwlFixum)
{
    BYTE bChar, b;

    *dwlFixum=0; *dwlRandNum=0;
    for(; *szPassWord; szPassWord++)
    {
        bChar = (BYTE)crc_32_tab[(BYTE)*szPassWord];
        b = (BYTE)(*dwlFixum >> 57);
        *dwlFixum = Int64ShllMod32(*dwlFixum, 7);
        *dwlFixum ^= (DWORDLONG)b;
        *dwlFixum ^= (DWORDLONG)bChar;
    }
}

static void Von3Nach4(ULONGLONG* dwlRandNum, ULONGLONG* dwlFixum, LPSTR von, LPSTR nach)
{
    DWORD dw=*((DWORD*)von);
    LPSTR dwptr;
    int i;
    dwptr = (LPSTR)&dw;
    dwptr[0] ^= GetRandNum(dwlRandNum, dwlFixum);
    dwptr[1] ^= GetRandNum(dwlRandNum, dwlFixum);
    dwptr[2] ^= GetRandNum(dwlRandNum, dwlFixum);
    dwptr[3] ^= GetRandNum(dwlRandNum, dwlFixum);
    for (i=0; i<4; i++)
    {
        *nach++ = NVT64[dw & 63]; dw = dw >> 6;
    }
}

static void Von4Nach3(ULONGLONG* dwlRandNum, ULONGLONG* dwlFixum, LPSTR von, LPSTR nach)
{
    LPSTR dwptr;
    DWORD dw=0;
    LPSTR cc;
    int i;
    for (i=0; i<4; i++)
    {
        if ((cc = strchr(NVT64, *von++))==NULL) cc=NVT64;
        dw = dw >> 6;
        dw |= ((((DWORD)(cc-NVT64)) & 63) << 18);
    }
    dwptr = (LPSTR)&dw;
    dwptr[0] ^= GetRandNum(dwlRandNum, dwlFixum);
    dwptr[1] ^= GetRandNum(dwlRandNum, dwlFixum);
    dwptr[2] ^= GetRandNum(dwlRandNum, dwlFixum);
    dwptr[3] ^= GetRandNum(dwlRandNum, dwlFixum);
    *((DWORD*)nach) = dw;
}

int CryptAndConvertBaseKey(LPSTR ins, LPSTR outs, int crypt)
{
    ULONGLONG dwlFixum;
    ULONGLONG dwlRandNum;
    int len;
    LPSTR c1,c2;

    *outs=0;

    // What ever you want here, but never change it later.
    CryCoCalculateKey("SCHLUESSEL", &dwlRandNum, &dwlFixum);

    if(crypt)
    {
        len = strlen(ins);
        c1 = ins; c2 = outs;
        while(len>0)
        {
            Von3Nach4(&dwlRandNum, &dwlFixum, c1, c2);
            if(len<3) c2[3]='=';
            if(len<2) c2[2]='=';
            len -= 3; c1 += 3; c2 += 4;
        }
        *c2=0;
    }
    else
    {
        len = strlen(ins);
        if(len & 3) return 0;
        c1 = ins; c2 = outs;
        while (len>0)
        {
            Von4Nach3(&dwlRandNum, &dwlFixum, c1, c2);
            if (c1[3]=='=') c2[2]=0;
            if (c1[2]=='=') c2[1]=0;
            len -= 4; c1 += 4; c2 += 3;
        }
        *c2=0;
    }
    return 1;
}

int StrongCryptAndConvertBaseKey(LPSTR ins, LPSTR outs, int crypt)
{
    int len1=( (32 + strlen(ins)) * 2);
    LPSTR c1, c2;
    LPSTR buff1 = (LPSTR)malloc(len1);

    if(crypt)
    {
        LPSTR fptr = NULL;
        sprintf(buff1, "::%s", fptr=Unique(8));
        free(fptr);
        CryptAndConvertBaseKey(ins, buff1 + 10, 1);
        c2 = buff1+14; c1 = buff1+3;
        while(*c2)
        {
            *c2 = *c2 + *c1;
            c2++;
            c1++;
            if(c1 >= (buff1+14)) c1 = buff1+3;
        }
        CryptAndConvertBaseKey(buff1, outs, 1);
    }
    else
    {
        CryptAndConvertBaseKey(ins, buff1, 0);
        if(!lprfxcmpi(buff1, "::"))
        {
            c2 = buff1+14; c1 = buff1+3;
            while(*c2)
            {
                *c2 = *c2 - *c1;
                c2++;
                c1++;
                if (c1 >= (buff1+14)) c1 = buff1+3;
            }
        }
        CryptAndConvertBaseKey(buff1+10, outs, 0);
    }
    free(buff1);
    return 1;
}

wie du die datei jetzt einliesst, musst du selber wissen

[ Dieser Beitrag wurde am 07.10.2002 um 02:20 Uhr von int_esskar editiert. ]

hm,

so was komplexes habe ich doch gar nicht verlangt, ich will einfach nur jedes zwichen um 10 erhöhen, das reicht für meine zwecke.

jendrik

int_esskar

ist aber nicht wirklich verschlüsselt...

int add10(BYTE* pbByte, DWORD size)
{
   int* ptr = (int*)pbByte;
   while(size--)
   {
      *ptr += 10;
      if(*ptr > 255) *ptr = *ptr % 255;
      ptr++;
   }
}

[ Dieser Beitrag wurde am 07.10.2002 um 03:26 Uhr von int_esskar editiert. ]

[ Dieser Beitrag wurde am 07.10.2002 um 03:28 Uhr von int_esskar editiert. ]

volkard

Original erstellt von int_esskar:
...

Jo. Ich erlaube mir, den Code leicht zu c++-ifizieren.

void cryptByAdd10(char* data,size_t size)
{
   for(int i=0;i!=size;++i)
      data[i]+=10;
}

int_esskar

Original erstellt von volkard:
...

dann doch eher..

void cryptByAdd10(char* data,size_t size)
{
   while(size--)
      data[size]+=10;
}

[ Dieser Beitrag wurde am 07.10.2002 um 11:43 Uhr von int_esskar editiert. ]

volkard

Original erstellt von int_esskar:
dann doch eher..
void cryptByAdd10(char* data,size_t size)
{
   while(size--)
      data[size]+=10;
}

Warum? Magste date[0] nicht behandeln?
Und was hast Du gegen for-Schleifen? Für solche Zwecke sind die doch fein lesbar.
Und irgendwie macht mein Compiler aus beiden Versionen 12 Assemblerbefehle.

1:    void cryptByAdd10(char* data,size_t size)
2:    {
00401000   mov         eax,edx
00401002   dec         edx
00401003   test        eax,eax
00401005   je          cryptByAdd10+16h (00401016)
3:       while(size--)
4:          data[size]+=10;
00401007   mov         al,byte ptr [ecx+edx]
0040100A   add         al,0Ah
0040100C   mov         byte ptr [ecx+edx],al
0040100F   mov         eax,edx
00401011   dec         edx
00401012   test        eax,eax
00401014   jne         cryptByAdd10+7 (00401007)
5:    }
00401016   ret

7:    void cryptByAdd102(char* data,size_t size)
8:    {
00401020   xor         eax,eax
00401022   test        edx,edx
00401024   je          cryptByAdd102+16h (00401036)
00401026   push        ebx
9:       for(size_t i=0;i!=size;++i)
10:         data[i]+=10;
00401027   mov         bl,byte ptr [eax+ecx]
0040102A   add         bl,0Ah
0040102D   mov         byte ptr [eax+ecx],bl
00401030   inc         eax
00401031   cmp         eax,edx
00401033   jne         cryptByAdd102+7 (00401027)
00401035   pop         ebx
11:   }
00401036   ret

Oh, die for-schleife hat nur 6 Befehle in der Schleife, die while-Schleife hat 7. Also ist for vielleicht sogar schneller.

Aber das war's gar nicht, um was es geht. Wollte nur die Lesbarkeit erhöhen, indem ich vereinfachte. Daß sowas gerne auch dabei schneller wird, ist purer Zufall.
Und anmeckern will ich Deine Lösung auch nicht, die ist bereits n der ersten Fassung ne gute Antwort für den Fragestellen. Wollte nur noch nen kleinen Tip einbringen.

[ Dieser Beitrag wurde am 07.10.2002 um 12:08 Uhr von volkard editiert. ]

int_esskar

na gut, na gut, es ist ja auch noch früh!

ich habe meine Daten teilweise mir einem Bit-Kehrer "verschlüsselt.
Gruss SKL

void krypto( char *anfadr )
{
  int i, l;
  unsigned char *poin;

  poin = anfadr;

  l = strlen( anfadr );
  for ( i=0; i<l; i++ )
  {
     *poin = ((*poin) << 4) + ((*poin) >> 4);
     poin++;
  }
}

Edit:
Bitte die Code-Tags benutzen. Danke!

[ Dieser Beitrag wurde am 07.10.2002 um 20:19 Uhr von Jansen editiert. ]

F98

Wie kann ich das Beispiel von int_esskar in einem eigenen Programm anwenden? Mir ist nicht ganz klar welche Funktionen ich aufrufen muss, damit ich aus einem uncodierten Eingabestring einen codierten Ausgabestring erhalte und umgekehrt. Und was für ein Algorithmus ist das eigentlich (Blowfish?)?

rüdiger

ich würde euch empfehlen, dass ihr lieber eine Krypto Library nehmt, die euch alles schon anbietet, da man bei den Implementierungen leicht misst machen kann (zB. beim C&P die SBox versaut, einfach was falsch verstanden, Code falsch eingebunden ...).

Librarys findet ihr in der FAQ oder per Google

Hargon

mußte man nicht eigentlich nur die datei in einen buffer lesen, diesen verschlüsseln und das ganze dann in eine neue datei schreiben (zusammen mit angaben über ursprünglichen dateityp zum beispiel)??

danach dann vieleicht noch da original löschen...

oder sehe ich das völlig verkehrt?

rüdiger

jup, nur beim löschen der Datei solltest du darauf achten, dass man diese mit irgend welchen Zeichen überschreiben sollte (20 mal oder so glaub ich), weil man die sonst leicht rekonstruieren kann

(wenn du aber keine gute Verschlüsselung nutzt, ist das eh egal)

Hargon

ja danke, war nur so ne frage, weil ich den ihnalt der diskusion nicht verstehe...

es ist doch jedem selbst überlasse, welchen algo zum verschlüsseln er nehmen will...

wer unbedingt mit caesar verschlüsseln will soll es tun...

fraglich ist ja auch immer vor wem man die daten schützen will??