diff --git a/cypress/fixtures/swh:1:dir:cd19126d815470b28919d64b2a8e6a3e37f900dd.tar.gz b/cypress/fixtures/swh_1_dir_cd19126d815470b28919d64b2a8e6a3e37f900dd.tar.gz
similarity index 100%
rename from cypress/fixtures/swh:1:dir:cd19126d815470b28919d64b2a8e6a3e37f900dd.tar.gz
rename to cypress/fixtures/swh_1_dir_cd19126d815470b28919d64b2a8e6a3e37f900dd.tar.gz
diff --git a/cypress/fixtures/swh:1:rev:1c480a4573d2a003fc2630c21c2b25829de49972.git.tar b/cypress/fixtures/swh_1_rev_1c480a4573d2a003fc2630c21c2b25829de49972.git.tar
similarity index 100%
rename from cypress/fixtures/swh:1:rev:1c480a4573d2a003fc2630c21c2b25829de49972.git.tar
rename to cypress/fixtures/swh_1_rev_1c480a4573d2a003fc2630c21c2b25829de49972.git.tar
diff --git a/cypress/integration/vault.spec.js b/cypress/integration/vault.spec.js
index 69d9f5fe..e0c7fef6 100644
--- a/cypress/integration/vault.spec.js
+++ b/cypress/integration/vault.spec.js
@@ -1,541 +1,541 @@
 /**
  * Copyright (C) 2019-2021  The Software Heritage developers
  * See the AUTHORS file at the top-level directory of this distribution
  * License: GNU Affero General Public License version 3, or any later version
  * See top-level LICENSE file for more information
  */
 
 const progressbarColors = {
   'new': 'rgba(128, 128, 128, 0.5)',
   'pending': 'rgba(0, 0, 255, 0.5)',
   'done': 'rgb(92, 184, 92)'
 };
 
 function checkVaultCookingTask(objectType) {
   cy.contains('button', 'Download')
     .click();
 
   cy.contains('.dropdown-item', objectType)
     .click();
 
   cy.wait('@checkVaultCookingTask');
 }
 
 function getVaultItemList() {
   return JSON.parse(window.localStorage.getItem('swh-vault-cooking-tasks'));
 }
 
 function updateVaultItemList(vaultItems) {
   window.localStorage.setItem('swh-vault-cooking-tasks', JSON.stringify(vaultItems));
 }
 
 // Mocks API response : /api/1/vault/(:bundleType)/(:swhid)
 // bundleType : {'flat', 'git_bare'}
 function genVaultCookingResponse(bundleType, swhid, status, message, fetchUrl) {
   return {
     'bundle_type': bundleType,
     'id': 1,
     'progress_message': message,
     'status': status,
     'swhid': swhid,
     'fetch_url': fetchUrl
   };
 };
 
 // Tests progressbar color, status
 // And status in localStorage
 function testStatus(taskId, color, statusMsg, status) {
   cy.get(`.swh-vault-table #vault-task-${CSS.escape(taskId)}`)
     .should('be.visible')
     .find('.progress-bar')
     .should('be.visible')
     .and('have.css', 'background-color', color)
     .and('contain', statusMsg)
     .then(() => {
       // Vault item with object_id as taskId should exist in localStorage
       const currentVaultItems = getVaultItemList();
       const vaultItem = currentVaultItems.find(obj => obj.swhid === taskId);
 
       assert.isNotNull(vaultItem);
       assert.strictEqual(vaultItem.status, status);
     });
 }
 
 describe('Vault Cooking User Interface Tests', function() {
 
   before(function() {
     const dirInfo = this.origin[0].directory[0];
     this.directory = `swh:1:dir:${dirInfo.id}`;
     this.directoryUrl = this.Urls.browse_origin_directory() +
       `?origin_url=${this.origin[0].url}&path=${dirInfo.path}`;
     this.vaultDirectoryUrl = this.Urls.api_1_vault_cook_flat(this.directory);
     this.vaultFetchDirectoryUrl = this.Urls.api_1_vault_fetch_flat(this.directory);
 
     this.revisionId = this.origin[1].revisions[0];
     this.revision = `swh:1:rev:${this.revisionId}`;
     this.revisionUrl = this.Urls.browse_revision(this.revisionId);
     this.vaultRevisionUrl = this.Urls.api_1_vault_cook_git_bare(this.revision);
     this.vaultFetchRevisionUrl = this.Urls.api_1_vault_fetch_git_bare(this.revision);
 
     const release = this.origin[1].release;
     this.releaseUrl = this.Urls.browse_release(release.id) + `?origin_url=${this.origin[1].url}`;
     this.vaultReleaseDirectoryUrl = this.Urls.api_1_vault_cook_flat(`swh:1:dir:${release.directory}`);
   });
 
   beforeEach(function() {
     // For some reason, this gets reset if we define it in the before() hook,
     // so we need to define it here
     this.vaultItems = [
       {
         'bundle_type': 'git_bare',
         'swhid': this.revision,
         'email': '',
         'status': 'done',
         'fetch_url': `/api/1/vault/git-bare/${this.revision}/raw/`,
         'progress_message': null
       }
     ];
     this.legacyVaultItems = [
       {
         'object_type': 'revision',
         'object_id': this.revisionId,
         'email': '',
         'status': 'done',
         'fetch_url': `/api/1/vault/revision/${this.revisionId}/gitfast/raw/`,
         'progress_message': null
       }
     ];
 
     this.genVaultDirCookingResponse = (status, message = null) => {
       return genVaultCookingResponse('flat', this.directory, status,
                                      message, this.vaultFetchDirectoryUrl);
     };
 
     this.genVaultRevCookingResponse = (status, message = null) => {
       return genVaultCookingResponse('git_bare', this.revision, status,
                                      message, this.vaultFetchRevisionUrl);
     };
 
   });
 
   it('should report an error when vault service is experiencing issues', function() {
     // Browse a directory
     cy.visit(this.directoryUrl);
 
     // Stub responses when requesting the vault API to simulate
     // an internal server error
     cy.intercept(this.vaultDirectoryUrl, {
       body: {'exception': 'APIError'},
       statusCode: 500
     }).as('checkVaultCookingTask');
 
     cy.contains('button', 'Download')
       .click();
 
     // Check error alert is displayed
     cy.get('.alert-danger')
     .should('be.visible')
     .should('contain', 'Archive cooking service is currently experiencing issues.');
   });
 
   it('should report an error when a cooking task creation failed', function() {
 
     // Browse a directory
     cy.visit(this.directoryUrl);
 
     // Stub responses when requesting the vault API to simulate
     // a task can not be created
     cy.intercept('GET', this.vaultDirectoryUrl, {
       body: {'exception': 'NotFoundExc'}
     }).as('checkVaultCookingTask');
 
     cy.intercept('POST', this.vaultDirectoryUrl, {
       body: {'exception': 'ValueError'},
       statusCode: 500
     }).as('createVaultCookingTask');
 
     cy.contains('button', 'Download')
       .click();
 
     // Create a vault cooking task through the GUI
     cy.get('.modal-dialog')
       .contains('button:visible', 'Ok')
       .click();
 
     cy.wait('@createVaultCookingTask');
 
     // Check error alert is displayed
     cy.get('.alert-danger')
       .should('be.visible')
       .should('contain', 'Archive cooking request submission failed.');
   });
 
   it('should display previous cooking tasks', function() {
 
     updateVaultItemList(this.vaultItems);
 
     cy.visit(this.Urls.browse_vault());
 
     cy.contains(`#vault-task-${CSS.escape(this.revision)} button`, 'Download')
       .click();
   });
 
   it('should display and upgrade previous cooking tasks from the legacy format', function() {
     updateVaultItemList(this.legacyVaultItems);
 
     cy.visit(this.Urls.browse_vault());
 
     // Check it is displayed
     cy.contains(`#vault-task-${CSS.escape(this.revision)} button`, 'Download')
       .then(() => {
         // Check the LocalStorage was upgraded
         expect(getVaultItemList()).to.deep.equal(this.vaultItems);
       });
   });
 
   it('should create a directory cooking task and report the success', function() {
 
     // Browse a directory
     cy.visit(this.directoryUrl);
 
     // Stub response to the vault API to simulate archive download
     cy.intercept('GET', this.vaultFetchDirectoryUrl, {
-      fixture: `${this.directory}.tar.gz`,
+      fixture: `${this.directory.replace(/:/g, '_')}.tar.gz`,
       headers: {
-        'Content-disposition': `attachment; filename=${this.directory}.tar.gz`,
+        'Content-disposition': `attachment; filename=${this.directory.replace(/:/g, '_')}.tar.gz`,
         'Content-Type': 'application/gzip'
       }
     }).as('fetchCookedArchive');
 
     // Stub responses when checking vault task status
     const checkVaulResponses = [
       {'exception': 'NotFoundExc'},
       this.genVaultDirCookingResponse('new'),
       this.genVaultDirCookingResponse('pending', 'Processing...'),
       this.genVaultDirCookingResponse('done')
     ];
 
     // trick to override the response of an intercepted request
     // https://github.com/cypress-io/cypress/issues/9302
     cy.intercept('GET', this.vaultDirectoryUrl, req => req.reply(checkVaulResponses.shift()))
       .as('checkVaultCookingTask');
 
     // Stub responses when requesting the vault API to simulate
     // a task has been created
     cy.intercept('POST', this.vaultDirectoryUrl, {
       body: this.genVaultDirCookingResponse('new')
     }).as('createVaultCookingTask');
 
     cy.contains('button', 'Download')
       .click();
 
     cy.window().then(win => {
       const swhIdsContext = win.swh.webapp.getSwhIdsContext();
       const browseDirectoryUrl = swhIdsContext.directory.swhid_with_context_url;
 
       // Create a vault cooking task through the GUI
       cy.get('.modal-dialog')
         .contains('button:visible', 'Ok')
         .click();
 
       cy.wait('@createVaultCookingTask');
 
       // Check success alert is displayed
       cy.get('.alert-success')
         .should('be.visible')
         .should('contain', 'Archive cooking request successfully submitted.');
 
       // Go to Downloads page
       cy.visit(this.Urls.browse_vault());
 
       cy.wait('@checkVaultCookingTask').then(() => {
         testStatus(this.directory, progressbarColors['new'], 'new', 'new');
       });
 
       cy.wait('@checkVaultCookingTask').then(() => {
         testStatus(this.directory, progressbarColors['pending'], 'Processing...', 'pending');
       });
 
       cy.wait('@checkVaultCookingTask').then(() => {
         testStatus(this.directory, progressbarColors['done'], 'done', 'done');
       });
 
       cy.get(`#vault-task-${CSS.escape(this.directory)} .vault-origin a`)
         .should('contain', this.origin[0].url)
         .should('have.attr', 'href', `${this.Urls.browse_origin()}?origin_url=${this.origin[0].url}`);
 
       cy.get(`#vault-task-${CSS.escape(this.directory)} .vault-object-info a`)
         .should('have.text', this.directory)
         .should('have.attr', 'href', browseDirectoryUrl);
 
       cy.get(`#vault-task-${CSS.escape(this.directory)} .vault-dl-link button`)
         .click();
 
       cy.wait('@fetchCookedArchive').then((xhr) => {
         assert.isNotNull(xhr.response.body);
       });
     });
   });
 
   it('should create a revision cooking task and report its status', function() {
     cy.adminLogin();
 
     // Browse a revision
     cy.visit(this.revisionUrl);
 
     // Stub response to the vault API indicating to simulate archive download
     cy.intercept({url: this.vaultFetchRevisionUrl}, {
-      fixture: `${this.revision}.git.tar`,
+      fixture: `${this.revision.replace(/:/g, '_')}.git.tar`,
       headers: {
-        'Content-disposition': `attachment; filename=${this.revision}.git.tar`,
+        'Content-disposition': `attachment; filename=${this.revision.replace(/:/g, '_')}.git.tar`,
         'Content-Type': 'application/gzip'
       }
     }).as('fetchCookedArchive');
 
     // Stub responses when checking vault task status
     const checkVaultResponses = [
       {'exception': 'NotFoundExc'},
       this.genVaultRevCookingResponse('new'),
       this.genVaultRevCookingResponse('pending', 'Processing...'),
       this.genVaultRevCookingResponse('done')
     ];
 
     // trick to override the response of an intercepted request
     // https://github.com/cypress-io/cypress/issues/9302
     cy.intercept('GET', this.vaultRevisionUrl, req => req.reply(checkVaultResponses.shift()))
       .as('checkVaultCookingTask');
 
     // Stub responses when requesting the vault API to simulate
     // a task has been created
     cy.intercept('POST', this.vaultRevisionUrl, {
       body: this.genVaultRevCookingResponse('new')
     }).as('createVaultCookingTask');
 
     // Create a vault cooking task through the GUI
     checkVaultCookingTask('as git');
 
     cy.window().then(win => {
       const swhIdsContext = win.swh.webapp.getSwhIdsContext();
       const browseRevisionUrl = swhIdsContext.revision.swhid_url;
 
       // Create a vault cooking task through the GUI
       cy.get('.modal-dialog')
         .contains('button:visible', 'Ok')
         .click();
 
       cy.wait('@createVaultCookingTask');
 
       // Check success alert is displayed
       cy.get('.alert-success')
         .should('be.visible')
         .should('contain', 'Archive cooking request successfully submitted.');
 
       // Go to Downloads page
       cy.visit(this.Urls.browse_vault());
 
       cy.wait('@checkVaultCookingTask').then(() => {
         testStatus(this.revision, progressbarColors['new'], 'new', 'new');
       });
 
       cy.wait('@checkVaultCookingTask').then(() => {
         testStatus(this.revision, progressbarColors['pending'], 'Processing...', 'pending');
       });
 
       cy.wait('@checkVaultCookingTask').then(() => {
         testStatus(this.revision, progressbarColors['done'], 'done', 'done');
       });
 
       cy.get(`#vault-task-${CSS.escape(this.revision)} .vault-origin`)
         .should('have.text', 'unknown');
 
       cy.get(`#vault-task-${CSS.escape(this.revision)} .vault-object-info a`)
         .should('have.text', this.revision)
         .should('have.attr', 'href', browseRevisionUrl);
 
       cy.get(`#vault-task-${CSS.escape(this.revision)} .vault-dl-link button`)
         .click();
 
       cy.wait('@fetchCookedArchive').then((xhr) => {
         assert.isNotNull(xhr.response.body);
       });
     });
   });
 
   it('should create a directory cooking task from the release view', function() {
 
     // Browse a directory
     cy.visit(this.releaseUrl);
 
     // Stub responses when checking vault task status
     const checkVaultResponses = [
       {'exception': 'NotFoundExc'},
       this.genVaultDirCookingResponse('new')
     ];
 
     // trick to override the response of an intercepted request
     // https://github.com/cypress-io/cypress/issues/9302
     cy.intercept('GET', this.vaultReleaseDirectoryUrl, req => req.reply(checkVaultResponses.shift()))
       .as('checkVaultCookingTask');
 
     // Stub responses when requesting the vault API to simulate
     // a task has been created
     cy.intercept('POST', this.vaultReleaseDirectoryUrl, {
       body: this.genVaultDirCookingResponse('new')
     }).as('createVaultCookingTask');
 
     cy.contains('button', 'Download')
       .click();
 
     // Create a vault cooking task through the GUI
     cy.get('.modal-dialog')
         .contains('button:visible', 'Ok')
         .click();
 
     cy.wait('@createVaultCookingTask');
 
     // Check success alert is displayed
     cy.get('.alert-success')
         .should('be.visible')
         .should('contain', 'Archive cooking request successfully submitted.');
   });
 
   it('should offer to recook an archive if no longer available for download', function() {
 
     updateVaultItemList(this.vaultItems);
 
     // Send 404 when fetching vault item
     cy.intercept({url: this.vaultFetchRevisionUrl}, {
       statusCode: 404,
       body: {
         'exception': 'NotFoundExc',
         'reason': `Revision with ID '${this.revision}' not found.`
       },
       headers: {
         'Content-Type': 'json'
       }
     }).as('fetchCookedArchive');
 
     cy.visit(this.Urls.browse_vault())
       .get(`#vault-task-${CSS.escape(this.revision)} .vault-dl-link button`)
       .click();
 
     cy.wait('@fetchCookedArchive').then(() => {
       cy.intercept('POST', this.vaultRevisionUrl, {
         body: this.genVaultRevCookingResponse('new')
       }).as('createVaultCookingTask');
 
       cy.intercept(this.vaultRevisionUrl, {
         body: this.genVaultRevCookingResponse('new')
       }).as('checkVaultCookingTask');
 
       cy.get('#vault-recook-object-modal > .modal-dialog')
         .should('be.visible')
         .contains('button:visible', 'Ok')
         .click();
 
       cy.wait('@checkVaultCookingTask')
         .then(() => {
           testStatus(this.revision, progressbarColors['new'], 'new', 'new');
         });
     });
   });
 
   it('should remove selected vault items', function() {
 
     updateVaultItemList(this.vaultItems);
 
     cy.visit(this.Urls.browse_vault())
       .get(`#vault-task-${CSS.escape(this.revision)}`)
       .find('input[type="checkbox"]')
       .click({force: true});
     cy.contains('button', 'Remove selected tasks')
       .click();
 
     cy.get(`#vault-task-${CSS.escape(this.revision)}`)
       .should('not.exist');
   });
 
   it('should offer to immediately download a directory tarball if already cooked', function() {
 
     // Browse a directory
     cy.visit(this.directoryUrl);
 
     // Stub response to the vault API to simulate archive download
     cy.intercept({url: this.vaultFetchDirectoryUrl}, {
-      fixture: `${this.directory}.tar.gz`,
+      fixture: `${this.directory.replace(/:/g, '_')}.tar.gz`,
       headers: {
-        'Content-disposition': `attachment; filename=${this.directory}.tar.gz`,
+        'Content-disposition': `attachment; filename=${this.directory.replace(/:/g, '_')}.tar.gz`,
         'Content-Type': 'application/gzip'
       }
     }).as('fetchCookedArchive');
 
     // Stub responses when requesting the vault API to simulate
     // the directory tarball has already been cooked
     cy.intercept(this.vaultDirectoryUrl, {
       body: this.genVaultDirCookingResponse('done')
     }).as('checkVaultCookingTask');
 
     // Create a vault cooking task through the GUI
     cy.contains('button', 'Download')
       .click();
 
     // Start archive download through the GUI
     cy.get('.modal-dialog')
       .contains('button:visible', 'Ok')
       .click();
 
     cy.wait('@fetchCookedArchive');
 
   });
 
   it('should offer to immediately download a bare revision git archive if already cooked', function() {
     cy.adminLogin();
     // Browse a directory
     cy.visit(this.revisionUrl);
 
     // Stub response to the vault API to simulate archive download
     cy.intercept({url: this.vaultFetchRevisionUrl}, {
-      fixture: `${this.revision}.git.tar`,
+      fixture: `${this.revision.replace(/:/g, '_')}.git.tar`,
       headers: {
-        'Content-disposition': `attachment; filename=${this.revision}.git.tar`,
+        'Content-disposition': `attachment; filename=${this.revision.replace(/:/g, '_')}.git.tar`,
         'Content-Type': 'application/gzip'
       }
     }).as('fetchCookedArchive');
 
     // Stub responses when requesting the vault API to simulate
     // the directory tarball has already been cooked
     cy.intercept(this.vaultRevisionUrl, {
       body: this.genVaultRevCookingResponse('done')
     }).as('checkVaultCookingTask');
 
     checkVaultCookingTask('as git');
 
     // Start archive download through the GUI
     cy.get('.modal-dialog')
       .contains('button:visible', 'Ok')
       .click();
 
     cy.wait('@fetchCookedArchive');
 
   });
 
   it('should offer to recook an object if previous vault task failed', function() {
 
     cy.visit(this.directoryUrl);
 
     // Stub responses when requesting the vault API to simulate
     // the last cooking of the directory tarball has failed
     cy.intercept(this.vaultDirectoryUrl, {
       body: this.genVaultDirCookingResponse('failed')
     }).as('checkVaultCookingTask');
 
     cy.contains('button', 'Download')
       .click();
 
     // Check that recooking the directory is offered to user
     cy.get('.modal-dialog')
       .contains('button:visible', 'Ok')
       .should('be.visible');
   });
 
 });
