Simple Encryption using C Programming Language

Welcome! As I have mentioned in the previous blog, we are here. If you haven't read the previous blog click here.

Have you ever wanted to play around with cryptography but felt overwhelmed by complex algorithms? Fear not! In this blog post, we'll learn an exciting yet simple encryption using a straightforward approach in C programming. Get ready to explore!

The Challenge:

Imagine you have two existing files, "Uppercase.txt" and "Lowercase.txt", each containing meaningful messages written in their respective cases.

if you dont know john doe you are not a real programmer
-Lowercase.txt

HELLO THERE MY NAME IS POND JAMES POND
-Uppercase.txt

Your challenge? To combine these messages in a unique way, creating a ciphered text that conceals the original meanings. It's a puzzle waiting to be solved, a challenge waiting to be conquered.

The Approach:

Our approach to this challenge is refreshingly simple yet effective. We'll use basic C programming techniques to alternate between the uppercase and lowercase messages, extracting random chunks from each and combining them to create our ciphered text. To add an extra layer of intrigue, we'll replace spaces in the uppercase message with underscores and spaces in the lowercase message with hyphens. This alternating and ciphering process will transform our ordinary messages into an enigmatic code ready for decryption.

The Solution:

#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>

// The required files are "Uppercase.txt" and "Lowercase.txt"
int main() {
	// random seed for the random function
	srand(time(NULL)); 
	int random_limit = 3;
	int rand_len;
	
	// input files with meaningful messages
	char *fileupper = "Uppercase.txt";
	char *filelower = "Lowercase.txt";
	
	// output file with cipher text
	char *filename = "test_encrypt.txt";
	
	// over-ridding the output file to remove if it already exist
	FILE *fo = fopen(filename, "w");
	fclose(fo);
	
    // open the input files for reading
    FILE *fu = fopen(fileupper, "r");
    FILE *fl = fopen(filelower, "r");
    
    // open the output file for append
    FILE *fr = fopen(filename, "a");
    
    // Store the content of the file
	char textUpper[1000];
	char textLower[1000];
	
	
	char subtextU[random_limit];
	char subtextL[random_limit];
	
	// Read the content and store it inside myString
	fgets(textUpper, 100, fu);
	fgets(textLower, 100, fl);
	
	// two indexing variables for two texts
	int idxU = 0, idxL = 0;

	int count = 0;
	// alternatingly getting string chunks from both files and run until the index finishes the text
    while(idxU < strlen(textUpper) || idxL < strlen(textLower)) {
    	int rand_len = rand() % random_limit + 1; // random chunk length
    	
    	// alternating file contents
		if (count % 2 == 0 && idxU < strlen(textUpper))	{
			// getting a chunk
    		strncpy(subtextU,textUpper+(idxU),rand_len);
    		subtextU[rand_len] = '\0';
    		
    		// replacing the space in Uppercase file with 'underscore'
    		for(int i = 0; i < rand_len; i++)
		        if(subtextU[i] == ' ')
		            subtextU[i] = '_';

			// writing it to file
			fprintf(fr, subtextU);

    		idxU = idxU + rand_len;
    		
    	} else if(idxL < strlen(textLower)) {
    		// getting a chunk
    		strncpy(subtextL,textLower+(idxL),rand_len);
    		subtextL[rand_len] = '\0';
    		
    		// replacing the space in Uppercase file with 'hyphen'
    		for(int i = 0; i < rand_len; i++)
		        if(subtextL[i] == ' ')
		            subtextL[i] = '-';
  
  			// writing it to file
			fprintf(fr, subtextL);     

    		idxL = idxL + rand_len;
		}
		count++;
	}
      
    // close the files
    fclose(fr);
    fclose(fu);
    fclose(fl);
    
    return 0;
}

1. File Setup: We begin by declaring the file names for our input and output files.

2. Randomization: We seed the random number generator and set a limit for the length of random chunks to extract from each message.

3. File Handling: We open the input files for reading and the output file for appending, ensuring that any existing content in the output file is cleared.

4. Text Retrieval: We read the content of both input files and store them in separate arrays.

5. Chunking and Ciphering: Using a while loop, we alternate between the two input texts, extracting random chunks. Spaces in the uppercase text are replaced with underscores, while spaces in the lowercase text are replaced with hyphens. The chunks are then written to the output file alternatively inside the loop. In the file, everything combines to form a cipher text.

6. File Closure: Finally, we close all the files, completing the encryption process.

The Revelation:

After running our encryption program, the once ordinary messages transform into mysterious ciphered texts. The hidden meanings lie concealed within the code, waiting to be deciphered by the existing code we made in previous blog.

Thank You, and Happy Problem Solving!             o(*^▽^*)┛