fam

xorBASICALLYFINISHED/encryptXorExpandedKey.py

@@ -0,0 +1,40 @@
+import os
+import sys
+
+KEY_SIZE = 10
+
+
+def expand_key(key, length):
+    return int(length / len(key)) * key + key[0:(length % len(key))]
+
+
+def xor(s1, s2):
+    assert len(s1) == len(s2)
+    return bytes([(a ^ b) for a, b in zip(s1, s2)])
+
+
+def main():
+    if len(sys.argv) <= 2:
+        key = os.urandom(KEY_SIZE)
+
+        filename = sys.argv[1]
+
+        f = open(filename,'rb')
+        data = f.read()
+        f.close()
+
+        expanded_key = expand_key(key, len(data))
+        data_encrypted = xor(expanded_key, data)
+
+        print(data_encrypted)
+
+        f = open(filename + ".enc", "wb")
+        f.write(data_encrypted)
+        f.close()
+
+        print("File %s encrypted with key: %s" % (filename, key.hex()))
+    else:
+        print("Usage: %s <filename>" % (sys.argv[0]))
+
+if __name__ == "__main__":
+    main()

xorBASICALLYFINISHED/temp/encryptXorExpandedKey.py

@@ -0,0 +1,57 @@
+import os
+import sys
+
+KEY_SIZE = 10
+
+
+def expand_key(key, length):
+    return int(length / len(key)) * key + key[0:(length % len(key))]
+
+
+def xor(s1, s2):
+    assert len(s1) == len(s2)
+    return bytes([(a ^ b) for a, b in zip(s1, s2)])
+
+
+def main():
+    if len(sys.argv) <= 2:
+        key = os.urandom(KEY_SIZE)
+        print(type(key))
+        filename = sys.argv[1]
+
+        f = open(filename,'rb')
+        data = f.read()
+        f.close()
+        #temp = bytes([0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0xc0, 0x03, 0x80, 0x02])
+        #eerste 10 bytes van voorbeeld afbeelding
+        #temp = bytes([0x49,0x47, 0x38, 0x46, 0x61, 0x39, 0x03, 0xc0, 0x02, 0x80])
+        #en dan krijg je deze bytes list
+        #solution = bytes([0x47, 0x3b, 0x57, 0x2b, 0x07, 0xd0, 0x29, 0xdb, 0x3b, 0x82])
+        #dus blijkbaar was de eerste set van bytes verkerd van volgorde, dus dit is de key die we dan krijgen (met de tweede temp)
+        #07a70ffe4f233ffbf9dd
+        #solution = bytes([0xf7, 0xa3, 0x1b, 0x32, 0xb1, 0x56, 0x94, 0x38, 0x3c, 0x90])
+        #solution = bytes.fromhex("07a70ffe4f233ffbf9dd")
+        #4947 3846 6139 03c0 0280
+
+        #key = bytes("49473846613903c00280")
+        #key = bytes.fromhex("0123456789")
+        #4947 3846 6139 03c0 0280
+        key = bytes(b'\x49\x47\x38\x46\x61\x39\x03\xc0\x02\x80')
+        #key = bytes([0x49, 0x47, 0x38, 0x46, 0x61, 0x39, 0x03, 0xc0, 0x02, 0x80])
+        #key = bytes([0x6e, 0x66, 0x4e, 0x7b, 0x94, 0xae, 0xd2, 0x15, 0xb4, 0xec])
+        key = bytes(b'\x29\x2f\x08\x43\xad\xcf\x12\x16\x34\xee')
+        expanded_key = expand_key(key, len(data))
+        data_encrypted = xor(expanded_key, data)
+
+        print(data_encrypted)
+
+        f = open(filename + ".enc", "wb")
+        f.write(data_encrypted)
+        f.close()
+
+        print("File %s encrypted with key: %s" % (filename, key.hex()))
+    else:
+        print("Usage: %s <filename>" % (sys.argv[0]))
+
+if __name__ == "__main__":
+    main()

xorBASICALLYFINISHED/temp/encryptXorExpandedKeyBEPPE.py

