cifrario simmetrico

Stato
Discussione chiusa ad ulteriori risposte.

Oromis92

Utente Silver
22 Dicembre 2007
102
12
2
84
ecco un'altro contest, che penso vi impegnerà e non poco! XD

obiettivo: scrivere un cifrario simmetrico. (ovvero che non abbia chiavi di sorta)
  • scrive due codici separati: encoder e decoder
  • spiegare come funziona il cifrario
  • il cifrario DEVE operare su file e non su stringhe
  • non ci devono essere chiavi di sorta (es: rot13 oppure b64)
  • postare un esempio con la stringa "The quick brown fox jumps over the lazy dog"
  • cifrario di vostra invenzione!
  • fine contest: 29/03/09 ore 12:00

ps. non limitatevi a uno XOR :asd:



ecco il mio codice:

encoder
Codice:
#!/usr/bin/perl;
# by Oromis92

# octcipher encoder

if (@ARGV < 1) {die "usage: $0 [input file] [>> output file]\n"} else {

while (<>) {
$str .= $_;
}
chomp $str;
@arr = split //, $str;

foreach (@arr) {

$_ = (sprintf("%O",ord($_)))+111;

@arr2 = split //, $_;
for $i (0..scalar(@arr2)) {
$aaa .= '+' x $arr2[$i] . '-';
}

print $aaa;
$aaa = '';
}
print $/;
}

decoder
Codice:
#!/usr/bin/perl
# by Oromis92

# octcipher decoder

if (@ARGV < 1) {die "usage: $0 [input file] [>> output file]\n"} else {
while (<>) {
$a .= $_;
}
undef $/;
$_ = $a;
$_ =~ y/- / /ds;
@yoda = map{ length } split;
while (@yoda) {
$_ = chr(oct((join('',splice(@yoda,0,3)))-111));
print $_;
}
}

funzionamento:
leggo il file carattere per carattere.
di ogni carattere ricavo il codice ascii.
trasformo questo codice in ottale.
aggiungo 111.
adesso, a seconda del numero ottenuto metto '+' intervallati da un singolo '-'
per esempio se il numero è 112 sarà +-+-++
oppure 341 diventa +++-++++-+
termino con due '-'


esempio:
Codice:
The quick brown fox jumps over the lazy dog
++-+++-+++++--++-++++++-+--++-+++++-++++++--+-+++++-+--++-+++++++-++--++-++++
+++-++++++--++-++++++-++--++-+++++-++++--++-++++++-++++--+-+++++-+--++-+++++-
+++--++-+++++++-+++--++-++++++-++++++++--++-+++++++-++++++++--++-++++++-++++
+++--+-+++++-+--++-+++++-+++++++--++-++++++-++++++++--++-++++++++-+--+-+++++-
+--++-++++++-+++--++-+++++++-++++++--++-++++++-++++++--++-+++++++-+--++-+++++
++-++++--+-+++++-+--++-++++++-++++++++--++-+++++++-+++++++--++-+++++-++++++--
++-+++++++-+++--+-+++++-+--++-+++++++-+++++--++-++++++-+--++-+++++-++++++--+-
+++++-+--++-++++++-+++++--++-+++++-++--++-++++++++-+++--++-++++++++-++--+-+++
++-+--++-+++++-+++++--++-++++++-++++++++--++-+++++-++++++++--+-+++++-+--

ps. ho aggiunto degli 'a capo' casuali perchè altrimenti sballerebbe la grafica del forum

Gradirei che tutti quelli che non postano il proprio codice mettano il tutto nei tag ot...grazie! by R4z0r_Cr4$H
 
[ot]io partecipo...appena ho tempo butto giù qualcosa!Gradirei che tutti quelli che non postano il proprio codice mettano il tutto nei tag ot...grazie![/ot]
 
Fatto. In PHP:
PHP:
<?php
$key = (isset ($argv[2])) ? $argv[2] : 282;
$str = (isset ($argv[1])) ? $argv[1] : "/dev/null";
$mod = (isset ($argv[3])) ? "decode" : "encode";
if (!file_exists ($str)) die ("File non esistente");
$fp = fopen ($str, "r");
$str = fread ($fp, filesize ($str));
fclose ($fp);

