tj

igirl-channel-jdweb/app/base/controller/impl/trademark/tmqueryCtl.js

@@ -172,6 +172,79 @@ class tmqueryCtl extends CtlBase {
       return system.getResult(null, "操作失败");
     }
   }
+  async getJdSign(pobj, qobj, req) {
+    try {
+      const { Signer, Context } = require('../jd-gateway-sdk');
+      let ctx = new Context('x3k0s704lfun-test.cn-north-1.jdcloud-api.net', '/market/order/api/submit', 'POST', null, 'empty');
+      ctx.regionId = 'cn-north-1'
+      ctx.headers.set('content-type', 'application/json');
+
+      let credentials = {
+        accessKeyId: 'C6D680733C19362B5DF478207D6A90A4', //替换自己的AK
+        secretAccessKey: 'EB9AFEE49CE41700CADD5F2EE3B2122C' //替换自己的SK--jd>>>>>>>
+      }
+
+      //测试报文：
+      //ctx.body = "pin=jcloud_pRiHQTd&serviceId=580010&itemCode=FW_GOODS-580010-1&platform=6"
+      //POST
+      var qs = require('querystring');
+      var post_data = { pin: "jcloud_pRiHQTd", serviceId: 580010, itemCode: "FW_GOODS-580010-1", platform: 6, orderNum: 1, articleType: 1 };//这是需要提交的数据
+      var tmpContent = JSON.stringify(post_data);
+      var tmpContentLength = Buffer.byteLength(tmpContent);
+      var content = qs.stringify(post_data);
+      ctx.body = tmpContent;
+
+      ctx.method = 'POST'
+      var signer = new Signer(ctx, credentials);
+
+
+      ctx.headers.set('Content-Length', tmpContentLength)
+      ctx.buildNonce()
+      var dd = new Date();
+      var auth = signer.sign(dd)
+
+      console.log("POST签名为：", auth)
+      ctx.headers.set('Authorization', auth)
+
+      ////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      var http = require('https');
+
+      var options = {
+        host: 'x3k0s704lfun-test.cn-north-1.jdcloud-api.net',
+        port: 443,
+        path: '/market/order/api/submit',
+        method: 'POST',
+        headers: {
+        }
+      };
+
+      for (let [key, value] of ctx.headers) {
+        options.headers[key] = value
+      }
+      console.log("\n post options:\n", options);
+      console.log("\n tmpContent:\n", tmpContent);
+
+      var req = http.request(options, function (res) {
+        console.log("statusCode: ", res.statusCode);
+        console.log("headers: ", res.headers);
+        var _data = '';
+        res.on('data', function (chunk) {
+          _data += chunk;
+        });
+        res.on('end', function () {
+          console.log("\n--->>\nresult:", _data)
+        });
+      });
+      req.on('error', (e) => {
+        console.error(`请求遇到问题-------------: ${e.message}`);
+      });
+      req.write(tmpContent);
+      req.end();
+
+    } catch (errorMsg) {
+      console.log(errorMsg, "--jd>>>>>>>errorMsg..............................>>>>>>");
+    }
+  }
 
 }
 module.exports = tmqueryCtl;

igirl-channel-jdweb/app/base/controller/jd-gateway-sdk/index.js

+module.exports={
+    Signer:require('./signer'),
+    Context:require('./requestContext')
+}
\ No newline at end of file

igirl-channel-jdweb/app/base/controller/jd-gateway-sdk/requestContext.js

