repo-forks: security, fix issue when forging fork_repo_id could allow reading

other people forks.

rhodecode/apps/admin/views/repositories.py

@@ -1,181 +1,182 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2017 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import logging
 import formencode
 import formencode.htmlfill
 
 from pyramid.httpexceptions import HTTPFound, HTTPForbidden
 from pyramid.view import view_config
 from pyramid.renderers import render
 from pyramid.response import Response
 
 from rhodecode.apps._base import BaseAppView, DataGridAppView
 
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.auth import (
     LoginRequired, CSRFRequired, NotAnonymous,
     HasPermissionAny, HasRepoGroupPermissionAny)
 from rhodecode.lib import helpers as h
 from rhodecode.lib.utils import repo_name_slug
 from rhodecode.lib.utils2 import safe_int, safe_unicode
 from rhodecode.model.forms import RepoForm
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.scm import RepoList, RepoGroupList, ScmModel
 from rhodecode.model.settings import SettingsModel
 from rhodecode.model.db import Repository, RepoGroup
 
 log = logging.getLogger(__name__)
 
 
 class AdminReposView(BaseAppView, DataGridAppView):
 
     def load_default_context(self):
         c = self._get_local_tmpl_context()
         self._register_global_c(c)
         return c
 
     def _load_form_data(self, c):
         acl_groups = RepoGroupList(RepoGroup.query().all(),
                                    perm_set=['group.write', 'group.admin'])
         c.repo_groups = RepoGroup.groups_choices(groups=acl_groups)
         c.repo_groups_choices = map(lambda k: safe_unicode(k[0]), c.repo_groups)
         c.landing_revs_choices, c.landing_revs = \
             ScmModel().get_repo_landing_revs()
         c.personal_repo_group = self._rhodecode_user.personal_repo_group
 
     @LoginRequired()
     @NotAnonymous()
+    # perms check inside
     @view_config(
         route_name='repos', request_method='GET',
         renderer='rhodecode:templates/admin/repos/repos.mako')
     def repository_list(self):
         c = self.load_default_context()
 
         repo_list = Repository.get_all_repos()
         c.repo_list = RepoList(repo_list, perm_set=['repository.admin'])
         repos_data = RepoModel().get_repos_as_dict(
             repo_list=c.repo_list, admin=True, super_user_actions=True)
         # json used to render the grid
         c.data = json.dumps(repos_data)
 
         return self._get_template_context(c)
 
     @LoginRequired()
     @NotAnonymous()
     # perms check inside
     @view_config(
         route_name='repo_new', request_method='GET',
         renderer='rhodecode:templates/admin/repos/repo_add.mako')
     def repository_new(self):
         c = self.load_default_context()
 
         new_repo = self.request.GET.get('repo', '')
         parent_group = safe_int(self.request.GET.get('parent_group'))
         _gr = RepoGroup.get(parent_group)
 
         if not HasPermissionAny('hg.admin', 'hg.create.repository')():
             # you're not super admin nor have global create permissions,
             # but maybe you have at least write permission to a parent group ?
 
             gr_name = _gr.group_name if _gr else None
             # create repositories with write permission on group is set to true
             create_on_write = HasPermissionAny('hg.create.write_on_repogroup.true')()
             group_admin = HasRepoGroupPermissionAny('group.admin')(group_name=gr_name)
             group_write = HasRepoGroupPermissionAny('group.write')(group_name=gr_name)
             if not (group_admin or (group_write and create_on_write)):
                 raise HTTPForbidden()
 
         self._load_form_data(c)
         c.new_repo = repo_name_slug(new_repo)
 
         # apply the defaults from defaults page
         defaults = SettingsModel().get_default_repo_settings(strip_prefix=True)
         # set checkbox to autochecked
         defaults['repo_copy_permissions'] = True
 
         parent_group_choice = '-1'
         if not self._rhodecode_user.is_admin and self._rhodecode_user.personal_repo_group:
             parent_group_choice = self._rhodecode_user.personal_repo_group
 
         if parent_group and _gr:
             if parent_group in [x[0] for x in c.repo_groups]:
                 parent_group_choice = safe_unicode(parent_group)
 
         defaults.update({'repo_group': parent_group_choice})
 
         data = render('rhodecode:templates/admin/repos/repo_add.mako',
                       self._get_template_context(c), self.request)
         html = formencode.htmlfill.render(
             data,
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False
         )
         return Response(html)
 
     @LoginRequired()
     @NotAnonymous()
     @CSRFRequired()
     # perms check inside
     @view_config(
         route_name='repo_create', request_method='POST',
         renderer='rhodecode:templates/admin/repos/repos.mako')
     def repository_create(self):
         c = self.load_default_context()
 
         form_result = {}
         task_id = None
         self._load_form_data(c)
 
         try:
             # CanWriteToGroup validators checks permissions of this POST
             form_result = RepoForm(repo_groups=c.repo_groups_choices,
                                    landing_revs=c.landing_revs_choices)()\
                             .to_python(dict(self.request.POST))
 
             # create is done sometimes async on celery, db transaction
             # management is handled there.
             task = RepoModel().create(form_result, self._rhodecode_user.user_id)
             from celery.result import BaseAsyncResult
             if isinstance(task, BaseAsyncResult):
                 task_id = task.task_id
         except formencode.Invalid as errors:
             data = render('rhodecode:templates/admin/repos/repo_add.mako',
                           self._get_template_context(c), self.request)
             html = formencode.htmlfill.render(
                 data,
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8",
                 force_defaults=False
             )
             return Response(html)
 
         except Exception as e:
             msg = self._log_creation_exception(e, form_result.get('repo_name'))
             h.flash(msg, category='error')
             raise HTTPFound(h.route_path('home'))
 
         raise HTTPFound(
             h.route_path('repo_creating',
                          repo_name=form_result['repo_name_full'],
                          _query=dict(task_id=task_id)))

