Thread: Vigenere encryption/decryption program.

> key = calloc (MAX_LEN_KEY , sizeof(char));
This needs to be as long as your plaintext, given what you're attempting to do in key_repeat()

key_repeat itself is massively overengineered (and just plain wrong).
Have a look at this.

Code:

#include <stdio.h>
#include <string.h>

void extend(char *plain, char *key) {
  size_t plen = strlen(plain);
  size_t klen = strlen(key);
  if ( plen <= klen ) {
    key[plen] = '\0';
  } else {
    char  *k2 = key, *k3 = key+klen;
    plain += klen;
    while ( *plain++ != '\0' )
      *k3++ = *k2++;
    *k3 = '\0';
  }
}

int main ( ) {
  char plain[100] = "this is a long piece of text";
  char key[100] = "key";
  extend(plain,key);
  printf("%s\n",plain);
  printf("%s\n",key);
  return 0;
}

thank you for your answer but what do you mean by "it is massively overengineered?" it is impossible to make some correction and use the function again? I should delete it and use your version?

I Think now it is ok. Your version is better because it is more simple. I have the problem that I am writing codes that they are complex sometimes ...

Code:

/* NEW vERSION.... */

/********************************************
 * Description: Simple Vigenere example program
 * Licence : Public 
 * ******************************************/
#include<stdio.h>
#include<ctype.h>
#include<string.h>
#include<stdlib.h>
#define MAX_ROWS 26
#define MAX_COLS 26
#define MAX_LEN_PLAINTEXT 30 + 1
#define S_CHAR 'A'  // Starting char of latin alphabet
#define E_CHAR 'Z'  // Ending char of latin alphabet
#define MOD 26
#if 1
#define INFO "*****************************************\n"\
			 "* Author: Kwstas Tsit                   *\n"\
			 "* Email: [email protected]            *\n"\
			 "* Date: 19/12/2014                      *\n"\
			 "* Type : Encryption/Decryption          *\n"\
			 "* Method: Vigenere Algorithm            *\n"\
			 "* More info: Google Vigenere Algorithm  *\n"\
			 "*****************************************\n"\

#define CRYPTO_LABEL " *******   ******  *   *   ***** *******   *******\n" \
                     "*          *    *  *   *   *   *    *      *     *\n" \
                     "*          ******  *****   *****    *      *     *\n" \
                     "*          **        *     *        *      *     *\n" \
                     "*******    * *       *     *        *      *******\n" \

#endif
                      
char *vigenere_crypto( char *plain, char *key);
char *vigenere_decrypto( char *encrypted , char *key);
void tab_recta( char tabula_recta[MAX_ROWS][MAX_COLS] );
void print_tab_recta( char tabula_recta[MAX_ROWS][MAX_COLS] );
int read_line( char *str , int n);
void key_repeat( char *key , char *plain);

char tabula_recta[MAX_ROWS][MAX_COLS];

/*************************************************
 *  main function , call the subroutines 
 *  of tab_recta table , encryption - decryption.
 * ***********************************************/
 
int main(void)
{
	char plain[MAX_LEN_PLAINTEXT]={'\0'};
	char key[MAX_LEN_PLAINTEXT]={'\0'};
	
	printf("%s" , CRYPTO_LABEL); 
	printf("\n %s" , INFO);
	
	tab_recta( tabula_recta );
	printf("\n");
	//print_tab_recta( tabula_recta );
	printf("Give the plaintext(up to 30 characters) : ");
	read_line( plain , MAX_LEN_PLAINTEXT ); //read the message.
	printf("Give the key: ");
	read_line( key , MAX_LEN_PLAINTEXT );  // the actual length of user's key. 
    
	key_repeat( plain , key);  // key repeat if it is necessary.
	puts(key);
	
	printf("\n Cipher: %s " , vigenere_crypto(plain, key) );
	printf("\n Plaintext: %s ", vigenere_decrypto( plain , key) );
	
	return 0;
}
/********************************************************
 *  tab_recta table filling function , uses an 2D array
 *  in order to make the tab_recta square table.
 * ******************************************************/
void tab_recta( char tabula_recta[MAX_ROWS][MAX_COLS] )
{
	
	int pos , row , col;
	
	for( row=0; row < MAX_ROWS; row++){
		pos = 0;
		for( col=0; col < MAX_COLS; col++){
			if( S_CHAR+row+col > E_CHAR && row > 0){
				tabula_recta[row][col] = S_CHAR + pos;
				pos++;
			}
		    else 
			tabula_recta[row][col] = S_CHAR+row+col;
		}
	}
	
	return;
}
/***********************************************
 *  Function that prints the contents of
 *  tabula_recta square if you want it.
 * *********************************************/
#if 0
void print_tab_recta( char tabula_recta[MAX_ROWS][MAX_COLS])
{
	int row , col;
	
	for( row=0; row<MAX_ROWS; row++) {
		printf("\n");
		for( col=0; col<MAX_COLS; col++){
				printf("%c" , tabula_recta[row][col]);
		}
	} 	

	return;
}
#endif 
/********************************************
 *  vigenere_crypto makes the encryption 
 *  The contents come from tabula_recta square
 *  it takes the plaintext as argument and the
 *  key in order to do the encryption procedure
 *  returns the encrypted string of your msg.
 * ******************************************/
