Encrypt and decrypt file in django

 #encrypt file
 def encrypt_file(self, in_file, password, extension='enc', salt_header='', key_length=32):
        if not self._validate(in_file, password):
            return False
        try:
            infile_name = in_file.name
            outfile_name = '{}.{}'.format(infile_name, extension)
            with open(outfile_name, 'wb') as out_file:
                bs = AES.block_size
                salt = os.urandom(bs - len(salt_header))
                key, iv = self._derive_key_and_iv(password, salt, key_length, bs)
                cipher = AES.new(key, AES.MODE_CBC, iv)
                out_file.write(str.encode(salt_header) + salt)
                finished = False
                while not finished:
                    chunk = in_file.read(1024 * bs)
                    if len(chunk) == 0 or len(chunk) % bs != 0:
                        padding_length = (bs - len(chunk) % bs) or bs
                        chunk += str.encode(
                            padding_length * chr(padding_length)
                        )
                        finished = True
                    out_file.write(cipher.encrypt(chunk))
                out_file.close()
            reopen = self._open_file(outfile_name)

            return self._return_file(reopen, outfile_name)




#decrypt file

    def decrypt_file(self, file_object, password, extension='enc', salt_header='', key_length=32):
        try:
            if not self._validate(file_object, password):
                return False
            filename = file_object.name
            outfile_name = filename.replace('.{}'.format(extension), '')
            print(os.path.join(file_object.name))
            with open(os.path.join(filename), 'r+b') as in_file:
                bs = AES.block_size
                salt = in_file.read(bs)[len(salt_header):]
                key, iv = self._derive_key_and_iv(password, salt, key_length, bs)
                cipher = AES.new(key, AES.MODE_CBC, iv)
                next_chunk = b''
                finished = False
                with open(outfile_name, 'wb') as out_file:
                    while not finished:
                        chunk, next_chunk = next_chunk, cipher.decrypt(in_file.read(1024 * bs))
                        if len(next_chunk) == 0:
                            if check_version == 2:
                                padding_length = chunk[-1]
                                chunk = chunk.replace(padding_length, '')
                            else:
                                padding_length = chunk[-1]
                                chunk = chunk[:-padding_length]
                            finished = True
                        out_file.write(chunk)
                    out_file.close()
            reopen = self._open_file(outfile_name)
            return self._return_file(reopen, outfile_name)



 #view


def encrypt_view(request):
    context = {}

    form = FileEncForm(request.POST or None, request.FILES or None)
    if form.is_valid():
        instance = form.save(commit=False)
        try:
            myfile = request.FILES.get('file', None)
            password = request.POST.get('password', None)
            encrypted_file = EncryptionService().encrypt_file(myfile, password, extension='enc')
            instance.file = encrypted_file
            instance.save()
        except ValidationError as e:
            print(e)
    context['form'] = form
    context['files'] = FileEncrypt.objects.all()
    return render(request, "file.html", context)


def decrypt_view(request, pk):
    context = {}
    try:
        my_object = FileEncrypt.objects.get(pk=pk)
        myfile = my_object.file

        decrypt_file = EncryptionService().decrypt_file(my_object.file, '123', extension='enc')

        f = open(decrypt_file, 'rb')
        file_content = f.read()
        f.close()
        return HttpResponse(file_content, content_type="text/plain")
    except ValidationError as e:
        print(e, 'rsfasd')

    return render(request, "file.html", context)




#model
class FileEncrypt(models.Model):
    file = models.FileField(
        upload_to='encrypt/'
    )