Tag: Convert

I'm trying to implement encryption with the help of libsodium and I have a quick code that accomplishes it. I need to convert the fast code to java (for Android). The algorithm and encryption mode used are AES / GCM / NoPadding. I have trouble understanding the Swift code.

The code is as follows:

Foundation of importation
import libsodium
import CryptoSwift
import SwiftyJSON

PullPaymentHelper class {

// MARK: - Constants

leave KEY_LENGTH: UInt64 = 32
let IV_LENGTH: Int = 16
let AUTHENTICATION_TAG_LENGTH: Int = 16
leave OPS_LIMITS: UInt64 = 10
let MEM_LIMITS: Int = 4000000
leave STATUS_SUCCESS: Int = 0

let VALUE_AAD: String = "SomeData"

let KEY_CIPHERB = "cipherb"
let KEY_ATAG = "atag"
let KEY_IV = "iv"
let KEY_SALT = "salt"

// MARK: - Methods of assistance

/// Derive the key from the private key and salt chain provided.
///
/// - Settings:
/// - privateKey: string value of the password
/// - saltStringBase64: base64 string of the salt value
/// - Returns: Byte array for the derived key
private func deriveKey (privateKey: String, saltBytes: [UInt8]) -> [UInt8]? {
let salt = Data (bytes: saltBytes)
leave passwordPointer = strdup (privateKey)

let modifiedKeyPointer = UnsafeMutablePointer.allocate (Ability: Int (KEY_LENGTH))

let status = crypto_pwhash_argon2i (
dérivéKeyPointer,
KEY_LENGTH,
passwordPointer,
UInt64 (privateKey.count),
salt.toPointer (),
OPS_LIMITS,
MEM_LIMITS,
crypto_pwhash_argon2i_alg_argon2i13 ()
)

returns status == STATUS_SUCCESS
? Array (UnsafeMutableBufferPointer (start: derivativeKeyPointer, account: Int (KEY_LENGTH)))
: no
}

/// Generate a new key for the key provided.
///
/// - privateKey parameter: string value of the private key
/// - Returns: Touple having the salt and the generated key
private function generateNewKey (privateKey: String) -> (salt: [UInt8], key: [UInt8])? {
guard let salt = Data (randomOfLength: Int (KEY_LENGTH)),
let key = deriveKey (privateKey: privateKey, saltBytes: salt.bytes) else {
print ("Can not generate salt")
returns zero
}

return (salt: salt.bytes, key: key)
}

func encryptDataWithPrivateKey (privateKey: String, data: [String: Any]) -> String? {
let dataStringToBeEcrypted = JSON (data)

guard let iv = Data (randomOfLength: IV_LENGTH) ?. bytes
let encInfo = generateNewKey (privateKey: privateKey),
leave plainTxt = try? dataStringToBeEcrypted.rawData (). bytes
else {return nil}

let sel = encInfo.salt
let key = encInfo.key

Let gcm = GCM (
iv: iv,
additionalAuthenticatedData: VALUE_AAD.bytes,
tagLength: AUTHENTICATION_TAG_LENGTH,
mode: .detached
)

keep aes = try? AES (key: key, blockMode: gcm, fill: .pkcs7),
leave encryptedMessage = try? aes.encrypt (plainTxt),
let atag = gcm.authenticationTag else {return nil}

// All values ​​are encoded in base64 strings
leave encyptedData = [
            KEY_CIPHERB: encryptedMessage.toBase64(),
            KEY_SALT: salt.toBase64(),
            KEY_IV: iv.toBase64(),
            KEY_ATAG: atag.toBase64()
        ]

        back to try? JSON (encyptedData) .rawData (). Base64EncodedString ()
}
}