feat: add bytes methods and using embeded TextEncoder and TextDecoder (#95)

* feat: add bytes methods and using embeded TextEncoder and TextDecoder

* chore: remove extra .js

* chore: fix types

Author: jerson

README.md

@@ -10,12 +10,12 @@
 ## JSI
 
 
-If you want to use with `JSI` instead of `NativeModules` you need to set
+If you want to use with `NativeModules` instead of `JSI` you need to set
 
 ```typescript
 import RSA from "react-native-fast-rsa";
 
-RSA.useJSI = true;
+RSA.useJSI = false;
 ```
 if you need to use generate methods it is a good idea to disable it, because for now JSI will block your UI but it is faster compared to NativeModules
 
@@ -78,15 +78,27 @@ class RSA {
   static decryptOAEP(message: string, label: string, hashName: Hash, privateKey: string): Promise<string>
   static decryptPKCS1v15(message: string, privateKey: string,): Promise<string>
 
+  static decryptOAEPBytes(message: Uint8Array, label: string, hashName: Hash, privateKey: string): Promise<Uint8Array>
+  static decryptPKCS1v15Bytes(message: Uint8Array, privateKey: string,): Promise<Uint8Array>
+
   static encryptOAEP(message: string,label: string, hashName: Hash, publicKey: string): Promise<string>
   static encryptPKCS1v15(message: string, publicKey: string): Promise<string>
 
+  static encryptOAEPBytes(message: Uint8Array,label: string, hashName: Hash, publicKey: string): Promise<Uint8Array>
+  static encryptPKCS1v15Bytes(message: Uint8Array, publicKey: string): Promise<Uint8Array>
+
   static signPSS(message: string, hashName: Hash, saltLengthName: SaltLength, privateKey: string): Promise<string>
   static signPKCS1v15(message: string, hashName: Hash, privateKey: string): Promise<string>
 
+  static signPSSBytes(message: Uint8Array, hashName: Hash, saltLengthName: SaltLength, privateKey: string): Promise<Uint8Array>
+  static signPKCS1v15Bytes(message: Uint8Array, hashName: Hash, privateKey: string): Promise<Uint8Array>
+
   static verifyPSS(signature: string, message: string, hashName: Hash, saltLengthName: SaltLength, publicKey: string): Promise<boolean>
   static verifyPKCS1v15(signature: string, message: string, hashName: Hash, publicKey: string): Promise<boolean>
 
+  static verifyPSSBytes(signature: Uint8Array, message: Uint8Array, hashName: Hash, saltLengthName: SaltLength, publicKey: string): Promise<boolean>
+  static verifyPKCS1v15Bytes(signature: Uint8Array, message: Uint8Array, hashName: Hash, publicKey: string): Promise<boolean>
+
   static hash(message: string, name: Hash): Promise<string>
   static base64(message: string): Promise<string>
 

android/fast-rsa-adapter.cpp

@@ -93,4 +93,97 @@ Java_com_fastrsa_FastRsaModule_callNative(JNIEnv* env,
   free(response);
 
   return result;
+}
+
+extern "C" JNIEXPORT jbyteArray JNICALL
+Java_com_fastrsa_FastRsaModule_encodeTextNative(JNIEnv* env, jobject thiz, jstring input, jstring encoding) {
+    if (input == nullptr || encoding == nullptr) {
+        jclass Exception = env->FindClass("java/lang/NullPointerException");
+        env->ThrowNew(Exception, "Input parameters 'input' or 'encoding' cannot be null");
+        return nullptr;
+    }
+
+    // Convert Java Strings to C Strings
+    const char* inputCStr = env->GetStringUTFChars(input, nullptr);
+    const char* encodingCStr = env->GetStringUTFChars(encoding, nullptr);
+
+    if (inputCStr == nullptr || encodingCStr == nullptr) {
+        jclass Exception = env->FindClass("java/lang/OutOfMemoryError");
+        env->ThrowNew(Exception, "Failed to allocate memory for 'input' or 'encoding'");
+        return nullptr;
+    }
+
+    // Call the shared library function
+    BytesReturn* response = RSAEncodeText(const_cast<char*>(inputCStr), const_cast<char*>(encodingCStr));
+
+    // Release allocated resources
+    env->ReleaseStringUTFChars(input, inputCStr);
+    env->ReleaseStringUTFChars(encoding, encodingCStr);
+
+    if (response->error != nullptr) {
+        jclass Exception = env->FindClass("java/lang/Exception");
+        env->ThrowNew(Exception, response->error);
+        free(response);
+        return nullptr;
+    }
+
+    // Create a new byte array to return the encoded data
+    jbyteArray result = env->NewByteArray(response->size);
+    if (result == nullptr) {
+        free(response);
+        jclass Exception = env->FindClass("java/lang/OutOfMemoryError");
+        env->ThrowNew(Exception, "Failed to allocate memory for result");
+        return nullptr;
+    }
+
+    env->SetByteArrayRegion(result, 0, response->size, reinterpret_cast<jbyte*>(response->message));
+    free(response);
+
+    return result;
+}
+
+extern "C" JNIEXPORT jstring JNICALL
+Java_com_fastrsa_FastRsaModule_decodeTextNative(JNIEnv* env, jobject thiz, jbyteArray input, jstring encoding, 
+                                          jint fatal, jint ignoreBOM, jint stream) {
+    if (input == nullptr || encoding == nullptr) {
+        jclass Exception = env->FindClass("java/lang/NullPointerException");
+        env->ThrowNew(Exception, "Input parameters 'input' or 'encoding' cannot be null");
+        return nullptr;
+    }
+
+    // Convert Java Strings to C Strings
+    const char* encodingCStr = env->GetStringUTFChars(encoding, nullptr);
+    if (encodingCStr == nullptr) {
+        jclass Exception = env->FindClass("java/lang/OutOfMemoryError");
+        env->ThrowNew(Exception, "Failed to allocate memory for 'encoding'");
+        return nullptr;
+    }
+
+    // Convert Java byte array to C byte array
+    jsize size = env->GetArrayLength(input);
+    jbyte* inputBytes = env->GetByteArrayElements(input, nullptr);
+    if (inputBytes == nullptr) {
+        env->ReleaseStringUTFChars(encoding, encodingCStr);
+        jclass Exception = env->FindClass("java/lang/OutOfMemoryError");
+        env->ThrowNew(Exception, "Failed to allocate memory for 'input'");
+        return nullptr;
+    }
+
+    // Call the shared library function
+    char* decodedString = RSADecodeText(inputBytes, size, const_cast<char*>(encodingCStr), fatal, ignoreBOM, stream);
+
+    // Release resources
+    env->ReleaseStringUTFChars(encoding, encodingCStr);
+    env->ReleaseByteArrayElements(input, inputBytes, JNI_ABORT);
+
+    if (decodedString == nullptr) {
+        jclass Exception = env->FindClass("java/lang/Exception");
+        env->ThrowNew(Exception, "Decoding failed");
+        return nullptr;
+    }
+
+    // Convert C string to Java string and return
+    jstring result = env->NewStringUTF(decodedString);
+    free(decodedString);
+    return result;
 }

android/src/main/java/com/fastrsa/FastRsaModule.kt

@@ -11,6 +11,8 @@ internal class FastRsaModule(reactContext: ReactApplicationContext) :
   external fun initialize(jsContext: Long)
   external fun destruct();
   external fun callNative(name: String, payload: ByteArray): ByteArray;
+  external fun encodeTextNative(input: String, encoding: String): ByteArray
+  external fun decodeTextNative(input: ByteArray, encoding: String, fatal: Int, ignoreBOM: Int, stream: Int): String
 
   companion object {
     init {
@@ -41,6 +43,32 @@ internal class FastRsaModule(reactContext: ReactApplicationContext) :
     }.start()
   }
 
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun encodeText(input: String, encoding: String): WritableArray {
+      return try {
+          val result = encodeTextNative(input, encoding) 
+          Arguments.createArray().apply {
+              result.forEach { byteValue: Byte -> pushInt(byteValue.toInt() and 0xFF) } 
+          }
+      } catch (e: Exception) {
+          Log.e(TAG, "Encoding error", e)
+          throw RuntimeException("ENCODE_ERROR: Failed to encode text")
+      }
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun decodeText(input: ReadableArray, encoding: String, fatal: Boolean, ignoreBOM: Boolean, stream: Boolean): String {
+      return try {
+          val bytes = ByteArray(input.size()) { index ->
+              input.getInt(index).toByte()
+          }
+          decodeTextNative(bytes, encoding, if (fatal) 1 else 0, if (ignoreBOM) 1 else 0, if (stream) 1 else 0)
+      } catch (e: Exception) {
+          Log.e(TAG, "Decoding error", e)
+          throw RuntimeException("DECODE_ERROR: Failed to decode text")
+      }
+  }
+
   @ReactMethod(isBlockingSynchronousMethod = true)
   fun install(): Boolean {
       Log.d(TAG, "Attempting to install JSI bindings...")

android/src/main/jniLibs/arm64-v8a/librsa_bridge.h

@@ -81,6 +81,8 @@ extern "C" {
 #endif
 
 extern BytesReturn* RSABridgeCall(char* name, void* payload, int payloadSize);
+extern BytesReturn* RSAEncodeText(char* input, char* encoding);
+extern char* RSADecodeText(void* input, int size, char* encoding, int fatal, int ignoreBOM, int stream);
 
 #ifdef __cplusplus
 }

android/src/main/jniLibs/arm64-v8a/librsa_bridge.so

@@ -81,6 +81,8 @@ extern "C" {
 #endif
 
 extern BytesReturn* RSABridgeCall(char* name, void* payload, int payloadSize);
+extern BytesReturn* RSAEncodeText(char* input, char* encoding);
+extern char* RSADecodeText(void* input, int size, char* encoding, int fatal, int ignoreBOM, int stream);
 
 #ifdef __cplusplus
 }

android/src/main/jniLibs/armeabi-v7a/librsa_bridge.h

@@ -81,6 +81,8 @@ extern "C" {
 #endif
 
 extern BytesReturn* RSABridgeCall(char* name, void* payload, int payloadSize);
+extern BytesReturn* RSAEncodeText(char* input, char* encoding);
+extern char* RSADecodeText(void* input, int size, char* encoding, int fatal, int ignoreBOM, int stream);
 
 #ifdef __cplusplus
 }

android/src/main/jniLibs/armeabi-v7a/librsa_bridge.so

@@ -81,6 +81,8 @@ extern "C" {
 #endif
 
 extern BytesReturn* RSABridgeCall(char* name, void* payload, int payloadSize);
+extern BytesReturn* RSAEncodeText(char* input, char* encoding);
+extern char* RSADecodeText(void* input, int size, char* encoding, int fatal, int ignoreBOM, int stream);
 
 #ifdef __cplusplus
 }