É possível descriptografar SHA1 [duplicado]

De um modo geral, não é possível. SHA1 é uma função de hash criptográfica, então a intenção do projeto era evitar o que você está tentando fazer. Não se pode dizer que seja impossível (apenas no nosso mundo com recursos limitados). Se tiver um hash SHA1 simples, pode descodificá-lo se adivinhar o que foi encriptado. Mas isto não é, obviamente, eficiente. Na realidade, descodificar um hash SHA-1 grande é quase impossível. Só para entender. Pensem da função mod. Se você calcular mod 5 e obter zero como você sabe qual foi a entrada. Foram 5 ou 10 ou 500? Ou, claro, o SHA-1 é mais sofisticado, mas este é basicamente o ponto.

Uma vez que o SHA-1 mapeia várias sequências de bytes para uma, não se pode "descodificar" um hash, mas em teoria pode-se encontrar colisões: cadeias que têm o mesmo hash.

Parece que quebrar um único haxixe custaria cerca de 2,7 milhões de dólares de tempo de computador atualmente, então seus esforços são provavelmente mais bem gastos em outro lugar.

O SHA1 é um haxixe de Sentido Único. Então você não pode revertê-lo realmente. É por isso que as aplicações o usam para armazenar o hash da senha e não a própria senha.

Como toda a função hash SHA-1 mapeia um grande conjunto de Entradas (as chaves) para um pequeno conjunto de alvos (os valores de hash). Assim, podem ocorrer colisões. Isto significa que dois valores do mapa do conjunto de entrada para o mesmo valor de hash.

Obviamente a probabilidade de colisão aumenta quando o alvo está a ficar menor. Mas vice isso também significa que a probabilidade de colisão diminui quando o conjunto alvo está ficando maior e o conjunto alvo do SHA-1 é de 160 bits.

Jeff Preshing , escreveu um blog muito bom sobre probabilidades de colisão de Hash {[19] } que pode ajudá-lo a decidir qual o algoritmo de hash a usar. Obrigado Jeff.

[[7]} em seu blog ele mostra uma tabela que nos diz a probabilidade de colisões para um determinado conjunto de entrada.

Como podes ver a probabilidade de um O hash de 32 bits é 1 em 2 se tiver 77163 valores de entrada.

Um simples programa java vai mostrar - nos o que a sua tabela mostra:

public class Main {

    public static void main(String[] args) {
        char[] inputValue = new char[10];

        Map<Integer, String> hashValues = new HashMap<Integer, String>();

        int collisionCount = 0;

        for (int i = 0; i < 77163; i++) {
            String asString = nextValue(inputValue);
            int hashCode = asString.hashCode();
            String collisionString = hashValues.put(hashCode, asString);
            if (collisionString != null) {
                collisionCount++;
                System.out.println("Collision: " + asString + " <-> " + collisionString);
            }
        }

        System.out.println("Collision count: " + collisionCount);
    }

    private static String nextValue(char[] inputValue) {
        nextValue(inputValue, 0);

        int endIndex = 0;
        for (int i = 0; i < inputValue.length; i++) {
            if (inputValue[i] == 0) {
                endIndex = i;
                break;
            }
        }

        return new String(inputValue, 0, endIndex);
    }

    private static void nextValue(char[] inputValue, int index) {
        boolean increaseNextIndex = inputValue[index] == 'z';

        if (inputValue[index] == 0 || increaseNextIndex) {
            inputValue[index] = 'A';
        } else {
            inputValue[index] += 1;
        }

        if (increaseNextIndex) {
            nextValue(inputValue, index + 1);
        }

    }

}

A minha saída termina com:

Collision: RvV <-> SWV
Collision: SvV <-> TWV
Collision: TvV <-> UWV
Collision: UvV <-> VWV
Collision: VvV <-> WWV
Collision: WvV <-> XWV
Collision count: 35135

Produziu 35135 colisões e é a metade de 77163. E se eu executar o programa com 30084 valores de entrada a contagem de colisão é 13606. Isto não é exatamente 1 em 10, mas é apenas uma probabilidade e o programa de exemplo não é perfeito, porque ele só usa os caracteres ascii entre A e z. Vamos fazer a última colisão declarada e verificar.

System.out.println("VvV".hashCode());
System.out.println("WWV".hashCode());

A minha saída é

86390
86390

Conclusão:

Se tiver um valor SHA-1 e quiser recuperar o valor de entrada, pode tentar um ataque de Força bruta. Isto significa que você tem que gerar todos os valores de entrada possíveis, adicioná-los e compará-los com o SHA-1 que você tem. Mas isso consumirá muito tempo e poder computacional. Algumas pessoas criaram as chamadas mesas arco-íris para alguma entrada. conjunto. Mas estes só existem para alguns pequenos conjuntos de entrada.

E lembre-se que muitos valores de entrada mapeiam para um único valor de hash alvo. Então, mesmo que você conheça todos os mapeamentos (o que é impossível, porque o conjunto de entrada é ilimitado) você ainda não pode dizer qual valor de entrada foi.