Java Base64.decode方法代码示例

import org.apache.axiom.om.util.Base64; //导入方法依赖的package包/类
public static PrivateKey getSamplePrivateKey() throws Exception {
    // Read in the key into a String
    StringBuilder pkcs8Lines = new StringBuilder();
    BufferedReader rdr = new BufferedReader(new StringReader(PRIVATE_KEY));
    String line;
    while ((line = rdr.readLine()) != null) {
        pkcs8Lines.append(line);
    }

    // Remove the "BEGIN" and "END" lines, as well as any whitespace

    String pkcs8Pem = pkcs8Lines.toString();
    pkcs8Pem = pkcs8Pem.replace("-----BEGIN PRIVATE KEY-----", "");
    pkcs8Pem = pkcs8Pem.replace("-----END PRIVATE KEY-----", "");
    pkcs8Pem = pkcs8Pem.replaceAll("\\s+", "");

    // Base64 decode the result

    byte[] pkcs8EncodedBytes = Base64.decode(pkcs8Pem);

    // extract the private key

    PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(pkcs8EncodedBytes);
    KeyFactory kf = KeyFactory.getInstance("RSA");
    return kf.generatePrivate(keySpec);
}
 

import org.apache.axiom.om.util.Base64; //导入方法依赖的package包/类
/**
 * Generate thumbprint of certificate
 *
 * @param encodedCert Base64 encoded certificate
 * @return Certificate thumbprint
 * @throws java.security.NoSuchAlgorithmException Unsupported hash algorithm
 */
public static String generateThumbPrint(String encodedCert) throws NoSuchAlgorithmException {

    if (encodedCert != null) {
        MessageDigest digestValue = null;
        digestValue = MessageDigest.getInstance("SHA-1");
        byte[] der = Base64.decode(encodedCert);
        digestValue.update(der);
        byte[] digestInBytes = digestValue.digest();
        String publicCertThumbprint = hexify(digestInBytes);
        return publicCertThumbprint;
    } else {
        String errorMsg = "Invalid encoded certificate: \'NULL\'";
        log.debug(errorMsg);
        throw new IllegalArgumentException(errorMsg);
    }
}
 

import org.apache.axiom.om.util.Base64; //导入方法依赖的package包/类
/**
 * @param encodedCert
 * @return
 * @throws CertificateException
 */
public static CertData getCertData(String encodedCert) throws CertificateException {

    if (encodedCert != null) {
        byte[] bytes = Base64.decode(encodedCert);
        CertificateFactory factory = CertificateFactory.getInstance("X.509");
        X509Certificate cert = (X509Certificate) factory
                .generateCertificate(new ByteArrayInputStream(bytes));
        Format formatter = new SimpleDateFormat("dd/MM/yyyy");
        return fillCertData(cert, formatter);
    } else {
        String errorMsg = "Invalid encoded certificate: \'NULL\'";
        log.debug(errorMsg);
        throw new IllegalArgumentException(errorMsg);
    }
}
 

import org.apache.axiom.om.util.Base64; //导入方法依赖的package包/类
/**
 * Generate thumbprint of certificate
 *
 * @param encodedCert Base64 encoded certificate
 * @return Decoded <code>Certificate</code>
 * @throws java.security.cert.CertificateException Error when decoding certificate
 */
public static Certificate decodeCertificate(String encodedCert) throws CertificateException {

    if (encodedCert != null) {
        byte[] bytes = Base64.decode(encodedCert);
        CertificateFactory factory = CertificateFactory.getInstance("X.509");
        X509Certificate cert = (X509Certificate) factory
                .generateCertificate(new ByteArrayInputStream(bytes));
        return cert;
    } else {
        String errorMsg = "Invalid encoded certificate: \'NULL\'";
        log.debug(errorMsg);
        throw new IllegalArgumentException(errorMsg);
    }
}
 

import org.apache.axiom.om.util.Base64; //导入方法依赖的package包/类
/**
 * decode the base64 encoded string
 * @param encodedString
 * @return
 */
public static String decodeBase64(String encodedString){
    // decode it and extract username and password
    byte[] decodedAuthHeader = Base64.decode(encodedString.split(" ")[1]);
    String authHeader = new String(decodedAuthHeader);
    String userName = authHeader.split(":")[0];
    return userName;
}
 

import org.apache.axiom.om.util.Base64; //导入方法依赖的package包/类
public static javax.activation.DataHandler convertToBase64Binary(String s) {
    // reusing the byteArrayDataSource from the Axiom classes
    if ((s == null) || s.equals("")){
        return null;
    }
    ByteArrayDataSource byteArrayDataSource = new ByteArrayDataSource(
            Base64.decode(s)
    );
    return new DataHandler(byteArrayDataSource);
}
 

