org.springframework.security.crypto.password.standardpasswordencoder Java Examples

@Test
public void testBcrypt(){
	String pwd = "jfish";
	StandardPasswordEncoder def = new StandardPasswordEncoder();
	BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
	
	TimeCounter time = new TimeCounter("sha");
	int times = 1;
	time.start();
	LangOps.ntimesRun(times, ()->{
		def.encode(pwd);
	});
	time.stop();
	
	time.restart("bcrypt");
	LangOps.ntimesRun(times, ()->{
		String str = encoder.encode(pwd);
		System.out.println("BCrypt "+str.length()+":"+str);
	});
	time.stop();
}
 

@Test
public void 스프링시큐리티_암호_인코딩() {
	String password = passwordEncoder.encode("1111");

	Assert.assertFalse(passwordEncoder.matches("1112", password));
	Assert.assertTrue(passwordEncoder.matches("1111", password));

	DelegatingPasswordEncoder newPasswordEncoder = (DelegatingPasswordEncoder) PasswordEncoderFactories.createDelegatingPasswordEncoder();
	newPasswordEncoder.setDefaultPasswordEncoderForMatches(new StandardPasswordEncoder());
	System.out.println(newPasswordEncoder.encode("1111"));
	Assert.assertTrue(newPasswordEncoder.matches("1111", password));
}
 

@Bean
public PasswordEncoder passwordEncoder()
{
    // Set up a DelegatingPasswordEncoder which decodes legacy passwords using the
    // StandardPasswordEncoder but encodes passwords using the modern BCryptPasswordEncoder 
    String encoderForEncoding = "bcrypt";
    Map<String, PasswordEncoder> encoders = new HashMap<>();
    encoders.put(encoderForEncoding, new BCryptPasswordEncoder());
    DelegatingPasswordEncoder delegatingEncoder = new DelegatingPasswordEncoder(
            encoderForEncoding, encoders);
    // Decode legacy passwords without encoder ID using the StandardPasswordEncoder
    delegatingEncoder.setDefaultPasswordEncoderForMatches(new StandardPasswordEncoder());
    return delegatingEncoder;
}
 

@Bean
public PasswordEncoder passwordEncoder() {
    if (passwordEncoderOverride != null) {
        return passwordEncoderOverride.createPasswordEncoder();
    }
    
    return new StandardPasswordEncoder();
}
 

@Autowired
public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
	// @formatter:off
	auth
		.userDetailsService(authorizedUserDetailsService())
		.passwordEncoder(new StandardPasswordEncoder());
	// @formatter:on
}
 

@Test
public void testStandardPasswordEncoder(){
    PasswordEncoder passwordEncoder = new StandardPasswordEncoder("web_qq");
    String password1 = passwordEncoder.encode("12345");
    String password2 = passwordEncoder.encode("mingguobin4");
    System.out.println("password1:"+password1);
    System.out.println("password2:"+password2);
    System.out.println(passwordEncoder.matches("mingguobin4",password1));
}
 

@CacheEvict(value = WallRideCacheConfiguration.USER_CACHE, allEntries = true)
public User updatePassword(PasswordUpdateRequest request, AuthorizedUser updatedBy) {
	User user = userRepository.findOneForUpdateById(request.getUserId());
	if (user == null) {
		throw new IllegalArgumentException("The user does not exist");
	}
	PasswordEncoder passwordEncoder = new StandardPasswordEncoder();
	user.setLoginPassword(passwordEncoder.encode(request.getPassword()));
	user.setUpdatedAt(LocalDateTime.now());
	user.setUpdatedBy(updatedBy.toString());
	return userRepository.saveAndFlush(user);
}
 

