1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
/*
dbx_tree: tree database driver for Miranda IM
Copyright 2007-2008 Michael "Protogenes" Kunz,
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "ARC4.h"
#include <string.h>
const wchar_t * ARC4::Name()
{
return cName;
}
const wchar_t * ARC4::Description()
{
return cDescription;
}
const uint32_t ARC4::BlockSizeBytes()
{
return cBlockSizeBytes;
}
const bool ARC4::IsStreamCipher()
{
return cIsStreamCipher;
}
ARC4::ARC4()
{
}
ARC4::~ARC4()
{
}
CCipher::TCipherInterface* ARC4::Create()
{
return (new ARC4())->m_Interface;
}
void ARC4::SetKey(void* Key, uint32_t KeyLength)
{
uint8_t swapbyte;
uint8_t index1;
uint8_t index2;
unsigned int i;
uint8_t * k = (uint8_t *) Key;
for (i = 0; i < 256; ++i)
State[i] = i;
x = 0;
y = 0;
index1 = 0;
index2 = 0;
for (i = 0; i < 256; ++i)
{
index2 = (k[index1] + State[i] + index2) & 0xff;
swapbyte = State[i];
State[i] = State[index2];
State[index2] = swapbyte;
index1 = (index1 + 1) % KeyLength;
}
for (i = 0; i < 3742; ++i)
Stream();
Backx = x;
Backy = y;
memcpy(BackState, State, sizeof(State));
}
inline uint8_t ARC4::Stream()
{
uint8_t swapbyte;
x = (x + 1) & 0xff;
y = (State[x] + y) & 0xff;
swapbyte = State[x];
State[x] = State[y];
State[y] = swapbyte;
return State[ (State[x] + State[y]) & 0xff ];
}
void ARC4::Encrypt(void* Data, uint32_t Size, uint32_t Nonce, uint32_t StartByte)
{
uint8_t * dat = (uint8_t *) Data;
x = Backx;
y = Backy;
memcpy(State, BackState, sizeof(State));
for (unsigned int i = (Nonce + (Nonce >> 8) + (Nonce >> 16) + (Nonce >> 24)) & 0x1ff; i > 0; --i)
Stream();
while (Size > 0)
{
(*dat) = (*dat) ^ Stream();
--Size;
++dat;
}
}
void ARC4::Decrypt(void* Data, uint32_t Size, uint32_t Nonce, uint32_t StartByte)
{
Encrypt(Data, Size, Nonce, StartByte);
}
extern "C" __declspec(dllexport) const TCipherInfo* CipherInfo(void * Reserved)
{
return &ARC4::cCipherInfo;
}
|