import org.apache.axiom.om.util.Base64; //导入方法依赖的package包/类
public boolean isAuthenticated(Message message, ClassResourceInfo classResourceInfo) {
    // extract authorization header and authenticate.
    // get the map of protocol headers
    Map protocolHeaders = (TreeMap) message.get(Message.PROTOCOL_HEADERS);
    // get the value for Authorization Header
    List authzHeaders = (ArrayList) protocolHeaders
            .get(EntitlementEndpointConstants.AUTHORIZATION_HEADER);
    if (authzHeaders != null) {
        // get the authorization header value, if provided
        String authzHeader = (String) authzHeaders.get(0);

        // decode it and extract username and password
        byte[] decodedAuthHeader = Base64.decode(authzHeader.split(" ")[1]);
        String authHeader = new String(decodedAuthHeader);
        String userName = authHeader.split(":")[0];
        String password = authHeader.split(":")[1];
        if (userName != null && password != null) {
            String tenantDomain = MultitenantUtils.getTenantDomain(userName);
            String tenantLessUserName = MultitenantUtils.getTenantAwareUsername(userName);

            try {
                // get super tenant context and get realm service which is an osgi service
                RealmService realmService = (RealmService) PrivilegedCarbonContext
                        .getThreadLocalCarbonContext().getOSGiService(RealmService.class);
                if (realmService != null) {
                    int tenantId = realmService.getTenantManager().getTenantId(tenantDomain);
                    if (tenantId == -1) {
                        log.error("Invalid tenant domain " + tenantDomain);
                        return false;
                    }
                    // get tenant's user realm
                    UserRealm userRealm = realmService.getTenantUserRealm(tenantId);
                    boolean authenticated = userRealm.getUserStoreManager().authenticate(
                            tenantLessUserName, password);
                    if (authenticated) {
                        // authentication success. set the username for authorization header and
                        // proceed the REST call
                        authzHeaders.set(0, userName);
                        return true;
                    } else {
                        log.error("Authentication failed for the user: " + tenantLessUserName
                                + "@" + tenantDomain);
                        return false;
                    }
                } else {
                    log.error("Error in getting Realm Service for user: " + userName);
                    return false;
                }
            } catch (UserStoreException e) {
                log.error("Internal server error while authenticating the user.");
                return false;
            }
        } else {
            log.error("Authentication required for this resource. " +
                            "Username or password not provided.");
            return false;
        }
    } else {
        log.error("Authentication required for this resource. " +
                      "Authorization header not present in the request.");
        return false;
    }

}
 

import org.apache.axiom.om.util.Base64; //导入方法依赖的package包/类
public void addKeyStore(String fileData, String filename, String password, String provider,
                        String type, String pvtkeyPass) throws SecurityConfigException {
    byte[] content = Base64.decode(fileData);
    addKeyStore(content, filename, password, provider, type, pvtkeyPass);
}
 

import org.apache.axiom.om.util.Base64; //导入方法依赖的package包/类
public void addTrustStore(String fileData, String filename, String password, String provider,
                          String type) throws SecurityConfigException {
    byte[] content = Base64.decode(fileData);
    addTrustStore(content, filename, password, provider, type);
}
 

import org.apache.axiom.om.util.Base64; //导入方法依赖的package包/类
public static Object processObject(OMElement omElement,
                                   Class classType,
                                   MultirefHelper helper,
                                   boolean isArrayType,
                                   ObjectSupplier objectSupplier,
                                   Type generictype) throws AxisFault {
    boolean hasRef = false;
    OMAttribute omatribute = MultirefHelper.processRefAtt(omElement);
    String ref = null;
    if (omatribute != null) {
        hasRef = true;
        ref = MultirefHelper.getAttvalue(omatribute);
    }
    if (OMElement.class.isAssignableFrom(classType)) {
        if (hasRef) {
            OMElement elemnt = helper.getOMElement(ref);
            if (elemnt == null) {
                return helper.processOMElementRef(ref);
            } else {
                return elemnt;
            }
        } else
            return omElement;
    } else {
        if (hasRef) {
            if (helper.getObject(ref) != null) {
                return helper.getObject(ref);
            } else {
                return helper.processRef(classType, ref, objectSupplier);
            }
        } else {
            OMAttribute attribute = omElement.getAttribute(
                    new QName("http://www.w3.org/2001/XMLSchema-instance", "nil", "xsi"));
            if (attribute != null) {
                return null;
            }
            if (SimpleTypeMapper.isSimpleType(classType)) {
                if (isArrayType && "byte".equals(classType.getName())) {
                    String value = omElement.getText();
                    return Base64.decode(value);
                } else {
                    return getSimpleTypeObjectChecked(classType, omElement);
                }
            } else if (SimpleTypeMapper.isCollection(classType)) {
                if (generictype != null && (generictype instanceof ParameterizedType)) {
                    ParameterizedType aType = (ParameterizedType) generictype;
                    Type[] parameterArgTypes = aType.getActualTypeArguments();
                    Type parameter = parameterArgTypes[0];
                    Iterator parts = omElement.getChildElements();
                    return ProcessGenericsElement((Class) parameter, omElement, helper, parts, objectSupplier, generictype);
                }
                return SimpleTypeMapper.getArrayList(omElement);
            } else if (SimpleTypeMapper.isDataHandler(classType)) {
                return SimpleTypeMapper.getDataHandler(omElement);
            } else {
                return BeanUtil.deserialize(classType, omElement, objectSupplier, null);
            }
        }
    }
}