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

# dkcSNOW20.c

SNOW2.0 steram cipher Algorithm [詳細]

`#include "dkcSNOW20.h"`
`#include "snow2tab.h"`
`#include <stdlib.h>`

dkcSNOW20.cのインクルード依存関係図

ソースコードを見る。

## マクロ定義
#define | snow2_key_shake(key, begin_offset)
#define | ainv_mul(w) (((w)>>8)^(snow_alphainv_mul[w&0xff]))
#define | a_mul(w) (((w)<<8)^(snow_alpha_mul[w>>24]))
#define | snow_byte(n, w) (dkcmGETBYTE(w,n) & 0xff)
#define | get_offset(p) (64 - p->store_size)
## 関数
DKC_INLINE int WINAPI | dkcSNOW2_64Byte (DKC_SNOW2 *p, uint32 *keystream_block)
static DKC_INLINE int | store (DKC_SNOW2 *p)
int WINAPI | dkcSNOW2Init (DKC_SNOW2 *p, uint8 *key, size_t keysize, uint32 IV3, uint32 IV2, uint32 IV1, uint32 IV0)
DKC_SNOW2 *WINAPI | dkcAllocSNOW2 (BYTE *key, size_t keysize, uint32 IV3, uint32 IV2, uint32 IV1, uint32 IV0)
int WINAPI | dkcFreeSNOW2 (DKC_SNOW2 **pp)
DKC_INLINE uint8 WINAPI | dkcSNOW2Process (DKC_SNOW2 *p)
| 1byteの暗号化用ストリームを生成する
int WINAPI | dkcSNOW2EncryptDOE (DKC_SNOW2 *p, uint8 *dest, size_t dsize, const uint8 *src, size_t ssize)
static DKC_INLINE int | encode_byte (DKC_SNOW2 *p, uint8 *inout, size_t size, size_t *nextoffset)
int WINAPI | dkcSNOW2EncryptNoDestDOE (DKC_SNOW2 *p, uint8 *inout, size_t size)
| 1byte単位で暗号化でいるSNOW2

## 説明

SNOW2.0 steram cipher Algorithm

から:
  2004/12/31

覚え書き:
  2005/09/06:内部実装を一新 本家では出来なかった1byte単位の暗号化を可能にする。

dkcSNOW20.c で定義されています。

## マクロ定義

#define a_mul | ( | w |  | ) | (((w)<<8)^(snow_alpha_mul[w>>24]))

| dkcSNOW20.c の 41 行で定義されています。 参照元 dkcSNOW2_64Byte(), と dkcSNOW2Init().

#define ainv_mul | ( | w |  | ) | (((w)>>8)^(snow_alphainv_mul[w&0xff]))

| dkcSNOW20.c の 40 行で定義されています。 参照元 dkcSNOW2_64Byte(), と dkcSNOW2Init().

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

| dkcSNOW20.c の 404 行で定義されています。

#define snow2_key_shake | ( | key,
|  | begin_offset |  | ) |

| 値:
    (((uint32)*(key+begin_offset))<<24) |       \
        (((uint32)*(key+1+begin_offset))<<16) | \
        (((uint32)*(key+2+begin_offset))<<8) |      \
        (((uint32)*(key+3+begin_offset)))               \
    #else if defined(ORDER_BADC)
dkcSNOW20.c の 30 行で定義されています。 参照元 dkcSNOW2Init().

#define snow_byte | ( | n,
|  | w |  | ) | (dkcmGETBYTE(w,n) & 0xff)

| dkcSNOW20.c の 44 行で定義されています。 参照元 dkcSNOW2_64Byte(), と dkcSNOW2Init().

## 関数

DKC_SNOW2* WINAPI dkcAllocSNOW2 | ( | BYTE * | key,
|  | size_t | keysize,
|  | uint32 | IV3,
|  | uint32 | IV2,
|  | uint32 | IV1,
|  | uint32 | IV0
| ) |

  | 引数:
  | keysize[in] | には16か32を入れないとダメ
