Thread: somthing funky

In your first for loop you are incrementing i twice.
And you shouldn't hard-code the lengths.

Code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
void Encrypt( char *, int len, const char * );
 
int main()
{
    const char *Original = "TOMORROW NEVER DIES";
    char Text[256];
    const char *Pword = "hello";
 
    strcpy( Text, Original );
    int text_len = strlen( Text );
 
    printf( "Original:  %s\n", Original );
 
    Encrypt( Text, text_len, Pword );
    // This may not print properly due to possible embedded '\0's
    printf( "Encrypted: %s\n", Text );
 
    printf( "Password:  " );
    for ( int i = 0; i < text_len ; i++ )
        printf("%c", Original[i] ^ Text[i]);
    putchar('\n');
     
    // length is needed due to possible embedded '\0's
    // (so you can't just use strlen in Encrypt)
    Encrypt( Text, text_len, Pword );
    printf( "Decrypted: %s\n", Text );
 
    return 0;
}
 
void Encrypt( char *Encrypted, int len, const char *Pword )
{
    int pword_len = strlen( Pword );
    for ( int j = 0, i = 0; i < len; i++, j = (j + 1) % pword_len )
        Encrypted[i] ^= Pword[j];
}

Your code doesn't make a lot of sense to me.
You seem to be trying to do something like the following.
It assumes that the plaintext is only uppercase letters and spaces and that the password is only lowercase letters, and that we know the password's length.
So it can only find possible password letters, not the exact letters since multiple letters could lead to uppercase letters or spaces. A longer message should give a better result.

Code:

#include <stdio.h>
#include <string.h>
#include <ctype.h>
 
int main()
{
    char Text[] = "TOMORROW NEVER DIES";
//    char Text[] = "A MUCH LONGER MESSAGE FOR HOPEFULLY A BETTER RESULT";
    char Pword[] = "hel";
    char Encrypted[sizeof Text];
 
    // Don't hardcode string lengths.
    int len = strlen( Text );
    int plen = strlen( Pword );
 
    printf("%s\n", Text);
 
    for ( int j = 0, i = 0; Text[i]; i++, j = (j + 1) % plen )
        Encrypted[i] = Text[i] ^ Pword[j];
    Encrypted[len] = '\0';
 
    // Encrypted characters are not necessarily printable.
    for ( int i = 0; i < len; i++)
        printf(isprint(Encrypted[i]) ? "%c" : "{0x%02X}", Encrypted[i]);
    putchar('\n');
 
    // Don't use numbers for letters, e.g., say 'A' instead of 65.
    for ( int StartIndex = 0; StartIndex < plen; StartIndex++ )
    {
        printf( "%2d: ", StartIndex );
        for ( int i = 'a'; i <= 'z'; i++ )
        {
            int Letter = 1;
            for ( int j = StartIndex; j < len; j += plen ) {
                int x = Encrypted[j] ^ i;
                if ( ! ( ( x >= 'A' && x <= 'Z' ) || x == ' ' ) )
                {
                    Letter = 0;
                    break;
                }
            }
            if ( Letter )
                printf( "%c ", i );
        }
        putchar('\n');
    }
 
    return 0;
}

If you start to think in terms of functions AND pointers this could be proven easier:

Code:

#include <stddef.h>
#include <stdint.h>

// Both dest and src points to buffers with the same size.
void xorblk( void *dest, const void *src, size_t blksize,
             const void *key, size_t keysize )
{
  uint8_t *d;
  const uint8_t *s, *de, *k, *ke;

  d = dest;
  s = src;
  de = dest + blksize;
  k = key;
  ke = key + keysize;

  while ( d < de )
  {
    *d++ = *s++ ^ *k++;
    if ( k == ke ) k = key;
  }  
}

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

static void display( const char *, const void *, size_t );

int main( void )
{
  char dest[32];    // with enough space to hold "encoded" data.
  char src[] = "TOMORROW NEVER DIES";
  const char key[] = "hel";
  size_t size, ksize;

  size = strlen( src );   // or (sizeof src - 1)
  ksize = strlen( key );  // or (sizeof key - 1)

  xorblk( dest, src, size, key, ksize );
  display( "original :", src, size );
  display( "encoded :", dest, size );

  xorblk( src, dest, size, key, ksize );
  display( "decoded :", src, size );
}

void display( const char *prompt, const void *p, size_t size )
{
  const uint8_t *q, *qe;
  ptrdiff_t offset;

  fputs( prompt, stdout );

  q = p;
  qe = p + size;

  while ( q < qe )
  {
    offset = q - (const uint8_t *)p;
    if ( offset % 16 == 0 )
      printf( "\n%08tx:", offset );

    printf( " %02x", *q );
    q++;
  }
  putchar( '\n' );    
}

Code:

$ ./xorenc
original:
00000000: 54 4f 4d 4f 52 52 4f 57 20 4e 45 56 45 52 20 44
00000010: 49 45 53
encoded :
00000000: 3c 2a 21 27 37 3e 27 32 4c 26 20 3a 2d 37 4c 2c
00000010: 2c 29 3b
decoded :
00000000: 54 4f 4d 4f 52 52 4f 57 20 4e 45 56 45 52 20 44
00000010: 49 45 53