opendaylight/appauth/src/main/java/org/opendaylight/controller/appauth/authorization/Authorization.java

   1
   2 /*
   3  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   4  *
   5  * This program and the accompanying materials are made available under the
   6  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   7  * and is available at http://www.eclipse.org/legal/epl-v10.html
   8  */
   9
  10 package org.opendaylight.controller.appauth.authorization;
  11
  12 import java.util.ArrayList;
  13 import java.util.HashSet;
  14 import java.util.List;
  15 import java.util.Map.Entry;
  16 import java.util.Set;
  17 import java.util.concurrent.ConcurrentMap;
  18
  19 import org.opendaylight.controller.sal.authorization.AppRoleLevel;
  20 import org.opendaylight.controller.sal.authorization.IResourceAuthorization;
  21 import org.opendaylight.controller.sal.authorization.Privilege;
  22 import org.opendaylight.controller.sal.authorization.Resource;
  23 import org.opendaylight.controller.sal.authorization.ResourceGroup;
  24 import org.opendaylight.controller.sal.authorization.UserLevel;
  25 import org.opendaylight.controller.sal.utils.ServiceHelper;
  26 import org.opendaylight.controller.sal.utils.Status;
  27 import org.opendaylight.controller.sal.utils.StatusCode;
  28 import org.opendaylight.controller.usermanager.IUserManager;
  29
  30 import org.slf4j.Logger;
  31 import org.slf4j.LoggerFactory;
  32
  33 /**
  34  * This abstract class implements the methods defined by IResourceAuthorization
  35  * interface for each application class.
  36  */
  37 public abstract class Authorization<T> implements IResourceAuthorization {
  38 private static final Logger logger = LoggerFactory.getLogger(Authorization.class);
  39     private static final String namesRegex = "^[a-zA-Z0-9]+[{\\.|\\_|\\-}[a-zA-Z0-9]]*$";
  40     /*
  41      * The configured resource groups
  42      */
  43     protected ConcurrentMap<String, Set<T>> resourceGroups;
  44     /*
  45      * The configured roles along with their level
  46      */
  47     protected ConcurrentMap<String, AppRoleLevel> roles;
  48     /*
  49      * The association of groups to roles
  50      */
  51     protected ConcurrentMap<String, Set<ResourceGroup>> groupsAuthorizations;
  52     /*
  53      * The name of the default group. It is the group which contains all the
  54      * resources
  55      */
  56     protected String allResourcesGroupName;
  57
  58     @Override
  59     public Status createRole(String role, AppRoleLevel level) {
  60         if (role == null || role.trim().isEmpty()
  61                 || !role.matches(Authorization.namesRegex)) {
  62             return new Status(StatusCode.BADREQUEST,
  63                     "Role name must start with alphanumeric, no special characters.");
  64         }
  65         if (isControllerRole(role)) {
  66             return new Status(StatusCode.NOTALLOWED,
  67                     "Controller roles cannot be explicitely "
  68                             + "created in App context");
  69         }
  70         if (isRoleInUse(role)) {
  71             return new Status(StatusCode.CONFLICT, "Role already in use");
  72         }
  73         if (roles.containsKey(role)) {
  74             if (roles.get(role).equals(level)) {
  75                 return new Status(StatusCode.SUCCESS, "Role is already present");
  76             } else {
  77                 return new Status(StatusCode.BADREQUEST,
  78                         "Role exists and has different level");
  79             }
  80         }
  81
  82         return createRoleInternal(role, level);
  83     }
  84
  85     protected Status createRoleInternal(String role, AppRoleLevel level) {
  86         roles.put(role, level);
  87         groupsAuthorizations.put(role, new HashSet<ResourceGroup>());
  88         return new Status(StatusCode.SUCCESS, null);
  89     }
  90
  91     @Override
  92     public Status removeRole(String role) {
  93         if (role == null || role.trim().isEmpty()) {
  94             return new Status(StatusCode.BADREQUEST, "Role name can't be empty");
  95         }
  96         if (isControllerRole(role)) {
  97             return new Status(StatusCode.NOTALLOWED,
  98                     "Controller roles cannot be removed");
  99         }
 100
 101         return removeRoleInternal(role);
 102     }
 103
 104     protected Status removeRoleInternal(String role) {
 105         groupsAuthorizations.remove(role);
 106         roles.remove(role);
 107         return new Status(StatusCode.SUCCESS, null);
 108     }
 109
 110     @Override
 111     public List<String> getRoles() {
 112         return new ArrayList<String>(groupsAuthorizations.keySet());
 113     }
 114
 115     @SuppressWarnings("unchecked")
 116     @Override
 117     public Status createResourceGroup(String groupName, List<Object> resources) {
 118         //verify group name not null/empty
 119         if (groupName == null || groupName.trim().isEmpty()
 120                 || !groupName.matches(Authorization.namesRegex)) {
 121             return new Status(StatusCode.BADREQUEST, "Group name must start with alphanumeric, no special characters");
 122         }
 123         //verify group name is not same as all-resources
 124         if (groupName.equals(this.allResourcesGroupName)) {
 125             return new Status(StatusCode.NOTALLOWED, "All resource group cannot be created");
 126         }
 127         //verify group name is unique
 128         if (resourceGroups.containsKey(groupName)) {
 129         return new Status(StatusCode.CONFLICT, "Group name already exists");
 130         }
 131
 132         //try adding resources, discard if not of type T
 133         Set<T> toBeAdded = new HashSet<T>();
 134         boolean allAdded = true;
 135         for (Object obj : resources) {
 136             try {
 137                 toBeAdded.add((T) obj);
 138             } catch (ClassCastException e) {
 139                 allAdded = false;
 140             }
 141         }
 142         /*if (toBeAdded.size() == 0){ // TODO andrekim - we should have the ability to create a group with no resources (so we can add and delete entries)
 143            return new Status(StatusCode.NOTACCEPTABLE, "Group not created. No valid resources specified");
 144         }*/
 145         resourceGroups.put(groupName, toBeAdded);
 146         return (allAdded ? new Status(StatusCode.SUCCESS, "All resources added succesfully") :
 147             new Status(StatusCode.SUCCESS, "One or more resources couldn't be added"));
 148     }
 149
 150     public Status addResourceToGroup(String groupName, T resource) {
 151         if (groupName == null || groupName.trim().isEmpty()) {
 152             return new Status(StatusCode.BADREQUEST, "Invalid group name");
 153         }
 154
 155         Set<T> group = resourceGroups.get(groupName);
 156         if (group != null && resource != null) {
 157             group.add(resource);
 158             return new Status(StatusCode.SUCCESS, "Resource added successfully");
 159         }
 160
 161         return new Status(StatusCode.NOTFOUND, "Group not found or incompatible resource");
 162     }
 163
 164     public Status removeRoleResourceGroupMapping(String groupName) {
 165         List<String> affectedRoles = new ArrayList<String>();
 166         Status result;
 167         for (Entry<String, Set<ResourceGroup>> pairs : groupsAuthorizations
 168                 .entrySet()) {
 169             String role = pairs.getKey();
 170             Set<ResourceGroup> groups = pairs.getValue();
 171             for (ResourceGroup group : groups) {
 172             if (group.getGroupName().equals(groupName)) {
 173             affectedRoles.add(role);
 174             break;
 175             }
 176             }
 177         }
 178         StringBuffer msg = new StringBuffer();
 179         for (String role : affectedRoles) {
 180              result = unassignResourceGroupFromRole(groupName, role);
 181              if (!result.isSuccess()) {
 182                 msg.append(result.getDescription());
 183                 msg.append(' ');
 184              }
 185          }
 186
 187         if (msg.length() != 0) {
 188                 return new Status(StatusCode.BADREQUEST, msg.toString());
 189         } else {
 190                 return new Status(StatusCode.SUCCESS);
 191         }
 192     }
 193
 194     @Override
 195     public Status removeResourceGroup(String groupName) {
 196         // Default resource group cannot be deleted
 197         if (groupName == null || groupName.trim().isEmpty()) {
 198             return new Status(StatusCode.BADREQUEST, "Invalid group name");
 199         }
 200         if (groupName.equals(this.allResourcesGroupName)) {
 201             return new Status(StatusCode.NOTALLOWED,
 202                     "All resource group cannot be removed");
 203         }
 204
 205         Status result = removeRoleResourceGroupMapping(groupName);
 206
 207         resourceGroups.remove(groupName);
 208
 209         if (!result.isSuccess()) {
 210             return result;
 211         }
 212
 213         return new Status(StatusCode.SUCCESS, null);
 214     }
 215
 216
 217     public Status removeResourceFromGroup(String groupName, T resource) {
 218         if (groupName == null || groupName.trim().isEmpty()) {
 219             return new Status(StatusCode.BADREQUEST, "Invalid group name");
 220         }
 221
 222         Set<T> group = resourceGroups.get(groupName);
 223         if (group != null && group.remove(resource)) {
 224             return new Status(StatusCode.SUCCESS, "Resource removed successfully");
 225         }
 226
 227         return new Status(StatusCode.NOTFOUND, "Group/Resource not found");
 228     }
 229
 230
 231     /**
 232      * Relay the call to user manager
 233      */
 234     @Override
 235     public UserLevel getUserLevel(String userName) {
 236         IUserManager userManager = (IUserManager) ServiceHelper
 237                 .getGlobalInstance(IUserManager.class, this);
 238
 239         if (logger.isDebugEnabled()) {
 240             logger.debug("User {} has UserLevel {}", userName, userManager.getUserLevel(userName));
 241         }
 242
 243         return (userManager == null) ? UserLevel.NOUSER : userManager
 244                 .getUserLevel(userName);
 245     }
 246
 247     @Override
 248     public Set<Resource> getAllResourcesforUser(String userName) {
 249         Set<Resource> resources = new HashSet<Resource>();
 250         IUserManager userManager = (IUserManager) ServiceHelper
 251                 .getGlobalInstance(IUserManager.class, this);
 252         if (userManager == null) {
 253             return new HashSet<Resource>(0);
 254         }
 255
 256         // Get the roles associated with this user
 257         List<String> roles = userManager.getUserRoles(userName);
 258         if (roles == null) {
 259             return resources;
 260         }
 261
 262         for (String role : roles) {
 263             // Get our resource groups associated with this role
 264             List<ResourceGroup> groups = this.getAuthorizedGroups(role);
 265             if (groups.isEmpty()) {
 266                 continue;
 267             }
 268             for (ResourceGroup group : groups) {
 269                 // Get the list of resources in this group
 270                 List<Object> list = this.getResources(group.getGroupName());
 271                 if (list.isEmpty()) {
 272                     continue;
 273                 }
 274                 for (Object resource : list) {
 275                     Resource toBeAdded = new Resource(resource,
 276                             group.getPrivilege());
 277                     /*
 278                      * Add the resource to the set if the same resource with
 279                      * higher privilege is not present. If the same resource
 280                      * with lower privilege is present, remove it. No check on
 281                      * same privilege resource as set guarantees no duplicates.
 282                      */
 283                     Resource existing = higherPrivilegeResourcePresent(
 284                             resources, toBeAdded);
 285                     if (existing == null) {
 286                         resources.add(toBeAdded);
 287                     }
 288                     existing = lowerPrivilegeResourcePresent(resources,
 289                             toBeAdded);
 290                     if (existing != null) {
 291                         resources.remove(existing);
 292                     }
 293                 }
 294             }
 295         }
 296
 297         if (logger.isDebugEnabled()) {
 298             logger.debug("User {} has resources {}", userName, resources);
 299         }
 300
 301         return resources;
 302     }
 303
 304     @Override
 305     public List<Resource> getAuthorizedResources(String role) {
 306         Set<Resource> resources = new HashSet<Resource>();
 307
 308         // Get our resource groups associated with this role
 309         List<ResourceGroup> groups = this.getAuthorizedGroups(role);
 310         if (groups.isEmpty()) {
 311             return new ArrayList<Resource>(0);
 312         }
 313         for (ResourceGroup group : groups) {
 314             // Get the list of resources in this group
 315             List<Object> list = this.getResources(group.getGroupName());
 316             if (list.isEmpty()) {
 317                 continue;
 318             }
 319             for (Object resource : list) {
 320                 Resource toBeAdded = new Resource(resource,
 321                         group.getPrivilege());
 322                 /*
 323                  * Add the resource to the set if the same resource with higher
 324                  * privilege is not present. If the same resource with lower
 325                  * privilege is present, remove it. No check on same privilege
 326                  * resource as set guarantees no duplicates.
 327                  */
 328                 Resource existing = higherPrivilegeResourcePresent(resources,
 329                         toBeAdded);
 330                 if (existing == null) {
 331                     resources.add(toBeAdded);
 332                 }
 333                 existing = lowerPrivilegeResourcePresent(resources, toBeAdded);
 334                 if (existing != null) {
 335                     resources.remove(existing);
 336                 }
 337             }
 338         }
 339
 340         if (logger.isDebugEnabled()) {
 341             logger.debug("For the Role {}, Authorized Resources are {}", role, resources);
 342         }
 343
 344         return new ArrayList<Resource>(resources);
 345     }
 346
 347     /**
 348      * Given a set of resources and a resource to test, it returns the element
 349      * in the set which represent the same resource with a lower privilege
 350      * associated to it, if present.
 351      *
 352      * @param resources
 353      * @param resource
 354      * @return
 355      */
 356     private Resource lowerPrivilegeResourcePresent(Set<Resource> resources,
 357             Resource resource) {
 358
 359         if (resource == null || resources == null) {
 360             return null;
 361         }
 362
 363         Object resourceElement = resource.getResource();
 364         Privilege resourcePrivilege = resource.getPrivilege();
 365         for (Resource element : resources) {
 366             if (element.getResource().equals(resourceElement)
 367                     && element.getPrivilege().ordinal() < resourcePrivilege
 368                             .ordinal()) {
 369                 return element;
 370             }
 371         }
 372         return null;
 373     }
 374
 375     /**
 376      * Given a set of resources and a resource to test, it returns the element
 377      * in the set which represents the same resource with an higher privilege,
 378      * if present.
 379      *
 380      * @param resources
 381      * @param resource
 382      * @return
 383      */
 384     private Resource higherPrivilegeResourcePresent(Set<Resource> resources,
 385             Resource resource) {
 386
 387         if (resource == null || resources == null) {
 388             return null;
 389         }
 390
 391         Object resourceElement = resource.getResource();
 392         Privilege resourcePrivilege = resource.getPrivilege();
 393         for (Resource element : resources) {
 394             if (element.getResource().equals(resourceElement)
 395                     && element.getPrivilege().ordinal() > resourcePrivilege
 396                             .ordinal()) {
 397                 return element;
 398             }
 399         }
 400
 401         return null;
 402     }
 403
 404     @Override
 405     public Privilege getResourcePrivilege(String userName, Object resource) {
 406
 407         if (userName == null || userName.trim().isEmpty() || resource == null) {
 408             return Privilege.NONE;
 409         }
 410
 411         Set<Resource> hisResources = getAllResourcesforUser(userName);
 412         for (Resource element : hisResources) {
 413             if (element.getResource().equals(resource)) {
 414                 return element.getPrivilege();
 415             }
 416         }
 417
 418         return Privilege.NONE;
 419     }
 420
 421     @Override
 422     public List<String> getResourceGroups() {
 423         return new ArrayList<String>(resourceGroups.keySet());
 424     }
 425
 426     @Override
 427     public Status assignResourceGroupToRole(String group, Privilege privilege,
 428             String role) {
 429         if (group == null || group.trim().isEmpty()) {
 430             return new Status(StatusCode.BADREQUEST, "Invalid group name");
 431         }
 432         if (role == null || role.trim().isEmpty()) {
 433             return new Status(StatusCode.BADREQUEST, "Role name can't be empty");
 434         }
 435         if (isControllerRole(role)) {
 436             return new Status(StatusCode.NOTALLOWED,
 437                     "No group assignment is accepted for Controller roles");
 438         }
 439
 440         return assignResourceGroupToRoleInternal(group, privilege, role);
 441     }
 442
 443     protected Status assignResourceGroupToRoleInternal(String group,
 444             Privilege privilege, String role) {
 445         groupsAuthorizations.get(role).add(new ResourceGroup(group, privilege));
 446         return new Status(StatusCode.SUCCESS, null);
 447     }
 448
 449     @Override
 450     public Status assignResourceGroupToRole(String groupName, String roleName) {
 451         if (groupName == null || groupName.trim().isEmpty()) {
 452             return new Status(StatusCode.BADREQUEST, "Group name can't be empty");
 453         }
 454         if (roleName == null || roleName.trim().isEmpty()) {
 455             return new Status(StatusCode.BADREQUEST, "Role name can't be empty");
 456         }
 457         // Infer group privilege from role's level
 458         Privilege privilege = Privilege.NONE;
 459         switch (this.getApplicationRoleLevel(roleName)) {
 460         case APPADMIN:
 461             privilege = Privilege.WRITE;
 462             break;
 463         case APPUSER:
 464             privilege = Privilege.USE;
 465             break;
 466         case APPOPERATOR:
 467             privilege = Privilege.READ;
 468             break;
 469         default:
 470             break;
 471         }
 472         return this.assignResourceGroupToRole(groupName, privilege, roleName);
 473     }
 474
 475     @Override
 476     public Status unassignResourceGroupFromRole(String group, String role) {
 477         if (group == null || group.trim().isEmpty()) {
 478             return new Status(StatusCode.BADREQUEST, "Group name can't be empty");
 479         }
 480         if (role == null || role.trim().isEmpty()) {
 481             return new Status(StatusCode.BADREQUEST, "Role name can't be empty");
 482         }
 483         if (isControllerRole(role)) {
 484             return new Status(StatusCode.NOTALLOWED,
 485                     "No group assignment change is allowed for "
 486                             + "Controller roles");
 487         }
 488
 489         return unassignResourceGroupFromRoleInternal(group, role);
 490     }
 491
 492     protected Status unassignResourceGroupFromRoleInternal(String group,
 493             String role) {
 494         ResourceGroup target = null;
 495         for (ResourceGroup rGroup : groupsAuthorizations.get(role)) {
 496             if (rGroup.getGroupName().equals(group)) {
 497                 target = rGroup;
 498                 break;
 499             }
 500         }
 501         if (target == null) {
 502             return new Status(StatusCode.SUCCESS, "Group " + group
 503                     + " was not assigned to " + role);
 504         } else {
 505         groupsAuthorizations.get(role).remove(target);
 506         return new Status(StatusCode.SUCCESS);
 507
 508         }
 509     }
 510
 511     @Override
 512     public List<ResourceGroup> getAuthorizedGroups(String role) {
 513         return (groupsAuthorizations.containsKey(role)) ? new ArrayList<ResourceGroup>(
 514                 groupsAuthorizations.get(role))
 515                 : new ArrayList<ResourceGroup>();
 516     }
 517
 518     @Override
 519     public List<Object> getResources(String groupName) {
 520         return (resourceGroups.containsKey(groupName)) ? new ArrayList<Object>(
 521                 resourceGroups.get(groupName)) : new ArrayList<Object>();
 522     }
 523
 524     @Override
 525     public boolean isApplicationRole(String roleName) {
 526         if (roleName == null) {
 527             return false;
 528         }
 529         return roles.containsKey(roleName);
 530     }
 531
 532     @Override
 533     public AppRoleLevel getApplicationRoleLevel(String roleName) {
 534         if (roleName == null || roleName.trim().isEmpty()) {
 535             return AppRoleLevel.NOUSER;
 536         }
 537
 538         if (isControllerRole(roleName)) {
 539             if (roleName.equals(UserLevel.NETWORKADMIN.toString()) ||
 540                     roleName.equals(UserLevel.SYSTEMADMIN.toString())) {
 541                 return AppRoleLevel.APPADMIN;
 542             } else {
 543                 return AppRoleLevel.APPOPERATOR;
 544             }
 545         }
 546
 547         return (roles.containsKey(roleName)) ? roles.get(roleName)
 548                 : AppRoleLevel.NOUSER;
 549     }
 550
 551     @Override
 552     public AppRoleLevel getUserApplicationLevel(String userName) {
 553         List<String> roles = null;
 554         IUserManager userManager = (IUserManager) ServiceHelper
 555                 .getGlobalInstance(IUserManager.class, this);
 556
 557         if (userName == null || userName.trim().isEmpty()
 558                 || (userManager == null)
 559                 || (roles = userManager.getUserRoles(userName)).isEmpty()) {
 560             return AppRoleLevel.NOUSER;
 561         }
 562         AppRoleLevel highestLevel = AppRoleLevel.NOUSER;
 563         for (String role : roles) {
 564             AppRoleLevel level = getApplicationRoleLevel(role);
 565             if (level.ordinal() < highestLevel.ordinal()) {
 566                 highestLevel = level;
 567             }
 568         }
 569         return highestLevel;
 570     }
 571
 572     /**
 573      * Returns the highest role the specified user has in this application
 574      * context
 575      *
 576      * @param user
 577      *            The user name
 578      * @return The highest role associated to the user in this application
 579      *         context
 580      */
 581     public String getHighestUserRole(String user) {
 582         IUserManager userManager = (IUserManager) ServiceHelper.getGlobalInstance(IUserManager.class, this);
 583         String highestRole = "";
 584         if (userManager != null && !userManager.getUserRoles(user).isEmpty()) {
 585             List<String> roles = userManager.getUserRoles(user);
 586             AppRoleLevel highestLevel = AppRoleLevel.NOUSER;
 587             for (String role : roles) {
 588                 AppRoleLevel current;
 589                 if (isApplicationRole(role)
 590                         && (current = getApplicationRoleLevel(role)).ordinal() < highestLevel.ordinal()) {
 591                     highestRole = role;
 592                     highestLevel = current;
 593                 }
 594             }
 595         }
 596         return highestRole;
 597     }
 598
 599     private boolean isControllerRole(String role) {
 600         return (role.equals(UserLevel.NETWORKADMIN.toString())
 601                 || role.equals(UserLevel.SYSTEMADMIN.toString()) || role
 602                     .equals(UserLevel.NETWORKOPERATOR.toString()));
 603     }
 604
 605     private boolean isRoleInUse(String role) {
 606         IUserManager userManager = (IUserManager) ServiceHelper
 607                 .getGlobalInstance(IUserManager.class, this);
 608
 609         if (userManager == null) {
 610             return true;
 611         }
 612         return userManager.isRoleInUse(role);
 613     }
 614 }