Java 类org.springframework.security.authentication.encoding.PasswordEncoder 实例源码

@Autowired
public DefaultCalendarService(final EventDao eventDao,
                              final CalendarUserDao userDao,
                              final JdbcOperations jdbcOperations,
                              final PasswordEncoder passwordEncoder) {
    if (eventDao == null) {
        throw new IllegalArgumentException("eventDao cannot be null");
    }
    if (userDao == null) {
        throw new IllegalArgumentException("userDao cannot be null");
    }
    if (jdbcOperations == null) {
        throw new IllegalArgumentException("jdbcOperations cannot be null");
    }
    if (passwordEncoder == null) {
        throw new IllegalArgumentException("passwordEncoder cannot be null");
    }
    this.eventDao = eventDao;
    this.userDao = userDao;
    this.jdbcOperations = jdbcOperations;
    this.passwordEncoder = passwordEncoder;
}

/**
 * Password encryption test method for
 * {@link com.impetus.ankush.service.impl.UserManagerImpl#saveUser(com.impetus.ankush.common.domain.model.User)}
 * .
 * @throws UserExistsException 
 */
@Test
public void testSaveUserPasswordEncryptionChanged() throws UserExistsException {
    user.setVersion(1);
    user.setUsername(user.getUsername().toLowerCase());
    String encryptedPassword = "ENCRYPTED"+user.getPassword();

    PasswordEncoder passwordEncoder = EasyMock.createMock(PasswordEncoder.class);
    ((UserManagerImpl)userManager).setPasswordEncoder(passwordEncoder);

    EasyMock.expect(passwordEncoder.encodePassword(user.getPassword(), null)).andReturn(encryptedPassword);

    EasyMock.expect(userDao.getUserPassword(user.getUsername())).andReturn(user.getPassword()+"Old");
    EasyMock.expect(userDao.saveUser(user)).andReturn(user);
    EasyMock.replay(userDao, passwordEncoder);

    userManager.saveUser(user);
    assertEquals("password not encrypted", encryptedPassword, user.getPassword());
}

/**
 * Password encryption test method for
 * {@link com.impetus.ankush.service.impl.UserManagerImpl#saveUser(com.impetus.ankush.common.domain.model.User)}
 * .
 * @throws UserExistsException 
 */
@Test
public void testSaveUserPasswordEncryptionNew() throws UserExistsException {
    user.setVersion(1);
    user.setUsername(user.getUsername().toLowerCase());
    String encryptedPassword = "ENCRYPTED"+user.getPassword();

    PasswordEncoder passwordEncoder = EasyMock.createMock(PasswordEncoder.class);
    ((UserManagerImpl)userManager).setPasswordEncoder(passwordEncoder);

    EasyMock.expect(passwordEncoder.encodePassword(user.getPassword(), null)).andReturn(encryptedPassword);

    EasyMock.expect(userDao.getUserPassword(user.getUsername())).andReturn(null);
    EasyMock.expect(userDao.saveUser(user)).andReturn(user);
    EasyMock.replay(userDao, passwordEncoder);

    userManager.saveUser(user);
    assertEquals("password not encrypted", encryptedPassword, user.getPassword());
}

/**
 * Password encryption test method for
 * {@link com.impetus.ankush.service.impl.UserManagerImpl#saveUser(com.impetus.ankush.common.domain.model.User)}
 * .
 * @throws UserExistsException 
 */
@Test
public void testSaveUserPasswordEncryptionUnchanged() throws UserExistsException {
    user.setVersion(1);
    user.setUsername(user.getUsername().toLowerCase());

    String encryptedPassword = "ENCRYPTED"+user.getPassword();
    user.setPassword(encryptedPassword);

    PasswordEncoder passwordEncoder = EasyMock.createStrictMock(PasswordEncoder.class);
    ((UserManagerImpl)userManager).setPasswordEncoder(passwordEncoder);

    EasyMock.expect(userDao.getUserPassword(user.getUsername())).andReturn(encryptedPassword);
    EasyMock.expect(userDao.saveUser(user)).andReturn(user);
    EasyMock.replay(userDao, passwordEncoder);

    userManager.saveUser(user);
    assertEquals("password not encrypted", encryptedPassword, user.getPassword());
}

@Test
public void testOldPWMigrate() {
    PasswordEncoder encoder = new Md5PasswordEncoder();
    String oldPW = encoder.encodePassword(STRING, null).toUpperCase();
    String newPW = PasswordUtils.updateOldEncPass(oldPW, DATESTRING);
    assertTrue("Old PW should match", PasswordUtils.isPasswordValid(newPW, STRING, DATESTRING));
}