char *vigenere_crypto(char *plaintext , char *key)
{
	int row_tab_rec , col_tab_rec , i=0;
	char *encrypted = plaintext; 
	
	while( encrypted[i] ){
		row_tab_rec = (key[i] - S_CHAR )%MOD;  // For the apropriate row.
		col_tab_rec = (plaintext[i] - S_CHAR )%MOD; // For the apropriate column.
		encrypted[i] = tabula_recta[row_tab_rec][col_tab_rec]; // The element of the tabula recta square.
		i++;
	}
		
	return encrypted;
}
/****************************************************
 *  vigenere_decrypto function makes the decryption
 *  in order to gve you the plaintext. It takes 
 *  the encrypted msg and the key. It produces the
 *  decrypted message.
 *  It returns the decrypted string which is the 
 *  previous plaintext.
 * *************************************************/
char *vigenere_decrypto(char *encrypted , char *key)
{
	int i=0;
	
	char *decrypted = encrypted;
	
	while( encrypted[i] ) {
		if( encrypted[i] >= key[i] ) 
			decrypted[i] = encrypted[i] - (key[i]- S_CHAR)%MOD; 
		
		else if ( encrypted[i] < key[i] )  
			decrypted[i] = E_CHAR + 1 - (key[i] - encrypted[i]) ;	
		i++;
	}
	
	return decrypted;
}
int read_line( char *str , int n)
{
	int ch , i=0;
	while( isspace( ch = getchar() ))
			;
	while( ch!= '\n' && ch != EOF) {
			if( i < n)
				str[i++] = ch;
				ch = getchar();
	}
	str[i] ='\0';
	
	return i;
}
void key_repeat(char *plain, char *key) {
  size_t plen = strlen(plain);
  size_t klen = strlen(key);
  
  if ( plen <= klen ) {
    key[plen] = '\0';
  } else {  
	char  *k2 = key, *k3 = key+klen;
    plain += klen;
    while ( *plain++ != '\0' )
      *k3++ = *k2++;
    *k3 = '\0';
  }

}

If there is any other suggestion about my code I would be grateful ... I want to program well and simple.

I think your read_line has the potential for a buffer overflow.

Here I am again ....

I have a basic problem .... I am trying to configure the program in order to make the encryption/decryption in more than one words ...

Code:

void key_repeat(char *plain, char *key) {
  size_t plen = strlen(plain);
  size_t klen = strlen(key);
  
  if ( plen <= klen ) {
    key[plen] = '\0';
  } else {  
	char  *k2 = key, *k3 = key+klen; /* k2 will continue from the first beginning of k3 (after the copy),
	 so will have already a copy of the key and so forth until the end of plain */
    plain += klen;
    while ( *plain!= '\0') {
		if( !isalpha(*plain) ) {
			*k3++ = *plain++;
			 k2 = key;
			 continue;
		}
		*k3++ = *k2++;  // copy the key to k3 location , repeat the key.
		plain++;
	} 
    *k3 = '\0';
   }
  puts(key);
}

That is the key function ... the changes in the program is here. The problems that I have is:

Code:

Give the plaintext(up to 30 characters) : HI MAN
Give the key: CLOUD
CLOUDC

 Cipher: JTGGDP 
 Plaintext: HISMAN

I have the problem with the plaintext "HI_MAN" and the CLOUD as the key. I was happy when I tried the "TRUTHWILLOUT_TRUTHWILLOUT" TEXT because the key is exactly what i want for example it was CLOUDCLOUDCL CLOUDCLOUDCL but then I saw that I have problems.I think the problem here is the plain +=klen; but if i change it I think that the code will be broken due to its logic. Any help? thank you in advance.

The whole code is here :

http://ideone.com/M4nzrh

P.S I just want to repeat the key when I have non alphabetic characters between the words.

So for "HI MAN", do you expect the key to be "CL OUD" or "CL CLO" ?

Now is a really good time to figure out how to use a debugger.

Put a breakpoint on this line if( !isalpha(*plain) )

Call the function with a small test case, like "A B" and "KEY"

At reaching the breakpoint, set up watch windows for the interesting variables, then
- explain to yourself what you expect the next line to do
- single-step the line of code and observe what happens.

Every time you're surprised by the result, STOP and have a really long think about what you wrote, and what you expect to achieve. Every surprise is a bug - whether that bug is in the code, or your understanding of the language or the problem is for you to figure out.

I expect the key to be "CL CLO"

The problem here is that plain points to 'N' so the key would be CLOUDC and then while( *plain != '\0') would be true , in addition I have no any problem with the input "HEYYY MAN" it works exactly as I want. The problem is where the word is less than key. In this case HEYYY and CLOUD has the same length so there is no problem.

my question: is there a way to solve the problem with your code or I should change all the function?

I have clear view what the problem is every time I don't need a debugger for this except you suggest debugger for other reason.... Thank you for your time

Salems code worked fine when you didn't have any spaces in your strings. With spaces it causes those spaces to be repeated as I showed you earlier.

To fix that you would need to insert spaces into the key string, shifting all letters after the insertion one space forward, then on reading the repeated part of the string you will have to skip over those spaces when copying to itself (if that makes sense..)

I think it would be simplier to copy the string to another buffer first, then read from that. Like so:

Code:

void key_repeat(char * plain, char * key) 
{
    size_t len = strlen(key);
    char * copy = malloc(len + 1); 
        
    /* Copy to internal buf or memory buf if possible */
    if (!copy)
        return;
    strcpy(copy, key);

    for (size_t i = 0; *plain; ++plain, ++key) 
        *key = !isalpha(*plain) ? *plain : copy[i++ % len];
    *key = '\0';

    free(copy);
}

Thank you very much for your help nonpuz

I knew the problem but I faced difficulties on how to write the code. I didn't bear in my mind the possibility-> copy[i%len].
I am good to read and understand others code but it is not the same when you are called to write your own. I hope in the future with more practice to be better on this

thank you again for all. Happy new year

P.S The whole program if you have any suggestion I would be grateful

Ideone.com - avjk3u - Online C Compiler & Debugging Tool