@mbtest/mountebank 2.9.2-beta.9050

package/src/models/http/baseHttpServer.js

@@ -0,0 +1,207 @@
+'use strict';
+
+/**
+ * The base implementation of http/s servers
+ * @module
+ */
+
+const net = require('net'),
+    headersMap = require('./headersMap.js'),
+    errors = require('../../util/errors.js'),
+    httpProxy = require('./httpProxy.js'),
+    httpRequest = require('./httpRequest.js'),
+    helpers = require('../../util/helpers.js');
+
+module.exports = function (createBaseServer) {
+
+    function create (options, logger, responseFn) {
+        const connections = {},
+            defaultResponse = options.defaultResponse || {};
+
+        function postProcess (stubResponse, request) {
+            /* eslint complexity: 0 */
+            const defaultHeaders = defaultResponse.headers || {},
+                response = {
+                    statusCode: stubResponse.statusCode || defaultResponse.statusCode || 200,
+                    headers: stubResponse.headers || defaultHeaders,
+                    body: stubResponse.body || defaultResponse.body || '',
+                    _mode: stubResponse._mode || defaultResponse._mode || 'text'
+                },
+                responseHeaders = headersMap.of(response.headers),
+                encoding = response._mode === 'binary' ? 'base64' : 'utf8',
+                isObject = helpers.isObject;
+
+            if (isObject(response.body)) {
+                // Support JSON response bodies
+                response.body = JSON.stringify(response.body, null, 4);
+            }
+
+            if (options.allowCORS) {
+                const requestHeaders = headersMap.of(request.headers),
+                    isCrossOriginPreflight = request.method === 'OPTIONS' &&
+                        requestHeaders.get('Access-Control-Request-Headers') &&
+                        requestHeaders.get('Access-Control-Request-Method') &&
+                        requestHeaders.get('Origin');
+
+                if (isCrossOriginPreflight) {
+                    responseHeaders.set('Access-Control-Allow-Headers', requestHeaders.get('Access-Control-Request-Headers'));
+                    responseHeaders.set('Access-Control-Allow-Methods', requestHeaders.get('Access-Control-Request-Method'));
+                    responseHeaders.set('Access-Control-Allow-Origin', requestHeaders.get('Origin'));
+                }
+            }
+
+            if (encoding === 'base64') {
+                // ensure the base64 has no newlines or other non
+                // base64 chars that will cause the body to be garbled.
+                response.body = response.body.replace(/[^A-Za-z0-9=+/]+/g, '');
+            }
+
+            if (!responseHeaders.has('Connection')) {
+                responseHeaders.set('Connection', 'close');
+            }
+
+            if (responseHeaders.has('Content-Length')) {
+                responseHeaders.set('Content-Length', Buffer.byteLength(response.body, encoding));
+            }
+
+            return response;
+        }
+
+        const baseServer = createBaseServer(options),
+            server = baseServer.createNodeServer();
+
+        // Allow long wait behaviors
+        server.timeout = 0;
+
+        server.on('connect', (response, client, head) => {
+            const host = response.socket.servername;
+            const port = response.socket.localPort;
+            // may we prefer this method instead?
+            const proxyServer = net.createConnection({ host, port }, () => {
+                client.on('error', err => {
+                    logger.warn('CLIENT TO PROXY ERROR: [%s] %s', err.code, err.message);
+                    logger.debug('%s', err.stack);
+                });
+                proxyServer.on('error', err => {
+                    logger.warn('SERVER PROXY ERROR: [%s] %s', err.code, err.message);
+                    logger.debug('%s', err.stack);
+                });
+
+                logger.info('PROXY TO SERVER SET UP TO %s ON %s', host, port);
+                client.write('HTTP/1.1 200 Connection established\r\n\r\n');
+                proxyServer.write(head);
+                proxyServer.pipe(client);
+                client.pipe(proxyServer);
+            });
+        });
+
+        server.on('connection', socket => {
+            const name = helpers.socketName(socket);
+
+            logger.debug('%s ESTABLISHED', name);
+
+            if (socket.on) {
+                connections[name] = socket;
+
+                socket.on('error', error => {
+                    logger.error('%s transmission error X=> %s', name, JSON.stringify(error));
+                });
+
+                socket.on('end', () => {
+                    logger.debug('%s LAST-ACK', name);
+                });
+
+                socket.on('close', () => {
+                    logger.debug('%s CLOSED', name);
+                    delete connections[name];
+                });
+            }
+        });
+
+        server.on('request', async (request, response) => {
+            const clientName = helpers.socketName(request.socket);
+
+            logger.info(`${clientName} => ${request.method} ${request.url}`);
+
+            try {
+                const simplifiedRequest = await httpRequest.createFrom(request);
+                logger.debug('%s => %s', clientName, JSON.stringify(simplifiedRequest));
+
+                const mbResponse = await responseFn(simplifiedRequest, { rawUrl: request.url }),
+                    stubResponse = postProcess(mbResponse, simplifiedRequest),
+                    encoding = stubResponse._mode === 'binary' ? 'base64' : 'utf8';
+
+                if (mbResponse.blocked) {
+                    request.socket.destroy();
+                    return;
+                }
+
+                if (helpers.simulateFault(request.socket, mbResponse.fault, logger)) {
+                    return;
+                }
+
+                response.writeHead(stubResponse.statusCode, stubResponse.headers);
+                response.end(stubResponse.body.toString(), encoding);
+
+                if (stubResponse) {
+                    logger.debug('%s <= %s', clientName, JSON.stringify(stubResponse));
+                }
+            }
+            catch (error) {
+                const exceptions = errors;
+                logger.error('%s X=> %s', clientName, JSON.stringify(exceptions.details(error)));
+                response.writeHead(500, { 'content-type': 'application/json' });
+                response.end(JSON.stringify({ errors: [exceptions.details(error)] }), 'utf8');
+            }
+        });
+
+        return new Promise((resolve, reject) => {
+            server.on('error', error => {
+                if (error.errno === 'EADDRINUSE') {
+                    reject(errors.ResourceConflictError(`Port ${options.port} is already in use`));
+                }
+                else if (error.errno === 'EACCES') {
+                    reject(errors.InsufficientAccessError());
+                }
+                else {
+                    reject(error);
+                }
+            });
+
+            // Bind the socket to a port (the || 0 bit auto-selects a port if one isn't provided)
+            server.listen(options.port || 0, options.host, () => {
+                resolve({
+                    port: server.address().port,
+                    metadata: baseServer.metadata,
+                    close: callback => {
+                        server.close(callback);
+                        Object.keys(connections).forEach(socket => {
+                            connections[socket].destroy();
+                        });
+                    },
+                    proxy: httpProxy.create(logger),
+                    encoding: 'utf8'
+                });
+            });
+        });
+    }
+
+    return {
+        testRequest: {
+            requestFrom: '',
+            method: 'GET',
+            path: '/',
+            query: {},
+            headers: {},
+            form: {},
+            body: ''
+        },
+        testProxyResponse: {
+            statusCode: 200,
+            headers: {},
+            body: ''
+        },
+        create: create,
+        validate: undefined
+    };
+};