@@ -0,0 +1,86 @@
+import os
+import sys
+
+KEY_SIZE = 10
+
+def xor(s1, s2):
+    assert len(s1) == len(s2)
+    return bytes([(a ^ b) for a, b in zip(s1, s2)])
+
+def expand_key(key, length):
+    return int(length / len(key)) * key + key[0:(length % len(key))]
+
+
+
+def main():
+    if len(sys.argv) <= 2:
+        key = os.urandom(KEY_SIZE)
+
+        filename = sys.argv[1]
+
+        f = open(filename,'rb')
+        data = f.read()
+        f.close()
+
+        expanded_key = expand_key("0123456789", len(data))
+        data_encrypted = xor(expanded_key, data)
+
+        print(data_encrypted)
+
+        f = open(filename + ".enc", "wb")
+        f.write(data_encrypted)
+        f.close()
+
+        print("File %s encrypted with key: %s" % (filename, key.hex()))
+    else:
+        print("Usage: %s <filename>" % (sys.argv[0]))
+
+
+
+'''
+
+16^10 mogelijkheden, nie plezant dus, mss zoeken naar een andere manier da we iets kunnen vinden.
+
+wat doet de expand key eigenlijk? dat soort dingen
+
+'''
+
+def decrypt():
+
+    filename = "voorbeeld.gif.enc"
+    with open("test.txt", "w") as outfile:
+        for i in range(0,16**10):
+            #print(bin(i).encode('ascii'))
+            #print(bin(i).format('0<16'))
+            #print(bin(i).format(16))
+            #dus hier pak je de binaire versie van je iterator, en zet je die om naar een string, dit zal dus bv voor 1 0b1 geven, daarna wil je natuurlijk dat alle andere nullen erbij staan, anders krijg je geen 10 byte lange string, dus je haalt de 0b eraf en daarna gebruik je format en de string tussen de {} om de plaats links van onze input te vullen met 0
+            temp = '{:0>80}'.format(str(bin(i))[2:]).encode('ascii')
+            outfile.write(str(temp))
+            #print(temp)
+            #print(os.urandom(KEY_SIZE))
+            if i > 10:
+                break
+    data = open(filename,'rb').read()
+    print(expand_key("0123456789", len(data)))
+    return True
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+if __name__ == "__main__":
+#    main()
+    decrypt()
+
+

xorBASICALLYFINISHED/temp/temp.txt

@@ -0,0 +1,2 @@
+0000000 4947 3846 6139 03c0 0280               
+000000a

xorBASICALLYFINISHED/temp/test.txt

@@ -0,0 +1 @@
+b'00000000000000000000000000000000000000000000000000000000000000000000000000000000'b'00000000000000000000000000000000000000000000000000000000000000000000000000000001'b'00000000000000000000000000000000000000000000000000000000000000000000000000000010'b'00000000000000000000000000000000000000000000000000000000000000000000000000000011'b'00000000000000000000000000000000000000000000000000000000000000000000000000000100'b'00000000000000000000000000000000000000000000000000000000000000000000000000000101'b'00000000000000000000000000000000000000000000000000000000000000000000000000000110'b'00000000000000000000000000000000000000000000000000000000000000000000000000000111'b'00000000000000000000000000000000000000000000000000000000000000000000000000001000'b'00000000000000000000000000000000000000000000000000000000000000000000000000001001'b'00000000000000000000000000000000000000000000000000000000000000000000000000001010'b'00000000000000000000000000000000000000000000000000000000000000000000000000001011'

xorBASICALLYFINISHED/temp/writeup

