AES encrypted secret key in JAVA decrypt in Swift

• privateKeyData (634 bytes)

• encryptedSecretKeyData (128 bytes)

• encryptedTextData (16 bytes)

I somehow managed to strip header from the privateKey and get privateKey

Please show how have you got the privateKey. Is it really the right data to use with Apple's frameworks?

Code Block 
let privatekeyData : Data = Data(base64Encoded: privateKeyString)!
 let SecretKeyData : Data =  Data(base64Encoded: EncrytedsecretKey)!
let textData : Data = Data(base64Encoded: encryptedText)! 

Code Block 
let privateKeyStripped  =  try! stripHeaderIfAny(keyData: privatekeyData)
        let attributes: [String: Any] = [
                         kSecAttrKeyType as String: kSecAttrKeyTypeRSA,
                         kSecAttrKeyClass as String: kSecAttrKeyClassPrivate
                     ]
   var error: Unmanaged<CFError>?
 let privateSecKey : SecKey = SecKeyCreateWithData(privateKeyStripped as CFData, attributes as CFDictionary, &error)
private func stripHeaderIfAny(keyData: Data) throws -> NSData {
let bytes = keyData.arrayOfBytes()
 var offset = 0
 guard bytes[offset] == 0x30 else {
        throw SwKeyConvert.SwError.invalidKey
    }
    offset += 1
    if bytes[offset] > 0x80 {
        offset += Int(bytes[offset]) - 0x80
    }
    offset += 1
    guard bytes[offset] == 0x02 else {
        throw SwKeyConvert.SwError.invalidKey
    }
    offset += 3
    /*without PKCS8 header*/
    if bytes[offset] == 0x02 {
        return keyData as NSData
    }
    let OID: [UInt8] = [0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86,
   	0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00]
    let slice: [UInt8] = Array(bytes[offset..<(offset + OID.count)])
    guard slice == OID else {
        throw SwKeyConvert.SwError.invalidKey
    }
    offset += OID.count
    guard bytes[offset] == 0x04 else {
    throw SwKeyConvert.SwError.invalidKey
    }
    offset += 1
    if bytes[offset] > 0x80 {
    offset += Int(bytes[offset]) - 0x80
    }
    offset += 1
    guard bytes[offset] == 0x30 else {
        throw SwKeyConvert.SwError.invalidKey
    }
        let newKeyData = keyData as NSData
        return newKeyData.subdata(with: NSRange(location: offset, length: keyData.count - offset)) as NSData
}

Step 2 cleared!

Code Block 
        var error:Unmanaged<CFError>?
        if let cfdata = SecKeyCopyExternalRepresentation(privateSecKey, &error) {
           let privateSecyKeyData:Data = cfdata as Data
           var secKey =  try! aesCBCDecrypt(data: SecretKeyData, keyData: privateSecyKeyData)
        }
 func aesCBCEncrypt(data:Data, keyData:Data) throws -> Data {
        let keyLength = keyData.count
        let validKeyLengths = [kCCKeySizeAES128, kCCKeySizeAES192, kCCKeySizeAES256]
        if (validKeyLengths.contains(keyLength) == false) {
            throw AESError.KeyError(("Invalid key length", keyLength))
        }
        let ivSize = kCCBlockSizeAES128;
        let cryptLength = size_t(ivSize + data.count + kCCBlockSizeAES128)
        var cryptData = Data(count:cryptLength)
        let status = cryptData.withUnsafeMutableBytes {ivBytes in
        SecRandomCopyBytes(kSecRandomDefault, kCCBlockSizeAES128, ivBytes)
        }
        if (status != 0) {
            throw AESError.IVError(("IV generation failed", Int(status)))
        }
        var numBytesEncrypted :size_t = 0
        let options   = CCOptions(kCCOptionPKCS7Padding)
        let cryptStatus = cryptData.withUnsafeMutableBytes {cryptBytes in
            data.withUnsafeBytes {dataBytes in
                keyData.withUnsafeBytes {keyBytes in
                    CCCrypt(CCOperation(kCCEncrypt),
                            CCAlgorithm(kCCAlgorithmAES),
                            options,
                            keyBytes, keyLength,
                            cryptBytes,
                            dataBytes, data.count,
                            cryptBytes+kCCBlockSizeAES128, cryptLength,
                            &numBytesEncrypted)
                }
            }
        }
        if UInt32(cryptStatus) == UInt32(kCCSuccess) {
            cryptData.count = numBytesEncrypted + ivSize
        }
        else {
            throw AESError.CryptorError(("Encryption failed", Int(cryptStatus)))
        }
        return cryptData;
    }

step 3: Decrypt the SecretKeyData using the private key privateSecKey.

Code Block 
let algorithm: SecKeyAlgorithm = .rsaEncryptionPKCS1
   guard SecKeyIsAlgorithmSupported(privateSecKey, .decrypt, algorithm) else {
   print("can not decrypt using this algorithm")
    return
   }
    var errorSec: Unmanaged<CFError>?
    let SecKeyDecryptedData = SecKeyCreateDecryptedData(privateSecKey,
                                                  algorithm,
                                                  SecretKeyData as CFData,
                                                  &errorSec) as Data?
        guard SecKeyDecryptedData != nil else {
          print("can not decrypt")
            return
        }
        let clearText = String(decoding: clearTextData!, as: UTF8.self)
}

Algorithm is correct

Code Block 
let algorithm: SecKeyAlgorithm = .rsaEncryptionOAEPSHA1

but now issue is I am getting resulted decrypted Data with 16 bytes only and when converted to string giving me Chinese characters

Keep all the Data as Data, do not try to convert them to String. Are you OK with this?

Code Block 
print(SecKeyDecryptedData as NSData) //<- or `as NSData?` here

Code Block 
print(SecKeyDecryptedData as NSData)

Is that result is OK?

Step 3 cleared.

• Both the input to decrypt, and the key to decrypt with, are of type Data.

Code Block 
import CommonCrypto
func aesOperation(_ operation: CCOperation, on data: Data, keyData: Data) -> Data? {
		
		let dataLength = data.count
		
		let keySize = keyData.count
		let bufferSize = dataLength + keySize
		
		var buffer = Data(count: bufferSize)
		var numBytesDecrypted: size_t = 0
		
		let cryptStatus = data.withUnsafeBytes {dataBP in
				keyData.withUnsafeBytes {keyBP in
						buffer.withUnsafeMutableBytes {bufferBP in
								CCCrypt(operation,
												CCAlgorithm(kCCAlgorithmAES),
												CCOptions(kCCOptionPKCS7Padding),
												keyBP.baseAddress!, keySize,
												nil,
												dataBP.baseAddress!, dataLength,
												bufferBP.baseAddress!, bufferSize,
												&numBytesDecrypted)
						}
				}
		}
		guard cryptStatus == kCCSuccess else {
				print("fail: \(cryptStatus)")
				return nil
		}
		print("Success")
		buffer.count = numBytesDecrypted
		return buffer
}

Code Block 
var textMessageData =  aesOperation(CCOperation(kCCDecrypt), on: textData, keyData: SecKeyDecryptedData!)
  /* Step 5 */
 let datastring = NSString(data: textMessageData!, encoding: String.Encoding.utf8.rawValue)

Code Block 
let datastring = String(data: textMessageData!, encoding: .utf8)