package/src/models/http/headersMap.js

@@ -0,0 +1,87 @@
+'use strict';
+
+/**
+ * Utility module to to get and set headers in a case-insensitive way while maintaining
+ * the original case sent in the request
+ * @module
+ */
+
+/**
+ * Creates a map from the given headers
+ * @param {Object} headers - the starting headers
+ * @returns {Object} - the map
+ */
+
+const helpers = require('../../util/helpers.js');
+
+function of (headers) {
+    /**
+     * Returns whether the map contains the given headerName, regardless of case
+     * @param {String} headerName - the header name
+     * @returns {boolean}
+     */
+    function has (headerName) {
+        return Object.keys(headers).some(header => header.toLowerCase() === headerName.toLowerCase());
+    }
+
+    function headerNameFor (headerName) {
+        const result = Object.keys(headers).find(header => header.toLowerCase() === headerName.toLowerCase());
+
+        return helpers.defined(result) ? result : headerName;
+    }
+
+    /**
+     * Retrieves the value for the given header in a case-insensitive way
+     * @param {String} headerName - the header name
+     * @returns {*}
+     */
+    function get (headerName) {
+        return headers[headerNameFor(headerName)];
+    }
+
+    /**
+     * Sets the value for the given header in a case-insensitive way.
+     * Will add the key if it does not already exist
+     * @param {String} headerName - the header name
+     * @param {String} value - the value
+     */
+    function set (headerName, value) {
+        headers[headerNameFor(headerName)] = value;
+    }
+
+    /**
+     * Retrieves all the headers with the original case for the keys
+     * @returns {Object} - the key/value pairs
+     */
+    function all () {
+        return headers;
+    }
+
+    return { get, set, has, all };
+}
+
+function add (current, value) {
+    return Array.isArray(current) ? current.concat(value) : [current].concat(value);
+}
+
+function arrayifyIfExists (current, value) {
+    return current ? add(current, value) : value;
+}
+
+/**
+ * Converts the array of raw headers to a map, maintaining the original case of the keys.
+ * This is necessary since node downcases the headers in its request.headers
+ * @param {Object} rawHeaders - the array of alternating keys and values
+ * @returns {Object} - the map
+ */
+function ofRaw (rawHeaders) {
+    const result = {};
+    for (let i = 0; i < rawHeaders.length; i += 2) {
+        const name = rawHeaders[i];
+        const value = rawHeaders[i + 1];
+        result[name] = arrayifyIfExists(result[name], value);
+    }
+    return of(result);
+}
+
+module.exports = { ofRaw, of };

