Brad Conte » My Code http://bradconte.com Why know the ordinary when you can understand the extraordinary? Fri, 20 Jan 2012 04:12:24 +0000 en hourly 1 http://wordpress.org/?v=3.3.1 Blowfish – C http://bradconte.com/blowfish_c.html http://bradconte.com/blowfish_c.html#comments Tue, 08 Aug 2006 07:28:42 +0000 Brad Conte http://test.b-con.us/code/blowfish-c Algorithm This is an implementation of the Blowfish block cipher.

There are two steps to the cipher. First, five sets of tables are initialized using the user’s key and the blowfish encryption algorithm itself (making the algorithm recursive). Second, the data is encrypted using the permutated tables initialized previously.

Code Documentation
  • void key_schedule(uchar user_key[], BLOWFISH_KEY *keystruct, int len)
    This generates an encryption key from a user-supplied key.

    • uchar user_key[]
      This is the user-supplied key.
    • BLOWFISH_KEY *keystruct
      This is the key structure that will be used to encrypt data later in the encryption functions.
    • int len
      This is the length, in bytes, of the key in the first parameter. It may be any value up to 448.


  • blowfish_encrypt(uchar in[], uchar out[], BLOWFISH_KEY *keystruct)
    blowfish_decrypt(uchar in[], uchar out[], BLOWFISH_KEY *keystruct)
    These functions encrypt and decrypt data, accordingly, using a Blowfish key structure.

    • uchar in[]
      This is the data to be encrypted, for the blowfish_encrypt() function, and the data to be decrypted for the blowfish_decrypt() function.
    • uchar out[]
      This is where to store the output encrypted data, for the blowfish_encrypt() function, and the output decrypted data for the blowfish_decrypt() function.
    • BLOWFISH_KEY *keystruct
      This is the key structure that is generated by the key_schedule() function (above). It is the same for both encrypted and decryption.
Code Usage
  1. Create the arrays to hold both input and output data for the encryption and/or decryption functions and a BLOWFISH_KEY structure.
  2. Call the key_schedule() function with the key, the BLOWFISH_KEY structure, and the length of the key in bytes.
  3. To encrypt data, call the blowfish_encrypt() function passing the array with the plaintext, the array to hold the output ciphertext, and the key structure.
  4. Do decrypt data, call the blowfish_decrypt() function passing the array with the ciphertext, the array to hold the output plaintext, and the key structure.
Code
• Source Code
• Sample Driver Program

Notes
In this implementation, all the initial P-Box and S-Box constants are stored in static memory location and copied to temporary memory locations for use in the key-initialization step. This is because the S-Box and P-Box values will be altered during the key initialization, so if the implementor wishes to encrypt data using multiple keys in the same session, then the key initialization function must be called more than once. Each time it is called it must start with the same constant values, but these values are altered during the key initialization. Since the P/S-Boxes are crafted uniquely for each encryption key, using a single universal array to store those values would allow multiple keys to be used sequentially, but it would prevent the developer from using multiple keys at the same time. Thus the blowfish key is represented as a structure that houses both the P-Box and S-Boxes. Using structures allows the developer to create and manage as many keys as desired by creating one structure per key.

The slight drawback to this method is that copying all the initial data introduces a minor performance hit when calling the key schedule, and using multiple memory locations boosts the amount of memory necessary (every Blowfish key requires just over 1KB of memory). However, on modern PCs, the memory performance hit is completely negligible. Assuming the developer only needs to use one Blowfish key, this code could be optimized to just use the permanent S/P-Boxes. These factors are only of practical concern for extremely computationally-weak machines (very low-end PCs, specialized hardware).

Cryptanalysis of the Blowfish algorithm itself to date has yielded but a few minor flaws, placing Blowfish as one of the best 64-bit block ciphers in existence. However, 64-bit block ciphers are known to leak information about the plaintext and should not be used if possible. So although no reasonable attacks exist against Blowfish itself, its 64-bit block size make it less than undesirable in the modern cryptographic world.]]> http://bradconte.com/blowfish_c.html/feed 0 Base 64 – C http://bradconte.com/base64_c.html http://bradconte.com/base64_c.html#comments Wed, 26 Jul 2006 07:11:42 +0000 Brad Conte http://test.b-con.us/code/base-64-c Algorithm This is an implementation of Base64 encoding.