rhodecode/apps/repository/views/repo_forks.py

@@ -1,253 +1,258 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2011-2017 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import logging
 import datetime
 import formencode
 import formencode.htmlfill
 
 from pyramid.httpexceptions import HTTPFound
 from pyramid.view import view_config
 from pyramid.renderers import render
 from pyramid.response import Response
 
 from rhodecode.apps._base import RepoAppView, DataGridAppView
 from rhodecode.lib.auth import (
     LoginRequired, HasRepoPermissionAnyDecorator, NotAnonymous,
     HasRepoPermissionAny, HasPermissionAnyDecorator, CSRFRequired)
 import rhodecode.lib.helpers as h
 from rhodecode.model.db import coalesce, or_, Repository, RepoGroup
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.forms import RepoForkForm
 from rhodecode.model.scm import ScmModel, RepoGroupList
 from rhodecode.lib.utils2 import safe_int, safe_unicode
 
 log = logging.getLogger(__name__)
 
 
 class RepoForksView(RepoAppView, DataGridAppView):
 
     def load_default_context(self):
         c = self._get_local_tmpl_context(include_app_defaults=True)
         c.rhodecode_repo = self.rhodecode_vcs_repo
 
         acl_groups = RepoGroupList(
             RepoGroup.query().all(),
             perm_set=['group.write', 'group.admin'])
         c.repo_groups = RepoGroup.groups_choices(groups=acl_groups)
         c.repo_groups_choices = map(lambda k: safe_unicode(k[0]), c.repo_groups)
         choices, c.landing_revs = ScmModel().get_repo_landing_revs()
         c.landing_revs_choices = choices
         c.personal_repo_group = c.rhodecode_user.personal_repo_group
 
         self._register_global_c(c)
         return c
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_forks_show_all', request_method='GET',
         renderer='rhodecode:templates/forks/forks.mako')
     def repo_forks_show_all(self):
         c = self.load_default_context()
         return self._get_template_context(c)
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_forks_data', request_method='GET',
         renderer='json_ext', xhr=True)
     def repo_forks_data(self):
         _ = self.request.translate
         column_map = {
             'fork_name': 'repo_name',
             'fork_date': 'created_on',
             'last_activity': 'updated_on'
         }
         draw, start, limit = self._extract_chunk(self.request)
         search_q, order_by, order_dir = self._extract_ordering(
             self.request, column_map=column_map)
 
         acl_check = HasRepoPermissionAny(
             'repository.read', 'repository.write', 'repository.admin')
         repo_id = self.db_repo.repo_id
         allowed_ids = []
         for f in Repository.query().filter(Repository.fork_id == repo_id):
             if acl_check(f.repo_name, 'get forks check'):
                 allowed_ids.append(f.repo_id)
 
         forks_data_total_count = Repository.query()\
             .filter(Repository.fork_id == repo_id)\
             .filter(Repository.repo_id.in_(allowed_ids))\
             .count()
 
         # json generate
         base_q = Repository.query()\
             .filter(Repository.fork_id == repo_id)\
             .filter(Repository.repo_id.in_(allowed_ids))\
 
         if search_q:
             like_expression = u'%{}%'.format(safe_unicode(search_q))
             base_q = base_q.filter(or_(
                 Repository.repo_name.ilike(like_expression),
                 Repository.description.ilike(like_expression),
             ))
 
         forks_data_total_filtered_count = base_q.count()
 
         sort_col = getattr(Repository, order_by, None)
         if sort_col:
             if order_dir == 'asc':
                 # handle null values properly to order by NULL last
                 if order_by in ['last_activity']:
                     sort_col = coalesce(sort_col, datetime.date.max)
                 sort_col = sort_col.asc()
             else:
                 # handle null values properly to order by NULL last
                 if order_by in ['last_activity']:
                     sort_col = coalesce(sort_col, datetime.date.min)
                 sort_col = sort_col.desc()
 
         base_q = base_q.order_by(sort_col)
         base_q = base_q.offset(start).limit(limit)
 
         fork_list = base_q.all()
 
         def fork_actions(fork):
             url_link = h.route_path(
                 'repo_compare',
                 repo_name=fork.repo_name,
                 source_ref_type=self.db_repo.landing_rev[0],
                 source_ref=self.db_repo.landing_rev[1],
                 target_ref_type=self.db_repo.landing_rev[0],
                 target_ref=self.db_repo.landing_rev[1],
                 _query=dict(merge=1, target_repo=f.repo_name))
             return h.link_to(_('Compare fork'), url_link, class_='btn-link')
 
         def fork_name(fork):
             return h.link_to(fork.repo_name,
                       h.route_path('repo_summary', repo_name=fork.repo_name))
 
         forks_data = []
         for fork in fork_list:
             forks_data.append({
                 "username": h.gravatar_with_user(self.request, fork.user.username),
                 "fork_name": fork_name(fork),
                 "description": fork.description,
                 "fork_date": h.age_component(fork.created_on, time_is_local=True),
                 "last_activity": h.format_date(fork.updated_on),
                 "action": fork_actions(fork),
             })
 
         data = ({
             'draw': draw,
             'data': forks_data,
             'recordsTotal': forks_data_total_count,
             'recordsFiltered': forks_data_total_filtered_count,
         })
 
         return data
 
     @LoginRequired()
     @NotAnonymous()
     @HasPermissionAnyDecorator('hg.admin', 'hg.fork.repository')
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_fork_new', request_method='GET',
         renderer='rhodecode:templates/forks/forks.mako')
     def repo_fork_new(self):
         c = self.load_default_context()
 
         defaults = RepoModel()._get_defaults(self.db_repo_name)
         # alter the description to indicate a fork
         defaults['description'] = (
             'fork of repository: %s \n%s' % (
                 defaults['repo_name'], defaults['description']))
         # add suffix to fork
         defaults['repo_name'] = '%s-fork' % defaults['repo_name']
 
         data = render('rhodecode:templates/forks/fork.mako',
                       self._get_template_context(c), self.request)
         html = formencode.htmlfill.render(
             data,
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False
         )
         return Response(html)
 
     @LoginRequired()
     @NotAnonymous()
     @HasPermissionAnyDecorator('hg.admin', 'hg.fork.repository')
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @CSRFRequired()
     @view_config(
         route_name='repo_fork_create', request_method='POST',
         renderer='rhodecode:templates/forks/fork.mako')
     def repo_fork_create(self):
         _ = self.request.translate
         c = self.load_default_context()
 
         _form = RepoForkForm(old_data={'repo_type': self.db_repo.repo_type},
                              repo_groups=c.repo_groups_choices,
                              landing_revs=c.landing_revs_choices)()
