예제 #1
0
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
예제 #2
0
 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()
예제 #3
0
    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()
예제 #4
0
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
예제 #5
0
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