function AVG(param) {
//Checking if AVG was already created -the constructor should only run once per window:
if (window.AVGRUN)
return null;
else
window.AVGRUN= true;
var IE_browser_version = parseFloat(navigator.appVersion.split("MSIE")[1]);
//Create XMLHttpRequest object once, this significantly improves the performance
try
{
if( IE_browser_version <= 6 )
var httpRequest = new ActiveXObject("Microsoft.XMLHttp");
else
var httpRequest = new XMLHttpRequest();
}
catch(err)
{
return ErrorHandler();
}
/* ###############################
Overriding Methods:
For each method define:
1. Private pointer to the original function
2. Privileged method to override the original function
The scan is done on the input variable
################################### */
/* -------------- Eval ------------- */
//Storing the original method in private variable
var AVG_eval = eval;
//Defining privileged method to override the original function
var Chck_eval = function (inpStr) {
if (isEmpty(inpStr))
return AVG_eval(inpStr);
if (checkData(inpStr, AVG_eval))
{
try
{
res = AVG_eval(inpStr);
return res;
}
catch(err){}
}
}
//Overriding the original function
//window.eval = Chck_eval;
/* ----------------------------------------------------------------------------------- */
/* -------------- document.write & document.writeln ------------- */
//Storing the original method in private variable
var AVG_docWrite = document.write;
var docWrite_Stuck=new Stuck(5);
var AVG_docWriteln = document.writeln;
var docWriteln_Stuck=new Stuck(5);
//Defining privileged method to override the original function
var Chck_docWrite = function (inpStr) {
if (arguments.length >1)
{
for(var i=1; i<arguments.length;i++)
{
inpStr+=arguments[i];
}
}
inpStr = String(inpStr);
if (isEmpty(inpStr) || docWrite_Stuck.find(inpStr))
{
try
{
if (IE_browser_version <= 7)
{
return AVG_docWrite(inpStr);
}
else
{
return AVG_docWrite.call(document, inpStr);
}
}
catch(err){}
}
docWrite_Stuck.add(inpStr);
if (checkData(inpStr, AVG_docWrite))
{
try
{
if (IE_browser_version <= 7 )
{
return AVG_docWrite(inpStr);
}
else
{
return AVG_docWrite.call(document, inpStr);
}
}
catch(err){}
}
}
var Chck_docWriteln = function (inpStr) {
if (arguments.length >1)
{
for(var i=1; i<arguments.length;i++)
{
inpStr+=arguments[i];
}
}
inpStr = String(inpStr);
if (isEmpty(inpStr) || docWriteln_Stuck.find(inpStr) )
{
try
{
if (IE_browser_version <= 7)
{
return AVG_docWriteln(inpStr);
}
else
{
return AVG_docWriteln.call(document, inpStr);
}
}
catch(err){}
}
docWriteln_Stuck.add(inpStr);
if (checkData(inpStr, AVG_docWriteln))
{
try
{
if (IE_browser_version <=7 )
{
return AVG_docWriteln(inpStr);
}
else
{
return AVG_docWriteln.call(document, inpStr);
}
}
catch(err){}
}
}
//Overriding the original function
//document.write = Chck_docWrite;
//document.writeln = Chck_docWriteln;
/* ----------------------------------------------------------------------------------- */
/* -------------- setTimeOut ------------- */
//Storing the original method in private variable
var AVG_STO = setTimeout;
//Store last calls value
var string_Stuck=new Stuck(5);
//Defining privileged method to override the original function
var Chck_STO = function (expr, timeout) {
if (isEmpty(expr))
return;
//Bypass scan in case the expression is equal to the last one scanned
if (string_Stuck.find(expr))
return AVG_STO(expr, timeout);
string_Stuck.add(expr);
if (checkData(expr, AVG_STO))
{
try
{
return AVG_STO(expr, timeout);
}
catch(err){}
}
}
//Overriding the original function
//window.setTimeout = Chck_STO;
/* ----------------------------------------------------------------------------------- */
/* -------------- Function constructor ------------- */
//Storing the original constructor in private variable
var AVG_Function = Function;
//Defining privileged method to override the original function
var Chck_Function = function () {
function inheritance() {}
inheritance.prototype = Function.prototype;
var Args = [].slice.call(arguments);
var Body = Args.pop();
if (isEmpty(Body))
{
AVG_eval('AVG_newFunc = AVG_Function(' + Args.join(',') + ')');
}
else
{
if (checkData('function(' + Args.join(',') + ') {' + Body + '}', AVG_Function) )
eval('AVG_newFunc = function(' + Args.join(',') + ') {' + Body + '}');
else
return false;
}
AVG_newFunc.prototype = new inheritance();
AVG_newFunc.prototype.constructor = AVG_newFunc;
return AVG_newFunc;
}
//Setting Chck_Function's prototype to Function's prototype
//Chck_Function.prototype = Function.prototype;
//Chck_Function.prototype.constructor = Chck_Function;
//Overriding the original function
//Function = Chck_Function;
/* ----------------------------------------------------------------------------------- */
/* -------------- setInterval ------------- */
//Storing the original method in private variable
var AVG_SetInterval = setInterval;
var SI_string_Stuck=new Stuck(5);
//Defining privileged method to override the original function
var Chck_SetInterval = function (expr, timeout) {
if (isEmpty(expr))
return;
if ( SI_string_Stuck.find( String(expr) ) )
return AVG_SetInterval(expr, timeout);
SI_string_Stuck.add(String(expr));
if (checkData(expr, AVG_SetInterval))
{
try
{
return AVG_SetInterval(expr, timeout);
}
catch(err){}
}
}
//Overriding the original function
//window.setInterval = Chck_SetInterval;
/* ----------------------------------------------------------------------------------- */
/* -------------- execScript ------------- */
//Run only if execScript is supported
if (typeof(window["execScript"]) != "undefined")
{
//Storing the original method in private variable
var AVG_execScript = execScript;
//Defining privileged method to override the original function
var Chck_execScript = function (expr, lang) {
if (isEmpty(expr))
return;
if (isEmpty(lang))
{
lang='javascript';
}
if (checkData(expr, AVG_execScript))
{
try
{
return AVG_execScript(expr, lang);
}
catch(err){}
}
}
//Overriding the original function
//window.execScript = Chck_execScript;
}
/* ----------------------------------------------------------------------------------- */
/* -------------- unescape ------------- */
//Storing the original method in private variable
var AVG_Unescape = unescape;
var MIN_SCAN_LEN = 4;
var AGG_Unescape_Buff = "";
//Defining privileged method to override the original function
var Chck_Unescape = function (inpStr) {
if (arguments.length >1)
{
for(var i=1; i<arguments.length;i++)
{
inpStr+=arguments[i];
}
}
inpStr = String(inpStr);
if (isEmpty(inpStr))
return AVG_Unescape(inpStr);
AGG_Unescape_Buff += String(inpStr);
if (AGG_Unescape_Buff.length < MIN_SCAN_LEN*3 )
{
return AVG_Unescape(inpStr);
}
if (checkData(AGG_Unescape_Buff, AVG_Unescape))
{
AGG_Unescape_Buff = "";
try
{
return AVG_Unescape(inpStr);
}
catch(err){}
}
AGG_Unescape_Buff = "";
}
//Overriding the original function
window.unescape = Chck_Unescape;
/* ----------------------------------------------------------------------------------- */
//Block malicous code
function BlockPage()
{
//redirect to block page + provide reason code + referrer
//document.location="http://www.avg.com/blockpage?reason=&referrer=";
}
var SEND_ORIG_BUFF = true;
function checkData(data, func)
{
//func: Currently not used, we can consider appending it to the buffer sent for scanning
//data: The buffer of the method
data = String(data);
var params =unescape_me(data);
if ( SEND_ORIG_BUFF && params.length != data.length )
{
params+= "\n"+data;
}
try
{
httpRequest.open("POST", "/CC0227228D62/CheckData", false);
httpRequest.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
httpRequest.send(params);
}
catch(err)
{
return ErrorHandler();
}
if (httpRequest.readyState == 4)
return respHandler(httpRequest);
else
return ErrorHandler();
}
function respHandler(httpRequest)
{
if (httpRequest.status == 200)
{
var resp = httpRequest.responseText;
if ((resp == null) ||
(resp == undefined) ||
(0 == resp.length) ||
("3" != resp.substr(0,1)))
{
return true;
}
else
{
BlockPage();
return false;
}
}
else
{
return ErrorHandler();
}
}
function ErrorHandler()
{
//This function handles the logic of infrastructure errors.
//For now, return true to avoid potential of false positives.
return true;
}
function isEmpty(Buf)
{
if ((Buf == 'undefined') ||
(Buf === undefined) ||
(Buf == "null") ||
(Buf === null) ||
(Buf == ""))
{
return true;
}
else
{
return false;
}
}
function Stuck (a_size) {
this.size=a_size;
//define the stuck size
this.StuckArray=new Array(this.size);
this.currentIndex = 0;
//add an item to the begining of the stuck. If stuck is full, pop out the oldest item
this.add = function(item){
if (this.StuckArray.length>this.size)
{
this.StuckArray.pop();
}
this.StuckArray.unshift(String(item));
};
//finds if item exists
this.find = function(item){
var s_item=String(item);
for (var i=0;i<this.size;i++)
{
if(s_item==this.StuckArray[i])
{
return true;
}
}
return false;
};
//toString implemetation
this.toString=function(){return this.StuckArray.toString()};
}
var MAX_UNESCAPE_ITERATIONS =5;
function unescape_me(data){
var mdata=String(data);
var udata=String('');
for (var i=0;i<MAX_UNESCAPE_ITERATIONS;i++){
udata=AVG_Unescape(mdata);
if (udata.length==mdata.length){ break; }
mdata=udata;
}
return udata;
}
}
AVG();