|
1. A crypt.bmp állomány TEA-ECB módban volt titkosítva, úgy hogy az állomány első 80 bájtját nem titkosítottuk, és a kulcs értéke: 0x0123, 0x4567, 0x89ab, 0xcdef. Fejtsük vissza, majd az eredeti állományt titkosítsuk CBC módban.
2. Titkosítsunk és fejtsünk vissza egy tetszőleges bináris állományt, rendre DES3-CBC, DES3-CTR, AES-CBC, AES-CTR módban, használva az általunk kiválasztott programozási nyelvhez megírt crypto könyvtárcsomagot. Forráskódok: bináris állomány titkosítása, visszafejtése a Blowfish-CBC algoritmussal Python, OpenSSL, Crypto++, Java.
3. Titkosítsunk és fejtsünk vissza egy tetszőleges bináris állományt, TEA-CBC, vagy TEA-CTR módban, ahol az alkalmazott kulcsot véletlenszerűen generáljuk.
4. Egy jpg állomány CBC blokk-titkosító módszert alkalmazva, affine, mod 256 titkosítóval volt titkosítva. Határozzuk meg az eredeti jpg állományt, a jpg titkosított értéke alapján, tudva, hogy az IV értéke (19), a titkosító kulcs pedig (157, 45).
5. Egy jpg állomány CBC blokk-titkosító módszert alkalmazva, Hill, mod 256 titkosítóval volt titkosítva. Határozzuk meg az eredeti jpg állományt, a jpg titkosított értéke alapján, ismerve a titkosító kulcsot, illetve tudva azt, hogy az IV értéke a titkosított állomány utolsó négy bájtjára van beírva.
6. Egy jpg állomány CBC blokk-titkosító módszert alkalmazva, Hill, mod 256 titkosítóval volt titkosítva, két betünkét. Határozzuk meg az eredeti jpg állományt a jpg titkosított értéke alapján, tudva, hogy az IV értéke (129, 131), a titkosító kulcs pedig (27, 131, 22, 101).
7. Határozzuk meg a inverzét mod m szerint, ahol az a és m legalább 128 bites véletlenszerűen generált számok legyenek. Használjuk a kiterjesztett Eukleidészi algoritmust. A feladat nem implementálható Pythonban, itt ugyanis implementálva van az algoritmus nagy számokra is: pow(a, -1, m).
8. Írjunk programot, amely meghatározza egy adott GF(28) -beli polinom multiplikatív inverzét. A program bemenetének tömbként adjuk meg a polinom együtthatóit és a program tömbként adja vissza az eredményt.
Példa:
4a -> ab, azaz [0100 1010] -> [1010 1011]
53 -> CA, azaz [0101 0011] -> [1100 1010]
9. Titkosítsunk és fejtsünk vissza egy tetszőleges bmp állományt Pythonban, DES3-CBC, DES3-ECB módban. Figyeljük meg, hogy a DES3-ECB titkosítás nem oldja meg az állomámy rejtjelezését!!!
10. Hasonlítsuk össze a Salsa20 és AES-256 titkosítók időigényét.
Segédanyag
TEA titkosítás, a blokkméret 64 bit, és a kulcsméret 128 bit. Az L, illetve R értékeket egy-egy 32 bites bájtszekvencia alapján kell létrehozni, a kulcsból képzett K[0], K[1], K[2], K[3] értékek is 32 bitesek, és a 128 bites kulcsból vannak létrehozva.
typedef unsigned int uInt;
void encrypt(uInt &L, uInt &R, uInt *Key) {
uInt delta = 0x9e3779b9;
uInt sum = 0;
for (int i = 0; i < 32; ++i) {
sum += delta;
L = L + (((R << 4) + Key[0]) ^ (R + sum) ^ ((R >> 5) + Key[1]));
R = R + (((L << 4) + Key[2]) ^ (L + sum) ^ ((L >> 5) + Key[3]));
}
}
void decrypt(uInt &L, uInt &R, uInt *Key) {
uInt delta = 0x9e3779b9;
uInt sum = delta << 5;
for (int i = 0; i < 32; ++i) {
R = R - (((L << 4) + Key[2]) ^ (L + sum) ^ ((L >> 5) + Key[3]));
L = L - (((R << 4) + Key[0]) ^ (R + sum) ^ ((R >> 5) + Key[1]));
sum = sum - delta;
}
}
void convertByte_toLR(uInt &L, uInt &R, unsigned char * byte, int len) {
R = L = 0;
int i;
for (i = 0; i < len / 2; ++i) {
L = (L << 8) + byte[i];
}
for (i = len / 2; i < len; ++i) {
R = (R << 8) + byte[i];
}
}
void convertLR_toByte(unsigned char *byte, uInt L, uInt R, int len) {
int i;
for (i = len / 2 - 1; i >= 0; --i) {
byte[i] = L & 0xFF;
L = L >> 8;
}
for (i = len - 1; i >= len / 2; --i) {
byte[i] = R & 0xFF;
R = R >> 8;
}
}
Java:
public static void encryptTEA_(int Lp[], int Rp[], int Key[]) {
int delta = 0x9e3779b9;
int sum = 0;
for (int i = 0; i < 32; ++i) {
sum = sum + delta;
Lp[0] = Lp[0] + (((Rp[0] << 4 & 0xfffffff0) + Key[0]) ^
(Rp[0] + sum) ^ ((Rp[0] >> 5 & 0x7ffffff) + Key[1]));
Rp[0] = Rp[0] + (((Lp[0] << 4 & 0xfffffff0) + Key[2]) ^
(Lp[0] + sum) ^ ((Lp[0] >> 5 & 0x7ffffff) + Key[3]));
}
}
public static void decryptTEA_(int Lp[], int Rp[], int Key[]) {
int delta = 0x9e3779b9;
int sum = delta << 5;
for (int i = 0; i < 32; ++i) {
Rp[0] = Rp[0] - (((Lp[0] << 4 & 0xfffffff0) + Key[2]) ^
(Lp[0] + sum) ^ ((Lp[0] >> 5 & 0x7ffffff) + Key[3]));
Lp[0] = Lp[0] - (((Rp[0] << 4 & 0xfffffff0) + Key[0]) ^
(Rp[0] + sum) ^ ((Rp[0] >> 5 & 0x7ffffff) + Key[1]));
sum = sum - delta;
}
}
public static int byteArrayToInt(byte[] b){
return b[3] & 0xFF |
(b[2] & 0xFF) << 8 |
(b[1] & 0xFF) << 16 |
(b[0] & 0xFF) << 24;
}
public static byte[] intToByteArray(int a){
return new byte[] {
(byte) ((a >> 24) & 0xFF),
(byte) ((a >> 16) & 0xFF),
(byte) ((a >> 8) & 0xFF),
(byte) (a & 0xFF);
}
|
