Estas 10 líneas de código que comparan cadenas para la igualdad me dan una completa confusión. Si no me cree, venga a ver

Estas 10 líneas de código que comparan cadenas para la igualdad me dan una completa confusión. Si no me cree, venga a ver

Código Ape Stone

Estas 10 líneas de código que comparan cadenas para la igualdad me dan una completa confusión. Si no me cree, venga a ver

Lamento usar este título para atraerlo a hacer clic, pero también puede leerlo y ver si puede ganar algo. (Sí, deja un mensaje en el área de comentarios. Nada. La transmisión en vivo el próximo fin de semana **, jaja, tú también lo crees)

Nota complementaria: la revisión de la cuenta oficial de WeChat tiene un impacto considerable en varios propietarios de cuentas. En la actualidad, de los datos de fondo, tiene poco efecto en mí, porque soy una imagen pequeña de todos modos. La cantidad de lectura en sí es lamentable. La verdad es, la imagen (recién aprendida del grupo de intercambio).

Primero vaya directamente al código:


boolean safeEqual(String a, String b) {
   if (a.length() != b.length()) {
       return false;
   }
   int equal = 0;
   for (int i = 0; i < a.length(); i++) {
       equal |= a.charAt(i) ^ b.charAt(i);
   }
   return equal == 0;
}

El código anterior fue traducido a Java en base a la versión original (Scala). La versión de Scala (el código que inicialmente llamó la atención del programador) es la siguiente:


def safeEqual(a: String, b: String) = {
  if (a.length != b.length) {
    false
  } else {
    var equal = 0
    for (i <- Array.range(0, a.length)) {
      equal |= a(i) ^ b(i)
    }
    equal == 0
  }
}

Al principio se siente extraño ver este código fuente. La función de esta función es comparar si dos cadenas son iguales. En primer lugar, "el resultado de la longitud desigual definitivamente no es igual, regresa inmediatamente" es bien entendido.
Eche un vistazo a la parte posterior y use su cerebro un poco, y podrá comprender la entrada incluso cuando gire: use la operación OR exclusiva 1 ^ 1 = 0, 1 ^ 0 = 1, 0 ^ 0 = 0 para comparar cada bit, si cada bit es igual, las dos cadenas deben ser iguales y la variable igual que almacena el valor XOR acumulativo debe ser 0; de lo contrario, es 1.

¿Piensas en ello de nuevo?


for (i <- Array.range(0, a.length)) {
  if (a(i) ^ b(i) != 0) // or a(i) != b[i]
    return false
}

A menudo hablamos de optimización del rendimiento. Desde la perspectiva de la eficiencia, ¿no debería ser posible devolver inmediatamente que dos cadenas no son iguales siempre que el resultado de un determinado bit sea diferente (es decir, 1)? (Como se muestra arriba).
Debe haber ...
Estas 10 líneas de código que comparan cadenas para la igualdad me dan una completa confusión. Si no me cree, venga a ver

¿Piensas en ello de nuevo?


En combinación con el nombre del método safeEquals, es posible que sepa algo sobre seguridad.

El código al comienzo de este artículo proviene de playframewok utilizado para verificar si los datos en la cookie (sesión) son legales (incluida la verificación de la firma), que también es el origen de este artículo.

Solíamos saber cómo mejorar la eficiencia a través de cálculos retrasados ​​y otros medios, ¡pero esta es la primera vez que los resultados se calculan pero se devuelven tarde!
Echemos un vistazo, hay un método similar en JDK, el siguiente código está tomado de java.security.MessageDigest:


public static boolean isEqual(byte[] digesta, byte[] digestb) {
   if (digesta == digestb) return true;
   if (digesta == null || digestb == null) {
       return false;
   }
   if (digesta.length != digestb.length) {
       return false;
   }

   int result = 0;
   // time-constant comparison
   for (int i = 0; i < digesta.length; i++) {
       result |= digesta[i] ^ digestb[i];
   }
   return result == 0;
}

Vea los comentarios, el propósito es comparar con la complejidad del tiempo constante.
Pero, ¿cuál es el riesgo de que el tiempo empleado en este proceso de cálculo no sea constante? (La música de fondo sonó en mi mente: "Chico, ¿tienes muchos signos de interrogación?")
Estas 10 líneas de código que comparan cadenas para la igualdad me dan una completa confusión. Si no me cree, venga a ver

La verdad es revelada


Después de una mayor exploración y comprensión, resulta que esto se hace para prevenir el ataque de tiempo. (Algunas personas lo traducen en sincronización ***)
Estas 10 líneas de código que comparan cadenas para la igualdad me dan una completa confusión. Si no me cree, venga a ver

Ataque de tiempo (ataque de tiempo)


Timing *** es un tipo de canal lateral *** (o "ataque de canal lateral", Side Channel Attack, SCA para abreviar). El canal lateral *** es un tipo de defecto de diseño de software o hardware, que es una especie de mal camino ". Un método ***.
Este método de piratería es para lograr el propósito de romper a través del consumo de energía, sincronización, fugas electromagnéticas, etc. En muchos entornos físicamente aislados, a menudo tiene un éxito sorprendente La eficacia de este nuevo tipo de seguridad es mucho mayor que los métodos matemáticos tradicionales de criptoanálisis (como se indica en una enciclopedia).
Este método puede hacer que llamar a safeEquals ("abcdefghijklmn", "xbcdefghijklmn") (solo el primer dígito es diferente) y llamar a safeEquals ("abcdefghijklmn", "abcdefghijklmn") (dos cadenas idénticas) toma el mismo tiempo. Evite que la cadena que se va a comparar sea forzada a través de una gran cantidad de cambios en las estadísticas de entrada y tiempo de ejecución.
Dar un ejemplo

Supongo que te gusta

Origin blog.51cto.com/15072927/2607592
Recomendado
Clasificación