@functionland/react-native-fula 0.4.0

package/android/src/main/java/land/fx/fula/Cryptography.java

@@ -0,0 +1,47 @@
+package land.fx.fula;
+
+import android.util.Base64;
+
+import java.io.UnsupportedEncodingException;
+import java.security.InvalidAlgorithmParameterException;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+import java.security.spec.InvalidKeySpecException;
+import java.security.spec.InvalidParameterSpecException;
+
+import javax.crypto.BadPaddingException;
+import javax.crypto.Cipher;
+import javax.crypto.IllegalBlockSizeException;
+import javax.crypto.NoSuchPaddingException;
+import javax.crypto.SecretKey;
+import javax.crypto.SecretKeyFactory;
+import javax.crypto.spec.PBEKeySpec;
+import javax.crypto.spec.SecretKeySpec;
+
+public class Cryptography {
+  public static String encryptMsg(String message, SecretKey secret)
+    throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, InvalidParameterSpecException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
+    Cipher cipher = null;
+    cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
+    cipher.init(Cipher.ENCRYPT_MODE, secret);
+    byte[] cipherText = cipher.doFinal(message.getBytes("UTF-8"));
+    return Base64.encodeToString(cipherText, Base64.NO_WRAP);
+  }
+
+  public static String decryptMsg(String cipherText, SecretKey secret)
+    throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidParameterSpecException, InvalidAlgorithmParameterException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException, UnsupportedEncodingException {
+    Cipher cipher = null;
+    cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
+    cipher.init(Cipher.DECRYPT_MODE, secret);
+    byte[] decode = Base64.decode(cipherText, Base64.NO_WRAP);
+    String decryptString = new String(cipher.doFinal(decode), "UTF-8");
+    return decryptString;
+  }
+
+  public static SecretKey generateKey(byte[] key)
+    throws NoSuchAlgorithmException, InvalidKeySpecException {
+    PBEKeySpec pbeKeySpec = new PBEKeySpec(StaticHelper.bytesToBase64(key).toCharArray(), key, 1000, 128);
+    SecretKey pbeKey = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256").generateSecret(pbeKeySpec);
+    return new SecretKeySpec(pbeKey.getEncoded(), "AES");
+  }
+}

package/android/src/main/java/land/fx/fula/FulaModule.java

