reformat to bytearray and padding fixes

Author: BarnyK

.gitignore

@@ -1,2 +1,3 @@
 /.vscode
-/__pycache__
+/__pycache__
+speedtests.py

constants.py

@@ -1,4 +1,4 @@
-HASH_VALUES = [
+INITIAL_HASH_VALUES = [
     0x6a09e667,
     0xbb67ae85,
     0x3c6ef372,

main.py

@@ -1,47 +1,74 @@
 from sys import argv
-from constants import *
+from constants import INITIAL_HASH_VALUES, CONSTANTS
 
-def pad_message(byte_message: bytes):
+# Words = 32b
+def circular_shift(x: bytes, y: int):
+    """
+    Word circular shift of bytes x by amount y
+    """
+    x = int.from_bytes(x, "big")
+    return NotImplementedError
+
+
+def xor(x: bytearray, y: bytearray):
+    """
+    XOR for bytes type
+    """
+    if len(x) != len(y):
+        raise Exception("XOR arguments should be the same length")
+    return bytes(int.from_bytes(x, "big") ^ int.from_bytes(y, "big"))
+
+
+def pad_message(byte_message: bytearray):
     """
     Pads message to length divisible by 512
     Appends binary 1 to the message and then appends number of zeros
     Number of zeroes is chosen so that the final message is divisible by 512 in bits
     """
-    number_of_zeros = 64 - ((len(byte_message)  + 8) % 64)
-    byte_message += b'\x80' + b'\x00' * (number_of_zeros - 1)
-    return byte_message
+    message_copy = byte_message[:] # Copy because bytearrays are done
+    number_of_zeros = 64 - ((len(message_copy) + 8) % 64)
+    message_copy += b"\x80" + bytearray(number_of_zeros - 1) + (len(message_copy)).to_bytes(8,"big")
+    return message_copy
 
 
-def divide_message(byte_message: bytes):
+def divide_message(byte_message: bytearray):
     """
     Divides messages into chunks of size 512
     """
     L = len(byte_message)
     if L % 64 != 0:
         raise Exception("Message length should be divisible by 64")
-    result_messages = [byte_message[64 * i : 64 * (i+1)] for i in range(L/64)]
+    result_messages = [byte_message[64 * i : 64 * (i + 1)] for i in range(int(L / 64))]
     return result_messages
 
 
+def sha256(message: str, encoding:str = "utf-8"):
+    message = bytearray(message, encoding)
+    return sha256_bytes(message)
 
-def encrypt(message: str):
-    message = message.encode("utf-8")
-    print(len(message))
-    return message
 
-def encrypt_bytes(message: bytes):
+def sha256_bytes(message: bytes):
+    message = pad_message(message)
+    messages = divide_message(message)
+    hash_values = INITIAL_HASH_VALUES
+    for m in messages:
+        chunk = m
+        for i in range(16,64):
+            i
+    print(len(message))
     return NotImplementedError
 
-def encrypt_file(filename):
-    return NotImplementedError
+
+def sha256_from_file(filename):
+    with open(filename, "rb") as f:
+        message = f.read()
+    return sha256_bytes(message)
+
 
 if __name__ == "__main__":
     while True:
         if len(argv) == 1:
             message = input("Input data: ")
         else:
             message = argv[1]
-        print(encrypt(message))
-        
-    
-    
+        print(sha256(message))

test_project.py

@@ -1,40 +1,77 @@
 import unittest
 
 
-class Test_Encryption(unittest.TestCase):
-
+class Test_Hashing(unittest.TestCase):
     def setUp(self):
-        from main import encrypt
-        self.encrypt = encrypt
+        from main import sha256
+
+        self.hash = sha256
 
     def test_result_against_hashlib(self):
         from hashlib import sha256
+
         message = "mzxkjcvnjkznxjkgvneqwiufhqwpqmajsdklfmaklsdmflkmklni2h543245njk"
-        encrypted_test = self.encrypt(message)
-        encrypted_known = sha256(message)
-        self.assertEqual(
-            encrypted_test, encrypted_known
-        )
-class Test_Padding(unittest.TestCase):
+        hash_test = self.hash(message)
+        hash_known = sha256(message)
+        self.assertEqual(hash_test, hash_known)
+
 
+class Test_Padding(unittest.TestCase):
     def setUp(self):
         from main import pad_message
+
         self.pad_message = pad_message
 
-    def test_correct_padding(self):
-        message = b'abcd'
+    def test_padding(self):
+        message = bytearray("abcd","utf-8")
+        padded_message = self.pad_message(message)
+        message += b"\x80" + b"\x00" * 58 + b"\x04"
+        self.assertEqual(padded_message, message)
+
+    def test_padding_for_empty(self):
+        message = bytearray()
         padded_message = self.pad_message(message)
-        message += b'\x80' + b'\x00' * 51
+        message += b"\x80" + b"\x00" * 63 
         self.assertEqual(padded_message, message)
 
-    def test_correct_padding_for_empty(self):
-        message = b""
+    def test_padding_for_big(self):
+        message = bytearray("a" * 534,"utf-8")
         padded_message = self.pad_message(message)
-        message = b'\x80' + b'\x00' * 55
+        message += b"\x80" + b"\x00" * 33 + b"\x00\x00\x00\x00\x00\x00\x02\x16"
+        print(len(message))
+        print(len(padded_message))
         self.assertEqual(padded_message, message)
 
-    def test_correct_padding_for_big(self):
-        message = b"a" * 534
+    def test_padding_for_length(self):
+        message = bytearray("a" * 534,"utf-8")
         padded_message = self.pad_message(message)
-        message += b'\x80' + b'\x00' * 33
-        self.assertEqual(padded_message, message)
+        self.assertEqual(len(padded_message), 576)
+
+
+
+class Test_Message_Division(unittest.TestCase):
+    def setUp(self):
+        from main import divide_message
+
+        self.divide = divide_message
+
+    def test_exception(self):
+        message = b"a" * 63
+        self.assertRaises(Exception, self.divide, message)
+
+    def test_correct_number(self):
+        message = b"a" * 64 * 5
+        messages = self.divide(message)
+        self.assertEqual(len(messages), 5)
+
+    def test_correct_lengths(self):
+        message = b"a" * 64 * 5
+        messages = self.divide(message)
+        for m in messages:
+            self.assertEquals(len(m), 64)
+
+    def test_correct_result(self):
+        message = b"a" * 64 * 64
+        messages = self.divide(message)
+        res_message = b"".join(messages)
+        self.assertEquals(res_message, message)