if ($mod == "encode") {
	foreach (str_split ($str, 1) as $tmp) {
		$ascii = ord ($tmp) + $key;
		$ascii = str_split ($ascii, 1);
		foreach ($ascii as $newCode) {
			$len = $newCode;
			print (($len==0) ? "+" : str_repeat ("*", $len)).":";
		}
		print "-";
		
	}
} else {
	$tmp = explode ("-", $str);
	array_pop ($tmp);
	foreach ($tmp as $lettera) {
		$total = "";
		foreach (explode (":", $lettera) as $carattere) {
			$total = $total.(($carattere=="+") ? "0" : strlen ($carattere));
		}
		$total = substr ($total, 0, strlen ($total)-1);
		$total = intval ($total) - $key;
		print chr ($total);
		$total = "";
	}
}
	
print "\n";
?>

Uso, da linea di comando:
Per fare l'encrypt:
Codice:
php /var/www/cripta.php file_to_crypt key(optional)
Esempio:
Codice:
php /var/www/cripta.php ciao.txt
Oppure con una chiave personalizzata:
Codice:
php /var/www/cripta.php ciao.txt 0
Per fare il decrypt:
Codice:
php /var/www/cripta.php file_to_decrypt key 1
Esempio:
Codice:
php /var/www/cripta.php decriptami.txt 0 1

Frase di esempio:
Codice:
***:******:******:-***:********:******
:-***:********:***:-***:*:****:-***:*********
:*****:-***:*********:*********:-***:********
:*******:-***:********:*:-***:********:*********
:-***:*:****:-***:********:+:-***:*********:******
:-***:*********:***:-****:+:*:-***:*********:**:-
***:*:****:-***:********:****:-***:*********:***
:-****:+:**:-***:*:****:-***:********:********:-
***:*********:*********:-***:*********:*:-***:
*********:****:-***:*********:*******:-***:*:****
:-***:*********:***:-****:+:+:-***:********:***:
-***:*********:******:-***:*:****:-***:*********
:********:-***:********:******:-***:********:***
:-***:*:****:-***:*********:+:-***:*******:*********
:-****:+:****:-****:+:***:-***:*:****:-***:********
:**:-***:*********:***:-***:********:*****:-**:****
*****:**:-

ps. ho aggiunto degli 'a capo' casuali perchè altrimenti sballerebbe la grafica del forum

Funzionamento:
Recupero il file;
Spezzetto la stringa per ogni carattere in un array (esempio: ciao diventa array ([0] = "c", [1] = "i" [...]));
Genero il codice ascii e lo spezzetto;
A seconda di cosa è produco: un + se è uno zero, un * se è un numero normale e separo il tutto con il : (esempio: 300 = ***:+:+);
Ad un altro carattere aggiungo un - (esempio: 300 200 = ***:+:+:-**:+:+)
 
java:
Codice:
import java.io.*;

public class CifrarioSimmetrico{
    BufferedReader encode;
    BufferedReader decode;

