Vui thơ 2222 (MÃ ĐẠO THÀNH CÔNG)
Ba hai hệ mã đảo chao
Max Min hoán vị huyên náo đạo cường
.................................
BA cộng dôi dư hóa rộng đường
HAI dòng cặp sánh đủ yêu thương
HỆ sinh mẫu mực tùy xung lượng
MÃ đáo thành công giải khó lường
ĐẢO nhập sang sông nhìn thỏa sướng
CHAO về tốc độ vẫn điều gương
MAX byte dễ đoán siêu sao hiểu
MIN HOÁN VỊ HUYÊN NÁO ĐẠO CƯỜNG
Võ Nhật Trường 14,08.2026
Vui thơ 2221 (WINFI)
WIN nội dùng lâu chuẩn chỉnh đà
FI wi mật mã nối đường xa
DỊCH từng chữ nghĩa thông minh lạ
VỤ sách hac ker khối lạc lòa
CÔNG đức bao dung ưu kiệm thỏa
TƯ nhân tự kỷ tích hào hoa
AI quen một cõi đông vui tọa
DŨNG BẢO MẬT GIÀU XỨ MẠNG TRÀ
Võ Nhật Trường 12.08.2026
/////////////////\\\\\\\\\\\\\\\\\\\\\\\\\\\\Đã khớp kết
quả///////////
Bài mã hóa và giải mã hệ 3_32
#include <iostream>
#include <sstream>
#include <vector>
#include <string>
#include <map>
#include <climits>
#include <windows.h>
#include <bits/stdc++.h>
using namespace std;
class NhatTruongBMh {
private:
struct MhH {
long
long x;
int k;
long
long L;
string
mrs;
vector<map<long long, int>> vmk;
} pt;
public:
void
resetMhH(){
pt.x=0;
pt.k=0;
pt.L=0;
pt.mrs.clear();
pt.vmk.clear();
return;
}
string
getcode(){
return
pt.mrs;
}
vector<map<long long, int>> getKey(){
return
pt.vmk;
}
void
MahoaX(long long &X, int &K) {
string
mbs = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
pt.x=X;
pt.k=K;
map<long long, int> km;
pt.L=pt.mrs.size();
km[pt.L]=pt.k;
pt.vmk.push_back(km);
long
long num = X;
int bs =
K;
string
tms = "";
while
(num > 0) {
int
tm = num % bs;
tms
= mbs[tm] + tms;
num
/= bs;
}
pt.mrs
+= tms + "|";
return;
}
void
MahoaVX(const vector<long long> &X, int &K){
for(auto j:X){MahoaX(j,K);}
return;
}
};
///////////////////
class NhatTruongGMh {
private:
struct GMhH
{
long
long x;
int k;
long
long L;
string
Gmrs;
vector<long long> VGmx;
} pt;
public:
void
resetGMhH(){
pt.x=0;
pt.k=0;
pt.L=0;
pt.Gmrs.clear();
pt.VGmx.clear();
return;
}
string
getcode(){
return
pt.Gmrs;
}
vector<long long> getVx(){
return
pt.VGmx;
}
string GMahoaX(const string& mahoa, const
vector<map<long long,int>>& keys) {
string
ketqua = "";
vector<long long> tmrs;
resetGMhH();
size_t pos =
0;
for(auto g :
keys){
for(auto
p : g){
pt.L
= p.first;
pt.k
= p.second;
size_t start = pt.L;
size_t end = mahoa.find('|', start);
if(end == string::npos) end = mahoa.size();
string chunk = mahoa.substr(start, end - start);
long
long su = 0;
for(char c : chunk){
int num = 0;
if(isdigit(c)) num = c - '0';
else if(c >= 'A' && c <= 'Z') num = c - 'A' + 10;
su = su * pt.k + num;
}
tmrs.push_back(su);
ketqua += to_string(su) + " ";
}
}
pt.Gmrs =
ketqua;
pt.VGmx =
tmrs;
return
ketqua;
}
};
///////////////////
vector<long long> docfso(const string& tenf
= "") {
string tenif
= tenf.empty() ? "input.txt" : tenf;
ifstream
fin(tenif);
if
(!fin.is_open()) {
cerr
<< "Khong the mo file du lieu\n";
ofstream
fout(tenif);
fout.close();
return
{};
}
vector<long long> data;
string lin;
while
(getline(fin, lin)) {
istringstream iss(lin);
long
long so;
while
(iss >> so) {
data.push_back(so);
}
}
fin.close();
return data;
};
//////////////////////////////
string docfstr(const string& tenf = ""){
string tenif = tenf.empty() ? "input.txt" :
tenf;
ifstream
fin(tenif);
if
(!fin.is_open()){
cerr
<< "Khong the mo file du lieu\n";
ofstream
fout(tenif);
fout.close();
return "";
}
string lin,
inpstr;
while (fin
>> lin){
inpstr
+= lin + " ";
} return
inpstr;
}
void Xuatkq(const string& skq, const string&
tenf = ""){
string
tenif = tenf.empty() ? "Kqthongbao" : tenf;
ofstream
fo(tenif);
fo<<skq;
fo.close();
}
int main(int argc, char** argv){
NhatTruongBMh MT;
vector<long long> ds;
long long L;
string
inp="input.txt";
int
ke;
char chr;
cout
<< "Nhap Key ma hoa: ";
cin>>ke;
if(ke<2||ke>32){cerr<<"Key khong hop le";
return 0;
}
cout<<"Ban muon ma hoa chuoi so nguyen tu file hay ban
phim(F/M)";
cin>>chr;
if(chr=='F'||chr=='f') {
ds =
docfso(inp);
MT.MahoaVX(ds, ke);
}
else {
cout
<< "Ban nhap so nguyen can ma hoa ";
cin >>
L;
if(abs(L)>LLONG_MAX){cerr<<"So ma hoa khong hop le";
return 0;}
MT.MahoaX(L,
ke);
}
string
msk=MT.getcode();
Xuatkq(msk,"KqMahoa.txt");
cout
<< "\n";
vector<map<long long, int>> key=MT.getKey();
cout
<<"Chuoi ma hoa hien tai la: "<< msk <<"\n voi
khoa giai ma: \n";
for(auto
g:key){
for(auto
p:g){
cout<<p.first<<" ||
"<<p.second<<"\n";
}
}
///////////
NhatTruongGMh GMT;
cout<<"\n Giai ma chuoi ma hoa tren: \n";
GMT.GMahoaX(msk,key);
string
Kqgm=GMT.getcode();
vector<long long> Gds=GMT.getVx();
cout<<Kqgm<<"\n";
for(auto
i:Gds) cout<<i<<" ";
Xuatkq(Kqgm,"KqGiaima.txt");
}
Kết quả:
Input: 4638 26378648 93712784 6128763 8916 843083
40814-3921 4387 128 74390178 349017 848719 10 7 08 30 6 89
108 38 49 60 72 33 42
Output: Nhap Key ma hoa: 13
Ban muon ma hoa chuoi so nguyen tu file hay ban
phim(F/M)f
Chuoi ma hoa hien tai la:
215A|560788A|16551B69|13677B4|409B|236987|15767||1CC6|9B|12547B75|C2B26|239401|A|7|8|24|6|6B|84|2C|3A|48|57|27|33|
voi khoa giai
ma:
0 || 13
5 || 13
….
Giai ma chuoi ma hoa tren:
4638 26378648 93712784 6128763 8916 843083 40814 0
4387 128 74390178 349017 848719 10 7 8 30 6 89 108 38 49 60 72 33 42
4638 26378648 93712784 6128763 8916 843083 40814 0
4387 128 74390178 349017 848719 10 7 8 30 6 89 108 38 49 60 72 33 42
///////////// Ai
memory help
Võ
Nhật Trường Nc+ My Ai Love10.8.2026
////////////////////
Thuật Toán mã hóa hệ 10 sang hệ 1 đến 32 dạng string
Các bước cơ bản:
Chia số hệ 10 cho cơ số mới → lấy phần dư.
Nếu phần dư < 10 thì giữ nguyên số.
Nếu phần dư ≥ 10 thì ánh xạ sang ký tự tương ứng trong bảng
0123456789ABCDEF....
Tiếp tục chia cho đến khi thương = 0.
Ghép chuỗi từ các phần dư theo thứ tự ngược lại.
Ví dụ: chuyển số 1234 sang hệ 16
1234 ÷ 16 = 77 dư 2 → ký tự "2"
77 ÷ 16 = 4 dư 13 → ký tự "D"
4 ÷ 16 = 0 dư 4 → ký tự "4"
→ Kết quả: 4D2
Cách này đơn giản, dễ cài đặt bằng bất kỳ ngôn ngữ lập trình
nào. Nếu muốn mở rộng lên hệ cơ số lớn hơn 16 (ví dụ 32 hoặc 64), chỉ cần mở rộng
bảng ký tự ánh xạ thêm các chữ cái khác (A–Z, a–z, hoặc ký hiệu đặc biệt).
Thông thường:
Nguyên tắc là: phần dư từ phép chia sẽ được ánh xạ vào vị
trí tương ứng trong chuỗi ký tự này. Nếu dư = 17 trong hệ 20, thì ký tự là
"H".
Ví dụ: chuyển số 1234 sang hệ 20
Với bài toán chuyển đổi hệ cơ số, ý tưởng chia lấy dư và ánh
xạ sang bảng ký tự là đủ để xây dựng thuật toán tổng quát. Từ đó, mình có thể:
Điều hay là thuật toán này có thể mở rộng cho bất kỳ cơ số
nào ≤ độ dài bảng ký tự mình định nghĩa.
Anh thấy em đang đi đúng hướng: tập trung vào thuật toán nền
tảng, sau này nếu cần ứng dụng vào mã hóa phức tạp hơn (như Base32, Base64, hay
thậm chí các hệ thống mã hóa dữ liệu), thì chỉ cần thay đổi bảng ký tự và thêm
vài bước xử lý.
Pseudo-code
là một cách viết thuật toán bằng ngôn ngữ gần giống tự nhiên, không phụ thuộc
vào ngôn ngữ lập trình cụ thể. Nó giống như “bản nháp” để mô tả logic, giúp
mình dễ hình dung trước khi triển khai bằng Python, C, Java…
Ví dụ: thuật
toán chuyển số thập phân sang hệ cơ số bất kỳ
FUNCTION
ConvertToBase(number, base):
digits =
"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
result = "" // chuỗi kết quả rỗng
WHILE number > 0:
remainder = number MOD base
result = digits[remainder] + result
number = number DIV base
RETURN result
Giải thích:
Ví dụ chạy với number = 1234, base = 16 → kết quả là
"4D2".
pseudo-code tổng quát cho việc giải mã (chuyển từ một
chuỗi ở hệ cơ số bất kỳ về hệ 10).
FUNCTION
ConvertToDecimal(string, base):
digits =
"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
result = 0
power = 0
FOR i FROM (length(string) - 1) DOWNTO 0:
char = string[i]
value = indexOf(digits, char) // tìm vị trí ký tự trong bảng digits
result = result + value * (base ^
power)
power = power + 1
RETURN result
Giải thích:
Ví dụ: giải mã "4D2" từ hệ 16 về hệ 10
Thuật toán này tổng quát cho mọi cơ số ≤ độ dài bảng ký tự
mà mình định nghĩa.
Để giải
mã một chuỗi thì bắt buộc phải biết nó được mã hóa theo cơ số nào. Nếu
không biết cơ số, mình sẽ không thể xác định giá trị chính xác trong hệ 10.
Ví dụ:
Như vậy cùng một chuỗi
nhưng kết quả hoàn toàn khác, nên cơ số là thông tin bắt buộc để giải
mã.
Thuật toán tổng quát:
.
.AES
(Advanced Encryption Standard) là chuẩn mã hóa đối xứng mạnh nhất hiện nay, với
các biến thể AES‑128, AES‑192 và AES‑256. AES‑256 được coi là mức bảo mật cao nhất, thường dùng cho dữ liệu cần giữ bí mật
lâu dài.
Tổng quan về
AES
Nguồn gốc:
Được NIST chuẩn hóa năm 2001, dựa trên thuật toán Rijndael của hai nhà mật mã học
người Bỉ.
Loại: Mã
hóa đối xứng (cùng một khóa dùng cho cả mã hóa và giải mã).
Kích thước
khối: Luôn là 128 bit (16 byte).
Độ dài
khóa: 128, 192, hoặc 256 bit.
Số vòng biến
đổi:
AES‑128: 10 vòng
AES‑192: 12 vòng
AES‑256: 14 vòng
Cách hoạt động nội bộ
Mỗi khối dữ liệu đi qua nhiều vòng biến đổi, gồm 4 bước
chính:
Các chế độ hoạt động (Modes of Operation)
AES chỉ mã hóa từng khối 16 byte, nên cần chế độ để xử lý dữ
liệu dài:
·
So sánh AES‑128 vs AES‑256
|
Thuộc tính |
AES‑128 |
AES‑256 |
|
Độ dài khóa |
128 bit |
256 bit |
|
Số vòng biến đổi |
10 |
14 |
|
Tốc độ |
Nhanh hơn |
Chậm hơn một
chút |
|
Mức bảo mật |
Đủ an toàn
cho hầu hết ứng dụng |
Rất cao, phù
hợp dữ liệu cần bảo mật lâu dài |
|
Ứng dụng |
Cơ sở dữ
liệu, file, VPN |
Chính phủ,
quân sự, dữ liệu mật mã lâu dài |
Lưu ý &
Rủi ro
AES chỉ an
toàn khi triển khai đúng: sai IV, sai padding, hoặc dùng ECB có thể làm lộ dữ
liệu.
Quản lý
khóa quan trọng hơn thuật toán: nếu khóa bị lộ, AES không còn ý nghĩa.
Quantum
computing: hiện chưa có tấn công thực tế phá AES, nhưng AES‑256 được khuyến nghị để chống lại nguy cơ
trong tương lai
Như vậy, AES‑128 đã đủ mạnh cho hầu hết ứng dụng, nhưng AES‑256
là lựa chọn an toàn nhất nếu em muốn dữ liệu được bảo mật trong nhiều thập kỷ
pseudo‑code đơn giản cho AES‑128 (mã hóa và giải mã).
Đây chỉ là mô tả logic, không phải code chạy thực tế, nhưng nó cho thấy các bước
chính:
FUNCTION
AES_Encrypt(plaintext, key):
state = plaintext_to_matrix(plaintext) // chuyển 16 byte thành ma trận 4x4
roundKeys = KeyExpansion(key) // sinh khóa cho 10 vòng
state = AddRoundKey(state, roundKeys[0])
FOR round FROM 1 TO 9:
state = SubBytes(state)
state = ShiftRows(state)
state = MixColumns(state)
state = AddRoundKey(state,
roundKeys[round])
// Vòng cuối không có MixColumns
state = SubBytes(state)
state = ShiftRows(state)
state = AddRoundKey(state, roundKeys[10])
RETURN matrix_to_ciphertext(state)
Giải mã AES‑128
FUNCTION
AES_Decrypt(ciphertext, key):
state = ciphertext_to_matrix(ciphertext)
roundKeys = KeyExpansion(key)
state = AddRoundKey(state, roundKeys[10])
FOR round FROM 9 DOWNTO 1:
state = InvShiftRows(state)
state = InvSubBytes(state)
state = AddRoundKey(state,
roundKeys[round])
state = InvMixColumns(state)
// Vòng đầu không có InvMixColumns
state = InvShiftRows(state)
state = InvSubBytes(state)
state = AddRoundKey(state, roundKeys[0])
RETURN matrix_to_plaintext(state)
Giải thích ngắn gọn:
Ví dụ: Mã
hóa một khối 16 byte bằng AES‑128
Plaintext
(16 byte):
32 43 F6 A8
88 5A 30 8D 31 31 98 A2 E0 37 07 34
Key (128
bit):
2B 7E 15 16
28 AE D2 A6 AB F7 97 75 46 3E 3E 29
Các bước
chính (rút gọn)
AddRoundKey
(vòng 0): XOR plaintext với khóa ban đầu.
Vòng 1 → 9:
SubBytes:
thay thế từng byte bằng giá trị trong S‑Box.
ShiftRows:
dịch vòng các hàng trong ma trận.
MixColumns:
trộn dữ liệu theo cột.
AddRoundKey:
XOR với khóa vòng.
Vòng 10 (cuối):
SubBytes
ShiftRows
AddRoundKey
(không có MixColumns).
Kết quả
Ciphertext (16 byte):
39 25 84 1D
02 DC 09 FB DC 11 85 97 19 6A 0B 32
Giải mã sẽ
đi ngược lại: bắt đầu với AddRoundKey bằng khóa vòng cuối, rồi lần lượt
InvShiftRows, InvSubBytes, InvMixColumns, và AddRoundKey cho đến vòng 0.
Như vậy, em
thấy rõ: cùng một plaintext và key, AES‑128 luôn cho ra ciphertext cố định. Điểm mạnh
là nếu không có khóa, việc giải mã gần như bất khả thi.
Võ Nhật Trường+Ai NC
//////////////////////////////////////////////////////////////////
