Commit dff5243d authored by Romain TISSERAND's avatar Romain TISSERAND
Browse files

Update libchdr to upstream

parent 6c43edeb
......@@ -16,69 +16,64 @@ INCFLAGS := -I$(CORE_DIR) \
-I$(LIBRETRO_COMM_DIR)/include
LIBCHDR_INCFLAGS = \
-I$(DEPS_DIR)/crypto \
-I$(DEPS_DIR)/flac-1.3.2/include \
-I$(DEPS_DIR)/flac-1.3.2/src/libFLAC/include \
-I$(DEPS_DIR)/lzma-16.04/C \
-I$(DEPS_DIR)/libchdr
-I$(DEPS_DIR)/flac-1.3.3/include \
-I$(DEPS_DIR)/flac-1.3.3/src/include \
-I$(DEPS_DIR)/lzma-19.00/include \
-I$(DEPS_DIR)/libchdr/include
LIBCHDR_SOURCES_C = \
$(DEPS_DIR)/crypto/md5.c \
$(DEPS_DIR)/crypto/sha1.c \
$(DEPS_DIR)/flac-1.3.2/src/libFLAC/bitmath.c \
$(DEPS_DIR)/flac-1.3.2/src/libFLAC/bitreader.c \
$(DEPS_DIR)/flac-1.3.2/src/libFLAC/cpu.c \
$(DEPS_DIR)/flac-1.3.2/src/libFLAC/crc.c \
$(DEPS_DIR)/flac-1.3.2/src/libFLAC/fixed.c \
$(DEPS_DIR)/flac-1.3.2/src/libFLAC/fixed_intrin_sse2.c \
$(DEPS_DIR)/flac-1.3.2/src/libFLAC/fixed_intrin_ssse3.c \
$(DEPS_DIR)/flac-1.3.2/src/libFLAC/float.c \
$(DEPS_DIR)/flac-1.3.2/src/libFLAC/format.c \
$(DEPS_DIR)/flac-1.3.2/src/libFLAC/lpc.c \
$(DEPS_DIR)/flac-1.3.2/src/libFLAC/lpc_intrin_avx2.c \
$(DEPS_DIR)/flac-1.3.2/src/libFLAC/lpc_intrin_sse2.c \
$(DEPS_DIR)/flac-1.3.2/src/libFLAC/lpc_intrin_sse41.c \
$(DEPS_DIR)/flac-1.3.2/src/libFLAC/lpc_intrin_sse.c \
$(DEPS_DIR)/flac-1.3.2/src/libFLAC/md5.c \
$(DEPS_DIR)/flac-1.3.2/src/libFLAC/memory.c \
$(DEPS_DIR)/flac-1.3.2/src/libFLAC/metadata_iterators.c \
$(DEPS_DIR)/flac-1.3.2/src/libFLAC/metadata_object.c \
$(DEPS_DIR)/flac-1.3.2/src/libFLAC/stream_decoder.c \
$(DEPS_DIR)/flac-1.3.2/src/libFLAC/window.c \
$(DEPS_DIR)/lzma-16.04/C/Alloc.c \
$(DEPS_DIR)/lzma-16.04/C/Bra86.c \
$(DEPS_DIR)/lzma-16.04/C/Bra.c \
$(DEPS_DIR)/lzma-16.04/C/BraIA64.c \
$(DEPS_DIR)/lzma-16.04/C/CpuArch.c \
$(DEPS_DIR)/lzma-16.04/C/Delta.c \
$(DEPS_DIR)/lzma-16.04/C/LzFind.c \
$(DEPS_DIR)/lzma-16.04/C/Lzma86Dec.c \
$(DEPS_DIR)/lzma-16.04/C/Lzma86Enc.c \
$(DEPS_DIR)/lzma-16.04/C/LzmaDec.c \
$(DEPS_DIR)/lzma-16.04/C/LzmaEnc.c \
$(DEPS_DIR)/lzma-16.04/C/LzmaLib.c \
$(DEPS_DIR)/lzma-16.04/C/Sort.c \
$(DEPS_DIR)/libchdr/bitstream.c \
$(DEPS_DIR)/libchdr/cdrom.c \
$(DEPS_DIR)/libchdr/chd.c \
$(DEPS_DIR)/libchdr/flac.c \
$(DEPS_DIR)/libchdr/huffman.c
$(DEPS_DIR)/flac-1.3.3/src/bitmath.c \
$(DEPS_DIR)/flac-1.3.3/src/bitreader.c \
$(DEPS_DIR)/flac-1.3.3/src/cpu.c \
$(DEPS_DIR)/flac-1.3.3/src/crc.c \
$(DEPS_DIR)/flac-1.3.3/src/fixed.c \
$(DEPS_DIR)/flac-1.3.3/src/fixed_intrin_sse2.c \
$(DEPS_DIR)/flac-1.3.3/src/fixed_intrin_ssse3.c \
$(DEPS_DIR)/flac-1.3.3/src/float.c \
$(DEPS_DIR)/flac-1.3.3/src/format.c \
$(DEPS_DIR)/flac-1.3.3/src/lpc.c \
$(DEPS_DIR)/flac-1.3.3/src/lpc_intrin_avx2.c \
$(DEPS_DIR)/flac-1.3.3/src/lpc_intrin_sse2.c \
$(DEPS_DIR)/flac-1.3.3/src/lpc_intrin_sse41.c \
$(DEPS_DIR)/flac-1.3.3/src/lpc_intrin_sse.c \
$(DEPS_DIR)/flac-1.3.3/src/md5.c \
$(DEPS_DIR)/flac-1.3.3/src/memory.c \
$(DEPS_DIR)/flac-1.3.3/src/metadata_iterators.c \
$(DEPS_DIR)/flac-1.3.3/src/metadata_object.c \
$(DEPS_DIR)/flac-1.3.3/src/stream_decoder.c \
$(DEPS_DIR)/flac-1.3.3/src/window.c \
$(DEPS_DIR)/lzma-19.00/src/Alloc.c \
$(DEPS_DIR)/lzma-19.00/src/Bra86.c \
$(DEPS_DIR)/lzma-19.00/src/BraIA64.c \
$(DEPS_DIR)/lzma-19.00/src/CpuArch.c \
$(DEPS_DIR)/lzma-19.00/src/Delta.c \
$(DEPS_DIR)/lzma-19.00/src/LzFind.c \
$(DEPS_DIR)/lzma-19.00/src/Lzma86Dec.c \
$(DEPS_DIR)/lzma-19.00/src/Lzma86Enc.c \
$(DEPS_DIR)/lzma-19.00/src/LzmaDec.c \
$(DEPS_DIR)/lzma-19.00/src/LzmaEnc.c \
$(DEPS_DIR)/lzma-19.00/src/Sort.c \
$(DEPS_DIR)/libchdr/src/libchdr_bitstream.c \
$(DEPS_DIR)/libchdr/src/libchdr_cdrom.c \
$(DEPS_DIR)/libchdr/src/libchdr_chd.c \
$(DEPS_DIR)/libchdr/src/libchdr_flac.c \
$(DEPS_DIR)/libchdr/src/libchdr_huffman.c
ZLIB_INCFLAGS = -I$(DEPS_DIR)/zlib
ZLIB_SOURCES_C = \
$(DEPS_DIR)/zlib/adler32.c \
$(DEPS_DIR)/zlib/compress.c \
$(DEPS_DIR)/zlib/crc32.c \
$(DEPS_DIR)/zlib/deflate.c \
$(DEPS_DIR)/zlib/gzclose.c \
$(DEPS_DIR)/zlib/gzlib.c \
$(DEPS_DIR)/zlib/gzread.c \
$(DEPS_DIR)/zlib/gzwrite.c \
$(DEPS_DIR)/zlib/inffast.c \
$(DEPS_DIR)/zlib/inflate.c \
$(DEPS_DIR)/zlib/inftrees.c \
$(DEPS_DIR)/zlib/trees.c \
$(DEPS_DIR)/zlib/uncompr.c \
$(DEPS_DIR)/zlib/zutil.c
$(DEPS_DIR)/zlib-1.2.11/adler32.c \
$(DEPS_DIR)/zlib-1.2.11/compress.c \
$(DEPS_DIR)/zlib-1.2.11/crc32.c \
$(DEPS_DIR)/zlib-1.2.11/deflate.c \
$(DEPS_DIR)/zlib-1.2.11/gzclose.c \
$(DEPS_DIR)/zlib-1.2.11/gzlib.c \
$(DEPS_DIR)/zlib-1.2.11/gzread.c \
$(DEPS_DIR)/zlib-1.2.11/gzwrite.c \
$(DEPS_DIR)/zlib-1.2.11/inffast.c \
$(DEPS_DIR)/zlib-1.2.11/inflate.c \
$(DEPS_DIR)/zlib-1.2.11/inftrees.c \
$(DEPS_DIR)/zlib-1.2.11/trees.c \
$(DEPS_DIR)/zlib-1.2.11/uncompr.c \
$(DEPS_DIR)/zlib-1.2.11/zutil.c
ifneq (,$(findstring msvc2003,$(platform)))
INCFLAGS += -I$(LIBRETRO_COMM_DIR)/include/compat/msvc
......@@ -168,7 +163,7 @@ endif
FLAGS += -DNEED_CD
ifeq ($(HAVE_CHD), 1)
FLAGS += -DHAVE_CHD -D_7ZIP_ST -DPACKAGE_VERSION=\"1.3.2\" -DFLAC_API_EXPORTS -DFLAC__HAS_OGG=0 -DHAVE_LROUND -DHAVE_STDINT_H -DHAVE_STDLIB_H -DHAVE_SYS_PARAM_H
FLAGS += -DHAVE_CHD -D_7ZIP_ST -DPACKAGE_VERSION=\"1.3.3\" -DFLAC_API_EXPORTS -DFLAC__HAS_OGG=0 -DHAVE_LROUND -DHAVE_STDINT_H -DHAVE_STDLIB_H -DHAVE_SYS_PARAM_H
ifeq ($(platform), win)
FLAGS += -DHAVE_FSEEKO
endif
......@@ -180,7 +175,7 @@ ifeq ($(HAVE_CHD), 1)
INCFLAGS += $(LIBCHDR_INCFLAGS)
SOURCES_C += $(LIBCHDR_SOURCES_C)
ifeq ($(WINDOWS_VERSION), 1)
SOURCES_C += $(DEPS_DIR)/flac-1.3.2/src/libFLAC/windows_unicode_filenames.c
SOURCES_C += $(DEPS_DIR)/flac-1.3.3/src/windows_unicode_filenames.c
endif
endif
......
crypto-algorithms
=================
About
---
These are basic implementations of standard cryptography algorithms, written by Brad Conte (brad@bradconte.com) from scratch and without any cross-licensing. They exist to provide publically accessible, restriction-free implementations of popular cryptographic algorithms, like AES and SHA-1. These are primarily intended for educational and pragmatic purposes (such as comparing a specification to actual implementation code, or for building an internal application that computes test vectors for a product). The algorithms have been tested against standard test vectors.
This code is released into the public domain free of any restrictions. The author requests acknowledgement if the code is used, but does not require it. This code is provided free of any liability and without any quality claims by the author.
Note that these are *not* cryptographically secure implementations. They have no resistence to side-channel attacks and should not be used in contexts that need cryptographically secure implementations.
These algorithms are not optimized for speed or space. They are primarily designed to be easy to read, although some basic optimization techniques have been employed.
Building
---
The source code for each algorithm will come in a pair of a source code file and a header file. There should be no inter-header file dependencies, no additional libraries, no platform-specific header files, or any other complicating matters. Compiling them should be as easy as adding the relevent source code to the project.
\ No newline at end of file
This diff is collapsed.
/*********************************************************************
* Filename: aes.h
* Author: Brad Conte (brad AT bradconte.com)
* Copyright:
* Disclaimer: This code is presented "as is" without any guarantees.
* Details: Defines the API for the corresponding AES implementation.
*********************************************************************/
#ifndef AES_H
#define AES_H
/*************************** HEADER FILES ***************************/
#include <stddef.h>
/****************************** MACROS ******************************/
#define AES_BLOCK_SIZE 16 // AES operates on 16 bytes at a time
/**************************** DATA TYPES ****************************/
typedef unsigned char BYTE; // 8-bit byte
typedef unsigned int WORD; // 32-bit word, change to "long" for 16-bit machines
/*********************** FUNCTION DECLARATIONS **********************/
///////////////////
// AES
///////////////////
// Key setup must be done before any AES en/de-cryption functions can be used.
void aes_key_setup(const BYTE key[], // The key, must be 128, 192, or 256 bits
WORD w[], // Output key schedule to be used later
int keysize); // Bit length of the key, 128, 192, or 256
void aes_encrypt(const BYTE in[], // 16 bytes of plaintext
BYTE out[], // 16 bytes of ciphertext
const WORD key[], // From the key setup
int keysize); // Bit length of the key, 128, 192, or 256
void aes_decrypt(const BYTE in[], // 16 bytes of ciphertext
BYTE out[], // 16 bytes of plaintext
const WORD key[], // From the key setup
int keysize); // Bit length of the key, 128, 192, or 256
///////////////////
// AES - CBC
///////////////////
int aes_encrypt_cbc(const BYTE in[], // Plaintext
size_t in_len, // Must be a multiple of AES_BLOCK_SIZE
BYTE out[], // Ciphertext, same length as plaintext
const WORD key[], // From the key setup
int keysize, // Bit length of the key, 128, 192, or 256
const BYTE iv[]); // IV, must be AES_BLOCK_SIZE bytes long
// Only output the CBC-MAC of the input.
int aes_encrypt_cbc_mac(const BYTE in[], // plaintext
size_t in_len, // Must be a multiple of AES_BLOCK_SIZE
BYTE out[], // Output MAC
const WORD key[], // From the key setup
int keysize, // Bit length of the key, 128, 192, or 256
const BYTE iv[]); // IV, must be AES_BLOCK_SIZE bytes long
///////////////////
// AES - CTR
///////////////////
void increment_iv(BYTE iv[], // Must be a multiple of AES_BLOCK_SIZE
int counter_size); // Bytes of the IV used for counting (low end)
void aes_encrypt_ctr(const BYTE in[], // Plaintext
size_t in_len, // Any byte length
BYTE out[], // Ciphertext, same length as plaintext
const WORD key[], // From the key setup
int keysize, // Bit length of the key, 128, 192, or 256
const BYTE iv[]); // IV, must be AES_BLOCK_SIZE bytes long
void aes_decrypt_ctr(const BYTE in[], // Ciphertext
size_t in_len, // Any byte length
BYTE out[], // Plaintext, same length as ciphertext
const WORD key[], // From the key setup
int keysize, // Bit length of the key, 128, 192, or 256
const BYTE iv[]); // IV, must be AES_BLOCK_SIZE bytes long
///////////////////
// AES - CCM
///////////////////
// Returns True if the input parameters do not violate any constraint.
int aes_encrypt_ccm(const BYTE plaintext[], // IN - Plaintext.
WORD plaintext_len, // IN - Plaintext length.
const BYTE associated_data[], // IN - Associated Data included in authentication, but not encryption.
unsigned short associated_data_len, // IN - Associated Data length in bytes.
const BYTE nonce[], // IN - The Nonce to be used for encryption.
unsigned short nonce_len, // IN - Nonce length in bytes.
BYTE ciphertext[], // OUT - Ciphertext, a concatination of the plaintext and the MAC.
WORD *ciphertext_len, // OUT - The length of the ciphertext, always plaintext_len + mac_len.
WORD mac_len, // IN - The desired length of the MAC, must be 4, 6, 8, 10, 12, 14, or 16.
const BYTE key[], // IN - The AES key for encryption.
int keysize); // IN - The length of the key in bits. Valid values are 128, 192, 256.
// Returns True if the input parameters do not violate any constraint.
// Use mac_auth to ensure decryption/validation was preformed correctly.
// If authentication does not succeed, the plaintext is zeroed out. To overwride
// this, call with mac_auth = NULL. The proper proceedure is to decrypt with
// authentication enabled (mac_auth != NULL) and make a second call to that
// ignores authentication explicitly if the first call failes.
int aes_decrypt_ccm(const BYTE ciphertext[], // IN - Ciphertext, the concatination of encrypted plaintext and MAC.
WORD ciphertext_len, // IN - Ciphertext length in bytes.
const BYTE assoc[], // IN - The Associated Data, required for authentication.
unsigned short assoc_len, // IN - Associated Data length in bytes.
const BYTE nonce[], // IN - The Nonce to use for decryption, same one as for encryption.
unsigned short nonce_len, // IN - Nonce length in bytes.
BYTE plaintext[], // OUT - The plaintext that was decrypted. Will need to be large enough to hold ciphertext_len - mac_len.
WORD *plaintext_len, // OUT - Length in bytes of the output plaintext, always ciphertext_len - mac_len .
WORD mac_len, // IN - The length of the MAC that was calculated.
int *mac_auth, // OUT - TRUE if authentication succeeded, FALSE if it did not. NULL pointer will ignore the authentication.
const BYTE key[], // IN - The AES key for decryption.
int keysize); // IN - The length of the key in BITS. Valid values are 128, 192, 256.
///////////////////
// Test functions
///////////////////
int aes_test();
int aes_ecb_test();
int aes_cbc_test();
int aes_ctr_test();
int aes_ccm_test();
#endif // AES_H
/*********************************************************************
* Filename: aes_test.c
* Author: Brad Conte (brad AT bradconte.com)
* Copyright:
* Disclaimer: This code is presented "as is" without any guarantees.
* Details: Performs known-answer tests on the corresponding AES
implementation. These tests do not encompass the full
range of available test vectors and are not sufficient
for FIPS-140 certification. However, if the tests pass
it is very, very likely that the code is correct and was
compiled properly. This code also serves as
example usage of the functions.
*********************************************************************/
/*************************** HEADER FILES ***************************/
#include <stdio.h>
#include <memory.h>
#include "aes.h"
/*********************** FUNCTION DEFINITIONS ***********************/
void print_hex(BYTE str[], int len)
{
int idx;
for(idx = 0; idx < len; idx++)
printf("%02x", str[idx]);
}
int aes_ecb_test()
{
WORD key_schedule[60], idx;
BYTE enc_buf[128];
BYTE plaintext[2][16] = {
{0x6b,0xc1,0xbe,0xe2,0x2e,0x40,0x9f,0x96,0xe9,0x3d,0x7e,0x11,0x73,0x93,0x17,0x2a},
{0xae,0x2d,0x8a,0x57,0x1e,0x03,0xac,0x9c,0x9e,0xb7,0x6f,0xac,0x45,0xaf,0x8e,0x51}
};
BYTE ciphertext[2][16] = {
{0xf3,0xee,0xd1,0xbd,0xb5,0xd2,0xa0,0x3c,0x06,0x4b,0x5a,0x7e,0x3d,0xb1,0x81,0xf8},
{0x59,0x1c,0xcb,0x10,0xd4,0x10,0xed,0x26,0xdc,0x5b,0xa7,0x4a,0x31,0x36,0x28,0x70}
};
BYTE key[1][32] = {
{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}
};
int pass = 1;
// Raw ECB mode.
//printf("* ECB mode:\n");
aes_key_setup(key[0], key_schedule, 256);
//printf( "Key : ");
//print_hex(key[0], 32);
for(idx = 0; idx < 2; idx++) {
aes_encrypt(plaintext[idx], enc_buf, key_schedule, 256);
//printf("\nPlaintext : ");
//print_hex(plaintext[idx], 16);
//printf("\n-encrypted to: ");
//print_hex(enc_buf, 16);
pass = pass && !memcmp(enc_buf, ciphertext[idx], 16);
aes_decrypt(ciphertext[idx], enc_buf, key_schedule, 256);
//printf("\nCiphertext : ");
//print_hex(ciphertext[idx], 16);
//printf("\n-decrypted to: ");
//print_hex(enc_buf, 16);
pass = pass && !memcmp(enc_buf, plaintext[idx], 16);
//printf("\n\n");
}
return(pass);
}
int aes_cbc_test()
{
WORD key_schedule[60];
BYTE enc_buf[128];
BYTE plaintext[1][32] = {
{0x6b,0xc1,0xbe,0xe2,0x2e,0x40,0x9f,0x96,0xe9,0x3d,0x7e,0x11,0x73,0x93,0x17,0x2a,0xae,0x2d,0x8a,0x57,0x1e,0x03,0xac,0x9c,0x9e,0xb7,0x6f,0xac,0x45,0xaf,0x8e,0x51}
};
BYTE ciphertext[1][32] = {
{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}
};
BYTE iv[1][16] = {
{0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f}
};
BYTE key[1][32] = {
{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}
};
int pass = 1;
//printf("* CBC mode:\n");
aes_key_setup(key[0], key_schedule, 256);
//printf( "Key : ");
//print_hex(key[0], 32);
//printf("\nIV : ");
//print_hex(iv[0], 16);
aes_encrypt_cbc(plaintext[0], 32, enc_buf, key_schedule, 256, iv[0]);
//printf("\nPlaintext : ");
//print_hex(plaintext[0], 32);
//printf("\n-encrypted to: ");
//print_hex(enc_buf, 32);
//printf("\nCiphertext : ");
//print_hex(ciphertext[0], 32);
pass = pass && !memcmp(enc_buf, ciphertext[0], 32);
aes_decrypt_cbc(ciphertext[0], 32, enc_buf, key_schedule, 256, iv[0]);
//printf("\nCiphertext : ");
//print_hex(ciphertext[0], 32);
//printf("\n-decrypted to: ");
//print_hex(enc_buf, 32);
//printf("\nPlaintext : ");
//print_hex(plaintext[0], 32);
pass = pass && !memcmp(enc_buf, plaintext[0], 32);
//printf("\n\n");
return(pass);
}
int aes_ctr_test()
{
WORD key_schedule[60];
BYTE enc_buf[128];
BYTE plaintext[1][32] = {
{0x6b,0xc1,0xbe,0xe2,0x2e,0x40,0x9f,0x96,0xe9,0x3d,0x7e,0x11,0x73,0x93,0x17,0x2a,0xae,0x2d,0x8a,0x57,0x1e,0x03,0xac,0x9c,0x9e,0xb7,0x6f,0xac,0x45,0xaf,0x8e,0x51}
};
BYTE ciphertext[1][32] = {
{0x60,0x1e,0xc3,0x13,0x77,0x57,0x89,0xa5,0xb7,0xa7,0xf5,0x04,0xbb,0xf3,0xd2,0x28,0xf4,0x43,0xe3,0xca,0x4d,0x62,0xb5,0x9a,0xca,0x84,0xe9,0x90,0xca,0xca,0xf5,0xc5}
};
BYTE iv[1][16] = {
{0xf0,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa,0xfb,0xfc,0xfd,0xfe,0xff},
};
BYTE key[1][32] = {
{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}
};
int pass = 1;
//printf("* CTR mode:\n");
aes_key_setup(key[0], key_schedule, 256);
//printf( "Key : ");
//print_hex(key[0], 32);
//printf("\nIV : ");
//print_hex(iv[0], 16);
aes_encrypt_ctr(plaintext[0], 32, enc_buf, key_schedule, 256, iv[0]);
//printf("\nPlaintext : ");
//print_hex(plaintext[0], 32);
//printf("\n-encrypted to: ");
//print_hex(enc_buf, 32);
pass = pass && !memcmp(enc_buf, ciphertext[0], 32);
aes_decrypt_ctr(ciphertext[0], 32, enc_buf, key_schedule, 256, iv[0]);
//printf("\nCiphertext : ");
//print_hex(ciphertext[0], 32);
//printf("\n-decrypted to: ");
//print_hex(enc_buf, 32);
pass = pass && !memcmp(enc_buf, plaintext[0], 32);
//printf("\n\n");
return(pass);
}
int aes_ccm_test()
{
int mac_auth;
WORD enc_buf_len;
BYTE enc_buf[128];
BYTE plaintext[3][32] = {
{0x20,0x21,0x22,0x23},
{0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f},
{0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37}
};
BYTE assoc[3][32] = {
{0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07},
{0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f},
{0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13}
};
BYTE ciphertext[3][32 + 16] = {
{0x71,0x62,0x01,0x5b,0x4d,0xac,0x25,0x5d},
{0xd2,0xa1,0xf0,0xe0,0x51,0xea,0x5f,0x62,0x08,0x1a,0x77,0x92,0x07,0x3d,0x59,0x3d,0x1f,0xc6,0x4f,0xbf,0xac,0xcd},
{0xe3,0xb2,0x01,0xa9,0xf5,0xb7,0x1a,0x7a,0x9b,0x1c,0xea,0xec,0xcd,0x97,0xe7,0x0b,0x61,0x76,0xaa,0xd9,0xa4,0x42,0x8a,0xa5,0x48,0x43,0x92,0xfb,0xc1,0xb0,0x99,0x51}
};
BYTE iv[3][16] = {
{0x10,0x11,0x12,0x13,0x14,0x15,0x16},
{0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17},
{0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b}
};
BYTE key[1][32] = {
{0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f}
};
int pass = 1;
//printf("* CCM mode:\n");
//printf("Key : ");
//print_hex(key[0], 16);
//print_hex(plaintext[0], 4);
//print_hex(assoc[0], 8);
//print_hex(ciphertext[0], 8);
//print_hex(iv[0], 7);
//print_hex(key[0], 16);
aes_encrypt_ccm(plaintext[0], 4, assoc[0], 8, iv[0], 7, enc_buf, &enc_buf_len, 4, key[0], 128);
//printf("\nNONCE : ");
//print_hex(iv[0], 7);
//printf("\nAssoc. Data : ");
//print_hex(assoc[0], 8);
//printf("\nPayload : ");
//print_hex(plaintext[0], 4);
//printf("\n-encrypted to: ");
//print_hex(enc_buf, enc_buf_len);
pass = pass && !memcmp(enc_buf, ciphertext[0], enc_buf_len);
aes_decrypt_ccm(ciphertext[0], 8, assoc[0], 8, iv[0], 7, enc_buf, &enc_buf_len, 4, &mac_auth, key[0], 128);
//printf("\n-Ciphertext : ");
//print_hex(ciphertext[0], 8);
//printf("\n-decrypted to: ");
//print_hex(enc_buf, enc_buf_len);
//printf("\nAuthenticated: %d ", mac_auth);
pass = pass && !memcmp(enc_buf, plaintext[0], enc_buf_len) && mac_auth;
aes_encrypt_ccm(plaintext[1], 16, assoc[1], 16, iv[1], 8, enc_buf, &enc_buf_len, 6, key[0], 128);
//printf("\n\nNONCE : ");
//print_hex(iv[1], 8);
//printf("\nAssoc. Data : ");
//print_hex(assoc[1], 16);
//printf("\nPayload : ");
//print_hex(plaintext[1], 16);
//printf("\n-encrypted to: ");
//print_hex(enc_buf, enc_buf_len);
pass = pass && !memcmp(enc_buf, ciphertext[1], enc_buf_len);
aes_decrypt_ccm(ciphertext[1], 22, assoc[1], 16, iv[1], 8, enc_buf, &enc_buf_len, 6, &mac_auth, key[0], 128);
//printf("\n-Ciphertext : ");
//print_hex(ciphertext[1], 22);
//printf("\n-decrypted to: ");
//print_hex(enc_buf, enc_buf_len);
//printf("\nAuthenticated: %d ", mac_auth);
pass = pass && !memcmp(enc_buf, plaintext[1], enc_buf_len) && mac_auth;
aes_encrypt_ccm(plaintext[2], 24, assoc[2], 20, iv[2], 12, enc_buf, &enc_buf_len, 8, key[0], 128);
//printf("\n\nNONCE : ");
//print_hex(iv[2], 12);
//printf("\nAssoc. Data : ");
//print_hex(assoc[2], 20);
//printf("\nPayload : ");
//print_hex(plaintext[2], 24);
//printf("\n-encrypted to: ");
//print_hex(enc_buf, enc_buf_len);
pass = pass && !memcmp(enc_buf, ciphertext[2], enc_buf_len);
aes_decrypt_ccm(ciphertext[2], 32, assoc[2], 20, iv[2], 12, enc_buf, &enc_buf_len, 8, &mac_auth, key[0], 128);
//printf("\n-Ciphertext : ");
//print_hex(ciphertext[2], 32);
//printf("\n-decrypted to: ");
//print_hex(enc_buf, enc_buf_len);
//printf("\nAuthenticated: %d ", mac_auth);
pass = pass && !memcmp(enc_buf, plaintext[2], enc_buf_len) && mac_auth;
//printf("\n\n");
return(pass);
}
int aes_test()
{
int pass = 1;
pass = pass && aes_ecb_test();
pass = pass && aes_cbc_test();
pass = pass && aes_ctr_test();
pass = pass && aes_ccm_test();
return(pass);
}
int main(int argc, char *argv[])
{
printf("AES Tests: %s\n", aes_test() ? "SUCCEEDED" : "FAILED");
return(0);
}
/*********************************************************************
* Filename: arcfour.c
* Author: Brad Conte (brad AT bradconte.com)
* Copyright:
* Disclaimer: This code is presented "as is" without any guarantees.
* Details: Implementation of the ARCFOUR encryption algorithm.
Algorithm specification can be found here:
* http://en.wikipedia.org/wiki/RC4
*********************************************************************/
/*************************** HEADER FILES ***************************/
#include <stdlib.h>
#include "arcfour.h"
/*********************** FUNCTION DEFINITIONS ***********************/
void arcfour_key_setup(BYTE state[], const BYTE key[], int len)
{
int i, j;
BYTE t;
for (i = 0; i < 256; ++i)
state[i] = i;
for (i = 0, j = 0; i < 256; ++i) {
j = (j + state[i] + key[i % len]) % 256;
t = state[i];
state[i] = state[j];
state[j] = t;
}
}
// This does not hold state between calls. It always generates the
// stream starting from the first output byte.
void arcfour_generate_stream(BYTE state[], BYTE out[], size_t len)
{
int i, j;
size_t idx;
BYTE t;