Base64 is an encoding scheme that allows binary data to be represented as text. It accepts a bit string of any length, splits it up into chucks of 6 bits, and replaces each chunk with its corresponding value from the list of characters: ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/ When the input is not an even multiple of 6 bits, the character ‘=’ is appended to the output as padding as needed.

Since the input has 8 bits of significant data and the output has 6 significant bits of data (there are 26=64 characters in the array above), the input to output ratio is very close to 3:4.

Code Documentation
  • void base64_encode(unsigned char in[], unsigned char out[], int len)
    This encodes raw data to Base64.
    • unsigned char in[]
      This contains the data to be encoded.
    • unsigned char out[]
      This will contains the output. The array should be larger than the input by a scale of 4:3, with a two character buffer.
    • int len
      This is the length, in bytes, of the input.
    • int newline_flag
      This is a flag, which can be set to true or false, to indicate whether or not the function should insert a newline in the base64 output every 76 characters. The technical specification for Base64 calls for this value, but this was based on technical standards/difficulties of the past and isn’t always desirable. By setting it to a non-zero value, a newline character will be added every 76 output characters (to wrap it in a rough rectangle shape), if it is set to 0 then the output will be one long string.
  • base64_decode(unsigned char in[], unsigned char out[], int len)
    This function decodes Base64 code into its original form.
    • unsigned char in[]
      This contains the Base64 data to be decoded.
    • unsigned char out[]
      This is the output array, it should be at least 3/4 the length of the input data, with an extra character of buffer.
    • int len
      This is the length of the input Base64 data.
    • Note: There is no need to include a newline flag for the decoding function, as it automatically parses out newline characters.
Code Usage
  1. First create/allocate two arrays to contain your original and encoded data.
  2. Determine the length of the data you wish to encode. Pass the input data, the array to contain the output, and the length of the data as arguments to the base64_encode() function.
  3. When you wish to decode the data, use the base64_decode() function. It works the same way, except the data gets decoded.
Code
• Source Code
• Sample Driver Program

Notes
This is the traditional base64 encoding scheme. The “Internet Base64″, in order to be URL friendly, replaces the last two characters of the substitution string, “+” and “/”, with “*” and “-”, respectively.

• Thanks to Christoph Otto for fixing a NULL termination bug (7-26-06). • ]]> http://bradconte.com/base64_c.html/feed 0 AES – C http://bradconte.com/aes_c.html http://bradconte.com/aes_c.html#comments Tue, 25 Jul 2006 08:20:36 +0000 Brad Conte http://test.b-con.us/code/aes-c Algorithm This is an implementation of the AES block cipher in 128, 192, and 256 bit modes, where the bit size corresponds to the key length. The algorithm encrypts plaintext in block sizes of 128 bits.

Code Documentation
  • KeySchedule(unsigned char key[], unsigned int w[])
    This function takes the generated key (128, 192, or 256 bits in length) and generates a key schedule to use in encryption.
    • unsigned char key[]
      Must contain 16, 24, or 32 bytes of data to be used as the key.
    • unsigned int w[]
      Must be 60 32-bit integers in size. This will be the outputted key schedule.
    • int keysize
      Must be the size of the key in bits, limited to the values 128, 192, or 256.
  • aes_encrypt(unsigned char in, unsigned char out, unsigned int key[], int keysize)
    aes_decrypt(unsigned char in, unsigned char out, unsigned int key[], int keysize)
    These functions encrypt and decrypt data, respectively.
    • unsigned char in[]
      The plaintext to be encrypted. The array must be 16 bytes in size.
    • unsigned char out[]
      The output ciphertext. The array must be 16 bytes in size.
    • unsigned int key[]
      The “w” array key schedule from the KeySchedule() function.
    • int keysize
      Ensure it’s the same value as the “keysize” value in KeySchedule() function.
