org.springframework.security.crypto.codec.Utf8 Java Examples

@Override
public TokenData createToken(TokenConfiguration config) {
    final long creationTime = System.currentTimeMillis();

    byte[] serverSecret = computeServerSecretApplicableAt(creationTime);
    byte[] content = contentPack(creationTime,
            generateRandom(),
            serverSecret,
            Utf8.encode(pack(config.getUserName(), config.getDeviceHash())));

    byte[] sign = sign(content);
    ByteBuffer buffer = ByteBuffer.allocate(1 + sign.length + 1 + content.length);
    store(buffer, content);
    store(buffer, sign);
    String key = base32.encodeAsString(buffer.array());

    return new TokenDataImpl(creationTime,
            TokenUtils.getKeyWithTypeAndToken(TYPE, key),
            config.getUserName(),
            config.getDeviceHash());
}
 

@Override
public TokenData getToken(String tokenString) {
    final String key = unwrapToken(tokenString);
    if (key.isEmpty()) {
        return null;
    }
    byte[] decodedKey = base32.decode(key);
    byte[] currentSignature;
    final long creationTime;
    byte[] random;
    byte[] payload;
    {
        byte[] content;
        {
            ByteBuffer buffer = ByteBuffer.wrap(decodedKey);
            content = restoreArray(buffer);
            currentSignature = restoreArray(buffer);
        }

        ByteBuffer contentBuffer = ByteBuffer.wrap(content);
        creationTime = contentBuffer.getLong();
        random = restoreArray(contentBuffer);
        // we need to skip secret
        restoreArray(contentBuffer);
        payload = restoreArray(contentBuffer);
    }

    final byte[] serverSecret = computeServerSecretApplicableAt(creationTime);

    // Verification
    byte[] expectedSign = sign(contentPack(creationTime, random, serverSecret, payload));
    Assert.isTrue(Arrays.equals(expectedSign, currentSignature), "Key verification failure");

    String[] unpack = unpack(Utf8.decode(payload));
    return new TokenDataImpl(creationTime, TokenUtils.getKeyWithTypeAndToken(TYPE, key), unpack[0], unpack[1]);
}
 

public MessageDigestPasswordEncoder(String algorithm, CharSequence secret) {
    try {
        messageDigest = MessageDigest.getInstance(algorithm);
    } catch (NoSuchAlgorithmException e) {
        throw new IllegalStateException("No such hashing algorithm", e);
    }

    this.secret = Utf8.encode(secret);
    this.saltGenerator = KeyGenerators.secureRandom();
}
 

public String encrypt(String text) {
    return new String(Hex.encode(encryptor.encrypt(Utf8.encode(text))));
}
 

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

private byte[] computeServerSecretApplicableAt(long time) {
    return Utf8.encode(serverSecret + ":" + (time % serverInteger));
}
 

@Override
public byte[] encrypt(byte[] plaintext) {

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

	Ciphertext ciphertext = this.transitOperations.encrypt(this.keyName, Plaintext.of(plaintext));

	return Utf8.encode(ciphertext.getCiphertext());
}
 

@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 = this.transitOperations.decrypt(this.keyName, Ciphertext.of(Utf8.decode(ciphertext)));

	return plaintext.getPlaintext();
}
 

/**
 * Encrypt the raw text string.
 *
 * @param text text
 */
@Override
public String encrypt(String text) {
    return Base64.toBase64String(bytesEncryptor.encrypt(Utf8.encode(text)));
}
 

/**
 * Decrypt the encrypted text string.
 *
 * @param encryptedText text
 */
@Override
public String decrypt(String encryptedText) {
    return Utf8.decode(bytesEncryptor.decrypt(Base64.decode(encryptedText)));
}