exports.serve = function (crawler, port) {
var webserver = require('webserver');
var server = webserver.create();
var service = server.listen(port, function(request, response) {
var context = {
postParams: request.post,
getParams: getParams(request.url)
};
crawler(context, function (event, context) {
response.statusCode = 200;
response.headers = {
'Cache': 'no-cache',
'Content-Type': 'application/json;charset=utf-8'
};
response.write(JSON.stringify(context.data, null, 2));
response.close();
});
});
return function () {
server.close();
};
};
function Server(bind,page){
log.debug("server constructor start execute");
this.COMMAND_FUNCTION_NAME_SIGNATURE = "command_" ;
this.page = page;
this.serverBind = bind || "127.0.0.1:5030";
this.serverHandler = webserver.create();
}
localWebServer = function () {
var server = require("webserver"),
serverInstance,
fs = require("fs"),
root = rootDir,
protocol = 'http:',
port = httpServerPort,
createServerCallback;
createServerCallback = function (request, response) {
var uri = URI(root + request.url),
filename = uri.normalizePathname().pathname(),
contentTypes = {
'html': 'text/html',
'js': 'text/javascript',
'css': 'text/css',
'png': 'image/png',
'jpg': 'image/jpeg',
'gif': 'image/gif',
'svg': 'image/svg+xml',
'swf': 'application/x-shockwave-flash'
},
file,
data,
extension;
if (fs.exists(filename)) {
data = fs.read(filename);
extension = filename.split('.').pop();
response.statusCode = 200;
response.headers = {
"Content-Type": contentTypes[extension] || "text/plain",
"Content-Length": data.length,
"Pragma": "no-cache",
"Expires": "Wed, 11 Jan 1984 05:00:00 GMT",
"Cache-Control": "max-age=0, no-cache, no-store, must-revalidate",
"Access-Control-Allow-Origin": "*"
};
response.write(data);
} else {
console.log("Phantomjs webserver sends 404 for:", filename);
response.statusCode = 404;
response.headers = {
"Content-Type": "text/plain"
};
response.write("404 Not Found\n");
}
response.close();
};
serverInstance = server.create()
.listen(port, {'keepAlive': true}, createServerCallback);
console.log();
console.log("Static file server running at\n => " + protocol + "://localhost:" + port);
},
function Server(bind){
log.debug("server constructor start execute");
this.COMMAND_FUNCTION_NAME_SIGNATURE = "command_" ;
if (!bind && this.hasOwnProperty("config")){
if (this.config.hasOwnProperty("bind")){
this.serverBind = this.config.bind;
}
}
this.serverBind = this.serverBind || "127.0.0.1:5030";
this.serverHandler = webserver.create();
}
page.open(settings.pageUrl, function(status) {
if (status !== 'success') {
console.log('Failed to load the address', settings.pageUrl);
phantom.exit(1);
}
var phantomRunnerDefinition = page.evaluate(function() {
return getPhantomRunnerDefinition();
});
if(!phantomRunnerDefinition) {
console.error("Unable to get runner definition from page.");
phantom.exit(2);
}
console.log('Opened page', settings.pageUrl, JSON.stringify(phantomRunnerDefinition));
var server = webserver.create();
var service = server.listen(settings.port, function(request, response) {
var responseHelper = new ResponseHelper(response);
var returnValue = null;
try {
page.onCallback = function(data) {
if(data.status === "success") {
var base64 = null;
if(data.base64) {
base64 = data.base64;
}
responseHelper.write(base64);
} else {
responseHelper.error(data.message);
}
};
returnValue = page.evaluate(function(request) {
return execute(request);
}, request);
if(!!returnValue && !returnValue.async) {
responseHelper.json(returnValue);
}
} catch(e) {
responseHelper.error(e);
}
});
console.log('PhantomJs server instance is running.');
});
Angel.prototype.init = function (ip, port) {
var self = this;
self._ip = ip;
self._port = port;
self._page = webpage.create();
self._server = webserver.create();
self._adblock = new adblock();
console.log("Creating new Tab: " + ip + ":" + port);
self._page.viewportSize = {
width: 1024,
height: 768
};
self._page.settings.resourceTimeout = 60000;
self._page.onResourceRequested = function (requestData, networkRequest) {
self._onResourceRequested(requestData, networkRequest);
};
self._page.onResourceReceived = function (response) {
self._onResourceReceived(response);
};
self._page.onResourceTimeout = function (request) {
self._onResourceTimeout(request);
};
self._page.onResourceError = function (resourceError) {
self._onResourceError(resourceError);
};
self._page.onConsoleMessage = function (msg, lineNum, sourceId) {
self._onConsoleMessage(msg, lineNum, sourceId);
};
try {
self._server.listen(ip + ":" + port,
function (request, response) {
self._handleRequest(request, response);
});
self._announceAngel();
} catch (ex) {
phantom.exit();
}
console.log("Starting Angel on port: " + self._port);
self._resetAutoDestruct();
};
* alert, confirm, etc. The page will be evaluated, and the DOM
* triggers will alert us of any suspicious JS.
*/
var DEBUG = true
var system = require('system');
var fs = require('fs');
// Create xss object that will be used to track XSS information
var xss = new Object();
xss.value = 0;
xss.msg = "";
// Create webserver object
var webserver = require('webserver');
server = webserver.create();
// Server config details
var host = '127.0.0.1';
var port = '8093';
/**
* parse incoming HTTP responses that are provided via BURP intruder.
* data is base64 encoded to prevent issues passing via HTTP.
*/
parsePage = function(data,url,headers) {
if (DEBUG) {
console.log("Beginning to parse page");
console.log("\tURL: " + url);
console.log("\tHeaders: " + headers);
}
var webpage = require('webpage');
var server = require('webserver')
var system = require('system');
var waitfor = require('./waitfor.js');
var listening = server.create().listen(8080, function (request, response) {
var page = webpage.create();
page.settings.loadImages = false;
response.headers = {
"Content-Type" : "text/html; charset=UTF-8",
"X-PhantomJS" : "true"
};
page.onResourceRequested = function (requestData, request) {
if ((/http:\/\/.+?\.css/gi).test(requestData['url']) ||
requestData.headers['Content-Type'] == 'text/css') {
console.log('The url of the request is matching. Aborting: ' + requestData['url']);
request.abort();
}
};
page.onResourceError = function (resourceError) {
console.log('Unable to load resource (#' + resourceError.id + 'URL:' + resourceError.url + ')');
console.log('Error code: ' + resourceError.errorCode + '. Description: ' + resourceError.errorString);
};
page.onError = function (msg, trace) {
var msgStack = ['ERROR: ' + msg];
phantom.injectJs("./test-environment.js");
phantom.injectJs("./test-require.js");
phantom.injectJs("./test-system.js");
phantom.injectJs("./test-webpage.js");
phantom.injectJs("./test-webpage-listeners.js");
phantom.injectJs("./test-webpage-keyevent.js");
phantom.injectJs("./test-webpage-keyevent2.js");
phantom.injectJs("./test-webpage-mouseevent.js");
phantom.injectJs("./test-webpage-callbacks.js");
phantom.injectJs("./test-webpage-render.js");
phantom.injectJs("./test-webpage-prompt.js");
phantom.injectJs("./test-webpage-open.js");
var webserverTest = webServerFactory.create();
webserverTest.listen(8083, function(request, response) {
var filepath = phantom.libraryPath+'/www'+request.url;
if (fs.exists(filepath)){
if (fs.isFile(filepath)) {
response.statusCode = 200;
var str = fs.read(filepath, "b")
var h = {};
var enc = '';
if (filepath.match(/\.png$/)) {
response.setEncoding("binary");
h['Content-Type'] = 'image/png';
}
else if (filepath.match(/\.css$/))
h['Content-Type'] = 'text/css';
var queryEnd = url.indexOf("#");
if (queryEnd < 0) {
queryEnd = url.length;
}
var queryString = url.substring(pathEnd + 1, queryEnd);
var query = parseQuery(queryString);
return {
pathname: path,
query: query
};
}
var s = server.create();
var service = s.listen(46317, function (req, resp) {
var u = parseUrl(req.url);
var params = u.query;
function writeError(e) {
console.error("Error: " + e.message + " (fetching " + params.url + ")");
console.error(JSON.stringify(e));
resp.statusCode = 500;
resp.setHeader("Content-Type", "text/plain");
resp.write("Message: " + e.message + "\n");
resp.write(JSON.stringify(e));
resp.write("\n" + e);
resp.close();
}
var FORMATS = {
png: {ext: "png", contentType: ""}
},
IMG_URL = system.env["THUMBER_IMG_URL"] || "/thumb",
IMG_DIR = system.env["THUMBER_IMG_DIR"] ||
fs.workingDirectory + fs.separator + "thumb",
TIMEOUT_DEFAULT = parseInt(system.env["THUMBER_TIMEOUT"]),
PORT = system.env["PHANTOM_PORT"];
PORT = PORT ? parseInt(PORT) : 8080;
if (isNaN(TIMEOUT_DEFAULT))
TIMEOUT_DEFAULT = 5000;
var server = webserver.create(),
service = server.listen(PORT, function(request, response) {
var url = request.url,
urlParts = url.split("?"),
query = parseQuery(urlParts[1]),
fetchURL = query.url,
format = query.format,
timeout = parseInt(query.timeout);
if (!query.url) {
response.statusCode = 401;
response.closeGracefully();
return;
}
if (!format)
var pageCache = [];
var adapterName = phantom.libraryPath + '/' + 'phantomjs-template-adapter.html';
var adapterHTML = fs.read(adapterName);
var renderFormats = {
'application/pdf': 'pdf',
'image/jpeg': 'jpeg',
'image/png': 'png',
};
if (!secret) {
console.warn('Warning: No secret supplied. Will accept unsigned requests!');
}
if (webserver.create().listen(port, function(request, response) {
// HTTP headers are case-insensitive
request.headers = Object.keys(request.headers).reduce(function(headers, key) {
headers[key.toLowerCase()] = request.headers[key];
return headers;
}, {});
try {
$renderTemplate(parseRequest(request))
.catch(function(err) {
return err;
})
.then(function(result) {
if (!(result instanceof Array)) {
result = [500, result && result.message || ('Unknown renderer response: ' + result)];
}
function main() {
var port = 9005;
var svr = webserver.create();
svr.listen(port, handle_request);
}
top: clipRect.top,
left: clipRect.left,
width: clipRect.width,
height: clipRect.height
};
var pic = page.renderBase64('png');
console.log("Rendered image of size: " + clipRect.width + 'x' + clipRect.height + " (" + pic.length + " bytes)");
return pic;
};
console.log("-> Starting server on port " + PORT + ".");
webserver.create().listen(PORT, function(request, response) {
console.log(request.method + ' ' + request.url);
if (request.method != 'POST' || request.url != '/') {
response.statusCode = 404;
response.close();
return;
}
// TODO: Add some kind of security here?
var render_fn = request.post && request.post['src'];
var page = webpage.create();
page.open('shell.html', function(status) {
if (status != 'success') {
console.log("Failed to load shell page, status: " + status);