python-3.x - UnicodeDecodeError: 'utf-8' codec can't decode byte 0xf6 in position 1: invalid start byte - 试图将 DES 编码数据转换为 UTF-8 字符串

Question

下面附上的代码：在这里，我正在尝试为使用 LSTM 的 DES 加密数据扩展 vigenere 密码分析模型。我修改了 des.py 脚本以扩展 DES 密码分析模型，但是当我尝试加载 des 加密数据以训练模型时，我不断收到此 UnicodeError。我已经尝试了针对给定错误在线提到的所有现有解决方案。请帮我修复这个错误。几周以来，我一直在解决这个模型的各种错误。

维德斯.py -

import copy
import numpy as np
from bitstring import Bits
import pyDes
import sys
import gzip
class vigdes():
    def __init__(self, alphabet, tsteps, key_len):
        self.A = alphabet
        self.key_len = key_len
        self.wordlen = tsteps - key_len

    def change_tsteps(self, tsteps):
        self.wordlen = tsteps - self.key_len

    def encode(self, key, plain):
        cipher = ''
        key='DESCRYPT'
        key.encode('utf-8')
        print("length of key: ", len(key));
        k = pyDes.des(key, pyDes.CBC, "\0\0\0\0\0\0\0\0", pad=None, padmode=pyDes.PAD_PKCS5)
        data = plain
        d = k.encrypt(data)
        cipher = d
        print("des cipher: ", cipher)
        return cipher

    def decode(self, key, cipher):
        plain = ''
        k = pyDes.des(key, pyDes.CBC, "\0\0\0\0\0\0\0\0", pad=None, padmode=pyDes.PAD_PKCS5)
        plain = k.decrypt(cipher).decode()
        print("des plain: ", plain)
        return plain

    def rands(self, size):
        ix = np.random.randint(len(self.A) ,size=size)
        return ''.join([self.A[i] for i in ix])

    def one_hot(self, s):
        _A = copy.deepcopy(self.A) + '-'
        ix = [_A.find(l) for l in s]
        z = np.zeros((len(s) ,len(_A)))
        z[range(len(s)) ,ix] = 1
        return z

    def next_batch(self, batch_size, verbose=False):
        batch_X = [] ; batch_y = [] ; batch_Xs = [] ; batch_ks = [] ; batch_ys = []
        for _ in range(batch_size):
            ys = self.rands(self.wordlen)
            ks = self.rands(np.random.randint(self.key_len) + 1)

            # lets us check for overfitting later
            while ks == 'KEY':
                ks_ = ks
                ks = self.rands(np.random.randint(self.key_len) + 1)
                print('warning! key was "{}" but now is "{}"'.format(ks_, ks))

            Xs = self.encode(ks, ys)
            ks += '- ' *(self.key_len - len(ks))
            if verbose: print( Xs, ks, ys )
            #remove
            xstr=str(Xs,'utf-8');
            X = self.one_hot(ks + xstr)

            #X = self.one_hot(ks + Xs)
            y = self.one_hot(ks + ys)
            batch_X.append(X)
            batch_y.append(y)
            batch_Xs.append(Xs) ; batch_ks.append(ks) ; batch_ys.append(ys)

        if not verbose:
            return (batch_X ,batch_y)
        else:
            return (batch_X, batch_y, batch_Xs, batch_ks, batch_ys)

主文件

import numpy as np
import os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import tensorflow as tf
import os

from stacked_rnn import StackedRNN

MEM_SIZES = [32, 64, 128, 256, 512] # use for vigenere ciphers

tf.app.flags.DEFINE_bool("train", True, "Run the train loop (else eval model)")
tf.app.flags.DEFINE_bool("vary_mem", False, "Trainpip --downg0c this model repeatedly for different memory sizes")
tf.app.flags.DEFINE_integer("key_len", 8, "Maximum length of key for encoding/decoding message")
tf.app.flags.DEFINE_integer("tsteps", 20, "Number of timesteps for backpropagation")
tf.app.flags.DEFINE_integer("rnn_size", 256, "Number of hidden units in the rnn")
tf.app.flags.DEFINE_integer("ncells", 1, "Number of recurrent cells to stack")
tf.app.flags.DEFINE_integer("batch_size", 50, "Size of batch in minibatch gradient descent")
tf.app.flags.DEFINE_integer("save_every", 1000, "Save model after this number of train steps")
tf.app.flags.DEFINE_integer("total_steps", 250000, "Total number of training steps")
tf.app.flags.DEFINE_integer("print_every", 100, "Print training info after this number of train steps")
tf.app.flags.DEFINE_integer("acc_every", 500, "Print/save accuracy info after this number of train steps")
tf.app.flags.DEFINE_float("dropout", 1.0, "Dropout for the last (full-connected) layer")
tf.app.flags.DEFINE_float("lr", 5e-4, "Learning rate (alpha) for the model")
tf.app.flags.DEFINE_string("cipher", "vigdes", 'Type of cipher to solve. ')
tf.app.flags.DEFINE_string("meta_dir", "", 'META_DIR')
tf.app.flags.DEFINE_string("save_dir", "", 'META_DIR')
tf.app.flags.DEFINE_string("A", "ABCDEFGHIJKLMNOPQRSTUVWXYZ", "Alphabet to use for polyalphabetic cipher")
FLAGS = tf.app.flags.FLAGS