package/src/models/http/httpProxy.js

@@ -0,0 +1,230 @@
+'use strict';
+
+/**
+ * The proxy implementation for http/s imposters
+ * @module
+ */
+
+const https = require('https'),
+    http = require('http'),
+    queryString = require('querystring'),
+    HttpProxyAgent = require('http-proxy-agent'),
+    HttpsProxyAgent = require('https-proxy-agent'),
+    helpers = require('../../util/helpers.js'),
+    headersMap = require('./headersMap.js'),
+    errors = require('../../util/errors.js');
+
+
+process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+
+/**
+ * Creates the proxy
+ * @param {Object} logger - The logger
+ * @returns {Object}
+ */
+function create (logger) {
+    const BINARY_CONTENT_ENCODINGS = [
+        'gzip', 'br', 'compress', 'deflate'
+    ];
+    const BINARY_MIME_TYPES = [
+        'audio/',
+        'application/epub+zip',
+        'application/gzip',
+        'application/java-archive',
+        'application/msword',
+        'application/octet-stream',
+        'application/pdf',
+        'application/rtf',
+        'application/vnd.ms-excel',
+        'application/vnd.ms-fontobject',
+        'application/vnd.ms-powerpoint',
+        'application/vnd.visio',
+        'application/x-shockwave-flash',
+        'application/x-tar',
+        'application/zip',
+        'font/',
+        'image/',
+        'model/',
+        'video/'
+    ];
+
+    function addInjectedHeadersTo (request, headersToInject) {
+        Object.keys(headersToInject || {}).forEach(key => {
+            request.headers[key] = headersToInject[key];
+        });
+    }
+
+    function toUrl (path, query, requestDetails) {
+        if (requestDetails) {
+            // Not passed in outOfProcess mode
+            return requestDetails.rawUrl;
+        }
+
+        const tail = queryString.stringify(query);
+
+        if (tail === '') {
+            return path;
+        }
+        return `${path}?${tail}`;
+    }
+
+    function hostnameFor (protocol, host, port) {
+        let result = host;
+        if ((protocol === 'http:' && port !== 80) || (protocol === 'https:' && port !== 443)) {
+            result += `:${port}`;
+        }
+        return result;
+    }
+
+    function setProxyAgent (parts, options) {
+        if (process.env.http_proxy && parts.protocol === 'http:') {
+            options.agent = new HttpProxyAgent(process.env.http_proxy);
+        }
+        else if (process.env.https_proxy && parts.protocol === 'https:') {
+            options.agent = new HttpsProxyAgent(process.env.https_proxy);
+        }
+    }
+
+    function getProxyRequest (baseUrl, originalRequest, proxyOptions, requestDetails) {
+        /* eslint complexity: 0 */
+        const parts = new URL(baseUrl),
+            protocol = parts.protocol === 'https:' ? https : http,
+            defaultPort = parts.protocol === 'https:' ? 443 : 80,
+            options = {
+                method: originalRequest.method,
+                hostname: parts.hostname,
+                port: parts.port || defaultPort,
+                auth: parts.auth,
+                path: toUrl(originalRequest.path, originalRequest.query, requestDetails),
+                headers: helpers.clone(originalRequest.headers),
+                cert: proxyOptions.cert,
+                key: proxyOptions.key,
+                ciphers: proxyOptions.ciphers || 'ALL',
+                secureProtocol: proxyOptions.secureProtocol,
+                passphrase: proxyOptions.passphrase,
+                rejectUnauthorized: false
+            };
+
+        // Only set host header if not overridden via injectHeaders (issue #388)
+        if (!proxyOptions.injectHeaders || !headersMap.of(proxyOptions.injectHeaders).has('host')) {
+            options.headers.host = hostnameFor(parts.protocol, parts.hostname, options.port);
+        }
+        setProxyAgent(parts, options);
+
+        // Avoid implicit chunked encoding (issue #132)
+        if (originalRequest.body &&
+            !headersMap.of(originalRequest.headers).has('Transfer-Encoding') &&
+            !headersMap.of(originalRequest.headers).has('Content-Length')) {
+            options.headers['Content-Length'] = Buffer.byteLength(originalRequest.body);
+        }
+
+        const proxiedRequest = protocol.request(options);
+        if (originalRequest.body) {
+            proxiedRequest.write(originalRequest.body);
+        }
+        return proxiedRequest;
+    }
+
+    function isBinaryResponse (headers) {
+        const contentEncoding = headers['content-encoding'] || '',
+            contentType = headers['content-type'] || '';
+
+        if (BINARY_CONTENT_ENCODINGS.some(binEncoding => contentEncoding.indexOf(binEncoding) >= 0)) {
+            return true;
+        }
+
+        return BINARY_MIME_TYPES.some(typeName => contentType.indexOf(typeName) >= 0);
+    }
+
+    function maybeJSON (text) {
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    }
+
+    function proxy (proxiedRequest) {
+        return new Promise(resolve => {
+            proxiedRequest.end();
+
+            proxiedRequest.once('response', response => {
+                const packets = [];
+
+                response.on('data', chunk => {
+                    packets.push(chunk);
+                });
+
+                response.on('end', () => {
+                    const body = Buffer.concat(packets),
+                        mode = isBinaryResponse(response.headers) ? 'binary' : 'text',
+                        encoding = mode === 'binary' ? 'base64' : 'utf8',
+                        stubResponse = {
+                            statusCode: response.statusCode,
+                            headers: headersMap.ofRaw(response.rawHeaders).all(),
+                            body: maybeJSON(body.toString(encoding)),
+                            _mode: mode
+                        };
+                    resolve(stubResponse);
+                });
+            });
+        });
+    }
+
+    /**
+     * Proxies an http/s request to a destination
+     * @memberOf module:models/http/httpProxy#
+     * @param {string} proxyDestination - The base URL to proxy to, without a path (e.g. http://www.google.com)
+     * @param {Object} originalRequest - The original http/s request to forward on to proxyDestination
+     * @param {Object} options - Proxy options
+     * @param {string} [options.cert] - The certificate, in case the destination requires mutual authentication
+     * @param {string} [options.key] - The private key, in case the destination requires mutual authentication
+     * @param {Object} [options.injectHeaders] - The headers to inject in the proxied request
+     * @param {Object} [options.passphrase] - The passphrase for the private key
+     * @param {Object} requestDetails - Additional details about the request not stored in the simplified JSON
+     * @returns {Object} - Promise resolving to the response
+     */
+    function to (proxyDestination, originalRequest, options, requestDetails) {
+
+        addInjectedHeadersTo(originalRequest, options.injectHeaders);
+
+        function log (direction, what) {
+            logger.debug('Proxy %s %s %s %s %s',
+                originalRequest.requestFrom, direction, JSON.stringify(what), direction, proxyDestination);
+        }
+
+        return new Promise((resolve, reject) => {
+            let proxiedRequest;
+            try {
+                proxiedRequest = getProxyRequest(proxyDestination, originalRequest, options, requestDetails);
+            }
+            catch (e) {
+                reject(errors.InvalidProxyError(`Unable to connect to ${JSON.stringify(proxyDestination)}`));
+            }
+
+            log('=>', originalRequest);
+
+            proxiedRequest.once('error', error => {
+                if (error.code === 'ENOTFOUND' || error.code === 'EAI_AGAIN') {
+                    reject(errors.InvalidProxyError(`Cannot resolve ${JSON.stringify(proxyDestination)}`));
+                }
+                else if (error.code === 'ECONNREFUSED' || error.code === 'ECONNRESET') {
+                    reject(errors.InvalidProxyError(`Unable to connect to ${JSON.stringify(proxyDestination)}`));
+                }
+                else {
+                    reject(error);
+                }
+            });
+
+            proxy(proxiedRequest).then(response => {
+                log('<=', response);
+                resolve(response);
+            });
+        });
+    }
+
+    return { to };
+}
+
+module.exports = { create };

