Java Password类代码示例

import org.picketlink.idm.credential.Password; //导入依赖的package包/类
/**
 * Autentica o usuario no banco de dados pelo modelo de seguranca
 */
@Override
public void authenticate() {

    final UsernamePasswordCredentials userCredentials = 
            new UsernamePasswordCredentials(this.wbCredentials.getUsername(),
                    new Password(this.wbCredentials.getPassword()));

    try {
        this.identityManager.validateCredentials(userCredentials);

        this.defineStatus(userCredentials.getStatus());
        
        if (this.getStatus() == AuthenticationStatus.SUCCESS) {
            this.setAccount(userCredentials.getValidatedAccount());
        } 
    } catch (Exception ex) {
        this.setStatus(AuthenticationStatus.FAILURE);
        logger.error("Error in an attempt to authenticate {}", 
                this.wbCredentials.getUsername(), ex);
    }
}
 

import org.picketlink.idm.credential.Password; //导入依赖的package包/类
/**
 *
 * @param user
 */
@Transactional
public void save(User user) {

    // validamos os dados do usuario
    final User found = this.findUserByUsername(user.getUsername());

    if (found != null) {
        throw new InternalServiceError("user.error.duplicated-username");
    }

    // pegamos o grupo e setamos o user no membership dele
    final GroupMembership groupMembership = user.getGroupMembership();

    // pegamos a senha antes de salvar o usuario
    final String unsecurePassword = user.getPassword();

    // salvamos
    this.identityManager.add(user);

    // atualizamos o usuario com a senha
    this.identityManager.updateCredential(user, new Password(unsecurePassword));

    // concedemos ao usuario o grant para o grupo que ele escolheu
    this.relationshipManager.add(groupMembership);
}
 

import org.picketlink.idm.credential.Password; //导入依赖的package包/类
/**
 *
 * @param user
 */
@Transactional
public void updateProfile(User user) {

    // limpa a senha para nao ser trocada quando em testes
    if (ApplicationUtils.isStageRunning(ProjectStage.SystemTest)
            && user.getUsername().equals("admin")) {
        user.setPassword(null);
    }

    // pegamos a senha antes de salvar o usuario
    final String unsecurePassword = user.getPassword();

    // atualizamos o usuario com a senha
    if (unsecurePassword != null && !unsecurePassword.isEmpty()) {
        this.identityManager.updateCredential(user, new Password(unsecurePassword));
    } else {
        // salvamos
        this.identityManager.update(user);
    }
}
 

import org.picketlink.idm.credential.Password; //导入依赖的package包/类
@PostConstruct
public void create() 
{

    // Create user john
    User john = new User("john");
    john.setEmail("[email protected]");
    john.setFirstName("John");
    john.setLastName("User");

    IdentityManager identityManager = this.partitionManager.createIdentityManager();

    identityManager.add(john);
    identityManager.updateCredential(john, new Password("123456"));

}
 

import org.picketlink.idm.credential.Password; //导入依赖的package包/类
public synchronized void create( @Observes PreAuthenticateEvent event ) {
  if ( alreadyDone ) {
    return;
  }

  alreadyDone = true;

  final IdentityManager identityManager = partitionManager.createIdentityManager();
  final RelationshipManager relationshipManager = partitionManager.createRelationshipManager();

  User admin = new User("admin");

  admin.setEmail("[email protected]");
  admin.setFirstName("");
  admin.setLastName("admin");

  User regular = new User("regular");

  regular.setEmail("[email protected]");
  regular.setFirstName("Regular");
  regular.setLastName("User");

  identityManager.add(admin);
  identityManager.add(regular);
  identityManager.updateCredential(admin, new Password("admin"));
  identityManager.updateCredential(regular, new Password("123"));

  Role roleDeveloper = new Role("simple");
  Role roleAdmin = new Role("admin");

  identityManager.add(roleDeveloper);
  identityManager.add(roleAdmin);

  relationshipManager.add(new Grant(admin, roleDeveloper));
  relationshipManager.add(new Grant(admin, roleAdmin));
}
 