    public void encoder(){
        String text="",result="[",cod="";
        try{
            encode=new BufferedReader(new FileReader("enc.txt"));
            text=encode.readLine();
            if(text.equals("")){
                System.out.println("File Vuoto o non leggibile!");
                System.exit(0);
            }for(int i=0;i<text.length();i++){
                int r=text.charAt(i)-30;
                String a=Integer.toBinaryString(r);
                if(a.length()==6){
                    cod="0"+a;
                }if(a.length()==2){
                    cod="00000"+a;
                }if(a.length()==7){
                    cod=a;
                }
                for(int j=0;j<cod.length();j++){
                    String cod2=""+cod.charAt(j);
                    if(cod2.equals("1")){result+=".";}else{result+="_";}
                }result+="]-[";
            }result=result.substring(0,result.length()-2);
        System.out.println(result);
        encode.close();
        }catch(IOException e){
            System.out.println(e.getMessage());
            System.exit(0);
        }
    }
    public void decoder(){
        String text="",result="",dec2="";
        int count=0;
        try{
            decode=new BufferedReader(new FileReader("dec.txt"));
            text=decode.readLine();
            if(text.equals("")){
                System.out.println("File Vuoto o non leggibile!");
                System.exit(0);
            }text=text.replace("[","");
            text=text.replace("]","");
            text=text.replace("-"," ");
            text=text.replace(".","1");
            text=text.replace("_","0");
            for(int i=0;i<text.length();i++){
                if(!(""+text.charAt(i)).equals(" ")){
                    dec2+=""+text.charAt(i);
                    count++;
                }if(count==7){
                    if(dec2.length()==2){
                       result+=" "; 
                    }else{
                        result+=(char)(Integer.parseInt(dec2,2)+30);
                    }
                    count=0;
                    dec2="";
                }
            }System.out.println(result);
            decode.close();
        }catch(IOException e){
            System.out.println(e.getMessage());
            System.exit(0);
        }
    }
}

preleva le stringhe dai rispettivi file di testo enc.txt e dec.txt che devono trovarsi nella stessa directory dove risiede il programma.

frase di esempio:
Codice:
[_.._.._]-[.__._._]-[.___...]-[_____._]-[._.__..]-[._._...]-[.__._..]-
[.___._.]-[.__.._.]-[_____._]-[.___.__]-[._._.__]-[._.___.]-[._..__.]-
[._.____]-[_____._]-[.__.___]-[._.___.]-[._.._._]-[_____._]-[.__..__]
-[._._...]-[.__....]-[._.__._]-[._._._.]-[_____._]-[._.___.]-[._..___]-
[.___...]-[._._.__]-[_____._]-[._._.._]-[.__._._]-[.___...]-[_____._]-
[.__..._]-[.____..]-[._...__]-[._.._..]-[_____._]-[.___.._]-[._.___.]-
[.__.__.]

ps. ho aggiunto degli 'a capo' casuali perchè altrimenti sballerebbe la grafica del forum

Funzionamento:
-prelevo la stringa dal file di testo
-prendo ogni singolo carattere
-prendo il suo ascii e sottraggo 30
-converto il numero ricavato in binario
-sostituisco gli 1 con . e gli 0 con _ ,intervallando ogni pezzo con - e racchiudendoli in delle parentesi quadre.

esempio:carattere "T" in ascii 84,sottraggo 30 ottengo 54,converto 54 in binario 0110110,sostituisco come detto sopra gli 1 e gli 0 e ottengo [_.._.._]-
 
[ot]Non ho ben capito cosa sia un cifrario simmetrico, ho cercato su wikipedia, ma dice che ci deve essere una chiave, mentre Oromis ha detto che non ci deve essere... In ogni caso ho l'algoritmo pronto, solo non so se lo devo postare per il fatto che non ho ben capito se rientra o no nei criteri del contest[/ot]
 
[ot]praticamente devi realizzare un algoritmo di codifica e decodifica,se conosci rot13 o base64 allora basati sul loro di concetto (non come è realizzato l'algoritmo ma come concetto di cifrario).[/ot]
 
Ecco qui il mio cifrario simmetrico .D

La spiegazione e' all'inizio del sorgente.

Language: lulzJS
Source: http://tfk.pastebin.com/fb7998ff

Frase d'esempio:
Codice:
,@~%-,;,%(;S%+[>n+;_@:g>D{a!?J.D<B$(K++0<!_q?)t@=+f,Q(/=,2)@.}#C<d@'-X%{#S%,%}f_!-b;}G~t-N}(o-}$7-$}5!@%)>-!2-g(R:(q<4?q>R_T<-#}K}c!C(]>/U<[!;-@!m!$',>J$(@*+;}s:c?+!I#}+;i>_o%+?}!:e_<%!C)V}6?},Z}D#}U]+>}>[U>>E.?Q.)>.C}>6%!D?s(+!!=?#-%/~5.3;0?I.?X/%A_]E[}t_?9<n/!v;<Q%w@>@;-}N$Y}8@%
~")J+$>-+d%%!b]2?/v-)+-U/_!}<g/-.$J[,)!)3}>_-a+<>V/-&{{<@%V<!l%Z-:]@>>/<g)d-F(Z,}%.F}J%_[
){8(_X!+$n!Q_<E>}++!;X.?Q!~}j<_-$@}[-l>}!!}}L#Z(:-H(L$#}a[%.g/i+{-B<0??W!;[c~A(e+g:!}};b(@!$N-s>B.K#!)-5@p<I<
Il risultato cambiera' ogni volta che verra' eseguito in quanto c'e' una dose di roba randomica.

