How to use

ClearPasswordSpec

in

org.wildfly.security.password.spec

  private static PasswordSpec decodeClearPasswordSpec(ByteIterator iterator) {
    return new ClearPasswordSpec(iterator.asUtf8String().drainToString().toCharArray());
  }
}

UnixSHACryptPasswordImpl(final String algorithm, final ClearPasswordSpec spec) throws NoSuchAlgorithmException {
  this(algorithm, spec.getEncodedPassword());
}

final ClearPasswordSpec spec = clearFactory.getKeySpec(clearFactory.translate(twoWayPassword), ClearPasswordSpec.class);
if (matchParameters != null) {
  return passwordType.cast(passwordFactory.generatePassword(new EncryptablePasswordSpec(spec.getEncodedPassword(), generateParameters)));
} else {
  return passwordType.cast(passwordFactory.generatePassword(spec));
  return passwordType.cast(passwordFactory.generatePassword(new EncryptablePasswordSpec(password, generateParameters)));
} else {
  return passwordType.cast(passwordFactory.generatePassword(new ClearPasswordSpec(password)));

MaskedPasswordImpl(final String algorithm, final ClearPasswordSpec keySpec) throws InvalidKeySpecException {
  this(algorithm, keySpec.getEncodedPassword());
}

<S extends KeySpec> S getKeySpec(final Class<S> keySpecType) throws InvalidKeySpecException {
  if (keySpecType.isAssignableFrom(ClearPasswordSpec.class)) {
    final char[] password = getPassword();
    return keySpecType.cast(new ClearPasswordSpec(password.clone()));
  }
  throw new InvalidKeySpecException();
}

UnixDESCryptPasswordImpl(final ClearPasswordSpec spec) throws InvalidKeySpecException, InvalidKeyException {
  this((short) (ThreadLocalRandom.current().nextInt() & 0xfff), spec.getEncodedPassword());
}

<S extends KeySpec> S getKeySpec(final Class<S> keySpecType) throws InvalidKeySpecException {
  if (keySpecType.isAssignableFrom(MaskedPasswordSpec.class)) {
    return keySpecType.cast(new MaskedPasswordSpec(initialKeyMaterial.clone(), iterationCount, salt.clone(), maskedPasswordBytes.clone()));
  } else if (keySpecType.isAssignableFrom(ClearPasswordSpec.class)) {
    return keySpecType.cast(new ClearPasswordSpec(unmask(algorithm, initialKeyMaterial, iterationCount, salt, maskedPasswordBytes)));
  } else {
    throw new InvalidKeySpecException();
  }
}

BSDUnixDESCryptPasswordImpl(final ClearPasswordSpec passwordSpec) throws InvalidKeySpecException {
  this(passwordSpec.getEncodedPassword(), ThreadLocalRandom.current().nextInt() & 0xffffff, DEFAULT_ITERATION_COUNT);
}

  passwordSpec = new ClearPasswordSpec(accountEntry.getPasswordRepresentation().toCharArray());
} else {
  passwordFactory = getPasswordFactory(ALGORITHM_DIGEST_MD5);

SimpleDigestPasswordImpl(final String algorithm, final ClearPasswordSpec spec) throws InvalidKeySpecException {
  this(algorithm, getDigestOfKS(algorithm, spec.getEncodedPassword()));
}

if (plainText) {
  passwordFactory = getPasswordFactory(ALGORITHM_CLEAR);
  passwordSpec = new ClearPasswordSpec(accountEntry.getPasswordRepresentation().toCharArray());
} else {
  passwordFactory = getPasswordFactory(ALGORITHM_DIGEST_MD5);

ScramDigestPasswordImpl(final String algorithm, final ClearPasswordSpec spec) throws InvalidKeySpecException, NoSuchAlgorithmException, InvalidKeyException {
  this(algorithm, spec.getEncodedPassword(), PasswordUtil.generateRandomSalt(DEFAULT_SALT_SIZE), DEFAULT_ITERATION_COUNT);
}

passwordSpec = new ClearPasswordSpec(decoder.decodeOctetStringAsString().toCharArray());
break;

BCryptPasswordImpl(final ClearPasswordSpec clearPasswordSpec) {
  this.salt = PasswordUtil.generateRandomSalt(BCRYPT_SALT_SIZE);
  this.iterationCount = DEFAULT_ITERATION_COUNT;
  this.hash = bcrypt(this.iterationCount, this.salt, getNormalizedPasswordBytes(clearPasswordSpec.getEncodedPassword()));
}

  passwordSpec = new ClearPasswordSpec(clear);
} else {
  return null;

SunUnixMD5CryptPasswordImpl(final ClearPasswordSpec spec) throws NoSuchAlgorithmException {
  this.algorithm = ALGORITHM_SUN_CRYPT_MD5;
  this.salt = PasswordUtil.generateRandomSalt(DEFAULT_SALT_SIZE);
  this.iterationCount = DEFAULT_ITERATION_COUNT;
  this.hash = sunMD5Crypt(algorithm, getNormalizedPasswordBytes(spec.getEncodedPassword()), salt, iterationCount);
}

try {
  PasswordFactory factory = PasswordFactory.getInstance(ClearPassword.ALGORITHM_CLEAR, providers);
  return Assert.assertNotNull(factory.generatePassword(new ClearPasswordSpec(finalPassword)).castAs(ClearPassword.class));
} catch (InvalidKeySpecException | NoSuchAlgorithmException cause) {
  throw xmlLog.xmlFailedToCreateCredential(location, cause);

SaltedSimpleDigestPasswordImpl(final String algorithm, final ClearPasswordSpec spec) throws InvalidKeySpecException {
  this.algorithm = algorithm;
  this.salt = PasswordUtil.generateRandomSalt(DEFAULT_SALT_SIZE);
  try {
    this.digest = digestOf(algorithm, salt, spec.getEncodedPassword());
  } catch (NoSuchAlgorithmException e) {
    throw log.invalidKeySpecNoSuchMessageDigestAlgorithm(algorithm);
  }
}

  private static PasswordSpec decodeClearPasswordSpec(ByteIterator iterator) {
    return new ClearPasswordSpec(iterator.asUtf8String().drainToString().toCharArray());
  }
}

UnixMD5CryptPasswordImpl(final ClearPasswordSpec spec) throws NoSuchAlgorithmException {
  this.salt = PasswordUtil.generateRandomSalt(SALT_SIZE);
  this.hash = encode(getNormalizedPasswordBytes(spec.getEncodedPassword()), this.salt);
}