曼彻斯特编码

crypto 评论

man有2个不同的规范，在二进制位的发送方式上还有正序和逆序之分，所以对给定的编码后的数据进行解码处理的时候，得考虑使用的规范和字节序。

曼彻斯特编码有2个不同的规范，在二进制位的发送方式上还有正序和逆序之分，所以对给定的编码后的数据进行解码处理的时候，得考虑使用的规范和字节序。

1. 曼彻斯特编码

  • 标准曼彻斯特编码

由G. E. Thomas, Andrew S. Tanenbaum等人在1949年提出的，它规定0是由低-高的电平跳变表示，1是高-低的电平跳变，即01为0，10为1。

  • IEEE曼彻斯特编码：

在IEEE 802.4（令牌总线）和低速版的IEEE 802.3（以太网）中规定，按照这样的说法，低-高电平跳变表示1，高-低的电平跳变表示0，即01为1，10为0。

2. 差分曼彻斯特编码

后一个信号如果与前一个信号跳变相同，则为0，不同，则为1，例如，0101，1010为0，0110，1001为1。第一个信号位如何确定，查到有资料说：

如果中间位电平从低到高，则表示0；
如果中间位电平从高到低，则表示1；

但有的题好像又是直接忽略第一位，待解。

  • 其他解法

只有5，6，9，a这4种字符：

5 - 0101；6 - 0110；9 - 1001；a - 1010。

然后转换为16进制，再转换成字符串即可获得flag。

3. 关于字节逆序的问题

在某个传输规范中，每个字节的8个比特位会逆序发送，如发送：01001001 10101010，发送顺序会变成10010010 01010101。因此这里也是做题中的一个坑。

4. 通用代码

代码在差分曼彻斯特编码的解码中，使用了忽略第一位的方法。

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
# -*- coding: utf-8 -*-
import struct
import math
def long_to_bytes(n):
    s = b''
    pack = struct.pack
    while n > 0:
        s = pack('>I', n & 0xffffffff) + s
        n = n >> 32
    for i in range(len(s)):
        if s[i] != b'\000'[0]:
            break
    else:
        s = b'\000'
        i = 0
    s = s[i:]
    return s

#字节逆序
def byteinvert(str_bin):
    ret=''
    for i in range(len(str_bin)//8):
        ret+=str_bin[i*8:i*8+8][::-1]
    return ret

#标准曼彻斯特
def MCST_stand(str_bin):
    ret=''
    for i in range(len(str_bin)//2):
        x=str_bin[i*2:i*2+2]
        if x=='01':
            ret+='0'
        elif x=='10':
            ret+='1'
        else:
            return 'stand manchester decode wrong!'
    return ret

#IEEE规范的曼彻斯特
def MCST_IEEE(str_bin):
    ret=''
    for i in range(math.ceil(len(str_bin)/8)):
        x=str_bin[i*2:i*2+2]
        if x=='01':
            ret+='1'
        elif x=='10':
            ret+='0'
        else:
            return 'stand manchester decode wrong!'
    return ret

#差分曼彻斯特
def MCST_diff(str_bin):
    ret=''
    for i in range(0,len(str_bin)//2-1):
        x1=str_bin[i*2:i*2+2]
        x2=str_bin[i*2+2:i*2+4]
        if x1==x2:
            ret+='0'
        else:
            ret+='1'
    return ret

if __name__ == "__main__":
    str_hex='9a9a9a6a9aa9656699a699a566995956996a996aa6a965aa9a6aa596a699665a9aa699655a696569655a9a9a9a595a6965569a59665566955a6965a9596a99aa9a9566a699aa9a969969669aa6969a9559596669'
    #str_bin='0101010101010101'
    str_bin=str(bin(int(str_hex,16)))[2:]
    
    m1=MCST_IEEE(str_bin)
    m2=MCST_stand(str_bin)
    m3=MCST_diff(str_bin)
    print('\nIEEE曼彻斯特:')
    print(m1)
    print(hex(int(m1,2)))
    print(long_to_bytes(int(m1,2)))
    print('\n 标准曼彻斯特:')
    print(m2)
    print(hex(int(m2,2)))
    print(long_to_bytes(int(m2,2)))
    print('\n 差分曼彻斯特:')
    print(m3)
    print(hex(int(m3,2)))
    print(long_to_bytes(int(m3,2)))
    print('\n=============字节逆序=============')
    m1=byteinvert(m1)
    m2=byteinvert(m2)
    m3=byteinvert(m3)
    print('\nIEEE曼彻斯特:')
    print(m1)
    print(hex(int(m1,2)))
    print(long_to_bytes(int(m1,2)))
    print('\n 标准曼彻斯特:')
    print(m2)
    print(hex(int(m2,2)))
    print(long_to_bytes(int(m2,2)))
    print('\n 差分曼彻斯特:')
    print(m3)
    print(hex(int(m3,2)))
    print(long_to_bytes(int(m3,2)))