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 unsigned char temp;
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 temp = sb1 [i];
00050 sb1 [i] = sb1 [j];
00051 sb1 [j] = temp;
00052
00053
00054
00055
00056 }
00057 return p;
00058 }
00059
00060 DKC_INLINE unsigned char WINAPI dkcArcfourByte(DKC_ARCFOUR_STATE *p){
00061 unsigned char i,j,temp;
00062 unsigned char *sb1 = p->msbox;
00063
00064
00065 i = (unsigned char )(p->mi+1);
00066 j = (unsigned char )(p->mj + sb1[i]);
00067
00068
00069 temp = sb1 [i];
00070 sb1 [i] = sb1 [j];
00071 sb1 [j] = temp;
00072
00073
00074
00075 p->mi = i;
00076 p->mj = j;
00077
00078 i = (unsigned char )(sb1 [i] + sb1 [j]);
00079 j = (unsigned char )sb1[i];
00080 return j;
00081 }
00082
00083 static DKC_INLINE void dkcArcfourEncrypt_Base(DKC_ARCFOUR_STATE *p,
00084 unsigned char *dest,unsigned const char *src,size_t srcsize)
00085 {
00086
00087 size_t cc;
00088 unsigned char i,j;
00089 unsigned char *sb1 = p->msbox;
00090 unsigned char temp;
00091
00092
00093 i = (unsigned char )(p->mi);
00094 j = (unsigned char )(p->mj);
00095
00096 for(cc = 0;cc < srcsize;cc++){
00097
00098 i = (unsigned char )(i+1);
00099 j = (unsigned char )(j + sb1[i]);
00100
00101
00102
00103 temp = sb1 [i];
00104 sb1 [i] = sb1 [j];
00105 sb1 [j] = temp;
00106
00107
00108
00109
00110
00111 dest[cc] = (unsigned char )
00112 (src[cc] ^ (unsigned char )sb1[
00113 (unsigned char )(sb1 [i] + sb1 [j])
00114 ]
00115 );
00116 }
00117
00118 p->mi = i;
00119 p->mj = j;
00120
00121 }
00122
00123 int WINAPI dkcArcfourEncrypt(DKC_ARCFOUR_STATE *p,
00124 unsigned char *dest,size_t destsize,
00125 const unsigned char *src,size_t srcsize)
00126 {
00127
00128 if(destsize < srcsize){
00129 return edk_BufferOverFlow;
00130 }
00131 dkcArcfourEncrypt_Base(p,dest,src,srcsize);
00132
00133
00134
00135
00136
00137 return edk_SUCCEEDED;
00138 }
00139
00140
00141
00142 void WINAPI dkcArcfourEncryptNoDest(DKC_ARCFOUR_STATE *p,
00143 unsigned char *dest_and_src,size_t dest_and_srcsize)
00144 {
00145 dkcArcfourEncrypt_Base(p,dest_and_src,dest_and_src,dest_and_srcsize);
00146 }
00147
00148 int WINAPI dkcFreeArcfour(DKC_ARCFOUR_STATE **p){
00149 if(NULL==p){
00150 return edk_FAILED;
00151 }
00152 return dkcFree((void **)p);
00153 }
00154
00155
00156
00157
00158
00159
00160 DKC_ARCFOUR2BYTE_STATE *WINAPI dkcAllocArcfour2Byte(
00161 const unsigned char *key,size_t keylen)
00162 {
00163
00164 int i,j;
00165 unsigned short temp;
00166 unsigned short *sb1,sb2[USHRT_MAX];
00167 DKC_ARCFOUR2BYTE_STATE *p;
00168 if(NULL==key || 0==keylen){
00169 return NULL;
00170 }
00171
00172 memset(sb2,0,sizeof(sb2));
00173
00174 p = (DKC_ARCFOUR2BYTE_STATE *)dkcAllocate(sizeof(DKC_ARCFOUR2BYTE_STATE));
00175 if(NULL==p){
00176 return NULL;
00177 }
00178 sb1 = p->msbox;
00179
00180
00181 for(i=0;i<USHRT_MAX;i++){
00182 sb1[i] = (unsigned short)i;
00183
00184
00185 }
00186 j=i=0;
00187
00188 for(;j<USHRT_MAX;j++){
00189 sb2[j] = key [j % keylen];
00190 }
00191
00192
00193 for(i=0;i<USHRT_MAX;i++){
00194
00195 j = (j + sb1[i] + sb2[i]) & 0xff;
00196 temp = sb1 [i];
00197 sb1 [i] = sb1 [j];
00198 sb1 [j] = temp;
00199
00200
00201
00202
00203 }
00204 return p;
00205 }
00206
00207 DKC_INLINE unsigned short WINAPI dkcArcfour2ByteProcess(DKC_ARCFOUR2BYTE_STATE *p){
00208 unsigned short i,j,temp;
00209 unsigned short *sb1 = p->msbox;
00210
00211
00212 i = (unsigned short )(p->mi+1);
00213 j = (unsigned short )(p->mj + sb1[i]);
00214
00215
00216 temp = sb1 [i];
00217 sb1 [i] = sb1 [j];
00218 sb1 [j] = temp;
00219
00220
00221
00222 p->mi = i;
00223 p->mj = j;
00224
00225 i = (unsigned short )(sb1 [i] + sb1 [j]);
00226 j = (unsigned short )sb1[i];
00227 return j;
00228 }
00229
00233 static DKC_INLINE void dkcArcfour2ByteEncrypt_Base(DKC_ARCFOUR2BYTE_STATE *p,
00234 unsigned short *dest,unsigned const short *src,size_t srcsize)
00235 {
00236
00237 size_t cc;
00238 unsigned short i,j;
00239 unsigned short *sb1 = p->msbox;
00240 unsigned short temp;
00241
00242
00243 i = (unsigned short )(p->mi);
00244 j = (unsigned short )(p->mj);
00245
00246 for(cc = 0;cc < srcsize;cc++){
00247
00248 i = (unsigned short )(i+1);
00249 j = (unsigned short )(j + sb1[i]);
00250
00251
00252
00253 temp = sb1 [i];
00254 sb1 [i] = sb1 [j];
00255 sb1 [j] = temp;
00256
00257
00258
00259
00260
00261 dest[cc] = (unsigned short )
00262 (src[cc] ^ (unsigned short )sb1[
00263 (unsigned short )(sb1 [i] + sb1 [j])
00264 ]
00265 );
00266 }
00267
00268 p->mi = i;
00269 p->mj = j;
00270
00271 }
00272
00273 int WINAPI dkcArcfour2ByteEncrypt(DKC_ARCFOUR2BYTE_STATE *p,
00274 unsigned char *dest,size_t destsize,
00275 const unsigned char *src,size_t srcsize)
00276 {
00277
00278 if(destsize < srcsize){
00279 return edk_BufferOverFlow;
00280 }
00281 if(srcsize % 2 != 0){
00282 return edk_ArgumentException;
00283 }
00284
00285 dkcArcfour2ByteEncrypt_Base(p,
00286 (unsigned short *)dest,(unsigned short *)src,
00287 srcsize / 2
00288 );
00289
00290
00291
00292
00293
00294 return edk_SUCCEEDED;
00295 }
00296
00297
00298
00299 int WINAPI dkcArcfour2ByteEncryptNoDest(DKC_ARCFOUR2BYTE_STATE *p,
00300 unsigned char *dest_and_src,size_t dest_and_srcsize)
00301 {
00302 if(dest_and_srcsize % 2 != 0){
00303 return edk_ArgumentException;
00304 }
00305 dkcArcfour2ByteEncrypt_Base(p,
00306 (unsigned short *)dest_and_src,(unsigned short *)dest_and_src,
00307 dest_and_srcsize / 2
00308 );
00309 return edk_SUCCEEDED;
00310 }
00311
00312 int WINAPI dkcFreeArcfour2Byte(DKC_ARCFOUR2BYTE_STATE **p){
00313 if(NULL==p){
00314 return edk_FAILED;
00315 }
00316 return dkcFree((void **)p);
00317 }
00318
00319
00320
00321