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
f56dbc05
Unverified
Commit
f56dbc05
authored
Sep 10, 2018
by
kokke
Committed by
GitHub
Sep 10, 2018
Browse files
Merge pull request #109 from franzinc/master
Testing improvements
parents
4b97e75f
7f211fb4
Changes
3
Show whitespace changes
Inline
Side-by-side
.gitignore
0 → 100644
View file @
f56dbc05
/*.o
/test.elf
/test.map
Makefile
View file @
f56dbc05
...
@@ -5,6 +5,12 @@ CC = gcc
...
@@ -5,6 +5,12 @@ CC = gcc
LD
=
gcc
LD
=
gcc
CFLAGS
=
-Wall
-Os
-c
CFLAGS
=
-Wall
-Os
-c
LDFLAGS
=
-Wall
-Os
-Wl
,-Map,test.map
LDFLAGS
=
-Wall
-Os
-Wl
,-Map,test.map
ifdef
AES192
CFLAGS
+=
-DAES192
=
1
endif
ifdef
AES256
CFLAGS
+=
-DAES256
=
1
endif
OBJCOPYFLAFS
=
-j
.text
-O
ihex
OBJCOPYFLAFS
=
-j
.text
-O
ihex
OBJCOPY
=
objcopy
OBJCOPY
=
objcopy
...
@@ -24,11 +30,11 @@ test.hex : test.elf
...
@@ -24,11 +30,11 @@ test.hex : test.elf
$(OBJCOPY)
${OBJCOPYFLAFS}
$<
$@
$(OBJCOPY)
${OBJCOPYFLAFS}
$<
$@
test.o
:
test.c aes.h aes.o
test.o
:
test.c aes.h aes.o
echo
[
CC]
$@
echo
[
CC]
$@
$(CFLAGS)
$(CC)
$(CFLAGS)
-o
$@
$<
$(CC)
$(CFLAGS)
-o
$@
$<
aes.o
:
aes.c aes.h
aes.o
:
aes.c aes.h
echo
[
CC]
$@
echo
[
CC]
$@
$(CFLAGS)
$(CC)
$(CFLAGS)
-o
$@
$<
$(CC)
$(CFLAGS)
-o
$@
$<
test.elf
:
aes.o test.o
test.elf
:
aes.o test.o
...
@@ -39,5 +45,10 @@ test.elf : aes.o test.o
...
@@ -39,5 +45,10 @@ test.elf : aes.o test.o
clean
:
clean
:
rm
-f
*
.OBJ
*
.LST
*
.o
*
.gch
*
.out
*
.hex
*
.map
rm
-f
*
.OBJ
*
.LST
*
.o
*
.gch
*
.out
*
.hex
*
.map
test
:
make clean
&&
make
&&
./test.elf
make clean
&&
make
AES192
=
1
&&
./test.elf
make clean
&&
make
AES256
=
1
&&
./test.elf
lint
:
lint
:
$(
call
SPLINT
)
$(
call
SPLINT
)
test.c
View file @
f56dbc05
...
@@ -12,38 +12,36 @@
...
@@ -12,38 +12,36 @@
static
void
phex
(
uint8_t
*
str
);
static
void
phex
(
uint8_t
*
str
);
static
void
test_encrypt_cbc
(
void
);
static
int
test_encrypt_cbc
(
void
);
static
void
test_decrypt_cbc
(
void
);
static
int
test_decrypt_cbc
(
void
);
static
void
test_encrypt_ctr
(
void
);
static
int
test_encrypt_ctr
(
void
);
static
void
test_decrypt_ctr
(
void
);
static
int
test_decrypt_ctr
(
void
);
static
void
test_encrypt_ecb
(
void
);
static
int
test_encrypt_ecb
(
void
);
static
void
test_decrypt_ecb
(
void
);
static
int
test_decrypt_ecb
(
void
);
static
void
test_encrypt_ecb_verbose
(
void
);
static
void
test_encrypt_ecb_verbose
(
void
);
int
main
(
void
)
int
main
(
void
)
{
{
int
exit
;
#ifdef
AES128
#if
def
ined(AES256)
printf
(
"
\n
Testing AES
128
\n\n
"
);
printf
(
"
\n
Testing AES
256
\n\n
"
);
#elif defined(AES192)
#elif defined(AES192)
printf
(
"
\n
Testing AES192
\n\n
"
);
printf
(
"
\n
Testing AES192
\n\n
"
);
#elif defined(AES
256
)
#elif defined(AES
128
)
printf
(
"
\n
Testing AES
256
\n\n
"
);
printf
(
"
\n
Testing AES
128
\n\n
"
);
#else
#else
printf
(
"You need to specify a symbol between AES128, AES192 or AES256. Exiting"
);
printf
(
"You need to specify a symbol between AES128, AES192 or AES256. Exiting"
);
return
0
;
return
0
;
#endif
#endif
test_encrypt_cbc
();
exit
=
test_encrypt_cbc
()
+
test_decrypt_cbc
()
+
test_decrypt_cbc
();
test_encrypt_ctr
()
+
test_decrypt_ctr
()
+
test_encrypt_ctr
();
test_decrypt_ecb
()
+
test_encrypt_ecb
();
test_decrypt_ctr
();
test_decrypt_ecb
();
test_encrypt_ecb
();
test_encrypt_ecb_verbose
();
test_encrypt_ecb_verbose
();
return
0
;
return
exit
;
}
}
...
@@ -51,12 +49,12 @@ int main(void)
...
@@ -51,12 +49,12 @@ int main(void)
static
void
phex
(
uint8_t
*
str
)
static
void
phex
(
uint8_t
*
str
)
{
{
#ifdef
AES128
#if
def
ined(AES256)
uint8_t
len
=
16
;
uint8_t
len
=
32
;
#elif defined(AES192)
#elif defined(AES192)
uint8_t
len
=
24
;
uint8_t
len
=
24
;
#elif defined(AES
256
)
#elif defined(AES
128
)
uint8_t
len
=
32
;
uint8_t
len
=
16
;
#endif
#endif
unsigned
char
i
;
unsigned
char
i
;
...
@@ -69,7 +67,7 @@ static void test_encrypt_ecb_verbose(void)
...
@@ -69,7 +67,7 @@ static void test_encrypt_ecb_verbose(void)
{
{
// Example of more verbose verification
// Example of more verbose verification
uint8_t
i
,
buf
[
64
],
buf2
[
64
]
;
uint8_t
i
;
// 128bit key
// 128bit key
uint8_t
key
[
16
]
=
{
(
uint8_t
)
0x2b
,
(
uint8_t
)
0x7e
,
(
uint8_t
)
0x15
,
(
uint8_t
)
0x16
,
(
uint8_t
)
0x28
,
(
uint8_t
)
0xae
,
(
uint8_t
)
0xd2
,
(
uint8_t
)
0xa6
,
(
uint8_t
)
0xab
,
(
uint8_t
)
0xf7
,
(
uint8_t
)
0x15
,
(
uint8_t
)
0x88
,
(
uint8_t
)
0x09
,
(
uint8_t
)
0xcf
,
(
uint8_t
)
0x4f
,
(
uint8_t
)
0x3c
};
uint8_t
key
[
16
]
=
{
(
uint8_t
)
0x2b
,
(
uint8_t
)
0x7e
,
(
uint8_t
)
0x15
,
(
uint8_t
)
0x16
,
(
uint8_t
)
0x28
,
(
uint8_t
)
0xae
,
(
uint8_t
)
0xd2
,
(
uint8_t
)
0xa6
,
(
uint8_t
)
0xab
,
(
uint8_t
)
0xf7
,
(
uint8_t
)
0x15
,
(
uint8_t
)
0x88
,
(
uint8_t
)
0x09
,
(
uint8_t
)
0xcf
,
(
uint8_t
)
0x4f
,
(
uint8_t
)
0x3c
};
...
@@ -79,9 +77,6 @@ static void test_encrypt_ecb_verbose(void)
...
@@ -79,9 +77,6 @@ static void test_encrypt_ecb_verbose(void)
(
uint8_t
)
0x30
,
(
uint8_t
)
0xc8
,
(
uint8_t
)
0x1c
,
(
uint8_t
)
0x46
,
(
uint8_t
)
0xa3
,
(
uint8_t
)
0x5c
,
(
uint8_t
)
0xe4
,
(
uint8_t
)
0x11
,
(
uint8_t
)
0xe5
,
(
uint8_t
)
0xfb
,
(
uint8_t
)
0xc1
,
(
uint8_t
)
0x19
,
(
uint8_t
)
0x1a
,
(
uint8_t
)
0x0a
,
(
uint8_t
)
0x52
,
(
uint8_t
)
0xef
,
(
uint8_t
)
0x30
,
(
uint8_t
)
0xc8
,
(
uint8_t
)
0x1c
,
(
uint8_t
)
0x46
,
(
uint8_t
)
0xa3
,
(
uint8_t
)
0x5c
,
(
uint8_t
)
0xe4
,
(
uint8_t
)
0x11
,
(
uint8_t
)
0xe5
,
(
uint8_t
)
0xfb
,
(
uint8_t
)
0xc1
,
(
uint8_t
)
0x19
,
(
uint8_t
)
0x1a
,
(
uint8_t
)
0x0a
,
(
uint8_t
)
0x52
,
(
uint8_t
)
0xef
,
(
uint8_t
)
0xf6
,
(
uint8_t
)
0x9f
,
(
uint8_t
)
0x24
,
(
uint8_t
)
0x45
,
(
uint8_t
)
0xdf
,
(
uint8_t
)
0x4f
,
(
uint8_t
)
0x9b
,
(
uint8_t
)
0x17
,
(
uint8_t
)
0xad
,
(
uint8_t
)
0x2b
,
(
uint8_t
)
0x41
,
(
uint8_t
)
0x7b
,
(
uint8_t
)
0xe6
,
(
uint8_t
)
0x6c
,
(
uint8_t
)
0x37
,
(
uint8_t
)
0x10
};
(
uint8_t
)
0xf6
,
(
uint8_t
)
0x9f
,
(
uint8_t
)
0x24
,
(
uint8_t
)
0x45
,
(
uint8_t
)
0xdf
,
(
uint8_t
)
0x4f
,
(
uint8_t
)
0x9b
,
(
uint8_t
)
0x17
,
(
uint8_t
)
0xad
,
(
uint8_t
)
0x2b
,
(
uint8_t
)
0x41
,
(
uint8_t
)
0x7b
,
(
uint8_t
)
0xe6
,
(
uint8_t
)
0x6c
,
(
uint8_t
)
0x37
,
(
uint8_t
)
0x10
};
memset
(
buf
,
0
,
64
);
memset
(
buf2
,
0
,
64
);
// print text to encrypt, key and IV
// print text to encrypt, key and IV
printf
(
"ECB encrypt verbose:
\n\n
"
);
printf
(
"ECB encrypt verbose:
\n\n
"
);
printf
(
"plain text:
\n
"
);
printf
(
"plain text:
\n
"
);
...
@@ -110,19 +105,19 @@ static void test_encrypt_ecb_verbose(void)
...
@@ -110,19 +105,19 @@ static void test_encrypt_ecb_verbose(void)
}
}
static
void
test_encrypt_ecb
(
void
)
static
int
test_encrypt_ecb
(
void
)
{
{
#ifdef AES128
#if defined(AES256)
uint8_t
key
[]
=
{
0x2b
,
0x7e
,
0x15
,
0x16
,
0x28
,
0xae
,
0xd2
,
0xa6
,
0xab
,
0xf7
,
0x15
,
0x88
,
0x09
,
0xcf
,
0x4f
,
0x3c
};
uint8_t
key
[]
=
{
0x60
,
0x3d
,
0xeb
,
0x10
,
0x15
,
0xca
,
0x71
,
0xbe
,
0x2b
,
0x73
,
0xae
,
0xf0
,
0x85
,
0x7d
,
0x77
,
0x81
,
uint8_t
out
[]
=
{
0x3a
,
0xd7
,
0x7b
,
0xb4
,
0x0d
,
0x7a
,
0x36
,
0x60
,
0xa8
,
0x9e
,
0xca
,
0xf3
,
0x24
,
0x66
,
0xef
,
0x97
};
0x1f
,
0x35
,
0x2c
,
0x07
,
0x3b
,
0x61
,
0x08
,
0xd7
,
0x2d
,
0x98
,
0x10
,
0xa3
,
0x09
,
0x14
,
0xdf
,
0xf4
};
uint8_t
out
[]
=
{
0xf3
,
0xee
,
0xd1
,
0xbd
,
0xb5
,
0xd2
,
0xa0
,
0x3c
,
0x06
,
0x4b
,
0x5a
,
0x7e
,
0x3d
,
0xb1
,
0x81
,
0xf8
};
#elif defined(AES192)
#elif defined(AES192)
uint8_t
key
[]
=
{
0x8e
,
0x73
,
0xb0
,
0xf7
,
0xda
,
0x0e
,
0x64
,
0x52
,
0xc8
,
0x10
,
0xf3
,
0x2b
,
0x80
,
0x90
,
0x79
,
0xe5
,
uint8_t
key
[]
=
{
0x8e
,
0x73
,
0xb0
,
0xf7
,
0xda
,
0x0e
,
0x64
,
0x52
,
0xc8
,
0x10
,
0xf3
,
0x2b
,
0x80
,
0x90
,
0x79
,
0xe5
,
0x62
,
0xf8
,
0xea
,
0xd2
,
0x52
,
0x2c
,
0x6b
,
0x7b
};
0x62
,
0xf8
,
0xea
,
0xd2
,
0x52
,
0x2c
,
0x6b
,
0x7b
};
uint8_t
out
[]
=
{
0xbd
,
0x33
,
0x4f
,
0x1d
,
0x6e
,
0x45
,
0xf2
,
0x5f
,
0xf7
,
0x12
,
0xa2
,
0x14
,
0x57
,
0x1f
,
0xa5
,
0xcc
};
uint8_t
out
[]
=
{
0xbd
,
0x33
,
0x4f
,
0x1d
,
0x6e
,
0x45
,
0xf2
,
0x5f
,
0xf7
,
0x12
,
0xa2
,
0x14
,
0x57
,
0x1f
,
0xa5
,
0xcc
};
#elif defined(AES256)
#elif defined(AES128)
uint8_t
key
[]
=
{
0x60
,
0x3d
,
0xeb
,
0x10
,
0x15
,
0xca
,
0x71
,
0xbe
,
0x2b
,
0x73
,
0xae
,
0xf0
,
0x85
,
0x7d
,
0x77
,
0x81
,
uint8_t
key
[]
=
{
0x2b
,
0x7e
,
0x15
,
0x16
,
0x28
,
0xae
,
0xd2
,
0xa6
,
0xab
,
0xf7
,
0x15
,
0x88
,
0x09
,
0xcf
,
0x4f
,
0x3c
};
0x1f
,
0x35
,
0x2c
,
0x07
,
0x3b
,
0x61
,
0x08
,
0xd7
,
0x2d
,
0x98
,
0x10
,
0xa3
,
0x09
,
0x14
,
0xdf
,
0xf4
};
uint8_t
out
[]
=
{
0x3a
,
0xd7
,
0x7b
,
0xb4
,
0x0d
,
0x7a
,
0x36
,
0x60
,
0xa8
,
0x9e
,
0xca
,
0xf3
,
0x24
,
0x66
,
0xef
,
0x97
};
uint8_t
out
[]
=
{
0xf3
,
0xee
,
0xd1
,
0xbd
,
0xb5
,
0xd2
,
0xa0
,
0x3c
,
0x06
,
0x4b
,
0x5a
,
0x7e
,
0x3d
,
0xb1
,
0x81
,
0xf8
};
#endif
#endif
uint8_t
in
[]
=
{
0x6b
,
0xc1
,
0xbe
,
0xe2
,
0x2e
,
0x40
,
0x9f
,
0x96
,
0xe9
,
0x3d
,
0x7e
,
0x11
,
0x73
,
0x93
,
0x17
,
0x2a
};
uint8_t
in
[]
=
{
0x6b
,
0xc1
,
0xbe
,
0xe2
,
0x2e
,
0x40
,
0x9f
,
0x96
,
0xe9
,
0x3d
,
0x7e
,
0x11
,
0x73
,
0x93
,
0x17
,
0x2a
};
...
@@ -133,38 +128,37 @@ static void test_encrypt_ecb(void)
...
@@ -133,38 +128,37 @@ static void test_encrypt_ecb(void)
printf
(
"ECB encrypt: "
);
printf
(
"ECB encrypt: "
);
if
(
0
==
memcmp
((
char
*
)
out
,
(
char
*
)
in
,
16
))
if
(
0
==
memcmp
((
char
*
)
out
,
(
char
*
)
in
,
16
))
{
{
printf
(
"SUCCESS!
\n
"
);
printf
(
"SUCCESS!
\n
"
);
}
return
(
0
);
else
}
else
{
{
printf
(
"FAILURE!
\n
"
);
printf
(
"FAILURE!
\n
"
);
return
(
1
);
}
}
}
}
static
void
test_decrypt_cbc
(
void
)
static
int
test_decrypt_cbc
(
void
)
{
{
#ifdef AES128
#if defined(AES256)
uint8_t
key
[]
=
{
0x2b
,
0x7e
,
0x15
,
0x16
,
0x28
,
0xae
,
0xd2
,
0xa6
,
0xab
,
0xf7
,
0x15
,
0x88
,
0x09
,
0xcf
,
0x4f
,
0x3c
};
uint8_t
in
[]
=
{
0x76
,
0x49
,
0xab
,
0xac
,
0x81
,
0x19
,
0xb2
,
0x46
,
0xce
,
0xe9
,
0x8e
,
0x9b
,
0x12
,
0xe9
,
0x19
,
0x7d
,
0x50
,
0x86
,
0xcb
,
0x9b
,
0x50
,
0x72
,
0x19
,
0xee
,
0x95
,
0xdb
,
0x11
,
0x3a
,
0x91
,
0x76
,
0x78
,
0xb2
,
0x73
,
0xbe
,
0xd6
,
0xb8
,
0xe3
,
0xc1
,
0x74
,
0x3b
,
0x71
,
0x16
,
0xe6
,
0x9e
,
0x22
,
0x22
,
0x95
,
0x16
,
0x3f
,
0xf1
,
0xca
,
0xa1
,
0x68
,
0x1f
,
0xac
,
0x09
,
0x12
,
0x0e
,
0xca
,
0x30
,
0x75
,
0x86
,
0xe1
,
0xa7
};
#elif defined(AES192)
uint8_t
key
[]
=
{
0x8e
,
0x73
,
0xb0
,
0xf7
,
0xda
,
0x0e
,
0x64
,
0x52
,
0xc8
,
0x10
,
0xf3
,
0x2b
,
0x80
,
0x90
,
0x79
,
0xe5
,
0x62
,
0xf8
,
0xea
,
0xd2
,
0x52
,
0x2c
,
0x6b
,
0x7b
};
uint8_t
in
[]
=
{
0x4f
,
0x02
,
0x1d
,
0xb2
,
0x43
,
0xbc
,
0x63
,
0x3d
,
0x71
,
0x78
,
0x18
,
0x3a
,
0x9f
,
0xa0
,
0x71
,
0xe8
,
0xb4
,
0xd9
,
0xad
,
0xa9
,
0xad
,
0x7d
,
0xed
,
0xf4
,
0xe5
,
0xe7
,
0x38
,
0x76
,
0x3f
,
0x69
,
0x14
,
0x5a
,
0x57
,
0x1b
,
0x24
,
0x20
,
0x12
,
0xfb
,
0x7a
,
0xe0
,
0x7f
,
0xa9
,
0xba
,
0xac
,
0x3d
,
0xf1
,
0x02
,
0xe0
,
0x08
,
0xb0
,
0xe2
,
0x79
,
0x88
,
0x59
,
0x88
,
0x81
,
0xd9
,
0x20
,
0xa9
,
0xe6
,
0x4f
,
0x56
,
0x15
,
0xcd
};
#elif defined(AES256)
uint8_t
key
[]
=
{
0x60
,
0x3d
,
0xeb
,
0x10
,
0x15
,
0xca
,
0x71
,
0xbe
,
0x2b
,
0x73
,
0xae
,
0xf0
,
0x85
,
0x7d
,
0x77
,
0x81
,
uint8_t
key
[]
=
{
0x60
,
0x3d
,
0xeb
,
0x10
,
0x15
,
0xca
,
0x71
,
0xbe
,
0x2b
,
0x73
,
0xae
,
0xf0
,
0x85
,
0x7d
,
0x77
,
0x81
,
0x1f
,
0x35
,
0x2c
,
0x07
,
0x3b
,
0x61
,
0x08
,
0xd7
,
0x2d
,
0x98
,
0x10
,
0xa3
,
0x09
,
0x14
,
0xdf
,
0xf4
};
0x1f
,
0x35
,
0x2c
,
0x07
,
0x3b
,
0x61
,
0x08
,
0xd7
,
0x2d
,
0x98
,
0x10
,
0xa3
,
0x09
,
0x14
,
0xdf
,
0xf4
};
uint8_t
in
[]
=
{
0xf5
,
0x8c
,
0x4c
,
0x04
,
0xd6
,
0xe5
,
0xf1
,
0xba
,
0x77
,
0x9e
,
0xab
,
0xfb
,
0x5f
,
0x7b
,
0xfb
,
0xd6
,
uint8_t
in
[]
=
{
0xf5
,
0x8c
,
0x4c
,
0x04
,
0xd6
,
0xe5
,
0xf1
,
0xba
,
0x77
,
0x9e
,
0xab
,
0xfb
,
0x5f
,
0x7b
,
0xfb
,
0xd6
,
0x9c
,
0xfc
,
0x4e
,
0x96
,
0x7e
,
0xdb
,
0x80
,
0x8d
,
0x67
,
0x9f
,
0x77
,
0x7b
,
0xc6
,
0x70
,
0x2c
,
0x7d
,
0x9c
,
0xfc
,
0x4e
,
0x96
,
0x7e
,
0xdb
,
0x80
,
0x8d
,
0x67
,
0x9f
,
0x77
,
0x7b
,
0xc6
,
0x70
,
0x2c
,
0x7d
,
0x39
,
0xf2
,
0x33
,
0x69
,
0xa9
,
0xd9
,
0xba
,
0xcf
,
0xa5
,
0x30
,
0xe2
,
0x63
,
0x04
,
0x23
,
0x14
,
0x61
,
0x39
,
0xf2
,
0x33
,
0x69
,
0xa9
,
0xd9
,
0xba
,
0xcf
,
0xa5
,
0x30
,
0xe2
,
0x63
,
0x04
,
0x23
,
0x14
,
0x61
,
0xb2
,
0xeb
,
0x05
,
0xe2
,
0xc3
,
0x9b
,
0xe9
,
0xfc
,
0xda
,
0x6c
,
0x19
,
0x07
,
0x8c
,
0x6a
,
0x9d
,
0x1b
};
0xb2
,
0xeb
,
0x05
,
0xe2
,
0xc3
,
0x9b
,
0xe9
,
0xfc
,
0xda
,
0x6c
,
0x19
,
0x07
,
0x8c
,
0x6a
,
0x9d
,
0x1b
};
#elif defined(AES192)
uint8_t
key
[]
=
{
0x8e
,
0x73
,
0xb0
,
0xf7
,
0xda
,
0x0e
,
0x64
,
0x52
,
0xc8
,
0x10
,
0xf3
,
0x2b
,
0x80
,
0x90
,
0x79
,
0xe5
,
0x62
,
0xf8
,
0xea
,
0xd2
,
0x52
,
0x2c
,
0x6b
,
0x7b
};
uint8_t
in
[]
=
{
0x4f
,
0x02
,
0x1d
,
0xb2
,
0x43
,
0xbc
,
0x63
,
0x3d
,
0x71
,
0x78
,
0x18
,
0x3a
,
0x9f
,
0xa0
,
0x71
,
0xe8
,
0xb4
,
0xd9
,
0xad
,
0xa9
,
0xad
,
0x7d
,
0xed
,
0xf4
,
0xe5
,
0xe7
,
0x38
,
0x76
,
0x3f
,
0x69
,
0x14
,
0x5a
,
0x57
,
0x1b
,
0x24
,
0x20
,
0x12
,
0xfb
,
0x7a
,
0xe0
,
0x7f
,
0xa9
,
0xba
,
0xac
,
0x3d
,
0xf1
,
0x02
,
0xe0
,
0x08
,
0xb0
,
0xe2
,
0x79
,
0x88
,
0x59
,
0x88
,
0x81
,
0xd9
,
0x20
,
0xa9
,
0xe6
,
0x4f
,
0x56
,
0x15
,
0xcd
};
#elif defined(AES128)
uint8_t
key
[]
=
{
0x2b
,
0x7e
,
0x15
,
0x16
,
0x28
,
0xae
,
0xd2
,
0xa6
,
0xab
,
0xf7
,
0x15
,
0x88
,
0x09
,
0xcf
,
0x4f
,
0x3c
};
uint8_t
in
[]
=
{
0x76
,
0x49
,
0xab
,
0xac
,
0x81
,
0x19
,
0xb2
,
0x46
,
0xce
,
0xe9
,
0x8e
,
0x9b
,
0x12
,
0xe9
,
0x19
,
0x7d
,
0x50
,
0x86
,
0xcb
,
0x9b
,
0x50
,
0x72
,
0x19
,
0xee
,
0x95
,
0xdb
,
0x11
,
0x3a
,
0x91
,
0x76
,
0x78
,
0xb2
,
0x73
,
0xbe
,
0xd6
,
0xb8
,
0xe3
,
0xc1
,
0x74
,
0x3b
,
0x71
,
0x16
,
0xe6
,
0x9e
,
0x22
,
0x22
,
0x95
,
0x16
,
0x3f
,
0xf1
,
0xca
,
0xa1
,
0x68
,
0x1f
,
0xac
,
0x09
,
0x12
,
0x0e
,
0xca
,
0x30
,
0x75
,
0x86
,
0xe1
,
0xa7
};
#endif
#endif
uint8_t
iv
[]
=
{
0x00
,
0x01
,
0x02
,
0x03
,
0x04
,
0x05
,
0x06
,
0x07
,
0x08
,
0x09
,
0x0a
,
0x0b
,
0x0c
,
0x0d
,
0x0e
,
0x0f
};
uint8_t
iv
[]
=
{
0x00
,
0x01
,
0x02
,
0x03
,
0x04
,
0x05
,
0x06
,
0x07
,
0x08
,
0x09
,
0x0a
,
0x0b
,
0x0c
,
0x0d
,
0x0e
,
0x0f
};
uint8_t
out
[]
=
{
0x6b
,
0xc1
,
0xbe
,
0xe2
,
0x2e
,
0x40
,
0x9f
,
0x96
,
0xe9
,
0x3d
,
0x7e
,
0x11
,
0x73
,
0x93
,
0x17
,
0x2a
,
uint8_t
out
[]
=
{
0x6b
,
0xc1
,
0xbe
,
0xe2
,
0x2e
,
0x40
,
0x9f
,
0x96
,
0xe9
,
0x3d
,
0x7e
,
0x11
,
0x73
,
0x93
,
0x17
,
0x2a
,
...
@@ -179,37 +173,36 @@ static void test_decrypt_cbc(void)
...
@@ -179,37 +173,36 @@ static void test_decrypt_cbc(void)
printf
(
"CBC decrypt: "
);
printf
(
"CBC decrypt: "
);
if
(
0
==
memcmp
((
char
*
)
out
,
(
char
*
)
in
,
64
))
if
(
0
==
memcmp
((
char
*
)
out
,
(
char
*
)
in
,
64
))
{
{
printf
(
"SUCCESS!
\n
"
);
printf
(
"SUCCESS!
\n
"
);
}
return
(
0
);
else
}
else
{
{
printf
(
"FAILURE!
\n
"
);
printf
(
"FAILURE!
\n
"
);
return
(
1
);
}
}
}
}
static
void
test_encrypt_cbc
(
void
)
static
int
test_encrypt_cbc
(
void
)
{
{
#ifdef AES128
#if defined(AES256)
uint8_t
key
[]
=
{
0x2b
,
0x7e
,
0x15
,
0x16
,
0x28
,
0xae
,
0xd2
,
0xa6
,
0xab
,
0xf7
,
0x15
,
0x88
,
0x09
,
0xcf
,
0x4f
,
0x3c
};
uint8_t
out
[]
=
{
0x76
,
0x49
,
0xab
,
0xac
,
0x81
,
0x19
,
0xb2
,
0x46
,
0xce
,
0xe9
,
0x8e
,
0x9b
,
0x12
,
0xe9
,
0x19
,
0x7d
,
0x50
,
0x86
,
0xcb
,
0x9b
,
0x50
,
0x72
,
0x19
,
0xee
,
0x95
,
0xdb
,
0x11
,
0x3a
,
0x91
,
0x76
,
0x78
,
0xb2
,
0x73
,
0xbe
,
0xd6
,
0xb8
,
0xe3
,
0xc1
,
0x74
,
0x3b
,
0x71
,
0x16
,
0xe6
,
0x9e
,
0x22
,
0x22
,
0x95
,
0x16
,
0x3f
,
0xf1
,
0xca
,
0xa1
,
0x68
,
0x1f
,
0xac
,
0x09
,
0x12
,
0x0e
,
0xca
,
0x30
,
0x75
,
0x86
,
0xe1
,
0xa7
};
#elif defined(AES192)
uint8_t
key
[]
=
{
0x8e
,
0x73
,
0xb0
,
0xf7
,
0xda
,
0x0e
,
0x64
,
0x52
,
0xc8
,
0x10
,
0xf3
,
0x2b
,
0x80
,
0x90
,
0x79
,
0xe5
,
0x62
,
0xf8
,
0xea
,
0xd2
,
0x52
,
0x2c
,
0x6b
,
0x7b
};
uint8_t
out
[]
=
{
0x4f
,
0x02
,
0x1d
,
0xb2
,
0x43
,
0xbc
,
0x63
,
0x3d
,
0x71
,
0x78
,
0x18
,
0x3a
,
0x9f
,
0xa0
,
0x71
,
0xe8
,
0xb4
,
0xd9
,
0xad
,
0xa9
,
0xad
,
0x7d
,
0xed
,
0xf4
,
0xe5
,
0xe7
,
0x38
,
0x76
,
0x3f
,
0x69
,
0x14
,
0x5a
,
0x57
,
0x1b
,
0x24
,
0x20
,
0x12
,
0xfb
,
0x7a
,
0xe0
,
0x7f
,
0xa9
,
0xba
,
0xac
,
0x3d
,
0xf1
,
0x02
,
0xe0
,
0x08
,
0xb0
,
0xe2
,
0x79
,
0x88
,
0x59
,
0x88
,
0x81
,
0xd9
,
0x20
,
0xa9
,
0xe6
,
0x4f
,
0x56
,
0x15
,
0xcd
};
#elif defined(AES256)
uint8_t
key
[]
=
{
0x60
,
0x3d
,
0xeb
,
0x10
,
0x15
,
0xca
,
0x71
,
0xbe
,
0x2b
,
0x73
,
0xae
,
0xf0
,
0x85
,
0x7d
,
0x77
,
0x81
,
uint8_t
key
[]
=
{
0x60
,
0x3d
,
0xeb
,
0x10
,
0x15
,
0xca
,
0x71
,
0xbe
,
0x2b
,
0x73
,
0xae
,
0xf0
,
0x85
,
0x7d
,
0x77
,
0x81
,
0x1f
,
0x35
,
0x2c
,
0x07
,
0x3b
,
0x61
,
0x08
,
0xd7
,
0x2d
,
0x98
,
0x10
,
0xa3
,
0x09
,
0x14
,
0xdf
,
0xf4
};
0x1f
,
0x35
,
0x2c
,
0x07
,
0x3b
,
0x61
,
0x08
,
0xd7
,
0x2d
,
0x98
,
0x10
,
0xa3
,
0x09
,
0x14
,
0xdf
,
0xf4
};
uint8_t
out
[]
=
{
0xf5
,
0x8c
,
0x4c
,
0x04
,
0xd6
,
0xe5
,
0xf1
,
0xba
,
0x77
,
0x9e
,
0xab
,
0xfb
,
0x5f
,
0x7b
,
0xfb
,
0xd6
,
uint8_t
out
[]
=
{
0xf5
,
0x8c
,
0x4c
,
0x04
,
0xd6
,
0xe5
,
0xf1
,
0xba
,
0x77
,
0x9e
,
0xab
,
0xfb
,
0x5f
,
0x7b
,
0xfb
,
0xd6
,
0x9c
,
0xfc
,
0x4e
,
0x96
,
0x7e
,
0xdb
,
0x80
,
0x8d
,
0x67
,
0x9f
,
0x77
,
0x7b
,
0xc6
,
0x70
,
0x2c
,
0x7d
,
0x9c
,
0xfc
,
0x4e
,
0x96
,
0x7e
,
0xdb
,
0x80
,
0x8d
,
0x67
,
0x9f
,
0x77
,
0x7b
,
0xc6
,
0x70
,
0x2c
,
0x7d
,
0x39
,
0xf2
,
0x33
,
0x69
,
0xa9
,
0xd9
,
0xba
,
0xcf
,
0xa5
,
0x30
,
0xe2
,
0x63
,
0x04
,
0x23
,
0x14
,
0x61
,
0x39
,
0xf2
,
0x33
,
0x69
,
0xa9
,
0xd9
,
0xba
,
0xcf
,
0xa5
,
0x30
,
0xe2
,
0x63
,
0x04
,
0x23
,
0x14
,
0x61
,
0xb2
,
0xeb
,
0x05
,
0xe2
,
0xc3
,
0x9b
,
0xe9
,
0xfc
,
0xda
,
0x6c
,
0x19
,
0x07
,
0x8c
,
0x6a
,
0x9d
,
0x1b
};
0xb2
,
0xeb
,
0x05
,
0xe2
,
0xc3
,
0x9b
,
0xe9
,
0xfc
,
0xda
,
0x6c
,
0x19
,
0x07
,
0x8c
,
0x6a
,
0x9d
,
0x1b
};
#elif defined(AES192)
uint8_t
key
[]
=
{
0x8e
,
0x73
,
0xb0
,
0xf7
,
0xda
,
0x0e
,
0x64
,
0x52
,
0xc8
,
0x10
,
0xf3
,
0x2b
,
0x80
,
0x90
,
0x79
,
0xe5
,
0x62
,
0xf8
,
0xea
,
0xd2
,
0x52
,
0x2c
,
0x6b
,
0x7b
};
uint8_t
out
[]
=
{
0x4f
,
0x02
,
0x1d
,
0xb2
,
0x43
,
0xbc
,
0x63
,
0x3d
,
0x71
,
0x78
,
0x18
,
0x3a
,
0x9f
,
0xa0
,
0x71
,
0xe8
,
0xb4
,
0xd9
,
0xad
,
0xa9
,
0xad
,
0x7d
,
0xed
,
0xf4
,
0xe5
,
0xe7
,
0x38
,
0x76
,
0x3f
,
0x69
,
0x14
,
0x5a
,
0x57
,
0x1b
,
0x24
,
0x20
,
0x12
,
0xfb
,
0x7a
,
0xe0
,
0x7f
,
0xa9
,
0xba
,
0xac
,
0x3d
,
0xf1
,
0x02
,
0xe0
,
0x08
,
0xb0
,
0xe2
,
0x79
,
0x88
,
0x59
,
0x88
,
0x81
,
0xd9
,
0x20
,
0xa9
,
0xe6
,
0x4f
,
0x56
,
0x15
,
0xcd
};
#elif defined(AES128)
uint8_t
key
[]
=
{
0x2b
,
0x7e
,
0x15
,
0x16
,
0x28
,
0xae
,
0xd2
,
0xa6
,
0xab
,
0xf7
,
0x15
,
0x88
,
0x09
,
0xcf
,
0x4f
,
0x3c
};
uint8_t
out
[]
=
{
0x76
,
0x49
,
0xab
,
0xac
,
0x81
,
0x19
,
0xb2
,
0x46
,
0xce
,
0xe9
,
0x8e
,
0x9b
,
0x12
,
0xe9
,
0x19
,
0x7d
,
0x50
,
0x86
,
0xcb
,
0x9b
,
0x50
,
0x72
,
0x19
,
0xee
,
0x95
,
0xdb
,
0x11
,
0x3a
,
0x91
,
0x76
,
0x78
,
0xb2
,
0x73
,
0xbe
,
0xd6
,
0xb8
,
0xe3
,
0xc1
,
0x74
,
0x3b
,
0x71
,
0x16
,
0xe6
,
0x9e
,
0x22
,
0x22
,
0x95
,
0x16
,
0x3f
,
0xf1
,
0xca
,
0xa1
,
0x68
,
0x1f
,
0xac
,
0x09
,
0x12
,
0x0e
,
0xca
,
0x30
,
0x75
,
0x86
,
0xe1
,
0xa7
};
#endif
#endif
uint8_t
iv
[]
=
{
0x00
,
0x01
,
0x02
,
0x03
,
0x04
,
0x05
,
0x06
,
0x07
,
0x08
,
0x09
,
0x0a
,
0x0b
,
0x0c
,
0x0d
,
0x0e
,
0x0f
};
uint8_t
iv
[]
=
{
0x00
,
0x01
,
0x02
,
0x03
,
0x04
,
0x05
,
0x06
,
0x07
,
0x08
,
0x09
,
0x0a
,
0x0b
,
0x0c
,
0x0d
,
0x0e
,
0x0f
};
uint8_t
in
[]
=
{
0x6b
,
0xc1
,
0xbe
,
0xe2
,
0x2e
,
0x40
,
0x9f
,
0x96
,
0xe9
,
0x3d
,
0x7e
,
0x11
,
0x73
,
0x93
,
0x17
,
0x2a
,
uint8_t
in
[]
=
{
0x6b
,
0xc1
,
0xbe
,
0xe2
,
0x2e
,
0x40
,
0x9f
,
0x96
,
0xe9
,
0x3d
,
0x7e
,
0x11
,
0x73
,
0x93
,
0x17
,
0x2a
,
...
@@ -223,35 +216,35 @@ static void test_encrypt_cbc(void)
...
@@ -223,35 +216,35 @@ static void test_encrypt_cbc(void)
printf
(
"CBC encrypt: "
);
printf
(
"CBC encrypt: "
);
if
(
0
==
memcmp
((
char
*
)
out
,
(
char
*
)
in
,
64
))
if
(
0
==
memcmp
((
char
*
)
out
,
(
char
*
)
in
,
64
))
{
{
printf
(
"SUCCESS!
\n
"
);
printf
(
"SUCCESS!
\n
"
);
}
return
(
0
);
else
}
else
{
{
printf
(
"FAILURE!
\n
"
);
printf
(
"FAILURE!
\n
"
);
return
(
1
);
}
}
}
}
static
void
test_xcrypt_ctr
(
const
char
*
xcrypt
);
static
int
test_xcrypt_ctr
(
const
char
*
xcrypt
);
static
void
test_encrypt_ctr
(
void
)
static
int
test_encrypt_ctr
(
void
)
{
{
test_xcrypt_ctr
(
"encrypt"
);
return
test_xcrypt_ctr
(
"encrypt"
);
}
}
static
void
test_decrypt_ctr
(
void
)
static
int
test_decrypt_ctr
(
void
)
{
{
test_xcrypt_ctr
(
"decrypt"
);
return
test_xcrypt_ctr
(
"decrypt"
);
}
}
static
void
test_xcrypt_ctr
(
const
char
*
xcrypt
)
static
int
test_xcrypt_ctr
(
const
char
*
xcrypt
)
{
{
#ifdef AES128
#if defined(AES256)
uint8_t
key
[
16
]
=
{
0x2b
,
0x7e
,
0x15
,
0x16
,
0x28
,
0xae
,
0xd2
,
0xa6
,
0xab
,
0xf7
,
0x15
,
0x88
,
0x09
,
0xcf
,
0x4f
,
0x3c
};
uint8_t
key
[
32
]
=
{
0x60
,
0x3d
,
0xeb
,
0x10
,
0x15
,
0xca
,
0x71
,
0xbe
,
0x2b
,
0x73
,
0xae
,
0xf0
,
0x85
,
0x7d
,
0x77
,
0x81
,
uint8_t
in
[
64
]
=
{
0x87
,
0x4d
,
0x61
,
0x91
,
0xb6
,
0x20
,
0xe3
,
0x26
,
0x1b
,
0xef
,
0x68
,
0x64
,
0x99
,
0x0d
,
0xb6
,
0xce
,
0x1f
,
0x35
,
0x2c
,
0x07
,
0x3b
,
0x61
,
0x08
,
0xd7
,
0x2d
,
0x98
,
0x10
,
0xa3
,
0x09
,
0x14
,
0xdf
,
0xf4
};
0x98
,
0x06
,
0xf6
,
0x6b
,
0x79
,
0x70
,
0xfd
,
0xff
,
0x86
,
0x17
,
0x18
,
0x7b
,
0xb9
,
0xff
,
0xfd
,
0xff
,
uint8_t
in
[
64
]
=
{
0x60
,
0x1e
,
0xc3
,
0x13
,
0x77
,
0x57
,
0x89
,
0xa5
,
0xb7
,
0xa7
,
0xf5
,
0x04
,
0xbb
,
0xf3
,
0xd2
,
0x28
,
0x5a
,
0xe4
,
0xdf
,
0x3e
,
0xdb
,
0xd5
,
0xd3
,
0x5e
,
0x5b
,
0x4f
,
0x09
,
0x02
,
0x0d
,
0xb0
,
0x3e
,
0xab
,
0xf4
,
0x43
,
0xe3
,
0xca
,
0x4d
,
0x62
,
0xb5
,
0x9a
,
0xca
,
0x84
,
0xe9
,
0x90
,
0xca
,
0xca
,
0xf5
,
0xc5
,
0x1e
,
0x03
,
0x1d
,
0xda
,
0x2f
,
0xbe
,
0x03
,
0xd1
,
0x79
,
0x21
,
0x70
,
0xa0
,
0xf3
,
0x00
,
0x9c
,
0xee
};
0x2b
,
0x09
,
0x30
,
0xda
,
0xa2
,
0x3d
,
0xe9
,
0x4c
,
0xe8
,
0x70
,
0x17
,
0xba
,
0x2d
,
0x84
,
0x98
,
0x8d
,
0xdf
,
0xc9
,
0xc5
,
0x8d
,
0xb6
,
0x7a
,
0xad
,
0xa6
,
0x13
,
0xc2
,
0xdd
,
0x08
,
0x45
,
0x79
,
0x41
,
0xa6
};
#elif defined(AES192)
#elif defined(AES192)
uint8_t
key
[
24
]
=
{
0x8e
,
0x73
,
0xb0
,
0xf7
,
0xda
,
0x0e
,
0x64
,
0x52
,
0xc8
,
0x10
,
0xf3
,
0x2b
,
0x80
,
0x90
,
0x79
,
0xe5
,
uint8_t
key
[
24
]
=
{
0x8e
,
0x73
,
0xb0
,
0xf7
,
0xda
,
0x0e
,
0x64
,
0x52
,
0xc8
,
0x10
,
0xf3
,
0x2b
,
0x80
,
0x90
,
0x79
,
0xe5
,
0x62
,
0xf8
,
0xea
,
0xd2
,
0x52
,
0x2c
,
0x6b
,
0x7b
};
0x62
,
0xf8
,
0xea
,
0xd2
,
0x52
,
0x2c
,
0x6b
,
0x7b
};
...
@@ -259,13 +252,12 @@ static void test_xcrypt_ctr(const char* xcrypt)
...
@@ -259,13 +252,12 @@ static void test_xcrypt_ctr(const char* xcrypt)
0x09
,
0x03
,
0x39
,
0xec
,
0x0a
,
0xa6
,
0xfa
,
0xef
,
0xd5
,
0xcc
,
0xc2
,
0xc6
,
0xf4
,
0xce
,
0x8e
,
0x94
,
0x09
,
0x03
,
0x39
,
0xec
,
0x0a
,
0xa6
,
0xfa
,
0xef
,
0xd5
,
0xcc
,
0xc2
,
0xc6
,
0xf4
,
0xce
,
0x8e
,
0x94
,
0x1e
,
0x36
,
0xb2
,
0x6b
,
0xd1
,
0xeb
,
0xc6
,
0x70
,
0xd1
,
0xbd
,
0x1d
,
0x66
,
0x56
,
0x20
,
0xab
,
0xf7
,
0x1e
,
0x36
,
0xb2
,
0x6b
,
0xd1
,
0xeb
,
0xc6
,
0x70
,
0xd1
,
0xbd
,
0x1d
,
0x66
,
0x56
,
0x20
,
0xab
,
0xf7
,
0x4f
,
0x78
,
0xa7
,
0xf6
,
0xd2
,
0x98
,
0x09
,
0x58
,
0x5a
,
0x97
,
0xda
,
0xec
,
0x58
,
0xc6
,
0xb0
,
0x50
};
0x4f
,
0x78
,
0xa7
,
0xf6
,
0xd2
,
0x98
,
0x09
,
0x58
,
0x5a
,
0x97
,
0xda
,
0xec
,
0x58
,
0xc6
,
0xb0
,
0x50
};
#elif defined(AES256)
#elif defined(AES128)
uint8_t
key
[
32
]
=
{
0x60
,
0x3d
,
0xeb
,
0x10
,
0x15
,
0xca
,
0x71
,
0xbe
,
0x2b
,
0x73
,
0xae
,
0xf0
,
0x85
,
0x7d
,
0x77
,
0x81
,
uint8_t
key
[
16
]
=
{
0x2b
,
0x7e
,
0x15
,
0x16
,
0x28
,
0xae
,
0xd2
,
0xa6
,
0xab
,
0xf7
,
0x15
,
0x88
,
0x09
,
0xcf
,
0x4f
,
0x3c
};
0x1f
,
0x35
,
0x2c
,
0x07
,
0x3b
,
0x61
,
0x08
,
0xd7
,
0x2d
,
0x98
,
0x10
,
0xa3
,
0x09
,
0x14
,
0xdf
,
0xf4
};
uint8_t
in
[
64
]
=
{
0x87
,
0x4d
,
0x61
,
0x91
,
0xb6
,
0x20
,
0xe3
,
0x26
,
0x1b
,
0xef
,
0x68
,
0x64
,
0x99
,
0x0d
,
0xb6
,
0xce
,
uint8_t
in
[
64
]
=
{
0x60
,
0x1e
,
0xc3
,
0x13
,
0x77
,
0x57
,
0x89
,
0xa5
,
0xb7
,
0xa7
,
0xf5
,
0x04
,
0xbb
,
0xf3
,
0xd2
,
0x28
,
0x98
,
0x06
,
0xf6
,
0x6b
,
0x79
,
0x70
,
0xfd
,
0xff
,
0x86
,
0x17
,
0x18
,
0x7b
,
0xb9
,
0xff
,
0xfd
,
0xff
,
0xf4
,
0x43
,
0xe3
,
0xca
,
0x4d
,
0x62
,
0xb5
,
0x9a
,
0xca
,
0x84
,
0xe9
,
0x90
,
0xca
,
0xca
,
0xf5
,
0xc5
,
0x5a
,
0xe4
,
0xdf
,
0x3e
,
0xdb
,
0xd5
,
0xd3
,
0x5e
,
0x5b
,
0x4f
,
0x09
,
0x02
,
0x0d
,
0xb0
,
0x3e
,
0xab
,
0x2b
,
0x09
,
0x30
,
0xda
,
0xa2
,
0x3d
,
0xe9
,
0x4c
,
0xe8
,
0x70
,
0x17
,
0xba
,
0x2d
,
0x84
,
0x98
,
0x8d
,
0x1e
,
0x03
,
0x1d
,
0xda
,
0x2f
,
0xbe
,
0x03
,
0xd1
,
0x79
,
0x21
,
0x70
,
0xa0
,
0xf3
,
0x00
,
0x9c
,
0xee
};
0xdf
,
0xc9
,
0xc5
,
0x8d
,
0xb6
,
0x7a
,
0xad
,
0xa6
,
0x13
,
0xc2
,
0xdd
,
0x08
,
0x45
,
0x79
,
0x41
,
0xa6
};
#endif
#endif
uint8_t
iv
[
16
]
=
{
0xf0
,
0xf1
,
0xf2
,
0xf3
,
0xf4
,
0xf5
,
0xf6
,
0xf7
,
0xf8
,
0xf9
,
0xfa
,
0xfb
,
0xfc
,
0xfd
,
0xfe
,
0xff
};
uint8_t
iv
[
16
]
=
{
0xf0
,
0xf1
,
0xf2
,
0xf3
,
0xf4
,
0xf5
,
0xf6
,
0xf7
,
0xf8
,
0xf9
,
0xfa
,
0xfb
,
0xfc
,
0xfd
,
0xfe
,
0xff
};
uint8_t
out
[
64
]
=
{
0x6b
,
0xc1
,
0xbe
,
0xe2
,
0x2e
,
0x40
,
0x9f
,
0x96
,
0xe9
,
0x3d
,
0x7e
,
0x11
,
0x73
,
0x93
,
0x17
,
0x2a
,
uint8_t
out
[
64
]
=
{
0x6b
,
0xc1
,
0xbe
,
0xe2
,
0x2e
,
0x40
,
0x9f
,
0x96
,
0xe9
,
0x3d
,
0x7e
,
0x11
,
0x73
,
0x93
,
0x17
,
0x2a
,
...
@@ -279,30 +271,29 @@ static void test_xcrypt_ctr(const char* xcrypt)
...
@@ -279,30 +271,29 @@ static void test_xcrypt_ctr(const char* xcrypt)
printf
(
"CTR %s: "
,
xcrypt
);
printf
(
"CTR %s: "
,
xcrypt
);
if
(
0
==
memcmp
((
char
*
)
out
,
(
char
*
)
in
,
64
))
if
(
0
==
memcmp
((
char
*
)
out
,
(
char
*
)
in
,
64
))
{
{
printf
(
"SUCCESS!
\n
"
);
printf
(
"SUCCESS!
\n
"
);
}
return
(
0
);
else
}
else
{
{
printf
(
"FAILURE!
\n
"
);
printf
(
"FAILURE!
\n
"
);
return
(
1
);
}
}
}
}
static
void
test_decrypt_ecb
(
void
)
static
int
test_decrypt_ecb
(
void
)
{
{
#ifdef AES128
#if defined(AES256)
uint8_t
key
[]
=
{
0x2b
,
0x7e
,
0x15
,
0x16
,
0x28
,
0xae
,
0xd2
,
0xa6
,
0xab
,
0xf7
,
0x15
,
0x88
,
0x09
,
0xcf
,
0x4f
,
0x3c
};
uint8_t
key
[]
=
{
0x60
,
0x3d
,
0xeb
,
0x10
,
0x15
,
0xca
,
0x71
,
0xbe
,
0x2b
,
0x73
,
0xae
,
0xf0
,
0x85
,
0x7d
,
0x77
,
0x81
,
uint8_t
in
[]
=
{
0x3a
,
0xd7
,
0x7b
,
0xb4
,
0x0d
,
0x7a
,
0x36
,
0x60
,
0xa8
,
0x9e
,
0xca
,
0xf3
,
0x24
,
0x66
,
0xef
,
0x97
};
0x1f
,
0x35
,
0x2c
,
0x07
,
0x3b
,
0x61
,
0x08
,
0xd7
,
0x2d
,
0x98
,
0x10
,
0xa3
,
0x09
,
0x14
,
0xdf
,
0xf4
};
uint8_t
in
[]
=
{
0xf3
,
0xee
,
0xd1
,
0xbd
,
0xb5
,
0xd2
,
0xa0
,
0x3c
,
0x06
,
0x4b
,
0x5a
,
0x7e
,
0x3d
,
0xb1
,
0x81
,
0xf8
};
#elif defined(AES192)
#elif defined(AES192)
uint8_t
key
[]
=
{
0x8e
,
0x73
,
0xb0
,
0xf7
,
0xda
,
0x0e
,
0x64
,
0x52
,
0xc8
,
0x10
,
0xf3
,
0x2b
,
0x80
,
0x90
,
0x79
,
0xe5
,
uint8_t
key
[]
=
{
0x8e
,
0x73
,
0xb0
,
0xf7
,
0xda
,
0x0e
,
0x64
,
0x52
,
0xc8
,
0x10
,
0xf3
,
0x2b
,
0x80
,
0x90
,
0x79
,
0xe5
,
0x62
,
0xf8
,
0xea
,
0xd2
,
0x52
,
0x2c
,
0x6b
,
0x7b
};
0x62
,
0xf8
,
0xea
,
0xd2
,
0x52
,
0x2c
,
0x6b
,
0x7b
};
uint8_t
in
[]
=
{
0xbd
,
0x33
,
0x4f
,
0x1d
,
0x6e
,
0x45
,
0xf2
,
0x5f
,
0xf7
,
0x12
,
0xa2
,
0x14
,
0x57
,
0x1f
,
0xa5
,
0xcc
};
uint8_t
in
[]
=
{
0xbd
,
0x33
,
0x4f
,
0x1d
,
0x6e
,
0x45
,
0xf2
,
0x5f
,
0xf7
,
0x12
,
0xa2
,
0x14
,
0x57
,
0x1f
,
0xa5
,
0xcc
};
#elif defined(AES256)
#elif defined(AES128)
uint8_t
key
[]
=
{
0x60
,
0x3d
,
0xeb
,
0x10
,
0x15
,
0xca
,
0x71
,
0xbe
,
0x2b
,
0x73
,
0xae
,
0xf0
,
0x85
,
0x7d
,
0x77
,
0x81
,
uint8_t
key
[]
=
{
0x2b
,
0x7e
,
0x15
,
0x16
,
0x28
,
0xae
,
0xd2
,
0xa6
,
0xab
,
0xf7
,
0x15
,
0x88
,
0x09
,
0xcf
,
0x4f
,
0x3c
};
0x1f
,
0x35
,
0x2c
,
0x07
,
0x3b
,
0x61
,
0x08
,
0xd7
,
0x2d
,
0x98
,
0x10
,
0xa3
,
0x09
,
0x14
,
0xdf
,
0xf4
};
uint8_t
in
[]
=
{
0x3a
,
0xd7
,
0x7b
,
0xb4
,
0x0d
,
0x7a
,
0x36
,
0x60
,
0xa8
,
0x9e
,
0xca
,
0xf3
,
0x24
,
0x66
,
0xef
,
0x97
};
uint8_t
in
[]
=
{
0xf3
,
0xee
,
0xd1
,
0xbd
,
0xb5
,
0xd2
,
0xa0
,
0x3c
,
0x06
,
0x4b
,
0x5a
,
0x7e
,
0x3d
,
0xb1
,
0x81
,
0xf8
};
#endif
#endif
uint8_t
out
[]
=
{
0x6b
,
0xc1
,
0xbe
,
0xe2
,
0x2e
,
0x40
,
0x9f
,
0x96
,
0xe9
,
0x3d
,
0x7e
,
0x11
,
0x73
,
0x93
,
0x17
,
0x2a
};
uint8_t
out
[]
=
{
0x6b
,
0xc1
,
0xbe
,
0xe2
,
0x2e
,
0x40
,
0x9f
,
0x96
,
0xe9
,
0x3d
,
0x7e
,
0x11
,
0x73
,
0x93
,
0x17
,
0x2a
};
...
@@ -313,13 +304,12 @@ static void test_decrypt_ecb(void)
...
@@ -313,13 +304,12 @@ static void test_decrypt_ecb(void)
printf
(
"ECB decrypt: "
);
printf
(
"ECB decrypt: "
);
if
(
0
==
memcmp
((
char
*
)
out
,
(
char
*
)
in
,
16
))
if
(
0
==
memcmp
((
char
*
)
out
,
(
char
*
)
in
,
16
))
{
{
printf
(
"SUCCESS!
\n
"
);
printf
(
"SUCCESS!
\n
"
);
}
return
(
0
);
else
}
else
{
{
printf
(
"FAILURE!
\n
"
);
printf
(
"FAILURE!
\n
"
);
return
(
1
);
}
}
}
}
...
...
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