grillon
/
astrXbian
forked from axiom-team/astrXbian
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
astrXbian/.install/.kodi/addons/plugin.video.vstream/resources/lib/GKDecrypter.py

315 lines
11 KiB
Python
Raw Blame History

# 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
Reference in New Issue View Git Blame Copy Permalink