Code Usage
  1. Call the KeyExpantion() function with the encryption key you want to use, the key schedule array, and the number of bits in length of the key.
  2. To decrypt data, call the aes_encrypt() function with the input plaintext array, an array to hold the output ciphertext, and the size of the original key in bits (same as the value passed to the KeyExpantion() function).
  3. To decrypt data, call the aes_decrypt() function with the input ciphertext array, an array to hold the output plaintext, and the size of the original key in bits (same as the value passed to the KeyExpantion() function).
Code
• Source Code
• Sample Driver Program

Notes
This implementation is designed for little endian processors, but I think should work for big endian processors as well.

I’ve taken some steps towards optimizing it, (basic things like unrolling loops), but the implementation is fairly slow. I hope to be able to optimize it more in the future.

Also note that this is not a hardened implementation of AES. It has benchmarked to be fairly slow and has not been designed to be resistant to side-channel attacks. Optimizing it and attack-proofing it are on my to-do list.

There are a few extra functions included in this code, printstate() and print_rnd_key(), and print_arry(), that fall under the heading of “Debugging Functions”. These are not a part of the AES implementation and may be removed, they only exist to aid in debugging the code should the implementor seek to optimize it or tinker with it in any way. I used them excessively when originally implementing the code, and figured they might come in handy to someone else as well. They’re not complex, but useful.]]> http://bradconte.com/aes_c.html/feed 0 SHA-256 – C http://bradconte.com/sha256_c.html http://bradconte.com/sha256_c.html#comments Tue, 25 Jul 2006 07:27:34 +0000 Brad Conte http://test.b-con.us/code/sha256-c Algorithm This is an implementation of the SHA-256 hash algorithm.

Code Documentation
  • SHA256_CTX
    A MD5 structure that will hold all hash-related data and calculations as the hash is calculated.

  • SHA256_init(SHA256_CTX *ctx)
    Initializes the SHA256_CTX object.

  • SHA1_update(SHA256_CTX *ctx, unsigned char data[], int len)
    Once an object has been created and initialized, the data to be hashed must be added. Due to practical limitations, it may not be optimal (or possible) to add all the data to the SHA256 hash in one data chunk, so the function inputs, stores, and calculates data as it is received, allowing the data to be added in as many chunks as necessary.

    • unsigned char data[]
      This is the data to be added to the hash.
    • int len
      This is the length, in bytes, of the data in the “data” array.


  • SHA256_final(SHA256_CTX *ctx, unsigned char hash[])
    Finalize and output the hash.

    • unsigned char hash[]
      This is the array to store the output hash. It must be at least 16 bytes in size.
Code Usage
  1. Create an SHA256_CTX object.
  2. Initialize it with sha256_init().
  3. Read some/all of the data to hash into an array, calculate the size of the data, and add it to the hash with sha256_update().
  4. Repeat the previous step for all the data you want to hash.
  5. Finalize and output the hash with sha256_final().
Repeat steps (2) to (5) for as many hashes as you want to calculate.

Code
• Source Code
• Sample Driver Program

Notes
The 32-bit words (which in this case are unsigned integers) used in the code use little endian byte ordering. The SHA-256 specification uses the big endian byte order, so some byte-reversals are made when copying data into and out of integers in this code.

This algorithm can hash data of any length, although 264 bits (2,147,483,648 gigabytes) is the recommended limit.

This algorithm has not been implemented in an optimized manner. This algorithm has passed testing against numerous test vectors, including all official vectors.]]> http://bradconte.com/sha256_c.html/feed 0 (3)DES – C http://bradconte.com/3des_c.html http://bradconte.com/3des_c.html#comments Mon, 10 Jul 2006 07:25:35 +0000 Brad Conte http://test.b-con.us/code/3des-c Algorithm This is an implementation of the DES and 3 DES block ciphers. 3DES (is simply the DES algorithm iterated three times and sometimes refered to as Triple DES. This algorithm encrypts plaintext in block sizes of 8 bytes.

