Java Code Examples for org.bouncycastle.util.encoders.Base64#encode()

protected byte[] perform(byte[] input) throws Exception {

		if( ! this.certAvailable.isSelected() )
			throw new IllegalArgumentException("No certificate available.");
		
		String padding = (String)paddings.getSelectedItem();
		Cipher cipher = Cipher.getInstance(String.format("%s/%s/%s", algorithm, cipherMode, padding));
        cipher.init(Cipher.ENCRYPT_MODE, this.cert.getPublicKey());
        
        String selectedInputMode = (String)inputMode.getSelectedItem();
        String selectedOutputMode = (String)outputMode.getSelectedItem();
        
        if( selectedInputMode.equals("Hex") )
        	input = Hex.decode(input);
        if( selectedInputMode.equals("Base64") )
        	input = Base64.decode(input);
      
		byte[] encrypted = cipher.doFinal(input);
		
		if( selectedOutputMode.equals("Hex") )
			encrypted = Hex.encode(encrypted);
		if( selectedOutputMode.equals("Base64") )
			encrypted = Base64.encode(encrypted);

		return encrypted;
	}
 

protected byte[] perform(byte[] input) throws Exception {

		if( ! this.keyAvailable.isSelected() )
			throw new IllegalArgumentException("No private key available.");
		
		String padding = (String)paddings.getSelectedItem();
		Cipher cipher = Cipher.getInstance(String.format("%s/%s/%s", algorithm, cipherMode, padding));
        cipher.init(Cipher.DECRYPT_MODE, this.selectedEntry.getPrivateKey());
        
        String selectedInputMode = (String)inputMode.getSelectedItem();
        String selectedOutputMode = (String)outputMode.getSelectedItem();
        
        if( selectedInputMode.equals("Hex") )
        	input = Hex.decode(input);
        if( selectedInputMode.equals("Base64") )
        	input = Base64.decode(input);
      
		byte[] encrypted = cipher.doFinal(input);
		
		if( selectedOutputMode.equals("Hex") )
			encrypted = Hex.encode(encrypted);
		if( selectedOutputMode.equals("Base64") )
			encrypted = Base64.encode(encrypted);

		return encrypted;
	}
 

/**
 * 加密
 * @param strMsg 明文
 * @return 加密后的byte数组(base64)
 * @since  1.0
 */
public byte[] EncryptMsg(String strMsg) {
    try {
        byte[] pInData = strMsg.getBytes("utf8");
        int nInLen = pInData.length;
        int nRemain = nInLen % 16;
        int nBlocks = (nInLen + 15) / 16;

        if (nRemain > 12 || nRemain == 0) {
            nBlocks += 1;
        }
        int nEncryptLen = nBlocks * 16;

        byte[] pData = Arrays.copyOf(pInData, nEncryptLen);

        byte[] lenbytes = CommonUtils.intToBytes(nInLen);

        for (int i = 0; i < 4; i++) {
            pData[nEncryptLen + i - 4] = lenbytes[i];
        }
        byte[] encrypted = AESUtils.encrypt(pData);
        return Base64.encode(encrypted);
    } catch (UnsupportedEncodingException e) {
        return new byte[]{};
    }
}
 

/**
 * queueEncrypt / queueDecryt works only for marshaled object.
 *
 * @param data
 * @param publicKey
 * @return
 * @throws IntegrationModuleException
 */
public byte[] queueEncrypt(byte[] data, PublicKey publicKey) throws IntegrationModuleException {

    String s = new String(data);
    s += encryptionSignature;
    data = s.getBytes();
    try {
        String key = publicKey.toString().substring(0, 16);
        final SecretKeySpec symKey = new SecretKeySpec(key.getBytes(), "AES");

        Cipher cipher = Cipher.getInstance("AES");

        int rest = 0;
        int length = 0;
        byte[] newbuf = null;

        if (cipher.getBlockSize() > 0) {
            rest = data.length % cipher.getBlockSize();
            length = data.length + (cipher.getBlockSize() - rest);

            newbuf = new byte[length];
            System.arraycopy(data, 0, newbuf, 0, data.length);
        } else {
            newbuf = new byte[data.length];
            System.arraycopy(data, 0, newbuf, 0, data.length);
        }

        cipher.init(Cipher.ENCRYPT_MODE, symKey);
        byte[] cipherData = cipher.doFinal(newbuf);

        return Base64.encode(cipherData);
    } catch (Throwable t) {
        Exceptionutils.errorHandler(t);
    }
    return null;
}
 

