public static void logTokens(Activity context) {

    // Add code to print out the key hash
    try {
      PackageInfo info =
          context
              .getPackageManager()
              .getPackageInfo(
                  context.getApplicationContext().getPackageName(), PackageManager.GET_SIGNATURES);
      for (Signature signature : info.signatures) {
        MessageDigest md = MessageDigest.getInstance("SHA-1");
        md.update(signature.toByteArray());
        Log.d("SHA-KeyHash:::", Base64.encodeToString(md.digest(), Base64.DEFAULT));

        md = MessageDigest.getInstance("MD5");
        md.update(signature.toByteArray());
        Log.d("MD5-KeyHash:::", Base64.encodeToString(md.digest(), Base64.DEFAULT));

        md = MessageDigest.getInstance("SHA");
        md.update(signature.toByteArray());
        Log.d("SHA-Hex-From-KeyHash:::", bytesToHex(md.digest()));
      }
    } catch (NameNotFoundException e) {

    } catch (NoSuchAlgorithmException e) {

    }
  }
  public static String printKeyHash(Activity context) {
    PackageInfo packageInfo;
    String key = null;
    try {
      // getting application package name, as defined in manifest
      String packageName = context.getApplicationContext().getPackageName();

      // Retriving package info
      packageInfo =
          context.getPackageManager().getPackageInfo(packageName, PackageManager.GET_SIGNATURES);

      Log.e("Package Name=", context.getApplicationContext().getPackageName());

      for (Signature signature : packageInfo.signatures) {
        MessageDigest md = MessageDigest.getInstance("SHA");
        md.update(signature.toByteArray());
        key = new String(Base64.encode(md.digest(), 0));

        // String key = new String(Base64.encodeBytes(md.digest()));
        Log.e("Key Hash=", key);
      }
    } catch (PackageManager.NameNotFoundException e1) {
      Log.e("Name not found", e1.toString());
    } catch (NoSuchAlgorithmException e) {
      Log.e("No such an algorithm", e.toString());
    } catch (Exception e) {
      Log.e("Exception", e.toString());
    }

    return key;
  }
  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;
  }
Example #4
0
  @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);
  }
Example #5
0
  public void selectProfilePicture(Intent data) {

    Uri selectedImage = data.getData();

    try {

      Bitmap finalImage = ImageHandler.getPortraitImage(selectedImage, getActivity(), 300, 200);
      profilePicture.setImageBitmap(finalImage);

      Bitmap thumbNail = ImageHandler.getPortraitImage(selectedImage, getActivity(), 35, 23);

      // http://stackoverflow.com/questions/26292969/can-i-store-image-files-in-firebase-using-java-api
      ByteArrayOutputStream stream = new ByteArrayOutputStream();
      finalImage.compress(Bitmap.CompressFormat.PNG, 100, stream);
      String imageString = Base64.encodeToString(stream.toByteArray(), Base64.DEFAULT);

      stream.reset();
      thumbNail.compress(Bitmap.CompressFormat.PNG, 100, stream);
      String thumbNString = Base64.encodeToString(stream.toByteArray(), Base64.DEFAULT);

      MainActivity.getUser().setProfilePicture(imageString, stream.toByteArray());
      stream.close();

      new FbDataChange("/users/" + MainActivity.getUser().getUid() + "/profilePicture", imageString)
          .execute();

      new FbDataChange("/users/" + MainActivity.getUser().getUid() + "/profileThumb", thumbNString)
          .execute();
    } catch (IOException e) {
    }
  }
Example #6
0
 /**
  * Encodes this ciphertext, IV, mac as a string.
  *
  * @return base64(iv) : base64(mac) : base64(ciphertext). The iv and mac go first because
  *     they're fixed length.
  */
 @Override
 public String toString() {
   String ivString = Base64.encodeToString(iv, BASE64_FLAGS);
   String cipherTextString = Base64.encodeToString(cipherText, BASE64_FLAGS);
   String macString = Base64.encodeToString(mac, BASE64_FLAGS);
   return String.format(ivString + ":" + macString + ":" + cipherTextString);
 }
Example #7
0
  @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);
  }
