diff options
Diffstat (limited to 'deps/npm/node_modules/npm-profile/node_modules/socks')
10 files changed, 945 insertions, 0 deletions
diff --git a/deps/npm/node_modules/npm-profile/node_modules/socks/.npmignore b/deps/npm/node_modules/npm-profile/node_modules/socks/.npmignore new file mode 100644 index 0000000000..7deddced8b --- /dev/null +++ b/deps/npm/node_modules/npm-profile/node_modules/socks/.npmignore @@ -0,0 +1,4 @@ +node_modules +.git* +.idea +npm-debug.log
\ No newline at end of file diff --git a/deps/npm/node_modules/npm-profile/node_modules/socks/LICENSE b/deps/npm/node_modules/npm-profile/node_modules/socks/LICENSE new file mode 100644 index 0000000000..b2442a9e71 --- /dev/null +++ b/deps/npm/node_modules/npm-profile/node_modules/socks/LICENSE @@ -0,0 +1,20 @@ +The MIT License (MIT) + +Copyright (c) 2013 Josh Glazebrook + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/deps/npm/node_modules/npm-profile/node_modules/socks/README.md b/deps/npm/node_modules/npm-profile/node_modules/socks/README.md new file mode 100644 index 0000000000..890b7deb6a --- /dev/null +++ b/deps/npm/node_modules/npm-profile/node_modules/socks/README.md @@ -0,0 +1,339 @@ +socks +============= + +socks is a full client implementation of the SOCKS 4, 4a, and 5 protocols in an easy to use node.js module. + +### Notice +As of February 26th, 2015, socks is the new home of the socks-client package. + +### Why socks? + +There is not any other SOCKS proxy client library on npm that supports all three variants of the SOCKS protocol. Nor are there any that support the BIND and associate features that some versions of the SOCKS protocol supports. + +Key Features: +* Supports SOCKS 4, 4a, and 5 protocols +* Supports the connect method (simple tcp connections of SOCKS) (Client -> SOCKS Server -> Target Server) +* Supports the BIND method (4, 4a, 5) +* Supports the associate (UDP forwarding) method (5) +* Simple and easy to use (one function call to make any type of SOCKS connection) + +## Installing: + +`npm install socks` + +### Getting Started Example + +For this example, say you wanted to grab the html of google's home page. + +```javascript +var Socks = require('socks'); + +var options = { + proxy: { + ipaddress: "202.101.228.108", // Random public proxy + port: 1080, + type: 5 // type is REQUIRED. Valid types: [4, 5] (note 4 also works for 4a) + }, + target: { + host: "google.com", // can be an ip address or domain (4a and 5 only) + port: 80 + }, + command: 'connect' // This defaults to connect, so it's optional if you're not using BIND or Associate. +}; + +Socks.createConnection(options, function(err, socket, info) { + if (err) + console.log(err); + else { + // Connection has been established, we can start sending data now: + socket.write("GET / HTTP/1.1\nHost: google.com\n\n"); + socket.on('data', function(data) { + console.log(data.length); + console.log(data); + }); + + // PLEASE NOTE: sockets need to be resumed before any data will come in or out as they are paused right before this callback is fired. + socket.resume(); + + // 569 + // <Buffer 48 54 54 50 2f 31 2e 31 20 33 30 31 20 4d 6f 76 65 64 20 50 65... + } +}); +``` + +### BIND Example: + +When sending the BIND command to a SOCKS proxy server, this will cause the proxy server to open up a new tcp port. Once this port is open, you, another client, application, etc, can then connect to the SOCKS proxy on that tcp port and communications will be forwarded to each connection through the proxy itself. + +```javascript +var options = { + proxy: { + ipaddress: "202.101.228.108", + port: 1080, + type: 4, + command: "bind" // Since we are using bind, we must specify it here. + }, + target: { + host: "1.2.3.4", // When using bind, it's best to give an estimation of the ip that will be connecting to the newly opened tcp port on the proxy server. + port: 1080 + } +}; + +Socks.createConnection(options, function(err, socket, info) { + if (err) + console.log(err); + else { + // BIND request has completed. + // info object contains the remote ip and newly opened tcp port to connect to. + console.log(info); + + // { port: 1494, host: '202.101.228.108' } + + socket.on('data', function(data) { + console.log(data.length); + console.log(data); + }); + + // Remember to resume the socket stream. + socket.resume(); + } +}); + +``` +At this point, your original connection to the proxy server remains open, and no data will be received until a tcp connection is made to the given endpoint in the info object. + +For an example, I am going to connect to the endpoint with telnet: + +``` +Joshs-MacBook-Pro:~ Josh$ telnet 202.101.228.108 1494 + Trying 202.101.228.108... + Connected to 202.101.228.108. + Escape character is '^]'. + hello + aaaaaaaaa +``` + +Note that this connection to the newly bound port does not need to go through the SOCKS handshake. + +Back at our original connection we see that we have received some new data: + +``` +8 +<Buffer 00 5a ca 61 43 a8 09 01> // This first piece of information can be ignored. + +7 +<Buffer 68 65 6c 6c 6f 0d 0a> // Hello <\r\n (enter key)> + +11 +<Buffer 61 61 61 61 61 61 61 61 61 0d 0a> // aaaaaaaaa <\r\n (enter key)> +``` + +As you can see the data entered in the telnet terminal is routed through the SOCKS proxy and back to the original connection that was made to the proxy. + +**Note** Please pay close attention to the first piece of data that was received. + +``` +<Buffer 00 5a ca 61 43 a8 09 01> + + [005a] [PORT:2} [IP:4] +``` + +This piece of data is technically part of the SOCKS BIND specifications, but because of my design decisions that were made in an effort to keep this library simple to use, you will need to make sure to ignore and/or deal with this initial packet that is received when a connection is made to the newly opened port. + +### Associate Example: +The associate command sets up a UDP relay for the remote SOCKS proxy server to relay UDP packets to the remote host of your choice. + +```javascript +var options = { + proxy: { + ipaddress: "202.101.228.108", + port: 1080, + type: 5, + command: "associate" // Since we are using associate, we must specify it here. + }, + target: { + // When using associate, either set the ip and port to 0.0.0.0:0 or the expected source of incoming udp packets. + // Note: Some SOCKS servers MAY block associate requests with 0.0.0.0:0 endpoints. + // Note: ipv4, ipv6, and hostnames are supported here. + host: "0.0.0.0", + port: 0 + } +}; + + +Socks.createConnection(options, function(err, socket, info) { + if (err) + console.log(err); + else { + // Associate request has completed. + // info object contains the remote ip and udp port to send UDP packets to. + console.log(info); + // { port: 42803, host: '202.101.228.108' } + + var udp = new dgram.Socket('udp4'); + + // In this example we are going to send "Hello" to 1.2.3.4:2323 through the SOCKS proxy. + + var pack = Socks.createUDPFrame({ host: "1.2.3.4", port: 2323}, new Buffer("hello")); + + // Send Packet to Proxy UDP endpoint given in the info object. + udp.send(pack, 0, pack.length, info.port, info.host); + } +}); + +``` +Now assuming that the associate request went through correctly. Anything that is typed in the stdin will first be sent to the SOCKS proxy on the endpoint that was provided in the info object. Once the SOCKS proxy receives it, it will then forward on the actual UDP packet to the host you you wanted. + + +1.2.3.4:2323 should now receive our relayed UDP packet from 202.101.228.108 (SOCKS proxy) +``` +// <Buffer 68 65 6c 6c 6f> +``` + +## Using socks as an HTTP Agent + +You can use socks as a http agent which will relay all your http +connections through the socks server. + +The object that `Socks.Agent` accepts is the same as `Socks.createConnection`, you don't need to set a target since you have to define it in `http.request` or `http.get` methods. + +The second argument is a boolean which indicates whether the remote endpoint requires TLS. + +```javascript +var socksAgent = new Socks.Agent({ + proxy: { + ipaddress: "202.101.228.108", + port: 1080, + type: 5, + }}, + true, // we are connecting to a HTTPS server, false for HTTP server + false // rejectUnauthorized option passed to tls.connect(). Only when secure is set to true +); + +http.get({ hostname: 'google.com', port: '443', agent: socksAgent}, function (res) { + // Connection header by default is keep-alive, we have to manually end the socket + socksAgent.encryptedSocket.end(); +}); +``` + +# Api Reference: + +There are only three exported functions that you will ever need to use. + +### Socks.createConnection( options, callback(err, socket, info) ) +> `Object` **Object containing options to use when creating this connection** + +> `function` **Callback that is called when connection completes or errors** + +Options: + +```javascript +var options = { + + // Information about proxy server + proxy: { + // IP Address of Proxy (Required) + ipaddress: "1.2.3.4", + + // TCP Port of Proxy (Required) + port: 1080, + + // Proxy Type [4, 5] (Required) + // Note: 4 works for both 4 and 4a. + type: 4, + + // SOCKS Connection Type (Optional) + // - defaults to 'connect' + + // 'connect' - establishes a regular SOCKS connection to the target host. + // 'bind' - establishes an open tcp port on the SOCKS for another client to connect to. + // 'associate' - establishes a udp association relay on the SOCKS server. + command: "connect", + + + // SOCKS 4 Specific: + + // UserId used when making a SOCKS 4/4a request. (Optional) + userid: "someuserid", + + // SOCKS 5 Specific: + + // Authentication used for SOCKS 5 (when it's required) (Optional) + authentication: { + username: "Josh", + password: "somepassword" + } + }, + + // Information about target host and/or expected client of a bind association. (Required) + target: { + // When using 'connect': IP Address or hostname (4a and 5 only) of a target to connect to. + // When using 'bind': IP Address of the expected client that will connect to the newly open tcp port. + // When using 'associate': IP Address and Port of the expected client that will send UDP packets to this UDP association relay. + + // Note: + // When using SOCKS 4, only an ipv4 address can be used. + // When using SOCKS 4a, an ipv4 address OR a hostname can be used. + // When using SOCKS 5, ipv4, ipv6, or a hostname can be used. + host: "1.2.3.4", + + // TCP port of target to connect to. + port: 1080 + }, + + // Amount of time to wait for a connection to be established. (Optional) + // - defaults to 10000ms (10 seconds) + timeout: 10000 +}; +``` +Callback: + +```javascript + +// err: If an error occurs, err will be an Error object, otherwise null. +// socket: Socket with established connection to your target host. +// info: If using BIND or associate, this will be the remote endpoint to use. + +function(err, socket, info) { + // Hopefully no errors :-) +} +``` + +### Socks.createUDPFrame( target, data, [frame] ) +> `Object` **Target host object containing destination for UDP packet** + +> `Buffer` **Data Buffer to send in the UDP packet** + +> `Number` **Frame number in UDP packet. (defaults to 0)** + +Creates a UDP packet frame for using with UDP association relays. + +returns `Buffer` The completed UDP packet container to be sent to the proxy for forwarding. + +target: +```javascript + +// Target host information for where the UDP packet should be sent. +var target = + { + // ipv4, ipv6, or hostname for where to have the proxy send the UDP packet. + host: "1.2.3.4", + + // udpport for where to send the UDP packet. + port: 2323 + } + +``` + +### Socks.Agent( options, tls) ) +> `Object` **Object containing options to use when creating this connection (see above in createConnection)** + +> `boolean` **Boolean indicating if we upgrade the connection to TLS on the socks server** + + +# Further Reading: +Please read the SOCKS 5 specifications for more information on how to use BIND and Associate. +http://www.ietf.org/rfc/rfc1928.txt + +# License +This work is licensed under the [MIT license](http://en.wikipedia.org/wiki/MIT_License). diff --git a/deps/npm/node_modules/npm-profile/node_modules/socks/examples/associate.js b/deps/npm/node_modules/npm-profile/node_modules/socks/examples/associate.js new file mode 100644 index 0000000000..82d6afa97b --- /dev/null +++ b/deps/npm/node_modules/npm-profile/node_modules/socks/examples/associate.js @@ -0,0 +1,33 @@ +var Socks = require('../index.js'); +var dgram = require('dgram'); + +var options = { + proxy: { + ipaddress: "202.101.228.108", + port: 1080, + type: 5, + command: 'associate' + }, + + target: { + host: "0.0.0.0", + port: 0 + } +}; + +Socks.createConnection(options, function(err, socket, info) { + if (err) + console.log(err); + else { + console.log("Connected"); + + // Associate request completed. + // Now we can send properly formed UDP packet frames to this endpoint for forwarding: + console.log(info); + // { port: 4381, host: '202.101.228.108' } + + var udp = new dgram.Socket('udp4'); + var packet = SocksClient.createUDPFrame({ host: "1.2.3.4", port: 5454}, new Buffer("Hello")); + udp.send(packet, 0, packet.length, info.port, info.host); + } +});
\ No newline at end of file diff --git a/deps/npm/node_modules/npm-profile/node_modules/socks/examples/bind.js b/deps/npm/node_modules/npm-profile/node_modules/socks/examples/bind.js new file mode 100644 index 0000000000..4410dd1def --- /dev/null +++ b/deps/npm/node_modules/npm-profile/node_modules/socks/examples/bind.js @@ -0,0 +1,30 @@ +var Socks = require('../index.js'); + +var options = { + proxy: { + ipaddress: "202.101.228.108", + port: 1080, + type: 5, + command: 'bind' + }, + + target: { + host: "0.0.0.0", + port: 0 + } +}; + +Socks.createConnection(options, function(err, socket, info) { + if (err) + console.log(err); + else { + console.log("Connected"); + + // BIND request completed, now a tcp client should connect to this endpoint: + console.log(info); + // { port: 3334, host: '202.101.228.108' } + + // Resume! You need to! + socket.resume(); + } +});
\ No newline at end of file diff --git a/deps/npm/node_modules/npm-profile/node_modules/socks/examples/connect.js b/deps/npm/node_modules/npm-profile/node_modules/socks/examples/connect.js new file mode 100644 index 0000000000..528ad4d416 --- /dev/null +++ b/deps/npm/node_modules/npm-profile/node_modules/socks/examples/connect.js @@ -0,0 +1,31 @@ +var Socks = require('../index.js'); + +var options = { + proxy: { + ipaddress: "31.193.133.9", + port: 1081, + type: 5 // (4 or 5) + }, + + target: { + host: "173.194.33.103", // (google.com) + port: 80 + } +}; + +Socks.createConnection(options, function (err, socket, info) { + if (err) + console.log(err); + else { + console.log("Connected"); + + socket.on('data', function (data) { + // do something with incoming data + }); + + // Please remember that sockets need to be resumed before any data will come in. + socket.resume(); + + // We can do whatever we want with the socket now. + } +});
\ No newline at end of file diff --git a/deps/npm/node_modules/npm-profile/node_modules/socks/index.js b/deps/npm/node_modules/npm-profile/node_modules/socks/index.js new file mode 100644 index 0000000000..29331d4a1c --- /dev/null +++ b/deps/npm/node_modules/npm-profile/node_modules/socks/index.js @@ -0,0 +1,6 @@ +var SocksClient = require('./lib/socks-client.js'); +var SocksAgent = require('./lib/socks-agent.js'); + +exports.createConnection = SocksClient.createConnection; +exports.createUDPFrame = SocksClient.createUDPFrame; +exports.Agent = SocksAgent.Agent; diff --git a/deps/npm/node_modules/npm-profile/node_modules/socks/lib/socks-agent.js b/deps/npm/node_modules/npm-profile/node_modules/socks/lib/socks-agent.js new file mode 100644 index 0000000000..db1c301ec9 --- /dev/null +++ b/deps/npm/node_modules/npm-profile/node_modules/socks/lib/socks-agent.js @@ -0,0 +1,108 @@ +var tls = require('tls'); +var inherits = require('util').inherits; +var EventEmitter = require('events').EventEmitter; +var SocksClient = require('./socks-client.js'); + +function SocksAgent(options, secure, rejectUnauthorized) { + this.options = options; + this.secure = secure || false; + this.rejectUnauthorized = rejectUnauthorized; + + if (this.rejectUnauthorized === undefined) { + this.rejectUnauthorized = true; + } +} + +inherits(SocksAgent, EventEmitter); + +SocksAgent.prototype.createConnection = function(req, opts, fn) { + var handler = fn, host, self = this; + + this.options.target = this.options.target || {}; + + if (!this.options.target.host) { + this.options.target.host = opts.host; + } + + if (!this.options.target.port) { + this.options.target.port = opts.port; + } + + host = this.options.target.host; + + if (this.secure) { + handler = function(err, socket, info) { + var options, cleartext; + + if (err) { + return fn(err); + } + + // save encrypted socket + self.encryptedSocket = socket; + + options = { + socket: socket, + servername: host, + rejectUnauthorized: self.rejectUnauthorized + }; + + cleartext = tls.connect(options, function (err) { + return fn(err, this); + }); + cleartext.on('error', fn); + + socket.resume(); + } + } + + SocksClient.createConnection(this.options, handler); +}; + +/** + * @see https://www.npmjs.com/package/agent-base + */ +SocksAgent.prototype.addRequest = function(req, host, port, localAddress) { + var opts; + if ('object' === typeof host) { + // >= v0.11.x API + opts = host; + if (opts.host && opts.path) { + // if both a `host` and `path` are specified then it's most likely the + // result of a `url.parse()` call... we need to remove the `path` portion so + // that `net.connect()` doesn't attempt to open that as a unix socket file. + delete opts.path; + } + } else { + // <= v0.10.x API + opts = { host: host, port: port }; + if (null !== localAddress) { + opts.localAddress = localAddress; + } + } + + var sync = true; + + this.createConnection(req, opts, function (err, socket) { + function emitErr () { + req.emit('error', err); + } + if (err) { + if (sync) { + // need to defer the "error" event, when sync, because by now the `req` + // instance hasn't event been passed back to the user yet... + process.nextTick(emitErr); + } else { + emitErr(); + } + } else { + req.onSocket(socket); + //have to resume this socket when node 12 + socket.resume(); + } + }); + + sync = false; +}; + +exports.Agent = SocksAgent; diff --git a/deps/npm/node_modules/npm-profile/node_modules/socks/lib/socks-client.js b/deps/npm/node_modules/npm-profile/node_modules/socks/lib/socks-client.js new file mode 100644 index 0000000000..4a31f62c32 --- /dev/null +++ b/deps/npm/node_modules/npm-profile/node_modules/socks/lib/socks-client.js @@ -0,0 +1,306 @@ +var net = require('net'); +var ip = require('ip'); +var SmartBuffer = require('smart-buffer'); + +(function () { + + var COMMAND = { + Connect: 0x01, + Bind: 0x02, + Associate: 0x03 + }; + + var SOCKS4_RESPONSE = { + Granted: 0x5A, + Failed: 0x5B, + Rejected: 0x5C, + RejectedIdent: 0x5D + }; + + var SOCKS5_AUTH = { + NoAuth: 0x00, + GSSApi: 0x01, + UserPass: 0x02 + }; + + var SOCKS5_RESPONSE = { + Granted: 0x00, + Failure: 0x01, + NotAllowed: 0x02, + NetworkUnreachable: 0x03, + HostUnreachable: 0x04, + ConnectionRefused: 0x05, + TTLExpired: 0x06, + CommandNotSupported: 0x07, + AddressNotSupported: 0x08 + }; + + + exports.createConnection = function (options, callback) { + var socket = new net.Socket(), finished = false, buff = new SmartBuffer(); + + // Defaults + options.timeout = options.timeout || 10000; + options.proxy.command = commandFromString(options.proxy.command); + options.proxy.userid = options.proxy.userid || ""; + + var auth = options.proxy.authentication || {}; + auth.username = auth.username || ""; + auth.password = auth.password || ""; + + options.proxy.authentication = auth; + + // Connect & negotiation timeout + function onTimeout() { + finish(new Error("Connection Timed Out"), socket, null, callback); + } + socket.setTimeout(options.timeout, onTimeout); + + // Socket events + socket.once('close', function () { + finish(new Error("Socket Closed"), socket, null, callback); + }); + + socket.once('error', function (err) { + }); + + socket.once('connect', function () { + if (options.proxy.type === 4) { + negotiateSocks4(options, socket, callback); + } else if (options.proxy.type === 5) { + negotiateSocks5(options, socket, callback); + } else { + throw new Error("Please specify a proxy type in options.proxy.type"); + } + }); + + socket.connect(options.proxy.port, options.proxy.ipaddress); + + + // 4/4a (connect, bind) - Supports domains & ipaddress + function negotiateSocks4(options, socket, callback) { + buff.writeUInt8(0x04); + buff.writeUInt8(options.proxy.command); + buff.writeUInt16BE(options.target.port); + + // ipv4 or domain? + if (net.isIPv4(options.target.host)) { + buff.writeBuffer(ip.toBuffer(options.target.host)); + buff.writeStringNT(options.proxy.userid); + } else { + buff.writeUInt8(0x00); + buff.writeUInt8(0x00); + buff.writeUInt8(0x00); + buff.writeUInt8(0x01); + buff.writeStringNT(options.proxy.userid); + buff.writeStringNT(options.target.host); + } + + socket.once('data', receivedResponse); + socket.write(buff.toBuffer()); + + function receivedResponse(data) { + socket.pause(); + if (data.length === 8 && data[1] === SOCKS4_RESPONSE.Granted) { + + if (options.proxy.command === COMMAND.Bind) { + buff.clear(); + buff.writeBuffer(data); + buff.skip(2); + + var info = { + port: buff.readUInt16BE(), + host: buff.readUInt32BE() + }; + + if (info.host === 0) { + info.host = options.proxy.ipaddress; + } else { + info.host = ip.fromLong(info.host); + } + + finish(null, socket, info, callback); + } else { + finish(null, socket, null, callback); + } + + } else { + finish(new Error("Rejected (" + data[1] + ")"), socket, null, callback); + } + } + } + + // Socks 5 (connect, bind, associate) - Supports domains and ipv4, ipv6. + function negotiateSocks5(options, socket, callback) { + buff.writeUInt8(0x05); + buff.writeUInt8(2); + buff.writeUInt8(SOCKS5_AUTH.NoAuth); + buff.writeUInt8(SOCKS5_AUTH.UserPass); + + socket.once('data', handshake); + socket.write(buff.toBuffer()); + + function handshake(data) { + if (data.length !== 2) { + finish(new Error("Negotiation Error"), socket, null, callback); + } else if (data[0] !== 0x05) { + finish(new Error("Negotiation Error (invalid version)"), socket, null, callback); + } else if (data[1] === 0xFF) { + finish(new Error("Negotiation Error (unacceptable authentication)"), socket, null, callback); + } else { + if (data[1] === SOCKS5_AUTH.NoAuth) { + sendRequest(); + } else if (data[1] === SOCKS5_AUTH.UserPass) { + sendAuthentication(options.proxy.authentication); + } else { + finish(new Error("Negotiation Error (unknown authentication type)"), socket, null, callback); + } + } + } + + function sendAuthentication(authinfo) { + buff.clear(); + buff.writeUInt8(0x01); + buff.writeUInt8(Buffer.byteLength(authinfo.username)); + buff.writeString(authinfo.username); + buff.writeUInt8(Buffer.byteLength(authinfo.password)); + buff.writeString(authinfo.password); + + socket.once('data', authenticationResponse); + socket.write(buff.toBuffer()); + + function authenticationResponse(data) { + if (data.length === 2 && data[1] === 0x00) { + sendRequest(); + } else { + finish(new Error("Negotiation Error (authentication failed)"), socket, null, callback); + } + } + } + + function sendRequest() { + buff.clear(); + buff.writeUInt8(0x05); + buff.writeUInt8(options.proxy.command); + buff.writeUInt8(0x00); + + // ipv4, ipv6, domain? + if (net.isIPv4(options.target.host)) { + buff.writeUInt8(0x01); + buff.writeBuffer(ip.toBuffer(options.target.host)); + } else if (net.isIPv6(options.target.host)) { + buff.writeUInt8(0x04); + buff.writeBuffer(ip.toBuffer(options.target.host)); + } else { + buff.writeUInt8(0x03); + buff.writeUInt8(options.target.host.length); + buff.writeString(options.target.host); + } + buff.writeUInt16BE(options.target.port); + + socket.once('data', receivedResponse); + socket.write(buff.toBuffer()); + } + + function receivedResponse(data) { + socket.pause(); + if (data.length < 4) { + finish(new Error("Negotiation Error"), socket, null, callback); + } else if (data[0] === 0x05 && data[1] === SOCKS5_RESPONSE.Granted) { + if (options.proxy.command === COMMAND.Connect) { + finish(null, socket, null, callback); + } else if (options.proxy.command === COMMAND.Bind || options.proxy.command === COMMAND.Associate) { + buff.clear(); + buff.writeBuffer(data); + buff.skip(3); + + var info = {}; + var addrtype = buff.readUInt8(); + + try { + + if (addrtype === 0x01) { + info.host = buff.readUInt32BE(); + if (info.host === 0) + info.host = options.proxy.ipaddress; + else + info.host = ip.fromLong(info.host); + } else if (addrtype === 0x03) { + var len = buff.readUInt8(); + info.host = buff.readString(len); + } else if (addrtype === 0x04) { + info.host = buff.readBuffer(16); + } else { + finish(new Error("Negotiation Error (invalid host address)"), socket, null, callback); + } + info.port = buff.readUInt16BE(); + + finish(null, socket, info, callback); + } catch (ex) { + finish(new Error("Negotiation Error (missing data)"), socket, null, callback); + } + } + } else { + finish(new Error("Negotiation Error (" + data[1] + ")"), socket, null, callback); + } + } + } + + function finish(err, socket, info, callback) { + socket.setTimeout(0, onTimeout); + if (!finished) { + finished = true; + + if (buff instanceof SmartBuffer) + buff.destroy(); + + if (err && socket instanceof net.Socket) { + socket.removeAllListeners('close'); + socket.removeAllListeners('timeout'); + socket.removeAllListeners('data'); + socket.destroy(); + socket = null; + } + + callback(err, socket, info); + } + } + + function commandFromString(str) { + var result = COMMAND.Connect; + + if (str === "connect") { + result = COMMAND.Connect; + } else if (str === 'associate') { + result = COMMAND.Associate; + } else if (str === 'bind') { + result = COMMAND.Bind; + } + + return result; + } + }; + + + exports.createUDPFrame = function (target, data, frame) { + var buff = new SmartBuffer(); + buff.writeUInt16BE(0); + buff.writeUInt8(frame || 0x00); + + if (net.isIPv4(target.host)) { + buff.writeUInt8(0x01); + buff.writeUInt32BE(ip.toLong(target.host)); + } else if (net.isIPv6(target.host)) { + buff.writeUInt8(0x04); + buff.writeBuffer(ip.toBuffer(target.host)); + } else { + buff.writeUInt8(0x03); + buff.writeUInt8(Buffer.byteLength(target.host)); + buff.writeString(target.host); + } + + buff.writeUInt16BE(target.port); + buff.writeBuffer(data); + return buff.toBuffer(); + }; +})(); diff --git a/deps/npm/node_modules/npm-profile/node_modules/socks/package.json b/deps/npm/node_modules/npm-profile/node_modules/socks/package.json new file mode 100644 index 0000000000..fcd2d16852 --- /dev/null +++ b/deps/npm/node_modules/npm-profile/node_modules/socks/package.json @@ -0,0 +1,68 @@ +{ + "_from": "socks@^1.1.10", + "_id": "socks@1.1.10", + "_inBundle": false, + "_integrity": "sha1-W4t/x8jzQcU+0FbpKbe/Tei6e1o=", + "_location": "/npm-profile/socks", + "_phantomChildren": {}, + "_requested": { + "type": "range", + "registry": true, + "raw": "socks@^1.1.10", + "name": "socks", + "escapedName": "socks", + "rawSpec": "^1.1.10", + "saveSpec": null, + "fetchSpec": "^1.1.10" + }, + "_requiredBy": [ + "/npm-profile/socks-proxy-agent" + ], + "_resolved": "https://registry.npmjs.org/socks/-/socks-1.1.10.tgz", + "_shasum": "5b8b7fc7c8f341c53ed056e929b7bf4de8ba7b5a", + "_spec": "socks@^1.1.10", + "_where": "/Users/rebecca/code/npm/node_modules/npm-profile/node_modules/socks-proxy-agent", + "author": { + "name": "Josh Glazebrook" + }, + "bugs": { + "url": "https://github.com/JoshGlazebrook/socks/issues" + }, + "bundleDependencies": false, + "contributors": [ + { + "name": "Samuel Gordalina" + } + ], + "dependencies": { + "ip": "^1.1.4", + "smart-buffer": "^1.0.13" + }, + "deprecated": false, + "description": "A SOCKS proxy client supporting SOCKS 4, 4a, and 5. (also supports BIND/Associate)", + "engines": { + "node": ">= 0.10.0", + "npm": ">= 1.3.5" + }, + "homepage": "https://github.com/JoshGlazebrook/socks", + "keywords": [ + "socks", + "proxy", + "client", + "tor", + "bind", + "associate", + "socks 4", + "socks 4a", + "socks 5", + "agent" + ], + "license": "MIT", + "main": "index.js", + "name": "socks", + "repository": { + "type": "git", + "url": "git+https://github.com/JoshGlazebrook/socks.git" + }, + "version": "1.1.10" +} |