@capgo/capacitor-updater 5.0.0-alpha.0 → 7.0.0

package/android/src/main/java/ee/forgr/capacitor_updater/CryptoCipher.java

@@ -0,0 +1,153 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package ee.forgr.capacitor_updater;
+
+/**
+ * Created by Awesometic
+ * It's encrypt returns Base64 encoded, and also decrypt for Base64 encoded cipher
+ * references: http://stackoverflow.com/questions/12471999/rsa-encryption-decryption-in-android
+ */
+import android.util.Base64;
+import java.security.GeneralSecurityException;
+import java.security.InvalidAlgorithmParameterException;
+import java.security.InvalidKeyException;
+import java.security.KeyFactory;
+import java.security.NoSuchAlgorithmException;
+import java.security.PrivateKey;
+import java.security.spec.InvalidKeySpecException;
+import java.security.spec.MGF1ParameterSpec;
+import java.security.spec.PKCS8EncodedKeySpec;
+import javax.crypto.BadPaddingException;
+import javax.crypto.Cipher;
+import javax.crypto.IllegalBlockSizeException;
+import javax.crypto.NoSuchPaddingException;
+import javax.crypto.SecretKey;
+import javax.crypto.spec.IvParameterSpec;
+import javax.crypto.spec.OAEPParameterSpec;
+import javax.crypto.spec.PSource;
+import javax.crypto.spec.SecretKeySpec;
+
+public class CryptoCipher {
+
+  public static byte[] decryptRSA(byte[] source, PrivateKey privateKey)
+    throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidAlgorithmParameterException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
+    Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPPadding");
+    OAEPParameterSpec oaepParams = new OAEPParameterSpec(
+      "SHA-256",
+      "MGF1",
+      new MGF1ParameterSpec("SHA-256"),
+      PSource.PSpecified.DEFAULT
+    );
+    cipher.init(Cipher.DECRYPT_MODE, privateKey, oaepParams);
+    byte[] decryptedBytes = cipher.doFinal(source);
+    return decryptedBytes;
+  }
+
+  public static byte[] decryptAES(byte[] cipherText, SecretKey key, byte[] iv) {
+    try {
+      IvParameterSpec ivParameterSpec = new IvParameterSpec(iv);
+      Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
+      SecretKeySpec keySpec = new SecretKeySpec(key.getEncoded(), "AES");
+      cipher.init(Cipher.DECRYPT_MODE, keySpec, ivParameterSpec);
+      byte[] decryptedText = cipher.doFinal(cipherText);
+      return decryptedText;
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+    return null;
+  }
+
+  public static SecretKey byteToSessionKey(byte[] sessionKey) {
+    // rebuild key using SecretKeySpec
+    SecretKey originalKey = new SecretKeySpec(
+      sessionKey,
+      0,
+      sessionKey.length,
+      "AES"
+    );
+    return originalKey;
+  }
+
+  private static PrivateKey readPkcs8PrivateKey(byte[] pkcs8Bytes)
+    throws GeneralSecurityException {
+    KeyFactory keyFactory = KeyFactory.getInstance("RSA");
+    PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(pkcs8Bytes);
+    try {
+      return keyFactory.generatePrivate(keySpec);
+    } catch (InvalidKeySpecException e) {
+      throw new IllegalArgumentException("Unexpected key format!", e);
+    }
+  }
+
+  private static byte[] join(byte[] byteArray1, byte[] byteArray2) {
+    byte[] bytes = new byte[byteArray1.length + byteArray2.length];
+    System.arraycopy(byteArray1, 0, bytes, 0, byteArray1.length);
+    System.arraycopy(
+      byteArray2,
+      0,
+      bytes,
+      byteArray1.length,
+      byteArray2.length
+    );
+    return bytes;
+  }
+
+  private static PrivateKey readPkcs1PrivateKey(byte[] pkcs1Bytes)
+    throws GeneralSecurityException {
+    // We can't use Java internal APIs to parse ASN.1 structures, so we build a PKCS#8 key Java can understand
+    int pkcs1Length = pkcs1Bytes.length;
+    int totalLength = pkcs1Length + 22;
+    byte[] pkcs8Header = new byte[] {
+      0x30,
+      (byte) 0x82,
+      (byte) ((totalLength >> 8) & 0xff),
+      (byte) (totalLength & 0xff), // Sequence + total length
+      0x2,
+      0x1,
+      0x0, // Integer (0)
+      0x30,
+      0xD,
+      0x6,
+      0x9,
+      0x2A,
+      (byte) 0x86,
+      0x48,
+      (byte) 0x86,
+      (byte) 0xF7,
+      0xD,
+      0x1,
+      0x1,
+      0x1,
+      0x5,
+      0x0, // Sequence: 1.2.840.113549.1.1.1, NULL
+      0x4,
+      (byte) 0x82,
+      (byte) ((pkcs1Length >> 8) & 0xff),
+      (byte) (pkcs1Length & 0xff), // Octet string + length
+    };
+    byte[] pkcs8bytes = join(pkcs8Header, pkcs1Bytes);
+    return readPkcs8PrivateKey(pkcs8bytes);
+  }
+
+  public static PrivateKey stringToPrivateKey(String private_key)
+    throws GeneralSecurityException {
+    // Base64 decode the result
+
+    String pkcs1Pem = private_key.toString();
+    pkcs1Pem = pkcs1Pem.replace("-----BEGIN RSA PRIVATE KEY-----", "");
+    pkcs1Pem = pkcs1Pem.replace("-----END RSA PRIVATE KEY-----", "");
+    pkcs1Pem = pkcs1Pem.replace("\\n", "");
+    pkcs1Pem = pkcs1Pem.replace(" ", "");
+
+    byte[] pkcs1EncodedBytes = Base64.decode(
+      pkcs1Pem.getBytes(),
+      Base64.DEFAULT
+    );
+    // extract the private key
+    return readPkcs1PrivateKey(pkcs1EncodedBytes);
+  }
+}