public AdminUserCreator(UserRepository userRepository, PasswordEncoder passwordEncoder, @Value("${carldav.admin.name}") String adminName, @Value("${carldav.admin.password:null}") String adminPassword) {
    Assert.notNull(userRepository, "userRepository is null");
    Assert.notNull(passwordEncoder, "passwordEncoder is null");
    Assert.hasText(adminName, "adminName is null");
    Assert.hasText(adminPassword, "adminPassword is null");
    this.userRepository = userRepository;
    this.passwordEncoder = passwordEncoder;
    this.adminName = adminName;
    this.adminPassword = adminPassword;
}

public String user_prepareForgotPasswordMessage(Long id)  {
    try {

        User user = userDAO.findById(id);
        PasswordEncoder encoder = new ShaPasswordEncoder(256);
        String hash = encoder.encodePassword(user.getEmail() + new Date().getTime(), user.getSalt());
        PasswordResetRequest  passwordResetRequest = new PasswordResetRequest(user.getLogin() ,hash);
        passwordResetRequestDAO.merge(passwordResetRequest);
        return hash;
    } 
    catch (Exception e) {
        log.error(e.getMessage(),e);
        throw (new RuntimeException(e));
    }
}

@Transactional(readOnly = false)
public User user_updatePassword(User user) {
        User dbUser = userDAO.findById(user.getId());
        dbUser.setLastUpdateDate(new Date());
        PasswordEncoder encoder = new ShaPasswordEncoder(256);
        dbUser.setPassword(encoder.encodePassword(user.getPassword(), user.getSalt()));
        return userDAO.merge(dbUser);
}

@Transactional(readOnly = false)
public User user_updatePassword(User user, PasswordResetRequest passwordResetRequest) {
        //update the request
        passwordResetRequest.setResetDate(new Date());
        passwordResetRequestDAO.merge(passwordResetRequest);

        //update password
        User dbUser = userDAO.findById(user.getId());
        dbUser.setLastUpdateDate(new Date());
        PasswordEncoder encoder = new ShaPasswordEncoder(256);
        dbUser.setPassword(encoder.encodePassword(user.getPassword(), user.getSalt()));
        return userDAO.merge(dbUser);
}

@Transactional(readOnly = false)
public User user_merge(User user) {
    //create save the password
    if (user.getId() == null) {
        user.setCreationDate(new Date());
        user.setLastUpdateDate(new Date());
        PasswordEncoder encoder = new ShaPasswordEncoder(256);
        user.setPassword(encoder.encodePassword(user.getPassword(), user.getSalt()));
        return userDAO.merge(user);
    }

    else
        //update do not update the password
        {   
        User dbUser = userDAO.findById(user.getId());
        dbUser.setLastUpdateDate(new Date());           
        dbUser.setLogin(user.getLogin());
        dbUser.setFirstName(user.getFirstName());
        dbUser.setDateOfBirth(user.getDateOfBirth());
        dbUser.setMiddleName(user.getMiddleName());
        dbUser.setLastName(user.getLastName());
        dbUser.setEmail(user.getEmail());
        dbUser.setEnabled(user.getEnabled());
        dbUser.setGroups(user.getGroups());
        dbUser.setDepartments(user.getDepartments());
        dbUser.setSurveyDefinitions(user.getSurveyDefinitions());
        return userDAO.merge(dbUser);   
    }
}

@Override
protected PasswordEncoder getPasswordEncoder() {
    if (log.isDebugEnabled()) {
        log.debug("Invoking getPasswordEncoder");
    }
    return super.getPasswordEncoder();
}

@Override
public void setPasswordEncoder(PasswordEncoder passwordEncoder) {
    if (log.isDebugEnabled()) {
        log.debug("Invoking setPasswordEncoder");
    }
    super.setPasswordEncoder(passwordEncoder);
}

public User create(User user) {
    user.setEnabled(true);
    user.setRegistrationDate(new Date());
     PasswordEncoder encoder = new Md5PasswordEncoder();
     String hashedPass = encoder.encodePassword(user.getPassword(), null);
     user.setPassword(hashedPass);
    return userRepository.save(user);
}

public void setPasswordEncoder(PasswordEncoder passwordEncoder) {
    this.passwordEncoder = passwordEncoder;
}

public void setPasswordEncoder(PasswordEncoder passwordEncoder) {
    this.passwordEncoder = passwordEncoder;
}

public void setPasswordEncoder(PasswordEncoder passwordEncoder) {
    this.passwordEncoder = passwordEncoder;
}

@ApiOperation(value = "Autentificar un Usuario",  
        notes = "Autentica un usuario, de ser correcto devuelve un token con el que se podrá acceder a los demás métodos privados.",
        response = TokenRest.class)
