vpn.email/views/api/testImapAccount.js

vpn.email client

"use strict";
const child_process = require("child_process");
const imap_1 = require("./imap");
const Mailcomposer = require("mailcomposer");
const util = require("./util");
const Async = require("async");
const shortID = require("shortid");
const Compress = require("./compress");
const ImapV1_1 = require("./ImapV1");
let lastMessage = '';
let lastErr = '';
const echoTimeOut = 1000 * 10;
const child_processExec = (command, SubEnv, power, debug, CallBack) => {
    const comm = ' node ' + command;
    const envSt = JSON.stringify(global.process.env);
    const SubEnvSt = JSON.stringify(SubEnv);
    const env = JSON.parse('{' + envSt.substr(1, envSt.length - 2) + ',' + SubEnvSt.substr(1, SubEnvSt.length - 2) + '}');
    //console.log (util.inspect ( env ))
    const grep = child_process.exec(comm, { env: env });
    grep.stdout.on('data', (data) => {
        lastMessage = data.toString('utf8');
        if (debug)
            console.log('grep.stdout == ', lastMessage);
    });
    grep.stderr.on('data', (data) => {
        lastErr = data.toString('utf8');
        if (debug)
            console.log('grep.stderr ==> ', lastErr);
    });
    grep.on('close', (code) => {
        if (debug)
            console.log('exit with code:', code);
        CallBack(null, code);
    });
};
const callback = () => {
    if (/Invalid credentials \(Failure\)|Lookup failed|[Incorrect|Invalid] username or password|Authentication failed|authentication failed|LOGIN|Login|service\.mail\.qq\.com/.test(lastMessage))
        return (new Error('passwordErrMsg'));
    if (/getaddrinfo ENOTFOUND/.test(lastMessage))
        return (new Error('hostAddrErr'));
    if (/Your account is not enabled for IMAP use|LOGIN auth error/.test(lastMessage))
        return (new Error('imapEnable'));
    if (/Timed out while authenticating with server/.test(lastMessage))
        return (new Error('hostAuthTimeOut'));
    if (/Timed out while connecting to server/.test(lastMessage))
        return (new Error('hostPortTimeOut'));
    if (/Hostname\/IP doesn't match certificate's altnames/.test(lastMessage))
        return (new Error('hostCertError'));
    if (/ECONNREFUSED/.test(lastMessage))
        return (new Error('ECONNREFUSED'));
    return (new Error('UnknowErr'));
};
exports.testImapCommand = (email, password, host, tls, port, CallBack) => {
    const env = {
        email: email,
        app_password: password,
        host: host,
        tls: tls,
        port: port,
        uuid: ''
    };
    child_processExec('views/api/_testImapAccount', env, '0', true, (err, data) => {
        if (err || data !== 0) {
            return CallBack(callback());
        }
        CallBack();
    });
};
class connectImap {
    constructor(sockSession, CallBack) {
        this.sockSession = sockSession;
        this.echoTimeOut = null;
        this.dockerPublicKey = null;
        this.echoBack = null;
        //this.timeoutFun = setTimeout( ioEvent, 1000 * 120, Io);
        const Config = sockSession.imapArray;
        const key = sockSession.keyPair;
        this.mailFolder = Config.uuid;
        this.emailAddress = Config.account;
        this.imap = new imap_1.default(Config.imapUserName, Config.imapUserPassword, Config.imapServer, parseInt(Config.imapPortNumber), Config.imapSsl, true, Config.uuid, true, true, false, false);
        this.imap._events.on('email', (email) => {
            console.log('listening folder have data from vpn.email server!');
            sockSession.imapConnected = true;
            if (/test@vpn.email/i.test(email.from[0].address)) {
                if (email.attachments && email.attachments.length) {
                    const text = email.attachments[0].content.toString('utf8');
                    if (/^-----BEGIN PGP MESSAGE-----/.test(text)) {
                        util.Decryption(text, sockSession.keyPairPassword, key.privateKeyUTF8, sockSession.dockerPublicKey || sockSession.vpnEmailPublicKey, (err, data) => {
                            if (err)
                                return console.log('Decryption mail err', text);
                            const datas = this.processMailBody(data.data, email);
                            CallBack(data.data);
                        });
                        return;
                    }
                }
            }
            console.log('unknow data format!', email.subject);
        });
        this.imap._events.on('imapReady', () => {
            console.log('IMAP connected');
            sockSession.imapConnected = true;
        });
    }
    saveToVpnEmail(DockerFolder, data, CallBack) {
        Async.waterfall([
            next => util.Encrypt(JSON.stringify(data), this.sockSession.dockerPublicKey, this.sockSession.keyPair.privateKeyUTF8, this.sockSession.keyPairPassword, next),
            (data, next) => {
                const emailOption = {
                    from: this.emailAddress,
                    to: [connectImap.systemEmailAddress],
                    attachments: [{
                            content: data
                        }]
                };
                const email = Mailcomposer(emailOption);
                this.imap.save(DockerFolder, email, next);
            }
        ], err => {
            if (err) {
                console.log('saveToVpnEmail Async.waterfall have ERROR', err);
                return CallBack('UnknowErr');
            }
            CallBack();
        });
    }
    processMailBody(body, email) {
        try {
            const datas = JSON.parse(body);
            const vpnServerConnectData = datas;
            //      echo come
            if (vpnServerConnectData.echo) {
                clearTimeout(this.echoTimeOut);
                console.log('echo return');
                if (this.echoBack && typeof this.echoBack === 'function')
                    this.echoBack();
                this.echoBack = null;
                this.echoTimeOut = null;
                return;
            }
            const command = datas;
            if (command.command && command.command.length) {
                if (/^activePassword$/.test(command.command))
                    this.sockSession.vpnServerConnectData.active = true;
                if (/^echo$/.test(command.command)) {
                }
                if (/^disconnect$/.test(command.command)) {
                    this.sockSession.vpnEmailServerKeepConnected = false;
                }
            }
            //          have docker public key
            if (vpnServerConnectData.haveDockerPublicKey && email.attachments[1].content && email.attachments[1].content.length) {
                const key = email.attachments[1].content.toString('utf8');
                if (/^-----BEGIN PGP PUBLIC KEY BLOCK-----\n/.test(key)) {
                    this.dockerPublicKey = key;
                    this.sockSession.dockerPublicKey = key;
                }
                this.sockSession.vpnServerConnectData = datas;
            }
            return datas;
        }
        catch (ex) {
            console.log('Server data format ERROR', body);
        }
    }
    destroy() {
        this.imap.distroy();
    }
    echoRespon(CallBack) {
        if (!this.sockSession.vpnServerConnectData || !this.sockSession.vpnServerConnectData.serverMailFolder)
            return (new Error(''));
        this.echoBack = CallBack;
        const emailOption = {
            subject: 'echo',
            from: this.emailAddress,
            to: [connectImap.systemEmailAddress]
        };
        const email = Mailcomposer(emailOption);
        console.log('save echo to server folder:', this.sockSession.vpnServerConnectData.serverMailFolder);
        this.imap.save(this.sockSession.vpnServerConnectData.serverMailFolder, email, () => {
            console.log('sent echo success!');
        });
        this.echoTimeOut = setTimeout(() => {
            CallBack(new Error('no'));
            this.echoBack = null;
        }, echoTimeOut);
    }
}
exports.connectImap = connectImap;
connectImap.systemEmailAddress = 'test@vpn.email';
const _ImapPairTest = (user, CallBack) => {
    const listeningFolder = shortID.generate();
    const uuid = shortID.generate();
    const pass = shortID.generate();
    const testText = new Buffer(1200).toString('base64');
    let startTime = null;
    let timeOut = null;
    let callBackData = 0;
    let imapErr = null;
    const content = Compress.packetBuffer(0, 0, uuid, Compress.encrypt(testText, pass));
    const newMail = (mail) => {
        const endTime = new Date();
        try {
            const pp = Compress.openPacket(mail);
            if (pp.uuid != uuid)
                return;
            Compress.decrypt(pp.buffer, pass, (err, data) => {
                imap.destroyImap();
                clearTimeout(timeOut);
                if (err)
                    return imapErr = err;
                return callBackData = new Date().getTime() - startTime.getTime();
            });
        }
        catch (ex) {
            console.log('ImapPairTest new email got ex', ex);
        }
    };
    const imap = new ImapV1_1.default(user, listeningFolder, false, true, newMail, (err, connectDelay) => {
        if (err)
            return CallBack(err);
        CallBack(imapErr, callBackData);
    });
    imap.save(content, listeningFolder, err => {
        if (err) {
            console.log('save got err!', err);
            imap.destroyImap();
            return imapErr = err;
        }
        startTime = new Date();
        timeOut = setTimeout(() => {
            console.log('timeout fire, destroy imap');
            imap.destroyImap();
            return imapErr = new Error('timeout');
        }, 15000);
    });
};
const _doImapPairTest = (user, maxConnect, CallBack) => {
    const loop = [];
    let errCount = 0;
    console.log('start test imap account:', user.imapUserName);
    for (let i = 0; i < maxConnect; i++) {
        loop.push(next => _ImapPairTest(user, next));
    }
    Async.parallel(loop, (err, time) => {
        console.log('_doImapPairTest callack!', err, time);
        if (err)
            return CallBack(err);
        if (time.every(n => n === -1))
            return CallBack(new Error('data error'));
        let u = 0;
        time.map(n => u += n);
        return CallBack(null, u / maxConnect);
    });
};
exports.doImapPairTest = (user, connectNumber, loopCount, CallBack) => {
    const loop = [];
    for (let i = 0; i < loopCount; i++) {
        loop.push(next => _doImapPairTest(user, connectNumber, next));
    }
    Async.series(loop, (err, n) => {
        console.log('doImapPairTest callback', err, n);
        if (err)
            return CallBack(err);
        let u = 0;
        n.map(n => u += n);
        return CallBack(null, u / loopCount);
    });
};
const user = [
    {
        imapUserName: 'proxyviaemail.test@yahoo.com',
        imapServer: 'imap.mail.yahoo.com',
        imapUserPassword: 'xgaupnackgdxbnpk',
        imapPortNumber: '993',
        serverMailBoxName: 'testMailBoxNameFromServer',
        dummyData: null,
        VpnviaEmailCheckOK: null,
        power: null,
        machineID: null,
        runningContainerData: null,
        imapSsl: true,
        Status: null,
        publicKey: null,
        uuid: 'testMailBoxNameFromClient',
        publicKey_id: null,
        systemPassword: null,
        account: null,
        email: null,
        password: null,
        smtpServer: null,
        smtpUserName: null,
        smtpSsl: null,
        smtpPortNumber: null,
        smtpUserPassword: null
    },
    {
        imapUserName: 'proxyviaemail@yahoo.com',
        imapServer: 'imap.mail.yahoo.com',
        imapUserPassword: 'ivqzejervrrumtqr',
        imapPortNumber: '993',
        serverMailBoxName: 'testMailBoxNameFromServer',
        dummyData: null,
        VpnviaEmailCheckOK: null,
        power: null,
        machineID: null,
        runningContainerData: null,
        imapSsl: true,
        Status: null,
        publicKey: null,
        uuid: 'testMailBoxNameFromClient',
        publicKey_id: null,
        systemPassword: null,
        account: null,
        email: null,
        password: null,
        smtpServer: null,
        smtpUserName: null,
        smtpSsl: null,
        smtpPortNumber: null,
        smtpUserPassword: null
    },
    {
        imapUserName: 'proxyviaemail@gmail.com',
        imapServer: 'imap.gmail.com',
        imapUserPassword: 'jsbznwsacaowjrbh',
        imapPortNumber: '993',
        serverMailBoxName: 'testMailBoxNameFromServer',
        dummyData: null,
        VpnviaEmailCheckOK: null,
        power: null,
        machineID: null,
        runningContainerData: null,
        imapSsl: true,
        Status: null,
        publicKey: null,
        uuid: 'testMailBoxNameFromClient',
        publicKey_id: null,
        systemPassword: null,
        account: null,
        email: null,
        password: null,
        smtpServer: null,
        smtpUserName: null,
        smtpSsl: null,
        smtpPortNumber: null,
        smtpUserPassword: null
    },
    {
        imapUserName: 'proxyviaemai_test@hotmail.com',
        imapServer: 'imap-mail.outlook.com',
        imapUserPassword: 'qtxfcxcntuokmdkv',
        imapPortNumber: '993',
        serverMailBoxName: 'testMailBoxNameFromServer',
        dummyData: null,
        VpnviaEmailCheckOK: null,
        power: null,
        machineID: null,
        runningContainerData: null,
        imapSsl: true,
        Status: null,
        publicKey: null,
        uuid: 'testMailBoxNameFromClient',
        publicKey_id: null,
        systemPassword: null,
        account: null,
        email: null,
        password: null,
        smtpServer: null,
        smtpUserName: null,
        smtpSsl: null,
        smtpPortNumber: null,
        smtpUserPassword: null
    },
    {
        imapUserName: 'proxyviaemai@hotmail.com',
        imapServer: 'imap-mail.outlook.com',
        imapUserPassword: 'jtsxjmnkrsfmozah',
        imapPortNumber: '993',
        serverMailBoxName: 'testMailBoxNameFromServer',
        dummyData: null,
        VpnviaEmailCheckOK: null,
        power: null,
        machineID: null,
        runningContainerData: null,
        imapSsl: true,
        Status: null,
        publicKey: null,
        uuid: 'testMailBoxNameFromClient',
        publicKey_id: null,
        systemPassword: null,
        account: null,
        email: null,
        password: null,
        smtpServer: null,
        smtpUserName: null,
        smtpSsl: null,
        smtpPortNumber: null,
        smtpUserPassword: null
    },
    {
        imapUserName: 'proxyviaemai@outlook.com',
        imapServer: 'imap-mail.outlook.com',
        imapUserPassword: 'wkjynmnrgoakyysh',
        imapPortNumber: '993',
        serverMailBoxName: 'testMailBoxNameFromServer',
        dummyData: null,
        VpnviaEmailCheckOK: null,
        power: null,
        machineID: null,
        runningContainerData: null,
        imapSsl: true,
        Status: null,
        publicKey: null,
        uuid: 'testMailBoxNameFromClient',
        publicKey_id: null,
        systemPassword: null,
        account: null,
        email: null,
        password: null,
        smtpServer: null,
        smtpUserName: null,
        smtpSsl: null,
        smtpPortNumber: null,
        smtpUserPassword: null
    },
    {
        imapUserName: 'vpn.emai1@outlook.com',
        imapServer: 'imap-mail.outlook.com',
        imapUserPassword: 'bvftsuzuvlbhneun',
        imapPortNumber: '993',
        serverMailBoxName: 'testMailBoxNameFromServer',
        dummyData: null,
        VpnviaEmailCheckOK: null,
        power: null,
        machineID: null,
        runningContainerData: null,
        imapSsl: true,
        Status: null,
        publicKey: null,
        uuid: 'testMailBoxNameFromClient',
        publicKey_id: null,
        systemPassword: null,
        account: null,
        email: null,
        password: null,
        smtpServer: null,
        smtpUserName: null,
        smtpSsl: null,
        smtpPortNumber: null,
        smtpUserPassword: null
    },
    {
        imapUserName: 'vpn.emai1@hotmail.com',
        imapServer: 'imap-mail.outlook.com',
        imapUserPassword: 'ckonxsoafvtvpjig',
        imapPortNumber: '993',
        serverMailBoxName: 'testMailBoxNameFromServer',
        dummyData: null,
        VpnviaEmailCheckOK: null,
        power: null,
        machineID: null,
        runningContainerData: null,
        imapSsl: true,
        Status: null,
        publicKey: null,
        uuid: 'testMailBoxNameFromClient',
        publicKey_id: null,
        systemPassword: null,
        account: null,
        email: null,
        password: null,
        smtpServer: null,
        smtpUserName: null,
        smtpSsl: null,
        smtpPortNumber: null,
        smtpUserPassword: null
    },
    {
        imapUserName: 'vpn.emai2@outlook.com',
        imapServer: 'imap-mail.outlook.com',
        imapUserPassword: 'ouqfvthomtelgyjd',
        imapPortNumber: '993',
        serverMailBoxName: 'testMailBoxNameFromServer',
        dummyData: null,
        VpnviaEmailCheckOK: null,
        power: null,
        machineID: null,
        runningContainerData: null,
        imapSsl: true,
        Status: null,
        publicKey: null,
        uuid: 'testMailBoxNameFromClient',
        publicKey_id: null,
        systemPassword: null,
        account: null,
        email: null,
        password: null,
        smtpServer: null,
        smtpUserName: null,
        smtpSsl: null,
        smtpPortNumber: null,
        smtpUserPassword: null
    },
    {
        imapUserName: '1035159026@qq.com',
        imapServer: 'imap.qq.com',
        imapUserPassword: 'drfhgkvskoilwe333vr',
        imapPortNumber: '993',
        serverMailBoxName: 'command',
        dummyData: null,
        VpnviaEmailCheckOK: null,
        power: null,
        machineID: null,
        runningContainerData: null,
        imapSsl: true,
        Status: null,
        publicKey: null,
        uuid: 'command1',
        publicKey_id: null,
        systemPassword: null,
        account: null,
        email: null,
        password: null,
        smtpServer: null,
        smtpUserName: null,
        smtpSsl: null,
        smtpPortNumber: null,
        smtpUserPassword: null
    },
    {
        imapUserName: 'proxyviaemail@gmx.com',
        imapServer: 'imap.gmx.com',
        imapUserPassword: 'Iosubly1',
        imapPortNumber: '993',
        serverMailBoxName: 'command',
        dummyData: null,
        VpnviaEmailCheckOK: null,
        power: null,
        machineID: null,
        runningContainerData: null,
        imapSsl: true,
        Status: null,
        publicKey: null,
        uuid: 'command1',
        publicKey_id: null,
        systemPassword: null,
        account: null,
        email: null,
        password: null,
        smtpServer: null,
        smtpUserName: null,
        smtpSsl: null,
        smtpPortNumber: null,
        smtpUserPassword: null
    }
];
exports.doImapPairTest(user[10], 6, 10, (err, j) => {
    if (err)
        return console.log('ERROR:', err);
    console.log(j);
});