@RequestMapping(method = RequestMethod.PUT)
public String update(
		@Validated @ModelAttribute(FORM_MODEL_KEY) PasswordUpdateForm form,
		BindingResult errors,
		AuthorizedUser authorizedUser,
		RedirectAttributes redirectAttributes) {
	redirectAttributes.addFlashAttribute(FORM_MODEL_KEY, form);
	redirectAttributes.addFlashAttribute(ERRORS_MODEL_KEY, errors);

	if (!errors.hasFieldErrors("newPassword")) {
		if (!ObjectUtils.nullSafeEquals(form.getNewPassword(), form.getNewPasswordRetype())) {
			errors.rejectValue("newPasswordRetype", "MatchRetype");
		}
	}

	if (!errors.hasErrors()) {
		User user = userService.getUserById(authorizedUser.getId());
		PasswordEncoder passwordEncoder = new StandardPasswordEncoder();
		if (!passwordEncoder.matches(form.getCurrentPassword(), user.getLoginPassword())) {
			errors.rejectValue("currentPassword", "MatchCurrentPassword");
		}
	}

	if (errors.hasErrors()) {
		return "redirect:/settings/password?step.edit";
	}

	PasswordUpdateRequest request = new PasswordUpdateRequest()
			.withUserId(authorizedUser.getId())
			.withPassword(form.getNewPassword());
	userService.updatePassword(request, authorizedUser);

	redirectAttributes.getFlashAttributes().clear();
	redirectAttributes.addFlashAttribute("updatedPassword", true);
	return "redirect:/settings/password";
}
 

@Bean
public PasswordEncoder passwordEncoder()
{
    // Set up a DelegatingPasswordEncoder which decodes legacy passwords using the
    // StandardPasswordEncoder but encodes passwords using the modern BCryptPasswordEncoder 
    String encoderForEncoding = "bcrypt";
    Map<String, PasswordEncoder> encoders = new HashMap<>();
    encoders.put(encoderForEncoding, new BCryptPasswordEncoder());
    DelegatingPasswordEncoder delegatingEncoder = new DelegatingPasswordEncoder(
            encoderForEncoding, encoders);
    // Decode legacy passwords without encoder ID using the StandardPasswordEncoder
    delegatingEncoder.setDefaultPasswordEncoderForMatches(new StandardPasswordEncoder());
    return delegatingEncoder;
}
 

@Test
public void testSpringPasswordEncoderInstance() {
    PasswordEncoder passwordEncoder = autoWiredIdmIdmEngineConfiguration.getPasswordEncoder();

    autoWiredIdmIdmEngineConfiguration.setPasswordEncoder(new SpringEncoder(new StandardPasswordEncoder()));
    validatePassword();

    autoWiredIdmIdmEngineConfiguration.setPasswordEncoder(passwordEncoder);
}
 

public static String encode(String password) {
    StandardPasswordEncoder encoder = new StandardPasswordEncoder();
    String encodedPassword = encoder.encode(password);
    return encodedPassword;
}
 

public static String encode(String password) {
    StandardPasswordEncoder encoder = new StandardPasswordEncoder();
    String encodedPassword = encoder.encode(password);
    return encodedPassword;
}
 

public static String encode(String password) {
    StandardPasswordEncoder encoder = new StandardPasswordEncoder();
    String encodedPassword = encoder.encode(password);
    return encodedPassword;
}
 

public static String encode(String password) {
    StandardPasswordEncoder encoder = new StandardPasswordEncoder();
    String encodedPassword = encoder.encode(password);
    return encodedPassword;
}
 

public static String encode(String password) {
    StandardPasswordEncoder encoder = new StandardPasswordEncoder();
    String encodedPassword = encoder.encode(password);
    return encodedPassword;
}
 

public static String generatedOwnerPassword() {
	PasswordEncoder passwordEncoder = new StandardPasswordEncoder();
	String password = "" + DateTime.now().getMillis(); 
	return passwordEncoder.encode(password);
}
 