import org.picketlink.idm.credential.Password; //导入依赖的package包/类
private void setup() {
    final IdentityManager identityManager = partitionManager.createIdentityManager();
    final RelationshipManager relationshipManager = partitionManager.createRelationshipManager();

    final User admin = new User("admin");
    final User director = new User("director");
    final User user = new User("user");
    final User guest = new User("guest");

    identityManager.add(admin);
    identityManager.add(director);
    identityManager.add(user);
    identityManager.add(guest);

    identityManager.updateCredential(admin,
                                     new Password("admin"));
    identityManager.updateCredential(director,
                                     new Password("director"));
    identityManager.updateCredential(user,
                                     new Password("user"));
    identityManager.updateCredential(guest,
                                     new Password("guest"));

    final Role roleAdmin = new Role("admin");
    final Role roleAnalyst = new Role("analyst");

    identityManager.add(roleAdmin);
    identityManager.add(roleAnalyst);

    relationshipManager.add(new Grant(admin,
                                      roleAnalyst));
    relationshipManager.add(new Grant(admin,
                                      roleAdmin));

    relationshipManager.add(new Grant(director,
                                      roleAnalyst));

    relationshipManager.add(new Grant(user,
                                      roleAnalyst));
}
 

import org.picketlink.idm.credential.Password; //导入依赖的package包/类
/**
 * 
 * @return 
 */
@NotNull(message = "{authentication.password}")
public String getPassword() {
    if (this.secret instanceof Password) {
        Password password = (Password) this.secret;
        return new String(password.getValue());
    }
    return null;
}
 

import org.picketlink.idm.credential.Password; //导入依赖的package包/类
/**
 * 
 * @param password 
 */
public void setPassword(final String password) {
    if (password == null) {
        throw new IllegalArgumentException("Password can not be null.");
    }
    this.secret = new Password(password.toCharArray());
}
 

import org.picketlink.idm.credential.Password; //导入依赖的package包/类
/**
 *
 * @param user
 */
@Transactional
public void update(User user) {

    // limpa a senha para nao ser trocada quando em testes
    if (ApplicationUtils.isStageRunning(ProjectStage.SystemTest)
            && user.getUsername().equals("admin")) {
        return;
    }

    // pegamos o grupo
    final GroupMembership groupMembership = user.getGroupMembership();

    // removemos o vinculo antigo
    this.listMembershipsByUser(user).forEach(membership -> {
        this.removeFromGroup(membership.getGroup(), user);
    });

    // pegamos a senha antes de salvar o usuario
    final String unsecurePassword = user.getPassword();

    // atualizamos o usuario com a senha
    if (unsecurePassword != null && !unsecurePassword.isEmpty()) {
        this.identityManager.updateCredential(user, new Password(unsecurePassword));
    } else {
        // salvamos
        this.identityManager.update(user);
    }

    // concedemos ao usuario o grant para o grupo que ele escolheu
    this.relationshipManager.add(groupMembership);
}
 

import org.picketlink.idm.credential.Password; //导入依赖的package包/类
private void setup() {
    final IdentityManager identityManager = partitionManager.createIdentityManager();
    final RelationshipManager relationshipManager = partitionManager.createRelationshipManager();

    final User admin = new User("admin");
    final User director = new User("director");
    final User user = new User("user");
    final User guest = new User("guest");

    identityManager.add(admin);
    identityManager.add(director);
    identityManager.add(user);
    identityManager.add(guest);

    identityManager.updateCredential(admin, new Password("admin"));
    identityManager.updateCredential(director, new Password("director"));
    identityManager.updateCredential(user, new Password("user"));
    identityManager.updateCredential(guest, new Password("guest"));

    final Role roleAdmin = new Role("admin");
    final Role roleAnalyst = new Role("analyst");

    identityManager.add(roleAdmin);
    identityManager.add(roleAnalyst);

    relationshipManager.add(new Grant(admin, roleAnalyst));
    relationshipManager.add(new Grant(admin, roleAdmin));

    relationshipManager.add(new Grant(director, roleAnalyst));

    relationshipManager.add(new Grant(user, roleAnalyst));
}
 

