最后按列的顺序从上到下从左至右解密。

栅栏加解密是对较短字符串的一种处理方式，给定行数Row，根据字符串长度计算出列数Column，构成一个方阵。

加密过程：就是按列依次从上到下对明文进行排列，然后按照密钥对各行进行打乱，最后以行顺序从左至右进行合并形成密文。

解密过程：将上述过程进行逆推，对每一行根据密钥的顺序回复到原始的方阵的顺序，并从密文回复原始的方阵，最后按列的顺序从上到下从左至右解密。

具体实现如下：所有实现封装到一个类RailFence中，初始化时可以指定列数和密钥，默认列数为2，无密钥。初始化函数如下：

[python] view plaincopyprint?

1. def __init__(self, row = 2, mask = None):  
2.     if row < 2:  
3.         raise ValueError(u'Not acceptable row number or mask value')  
4.     self.Row    = row  
5.     if mask != None and not isinstance(mask, (types.StringType, types.UnicodeType)):  
6.         raise ValueError(u'Not acceptable mask value')  
7.     self.Mask   = mask  
8.     self.Length = 0  
9.     self.Column = 0  

加密过程，可以选择是否去除空白字符。首先是类型检查，列数计算等工作，核心是通过计算的参数得到gird这个二维列表表示的方阵，也是栅栏加密的核心。具体实现如下：

[python] view plaincopyprint?

1. def encrypt(self, src, nowhitespace = False):  
2.     if not isinstance(src, (types.StringType, types.UnicodeType)):  
3.         raise TypeError(u'Encryption src text is not string')  
4.     if nowhitespace:  
5.         self.NoWhiteSpace = ''  
6.         for i in src:  
7.             if i in string.whitespace: continue  
8.             self.NoWhiteSpace += i  
9.     else:  
10.         self.NoWhiteSpace = src  
11.       
12.     self.Length = len(self.NoWhiteSpace)  
13.     self.Column = int(math.ceil(self.Length / self.Row))  
14.     try:  
15.         self.__check()  
16.     except Exception, msg:  
17.         print msg  
18.     #get mask order  
19.     self.__getOrder()  
20.       
21.     grid = [[] for i in range(self.Row)]  
22.     for c in range(self.Column):  
23.         endIndex = (c + 1) * self.Row  
24.         if endIndex > self.Length:  
25.             endIndex = self.Length  
26.         r = self.NoWhiteSpace[c * self.Row : endIndex]  
27.         for i,j in enumerate(r):  
28.             if self.Mask != None and len(self.Order) > 0:  
29.                 grid[self.Order[i]].append(j)  
30.             else:  
31.                 grid[i].append(j)  
32.     return ''.join([''.join(l) for l in grid])  

其中主要的方法是按照列数遍历，每次从明文中取列数个数的字符串保存在遍历 r 中，其中需要处理最后一列的结束下标是否超过字符串长度。然后将这一列字符串依次按照顺序加入到方阵grid的各列对应位置。

解密过程复杂一些，因为有密钥对顺序的打乱，需要先恢复打乱的各行的顺序，得到之前的方阵之后，再按照列的顺序依次连接字符串得到解密后的字符串。具体实现如下：

[python] view plaincopyprint?

1. def decrypt(self, dst):  
2.     if not isinstance(dst, (types.StringType, types.UnicodeType)):  
3.         raise TypeError(u'Decryption dst text is not string')  
4.     self.Length = len(dst)  
5.     self.Column = int(math.ceil(self.Length / self.Row))  
6.     try:  
7.         self.__check()  
8.     except Exception, msg:  
9.         print msg  
10.     #get mask order  
11.     self.__getOrder()  
12.       
13.     grid  = [[] for i in range(self.Row)]  
14.     space = self.Row * self.Column - self.Length  
15.     ns    = self.Row - space  
16.     prevE = 0  
17.     for i in range(self.Row):  
18.         if self.Mask != None:  
19.             s = prevE  
20.             O = 0  
21.             for x,y in enumerate(self.Order):  
22.                 if i == y:  
23.                     O = x  
24.                     break  
25.             if O < ns: e = s + self.Column  
26.             else: e = s + (self.Column - 1)  
27.             r = dst[s : e]  
28.             prevE = e  
29.             grid[O] = list(r)  
30.         else:  
31.             startIndex = 0  
32.             endIndex   = 0  
33.             if i < self.Row - space:  
34.                 startIndex = i * self.Column  
35.                 endIndex   = startIndex + self.Column  
36.             else:                  
37.                 startIndex = ns * self.Column + (i - ns) * (self.Column - 1)  
38.                 endIndex   = startIndex + (self.Column - 1)  
39.             r = dst[startIndex:endIndex]  
40.             grid[i] = list(r)  
41.     res = ''  
42.     for c in range(self.Column):  
43.         for i in range(self.Row):  
44.             line = grid[i]  
45.             if len(line) == c:  
46.                 res += ' '  
47.             else:  
48.                 res += line[c]  
49.     return res  

实际运行

测试代码如下，以4行加密，密钥为bcaf：

[python] view plaincopyprint?

1. rf = RailFence(4, 'bcaf')  
2. e = rf.encrypt('the anwser is wctf{C01umnar},if u is a big new,u can help us think more question,tks.')  
3. print "Encrypt: ",e  
4. print "Decrypt: ", rf.decrypt(e)  

结果如下图：