Ah ovviamente e' molto lento, pero' mi son divertito .D

Edit:
Per Oromis92 il miscredente:
Codice:
meh@lolcahost ~ $ cat to_crypt 
OROMIS E' UN MISCREDENTE!1!1!!!11QUATTRO
meh@lolcahost ~ $ crypt_infernet.js to_crypt encrypted
meh@lolcahost ~ $ cat encrypted 
}J:<.o(#]^>#*+f%(!~=~f)'>.h?N@>I[@-f%;6[O[+X[,3<(+7],?)"/?L)}?$?i:&;]{}#}<(^!!"${{[4<[_d(']{%~>?+>~!9,--%--,I{),([{$Z!)<*>G?#$N}[}W{(l%!++?Q_/r)>)8_%>+@:+"#1~4+W,--P,%~,9@$n}+_(O~{P-4#->?w-[:,/_N,,O>{P_>L]]9[Y?>B,)!.~B/#?*@/0!!.?8<-.l:?]f[{^(?':i#n]_Q:S~:!~)O?Z$({;%>b!!{<K;[}(=%;*]j(c/u;<*%N?%)-2/,(L}>r$~?),%Y!?b%C@L<Z:U[8!<}Y<;>]@!A(}k<p.-~,N--w>^$@!_F$+>}R]{4-t{F,}$0[n/,~:h[>E//#a)v}d:$=?{n/K%^@.$<B?f.:,S;)S)<>B;"[@.-M%K-%)#_l%u$}#}k_^_<!?C(>>f%~j-
meh@lolcahost ~ $ crypt_infernet.js -d encrypted 
OROMIS E' UN MISCREDENTE!1!1!!!11QUATTRO
meh@lolcahost ~ $ crypt_infernet.js to_crypt encrypted
meh@lolcahost ~ $ cat encrypted 
<#M>p#+~$%[-+}<q)]/-,}H~>)g/K%-U,~r;?M;."(%l+$.(f#;c(;<a!
$+::.9@%@e!<
+a>H%T_M)B_h)-B;M]+D,=,f%a@(r?p>-]7+j#(t+P-!o+s/~p,A@V<T/@/f>:+N>?@h]?G)h<A]((++B%&?@{S_>;O{%F}+Q,/%e;*_V+V$!"}#<3##._}>~&%[s;>$%0%f+<{Y~=_.][@6<a:;})m:S[j+>$/Z>~V/~t@%#W[+-M:d%I(R-)/!@H#_}>D:]e[u_{]#!:@<;f?/$%K<K(([+=#Q,p<>(T$$}N_n/X?f%("?)X([@l}+E>~a$-]T~r<2<2(l-L;9({f.>C?}!R[?Q,5_-?-%_(a~H:+U+P}a,[-$@P(?},:<':X:-^{n$.]2:]E#(0~.A[6{p+*$9[}4@@1>;{{}}[email protected]_.n}<,B]I)';o(P?r}({k#2.(u{($H?{,t>
>(3!7-}A!
.(R
meh@lolcahost ~ $ crypt_infernet.js -d encrypted 
OROMIS E' UN MISCREDENTE!1!1!!!11QUATTRO
 
Ecco il mio codice in php:
Codice:
<?php
error_reporting("E_ALL ~E_NOTICE");
function numbstr_encrypt($str) {
	for($i=0;$i<strlen($str);$i++) {
		$nums[] = ord($str[$i]);
	}
	for($i=0;$i<count($nums);$i++) {
		$c += $nums[$i];
	}
	$c = floor($c / strlen($str));
	while($c > 10) {
		$c = floor($c / 2);
	}
	for($i=0;$i<count($nums);$i++) {
		$nums[$i] *= $c;
	}
	return join("",$nums).$c;
}
function numbstr_decrypt($num) {
	$c = 1;
	settype($num,"string");
	$k = $num[strlen($num)-1];
	for($i=0;$i<strlen($num);$i++) {
		if($c != 4) {
			$prov .= $num[$i];
			$c++;
		} else {
			$nums[] = $prov;
			unset($prov);
			$prov = $num[$i];
			$c = 2;
		}
	}
	for($i=0;$i<count($nums);$i++) {
		$nums[$i] /= $k;
	}
	for($i=0;$i<count($nums);$i++) {
		$nums[$i] = chr($nums[$i]);
	}
	return join("",$nums);
}
?>
Perl:
Codice:
use integer;
sub encrypt {
	$str = shift;
	for($i=0;$i<length($str);$i++) {
		$arr[$i] = ord(substr($str,$i,1));
	}
	for($i=0;$i<$#arr;$i++) {
		$c += $arr[$i];
		$c /= $#arr;
	}
	$c /= 2 while($c > 10);
	for($i=0;$i<=$#arr;$i++) {
		$arr[$i] = $arr[$i] * $c;
	}
	return join("",@arr).$c."\n";
}

sub decrypt {
	$str = shift;
	@s = split //,$str;
	$k = $s[$#s];
	$c = 1;
	for($i=0;$i<length($str);$i++) {
		if($c != 4) {
			$ret .= $s[$i];
			$c++;
		} else {
			push @nums, $ret;
			$ret = $s[$i];
			$c = 2;
			}
	}
   for($i=0;$i<length(join("",@nums));$i++) {
		$nums[$i] = chr($nums[$i] / $k);
	}
	return (join "", @nums)."\n";
}
[ot]Il codice è un po' vecchiotto (qualche anno) e andrebbe migliorato[/ot]
L'algoritmo funziona così:
Intanto calcolare i valori ascii delle lettere(funzione ord in php,perl,python)
Poi sommare tutti questi valori e dividerli per la lunghezza della stringa. Il risultato è la chiave
Finchè la chiave è maggiore di 10 dividerla per 2.
Moltiplicare ogni risultato ottenuto (valori ascii delle lettere) per la chiave.
Scrivere tutti i risultati attaccati e in fondo mettere la chiave
Schemettino:
Codice:
C   I   A   O
|   |   |   |
67  73  65  79 chiave = (67+73+65+79) / 4 = 71 (diviso x 2 finchè > 10) = 8
|   |   |   |
67* 73* 65* 79*
8   8   8   8
|   |   |   |
536 584 520 632
---------------------------
            |
      5365845206328
 
Ciao regaz.. scusate il ritardo..non mi ero accorto della sezione prima di ieri..!!
complimenti a tutti intanto...
purtroppo io arrivando per ultimo ho dovuto fare qualcosa di un pelino piu originale...

il mio script prende come input una stringa da un file e restituisce un file contenente la stringa 'criptata'. (encoded.rb)
ma la stringa criptata è in realta anche il codice che se eseguito la decodifica e restituisce l'originale.

Il codice generato varia ogni volta anche con la stessa stringa grazie a numerosi parametri casuali e per elaborare l'output decodifica parti della stringa originale codificate precedentemente dal programma base e le decripta con apposite funzioni!

E' possibile inserire nel programma infinite funzioni per cifrare (tipo molte delle vostre) e queste verranno invocate a random per precodificare pezzi della stringa originale.

[ruby] lo script cif0.rb :
Codice:
#!/usr/bin/ruby
require "base64"
$_fnc=[
"X3I9IiIKX3Muc3BsaXQoIiAiKS5lYWNoe3xjfApjPWMudG9faS0zMApjLnRvX3MuZWFjaF9ieXRle3xjMHwKIF9yKz0oYzAuY2hyLnRvX2k+MCkgPyAiLSIq
YzAuY2hyLnRvX2kgOiAiXyIKX3IrPSIsIgp9Cl9yPV9yWzAsX3IubGVuZ3RoLTFdCl9yKz0iLiIKfQpfcgo=",
"X3I9IiIKX2xsPSIiCl9zLnNwbGl0KC8gLykuZWFjaHt8bnwKbj1uLnRvX2kudG9fcygyKQpuPSIwIituIHVudGlsIG4ubGVuZ3RoPT04Cm4uZWFjaF9ieXRl
e3xiYnwKX2xsKz1iYi5jaHIKaWYgX2xsLmxlbmd0aD09Mgpfcis9KDM1K19sbC50b19pKS5jaHIrIn4iCl9sbD0iIgplbmQKfQp9Cl9yCg==",
"Cl9yPScnCl9zLnNwbGl0KCIgIikuZWFjaHt8bXwKbT1tLnRvX2leNwpfcis9KChtPjMzIGFuZCBtPD0xMjApID8gbS5jaHIgOiAiXiIrbS50b19zKSsiISIK
fQpfclswLi4uLTFdCg=="
]
$_dec=[
"X3I9IiIKX3Muc3BsaXQoIi4iKS5lYWNoe3xxfApxLnNwbGl0KCIsIikuZWFjaHt8d3wKX3IrPSh3PT0iXyIpID8gIjAiIDogdy5sZW5ndGgudG9fcwp9Cl9y
Kz0iICIKfQpfcjA9IiIKX3Iuc3BsaXQoIiAiKS5lYWNoe3xlfAplPShlLnRvX2krMzApLnRvX3MKZT0iMCIrZSB1bnRpbCBlLmxlbmd0aD09MwpfcjArPWUr
IiAiCn0KX3IwWzAsX3IwLmxlbmd0aC0xXQo=",
"X3I9IiIKX2s9JycKX3Muc3BsaXQoIn4iKS5lYWNoe3x2fAp2PSh2WzBdLnRvX2ktMzUpLnRvX3MKX2srPSh2Lmxlbmd0aD09Mik/IHYgOiAnMCcrdgppZiBf
ay5sZW5ndGg9PTgKX2s9X2sudG9faSgyKS50b19zCl9rPScwJytfayB1bnRpbCBfay5sZW5ndGg9PTMKX3IrPV9rKyIgIgpfaz0nJwplbmQKfQpfclswLi4u
LTFdCg==",
"X3I9JycKX3Muc3BsaXQoLyEvKS5lYWNoe3xtfAptPShtWzAsMV09PSJeIikgPyBtWzEuLi0xXSA6IG1bMF0udG9fcwptPW0udG9faV43Cl9yKz1tLnRvX3Mr
IiAiCn0KX3JbMC4uLi0xXQ=="
]
def gogo(ff)
_rs=""
ff.split(":").each{|q|
_rs+=q.to_i.chr.to_s
}
_rs
end
$_out="\n"+Base64.decode64("ZGVmIGdvZ28oZmYpCl9ycz0iIgpmZi5zcGxpdCgiICIpLmVhY2h7fHF8Cl9ycys9cS50b19pLmNoci50b19zCn0KX3JzCmVuZAo=")+"\n"
$_cmt="#\n#\n#  By GreyFox -> http://www.cyberfox.netsons.org\n#\n#"
$_gv=[]

def encode(_s)
_g=rand($_fnc.length).to_i
_rr1=Base64.decode64($_fnc[_g])
_rr2=Base64.decode64($_dec[_g])
if !$_gv.include?(_g)
$_out+="def dec_"+_g.to_s+"(_s)\n"+_rr2+"\nend\n"
$_gv.push(_g)
end
$_out+="print gogo dec_"+_g.to_s+"(\""+eval(_rr1).to_s+"\")\n"
end

if !ARGV[0] || ARGV[1]
puts "usage fif0 <file>"
exit 0
end
if !File.file?(ARGV[0]) 
puts "Sorry, I can't read "+ARGV[0]+"."
exit 0
end
_nc=File.size?(ARGV[0])
ran=rand(4)
_nc/=10 until _nc<ran+3

File.open(ARGV[0]) do |_f|
_ncc=1
_ss=""
_f.each_byte{|c| c=c.to_s
c="0"+c until c.length==3
_ss+=" "+c

if(_ncc==4) 
_ncc=0
encode(_ss)
_ss=""
end
_ncc+=1
}
File.open "encoded.rb", "w" do |_outfile|
    _outfile << "#!/usr/bin/ruby\n"+$_cmt+"\n"+$_out+"puts \"\n\"\n#--->end encoded file"
end
puts "encoded string @ ./encoded.rb"
end

la stringa codificata:

Codice:
#!/usr/bin/ruby
#
#
#  By GreyFox -> http://www.cyberfox.netsons.org
#
#

def gogo(ff)
_rs=""
ff.split(" ").each{|q|
_rs+=q.to_i.chr.to_s
}
_rs
end

def dec_1(_s)
_r=""
_k=''
_s.split("~").each{|v|
v=(v[0].to_i-35).to_s
_k+=(v.length==2)? v : '0'+v
if _k.length==8
_k=_k.to_i(2).to_s
_k='0'+_k until _k.length==3
_r+=_k+" "
_k=''
end
}
_r[0...-1]

end
print gogo dec_1("#~#~#~#~$~$~$~#~$~-~-~#~$~-~$~$~#~-~#~#~")
def dec_0(_s)
_r=""
_s.split(".").each{|q|
q.split(",").each{|w|
_r+=(w=="_") ? "0" : w.length.to_s
}
_r+=" "
}
_r0=""
_r.split(" ").each{|e|
e=(e.to_i+30).to_s
e="0"+e until e.length==3
_r0+=e+" "
}
_r0[0,_r0.length-1]

end
print gogo dec_0("--------,---.--------,-------.-------,-----.------,---------.")
print gogo dec_1("#~#~#~#~$~-~-~.~#~-~#~#~$~-~#~-~$~.~#~-~")
print gogo dec_1("#~#~#~#~$~-~.~.~$~.~$~.~$~-~.~-~#~-~#~#~")
def dec_2(_s)
_r=''
_s.split(/!/).each{|m|
m=(m[0,1]=="^") ? m[1..-1] : m[0].to_s
m=m.to_i^7
_r+=m.to_s+" "
}
_r[0...-1]
end
print gogo dec_2("a!h!^127!'")
print gogo dec_2("m!r!j!w")
print gogo dec_2("t!'!h!q")
print gogo dec_2("b!u!'!s")
print gogo dec_0("-------,----.-------,-.--.-------,--------.")
print gogo dec_2("f!^125!^126!'")
print gogo dec_2("c!h!`!)")
puts "
"
#--->end encoded file

la frase d'esempio codificata è quella standard di oromis.

uso: codifica:
# ./cif0.rb <file>
decodifica:
# ./encoded.rb

esempio:

sciao

PS: Quel base64 che vedete non è stato assolutamente usato per criptare alcunche , ho utilizzato solo funzioni fai-da-me simili alle vostre. quel b64 sono appunto le funzioni codificate da invocare!
 
Mi sono dimenticato di dire che lo script prima divide la stringa in gruppi di caratteri il cui numero è random.
poi ogni gruppo lo codifica usando una delle funzioni di cifratura inserite nel programma (in questo caso ne ho inserite solo 3 ma se ne possono inserire un numero arbitrario) poi genera la parte di codice dedito a decodificarla e lo aggiunge all'output.
le funzioni per la precodifica sono inserite codificate in b64 perche dovevo usare questo script per un'altra cosa, ma è possibilissimo inserirle direttamente in ruby.
 
Stato
Discussione chiusa ad ulteriori risposte.