メインページ | アルファベット順一覧 | 構成 | ファイル一覧 | 構成メンバ | ファイルメンバ | 関連ページ

dkcHC256.c

HC256 stream cipher Algorithm [詳細]

#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)
#define get_offset(p)   (64 - p->store_size)

関数

static DKC_INLINE uint32 h1 (uint32 *Q, uint32 x)
static DKC_INLINE uint32 h2 (uint32 *P, uint32 x)
static DKC_INLINE uint32 g1 (uint32 *Q, uint32 x, uint32 y)
static DKC_INLINE uint32 g2 (uint32 *P, uint32 x, uint32 y)
static DKC_INLINE uint32 fb1 (uint32 *Q, uint32 u, uint32 v, uint32 b, uint32 c)
static DKC_INLINE uint32 fb2 (uint32 *P, uint32 u, uint32 v, uint32 b, uint32 c)
static DKC_INLINE void fb1_ (uint32 *Q, uint32 *u, uint32 v, uint32 b, uint32 c)
static 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 uint32 dkcHC256Process32 (DKC_HC256 *p, uint32 u)
static DKC_INLINE void step_A (DKC_HC256 *p, uint32 u, uint32 v, uint32 a, uint32 b, uint32 c, uint32 d, uint32 *m)
static DKC_INLINE void step_B (DKC_HC256 *p, uint32 u, uint32 v, uint32 a, uint32 b, uint32 c, uint32 d, uint32 *m)
static DKC_INLINE void get_encrypt_array (DKC_HC256 *p, uint32 data[])
static DKC_INLINE int store (DKC_HC256 *p)
DKC_INLINE DKC_HC256 *WINAPI dkcAllocHC256 (BYTE *key, size_t size, uint32 *iv, size_t ivsize)
 keyのサイズは32byte ivも32byte
DKC_INLINE DKC_HC256dkcAllocHC256Const (const uint8 *key, size_t size, const uint32 *iv, size_t ivsize)
DKC_INLINE int WINAPI dkcFreeHC256 (DKC_HC256 **p)
static DKC_INLINE uint8 hc256_byte (DKC_HC256 *p)
DKC_INLINE uint8 WINAPI dkcHC256Process (DKC_HC256 *p)
int WINAPI dkcHC256EncryptDOE (DKC_HC256 *p, uint8 *dest, size_t dsize, const uint8 *src, size_t ssize)
static DKC_INLINE int encode_byte (DKC_HC256 *p, uint8 *inout, size_t size, size_t *nextoffset)
int WINAPI dkcHC256EncryptNoDestDOE (DKC_HC256 *p, uint8 *inout, size_t size)
 この処理バイトを分割していく


説明

HC256 stream cipher Algorithm

覚え書き:
これ(以下)はオリジナルの紹介(表記)していたコメント(文章)です。 this is the original introductory comment:
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 で定義されています。


マクロ定義

#define f a,
b,
c,
 )     (f2((a)) + b + f1((c)) + d)
 

dkcHC256.c119 行で定義されています。

参照元 initialization().

#define f1  )     (rotr((x),7) ^ rotr((x),18) ^ ((x) >> 3))
 

dkcHC256.c117 行で定義されています。

#define f2  )     (rotr((x),17) ^ rotr((x),19) ^ ((x) >> 10))
 

dkcHC256.c118 行で定義されています。

#define feedback_1 u,
v,
b,
 ) 
 

値:

{        \
   uint32 tem0,tem1,tem2;          \
   tem0 = rotr((v),23);             \
   tem1 = rotr((c),10);            \
   tem2 = ((v) ^ (c)) & 0x3ff;     \
   (u) += (b)+(tem0^tem1)+Q[tem2]; \
}

dkcHC256.c72 行で定義されています。

参照元 initialization().

#define feedback_2 u,
v,
b,
 ) 
 

値:

{        \
   uint32 tem0,tem1,tem2;          \
   tem0 = rotr((v),23);             \
   tem1 = rotr((c),10);            \
   tem2 = ((v) ^ (c)) & 0x3ff;     \
   (u) += (b)+(tem0^tem1)+P[tem2]; \
}

dkcHC256.c80 行で定義されています。

参照元 initialization().

#define get_offset  )     (64 - p->store_size)
 

dkcHC256.c351 行で定義されています。

