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

# dkcSNOW20.h

SNOW2.0 steram cipher Algorithm [詳細]

`#include "dkcOSIndependent.h"`

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

このグラフは、どのファイルから直接、間接的にインクルードされているかを示しています。

ソースコードを見る。

## 構成
struct | dkc_SNOW2
## マクロ定義
#define | dkcdSNOW2_BOX_SIZE 16
#define | dkcSNOW2_Byte(p) dkcSNOW2Process(p)
#define | dkcSNOW2DecryptDOE(a, b, c, d, e) dkcSNOW2EncryptDOE(a,b,c,d,e)
#define | dkcSNOW2DecryptNoDestDOE(a, b, c) dkcSNOW2EncryptNoDestDOE(a,b,c)
## 型定義
typedef dkc_SNOW2 | DKC_SNOW2
## 関数
DKC_EXTERN DKC_SNOW2 *WINAPI | dkcAllocSNOW2 (BYTE *key, size_t keysize, uint32 IV3, uint32 IV2, uint32 IV1, uint32 IV0)
DKC_EXTERN int WINAPI | dkcSNOW2Init (DKC_SNOW2 *p, uint8 *key, size_t keysize, uint32 IV3, uint32 IV2, uint32 IV1, uint32 IV0)
DKC_INLINE DKC_SNOW2 * | dkcAllocSNOW2Const (const BYTE *key, size_t keysize, uint32 IV3, uint32 IV2, uint32 IV1, uint32 IV0)
DKC_EXTERN int WINAPI | dkcFreeSNOW2 (DKC_SNOW2 **)
DKC_EXTERN uint8 WINAPI | dkcSNOW2Process (DKC_SNOW2 *p)
| 1byteの暗号化用ストリームを生成する
DKC_EXTERN int WINAPI | dkcSNOW2EncryptNoDestDOE (DKC_SNOW2 *p, uint8 *inout, size_t size)
| 1byte単位で暗号化でいるSNOW2
DKC_EXTERN int WINAPI | dkcSNOW2EncryptDOE (DKC_SNOW2 *, uint8 *dest, size_t dsize, const uint8 *src, size_t ssize)

## 説明

SNOW2.0 steram cipher Algorithm

から:
  2004/12/31

覚え書き:
  参考資料： http://www.it.lth.se/cryptology/snow/

TODO:
  endianがビッグでもリトルでも、その他でも出力結果が同じで動くかどうかを確かめること

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

## マクロ定義

#define dkcdSNOW2_BOX_SIZE 16

| dkcSNOW20.h の 21 行で定義されています。

#define dkcSNOW2_Byte | ( | p |  | ) | dkcSNOW2Process(p)

| dkcSNOW20.h の 79 行で定義されています。 参照元 encode_byte().

#define dkcSNOW2DecryptDOE | ( | a,
|  | b,
|  | c,
|  | d,
|  | e |  | ) | dkcSNOW2EncryptDOE(a,b,c,d,e)

| dkcSNOW20.h の 87 行で定義されています。

#define dkcSNOW2DecryptNoDestDOE | ( | a,
|  | b,
|  | c |  | ) | dkcSNOW2EncryptNoDestDOE(a,b,c)

| dkcSNOW20.h の 89 行で定義されています。 参照元 dkcDCF01Read().

## 型定義

typedef struct dkc_SNOW2 DKC_SNOW2

## 関数

DKC_EXTERN 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 }

DKC_INLINE DKC_SNOW2* dkcAllocSNOW2Const | ( | const BYTE * | key,
|  | size_t | keysize,
|  | uint32 | IV3,
|  | uint32 | IV2,
|  | uint32 | IV1,
|  | uint32 | IV0
| ) |

| dkcSNOW20.h の 58 行で定義されています。 参照先 dkcAllocSNOW2(), NULL, と uint8.
    00059 {
    00060     uint8 v[32];
    00061     switch(keysize){
    00062     case 16:
    00063         memcpy(v,key,16);
    00064         memset(&v[16],0,16);
    00065         break;
    00066     case 32:
    00067         memcpy(v,key,32);
    00068         break;
    00069     default:
    00070         return NULL;
    00071     }
    00072     return dkcAllocSNOW2(v,keysize,IV3,IV2,IV1,IV0);
    00073 }

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

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

DKC_EXTERN int WINAPI dkcSNOW2EncryptDOE | ( | DKC_SNOW2 * | ,
|  | 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 }

DKC_EXTERN 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 }

DKC_EXTERN 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_EXTERN 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 }