decrypting non-armored files | #118

Tom James Holub · Tom James Holub · commit 253e50a18002 · 2017-10-15T19:18:18.000-07:00
diff --git a/.gitignore b/.gitignore
@@ -30,6 +30,7 @@ captures/
 *.iml
 .idea/workspace.xml
 .idea/libraries
+.idea/misc.xml
 
 # Keystore files
 *.jks
diff --git a/FlowCrypt/src/main/assets/js/tool.js b/FlowCrypt/src/main/assets/js/tool.js
@@ -2032,16 +2032,22 @@
   }
 
   function crypto_message_decrypt(db, account_email, encrypted_data, one_time_message_password, callback, force_output_format) {
-    var armored_encrypted = tool.value(crypto_armor_headers('message').begin).in(encrypted_data);
-    var armored_signed_only = tool.value(crypto_armor_headers('signed_message').begin).in(encrypted_data);
+    var armored_encrypted = false;
+    var armored_signed_only = false;
     var other_errors = [];
     try {
-      if(armored_encrypted) {
-        var message = openpgp.message.readArmored(encrypted_data);
-      } else if(armored_signed_only) {
-        var message = openpgp.cleartext.readArmored(encrypted_data);
+      if (encrypted_data instanceof Uint8Array) {
+        var message = openpgp.message.read(encrypted_data);
       } else {
-        var message = openpgp.message.read(tool.str.to_uint8(encrypted_data));
+        armored_encrypted = tool.value(crypto_armor_headers('message').begin).in(encrypted_data);
+        armored_signed_only = !armored_encrypted && tool.value(crypto_armor_headers('signed_message').begin).in(encrypted_data);
+        if(armored_encrypted) {
+          var message = openpgp.message.readArmored(encrypted_data);
+        } else if(armored_signed_only) {
+          var message = openpgp.cleartext.readArmored(encrypted_data);
+        } else {
+          var message = openpgp.message.read(tool.str.to_uint8(encrypted_data));
+        }
       }
     } catch(format_error) {
       callback({success: false, counts: zeroed_decrypt_error_counts(), format_error: format_error.message, errors: other_errors, encrypted: null, signature: null});
diff --git a/FlowCrypt/src/main/java/com/flowcrypt/email/js/Js.java b/FlowCrypt/src/main/java/com/flowcrypt/email/js/Js.java
@@ -65,37 +65,29 @@ public Js(Context context, StorageConnectorInterface storage) throws IOException
     }
 
     public Boolean str_is_email_valid(String email) {
-        return (Boolean) this.call(Boolean.class, new String[]{"str", "is_email_valid"}, new
-                V8Array(v8).push(email));
+        return (Boolean) this.call(Boolean.class, new String[]{"str", "is_email_valid"}, new V8Array(v8).push(email));
     }
 
     public PgpContact str_parse_email(String email) {
-        V8Object e = (V8Object) this.call(Object.class, new String[]{"str", "parse_email"}, new
-                V8Array(v8).push(email));
+        V8Object e = (V8Object) this.call(Object.class, new String[]{"str", "parse_email"}, new V8Array(v8).push(email));
         return new PgpContact(e.getString("email"), e.getString("name"));
     }
 
     public String str_base64url_encode(String str) {
-        return (String) this.call(String.class, new String[]{"str", "base64url_encode"}, new
-                V8Array(v8).push(str));
+        return (String) this.call(String.class, new String[]{"str", "base64url_encode"}, new V8Array(v8).push(str));
     }
 
     public String str_base64url_decode(String str) {
-        return (String) this.call(String.class, new String[]{"str", "base64url_decode"}, new
-                V8Array(v8).push(str));
+        return (String) this.call(String.class, new String[]{"str", "base64url_decode"}, new V8Array(v8).push(str));
     }
 
     public long time_to_utc_timestamp(String str) {
-        return Long.parseLong((String) this.call(String.class, new String[]{"time",
-                "to_utc_timestamp"}, new V8Array(v8).push(str).push(true)));
+        return Long.parseLong((String) this.call(String.class, new String[]{"time", "to_utc_timestamp"},
+                new V8Array(v8).push(str).push(true)));
     }
 
     public MimeMessage mime_decode(String mime_message) {
-        Long start = System.currentTimeMillis();
-        this.call(Object.class, new String[]{"mime", "decode"}, new V8Array(v8).push
-                (mime_message).push(cb_catcher));
-        Long end = System.currentTimeMillis();
-        System.out.println("duration decode: " + (end - start));
+        this.call(Object.class, new String[]{"mime", "decode"}, new V8Array(v8).push(mime_message).push(cb_catcher));
         if ((Boolean) cb_last_value[0]) {
             return new MimeMessage((V8Object) cb_last_value[1], this);
         } else {
@@ -121,49 +113,46 @@ public String mime_encode(String body, PgpContact[] to, PgpContact from, String
     }
 
     public ProcessedMime mime_process(String mime_message) {
-        this.call(Object.class, new String[]{"mime", "process"}, new V8Array(v8).push
-                (mime_message).push(cb_catcher));
+        this.call(Object.class, new String[]{"mime", "process"}, new V8Array(v8).push(mime_message).push(cb_catcher));
         return new ProcessedMime((V8Object) cb_last_value[0], this);
     }
 
     public String crypto_key_normalize(String armored_key) {
-        return (String) this.call(String.class, new String[]{"crypto", "key", "normalize"}, new
-                V8Array(v8).push(armored_key));
+        return (String) this.call(String.class, new String[]{"crypto", "key", "normalize"}, new V8Array(v8)
+                .push(armored_key));
     }
 
     public PgpKey crypto_key_read(String armored_key) {
-        return new PgpKey((V8Object) this.call(Object.class, new String[]{"crypto", "key",
-                "read"}, new V8Array(v8).push(armored_key)), this);
+        return new PgpKey((V8Object) this.call(Object.class, new String[]{"crypto", "key", "read"}, new V8Array(v8)
+                .push(armored_key)), this);
     }
 
     public V8Object crypto_key_decrypt(PgpKey private_key, String passphrase) {
-        return (V8Object) this.call(Object.class, new String[]{"crypto", "key", "decrypt"}, new
-                V8Array(v8).push(private_key.getV8Object()).push(passphrase));
+        return (V8Object) this.call(Object.class, new String[]{"crypto", "key", "decrypt"}, new V8Array(v8)
+                .push(private_key.getV8Object()).push(passphrase));
     }
 
     public String crypto_key_fingerprint(PgpKey key) {
-        return (String) this.call(String.class, new String[]{"crypto", "key", "fingerprint"}, new
-                V8Array(v8).push(key.getV8Object()));
+        return (String) this.call(String.class, new String[]{"crypto", "key", "fingerprint"}, new V8Array(v8)
+                .push(key.getV8Object()));
     }
 
     public String crypto_key_longid(PgpKey key) {
-        return (String) this.call(String.class, new String[]{"crypto", "key", "longid"}, new
-                V8Array(v8).push(key.getV8Object()));
+        return (String) this.call(String.class, new String[]{"crypto", "key", "longid"}, new V8Array(v8)
+                .push(key.getV8Object()));
     }
 
     public String crypto_key_longid(String fingerprint) {
-        return (String) this.call(String.class, new String[]{"crypto", "key", "longid"}, new
-                V8Array(v8).push(fingerprint));
+        return (String) this.call(String.class, new String[]{"crypto", "key", "longid"}, new V8Array(v8)
+                .push(fingerprint));
     }
 
     public String crypto_armor_clip(String text) {
-        return (String) this.call(String.class, new String[]{"crypto", "armor", "clip"}, new
-                V8Array(v8).push(text));
+        return (String) this.call(String.class, new String[]{"crypto", "armor", "clip"}, new V8Array(v8).push(text));
     }
 
     public String mnemonic(String longid) {
-        return (String) this.call(String.class, v8, new String[]{"mnemonic"}, new V8Array(v8)
-                .push(longid));
+        return (String) this.call(String.class, v8, new String[]{"mnemonic"}, new V8Array(v8).push(longid));
     }
 
     public String crypto_message_encrypt(String pubkeys[], String text) {
@@ -184,27 +173,30 @@ public byte[] crypto_message_encrypt(String pubkeys[], byte[] content, String fi
 
     public PgpDecrypted crypto_message_decrypt(String data, String password) {
         // db,account_email,encrypted_data,one_time_message_password,callback,force_output_format
-        Long start = System.currentTimeMillis();
-        V8Array params = new V8Array(v8).push(NULL).push("").push(data).push(password).push
-                (cb_catcher).push(NULL);
+        V8Array params = new V8Array(v8).push(NULL).push("").push(data).push(password).push(cb_catcher).push(NULL);
         this.call(void.class, new String[]{"crypto", "message", "decrypt"}, params);
-        Long end = System.currentTimeMillis();
-        System.out.println("duration decrypt: " + (end - start));
         return new PgpDecrypted((V8Object) cb_last_value[0]);
     }
 
     public PgpDecrypted crypto_message_decrypt(String data) {
         return crypto_message_decrypt(data, "");
     }
 
+    public PgpDecrypted crypto_message_decrypt(byte[] bytes) {
+        // db,account_email,encrypted_data,one_time_message_password,callback,force_output_format
+        V8Array params = new V8Array(v8).push(NULL).push("").push(uint8(bytes)).push("").push(cb_catcher).push(NULL);
+        this.call(void.class, new String[]{"crypto", "message", "decrypt"}, params);
+        return new PgpDecrypted((V8Object) cb_last_value[0]);
+    }
+
     public String api_gmail_query_backups(String account_email) {
         return (String) this.call(String.class, new String[]{"api", "gmail", "query", "backups"},
                 new V8Array(v8).push(account_email));
     }
 
     public IdToken api_auth_parse_id_token(String id_token) {
-        return new IdToken((V8Object) this.call(Object.class, new String[]{"api", "auth",
-                "parse_id_token"}, new V8Array(v8).push(id_token)));
+        return new IdToken((V8Object) this.call(Object.class, new String[]{"api", "auth", "parse_id_token"},
+                new V8Array(v8).push(id_token)));
     }
 
     /**
@@ -255,8 +247,8 @@ private static String read(InputStream inputStream) throws IOException {
     }
 
     private V8Object mime_reply_headers(MimeMessage original) {
-        return (V8Object) this.call(Object.class, new String[]{"mime", "reply_headers"}, new
-                V8Array(v8).push(original.getV8Object()));
+        return (V8Object) this.call(Object.class, new String[]{"mime", "reply_headers"}, new V8Array(v8)
+                .push(original.getV8Object()));
     }
 
     private Object call(Class<?> return_type, String path[], V8Array args) {
@@ -295,26 +287,19 @@ private V8Array array(String arr[]) {
 
     private void bindJavaMethods() {
         JavaMethodsForJavascript methods = new JavaMethodsForJavascript(v8, storage);
-        v8.registerJavaMethod(methods, "console_log", "engine_host_console_log", new
-                Class[]{String.class});
-        v8.registerJavaMethod(methods, "console_error", "engine_host_console_error", new
-                Class[]{String.class});
+        v8.registerJavaMethod(methods, "console_log", "engine_host_console_log", new Class[]{String.class});
+        v8.registerJavaMethod(methods, "console_error", "engine_host_console_error", new Class[]{String.class});
         v8.registerJavaMethod(methods, "alert", "engine_host_alert", new Class[]{String.class});
-        v8.registerJavaMethod(methods, "private_keys_get", "private_keys_get", new Class[]{String
-                .class, V8Array.class});
-        v8.registerJavaMethod(methods, "private_keys_get", "private_keys_get", new Class[]{String
-                .class, String.class});
-        v8.registerJavaMethod(methods, "private_keys_get", "private_keys_get", new Class[]{String
-                .class});
-        v8.registerJavaMethod(methods, "get_passphrase", "get_passphrase", new Class[]{String
-                .class, String.class});
-        v8.registerJavaMethod(methods, "java_mod_pow_strings", "java_mod_pow", new Class[]{String
-                .class, String.class, String.class});
-        v8.registerJavaMethod(methods, "secure_random", "engine_host_secure_random", new Class[]{
-                Integer.class});
+        v8.registerJavaMethod(methods, "private_keys_get", "private_keys_get", new Class[]{String.class, V8Array.class});
+        v8.registerJavaMethod(methods, "private_keys_get", "private_keys_get", new Class[]{String.class, String.class});
+        v8.registerJavaMethod(methods, "private_keys_get", "private_keys_get", new Class[]{String.class});
+        v8.registerJavaMethod(methods, "get_passphrase", "get_passphrase", new Class[]{String.class, String.class});
+        v8.registerJavaMethod(methods, "java_mod_pow_strings", "java_mod_pow", new Class[]{String.class, String.class,
+                String.class});
+        v8.registerJavaMethod(methods, "secure_random", "engine_host_secure_random", new Class[]{Integer.class});
         v8.registerJavaMethod(methods, "html_to_text", "html_to_text", new Class[]{String.class});
-        v8.registerJavaMethod(methods, "rsa_decrypt", "java_rsa_decrypt", new Class[]{String.class,
-                String.class, V8Array.class});
+        v8.registerJavaMethod(methods, "rsa_decrypt", "java_rsa_decrypt", new Class[]{String.class, String.class,
+                V8Array.class});
 
     }
 
@@ -361,61 +346,74 @@ class MeaningfulV8ObjectContainer {
         v8object = o;
     }
 
-    public V8Array getAttributeAsArray(String k) {
+    V8Array getAttributeAsArray(String k) {
         return getAttributeAsArray(v8object, k);
     }
 
-    public V8Array getAttributeAsArray(V8Object obj, String k) {
+    V8Object getAttributeAsObject(String name) {
+        return getAttributeAsObject(v8object, name);
+    }
+
+    Boolean getAttributeAsBoolean(String name) {
+        return getAttributeAsBoolean(v8object, name);
+    }
+
+    Integer getAttributeAsInteger(String name) {
+        return getAttributeAsInteger(v8object, name);
+    }
+
+    String getAttributeAsString(String k) {
+        return getAttributeAsString(v8object, k);
+    }
+
+    byte[] getAttributeAsBytes(String k) {
+        return getAttributeAsBytes(v8object, k);
+    }
+
+    static V8Array getAttributeAsArray(V8Object obj, String k) {
         try {
             return obj.getArray(k);
         } catch (V8ResultUndefined e) {
             return null;
         }
     }
 
-    public V8Object getAttributeAsObject(String name) {
-        return getAttributeAsObject(v8object, name);
-    }
-
-    public V8Object getAttributeAsObject(V8Object obj, String k) {
+    static V8Object getAttributeAsObject(V8Object obj, String k) {
         try {
             return obj.getObject(k);
         } catch (V8ResultUndefined e) {
             return null;
         }
     }
 
-    public Boolean getAttributeAsBoolean(String name) {
-        return getAttributeAsBoolean(v8object, name);
-    }
-
-    public Boolean getAttributeAsBoolean(V8Object obj, String k) {
+    static Boolean getAttributeAsBoolean(V8Object obj, String k) {
         try {
             return obj.getBoolean(k);
         } catch (V8ResultUndefined e) {
             return null;
         }
     }
 
-    public Integer getAttributeAsInteger(String name) {
-        return getAttributeAsInteger(v8object, name);
-    }
-
-    public Integer getAttributeAsInteger(V8Object obj, String k) {
+    static Integer getAttributeAsInteger(V8Object obj, String k) {
         try {
             return obj.getInteger(k);
         } catch (V8ResultUndefined e) {
             return null;
         }
     }
 
-    protected String getAttributeAsString(String k) {
-        return getAttributeAsString(v8object, k);
+    static String getAttributeAsString(V8Object obj, String k) {
+        try {
+            return obj.getString(k);
+        } catch (V8ResultUndefined e) {
+            return null;
+        }
     }
 
-    protected String getAttributeAsString(V8Object obj, String k) {
+    static byte[] getAttributeAsBytes(V8Object obj, String k) {
         try {
-            return obj.getString(k);
+            V8TypedArray typedArray = (V8TypedArray) obj.getObject(k);
+            return typedArray.getBytes(0, typedArray.length());
         } catch (V8ResultUndefined e) {
             return null;
         }
@@ -515,13 +513,11 @@ public BigInteger java_mod_pow(BigInteger b, BigInteger e, BigInteger m) {
     public String rsa_decrypt(String modulus, String exponent, V8Array encrypted) {
         try {
             KeyFactory keyFactory = KeyFactory.getInstance("RSA");
-            KeySpec keySpec = new RSAPrivateKeySpec(new BigInteger(modulus), new BigInteger
-                    (exponent));
+            KeySpec keySpec = new RSAPrivateKeySpec(new BigInteger(modulus), new BigInteger(exponent));
             PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
             Cipher decryptCipher = Cipher.getInstance("RSA/ECB/NoPadding");
             decryptCipher.init(Cipher.DECRYPT_MODE, privateKey);
-            byte[] decrypted_bytes = decryptCipher.doFinal(encrypted.getBytes(0, encrypted.length
-                    ()));
+            byte[] decrypted_bytes = decryptCipher.doFinal(encrypted.getBytes(0, encrypted.length()));
             return new BigInteger(decrypted_bytes).toString();
         } catch (Exception e) {
             System.out.println("JAVA RSA ERROR:" + e.getClass() + " --- " + e.getMessage());
diff --git a/FlowCrypt/src/main/java/com/flowcrypt/email/js/PgpDecrypted.java b/FlowCrypt/src/main/java/com/flowcrypt/email/js/PgpDecrypted.java
@@ -68,15 +68,23 @@ public String getContent() {
         if(content == null) {
             return null;
         }
-        return this.getAttributeAsString(content, "data"); // todo - may need to convert from uint8
+        return getAttributeAsString(content, "data");
+    }
+
+    public byte[] getBytes() {
+        V8Object content = this.getAttributeAsObject("content");
+        if(content == null) {
+            return null;
+        }
+        return getAttributeAsBytes(content, "data");
     }
 
     private Integer getCount(String name) {
         V8Object counts = this.getAttributeAsObject("counts");
         if(counts == null) {
             return null;
         }
-        return this.getAttributeAsInteger(counts, name);
+        return getAttributeAsInteger(counts, name);
     }
 
     private String[] getStrings(String name) {

Original file line number	Diff line number	Diff line change
`@@ -68,15 +68,23 @@ public String getContent() {`
`68`	`68`	`if(content == null) {`
`69`	`69`	`return null;`
`70`	`70`	`}`
`71`		`- return this.getAttributeAsString(content, "data"); // todo - may need to convert from uint8`
	`71`	`+ return getAttributeAsString(content, "data");`
	`72`	`+ }`
	`73`	`+`
	`74`	`+ public byte[] getBytes() {`
	`75`	`+ V8Object content = this.getAttributeAsObject("content");`
	`76`	`+ if(content == null) {`
	`77`	`+ return null;`
	`78`	`+ }`
	`79`	`+ return getAttributeAsBytes(content, "data");`
`72`	`80`	`}`
`73`	`81`
`74`	`82`	`private Integer getCount(String name) {`
`75`	`83`	`V8Object counts = this.getAttributeAsObject("counts");`
`76`	`84`	`if(counts == null) {`
`77`	`85`	`return null;`
`78`	`86`	`}`
`79`		`- return this.getAttributeAsInteger(counts, name);`
	`87`	`+ return getAttributeAsInteger(counts, name);`
`80`	`88`	`}`
`81`	`89`
`82`	`90`	`private String[] getStrings(String name) {`