cipher overflowing - c

Question

I am ciphering like the following but don't know how to prevent the capitals going into other symbols if they are shifted out of range, similarly the lowercase go out of range of the lowercase letters. How can I make them go round in a circle and stop overflow? Thanks
int size = strlen(plain_text);
int arrayelement = 0;
for(arrayelement = 0; arrayelement < size; arrayelement++)
{
if (islower(plain_text[arrayelement]))
{
ciphered_text[arrayelement] = (int)(plain_text[arrayelement] + shiftkey);
}
else if (isupper(plain_text[arrayelement]))
{
ciphered_text[arrayelement] = (int)(plain_text[arrayelement] + shiftkey);
}
}
ciphered_text[size] = '\0';
printf("%s", ciphered_text);

Answer 1

I guess you use a type like char so an easy solution to not overflow is to do
int tmp_ciphered = (my_char + shift) % 0xff;
char ciphered = (char)(tmp_ciphered);
thenyou turn and do not overflow, this is a ring

Answer 2

This duplicates (almost exactly) c++ simple Caesar cipher algorithm.
Note that I don't agree with the accepted answer on that post. Basically you have to map the characters back into the range using something like ((c-'a'+shift) % 26) + 'a'. However that assumes your characters are in 'a'..'z'. Might be safer to use c >= 'a' && c <= 'z' instead of islower as I'm not sure how locale will play into on non-English systems. Similar for isupper and the other range. Finally, you need an else clause to handle when the char is not in either range.

Answer 3

The only truly portable way to do this involves building a lookup table for the input domain, and manually building the chars based on non-linear-assumptions.
Even for the restricted domain of ['a'..'z','A'..'Z'], assuming 'A'..'Z' is contiguous is not defined by the language standard, and is provably not always the case. For any naysayers that think otherwise, I direct you to ordinal positions of characters in the chart at this link, paying close attention to the dead-zones in the middle of the assumed sequences. If you think "Nobody uses EBCDIC anymore", let me assure you both AS/400 and OS/390 are alive and well (and probably processing your US taxes right now, as the IRS is one of IBM's biggest customers).
In fact, the C standard is pretty explicit about this:
C99-5.2.1.3 In both the source and execution basic character sets, the value of each character after 0 in the above list of decimal digits shall be one greater than the value of the previous.
Nowhere is there even a mention of defined ordering or even implied ordering on any other part of the character sets. In fact, '0'..'9' has one other unique attribute: they are the only characters guaranteed to be unaffected by locale changes.
So rather than assume a linear continuation exists for characters while thumbing our noses at the suspicious silence of the standard, let us define our own, hard map. I'lll not inline the code here like I normally do; if you're still with me you're genuinely interested in knowing and will likely read and critique the code below. But I will describe in summary how it works:
Static-declare two alphabets, double in length (A..ZA..Z,a..za..z).
Declare two arrays (encrypt and decrypt) large enough to hold (1<<CHAR_BIT) entries.
Fully initialize both arrays with values corresponding to their indexes. Ex: a[0]=0,a[1]=1,...
Fill each location in the encrypt-array that is part of our alphabets from (1) with the proper value corresponding to the shift width Ex. a['a'] = 'g' for a ROT5.
Mirror (4) by working backward from the tail of the alphabet applying the opposite shift direction. Ex: `a['g'] = 'a';
You can now use the encryption array as a simple table to translate input text to cipher text:
enc-char = encrypt[ dec-char ];
dec-char = decrypt[ enc-char ];
If you think it seems like a ton of work just to get source-level platform independence, you're absolutely right. But you would be amazed at the #ifdef #endif hell that people try to pass off as "multi-platform". The core goal of platform-independent code is to not only define common source, but define behavior as well. No matter what the platform, the concepts above will work. (and not a #ifdef in sight).
Thanks for taking the time to read this fiasco. Such a seemingly simple problem...
Sample main.cpp
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>
// global tables for encoding. must call init_tables() before using
static char xlat_enc[1 << CHAR_BIT];
static char xlat_dec[1 << CHAR_BIT];
void init_tables(unsigned shift)
{
// our rotation alphabets
static char ucase[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ";
static char lcase[] = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz";
int i=0;
// ensure shift is below our maximum shift
shift %= 26;
// prime our table
for (;i<(1 << CHAR_BIT);i++)
xlat_enc[i] = xlat_dec[i] = i;
// apply shift to our xlat tables, both enc and dec.
for (i=0;i<(sizeof(ucase)+1)/2;i++)
{
xlat_enc[ lcase[i] ] = lcase[i+shift];
xlat_enc[ ucase[i] ] = ucase[i+shift];
xlat_dec[ lcase[sizeof(lcase) - i - 1] ] = lcase[sizeof(lcase) - i - 1 - shift];
xlat_dec[ ucase[sizeof(ucase) - i - 1] ] = ucase[sizeof(ucase) - i - 1 - shift];
}
}
// main entrypoint
int main(int argc, char *argv[])
{
// using a shift of 13 for our sample
const int shift = 13;
// initialize the tables
init_tables(shift);
// now drop the messsage to the console
char plain[] = "The quick brown fox jumps over the lazy dog.";
char *p = plain;
for (;*p; fputc(xlat_enc[*p++], stdout));
fputc('\n', stdout);
char cipher[] = "Gur dhvpx oebja sbk whzcf bire gur ynml qbt.";
p = cipher;
for (;*p; fputc(xlat_dec[*p++], stdout));
fputc('\n', stdout);
return EXIT_SUCCESS;
}
Output
Gur dhvpx oebja sbk whzcf bire gur ynml qbt.
The quick brown fox jumps over the lazy dog.

Answer 4

You can implement it literally:
"if they are shifted out of range":
if (ciphered_text[arrayelement] > 'z')
"make them go round in a circle and stop overflow":
ciphered_text[arrayelement] -= 26;
In your context:
if (plain_text[arrayelement] >= 'a' && plain_text[arrayelement] <= 'z')
{
ciphered_text[arrayelement] = (int)(plain_text[arrayelement] + shiftkey);
if (ciphered_text[arrayelement] > 'z')
ciphered_text[arrayelement] -= 26;
}
(assuming you work with English text in ACSII encoding, and shiftkey is in the range 1...25, like it should be)