Originariamente inviato da Pezzman
Sono uno studente di ingegneria ed il mio professore mi ha dato un lavoro da fare che io vi propongo:
perchè se l'ha dato a te lo proponi a noi ? 
Originariamente inviato da Pezzman
partendo da una pagina html criptata tramite codice javascript (qui vi mando a una pagina di esempio
qui ) bisogna:
è un esempio o è essattamente il tipo di crypt richiesto ?
Originariamente inviato da Pezzman
1) decodificare la pagina per comprenderne il codice
2) creare una pagina in html (con javascript) in cui inserendo il codice codificato in una Textarea, ne fornisca la decodifica in una seconda textarea sempre presente nella pagina (o visualizzi un'altra pagina con il codice decodificato - questo e indifferente)
Per quanto riguarda il primo punto non è un problema in quanto lo stesso firefox con il DOM inspector ti permette di ottenere il codice decodificato.
attenzione, FireFox permette di leggere quanto mostrato ma non dice niente sul crypt ... quindi il dom inspactor per questo problema non serve a niente, ovvio che mostra l'albero della pagina, visto che questa viene visualizzata.
Originariamente inviato da Pezzman
Invece il secondo punto è un po' più complesso: infatti il mio problema è che la pagina che devo creare deve essere in grado di decodificare tutte le pagine criptate che uno gli inserisce, non solo quello dell'esempio sopra citato. insomma deve fare un po quello che fanno i browser: dal codice javascript ottengono la chiave di decodifica che gli permette di interpretare il codice.
il browser non fa assolutamente niente ... è il javascript che compie le operazioni di decryptaggio ...
Originariamente inviato da Pezzman
Qualcuno ha qualche idea? Spero di essere stato abbastanza chiaro... vi ringrazio in anticipo
Non è ben chiaro il compito di questo professore ... intanto bisogna capire se il crypt di esempio è universale, ovvero se questa pagina del punto 2 debba essere compatibile esattamente con quel tipo di crypt, poi bisogna semplicemente analizzare il codice javascript presente nella pagina di esempio.
Ecco la mia analisi.
Il codice offuscato della pagina
Si basa principalmente sulla funzione codeIt, richiamata dalla funzione d, la quale non fa altro che accodare ad una variabile di tipo stringa il risultato della chiamata a codeIt.
Tale funzione sfrutta una chiave ovviamente ben visibile, la variabile key, la quale non fa altro che switchare i caratteri della stringa passata in modo speculare.
Se il carattere è presente nella prima metà della stringa, si prende a specchio il carattere della seconda metà (esempio, chiave "abcde", carattere "b", restituisce "d", ovvero distanza di b da c + c)
Da qui l'analisi via codice della funzione, per altro alquanto discutibile come realizzazione nel suo insieme.
codice:
// funzione codeIt, decripta in modo speculare in base ad una chiave
function codeIt (
mC, // chiave
eS // messaggio
) {
var wTG, // int (posizione del carattere sull achiave)
mcH = mC.length / 2, // float (metà lunghezza chiave in float)
nS = "", // risultato (stringa concatenata carattere per crattere)
dv; // float (char corrispondente da prendere nella chiave)
// per ogni carattere del messaggio ...
for (var x = 0; x < eS.length; x++) {
// prendo la posizione del carattere nella chiave
wTG = mC.indexOf(eS.charAt(x));
// se è maggiore della metà della chiave
if (wTG > mcH) {
// il carattere da prendere equivale alla index - la metà della chiave (torno in dietro di mezza chiave)
dv = wTG - mcH;
// aggiungo alla stringa il carattere chiave sottraendo metà (sono fagiani a usare 33 ... 33 equivale a parseInt(mcH))
nS = nS + mC.charAt(33 - dv);
}
// ... altrimenti ...
else {
// se il carattere non esiste nella chiave (sono fagiani a riusare key ... questo valore è esattamente wTG)
if (key.indexOf(eS.charAt(x)) < 0) {
// aggiungo semplicemente il carattere attuale
nS = nS + eS.charAt(x)
}
// altrimenti
else {
// il carattere da prendere equivale alla metà della chiave - la index (posiziono dv al contrario sulla prima metà della chiave)
dv = mcH - wTG;
// aggiungo alla stringa il carattere chiave aggiungendo metà
nS = nS + mC.charAt(33 + dv);
}
}
}
return nS;
}
Questa funzione usa un pò di statiche (il numero 33), si scorda di aver già preso valori ... ma l'importante è aver capito cosa fa con la chiave, e come creare quindi una funzione in grado di generare codice compatibile con la stessa.
codice:
function encodeIt(mC, eS){
var wTG,
mcH = mC.length / 2,
nS = [];
for(var i = 0, j = eS.length; i < j; i++) {
wTG = mC.indexOf(eS.charAt(i));
switch(wTG) {
case -1:
nS.push(eS.charAt(i));
break;
default:
wTG = (wTG > mcH) ?
parseInt(parseInt(mcH) - (parseInt(wTG) - mcH)) :
parseInt(parseInt(mcH) + (parseInt(mcH) - wTG));
nS.push(mC.charAt(wTG));
break;
}
}
return nS.join("");
}
niente di più semplice, fosse stato uno xor sarebbe stato più divertente ...
per fare la prova del 9 basta eseguire un'operazione come questa:
codice:
alert(ky === codeIt(key, encodeIt(key, ky)));
dove ky è la stringa stampata in cima alla pagina con document.write ... il risultato è true, quindi la funzione encodeIt è la mia versione della funzione che genera le stringhe utilizzate dalla loro codeIt.
Appurato che in testata il document.write non inserisce niente di utile a livello di crypting, nemmeno la funzione creata nella seconda parte della pagina, non resta che analizzare il resto.
Ad un certo punto si trova un eval di un unescape di una stringa.
Questa non è altro che una funzione di questo tipo:
codice:
function r(c) {
var n = "",
s,
l,
e,
d;
for (s = 0; s < c.length; s++) {
l = c.charAt(s);
e = q.indexOf(l);
if (e > -1) {
d = ((e + 1) % j - 1);
if (d <= 0) {
d += j;
}
n += q.charAt(d - 1);
} else {
n += l;
}
}
w += n;
}
dove c'è solo casino tra le locali e le globali dichiarate prima della funzione
codice:
var j=80,
m="",
w="",
q="yK4Y!oMaNH>fn-0CLWs.SV&uPOTkQA<=%;UrjR#J5I91qvideZwlB7:bF2c/8p G+6hzXtx_)mEgD(\"3";
j è semplicemente la length di q e q è la chiave usata dalla funzione r.
Quella funzione però è una mezza boiata ... il codice per generare stringhe compatibili con quella funzione dovrebbe essere questo:
codice:
function encoder(c) {
var p = 0,
q2 = q + q.charAt(0),
nS = [];
for(var i = 0, j = c.length; i < j; i++) {
p = q.indexOf(c.charAt(i));
switch(p) {
case -1:
nS.push(c.charAt(i));
break;
default:
nS.push(q2.charAt(++p));
break;
}
}
return nS.join("");
}
basata anche questa sulla q, la chiave ... ed altro non fa che prendere il carattere dopo.
La seconda parte sfrutta quindi un altro crypt addirittura più semplice per creare a sua volta la chiamata alla funzione d, quella usata in testata, con stringhe compatibili (ma switchate sembrano diverse per tipologia o caratteri).
Sapendo come è generato il codice della testata e sapendo come sono generate le stringhe nel body, non ti resta che sfruttare queste mie funzioni per riproporre il crypt / decrypt di quello che ti pare, fermorestando che il crypt considerato sia esattamente quello usato dalla pagina di esempio poichè non esiste un crypt decrypt universale e non puoi sfruttare questi metodi per tutte le pagine cryptate che trovi.
Saluti.
[edit]
poi mi dici quanto ho preso come voto ? ... sono curioso, ingegneria l'ho sempre evitata.
Rispondi quotando
