How to use

decode

method

in

org.springframework.security.crypto.codec.Utf8

public static String convertPasswordToString(Object passObj) {
  Assert.notNull(passObj, "Password object to convert must not be null");
  if (passObj instanceof byte[]) {
    return Utf8.decode((byte[]) passObj);
  }
  else if (passObj instanceof String) {
    return (String) passObj;
  }
  else {
    throw new IllegalArgumentException(
        "Password object was not a String or byte array.");
  }
}

  private String encodePart(byte[] part) {
    return Utf8.decode(Base64.getEncoder().encode(part));
  }
}

  private String encodePart(byte[] part) {
    return Utf8.decode(Base64.getEncoder().encode(part));
  }
}

private String encode(byte[] digest) {
  if (this.encodeHashAsBase64) {
    return Utf8.decode(Base64.getEncoder().encode(digest));
  }
  else {
    return new String(Hex.encode(digest));
  }
}

private String encode(byte[] digest) {
  if (this.encodeHashAsBase64) {
    return Utf8.decode(Base64.getEncoder().encode(digest));
  }
  else {
    return new String(Hex.encode(digest));
  }
}

private String encode(byte[] digest) {
  if (this.encodeHashAsBase64) {
    return Utf8.decode(Base64.getEncoder().encode(digest));
  }
  else {
    return new String(Hex.encode(digest));
  }
}

private String encode(byte[] digest) {
  if (this.encodeHashAsBase64) {
    return Utf8.decode(Base64.getEncoder().encode(digest));
  }
  else {
    return new String(Hex.encode(digest));
  }
}

private String encode(CharSequence rawPassword, byte[] salt) {
  MessageDigest sha;
  try {
    sha = MessageDigest.getInstance("SHA");
    sha.update(Utf8.encode(rawPassword));
  }
  catch (java.security.NoSuchAlgorithmException e) {
    throw new IllegalStateException("No SHA implementation available!");
  }
  if (salt != null) {
    sha.update(salt);
  }
  byte[] hash = combineHashAndSalt(sha.digest(), (byte[]) salt);
  String prefix;
  if (salt == null || salt.length == 0) {
    prefix = forceLowerCasePrefix ? SHA_PREFIX_LC : SHA_PREFIX;
  }
  else {
    prefix = forceLowerCasePrefix ? SSHA_PREFIX_LC : SSHA_PREFIX;
  }
  return prefix + Utf8.decode(Base64.getEncoder().encode(hash));
}

public Token allocateToken(String extendedInformation) {
  Assert.notNull(extendedInformation,
      "Must provided non-null extendedInformation (but it can be empty)");
  long creationTime = new Date().getTime();
  String serverSecret = computeServerSecretApplicableAt(creationTime);
  String pseudoRandomNumber = generatePseudoRandomNumber();
  String content = Long.toString(creationTime) + ":" + pseudoRandomNumber + ":"
      + extendedInformation;
  // Compute key
  String sha512Hex = Sha512DigestUtils.shaHex(content + ":" + serverSecret);
  String keyPayload = content + ":" + sha512Hex;
  String key = Utf8.decode(Base64.getEncoder().encode(Utf8.encode(keyPayload)));
  return new DefaultToken(key, creationTime, extendedInformation);
}

public String decrypt(String encryptedText) {
  return Utf8.decode(encryptor.decrypt(Hex.decode(encryptedText)));
}

private String encode(CharSequence rawPassword, byte[] salt) {
  MessageDigest sha;
  try {
    sha = MessageDigest.getInstance("SHA");
    sha.update(Utf8.encode(rawPassword));
  }
  catch (java.security.NoSuchAlgorithmException e) {
    throw new IllegalStateException("No SHA implementation available!");
  }
  if (salt != null) {
    sha.update(salt);
  }
  byte[] hash = combineHashAndSalt(sha.digest(), (byte[]) salt);
  String prefix;
  if (salt == null || salt.length == 0) {
    prefix = forceLowerCasePrefix ? SHA_PREFIX_LC : SHA_PREFIX;
  }
  else {
    prefix = forceLowerCasePrefix ? SSHA_PREFIX_LC : SSHA_PREFIX;
  }
  return prefix + Utf8.decode(Base64.getEncoder().encode(hash));
}

public String decrypt(String encryptedText) {
  return Utf8.decode(encryptor.decrypt(Hex.decode(encryptedText)));
}

    Utf8.decode(Base64.getDecoder().decode(Utf8.encode(key))), ":");
Assert.isTrue(tokens.length >= 4, () -> "Expected 4 or more tokens but found "
    + tokens.length);

public Token allocateToken(String extendedInformation) {
  Assert.notNull(extendedInformation,
      "Must provided non-null extendedInformation (but it can be empty)");
  long creationTime = new Date().getTime();
  String serverSecret = computeServerSecretApplicableAt(creationTime);
  String pseudoRandomNumber = generatePseudoRandomNumber();
  String content = Long.toString(creationTime) + ":" + pseudoRandomNumber + ":"
      + extendedInformation;
  // Compute key
  String sha512Hex = Sha512DigestUtils.shaHex(content + ":" + serverSecret);
  String keyPayload = content + ":" + sha512Hex;
  String key = Utf8.decode(Base64.getEncoder().encode(Utf8.encode(keyPayload)));
  return new DefaultToken(key, creationTime, extendedInformation);
}

    Utf8.decode(Base64.getDecoder().decode(Utf8.encode(key))), ":");
Assert.isTrue(tokens.length >= 4, () -> "Expected 4 or more tokens but found "
    + tokens.length);

  @Test
  public void utf8EncodesAndDecodesCorrectly() throws Exception {
    byte[] bytes = Utf8.encode("6048b75ed560785c");
    assertThat(bytes).hasSize(16);
    assertThat(Arrays.equals("6048b75ed560785c".getBytes("UTF-8"), bytes)).isTrue();

    String decoded = Utf8.decode(bytes);

    assertThat(decoded).isEqualTo("6048b75ed560785c");
  }
}

  @Override
  public AuditEvent getAuditEvent() {

    String name = getAuthentication().getName();

    try {
      // Store hash of name, to conceal accidental entry of sensitive info
      // (e.g. password)
      name = Utf8.decode(Base64.encode(MessageDigest.getInstance("SHA-1").digest(Utf8.encode(name))));
    } catch (NoSuchAlgorithmException shouldNeverHappen) {
      name = "NOSHA";
    }

    return createAuditRecord(name, AuditEventType.UserNotFound, getOrigin(getAuthenticationDetails()), "");

  }
}

private String encode(byte[] digest) {
  if (this.encodeHashAsBase64) {
    return Utf8.decode(Base64.getEncoder().encode(digest));
  }
  else {
    return new String(Hex.encode(digest));
  }
}

private String encode(byte[] digest) {
  if (this.encodeHashAsBase64) {
    return Utf8.decode(Base64.getEncoder().encode(digest));
  }
  else {
    return new String(Hex.encode(digest));
  }
}

  @Override
  public byte[] decrypt(byte[] ciphertext) {

    Assert.notNull(ciphertext, "Ciphertext must not be null");
    Assert.isTrue(!ObjectUtils.isEmpty(ciphertext), "Ciphertext must not be empty");

    Plaintext plaintext = transitOperations.decrypt(keyName,
        Ciphertext.of(Utf8.decode(ciphertext)));

    return plaintext.getPlaintext();
  }
}