Thread: Bitwrap

Good day,

I'm attempting to write a short encryption program. One stage of the encryption / decryption process will be bitshifting. However, this process ( using << and >> operators ) causes data corruption : the end bit is lost. I wish to make sure that, whether the bit added when the program is run, is a 0 or a 1, that my code will work. Therefore, I have put together the following program :



THEORY :

Encryption
Left bitshift by 1 bit. Endbit is lost. If endbit ( left bit representing 128 ) is 1, the value of character is bigger than 127. Therefore, if this is the case, bitshift 1 left, and then OR the value with the integer 1 ( 00000001 ) to wrap this bit on the end. This will correct the bitshift, whether the added bit on the right is a 1 or a 0.
If the value of the character is less than 128, then bitshift left, and check if this new value is odd. If it is, take away 1, else, do nothing. This will correct the value of the bitshifted char, whether the added bit was 1 or 0.

Decryption
Right bitshift by 1 bit. Endbit ( right bit representing 1 ) is lost. If the value of the character is odd, then the endbit = 1. In this case, bitshift right, and check if the new value is larger than 127. If so, the added bit was 1, so do nothing. If it is less than 128, add 128 to the ASCII value in order to turn the added bit to 1.
If the value is even, the new bit must be 0. Therefore, check, as above, if the new value, once bitshifted, is larger than 127. If this is the case, subtract 128. Else, do nothing. This will make sure the added bit is 0.



PRACTICE :

Code:

void bse()   // BitShift Encrypt
{
     int b = (int)a;   // a is char a; the character being encrypted.
     
     if(b > 127)
     {   
             a = (a << 1);
             a = (a | 1);
     }
     
     else if(b < 128)
     {
          a = (a << 1);
          if(a % 2 == 1) a = a - 1;
     }
}







void bsd()    // BitShift Decrypt
{
     int b = (int)a;
     
     if((b % 2) == 1)
     {
           a = (a >> 1);
           int c = (int)a;
           if(c < 127) a = a + 128;
     }
     
     else if((b % 2) == 0)
     {
          a = (a >> 1);
          int c = (int)a;
          if(c > 127) a = a - 128;
     }
}

For some reason that escapes me, this code only works for ASCII values larger than 127, and I cannot see the problem...

Korhedron

Might be wrong, but isnt it always a 0 thats added in bit shift?

Thank you for all the replies...

I still have a few questions.
Firstly, RedZone, I thought that 0 was always added, yet the code above is supposed to be able to work whether a 0 or a 1 was added... When bitshifting left, the test determines whether the lost bit was 1 or 0, and then makes sure the added bit corresponds. When bitshifting right, the same thing is done : the lost bit is determined, and then we make sure the added bit corresponds. Therefore, why does this only work for ASCII values above 128 ?

DougDBug, thanks for the comments. I'm aware that my code is hardly presentable :P

Salem, thanks for the alternative, which I'm still trying to work out

I'll post my progress as soon as possible.

Thanks,
Korhedron

The code seems to work, except now, for values above 128. I think this is because my tests have been using Notepad, which won't take Unicode characters ( and, for example, the character é which has an ASCII value of 130, bitwraps left to have an ASCII value of 5, which Notepad won't take ). However, I've tested this with MSWord Documents, or with JPG images, and still, the outputted file has changes and won't open properly. I'm not sure what's going wrong...

Currently, I'm doing this :

Code:

void bse()
{
     int b = (int)a;
     if(b > 127)
     {
         a = ((a << 1) | 0x01);  // If the lost bit was 1, make sure it's 1 on the right after bitshift
     }
     
     else
     {
         a = ((a << 1) & 0xFE);   // If lost bit was 0, make sure it's 0 after bitshift
     }
}


void bsd()
{
     if( ((int)a) % 2 == 1)
     {
         a = ((a >> 1) | 0x80);
     }
     
     else
     {
         a = ((a >> 1) & 0x7F);
     }
}

I'm therefore thinking the code works, but file formats won't take certain characters. I've tried files with no extension, same problem : chars with ASCII over 128 won't convert properly... Any ideas ?

Thanks,
Kor

I am currently using binary I/O, still to the same effect... é ( ASCII 130 ) becomes ASCII 5 which won't print or save to file.

Code:

ifstream fin;
ofstream fout;

fin.open("text.txt", ios::binary);
fout.open("out.txt", ios::binary);

while(fin.get(a))
{
     bse();
     fout << a;
}

That's all I'm doing... I've tried with files with no extension, to the same result.

Thanks for the help, I'll get a hex editor. Other than that though, I can't really use this in any kind of algorithm, or I'd have some kind of data loss if I compensated for unprintable characters... Thanks anyway

xErath, my char a is a global variable, thus is passed to the function when it calls it.

Thanks a lot,
Korhedron