+const util = require('./util')
+const uuid=require('uuid')
+
+const NOUNCEHEADER='x-jdcloud-nonce'
+
+class Context {
+    constructor(host,path,method,headers,serviceName='',regionId='')
+    {
+        if(!host)
+            throw new Error("host is required")
+        if(!path)
+            throw new Error("path is required")
+        if(!method)
+            throw new Error("method is required")
+        this.host=host
+        this.headers=headers||new Map()
+        this.method=method
+        this.path=util.uriEscapePath(path)
+        this.serviceName=serviceName
+        this.regionId=regionId
+    }
+
+    buildNonce()
+    {
+       this.headers.set(NOUNCEHEADER,uuid.v4())
+    }
+
+    setNonce(nonce)
+    {
+        this.headers.set(NOUNCEHEADER,nonce)
+    }
+
+    check()
+    {
+        if(!this.headers.get(NOUNCEHEADER))
+            throw new Error("header['x-jdcloud-nonce'] is required")
+        if(!this.regionId)
+            throw new Error("regionId is required")
+    }
+
+    buildQuery (queryParams) {
+        var queryParamsWithoutEmptyItem = {}
+        var keys = Object.keys(queryParams)
+        for (let key of keys) {
+            if (queryParams[key] !== undefined) {
+                queryParamsWithoutEmptyItem[key] = queryParams[key]
+            }
+        }
+        return util.queryParamsToString(queryParamsWithoutEmptyItem)
+    }
+}
+
+module.exports=Context

igirl-channel-jdweb/app/base/controller/jd-gateway-sdk/signer/index.js

