Elep

'use strict';

/*
    HTTP Hawk Authentication Scheme
    Copyright (c) 2012-2016, Eran Hammer <eran@hammer.io>
    BSD Licensed
*/

// Declare namespace

const hawk = {
    internals: {}
};

hawk.client = {

// Generate an Authorization header for a given request

/*
        uri: 'http://example.com/resource?a=b' or object generated by hawk.utils.parseUri()
        method: HTTP verb (e.g. 'GET', 'POST')
        options: {

// Required

credentials: {
                id: 'dh37fgj492je',
                key: 'aoijedoaijsdlaksjdl',
                algorithm: 'sha256'                                 // 'sha1', 'sha256'
            },

// Optional

ext: 'application-specific',                        // Application specific data sent via the ext attribute
            timestamp: Date.now() / 1000,                       // A pre-calculated timestamp in seconds
            nonce: '2334f34f',                                  // A pre-generated nonce
            localtimeOffsetMsec: 400,                           // Time offset to sync with server time (ignored if timestamp provided)
            payload: '{"some":"payload"}',                      // UTF-8 encoded string for body hash generation (ignored if hash provided)
            contentType: 'application/json',                    // Payload content-type (ignored if hash provided)
            hash: 'U4MKKSmiVxk37JCCrAVIjV=',                    // Pre-calculated payload hash
            app: '24s23423f34dx',                               // Oz application id
            dlg: '234sz34tww3sd'                                // Oz delegated-by application id
        }
    */

header: function (uri, method, options) {

const result = {
            field: '',
            artifacts: {}
        };

// Validate inputs

if (!uri || (typeof uri !== 'string' && typeof uri !== 'object') ||
            !method || typeof method !== 'string' ||
            !options || typeof options !== 'object') {

result.err = 'Invalid argument type';
            return result;
        }

// Application time

const timestamp = options.timestamp || hawk.utils.nowSec(options.localtimeOffsetMsec);

// Validate credentials

const credentials = options.credentials;
        if (!credentials ||
            !credentials.id ||
            !credentials.key ||
            !credentials.algorithm) {

result.err = 'Invalid credentials object';
            return result;
        }

if (hawk.crypto.algorithms.indexOf(credentials.algorithm) === -1) {
            result.err = 'Unknown algorithm';
            return result;
        }

// Parse URI

if (typeof uri === 'string') {
            uri = hawk.utils.parseUri(uri);
        }

// Calculate signature

const artifacts = {
            ts: timestamp,
            nonce: options.nonce || hawk.utils.randomString(6),
            method,
            resource: uri.resource,
            host: uri.host,
            port: uri.port,
            hash: options.hash,
            ext: options.ext,
            app: options.app,
            dlg: options.dlg
        };

result.artifacts = artifacts;

// Calculate payload hash

if (!artifacts.hash &&
            (options.payload || options.payload === '')) {

artifacts.hash = hawk.crypto.calculatePayloadHash(options.payload, credentials.algorithm, options.contentType);
        }

const mac = hawk.crypto.calculateMac('header', credentials, artifacts);

// Construct header

const hasExt = artifacts.ext !== null && artifacts.ext !== undefined && artifacts.ext !== '';       // Other falsey values allowed
        let header = 'Hawk id="' + credentials.id +
                     '", ts="' + artifacts.ts +
                     '", nonce="' + artifacts.nonce +
                     (artifacts.hash ? '", hash="' + artifacts.hash : '') +
                     (hasExt ? '", ext="' + hawk.utils.escapeHeaderAttribute(artifacts.ext) : '') +
                     '", mac="' + mac + '"';

if (artifacts.app) {
            header += ', app="' + artifacts.app +
                      (artifacts.dlg ? '", dlg="' + artifacts.dlg : '') + '"';
        }

result.field = header;

return result;
    },

// Generate a bewit value for a given URI

/*
        uri: 'http://example.com/resource?a=b'
        options: {

// Required

credentials: {
            id: 'dh37fgj492je',
            key: 'aoijedoaijsdlaksjdl',
            algorithm: 'sha256'                             // 'sha1', 'sha256'
            },
            ttlSec: 60 * 60,                                    // TTL in seconds

// Optional

ext: 'application-specific',                        // Application specific data sent via the ext attribute
            localtimeOffsetMsec: 400                            // Time offset to sync with server time
         };
    */

bewit: function (uri, options) {

// Validate inputs

if (!uri ||
            (typeof uri !== 'string') ||
            !options ||
            typeof options !== 'object' ||
            !options.ttlSec) {

return '';
        }

options.ext = (options.ext === null || options.ext === undefined ? '' : options.ext);       // Zero is valid value

// Application time

const now = hawk.utils.nowSec(options.localtimeOffsetMsec);

// Validate credentials

const credentials = options.credentials;
        if (!credentials ||
            !credentials.id ||
            !credentials.key ||
            !credentials.algorithm) {

return '';
        }

if (hawk.crypto.algorithms.indexOf(credentials.algorithm) === -1) {
            return '';
        }

// Parse URI

uri = hawk.utils.parseUri(uri);

// Calculate signature

const exp = now + options.ttlSec;
        const mac = hawk.crypto.calculateMac('bewit', credentials, {
            ts: exp,
            nonce: '',
            method: 'GET',
            resource: uri.resource,                            // Maintain trailing '?' and query params
            host: uri.host,
            port: uri.port,
            ext: options.ext
        });

// Construct bewit: id\exp\mac\ext

const bewit = credentials.id + '\\' + exp + '\\' + mac + '\\' + options.ext;
        return hawk.utils.base64urlEncode(bewit);
    },

// Validate server response

/*
        request:    object created via 'new XMLHttpRequest()' after response received or fetch API 'Response'
        artifacts:  object received from header().artifacts
        options: {
            payload:    optional payload received
            required:   specifies if a Server-Authorization header is required. Defaults to 'false'
        }
    */

authenticate: function (request, credentials, artifacts, options) {

options = options || {};

const getHeader = function (name) {

// Fetch API or plain headers

if (request.headers) {
                return (typeof request.headers.get === 'function' ? request.headers.get(name) : request.headers[name]);
            }

// XMLHttpRequest

return (request.getResponseHeader ? request.getResponseHeader(name) : request.getHeader(name));
        };

const wwwAuthenticate = getHeader('www-authenticate');
        if (wwwAuthenticate) {

// Parse HTTP WWW-Authenticate header

const wwwAttributes = hawk.utils.parseAuthorizationHeader(wwwAuthenticate, ['ts', 'tsm', 'error']);
            if (!wwwAttributes) {
                return false;
            }

if (wwwAttributes.ts) {
                const tsm = hawk.crypto.calculateTsMac(wwwAttributes.ts, credentials);
                if (tsm !== wwwAttributes.tsm) {
                    return false;
                }

hawk.utils.setNtpSecOffset(wwwAttributes.ts - Math.floor(Date.now() / 1000));      // Keep offset at 1 second precision
            }
        }

// Parse HTTP Server-Authorization header

const serverAuthorization = getHeader('server-authorization');
        if (!serverAuthorization &&
            !options.required) {

return true;
        }

const attributes = hawk.utils.parseAuthorizationHeader(serverAuthorization, ['mac', 'ext', 'hash']);
        if (!attributes) {
            return false;
        }

const modArtifacts = {
            ts: artifacts.ts,
            nonce: artifacts.nonce,
            method: artifacts.method,
            resource: artifacts.resource,
            host: artifacts.host,
            port: artifacts.port,
            hash: attributes.hash,
            ext: attributes.ext,
            app: artifacts.app,
            dlg: artifacts.dlg
        };

const mac = hawk.crypto.calculateMac('response', credentials, modArtifacts);
        if (mac !== attributes.mac) {
            return false;
        }

if (!options.payload &&
            options.payload !== '') {

return true;
        }

if (!attributes.hash) {
            return false;
        }

const calculatedHash = hawk.crypto.calculatePayloadHash(options.payload, credentials.algorithm, getHeader('content-type'));
        return (calculatedHash === attributes.hash);
    },

message: function (host, port, message, options) {

// Validate inputs

if (!host || typeof host !== 'string' ||
            !port || typeof port !== 'number' ||
            message === null || message === undefined || typeof message !== 'string' ||
            !options || typeof options !== 'object') {

return null;
        }

// Application time

const timestamp = options.timestamp || hawk.utils.nowSec(options.localtimeOffsetMsec);

// Validate credentials

const credentials = options.credentials;
        if (!credentials ||
            !credentials.id ||
            !credentials.key ||
            !credentials.algorithm) {

// Invalid credential object
            return null;
        }

if (hawk.crypto.algorithms.indexOf(credentials.algorithm) === -1) {
            return null;
        }

// Calculate signature

const artifacts = {
            ts: timestamp,
            nonce: options.nonce || hawk.utils.randomString(6),
            host,
            port,
            hash: hawk.crypto.calculatePayloadHash(message, credentials.algorithm)
        };

// Construct authorization

const result = {
            id: credentials.id,
            ts: artifacts.ts,
            nonce: artifacts.nonce,
            hash: artifacts.hash,
            mac: hawk.crypto.calculateMac('message', credentials, artifacts)
        };

return result;
    },

authenticateTimestamp: function (message, credentials, updateClock) {               // updateClock defaults to true

const tsm = hawk.crypto.calculateTsMac(message.ts, credentials);
        if (tsm !== message.tsm) {
            return false;
        }

if (updateClock !== false) {
            hawk.utils.setNtpSecOffset(message.ts - Math.floor(Date.now() / 1000));     // Keep offset at 1 second precision
        }

return true;
    }
};

