14 |
15 |
16 | )
17 | }
18 |
19 | export default Checkbox
--------------------------------------------------------------------------------
/src/globalSlice.ts:
--------------------------------------------------------------------------------
1 | import { createSlice } from '@reduxjs/toolkit';
2 | import i18n from './i18n';
3 |
4 | const initialState = {
5 | language: localStorage.getItem('language') || 'en',
6 | };
7 |
8 | const globalSlice = createSlice({
9 | name: 'global',
10 | initialState,
11 | reducers: {
12 | setLanguage: (state, action) => {
13 | const selectedLanguage = action.payload;
14 | state.language = selectedLanguage;
15 | localStorage.setItem('language', selectedLanguage);
16 | i18n.changeLanguage(selectedLanguage);
17 | }
18 | },
19 | });
20 |
21 | export const { setLanguage } = globalSlice.actions;
22 | export default globalSlice.reducer;
23 |
--------------------------------------------------------------------------------
/src/Utils/getAppVersion.tsx:
--------------------------------------------------------------------------------
1 | import { useState, useEffect } from 'react'
2 |
3 | export const useAppVersion = () => {
4 | const [appVersion, setAppVersion] = useState
11 | 
12 |
18 | );
19 | }
--------------------------------------------------------------------------------
/src/Routes/components/ThemeCustomBox.tsx:
--------------------------------------------------------------------------------
1 | import { useTheme } from "@/Providers/ThemeProvider";
2 |
3 | const ThemeCustomBox = ({ mode }: { mode: "dark" | "light" }) => {
4 | const { themeType, setThemeType } = useTheme();
5 |
6 | return (
7 |
12 |
13 |
17 | AroCrypt useOpenLink(`https://github.com/AroCrypt/app/releases`)}>v{appVersion}
14 |{t("about_page_info")}
15 |{t('about_dev_info')} useOpenLink("https://github.com/OfficialAroCodes")}>AroCodes.
16 | setThemeType(mode)}
10 | >
11 |
12 |
21 | )
22 | }
23 |
24 | export default ThemeCustomBox
25 |
--------------------------------------------------------------------------------
/src/Utils/AlgorithmUtil.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 |
3 | const Available_Algorithms = [
4 | 'AES-256-GCM',
5 | 'AES-192-GCM',
6 | 'AES-128-GCM',
7 | 'AES-256-CBC',
8 | 'AES-192-CBC',
9 | 'AES-128-CBC',
10 | 'AES-256-CTR',
11 | 'AES-192-CTR',
12 | 'AES-128-CTR',
13 | ];
14 |
15 | const DEFAULT_ALGO = 'AES-256-GCM';
16 |
17 | const getAlgorithm = (key: string) => {
18 | const raw = localStorage.getItem(key);
19 | if (raw && Available_Algorithms.includes(raw)) return raw;
20 | localStorage.setItem(key, DEFAULT_ALGO);
21 | return DEFAULT_ALGO;
22 | };
23 |
24 | export const CheckAlgorithm = () => {
25 | getAlgorithm('encryptionMethod');
26 | getAlgorithm('decryptionMethod');
27 | };
28 |
29 | const Algorithm: React.FC = () => {
30 | CheckAlgorithm();
31 | return null;
32 | };
33 |
34 | export default Algorithm;
35 |
--------------------------------------------------------------------------------
/electron/main/utils/sanitizeFilePath.ts:
--------------------------------------------------------------------------------
1 | import path from "path";
2 | import fs from 'fs';
3 | import { safeWriteLog } from "./writeLog";
4 |
5 | export function sanitizeFilePath(inputPath: string, allowFileCreation: boolean = false): string {
6 | try {
7 | const normalizedPath = path.normalize(inputPath);
8 | const absolutePath = path.resolve(normalizedPath);
9 |
10 | if (!allowFileCreation && !fs.existsSync(absolutePath)) {
11 | throw new Error(`File does not exist: ${absolutePath}`);
12 | }
13 |
14 | if (allowFileCreation) {
15 | const directory = path.dirname(absolutePath);
16 | fs.mkdirSync(directory, { recursive: true });
17 | }
18 |
19 | return absolutePath;
20 | } catch (error) {
21 | safeWriteLog(`Path sanitization error: ${error}`);
22 | throw new Error(`Invalid file path: ${inputPath}`);
23 | }
24 | }
--------------------------------------------------------------------------------
/src/Utils/getDeviceOS.tsx:
--------------------------------------------------------------------------------
1 | import { useState } from "react";
2 |
3 | export default function getDeviceOS() {
4 | const [osType, setOsType] = useState<'mac' | 'win' | 'linux' | null>(null);
5 | let platform = '';
6 |
7 | if (window?.electronAPI?.getPlatform) {
8 | window.electronAPI.getPlatform().then((result: string) => {
9 | platform = result;
10 | if (platform.startsWith('win')) setOsType('win');
11 | else if (platform.startsWith('darwin') || platform === 'mac') setOsType('mac');
12 | else if (platform.startsWith('linux')) setOsType('linux');
13 | else setOsType(null);
14 | }).catch(() => setOsType(null));
15 | } else if (navigator?.userAgent) {
16 | const ua = navigator.userAgent.toLowerCase();
17 | if (ua.indexOf('win') !== -1) setOsType('win');
18 | else if (ua.indexOf('mac') !== -1) setOsType('mac');
19 | else if (ua.indexOf('linux') !== -1) setOsType('linux');
20 | else setOsType(null);
21 | }
22 |
23 | return osType;
24 | }
--------------------------------------------------------------------------------
/src/store.ts:
--------------------------------------------------------------------------------
1 | import { configureStore } from '@reduxjs/toolkit';
2 | import globalReducer from './globalSlice';
3 | import encryptionReducer from './store/encryptionSlice';
4 | import decryptionSlice from './store/decryptionSlice';
5 | import encryptionMethodReducer from './store/encryptionMethodSlice';
6 | import { useDispatch, useSelector, TypedUseSelectorHook } from 'react-redux';
7 |
8 | export const store = configureStore({
9 | reducer: {
10 | global: globalReducer,
11 | encryption: encryptionReducer,
12 | decryption: decryptionSlice,
13 | encryptionMethod: encryptionMethodReducer,
14 | },
15 | middleware: (getDefaultMiddleware) =>
16 | getDefaultMiddleware({
17 | serializableCheck: false,
18 | }),
19 | });
20 |
21 | export type RootState = ReturnType
13 |
14 |
20 |
15 |
16 |
17 |
18 |
19 |
27 | {toasts.map(({ id, type, message, title }) => (
28 | {
34 | setToasts((prev) => prev.filter((t) => t.id !== id));
35 | }}
36 | />
37 | ))}
38 |
39 |
11 |
32 | )
33 | }
34 |
35 | export default SettingsNav
--------------------------------------------------------------------------------
/.vite.config.flat.txt:
--------------------------------------------------------------------------------
1 | import { rmSync } from 'node:fs'
2 | import path from 'node:path'
3 | import { defineConfig } from 'vite'
4 | import react from '@vitejs/plugin-react'
5 | import electron from 'vite-plugin-electron'
6 | import renderer from 'vite-plugin-electron-renderer'
7 | import pkg from './package.json'
8 |
9 | // https://vitejs.dev/config/
10 | export default defineConfig(({ command }) => {
11 | rmSync('dist-electron', { recursive: true, force: true })
12 |
13 | const isServe = command === 'serve'
14 | const isBuild = command === 'build'
15 | const sourcemap = isServe || !!process.env.VSCODE_DEBUG
16 |
17 | return {
18 | resolve: {
19 | alias: {
20 | '@': path.join(__dirname, 'src')
21 | },
22 | },
23 | plugins: [
24 | react(),
25 | electron([
26 | {
27 | // Main-Process entry file of the Electron App.
28 | entry: 'electron/main/index.ts',
29 | onstart(options) {
30 | if (process.env.VSCODE_DEBUG) {
31 | console.log(/* For `.vscode/.debug.script.mjs` */'[startup] Electron App')
32 | } else {
33 | options.startup()
34 | }
35 | },
36 | vite: {
37 | build: {
38 | sourcemap,
39 | minify: isBuild,
40 | outDir: 'dist-electron/main',
41 | rollupOptions: {
42 | external: Object.keys('dependencies' in pkg ? pkg.dependencies : {}),
43 | },
44 | },
45 | },
46 | },
47 | {
48 | entry: 'electron/preload/index.ts',
49 | onstart(options) {
50 | // Notify the Renderer-Process to reload the page when the Preload-Scripts build is complete,
51 | // instead of restarting the entire Electron App.
52 | options.reload()
53 | },
54 | vite: {
55 | build: {
56 | sourcemap: sourcemap ? 'inline' : undefined, // #332
57 | minify: isBuild,
58 | outDir: 'dist-electron/preload',
59 | rollupOptions: {
60 | external: Object.keys('dependencies' in pkg ? pkg.dependencies : {}),
61 | },
62 | },
63 | },
64 | }
65 | ]),
66 | // Use Node.js API in the Renderer-process
67 | renderer(),
68 | ],
69 | server: process.env.VSCODE_DEBUG && (() => {
70 | const url = new URL(pkg.debug.env.VITE_DEV_SERVER_URL)
71 | return {
72 | host: url.hostname,
73 | port: +url.port,
74 | }
75 | })(),
76 | clearScreen: false,
77 | }
78 | })
79 |
--------------------------------------------------------------------------------
/electron/main/utils/KeyService.ts:
--------------------------------------------------------------------------------
1 | import { safeWriteLog } from './writeLog';
2 | import { MlKem768 } from 'mlkem';
3 | import { saveKEMKeyToDB, getKeys } from './db/DBService';
4 |
5 | export function validateKemKey(key: string, type: "public" | "secret"): boolean {
6 | if (!key || typeof key !== "string") return false;
7 |
8 | try {
9 | const bytes = Buffer.from(key, "base64");
10 | if (type === "public") return bytes.length > 0;
11 | if (type === "secret") return bytes.length > 0;
12 | return false;
13 | } catch {
14 | return false;
15 | }
16 | }
17 |
18 | export async function saveKEMKey(public_key: string, secret_key: string, recipient_key: string): Promise
12 |
16 |
31 |
17 |
18 | {t('security')}
19 |
20 |
21 |
25 |
26 |
27 | {t('appearance')}
28 |
29 |
30 |
54 |
75 |
82 | );
83 | };
84 |
85 | export default SettingsDropDown;
86 |
--------------------------------------------------------------------------------
/src/Routes/tabs/Appearance.tsx:
--------------------------------------------------------------------------------
1 | import { useState } from "react";
2 | import { useAppDispatch } from "@/store";
3 | import { useTranslation } from "react-i18next";
4 | import BottomInfo from "@/Components/BottomInfo";
5 | import SettingsDropDown from "@/Components/SettingsDropDown";
6 | import { useSelector } from "react-redux";
7 | import { setLanguage } from "@/globalSlice";
8 | import ThemeCustomBox from "../components/ThemeCustomBox";
9 |
10 | const AppearanceSettings = () => {
11 | const { t } = useTranslation();
12 | const dispatch = useAppDispatch();
13 |
14 | /* info: States */
15 | const [isLangMenuOpen, setIsLangMenuOpen] = useState(false);
16 |
17 | const currentLanguage = useSelector((state: any) => state.global.language);
18 | const handleLanguageChange = (lang: any) => {
19 | dispatch(setLanguage(lang));
20 | };
21 |
22 | return (
23 | <>
24 |
79 | {children}
80 |
81 |
25 |
61 |
62 | );
63 | };
64 |
65 | export default AppearanceSettings;
66 |
--------------------------------------------------------------------------------
/electron/main/utils/validateFileDecryption.ts:
--------------------------------------------------------------------------------
1 | import fs from "fs";
2 | import crypto from "crypto";
3 | import { generateKey, getIVLength } from "./crypto";
4 | import { safeWriteLog } from "./writeLog";
5 | import { loadKemKeys } from "./KeyService";
6 |
7 | export async function validateFileDecryption(
8 | inputPath: string,
9 | method: string
10 | ): Promise
26 |
35 |
41 |
47 |
48 |
49 |
27 |
30 | {t("interface_language")}
28 |{t("interface_language_info")}
29 |
50 |
59 |
51 |
54 | {t("app_theme.title")}
52 |{t("app_theme.desc")}
53 |
55 |
58 |
24 |
47 | )
48 | }
49 |
50 | export default ModalAlertBox
--------------------------------------------------------------------------------
/electron/main/utils/encryptText.ts:
--------------------------------------------------------------------------------
1 | import { AesKeySlice, generateKey, getIVLength } from "./crypto";
2 | import crypto from "crypto";
3 | import { MlKem768 } from "mlkem";
4 | import { loadKemKeys } from "./KeyService";
5 | import { safeWriteLog } from "./writeLog";
6 |
7 | const kem = new MlKem768();
8 |
9 | interface EncryptedPayload {
10 | content: string;
11 | iv: string;
12 | salt: string;
13 | kemCiphertext: string | null;
14 | hmac?: string;
15 | authTag?: string;
16 | }
17 |
18 | export async function encrypt(
19 | text: string,
20 | method: string,
21 | isShareable: boolean
22 | ): Promise
25 |
46 |
26 |
44 | 27 | { 28 | type === 0 ? ( 29 | 30 | ) : ( 31 | 32 | ) 33 | } 34 | {header} 35 |
36 | { 37 | changeable && ( 38 |
39 |
40 |
41 | )
42 | }
43 | {text_info}
45 |
11 |
34 |
35 | );
36 | };
37 |
38 | export default BottomInfo;
39 |
--------------------------------------------------------------------------------
/electron/main/utils/decryptText.ts:
--------------------------------------------------------------------------------
1 | import { generateKey } from "./crypto";
2 | import crypto from "crypto";
3 | import { loadKemKeys } from "./KeyService";
4 | import { MlKem768 } from "mlkem";
5 |
6 | const kem = new MlKem768();
7 |
8 | interface EncryptedPayload {
9 | content: string;
10 | iv: string;
11 | salt: string;
12 | kemCiphertext: string | null;
13 | hmac?: string;
14 | authTag?: string;
15 | }
16 |
17 | export async function decrypt(
18 | packedData: string,
19 | method: string
20 | ): Promise
25 | {
26 | msgType === 'warn' ? (
27 |
28 | ) : msgType === 'error' ?
29 | (
30 |
31 | ) : (
32 |
33 | )
34 | }
35 | {message}
36 |
37 | );
38 | };
39 |
40 | export default InlineMessageBox
--------------------------------------------------------------------------------
/src/Components/ToastNotification.tsx:
--------------------------------------------------------------------------------
1 | import { useEffect, useState } from "react";
2 |
3 | interface ToastInterface {
4 | type: number;
5 | message: string;
6 | title: string;
7 | onDone?: () => void;
8 | }
9 |
10 | const ToastNotification = ({ type, message, title, onDone }: ToastInterface) => {
11 | const [visible, setVisible] = useState(false);
12 |
13 | useEffect(() => {
14 | const showTimer = setTimeout(() => {
15 | setVisible(true);
16 | }, 10);
17 |
18 | const hideTimer = setTimeout(() => {
19 | setVisible(false);
20 | }, 4000);
21 |
22 | const cleanupTimer = setTimeout(() => {
23 | onDone?.();
24 | }, 4300);
25 |
26 | return () => {
27 | clearTimeout(showTimer);
28 | clearTimeout(hideTimer);
29 | clearTimeout(cleanupTimer);
30 | };
31 | }, []);
32 |
33 | return (
34 |
35 |
36 | {
37 | type === 1 ? (
38 |
39 | ) : type === 2 ? (
40 |
41 | ) : (
42 |
43 | )
44 | }
45 |
46 |
51 | );
52 | };
53 |
54 | export default ToastNotification;
55 |
--------------------------------------------------------------------------------
/src/Components/Titlebar.tsx:
--------------------------------------------------------------------------------
1 | import useAppVersion from '@/Utils/getAppVersion';
2 | import React, { useState, useEffect, useRef } from 'react'
3 | import MainDropDown from './MainDropDown';
4 | import { useClickOutside } from 'react-haiku';
5 |
6 | interface TitlebarProps {
7 | isAbout: boolean;
8 | }
9 |
10 | const Titlebar: React.FC
47 |
50 | {title}
48 |{message}
49 |
55 |
95 |
96 | )
97 | }
98 |
99 | export default Titlebar;
--------------------------------------------------------------------------------
/src/main.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import ReactDOM from 'react-dom/client';
3 | import { HashRouter, Routes, Route } from 'react-router-dom';
4 | import { Provider } from 'react-redux';
5 | import store from '@/store';
6 | import "@/main.css";
7 | import '@/i18n';
8 |
9 | /* info: Components */
10 | import Titlebar from "@/Components/Titlebar";
11 | import Navbar from '@/Components/Navbar';
12 | import UpdateModal from '@/Components/UpdateModal';
13 | import AboutWindow from '@/Components/AboutWindow';
14 |
15 | /* info: Utils */
16 | import Algorithm from './Utils/AlgorithmUtil';
17 |
18 | /* info: Providers */
19 | import { ThemeProvider, initializeTheme } from '@Providers/ThemeProvider';
20 | import RippleProvider from '@/Providers/RippleProvider';
21 | import StartupProvider from './Providers/StartupProvider';
22 | import { DecryptProvider } from '@/Context/DecryptContext';
23 | import { EncryptProvider } from '@/Context/EncryptContext';
24 | import { ToastProvider } from '@/Context/ToastContext';
25 | import { KeysMainProvider } from '@/Context/KeysContext';
26 | import { ExtractProvider } from '@/Context/ExtractContext';
27 | import { EmbedProvider } from '@/Context/EmbedContext';
28 |
29 | /* info: Routes */
30 | import FileEncryption from '@/Routes/FileEncryption';
31 | import TextEncryption from "@/Routes/TextEncryption";
32 | import TextDecryption from "@/Routes/TextDecryption";
33 | import FileDecryption from '@/Routes/FileDecryption';
34 | import Settings from '@/Routes/Settings';
35 | import AppearanceSettings from '@/Routes/tabs/Appearance';
36 | import SettingsNav from '@/Routes/components/SettingsNav';
37 | import DataHider from '@/Routes/DataHider';
38 | import DataExtractor from '@/Routes/DataExtracter';
39 |
40 |
41 | initializeTheme();
42 |
43 | const isAboutWindow = window.location.hash === '#about';
44 |
45 | ReactDOM.createRoot(document.getElementById('root') as HTMLElement).render(
46 |
56 |
57 |
59 |
57 | AroCrypt v{appVersion}
58 |
60 | {
61 | !isAbout && (
62 | <>
63 |
94 |
64 |
73 |
75 |
78 |
87 |
88 | )
89 | }
90 |
93 |
2 | 
3 | 
4 | 
5 | 
6 |
7 |
3 |
4 |
5 |
6 |
2 |
3 |
4 |
5 |
6 |
7 |
3 |
4 |
5 |
6 |
60 |
120 | )
121 | }
122 |
123 | export default UpdateModal;
--------------------------------------------------------------------------------
/src/Components/ViewUnpackedKeys.tsx:
--------------------------------------------------------------------------------
1 | import { useState, useEffect, useCallback, useRef } from "react";
2 | import { useTranslation } from "react-i18next";
3 | import CopyText from "@/Utils/copyText";
4 | import InlineMessageBox from "./InlineMessageBox";
5 | import { useClickOutside } from "react-haiku";
6 |
7 | interface DecodedKeys {
8 | content?: string;
9 | iv?: string;
10 | salt?: string;
11 | hmac?: string;
12 | authTag? : string;
13 | kemCiphertext?: string;
14 | }
15 |
16 | interface ViewUnpackedKeysProps {
17 | isShown: boolean;
18 | packedKeys: string;
19 | onClose: Function;
20 | }
21 |
22 | const ViewUnpackedKeys: React.FC
61 |
119 |
62 |
118 |
63 |
64 |
65 |
66 |
69 | {
70 | osType === "mac" ? (
71 | <>
72 | {
73 | osType === "mac" && (
74 | {t('update_required')}
67 |{t('update_info')}
68 |
91 |
101 |
102 | ) : (
103 |
114 | )
115 | )
116 | }
117 |
92 |
95 | {t('downloading')}
93 |{downloadProgress !== null ? `${downloadProgress.toFixed(1)}%` : "0%"} / 100%
94 |
96 |
99 |
100 |
98 |
99 |
106 | {showCopyButton && value && (
107 |
123 | )}
124 |
125 | ), [copySuccess, handleCopy, isLoading]);
126 |
127 | const ModalRef = useRef(null);
128 |
129 | const handleClose = () => {
130 | onClose(false);
131 | }
132 |
133 | useClickOutside(ModalRef, handleClose)
134 |
135 | return (
136 |
137 |
174 | );
175 | };
176 |
177 | export default ViewUnpackedKeys;
--------------------------------------------------------------------------------
/electron/main/utils/extractHiddenData.ts:
--------------------------------------------------------------------------------
1 | import fs from 'fs';
2 | import path from 'path';
3 | import crypto from 'crypto';
4 | import { PNG } from 'pngjs';
5 | import { AesKeySlice, generateKey, getIVLength } from '../utils/crypto';
6 | import { app } from 'electron';
7 | import { safeWriteLog } from './writeLog';
8 | import { loadKemKeys } from './KeyService';
9 | import { MlKem768 } from 'mlkem';
10 |
11 | const kem = new MlKem768();
12 |
13 | export function unpackFiles(buffer: Buffer, outputPath: string): string[] {
14 | safeWriteLog(`[unpackFiles] Buffer size: ${buffer.length}`);
15 | const extractedFiles: string[] = [];
16 |
17 | try {
18 | let offset = 0;
19 | const totalFiles = buffer.readUInt16BE(offset);
20 | offset += 2;
21 |
22 | safeWriteLog(`[unpackFiles] Total files embedded: ${totalFiles}`);
23 |
24 | for (let i = 0; i < totalFiles; i++) {
25 | safeWriteLog(`[unpackFiles] Extracting file ${i + 1}/${totalFiles}`);
26 |
27 | const filenameLength = buffer.readUInt16BE(offset);
28 | offset += 2;
29 |
30 | const filename = buffer.slice(offset, offset + filenameLength).toString('utf-8');
31 | offset += filenameLength;
32 |
33 | const fileSize = buffer.readUInt32BE(offset);
34 | offset += 4;
35 |
36 | const fileData = buffer.slice(offset, offset + fileSize);
37 | offset += fileSize;
38 |
39 | const finalPath = path.join(outputPath, filename);
40 | const dir = path.dirname(finalPath);
41 | fs.mkdirSync(dir, { recursive: true });
42 | fs.writeFileSync(finalPath, fileData);
43 | safeWriteLog(`[unpackFiles] File extracted to: ${finalPath}`);
44 |
45 | extractedFiles.push(finalPath);
46 | }
47 |
48 | return extractedFiles;
49 | } catch (err) {
50 | console.error(`[unpackFiles] Error:`, err);
51 | throw err;
52 | }
53 | }
54 |
55 | export default async function extractHiddenData(
56 | imagePath: string,
57 | method: string
58 | ): Promise<{ response: string; files: string[] }> {
59 | safeWriteLog(`[EXTRACT] Image path: ${imagePath}`);
60 | safeWriteLog(`[EXTRACT] Method: ${method}`);
61 |
62 | const { PRIVATE_KEY } = await loadKemKeys();
63 |
64 | // Create temporary directory
65 | const tempDir = path.join(app.getPath('temp'), 'arocrypt-extraction');
66 | if (!fs.existsSync(tempDir)) {
67 | fs.mkdirSync(tempDir, { recursive: true });
68 | }
69 |
70 | return new Promise((resolve, reject) => {
71 | const imageStream = fs.createReadStream(imagePath);
72 | const png = new PNG();
73 |
74 | png.on('parsed', async function () {
75 | try {
76 | safeWriteLog(`[EXTRACT] PNG parsed`);
77 |
78 | const bitData: number[] = [];
79 | for (let i = 0; i < this.data.length; i++) {
80 | bitData.push(this.data[i] & 1);
81 | }
82 |
83 | const byteData = [];
84 | for (let i = 0; i < bitData.length; i += 8) {
85 | const byte = bitData
86 | .slice(i, i + 8)
87 | .reduce((acc, bit, j) => acc | (bit << (7 - j)), 0);
88 | byteData.push(byte);
89 | }
90 |
91 | const fullBuffer = Buffer.from(byteData);
92 | const payloadBase64 = fullBuffer.toString('utf8').trim();
93 | const payload: {
94 | content: string;
95 | iv: string;
96 | salt: string;
97 | kemCiphertext?: string | null;
98 | authTag?: string;
99 | hmac?: string;
100 | } = JSON.parse(Buffer.from(payloadBase64, 'base64').toString('utf8'));
101 |
102 | const ivBuffer = Buffer.from(payload.iv, 'hex');
103 | const saltBuffer = Buffer.from(payload.salt, 'hex');
104 | const encryptedData = Buffer.from(payload.content, 'hex');
105 | const kemCiphertextBuf = payload.kemCiphertext
106 | ? Uint8Array.from(Buffer.from(payload.kemCiphertext, 'base64'))
107 | : null;
108 | const authTag = payload.authTag ? Buffer.from(payload.authTag, 'hex') : null;
109 |
110 | // Derive AES key
111 | let originalKeyForKdf: string;
112 | if (kemCiphertextBuf) {
113 | try {
114 | const sharedSecret = await kem.decap(
115 | kemCiphertextBuf,
116 | Uint8Array.from(Buffer.from(PRIVATE_KEY!, 'base64'))
117 | );
118 | originalKeyForKdf = Buffer.from(sharedSecret).toString();
119 | } catch (e) {
120 | safeWriteLog(`[EXTRACT] KEM decapsulation failed: ${(e as Error).message}`);
121 | throw e;
122 | }
123 | } else {
124 | originalKeyForKdf = PRIVATE_KEY!;
125 | }
126 |
127 | const aesKey = generateKey({
128 | originalKey: originalKeyForKdf,
129 | method,
130 | salt: saltBuffer,
131 | });
132 |
133 | // Verify HMAC if non-AEAD
134 | if (!/gcm|chacha/i.test(method) && payload.hmac) {
135 | const hmacKey = crypto.createHash('sha256').update(AesKeySlice(method, aesKey)).digest();
136 | const hmac = crypto.createHmac('sha256', hmacKey);
137 | hmac.update(ivBuffer);
138 | hmac.update(saltBuffer);
139 | hmac.update(encryptedData);
140 | if (payload.kemCiphertext) hmac.update(Buffer.from(payload.kemCiphertext, 'base64'));
141 | const digest = hmac.digest('hex');
142 | if (digest !== payload.hmac) throw new Error('HMAC validation failed');
143 | }
144 |
145 | const decipher = crypto.createDecipheriv(method, AesKeySlice(method, aesKey), ivBuffer);
146 | if (authTag) (decipher as crypto.DecipherGCM).setAuthTag(authTag);
147 |
148 | const decryptedBuffer = Buffer.concat([decipher.update(encryptedData), decipher.final()]);
149 | const files = unpackFiles(decryptedBuffer, tempDir);
150 |
151 | safeWriteLog(`[EXTRACT] Extraction complete. Files: ${files}`);
152 | resolve({ response: 'OK', files });
153 | } catch (err) {
154 | console.error(`[EXTRACT] Error during extraction/decryption:`, err);
155 | reject({ response: 'BAD', error: err });
156 | }
157 | });
158 |
159 | png.on('error', err => {
160 | console.error(`[EXTRACT] PNG error:`, err);
161 | reject({ response: 'BAD', error: err });
162 | });
163 |
164 | imageStream.pipe(png);
165 | });
166 | }
167 |
--------------------------------------------------------------------------------
/src/Routes/TextDecryption.tsx:
--------------------------------------------------------------------------------
1 | import { RootState } from "@/store";
2 | import React, { useEffect, useRef, useState } from "react";
3 | import { Trans, useTranslation } from "react-i18next";
4 | import { useDispatch, useSelector } from "react-redux";
5 | import { setPackedKeys, setDecryptedText } from "@/store/decryptionSlice";
6 | import BottomInfo from "@/Components/BottomInfo";
7 | import { useToast } from "@/Context/ToastContext";
8 | import { useClickOutside, useKeyPress } from "react-haiku";
9 | import SwitchToggler from "@/Components/ui/SwitchToggler";
10 | import HistoryModal from "@/Components/HistoryModal";
11 | import { CheckAlgorithm } from "@/Utils/AlgorithmUtil";
12 | import getDeviceOS from "@/Utils/getDeviceOS";
13 |
14 | const Decryption: React.FC = () => {
15 | const toast = useToast();
16 | const { t } = useTranslation();
17 | const dispatch = useDispatch();
18 | const { packedKeys, decrypted_text } = useSelector(
19 | (state: RootState) => state.decryption
20 | );
21 | const [isButtonDisabled, setIsButtonDisabled] = useState(false);
22 | const osType = getDeviceOS();
23 |
24 | const de_method = localStorage.getItem("decryptionMethod");
25 |
26 | const handleDecrypt = async () => {
27 | try {
28 | CheckAlgorithm();
29 |
30 | const decryptParams = {
31 | packedKeys: packedKeys,
32 | method: de_method,
33 | isSaveHistory: isSaveHistory,
34 | };
35 |
36 | const decryptedResult = await window.electronAPI.decrypt(
37 | decryptParams as any
38 | );
39 |
40 | if (decryptedResult === "invalid") {
41 | dispatch(setDecryptedText(""));
42 | setIsButtonDisabled(true);
43 | toast(0, t('toast.text_decryption_msg'), t('toast.text_decryption_title'))
44 | return;
45 | }
46 |
47 | dispatch(setDecryptedText(decryptedResult));
48 | setIsButtonDisabled(true);
49 | } catch (error: any) {
50 | toast(0, `Unexpected Error has Occurred: ${error}`, "Unexpected Error")
51 | }
52 | };
53 |
54 | const handleTypeSecurityKey = (e: any) => {
55 | dispatch(setPackedKeys(e.target.value));
56 | dispatch(setDecryptedText(""));
57 | setIsButtonDisabled(false);
58 | setIsButtonDisabled(false);
59 | };
60 |
61 | const combination = () => {
62 | if (packedKeys && !isButtonDisabled) {
63 | handleDecrypt();
64 | }
65 | }
66 |
67 | useKeyPress(['Control', 'D'], combination);
68 | useKeyPress(['Meta', 'D'], combination);
69 |
70 | /* info: Config Functions */
71 |
72 | // Dropdown and Modal
73 | const [isHistoryModal, setHistoryModal] = useState(false);
74 | const [isConfigOpen, setConfigOpen] = useState(false);
75 | const ConfigRef = useRef(null)
76 |
77 | useClickOutside(ConfigRef, () => setConfigOpen(false));
78 |
79 | // Configs
80 | const [isSaveHistory, setSaveHistory] = useState(false);
81 |
82 | useEffect(() => {
83 | const contentHistory = localStorage.getItem('logs.dtext') === 'true';
84 |
85 | setSaveHistory(contentHistory);
86 | }, [isSaveHistory])
87 |
88 | const HandleConfigOperation = (config: string) => {
89 | switch (config) {
90 | case "logs":
91 | localStorage.setItem('logs.dtext', `${isSaveHistory ? false : true}`)
92 | setSaveHistory(!isSaveHistory)
93 | break;
94 | }
95 | }
96 |
97 | /* info: Config Functions {END} */
98 |
99 | return (
100 | <>
101 |
138 |
173 | {t("unpacked_package")}
139 | 153 | 154 |
102 |
168 | {t("text_decryption")}
103 |
104 |
110 |
130 |
111 |
117 |
129 |
118 |
128 | {t("config.dtext")}
119 | 120 | HandleConfigOperation("logs")}>
121 | HandleConfigOperation("logs")} />
126 |
127 |
122 |
125 | {t("config.history.title")}
123 |{t("config.history.desc")}
124 |
131 |
132 |
140 |
141 |
142 |
143 |
150 |
151 |
166 |
23 |
105 | );
106 | }
107 |
--------------------------------------------------------------------------------
24 |
104 |
25 |
36 |
47 |
58 |
59 |
60 |
61 |
72 |
81 |
82 |
83 |
84 |
93 |
102 |
103 |