Phicar's world

Hola muchachos, Como estan?(no espero que respondan ).

Bueno En relacion a mis manuales que tenia para publicar espero sepan
esperar, puesto que mi pc no esta conmigo y no le saque el disco , estoy
escribiendo en GNU nano y en un teclado gringo asi que me disculpo otra
vez por mi ortografia .
Bueno despues de mis disculpas les presento el siguiente texto, es sobre
transposicion columnar Codificacion y analisis(MUY BASICO, el markov todavia
no me funciona).

Bueno para empezar les digo que la transposicion columnar es un algoritmo
que puede llevarse a cabo con lapiz y papel. El algoritmo se compone de un
texto plano, un numero de columnas menor a la longitud del texto y el orden
de las columnas para ponerlas en el texto cifrado.Me explico, digamos tenemos
el texto plano "Phicar blog", queremos que tenga unas 3 columnas y que su
orden sea 0,2,1; Entonces tenemos que dividir el texto plano en esas tres
columnas y eso quedaria como (Phi/car/ bl/og) estamos separandolos con "/".
Teniendo las partecitas entonces vamos a coger cada parte de las partes ,
primero la columna 0 "Pc o", despues la columna 2 "irl" y luego la columna 1
"habg", con lo cual el cifrado quedaria "Pc oirlhabg".
Bueno para que los programadores lo vean mas claro les dejo codigo explicado:

import java.util.*;
import java.io.*;
public class ctCod{
public static void main(String args[]) throws IOException{//si hay errores los atrapa IO
try{
if(new File(args[0]).exists()){//si el archivo en el que esta el texto existe siga si no no haga nada
byte ar[] = new byte[(int) new File(args[0]).length()];//donde vamos a almacenar lo que haya en el archivo
FileInputStream lector = new FileInputStream(args[0]);//el stream el archivo
lector.read(ar);//leemos
int col = 0;
if((col=Integer.parseInt(args[1])) >0 && col<=ar.length){//vemos si la columna esta entre 1 y la longitud del texto
StringTokenizer pru = new StringTokenizer(args[2],",");//el formato de la ordenacion vas con  , de por medio
boolean si = true;
if(col != pru.countTokens()){
System.err.println("No ordenamiento");
return;
}
for(int n = 0;n<col;n++){//vemos si estamos bien de ordenamiento
if(si){
si = (args[2].indexOf(String.valueOf(n)) != -1);
}else{
System.err.println("El orden de columnas ta mal");
return;
}
}
System.out.println(cod(new String(ar,0,ar.length),col,args[2]));//llamamos la funcion magica cod
}else
return;
}else
return;
}catch(Exception phi){//recibimos si hay error
phi.printStackTrace();
System.err.println("Ingrese archivo a leer, numero de columnas y el orden de estas\nEjemplo:\n"+
"java ctCod ctin.in 4 0,3,2,1");//vean como es el formato ctin.in es el archivo que contiene el texto, columna, ordena
}
}
public static String cod(String a,int col,String ord){//la funcion recibe texto, columna y el orden en cadena
Vector<String> orden = new Vector<String>();//el vector que contendra las partes
StringTokenizer tok= new StringTokenizer(ord,",");//el token de los ordenamientos
double le = Math.ceil((double)a.length()/(double)col);//vemos cuantos conjuntos habran
String partecitas[] = new String[(int)(le)];
int k =0;
for(int n = 0;k<partecitas.length;k++,n+=col)
partecitas[k]=a.substring(n,((n+col)<a.length())?(n+col):a.length());//cogemos cada parte del texto
for(int n =0;n<col;n++){//recorremos las columnas
String temp = "";
for(int b = 0;b<partecitas.length;b++){//recorremos los conjuntos del texto
temp+=(partecitas[b].length()>n)?partecitas[b].charAt(n):"";//vamos agnadiendo
}
orden.add(n,temp);//lo agnadimos al vector
}
String e = "";
while(tok.hasMoreTokens())
e+=orden.get(Integer.parseInt(tok.nextToken()));//aca es donde unimos todo
return e.trim();//retornamos la cadena
}
}

Bueno y en la otra mano les traigo un criptoanalisis bastante basico, es en
base a un crib o una palabra que creemos se encuentra en el plaintext..

Cogemos esa palabra y la sometemos a la transposicion columnar hasta
encontrar alguna que contenga todas las partes en el texto cifrado.

