Nem kryptering af streng?

Du samler heller ikke på point her Bertel? Bruger din Hex-funktioner, de er alt rigelige....
Tak for hjælpen også til dig Jess.
Godt Nytår når I når dertil.

Vær opmærksom på at omdanne til hex er IKKE en kryptering! Du kan evt. modificer den så den benytter sig af "Cæcars algoritme". Den er IKKE sikker, men er simpel at implementeret.

Givet en krypteringsfunktion (e) og en dekrypteringsfunktion (d), der ser ud som beskrevet nedenfor. Her er "k" din nøgle, der kan varetage en værdi i intervallet [0;25], "x" er din klartekst (altså din hexværdi) og "y" er din ciphertekst. Bemærk 26 er valgt da det er svarende til de 26 bogstaver i det engelsksproget alfabet.

e(x) = (x + k % 26)
d(y) = (y - k % 26)

Krypteringen kan hurtigt brydes med en exhaustive key search, da der kun er 26 mulige nøgler eftersom det er en monoalfabetisk kryptering. Udvid evt. selv krypteringsfunktionen, så den bliver polyalfabetisk. Dette vil også gøre en eventuel exhaustive key search mere besværlig (men ikke umulig).

Generelt når man laver kryptering så er der to regler, der altid skal overholdes.

1) Algoritmen skal være offentlig
2) Nøglen skal være privat

Hth

Så vidt jeg ved har borland builder en udmærket hjælpfunktion, så hvis du prøver at trykke F1 og se om du kan finde noget

Jeg havde denne til at ligge på lageret:

#include <iostream>
#include <string>


std::string Crypt(const std::string& aIn)
{
   static const char Arr1[] = "klmnopqrstuvwxyzabcdefghij";
   static const char Arr2[] = "KLMNOPQRSTUVWXYZABCDEFGHIJ";
   std::string::size_type idx;
   std::string Out;
   for(idx = 0; idx < aIn.size(); idx++)
   {
      int ii = aIn[idx] - 'a';
      int jj = aIn[idx] - 'A';
      if(aIn[idx] >= 'a' && aIn[idx] <= 'z')
         Out += Arr1[ii];
      else if(aIn[idx] >= 'A' && aIn[idx] <= 'Z')
         Out += Arr2[jj];
      else
         Out += aIn[idx];
   }
   return Out;
}

std::string Decrypt(const std::string& aIn)
{
   static const char Arr1[] = "qrstuvwxyzabcdefghijklmnop";
   static const char Arr2[] = "QRSTUVWXYZABCDEFGHIJKLMNOP";
   std::string::size_type idx;
   std::string Out;
   for(idx = 0; idx < aIn.size(); idx++)
   {
      int ii = aIn[idx] - 'a';
      int jj = aIn[idx] - 'A';
      if(aIn[idx] >= 'a' && aIn[idx] <= 'z')
         Out += Arr1[ii];
      else if(aIn[idx] >= 'A' && aIn[idx] <= 'Z')
         Out += Arr2[jj];
      else
         Out += aIn[idx];
   }
   return Out;
}

int main()
{
   std::string Line;
   std::cout << "Skriv noget: ";
   std::cout.flush();
   std::getline(std::cin, Line);
   std::string Crypted = Crypt(Line);
   std::cout << "Krypteret: " << Crypted << std::endl;
   std::string Decrypted = Decrypt(Crypted);
   std::cout << "Dekrypteret: " << Decrypted << std::endl;
}

Jeg har vist postet den før.

Når man skal kryptere skal man IKKE begynde at lave sin egen krypteringsalgoritme! Det er langt fra sikkert og det tager oftest ikke lang tid at bryde krypteringen da ens egen algoritme oftest indeholder mange huller idet den ikke har været igennem reviews.

Der findes flere muligheder for kryptering. Man kan fx vælge at bruge openssl (som kan porteres til andre platforme) eller man kan bruge Windows Crypto API. Skal applikationen kun kunne køres på en Windows platform, så vil jeg anbefale at du anvender Windows Crypto API (CAPI). Du kan se et eksempel på hvordan du anvender det på nedenstående url.

http://www.codeproject.com/cpp/EncryptionCryptoAPI.asp


Hth

Så sikkert behøver det nu ikke at være. Det var bare så ordet ikke stod direkte i Reg. basen.
Jeg havde egentlig bare tænkt på at lave det om til en hex-værdi men jeg synes ikke jeg kan finde nogen StrToHex-agtig funktion i Borland? Eller i den indbygede writexxxtoreg funktion i Borland. Der er kun writeinttoreg og writestringtoreg, ingen hextoreg.
Nogen idéer?

Måske:

#include <iostream>
#include <iomanip>
#include <string>
#include <stdlib.h>
#include <sstream>

std::string ToHex(const std::string& aIn)
{
   std::stringstream Out;
   std::string::size_type idx;
   for(idx = 0; idx < aIn.size(); idx++)
      Out << std::hex << std::setw(2) << std::setfill(' ') << int(aIn[idx]);

   return Out.str();
}

std::string FromHex(const std::string& aIn)
{
   std::string Out;
   std::string Temp = aIn;
   while(!Temp.empty())
   {
      Out += (char )strtol(Temp.substr(0, 2).c_str(), 0, 16);
      Temp = Temp.substr(2);
   }
   return Out;
}

int main()
{
   std::string Line;
   std::cout << "Skriv noget: ";
   std::cout.flush();
   std::getline(std::cin, Line);
   std::string Crypted = ToHex(Line);
   std::cout << "Krypteret: " << Crypted << std::endl;
   std::string Decrypted = FromHex(Crypted);
   std::cout << "Dekrypteret: " << Decrypted << std::endl;
}

En anden måde at kryptere på er også at anvende RC4 som er en stream cipher kryptering. Denne er dog naturligvis ikke så stærk, men til gengæld noget hurtigere.


http://www.codeproject.com/cpp/RC4CPP_DK.asp


Hth

Du samler heller ikke på point her Bertel? Bruger din Hex-funktioner, de er alt rigelige....
Tak for hjælpen også til dig Jess.
Godt Nytår når I når dertil.