dbgate-api 5.4.0 → 5.4.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dbgate-api",
   "main": "src/index.js",
-  "version": "5.4.0",
+  "version": "5.4.2",
   "homepage": "https://dbgate.org/",
   "repository": {
     "type": "git",
@@ -26,10 +26,10 @@
     "compare-versions": "^3.6.0",
     "cors": "^2.8.5",
     "cross-env": "^6.0.3",
-    "dbgate-datalib": "^5.4.0",
+    "dbgate-datalib": "^5.4.2",
     "dbgate-query-splitter": "^4.10.3",
-    "dbgate-sqltree": "^5.4.0",
-    "dbgate-tools": "^5.4.0",
+    "dbgate-sqltree": "^5.4.2",
+    "dbgate-tools": "^5.4.2",
     "debug": "^4.3.4",
     "diff": "^5.0.0",
     "diff2html": "^3.4.13",
@@ -74,7 +74,7 @@
   "devDependencies": {
     "@types/fs-extra": "^9.0.11",
     "@types/lodash": "^4.14.149",
-    "dbgate-types": "^5.4.0",
+    "dbgate-types": "^5.4.2",
     "env-cmd": "^10.1.0",
     "node-loader": "^1.0.2",
     "nodemon": "^2.0.2",

package/src/controllers/config.js

@@ -7,6 +7,7 @@ const { hasPermission } = require('../utility/hasPermission');
 const socket = require('../utility/socket');
 const _ = require('lodash');
 const AsyncLock = require('async-lock');
+const jwt = require('jsonwebtoken');
 
 const currentVersion = require('../currentVersion');
 const platformInfo = require('../utility/platformInfo');
@@ -14,6 +15,8 @@ const connections = require('../controllers/connections');
 const { getAuthProviderFromReq } = require('../auth/authProvider');
 const { checkLicense, checkLicenseKey } = require('../utility/checkLicense');
 const storage = require('./storage');
+const { getAuthProxyUrl } = require('../utility/authProxy');
+const { getPublicHardwareFingerprint } = require('../utility/hardwareFingerprint');
 
 const lock = new AsyncLock();
 
@@ -150,6 +153,22 @@ module.exports = {
 
   saveLicenseKey_meta: true,
   async saveLicenseKey({ licenseKey }) {
+    const decoded = jwt.decode(licenseKey);
+    if (!decoded) {
+      return {
+        status: 'error',
+        errorMessage: 'Invalid license key',
+      };
+    }
+
+    const { exp } = decoded;
+    if (exp * 1000 < Date.now()) {
+      return {
+        status: 'error',
+        errorMessage: 'License key is expired',
+      };
+    }
+
     try {
       if (process.env.STORAGE_DATABASE) {
         await storage.writeConfig({ group: 'license', config: { licenseKey } });
@@ -158,8 +177,33 @@ module.exports = {
         await fs.writeFile(path.join(datadir(), 'license.key'), licenseKey);
       }
       socket.emitChanged(`config-changed`);
+      return { status: 'ok' };
     } catch (err) {
-      return null;
+      return {
+        status: 'error',
+        errorMessage: err.message,
+      };
+    }
+  },
+
+  startTrial_meta: true,
+  async startTrial() {
+    try {
+      const fingerprint = await getPublicHardwareFingerprint();
+
+      const resp = await axios.default.post(`${getAuthProxyUrl()}/trial-license`, {
+        type: 'premium-trial',
+        days: 30,
+        fingerprint,
+      });
+      const { token } = resp.data;
+
+      return await this.saveLicenseKey({ licenseKey: token });
+    } catch (err) {
+      return {
+        status: 'error',
+        errorMessage: err.message,
+      };
     }
   },
 

package/src/currentVersion.js

@@ -1,5 +1,5 @@
 
 module.exports = { 
-  version: '5.4.0',
-  buildTime: '2024-09-03T13:07:02.765Z'
+  version: '5.4.2',
+  buildTime: '2024-09-06T11:51:54.891Z'
 };

package/src/utility/authProxy.js

@@ -12,9 +12,14 @@ async function authProxyGetTokenFromCode(options) {
 
 function startTokenChecking(sid, callback) {}
 
+function getAuthProxyUrl() {
+  return 'https://auth.dbgate.eu';
+}
+
 module.exports = {
   isAuthProxySupported,
   authProxyGetRedirectUrl,
   authProxyGetTokenFromCode,
   startTokenChecking,
+  getAuthProxyUrl,
 };

package/src/utility/hardwareFingerprint.js

@@ -0,0 +1,88 @@
+const axios = require('axios');
+const os = require('os');
+const crypto = require('crypto');
+const platformInfo = require('./platformInfo');
+
+async function getPublicIpInfo() {
+  try {
+    const resp = await axios.default.get('https://ipinfo.io/json');
+    if (!resp.data?.ip) {
+      return { ip: 'unknown-ip' };
+    }
+    return resp.data;
+  } catch (err) {
+    return { ip: 'unknown-ip' };
+  }
+}
+
+function getMacAddress() {
+  try {
+    const interfaces = os.networkInterfaces();
+    for (let iface of Object.values(interfaces)) {
+      for (let config of iface) {
+        if (config.mac && config.mac !== '00:00:00:00:00:00') {
+          return config.mac;
+        }
+      }
+    }
+    return '00:00:00:00:00:00';
+  } catch (err) {
+    return '00:00:00:00:00:00';
+  }
+}
+
+async function getHardwareFingerprint() {
+  const publicIpInfo = await getPublicIpInfo();
+  const macAddress = getMacAddress();
+  const platform = os.platform();
+  const release = os.release();
+  const hostname = os.hostname();
+  const totalMemory = os.totalmem();
+
+  return {
+    publicIp: publicIpInfo.ip,
+    country: publicIpInfo.country,
+    region: publicIpInfo.region,
+    city: publicIpInfo.city,
+    macAddress,
+    platform,
+    release,
+    hostname,
+    totalMemory,
+  };
+}
+
+async function getHardwareFingerprintHash(data = undefined) {
+  if (!data) {
+    data = await getHardwareFingerprint();
+  }
+  const fingerprintData = JSON.stringify(data);
+  const hash = crypto.createHash('sha256').update(fingerprintData).digest('hex');
+  return hash;
+}
+
+async function getPublicHardwareFingerprint() {
+  const fingerprint = await getHardwareFingerprint();
+  const hash = await getHardwareFingerprintHash(fingerprint);
+  return {
+    hash,
+    payload: {
+      platform: fingerprint.platform,
+      city: fingerprint.city,
+      country: fingerprint.country,
+      region: fingerprint.region,
+      isDocker: platformInfo.isDocker,
+      isElectron: platformInfo.isElectron,
+    },
+  };
+}
+
+// getHardwareFingerprint().then(console.log);
+// getHardwareFingerprintHash().then(console.log);
+// getPublicHardwareFingerprint().then(console.log);
+
+module.exports = {
+  getHardwareFingerprint,
+  getHardwareFingerprintHash,
+  getPublicHardwareFingerprint,
+};