Здравствуйте, Srgteam, Вы писали:
S>Люди добрые выручите пожалуйста, у кого есть реализация этого алгоритма на С++, желательно с функциями открытия файла, разбивки его по блокам ну и т. д...
S>Можно на Билдере, или Вижаке...
S>заранее, очень очень благодарен
//////////////////////////////////////////////////////////////////////////
// RSA RC6 symmetric cipher. RC6-32/20/x
// Block size: 128 bits = 4 DWORDs
// Key sizes: 32*x bits = x DWORDs, x > 0
class RC6
{
public:
RC6(bool isCBCmode = true) {Init(isCBCmode);}
RC6(const RC6 &other) {InitFrom(other);}
~RC6();
bool isCBC () {return m_isCBCmode;}
void Init (bool isCBCmode);
void InitFrom (const RC6 &other);
// Bits: 32*x
bool SetKey (const void *key, DWORD nBits);
// Block = 16 bytes
void EncryptBlock (const void *_input, void *_output);
void DecryptBlock (const void *_input, void *_output);
private:
DWORD m_CBC[4]; // previous round results for cipher block chaining
bool m_isCBCmode;
DWORD m_sTable[44];
};
#define RC6_MAGIC_INIT (0xb7e15163)
#define RC6_MAGIC_INCR (0x9e3779b9)
void RC6::InitFrom (const RC6 &other)
{
memcpy (m_CBC, other.m_CBC, sizeof(m_CBC));
m_isCBCmode = other.m_isCBCmode;
memcpy (m_sTable,other.m_sTable,sizeof(m_sTable));
}
void RC6::Init (bool isCBCmode)
{
m_isCBCmode = isCBCmode;
memset(m_sTable,0,sizeof (m_sTable));
memset(m_CBC,0,sizeof (m_CBC));
}
RC6::~RC6()
{
memset(m_CBC,0,sizeof (m_CBC));
memset(m_sTable,0,sizeof (m_sTable));
}
bool RC6::SetKey (const void *key, DWORD keySize)
{
if ((!keySize) || (keySize & 31))
return false;
keySize >>= 5;
memset(m_CBC,0,sizeof (m_CBC));
// Fill sTable with initial value
m_sTable[0] = RC6_MAGIC_INIT;
for(int i = 0; i < 43; i++)
m_sTable[i+1] = m_sTable[i] + RC6_MAGIC_INCR;
DWORD A,B, mixRounds;
// Create key copy, 'cause we will change it
DWORD *keyCopy = new DWORD[keySize];
memcpy(keyCopy,key,keySize*sizeof (DWORD));
A = B = 0;
mixRounds = 3 * max (44, keySize);
// Mixin' key with sTable
for (i = 0; i != mixRounds; i++)
{
int org = i % 44;
A = m_sTable[org] = _rotl(m_sTable[org] + A + B, 3);
org = i % keySize;
B = keyCopy[org] = _rotl(keyCopy[org] + A + B, A+B);
}
// Cleanup
memset(keyCopy,0,keySize*sizeof (DWORD));
delete [] keyCopy;
return true;
}
void RC6::EncryptBlock(const void *_input, void *_output)
{
DWORD A,B,C,D,T,U;
const DWORD *input = (const DWORD *)_input;
DWORD *output = (DWORD *)_output;
A = input[0];
B = input[1];
C = input[2];
D = input[3];
if (m_isCBCmode)
{
A ^= m_CBC[0];
B ^= m_CBC[1];
C ^= m_CBC[2];
D ^= m_CBC[3];
}
B += m_sTable[0];
D += m_sTable[1];
#define RC6_ENCODE(a,b,c,d,rnd) \
T = _rotl (b * (2*b + 1), 5); \
U = _rotl (d * (2*d + 1), 5); \
a = _rotl (a ^ T, U) + m_sTable[(rnd+1)*2]; \
c = _rotl (c ^ U, T) + m_sTable[(rnd+1)*2+1]; \
RC6_ENCODE(A,B,C,D,0)
RC6_ENCODE(B,C,D,A,1)
RC6_ENCODE(C,D,A,B,2)
RC6_ENCODE(D,A,B,C,3)
RC6_ENCODE(A,B,C,D,4)
RC6_ENCODE(B,C,D,A,5)
RC6_ENCODE(C,D,A,B,6)
RC6_ENCODE(D,A,B,C,7)
RC6_ENCODE(A,B,C,D,8)
RC6_ENCODE(B,C,D,A,9)
RC6_ENCODE(C,D,A,B,10)
RC6_ENCODE(D,A,B,C,11)
RC6_ENCODE(A,B,C,D,12)
RC6_ENCODE(B,C,D,A,13)
RC6_ENCODE(C,D,A,B,14)
RC6_ENCODE(D,A,B,C,15)
RC6_ENCODE(A,B,C,D,16)
RC6_ENCODE(B,C,D,A,17)
RC6_ENCODE(C,D,A,B,18)
RC6_ENCODE(D,A,B,C,19)
A += m_sTable[42];
C += m_sTable[43];
output[0] = A;
output[1] = B;
output[2] = C;
output[3] = D;
if (m_isCBCmode)
memcpy (m_CBC,output,sizeof (m_CBC));
}
void RC6::DecryptBlock (const void *_input, void *_output)
{
DWORD A,B,C,D,T,U;
const DWORD *input = (const DWORD *)_input;
DWORD *output = (DWORD *)_output;
DWORD backCBC[4];
A = input[0];
B = input[1];
C = input[2];
D = input[3];
if (m_isCBCmode)
memcpy (backCBC,_input,sizeof (backCBC));
C -= m_sTable[43];
A -= m_sTable[42];
#define RC6_DECODE(a,b,c,d,rnd) \
U = _rotl (d * (2*d + 1), 5); \
T = _rotl (b * (2*b + 1), 5); \
c = _rotr (c - m_sTable[(rnd+1)*2+1], T) ^ U; \
a = _rotr (a - m_sTable[(rnd+1)*2], U) ^ T;
RC6_DECODE(D,A,B,C,19)
RC6_DECODE(C,D,A,B,18)
RC6_DECODE(B,C,D,A,17)
RC6_DECODE(A,B,C,D,16)
RC6_DECODE(D,A,B,C,15)
RC6_DECODE(C,D,A,B,14)
RC6_DECODE(B,C,D,A,13)
RC6_DECODE(A,B,C,D,12)
RC6_DECODE(D,A,B,C,11)
RC6_DECODE(C,D,A,B,10)
RC6_DECODE(B,C,D,A,9)
RC6_DECODE(A,B,C,D,8)
RC6_DECODE(D,A,B,C,7)
RC6_DECODE(C,D,A,B,6)
RC6_DECODE(B,C,D,A,5)
RC6_DECODE(A,B,C,D,4)
RC6_DECODE(D,A,B,C,3)
RC6_DECODE(C,D,A,B,2)
RC6_DECODE(B,C,D,A,1)
RC6_DECODE(A,B,C,D,0)
D -= m_sTable[1];
B -= m_sTable[0];
if (m_isCBCmode)
{
A ^= m_CBC[0];
B ^= m_CBC[1];
C ^= m_CBC[2];
D ^= m_CBC[3];
memcpy(m_CBC,backCBC,sizeof (backCBC));
}
output[0] = A;
output[1] = B;
output[2] = C;
output[3] = D;
}
... << RSDN@Home 1.1.4 stable SR1 rev. 568>>
Забанили по IP, значит пора закрыть эту страницу.
Всем пока