@@ -0,0 +1,443 @@
+package land.fx.fula;
+
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.module.annotations.ReactModule;
+
+import org.jetbrains.annotations.Contract;
+
+import java.io.File;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+
+import javax.crypto.SecretKey;
+
+import fulamobile.Config;
+import fulamobile.Fulamobile;
+
+import land.fx.wnfslib.LibKt;
+
+@ReactModule(name = FulaModule.NAME)
+public class FulaModule extends ReactContextBaseJavaModule {
+  public static final String NAME = "FulaModule";
+  fulamobile.Client fula;
+  Client client;
+  String appDir;
+  String fulaStorePath;
+  String privateForest;
+  land.fx.wnfslib.Config rootConfig;
+  SharedPreferenceHelper sharedPref;
+  static String PRIVATE_KEY_STORE_ID = "PRIVATE_KEY";
+
+  public class Client implements land.fx.wnfslib.Client {
+
+    private fulamobile.Client internalClient;
+
+    Client(fulamobile.Client clientInput) {
+      internalClient = clientInput;
+    }
+
+    @NonNull
+    @Override
+    public byte[] get(@NonNull byte[] cid) {
+      try {
+        internalClient.get(cid);
+      } catch (Exception e) {
+        e.printStackTrace();
+      }
+      return null;
+    }
+
+    @NonNull
+    @Override
+    public byte[] put(@NonNull byte[] data, long codec) {
+      try {
+        return client.put(data, codec);
+      } catch (Exception e) {
+        e.printStackTrace();
+      }
+      return null;
+    }
+  }
+
+  public FulaModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+    appDir = reactContext.getFilesDir().toString();
+    fulaStorePath = appDir + "/fula";
+    File storeDir = new File(fulaStorePath);
+    sharedPref = SharedPreferenceHelper.getInstance(reactContext.getApplicationContext());
+    boolean success = true;
+    if (!storeDir.exists()) {
+      success = storeDir.mkdirs();
+    }
+    if (success) {
+      Log.d(NAME, "Fula store folder created");
+    } else {
+      Log.d(NAME, "Unable to create fula store folder!");
+    }
+  }
+
+  @Override
+  @NonNull
+  public String getName() {
+    return NAME;
+  }
+
+
+  private byte[] toByte(@NonNull String input) {
+    return input.getBytes(StandardCharsets.UTF_8);
+  }
+
+  @NonNull
+  @Contract("_ -> new")
+  private String toString(byte[] input) {
+    return new String(input, StandardCharsets.UTF_8);
+  }
+
+  @NonNull
+  private static int[] stringArrToIntArr(@NonNull String[] s) {
+    int[] result = new int[s.length];
+    for (int i = 0; i < s.length; i++) {
+      result[i] = Integer.parseInt(s[i]);
+    }
+    return result;
+  }
+
+  @NonNull
+  @Contract(pure = true)
+  private static byte[] convertIntToByte(@NonNull int[] input) {
+    byte[] result = new byte[input.length];
+    for (int i = 0; i < input.length; i++) {
+      byte b = (byte) input[i];
+      result[i] = b;
+    }
+    return result;
+  }
+
+  @NonNull
+  private static byte[] convertStringToByte(@NonNull String data) {
+    String[] keyInt_S = data.split(",");
+    int[] keyInt = stringArrToIntArr(keyInt_S);
+
+    return convertIntToByte(keyInt);
+  }
+
+  @ReactMethod
+  public void init(String identityString, String storePath, String bloxAddr, Promise promise) {
+    Log.d("ReactNative", "init started");
+    ThreadUtils.runOnExecutor(() -> {
+      try {
+        Log.d("ReactNative", "init storePath= " + storePath);
+        byte[] identity = toByte(identityString);
+        Log.d("ReactNative", "init identity= " + identityString);
+        String[] obj = initInternal(identity, storePath, bloxAddr);
+        Log.d("ReactNative", "init object created: [ " + obj[0] + ", " + obj[1] + ", " + obj[2] + " ]");
+        promise.resolve(obj);
+      } catch (Exception e) {
+        Log.d("ReactNative", "init failed with Error: " + e.getMessage());
+        promise.reject(e);
+      }
+    });
+  }
+
+  @NonNull
+  private byte[] createPeerIdentity(byte[] privateKey) throws Exception {
+    try {
+      // 1: First: create public key from provided private key
+      // 2: Should read the local keychain store (if it is key-value, key is public key above,
+      // 3: if found, decrypt using the private key
+      // 4: If not found or decryption not successful, generate an identity
+      // 5: then encrypt and store in keychain
+
+      String encryptedKey = sharedPref.getValue(PRIVATE_KEY_STORE_ID);
+      SecretKey secretKey = Cryptography.generateKey(privateKey);
+      if (encryptedKey == null) {
+        byte[] autoGeneratedIdentity = Fulamobile.generateEd25519Key();
+        encryptedKey = Cryptography.encryptMsg(StaticHelper.bytesToBase64(autoGeneratedIdentity), secretKey);
+        sharedPref.add(PRIVATE_KEY_STORE_ID, encryptedKey);
+      }
+      return StaticHelper.base64ToBytes(Cryptography.decryptMsg(encryptedKey, secretKey));
+
+    } catch (Exception e) {
+      Log.d("ReactNative", "createPeerIdentity failed with Error: " + e.getMessage());
+      throw (e);
+    }
+  }
+
+  @NonNull
+  private String[] initInternal(byte[] identity, String storePath, String bloxAddr) throws Exception {
+    try {
+      Config config_ext = new Config();
+      if (storePath == null || storePath.trim().isEmpty()) {
+        config_ext.setStorePath(fulaStorePath);
+      } else {
+        config_ext.setStorePath(storePath);
+      }
+      Log.d("ReactNative", "storePath is set: " + config_ext.getStorePath());
+
+      byte[] peerIdentity = createPeerIdentity(identity);
+      config_ext.setIdentity(peerIdentity);
+      Log.d("ReactNative", "peerIdentity is set: " + toString(config_ext.getIdentity()));
+      config_ext.setBloxAddr(bloxAddr);
+      Log.d("ReactNative", "bloxAddr is set: " + config_ext.getBloxAddr());
+      this.fula = Fulamobile.newClient(config_ext);
+      this.client = new Client(this.fula);
+      Log.d("ReactNative", "fula initialized: " + this.fula.id());
+      if (this.rootConfig == null) {
+        Log.d("ReactNative", "creating rootConfig");
+        this.privateForest = LibKt.createPrivateForest(this.client);
+        Log.d("ReactNative", "privateForest is created: " + this.privateForest);
+        this.rootConfig = LibKt.createRootDir(this.client, this.privateForest);
+        Log.d("ReactNative", "rootConfig is created: " + this.rootConfig.getCid());
+      } else {
+        Log.d("ReactNative", "rootConfig existed: " + this.rootConfig.getCid());
+      }
+      String peerId = this.fula.id();
+      String[] obj = new String[3];
+      obj[0] = peerId;
+      obj[1] = this.rootConfig.getCid();
+      obj[2] = this.rootConfig.getPrivate_ref();
+      Log.d("ReactNative", "initInternal is completed successfully");
+      return obj;
+    } catch (Exception e) {
+      Log.d("ReactNative", "init internal failed with Error: " + e.getMessage());
+      throw (e);
+    }
+  }
+
+  @ReactMethod
+  public void mkdir(String path, Promise promise) {
+    ThreadUtils.runOnExecutor(() -> {
+      Log.d("ReactNative", "mkdir: path = " + path);
+      try {
+        land.fx.wnfslib.Config config = LibKt.mkdir(this.client, this.rootConfig.getCid(), this.rootConfig.getPrivate_ref(), path);
+        this.rootConfig = config;
+        promise.resolve(config.getCid());
+      } catch (Exception e) {
+        Log.d("get", e.getMessage());
+        promise.reject(e);
+      }
+    });
+  }
+
+  @ReactMethod
+  public void writeFile(String fulaTargetFilename, String localFilename, Promise promise) {
+    /*
+    // reads content of the file form localFilename (should include full absolute path to local file with read permission
+    // writes content to the specified location by fulaTargetFilename in Fula filesystem
+    // fulaTargetFilename: a string including full path and filename of target file on Fula (e.g. root/pictures/cat.jpg)
+    // localFilename: a string containing full path and filename of local file on hte device (e.g /usr/bin/cat.jpg)
+    // Returns: new cid of the root after this file is placed in the tree
+     */
+    ThreadUtils.runOnExecutor(() -> {
+      Log.d("ReactNative", "writeFile to : path = " + fulaTargetFilename + ", from: " + localFilename);
+      try {
+        land.fx.wnfslib.Config config = LibKt.writeFileFromPath(this.client, this.rootConfig.getCid(), this.rootConfig.getPrivate_ref(), fulaTargetFilename, localFilename);
+        this.rootConfig = config;
+        promise.resolve(config.getCid());
+      } catch (Exception e) {
+        Log.d("get", e.getMessage());
+        promise.reject(e);
+      }
+    });
+  }
+
+  @ReactMethod
+  public void writeFileContent(String path, String contentString, Promise promise) {
+    ThreadUtils.runOnExecutor(() -> {
+      Log.d("ReactNative", "writeFile: contentString = " + contentString);
+      Log.d("ReactNative", "writeFile: path = " + path);
+      try {
+        byte[] content = convertStringToByte(contentString);
+        land.fx.wnfslib.Config config = LibKt.writeFile(this.client, this.rootConfig.getCid(), this.rootConfig.getPrivate_ref(), path, content);
+        this.rootConfig = config;
+        promise.resolve(config.getCid());
+      } catch (Exception e) {
+        Log.d("get", e.getMessage());
+        promise.reject(e);
+      }
+    });
+  }
+
+  @ReactMethod
+  public void ls(String path, Promise promise) {
+    ThreadUtils.runOnExecutor(() -> {
+      Log.d("ReactNative", "ls: path = " + path);
+      try {
+        String res = LibKt.ls(this.client, this.rootConfig.getCid(), this.rootConfig.getPrivate_ref(), path);
+        promise.resolve(res);
+      } catch (Exception e) {
+        Log.d("get", e.getMessage());
+        promise.reject(e);
+      }
+    });
+  }
+
+  @ReactMethod
+  public void readFile(String path, Promise promise) {
+    ThreadUtils.runOnExecutor(() -> {
+      Log.d("ReactNative", "ls: path = " + path);
+      try {
+        byte[] res = LibKt.readFile(this.client, this.rootConfig.getCid(), this.rootConfig.getPrivate_ref(), path);
+        String resString = toString(res);
+        promise.resolve(resString);
+      } catch (Exception e) {
+        Log.d("get", e.getMessage());
+        promise.reject(e);
+      }
+    });
+  }
+
+  @ReactMethod
+  public void get(String keyString, Promise promise) {
+    ThreadUtils.runOnExecutor(() -> {
+      Log.d("ReactNative", "get: keyString = " + keyString);
+      try {
+        byte[] key = convertStringToByte(keyString);
+        byte[] value = getInternal(key);
+        String valueString = toString(value);
+        promise.resolve(valueString);
+      } catch (Exception e) {
+        Log.d("get", e.getMessage());
+        promise.reject(e);
+      }
+    });
+  }
+
+  @NonNull
+  private byte[] getInternal(byte[] key) throws Exception {
+    try {
+      Log.d("ReactNative", "getInternal: key.toString() = " + toString(key));
+      Log.d("ReactNative", "getInternal: key.toString().bytes = " + Arrays.toString(key));
+      byte[] value = this.fula.get(key);
+      Log.d("ReactNative", "getInternal: value.toString() = " + toString(value));
+      return value;
+    } catch (Exception e) {
+      Log.d("ReactNative", "getInternal: error = " + e.getMessage());
+      Log.d("getInternal", e.getMessage());
+      throw (e);
+    }
+  }
+
+  @ReactMethod
+  public void has(String keyString, Promise promise) {
+    ThreadUtils.runOnExecutor(() -> {
+      Log.d("ReactNative", "has: keyString = " + keyString);
+      try {
+        byte[] key = convertStringToByte(keyString);
+        boolean result = hasInternal(key);
+        promise.resolve(result);
+      } catch (Exception e) {
+        Log.d("get", e.getMessage());
+        promise.reject(e);
+      }
+    });
+  }
+
+  @NonNull
+  private boolean hasInternal(byte[] key) throws Exception {
+    try {
+      boolean res = this.fula.has(key);
+      return res;
+    } catch (Exception e) {
+      Log.d("hasInternal", e.getMessage());
+      throw (e);
+    }
+  }
+
+  @NonNull
+  private void pullInternal(byte[] key) throws Exception {
+    try {
+      this.fula.pull(key);
+    } catch (Exception e) {
+      Log.d("pullInternal", e.getMessage());
+      throw (e);
+    }
+  }
+
+  @ReactMethod
+  public void push(Promise promise) {
+    ThreadUtils.runOnExecutor(() -> {
+      Log.d("ReactNative", "push started");
+      try {
+        pushInternal(convertStringToByte(this.rootConfig.getCid()));
+        promise.resolve(this.rootConfig.getCid());
+      } catch (Exception e) {
+        Log.d("get", e.getMessage());
+        promise.reject(e);
+      }
+    });
+  }
+
+  @NonNull
+  private void pushInternal(byte[] key) throws Exception {
+    try {
+      if (this.fula.has(key)) {
+        this.fula.push(key);
+      } else {
+        Log.d("pushInternal", "error: key wasn't found");
+        throw new Exception("key wasn't found in local storage");
+      }
+    } catch (Exception e) {
+      Log.d("pushInternal", e.getMessage());
+      throw (e);
+    }
+  }
+
+  @ReactMethod
+  public void put(String valueString, String codecString, Promise promise) {
+    ThreadUtils.runOnExecutor(() -> {
+      Log.d("ReactNative", "put: codecString = " + codecString);
+      Log.d("ReactNative", "put: valueString = " + valueString);
+      try {
+        //byte[] codec = convertStringToByte(CodecString);
+        long codec = Long.parseLong(codecString);
+
+
+        Log.d("ReactNative", "put: codec = " + codec);
+        byte[] value = toByte(valueString);
+
+        Log.d("ReactNative", "put: value.toString() = " + toString(value));
+        byte[] key = putInternal(value, codec);
+        Log.d("ReactNative", "put: key.toString() = " + toString(key));
+        promise.resolve(toString(key));
+      } catch (Exception e) {
+        Log.d("ReactNative", "put: error = " + e.getMessage());
+        Log.d("put", e.getMessage());
+        promise.reject(e);
+      }
+    });
+  }
+
+  @NonNull
+  private byte[] putInternal(byte[] value, long codec) throws Exception {
+    try {
+      byte[] key = this.fula.put(value, codec);
+      return key;
+    } catch (Exception e) {
+      Log.d("putInternal", e.getMessage());
+      throw (e);
+    }
+  }
+
+  @ReactMethod
+  public void shutdown(Promise promise) {
+    ThreadUtils.runOnExecutor(() -> {
+      try {
+        fula.shutdown();
+        promise.resolve(true);
+      } catch (Exception e) {
+        promise.reject(e);
+        Log.d("shutdown", e.getMessage());
+      }
+    });
+
+  }
+
+}