@@ -0,0 +1,127 @@
+
+'''
+
+16^10 mogelijkheden, nie plezant dus, mss zoeken naar een andere manier da we iets kunnen vinden.
+
+wat doet de expand key eigenlijk? dat soort dingen
+
+
+expand key repeat gewoon de key die hij binnen krijgt (de 10 bytes) tot het de lengte heeft van het bestand dat geencrypt moet worden
+
+nu is de vraag, is er een stuk in een gif dat elke keer hetzelfde is en lang genoeg is dat we zo de key terug kunnen vinden. 
+'''
+dus, aangezien ons bestand een gif is betekend dit dat het begint met de letters GIF, dus de eerste 3 bytes kunnen ons al een stuk van onze key geven
+de volgende 3 bytes zijn 2 mogelijkheden 87a of 89a, dit kan ons ook al een voordeel geven, maar dan komen we inde problemen. meeste van de volgende bytes zijn afhankelijk van de afbeelding, daarna komen we in de volgende blok, nvm onze foto is 960 op 640, dit is een grote hulp want dat betekend dat we onze volledige string zullen hebben op 1 byte na: de eerste 3 bytes : GIF gevolgd door de volgende 3 bytes 87a/89a en dan gevolgd door 4 bytes die de grote van de afbeelding tonen,
+   waarvan we weten dat deze 960 op 640 px is
+
+bij onze voorbeeld foto was dit:
+4947 3846 6139 03c0 0280 00f7 0000 0000
+
+0000 0033 6600 0000 0099 cc00 0000 00ff
+
+002b 2b00 0033 662b 
+
+G I F 8 9 a 300 003 200 002
+
+na een poging om onze afbeelding een key uit te krijgen kreeg ik deze terug:
+473b572b07d029db3b82 
+blijkbaar verkeerd erges iets gedaan, dit is misschien de key?
+f7a31b32b15694383c90
+
+daarboven op heeft ons voorbeeld dezelfde dimensies? demensies? een van die twee. heeft dezelfde hoeveelheden van breedte en hoogte als onze te cracken gif. het enige dat kan veranderen is de version, dat van 89a naar 87a kan gaan. dit betekend dat we dus de key veel gemakkelijker eruit kunnen halen door te kijken naar de binaire waarden van deze letters en zo een xor uit te voeren om onze key te krijgen. yay
+
+temp:
+
+         2b00 0099 cc2b 2b00
+
+
+
+
+
+hier is wat info over gifs:
+{
+            GIF Header
+    Offset   Length   Contents
+      0      3 bytes  "GIF"
+      3      3 bytes  "87a" or "89a"
+      6      2 bytes  <Logical Screen Width>
+      8      2 bytes  <Logical Screen Height>
+     10      1 byte   bit 0:    Global Color Table Flag (GCTF)
+                      bit 1..3: Color Resolution
+                      bit 4:    Sort Flag to Global Color Table
+                      bit 5..7: Size of Global Color Table: 2^(1+n)
+     11      1 byte   <Background Color Index>
+     12      1 byte   <Pixel Aspect Ratio>
+     13      ? bytes  <Global Color Table(0..255 x 3 bytes) if GCTF is one>
+             ? bytes  <Blocks>
+             1 bytes  <Trailer> (0x3b)
+    Image Block
+    Offset   Length   Contents
+      0      1 byte   Image Separator (0x2c)
+      1      2 bytes  Image Left Position
+      3      2 bytes  Image Top Position
+      5      2 bytes  Image Width
+      7      2 bytes  Image Height
+      8      1 byte   bit 0:    Local Color Table Flag (LCTF)
+                      bit 1:    Interlace Flag
+                      bit 2:    Sort Flag
+                      bit 2..3: Reserved
+                      bit 4..7: Size of Local Color Table: 2^(1+n)
+             ? bytes  Local Color Table(0..255 x 3 bytes) if LCTF is one
+             1 byte   LZW Minimum Code Size
+    [ // Blocks
+             1 byte   Block Size (s)
+            (s)bytes  Image Data
+    ]*
+             1 byte   Block Terminator(0x00)
+    Graphic Control Extension Block
+    Offset   Length   Contents
+      0      1 byte   Extension Introducer (0x21)
+      1      1 byte   Graphic Control Label (0xf9)
+      2      1 byte   Block Size (0x04)
+      3      1 byte   bit 0..2: Reserved
+                      bit 3..5: Disposal Method
+                      bit 6:    User Input Flag
+                      bit 7:    Transparent Color Flag
+      4      2 bytes  Delay Time (1/100ths of a second)
+      6      1 byte   Transparent Color Index
+      7      1 byte   Block Terminator(0x00)
+    Comment Extension Block
+    Offset   Length   Contents
+      0      1 byte   Extension Introducer (0x21)
+      1      1 byte   Comment Label (0xfe)
+    [
+             1 byte   Block Size (s)
+            (s)bytes  Comment Data
+    ]*
+             1 byte   Block Terminator(0x00)
+    Plain Text Extension Block
+    Offset   Length   Contents
+      0      1 byte   Extension Introducer (0x21)
+      1      1 byte   Plain Text Label (0x01)
+      2      1 byte   Block Size (0x0c)
+      3      2 bytes  Text Grid Left Position
+      5      2 bytes  Text Grid Top Position
+      7      2 bytes  Text Grid Width
+      9      2 bytes  Text Grid Height
+     10      1 byte   Character Cell Width(
+     11      1 byte   Character Cell Height
+     12      1 byte   Text Foreground Color Index(
+     13      1 byte   Text Background Color Index(
+    [
+             1 byte   Block Size (s)
+            (s)bytes  Plain Text Data
+    ]*
+             1 byte   Block Terminator(0x00)
+    Application Extension Block
+    Offset   Length   Contents
+      0      1 byte   Extension Introducer (0x21)
+      1      1 byte   Application Label (0xff)
+      2      1 byte   Block Size (0x0b)
+      3      8 bytes  Application Identifire
+    [
+             1 byte   Block Size (s)
+            (s)bytes  Application Data
+    ]*
+             1 byte   Block Terminator(0x00)
+}