覚え書き: keyのサイズは128bit (16byte)か256bit (32byte) キーのエンディアンについては未定義･･･。 dkcSNOW20.c の 375 行で定義されています。 参照先 dkcAllocate(), dkcFreeSNOW2(), dkcSNOW2Init(), NULL, と dkc_SNOW2::store_size. 参照元 dkcAllocSNOW2Const(), と dkcAllocSNOW2NoLimitKeyLength().
    00377 {
    00378     DKC_SNOW2 *p;
    00379     int r;
    00380     p = dkcAllocate(sizeof(DKC_SNOW2));
    00381     if(NULL==p){
    00382         return NULL;
    00383     }
    00384     p->store_size = 0;
    00385     r = dkcSNOW2Init(p,key,keysize,IV3,IV2,IV1,IV0);
    00386     if(DKUTIL_FAILED(r)){
    00387         goto Error;
    00388     }
    00389
    00390     return p;
    00391 Error:
    00392     dkcFreeSNOW2(&p);
    00393     return NULL;
    00394 }

int WINAPI dkcFreeSNOW2 | ( | DKC_SNOW2 ** | pp | ) |

| dkcSNOW20.c の 398 行で定義されています。 参照先 dkcFree(). 参照元 dkcAllocDCF01(), dkcAllocSNOW2(), dkcDCF01ToFile(), と dkcFileToDCF01().
    00398                                        {
    00399     int r;
    00400     r = dkcFree(pp);
    00401     return r;
    00402 }

DKC_INLINE int WINAPI dkcSNOW2_64Byte | ( | DKC_SNOW2 * | p,
|  | uint32 * | keystream_block
| ) |