参照元 dkcSelect(), dkcSNOW2Process(), と hc256_byte().

#define rotr x,
 )     (((x)>>(n))|((x)<<(32-(n))))
 

dkcHC256.c33 行で定義されています。

参照元 fb1(), fb1_(), fb2(), fb2_(), g1(), g2(), step_A(), と step_B().


関数

DKC_INLINE DKC_HC256* WINAPI dkcAllocHC256 BYTE key,
size_t  size,
uint32 *  iv,
size_t  ivsize
 

keyのサイズは32byte ivも32byte

参照:
keyやivは内部でいじり倒されるのでそれが嫌な場合はdkcAllocHC256Const()を使ってください。

dkcHC256.c309 行で定義されています。

参照先 dkcAllocate(), dkcdHC256_IV_SIZE, dkcdHC256_KEY_SIZE, initialization(), NULL, store(), と uint32.

参照元 dkcAllocHC256Const(), と dkcAllocHC256NoLimitKeyLength().

00309                                                                                           {
00310     DKC_HC256 *p;
00311     //uint32 iv[8];
00312     //size_t limit = sizeof(uint32) * 8;
00313     //if(size != limit || ivsize != limit){
00314     if(size != dkcdHC256_KEY_SIZE || ivsize != dkcdHC256_IV_SIZE){
00315         return NULL;
00316     }
00317     
00318     p = dkcAllocate(sizeof(DKC_HC256));
00319     if(NULL==p){
00320         return NULL;
00321     }
00322     //DKUTIL_MEMZERO(iv,sizeof(iv));
00323     initialization(p,(uint32 *)key,iv);
00324     store(p);
00325     //p->store_size = 64;
00326     return p;
00327 }

DKC_INLINE DKC_HC256* dkcAllocHC256Const const uint8 *  key,
size_t  size,
const uint32 *  iv,
size_t  ivsize
 

dkcHC256.c329 行で定義されています。

参照先 dkcAllocHC256(), NULL, uint32, と uint8.

00330 {
00331     DKC_HC256 *p=NULL;
00332     uint32 *piv = malloc(ivsize);
00333     uint8 *pt;
00334     if(!piv) return NULL;
00335     pt = malloc(size);
00336     if(pt){
00337         memcpy(pt,key,size);
00338         memcpy(piv,iv,ivsize);
00339         p = dkcAllocHC256(pt,size,piv,ivsize);
00340         free(pt);
00341         free(piv);
00342     }
00343     return p;
00344 }

DKC_INLINE int WINAPI dkcFreeHC256 DKC_HC256 **  p  ) 
 

dkcHC256.c346 行で定義されています。

参照先 dkcFree().

00346                                                  {
00347     return dkcFree(p);
00348 }

int WINAPI dkcHC256EncryptDOE DKC_HC256 p,
uint8 *  dest,
size_t  dsize,
const uint8 *  src,
size_t  ssize
 

覚え書き:

dkcHC256.c376 行で定義されています。

参照先 dkcHC256EncryptNoDestDOE().

00377 {
00378     if(ssize > dsize){
00379         return edk_ArgumentException;
00380     }
00381     if(dest != src){
00382         memcpy(dest,src,ssize);
00383     }
00384     return dkcHC256EncryptNoDestDOE(p,dest,ssize);
00385 
00386 }

int WINAPI dkcHC256EncryptNoDestDOE DKC_HC256 p,
uint8 *  inout,
size_t  size
 

この処理バイトを分割していく

dkcHC256.c425 行で定義されています。

参照先 dkcHC256EncryptNoDestDOE(), dkcmASSERT, dkcmNOT_ASSERT, encode_byte(), NULL, store(), dkc_HC256::store_size, dkc_HC256::u_store, と uint8.

参照元 dkcHC256EncryptDOE(), と dkcHC256EncryptNoDestDOE().

