Move to NextJS + other changes

src/app/util/BazookaManager.ts

@@ -0,0 +1,135 @@
+import { app } from '@tauri-apps/api'
+import { NormalConfig } from '../types/NormalConfig'
+import {
+  BaseDirectory,
+  create,
+  exists,
+  mkdir,
+  readTextFile,
+  writeFile
+} from '@tauri-apps/plugin-fs'
+import { decrypt, encrypt } from './Encryption'
+import { VersionsConfig } from '../types/VersionsConfig'
+import { getKey } from './KeysHelper'
+
+export async function readNormalConfig (): Promise<NormalConfig> {
+  const version = await app.getVersion()
+  try {
+    const options = {
+      baseDir: BaseDirectory.AppLocalData
+    }
+    const doesFolderExist = await exists('', options)
+    const doesConfigExist = await exists('config.dat', options)
+    if (!doesFolderExist || !doesConfigExist) {
+      if (!doesFolderExist) {
+        await mkdir('', options)
+      }
+      const file = await create('config.dat', options)
+      await file.write(
+        new TextEncoder().encode(
+          await encrypt(
+            JSON.stringify(new NormalConfig(version)),
+            await getKey(2)
+          )
+        )
+      )
+      await file.close()
+      return new NormalConfig(version)
+    }
+    const config = await readTextFile('config.dat', options)
+    return NormalConfig.import(
+      JSON.parse(await decrypt(config, await getKey(2)))
+    )
+  } catch {
+    return new NormalConfig(version)
+  }
+}
+
+export async function writeNormalConfig (data: NormalConfig) {
+  const options = {
+    baseDir: BaseDirectory.AppLocalData
+  }
+  const doesFolderExist = await exists('', options)
+  const doesConfigExist = await exists('config.dat', options)
+  if (!doesFolderExist || !doesConfigExist) {
+    if (!doesFolderExist) {
+      await mkdir('', options)
+    }
+    const file = await create('config.dat', options)
+    await file.write(
+      new TextEncoder().encode(
+        await encrypt(JSON.stringify(data), await getKey(2))
+      )
+    )
+    await file.close()
+  } else {
+    await writeFile(
+      'config.dat',
+      new TextEncoder().encode(
+        await encrypt(JSON.stringify(data), await getKey(2))
+      ),
+      options
+    )
+  }
+}
+
+export async function readVersionsConfig (): Promise<VersionsConfig> {
+  const version = await app.getVersion()
+  try {
+    const options = {
+      baseDir: BaseDirectory.AppLocalData
+    }
+    const doesFolderExist = await exists('', options)
+    const doesConfigExist = await exists('versions.dat', options)
+    if (!doesFolderExist || !doesConfigExist) {
+      if (!doesFolderExist) {
+        await mkdir('', options)
+      }
+      const file = await create('versions.dat', options)
+      await file.write(
+        new TextEncoder().encode(
+          await encrypt(
+            JSON.stringify(new VersionsConfig(version)),
+            await getKey(3)
+          )
+        )
+      )
+      await file.close()
+      return new VersionsConfig(version)
+    }
+    const config = await readTextFile('versions.dat', options)
+    return VersionsConfig.import(
+      JSON.parse(await decrypt(config, await getKey(3)))
+    )
+  } catch {
+    return new VersionsConfig(version)
+  }
+}
+
+export async function writeVersionsConfig (data: VersionsConfig) {
+  const options = {
+    baseDir: BaseDirectory.AppLocalData
+  }
+  const doesFolderExist = await exists('', options)
+  const doesConfigExist = await exists('versions.dat', options)
+  if (!doesFolderExist || !doesConfigExist) {
+    if (!doesFolderExist) {
+      await mkdir('', options)
+    }
+    const file = await create('versions.dat', options)
+    await file.write(
+      new TextEncoder().encode(
+        await encrypt(JSON.stringify(data), await getKey(3))
+      )
+    )
+    await file.close()
+  } else {
+    await writeFile(
+      'versions.dat',
+      new TextEncoder().encode(
+        await encrypt(JSON.stringify(data), await getKey(3))
+      ),
+      options
+    )
+  }
+}

src/app/util/Encryption.ts

@@ -0,0 +1,45 @@
+import CryptoJS from 'crypto-js'
+import { getKey } from './KeysHelper'
+
+export async function encrypt (
+  plainText: string,
+  key?: string
+): Promise<string> {
+  if (!key) key = await getKey(1)
+  const iv = CryptoJS.lib.WordArray.random(16)
+  const encrypted = CryptoJS.AES.encrypt(
+    plainText,
+    CryptoJS.enc.Utf8.parse(key),
+    {
+      iv,
+      mode: CryptoJS.mode.CBC,
+      padding: CryptoJS.pad.Pkcs7
+    }
+  )
+  const combined = iv.concat(encrypted.ciphertext)
+  return CryptoJS.enc.Base64.stringify(combined)
+}
+
+export async function decrypt (dataB64: string, key?: string): Promise<string> {
+  if (!key) key = await getKey(0)
+  const data = CryptoJS.enc.Base64.parse(dataB64)
+  const iv = CryptoJS.lib.WordArray.create(data.words.slice(0, 4), 16)
+  const ciphertext = CryptoJS.lib.WordArray.create(
+    data.words.slice(4),
+    data.sigBytes - 16
+  )
+  const cipherParams = CryptoJS.lib.CipherParams.create({ ciphertext })
+
+  const decrypted = CryptoJS.AES.decrypt(
+    cipherParams,
+    CryptoJS.enc.Utf8.parse(key),
+    {
+      iv,
+      mode: CryptoJS.mode.CBC,
+      padding: CryptoJS.pad.Pkcs7
+    }
+  )
+  const result = decrypted.toString(CryptoJS.enc.Utf8)
+  if (!result) throw new Error(await encrypt('-997'))
+  return result
+}

src/app/util/KeysHelper.ts

@@ -0,0 +1,11 @@
+import { invoke } from '@tauri-apps/api/core'
+
+export async function getKey (key: number): Promise<string> {
+  try {
+    const message = await invoke('get_keys_config', { key })
+    return message as string
+  } catch (error) {
+    console.error('Failed to get key from Tauri backend', error)
+    return ''
+  }
+}