def encrypt(txt,schl=schl):
"""verschluesselt den text.
es ist empfehlenswert den text mit
zeichen zu ergaenzen, bis seine laenge
ein vielfaches von 8 ergibt.
das programm macht das automatisch mit "\x88"
"""#;test=[]
i=0
txt+="\x88"*(-len(txt)%8)
lentxt=len(txt)
lenschl=len(schl)
lall=[]
index=[0]
schluessel=iterator(schl,index)
ns=schluessel.next
range8=range(8)
range_0_lentxt_8=range(0,lentxt,8)
##########################################################
#boxliste erzeugen [[[] x 8], ...]
lall=[[int_tuple(ord(i)^ord(ns())) for i in txt[n:n+8]] for n in range_0_lentxt_8]
#auf laenge | 8 bringen
lenlall=len(lall)
# test.append(lall[:])
##########################################################
# boxen shiften
itlistboshift=[]
i=1
while i<lentxt:
itlistboshift.append(i)
i=i<<8
##########################################################
for runde in range(10):
##########################################################
#boxen shiften
lall=[zip(*shiftbox(i,int_octtuple(ns()+ns()+ns()))) for i in lall[:]]
# test.append(lall[:])
##########################################################
#boxliste shiften
t=()
for i in range8:
#shifttuple erstellen
k=0
for j in itlistboshift:k+=ord(schluessel.next())*j
t+=(k,)
l=[]#liste fuer bitreihen aus lall
for i in lall:l+=i
bitlist=zip(*shiftbox(zip(*l),t))#lall-bitreihen shiften, in byte-tuple fassen
# test.append(bitlist[:])
#ausgangsposition herstellen
lall=[[bitlist[i] for i in range8] for n in range_0_lentxt_8]
# test.append(lall[:])
##########################################################
r=""
for b in lall:
rt=""
for t in b:
rt+=chr(tuple_int(t))
r+=rt
return files.int_string(index[0],("\x00",))+"\x00"+r#,schl,test
def __init__(self,name="random"):
if name=="random":
from main import files
self.name="com"+files.int_string(int((255**2)*random.random()),(split[0],))
else:
self.name=name
self.socket=socket.socket(2,1)
self.socket.bind(("",0))
self.socket.listen(1)
self.clients={}#name:[str1, ...]
self.server_connection={}#name:obj
self.accept=True
self.accepting=False#ob _accept_thread noch in process
self.empfunk=[]#[ (funk ,(args,)), ... ]
self.wait_accept={}#str(addr):name/None
self.block_connect={}#ip:port
self.intfunk=[]#[ (funk ,(args,)), ... ]
self.accept_thread()
def __init__(self, name="random"):
if name == "random":
from main import files
self.name = "com" + files.int_string(
int((255**2) * random.random()), (split[0], ))
else:
self.name = name
self.socket = socket.socket(2, 1)
self.socket.bind(("", 0))
self.socket.listen(1)
self.clients = {} #name:[str1, ...]
self.server_connection = {} #name:obj
self.accept = True
self.accepting = False #ob _accept_thread noch in process
self.empfunk = [] #[ (funk ,(args,)), ... ]
self.wait_accept = {} #str(addr):name/None
self.block_connect = {} #ip:port
self.intfunk = [] #[ (funk ,(args,)), ... ]
self.accept_thread()
def encrypt(txt, schl=schl):
"""verschluesselt den text.
es ist empfehlenswert den text mit
zeichen zu ergaenzen, bis seine laenge
ein vielfaches von 8 ergibt.
das programm macht das automatisch mit "\x88"
"""
test = []
i = 0
txt += "\x88" * (-len(txt) % 8)
lentxt = len(txt)
lenschl = len(schl)
lall = []
index = [0]
schluessel = iterator(schl, index)
##########################################################
# boxliste erzeugen [[[] x 8], ...]
for n in txt:
if i % 8 == 0:
lbox = []
lall.append(lbox)
t = int_tuple(ord(n) ^ ord(schluessel.next()))
lbox.append(t)
i += 1
# auf laenge | 8 bringen
lenlall = len(lall)
test.append(lall)
##########################################################
# boxen shiften
itlistboshift = []
i = 1
while i < lentxt:
itlistboshift.append(i)
i = i << 8
##########################################################
for runde in range(10):
##########################################################
# boxen shiften
i = lenlall
lallklon = lall[:]
while i:
i -= 1
lall[i] = zip(
*shiftbox(lallklon[i], int_octtuple(schluessel.next() + schluessel.next() + schluessel.next()))
)
test.append(lall)
##########################################################
# boxliste shiften
t = ()
for i in range(8):
# shifttuple erstellen
k = 0
for j in itlistboshift:
k += ord(schluessel.next()) * j
t += (k,)
l = [] # liste fuer bitreihen aus lall
for i in lall:
l += i
bitlist = zip(*shiftbox(zip(*l), t)) # lall-bitreihen shiften, in byte-tuple fassen
test.append(bitlist)
# ausgangsposition herstellen
lall = []
i = 0
while i < lentxt:
if i % 8 == 0:
lbox = []
lall.append(lbox)
lbox.append(bitlist[i])
i += 1
test.append(lall)
##########################################################
r = ""
for b in lall:
rt = ""
for t in b:
rt += chr(tuple_int(t))
r += rt
return files.int_string(index[0], ("\x00",)) + "\x00" + r # ,schl,test
def encrypt(txt, schl=schl):
"""verschluesselt den text.
es ist empfehlenswert den text mit
zeichen zu ergaenzen, bis seine laenge
ein vielfaches von 8 ergibt.
das programm macht das automatisch mit "\x88"
"""
test = []
i = 0
txt += "\x88" * (-len(txt) % 8)
lentxt = len(txt)
lenschl = len(schl)
lall = []
index = [0]
schluessel = iterator(schl, index)
##########################################################
#boxliste erzeugen [[[] x 8], ...]
for n in txt:
if i % 8 == 0:
lbox = []
lall.append(lbox)
t = int_tuple(ord(n) ^ ord(schluessel.next()))
lbox.append(t)
i += 1
#auf laenge | 8 bringen
lenlall = len(lall)
test.append(lall)
##########################################################
# boxen shiften
itlistboshift = []
i = 1
while i < lentxt:
itlistboshift.append(i)
i = i << 8
##########################################################
for runde in range(10):
##########################################################
#boxen shiften
i = lenlall
lallklon = lall[:]
while i:
i -= 1
lall[i]=zip(*shiftbox(lallklon[i]\
,int_octtuple(schluessel.next()\
+schluessel.next()+schluessel.next())))
test.append(lall)
##########################################################
#boxliste shiften
t = ()
for i in range(8):
#shifttuple erstellen
k = 0
for j in itlistboshift:
k += ord(schluessel.next()) * j
t += (k, )
l = [] #liste fuer bitreihen aus lall
for i in lall:
l += i
bitlist = zip(*shiftbox(
zip(*l), t)) #lall-bitreihen shiften, in byte-tuple fassen
test.append(bitlist)
#ausgangsposition herstellen
lall = []
i = 0
while i < lentxt:
if i % 8 == 0:
lbox = []
lall.append(lbox)
lbox.append(bitlist[i])
i += 1
test.append(lall)
##########################################################
r = ""
for b in lall:
rt = ""
for t in b:
rt += chr(tuple_int(t))
r += rt
return files.int_string(index[0], ("\x00", )) + "\x00" + r #,schl,test