| dkcSNOW20.c の 47 行で定義されています。 参照先 a_mul, ainv_mul, dkcmASSERT, dkc_SNOW2::r1, dkc_SNOW2::r2, snow_byte, snow_T0, snow_T1, snow_T2, snow_T3, dkc_SNOW2::store_size, dkc_SNOW2::sw, と uint32. 参照元 store().
    00047                                                                            {
    00048     //uint32 *snow_ptr = p->snow_ptr;
    00049     uint32 fsmtmp,*sw = p->sw;
    00050     uint32 r1 = p->r1;
    00051     uint32 r2 = p->r2;
    00052
    00053     dkcmASSERT(p->store_size == 0);
    00054
    00055   sw[0] =a_mul(sw[0] )^ sw[2] ^ainv_mul(sw[11] );
    00056   fsmtmp=r2+ sw[5] ;
    00057   r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00058   r1=fsmtmp;
    00059   keystream_block[0]=(r1+ sw[0] )^r2^ sw[1] ;
    00060
    00061   sw[1] =a_mul(sw[1] )^ sw[3] ^ainv_mul(sw[12]);
    00062   fsmtmp=r2+ sw[6] ;
    00063   r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00064   r1=fsmtmp;
    00065   keystream_block[1]=(r1+ sw[1] )^r2^ sw[2] ;
    00066
    00067   sw[2] =a_mul(sw[2] )^ sw[4] ^ainv_mul(sw[13] );
    00068   fsmtmp=r2+ sw[7] ;
    00069   r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00070   r1=fsmtmp;
    00071   keystream_block[2]=(r1+ sw[2] )^r2^ sw[3] ;
    00072
    00073   sw[3] =a_mul(sw[3] )^ sw[5] ^ainv_mul(sw[14] );
    00074   fsmtmp=r2+ sw[8] ;
    00075   r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00076   r1=fsmtmp;
    00077   keystream_block[3]=(r1+ sw[3] )^r2^ sw[4] ;
    00078
    00079   sw[4 ]=a_mul(sw[4] )^ sw[6] ^ainv_mul(sw[15] );
    00080   fsmtmp=r2+ sw[9] ;
    00081   r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00082   r1=fsmtmp;
    00083   keystream_block[4]=(r1+ sw[4] )^r2^ sw[5] ;
    00084
    00085   sw[5] =a_mul(sw[5] )^ sw[7] ^ainv_mul(sw[0] );
    00086   fsmtmp=r2+ sw[10] ;
    00087   r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00088   r1=fsmtmp;
    00089   keystream_block[5]=(r1+ sw[5] )^r2^ sw[6] ;
    00090
    00091   sw[6] =a_mul(sw[6] )^ sw[8] ^ainv_mul(sw[1] );
    00092   fsmtmp=r2+ sw[11] ;
    00093   r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00094   r1=fsmtmp;
    00095   keystream_block[6]=(r1+ sw[6] )^r2^ sw[7] ;
    00096
    00097   sw[7] =a_mul(sw[7] )^ sw[9] ^ainv_mul(sw[2] );
    00098   fsmtmp=r2+ sw[12 ];
    00099   r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00100   r1=fsmtmp;
    00101   keystream_block[7]=(r1+ sw[7] )^r2^ sw[8] ;
    00102
    00103   sw[8] =a_mul(sw[8] )^ sw[10] ^ainv_mul(sw[3] );
    00104   fsmtmp=r2+ sw[13] ;
    00105   r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00106   r1=fsmtmp;
    00107   keystream_block[8]=(r1+ sw[8] )^r2^ sw[9] ;
    00108
    00109   sw[9] =a_mul(sw[9] )^ sw[11] ^ainv_mul(sw[4] );
    00110   fsmtmp=r2+ sw[14] ;
    00111   r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00112   r1=fsmtmp;
    00113   keystream_block[9]=(r1+ sw[9] )^r2^ sw[10] ;
    00114
    00115   sw[10] =a_mul(sw[10] )^ sw[12] ^ainv_mul(sw[5] );
    00116   fsmtmp=r2+ sw[15] ;
    00117   r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00118   r1=fsmtmp;
    00119   keystream_block[10]=(r1+ sw[10] )^r2^ sw[11] ;
    00120
    00121   sw[11] =a_mul(sw[11] )^ sw[13] ^ainv_mul(sw[6] );
    00122   fsmtmp=r2+ sw[0] ;
    00123   r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00124   r1=fsmtmp;
    00125   keystream_block[11]=(r1+ sw[11] )^r2^ sw[12] ;
    00126
    00127   sw[12] =a_mul(sw[12] )^ sw[14] ^ainv_mul(sw[7] );
    00128   fsmtmp=r2+ sw[1 ];
    00129   r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00130   r1=fsmtmp;
    00131   keystream_block[12]=(r1+ sw[12] )^r2^ sw[13] ;
    00132
    00133   sw[13] =a_mul(sw[13] )^ sw[15] ^ainv_mul(sw[8] );
    00134   fsmtmp=r2+ sw[2] ;
    00135   r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00136   r1=fsmtmp;
    00137   keystream_block[13]=(r1+ sw[13] )^r2^ sw[14] ;
    00138
    00139   sw[14] =a_mul(sw[14] )^ sw[0] ^ainv_mul(sw[9] );
    00140   fsmtmp=r2+ sw[3] ;
    00141   r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00142   r1=fsmtmp;
    00143   keystream_block[14]=(r1+ sw[14] )^r2^ sw[15] ;
    00144
    00145   sw[15] =a_mul(sw[15] )^ sw[1] ^ainv_mul(sw[10] );
    00146   fsmtmp=r2+ sw[4] ;
    00147   r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00148   r1=fsmtmp;
    00149   keystream_block[15]=(r1+ sw[15] )^r2^ sw[0] ;
    00150     //update
    00151     p->r1 = r1;
    00152     p->r2 = r2;
    00153     //p->snow_ptr = snow_ptr;
    00154     //update_sw512(p);
    00155     return edk_SUCCEEDED;
    00156 }

int WINAPI dkcSNOW2EncryptDOE | ( | DKC_SNOW2 * | p,
|  | uint8 * | dest,
|  | size_t | dsize,
|  | const uint8 * | src,
|  | size_t | ssize
| ) |

| dkcSNOW20.c の 421 行で定義されています。 参照先 dkcSNOW2EncryptNoDestDOE().
    00422 {
    00423     if(dsize < ssize){
    00424         return edk_ArgumentException;
    00425     }
    00426     if(dest != src){
    00427         memcpy(dest,src,ssize);
    00428     }
    00429     return dkcSNOW2EncryptNoDestDOE(p,dest,ssize);
    00430
    00431 }

