hola a todos, creo que este es mi primer post(o uno de los primeros...) me encanto la pag... asi que creo que participare mas activamente en ella... bueno, necesito su ayuda... es para una tarea, la tengo casi lista solo me falta un detalle muy pequeño que no me resulta de ninguna forma de las que he tratado... bueno, esta es la tarea...
TAREA 1 CRIPTOSISTEMAS
INTRODUCCIÓN
La criptología está formada por dos técnicas complementarias: criptoanálisis y
criptografía. La criptografía es la técnica de convertir un texto inteligible, texto
en claro (plaintext), en otro, llamado criptograma (ciphertext), cuyo contenido
de información es igual al anterior pero sólo lo pueden entender las personas
autorizadas. El criptoanálisis es la técnica de descifrar un criptograma sin tener
la autorización.
1. Método Julio Cesar
Es el más antiguo conocido. La época de Julio Cesar es la primera que se tiene
noticia de la popularización de la escritura de un idioma, el latín, ya que éste
tuvo un a gran difusión entre diferentes ejércitos y clases sociales. Así apareció
la necesidad de ocultar información escrita y, por lo tanto, de la criptología. El
sistema reemplaza cada letra por la situada tres posiciones delante en el
alfabeto. Por ejemplo:
B -> E
Y -> A
LLEGUE VI VENCI -> OOHJXH YL YHQFL
Es fácil de romper:
6 Prueba y ensayo con 26 intentos.
6 Métodos estadísticos.
2. Sistemas monoalfabéticos
Sustituyen cada letra por otra que ocupa la misma posición en un alfabeto
desordenado, así se consiguen tantas claves como posibilidades de alfabetos hay:
Nº de claves 26! = 4.1026
Es mucho mejor que el de Julio Cesar y tiene más claves que el sistema más
utilizado actualmente DES (256 = 7,2.1016 claves). No se puede utilizar prueba y
ensayo para romperlo.
El problema está en cómo recordar la clave, es decir, el alfabeto desordenado.
Para ello se utiliza una palabra de uso común que permite crear, con un
algoritmo conocido, el alfabeto desordenado. Entonces, en la práctica, las claves
posibles no son los alfabetos sino que las palabras fáciles de recordar, muchas
menos que 26!.
El sistema es el siguiente:
1. Se busca una palabra (clave) fácil de recordar y se le quitan las letras
duplicadas.
SEGURIDAD -> SEGURIDA
2. Se añaden al final de la palabra las restantes letras del alfabeto.
SEGURIDABCFH..................XYZ
3. Se ordenan en una matriz cuya primera fila es la palabra clave
S E G U R I D A
B C F H J K L M
N O P Q T V W X
Y Z
4. El nuevo alfabeto se lee por columnas
YNBSZOCEPFGQHUTJRVKIWLDXMA
Así la clave es más fácil de transmitir y recordar pero el sistema de prueba y
ensayo se reduce a todas las palabras conocidas. El sistema de criptoanálisis
mejor para romper el algoritmo es el estadístico.
DESARROLLO
Realice dos programas en lenguaje C.
o El primero debe implementar el algoritmo descrito por el apartado dos
(sistemas Monoalfabéticos) para codificar un mensaje. El sistema debe
solicitar al usuario previamente la palabra clave y luego mostrar el
mensaje codificado (prob1.c).
o Un segundo programa que decodifique un mensaje dado, solicitando
previamente la clave al usuario (prob2.c).
Fecha de Entrega
13 de septiembre de 2006, antes de las 18:00 hrs en la secretaría de la escuela
Sugerencias y observaciones: Trabajar con arreglos, el espacio en blanco no se
codifica y considere un alfabeto con 26 letras (no incluya la letra ñ).
tengo hasta el momento esto:
#include<stdio.h>
#include<stdlib.h>
char palabra_clave[35];
char alfabeto[35][26];
char nuevo_alfabeto[26];
char alfabeto_normal[26];
char mensaje[5000];
char mensaje_codificado[5000];
int max_columnas, columna, fila, num_letras, limite_fila, limite_columna, k;
int max_letras;
int reg_a, reg_b, reg_c, reg_d, reg_e, reg_f, reg_g, reg_h, reg_i, reg_j, reg_k;
int reg_l, reg_m, reg_n, reg_o, reg_p, reg_q, reg_r, reg_s, reg_t, reg_u, reg_v;
int reg_w, reg_x, reg_y, reg_z;
void entrada_clave();
void inicializar();
int registro(char car);
void salida();
void otra_fila();
void poner(char car);
void otras_letras();
void inicializar_alfabeto();
void entrada_mensaje();
void ordenar_letras();
int ver_vacio(int i, int j);
void codificar_mensaje();
int main(){
inicializar();
nuevo_alfabeto[26]=32;
entrada_clave();
entrada_mensaje();
otras_letras();
ordenar_letras();
codificar_mensaje();
salida();
}
/****************************************************************************/
void codificar_mensaje(){
int i,j,m=0, continuar=0;
char car;
int let=0;
while(let<=max_letras){
car=mensaje[let];
while(continuar==0){
if(car==alfabeto_normal
){
mensaje_codificado[m]=nuevo_alfabeto;
m=m+1;
continuar=1;
}
i=i+1;
}
let=let+1;
}
}
/**************************************************************************/
void otra_fila(){
if(columna==max_columnas){
columna=0;
fila=fila+1;
}
}
/*****************************************************************************/
void entrada_clave(){
int col_clave=0;
int sal=0;
int col=0, escribir;
char car;
printf("Ingrese palabra clave \n");
while(sal==0){
car= getchar();
if(car==10)
sal=1;
else{
sal=0;
palabra_clave[col_clave]=car;
col_clave=col_clave+1;
escribir=registro(car);
if(escribir==0){
alfabeto[0][col]=car;
col=col+1;
}
}
}
max_columnas=col;
}
/******************************************************************************/
void poner(char car){
alfabeto[fila][columna]=car;
columna=columna+1;
otra_fila();
}
/****************************************************************************/
void entrada_mensaje(){
int i=0,letra=0;
char car;
printf("Ingrese mensaje\n");
while(i==0){
car= getchar();
if(car==10)
i=1;
else{
i=0;
mensaje[letra]=car;
num_letras=num_letras+1;
letra=letra+1;
}
}
max_letras=(num_letras+1);
}
/*****************************************************************************/
void ordenar_letras(){
/*matriz con las letras=alfabeto*/
int i,j, temp;
for(j=0;j<=(limite_columna+5);j++){
for(i=limite_fila;i>=0;i--){
temp=ver_vacio(i,j);
if(temp==0){
nuevo_alfabeto[k]=alfabeto[j];
k=k+1;
}
}
}
}
/***************************************************************************/
int ver_vacio(int i, int j){
int temp;
if(alfabeto[j]!=32){
temp=0;
}
else
temp=1;
return temp;
}
/***************************************************************************/
void otras_letras(){
int i, temp;
for(i=1;i<=26;i++){
switch (i){
case 1: temp=registro(97);
if(temp==0)
poner(97);
break;
case 2: temp=registro(98);
if(temp==0)
poner(98);
break;
case 3: temp=registro(99);
if(temp==0)
poner(99);
break;
case 4: temp=registro(100);
if(temp==0)
poner(100);
break;
case 5: temp=registro(101);
if(temp==0)
poner(101);
break;
case 6: temp=registro(102);
if(temp==0)
poner(102);
break;
case 7: temp=registro(103);
if(temp==0)
poner(103);
break;
case 8: temp=registro(104);
if(temp==0)
poner(104);
break;
case 9: temp=registro(105);
if(temp==0)
poner(105);
break;
case 10: temp=registro(106);
if(temp==0)
poner(106);
break;
case 11: temp=registro(107);
if(temp==0)
poner(107);
break;
case 12: temp=registro(108);
if(temp==0)
poner(108);
break;
case 13: temp=registro(109);
if(temp==0)
poner(109);
break;
case 14: temp=registro(110);
if(temp==0)
poner(110);
break;
case 15: temp=registro(111);
if(temp==0)
poner(111);
break;
case 16: temp=registro(112);
if(temp==0)
poner(112);
break;
case 17: temp=registro(113);
if(temp==0)
poner(113);
break;
case 18: temp=registro(114);
if(temp==0)
poner(114);
break;
case 19: temp=registro(115);
if(temp==0)
poner(115);
break;
case 20: temp=registro(116);
if(temp==0)
poner(116);
break;
case 21: temp=registro(117);
if(temp==0)
poner(117);
break;
case 22: temp=registro(118);
if(temp==0)
poner(118);
break;
case 23: temp=registro(119);
if(temp==0)
poner(119);
break;
case 24: temp=registro(120);
if(temp==0)
poner(120);
break;
case 25: temp=registro(121);
if(temp==0)
poner(121);
break;
case 26: temp=registro(122);
if(temp==0)
poner(122);
limite_fila=fila;
limite_columna=columna;
break;
default: i=26;
break;
}
}
}
/*****************************************************************************/
void inicializar(){
int cont, i, j;
for(cont=0;cont<=35;cont++){
palabra_clave[cont]=32;
nuevo_alfabeto[cont]=32;
}
reg_a=0;
reg_b=0;
reg_c=0;
reg_d=0;
reg_e=0;
reg_f=0;
reg_g=0;
reg_h=0;
reg_i=0;
reg_j=0;
reg_k=0;
reg_l=0;
reg_m=0;
reg_n=0;
reg_o=0;
reg_p=0;
reg_q=0;
reg_r=0;
reg_s=0;
reg_t=0;
reg_u=0;
reg_v=0;
reg_w=0;
reg_x=0;
reg_y=0;
reg_z=0;
fila=1;
columna=0;
for(i=0;i<=35;i++){
for(j=0;j<=26;j++){
alfabeto[j]=32;
}
}
inicializar_alfabeto();
num_letras=0;
limite_fila=0;
limite_columna=0;
k=0;
}
/**************************************************************************/
int registro(char car){
int ret;
if(car==65||car==97){
if(reg_a==1)
ret=1;
else{
ret=0;
reg_a=1;
}
}
if(car==66||car==98){
if(reg_b==1)
ret=1;
else{
ret=0;
reg_b=1;
}
}
if(car==67||car==99){
if(reg_c==1)
ret=1;
else{
ret=0;
reg_c=1;
}
}
if(car==68||car==100){
if(reg_d==1)
ret=1;
else{
ret=0;
reg_d=1;
}
}
if(car==69||car==101){
if(reg_e==1)
ret=1;
else{
ret=0;
reg_e=1;
}
}
if(car==70||car==102){
if(reg_f==1)
ret=1;
else{
ret=0;
reg_f=1;
}
}
if(car==71||car==103){
if(reg_g==1)
ret=1;
else{
ret=0;
reg_g=1;
}
}
if(car==72||car==104){
if(reg_h==1)
ret=1;
else{
ret=0;
reg_h=1;
}
}
if(car==73||car==105){
if(reg_i==1)
ret=1;
else{
ret=0;
reg_i=1;
}
}
if(car==74||car==106){
if(reg_j==1)
ret=1;
else{
ret=0;
reg_j=1;
}
}
if(car==75||car==107){
if(reg_k==1)
ret=1;
else{
ret=0;
reg_k=1;
}
}
if(car==76||car==108){
if(reg_l==1)
ret=1;
else{
ret=0;
reg_l=1;
}
}
if(car==77||car==109){
if(reg_m==1)
ret=1;
else{
ret=0;
reg_m=1;
}
}
if(car==78||car==110){
if(reg_n==1)
ret=1;
else{
ret=0;
reg_n=1;
}
}
if(car==79||car==111){
if(reg_o==1)
ret=1;
else{
ret=0;
reg_o=1;
}
}
if(car==80||car==112){
if(reg_p==1)
ret=1;
else{
ret=0;
reg_p=1;
}
}
if(car==81||car==113){
if(reg_q==1)
ret=1;
else{
ret=0;
reg_q=1;
}
}
if(car==82||car==114){
if(reg_r==1)
ret=1;
else{
ret=0;
reg_r=1;
}
}
if(car==83||car==115){
if(reg_s==1)
ret=1;
else{
ret=0;
reg_s=1;
}
}
if(car==84||car==116){
if(reg_t==1)
ret=1;
else{
ret=0;
reg_t=1;
}
}
if(car==85||car==117){
if(reg_u==1)
ret=1;
else{
ret=0;
reg_u=1;
}
}
if(car==86||car==118){
if(reg_v==1)
ret=1;
else{
ret=0;
reg_v=1;
}
}
if(car==87||car==119){
if(reg_w==1)
ret=1;
else{
ret=0;
reg_w=1;
}
}
if(car==88||car==120){
if(reg_x==1)
ret=1;
else{
ret=0;
reg_x=1;
}
}
if(car==89||car==121){
if(reg_y==1)
ret=1;
else{
ret=0;
reg_y=1;
}
}
if(car==90||car==122){
if(reg_z==1)
ret=1;
else{
ret=0;
reg_z=1;
}
}
return ret;
}
/***************************************************************************/
void inicializar_alfabeto(){
int i;
for(i=1;i<=27;i++){
switch (i){
case 1: alfabeto_normal[(i-1)]=97;
break;
case 2: alfabeto_normal[(i-1)]=98;
break;
case 3: alfabeto_normal[(i-1)]=99;
break;
case 4: alfabeto_normal[(i-1)]=100;
break;
case 5: alfabeto_normal[(i-1)]=101;
break;
case 6: alfabeto_normal[(i-1)]=102;
break;
case 7: alfabeto_normal[(i-1)]=103;
break;
case 8: alfabeto_normal[(i-1)]=104;
break;
case 9: alfabeto_normal[(i-1)]=105;
break;
case 10: alfabeto_normal[(i-1)]=106;
break;
case 11: alfabeto_normal[(i-1)]=107;
break;
case 12: alfabeto_normal[(i-1)]=108;
break;
case 13: alfabeto_normal[(i-1)]=109;
break;
case 14: alfabeto_normal[(i-1)]=110;
break;
case 15: alfabeto_normal[(i-1)]=111;
break;
case 16: alfabeto_normal[(i-1)]=112;
break;
case 17: alfabeto_normal[(i-1)]=113;
break;
case 18: alfabeto_normal[(i-1)]=114;
break;
case 19: alfabeto_normal[(i-1)]=115;
break;
case 20: alfabeto_normal[(i-1)]=116;
break;
case 21: alfabeto_normal[(i-1)]=117;
break;
case 22: alfabeto_normal[(i-1)]=118;
break;
case 23: alfabeto_normal[(i-1)]=119;
break;
case 24: alfabeto_normal[(i-1)]=120;
break;
case 25: alfabeto_normal[(i-1)]=121;
break;
case 26: alfabeto_normal[(i-1)]=122;
break;
case 27: alfabeto_normal[(i-1)]=32;
break;
default: i=28;
break;
}
}
}
/****************************************************************************/
void salida(){
int i, j, k;
printf("sin repetir letras ");
for(i=0;i<1;i++){
for(j=0;j<=max_columnas;j++){
printf("%c",alfabeto[0][j]);
}
}
printf("\npalabra clave ");
for(k=0;k<=35;k++){
printf("%c",palabra_clave[k]);
}
printf("\n");
for(i=0;i<=(fila);i++){
for(j=0;j<max_columnas;j++){
printf("%c",alfabeto[j]);
}
printf("\n");
}
printf("\n");
printf("alfabeto desordenado \n");
for(i=0;i<=25;i++){
printf("%c",nuevo_alfabeto);
}
printf("\n\nel mensaje codificado\n");
for(i=0;i<=max_letras;i++){
printf("%c",mensaje_codificado);
}
system("pause");
}
y el error lo tengo aqui...
void codificar_mensaje(){
int i,j,m=0, continuar=0;
char car;
int let=0;
while(let<=max_letras){
car=mensaje[let];
while(continuar==0){
if(car==alfabeto_normal[i]){
mensaje_codificado[m]=nuevo_alfabeto[i];
m=m+1;
continuar=1;
}
i=i+1;
}
let=let+1;
}
}
lo que pretendo hacer, es que el pc busque si la letra del mensaje en la posicion let es igual al caracter de la posicion "alfabeto_normal
", y si es asi, que lo reemplaze por el caracter que esta en la misma posicion del alfabeto desordenado... he intentado 3 formas distintas y no logro ver donde esta mi error, si alguien me ayudara porfavor... muchas gracias a todos los que se dieron el trabajo de leer todo esto... se que es un poco largo...
ps:serviria para retos o no???? si asi lo estiman conveniente..borren este post o el codigo...
