Function program not working...

Can someone explain why this doesn't work?

Code:

#include <iostream.h>
#include <string.h>

char* encrypt(char *passD, char *phraseD);
char* decrypt(char *passD, char *encryptedD);

void main()
{
	char *encrypted, pass[10], phrase[30], *passer, *phraser, choice;
	int x, d=0;
		cout << "\nPlease type a password:\n";
		cin.getline(pass, 9);
		
		cout << "\nPlease type a phrase to encrypt:\n";
		cin.getline(phrase, 29);
		passer = &pass[0];
		phraser = &phrase[0];
		encrypted = encrypt(passer,phraser);
		cout << "\n--------------------\nEncrypted phrase is:\n "<< encrypted;		
		cout << "\n\nHey, this works!\n" << decrypt(passer, encrypted) << "\n";

}

char* encrypt(char *passD, char *phraseD)
{
	char encrypted[60];
	int x, d = 0;
		for (x=0; x < strlen(phraseD); x++)
		{
			if(d > strlen(passD))
				d = 0;
			encrypted[x] = *(phraseD+ x) ^ *(passD +d);
			d++;
		}
		return &encrypted[0];
}


char* decrypt(char *passD, char *encryptedD)
{
	char phrase[60];
	int x, d = 0;
		for (x=0; x < strlen(encryptedD); x++)
		{	
			if(d > strlen(passD))
				d = 0;
			phrase[x] = *(encryptedD+ x) ^ *(passD +d);
			d++;
		}
	return &phrase[0];
}

Thanks!
sirSolarius

Which part are you questioning?

It just doesn't encrypt or decrypt anything. Try it.

sirSolarius

Your encription is or-ing one letter plus a value with one letter plus a value that is in binary:

1001 exclusive or'ed with 0011 becomes 1010
-----------------------
1001
0011
------
1010

That is were there is two 1's they become zero and one 1 and one 0 become 1.

I do belive you can not return from that value because you would not know where you originally started.

Originally posted by velius
1001 exclusive or'ed with 0011 becomes 1010
-----------------------
1001
0011
------
1010

Ok.

1010
0011
----------
1001

That gives you the original number.

sirSolarius

Yes that does but there is no guarantee that can work every time. Remember the 0 is created both by two 0's and two 1's.

Yes, it always works. For those who know boolean algebra:

a xor b = (a and !b) or (b and !a)

or, to use simpler notation:

a!b + b!a

(a xor b) xor b = (a!b + b!a)!b + b!(a!b + b!a)

= a!b!b + b!a!b + b(!a + b)(!b + a) [The second part uses deMorgan's law that to invert a large expression, one can invert every term and swap AND and OR]

= a!b + 0 + b(!a!b + ab)

= a!b + b!a!b + bab

= a!b + ab

= a(!b + b)

= a(1)

= a

So, for all a, b:

(a xor b) xor b == a

Alternately, one could approach this using the fact that xor is a commutative operator; that is, (a xor b) xor c == a xor (b xor c).

By this property:
(a xor b) xor b = a xor (b xor b)
= a xor (0)
= a

As long as you know b, the "key" that you xor with, you can always recover a (the original value) from a xor b (the encoded value).

Oh, the above boolean algebra holds equally true for any bit length a, b -- but note, the constant '1' in the boolean algebra represents a number with all positions as '1', so if a and b are 4 bits, '1' is '1111'.

You have tought me something I did not know about xor'ing. Thank you, Cat.