import org.bouncycastle.util.encoders.DecoderException; //导入依赖的package包/类
public JettyKeystoreConvertorBuilder setPrivateKeyFromPKCS8(InputStream inputStream, String algorithm) throws JettyKeystoreException {
    try {
        String contentKeyFile = IOUtils.toString(inputStream);

        Matcher contentKeyMatcher = PRIVATE_KEY_PATTERN.matcher(contentKeyFile);

        String contentKey;
        if (contentKeyMatcher.find()) {
            contentKey = contentKeyMatcher.group(1);
        } else {
            contentKey = contentKeyFile;
        }

        byte[] decodedKeyFile = Base64.decode(contentKey);

        KeyFactory keyFactory = KeyFactory.getInstance(algorithm);

        PKCS8EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(decodedKeyFile);
        privateKey = keyFactory.generatePrivate(privateKeySpec);

        return this;

    } catch (IOException | NoSuchAlgorithmException | InvalidKeySpecException | DecoderException e) {
        throw new JettyKeystoreException(JettyKeystoreException.ERROR_LOAD_PRIVATE_KEY_PKCS8, "Can not load private key (PKCS8)", e);
    }
}
 

import org.bouncycastle.util.encoders.DecoderException; //导入依赖的package包/类
/**
 * Returns the decrypted plaintext.
 *
 * @param protectedValue the cipher text read from the {@code nifi.properties} file
 * @return the raw value to be used by the application
 * @throws SensitivePropertyProtectionException if there is an error decrypting the cipher text
 */
@Override
public String unprotect(String protectedValue) throws SensitivePropertyProtectionException {
    if (protectedValue == null || protectedValue.trim().length() < MIN_CIPHER_TEXT_LENGTH) {
        throw new IllegalArgumentException("Cannot decrypt a cipher text shorter than " + MIN_CIPHER_TEXT_LENGTH + " chars");
    }

    if (!protectedValue.contains(DELIMITER)) {
        throw new IllegalArgumentException("The cipher text does not contain the delimiter " + DELIMITER + " -- it should be of the form Base64(IV) || Base64(cipherText)");
    }

    protectedValue = protectedValue.trim();

    final String IV_B64 = protectedValue.substring(0, protectedValue.indexOf(DELIMITER));
    byte[] iv = Base64.decode(IV_B64);
    if (iv.length < IV_LENGTH) {
        throw new IllegalArgumentException("The IV (" + iv.length + " bytes) must be at least " + IV_LENGTH + " bytes");
    }

    String CIPHERTEXT_B64 = protectedValue.substring(protectedValue.indexOf(DELIMITER) + 2);

    // Restore the = padding if necessary to reconstitute the GCM MAC check
    if (CIPHERTEXT_B64.length() % 4 != 0) {
        final int paddedLength = CIPHERTEXT_B64.length() + 4 - (CIPHERTEXT_B64.length() % 4);
        CIPHERTEXT_B64 = StringUtils.rightPad(CIPHERTEXT_B64, paddedLength, '=');
    }

    try {
        byte[] cipherBytes = Base64.decode(CIPHERTEXT_B64);

        cipher.init(Cipher.DECRYPT_MODE, this.key, new IvParameterSpec(iv));
        byte[] plainBytes = cipher.doFinal(cipherBytes);
        logger.debug(getName() + " decrypted a sensitive value successfully");
        return new String(plainBytes, StandardCharsets.UTF_8);
    } catch (BadPaddingException | IllegalBlockSizeException | DecoderException | InvalidAlgorithmParameterException | InvalidKeyException e) {
        final String msg = "Error decrypting a protected value";
        logger.error(msg, e);
        throw new SensitivePropertyProtectionException(msg, e);
    }
}
 

import org.bouncycastle.util.encoders.DecoderException; //导入依赖的package包/类
@Test
public void testGetOSCPInvalid() {
    try {
        // The encoded OCSP request is missing some chars at the end and is therefore invalid
        mvc.perform(get("/x509/api/certificates/ocsp/urn:mrn:mcl:ca:maritimecloud-idreg/MFUwUzBRME8wTTAJBgUrDgMCGgUABBQ6UIqQ34%2BgN2srrAjL6PckJ0ELZQQUxE5nZxstKKPxT9ruhJjPzxpwfFUCFCPUaD%2Fh4aw7GY%2F7bjSdgGf").header("Origin", "bla"));
        assertTrue("This shold not be reached, an exception should be thrown!", false);
    } catch (Exception e) {
        assertTrue(e.getCause() instanceof DecoderException);
    }
}
 

import org.bouncycastle.util.encoders.DecoderException; //导入依赖的package包/类
private void invalidTest(String data)
{
    try
    {
        UrlBase64.decode(data);
    }
    catch (DecoderException e)
    {
        return;
    }

    fail("invalid String data parsed");
}
 

import org.bouncycastle.util.encoders.DecoderException; //导入依赖的package包/类
private void invalidTest(String data)
{
    try
    {
        Hex.decode(data);
    }
    catch (DecoderException e)
    {
        return;
    }

    fail("invalid String data parsed");
}
 

import org.bouncycastle.util.encoders.DecoderException; //导入依赖的package包/类
private void invalidTest(String data)
{
    try
    {
        Base64.decode(data);
    }
    catch (DecoderException e)
    {
        return;
    }

    fail("invalid String data parsed");
}