package/src/models/http/httpRequest.js

@@ -0,0 +1,82 @@
+'use strict';
+
+const queryString = require('querystring'),
+    zlib = require('zlib'),
+    helpers = require('../../util/helpers.js'),
+    headersMapModule = require('./headersMap.js');
+
+
+/**
+ * Transforms a node http/s request to a simplified mountebank http/s request
+ * that will be shown in the API
+ * @module
+ */
+
+function transform (request) {
+    const url = new URL(request.url, 'http://localhost'),
+        search = url.search === '' ? '' : url.search.substr(1),
+        headersMap = headersMapModule.ofRaw(request.rawHeaders),
+        transformed = {
+            requestFrom: helpers.socketName(request.socket),
+            method: request.method,
+            path: url.pathname,
+            query: queryString.parse(search),
+            headers: headersMap.all(),
+            body: request.body,
+            ip: request.socket.remoteAddress
+        },
+        contentType = headersMap.get('Content-Type');
+
+    if (request.body && isUrlEncodedForm(contentType)) {
+        transformed.form = queryString.parse(request.body);
+    }
+
+    return transformed;
+}
+
+function isUrlEncodedForm (contentType) {
+    if (!contentType) {
+        return false;
+    }
+
+    const index = contentType.indexOf(';'),
+        type = index !== -1 ? contentType.substr(0, index).trim() : contentType.trim();
+
+    return type === 'application/x-www-form-urlencoded';
+}
+
+/**
+ * Creates the API-friendly http/s request
+ * @param {Object} request - The raw http/s request
+ * @returns {Object} - Promise resolving to the simplified request
+ */
+function createFrom (request) {
+    return new Promise(resolve => {
+        const chunks = [];
+        request.on('data', chunk => { chunks.push(Buffer.from(chunk)); });
+        request.on('end', () => {
+            const headersMap = headersMapModule.ofRaw(request.rawHeaders),
+                contentEncoding = headersMap.get('Content-Encoding'),
+                buffer = Buffer.concat(chunks);
+
+            if (contentEncoding === 'gzip') {
+                try {
+                    request.body = zlib.gunzipSync(buffer).toString();
+                }
+                catch (error) { /* do nothing */ }
+            }
+            else if (contentEncoding === 'br') {
+                try {
+                    request.body = zlib.brotliDecompressSync(buffer).toString();
+                }
+                catch (error) { /* do nothing */ }
+            }
+            else {
+                request.body = buffer.toString();
+            }
+            resolve(transform(request));
+        });
+    });
+}
+
+module.exports = { createFrom };

