chore: rsa base64decode add

Author: ko-devHong

android/src/main/java/com/cryptorsa/CryptoRsa.kt

@@ -255,6 +255,12 @@ class CryptoRsa(originReactContext: ReactApplicationContext, keySize:Int?) {
     return String(cipher.doFinal(decryptedData), Charsets.UTF_8)
   }
 
+  @Throws(NoSuchAlgorithmException::class, InvalidKeySpecException::class, IllegalBlockSizeException::class, BadPaddingException::class, NoSuchPaddingException::class, InvalidKeyException::class)
+  fun base64Decode(base64String: String): String? {
+    val originValues = Base64.decode(base64String,Base64.DEFAULT)
+    return originValues.toString()
+  }
+
   companion object {
     private var originKeySize = 2048
     private lateinit var reactContext: ReactApplicationContext;

android/src/main/java/com/cryptorsa/CryptoRsaModule.kt

@@ -75,6 +75,13 @@ class CryptoRsaModule(reactContext: ReactApplicationContext) :
     }
   }
 
+  @ReactMethod
+  fun base64Decode(base64String: String,promise: Promise) {
+    runBlocking {
+      launch { promise.resolve(cryptoRsa.base64Decode(base64String))  }
+    }
+  }
+
   companion object {
     const val NAME = "CryptoRsa"
     private lateinit var cryptoRsa: CryptoRsa

example/src/App.tsx

@@ -14,18 +14,21 @@ export default function App() {
       try {
         const { publicKey } = await RNCryptoRsa.init();
         setPublicString(publicKey);
-        // console.log('@publicKey  : ', publicKey);
+        console.log('@publicKey  : ', publicKey);
         // console.log('privateKey : ', privateKey);
         const encryptBase64String = await RNCryptoRsa.encrypt(
           'hello world',
           publicKey
         );
         console.log('@encryptBase64String : ', encryptBase64String);
-        RNCryptoRsa.decrypt(encryptBase64String)
-          .then((rrr) => {
-            console.log('@decrypt String : ', rrr);
-          })
-          .catch(console.error);
+        RNCryptoRsa.base64Decode(encryptBase64String).then((str) =>
+          console.log('base64Decode', str)
+        );
+        // RNCryptoRsa.decrypt(encryptBase64String)
+        //   .then((rrr) => {
+        //     console.log('@decrypt String : ', rrr);
+        //   })
+        //   .catch(console.error);
       } catch (e) {
         console.error('error : ', e);
       }
@@ -35,6 +38,7 @@ export default function App() {
   const decryptString = async () => {
     console.log('base64String : ', base64String);
     const originString = await RNCryptoRsa.decrypt(base64String);
+    console.log('originString : ', originString);
     setResult(originString);
   };
 

ios/CryptoRsa.swift

@@ -35,13 +35,16 @@ class CryptoRsa: NSObject {
     }
 
     func getKeyFromKeychain(tag: String) -> SecKey? {
-        let query: [String: Any] = [
+        var query: [String: Any] = [
             kSecClass as String: kSecClassKey,
             kSecAttrApplicationTag as String: tag,
             kSecAttrKeyType as String: kSecAttrKeyTypeRSA,
-            kSecReturnRef as String: true,
-            kSecReturnData as String: kCFBooleanTrue ?? true
         ]
+        if(tag == publicTag) {
+            query[kSecReturnData as String] = kCFBooleanTrue ?? true
+        } else {
+            query[kSecReturnRef as String] = true
+        }
 
         var item: CFTypeRef?
         let status = SecItemCopyMatching(query as CFDictionary, &item)
@@ -178,6 +181,11 @@ class CryptoRsa: NSObject {
     func encrypt(message: String, pemString: String,resolve:RCTPromiseResolveBlock,reject:RCTPromiseRejectBlock) -> Void {
         guard let data = message.data(using: .utf8) else { return reject(nil,nil,RuntimeError("Data is null")) }
 
+        // 데이터 크기 확인 (예시: RSA 키 크기 2048비트, 최대 데이터 크기 245바이트)
+        if data.count > 245 {
+            return reject(nil, nil, RuntimeError("Data size too large for RSA encryption"))
+        }
+        
         guard let publicKey = pemStringToPublicKey(pemString) else {
             return reject(nil,nil,RuntimeError("pemStringTopublicKey is null"))
         }
@@ -193,34 +201,39 @@ class CryptoRsa: NSObject {
             return reject(nil, nil, RuntimeError("Encryption error: \((error?.takeRetainedValue())!)"))
         }
 
-        resolve(cipherData.base64EncodedString())
+        resolve(base64EncodeString(cipherData))
     }
 
     @objc(decrypt:withResolver:withRejecter:)
     func decrypt(encryptedDataString: String, resolve:RCTPromiseResolveBlock,reject:RCTPromiseRejectBlock) -> Any? {
         guard let encryptedData = base64Decode(encryptedDataString) else {
-            print("base64Decode Faild")
-            return reject(nil,nil,RuntimeError("base64Decode Faild"))
+            print("base64Decode Failed")
+            return reject(nil, nil, RuntimeError("base64Decode Failed"))
         }
-        guard let loadedPrivateKey = getKeyFromKeychain(tag: privateTag ) else {
-            print("Load Faild privateKey in KeyChain ")
-            return reject(nil,nil,RuntimeError("Keychain Load failed"))
+        
+        guard let loadedPrivateKey = getKeyFromKeychain(tag: privateTag) else {
+            print("Load Failed privateKey in KeyChain")
+            reject(nil, nil, RuntimeError("Keychain Load failed"))
+            return nil
+        }
+        
+        // Check if the encrypted data size matches the key size
+        let blockSize = SecKeyGetBlockSize(loadedPrivateKey)
+        if encryptedData.count != blockSize {
+            print("Encrypted data size does not match key block size")
+            reject(nil, nil, RuntimeError("Encrypted data size does not match key block size"))
+            return nil
         }
-        print("Load privateKey in KeyChain :", loadedPrivateKey)
 
         guard SecKeyIsAlgorithmSupported(loadedPrivateKey, .decrypt, secKeyAlgorithm) else {
-            reject(nil,nil,RuntimeError("SecKeyIsAlgorithm not supported"))
+            reject(nil, nil, RuntimeError("SecKeyIsAlgorithm not supported"))
             return nil
         }
-        var error: Unmanaged<CFError>?
 
-        guard let clearData = SecKeyCreateDecryptedData(loadedPrivateKey,
-                                                        secKeyAlgorithm,
-                                                        encryptedData as CFData,
-                                                        &error) as Data? else {
-            print("Decryption error: \((error?.takeRetainedValue())!)")
-            return reject(nil,nil,RuntimeError("SecKeyIsAlgorithm not supported"))
-            
+        var error: Unmanaged<CFError>?
+        guard let clearData = SecKeyCreateDecryptedData(loadedPrivateKey, secKeyAlgorithm, encryptedData as CFData, &error) as Data? else {
+            print("Decryption error: \(error?.takeRetainedValue().localizedDescription ?? "Unknown error")")
+            return reject(nil, nil, RuntimeError("Decryption error: \(error?.takeRetainedValue().localizedDescription ?? "Unknown error")"))
         }
 
         return resolve(String(data: clearData, encoding: .utf8))

src/index.tsx

@@ -43,6 +43,10 @@ class CryptoRsaClass {
   async getSHA512Text(pemString: string): Promise<string> {
     return await this.instance.getSHA512Text(pemString);
   }
+
+  async base64Decode(base64String: string): Promise<string> {
+    return await this.instance.base64Decode(base64String);
+  }
 }
 
 const RNCryptoRsa = new CryptoRsaClass();