00426 {
00427 
00428     size_t i = 0;
00429     int r = edk_FAILED;
00430     size_t count,rest;
00431     uint64 *io64 = NULL;
00432 
00433     r = encode_byte(p,inout,size,&rest);
00434     switch(r){
00435     case edk_SUCCEEDED:
00436         return r;
00437     case edk_NoValueToProcess:
00438         break;
00439     default:
00440         dkcmNOT_ASSERT(DKUTIL_FAILED(r));
00441     }
00442     size = size - rest;
00443     inout += rest;
00444     if(rest == size) return edk_SUCCEEDED;
00445     //if(size <= 0) return edk_SUCCEEDED;
00446 
00447     count = size / 64;
00448     rest = size % 64;//最適化に任せよう(笑)
00449     
00450     if(64!=p->store_size){
00451         dkcmASSERT(p->store_size ==0);
00452         r = store(p);
00453         dkcmNOT_ASSERT(DKUTIL_FAILED(r));
00454     }
00455     io64 = (uint64 *)inout;
00456     for(i=0;i<count;i++){
00457         //64bit単位も良いかも?
00458         io64[0] ^= p->u_store.a64[0];
00459         io64[1] ^= p->u_store.a64[1];
00460         io64[2] ^= p->u_store.a64[2];
00461         io64[3] ^= p->u_store.a64[3];
00462         io64[4] ^= p->u_store.a64[4];
00463         io64[5] ^= p->u_store.a64[5];
00464         io64[6] ^= p->u_store.a64[6];
00465         io64[7] ^= p->u_store.a64[7];
00466 
00467         io64+=8;
00468         p->store_size = 0;
00469         store(p);
00470     }
00471     inout =(uint8*)io64;
00472     return dkcHC256EncryptNoDestDOE(p,inout,rest);
00473 
00474 }

DKC_INLINE uint8 WINAPI dkcHC256Process DKC_HC256 p  ) 
 

dkcHC256.c365 行で定義されています。

参照先 dkcmNOT_ASSERT, hc256_byte(), store(), と dkc_HC256::store_size.

00365                                                      {
00366     int r = 0;
00367     //DKC_4BYTE_LITTLE_ENDIAN_BASE a;
00368     if(p->store_size <= 0){
00369         r = store(p);
00370         dkcmNOT_ASSERT(DKUTIL_FAILED(r));
00371     }
00372     return hc256_byte(p);
00373 
00374 }

DKC_INLINE uint32 dkcHC256Process32 DKC_HC256 p,
uint32  u
 

dkcHC256.c194 行で定義されています。

参照先 dkc_HC256::counter2048, g1(), g2(), h1(), h2(), dkc_HC256::P, と dkc_HC256::Q.

00195 {
00196     unsigned long i,i3, i10, i12, i1023;
00197     unsigned long output;
00198 
00199     i   = p->counter2048 & 0x3ff;
00200     i3  = (i - 3) & 0x3ff;
00201     i10 = (i - 10) & 0x3ff;
00202     i12 = (i - 12) & 0x3ff;
00203     i1023 = (i - 1023) & 0x3ff;
00204 
00205     if (p->counter2048 < 1024) {
00206         p->P[i] = p->P[i] + p->P[i10] + g1(p->Q,p->P[i3],p->P[i1023]);
00207         output = h1(p->Q,p->P[i12]) ^ p->P[i];
00208     }
00209     else {
00210         p->Q[i] = p->Q[i] + p->Q[i10] + g2(p->P,p->Q[i3],p->Q[i1023]);
00211         output = h2(p->P,p->Q[i12]) ^ p->Q[i];
00212 
00213     }
00214     p->counter2048 = (p->counter2048+1) & 0x7ff;
00215     return (output);
00216 }

static DKC_INLINE int encode_byte DKC_HC256 p,
uint8 *  inout,
size_t  size,
size_t *  nextoffset
[static]
 

dkcHC256.c387 行で定義されています。

参照先 dkcmNOT_ASSERT, hc256_byte(), store(), と dkc_HC256::store_size.

参照元 dkcHC256EncryptNoDestDOE(), と dkcSNOW2EncryptNoDestDOE().

00388 {
00389     size_t i=0;
00390     int r;
00391     if(size <= 0){
00392         r =  edk_SUCCEEDED;
00393         goto End;
00394     }
00395     if((size > 64) && ( p->store_size == 0 || 64==p->store_size)){
00396     //if((size > 8) && ( p->store_size == 0 || 8==p->store_size)){
00397         r = edk_NoValueToProcess;
00398         goto End;
00399     }
00400     if(p->store_size ==0){
00401         r = store(p);
00402         dkcmNOT_ASSERT(DKUTIL_FAILED(r));
00403     }
00404     for(i=0;i<size;i++){
00405         inout[i] ^= hc256_byte(p);
00406         if(p->store_size ==0){
00407             //if(size - (i+1) >= 64){//(i + 1)かも?
00408             if(size - i > 64){
00409                 r = edk_NoValueToProcess;
00410                 i++;
00411                 goto End;
00412             }
00413             r = store(p);
00414             dkcmNOT_ASSERT(DKUTIL_FAILED(r));
00415         }
00416     }
00417     r = edk_SUCCEEDED;
00418 End:
00419     *nextoffset = i;
00420     return r;
00421 }