@CacheEvict(value = WallRideCacheConfiguration.USER_CACHE, allEntries = true)
	public AuthorizedUser signup(SignupRequest request, User.Role role, String token) throws ServiceException {
		UserInvitation invitation = null;
		if (token != null) {
			invitation = userInvitationRepository.findOneForUpdateByToken(token);
			if (invitation == null) {
				throw new HttpForbiddenException();
			}
			if (!validateInvitation(invitation)) {
				throw new HttpForbiddenException();
			}
		}

		User duplicate;
		duplicate = userRepository.findOneByLoginId(request.getLoginId());
		if (duplicate != null) {
			throw new DuplicateLoginIdException(request.getLoginId());
		}
		duplicate = userRepository.findOneByEmail(request.getEmail());
		if (duplicate != null) {
			throw new DuplicateEmailException(request.getEmail());
		}

		LocalDateTime now = LocalDateTime.now();
		if (invitation != null) {
			invitation.setAccepted(true);
			invitation.setAcceptedAt(now);
			userInvitationRepository.saveAndFlush(invitation);
		}

		User user = new User();
		user.setLoginId(request.getLoginId());
		StandardPasswordEncoder passwordEncoder = new StandardPasswordEncoder();
		user.setLoginPassword(passwordEncoder.encode(request.getLoginPassword()));
		user.getName().setFirstName(request.getName().getFirstName());
		user.getName().setLastName(request.getName().getLastName());
		user.setEmail(request.getEmail());
		user.getRoles().add(role);
		user.setCreatedAt(now);
		user.setUpdatedAt(now);
		user = userRepository.saveAndFlush(user);

		AuthorizedUser authorizedUser = new AuthorizedUser(user);
//		Authentication auth = new UsernamePasswordAuthenticationToken(authorizedUser, null, authorizedUser.getAuthorities());
//		SecurityContextHolder.getContext().setAuthentication(auth);

		return authorizedUser;
	}
 

@CacheEvict(value = {WallRideCacheConfiguration.USER_CACHE, WallRideCacheConfiguration.BLOG_CACHE}, allEntries = true)
public User setup(SetupRequest request) {
	LocalDateTime now = LocalDateTime.now();

	User user = new User();
	user.setLoginId(request.getLoginId());

	StandardPasswordEncoder passwordEncoder = new StandardPasswordEncoder();
	user.setLoginPassword(passwordEncoder.encode(request.getLoginPassword()));

	user.getName().setFirstName(request.getName().getFirstName());
	user.getName().setLastName(request.getName().getLastName());
	user.setEmail(request.getEmail());

	user.getRoles().add(User.Role.ADMIN);

	user.setCreatedAt(now);
	user.setUpdatedAt(now);

	user = userRepository.saveAndFlush(user);

	Blog blog = new Blog();
	blog.setCode("default");
	blog.setDefaultLanguage(request.getDefaultLanguage());
	blog.setCreatedAt(now);
	blog.setCreatedBy(user.toString());
	blog.setUpdatedAt(now);
	blog.setUpdatedBy(user.toString());

	BlogLanguage defaultLanguage = new BlogLanguage();
	defaultLanguage.setBlog(blog);
	defaultLanguage.setLanguage(request.getDefaultLanguage());
	defaultLanguage.setTitle(request.getWebsiteTitle());
	defaultLanguage.setCreatedAt(now);
	defaultLanguage.setCreatedBy(user.toString());
	defaultLanguage.setUpdatedAt(now);
	defaultLanguage.setUpdatedBy(user.toString());

	Set<BlogLanguage> blogLanguages = new HashSet<>();
	blogLanguages.add(defaultLanguage);

	for (String language : request.getLanguages()) {
		BlogLanguage blogLanguage = new BlogLanguage();
		blogLanguage.setBlog(blog);
		blogLanguage.setLanguage(language);
		blogLanguage.setTitle(request.getWebsiteTitle());
		blogLanguage.setCreatedAt(now);
		blogLanguage.setCreatedBy(user.toString());
		blogLanguage.setUpdatedAt(now);
		blogLanguage.setUpdatedBy(user.toString());

		blogLanguages.add(blogLanguage);
	}
	blog.setLanguages(blogLanguages);

	blogRepository.saveAndFlush(blog);

	return user;
}
 

