<module>../../statisticsmanager/api</module>
<module>../../statisticsmanager/implementation</module>
<module>../../statisticsmanager/integrationtest</module>
- <module>../../topologymanager</module>
+ <module>../../topologymanager/implementation</module>
<module>../../usermanager/api</module>
<module>../../usermanager/implementation</module>
<module>../../connectionmanager/api</module>
controllerKeyStorePassword=
controllerTrustStore=
controllerTrustStorePassword=
+
+# User Manager configurations
+enableStrongPasswordCheck = false
return ((to >= 0) && (to <= 0xffff));
}
+ public boolean isProtocolValid(String protocol) {
+ int protocol_number = IPProtocols.getProtocolNumberInt(protocol);
+ if (protocol_number < 1 || protocol_number > 255) {
+ return false;
+ }
+ return true;
+ }
+
private Status conflictWithContainerFlow(IContainer container) {
// Return true if it's default container
if (container.getName().equals(GlobalConstants.DEFAULT.toString())) {
}
}
+ if ((protocol != null) && !isProtocolValid(protocol)) {
+ return new Status(StatusCode.BADREQUEST, String.format("Protocol %s is not valid", protocol));
+ }
+
if ((tosBits != null) && !isTOSBitsValid(tosBits)) {
return new Status(StatusCode.BADREQUEST, String.format("IP ToS bits %s is not in the range 0 - 63",
tosBits));
}
public static AppRoleLevel fromString(String levelString) {
- for (AppRoleLevel level : AppRoleLevel.values()) {
- if (level.toString().equals(levelString)) {
- return level;
+ for (AppRoleLevel rolelevel : AppRoleLevel.values()) {
+ if (rolelevel.toString().equals(levelString)) {
+ return rolelevel;
}
}
return null;
@Override
public String toString() {
if (this.nodeType.equals(NodeIDType.OPENFLOW)) {
- return this.nodeType.toString() + "|"
+ return this.nodeType + "|"
+ HexEncode.longToHexString((Long) this.nodeID);
} else {
- return this.nodeType.toString() + "|" + this.nodeID.toString();
+ return this.nodeType + "|" + this.nodeID.toString();
}
}
.equals(NodeConnectorIDType.SWSTACK) ||
this.nodeConnectorType
.equals(NodeConnectorIDType.HWPATH)) {
- return this.nodeConnectorType.toString();
+ return this.nodeConnectorType;
} else {
- return this.nodeConnectorType.toString() + "|"
+ return this.nodeConnectorType + "|"
+ this.nodeConnectorID.toString();
}
}
}
public String getNodeTableIdAsString() {
- return this.nodeTableType.toString() + "|"
+ return this.nodeTableType + "|"
+ this.nodeTableID.toString();
}
WESP("WESP",141),
ROHC("ROHC",142);
*/
- private static final String regexNumberString = "^[0-9]+$";
+ private static final String regexDecimalString = "^[0-9]{3}$";
+ private static final String regexHexString = "^(0(x|X))[0-9a-fA-F]{2}$";
private String protocolName;
private int protocolNumber;
}
public static short getProtocolNumberShort(String name) {
- if (name.matches(regexNumberString)) {
+ if (name.matches(regexHexString)) {
+ return Short.valueOf(Short.decode(name));
+ }
+ if (name.matches(regexDecimalString)) {
return Short.valueOf(name);
}
for (IPProtocols proto : IPProtocols.values()) {
}
public static int getProtocolNumberInt(String name) {
- if (name.matches(regexNumberString)) {
+ if (name.matches(regexHexString)) {
+ return Integer.valueOf(Integer.decode(name));
+ }
+ if (name.matches(regexDecimalString)) {
return Integer.valueOf(name);
}
for (IPProtocols proto : IPProtocols.values()) {
}
public static byte getProtocolNumberByte(String name) {
- if (name.matches(regexNumberString)) {
+ if (name.matches(regexHexString)) {
+ return Integer.valueOf(Integer.decode(name)).byteValue();
+ }
+ if (name.matches(regexDecimalString)) {
return Integer.valueOf(name).byteValue();
}
for (IPProtocols proto : IPProtocols.values()) {
<groupId>org.opendaylight.controller</groupId>
<artifactId>commons.opendaylight</artifactId>
<version>1.4.0-SNAPSHOT</version>
- <relativePath>../commons/opendaylight</relativePath>
+ <relativePath>../../commons/opendaylight</relativePath>
</parent>
<scm>
<connection>scm:git:ssh://git.opendaylight.org:29418/controller.git</connection>
protected String user;
protected List<String> roles;
private String password;
+
+ private static final boolean strongPasswordCheck = Boolean.getBoolean("enableStrongPasswordCheck");
+ private static final String BAD_PASSWORD = "Bad Password";
private static final int USERNAME_MAXLENGTH = 32;
- private static final int PASSWORD_MINLENGTH = 5;
- private static final int PASSWORD_MAXLENGTH = 256;
+ protected static final String PASSWORD_REGEX = "(?=.*[^\\w])(?=.*\\d)(?=.*[a-z])(?=.*[A-Z]).{8,256}$";
private static final Pattern INVALID_USERNAME_CHARACTERS = Pattern.compile("([/\\s\\.\\?#%;\\\\]+)");
private static MessageDigest oneWayFunction = null;
static {
public UserConfig(String user, String password, List<String> roles) {
this.user = user;
- this.password = password;
- if (this.validatePassword().isSuccess()) {
- /*
- * Only if the password is a valid one, hash it. So in case it is not
- * valid, when UserConfig.validate() is called, the proper
- * validation error will be returned to the caller. If we hashed a
- * priori instead, the mis-configuration would be masked
- */
- this.password = hash(this.password);
- }
+ /*
+ * Password validation to be done on clear text password. If fails, mark
+ * the password with a well known label, so that object validation can
+ * report the proper error. Only if password is a valid one, hash it.
+ */
+ this.password = (validatePassword(password).isSuccess()) ? hash(password) : BAD_PASSWORD;
this.roles = (roles == null) ? new ArrayList<String>() : new ArrayList<String>(roles);
}
}
public Status validate() {
- Status validCheck = validateRoles();
+ Status validCheck = validateUsername();
if (validCheck.isSuccess()) {
- validCheck = validateUsername();
+ validCheck = (!password.equals(BAD_PASSWORD)) ? new Status(StatusCode.SUCCESS) : new Status(
+ StatusCode.BADREQUEST,
+ "Password should be 8 to 256 characters long, contain both upper and lower case letters, "
+ + "at least one number and at least one non alphanumeric character");
}
if (validCheck.isSuccess()) {
- validCheck = validatePassword();
+ validCheck = validateRoles();
}
return validCheck;
}
return new Status(StatusCode.SUCCESS);
}
- private Status validatePassword() {
+ private Status validatePassword(String password) {
if (password == null || password.isEmpty()) {
return new Status(StatusCode.BADREQUEST, "Password cannot be empty");
}
- if (password.length() < UserConfig.PASSWORD_MINLENGTH
- || password.length() > UserConfig.PASSWORD_MAXLENGTH) {
- return new Status(StatusCode.BADREQUEST,
- "Password should have 5-256 characters");
+ if (strongPasswordCheck && !password.matches(UserConfig.PASSWORD_REGEX)) {
+ return new Status(StatusCode.BADREQUEST, "Password should be 8 to 256 characters long, "
+ + "contain both upper and lower case letters, at least one number "
+ + "and at least one non alphanumeric character");
}
return new Status(StatusCode.SUCCESS);
}
UserConfig.oneWayFunction.reset();
return HexEncode.bytesToHexString(UserConfig.oneWayFunction.digest(message.getBytes(Charset.defaultCharset())));
}
+
+ /**
+ * Returns UserConfig instance populated with the passed parameters. It does
+ * not run any checks on the passed parameters.
+ *
+ * @param userName
+ * the user name
+ * @param password
+ * the plain text password
+ * @param roles
+ * the list of roles
+ * @return the UserConfig object populated with the passed parameters. No
+ * validity check is run on the input parameters.
+ */
+ public static UserConfig getUncheckedUserConfig(String userName, String password, List<String> roles) {
+ UserConfig config = new UserConfig();
+ config.user = userName;
+ config.password = hash(password);
+ config.roles = roles;
+ return config;
+ }
}
UserConfig userConfig2 = new UserConfig("uname", "ciscocisco", roles);
assertEquals(userConfig, userConfig2);
}
+
+ @Test
+ public void userConfigPasswordTest() {
+
+ String regex = UserConfig.PASSWORD_REGEX;
+ String password = null;
+
+ // Good password
+ password = "aBc@eF#h9";
+ assertTrue(password.matches(regex));
+ password = "^aBc@eF#h9$88ad*o&";
+ assertTrue(password.matches(regex));
+ password = "_^aBc@\":eF#h;9$\\8|8ad*o&-(){}/,.><?+-";
+ assertTrue(password.matches(regex));
+ password = "culonE1)";
+ assertTrue(password.matches(regex));
+
+ // Too short
+ password = "aB3@eF#";
+ assertFalse(password.matches(regex));
+
+ // No number
+ password = "#BeCCC#CeDfDf";
+ assertFalse(password.matches(regex));
+
+ // No lower case
+ password = "AB8C#CC@C4";
+ assertFalse(password.matches(regex));
+
+ // No upper case
+ password = "ab8defg9!";
+ assertFalse(password.matches(regex));
+
+ // No special characters
+ password = "aBc4ef7H8";
+ assertFalse(password.matches(regex));
+ }
}
*/
@Override
public Object[] getImplementations() {
- return null;
+ return new Object[]{};
}
/**
}
private void checkDefaultNetworkAdmin() {
- // If startup config is not there, it's old or it was deleted,
- // need to add Default Network Admin User
+ /*
+ * If startup config is not there, it's old or it was deleted or if a
+ * password recovery was run, need to add Default Network Admin User
+ */
if (!localUserConfigList.containsKey(DEFAULT_ADMIN)) {
List<String> roles = new ArrayList<String>(1);
roles.add(DEFAULT_ADMIN_ROLE);
- localUserConfigList.put(DEFAULT_ADMIN, new UserConfig(DEFAULT_ADMIN, DEFAULT_ADMIN_PASSWORD, roles));
+ // Need to skip the strong password check for the default admin
+ UserConfig defaultAdmin = UserConfig.getUncheckedUserConfig(UserManager.DEFAULT_ADMIN,
+ UserManager.DEFAULT_ADMIN_PASSWORD, roles);
+ localUserConfigList.put(UserManager.DEFAULT_ADMIN, defaultAdmin);
}
}
import java.util.Set;
import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpSession;
import org.opendaylight.controller.clustering.services.IClusterGlobalServices;
import org.opendaylight.controller.connectionmanager.IConnectionManager;
@RequestMapping(value = "/users/password/{username}", method = RequestMethod.POST)
@ResponseBody
- public Status changePassword(@PathVariable("username") String username, HttpServletRequest request,
- @RequestParam("currentPassword") String currentPassword, @RequestParam("newPassword") String newPassword) {
+ public Status changePassword(
+ @PathVariable("username") String username, HttpServletRequest request,
+ @RequestParam(value = "currentPassword", required=false) String currentPassword,
+ @RequestParam("newPassword") String newPassword) {
IUserManager userManager = (IUserManager) ServiceHelper.getGlobalInstance(IUserManager.class, this);
if (userManager == null) {
- return new Status(StatusCode.GONE, "User Manager not found");
+ return new Status(StatusCode.NOSERVICE, "User Manager unavailable");
}
- if (!authorize(userManager, UserLevel.NETWORKADMIN, request)) {
- return new Status(StatusCode.FORBIDDEN, "Operation not permitted");
- }
+ Status status;
+ String requestingUser = request.getUserPrincipal().getName();
+
+ //changing own password
+ if (requestingUser.equals(username) ) {
+ status = userManager.changeLocalUserPassword(username, currentPassword, newPassword);
+ //enforce the user to re-login with new password
+ if (status.isSuccess() && !newPassword.equals(currentPassword)) {
+ userManager.userLogout(username);
+ HttpSession session = request.getSession(false);
+ if ( session != null) {
+ session.invalidate();
+ }
+ }
+
+ //admin level user resetting other's password
+ } else if (authorize(userManager, UserLevel.NETWORKADMIN, request)) {
+
+ //Since User Manager doesn't have an unprotected password change API,
+ //we re-create the user with the new password (and current roles).
+ List<String> roles = userManager.getUserRoles(username);
+ UserConfig newConfig = new UserConfig(username, newPassword, roles);
+
+ //validate before removing existing config, so we don't remove but fail to add
+ status = newConfig.validate();
+ if (!status.isSuccess()) {
+ return status;
+ }
+
+ userManager.userLogout(username);
+ status = userManager.removeLocalUser(username);
+ if (!status.isSuccess()) {
+ return status;
+ }
+ if (userManager.addLocalUser(newConfig).isSuccess()) {
+ status = new Status(StatusCode.SUCCESS, "Password for user " + username + " reset successfully.");
+ } else {
+ //unexpected
+ status = new Status(StatusCode.INTERNALERROR, "Failed resetting password for user " + username + ". User is now removed.");
+ }
- if (newPassword.isEmpty()) {
- return new Status(StatusCode.BADREQUEST, "Empty passwords not allowed");
+ //unauthorized
+ } else {
+ status = new Status(StatusCode.UNAUTHORIZED, "Operation not permitted");
}
- Status status = userManager.changeLocalUserPassword(username, currentPassword, newPassword);
if (status.isSuccess()) {
- DaylightWebUtil.auditlog("User", request.getUserPrincipal().getName(), "changed password for", username);
+ DaylightWebUtil.auditlog("User", requestingUser, "changed password for", username);
}
return status;
}
</div>
<div class="span3">
<div id="toolbar" class="btn-group">
+ <input type="hidden" id="currentuser" value="${username}" data-role="${role}">
<a class="btn dropdown-toggle" data-toggle="dropdown" href="#">
<div class="icon-user"></div> ${username} <span class="caret"></span>
</a>
// change password binding
$('#'+one.main.admin.id.modal.password.submit, $modal).click(function() {
one.main.admin.password.submit(id, $modal, function(result) {
- if (result.code == 'SUCCESS') {
- $modal.modal('hide');
- successCallback();
+ if (result.success) {
+ //if changed own password, enforce relogin
+ if (id.trim() == $('#currentuser').val().trim()) {
+ alert("Password changed successfully. Please re-login with your new password.");
+ window.location = '/';
+ }
} else {
alert(result.code+': '+result.description);
}
Code Review / controller.git / commitdiff