ejemplo: tenemos el texto "Phicar es chevere" y lo sometemos a 3 0,2,1
nos queda "Pc erirshehaecve", entonces vamos a usar de crib "chevere" si
lo hacemos de la forma correcta en 2 nos quedaria "cve/he/er" y si ponen
cuidado si estan ahi esos cribs e las posiciones "cve"-->14, "he"-->9, "er"
-->4 entonces nos queda que las columnas si son 3. Pero como hacemos para
hallar el orden de las columnas en el texto cifrado??, pues bueno volvemos
a hacer la pruebita , cogemos cada uno y los trasposicionamos hasta que
salga el texto ..solo hay 6 posibilidades diferentes..cosa dificil donde
fueran muchas mas las columnas siempre se veran las posibilidades como
columna!(si fuera 8 seria 8!=40320) entonces toca poner atencion con esas
grandes..y se puede usar la logica como la hemos usado, o se puede usar el
metodo de markov, que es de lo que trata lo que sigue(Si me sale bien )


Bueno pa los que les queda mas claro el codigo aca se los dejo explicado

//Funca pa encontar la columna!!!
import java.io.*;
import java.util.*;
public class cTCrib{
public static void main(String args[]) throws IOException{
FileInputStream lect = new FileInputStream(args[0]);
byte hola[] = new byte[(int) new File(args[0]).length()];
lect.read(hola);//leo archivo
String txt = new String(hola,0,hola.length);//texto a analizar
String crib = args[1];//crib sin transposicionar
String variantes[] = getVar(crib);//get posible cribs
Vector<Integer> es = getCon(variantes,txt);//get width
if(es.size()==0){
System.out.println("Ese Crib no funco");
return;
}
System.out.println("Los posibles numero de columna");
for(int n = 0;n<es.size();n++)
System.out.print(es.get(n)+",");
System.out.println();
}
/*getVar, este metodo recibe el crib y retorna un arreglo
el cual obtendra todos los diferentes textos...hacemos 
uso del metodo gen que genera el texto cifrado bajo x columna*/
public static String [] getVar(String a){
String hola[] = new String[a.length()-1];
for(int k=0;k<hola.length;k++)
hola[k]=gen(a,k+2);
return hola;
}
/*Metodo getCon, este metodo recibe el arreglo obtenido de getVar y el texto cifrado a analizar
y devuelve las posibles columnas */
public static Vector<Integer> getCon(String a[],String b){
Vector<Integer> ha = new Vector<Integer>();//vector a devolver
for(int n =0;n<a.length;n++){//recorremos todos los cribs
StringTokenizer token = new StringTokenizer(a[n],"|");//el metodo gen pone para diferenciar los conjuntos "|"
int temp =0;
int tota = token.countTokens();//estos son todos los conjuntos
while(token.hasMoreTokens()){//recorremos todos los posibles cribs
if(find(token.nextToken(),b).length>=1)//llamamos metodo find pa ver si si se encuentra el crib en el texto
temp++;//el temporal suma 1
}
if(temp == tota)//si todos los cribs estan quiere decir que es un posible width
ha.add(n+2);//lo agnadimos
}
return ha;//retornamos el vector
}
/*gen, metodo con el cual ciframos el crib ingresado por el usuario*/
public static String gen(String a,int width){
String part[] = new String[(int)Math.ceil(((double)a.length())/((double)width))];
for(int n =0,k=0;k<part.length;k++,n+=width){
if((n+width)<a.length())
part[k]=a.substring(n,n+width);
else
part[k]=a.substring(n,a.length());
}
String res="";
for(int n = 0;n<width;n++){
res+="|";
for(int k = 0;k<part.length;k++)
if(part[k].length() >n)res+=part[k].charAt(n);
}
return res;
}
/*este metodo ve si el metodo si se encuentra y devuelve la posicion de donde se encuentra
se le ingresa la palabra a buscar y el texto
*/
public static int [] find(String a,String b){
Vector<Integer> veces= new Vector<Integer>();//vector que contendra posiciones
int tmp = 0;
while((tmp=b.indexOf(a,tmp))!=-1){//mientras lo encuentre agnada al vector la posicion
veces.add(tmp);
tmp++;
}
int ve[] = new int[veces.size()];
for(int n = 0;n<ve.length;n++)
ve[n]=veces.get(n);//pasamos el vector a un arreglo
return ve;
}
}

Vemos, ojala le haya gustado a alguien o le haya servido :]