static DKC_INLINE uint32 fb1 uint32 *  Q,
uint32  u,
uint32  v,
uint32  b,
uint32  c
[static]
 

dkcHC256.c87 行で定義されています。

参照先 rotr, と uint32.

00087                                                                            {
00088      uint32 tem0,tem1,tem2;          
00089    tem0 = rotr((v),23);             
00090    tem1 = rotr((c),10);            
00091    tem2 = ((v) ^ (c)) & 0x3ff;    
00092    (u) += (b)+(tem0^tem1)+Q[tem2];
00093      return u;
00094 }

static DKC_INLINE void fb1_ uint32 *  Q,
uint32 *  u,
uint32  v,
uint32  b,
uint32  c
[static]
 

dkcHC256.c103 行で定義されています。

参照先 rotr, と uint32.

参照元 initialization().

00103                                                                            {
00104      uint32 tem0,tem1,tem2;          
00105    tem0 = rotr((v),23);             
00106    tem1 = rotr((c),10);            
00107    tem2 = ((v) ^ (c)) & 0x3ff;     
00108    (*u) += (b)+(tem0^tem1)+Q[tem2]; 
00109 }

static DKC_INLINE uint32 fb2 uint32 *  P,
uint32  u,
uint32  v,
uint32  b,
uint32  c
[static]
 

dkcHC256.c95 行で定義されています。

参照先 rotr, と uint32.

00095                                                                            {
00096     uint32 tem0,tem1,tem2;          
00097     tem0 = rotr((v),23);             
00098     tem1 = rotr((c),10);               
00099     tem2 = ((v) ^ (c)) & 0x3ff;     
00100     (u) += (b)+(tem0^tem1)+P[tem2]; 
00101     return u;
00102 }

static DKC_INLINE void fb2_ uint32 *  P,
uint32 *  u,
uint32  v,
uint32  b,
uint32  c
[static]
 

dkcHC256.c110 行で定義されています。

参照先 rotr, と uint32.

参照元 initialization().

00110                                                                            {
00111     uint32 tem0,tem1,tem2;          
00112     tem0 = rotr((v),23);             
00113     tem1 = rotr((c),10);               
00114     tem2 = ((v) ^ (c)) & 0x3ff;     
00115     (*u) += (b)+(tem0^tem1)+P[tem2]; 
00116 }

static DKC_INLINE uint32 g1 uint32 *  Q,
uint32  x,
uint32  y
[static]
 

dkcHC256.c57 行で定義されています。

参照先 rotr, と uint32.

参照元 dkcHC256Process32().

00057                                                         {
00058     uint32 a,b,c;
00059     a = rotr((x),10);
00060     b = rotr((y),23);
00061     c = ((x)^(y))&0x3ff;
00062     return (a^b) + Q[c];
00063 }

static DKC_INLINE uint32 g2 uint32 *  P,
uint32  x,
uint32  y
[static]
 

dkcHC256.c64 行で定義されています。

参照先 rotr, と uint32.

参照元 dkcHC256Process32().

00064                                                         {
00065     uint32 a,b,c;
00066     a = rotr((x),10);
00067     b = rotr((y),23);
00068     c = ((x)^(y))&0x3ff;
00069     return (a^b) + P[c];
00070 }

static DKC_INLINE void get_encrypt_array DKC_HC256 p,
uint32  data[]
[static]
 

dkcHC256.c248 行で定義されています。

参照先 dkc_HC256::counter2048, dkc_HC256::P, dkc_HC256::Q, step_A(), step_B(), uint32, dkc_HC256::X, と dkc_HC256::Y.

参照元 store().