Code Documentation
For DES:
  • void key_schedule(unsigned char key[], unsigned char schedule[][6], unsigned int mode)
    This function generates a multi-dimensional key schedule from a user-supplied key, the key schedule will be used for encryption.

    • unsigned char key[]
      Must contain 8 bytes of data to be used as the key.
    • unsigned int schedule[][6]
      Must be 16 arrays of 6 bytes each. This will contain the final key output.
    • unsigned int mode
      This value should be set to appropriate the macro-defined ENCRYPT or DECRYPT value.


  • void des_crypt(unsigned char in[], unsigned char out[], unsigned char key[][6])
    This function both encrypts and decrypts text using the key schedule.

    • unsigned char in[]
      This contains the plaintext/ciphertext to be encrypted/decrypted. It must contain 8 bytes of data. Padding may be necessary if it is the last block of the plaintext.
    • unsigned char out[]
      This contains the encrypted/decrypted ciphertext/plaintext output. It must be 8 bytes in size.
    • unsigned int key[][6]
      The “schedule” array from the key_schedule() function.


For 3DES:
  • void three_des_key_schedule(unsigned char key[], unsigned char schedule[][16][6], unsigned int mode)

    • unsigned char key[]
      This array must contain 24 bytes of data to be used as the encryption key.
    • unsigned int schedule[][16][6]
      Must be 3 arrays each with 16 arrays of 6 bytes each.
    • unsigned int mode
      Set this equal to the macro-defined ENCRYPT or DECRYPT values.


  • three_des_crypt()
    function must be called, the same function both encrypts or decrypts the data.

    • unsigned char in[]
      Must contain 8 bytes of data to be encrypted/decrypted.
    • unsigned char out[]
      Must be 8 bytes in size to hold the encrypted/decrypted data.
    • unsigned int key[][16][6]
      The “schedule” array from three_key_schedule() function.




Code Usage
For DES:
  1. Generate an 8 byte key. Note that only the seven most significant bits of each byte will actually be used.
  2. Use the key_schedule() function to generate a key schedule from the eight byte key.
  3. Use the des_crypt() function to encrypt your plaintext in blocks of 8 bytes. (You will likely have to pad your last block of plaintext.) The output is the ciphertext.
  4. To decrypt the ciphertext, switch the “mode” argument for des_crypt() and pass said function the ciphertext as input.
For 3DES:
  1. Generate a 24 byte key. Note that only the seven most significant bits of each byte will actually be used.
  2. Use the three_des_key_schedule() function to expand the key into a key schedule.
  3. Use the three_des_crypt() function to encrypt your plaintext in blocks of 8 bytes. (You will likely have to pad your last block of plaintext.) The output is the ciphertext.
  4. To decrypt the ciphertext, switch the “mode” argument for three_des_crypt() and pass said function the ciphertext as input.
Code
• Source Code
• Sample Driver Program

Notes
This implementation adheres fully to the official DES specification and includes the Initial Permutation and Inverse Initial Permutation steps that are often neglected for convenience, as they serve no cryptographic purposes.

This is an amature implementation of DES. It has benchmarked to be fairly slow and has not been designed to be resistant to any sort of side-channel attacks. Hopefully I will optimize and attack-proof it in the future.]]> http://bradconte.com/3des_c.html/feed 0 SHA-1 – C http://bradconte.com/sha1_c.html http://bradconte.com/sha1_c.html#comments Wed, 28 Jun 2006 07:22:36 +0000 Brad Conte http://test.b-con.us/code/sha1-c Algorithm This is an implementation of the SHA-1 hash algorithm.

