source.dussan.org Git - archiva.git/blob

   1 package org.codehaus.plexus.redback.struts2.action;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import org.codehaus.plexus.redback.policy.PasswordRuleViolationException;
  23 import org.codehaus.plexus.redback.rbac.Permission;
  24 import org.codehaus.plexus.redback.rbac.RBACManager;
  25 import org.codehaus.plexus.redback.rbac.RbacManagerException;
  26 import org.codehaus.plexus.redback.rbac.Resource;
  27 import org.codehaus.plexus.redback.rbac.Role;
  28 import org.codehaus.plexus.redback.system.SecuritySystem;
  29 import org.codehaus.plexus.redback.users.User;
  30 import org.codehaus.plexus.util.StringUtils;
  31 import org.codehaus.redback.integration.model.UserCredentials;
  32 import org.codehaus.redback.integration.role.RoleConstants;
  33 import org.codehaus.redback.integration.security.role.RedbackRoleConstants;
  34 import org.codehaus.redback.integration.util.RoleSorter;
  35
  36 import javax.inject.Inject;
  37 import javax.inject.Named;
  38 import javax.mail.internet.AddressException;
  39 import javax.mail.internet.InternetAddress;
  40 import java.util.ArrayList;
  41 import java.util.Collections;
  42 import java.util.List;
  43 import java.util.Map;
  44
  45 /**
  46  * AbstractUserCredentialsAction
  47  *
  48  * @author <a href="mailto:joakim@erdfelt.com">Joakim Erdfelt</a>
  49  * @version $Id$
  50  */
  51 public abstract class AbstractUserCredentialsAction
  52     extends AbstractSecurityAction
  53 {
  54     // ------------------------------------------------------------------
  55     //  Component Requirements
  56     // ------------------------------------------------------------------
  57
  58     /**
  59      *
  60      */
  61     @Inject
  62     @Named( value = "rBACManager#cached" )
  63     private RBACManager manager;
  64
  65     /**
  66      *
  67      */
  68     @Inject
  69     protected SecuritySystem securitySystem;
  70
  71     // ------------------------------------------------------------------
  72     // Action Parameters
  73     // ------------------------------------------------------------------
  74
  75     protected UserCredentials internalUser;
  76
  77     protected final String VALID_USERNAME_CHARS = "[a-zA-Z_0-9\\-.@]*";
  78
  79     public RBACManager getManager()
  80     {
  81         return manager;
  82     }
  83
  84     public void setManager( RBACManager manager )
  85     {
  86         this.manager = manager;
  87     }
  88
  89     public SecuritySystem getSecuritySystem()
  90     {
  91         return securitySystem;
  92     }
  93
  94     public void setSecuritySystem( SecuritySystem securitySystem )
  95     {
  96         this.securitySystem = securitySystem;
  97     }
  98
  99     // ------------------------------------------------------------------
 100     // Action Entry Points - (aka Names)
 101     // ------------------------------------------------------------------
 102
 103     public void validateCredentialsLoose()
 104     {
 105         if ( StringUtils.isEmpty( internalUser.getUsername() ) )
 106         {
 107             addFieldError( "user.username", getText( "username.required" ) );
 108         }
 109         else
 110         {
 111             if ( !internalUser.getUsername().matches( VALID_USERNAME_CHARS ) )
 112             {
 113                 addFieldError( "user.username", getText( "username.invalid.characters" ) );
 114             }
 115         }
 116
 117         if ( StringUtils.isEmpty( internalUser.getFullName() ) )
 118         {
 119             addFieldError( "user.fullName", getText( "fullName.required" ) );
 120         }
 121
 122         if ( StringUtils.isEmpty( internalUser.getEmail() ) )
 123         {
 124             addFieldError( "user.email", getText( "email.required" ) );
 125         }
 126
 127         if ( !StringUtils.equals( internalUser.getPassword(), internalUser.getConfirmPassword() ) )
 128         {
 129             addFieldError( "user.confirmPassword", getText( "passwords.does.not.match" ) );
 130         }
 131
 132         try
 133         {
 134             if ( !StringUtils.isEmpty( internalUser.getEmail() ) )
 135             {
 136                 new InternetAddress( internalUser.getEmail(), true );
 137             }
 138         }
 139         catch ( AddressException e )
 140         {
 141             addFieldError( "user.email", getText( "email.invalid" ) );
 142         }
 143     }
 144
 145     public void validateCredentialsStrict()
 146     {
 147         validateCredentialsLoose();
 148
 149         User tmpuser = internalUser.createUser( securitySystem.getUserManager() );
 150
 151         try
 152         {
 153             securitySystem.getPolicy().validatePassword( tmpuser );
 154         }
 155         catch ( PasswordRuleViolationException e )
 156         {
 157             processPasswordRuleViolations( e );
 158         }
 159
 160         if ( ( StringUtils.isEmpty( internalUser.getPassword() ) ) )
 161         {
 162             addFieldError( "user.password", getText( "password.required" ) );
 163         }
 164     }
 165
 166     /**
 167      * this is a hack. this is a hack around the requirements of putting RBAC constraints into the model. this adds one
 168      * very major restriction to this security system, that a role name must contain the identifiers of the resource
 169      * that is being constrained for adding and granting of roles, this is unacceptable in the long term and we need to
 170      * get the model refactored to include this RBAC concept
 171      *
 172      * @param roleList
 173      * @return
 174      * @throws org.codehaus.plexus.redback.rbac.RbacManagerException
 175      *
 176      */
 177     protected List<Role> filterRolesForCurrentUserAccess( List<Role> roleList )
 178         throws RbacManagerException
 179     {
 180         String currentUser = getCurrentUser();
 181
 182         List<Role> filteredRoleList = new ArrayList<Role>();
 183
 184         Map<String, List<Permission>> assignedPermissionMap = manager.getAssignedPermissionMap( currentUser );
 185         List<String> resourceGrants = new ArrayList<String>();
 186
 187         if ( assignedPermissionMap.containsKey( RedbackRoleConstants.USER_MANAGEMENT_ROLE_GRANT_OPERATION ) )
 188         {
 189             List<Permission> roleGrantPermissions =
 190                 assignedPermissionMap.get( RedbackRoleConstants.USER_MANAGEMENT_ROLE_GRANT_OPERATION );
 191
 192             for ( Permission permission : roleGrantPermissions )
 193             {
 194                 if ( permission.getResource().getIdentifier().equals( Resource.GLOBAL ) )
 195                 {
 196                     // the current user has the rights to assign any given role
 197                     return roleList;
 198                 }
 199                 else
 200                 {
 201                     resourceGrants.add( permission.getResource().getIdentifier() );
 202                 }
 203             }
 204         }
 205         else
 206         {
 207             return Collections.emptyList();
 208         }
 209
 210         String delimiter = " - ";
 211
 212         // we should have a list of resourceGrants now, this will provide us with the information necessary to restrict
 213         // the role list
 214         for ( Role role : roleList )
 215         {
 216             int delimiterIndex = role.getName().indexOf( delimiter );
 217             for ( String resourceIdentifier : resourceGrants )
 218             {
 219
 220                 if ( ( role.getName().indexOf( resourceIdentifier ) != -1 ) && ( delimiterIndex != -1 ) )
 221                 {
 222                     String resourceName = role.getName().substring( delimiterIndex + delimiter.length() );
 223                     if ( resourceName.equals( resourceIdentifier ) )
 224                     {
 225                         filteredRoleList.add( role );
 226                     }
 227                 }
 228             }
 229         }
 230
 231         Collections.sort( filteredRoleList, new RoleSorter() );
 232         return filteredRoleList;
 233     }
 234
 235     protected List<Role> getFilteredRolesForCurrentUserAccess()
 236         throws RbacManagerException
 237     {
 238         List<Role> roles = manager.getAllRoles();
 239
 240         if ( roles == null )
 241         {
 242             return Collections.emptyList();
 243         }
 244
 245         return filterRolesForCurrentUserAccess( roles );
 246     }
 247 }