00249 {
00250     uint32 cc,dd,counter2048 = p->counter2048;
00251     uint32 *P = p->P,*Q = p->Q,*X =p->X, *Y = p->Y;
00252 
00253     cc = counter2048 & 0x3ff;
00254     dd = (cc+16) & 0x3ff;
00255 
00256     if (counter2048 < 1024) 
00257     {           
00258         counter2048 = (counter2048 + 16) & 0x7ff;
00259         step_A(p,P[cc+0], P[cc+1], X[0], X[6], X[13],X[4], &data[0]);
00260         step_A(p,P[cc+1], P[cc+2], X[1], X[7], X[14],X[5], &data[1]);
00261         step_A(p,P[cc+2], P[cc+3], X[2], X[8], X[15],X[6], &data[2]);
00262         step_A(p,P[cc+3], P[cc+4], X[3], X[9], X[0], X[7], &data[3]);
00263         step_A(p,P[cc+4], P[cc+5], X[4], X[10],X[1], X[8], &data[4]);
00264         step_A(p,P[cc+5], P[cc+6], X[5], X[11],X[2], X[9], &data[5]);
00265         step_A(p,P[cc+6], P[cc+7], X[6], X[12],X[3], X[10],&data[6]);
00266         step_A(p,P[cc+7], P[cc+8], X[7], X[13],X[4], X[11],&data[7]);
00267         step_A(p,P[cc+8], P[cc+9], X[8], X[14],X[5], X[12],&data[8]);
00268         step_A(p,P[cc+9], P[cc+10],X[9], X[15],X[6], X[13],&data[9]);
00269         step_A(p,P[cc+10],P[cc+11],X[10],X[0], X[7], X[14],&data[10]);
00270         step_A(p,P[cc+11],P[cc+12],X[11],X[1], X[8], X[15],&data[11]);
00271         step_A(p,P[cc+12],P[cc+13],X[12],X[2], X[9], X[0], &data[12]);
00272         step_A(p,P[cc+13],P[cc+14],X[13],X[3], X[10],X[1], &data[13]);
00273         step_A(p,P[cc+14],P[cc+15],X[14],X[4], X[11],X[2], &data[14]);
00274         step_A(p,P[cc+15],P[dd+0], X[15],X[5], X[12],X[3], &data[15]);
00275     }
00276     else                    
00277     {
00278         counter2048 = (counter2048 + 16) & 0x7ff;
00279         step_B(p,Q[cc+0], Q[cc+1], Y[0], Y[6], Y[13],Y[4], &data[0]);
00280         step_B(p,Q[cc+1], Q[cc+2], Y[1], Y[7], Y[14],Y[5], &data[1]);
00281         step_B(p,Q[cc+2], Q[cc+3], Y[2], Y[8], Y[15],Y[6], &data[2]);
00282         step_B(p,Q[cc+3], Q[cc+4], Y[3], Y[9], Y[0], Y[7], &data[3]);
00283         step_B(p,Q[cc+4], Q[cc+5], Y[4], Y[10],Y[1], Y[8], &data[4]);
00284         step_B(p,Q[cc+5], Q[cc+6], Y[5], Y[11],Y[2], Y[9], &data[5]);
00285         step_B(p,Q[cc+6], Q[cc+7], Y[6], Y[12],Y[3], Y[10],&data[6]);
00286         step_B(p,Q[cc+7], Q[cc+8], Y[7], Y[13],Y[4], Y[11],&data[7]);
00287         step_B(p,Q[cc+8], Q[cc+9], Y[8], Y[14],Y[5], Y[12],&data[8]);
00288         step_B(p,Q[cc+9], Q[cc+10],Y[9], Y[15],Y[6], Y[13],&data[9]);
00289         step_B(p,Q[cc+10],Q[cc+11],Y[10],Y[0], Y[7], Y[14],&data[10]);
00290         step_B(p,Q[cc+11],Q[cc+12],Y[11],Y[1], Y[8], Y[15],&data[11]);
00291         step_B(p,Q[cc+12],Q[cc+13],Y[12],Y[2], Y[9], Y[0], &data[12]);
00292         step_B(p,Q[cc+13],Q[cc+14],Y[13],Y[3], Y[10],Y[1], &data[13]);
00293         step_B(p,Q[cc+14],Q[cc+15],Y[14],Y[4], Y[11],Y[2], &data[14]);
00294         step_B(p,Q[cc+15],Q[dd+0], Y[15],Y[5], Y[12],Y[3], &data[15]);
00295     }
00296 
00297     p->counter2048 = counter2048;
00298 }

static DKC_INLINE uint32 h1 uint32 *  Q,
uint32  x
[static]
 