diff --git a/swh/web/api/views/vault.py b/swh/web/api/views/vault.py
index 052d9c17..d5e78564 100644
--- a/swh/web/api/views/vault.py
+++ b/swh/web/api/views/vault.py
@@ -1,490 +1,496 @@
 # Copyright (C) 2015-2021  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU Affero General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 from typing import Any, Dict
 
 from django.http import HttpResponse
 from django.shortcuts import redirect
 
 from swh.model.identifiers import CoreSWHID, ObjectType
 from swh.web.api.apidoc import api_doc, format_docstring
 from swh.web.api.apiurls import api_route
 from swh.web.api.views.utils import api_lookup
 from swh.web.common import archive, query
 from swh.web.common.exc import BadInputExc
 from swh.web.common.utils import reverse
 
 ######################################################
 # Common
 
 SWHID_RE = "swh:1:[a-z]{3}:[0-9a-z]{40}"
 
 
 # XXX: a bit spaghetti. Would be better with class-based views.
 def _dispatch_cook_progress(request, bundle_type: str, swhid: CoreSWHID):
     if request.method == "GET":
         return api_lookup(
             archive.vault_progress,
             bundle_type,
             swhid,
             notfound_msg=f"Cooking of {swhid} was never requested.",
             request=request,
         )
     elif request.method == "POST":
         email = request.POST.get("email", request.GET.get("email", None))
         return api_lookup(
             archive.vault_cook,
             bundle_type,
             swhid,
             email,
             notfound_msg=f"{swhid} not found.",
             request=request,
         )
 
 
 def _vault_response(vault_response: Dict[str, Any]) -> Dict[str, Any]:
     return {
         "fetch_url": vault_response["fetch_url"],
         "progress_message": vault_response["progress_msg"],
         "id": vault_response["task_id"],
         "status": vault_response["task_status"],
         "swhid": str(vault_response["swhid"]),
     }
 
 
 ######################################################
 # Flat bundles
 
 
 @api_route(
     f"/vault/flat/(?P<swhid>{SWHID_RE})/",
     "api-1-vault-cook-flat",
     methods=["GET", "POST"],
     throttle_scope="swh_vault_cooking",
     never_cache=True,
 )
 @api_doc("/vault/flat/")
 @format_docstring()
 def api_vault_cook_flat(request, swhid):
     """
     .. http:get:: /api/1/vault/flat/(swhid)/
     .. http:post:: /api/1/vault/flat/(swhid)/
 
         Request the cooking of a simple archive, typically for a directory.
 
         That endpoint enables to create a vault cooking task for a directory
         through a POST request or check the status of a previously created one
         through a GET request.
 
         Once the cooking task has been executed, the resulting archive can
         be downloaded using the dedicated endpoint
         :http:get:`/api/1/vault/flat/(swhid)/raw/`.
 
         Then to extract the cooked directory in the current one, use::
 
-            $ tar xvf path/to/swh:1:*.tar.gz
+            $ tar xvf path/to/swh_1_*.tar.gz
 
         :param string swhid: the object's SWHID
 
         :query string email: e-mail to notify when the archive is ready
 
         {common_headers}
 
         :>json string fetch_url: the url from which to download the archive
             once it has been cooked
             (see :http:get:`/api/1/vault/flat/(swhid)/raw/`)
         :>json string progress_message: message describing the cooking task
             progress
         :>json number id: the cooking task id
         :>json string status: the cooking task status
             (either **new**, **pending**, **done** or **failed**)
         :>json string swhid: the identifier of the object to cook
 
         :statuscode 200: no error
         :statuscode 400: an invalid directory identifier has been provided
         :statuscode 404: requested directory did not receive any cooking
             request yet (in case of GET) or can not be found in the archive
             (in case of POST)
     """
     swhid = CoreSWHID.from_string(swhid)
     if swhid.object_type == ObjectType.DIRECTORY:
         res = _dispatch_cook_progress(request, "flat", swhid)
         res["fetch_url"] = reverse(
             "api-1-vault-fetch-flat", url_args={"swhid": str(swhid)}, request=request,
         )
         return _vault_response(res)
     elif swhid.object_type == ObjectType.CONTENT:
         raise BadInputExc(
             "Content objects do not need to be cooked, "
             "use `/api/1/content/raw/` instead."
         )
     elif swhid.object_type == ObjectType.REVISION:
         # TODO: support revisions too? (the vault allows it)
         raise BadInputExc(
             "Only directories can be cooked as 'flat' bundles. "
             "Use `/api/1/vault/gitfast/` to cook revisions, as gitfast bundles."
         )
     else:
         raise BadInputExc("Only directories can be cooked as 'flat' bundles.")
 
 
 @api_route(
     r"/vault/directory/(?P<dir_id>[0-9a-f]+)/",
     "api-1-vault-cook-directory",
     methods=["GET", "POST"],
     checksum_args=["dir_id"],
     throttle_scope="swh_vault_cooking",
     never_cache=True,
 )
 @api_doc("/vault/directory/", tags=["deprecated"])
 @format_docstring()
 def api_vault_cook_directory(request, dir_id):
     """
     .. http:get:: /api/1/vault/directory/(dir_id)/
 
         This endpoint was replaced by :http:get:`/api/1/vault/flat/(swhid)/`
     """
     _, obj_id = query.parse_hash_with_algorithms_or_throws(
         dir_id, ["sha1"], "Only sha1_git is supported."
     )
 
     swhid = f"swh:1:dir:{obj_id.hex()}"
     res = _dispatch_cook_progress(request, "flat", CoreSWHID.from_string(swhid))
     res["fetch_url"] = reverse(
         "api-1-vault-fetch-flat", url_args={"swhid": swhid}, request=request,
     )
     return _vault_response(res)
 
 
 @api_route(
     f"/vault/flat/(?P<swhid>{SWHID_RE})/raw/", "api-1-vault-fetch-flat",
 )
 @api_doc("/vault/flat/raw/")
 def api_vault_fetch_flat(request, swhid):
     """
     .. http:get:: /api/1/vault/flat/(swhid)/raw/
 
         Fetch the cooked archive for a flat bundle.
 
         See :http:get:`/api/1/vault/flat/(swhid)/` to get more
         details on 'flat' bundle cooking.
 
         :param string swhid: the SWHID of the object to cook
 
         :resheader Content-Type: application/octet-stream
 
         :statuscode 200: no error
         :statuscode 404: requested directory did not receive any cooking
             request yet (in case of GET) or can not be found in the archive
             (in case of POST)
     """
     res = api_lookup(
         archive.vault_fetch,
         "flat",
         CoreSWHID.from_string(swhid),
         notfound_msg=f"Cooked archive for {swhid} not found.",
         request=request,
     )
     fname = "{}.tar.gz".format(swhid)
     response = HttpResponse(res, content_type="application/gzip")