package/android/src/main/java/land/fx/fula/FulaPackage.java

@@ -0,0 +1,32 @@
+package land.fx.fula;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class FulaPackage implements ReactPackage {
+  @NonNull
+  @Override
+  public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+      List<NativeModule> modules = new ArrayList<>();
+      try {
+          modules.add(new FulaModule(reactContext));
+      } catch (Exception e) {
+          e.printStackTrace();
+      }
+      return modules;
+  }
+
+  @NonNull
+  @Override
+  public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+      return Collections.emptyList();
+  }
+}

package/android/src/main/java/land/fx/fula/SharedPreferenceHelper.java

@@ -0,0 +1,65 @@
+package land.fx.fula;
+
+import static android.content.Context.MODE_PRIVATE;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.util.Log;
+
+public class SharedPreferenceHelper {
+  private static SharedPreferenceHelper me;
+  private static String sharedPrefName;
+  private static Context context;
+
+  private SharedPreferenceHelper() {
+  }
+
+  public static SharedPreferenceHelper getInstance(Context cntx) {
+    if (me == null) {
+      me = new SharedPreferenceHelper();
+    }
+    context = cntx;
+    sharedPrefName = "APP_KEY_PAIR_VALUE";
+    return me;
+  }
+
+  public String getValue(String key) {
+    SharedPreferences prefs = context.getSharedPreferences(sharedPrefName, MODE_PRIVATE);
+    return prefs.getString(key, null);
+  }
+
+  public boolean getBooleanValue(String key) {
+    SharedPreferences prefs = context.getSharedPreferences(sharedPrefName, MODE_PRIVATE);
+    return prefs.getBoolean(key, false);
+  }
+
+  public SharedPreferenceHelper add(String key, String value) {
+    try {
+      context.getSharedPreferences(sharedPrefName, MODE_PRIVATE).edit().putString(key, value).apply();
+      return me;
+    } catch (Exception ex) {
+      Log.e("React-Native-Fula", "SharedPrefHandler: AddSharedPref: Exception: " + ex.getMessage(), ex);
+      throw ex;
+    }
+  }
+
+  public SharedPreferenceHelper add(String key, boolean value) {
+    try {
+      context.getSharedPreferences(sharedPrefName, MODE_PRIVATE).edit().putBoolean(key, value).apply();
+      return me;
+    } catch (Exception e) {
+      Log.e("React-Native-Fula", "SharedPrefHandler: AddSharedPref: Exception: " + e.getMessage(), e);
+      throw e;
+    }
+  }
+
+  public SharedPreferenceHelper remove(String key) {
+    try {
+      context.getSharedPreferences(sharedPrefName, MODE_PRIVATE).edit().remove(key).apply();
+      return me;
+    } catch (Exception ex) {
+      Log.e("React-Native-Fula", "SharedPrefHandler: AddSharedPref: Exception: " + ex.getMessage(), ex);
+      throw ex;
+    }
+  }
+}

