<s> import re <EOL> import urllib <EOL> import base64 <EOL> import unpackstd <EOL> import unpack95High <EOL> from string import join <EOL> import traceback , sys <EOL> class JsFunctions : <EOL> def hp_d01 ( self , s ) : <EOL> ar = [ ] <EOL> os = "<STR_LIT>" <EOL> for i in range ( <NUM_LIT:0> , len ( s ) - <NUM_LIT:1> ) : <EOL> c = ord ( s [ i ] ) <EOL> if c < <NUM_LIT> : <EOL> c = c ^ <NUM_LIT:2> <EOL> os += chr ( c ) <EOL> if len ( os ) > <NUM_LIT> : <EOL> ar . append ( os ) <EOL> os = "<STR_LIT>" <EOL> o = join ( ar , '<STR_LIT>' ) + os <EOL> return o <EOL> def o61a2a8f ( self , s ) : <EOL> r = "<STR_LIT>" ; <EOL> tmp = s . split ( "<STR_LIT>" ) ; <EOL> s = urllib . unquote ( tmp [ <NUM_LIT:0> ] ) ; <EOL> k = urllib . unquote ( tmp [ <NUM_LIT:1> ] + "<STR_LIT>" ) ; <EOL> for i in range ( <NUM_LIT:0> , len ( s ) - <NUM_LIT:1> ) : <EOL> r += chr ( ( int ( k [ i % len ( k ) ] ) ^ ord ( s [ i ] ) ) + <NUM_LIT:1> ) ; <EOL> return r ; <EOL> def n98c4d2c ( self , s ) : <EOL> txtArr = s . split ( '<STR_LIT>' ) <EOL> s = urllib . unquote ( txtArr [ <NUM_LIT:0> ] ) <EOL> t = urllib . unquote ( txtArr [ <NUM_LIT:1> ] + '<STR_LIT>' ) <EOL> tmp = '<STR_LIT>' <EOL> for i in range ( <NUM_LIT:0> , len ( s ) - <NUM_LIT:1> ) : <EOL> tmp += chr ( ( int ( t [ i % len ( t ) ] ) ^ ord ( s [ i ] ) ) + - <NUM_LIT:6> ) <EOL> return urllib . unquote ( tmp ) <EOL> def RrRrRrRr ( self , teaabb ) : <EOL> tttmmm = "<STR_LIT>" <EOL> l = len ( teaabb ) <EOL> www = hhhhffff = int ( round ( l / <NUM_LIT:2> ) ) <EOL> if l < <NUM_LIT:2> * www : <EOL> hhhhffff -= <NUM_LIT:1> <EOL> for i in range ( <NUM_LIT:0> , hhhhffff - <NUM_LIT:1> ) : <EOL> tttmmm = tttmmm + teaabb [ i ] + teaabb [ i + hhhhffff ] <EOL> if l < <NUM_LIT:2> * www : <EOL> tttmmm = tttmmm + teaabb [ l - <NUM_LIT:1> ] <EOL> return tttmmm <EOL> def ew_dc ( self , s ) : <EOL> d = '<STR_LIT>' <EOL> a = [ ] <EOL> for i in range ( <NUM_LIT:0> , len ( s ) - <NUM_LIT:1> ) : <EOL> c = ord ( s [ i ] ) <EOL> if ( c < <NUM_LIT> ) : <EOL> c = c ^ <NUM_LIT:5> <EOL> d += chr ( c ) <EOL> if ( i + <NUM_LIT:1> ) % <NUM_LIT> == <NUM_LIT:0> : <EOL> a . append ( d ) <EOL> d = '<STR_LIT>' <EOL> r = join ( a , '<STR_LIT>' ) + d <EOL> return r <EOL> def pbbfa0 ( self , s ) : <EOL> r = "<STR_LIT>" <EOL> tmp = s . split ( "<STR_LIT>" ) <EOL> s = urllib . unquote ( tmp [ <NUM_LIT:0> ] ) <EOL> k = urllib . unquote ( tmp [ <NUM_LIT:1> ] + "<STR_LIT>" ) <EOL> for i in range ( <NUM_LIT:0> , len ( s ) ) : <EOL> r += chr ( ( int ( k [ i % len ( k ) ] ) ^ ord ( s [ i ] ) ) + <NUM_LIT:7> ) <EOL> return r <EOL> class JsUnpacker : <EOL> def unpackAll ( self , data ) : <EOL> try : <EOL> in_data = data <EOL> sPattern = '<STR_LIT>' <EOL> enc_data = re . compile ( sPattern ) . findall ( in_data ) <EOL> if len ( enc_data ) == <NUM_LIT:0> : <EOL> sPattern = '<STR_LIT>' <EOL> enc_data = re . compile ( sPattern ) . findall ( in_data ) <EOL> for enc_val in enc_data : <EOL> unpack_val = unpackstd . unpack ( enc_val ) <EOL> in_data = in_data . replace ( enc_val , unpack_val ) <EOL> in_data = in_data . replace ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> return in_data <EOL> except : <EOL> traceback . print_exc ( file = sys . stdout ) <EOL> return data . replace ( enc_val , '<STR_LIT>' ) <EOL> def containsPacked ( self , data ) : <EOL> return '<STR_LIT>' in data or '<STR_LIT>' in data <EOL> class JsUnpackerV2 : <EOL> def unpackAll ( self , data ) : <EOL> try : <EOL> in_data = data <EOL> sPattern = '<STR_LIT>' <EOL> enc_data = re . compile ( sPattern ) . findall ( in_data ) <EOL> if len ( enc_data ) == <NUM_LIT:0> : <EOL> sPattern = '<STR_LIT>' <EOL> enc_data = re . compile ( sPattern ) . findall ( in_data ) <EOL> for enc_val in enc_data : <EOL> unpack_val = self . unpack ( enc_val ) <EOL> in_data = in_data . replace ( enc_val , unpack_val ) <EOL> return in_data <EOL> except : <EOL> traceback . print_exc ( file = sys . stdout ) <EOL> return data <EOL> def containsPacked ( self , data ) : <EOL> return '<STR_LIT>' in data <EOL> def unpack ( self , sJavascript , iteration = <NUM_LIT:1> , totaliterations = <NUM_LIT:1> ) : <EOL> aSplit = sJavascript . split ( "<STR_LIT>" ) <EOL> p1 , a1 , c1 , k1 = ( '<STR_LIT>' , '<STR_LIT:0>' , '<STR_LIT:0>' , '<STR_LIT>' ) <EOL> ss = "<STR_LIT>" + aSplit [ <NUM_LIT:1> ] . split ( "<STR_LIT>" ) [ <NUM_LIT:0> ] + '<STR_LIT:)>' <EOL> exec ( ss ) <EOL> k1 = k1 . split ( '<STR_LIT:|>' ) <EOL> aSplit = aSplit [ <NUM_LIT:1> ] . split ( "<STR_LIT>" ) <EOL> e = '<STR_LIT>' <EOL> d = '<STR_LIT>' <EOL> sUnpacked1 = str ( self . __unpack ( p1 , a1 , c1 , k1 , e , d , iteration ) ) <EOL> if iteration >= totaliterations : <EOL> return sUnpacked1 <EOL> else : <EOL> return self . unpack ( sUnpacked1 , iteration + <NUM_LIT:1> ) <EOL> def __unpack ( self , p , a , c , k , e , d , iteration , v = <NUM_LIT:1> ) : <EOL> while ( c >= <NUM_LIT:1> ) : <EOL> c = c - <NUM_LIT:1> <EOL> if ( k [ c ] ) : <EOL> aa = str ( self . __itoaNew ( c , a ) ) <EOL> p = re . sub ( '<STR_LIT>' + aa + '<STR_LIT>' , k [ c ] , p ) <EOL> return p <EOL> def __itoa ( self , num , radix ) : <EOL> result = "<STR_LIT>" <EOL> if num == <NUM_LIT:0> : return '<STR_LIT:0>' <EOL> while num > <NUM_LIT:0> : <EOL> result = "<STR_LIT>" [ num % radix ] + result <EOL> num /= radix <EOL> return result <EOL> def __itoaNew ( self , cc , a ) : <EOL> aa = "<STR_LIT>" if cc < a else self . __itoaNew ( int ( cc / a ) , a ) <EOL> cc = ( cc % a ) <EOL> bb = chr ( cc + <NUM_LIT> ) if cc > <NUM_LIT> else str ( self . __itoa ( cc , <NUM_LIT> ) ) <EOL> return aa + bb <EOL> class JsUnpacker95High : <EOL> def unpackAll ( self , data ) : <EOL> try : <EOL> in_data = data <EOL> sPattern = '<STR_LIT>' <EOL> enc_data = re . compile ( sPattern ) . findall ( in_data ) <EOL> if len ( enc_data ) == <NUM_LIT:0> : <EOL> sPattern = '<STR_LIT>' <EOL> enc_data = re . compile ( sPattern ) . findall ( in_data ) <EOL> for enc_val in enc_data : <EOL> unpack_val = unpack95High . unpack ( enc_val ) <EOL> in_data = in_data . replace ( enc_val , unpack_val ) <EOL> in_data = in_data . replace ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> return in_data <EOL> except : <EOL> traceback . print_exc ( file = sys . stdout ) <EOL> return data . replace ( enc_val , '<STR_LIT>' ) <EOL> def containsPacked ( self , data ) : <EOL> return r'<STR_LIT>' in data <EOL> class JsUnIonCube : <EOL> def ionX ( self , x , arrayX ) : <EOL> r = [ ] <EOL> s = <NUM_LIT:0> <EOL> w = <NUM_LIT:0> <EOL> for d in x : <EOL> w |= int ( arrayX [ ord ( d ) - <NUM_LIT> ] ) << s <EOL> if ( s ) : <EOL> r . append ( chr ( <NUM_LIT> ^ w & <NUM_LIT:255> ) ) <EOL> w >>= <NUM_LIT:8> <EOL> s -= <NUM_LIT:2> <EOL> else : <EOL> s = <NUM_LIT:6> <EOL> r = '<STR_LIT>' . join ( r ) <EOL> return r <EOL> def unIonALL ( self , data ) : <EOL> in_data = data <EOL> sPattern = '<STR_LIT>' <EOL> undc_data = re . compile ( sPattern ) . findall ( in_data ) <EOL> c = undc_data [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] <EOL> x = undc_data [ <NUM_LIT:0> ] [ <NUM_LIT:1> ] <EOL> l = list ( c ) <EOL> for i in range ( <NUM_LIT:0> , len ( c ) , <NUM_LIT:3> ) : <EOL> l [ i ] = '<STR_LIT:%>' <EOL> c = '<STR_LIT>' . join ( l ) <EOL> c = urllib . unquote_plus ( c ) <EOL> arrayPattern = '<STR_LIT>' <EOL> arrayData = re . compile ( arrayPattern ) . findall ( c ) <EOL> ionArray = arrayData [ <NUM_LIT:0> ] . split ( '<STR_LIT:U+002C>' ) <EOL> data = self . ionX ( x , ionArray ) <EOL> return data <EOL> def containsIon ( self , data ) : <EOL> return '<STR_LIT>' in data <EOL> class JsUnwiser : <EOL> def unwiseAll ( self , data ) : <EOL> try : <EOL> in_data = data <EOL> sPattern = '<STR_LIT>' <EOL> wise_data = re . compile ( sPattern ) . findall ( in_data ) <EOL> for wise_val in wise_data : <EOL> unpack_val = self . unwise ( wise_val ) <EOL> in_data = in_data . replace ( wise_val , unpack_val ) <EOL> return re . sub ( "<STR_LIT>" , "<STR_LIT>" , in_data , count = <NUM_LIT:1> , flags = re . DOTALL ) <EOL> except : <EOL> traceback . print_exc ( file = sys . stdout ) <EOL> return data <EOL> def containsWise ( self , data ) : <EOL> return '<STR_LIT>' in data <EOL> def unwise ( self , sJavascript ) : <EOL> page_value = "<STR_LIT>" <EOL> try : <EOL> ss = "<STR_LIT>" + sJavascript + '<STR_LIT:)>' <EOL> exec ( ss ) <EOL> page_value = self . __unpack ( w , i , s , e ) <EOL> except : traceback . print_exc ( file = sys . stdout ) <EOL> return page_value <EOL> def __unpack ( self , w , i , s , e ) : <EOL> lIll = <NUM_LIT:0> ; <EOL> ll1I = <NUM_LIT:0> ; <EOL> Il1l = <NUM_LIT:0> ; <EOL> ll1l = [ ] ; <EOL> l1lI = [ ] ; <EOL> while True : <EOL> if ( lIll < <NUM_LIT:5> ) : <EOL> l1lI . append ( w [ lIll ] ) <EOL> elif ( lIll < len ( w ) ) : <EOL> ll1l . append ( w [ lIll ] ) ; <EOL> lIll += <NUM_LIT:1> ; <EOL> if ( ll1I < <NUM_LIT:5> ) : <EOL> l1lI . append ( i [ ll1I ] ) <EOL> elif ( ll1I < len ( i ) ) : <EOL> ll1l . append ( i [ ll1I ] ) <EOL> ll1I += <NUM_LIT:1> ; <EOL> if ( Il1l < <NUM_LIT:5> ) : <EOL> l1lI . append ( s [ Il1l ] ) <EOL> elif ( Il1l < len ( s ) ) : <EOL> ll1l . append ( s [ Il1l ] ) ; <EOL> Il1l += <NUM_LIT:1> ; <EOL> if ( len ( w ) + len ( i ) + len ( s ) + len ( e ) == len ( ll1l ) + len ( l1lI ) + len ( e ) ) : <EOL> break ; <EOL> lI1l = '<STR_LIT>' . join ( ll1l ) <EOL> I1lI = '<STR_LIT>' . join ( l1lI ) <EOL> ll1I = <NUM_LIT:0> ; <EOL> l1ll = [ ] ; <EOL> for lIll in range ( <NUM_LIT:0> , len ( ll1l ) , <NUM_LIT:2> ) : <EOL> ll11 = - <NUM_LIT:1> ; <EOL> if ( ord ( I1lI [ ll1I ] ) % <NUM_LIT:2> ) : <EOL> ll11 = <NUM_LIT:1> ; <EOL> l1ll . append ( chr ( int ( lI1l [ lIll : lIll + <NUM_LIT:2> ] , <NUM_LIT> ) - ll11 ) ) ; <EOL> ll1I += <NUM_LIT:1> ; <EOL> if ( ll1I >= len ( l1lI ) ) : <EOL> ll1I = <NUM_LIT:0> ; <EOL> ret = '<STR_LIT>' . join ( l1ll ) <EOL> if '<STR_LIT>' in ret : <EOL> ret = re . compile ( '<STR_LIT>' ) . findall ( ret ) [ <NUM_LIT:0> ] <EOL> return self . unwise ( ret ) <EOL> else : <EOL> return ret <EOL> class JsUnFunc : <EOL> def unFuncALL ( self , data ) : <EOL> in_data = data <EOL> dec_data = '<STR_LIT>' <EOL> sPattern = r"<STR_LIT>" <EOL> kPattern = r"<STR_LIT>" <EOL> dataPattern = r"<STR_LIT>" <EOL> modPattern = r"<STR_LIT>" <EOL> s_data = re . compile ( sPattern ) . findall ( in_data ) <EOL> k_data = re . compile ( kPattern ) . findall ( in_data ) <EOL> undc_data = re . compile ( dataPattern ) . findall ( in_data ) <EOL> mod_data = re . compile ( modPattern ) . findall ( in_data ) <EOL> sDelimiter = s_data [ <NUM_LIT:0> ] <EOL> s = undc_data [ <NUM_LIT:0> ] <EOL> tmp = urllib . unquote ( s ) . split ( sDelimiter ) <EOL> k = tmp [ <NUM_LIT:1> ] + k_data [ <NUM_LIT:0> ] <EOL> mod = int ( mod_data [ <NUM_LIT:0> ] ) <EOL> encData = tmp [ <NUM_LIT:0> ] <EOL> for i , d in enumerate ( encData ) : <EOL> dec_data += chr ( ( int ( k [ i % len ( k ) ] ) ^ ord ( d ) ) + mod ) <EOL> data = re . sub ( "<STR_LIT>" , dec_data , in_data , count = <NUM_LIT:1> , flags = re . DOTALL ) <EOL> return data <EOL> def cointainUnFunc ( self , data ) : <EOL> return '<STR_LIT>' in data <EOL> class JsUnPP : <EOL> def UnPPAll ( self , data ) : <EOL> def removeNonAscii ( s ) : return "<STR_LIT>" . join ( i for i in s if ord ( i ) < <NUM_LIT> ) <EOL> in_data = data <EOL> tPattern = r"<STR_LIT>" <EOL> t_data = re . compile ( tPattern ) . findall ( in_data ) <EOL> for i in t_data : <EOL> out_data = removeNonAscii ( str ( base64 . b16decode ( i . upper ( ) ) ) ) <EOL> data = re . sub ( r"<STR_LIT>" , out_data , data , count = <NUM_LIT:1> ) <EOL> return data <EOL> def containUnPP ( self , data ) : <EOL> return '<STR_LIT>' in data <EOL> class JsUnPush : <EOL> def UnPush ( self , data ) : <EOL> in_data = data <EOL> varPattern = '<STR_LIT>' <EOL> var_data = re . compile ( varPattern ) . findall ( in_data ) <EOL> charPattern = '<STR_LIT>' <EOL> chars = re . compile ( charPattern ) . findall ( var_data [ <NUM_LIT:0> ] ) <EOL> res = urllib . unquote ( '<STR_LIT>' . join ( chars ) ) <EOL> out_data = in_data . replace ( var_data [ <NUM_LIT:0> ] , res ) <EOL> return out_data <EOL> def containUnPush ( self , data ) : <EOL> return '<STR_LIT>' in data </s>