+// Copyright 2018 JDCLOUD.COM
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License
+// This signer is modified from AWS V4 signer algorithm.
+
+var util = require('../util')
+var v2Credentials = require('./v2_credentials')
+
+
+module.exports = class SignerV2  {
+    constructor (request,credentials,logger=console.log) {
+
+        this.signatureCache = true
+        this.algorithm = 'JDCLOUD2-HMAC-SHA256'
+        this.unsignableHeaders = [
+            'authorization',
+            'user-agent',
+            'x-jdcloud-id',
+            'x-jcloud-id',
+            'x-jdcloud-content-sha256'
+        ]
+        this.signableHeaders = [
+            'content-type',
+            'host',
+            'x-jdcloud-date',
+            'x-jdcloud-nonce'
+        ]
+
+        this.request=request
+        this.headers=request.headers
+        this.serviceName =request.serviceName
+        this.logger=logger
+        this.credentials=credentials
+        // this.signatureCache = typeof options.signatureCache === 'boolean' ? options.signatureCache : true;
+    }
+
+    setSignableHeaders(signableHeaders)
+    {
+      let headers=['x-jdcloud-nonce']
+      if(this.headers.has('x-jdcloud-security-token'))
+        headers.push('x-jdcloud-security-token')
+      for(let header of signableHeaders)
+      {
+        headers.push(header)
+      }
+      this.signableHeaders=[...new Set(headers)]
+    }
+    addAuthorization (date) {
+        // var datetime = '20180119T070300Z';
+        this.request.check()
+        var datetime = util.date.iso8601(date).replace(/[:-]|\.\d{3}/g, '')
+        this.addHeaders(this.credentials, datetime)
+
+        if (!this.headers.get('x-jdcloud-oauth2-token')) {
+            this.headers.set(
+                'Authorization',
+                this.authorization(this.credentials, datetime)
+            )
+        }
+    }
+
+    sign(date)
+    {
+        this.request.check()
+        var datetime = util.date.iso8601(date).replace(/[:-]|\.\d{3}/g, '')
+        this.addHeaders(this.credentials, datetime)
+        return this.authorization(this.credentials, datetime)
+    }
+
+    addHeaders (credentials, datetime) {
+        this.headers.set('x-jdcloud-date', datetime)
+        this.headers.set(
+            'host',
+            this.request.host
+        )
+    }
+
+    signedHeaders () {
+        var keys = []
+        this.headers.forEach((value, key) => {
+            key = key.toLowerCase()
+            if (this.isSignableHeader(key)) {
+                keys.push(key)
+            }
+        })
+
+        return keys.sort().join(';')
+    }
+
+    credentialString (datetime) {
+        return v2Credentials.createScope(
+            datetime.substr(0, 8),
+            this.request.regionId,
+            this.serviceName
+        )
+    }
+
+    signature (credentials, datetime) {
+        var signingKey = v2Credentials.getSigningKey(
+            credentials,
+            datetime.substr(0, 8),
+            this.request.regionId,
+            this.serviceName,
+            this.signatureCache
+        )
+        return util.crypto.hmac(signingKey, this.stringToSign(datetime), 'hex')
+    }
+
+    stringToSign (datetime) {
+        var parts = []
+        parts.push(this.algorithm)
+        parts.push(datetime)
+        parts.push(this.credentialString(datetime))
+        parts.push(this.hexEncodedHash(this.canonicalString()))
+        this.logger('StringToSign is \n' + JSON.stringify(parts), 'DEBUG')
+        return parts.join('\n')
+    }
+
+    // 构建标准签名字符串
+    canonicalString () {
+        var parts = []
+        var pathname = this.request.path
+        parts.push(this.request.method)
+        parts.push(pathname)
+        parts.push(this.request.query)
+        parts.push(this.canonicalHeaders() + '\n')
+        parts.push(this.signedHeaders())
+        parts.push(this.hexEncodedBodyHash())
+        this.logger(
+            'canonicalString is \n' + JSON.stringify(parts),
+            'DEBUG'
+        )
+        return parts.join('\n')
+    }
+
+    canonicalHeaders () {
+        var headers = []
+        this.headers.forEach((value, key) => {
+            headers.push([key, value])
+        })
+        headers.sort(function (a, b) {
+            return a[0].toLowerCase() < b[0].toLowerCase() ? -1 : 1
+        })
+        var parts = []
+        util.arrayEach.call(this, headers, function (item) {
+            var key = item[0].toLowerCase()
+            if (this.isSignableHeader(key)) {
+                var value = item[1]
+                if (
+                    typeof value === 'undefined' ||
+                    value === null ||
+                    typeof value.toString !== 'function'
+                ) {
+                    throw util.error(
+                        new Error('Header ' + key + ' contains invalid value'),
+                        {
+                            code: 'InvalidHeader'
+                        }
+                    )
+                }
+                parts.push(key + ':' + this.canonicalHeaderValues(value.toString()))
+            }
+        })
+        return parts.join('\n')
+    }
+
+    canonicalHeaderValues (values) {
+        return values.replace(/\s+/g, ' ').replace(/^\s+|\s+$/g, '')
+    }
+
+    authorization (credentials, datetime) {
+        var parts = []
+        var credString = this.credentialString(datetime)
+        parts.push(
+            this.algorithm +
+            ' Credential=' +
+            credentials.accessKeyId +
+            '/' +
+            credString
+        )
+        parts.push('SignedHeaders=' + this.signedHeaders())
+        parts.push('Signature=' + this.signature(credentials, datetime))
+        this.logger('Signature is \n' + JSON.stringify(parts), 'DEBUG')
+        return parts.join(', ')
+    }
+
+    hexEncodedHash (string) {
+        return util.crypto.sha256(string, 'hex')
+    }
+
+    hexEncodedBodyHash () {
+        return (
+            this.headers.get('x-jdcloud-content-sha256') ||
+            this.hexEncodedHash(this.request.body || '')
+        )
+        /* var request = this.request;
+            if (this.isPresigned() && this.serviceName === 's3' && !request.body) {
+                return 'UNSIGNED-PAYLOAD';
+            } else if (request.headers['X-Amz-Content-Sha256']) {
+                return request.headers['X-Amz-Content-Sha256'];
+            } else {
+                return this.hexEncodedHash(this.request.body || '');
+            } */
+    }
+
+    isSignableHeader (key) {
+        return this.signableHeaders.includes(key.toLowerCase())
+    }
+}

igirl-channel-jdweb/app/base/controller/jd-gateway-sdk/signer/v2_credentials.js

