00001
00008 #define DKUTIL_C_TELECOM_CONFIRM_PACKET_C
00009 #include "dkcTelecomConfirmPacket.h"
00010
00011 #if 0
00012
00013 #include "dkcMath.h"
00014 #include "dkcLZW.h"
00015
00016 static DKC_INLINE ULONG all_add(uint8 *a,size_t size){
00017 size_t i=0;
00018 ULONG t=0;
00019 for(;i<size;i++){
00020 t += a[i];
00021 }
00022 return t;
00023 }
00024
00025
00026 DKC_TELECOM_CONFIRM_PACKET* WINAPI dkcAllocTelecomConfirmPacketAuto(const void *key,size_t keysize)
00027 {
00028 return dkcAllocTelecomConfirmPacket(dkcdTELECOM_CONFIRM_PACKET_DEFAULT_PAUSE_SIZE,
00029 key,keysize,
00030 edk_SNOW2_SIGNATURE,
00031 FALSE
00032 );
00033
00034 }
00035
00036
00037
00038
00039
00040 DKC_EXTERN DKC_TELECOM_CONFIRM_PACKET* WINAPI dkcAllocTelecomConfirmPacket(size_t pause_size,const void *key,size_t keysize,UINT flag,BOOL isNaturalKey)
00041 {
00042 DKC_TELECOM_CONFIRM_PACKET* p = dkcAllocate(sizeof(DKC_TELECOM_CONFIRM_PACKET));
00043 int r;
00044 if(NULL==p) return NULL;
00045
00046 p->pause_size = pause_size;
00047
00048
00049 p->flag = flag;
00050 p->psig = dkcAllocSHA512();
00051 if(NULL==p->psig) goto Error;
00052
00053
00054 dkcSHA512Init(p->psig);
00055 dkcSHA512Load(p->psig,key,keysize);
00056
00057 r = dkcSHA512FinalDigest(p->psig,p->key512,sizeof(p->key512));
00058 if(DKUTIL_FAILED(r)) goto Error;
00059
00060 if(edk_ARCFOUR_SIGNATURE & flag){
00061
00062 if(isNaturalKey){
00063 p->crypt_obj = dkcAllocArcfour(key,keysize);
00064 }else{
00065 p->crypt_obj = dkcAllocArcfour(p->key512,sizeof(p->key512));
00066 }
00067 }else if(edk_HC256_SIGNATURE & flag){
00068
00069 if(isNaturalKey){
00070 p->crypt_obj = dkcAllocHC256NoLimitKeyLength(key,keysize);
00071 }else{
00072 p->crypt_obj = dkcAllocHC256NoLimitKeyLength(p->key512,sizeof(p->key512));
00073 }
00074 }else if(edk_SNOW20_SIGNATURE & flag){
00075 if(isNaturalKey){
00076 p->crypt_obj = dkcAllocSNOW2NoLimitKeyLength(key,keysize);
00077 }else{
00078 p->crypt_obj = dkcAllocSNOW2NoLimitKeyLength(p->key512,sizeof(p->key512));
00079 }
00080 }else if(edk_VERNAM_SIGNATURE & flag){
00081 dkcmNOT_ASSERT("NO IMPL");
00082 }
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093 dkcSrand(&(p->seed),all_add(p->key512,sizeof(p->key512)));
00094
00095
00096 p->isNaturalKey = (uint8)(isNaturalKey != 0);
00097 return p;
00098
00099 Error:
00100 dkcFreeSHA512(&(p->psig));
00101 dkcFree(&p);
00102 return NULL;
00103 }
00104
00105 int WINAPI dkcFreeTelecomConfirmPacket(DKC_TELECOM_CONFIRM_PACKET **p){
00106 if(edk_ARCFOUR_SIGNATURE & (*p)->flag){
00107 dkcFreeArcfour((DKC_ARCFOUR_STATE **)&((*p)->crypt_obj));
00108 }else if(edk_HC256_SIGNATURE & (*p)->flag){
00109 dkcFreeHC256((DKC_HC256**)&((*p)->crypt_obj));
00110 }else if(edk_SNOW20_SIGNATURE & (*p)->flag){
00111 dkcFreeSNOW2((DKC_SNOW2**)&((*p)->crypt_obj));
00112 }else if(edk_VERNAM_SIGNATURE & (*p)->flag){
00113 dkcmNOT_ASSERT("NO IMPL");
00114 }
00115
00116 dkcFreeSHA512(&((*p)->psig));
00117 return dkcFree(p);
00118 }
00119
00120
00122 static void copy_tcp_header(void *dest,DKC_TELECOM_CONFIRM_PACKET_HEADER *a){
00123 DKC_TELECOM_CONFIRM_PACKET_HEADER *p = dest;
00124 memcpy( p->sig,a->sig,sizeof(p->sig));
00125 if(dkcIsBigEndian()){
00126 p->length = dkcReverseEndian32(a->length);
00127 }else{
00128 p->length = a->length;
00129 }
00130 }
00131
00133 static void copy_lzw_header(void *dest,const DKC_LZW_HEADER *a){
00134 DKC_LZW_HEADER *p = dest;
00135
00136 if(dkcIsBigEndian()){
00137 p->mSignature = dkcReverseEndian32(a->mSignature);
00138 p->mOriginSize = dkcReverseEndian32(a->mOriginSize);
00139 p->mCompressedSize = dkcReverseEndian32(a->mCompressedSize);
00140 p->option = dkcReverseEndian32(a->option);
00141 }else{
00142 memcpy(p,a,sizeof(*p));
00143 }
00144 }
00145
00146 static DKC_INLINE int tcp_encode_pause(DKC_TELECOM_CONFIRM_PACKET *p,
00147 uint8 *dest,size_t destsize,const uint8 *src,size_t srcsize)
00148 {
00149 int r;
00150 DKC_TELECOM_CONFIRM_PACKET_HEADER header;
00151 DKC_LZW_HEADER hlzw;
00152
00153 size_t tt = sizeof(header) + sizeof(hlzw);
00154
00155
00156 if(dkcdTELECOM_CONFIRM_PACKET_MAX_LENGTH < srcsize + tt){
00157 return edk_ArgumentException;
00158 }
00159 if(destsize < tt){
00160 return edk_BufferOverFlow;
00161 }
00162
00163
00164
00165
00166 header.length = srcsize & dkcdTELECOM_CONFIRM_PACKET_MAX_LENGTH;
00167
00168 header.length |= (p->isNaturalKey) ? (1<<31) : 0;
00169
00170
00171 dkcSHA512Init(p->psig);
00172 dkcSHA512Load(p->psig,src,srcsize);
00173 r = dkcSHA512FinalDigest(p->psig,header.sig,sizeof(header.sig));
00174 if(DKUTIL_FAILED(r)) return r;
00175
00176 copy_tcp_header(dest,&header);
00177
00178
00179
00180 {
00181 DKC_LZW *plzw;
00182
00183 uint8 *dest_t;
00184 size_t dest_size_t;
00185
00186
00187
00188
00189 dest_t = dest + tt;
00190 dest_size_t = destsize - tt;
00191 plzw = dkcAllocLZW(p->pause_size);
00192 if(NULL==plzw){
00193 r = edk_FAILED;
00194 goto Error;
00195 }
00196
00197 r = dkcLZWEncode(plzw,&hlzw,dest_t,dest_size_t,src,srcsize,dest_size_t,
00198 dkcRand(&(p->seed)),
00199 edkcLZW_Default);
00200
00201 dkcFreeLZW(&plzw);
00202
00203 if(DKUTIL_FAILED(r)) goto Error;
00204
00205
00206 dest_t = dest + sizeof(header);
00207 copy_lzw_header(dest_t,&hlzw);
00208
00209
00210
00211 }
00212
00213
00214
00215 {
00216 uint8 *dest_t = dest + tt;
00217 size_t dest_size_t = hlzw.mCompressedSize ;
00218 if(edk_ARCFOUR_SIGNATURE & p->flag){
00219 dkcArcfourEncryptNoDest(p->crypt_obj,dest_t,dest_size_t);
00220 }else if(edk_HC256_SIGNATURE & p->flag){
00221 dkcHC256EncryptNoDestDOE(p->crypt_obj,dest_t,dest_size_t);
00222 }else if(edk_SNOW20_SIGNATURE & p->flag){
00223 dkcSNOW2EncryptNoDestDOE(p->crypt_obj,dest_t,dest_size_t);
00224 }else if(edk_VERNAM_SIGNATURE & p->flag){
00225 dkcmNOT_ASSERT("NO IMPL");
00226 }
00227
00228
00229 }
00230
00231 Error:
00232 return r;
00233 }
00234
00235 int WINAPI dkcTelecomConfirmPacketEncode(DKC_TELECOM_CONFIRM_PACKET *p,
00236 uint8 *dest,size_t destsize,const uint8 *src,size_t srcsize)
00237 {
00238 size_t count = srcsize / p->pause_size;
00239 size_t rest = srcsize % p->pause_size,i;
00240 int r;size_t offset = 0;
00241 for(i=0;i<count;i++){
00242 offset = count * p->pause_size;
00243 r = tcp_encode_pause(p,dest,destsize,src,srcsize);
00244 if(DKUTIL_FAILED(r)) return r;
00245 }
00246
00247 }
00248
00249 static DKC_INLINE void get_lzw_header(DKC_LZW_HEADER *p,const uint8 *src){
00250 DKC_LZW_HEADER *a = (DKC_LZW_HEADER *)((uint8 *)src + sizeof(DKC_LZW_HEADER));
00251 if(dkcIsBigEndian()){
00252 p->mSignature = dkcReverseEndian32(a->mSignature);
00253 p->mOriginSize = dkcReverseEndian32(a->mOriginSize);
00254 p->mCompressedSize = dkcReverseEndian32(a->mCompressedSize);
00255 p->option = dkcReverseEndian32(a->option);
00256 }else{
00257 memcpy(p,a,sizeof(*p));
00258 }
00259 }
00260 size_t WINAPI dkcGetOutputSize(const uint8 *src){
00261 DKC_LZW_HEADER h;
00262 get_lzw_header(&h,src);
00263 return h.mOriginSize;
00264 }
00265
00266
00267 int WINAPI dkcTelecomConfirmPacketDecode(DKC_TELECOM_CONFIRM_PACKET *p,uint8 *dest,size_t destsize,const uint8 *src,size_t srcsize)
00268 {
00269 int r;
00270 DKC_TELECOM_CONFIRM_PACKET_HEADER header;
00271 DKC_LZW_HEADER hlzw;
00272
00273 size_t tt = sizeof(header) + sizeof(hlzw);
00274
00275
00276 if(dkcdTELECOM_CONFIRM_PACKET_MAX_LENGTH < srcsize + tt){
00277 return edk_ArgumentException;
00278 }
00279
00280
00281
00282
00283
00284 copy_tcp_header((void *)&header,(DKC_TELECOM_CONFIRM_PACKET_HEADER *)src);
00285 get_lzw_header(&hlzw,src);
00286 if(hlzw.mOriginSize < destsize){
00287 return edk_BufferOverFlow;
00288 }
00289
00290
00291
00292 {
00293 DKC_LZW *plzw;
00294
00295 uint8 *src_t;
00296 size_t src_size_t;
00297
00298
00299
00300
00301
00302 src_t = (uint8 *)src + tt;
00303 src_size_t = srcsize - tt;
00304 plzw = dkcAllocLZW(p->pause_size );
00305 if(NULL==plzw){
00306 r = edk_FAILED;
00307 goto Error;
00308 }
00309
00310 r = dkcLZWDecode(plzw,&hlzw,dest,destsize,src_t,src_size_t,
00311 dkcRand(&(p->seed)));
00312
00313 dkcFreeLZW(&plzw);
00314
00315 if(DKUTIL_FAILED(r)) goto Error;
00316
00317
00318
00319 }
00320
00321
00322
00323 {
00324 uint8 *dest_t = dest;
00325 size_t dest_size_t = hlzw.mOriginSize ;
00326
00327 if(edk_ARCFOUR_SIGNATURE & p->flag){
00328 dkcArcfourEncryptNoDest(p->crypt_obj,dest_t,dest_size_t);
00329 }else if(edk_HC256_SIGNATURE & p->flag){
00330 dkcHC256EncryptNoDestDOE(p->crypt_obj,dest_t,dest_size_t);
00331 }else if(edk_SNOW20_SIGNATURE & p->flag){
00332 dkcSNOW2EncryptNoDestDOE(p->crypt_obj,dest_t,dest_size_t);
00333 }else if(edk_VERNAM_SIGNATURE & p->flag){
00334 dkcmNOT_ASSERT("NO IMPL");
00335 }
00336
00337
00338 }
00339
00340 Error:
00341 return r;
00342 }
00343 #endif //end of if 0