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

# 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_HC256 * | dkcAllocHC256Const (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,
|  | d |  | ) | (f2((a)) + b + f1((c)) + d)

| dkcHC256.c の 119 行で定義されています。 参照元 initialization().

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

| dkcHC256.c の 117 行で定義されています。

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

| dkcHC256.c の 118 行で定義されています。

#define feedback_1 | ( | u,
|  | v,
|  | b,
|  | c |  | ) |

| 値:
    {        \
       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().

#define feedback_2 | ( | u,
|  | v,
|  | b,
|  | c |  | ) |

| 値:
    {        \
       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().

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

| dkcHC256.c の 351 行で定義されています。 参照元 dkcSelect(), dkcSNOW2Process(), と hc256_byte().

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

| dkcHC256.c の 33 行で定義されています。 参照元 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.c の 309 行で定義されています。 参照先 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.c の 329 行で定義されています。 参照先 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.c の 346 行で定義されています。 参照先 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.c の 376 行で定義されています。 参照先 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.c の 425 行で定義されています。 参照先 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.c の 365 行で定義されています。 参照先 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.c の 194 行で定義されています。 参照先 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.c の 387 行で定義されています。 参照先 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.c の 87 行で定義されています。 参照先 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.c の 103 行で定義されています。 参照先 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.c の 95 行で定義されています。 参照先 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.c の 110 行で定義されています。 参照先 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.c の 57 行で定義されています。 参照先 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.c の 64 行で定義されています。 参照先 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.c の 248 行で定義されています。 参照先 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.c の 39 行で定義されています。 参照先 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.c の 48 行で定義されています。 参照先 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.c の 353 行で定義されています。 参照先 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.c の 121 行で定義されています。 参照先 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.c の 219 行で定義されています。 参照先 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.c の 233 行で定義されています。 参照先 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.c の 300 行で定義されています。 参照先 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 }