Anti Http Spy

 ().Loaded   
().Loaded = 

 HttpService = :()

 detected = 

 ts = :()

 (msg)
    (..msg)


 deb = 

 ()
      deb  deb =    
    (:(()))()


 realHookFunction = ()
 realHookMetamethod = ()

 originals = {}
 HTTP_METHODS = {
    HttpGet = ,
    HttpPost = ,
    GetAsync = ,
    PostAsync = ,
    RequestAsync = ,
}

 (fn,visited,depth)
     found = {}
     depth >    fn  (fn) ~=    found 
     visited[fn]   found 
    visited[fn] = 

      (v)
         (v) ==  
            found[v] = 
             f  ((v,visited,depth + )) 
                found[f] = 
            
         (v) ==   depth <  
             i,tv  (v) 
                 (tv) ==  
                    found[tv] = 
                     f  ((tv,visited,depth + )) 
                        found[f] = 
                    
                
            
        
    

    (()
         ups = (fn)
         ups   i,v  (ups)  (v)  
    )

    (()
         i = , 
             a,b = (fn,i)
             a ==   b ==    
            (a)
             b ~=   (b) 
        
    )

    (()
         i = , 
             name,val = debug.(fn,i)
              name   
            (val)
        
    )

     found


 (fn,name)
      fn   , 

     hooked = 

     (fn) 
        hooked = 
        (..name)
    

     restored
    (() restored = (fn) )
     restored  (restored) ==   (restored) 
         hooked  (..name..) 
        (() (fn,restored) )
         restored,hooked
    

     dummy = (() )
     prev
    (() prev = (fn,dummy) )

      prev 
        (() (fn,fn) )
         fb
        (() fb = (fn) )
         fb,hooked
    

     (prev) 
        hooked = 
        (..name..)

         allFns = (prev,{},)
         f  (allFns) 
             (f) 
                (..name..)
                (fn,f)
                 f,
            
        

         cl
        (() cl = (prev) )
         cl  (cl) 
            (fn,cl)
             cl,
        

        (fn,prev)
         fb
        (() fb = (fn) )
         fb  prev,
    

    (fn,prev)
     prev,hooked


 anyHooked = 

 instanceMethods = {
    {.HttpGet,,},
    {.HttpPost,,},
    {HttpService.GetAsync,,},
    {HttpService.PostAsync,,},
    {HttpService.RequestAsync,,},
}

 i,m  (instanceMethods) 
     orig,hooked = (m[],m[])
    originals[m[]] = orig
     hooked  anyHooked =  


 globalFns = {
    {,,},
    {,,},
    {  .request,,},
    {  .request,,},
}

 i,g  (globalFns) 
     g[] 
         orig,hooked = (g[],g[])
        originals[g[]] = orig
         hooked  anyHooked =  
    


(()  originals.request    ().request = originals.request  )
(()  originals.http_request    ().http_request = originals.http_request  )
(()  originals.http_dot_request    .request = originals.http_dot_request  )
(()  originals.syn_request    .request = originals.syn_request  )

 rawMt
(() rawMt = () )

 originalNc

 ncDummy = ((self,...)   )
 prevNc
(() prevNc = (,,ncDummy) )

 prevNc 
     (prevNc) 
        anyHooked = 
        ()

         allFns = (prevNc,{},)
         f  (allFns) 
             (f) 
                originalNc = f
                ()
                
            
        

          originalNc 
            (() originalNc = (prevNc) )
              originalNc  originalNc = prevNc 
        
    
        originalNc = prevNc
    

    (() originalNc = rawMt.__namecall )


 anyHooked 
    detected = 
    ()
    ()



 ()
	(()
		 i,obj  (()) 
			 (obj) ==  
				(()
					 first = (obj,)
					 (first) ==  
						 url = (first,)  (first,)
						 method = (first,)  (first,)
						 (url) ==   (method) ==  
							 i = #obj,,-  (obj,i,) 
						
					
				)
			
		
	)


()

.(()
	 .() 
		()
	
)

 ncHandler = ((self,...)
     method = ()
     HTTP_METHODS[method]  originals[method] 
         originals[method](self,...)
    
     originalNc 
         (self,...)
    
)

(() (,,ncHandler) )

(()
     mt = ()
    (mt,)
    mt.__namecall = ncHandler
    (mt,)
)

 ()
    ()

    (()  originals.HttpGet  (.HttpGet,originals.HttpGet)  )
    (()  originals.HttpPost  (.HttpPost,originals.HttpPost)  )
    (()  originals.GetAsync  (HttpService.GetAsync,originals.GetAsync)  )
    (()  originals.PostAsync  (HttpService.PostAsync,originals.PostAsync)  )
    (()  originals.RequestAsync  (HttpService.RequestAsync,originals.RequestAsync)  )

    (()  originals.request    (,originals.request)  )
    (()  originals.http_request    (,originals.http_request)  )
    (()  originals.http_dot_request    .request  (.request,originals.http_dot_request)  )
    (()  originals.syn_request    .request  (.request,originals.syn_request)  )

    ()



 (fn)
      fn  (fn) ~=     
     fn == .HttpGet  fn == .HttpPost    
     fn == HttpService.GetAsync  fn == HttpService.PostAsync  fn == HttpService.RequestAsync    
       fn ==     
       fn ==     
       .request  fn == .request    
       .request  fn == .request    
     


(,((target,hook)
     (target) 
        ()
        detected = 
        ()
         target
    
     (target,hook)
))

(,((obj,method,hook)
     obj ==   method ==   (hook) ==  
         actualHook = hook
         (obj,method,((self,...)
             m = ()
             HTTP_METHODS[m]  originals[m] 
                 originals[m](self,...)
            
             (self,...)
        ))
    
     (obj,method,hook)
))


 safeRequestFn = originals.request  originals.http_request  originals.syn_request  originals.http_dot_request

 (url,body,headers)
      safeRequestFn 
        ()
         ,
    
    headers = headers  {[] = }
     ok,response = (safeRequestFn,{
        Url = url,
        Method = ,
        Headers = headers,
        Body = body,
    })
     ok  response   response.Body,response.StatusCode 
    (..(response))
     ,


 (url,headers)
      safeRequestFn   , 
    headers = headers  {}
     ok,response = (safeRequestFn,{
        Url = url,
        Method = ,
        Headers = headers,
    })
     ok  response   response.Body,response.StatusCode 
     ,


().safePost = safePost
().safeGet = safeGet

().()

()