Django: Valider le type de fichier du fichier téléchargé

J'ai une application qui permet aux gens de télécharger des fichiers, représenté comme UploadedFiles. Cependant, je tiens à vous assurer que les utilisateurs d'uploader des fichiers xml. Je sais que je peux le faire à l'aide de magic, mais je ne sais pas où mettre cette check - je ne peux pas le mettre dans le clean fonction depuis le fichier n'est pas encore téléchargé lorsque clean pistes, autant que je peux dire.

Voici la UploadedFile modèle:

class UploadedFile(models.Model):
    """This represents a file that has been uploaded to the server."""
    STATE_UPLOADED = 0
    STATE_ANNOTATED = 1
    STATE_PROCESSING = 2
    STATE_PROCESSED = 4
    STATES = (
        (STATE_UPLOADED, "Uploaded"),
        (STATE_ANNOTATED, "Annotated"),
        (STATE_PROCESSING, "Processing"),
        (STATE_PROCESSED, "Processed"),
    )

    status = models.SmallIntegerField(choices=STATES,
        default=0, blank=True, null=True) 
    file = models.FileField(upload_to=settings.XML_ROOT)
    project = models.ForeignKey(Project)

    def __unicode__(self):
        return self.file.name

    def name(self):
        return os.path.basename(self.file.name)

    def save(self, *args, **kwargs):
        if not self.status:
            self.status = self.STATE_UPLOADED
        super(UploadedFile, self).save(*args, **kwargs)

    def delete(self, *args, **kwargs):
        os.remove(self.file.path)
        self.file.delete(False)
        super(UploadedFile, self).delete(*args, **kwargs)

    def get_absolute_url(self):
        return u'/upload/projects/%d' % self.id

    def clean(self):
        if not "XML" in magic.from_file(self.file.url):
            raise ValidationError(u'Not an xml file.')

class UploadedFileForm(forms.ModelForm):
    class Meta:                
        model = UploadedFile
        exclude = ('project',)

stackoverflow.com/questions/6460848/...
Mais il est hautement inefficace - je pourrais le titre d'un fichier tout ce que je veux.
Droite, ce que vérifie l'extension, mais vous pouvez l'utiliser comme base pour valider le fichier, telles que l'ouverture et la vérification de la validité de l'xml.
Le fichier est téléchargé lorsque clean fonctionne?
Jetez un oeil à Mikkos réponse et la façon dont il gère les formes nettoyé (post) de données qui contient le téléchargement de la filedata.

OriginalL'auteur Plasma | 2013-11-28

De valider les fichiers est régulièrement question, donc je voudrais utiliser un validateurs:

from django.utils.deconstruct import deconstructible
from django.template.defaultfilters import filesizeformat
import magic
@deconstructible
class FileValidator(object):
error_messages = {
'max_size': ("Ensure this file size is not greater than %(max_size)s."
" Your file size is %(size)s."),
'min_size': ("Ensure this file size is not less than %(min_size)s. "
"Your file size is %(size)s."),
'content_type': "Files of type %(content_type)s are not supported.",
}
def __init__(self, max_size=None, min_size=None, content_types=()):
self.max_size = max_size
self.min_size = min_size
self.content_types = content_types
def __call__(self, data):
if self.max_size is not None and data.size > self.max_size:
params = {
'max_size': filesizeformat(self.max_size), 
'size': filesizeformat(data.size),
}
raise ValidationError(self.error_messages['max_size'],
'max_size', params)
if self.min_size is not None and data.size < self.min_size:
params = {
'min_size': filesizeformat(self.mix_size),
'size': filesizeformat(data.size)
}
raise ValidationError(self.error_messages['min_size'], 
'min_size', params)
if self.content_types:
content_type = magic.from_buffer(data.read(), mime=True)
if content_type not in self.content_types:
params = { 'content_type': content_type }
raise ValidationError(self.error_messages['content_type'],
'content_type', params)
def __eq__(self, other):
return isinstance(other, FileValidator)

Ensuite, vous pouvez utiliser FileValidator dans votre model.FileField ou forms.FileField comme suit:

validate_file = FileValidator(max_size=1024 * 100, 
content_types=('application/xml',))
file = models.FileField(upload_to=settings.XML_ROOT, 
validators=[validate_file])

vous devriez mettre data.seek(0) après content_type = magic.from_buffer(data.read(), mime=True) de sorte que déposée peut être lu à nouveau dans la vue ou gestionnaire de fichier sans demander expressément à 0.
à travers une recherche sur google trouvé ce pypi.python.org/pypi/django-validated-file/2.0 est-ce que vous avez décrit ci-dessus
Pourquoi ajoutez-vous une @deconstructible décorateur à la classe?

OriginalL'auteur Sultan Alotaibi