hawk.crypto = {

headerVersion: '1',

algorithms: ['sha1', 'sha256'],

calculateMac: function (type, credentials, options) {

const normalized = hawk.crypto.generateNormalizedString(type, options);

const hmac = CryptoJS['Hmac' + credentials.algorithm.toUpperCase()](normalized, credentials.key);
        return hmac.toString(CryptoJS.enc.Base64);
    },

generateNormalizedString: function (type, options) {

let normalized = 'hawk.' + hawk.crypto.headerVersion + '.' + type + '\n' +
                         options.ts + '\n' +
                         options.nonce + '\n' +
                         (options.method || '').toUpperCase() + '\n' +
                         (options.resource || '') + '\n' +
                         options.host.toLowerCase() + '\n' +
                         options.port + '\n' +
                         (options.hash || '') + '\n';

if (options.ext) {
            normalized += options.ext.replace('\\', '\\\\').replace('\n', '\\n');
        }

normalized += '\n';

if (options.app) {
            normalized += options.app + '\n' +
                          (options.dlg || '') + '\n';
        }

return normalized;
    },

calculatePayloadHash: function (payload, algorithm, contentType) {

const hash = CryptoJS.algo[algorithm.toUpperCase()].create();
        hash.update('hawk.' + hawk.crypto.headerVersion + '.payload\n');
        hash.update(hawk.utils.parseContentType(contentType) + '\n');
        hash.update(payload);
        hash.update('\n');
        return hash.finalize().toString(CryptoJS.enc.Base64);
    },

calculateTsMac: function (ts, credentials) {

const hash = CryptoJS['Hmac' + credentials.algorithm.toUpperCase()]('hawk.' + hawk.crypto.headerVersion + '.ts\n' + ts + '\n', credentials.key);
        return hash.toString(CryptoJS.enc.Base64);
    }
};

