Пример #1
0
  /**
   * @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;
  }
Пример #2
0
 /**
  * Generates a PublicKey instance from a string containing the Base64-encoded public key.
  *
  * @param encodedPublicKey Base64-encoded public key
  * @throws IllegalArgumentException if encodedPublicKey is invalid
  */
 private PublicKey generatePublicKey(String encodedPublicKey) {
   try {
     byte[] decodedKey = Base64.decode(encodedPublicKey);
     KeyFactory keyFactory = KeyFactory.getInstance(KEY_FACTORY_ALGORITHM);
     return keyFactory.generatePublic(new X509EncodedKeySpec(decodedKey));
   } catch (NoSuchAlgorithmException e) {
     throw new RuntimeException(e);
   } catch (InvalidKeySpecException e) {
     Log.e(TAG, "Invalid key specification.");
     throw new IllegalArgumentException(e);
   } catch (Base64DecoderException e) {
     Log.e(TAG, "Base64 decoding failed.");
     throw new IllegalArgumentException(e);
   }
 }
Пример #3
0
 /**
  * Verifies that the signature from the server matches the computed signature on the data.
  * Returns true if the data is correctly signed.
  *
  * @param signedData signed data from server
  * @param signature server signature
  * @return true if the data and signature match
  */
 private boolean verify(String signedData, String signature) {
   Signature sig;
   try {
     sig = Signature.getInstance(SIGNATURE_ALGORITHM);
     sig.initVerify(key);
     sig.update(signedData.getBytes());
     if (!sig.verify(Base64.decode(signature))) {
       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;
 }