@CacheEvict(value = WallRideCacheConfiguration.USER_CACHE, allEntries = true)
public User updatePassword(PasswordUpdateRequest request, PasswordResetToken passwordResetToken) {
	User user = userRepository.findOneForUpdateById(request.getUserId());
	if (user == null) {
		throw new IllegalArgumentException("The user does not exist");
	}
	PasswordEncoder passwordEncoder = new StandardPasswordEncoder();
	user.setLoginPassword(passwordEncoder.encode(request.getPassword()));
	user.setUpdatedAt(LocalDateTime.now());
	user.setUpdatedBy(passwordResetToken.getUser().toString());
	user = userRepository.saveAndFlush(user);

	passwordResetTokenRepository.delete(passwordResetToken);

	try {
		Blog blog = blogService.getBlogById(Blog.DEFAULT_ID);
		String blogTitle = blog.getTitle(LocaleContextHolder.getLocale().getLanguage());

		ServletUriComponentsBuilder builder = ServletUriComponentsBuilder.fromCurrentContextPath();
		if (blog.isMultiLanguage()) {
			builder.path("/{language}");
		}
		builder.path("/login");

		Map<String, Object> urlVariables = new LinkedHashMap<>();
		urlVariables.put("language", request.getLanguage());
		urlVariables.put("token", passwordResetToken.getToken());
		String loginLink = builder.buildAndExpand(urlVariables).toString();

		Context ctx = new Context(LocaleContextHolder.getLocale());
		ctx.setVariable("passwordResetToken", passwordResetToken);
		ctx.setVariable("resetLink", loginLink);

		MimeMessage mimeMessage = mailSender.createMimeMessage();
		MimeMessageHelper message = new MimeMessageHelper(mimeMessage, true, "UTF-8"); // true = multipart
		message.setSubject(MessageFormat.format(
				messageSourceAccessor.getMessage("PasswordChangedSubject", LocaleContextHolder.getLocale()),
				blogTitle));
		message.setFrom(mailProperties.getProperties().get("mail.from"));
		message.setTo(passwordResetToken.getEmail());

		String htmlContent = templateEngine.process("password-changed", ctx);
		message.setText(htmlContent, true); // true = isHtml

		mailSender.send(mimeMessage);
	} catch (MessagingException e) {
		throw new ServiceException(e);
	}

	return user;
}
 

public static String encode(String password) {
    StandardPasswordEncoder encoder = new StandardPasswordEncoder();
    String encodedPassword = encoder.encode(password);
    return encodedPassword;
}
 

@Bean
public PasswordEncoder encoder() {
  return new StandardPasswordEncoder("53cr3t");
}
 

@Bean
@Primary
public PasswordEncoder getPasswordEncoder(){
    return new StandardPasswordEncoder(salt);
}
 

public String standardEncoder(String password) {
    StandardPasswordEncoder standardPasswordEncoder = new StandardPasswordEncoder();
    String encoded = standardPasswordEncoder.encode(password);
    return encoded;
}
 

public String standardEncoder(String password) {
    StandardPasswordEncoder standardPasswordEncoder = new StandardPasswordEncoder();
    String encoded = standardPasswordEncoder.encode(password);
    return encoded;
}
 

protected void doAfterPropertiesSet() throws Exception {
	Assert.notNull(this.userDetailsService, "A UserDetailsService must be set");
	Assert.notNull(this.passwordSaltProvider, "A PasswordSaltProvider must be set");

	passwordEncoder = new StandardPasswordEncoder(passwordSaltProvider.getSalt());
}
 

@Override
public void afterPropertiesSet() throws Exception {
	this.passwordEncoder = new StandardPasswordEncoder(accountConfigurationProperties.getSalt());
}
 

public static String encode(String password) {
    StandardPasswordEncoder encoder = new StandardPasswordEncoder();
    String encodedPassword = encoder.encode(password);
    return encodedPassword;
}
 

public static String encode(String password) {
    StandardPasswordEncoder encoder = new StandardPasswordEncoder();
    String encodedPassword = encoder.encode(password);
    return encodedPassword;
}
 

@Bean
public PasswordEncoder encoder() {
  return new StandardPasswordEncoder("53cr3t");
}
 

public static String encode(String password) {
    StandardPasswordEncoder encoder = new StandardPasswordEncoder();
    String encodedPassword = encoder.encode(password);
    return encodedPassword;
}