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

rijndael-alg-fst.h

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

Included by dependency graph

ソースコードを見る。

マクロ定義

#define MAXKC   (256/32)
 rijndael-alg-fst.h

#define MAXKB   (256/8)
#define MAXNR   14

型定義

typedef unsigned char u8
typedef unsigned short u16
typedef unsigned int u32

関数

int rijndaelKeySetupEnc (u32 rk[], const u8 cipherKey[], int keyBits)
 Expand the cipher key into the encryption key schedule.

int rijndaelKeySetupDec (u32 rk[], const u8 cipherKey[], int keyBits)
 Expand the cipher key into the decryption key schedule.

void rijndaelEncrypt (const u32 rk[], int Nr, const u8 pt[16], u8 ct[16])
void rijndaelDecrypt (const u32 rk[], int Nr, const u8 ct[16], u8 pt[16])


マクロ定義

#define MAXKB   (256/8)
 

rijndael-alg-fst.h30 行で定義されています。

参照元 makeKey().

#define MAXKC   (256/32)
 

rijndael-alg-fst.h

バージョン:
3.0 (December 2000)
Optimised ANSI C code for the Rijndael cipher (now AES)

作者:
Vincent Rijmen <vincent.rijmen@esat.kuleuven.ac.be>

Antoon Bosselaers <antoon.bosselaers@esat.kuleuven.ac.be>

Paulo Barreto <paulo.barreto@terra.com.br>

This code is hereby placed in the public domain.

THIS SOFTWARE IS PROVIDED BY THE AUTHORS ''AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

rijndael-alg-fst.h29 行で定義されています。

#define MAXNR   14
 

rijndael-alg-fst.h31 行で定義されています。


型定義

typedef unsigned short u16
 

rijndael-alg-fst.h34 行で定義されています。

typedef unsigned int u32
 

rijndael-alg-fst.h35 行で定義されています。

参照元 blockDecrypt(), blockEncrypt(), padDecrypt(), padEncrypt(), rijndaelDecrypt(), rijndaelEncrypt(), rijndaelKeySetupDec(), と rijndaelKeySetupEnc().

typedef unsigned char u8
 

rijndael-alg-fst.h33 行で定義されています。

参照元 blockDecrypt(), blockEncrypt(), cipherInit(), makeKey(), padDecrypt(), padEncrypt(), rijndaelDecrypt(), rijndaelEncrypt(), rijndaelKeySetupDec(), と rijndaelKeySetupEnc().


関数

void rijndaelDecrypt const u32  rk[],
int  Nr,
const u8  ct[16],
u8  pt[16]
 

rijndael-alg-fst.c1036 行で定義されています。

参照先 GETU32, PUTU32, Td0, Td1, Td2, Td3, Td4, u32, と u8.

参照元 blockDecrypt(), と padDecrypt().

