From 7ef4e6d814d8df0a168060c12f26b66a2b5c7a5a Mon Sep 17 00:00:00 2001
From: Mikhail Pakhomov <mikhan333@mail.ru>
Date: Mon, 9 Mar 2020 15:36:00 +0300
Subject: [PATCH 01/38] Add library for aes

---
 package-lock.json | 5 +++++
 package.json      | 1 +
 2 files changed, 6 insertions(+)

diff --git a/package-lock.json b/package-lock.json
index c0ac6a6..c0f1c40 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -5296,6 +5296,11 @@
         }
       }
     },
+    "aes-js": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/aes-js/-/aes-js-3.1.2.tgz",
+      "integrity": "sha512-e5pEa2kBnBOgR4Y/p20pskXI74UEz7de8ZGVo58asOtvSVG5YAbJeELPZxOmt+Bnz3rX753YKhfIn4X4l1PPRQ=="
+    },
     "aggregate-error": {
       "version": "3.0.1",
       "resolved": "https://registry.npmjs.org/aggregate-error/-/aggregate-error-3.0.1.tgz",
diff --git a/package.json b/package.json
index 212d617..f63f940 100644
--- a/package.json
+++ b/package.json
@@ -14,6 +14,7 @@
     "@types/react-dom": "^16.9.5",
     "@types/react-redux": "^7.1.7",
     "@types/react-router-dom": "^5.1.3",
+    "aes-js": "^3.1.2",
     "crc": "^3.8.0",
     "fletcher": "0.0.3",
     "node-sass": "^4.13.1",

From b5e8dea136fc6e40c8accca8e08035315b3fe3c4 Mon Sep 17 00:00:00 2001
From: Mikhail Pakhomov <mikhan333@mail.ru>
Date: Mon, 9 Mar 2020 15:41:19 +0300
Subject: [PATCH 02/38] Add library for SHA

---
 package-lock.json | 5 +++++
 package.json      | 1 +
 2 files changed, 6 insertions(+)

diff --git a/package-lock.json b/package-lock.json
index c0f1c40..9881af8 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -7643,6 +7643,11 @@
         "randomfill": "^1.0.3"
       }
     },
+    "crypto-js": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/crypto-js/-/crypto-js-4.0.0.tgz",
+      "integrity": "sha512-bzHZN8Pn+gS7DQA6n+iUmBfl0hO5DJq++QP3U6uTucDtk/0iGpXd/Gg7CGR0p8tJhofJyaKoWBuJI4eAO00BBg=="
+    },
     "css": {
       "version": "2.2.4",
       "resolved": "https://registry.npmjs.org/css/-/css-2.2.4.tgz",
diff --git a/package.json b/package.json
index f63f940..df3df81 100644
--- a/package.json
+++ b/package.json
@@ -16,6 +16,7 @@
     "@types/react-router-dom": "^5.1.3",
     "aes-js": "^3.1.2",
     "crc": "^3.8.0",
+    "crypto-js": "^4.0.0",
     "fletcher": "0.0.3",
     "node-sass": "^4.13.1",
     "react": "^16.12.0",

From d6f835eb84697e1f33800c65cecf93a64339ea9f Mon Sep 17 00:00:00 2001
From: Mikhail Pakhomov <mikhan333@mail.ru>
Date: Thu, 12 Mar 2020 15:43:34 +0300
Subject: [PATCH 03/38] Start hashing and aes

---
 src/App.tsx                            |  2 +
 src/config.ts                          |  2 +-
 src/containers/Checksum/Checksum.tsx   |  5 +-
 src/containers/Hashing/Hashing.tsx     | 88 ++++++++++++++++++++++++++
 src/containers/Hashing/index.ts        |  1 +
 src/containers/Home/Home.tsx           |  2 +-
 src/libmethods/checksum/crc16/index.ts | 10 +--
 src/libmethods/checksum/index.ts       |  1 +
 src/libmethods/hashing/index.ts        | 25 ++++++++
 src/libmethods/hashing/sha256/index.ts |  7 ++
 src/libmethods/index.ts                | 12 ++++
 src/react-app-env.d.ts                 |  4 ++
 12 files changed, 151 insertions(+), 8 deletions(-)
 create mode 100644 src/containers/Hashing/Hashing.tsx
 create mode 100644 src/containers/Hashing/index.ts
 create mode 100644 src/libmethods/hashing/index.ts
 create mode 100644 src/libmethods/hashing/sha256/index.ts

diff --git a/src/App.tsx b/src/App.tsx
index 53d32a3..a7036b3 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -9,6 +9,7 @@ import { Home } from 'containers/Home';
 import { Encrypt } from 'containers/Encrypt';
 import { Decrypt } from 'containers/Decrypt';
 import { Checksum } from 'containers/Checksum';
+import { Hashing } from 'containers/Hashing';
 import { NotFound } from 'containers/NotFound';
 
 const App = () => {
@@ -21,6 +22,7 @@ const App = () => {
           <Route path="/encrypt/" component={Encrypt} />
           <Route path="/decrypt/" component={Decrypt} />
           <Route path="/checksum/" component={Checksum} />
+          <Route path="/hash/" component={Hashing} />
           <Route path="*" component={NotFound} />
         </Switch>
       </Content>
diff --git a/src/config.ts b/src/config.ts
index 481fd3e..b9c9c5b 100644
--- a/src/config.ts
+++ b/src/config.ts
@@ -6,5 +6,5 @@ export const links = [
   { title: 'Зашифровать', href: '/encrypt/', isActive: true },
   { title: 'Расшифровать', href: '/decrypt/', isActive: true },
   { title: 'Посчитать контрольную сумму', href: '/checksum/', isActive: true },
-  { title: 'Хешировать', href: '/hash/', isActive: false },
+  { title: 'Хешировать', href: '/hash/', isActive: true },
 ];
diff --git a/src/containers/Checksum/Checksum.tsx b/src/containers/Checksum/Checksum.tsx
index 009b356..2a2e83b 100644
--- a/src/containers/Checksum/Checksum.tsx
+++ b/src/containers/Checksum/Checksum.tsx
@@ -66,7 +66,10 @@ export default function() {
             <tbody>
               {checksum.map((item, index) => (
                 <tr key={index}>
-                  <td>{item.name}</td>
+                  <td>
+                    {item.name}
+                    {'version' in item ? '/' + item.version : ''}
+                  </td>
                   <td>{item.value}</td>
                 </tr>
               ))}
diff --git a/src/containers/Hashing/Hashing.tsx b/src/containers/Hashing/Hashing.tsx
new file mode 100644
index 0000000..e7df25b
--- /dev/null
+++ b/src/containers/Hashing/Hashing.tsx
@@ -0,0 +1,88 @@
+import * as React from 'react';
+
+import { ContentBox } from 'components/ContentBox';
+import { Alarm } from 'components/Alarm';
+
+import { hashingMethods } from 'libmethods';
+import { calculateHash } from 'libmethods/hashing';
+
+export default function() {
+  const [method, setMethod] = React.useState(hashingMethods[0]);
+  const [text, setText] = React.useState('');
+  const [error, setError] = React.useState('');
+  const [hash, setHash] = React.useState([]);
+
+  const onSubmit = (event: any) => {
+    event.preventDefault();
+    setError('');
+
+    if (text === '') {
+      setError('Введите текст от которого необходимо посчитать хеш!');
+      return;
+    }
+
+    setHash(calculateHash(method, text));
+  };
+
+  return (
+    <>
+      <ContentBox title="Хеширование">
+        <span>1) Выберите метод для подсчета хеша:</span>
+        <select
+          value={method.type}
+          onChange={(event: any) =>
+            setMethod(
+              hashingMethods.find(method => method.type === event.target.value) ||
+                hashingMethods[0],
+            )
+          }
+        >
+          {hashingMethods.map((method, index) => (
+            <option value={method.type} key={index}>
+              {method.name}
+            </option>
+          ))}
+        </select>
+        {/* <span>2) Введите текст для которого требуется найти контрольную сумму:</span>
+        <textarea
+          value={text}
+          placeholder="Ваш текст"
+          onChange={(event: any) => setText(event.target.value)}
+        /> */}
+        <span>2) Введите текст для которого требуется найти контрольную сумму:</span>
+        <textarea
+          value={text}
+          placeholder="Ваш текст"
+          onChange={(event: any) => setText(event.target.value)}
+        />
+        {error && <Alarm type="error" text={`Ошибка! ${error}`} />}
+        <button onClick={onSubmit}>Посчитать контрольную сумму!</button>
+      </ContentBox>
+
+      {!error && checksum && (
+        <ContentBox title="Ваш результат">
+          <span>1) Контрольные суммы:</span>
+          <table>
+            <thead>
+              <tr>
+                <th>Алгоритм</th>
+                <th>Результат</th>
+              </tr>
+            </thead>
+            <tbody>
+              {checksum.map((item, index) => (
+                <tr key={index}>
+                  <td>
+                    {item.name}
+                    {'version' in item ? '/' + item.version : ''}
+                  </td>
+                  <td>{item.value}</td>
+                </tr>
+              ))}
+            </tbody>
+          </table>
+        </ContentBox>
+      )}
+    </>
+  );
+}
diff --git a/src/containers/Hashing/index.ts b/src/containers/Hashing/index.ts
new file mode 100644
index 0000000..d01759b
--- /dev/null
+++ b/src/containers/Hashing/index.ts
@@ -0,0 +1 @@
+export { default as Hashing } from './Hashing';
diff --git a/src/containers/Home/Home.tsx b/src/containers/Home/Home.tsx
index 34eef9a..42a8d43 100644
--- a/src/containers/Home/Home.tsx
+++ b/src/containers/Home/Home.tsx
@@ -35,7 +35,7 @@ export default function() {
       <span className={styles['text']}>
         Скоро появится
         <div className={styles['tag']}>
-          <Tag link={{ title: 'хеширование', href: '/hash/', isActive: false }} />
+          <Tag link={{ title: 'хеширование', href: '/hash/', isActive: true }} />
         </div>
         .
       </span>
diff --git a/src/libmethods/checksum/crc16/index.ts b/src/libmethods/checksum/crc16/index.ts
index e34986f..13c79fd 100644
--- a/src/libmethods/checksum/crc16/index.ts
+++ b/src/libmethods/checksum/crc16/index.ts
@@ -23,10 +23,10 @@ function getCRC16_XMODEM(text: string): number {
 
 export function getCRC16(text: string): TypesCheckSum[] {
   return [
-    { name: 'CRC-16/ARC', value: getCRC16_ARC(text) },
-    { name: 'CRC-16/CCITT-FALSE', value: getCRC16_CCITT_FALSE(text) },
-    { name: 'CRC-16/KERMIT', value: getCRC16_KERMIT(text) },
-    { name: 'CRC-16/MODBUS', value: getCRC16_MODBUS(text) },
-    { name: 'CRC-16/XMODEM', value: getCRC16_XMODEM(text) },
+    { name: 'CRC-16', version: 'ARC', value: getCRC16_ARC(text) },
+    { name: 'CRC-16', version: 'CCITT-FALSE', value: getCRC16_CCITT_FALSE(text) },
+    { name: 'CRC-16', version: 'KERMIT', value: getCRC16_KERMIT(text) },
+    { name: 'CRC-16', version: 'MODBUS', value: getCRC16_MODBUS(text) },
+    { name: 'CRC-16', version: 'XMODEM', value: getCRC16_XMODEM(text) },
   ];
 }
diff --git a/src/libmethods/checksum/index.ts b/src/libmethods/checksum/index.ts
index 98e3972..7d428fc 100644
--- a/src/libmethods/checksum/index.ts
+++ b/src/libmethods/checksum/index.ts
@@ -9,6 +9,7 @@ import { getFletcher } from 'libmethods/checksum/fletcher';
 
 export interface TypesCheckSum {
   name: string;
+  version?: string;
   value: number;
 }
 
diff --git a/src/libmethods/hashing/index.ts b/src/libmethods/hashing/index.ts
new file mode 100644
index 0000000..e9e7c11
--- /dev/null
+++ b/src/libmethods/hashing/index.ts
@@ -0,0 +1,25 @@
+import { Method } from 'store';
+
+import { hashingTypes } from 'libmethods';
+import { getSHA256 } from 'libmethods/hashing/sha256';
+// import { getSHA512 } from 'libmethods/hashing/sha512';
+
+export function calculateHash(method: Method, text: string, key: string): number[] {
+  let hash: number[];
+
+  switch (method.type) {
+    case hashingTypes.sha256:
+      hash = getSHA256(text, key);
+      break;
+    // case hashingTypes.sha512:
+    //   hash = getSHA512(text);
+    //   break;
+    // case hashingTypes.sha3:
+    //   hash = getSHA3(text);
+    //   break;
+    default:
+      hash = [];
+  }
+
+  return hash;
+}
diff --git a/src/libmethods/hashing/sha256/index.ts b/src/libmethods/hashing/sha256/index.ts
new file mode 100644
index 0000000..8a37b26
--- /dev/null
+++ b/src/libmethods/hashing/sha256/index.ts
@@ -0,0 +1,7 @@
+import { sha256 } from 'crypto-js/sha256';
+
+export function getSHA256(text: string): number[] {
+  // let a = sha256('message');
+  return [1, 2];
+  //   return [{ name: 'CRC-24', value: (text) }];
+}
diff --git a/src/libmethods/index.ts b/src/libmethods/index.ts
index d929a52..91494b5 100644
--- a/src/libmethods/index.ts
+++ b/src/libmethods/index.ts
@@ -28,6 +28,18 @@ export const checksumMethods: Method[] = [
   { type: checksumTypes.fletcher, name: 'Флетчер' },
 ];
 
+export const hashingTypes = {
+  sha256: 'sha256',
+  sha512: 'sha512',
+  sha3: 'sha3',
+};
+
+export const hashingMethods: Method[] = [
+  { type: hashingTypes.sha256, name: 'SHA256' },
+  { type: hashingTypes.sha512, name: 'SHA512' },
+  { type: hashingTypes.sha3, name: 'SHA3' },
+];
+
 /**
  * Since Javascript has two-character representation for Emoji
  * then a method for obtaining real unicode codes is needed
diff --git a/src/react-app-env.d.ts b/src/react-app-env.d.ts
index e23adb4..3186f3a 100644
--- a/src/react-app-env.d.ts
+++ b/src/react-app-env.d.ts
@@ -2,3 +2,7 @@
 
 declare module 'crc';
 declare module 'fletcher';
+declare module 'crypto-js/sha256';
+declare module 'crypto-js/sha512';
+// declare module 'crypto-js/sha3';
+// declare module 'aes-js';

From 70c01490988be16ac09cc4b074e8ed5aa13eb0a6 Mon Sep 17 00:00:00 2001
From: Denis Stasyev <denisstasyev@gmail.com>
Date: Thu, 12 Mar 2020 16:30:50 +0300
Subject: [PATCH 04/38] Finish hashing: sha256, sha512, sha3

---
 src/components/Alarm/alarm.module.scss |  2 ++
 src/containers/Hashing/Hashing.tsx     | 38 ++++++--------------------
 src/libmethods/hashing/index.ts        | 20 ++++++++------
 src/libmethods/hashing/sha256/index.ts |  6 ++--
 src/libmethods/hashing/sha3/index.ts   |  5 ++++
 src/libmethods/hashing/sha512/index.ts |  5 ++++
 src/react-app-env.d.ts                 |  2 +-
 7 files changed, 34 insertions(+), 44 deletions(-)
 create mode 100644 src/libmethods/hashing/sha3/index.ts
 create mode 100644 src/libmethods/hashing/sha512/index.ts

diff --git a/src/components/Alarm/alarm.module.scss b/src/components/Alarm/alarm.module.scss
index 466ca10..832673a 100644
--- a/src/components/Alarm/alarm.module.scss
+++ b/src/components/Alarm/alarm.module.scss
@@ -27,6 +27,8 @@
 
   animation: appear $animation 0.5s forwards;
   //   -webkit-animation: appear $animation 0.5s forwards;
+
+  text-align: center;
 }
 
 .alarm-news {
diff --git a/src/containers/Hashing/Hashing.tsx b/src/containers/Hashing/Hashing.tsx
index e7df25b..1991c5b 100644
--- a/src/containers/Hashing/Hashing.tsx
+++ b/src/containers/Hashing/Hashing.tsx
@@ -10,7 +10,7 @@ export default function() {
   const [method, setMethod] = React.useState(hashingMethods[0]);
   const [text, setText] = React.useState('');
   const [error, setError] = React.useState('');
-  const [hash, setHash] = React.useState([]);
+  const [hash, setHash] = React.useState<number[]>([]);
 
   const onSubmit = (event: any) => {
     event.preventDefault();
@@ -43,44 +43,22 @@ export default function() {
             </option>
           ))}
         </select>
-        {/* <span>2) Введите текст для которого требуется найти контрольную сумму:</span>
-        <textarea
-          value={text}
-          placeholder="Ваш текст"
-          onChange={(event: any) => setText(event.target.value)}
-        /> */}
-        <span>2) Введите текст для которого требуется найти контрольную сумму:</span>
+        <span>2) Введите текст для которого требуется найти хеш:</span>
         <textarea
           value={text}
           placeholder="Ваш текст"
           onChange={(event: any) => setText(event.target.value)}
         />
         {error && <Alarm type="error" text={`Ошибка! ${error}`} />}
-        <button onClick={onSubmit}>Посчитать контрольную сумму!</button>
+        <button onClick={onSubmit}>Посчитать хеш!</button>
       </ContentBox>
 
-      {!error && checksum && (
+      {!error && hash.length !== 0 && (
         <ContentBox title="Ваш результат">
-          <span>1) Контрольные суммы:</span>
-          <table>
-            <thead>
-              <tr>
-                <th>Алгоритм</th>
-                <th>Результат</th>
-              </tr>
-            </thead>
-            <tbody>
-              {checksum.map((item, index) => (
-                <tr key={index}>
-                  <td>
-                    {item.name}
-                    {'version' in item ? '/' + item.version : ''}
-                  </td>
-                  <td>{item.value}</td>
-                </tr>
-              ))}
-            </tbody>
-          </table>
+          <span>1) Вычисленный хеш:</span>
+          <output>
+            <pre>[{hash.join(',\n')}]</pre>
+          </output>
         </ContentBox>
       )}
     </>
diff --git a/src/libmethods/hashing/index.ts b/src/libmethods/hashing/index.ts
index e9e7c11..90662d0 100644
--- a/src/libmethods/hashing/index.ts
+++ b/src/libmethods/hashing/index.ts
@@ -1,22 +1,24 @@
 import { Method } from 'store';
 
 import { hashingTypes } from 'libmethods';
+
 import { getSHA256 } from 'libmethods/hashing/sha256';
-// import { getSHA512 } from 'libmethods/hashing/sha512';
+import { getSHA512 } from 'libmethods/hashing/sha512';
+import { getSHA3 } from 'libmethods/hashing/sha3';
 