protected byte[] crypt(byte[] input, int cipherMode, String algorithm, String mode, String padding)
		throws Exception {
	byte[] key = keyTxt.getText();
	byte[] iv = ivTxt.getText();

	SecretKeySpec secretKeySpec = new SecretKeySpec(key, algorithm);
	IvParameterSpec ivSpec = new IvParameterSpec(iv);
	Cipher cipher = Cipher.getInstance(String.format("%s/%s/%s", algorithm, mode, padding));

       if( mode.equals("ECB") ) {
           cipher.init(cipherMode, secretKeySpec);
       } else {
           cipher.init(cipherMode, secretKeySpec, ivSpec);
       }

       String selectedInputMode = (String)inputMode.getSelectedItem();
       String selectedOutputMode = (String)outputMode.getSelectedItem();
       
       if( selectedInputMode.equals("Hex") )
       	input = Hex.decode(input);
       if( selectedInputMode.equals("Base64") )
       	input = Base64.decode(input);
     
	byte[] encrypted = cipher.doFinal(input);
	
	if( selectedOutputMode.equals("Hex") )
		encrypted = Hex.encode(encrypted);
	if( selectedOutputMode.equals("Base64") )
		encrypted = Base64.encode(encrypted);

	return encrypted;
}
 

public static void checkHash(byte[] blobHashValue, byte[] decompressedBlob) throws InvalidBlobContentConnectorException, TechnicalConnectorException {
   try {
      byte[] calculatedHashValue = buildHash(decompressedBlob);
      if (!Arrays.areEqual(blobHashValue, calculatedHashValue)) {
         String blobHashAsString = blobHashValue != null ? new String(Base64.encode(blobHashValue)) : "";
         String calculatedHashAsString = calculatedHashValue != null ? new String(Base64.encode(calculatedHashValue)) : "";
         throw new InvalidBlobContentConnectorException(InvalidBlobContentConnectorExceptionValues.HASH_VALUES_DIFFERENT, (Blob)null, decompressedBlob, new Object[]{blobHashAsString, calculatedHashAsString});
      }
   } catch (NoSuchAlgorithmException var5) {
      throw new TechnicalConnectorException(TechnicalConnectorExceptionValues.ERROR_GENERAL, var5, new Object[]{var5.getMessage()});
   }
}
 

private String generatePassword() throws ServerApiException {
    try {
        final SecureRandom randomGen = SecureRandom.getInstance("SHA1PRNG");
        final byte bytes[] = new byte[20];
        randomGen.nextBytes(bytes);
        return new String(Base64.encode(bytes), "UTF-8");
    } catch (NoSuchAlgorithmException | UnsupportedEncodingException e) {
        throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, "Failed to generate random password");
    }
}
 

public KeyResult getNewKey(GetNewKeyRequestContent request, byte[] kgssETK) throws TechnicalConnectorException {
   Credential encryptionCredential = Session.getInstance().getSession().getEncryptionCredential();
   Map<String, PrivateKey> decryptionKeys = Session.getInstance().getSession().getEncryptionPrivateKeys();
   GetNewKeyResponseContent response = this.getNewKey(request, encryptionCredential, decryptionKeys, kgssETK);
   byte[] keyResponse = response.getNewKey();
   String keyId = new String(Base64.encode(response.getNewKeyIdentifier()));
   return new KeyResult(new SecretKeySpec(keyResponse, "AES"), keyId);
}
 

private String generatePassword() throws ServerApiException {
    try {
        final SecureRandom randomGen = SecureRandom.getInstance("SHA1PRNG");
        final byte bytes[] = new byte[20];
        randomGen.nextBytes(bytes);
        return new String(Base64.encode(bytes), "UTF-8");
    } catch (NoSuchAlgorithmException | UnsupportedEncodingException e) {
        throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, "Failed to generate random password");
    }
}
 