package/src/models/http/httpServer.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const http = require('http'),
+    baseHttpServer = require('./baseHttpServer.js');
+
+/**
+ * Represents an http imposter
+ * @module
+ */
+
+function createBaseServer () {
+    return {
+        metadata: {},
+        createNodeServer: http.createServer
+    };
+}
+
+module.exports = baseHttpServer(createBaseServer);

package/src/models/http/index.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const config = JSON.parse(process.argv[2]),
+    httpServer = require('./httpServer.js'),
+    httpProxy = require('./httpProxy.js'),
+    mbConnection = require('../mbConnection.js').create(config);
+
+httpServer.create(config, mbConnection.logger(), mbConnection.getResponse).then(server => {
+    mbConnection.setPort(server.port);
+    mbConnection.setProxy(httpProxy.create(mbConnection.logger()));
+
+    const metadata = server.metadata;
+    metadata.port = server.port;
+    console.log(JSON.stringify(metadata));
+}).catch(error => {
+    console.error(JSON.stringify(error));
+    process.exit(1); // eslint-disable-line no-process-exit
+});

package/src/models/https/cert/mb-cert.pem

@@ -0,0 +1,20 @@
+-----BEGIN CERTIFICATE-----
+MIIDMTCCAhkCFC1be7uOugfu2q1NmVapw9+SQ0skMA0GCSqGSIb3DQEBCwUAMFUx
+CzAJBgNVBAYTAlVTMQswCQYDVQQIDAJUWDEPMA0GA1UEBwwGRGFsbGFzMRMwEQYD
+VQQKDAptb3VudGViYW5rMRMwEQYDVQQDDAptb3VudGViYW5rMB4XDTIzMDYwNjAy
+MjE0MVoXDTMzMDYwMzAyMjE0MVowVTELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAlRY
+MQ8wDQYDVQQHDAZEYWxsYXMxEzARBgNVBAoMCm1vdW50ZWJhbmsxEzARBgNVBAMM
+Cm1vdW50ZWJhbmswggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDM+JWj
+JFwtRE++8pTUs6GyWFLKMGSsZDUyJG0n9QivhJPE3fovecKzBdRZZUrAjHWP1Xxp
+DLsqfy3FKzD9bEI2bIaa6Bv3QCUiSEheXteBlljltd4Rhup9yWnpwkBmDW4FIxV6
+Hm5aOyRx41EGcq4Ir0rwpTMkHRrakCKkyVCuhcPbAeTtJn2jw9QIJB3G2IsWuziU
+Fmg2TO90HPUpeoVVEgoO9B9DuCX3QmFBki3xTmm9HnvZ7C0tRZM6Y2aEWoPlzosE
+7PcFjDmd9jmSXo3NED9+tDc4Xaoc9iPBpLMCqe6DaZBbqHxSFFS6spBJClqev09g
+45PC3HqXl/Qxzj7VAgMBAAEwDQYJKoZIhvcNAQELBQADggEBAH2pBSp0wtEmRiuY
+9jhnB8C7pFDOUSUHIfOXKovH92ErqA0KGFvAhCShV71OW63C+7BfJTkt0Gq0pwfD
+TdDQ1T9YNFU6NbNbMfSG9u0TMwajnawnNdO5Gk6LtXJFseWsn5PblCVrWD/qvLMF
+DcllKYW8a8GBbttngt0bhGvh+DxPesjkHoeIWed6UCo3+Wdypes/vol3GL/e8Re5
+uy3eKSBPR5dx/s6l/ZPDEksYV1ve5jv/lBKmRFKv5bFGiTrd5eUE25P2+n9DNGyY
+yNrcLvc1WY/0sqGFmo2ci4ECZVDwx/GhKhdZw7IY8tfLfsKR7sAI6nDHO/GbPYYd
+piqTpzQ=
+-----END CERTIFICATE-----