@ApiResponses(value = { @ApiResponse(code = 401, message = "username token mismatch<br> hash incorrect<br> token expirated<br> username apikey mismatch<br> apikey hash incorrect<br> apikey expirated<br> apikey secret incorrect<br> token or apikey incorrect"),
                        @ApiResponse(code = 400, message = "incorrect request")  })
@RequestMapping(value = "/login", method = RequestMethod.POST, headers = "Accept=application/json", consumes = MediaType.APPLICATION_JSON_VALUE)
@ResponseBody
public ResponseEntity<?> CreateToken(
        @ApiParam(value = "JSON con el envío") @RequestBody InputUserRest bodyjson){
    try {

        int error = ValidateApi(bodyjson.getApikey());
        if (error > 0) {
            return new ResponseEntity<>(TokenUtils.ErrorMessage(error), HttpStatus.UNAUTHORIZED);
        }

        String username = bodyjson.getUsername();
        String password = bodyjson.getPassword();

        String sql = "SELECT * FROM public.users WHERE username = ?";

        try{
            User user =  (User) jdbcTemplate.queryForObject(sql,new Object[]{username},new BeanPropertyRowMapper(User.class));
            PasswordEncoder encoder = new Md5PasswordEncoder();
            password = encoder.encodePassword(password,"ABC123XYZ789");

            if(user.getPassword().equals(password)){
                TokenRest token = new TokenRest(TokenUtils.CreateTokenUser(username), TokenUtils.expirityToken);
                return  new ResponseEntity<>(token, HttpStatus.OK);
        }
        else
            return  new ResponseEntity<>(ErrorUtils.BAD_USERNAME_PASSWORD, HttpStatus.UNAUTHORIZED);


        }catch(Exception e){
            return  new ResponseEntity<>(ErrorUtils.BAD_USERNAME_PASSWORD, HttpStatus.UNAUTHORIZED);
        }


    } catch (IOException ex) {
       return new ResponseEntity<>(TokenUtils.ErrorMessage(8), HttpStatus.BAD_REQUEST);
    }

}

public void setPasswordEncoder(PasswordEncoder passwordEncoder) {
    this.passwordEncoder = passwordEncoder;
}

/**
 *
 * @param passwordEncoder Set the password encoder
 */
@Autowired(required = false)
public final void setPasswordEncoder(final PasswordEncoder passwordEncoder) {
    this.passwordEncoder = passwordEncoder;
}

@Override
public PasswordEncoder getPasswordEncoder() {
    return super.getPasswordEncoder();
}

public void setPasswordEncoder(PasswordEncoder passwordEncoder) {
    super.setPasswordEncoder(passwordEncoder);
}

public void setPasswordEncoder(PasswordEncoder passwordEncoder) {
    this.passwordEncoder = passwordEncoder;
}

@SuppressWarnings("deprecation")
public void setPasswordEncoder(PasswordEncoder passwordEncoder) {
    this.passwordEncoder = passwordEncoder;
}

public User updateWithNewPassword(User user) {
     PasswordEncoder encoder = new Md5PasswordEncoder();
     String hashedPass = encoder.encodePassword(user.getPassword(), null);
     user.setPassword(hashedPass);
    return userRepository.save(user);
}

protected PasswordEncoder getPasswordEncoder() {
    return passwordEncoder;
}

private void createSystemNodes() throws RepositoryException {
    LOG.info("Creating system nodes");

       Node rootNode = getTemplate().getRootNode();

       Node nextServerNode = rootNode.addNode(StorageConstants.NEXT_SERVER_FOLDER_NAME);
       nextServerNode.addMixin("mix:referenceable");
       nextServerNode.setProperty("className", Folder.class.getName());
       nextServerNode.setProperty("version", "-1");

       Node reportsNode = nextServerNode.addNode(StorageConstants.REPORTS_FOLDER_NAME);
       reportsNode.addMixin("mix:referenceable");
       reportsNode.setProperty("className", Folder.class.getName());

       Node datasourcesNode = nextServerNode.addNode(StorageConstants.DATASOURCES_FOLDER_NAME);
       datasourcesNode.addMixin("mix:referenceable");
       datasourcesNode.setProperty("className", Folder.class.getName());

       Node schedulersNode = nextServerNode.addNode(StorageConstants.SCHEDULER_FOLDER_NAME);
       schedulersNode.addMixin("mix:referenceable");
       schedulersNode.setProperty("className", Folder.class.getName());

       Node securityNode = nextServerNode.addNode(StorageConstants.SECURITY_FOLDER_NAME);
       securityNode.addMixin("mix:referenceable");
       securityNode.setProperty("className", Folder.class.getName());

       Node usersNode = securityNode.addNode(StorageConstants.USERS_FOLDER_NAME);
       usersNode.addMixin("mix:referenceable");
       usersNode.setProperty("className", Folder.class.getName());

       Node groupsNode = securityNode.addNode(StorageConstants.GROUPS_FOLDER_NAME);
       groupsNode.addMixin("mix:referenceable");
       groupsNode.setProperty("className", Folder.class.getName());

       Node adminNode = usersNode.addNode(StorageConstants.ADMIN_USER_NAME);
       adminNode.addMixin("mix:referenceable");
       adminNode.setProperty("className", User.class.getName());
       adminNode.setProperty("admin", true);
       PasswordEncoder passwordEncoder = new Md5PasswordEncoder();
       adminNode.setProperty("password", passwordEncoder.encodePassword("1", null));

       getTemplate().save();
}

