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

dkcSNOW20.c

SNOW2.0 cipher Algorithm [詳細]

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

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

ソースコードを見る。

マクロ定義

#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 dkcSNOW2_Byte (DKC_SNOW2 *p)
 1byteの暗号化用ストリームを生成する
int WINAPI dkcSNOW2EncryptDOE (DKC_SNOW2 *p, uint8 *dest, size_t dsize, const uint8 *src, size_t ssize)
int WINAPI dkcSNOW2EncryptNoDestDOE (DKC_SNOW2 *p, uint8 *inout, size_t size)
 1byte単位で暗号化でいるSNOW2


説明

SNOW2.0 cipher Algorithm

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

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


マクロ定義

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

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

参照元 dkcSNOW2_64Byte(), と dkcSNOW2Init().

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

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

参照元 dkcSNOW2_64Byte(), と dkcSNOW2Init().

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

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

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

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

参照元 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.c375 行で定義されています。

参照先 dkcAllocate(), dkcFreeSNOW2(), dkcSNOW2Init(), NULL, と dkc_SNOW2::store_size.

参照元 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.c398 行で定義されています。

参照先 dkcFree().

参照元 dkcAllocSNOW2().

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.c47 行で定義されています。

参照先 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.

参照元 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 }

DKC_INLINE uint8 WINAPI dkcSNOW2_Byte DKC_SNOW2 p  ) 
 

1byteの暗号化用ストリームを生成する

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

参照先 dkcmNOT_ASSERT, get_offset, store(), dkc_SNOW2::store_size, と dkc_SNOW2::u_store.

参照元 dkcSNOW2EncryptNoDestDOE().

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 }

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

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

参照先 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.c434 行で定義されています。

参照先 dkcmNOT_ASSERT, dkcSNOW2_Byte(), dkcSNOW2EncryptNoDestDOE(), store(), dkc_SNOW2::store_size, と dkc_SNOW2::u_store.

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

00435 {
00436 
00437 
00438 
00439     size_t i;
00440     int r;
00441     size_t count,rest;
00442     //uint32 *io32;
00443     uint64 *io64;
00444     //残り物処分
00445     if(size <= 0) return edk_SUCCEEDED;
00446     for(i=0;;){//for scope
00447         if((size > 64) && ( p->store_size == 0 || 64==p->store_size)){
00448             break;
00449         }
00450         for(;i<size;i++){
00451             inout[i] ^= dkcSNOW2_Byte(p);
00452             if(p->store_size == 0){
00453                 break;
00454             }
00455         }
00456         break;
00457     }
00458     size-=i;
00459     inout+=i;
00460     if(size <= 0) return edk_SUCCEEDED;
00461 
00462     count = size / 64;
00463     rest = size % 64;//最適化に任せよう(笑)
00464     if(64!=p->store_size){
00465         r = store(p);
00466         dkcmNOT_ASSERT(DKUTIL_FAILED(r));
00467     }
00468     //io32 = (uint32 *)inout;
00469     io64 =(uint64*)inout;
00470     for(;i<count;i++){
00471         //64bit単位も良いかも?
00472         /*io32[0] ^= p->u_store.a32[0];
00473         io32[1] ^= p->u_store.a32[1];
00474         io32[2] ^= p->u_store.a32[2];
00475         io32[3] ^= p->u_store.a32[3];
00476         io32[4] ^= p->u_store.a32[4];
00477         io32[5] ^= p->u_store.a32[5];
00478         io32[6] ^= p->u_store.a32[6];
00479         io32[7] ^= p->u_store.a32[7];
00480         io32[8] ^= p->u_store.a32[8];
00481         io32[9] ^= p->u_store.a32[9];
00482         io32[10] ^= p->u_store.a32[10];
00483         io32[11] ^= p->u_store.a32[11];
00484         io32[12] ^= p->u_store.a32[12];
00485         io32[13] ^= p->u_store.a32[13];
00486         io32[14] ^= p->u_store.a32[14];
00487         io32[15] ^= p->u_store.a32[15];
00488         
00489         io32+=16;*/
00490         io64[0] ^= p->u_store.a64[0];
00491         io64[1] ^= p->u_store.a64[1];
00492         io64[2] ^= p->u_store.a64[2];
00493         io64[3] ^= p->u_store.a64[3];
00494         io64[4] ^= p->u_store.a64[4];
00495         io64[5] ^= p->u_store.a64[5];
00496         io64[6] ^= p->u_store.a64[6];
00497         io64[7] ^= p->u_store.a64[7];
00498         io64+=8;
00499         p->store_size = 0;
00500         store(p);
00501     }
00502     //inout =(uint8*)io32;
00503         inout =(uint8*)io64;
00504     return dkcSNOW2EncryptNoDestDOE(p,inout,rest);
00505 
00506 }

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

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

参照先 a_mul, ainv_mul, NULL, dkc_SNOW2::outfrom_fsm, dkc_SNOW2::r1, dkc_SNOW2::r2, s0(), s1(), snow_byte, snow_T0, snow_T1, snow_T2, snow_T3, store(), と dkc_SNOW2::sw.

参照元 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 }

static DKC_INLINE int store DKC_SNOW2 p  )  [static]
 

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

参照先 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 }


dkutil_cに対してSat Sep 10 09:25:09 2005に生成されました。  doxygen 1.4.4