web: Send better errors for failed upload requests

[pbs.git] / src / web / uploads.py

#!/usr/bin/python3
###############################################################################
#                                                                             #
# Pakfire - The IPFire package management system                              #
# Copyright (C) 2011 Pakfire development team                                 #
#                                                                             #
# This program is free software: you can redistribute it and/or modify        #
# it under the terms of the GNU General Public License as published by        #
# the Free Software Foundation, either version 3 of the License, or           #
# (at your option) any later version.                                         #
#                                                                             #
# This program is distributed in the hope that it will be useful,             #
# but WITHOUT ANY WARRANTY; without even the implied warranty of              #
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               #
# GNU General Public License for more details.                                #
#                                                                             #
# You should have received a copy of the GNU General Public License           #
# along with this program.  If not, see <http://www.gnu.org/licenses/>.       #
#                                                                             #
###############################################################################

import io
import tornado.web

from . import base
from .. import uploads
from .. import users

class APIv1IndexHandler(base.APIMixin, tornado.web.RequestHandler):
	# Allow users to perform uploads
	allow_users = True

	@base.negotiate
	def get(self):
		uploads = []

		for upload in self.current_user.uploads:
			uploads.append({
				"id"         : "%s" % upload.uuid,
				"filename"   : upload.filename,
				"size"       : upload.size,

				"created_at" : upload.created_at.isoformat(),
				"expires_at" : upload.expires_at.isoformat(),
			})

		self.finish({
			"status"  : "ok",
			"uploads" : uploads,
		})

	@base.negotiate
	async def post(self):
		"""
			Creates a new upload and returns its UUID
		"""
		# Fetch the filename
		filename = self.get_argument("filename")

		# Fetch file size
		size = self.get_argument_int("size")

		# Fetch the digest algorithm
		digest_algo = self.get_argument("hexdigest_algo")

		# Fetch the digest
		hexdigest = self.get_argument("hexdigest")

		# Convert hexdigest
		try:
			digest = bytes.fromhex(hexdigest)
		except ValueError as e:
			raise tornado.web.HTTPError(400, "Invalid hexdigest") from e

		# Create a new upload
		with self.db.transaction():
			try:
				upload = await self.backend.uploads.create(
					filename,
					size=size,
					owner=self.current_user,
					digest_algo=digest_algo,
					digest=digest,
				)

			except uploads.UnsupportedDigestException as e:
				raise base.APIError(400, "Unsupported digest %s" % digest_algo) from e

			except users.QuotaExceededError as e:
				raise base.APIError(400, "Quota exceeded for %s" % self.current_user) from e

			except ValueError as e:
				raise base.APIError(400, "%s" % e) from e

		# Send the ID of the upload back to the client
		self.finish({
			"id"         : "%s" % upload.uuid,
			"expires_at" : upload.expires_at.isoformat(),
		})


@tornado.web.stream_request_body
class APIv1DetailHandler(base.APIMixin, tornado.web.RequestHandler):
	# Allow users to perform uploads
	allow_users = True

	def initialize(self):
		# Buffer to cache the uploaded content
		self.buffer = io.BytesIO()

	def data_received(self, data):
		"""
			Called when some data is being received
		"""
		self.buffer.write(data)

	# Yes, this does not require authentication. You have seen this correctly.
	# This is because of us using SPNEGO which might cause a request being sent
	# more than once, which therefore means that the payload is being transferred
	# more than once.
	# To avoid this, we request the digest when the upload is being created, we
	# then generate a unique ID which an attacker would have to guess first and
	# then have to upload a file which's hash collides with the original file.
	async def put(self, uuid):
		"""
			Called to store the received payload
		"""
		# Fetch the upload
		upload = self.backend.uploads.get_by_uuid(uuid)
		if not upload:
			raise tornado.web.HTTPError(404, "Could not find upload %s" % uuid)

		# Import the payload from the buffer
		with self.db.transaction():
			try:
				await upload.copyfrom(self.buffer)

			except ValueError as e:
				raise base.APIError(400, "%s" % e) from e

	@base.negotiate
	async def delete(self, uuid):
		"""
			Deletes an upload with a certain UUID
		"""
		# Fetch the upload
		upload = self.backend.uploads.get_by_uuid(uuid)
		if not upload:
			raise tornado.web.HTTPError(404, "Could not find upload %s" % uuid)

		# Check for permissions
		if not upload.has_perm(self.current_user):
			raise tornado.web.HTTPError(403, "%s has no permission to delete %s" \
				% (self.current_user, upload))

		# Delete the upload
		with self.db.transaction():
			await upload.delete()

		self.finish({
			"status" : "ok",
		})