@Bean
public PasswordEncoder passwordEncoder() {
    return new ShaPasswordEncoder(256);
}

@ApiOperation(value = "Generar una llave de desarrollador",  
        notes = "Crea una llave de desarrollador para comenzar a utilizar la Capa de servicios Web.",
        response = ApiRest.class)
@ApiResponses(value = { @ApiResponse(code = 404, message = "bad user"),
                        @ApiResponse(code = 401, message = "bad username or password") })
@RequestMapping(value = "/generateapi", method = RequestMethod.POST, headers = "Accept=application/json", consumes = MediaType.APPLICATION_JSON_VALUE)
@ResponseBody
public ResponseEntity<?> GenerateAPI(
        @ApiParam(value = "JSON con el envío") @RequestBody InputGenerateApiRest bodyjson){

        if(!userDAO.isUser(bodyjson.getUsername()))
            return new ResponseEntity<>(ErrorUtils.BAD_USER, HttpStatus.NOT_FOUND);

        String sql = "SELECT * FROM public.users WHERE username = ?";


        User user =  (User) jdbcTemplate.queryForObject(sql,new Object[]{bodyjson.getUsername()},new BeanPropertyRowMapper(User.class));
        PasswordEncoder encoder = new Md5PasswordEncoder();
        String password = encoder.encodePassword(bodyjson.getPassword(),"ABC123XYZ789");

        if(!user.getPassword().equals(password))
            return  new ResponseEntity<>(ErrorUtils.BAD_USERNAME_PASSWORD, HttpStatus.UNAUTHORIZED);               

        String apiKey = TokenUtils.CreateAPIKey(bodyjson.getUsername(), password);

        return new ResponseEntity<>(new ApiRest(apiKey, TokenUtils.expirityAPIKey),HttpStatus.OK);



}

/**
 * Standard SHA-256 Password Encoder
 * @return ShaPasswordEncoder
 *
 * @see ShaPasswordEncoder
 */
@Bean
public PasswordEncoder passwordEncoder(){
    return new ShaPasswordEncoder(256);
}

/**
 * Sets the password encoder.
 * 
 * @param passwordEncoder
 *            the new password encoder
 */
@Autowired
public void setPasswordEncoder(PasswordEncoder passwordEncoder) {
    this.passwordEncoder = passwordEncoder;
}

/**
 * The password encoder to use for the plain-text password signature method.
 *
 * @return The password encoder to use for the plain-text password signature method.
 */
public PasswordEncoder getPlainTextPasswordEncoder() {
  return plainTextPasswordEncoder;
}

/**
 * The password encoder to use for the plain-text password signature method.
 *
 * @param plainTextPasswordEncoder The password encoder to use for the plain-text password signature method.
 */
public void setPlainTextPasswordEncoder(PasswordEncoder plainTextPasswordEncoder) {
  this.plainTextPasswordEncoder = plainTextPasswordEncoder;
}

/**
 * Construct a plain text signature method with the given plain-text secret.
 *
 * @param secret  The secret.
 * @param encoder The password encoder, or null if none is to be used.
 * @param salt The salt for the secret, if any.
 */
public PlainTextSignatureMethod(String secret, PasswordEncoder encoder, Object salt) {
  this.secret = secret;
  this.encoder = encoder;
  this.salt = salt;
}

/**
 * Sets the PasswordEncoder instance to be used to encode and validate passwords.
 * If not set, {@link PlaintextPasswordEncoder} will be used by default.
 *
 * @param passwordEncoder The passwordEncoder to use
 */
public void setPasswordEncoder(PasswordEncoder passwordEncoder) {
    this.passwordEncoder = passwordEncoder;
}