@sungly/cognito-cli/lib/cmds/authentication/srp-login.js

CLI for all Cognito user life cycle management

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var initiateSrpAuth = function () {
    var _ref3 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee(_ref2) {
        var username = _ref2.username,
            clientId = _ref2.clientId,
            clientSecret = _ref2.clientSecret,
            srpClient = _ref2.srpClient;
        var SRP_A, authParams, params;
        return _regenerator2.default.wrap(function _callee$(_context) {
            while (1) {
                switch (_context.prev = _context.next) {
                    case 0:
                        SRP_A = srpClient.calculateA();
                        authParams = {
                            USERNAME: username,
                            SRP_A: SRP_A
                        };
                        params = {
                            AuthFlow: 'USER_SRP_AUTH',
                            ClientId: clientId,
                            AuthParameters: (0, _util.addSecretHashToParams)({ params: authParams, clientId: clientId, clientSecret: clientSecret, username: username })
                        };
                        return _context.abrupt('return', _util.cognitoClient.initiateAuth(params).promise());

                    case 4:
                    case 'end':
                        return _context.stop();
                }
            }
        }, _callee, this);
    }));

    return function initiateSrpAuth(_x) {
        return _ref3.apply(this, arguments);
    };
}();

exports.default = srpLogin;

var _prompt = require('prompt');

var _prompt2 = _interopRequireDefault(_prompt);

var _amazonUserPoolSrpClient = require('amazon-user-pool-srp-client');

var _config = require('../../config');

var _config2 = _interopRequireDefault(_config);

var _util = require('../../util');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function responseToSrpAuth(_ref) {
    var ChallengeName = _ref.ChallengeName,
        ChallengeParameters = _ref.ChallengeParameters,
        userPoolId = _ref.userPoolId,
        clientId = _ref.clientId,
        clientSecret = _ref.clientSecret,
        password = _ref.password,
        srpClient = _ref.srpClient;

    var hkdf = srpClient.getPasswordAuthenticationKey(ChallengeParameters.USER_ID_FOR_SRP, password, ChallengeParameters.SRP_B, ChallengeParameters.SALT);
    var dateNow = (0, _amazonUserPoolSrpClient.getNowString)();
    var signatureString = (0, _amazonUserPoolSrpClient.calculateSignature)(hkdf, userPoolId, ChallengeParameters.USER_ID_FOR_SRP, ChallengeParameters.SECRET_BLOCK, dateNow);

    var challengeResponses = {
        PASSWORD_CLAIM_SIGNATURE: signatureString,
        PASSWORD_CLAIM_SECRET_BLOCK: ChallengeParameters.SECRET_BLOCK,
        TIMESTAMP: dateNow,
        USERNAME: ChallengeParameters.USERNAME
    };

    var params = {
        ClientId: clientId,
        ChallengeName: ChallengeName,
        ChallengeResponses: (0, _util.addSecretHashToParams)({
            params: challengeResponses,
            clientId: clientId,
            clientSecret: clientSecret,
            username: ChallengeParameters.USERNAME
        })
    };

    return _util.cognitoClient.respondToAuthChallenge(params).promise();
}

function srpLogin() {
    var _this = this;

    _prompt2.default.start();

    _prompt2.default.get([{
        name: 'username',
        required: true
    }, {
        name: 'password',
        hidden: true
    }], function () {
        var _ref4 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee2(err, result) {
            var userPoolId, clientId, clientSecret, poolId, srpClient, _ref5, ChallengeName, ChallengeParameters, res;

            return _regenerator2.default.wrap(function _callee2$(_context2) {
                while (1) {
                    switch (_context2.prev = _context2.next) {
                        case 0:
                            _util.logger.info('message: Logging in...');

                            userPoolId = _config2.default.userPoolId, clientId = _config2.default.clientId, clientSecret = _config2.default.clientSecret;
                            poolId = userPoolId.split('_')[1];
                            srpClient = new _amazonUserPoolSrpClient.SRPClient(poolId);
                            _context2.prev = 4;
                            _context2.next = 7;
                            return initiateSrpAuth({
                                username: result.username,
                                clientId: clientId,
                                clientSecret: clientSecret,
                                srpClient: srpClient
                            });

                        case 7:
                            _ref5 = _context2.sent;
                            ChallengeName = _ref5.ChallengeName;
                            ChallengeParameters = _ref5.ChallengeParameters;
                            _context2.next = 12;
                            return responseToSrpAuth({
                                ChallengeName: ChallengeName,
                                ChallengeParameters: ChallengeParameters,
                                userPoolId: poolId,
                                clientId: clientId,
                                clientSecret: clientSecret,
                                username: result.username,
                                password: result.password,
                                srpClient: srpClient
                            });

                        case 12:
                            res = _context2.sent;


                            _util.logger.info(res);
                            _context2.next = 19;
                            break;

                        case 16:
                            _context2.prev = 16;
                            _context2.t0 = _context2['catch'](4);

                            _util.logger.error(_context2.t0.message);

                        case 19:
                        case 'end':
                            return _context2.stop();
                    }
                }
            }, _callee2, _this, [[4, 16]]);
        }));

        return function (_x2, _x3) {
            return _ref4.apply(this, arguments);
        };
    }());
}