Algoritmo simples de criptografia de chave simétrica que eu criei

Programação Java
#1

Ele funciona da seguinte maneira: Pega a mensagem, reverte, e nela adiciona alguns caracteres. Para faze-lo, eu basicamente usei as seguintes classes: String, StringBuilder (para adicionar ou remover caractere) e StringBuffer (para reverter a mensagem).

public interface Chave {

    public String criptografia(String x);
    public String descriptografar(String i);
}

public class Encriptar implements Chave {

    @Override
    public String criptografia(String x){
        StringBuffer sb = new StringBuffer(x); /*cria uma StringBuffer que
        recebe a String que é passada como argumento no método.
        */
        String a = sb.reverse().toString(); /*Cria uma string que armazena
        a string buffer revertida*/
        
        StringBuilder sc = new StringBuilder(a);/*cria uma stringbuilder que
        armazena a String revertida*/
        
        String p =  sc.insert(1, "GñopDS1G 978F 7CS7F-{54").toString();/*
        Adiciona os seguintes caracteres entre o primeiro e segundo caractere 
        (no caso, a partir da posição 1, indo até a posição 24)*/ 
        p = sc.insert(0, "D(GS G9õmoga16*.98F {´´´798!?").toString();/*adiciona
        os seguintes caracteres antes da palavra (a partir da posição 0, indo
        até a posição 29)*/
        p = sc.insert(p.length() - 1, "´´sg  dg5d4àóîís g2dg9s7").toString();/*
        adiciona os seguintes caracteres entre o penúltimo e último*/
        p = sc.insert(p.length(), "kl sco pesaox").toString();/*adiciona os
        seguintes caracteres depois do último*/
        
        return p.toUpperCase(); //retorna a mensagem criptografada maiúscula
    }//fim do método criptografia

    @Override
    public String descriptografar(String i) {
        StringBuilder sl = new StringBuilder(i);/*Cria uma StringBuilder que
        recebe a mensagem criptografada*/
        
        sl.delete(0, 29);/*elimina os caracteres da posição 0 à 29, onde foi
        adicionado caractere*/
        sl.delete(1, 24);/*elimina os caracteres da posição 1 à 24, onde foi
        adicionado caractere*/
        sl.delete(sl.length() - 13, sl.length());/*elimina os caracteres apartir
        da posição, onde foi adicionado caractere*/
        sl.delete(sl.length() - 25, sl.length() - 1);/*elimina os caracteres
        localizados antes do último caractere até o caractere localizado na
        posição da subtração entre o tamanho do caractere subtraido à 25, 
        onde foi adicionado caractere*/
        
        StringBuffer sf = new StringBuffer(sl.toString());/*Cria uma
        StringBuffer, que armazena a StringBuilder com a mensagem que foi
        passada para String*/
        
        String x = sf.reverse().toString();/*cria uma String que armazena a
        StringBuffer revertida, na qual foi passada para String*/
        
        return x;//retorna a mensagem descriptografada
    }//fim do método descriptografar
}//fim da classe Encriptar

public class Principal {

    public static void main(String[] args) {
        Encriptar e = new Encriptar();
        String mensagem = "Hadrya";
        System.out.println("Mensagem pura: "+mensagem);
        System.out.println("Mensagem criptada:\n"+e.criptografia(mensagem));
        
        String mensagemDescriptografada = e.criptografia(mensagem);
        
        System.out.println("Mensagem descriptografada: "
                +e.descriptografar(mensagemDescriptografada));
    }
    
}

Saída:

Mensagem pura: Hadrya
Mensagem criptada:
D(GS G9ÕMOGA16*.98F {´´´798!?AGÑOPDS1G 978F 7CS7F-{54YRDA´´SG DG5D4ÀÓÎÍS G2DG9S7HKL SCO PESAOX
Mensagem descriptografada: HADRYA

1 curtida
#2

O seguinte código faz uma criptografia chamada SHA256, projetado pela Agência de Segurança Nacional dos EUA (NSA). O problema, ou vantagem (dependendo do seu uso), o SHA256 é Irreversível, um valor de hash pode ser livremente distribuídos, armazenados e utilizados para fins comparativos.

public String criptografar(String senha) {
    try {
        java.security.MessageDigest algorithm = java.security.MessageDigest.getInstance("SHA-256");
        byte[] messageDigest = algorithm.digest(senha.getBytes("UTF-8"));
        StringBuilder hexString = new StringBuilder();
        for (byte b : messageDigest) {
            hexString.append(String.format("%02X", 0xFF & b));
        }
        return hexString.toString();
    } catch (java.io.UnsupportedEncodingException | java.security.NoSuchAlgorithmException ex) {
        return null;
    }
}

Para fazer testes com senhas irreversíveis vou usar um exemplo de cadastro de Usuario:

Senha Digitada:
123
Valor Adquirido: A665A45920422F9D417E4867EFDC4FB8A04A1F3FFF1FA07E998E86F7F7A27AE3

Este valor é gravado no banco de dados no campo senha deste Usuário. Quando ele fizer login, o valor digitado sera criptografado, e se o valor criptografado bater com o existente do banco, ele valida.

Senha Digitada:
Hydra
Valor Adquirido: CD80F8408E025EF077E7056466C00FE4A4AC09B9BF006487C198C799A2C43EA0

1 curtida
#3

Aliais seu código esta excelente, a unica recomendação q indicaria é de fazer com que

p = sc.insert(p.length() - 1, "´´sg  dg5d4àóîís g2dg9s7").toString();/*

… gere Strings aleatórias dependendo da senha da pessoa(tipo somar essas strings também), desta forma caso uma pessoa tenha em mãos a lista de Senha, ele dificilmente encontrará um padrão.

1 curtida