int WINAPI dkcSNOW2EncryptNoDestDOE | ( | DKC_SNOW2 * | p,
|  | uint8 * | inout,
|  | size_t | size
| ) |

| 1byte単位で暗号化でいるSNOW2 覚え書き: dkcSNOW20.c の 473 行で定義されています。 参照先 dkcmASSERT, dkcmNOT_ASSERT, dkcSNOW2EncryptNoDestDOE(), encode_byte(), NULL, store(), dkc_SNOW2::store_size, dkc_SNOW2::u_store, と uint8. 参照元 dkcDCF01Write(), dkcSNOW2EncryptDOE(), と dkcSNOW2EncryptNoDestDOE().
    00474 {
    00475
    00476     size_t i = 0;
    00477     int r = edk_FAILED;
    00478     size_t count,rest;
    00479     uint64 *io64 = NULL;
    00480
    00481     r = encode_byte(p,inout,size,&rest);
    00482     switch(r){
    00483     case edk_SUCCEEDED:
    00484         return r;
    00485     case edk_NoValueToProcess:
    00486         break;
    00487     default:
    00488         dkcmNOT_ASSERT(DKUTIL_FAILED(r));
    00489     }
    00490     size = size - rest;
    00491     inout += rest;
    00492     if(rest == size) return edk_SUCCEEDED;
    00493     //if(size <= 0) return edk_SUCCEEDED;
    00494
    00495     count = size / 64;
    00496     rest = size % 64;//最適化に任せよう（笑）
    00497
    00498     if(64!=p->store_size){
    00499         dkcmASSERT(p->store_size ==0);
    00500         r = store(p);
    00501         dkcmNOT_ASSERT(DKUTIL_FAILED(r));
    00502     }
    00503     io64 = (uint64 *)inout;
    00504     for(i=0;i<count;i++){
    00505         //64bit単位も良いかも？
    00506         io64[0] ^= p->u_store.a64[0];
    00507         io64[1] ^= p->u_store.a64[1];
    00508         io64[2] ^= p->u_store.a64[2];
    00509         io64[3] ^= p->u_store.a64[3];
    00510         io64[4] ^= p->u_store.a64[4];
    00511         io64[5] ^= p->u_store.a64[5];
    00512         io64[6] ^= p->u_store.a64[6];
    00513         io64[7] ^= p->u_store.a64[7];
    00514
    00515         io64+=8;
    00516         p->store_size = 0;
    00517         store(p);
    00518     }
    00519     inout =(uint8*)io64;
    00520     return dkcSNOW2EncryptNoDestDOE(p,inout,rest);
    00521
    00522 }

int WINAPI dkcSNOW2Init | ( | DKC_SNOW2 * | p,
|  | uint8 * | key,
|  | size_t | keysize,
|  | uint32 | IV3,
|  | uint32 | IV2,
|  | uint32 | IV1,
|  | uint32 | IV0
| ) |

