315 lines
11 KiB
Python
315 lines
11 KiB
Python
# To use it
|
|
#
|
|
# Key = "a949abce37b369f11237d3c7a04c5721"
|
|
# x = GKDecrypter(128,128)
|
|
# sUrl = x.decrypt(EncodedLink.group(1), Key.decode("hex"), "ECB").split('\0')[0]
|
|
#
|
|
# Key = "787I8fNAUERTrrbbT1nxg"
|
|
# x = GKDecrypter(192,128)
|
|
# sUrl = x.decrypt(EncodedLink, Key, "ECB").split('\0')[0]
|
|
#
|
|
#
|
|
|
|
import math
|
|
|
|
class GKDecrypter:
|
|
def __init__(self, param1, param2):
|
|
|
|
self.Rcon = [1,2,4,8,16,32,64,128,27,54,108,216,171,77,154,47,94,188,99,198,151,53,106,212,179,125,250,239,197,145]
|
|
self.SBox = [99,124,119,123,242,107,111,197,48,1,103,43,254,215,171,118,202,130,201,125,250,89,71,240,173,212,162,175,156,164,114,192,183,253,147,38,54,63,247,204,52,165,229,241,113,216,49,21,4,199,35,195,24,150,5,154,7,18,128,226,235,39,178,117,9,131,44,26,27,110,90,160,82,59,214,179,41,227,47,132,83,209,0,237,32,252,177,91,106,203,190,57,74,76,88,207,208,239,170,251,67,77,51,133,69,249,2,127,80,60,159,168,81,163,64,143,146,157,56,245,188,182,218,33,16,255,243,210,205,12,19,236,95,151,68,23,196,167,126,61,100,93,25,115,96,129,79,220,34,42,144,136,70,238,184,20,222,94,11,219,224,50,58,10,73,6,36,92,194,211,172,98,145,149,228,121,231,200,55,109,141,213,78,169,108,86,244,234,101,122,174,8,186,120,37,46,28,166,180,198,232,221,116,31,75,189,139,138,112,62,181,102,72,3,246,14,97,53,87,185,134,193,29,158,225,248,152,17,105,217,142,148,155,30,135,233,206,85,40,223,140,161,137,13,191,230,66,104,65,153,45,15,176,84,187,22]
|
|
self.SBoxInverse = [82,9,106,213,48,54,165,56,191,64,163,158,129,243,215,251,124,227,57,130,155,47,255,135,52,142,67,68,196,222,233,203,84,123,148,50,166,194,35,61,238,76,149,11,66,250,195,78,8,46,161,102,40,217,36,178,118,91,162,73,109,139,209,37,114,248,246,100,134,104,152,22,212,164,92,204,93,101,182,146,108,112,72,80,253,237,185,218,94,21,70,87,167,141,157,132,144,216,171,0,140,188,211,10,247,228,88,5,184,179,69,6,208,44,30,143,202,63,15,2,193,175,189,3,1,19,138,107,58,145,17,65,79,103,220,234,151,242,207,206,240,180,230,115,150,172,116,34,231,173,53,133,226,249,55,232,28,117,223,110,71,241,26,113,29,41,197,137,111,183,98,14,170,24,190,27,252,86,62,75,198,210,121,32,154,219,192,254,120,205,90,244,31,221,168,51,136,7,199,49,177,18,16,89,39,128,236,95,96,81,127,169,25,181,74,13,45,229,122,159,147,201,156,239,160,224,59,77,174,42,245,176,200,235,187,60,131,83,153,97,23,43,4,126,186,119,214,38,225,105,20,99,85,33,12,125]
|
|
self.keySize = param1
|
|
self.blockSize = param2
|
|
self.roundsArray = [0,0,0,0,[0,0,0,0,10,0,12,0,14],0,[0,0,0,0,12,0,12,0,14],0,[0,0,0,0,14,0,14,0,14]]
|
|
self.shiftOffsets = [0,0,0,0,[0,1,2,3],0,[0,1,2,3],0,[0,1,3,4]]
|
|
self.Nb = param2 / 32
|
|
self.Nk = param1 / 32
|
|
self.Nr = self.roundsArray[self.Nk][self.Nb]
|
|
|
|
|
|
def decrypt(self,param1, param2, param3):
|
|
_loc10_ = None
|
|
_loc4_ = []
|
|
_loc5_ = []
|
|
_loc6_ = self.hexToChars(param1)#==48 characters
|
|
_loc7_ = self.blockSize / 8
|
|
_lo8st = self.strToChars(param2)
|
|
_loc8_ = self.keyExpansion(_lo8st)
|
|
_loc9_ = (len(_loc6_) / _loc7_) - 1
|
|
|
|
while _loc9_ > 0:
|
|
_loc5_ = self.decryption(_loc6_[_loc9_ * _loc7_:(_loc9_ + 1) * _loc7_],_loc8_)
|
|
_loc4_ = _loc5_ + (_loc4_)
|
|
_loc9_ -= 1
|
|
_loc44 = self.decryption(_loc6_[0:int(_loc7_)],_loc8_)
|
|
_loc4_ = _loc44+_loc4_
|
|
_loc4_ = self.charsToStr(_loc4_)
|
|
|
|
return _loc4_
|
|
|
|
|
|
def MyInt(self, x):
|
|
x = 0xffffffff & x
|
|
if x > 0x7fffffff :
|
|
return - ( ~(x - 1) & 0xffffffff )
|
|
else : return x
|
|
|
|
|
|
def keyExpansion(self, param1):
|
|
_loc4_ = None
|
|
_loc2_ = 0
|
|
self.Nk = self.keySize / 32#=6, what if this was 5
|
|
self.Nb = self.blockSize / 32
|
|
_loc3_ = []
|
|
self.Nr = self.roundsArray[self.Nk][self.Nb]# ==12, what if this was 10?
|
|
_loc4_ = 0
|
|
_loc3_ = [0]*(self.Nb * (self.Nr + 1))
|
|
while _loc4_ < self.Nk:
|
|
if (_loc4_)<len(param1)/4:
|
|
_loc3_[_loc4_] = param1[4 * _loc4_] | param1[4 * _loc4_ + 1] << 8 | param1[4 * _loc4_ + 2] << 16 | param1[4 * _loc4_ + 3] << 24
|
|
_loc4_ += 1
|
|
_loc4_ = self.Nk
|
|
while _loc4_ < self.Nb * (self.Nr + 1):
|
|
_loc2_ = _loc3_[_loc4_ - 1]
|
|
if(_loc4_ % self.Nk == 0):
|
|
_loc2_ = (self.SBox[_loc2_ >> 8 & 255] | self.SBox[_loc2_ >> 16 & 255] << 8 | self.SBox[_loc2_ >> 24 & 255] << 16 | self.SBox[_loc2_ & 255] << 24) ^ self.Rcon[int(math.floor(_loc4_ / self.Nk))-1]
|
|
else:
|
|
if(self.Nk > 6 and _loc4_ % self.Nk == 4):
|
|
_loc2_ = self.SBox[_loc2_ >> 24 & 255] << 24 | self.SBox[_loc2_ >> 16 & 255] << 16 | self.SBox[_loc2_ >> 8 & 255] << 8 | self.SBox[_loc2_ & 255]
|
|
_loc3_[_loc4_] = self.MyInt(_loc3_[_loc4_ - self.Nk] ^ _loc2_)
|
|
_loc4_ += 1
|
|
|
|
return _loc3_
|
|
|
|
|
|
def hexToChars(self, param1):
|
|
_loc2_ = []
|
|
_loc3_ = 0
|
|
if param1[0:1] == '0x':
|
|
_loc3_ = 2
|
|
|
|
while _loc3_ < len(param1):
|
|
_loc2_.append(int(param1[_loc3_: _loc3_ + 2], 16))
|
|
_loc3_ = _loc3_ + 2
|
|
|
|
return _loc2_
|
|
|
|
|
|
def strToChars(self, param1):
|
|
_loc2_ = []
|
|
_loc3_ = 0
|
|
while(_loc3_ < len(param1)):
|
|
_loc2_.append(ord(param1[_loc3_]))
|
|
_loc3_+=1
|
|
|
|
return _loc2_
|
|
|
|
|
|
def charsToStr(self, param1):
|
|
_loc2_ = ''
|
|
_loc3_ = 0
|
|
while(_loc3_ < len(param1)):
|
|
_loc2_ = _loc2_ + chr(param1[_loc3_])
|
|
_loc3_ += 1
|
|
return _loc2_
|
|
|
|
|
|
def packBytes(self, param1):
|
|
_loc2_ = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
|
|
_loc3_ = 0
|
|
while(_loc3_ < len(param1)):
|
|
_loc2_[0][_loc3_ / 4] = param1[_loc3_]
|
|
_loc2_[1][_loc3_ / 4] = param1[_loc3_ + 1]
|
|
_loc2_[2][_loc3_ / 4] = param1[_loc3_ + 2]
|
|
_loc2_[3][_loc3_ / 4] = param1[_loc3_ + 3]
|
|
_loc3_ = _loc3_ + 4
|
|
return _loc2_
|
|
|
|
|
|
def unpackBytes(self, param1):
|
|
_loc2_ = []
|
|
_loc3_ = 0
|
|
while(_loc3_ < len(param1[0])):
|
|
_loc2_.append(param1[0][_loc3_])
|
|
_loc2_.append(param1[1][_loc3_])
|
|
_loc2_.append(param1[2][_loc3_])
|
|
_loc2_.append(param1[3][_loc3_])
|
|
_loc3_ += 1
|
|
return _loc2_
|
|
|
|
|
|
def InverseRound(self, param1, param2):
|
|
_loc3_ = False
|
|
_loc4_ = True
|
|
|
|
self.addRoundKey(param1,param2)
|
|
self.mixColumn(param1,'decrypt')
|
|
self.shiftRow(param1,'decrypt')
|
|
self.byteSub(param1,'decrypt')
|
|
|
|
|
|
def FinalRound(self, param1, param2):
|
|
self.byteSub(param1, 'encrypt')
|
|
self.shiftRow(param1, 'encrypt')
|
|
self.addRoundKey(param1, param2)
|
|
|
|
|
|
def InverseFinalRound(self, param1, param2):
|
|
self.addRoundKey(param1, param2)
|
|
self.shiftRow(param1, 'decrypt')
|
|
self.byteSub(param1, 'decrypt')
|
|
|
|
|
|
def addRoundKey(self, param1, param2):
|
|
_loc3_ = 0
|
|
|
|
while(_loc3_ < self.Nb):
|
|
param1[0][_loc3_] = param1[0][_loc3_] ^ param2[_loc3_] & 255
|
|
param1[1][_loc3_] = param1[1][_loc3_] ^ param2[_loc3_] >> 8 & 255
|
|
param1[2][_loc3_] = param1[2][_loc3_] ^ param2[_loc3_] >> 16 & 255
|
|
param1[3][_loc3_] = param1[3][_loc3_] ^ param2[_loc3_] >> 24 & 255
|
|
_loc3_ += 1
|
|
|
|
|
|
def shiftRow(self, param1, param2):
|
|
_loc4_ = True
|
|
_loc5_ = False
|
|
_loc3_ = 1
|
|
|
|
while(_loc3_ < 4):
|
|
if(param2 == 'encrypt'):
|
|
param1[_loc3_] = self.cyclicShiftLeft(param1[_loc3_],self.shiftOffsets[self.Nb][_loc3_])
|
|
else:
|
|
param1[_loc3_] = self.cyclicShiftLeft(param1[_loc3_],self.Nb - self.shiftOffsets[self.Nb][_loc3_])
|
|
|
|
_loc3_ += 1
|
|
|
|
|
|
def cyclicShiftLeft(self, param1, param2):
|
|
_loc3_ = param1[0: param2]
|
|
param1 = param1[param2:]
|
|
param1.extend(_loc3_)
|
|
|
|
return param1
|
|
|
|
|
|
def decryption(self, param1, param2):
|
|
param1 = self.packBytes(param1)
|
|
self.InverseFinalRound(param1,param2[self.Nb * self.Nr:])#nb*nr=42
|
|
_loc3_ = self.Nr - 1
|
|
while(_loc3_ > 0):
|
|
self.InverseRound(param1,param2[(self.Nb * _loc3_):self.Nb * (_loc3_ + 1)])
|
|
_loc3_-=1
|
|
|
|
self.addRoundKey(param1,param2)
|
|
reVal = self.unpackBytes(param1)
|
|
|
|
return reVal
|
|
|
|
|
|
def byteSub(self, param1, param2):
|
|
_loc3_ = []
|
|
_loc5_ = 0
|
|
if(param2 == 'encrypt'):
|
|
_loc3_ = self.SBox
|
|
else:
|
|
_loc3_ = self.SBoxInverse
|
|
|
|
_loc4_ = 0
|
|
|
|
while(_loc4_ < 4):
|
|
_loc5_ = 0
|
|
while(_loc5_ < self.Nb):
|
|
param1[_loc4_][_loc5_] = _loc3_[param1[_loc4_][_loc5_]]
|
|
_loc5_ += 1
|
|
_loc4_ += 1
|
|
|
|
|
|
def mixColumn(self, param1, param2):
|
|
_loc4_ = 0
|
|
_loc3_ = [0,0,0,0]
|
|
_loc5_ = 0
|
|
|
|
while(_loc5_ < self.Nb):
|
|
_loc4_ = 0
|
|
while(_loc4_ < 4):
|
|
|
|
if(param2 == "encrypt"):
|
|
_loc3_[_loc4_] = self.mult_GF256(param1[_loc4_][_loc5_],2) ^ self.mult_GF256(param1[(_loc4_ + 1) % 4][_loc5_],3) ^ param1[(_loc4_ + 2) % 4][_loc5_] ^ param1[(_loc4_ + 3) % 4][_loc5_]
|
|
else:
|
|
_loc3_[_loc4_] = self.mult_GF256(param1[_loc4_][_loc5_],14) ^ self.mult_GF256(param1[(_loc4_ + 1) % 4][_loc5_],11) ^ self.mult_GF256(param1[(_loc4_ + 2) % 4][_loc5_],13) ^ self.mult_GF256(param1[(_loc4_ + 3) % 4][_loc5_],9)
|
|
_loc4_ += 1
|
|
|
|
_loc4_ = 0
|
|
while(_loc4_ < 4):
|
|
param1[_loc4_][_loc5_] = _loc3_[_loc4_]
|
|
_loc4_ += 1
|
|
|
|
_loc5_ += 1
|
|
|
|
|
|
def xtime(self, param1):
|
|
param1 = param1 << 1
|
|
if param1 & 256:
|
|
return param1 ^ 283
|
|
else:
|
|
return param1
|
|
|
|
|
|
def mult_GF256(self, param1, param2):
|
|
_loc3_ = 0
|
|
_loc4_ = 1
|
|
|
|
while(_loc4_ < 256):
|
|
if(param1 & _loc4_):
|
|
_loc3_ = _loc3_ ^ param2
|
|
_loc4_ = _loc4_ * 2
|
|
param2 = self.xtime(param2)
|
|
|
|
return _loc3_
|
|
|
|
|
|
def hexToChars(param1):
|
|
_loc4_ = False
|
|
_loc5_ = True
|
|
_loc2_ = []
|
|
_loc3_ = 0
|
|
if param1[0:1] == '0x':
|
|
_loc3_ = 2
|
|
|
|
while _loc3_ < len(param1):
|
|
_loc2_.append(int(param1[_loc3_: _loc3_ + 1], 16))
|
|
_loc3_ = _loc3_ + 2
|
|
|
|
return "".join(_loc2_)
|
|
|
|
|
|
def arrNametoString(param1):
|
|
_loc4_ = True
|
|
_loc5_ = False
|
|
_loc2_ = ""
|
|
param1.reverse()
|
|
_loc3_ = 0
|
|
while(_loc3_ < len(param1)):
|
|
_loc2_ = _loc2_ + chr(param1[_loc3_])
|
|
_loc3_ += 1
|
|
|
|
return _loc2_
|
|
|
|
|
|
def decryptKey(param1):
|
|
_local_2 = gledajfilmDecrypter(198, 128)
|
|
_local_3 = [17536, 16512, 16524, 17420, 17544, 3144, 3204, 17416, 19532, 3080, 16456, 16460, 18572, 16396, 19468, 17408, 19464, 16524, 18508, 17420]
|
|
_local_4 = bytearray()
|
|
_local_5 = 0
|
|
_local_6 = 0
|
|
|
|
while _local_5 < len(_local_3):
|
|
_local_6 = _local_3[_local_5]
|
|
_local_6 = _local_6 >> 12
|
|
_local_4.extend(bytes(_local_6))
|
|
_local_5 += 1
|
|
reVal = _local_2.decrypt(param1, str(_local_4), "ECB").split('\0')[0]
|
|
|
|
return reVal
|