-    response["Content-disposition"] = "attachment; filename={}".format(fname)
+    response["Content-disposition"] = "attachment; filename={}".format(
+        fname.replace(":", "_")
+    )
     return response
 
 
 @api_route(
     r"/vault/directory/(?P<dir_id>[0-9a-f]+)/raw/",
     "api-1-vault-fetch-directory",
     checksum_args=["dir_id"],
 )
 @api_doc("/vault/directory/raw/", tags=["hidden", "deprecated"])
 def api_vault_fetch_directory(request, dir_id):
     """
     .. http:get:: /api/1/vault/directory/(dir_id)/raw/
 
         This endpoint was replaced by :http:get:`/api/1/vault/flat/raw/`
     """
     _, obj_id = query.parse_hash_with_algorithms_or_throws(
         dir_id, ["sha1"], "Only sha1_git is supported."
     )
     rev_flat_raw_url = reverse(
         "api-1-vault-fetch-flat", url_args={"swhid": f"swh:1:dir:{dir_id}"}
     )
     return redirect(rev_flat_raw_url)
 
 
 ######################################################
 # gitfast bundles
 
 
 @api_route(
     f"/vault/gitfast/(?P<swhid>{SWHID_RE})/",
     "api-1-vault-cook-gitfast",
     methods=["GET", "POST"],
     throttle_scope="swh_vault_cooking",
     never_cache=True,
 )
 @api_doc("/vault/gitfast/")
 @format_docstring()
 def api_vault_cook_gitfast(request, swhid):
     """
     .. http:get:: /api/1/vault/gitfast/(swhid)/
     .. http:post:: /api/1/vault/gitfast/(swhid)/
 
         Request the cooking of a gitfast archive for a revision or check
         its cooking status.
 
         That endpoint enables to create a vault cooking task for a revision
         through a POST request or check the status of a previously created one
         through a GET request.
 
         Once the cooking task has been executed, the resulting gitfast archive
         can be downloaded using the dedicated endpoint
         :http:get:`/api/1/vault/gitfast/(swhid)/raw/`.
 
         Then to import the revision in the current directory, use::
 
             $ git init
-            $ zcat path/to/swh:1:rev:*.gitfast.gz | git fast-import
+            $ zcat path/to/swh_1_rev_*.gitfast.gz | git fast-import
             $ git checkout HEAD
 
         :param string swhid: the revision's permanent identifiers
 
         :query string email: e-mail to notify when the gitfast archive is ready
 
         {common_headers}
 
         :>json string fetch_url: the url from which to download the archive
             once it has been cooked
             (see :http:get:`/api/1/vault/gitfast/(swhid)/raw/`)
         :>json string progress_message: message describing the cooking task
             progress
         :>json number id: the cooking task id
         :>json string status: the cooking task status (new/pending/done/failed)
         :>json string swhid: the identifier of the object to cook
 
         :statuscode 200: no error
         :statuscode 404: requested directory did not receive any cooking
             request yet (in case of GET) or can not be found in the archive
             (in case of POST)
     """
     swhid = CoreSWHID.from_string(swhid)
     if swhid.object_type == ObjectType.REVISION:
         res = _dispatch_cook_progress(request, "gitfast", swhid)
         res["fetch_url"] = reverse(
             "api-1-vault-fetch-gitfast",
             url_args={"swhid": str(swhid)},
             request=request,
         )
         return _vault_response(res)
     elif swhid.object_type == ObjectType.CONTENT:
         raise BadInputExc(
             "Content objects do not need to be cooked, "
             "use `/api/1/content/raw/` instead."
         )
     elif swhid.object_type == ObjectType.DIRECTORY:
         raise BadInputExc(
             "Only revisions can be cooked as 'gitfast' bundles. "
             "Use `/api/1/vault/flat/` to cook directories, as flat bundles."
         )
     else:
         raise BadInputExc("Only revisions can be cooked as 'gitfast' bundles.")
 
 
 @api_route(
     r"/vault/revision/(?P<rev_id>[0-9a-f]+)/gitfast/",
     "api-1-vault-cook-revision_gitfast",
     methods=["GET", "POST"],
     checksum_args=["rev_id"],
     throttle_scope="swh_vault_cooking",
     never_cache=True,
 )
 @api_doc("/vault/revision/gitfast/", tags=["deprecated"])
 @format_docstring()
 def api_vault_cook_revision_gitfast(request, rev_id):
     """
     .. http:get:: /api/1/vault/revision/(rev_id)/gitfast/
 
         This endpoint was replaced by :http:get:`/api/1/vault/gitfast/`
     """
     _, obj_id = query.parse_hash_with_algorithms_or_throws(
         rev_id, ["sha1"], "Only sha1_git is supported."
     )
 
     swhid = f"swh:1:rev:{obj_id.hex()}"
     res = _dispatch_cook_progress(request, "gitfast", CoreSWHID.from_string(swhid))
     res["fetch_url"] = reverse(
         "api-1-vault-fetch-gitfast", url_args={"swhid": swhid}, request=request,
     )
     return _vault_response(res)
 
 
 @api_route(
     f"/vault/gitfast/(?P<swhid>{SWHID_RE})/raw/", "api-1-vault-fetch-gitfast",
 )
 @api_doc("/vault/gitfast/raw/")
 def api_vault_fetch_revision_gitfast(request, swhid):
     """
     .. http:get:: /api/1/vault/gitfast/(swhid)/raw/
 
         Fetch the cooked gitfast archive for a revision.
 
         See :http:get:`/api/1/vault/gitfast/(swhid)/` to get more
         details on gitfast cooking.
 
         :param string rev_id: the revision's sha1 identifier
 
         :resheader Content-Type: application/octet-stream
 
         :statuscode 200: no error
         :statuscode 404: requested directory did not receive any cooking
             request yet (in case of GET) or can not be found in the archive
             (in case of POST)
     """
     res = api_lookup(
         archive.vault_fetch,
         "gitfast",
         CoreSWHID.from_string(swhid),
         notfound_msg="Cooked archive for {} not found.".format(swhid),
         request=request,
     )
     fname = "{}.gitfast.gz".format(swhid)
     response = HttpResponse(res, content_type="application/gzip")
