00001
00007 #define DKUTIL_C_ARCFOUR_C
00008 #include "dkcArcfour.h"
00009 #include "dkcStdio.h"
00010
00011
00012
00013 DKC_ARCFOUR_STATE *WINAPI dkcAllocArcfour(
00014 const unsigned char *key,size_t keylen)
00015 {
00016
00017 int i,j;
00018
00019 unsigned char *sb1,sb2[256];
00020 DKC_ARCFOUR_STATE *p;
00021 if(NULL==key || 0==keylen){
00022 return NULL;
00023 }
00024
00025 memset(sb2,0,sizeof(sb2));
00026
00027 p = (DKC_ARCFOUR_STATE *)dkcAllocate(sizeof(DKC_ARCFOUR_STATE));
00028 if(NULL==p){
00029 return NULL;
00030 }
00031 sb1 = p->msbox;
00032
00033
00034 for(i=0;i<256;i++){
00035 sb1[i] = (unsigned char)i;
00036
00037
00038 }
00039 j=i=0;
00040
00041 for(;j<256;j++){
00042 sb2[j] = key [j % keylen];
00043 }
00044
00045
00046 for(i=0;i<256;i++){
00047
00048 j = (j + sb1[i] + sb2[i]) & 0xff;
00049
00050
00051
00052 SWAP_TEMP(register uint8, sb1 [i],sb1 [j]);
00053
00054
00055
00056
00057
00058
00059
00060 }
00061 return p;
00062 }
00063
00064 DKC_INLINE unsigned char WINAPI dkcArcfourProcess(DKC_ARCFOUR_STATE *p){
00065
00066 unsigned char i,j;
00067 unsigned char *sb1 = p->msbox;
00068
00069
00070 i = (unsigned char )(p->mi+1);
00071 j = (unsigned char )(p->mj + sb1[i]);
00072
00073
00074 SWAP_FAST8( sb1 [i],sb1 [j]);
00075
00076
00077
00078
00079
00080
00081 p->mi = i;
00082 p->mj = j;
00083
00084 i = (unsigned char )(sb1 [i] + sb1 [j]);
00085 j = (unsigned char )sb1[i];
00086 return j;
00087 }
00088
00089 static DKC_INLINE void dkcArcfourEncrypt_Base(DKC_ARCFOUR_STATE *p,
00090 unsigned char *dest,unsigned const char *src,size_t srcsize)
00091 {
00092
00093 size_t cc;
00094 unsigned char i,j;
00095 unsigned char *sb1 = p->msbox;
00096
00097
00098
00099 i = (unsigned char )(p->mi);
00100 j = (unsigned char )(p->mj);
00101
00102 for(cc = 0;cc < srcsize;cc++){
00103
00104 i = (unsigned char )(i+1);
00105 j = (unsigned char )(j + sb1[i]);
00106
00107
00108
00109 SWAP_FAST8(sb1 [i],sb1 [j]);
00110
00111
00112
00113
00114
00115
00116
00117
00118 dest[cc] = (unsigned char )
00119 (src[cc] ^ (unsigned char )sb1[
00120 (unsigned char )(sb1 [i] + sb1 [j])
00121 ]
00122 );
00123 }
00124
00125 p->mi = i;
00126 p->mj = j;
00127
00128 }
00129
00130 int WINAPI dkcArcfourEncrypt(DKC_ARCFOUR_STATE *p,
00131 unsigned char *dest,size_t destsize,
00132 const unsigned char *src,size_t srcsize)
00133 {
00134
00135 if(destsize < srcsize){
00136 return edk_BufferOverFlow;
00137 }
00138 dkcArcfourEncrypt_Base(p,dest,src,srcsize);
00139
00140
00141
00142
00143
00144 return edk_SUCCEEDED;
00145 }
00146
00147
00148
00149 void WINAPI dkcArcfourEncryptNoDest(DKC_ARCFOUR_STATE *p,
00150 unsigned char *dest_and_src,size_t dest_and_srcsize)
00151 {
00152 dkcArcfourEncrypt_Base(p,dest_and_src,dest_and_src,dest_and_srcsize);
00153 }
00154
00155 int WINAPI dkcFreeArcfour(DKC_ARCFOUR_STATE **p){
00156 if(NULL==p){
00157 return edk_FAILED;
00158 }
00159 return dkcFree((void **)p);
00160 }
00161
00162
00163
00164
00165
00166
00167 DKC_ARCFOUR2BYTE_STATE *WINAPI dkcAllocArcfour2Byte(
00168 const unsigned char *key,size_t keylen)
00169 {
00170
00171 int i,j;
00172
00173 unsigned short *sb1,sb2[USHRT_MAX];
00174 DKC_ARCFOUR2BYTE_STATE *p;
00175 if(NULL==key || 0==keylen){
00176 return NULL;
00177 }
00178
00179 memset(sb2,0,sizeof(sb2));
00180
00181 p = (DKC_ARCFOUR2BYTE_STATE *)dkcAllocate(sizeof(DKC_ARCFOUR2BYTE_STATE));
00182 if(NULL==p){
00183 return NULL;
00184 }
00185 sb1 = p->msbox;
00186
00187
00188 for(i=0;i<USHRT_MAX;i++){
00189 sb1[i] = (unsigned short)i;
00190
00191
00192 }
00193 j=i=0;
00194
00195 for(;j<USHRT_MAX;j++){
00196 sb2[j] = key [j % keylen];
00197 }
00198
00199
00200 for(i=0;i<USHRT_MAX;i++){
00201
00202 j = (j + sb1[i] + sb2[i]) & 0xff;
00203
00204 SWAP_TEMP(register uint16,sb1 [i],sb1 [j]);
00205
00206
00207
00208
00209
00210
00211
00212 }
00213 return p;
00214 }
00215
00216 DKC_INLINE unsigned short WINAPI dkcArcfour2ByteProcess(DKC_ARCFOUR2BYTE_STATE *p){
00217
00218 unsigned short i,j;
00219 unsigned short *sb1 = p->msbox;
00220
00221
00222 i = (unsigned short )(p->mi+1);
00223 j = (unsigned short )(p->mj + sb1[i]);
00224
00225
00226 SWAP_FAST16(sb1[i],sb1[j]);
00227
00228
00229
00230
00231
00232
00233
00234 p->mi = i;
00235 p->mj = j;
00236
00237 i = (unsigned short )(sb1 [i] + sb1 [j]);
00238 j = (unsigned short )sb1[i];
00239 return j;
00240 }
00241
00245 static DKC_INLINE void dkcArcfour2ByteEncrypt_Base(DKC_ARCFOUR2BYTE_STATE *p,
00246 unsigned short *dest,unsigned const short *src,size_t srcsize)
00247 {
00248
00249 size_t cc;
00250 unsigned short i,j;
00251 unsigned short *sb1 = p->msbox;
00252
00253
00254
00255 i = (unsigned short )(p->mi);
00256 j = (unsigned short )(p->mj);
00257
00258 for(cc = 0;cc < srcsize;cc++){
00259
00260 i = (unsigned short )(i+1);
00261 j = (unsigned short )(j + sb1[i]);
00262
00263
00264 SWAP_FAST16(sb1[i],sb1[j]);
00265
00266
00267
00268
00269
00270
00271
00272
00273 dest[cc] = (unsigned short )
00274 (src[cc] ^ (unsigned short )sb1[
00275 (unsigned short )(sb1 [i] + sb1 [j])
00276 ]
00277 );
00278 }
00279
00280 p->mi = i;
00281 p->mj = j;
00282
00283 }
00284
00285 int WINAPI dkcArcfour2ByteEncrypt(DKC_ARCFOUR2BYTE_STATE *p,
00286 unsigned char *dest,size_t destsize,
00287 const unsigned char *src,size_t srcsize)
00288 {
00289
00290 if(destsize < srcsize){
00291 return edk_BufferOverFlow;
00292 }
00293 if(srcsize % 2 != 0){
00294 return edk_ArgumentException;
00295 }
00296
00297 dkcArcfour2ByteEncrypt_Base(p,
00298 (unsigned short *)dest,(unsigned short *)src,
00299 srcsize / 2
00300 );
00301
00302
00303
00304
00305
00306 return edk_SUCCEEDED;
00307 }
00308
00309
00310
00311 int WINAPI dkcArcfour2ByteEncryptNoDest(DKC_ARCFOUR2BYTE_STATE *p,
00312 unsigned char *dest_and_src,size_t dest_and_srcsize)
00313 {
00314 if(dest_and_srcsize % 2 != 0){
00315 return edk_ArgumentException;
00316 }
00317 dkcArcfour2ByteEncrypt_Base(p,
00318 (unsigned short *)dest_and_src,(unsigned short *)dest_and_src,
00319 dest_and_srcsize / 2
00320 );
00321 return edk_SUCCEEDED;
00322 }
00323
00324 int WINAPI dkcFreeArcfour2Byte(DKC_ARCFOUR2BYTE_STATE **p){
00325 if(NULL==p){
00326 return edk_FAILED;
00327 }
00328 return dkcFree((void **)p);
00329 }
00330
00331
00332
00333