misc总结(编码密码篇)

推荐使用https://www.dcode.fr/和CyberChef

常见编码/加密

1.1. ASCII编码

ASCII码大致可以分作三部分组成。

第一部分是：ASCII非打印控制字符。ASCII表上的数字0–31分配给了控制字符，用于控制像打印机等一些外围设备。

第二部分是：ASCII打印字符。数字 32–126 分配给了能在键盘上找到的字符，数字127代表 DELETE 命令。

第三部分是：扩展ASCII打印字符。扩展的ASCII字符满足了对更多字符的需求。扩展的ASCII包含ASCII中已有的128个字符（数字0–32显示在下图中），又增加了128个字符，总共是256个。

1.2. Base家族

base64 编码是用64（2^6）个字符，对二进制数据进行编码的方式
base32 就是用32（2^5）个字符，对二进制数据进行编码的方式
base16 就是用16（2^4）个字符，对二进制数据进行编码的方式

这里我们可以清楚的看到，base系列编码之间的不同，在于用于编码的字符数量的多少
具体参考wiki百科

1.2.1. base16码表

0123456789ABCDEF

Base16使用两个ASCII字符去编码原数据中的一个字节数据，所以Base16不可能用到填充符号=

1.2.2. base32码表

ABCDEFGHIJKLMNOPQRSTUVWXYZ234567

另有=符号作为填充

1.2.3. base58码表

123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz

相比 Base_64，Base_58 不使用数字 “0”，字母大写”O”，字母大写 “I”，和字母小写 “l”，以及 “+” 和 “/“ 符号，比Base64共减少6个字符，故称着Base58

1.2.4. base62码表

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789

Base62使用了62个字符编码，包括0-9，a-z，A-Z。

1.2.5. base64码表

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/

另有=符号作为填充

1.2.6. base91码表

Base91编码是从94个可打印ASCII字符（0x21-0x7E）中，以下三个字符被省略以构建Base91编码表：-（破折号，0x2D）\（反斜杠，0x5C）’（撇号，0x27）

1.3. Quoted-printable 编码

Quoted-printable或QP encoding，没有规范的中文译名，可译为可打印字符引用编码或使用可打印字符的编码。Quoted-printable是使用可打印的ASCII字符（如字母、数字与“=”）表示各种编码格式下的字符，以便能在7-bit数据通路上传输8-bit数据, 或者更一般地说在非8-bit clean媒体上正确处理数据。这被定义为MIME content transfer encoding，用于e-mail。

例子：

1
=E4=BB=8A=E5=B9=B4=E5=85=83=E5=A4=9C=E6=97=B6=EF=BC=8C=E6=9C=88=E4=B8=8E=E7=81=AF=E4=BE=9D=E6=97=A7=E3=80=82

特点：由=，大写字母A–F和数字0-9组成，不加密英文和数字

解码：CyberChef可解

1.4. XXencode编码

表：+-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

XXencode将输入文本以每三个字节为单位进行编码。如果最后剩下的资料少于三个字节，不够的部份用零补齐。这三个字节共有24个Bit，以6bit为单位分为4个组，每个组以十进制来表示所出现的数值只会落在0到63之间。以所对应值的位置字符代替。

例子：

1
2
3
4
5
hK3VZPaBjN4KxewfYmCjCl94yohH1jwXxiDPLpfrOneepdQuvjTXEo95UkiiV
hcwXbiTjLvffnmeDDkfL2pwf-nwbNoxf6zPXqpxOxqeCggfitivL2gfyrrRD1
hkSCmiQPfcODJsgXxiDPLpfrOiP9Ho16oiDN0OLGXfB9IBa7dRAuehOLCivTK
hnecoiDPLuOCgkvysxhTdohH8ffrspgP+h95hmfv9yPDqnxOplAfxpfLKivjV
dkiHIqX0pjHMnpeuwt84XohH9yPPIouPKhPL2nfjKkxTKhzioygnacOA+

特点：第一位通常表示这一行密文是由多少个字符加密得到的，比如cat加密后是1Mq3o，1在表中的索引值是3，所以可以看做原文由三位字符组成。并且每行最多只能加密45个字符，然后换行，可以参考上面的例子

在线加解密

1.5. UUencode编码

表：ASCII字符集中可打印字符(32-96)

