Exemple #1
0
def decrypt(txt, schl=schl):
    i = txt.index("\x00")
    index = [files.string_int(txt[:i], ("\x00",))]
    schluessel = iterator(schl, index, -1)
    lentxt = len(txt)
    lall = []
    n = 0
    for i in txt[i + 1 :]:
        if n % 8 == 0:
            lbox = []
            lall.append(lbox)
        lbox.append(int_tuple(ord(i)))
        n += 1
    for runde in range(10):
        pass
Exemple #2
0
def decrypt(txt,schl=schl):
    i=txt.index("\x00")
    index=[files.string_int(txt[:i],("\x00",))]
    schluessel=iterator(schl,index,-1)
    lentxt=len(txt)
    lall=[]
    n=0
    for i in txt[i+1:]:
        if n%8==0:
            lbox=[]
            lall.append(lbox)
        lbox.append(int_tuple(ord(i)))
        n+=1
    for runde in range(10):
        pass
def decrypt(txt, schl=schl):  # test=[]):
    """
    entschluesslt den text in txt mit dem schluessel in schl
    es kann vorkommen, das letzte zeichen fehlen, wenn diese lauteten:"\x88"
    """
    i = txt.index("\x00")
    index = [files.string_int(txt[:i], ("\x00",))]
    schluessel = iterator(schl, index, -1)
    lentxt = len(txt) - i - 1
    lall = []
    n = 0
    ##########################################################getestet
    # lall erzeugen
    for i in txt[i + 1 :]:
        if n % 8 == 0:
            lbox = []
            lall.append(lbox)
        lbox.append(int_tuple(ord(i)))
        n += 1
    #    print test[-1]==lall
    ##########################################################getestet
    # boxen shiften
    itlistboshift = []
    i = 1
    while i < lentxt:
        itlistboshift.append(i)
        i = i << 8
    itlistboshift.reverse()
    ##########################################################
    lenlall = len(lall)
    for runde in range(10):
        ##########################################################
        # boxliste shiften -
        t = []
        for i in range(8):
            # shifttuple erstellen
            k = 0
            for j in itlistboshift:
                k -= ord(schluessel.next()) * j
            t.append(k)
        l = []  # liste fuer bitreihen aus lall
        for i in lall:
            l += i
        t.reverse()
        bitlist = zip(*shiftbox(zip(*l), t))  # lall-bitreihen shiften, in byte-tuple fassen
        #        print test[-2]==bitlist
        # ausgangsposition herstellen
        lall = []
        i = 0
        while i < lentxt:
            if i % 8 == 0:
                lbox = []
                lall.append(lbox)
            lbox.append(bitlist[i])
            i += 1
        #        print test[-3]==lall
        ##########################################################
        # boxen shiften
        i = 0
        lallklon = lall[:]
        while i < lenlall:
            lall[i] = shiftbox(
                zip(*lallklon[i]), int_negocttuple(schluessel.next() + schluessel.next() + schluessel.next())
            )
            i += 1
    #        print test[-4]==lall
    ##########################################################
    r = ""
    lall.reverse()
    for b in lall:
        rt = ""
        b.reverse()
        for t in b:
            rt = chr(tuple_int(t) ^ ord(schluessel.next())) + rt
        r = rt + r
    i = 0
    while r[i - 1] == "\x88":
        i -= 1
    #    print index # kontrolle: wenn [0]:alles ok
    if i == 0:
        return r
    else:
        return r[:i]
def decrypt(
    txt,
    schl=schl,
):  # test=[]):
    """
    entschluesslt den text in txt mit dem schluessel in schl
    es kann vorkommen, das letzte zeichen fehlen, wenn diese lauteten:"\x88"
    """
    i = txt.index("\x00")
    index = [files.string_int(txt[:i], ("\x00", ))]
    schluessel = iterator(schl, index, -1)
    lentxt = len(txt) - i - 1
    lall = []
    n = 0
    ##########################################################getestet
    #lall erzeugen
    for i in txt[i + 1:]:
        if n % 8 == 0:
            lbox = []
            lall.append(lbox)
        lbox.append(int_tuple(ord(i)))
        n += 1
#    print test[-1]==lall
##########################################################getestet
# boxen shiften
    itlistboshift = []
    i = 1
    while i < lentxt:
        itlistboshift.append(i)
        i = i << 8
    itlistboshift.reverse()
    ##########################################################
    lenlall = len(lall)
    for runde in range(10):
        ##########################################################
        #boxliste shiften -
        t = []
        for i in range(8):
            #shifttuple erstellen
            k = 0
            for j in itlistboshift:
                k -= ord(schluessel.next()) * j
            t.append(k)
        l = []  #liste fuer bitreihen aus lall
        for i in lall:
            l += i
        t.reverse()
        bitlist = zip(*shiftbox(
            zip(*l), t))  #lall-bitreihen shiften, in byte-tuple fassen
        #        print test[-2]==bitlist
        #ausgangsposition herstellen
        lall = []
        i = 0
        while i < lentxt:
            if i % 8 == 0:
                lbox = []
                lall.append(lbox)
            lbox.append(bitlist[i])
            i += 1
#        print test[-3]==lall
##########################################################
#boxen shiften
        i = 0
        lallklon = lall[:]
        while i < lenlall:
            lall[i]=shiftbox(zip(*lallklon[i])\
                    ,int_negocttuple(schluessel.next()\
                    +schluessel.next()+schluessel.next()))
            i += 1


#        print test[-4]==lall
##########################################################
    r = ""
    lall.reverse()
    for b in lall:
        rt = ""
        b.reverse()
        for t in b:
            rt = chr(tuple_int(t) ^ ord(schluessel.next())) + rt
        r = rt + r
    i = 0
    while r[i - 1] == "\x88":
        i -= 1
    #    print index # kontrolle: wenn [0]:alles ok
    if i == 0:
        return r
    else:
        return r[:i]