+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
literal 0
HcmV?d00001
diff --git a/deps/npm/node_modules/request/node_modules/form-data/test/integration/test-custom-headers.js b/deps/npm/node_modules/request/node_modules/form-data/test/integration/test-custom-headers.js
new file mode 100644
index 00000000000..1c9b6adad56
--- /dev/null
+++ b/deps/npm/node_modules/request/node_modules/form-data/test/integration/test-custom-headers.js
@@ -0,0 +1,75 @@
+/*
+test custom headers, added in pull request:
+https://github.com/felixge/node-form-data/pull/17
+*/
+
+var common = require('../common');
+var assert = common.assert;
+var http = require('http');
+
+var FormData = require(common.dir.lib + '/form_data');
+
+var CRLF = '\r\n';
+
+var testHeader = 'X-Test-Fake: 123';
+
+var expectedLength;
+
+
+var server = http.createServer(function(req, res) {
+ var data = '';
+ req.setEncoding('utf8');
+
+ req.on('data', function(d) {
+ data += d;
+ });
+
+ req.on('end', function() {
+ assert.ok( data.indexOf( testHeader ) != -1 );
+
+ // content-length would be 1000+ w/actual buffer size,
+ // but smaller w/overridden size.
+ assert.ok( typeof req.headers['content-length'] !== 'undefined' );
+ assert.equal(req.headers['content-length'], expectedLength);
+
+ res.writeHead(200);
+ res.end('done');
+ });
+});
+
+
+server.listen(common.port, function() {
+ var form = new FormData();
+
+ var options = {
+ header:
+ CRLF + '--' + form.getBoundary() + CRLF +
+ testHeader +
+ CRLF + CRLF,
+
+ // override content-length,
+ // much lower than actual buffer size (1000)
+ knownLength: 1
+ };
+
+ var bufferData = [];
+ for (var z = 0; z < 1000; z++) {
+ bufferData.push(1);
+ }
+ var buffer = new Buffer(bufferData);
+
+ form.append('my_buffer', buffer, options);
+
+ // (available to req handler)
+ expectedLength = form._lastBoundary().length + form._overheadLength + options.knownLength;
+
+ form.submit('http://localhost:' + common.port + '/', function(err, res) {
+ if (err) {
+ throw err;
+ }
+
+ assert.strictEqual(res.statusCode, 200);
+ server.close();
+ });
+
+});
diff --git a/deps/npm/node_modules/request/node_modules/form-data/test/integration/test-form-get-length.js b/deps/npm/node_modules/request/node_modules/form-data/test/integration/test-form-get-length.js
new file mode 100644
index 00000000000..44d3b4dc276
--- /dev/null
+++ b/deps/npm/node_modules/request/node_modules/form-data/test/integration/test-form-get-length.js
@@ -0,0 +1,93 @@
+var common = require('../common');
+var assert = common.assert;
+var FormData = require(common.dir.lib + '/form_data');
+var fake = require('fake').create();
+var fs = require('fs');
+
+(function testEmptyForm() {
+ var form = new FormData();
+ var callback = fake.callback(arguments.callee.name + '-getLength');
+ var calls = fake.expectAnytime(callback, [null, 0]).calls;
+
+ form.getLength(callback);
+
+ // Make sure our response is async
+ assert.strictEqual(calls.length, 0);
+})();
+
+(function testUtf8String() {
+ var FIELD = 'my_field';
+ var VALUE = 'May the € be with you';
+
+ var form = new FormData();
+ form.append(FIELD, VALUE);
+ var callback = fake.callback(arguments.callee.name + '-getLength');
+
+ var expectedLength =
+ form._overheadLength +
+ Buffer.byteLength(VALUE) +
+ form._lastBoundary().length;
+
+ fake.expectAnytime(callback, [null, expectedLength]);
+ form.getLength(callback);
+})();
+
+(function testBuffer() {
+ var FIELD = 'my_field';
+ var VALUE = new Buffer(23);
+
+ var form = new FormData();
+ form.append(FIELD, VALUE);
+ var callback = fake.callback(arguments.callee.name + '-getLength');
+
+ var expectedLength =
+ form._overheadLength +
+ VALUE.length +
+ form._lastBoundary().length;
+
+ fake.expectAnytime(callback, [null, expectedLength]);
+ form.getLength(callback);
+})();
+
+
+(function testStringFileBufferFile() {
+ var fields = [
+ {
+ name: 'my_field',
+ value: 'Test 123',
+ },
+ {
+ name: 'my_image',
+ value: fs.createReadStream(common.dir.fixture + '/unicycle.jpg'),
+ },
+ {
+ name: 'my_buffer',
+ value: new Buffer('123'),
+ },
+ {
+ name: 'my_txt',
+ value: fs.createReadStream(common.dir.fixture + '/bacon.txt'),
+ },
+ ];
+
+ var form = new FormData();
+ var expectedLength = 0;
+
+ fields.forEach(function(field) {
+ form.append(field.name, field.value);
+ if (field.value.path) {
+ var stat = fs.statSync(field.value.path);
+ expectedLength += stat.size;
+ } else {
+ expectedLength += field.value.length;
+ }
+ });
+
+ expectedLength += form._overheadLength + form._lastBoundary().length;
+
+ var callback = fake.callback(arguments.callee.name + '-getLength');
+ fake.expectAnytime(callback, [null, expectedLength]);
+ form.getLength(callback);
+})();
+
+
diff --git a/deps/npm/node_modules/request/node_modules/form-data/test/integration/test-get-boundary.js b/deps/npm/node_modules/request/node_modules/form-data/test/integration/test-get-boundary.js
new file mode 100644
index 00000000000..6dc2fb2bdde
--- /dev/null
+++ b/deps/npm/node_modules/request/node_modules/form-data/test/integration/test-get-boundary.js
@@ -0,0 +1,18 @@
+var common = require('../common');
+var assert = common.assert;
+
+var FormData = require(common.dir.lib + '/form_data');
+
+(function testOneBoundaryPerForm() {
+ var form = new FormData();
+ var boundary = form.getBoundary();
+
+ assert.equal(boundary, form.getBoundary());
+ assert.equal(boundary.length, 50);
+})();
+
+(function testUniqueBoundaryPerForm() {
+ var formA = new FormData();
+ var formB = new FormData();
+ assert.notEqual(formA.getBoundary(), formB.getBoundary());
+})();
diff --git a/deps/npm/node_modules/request/node_modules/form-data/test/integration/test-http-response.js b/deps/npm/node_modules/request/node_modules/form-data/test/integration/test-http-response.js
new file mode 100644
index 00000000000..8e183fed31d
--- /dev/null
+++ b/deps/npm/node_modules/request/node_modules/form-data/test/integration/test-http-response.js
@@ -0,0 +1,121 @@
+var common = require('../common');
+var assert = common.assert;
+var http = require('http');
+var path = require('path');
+var mime = require('mime');
+var request = require('request');
+var parseUrl = require('url').parse;
+var fs = require('fs');
+var FormData = require(common.dir.lib + '/form_data');
+var IncomingForm = require('formidable').IncomingForm;
+
+var remoteFile = 'http://nodejs.org/images/logo.png';
+
+var FIELDS;
+var server;
+
+var parsedUrl = parseUrl(remoteFile)
+ , options = {
+ method: 'get',
+ port: parsedUrl.port || 80,
+ path: parsedUrl.pathname,
+ host: parsedUrl.hostname
+ }
+ ;
+
+http.request(options, function(res) {
+
+ FIELDS = [
+ {name: 'my_field', value: 'my_value'},
+ {name: 'my_buffer', value: new Buffer([1, 2, 3])},
+ {name: 'remote_file', value: res }
+ ];
+
+ var form = new FormData();
+ FIELDS.forEach(function(field) {
+ form.append(field.name, field.value);
+ });
+
+ server.listen(common.port, function() {
+
+ form.submit('http://localhost:' + common.port + '/', function(err, res) {
+
+ if (err) {
+ throw err;
+ }
+
+ assert.strictEqual(res.statusCode, 200);
+ server.close();
+ });
+
+ });
+
+
+}).end();
+
+server = http.createServer(function(req, res) {
+
+ // formidable is broken so let's do it manual way
+ //
+ // var form = new IncomingForm();
+ // form.uploadDir = common.dir.tmp;
+ // form.parse(req);
+ // form
+ // .on('field', function(name, value) {
+ // var field = FIELDS.shift();
+ // assert.strictEqual(name, field.name);
+ // assert.strictEqual(value, field.value+'');
+ // })
+ // .on('file', function(name, file) {
+ // var field = FIELDS.shift();
+ // assert.strictEqual(name, field.name);
+ // assert.strictEqual(file.name, path.basename(field.value.path));
+ // // mime.lookup file.NAME == 'my_file' ?
+ // assert.strictEqual(file.type, mime.lookup(file.name));
+ // })
+ // .on('end', function() {
+ // res.writeHead(200);
+ // res.end('done');
+ // });
+
+ // temp workaround
+ var data = '';
+ req.setEncoding('utf8');
+
+ req.on('data', function(d) {
+ data += d;
+ });
+
+ req.on('end', function() {
+
+ // check for the fields' traces
+
+ // 1st field : my_field
+ var field = FIELDS.shift();
+ assert.ok( data.indexOf('form-data; name="'+field.name+'"') != -1 );
+ assert.ok( data.indexOf(field.value) != -1 );
+
+ // 2nd field : my_buffer
+ var field = FIELDS.shift();
+ assert.ok( data.indexOf('form-data; name="'+field.name+'"') != -1 );
+ assert.ok( data.indexOf(field.value) != -1 );
+
+ // 3rd field : remote_file
+ var field = FIELDS.shift();
+ assert.ok( data.indexOf('form-data; name="'+field.name+'"') != -1 );
+ assert.ok( data.indexOf('; filename="'+path.basename(remoteFile)+'"') != -1 );
+ // check for http://nodejs.org/images/logo.png traces
+ assert.ok( data.indexOf('ImageReady') != -1 );
+ assert.ok( data.indexOf('Content-Type: '+mime.lookup(remoteFile) ) != -1 );
+
+ res.writeHead(200);
+ res.end('done');
+
+ });
+
+});
+
+
+process.on('exit', function() {
+ assert.strictEqual(FIELDS.length, 0);
+});
diff --git a/deps/npm/node_modules/request/node_modules/form-data/test/integration/test-pipe.js b/deps/npm/node_modules/request/node_modules/form-data/test/integration/test-pipe.js
new file mode 100644
index 00000000000..3cb4ce44a6e
--- /dev/null
+++ b/deps/npm/node_modules/request/node_modules/form-data/test/integration/test-pipe.js
@@ -0,0 +1,120 @@
+var common = require('../common');
+var assert = common.assert;
+var http = require('http');
+var path = require('path');
+var mime = require('mime');
+var request = require('request');
+var fs = require('fs');
+var FormData = require(common.dir.lib + '/form_data');
+var IncomingForm = require('formidable').IncomingForm;
+
+var remoteFile = 'http://nodejs.org/images/logo.png';
+
+// wrap non simple values into function
+// just to deal with ReadStream "autostart"
+// Can't wait for 0.10
+var FIELDS = [
+ {name: 'my_field', value: 'my_value'},
+ {name: 'my_buffer', value: function(){ return new Buffer([1, 2, 3])} },
+ {name: 'my_file', value: function(){ return fs.createReadStream(common.dir.fixture + '/unicycle.jpg')} },
+ {name: 'remote_file', value: function(){ return request(remoteFile)} }
+];
+
+var server = http.createServer(function(req, res) {
+
+ // formidable is fixed on github
+ // but still 7 month old in npm
+ //
+ // var form = new IncomingForm();
+ // form.uploadDir = common.dir.tmp;
+ // form.parse(req);
+ // form
+ // .on('field', function(name, value) {
+ // var field = FIELDS.shift();
+ // assert.strictEqual(name, field.name);
+ // assert.strictEqual(value, field.value+'');
+ // })
+ // .on('file', function(name, file) {
+ // var field = FIELDS.shift();
+ // assert.strictEqual(name, field.name);
+ // assert.strictEqual(file.name, path.basename(field.value.path));
+ // assert.strictEqual(file.type, mime.lookup(file.name));
+ // })
+ // .on('end', function() {
+ // res.writeHead(200);
+ // res.end('done');
+ // });
+
+ // temp workaround
+ var data = '';
+ req.setEncoding('utf8');
+
+ req.on('data', function(d) {
+ data += d;
+ });
+
+ req.on('end', function() {
+ // check for the fields' traces
+
+ // 1st field : my_field
+ var field = FIELDS.shift();
+ assert.ok( data.indexOf('form-data; name="'+field.name+'"') != -1 );
+ assert.ok( data.indexOf(field.value) != -1 );
+
+ // 2nd field : my_buffer
+ var field = FIELDS.shift();
+ assert.ok( data.indexOf('form-data; name="'+field.name+'"') != -1 );
+ assert.ok( data.indexOf(field.value) != -1 );
+
+ // 3rd field : my_file
+ var field = FIELDS.shift();
+ assert.ok( data.indexOf('form-data; name="'+field.name+'"') != -1 );
+ assert.ok( data.indexOf('; filename="'+path.basename(field.value.path)+'"') != -1 );
+
+ // check for unicycle.jpg traces
+ assert.ok( data.indexOf('2005:06:21 01:44:12') != -1 );
+ assert.ok( data.indexOf('Content-Type: '+mime.lookup(field.value.path) ) != -1 );
+
+ // 4th field : remote_file
+ var field = FIELDS.shift();
+ assert.ok( data.indexOf('form-data; name="'+field.name+'"') != -1 );
+ assert.ok( data.indexOf('; filename="'+path.basename(field.value.path)+'"') != -1 );
+ // check for http://nodejs.org/images/logo.png traces
+ assert.ok( data.indexOf('ImageReady') != -1 );
+ assert.ok( data.indexOf('Content-Type: '+mime.lookup(remoteFile) ) != -1 );
+
+ res.writeHead(200);
+ res.end('done');
+
+ });
+
+
+});
+
+server.listen(common.port, function() {
+ var form = new FormData();
+ FIELDS.forEach(function(field) {
+ // important to append ReadStreams within the same tick
+ if ((typeof field.value == 'function')) {
+ field.value = field.value();
+ }
+ form.append(field.name, field.value);
+ });
+
+ var request = http.request({
+ method: 'post',
+ port: common.port,
+ path: '/upload',
+ headers: form.getHeaders()
+ });
+
+ form.pipe(request);
+
+ request.on('response', function(res) {
+ server.close();
+ });
+});
+
+process.on('exit', function() {
+ assert.strictEqual(FIELDS.length, 0);
+});
diff --git a/deps/npm/node_modules/request/node_modules/form-data/test/integration/test-submit-custom.js b/deps/npm/node_modules/request/node_modules/form-data/test/integration/test-submit-custom.js
new file mode 100644
index 00000000000..0e4c592e7c6
--- /dev/null
+++ b/deps/npm/node_modules/request/node_modules/form-data/test/integration/test-submit-custom.js
@@ -0,0 +1,121 @@
+var common = require('../common');
+var assert = common.assert;
+var http = require('http');
+var path = require('path');
+var mime = require('mime');
+var request = require('request');
+var fs = require('fs');
+var FormData = require(common.dir.lib + '/form_data');
+var IncomingForm = require('formidable').IncomingForm;
+
+var remoteFile = 'http://nodejs.org/images/logo.png';
+
+// wrap non simple values into function
+// just to deal with ReadStream "autostart"
+// Can't wait for 0.10
+var FIELDS = [
+ {name: 'my_field', value: 'my_value'},
+ {name: 'my_buffer', value: function(){ return new Buffer([1, 2, 3])} },
+ {name: 'my_file', value: function(){ return fs.createReadStream(common.dir.fixture + '/unicycle.jpg')} },
+ {name: 'remote_file', value: function(){ return request(remoteFile)} }
+];
+
+var server = http.createServer(function(req, res) {
+
+ // formidable is fixed on github
+ // but still 7 month old in npm
+ //
+ // var form = new IncomingForm();
+ // form.uploadDir = common.dir.tmp;
+ // form.parse(req);
+ // form
+ // .on('field', function(name, value) {
+ // var field = FIELDS.shift();
+ // assert.strictEqual(name, field.name);
+ // assert.strictEqual(value, field.value+'');
+ // })
+ // .on('file', function(name, file) {
+ // var field = FIELDS.shift();
+ // assert.strictEqual(name, field.name);
+ // assert.strictEqual(file.name, path.basename(field.value.path));
+ // // mime.lookup file.NAME == 'my_file' ?
+ // assert.strictEqual(file.type, mime.lookup(file.name));
+ // })
+ // .on('end', function() {
+ // res.writeHead(200);
+ // res.end('done');
+ // });
+
+ // temp workaround
+ var data = '';
+ req.setEncoding('utf8');
+ req.on('data', function(d) {
+ data += d;
+ });
+ req.on('end', function() {
+ // check for the fields' traces
+
+ // 1st field : my_field
+ var field = FIELDS.shift();
+ assert.ok( data.indexOf('form-data; name="'+field.name+'"') != -1 );
+ assert.ok( data.indexOf(field.value) != -1 );
+
+ // 2nd field : my_buffer
+ var field = FIELDS.shift();
+ assert.ok( data.indexOf('form-data; name="'+field.name+'"') != -1 );
+ assert.ok( data.indexOf(field.value) != -1 );
+
+ // 3rd field : my_file
+ var field = FIELDS.shift();
+ assert.ok( data.indexOf('form-data; name="'+field.name+'"') != -1 );
+ assert.ok( data.indexOf('; filename="'+path.basename(field.value.path)+'"') != -1 );
+ // check for unicycle.jpg traces
+ assert.ok( data.indexOf('2005:06:21 01:44:12') != -1 );
+ assert.ok( data.indexOf('Content-Type: '+mime.lookup(field.value.path) ) != -1 );
+
+ // 4th field : remote_file
+ var field = FIELDS.shift();
+ assert.ok( data.indexOf('form-data; name="'+field.name+'"') != -1 );
+ assert.ok( data.indexOf('; filename="'+path.basename(field.value.path)+'"') != -1 );
+ // check for http://nodejs.org/images/logo.png traces
+ assert.ok( data.indexOf('ImageReady') != -1 );
+ assert.ok( data.indexOf('Content-Type: '+mime.lookup(remoteFile) ) != -1 );
+
+ res.writeHead(200);
+ res.end('done');
+
+ });
+
+});
+
+server.listen(common.port, function() {
+
+ var form = new FormData();
+
+ FIELDS.forEach(function(field) {
+ // important to append ReadStreams within the same tick
+ if ((typeof field.value == 'function')) {
+ field.value = field.value();
+ }
+ form.append(field.name, field.value);
+ });
+
+ // custom params object passed to submit
+ form.submit({
+ port: common.port,
+ path: '/'
+ }, function(err, res) {
+
+ if (err) {
+ throw err;
+ }
+
+ assert.strictEqual(res.statusCode, 200);
+ server.close();
+ });
+
+});
+
+process.on('exit', function() {
+ assert.strictEqual(FIELDS.length, 0);
+});
diff --git a/deps/npm/node_modules/request/node_modules/form-data/test/integration/test-submit.js b/deps/npm/node_modules/request/node_modules/form-data/test/integration/test-submit.js
new file mode 100644
index 00000000000..b6e2c07a36c
--- /dev/null
+++ b/deps/npm/node_modules/request/node_modules/form-data/test/integration/test-submit.js
@@ -0,0 +1,117 @@
+var common = require('../common');
+var assert = common.assert;
+var http = require('http');
+var path = require('path');
+var mime = require('mime');
+var request = require('request');
+var fs = require('fs');
+var FormData = require(common.dir.lib + '/form_data');
+var IncomingForm = require('formidable').IncomingForm;
+
+var remoteFile = 'http://nodejs.org/images/logo.png';
+
+// wrap non simple values into function
+// just to deal with ReadStream "autostart"
+// Can't wait for 0.10
+var FIELDS = [
+ {name: 'my_field', value: 'my_value'},
+ {name: 'my_buffer', value: function(){ return new Buffer([1, 2, 3])} },
+ {name: 'my_file', value: function(){ return fs.createReadStream(common.dir.fixture + '/unicycle.jpg')} },
+ {name: 'remote_file', value: function(){ return request(remoteFile)} }
+];
+
+var server = http.createServer(function(req, res) {
+
+ // formidable is fixed on github
+ // but still 7 month old in npm
+ //
+ // var form = new IncomingForm();
+ // form.uploadDir = common.dir.tmp;
+ // form.parse(req);
+ // form
+ // .on('field', function(name, value) {
+ // var field = FIELDS.shift();
+ // assert.strictEqual(name, field.name);
+ // assert.strictEqual(value, field.value+'');
+ // })
+ // .on('file', function(name, file) {
+ // var field = FIELDS.shift();
+ // assert.strictEqual(name, field.name);
+ // assert.strictEqual(file.name, path.basename(field.value.path));
+ // // mime.lookup file.NAME == 'my_file' ?
+ // assert.strictEqual(file.type, mime.lookup(file.name));
+ // })
+ // .on('end', function() {
+ // res.writeHead(200);
+ // res.end('done');
+ // });
+
+ // temp workaround
+ var data = '';
+ req.setEncoding('utf8');
+ req.on('data', function(d) {
+ data += d;
+ });
+ req.on('end', function() {
+ // check for the fields' traces
+
+ // 1st field : my_field
+ var field = FIELDS.shift();
+ assert.ok( data.indexOf('form-data; name="'+field.name+'"') != -1 );
+ assert.ok( data.indexOf(field.value) != -1 );
+
+ // 2nd field : my_buffer
+ var field = FIELDS.shift();
+ assert.ok( data.indexOf('form-data; name="'+field.name+'"') != -1 );
+ assert.ok( data.indexOf(field.value) != -1 );
+
+ // 3rd field : my_file
+ var field = FIELDS.shift();
+ assert.ok( data.indexOf('form-data; name="'+field.name+'"') != -1 );
+ assert.ok( data.indexOf('; filename="'+path.basename(field.value.path)+'"') != -1 );
+ // check for unicycle.jpg traces
+ assert.ok( data.indexOf('2005:06:21 01:44:12') != -1 );
+ assert.ok( data.indexOf('Content-Type: '+mime.lookup(field.value.path) ) != -1 );
+
+ // 4th field : remote_file
+ var field = FIELDS.shift();
+ assert.ok( data.indexOf('form-data; name="'+field.name+'"') != -1 );
+ assert.ok( data.indexOf('; filename="'+path.basename(field.value.path)+'"') != -1 );
+ // check for http://nodejs.org/images/logo.png traces
+ assert.ok( data.indexOf('ImageReady') != -1 );
+ assert.ok( data.indexOf('Content-Type: '+mime.lookup(remoteFile) ) != -1 );
+
+ res.writeHead(200);
+ res.end('done');
+
+ });
+
+});
+
+server.listen(common.port, function() {
+
+ var form = new FormData();
+
+ FIELDS.forEach(function(field) {
+ // important to append ReadStreams within the same tick
+ if ((typeof field.value == 'function')) {
+ field.value = field.value();
+ }
+ form.append(field.name, field.value);
+ });
+
+ form.submit('http://localhost:' + common.port + '/', function(err, res) {
+
+ if (err) {
+ throw err;
+ }
+
+ assert.strictEqual(res.statusCode, 200);
+ server.close();
+ });
+
+});
+
+process.on('exit', function() {
+ assert.strictEqual(FIELDS.length, 0);
+});
diff --git a/deps/npm/node_modules/request/node_modules/form-data/test/run.js b/deps/npm/node_modules/request/node_modules/form-data/test/run.js
new file mode 100755
index 00000000000..0bb8e822414
--- /dev/null
+++ b/deps/npm/node_modules/request/node_modules/form-data/test/run.js
@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+var far = require('far').create();
+
+far.add(__dirname);
+far.include(/test-.*\.js$/);
+
+far.execute();
diff --git a/deps/npm/node_modules/request/node_modules/hawk/.npmignore b/deps/npm/node_modules/request/node_modules/hawk/.npmignore
new file mode 100644
index 00000000000..77ba16cb055
--- /dev/null
+++ b/deps/npm/node_modules/request/node_modules/hawk/.npmignore
@@ -0,0 +1,18 @@
+.idea
+*.iml
+npm-debug.log
+dump.rdb
+node_modules
+results.tap
+results.xml
+npm-shrinkwrap.json
+config.json
+.DS_Store
+*/.DS_Store
+*/*/.DS_Store
+._*
+*/._*
+*/*/._*
+coverage.*
+lib-cov
+
diff --git a/deps/npm/node_modules/request/node_modules/hawk/.travis.yml b/deps/npm/node_modules/request/node_modules/hawk/.travis.yml
new file mode 100755
index 00000000000..d8523c933a2
--- /dev/null
+++ b/deps/npm/node_modules/request/node_modules/hawk/.travis.yml
@@ -0,0 +1,5 @@
+language: node_js
+
+node_js:
+ - 0.8
+
diff --git a/deps/npm/node_modules/request/node_modules/hawk/LICENSE b/deps/npm/node_modules/request/node_modules/hawk/LICENSE
new file mode 100755
index 00000000000..e699a7bdbaa
--- /dev/null
+++ b/deps/npm/node_modules/request/node_modules/hawk/LICENSE
@@ -0,0 +1,24 @@
+Copyright (c) 2012-2013, Eran Hammer.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of Eran Hammer nor the
+ names of its contributors may be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL ERAN HAMMER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/deps/npm/node_modules/request/node_modules/hawk/Makefile b/deps/npm/node_modules/request/node_modules/hawk/Makefile
new file mode 100755
index 00000000000..97ba3af437a
--- /dev/null
+++ b/deps/npm/node_modules/request/node_modules/hawk/Makefile
@@ -0,0 +1,11 @@
+test:
+ @./node_modules/.bin/lab
+test-cov:
+ @./node_modules/.bin/lab -r threshold -t 100
+test-cov-html:
+ @./node_modules/.bin/lab -r html -o coverage.html
+complexity:
+ @./node_modules/.bin/cr -o complexity.md -f markdown lib
+
+.PHONY: test test-cov test-cov-html complexity
+
diff --git a/deps/npm/node_modules/request/node_modules/hawk/README.md b/deps/npm/node_modules/request/node_modules/hawk/README.md
new file mode 100755
index 00000000000..66b52cbbd27
--- /dev/null
+++ b/deps/npm/node_modules/request/node_modules/hawk/README.md
@@ -0,0 +1,604 @@
+
+
+
**Hawk** is an HTTP authentication scheme using a message authentication code (MAC) algorithm to provide partial
+HTTP request cryptographic verification. For more complex use cases such as access delegation, see [Oz](https://github.com/hueniverse/oz).
+
+Current version: **0.10.1**
+
+[](http://travis-ci.org/hueniverse/hawk)
+
+# Table of Content
+
+- [**Introduction**](#introduction)
+ - [Replay Protection](#replay-protection)
+ - [Usage Example](#usage-example)
+ - [Protocol Example](#protocol-example)
+ - [Payload Validation](#payload-validation)
+ - [Response Payload Validation](#response-payload-validation)
+
+- [**Single URI Authorization**](#single-uri-authorization)
+ - [Usage Example](#bewit-usage-example)
+
+- [**Security Considerations**](#security-considerations)
+ - [MAC Keys Transmission](#mac-keys-transmission)
+ - [Confidentiality of Requests](#confidentiality-of-requests)
+ - [Spoofing by Counterfeit Servers](#spoofing-by-counterfeit-servers)
+ - [Plaintext Storage of Credentials](#plaintext-storage-of-credentials)
+ - [Entropy of Keys](#entropy-of-keys)
+ - [Coverage Limitations](#coverage-limitations)
+ - [Future Time Manipulation](#future-time-manipulation)
+ - [Client Clock Poisoning](#client-clock-poisoning)
+ - [Bewit Limitations](#bewit-limitations)
+
+- [**Frequently Asked Questions**](#frequently-asked-questions)
+
+- [**Acknowledgements**](#acknowledgements)
+
+# Introduction
+
+**Hawk** is an HTTP authentication scheme providing mechanisms for making authenticated HTTP requests with
+partial cryptographic verification of the request and response, covering the HTTP method, request URI, host,
+and optionally the request payload.
+
+Similar to the HTTP [Digest access authentication schemes](http://www.ietf.org/rfc/rfc2617.txt), **Hawk** uses a set of
+client credentials which include an identifier (e.g. username) and key (e.g. password). Likewise, just as with the Digest scheme,
+the key is never included in authenticated requests. Instead, it is used to calculate a request MAC value which is
+included in its place.
+
+However, **Hawk** has several differences from Digest. In particular, while both use a nonce to limit the possibility of
+replay attacks, in **Hawk** the client generates the nonce and uses it in combination with a timestamp, leading to less
+"chattiness" (interaction with the server).
+
+Also unlike Digest, this scheme is not intended to protect the key itself (the password in Digest) because
+the client and server must both have access to the key material in the clear.
+
+The primary design goals of this scheme are to:
+* simplify and improve HTTP authentication for services that are unwilling or unable to deploy TLS for all resources,
+* secure credentials against leakage (e.g., when the client uses some form of dynamic configuration to determine where
+ to send an authenticated request), and
+* avoid the exposure of credentials sent to a malicious server over an unauthenticated secure channel due to client
+ failure to validate the server's identity as part of its TLS handshake.
+
+In addition, **Hawk** supports a method for granting third-parties temporary access to individual resources using
+a query parameter called _bewit_ (in falconry, a leather strap used to attach a tracking device to the leg of a hawk).
+
+The **Hawk** scheme requires the establishment of a shared symmetric key between the client and the server,
+which is beyond the scope of this module. Typically, the shared credentials are established via an initial
+TLS-protected phase or derived from some other shared confidential information available to both the client
+and the server.
+
+
+## Replay Protection
+
+Without replay protection, an attacker can use a compromised (but otherwise valid and authenticated) request more
+than once, gaining access to a protected resource. To mitigate this, clients include both a nonce and a timestamp when
+making requests. This gives the server enough information to prevent replay attacks.
+
+The nonce is generated by the client, and is a string unique across all requests with the same timestamp and
+key identifier combination.
+
+The timestamp enables the server to restrict the validity period of the credentials where requests occuring afterwards
+are rejected. It also removes the need for the server to retain an unbounded number of nonce values for future checks.
+By default, **Hawk** uses a time window of 1 minute to allow for time skew between the client and server (which in
+practice translates to a maximum of 2 minutes as the skew can be positive or negative).
+
+Using a timestamp requires the client's clock to be in sync with the server's clock. **Hawk** requires both the client
+clock and the server clock to use NTP to ensure synchronization. However, given the limitations of some client types
+(e.g. browsers) to deploy NTP, the server provides the client with its current time in response to a bad timestamp.
+
+There is no expectation that the client will adjust its system clock to match the server (in fact, this would be a
+potential attack vector). Instead, the client only uses the server's time to calculate an offset used only
+for communications with that particular server. The protocol rewards clients with synchronized clocks by reducing
+the number of round trips required to authenticate the first request.
+
+
+## Usage Example
+
+Server code:
+
+```javascript
+var Http = require('http');
+var Hawk = require('hawk');
+
+
+// Credentials lookup function
+
+var credentialsFunc = function (id, callback) {
+
+ var credentials = {
+ key: 'werxhqb98rpaxn39848xrunpaw3489ruxnpa98w4rxn',
+ algorithm: 'sha256',
+ user: 'Steve'
+ };
+
+ return callback(null, credentials);
+};
+
+// Create HTTP server
+
+var handler = function (req, res) {
+
+ // Authenticate incoming request
+
+ Hawk.server.authenticate(req, credentialsFunc, {}, function (err, credentials, artifacts) {
+
+ // Prepare response
+
+ var payload = (!err ? 'Hello ' + credentials.user + ' ' + artifacts.ext : 'Shoosh!');
+ var headers = { 'Content-Type': 'text/plain' };
+
+ // Generate Server-Authorization response header
+
+ var header = Hawk.server.header(artifacts, { payload: payload, contentType: headers['Content-Type'] });
+ headers['Server-Authorization'] = header;
+
+ // Send the response back
+
+ res.writeHead(!err ? 200 : 401, headers);
+ res.end(payload);
+ });
+};
+
+// Start server
+
+Http.createServer(handler).listen(8000, 'example.com');
+```
+
+Client code:
+
+```javascript
+var Request = require('request');
+var Hawk = require('hawk');
+
+
+// Client credentials
+
+var credentials = {
+ id: 'dh37fgj492je',
+ key: 'werxhqb98rpaxn39848xrunpaw3489ruxnpa98w4rxn',
+ algorithm: 'sha256'
+}
+
+// Request options
+
+var requestOptions = {
+ uri: 'http://example.com:8000/resource/1?b=1&a=2',
+ method: 'GET',
+ headers: {}
+};
+
+// Generate Authorization request header
+
+var header = Hawk.client.header('http://example.com:8000/resource/1?b=1&a=2', 'GET', { credentials: credentials, ext: 'some-app-data' });
+requestOptions.headers.Authorization = header.field;
+
+// Send authenticated request
+
+Request(requestOptions, function (error, response, body) {
+
+ // Authenticate the server's response
+
+ var isValid = Hawk.client.authenticate(response, header.artifacts, { payload: body });
+
+ // Output results
+
+ console.log(response.statusCode + ': ' + body + (isValid ? ' (valid)' : ' (invalid)'));
+});
+```
+
+**Hawk** utilized the [**SNTP**](https://github.com/hueniverse/sntp) module for time sync management. By default, the local
+machine time is used. To automatically retrieve and synchronice the clock within the application, use the SNTP 'start()' method.
+
+```javascript
+Hawk.sntp.start();
+```
+
+
+## Protocol Example
+
+The client attempts to access a protected resource without authentication, sending the following HTTP request to
+the resource server:
+
+```
+GET /resource/1?b=1&a=2 HTTP/1.1
+Host: example.com:8000
+```
+
+The resource server returns an authentication challenge.
+
+```
+HTTP/1.1 401 Unauthorized
+WWW-Authenticate: Hawk
+```
+
+The client has previously obtained a set of **Hawk** credentials for accessing resources on the "http://example.com/"
+server. The **Hawk** credentials issued to the client include the following attributes:
+
+* Key identifier: dh37fgj492je
+* Key: werxhqb98rpaxn39848xrunpaw3489ruxnpa98w4rxn
+* Algorithm: sha256
+
+The client generates the authentication header by calculating a timestamp (e.g. the number of seconds since January 1,
+1970 00:00:00 GMT), generating a nonce, and constructing the normalized request string (each value followed by a newline
+character):
+
+```
+hawk.1.header
+1353832234
+j4h3g2
+GET
+/resource?a=1&b=2
+example.com
+8000
+
+some-app-ext-data
+
+```
+
+The request MAC is calculated using HMAC with the specified hash algorithm "sha256" and the key over the normalized request string.
+The result is base64-encoded to produce the request MAC:
+
+```
+6R4rV5iE+NPoym+WwjeHzjAGXUtLNIxmo1vpMofpLAE=
+```
+
+The client includes the **Hawk** key identifier, timestamp, nonce, application specific data, and request MAC with the request using
+the HTTP `Authorization` request header field:
+
+```
+GET /resource/1?b=1&a=2 HTTP/1.1
+Host: example.com:8000
+Authorization: Hawk id="dh37fgj492je", ts="1353832234", nonce="j4h3g2", ext="some-app-ext-data", mac="6R4rV5iE+NPoym+WwjeHzjAGXUtLNIxmo1vpMofpLAE="
+```
+
+The server validates the request by calculating the request MAC again based on the request received and verifies the validity
+and scope of the **Hawk** credentials. If valid, the server responds with the requested resource.
+
+
+### Payload Validation
+
+**Hawk** provides optional payload validation. When generating the authentication header, the client calculates a payload hash
+using the specified hash algorithm. The hash is calculated over the concatenated value of (each followed by a newline character):
+* `hawk.1.payload`
+* the content-type in lowercase, without any parameters (e.g. `application/json`)
+* the request payload prior to any content encoding (the exact representation requirements should be specified by the server for payloads other than simple single-part ascii to ensure interoperability)
+
+For example:
+
+* Payload: `Thank you for flying Hawk`
+* Content Type: `text/plain`
+* Hash (sha256): `Yi9LfIIFRtBEPt74PVmbTF/xVAwPn7ub15ePICfgnuY=`
+
+Results in the following input to the payload hash function (newline terminated values):
+
+```
+hawk.1.payload
+text/plain
+Thank you for flying Hawk
+
+```
+
+Which produces the following hash value:
+
+```
+Yi9LfIIFRtBEPt74PVmbTF/xVAwPn7ub15ePICfgnuY=
+```
+
+The client constructs the normalized request string (newline terminated values):
+
+```
+hawk.1.header
+1353832234
+j4h3g2
+POST
+/resource?a=1&b=2
+example.com
+8000
+Yi9LfIIFRtBEPt74PVmbTF/xVAwPn7ub15ePICfgnuY=
+some-app-ext-data
+
+```
+
+Then calculates the request MAC and includes the **Hawk** key identifier, timestamp, nonce, payload hash, application specific data,
+and request MAC, with the request using the HTTP `Authorization` request header field:
+
+```
+POST /resource/1 HTTP/1.1
+Host: example.com:8000
+Authorization: Hawk id="dh37fgj492je", ts="1353832234", nonce="j4h3g2", hash="Yi9LfIIFRtBEPt74PVmbTF/xVAwPn7ub15ePICfgnuY=", ext="some-app-ext-data", mac="aSe1DERmZuRl3pI36/9BdZmnErTw3sNzOOAUlfeKjVw="
+```
+
+It is up to the server if and when it validates the payload for any given request, based solely on it's security policy
+and the nature of the data included.
+
+If the payload is available at the time of authentication, the server uses the hash value provided by the client to construct
+the normalized string and validates the MAC. If the MAC is valid, the server calculates the payload hash and compares the value
+with the provided payload hash in the header. In many cases, checking the MAC first is faster than calculating the payload hash.
+
+However, if the payload is not available at authentication time (e.g. too large to fit in memory, streamed elsewhere, or processed
+at a different stage in the application), the server may choose to defer payload validation for later by retaining the hash value
+provided by the client after validating the MAC.
+
+It is important to note that MAC validation does not mean the hash value provided by the client is valid, only that the value
+included in the header was not modified. Without calculating the payload hash on the server and comparing it to the value provided
+by the client, the payload may be modified by an attacker.
+
+
+## Response Payload Validation
+
+**Hawk** provides partial response payload validation. The server includes the `Server-Authorization` response header which enables the
+client to authenticate the response and ensure it is talking to the right server. **Hawk** defines the HTTP `Server-Authorization` header
+as a response header using the exact same syntax as the `Authorization` request header field.
+
+The header is contructed using the same process as the client's request header. The server uses the same credentials and other
+artifacts provided by the client to constructs the normalized request string. The `ext` and `hash` values are replaced with
+new values based on the server response. The rest as identical to those used by the client.
+
+The result MAC digest is included with the optional `hash` and `ext` values:
+
+```
+Server-Authorization: Hawk mac="XIJRsMl/4oL+nn+vKoeVZPdCHXB4yJkNnBbTbHFZUYE=", hash="f9cDF/TDm7TkYRLnGwRMfeDzT6LixQVLvrIKhh0vgmM=", ext="response-specific"
+```
+
+
+# Single URI Authorization
+
+There are cases in which limited and short-term access to a protected resource is granted to a third party which does not
+have access to the shared credentials. For example, displaying a protected image on a web page accessed by anyone. **Hawk**
+provides limited support for such URIs in the form of a _bewit_ - a URI query parameter appended to the request URI which contains
+the necessary credentials to authenticate the request.
+
+Because of the significant security risks involved in issuing such access, bewit usage is purposely limited only to GET requests
+and for a finite period of time. Both the client and server can issue bewit credentials, however, the server should not use the same
+credentials as the client to maintain clear traceability as to who issued which credentials.
+
+In order to simplify implementation, bewit credentials do not support single-use policy and can be replayed multiple times within
+the granted access timeframe.
+
+
+## Bewit Usage Example
+
+Server code:
+
+```javascript
+var Http = require('http');
+var Hawk = require('hawk');
+
+
+// Credentials lookup function
+
+var credentialsFunc = function (id, callback) {
+
+ var credentials = {
+ key: 'werxhqb98rpaxn39848xrunpaw3489ruxnpa98w4rxn',
+ algorithm: 'sha256'
+ };
+
+ return callback(null, credentials);
+};
+
+// Create HTTP server
+
+var handler = function (req, res) {
+
+ Hawk.uri.authenticate(req, credentialsFunc, {}, function (err, credentials, attributes) {
+
+ res.writeHead(!err ? 200 : 401, { 'Content-Type': 'text/plain' });
+ res.end(!err ? 'Access granted' : 'Shoosh!');
+ });
+};
+
+Http.createServer(handler).listen(8000, 'example.com');
+```
+
+Bewit code generation:
+
+```javascript
+var Request = require('request');
+var Hawk = require('hawk');
+
+
+// Client credentials
+
+var credentials = {
+ id: 'dh37fgj492je',
+ key: 'werxhqb98rpaxn39848xrunpaw3489ruxnpa98w4rxn',
+ algorithm: 'sha256'
+}
+
+// Generate bewit
+
+var duration = 60 * 5; // 5 Minutes
+var bewit = Hawk.uri.getBewit('http://example.com:8080/resource/1?b=1&a=2', { credentials: credentials, ttlSec: duration, ext: 'some-app-data' });
+var uri = 'http://example.com:8000/resource/1?b=1&a=2' + '&bewit=' + bewit;
+```
+
+
+# Security Considerations
+
+The greatest sources of security risks are usually found not in **Hawk** but in the policies and procedures surrounding its use.
+Implementers are strongly encouraged to assess how this module addresses their security requirements. This section includes
+an incomplete list of security considerations that must be reviewed and understood before deploying **Hawk** on the server.
+Many of the protections provided in **Hawk** depends on whether and how they are used.
+
+### MAC Keys Transmission
+
+**Hawk** does not provide any mechanism for obtaining or transmitting the set of shared credentials required. Any mechanism used
+to obtain **Hawk** credentials must ensure that these transmissions are protected using transport-layer mechanisms such as TLS.
+
+### Confidentiality of Requests
+
+While **Hawk** provides a mechanism for verifying the integrity of HTTP requests, it provides no guarantee of request
+confidentiality. Unless other precautions are taken, eavesdroppers will have full access to the request content. Servers should
+carefully consider the types of data likely to be sent as part of such requests, and employ transport-layer security mechanisms
+to protect sensitive resources.
+
+### Spoofing by Counterfeit Servers
+
+**Hawk** provides limited verification of the server authenticity. When receiving a response back from the server, the server
+may choose to include a response `Server-Authorization` header which the client can use to verify the response. However, it is up to
+the server to determine when such measure is included, to up to the client to enforce that policy.
+
+A hostile party could take advantage of this by intercepting the client's requests and returning misleading or otherwise
+incorrect responses. Service providers should consider such attacks when developing services using this protocol, and should
+require transport-layer security for any requests where the authenticity of the resource server or of server responses is an issue.
+
+### Plaintext Storage of Credentials
+
+The **Hawk** key functions the same way passwords do in traditional authentication systems. In order to compute the request MAC,
+the server must have access to the key in plaintext form. This is in contrast, for example, to modern operating systems, which
+store only a one-way hash of user credentials.
+
+If an attacker were to gain access to these keys - or worse, to the server's database of all such keys - he or she would be able
+to perform any action on behalf of any resource owner. Accordingly, it is critical that servers protect these keys from unauthorized
+access.
+
+### Entropy of Keys
+
+Unless a transport-layer security protocol is used, eavesdroppers will have full access to authenticated requests and request
+MAC values, and will thus be able to mount offline brute-force attacks to recover the key used. Servers should be careful to
+assign keys which are long enough, and random enough, to resist such attacks for at least the length of time that the **Hawk**
+credentials are valid.
+
+For example, if the credentials are valid for two weeks, servers should ensure that it is not possible to mount a brute force
+attack that recovers the key in less than two weeks. Of course, servers are urged to err on the side of caution, and use the
+longest key reasonable.
+
+It is equally important that the pseudo-random number generator (PRNG) used to generate these keys be of sufficiently high
+quality. Many PRNG implementations generate number sequences that may appear to be random, but which nevertheless exhibit
+patterns or other weaknesses which make cryptanalysis or brute force attacks easier. Implementers should be careful to use
+cryptographically secure PRNGs to avoid these problems.
+
+### Coverage Limitations
+
+The request MAC only covers the HTTP `Host` header and optionally the `Content-Type` header. It does not cover any other headers
+which can often affect how the request body is interpreted by the server. If the server behavior is influenced by the presence
+or value of such headers, an attacker can manipulate the request headers without being detected. Implementers should use the
+`ext` feature to pass application-specific information via the `Authorization` header which is protected by the request MAC.
+
+The response authentication, when performed, only covers the response payload, content-type, and the request information
+provided by the client in it's request (method, resource, timestamp, nonce, etc.). It does not cover the HTTP status code or
+any other response header field (e.g. Location) which can affect the client's behaviour.
+
+### Future Time Manipulation
+
+The protocol relies on a clock sync between the client and server. To accomplish this, the server informs the client of its
+current time when an invalid timestamp is received.
+
+If an attacker is able to manipulate this information and cause the client to use an incorrect time, it would be able to cause
+the client to generate authenticated requests using time in the future. Such requests will fail when sent by the client, and will
+not likely leave a trace on the server (given the common implementation of nonce, if at all enforced). The attacker will then
+be able to replay the request at the correct time without detection.
+
+The client must only use the time information provided by the server if:
+* it was delivered over a TLS connection and the server identity has been verified, or
+* the `tsm` MAC digest calculated using the same client credentials over the timestamp has been verified.
+
+### Client Clock Poisoning
+
+When receiving a request with a bad timestamp, the server provides the client with its current time. The client must never use
+the time received from the server to adjust its own clock, and must only use it to calculate an offset for communicating with
+that particular server.
+
+### Bewit Limitations
+
+Special care must be taken when issuing bewit credentials to third parties. Bewit credentials are valid until expiration and cannot
+be revoked or limited without using other means. Whatever resource they grant access to will be completely exposed to anyone with
+access to the bewit credentials which act as bearer credentials for that particular resource. While bewit usage is limited to GET
+requests only and therefore cannot be used to perform transactions or change server state, it can still be used to expose private
+and sensitive information.
+
+
+# Frequently Asked Questions
+
+### Where is the protocol specification?
+
+If you are looking for some prose explaining how all this works, **this is it**. **Hawk** is being developed as an open source
+project instead of a standard. In other words, the [code](/hueniverse/hawk/tree/master/lib) is the specification. Not sure about
+something? Open an issue!
+
+### Is it done?
+
+At if version 0.10.0, **Hawk** is feature-complete. However, until this module reaches version 1.0.0 it is considered experimental
+and is likely to change. This also means your feedback and contribution are very welcome. Feel free to open issues with questions
+and suggestions.
+
+### Where can I find **Hawk** implementations in other languages?
+
+**Hawk**'s only reference implementation is provided in JavaScript as a node.js module. However, others are actively porting it to other
+platforms. There is already a [PHP](https://github.com/alexbilbie/PHP-Hawk),
+[.NET](https://github.com/pcibraro/hawknet), and [JAVA](https://github.com/wealdtech/hawk) libraries available. The full list
+is maintained [here](https://github.com/hueniverse/hawk/issues?labels=port). Please add an issue if you are working on another
+port. A cross-platform test-suite is in the works.
+
+### Why isn't the algorithm part of the challenge or dynamically negotiated?
+
+The algorithm used is closely related to the key issued as different algorithms require different key sizes (and other
+requirements). While some keys can be used for multiple algorithm, the protocol is designed to closely bind the key and algorithm
+together as part of the issued credentials.
+
+### Why is Host and Content-Type the only headers covered by the request MAC?
+
+It is really hard to include other headers. Headers can be changed by proxies and other intermediaries and there is no
+well-established way to normalize them. Many platforms change the case of header field names and values. The only
+straight-forward solution is to include the headers in some blob (say, base64 encoded JSON) and include that with the request,
+an approach taken by JWT and other such formats. However, that design violates the HTTP header boundaries, repeats information,
+and introduces other security issues because firewalls will not be aware of these "hidden" headers. In addition, any information
+repeated must be compared to the duplicated information in the header and therefore only moves the problem elsewhere.
+
+### Why not just use HTTP Digest?
+
+Digest requires pre-negotiation to establish a nonce. This means you can't just make a request - you must first send
+a protocol handshake to the server. This pattern has become unacceptable for most web services, especially mobile
+where extra round-trip are costly.
+
+### Why bother with all this nonce and timestamp business?
+
+**Hawk** is an attempt to find a reasonable, practical compromise between security and usability. OAuth 1.0 got timestamp
+and nonces halfway right but failed when it came to scalability and consistent developer experience. **Hawk** addresses
+it by requiring the client to sync its clock, but provides it with tools to accomplish it.
+
+In general, replay protection is a matter of application-specific threat model. It is less of an issue on a TLS-protected
+system where the clients are implemented using best practices and are under the control of the server. Instead of dropping
+replay protection, **Hawk** offers a required time window and an optional nonce verification. Together, it provides developers
+with the ability to decide how to enforce their security policy without impacting the client's implementation.
+
+### What are `app` and `dlg` in the authorization header and normalized mac string?
+
+The original motivation for **Hawk** was to replace the OAuth 1.0 use cases. This included both a simple client-server mode which
+this module is specifically designed for, and a delegated access mode which is being developed separately in
+[Oz](https://github.com/hueniverse/oz). In addition to the **Hawk** use cases, Oz requires another attribute: the application id `app`.
+This provides binding between the credentials and the application in a way that prevents an attacker from tricking an application
+to use credentials issued to someone else. It also has an optional 'delegated-by' attribute `dlg` which is the application id of the
+application the credentials were directly issued to. The goal of these two additions is to allow Oz to utilize **Hawk** directly,
+but with the additional security of delegated credentials.
+
+### What is the purpose of the static strings used in each normalized MAC input?
+
+When calculating a hash or MAC, a static prefix (tag) is added. The prefix is used to prevent MAC values from being
+used or reused for a purpose other than what they were created for (i.e. prevents switching MAC values between a request,
+response, and a bewit use cases). It also protects against expliots created after a potential change in how the protocol
+creates the normalized string. For example, if a future version would switch the order of nonce and timestamp, it
+can create an exploit opportunity for cases where the nonce is similar in format to a timestamp.
+
+### Does **Hawk** have anything to do with OAuth?
+
+Short answer: no.
+
+**Hawk** was originally proposed as the OAuth MAC Token specification. However, the OAuth working group in its consistent
+incompetence failed to produce a final, usable solution to address one of the most popular use cases of OAuth 1.0 - using it
+to authenticate simple client-server transactions (i.e. two-legged). As you can guess, the OAuth working group is still hard
+at work to produce more garbage.
+
+**Hawk** provides a simple HTTP authentication scheme for making client-server requests. It does not address the OAuth use case
+of delegating access to a third party. If you are looking for an OAuth alternative, check out [Oz](/hueniverse/oz).
+
+
+# Acknowledgements
+
+**Hawk** is a derivative work of the [HTTP MAC Authentication Scheme](http://tools.ietf.org/html/draft-hammer-oauth-v2-mac-token-05) proposal
+co-authored by Ben Adida, Adam Barth, and Eran Hammer, which in turn was based on the OAuth 1.0 community specification.
+
+Special thanks to Ben Laurie for his always insightful feedback and advice.
+
+The **Hawk** logo was created by [Chris Carrasco](http://chriscarrasco.com).
diff --git a/deps/npm/node_modules/request/node_modules/hawk/example/usage.js b/deps/npm/node_modules/request/node_modules/hawk/example/usage.js
new file mode 100755
index 00000000000..1f78f9a56e1
--- /dev/null
+++ b/deps/npm/node_modules/request/node_modules/hawk/example/usage.js
@@ -0,0 +1,77 @@
+// Load modules
+
+var Http = require('http');
+var Request = require('request');
+var Hawk = require('../lib');
+
+
+// Declare internals
+
+var internals = {
+ credentials: {
+ dh37fgj492je: {
+ id: 'dh37fgj492je', // Required by Hawk.client.header
+ key: 'werxhqb98rpaxn39848xrunpaw3489ruxnpa98w4rxn',
+ algorithm: 'sha256',
+ user: 'Steve'
+ }
+ }
+};
+
+
+// Credentials lookup function
+
+var credentialsFunc = function (id, callback) {
+
+ return callback(null, internals.credentials[id]);
+};
+
+
+// Create HTTP server
+
+var handler = function (req, res) {
+
+ Hawk.server.authenticate(req, credentialsFunc, {}, function (err, credentials, artifacts) {
+
+ var payload = (!err ? 'Hello ' + credentials.user + ' ' + artifacts.ext : 'Shoosh!');
+ var headers = {
+ 'Content-Type': 'text/plain',
+ 'Server-Authorization': Hawk.server.header(artifacts, { payload: payload, contentType: 'text/plain' })
+ };
+
+ res.writeHead(!err ? 200 : 401, headers);
+ res.end(payload);
+ });
+};
+
+Http.createServer(handler).listen(8000, '127.0.0.1');
+
+
+// Send unauthenticated request
+
+Request('http://127.0.0.1:8000/resource/1?b=1&a=2', function (error, response, body) {
+
+ console.log(response.statusCode + ': ' + body);
+});
+
+
+// Send authenticated request
+
+var header = Hawk.client.header('http://127.0.0.1:8000/resource/1?b=1&a=2', 'GET', { credentials: internals.credentials.dh37fgj492je, ext: 'and welcome!' });
+var options = {
+ uri: 'http://127.0.0.1:8000/resource/1?b=1&a=2',
+ method: 'GET',
+ headers: {
+ authorization: header.field
+ }
+};
+
+
+Request(options, function (error, response, body) {
+
+ var isValid = Hawk.client.authenticate(response, header.artifacts, { payload: body });
+ console.log(response.statusCode + ': ' + body + (isValid ? ' (valid)' : ' (invalid)'));
+ process.exit(0);
+});
+
+
diff --git a/deps/npm/node_modules/request/node_modules/hawk/images/hawk.png b/deps/npm/node_modules/request/node_modules/hawk/images/hawk.png
new file mode 100755
index 0000000000000000000000000000000000000000..a0e15cda0144a7d7ed222e74a2ea4afbab32555c
GIT binary patch
literal 6945
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