-
50 | {route.children?.map((childRoute: CustomRouteObject, index) => (
51 |
85 |
90 | {hasChildren && (
91 | {route.name}
86 |
87 | {route.description}
88 |
89 | -
104 | {route.children?.map((childRoute: CustomRouteObject, index) => (
105 |
9 |
15 | );
16 | }
17 |
--------------------------------------------------------------------------------
/src/assets/svg/delete.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/src/assets/svg/down.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/src/assets/svg/download.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/src/assets/svg/full_screen.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/src/assets/svg/lock.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/src/assets/svg/menu.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/src/assets/svg/plus.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/src/assets/svg/recover.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/src/assets/svg/right_arrow.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/src/assets/svg/ruler.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/src/assets/svg/unlock.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/src/components/Button/constant.ts:
--------------------------------------------------------------------------------
1 | export const TYPES = {
2 | white:
3 | "text-gray-900 bg-white border border-gray-300 hover:bg-gray-100 dark:bg-gray-800 dark:text-white dark:border-gray-600 dark:hover:bg-gray-700 dark:hover:border-gray-600",
4 | blue: "text-white bg-blue-700 hover:bg-blue-800 dark:bg-blue-600 dark:hover:bg-blue-700",
5 | };
6 |
--------------------------------------------------------------------------------
/src/components/Button/index.tsx:
--------------------------------------------------------------------------------
1 | import React from "react";
2 | import { TYPES } from "./constant";
3 |
4 | export default function Button(
5 | props: React.DetailedHTMLProps<
6 | React.ButtonHTMLAttributes
11 |
14 | -
27 | {options.map((item, index) => (
28 |
- 29 | 40 | 50 | 51 | ))} 52 |
223 |
294 | );
295 | };
296 |
297 | const ImageCropModal: React.FC
224 |
255 |
256 |
225 | 裁剪图片
226 |
234 |
227 | {aspect ? (
228 |
233 |
235 |
240 |
236 |
238 |
241 |
247 |
253 |
254 |
257 |
284 |
285 |
258 |
268 | 
281 |
282 |
283 |
286 |
293 |
95 |
105 | {isOpen && (
106 |
130 | );
131 | };
132 |
133 | export default Select;
134 |
--------------------------------------------------------------------------------
/src/components/ProgressBar/constant.ts:
--------------------------------------------------------------------------------
1 | export const COLOR_CLASS_MAP = {
2 | blue: "from-blue-400 to-blue-500",
3 | red: "from-red-400 to-red-500",
4 | };
5 |
--------------------------------------------------------------------------------
/src/components/ProgressBar/index.tsx:
--------------------------------------------------------------------------------
1 | import { decimalToPercentage } from "@/utils/number";
2 | import React, { useMemo } from "react";
3 | import { COLOR_CLASS_MAP } from "./constant";
4 |
5 | type Props = {
6 | current: number;
7 | total: number;
8 | type: "fraction" | "percentage";
9 | className?: string;
10 | color?: "blue" | "red";
11 | };
12 |
13 | const ProgressBar: React.FC
107 |
128 | )}
129 | -
112 | {options?.map((option, index) => (
113 |
- handleOptionClick(index)}
119 | >
120 |
121 |
122 | ))}
123 |
125 |
127 |
37 |
41 |
45 | );
46 | };
47 |
48 | export default ProgressBar;
49 |
--------------------------------------------------------------------------------
/src/components/Ruler/index.tsx:
--------------------------------------------------------------------------------
1 | import { shallowEqual } from "@/utils/object";
2 | import produce from "immer";
3 | import React, {
4 | useCallback,
5 | useEffect,
6 | useMemo,
7 | useRef,
8 | useState,
9 | memo,
10 | } from "react";
11 | import { ReactComponent as SVG_ruler } from "@/assets/svg/ruler.svg";
12 | interface typeProps {
13 | min: number;
14 | max: number;
15 | defaultValue: number;
16 | suffix: string;
17 | }
18 | //不同类型刻度尺的刻度值
19 | interface Props {
20 | defaultScale: typeProps;
21 | defaultRotate: typeProps;
22 | onChange?: (values: { scale: number; rotate: number }) => void;
23 | forceValue?: {
24 | scale?: number;
25 | rotate?: number;
26 | };
27 | }
28 |
29 | const Ruler = ({
30 | defaultScale,
31 | defaultRotate,
32 | onChange,
33 | forceValue,
34 | }: Props) => {
35 | /**
36 | * 根据刻度计算位置
37 | */
38 | const getPosition = (type: typeProps) => {
39 | return (type.defaultValue - type.min) / (type.max - type.min);
40 | };
41 | //鼠标按下位置
42 | const mouseDownPosition = useRef<{
43 | xPos: number;
44 | yPos: number;
45 | }>({
46 | xPos: 0,
47 | yPos: 0,
48 | });
49 | //刻度尺的ref
50 | const rulerRef = useRef
42 | {content}
43 |
44 |
217 |
250 |
251 | );
252 | };
253 |
254 | export default memo(Ruler, (prevProps, nextProps) => {
255 | return (
256 | shallowEqual(prevProps.defaultRotate, nextProps.defaultRotate) &&
257 | shallowEqual(prevProps.defaultScale, nextProps.defaultScale) &&
258 | prevProps.onChange === nextProps.onChange &&
259 | prevProps.forceValue === nextProps.forceValue
260 | );
261 | });
262 |
--------------------------------------------------------------------------------
/src/components/Table/index.tsx:
--------------------------------------------------------------------------------
1 | import React from "react";
2 | import { TableProps } from "./type";
3 |
4 | function Table({ columns, data }: TableProps) {
5 | return (
6 |
218 |
219 |
220 |
221 |
234 |
222 | {values[activeType]}
223 | {(activeType === "scale" ? defaultScale : defaultRotate).suffix}
224 |
225 |
229 |
233 |
230 |
232 |
235 | {typeObj.map((item, index) => (
236 |
247 | ))}
248 |
249 | | 15 | {column.title} 16 | | 17 | ))} 18 |
|---|
| 28 | {row[column.key] ?? "-"} 29 | | 30 | ))} 31 |
27 | 此浏览器可能不是基于Chromium内核, 可能存在功能缺失的情况
28 |
32 | x
33 |
34 |
35 | )}
36 |
37 | );
38 | };
39 |
--------------------------------------------------------------------------------
/src/components/Upload/index.tsx:
--------------------------------------------------------------------------------
1 | import { calculateMD5, file2FileType } from "@/utils/file";
2 | import React, { Fragment, useEffect, useState } from "react";
3 | import Dropzone from "react-dropzone";
4 | import pLimit from "p-limit";
5 | import { produce } from "immer";
6 | import { FileType } from "@/components/Upload/type";
7 | import ImageCrop from "../ImageCrop";
8 | import { ReactComponent as SVG_plus } from "@/assets/svg/plus.svg";
9 | import { ReactComponent as SVG_delete } from "@/assets/svg/delete.svg";
10 | import { Thumbnail } from "../Thumbnail";
11 |
12 | const Upload: React.FC<{
13 | list?: FileType[];
14 | disabled?: boolean;
15 | className?: string;
16 | onAdd?: (files: FileType[], insertIndex: number) => void;
17 | onRemove?: (md5: string) => void;
18 | onUploadStateChange?: (status: boolean) => void;
19 | }> = ({ list, disabled, className, onAdd, onRemove, onUploadStateChange }) => {
20 | const [files, setFiles] = useState
159 |
160 | {({ getRootProps, getInputProps }) => (
161 |
172 | {files.map((file) => (
173 |
188 |
162 |
170 | )}
171 |
166 |
167 |
169 |
177 | handleOpenModal(file)} />
178 |
179 |
185 |
186 | ))}
187 |
17 |
30 | );
31 | };
32 |
33 | export default function ControlPanel({
34 | onStart, //开始加密
35 | className, //类名
36 | pluginList, //插件列表
37 | disabled, //是否正在加密
38 | onClearUpload, //清除上传文件
39 | onClearOutput, //清除输出文件
40 | }: {
41 | onStart?: (option: ControlOptionType) => void;
42 | className?: string;
43 | pluginList: Plugin[];
44 | disabled?: boolean;
45 | onClearUpload?: () => void;
46 | onClearOutput?: () => void;
47 | }) {
48 | //插件索引
49 | const [pluginIndex, setPluginIndex] = useState
21 | {props.label}
22 |
23 | {props.children}
24 | {props.message && (
25 |
26 | {props.message}
27 |
28 | )}
29 | {option.name}
172 | {option.description}
173 |
174 |
175 | {capitalizeFirstLetter(option.language)}
176 |
177 | {option.version}
178 |
179 |
219 | {/* 算法列表 */}
220 | -
240 |
249 |
250 |
251 | {/* 文件格式 */}
252 | -
253 |
264 | {/* 图像质量 */}
265 | -
266 |
281 |
282 |
304 | );
305 | }
306 |
--------------------------------------------------------------------------------
/src/pages/encryption/ControlPanel/type.ts:
--------------------------------------------------------------------------------
1 | export type ImageFormatType =
2 | | "image/png"
3 | | "image/jpeg"
4 | | "image/bmp"
5 | | "image/webp"
6 | | "";
7 | export interface ControlOptionType {
8 | pluginName: string;
9 | optionName: "encrypt" | "decrypt";
10 | key: string;
11 | format: ImageFormatType;
12 | quality: number;
13 | }
14 |
--------------------------------------------------------------------------------
/src/pages/encryption/Output/constant.ts:
--------------------------------------------------------------------------------
1 | import { TableColumn } from "@/components/Table/type";
2 |
3 | export const columns: TableColumn[] = [
4 | {
5 | title: "原图",
6 | key: "origin",
7 | },
8 | {
9 | title: "生成图",
10 | key: "current",
11 | },
12 | {
13 | title: "原图大小",
14 | key: "originSize",
15 | },
16 | {
17 | title: "生成图大小",
18 | key: "currentSize",
19 | },
20 | {
21 | title: "压缩率",
22 | key: "compressionRatio",
23 | },
24 | {
25 | title: "操作",
26 | key: "operate",
27 | },
28 | ];
29 |
--------------------------------------------------------------------------------
/src/pages/encryption/Output/index.tsx:
--------------------------------------------------------------------------------
1 | import React, { Fragment, useState } from "react";
2 | import Table from "@/components/Table";
3 | import { FileType } from "@/components/Upload/type";
4 | import { columns } from "./constant";
5 | import CustomModal from "@/components/CustomModal";
6 | import { getCompressionRate } from "@/utils/file";
7 | import { ReactComponent as SVG_delete } from "@/assets/svg/delete.svg";
8 | import { Thumbnail } from "@/components/Thumbnail";
9 | import saveAs from "file-saver";
10 | import { formatSize } from "@/utils/number";
11 |
12 | export default function Output({
13 | pairList,
14 | className,
15 | disabled,
16 | onRemove,
17 | }: {
18 | pairList: [FileType, FileType][];
19 | className?: string;
20 | disabled?: boolean;
21 | onRemove?: (md5: string) => void;
22 | }) {
23 | const [isModalOpen, setIsModalOpen] = useState(false);
24 | const [editImage, setEditImage] = useState<{
25 | src: string;
26 | name: string;
27 | } | null>(null);
28 | /**
29 | * 打开图片裁剪模态框
30 | */
31 | const handleOpenModal = (src: string, name: string) => {
32 | setIsModalOpen(true);
33 | setEditImage({
34 | src,
35 | name,
36 | });
37 | };
38 | /**
39 | * 关闭图片裁剪模态框
40 | */
41 | const handleCloseModal = () => {
42 | setIsModalOpen(false);
43 | setEditImage(null);
44 | };
45 | /**
46 | * 删除图像
47 | */
48 | const handleRemove = (md5: string) => {
49 | if (disabled) {
50 | return;
51 | }
52 | onRemove?.(md5);
53 | };
54 | /**
55 | * 下载图像
56 | */
57 | const handleDown = ({ file }: FileType) => {
58 | if (disabled) {
59 | return;
60 | }
61 | saveAs(file, file.name);
62 | };
63 |
64 | /**
65 | * 生成表格数据
66 | */
67 | const generateData = () =>
68 | Array.from(pairList, ([originFile, encryptFile]) => {
69 | const id = originFile.md5;
70 | const origin = (
71 | - item.label}
259 | renderList={(list) => list.label}
260 | className="flex-1"
261 | listNumber={3}
262 | >
267 |
276 |
277 | {qualityLabel}
278 |
279 |
280 |
283 |
291 |
299 |
302 |
303 |
92 | handleDown(encryptFile)}
94 | className="cursor-pointer select-none text-blue-500 font-semibold text-sm underline underline-offset-2 mx-2"
95 | >
96 | 下载
97 |
98 | handleRemove(originFile.md5)}
100 | className="cursor-pointer select-none text-red-500 font-semibold text-sm underline underline-offset-2 mx-2"
101 | >
102 | 删除
103 |
104 |
105 | );
106 | return {
107 | id,
108 | origin,
109 | current,
110 | originSize,
111 | currentSize,
112 | compressionRatio: (
113 | 100 ? "text-red-500" : "text-green-500"
116 | }`}
117 | >
118 | {compressionRatio}%
119 |
120 | ),
121 | operate,
122 | };
123 | });
124 |
125 | return (
126 |
128 |
132 |
129 |
130 |
131 |
137 | {editImage && (
138 | e.preventDefault()}
143 | >
144 | 
153 |
154 | )}
155 |
156 |
157 |
163 |
219 |
283 | );
284 | }
285 |
--------------------------------------------------------------------------------
/src/pages/steganography/ControlPanel/constant.ts:
--------------------------------------------------------------------------------
1 | //可操作选项
2 | export const OPTION_CARDS = [
3 | {
4 | title: "写入信息",
5 | description: "使用当前算法往图像中写入信息",
6 | },
7 | {
8 | title: "提取信息",
9 | description: "使用当前算法从图像中提取信息",
10 | },
11 | ];
12 |
--------------------------------------------------------------------------------
/src/pages/steganography/ControlPanel/index.tsx:
--------------------------------------------------------------------------------
1 | import React, { Fragment, useMemo, useState } from "react";
2 | import { Plugin } from "@/service/plugin/type";
3 | import List from "@/components/List";
4 | import Button from "@/components/Button";
5 | import { OPTION_CARDS } from "./constant";
6 | import { capitalizeFirstLetter } from "@/utils/string";
7 | import { ControlOptionType } from "./type";
8 | import CardSelect from "@/components/CardSelect";
9 |
10 | const Item = (props: {
11 | label: string;
12 | children?: React.ReactNode;
13 | message?: string;
14 | }) => {
15 | return (
16 |
220 |
282 |
221 |
232 |
222 |
231 |
233 |
244 |
234 |
243 |
245 |
281 |
246 |
251 |
252 |
257 |
280 |
258 |
259 | {processMessage}
260 |
261 |
268 |
274 |
279 |
17 |
30 | );
31 | };
32 |
33 | export default function ControlPanel({
34 | onStart, //开始加密
35 | className, //类名
36 | pluginList, //插件列表
37 | disabled, //是否正在加密
38 | onClearUpload, //清除上传文件
39 | onClearOutput, //清除输出文件
40 | }: {
41 | onStart?: (option: ControlOptionType) => void;
42 | className?: string;
43 | pluginList: Plugin[];
44 | disabled?: boolean;
45 | onClearUpload?: () => void;
46 | onClearOutput?: () => void;
47 | }) {
48 | //插件索引
49 | const [pluginIndex, setPluginIndex] = useState
21 | {props.label}
22 |
23 | {props.children}
24 | {props.message && (
25 |
26 | {props.message}
27 |
28 | )}
29 | {option.name}
164 | {option.description}
165 |
166 |
167 | {capitalizeFirstLetter(option.language)}
168 |
169 | {option.version}
170 |
171 |
183 | {/* 算法列表 */}
184 | -
204 |
214 |
215 | {/* 信息重复次数 */}
216 | {pluginComponentRule.repeat && (
217 | -
218 |
227 |
228 | )}
229 | {/* 要写入的信息 */}
230 | {!!optionIndex || (
231 | -
232 |
241 |
242 | )}
243 |
265 | );
266 | }
267 |
--------------------------------------------------------------------------------
/src/pages/steganography/ControlPanel/type.ts:
--------------------------------------------------------------------------------
1 | export interface ControlOptionType {
2 | pluginName: string;
3 | optionName: "encrypt" | "decrypt";
4 | key: string;
5 | message: string | null;
6 | repeat: number;
7 | }
8 |
--------------------------------------------------------------------------------
/src/pages/steganography/Output/constant.ts:
--------------------------------------------------------------------------------
1 | import { TableColumn } from "@/components/Table/type";
2 |
3 | export const columns: TableColumn[] = [
4 | {
5 | title: "隐写图",
6 | key: "image",
7 | },
8 | {
9 | title: "原图大小",
10 | key: "originSize",
11 | },
12 | {
13 | title: "隐写图大小",
14 | key: "currentSize",
15 | },
16 | {
17 | title: "压缩率",
18 | key: "compressionRatio",
19 | },
20 | {
21 | title: "承载信息",
22 | key: "message",
23 | },
24 | {
25 | title: "操作",
26 | key: "operate",
27 | },
28 | ];
29 |
--------------------------------------------------------------------------------
/src/pages/steganography/Output/index.tsx:
--------------------------------------------------------------------------------
1 | import React, { Fragment, useState } from "react";
2 | import Table from "@/components/Table";
3 | import { FileType } from "@/components/Upload/type";
4 | import { columns } from "./constant";
5 | import CustomModal from "@/components/CustomModal";
6 | import { getCompressionRate } from "@/utils/file";
7 | import { ReactComponent as SVG_delete } from "@/assets/svg/delete.svg";
8 | import { Thumbnail } from "@/components/Thumbnail";
9 | import saveAs from "file-saver";
10 | import { formatSize } from "@/utils/number";
11 |
12 | export default function Output({
13 | pairList,
14 | className,
15 | disabled,
16 | onRemove,
17 | }: {
18 | pairList: [FileType, FileType, string][];
19 | className?: string;
20 | disabled?: boolean;
21 | onRemove?: (md5: string) => void;
22 | }) {
23 | const [isModalOpen, setIsModalOpen] = useState(false);
24 | const [editImage, setEditImage] = useState<{
25 | src: string;
26 | name: string;
27 | } | null>(null);
28 | /**
29 | * 打开图片模态框
30 | */
31 | const handleOpenModal = (src: string, name: string) => {
32 | setIsModalOpen(true);
33 | setEditImage({
34 | src,
35 | name,
36 | });
37 | };
38 | /**
39 | * 关闭图片模态框
40 | */
41 | const handleCloseModal = () => {
42 | setIsModalOpen(false);
43 | setEditImage(null);
44 | };
45 | /**
46 | * 删除图像
47 | */
48 | const handleRemove = (md5: string) => {
49 | if (disabled) {
50 | return;
51 | }
52 | onRemove?.(md5);
53 | };
54 | /**
55 | * 下载图像
56 | */
57 | const handleDown = ({ file }: FileType) => {
58 | if (disabled) {
59 | return;
60 | }
61 | saveAs(file, file.name);
62 | };
63 |
64 | /**
65 | * 生成表格数据
66 | */
67 | const generateData = () =>
68 | Array.from(pairList, ([originFile, encryptFile, payload]) => {
69 | const id = originFile.md5;
70 | const image = (
71 |
244 |
252 |
260 |
263 |
264 |
86 | handleDown(encryptFile)}
88 | className="cursor-pointer select-none text-blue-500 font-semibold text-sm underline underline-offset-2 mx-2"
89 | >
90 | 下载
91 |
92 | handleRemove(originFile.md5)}
94 | className="cursor-pointer select-none text-red-500 font-semibold text-sm underline underline-offset-2 mx-2"
95 | >
96 | 删除
97 |
98 |
99 | );
100 | return {
101 | id,
102 | image,
103 | originSize,
104 | currentSize,
105 | compressionRatio: (
106 | 100 ? "text-red-500" : "text-green-500"
109 | }`}
110 | >
111 | {compressionRatio}%
112 |
113 | ),
114 | message: (
115 |
116 | {payload}
117 |
118 | ),
119 | operate,
120 | };
121 | });
122 |
123 | return (
124 |
126 |
130 |
127 |
128 |
129 |
135 | {editImage && (
136 | e.preventDefault()}
141 | >
142 |
151 |
152 | )}
153 |
154 |
155 |
161 |
219 |
283 | );
284 | }
285 |
--------------------------------------------------------------------------------
/src/plugins/encryption/Arnold/index.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "Arnold变换",
3 | "key": "encry_arnold",
4 | "version": "1.0.0",
5 | "description": "基于Arnold变换, 对图像像素位置置乱, 加密结果是正方形",
6 | "language": "javascript",
7 | "keyRule": {
8 | "regex": "^0*(100|[1-9][0-9]?)$",
9 | "required": true,
10 | "message": "请输入数字范围为1-100"
11 | }
12 | }
--------------------------------------------------------------------------------
/src/plugins/encryption/Arnold/index.ts:
--------------------------------------------------------------------------------
1 | import { PixelBuffer } from "@/service/image/type";
2 | import { processImageByWebGL2 } from "@/utils/webgl";
3 | import { padImageToSquare, restoreImageFromSquare } from "@/utils/file";
4 |
5 | type encryptFuncType = (
6 | data: PixelBuffer,
7 | key: string
8 | ) => {
9 | data: PixelBuffer;
10 | };
11 | type decryptFuncType = encryptFuncType;
12 |
13 | const encrypt: encryptFuncType = (data, key) => {
14 | // 将图像填充为正方形
15 | const paddedData = padImageToSquare(data);
16 | // 片段着色器
17 | const fragmentShader = `#version 300 es
18 | precision mediump float;
19 | uniform int u_iteration;
20 | uniform float u_size;
21 | uniform sampler2D u_texture;
22 | in vec2 v_texcoord;
23 | out vec4 outColor;
24 | void main() {
25 | // 将纹理坐标转换为像素坐标
26 | ivec2 pixelCoordinate = ivec2(v_texcoord * u_size);
27 | // 定义变换矩阵
28 | const mat2 transformMatrix = mat2(1.0, 1.0, 1.0, 2.0);
29 | //迭代变换
30 | for (int i = 0; i < u_iteration; i++) {
31 | // 将 pixelCoordinate 转换为 vec2 类型以进行矩阵乘法
32 | vec2 tempPixelCoordinate = vec2(pixelCoordinate);
33 | // 计算矩阵乘积
34 | tempPixelCoordinate = transformMatrix * tempPixelCoordinate;
35 | // 将结果转换回 ivec2 类型
36 | pixelCoordinate = ivec2(tempPixelCoordinate);
37 | // 为结果加上 int(u_size)
38 | pixelCoordinate = pixelCoordinate + int(u_size);
39 | // 对结果取模 u_size
40 | pixelCoordinate = pixelCoordinate % int(u_size);
41 | }
42 |
43 | // 将获取到的颜色值设置为输出颜色
44 | outColor = texelFetch(u_texture, pixelCoordinate, 0);
45 | }
46 | `;
47 |
48 | // 处理函数
49 | const process = (gl: WebGL2RenderingContext, program: WebGLProgram) => {
50 | // 获取 u_iteration 变量位置
51 | const iterationsLocation = gl.getUniformLocation(program, "u_iteration");
52 | gl.uniform1i(iterationsLocation, Number(key));
53 | // 获取 u_size 变量位置
54 | const sizeLocation = gl.getUniformLocation(program, "u_size");
55 | gl.uniform1f(sizeLocation, paddedData.width);
56 | };
57 |
58 | // 返回输出数据
59 | return {
60 | data: processImageByWebGL2(paddedData, fragmentShader, process),
61 | };
62 | };
63 | const decrypt: decryptFuncType = (data, key) => {
64 | // 片段着色器
65 | const fragmentShader = `#version 300 es
66 | precision highp float;
67 | uniform int u_iterations;
68 | uniform float u_size;
69 | uniform sampler2D u_texture;
70 | in vec2 v_texcoord;
71 | out vec4 outColor;
72 | void main() {
73 | // 将纹理坐标转换为像素坐标
74 | ivec2 pixelCoordinate = ivec2(v_texcoord * u_size);
75 | // 定义变换矩阵
76 | const mat2 transformMatrix = mat2(2.0, -1.0, -1.0, 1.0);
77 | for (int i = 0; i < u_iterations; i++) {
78 | // 将 pixelCoordinate 转换为 vec2 类型以进行矩阵乘法
79 | vec2 tempPixelCoordinate = vec2(pixelCoordinate);
80 | // 计算矩阵乘积
81 | tempPixelCoordinate = transformMatrix * tempPixelCoordinate;
82 | // 将结果转换回 ivec2 类型
83 | pixelCoordinate = ivec2(tempPixelCoordinate);
84 | // 为结果加上 int(u_size)
85 | pixelCoordinate = pixelCoordinate + int(u_size);
86 | // 对结果取模 u_size
87 | pixelCoordinate = pixelCoordinate % int(u_size);
88 | }
89 | outColor = texelFetch(u_texture, pixelCoordinate, 0);
90 | }
91 | `;
92 |
93 | // 处理函数
94 | const process = (gl: WebGL2RenderingContext, program: WebGLProgram) => {
95 | // 获取 u_iterations 变量位置
96 | const iterationsLocation = gl.getUniformLocation(program, "u_iterations");
97 | gl.uniform1i(iterationsLocation, Number(key));
98 | // 获取 u_size 变量位置
99 | const sizeLocation = gl.getUniformLocation(program, "u_size");
100 | gl.uniform1f(sizeLocation, data.width);
101 | };
102 |
103 | // 进行Arnold变换
104 | const transformData = processImageByWebGL2(data, fragmentShader, process);
105 | //裁剪图像
106 | return {
107 | data: restoreImageFromSquare(transformData),
108 | };
109 | };
110 |
111 | export { encrypt, decrypt };
112 |
--------------------------------------------------------------------------------
/src/plugins/encryption/DNA/index.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "基于DNA编码的混沌加密算法",
3 | "key": "encry_dna",
4 | "version": "1.0.0",
5 | "description": "基于DNA动态编码及混沌Logistic映射的加密算法",
6 | "language": "javascript",
7 | "keyRule": {
8 | "regex": "",
9 | "required": true,
10 | "message": ""
11 | }
12 | }
--------------------------------------------------------------------------------
/src/plugins/encryption/DNA/index.ts:
--------------------------------------------------------------------------------
1 | import { PixelBuffer } from "@/service/image/type";
2 | import { DNAByte } from "@/utils/dna";
3 | import { PBKDF2 } from "crypto-js";
4 | import { str2Num } from "@/utils/string";
5 | import {
6 | dnaByte2Byte,
7 | byte2DNAByte,
8 | add4Rule1,
9 | sub4Rule1,
10 | xor4Rule1,
11 | } from "@/utils/dna";
12 |
13 | type encryptFuncType = (
14 | data: PixelBuffer,
15 | key: string
16 | ) => {
17 | data: PixelBuffer;
18 | };
19 | type decryptFuncType = encryptFuncType;
20 | type DNAByte3Channel = [DNAByte, DNAByte, DNAByte];
21 | /**
22 | * 默认规则编码->在默认规则编码的前提下用某种方式和前一个像素计算->动态规则解码
23 | * @param data 图像数据
24 | * @param key 密钥
25 | * @returns 加密后的图像数据
26 | */
27 | const encrypt: encryptFuncType = ({ buffer, width, height, name }, key) => {
28 | // 初始化
29 | const pixels = new Uint8ClampedArray(buffer);
30 | const midPixels = new Uint8ClampedArray(pixels.length);
31 |
32 | //规则对应操作
33 | const funcMap = {
34 | 0: add4Rule1,
35 | 1: xor4Rule1,
36 | 2: sub4Rule1,
37 | };
38 | // logistic映射函数
39 | const logistic = (x: number) => {
40 | const mu = 3.999999999999999;
41 | return mu * x * (1 - x);
42 | };
43 |
44 | //派生密钥
45 | //keys[0-2]用于确定不同通道动态规则
46 | //keys[3]用于确定运算规则
47 | const keys = Array.from({ length: 4 }, (_, i) =>
48 | PBKDF2(key, `key${i}`).toString()
49 | );
50 | //额外的密钥用于确定初始状态
51 | //用于确定默认规则和扩散初始值
52 | const extraKeys = Array.from({ length: 3 }, (_, i) =>
53 | PBKDF2(key, `extraKey${i}`).toString()
54 | );
55 | //将密钥转换为初始状态
56 | let states = keys.map((key) => str2Num(key, true));
57 | //将额外密钥转换为初始状态
58 | let extraStates = extraKeys.map((key) => str2Num(key, true));
59 | //初始迭代1000次
60 | for (let i = 0; i < 1000; i++) {
61 | states = states.map(logistic);
62 | extraStates = extraStates.map(logistic);
63 | }
64 | //确定默认规则
65 | const defaultRule = Math.round(extraStates[0] * 7);
66 | //确定扩散初始值
67 | const prevDNAByte3Channel: DNAByte3Channel = [
68 | byte2DNAByte(
69 | Math.round(extraStates[2] * 255),
70 | Math.round(extraStates[0] * 7)
71 | ),
72 | byte2DNAByte(
73 | Math.round(extraStates[1] * 255),
74 | Math.round(extraStates[1] * 7)
75 | ),
76 | byte2DNAByte(
77 | Math.round(extraStates[0] * 255),
78 | Math.round(extraStates[2] * 7)
79 | ),
80 | ];
81 | //使用混沌序列对图像进行加密
82 | for (let h = 0; h < height; h++) {
83 | for (let w = 0; w < width; w++) {
84 | const index = (h * width + w) * 4;
85 | //迭代混沌序列
86 | states = states.map(logistic);
87 |
88 | // 使用默认编码规则编码三个通道
89 | const currDNAByte3Channel: DNAByte3Channel = [
90 | byte2DNAByte(pixels[index], defaultRule),
91 | byte2DNAByte(pixels[index + 1], defaultRule),
92 | byte2DNAByte(pixels[index + 2], defaultRule),
93 | ];
94 |
95 | //根据key[1]确定运算规则, 逐通道运算
96 | const ruleFunc = funcMap[Math.round(states[3] * 2) as 0 | 1 | 2];
97 | for (let i = 0; i < prevDNAByte3Channel.length; i++) {
98 | const prevDNAByte = prevDNAByte3Channel[i];
99 | const currDNAByte = currDNAByte3Channel[i];
100 | // 每个像素包含4个编码
101 | currDNAByte3Channel[i] = prevDNAByte.map((prevDNACode, codeIndex) =>
102 | ruleFunc(currDNAByte[codeIndex], prevDNACode)
103 | ) as DNAByte;
104 |
105 | // 记录当前通道编码
106 | prevDNAByte3Channel[i] = currDNAByte3Channel[i];
107 | }
108 |
109 | // 根据key[0]使用动态解码规则解码三个通道
110 | midPixels[index] = dnaByte2Byte(
111 | currDNAByte3Channel[0],
112 | Math.round(states[0] * 7)
113 | );
114 | midPixels[index + 1] = dnaByte2Byte(
115 | currDNAByte3Channel[1],
116 | Math.round(states[1] * 7)
117 | );
118 | midPixels[index + 2] = dnaByte2Byte(
119 | currDNAByte3Channel[2],
120 | Math.round(states[2] * 7)
121 | );
122 | // 图像A值保持不变
123 | midPixels[index + 3] = pixels[index + 3];
124 | }
125 | }
126 | // 输出
127 | return {
128 | data: {
129 | name,
130 | buffer: midPixels.buffer,
131 | width,
132 | height,
133 | },
134 | };
135 | };
136 | /**
137 | * 动态规则解码->得到计算后的结果, 将结果和前一个的加密结果做反运算->默认规则解码
138 | * @param data 图像数据
139 | * @param key 密钥
140 | * @returns 解密后的图像数据
141 | */
142 |
143 | const decrypt: decryptFuncType = ({ buffer, width, height, name }, key) => {
144 | // 初始化
145 | const pixels = new Uint8ClampedArray(buffer);
146 | const midPixels = new Uint8ClampedArray(pixels.length);
147 | //规则对应操作
148 | const funcMap = {
149 | 0: add4Rule1,
150 | 1: xor4Rule1,
151 | 2: sub4Rule1,
152 | };
153 | // logistic映射函数
154 | const logistic = (x: number) => {
155 | const mu = 3.999999999999999;
156 | return mu * x * (1 - x);
157 | };
158 |
159 | //派生密钥
160 | //keys[0-2]用于确定动态规则
161 | //keys[3]用于确定运算规则
162 | const keys = Array.from({ length: 4 }, (_, i) =>
163 | PBKDF2(key, `key${i}`).toString()
164 | );
165 | //额外的密钥用于确定初始状态
166 | //用于确定默认规则和扩散初始值
167 | const extraKeys = Array.from({ length: 3 }, (_, i) =>
168 | PBKDF2(key, `extraKey${i}`).toString()
169 | );
170 | //将密钥转换为初始状态
171 | let states = keys.map((key) => str2Num(key, true));
172 | //将额外密钥转换为初始状态
173 | let extraStates = extraKeys.map((key) => str2Num(key, true));
174 | //初始迭代1000次
175 | for (let i = 0; i < 1000; i++) {
176 | states = states.map(logistic);
177 | extraStates = extraStates.map(logistic);
178 | }
179 | //确定默认规则
180 | const defaultRule = Math.round(extraStates[0] * 7);
181 | //确定扩散初始值
182 | const prevDNAByte3Channel: DNAByte3Channel = [
183 | byte2DNAByte(
184 | Math.round(extraStates[2] * 255),
185 | Math.round(extraStates[0] * 7)
186 | ),
187 | byte2DNAByte(
188 | Math.round(extraStates[1] * 255),
189 | Math.round(extraStates[1] * 7)
190 | ),
191 | byte2DNAByte(
192 | Math.round(extraStates[0] * 255),
193 | Math.round(extraStates[2] * 7)
194 | ),
195 | ];
196 | //使用混沌序列对图像进行解密
197 | for (let h = 0; h < height; h++) {
198 | for (let w = 0; w < width; w++) {
199 | const index = (h * width + w) * 4;
200 | //迭代混沌序列
201 | states = states.map(logistic);
202 |
203 | // 根据key[0]使用动态编码规则编码三个通道，还原到计算后的状态
204 | const currDNAByte3Channel: DNAByte3Channel = [
205 | byte2DNAByte(pixels[index], Math.round(states[0] * 7)),
206 | byte2DNAByte(pixels[index + 1], Math.round(states[1] * 7)),
207 | byte2DNAByte(pixels[index + 2], Math.round(states[2] * 7)),
208 | ];
209 |
210 | //根据key[1]确定运算规则, 逐通道逆运算
211 | const ruleFunc = funcMap[(2 - Math.round(states[3] * 2)) as 0 | 1 | 2];
212 | for (let i = 0; i < prevDNAByte3Channel.length; i++) {
213 | const prevDNAByte = prevDNAByte3Channel[i];
214 | const currDNAByte = currDNAByte3Channel[i];
215 | // 每个像素包含4个编码
216 | // 因为当前像素加密时使用的值是前一个像素加密后的值，所以为了后面的像素解密, 这里也应该是当前像素的加密值
217 | prevDNAByte3Channel[i] = currDNAByte3Channel[i];
218 | // 运算解密像素
219 | currDNAByte3Channel[i] = prevDNAByte.map((prevDNACode, codeIndex) =>
220 | ruleFunc(currDNAByte[codeIndex], prevDNACode)
221 | ) as DNAByte;
222 | }
223 | // 使用默认解码规则解码三个通道
224 | midPixels[index] = dnaByte2Byte(currDNAByte3Channel[0], defaultRule);
225 | midPixels[index + 1] = dnaByte2Byte(currDNAByte3Channel[1], defaultRule);
226 | midPixels[index + 2] = dnaByte2Byte(currDNAByte3Channel[2], defaultRule);
227 | // 图像A值保持不变
228 | midPixels[index + 3] = pixels[index + 3];
229 | }
230 | }
231 | // 输出
232 | return {
233 | data: {
234 | name,
235 | buffer: midPixels.buffer,
236 | width,
237 | height,
238 | },
239 | };
240 | };
241 |
242 | export { encrypt, decrypt };
243 |
--------------------------------------------------------------------------------
/src/plugins/encryption/Logistic/index.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "混沌Logistic加密算法",
3 | "key": "encry_logistic",
4 | "version": "1.0.0",
5 | "description": "基于混沌Logistic映射对图像进行加密",
6 | "language": "javascript",
7 | "keyRule": {
8 | "regex": "",
9 | "required": true,
10 | "message": ""
11 | }
12 | }
--------------------------------------------------------------------------------
/src/plugins/encryption/Logistic/index.ts:
--------------------------------------------------------------------------------
1 | import { PixelBuffer } from "@/service/image/type";
2 | import { PBKDF2 } from "crypto-js";
3 | import { str2Num } from "@/utils/string";
4 | type encryptFuncType = (
5 | data: PixelBuffer,
6 | key: string
7 | ) => {
8 | data: PixelBuffer;
9 | };
10 | type decryptFuncType = encryptFuncType;
11 |
12 | const encrypt: encryptFuncType = ({ buffer, width, height, name }, key) => {
13 | // 初始化
14 | const pixels = new Uint8ClampedArray(buffer);
15 | const midPixels = new Uint8ClampedArray(pixels.length);
16 | // logistic映射函数
17 | const logistic = (x: number) => {
18 | const mu = 3.999999999999999;
19 | return mu * x * (1 - x);
20 | };
21 |
22 | //派生密钥
23 | const keys = Array.from({ length: 4 }, (_, i) =>
24 | PBKDF2(key, `key${i}`).toString()
25 | );
26 |
27 | //将密钥转换为初始状态
28 | let states = keys.map((key) => str2Num(key, true));
29 | //初始迭代1000次
30 | for (let i = 0; i < 1000; i++) {
31 | states = states.map(logistic);
32 | }
33 |
34 | //使用混沌序列对图像进行加密
35 | for (let i = 0; i < height; i++) {
36 | for (let j = 0; j < width; j++) {
37 | const index = (i * width + j) * 4;
38 | // 对像素进行异或, 不同的state迭代次数和不同通道的状态可以极大程度的去除图像三个通道的相关性
39 | states = states.map(logistic);
40 | // 图像R值
41 | states[0] = logistic(states[0]);
42 | midPixels[index] =
43 | pixels[index] ^
44 | Math.round(states[0] * 255) ^
45 | Math.round(states[1] * 255);
46 |
47 | // 图像G值
48 | states[0] = logistic(states[0]);
49 | midPixels[index + 1] =
50 | pixels[index + 1] ^
51 | Math.round(states[0] * 255) ^
52 | Math.round(states[2] * 255);
53 |
54 | // 图像B值
55 | states[0] = logistic(states[0]);
56 | midPixels[index + 2] =
57 | pixels[index + 2] ^
58 | Math.round(states[0] * 255) ^
59 | Math.round(states[3] * 255);
60 |
61 | // 图像A值保持不变
62 | midPixels[index + 3] = pixels[index + 3];
63 | }
64 | }
65 | // 输出
66 | return {
67 | data: {
68 | name,
69 | buffer: midPixels.buffer,
70 | width,
71 | height,
72 | },
73 | };
74 | };
75 |
76 | const decrypt: decryptFuncType = (data, key) => {
77 | // 解密与加密过程相同
78 | return encrypt(data, key);
79 | };
80 |
81 | export { encrypt, decrypt };
82 |
--------------------------------------------------------------------------------
/src/plugins/encryption/Tent/index.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "混沌Tent加密算法",
3 | "key": "encry_tent",
4 | "version": "1.0.0",
5 | "description": "基于Tent映射对图像进行加密",
6 | "language": "javascript",
7 | "keyRule": {
8 | "regex": "",
9 | "required": true,
10 | "message": ""
11 | }
12 | }
--------------------------------------------------------------------------------
/src/plugins/encryption/Tent/index.ts:
--------------------------------------------------------------------------------
1 | import { PixelBuffer } from "@/service/image/type";
2 | import { PBKDF2 } from "crypto-js";
3 | import { str2Num } from "@/utils/string";
4 | type encryptFuncType = (
5 | data: PixelBuffer,
6 | key: string
7 | ) => {
8 | data: PixelBuffer;
9 | };
10 | type decryptFuncType = encryptFuncType;
11 |
12 | const encrypt: encryptFuncType = ({ buffer, width, height, name }, key) => {
13 | // 初始化
14 | const pixels = new Uint8ClampedArray(buffer);
15 | const midPixels = new Uint8ClampedArray(pixels.length);
16 | // Tent映射函数
17 | const tentMap = (x: number) => {
18 | const r = 1.999999999999999;
19 | if (x < 0.5) {
20 | x = r * x;
21 | } else {
22 | x = r * (1 - x);
23 | }
24 | return x;
25 | };
26 |
27 | //派生密钥
28 | const keys = Array.from({ length: 4 }, (_, i) =>
29 | PBKDF2(key, `key${i}`).toString()
30 | );
31 |
32 | //将密钥转换为初始状态
33 | let states = keys.map((key) => str2Num(key, true));
34 | //初始迭代1000次
35 | for (let i = 0; i < 1000; i++) {
36 | states = states.map(tentMap);
37 | }
38 |
39 | //使用混沌序列对图像进行加密
40 | for (let i = 0; i < height; i++) {
41 | for (let j = 0; j < width; j++) {
42 | const index = (i * width + j) * 4;
43 | // 对像素进行异或, 不同的state迭代次数和不同通道的状态可以极大程度的去除图像三个通道的相关性
44 | states = states.map(tentMap);
45 | // 图像R值
46 | states[0] = tentMap(states[0]);
47 | midPixels[index] =
48 | pixels[index] ^
49 | Math.round(states[0] * 255) ^
50 | Math.round(states[1] * 255);
51 |
52 | // 图像G值
53 | states[0] = tentMap(states[0]);
54 | midPixels[index + 1] =
55 | pixels[index + 1] ^
56 | Math.round(states[0] * 255) ^
57 | Math.round(states[2] * 255);
58 |
59 | // 图像B值
60 | states[0] = tentMap(states[0]);
61 | midPixels[index + 2] =
62 | pixels[index + 2] ^
63 | Math.round(states[0] * 255) ^
64 | Math.round(states[3] * 255);
65 |
66 | // 图像A值保持不变
67 | midPixels[index + 3] = pixels[index + 3];
68 | }
69 | }
70 | // 输出
71 | return {
72 | data: {
73 | name,
74 | buffer: midPixels.buffer,
75 | width,
76 | height,
77 | },
78 | };
79 | };
80 |
81 | const decrypt: decryptFuncType = (data, key) => {
82 | // 解密与加密过程相同
83 | return encrypt(data, key);
84 | };
85 |
86 | export { encrypt, decrypt };
87 |
--------------------------------------------------------------------------------
/src/plugins/steganography/DCT/index.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "基于DCT变换的隐写术",
3 | "key": "stega_dct",
4 | "version": "1.0.0",
5 | "description": "基于DCT变换的图像隐写方法",
6 | "language": "javascript",
7 | "keyRule": {
8 | "regex": "",
9 | "required": true,
10 | "message": ""
11 | },
12 | "componentRule": {
13 | "repeat": true
14 | }
15 | }
--------------------------------------------------------------------------------
/src/plugins/steganography/DCT/index.ts:
--------------------------------------------------------------------------------
1 | import { PixelBuffer } from "@/service/image/type";
2 | import { writeMsgToImage, readMsgFromImage } from "./dct";
3 | type encryptFuncType = (
4 | data: PixelBuffer,
5 | key: string,
6 | options: { message: string; repeat: number }
7 | ) => {
8 | data: PixelBuffer;
9 | payload?: string;
10 | };
11 |
12 | type decryptFuncType = (
13 | data: PixelBuffer,
14 | key: string,
15 | options: { repeat: number }
16 | ) => {
17 | data: PixelBuffer;
18 | payload: string;
19 | };
20 | //图像隐写
21 | const encrypt: encryptFuncType = (data, key, { message, repeat }) => {
22 | //如果消息为空，则直接返回原图像
23 | if (!message?.trim()) {
24 | return {
25 | data,
26 | };
27 | }
28 | const resData = writeMsgToImage(data, message, key, repeat);
29 | return {
30 | data: resData,
31 | payload: message,
32 | };
33 | };
34 | //图像提取
35 | const decrypt: decryptFuncType = (data, key, { repeat }) => {
36 | const payload = readMsgFromImage(data, key, repeat);
37 | return {
38 | data,
39 | payload,
40 | };
41 | };
42 |
43 | export { encrypt, decrypt };
44 |
--------------------------------------------------------------------------------
/src/plugins/steganography/DCT/mersenne-twister.d.ts:
--------------------------------------------------------------------------------
1 | declare class MersenneTwister {
2 | constructor(seed?: number);
3 | init_genrand(s: number): void;
4 | init_by_array(init_key: number[], key_length: number): void;
5 | genrand_int32(): number;
6 | }
7 | export default MersenneTwister;
8 |
--------------------------------------------------------------------------------
/src/plugins/steganography/DCT/mersenne-twister.js:
--------------------------------------------------------------------------------
1 | // Code from https://gist.github.com/banksean/300494 for seeded rand.
2 |
3 | /*
4 | I've wrapped Makoto Matsumoto and Takuji Nishimura's code in a namespace
5 | so it's better encapsulated. Now you can have multiple random number generators
6 | and they won't stomp all over eachother's state.
7 |
8 | If you want to use this as a substitute for Math.random(), use the random()
9 | method like so:
10 |
11 | var m = new MersenneTwister();
12 | var randomNumber = m.random();
13 |
14 | You can also call the other genrand_{foo}() methods on the instance.
15 | If you want to use a specific seed in order to get a repeatable random
16 | sequence, pass an integer into the constructor:
17 | var m = new MersenneTwister(123);
18 | and that will always produce the same random sequence.
19 | Sean McCullough (banksean@gmail.com)
20 | */
21 |
22 | /*
23 | A C-program for MT19937, with initialization improved 2002/1/26.
24 | Coded by Takuji Nishimura and Makoto Matsumoto.
25 |
26 | Before using, initialize the state by using init_genrand(seed)
27 | or init_by_array(init_key, key_length).
28 |
29 | Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
30 | All rights reserved.
31 |
32 | Redistribution and use in source and binary forms, with or without
33 | modification, are permitted provided that the following conditions
34 | are met:
35 |
36 | 1. Redistributions of source code must retain the above copyright
37 | notice, this list of conditions and the following disclaimer.
38 |
39 | 2. Redistributions in binary form must reproduce the above copyright
40 | notice, this list of conditions and the following disclaimer in the
41 | documentation and/or other materials provided with the distribution.
42 |
43 | 3. The names of its contributors may not be used to endorse or promote
44 | products derived from this software without specific prior written
45 | permission.
46 |
47 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
48 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
49 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
50 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
51 | CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
52 | EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
53 | PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
54 | PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
55 | LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
56 | NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
57 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
58 |
59 |
60 | Any feedback is very welcome.
61 | http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
62 | email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
63 | */
64 |
65 | var MersenneTwister = function (seed) {
66 | if (seed == undefined) {
67 | seed = new Date().getTime();
68 | }
69 | /* Period parameters */
70 | this.N = 624;
71 | this.M = 397;
72 | this.MATRIX_A = 0x9908b0df; /* constant vector a */
73 | this.UPPER_MASK = 0x80000000; /* most significant w-r bits */
74 | this.LOWER_MASK = 0x7fffffff; /* least significant r bits */
75 |
76 | this.mt = new Array(this.N); /* the array for the state vector */
77 | this.mti = this.N + 1; /* mti==N+1 means mt[N] is not initialized */
78 |
79 | this.init_genrand(seed);
80 | };
81 |
82 | /* initializes mt[N] with a seed */
83 | MersenneTwister.prototype.init_genrand = function (s) {
84 | this.mt[0] = s >>> 0;
85 | for (this.mti = 1; this.mti < this.N; this.mti++) {
86 | const s = this.mt[this.mti - 1] ^ (this.mt[this.mti - 1] >>> 30);
87 | this.mt[this.mti] =
88 | ((((s & 0xffff0000) >>> 16) * 1812433253) << 16) +
89 | (s & 0x0000ffff) * 1812433253 +
90 | this.mti;
91 | /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
92 | /* In the previous versions, MSBs of the seed affect */
93 | /* only MSBs of the array mt[]. */
94 | /* 2002/01/09 modified by Makoto Matsumoto */
95 | this.mt[this.mti] >>>= 0;
96 | /* for >32 bit machines */
97 | }
98 | };
99 |
100 | /* initialize by an array with array-length */
101 | /* init_key is the array for initializing keys */
102 | /* key_length is its length */
103 | /* slight change for C++, 2004/2/26 */
104 | MersenneTwister.prototype.init_by_array = function (init_key, key_length) {
105 | var i, j, k;
106 | this.init_genrand(19650218);
107 | i = 1;
108 | j = 0;
109 | k = this.N > key_length ? this.N : key_length;
110 | for (; k; k--) {
111 | var s = this.mt[i - 1] ^ (this.mt[i - 1] >>> 30);
112 | this.mt[i] =
113 | (this.mt[i] ^
114 | (((((s & 0xffff0000) >>> 16) * 1664525) << 16) +
115 | (s & 0x0000ffff) * 1664525)) +
116 | init_key[j] +
117 | j; /* non linear */
118 | this.mt[i] >>>= 0; /* for WORDSIZE > 32 machines */
119 | i++;
120 | j++;
121 | if (i >= this.N) {
122 | this.mt[0] = this.mt[this.N - 1];
123 | i = 1;
124 | }
125 | if (j >= key_length) j = 0;
126 | }
127 | for (k = this.N - 1; k; k--) {
128 | const s = this.mt[i - 1] ^ (this.mt[i - 1] >>> 30);
129 | this.mt[i] =
130 | (this.mt[i] ^
131 | (((((s & 0xffff0000) >>> 16) * 1566083941) << 16) +
132 | (s & 0x0000ffff) * 1566083941)) -
133 | i; /* non linear */
134 | this.mt[i] >>>= 0; /* for WORDSIZE > 32 machines */
135 | i++;
136 | if (i >= this.N) {
137 | this.mt[0] = this.mt[this.N - 1];
138 | i = 1;
139 | }
140 | }
141 |
142 | this.mt[0] = 0x80000000; /* MSB is 1; assuring non-zero initial array */
143 | };
144 |
145 | /* generates a random number on [0,0xffffffff]-interval */
146 | MersenneTwister.prototype.genrand_int32 = function () {
147 | var y;
148 | var mag01 = [0x0, this.MATRIX_A];
149 | /* mag01[x] = x * MATRIX_A for x=0,1 */
150 |
151 | if (this.mti >= this.N) {
152 | /* generate N words at one time */
153 | var kk;
154 |
155 | if (this.mti == this.N + 1)
156 | /* if init_genrand() has not been called, */
157 | this.init_genrand(5489); /* a default initial seed is used */
158 |
159 | for (kk = 0; kk < this.N - this.M; kk++) {
160 | y = (this.mt[kk] & this.UPPER_MASK) | (this.mt[kk + 1] & this.LOWER_MASK);
161 | this.mt[kk] = this.mt[kk + this.M] ^ (y >>> 1) ^ mag01[y & 0x1];
162 | }
163 | for (; kk < this.N - 1; kk++) {
164 | y = (this.mt[kk] & this.UPPER_MASK) | (this.mt[kk + 1] & this.LOWER_MASK);
165 | this.mt[kk] =
166 | this.mt[kk + (this.M - this.N)] ^ (y >>> 1) ^ mag01[y & 0x1];
167 | }
168 | y =
169 | (this.mt[this.N - 1] & this.UPPER_MASK) | (this.mt[0] & this.LOWER_MASK);
170 | this.mt[this.N - 1] = this.mt[this.M - 1] ^ (y >>> 1) ^ mag01[y & 0x1];
171 |
172 | this.mti = 0;
173 | }
174 |
175 | y = this.mt[this.mti++];
176 |
177 | /* Tempering */
178 | y ^= y >>> 11;
179 | y ^= (y << 7) & 0x9d2c5680;
180 | y ^= (y << 15) & 0xefc60000;
181 | y ^= y >>> 18;
182 |
183 | return y >>> 0;
184 | };
185 | /* These real versions are due to Isaku Wada, 2002/01/09 added */
186 | export default MersenneTwister;
187 |
--------------------------------------------------------------------------------
/src/plugins/steganography/DCT/utf_8.ts:
--------------------------------------------------------------------------------
1 | /**
2 | * 用于将UTF-8编码的字节数组解码为字符串
3 | * @param {*} bytes 字节数组
4 | * @returns 解码后的字符串
5 | */
6 | export function utf8Decode(bytes: number[]): string {
7 | const chars = [];
8 | let offset = 0;
9 | const length = bytes.length;
10 | let c;
11 | let c2;
12 | let c3;
13 |
14 | while (offset < length) {
15 | c = bytes[offset];
16 | c2 = bytes[offset + 1];
17 | c3 = bytes[offset + 2];
18 |
19 | if (128 > c) {
20 | chars.push(String.fromCharCode(c));
21 | offset += 1;
22 | } else if (191 < c && c < 224) {
23 | chars.push(String.fromCharCode(((c & 31) << 6) | (c2 & 63)));
24 | offset += 2;
25 | } else {
26 | chars.push(
27 | String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63))
28 | );
29 | offset += 3;
30 | }
31 | }
32 |
33 | return chars.join("");
34 | }
35 | /**
36 | * 用用于将字符串编码为UTF-8字节数组
37 | * @param {*} str 输入字符串
38 | * @returns 编码后的字节数组
39 | */
40 | export function utf8Encode(str: string) {
41 | const bytes = [];
42 | let offset = 0;
43 | let char;
44 |
45 | str = encodeURI(str);
46 | const length = str.length;
47 |
48 | while (offset < length) {
49 | char = str[offset];
50 | offset += 1;
51 |
52 | if ("%" !== char) {
53 | bytes.push(char.charCodeAt(0));
54 | } else {
55 | char = str[offset] + str[offset + 1];
56 | bytes.push(parseInt(char, 16));
57 | offset += 2;
58 | }
59 | }
60 |
61 | return bytes;
62 | }
63 |
--------------------------------------------------------------------------------
/src/plugins/steganography/lsb/index.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "LSB隐写",
3 | "key": "stega_lsb",
4 | "version": "1.0.0",
5 | "description": "基于最低有效位的图像隐写方法",
6 | "language": "javascript",
7 | "keyRule": {
8 | "regex": "",
9 | "required": true,
10 | "message": ""
11 | },
12 | "componentRule": {
13 | "repeat": false
14 | }
15 | }
--------------------------------------------------------------------------------
/src/plugins/steganography/lsb/index.ts:
--------------------------------------------------------------------------------
1 | import { PixelBuffer } from "@/service/image/type";
2 | import { writeMsgToImage, readMsgFromImage } from "./lsb";
3 | type encryptFuncType = (
4 | data: PixelBuffer,
5 | key: string,
6 | options: { message: string; repeat: number }
7 | ) => {
8 | data: PixelBuffer;
9 | payload?: string;
10 | };
11 |
12 | type decryptFuncType = (
13 | data: PixelBuffer,
14 | key: string,
15 | options: { repeat: number }
16 | ) => {
17 | data: PixelBuffer;
18 | payload: string;
19 | };
20 | //图像隐写
21 | const encrypt: encryptFuncType = (data, key, { message }) => {
22 | //如果消息为空，则直接返回原图像
23 | if (!message?.trim()) {
24 | return {
25 | data,
26 | };
27 | }
28 | const resData = writeMsgToImage(data, message, key);
29 | return {
30 | data: resData,
31 | payload: message,
32 | };
33 | };
34 | //图像提取
35 | const decrypt: decryptFuncType = (data, key) => {
36 | const payload = readMsgFromImage(data, key);
37 | return {
38 | data,
39 | payload,
40 | };
41 | };
42 |
43 | export { encrypt, decrypt };
44 |
--------------------------------------------------------------------------------
/src/plugins/steganography/lsb/lsb.ts:
--------------------------------------------------------------------------------
1 | import { PixelBuffer } from "@/service/image/type";
2 | import { SHA512 } from "crypto-js";
3 | import MersenneTwister from "./mersenne-twister";
4 | import { utf8Encode, utf8Decode } from "./utf_8";
5 |
6 | /**
7 | * 基于密码生成一个哈希顺序数组
8 | * @param password 用于生成哈希顺序的密码
9 | * @param arr_len 生成的顺序数组长度
10 | * @returns 生成的哈希顺序数组
11 | */
12 | function get_hashed_order(password: string, arr_len: number) {
13 | // O(arr_len) algorithm
14 | const orders = Array.from(Array(arr_len).keys());
15 | const result = [];
16 | let loc;
17 | const seed = SHA512(password).words.reduce(function (total, num) {
18 | return total + Math.abs(num);
19 | }, 0);
20 | const rnd = new MersenneTwister(seed);
21 | for (let i = arr_len; i > 0; i--) {
22 | loc = rnd.genrand_int32() % i;
23 | result.push(orders[loc]);
24 | orders[loc] = orders[i - 1];
25 | }
26 | return result;
27 | }
28 |
29 | /**
30 | * 将字符串转换为二进制数组
31 | * @param str 输入字符串
32 | * @param num_copy 每个字符复制的次数
33 | * @returns 二进制数组
34 | */
35 | function str_to_bits(str: string, num_copy: number) {
36 | const utf8array = utf8Encode(str);
37 | const result = [];
38 | const utf8strlen = utf8array.length;
39 | for (let i = 0; i < utf8strlen; i++) {
40 | for (let j = 128; j > 0; j = Math.floor(j / 2)) {
41 | if (Math.floor(utf8array[i] / j)) {
42 | for (let cp = 0; cp < num_copy; cp++) result.push(1);
43 | utf8array[i] -= j;
44 | } else {
45 | for (let cp = 0; cp < num_copy; cp++) result.push(0);
46 | }
47 | }
48 | }
49 | for (let j = 0; j < 24; j++) {
50 | for (let i = 0; i < num_copy; i++) {
51 | result.push(1);
52 | }
53 | }
54 | return result;
55 | }
56 | /**
57 | * 将二进制数组转换为字符串
58 | * @param bitarray 二进制数组
59 | * @param num_copy 每个字符复制的次数
60 | * @returns 字符串
61 | */
62 | function bits_to_str(bitarray: number[], num_copy: number) {
63 | function merge_bits(bits: number[]) {
64 | const bits_len = bits.length;
65 | let bits_sum = 0;
66 | for (let i = 0; i < bits_len; i++) bits_sum += bits[i];
67 | return Math.round(bits_sum / bits_len);
68 | }
69 |
70 | const msg_array = [];
71 | let data, tmp;
72 |
73 | const msg_array_len = Math.floor(Math.floor(bitarray.length / num_copy) / 8);
74 | for (let i = 0; i < msg_array_len; i++) {
75 | data = 0;
76 | tmp = 128;
77 | for (let j = 0; j < 8; j++) {
78 | data +=
79 | merge_bits(
80 | bitarray.slice((i * 8 + j) * num_copy, (i * 8 + j + 1) * num_copy)
81 | ) * tmp;
82 | tmp = Math.floor(tmp / 2);
83 | }
84 | if (data == 255) break; //END NOTATION
85 | msg_array.push(data);
86 | }
87 |
88 | return utf8Decode(msg_array);
89 | }
90 | /**
91 | * 准备要写入的数据，对数据进行混淆，并按照加密密钥生成的哈希顺序将数据位插入到结果数组中
92 | * @param data_bits 要写入的数据位数组
93 | * @param enc_key 加密密钥
94 | * @param encode_len 要编码的长度
95 | * @returns 处理后的数据位数组
96 | */
97 | function prepare_write_data(
98 | data_bits: number[],
99 | enc_key: string,
100 | encode_len: number
101 | ) {
102 | const data_bits_len = data_bits.length;
103 | if (data_bits.length > encode_len) throw "Can not hold this many data!";
104 | const result = Array(encode_len);
105 | for (let i = 0; i < encode_len; i++) {
106 | result[i] = Math.floor(Math.random() * 2); //obfuscation
107 | }
108 |
109 | const order = get_hashed_order(enc_key, encode_len);
110 | for (let i = 0; i < data_bits_len; i++) result[order[i]] = data_bits[i];
111 |
112 | return result;
113 | }
114 | function write_lsb(imageBuffer: Uint8ClampedArray, setdata: number[]) {
115 | function unsetbit(k: number) {
116 | return k % 2 == 1 ? k - 1 : k;
117 | }
118 |
119 | function setbit(k: number) {
120 | return k % 2 == 1 ? k : k + 1;
121 | }
122 | let j = 0;
123 | const newImageBuffer = new Uint8ClampedArray(imageBuffer.length);
124 |
125 | for (let i = 0; i < newImageBuffer.length; i += 4) {
126 | newImageBuffer[i] = setdata[j]
127 | ? setbit(imageBuffer[i])
128 | : unsetbit(imageBuffer[i]);
129 | newImageBuffer[i + 1] = setdata[j + 1]
130 | ? setbit(imageBuffer[i + 1])
131 | : unsetbit(imageBuffer[i + 1]);
132 | newImageBuffer[i + 2] = setdata[j + 2]
133 | ? setbit(imageBuffer[i + 2])
134 | : unsetbit(imageBuffer[i + 2]);
135 | newImageBuffer[i + 3] = imageBuffer[i + 3];
136 | j += 3;
137 | }
138 | return newImageBuffer.buffer;
139 | }
140 |
141 | /**
142 | * 准备要读取的数据，并按照加密密钥生成的哈希顺序读取数据
143 | * @param data_bits 要写入的数据位数组
144 | * @param enc_key 加密密钥
145 | * @returns 处理后的数据位数组
146 | */
147 | function prepare_read_data(data_bits: number[], enc_key: string) {
148 | const data_bits_len = data_bits.length;
149 | const result = Array(data_bits_len);
150 | const order = get_hashed_order(enc_key, data_bits_len);
151 |
152 | for (let i = 0; i < data_bits_len; i++) result[i] = data_bits[order[i]];
153 |
154 | return result;
155 | }
156 | /**
157 | * 从图像数据中读取数据
158 | * @param imageDataArray 图像数据
159 | * @returns 读取到的数据
160 | */
161 | function get_bits_lsb(imageDataArray: Uint8ClampedArray) {
162 | const result = [];
163 | for (let i = 0; i < imageDataArray.length; i += 4) {
164 | result.push(imageDataArray[i] % 2 == 1 ? 1 : 0);
165 | result.push(imageDataArray[i + 1] % 2 == 1 ? 1 : 0);
166 | result.push(imageDataArray[i + 2] % 2 == 1 ? 1 : 0);
167 | }
168 | return result;
169 | }
170 |
171 | /**
172 | * 从图像中提取消息
173 | * @param pixelData 图像数据
174 | * @param enc_key 用于提取消息的密钥
175 | * @param num_copy 每个位要写入图像的副本数。较大的值具有更强的鲁棒性，但容量较小
176 | * @returns 提取的消息
177 | */
178 | export function readMsgFromImage(
179 | pixelData: PixelBuffer,
180 | enc_key: string,
181 | num_copy = 1
182 | ) {
183 | const imageDataArray = new Uint8ClampedArray(pixelData.buffer);
184 | const tempBitsArray = get_bits_lsb(imageDataArray);
185 | const tempArray = prepare_read_data(tempBitsArray, enc_key);
186 | return bits_to_str(tempArray, num_copy);
187 | }
188 | /**
189 | * 将消息写入图像
190 | * @param pixelData 图像数据
191 | * @param msg 要隐藏的消息
192 | * @param enc_key 用于加密消息的密钥
193 | * @param num_copy 每个位要写入图像的副本数。较大的值具有更强的鲁棒性，但容量较小
194 | * @returns 处理后的图像数据
195 | */
196 | export const writeMsgToImage = (
197 | pixelData: PixelBuffer,
198 | msg: string,
199 | enc_key: string,
200 | num_copy = 1
201 | ): PixelBuffer => {
202 | const imageBuffer = new Uint8ClampedArray(pixelData.buffer);
203 | //保存结果
204 | let resultBuffer = pixelData.buffer;
205 | const encode_len = (imageBuffer.length / 4) * 3;
206 | // prepare data
207 | let bit_stream = str_to_bits(msg, num_copy);
208 | bit_stream = prepare_write_data(bit_stream, enc_key, encode_len);
209 | resultBuffer = write_lsb(imageBuffer, bit_stream);
210 | return {
211 | width: pixelData.width,
212 | height: pixelData.height,
213 | name: pixelData.name,
214 | buffer: resultBuffer,
215 | };
216 | };
217 |
--------------------------------------------------------------------------------
/src/plugins/steganography/lsb/mersenne-twister.d.ts:
--------------------------------------------------------------------------------
1 | declare class MersenneTwister {
2 | constructor(seed?: number);
3 | init_genrand(s: number): void;
4 | init_by_array(init_key: number[], key_length: number): void;
5 | genrand_int32(): number;
6 | }
7 | export default MersenneTwister;
8 |
--------------------------------------------------------------------------------
/src/plugins/steganography/lsb/mersenne-twister.js:
--------------------------------------------------------------------------------
1 | // Code from https://gist.github.com/banksean/300494 for seeded rand.
2 |
3 | /*
4 | I've wrapped Makoto Matsumoto and Takuji Nishimura's code in a namespace
5 | so it's better encapsulated. Now you can have multiple random number generators
6 | and they won't stomp all over eachother's state.
7 |
8 | If you want to use this as a substitute for Math.random(), use the random()
9 | method like so:
10 |
11 | var m = new MersenneTwister();
12 | var randomNumber = m.random();
13 |
14 | You can also call the other genrand_{foo}() methods on the instance.
15 | If you want to use a specific seed in order to get a repeatable random
16 | sequence, pass an integer into the constructor:
17 | var m = new MersenneTwister(123);
18 | and that will always produce the same random sequence.
19 | Sean McCullough (banksean@gmail.com)
20 | */
21 |
22 | /*
23 | A C-program for MT19937, with initialization improved 2002/1/26.
24 | Coded by Takuji Nishimura and Makoto Matsumoto.
25 |
26 | Before using, initialize the state by using init_genrand(seed)
27 | or init_by_array(init_key, key_length).
28 |
29 | Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
30 | All rights reserved.
31 |
32 | Redistribution and use in source and binary forms, with or without
33 | modification, are permitted provided that the following conditions
34 | are met:
35 |
36 | 1. Redistributions of source code must retain the above copyright
37 | notice, this list of conditions and the following disclaimer.
38 |
39 | 2. Redistributions in binary form must reproduce the above copyright
40 | notice, this list of conditions and the following disclaimer in the
41 | documentation and/or other materials provided with the distribution.
42 |
43 | 3. The names of its contributors may not be used to endorse or promote
44 | products derived from this software without specific prior written
45 | permission.
46 |
47 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
48 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
49 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
50 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
51 | CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
52 | EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
53 | PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
54 | PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
55 | LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
56 | NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
57 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
58 |
59 |
60 | Any feedback is very welcome.
61 | http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
62 | email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
63 | */
64 |
65 | var MersenneTwister = function (seed) {
66 | if (seed == undefined) {
67 | seed = new Date().getTime();
68 | }
69 | /* Period parameters */
70 | this.N = 624;
71 | this.M = 397;
72 | this.MATRIX_A = 0x9908b0df; /* constant vector a */
73 | this.UPPER_MASK = 0x80000000; /* most significant w-r bits */
74 | this.LOWER_MASK = 0x7fffffff; /* least significant r bits */
75 |
76 | this.mt = new Array(this.N); /* the array for the state vector */
77 | this.mti = this.N + 1; /* mti==N+1 means mt[N] is not initialized */
78 |
79 | this.init_genrand(seed);
80 | };
81 |
82 | /* initializes mt[N] with a seed */
83 | MersenneTwister.prototype.init_genrand = function (s) {
84 | this.mt[0] = s >>> 0;
85 | for (this.mti = 1; this.mti < this.N; this.mti++) {
86 | const s = this.mt[this.mti - 1] ^ (this.mt[this.mti - 1] >>> 30);
87 | this.mt[this.mti] =
88 | ((((s & 0xffff0000) >>> 16) * 1812433253) << 16) +
89 | (s & 0x0000ffff) * 1812433253 +
90 | this.mti;
91 | /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
92 | /* In the previous versions, MSBs of the seed affect */
93 | /* only MSBs of the array mt[]. */
94 | /* 2002/01/09 modified by Makoto Matsumoto */
95 | this.mt[this.mti] >>>= 0;
96 | /* for >32 bit machines */
97 | }
98 | };
99 |
100 | /* initialize by an array with array-length */
101 | /* init_key is the array for initializing keys */
102 | /* key_length is its length */
103 | /* slight change for C++, 2004/2/26 */
104 | MersenneTwister.prototype.init_by_array = function (init_key, key_length) {
105 | var i, j, k;
106 | this.init_genrand(19650218);
107 | i = 1;
108 | j = 0;
109 | k = this.N > key_length ? this.N : key_length;
110 | for (; k; k--) {
111 | var s = this.mt[i - 1] ^ (this.mt[i - 1] >>> 30);
112 | this.mt[i] =
113 | (this.mt[i] ^
114 | (((((s & 0xffff0000) >>> 16) * 1664525) << 16) +
115 | (s & 0x0000ffff) * 1664525)) +
116 | init_key[j] +
117 | j; /* non linear */
118 | this.mt[i] >>>= 0; /* for WORDSIZE > 32 machines */
119 | i++;
120 | j++;
121 | if (i >= this.N) {
122 | this.mt[0] = this.mt[this.N - 1];
123 | i = 1;
124 | }
125 | if (j >= key_length) j = 0;
126 | }
127 | for (k = this.N - 1; k; k--) {
128 | const s = this.mt[i - 1] ^ (this.mt[i - 1] >>> 30);
129 | this.mt[i] =
130 | (this.mt[i] ^
131 | (((((s & 0xffff0000) >>> 16) * 1566083941) << 16) +
132 | (s & 0x0000ffff) * 1566083941)) -
133 | i; /* non linear */
134 | this.mt[i] >>>= 0; /* for WORDSIZE > 32 machines */
135 | i++;
136 | if (i >= this.N) {
137 | this.mt[0] = this.mt[this.N - 1];
138 | i = 1;
139 | }
140 | }
141 |
142 | this.mt[0] = 0x80000000; /* MSB is 1; assuring non-zero initial array */
143 | };
144 |
145 | /* generates a random number on [0,0xffffffff]-interval */
146 | MersenneTwister.prototype.genrand_int32 = function () {
147 | var y;
148 | var mag01 = [0x0, this.MATRIX_A];
149 | /* mag01[x] = x * MATRIX_A for x=0,1 */
150 |
151 | if (this.mti >= this.N) {
152 | /* generate N words at one time */
153 | var kk;
154 |
155 | if (this.mti == this.N + 1)
156 | /* if init_genrand() has not been called, */
157 | this.init_genrand(5489); /* a default initial seed is used */
158 |
159 | for (kk = 0; kk < this.N - this.M; kk++) {
160 | y = (this.mt[kk] & this.UPPER_MASK) | (this.mt[kk + 1] & this.LOWER_MASK);
161 | this.mt[kk] = this.mt[kk + this.M] ^ (y >>> 1) ^ mag01[y & 0x1];
162 | }
163 | for (; kk < this.N - 1; kk++) {
164 | y = (this.mt[kk] & this.UPPER_MASK) | (this.mt[kk + 1] & this.LOWER_MASK);
165 | this.mt[kk] =
166 | this.mt[kk + (this.M - this.N)] ^ (y >>> 1) ^ mag01[y & 0x1];
167 | }
168 | y =
169 | (this.mt[this.N - 1] & this.UPPER_MASK) | (this.mt[0] & this.LOWER_MASK);
170 | this.mt[this.N - 1] = this.mt[this.M - 1] ^ (y >>> 1) ^ mag01[y & 0x1];
171 |
172 | this.mti = 0;
173 | }
174 |
175 | y = this.mt[this.mti++];
176 |
177 | /* Tempering */
178 | y ^= y >>> 11;
179 | y ^= (y << 7) & 0x9d2c5680;
180 | y ^= (y << 15) & 0xefc60000;
181 | y ^= y >>> 18;
182 |
183 | return y >>> 0;
184 | };
185 | /* These real versions are due to Isaku Wada, 2002/01/09 added */
186 | export default MersenneTwister;
187 |
--------------------------------------------------------------------------------
/src/plugins/steganography/lsb/utf_8.ts:
--------------------------------------------------------------------------------
1 | /**
2 | * 用于将UTF-8编码的字节数组解码为字符串
3 | * @param {*} bytes 字节数组
4 | * @returns 解码后的字符串
5 | */
6 | export function utf8Decode(bytes: number[]): string {
7 | const chars = [];
8 | let offset = 0;
9 | const length = bytes.length;
10 | let c;
11 | let c2;
12 | let c3;
13 |
14 | while (offset < length) {
15 | c = bytes[offset];
16 | c2 = bytes[offset + 1];
17 | c3 = bytes[offset + 2];
18 |
19 | if (128 > c) {
20 | chars.push(String.fromCharCode(c));
21 | offset += 1;
22 | } else if (191 < c && c < 224) {
23 | chars.push(String.fromCharCode(((c & 31) << 6) | (c2 & 63)));
24 | offset += 2;
25 | } else {
26 | chars.push(
27 | String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63))
28 | );
29 | offset += 3;
30 | }
31 | }
32 |
33 | return chars.join("");
34 | }
35 | /**
36 | * 用用于将字符串编码为UTF-8字节数组
37 | * @param {*} str 输入字符串
38 | * @returns 编码后的字节数组
39 | */
40 | export function utf8Encode(str: string) {
41 | const bytes = [];
42 | let offset = 0;
43 | let char;
44 |
45 | str = encodeURI(str);
46 | const length = str.length;
47 |
48 | while (offset < length) {
49 | char = str[offset];
50 | offset += 1;
51 |
52 | if ("%" !== char) {
53 | bytes.push(char.charCodeAt(0));
54 | } else {
55 | char = str[offset] + str[offset + 1];
56 | bytes.push(parseInt(char, 16));
57 | offset += 2;
58 | }
59 | }
60 |
61 | return bytes;
62 | }
63 |
--------------------------------------------------------------------------------
/src/routes.tsx:
--------------------------------------------------------------------------------
1 | import React, { Navigate, RouteObject } from "react-router-dom";
2 | import { lazy } from "react";
3 | const Encryption = lazy(() => import("./pages/encryption"));
4 | const Steganography = lazy(() => import("./pages/steganography"));
5 |
6 | export type CustomRouteObject = RouteObject & {
7 | name?: string;
8 | description?: string;
9 | children?: CustomRouteObject[];
10 | };
11 | const routes: CustomRouteObject[] = [
12 | {
13 | name: "图像加密",
14 | path: "/encryption",
15 | description:
16 | "对图像进行批量加密处理, 请选择对应算法、上传图片、输入密钥、点击开始按钮进行操作\r\n请注意已加密图像不抗压缩攻击, 请勿进行有损压缩\r\n图像格式是否可用取决于浏览器支持",
17 | element:
220 |
282 |
221 |
232 |
222 |
231 |
233 |
244 |
234 |
243 |
245 |
281 |
246 |
251 |
252 |
257 |
280 |
258 |
259 | {processMessage}
260 |
261 |
268 |
274 |
279 |