Tengo una .obj archivo en el que, anteriormente, he transformado a una imagen en base64 y se guarda con pickle.

El problema es cuando trato de cargar el .obj archivo con pickle, para convertir el código en la imagen de base64, y cargar con pygame.

La función que carga la imagen:

def mainDisplay_load(self):
    main_folder = path.dirname(__file__)
    img_main_folder = path.join(main_folder, "sd_graphics")

    # loadImg
    self.mainTerminal = pg.image.load(path.join(img_main_folder, self.main_uncode("tr.obj"))).convert_alpha()

La función que descifra el archivo:

def main_uncode(self, object):
    openFile = open(object, "rb")
    str = pickle.load(openFile)
    openFile.close()
    fileData = base64.b64decode(str)
    return fileData

El error cuando se ejecuta el código:

str = pickle.load(openFile)

EOFError: se acabó la entrada

¿Cómo puedo solucionarlo?

  • De la versión de Python: 3.6.2
  • Pygame versión: 1.9.3

Actualización de 1

Este es el código que he usado para crear el .obj de archivo:

import base64, pickle

with open("terminal.png", "rb") as imageFile:
    str = base64.b64encode(imageFile.read())
    print(str)

file_pi = open("tr.obj","wb")
pickle.dump(str,file_pi)
file_pi.close()

file_pi2 = open("tr.obj","rb")
str2 = pickle.load(file_pi2)
file_pi2.close()

imgdata = base64.b64decode(str2)
filename = 'some_image.jpg'  # I assume you have a way of picking unique filenames
with open(filename, 'wb') as f:
    f.write(imgdata)

Una vez creado el archivo, se carga y una segunda imagen es creada. Esto es para comprobar si la imagen es la misma o hay errores en la conversión.

Como se puede ver, he utilizado parte del código para cargar la imagen, pero en lugar de ahorrar, se carga en pygame. Y ahí es donde el error se produce.

Actualización 2

Por fin he conseguido resolverlo.

En el código principal:

def mainDisplay_load(self):
    self.all_graphics = pg.sprite.Group()
    self.graphics_menu = pg.sprite.Group()

    # loadImg
    self.img_mainTerminal = mainGraphics(self, 0, 0, "sd_graphics/tr.obj")

En la biblioteca que contiene las clases gráficas:

import pygame as pg
import base64 as bs
import pickle as pk
from io import BytesIO as by
from lib.setting import *

class mainGraphics(pg.sprite.Sprite):
    def __init__(self, game, x, y, object):
        self.groups = game.all_graphics, game.graphics_menu
        pg.sprite.Sprite.__init__(self, self.groups)
        self.game = game
        self.object = object
        self.outputGraphics = by()

        self.x = x
        self.y = y

        self.eventType()

        self.rect = self.image.get_rect()
        self.rect.x = self.x * tilesizeDefault
        self.rect.y = self.y * tilesizeDefault

    def eventType(self):
        openFile = open(self.object, "rb")
        str = pk.load(openFile)
        openFile.close()
        self.outputGraphics.write(bs.b64decode(str))
        self.outputGraphics.seek(0)
        self.image = pg.image.load(self.outputGraphics).convert_alpha()

Para la pregunta de por qué yo debería hacer tal cosa, es simple:

cualquier atacante con suficiente motivación, todavía puede conseguir fácilmente

Python es libre y abierto.

Por un lado, tenemos a una persona que intencionalmente va y modificar y recuperar los datos ocultos. Pero si Python es un lenguaje abierto, como con aún más complicada y protegido de los idiomas, los más motivados, son capaces de romper el juego o programa y recuperar los mismos datos.

Por otro lado, tenemos a una persona que sólo conoce los fundamentos, o ni siquiera eso. Una persona que no puede acceder a los archivos sin necesidad de saber más sobre la lengua, o la decodificación de los archivos.

Así se puede entender que la decodificación de los archivos, desde mi punto de vista, no necesita ser protegido de una persona motivada. Porque incluso con más compleja y protegido del lenguaje, lo que motivó la persona va a ser capaz de conseguir lo que quiere. La protección es utilizado en contra de personas que no tienen ningún conocimiento de la lengua.

parece que existe un error en su _load función – se concatenan descodifica los datos de la imagen con el nombre de la carpeta? También, si desea significativa ayuda, usted puede publicar el código utilizado para crear estos archivos en lugar de sólo describir. Como sea, parece ser que tiene algunos bastante redundante pasos.
Por CIERTO, el error se ha informado de que sucede antes de que la parte que he mencionado anteriormente,que también sería error. El problema parece ser que durante la creación de sus archivos.
He añadido el código que uso para crear el .archivo obj

OriginalEl autor BlackFenix06 | 2017-11-12

1 Comentario

  1. 1

    Por lo tanto, si el error es de hecho «pickle: ejecutar fuera de la entrada», que probablemente significa que te equivocaste de sus directorios en el código anterior, y está tratando de leer un archivo vacío con el mismo nombre que su obj archivo.

    Realidad, como es, esta línea en el código:

    self.mainTerminal=pg.image.load(path.join(img_main_folder,self.main_uncode
    ("tr.obj"))).convert_alpha()

    Está totalmente en mal estado. Acaba de leer y se puede ver el problema: se pasa a la main_uncode método sólo el nombre de archivo, sin la información de directorio. Y luego, si es que por casualidad han trabajado, como he poitned en los comentarios hace un tiempo, debe tratar de utilizar el deserializada datos de la imagen como el nombre de un archivo desde el que leer su imagen. (Usted o alguien más probablemente había pensado que main_uncode debe escribir un archivo de imagen temporal y orden de los datos de imagen a la que, por lo que Pygame podía leer, sino como lo que es, es simplemente devolver los datos de imagen raw en una cadena).

    Threfore, mediante la fijación de la llamada anterior y pasa una ruta de acceso real a main_uncode, y además de modificar para escribir el temporal de datos a un archivo y volver a su ruta de acceso de la revisión de los fragmentos de código anterior.

    Segunda cosa es que yo no puedo entender por qué usted necesita este «.obj archivo». Si es sólo para la «seguridad por oscuridad» salto a la gente a conseguir su liado archivo no se puede abrir las imágenes, que es una cosa lejos de ser una práctica recomendada. Para resumir en una sola cosa: que va a retrasar los usos legítimos de su archivo (como, usted no parece ser capaz de usarlo ), mientras que cualquier atacante con suficiente motivación todavía puede llegar a ella fácilmente. Por apertura de una imagen, base-64 codificación y decapado, y hacer el proceso inverso que están haciendo esencialmente un no-operación. Aún más, un archivo pickle puede serializar y escribir en el disco complejo de los objetos de Python – pero un base64 serialización de una imagen puede ser escrito directamente a un archivo, sin necesidad de vinagre.

    Tercera cosa: sólo tiene que utilizar with para abrir todos los archivos, no solo la que se lee con la biblioteca de imágenes, Tómese su tiempo para aprender un poco más acerca de Python.

    OriginalEl autor jsbueno

Dejar respuesta

Please enter your comment!
Please enter your name here