static createDecipherBundle(serverSideEncryptionInfo, offset,
                                log, cb) {
        if (!serverSideEncryptionInfo.masterKeyId ||
            !serverSideEncryptionInfo.cipheredDataKey ||
            !serverSideEncryptionInfo.cryptoScheme) {
            log.error('Invalid cryptographic information', { implName });
            return cb(errors.InternalError);
        }
        const decipherBundle = {
            cryptoScheme: serverSideEncryptionInfo.cryptoScheme,
            decipher: null,
        };

        // shadowing global client for key - implName already used can't be shadowed here
        const { error, client, implName: _impl, key } = getClientForKey(
            serverSideEncryptionInfo.masterKeyId, log);
        if (error) {
            return cb(error);
        }

        return async.waterfall([
            function decipherDataKey(next) {
                return client.decipherDataKey(
                    decipherBundle.cryptoScheme,
                    key,
                    serverSideEncryptionInfo.cipheredDataKey,
                    log, (err, plainTextDataKey) => {
                        log.debug('deciphering a data key');
                        if (err) {
                            log.debug('error from kms',
                                     { implName: _impl, error: err });
                            return next(err);
                        }
                        log.trace('data key deciphered by the kms');
                        return next(null, plainTextDataKey);
                    });
            },
            function createDecipher(plainTextDataKey, next) {
                log.debug('creating a decipher');
                return Common.createDecipher(decipherBundle.cryptoScheme,
                    plainTextDataKey, offset, log, (err, decipher) => {
                        plainTextDataKey.fill(0);
                        if (err) {
                            log.debug('error from kms',
                            { implName: _impl, error: err });
                            return next(err);
                        }
                        log.trace('decipher created by the kms');
                        return next(null, decipher);
                    });
            },
            function finishDecipherBundle(decipher, next) {
                decipherBundle.decipher = decipher;
                return next(null, decipherBundle);
            },
        ], (err, decipherBundle) => {
            if (err) {
                log.error('error processing decipher bundle',
                          { implName: _impl, error: err });
                return cb(err);
            }
            return cb(err, decipherBundle);
        });
    }
createDecipherBundle
@param {object} serverSideEncryptionInfo - info for decryption
@param {number} serverSideEncryptionInfo.cryptoScheme -
cryptoScheme used
@param {string} serverSideEncryptionInfo.algorithm -
algorithm to use
@param {string} serverSideEncryptionInfo.masterKeyId -
key to get master key
@param {boolean} serverSideEncryptionInfo.mandatory -
true for mandatory encryption
@param {buffer} serverSideEncryptionInfo.cipheredDataKey -
ciphered data key
@param {number} offset - offset for decryption
@param {object} log - logger object
@param {function} cb - cb from external call
@returns {undefined}
@callback called with (err, decipherBundle)