Arquivo Discussoes de Programacao e Tecnologia Ae pessoal sou novo ai no fórum e estou começando com o java também. Um grande abraço a todos!!
Eu tava pesquisando alguma coisa sobre criptografia, consegui fazer alguma coisa com MD5, mas o MD5 não dezincripta. Eu precisava de algo que incriptace e dezincriptace, passando por parâmetro uma string, alguém tem alguma coisa do tipo ai??
Baita Abraço!!
Cara esta me dando erro nesta linha aqui na classe CriptografarSenha:
ObterValorASCII obtemValorAscii = new ObterValorASCII();
Tenho que importar algo no meu projeto, fazer uma classe pra isso??
Mas pelo que eu vi do codigo é isso mesmo que estou precisando, ta perfeito só não to conseguindo roda por causa deste erro.
Alguma idéia??
cara faça uma classe “ObterValorASCII” com recendo uma String e devolvendo o codigo ASCII correspondente.
procure na net uma tabela.
Existe realmente a necessidade de decriptografar sua string?
O que costumo fazer aqui é comparar as criptrografias e não decriptografar. Creio eu que dá mais segurança!
Gostaria de saber tbm como funciona este processo de retornar o codigo ascII,alguem poderia explicar?
obrigado.
Existe realmente a necessidade de decriptografar sua string?O que costumo fazer aqui é comparar as criptrografias e não decriptografar. Creio eu que dá mais segurança!
É uma boa também cara, mas eu preciso sim decriptografar. 
Criptografia
public class CriptografarSenha {
private String senha;
public CriptografarSenha() {
}
public CriptografarSenha(String senha) {
this.criptografaSenha(senha);
}
/**
* Método que retorna a senha criptografada
* @return String this.senha.toString()
*/
public String getSenhaCriptografada() {
return this.senha.toString();
}
/**
* Método que criptografa a senha
* @param senha
* @return String senhaResult
*/
public String criptografaSenha(String senha) {
String senhaResult;
String arrumaResult = new String("");
StringBuffer senhaAsciiAux;
StringBuffer valorAscii;
Short senhaShort;
Short shortAux;
short somaSenha = 0;
senhaAsciiAux = new StringBuffer("000000000000000000");
valorAscii = new StringBuffer("000000000000000000");
ObterValorASCII obtemValorAscii = new ObterValorASCII();
int ind2 = 1;
for (int ind1 = 0; ind1 < senha.length(); ind1++) {
senhaAsciiAux.replace(
ind2 - 1,
ind2 + 1,
obtemValorAscii.getValorAscii(senha.substring(ind1)));
ind2 = ind2 + 3;
}
senhaAsciiAux.setLength(18);
// Truncando p/ os 18 caracteres da criptografia
for (int ind1 = 0; ind1 < 16; ind1 += 3) {
senhaShort =
new Short(senhaAsciiAux.substring(ind1, ind1 + 3).toString());
somaSenha =
(short) (senhaShort.shortValue());
shortAux = new Short(somaSenha);
arrumaResult = Short.toString(shortAux.shortValue());
if ((arrumaResult != null) && (arrumaResult.length() == 2)) {
arrumaResult = "0" + arrumaResult;
}
valorAscii.replace(ind1, ind1 + 2, arrumaResult);
}
valorAscii.setLength(18);
//Truncando p/ os 24 caracteres da criptografia do Logix
senhaResult = (String) valorAscii.toString();
this.senha = senhaResult;
// Obtendo senha criptografada
return senhaResult;
}
}
Decriptografa
public class DecriptoGrafarSenha {
private String senha;
/**
* Método que retorna a senha decriptografada
* @return String this.senha.toString()
*/
public String getSenhaDecriptografada() {
return this.senha.toString();
}
public DecriptoGrafarSenha() {
}
public DecriptoGrafarSenha(String senhaCripto) {
this.decriptografarSenha(senhaCripto);
}
/**
* Método que descriptografa a senha criptografada passada por parâmetro
* @param senhaCripto
* @return String senhaResult
* @throws java.lang.NumberFormatException
*/
public String decriptografarSenha(String senhaCripto) throws java.lang.NumberFormatException {
String senhaResult;
String arrumaResult = new String("");
StringBuffer senhaAsciiAux;
StringBuffer senhaResultAux;
StringBuffer valorAscii;
Short shortAux;
Short senhaCriptoShort;
short diminuiSenha = 0;
senhaAsciiAux = new StringBuffer("000000000000000000");
senhaResultAux = new StringBuffer("000000000000000000");
valorAscii = new StringBuffer(senhaCripto);
for (int ind1 = 0; ind1 < 16; ind1 += 3) {
senhaCriptoShort = new Short(valorAscii.substring(ind1,ind1+3).toString());
diminuiSenha = (short) (senhaCriptoShort.shortValue());
shortAux = new Short(diminuiSenha);
arrumaResult = Short.toString(shortAux.shortValue());
if ((arrumaResult != null) && (arrumaResult.length() == 2)) {
arrumaResult = "0" + arrumaResult;
}
senhaResultAux.replace(ind1, ind1 + 2, arrumaResult);
}
senhaResultAux.setLength(18);
//Truncando p/ os 18 caracteres da criptografia
senhaResult="";
try {
for(int ind1=0;ind1<16;ind1 +=3){
String aux = String.valueOf((char) new Short(senhaResultAux.substring(ind1, ind1 + 3).toString()).intValue());
if((Character.isLetterOrDigit(aux.charAt(0)))){
senhaResult += aux;
}
}
} catch(Exception ex) {
return "000000000";
}
return this.senha = senhaResult;
}
}
Teste
public class TesteClasseCriptoGrafiaDescriptografia {
/**
* Método main da classe
* @param args
*/
public static void main(String[] args) {
String pass = "uHjWdg";
CriptografarSenha cripto = new CriptografarSenha(pass);
//DecriptoGrafarSenha decripto = new DecriptoGrafarSenha();
System.out.println("Testes de senha");
System.out.println("Senha Plana: " + pass);
System.out.println("Senha Banco: " + cripto.getSenhaCriptografada());
System.out.println("#####################################");
System.out.println("");
System.out.println("FIM");
}
}
espero ter ajudado
Segue :D
public class ObterValorASCII {
private String valorASCII;
public ObterValorASCII() {
}
public ObterValorASCII(String caracterString) {
this.getValorAscii(caracterString);
}
/**
* Método que retorna o valor de uma string em ascii
* @param caracterString
* @return String resultCharacter
*/
public String getValorAscii(String caracterString) {
Character caracter;
Character caracter2;
Character caracter3;
Character caracter4;
String caracterAux;
String resultCharacter;
StringBuffer valorAscii;
int compara = 0;
short posIni = 0;
short posFim = 0;
short comparador = 0;
byte valorAsciiAux;
posIni = (short) 32;
posFim = (short) 126;
caracter = new Character(caracterString.charAt(0));
caracter2 = new Character('0');
caracter3 = new Character('A');
caracter4 = new Character('a');
valorAscii = new StringBuffer();
compara = caracter.compareTo(caracter2);
// Retorna 0 (zero) se for igual numericamente
// Retorna um numero menor que zero se for menor numericamente
// Retorna um numero maior que zero se for maior numericamente
if (compara == 0 || compara > 0) {
posIni = (short) 48;
compara = caracter.compareTo(caracter3);
if (compara == 0 || compara > 0) {
posIni = (short) 65;
compara = caracter.compareTo(caracter4);
if (compara == 0 || compara > 0) {
posIni = (short) 97;
} else {
posFim = (short) 90;
}
} else {
posFim = (short) 90;
}
} else {
posFim = (short) 47;
}
for (int i = posIni; i <= posFim; i++) {
caracterAux = caracter.toString();
valorAsciiAux = (byte) caracterAux.charAt(0);
comparador = valorAsciiAux;
if (comparador == i) {
if (comparador < 100) {
valorAscii.append("0").append(i);
// apenas para fazer igual ao 4GL USING &&&
} else {
valorAscii.append(i);
}
}
}
resultCharacter = new String(valorAscii);
return resultCharacter;
}
/**
* Método que retorna o valor ascii
* @return String this.valorASCII.toString()
*/
public String getValorASCII() {
return this.valorASCII.toString();
}
}