add nactf_error-1 challenge,

Author: RaaCT0R

README.md

@@ -27,6 +27,7 @@ Here we upload:
 	- [UTCTF-crypto2: One True Problem](./cryptography/utctf_One-True-Problem/WRITEUP.md)
 	- [UTCTF-crypto3: Random ECB](./cryptography/utctf_Random-ECB/WRITEUP.md)
 	- [nactf-crypto5: Random Number Generator](./cryptography/nactf_random-number-generator/WRITEUP.md)
+	- [nactf-crypto5: Error 1](./cryptography/nactf_error-1/WRITEUP.md)
  - Sites and Laboratories
 	- [Ctflearn-p177: ALEXCTF CR2: MANY TIME SECRETS](./cryptography/ctflearn_ALEXCTF-CR2:-MANY-TIME-SECRETS/ctflearn-p177.md)
 	- [Ctflearn-p115: Character Encoding](./cryptography/ctflearn_Character-Encoding/ctflearn-p115.md)

cryptography/nactf_error-1/WRITEUP.md

@@ -0,0 +1,57 @@
+## Challenge name:	Error 1
+
+### Description:
+> Pranay has decided that the previous error detection scheme is a little bit too inefficient... While eating his delicious HAM-filled Italian Sub at lunch, he came up with a new idea. Fortunately, he has also invested in a less noisy communication channel.
+> 
+> P.S: given files: *[error1.py](./error1.py)*, *[enc.txt](./enc.txt)*
+
+### Solution:
+
+This is not a cryptography but a communication systems challenge that referred to **Hamming code Error Detection**. It **XOR** the index of ones (actually, index + 1) in binary representation of each block of message and save the result number *(parity)* with the block. You can read more [here](https://en.wikipedia.org/wiki/Hamming_code).
+
+In this challenge, they partitioned the message into block of size 11-bit that form a 4-bit parity and saved them at indexes of 0, 1, 3 and 7, which will form 15-bit blocks. After creating each block, they simulate one-bit error that flip a single bit. The parity number of result block will be:
+
+> parity = last_parity ^ (index_of_fliped_bit + 1)
+
+As we know about XOR, we can calculate **index_of_fliped_bit** as follow:
+
+> index_of_fliped_bit = (parity ^ last_parity) - 1
+
+So we need to partition the cipher into 15-bit blocks, calculate parity and compare it to parity that is saved with message, calculate XOR of them to get fliped bit index, and correct it.
+
+**Code**
+
+    from functools import reduce
+
+    text = ''
+
+    with open('enc.txt', 'r') as fd:
+        text = fd.read()
+
+    flag = []
+    flag = [[int(j) for j in text[i:i + 15]] for i in range(0, len(text), 15)]
+
+    code = ''
+    for i in flag:
+        p_arr = []
+        for j in range(4):
+            p_arr.append(str(i[2 ** j - 1]))
+        p_num = int(p_arr[0]) + int(p_arr[1]) * 2 + int(p_arr[2]) * 4 + int(p_arr[3]) * 8
+
+        parity = reduce(lambda a, b: a ^ b, [j + 1 for j, bit in enumerate(i) if (bit and j != 0 and j != 1 and j != 3 and j != 7)])
+        parity_arr = list(reversed(list(str(format(parity, "04b")))))
+
+        ind = (p_num ^ parity) - 1
+        i[ind] = int(not i[ind])
+        
+        for j in range(15):
+            if (j != 0 and j != 1 and j != 3 and j != 7):
+                code += str(i[j])
+
+    for i in range(0, len(code), 8):
+        print(chr(int(code[i:i+8], 2)), end='')
+    print()
+
+**The Flag**
+
+    nactf{hamm1ng_cod3s_546mv3q9a0te}

cryptography/nactf_error-1/enc.txt

@@ -0,0 +1 @@
+010011011010011010100011011001111110111101000101010011110111010101110110100110001100000111011101100100101111011010110001010011001110011010101111010111111010111010110111010111110110100110011011001101101101011101000111101000110100001010110100100001110110011110111011111101111000001100100011011010010111101100100100000011001101000001001010100000100111001011111101

cryptography/nactf_error-1/error1.py

@@ -0,0 +1,26 @@
+import random
+from functools import reduce
+
+with open("flag.txt", "r") as fin:
+    flag = fin.read()
+
+flag = "".join(str(format(ord(c), '08b')) for c in flag)  # converts flag to 8 bit ascii representation
+flag = [[int(j) for j in flag[i:i + 11]] for i in range(0, len(flag), 11)]  # separates into 11 bit groups
+code = []
+for i in flag:
+    for j in range(4):
+        i.insert(2 ** j - 1, 0)
+    parity = reduce(lambda a, b: a ^ b, [j + 1 for j, bit in enumerate(i) if bit])
+    parity = list(reversed(list(str(format(parity, "04b"))))) # separates number into individual binary bits
+
+    for j in range(4):
+        if parity[j] == "1":
+            i[2 ** j - 1] = 1
+    
+    # ind = random.randint(0, len(i) - 1)
+    # i[ind] = int(not i[ind]) # simulates a one bit error
+    code.extend(i)
+
+enc = "".join([str(i) for i in code])
+with open("enc1.txt", "w") as fout:
+    fout.write(enc)

cryptography/nactf_random-number-generator/WRITEUP.md

@@ -27,7 +27,7 @@ The **time.time()** will return seconds passed from 1970. So before we start the
         resp = r.recvline()
         return resp
 
-Since the service use only 5 precision of time() function, and it's divided by 100, the bruteforce should not be large. Add **0.000001** to time, generate a random number, compare to **r**, till we find right seed. Then we generate two next numbers and send to server and get flag in return. let's see the code:
+Since the service use only 5 precision of time() function, and it's divided by 100, the bruteforce should not be large. Add **0.00001** to time, generate a random number, compare to **r**, till we find right seed. Then we generate two next numbers and send to server and get flag in return. let's see the code:
 
     start_seed = round(time.time() / 100, 5)