01036                                                                                          {
01037     u32 s0, s1, s2, s3, t0, t1, t2, t3;
01038     u32 *rk = (u32 *)rk_t;
01039 #ifndef FULL_UNROLL
01040     int r;
01041 #endif /* ?FULL_UNROLL */
01042 
01043     /*
01044      * map byte array block to cipher state
01045      * and add initial round key:
01046      */
01047     s0 = GETU32(ct     ) ^ rk[0];
01048     s1 = GETU32(ct +  4) ^ rk[1];
01049     s2 = GETU32(ct +  8) ^ rk[2];
01050     s3 = GETU32(ct + 12) ^ rk[3];
01051 #ifdef FULL_UNROLL
01052     /* round 1: */
01053     t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >>  8) & 0xff] ^ Td3[s1 & 0xff] ^ rk[ 4];
01054     t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >>  8) & 0xff] ^ Td3[s2 & 0xff] ^ rk[ 5];
01055     t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >>  8) & 0xff] ^ Td3[s3 & 0xff] ^ rk[ 6];
01056     t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >>  8) & 0xff] ^ Td3[s0 & 0xff] ^ rk[ 7];
01057     /* round 2: */
01058     s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >>  8) & 0xff] ^ Td3[t1 & 0xff] ^ rk[ 8];
01059     s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >>  8) & 0xff] ^ Td3[t2 & 0xff] ^ rk[ 9];
01060     s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >>  8) & 0xff] ^ Td3[t3 & 0xff] ^ rk[10];
01061     s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >>  8) & 0xff] ^ Td3[t0 & 0xff] ^ rk[11];
01062     /* round 3: */
01063     t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >>  8) & 0xff] ^ Td3[s1 & 0xff] ^ rk[12];
01064     t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >>  8) & 0xff] ^ Td3[s2 & 0xff] ^ rk[13];
01065     t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >>  8) & 0xff] ^ Td3[s3 & 0xff] ^ rk[14];
01066     t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >>  8) & 0xff] ^ Td3[s0 & 0xff] ^ rk[15];
01067     /* round 4: */
01068     s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >>  8) & 0xff] ^ Td3[t1 & 0xff] ^ rk[16];
01069     s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >>  8) & 0xff] ^ Td3[t2 & 0xff] ^ rk[17];
01070     s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >>  8) & 0xff] ^ Td3[t3 & 0xff] ^ rk[18];
01071     s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >>  8) & 0xff] ^ Td3[t0 & 0xff] ^ rk[19];
01072     /* round 5: */
01073     t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >>  8) & 0xff] ^ Td3[s1 & 0xff] ^ rk[20];
01074     t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >>  8) & 0xff] ^ Td3[s2 & 0xff] ^ rk[21];
01075     t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >>  8) & 0xff] ^ Td3[s3 & 0xff] ^ rk[22];
01076     t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >>  8) & 0xff] ^ Td3[s0 & 0xff] ^ rk[23];
01077     /* round 6: */
01078     s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >>  8) & 0xff] ^ Td3[t1 & 0xff] ^ rk[24];
01079     s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >>  8) & 0xff] ^ Td3[t2 & 0xff] ^ rk[25];
01080     s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >>  8) & 0xff] ^ Td3[t3 & 0xff] ^ rk[26];
01081     s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >>  8) & 0xff] ^ Td3[t0 & 0xff] ^ rk[27];
01082     /* round 7: */
01083     t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >>  8) & 0xff] ^ Td3[s1 & 0xff] ^ rk[28];
01084     t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >>  8) & 0xff] ^ Td3[s2 & 0xff] ^ rk[29];
01085     t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >>  8) & 0xff] ^ Td3[s3 & 0xff] ^ rk[30];
01086     t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >>  8) & 0xff] ^ Td3[s0 & 0xff] ^ rk[31];
01087     /* round 8: */
01088     s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >>  8) & 0xff] ^ Td3[t1 & 0xff] ^ rk[32];
01089     s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >>  8) & 0xff] ^ Td3[t2 & 0xff] ^ rk[33];
01090     s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >>  8) & 0xff] ^ Td3[t3 & 0xff] ^ rk[34];
01091     s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >>  8) & 0xff] ^ Td3[t0 & 0xff] ^ rk[35];
01092     /* round 9: */
01093     t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >>  8) & 0xff] ^ Td3[s1 & 0xff] ^ rk[36];
01094     t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >>  8) & 0xff] ^ Td3[s2 & 0xff] ^ rk[37];
01095     t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >>  8) & 0xff] ^ Td3[s3 & 0xff] ^ rk[38];
01096     t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >>  8) & 0xff] ^ Td3[s0 & 0xff] ^ rk[39];
01097     if (Nr > 10) {
01098         /* round 10: */
01099         s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >>  8) & 0xff] ^ Td3[t1 & 0xff] ^ rk[40];
01100         s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >>  8) & 0xff] ^ Td3[t2 & 0xff] ^ rk[41];
01101         s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >>  8) & 0xff] ^ Td3[t3 & 0xff] ^ rk[42];
01102         s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >>  8) & 0xff] ^ Td3[t0 & 0xff] ^ rk[43];
01103         /* round 11: */
01104         t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >>  8) & 0xff] ^ Td3[s1 & 0xff] ^ rk[44];
01105         t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >>  8) & 0xff] ^ Td3[s2 & 0xff] ^ rk[45];
01106         t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >>  8) & 0xff] ^ Td3[s3 & 0xff] ^ rk[46];
01107         t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >>  8) & 0xff] ^ Td3[s0 & 0xff] ^ rk[47];
01108         if (Nr > 12) {
01109             /* round 12: */
01110             s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >>  8) & 0xff] ^ Td3[t1 & 0xff] ^ rk[48];
01111             s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >>  8) & 0xff] ^ Td3[t2 & 0xff] ^ rk[49];
01112             s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >>  8) & 0xff] ^ Td3[t3 & 0xff] ^ rk[50];
01113             s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >>  8) & 0xff] ^ Td3[t0 & 0xff] ^ rk[51];
01114             /* round 13: */
01115             t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >>  8) & 0xff] ^ Td3[s1 & 0xff] ^ rk[52];
01116             t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >>  8) & 0xff] ^ Td3[s2 & 0xff] ^ rk[53];
01117             t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >>  8) & 0xff] ^ Td3[s3 & 0xff] ^ rk[54];
01118             t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >>  8) & 0xff] ^ Td3[s0 & 0xff] ^ rk[55];
01119         }
01120     }
01121     rk += Nr << 2;
01122 #else  /* !FULL_UNROLL */
01123     /*
01124      * Nr - 1 full rounds:
01125      */
01126     r = Nr >> 1;
01127     for (;;) {
01128         t0 =
01129             Td0[(s0 >> 24)       ] ^
01130             Td1[(s3 >> 16) & 0xff] ^
01131             Td2[(s2 >>  8) & 0xff] ^
01132             Td3[(s1      ) & 0xff] ^
01133             rk[4];
01134         t1 =
01135             Td0[(s1 >> 24)       ] ^
01136             Td1[(s0 >> 16) & 0xff] ^
01137             Td2[(s3 >>  8) & 0xff] ^
01138             Td3[(s2      ) & 0xff] ^
01139             rk[5];
01140         t2 =
01141             Td0[(s2 >> 24)       ] ^
01142             Td1[(s1 >> 16) & 0xff] ^
01143             Td2[(s0 >>  8) & 0xff] ^
01144             Td3[(s3      ) & 0xff] ^
01145             rk[6];
01146         t3 =
01147             Td0[(s3 >> 24)       ] ^
01148             Td1[(s2 >> 16) & 0xff] ^
01149             Td2[(s1 >>  8) & 0xff] ^
01150             Td3[(s0      ) & 0xff] ^
01151             rk[7];
01152 
01153         rk += 8;
01154         if (--r == 0) {
01155             break;
01156         }
01157 
01158         s0 =
01159             Td0[(t0 >> 24)       ] ^
01160             Td1[(t3 >> 16) & 0xff] ^
01161             Td2[(t2 >>  8) & 0xff] ^
01162             Td3[(t1      ) & 0xff] ^
01163             rk[0];
01164         s1 =
01165             Td0[(t1 >> 24)       ] ^
01166             Td1[(t0 >> 16) & 0xff] ^
01167             Td2[(t3 >>  8) & 0xff] ^
01168             Td3[(t2      ) & 0xff] ^
01169             rk[1];
01170         s2 =
01171             Td0[(t2 >> 24)       ] ^
01172             Td1[(t1 >> 16) & 0xff] ^
01173             Td2[(t0 >>  8) & 0xff] ^
01174             Td3[(t3      ) & 0xff] ^
01175             rk[2];
01176         s3 =
01177             Td0[(t3 >> 24)       ] ^
01178             Td1[(t2 >> 16) & 0xff] ^
01179             Td2[(t1 >>  8) & 0xff] ^
01180             Td3[(t0      ) & 0xff] ^
01181             rk[3];
01182     }
01183 #endif /* ?FULL_UNROLL */
01184     /*
01185      * apply last round and
01186      * map cipher state to byte array block:
01187      */
01188     s0 =
01189         (Td4[(t0 >> 24)       ] & 0xff000000) ^
01190         (Td4[(t3 >> 16) & 0xff] & 0x00ff0000) ^
01191         (Td4[(t2 >>  8) & 0xff] & 0x0000ff00) ^
01192         (Td4[(t1      ) & 0xff] & 0x000000ff) ^
01193         rk[0];
01194     PUTU32(pt     , s0);
01195     s1 =
01196         (Td4[(t1 >> 24)       ] & 0xff000000) ^
01197         (Td4[(t0 >> 16) & 0xff] & 0x00ff0000) ^
01198         (Td4[(t3 >>  8) & 0xff] & 0x0000ff00) ^
01199         (Td4[(t2      ) & 0xff] & 0x000000ff) ^
01200         rk[1];
01201     PUTU32(pt +  4, s1);
01202     s2 =
01203         (Td4[(t2 >> 24)       ] & 0xff000000) ^
01204         (Td4[(t1 >> 16) & 0xff] & 0x00ff0000) ^
01205         (Td4[(t0 >>  8) & 0xff] & 0x0000ff00) ^
01206         (Td4[(t3      ) & 0xff] & 0x000000ff) ^
01207         rk[2];
01208     PUTU32(pt +  8, s2);
01209     s3 =
01210         (Td4[(t3 >> 24)       ] & 0xff000000) ^
01211         (Td4[(t2 >> 16) & 0xff] & 0x00ff0000) ^
01212         (Td4[(t1 >>  8) & 0xff] & 0x0000ff00) ^
01213         (Td4[(t0      ) & 0xff] & 0x000000ff) ^
01214         rk[3];
01215     PUTU32(pt + 12, s3);
01216 }