Code Documentation
  • SHA1_CTX
    A MD5 structure that will hold all hash-related data and calculations as the hash is calculated.

  • SHA1_init(SHA1_CTX *ctx)
    Initializes the SHA1_CTX object.

  • SHA1_update(SHA1_CTX *ctx, unsigned char data[], int len)
    Once an object has been created and initialized, the data to be hashed must be added. Due to practical limitations, it may not be optimal (or possible) to add all the data to the SHA1 hash in one data chunk, so the function inputs, stores, and calculates data as it is received, allowing the data to be added in as many chunks as necessary.

    • unsigned char data[]
      This is the data to be added to the hash.
    • int len
      This is the length, in bytes, of the data in the “data” array.


  • SHA1_final(SHA1_CTX *ctx, unsigned char hash[])
    Finalize and output the hash.

    • unsigned char hash[]
      This is the array to store the output hash. It must be at least 16 bytes in size.
Code Usage
  1. Create an SHA1_CTX object.
  2. Initialize it with sha1_init().
  3. Read some/all of the data to hash into an array, calculate the size of the data, and add it to the hash with sha1_update().
  4. Repeat the previous step for all the data you want to hash.
  5. Finalize and output the hash with sha1_final().
Repeat steps (2) to (5) for as many hashes as you want to calculate.

Code
• Source Code
• Sample Driver Program

Notes
The 32-bit words (which in this case are unsigned integers) used in the code use little endian byte ordering. The SHA-1 specification uses the big endian byte order, so some byte-reversals are made when copying data into and out of integers in this code.

This algorithm has not been optimized, although some general attempts have been made to that effect. This algorithm has been tested against numerous test vectors (including all official ones) and passed the tests.

This algorithm can hash data of any length, although 264 bits (2,147,483,648 gigabytes) is the recommended limit.

It is worth noting that SHA-1 is no longer considered a perfectly secure hash algorithm. It is recommended that a hash algorithm such as Whirlpool or RIPE-MD, or even SHA-1 with double the number of standard rounds, be used in when security is critical. ]]> http://bradconte.com/sha1_c.html/feed 0 MD5 – C http://bradconte.com/md5_c.html http://bradconte.com/md5_c.html#comments Wed, 21 Jun 2006 07:21:38 +0000 Brad Conte http://test.b-con.us/code/md5-c Algorithm This is an implementation of the MD5 hash algorithm.

Code Documentation
  • MD5_CTX
    A MD5 structure that will hold all hash-related data and calculations as the hash is calculated.

  • md5_init(MD5_CTX *ctx)
    Initializes the MD5_CTX object.

  • md5_update(MD5_CTX *ctx, unsigned char data[], int len)
    Once an object has been created and initialized, the data to be hashed must be added. Due to practical limitations, it may not be optimal (or possible) to add all the data to the MD5 hash in one data chunk, so the function inputs, stores, and calculates data as it is received, allowing the data to be added in as many chunks as necessary.

    • unsigned char data[]
      This is the data to be added to the hash.
    • int len
      This is the length, in bytes, of the data in the “data” array.


  • md5_final(MD5_CTX *ctx, unsigned char hash[])
    Finalize and output the hash.

    • unsigned char hash[]
      This is the array to store the output hash. It must be at least 16 bytes in size.
Code Usage
  1. Create an MD5_CTX object.
  2. Initialize it with md5_init().
  3. Read some/all of the data to hash into an array, calculate the size of the data, and add it to the hash with md5_update().
  4. Repeat the previous step for all the data you want to hash.
  5. Finalize and output the hash with md5_final().
Repeat steps (2) to (5) for as many hashes as you want to calculate.

Code
• Source Code
• Sample Driver Program

Notes
The 32-bit words (which in this case are unsigned integers) used in the code assume little endian byte ordering. The MD5 specification uses the big endian byte order, so some byte-reversals are made when copying data into and out of integers in this code.

This algorithm has not actually been optimized, although some general attempts have been made to that effect. This algorithm has been tested against numerous test vectors (including all official ones) and has proved to be accurate.

This algorithm can hash data of any length, although 264 bits (2,147,483,648 gigabytes) is the recommended limit.

Note, that MD5 is no longer considered a reasonably secure hash algorithm. It is recommended that a hash algorithm such as Whirlpool, RIPEMD, or SHA1 (with double the number of standard rounds) be used rather than MD5. ]]> http://bradconte.com/md5_c.html/feed 0