import org.picketlink.idm.credential.Password; //导入依赖的package包/类
@POST
@Consumes("application/json")
@Produces(MediaType.APPLICATION_JSON)
public User register(RegistrationParams params) throws Exception
{
   User user = new User();
   user.setUsername(params.getUsername());
   user.setFirstName(params.getFirstName());
   user.setLastName(params.getLastName());

   identityManager.add(user);
   identityManager.updateCredential(user, new Password(params.getPassword()));

   return user;
}
 

import org.picketlink.idm.credential.Password; //导入依赖的package包/类
@Override
@Transactional(qualifier = PicketLink.class)
public void authenticate() 
{
	if(!identity.isLoggedIn())
	{
		FacesContext context = FacesContext.getCurrentInstance();
		if (realm.isEmpty())
		{
			context.addMessage("Realm",new FacesMessage(messages.DomainRequired()));
		}
		if (credentials.getUserId().isEmpty())
		{
			context.addMessage("username",new FacesMessage(messages.UsernameRequired()));
		}
		if (credentials.getPassword().isEmpty())
		{
			context.addMessage("password",new FacesMessage(messages.PasswordRequired()));
		}
				
		Realm storedRealm = partitionManager.getPartition(Realm.class, realm);
		if(storedRealm == null)
		{
			context.addMessage(null,new FacesMessage(FacesMessage.SEVERITY_ERROR,"Error!", messages.LoginStatusFailure()));
			return;
		}
		IdentityManager identityManager = partitionManager.createIdentityManager(storedRealm);
		
		Password password = new Password(credentials.getPassword());
		UsernamePasswordCredentials m_credentials = new UsernamePasswordCredentials(credentials.getUserId(), password);
		identityManager.validateCredentials(m_credentials);
        org.picketlink.idm.credential.Credentials.Status status = m_credentials.getStatus();
        if (status == org.picketlink.idm.credential.Credentials.Status.INVALID)
        {
			context.addMessage(null,new FacesMessage(FacesMessage.SEVERITY_ERROR,"Error!", messages.LoginStatusFailure()));
			return;
        }
        IdentityQueryBuilder queryBuilder = identityManager.getQueryBuilder();
        IdentityQuery<User> query = queryBuilder.createIdentityQuery(User.class);

        // let's check if the user is stored by querying by name
        query.where(queryBuilder.equal(User.USER_NAME, credentials.getUserId()));

        List<User> users = query.getResultList();

        setStatus(AuthenticationStatus.SUCCESS);
        setAccount(users.get(0));
//		UserIdentity user = new UserIdentity();
//		user.setUsername(Username);
//		user.setPassword(Password);
//		model.SaveUser(user);
//		System.out.print("this is test");
	}
     //  this.viewNavigationHandler.navigateTo(Windows.contourdynamics.class);
}
 