void rijndaelEncrypt const u32  rk[],
int  Nr,
const u8  pt[16],
u8  ct[16]
 

rijndael-alg-fst.c854 行で定義されています。

参照先 GETU32, PUTU32, Te0, Te1, Te2, Te3, Te4, u32, と u8.

参照元 blockDecrypt(), blockEncrypt(), と padEncrypt().

00854                                                                                          {
00855     u32 s0, s1, s2, s3, t0, t1, t2, t3;
00856     u32 *rk = (u32 *)rk_t;
00857 #ifndef FULL_UNROLL
00858     int r;
00859 #endif /* ?FULL_UNROLL */
00860 
00861     /*
00862      * map byte array block to cipher state
00863      * and add initial round key:
00864      */
00865     s0 = GETU32(pt     ) ^ rk[0];
00866     s1 = GETU32(pt +  4) ^ rk[1];
00867     s2 = GETU32(pt +  8) ^ rk[2];
00868     s3 = GETU32(pt + 12) ^ rk[3];
00869 #ifdef FULL_UNROLL
00870     /* round 1: */
00871     t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >>  8) & 0xff] ^ Te3[s3 & 0xff] ^ rk[ 4];
00872     t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >>  8) & 0xff] ^ Te3[s0 & 0xff] ^ rk[ 5];
00873     t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >>  8) & 0xff] ^ Te3[s1 & 0xff] ^ rk[ 6];
00874     t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >>  8) & 0xff] ^ Te3[s2 & 0xff] ^ rk[ 7];
00875     /* round 2: */
00876     s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >>  8) & 0xff] ^ Te3[t3 & 0xff] ^ rk[ 8];
00877     s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >>  8) & 0xff] ^ Te3[t0 & 0xff] ^ rk[ 9];
00878     s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >>  8) & 0xff] ^ Te3[t1 & 0xff] ^ rk[10];
00879     s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >>  8) & 0xff] ^ Te3[t2 & 0xff] ^ rk[11];
00880     /* round 3: */
00881     t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >>  8) & 0xff] ^ Te3[s3 & 0xff] ^ rk[12];
00882     t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >>  8) & 0xff] ^ Te3[s0 & 0xff] ^ rk[13];
00883     t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >>  8) & 0xff] ^ Te3[s1 & 0xff] ^ rk[14];
00884     t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >>  8) & 0xff] ^ Te3[s2 & 0xff] ^ rk[15];
00885     /* round 4: */
00886     s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >>  8) & 0xff] ^ Te3[t3 & 0xff] ^ rk[16];
00887     s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >>  8) & 0xff] ^ Te3[t0 & 0xff] ^ rk[17];
00888     s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >>  8) & 0xff] ^ Te3[t1 & 0xff] ^ rk[18];
00889     s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >>  8) & 0xff] ^ Te3[t2 & 0xff] ^ rk[19];
00890     /* round 5: */
00891     t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >>  8) & 0xff] ^ Te3[s3 & 0xff] ^ rk[20];
00892     t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >>  8) & 0xff] ^ Te3[s0 & 0xff] ^ rk[21];
00893     t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >>  8) & 0xff] ^ Te3[s1 & 0xff] ^ rk[22];
00894     t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >>  8) & 0xff] ^ Te3[s2 & 0xff] ^ rk[23];
00895     /* round 6: */
00896     s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >>  8) & 0xff] ^ Te3[t3 & 0xff] ^ rk[24];
00897     s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >>  8) & 0xff] ^ Te3[t0 & 0xff] ^ rk[25];
00898     s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >>  8) & 0xff] ^ Te3[t1 & 0xff] ^ rk[26];
00899     s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >>  8) & 0xff] ^ Te3[t2 & 0xff] ^ rk[27];
00900     /* round 7: */
00901     t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >>  8) & 0xff] ^ Te3[s3 & 0xff] ^ rk[28];
00902     t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >>  8) & 0xff] ^ Te3[s0 & 0xff] ^ rk[29];
00903     t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >>  8) & 0xff] ^ Te3[s1 & 0xff] ^ rk[30];
00904     t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >>  8) & 0xff] ^ Te3[s2 & 0xff] ^ rk[31];
00905     /* round 8: */
00906     s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >>  8) & 0xff] ^ Te3[t3 & 0xff] ^ rk[32];
00907     s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >>  8) & 0xff] ^ Te3[t0 & 0xff] ^ rk[33];
00908     s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >>  8) & 0xff] ^ Te3[t1 & 0xff] ^ rk[34];
00909     s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >>  8) & 0xff] ^ Te3[t2 & 0xff] ^ rk[35];
00910     /* round 9: */
00911     t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >>  8) & 0xff] ^ Te3[s3 & 0xff] ^ rk[36];
00912     t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >>  8) & 0xff] ^ Te3[s0 & 0xff] ^ rk[37];
00913     t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >>  8) & 0xff] ^ Te3[s1 & 0xff] ^ rk[38];
00914     t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >>  8) & 0xff] ^ Te3[s2 & 0xff] ^ rk[39];
00915     if (Nr > 10) {
00916         /* round 10: */
00917         s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >>  8) & 0xff] ^ Te3[t3 & 0xff] ^ rk[40];
00918         s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >>  8) & 0xff] ^ Te3[t0 & 0xff] ^ rk[41];
00919         s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >>  8) & 0xff] ^ Te3[t1 & 0xff] ^ rk[42];
00920         s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >>  8) & 0xff] ^ Te3[t2 & 0xff] ^ rk[43];
00921         /* round 11: */
00922         t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >>  8) & 0xff] ^ Te3[s3 & 0xff] ^ rk[44];
00923         t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >>  8) & 0xff] ^ Te3[s0 & 0xff] ^ rk[45];
00924         t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >>  8) & 0xff] ^ Te3[s1 & 0xff] ^ rk[46];
00925         t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >>  8) & 0xff] ^ Te3[s2 & 0xff] ^ rk[47];
00926         if (Nr > 12) {
00927             /* round 12: */
00928             s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >>  8) & 0xff] ^ Te3[t3 & 0xff] ^ rk[48];
00929             s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >>  8) & 0xff] ^ Te3[t0 & 0xff] ^ rk[49];
00930             s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >>  8) & 0xff] ^ Te3[t1 & 0xff] ^ rk[50];
00931             s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >>  8) & 0xff] ^ Te3[t2 & 0xff] ^ rk[51];
00932             /* round 13: */
00933             t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >>  8) & 0xff] ^ Te3[s3 & 0xff] ^ rk[52];
00934             t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >>  8) & 0xff] ^ Te3[s0 & 0xff] ^ rk[53];
00935             t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >>  8) & 0xff] ^ Te3[s1 & 0xff] ^ rk[54];
00936             t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >>  8) & 0xff] ^ Te3[s2 & 0xff] ^ rk[55];
00937         }
00938     }
00939     rk += Nr << 2;
00940 #else  /* !FULL_UNROLL */
00941     /*
00942      * Nr - 1 full rounds:
00943      */
00944     r = Nr >> 1;
00945     for (;;) {
00946         t0 =
00947             Te0[(s0 >> 24)       ] ^
00948             Te1[(s1 >> 16) & 0xff] ^
00949             Te2[(s2 >>  8) & 0xff] ^
00950             Te3[(s3      ) & 0xff] ^
00951             rk[4];
00952         t1 =
00953             Te0[(s1 >> 24)       ] ^
00954             Te1[(s2 >> 16) & 0xff] ^
00955             Te2[(s3 >>  8) & 0xff] ^
00956             Te3[(s0      ) & 0xff] ^
00957             rk[5];
00958         t2 =
00959             Te0[(s2 >> 24)       ] ^
00960             Te1[(s3 >> 16) & 0xff] ^
00961             Te2[(s0 >>  8) & 0xff] ^
00962             Te3[(s1      ) & 0xff] ^
00963             rk[6];
00964         t3 =
00965             Te0[(s3 >> 24)       ] ^
00966             Te1[(s0 >> 16) & 0xff] ^
00967             Te2[(s1 >>  8) & 0xff] ^
00968             Te3[(s2      ) & 0xff] ^
00969             rk[7];
00970 
00971         rk += 8;
00972         if (--r == 0) {
00973             break;
00974         }
00975 
00976         s0 =
00977             Te0[(t0 >> 24)       ] ^
00978             Te1[(t1 >> 16) & 0xff] ^
00979             Te2[(t2 >>  8) & 0xff] ^
00980             Te3[(t3      ) & 0xff] ^
00981             rk[0];
00982         s1 =
00983             Te0[(t1 >> 24)       ] ^
00984             Te1[(t2 >> 16) & 0xff] ^
00985             Te2[(t3 >>  8) & 0xff] ^
00986             Te3[(t0      ) & 0xff] ^
00987             rk[1];
00988         s2 =
00989             Te0[(t2 >> 24)       ] ^
00990             Te1[(t3 >> 16) & 0xff] ^
00991             Te2[(t0 >>  8) & 0xff] ^
00992             Te3[(t1      ) & 0xff] ^
00993             rk[2];
00994         s3 =
00995             Te0[(t3 >> 24)       ] ^
00996             Te1[(t0 >> 16) & 0xff] ^
00997             Te2[(t1 >>  8) & 0xff] ^
00998             Te3[(t2      ) & 0xff] ^
00999             rk[3];
01000     }
01001 #endif /* ?FULL_UNROLL */
01002     /*
01003      * apply last round and
01004      * map cipher state to byte array block:
01005      */
01006     s0 =
01007         (Te4[(t0 >> 24)       ] & 0xff000000) ^
01008         (Te4[(t1 >> 16) & 0xff] & 0x00ff0000) ^
01009         (Te4[(t2 >>  8) & 0xff] & 0x0000ff00) ^
01010         (Te4[(t3      ) & 0xff] & 0x000000ff) ^
01011         rk[0];
01012     PUTU32(ct     , s0);
01013     s1 =
01014         (Te4[(t1 >> 24)       ] & 0xff000000) ^
01015         (Te4[(t2 >> 16) & 0xff] & 0x00ff0000) ^
01016         (Te4[(t3 >>  8) & 0xff] & 0x0000ff00) ^
01017         (Te4[(t0      ) & 0xff] & 0x000000ff) ^
01018         rk[1];
01019     PUTU32(ct +  4, s1);
01020     s2 =
01021         (Te4[(t2 >> 24)       ] & 0xff000000) ^
01022         (Te4[(t3 >> 16) & 0xff] & 0x00ff0000) ^
01023         (Te4[(t0 >>  8) & 0xff] & 0x0000ff00) ^
01024         (Te4[(t1      ) & 0xff] & 0x000000ff) ^
01025         rk[2];
01026     PUTU32(ct +  8, s2);
01027     s3 =
01028         (Te4[(t3 >> 24)       ] & 0xff000000) ^
01029         (Te4[(t0 >> 16) & 0xff] & 0x00ff0000) ^
01030         (Te4[(t1 >>  8) & 0xff] & 0x0000ff00) ^
01031         (Te4[(t2      ) & 0xff] & 0x000000ff) ^
01032         rk[3];
01033     PUTU32(ct + 12, s3);
01034 }

