inverse longue série à l'algorithme de chaîne

Question

i besoin d'inverser l'algorithme suivant qui convertit une longue série dans une chaîne:

public final class LongConverter { 
private final long[] l; 

public LongConverter(long[] paramArrayOfLong) { 
    this.l = paramArrayOfLong; 
} 

private void convertLong(long paramLong, byte[] paramArrayOfByte, int paramInt) { 
    int i = Math.min(paramArrayOfByte.length, paramInt + 8); 
    while (paramInt < i) { 
     paramArrayOfByte[paramInt] = ((byte) (int) paramLong); 
     paramLong >>= 8; 
     paramInt++; 
    } 
} 

public final String toString() { 
    int i = this.l.length; 
    byte[] arrayOfByte = new byte[8 * (i - 1)]; 
    long l1 = this.l[0]; 
    Random localRandom = new Random(l1); 
    for (int j = 1; j < i; j++) { 
     long l2 = localRandom.nextLong(); 
     convertLong(this.l[j]^l2, arrayOfByte, 8 * (j - 1)); 
    } 
    String str; 
    try { 
     str = new String(arrayOfByte, "UTF8"); 
    } catch (UnsupportedEncodingException localUnsupportedEncodingException) { 
     throw new AssertionError(localUnsupportedEncodingException); 
    } 
    int k = str.indexOf(0); 
    if (-1 == k) { 
     return str; 
    } 
    return str.substring(0, k); 
} 

Alors, quand je fais l'appel suivant

System.out.println(new LongConverter(new long[]{-6567892116040843544L, 3433539276790523832L}).toString()); 

il imprime comme résultat.

Ce serait génial si quelqu'un pouvait dire quel algorithme c'est ou comment je pourrais l'inverser.

Merci pour votre aide

Answer 1

Ce n'est pas un problème résoluble comme indiqué parce

• vous utilisez uniquement l[0] donc des valeurs long supplémentaires pourraient être quelque chose. Il est garanti qu'il existe N << 16 solutions à ce problème. Alors que la graine pour random est 64 bits en réalité, la valeur utilisée en interne est de 48 bits. Cela signifie qu'il n'y a aucune solution, là si au moins 16K solutions pour une graine long.

Ce que vous pouvez faire est;

• trouver la plus petite graine qui générerait la chaîne en utilisant la force brute. Pour une courte durée, cela ne prendra pas beaucoup de temps, cependant si vous avez 5-6 caractères cela prendra du temps et pour 7+, il n'y aura peut-être pas de solution.

• au lieu de générer des caractères de 8 bits où toutes les valeurs de 8 bits sont égales. Vous pouvez limiter la plage à l'espace, A-Z, a-z et 0-9. Cela signifie que vous pouvez avoir ~ 6 bits de hasard, des graines plus courtes et des chaînes légèrement plus longues.

BTW Vous pourriez trouver ce post intéressant où j'utilise des graines aléatoires artificielles pour générer des séquences spécifiques. http://vanillajava.blogspot.co.uk/2011/10/randomly-no-so-random.html

Si vous voulez un processus qui vous permet de toujours recréer les longs d'origine à partir d'une chaîne ou d'un octet [], je suggère d'utiliser le cryptage. Vous pouvez chiffrer une chaîne codée en UTF-8 ou un octet [] dans un autre octet [] pouvant être codé en base64 pour être lisible en tant que texte. (Ou vous pouvez sauter le cryptage et utiliser base64 seul)