package/android/src/main/java/land/fx/fula/StaticHelper.java

@@ -0,0 +1,13 @@
+package land.fx.fula;
+
+import java.util.Base64;
+
+public class StaticHelper {
+  public static String bytesToBase64(byte[] bytes) {
+    return Base64.getEncoder().encodeToString(bytes);
+  }
+
+  public static byte[] base64ToBytes(String base64) {
+    return Base64.getDecoder().decode(base64);
+  }
+}

package/android/src/main/java/land/fx/fula/ThreadUtils.java

@@ -0,0 +1,42 @@
+package land.fx.fula;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+final class ThreadUtils {
+    /**
+     * Thread which will be used to call all APIs. They
+     * they don't run on the calling thread anyway, we are deferring the calls
+     * to this thread to avoid (potentially) blocking the calling thread.
+     */
+    private static final ExecutorService executor
+        = Executors.newSingleThreadExecutor();
+
+    /**
+     * Runs the given {@link Runnable} on the executor.
+     * @param runnable
+     */
+    public static void runOnExecutor(Runnable runnable) {
+        executor.execute(runnable);
+    }
+
+    /**
+     * Submits the given {@link Callable} to be run on the executor.
+     * @param callable
+     * @return Future.
+     */
+    public static <T> Future<T> submitToExecutor(Callable<T> callable) {
+        return executor.submit(callable);
+    }
+
+    /**
+     * Submits the given {@link Runnable} to be run on the executor.
+     * @param runnable
+     * @return Future.
+     */
+    public static Future<?> submitToExecutor(Runnable runnable) {
+        return executor.submit(runnable);
+    }
+}

package/ios/FulaModule.h

@@ -0,0 +1,10 @@
+#import <React/RCTBridgeModule.h>
+#import <Mobile/Mobile.h>
+
+@interface FulaModule : NSObject <RCTBridgeModule> {
+    MobileFula *fula;
+}
+
+- (MobileFula *) fula;
+
+@end