rijndael.pas

AES Source Code in Pascal

                    (Te4[(temp       ) AND $FF] AND $000000FF);
                rk[p + 13] := rk[p + 5] XOR rk[p + 12];
                rk[p + 14] := rk[p + 6] XOR rk[p + 13];
                rk[p + 15] := rk[p + 7] XOR rk[p + 14];
                INC(p, 8);
            END { WHILE };
        END { IF };
        KeySetupEnc := 0; (* invalid key size *)
    END { KeySetupEnc };

    (**
     * Expand the cipher key into the decryption key schedule.
     *
     * @return    the number of rounds for the given cipher key size.
     *)
    FUNCTION KeySetupDec (VAR rk: ExpandedKey;
            CONST cipherKey: ARRAY OF BYTE {Block}; keyBits: LONGINT): LONGINT;
    { pre: keyBits in [128, 192, 256] }
        VAR i, j, Nr, p: LONGINT; temp: SET32;
    BEGIN
        (* expand the cipher key: *)
        Nr := KeySetupEnc(rk, cipherKey, keyBits);
        (* invert the order of the round keys: *)
        i := 0; j := 4*Nr;
        WHILE i < j DO BEGIN
            temp := rk[i    ]; rk[i    ] := rk[j    ]; rk[j    ] := temp;
            temp := rk[i + 1]; rk[i + 1] := rk[j + 1]; rk[j + 1] := temp;
            temp := rk[i + 2]; rk[i + 2] := rk[j + 2]; rk[j + 2] := temp;
            temp := rk[i + 3]; rk[i + 3] := rk[j + 3]; rk[j + 3] := temp;
            INC(i, 4); DEC(j, 4);
        END { WHILE };
        (* apply the inverse MixColumn transform to all round keys but the first and the last: *)
        p := 0;
        FOR i := 1 TO Nr - 1 DO BEGIN
            INC(p, 4);
            rk[p    ] :=
                Td0[Te4[(rk[p    ] SHR 24)        ] AND $FF] XOR
                Td1[Te4[(rk[p    ] SHR 16) AND $FF] AND $FF] XOR
                Td2[Te4[(rk[p    ] SHR  8) AND $FF] AND $FF] XOR
                Td3[Te4[(rk[p    ]       ) AND $FF] AND $FF];
            rk[p + 1] :=
                Td0[Te4[(rk[p + 1] SHR 24)        ] AND $FF] XOR
                Td1[Te4[(rk[p + 1] SHR 16) AND $FF] AND $FF] XOR
                Td2[Te4[(rk[p + 1] SHR  8) AND $FF] AND $FF] XOR
                Td3[Te4[(rk[p + 1]       ) AND $FF] AND $FF];
            rk[p + 2] :=
                Td0[Te4[(rk[p + 2] SHR 24)        ] AND $FF] XOR
                Td1[Te4[(rk[p + 2] SHR 16) AND $FF] AND $FF] XOR
                Td2[Te4[(rk[p + 2] SHR  8) AND $FF] AND $FF] XOR
                Td3[Te4[(rk[p + 2]       ) AND $FF] AND $FF];
            rk[p + 3] :=
                Td0[Te4[(rk[p + 3] SHR 24)        ] AND $FF] XOR
                Td1[Te4[(rk[p + 3] SHR 16) AND $FF] AND $FF] XOR
                Td2[Te4[(rk[p + 3] SHR  8) AND $FF] AND $FF] XOR
                Td3[Te4[(rk[p + 3]       ) AND $FF] AND $FF];
        END { FOR i };
        KeySetupDec := Nr;
    END { KeySetupDec };

    (**
     * Encrypt a block (16 bytes) from pt at index p0 onto ct at index c0.
     *)
    PROCEDURE Encrypt (CONST rk: ExpandedKey; Nr: LONGINT;
            CONST pt: ARRAY OF BYTE {Block}; p0: LONGINT;
            VAR ct: ARRAY OF BYTE {Block}; c0: LONGINT);
        VAR s0, s1, s2, s3, t0, t1, t2, t3: SET32; p, r: LONGINT;
    BEGIN 
        (*
         * map byte array block to cipher state
         * and add initial round key:
         *)
        s0 := GetSet(pt, p0     ) XOR rk[0];
        s1 := GetSet(pt, p0 +  4) XOR rk[1];
        s2 := GetSet(pt, p0 +  8) XOR rk[2];
        s3 := GetSet(pt, p0 + 12) XOR rk[3];
        (*
         * Nr - 1 full rounds:
         *)
        r := Nr DIV 2;
        p := 0;
        WHILE r <> 0 DO BEGIN
            t0 :=
                Te0[(s0 SHR 24)        ] XOR
                Te1[(s1 SHR 16) AND $FF] XOR
                Te2[(s2 SHR  8) AND $FF] XOR
                Te3[(s3       ) AND $FF] XOR
                rk[p + 4];
            t1 :=
                Te0[(s1 SHR 24)        ] XOR
                Te1[(s2 SHR 16) AND $FF] XOR
                Te2[(s3 SHR  8) AND $FF] XOR
                Te3[(s0       ) AND $FF] XOR
                rk[p + 5];
            t2 :=
                Te0[(s2 SHR 24)        ] XOR
                Te1[(s3 SHR 16) AND $FF] XOR
                Te2[(s0 SHR  8) AND $FF] XOR
                Te3[(s1       ) AND $FF] XOR
                rk[p + 6];
            t3 :=
                Te0[(s3 SHR 24)        ] XOR
                Te1[(s0 SHR 16) AND $FF] XOR
                Te2[(s1 SHR  8) AND $FF] XOR
                Te3[(s2       ) AND $FF] XOR
                rk[p + 7];

            INC(p, 8);
            DEC(r);
            IF r <> 0 THEN BEGIN

            s0 :=
                Te0[(t0 SHR 24)        ] XOR
                Te1[(t1 SHR 16) AND $FF] XOR
                Te2[(t2 SHR  8) AND $FF] XOR
                Te3[(t3       ) AND $FF] XOR
                rk[p];
            s1 :=
                Te0[(t1 SHR 24)        ] XOR
                Te1[(t2 SHR 16) AND $FF] XOR
                Te2[(t3 SHR  8) AND $FF] XOR
                Te3[(t0       ) AND $FF] XOR
                rk[p + 1];
            s2 :=
                Te0[(t2 SHR 24)        ] XOR
                Te1[(t3 SHR 16) AND $FF] XOR
                Te2[(t0 SHR  8) AND $FF] XOR
                Te3[(t1       ) AND $FF] XOR
                rk[p + 2];
            s3 :=
                Te0[(t3 SHR 24)        ] XOR
                Te1[(t0 SHR 16) AND $FF] XOR
                Te2[(t1 SHR  8) AND $FF] XOR
                Te3[(t2       ) AND $FF] XOR
                rk[p + 3];
            END { IF };
        END { WHILE };
        (*
         * apply last round and
         * map cipher state to byte array block:
         *)
        s0 :=
            (Te4[(t0 SHR 24)        ] AND $FF000000) XOR
            (Te4[(t1 SHR 16) AND $FF] AND $00FF0000) XOR
            (Te4[(t2 SHR  8) AND $FF] AND $0000FF00) XOR
            (Te4[(t3       ) AND $FF] AND $000000FF) XOR
            rk[p];
        PutSet(ct, c0 + 0, s0);
        s1 :=
            (Te4[(t1 SHR 24)        ] AND $FF000000) XOR
            (Te4[(t2 SHR 16) AND $FF] AND $00FF0000) XOR
            (Te4[(t3 SHR  8) AND $FF] AND $0000FF00) XOR
            (Te4[(t0       ) AND $FF] AND $000000FF) XOR
            rk[p + 1];
        PutSet(ct, c0 +  4, s1);
        s2 :=
            (Te4[(t2 SHR 24)        ] AND $FF000000) XOR
            (Te4[(t3 SHR 16) AND $FF] AND $00FF0000) XOR
            (Te4[(t0 SHR  8) AND $FF] AND $0000FF00) XOR
            (Te4[(t1       ) AND $FF] AND $000000FF) XOR
            rk[p + 2];
        PutSet(ct, c0 +  8, s2);
        s3 :=
            (Te4[(t3 SHR 24)        ] AND $FF000000) XOR
            (Te4[(t0 SHR 16) AND $FF] AND $00FF0000) XOR
            (Te4[(t1 SHR  8) AND $FF] AND $0000FF00) XOR
            (Te4[(t2       ) AND $FF] AND $000000FF) XOR
            rk[p + 3];
        PutSet(ct, c0 + 12, s3);
    END { Encrypt };

    (**
     * Decrypt a block (16 bytes) from ct at index c0 onto pt at index p0.
     *)
    PROCEDURE Decrypt (CONST rk: ExpandedKey; Nr: LONGINT;
            CONST ct: ARRAY OF BYTE {Block}; c0: LONGINT;
            VAR pt: ARRAY OF BYTE {Block}; p0: LONGINT);
        VAR s0, s1, s2, s3, t0, t1, t2, t3: SET32; p, r: LONGINT;
    BEGIN 
        (*
         * map byte array block to cipher state
         * and add initial round key:
         *)
        s0 := GetSet(ct, c0     ) XOR rk[0];
        s1 := GetSet(ct, c0 +  4) XOR rk[1];
        s2 := GetSet(ct, c0 +  8) XOR rk[2];
        s3 := GetSet(ct, c0 + 12) XOR rk[3];
        (*
         * Nr - 1 full rounds:
         *)
        r := Nr DIV 2;
        p := 0;
        WHILE r <> 0 DO BEGIN
            t0 :=
                Td0[(s0 SHR 24)        ] XOR
                Td1[(s3 SHR 16) AND $FF] XOR
                Td2[(s2 SHR  8) AND $FF] XOR
                Td3[(s1       ) AND $FF] XOR
                rk[p + 4];
            t1 :=
                Td0[(s1 SHR 24)        ] XOR
                Td1[(s0 SHR 16) AND $FF] XOR
                Td2[(s3 SHR  8) AND $FF] XOR
                Td3[(s2       ) AND $FF] XOR
                rk[p + 5];
            t2 :=
                Td0[(s2 SHR 24)        ] XOR
                Td1[(s1 SHR 16) AND $FF] XOR
                Td2[(s0 SHR  8) AND $FF] XOR
                Td3[(s3       ) AND $FF] XOR
                rk[p + 6];
            t3 :=
                Td0[(s3 SHR 24)        ] XOR
                Td1[(s2 SHR 16) AND $FF] XOR
                Td2[(s1 SHR  8) AND $FF] XOR
                Td3[(s0       ) AND $FF] XOR
                rk[p + 7];

            INC(p, 8);
            DEC(r);
            IF r <> 0 THEN BEGIN

            s0 :=
                Td0[(t0 SHR 24)        ] XOR
                Td1[(t3 SHR 16) AND $FF] XOR
                Td2[(t2 SHR  8) AND $FF] XOR
                Td3[(t1       ) AND $FF] XOR
                rk[p];
            s1 :=
                Td0[(t1 SHR 24)        ] XOR
                Td1[(t0 SHR 16) AND $FF] XOR
                Td2[(t3 SHR  8) AND $FF] XOR
                Td3[(t2       ) AND $FF] XOR
                rk[p + 1];
            s2 :=
                Td0[(t2 SHR 24)        ] XOR
                Td1[(t1 SHR 16) AND $FF] XOR
                Td2[(t0 SHR  8) AND $FF] XOR
                Td3[(t3       ) AND $FF] XOR
                rk[p + 2];
            s3 :=
                Td0[(t3 SHR 24)        ] XOR
                Td1[(t2 SHR 16) AND $FF] XOR
                Td2[(t1 SHR  8) AND $FF] XOR
                Td3[(t0       ) AND $FF] XOR
                rk[p + 3];
            END { IF };
        END { WHILE };
        (*
         * apply last round and
         * map cipher state to byte array block:
         *)
        s0 :=
            (Td4[(t0 SHR 24)        ] AND $FF000000) XOR
            (Td4[(t3 SHR 16) AND $FF] AND $00FF0000) XOR
            (Td4[(t2 SHR  8) AND $FF] AND $0000FF00) XOR
            (Td4[(t1       ) AND $FF] AND $000000FF) XOR
            rk[p];
        PutSet(pt, p0 + 0, s0);
        s1 :=
            (Td4[(t1 SHR 24)        ] AND $FF000000) XOR
            (Td4[(t0 SHR 16) AND $FF] AND $00FF0000) XOR
            (Td4[(t3 SHR  8) AND $FF] AND $0000FF00) XOR
            (Td4[(t2       ) AND $FF] AND $000000FF) XOR
            rk[p + 1];
        PutSet(pt, p0 +  4, s1);
        s2 :=
            (Td4[(t2 SHR 24)        ] AND $FF000000) XOR
            (Td4[(t1 SHR 16) AND $FF] AND $00FF0000) XOR
            (Td4[(t0 SHR  8) AND $FF] AND $0000FF00) XOR
            (Td4[(t3       ) AND $FF] AND $000000FF) XOR
            rk[p + 2];
        PutSet(pt, p0 +  8, s2);
        s3 :=
            (Td4[(t3 SHR 24)        ] AND $FF000000) XOR
            (Td4[(t2 SHR 16) AND $FF] AND $00FF0000) XOR
            (Td4[(t1 SHR  8) AND $FF] AND $0000FF00) XOR
            (Td4[(t0       ) AND $FF] AND $000000FF) XOR
            rk[p + 3];
        PutSet(pt, p0 + 12, s3);
    END { Decrypt };

END { unit Rijndael }.