Example #8
0
 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);
 }
  /**
   * 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;
  }
 public void testMakeUriString() throws IOException {
   // Simple user name and command
   EasSyncService svc = setupService(USER);
   String uriString = svc.makeUriString("Sync", null);
   // These next two should now be cached
   assertNotNull(svc.mAuthString);
   assertNotNull(svc.mUserString);
   assertEquals(
       "Basic " + Base64.encodeToString((USER + ":" + PASSWORD).getBytes(), Base64.NO_WRAP),
       svc.mAuthString);
   assertEquals(
       "&User="******"&DeviceId=" + ID + "&DeviceType=" + EasSyncService.DEVICE_TYPE,
       svc.mUserString);
   assertEquals(
       "https://" + HOST + "/Microsoft-Server-ActiveSync?Cmd=Sync" + svc.mUserString, uriString);
   // User name that requires encoding
   String user = "******";
   svc = setupService(user);
   uriString = svc.makeUriString("Sync", null);
   assertEquals(
       "Basic " + Base64.encodeToString((user + ":" + PASSWORD).getBytes(), Base64.NO_WRAP),
       svc.mAuthString);
   String safeUserName = "******";
   assertEquals(
       "&User="******"&DeviceId=" + ID + "&DeviceType=" + EasSyncService.DEVICE_TYPE,
       svc.mUserString);
   assertEquals(
       "https://" + HOST + "/Microsoft-Server-ActiveSync?Cmd=Sync" + svc.mUserString, uriString);
 }
  public List<NameValuePair> addnew_crypt_K_param(List<NameValuePair> param, String url) {
    ArrayList<NameValuePair> localArrayList = new ArrayList<NameValuePair>();

    generate_new_aes_key();

    localArrayList.add(new BasicNameValuePair("K", get_K()));

    Iterator<NameValuePair> i = param.iterator();
    boolean is_login = false;

    if (url.indexOf("login?") != -1 || url.indexOf("regist?") != -1) {
      is_login = true;
      ON = true;
    }
    while (i.hasNext()) {

      NameValuePair n = i.next();
      //		String val = Base64.encodeBase64String(new_encrypt_cn(E_CODE.AES,n.getValue()));
      String val =
          new String(Base64.encode(new_encrypt_cn(E_CODE.AES, n.getValue()), Base64.DEFAULT));

      if (is_login == true) {
        //			localArrayList.add(new BasicNameValuePair(n.getName(),
        // Base64.encodeBase64String(new_encrypt_cn(E_CODE.RSA_EP, val))));
        localArrayList.add(
            new BasicNameValuePair(
                n.getName(),
                new String(Base64.encode(new_encrypt_cn(E_CODE.RSA_EP, val), Base64.DEFAULT))));
      } else {
        localArrayList.add(new BasicNameValuePair(n.getName(), val));
      }
    }
    return localArrayList;
  }
  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);
  }
Example #13
0
 /**
  * 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);
   }
 }
Example #14
0
    @Override
    public void run() {
      int ret = 1;
      ret = OpenModule();
      if (ret != 0) {
        if (callback != null) {
          callback.onFail(-884, "指纹模块打开失败");
        }
        api.IDCard_Close();
        m_bThreadFinished = true;
        return;
      }
      if (callback != null) {
        callback.onStart();
      }
      try {
        synchronized (this) {
          while (runFlag) {
            try {
              Thread.sleep(1000);
            } catch (InterruptedException e) {
              e.printStackTrace();
            }
            APDU_RESP ApduResp_TCD = new APDU_RESP();
            ret = api.TCD_Read_Test(ApduResp_TCD);
            if (0 == ret) {
              String strInfo = "";
              byte[] fingerByte = new byte[ApduResp_TCD.LenOut];
              try {
                System.arraycopy(ApduResp_TCD.DataOut, 0, fingerByte, 0, ApduResp_TCD.LenOut);
                Log.e("fingerCode:", ByteTool.byte2hex(fingerByte));
                if (fingerType == Config.WELL_FINGER) {
                  strInfo = FingerUnit.parseWellcom(fingerByte);
                } else if (fingerType == Config.SHENGYE_FINGER) {
                  strInfo = Base64.encodeToString(fingerByte, Base64.NO_WRAP);
                } else {
                  strInfo = Base64.encodeToString(fingerByte, Base64.NO_WRAP);
                }
              } catch (ArrayIndexOutOfBoundsException e) {
                continue;
              }
              callback.onRead(strInfo);
              runFlag = false;
              break;
            } else {

              // callback.onFail(ret, "未读取到指纹");
            }
          }
        }
      } finally {
        m_bThreadFinished = true;
      }
    }
Example #15
0
        @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();
        }
 public void rsaCypher(String rString, InputStream inputStream, File directory)
     throws InvalidKeyException, NoSuchPaddingException, NoSuchAlgorithmException, IOException,
         BadPaddingException, IllegalBlockSizeException {
   kpg = KeyPairGenerator.getInstance("RSA");
   kpg.initialize(1024);
   kp = kpg.genKeyPair();
   privateKey = kp.getPrivate();
   cipher = Cipher.getInstance("RSA");
   File root = new File(Environment.getExternalStorageDirectory() + "/Notes/", "rsapublick.txt");
   // Read text from file
   if (root.exists()) {
     StringBuilder text = new StringBuilder();
     try {
       BufferedReader br = new BufferedReader(new FileReader(root));
       String line;
       while ((line = br.readLine()) != null) {
         text.append(line);
         text.append('\n');
       }
       br.close();
       byte[] keyBytes = Base64.decode(text.toString().getBytes("utf-8"), 0);
       X509EncodedKeySpec spec = new X509EncodedKeySpec(keyBytes);
       KeyFactory keyFactory = KeyFactory.getInstance("RSA");
       publicKey = keyFactory.generatePublic(spec);
     } catch (IOException e) {
       // You'll need to add proper error handling here
     } catch (InvalidKeySpecException e) {
       e.printStackTrace();
     }
   } else {
     publicKey = kp.getPublic();
     byte[] pKbytes = Base64.encode(publicKey.getEncoded(), 0);
     String pK = new String(pKbytes);
     String pubKey = "-----BEGIN public KEY-----\n" + pK + "-----END public KEY-----\n";
     System.out.println(pubKey);
     generateNoteOnSD("rsapublick.txt", pK, directorio);
   }
   this.cipher.init(Cipher.ENCRYPT_MODE, publicKey);
   byte[] bytes = getBytesFromInputStream(inputStream);
   byte[] encrypted = blockCipher(bytes, Cipher.ENCRYPT_MODE);
   FileOutputStream fileOutputStream = new FileOutputStream(directory);
   fileOutputStream.write(encrypted);
   fileOutputStream.close();
   System.out.println("Encryptado RSA Finalizado");
   root = new File(Environment.getExternalStorageDirectory() + "/Notes/", "rsaOrivatek.txt");
   if (!root.exists()) {
     byte[] pKbytes = Base64.encode(getPrivateKey().getEncoded(), 0);
     String pK = new String(pKbytes);
     String pubKey = "-----BEGIN private KEY-----\n" + pK + "-----END private KEY-----\n";
     System.out.println(pubKey);
     generateNoteOnSD("rsaOrivatek.txt", pK, directorio);
   }
 }
  @Override
  public void requestPurchase(String sku) {
    try {
      SecureRandom sr;
      sr = SecureRandom.getInstance("SHA1PRNG");
      String uniqueId = Long.toHexString(sr.nextLong());

      JSONObject purchaseRequest = new JSONObject();
      purchaseRequest.put("uuid", uniqueId);
      purchaseRequest.put("identifier", sku);
      purchaseRequest.put("testing", TESTING);

      String purchaseRequestJson = purchaseRequest.toString();

      byte[] keyBytes = new byte[16];
      sr.nextBytes(keyBytes);
      SecretKey key = new SecretKeySpec(keyBytes, "AES");

      byte[] ivBytes = new byte[16];
      sr.nextBytes(ivBytes);
      IvParameterSpec iv = new IvParameterSpec(ivBytes);

      Cipher cipher;
      cipher = Cipher.getInstance("AES/CBC/PKCS5Padding", "BC");
      cipher.init(Cipher.ENCRYPT_MODE, key, iv);
      byte[] payload = cipher.doFinal(purchaseRequestJson.getBytes("UTF-8"));

      cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding", "BC");
      cipher.init(Cipher.ENCRYPT_MODE, mPublicKey);
      byte[] encryptedKey = cipher.doFinal(keyBytes);

      Purchasable purchasable =
          new Purchasable(
              sku,
              Base64.encodeToString(encryptedKey, Base64.NO_WRAP),
              Base64.encodeToString(ivBytes, Base64.NO_WRAP),
              Base64.encodeToString(payload, Base64.NO_WRAP));

      //            synchronized (mOutstandingPurchaseRequests) {
      //                mOutstandingPurchaseRequests.put(uniqueId, product);
      //            }

      OuyaFacade.getInstance().requestPurchase(purchasable, this);

    } catch (Throwable e) {
      e.printStackTrace();
    }
  }
  /**
   * 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;
  }
 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();
 }
Example #20
0
 public String getStringImage(Bitmap bmp) {
   ByteArrayOutputStream baos = new ByteArrayOutputStream();
   bmp.compress(Bitmap.CompressFormat.JPEG, 50, baos);
   byte[] imageBytes = baos.toByteArray();
   String encodedImage = Base64.encodeToString(imageBytes, Base64.DEFAULT);
   return encodedImage;
 }
  private void initQuery() throws IOException {
    Hashtable<String, String> map = new Hashtable<String, String>();
    map.put("uid", "TEMP_USER");
    map.put("pwd", "TEMP_PASSWORD");
    map.put(QUERY_PARAM, Base64.encodeToString(TEST_QUERY.getBytes(), 0));

    HttpParams params = new BasicHttpParams();

    HttpConnectionParams.setStaleCheckingEnabled(params, false);
    HttpConnectionParams.setConnectionTimeout(params, ConnectionManager.DEFAULT_TIMEOUT);
    HttpConnectionParams.setSoTimeout(params, ConnectionManager.DEFAULT_TIMEOUT);
    DefaultHttpClient httpClient = new DefaultHttpClient(params);

    // create post method
    HttpPost postMethod = new HttpPost(QUERY_URI);

    ByteArrayOutputStream byteArrayOS = new ByteArrayOutputStream();
    ObjectOutputStream objOS = new ObjectOutputStream(byteArrayOS);
    objOS.writeObject(map);
    ByteArrayEntity req_entity = new ByteArrayEntity(byteArrayOS.toByteArray());
    req_entity.setContentType(MIMETypeConstantsIF.BINARY_TYPE);

    // associating entity with method
    postMethod.setEntity(req_entity);

    // Executing post method
    executeHttpClient(httpClient, postMethod);
  }
Example #22
0
  public static void report(String app, String deviceId, SocketPacket packet) {
    String address = "http://172.19.207.87:8080/report/socket/output";
    // 传参数 服务端获取的方法为request.getParameter("name")
    List<FormEntry> params = new ArrayList<FormEntry>();
    params.add(new FormEntry(FormEntry.Type.String, "app", app));
    params.add(new FormEntry(FormEntry.Type.String, "domain", packet.getDomain()));
    params.add(new FormEntry(FormEntry.Type.String, "host", packet.getHost()));
    params.add(new FormEntry(FormEntry.Type.String, "type", packet.getType()));
    params.add(
        new FormEntry(FormEntry.Type.String, "timestamp", Long.toString(packet.getTimestamp())));
    params.add(
        new FormEntry(
            FormEntry.Type.String,
            "data",
            Base64.encodeToString(packet.getBytes(), Base64.DEFAULT)));
    params.add(new FormEntry(FormEntry.Type.String, "deviceId", deviceId));
    // post
    AsyncHttp.post(
        address,
        params,
        new AsyncHttp.ResultCallback() {
          @Override
          public void onSuccess(String url, int statusCode, String result) {}

          @Override
          public void onFailure(String url, int statusCode, int errorType, Throwable throwable) {}
        });
  }
  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");
  }
Example #24
0
 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");
 }
 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);
   }
 }
  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;
  }
Example #27
0
  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);
  }
    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();
      }
    }
Example #29
0
 // convert bitmap to base64
 public static String bitmapToBase64(Bitmap bitmap) {
   String result = null;
   ByteArrayOutputStream baos = null;
   try {
     if (bitmap != null) {
       baos = new ByteArrayOutputStream();
       bitmap.compress(Bitmap.CompressFormat.PNG, 100, baos);
       baos.flush();
       baos.close();
       byte[] bitmapBytes = baos.toByteArray();
       result = Base64.encodeToString(bitmapBytes, Base64.DEFAULT);
     }
   } catch (IOException e) {
     e.printStackTrace();
   } finally {
     try {
       if (baos != null) {
         baos.flush();
         baos.close();
       }
     } catch (IOException e) {
       e.printStackTrace();
     }
   }
   return result;
 }
  public static List<Tweet> getTweetsOfUser(String userName) {
    try {
      // Step 1: Encode consumer key and secret
      final String urlApiKey = URLEncoder.encode(Constants.Twitter.API_KEY, "UTF-8");
      final String urlApiSecret = URLEncoder.encode(Constants.Twitter.API_SECRET, "UTF-8");

      // Concatenate the encoded consumer key, a colon character, and the
      // encoded consumer secret
      final String combined = urlApiKey + ":" + urlApiSecret;

      // Base64 encode the string
      final String base64Encoded = Base64.encodeToString(combined.getBytes(), Base64.NO_WRAP);

      // Retrieve the raw authorization token from Twitter
      final TwitterAuthenticated auth = getTwitterAuthentication(base64Encoded);

      // Applications should verify that the value associated with the
      // token_type key of the returned object is bearer
      if ((null != auth) && (null != auth.token_type) && (auth.token_type.equals("bearer"))) {
        return getTweets(userName, auth.access_token);
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
    return getFakeTweets();
  }