package/src/models/https/cert/mb-csr.pem

@@ -0,0 +1,16 @@
+-----BEGIN CERTIFICATE REQUEST-----
+MIICmjCCAYICAQAwVTELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAlRYMQ8wDQYDVQQH
+DAZEYWxsYXMxEzARBgNVBAoMCm1vdW50ZWJhbmsxEzARBgNVBAMMCm1vdW50ZWJh
+bmswggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDM+JWjJFwtRE++8pTU
+s6GyWFLKMGSsZDUyJG0n9QivhJPE3fovecKzBdRZZUrAjHWP1XxpDLsqfy3FKzD9
+bEI2bIaa6Bv3QCUiSEheXteBlljltd4Rhup9yWnpwkBmDW4FIxV6Hm5aOyRx41EG
+cq4Ir0rwpTMkHRrakCKkyVCuhcPbAeTtJn2jw9QIJB3G2IsWuziUFmg2TO90HPUp
+eoVVEgoO9B9DuCX3QmFBki3xTmm9HnvZ7C0tRZM6Y2aEWoPlzosE7PcFjDmd9jmS
+Xo3NED9+tDc4Xaoc9iPBpLMCqe6DaZBbqHxSFFS6spBJClqev09g45PC3HqXl/Qx
+zj7VAgMBAAGgADANBgkqhkiG9w0BAQsFAAOCAQEAUiKzIKhw1QfOeJ2HGmyC9cyh
+r32YyUWVyKWEIdFedcsZcisGE+95UFeakP18LEnfnz8fMfxJHA/J/2rsLxvwx7UI
+naZ9IW+RjSbpZvA3HKoiDubc29sBYX6QGdjMYQpxLzJhW20VpPx29TTVmR2Sg2rM
+P5zhUtYi8YqE2P8bRGZTMsm585Y36dzUl4u5JKVNWBH6Z7q+339I0i+Y+EfoWDzb
+HXztEH9OcyGbWD2sHJGLaEwYVCm6RmFRtCX9LCBjt2lPfmHwm4L+qSfUPRdsfixh
+clLJfcE5i11Ydacp6Mlff3PXkM96Aw4t6CE9fudu1uaAMVoSq9vpmSp0tnrtXA==
+-----END CERTIFICATE REQUEST-----