UUencode是一种二进制到文字的编码，最早在unix 邮件系统中使用，全称：Unix-to-Unix encoding，UUencode将输入文本以每三个字节为单位进行编码，如果最后剩下的资料少于三个字节，不够的部份用零补齐。三个字节共有24个Bit，以6-bit为单位分为4个组，每个组以十进制来表示所出现的字节的数值。这个数值只会落在0到63之间。然后将每个数加上32，所产生的结果刚好落在ASCII字符集中可打印字符（32-空白…95-底线）的范围之中。

例子：

1
2
3
4
5
6
7
8
9
M555E;F-O9&7*Q]*[UM:V_KWXUL:UO<[$U]:UQ+'@PNNCK-?NU.?4VG5N:7@@
MT\J\_L^US;/6T,JYT\.CK,BKL\:CNE5N:7@M=&\M56YI>"!E;F-O9&EN9Z.L
M555E;F-O9&6]J\KDR.O.Q+&^TM3#O\C]N/;7UKW:SJJUI<Z[O?C0T+'@PNNC
MK,CGN?O7[KKSRJ//PK7$U\K!S\G9T]K(_;CVU]:]VJ.LLKNYN[7$LK^WW=/#
MP>.RN<;KH:/(_;CVU]:]VKFRT]`R-+CV0FETHZS2U#8M8FETSJJUI<Z[M];.
MJC2X]M?IHZS#O[CVU^G2U,JNO?C6QL"TL>W*OLOYL_;/UK7$U]:]VK7$ROW6
MM:&CU>*X]LK]UK76N[OAPN34VC"UO38SUJZ\Y*&CR+NZ\[VKP[^X]LK]O-/)
MSS,RHZS+^;+ZR?JUQ+WAN?NXU;K#PN34VD%30TE)U]:W^[ROUM"_R;3RTZ'7
CUK?[HZ@S,BV_U;#7H:TY-2VUU\_?HZFUQ+>VSJ?6KM;0H:,`

特点：与XXencode相似，第一位表示这一行密文是由多少个字符加密得到的。

在线加解密

1.6. 敲击码

基于5×5方格波利比奥斯方阵来实现

例子：

code
1
2
..... ../... ./... ./... ../
52 31 31 32

原文：wllm

特点：不超过五个点，两个一组，使用斜杠分隔每组

1.7. 莫尔斯电码

摩尔斯电码主要由以下5种它的代码组成：
1：点（.）
2：划（-）
3：每个字符间短的停顿（通常用空格表示停顿）
4：每个词之间中等的停顿（通常用 / 划分）
5：以及句子之间长的停顿

表

1
2
3
4
5
6
7
8
9
10
11
12
13
A  .-    N  -.    .  .-.-.-  +  .-.-.    1  .----
B  -...  O  ---   ,  --..--  _  ..--.-   2  ..---
C  -.-.  P  .--.  :  ---...  $  ...-..-  3  ...--
D  -..   Q  --.-  "  .-..-.  &  .-...    4  ....-
E  .     R  .-.   '  .----.  /  -..-.    5  .....
F  ..-.  S  ...   !  -.-.--              6  -....
G  --.   T  -     ?  ..--..              7  --...
H  ....  U  ..-   @  .--.-.              8  ---..
I  ..    V  ...-  -  -....-              9  ----.
J  .---  W  .--   ;  -.-.-.              0  -----
K  -.-   X  -..-  (  -.--.
L  .-..  Y  -.--  )  -.--.-
M  --    Z  --..  =  -...-

例子：.../---/...

原文：SOS

解码：CyberChef可解

1.8. 社会主义核心价值观编码

