pierrickdelrieu / erode-backend Goto Github PK

if y == 0:
    return 1
elif y == 1:
    return x % modulo
else:
    root = pow_mod(x, y // 2, modulo)
    if y % 2 == 0:
        return (root * root) % modulo
    else:
        return (root * root * x) % modulo

numberInBase = []
quotient = 1
while(quotient != 0):
    numberInBase.append(number % base)
    quotient = number // base
    number = quotient

# we invert the number of the the list to have the right order
return numberInBase[::-1]

numberInBase = []
quotient = 1
while(quotient != 0):
    numberInBase.append(number % 16)
    if((number % 16) == 10):
        numberInBase.append(0)
    quotient = number // 16
    number = quotient

# we invert the number of the the list to have the right order
return numberInBase[::-1]

result = 0
power = len(number)-1
for x in number:
    result += (x*(base**power))
    power -= 1

return result

new_binary = []
for i in binary:
    if(i == 0):
        new_binary.append(1)
    else:
        new_binary.append(0)

return new_binary

x = [int(a) for a in str(tag_code)]

fatalis = (x[1]*x[3]+x[0]-x[2])%6
if(fatalis == 0):
    fatalis = 4

newmessage = ""
for i in message:
    if(ord(i) in Tab):
        newmessage += chr(Tab[(Tab.index(ord(i))+(fatalis*2))%len(Tab)])
    else:
        newmessage += i
        
return newmessage

x = [int(a) for a in str(tag_code)]
stark = (x[1]*x[3]+x[0]-x[2])%6
if(stark == 0):
    stark = 4

newmessage = ""
for i in message:
    if(ord(i) in Tab):
        newmessage += chr(Tab[(Tab.index(ord(i))+(stark*2))%len(Tab)])
    else:
        newmessage += i

return newmessage

x = [int(a) for a in str(tag_code)]

babylonia = (x[0]*x[3]+x[2]-x[1])%20
if(babylonia == 0):
    babylonia = 13

newmessage = ""
for i in message:
    if(ord(i) in Tab):
        newmessage += chr(Tab[(Tab.index(ord(i))+(babylonia*2))%len(Tab)])
    else:
        newmessage += i

return newmessage

x = [int(a) for a in str(tag_code)]

Lutece = (x[0]*x[3]+x[2]-x[1])%20
if(Lutece == 0):
    Lutece = 13

newmessage = ""
for i in message:
    if(ord(i) in Tab):
        newmessage += chr(Tab[(Tab.index(ord(i))-(Lutece*2))%len(Tab)])
    else:
        newmessage += i

return newmessage

return True

flag = 0
hexa_array = []  # we will get an array of array

message = Babylonia(message, tag_code)
message = project_Fatalis(message, tag_code)

for i in message:
    hexa_array.append(convert_number_from_base10_to_base16(ord(i)))
#print(hexa_array)
# fusion of the array
newArray = []
for i in range(len(hexa_array)):
    for j in range(len(hexa_array[i])):
        newArray.append(hexa_array[i][j])
#print(newArray)

# completion to a certain size
while(len(newArray) < 10):
    newArray.append(0)
# print(newArray)

group10 = convert_number_from_baseX_to_base10(newArray, tag_code)
# print(group10)

group10Binaire = convert_number_from_base10_to_baseX(group10, 2)
# print(group10Binaire)

group10BinaireComp = one_complement(group10Binaire)
# print(group10BinaireComp)
# if first element is 0 we need to mark it
i = 0
while(group10BinaireComp[i] == 0 and i < len(group10BinaireComp)):
    flag += 1
    i += 1

conversionEnChiffre = convert_number_from_baseX_to_base10(
    group10BinaireComp, 2)
# print(conversionEnChiffre)

return conversionEnChiffre, flag

"""

# we're gonna encrypt multiple blocks
allblocks = []
substring = ""
counter = 0
for i in range(len(full_message)):
    if(counter == 5):
        allblocks.append(substring)
        substring = full_message[i]
        counter = 1
    else:
        counter = counter+1
        substring += full_message[i]

allblocks.append(substring)

#print(allblocks)
# we have blocks of 5 char or less

StoreCipheredNumbers = []
FlagNumbers = []

for i in allblocks:
    result = encryption_junior(i, tag_code)
    StoreCipheredNumbers.append(result[0])
    FlagNumbers.append(result[1])

# print(StoreCipheredNumbers)
Storage = StoreCipheredNumbers, FlagNumbers
message = ""
for i in range(len(Storage[0])):
    if(i==(len(Storage[0])-1)):
        message += str(Storage[0][i])+"!"+str(Storage[1][i])
    else:
        message += str(Storage[0][i])+"!"+str(Storage[1][i])+"!"

return message

"""

# first goes from base 10 to binary
binary = convert_number_from_base10_to_baseX(ciphered, 2)
# print(binary)

# then one complement
if(flag != 0):
    for i in range(flag):
        binary.insert(0, 0)

binaryComp = one_complement(binary)
# print(binaryComp)

# goes back to base 10
base10 = convert_number_from_baseX_to_base10(binaryComp, 2)
# print(base10)

# convert back to base tag_code
FusedArray = convert_number_from_base10_to_baseX(base10, tag_code)
# print(FusedArray)

#we compare last digits if a group of 2 are both = 0 we delete this

newtable = []

#print(FusedArray)
for i in range(0, len(FusedArray), 2):
    if (FusedArray[i] == 0) and (FusedArray[i+1] == 0):
        a = 1
    else:
        newtable.append(FusedArray[i])
        newtable.append(FusedArray[i+1])

#print(newtable)

# then we split in groups of 2 numbers to then convert back in hexa to ascii
str = ""
for i in range(0, len(newtable), 2):
    str += chr(convert_number_from_baseX_to_base10(
        [newtable[i], newtable[i+1]], 16))

str = Lutèce(str, tag_code)
str = project_Stark(str, tag_code)
# print(str)
return str

"""

Storage = AllCipheredBlocks.split("!")
blocks = []
Flags = []
for i in range(len(Storage)):
    if(i%2==0):
        blocks.append(int(Storage[i]))
    else:
        Flags.append(int(Storage[i]))


Ragnarock = ""

for i in range(len(blocks)):
    Ragnarock += decipher_junior(blocks[i], tag_code, Flags[i])

return Ragnarock

message = str(sys.argv[1])
#open text file in read mode
#text_file = open("key.txt", "r")

#read whole file to a string
#data = text_file.read()

#close file
#text_file.close()

#print(data)
#message = data
tag_code = int(sys.argv[2])
#tag_code = 9999

if(possibility_of_encryption(message)):

    Storage = encryption_senior(message,tag_code)
    print(Storage)
else:
    print("Il y a un problème")