Wie das Internet-Prüfsumme aus einem byte [] in Java berechnen
-
29-09-2019 - |
Frage
Ich versuche, herauszufinden, wie man das Internet Checksum in Java berechnen und seine verursacht mir kein Ende der Schmerzen. (Ich bin schrecklich an Bitmanipulations.) Fand ich eine Version in C # berechnen ein Internet (auch bekannt als IP, auch bekannt als RFC791) Prüfsumme in C # . Aber bei meinem Versuch, es zu Java Umwandlung nicht sehen, die richtigen Ergebnisse zu erzielen. Kann jemand sehen, was mache ich falsch? Ich vermute, einen Datentyp Problem.
public long getValue() {
byte[] buf = { (byte) 0xed, 0x2A, 0x44, 0x10, 0x03, 0x30};
int length = buf.length;
int i = 0;
long sum = 0;
long data = 0;
while (length > 1) {
data = 0;
data = (((buf[i]) << 8) | ((buf[i + 1]) & 0xFF));
sum += data;
if ((sum & 0xFFFF0000) > 0) {
sum = sum & 0xFFFF;
sum += 1;
}
i += 2;
length -= 2;
}
if (length > 0) {
sum += (buf[i] << 8);
// sum += buffer[i];
if ((sum & 0xFFFF0000) > 0) {
sum = sum & 0xFFFF;
sum += 1;
}
}
sum = ~sum;
sum = sum & 0xFFFF;
return sum;
}
Lösung
Edited anzuwenden Kommentare von @Andy, @EJP, @RD et al und das Hinzufügen zusätzlicher Testfälle nur um sicher zu sein.
Ich habe eine Kombination aus @Andys Antwort (richtig identifiziert den Standort des Problems) und aktualisiert den Code umfassen die Unit-Tests in der verknüpften Antwort bereitgestellt verwendet zusammen mit einem verified Nachricht Prüfsumme zusätzlicher Testfall.
Zuerst wird die Umsetzung
package org.example.checksum;
public class InternetChecksum {
/**
* Calculate the Internet Checksum of a buffer (RFC 1071 - http://www.faqs.org/rfcs/rfc1071.html)
* Algorithm is
* 1) apply a 16-bit 1's complement sum over all octets (adjacent 8-bit pairs [A,B], final odd length is [A,0])
* 2) apply 1's complement to this final sum
*
* Notes:
* 1's complement is bitwise NOT of positive value.
* Ensure that any carry bits are added back to avoid off-by-one errors
*
*
* @param buf The message
* @return The checksum
*/
public long calculateChecksum(byte[] buf) {
int length = buf.length;
int i = 0;
long sum = 0;
long data;
// Handle all pairs
while (length > 1) {
// Corrected to include @Andy's edits and various comments on Stack Overflow
data = (((buf[i] << 8) & 0xFF00) | ((buf[i + 1]) & 0xFF));
sum += data;
// 1's complement carry bit correction in 16-bits (detecting sign extension)
if ((sum & 0xFFFF0000) > 0) {
sum = sum & 0xFFFF;
sum += 1;
}
i += 2;
length -= 2;
}
// Handle remaining byte in odd length buffers
if (length > 0) {
// Corrected to include @Andy's edits and various comments on Stack Overflow
sum += (buf[i] << 8 & 0xFF00);
// 1's complement carry bit correction in 16-bits (detecting sign extension)
if ((sum & 0xFFFF0000) > 0) {
sum = sum & 0xFFFF;
sum += 1;
}
}
// Final 1's complement value correction to 16-bits
sum = ~sum;
sum = sum & 0xFFFF;
return sum;
}
}
Dann wird der Unit-Test in JUnit4
package org.example.checksum;
import org.junit.Test;
import static junit.framework.Assert.assertEquals;
public class InternetChecksumTest {
@Test
public void simplestValidValue() {
InternetChecksum testObject = new InternetChecksum();
byte[] buf = new byte[1]; // should work for any-length array of zeros
long expected = 0xFFFF;
long actual = testObject.calculateChecksum(buf);
assertEquals(expected, actual);
}
@Test
public void validSingleByteExtreme() {
InternetChecksum testObject = new InternetChecksum();
byte[] buf = new byte[]{(byte) 0xFF};
long expected = 0xFF;
long actual = testObject.calculateChecksum(buf);
assertEquals(expected, actual);
}
@Test
public void validMultiByteExtrema() {
InternetChecksum testObject = new InternetChecksum();
byte[] buf = new byte[]{0x00, (byte) 0xFF};
long expected = 0xFF00;
long actual = testObject.calculateChecksum(buf);
assertEquals(expected, actual);
}
@Test
public void validExampleMessage() {
InternetChecksum testObject = new InternetChecksum();
// Berkley example http://www.cs.berkeley.edu/~kfall/EE122/lec06/tsld023.htm
// e3 4f 23 96 44 27 99 f3
byte[] buf = {(byte) 0xe3, 0x4f, 0x23, (byte) 0x96, 0x44, 0x27, (byte) 0x99, (byte) 0xf3};
long expected = 0x1aff;
long actual = testObject.calculateChecksum(buf);
assertEquals(expected, actual);
}
@Test
public void validExampleEvenMessageWithCarryFromRFC1071() {
InternetChecksum testObject = new InternetChecksum();
// RFC1071 example http://www.ietf.org/rfc/rfc1071.txt
// 00 01 f2 03 f4 f5 f6 f7
byte[] buf = {(byte) 0x00, 0x01, (byte) 0xf2, (byte) 0x03, (byte) 0xf4, (byte) 0xf5, (byte) 0xf6, (byte) 0xf7};
long expected = 0x220d;
long actual = testObject.calculateChecksum(buf);
assertEquals(expected, actual);
}
}
Andere Tipps
Eine wesentlich kürzere Version ist die folgende:
long checksum(byte[] buf, int length) {
int i = 0;
long sum = 0;
while (length > 0) {
sum += (buf[i++]&0xff) << 8;
if ((--length)==0) break;
sum += (buf[i++]&0xff);
--length;
}
return (~((sum & 0xFFFF)+(sum >> 16)))&0xFFFF;
}
Ich denke, es Art Förderung ist, die Probleme verursacht. Lets Blick auf data = (((buf[i]) << 8) | ((buf[i + 1]) & 0xFF))
:
-
((buf[i]) << 8)
würdebuf[i]
zuint
fördern, wodurch Zeichen Erweiterung -
(buf[i + 1]) & 0xFF
würde auchbuf[i + 1]
zuint
fördern, Zeichen Expansion verursacht. Aber Maskierung dieses Arguments mit0xff
ist das Richtige -. Wir richtigen Operanden in diesem Fall erhalten - Die ganze Ausdruck
long
gefördert wird (wieder einmal Zeichen enthalten).
Das Problem liegt in dem ersten Argument - es sollte mit 0xff00
maskiert werden, wie folgt aus: data = (((buf[i] << 8) & 0xFF00) | ((buf[i + 1]) & 0xFF))
. Aber ich vermute, es gibt effizientere Algorithmen für Java implementiert, vielleicht sogar Standard-Bibliothek hat einen. Vielleicht haben Sie einen Blick auf MessageDigest
nehmen, vielleicht ist es eine hat.