Romper cifrado transposición por grupos + xor

[aguml]

Hola amigos, hace tiempo vi el cifrado cesar y el vigenese y ahora he visto el método de transposición por grupos el cual imagino que seria muy sencillo de romper y por eso se me ocurrió xorear cada carácter con el valor de su posición en la clave y funciona pero no se que tan fuerte seria este método a la hora de romper el cifrado.
Pongo el código por si alguien quiere verlo:

Código C:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define TAM 100
#define TAM_CLAVE 5
 
enum {encript=1,decript};
//---------------------------------------------------------------------------
 
void solicitar_frase(char *cadena)
{
    //TITULO
    printf("\t ---------------------------------\n");
    printf("\t|             Cifrado             |\n");
    printf("\t|     TRANSPOSICION POR GRUPO     |\n");
    printf("\t ---------------------------------\n");
    printf("Ingresa un mensaje para cifrar: ");
    fgets(cadena,TAM-1,stdin);
}
//---------------------------------------------------------------------------
 
int solicitar_accion(void)
{
    int op;
    printf("1-Encriptar\n");
    printf("2-Desencriptar\n");
    printf("Seleccione una de las acciones a realizar: ");
    scanf("%i",&op);
    return op;
}
//---------------------------------------------------------------------------
 
//Esta funcion da el formato correcto y ademas retorna el largo de la cadena formateada
int dar_formato(const char *original, char *formateada, const int size_clave)
{
    int i=0,j=0,caracteres_restantes=0;
 
    while (original[i]!='\0' && original[i]!='\n')
    {
        if (original[i]==' ')
        {
            i++;
        }
        formateada[j]=original[i];
        i++;
        j++;
    }
    if(j%size_clave!=0)
        caracteres_restantes =size_clave-(j%size_clave);
 
    for (i=0;i<caracteres_restantes;i++)
    {
        formateada[j]='X';
        j++;
    }
    formateada[j]='\0';
    return j;
}
//---------------------------------------------------------------------------
 
void encriptar (const char *cadena, const int largo, const int clave[], const int size_clave)
{
    int i,j,k=0,l=0;
    char *aux;
    
    aux=malloc (size_clave * sizeof (char));
 
    for (i=0;i<largo;i++)
    {
        aux[k]=cadena[l*size_clave + clave[k]-1]^clave[k];
        if (k==size_clave-1){
            for (j=0; j<size_clave;j++)
            {
                cadena[l*size_clave + j]=aux[j];
            }
            l++;
            k=0;
        }else{
            k++;
        }
    }
    free (aux);
}
//---------------------------------------------------------------------------
 
void desencriptar (const char *cadena, const int largo, const int clave[], const int size_clave)
{
    int i,j,k=0,l=0;
    char *aux;
    
    aux=malloc (size_clave * sizeof (char));
 
    for (i=0;i<largo;i++)
    {
        aux[clave[k]-1]=cadena[i]^clave[k];
        if (k==size_clave-1){
            for (j=0; j<size_clave;j++)
            {
                cadena[l*size_clave + j]=aux[j];
            }
            l++;
            k=0;
        }else{
            k++;
        }
    }
    free (aux);
}
//---------------------------------------------------------------------------
 
int main(int argc, char* argv[])
{
    //Variables necesaria
    const int clave[TAM_CLAVE]={4,3,5,2,1}; //los arrais de enteros no necesitan un espacio extra como pasa con los arrais de caracteres
    char frase[TAM];
    char frasenueva[TAM];
    int largo,accion;
 
    switch(argc)
    {
        case 1:
            //Obtengo la cadena
            solicitar_frase(frase);
 
            //doy formato a la frase
            largo=dar_formato(frase,frasenueva,TAM_CLAVE);
 
            //Solicito la accion a realizar con dicha frase
            do{
                system("CLS");
                accion=solicitar_accion();
            }while(accion != encript && accion != decript);
            system("CLS");
            printf ("Frase formateada:\n%s\n\n",frasenueva);
 
            switch(accion)
            {
                case encript:
                    encriptar(frasenueva,largo,clave,TAM_CLAVE);
                    printf("Frase encriptada:\n%s\n\n",frasenueva);
                    break;
                case decript:
                    desencriptar(frasenueva,largo,clave,TAM_CLAVE);
                    printf("Frase desencriptada:\n%s\n\n",frasenueva);
                    break;
            }
            break;
        case 3:
            //doy formato a la frase
            largo=dar_formato(argv[2],frasenueva,TAM_CLAVE);
            printf ("\nFrase formateada:\n%s\n\n",frasenueva);
 
            if(strcmp(argv[1],"-d")==0)
            {
                //la desencripto
                desencriptar(frasenueva,largo,clave,TAM_CLAVE);
                printf("Frase desencriptada:\n%s\n\n",frasenueva);
            }else if(strcmp(argv[1],"-e")==0){
                //la encripto
                encriptar (frasenueva,largo,clave,TAM_CLAVE);
                printf("Frase encriptada:\n%s\n\n",frasenueva);
            }else{
                printf("La accion solicitada no existe\n");
            }
            break;
        default:
            printf("Numero de parametros erroneo\n");
    }
    system("PAUSE");
    return 0;
}
//---------------------------------------------------------------------------
 

[PercevalCiro]

Una consulta con que estas compilando el código?. Te pregunto porque si lo dejo en la declaración de los procedimientos (funciones void) como

const char *cadena

me dice que es una asignación ilegal, y me genero duda porque es bastante lógico, no se con que estas compilando. Muchas gracias.

[aguml]

En C++Builder pero eso es totalmente estándar ya que eso indica que se pasa un puntero a una cadena constante y es bueno pasarlo cómo constante para evitar que se pueda modificar dentro de la función ya que si lo hiciéramos de forma accidental daría una excepción.
En el móvil usando c4droid compila y funciona a la perfección.

[PercevalCiro]

Entiendo, en CygWin da error, y en el estandar gcc también me da error. Realizando esa modificación me permite compilar; en realidad personalmente creo que como cuestión lógica no tendría sentido pasar algo como referencia e indicarle que sea constante, la solución sencilla sería no enviarlo como referencia y si dentro de una variable, o depositarlo en el argumento de la función. Esto no quiere decir que yo diga que no debería compilar, digo que si lo pienso muy apresuradamente me parece una redundancia, o sea, me parece que correcto que de error. Pero gracias por la aclaración del compilador hace muchisiiiiimo que no uso el Builder.

Saludos!!