| dkcSNOW20.c の 167 行で定義されています。 参照先 a_mul, ainv_mul, NULL, dkc_SNOW2::outfrom_fsm, dkc_SNOW2::r1, dkc_SNOW2::r2, s0(), s1(), snow2_key_shake, snow_byte, snow_T0, snow_T1, snow_T2, snow_T3, store(), dkc_SNOW2::sw, と uint32. 参照元 dkcAllocSNOW2().
    00168 {
    00169     int i;
    00170
    00171     uint32 s15,s14,s13,s12,s11,s10,s9,s8,s7,s6,s5,s4,s3,s2,s1,s0;
    00172     uint32 outfrom_fsm,fsmtmp,r1,r2;
    00173
    00174     if(NULL==p || NULL==key){
    00175         return edk_ArgumentException;
    00176     }
    00177     switch(keysize)
    00178     {
    00179         case 16:
    00180             p->sw[15] = snow2_key_shake(key,0);
    00181             p->sw[14] = snow2_key_shake(key,4);
    00182             p->sw[13] = snow2_key_shake(key,8);
    00183             p->sw[12] = snow2_key_shake(key,12);
    00184             p->sw[11] = ~p->sw[15]; /* bitwip->sw[e inverp->sw[e */
    00185             p->sw[10] = ~p->sw[14];
    00186             p->sw[9]  = ~p->sw[13];
    00187             p->sw[8]  = ~p->sw[12];
    00188             p->sw[7]  = p->sw[15]; /* jup->sw[t copy */
    00189             p->sw[6]  = p->sw[14];
    00190             p->sw[5]  = p->sw[13];
    00191             p->sw[4] = p->sw[12];
    00192             p->sw[3]  =~p->sw[15]; /* bitwip->sw[e inverp->sw[e */
    00193             p->sw[2]  =~p->sw[14];
    00194             p->sw[1]  =~p->sw[13];
    00195             p->sw[0]  =~p->sw[12];
    00196             break;
    00197         case 32:
    00198             p->sw[15] = snow2_key_shake(key,0);
    00199             p->sw[14] = snow2_key_shake(key,4);
    00200             p->sw[13] = snow2_key_shake(key,8);
    00201             p->sw[12] = snow2_key_shake(key,12);
    00202             p->sw[11] = snow2_key_shake(key,16);
    00203             p->sw[10] = snow2_key_shake(key,20);
    00204             p->sw[9]  = snow2_key_shake(key,24);
    00205             p->sw[8]  = snow2_key_shake(key,28);
    00206             p->sw[7] =~p->sw[15]; // bitwip->sw[e inverp->sw[e
    00207             p->sw[6] =~p->sw[14];
    00208             p->sw[5] =~p->sw[13];
    00209             p->sw[4] =~p->sw[12];
    00210             p->sw[3] =~p->sw[11];
    00211             p->sw[2] =~p->sw[10];
    00212             p->sw[1] =~p->sw[9];
    00213             p->sw[0] =~p->sw[8];
    00214         break;
    00215         default:
    00216             return edk_ArgumentException;
    00217     }
    00218
    00219
    00220     // XOR IV values
    00221     p->sw[15]^=IV0;
    00222     p->sw[12]^=IV1;
    00223     p->sw[10]^=IV2;
    00224     p->sw[9] ^=IV3;
    00225
    00226
    00227
    00228   p->r1=0;
    00229   p->r2=0;
    00230
    00231
    00232     s15 = p->sw[15];
    00233     s14 = p->sw[14];
    00234     s13 = p->sw[13];
    00235     s12 = p->sw[12];
    00236     s11 = p->sw[11];
    00237     s10 = p->sw[10];
    00238     s9 = p->sw[9];
    00239     s8 = p->sw[8];
    00240     s7 = p->sw[7];
    00241     s6 = p->sw[6];
    00242     s5 = p->sw[5];
    00243     s4 = p->sw[4];
    00244     s3 = p->sw[3];
    00245     s2 = p->sw[2];
    00246     s1 = p->sw[1];
    00247     s0 = p->sw[0];
    00248     outfrom_fsm = p->outfrom_fsm;
    00249     r1 = p->r1;
    00250     r2 = p->r2;
    00251
    00252
    00253     for(i=0;i<2;i++)
    00254     {
    00255
    00256     outfrom_fsm=(r1+ s15 )^r2;
    00257     s0 =a_mul(s0 )^ s2 ^ainv_mul(s11 )^outfrom_fsm;
    00258     fsmtmp=r2+ s5 ;
    00259     r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00260     r1=fsmtmp;
    00261
    00262     outfrom_fsm=(r1+ s0 )^r2;
    00263     s1 =a_mul(s1 )^ s3 ^ainv_mul(s12 )^outfrom_fsm;
    00264     fsmtmp=r2+ s6 ;
    00265     r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00266     r1=fsmtmp;
    00267
    00268     outfrom_fsm=(r1+ s1 )^r2;
    00269     s2 =a_mul(s2 )^ s4 ^ainv_mul(s13 )^outfrom_fsm;
    00270     fsmtmp=r2+ s7 ;
    00271     r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00272     r1=fsmtmp;
    00273
    00274     outfrom_fsm=(r1+ s2 )^r2;
    00275     s3 =a_mul(s3 )^ s5 ^ainv_mul(s14 )^outfrom_fsm;
    00276     fsmtmp=r2+ s8 ;
    00277     r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00278     r1=fsmtmp;
    00279
    00280     outfrom_fsm=(r1+ s3 )^r2;
    00281     s4 =a_mul(s4 )^ s6 ^ainv_mul(s15 )^outfrom_fsm;
    00282     fsmtmp=r2+ s9 ;
    00283     r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00284     r1=fsmtmp;
    00285
    00286     outfrom_fsm=(r1+ s4 )^r2;
    00287     s5 =a_mul(s5 )^ s7 ^ainv_mul(s0 )^outfrom_fsm;
    00288     fsmtmp=r2+ s10 ;
    00289     r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00290     r1=fsmtmp;
    00291
    00292     outfrom_fsm=(r1+ s5 )^r2;
    00293     s6 =a_mul(s6 )^ s8 ^ainv_mul(s1 )^outfrom_fsm;
    00294     fsmtmp=r2+ s11 ;
    00295     r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00296     r1=fsmtmp;
    00297
    00298     outfrom_fsm=(r1+ s6 )^r2;
    00299     s7 =a_mul(s7 )^ s9 ^ainv_mul(s2 )^outfrom_fsm;
    00300     fsmtmp=r2+ s12 ;
    00301     r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00302     r1=fsmtmp;
    00303
    00304     outfrom_fsm=(r1+ s7 )^r2;
    00305     s8 =a_mul(s8 )^ s10 ^ainv_mul(s3 )^outfrom_fsm;
    00306     fsmtmp=r2+ s13 ;
    00307     r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00308     r1=fsmtmp;
    00309
    00310     outfrom_fsm=(r1+ s8 )^r2;
    00311     s9 =a_mul(s9 )^ s11 ^ainv_mul(s4 )^outfrom_fsm;
    00312     fsmtmp=r2+ s14 ;
    00313     r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00314     r1=fsmtmp;
    00315
    00316     outfrom_fsm=(r1+ s9 )^r2;
    00317     s10 =a_mul(s10 )^ s12 ^ainv_mul(s5 )^outfrom_fsm;
    00318     fsmtmp=r2+ s15 ;
    00319     r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00320     r1=fsmtmp;
    00321
    00322     outfrom_fsm=(r1+ s10 )^r2;
    00323     s11 =a_mul(s11 )^ s13 ^ainv_mul(s6 )^outfrom_fsm;
    00324     fsmtmp=r2+ s0 ;
    00325     r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00326     r1=fsmtmp;
    00327
    00328     outfrom_fsm=(r1+ s11 )^r2;
    00329     s12 =a_mul(s12 )^ s14 ^ainv_mul(s7 )^outfrom_fsm;
    00330     fsmtmp=r2+ s1 ;
    00331     r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00332     r1=fsmtmp;
    00333
    00334     outfrom_fsm=(r1+ s12 )^r2;
    00335     s13 =a_mul(s13 )^ s15 ^ainv_mul(s8 )^outfrom_fsm;
    00336     fsmtmp=r2+ s2 ;
    00337     r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00338     r1=fsmtmp;
    00339
    00340     outfrom_fsm=(r1+ s13 )^r2;
    00341     s14 =a_mul(s14 )^ s0 ^ainv_mul(s9 )^outfrom_fsm;
    00342     fsmtmp=r2+ s3 ;
    00343     r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00344     r1=fsmtmp;
    00345
    00346     outfrom_fsm=(r1+ s14 )^r2;
    00347     s15 =a_mul(s15 )^ s1 ^ainv_mul(s10 )^outfrom_fsm;
    00348     fsmtmp=r2+ s4 ;
    00349     r2=snow_T0[snow_byte(0,r1)]^snow_T1[snow_byte(1,r1)]^snow_T2[snow_byte(2,r1)]^snow_T3[snow_byte(3,r1)];
    00350     r1=fsmtmp;
    00351   }
    00352     p->sw[15] = s15  ;
    00353     p->sw[14] = s14  ;
    00354     p->sw[13] = s13  ;
    00355     p->sw[12] = s12  ;
    00356     p->sw[11] = s11  ;
    00357     p->sw[10] = s10  ;
    00358     p->sw[9] = s9  ;
    00359     p->sw[8] = s8  ;
    00360     p->sw[7] = s7  ;
    00361     p->sw[6] = s6 ;
    00362     p->sw[5] = s5;
    00363     p->sw[4] = s4  ;
    00364     p->sw[3] = s3  ;
    00365     p->sw[2] = s2 ;
    00366     p->sw[1] = s1  ;
    00367     p->sw[0] = s0  ;
    00368     p->outfrom_fsm = outfrom_fsm ;
    00369     p->r1 = r1  ;
    00370     p->r2 = r2;
    00371     return store(p);
    00372 }