// localStorage compatible interface

hawk.internals.LocalStorage = function () {

this._cache = {};
    this.length = 0;

this.getItem = function (key) {

return this._cache.hasOwnProperty(key) ? String(this._cache[key]) : null;
    };

this.setItem = function (key, value) {

this._cache[key] = String(value);
        this.length = Object.keys(this._cache).length;
    };

this.removeItem = function (key) {

delete this._cache[key];
        this.length = Object.keys(this._cache).length;
    };

this.clear = function () {

this._cache = {};
        this.length = 0;
    };

this.key = function (i) {

return Object.keys(this._cache)[i || 0];
    };
};

hawk.utils = {

storage: new hawk.internals.LocalStorage(),

setStorage: function (storage) {

const ntpOffset = hawk.utils.storage.getItem('hawk_ntp_offset');
        hawk.utils.storage = storage;
        if (ntpOffset) {
            hawk.utils.setNtpSecOffset(ntpOffset);
        }
    },

setNtpSecOffset: function (offset) {

try {
            hawk.utils.storage.setItem('hawk_ntp_offset', offset);
        }
        catch (err) {
            console.error('[hawk] could not write to storage.');
            console.error(err);
        }
    },

getNtpSecOffset: function () {

const offset = hawk.utils.storage.getItem('hawk_ntp_offset');
        if (!offset) {
            return 0;
        }

return parseInt(offset, 10);
    },

now: function (localtimeOffsetMsec) {

return Date.now() + (localtimeOffsetMsec || 0) + (hawk.utils.getNtpSecOffset() * 1000);
    },

nowSec: function (localtimeOffsetMsec) {

return Math.floor(hawk.utils.now(localtimeOffsetMsec) / 1000);
    },

escapeHeaderAttribute: function (attribute) {

return attribute.replace(/\\/g, '\\\\').replace(/\"/g, '\\"');
    },

parseContentType: function (header) {

if (!header) {
            return '';
        }

return header.split(';')[0].replace(/^\s+|\s+$/g, '').toLowerCase();
    },

parseAuthorizationHeader: function (header, keys) {

if (!header) {
            return null;
        }

const headerParts = header.match(/^(\w+)(?:\s+(.*))?$/);       // Header: scheme[ something]
        if (!headerParts) {
            return null;
        }

const scheme = headerParts[1];
        if (scheme.toLowerCase() !== 'hawk') {
            return null;
        }

const attributesString = headerParts[2];
        if (!attributesString) {
            return null;
        }

const attributes = {};
        const verify = attributesString.replace(/(\w+)="([^"\\]*)"\s*(?:,\s*|$)/g, ($0, $1, $2) => {

// Check valid attribute names

if (keys.indexOf($1) === -1) {
                return;
            }

// Allowed attribute value characters: !#$%&'()*+,-./:;<=>?@[]^_`{|}~ and space, a-z, A-Z, 0-9

if ($2.match(/^[ \w\!#\$%&'\*\+,\-\.\/\:;<\=>\?@\[\]\^`\{\|\}~]+$/) === null) {
                return;
            }

// Check for duplicates

if (attributes.hasOwnProperty($1)) {
                return;
            }

attributes[$1] = $2;
            return '';
        });

if (verify !== '') {
            return null;
        }

return attributes;
    },

randomString: function (size) {

const randomSource = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
        const len = randomSource.length;

const result = [];
        for (let i = 0; i < size; ++i) {
            result[i] = randomSource[Math.floor(Math.random() * len)];
        }

return result.join('');
    },

//          1                        2             3      4
    uriRegex: /^([^:]+)\:\/\/(?:[^@/]*@)?([^\/:]+)(?:\:(\d+))?([^#]*)(?:#.*)?$/,       // scheme://credentials@host:port/resource#fragment
    parseUri: function (input) {

const parts = input.match(hawk.utils.uriRegex);
        if (!parts) {
            return { host: '', port: '', resource: '' };
        }

const scheme = parts[1].toLowerCase();
        const uri = {
            host: parts[2],
            port: parts[3] || (scheme === 'http' ? '80' : (scheme === 'https' ? '443' : '')),
            resource: parts[4]
        };

return uri;
    },

base64urlEncode: function (value) {

const wordArray = CryptoJS.enc.Utf8.parse(value);
        const encoded = CryptoJS.enc.Base64.stringify(wordArray);
        return encoded.replace(/\+/g, '-').replace(/\//g, '_').replace(/\=/g, '');
    }
};

// $lab:coverage:off$
/* eslint-disable */

hawk.crypto.utils = CryptoJS;

// Export if used as a module

if (typeof module !== 'undefined' && module.exports) {
    module.exports = hawk;
}

/* eslint-enable */
// $lab:coverage:on$