@Override
public KeyResult getNewKey(GetNewKeyRequestContent request, UUID keystoreId, KeyStore keystore, String quality, String passPhrase, byte[] kgssETK) throws TechnicalConnectorException {
   Credential credential = new KeyStoreCredential(keystoreId, keystore, "authentication", passPhrase, quality);
   Map<String, PrivateKey> hokPrivateKeys = KeyManager.getDecryptionKeys(keystore, passPhrase.toCharArray());
   Crypto crypto = CryptoFactory.getCrypto(credential, hokPrivateKeys);

   GetNewKeyResponseContent response = this.getNewKey(request, crypto, credential, hokPrivateKeys, kgssETK);
   byte[] keyResponse = response.getNewKey();
   String keyId = new String(Base64.encode(response.getNewKeyIdentifier()));
   return new KeyResult(new SecretKeySpec(keyResponse, "AES"), keyId);
}
 

public static void checkHash(byte[] blobHashValue, byte[] decompressedBlob) throws InvalidBlobContentConnectorException, TechnicalConnectorException {
   try {
      byte[] calculatedHashValue = buildHash(decompressedBlob);
      if (!Arrays.areEqual(blobHashValue, calculatedHashValue)) {
         String blobHashAsString = blobHashValue != null ? new String(Base64.encode(blobHashValue)) : "";
         String calculatedHashAsString = calculatedHashValue != null ? new String(Base64.encode(calculatedHashValue)) : "";
         throw new InvalidBlobContentConnectorException(InvalidBlobContentConnectorExceptionValues.HASH_VALUES_DIFFERENT, (Blob)null, decompressedBlob, new Object[]{blobHashAsString, calculatedHashAsString});
      }
   } catch (NoSuchAlgorithmException var5) {
      throw new TechnicalConnectorException(TechnicalConnectorExceptionValues.ERROR_GENERAL, var5, new Object[]{var5.getMessage()});
   }
}
 

private String processDigest(byte[] data) throws TechnicalConnectorException {
   return new String(Base64.encode(ConnectorCryptoUtils.calculateDigest("SHA-256", data)));
}
 

private static String sealFolders(Crypto crypto, String folders, String hubIdPropKey, String hubAppIdPropKey) throws TechnicalConnectorException, UnsupportedEncodingException {
   byte[] encryptedMessage = crypto.seal(Crypto.SigningPolicySelector.WITH_NON_REPUDIATION, getHubEtk(hubIdPropKey, hubAppIdPropKey), folders.getBytes(Charset.UTF_8.getName()));
   encryptedMessage = Base64.encode(encryptedMessage);
   return new String(encryptedMessage);
}
 

private static String sealFolders(Crypto crypto, String folders, String hubIdPropKey, String hubAppIdPropKey) throws TechnicalConnectorException, UnsupportedEncodingException {
   byte[] encryptedMessage = crypto.seal(Crypto.SigningPolicySelector.WITH_NON_REPUDIATION, getHubEtk(hubIdPropKey, hubAppIdPropKey), folders.getBytes(Charset.UTF_8.getName()));
   encryptedMessage = Base64.encode(encryptedMessage);
   return new String(encryptedMessage);
}
 

private String processDigest(byte[] data) throws TechnicalConnectorException {
   return new String(Base64.encode(ConnectorCryptoUtils.calculateDigest("SHA-256", data)));
}
 

private static String sealFolders(Crypto crypto, String folders) throws TechnicalConnectorException, UnsupportedEncodingException {
   byte[] encryptedMessage = crypto.seal(Crypto.SigningPolicySelector.WITH_NON_REPUDIATION, getHubEtk(), folders.getBytes(Charset.UTF_8.getName()));
   encryptedMessage = Base64.encode(encryptedMessage);
   return new String(encryptedMessage);
}
 

private static String sealFolders(Crypto crypto, String folders, String hubIdPropKey, String hubAppIdPropKey) throws TechnicalConnectorException, UnsupportedEncodingException {
   byte[] encryptedMessage = crypto.seal(Crypto.SigningPolicySelector.WITH_NON_REPUDIATION, getHubEtk(hubIdPropKey, hubAppIdPropKey), folders.getBytes(Charset.UTF_8.getName()));
   encryptedMessage = Base64.encode(encryptedMessage);
   return new String(encryptedMessage);
}
 