+var cachedSecret = {}
+var cacheQueue = []
+var maxCacheEntries = 50
+var v2Identifier = 'jdcloud2_request'
+
+var util = require('../util')
+
+module.exports = {
+  /**
+   * @api private
+   *
+   * @param date [String]
+   * @param region [String]
+   * @param serviceName [String]
+   * @return [String]
+   */
+  createScope: function createScope (date, region, serviceName) {
+    return [date.substr(0, 8), region, serviceName, v2Identifier].join('/')
+  },
+
+  /**
+   * @api private
+   *
+   * @param credentials [Credentials]
+   * @param date [String]
+   * @param region [String]
+   * @param service [String]
+   * @param shouldCache [Boolean]
+   * @return [String]
+   */
+  getSigningKey: function getSigningKey (
+    credentials,
+    date,
+    region,
+    service,
+    shouldCache
+  ) {
+    var credsIdentifier = util.crypto.hmac(
+      credentials.secretAccessKey,
+      credentials.accessKeyId,
+      'base64'
+    )
+    var cacheKey = [credsIdentifier, date, region, service].join('_')
+    shouldCache = shouldCache !== false
+    if (shouldCache && cacheKey in cachedSecret) {
+      return cachedSecret[cacheKey]
+    }
+
+    var kDate = util.crypto.hmac(
+      'JDCLOUD2' + credentials.secretAccessKey,
+      date,
+      'buffer'
+    )
+    var kRegion = util.crypto.hmac(kDate, region, 'buffer')
+    var kService = util.crypto.hmac(kRegion, service, 'buffer')
+
+    var signingKey = util.crypto.hmac(kService, v2Identifier, 'buffer')
+    if (shouldCache) {
+      cachedSecret[cacheKey] = signingKey
+      cacheQueue.push(cacheKey)
+      if (cacheQueue.length > maxCacheEntries) {
+        // remove the oldest entry (not the least recently used)
+        delete cachedSecret[cacheQueue.shift()]
+      }
+    }
+
+    return signingKey
+  },
+
+  /**
+   * @api private
+   *
+   * Empties the derived signing key cache. Made available for testing purposes
+   * only.
+   */
+  emptyCache: function emptyCache () {
+    cachedSecret = {}
+    cacheQueue = []
+  }
+}

igirl-channel-jdweb/app/base/controller/jd-gateway-sdk/util.js

