forked from kalmar/DALGLI0
140 lines
4.0 KiB
Python
140 lines
4.0 KiB
Python
import sys
|
|
import ast
|
|
import time
|
|
from itertools import zip_longest
|
|
|
|
class Polynomial:
|
|
|
|
def __init__(self, coef_list):
|
|
self.degree = len(coef_list) - 1
|
|
self.coefficients = coef_list
|
|
|
|
@staticmethod
|
|
def add(p1, p2):
|
|
result = []
|
|
f = p1.coefficients
|
|
g = p2.coefficients
|
|
if len(f) >= len(g):
|
|
result = f
|
|
for i in range(0, len(g)):
|
|
result[i] = f[i] + g[i]
|
|
else:
|
|
result = g
|
|
for i in range(0, len(f)):
|
|
result[i] = f[i] + g[i]
|
|
result = [x % int(n) for x in result]
|
|
return Polynomial(result)
|
|
|
|
@staticmethod
|
|
def multiply(p1, p2):
|
|
result = [0] * (p1.degree + p2.degree + 1)
|
|
f = p1.coefficients
|
|
g = p2.coefficients
|
|
for i in range(0, len(f)):
|
|
for j in range(0, len(g)):
|
|
result[i+j] += f[i] * g[j]
|
|
result = [x % int(n) for x in result]
|
|
return Polynomial(result)
|
|
|
|
@staticmethod
|
|
def divide(p1, p2):
|
|
def inverse(x):
|
|
for i in range(1, int(n)):
|
|
r = (i * x) % int(n)
|
|
if r == 1:
|
|
break
|
|
else:
|
|
raise ZeroDivisionError
|
|
return i
|
|
if p1.degree < p2.degree:
|
|
return p1
|
|
f = p1.coefficients
|
|
g = p2.coefficients
|
|
g_lead_coef = g[-1]
|
|
g_deg = p2.degree
|
|
while len(f) >= len(g):
|
|
f_lead_coef = f[-1]
|
|
tmp_coef = f_lead_coef * inverse(g_lead_coef)
|
|
tmp_exp = len(f) - 1 - g_deg
|
|
tmp = []
|
|
for _ in range(tmp_exp):
|
|
tmp.append(0)
|
|
tmp.append(tmp_coef)
|
|
tmp_poly = Polynomial(tmp)
|
|
sub = Polynomial.multiply(p2, tmp_poly)
|
|
f = [x - y for x, y in zip(f, sub.coefficients)]
|
|
f = [x % int(n) for x in f]
|
|
while f and f[-1] == 0:
|
|
f.pop()
|
|
return Polynomial(f)
|
|
|
|
|
|
n = 2
|
|
|
|
|
|
def normalize_byte(data):
|
|
while len(data) != 8:
|
|
if len(data) < 8:
|
|
data = str(0) + data
|
|
else:
|
|
data.replace(data[0], '')
|
|
return data
|
|
|
|
|
|
def encode(in_data):
|
|
data = in_data
|
|
data = list(data)
|
|
data_binary = [bin(ord(char)).replace('b', '') for char in data]
|
|
data_binary = [normalize_byte(byte) for byte in data_binary]
|
|
data_binary = [int(bit) for bit in list(''.join(data_binary))]
|
|
data_binary.reverse()
|
|
|
|
M = [0] * 16 + data_binary
|
|
L = [0] * (len(data_binary)) + [1] * 16
|
|
G = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1]
|
|
FCS_poly = Polynomial.divide(Polynomial.add(Polynomial(M), Polynomial(L)), Polynomial(G))
|
|
FCS = FCS_poly.coefficients + [0] * (16 - len(FCS_poly.coefficients))
|
|
|
|
FCS.reverse()
|
|
data_binary.reverse()
|
|
data_binary = data_binary + FCS
|
|
data_binary = [data_binary[i:i+8] for i in range(0, len(data_binary), 8)]
|
|
data = [chr(int(''.join(map(str, byte)), 2)) for byte in data_binary]
|
|
|
|
return ''.join(data)
|
|
|
|
|
|
def check_fcs(in_data):
|
|
data = in_data
|
|
data = list(data)
|
|
data_binary = [bin(ord(char)).replace('b', '') for char in data]
|
|
data_binary = [normalize_byte(byte) for byte in data_binary]
|
|
data_binary = [int(bit) for bit in list(''.join(data_binary))]
|
|
data_binary.reverse()
|
|
|
|
C = [0] * 16 + data_binary
|
|
L = [0] * len(data_binary) + [1] * 16
|
|
G = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1]
|
|
S = Polynomial.divide(Polynomial.add(Polynomial(C), Polynomial(L)), Polynomial(G))
|
|
|
|
if S.coefficients == []:
|
|
return True
|
|
|
|
return False
|
|
|
|
|
|
def main():
|
|
try:
|
|
if sys.argv[1] == '-e' or sys.argv[1] == '-encode':
|
|
print(encode(sys.argv[2]))
|
|
elif sys.argv[1] == '-c' or sys.argv[1] == '-check':
|
|
print(check_fcs(sys.argv[2]))
|
|
else:
|
|
raise IndexError
|
|
except IndexError:
|
|
print("To encode: python3 CRC16.py -e [argument]\nTo check FCS: python3 CRC16.py -c [argument]")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|