-    response["Content-disposition"] = "attachment; filename={}".format(fname)
+    response["Content-disposition"] = "attachment; filename={}".format(
+        fname.replace(":", "_")
+    )
     return response
 
 
 @api_route(
     r"/vault/revision/(?P<rev_id>[0-9a-f]+)/gitfast/raw/",
     "api-1-vault-fetch-revision_gitfast",
     checksum_args=["rev_id"],
 )
 @api_doc("/vault/revision_gitfast/raw/", tags=["hidden", "deprecated"])
 def _api_vault_revision_gitfast_raw(request, rev_id):
     """
     .. http:get:: /api/1/vault/revision/(rev_id)/gitfast/raw/
 
         This endpoint was replaced by :http:get:`/api/1/vault/gitfast/raw/`
     """
     rev_gitfast_raw_url = reverse(
         "api-1-vault-fetch-gitfast", url_args={"swhid": f"swh:1:rev:{rev_id}"}
     )
     return redirect(rev_gitfast_raw_url)
 
 
 ######################################################
 # git_bare bundles
 
 
 @api_route(
     f"/vault/git-bare/(?P<swhid>{SWHID_RE})/",
     "api-1-vault-cook-git-bare",
     methods=["GET", "POST"],
     throttle_scope="swh_vault_cooking",
     never_cache=True,
 )
 @api_doc("/vault/git-bare/")
 @format_docstring()
 def api_vault_cook_git_bare(request, swhid):
     """
     .. http:get:: /api/1/vault/git-bare/(swhid)/
     .. http:post:: /api/1/vault/git-bare/(swhid)/
 
         Request the cooking of a git-bare archive for a revision or check
         its cooking status.
 
         That endpoint enables to create a vault cooking task for a revision
         through a POST request or check the status of a previously created one
         through a GET request.
 
         Once the cooking task has been executed, the resulting git-bare archive
         can be downloaded using the dedicated endpoint
         :http:get:`/api/1/vault/git-bare/(swhid)/raw/`.
 
         Then to import the revision in the current directory, use::
 
-            $ tar -xf path/to/swh:1:rev:*.git.tar
+            $ tar -xf path/to/swh_1_rev_*.git.tar
             $ git clone swh:1:rev:*.git new_repository
 
         (replace ``swh:1:rev:*`` with the SWHID of the requested revision)
 
         This will create a directory called ``new_repository``, which is a git
         repository containing the requested objects.
 
         :param string swhid: the revision's permanent identifier
 
         :query string email: e-mail to notify when the git-bare archive is ready
 
         {common_headers}
 
         :>json string fetch_url: the url from which to download the archive
             once it has been cooked
             (see :http:get:`/api/1/vault/git-bare/(swhid)/raw/`)
         :>json string progress_message: message describing the cooking task
             progress
         :>json number id: the cooking task id
         :>json string status: the cooking task status (new/pending/done/failed)
         :>json string swhid: the identifier of the object to cook
 
         :statuscode 200: no error
         :statuscode 404: requested directory did not receive any cooking
             request yet (in case of GET) or can not be found in the archive
             (in case of POST)
     """
     swhid = CoreSWHID.from_string(swhid)
     if swhid.object_type == ObjectType.REVISION:
         res = _dispatch_cook_progress(request, "git_bare", swhid)
         res["fetch_url"] = reverse(
             "api-1-vault-fetch-git-bare",
             url_args={"swhid": str(swhid)},
             request=request,
         )
         return _vault_response(res)
     elif swhid.object_type == ObjectType.CONTENT:
         raise BadInputExc(
             "Content objects do not need to be cooked, "
             "use `/api/1/content/raw/` instead."
         )
     elif swhid.object_type == ObjectType.DIRECTORY:
         raise BadInputExc(
             "Only revisions can be cooked as 'git-bare' bundles. "
             "Use `/api/1/vault/flat/` to cook directories, as flat bundles."
         )
     else:
         raise BadInputExc("Only revisions can be cooked as 'git-bare' bundles.")
 
 
 @api_route(
     f"/vault/git-bare/(?P<swhid>{SWHID_RE})/raw/", "api-1-vault-fetch-git-bare",
 )
 @api_doc("/vault/git-bare/raw/")
 def api_vault_fetch_revision_git_bare(request, swhid):
     """
     .. http:get:: /api/1/vault/git-bare/(swhid)/raw/
 
         Fetch the cooked git-bare archive for a revision.
 
         See :http:get:`/api/1/vault/git-bare/(swhid)/` to get more
         details on git-bare cooking.
 
         :param string swhid: the revision's permanent identifier
 
         :resheader Content-Type: application/octet-stream
 
         :statuscode 200: no error
         :statuscode 404: requested directory did not receive any cooking
             request yet (in case of GET) or can not be found in the archive
             (in case of POST)
     """
     res = api_lookup(
         archive.vault_fetch,
         "git_bare",
         CoreSWHID.from_string(swhid),
         notfound_msg="Cooked archive for {} not found.".format(swhid),
         request=request,
     )
     fname = "{}.git.tar".format(swhid)
     response = HttpResponse(res, content_type="application/gzip")
-    response["Content-disposition"] = "attachment; filename={}".format(fname)
+    response["Content-disposition"] = "attachment; filename={}".format(
+        fname.replace(":", "_")
+    )
     return response