Transcript
Kapitel 6: Arithmetik in JavaCard Problem: Keine Integers in JavaCard ToDo: Rechnen mit Bytes und Shorts
Java SmartCards, Kap. 6 (1/20)
Hex-Notation 1 Byte = 8 Bit, b7 b6 b5 b4 b3 b2 b1 b0 0101 | {z } | {z } 1110
= 0 ∗ 27 + 1 ∗ 26 + 0 ∗ 25 + 1 ∗ 24 + 1 ∗ 23 + 1 ∗ 22 + 1 ∗ 21 + 0 ∗ 20 = 94
5
E
= 0x5E = 5 ∗ 16 + 14 = 94
Hex: 0. . . 9, 10 = A, 11 = B, 12 = C, 13 = D, 14 = E, 15 = F
Java SmartCards, Kap. 6 (2/20)
Wertebereiche in Java Typ
L¨ange
Minimaler Wert
byte
8 Bit
-128
short
16 Bit
-32768
int
32 Bit
-2147483648
long
64 Bit
-9223372036854775808
Maximaler Wert 127 32767 2147483647 9223372036854775807
Java SmartCards, Kap. 6 (3/20)
Arithmetik in Java: Java Language Specification 4.2.2 (Integer Operations): If an integer other than a shift operator has at least one operand of type long, then the operation is carried out using 64-bit precision, and the result of the numerical operator is of type long. If the other operand is not long, it is first widened (§5.1.4) to type long by numeric promotion (§5.6). Otherwise, the operation is carried out using 32-bit precision, and the result of the numerical operator is of type int. If either operand is not an int, it is first widened to type int by numeric promotion.
Java SmartCards, Kap. 6 (4/20)
Arithmetik in Java: •
Argumente werden automatisch nach int konvertiert
•
Berechnung mit Integers
•
Ergebnis ist int
•
Kein Check auf Over-/Underflow
short x, y; . . . short z = (short)(x * y); (Cast notwendig) 1.000.000 ∗ 1.000.000 = −727.379.968 (Overflow) (Bem.: Ein Argument long: Berechnung/Ergebnis long, analog fu ¨r float, double)
Java SmartCards, Kap. 6 (5/20)
Arithmetik in Java: •
Automatische Konvertierung byte → short → int
•
Umgekehrt ist expliziter Cast notwendig!
• •
Cast: u ¨ berza¨hlige“ Bits abschneiden ” Ergebnis von Arithmetikoperationen ist immer vom Typ int.
•
Arithmetikoperationen: +, -, *, /, % und
•
Bitoperationen: & (And), | (Or), ^ (Xor), ~ (Komplement) links-shift <<, rechts-shift >> (mit Vorzeichen), >>> (mit Nullen)
•
Negative Zahlen: 2er-Komplement
Java SmartCards, Kap. 6 (6/20)
Arithmetik in Java: Java Language Specification 5.1.2 (Widening Primitive Conversion): A widening conversion of a signed integer value to an integral type T simply sign-extends the two’s-complement representation of the integer value to fill the wider format. Java Language Specification 5.1.3 (Narrowing Primitive Conversion): A narrowing conversion of a signed integer to an integral type T simply discards all but the n lowest bits, where n is the number of bits used to represent type T. In addition to a possible loss of information about the magnitude of the numeric value, this may cause the sign of the resulting value to differ from the sign of the input value. Java SmartCards, Kap. 6 (7/20)
2er-Komplement: 1. Schritt:
bilde Bitdarstellung des Betrags
34 ⇒ 0010 0010
2. Schritt:
bitweise Invertierung
⇒ 1101 1101
3. Schritt:
addiere 1
⇒ 1101 1110 = -34
0010 0010 +34
=
0000 0000 0010 0010 0000 0000 0000 0000 0000 0000 0010 0010 1101 1110
-34
=
1111 1111 1101 1110 1111 1111 1111 1111 1111 1111 1101 1110
(byte) (short) (int) (byte) (short) (int)
Java SmartCards, Kap. 6 (8/20)
Eigenschaften •
Fu ˆ positive, 1 = ˆ negative Zahl ¨hrendes Bit ist Vorzeichen: 0 =
•
⇒ gro¨ßte Byte-Zahl: 0111 1111 = 0x7F = 127
•
⇒ kleinste Byte-Zahl: 1000 0000 = 0x80 = -128
•
Cast schneidet obere Bits ab: 0000 1000 1111 1111 ⇒ 1111 1111
•
Rest: 5 % 3 = 2, -5 % 3 = -2, 5 % -3 = 2, -5 % -3 = -2
•
int i; 0 ≤ i ∧ i % 256 ≤ 127
→ (byte)i = i % 256
0 ≤ i ∧ 127 < i % 256
→ (byte)i = (i % 256) − 256
i < 0 ∧ i % 256 < −128 → (byte)i = (i % 256) + 256 i < 0 ∧ − 128 ≤ i % 256 → (byte)i = i % 256
Java SmartCards, Kap. 6 (9/20)
6 weitere Bemerkungen dazu: 1. Arithmetik ist vom Typ int: byte b = (byte)(x + y);
(x, y Bytes)
byte b = (byte)(x & 0x7F);
(x Byte)
•
Beide Argumente werden in Integers umgewandelt
•
die Rechenoperation wird auf Integers ausgefu ¨hrt
•
das Ergebnis ist ein Integer
⇒ Cast notwendig. (Auch wenn Ergebnis in ein Byte passt.) 2. Integer Literale: •
Konstanten sind immer vom Typ Integer
byte b = 0x20; (narrowing primitive conversion) byte b = (byte)0xA0; (kein signed Byte) f((short)0) (bei Methoden keine narrowing primitive conversion) Java SmartCards, Kap. 6 (10/20)
3. Casts: A0 = 1010 0000 - fu ¨hrendes 1-Bit byte → int: A0 → FF FF FF A0 int → byte: 00 00 00 A0 → A0 4. Signed vs. Unsigned Bytes: (int)0xA0 = 160, aber (int)(byte)0xA0 = –96. unsigned byte → int: (b & 0xFF) da (int)((byte)0xA0 & 0xFF) = 160 5. int → High-Byte, Low-Byte: (i >> 8) & 0xFF und i & 0xFF (vgl. setShort) High-Byte, Low-Byte → int: (b1 << 8) | (b2 & 0xFF) (vgl. getShort) 6. (short)(-1 >>> 15) == -1 Java SmartCards, Kap. 6 (11/20)
Short- vs. Integer-Arithmetik 1. Beispiel: short x1 = 20000, x2 = (short)((x1 * 5) / 10); Integer-Arithmetik: x2 = 10000 Short-Arithmetik:
x2 = –3107
2. Beispiel: short x1 = 20000, x2 = 30000, x3 = (short)((x1 + x2) - x2); Integer-Arithmetik: x3 = 20000 Short-Arithmetik:
x3 = 20000
3. Beispiel: short x1 = 20000, x2 = 30000; boolean res = (x1 < x1 + x2); Integer-Arithmetik: res = true; Short-Arithmetik:
res = false;
Java SmartCards, Kap. 6 (12/20)
Der cap-Converter: •
pru ¨ft, dass kein int, long, . . . benutzt wird.
•
pru ¨ft, dass short-Arithmetik = int-Arithmetik ⇒ Rechengesetze
Beispiele: 1.
(short)((x * y) - z)
Ok
2.
x + y < z
Fehler!
3.
(x + y) / 1000
Fehler!
Java SmartCards, Kap. 6 (13/20)
Prinzip short-Arithmetik = int-Arithmetik, wenn . . . 1. das Ergebnis einer Operation (sofort) nach (short) oder (byte) gecastet wird: (short)(x ⊕ y) 2. die Operation innerhalb eines Casts stattfindet und bestimmte Rechenregeln gelten: (short)(a ⊕1 ((b ⊕2 c) ⊕3 d)) 3. das Ergebnis von der Gr¨oße her in ein short passt: byte b, c; ⇒ −32768 < b * (x % c) < 32767
Java SmartCards, Kap. 6 (14/20)
Rechengesetze (1): s, t: bel. Ausdru ¨cke mit Ergebnistype int, z. B. s = (x * y) * z 1.
Un¨ares Minus:
(short)(- s)
2.
Addition:
(short)(s + t) = (short)((short)s + t)
3.
Subtraktion:
(short)(s - t) = (short)(s - (short)t)
4.
Multiplikation:
(short)(s * t) = (short)((short)s * t)
= (short)(- (short)s)
und s¨amtliche Varianten. Bem.: 1. wird vom cap converter nicht akzeptiert.
Java SmartCards, Kap. 6 (15/20)
Rechengesetze (2): 1.
Komplement:
2.
Bitweises Und:
(short)(~s) (short)(s & t)
= (short)(~(short)s) = (short)((short)s & t)
3.
Bitweises Oder:
(short)(s | t)
= (short)((short)s | t)
4.
Bitweises Xor:
(short)(s ^ t)
= (short)((short)s ^ t)
5.
Links-Shift:
(short)(s << n) = (short)((short)s << n)
und sa¨mtliche Varianten.
Java SmartCards, Kap. 6 (16/20)
Rechengesetze (3): Im Allgemeinen (auch fu ¨r Varianten): 1. (short)(s / t) 6= (short)((short)s / (short)t) Beispiel: s = 216 , t = 215 2. (short)(s % t) 6= (short)((short)s % (short)t) Beispiel: s = 2 ∗ 216 − 1, t = 216 − 1 3. (short)(s >> n) 6= (short)((short)s >> n) Beispiel: s = 215 , n = 1 4. (short)(s >>> n) 6= (short)((short)s >>> n) Beispiel: s = 215 , n = 1 gilt natu ¨rlich, wenn s und t in ein short passen. Java SmartCards, Kap. 6 (17/20)
Rechengesetze (4): Im Allgemeinen (auch fu ¨r Varianten): 1. s < t 6⇔ (short)s < (short)t 2. (short)s == (short)t 6⇒ s == t aber natu ¨rlich s == t ⇒ (short)s == (short)t ⇒ (short)(x + y) == z Cast ist notwendig! gilt natu ¨rlich, wenn s und t in ein short passen.
Java SmartCards, Kap. 6 (18/20)
Rechengesetze (5): . . . gilt, wenn s und t in ein short passen? 1. short x,y,z ⇒ x & y “passt” – Ok! ⇒ (x & y) == z kein Cast notwendig. Ebenso fu ¨r |, ^ , ~, >>, >>> 2. short x,y,z ⇒ x % y “passt” – Ok! ⇒ (x % y) == z kein Cast notwendig. Ebenso fu ¨r / 3. byte x,y ⇒ x + y, x + 127 “passt” – Ok! ⇒ (x + y) == z kein Cast notwendig. Ebenso fu ¨r -, * 4. byte x,y,z ⇒ x + y + z, x + 128 “passt” – Fehler! Java SmartCards, Kap. 6 (19/20)
Spezielle Konstrukte: 1. Bei Compound assignment impliziter cast: short x; x += y + z; ok, ≡ x = (short)(x + (y + z)) x /= y + z; nicht ok, ≡ x = (short)(x / (y + z)) 2. Bei Shift wird 2. Argument n implizit zu (n & 31): x >> n ≡ x >> (n & 31)
Java SmartCards, Kap. 6 (20/20)