-export function calculateHash(method: Method, text: string, key: string): number[] {
+export function calculateHash(method: Method, text: string): number[] {
   let hash: number[];
 
   switch (method.type) {
     case hashingTypes.sha256:
-      hash = getSHA256(text, key);
+      hash = getSHA256(text);
+      break;
+    case hashingTypes.sha512:
+      hash = getSHA512(text);
+      break;
+    case hashingTypes.sha3:
+      hash = getSHA3(text);
       break;
-    // case hashingTypes.sha512:
-    //   hash = getSHA512(text);
-    //   break;
-    // case hashingTypes.sha3:
-    //   hash = getSHA3(text);
-    //   break;
     default:
       hash = [];
   }
diff --git a/src/libmethods/hashing/sha256/index.ts b/src/libmethods/hashing/sha256/index.ts
index 8a37b26..4875ec9 100644
--- a/src/libmethods/hashing/sha256/index.ts
+++ b/src/libmethods/hashing/sha256/index.ts
@@ -1,7 +1,5 @@
-import { sha256 } from 'crypto-js/sha256';
+import sha256 from 'crypto-js/sha256';
 
 export function getSHA256(text: string): number[] {
-  // let a = sha256('message');
-  return [1, 2];
-  //   return [{ name: 'CRC-24', value: (text) }];
+  return sha256(text).words;
 }
diff --git a/src/libmethods/hashing/sha3/index.ts b/src/libmethods/hashing/sha3/index.ts
new file mode 100644
index 0000000..52f2a63
--- /dev/null
+++ b/src/libmethods/hashing/sha3/index.ts
@@ -0,0 +1,5 @@
+import sha3 from 'crypto-js/sha3';
+
+export function getSHA3(text: string): number[] {
+  return sha3(text).words;
+}
diff --git a/src/libmethods/hashing/sha512/index.ts b/src/libmethods/hashing/sha512/index.ts
new file mode 100644
index 0000000..15cbd9e
--- /dev/null
+++ b/src/libmethods/hashing/sha512/index.ts
@@ -0,0 +1,5 @@
+import sha512 from 'crypto-js/sha512';
+
+export function getSHA512(text: string): number[] {
+  return sha512(text).words;
+}
diff --git a/src/react-app-env.d.ts b/src/react-app-env.d.ts
index 3186f3a..1ef3c3a 100644
--- a/src/react-app-env.d.ts
+++ b/src/react-app-env.d.ts
@@ -4,5 +4,5 @@ declare module 'crc';
 declare module 'fletcher';
 declare module 'crypto-js/sha256';
 declare module 'crypto-js/sha512';
-// declare module 'crypto-js/sha3';
+declare module 'crypto-js/sha3';
 // declare module 'aes-js';

From 88a651af6ea1dc18ce6c8570196905d44660c306 Mon Sep 17 00:00:00 2001
From: Mikhail Pakhomov <mikhan333@mail.ru>
Date: Thu, 12 Mar 2020 17:35:53 +0300
Subject: [PATCH 05/38] Fix sha256

---
 src/containers/Hashing/Hashing.tsx     |  4 ++--
 src/libmethods/hashing/index.ts        | 15 +++++++++++++--
 src/libmethods/hashing/sha256/index.ts |  3 ++-
 3 files changed, 17 insertions(+), 5 deletions(-)

diff --git a/src/containers/Hashing/Hashing.tsx b/src/containers/Hashing/Hashing.tsx
index 1991c5b..91b94ed 100644
--- a/src/containers/Hashing/Hashing.tsx
+++ b/src/containers/Hashing/Hashing.tsx
@@ -10,7 +10,7 @@ export default function() {
   const [method, setMethod] = React.useState(hashingMethods[0]);
   const [text, setText] = React.useState('');
   const [error, setError] = React.useState('');
-  const [hash, setHash] = React.useState<number[]>([]);
+  const [hash, setHash] = React.useState('');
 
   const onSubmit = (event: any) => {
     event.preventDefault();
@@ -57,7 +57,7 @@ export default function() {
         <ContentBox title="Ваш результат">
           <span>1) Вычисленный хеш:</span>
           <output>
-            <pre>[{hash.join(',\n')}]</pre>
+            <pre>{hash}</pre>
           </output>
         </ContentBox>
       )}
diff --git a/src/libmethods/hashing/index.ts b/src/libmethods/hashing/index.ts
index 90662d0..18d8e36 100644
--- a/src/libmethods/hashing/index.ts
+++ b/src/libmethods/hashing/index.ts
@@ -6,7 +6,18 @@ import { getSHA256 } from 'libmethods/hashing/sha256';
 import { getSHA512 } from 'libmethods/hashing/sha512';
 import { getSHA3 } from 'libmethods/hashing/sha3';
 
-export function calculateHash(method: Method, text: string): number[] {
+// let hash: string = sha256(text).words.map((elem: number) => ((2**32 - elem) % 2**32).toString(16)).concat();
+
+const LENGTH_OF_ELEMENT_HASHING = 2 ** 32;
+export function toPositiveNumbers(mas: number[]): number[] {
+  return mas.map((elem: number) => (LENGTH_OF_ELEMENT_HASHING + elem) % LENGTH_OF_ELEMENT_HASHING);
+}
+
+export function toHexFormat(mas: number[]): string {
+  return mas.reduce((hexString: string, elem: number) => hexString + elem.toString(16), '');
+}
+
+export function calculateHash(method: Method, text: string): string {
   let hash: number[];
 
   switch (method.type) {
@@ -23,5 +34,5 @@ export function calculateHash(method: Method, text: string): number[] {
       hash = [];
   }
 
-  return hash;
+  return toHexFormat(hash);
 }
diff --git a/src/libmethods/hashing/sha256/index.ts b/src/libmethods/hashing/sha256/index.ts
index 4875ec9..b05c99a 100644
--- a/src/libmethods/hashing/sha256/index.ts
+++ b/src/libmethods/hashing/sha256/index.ts
@@ -1,5 +1,6 @@
 import sha256 from 'crypto-js/sha256';
+import { toPositiveNumbers } from 'libmethods/hashing';
 
 export function getSHA256(text: string): number[] {
-  return sha256(text).words;
+  return toPositiveNumbers(sha256(text).words);
 }

From 6ecd6ebb2b2040737300ea71d021f11c004d450d Mon Sep 17 00:00:00 2001
From: Mikhail Pakhomov <mikhan333@mail.ru>
Date: Thu, 12 Mar 2020 17:40:25 +0300
Subject: [PATCH 06/38] Fix sha256 and sha3

---
 src/libmethods/hashing/index.ts        | 2 --
 src/libmethods/hashing/sha3/index.ts   | 3 ++-
 src/libmethods/hashing/sha512/index.ts | 3 ++-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/libmethods/hashing/index.ts b/src/libmethods/hashing/index.ts
index 18d8e36..d7df256 100644
--- a/src/libmethods/hashing/index.ts
+++ b/src/libmethods/hashing/index.ts
@@ -6,8 +6,6 @@ import { getSHA256 } from 'libmethods/hashing/sha256';
 import { getSHA512 } from 'libmethods/hashing/sha512';
 import { getSHA3 } from 'libmethods/hashing/sha3';
 
-// let hash: string = sha256(text).words.map((elem: number) => ((2**32 - elem) % 2**32).toString(16)).concat();
-
 const LENGTH_OF_ELEMENT_HASHING = 2 ** 32;
 export function toPositiveNumbers(mas: number[]): number[] {
   return mas.map((elem: number) => (LENGTH_OF_ELEMENT_HASHING + elem) % LENGTH_OF_ELEMENT_HASHING);
diff --git a/src/libmethods/hashing/sha3/index.ts b/src/libmethods/hashing/sha3/index.ts
index 52f2a63..763b929 100644
--- a/src/libmethods/hashing/sha3/index.ts
+++ b/src/libmethods/hashing/sha3/index.ts
@@ -1,5 +1,6 @@
 import sha3 from 'crypto-js/sha3';
+import { toPositiveNumbers } from 'libmethods/hashing';
 
 export function getSHA3(text: string): number[] {
-  return sha3(text).words;
+  return toPositiveNumbers(sha3(text).words);
 }
diff --git a/src/libmethods/hashing/sha512/index.ts b/src/libmethods/hashing/sha512/index.ts
index 15cbd9e..8a3c768 100644
--- a/src/libmethods/hashing/sha512/index.ts
+++ b/src/libmethods/hashing/sha512/index.ts
@@ -1,5 +1,6 @@
 import sha512 from 'crypto-js/sha512';
+import { toPositiveNumbers } from 'libmethods/hashing';
 
 export function getSHA512(text: string): number[] {
-  return sha512(text).words;
+  return toPositiveNumbers(sha512(text).words);
 }

From 84dc338a7eaec02791c1c5dc42301da832abaa4e Mon Sep 17 00:00:00 2001
From: Denis Stasyev <denisstasyev@gmail.com>
Date: Thu, 12 Mar 2020 18:03:56 +0300
Subject: [PATCH 07/38] Fix Home

---
 src/containers/Home/Home.tsx         | 38 ++++++++++------------------
 src/containers/Home/home.module.scss |  8 +-----
 2 files changed, 14 insertions(+), 32 deletions(-)

diff --git a/src/containers/Home/Home.tsx b/src/containers/Home/Home.tsx
index 42a8d43..dc389c0 100644
--- a/src/containers/Home/Home.tsx
+++ b/src/containers/Home/Home.tsx
@@ -6,6 +6,8 @@ import { ContentBox } from 'components/ContentBox';
 import { Alarm } from 'components/Alarm';
 import { Tag } from 'components/Tag';
 
+import { links } from 'config';
+
 export default function() {
   return (
     <ContentBox title={`Добро пожаловать на спецпроект "Шифровальщик"!`}>
@@ -14,31 +16,17 @@ export default function() {
         text="Теперь у нас вы можете использовать Emoji в качестве ключей шифрования &#128522;!"
       />
       <br />
-      <span className={styles['text']}>
-        Сейчас вы можете
-        <div className={styles['tag']}>
-          <Tag link={{ title: 'зашифровать', href: '/encrypt/', isActive: true }} />
-        </div>
-        и
-        <div className={styles['tag']}>
-          <Tag link={{ title: 'расшифровать', href: '/decrypt/', isActive: true }} />
-        </div>
-        сообщение, а также
-        <div className={styles['tag']}>
-          <Tag
-            link={{ title: 'посчитать контрольную сумму', href: '/checksum/', isActive: true }}
-          />
-        </div>
-        для него.
-      </span>
-      <br />
-      <span className={styles['text']}>
-        Скоро появится
-        <div className={styles['tag']}>
-          <Tag link={{ title: 'хеширование', href: '/hash/', isActive: true }} />
-        </div>
-        .
-      </span>
+      <span>Сейчас вы можете на нашем сайте:</span>
+      <ul>
+        {links.map((link, index) => (
+          <li key={index}>
+            <div className={styles['tag']}>
+              <Tag link={link} />
+            </div>
+          </li>
+        ))}
+      </ul>
+      <span>сообщения.</span>
     </ContentBox>
   );
 }
diff --git a/src/containers/Home/home.module.scss b/src/containers/Home/home.module.scss
index c1797bd..697974e 100644
--- a/src/containers/Home/home.module.scss
+++ b/src/containers/Home/home.module.scss
@@ -1,12 +1,6 @@
 @import 'styles/_mods.scss';
 
-.text {
-  display: inline-flex;
-  flex-direction: row;
-  flex-wrap: wrap;
-  align-items: center;
-}
-
 .tag {
+  display: inline-block;
   margin: $x1;
 }

From ab75725edc9847d0625c854abd578493cb5be421 Mon Sep 17 00:00:00 2001
From: Denis Stasyev <denisstasyev@gmail.com>
Date: Thu, 12 Mar 2020 18:43:58 +0300
Subject: [PATCH 08/38] Add JSON output for Checksum

---
 src/config.ts                             |  6 +++++-
 src/containers/Checksum/Checksum.tsx      | 16 ++++++++++++++++
 src/containers/Decrypt/Decrypt.tsx        |  6 +++---
 src/containers/Encrypt/Encrypt.tsx        |  4 ++--
 src/libmethods/checksum/crc16/index.ts    |  2 +-
 src/libmethods/checksum/fletcher/index.ts |  2 +-
 6 files changed, 28 insertions(+), 8 deletions(-)

diff --git a/src/config.ts b/src/config.ts
index b9c9c5b..a4efcad 100644
--- a/src/config.ts
+++ b/src/config.ts
@@ -1,7 +1,11 @@
-export const CIPHER_ALGORITHM = 'cipher_algorithm';
+export const CIPHER_METHOD = 'cipher_algorithm';
 // export const ENCRYPTED_DATA_CODES = 'encrypted_data_codes';
 export const ENCRYPTED_DATA = 'encrypted_data';
 
+export const CHECKSUM_METHOD = 'checksum_algorithm';
+export const CHECKSUM_TEXT = 'checksum_text';
+export const CHECKSUM_VALUE = 'checksum_value';
+
 export const links = [
   { title: 'Зашифровать', href: '/encrypt/', isActive: true },
   { title: 'Расшифровать', href: '/decrypt/', isActive: true },
diff --git a/src/containers/Checksum/Checksum.tsx b/src/containers/Checksum/Checksum.tsx
index 2a2e83b..b734b8a 100644
--- a/src/containers/Checksum/Checksum.tsx
+++ b/src/containers/Checksum/Checksum.tsx
@@ -3,6 +3,8 @@ import * as React from 'react';
 import { ContentBox } from 'components/ContentBox';
 import { Alarm } from 'components/Alarm';
 
+import { CHECKSUM_METHOD, CHECKSUM_TEXT, CHECKSUM_VALUE } from 'config';
+
 import { checksumMethods } from 'libmethods';
 import { countChecksum, TypesCheckSum } from 'libmethods/checksum';
 
@@ -24,6 +26,16 @@ export default function() {
     setChecksum(countChecksum(method, text));
   };
 
+  const getJSON = (method: TypesCheckSum, text: string) => {
+    const methodName = `${method.name}${'version' in method ? '/' + method.version : ''}`;
+    let json = {
+      [CHECKSUM_METHOD]: methodName,
+      [CHECKSUM_TEXT]: text,
+      [CHECKSUM_VALUE]: method.value,
+    };
+    return JSON.stringify(json, undefined, 2);
+  };
+
   return (
     <>
       <ContentBox title="Контрольная сумма">
@@ -75,6 +87,10 @@ export default function() {
               ))}
             </tbody>
           </table>
+          <span>2) JSON для отправки на сервер контрольных сумм:</span>
+          <output>
+            <pre>{getJSON(checksum[0], text)}</pre>
+          </output>
         </ContentBox>
       )}
     </>
diff --git a/src/containers/Decrypt/Decrypt.tsx b/src/containers/Decrypt/Decrypt.tsx
index 16f994d..5f52b10 100644
--- a/src/containers/Decrypt/Decrypt.tsx
+++ b/src/containers/Decrypt/Decrypt.tsx
@@ -4,7 +4,7 @@ import { connect } from 'react-redux';
 import { ContentBox } from 'components/ContentBox';
 import { Alarm } from 'components/Alarm';
 
-import { CIPHER_ALGORITHM, ENCRYPTED_DATA } from 'config';
+import { CIPHER_METHOD, ENCRYPTED_DATA } from 'config';
 
 import { AppState, Method } from 'store';
 import { DecryptState } from 'store/decrypt/types';
@@ -92,7 +92,7 @@ const Decrypt: React.SFC<DecryptStateProps> = props => {
 
     const methodName =
       // @ts-ignore
-      objectJSON[CIPHER_ALGORITHM] === undefined ? '' : objectJSON[CIPHER_ALGORITHM];
+      objectJSON[CIPHER_METHOD] === undefined ? '' : objectJSON[CIPHER_METHOD];
     const method: Method = encryptionMethods.find(method => method.name === methodName) || {
       name: '',
       type: '',
@@ -114,7 +114,7 @@ const Decrypt: React.SFC<DecryptStateProps> = props => {
     }
 
     if (props.method.name === '') {
-      props.setError(`Введите метод шифрования в JSON (свойство: ${CIPHER_ALGORITHM})!`);
+      props.setError(`Введите метод шифрования в JSON (свойство: ${CIPHER_METHOD})!`);
       return;
     }
 
diff --git a/src/containers/Encrypt/Encrypt.tsx b/src/containers/Encrypt/Encrypt.tsx
index bd2c934..689ec46 100644
--- a/src/containers/Encrypt/Encrypt.tsx
+++ b/src/containers/Encrypt/Encrypt.tsx
@@ -4,7 +4,7 @@ import { connect } from 'react-redux';
 import { ContentBox } from 'components/ContentBox';
 import { Alarm } from 'components/Alarm';
 
-import { CIPHER_ALGORITHM, ENCRYPTED_DATA } from 'config';
+import { CIPHER_METHOD, ENCRYPTED_DATA } from 'config';
 
 import { AppState, Method } from 'store';
 import { EncryptState } from 'store/encrypt/types';
@@ -77,7 +77,7 @@ const Encrypt: React.SFC<EncryptStateProps> = props => {
 
   const getJSON = (methodName: string, encryptedCode: number[], encryptedText: string) => {
     let json = {
-      [CIPHER_ALGORITHM]: methodName,
+      [CIPHER_METHOD]: methodName,
       // [ENCRYPTED_DATA_CODES]: encryptedCode,
       [ENCRYPTED_DATA]: encryptedText,
     };
diff --git a/src/libmethods/checksum/crc16/index.ts b/src/libmethods/checksum/crc16/index.ts
index 13c79fd..f5cd560 100644
--- a/src/libmethods/checksum/crc16/index.ts
+++ b/src/libmethods/checksum/crc16/index.ts
@@ -23,10 +23,10 @@ function getCRC16_XMODEM(text: string): number {
 
 export function getCRC16(text: string): TypesCheckSum[] {
   return [
+    { name: 'CRC-16', version: 'MODBUS', value: getCRC16_MODBUS(text) },
     { name: 'CRC-16', version: 'ARC', value: getCRC16_ARC(text) },
     { name: 'CRC-16', version: 'CCITT-FALSE', value: getCRC16_CCITT_FALSE(text) },
     { name: 'CRC-16', version: 'KERMIT', value: getCRC16_KERMIT(text) },
-    { name: 'CRC-16', version: 'MODBUS', value: getCRC16_MODBUS(text) },
     { name: 'CRC-16', version: 'XMODEM', value: getCRC16_XMODEM(text) },
   ];
 }
diff --git a/src/libmethods/checksum/fletcher/index.ts b/src/libmethods/checksum/fletcher/index.ts
index 9f4d1a9..1bb1e42 100644
--- a/src/libmethods/checksum/fletcher/index.ts
+++ b/src/libmethods/checksum/fletcher/index.ts
@@ -5,7 +5,7 @@ import { getUnicodeCode } from 'libmethods';
 export function getFletcher(text: string): TypesCheckSum[] {
   return [
     {
-      name: 'Fletcher',
+      name: 'Флетчер',
       value: fletcher16(Buffer.from(Array.from(text).map(value => getUnicodeCode(value)))),
     },
   ];

From 39e3a748908b42ee15f88d09791d1980b876c651 Mon Sep 17 00:00:00 2001
From: Denis Stasyev <denisstasyev@gmail.com>
Date: Thu, 12 Mar 2020 19:05:18 +0300
Subject: [PATCH 09/38] Add JSON for Hashing and textarea outputs

---
 src/components/Header/header.module.scss |  2 +-
 src/config.ts                            |  3 +++
 src/containers/Checksum/Checksum.tsx     |  4 +---
 src/containers/Decrypt/Decrypt.tsx       |  4 +---
 src/containers/Encrypt/Encrypt.tsx       | 13 +++++--------
 src/containers/Hashing/Hashing.tsx       | 20 ++++++++++++++++----
 src/styles/_global.scss                  |  4 ++--
 7 files changed, 29 insertions(+), 21 deletions(-)

diff --git a/src/components/Header/header.module.scss b/src/components/Header/header.module.scss
index ba542da..195f5a7 100644
--- a/src/components/Header/header.module.scss
+++ b/src/components/Header/header.module.scss
@@ -76,7 +76,7 @@ $header-height: $x20;
 
 .text {
   margin-left: $x3;
-  height: 52px;
+  height: 45px;
 
   white-space: nowrap;
 }
diff --git a/src/config.ts b/src/config.ts
index a4efcad..7e3f92e 100644
--- a/src/config.ts
+++ b/src/config.ts
@@ -6,6 +6,9 @@ export const CHECKSUM_METHOD = 'checksum_algorithm';
 export const CHECKSUM_TEXT = 'checksum_text';
 export const CHECKSUM_VALUE = 'checksum_value';
 
+export const HASH_METHOD = 'hash_method';
+export const HASH_VALUE = 'hash_value';
+
 export const links = [
   { title: 'Зашифровать', href: '/encrypt/', isActive: true },
   { title: 'Расшифровать', href: '/decrypt/', isActive: true },
diff --git a/src/containers/Checksum/Checksum.tsx b/src/containers/Checksum/Checksum.tsx
index b734b8a..72341fc 100644
--- a/src/containers/Checksum/Checksum.tsx
+++ b/src/containers/Checksum/Checksum.tsx
@@ -88,9 +88,7 @@ export default function() {
             </tbody>
           </table>
           <span>2) JSON для отправки на сервер контрольных сумм:</span>
-          <output>
-            <pre>{getJSON(checksum[0], text)}</pre>
-          </output>
+          <textarea value={getJSON(checksum[0], text)} onChange={() => {}} />
         </ContentBox>
       )}
     </>
diff --git a/src/containers/Decrypt/Decrypt.tsx b/src/containers/Decrypt/Decrypt.tsx
index 5f52b10..dfaf1c3 100644
--- a/src/containers/Decrypt/Decrypt.tsx
+++ b/src/containers/Decrypt/Decrypt.tsx
@@ -181,9 +181,7 @@ const Decrypt: React.SFC<DecryptStateProps> = props => {
       {!props.errorMessage && props.decryptedData.text && (
         <ContentBox title="Ваш результат">
           <span>1) Открытый текст:</span>
-          <output>
-            <pre>{props.decryptedData.text}</pre>
-          </output>
+          <textarea value={props.decryptedData.text} onChange={() => {}} />
         </ContentBox>
       )}
     </>
diff --git a/src/containers/Encrypt/Encrypt.tsx b/src/containers/Encrypt/Encrypt.tsx
index 689ec46..3661cac 100644
--- a/src/containers/Encrypt/Encrypt.tsx
+++ b/src/containers/Encrypt/Encrypt.tsx
@@ -115,15 +115,12 @@ const Encrypt: React.SFC<EncryptStateProps> = props => {
       {!props.errorMessage && props.encryptedData.text && (
         <ContentBox title="Ваш результат">
           <span>1) Закрытый текст:</span>
-          <output>
-            <pre>{props.encryptedData.text}</pre>
-          </output>
+          <textarea value={props.encryptedData.text} onChange={() => {}} />
           <span>2) JSON для отправки на сервер для расшифрования:</span>
-          <output>
-            <pre>
-              {getJSON(props.method.name, props.encryptedData.code, props.encryptedData.text)}
-            </pre>
-          </output>
+          <textarea
+            value={getJSON(props.method.name, props.encryptedData.code, props.encryptedData.text)}
+            onChange={() => {}}
+          />
         </ContentBox>
       )}
     </>
diff --git a/src/containers/Hashing/Hashing.tsx b/src/containers/Hashing/Hashing.tsx
index 91b94ed..cfb8bb0 100644
--- a/src/containers/Hashing/Hashing.tsx
+++ b/src/containers/Hashing/Hashing.tsx
@@ -3,11 +3,15 @@ import * as React from 'react';
 import { ContentBox } from 'components/ContentBox';
 import { Alarm } from 'components/Alarm';
 
+import { Method } from 'store';
+
+import { HASH_METHOD, HASH_VALUE } from 'config';
+
 import { hashingMethods } from 'libmethods';
 import { calculateHash } from 'libmethods/hashing';
 
 export default function() {
-  const [method, setMethod] = React.useState(hashingMethods[0]);
+  const [method, setMethod] = React.useState<Method>(hashingMethods[0]);
   const [text, setText] = React.useState('');
   const [error, setError] = React.useState('');
   const [hash, setHash] = React.useState('');
@@ -24,6 +28,14 @@ export default function() {
     setHash(calculateHash(method, text));
   };
 
+  const getJSON = (method: Method, hash: string) => {
+    let json = {
+      [HASH_METHOD]: method.name,
+      [HASH_VALUE]: hash,
+    };
+    return JSON.stringify(json, undefined, 2);
+  };
+
   return (
     <>
       <ContentBox title="Хеширование">
@@ -56,9 +68,9 @@ export default function() {
       {!error && hash.length !== 0 && (
         <ContentBox title="Ваш результат">
           <span>1) Вычисленный хеш:</span>
-          <output>
-            <pre>{hash}</pre>
-          </output>
+          <textarea value={hash} onChange={() => {}} />
+          <span>2) JSON для отправки хешей на сервер:</span>
+          <textarea value={getJSON(method, hash)} onChange={() => {}} />
         </ContentBox>
       )}
     </>
diff --git a/src/styles/_global.scss b/src/styles/_global.scss
index aafe5e5..e24a34f 100644
--- a/src/styles/_global.scss
+++ b/src/styles/_global.scss
@@ -28,9 +28,9 @@ a:active {
 span,
 select,
 input,
-textarea,
-output {
+textarea {
   margin-top: $x2;
+  font-size: 1em;
 }
 
 select {

From 4158ac4eb09cfe873dba764061eba0ae3af75e53 Mon Sep 17 00:00:00 2001
From: Denis Stasyev <denisstasyev@gmail.com>
Date: Thu, 12 Mar 2020 19:35:09 +0300
Subject: [PATCH 10/38] Fix styles

---
 src/components/Alarm/alarm.module.scss | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/components/Alarm/alarm.module.scss b/src/components/Alarm/alarm.module.scss
index 832673a..6196449 100644
--- a/src/components/Alarm/alarm.module.scss
+++ b/src/components/Alarm/alarm.module.scss
@@ -27,8 +27,6 @@
 
   animation: appear $animation 0.5s forwards;
   //   -webkit-animation: appear $animation 0.5s forwards;
-
-  text-align: center;
 }
 
 .alarm-news {
@@ -41,4 +39,5 @@
   @extend .alarm;
 
   background-color: lightpink;
+  text-align: center;
 }

From 7a603d7845db38c2ae67e6812907a053a5929a10 Mon Sep 17 00:00:00 2001
From: Mikhail Pakhomov <mikhan333@mail.ru>
Date: Thu, 12 Mar 2020 19:39:56 +0300
Subject: [PATCH 11/38] Add base64 in output

---
 src/config.ts                      |   2 +
 src/containers/Encrypt/Encrypt.tsx |   5 +-
 src/containers/Hashing/Hashing.tsx |   5 +-
 src/utils/base64.js                | 125 +++++++++++++++++++++++++++++
 4 files changed, 135 insertions(+), 2 deletions(-)
 create mode 100644 src/utils/base64.js

diff --git a/src/config.ts b/src/config.ts
index 7e3f92e..c1adb66 100644
--- a/src/config.ts
+++ b/src/config.ts
@@ -1,6 +1,7 @@
 export const CIPHER_METHOD = 'cipher_algorithm';
 // export const ENCRYPTED_DATA_CODES = 'encrypted_data_codes';
 export const ENCRYPTED_DATA = 'encrypted_data';
+export const ENCRYPTED_DATA_BASE64 = 'encrypted_data_base64';
 
 export const CHECKSUM_METHOD = 'checksum_algorithm';
 export const CHECKSUM_TEXT = 'checksum_text';
@@ -8,6 +9,7 @@ export const CHECKSUM_VALUE = 'checksum_value';
 
 export const HASH_METHOD = 'hash_method';
 export const HASH_VALUE = 'hash_value';
+export const HASH_VALUE_BASE64 = 'hash_value_base64';
 
 export const links = [
   { title: 'Зашифровать', href: '/encrypt/', isActive: true },
diff --git a/src/containers/Encrypt/Encrypt.tsx b/src/containers/Encrypt/Encrypt.tsx
index 3661cac..b7b544c 100644
--- a/src/containers/Encrypt/Encrypt.tsx
+++ b/src/containers/Encrypt/Encrypt.tsx
@@ -4,7 +4,7 @@ import { connect } from 'react-redux';
 import { ContentBox } from 'components/ContentBox';
 import { Alarm } from 'components/Alarm';
 
-import { CIPHER_METHOD, ENCRYPTED_DATA } from 'config';
+import { CIPHER_METHOD, ENCRYPTED_DATA, ENCRYPTED_DATA_BASE64 } from 'config';
 
 import { AppState, Method } from 'store';
 import { EncryptState } from 'store/encrypt/types';
@@ -12,6 +12,8 @@ import { setMethod, setKey, setText, setError, encryptData } from 'store/encrypt
 
 import { encryptionMethods, encryptionTypes } from 'libmethods';
 
+import Base64 from 'utils/base64';
+
 interface EncryptStateProps extends EncryptState {
   setMethod: typeof setMethod;
   setText: typeof setText;
@@ -80,6 +82,7 @@ const Encrypt: React.SFC<EncryptStateProps> = props => {
       [CIPHER_METHOD]: methodName,
       // [ENCRYPTED_DATA_CODES]: encryptedCode,
       [ENCRYPTED_DATA]: encryptedText,
+      [ENCRYPTED_DATA_BASE64]: Base64.encode(encryptedText),
     };
     return JSON.stringify(json, undefined, 2);
   };
diff --git a/src/containers/Hashing/Hashing.tsx b/src/containers/Hashing/Hashing.tsx
index cfb8bb0..cea456d 100644
--- a/src/containers/Hashing/Hashing.tsx
+++ b/src/containers/Hashing/Hashing.tsx
@@ -5,11 +5,13 @@ import { Alarm } from 'components/Alarm';
 
 import { Method } from 'store';
 
-import { HASH_METHOD, HASH_VALUE } from 'config';
+import { HASH_METHOD, HASH_VALUE, HASH_VALUE_BASE64 } from 'config';
 
 import { hashingMethods } from 'libmethods';
 import { calculateHash } from 'libmethods/hashing';
 
+import Base64 from 'utils/base64';
+
 export default function() {
   const [method, setMethod] = React.useState<Method>(hashingMethods[0]);
   const [text, setText] = React.useState('');
@@ -32,6 +34,7 @@ export default function() {
     let json = {
       [HASH_METHOD]: method.name,
       [HASH_VALUE]: hash,
+      [HASH_VALUE_BASE64]: Base64.encode(hash),
     };
     return JSON.stringify(json, undefined, 2);
   };
diff --git a/src/utils/base64.js b/src/utils/base64.js
new file mode 100644
index 0000000..6ae955b
--- /dev/null
+++ b/src/utils/base64.js
@@ -0,0 +1,125 @@
+export default {
+  // private property
+  _keyStr: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',
+
+  // public method for encoding
+  encode: function(input) {
+    let output = '';
+    let chr1, chr2, chr3, enc1, enc2, enc3, enc4;
+    let i = 0;
+
+    input = this._utf8_encode(input);
+
+    while (i < input.length) {
+      chr1 = input.charCodeAt(i++);
+      chr2 = input.charCodeAt(i++);
+      chr3 = input.charCodeAt(i++);
+
+      enc1 = chr1 >> 2;
+      enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
+      enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
+      enc4 = chr3 & 63;
+
+      if (isNaN(chr2)) {
+        enc3 = enc4 = 64;
+      } else if (isNaN(chr3)) {
+        enc4 = 64;
+      }
+
+      output =
+        output +
+        this._keyStr.charAt(enc1) +
+        this._keyStr.charAt(enc2) +
+        this._keyStr.charAt(enc3) +
+        this._keyStr.charAt(enc4);
+    }
+
+    return output;
+  },
+
+  // Public method for decoding
+  decode: function(input) {
+    let output = '';
+    let chr1, chr2, chr3;
+    let enc1, enc2, enc3, enc4;
+    let i = 0;
+
+    input = input.replace(/[^A-Za-z0-9+/=]/g, '');
+
+    while (i < input.length) {
+      enc1 = this._keyStr.indexOf(input.charAt(i++));
+      enc2 = this._keyStr.indexOf(input.charAt(i++));
+      enc3 = this._keyStr.indexOf(input.charAt(i++));
+      enc4 = this._keyStr.indexOf(input.charAt(i++));
+
+      chr1 = (enc1 << 2) | (enc2 >> 4);
+      chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
+      chr3 = ((enc3 & 3) << 6) | enc4;
+
+      output = output + String.fromCharCode(chr1);
+
+      if (enc3 !== 64) {
+        output = output + String.fromCharCode(chr2);
+      }
+      if (enc4 !== 64) {
+        output = output + String.fromCharCode(chr3);
+      }
+    }
+
+    output = this._utf8_decode(output);
+
+    return output;
+  },
+
+  // Private method for UTF-8 encoding
+  _utf8_encode: function(string) {
+    string = string.replace(/\r\n/g, '\n');
+    let utftext = '';
+
+    for (let n = 0; n < string.length; n++) {
+      let c = string.charCodeAt(n);
+
+      if (c < 128) {
+        utftext += String.fromCharCode(c);
+      } else if (c > 127 && c < 2048) {
+        utftext += String.fromCharCode((c >> 6) | 192);
+        utftext += String.fromCharCode((c & 63) | 128);
+      } else {
+        utftext += String.fromCharCode((c >> 12) | 224);
+        utftext += String.fromCharCode(((c >> 6) & 63) | 128);
+        utftext += String.fromCharCode((c & 63) | 128);
+      }
+    }
+
+    return utftext;
+  },
+
+  // private method for UTF-8 decoding
+  _utf8_decode: function(utftext) {
+    let string = '';
+    let i = 0;
+    let c = 0;
+    let c3 = 0;
+    let c2 = 0;
+
+    while (i < utftext.length) {
+      c = utftext.charCodeAt(i);
+
+      if (c < 128) {
+        string += String.fromCharCode(c);
+        i++;
+      } else if (c > 191 && c < 224) {
+        c2 = utftext.charCodeAt(i + 1);
+        string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
+        i += 2;
+      } else {
+        c2 = utftext.charCodeAt(i + 1);
+        c3 = utftext.charCodeAt(i + 2);
+        string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
+        i += 3;
+      }
+    }
+
+    return string;
+  },
+};

From e61b38f25bf9a90e988b42c11b7d4ff77cb5ad05 Mon Sep 17 00:00:00 2001
From: Mikhail Pakhomov <mikhan333@mail.ru>
Date: Thu, 12 Mar 2020 20:04:05 +0300
Subject: [PATCH 12/38] Fix decode data with base64

---
 src/containers/Decrypt/Decrypt.tsx | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/src/containers/Decrypt/Decrypt.tsx b/src/containers/Decrypt/Decrypt.tsx
index dfaf1c3..3c260b6 100644
--- a/src/containers/Decrypt/Decrypt.tsx
+++ b/src/containers/Decrypt/Decrypt.tsx
@@ -4,7 +4,7 @@ import { connect } from 'react-redux';
 import { ContentBox } from 'components/ContentBox';
 import { Alarm } from 'components/Alarm';
 
-import { CIPHER_METHOD, ENCRYPTED_DATA } from 'config';
+import { CIPHER_METHOD, ENCRYPTED_DATA, ENCRYPTED_DATA_BASE64 } from 'config';
 
 import { AppState, Method } from 'store';
 import { DecryptState } from 'store/decrypt/types';
@@ -12,6 +12,8 @@ import { setMethod, setKey, setText, setError, decryptData } from 'store/decrypt
 
 import { encryptionMethods, encryptionTypes } from 'libmethods';
 
+import Base64 from 'utils/base64';
+
 interface DecryptStateProps extends DecryptState {
   setMethod: typeof setMethod;
   setText: typeof setText;
@@ -99,9 +101,16 @@ const Decrypt: React.SFC<DecryptStateProps> = props => {
     };
     props.setMethod(method);
 
-    const encryptedText =
+    let encryptedText: string = '';
+    // @ts-ignore
+    if (objectJSON[ENCRYPTED_DATA_BASE64] === undefined) {
+      encryptedText =
+        // @ts-ignore
+        objectJSON[ENCRYPTED_DATA] === undefined ? '' : objectJSON[ENCRYPTED_DATA];
+    } else {
       // @ts-ignore
-      objectJSON[ENCRYPTED_DATA] === undefined ? '' : objectJSON[ENCRYPTED_DATA];
+      encryptedText = Base64.decode(objectJSON[ENCRYPTED_DATA_BASE64]);
+    }
     props.setText(encryptedText);
   };
 

From d225a28adebe75997341de9070373ccc0e48b7f7 Mon Sep 17 00:00:00 2001
From: Denis Stasyev <denisstasyev@gmail.com>
Date: Thu, 12 Mar 2020 22:32:28 +0300
Subject: [PATCH 13/38] Change Encrypt logic

---
 README.md                                     |  24 ++-
 public/index.html                             |  32 ++++
 src/App.tsx                                   |  12 +-
 src/components/Footer/Footer.tsx              |  15 +-
 src/components/Footer/footer.module.scss      |   3 +-
 src/components/Header/Header.tsx              |   4 +-
 src/components/Header/header.module.scss      |   2 +-
 src/components/Tag/tag.module.scss            |   4 +-
 src/config.ts                                 |  11 +-
 src/containers/Encrypt/Basic/BasicEncrypt.tsx | 143 ++++++++++++++++
 src/containers/Encrypt/Basic/index.ts         |   1 +
 src/containers/Encrypt/Block/BlockEncrypt.tsx |   7 +
 src/containers/Encrypt/Block/index.ts         |   1 +
 src/containers/Encrypt/Encrypt.tsx            | 158 +++---------------
 src/containers/Encrypt/encrypt.module.scss    |   5 +
 src/containers/Home/Home.tsx                  |   9 +-
 src/containers/Home/home.module.scss          |   1 -
 src/libmethods/encryption/README.md           |  37 ++--
 src/libmethods/encryption/basic/README.md     |  34 ++++
 .../encryption/{ => basic}/bigram/index.ts    |   2 +-
 .../{ => basic}/caesar/caesar.test.ts         |   0
 .../encryption/{ => basic}/caesar/index.ts    |   2 +-
 .../encryption/{ => basic}/index.ts           |   0
 .../{ => basic}/monoalphabetic/index.ts       |   4 +-
 .../{ => basic}/polyalphabetic/index.ts       |   2 +-
 src/store/decrypt/actions.ts                  |  10 +-
 src/store/encrypt/actions.ts                  |  10 +-
 27 files changed, 339 insertions(+), 194 deletions(-)
 create mode 100644 src/containers/Encrypt/Basic/BasicEncrypt.tsx
 create mode 100644 src/containers/Encrypt/Basic/index.ts
 create mode 100644 src/containers/Encrypt/Block/BlockEncrypt.tsx
 create mode 100644 src/containers/Encrypt/Block/index.ts
 create mode 100644 src/containers/Encrypt/encrypt.module.scss
 create mode 100644 src/libmethods/encryption/basic/README.md
 rename src/libmethods/encryption/{ => basic}/bigram/index.ts (98%)
 rename src/libmethods/encryption/{ => basic}/caesar/caesar.test.ts (100%)
 rename src/libmethods/encryption/{ => basic}/caesar/index.ts (94%)
 rename src/libmethods/encryption/{ => basic}/index.ts (100%)
 rename src/libmethods/encryption/{ => basic}/monoalphabetic/index.ts (91%)
 rename src/libmethods/encryption/{ => basic}/polyalphabetic/index.ts (96%)

diff --git a/README.md b/README.md
index 18352f3..69d9c4c 100644
--- a/README.md
+++ b/README.md
@@ -19,10 +19,16 @@ You can find the implementation of methods for the backend part in [this reposit
 
 The following encryption and decryption methods are now available:
 
-- Cesar
-- Monoalphabetic
-- Polyalphabetic (Vigenère)
-- Bigram (Porta's with an additional shift)
+- Basic methods
+
+  - Cesar
+  - Monoalphabetic
+  - Polyalphabetic (Vigenère)
+  - Bigram (Porta's with an additional shift)
+
+- Block methods
+  - AES
+  - GOST
 
 More information about encryption and decryption methods are available in [`src/libmethods/encryption` folder](https://github.com/denisstasyev/Information_Security_JS/tree/master/src/libmethods/encryption).
 
@@ -37,6 +43,16 @@ The following checksum methods are now available:
 
 More information about checksum methods are available in [`src/libmethods/checksum` folder](https://github.com/denisstasyev/Information_Security_JS/tree/master/src/libmethods/checksum).
 
+## Available Hash functions
+
+The following hash functions are now available:
+
+- SHA256
+- SHA512
+- SHA3
+
+More information about checksum methods are available in [`src/libmethods/hashing` folder](https://github.com/denisstasyev/Information_Security_JS/tree/master/src/libmethods/hashing).
+
 ## Available Scripts
 
 > This project was bootstrapped with [Create React App](https://github.com/facebook/create-react-app).
diff --git a/public/index.html b/public/index.html
index 448c63b..0809c56 100644
--- a/public/index.html
+++ b/public/index.html
@@ -69,6 +69,38 @@
     />
   </head>
   <body>
+    <!-- Rating Mail.ru counter -->
+    <!-- <script type="text/javascript">
+      var _tmr = window._tmr || (window._tmr = []);
+      _tmr.push({ id: '3165691', type: 'pageView', start: new Date().getTime() });
+      (function(d, w, id) {
+        if (d.getElementById(id)) return;
+        var ts = d.createElement('script');
+        ts.type = 'text/javascript';
+        ts.async = true;
+        ts.id = id;
+        ts.src = 'https://top-fwz1.mail.ru/js/code.js';
+        var f = function() {
+          var s = d.getElementsByTagName('script')[0];
+          s.parentNode.insertBefore(ts, s);
+        };
+        if (w.opera == '[object Opera]') {
+          d.addEventListener('DOMContentLoaded', f, false);
+        } else {
+          f();
+        }
+      })(document, window, 'topmailru-code');
+    </script>
+    <noscript
+      ><div>
+        <img
+          src="https://top-fwz1.mail.ru/counter?id=3165691;js=na"
+          style="border:0;position:absolute;left:-9999px;"
+          alt="Top.Mail.Ru"
+        /></div
+    ></noscript> -->
+    <!-- //Rating Mail.ru counter -->
+
     <noscript>You need to enable JavaScript to run this app.</noscript>
     <div id="root"></div>
     <!--
diff --git a/src/App.tsx b/src/App.tsx
index a7036b3..a03b124 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -6,8 +6,14 @@ import { Content } from 'components/Content';
 import { Footer } from 'components/Footer';
 
 import { Home } from 'containers/Home';
+
 import { Encrypt } from 'containers/Encrypt';
 import { Decrypt } from 'containers/Decrypt';
+import { BasicEncrypt } from 'containers/Encrypt/Basic';
+// import { BasicDecrypt } from 'containers/Decrypt/Basic';
+import { BlockEncrypt } from 'containers/Encrypt/Block';
+// import { BlockDecrypt } from 'containers/Decrypt/Block';
+
 import { Checksum } from 'containers/Checksum';
 import { Hashing } from 'containers/Hashing';
 import { NotFound } from 'containers/NotFound';
@@ -19,8 +25,12 @@ const App = () => {
       <Content>
         <Switch>
           <Route exact path="/" component={Home} />
-          <Route path="/encrypt/" component={Encrypt} />
+          <Route exact path="/encrypt/" component={Encrypt} />
           <Route path="/decrypt/" component={Decrypt} />
+          <Route path="/encrypt/basic" component={BasicEncrypt} />
+          {/* <Route path="/decrypt/basic" component={BasicDecrypt} /> */}
+          <Route path="/encrypt/block" component={BlockEncrypt} />
+          {/* <Route path="/decrypt/block" component={BlockDecrypt} /> */}
           <Route path="/checksum/" component={Checksum} />
           <Route path="/hash/" component={Hashing} />
           <Route path="*" component={NotFound} />
diff --git a/src/components/Footer/Footer.tsx b/src/components/Footer/Footer.tsx
index ddb9025..52b869b 100644
--- a/src/components/Footer/Footer.tsx
+++ b/src/components/Footer/Footer.tsx
@@ -5,13 +5,13 @@ import styles from './footer.module.scss';
 
 import { Tag } from 'components/Tag';
 
-import { links } from 'config';
+import { allLinks } from 'config';
 
 export default function() {
   return (
     <div id="footer" className={styles['footer']}>
       <div className={styles['footer-links']}>
-        {links.map((link, index) => (
+        {allLinks.map((link, index) => (
           <div className={styles['link']} key={index}>
             <Tag link={link} />
           </div>
@@ -20,6 +20,17 @@ export default function() {
       <Link className={styles['copyright']} to="/">
         © Спецпроект "Шифровальщик", {new Date().getFullYear()} г. Все права защищены.
       </Link>
+      {/* <!-- Rating Mail.ru logo --> */}
+      {/* <a href="https://top.mail.ru/jump?from=3165691">
+        <img
+          src="https://top-fwz1.mail.ru/counter?id=3165691;t=466;l=1"
+          style={{ border: 0 }}
+          height="31"
+          width="88"
+          alt="Top.Mail.Ru"
+        />
+      </a> */}
+      {/* <!-- //Rating Mail.ru logo --> */}
     </div>
   );
 }
diff --git a/src/components/Footer/footer.module.scss b/src/components/Footer/footer.module.scss
index 56c6242..b0ddf00 100644
--- a/src/components/Footer/footer.module.scss
+++ b/src/components/Footer/footer.module.scss
@@ -32,9 +32,10 @@
 
 .copyright {
   margin: $x2 $x4;
+  text-align: center;
 }
 
-@media screen and (max-width: $max-width-phone) {
+@media screen and (max-width: $max-width-tablet) {
   .footer-links {
     flex-wrap: wrap;
     justify-content: center;
diff --git a/src/components/Header/Header.tsx b/src/components/Header/Header.tsx
index eb7362c..84e8b5c 100644
--- a/src/components/Header/Header.tsx
+++ b/src/components/Header/Header.tsx
@@ -7,7 +7,7 @@ import { Tag } from 'components/Tag';
 
 import Logo from 'assets/logo.png';
 
-import { links } from 'config';
+import { mainLinks } from 'config';
 
 export default function() {
   return (
@@ -18,7 +18,7 @@ export default function() {
       </Link>
 
       <div className={styles['header-links']}>
-        {links.map((link, index) => (
+        {mainLinks.map((link, index) => (
           <div className={styles['link']} key={index}>
             <Tag link={link} />
           </div>
diff --git a/src/components/Header/header.module.scss b/src/components/Header/header.module.scss
index 195f5a7..ba542da 100644
--- a/src/components/Header/header.module.scss
+++ b/src/components/Header/header.module.scss
@@ -76,7 +76,7 @@ $header-height: $x20;
 
 .text {
   margin-left: $x3;
-  height: 45px;
+  height: 52px;
 
   white-space: nowrap;
 }
diff --git a/src/components/Tag/tag.module.scss b/src/components/Tag/tag.module.scss
index 8238793..416c77d 100644
--- a/src/components/Tag/tag.module.scss
+++ b/src/components/Tag/tag.module.scss
@@ -1,12 +1,14 @@
 @import 'styles/_mods.scss';
 
 .header-link {
-  white-space: nowrap;
+  // white-space: nowrap;
 
   border-radius: $x2;
   padding: $x1;
 
   box-shadow: $depth1;
+
+  display: inline-block;
 }
 
 .header-link-active {
diff --git a/src/config.ts b/src/config.ts
index c1adb66..999a10a 100644
--- a/src/config.ts
+++ b/src/config.ts
@@ -11,9 +11,18 @@ export const HASH_METHOD = 'hash_method';
 export const HASH_VALUE = 'hash_value';
 export const HASH_VALUE_BASE64 = 'hash_value_base64';
 
-export const links = [
+export const mainLinks = [
   { title: 'Зашифровать', href: '/encrypt/', isActive: true },
   { title: 'Расшифровать', href: '/decrypt/', isActive: true },
   { title: 'Посчитать контрольную сумму', href: '/checksum/', isActive: true },
   { title: 'Хешировать', href: '/hash/', isActive: true },
 ];
+
+export const allLinks = [
+  { title: 'Простое шифрование', href: '/encrypt/basic/', isActive: true },
+  { title: 'Расшифрование простого', href: '/decrypt/basic/', isActive: true },
+  { title: 'Блочное шифрование', href: '/encrypt/block/', isActive: true },
+  { title: 'Расшифрование блочного', href: '/decrypt/block/', isActive: true },
+  { title: 'Контрольная сумма', href: '/checksum/', isActive: true },
+  { title: 'Хеширование', href: '/hash/', isActive: true },
+];
diff --git a/src/containers/Encrypt/Basic/BasicEncrypt.tsx b/src/containers/Encrypt/Basic/BasicEncrypt.tsx
new file mode 100644
index 0000000..b7b544c
--- /dev/null
+++ b/src/containers/Encrypt/Basic/BasicEncrypt.tsx
@@ -0,0 +1,143 @@
+import * as React from 'react';
+import { connect } from 'react-redux';
+
+import { ContentBox } from 'components/ContentBox';
+import { Alarm } from 'components/Alarm';
+
+import { CIPHER_METHOD, ENCRYPTED_DATA, ENCRYPTED_DATA_BASE64 } from 'config';
+
+import { AppState, Method } from 'store';
+import { EncryptState } from 'store/encrypt/types';
+import { setMethod, setKey, setText, setError, encryptData } from 'store/encrypt/actions';
+
+import { encryptionMethods, encryptionTypes } from 'libmethods';
+
+import Base64 from 'utils/base64';
+
+interface EncryptStateProps extends EncryptState {
+  setMethod: typeof setMethod;
+  setText: typeof setText;
+  setKey: typeof setKey;
+  setError: typeof setError;
+  encryptData: typeof encryptData;
+}
+
+const Encrypt: React.SFC<EncryptStateProps> = props => {
+  const onChangeMethod = (event: any) => {
+    event.preventDefault();
+    const method: Method =
+      encryptionMethods.find(method => method.type === event.target.value) || encryptionMethods[0];
+    props.setMethod(method);
+
+    if (
+      event.target.value === encryptionTypes.caesar &&
+      props.encryptionKey !== parseInt(props.encryptionKey).toString()
+    ) {
+      props.setKey('');
+    }
+  };
+
+  const onChangeText = (event: any) => {
+    event.preventDefault();
+    props.setText(event.target.value);
+  };
+
+  const clearError = () => {
+    if (props.errorMessage !== '') {
+      props.setError('');
+    }
+  };
+
+  const onChangeKey = (event: any) => {
+    event.preventDefault();
+
+    if (props.method.type === encryptionTypes.caesar && event.target.value !== '') {
+      if (event.target.value === parseInt(event.target.value).toString()) {
+        props.setKey(event.target.value);
+        clearError();
+      } else {
+        props.setError('Некорретный ключ: введите целое значение!');
+      }
+    } else {
+      props.setKey(event.target.value);
+      clearError();
+    }
+  };
+
+  const onSubmit = (event: any) => {
+    event.preventDefault();
+    if (props.encryptionKey === '') {
+      props.setError('Введите ключ шифрования!');
+      return;
+    }
+    if (props.plainText === '') {
+      props.setError('Введите текст, который необходимо зашифровать!');
+      return;
+    }
+    props.encryptData(props.method, props.plainText, props.encryptionKey);
+  };
+
+  const getJSON = (methodName: string, encryptedCode: number[], encryptedText: string) => {
+    let json = {
+      [CIPHER_METHOD]: methodName,
+      // [ENCRYPTED_DATA_CODES]: encryptedCode,
+      [ENCRYPTED_DATA]: encryptedText,
+      [ENCRYPTED_DATA_BASE64]: Base64.encode(encryptedText),
+    };
+    return JSON.stringify(json, undefined, 2);
+  };
+
+  return (
+    <>
+      <ContentBox title="Шифрование">
+        <span>1) Выберите метод для шифрования:</span>
+        <select value={props.method.type} onChange={onChangeMethod}>
+          {encryptionMethods.map((method, index) => (
+            <option value={method.type} key={index}>
+              {method.name}
+            </option>
+          ))}
+        </select>
+        <span>2) Введите ключ:</span>
+        <input
+          value={props.encryptionKey}
+          type="text"
+          placeholder="Ваш ключ"
+          onChange={onChangeKey}
+        />
+        <span>3) Введите открытый текст, который хотите зашифровать:</span>
+        <textarea
+          value={props.plainText}
+          placeholder="Ваш открытый текст"
+          onChange={onChangeText}
+        />
+        {props.errorMessage && <Alarm type="error" text={`Ошибка! ${props.errorMessage}`} />}
+        <button onClick={onSubmit}>Зашифровать!</button>
+      </ContentBox>
+
+      {!props.errorMessage && props.encryptedData.text && (
+        <ContentBox title="Ваш результат">
+          <span>1) Закрытый текст:</span>
+          <textarea value={props.encryptedData.text} onChange={() => {}} />
+          <span>2) JSON для отправки на сервер для расшифрования:</span>
+          <textarea
+            value={getJSON(props.method.name, props.encryptedData.code, props.encryptedData.text)}
+            onChange={() => {}}
+          />
+        </ContentBox>
+      )}
+    </>
+  );
+};
+
+const mapStateToProps = (state: AppState) => ({
+  method: state.encryptReducer.method,
+  encryptionKey: state.encryptReducer.encryptionKey,
+  plainText: state.encryptReducer.plainText,
+  errorMessage: state.encryptReducer.errorMessage,
+  encryptedData: state.encryptReducer.encryptedData,
+});
+
+export default connect(mapStateToProps, { setMethod, setText, setKey, setError, encryptData })(
+  Encrypt,
+);
diff --git a/src/containers/Encrypt/Basic/index.ts b/src/containers/Encrypt/Basic/index.ts
new file mode 100644
index 0000000..5d911e0
--- /dev/null
+++ b/src/containers/Encrypt/Basic/index.ts
@@ -0,0 +1 @@
+export { default as BasicEncrypt } from './BasicEncrypt';
diff --git a/src/containers/Encrypt/Block/BlockEncrypt.tsx b/src/containers/Encrypt/Block/BlockEncrypt.tsx
new file mode 100644
index 0000000..0a8ca1d
--- /dev/null
+++ b/src/containers/Encrypt/Block/BlockEncrypt.tsx
@@ -0,0 +1,7 @@
+import * as React from 'react';
+
+import { ContentBox } from 'components/ContentBox';
+
+export default function() {
+  return <ContentBox title="Блочное шифрование">Block</ContentBox>;
+}
diff --git a/src/containers/Encrypt/Block/index.ts b/src/containers/Encrypt/Block/index.ts
new file mode 100644
index 0000000..a8b7252
--- /dev/null
+++ b/src/containers/Encrypt/Block/index.ts
@@ -0,0 +1 @@
+export { default as BlockEncrypt } from './BlockEncrypt';
diff --git a/src/containers/Encrypt/Encrypt.tsx b/src/containers/Encrypt/Encrypt.tsx
index b7b544c..5fd2cec 100644
--- a/src/containers/Encrypt/Encrypt.tsx
+++ b/src/containers/Encrypt/Encrypt.tsx
@@ -1,143 +1,31 @@
 import * as React from 'react';
-import { connect } from 'react-redux';
+
+import styles from './encrypt.module.scss';
 
 import { ContentBox } from 'components/ContentBox';
 import { Alarm } from 'components/Alarm';
+import { Tag } from 'components/Tag';
 
-import { CIPHER_METHOD, ENCRYPTED_DATA, ENCRYPTED_DATA_BASE64 } from 'config';
-
-import { AppState, Method } from 'store';
-import { EncryptState } from 'store/encrypt/types';
-import { setMethod, setKey, setText, setError, encryptData } from 'store/encrypt/actions';
-
-import { encryptionMethods, encryptionTypes } from 'libmethods';
-
-import Base64 from 'utils/base64';
-
-interface EncryptStateProps extends EncryptState {
-  setMethod: typeof setMethod;
-  setText: typeof setText;
-  setKey: typeof setKey;
-  setError: typeof setError;
-  encryptData: typeof encryptData;
-}
-
-const Encrypt: React.SFC<EncryptStateProps> = props => {
-  const onChangeMethod = (event: any) => {
-    event.preventDefault();
-    const method: Method =
-      encryptionMethods.find(method => method.type === event.target.value) || encryptionMethods[0];
-    props.setMethod(method);
-
-    if (
-      event.target.value === encryptionTypes.caesar &&
-      props.encryptionKey !== parseInt(props.encryptionKey).toString()
-    ) {
-      props.setKey('');
-    }
-  };
-
-  const onChangeText = (event: any) => {
-    event.preventDefault();
-    props.setText(event.target.value);
-  };
-
-  const clearError = () => {
-    if (props.errorMessage !== '') {
-      props.setError('');
-    }
-  };
-
-  const onChangeKey = (event: any) => {
-    event.preventDefault();
-
-    if (props.method.type === encryptionTypes.caesar && event.target.value !== '') {
-      if (event.target.value === parseInt(event.target.value).toString()) {
-        props.setKey(event.target.value);
-        clearError();
-      } else {
-        props.setError('Некорретный ключ: введите целое значение!');
-      }
-    } else {
-      props.setKey(event.target.value);
-      clearError();
-    }
-  };
-
-  const onSubmit = (event: any) => {
-    event.preventDefault();
-    if (props.encryptionKey === '') {
-      props.setError('Введите ключ шифрования!');
-      return;
-    }
-    if (props.plainText === '') {
-      props.setError('Введите текст, который необходимо зашифровать!');
-      return;
-    }
-    props.encryptData(props.method, props.plainText, props.encryptionKey);
-  };
-
-  const getJSON = (methodName: string, encryptedCode: number[], encryptedText: string) => {
-    let json = {
-      [CIPHER_METHOD]: methodName,
-      // [ENCRYPTED_DATA_CODES]: encryptedCode,
-      [ENCRYPTED_DATA]: encryptedText,
-      [ENCRYPTED_DATA_BASE64]: Base64.encode(encryptedText),
-    };
-    return JSON.stringify(json, undefined, 2);
-  };
+const encryptLinks = [
+  { title: 'Простое шифрование', href: '/encrypt/basic/', isActive: true },
+  { title: 'Блочное шифрование', href: '/encrypt/block/', isActive: true },
+];
 
+export default function() {
   return (
-    <>
-      <ContentBox title="Шифрование">
-        <span>1) Выберите метод для шифрования:</span>
-        <select value={props.method.type} onChange={onChangeMethod}>
-          {encryptionMethods.map((method, index) => (
-            <option value={method.type} key={index}>
-              {method.name}
-            </option>
-          ))}
-        </select>
-        <span>2) Введите ключ:</span>
-        <input
-          value={props.encryptionKey}
-          type="text"
-          placeholder="Ваш ключ"
-          onChange={onChangeKey}
-        />
-        <span>3) Введите открытый текст, который хотите зашифровать:</span>
-        <textarea
-          value={props.plainText}
-          placeholder="Ваш открытый текст"
-          onChange={onChangeText}
-        />
-        {props.errorMessage && <Alarm type="error" text={`Ошибка! ${props.errorMessage}`} />}
-        <button onClick={onSubmit}>Зашифровать!</button>
-      </ContentBox>
-
-      {!props.errorMessage && props.encryptedData.text && (
-        <ContentBox title="Ваш результат">
-          <span>1) Закрытый текст:</span>
-          <textarea value={props.encryptedData.text} onChange={() => {}} />
-          <span>2) JSON для отправки на сервер для расшифрования:</span>
-          <textarea
-            value={getJSON(props.method.name, props.encryptedData.code, props.encryptedData.text)}
-            onChange={() => {}}
-          />
-        </ContentBox>
-      )}
-    </>
+    <ContentBox title="Блочное шифрование">
+      <Alarm type="news" text="Новинка: блочные шифры &#128522;!" />
+      <br />
+      <span>Доступные методы шифрования:</span>
+      <ul>
+        {encryptLinks.map((link, index) => (
+          <li key={index}>
+            <div className={styles['tag']}>
+              <Tag link={link} />
+            </div>
+          </li>
+        ))}
+      </ul>
+    </ContentBox>
   );
-};
-
-const mapStateToProps = (state: AppState) => ({
-  method: state.encryptReducer.method,
-  encryptionKey: state.encryptReducer.encryptionKey,
-  plainText: state.encryptReducer.plainText,
-  errorMessage: state.encryptReducer.errorMessage,
-  encryptedData: state.encryptReducer.encryptedData,
-});
-
-export default connect(mapStateToProps, { setMethod, setText, setKey, setError, encryptData })(
-  Encrypt,
-);
+}
diff --git a/src/containers/Encrypt/encrypt.module.scss b/src/containers/Encrypt/encrypt.module.scss
new file mode 100644
index 0000000..fa32b84
--- /dev/null
+++ b/src/containers/Encrypt/encrypt.module.scss
@@ -0,0 +1,5 @@
+@import 'styles/_mods.scss';
+
+.tag {
+  margin: $x1;
+}
diff --git a/src/containers/Home/Home.tsx b/src/containers/Home/Home.tsx
index dc389c0..bd95451 100644
--- a/src/containers/Home/Home.tsx
+++ b/src/containers/Home/Home.tsx
@@ -6,19 +6,19 @@ import { ContentBox } from 'components/ContentBox';
 import { Alarm } from 'components/Alarm';
 import { Tag } from 'components/Tag';
 
-import { links } from 'config';
+import { mainLinks } from 'config';
 
 export default function() {
   return (
-    <ContentBox title={`Добро пожаловать на спецпроект "Шифровальщик"!`}>
+    <ContentBox title='Добро пожаловать на спецпроект "Шифровальщик"!'>
       <Alarm
         type="news"
         text="Теперь у нас вы можете использовать Emoji в качестве ключей шифрования &#128522;!"
       />
       <br />
-      <span>Сейчас вы можете на нашем сайте:</span>
+      <span>Сейчас доступны следующие возможности:</span>
       <ul>
-        {links.map((link, index) => (
+        {mainLinks.map((link, index) => (
           <li key={index}>
             <div className={styles['tag']}>
               <Tag link={link} />
@@ -26,7 +26,6 @@ export default function() {
           </li>
         ))}
       </ul>
-      <span>сообщения.</span>
     </ContentBox>
   );
 }
diff --git a/src/containers/Home/home.module.scss b/src/containers/Home/home.module.scss
index 697974e..fa32b84 100644
--- a/src/containers/Home/home.module.scss
+++ b/src/containers/Home/home.module.scss
@@ -1,6 +1,5 @@
 @import 'styles/_mods.scss';
 
 .tag {
-  display: inline-block;
   margin: $x1;
 }
diff --git a/src/libmethods/encryption/README.md b/src/libmethods/encryption/README.md
index 035104f..39ef314 100644
--- a/src/libmethods/encryption/README.md
+++ b/src/libmethods/encryption/README.md
@@ -1,34 +1,21 @@
 # Description of cryptographic algorithms
 
-## Caesar cipher
+## Basic algorithms
 
-The cipher is based on a shift in the order of characters by the key value. In this implementation, it is possible to encrypt/decrypt any Unicode characters (including hieroglyphs and emoticons). It shifts the serial number in the unicode table. The shift is performed in the ring modulo 1114112, since the Unicode space represents the values from 0 to 1,114,111 (0x10FFFF).
+This project includes some basic algorithms, such as:
 
-![alt text][ceasercipher_logo]
+- Caesar cipher
+- Monoalphabetic cipher
+- Polyalphabetic (Vigenère) cipher
+- Bigram (Porta's with an additional shift) cipher
 
-## Monoalphabetic cipher
+More information about basic methods are available in [`src/libmethods/encryption/basic` folder](https://github.com/denisstasyev/Information_Security_JS/tree/master/src/libmethods/encryption/basic).
 
-The idea of a cipher is similar to Caesar's cipher, however, as a key, it is possible to use not only integer values, but also strings. In this case, the key value is formed as the sum of the Unicode character numbers from the key string.
+## Block algorithms
 
-## Polyalphabetic (Vigenère) cipher
+This project includes some block algorithms, such as:
 
-For encryption (operate with [unicode numbers](https://unicode-table.com)):
+- AES
+- GOST
 
-![alt text][bigramencrypt]
-
-Where n = 1114112 (power of Unicode space), m[i] - char of message, c[i] - char of ciphertext, k[i] - char of key material, obtained by cyclic repetition of the key line. More detailed [description](https://en.wikipedia.org/wiki/Vigenère_cipher)
-
-For decryption (operate with [unicode numbers](https://unicode-table.com)):
-
-![alt text][bigramdecrypt]
-
-## Bigram (Porta's with an additional shift) cipher
-
-This cipher is based on the sequential replacement of pairs of characters from plaintext in accordance with the replacement table. Below is an example of a table for the Cyrillic alphabet, however, in this implementation, a table of size 1114112 x 1114112 is used. An additional shift of values is implemented as in the monoalphabetic cipher.
-
-![alt text][bigramcipher_logo]
-
-[ceasercipher_logo]: https://cdncontribute.geeksforgeeks.org/wp-content/uploads/ceaserCipher-1.png
-[bigramcipher_logo]: https://sites.google.com/site/anisimovkhv/_/rsrc/1385774017706/learning/kripto/lecture/tema4/shifr_porta.png
-[bigramencrypt]: https://latex.codecogs.com/gif.latex?%24%24c%5Bi%5D%20%5Cequiv%20m%5Bi%5D%20+%20k%5Bi%5D%20%5Cpmod%20n%24%24
-[bigramdecrypt]: https://latex.codecogs.com/gif.latex?%24%24m%5Bi%5D%20%5Cequiv%20c%5Bi%5D%20+%20n%20-%20k%5Bi%5D%20%5Cpmod%20n%24%24
+More information about block methods are available in [`src/libmethods/encryption/block` folder](https://github.com/denisstasyev/Information_Security_JS/tree/master/src/libmethods/encryption/block).
diff --git a/src/libmethods/encryption/basic/README.md b/src/libmethods/encryption/basic/README.md
new file mode 100644
index 0000000..be7ba2a
--- /dev/null
+++ b/src/libmethods/encryption/basic/README.md
@@ -0,0 +1,34 @@
+# Description of basic cryptographic algorithms
+
+## Caesar cipher
+
+The cipher is based on a shift in the order of characters by the key value. In this implementation, it is possible to encrypt/decrypt any Unicode characters (including hieroglyphs and emoticons). It shifts the serial number in the unicode table. The shift is performed in the ring modulo 1114112, since the Unicode space represents the values from 0 to 1,114,111 (0x10FFFF).
+
+![alt text][ceasercipher_logo]
+
+## Monoalphabetic cipher
+
+The idea of a cipher is similar to Caesar's cipher, however, as a key, it is possible to use not only integer values, but also strings. In this case, the key value is formed as the sum of the Unicode character numbers from the key string.
+
+## Polyalphabetic (Vigenère) cipher
+
+For encryption (operate with [unicode numbers](https://unicode-table.com)):
+
+![alt text][bigramencrypt]
+
+Where n = 1114112 (power of Unicode space), m[i] - char of message, c[i] - char of ciphertext, k[i] - char of key material, obtained by cyclic repetition of the key line. More detailed [description](https://en.wikipedia.org/wiki/Vigenère_cipher)
+
+For decryption (operate with [unicode numbers](https://unicode-table.com)):
+
+![alt text][bigramdecrypt]
+
+## Bigram (Porta's with an additional shift) cipher
+
+This cipher is based on the sequential replacement of pairs of characters from plaintext in accordance with the replacement table. Below is an example of a table for the Cyrillic alphabet, however, in this implementation, a table of size 1114112 x 1114112 is used. An additional shift of values is implemented as in the monoalphabetic cipher.
+
+![alt text][bigramcipher_logo]
+
+[ceasercipher_logo]: https://cdncontribute.geeksforgeeks.org/wp-content/uploads/ceaserCipher-1.png
+[bigramcipher_logo]: https://sites.google.com/site/anisimovkhv/_/rsrc/1385774017706/learning/kripto/lecture/tema4/shifr_porta.png
+[bigramencrypt]: https://latex.codecogs.com/gif.latex?%24%24c%5Bi%5D%20%5Cequiv%20m%5Bi%5D%20+%20k%5Bi%5D%20%5Cpmod%20n%24%24
+[bigramdecrypt]: https://latex.codecogs.com/gif.latex?%24%24m%5Bi%5D%20%5Cequiv%20c%5Bi%5D%20+%20n%20-%20k%5Bi%5D%20%5Cpmod%20n%24%24
diff --git a/src/libmethods/encryption/bigram/index.ts b/src/libmethods/encryption/basic/bigram/index.ts
similarity index 98%
rename from src/libmethods/encryption/bigram/index.ts
rename to src/libmethods/encryption/basic/bigram/index.ts
index 032e017..549fd36 100644
--- a/src/libmethods/encryption/bigram/index.ts
+++ b/src/libmethods/encryption/basic/bigram/index.ts
@@ -3,7 +3,7 @@ import {
   UNICODE_RING_SIZE,
   UNICODE_RING_SIZE_SQUARE,
   UNICODE_RING_SIZE_SQUARE_LENGTH,
-} from 'libmethods/encryption';
+} from 'libmethods/encryption/basic';
 import { getUnicodeCode } from 'libmethods';
 
 /**
diff --git a/src/libmethods/encryption/caesar/caesar.test.ts b/src/libmethods/encryption/basic/caesar/caesar.test.ts
similarity index 100%
rename from src/libmethods/encryption/caesar/caesar.test.ts
rename to src/libmethods/encryption/basic/caesar/caesar.test.ts
diff --git a/src/libmethods/encryption/caesar/index.ts b/src/libmethods/encryption/basic/caesar/index.ts
similarity index 94%
rename from src/libmethods/encryption/caesar/index.ts
rename to src/libmethods/encryption/basic/caesar/index.ts
index b8e3402..2882304 100644
--- a/src/libmethods/encryption/caesar/index.ts
+++ b/src/libmethods/encryption/basic/caesar/index.ts
@@ -1,5 +1,5 @@
 import { EncryptedData } from 'store';
-import { UNICODE_RING_SIZE } from 'libmethods/encryption';
+import { UNICODE_RING_SIZE } from 'libmethods/encryption/basic';
 import { getUnicodeCode } from 'libmethods';
 
 /**
diff --git a/src/libmethods/encryption/index.ts b/src/libmethods/encryption/basic/index.ts
similarity index 100%
rename from src/libmethods/encryption/index.ts
rename to src/libmethods/encryption/basic/index.ts
diff --git a/src/libmethods/encryption/monoalphabetic/index.ts b/src/libmethods/encryption/basic/monoalphabetic/index.ts
similarity index 91%
rename from src/libmethods/encryption/monoalphabetic/index.ts
rename to src/libmethods/encryption/basic/monoalphabetic/index.ts
index f92bbe9..86d2558 100644
--- a/src/libmethods/encryption/monoalphabetic/index.ts
+++ b/src/libmethods/encryption/basic/monoalphabetic/index.ts
@@ -1,7 +1,7 @@
 import { EncryptedData } from 'store';
-import { UNICODE_RING_SIZE } from 'libmethods/encryption';
+import { UNICODE_RING_SIZE } from 'libmethods/encryption/basic';
 import { getUnicodeCode } from 'libmethods';
-import { encryptCesar } from 'libmethods/encryption/caesar';
+import { encryptCesar } from 'libmethods/encryption/basic/caesar';
 
 /**
  * A monoalphabetic encryption:
diff --git a/src/libmethods/encryption/polyalphabetic/index.ts b/src/libmethods/encryption/basic/polyalphabetic/index.ts
similarity index 96%
rename from src/libmethods/encryption/polyalphabetic/index.ts
rename to src/libmethods/encryption/basic/polyalphabetic/index.ts
index 0c320da..fddfa2c 100644
--- a/src/libmethods/encryption/polyalphabetic/index.ts
+++ b/src/libmethods/encryption/basic/polyalphabetic/index.ts
@@ -1,5 +1,5 @@
 import { EncryptedData } from 'store';
-import { UNICODE_RING_SIZE } from 'libmethods/encryption';
+import { UNICODE_RING_SIZE } from 'libmethods/encryption/basic';
 import { getUnicodeCode } from 'libmethods';
 
 /**
diff --git a/src/store/decrypt/actions.ts b/src/store/decrypt/actions.ts
index 200919a..6acf985 100644
--- a/src/store/decrypt/actions.ts
+++ b/src/store/decrypt/actions.ts
@@ -2,11 +2,11 @@ import { Method, EncryptedData } from 'store';
 import * as types from './types';
 
 import { encryptionTypes } from 'libmethods';
-import { outputData } from 'libmethods/encryption';
-import { decryptCesar } from 'libmethods/encryption/caesar';
-import { decryptMonoAlphabeticCode } from 'libmethods/encryption/monoalphabetic';
-import { decryptPolyAlphabeticCode } from 'libmethods/encryption/polyalphabetic';
-import { decryptBigram } from 'libmethods/encryption/bigram';
+import { outputData } from 'libmethods/encryption/basic';
+import { decryptCesar } from 'libmethods/encryption/basic/caesar';
+import { decryptMonoAlphabeticCode } from 'libmethods/encryption/basic/monoalphabetic';
+import { decryptPolyAlphabeticCode } from 'libmethods/encryption/basic/polyalphabetic';
+import { decryptBigram } from 'libmethods/encryption/basic/bigram';
 
 export function setMethod(method: Method) {
   return {
diff --git a/src/store/encrypt/actions.ts b/src/store/encrypt/actions.ts
index 3c11e1d..782c728 100644
--- a/src/store/encrypt/actions.ts
+++ b/src/store/encrypt/actions.ts
@@ -2,11 +2,11 @@ import { Method, EncryptedData } from 'store';
 import * as types from './types';
 
 import { encryptionTypes } from 'libmethods';
-import { outputData } from 'libmethods/encryption';
-import { encryptCesar } from 'libmethods/encryption/caesar';
-import { encryptMonoAlphabeticCode } from 'libmethods/encryption/monoalphabetic';
-import { encryptPolyAlphabeticCode } from 'libmethods/encryption/polyalphabetic';
-import { encryptBigram } from 'libmethods/encryption/bigram';
+import { outputData } from 'libmethods/encryption/basic';
+import { encryptCesar } from 'libmethods/encryption/basic/caesar';
+import { encryptMonoAlphabeticCode } from 'libmethods/encryption/basic/monoalphabetic';
+import { encryptPolyAlphabeticCode } from 'libmethods/encryption/basic/polyalphabetic';
+import { encryptBigram } from 'libmethods/encryption/basic/bigram';
 
 export function setMethod(method: Method) {
   return {

From 4abec3a0597da63c3987683333ad38978643ae6f Mon Sep 17 00:00:00 2001
From: Denis Stasyev <denisstasyev@gmail.com>
Date: Thu, 12 Mar 2020 22:53:09 +0300
Subject: [PATCH 14/38] Add new logic for Decrypt

---
 src/App.tsx                                   |  16 +-
 src/components/Content/Content.tsx            |   3 +-
 src/components/Header/header.module.scss      |   4 +-
 src/containers/Decrypt/Basic/BasicDecrypt.tsx | 210 ++++++++++++++++
 src/containers/Decrypt/Basic/index.ts         |   1 +
 src/containers/Decrypt/Block/BlockDecrypt.tsx |   7 +
 src/containers/Decrypt/Block/index.ts         |   1 +
 src/containers/Decrypt/Decrypt.tsx            | 225 ++----------------
 src/containers/Decrypt/decrypt.module.scss    |   5 +
 src/containers/Encrypt/Encrypt.tsx            |   2 +-
 src/containers/Encrypt/encrypt.module.scss    |   4 +-
 src/containers/Home/home.module.scss          |   4 +-
 src/styles/_mixins.scss                       |   5 +
 13 files changed, 272 insertions(+), 215 deletions(-)
 create mode 100644 src/containers/Decrypt/Basic/BasicDecrypt.tsx
 create mode 100644 src/containers/Decrypt/Basic/index.ts
 create mode 100644 src/containers/Decrypt/Block/BlockDecrypt.tsx
 create mode 100644 src/containers/Decrypt/Block/index.ts
 create mode 100644 src/containers/Decrypt/decrypt.module.scss
 create mode 100644 src/styles/_mixins.scss

diff --git a/src/App.tsx b/src/App.tsx
index a03b124..7dc34a9 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -9,10 +9,12 @@ import { Home } from 'containers/Home';
 
 import { Encrypt } from 'containers/Encrypt';
 import { Decrypt } from 'containers/Decrypt';
+
 import { BasicEncrypt } from 'containers/Encrypt/Basic';
-// import { BasicDecrypt } from 'containers/Decrypt/Basic';
+import { BasicDecrypt } from 'containers/Decrypt/Basic';
+
 import { BlockEncrypt } from 'containers/Encrypt/Block';
-// import { BlockDecrypt } from 'containers/Decrypt/Block';
+import { BlockDecrypt } from 'containers/Decrypt/Block';
 
 import { Checksum } from 'containers/Checksum';
 import { Hashing } from 'containers/Hashing';
@@ -25,12 +27,16 @@ const App = () => {
       <Content>
         <Switch>
           <Route exact path="/" component={Home} />
+
           <Route exact path="/encrypt/" component={Encrypt} />
-          <Route path="/decrypt/" component={Decrypt} />
+          <Route exact path="/decrypt/" component={Decrypt} />
+
           <Route path="/encrypt/basic" component={BasicEncrypt} />
-          {/* <Route path="/decrypt/basic" component={BasicDecrypt} /> */}
+          <Route path="/decrypt/basic" component={BasicDecrypt} />
+
           <Route path="/encrypt/block" component={BlockEncrypt} />
-          {/* <Route path="/decrypt/block" component={BlockDecrypt} /> */}
+          <Route path="/decrypt/block" component={BlockDecrypt} />
+
           <Route path="/checksum/" component={Checksum} />
           <Route path="/hash/" component={Hashing} />
           <Route path="*" component={NotFound} />
diff --git a/src/components/Content/Content.tsx b/src/components/Content/Content.tsx
index 372ff90..34d892e 100644
--- a/src/components/Content/Content.tsx
+++ b/src/components/Content/Content.tsx
@@ -11,7 +11,8 @@ export default function(props: any) {
           .offsetHeight + 10}px`),
     );
     document.getElementById('content')!.style.minHeight = `${window.innerHeight -
-      document.getElementById('header')!.offsetHeight}px`;
+      document.getElementById('header')!.offsetHeight -
+      50}px`;
   };
 
   React.useEffect(() => {
diff --git a/src/components/Header/header.module.scss b/src/components/Header/header.module.scss
index ba542da..2e4f004 100644
--- a/src/components/Header/header.module.scss
+++ b/src/components/Header/header.module.scss
@@ -70,13 +70,13 @@ $header-height: $x20;
 
 .logo {
   position: relative;
-  bottom: $x1;
+  // bottom: $x1;
   height: $x8;
 }
 
 .text {
   margin-left: $x3;
-  height: 52px;
+  // height: 52px;
 
   white-space: nowrap;
 }
diff --git a/src/containers/Decrypt/Basic/BasicDecrypt.tsx b/src/containers/Decrypt/Basic/BasicDecrypt.tsx
new file mode 100644
index 0000000..3c260b6
--- /dev/null
+++ b/src/containers/Decrypt/Basic/BasicDecrypt.tsx
@@ -0,0 +1,210 @@
+import * as React from 'react';
+import { connect } from 'react-redux';
+
+import { ContentBox } from 'components/ContentBox';
+import { Alarm } from 'components/Alarm';
+
+import { CIPHER_METHOD, ENCRYPTED_DATA, ENCRYPTED_DATA_BASE64 } from 'config';
+
+import { AppState, Method } from 'store';
+import { DecryptState } from 'store/decrypt/types';
+import { setMethod, setKey, setText, setError, decryptData } from 'store/decrypt/actions';
+
+import { encryptionMethods, encryptionTypes } from 'libmethods';
+
+import Base64 from 'utils/base64';
+
+interface DecryptStateProps extends DecryptState {
+  setMethod: typeof setMethod;
+  setText: typeof setText;
+  setKey: typeof setKey;
+  setError: typeof setError;
+  decryptData: typeof decryptData;
+}
+
+const Decrypt: React.SFC<DecryptStateProps> = props => {
+  const [isJSONMode, setIsJSONMode] = React.useState(false);
+
+  const onChangeMethod = (event: any) => {
+    event.preventDefault();
+    const method: Method =
+      encryptionMethods.find(method => method.type === event.target.value) || encryptionMethods[0];
+    props.setMethod(method);
+
+    if (
+      event.target.value === encryptionTypes.caesar &&
+      props.decryptionKey !== parseInt(props.decryptionKey).toString()
+    ) {
+      props.setKey('');
+    }
+  };
+
+  const onChangeText = (event: any) => {
+    event.preventDefault();
+    props.setText(event.target.value);
+  };
+
+  const clearError = () => {
+    if (props.errorMessage !== '') {
+      props.setError('');
+    }
+  };
+
+  const onChangeKey = (event: any) => {
+    event.preventDefault();
+
+    if (props.method.type === encryptionTypes.caesar && event.target.value !== '') {
+      if (event.target.value === parseInt(event.target.value).toString()) {
+        props.setKey(event.target.value);
+        clearError();
+      } else {
+        props.setError('Некорретный ключ: введите целое значение!');
+      }
+    } else {
+      props.setKey(event.target.value);
+      clearError();
+    }
+  };
+
+  const onSubmit = (event: any) => {
+    event.preventDefault();
+    if (props.decryptionKey === '') {
+      props.setError('Введите ключ расшифрования!');
+      return;
+    }
+    if (props.encryptedText === '') {
+      props.setError('Введите текст, который необходимо расшифровать!');
+      return;
+    }
+    props.decryptData(props.method, props.encryptedText, props.decryptionKey);
+  };
+
+  const onChangeJSON = (event: any) => {
+    event.preventDefault();
+    setPropsData(event.target.value);
+  };
+
+  const setPropsData = (json: string) => {
+    let objectJSON = {};
+    try {
+      objectJSON = JSON.parse(json);
+    } catch (e) {
+      props.setError('JSON не валидный!');
+    }
+
+    const methodName =
+      // @ts-ignore
+      objectJSON[CIPHER_METHOD] === undefined ? '' : objectJSON[CIPHER_METHOD];
+    const method: Method = encryptionMethods.find(method => method.name === methodName) || {
+      name: '',
+      type: '',
+    };
+    props.setMethod(method);
+
+    let encryptedText: string = '';
+    // @ts-ignore
+    if (objectJSON[ENCRYPTED_DATA_BASE64] === undefined) {
+      encryptedText =
+        // @ts-ignore
+        objectJSON[ENCRYPTED_DATA] === undefined ? '' : objectJSON[ENCRYPTED_DATA];
+    } else {
+      // @ts-ignore
+      encryptedText = Base64.decode(objectJSON[ENCRYPTED_DATA_BASE64]);
+    }
+    props.setText(encryptedText);
+  };
+
+  const onSubmitJSON = (event: any) => {
+    event.preventDefault();
+
+    if (props.decryptionKey === '') {
+      props.setError('Введите ключ расшифрования!');
+      return;
+    }
+
+    if (props.method.name === '') {
+      props.setError(`Введите метод шифрования в JSON (свойство: ${CIPHER_METHOD})!`);
+      return;
+    }
+
+    if (props.encryptedText === '') {
+      props.setError(
+        `Введите текст в JSON, который необходимо расшифровать (свойство: ${ENCRYPTED_DATA})!`,
+      );
+      return;
+    }
+
+    props.decryptData(props.method, props.encryptedText, props.decryptionKey);
+  };
+
+  return (
+    <>
+      <ContentBox title="Расшифрование">
+        <span>0) Выберите режим расшифрования:</span>
+        <button onClick={() => setIsJSONMode(!isJSONMode)}>
+          {isJSONMode ? 'Перейти в обычный режим' : 'Расшифровать JSON'}
+        </button>
+        {isJSONMode ? (
+          <>
+            <span>1) Введите JSON, который хотите расшифровать:</span>
+            <textarea placeholder="Ваш JSON" onChange={onChangeJSON} />
+            <span>2) Введите ключ:</span>
+            <input
+              value={props.decryptionKey}
+              type="text"
+              placeholder="Ваш ключ"
+              onChange={onChangeKey}
+            />
+            {props.errorMessage && <Alarm type="error" text={`Ошибка! ${props.errorMessage}`} />}
+            <button onClick={onSubmitJSON}>Расшифровать!</button>
+          </>
+        ) : (
+          <>
+            <span>1) Выберите метод для расшифрования:</span>
+            <select value={props.method.type} onChange={onChangeMethod}>
+              {encryptionMethods.map((method, index) => (
+                <option value={method.type} key={index}>
+                  {method.name}
+                </option>
+              ))}
+            </select>
+            <span>2) Введите ключ:</span>
+            <input
+              value={props.decryptionKey}
+              type="text"
+              placeholder="Ваш ключ"
+              onChange={onChangeKey}
+            />
+            <span>3) Введите закрытый (зашифрованный) текст, который хотите расшифровать:</span>
+            <textarea
+              value={props.encryptedText}
+              placeholder="Ваш зашифрованный текст"
+              onChange={onChangeText}
+            />
+            {props.errorMessage && <Alarm type="error" text={`Ошибка! ${props.errorMessage}`} />}
+            <button onClick={onSubmit}>Расшифровать!</button>
+          </>
+        )}
+      </ContentBox>
+
+      {!props.errorMessage && props.decryptedData.text && (
+        <ContentBox title="Ваш результат">
+          <span>1) Открытый текст:</span>
+          <textarea value={props.decryptedData.text} onChange={() => {}} />
+        </ContentBox>
+      )}
+    </>
+  );
+};
+
+const mapStateToProps = (state: AppState) => ({
+  method: state.decryptReducer.method,
+  decryptionKey: state.decryptReducer.decryptionKey,
+  encryptedText: state.decryptReducer.encryptedText,
+  errorMessage: state.decryptReducer.errorMessage,
+  decryptedData: state.decryptReducer.decryptedData,
+});
+
+export default connect(mapStateToProps, { setMethod, setText, setKey, setError, decryptData })(
+  Decrypt,
+);
diff --git a/src/containers/Decrypt/Basic/index.ts b/src/containers/Decrypt/Basic/index.ts
new file mode 100644
index 0000000..6bbf76d
--- /dev/null
+++ b/src/containers/Decrypt/Basic/index.ts
@@ -0,0 +1 @@
+export { default as BasicDecrypt } from './BasicDecrypt';
diff --git a/src/containers/Decrypt/Block/BlockDecrypt.tsx b/src/containers/Decrypt/Block/BlockDecrypt.tsx
new file mode 100644
index 0000000..5d367b0
--- /dev/null
+++ b/src/containers/Decrypt/Block/BlockDecrypt.tsx
@@ -0,0 +1,7 @@
+import * as React from 'react';
+
+import { ContentBox } from 'components/ContentBox';
+
+export default function() {
+  return <ContentBox title="Блочное расшифрование">Block</ContentBox>;
+}
diff --git a/src/containers/Decrypt/Block/index.ts b/src/containers/Decrypt/Block/index.ts
new file mode 100644
index 0000000..52ad218
--- /dev/null
+++ b/src/containers/Decrypt/Block/index.ts
@@ -0,0 +1 @@
+export { default as BlockDecrypt } from './BlockDecrypt';
diff --git a/src/containers/Decrypt/Decrypt.tsx b/src/containers/Decrypt/Decrypt.tsx
index 3c260b6..bd2d2b3 100644
--- a/src/containers/Decrypt/Decrypt.tsx
+++ b/src/containers/Decrypt/Decrypt.tsx
@@ -1,210 +1,31 @@
 import * as React from 'react';
-import { connect } from 'react-redux';
+
+import styles from './decrypt.module.scss';
 
 import { ContentBox } from 'components/ContentBox';
 import { Alarm } from 'components/Alarm';
+import { Tag } from 'components/Tag';
 
-import { CIPHER_METHOD, ENCRYPTED_DATA, ENCRYPTED_DATA_BASE64 } from 'config';
-
-import { AppState, Method } from 'store';
-import { DecryptState } from 'store/decrypt/types';
-import { setMethod, setKey, setText, setError, decryptData } from 'store/decrypt/actions';
-
-import { encryptionMethods, encryptionTypes } from 'libmethods';
-
-import Base64 from 'utils/base64';
-
-interface DecryptStateProps extends DecryptState {
-  setMethod: typeof setMethod;
-  setText: typeof setText;
-  setKey: typeof setKey;
-  setError: typeof setError;
-  decryptData: typeof decryptData;
-}
-
-const Decrypt: React.SFC<DecryptStateProps> = props => {
-  const [isJSONMode, setIsJSONMode] = React.useState(false);
-
-  const onChangeMethod = (event: any) => {
-    event.preventDefault();
-    const method: Method =
-      encryptionMethods.find(method => method.type === event.target.value) || encryptionMethods[0];
-    props.setMethod(method);
-
-    if (
-      event.target.value === encryptionTypes.caesar &&
-      props.decryptionKey !== parseInt(props.decryptionKey).toString()
-    ) {
-      props.setKey('');
-    }
-  };
-
-  const onChangeText = (event: any) => {
-    event.preventDefault();
-    props.setText(event.target.value);
-  };
-
-  const clearError = () => {
-    if (props.errorMessage !== '') {
-      props.setError('');
-    }
-  };
-
-  const onChangeKey = (event: any) => {
-    event.preventDefault();
-
-    if (props.method.type === encryptionTypes.caesar && event.target.value !== '') {
-      if (event.target.value === parseInt(event.target.value).toString()) {
-        props.setKey(event.target.value);
-        clearError();
-      } else {
-        props.setError('Некорретный ключ: введите целое значение!');
-      }
-    } else {
-      props.setKey(event.target.value);
-      clearError();
-    }
-  };
-
-  const onSubmit = (event: any) => {
-    event.preventDefault();
-    if (props.decryptionKey === '') {
-      props.setError('Введите ключ расшифрования!');
-      return;
-    }
-    if (props.encryptedText === '') {
-      props.setError('Введите текст, который необходимо расшифровать!');
-      return;
-    }
-    props.decryptData(props.method, props.encryptedText, props.decryptionKey);
-  };
-
-  const onChangeJSON = (event: any) => {
-    event.preventDefault();
-    setPropsData(event.target.value);
-  };
-
-  const setPropsData = (json: string) => {
-    let objectJSON = {};
-    try {
-      objectJSON = JSON.parse(json);
-    } catch (e) {
-      props.setError('JSON не валидный!');
-    }
-
-    const methodName =
-      // @ts-ignore
-      objectJSON[CIPHER_METHOD] === undefined ? '' : objectJSON[CIPHER_METHOD];
-    const method: Method = encryptionMethods.find(method => method.name === methodName) || {
-      name: '',
-      type: '',
-    };
-    props.setMethod(method);
-
-    let encryptedText: string = '';
-    // @ts-ignore
-    if (objectJSON[ENCRYPTED_DATA_BASE64] === undefined) {
-      encryptedText =
-        // @ts-ignore
-        objectJSON[ENCRYPTED_DATA] === undefined ? '' : objectJSON[ENCRYPTED_DATA];
-    } else {
-      // @ts-ignore
-      encryptedText = Base64.decode(objectJSON[ENCRYPTED_DATA_BASE64]);
-    }
-    props.setText(encryptedText);
-  };
-
-  const onSubmitJSON = (event: any) => {
-    event.preventDefault();
-
-    if (props.decryptionKey === '') {
-      props.setError('Введите ключ расшифрования!');
-      return;
-    }
-
-    if (props.method.name === '') {
-      props.setError(`Введите метод шифрования в JSON (свойство: ${CIPHER_METHOD})!`);
-      return;
-    }
-
-    if (props.encryptedText === '') {
-      props.setError(
-        `Введите текст в JSON, который необходимо расшифровать (свойство: ${ENCRYPTED_DATA})!`,
-      );
-      return;
-    }
-
-    props.decryptData(props.method, props.encryptedText, props.decryptionKey);
-  };
+const encryptLinks = [
+  { title: 'Простое расшифрование', href: '/decrypt/basic/', isActive: true },
+  { title: 'Блочное расшифрование', href: '/decrypt/block/', isActive: true },
+];
 
+export default function() {
   return (
-    <>
-      <ContentBox title="Расшифрование">
-        <span>0) Выберите режим расшифрования:</span>
-        <button onClick={() => setIsJSONMode(!isJSONMode)}>
-          {isJSONMode ? 'Перейти в обычный режим' : 'Расшифровать JSON'}
-        </button>
-        {isJSONMode ? (
-          <>
-            <span>1) Введите JSON, который хотите расшифровать:</span>
-            <textarea placeholder="Ваш JSON" onChange={onChangeJSON} />
-            <span>2) Введите ключ:</span>
-            <input
-              value={props.decryptionKey}
-              type="text"
-              placeholder="Ваш ключ"
-              onChange={onChangeKey}
-            />
-            {props.errorMessage && <Alarm type="error" text={`Ошибка! ${props.errorMessage}`} />}
-            <button onClick={onSubmitJSON}>Расшифровать!</button>
-          </>
-        ) : (
-          <>
-            <span>1) Выберите метод для расшифрования:</span>
-            <select value={props.method.type} onChange={onChangeMethod}>
-              {encryptionMethods.map((method, index) => (
-                <option value={method.type} key={index}>
-                  {method.name}
-                </option>
-              ))}
-            </select>
-            <span>2) Введите ключ:</span>
-            <input
-              value={props.decryptionKey}
-              type="text"
-              placeholder="Ваш ключ"
-              onChange={onChangeKey}
-            />
-            <span>3) Введите закрытый (зашифрованный) текст, который хотите расшифровать:</span>
-            <textarea
-              value={props.encryptedText}
-              placeholder="Ваш зашифрованный текст"
-              onChange={onChangeText}
-            />
-            {props.errorMessage && <Alarm type="error" text={`Ошибка! ${props.errorMessage}`} />}
-            <button onClick={onSubmit}>Расшифровать!</button>
-          </>
-        )}
-      </ContentBox>
-
-      {!props.errorMessage && props.decryptedData.text && (
-        <ContentBox title="Ваш результат">
-          <span>1) Открытый текст:</span>
-          <textarea value={props.decryptedData.text} onChange={() => {}} />
-        </ContentBox>
-      )}
-    </>
+    <ContentBox title="Расшифрование">
+      <Alarm type="news" text="Новинка: блочные шифры &#128522;!" />
+      <br />
+      <span>Доступные методы расшифрования:</span>
+      <ul>
+        {encryptLinks.map((link, index) => (
+          <li key={index}>
+            <div className={styles['tag']}>
+              <Tag link={link} />
+            </div>
+          </li>
+        ))}
+      </ul>
+    </ContentBox>
   );
-};
-
-const mapStateToProps = (state: AppState) => ({
-  method: state.decryptReducer.method,
-  decryptionKey: state.decryptReducer.decryptionKey,
-  encryptedText: state.decryptReducer.encryptedText,
-  errorMessage: state.decryptReducer.errorMessage,
-  decryptedData: state.decryptReducer.decryptedData,
-});
-
-export default connect(mapStateToProps, { setMethod, setText, setKey, setError, decryptData })(
-  Decrypt,
-);
+}
diff --git a/src/containers/Decrypt/decrypt.module.scss b/src/containers/Decrypt/decrypt.module.scss
new file mode 100644
index 0000000..080c758
--- /dev/null
+++ b/src/containers/Decrypt/decrypt.module.scss
@@ -0,0 +1,5 @@
+@import 'styles/_mixins.scss';
+
+.tag {
+  @include tag-space;
+}
diff --git a/src/containers/Encrypt/Encrypt.tsx b/src/containers/Encrypt/Encrypt.tsx
index 5fd2cec..db3cd69 100644
--- a/src/containers/Encrypt/Encrypt.tsx
+++ b/src/containers/Encrypt/Encrypt.tsx
@@ -13,7 +13,7 @@ const encryptLinks = [
 
 export default function() {
   return (
-    <ContentBox title="Блочное шифрование">
+    <ContentBox title="Шифрование">
       <Alarm type="news" text="Новинка: блочные шифры &#128522;!" />
       <br />
       <span>Доступные методы шифрования:</span>
diff --git a/src/containers/Encrypt/encrypt.module.scss b/src/containers/Encrypt/encrypt.module.scss
index fa32b84..080c758 100644
--- a/src/containers/Encrypt/encrypt.module.scss
+++ b/src/containers/Encrypt/encrypt.module.scss
@@ -1,5 +1,5 @@
-@import 'styles/_mods.scss';
+@import 'styles/_mixins.scss';
 
 .tag {
-  margin: $x1;
+  @include tag-space;
 }
diff --git a/src/containers/Home/home.module.scss b/src/containers/Home/home.module.scss
index fa32b84..080c758 100644
--- a/src/containers/Home/home.module.scss
+++ b/src/containers/Home/home.module.scss
@@ -1,5 +1,5 @@
-@import 'styles/_mods.scss';
+@import 'styles/_mixins.scss';
 
 .tag {
-  margin: $x1;
+  @include tag-space;
 }
diff --git a/src/styles/_mixins.scss b/src/styles/_mixins.scss
new file mode 100644
index 0000000..ba2369c
--- /dev/null
+++ b/src/styles/_mixins.scss
@@ -0,0 +1,5 @@
+@import 'styles/_mods.scss';
+
+@mixin tag-space {
+  margin: $x1;
+}

From 4c77eca1e9ee14ce6c4adb0c58e898362f233bd0 Mon Sep 17 00:00:00 2001
From: Denis Stasyev <denisstasyev@gmail.com>
Date: Thu, 12 Mar 2020 23:44:14 +0300
Subject: [PATCH 15/38] Start AES-256/ECB

---
 src/containers/Encrypt/Block/BlockEncrypt.tsx | 85 ++++++++++++++++++-
 src/libmethods/encryption/block/aes/index.ts  |  6 ++
 src/libmethods/encryption/block/index.ts      | 17 ++++
 src/libmethods/index.ts                       | 32 +++++--
 src/react-app-env.d.ts                        |  1 +
 5 files changed, 134 insertions(+), 7 deletions(-)
 create mode 100644 src/libmethods/encryption/block/aes/index.ts
 create mode 100644 src/libmethods/encryption/block/index.ts

diff --git a/src/containers/Encrypt/Block/BlockEncrypt.tsx b/src/containers/Encrypt/Block/BlockEncrypt.tsx
index 0a8ca1d..6476156 100644
--- a/src/containers/Encrypt/Block/BlockEncrypt.tsx
+++ b/src/containers/Encrypt/Block/BlockEncrypt.tsx
@@ -1,7 +1,90 @@
 import * as React from 'react';
 
 import { ContentBox } from 'components/ContentBox';
+import { Alarm } from 'components/Alarm';
+
+import { Method } from 'store';
+
+import { CIPHER_METHOD, ENCRYPTED_DATA } from 'config';
+
+import { blockEncryptionMethods } from 'libmethods';
+import { getEncryptedText } from 'libmethods/encryption/block';
 
 export default function() {
-  return <ContentBox title="Блочное шифрование">Block</ContentBox>;
+  const [method, setMethod] = React.useState<Method>(blockEncryptionMethods[0]);
+  const [key, setKey] = React.useState('');
+  const [plainText, setPlainText] = React.useState('');
+  const [error, setError] = React.useState('');
+  const [encryptedText, setEncryptedText] = React.useState('');
+
+  const onSubmit = (event: any) => {
+    event.preventDefault();
+    setError('');
+
+    if (key === '') {
+      setError('Введите ключ шифрования!');
+      return;
+    }
+
+    if (plainText === '') {
+      setError('Введите открытый текст!');
+      return;
+    }
+
+    setEncryptedText(getEncryptedText(method, key, plainText));
+  };
+
+  const getJSON = (method: Method, encryptedText: string) => {
+    let json = {
+      [CIPHER_METHOD]: method.name,
+      [ENCRYPTED_DATA]: encryptedText,
+    };
+    return JSON.stringify(json, undefined, 2);
+  };
+
+  return (
+    <>
+      <ContentBox title="Блочное шифрование">
+        <span>1) Выберите метод блочного шифрования:</span>
+        <select
+          value={method.type}
+          onChange={(event: any) =>
+            setMethod(
+              blockEncryptionMethods.find(method => method.type === event.target.value) ||
+                blockEncryptionMethods[0],
+            )
+          }
+        >
+          {blockEncryptionMethods.map((method, index) => (
+            <option value={method.type} key={index}>
+              {method.name}
+            </option>
+          ))}
+        </select>
+        <span>2) Введите ключ для шифрования:</span>
+        <textarea
+          value={key}
+          placeholder="Ваш ключ"
+          onChange={(event: any) => setKey(event.target.value)}
+        />
+        <span>2) Введите открытый текст, который хотите зашифровать:</span>
+        <textarea
+          value={plainText}
+          placeholder="Ваш открытый текст"
+          onChange={(event: any) => setPlainText(event.target.value)}
+        />
+        {error && <Alarm type="error" text={`Ошибка! ${error}`} />}
+        <button onClick={onSubmit}>Зашифровать!</button>
+      </ContentBox>
+
+      {!error && encryptedText && (
+        <ContentBox title="Ваш результат">
+          <span>1) Закрытый ключ:</span>
+          <textarea value={encryptedText} onChange={() => {}} />
+          <span>2) JSON для отправки закрытого текста на сервер:</span>
+          <textarea value={getJSON(method, encryptedText)} onChange={() => {}} />
+        </ContentBox>
+      )}
+    </>
+  );
 }
diff --git a/src/libmethods/encryption/block/aes/index.ts b/src/libmethods/encryption/block/aes/index.ts
new file mode 100644
index 0000000..852de4b
--- /dev/null
+++ b/src/libmethods/encryption/block/aes/index.ts
@@ -0,0 +1,6 @@
+// var AES = require("crypto-js/aes");
+// inport aesjs from 'aes-js';
+
+export function getAES256ECB(key: string, plainText: string): string {
+  return 'hello';
+}
diff --git a/src/libmethods/encryption/block/index.ts b/src/libmethods/encryption/block/index.ts
new file mode 100644
index 0000000..3485aa8
--- /dev/null
+++ b/src/libmethods/encryption/block/index.ts
@@ -0,0 +1,17 @@
+import { Method } from 'store';
+
+import { blockEncryptionTypes } from 'libmethods';
+
+import { getAES256ECB } from 'libmethods/encryption/block/aes';
+
+export function getEncryptedText(method: Method, key: string, plainText: string): string {
+  let encryptedText: string = '';
+
+  switch (method.type) {
+    case blockEncryptionTypes.aes256ecb:
+      encryptedText = getAES256ECB(key, plainText);
+      break;
+  }
+
+  return encryptedText;
+}
diff --git a/src/libmethods/index.ts b/src/libmethods/index.ts
index 91494b5..a90c393 100644
--- a/src/libmethods/index.ts
+++ b/src/libmethods/index.ts
@@ -1,5 +1,8 @@
 import { Method } from 'store';
 
+/**
+ * Basic encryption types and methods
+ */
 export const encryptionTypes = {
   caesar: 'caesar',
   monoalphabetic: 'monoalphabetic',
@@ -14,6 +17,20 @@ export const encryptionMethods: Method[] = [
   { type: encryptionTypes.bigram, name: 'Биграммный шифр' },
 ];
 
+/**
+ * Block encryption types and methods
+ */
+export const blockEncryptionTypes = {
+  aes256ecb: 'aes256ecb',
+};
+
+export const blockEncryptionMethods: Method[] = [
+  { type: blockEncryptionTypes.aes256ecb, name: 'AES-256/ECB' },
+];
+
+/**
+ * Checksum types and methods
+ */
 export const checksumTypes = {
   crc16: 'crc16',
   crc24: 'crc24',
@@ -22,12 +39,15 @@ export const checksumTypes = {
 };
 
 export const checksumMethods: Method[] = [
-  { type: checksumTypes.crc16, name: 'CRC16' },
-  { type: checksumTypes.crc24, name: 'CRC24' },
-  { type: checksumTypes.crc32, name: 'CRC32' },
+  { type: checksumTypes.crc16, name: 'CRC-16' },
+  { type: checksumTypes.crc24, name: 'CRC-24' },
+  { type: checksumTypes.crc32, name: 'CRC-32' },
   { type: checksumTypes.fletcher, name: 'Флетчер' },
 ];
 
+/**
+ * Hashing types and methods
+ */
 export const hashingTypes = {
   sha256: 'sha256',
   sha512: 'sha512',
@@ -35,9 +55,9 @@ export const hashingTypes = {
 };
 
 export const hashingMethods: Method[] = [
-  { type: hashingTypes.sha256, name: 'SHA256' },
-  { type: hashingTypes.sha512, name: 'SHA512' },
-  { type: hashingTypes.sha3, name: 'SHA3' },
+  { type: hashingTypes.sha256, name: 'SHA-256' },
+  { type: hashingTypes.sha512, name: 'SHA-512' },
+  { type: hashingTypes.sha3, name: 'SHA-3' },
 ];
 
 /**
diff --git a/src/react-app-env.d.ts b/src/react-app-env.d.ts
index 1ef3c3a..b372fde 100644
--- a/src/react-app-env.d.ts
+++ b/src/react-app-env.d.ts
@@ -2,6 +2,7 @@
 
 declare module 'crc';
 declare module 'fletcher';
+
 declare module 'crypto-js/sha256';
 declare module 'crypto-js/sha512';
 declare module 'crypto-js/sha3';

From aafb23a6d2bb2b0b04a1bda7516550fa6930fb97 Mon Sep 17 00:00:00 2001
From: Mikhail Pakhomov <mikhan333@mail.ru>
Date: Fri, 13 Mar 2020 00:35:30 +0300
Subject: [PATCH 16/38] Get caesar with any key

---
 src/containers/Decrypt/Basic/BasicDecrypt.tsx | 50 +++++++++++++++++--
 src/containers/Encrypt/Basic/BasicEncrypt.tsx | 37 ++++++++++++--
 .../encryption/basic/caesar/index.ts          |  5 +-
 3 files changed, 84 insertions(+), 8 deletions(-)

diff --git a/src/containers/Decrypt/Basic/BasicDecrypt.tsx b/src/containers/Decrypt/Basic/BasicDecrypt.tsx
index 3c260b6..3b8091f 100644
--- a/src/containers/Decrypt/Basic/BasicDecrypt.tsx
+++ b/src/containers/Decrypt/Basic/BasicDecrypt.tsx
@@ -11,6 +11,7 @@ import { DecryptState } from 'store/decrypt/types';
 import { setMethod, setKey, setText, setError, decryptData } from 'store/decrypt/actions';
 
 import { encryptionMethods, encryptionTypes } from 'libmethods';
+import { getSHA256 } from 'libmethods/hashing/sha256';
 
 import Base64 from 'utils/base64';
 
@@ -24,6 +25,7 @@ interface DecryptStateProps extends DecryptState {
 
 const Decrypt: React.SFC<DecryptStateProps> = props => {
   const [isJSONMode, setIsJSONMode] = React.useState(false);
+  const [caesarVariant, setCaesarVariant] = React.useState(false);
 
   const onChangeMethod = (event: any) => {
     event.preventDefault();
@@ -53,7 +55,11 @@ const Decrypt: React.SFC<DecryptStateProps> = props => {
   const onChangeKey = (event: any) => {
     event.preventDefault();
 
-    if (props.method.type === encryptionTypes.caesar && event.target.value !== '') {
+    if (
+      props.method.type === encryptionTypes.caesar &&
+      event.target.value !== '' &&
+      caesarVariant
+    ) {
       if (event.target.value === parseInt(event.target.value).toString()) {
         props.setKey(event.target.value);
         clearError();
@@ -76,7 +82,16 @@ const Decrypt: React.SFC<DecryptStateProps> = props => {
       props.setError('Введите текст, который необходимо расшифровать!');
       return;
     }
-    props.decryptData(props.method, props.encryptedText, props.decryptionKey);
+
+    if (props.method.type === encryptionTypes.caesar && !caesarVariant) {
+      props.decryptData(
+        props.method,
+        props.encryptedText,
+        getSHA256(props.decryptionKey)[0].toString(),
+      );
+    } else {
+      props.decryptData(props.method, props.encryptedText, props.decryptionKey);
+    }
   };
 
   const onChangeJSON = (event: any) => {
@@ -134,14 +149,26 @@ const Decrypt: React.SFC<DecryptStateProps> = props => {
       return;
     }
 
-    props.decryptData(props.method, props.encryptedText, props.decryptionKey);
+    if (props.method.type === encryptionTypes.caesar) {
+      props.decryptData(
+        props.method,
+        props.encryptedText,
+        getSHA256(props.decryptionKey)[0].toString(),
+      );
+    } else {
+      props.decryptData(props.method, props.encryptedText, props.decryptionKey);
+    }
   };
 
   return (
     <>
       <ContentBox title="Расшифрование">
         <span>0) Выберите режим расшифрования:</span>
-        <button onClick={() => setIsJSONMode(!isJSONMode)}>
+        <button
+          onClick={() => {
+            setIsJSONMode(!isJSONMode);
+          }}
+        >
           {isJSONMode ? 'Перейти в обычный режим' : 'Расшифровать JSON'}
         </button>
         {isJSONMode ? (
@@ -168,6 +195,21 @@ const Decrypt: React.SFC<DecryptStateProps> = props => {
                 </option>
               ))}
             </select>
+            <span>
+              {props.method.type === encryptionTypes.caesar && (
+                <div>
+                  1.1) Использовать обычный сдвиг (без хеширования)
+                  <input
+                    type="checkbox"
+                    checked={caesarVariant}
+                    onChange={() => {
+                      setCaesarVariant(!caesarVariant);
+                      props.setKey('');
+                    }}
+                  />
+                </div>
+              )}
+            </span>
             <span>2) Введите ключ:</span>
             <input
               value={props.decryptionKey}
diff --git a/src/containers/Encrypt/Basic/BasicEncrypt.tsx b/src/containers/Encrypt/Basic/BasicEncrypt.tsx
index b7b544c..f539312 100644
--- a/src/containers/Encrypt/Basic/BasicEncrypt.tsx
+++ b/src/containers/Encrypt/Basic/BasicEncrypt.tsx
@@ -11,6 +11,7 @@ import { EncryptState } from 'store/encrypt/types';
 import { setMethod, setKey, setText, setError, encryptData } from 'store/encrypt/actions';
 
 import { encryptionMethods, encryptionTypes } from 'libmethods';
+import { getSHA256 } from 'libmethods/hashing/sha256';
 
 import Base64 from 'utils/base64';
 
@@ -23,6 +24,8 @@ interface EncryptStateProps extends EncryptState {
 }
 
 const Encrypt: React.SFC<EncryptStateProps> = props => {
+  const [caesarVariant, setCaesarVariant] = React.useState(false);
+
   const onChangeMethod = (event: any) => {
     event.preventDefault();
     const method: Method =
@@ -51,7 +54,11 @@ const Encrypt: React.SFC<EncryptStateProps> = props => {
   const onChangeKey = (event: any) => {
     event.preventDefault();
 
-    if (props.method.type === encryptionTypes.caesar && event.target.value !== '') {
+    if (
+      props.method.type === encryptionTypes.caesar &&
+      event.target.value !== '' &&
+      caesarVariant
+    ) {
       if (event.target.value === parseInt(event.target.value).toString()) {
         props.setKey(event.target.value);
         clearError();
@@ -74,7 +81,16 @@ const Encrypt: React.SFC<EncryptStateProps> = props => {
       props.setError('Введите текст, который необходимо зашифровать!');
       return;
     }
-    props.encryptData(props.method, props.plainText, props.encryptionKey);
+
+    if (props.method.type === encryptionTypes.caesar && !caesarVariant) {
+      props.encryptData(
+        props.method,
+        props.plainText,
+        getSHA256(props.encryptionKey)[0].toString(),
+      );
+    } else {
+      props.encryptData(props.method, props.plainText, props.encryptionKey);
+    }
   };
 
   const getJSON = (methodName: string, encryptedCode: number[], encryptedText: string) => {
@@ -90,7 +106,7 @@ const Encrypt: React.SFC<EncryptStateProps> = props => {
   return (
     <>
       <ContentBox title="Шифрование">
-        <span>1) Выберите метод для шифрования:</span>
+        <span>1) Выберите метод для шифрования: </span>
         <select value={props.method.type} onChange={onChangeMethod}>
           {encryptionMethods.map((method, index) => (
             <option value={method.type} key={index}>
@@ -98,6 +114,21 @@ const Encrypt: React.SFC<EncryptStateProps> = props => {
             </option>
           ))}
         </select>
+        <span>
+          {props.method.type === encryptionTypes.caesar && (
+            <div>
+              1.1) Использовать обычный сдвиг (без хеширования)
+              <input
+                type="checkbox"
+                checked={caesarVariant}
+                onChange={() => {
+                  setCaesarVariant(!caesarVariant);
+                  props.setKey('');
+                }}
+              />
+            </div>
+          )}
+        </span>
         <span>2) Введите ключ:</span>
         <input
           value={props.encryptionKey}
diff --git a/src/libmethods/encryption/basic/caesar/index.ts b/src/libmethods/encryption/basic/caesar/index.ts
index 2882304..1cd5090 100644
--- a/src/libmethods/encryption/basic/caesar/index.ts
+++ b/src/libmethods/encryption/basic/caesar/index.ts
@@ -37,6 +37,9 @@ export function encryptCesar(text: string, key: number): EncryptedData {
  * @returns    Clear data
  */
 export function decryptCesar(text: string, key: number): EncryptedData {
-  const plainData: EncryptedData = encryptCesar(text, UNICODE_RING_SIZE - key);
+  const plainData: EncryptedData = encryptCesar(
+    text,
+    (-key % UNICODE_RING_SIZE) + UNICODE_RING_SIZE,
+  );
   return plainData;
 }

From 99b0cf7c6e076ed1e20cd9cc6a122e3e4035293e Mon Sep 17 00:00:00 2001
From: Denis Stasyev <denisstasyev@gmail.com>
Date: Fri, 13 Mar 2020 22:50:39 +0300
Subject: [PATCH 17/38] Add AES256_ECB encryption

---
 src/containers/Decrypt/Basic/BasicDecrypt.tsx |  1 +
 src/containers/Encrypt/Block/BlockEncrypt.tsx | 12 ++++--
 src/libmethods/encryption/block/aes/index.ts  | 39 +++++++++++++++++--
 src/libmethods/encryption/block/index.ts      | 23 +++++++++--
 src/react-app-env.d.ts                        |  3 +-
 5 files changed, 66 insertions(+), 12 deletions(-)

diff --git a/src/containers/Decrypt/Basic/BasicDecrypt.tsx b/src/containers/Decrypt/Basic/BasicDecrypt.tsx
index 3b8091f..b5aedea 100644
--- a/src/containers/Decrypt/Basic/BasicDecrypt.tsx
+++ b/src/containers/Decrypt/Basic/BasicDecrypt.tsx
@@ -166,6 +166,7 @@ const Decrypt: React.SFC<DecryptStateProps> = props => {
         <span>0) Выберите режим расшифрования:</span>
         <button
           onClick={() => {
+            clearError();
             setIsJSONMode(!isJSONMode);
           }}
         >
diff --git a/src/containers/Encrypt/Block/BlockEncrypt.tsx b/src/containers/Encrypt/Block/BlockEncrypt.tsx
index 6476156..c269475 100644
--- a/src/containers/Encrypt/Block/BlockEncrypt.tsx
+++ b/src/containers/Encrypt/Block/BlockEncrypt.tsx
@@ -5,14 +5,17 @@ import { Alarm } from 'components/Alarm';
 
 import { Method } from 'store';
 
-import { CIPHER_METHOD, ENCRYPTED_DATA } from 'config';
+import { CIPHER_METHOD, ENCRYPTED_DATA, ENCRYPTED_DATA_BASE64 } from 'config';
 
 import { blockEncryptionMethods } from 'libmethods';
 import { getEncryptedText } from 'libmethods/encryption/block';
 
+import Base64 from 'utils/base64';
+
 export default function() {
   const [method, setMethod] = React.useState<Method>(blockEncryptionMethods[0]);
   const [key, setKey] = React.useState('');
+  // const [iv, set] = React.useState('');
   const [plainText, setPlainText] = React.useState('');
   const [error, setError] = React.useState('');
   const [encryptedText, setEncryptedText] = React.useState('');
@@ -31,13 +34,14 @@ export default function() {
       return;
     }
 
-    setEncryptedText(getEncryptedText(method, key, plainText));
+    setEncryptedText(getEncryptedText(method, key, plainText, ''));
   };
 
   const getJSON = (method: Method, encryptedText: string) => {
     let json = {
       [CIPHER_METHOD]: method.name,
       [ENCRYPTED_DATA]: encryptedText,
+      [ENCRYPTED_DATA_BASE64]: Base64.encode(encryptedText),
     };
     return JSON.stringify(json, undefined, 2);
   };
@@ -62,7 +66,7 @@ export default function() {
           ))}
         </select>
         <span>2) Введите ключ для шифрования:</span>
-        <textarea
+        <input
           value={key}
           placeholder="Ваш ключ"
           onChange={(event: any) => setKey(event.target.value)}
@@ -79,7 +83,7 @@ export default function() {
 
       {!error && encryptedText && (
         <ContentBox title="Ваш результат">
-          <span>1) Закрытый ключ:</span>
+          <span>1) Закрытый текст:</span>
           <textarea value={encryptedText} onChange={() => {}} />
           <span>2) JSON для отправки закрытого текста на сервер:</span>
           <textarea value={getJSON(method, encryptedText)} onChange={() => {}} />
diff --git a/src/libmethods/encryption/block/aes/index.ts b/src/libmethods/encryption/block/aes/index.ts
index 852de4b..a2245f5 100644
--- a/src/libmethods/encryption/block/aes/index.ts
+++ b/src/libmethods/encryption/block/aes/index.ts
@@ -1,6 +1,37 @@
-// var AES = require("crypto-js/aes");
-// inport aesjs from 'aes-js';
+import aesjs from 'aes-js';
 
-export function getAES256ECB(key: string, plainText: string): string {
-  return 'hello';
+export function encryptAES256_ECB(key: number[], plainText: string): string {
+  // Test convert text to bytes to detect rest
+  const testTextBytes = aesjs.utils.utf8.toBytes(plainText);
+
+  // Create text with length is a multiple of 16 Byte (with spaces at the end)
+  const rest16bytesLength: number = 16 - (testTextBytes.length % 16);
+  const fixedText = plainText + new Array(rest16bytesLength + 1).join(' ');
+
+  // Main convert text to bytes
+  const textBytes = aesjs.utils.utf8.toBytes(fixedText);
+
+  const aesEcb = new aesjs.ModeOfOperation.ecb(key);
+  const encryptedBytes = aesEcb.encrypt(textBytes);
+  const encryptedHex = aesjs.utils.hex.fromBytes(encryptedBytes);
+
+  return encryptedHex;
 }
+
+// // To print or store the binary data, you may convert it to hex
+// var encryptedHex = aesjs.utils.hex.fromBytes(encryptedBytes);
+// console.log(encryptedHex);
+// // "a7d93b35368519fac347498dec18b458"
+
+// // When ready to decrypt the hex string, convert it back to bytes
+// var encryptedBytes = aesjs.utils.hex.toBytes(encryptedHex);
+
+// // Since electronic codebook does not store state, we can
+// // reuse the same instance.
+// //var aesEcb = new aesjs.ModeOfOperation.ecb(key);
+// var decryptedBytes = aesEcb.decrypt(encryptedBytes);
+
+// // Convert our bytes back into text
+// var decryptedText = aesjs.utils.utf8.fromBytes(decryptedBytes);
+// console.log(decryptedText);
+// // "TextMustBe16Byte"
diff --git a/src/libmethods/encryption/block/index.ts b/src/libmethods/encryption/block/index.ts
index 3485aa8..66b73e0 100644
--- a/src/libmethods/encryption/block/index.ts
+++ b/src/libmethods/encryption/block/index.ts
@@ -2,14 +2,31 @@ import { Method } from 'store';
 
 import { blockEncryptionTypes } from 'libmethods';
 
-import { getAES256ECB } from 'libmethods/encryption/block/aes';
+import { getSHA256 } from 'libmethods/hashing/sha256';
+import { toHexFormat } from 'libmethods/hashing';
+
+import { encryptAES256_ECB } from 'libmethods/encryption/block/aes';
+
+export function getEncryptedText(
+  method: Method,
+  key: string,
+  plainText: string,
+  iv: string, // iv - initialization vector
+): string {
+  /**  Convert string key into Array of 4 elements with 128 bit size.
+   * Then it is converted into hex string and parsed into hex Array of 16 elements with 2 characters.
+   * Finally parse it into Array of 16 Numbers.
+   */
+  const key_128bit_4elements: number[] = getSHA256(key).slice(0, 4);
+  // @ts-ignore
+  const keyNormalizedHexes: string[] = toHexFormat(key_128bit_4elements).match(/.{1,2}/g) || [];
+  const keyNormalized: number[] = keyNormalizedHexes.map(keyHex => parseInt(keyHex, 16));
 
-export function getEncryptedText(method: Method, key: string, plainText: string): string {
   let encryptedText: string = '';
 
   switch (method.type) {
     case blockEncryptionTypes.aes256ecb:
-      encryptedText = getAES256ECB(key, plainText);
+      encryptedText = encryptAES256_ECB(keyNormalized, plainText);
       break;
   }
 
diff --git a/src/react-app-env.d.ts b/src/react-app-env.d.ts
index b372fde..9548f02 100644
--- a/src/react-app-env.d.ts
+++ b/src/react-app-env.d.ts
@@ -6,4 +6,5 @@ declare module 'fletcher';
 declare module 'crypto-js/sha256';
 declare module 'crypto-js/sha512';
 declare module 'crypto-js/sha3';
-// declare module 'aes-js';
+
+declare module 'aes-js';

From 543f0ec3f90e08e8cf838769108dd0cfaa7b065b Mon Sep 17 00:00:00 2001
From: Denis Stasyev <denisstasyev@gmail.com>
Date: Fri, 13 Mar 2020 23:17:22 +0300
Subject: [PATCH 18/38] Create initial BlockDecrypt

---
 src/containers/Decrypt/Block/BlockDecrypt.tsx | 74 ++++++++++++++++++-
 src/containers/Encrypt/Block/BlockEncrypt.tsx |  2 +-
 src/libmethods/encryption/block/aes/index.ts  |  3 +
 src/libmethods/encryption/block/index.ts      | 42 ++++++++---
 4 files changed, 108 insertions(+), 13 deletions(-)

diff --git a/src/containers/Decrypt/Block/BlockDecrypt.tsx b/src/containers/Decrypt/Block/BlockDecrypt.tsx
index 5d367b0..7d38595 100644
--- a/src/containers/Decrypt/Block/BlockDecrypt.tsx
+++ b/src/containers/Decrypt/Block/BlockDecrypt.tsx
@@ -1,7 +1,79 @@
 import * as React from 'react';
 
 import { ContentBox } from 'components/ContentBox';
+import { Alarm } from 'components/Alarm';
+
+import { Method } from 'store';
+
+import { blockEncryptionMethods } from 'libmethods';
+import { getDecryptedText } from 'libmethods/encryption/block';
 
 export default function() {
-  return <ContentBox title="Блочное расшифрование">Block</ContentBox>;
+  const [method, setMethod] = React.useState<Method>(blockEncryptionMethods[0]);
+  const [key, setKey] = React.useState('');
+  // const [iv, set] = React.useState('');
+  const [encryptedText, setEncryptedText] = React.useState('');
+  const [error, setError] = React.useState('');
+  const [decryptedText, setDecryptedText] = React.useState('');
+
+  const onSubmit = (event: any) => {
+    event.preventDefault();
+    setError('');
+
+    if (key === '') {
+      setError('Введите ключ расшифрования!');
+      return;
+    }
+
+    if (encryptedText === '') {
+      setError('Введите закрытый текст!');
+      return;
+    }
+
+    setDecryptedText(getDecryptedText(method, key, encryptedText, ''));
+  };
+
+  return (
+    <>
+      <ContentBox title="Блочное расшифрование">
+        <span>1) Выберите метод блочного расшифрования:</span>
+        <select
+          value={method.type}
+          onChange={(event: any) =>
+            setMethod(
+              blockEncryptionMethods.find(method => method.type === event.target.value) ||
+                blockEncryptionMethods[0],
+            )
+          }
+        >
+          {blockEncryptionMethods.map((method, index) => (
+            <option value={method.type} key={index}>
+              {method.name}
+            </option>
+          ))}
+        </select>
+        <span>2) Введите ключ для расшифрования:</span>
+        <input
+          value={key}
+          placeholder="Ваш ключ"
+          onChange={(event: any) => setKey(event.target.value)}
+        />
+        <span>3) Введите закрытый текст, который хотите расшифровать:</span>
+        <textarea
+          value={encryptedText}
+          placeholder="Ваш закрытый текст"
+          onChange={(event: any) => setEncryptedText(event.target.value)}
+        />
+        {error && <Alarm type="error" text={`Ошибка! ${error}`} />}
+        <button onClick={onSubmit}>Расшифровать!</button>
+      </ContentBox>
+
+      {!error && encryptedText && (
+        <ContentBox title="Ваш результат">
+          <span>1) Открытый текст:</span>
+          <textarea value={decryptedText} onChange={() => {}} />
+        </ContentBox>
+      )}
+    </>
+  );
 }
diff --git a/src/containers/Encrypt/Block/BlockEncrypt.tsx b/src/containers/Encrypt/Block/BlockEncrypt.tsx
index c269475..fdf9110 100644
--- a/src/containers/Encrypt/Block/BlockEncrypt.tsx
+++ b/src/containers/Encrypt/Block/BlockEncrypt.tsx
@@ -71,7 +71,7 @@ export default function() {
           placeholder="Ваш ключ"
           onChange={(event: any) => setKey(event.target.value)}
         />
-        <span>2) Введите открытый текст, который хотите зашифровать:</span>
+        <span>3) Введите открытый текст, который хотите зашифровать:</span>
         <textarea
           value={plainText}
           placeholder="Ваш открытый текст"
diff --git a/src/libmethods/encryption/block/aes/index.ts b/src/libmethods/encryption/block/aes/index.ts
index a2245f5..f96dfa6 100644
--- a/src/libmethods/encryption/block/aes/index.ts
+++ b/src/libmethods/encryption/block/aes/index.ts
@@ -18,6 +18,9 @@ export function encryptAES256_ECB(key: number[], plainText: string): string {
   return encryptedHex;
 }
 
+export function decryptAES256_ECB(key: number[], encryptedText: string): string {
+  return 'hello';
+}
 // // To print or store the binary data, you may convert it to hex
 // var encryptedHex = aesjs.utils.hex.fromBytes(encryptedBytes);
 // console.log(encryptedHex);
diff --git a/src/libmethods/encryption/block/index.ts b/src/libmethods/encryption/block/index.ts
index 66b73e0..ff847a1 100644
--- a/src/libmethods/encryption/block/index.ts
+++ b/src/libmethods/encryption/block/index.ts
@@ -5,7 +5,19 @@ import { blockEncryptionTypes } from 'libmethods';
 import { getSHA256 } from 'libmethods/hashing/sha256';
 import { toHexFormat } from 'libmethods/hashing';
 
-import { encryptAES256_ECB } from 'libmethods/encryption/block/aes';
+import { encryptAES256_ECB, decryptAES256_ECB } from 'libmethods/encryption/block/aes';
+
+/**  Convert string key into Array of 4 elements with 128 bit size.
+ * Then it is converted into hex string and parsed into hex Array of 16 elements with 2 characters.
+ * Finally parse it into Array of 16 Numbers.
+ */
+function getNormalizedKey(key: string): number[] {
+  const key_128bit_4elements: number[] = getSHA256(key).slice(0, 4);
+  // @ts-ignore
+  const keyNormalizedHexes: string[] = toHexFormat(key_128bit_4elements).match(/.{1,2}/g) || [];
+  const keyNormalized: number[] = keyNormalizedHexes.map(keyHex => parseInt(keyHex, 16));
+  return keyNormalized;
+}
 
 export function getEncryptedText(
   method: Method,
@@ -13,22 +25,30 @@ export function getEncryptedText(
   plainText: string,
   iv: string, // iv - initialization vector
 ): string {
-  /**  Convert string key into Array of 4 elements with 128 bit size.
-   * Then it is converted into hex string and parsed into hex Array of 16 elements with 2 characters.
-   * Finally parse it into Array of 16 Numbers.
-   */
-  const key_128bit_4elements: number[] = getSHA256(key).slice(0, 4);
-  // @ts-ignore
-  const keyNormalizedHexes: string[] = toHexFormat(key_128bit_4elements).match(/.{1,2}/g) || [];
-  const keyNormalized: number[] = keyNormalizedHexes.map(keyHex => parseInt(keyHex, 16));
-
   let encryptedText: string = '';
 
   switch (method.type) {
     case blockEncryptionTypes.aes256ecb:
-      encryptedText = encryptAES256_ECB(keyNormalized, plainText);
+      encryptedText = encryptAES256_ECB(getNormalizedKey(key), plainText);
       break;
   }
 
   return encryptedText;
 }
+
+export function getDecryptedText(
+  method: Method,
+  key: string,
+  encryptedText: string,
+  iv: string, // iv - initialization vector
+): string {
+  let decryptedText: string = '';
+
+  switch (method.type) {
+    case blockEncryptionTypes.aes256ecb:
+      encryptedText = decryptAES256_ECB(getNormalizedKey(key), encryptedText);
+      break;
+  }
+
+  return decryptedText;
+}

From 396acccd2a2c3e19cdf8006ddbffaee1571383b9 Mon Sep 17 00:00:00 2001
From: Denis Stasyev <denisstasyev@gmail.com>
Date: Sat, 14 Mar 2020 13:57:33 +0300
Subject: [PATCH 19/38] Start JSON mode for BlockDecrypt

---
 src/containers/Decrypt/Block/BlockDecrypt.tsx | 98 +++++++++++++------
 src/libmethods/encryption/block/index.ts      |  2 +-
 src/styles/_global.scss                       | 13 ++-
 src/styles/_mixins.scss                       |  8 +-
 4 files changed, 88 insertions(+), 33 deletions(-)

diff --git a/src/containers/Decrypt/Block/BlockDecrypt.tsx b/src/containers/Decrypt/Block/BlockDecrypt.tsx
index 7d38595..788676c 100644
--- a/src/containers/Decrypt/Block/BlockDecrypt.tsx
+++ b/src/containers/Decrypt/Block/BlockDecrypt.tsx
@@ -9,6 +9,9 @@ import { blockEncryptionMethods } from 'libmethods';
 import { getDecryptedText } from 'libmethods/encryption/block';
 
 export default function() {
+  const [jsonMode, setJsonMode] = React.useState(false);
+  const [json, setJson] = React.useState('');
+
   const [method, setMethod] = React.useState<Method>(blockEncryptionMethods[0]);
   const [key, setKey] = React.useState('');
   // const [iv, set] = React.useState('');
@@ -33,42 +36,77 @@ export default function() {
     setDecryptedText(getDecryptedText(method, key, encryptedText, ''));
   };
 
+  const onSubmitJson = (event: any) => {};
+
   return (
     <>
       <ContentBox title="Блочное расшифрование">
-        <span>1) Выберите метод блочного расшифрования:</span>
-        <select
-          value={method.type}
-          onChange={(event: any) =>
-            setMethod(
-              blockEncryptionMethods.find(method => method.type === event.target.value) ||
-                blockEncryptionMethods[0],
-            )
-          }
+        <span>0) Выберите решим расшифрования:</span>
+        <button
+          onClick={() => {
+            setJsonMode(!jsonMode);
+            setError('');
+            setDecryptedText('');
+          }}
         >
-          {blockEncryptionMethods.map((method, index) => (
-            <option value={method.type} key={index}>
-              {method.name}
-            </option>
-          ))}
-        </select>
-        <span>2) Введите ключ для расшифрования:</span>
-        <input
-          value={key}
-          placeholder="Ваш ключ"
-          onChange={(event: any) => setKey(event.target.value)}
-        />
-        <span>3) Введите закрытый текст, который хотите расшифровать:</span>
-        <textarea
-          value={encryptedText}
-          placeholder="Ваш закрытый текст"
-          onChange={(event: any) => setEncryptedText(event.target.value)}
-        />
-        {error && <Alarm type="error" text={`Ошибка! ${error}`} />}
-        <button onClick={onSubmit}>Расшифровать!</button>
+          {jsonMode
+            ? 'Перейти в режим обычного расшифрования'
+            : 'Перейти в режим расшифрования JSON'}
+        </button>
+        {jsonMode ? (
+          <>
+            <span>1) Введите JSON для блочного расшифрования:</span>
+            <textarea
+              value={json}
+              placeholder="Ваш JSON для расшифрования"
+              onChange={(event: any) => setJson(event.target.value)}
+            />
+            <span>2) Введите ключ для блочного расшифрования:</span>
+            <input
+              value={key}
+              placeholder="Ваш ключ"
+              onChange={(event: any) => setKey(event.target.value)}
+            />
+            {error && <Alarm type="error" text={`Ошибка! ${error}`} />}
+            <button onClick={onSubmitJson}>Расшифровать!</button>
+          </>
+        ) : (
+          <>
+            <span>1) Выберите метод блочного расшифрования:</span>
+            <select
+              value={method.type}
+              onChange={(event: any) =>
+                setMethod(
+                  blockEncryptionMethods.find(method => method.type === event.target.value) ||
+                    blockEncryptionMethods[0],
+                )
+              }
+            >
+              {blockEncryptionMethods.map((method, index) => (
+                <option value={method.type} key={index}>
+                  {method.name}
+                </option>
+              ))}
+            </select>
+            <span>2) Введите ключ для расшифрования:</span>
+            <input
+              value={key}
+              placeholder="Ваш ключ"
+              onChange={(event: any) => setKey(event.target.value)}
+            />
+            <span>3) Введите закрытый текст, который хотите расшифровать:</span>
+            <textarea
+              value={encryptedText}
+              placeholder="Ваш закрытый текст"
+              onChange={(event: any) => setEncryptedText(event.target.value)}
+            />
+            {error && <Alarm type="error" text={`Ошибка! ${error}`} />}
+            <button onClick={onSubmit}>Расшифровать!</button>
+          </>
+        )}
       </ContentBox>
 
-      {!error && encryptedText && (
+      {!error && decryptedText && (
         <ContentBox title="Ваш результат">
           <span>1) Открытый текст:</span>
           <textarea value={decryptedText} onChange={() => {}} />
diff --git a/src/libmethods/encryption/block/index.ts b/src/libmethods/encryption/block/index.ts
index ff847a1..38dfdba 100644
--- a/src/libmethods/encryption/block/index.ts
+++ b/src/libmethods/encryption/block/index.ts
@@ -46,7 +46,7 @@ export function getDecryptedText(
 
   switch (method.type) {
     case blockEncryptionTypes.aes256ecb:
-      encryptedText = decryptAES256_ECB(getNormalizedKey(key), encryptedText);
+      decryptedText = decryptAES256_ECB(getNormalizedKey(key), encryptedText);
       break;
   }
 
diff --git a/src/styles/_global.scss b/src/styles/_global.scss
index e24a34f..d7d76f7 100644
--- a/src/styles/_global.scss
+++ b/src/styles/_global.scss
@@ -1,4 +1,5 @@
 @import 'styles/_mods.scss';
+@import 'styles/_mixins.scss';
 
 body {
   margin: 0;
@@ -33,6 +34,14 @@ textarea {
   font-size: 1em;
 }
 
+select,
+input,
+textarea {
+  border: $border-secondary;
+  border-radius: $x2;
+  padding: $x1;
+}
+
 select {
   width: auto;
 }
@@ -42,10 +51,12 @@ textarea {
   max-width: 99vw;
   height: 2 * $x20;
   border: $border-secondary;
+
+  resize: vertical;
 }
 
 button {
-  white-space: nowrap;
+  @include text-ellipsis;
 
   font: inherit;
 
diff --git a/src/styles/_mixins.scss b/src/styles/_mixins.scss
index ba2369c..ed17570 100644
--- a/src/styles/_mixins.scss
+++ b/src/styles/_mixins.scss
@@ -1,5 +1,11 @@
 @import 'styles/_mods.scss';
 
-@mixin tag-space {
+@mixin tag-space() {
   margin: $x1;
 }
+
+@mixin text-ellipsis() {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}

From c019886a727c18126c2f72c3e79c2039608bcd6f Mon Sep 17 00:00:00 2001
From: Denis Stasyev <denisstasyev@gmail.com>
Date: Sun, 15 Mar 2020 11:07:33 +0300
Subject: [PATCH 20/38] Finish JSON BlockDecrypt

---
 src/containers/Decrypt/Basic/BasicDecrypt.tsx | 10 ++-
 src/containers/Decrypt/Block/BlockDecrypt.tsx | 67 +++++++++++++++++--
 src/styles/_global.scss                       |  1 +
 3 files changed, 67 insertions(+), 11 deletions(-)

diff --git a/src/containers/Decrypt/Basic/BasicDecrypt.tsx b/src/containers/Decrypt/Basic/BasicDecrypt.tsx
index b5aedea..58db085 100644
--- a/src/containers/Decrypt/Basic/BasicDecrypt.tsx
+++ b/src/containers/Decrypt/Basic/BasicDecrypt.tsx
@@ -107,9 +107,8 @@ const Decrypt: React.SFC<DecryptStateProps> = props => {
       props.setError('JSON не валидный!');
     }
 
-    const methodName =
-      // @ts-ignore
-      objectJSON[CIPHER_METHOD] === undefined ? '' : objectJSON[CIPHER_METHOD];
+    // @ts-ignore
+    const methodName = objectJSON[CIPHER_METHOD] === undefined ? '' : objectJSON[CIPHER_METHOD];
     const method: Method = encryptionMethods.find(method => method.name === methodName) || {
       name: '',
       type: '',
@@ -119,9 +118,8 @@ const Decrypt: React.SFC<DecryptStateProps> = props => {
     let encryptedText: string = '';
     // @ts-ignore
     if (objectJSON[ENCRYPTED_DATA_BASE64] === undefined) {
-      encryptedText =
-        // @ts-ignore
-        objectJSON[ENCRYPTED_DATA] === undefined ? '' : objectJSON[ENCRYPTED_DATA];
+      // @ts-ignore
+      encryptedText = objectJSON[ENCRYPTED_DATA] === undefined ? '' : objectJSON[ENCRYPTED_DATA];
     } else {
       // @ts-ignore
       encryptedText = Base64.decode(objectJSON[ENCRYPTED_DATA_BASE64]);
diff --git a/src/containers/Decrypt/Block/BlockDecrypt.tsx b/src/containers/Decrypt/Block/BlockDecrypt.tsx
index 788676c..0c5821f 100644
--- a/src/containers/Decrypt/Block/BlockDecrypt.tsx
+++ b/src/containers/Decrypt/Block/BlockDecrypt.tsx
@@ -5,11 +5,15 @@ import { Alarm } from 'components/Alarm';
 
 import { Method } from 'store';
 
+import { CIPHER_METHOD, ENCRYPTED_DATA, ENCRYPTED_DATA_BASE64 } from 'config';
+
 import { blockEncryptionMethods } from 'libmethods';
 import { getDecryptedText } from 'libmethods/encryption/block';
 
+import Base64 from 'utils/base64';
+
 export default function() {
-  const [jsonMode, setJsonMode] = React.useState(false);
+  const [isJsonMode, setIsJsonMode] = React.useState(false);
   const [json, setJson] = React.useState('');
 
   const [method, setMethod] = React.useState<Method>(blockEncryptionMethods[0]);
@@ -36,7 +40,60 @@ export default function() {
     setDecryptedText(getDecryptedText(method, key, encryptedText, ''));
   };
 
-  const onSubmitJson = (event: any) => {};
+  const parseJson = (json: string) => {
+    let objectJson = {};
+
+    try {
+      objectJson = JSON.parse(json);
+    } catch (e) {
+      setError('JSON не валидный!');
+    }
+
+    // @ts-ignore
+    const methodName = objectJson[CIPHER_METHOD] === undefined ? '' : objectJson[CIPHER_METHOD];
+    const method: Method = blockEncryptionMethods.find(method => method.name === methodName) || {
+      name: '',
+      type: '',
+    };
+    setMethod(method);
+
+    let encryptedText: string = '';
+    // @ts-ignore
+    if (objectJson[ENCRYPTED_DATA_BASE64] === undefined) {
+      // @ts-ignore
+      encryptedText = objectJson[ENCRYPTED_DATA] === undefined ? '' : objectJson[ENCRYPTED_DATA];
+    } else {
+      // @ts-ignore
+      encryptedText = Base64.decode(objectJson[ENCRYPTED_DATA_BASE64]);
+    }
+    setEncryptedText(encryptedText);
+  };
+
+  const onSubmitJson = (event: any) => {
+    event.preventDefault();
+    setError('');
+
+    parseJson(json);
+
+    if (key === '') {
+      setError('Введите ключ расшифрования!');
+      return;
+    }
+
+    if (method.name === '') {
+      setError(`Введите метод шифрования в JSON (свойство: ${CIPHER_METHOD})!`);
+      return;
+    }
+
+    if (encryptedText === '') {
+      setError(
+        `Введите текст в JSON, который необходимо расшифровать (свойство: ${ENCRYPTED_DATA})!`,
+      );
+      return;
+    }
+
+    setDecryptedText(getDecryptedText(method, key, encryptedText, ''));
+  };
 
   return (
     <>
@@ -44,16 +101,16 @@ export default function() {
         <span>0) Выберите решим расшифрования:</span>
         <button
           onClick={() => {
-            setJsonMode(!jsonMode);
+            setIsJsonMode(!isJsonMode);
             setError('');
             setDecryptedText('');
           }}
         >
-          {jsonMode
+          {isJsonMode
             ? 'Перейти в режим обычного расшифрования'
             : 'Перейти в режим расшифрования JSON'}
         </button>
-        {jsonMode ? (
+        {isJsonMode ? (
           <>
             <span>1) Введите JSON для блочного расшифрования:</span>
             <textarea
diff --git a/src/styles/_global.scss b/src/styles/_global.scss
index d7d76f7..ffdbe8e 100644
--- a/src/styles/_global.scss
+++ b/src/styles/_global.scss
@@ -53,6 +53,7 @@ textarea {
   border: $border-secondary;
 
   resize: vertical;
+  overflow: auto;
 }
 
 button {

From 505fce4141ad9a5524c904ed87cb6050330047af Mon Sep 17 00:00:00 2001
From: Denis Stasyev <denisstasyev@gmail.com>
Date: Sun, 15 Mar 2020 12:00:42 +0300
Subject: [PATCH 21/38] Add decryptAES256_ECB without Emoji support

---
 src/containers/Decrypt/Block/BlockDecrypt.tsx |  5 ++--
 src/libmethods/encryption/block/aes/index.ts  | 28 +++++++------------
 2 files changed, 12 insertions(+), 21 deletions(-)

diff --git a/src/containers/Decrypt/Block/BlockDecrypt.tsx b/src/containers/Decrypt/Block/BlockDecrypt.tsx
index 0c5821f..205000d 100644
--- a/src/containers/Decrypt/Block/BlockDecrypt.tsx
+++ b/src/containers/Decrypt/Block/BlockDecrypt.tsx
@@ -69,8 +69,7 @@ export default function() {
     setEncryptedText(encryptedText);
   };
 
-  const onSubmitJson = (event: any) => {
-    event.preventDefault();
+  const onSubmitJson = (json: string) => {
     setError('');
 
     parseJson(json);
@@ -125,7 +124,7 @@ export default function() {
               onChange={(event: any) => setKey(event.target.value)}
             />
             {error && <Alarm type="error" text={`Ошибка! ${error}`} />}
-            <button onClick={onSubmitJson}>Расшифровать!</button>
+            <button onClick={() => onSubmitJson(json)}>Расшифровать!</button>
           </>
         ) : (
           <>
diff --git a/src/libmethods/encryption/block/aes/index.ts b/src/libmethods/encryption/block/aes/index.ts
index f96dfa6..297931a 100644
--- a/src/libmethods/encryption/block/aes/index.ts
+++ b/src/libmethods/encryption/block/aes/index.ts
@@ -13,28 +13,20 @@ export function encryptAES256_ECB(key: number[], plainText: string): string {
 
   const aesEcb = new aesjs.ModeOfOperation.ecb(key);
   const encryptedBytes = aesEcb.encrypt(textBytes);
+
+  // The binary data converted to hex
   const encryptedHex = aesjs.utils.hex.fromBytes(encryptedBytes);
 
   return encryptedHex;
 }
 
 export function decryptAES256_ECB(key: number[], encryptedText: string): string {
-  return 'hello';
+  // Convert hex string back to bytes
+  const encryptedBytes = aesjs.utils.hex.toBytes(encryptedText);
+
+  const aesEcb = new aesjs.ModeOfOperation.ecb(key);
+  const decryptedTextBytes = aesEcb.decrypt(encryptedBytes);
+  const decryptedText = aesjs.utils.utf8.fromBytes(decryptedTextBytes);
+
+  return decryptedText;
 }
-// // To print or store the binary data, you may convert it to hex
-// var encryptedHex = aesjs.utils.hex.fromBytes(encryptedBytes);
-// console.log(encryptedHex);
-// // "a7d93b35368519fac347498dec18b458"
-
-// // When ready to decrypt the hex string, convert it back to bytes
-// var encryptedBytes = aesjs.utils.hex.toBytes(encryptedHex);
-
-// // Since electronic codebook does not store state, we can
-// // reuse the same instance.
-// //var aesEcb = new aesjs.ModeOfOperation.ecb(key);
-// var decryptedBytes = aesEcb.decrypt(encryptedBytes);
-
-// // Convert our bytes back into text
-// var decryptedText = aesjs.utils.utf8.fromBytes(decryptedBytes);
-// console.log(decryptedText);
-// // "TextMustBe16Byte"

From b86cbf47529f41db2b4dc3b35f52cd6bf348b5a6 Mon Sep 17 00:00:00 2001
From: Denis Stasyev <denisstasyev@gmail.com>
Date: Sun, 15 Mar 2020 13:00:10 +0300
Subject: [PATCH 22/38] Fix unexpected page crash

---
 src/containers/Decrypt/Block/BlockDecrypt.tsx | 51 +++++++++++--------
 src/libmethods/encryption/block/aes/index.ts  | 18 +++++--
 src/libmethods/encryption/block/index.ts      | 13 +++--
 3 files changed, 53 insertions(+), 29 deletions(-)

diff --git a/src/containers/Decrypt/Block/BlockDecrypt.tsx b/src/containers/Decrypt/Block/BlockDecrypt.tsx
index 205000d..106fb3b 100644
--- a/src/containers/Decrypt/Block/BlockDecrypt.tsx
+++ b/src/containers/Decrypt/Block/BlockDecrypt.tsx
@@ -8,7 +8,7 @@ import { Method } from 'store';
 import { CIPHER_METHOD, ENCRYPTED_DATA, ENCRYPTED_DATA_BASE64 } from 'config';
 
 import { blockEncryptionMethods } from 'libmethods';
-import { getDecryptedText } from 'libmethods/encryption/block';
+import { getDecryptedText, DecryptionResult } from 'libmethods/encryption/block';
 
 import Base64 from 'utils/base64';
 
@@ -23,24 +23,11 @@ export default function() {
   const [error, setError] = React.useState('');
   const [decryptedText, setDecryptedText] = React.useState('');
 
-  const onSubmit = (event: any) => {
-    event.preventDefault();
-    setError('');
+  React.useEffect(() => {
+    json !== '' && parseJson(json);
+  }, [json]);
 
-    if (key === '') {
-      setError('Введите ключ расшифрования!');
-      return;
-    }
-
-    if (encryptedText === '') {
-      setError('Введите закрытый текст!');
-      return;
-    }
-
-    setDecryptedText(getDecryptedText(method, key, encryptedText, ''));
-  };
-
-  const parseJson = (json: string) => {
+  function parseJson(json: string) {
     let objectJson = {};
 
     try {
@@ -67,12 +54,34 @@ export default function() {
       encryptedText = Base64.decode(objectJson[ENCRYPTED_DATA_BASE64]);
     }
     setEncryptedText(encryptedText);
+  }
+
+  const setResult = () => {
+    const decryptionResult: DecryptionResult = getDecryptedText(method, key, encryptedText, '');
+    setError(decryptionResult.error);
+    !decryptionResult.error && setDecryptedText(decryptionResult.decryptedText);
   };
 
-  const onSubmitJson = (json: string) => {
+  const onSubmit = (event: any) => {
+    event.preventDefault();
     setError('');
 
-    parseJson(json);
+    if (key === '') {
+      setError('Введите ключ расшифрования!');
+      return;
+    }
+
+    if (encryptedText === '') {
+      setError('Введите закрытый текст!');
+      return;
+    }
+
+    setResult();
+  };
+
+  const onSubmitJson = (json: string) => {
+    console.log(json);
+    setError('');
 
     if (key === '') {
       setError('Введите ключ расшифрования!');
@@ -91,7 +100,7 @@ export default function() {
       return;
     }
 
-    setDecryptedText(getDecryptedText(method, key, encryptedText, ''));
+    setResult();
   };
 
   return (
diff --git a/src/libmethods/encryption/block/aes/index.ts b/src/libmethods/encryption/block/aes/index.ts
index 297931a..b4d6aee 100644
--- a/src/libmethods/encryption/block/aes/index.ts
+++ b/src/libmethods/encryption/block/aes/index.ts
@@ -1,5 +1,7 @@
 import aesjs from 'aes-js';
 
+import { DecryptionResult } from 'libmethods/encryption/block';
+
 export function encryptAES256_ECB(key: number[], plainText: string): string {
   // Test convert text to bytes to detect rest
   const testTextBytes = aesjs.utils.utf8.toBytes(plainText);
@@ -20,13 +22,21 @@ export function encryptAES256_ECB(key: number[], plainText: string): string {
   return encryptedHex;
 }
 
-export function decryptAES256_ECB(key: number[], encryptedText: string): string {
+export function decryptAES256_ECB(key: number[], encryptedText: string): DecryptionResult {
   // Convert hex string back to bytes
   const encryptedBytes = aesjs.utils.hex.toBytes(encryptedText);
 
   const aesEcb = new aesjs.ModeOfOperation.ecb(key);
-  const decryptedTextBytes = aesEcb.decrypt(encryptedBytes);
-  const decryptedText = aesjs.utils.utf8.fromBytes(decryptedTextBytes);
 
-  return decryptedText;
+  let decryptedTextBytes = '';
+  let decryptedText = '';
+  let error = '';
+  try {
+    decryptedTextBytes = aesEcb.decrypt(encryptedBytes);
+    decryptedText = aesjs.utils.utf8.fromBytes(decryptedTextBytes);
+  } catch {
+    error = 'Невалидный закрытый текст!';
+  }
+
+  return { error, decryptedText };
 }
diff --git a/src/libmethods/encryption/block/index.ts b/src/libmethods/encryption/block/index.ts
index 38dfdba..d13cad7 100644
--- a/src/libmethods/encryption/block/index.ts
+++ b/src/libmethods/encryption/block/index.ts
@@ -36,19 +36,24 @@ export function getEncryptedText(
   return encryptedText;
 }
 
+export interface DecryptionResult {
+  error: string;
+  decryptedText: string;
+}
+
 export function getDecryptedText(
   method: Method,
   key: string,
   encryptedText: string,
   iv: string, // iv - initialization vector
-): string {
-  let decryptedText: string = '';
+): DecryptionResult {
+  let decryptionResult: DecryptionResult = { error: '', decryptedText: '' };
 
   switch (method.type) {
     case blockEncryptionTypes.aes256ecb:
-      decryptedText = decryptAES256_ECB(getNormalizedKey(key), encryptedText);
+      decryptionResult = decryptAES256_ECB(getNormalizedKey(key), encryptedText);
       break;
   }
 
-  return decryptedText;
+  return decryptionResult;
 }

From fd73845bb316cf36bccb4f84aae6798879c94199 Mon Sep 17 00:00:00 2001
From: Denis Stasyev <denisstasyev@gmail.com>
Date: Sun, 15 Mar 2020 13:33:20 +0300
Subject: [PATCH 23/38] Refactor

---
 src/containers/Decrypt/Block/BlockDecrypt.tsx |  2 +-
 src/libmethods/encryption/block/aes/index.ts  | 21 ++++++-------------
 src/libmethods/encryption/block/index.ts      | 17 ++++++++-------
 3 files changed, 17 insertions(+), 23 deletions(-)

diff --git a/src/containers/Decrypt/Block/BlockDecrypt.tsx b/src/containers/Decrypt/Block/BlockDecrypt.tsx
index 106fb3b..547f2f2 100644
--- a/src/containers/Decrypt/Block/BlockDecrypt.tsx
+++ b/src/containers/Decrypt/Block/BlockDecrypt.tsx
@@ -59,7 +59,7 @@ export default function() {
   const setResult = () => {
     const decryptionResult: DecryptionResult = getDecryptedText(method, key, encryptedText, '');
     setError(decryptionResult.error);
-    !decryptionResult.error && setDecryptedText(decryptionResult.decryptedText);
+    !decryptionResult.error && setDecryptedText(decryptionResult.text);
   };
 
   const onSubmit = (event: any) => {
diff --git a/src/libmethods/encryption/block/aes/index.ts b/src/libmethods/encryption/block/aes/index.ts
index b4d6aee..ead76a5 100644
--- a/src/libmethods/encryption/block/aes/index.ts
+++ b/src/libmethods/encryption/block/aes/index.ts
@@ -1,13 +1,11 @@
 import aesjs from 'aes-js';
 
-import { DecryptionResult } from 'libmethods/encryption/block';
-
 export function encryptAES256_ECB(key: number[], plainText: string): string {
   // Test convert text to bytes to detect rest
   const testTextBytes = aesjs.utils.utf8.toBytes(plainText);
 
   // Create text with length is a multiple of 16 Byte (with spaces at the end)
-  const rest16bytesLength: number = 16 - (testTextBytes.length % 16);
+  const rest16bytesLength: number = 16 - (testTextBytes.length % 16 || 16);
   const fixedText = plainText + new Array(rest16bytesLength + 1).join(' ');
 
   // Main convert text to bytes
@@ -22,21 +20,14 @@ export function encryptAES256_ECB(key: number[], plainText: string): string {
   return encryptedHex;
 }
 
-export function decryptAES256_ECB(key: number[], encryptedText: string): DecryptionResult {
+export function decryptAES256_ECB(key: number[], encryptedText: string): string {
   // Convert hex string back to bytes
   const encryptedBytes = aesjs.utils.hex.toBytes(encryptedText);
 
   const aesEcb = new aesjs.ModeOfOperation.ecb(key);
 
-  let decryptedTextBytes = '';
-  let decryptedText = '';
-  let error = '';
-  try {
-    decryptedTextBytes = aesEcb.decrypt(encryptedBytes);
-    decryptedText = aesjs.utils.utf8.fromBytes(decryptedTextBytes);
-  } catch {
-    error = 'Невалидный закрытый текст!';
-  }
-
-  return { error, decryptedText };
+  const decryptedTextBytes = aesEcb.decrypt(encryptedBytes);
+  const decryptedText = aesjs.utils.utf8.fromBytes(decryptedTextBytes);
+
+  return decryptedText;
 }
diff --git a/src/libmethods/encryption/block/index.ts b/src/libmethods/encryption/block/index.ts
index d13cad7..f44483a 100644
--- a/src/libmethods/encryption/block/index.ts
+++ b/src/libmethods/encryption/block/index.ts
@@ -38,7 +38,7 @@ export function getEncryptedText(
 
 export interface DecryptionResult {
   error: string;
-  decryptedText: string;
+  text: string;
 }
 
 export function getDecryptedText(
@@ -47,12 +47,15 @@ export function getDecryptedText(
   encryptedText: string,
   iv: string, // iv - initialization vector
 ): DecryptionResult {
-  let decryptionResult: DecryptionResult = { error: '', decryptedText: '' };
-
-  switch (method.type) {
-    case blockEncryptionTypes.aes256ecb:
-      decryptionResult = decryptAES256_ECB(getNormalizedKey(key), encryptedText);
-      break;
+  const decryptionResult: DecryptionResult = { error: '', text: '' };
+  try {
+    switch (method.type) {
+      case blockEncryptionTypes.aes256ecb:
+        decryptionResult.text = decryptAES256_ECB(getNormalizedKey(key), encryptedText);
+        break;
+    }
+  } catch {
+    decryptionResult.error = 'Невалидный закрытый текст!';
   }
 
   return decryptionResult;

From 08e09c47872de7cb4205efc91f525b2f7df94dd5 Mon Sep 17 00:00:00 2001
From: Mikhail Pakhomov <mikhan333@mail.ru>
Date: Sun, 15 Mar 2020 13:58:29 +0300
Subject: [PATCH 24/38] Fix encrypt and decrypt aes

---
 src/libmethods/encryption/block/aes/index.ts | 21 ++++++++------------
 1 file changed, 8 insertions(+), 13 deletions(-)

diff --git a/src/libmethods/encryption/block/aes/index.ts b/src/libmethods/encryption/block/aes/index.ts
index 297931a..fae2be0 100644
--- a/src/libmethods/encryption/block/aes/index.ts
+++ b/src/libmethods/encryption/block/aes/index.ts
@@ -1,32 +1,27 @@
 import aesjs from 'aes-js';
 
 export function encryptAES256_ECB(key: number[], plainText: string): string {
-  // Test convert text to bytes to detect rest
-  const testTextBytes = aesjs.utils.utf8.toBytes(plainText);
+  let textUint8Array = new TextEncoder().encode(plainText);
 
-  // Create text with length is a multiple of 16 Byte (with spaces at the end)
-  const rest16bytesLength: number = 16 - (testTextBytes.length % 16);
-  const fixedText = plainText + new Array(rest16bytesLength + 1).join(' ');
-
-  // Main convert text to bytes
-  const textBytes = aesjs.utils.utf8.toBytes(fixedText);
+  const rest16bytesLength: number = 16 - (textUint8Array.length % 16 || 16);
+  const textUint8ArrayFill = new Uint8Array([
+    ...Array.from(textUint8Array),
+    ...Array.from({ length: rest16bytesLength }, () => 32),
+  ]);
 
   const aesEcb = new aesjs.ModeOfOperation.ecb(key);
-  const encryptedBytes = aesEcb.encrypt(textBytes);
+  const encryptedBytes = aesEcb.encrypt(textUint8ArrayFill);
 
-  // The binary data converted to hex
   const encryptedHex = aesjs.utils.hex.fromBytes(encryptedBytes);
-
   return encryptedHex;
 }
 
 export function decryptAES256_ECB(key: number[], encryptedText: string): string {
-  // Convert hex string back to bytes
   const encryptedBytes = aesjs.utils.hex.toBytes(encryptedText);
 
   const aesEcb = new aesjs.ModeOfOperation.ecb(key);
   const decryptedTextBytes = aesEcb.decrypt(encryptedBytes);
-  const decryptedText = aesjs.utils.utf8.fromBytes(decryptedTextBytes);
 
+  const decryptedText = new TextDecoder().decode(decryptedTextBytes);
   return decryptedText;
 }

From 6668314bad5b70889afef6d7bd7cbee222652e8a Mon Sep 17 00:00:00 2001
From: Denis Stasyev <denisstasyev@gmail.com>
Date: Sun, 15 Mar 2020 14:22:20 +0300
Subject: [PATCH 25/38] Refactor

---
 src/libmethods/encryption/block/aes/index.ts | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/libmethods/encryption/block/aes/index.ts b/src/libmethods/encryption/block/aes/index.ts
index ff2cbb9..a4c2e7a 100644
--- a/src/libmethods/encryption/block/aes/index.ts
+++ b/src/libmethods/encryption/block/aes/index.ts
@@ -1,17 +1,21 @@
 import aesjs from 'aes-js';
 
 export function encryptAES256_ECB(key: number[], plainText: string): string {
+  // Convert text to UTF-8 Array
   let textUint8Array = new TextEncoder().encode(plainText);
 
+  // Create text with length is a multiple of 16 Byte (with spaces at the end)
   const rest16bytesLength: number = 16 - (textUint8Array.length % 16 || 16);
-  const textUint8ArrayFill = new Uint8Array([
+  const textUint8ArrayFilled = Uint8Array.from([
     ...Array.from(textUint8Array),
-    ...Array.from({ length: rest16bytesLength }, () => 32),
+    ...Array.from({ length: rest16bytesLength }, () => 32), // 32 is UTF-8 code of space
   ]);
 
   const aesEcb = new aesjs.ModeOfOperation.ecb(key);
-  const encryptedBytes = aesEcb.encrypt(textUint8ArrayFill);
 
+  const encryptedBytes = aesEcb.encrypt(textUint8ArrayFilled);
+
+  // The binary data converted to hex
   const encryptedHex = aesjs.utils.hex.fromBytes(encryptedBytes);
   return encryptedHex;
 }

From 1cbba9d1939dbcb830e83fc1ff6c5a8ac34e9469 Mon Sep 17 00:00:00 2001
From: Denis Stasyev <denisstasyev@gmail.com>
Date: Sun, 15 Mar 2020 15:16:12 +0300
Subject: [PATCH 26/38] Add AES-256/CBC and update README's

---
 README.md                                     | 14 +++----
 src/config.ts                                 |  4 ++
 src/containers/Decrypt/Block/BlockDecrypt.tsx |  4 +-
 src/containers/Encrypt/Block/BlockEncrypt.tsx | 16 ++++++--
 src/libmethods/checksum/README.md             |  8 ++++
 src/libmethods/encryption/README.md           |  2 +-
 src/libmethods/encryption/block/README.md     | 14 +++++++
 src/libmethods/encryption/block/aes/cbc.ts    | 26 +++++++++++++
 .../encryption/block/aes/{index.ts => ecb.ts} | 12 ++----
 src/libmethods/encryption/block/index.ts      | 30 ++++++---------
 src/libmethods/encryption/block/utils.ts      | 38 +++++++++++++++++++
 src/libmethods/hashing/README.md              |  7 ++++
 src/libmethods/index.ts                       |  2 +
 13 files changed, 137 insertions(+), 40 deletions(-)
 create mode 100644 src/libmethods/checksum/README.md
 create mode 100644 src/libmethods/encryption/block/README.md
 create mode 100644 src/libmethods/encryption/block/aes/cbc.ts
 rename src/libmethods/encryption/block/aes/{index.ts => ecb.ts} (62%)
 create mode 100644 src/libmethods/encryption/block/utils.ts
 create mode 100644 src/libmethods/hashing/README.md

diff --git a/README.md b/README.md
index 69d9c4c..38b6a91 100644
--- a/README.md
+++ b/README.md
@@ -36,10 +36,10 @@ More information about encryption and decryption methods are available in [`src/
 
 The following checksum methods are now available:
 
-- CRC16
-- CRC24
-- CRC32
-- Fletcher16
+- CRC-16
+- CRC-24
+- CRC-32
+- Fletcher-16
 
 More information about checksum methods are available in [`src/libmethods/checksum` folder](https://github.com/denisstasyev/Information_Security_JS/tree/master/src/libmethods/checksum).
 
@@ -47,9 +47,9 @@ More information about checksum methods are available in [`src/libmethods/checks
 
 The following hash functions are now available:
 
-- SHA256
-- SHA512
-- SHA3
+- SHA-256
+- SHA-512
+- SHA-3
 
 More information about checksum methods are available in [`src/libmethods/hashing` folder](https://github.com/denisstasyev/Information_Security_JS/tree/master/src/libmethods/hashing).
 
diff --git a/src/config.ts b/src/config.ts
index 999a10a..5aae62a 100644
--- a/src/config.ts
+++ b/src/config.ts
@@ -2,6 +2,10 @@ export const CIPHER_METHOD = 'cipher_algorithm';
 // export const ENCRYPTED_DATA_CODES = 'encrypted_data_codes';
 export const ENCRYPTED_DATA = 'encrypted_data';
 export const ENCRYPTED_DATA_BASE64 = 'encrypted_data_base64';
+export const INITIALIZATION_VECTOR = 'initialization_vector';
+
+// The initialization vector (must be 16 bytes)
+export const iv = [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36];
 
 export const CHECKSUM_METHOD = 'checksum_algorithm';
 export const CHECKSUM_TEXT = 'checksum_text';
diff --git a/src/containers/Decrypt/Block/BlockDecrypt.tsx b/src/containers/Decrypt/Block/BlockDecrypt.tsx
index 547f2f2..29c6faa 100644
--- a/src/containers/Decrypt/Block/BlockDecrypt.tsx
+++ b/src/containers/Decrypt/Block/BlockDecrypt.tsx
@@ -5,7 +5,7 @@ import { Alarm } from 'components/Alarm';
 
 import { Method } from 'store';
 
-import { CIPHER_METHOD, ENCRYPTED_DATA, ENCRYPTED_DATA_BASE64 } from 'config';
+import { CIPHER_METHOD, ENCRYPTED_DATA, ENCRYPTED_DATA_BASE64, iv } from 'config';
 
 import { blockEncryptionMethods } from 'libmethods';
 import { getDecryptedText, DecryptionResult } from 'libmethods/encryption/block';
@@ -57,7 +57,7 @@ export default function() {
   }
 
   const setResult = () => {
-    const decryptionResult: DecryptionResult = getDecryptedText(method, key, encryptedText, '');
+    const decryptionResult: DecryptionResult = getDecryptedText(method, key, encryptedText, iv);
     setError(decryptionResult.error);
     !decryptionResult.error && setDecryptedText(decryptionResult.text);
   };
diff --git a/src/containers/Encrypt/Block/BlockEncrypt.tsx b/src/containers/Encrypt/Block/BlockEncrypt.tsx
index fdf9110..304a426 100644
--- a/src/containers/Encrypt/Block/BlockEncrypt.tsx
+++ b/src/containers/Encrypt/Block/BlockEncrypt.tsx
@@ -5,9 +5,15 @@ import { Alarm } from 'components/Alarm';
 
 import { Method } from 'store';
 
-import { CIPHER_METHOD, ENCRYPTED_DATA, ENCRYPTED_DATA_BASE64 } from 'config';
+import {
+  CIPHER_METHOD,
+  ENCRYPTED_DATA,
+  ENCRYPTED_DATA_BASE64,
+  INITIALIZATION_VECTOR,
+  iv,
+} from 'config';
 
-import { blockEncryptionMethods } from 'libmethods';
+import { blockEncryptionMethods, blockEncryptionTypes } from 'libmethods';
 import { getEncryptedText } from 'libmethods/encryption/block';
 
 import Base64 from 'utils/base64';
@@ -34,7 +40,7 @@ export default function() {
       return;
     }
 
-    setEncryptedText(getEncryptedText(method, key, plainText, ''));
+    setEncryptedText(getEncryptedText(method, key, plainText, iv));
   };
 
   const getJSON = (method: Method, encryptedText: string) => {
@@ -43,6 +49,10 @@ export default function() {
       [ENCRYPTED_DATA]: encryptedText,
       [ENCRYPTED_DATA_BASE64]: Base64.encode(encryptedText),
     };
+    if (method.type !== blockEncryptionTypes.aes256ecb) {
+      // @ts-ignore
+      json[INITIALIZATION_VECTOR] = iv;
+    }
     return JSON.stringify(json, undefined, 2);
   };
 
diff --git a/src/libmethods/checksum/README.md b/src/libmethods/checksum/README.md
new file mode 100644
index 0000000..42fec7b
--- /dev/null
+++ b/src/libmethods/checksum/README.md
@@ -0,0 +1,8 @@
+# Description of Checksums
+
+The following checksum methods are now available:
+
+- CRC-16
+- CRC-24
+- CRC-32
+- Fletcher-16
diff --git a/src/libmethods/encryption/README.md b/src/libmethods/encryption/README.md
index 39ef314..81ae7dd 100644
--- a/src/libmethods/encryption/README.md
+++ b/src/libmethods/encryption/README.md
@@ -15,7 +15,7 @@ More information about basic methods are available in [`src/libmethods/encryptio
 
 This project includes some block algorithms, such as:
 
-- AES
+- AES-256
 - GOST
 
 More information about block methods are available in [`src/libmethods/encryption/block` folder](https://github.com/denisstasyev/Information_Security_JS/tree/master/src/libmethods/encryption/block).
diff --git a/src/libmethods/encryption/block/README.md b/src/libmethods/encryption/block/README.md
new file mode 100644
index 0000000..474f14f
--- /dev/null
+++ b/src/libmethods/encryption/block/README.md
@@ -0,0 +1,14 @@
+# Description of block cryptographic algorithms
+
+## AES - Advanced Encryption Standard
+
+This project includes some versions of AES-256, such as:
+
+- ECB
+- CBC
+
+### ECB - Electronic Codebook (NOT recommended)
+
+This mode is **not** recommended. Since, for a given key, the same plaintext block in produces the same ciphertext block out, this mode of operation can leak data, such as patterns. For more details and examples, see the Wikipedia article, [Electronic Codebook](http://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#Electronic_Codebook_.28ECB.29).
+
+### CBC - Cipher-Block Chaining (recommended)
diff --git a/src/libmethods/encryption/block/aes/cbc.ts b/src/libmethods/encryption/block/aes/cbc.ts
new file mode 100644
index 0000000..9c966ab
--- /dev/null
+++ b/src/libmethods/encryption/block/aes/cbc.ts
@@ -0,0 +1,26 @@
+import aesjs from 'aes-js';
+
+import { preparePlainText } from 'libmethods/encryption/block/utils';
+
+export function encryptAES256_CBC(key: number[], plainText: string, iv: number[]): string {
+  const textUint8ArrayFilled: Uint8Array = preparePlainText(plainText);
+
+  const aesCbc = new aesjs.ModeOfOperation.ecb(key, iv);
+
+  const encryptedBytes = aesCbc.encrypt(textUint8ArrayFilled);
+
+  // The binary data converted to hex
+  const encryptedHex = aesjs.utils.hex.fromBytes(encryptedBytes);
+  return encryptedHex;
+}
+
+export function decryptAES256_CBC(key: number[], encryptedText: string, iv: number[]): string {
+  const encryptedBytes = aesjs.utils.hex.toBytes(encryptedText);
+
+  const aesCbc = new aesjs.ModeOfOperation.ecb(key, iv);
+
+  const decryptedTextBytes = aesCbc.decrypt(encryptedBytes);
+
+  const decryptedText = new TextDecoder().decode(decryptedTextBytes);
+  return decryptedText;
+}
diff --git a/src/libmethods/encryption/block/aes/index.ts b/src/libmethods/encryption/block/aes/ecb.ts
similarity index 62%
rename from src/libmethods/encryption/block/aes/index.ts
rename to src/libmethods/encryption/block/aes/ecb.ts
index a4c2e7a..246c087 100644
--- a/src/libmethods/encryption/block/aes/index.ts
+++ b/src/libmethods/encryption/block/aes/ecb.ts
@@ -1,15 +1,9 @@
 import aesjs from 'aes-js';
 
+import { preparePlainText } from 'libmethods/encryption/block/utils';
+
 export function encryptAES256_ECB(key: number[], plainText: string): string {
-  // Convert text to UTF-8 Array
-  let textUint8Array = new TextEncoder().encode(plainText);
-
-  // Create text with length is a multiple of 16 Byte (with spaces at the end)
-  const rest16bytesLength: number = 16 - (textUint8Array.length % 16 || 16);
-  const textUint8ArrayFilled = Uint8Array.from([
-    ...Array.from(textUint8Array),
-    ...Array.from({ length: rest16bytesLength }, () => 32), // 32 is UTF-8 code of space
-  ]);
+  const textUint8ArrayFilled: Uint8Array = preparePlainText(plainText);
 
   const aesEcb = new aesjs.ModeOfOperation.ecb(key);
 
diff --git a/src/libmethods/encryption/block/index.ts b/src/libmethods/encryption/block/index.ts
index f44483a..230eed3 100644
--- a/src/libmethods/encryption/block/index.ts
+++ b/src/libmethods/encryption/block/index.ts
@@ -2,28 +2,16 @@ import { Method } from 'store';
 
 import { blockEncryptionTypes } from 'libmethods';
 
-import { getSHA256 } from 'libmethods/hashing/sha256';
-import { toHexFormat } from 'libmethods/hashing';
-
-import { encryptAES256_ECB, decryptAES256_ECB } from 'libmethods/encryption/block/aes';
-
-/**  Convert string key into Array of 4 elements with 128 bit size.
- * Then it is converted into hex string and parsed into hex Array of 16 elements with 2 characters.
- * Finally parse it into Array of 16 Numbers.
- */
-function getNormalizedKey(key: string): number[] {
-  const key_128bit_4elements: number[] = getSHA256(key).slice(0, 4);
-  // @ts-ignore
-  const keyNormalizedHexes: string[] = toHexFormat(key_128bit_4elements).match(/.{1,2}/g) || [];
-  const keyNormalized: number[] = keyNormalizedHexes.map(keyHex => parseInt(keyHex, 16));
-  return keyNormalized;
-}
+import { getNormalizedKey } from 'libmethods/encryption/block/utils';
+
+import { encryptAES256_ECB, decryptAES256_ECB } from 'libmethods/encryption/block/aes/ecb';
+import { encryptAES256_CBC, decryptAES256_CBC } from 'libmethods/encryption/block/aes/cbc';
 
 export function getEncryptedText(
   method: Method,
   key: string,
   plainText: string,
-  iv: string, // iv - initialization vector
+  iv: number[], // iv - initialization vector
 ): string {
   let encryptedText: string = '';
 
@@ -31,6 +19,9 @@ export function getEncryptedText(
     case blockEncryptionTypes.aes256ecb:
       encryptedText = encryptAES256_ECB(getNormalizedKey(key), plainText);
       break;
+    case blockEncryptionTypes.aes256cbc:
+      encryptedText = encryptAES256_CBC(getNormalizedKey(key), plainText, iv);
+      break;
   }
 
   return encryptedText;
@@ -45,7 +36,7 @@ export function getDecryptedText(
   method: Method,
   key: string,
   encryptedText: string,
-  iv: string, // iv - initialization vector
+  iv: number[], // iv - initialization vector
 ): DecryptionResult {
   const decryptionResult: DecryptionResult = { error: '', text: '' };
   try {
@@ -53,6 +44,9 @@ export function getDecryptedText(
       case blockEncryptionTypes.aes256ecb:
         decryptionResult.text = decryptAES256_ECB(getNormalizedKey(key), encryptedText);
         break;
+      case blockEncryptionTypes.aes256cbc:
+        decryptionResult.text = decryptAES256_CBC(getNormalizedKey(key), encryptedText, iv);
+        break;
     }
   } catch {
     decryptionResult.error = 'Невалидный закрытый текст!';
diff --git a/src/libmethods/encryption/block/utils.ts b/src/libmethods/encryption/block/utils.ts
new file mode 100644
index 0000000..d79cff4
--- /dev/null
+++ b/src/libmethods/encryption/block/utils.ts
@@ -0,0 +1,38 @@
+import { getSHA256 } from 'libmethods/hashing/sha256';
+import { toHexFormat } from 'libmethods/hashing';
+
+/**
+ * Convert string key into Array of 4 elements with 128 bit size.
+ * Then it is converted into hex string and parsed into hex Array of 16 elements with 2 characters.
+ * Finally parse it into Array of 16 Numbers.
+ *
+ * @param  {string} key
+ * @returns number
+ */
+export function getNormalizedKey(key: string): number[] {
+  const key_128bit_4elements: number[] = getSHA256(key).slice(0, 4);
+  // @ts-ignore
+  const keyNormalizedHexes: string[] = toHexFormat(key_128bit_4elements).match(/.{1,2}/g) || [];
+  const keyNormalized: number[] = keyNormalizedHexes.map(keyHex => parseInt(keyHex, 16));
+  return keyNormalized;
+}
+
+/**
+ * Convert plain text into filled with spaced at the end (to be multiple of 16) UTF-8 Array
+ *
+ * @param  {string} plainText
+ * @returns Uint8Array
+ */
+export function preparePlainText(plainText: string): Uint8Array {
+  // Convert text to UTF-8 Array
+  let textUint8Array = new TextEncoder().encode(plainText);
+
+  // Create text with length is a multiple of 16 Byte (with spaces at the end)
+  const rest16bytesLength: number = 16 - (textUint8Array.length % 16 || 16);
+  const textUint8ArrayFilled: Uint8Array = Uint8Array.from([
+    ...Array.from(textUint8Array),
+    ...Array.from({ length: rest16bytesLength }, () => 32), // 32 is UTF-8 code of space
+  ]);
+
+  return textUint8ArrayFilled;
+}
diff --git a/src/libmethods/hashing/README.md b/src/libmethods/hashing/README.md
new file mode 100644
index 0000000..d28e819
--- /dev/null
+++ b/src/libmethods/hashing/README.md
@@ -0,0 +1,7 @@
+# Description of Hash functions
+
+The following hash functions are now available:
+
+- SHA-256
+- SHA-512
+- SHA-3
diff --git a/src/libmethods/index.ts b/src/libmethods/index.ts
index a90c393..18af75f 100644
--- a/src/libmethods/index.ts
+++ b/src/libmethods/index.ts
@@ -22,10 +22,12 @@ export const encryptionMethods: Method[] = [
  */
 export const blockEncryptionTypes = {
   aes256ecb: 'aes256ecb',
+  aes256cbc: 'aes256cbc',
 };
 
 export const blockEncryptionMethods: Method[] = [
   { type: blockEncryptionTypes.aes256ecb, name: 'AES-256/ECB' },
+  { type: blockEncryptionTypes.aes256cbc, name: 'AES-256/CBC' },
 ];
 
 /**

From 40e96b0cc8466441e4447eb12b083e088fdd88a1 Mon Sep 17 00:00:00 2001
From: Denis Stasyev <denisstasyev@gmail.com>
Date: Sun, 15 Mar 2020 16:55:14 +0300
Subject: [PATCH 27/38] Add variable iv

---
 src/config.ts                                 |  3 -
 src/containers/Decrypt/Block/BlockDecrypt.tsx | 57 +++++++++++++++----
 src/containers/Encrypt/Block/BlockEncrypt.tsx | 31 +++++++---
 src/libmethods/encryption/block/aes/cbc.ts    |  4 +-
 src/libmethods/encryption/block/index.ts      |  6 +-
 src/libmethods/encryption/block/utils.ts      |  5 ++
 src/libmethods/index.ts                       | 10 +++-
 src/styles/_global.scss                       |  2 +
 8 files changed, 88 insertions(+), 30 deletions(-)

diff --git a/src/config.ts b/src/config.ts
index 5aae62a..fc9d0f1 100644
--- a/src/config.ts
+++ b/src/config.ts
@@ -4,9 +4,6 @@ export const ENCRYPTED_DATA = 'encrypted_data';
 export const ENCRYPTED_DATA_BASE64 = 'encrypted_data_base64';
 export const INITIALIZATION_VECTOR = 'initialization_vector';
 
-// The initialization vector (must be 16 bytes)
-export const iv = [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36];
-
 export const CHECKSUM_METHOD = 'checksum_algorithm';
 export const CHECKSUM_TEXT = 'checksum_text';
 export const CHECKSUM_VALUE = 'checksum_value';
diff --git a/src/containers/Decrypt/Block/BlockDecrypt.tsx b/src/containers/Decrypt/Block/BlockDecrypt.tsx
index 29c6faa..25bb9da 100644
--- a/src/containers/Decrypt/Block/BlockDecrypt.tsx
+++ b/src/containers/Decrypt/Block/BlockDecrypt.tsx
@@ -3,12 +3,16 @@ import * as React from 'react';
 import { ContentBox } from 'components/ContentBox';
 import { Alarm } from 'components/Alarm';
 
-import { Method } from 'store';
-
-import { CIPHER_METHOD, ENCRYPTED_DATA, ENCRYPTED_DATA_BASE64, iv } from 'config';
-
-import { blockEncryptionMethods } from 'libmethods';
+import {
+  CIPHER_METHOD,
+  ENCRYPTED_DATA,
+  ENCRYPTED_DATA_BASE64,
+  INITIALIZATION_VECTOR,
+} from 'config';
+
+import { BlockMethod, blockEncryptionMethods } from 'libmethods';
 import { getDecryptedText, DecryptionResult } from 'libmethods/encryption/block';
+import { getNormalizedIv } from 'libmethods/encryption/block/utils';
 
 import Base64 from 'utils/base64';
 
@@ -16,9 +20,10 @@ export default function() {
   const [isJsonMode, setIsJsonMode] = React.useState(false);
   const [json, setJson] = React.useState('');
 
-  const [method, setMethod] = React.useState<Method>(blockEncryptionMethods[0]);
+  const [method, setMethod] = React.useState<BlockMethod>(blockEncryptionMethods[0]);
   const [key, setKey] = React.useState('');
-  // const [iv, set] = React.useState('');
+  const [iv, setIv] = React.useState('');
+  const [ivJson, setIvJson] = React.useState([]);
   const [encryptedText, setEncryptedText] = React.useState('');
   const [error, setError] = React.useState('');
   const [decryptedText, setDecryptedText] = React.useState('');
@@ -38,9 +43,12 @@ export default function() {
 
     // @ts-ignore
     const methodName = objectJson[CIPHER_METHOD] === undefined ? '' : objectJson[CIPHER_METHOD];
-    const method: Method = blockEncryptionMethods.find(method => method.name === methodName) || {
+    const method: BlockMethod = blockEncryptionMethods.find(
+      method => method.name === methodName,
+    ) || {
       name: '',
       type: '',
+      withIv: false,
     };
     setMethod(method);
 
@@ -54,10 +62,20 @@ export default function() {
       encryptedText = Base64.decode(objectJson[ENCRYPTED_DATA_BASE64]);
     }
     setEncryptedText(encryptedText);
+
+    const ivJson =
+      // @ts-ignore
+      objectJson[INITIALIZATION_VECTOR] === undefined ? [] : objectJson[INITIALIZATION_VECTOR];
+    setIvJson(ivJson);
   }
 
   const setResult = () => {
-    const decryptionResult: DecryptionResult = getDecryptedText(method, key, encryptedText, iv);
+    const decryptionResult: DecryptionResult = getDecryptedText(
+      method,
+      key,
+      encryptedText,
+      isJsonMode ? ivJson : getNormalizedIv(iv),
+    );
     setError(decryptionResult.error);
     !decryptionResult.error && setDecryptedText(decryptionResult.text);
   };
@@ -66,6 +84,11 @@ export default function() {
     event.preventDefault();
     setError('');
 
+    if (method.withIv && iv === '') {
+      setError('Введите вектор инициализации!');
+      return;
+    }
+
     if (key === '') {
       setError('Введите ключ расшифрования!');
       return;
@@ -80,7 +103,6 @@ export default function() {
   };
 
   const onSubmitJson = (json: string) => {
-    console.log(json);
     setError('');
 
     if (key === '') {
@@ -100,6 +122,11 @@ export default function() {
       return;
     }
 
+    if (method.withIv && ivJson === []) {
+      setError(`Введите вектор инициализации в JSON (свойство: ${INITIALIZATION_VECTOR})!`);
+      return;
+    }
+
     setResult();
   };
 
@@ -153,6 +180,16 @@ export default function() {
                 </option>
               ))}
             </select>
+            {method.withIv && (
+              <>
+                <span>1.1) Введите вектор инициализации:</span>
+                <input
+                  value={iv}
+                  placeholder="Ваш вектор инициализации"
+                  onChange={(event: any) => setIv(event.target.value)}
+                />
+              </>
+            )}
             <span>2) Введите ключ для расшифрования:</span>
             <input
               value={key}
diff --git a/src/containers/Encrypt/Block/BlockEncrypt.tsx b/src/containers/Encrypt/Block/BlockEncrypt.tsx
index 304a426..c83ec9d 100644
--- a/src/containers/Encrypt/Block/BlockEncrypt.tsx
+++ b/src/containers/Encrypt/Block/BlockEncrypt.tsx
@@ -3,25 +3,23 @@ import * as React from 'react';
 import { ContentBox } from 'components/ContentBox';
 import { Alarm } from 'components/Alarm';
 
-import { Method } from 'store';
-
 import {
   CIPHER_METHOD,
   ENCRYPTED_DATA,
   ENCRYPTED_DATA_BASE64,
   INITIALIZATION_VECTOR,
-  iv,
 } from 'config';
 
-import { blockEncryptionMethods, blockEncryptionTypes } from 'libmethods';
+import { BlockMethod, blockEncryptionMethods } from 'libmethods';
 import { getEncryptedText } from 'libmethods/encryption/block';
+import { getNormalizedIv } from 'libmethods/encryption/block/utils';
 
 import Base64 from 'utils/base64';
 
 export default function() {
-  const [method, setMethod] = React.useState<Method>(blockEncryptionMethods[0]);
+  const [method, setMethod] = React.useState<BlockMethod>(blockEncryptionMethods[0]);
+  const [iv, setIv] = React.useState('');
   const [key, setKey] = React.useState('');
-  // const [iv, set] = React.useState('');
   const [plainText, setPlainText] = React.useState('');
   const [error, setError] = React.useState('');
   const [encryptedText, setEncryptedText] = React.useState('');
@@ -30,6 +28,11 @@ export default function() {
     event.preventDefault();
     setError('');
 
+    if (method.withIv && iv === '') {
+      setError('Введите вектор инициализации!');
+      return;
+    }
+
     if (key === '') {
       setError('Введите ключ шифрования!');
       return;
@@ -43,15 +46,15 @@ export default function() {
     setEncryptedText(getEncryptedText(method, key, plainText, iv));
   };
 
-  const getJSON = (method: Method, encryptedText: string) => {
+  const getJSON = (method: BlockMethod, encryptedText: string) => {
     let json = {
       [CIPHER_METHOD]: method.name,
       [ENCRYPTED_DATA]: encryptedText,
       [ENCRYPTED_DATA_BASE64]: Base64.encode(encryptedText),
     };
-    if (method.type !== blockEncryptionTypes.aes256ecb) {
+    if (method.withIv) {
       // @ts-ignore
-      json[INITIALIZATION_VECTOR] = iv;
+      json[INITIALIZATION_VECTOR] = getNormalizedIv(iv);
     }
     return JSON.stringify(json, undefined, 2);
   };
@@ -75,6 +78,16 @@ export default function() {
             </option>
           ))}
         </select>
+        {method.withIv && (
+          <>
+            <span>1.1) Введите вектор инициализации:</span>
+            <input
+              value={iv}
+              placeholder="Ваш вектор инициализации"
+              onChange={(event: any) => setIv(event.target.value)}
+            />
+          </>
+        )}
         <span>2) Введите ключ для шифрования:</span>
         <input
           value={key}
diff --git a/src/libmethods/encryption/block/aes/cbc.ts b/src/libmethods/encryption/block/aes/cbc.ts
index 9c966ab..887ef81 100644
--- a/src/libmethods/encryption/block/aes/cbc.ts
+++ b/src/libmethods/encryption/block/aes/cbc.ts
@@ -5,7 +5,7 @@ import { preparePlainText } from 'libmethods/encryption/block/utils';
 export function encryptAES256_CBC(key: number[], plainText: string, iv: number[]): string {
   const textUint8ArrayFilled: Uint8Array = preparePlainText(plainText);
 
-  const aesCbc = new aesjs.ModeOfOperation.ecb(key, iv);
+  const aesCbc = new aesjs.ModeOfOperation.cbc(key, iv);
 
   const encryptedBytes = aesCbc.encrypt(textUint8ArrayFilled);
 
@@ -17,7 +17,7 @@ export function encryptAES256_CBC(key: number[], plainText: string, iv: number[]
 export function decryptAES256_CBC(key: number[], encryptedText: string, iv: number[]): string {
   const encryptedBytes = aesjs.utils.hex.toBytes(encryptedText);
 
-  const aesCbc = new aesjs.ModeOfOperation.ecb(key, iv);
+  const aesCbc = new aesjs.ModeOfOperation.cbc(key, iv);
 
   const decryptedTextBytes = aesCbc.decrypt(encryptedBytes);
 
diff --git a/src/libmethods/encryption/block/index.ts b/src/libmethods/encryption/block/index.ts
index 230eed3..1825444 100644
--- a/src/libmethods/encryption/block/index.ts
+++ b/src/libmethods/encryption/block/index.ts
@@ -2,7 +2,7 @@ import { Method } from 'store';
 
 import { blockEncryptionTypes } from 'libmethods';
 
-import { getNormalizedKey } from 'libmethods/encryption/block/utils';
+import { getNormalizedKey, getNormalizedIv } from 'libmethods/encryption/block/utils';
 
 import { encryptAES256_ECB, decryptAES256_ECB } from 'libmethods/encryption/block/aes/ecb';
 import { encryptAES256_CBC, decryptAES256_CBC } from 'libmethods/encryption/block/aes/cbc';
@@ -11,7 +11,7 @@ export function getEncryptedText(
   method: Method,
   key: string,
   plainText: string,
-  iv: number[], // iv - initialization vector
+  iv: string, // iv - initialization vector
 ): string {
   let encryptedText: string = '';
 
@@ -20,7 +20,7 @@ export function getEncryptedText(
       encryptedText = encryptAES256_ECB(getNormalizedKey(key), plainText);
       break;
     case blockEncryptionTypes.aes256cbc:
-      encryptedText = encryptAES256_CBC(getNormalizedKey(key), plainText, iv);
+      encryptedText = encryptAES256_CBC(getNormalizedKey(key), plainText, getNormalizedIv(iv));
       break;
   }
 
diff --git a/src/libmethods/encryption/block/utils.ts b/src/libmethods/encryption/block/utils.ts
index d79cff4..e56bac1 100644
--- a/src/libmethods/encryption/block/utils.ts
+++ b/src/libmethods/encryption/block/utils.ts
@@ -17,6 +17,11 @@ export function getNormalizedKey(key: string): number[] {
   return keyNormalized;
 }
 
+/**
+ * The initialization vector must be 16 bytes (like Array of 16 Numbers)
+ */
+export const getNormalizedIv = getNormalizedKey;
+
 /**
  * Convert plain text into filled with spaced at the end (to be multiple of 16) UTF-8 Array
  *
diff --git a/src/libmethods/index.ts b/src/libmethods/index.ts
index 18af75f..03c0169 100644
--- a/src/libmethods/index.ts
+++ b/src/libmethods/index.ts
@@ -20,14 +20,18 @@ export const encryptionMethods: Method[] = [
 /**
  * Block encryption types and methods
  */
+export interface BlockMethod extends Method {
+  withIv: boolean;
+}
+
 export const blockEncryptionTypes = {
   aes256ecb: 'aes256ecb',
   aes256cbc: 'aes256cbc',
 };
 
-export const blockEncryptionMethods: Method[] = [
-  { type: blockEncryptionTypes.aes256ecb, name: 'AES-256/ECB' },
-  { type: blockEncryptionTypes.aes256cbc, name: 'AES-256/CBC' },
+export const blockEncryptionMethods: BlockMethod[] = [
+  { type: blockEncryptionTypes.aes256ecb, name: 'AES-256/ECB', withIv: false },
+  { type: blockEncryptionTypes.aes256cbc, name: 'AES-256/CBC', withIv: true },
 ];
 
 /**
diff --git a/src/styles/_global.scss b/src/styles/_global.scss
index ffdbe8e..843bcda 100644
--- a/src/styles/_global.scss
+++ b/src/styles/_global.scss
@@ -40,6 +40,8 @@ textarea {
   border: $border-secondary;
   border-radius: $x2;
   padding: $x1;
+
+  box-shadow: none;
 }
 
 select {

From 59a9d19304aaaa03c0840bbd366ba486ff852dd6 Mon Sep 17 00:00:00 2001
From: Denis Stasyev <denisstasyev@gmail.com>
Date: Sun, 15 Mar 2020 17:30:46 +0300
Subject: [PATCH 28/38] Add AES-256/CTR

---
 src/libmethods/encryption/block/README.md  |  3 +++
 src/libmethods/encryption/block/aes/ctr.ts | 26 ++++++++++++++++++++++
 src/libmethods/encryption/block/index.ts   |  7 ++++++
 src/libmethods/index.ts                    |  2 ++
 4 files changed, 38 insertions(+)
 create mode 100644 src/libmethods/encryption/block/aes/ctr.ts

diff --git a/src/libmethods/encryption/block/README.md b/src/libmethods/encryption/block/README.md
index 474f14f..29ef335 100644
--- a/src/libmethods/encryption/block/README.md
+++ b/src/libmethods/encryption/block/README.md
@@ -6,9 +6,12 @@ This project includes some versions of AES-256, such as:
 
 - ECB
 - CBC
+- CTR
 
 ### ECB - Electronic Codebook (NOT recommended)
 
 This mode is **not** recommended. Since, for a given key, the same plaintext block in produces the same ciphertext block out, this mode of operation can leak data, such as patterns. For more details and examples, see the Wikipedia article, [Electronic Codebook](http://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#Electronic_Codebook_.28ECB.29).
 
 ### CBC - Cipher-Block Chaining (recommended)
+
+### CTR - Counter (recommended)
diff --git a/src/libmethods/encryption/block/aes/ctr.ts b/src/libmethods/encryption/block/aes/ctr.ts
new file mode 100644
index 0000000..b151257
--- /dev/null
+++ b/src/libmethods/encryption/block/aes/ctr.ts
@@ -0,0 +1,26 @@
+import aesjs from 'aes-js';
+
+import { preparePlainText } from 'libmethods/encryption/block/utils';
+
+export function encryptAES256_CTR(key: number[], plainText: string): string {
+  const textUint8ArrayFilled: Uint8Array = preparePlainText(plainText);
+
+  const aesCtr = new aesjs.ModeOfOperation.ctr(key, new aesjs.Counter(5));
+
+  const encryptedBytes = aesCtr.encrypt(textUint8ArrayFilled);
+
+  // The binary data converted to hex
+  const encryptedHex = aesjs.utils.hex.fromBytes(encryptedBytes);
+  return encryptedHex;
+}
+
+export function decryptAES256_CTR(key: number[], encryptedText: string): string {
+  const encryptedBytes = aesjs.utils.hex.toBytes(encryptedText);
+
+  const aesCtr = new aesjs.ModeOfOperation.ctr(key, new aesjs.Counter(5));
+
+  const decryptedTextBytes = aesCtr.decrypt(encryptedBytes);
+
+  const decryptedText = new TextDecoder().decode(decryptedTextBytes);
+  return decryptedText;
+}
diff --git a/src/libmethods/encryption/block/index.ts b/src/libmethods/encryption/block/index.ts
index 1825444..cacb2fd 100644
--- a/src/libmethods/encryption/block/index.ts
+++ b/src/libmethods/encryption/block/index.ts
@@ -6,6 +6,7 @@ import { getNormalizedKey, getNormalizedIv } from 'libmethods/encryption/block/u
 
 import { encryptAES256_ECB, decryptAES256_ECB } from 'libmethods/encryption/block/aes/ecb';
 import { encryptAES256_CBC, decryptAES256_CBC } from 'libmethods/encryption/block/aes/cbc';
+import { encryptAES256_CTR, decryptAES256_CTR } from 'libmethods/encryption/block/aes/ctr';
 
 export function getEncryptedText(
   method: Method,
@@ -22,6 +23,9 @@ export function getEncryptedText(
     case blockEncryptionTypes.aes256cbc:
       encryptedText = encryptAES256_CBC(getNormalizedKey(key), plainText, getNormalizedIv(iv));
       break;
+    case blockEncryptionTypes.aes256ctr:
+      encryptedText = encryptAES256_CTR(getNormalizedKey(key), plainText);
+      break;
   }
 
   return encryptedText;
@@ -47,6 +51,9 @@ export function getDecryptedText(
       case blockEncryptionTypes.aes256cbc:
         decryptionResult.text = decryptAES256_CBC(getNormalizedKey(key), encryptedText, iv);
         break;
+      case blockEncryptionTypes.aes256ctr:
+        decryptionResult.text = decryptAES256_CTR(getNormalizedKey(key), encryptedText);
+        break;
     }
   } catch {
     decryptionResult.error = 'Невалидный закрытый текст!';
diff --git a/src/libmethods/index.ts b/src/libmethods/index.ts
index 03c0169..6d37407 100644
--- a/src/libmethods/index.ts
+++ b/src/libmethods/index.ts
@@ -27,11 +27,13 @@ export interface BlockMethod extends Method {
 export const blockEncryptionTypes = {
   aes256ecb: 'aes256ecb',
   aes256cbc: 'aes256cbc',
+  aes256ctr: 'aes256ctr',
 };
 
 export const blockEncryptionMethods: BlockMethod[] = [
   { type: blockEncryptionTypes.aes256ecb, name: 'AES-256/ECB', withIv: false },
   { type: blockEncryptionTypes.aes256cbc, name: 'AES-256/CBC', withIv: true },
+  { type: blockEncryptionTypes.aes256ctr, name: 'AES-256/CTR', withIv: false },
 ];
 
 /**

From 53c9516a0e8aaf8d7ab5a8f6a446a0c11975e133 Mon Sep 17 00:00:00 2001
From: Denis Stasyev <denisstasyev@gmail.com>
Date: Sun, 15 Mar 2020 17:40:37 +0300
Subject: [PATCH 29/38] Add AES-256/CFB

---
 src/libmethods/encryption/block/README.md  |  3 +++
 src/libmethods/encryption/block/aes/cfb.ts | 28 ++++++++++++++++++++++
 src/libmethods/encryption/block/index.ts   |  7 ++++++
 src/libmethods/index.ts                    |  2 ++
 4 files changed, 40 insertions(+)
 create mode 100644 src/libmethods/encryption/block/aes/cfb.ts

diff --git a/src/libmethods/encryption/block/README.md b/src/libmethods/encryption/block/README.md
index 29ef335..5795378 100644
--- a/src/libmethods/encryption/block/README.md
+++ b/src/libmethods/encryption/block/README.md
@@ -7,6 +7,7 @@ This project includes some versions of AES-256, such as:
 - ECB
 - CBC
 - CTR
+- CFB
 
 ### ECB - Electronic Codebook (NOT recommended)
 
@@ -15,3 +16,5 @@ This mode is **not** recommended. Since, for a given key, the same plaintext blo
 ### CBC - Cipher-Block Chaining (recommended)
 
 ### CTR - Counter (recommended)
+
+### CFB - Cipher Feedback
diff --git a/src/libmethods/encryption/block/aes/cfb.ts b/src/libmethods/encryption/block/aes/cfb.ts
new file mode 100644
index 0000000..6481185
--- /dev/null
+++ b/src/libmethods/encryption/block/aes/cfb.ts
@@ -0,0 +1,28 @@
+import aesjs from 'aes-js';
+
+import { preparePlainText } from 'libmethods/encryption/block/utils';
+
+const segmentSize = 8;
+
+export function encryptAES256_CFB(key: number[], plainText: string, iv: number[]): string {
+  const textUint8ArrayFilled: Uint8Array = preparePlainText(plainText);
+
+  const aesCfb = new aesjs.ModeOfOperation.cfb(key, iv, segmentSize);
+
+  const encryptedBytes = aesCfb.encrypt(textUint8ArrayFilled);
+
+  // The binary data converted to hex
+  const encryptedHex = aesjs.utils.hex.fromBytes(encryptedBytes);
+  return encryptedHex;
+}
+
+export function decryptAES256_CFB(key: number[], encryptedText: string, iv: number[]): string {
+  const encryptedBytes = aesjs.utils.hex.toBytes(encryptedText);
+
+  const aesCfb = new aesjs.ModeOfOperation.cfb(key, iv, segmentSize);
+
+  const decryptedTextBytes = aesCfb.decrypt(encryptedBytes);
+
+  const decryptedText = new TextDecoder().decode(decryptedTextBytes);
+  return decryptedText;
+}
diff --git a/src/libmethods/encryption/block/index.ts b/src/libmethods/encryption/block/index.ts
index cacb2fd..7f120e5 100644
--- a/src/libmethods/encryption/block/index.ts
+++ b/src/libmethods/encryption/block/index.ts
@@ -7,6 +7,7 @@ import { getNormalizedKey, getNormalizedIv } from 'libmethods/encryption/block/u
 import { encryptAES256_ECB, decryptAES256_ECB } from 'libmethods/encryption/block/aes/ecb';
 import { encryptAES256_CBC, decryptAES256_CBC } from 'libmethods/encryption/block/aes/cbc';
 import { encryptAES256_CTR, decryptAES256_CTR } from 'libmethods/encryption/block/aes/ctr';
+import { encryptAES256_CFB, decryptAES256_CFB } from 'libmethods/encryption/block/aes/cfb';
 
 export function getEncryptedText(
   method: Method,
@@ -26,6 +27,9 @@ export function getEncryptedText(
     case blockEncryptionTypes.aes256ctr:
       encryptedText = encryptAES256_CTR(getNormalizedKey(key), plainText);
       break;
+    case blockEncryptionTypes.aes256cfb:
+      encryptedText = encryptAES256_CFB(getNormalizedKey(key), plainText, getNormalizedIv(iv));
+      break;
   }
 
   return encryptedText;
@@ -54,6 +58,9 @@ export function getDecryptedText(
       case blockEncryptionTypes.aes256ctr:
         decryptionResult.text = decryptAES256_CTR(getNormalizedKey(key), encryptedText);
         break;
+      case blockEncryptionTypes.aes256cfb:
+        decryptionResult.text = decryptAES256_CFB(getNormalizedKey(key), encryptedText, iv);
+        break;
     }
   } catch {
     decryptionResult.error = 'Невалидный закрытый текст!';
diff --git a/src/libmethods/index.ts b/src/libmethods/index.ts
index 6d37407..cddc63c 100644
--- a/src/libmethods/index.ts
+++ b/src/libmethods/index.ts
@@ -28,12 +28,14 @@ export const blockEncryptionTypes = {
   aes256ecb: 'aes256ecb',
   aes256cbc: 'aes256cbc',
   aes256ctr: 'aes256ctr',
+  aes256cfb: 'aes256cfb',
 };
 
 export const blockEncryptionMethods: BlockMethod[] = [
   { type: blockEncryptionTypes.aes256ecb, name: 'AES-256/ECB', withIv: false },
   { type: blockEncryptionTypes.aes256cbc, name: 'AES-256/CBC', withIv: true },
   { type: blockEncryptionTypes.aes256ctr, name: 'AES-256/CTR', withIv: false },
+  { type: blockEncryptionTypes.aes256cfb, name: 'AES-256/CFB', withIv: true },
 ];
 
 /**

From 6bb1a381146612777ef3d9e106b4eeb070a38daf Mon Sep 17 00:00:00 2001
From: Denis Stasyev <denisstasyev@gmail.com>
Date: Sun, 15 Mar 2020 17:46:37 +0300
Subject: [PATCH 30/38] Add AES-256/OFB

---
 src/libmethods/encryption/block/README.md  |  3 +++
 src/libmethods/encryption/block/aes/ofb.ts | 26 ++++++++++++++++++++++
 src/libmethods/encryption/block/index.ts   |  7 ++++++
 src/libmethods/index.ts                    |  2 ++
 4 files changed, 38 insertions(+)
 create mode 100644 src/libmethods/encryption/block/aes/ofb.ts

diff --git a/src/libmethods/encryption/block/README.md b/src/libmethods/encryption/block/README.md
index 5795378..5e6efdd 100644
--- a/src/libmethods/encryption/block/README.md
+++ b/src/libmethods/encryption/block/README.md
@@ -8,6 +8,7 @@ This project includes some versions of AES-256, such as:
 - CBC
 - CTR
 - CFB
+- OFB
 
 ### ECB - Electronic Codebook (NOT recommended)
 
@@ -18,3 +19,5 @@ This mode is **not** recommended. Since, for a given key, the same plaintext blo
 ### CTR - Counter (recommended)
 
 ### CFB - Cipher Feedback
+
+### OFB - Output Feedback
diff --git a/src/libmethods/encryption/block/aes/ofb.ts b/src/libmethods/encryption/block/aes/ofb.ts
new file mode 100644
index 0000000..e28f32d
--- /dev/null
+++ b/src/libmethods/encryption/block/aes/ofb.ts
@@ -0,0 +1,26 @@
+import aesjs from 'aes-js';
+
+import { preparePlainText } from 'libmethods/encryption/block/utils';
+
+export function encryptAES256_OFB(key: number[], plainText: string, iv: number[]): string {
+  const textUint8ArrayFilled: Uint8Array = preparePlainText(plainText);
+
+  const aesOfb = new aesjs.ModeOfOperation.ofb(key, iv);
+
+  const encryptedBytes = aesOfb.encrypt(textUint8ArrayFilled);
+
+  // The binary data converted to hex
+  const encryptedHex = aesjs.utils.hex.fromBytes(encryptedBytes);
+  return encryptedHex;
+}
+
+export function decryptAES256_OFB(key: number[], encryptedText: string, iv: number[]): string {
+  const encryptedBytes = aesjs.utils.hex.toBytes(encryptedText);
+
+  const aesOfb = new aesjs.ModeOfOperation.ofb(key, iv);
+
+  const decryptedTextBytes = aesOfb.decrypt(encryptedBytes);
+
+  const decryptedText = new TextDecoder().decode(decryptedTextBytes);
+  return decryptedText;
+}
diff --git a/src/libmethods/encryption/block/index.ts b/src/libmethods/encryption/block/index.ts
index 7f120e5..eb5dcf0 100644
--- a/src/libmethods/encryption/block/index.ts
+++ b/src/libmethods/encryption/block/index.ts
@@ -8,6 +8,7 @@ import { encryptAES256_ECB, decryptAES256_ECB } from 'libmethods/encryption/bloc
 import { encryptAES256_CBC, decryptAES256_CBC } from 'libmethods/encryption/block/aes/cbc';
 import { encryptAES256_CTR, decryptAES256_CTR } from 'libmethods/encryption/block/aes/ctr';
 import { encryptAES256_CFB, decryptAES256_CFB } from 'libmethods/encryption/block/aes/cfb';
+import { encryptAES256_OFB, decryptAES256_OFB } from 'libmethods/encryption/block/aes/ofb';
 
 export function getEncryptedText(
   method: Method,
@@ -30,6 +31,9 @@ export function getEncryptedText(
     case blockEncryptionTypes.aes256cfb:
       encryptedText = encryptAES256_CFB(getNormalizedKey(key), plainText, getNormalizedIv(iv));
       break;
+    case blockEncryptionTypes.aes256ofb:
+      encryptedText = encryptAES256_OFB(getNormalizedKey(key), plainText, getNormalizedIv(iv));
+      break;
   }
 
   return encryptedText;
@@ -61,6 +65,9 @@ export function getDecryptedText(
       case blockEncryptionTypes.aes256cfb:
         decryptionResult.text = decryptAES256_CFB(getNormalizedKey(key), encryptedText, iv);
         break;
+      case blockEncryptionTypes.aes256ofb:
+        decryptionResult.text = decryptAES256_OFB(getNormalizedKey(key), encryptedText, iv);
+        break;
     }
   } catch {
     decryptionResult.error = 'Невалидный закрытый текст!';
diff --git a/src/libmethods/index.ts b/src/libmethods/index.ts
index cddc63c..d119736 100644
--- a/src/libmethods/index.ts
+++ b/src/libmethods/index.ts
@@ -29,6 +29,7 @@ export const blockEncryptionTypes = {
   aes256cbc: 'aes256cbc',
   aes256ctr: 'aes256ctr',
   aes256cfb: 'aes256cfb',
+  aes256ofb: 'aes256ofb',
 };
 
 export const blockEncryptionMethods: BlockMethod[] = [
@@ -36,6 +37,7 @@ export const blockEncryptionMethods: BlockMethod[] = [
   { type: blockEncryptionTypes.aes256cbc, name: 'AES-256/CBC', withIv: true },
   { type: blockEncryptionTypes.aes256ctr, name: 'AES-256/CTR', withIv: false },
   { type: blockEncryptionTypes.aes256cfb, name: 'AES-256/CFB', withIv: true },
+  { type: blockEncryptionTypes.aes256ofb, name: 'AES-256/OFB', withIv: true },
 ];
 
 /**

From 7313ff30de94238ac6b277d0c1ef4bfc135710c5 Mon Sep 17 00:00:00 2001
From: Mikhail Pakhomov <mikhan333@mail.ru>
Date: Sun, 15 Mar 2020 19:20:59 +0300
Subject: [PATCH 31/38] Fix minor erros

---
 src/libmethods/encryption/block/index.ts | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/src/libmethods/encryption/block/index.ts b/src/libmethods/encryption/block/index.ts
index b6cc888..8c9b6cd 100644
--- a/src/libmethods/encryption/block/index.ts
+++ b/src/libmethods/encryption/block/index.ts
@@ -39,13 +39,21 @@ export function getEncryptedText(
       );
       break;
     case blockEncryptionTypes.aes256ctr:
-      encryptedText = encryptAES256_CTR(getNormalizedKey(key), plainText);
+      encryptionResult.encryptedText = encryptAES256_CTR(getNormalizedKey(key), plainText);
       break;
     case blockEncryptionTypes.aes256cfb:
-      encryptedText = encryptAES256_CFB(getNormalizedKey(key), plainText, getNormalizedIv(iv));
+      encryptionResult.encryptedText = encryptAES256_CFB(
+        getNormalizedKey(key),
+        plainText,
+        encryptionResult.iv || [],
+      );
       break;
     case blockEncryptionTypes.aes256ofb:
-      encryptedText = encryptAES256_OFB(getNormalizedKey(key), plainText, getNormalizedIv(iv));
+      encryptionResult.encryptedText = encryptAES256_OFB(
+        getNormalizedKey(key),
+        plainText,
+        encryptionResult.iv || [],
+      );
       break;
   }
 

From ea1105436a6b6f7c81022e3e5876b7853f416afd Mon Sep 17 00:00:00 2001
From: Mikhail Pakhomov <mikhan333@mail.ru>
Date: Sun, 15 Mar 2020 19:23:01 +0300
Subject: [PATCH 32/38] Fix error

---
 src/containers/Decrypt/Block/BlockDecrypt.tsx |  7 ++++---
 src/libmethods/encryption/block/index.ts      | 14 +++++++++++---
 2 files changed, 15 insertions(+), 6 deletions(-)

diff --git a/src/containers/Decrypt/Block/BlockDecrypt.tsx b/src/containers/Decrypt/Block/BlockDecrypt.tsx
index 5a91d0b..653f226 100644
--- a/src/containers/Decrypt/Block/BlockDecrypt.tsx
+++ b/src/containers/Decrypt/Block/BlockDecrypt.tsx
@@ -63,11 +63,12 @@ export default function() {
     setEncryptedText(encryptedText);
 
     // @ts-ignore
-    setIv(
+    const ivJson =
+      // @ts-ignore
       objectJson[INITIALIZATION_VECTOR] === undefined
         ? ''
-        : objectJson[INITIALIZATION_VECTOR].toString(),
-    );
+        : objectJson[INITIALIZATION_VECTOR].toString();
+    setIv(ivJson);
   }
 
   const setResult = () => {
diff --git a/src/libmethods/encryption/block/index.ts b/src/libmethods/encryption/block/index.ts
index 8c9b6cd..3badc21 100644
--- a/src/libmethods/encryption/block/index.ts
+++ b/src/libmethods/encryption/block/index.ts
@@ -87,13 +87,21 @@ export function getDecryptedText(
         );
         break;
       case blockEncryptionTypes.aes256ctr:
-        decryptionResult.text = decryptAES256_CTR(getNormalizedKey(key), encryptedText);
+        decryptionResult.decryptedText = decryptAES256_CTR(getNormalizedKey(key), encryptedText);
         break;
       case blockEncryptionTypes.aes256cfb:
-        decryptionResult.text = decryptAES256_CFB(getNormalizedKey(key), encryptedText, iv);
+        decryptionResult.decryptedText = decryptAES256_CFB(
+          getNormalizedKey(key),
+          encryptedText,
+          iv || zeroIv,
+        );
         break;
       case blockEncryptionTypes.aes256ofb:
-        decryptionResult.text = decryptAES256_OFB(getNormalizedKey(key), encryptedText, iv);
+        decryptionResult.decryptedText = decryptAES256_OFB(
+          getNormalizedKey(key),
+          encryptedText,
+          iv || zeroIv,
+        );
         break;
     }
   } catch {

From 809c68bac876dfbde6fd9e02771986770c0ecfbd Mon Sep 17 00:00:00 2001
From: Mikhail Pakhomov <mikhan333@mail.ru>
Date: Sun, 15 Mar 2020 19:29:42 +0300
Subject: [PATCH 33/38] Small style fixes

---
 src/containers/Encrypt/Block/BlockEncrypt.tsx | 22 ++++++++++---------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/src/containers/Encrypt/Block/BlockEncrypt.tsx b/src/containers/Encrypt/Block/BlockEncrypt.tsx
index c14390e..5ca6b8b 100644
--- a/src/containers/Encrypt/Block/BlockEncrypt.tsx
+++ b/src/containers/Encrypt/Block/BlockEncrypt.tsx
@@ -89,16 +89,18 @@ export default function() {
             </option>
           ))}
         </select>
-        {method.withIv && (
-          <>
-            <span>2) Ввести вектор инициализации вручную:</span>
-            <input
-              type="checkbox"
-              checked={IvInputBool}
-              onChange={() => setIvInputBool(!IvInputBool)}
-            />
-          </>
-        )}
+        <span>
+          {method.withIv && (
+            <>
+              <span>2) Ввести вектор инициализации вручную:</span>
+              <input
+                type="checkbox"
+                checked={IvInputBool}
+                onChange={() => setIvInputBool(!IvInputBool)}
+              />
+            </>
+          )}
+        </span>
         {IvInputBool && (
           <>
             <span>2.1) Введите вектор инициализации:</span>

From 5db72f6cf9d0c9b2b01807325f8f62bdac68b600 Mon Sep 17 00:00:00 2001
From: Mikhail Pakhomov <mikhan333@mail.ru>
Date: Sun, 15 Mar 2020 19:46:38 +0300
Subject: [PATCH 34/38] Add generating random iv

---
 package-lock.json                             | 13 +++++++++
 package.json                                  |  1 +
 src/containers/Decrypt/Block/BlockDecrypt.tsx | 24 ++++++++--------
 src/containers/Encrypt/Basic/BasicEncrypt.tsx |  2 +-
 src/containers/Encrypt/Block/BlockEncrypt.tsx | 28 +++++++++----------
 src/libmethods/encryption/block/utils.ts      |  3 +-
 6 files changed, 43 insertions(+), 28 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 8b34e8e..2a4b95d 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -12500,6 +12500,19 @@
       "resolved": "https://registry.npmjs.org/js-base64/-/js-base64-2.5.2.tgz",
       "integrity": "sha512-Vg8czh0Q7sFBSUMWWArX/miJeBWYBPpdU/3M/DKSaekLMqrqVPaedp+5mZhie/r0lgrcaYBfwXatEew6gwgiQQ=="
     },
+    "js-crypto-env": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/js-crypto-env/-/js-crypto-env-0.3.2.tgz",
+      "integrity": "sha512-F1uHiCkSOo36qBuuZABA4sBf+xeFBzhJZ0Sd7af8FAruszIhm1Xxv+Zr5Ne90Zlh7/fnxCsrdkj0N8f0a3lVlQ=="
+    },
+    "js-crypto-random": {
+      "version": "0.4.3",
+      "resolved": "https://registry.npmjs.org/js-crypto-random/-/js-crypto-random-0.4.3.tgz",
+      "integrity": "sha512-C3gzphPPfw9jfQ9Q/LjhJMZxQNp3AaoVRDvyZkiB+zYltfs8tKQPsskWkXACpg1Nzh01PtSRUvVijjptd2qGHQ==",
+      "requires": {
+        "js-crypto-env": "^0.3.2"
+      }
+    },
     "js-tokens": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
diff --git a/package.json b/package.json
index 6b8bbff..75a1678 100644
--- a/package.json
+++ b/package.json
@@ -19,6 +19,7 @@
     "crypto-js": "^4.0.0",
     "fletcher": "0.0.3",
     "gost89": "^0.1.11",
+    "js-crypto-random": "^0.4.3",
     "node-sass": "^4.13.1",
     "react": "^16.12.0",
     "react-dom": "^16.12.0",
diff --git a/src/containers/Decrypt/Block/BlockDecrypt.tsx b/src/containers/Decrypt/Block/BlockDecrypt.tsx
index 653f226..870dc54 100644
--- a/src/containers/Decrypt/Block/BlockDecrypt.tsx
+++ b/src/containers/Decrypt/Block/BlockDecrypt.tsx
@@ -182,28 +182,28 @@ export default function() {
                 </option>
               ))}
             </select>
-            {method.withIv && (
-              <>
-                <span>2) Введите вектор инициализации:</span>
-                <input
-                  value={iv}
-                  placeholder="Ваш вектор инициализации"
-                  onChange={(event: any) => setIv(event.target.value)}
-                />
-              </>
-            )}
-            <span>3) Введите ключ для расшифрования:</span>
+            <span>2) Введите ключ для расшифрования:</span>
             <input
               value={key}
               placeholder="Ваш ключ"
               onChange={(event: any) => setKey(event.target.value)}
             />
-            <span>4) Введите закрытый текст, который хотите расшифровать:</span>
+            <span>3) Введите закрытый текст, который хотите расшифровать:</span>
             <textarea
               value={encryptedText}
               placeholder="Ваш закрытый текст"
               onChange={(event: any) => setEncryptedText(event.target.value)}
             />
+            {method.withIv && (
+              <>
+                <span>4) Введите вектор инициализации:</span>
+                <input
+                  value={iv}
+                  placeholder="Ваш вектор инициализации"
+                  onChange={(event: any) => setIv(event.target.value)}
+                />
+              </>
+            )}
             {error && <Alarm type="error" text={`Ошибка! ${error}`} />}
             <button onClick={onSubmit}>Расшифровать!</button>
           </>
diff --git a/src/containers/Encrypt/Basic/BasicEncrypt.tsx b/src/containers/Encrypt/Basic/BasicEncrypt.tsx
index f539312..e49e33e 100644
--- a/src/containers/Encrypt/Basic/BasicEncrypt.tsx
+++ b/src/containers/Encrypt/Basic/BasicEncrypt.tsx
@@ -117,7 +117,7 @@ const Encrypt: React.SFC<EncryptStateProps> = props => {
         <span>
           {props.method.type === encryptionTypes.caesar && (
             <div>
-              1.1) Использовать обычный сдвиг (без хеширования)
+              1.1) Использовать обычный сдвиг (без хеширования):
               <input
                 type="checkbox"
                 checked={caesarVariant}
diff --git a/src/containers/Encrypt/Block/BlockEncrypt.tsx b/src/containers/Encrypt/Block/BlockEncrypt.tsx
index 5ca6b8b..e3f642b 100644
--- a/src/containers/Encrypt/Block/BlockEncrypt.tsx
+++ b/src/containers/Encrypt/Block/BlockEncrypt.tsx
@@ -89,10 +89,22 @@ export default function() {
             </option>
           ))}
         </select>
+        <span>2) Введите ключ для шифрования:</span>
+        <input
+          value={key}
+          placeholder="Ваш ключ"
+          onChange={(event: any) => setKey(event.target.value)}
+        />
+        <span>3) Введите открытый текст, который хотите зашифровать:</span>
+        <textarea
+          value={plainText}
+          placeholder="Ваш открытый текст"
+          onChange={(event: any) => setPlainText(event.target.value)}
+        />
         <span>
           {method.withIv && (
             <>
-              <span>2) Ввести вектор инициализации вручную:</span>
+              <span>4) Введите вектор инициализации вручную:</span>
               <input
                 type="checkbox"
                 checked={IvInputBool}
@@ -103,7 +115,7 @@ export default function() {
         </span>
         {IvInputBool && (
           <>
-            <span>2.1) Введите вектор инициализации:</span>
+            <span>4.1) Введите вектор инициализации:</span>
             <input
               value={iv}
               placeholder="Ваш вектор инициализации"
@@ -111,18 +123,6 @@ export default function() {
             />
           </>
         )}
-        <span>3) Введите ключ для шифрования:</span>
-        <input
-          value={key}
-          placeholder="Ваш ключ"
-          onChange={(event: any) => setKey(event.target.value)}
-        />
-        <span>4) Введите открытый текст, который хотите зашифровать:</span>
-        <textarea
-          value={plainText}
-          placeholder="Ваш открытый текст"
-          onChange={(event: any) => setPlainText(event.target.value)}
-        />
         {error && <Alarm type="error" text={`Ошибка! ${error}`} />}
         <button onClick={onSubmit}>Зашифровать!</button>
       </ContentBox>
diff --git a/src/libmethods/encryption/block/utils.ts b/src/libmethods/encryption/block/utils.ts
index c7ec61d..c2e9ddc 100644
--- a/src/libmethods/encryption/block/utils.ts
+++ b/src/libmethods/encryption/block/utils.ts
@@ -1,5 +1,6 @@
 import { getSHA256 } from 'libmethods/hashing/sha256';
 import { toHexFormat } from 'libmethods/hashing';
+import { getRandomBytes } from 'js-crypto-random';
 
 /**
  * Convert string key into Array of 4 elements with 128 bit size.
@@ -27,7 +28,7 @@ export function getNormalizedIv(iv: string): number[] | undefined {
 }
 
 export function generateIv(): number[] {
-  return [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
+  return Array.from(getRandomBytes(16));
 }
 
 /**

From bdd72cafe3fb37b9465bf209ddc46a45111f1f30 Mon Sep 17 00:00:00 2001
From: Mikhail Pakhomov <mikhan333@mail.ru>
Date: Sun, 15 Mar 2020 19:50:51 +0300
Subject: [PATCH 35/38] Delete parser

---
 package.json                                  | 2 +-
 src/containers/Decrypt/Block/BlockDecrypt.tsx | 4 +---
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/package.json b/package.json
index 75a1678..7fcd156 100644
--- a/package.json
+++ b/package.json
@@ -69,7 +69,7 @@
   },
   "husky": {
     "hooks": {
-      "pre-commit": "lint-staged"
+      "pre-commit": ""
     }
   },
   "lint-staged": {
diff --git a/src/containers/Decrypt/Block/BlockDecrypt.tsx b/src/containers/Decrypt/Block/BlockDecrypt.tsx
index 870dc54..60d50e0 100644
--- a/src/containers/Decrypt/Block/BlockDecrypt.tsx
+++ b/src/containers/Decrypt/Block/BlockDecrypt.tsx
@@ -65,9 +65,7 @@ export default function() {
     // @ts-ignore
     const ivJson =
       // @ts-ignore
-      objectJson[INITIALIZATION_VECTOR] === undefined
-        ? ''
-        : objectJson[INITIALIZATION_VECTOR].toString();
+      objectJson[INITIALIZATION_VECTOR] === undefined ? '' : objectJson[INITIALIZATION_VECTOR].toString();
     setIv(ivJson);
   }
 

From a939a61c9e0e39e7dab5fa585b6eefa6cd9698e9 Mon Sep 17 00:00:00 2001
From: Mikhail Pakhomov <mikhan333@mail.ru>
Date: Sun, 15 Mar 2020 20:13:58 +0300
Subject: [PATCH 36/38] Add default IV

---
 src/containers/Decrypt/Block/BlockDecrypt.tsx |  4 ++--
 src/containers/Encrypt/Block/BlockEncrypt.tsx |  4 ++--
 src/libmethods/encryption/block/index.ts      | 15 +++++++--------
 src/libmethods/encryption/block/utils.ts      |  2 ++
 4 files changed, 13 insertions(+), 12 deletions(-)

diff --git a/src/containers/Decrypt/Block/BlockDecrypt.tsx b/src/containers/Decrypt/Block/BlockDecrypt.tsx
index 60d50e0..1c8c58d 100644
--- a/src/containers/Decrypt/Block/BlockDecrypt.tsx
+++ b/src/containers/Decrypt/Block/BlockDecrypt.tsx
@@ -12,7 +12,7 @@ import {
 
 import { BlockMethod, blockEncryptionMethods } from 'libmethods';
 import { getDecryptedText, DecryptionResult } from 'libmethods/encryption/block';
-import { getNormalizedIv } from 'libmethods/encryption/block/utils';
+import { getNormalizedIv, DEFAULT_IV } from 'libmethods/encryption/block/utils';
 
 import Base64 from 'utils/base64';
 
@@ -22,7 +22,7 @@ export default function() {
 
   const [method, setMethod] = React.useState<BlockMethod>(blockEncryptionMethods[0]);
   const [key, setKey] = React.useState('');
-  const [iv, setIv] = React.useState('');
+  const [iv, setIv] = React.useState(DEFAULT_IV.join(', '));
   const [encryptedText, setEncryptedText] = React.useState('');
   const [error, setError] = React.useState('');
   const [decryptedText, setDecryptedText] = React.useState('');
diff --git a/src/containers/Encrypt/Block/BlockEncrypt.tsx b/src/containers/Encrypt/Block/BlockEncrypt.tsx
index e3f642b..e73180d 100644
--- a/src/containers/Encrypt/Block/BlockEncrypt.tsx
+++ b/src/containers/Encrypt/Block/BlockEncrypt.tsx
@@ -12,13 +12,13 @@ import {
 
 import { BlockMethod, blockEncryptionMethods } from 'libmethods';
 import { getEncryptedText, BlockEncryptionResult } from 'libmethods/encryption/block';
-import { getNormalizedIv } from 'libmethods/encryption/block/utils';
+import { getNormalizedIv, DEFAULT_IV } from 'libmethods/encryption/block/utils';
 
 import Base64 from 'utils/base64';
 
 export default function() {
   const [method, setMethod] = React.useState<BlockMethod>(blockEncryptionMethods[0]);
-  const [iv, setIv] = React.useState('');
+  const [iv, setIv] = React.useState(DEFAULT_IV.join(', '));
   const [ivOutput, setIvOutput] = React.useState<number[] | undefined>(undefined);
   const [IvInputBool, setIvInputBool] = React.useState(false);
   const [key, setKey] = React.useState('');
diff --git a/src/libmethods/encryption/block/index.ts b/src/libmethods/encryption/block/index.ts
index 3badc21..aa9e327 100644
--- a/src/libmethods/encryption/block/index.ts
+++ b/src/libmethods/encryption/block/index.ts
@@ -2,7 +2,7 @@ import { BlockMethod } from 'libmethods';
 
 import { blockEncryptionTypes } from 'libmethods';
 
-import { getNormalizedKey, generateIv } from 'libmethods/encryption/block/utils';
+import { getNormalizedKey, generateIv, DEFAULT_IV } from 'libmethods/encryption/block/utils';
 
 import { encryptAES256_ECB, decryptAES256_ECB } from 'libmethods/encryption/block/aes/ecb';
 import { encryptAES256_CBC, decryptAES256_CBC } from 'libmethods/encryption/block/aes/cbc';
@@ -35,7 +35,7 @@ export function getEncryptedText(
       encryptionResult.encryptedText = encryptAES256_CBC(
         getNormalizedKey(key),
         plainText,
-        encryptionResult.iv || [],
+        encryptionResult.iv || DEFAULT_IV,
       );
       break;
     case blockEncryptionTypes.aes256ctr:
@@ -45,14 +45,14 @@ export function getEncryptedText(
       encryptionResult.encryptedText = encryptAES256_CFB(
         getNormalizedKey(key),
         plainText,
-        encryptionResult.iv || [],
+        encryptionResult.iv || DEFAULT_IV,
       );
       break;
     case blockEncryptionTypes.aes256ofb:
       encryptionResult.encryptedText = encryptAES256_OFB(
         getNormalizedKey(key),
         plainText,
-        encryptionResult.iv || [],
+        encryptionResult.iv || DEFAULT_IV,
       );
       break;
   }
@@ -72,7 +72,6 @@ export function getDecryptedText(
   iv?: number[],
 ): DecryptionResult {
   const decryptionResult: DecryptionResult = { decryptedText: '', error: '' };
-  const zeroIv = Array(16).fill(0);
 
   try {
     switch (method.type) {
@@ -83,7 +82,7 @@ export function getDecryptedText(
         decryptionResult.decryptedText = decryptAES256_CBC(
           getNormalizedKey(key),
           encryptedText,
-          iv || zeroIv,
+          iv || DEFAULT_IV,
         );
         break;
       case blockEncryptionTypes.aes256ctr:
@@ -93,14 +92,14 @@ export function getDecryptedText(
         decryptionResult.decryptedText = decryptAES256_CFB(
           getNormalizedKey(key),
           encryptedText,
-          iv || zeroIv,
+          iv || DEFAULT_IV,
         );
         break;
       case blockEncryptionTypes.aes256ofb:
         decryptionResult.decryptedText = decryptAES256_OFB(
           getNormalizedKey(key),
           encryptedText,
-          iv || zeroIv,
+          iv || DEFAULT_IV,
         );
         break;
     }
diff --git a/src/libmethods/encryption/block/utils.ts b/src/libmethods/encryption/block/utils.ts
index c2e9ddc..b1b749c 100644
--- a/src/libmethods/encryption/block/utils.ts
+++ b/src/libmethods/encryption/block/utils.ts
@@ -31,6 +31,8 @@ export function generateIv(): number[] {
   return Array.from(getRandomBytes(16));
 }
 
+export const DEFAULT_IV = Array(16).fill(0);
+
 /**
  * Convert plain text into filled with spaced at the end (to be multiple of 16) UTF-8 Array
  *

From fc1408e19f1675666b15a4e4202309aff6cedf06 Mon Sep 17 00:00:00 2001
From: Mikhail Pakhomov <mikhan333@mail.ru>
Date: Sun, 15 Mar 2020 20:16:14 +0300
Subject: [PATCH 37/38] Changes for denis

---
 src/containers/Decrypt/Block/BlockDecrypt.tsx | 4 ++--
 src/containers/Encrypt/Block/BlockEncrypt.tsx | 2 +-
 src/libmethods/encryption/block/index.ts      | 6 +++---
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/containers/Decrypt/Block/BlockDecrypt.tsx b/src/containers/Decrypt/Block/BlockDecrypt.tsx
index 1c8c58d..11a57c3 100644
--- a/src/containers/Decrypt/Block/BlockDecrypt.tsx
+++ b/src/containers/Decrypt/Block/BlockDecrypt.tsx
@@ -11,7 +11,7 @@ import {
 } from 'config';
 
 import { BlockMethod, blockEncryptionMethods } from 'libmethods';
-import { getDecryptedText, DecryptionResult } from 'libmethods/encryption/block';
+import { getDecryptedText, BlockDecryptionResult } from 'libmethods/encryption/block';
 import { getNormalizedIv, DEFAULT_IV } from 'libmethods/encryption/block/utils';
 
 import Base64 from 'utils/base64';
@@ -70,7 +70,7 @@ export default function() {
   }
 
   const setResult = () => {
-    const decryptionResult: DecryptionResult = getDecryptedText(
+    const decryptionResult: BlockDecryptionResult = getDecryptedText(
       method,
       key,
       encryptedText,
diff --git a/src/containers/Encrypt/Block/BlockEncrypt.tsx b/src/containers/Encrypt/Block/BlockEncrypt.tsx
index e73180d..184ef93 100644
--- a/src/containers/Encrypt/Block/BlockEncrypt.tsx
+++ b/src/containers/Encrypt/Block/BlockEncrypt.tsx
@@ -104,7 +104,7 @@ export default function() {
         <span>
           {method.withIv && (
             <>
-              <span>4) Введите вектор инициализации вручную:</span>
+              <span>4) Ввести вектор инициализации вручную:</span>
               <input
                 type="checkbox"
                 checked={IvInputBool}
diff --git a/src/libmethods/encryption/block/index.ts b/src/libmethods/encryption/block/index.ts
index aa9e327..d13dd76 100644
--- a/src/libmethods/encryption/block/index.ts
+++ b/src/libmethods/encryption/block/index.ts
@@ -60,7 +60,7 @@ export function getEncryptedText(
   return encryptionResult;
 }
 
-export interface DecryptionResult {
+export interface BlockDecryptionResult {
   decryptedText: string;
   error: string;
 }
@@ -70,8 +70,8 @@ export function getDecryptedText(
   key: string,
   encryptedText: string,
   iv?: number[],
-): DecryptionResult {
-  const decryptionResult: DecryptionResult = { decryptedText: '', error: '' };
+): BlockDecryptionResult {
+  const decryptionResult: BlockDecryptionResult = { decryptedText: '', error: '' };
 
   try {
     switch (method.type) {

From 1aa1929893a944bfe4100823eacbfcace5923ef0 Mon Sep 17 00:00:00 2001
From: Denis Stasyev <denisstasyev@gmail.com>
Date: Sun, 15 Mar 2020 20:27:02 +0300
Subject: [PATCH 38/38] Fix Linter

---
 package.json                                  | 2 +-
 src/containers/Decrypt/Block/BlockDecrypt.tsx | 8 ++++++--
 src/react-app-env.d.ts                        | 1 -
 3 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/package.json b/package.json
index 7fcd156..75a1678 100644
--- a/package.json
+++ b/package.json
@@ -69,7 +69,7 @@
   },
   "husky": {
     "hooks": {
-      "pre-commit": ""
+      "pre-commit": "lint-staged"
     }
   },
   "lint-staged": {
diff --git a/src/containers/Decrypt/Block/BlockDecrypt.tsx b/src/containers/Decrypt/Block/BlockDecrypt.tsx
index 11a57c3..7056b75 100644
--- a/src/containers/Decrypt/Block/BlockDecrypt.tsx
+++ b/src/containers/Decrypt/Block/BlockDecrypt.tsx
@@ -62,10 +62,14 @@ export default function() {
     }
     setEncryptedText(encryptedText);
 
-    // @ts-ignore
     const ivJson =
       // @ts-ignore
-      objectJson[INITIALIZATION_VECTOR] === undefined ? '' : objectJson[INITIALIZATION_VECTOR].toString();
+      objectJson[INITIALIZATION_VECTOR] === undefined
+        ? ''
+        : //prettier-ignore
+          // @ts-ignore
+          objectJson[INITIALIZATION_VECTOR].toString();
+
     setIv(ivJson);
   }
 
diff --git a/src/react-app-env.d.ts b/src/react-app-env.d.ts
index 087727a..36ea484 100644
--- a/src/react-app-env.d.ts
+++ b/src/react-app-env.d.ts
@@ -6,7 +6,6 @@ declare module 'fletcher';
 declare module 'crypto-js/sha256';
 declare module 'crypto-js/sha512';
 declare module 'crypto-js/sha3';
-declare module 'crypto-js/sha3';
 
 declare module 'aes-js';
 declare module 'gost89';