+var util = {
+  isBrowser: function isBrowser () {
+    return process && process.browser
+  },
+  isNode: function isNode () {
+    return !util.isBrowser()
+  },
+  uriEscape: function uriEscape (string) {
+    var output = encodeURIComponent(string)
+    output = output.replace(/[^A-Za-z0-9_.~\-%]+/g, escape)
+
+    // AWS percent-encodes some extra non-standard characters in a URI
+    output = output.replace(/[*]/g, function (ch) {
+      return (
+        '%' +
+        ch
+          .charCodeAt(0)
+          .toString(16)
+          .toUpperCase()
+      )
+    })
+
+    return output
+  },
+  uriEscapePath: function uriEscapePath (string) {
+    var parts = []
+    util.arrayEach(string.split('/'), function (part) {
+      parts.push(util.uriEscape(part))
+    })
+    return parts.join('/')
+  },
+  abort: {},
+  each: function each (object, iterFunction) {
+    for (var key in object) {
+      if (Object.prototype.hasOwnProperty.call(object, key)) {
+        var ret = iterFunction.call(this, key, object[key])
+        if (ret === util.abort) break
+      }
+    }
+  },
+
+  arrayEach: function arrayEach (array, iterFunction) {
+    for (var idx in array) {
+      if (Object.prototype.hasOwnProperty.call(array, idx)) {
+        var ret = iterFunction.call(this, array[idx], parseInt(idx, 10))
+        if (ret === util.abort) break
+      }
+    }
+  },
+  arraySliceFn: function arraySliceFn (obj) {
+    var fn = obj.slice || obj.webkitSlice || obj.mozSlice
+    return typeof fn === 'function' ? fn : null
+  },
+  queryParamsToString: function queryParamsToString (params) {
+    var items = []
+    var escape = util.uriEscape
+    var sortedKeys = Object.keys(params).sort()
+
+    util.arrayEach(sortedKeys, function (name) {
+      var value = params[name]
+      var ename = escape(name)
+      var result = ename + '='
+      if (Array.isArray(value)) {
+        var vals = []
+        util.arrayEach(value, function (item) {
+          vals.push(escape(item))
+        })
+        result = ename + '=' + vals.sort().join('&' + ename + '=')
+      } else if (value !== undefined && value !== null) {
+        result = ename + '=' + escape(value)
+      }
+      items.push(result)
+    })
+
+    return items.join('&')
+  },
+  date: {
+    getDate () {
+      return new Date()
+    },
+    iso8601: function iso8601 (date) {
+      if (date === undefined) {
+        date = util.date.getDate()
+      }
+      return date.toISOString().replace(/\.\d{3}Z$/, 'Z')
+    }
+  },
+  crypto: {
+    /* eslint-disable no-use-before-define */
+    crc32Table: [
+      0x00000000,
+      0x77073096,
+      0xee0e612c,
+      0x990951ba,
+      0x076dc419,
+      0x706af48f,
+      0xe963a535,
+      0x9e6495a3,
+      0x0edb8832,
+      0x79dcb8a4,
+      0xe0d5e91e,
+      0x97d2d988,
+      0x09b64c2b,
+      0x7eb17cbd,
+      0xe7b82d07,
+      0x90bf1d91,
+      0x1db71064,
+      0x6ab020f2,
+      0xf3b97148,
+      0x84be41de,
+      0x1adad47d,
+      0x6ddde4eb,
+      0xf4d4b551,
+      0x83d385c7,
+      0x136c9856,
+      0x646ba8c0,
+      0xfd62f97a,
+      0x8a65c9ec,
+      0x14015c4f,
+      0x63066cd9,
+      0xfa0f3d63,
+      0x8d080df5,
+      0x3b6e20c8,
+      0x4c69105e,
+      0xd56041e4,
+      0xa2677172,
+      0x3c03e4d1,
+      0x4b04d447,
+      0xd20d85fd,
+      0xa50ab56b,
+      0x35b5a8fa,
+      0x42b2986c,
+      0xdbbbc9d6,
+      0xacbcf940,
+      0x32d86ce3,
+      0x45df5c75,
+      0xdcd60dcf,
+      0xabd13d59,
+      0x26d930ac,
+      0x51de003a,
+      0xc8d75180,
+      0xbfd06116,
+      0x21b4f4b5,
+      0x56b3c423,
+      0xcfba9599,
+      0xb8bda50f,
+      0x2802b89e,
+      0x5f058808,
+      0xc60cd9b2,
+      0xb10be924,
+      0x2f6f7c87,
+      0x58684c11,
+      0xc1611dab,
+      0xb6662d3d,
+      0x76dc4190,
+      0x01db7106,
+      0x98d220bc,
+      0xefd5102a,
+      0x71b18589,
+      0x06b6b51f,
+      0x9fbfe4a5,
+      0xe8b8d433,
+      0x7807c9a2,
+      0x0f00f934,
+      0x9609a88e,
+      0xe10e9818,
+      0x7f6a0dbb,
+      0x086d3d2d,
+      0x91646c97,
+      0xe6635c01,
+      0x6b6b51f4,
+      0x1c6c6162,
+      0x856530d8,
+      0xf262004e,
+      0x6c0695ed,
+      0x1b01a57b,
+      0x8208f4c1,
+      0xf50fc457,
+      0x65b0d9c6,
+      0x12b7e950,
+      0x8bbeb8ea,
+      0xfcb9887c,
+      0x62dd1ddf,
+      0x15da2d49,
+      0x8cd37cf3,
+      0xfbd44c65,
+      0x4db26158,
+      0x3ab551ce,
+      0xa3bc0074,
+      0xd4bb30e2,
+      0x4adfa541,
+      0x3dd895d7,
+      0xa4d1c46d,
+      0xd3d6f4fb,
+      0x4369e96a,
+      0x346ed9fc,
+      0xad678846,
+      0xda60b8d0,
+      0x44042d73,
+      0x33031de5,
+      0xaa0a4c5f,
+      0xdd0d7cc9,
+      0x5005713c,
+      0x270241aa,
+      0xbe0b1010,
+      0xc90c2086,
+      0x5768b525,
+      0x206f85b3,
+      0xb966d409,
+      0xce61e49f,
+      0x5edef90e,
+      0x29d9c998,
+      0xb0d09822,
+      0xc7d7a8b4,
+      0x59b33d17,
+      0x2eb40d81,
+      0xb7bd5c3b,
+      0xc0ba6cad,
+      0xedb88320,
+      0x9abfb3b6,
+      0x03b6e20c,
+      0x74b1d29a,
+      0xead54739,
+      0x9dd277af,
+      0x04db2615,
+      0x73dc1683,
+      0xe3630b12,
+      0x94643b84,
+      0x0d6d6a3e,
+      0x7a6a5aa8,
+      0xe40ecf0b,
+      0x9309ff9d,
+      0x0a00ae27,
+      0x7d079eb1,
+      0xf00f9344,
+      0x8708a3d2,
+      0x1e01f268,
+      0x6906c2fe,
+      0xf762575d,
+      0x806567cb,
+      0x196c3671,
+      0x6e6b06e7,
+      0xfed41b76,
+      0x89d32be0,
+      0x10da7a5a,
+      0x67dd4acc,
+      0xf9b9df6f,
+      0x8ebeeff9,
+      0x17b7be43,
+      0x60b08ed5,
+      0xd6d6a3e8,
+      0xa1d1937e,
+      0x38d8c2c4,
+      0x4fdff252,
+      0xd1bb67f1,
+      0xa6bc5767,
+      0x3fb506dd,
+      0x48b2364b,
+      0xd80d2bda,
+      0xaf0a1b4c,
+      0x36034af6,
+      0x41047a60,
+      0xdf60efc3,
+      0xa867df55,
+      0x316e8eef,
+      0x4669be79,
+      0xcb61b38c,
+      0xbc66831a,
+      0x256fd2a0,
+      0x5268e236,
+      0xcc0c7795,
+      0xbb0b4703,
+      0x220216b9,
+      0x5505262f,
+      0xc5ba3bbe,
+      0xb2bd0b28,
+      0x2bb45a92,
+      0x5cb36a04,
+      0xc2d7ffa7,
+      0xb5d0cf31,
+      0x2cd99e8b,
+      0x5bdeae1d,
+      0x9b64c2b0,
+      0xec63f226,
+      0x756aa39c,
+      0x026d930a,
+      0x9c0906a9,
+      0xeb0e363f,
+      0x72076785,
+      0x05005713,
+      0x95bf4a82,
+      0xe2b87a14,
+      0x7bb12bae,
+      0x0cb61b38,
+      0x92d28e9b,
+      0xe5d5be0d,
+      0x7cdcefb7,
+      0x0bdbdf21,
+      0x86d3d2d4,
+      0xf1d4e242,
+      0x68ddb3f8,
+      0x1fda836e,
+      0x81be16cd,
+      0xf6b9265b,
+      0x6fb077e1,
+      0x18b74777,
+      0x88085ae6,
+      0xff0f6a70,
+      0x66063bca,
+      0x11010b5c,
+      0x8f659eff,
+      0xf862ae69,
+      0x616bffd3,
+      0x166ccf45,
+      0xa00ae278,
+      0xd70dd2ee,
+      0x4e048354,
+      0x3903b3c2,
+      0xa7672661,
+      0xd06016f7,
+      0x4969474d,
+      0x3e6e77db,
+      0xaed16a4a,
+      0xd9d65adc,
+      0x40df0b66,
+      0x37d83bf0,
+      0xa9bcae53,
+      0xdebb9ec5,
+      0x47b2cf7f,
+      0x30b5ffe9,
+      0xbdbdf21c,
+      0xcabac28a,
+      0x53b39330,
+      0x24b4a3a6,
+      0xbad03605,
+      0xcdd70693,
+      0x54de5729,
+      0x23d967bf,
+      0xb3667a2e,
+      0xc4614ab8,
+      0x5d681b02,
+      0x2a6f2b94,
+      0xb40bbe37,
+      0xc30c8ea1,
+      0x5a05df1b,
+      0x2d02ef8d
+    ],
+    /* eslint-disable no-use-before-define */
+
+    crc32: function crc32 (data) {
+      var tbl = util.crypto.crc32Table
+      var crc = 0 ^ -1
+
+      if (typeof data === 'string') {
+        data = new util.Buffer(data)
+      }
+
+      for (var i = 0; i < data.length; i++) {
+        var code = data.readUInt8(i)
+        crc = (crc >>> 8) ^ tbl[(crc ^ code) & 0xff]
+      }
+      return (crc ^ -1) >>> 0
+    },
+
+    hmac: function hmac (key, string, digest, fn) {
+      if (!digest) digest = 'binary'
+      if (digest === 'buffer') {
+        digest = undefined
+      }
+      if (!fn) fn = 'sha256'
+      if (typeof string === 'string') string = new util.Buffer(string)
+      return util.crypto.lib
+        .createHmac(fn, key)
+        .update(string)
+        .digest(digest)
+    },
+
+    md5: function md5 (data, digest, callback) {
+      return util.crypto.hash('md5', data, digest, callback)
+    },
+
+    sha256: function sha256 (data, digest, callback) {
+      return util.crypto.hash('sha256', data, digest, callback)
+    },
+
+    hash: function (algorithm, data, digest, callback) {
+      var hash = util.crypto.createHash(algorithm)
+      if (!digest) {
+        digest = 'binary'
+      }
+      if (digest === 'buffer') {
+        digest = undefined
+      }
+      if (typeof data === 'string') data = new util.Buffer(data)
+      var sliceFn = util.arraySliceFn(data)
+      var isBuffer = util.Buffer.isBuffer(data)
+      // Identifying objects with an ArrayBuffer as buffers
+      if (
+        util.isBrowser() &&
+        typeof ArrayBuffer !== 'undefined' &&
+        data &&
+        data.buffer instanceof ArrayBuffer
+      ) {
+        isBuffer = true
+      }
+
+      if (
+        callback &&
+        typeof data === 'object' &&
+        typeof data.on === 'function' &&
+        !isBuffer
+      ) {
+        data.on('data', function (chunk) {
+          hash.update(chunk)
+        })
+        data.on('error', function (err) {
+          callback(err)
+        })
+        data.on('end', function () {
+          callback(null, hash.digest(digest))
+        })
+      } else if (
+        callback &&
+        sliceFn &&
+        !isBuffer &&
+        typeof FileReader !== 'undefined'
+      ) {
+        // this might be a File/Blob
+        var index = 0
+        var size = 1024 * 512
+        var reader = new FileReader()
+        reader.onerror = function () {
+          callback(new Error('Failed to read data.'))
+        }
+        reader.onload = function () {
+          var buf = new util.Buffer(new Uint8Array(reader.result))
+          hash.update(buf)
+          index += buf.length
+          reader._continueReading()
+        }
+        reader._continueReading = function () {
+          if (index >= data.size) {
+            callback(null, hash.digest(digest))
+            return
+          }
+
+          var back = index + size
+          if (back > data.size) back = data.size
+          reader.readAsArrayBuffer(sliceFn.call(data, index, back))
+        }
+
+        reader._continueReading()
+      } else {
+        if (util.isBrowser() && typeof data === 'object' && !isBuffer) {
+          data = new util.Buffer(new Uint8Array(data))
+        }
+        var out = hash.update(data).digest(digest)
+        if (callback) callback(null, out)
+        return out
+      }
+    },
+
+    toHex: function toHex (data) {
+      var out = []
+      for (var i = 0; i < data.length; i++) {
+        out.push(('0' + data.charCodeAt(i).toString(16)).substr(-2, 2))
+      }
+      return out.join('')
+    },
+
+    createHash: function createHash (algorithm) {
+      return util.crypto.lib.createHash(algorithm)
+    }
+  }
+}
+util.crypto.lib = require('crypto')
+util.Buffer = require('buffer').Buffer
+util.url = require('url')
+util.querystring = require('querystring')
+module.exports = util