##### interpret user input #####
ciphers = ["vigenere", "DES","vigdes"]
if FLAGS.cipher not in ciphers:
    raise NotImplementedError('only {} ciphers are implemented'.format(ciphers))

CRACK_MODE = FLAGS.cipher not in ciphers[:3]
print("Crack mode: {}".format(CRACK_MODE))
if CRACK_MODE:
    from crack_train_utils import *
else:
    from train_utils import *

##### make cipher dataloader #####
data = None
if FLAGS.cipher == ciphers[0]:
    from vigenere import Vigenere
    data = Vigenere(FLAGS.A, tsteps=FLAGS.tsteps, key_len=FLAGS.key_len)
elif FLAGS.cipher == ciphers[1]:
    from DES import DES
    data = DES(FLAGS.A, tsteps=FLAGS.tsteps, key_len=FLAGS.key_len)
elif FLAGS.cipher == ciphers[2]:
    from vigdes import vigdes
    data = vigdes(FLAGS.A, tsteps=FLAGS.tsteps, key_len=FLAGS.key_len)

elif FLAGS.cipher == ciphers[3]:
    from crack_vigenere import CrackVigenere
    data = CrackVigenere(FLAGS.A, tsteps=FLAGS.tsteps, key_len=FLAGS.key_len)
elif FLAGS.cipher == ciphers[4]:
    from crack_autokey import CrackAutokey
    data = CrackAutokey(FLAGS.A, tsteps=FLAGS.tsteps, key_len=FLAGS.key_len)

def get_model(FLAGS):
    global CRACK_MODE
    model = StackedRNN(FLAGS=FLAGS, crack_mode=CRACK_MODE)
    model.count_params()
    return model

def eval_model(FLAGS, model, data, log):
    # evaluate model (quantitatively first, then qualitatively)
    print('plotting (check ./{} directory)...'.format(FLAGS.meta_dir))
    plot_stats(log, FLAGS)

    global_step = model.try_load_model()
    print( "accuracy is: {:3f}%".format(accuracy(model,data)) )
    sample(model, data, FLAGS)

# train model
if not FLAGS.vary_mem and FLAGS.train:

    # make bookkeping devices
    FLAGS.meta_dir = 'meta/' + FLAGS.cipher +'/' # directory to save loss history, figures, etc.
    FLAGS.save_dir = 'save/' + FLAGS.cipher +'/' # directory to save model
    os.makedirs(FLAGS.save_dir) if not os.path.exists(FLAGS.save_dir) else None
    os.makedirs(FLAGS.meta_dir) if not os.path.exists(FLAGS.meta_dir) else None
    log = Logger(FLAGS)

    # train model
    model = get_model(FLAGS)
    train(model, data, log, FLAGS)
    
elif FLAGS.train:
    for m in MEM_SIZES:
        FLAGS.rnn_size = m # change rnn memory size

        # make bookkeping devices
        FLAGS.meta_dir = 'meta/' + FLAGS.cipher +'-{}/'.format(m) # directory to save loss history, figures, etc.
        FLAGS.save_dir = 'save/' + FLAGS.cipher +'-{}/'.format(m) # directory to save model
        os.makedirs(FLAGS.save_dir) if not os.path.exists(FLAGS.save_dir) else None
        os.makedirs(FLAGS.meta_dir) if not os.path.exists(FLAGS.meta_dir) else None
        log = Logger(FLAGS)

        # train as usual
        model = get_model(FLAGS)
        train(model, data, log, FLAGS)
        eval_model(FLAGS, model, data, log)

elif not FLAGS.vary_mem and not FLAGS.train:
    # make bookkeping devices
    FLAGS.meta_dir = 'meta/' + FLAGS.cipher + '/' # directory to save loss history, figures, etc.
    FLAGS.save_dir = 'save/' + FLAGS.cipher + '/' # directory to save model
    os.makedirs(FLAGS.save_dir) if not os.path.exists(FLAGS.save_dir) else None
    os.makedirs(FLAGS.meta_dir) if not os.path.exists(FLAGS.meta_dir) else None

    print(FLAGS.meta_dir) ; print(FLAGS.save_dir)
    log = Logger(FLAGS)
    model = get_model(FLAGS)
    eval_model(FLAGS, model, data, log)

python-3.x - UnicodeDecodeError: 'utf-8' codec can't decode byte 0xf6 in position 1: invalid start byte - 试图将 DES 编码数据转换为 UTF-8 字符串

0 回答 0

Related

Reference