Newsgroup: it.comp.java
Titolo: Intepretare Codice

Buongiorno.
Devo fare un nuovo applicativo che funziona nel browser e legge e scrive in
un db.
Per farlo usero' php che e' a me il linguaggio piu' famigliare.
Ma ecco il problema: il programma in questione esiste gia' ed e' scritto in
java compilato ed eseguito sul lato client.
(ho i sorgenti).
La prima cosa che fa questo programma e' autenticarsi tramite user e
password in un database.
Ma per fare cio' NON PASSA LA PASSWORD IN CHIARO ma gioca un po' con le
lettere.
Del tipo: converte le lettere in ascii, ci aggiunge dei valori fissi, fa
delle scelte ed alla fine strasferisce il risultato per il controllo nel DB.
Se il valore ricavato corrisponde l'utente e' autenticato.
Io devo capire ESATTAMENTE cosa fa questo algoritmo e riprodurlo in PHP.
Se pubblico il listato, qualcuno mi sa dire cosa fa ?
(il java non lo conosco ed andando ad intuito ho ricostruito i calcoli, ma
il risutlato fatto a mano non torna).
Grazie !
selidori
http://www.bloopers.it

 ha scritto nel messaggio
news:ailpiu$4pp8$1...@stargate1.inet.it...


 Io in primis.
Grazie VERAMENTE !
Allora si tratta di un'autenticazione da fare tramite browser.
Come dicevo esiste gia' fatto in java compilato (.class) ma ora io devo
rifare da capo il programma.
L'utente si autentica inserendo username e password.
Una volta ottenuti dal form html queste due stringhe, il motore (ora java)
cerca in una tabella del db il nome dell'utente.
Quando lo trova confronta il valore del campo PASSWORD della stessa riga con
uno che calcola in base a quello introdotto nel form.
Io devo capire come effettuare questo calcolo.
Come gia' detto non so assolutamente java pertanto non capisco che cavolo
fa.
Mi sembra di capire che uno per uno estragga una lettera alla volta dalla
stringa, quindi la converta in valore ascii. da qua somma il valore ottenuto
con la prima lettera del login (sempre in ascii). poi leva 122 (se maggiore
di 122) ed in fine riottiene un carattere stampabile.
tuttavia non va.
ad esempio, ecco tre sempi di stringa di partenza e di arrivo:
inserendo il valore:
user: Elidori
password: 1e7c69
risulta: h n mm
(purtroppo non vi so dire i valori non stampabili)
inserendo
user: Merli
pswd: 713414
risulta: mdiggg
inserendo:
user: Colnaghi
pswd: 80596f
risulta: neknl!
(ovviamente sono state trascritte sempre uguali le maiusc/minus).
Insomma mi sapete dire A PAROLE come si calcola il risultante ?
Poi io me lo rifaccio in PHP....
Aggia', dimenticavo il trancio di sorgente:
(
login[1] e' la password di partenza, quella introdotta a manina
login[0] e' il login
cript= dovrebbe essere il risultante
)
  /**
                         *
************************************************************
                         */
                        String cript = "";
                        int ttNome = 0;
                        for (int tt = 0; tt < login[1].length(); tt++) {
                            int ascPass = login[1].charAt(tt);
                            if (ttNome >= login[0].length()) {
                                ttNome = 0;
                            }
                            int ascNome = login[0].charAt(ttNome);
                            ttNome += 1;
                            int ascTot = ascPass + ascNome;
                            if (ascTot > 122) {
                                ascTot -= 122;
                            }
                            char cr = (char) (ascTot);
                            cript += cr;
                        }
                        /**
                         *
************************************************************
                         */
grazieeeeeeeeeeeeeeee
selidori
http://www.bloopers.it

 
Ciao,
e' abbastanza semplice: viene fatta la somma dei codici dei caratteri
corrispondenti dello username e della password (in chiaro). Se il codice
risultante e' maggiore di 122, viene sottratto appunto il valore 122.
Nel caso in cui lo username sia piu' corto della password, per i
caratteri eccedenti viene sempre usato il primo carattere dello username.
-- 
Lucio Benfante
Brainbench MVP for Java 1
http://www.brainbench.com
MyTranscript: 
http://www.brainbench.com/transcript.jsp?pid=167064

 caratteri eccedenti viene sempre usato il primo carattere dello username.
Ti ringrazio veramente moltissimo della spiegazione.
Avevo capito pure io fosse cosi' ma i conti non tornano.
Facciamo il primo esempio:
utente: Merli
password introdotta: 713414
password calcolata: mdiggg
Questi sono sicuri perche' vanno. cioe' sono valori sicurissimi!
allora si diceva si ricavare i valori ascii, sommarli ed eventualmente
lavare 122. poi riconvertirli in ascii.
proviamoci:
(fidatevi, non state ad impazzire a controllare!)
------------------------------------------
M=77
7=55
totale primo valore 77+55=132
meno 122= 10
valore ascii di 10=LF (un char a sinistra)
invece dovrebbe risultare m (cioe' 109)
------------------------------------------
e=101
1=49
totale primo valore 150
meno 122= 28
valore ascii di 28=FS
invece dovrebbe risultare d (cioe' 100)
------------------------------------------
r=114
3=51
totale primo valore 165
meno 122=43
valore ascii di 43=+
invece dovrebbe risultare i (cioe' 105)
------------------------------------------
l=108
4=52
totale primo valore 160
meno 122=38
valore ascii di 43=&
invece dovrebbe risultare g (cioe' 103)
------------------------------------------
i=105
1=49
totale primo valore 154
meno 122=32
valore ascii di 43=SP
invece dovrebbe risultare g (cioe' 103)
------------------------------------------
M=77 (si riusa il primo carattere username)
4=52
totale primo valore 129
meno 122=7
valore ascii di 7=BEL
invece dovrebbe risultare g (cioe' 103)
Insomma il risultate dovrebbe essere mdiggg invece e' (due cahr non
stamp)i&(altri due non stamp).
ho provato a rifare i calcoli anche con varianti maiuscole/miuscole anche se
nel codice java non c'e'.
vi devo veramente un piacerone !
selidori
http://www.bloopers.it

 username.
 
...scusa, piccolo errore.
In realta' nel caso in cui lo username sia piu' corto della password e si
cerchi quindi di utilizzare un carattere oltre la sua lunghezza, si
ricomincia invece dall'inizio (non sempre il primo come ti avevo detto).
Quindi, supponendo una password lunga 15 e uno username lungo 8, quando
si processera' il nono carattere della password, si utilizzera' il primo
carattere dell' username; quando si processera' il decimo della password
si usera' il secondo dello username...e cosi' via.
Sei sicuro che sia questo l'algoritmo utilizzato? Non mi sembra che le
tue prove corrispondano e sono abbastanza certo (ora) che la spiegazione
sia corretta.
