I came upon the idea of changing viewing angle while pondering something completely unrelated–DNA frameshifts, if I recall. This isn’t really encryption, but rather it’s interpreting data from a different angle. It’s more of an obfuscation. As for real world implication… you’d have to dig into it a little deeper than I have.
The idea is that you enter data and it is broken into 8 character packets, converted to its ascii binary value, and laid into an 8x8 table of 0s and 1s. That table is then interpreted from a different viewing angle, converted back into characters, and regrouped from its 8 character packets. For instance, the string “ThisData” is entered, and a string of a bit of gobbledygook is returned:

I present to you the first draft code I wrote to create this behavior:
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
TheData=raw_input("Enter your data > ")
TheData=str(TheData[:])
lendiff=len(TheData)%8
if lendiff>0:
TheData=TheData+((8-lendiff)*'0')
DataList = list(TheData)
DataListBinary = []
atemp=[]
DataListBinaryOutput = [[],[],[],[],[],[],[],[]]
indexer = [0,0]
for sublst in DataListBinaryOutput:
sublst=[[],[],[],[],[],[],[],[]]
for a in DataList:
for b in bin(ord(a)):
atemp.append(b)
DataListBinary.append(atemp)
atemp=[]
for c in DataListBinary:
offset=c.index('b')
c[:offset+1]=offset*['0']
if len(c)<8:
c=((8-len(c))*['0'])+c
for d in c:
DataListBinaryOutput[indexer[1]].insert(indexer[0],d)
indexer[1]=indexer[1]+1
indexer[0]=indexer[0]+1
indexer[1]=0
indexer = [0,0]
joiner=['','','','','','','','']
for e in DataListBinaryOutput:
for f in e:
joiner[indexer[0]]=joiner[indexer[0]][:]+f
indexer[1]=indexer[1]+1
indexer[1]=0
indexer[0]=indexer[0]+1
finalResult=''
for g in joiner:
finalResult=finalResult[:]+chr(int(g, 2))
print finalResult
It gets the job done, but there are a couple issues that I immediately saw:
- The code repeats several steps and could be condensed into functions to reduce code size. For instance, to get the original string to an 8 element list of 8 element lists, the data goes through similar processes: being forced into a list of 8 elements. Similarly, when converting back to readable data, the list is converted into strings two separate times. It’s likely these processes could each be turned into functions or methods.
- Only 8 characters can be run through this code at a time. If the original data was broken into instances of a class, each instance of 8 characters could be run through the interpretation simultaneously.
- It’s clunky.
I like how the flow of this works, because it seems to tell the story of many programs:
Something happens, then the program does something important, and then that something un-happens. For instance a file is opened, a change is written, and then file is closed. In this case a process rolls forward so that the main function can happen(breaking the easily readable data into an 8x8 grid), the change happens(data is interpreted from a different view), and then a process rolls backward(the 8x8 grid is returned to easily readable data).
Revisions soon!