github上的加解密js代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
import "babel-polyfill";
{
    function assert(...express){
        const l = express.length;
        const msg = (typeof express[l-1] === 'string')? express[l-1]: 'Assert Error';
        for(let b of express){
            if(!b){
                throw new Error(msg);
            }
        }
    }

    function randBin(){
        return Math.random() >= 0.5;
    }

    const values = '富强民主文明和谐自由平等公正法治爱国敬业诚信友善';

    function str2utf8(str){
        // return in hex

        const notEncoded = /[A-Za-z0-9\-\_\.\!\~\*\'\(\)]/g;
        const str1 = str.replace(notEncoded, c=>c.codePointAt(0).toString(16));
        let str2 = encodeURIComponent(str1);
        const concated = str2.replace(/%/g, '').toUpperCase();
        return concated;
    }

    function utf82str(utfs){
        assert(typeof utfs === 'string', 'utfs Error');

        const l = utfs.length;

        assert((l & 1) === 0);

        const splited = [];

        for(let i = 0; i < l; i++){
            if((i & 1) === 0){
                splited.push('%');
            }
            splited.push(utfs[i]);
        }

        return decodeURIComponent(splited.join(''));
    }

    function hex2duo(hexs){
        // duodecimal in array of number

        // '0'.. '9' -> 0.. 9
        // 'A'.. 'F' -> 10, c - 10    a2fFlag = 10
        //          or 11, c - 6      a2fFlag = 11
        assert(typeof hexs === 'string')

        const duo = [];

        for(let c of hexs){
            const n = Number.parseInt(c, 16);
            if(n < 10){
                duo.push(n);
            }else{
                if(randBin()){
                    duo.push(10);
                    duo.push(n - 10);
                }else{
                    duo.push(11);
                    duo.push(n - 6);
                }
            }
        }
        return duo;
    }

    function duo2hex(duo){
        assert(duo instanceof Array);

        const hex = [];

        const l = duo.length;

        let i = 0;

        while(i < l){
            if(duo[i] < 10){
                hex.push(duo[i]);
            }else{
                if(duo[i] === 10){
                    i++;
                    hex.push(duo[i] + 10);
                }else{
                    i++;
                    hex.push(duo[i] + 6);
                }
            }
            i++;
        }
        return hex.map(v=>v.toString(16).toUpperCase()).join('');
    }


    function duo2values(duo){
        return duo.map(d=>values[2*d]+values[2*d+1]).join('');
    }

    function valuesDecode(encoded){
        const duo = [];

        for(let c of encoded){
            const i = values.indexOf(c);
            if(i === -1){
                continue;
            }else if(i & 1){
                continue;
            }else{
                // i is even
                duo.push(i >> 1);
            }
        }

        const hexs = duo2hex(duo);

        assert((hexs.length & 1) === 0);

        let str;
        try{
            str = utf82str(hexs);
        }catch(e){
            throw e;
        }
        return str;
    }


    function valuesEncode(str){
        return duo2values(hex2duo(str2utf8(str)));
    }

    // ------------------

    const decodedArea = document.getElementById('decoded-area');
    const encodedArea = document.getElementById('encoded-area');
    const decodeBtn = document.getElementById('decode-btn');
    const encodeBtn = document.getElementById('encode-btn');

    encodeBtn.addEventListener('click', e=>{
        encodedArea.value = '';
        const encoded = valuesEncode(decodedArea.value);
        encodedArea.value = encoded;
    });

    decodeBtn.addEventListener('click', e=>{
        decodedArea.value = '';
        const decoded = valuesDecode(encodedArea.value);
        decodedArea.value = decoded;
    });
};

分析后不难发现有以下几点结论：

1：表是富强 民主 文明 和谐 自由 平等 公正 法治 爱国 敬业 诚信 友善，索引值0-11

2：字符串hex值中的0-9 对应 表索引值的0-9。比如十六进制的0，在表中是富强

3：字符串hex值中的A-F 对应 表索引值的关系有两种

1
2
3
4
5
6
7
8
9
10
11
12
13
A -> 10 0
B -> 10 1
C -> 10 2
D -> 10 3
E -> 10 4
F -> 10 5

A -> 11 4
B -> 11 5
C -> 11 6
D -> 11 7
E -> 11 8
F -> 11 9

解释一下上面的结论，以我Kc !6为例子
加密后的几种结果为
诚信自由公正爱国爱国敬业民主自由诚信民主公正和谐文明富强文明民主和谐公正
诚信自由公正爱国爱国敬业民主自由友善平等公正和谐文明富强文明民主和谐公正
友善爱国公正爱国爱国敬业民主自由诚信民主公正和谐文明富强文明民主和谐公正
友善爱国公正爱国爱国敬业民主自由友善平等公正和谐文明富强文明民主和谐公正

先将我Kc !6以十六进制编码的形式表示E6 88 91 4B 63 20 21 36

E在表中是10 4或者11 8，然后拿10 4和11 8在索引表中找到诚信 自由或者友善 爱国，再接着是6，在表中是公正，后面的以此类推。

1.9. jjencode/aaencode

jjencode代码，就是将正常的js代码转换成复杂的只有符号的字符串编码，进行加密 如：[$._$_]+$._$+",\\"+$.$__+$.___+"\\"+$.__$+$.__$+$这样的组合

jjencode加密/解密

aaencode代码，则是将正常的js代码转为好玩的特殊网络表情符号。如:ﾟωﾟﾉ= /｀ｍ´）ﾉ ~┻━┻ //*´∇｀*/ ['_']; o=(ﾟｰﾟ)这样的表情文字

AAEncode加密/解密

1.10. 埃特巴什码(Atbash)

就是倒着来

常文：A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
密文：Z Y X W V U T S R Q P O N M L K J I H G F E D C B A

例子

1
2
WZHXGU{5v0u98z95u79829y7z484z54066xy08u}
DASCTF{5e0f98a95f79829b7a484a54066cb08f}

CyberChef可解

1.11. 金笛短信PDU编码

需要一行一行地解码

例子

1
2
3
4
5
6
7
8
9
0001000D91683106019196F4000872003800390035003000340045003400370030004400300041003100410030004100300030003000300030003000300044003400390034003800340034003500320030003000300030003000300034003700300030003000300030003000300038003000380030003200300030003000300030
0001000D91683106019196F4000872003000320034004400430037003500460031003000300030003000300030004200430034003900340034003400310035003400370038003500450044004400390032003400310031003200380035003300300030003800340033004200390031003900460037003300460031003500390046
0001000D91683106019196F400087000380034004600410038003700310032003100370036004500370034003500310032003600450033004400340041003600320044003700390035003500420033003800380032003100310037003900390042004200320045004100420039003500410036004200330042004200450037
0001000D91683106019196F400086E0042003600300039003900330045004500360033004600320036004600440044003100420043004400410042003300300033003300310046004500350045003600440039003300370035004200300036003500360036004100320031003000410033004100420037003100440038
0001000D91683106019196F400087000450033004400370032003100300031004400420034003900310036003900360038003000310033003200340046003800450046003200380034004500420033003500430030004600420036003400450046003100300030004100310042004100300043003200300044004400450042
0001000D91683106019196F400086E0038003400410032004200440038004200350038004200330039004500410043003600450030004100420031003000380044003600440036004600340034004300460044003800310044003000330042003600390034004200430039003400430032003300310033004400340046
0001000D91683106019196F400087000360038003900390031003600440036003200360041003700390035003800460035004300440039003500390042004500320038004300340034003300410045003700360043003100300035003800380030003200380035003900320039003600310042004600430044003400300044
0001000D91683106019196F4000872003100350037004600310033003400310033003800390043004600410042003600410045003500460032003300300038003700370035004500380031004500420032003000330030004300300035003000340037003500310044003900460041003400450045004600320032004600440030
0001000D91683106019196F400085200300037004400450044003500420036003800410033003100350046004400310031003000300030003000300030003000300034003900340035003400450034003400410045003400320036003000380032

金笛短信PDU编码解码工具

1.12. Twitter Secret Messages

例子：

1
i hａd a grｅａｔ dａｙ at the beach! #sunshine

特点：密文中有很多Unicode字符

在线网站解密

1.13. 中文电码

中文电码表采用了四位阿拉伯数字作代号，从0001到9999按四位数顺序排列，用四位数字表示最多一万个汉字、字母和符号。汉字先按部首，后按笔划排列。字母和符号放到电码表的最尾。

例子：

1
2
3
4
中：0022
文：2429
电：7193
码：4316

特点：四个数字一组

在线查询中文电码

1.14. 凯撒密码

凯撒密码是一种替换加密技术，明文中的所有字母都在字母表上向后（或向前）按照一个固定数目进行偏移后被替换成密文。例如，当偏移量是3的时候，所有的字母A将被替换成D，B变成E，以此类推。

凯撒(Caesar)加密/解密

1.15. VBS加密

enc.vbe内容如下

1
#@~^HAAAAA==W^lLyPb/P@#@&4*.2{W!!x[mFC&|0AcAAA==^#~@

VBScript encrypter and decrypter

1.16. 盲文

布莱尔创造的由6个点为基础结构的盲字，在纸面上有的凸起，有的不凸起，形成64种变化，即64种符形，在每个符号（单位称”方”）左右两列，每列各三个点，从左边自上而下叫做1、2、3点，从右边自上而下叫做4、5、6点。

英语字母盲文表如下

数字盲文表如下

在线翻译

1.17. ook

Ook! 与Brainfuck类似, 但用单词”Ook”，”Ook.” 和 “Ook?”代替。

在线网站1
在线网站2

1.18. 棋盘密码(Polybius,ADFGX,ADFGVX)

波利比奥斯方阵密码

例如“hello”用棋盘密码加密后变成“2315313134”。实际应用中，方阵中的字母顺序会被打乱，然后分发给信息发送方和接收方，增加第三方破解难度。

特点：
明文只能是字母；
密文全部为数字；
密文长度是明文的两倍，即偶数；
明文字母I和J的密文编码相同，解密后需人工确认。

第一次世界大战中德军发明了ADFGX棋盘密码，它是Polybius棋盘密码的改良版本，以适应当时的电报信息加密传送。ADFGX密码将Polybius棋盘中的12345替换成ADFGX，因此密文由数字变成了字母。然后使用一个密钥将密文再次移位加密，得到最终密文。

它是ADFGX棋盘的加强版本，增加了一个行列，用V表示。如此形成6行6列的棋盘，容纳26个字母、10个数字，总计36个字符。加密强度更高，且解密时不再刻意区分I和J

这个密码以使用于密文当中的六个字母A、D、F、G、V、X命名

解密脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
def adfgvx_plus_decode(cp: str, kw: str, km: str) -> str:
    """
        cp:cipher     密文
        kw:keyword    密码
        km:keymap     键盘布局
    """
    keyword = kw.lower()
    cipher = cp.lower()
    klen = len(keyword)
    clen = len(cipher) // klen
    ncol = len(cipher) % klen
    #print(len(cipher),klen,clen,ncol)

    cols = [''] * klen
    i = j = k = 0
    while i < klen:
        try:  # js: string.charAt(j)
            c = 'abcdefghijklmnopqrstuvwxyz'[j]
        except:
            c = ''
        t = keyword.find(c)  # js: string.indexOf(c)
        if t >= 0:
            col = clen + (1 if t < ncol else 0)
            cols[t] = cipher[k:k + col]
            k += col
            atmp = list(keyword)
            atmp[t] = '_'
            keyword = ''.join(atmp)
            i += 1
        else:
            j += 1
        #print(i,j,k,t,cols,keyword)

    s = ''
    for i in range(clen + 1):
        for j in range(klen):
            try:  # js: string.charAt(j)
                s += cols[j][i]
            except:
                pass
            #print(s)

    a = 'adfgvx'
    return ''.join([km[a.find(s[i]) * 6 + a.find(s[i + 1])] for i in range(0, len(s), 2)])


s = [['P', 'H', '0', 'Q', 'G', '6'],
     ['4', 'M', 'E', 'A', '1', 'Y'],
     ['L', '2', 'N', 'O', 'F', 'D'],
     ['X', 'K', 'R', '3', 'C', 'V'],
     ['S', '5', 'Z', 'W', '7', 'B'],
     ['J', '9', 'U', 'T', 'I', '8']]
keymap = ''.join([s[i][j] for i in range(6) for j in range(6)])
keyword = 'Yusayyds'
cipher = 'AGAXXDAGGVGGVDVADAVXDGADVGDVAADDDDFXAFAFDGDVXXDGGDGGDXDDFDDXVGXADGVDFXVVAADDXDXXADDVGGGXGXXXXGXXGGXGDVVVGGGAGAAAAGAAGGAGDDDAGAGGGAGGAGAGAAAVAAAXGXGGGXGGXGXGXXXV'
flag = adfgvx_plus_decode(cipher, keyword, keymap)
for i in range(0, len(flag), 2):
    print(chr(int(flag[i:i + 2], 16)), end='')

1.19. serpent

Serpent是一种对称式分组加密算法，是高级加密标准（AES）的候选者之一，其顺序仅次于Rijndael算法。设计者为罗斯·安德森、艾力·毕汉姆及拉尔斯·克努森。

与其他进入AES评选名单的算法一样，Serpent的区块长度为128比特，支持的密钥长度为128、192和256比特。

在线加解密

1.20. piet

与Whitespace，JSFuck等类似，是一种编程语言，不过这个语言的程序是点阵图

可以使用在线解释器

还可以下载源代码npiet-1.3a-win32到本地，然后使用以下命令运行

1
npiet.exe -tpic solved.png

特点：白底+很多彩色的小像素点组成的图片

1.21. 当铺密码

当前汉字有多少笔画出头，对应的明文就是数字几

例子:

1
2
密文：王夫 井工 夫口 由中人 井中 夫夫 由中大
对应：67 84 70 123 82 77 125

1.22. brainfuck

Brainfuck是一种极小化的计算机语言，只使用8种特定的符号

注意内存中也可能会藏有信息，例如2023年羊城杯的GIFuck

在线转换1，在线转换2(可看内存)

例子：

1
2
3
+++++ +++++ [->++ +++++ +++<] >.<++ +[->+ ++<]> +++++ .<+++ +++++ [->--
----- -<]>- -.<++ +++++ [->++ +++++ <]>++ +++++ +++++ +.<++ +++++ [->--
----- <]>-- ----- ----- .<

1.23. BubbleBabble编码

特征：五位小写字母一组，以-分割

例子：xipak-herek-serid-bapok-horek-syrox

在线工具

1.24. 阴阳怪气编码

特征：['就 这 ¿ ', '不 会 吧 ？ ']

GitHub项目地址

在线编码解密

1.25. emoji-aes

特征：都由表情符号组成

emoji-aes实际上就是aes加密文本，用一个key当作偏移，在表情字典中对应

emoji-aes在线

1.26 codemoji

特征是key和密文为表情符号

codemoji-encrypt
codemoji-cracker

1.27 solfa-cipher

音乐密码

solfa-cipher

1.28 Code Decabit

特征：由+和-组成，十位一组

例如：

1
+-+-++--+- ++---+-++- -+--++-++- +--++-++-- --+++++--- ++-++---+- +++-+-+--- +-+-+---++ ---+++-++- -+--++-++- -+--+++-+- -+--++-++- -+--++-++- ++-+-+-+-- -+--+++-+- ++-++---+- -++++---+- -+--++-++- ++-+-+-+-- +-+++---+- +++-++---- ---+++-++- +-+-+---++ ++-+-+-+-- +-+-+--++- ++--+--++- -++++---+- +---+++-+- ++-+-+-+-- -++++---+- -+--+++-+- +--+-+-++- +++-+-+--- +-+++---+- -+--+-+++- -+--++-++- ---+++-++- ++++----+- -++++---+- -+--+++-+- -+--++-++- ----+++++-

Code Decabit

1.29 DNA编码

特征：由ACGT组成

加解密脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
mapping = {

'AAA':'a',
'AAC':'b',
'AAG':'c',
'AAT':'d',
'ACA':'e',
'ACC':'f',
'ACG':'g',
'ACT':'h',
'AGA':'i',
'AGC':'j',
'AGG':'k',
'AGT':'l',
'ATA':'m',
'ATC':'n',
'ATG':'o',
'ATT':'p',
'CAA':'q',
'CAC':'r',
'CAG':'s',
'CAT':'t',
'CCA':'u',
'CCC':'v',
'CCG':'w',
'CCT':'x',
'CGA':'y',
'CGC':'z',
'CGG':'A',
'CGT':'B',
'CTA':'C',
'CTC':'D',
'CTG':'E',
'CTT':'F',
'GAA':'G',
'GAC':'H',
'GAG':'I',
'GAT':'J',
'GCA':'K',
'GCC':'L',
'GCG':'M',
'GCT':'N',
'GGA':'O',
'GGC':'P',
'GGG':'Q',
'GGT':'R',
'GTA':'S',
'GTC':'T',
'GTG':'U',
'GTT':'V',
'TAA':'W',
'TAC':'X',
'TAG':'Y',
'TAT':'Z',
'TCA':'1',
'TCC':'2',
'TCG':'3',
'TCT':'4',
'TGA':'5',
'TGC':'6',
'TGG':'7',
'TGT':'8',
'TTA':'9',
'TTC':'0',
'TTG':' ',
'TTT':'.'


}


encode_string = 'OME'

decode_string = 'GGAGCGCTG'

inverted_mapping = dict(zip(mapping.values(), mapping.keys()))

def decode_dna( decode_string ):

    pieces = []
    for i in range( 0, len(decode_string), 3 ):
        piece =  decode_string[i:i+3]
        ## pieces.append()
        pieces.append( mapping[piece] )

    return "".join(pieces)

def encode_dna(encode_string):
    pieces = []
    for i in encode_string:
        piece =  inverted_mapping[i]
        pieces.append(piece)
    return "".join(pieces)

print 'Decoded String is:- '+ decode_dna(decode_string)
print 'Encoded DNA String is:- '+ encode_dna(encode_string)

1.30. Gronsfeld

格罗斯费尔德密码(Gronsfeld cipher)实际上和维吉尼亚密码相同，除了使用了数字来代替字母以外没有什么区别

在线解密

解密脚本

1
2
3
4
5
6
7
from pycipher import Gronsfeld

cipher = 'TGLBOMSJNSRAJAZDEZXGHSJNZWHG'
key = [1,50,61,8,9,20,63,41]
secret = Gronsfeld(key).decipher(cipher)

print(secret)

1.31. 仿射密码(Affine)

例子

1
2
3
gezx{j13p5oznp_1t_z_900y_k3z771h_k001}
密钥：a=17 b=77
flag{w13e5hake_1s_a_900d_t3a771c_t001}

特点：有两个密钥ab(a是1,3,5,7,9,11,15,17,19,21,23,25中的一个)

在线解密/CyberChef也可解

1.32. 希尔密码(hill)

希尔密码，是使用基本矩阵论原理的替换密码，现多用于古典密码教学学习。
希尔密码，把每个字母当作26进制数字：A=0, B=1, C=2…，Z=25， 并把原文字母转换成数字，形成N维向量，跟一个n×n的密钥矩阵相乘，再将计算出的结果模26，即可得到加密密文。
用作加密的密钥（即矩阵）必须是可逆的，否则就不可能解密，只有矩阵的行列式和26互质，才是可逆的。

例子

1
2
密文：ymyvzjtxswwktetpyvpfmvcdgywktetpyvpfuedfnzdjsiujvpwktetpyvnzdjpfkjssvacdgywktetpyvnzdjqtincduedfpfkjssne
密钥：3 4 19 11

特点：密钥是四个数字

在线网站

1.33. 云影密码

原理：以0作为分隔符分组，然后把每组数字相加得到一个数字，这个数字对应的就是26字母中的下标

特点：密文只由01248组成

解密脚本

1
2
3
4
5
6
7
8
9
10
ciphey = "8842101220480224404014224202480122"
enc_list = ciphey.split('0')
res = []
print(enc_list)
for item in enc_list:
    sum = 0
    for num in item:
        sum += int(num)
    res.append(chr(sum + 64))
print(''.join(res))

1.34. 维吉尼亚(vigenere)密码

1、有密文和密钥：

直接用cyberchef或者在线网站解密

2、有密文，没有密钥：

尝试用在线网站爆破

3、有密文，没有密钥，但是知道明文的前几位：

根据对照表，手搓密钥的前几位，找规律

4、给了密钥字典，用脚本爆破

1
2
3
4
5
6
7
8
9
10
11
12
13
from pycipher import Vigenere

cipher = "rla xymijgpf ppsoto wq u nncwel ff tfqlgnxwzz sgnlwduzmy vcyg ib bhfbe u tnaxua ff satzmpibf vszqen eyvlatq cnzhk dk hfy mnciuzj ou s yygusfp bl dq e okcvpa hmsz vi wdimyfqqjqubzc hmpmbgxifbgi qs lciyaktb jf clntkspy drywuz wucfm"

with open("keys.txt","r") as f:
    lines = f.readlines()

for line in lines:
    key = line.strip()
    res = Vigenere(key).decipher(cipher)
    if "PASSWORD" in res:
        print(f"[+] key: {key}")
        print(f"[+] res: {res.lower()}")

1.35 博多码(Baudot Code)

博多码是一种5位编码系统，通常用于电报通信。它有两种模式：字母移位（Letters Shift）和数字移位（Figures Shift），通过特殊的控制字符来切换模式。例如，当遇到特定的移位码时，后续的编码会切换到另一种模式，直到再次切换回来

主要特点是字符用5比特编码，采用两个字符集

解码脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
letters = {
    '00000': '', '00001': 'E', '00010': '', '00011': 'A', '00100': ' ',
    '00101': 'S', '00110': 'I', '00111': 'U', '01000': '', '01001': 'D',
    '01010': 'R', '01011': 'J', '01100': 'N', '01101': 'F', '01110': 'C',
    '01111': 'K', '10000': 'T', '10001': 'Z', '10010': 'L', '10011': 'W',
    '10100': 'H', '10101': 'Y', '10110': 'P', '10111': 'Q', '11000': 'O',
    '11001': 'B', '11010': 'G', '11011': '', '11100': 'M', '11101': 'X',
    '11110': 'V', '11111': ''
}

figures = {
    '00000': '', '00001': '3', '00010': '', '00011': '-', '00100': ' ',
    '00101': '', '00110': '8', '00111': '7', '01000': '', '01001': '$',
    '01010': '4', '01011': "'", '01100': ',', '01101': '!', '01110': ':',
    '01111': '(', '10000': '5', '10001': '"', '10010': ')', '10011': '2',
    '10100': '#', '10101': '6', '10110': '0', '10111': '1', '11000': '9',
    '11001': '?', '11010': '&', '11011': '', '11100': '.', '11101': '/',
    '11110': ';', '11111': ''
}

# 分割二进制序列为5位一组
binary_groups = "001000011010000001001001100011001010010000011001001101110000000111111111001001101000000100011101100001001000010010010000101000001110000001001100100001011100001111100000010010001111011001100010011011000010000011001010010010000101000000100100001100110010000000010101001100000111000000110110000110000011100100010010000000011001000001110100101000011101101010000100000111001010110101000001111001000011000000100011001100000100110111011111111001001101101111111110011010000000111101110111100101110011111001000010111100000110101010000001001010111000001110010010100000111111000001001000110111000001110110001001001001000010100001100010100100101101001000011011100000100100000110110001001001001000010100000010010001101100100001111010001000011000101001000101100111110111000011111100001101100011111110001111011000111111101101110111011111111111100000111011101011111100110100001101100011110001111100011111000000100010"
groups = [binary_groups[i:i+5] for i in range(0, len(binary_groups), 5)]

current_mode = 'letters'
result = []

for code in groups:
    if current_mode == 'letters':
        if code == '11011':  # 遇到FS切换到数字模式
            current_mode = 'figures'
            continue
        elif code == '11111':  # LS无需处理
            continue
        result.append(letters[code])
    elif current_mode == 'figures':
        if code == '11111':  # 遇到LS切换回字母模式
            current_mode = 'letters'
            continue
        result.append(figures[code])

decoded = ''.join(result).lower()
print(decoded)

图形密码

这一部分较简单，对着表翻译就好，但也比较抽象，因为时常会出现奇奇怪怪的东西

2.1. 跳舞的小人

找到了三种不同的表，将密文与表一一对应即可（好像出自福尔摩斯）

2.2. 猪圈密码

猪圈密码在线转换

以下几张是变种猪圈

2.3. 圣堂武士密码

圣堂武士密码其实也是变种猪圈，不过比较有名

2.4. 银河字母

2.5. 凹凸字体

2.6. 夏多密码（曲折密码）

来源：作者麦克斯韦·格兰特在中篇小说《死亡之链》塑造夏多这一英雄人物中所自创的密码
整个夏多密码由两部分组成，码表和旋转方向

最后四个符号（1，2，3，4）可以出现在密文中的任意位置，它代表着在此之后的密文需要向什么方向旋转

2.7. 古埃及象形文字

2.8. 费兹象形文字

2.9. Flag Semaphore旗语

2.10. 船用信号旗

2.11. Dvorak键盘加密

利用两种键盘字母的排列顺序不同，进行的一种替换加密方式。

Dvorak键盘，中文名字是德沃夏克键盘，由奥古斯特·德沃夏克和威廉·迪利在1930年代期间设计

other

各种奇奇怪怪又抽象的实在太多了，可以参考下面两篇文章中的字符表
https://www.cnblogs.com/Nuy0ah/p/16138118.html
https://www.bilibili.com/read/cv19369626/

部分脚本参考：CTF-Misc Guide

总结
#misc #总结 #编码 #密码
misc总结(编码密码篇)
https://www.dr0n.top/posts/86a2c34b/
作者
dr0n
发布于
2022年7月1日
更新于
2025年8月17日
许可协议