DKC_INLINE uint8 WINAPI dkcSNOW2Process | ( | DKC_SNOW2 * | p | ) |

| 1byteの暗号化用ストリームを生成する dkcSNOW20.c の 406 行で定義されています。 参照先 dkcmNOT_ASSERT, get_offset, store(), dkc_SNOW2::store_size, と dkc_SNOW2::u_store.
    00406                                                      {
    00407     int r = 0;
    00408     size_t offset;
    00409     //DKC_4BYTE_LITTLE_ENDIAN_BASE a;
    00410     if(p->store_size <=0){
    00411         r = store(p);
    00412         dkcmNOT_ASSERT(DKUTIL_FAILED(r));
    00413     }
    00414     offset = get_offset(p);
    00415     p->store_size--;
    00416     return p->u_store.a8[offset];
    00417 }

static DKC_INLINE int encode_byte | ( | DKC_SNOW2 * | p,
|  | uint8 * | inout,
|  | size_t | size,
|  | size_t * | nextoffset
| ) | `[static]`

| dkcSNOW20.c の 435 行で定義されています。 参照先 dkcmNOT_ASSERT, dkcSNOW2_Byte, store(), と dkc_SNOW2::store_size.
    00436 {
    00437     size_t i=0;
    00438     int r;
    00439     if(size <= 0){
    00440         r =  edk_SUCCEEDED;
    00441         goto End;
    00442     }
    00443     if((size > 64) && ( p->store_size == 0 || 64==p->store_size)){
    00444     //if((size > 8) && ( p->store_size == 0 || 8==p->store_size)){
    00445         r = edk_NoValueToProcess;
    00446         goto End;
    00447     }
    00448     if(p->store_size ==0){
    00449         r = store(p);
    00450         dkcmNOT_ASSERT(DKUTIL_FAILED(r));
    00451     }
    00452     for(i=0;i<size;i++){
    00453         inout[i] ^= dkcSNOW2_Byte(p);
    00454         if(p->store_size ==0){
    00455             //if(size - (i+1) >= 64){//(i + 1)かも？
    00456             if(size - i > 64){
    00457                 r = edk_NoValueToProcess;
    00458                 i++;
    00459                 goto End;
    00460             }
    00461             r = store(p);
    00462             dkcmNOT_ASSERT(DKUTIL_FAILED(r));
    00463         }
    00464     }
    00465     r = edk_SUCCEEDED;
    00466 End:
    00467     *nextoffset = i;
    00468     return r;
    00469 }

static DKC_INLINE int store | ( | DKC_SNOW2 * | p | ) | `[static]`

| dkcSNOW20.c の 158 行で定義されています。 参照先 dkcmNOT_ASSERT, dkcSNOW2_64Byte(), dkc_SNOW2::store_size, と dkc_SNOW2::u_store.
    00158                                          {
    00159     int r;
    00160     dkcmNOT_ASSERT(0 != p->store_size);
    00161     if(0 != p->store_size) return edk_LogicError;
    00162     r = dkcSNOW2_64Byte(p,p->u_store.a32);
    00163     p->store_size = 64;
    00164     return r;
    00165 }