#include "dkcHC256.h"
#include <stdlib.h>
dkcHC256.cのインクルード依存関係図

マクロ定義 | |
| #define | rotr(x, n) (((x)>>(n))|((x)<<(32-(n)))) |
| #define | feedback_1(u, v, b, c) |
| #define | feedback_2(u, v, b, c) |
| #define | f1(x) (rotr((x),7) ^ rotr((x),18) ^ ((x) >> 3)) |
| #define | f2(x) (rotr((x),17) ^ rotr((x),19) ^ ((x) >> 10)) |
| #define | f(a, b, c, d) (f2((a)) + b + f1((c)) + d) |
関数 | |
| DKC_INLINE uint32 | h1 (uint32 *Q, uint32 x) |
| DKC_INLINE uint32 | h2 (uint32 *P, uint32 x) |
| DKC_INLINE uint32 | g1 (uint32 *Q, uint32 x, uint32 y) |
| DKC_INLINE uint32 | g2 (uint32 *P, uint32 x, uint32 y) |
| DKC_INLINE uint32 | fb1 (uint32 *Q, uint32 u, uint32 v, uint32 b, uint32 c) |
| DKC_INLINE uint32 | fb2 (uint32 *P, uint32 u, uint32 v, uint32 b, uint32 c) |
| DKC_INLINE void | fb1_ (uint32 *Q, uint32 *u, uint32 v, uint32 b, uint32 c) |
| DKC_INLINE void | fb2_ (uint32 *P, uint32 *u, uint32 v, uint32 b, uint32 c) |
| void | initialization (DKC_HC256 *p, uint32 key[], uint32 iv[]) |
| DKC_INLINE DKC_HC256 *WINAPI | dkcAllocHC256 (BYTE *key, size_t size) |
| DKC_INLINE int WINAPI | dkcFreeHC256 (DKC_HC256 **p) |
| DKC_INLINE uint32 | dkcHC256Process (DKC_HC256 *p, uint32 u) |
| DKC_INLINE void | step_A (DKC_HC256 *p, uint32 u, uint32 v, uint32 a, uint32 b, uint32 c, uint32 d, uint32 *m) |
| DKC_INLINE | step_B (DKC_HC256 *p, uint32 u, uint32 v, uint32 a, uint32 b, uint32 c, uint32 d, uint32 *m) |
| void | encrypt (DKC_HC256 *p, uint32 data[]) |
| DKC_INLINE int WINAPI | dkcHC256EncryptBlock512NoDestDOE (DKC_HC256 *p, BYTE *dest, size_t size) |
| DKC_INLINE int WINAPI | dkcHC256EncryptBlock512DOE (DKC_HC256 *p, BYTE *dest, size_t dsize, const BYTE *src, size_t ssize) |
//Stream cipher HC-256 was published at Fast Software Encryption 2004 //This optimized C code of stream cipher HC-256 is implemented by //Hongjun Wu in 2003. //This code runs at about 1.9 bit/cycle on the Intel Pentium 4 processor //with the Intel C++ 7.1 compiler.dkcHC256.c で定義されています。
マクロ定義
|
|
dkcHC256.c の 119 行で定義されています。 参照元 initialization(). |
|
|
dkcHC256.c の 117 行で定義されています。 |
|
|
dkcHC256.c の 118 行で定義されています。 |
|
|
値: { \
uint32 tem0,tem1,tem2; \
tem0 = rotr((v),23); \
tem1 = rotr((c),10); \
tem2 = ((v) ^ (c)) & 0x3ff; \
(u) += (b)+(tem0^tem1)+Q[tem2]; \
}
dkcHC256.c の 72 行で定義されています。 参照元 initialization(). |
|
|
値: { \
uint32 tem0,tem1,tem2; \
tem0 = rotr((v),23); \
tem1 = rotr((c),10); \
tem2 = ((v) ^ (c)) & 0x3ff; \
(u) += (b)+(tem0^tem1)+P[tem2]; \
}
dkcHC256.c の 80 行で定義されています。 参照元 initialization(). |
|
|
dkcHC256.c の 33 行で定義されています。 参照元 fb1(), fb1_(), fb2(), fb2_(), g1(), g2(), step_A(), と step_B(). |
|
||||||||||||
|
dkcHC256.c の 192 行で定義されています。 参照先 BYTE, DKC_HC256, dkcAllocate(), initialization(), と NULL.
00192 {
00193 DKC_HC256 *p;
00194 uint32 iv[8];
00195 if(size != sizeof(uint32) * 8){
00196 return NULL;
00197 }
00198
00199 p = dkcAllocate(sizeof(DKC_HC256));
00200 if(NULL==p){
00201 return NULL;
00202 }
00203 DKUTIL_MEMZERO(iv,sizeof(iv));
00204 initialization(p,(uint32 *)key,iv);
00205 return p;
00206 }
|
|
|
dkcHC256.c の 210 行で定義されています。
00210 {
00211 return dkcFree(p);
00212 }
|
|
||||||||||||||||||||||||
|
dkcHC256.c の 329 行で定義されています。 参照先 BYTE, DKC_HC256, dkcHC256EncryptBlock512NoDestDOE(), dkcmNOT_ASSERT, と NULL.
00330 {
00331 dkcmNOT_ASSERT(NULL==p || NULL==dest || NULL==src);
00332 if(ssize != 512 || dsize < 512){
00333 return edk_ArgumentException;
00334 }
00335 memcpy(dest,src,ssize);
00336 return dkcHC256EncryptBlock512NoDestDOE(p,dest,ssize);
00337 }
|
|
||||||||||||||||
|
dkcHC256.c の 320 行で定義されています。 参照先 BYTE, DKC_HC256, dkcmNOT_ASSERT, encrypt(), と NULL. 参照元 dkcHC256EncryptBlock512DOE().
00320 {
00321 dkcmNOT_ASSERT(NULL==p || NULL==dest);
00322 if(size != 512){
00323 return edk_ArgumentException;
00324 }
00325 encrypt(p,(uint32 *)dest);
00326 return edk_SUCCEEDED;
00327 }
|
|
||||||||||||
|
dkcHC256.c の 216 行で定義されています。 参照先 dkc_HC256::counter2048, DKC_HC256, g1(), g2(), h1(), h2(), dkc_HC256::P, と dkc_HC256::Q.
00217 {
00218 unsigned long i,i3, i10, i12, i1023;
00219 unsigned long output;
00220
00221 i = p->counter2048 & 0x3ff;
00222 i3 = (i - 3) & 0x3ff;
00223 i10 = (i - 10) & 0x3ff;
00224 i12 = (i - 12) & 0x3ff;
00225 i1023 = (i - 1023) & 0x3ff;
00226
00227 if (p->counter2048 < 1024) {
00228 p->P[i] = p->P[i] + p->P[i10] + g1(p->Q,p->P[i3],p->P[i1023]);
00229 output = h1(p->Q,p->P[i12]) ^ p->P[i];
00230 }
00231 else {
00232 p->Q[i] = p->Q[i] + p->Q[i10] + g2(p->P,p->Q[i3],p->Q[i1023]);
00233 output = h2(p->P,p->Q[i12]) ^ p->Q[i];
00234
00235 }
00236 p->counter2048 = (p->counter2048+1) & 0x7ff;
00237 return (output);
00238 }
|
|
||||||||||||
|
dkcHC256.c の 268 行で定義されています。 参照先 dkc_HC256::counter2048, DKC_HC256, dkc_HC256::P, dkc_HC256::Q, step_A(), step_B(), dkc_HC256::X, と dkc_HC256::Y. 参照元 dkcHC256EncryptBlock512NoDestDOE().
00269 {
00270 uint32 cc,dd,counter2048 = p->counter2048;
00271 uint32 *P = p->P,*Q = p->Q,*X =p->X, *Y = p->Y;
00272
00273 cc = counter2048 & 0x3ff;
00274 dd = (cc+16) & 0x3ff;
00275
00276 if (counter2048 < 1024)
00277 {
00278 counter2048 = (counter2048 + 16) & 0x7ff;
00279 step_A(p,P[cc+0], P[cc+1], X[0], X[6], X[13],X[4], &data[0]);
00280 step_A(p,P[cc+1], P[cc+2], X[1], X[7], X[14],X[5], &data[1]);
00281 step_A(p,P[cc+2], P[cc+3], X[2], X[8], X[15],X[6], &data[2]);
00282 step_A(p,P[cc+3], P[cc+4], X[3], X[9], X[0], X[7], &data[3]);
00283 step_A(p,P[cc+4], P[cc+5], X[4], X[10],X[1], X[8], &data[4]);
00284 step_A(p,P[cc+5], P[cc+6], X[5], X[11],X[2], X[9], &data[5]);
00285 step_A(p,P[cc+6], P[cc+7], X[6], X[12],X[3], X[10],&data[6]);
00286 step_A(p,P[cc+7], P[cc+8], X[7], X[13],X[4], X[11],&data[7]);
00287 step_A(p,P[cc+8], P[cc+9], X[8], X[14],X[5], X[12],&data[8]);
00288 step_A(p,P[cc+9], P[cc+10],X[9], X[15],X[6], X[13],&data[9]);
00289 step_A(p,P[cc+10],P[cc+11],X[10],X[0], X[7], X[14],&data[10]);
00290 step_A(p,P[cc+11],P[cc+12],X[11],X[1], X[8], X[15],&data[11]);
00291 step_A(p,P[cc+12],P[cc+13],X[12],X[2], X[9], X[0], &data[12]);
00292 step_A(p,P[cc+13],P[cc+14],X[13],X[3], X[10],X[1], &data[13]);
00293 step_A(p,P[cc+14],P[cc+15],X[14],X[4], X[11],X[2], &data[14]);
00294 step_A(p,P[cc+15],P[dd+0], X[15],X[5], X[12],X[3], &data[15]);
00295 }
00296 else
00297 {
00298 counter2048 = (counter2048 + 16) & 0x7ff;
00299 step_B(p,Q[cc+0], Q[cc+1], Y[0], Y[6], Y[13],Y[4], &data[0]);
00300 step_B(p,Q[cc+1], Q[cc+2], Y[1], Y[7], Y[14],Y[5], &data[1]);
00301 step_B(p,Q[cc+2], Q[cc+3], Y[2], Y[8], Y[15],Y[6], &data[2]);
00302 step_B(p,Q[cc+3], Q[cc+4], Y[3], Y[9], Y[0], Y[7], &data[3]);
00303 step_B(p,Q[cc+4], Q[cc+5], Y[4], Y[10],Y[1], Y[8], &data[4]);
00304 step_B(p,Q[cc+5], Q[cc+6], Y[5], Y[11],Y[2], Y[9], &data[5]);
00305 step_B(p,Q[cc+6], Q[cc+7], Y[6], Y[12],Y[3], Y[10],&data[6]);
00306 step_B(p,Q[cc+7], Q[cc+8], Y[7], Y[13],Y[4], Y[11],&data[7]);
00307 step_B(p,Q[cc+8], Q[cc+9], Y[8], Y[14],Y[5], Y[12],&data[8]);
00308 step_B(p,Q[cc+9], Q[cc+10],Y[9], Y[15],Y[6], Y[13],&data[9]);
00309 step_B(p,Q[cc+10],Q[cc+11],Y[10],Y[0], Y[7], Y[14],&data[10]);
00310 step_B(p,Q[cc+11],Q[cc+12],Y[11],Y[1], Y[8], Y[15],&data[11]);
00311 step_B(p,Q[cc+12],Q[cc+13],Y[12],Y[2], Y[9], Y[0], &data[12]);
00312 step_B(p,Q[cc+13],Q[cc+14],Y[13],Y[3], Y[10],Y[1], &data[13]);
00313 step_B(p,Q[cc+14],Q[cc+15],Y[14],Y[4], Y[11],Y[2], &data[14]);
00314 step_B(p,Q[cc+15],Q[dd+0], Y[15],Y[5], Y[12],Y[3], &data[15]);
00315 }
00316
00317 p->counter2048 = counter2048;
00318 }
|
|
||||||||||||||||||||||||
|
dkcHC256.c の 87 行で定義されています。 参照先 rotr.
|
|
||||||||||||||||||||||||
|
dkcHC256.c の 103 行で定義されています。 参照先 rotr. 参照元 initialization().
|
|
||||||||||||||||||||||||
|
dkcHC256.c の 95 行で定義されています。 参照先 rotr.
|
|
||||||||||||||||||||||||
|
dkcHC256.c の 110 行で定義されています。 参照先 rotr. 参照元 initialization().
|
|
||||||||||||||||
|
dkcHC256.c の 57 行で定義されています。 参照先 rotr. 参照元 dkcHC256Process().
|
|
||||||||||||||||
|
dkcHC256.c の 64 行で定義されています。 参照先 rotr. 参照元 dkcHC256Process().
|
|
||||||||||||
|
dkcHC256.c の 39 行で定義されています。 参照先 DKC_4BYTE_UNION_LITTLE_ENDIAN_BASE. 参照元 dkcHC256Process(), と step_A().
00039 {
00040 DKC_4BYTE_UNION_LITTLE_ENDIAN_BASE a;
00041 a.dword = x;
00042 return Q[a.w.byte0] +
00043 Q[256+a.w.byte1] +
00044 Q[512+a.w.byte2] +
00045 Q[768+a.w.byte3];
00046 }
|
|
||||||||||||
|
dkcHC256.c の 48 行で定義されています。 参照先 DKC_4BYTE_UNION_LITTLE_ENDIAN_BASE. 参照元 dkcHC256Process(), と step_B().
00048 {
00049 DKC_4BYTE_UNION_LITTLE_ENDIAN_BASE a;
00050 a.dword = x;
00051 return P[a.w.byte0] +
00052 P[256+a.w.byte1] +
00053 P[512+a.w.byte2] +
00054 P[768+a.w.byte3];
00055 }
|
|
||||||||||||||||
|
dkcHC256.c の 121 行で定義されています。 参照先 dkc_HC256::counter2048, DKC_HC256, f, fb1_(), fb2_(), feedback_1, feedback_2, dkc_HC256::P, dkc_HC256::Q, dkc_HC256::X, と dkc_HC256::Y. 参照元 dkcAllocHC256().
00122 {
00123 uint32 i,j;
00124 uint32 *P = p->P;
00125 uint32 *Q = p->Q;
00126
00127 //expand the key and iv into P and Q
00128 for (i = 0; i < 8; i++) P[i] = key[i];
00129 for (i = 8; i < 16; i++) P[i] = iv[i-8];
00130
00131 for (i = 16; i < 528; i++)
00132 P[i] = f(P[i-2],P[i-7],P[i-15],P[i-16])+i;
00133 for (i = 0; i < 16; i++)
00134 P[i] = P[i+512];
00135 for (i = 16; i < 1024; i++)
00136 P[i] = f(P[i-2],P[i-7],P[i-15],P[i-16])+512+i;
00137
00138 for (i = 0; i < 16; i++)
00139 Q[i] = P[1024-16+i];
00140 for (i = 16; i < 32; i++)
00141 Q[i] = f(Q[i-2],Q[i-7],Q[i-15],Q[i-16])+1520+i;
00142 for (i = 0; i < 16; i++)
00143 Q[i] = Q[i+16];
00144 for (i = 16; i < 1024;i++)
00145 Q[i] = f(Q[i-2],Q[i-7],Q[i-15],Q[i-16])+1536+i;
00146
00147 //run the cipher 4096 steps without generating output
00148 for (i = 0; i < 2; i++) {
00149 #if 1
00150 for (j = 0; j < 10; j++)
00151 fb1_(Q,&P[j],P[j+1],P[(j-10)&0x3ff],P[(j-3)&0x3ff]);
00152 for (j = 10; j < 1023; j++)
00153 fb1_(Q,&P[j],P[j+1],P[j-10],P[j-3]);
00154 fb1_(Q,&P[1023],P[0],P[1013],P[1020]);
00155 for (j = 0; j < 10; j++)
00156 fb2_(P,&Q[j],Q[j+1],Q[(j-10)&0x3ff],Q[(j-3)&0x3ff]);
00157 for (j = 10; j < 1023; j++)
00158 fb2_(P,&Q[j],Q[j+1],Q[j-10],Q[j-3]);
00159 fb2_(P,&Q[1023],Q[0],Q[1013],Q[1020]);
00160 /*
00161 for (j = 0; j < 10; j++)
00162 P[j] = fb1(P,P[j],P[j+1],P[(j-10)&0x3ff],P[(j-3)&0x3ff]);
00163 for (j = 10; j < 1023; j++)
00164 P[j] = fb1(P,P[j],P[j+1],P[j-10],P[j-3]);
00165 P[1023] = fb1(P,P[1023],P[0],P[1013],P[1020]);
00166 for (j = 0; j < 10; j++)
00167 Q[j] = fb2(Q,Q[j],Q[j+1],Q[(j-10)&0x3ff],Q[(j-3)&0x3ff]);
00168 for (j = 10; j < 1023; j++)
00169 Q[j] =fb2(Q,Q[j],Q[j+1],Q[j-10],Q[j-3]);
00170 Q[1023] =fb2(Q,Q[1023],Q[0],Q[1013],Q[1020]);
00171 */
00172 #else
00173 for (j = 0; j < 10; j++)
00174 feedback_1(P[j],P[j+1],P[(j-10)&0x3ff],P[(j-3)&0x3ff]);
00175 for (j = 10; j < 1023; j++)
00176 feedback_1(P[j],P[j+1],P[j-10],P[j-3]);
00177 feedback_1(P[1023],P[0],P[1013],P[1020]);
00178 for (j = 0; j < 10; j++)
00179 feedback_2(Q[j],Q[j+1],Q[(j-10)&0x3ff],Q[(j-3)&0x3ff]);
00180 for (j = 10; j < 1023; j++)
00181 feedback_2(Q[j],Q[j+1],Q[j-10],Q[j-3]);
00182 feedback_2(Q[1023],Q[0],Q[1013],Q[1020]);
00183 #endif
00184 }
00185
00186 //initialize counter2048, and tables X and Y
00187 p->counter2048 = 0;
00188 for (i = 0; i < 16; i++) p->X[i] = P[1008+i];
00189 for (i = 0; i < 16; i++) p->Y[i] = Q[1008+i];
00190 }
|
|
||||||||||||||||||||||||||||||||||||
|
dkcHC256.c の 241 行で定義されています。 参照先 DKC_HC256, h1(), dkc_HC256::P, dkc_HC256::Q, と rotr. 参照元 encrypt().
|
|
||||||||||||||||||||||||||||||||||||
|
dkcHC256.c の 254 行で定義されています。 参照先 DKC_HC256, h2(), dkc_HC256::P, と rotr. 参照元 encrypt().
|
1.3.6