dkcHC256.c39 行で定義されています。

参照先 dkc4ByteUnionLittleEndianBase::dword, と dkc4ByteUnionLittleEndianBase::w.

参照元 dkcHC256Process32(), と 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 }

static DKC_INLINE uint32 h2 uint32 *  P,
uint32  x
[static]
 

dkcHC256.c48 行で定義されています。

参照先 dkc4ByteUnionLittleEndianBase::dword, と dkc4ByteUnionLittleEndianBase::w.

参照元 dkcHC256Process32(), と 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 }

static DKC_INLINE uint8 hc256_byte DKC_HC256 p  )  [static]
 

dkcHC256.c353 行で定義されています。

参照先 dkcmNOT_ASSERT, get_offset, dkc_HC256::store_size, と dkc_HC256::u_store.

参照元 dkcHC256Process(), と encode_byte().

00353                                                 {
00354     
00355     size_t offset; 
00356     //DKC_4BYTE_LITTLE_ENDIAN_BASE a;
00357     dkcmNOT_ASSERT(0==p->store_size);
00358 
00359     offset = get_offset(p);
00360     p->store_size--;
00361     return p->u_store.a8[offset];
00362 
00363 }

void initialization DKC_HC256 p,
uint32  key[],
uint32  iv[]
 

dkcHC256.c121 行で定義されています。

参照先 dkc_HC256::counter2048, f, fb1_(), fb2_(), feedback_1, feedback_2, dkc_HC256::P, dkc_HC256::Q, uint32, 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 }   

static DKC_INLINE void step_A DKC_HC256 p,
uint32  u,
uint32  v,
uint32  a,
uint32  b,
uint32  c,
uint32  d,
uint32 *  m
[static]
 

dkcHC256.c219 行で定義されています。

参照先 h1(), dkc_HC256::P, dkc_HC256::Q, rotr, と uint32.

参照元 get_encrypt_array().

00221 {
00222     uint32 tem0,tem1,tem2,tem3;
00223     tem0 = rotr((v),23);
00224     tem1 = rotr((c),10);
00225     tem2 = ((v) ^ (c)) & 0x3ff;
00226     (u) += (b)+(tem0^tem1) + p->Q[tem2];
00227     (a) = (u);
00228     tem3 = h1(p->P,d);
00229     //h1(p->Q,(d),tem3);                    
00230     //(*m) ^= tem3 ^ (u) ;
00231     *m = tem3 ^ (u) ;
00232 }

static DKC_INLINE void step_B DKC_HC256 p,
uint32  u,
uint32  v,
uint32  a,
uint32  b,
uint32  c,
uint32  d,
uint32 *  m
[static]
 

dkcHC256.c233 行で定義されています。

参照先 h2(), dkc_HC256::P, rotr, と uint32.

参照元 get_encrypt_array().

00234                                                                                                           {
00235     uint32 tem0,tem1,tem2,tem3;      
00236     tem0 = rotr((v),23);              
00237     tem1 = rotr((c),10);             
00238     tem2 = ((v) ^ (c)) & 0x3ff;      
00239     (u) += (b)+(tem0^tem1)+p->P[tem2];  
00240     (a) = (u);
00241     tem3 = h2(p->P,d);
00242     //h2(p->P,(d),tem3);                    
00243     //(*m) ^= tem3 ^ (u) ;              
00244     *m = tem3 ^ (u) ;
00245 }       

static DKC_INLINE int store DKC_HC256 p  )  [static]
 

dkcHC256.c300 行で定義されています。

参照先 dkcmNOT_ASSERT, get_encrypt_array(), dkc_HC256::store_size, と dkc_HC256::u_store.

参照元 dkcAllocHC256(), dkcHC256EncryptNoDestDOE(), dkcHC256Process(), dkcSNOW2EncryptNoDestDOE(), dkcSNOW2Init(), dkcSNOW2Process(), と encode_byte().

00300                                          {
00301     
00302     dkcmNOT_ASSERT(0 != p->store_size);
00303     if(0 != p->store_size) return edk_LogicError;
00304     get_encrypt_array(p,p->u_store.a32);
00305     p->store_size = 64;
00306     return edk_SUCCEEDED;
00307 }


dkutil_cに対してMon Jan 16 00:41:41 2006に生成されました。  doxygen 1.4.4