Skip to content
GitLab
Menu
Projects
Groups
Snippets
Loading...
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Menu
Open sidebar
ruanhaishen
Tiny AES C
Commits
9ae240cf
Commit
9ae240cf
authored
May 29, 2014
by
kokke
Browse files
Update aes.c
parent
698375cf
Changes
1
Hide whitespace changes
Inline
Side-by-side
aes.c
View file @
9ae240cf
...
@@ -3,31 +3,31 @@
...
@@ -3,31 +3,31 @@
This is the implementation of the AES128 algorithm, specifically ECB mode.
This is the implementation of the AES128 algorithm, specifically ECB mode.
The implementation is verified against the test vectors in:
The implementation is verified against the test vectors in:
National Institute of Standards and Technology Special Publication 800-38A 2001 ED
National Institute of Standards and Technology Special Publication 800-38A 2001 ED
ECB-AES128
ECB-AES128
----------
----------
plain-text:
plain-text:
6bc1bee22e409f96e93d7e117393172a
6bc1bee22e409f96e93d7e117393172a
ae2d8a571e03ac9c9eb76fac45af8e51
ae2d8a571e03ac9c9eb76fac45af8e51
30c81c46a35ce411e5fbc1191a0a52ef
30c81c46a35ce411e5fbc1191a0a52ef
f69f2445df4f9b17ad2b417be66c3710
f69f2445df4f9b17ad2b417be66c3710
key:
key:
2b7e151628aed2a6abf7158809cf4f3c
2b7e151628aed2a6abf7158809cf4f3c
resulting cipher
resulting cipher
50fe67cc996d32b6da0937e99bafec60
50fe67cc996d32b6da0937e99bafec60
d9a4dada0892239f6b8b3d7680e15674
d9a4dada0892239f6b8b3d7680e15674
a78819583f0308e7a6bf36b1386abf23
a78819583f0308e7a6bf36b1386abf23
c6d3416d29165c6fcb8e51a227ba994e
c6d3416d29165c6fcb8e51a227ba994e
Use aes_encrypt_string() to encrypt or decrypt a string
Use aes_encrypt_string() to encrypt or decrypt a string
NOTE:
String length must be evenly divisible by 16byte (str_len % 16 == 0)
NOTE:
String length must be evenly divisible by 16byte (str_len % 16 == 0)
You should pad the end of the string with zeros if this is not the case.
You should pad the end of the string with zeros if this is not the case.
*/
*/
...
@@ -75,44 +75,44 @@ static uint8_t* Key;
...
@@ -75,44 +75,44 @@ static uint8_t* Key;
// This can be useful in (embedded) bootloader applications, where ROM is often limited.
// This can be useful in (embedded) bootloader applications, where ROM is often limited.
static
const
uint8_t
sbox
[
256
]
=
{
static
const
uint8_t
sbox
[
256
]
=
{
//0 1 2 3 4 5 6 7 8 9 A B C D E F
//0 1 2 3 4 5 6 7 8 9 A B C D E F
0x63
,
0x7c
,
0x77
,
0x7b
,
0xf2
,
0x6b
,
0x6f
,
0xc5
,
0x30
,
0x01
,
0x67
,
0x2b
,
0xfe
,
0xd7
,
0xab
,
0x76
,
0x63
,
0x7c
,
0x77
,
0x7b
,
0xf2
,
0x6b
,
0x6f
,
0xc5
,
0x30
,
0x01
,
0x67
,
0x2b
,
0xfe
,
0xd7
,
0xab
,
0x76
,
0xca
,
0x82
,
0xc9
,
0x7d
,
0xfa
,
0x59
,
0x47
,
0xf0
,
0xad
,
0xd4
,
0xa2
,
0xaf
,
0x9c
,
0xa4
,
0x72
,
0xc0
,
0xca
,
0x82
,
0xc9
,
0x7d
,
0xfa
,
0x59
,
0x47
,
0xf0
,
0xad
,
0xd4
,
0xa2
,
0xaf
,
0x9c
,
0xa4
,
0x72
,
0xc0
,
0xb7
,
0xfd
,
0x93
,
0x26
,
0x36
,
0x3f
,
0xf7
,
0xcc
,
0x34
,
0xa5
,
0xe5
,
0xf1
,
0x71
,
0xd8
,
0x31
,
0x15
,
0xb7
,
0xfd
,
0x93
,
0x26
,
0x36
,
0x3f
,
0xf7
,
0xcc
,
0x34
,
0xa5
,
0xe5
,
0xf1
,
0x71
,
0xd8
,
0x31
,
0x15
,
0x04
,
0xc7
,
0x23
,
0xc3
,
0x18
,
0x96
,
0x05
,
0x9a
,
0x07
,
0x12
,
0x80
,
0xe2
,
0xeb
,
0x27
,
0xb2
,
0x75
,
0x04
,
0xc7
,
0x23
,
0xc3
,
0x18
,
0x96
,
0x05
,
0x9a
,
0x07
,
0x12
,
0x80
,
0xe2
,
0xeb
,
0x27
,
0xb2
,
0x75
,
0x09
,
0x83
,
0x2c
,
0x1a
,
0x1b
,
0x6e
,
0x5a
,
0xa0
,
0x52
,
0x3b
,
0xd6
,
0xb3
,
0x29
,
0xe3
,
0x2f
,
0x84
,
0x09
,
0x83
,
0x2c
,
0x1a
,
0x1b
,
0x6e
,
0x5a
,
0xa0
,
0x52
,
0x3b
,
0xd6
,
0xb3
,
0x29
,
0xe3
,
0x2f
,
0x84
,
0x53
,
0xd1
,
0x00
,
0xed
,
0x20
,
0xfc
,
0xb1
,
0x5b
,
0x6a
,
0xcb
,
0xbe
,
0x39
,
0x4a
,
0x4c
,
0x58
,
0xcf
,
0x53
,
0xd1
,
0x00
,
0xed
,
0x20
,
0xfc
,
0xb1
,
0x5b
,
0x6a
,
0xcb
,
0xbe
,
0x39
,
0x4a
,
0x4c
,
0x58
,
0xcf
,
0xd0
,
0xef
,
0xaa
,
0xfb
,
0x43
,
0x4d
,
0x33
,
0x85
,
0x45
,
0xf9
,
0x02
,
0x7f
,
0x50
,
0x3c
,
0x9f
,
0xa8
,
0xd0
,
0xef
,
0xaa
,
0xfb
,
0x43
,
0x4d
,
0x33
,
0x85
,
0x45
,
0xf9
,
0x02
,
0x7f
,
0x50
,
0x3c
,
0x9f
,
0xa8
,
0x51
,
0xa3
,
0x40
,
0x8f
,
0x92
,
0x9d
,
0x38
,
0xf5
,
0xbc
,
0xb6
,
0xda
,
0x21
,
0x10
,
0xff
,
0xf3
,
0xd2
,
0x51
,
0xa3
,
0x40
,
0x8f
,
0x92
,
0x9d
,
0x38
,
0xf5
,
0xbc
,
0xb6
,
0xda
,
0x21
,
0x10
,
0xff
,
0xf3
,
0xd2
,
0xcd
,
0x0c
,
0x13
,
0xec
,
0x5f
,
0x97
,
0x44
,
0x17
,
0xc4
,
0xa7
,
0x7e
,
0x3d
,
0x64
,
0x5d
,
0x19
,
0x73
,
0xcd
,
0x0c
,
0x13
,
0xec
,
0x5f
,
0x97
,
0x44
,
0x17
,
0xc4
,
0xa7
,
0x7e
,
0x3d
,
0x64
,
0x5d
,
0x19
,
0x73
,
0x60
,
0x81
,
0x4f
,
0xdc
,
0x22
,
0x2a
,
0x90
,
0x88
,
0x46
,
0xee
,
0xb8
,
0x14
,
0xde
,
0x5e
,
0x0b
,
0xdb
,
0x60
,
0x81
,
0x4f
,
0xdc
,
0x22
,
0x2a
,
0x90
,
0x88
,
0x46
,
0xee
,
0xb8
,
0x14
,
0xde
,
0x5e
,
0x0b
,
0xdb
,
0xe0
,
0x32
,
0x3a
,
0x0a
,
0x49
,
0x06
,
0x24
,
0x5c
,
0xc2
,
0xd3
,
0xac
,
0x62
,
0x91
,
0x95
,
0xe4
,
0x79
,
0xe0
,
0x32
,
0x3a
,
0x0a
,
0x49
,
0x06
,
0x24
,
0x5c
,
0xc2
,
0xd3
,
0xac
,
0x62
,
0x91
,
0x95
,
0xe4
,
0x79
,
0xe7
,
0xc8
,
0x37
,
0x6d
,
0x8d
,
0xd5
,
0x4e
,
0xa9
,
0x6c
,
0x56
,
0xf4
,
0xea
,
0x65
,
0x7a
,
0xae
,
0x08
,
0xe7
,
0xc8
,
0x37
,
0x6d
,
0x8d
,
0xd5
,
0x4e
,
0xa9
,
0x6c
,
0x56
,
0xf4
,
0xea
,
0x65
,
0x7a
,
0xae
,
0x08
,
0xba
,
0x78
,
0x25
,
0x2e
,
0x1c
,
0xa6
,
0xb4
,
0xc6
,
0xe8
,
0xdd
,
0x74
,
0x1f
,
0x4b
,
0xbd
,
0x8b
,
0x8a
,
0xba
,
0x78
,
0x25
,
0x2e
,
0x1c
,
0xa6
,
0xb4
,
0xc6
,
0xe8
,
0xdd
,
0x74
,
0x1f
,
0x4b
,
0xbd
,
0x8b
,
0x8a
,
0x70
,
0x3e
,
0xb5
,
0x66
,
0x48
,
0x03
,
0xf6
,
0x0e
,
0x61
,
0x35
,
0x57
,
0xb9
,
0x86
,
0xc1
,
0x1d
,
0x9e
,
0x70
,
0x3e
,
0xb5
,
0x66
,
0x48
,
0x03
,
0xf6
,
0x0e
,
0x61
,
0x35
,
0x57
,
0xb9
,
0x86
,
0xc1
,
0x1d
,
0x9e
,
0xe1
,
0xf8
,
0x98
,
0x11
,
0x69
,
0xd9
,
0x8e
,
0x94
,
0x9b
,
0x1e
,
0x87
,
0xe9
,
0xce
,
0x55
,
0x28
,
0xdf
,
0xe1
,
0xf8
,
0x98
,
0x11
,
0x69
,
0xd9
,
0x8e
,
0x94
,
0x9b
,
0x1e
,
0x87
,
0xe9
,
0xce
,
0x55
,
0x28
,
0xdf
,
0x8c
,
0xa1
,
0x89
,
0x0d
,
0xbf
,
0xe6
,
0x42
,
0x68
,
0x41
,
0x99
,
0x2d
,
0x0f
,
0xb0
,
0x54
,
0xbb
,
0x16
};
0x8c
,
0xa1
,
0x89
,
0x0d
,
0xbf
,
0xe6
,
0x42
,
0x68
,
0x41
,
0x99
,
0x2d
,
0x0f
,
0xb0
,
0x54
,
0xbb
,
0x16
};
// The round constant word array, Rcon[i], contains the values given by
// The round constant word array, Rcon[i], contains the values given by
// x to th e power (i-1) being powers of x (x is denoted as {02}) in the field GF(2^8)
// x to th e power (i-1) being powers of x (x is denoted as {02}) in the field GF(2^8)
// Note that i starts at 1, not 0).
// Note that i starts at 1, not 0).
static
const
uint8_t
Rcon
[
255
]
=
{
static
const
uint8_t
Rcon
[
255
]
=
{
0x8d
,
0x01
,
0x02
,
0x04
,
0x08
,
0x10
,
0x20
,
0x40
,
0x80
,
0x1b
,
0x36
,
0x6c
,
0xd8
,
0xab
,
0x4d
,
0x9a
,
0x8d
,
0x01
,
0x02
,
0x04
,
0x08
,
0x10
,
0x20
,
0x40
,
0x80
,
0x1b
,
0x36
,
0x6c
,
0xd8
,
0xab
,
0x4d
,
0x9a
,
0x2f
,
0x5e
,
0xbc
,
0x63
,
0xc6
,
0x97
,
0x35
,
0x6a
,
0xd4
,
0xb3
,
0x7d
,
0xfa
,
0xef
,
0xc5
,
0x91
,
0x39
,
0x2f
,
0x5e
,
0xbc
,
0x63
,
0xc6
,
0x97
,
0x35
,
0x6a
,
0xd4
,
0xb3
,
0x7d
,
0xfa
,
0xef
,
0xc5
,
0x91
,
0x39
,
0x72
,
0xe4
,
0xd3
,
0xbd
,
0x61
,
0xc2
,
0x9f
,
0x25
,
0x4a
,
0x94
,
0x33
,
0x66
,
0xcc
,
0x83
,
0x1d
,
0x3a
,
0x72
,
0xe4
,
0xd3
,
0xbd
,
0x61
,
0xc2
,
0x9f
,
0x25
,
0x4a
,
0x94
,
0x33
,
0x66
,
0xcc
,
0x83
,
0x1d
,
0x3a
,
0x74
,
0xe8
,
0xcb
,
0x8d
,
0x01
,
0x02
,
0x04
,
0x08
,
0x10
,
0x20
,
0x40
,
0x80
,
0x1b
,
0x36
,
0x6c
,
0xd8
,
0x74
,
0xe8
,
0xcb
,
0x8d
,
0x01
,
0x02
,
0x04
,
0x08
,
0x10
,
0x20
,
0x40
,
0x80
,
0x1b
,
0x36
,
0x6c
,
0xd8
,
0xab
,
0x4d
,
0x9a
,
0x2f
,
0x5e
,
0xbc
,
0x63
,
0xc6
,
0x97
,
0x35
,
0x6a
,
0xd4
,
0xb3
,
0x7d
,
0xfa
,
0xef
,
0xab
,
0x4d
,
0x9a
,
0x2f
,
0x5e
,
0xbc
,
0x63
,
0xc6
,
0x97
,
0x35
,
0x6a
,
0xd4
,
0xb3
,
0x7d
,
0xfa
,
0xef
,
0xc5
,
0x91
,
0x39
,
0x72
,
0xe4
,
0xd3
,
0xbd
,
0x61
,
0xc2
,
0x9f
,
0x25
,
0x4a
,
0x94
,
0x33
,
0x66
,
0xcc
,
0xc5
,
0x91
,
0x39
,
0x72
,
0xe4
,
0xd3
,
0xbd
,
0x61
,
0xc2
,
0x9f
,
0x25
,
0x4a
,
0x94
,
0x33
,
0x66
,
0xcc
,
0x83
,
0x1d
,
0x3a
,
0x74
,
0xe8
,
0xcb
,
0x8d
,
0x01
,
0x02
,
0x04
,
0x08
,
0x10
,
0x20
,
0x40
,
0x80
,
0x1b
,
0x83
,
0x1d
,
0x3a
,
0x74
,
0xe8
,
0xcb
,
0x8d
,
0x01
,
0x02
,
0x04
,
0x08
,
0x10
,
0x20
,
0x40
,
0x80
,
0x1b
,
0x36
,
0x6c
,
0xd8
,
0xab
,
0x4d
,
0x9a
,
0x2f
,
0x5e
,
0xbc
,
0x63
,
0xc6
,
0x97
,
0x35
,
0x6a
,
0xd4
,
0xb3
,
0x36
,
0x6c
,
0xd8
,
0xab
,
0x4d
,
0x9a
,
0x2f
,
0x5e
,
0xbc
,
0x63
,
0xc6
,
0x97
,
0x35
,
0x6a
,
0xd4
,
0xb3
,
0x7d
,
0xfa
,
0xef
,
0xc5
,
0x91
,
0x39
,
0x72
,
0xe4
,
0xd3
,
0xbd
,
0x61
,
0xc2
,
0x9f
,
0x25
,
0x4a
,
0x94
,
0x7d
,
0xfa
,
0xef
,
0xc5
,
0x91
,
0x39
,
0x72
,
0xe4
,
0xd3
,
0xbd
,
0x61
,
0xc2
,
0x9f
,
0x25
,
0x4a
,
0x94
,
0x33
,
0x66
,
0xcc
,
0x83
,
0x1d
,
0x3a
,
0x74
,
0xe8
,
0xcb
,
0x8d
,
0x01
,
0x02
,
0x04
,
0x08
,
0x10
,
0x20
,
0x33
,
0x66
,
0xcc
,
0x83
,
0x1d
,
0x3a
,
0x74
,
0xe8
,
0xcb
,
0x8d
,
0x01
,
0x02
,
0x04
,
0x08
,
0x10
,
0x20
,
0x40
,
0x80
,
0x1b
,
0x36
,
0x6c
,
0xd8
,
0xab
,
0x4d
,
0x9a
,
0x2f
,
0x5e
,
0xbc
,
0x63
,
0xc6
,
0x97
,
0x35
,
0x40
,
0x80
,
0x1b
,
0x36
,
0x6c
,
0xd8
,
0xab
,
0x4d
,
0x9a
,
0x2f
,
0x5e
,
0xbc
,
0x63
,
0xc6
,
0x97
,
0x35
,
0x6a
,
0xd4
,
0xb3
,
0x7d
,
0xfa
,
0xef
,
0xc5
,
0x91
,
0x39
,
0x72
,
0xe4
,
0xd3
,
0xbd
,
0x61
,
0xc2
,
0x9f
,
0x6a
,
0xd4
,
0xb3
,
0x7d
,
0xfa
,
0xef
,
0xc5
,
0x91
,
0x39
,
0x72
,
0xe4
,
0xd3
,
0xbd
,
0x61
,
0xc2
,
0x9f
,
0x25
,
0x4a
,
0x94
,
0x33
,
0x66
,
0xcc
,
0x83
,
0x1d
,
0x3a
,
0x74
,
0xe8
,
0xcb
,
0x8d
,
0x01
,
0x02
,
0x04
,
0x25
,
0x4a
,
0x94
,
0x33
,
0x66
,
0xcc
,
0x83
,
0x1d
,
0x3a
,
0x74
,
0xe8
,
0xcb
,
0x8d
,
0x01
,
0x02
,
0x04
,
0x08
,
0x10
,
0x20
,
0x40
,
0x80
,
0x1b
,
0x36
,
0x6c
,
0xd8
,
0xab
,
0x4d
,
0x9a
,
0x2f
,
0x5e
,
0xbc
,
0x63
,
0x08
,
0x10
,
0x20
,
0x40
,
0x80
,
0x1b
,
0x36
,
0x6c
,
0xd8
,
0xab
,
0x4d
,
0x9a
,
0x2f
,
0x5e
,
0xbc
,
0x63
,
0xc6
,
0x97
,
0x35
,
0x6a
,
0xd4
,
0xb3
,
0x7d
,
0xfa
,
0xef
,
0xc5
,
0x91
,
0x39
,
0x72
,
0xe4
,
0xd3
,
0xbd
,
0xc6
,
0x97
,
0x35
,
0x6a
,
0xd4
,
0xb3
,
0x7d
,
0xfa
,
0xef
,
0xc5
,
0x91
,
0x39
,
0x72
,
0xe4
,
0xd3
,
0xbd
,
0x61
,
0xc2
,
0x9f
,
0x25
,
0x4a
,
0x94
,
0x33
,
0x66
,
0xcc
,
0x83
,
0x1d
,
0x3a
,
0x74
,
0xe8
,
0xcb
};
0x61
,
0xc2
,
0x9f
,
0x25
,
0x4a
,
0x94
,
0x33
,
0x66
,
0xcc
,
0x83
,
0x1d
,
0x3a
,
0x74
,
0xe8
,
0xcb
};
/*****************************************************************************/
/*****************************************************************************/
...
@@ -120,101 +120,101 @@ static const uint8_t Rcon[255] = {
...
@@ -120,101 +120,101 @@ static const uint8_t Rcon[255] = {
/*****************************************************************************/
/*****************************************************************************/
static
uint8_t
getSBoxValue
(
uint8_t
num
)
static
uint8_t
getSBoxValue
(
uint8_t
num
)
{
{
return
sbox
[
num
];
return
sbox
[
num
];
}
}
// This function produces Nb(Nr+1) round keys. The round keys are used in each round to decrypt the states.
// This function produces Nb(Nr+1) round keys. The round keys are used in each round to decrypt the states.
static
void
KeyExpansion
()
static
void
KeyExpansion
()
{
{
uint8_t
i
,
j
,
k
;
uint8_t
i
,
j
,
k
;
uint8_t
tempa
[
4
];
// used for the column/row operations
uint8_t
tempa
[
4
];
// used for the column/row operations
// The first round key is the key itself.
// The first round key is the key itself.
for
(
i
=
0
;
i
<
Nk
;
++
i
)
for
(
i
=
0
;
i
<
Nk
;
++
i
)
{
{
RoundKey
[
i
*
4
]
=
Key
[
i
*
4
];
RoundKey
[
i
*
4
]
=
Key
[
i
*
4
];
RoundKey
[(
i
*
4
)
+
1
]
=
Key
[(
i
*
4
)
+
1
];
RoundKey
[(
i
*
4
)
+
1
]
=
Key
[(
i
*
4
)
+
1
];
RoundKey
[(
i
*
4
)
+
2
]
=
Key
[(
i
*
4
)
+
2
];
RoundKey
[(
i
*
4
)
+
2
]
=
Key
[(
i
*
4
)
+
2
];
RoundKey
[(
i
*
4
)
+
3
]
=
Key
[(
i
*
4
)
+
3
];
RoundKey
[(
i
*
4
)
+
3
]
=
Key
[(
i
*
4
)
+
3
];
}
}
// All other round keys are found from the previous round keys.
// All other round keys are found from the previous round keys.
for
(;
(
i
<
(
Nb
*
Nr
)
+
1
);
++
i
)
for
(;
(
i
<
(
Nb
*
Nr
)
+
1
);
++
i
)
{
{
for
(
j
=
0
;
j
<
4
;
++
j
)
for
(
j
=
0
;
j
<
4
;
++
j
)
{
{
tempa
[
j
]
=
RoundKey
[(
i
-
1
)
*
4
+
j
];
tempa
[
j
]
=
RoundKey
[(
i
-
1
)
*
4
+
j
];
}
}
if
(
i
%
Nk
==
0
)
if
(
i
%
Nk
==
0
)
{
{
// This function rotates the 4 bytes in a word to the left once.
// This function rotates the 4 bytes in a word to the left once.
// [a0,a1,a2,a3] becomes [a1,a2,a3,a0]
// [a0,a1,a2,a3] becomes [a1,a2,a3,a0]
// Function RotWord()
// Function RotWord()
{
{
k
=
tempa
[
0
];
k
=
tempa
[
0
];
tempa
[
0
]
=
tempa
[
1
];
tempa
[
0
]
=
tempa
[
1
];
tempa
[
1
]
=
tempa
[
2
];
tempa
[
1
]
=
tempa
[
2
];
tempa
[
2
]
=
tempa
[
3
];
tempa
[
2
]
=
tempa
[
3
];
tempa
[
3
]
=
k
;
tempa
[
3
]
=
k
;
}
}
// SubWord() is a function that takes a four-byte input word and
// SubWord() is a function that takes a four-byte input word and
// applies the S-box to each of the four bytes to produce an output word.
// applies the S-box to each of the four bytes to produce an output word.
// Function Subword()
// Function Subword()
{
{
tempa
[
0
]
=
getSBoxValue
(
tempa
[
0
]);
tempa
[
0
]
=
getSBoxValue
(
tempa
[
0
]);
tempa
[
1
]
=
getSBoxValue
(
tempa
[
1
]);
tempa
[
1
]
=
getSBoxValue
(
tempa
[
1
]);
tempa
[
2
]
=
getSBoxValue
(
tempa
[
2
]);
tempa
[
2
]
=
getSBoxValue
(
tempa
[
2
]);
tempa
[
3
]
=
getSBoxValue
(
tempa
[
3
]);
tempa
[
3
]
=
getSBoxValue
(
tempa
[
3
]);
}
}
tempa
[
0
]
=
tempa
[
0
]
^
Rcon
[
i
/
Nk
];
tempa
[
0
]
=
tempa
[
0
]
^
Rcon
[
i
/
Nk
];
}
}
else
if
(
Nk
>
6
&&
i
%
Nk
==
4
)
else
if
(
Nk
>
6
&&
i
%
Nk
==
4
)
{
{
// Function Subword()
// Function Subword()
{
{
tempa
[
0
]
=
getSBoxValue
(
tempa
[
0
]);
tempa
[
0
]
=
getSBoxValue
(
tempa
[
0
]);
tempa
[
1
]
=
getSBoxValue
(
tempa
[
1
]);
tempa
[
1
]
=
getSBoxValue
(
tempa
[
1
]);
tempa
[
2
]
=
getSBoxValue
(
tempa
[
2
]);
tempa
[
2
]
=
getSBoxValue
(
tempa
[
2
]);
tempa
[
3
]
=
getSBoxValue
(
tempa
[
3
]);
tempa
[
3
]
=
getSBoxValue
(
tempa
[
3
]);
}
}
}
}
RoundKey
[
i
*
4
]
=
RoundKey
[
i
-
Nk
*
4
]
^
tempa
[
0
];
RoundKey
[
i
*
4
]
=
RoundKey
[
i
-
Nk
*
4
]
^
tempa
[
0
];
RoundKey
[(
i
*
4
)
+
1
]
=
RoundKey
[(
i
-
Nk
)
*
(
4
+
1
)]
^
tempa
[
1
];
RoundKey
[(
i
*
4
)
+
1
]
=
RoundKey
[(
i
-
Nk
)
*
(
4
+
1
)]
^
tempa
[
1
];
RoundKey
[(
i
*
4
)
+
2
]
=
RoundKey
[(
i
-
Nk
)
*
(
4
+
2
)]
^
tempa
[
2
];
RoundKey
[(
i
*
4
)
+
2
]
=
RoundKey
[(
i
-
Nk
)
*
(
4
+
2
)]
^
tempa
[
2
];
RoundKey
[(
i
*
4
)
+
3
]
=
RoundKey
[(
i
-
Nk
)
*
(
4
+
3
)]
^
tempa
[
3
];
RoundKey
[(
i
*
4
)
+
3
]
=
RoundKey
[(
i
-
Nk
)
*
(
4
+
3
)]
^
tempa
[
3
];
}
}
}
}
// This function adds the round key to state.
// This function adds the round key to state.
// The round key is added to the state by an XOR function.
// The round key is added to the state by an XOR function.
static
void
AddRoundKey
(
uint8_t
round
)
static
void
AddRoundKey
(
uint8_t
round
)
{
{
uint8_t
i
,
j
;
uint8_t
i
,
j
;
for
(
i
=
0
;
i
<
4
;
i
++
)
for
(
i
=
0
;
i
<
4
;
i
++
)
{
{
for
(
j
=
0
;
j
<
4
;
++
j
)
for
(
j
=
0
;
j
<
4
;
++
j
)
{
{
state
[
j
][
i
]
^=
RoundKey
[
round
*
Nb
*
4
+
i
*
Nb
+
j
];
state
[
j
][
i
]
^=
RoundKey
[
round
*
Nb
*
4
+
i
*
Nb
+
j
];
}
}
}
}
}
}
// The SubBytes Function Substitutes the values in the
// The SubBytes Function Substitutes the values in the
// state matrix with values in an S-box.
// state matrix with values in an S-box.
static
void
SubBytes
()
static
void
SubBytes
()
{
{
uint8_t
i
,
j
;
uint8_t
i
,
j
;
for
(
i
=
0
;
i
<
4
;
++
i
)
for
(
i
=
0
;
i
<
4
;
++
i
)
{
{
for
(
j
=
0
;
j
<
4
;
++
j
)
for
(
j
=
0
;
j
<
4
;
++
j
)
{
{
state
[
i
][
j
]
=
getSBoxValue
(
state
[
i
][
j
]);
state
[
i
][
j
]
=
getSBoxValue
(
state
[
i
][
j
]);
}
}
}
}
}
}
// The ShiftRows() function shifts the rows in the state to the left.
// The ShiftRows() function shifts the rows in the state to the left.
...
@@ -222,97 +222,97 @@ static void SubBytes()
...
@@ -222,97 +222,97 @@ static void SubBytes()
// Offset = Row number. So the first row is not shifted.
// Offset = Row number. So the first row is not shifted.
static
void
ShiftRows
()
static
void
ShiftRows
()
{
{
uint8_t
temp
;
uint8_t
temp
;
// Rotate first row 1 columns to left
// Rotate first row 1 columns to left
temp
=
state
[
1
][
0
];
temp
=
state
[
1
][
0
];
state
[
1
][
0
]
=
state
[
1
][
1
];
state
[
1
][
0
]
=
state
[
1
][
1
];
state
[
1
][
1
]
=
state
[
1
][
2
];
state
[
1
][
1
]
=
state
[
1
][
2
];
state
[
1
][
2
]
=
state
[
1
][
3
];
state
[
1
][
2
]
=
state
[
1
][
3
];
state
[
1
][
3
]
=
temp
;
state
[
1
][
3
]
=
temp
;
// Rotate second row 2 columns to left
// Rotate second row 2 columns to left
temp
=
state
[
2
][
0
];
temp
=
state
[
2
][
0
];
state
[
2
][
0
]
=
state
[
2
][
2
];
state
[
2
][
0
]
=
state
[
2
][
2
];
state
[
2
][
2
]
=
temp
;
state
[
2
][
2
]
=
temp
;
temp
=
state
[
2
][
1
];
temp
=
state
[
2
][
1
];
state
[
2
][
1
]
=
state
[
2
][
3
];
state
[
2
][
1
]
=
state
[
2
][
3
];
state
[
2
][
3
]
=
temp
;
state
[
2
][
3
]
=
temp
;
// Rotate third row 3 columns to left
// Rotate third row 3 columns to left
temp
=
state
[
3
][
0
];
temp
=
state
[
3
][
0
];
state
[
3
][
0
]
=
state
[
3
][
3
];
state
[
3
][
0
]
=
state
[
3
][
3
];
state
[
3
][
3
]
=
state
[
3
][
2
];
state
[
3
][
3
]
=
state
[
3
][
2
];
state
[
3
][
2
]
=
state
[
3
][
1
];
state
[
3
][
2
]
=
state
[
3
][
1
];
state
[
3
][
1
]
=
temp
;
state
[
3
][
1
]
=
temp
;
}
}
static
uint8_t
xtime
(
uint8_t
x
)
static
uint8_t
xtime
(
uint8_t
x
)
{
{
return
((
x
<<
1
)
^
(((
x
>>
7
)
&
1
)
*
0x1b
));
return
((
x
<<
1
)
^
(((
x
>>
7
)
&
1
)
*
0x1b
));
}
}
// MixColumns function mixes the columns of the state matrix
// MixColumns function mixes the columns of the state matrix
static
void
MixColumns
()
static
void
MixColumns
()
{
{
uint8_t
i
;
uint8_t
i
;
uint8_t
Tmp
,
Tm
,
t
;
uint8_t
Tmp
,
Tm
,
t
;
for
(
i
=
0
;
i
<
4
;
++
i
)
for
(
i
=
0
;
i
<
4
;
++
i
)
{
{
t
=
state
[
0
][
i
];
t
=
state
[
0
][
i
];
Tmp
=
state
[
0
][
i
]
^
state
[
1
][
i
]
^
state
[
2
][
i
]
^
state
[
3
][
i
]
;
Tmp
=
state
[
0
][
i
]
^
state
[
1
][
i
]
^
state
[
2
][
i
]
^
state
[
3
][
i
]
;
Tm
=
state
[
0
][
i
]
^
state
[
1
][
i
]
;
Tm
=
xtime
(
Tm
);
state
[
0
][
i
]
^=
Tm
^
Tmp
;
Tm
=
state
[
0
][
i
]
^
state
[
1
][
i
]
;
Tm
=
xtime
(
Tm
);
state
[
0
][
i
]
^=
Tm
^
Tmp
;
Tm
=
state
[
1
][
i
]
^
state
[
2
][
i
]
;
Tm
=
xtime
(
Tm
);
state
[
1
][
i
]
^=
Tm
^
Tmp
;
Tm
=
state
[
1
][
i
]
^
state
[
2
][
i
]
;
Tm
=
xtime
(
Tm
);
state
[
1
][
i
]
^=
Tm
^
Tmp
;
Tm
=
state
[
2
][
i
]
^
state
[
3
][
i
]
;
Tm
=
xtime
(
Tm
);
state
[
2
][
i
]
^=
Tm
^
Tmp
;
Tm
=
state
[
2
][
i
]
^
state
[
3
][
i
]
;
Tm
=
xtime
(
Tm
);
state
[
2
][
i
]
^=
Tm
^
Tmp
;
Tm
=
state
[
3
][
i
]
^
t
;
Tm
=
xtime
(
Tm
);
state
[
3
][
i
]
^=
Tm
^
Tmp
;
Tm
=
state
[
3
][
i
]
^
t
;
Tm
=
xtime
(
Tm
);
state
[
3
][
i
]
^=
Tm
^
Tmp
;
}
}
}
}
// Cipher is the main function that encrypts the PlainText.
// Cipher is the main function that encrypts the PlainText.
static
void
Cipher
()
static
void
Cipher
()
{
{
uint8_t
i
,
j
,
round
=
0
;
uint8_t
i
,
j
,
round
=
0
;
//Copy the input PlainText to state array.
//Copy the input PlainText to state array.
for
(
i
=
0
;
i
<
4
;
++
i
)
for
(
i
=
0
;
i
<
4
;
++
i
)
{
{
for
(
j
=
0
;
j
<
4
;
++
j
)
for
(
j
=
0
;
j
<
4
;
++
j
)
{
{
state
[
j
][
i
]
=
in
[(
i
*
4
)
+
j
];
state
[
j
][
i
]
=
in
[(
i
*
4
)
+
j
];
}
}
}
}
// Add the First round key to the state before starting the rounds.
// Add the First round key to the state before starting the rounds.
AddRoundKey
(
0
);
AddRoundKey
(
0
);
// There will be Nr rounds.
// There will be Nr rounds.
// The first Nr-1 rounds are identical.
// The first Nr-1 rounds are identical.
// These Nr-1 rounds are executed in the loop below.
// These Nr-1 rounds are executed in the loop below.
for
(
round
=
1
;
round
<
Nr
;
++
round
)
for
(
round
=
1
;
round
<
Nr
;
++
round
)
{
{
SubBytes
();
SubBytes
();
ShiftRows
();
ShiftRows
();
MixColumns
();
MixColumns
();
AddRoundKey
(
round
);
AddRoundKey
(
round
);
}
}
// The last round is given below.
// The last round is given below.
// The MixColumns function is not here in the last round.
// The MixColumns function is not here in the last round.
SubBytes
();
SubBytes
();
ShiftRows
();
ShiftRows
();
AddRoundKey
(
Nr
);
AddRoundKey
(
Nr
);
// The encryption process is over.
// The encryption process is over.
// Copy the state array to output array.
// Copy the state array to output array.
for
(
i
=
0
;
i
<
4
;
++
i
)
for
(
i
=
0
;
i
<
4
;
++
i
)
{
{
for
(
j
=
0
;
j
<
4
;
++
j
)
for
(
j
=
0
;
j
<
4
;
++
j
)
{
{
out
[(
i
*
4
)
+
j
]
=
state
[
j
][
i
];
out
[(
i
*
4
)
+
j
]
=
state
[
j
][
i
];
}
}
}
}
}
}
...
@@ -322,16 +322,16 @@ static void Cipher()
...
@@ -322,16 +322,16 @@ static void Cipher()
void
AES128_ECB
(
uint8_t
*
input
,
uint8_t
*
key
,
uint8_t
*
output
)
void
AES128_ECB
(
uint8_t
*
input
,
uint8_t
*
key
,
uint8_t
*
output
)
{
{
// Copy the Key and CipherText
// Copy the Key and CipherText
Key
=
key
;
Key
=
key
;
in
=
input
;
in
=
input
;
out
=
output
;
out
=
output
;
// The KeyExpansion routine must be called before encryption.
// The KeyExpansion routine must be called before encryption.
KeyExpansion
();
KeyExpansion
();
// The next function call encrypts the PlainText with the Key using AES algorithm.
// The next function call encrypts the PlainText with the Key using AES algorithm.
Cipher
();
Cipher
();
}
}
...
...
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
.
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment