dgbuilder/dgeflows/node_modules/express/node_modules/proxy-addr/index.js

   1 /*!
   2  * proxy-addr
   3  * Copyright(c) 2014 Douglas Christopher Wilson
   4  * MIT Licensed
   5  */
   6
   7 /**
   8  * Module exports.
   9  */
  10
  11 module.exports = proxyaddr;
  12 module.exports.all = alladdrs;
  13 module.exports.compile = compile;
  14
  15 /**
  16  * Module dependencies.
  17  */
  18
  19 var forwarded = require('forwarded');
  20 var ipaddr = require('ipaddr.js');
  21
  22 /**
  23  * Variables.
  24  */
  25
  26 var digitre = /^[0-9]+$/;
  27 var isip = ipaddr.isValid;
  28 var parseip = ipaddr.parse;
  29
  30 /**
  31  * Pre-defined IP ranges.
  32  */
  33
  34 var ipranges = {
  35   linklocal: ['169.254.0.0/16', 'fe80::/10'],
  36   loopback: ['127.0.0.1/8', '::1/128'],
  37   uniquelocal: ['10.0.0.0/8', '172.16.0.0/12', '192.168.0.0/16', 'fc00::/7']
  38 };
  39
  40 /**
  41  * Get all addresses in the request, optionally stopping
  42  * at the first untrusted.
  43  *
  44  * @param {Object} request
  45  * @param {Function|Array|String} [trust]
  46  * @api public
  47  */
  48
  49 function alladdrs(req, trust) {
  50   // get addresses
  51   var addrs = forwarded(req);
  52
  53   if (!trust) {
  54     // Return all addresses
  55     return addrs;
  56   }
  57
  58   if (typeof trust !== 'function') {
  59     trust = compile(trust);
  60   }
  61
  62   for (var i = 0; i < addrs.length - 1; i++) {
  63     if (trust(addrs[i], i)) continue;
  64
  65     addrs.length = i + 1;
  66   }
  67
  68   return addrs;
  69 }
  70
  71 /**
  72  * Compile argument into trust function.
  73  *
  74  * @param {Array|String} val
  75  * @api private
  76  */
  77
  78 function compile(val) {
  79   if (!val) {
  80     throw new TypeError('argument is required');
  81   }
  82
  83   var trust = typeof val === 'string'
  84     ? [val]
  85     : val;
  86
  87   if (!Array.isArray(trust)) {
  88     throw new TypeError('unsupported trust argument');
  89   }
  90
  91   for (var i = 0; i < trust.length; i++) {
  92     val = trust[i];
  93
  94     if (!ipranges.hasOwnProperty(val)) {
  95       continue;
  96     }
  97
  98     // Splice in pre-defined range
  99     val = ipranges[val];
 100     trust.splice.apply(trust, [i, 1].concat(val));
 101     i += val.length - 1;
 102   }
 103
 104   return compileTrust(compileRangeSubnets(trust));
 105 }
 106
 107 /**
 108  * Compile `arr` elements into range subnets.
 109  *
 110  * @param {Array} arr
 111  * @api private
 112  */
 113
 114 function compileRangeSubnets(arr) {
 115   var rangeSubnets = new Array(arr.length);
 116
 117   for (var i = 0; i < arr.length; i++) {
 118     rangeSubnets[i] = parseipNotation(arr[i]);
 119   }
 120
 121   return rangeSubnets;
 122 }
 123
 124 /**
 125  * Compile range subnet array into trust function.
 126  *
 127  * @param {Array} rangeSubnets
 128  * @api private
 129  */
 130
 131 function compileTrust(rangeSubnets) {
 132   // Return optimized function based on length
 133   var len = rangeSubnets.length;
 134   return len === 0
 135     ? trustNone
 136     : len === 1
 137     ? trustSingle(rangeSubnets[0])
 138     : trustMulti(rangeSubnets);
 139 }
 140
 141 /**
 142  * Parse IP notation string into range subnet.
 143  *
 144  * @param {String} note
 145  * @api private
 146  */
 147
 148 function parseipNotation(note) {
 149   var ip;
 150   var kind;
 151   var max;
 152   var pos = note.lastIndexOf('/');
 153   var range;
 154
 155   ip = pos !== -1
 156     ? note.substring(0, pos)
 157     : note;
 158
 159   if (!isip(ip)) {
 160     throw new TypeError('invalid IP address: ' + ip);
 161   }
 162
 163   ip = parseip(ip);
 164
 165   kind = ip.kind();
 166   max = kind === 'ipv6'
 167     ? 128
 168     : 32;
 169
 170   range = pos !== -1
 171     ? note.substring(pos + 1, note.length)
 172     : max;
 173
 174   if (typeof range !== 'number') {
 175     range = digitre.test(range)
 176       ? parseInt(range, 10)
 177       : isip(range)
 178       ? parseNetmask(range)
 179       : 0;
 180   }
 181
 182   if (ip.kind() === 'ipv6' && ip.isIPv4MappedAddress()) {
 183     // Store as IPv4
 184     ip = ip.toIPv4Address();
 185     range = range <= max
 186       ? range - 96
 187       : range;
 188   }
 189
 190   if (range <= 0 || range > max) {
 191     throw new TypeError('invalid range on address: ' + note);
 192   }
 193
 194   return [ip, range];
 195 }
 196
 197 /**
 198  * Parse netmask string into CIDR range.
 199  *
 200  * @param {String} note
 201  * @api private
 202  */
 203
 204 function parseNetmask(netmask) {
 205   var ip = parseip(netmask);
 206   var parts;
 207   var size;
 208
 209   switch (ip.kind()) {
 210     case 'ipv4':
 211       parts = ip.octets;
 212       size = 8;
 213       break;
 214     case 'ipv6':
 215       parts = ip.parts;
 216       size = 16;
 217       break;
 218   }
 219
 220   var max = Math.pow(2, size) - 1;
 221   var part;
 222   var range = 0;
 223
 224   for (var i = 0; i < parts.length; i++) {
 225     part = parts[i] & max;
 226
 227     if (part === max) {
 228       range += size;
 229       continue;
 230     }
 231
 232     while (part) {
 233       part = (part << 1) & max;
 234       range += 1;
 235     }
 236
 237     break;
 238   }
 239
 240   return range;
 241 }
 242
 243 /**
 244  * Determine address of proxied request.
 245  *
 246  * @param {Object} request
 247  * @param {Function|Array|String} trust
 248  * @api public
 249  */
 250
 251 function proxyaddr(req, trust) {
 252   if (!req) {
 253     throw new TypeError('req argument is required');
 254   }
 255
 256   if (!trust) {
 257     throw new TypeError('trust argument is required');
 258   }
 259
 260   var addrs = alladdrs(req, trust);
 261   var addr = addrs[addrs.length - 1];
 262
 263   return addr;
 264 }
 265
 266 /**
 267  * Static trust function to trust nothing.
 268  *
 269  * @api private
 270  */
 271
 272 function trustNone() {
 273   return false;
 274 }
 275
 276 /**
 277  * Compile trust function for multiple subnets.
 278  *
 279  * @param {Array} subnets
 280  * @api private
 281  */
 282
 283 function trustMulti(subnets) {
 284   return function trust(addr) {
 285     if (!isip(addr)) return false;
 286
 287     var ip = parseip(addr);
 288     var ipv4;
 289     var kind = ip.kind();
 290     var subnet;
 291     var subnetip;
 292     var subnetkind;
 293     var subnetrange;
 294     var trusted;
 295
 296     for (var i = 0; i < subnets.length; i++) {
 297       subnet = subnets[i];
 298       subnetip = subnet[0];
 299       subnetkind = subnetip.kind();
 300       subnetrange = subnet[1];
 301       trusted = ip;
 302
 303       if (kind !== subnetkind) {
 304         if (kind !== 'ipv6' || subnetkind !== 'ipv4' || !ip.isIPv4MappedAddress()) {
 305           continue;
 306         }
 307
 308         // Store addr as IPv4
 309         ipv4 = ipv4 || ip.toIPv4Address();
 310         trusted = ipv4;
 311       }
 312
 313       if (trusted.match(subnetip, subnetrange)) return true;
 314     }
 315
 316     return false;
 317   };
 318 }
 319
 320 /**
 321  * Compile trust function for single subnet.
 322  *
 323  * @param {Object} subnet
 324  * @api private
 325  */
 326
 327 function trustSingle(subnet) {
 328   var subnetip = subnet[0];
 329   var subnetkind = subnetip.kind();
 330   var subnetisipv4 = subnetkind === 'ipv4';
 331   var subnetrange = subnet[1];
 332
 333   return function trust(addr) {
 334     if (!isip(addr)) return false;
 335
 336     var ip = parseip(addr);
 337     var kind = ip.kind();
 338
 339     return kind === subnetkind
 340       ? ip.match(subnetip, subnetrange)
 341       : subnetisipv4 && kind === 'ipv6' && ip.isIPv4MappedAddress()
 342       ? ip.toIPv4Address().match(subnetip, subnetrange)
 343       : false;
 344   };
 345 }