private static String sealFolders(Crypto crypto, String folders, Long hubId, String hubApplication, EncryptionToken hubEtk) throws TechnicalConnectorException, UnsupportedEncodingException {
   byte[] encryptedMessage = crypto.seal(Crypto.SigningPolicySelector.WITH_NON_REPUDIATION, hubEtk, folders.getBytes(Charset.UTF_8.getName()));
   encryptedMessage = Base64.encode(encryptedMessage);
   return new String(encryptedMessage);
}
 

@RequestMapping(value = "tsa", method = RequestMethod.POST)
public void tsa(HttpServletRequest req, HttpServletResponse resp) {
    String remoteIp = req.getRemoteAddr();
    try {
        if (!TsaTranserConstant.TIMESTAMP_QUERY_CONTENT_TYPE.equalsIgnoreCase(req.getContentType())) {
            resp.sendError(HttpServletResponse.SC_BAD_REQUEST, "content type should be " + TsaTranserConstant.TIMESTAMP_QUERY_CONTENT_TYPE);
            return;
        }
        if (!TsaTranserConstant.TIMESTAMP_QUERY_CONTENT_TYPE.equalsIgnoreCase(req.getContentType())) {
            resp.sendError(HttpServletResponse.SC_BAD_REQUEST, "content type should be " + TsaTranserConstant.TIMESTAMP_QUERY_CONTENT_TYPE);
            return;
        }
        if (littleTsaConfig.isUsernameEnabled()) {
            if (!littleTsaConfig.getTsaUsername().equals(req.getHeader("username")) || !littleTsaConfig.getTsaPassword().equals(req.getHeader("password"))) {
                resp.sendError(HttpServletResponse.SC_BAD_REQUEST, "username and password must match");
                return;
            }
        }
        if (req.getContentLength() == 0) {
            LOG.error("timestamp request is empty");
            resp.sendError(HttpServletResponse.SC_BAD_REQUEST, "timestamp request is empty");
            return;
        }
        boolean isBase64 = TsaTranserConstant.isBase64(req.getHeader(TsaTranserConstant.TRANSFER_ENCODING_HEADER));
        TimeStampRequest timeStampRequest = readRequest(req, isBase64);

        LOG.debug("TS Request received from {}", remoteIp);
        TimeStampResponse stampResponse = timeStampService.timestamp(timeStampRequest);
        if (stampResponse == null) {
            LOG.warn("TS Request received from {} is not acceptable", remoteIp);
            resp.sendError(HttpServletResponse.SC_NOT_ACCEPTABLE, "Could not generate timestamp response");
            return;
        }
        if (stampResponse.getTimeStampToken() == null) {
            LOG.warn("TS Request received from {} is not acceptable", remoteIp);
            resp.sendError(HttpServletResponse.SC_NOT_ACCEPTABLE, "Could not generate timestamp response");
            return;
        }
        byte[] response = stampResponse.getEncoded();
        if (isBase64) {
            resp.setHeader(TsaTranserConstant.TRANSFER_ENCODING_HEADER, TsaTranserConstant.TRANSFER_ENCODING_BASE64);
            response = Base64.encode(response);
            LOG.debug("Responding to {} is in base64", remoteIp);
        } else {
            resp.setHeader(TsaTranserConstant.TRANSFER_ENCODING_HEADER, TsaTranserConstant.TRANSFER_ENCODING_BINARY);
            LOG.debug("Responding to %s is in binary mode", remoteIp);
        }

        resp.setStatus(HttpServletResponse.SC_OK);
        resp.setContentType(TsaTranserConstant.TIMESTAMP_REPLY_CONTENT_TYPE);
        resp.setContentLength(response.length);
        ServletOutputStream outputStream = resp.getOutputStream();
        outputStream.write(response);
        outputStream.close();
    } catch (Exception e) {
        LOG.warn("TS Request received from {} is not acceptable", remoteIp);
        try {
            resp.sendError(HttpServletResponse.SC_NOT_ACCEPTABLE, "Could not generate timestamp response");
        } catch (IOException ex) {
            LOG.error("error,{}", ex);
        }
    }
}
 

/**
 * <p>
 * 二进制数据编码为BASE64字符串
 * </p>
 * 
 * @param bytes
 * @return
 * @throws Exception
 */
public static String encode(byte[] bytes) throws Exception {
    return new String(Base64.encode(bytes));
}