package/android/src/main/java/ee/forgr/capacitor_updater/DelayCondition.java

@@ -0,0 +1,62 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package ee.forgr.capacitor_updater;
+
+import com.google.gson.annotations.SerializedName;
+import java.util.Objects;
+
+public class DelayCondition {
+
+  @SerializedName("kind")
+  private DelayUntilNext kind;
+
+  @SerializedName("value")
+  private String value;
+
+  public DelayCondition(DelayUntilNext kind, String value) {
+    this.kind = kind;
+    this.value = value;
+  }
+
+  public DelayUntilNext getKind() {
+    return kind;
+  }
+
+  public void setKind(DelayUntilNext kind) {
+    this.kind = kind;
+  }
+
+  public String getValue() {
+    return value;
+  }
+
+  public void setValue(String value) {
+    this.value = value;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (!(o instanceof DelayCondition)) return false;
+    DelayCondition that = (DelayCondition) o;
+    return (
+      getKind() == that.getKind() && Objects.equals(getValue(), that.getValue())
+    );
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(getKind(), getValue());
+  }
+
+  @Override
+  public String toString() {
+    return (
+      "DelayCondition{" + "kind=" + kind + ", value='" + value + '\'' + '}'
+    );
+  }
+}

package/android/src/main/java/ee/forgr/capacitor_updater/DelayUntilNext.java

@@ -0,0 +1,14 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package ee.forgr.capacitor_updater;
+
+public enum DelayUntilNext {
+  background,
+  kill,
+  nativeVersion,
+  date,
+}

package/android/src/main/java/ee/forgr/capacitor_updater/DownloadService.java

@@ -0,0 +1,126 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package ee.forgr.capacitor_updater;
+
+import android.app.IntentService;
+import android.content.Intent;
+import java.io.DataInputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.net.URL;
+import java.net.URLConnection;
+
+public class DownloadService extends IntentService {
+
+  public static final String URL = "URL";
+  public static final String ID = "id";
+  public static final String PERCENT = "percent";
+  public static final String FILEDEST = "filendest";
+  public static final String DOCDIR = "docdir";
+  public static final String ERROR = "error";
+  public static final String VERSION = "version";
+  public static final String SESSIONKEY = "sessionkey";
+  public static final String CHECKSUM = "checksum";
+  public static final String NOTIFICATION = "service receiver";
+  public static final String PERCENTDOWNLOAD = "percent receiver";
+
+  public DownloadService() {
+    super("Background DownloadService");
+  }
+
+  private int calcTotalPercent(
+    final int percent,
+    final int min,
+    final int max
+  ) {
+    return (percent * (max - min)) / 100 + min;
+  }
+
+  // Will be called asynchronously by OS.
+  @Override
+  protected void onHandleIntent(Intent intent) {
+    String url = intent.getStringExtra(URL);
+    String id = intent.getStringExtra(ID);
+    String documentsDir = intent.getStringExtra(DOCDIR);
+    String dest = intent.getStringExtra(FILEDEST);
+    String version = intent.getStringExtra(VERSION);
+    String sessionKey = intent.getStringExtra(SESSIONKEY);
+    String checksum = intent.getStringExtra(CHECKSUM);
+
+    try {
+      final URL u = new URL(url);
+      final URLConnection connection = u.openConnection();
+      final InputStream is = u.openStream();
+      final DataInputStream dis = new DataInputStream(is);
+
+      final File target = new File(documentsDir, dest);
+      target.getParentFile().mkdirs();
+      target.createNewFile();
+      final FileOutputStream fos = new FileOutputStream(target);
+
+      final long totalLength = connection.getContentLength();
+      final int bufferSize = 1024;
+      final byte[] buffer = new byte[bufferSize];
+      int length;
+
+      int bytesRead = bufferSize;
+      int percent = 0;
+      this.notifyDownload(id, 10);
+      while ((length = dis.read(buffer)) > 0) {
+        fos.write(buffer, 0, length);
+        final int newPercent = (int) ((bytesRead * 100) / totalLength);
+        if (totalLength > 1 && newPercent != percent) {
+          percent = newPercent;
+          this.notifyDownload(id, this.calcTotalPercent(percent, 10, 70));
+        }
+        bytesRead += length;
+      }
+      publishResults(dest, id, version, checksum, sessionKey, "");
+    } catch (Exception e) {
+      e.printStackTrace();
+      publishResults(
+        "",
+        id,
+        version,
+        checksum,
+        sessionKey,
+        e.getLocalizedMessage()
+      );
+    }
+  }
+
+  private void notifyDownload(String id, int percent) {
+    Intent intent = new Intent(PERCENTDOWNLOAD);
+    intent.putExtra(ID, id);
+    intent.putExtra(PERCENT, percent);
+    sendBroadcast(intent);
+  }
+
+  private void publishResults(
+    String dest,
+    String id,
+    String version,
+    String checksum,
+    String sessionKey,
+    String error
+  ) {
+    Intent intent = new Intent(NOTIFICATION);
+    if (dest != null && !dest.isEmpty()) {
+      intent.putExtra(FILEDEST, dest);
+    }
+    if (error != null && !error.isEmpty()) {
+      intent.putExtra(ERROR, error);
+    }
+    intent.putExtra(ID, id);
+    intent.putExtra(VERSION, version);
+    intent.putExtra(SESSIONKEY, sessionKey);
+    intent.putExtra(CHECKSUM, checksum);
+    intent.putExtra(ERROR, error);
+    sendBroadcast(intent);
+  }
+}