import org.picketlink.idm.credential.Password; //导入依赖的package包/类
@PostConstruct
public void create() throws Exception{
	Realm cd = new Realm(REALM_CD_NAME);
	Realm storedRealm = partitionManager.getPartition(Realm.class, cd.getName());
	if(storedRealm == null)
	{
		cd.setEnforceSSL(true);
		KeyPair keyPair = KeyPairGenerator.getInstance("RSA").generateKeyPair();
		cd.setPrivateKey(keyPair.getPrivate().getEncoded());
		cd.setPublickKey(keyPair.getPublic().getEncoded());
		cd.setNumberFailedLoginAttempts(3);
		partitionManager.add(cd);
 
    	IdentityManager cdIdentityManager = partitionManager.createIdentityManager(cd);
    	
        Role Administrator = new Role("Administrator");
        Role Customer = new Role("Customer");
        Role Consumer = new Role("Consumer");
        Role Vendor = new Role("Vendor");
        Role Contacts = new Role("Contacts");
        
        cdIdentityManager.add(Administrator);
        cdIdentityManager.add(Customer);
        cdIdentityManager.add(Consumer);
        cdIdentityManager.add(Vendor);
        cdIdentityManager.add(Contacts);
        
        User user = new User("admin");            
        cdIdentityManager.add(user);
        Password password = new Password("admin");
        cdIdentityManager.updateCredential(user, password); 
        
        RelationshipManager relationshipManager = partitionManager.createRelationshipManager();
        relationshipManager.add(new Grant(user, Administrator));
        
        
        Realm cdcustomer = new Realm(REALM_CDCustomer_NAME);
    	Realm customerRealm = partitionManager.getPartition(Realm.class, cdcustomer.getName());
    	
    	if(customerRealm == null)
    	{
    		cdcustomer.setEnforceSSL(true);
    		KeyPair keyPaircustomer = KeyPairGenerator.getInstance("RSA").generateKeyPair();
    		cdcustomer.setPrivateKey(keyPaircustomer.getPrivate().getEncoded());
    		cdcustomer.setPublickKey(keyPaircustomer.getPublic().getEncoded());
    		cdcustomer.setNumberFailedLoginAttempts(3);
    		partitionManager.add(cdcustomer);
 
        	IdentityManager cdIdentityManagercst = partitionManager.createIdentityManager(cdcustomer);
        	
        	User customer = new User("customer");            
        	cdIdentityManagercst.add(customer);
            Password demo = new Password("demo");
            cdIdentityManagercst.updateCredential(customer, demo); 
            relationshipManager.add(new Grant(customer, Customer));
            
            
            User consumer = new User("consumer");            
        	cdIdentityManagercst.add(consumer);
            cdIdentityManagercst.updateCredential(consumer, demo); 
            relationshipManager.add(new Grant(consumer, Consumer));
    	}
	}
}
 

import org.picketlink.idm.credential.Password; //导入依赖的package包/类
/**
 * Creates example users so people can log in while trying out the app.
 */
public synchronized void create(@Observes PreAuthenticateEvent event) {
    if (done) {
        return;
    }

    done = true;

    final IdentityManager identityManager = partitionManager.createIdentityManager();
    final RelationshipManager relationshipManager = partitionManager.createRelationshipManager();

    User admin = new User("admin");

    admin.setEmail("[email protected]");
    admin.setFirstName("John");
    admin.setLastName("Doe");

    User nonAdmin = new User("joe");

    nonAdmin.setEmail("[email protected]");
    nonAdmin.setFirstName("Joe");
    nonAdmin.setLastName("Doe");

    identityManager.add(admin);
    identityManager.add(nonAdmin);
    identityManager.updateCredential(admin,
                                     new Password("admin"));
    identityManager.updateCredential(nonAdmin,
                                     new Password("joe"));

    Role roleSimple = new Role("simple");
    Role roleAdmin = new Role("admin");

    identityManager.add(roleSimple);
    identityManager.add(roleAdmin);

    relationshipManager.add(new Grant(admin,
                                      roleSimple));
    relationshipManager.add(new Grant(admin,
                                      roleAdmin));

    relationshipManager.add(new Grant(nonAdmin,
                                      roleSimple));
}
 

import org.picketlink.idm.credential.Password; //导入依赖的package包/类
/**
 * Creates example users so people can log in while trying out the app.
 */
public synchronized void create(@Observes PreAuthenticateEvent event) {
    if (done) {
        return;
    }

    done = true;

    final IdentityManager identityManager = partitionManager.createIdentityManager();
    final RelationshipManager relationshipManager = partitionManager.createRelationshipManager();

    User admin = new User("admin");

    admin.setEmail("[email protected]");
    admin.setFirstName("John");
    admin.setLastName("Doe");

    User nonAdmin = new User("joe");

    nonAdmin.setEmail("[email protected]");
    nonAdmin.setFirstName("Joe");
    nonAdmin.setLastName("Doe");

    identityManager.add(admin);
    identityManager.add(nonAdmin);
    identityManager.updateCredential(admin,
                                     new Password("admin"));
    identityManager.updateCredential(nonAdmin,
                                     new Password("123"));

    Role roleSimple = new Role("simple");
    Role roleAdmin = new Role("admin");

    identityManager.add(roleSimple);
    identityManager.add(roleAdmin);

    relationshipManager.add(new Grant(admin,
                                      roleSimple));
    relationshipManager.add(new Grant(admin,
                                      roleAdmin));
}