C Symmetric stream cipher
Does anyone have a good stream encryption implementation written in pure portable C? At this point, I don't really know much about the strength of the cipher because this is only for a proof of concept, but speed will be important. I was thinking about Xor'ing with a constant if I can't find a decent stream cipher.
source to share
EDIT (2018): Use NaCl or libsodium , or TweetNaCl if you're looking for a smaller code size. They provide strong encryption and should be much faster than RC4.
RC4 is a very simple algorithm to implement.
Check out Sterling Camden or Adam Back implementation .
source to share
See the ECRYPT eStream project . These are serious hardcore cryptographic algorithms evaluated by security experts. As far as I know, all candidate algorithms had to include implementation in pure C (not C ++).
edit: The great thing about this website is that it details various algorithms, including their known flaws, and includes performance tests .
source to share
For a clean POC application, you can quickly dump the ROT13 in place. http://en.wikipedia.org/wiki/ROT13
However, I very much hesitate to make a proposal, as all too often the simple POC code that had to be replaced later never ...
source to share
Here is an extremely simple implementation of stream encryption in C. It is not , in any way designed for security. It simply illustrates how to complete the required basic steps.
The real magic must be done in a function CycleKey
that generates new key values, since each piece of data is passed through the encryption stream.
This example encrypts one at a time char
. You have to expand the concept to larger blocks of encryption data to be anywhere close to security. Once again, I did it just to illustrate the basic steps.
Good luck with your project!
#include <stdio.h>
char staticKey;
void CycleKey(char data)
{
/* this is where the real magic should occur */
/* this code does *not* do a good job of it. */
staticKey += data;
if (staticKey & 0x80)
{
staticKey ^= 0xD8;
}
else
{
staticKey += 0x8B;
}
}
void ResetCipher(const char * key)
{
staticKey = 0;
while (*key)
{
CycleKey(*key);
key++;
}
}
void Encrypt(const char * plaintext, char * encrypted)
{
while (*plaintext)
{
*encrypted = *plaintext + staticKey;
CycleKey(*encrypted);
encrypted++;
plaintext++;
}
*encrypted = '\0';
}
void Decrypt(char * plaintext, const char * encrypted)
{
while (*encrypted)
{
*plaintext = *encrypted - staticKey;
CycleKey(*encrypted);
plaintext++;
encrypted++;
}
*plaintext = '\0';
}
int main(void)
{
char * key = "123";
char * message = "Hello, World!";
char encrypted[20];
char decrypted[20];
ResetCipher(key);
Encrypt(message, encrypted);
ResetCipher(key);
Decrypt(decrypted, encrypted);
printf("output: %s\n", decrypted);
return 0;
}
source to share
Have you looked at OpenSSL? It has a robust implementation of many cryptographic algorithms and primitives. You don't need to use it with anything network related. However, this is not well documented or easy to learn. If you care about security (for example, if you store user personal data such as credit cards), you should definitely use OpenSSL or another secure implementation instead of rolling around on your own.
source to share
You can refer to the below code to understand the purpose. The code uses a pseudo-random number generator to generate the key and is purely written in C.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* Function declarations */
int getSize(char *array);
int hashCode(const char *str, int size);
void convertIntToBinaryArray(int num, int *arr, int *index);
void encryptStreamCipher(int key[], int data[], int encypted_data[],int data_size);
void decryptStreamCipher(int key[], int enc_data[], int data_size);
void convertCharToBinary(char c,int *binary_arr,int *index);
void convertStringToBinary(char *str,int *binary_arr, int *size);
void convertBinaryToString(int *data,char *array_string,int *index);
char convertBinaryToChar(char *str);
void displayIntArray(int *array, int size);
void displayCharArray(char *array, int size);
#define MAX_SIZE 10000
int main(int argc, char **argv) {
char array_string[MAX_SIZE];
char ascii_key[MAX_SIZE];
int data[MAX_SIZE];
int key[MAX_SIZE];
int encypted_data[MAX_SIZE];
int seed;
int key_int;
int key_size = 0;
int index;
int data_size = 0;
/* 1. Enter the data to encrypt (Do not use space in between)*/
fprintf(stdout, "Enter data to encrypt: \n");
fscanf(stdin, "%s", array_string);
/* 2. Convert the string to binary data */
convertStringToBinary(array_string,data,&data_size);
printf("Data in binary: \n");
displayIntArray(data,data_size);
/* 3. Read the key string from user */
fprintf(stdout, "Enter key to encrypt data with: \n");
fscanf(stdin, "%s", ascii_key);
/* 4.Get hash code from the key */
key_size = getSize(ascii_key);
seed = hashCode(ascii_key, key_size);
/* 5. Set the key as seed to random number generator to create a key of random bits */
srand(seed);
key_int = rand();
/* 6. Convert key to binary int array */
convertIntToBinaryArray(key_int, key, &index);
printf("Key in binary: \n");
displayIntArray(key,index);
/* 7. Encrypt : (Binary data) XOR (Binary key) */
encryptStreamCipher(key, data, encypted_data, data_size);
/* 8. Display encrypted data */
printf("encrypted Data: \n");
displayIntArray(encypted_data,data_size);
/* 9.Now, Decrypt data and verify initial data */
decryptStreamCipher(key, encypted_data, data_size);
printf("Decrypted binary data: \n");
displayIntArray(encypted_data,data_size);
/* 10. Convert decrypted data in binary to string */
memset(array_string,0,sizeof(array_string));
convertBinaryToString(encypted_data,array_string,&data_size);
/* 11.Display the original message in string */
printf("Decrypted Data in String: \n");
displayCharArray(array_string,data_size);
return 0;
}
int getSize(char *array) {
int size = 0;
int i = 0;
while ((i != MAX_SIZE) && (array[i] != '\0')) {
i++;
size++;
}
return size;
}
int hashCode(const char *str, int size) {
int hash = 0;
for (int i = 0; i < size; i++) {
hash = 31 * hash + str[i];
}
return hash;
}
void convertIntToBinaryArray(int num, int *arr, int *index) {
if (num == 0 || *index >= MAX_SIZE)
return;
convertIntToBinaryArray(num / 2, arr, index);
if (num % 2 == 0)
arr[(*index)++] = 0;
else
arr[(*index)++] = 1;
}
void encryptStreamCipher(int key[], int data[], int encypted_data[],
int data_size) {
for (int i = 0; i < data_size; i++) {
encypted_data[i] = data[i] ^ key[i];
}
}
void decryptStreamCipher(int key[], int enc_data[], int data_size) {
for (int i = 0; i < data_size; i++) {
enc_data[i] = enc_data[i] ^ key[i];
}
}
void convertStringToBinary(char *str,int *binary_arr,int *index) {
*index=0;
for (int i = 0; i<strlen(str); i++) {
convertCharToBinary(str[i],binary_arr,index);
}
}
void convertCharToBinary(char c,int *binary_arr,int *index) {
for (int i = 7; i >= 0; --i) {
binary_arr[*index]=((c & (1 << i)) ? 1 : 0);
(*index)++;
}
}
void convertBinaryToString(int *data,char *array_string,int *index){
int data_size=*index;
char char_array[data_size];
*index=0;
for(int i=0;i<data_size;i++){
char_array[i]=(data[i] == 1?'1':'0');
}
for(int i=0;i<data_size;i=i+8){
char sub_str[8];
memcpy(sub_str,char_array+i,8);
array_string[(*index)++]=convertBinaryToChar(sub_str);
}
}
char convertBinaryToChar(char *str){
char c=strtol(str,0,2);
return c;
}
void displayIntArray(int *array, int size)
{
for (int i = 0; i < size; i++) {
printf("%d",array[i]);
}
printf("\n");
}
void displayCharArray(char *array, int size)
{
for (int i = 0; i < size; i++) {
printf("%c",array[i]);
}
printf("\n");
}
Output:
Enter data for encryption: prateekjoshi
Binary data:
01110000011100100110000101110100011001010110010101101011011010100110111101110011011 0100001101001
Enter the key to encrypt data using:
password
The key is in binary:
+101010100101110000101101000101
encrypted data:
11011010001011100100110001100000011001010110010101101011011010100110111101110011011 0100001101001
Decrypted binary data:
01110000011100100110000101110100011001010110010101101011011010100110111101110011011 0100001101001
Decrypted data in line:
prateekjoshi
source to share