+        post_data = dict(self.request.POST)
+
+        # forbid injecting other repo by forging a request
+        post_data['fork_parent_id'] = self.db_repo.repo_id
+
         form_result = {}
         task_id = None
         try:
-            form_result = _form.to_python(dict(self.request.POST))
+            form_result = _form.to_python(post_data)
             # create fork is done sometimes async on celery, db transaction
             # management is handled there.
             task = RepoModel().create_fork(
                 form_result, c.rhodecode_user.user_id)
             from celery.result import BaseAsyncResult
             if isinstance(task, BaseAsyncResult):
                 task_id = task.task_id
         except formencode.Invalid as errors:
             c.rhodecode_db_repo = self.db_repo
 
             data = render('rhodecode:templates/forks/fork.mako',
                           self._get_template_context(c), self.request)
             html = formencode.htmlfill.render(
                 data,
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8",
                 force_defaults=False
             )
             return Response(html)
         except Exception:
             log.exception(
                 u'Exception while trying to fork the repository %s',
                 self.db_repo_name)
             msg = (
                 _('An error occurred during repository forking %s') % (
                     self.db_repo_name, ))
             h.flash(msg, category='error')
 
         repo_name = form_result.get('repo_name_full', self.db_repo_name)
         raise HTTPFound(
             h.route_path('repo_creating',
                          repo_name=repo_name,
                          _query=dict(task_id=task_id)))