| /programs/develop/ktcc/trunk/libc/include/cryptal/aes.h |
|---|
| 0,0 → 1,123 |
| /********************************************************************* |
| * 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 |
| /programs/develop/ktcc/trunk/libc/include/cryptal/arcfour.h |
|---|
| 0,0 → 1,30 |
| /********************************************************************* |
| * Filename: arcfour.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 ARCFOUR implementation. |
| *********************************************************************/ |
| #ifndef ARCFOUR_H |
| #define ARCFOUR_H |
| /*************************** HEADER FILES ***************************/ |
| #include <stddef.h> |
| /**************************** DATA TYPES ****************************/ |
| typedef unsigned char BYTE; // 8-bit byte |
| /*********************** FUNCTION DECLARATIONS **********************/ |
| // Input: state - the state used to generate the keystream |
| // key - Key to use to initialize the state |
| // len - length of key in bytes (valid lenth is 1 to 256) |
| void arcfour_key_setup(BYTE state[], const BYTE key[], int len); |
| // Pseudo-Random Generator Algorithm |
| // Input: state - the state used to generate the keystream |
| // out - Must be allocated to be of at least "len" length |
| // len - number of bytes to generate |
| void arcfour_generate_stream(BYTE state[], BYTE out[], size_t len); |
| #endif // ARCFOUR_H |
| /programs/develop/ktcc/trunk/libc/include/cryptal/base64.h |
|---|
| 0,0 → 1,27 |
| /********************************************************************* |
| * Filename: base64.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 Base64 implementation. |
| *********************************************************************/ |
| #ifndef BASE64_H |
| #define BASE64_H |
| /*************************** HEADER FILES ***************************/ |
| #include <stddef.h> |
| /**************************** DATA TYPES ****************************/ |
| typedef unsigned char BYTE; // 8-bit byte |
| /*********************** FUNCTION DECLARATIONS **********************/ |
| // Returns the size of the output. If called with out = NULL, will just return |
| // the size of what the output would have been (without a terminating NULL). |
| size_t base64_encode(const BYTE in[], BYTE out[], size_t len, int newline_flag); |
| // Returns the size of the output. If called with out = NULL, will just return |
| // the size of what the output would have been (without a terminating NULL). |
| size_t base64_decode(const BYTE in[], BYTE out[], size_t len); |
| #endif // BASE64_H |
| /programs/develop/ktcc/trunk/libc/include/cryptal/blowfish.h |
|---|
| 0,0 → 1,32 |
| /********************************************************************* |
| * Filename: blowfish.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 Blowfish implementation. |
| *********************************************************************/ |
| #ifndef BLOWFISH_H |
| #define BLOWFISH_H |
| /*************************** HEADER FILES ***************************/ |
| #include <stddef.h> |
| /****************************** MACROS ******************************/ |
| #define BLOWFISH_BLOCK_SIZE 8 // Blowfish operates on 8 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 |
| typedef struct { |
| WORD p[18]; |
| WORD s[4][256]; |
| } BLOWFISH_KEY; |
| /*********************** FUNCTION DECLARATIONS **********************/ |
| void blowfish_key_setup(const BYTE user_key[], BLOWFISH_KEY *keystruct, size_t len); |
| void blowfish_encrypt(const BYTE in[], BYTE out[], const BLOWFISH_KEY *keystruct); |
| void blowfish_decrypt(const BYTE in[], BYTE out[], const BLOWFISH_KEY *keystruct); |
| #endif // BLOWFISH_H |
| /programs/develop/ktcc/trunk/libc/include/cryptal/des.h |
|---|
| 0,0 → 1,37 |
| /********************************************************************* |
| * Filename: des.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 DES implementation. |
| Note that encryption and decryption are defined by how |
| the key setup is performed, the actual en/de-cryption is |
| performed by the same function. |
| *********************************************************************/ |
| #ifndef DES_H |
| #define DESH |
| /*************************** HEADER FILES ***************************/ |
| #include <stddef.h> |
| /****************************** MACROS ******************************/ |
| #define DES_BLOCK_SIZE 8 // DES operates on 8 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 |
| typedef enum { |
| DES_ENCRYPT, |
| DES_DECRYPT |
| } DES_MODE; |
| /*********************** FUNCTION DECLARATIONS **********************/ |
| void des_key_setup(const BYTE key[], BYTE schedule[][6], DES_MODE mode); |
| void des_crypt(const BYTE in[], BYTE out[], const BYTE key[][6]); |
| void three_des_key_setup(const BYTE key[], BYTE schedule[][16][6], DES_MODE mode); |
| void three_des_crypt(const BYTE in[], BYTE out[], const BYTE key[][16][6]); |
| #endif // DES_H |
| /programs/develop/ktcc/trunk/libc/include/cryptal/md2.h |
|---|
| 0,0 → 1,33 |
| /********************************************************************* |
| * Filename: md2.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 MD2 implementation. |
| *********************************************************************/ |
| #ifndef MD2_H |
| #define MD2_H |
| /*************************** HEADER FILES ***************************/ |
| #include <stddef.h> |
| /****************************** MACROS ******************************/ |
| #define MD2_BLOCK_SIZE 16 |
| /**************************** DATA TYPES ****************************/ |
| typedef unsigned char BYTE; // 8-bit byte |
| typedef struct { |
| BYTE data[16]; |
| BYTE state[48]; |
| BYTE checksum[16]; |
| int len; |
| } MD2_CTX; |
| /*********************** FUNCTION DECLARATIONS **********************/ |
| void md2_init(MD2_CTX *ctx); |
| void md2_update(MD2_CTX *ctx, const BYTE data[], size_t len); |
| void md2_final(MD2_CTX *ctx, BYTE hash[]); // size of hash must be MD2_BLOCK_SIZE |
| #endif // MD2_H |
| /programs/develop/ktcc/trunk/libc/include/cryptal/md5.h |
|---|
| 0,0 → 1,34 |
| /********************************************************************* |
| * Filename: md5.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 MD5 implementation. |
| *********************************************************************/ |
| #ifndef MD5_H |
| #define MD5_H |
| /*************************** HEADER FILES ***************************/ |
| #include <stddef.h> |
| /****************************** MACROS ******************************/ |
| #define MD5_BLOCK_SIZE 16 // MD5 outputs a 16 byte digest |
| /**************************** DATA TYPES ****************************/ |
| typedef unsigned char BYTE; // 8-bit byte |
| typedef unsigned int WORD; // 32-bit word, change to "long" for 16-bit machines |
| typedef struct { |
| BYTE data[64]; |
| WORD datalen; |
| unsigned long long bitlen; |
| WORD state[4]; |
| } MD5_CTX; |
| /*********************** FUNCTION DECLARATIONS **********************/ |
| void md5_init(MD5_CTX *ctx); |
| void md5_update(MD5_CTX *ctx, const BYTE data[], size_t len); |
| void md5_final(MD5_CTX *ctx, BYTE hash[]); |
| #endif // MD5_H |
| /programs/develop/ktcc/trunk/libc/include/cryptal/rot-13.h |
|---|
| 0,0 → 1,20 |
| /********************************************************************* |
| * Filename: rot-13.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 ROT-13 implementation. |
| *********************************************************************/ |
| #ifndef ROT13_H |
| #define ROT13_H |
| /*************************** HEADER FILES ***************************/ |
| #include <stddef.h> |
| /*********************** FUNCTION DECLARATIONS **********************/ |
| // Performs IN PLACE rotation of the input. Assumes input is NULL terminated. |
| // Preserves each charcter's case. Ignores non alphabetic characters. |
| void rot13(char str[]); |
| #endif // ROT13_H |
| /programs/develop/ktcc/trunk/libc/include/cryptal/sha1.h |
|---|
| 0,0 → 1,35 |
| /********************************************************************* |
| * Filename: sha1.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 SHA1 implementation. |
| *********************************************************************/ |
| #ifndef SHA1_H |
| #define SHA1_H |
| /*************************** HEADER FILES ***************************/ |
| #include <stddef.h> |
| /****************************** MACROS ******************************/ |
| #define SHA1_BLOCK_SIZE 20 // SHA1 outputs a 20 byte digest |
| /**************************** DATA TYPES ****************************/ |
| typedef unsigned char BYTE; // 8-bit byte |
| typedef unsigned int WORD; // 32-bit word, change to "long" for 16-bit machines |
| typedef struct { |
| BYTE data[64]; |
| WORD datalen; |
| unsigned long long bitlen; |
| WORD state[5]; |
| WORD k[4]; |
| } SHA1_CTX; |
| /*********************** FUNCTION DECLARATIONS **********************/ |
| void sha1_init(SHA1_CTX *ctx); |
| void sha1_update(SHA1_CTX *ctx, const BYTE data[], size_t len); |
| void sha1_final(SHA1_CTX *ctx, BYTE hash[]); |
| #endif // SHA1_H |
| /programs/develop/ktcc/trunk/libc/include/cryptal/sha256.h |
|---|
| 0,0 → 1,34 |
| /********************************************************************* |
| * Filename: sha256.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 SHA1 implementation. |
| *********************************************************************/ |
| #ifndef SHA256_H |
| #define SHA256_H |
| /*************************** HEADER FILES ***************************/ |
| #include <stddef.h> |
| /****************************** MACROS ******************************/ |
| #define SHA256_BLOCK_SIZE 32 // SHA256 outputs a 32 byte digest |
| /**************************** DATA TYPES ****************************/ |
| typedef unsigned char BYTE; // 8-bit byte |
| typedef unsigned int WORD; // 32-bit word, change to "long" for 16-bit machines |
| typedef struct { |
| BYTE data[64]; |
| WORD datalen; |
| unsigned long long bitlen; |
| WORD state[8]; |
| } SHA256_CTX; |
| /*********************** FUNCTION DECLARATIONS **********************/ |
| void sha256_init(SHA256_CTX *ctx); |
| void sha256_update(SHA256_CTX *ctx, const BYTE data[], size_t len); |
| void sha256_final(SHA256_CTX *ctx, BYTE hash[]); |
| #endif // SHA256_H |
| /programs/develop/ktcc/trunk/libc/include/memory.h |
|---|
| 0,0 → 1,8 |
| #ifndef _MEMORY_H |
| #define _MEMORY_H |
| #ifndef _STRING_H |
| #include <string.h> |
| #endif |
| #endif |