Pour la postérité: la solution est d'utiliser la read méthode et passer à magic.from_buffer.

class UploadedFileForm(ModelForm):
def clean_file(self):
file = self.cleaned_data.get("file", False)
filetype = magic.from_buffer(file.read())
if not "XML" in filetype:
raise ValidationError("File is not XML.")
return file
class Meta:
model = models.UploadedFile
exclude = ('project',)

OriginalL'auteur Plasma

8

De django 1.11, vous pouvez également utiliser FileExtensionValidator.
```
from django.core.validators import FileExtensionValidator
class UploadedFile(models.Model):
file = models.FileField(upload_to=settings.XML_ROOT, 
validators=[FileExtensionValidator(allowed_extensions=['xml'])])
```
Remarque: ceci doit être utilisé sur un FileField et ne fonctionnera pas sur un CharField (par exemple), depuis le programme de validation valide sur la valeur.nom.

ref: https://docs.djangoproject.com/en/dev/ref/validators/#fileextensionvalidator

OriginalL'auteur rbennell
3

Je pense que ce que vous voulez faire est de nettoyer le fichier téléchargé dans Django Form.clean_your_field_name_here() méthodes - les données sont disponibles sur votre système puis, si elle était présentée comme normale requête HTTP POST.

Aussi, si vous considérez que c'est inefficace explorer les options des différents Django de téléchargement de fichiers backend et comment faire du streaming de traitement.

Si vous avez besoin de prendre en compte la sécurité du système lorsque vous traitez avec les téléchargements
- Assurez-vous téléchargé le fichier a l'extension correcte
- Assurez-vous que le type mime correspond à l'extension de fichier
Dans le cas où vous êtes inquiet au sujet de l'utilisateur de téléchargement d'exploiter des fichiers (pour les attaques à l'encontre de votre site)
- De réécrire tout le contenu du fichier sur enregistrer pour se débarrasser de possible en sus (exploiter) charge utile (si vous ne pouvez pas incorporer HTML en XML dont le navigateur interprète comme un site d'origine HTML fichier lors du téléchargement)
- Assurez-vous que vous utilisez-tête content-disposition en téléchargement
Certains plus d'infos ici: http://opensourcehacker.com/2013/07/31/secure-user-uploads-and-exploiting-served-user-content/

Ci-dessous est mon exemple comment j'ai désinfecter les images téléversées:
```
class Example(models.Model):
image = models.ImageField(upload_to=filename_gen("participant-images/"), blank=True, null=True)
class Example(forms.ModelForm):
def clean_image(self):
""" Clean the uploaded image attachemnt.
"""
image = self.cleaned_data.get('image', False)
utils.ensure_safe_user_image(image)
return image
def ensure_safe_user_image(image):
""" Perform various checks to sanitize user uploaded image data.
Checks that image was valid header, then
:param: InMemoryUploadedFile instance (Django form field value)
:raise: ValidationError in the case the image content has issues
"""
if not image:
return
assert isinstance(image, InMemoryUploadedFile), "Image rewrite has been only tested on in-memory upload backend"
# Make sure the image is not too big, so that PIL trashes the server
if image:
if image._size > 4*1024*1024:
raise ValidationError("Image file too large - the limit is 4 megabytes")
# Then do header peak what the image claims
image.file.seek(0)
mime = magic.from_buffer(image.file.getvalue(), mime=True)
if mime not in ("image/png", "image/jpeg"):
raise ValidationError("Image is not valid. Please upload a JPEG or PNG image.")
doc_type = mime.split("/")[-1].upper()
# Read data from cStringIO instance
image.file.seek(0)
pil_image = Image.open(image.file)
# Rewrite the image contents in the memory
# (bails out with exception on bad data)
buf = StringIO()
pil_image.thumbnail((2048, 2048), Image.ANTIALIAS)
pil_image.save(buf, doc_type)
image.file = buf
# Make sure the image has valid extension (can't upload .htm image)
extension = unicode(doc_type.lower())
if not image.name.endswith(u".%s" % extension):
image.name = image.name + u"." + extension
```
Il me semble avoir de la difficulté avec cela - j'ai déjà un modelForm pour mon UploadedFile modèle (voir mon OP), et je ne sais pas où je peux mettre clean_file. Si je l'ai mis à l'extérieur de meta, j'obtiens une erreur javascript que j'utilise pour télécharger le fichier. À l'intérieur de meta, il ne semble pas s'exécuter.
Ou je suppose que mon vrai problème, c'est que le file est encore dans la mémoire (c'est un InMemoryUploadedFile objet), donc je ne vois pas comment je peux courir aucun contrôle sur le fichier.

OriginalL'auteur Mikko Ohtamaa

Vous devez vous connecter pour publier un commentaire.