Help with functions

The ciphertext is almost identical to the message:

Code:

#include <iostream>
#include <string>
using namespace std;

#define DEBUG


char* shift(char* k) {

  // return an (odd) permutation of `k'

  int sz = sizeof(k)/sizeof(char);

  for(int i = 0; i < sz; i++) {
    char t = k[i];
    k[i] = k[i+1];
    k[i+1] = t;
  }

  return k;

}

char* forward(char* m, char* k) {

  // forward cipher (encryption)

  int sz_m = sizeof(m)/sizeof(char);

  while(*m++ ^= *k) {
    k = shift(k); // algorithm (symmetric difference)
#ifdef DEBUG
    cout << k << '\n';
#endif
  }
  return m;
}

int main(int argc, char* argv[]) {

  char** args = argv;

  char* mess;
  char* key;

  switch(argc) {
  case 3:
    mess = args[1];
    key = args[2];
    break;
  default:
    cout <<"usage: encrypt message key\n";
    return 1;
  }

  cout << "Encrypted message is: \n"
       <<"\n\t" << forward(mess, key) << '\n';

  return 0;
}

The `shift' function is supposed to rotate through each character in the key, so that a (somewhat) different comparison is done for as many characters as the unencrypted message contains. But the output points to a problem:

Code:

oops% encrypt bell-labs message
Encrypted message is:

        ll-labs

Any ideas? Great help on past issues--thanks.

Code:

>  int sz = sizeof(k)/sizeof(char);

Perhaps you want to use the length of the key here:

Code:

  int sz = strlen(k);

Thanks, but I still have the same problem : (

To expand on swoopy's response, sizeof(array)/sizeof(*array) only works on proper arrays. It doesn't work on pointers to strings or anything like that. And since, when passed to functions, arrays "degrade" (sorry, Prelude) into pointers, you can't use that trick to determine the number of elements in an array inside of a function that was passed that array. That's why you have to pass the size into the function as a separate parameter.

I'm examining your code in greater detail now.

[edit] Your shift function can return void. It doesn't have to return the pointer, because you don't modify it in any way.

You don't need to use args, argv will do just fine.

What if the encrypted message contains NULLs? . . . .

Anyway, I experimented a bit, and this is what I came up with. It's not pretty, but hey.

Code:

#include <iostream>
#include <string>
#include <cctype>
using namespace std;

#define DEBUG


void shift(char* k) {

  // return an (odd) permutation of `k'

  int sz = strlen(k);

  for(int i = 0; i < sz-1; i++) {
    char t = k[i];
    k[i] = k[i+1];
    k[i+1] = t;
  }
}

char* forward(char* m, char* k) {

  // forward cipher (encryption)

  int sz_m = strlen(m);

  for(;;) {
    *m ^= *k;
    if(!*++m) break;
    cout << "[message: " << m << "]\n";

    shift(k); // algorithm (symmetric difference)
#ifdef DEBUG
    cout << k << '\n';
#endif
  }
  return m;
}

int main(int argc, char* argv[]) {

  char* mess;
  char* key;

  switch(argc) {
  case 3:
    mess = argv[1];
    key = argv[2];
    break;
  default:
    cout <<"usage: encrypt message key\n";
    return 1;
  }

  {
    cout << "Encrypted message is: \n"
         <<"\n\t";
    int len = strlen(mess);
    const char *message = forward(mess, key);
    for(int x = 0; x < len; x ++) {
        cout << (int)mess[x] << ' ' << (isprint(mess[x]) ? (char)mess[x] : '-') << endl;
    }
  }

  return 0;
}

Hopefully that helps. [/edit]

Code:

>  while(*m++ ^= *k) {

Either change this to:

Code:

size_t len = strlen(m);
for (int i=0; i<len; i++)
{
	*m++ ^= *k;

Or be sure you don't xor a letter with itself, which results in a null terminatro (\0), and consequently the loop terminates.

>oops% encrypt bell-labs message
xor e with e and you get 0.

Code:

#include <string>

Are you aware that you are not using anything from that header?

C-style array functionality (strlen, strcpy etc) are in <cstring>.

This might be a large part of your problem, as it seems that you are quite relaxed about array bounds.

Edit: Using std::string might also take care of the 0-character problem because std::string doesn't use '\0' for anything special.

Code:

char* forward(char* m, char* k) {

  // forward cipher (encryption)

  int sz_m = sizeof(m)/sizeof(char);

  while(*m++ ^= *k) {
    k = shift(k); // algorithm (symmetric difference)
#ifdef DEBUG
    cout << k << '\n';
#endif
  }
  return m;
}

Note that sz_m isn't used. Are you quite sure that the while loop condition respects the different lengths of the two buffers? What if key is shorter than message? Or the other way round?

The shift function appears simply to chops characters from the beginning of the key, making it even shorter.

Thanks all! It works, and the code is much cleaner.

Now I have to go backward( ) ; )

Great info, thanks for sharing

Toni Rudolf Vlaic