int rijndaelKeySetupDec u32  rk[],
const u8  cipherKey[],
int  keyBits
 

Expand the cipher key into the decryption key schedule.

戻り値:
the number of rounds for the given cipher key size.

rijndael-alg-fst.c814 行で定義されています。

参照先 rijndaelKeySetupEnc(), Td0, Td1, Td2, Td3, Te4, u32, と u8.

参照元 makeKey().

00814                                                                                    {
00815     int Nr, i, j;
00816     u32 temp;
00817 
00818     /* expand the cipher key: */
00819     Nr = rijndaelKeySetupEnc(rk, cipherKey, keyBits);
00820     /* invert the order of the round keys: */
00821     for (i = 0, j = 4*Nr; i < j; i += 4, j -= 4) {
00822         temp = rk[i    ]; rk[i    ] = rk[j    ]; rk[j    ] = temp;
00823         temp = rk[i + 1]; rk[i + 1] = rk[j + 1]; rk[j + 1] = temp;
00824         temp = rk[i + 2]; rk[i + 2] = rk[j + 2]; rk[j + 2] = temp;
00825         temp = rk[i + 3]; rk[i + 3] = rk[j + 3]; rk[j + 3] = temp;
00826     }
00827     /* apply the inverse MixColumn transform to all round keys but the first and the last: */
00828     for (i = 1; i < Nr; i++) {
00829         rk += 4;
00830         rk[0] =
00831             Td0[Te4[(rk[0] >> 24)       ] & 0xff] ^
00832             Td1[Te4[(rk[0] >> 16) & 0xff] & 0xff] ^
00833             Td2[Te4[(rk[0] >>  8) & 0xff] & 0xff] ^
00834             Td3[Te4[(rk[0]      ) & 0xff] & 0xff];
00835         rk[1] =
00836             Td0[Te4[(rk[1] >> 24)       ] & 0xff] ^
00837             Td1[Te4[(rk[1] >> 16) & 0xff] & 0xff] ^
00838             Td2[Te4[(rk[1] >>  8) & 0xff] & 0xff] ^
00839             Td3[Te4[(rk[1]      ) & 0xff] & 0xff];
00840         rk[2] =
00841             Td0[Te4[(rk[2] >> 24)       ] & 0xff] ^
00842             Td1[Te4[(rk[2] >> 16) & 0xff] & 0xff] ^
00843             Td2[Te4[(rk[2] >>  8) & 0xff] & 0xff] ^
00844             Td3[Te4[(rk[2]      ) & 0xff] & 0xff];
00845         rk[3] =
00846             Td0[Te4[(rk[3] >> 24)       ] & 0xff] ^
00847             Td1[Te4[(rk[3] >> 16) & 0xff] & 0xff] ^
00848             Td2[Te4[(rk[3] >>  8) & 0xff] & 0xff] ^
00849             Td3[Te4[(rk[3]      ) & 0xff] & 0xff];
00850     }
00851     return Nr;
00852 }

