public static byte[] decode(String s, int flags) { boolean websafeDesired = true; if (getSdkVersion() >= 8) { int newFlags = URL_SAFE; if ((flags & NO_PADDING) != 0) { newFlags = URL_SAFE | NO_PADDING; } if ((flags & URL_SAFE) != 0) { newFlags |= 8; } return Base64.decode(s, newFlags); } boolean paddingDesired; if ((flags & NO_PADDING) == 0) { paddingDesired = true; } else { paddingDesired = false; } if ((flags & URL_SAFE) == 0) { websafeDesired = false; } if (websafeDesired) { return Base64.decodeWebSafe(s); } return Base64.decode(s); }
public byte[] new_decrypt_cn(E_CODE paramE_CODE, byte[] paramArrayOfByte) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeySpecException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException { byte[] localObject = null; if (paramE_CODE == E_CODE.RSA) { if (rsa_key.length() > 2) { Cipher localCipher; byte[] arrayOfByte = new byte[0]; // PublicKey localPublicKey = KeyFactory.getInstance("RSA").generatePublic(new // X509EncodedKeySpec(Base64.decodeBase64(rsa_key))); PublicKey localPublicKey = KeyFactory.getInstance("RSA") .generatePublic(new X509EncodedKeySpec(Base64.decode(rsa_key, Base64.DEFAULT))); System.out.println("key length-" + (Base64.decode(rsa_key, Base64.DEFAULT)).length); System.out.println("data length-" + paramArrayOfByte.length); localCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding"); localCipher.init(Cipher.DECRYPT_MODE, localPublicKey); // localCipher.init(Cipher.ENCRYPT_MODE, localPublicKey); arrayOfByte = localCipher.doFinal(paramArrayOfByte); // int oldLength; // for (int i = 0; i < paramArrayOfByte.length; i += 8) { // byte[] temp = localCipher.doFinal(paramArrayOfByte, i, i + 8); // oldLength = arrayOfByte.length; // arrayOfByte = Arrays.copyOf(arrayOfByte, temp.length+arrayOfByte.length); // System.arraycopy(temp, 0, arrayOfByte, oldLength, temp.length); // } // arrayOfByte = paramArrayOfByte; return arrayOfByte; } } else if (paramE_CODE == E_CODE.RSA_EP) { if (rsa_ep_key.length() >= 2) { // PrivateKey localPrivateKey = KeyFactory.getInstance("RSA").generatePrivate(new // PKCS8EncodedKeySpec(Base64.decodeBase64(rsa_ep_key))); PrivateKey localPrivateKey = KeyFactory.getInstance("RSA") .generatePrivate( new PKCS8EncodedKeySpec(Base64.decode(rsa_ep_key, Base64.DEFAULT))); Cipher localCipher2 = Cipher.getInstance("RSA/ECB/PKCS1Padding"); localCipher2.init(2, localPrivateKey); localObject = localCipher2.doFinal(paramArrayOfByte); } } else if (paramE_CODE == E_CODE.AES) { // SecretKeySpec localSecretKeySpec = new // SecretKeySpec(Base64.decodeBase64(aes_key.getBytes()), "AES"); // byte[] arrayOfByte1 = Base64.decodeBase64(paramArrayOfByte); SecretKeySpec localSecretKeySpec = new SecretKeySpec(Base64.decode(aes_key.getBytes(), Base64.DEFAULT), "AES"); byte[] arrayOfByte1 = Base64.decode(paramArrayOfByte, Base64.DEFAULT); Cipher localCipher1 = Cipher.getInstance("AES/ECB/PKCS5Padding"); localCipher1.init(Cipher.DECRYPT_MODE, localSecretKeySpec); byte[] arrayOfByte2 = localCipher1.doFinal(arrayOfByte1); localObject = arrayOfByte2; } return localObject; }
/** * Get the signing key unique to this installation, or create it if it doesn't exist. The purpose * of this key is to allow signing of backup files (and any other such files) to ensure they are * not modified by some other program. Of course, if the other program has root then it can modify * or read this key anyway, so all bets are off. * * @return secret key for signing and verification */ public SecretKey getOrCreateSigningKey() { String signingKey = this.prefs.getString(BACKUP_SIGNING_KEY, null); SecretKey secretKey = null; if (signingKey != null) { secretKey = new SecretKeySpec( Base64.decode(signingKey, Base64.DEFAULT), 0, Base64.decode(signingKey, Base64.DEFAULT).length, "HmacSHA1"); } else { // supporting multiple algorithms would be good, but then we also need to store the key // type... try { secretKey = KeyGenerator.getInstance("HmacSHA1").generateKey(); } catch (NoSuchAlgorithmException e) { } Editor editor = this.prefs.edit(); editor.putString( BACKUP_SIGNING_KEY, Base64.encodeToString(secretKey.getEncoded(), Base64.DEFAULT)); editor.commit(); } return secretKey; }
@Kroll.method public String decode(HashMap args) { // decode string back to plain text // KrollDict arg = new KrollDict(args); String txt = arg.getString("cipherText"); byte[] bytesEncoded = Base64.decode(txt, 0); String keyString = arg.getString("privateKey"); PrivateKey key; try { byte[] encodedKey = Base64.decode(keyString, 0); PKCS8EncodedKeySpec x509KeySpec = new PKCS8EncodedKeySpec(encodedKey); KeyFactory keyFact = KeyFactory.getInstance("RSA", "BC"); key = keyFact.generatePrivate(x509KeySpec); } catch (Exception e) { return "error key"; } byte[] decodedBytes = null; try { Cipher c = Cipher.getInstance("RSA"); c.init(Cipher.DECRYPT_MODE, key); decodedBytes = c.doFinal(bytesEncoded); } catch (Exception e) { Log.e(TAG, "RSA decryption error " + e.toString()); return "error"; } return new String(decodedBytes); }
public CryptEngineImpl(Context ctx) throws Exception { // Получаем действующее хранилище IKeyStorage storage = KeyStorageFactory.getKeyStorage(ctx); Log.v("TFORWARD.CryptEngineImpl", "Decoding public key..."); byte[] publicKey = Base64.decode(storage.getKey(IKeyStorage.PUBLIC_KEY_TYPE), Base64.DEFAULT); Log.v("TFORWARD.CryptEngineImpl", "Decoding ASN1 Structure"); ASN1InputStream asnStream = new ASN1InputStream(publicKey); ASN1Sequence sequence = null; try { Log.v("TFORWARD.CryptEngineImpl", "Reading ASN1 Sequence"); sequence = (ASN1Sequence) asnStream.readObject(); } finally { asnStream.close(); } Log.v("TFORWARD.CryptEngineImpl", "Creating certificate. " + sequence.size()); Certificate certificate = Certificate.getInstance(sequence); SubjectPublicKeyInfo publicKeyInfo = certificate.getSubjectPublicKeyInfo(); RSAPublicKey publicKeyStructure = RSAPublicKey.getInstance(publicKeyInfo.parsePublicKey()); BigInteger mod = publicKeyStructure.getModulus(); BigInteger pubExp = publicKeyStructure.getPublicExponent(); publicRsaKey = new RSAKeyParameters(false, mod, pubExp); // ------------------------ PRIVATE KEY -------------------------------- byte[] privateKeyData = Base64.decode(storage.getKey(IKeyStorage.SECRET_KEY_TYPE), Base64.DEFAULT); asnStream = new ASN1InputStream(privateKeyData); ASN1Sequence asnSequence = null; try { asnSequence = (ASN1Sequence) asnStream.readObject(); } finally { asnStream.close(); } RSAPrivateKey privateKey = RSAPrivateKey.getInstance(asnSequence); privateRsaKey = new RSAPrivateCrtKeyParameters( privateKey.getModulus(), privateKey.getPublicExponent(), privateKey.getPrivateExponent(), privateKey.getPrime1(), privateKey.getPrime2(), privateKey.getExponent1(), privateKey.getExponent2(), privateKey.getCoefficient()); RSAEngine engine = new RSAEngine(); digest = new MD5Digest(); cipher = new PKCS1Encoding(engine); }
/** * Constructs a new bundle of ciphertext and IV from a string of the format <code> * base64(iv):base64(ciphertext)</code>. * * @param base64IvAndCiphertext A string of the format <code>iv:ciphertext</code> The IV and * ciphertext must each be base64-encoded. */ public CipherTextIvMac(String base64IvAndCiphertext) { String[] civArray = base64IvAndCiphertext.split(":"); if (civArray.length != 3) { throw new IllegalArgumentException("Cannot parse iv:ciphertext:mac"); } else { iv = Base64.decode(civArray[0], BASE64_FLAGS); mac = Base64.decode(civArray[1], BASE64_FLAGS); cipherText = Base64.decode(civArray[2], BASE64_FLAGS); } }
@Override public void run() { Looper.prepare(); while (bool_thread) { try { Log.i("check_time", check_time); Thread.sleep(Integer.parseInt(check_time) * 60000); if (Utils.isNetworkAvailable(BaseActivity.this)) { List<ExpressModel> list = finalDb.findAllByWhere(ExpressModel.class, "IsDownLoad=0"); list.size(); for (ExpressModel e : list) { ImageObject[] imgs = new ImageObject[3]; ImageObject imageObject1 = new ImageObject(); imageObject1.setImageId("ConsignIdentityImageId"); if (!VikiccUtils.isEmptyString(e.getConsignIdentityImageId())) { imageObject1.setImageData( Utils.getBitmapFromByte( Base64.decode(e.getConsignIdentityImageId(), Base64.DEFAULT))); } ImageObject imageObject2 = new ImageObject(); imageObject2.setImageId("GoodsImageId"); imageObject2.setImageData( Utils.getBitmapFromByte(Base64.decode(e.getGoodsImageId(), Base64.DEFAULT))); ImageObject imageObject3 = new ImageObject(); imageObject3.setImageId("OrderImageId"); imageObject3.setImageData( Utils.getBitmapFromByte(Base64.decode(e.getOrderImageId(), Base64.DEFAULT))); // if // (!VikiccUtils.isEmptyString(e.getConsignIdentityImageId())) { // // imageObject1.setImageData(Utils.getBitmapFromByte(e.getConsignIdentityImageId().getBytes())); // } // // imageObject2.setImageData(Utils.getBitmapFromByte(e.getGoodsImageId().getBytes())); // // imageObject3.setImageData(Utils.getBitmapFromByte(e.getOrderImageId().getBytes())); imgs[0] = imageObject1; imgs[1] = imageObject2; imgs[2] = imageObject3; e.setImages(imgs); AddExpress(e); } } Message message = new Message(); message.what = 1; handler.sendMessage(message); // 发送消息 } catch (InterruptedException e) { e.printStackTrace(); } } Looper.loop(); }
/** * Returns an ArrayList containing all the Addresses stored in the application's database * * @return An ArrayList containing one Address object for each record in the Addresses table. */ public ArrayList<Address> getAllAddresses() { ArrayList<Address> addresses = new ArrayList<Address>(); // Specify which columns from the table we are interested in String[] projection = { AddressesTable.COLUMN_ID, AddressesTable.COLUMN_CORRESPONDING_PUBKEY_ID, AddressesTable.COLUMN_LABEL, AddressesTable.COLUMN_ADDRESS, AddressesTable.COLUMN_PRIVATE_SIGNING_KEY, AddressesTable.COLUMN_PRIVATE_ENCRYPTION_KEY, AddressesTable.COLUMN_RIPE_HASH, AddressesTable.COLUMN_TAG }; // Query the database via the ContentProvider Cursor cursor = mContentResolver.query( DatabaseContentProvider.CONTENT_URI_ADDRESSES, projection, null, null, null); if (cursor.moveToFirst()) { do { long id = cursor.getLong(0); long correspondingPubkeyId = cursor.getLong(1); String label = cursor.getString(2); String address = cursor.getString(3); String privateSigningKey = cursor.getString(4); String privateEncryptionKey = cursor.getString(5); byte[] ripeHash = Base64.decode(cursor.getString(6), Base64.DEFAULT); byte[] tag = Base64.decode(cursor.getString(7), Base64.DEFAULT); Address a = new Address(); a.setId(id); a.setCorrespondingPubkeyId(correspondingPubkeyId); a.setLabel(label); a.setAddress(address); a.setPrivateSigningKey(privateSigningKey); a.setPrivateEncryptionKey(privateEncryptionKey); a.setRipeHash(ripeHash); a.setTag(tag); addresses.add(a); } while (cursor.moveToNext()); } cursor.close(); return addresses; }
private void updateUI() { if (mModelInfo != null) { byte[] htmlContent = Base64.decode(mModelInfo.content, Base64.DEFAULT); Logger.i(TAG, "ContractContent = " + new String(htmlContent)); mWebView.loadDataWithBaseURL(null, new String(htmlContent), "text/html", "UTF-8", null); } }
protected void onPostExecute(JSONObject json) { int success; String mensaje; try { success = json.getInt(Constantes.JSON_SUCCESS); mensaje = json.getString(Constantes.JSON_MESSAGE); if (success == 1) { // si fue bien // Getting Array of Events String image_string = json.getString("image"); byte[] image_byte = Base64.decode(image_string, Base64.DEFAULT); event.setCartel(image_byte); setEventsFields(); // ivCartel.setImageBitmap(BitmapFactory.decodeByteArray(image_byte, 0, // image_byte.length)); } else { Toast.makeText(getActivity(), mensaje, Toast.LENGTH_LONG).show(); } } catch (JSONException e) { e.printStackTrace(); } }
private static Bitmap convertJsonStringBytes2Bitmap(byte[] bytes, String key) throws IOException, OutOfMemoryError { int size = bytes.length; // reduce json header and ender size // json header: {"key":" // json ender: "} String jHeader = "{\"" + key + "\":\""; int start = jHeader.getBytes().length; String jEnd = "\"}"; int length = size - start - jEnd.getBytes().length; // Log.i(TAG, "start:" + start + ",length:" + length); if (start >= size - 1 || length < 0) { return null; } bytes = Base64.decode(bytes, start, length, Base64.DEFAULT); // reduce auth header and ender size = bytes.length; start = AUTH_HEAD_BYTES_SIZE; length = size - start - AUTH_END_BYTES_SIZE; // Log.i(TAG, "bitmap start:" + start + ",length:" + length); if (start >= size - 1 || length < 0) { return null; } Bitmap map = BitmapFactory.decodeByteArray(bytes, start, length); return map; }
private OpenForReadResult readDataUri(Uri paramUri) { Object localObject = paramUri.getSchemeSpecificPart(); int k = ((String) localObject).indexOf(','); if (k == -1) { return null; } String[] arrayOfString = ((String) localObject).substring(0, k).split(";"); String str = null; int j = 0; if (arrayOfString.length > 0) { str = arrayOfString[0]; } int i = 1; while (i < arrayOfString.length) { if ("base64".equalsIgnoreCase(arrayOfString[i])) { j = 1; } i += 1; } localObject = ((String) localObject).substring(k + 1); if (j != 0) {} for (localObject = Base64.decode((String) localObject, 0); ; localObject = EncodingUtils.getBytes((String) localObject, "UTF-8")) { return new OpenForReadResult( paramUri, new ByteArrayInputStream((byte[]) localObject), str, localObject.length, null); } }
private void createCrossImage() { mCrossImage = new ImageView(getContext()); // Dismiss the dialog when user click on the 'x' mCrossImage.setOnClickListener( new View.OnClickListener() { @Override public void onClick(View v) { mListener.onCancel(); FbDialog.this.dismiss(); } }); int px30 = (int) TypedValue.applyDimension( TypedValue.COMPLEX_UNIT_DIP, 30, getContext().getResources().getDisplayMetrics()); mCrossImage.setLayoutParams(new FrameLayout.LayoutParams(px30, px30)); mCrossImage.setScaleType(ImageView.ScaleType.FIT_CENTER); byte[] decodedString = Base64.decode(CLOSE_BT, Base64.DEFAULT); Bitmap cross = BitmapFactory.decodeByteArray(decodedString, 0, decodedString.length); mCrossImage.setImageBitmap(cross); /* 'x' should not be visible while webview is loading * make it visible only after webview has fully loaded */ mCrossImage.setVisibility(View.INVISIBLE); }
@Override public boolean execute(String action, JSONArray data, CallbackContext callbackContext) throws JSONException { if (action.equals(ACTION)) { String base64 = data.optString(0); if (base64.equals("")) // isEmpty() requires API level 9 callbackContext.error("Missing base64 string"); // Create the bitmap from the base64 string Log.d("Canvas2ImagePlugin", base64); byte[] decodedString = Base64.decode(base64, Base64.DEFAULT); Bitmap bmp = BitmapFactory.decodeByteArray(decodedString, 0, decodedString.length); if (bmp == null) { callbackContext.error("The image could not be decoded"); } else { // Save the image File imageFile = savePhoto(bmp); if (imageFile == null) callbackContext.error("Error while saving image"); // Update image gallery scanPhoto(imageFile); callbackContext.success(imageFile.toString()); } return true; } else { return false; } }
private void loadImage(String image) { byte[] img; img = Base64.decode(image, Base64.DEFAULT); ByteArrayInputStream in = new ByteArrayInputStream(img); Bitmap bmp = BitmapFactory.decodeStream(in); imgView.setImageBitmap(bmp); }
public Bitmap getThumbnail() { if (thumbnail == null && thumbnailBase64 != null) { byte[] decodeString = Base64.decode(thumbnailBase64, Base64.DEFAULT); thumbnail = BitmapFactory.decodeByteArray(decodeString, 0, decodeString.length); } return thumbnail; }
public static String decryptIt(String value) { try { DESKeySpec keySpec = new DESKeySpec(cryptoPass.getBytes("UTF8")); SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES"); SecretKey key = keyFactory.generateSecret(keySpec); byte[] encrypedPwdBytes = Base64.decode(value, Base64.DEFAULT); // cipher is not thread safe Cipher cipher = Cipher.getInstance("DES"); cipher.init(Cipher.DECRYPT_MODE, key); byte[] decrypedValueBytes = (cipher.doFinal(encrypedPwdBytes)); String decrypedValue = new String(decrypedValueBytes); Log.d(TAG, "Decrypted: " + value + " -> " + decrypedValue); return decrypedValue; } catch (InvalidKeyException e) { e.printStackTrace(); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } catch (InvalidKeySpecException e) { e.printStackTrace(); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } catch (BadPaddingException e) { e.printStackTrace(); } catch (NoSuchPaddingException e) { e.printStackTrace(); } catch (IllegalBlockSizeException e) { e.printStackTrace(); } return value; }
/** * Verifies that the signature from the server matches the computed signature on the data. Returns * true if the data is correctly signed. * * @param publicKey public key associated with the developer account * @param signedData signed data from server * @param signature server signature * @return true if the data and signature match */ public static boolean verify(PublicKey publicKey, String signedData, String signature) { if (Consts.DEBUG) { Log.i(TAG, "signature: " + signature); } Signature sig; try { sig = Signature.getInstance(SIGNATURE_ALGORITHM); sig.initVerify(publicKey); sig.update(signedData.getBytes()); // if (!sig.verify(Base64.decode(signature))) { if (!sig.verify(Base64.decode(signature, Base64.DEFAULT))) { Log.e(TAG, "Signature verification failed."); return false; } return true; } catch (NoSuchAlgorithmException e) { Log.e(TAG, "NoSuchAlgorithmException."); } catch (InvalidKeyException e) { Log.e(TAG, "Invalid key specification."); } catch (SignatureException e) { Log.e(TAG, "Signature exception."); } // catch (Base64DecoderException e) { // Log.e(TAG, "Base64 decoding failed."); // } return false; }
/** * @param s * @return * @throws GeneralSecurityException * @throws UnsupportedEncodingException */ public static String decrypt(final String s) throws GeneralSecurityException, UnsupportedEncodingException { String decrypted = null; try { if (s != null) { final SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("PBEWithMD5AndDES"); final SecretKey secretKey = secretKeyFactory.generateSecret(new PBEKeySpec(secret.toCharArray())); final Cipher cipher = Cipher.getInstance("PBEWithMD5AndDES"); cipher.init(Cipher.DECRYPT_MODE, secretKey, new PBEParameterSpec(SALT, 20)); final byte[] stringBytes = s.getBytes("UTF-8"); final byte[] decodedBytes = Base64.decode(stringBytes, Base64.DEFAULT); final byte[] decryptedBytes = cipher.doFinal(decodedBytes); decrypted = new String(decryptedBytes, "UTF-8"); } } catch (GeneralSecurityException x) { throw x; } catch (UnsupportedEncodingException x) { throw x; } catch (Exception x) { DBG.m(x); } return decrypted; }
/** * @param src * @return source data * @throws NoSuchPaddingException * @throws NoSuchAlgorithmException * @throws InvalidAlgorithmParameterException * @throws InvalidKeyException */ public byte[] decrypt(String baseKey, String src) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException { byte[] key = SHA256(baseKey); if (secureKey == null) { secureKey = new SecretKeySpec(key, "AES"); } if (decryptor == null) { decryptor = Cipher.getInstance("AES/CBC/PKCS5Padding"); decryptor.init(Cipher.DECRYPT_MODE, secureKey, new IvParameterSpec(IV.getBytes())); } byte[] dec = Base64.decode(src, 0); byte[] ret = null; try { ret = decryptor.doFinal(dec); } catch (IllegalBlockSizeException e) { e.printStackTrace(); } catch (BadPaddingException e) { e.printStackTrace(); } return ret; }
private OpenForReadResult readDataUri(Uri uri) { String uriAsString = uri.getSchemeSpecificPart(); int commaPos = uriAsString.indexOf(','); if (commaPos == -1) { return null; } String[] mimeParts = uriAsString.substring(0, commaPos).split(";"); String contentType = null; boolean base64 = false; if (mimeParts.length > 0) { contentType = mimeParts[0]; } for (int i = 1; i < mimeParts.length; ++i) { if ("base64".equalsIgnoreCase(mimeParts[i])) { base64 = true; } } String dataPartAsString = uriAsString.substring(commaPos + 1); byte[] data = base64 ? Base64.decode(dataPartAsString, Base64.DEFAULT) : EncodingUtils.getBytes(dataPartAsString, "UTF-8"); InputStream inputStream = new ByteArrayInputStream(data); return new OpenForReadResult(uri, inputStream, contentType, data.length, null); }
static List<HeartRateItem> a(String str) { List<HeartRateItem> arrayList = new ArrayList(); try { JSONObject jSONObject = new JSONObject(str); if (jSONObject.optInt(b.a) != 1) { return null; } JSONArray jSONArray = jSONObject.getJSONArray(b.b); int length = jSONArray.length(); for (int i = 0; i < length; i++) { jSONObject = jSONArray.getJSONObject(i); byte[] decode = Base64.decode(jSONObject.getString(O.j), 2); if (decode != null && decode.length > 0) { long j = jSONObject.getLong(g.f); for (int i2 = 0; i2 < decode.length; i2++) { if (decode[i2] != (byte) 0) { HeartRateItem heartRateItem = new HeartRateItem(); heartRateItem.type = 1; heartRateItem.time = ((long) i2) + j; heartRateItem.hr = decode[i2] & HeartRateInfo.HR_EMPTY_VALUE; arrayList.add(heartRateItem); } } } } return arrayList; } catch (JSONException e) { e.printStackTrace(); return arrayList; } }
static { density = ApplicationLoader.applicationContext.getResources().getDisplayMetrics().density; SharedPreferences preferences = ApplicationLoader.applicationContext.getSharedPreferences("primes", Context.MODE_PRIVATE); String primes = preferences.getString("primes", null); if (primes == null) { goodPrimes.add( "C71CAEB9C6B1C9048E6C522F70F13F73980D40238E3E21C14934D037563D930F48198A0AA7C14058229493D22530F4DBFA336F6E0AC925139543AED44CCE7C3720FD51F69458705AC68CD4FE6B6B13ABDC9746512969328454F18FAF8C595F642477FE96BB2A941D5BCD1D4AC8CC49880708FA9B378E3C4F3A9060BEE67CF9A4A4A695811051907E162753B56B0F6B410DBA74D8A84B2A14B3144E0EF1284754FD17ED950D5965B4B9DD46582DB1178D169C6BC465B0D6FF9CA3928FEF5B9AE4E418FC15E83EBEA0F87FA9FF5EED70050DED2849F47BF959D956850CE929851F0D8115F635B105EE2E4E15D04B2454BF6F4FADF034B10403119CD8E3B92FCC5B"); } else { try { byte[] bytes = Base64.decode(primes, Base64.DEFAULT); if (bytes != null) { SerializedData data = new SerializedData(bytes); int count = data.readInt32(); for (int a = 0; a < count; a++) { goodPrimes.add(data.readString()); } } } catch (Exception e) { FileLog.e("tmessages", e); goodPrimes.clear(); goodPrimes.add( "C71CAEB9C6B1C9048E6C522F70F13F73980D40238E3E21C14934D037563D930F48198A0AA7C14058229493D22530F4DBFA336F6E0AC925139543AED44CCE7C3720FD51F69458705AC68CD4FE6B6B13ABDC9746512969328454F18FAF8C595F642477FE96BB2A941D5BCD1D4AC8CC49880708FA9B378E3C4F3A9060BEE67CF9A4A4A695811051907E162753B56B0F6B410DBA74D8A84B2A14B3144E0EF1284754FD17ED950D5965B4B9DD46582DB1178D169C6BC465B0D6FF9CA3928FEF5B9AE4E418FC15E83EBEA0F87FA9FF5EED70050DED2849F47BF959D956850CE929851F0D8115F635B105EE2E4E15D04B2454BF6F4FADF034B10403119CD8E3B92FCC5B"); } } System.loadLibrary("tmessages"); }
/** * 将加密的byte[]解密,返回解密后字节数组 * * @param msg 加密消息体 * @param srcKey 会话密钥 * @return byte[] 解密后byte[] * @throws Exception Exception */ public static byte[] decode2Byte(byte[] msg, String srcKey) throws Exception { SecretKey sercKey = new SecretKeySpec(srcKey.getBytes(), ALGORITHM_3DES); byte[] base64Msg = decrypt(sercKey, msg, ALGORITHM_3DES); return Base64.decode(base64Msg, Base64.DEFAULT); }
public String decrypt(String encrypted, Cipher cipher) throws Exception { byte[] bts = Base64.decode(encrypted, Base64.DEFAULT); byte[] decrypted = blockCipher(bts, Cipher.DECRYPT_MODE, cipher); return new String(decrypted, "UTF-8"); }
/** * 将加密的字符串解密,返回解密后字符串 * * @param msg 加密消息体 * @param srcKey 会话密钥 * @return String 解密后byte[] * @throws Exception Exception */ public static String decode2Str(String msg, String srcKey) throws Exception { SecretKey sercKey = new SecretKeySpec(srcKey.getBytes(), ALGORITHM_3DES); String base64Msg = decrypt(sercKey, msg, ALGORITHM_3DES); return new String(Base64.decode(base64Msg, Base64.DEFAULT), "UTF-8"); }
public static TodoList todoListFromString(String todoListData) throws IOException, ClassNotFoundException { ByteArrayInputStream bis = new ByteArrayInputStream(Base64.decode(todoListData, Base64.DEFAULT)); ObjectInputStream ois = new ObjectInputStream(bis); return (TodoList) ois.readObject(); }
/** * 将Base64的图片转化为jpg格式保存 * * @param base64Data Base64图片数据 * @param savePath 保存的路径 * @return 返回图片的Bitmap */ public static Bitmap base64ToBitmap(String base64Data, String savePath) { byte[] bytes = Base64.decode(base64Data, Base64.DEFAULT); Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length); File file = new File(savePath); FileOutputStream fos = null; try { fos = new FileOutputStream(file); } catch (FileNotFoundException e) { e.printStackTrace(); } try { boolean isSuccess = bitmap.compress(Bitmap.CompressFormat.JPEG, 100, fos); if (isSuccess) { fos.flush(); fos.close(); return bitmap; } else { fos.close(); return null; } } catch (Exception e) { e.printStackTrace(); } return null; }
@Kroll.method public String encode(HashMap args) { // encode text to cipher text // KrollDict arg = new KrollDict(args); String txt = arg.getString("plainText"); String keyString = arg.getString("publicKey"); byte[] encodedBytes = null; Key key; try { byte[] encodedKey = Base64.decode(keyString, 0); X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(encodedKey); KeyFactory keyFact = KeyFactory.getInstance("RSA", "BC"); key = keyFact.generatePublic(x509KeySpec); } catch (Exception e) { return "error key"; } try { Cipher c = Cipher.getInstance("RSA"); c.init(Cipher.ENCRYPT_MODE, key); encodedBytes = c.doFinal(txt.getBytes()); } catch (Exception e) { Log.e(TAG, "RSA encryption error " + e.toString()); } return Base64.encodeToString(encodedBytes, Base64.NO_WRAP); }
public static String base64Decode(String encoded) { if (encoded == null) { return null; } byte[] decoded = Base64.decode(encoded, Base64.DEFAULT); return new String(decoded); }