int rijndaelKeySetupEnc u32  rk[],
const u8  cipherKey[],
int  keyBits
 

Expand the cipher key into the encryption key schedule.

戻り値:
the number of rounds for the given cipher key size.

rijndael-alg-fst.c728 行で定義されています。

参照先 GETU32, rcon, Te4, u32, と u8.

参照元 makeKey(), と rijndaelKeySetupDec().

00728                                                                                    {
00729     int i = 0;
00730     u32 temp;
00731 
00732     rk[0] = GETU32(cipherKey     );
00733     rk[1] = GETU32(cipherKey +  4);
00734     rk[2] = GETU32(cipherKey +  8);
00735     rk[3] = GETU32(cipherKey + 12);
00736     if (keyBits == 128) {
00737         for (;;) {
00738             temp  = rk[3];
00739             rk[4] = rk[0] ^
00740                 (Te4[(temp >> 16) & 0xff] & 0xff000000) ^
00741                 (Te4[(temp >>  8) & 0xff] & 0x00ff0000) ^
00742                 (Te4[(temp      ) & 0xff] & 0x0000ff00) ^
00743                 (Te4[(temp >> 24)       ] & 0x000000ff) ^
00744                 rcon[i];
00745             rk[5] = rk[1] ^ rk[4];
00746             rk[6] = rk[2] ^ rk[5];
00747             rk[7] = rk[3] ^ rk[6];
00748             if (++i == 10) {
00749                 return 10;
00750             }
00751             rk += 4;
00752         }
00753     }
00754     rk[4] = GETU32(cipherKey + 16);
00755     rk[5] = GETU32(cipherKey + 20);
00756     if (keyBits == 192) {
00757         for (;;) {
00758             temp = rk[ 5];
00759             rk[ 6] = rk[ 0] ^
00760                 (Te4[(temp >> 16) & 0xff] & 0xff000000) ^
00761                 (Te4[(temp >>  8) & 0xff] & 0x00ff0000) ^
00762                 (Te4[(temp      ) & 0xff] & 0x0000ff00) ^
00763                 (Te4[(temp >> 24)       ] & 0x000000ff) ^
00764                 rcon[i];
00765             rk[ 7] = rk[ 1] ^ rk[ 6];
00766             rk[ 8] = rk[ 2] ^ rk[ 7];
00767             rk[ 9] = rk[ 3] ^ rk[ 8];
00768             if (++i == 8) {
00769                 return 12;
00770             }
00771             rk[10] = rk[ 4] ^ rk[ 9];
00772             rk[11] = rk[ 5] ^ rk[10];
00773             rk += 6;
00774         }
00775     }
00776     rk[6] = GETU32(cipherKey + 24);
00777     rk[7] = GETU32(cipherKey + 28);
00778     if (keyBits == 256) {
00779         for (;;) {
00780             temp = rk[ 7];
00781             rk[ 8] = rk[ 0] ^
00782                 (Te4[(temp >> 16) & 0xff] & 0xff000000) ^
00783                 (Te4[(temp >>  8) & 0xff] & 0x00ff0000) ^
00784                 (Te4[(temp      ) & 0xff] & 0x0000ff00) ^
00785                 (Te4[(temp >> 24)       ] & 0x000000ff) ^
00786                 rcon[i];
00787             rk[ 9] = rk[ 1] ^ rk[ 8];
00788             rk[10] = rk[ 2] ^ rk[ 9];
00789             rk[11] = rk[ 3] ^ rk[10];
00790             if (++i == 7) {
00791                 return 14;
00792             }
00793             temp = rk[11];
00794             rk[12] = rk[ 4] ^
00795                 (Te4[(temp >> 24)       ] & 0xff000000) ^
00796                 (Te4[(temp >> 16) & 0xff] & 0x00ff0000) ^
00797                 (Te4[(temp >>  8) & 0xff] & 0x0000ff00) ^
00798                 (Te4[(temp      ) & 0xff] & 0x000000ff);
00799             rk[13] = rk[ 5] ^ rk[12];
00800             rk[14] = rk[ 6] ^ rk[13];
00801             rk[15] = rk[ 7] ^ rk[14];
00802 
00803             rk += 8;
00804         }
00805     }
00806     return 0;
00807 }


dkutil_cに対してTue Feb 22 02:03:31 2005に生成されました。 doxygen 1.3.6