Printing out ! with printf inside swift code - swift

Question

I'm attempting to encrypt a string with openssl. The string that is to be encrypted is a randomly generated string consisting of letters, numbers, and symbols. The following command is run to attempt to encrypt the string:
printf "randomString" | openssl enc -base64 -e -aes-256-cbc -salt -pass pass: "passwordSalt"
This works fine as long as there weren't any characters generated in the string that printf doesn't like. I've seen other posts about handling a % by putting two percentage's together %%.
However, issues arise if there is a ! in the string. Other sources say to single quote the string instead of double quoting, as double quoting causes bash to interpolate the string. This wouldn't be an issue if I were just running this in the command line. The printf and openssl commands are being run in swift as a Process() and unfortunately there is no such thing as single quotes in swift. I've even tried to enclose the string in single quotes after it's generated but that causes the single quotes to be part of the string during encryption. Is there any way or any option provided with printf that allows the use of a ! in a string when double quotes aren't an option? echo also works in a similar fashion, where single quoting works but double quotes interpolates certain characters, but I will be fine with using echo or printf.

Answer 1

Stop mucking about with printf and just write the input string directly to the standard input of openssl. Then you don't need to worry about quoting weird characters.
import Foundation
func encrypt(_ plainText: String) async throws -> String? {
let pipeToChild = Pipe()
let fileHandleToChild = pipeToChild.fileHandleForWriting
let pipeFromChild = Pipe()
let fileHandleFromChild = pipeFromChild.fileHandleForReading
let child = Process()
child.executableURL = URL(fileURLWithPath: "/usr/bin/openssl")
child.arguments = [
"enc",
"-base64",
"-e",
"-aes-256-cbc",
"-salt",
"-pass", "pass:passwordSalt"
]
child.standardInput = pipeToChild
child.standardOutput = pipeFromChild
try child.run()
async let writeResult: () = Task {
try fileHandleToChild.write(contentsOf: plainText.data(using: .utf8)!)
try fileHandleToChild.close()
}.value
async let readResult = Task {
try fileHandleFromChild.readToEnd()
}.value
let _ = try await writeResult
let data = try await readResult
return data.flatMap { String(data: $0, encoding: .utf8) }
}
#main
struct MyMain {
static func main() async {
do {
let answer = try await encrypt(#"string with \/\/eird ${embedded} "c"harac't'ers"#)
print(answer ?? "(failed to encrypt)")
}
catch {
print("error: \(error)")
}
}
}
UPDATE
Here is a version that doesn't use async. It could in theory deadlock if openssl tries to write substantial output before reading all of its input. It probably won't be a problem if the plaintext is no more than 4k.
import Foundation
func encrypt(_ plainText: String) throws -> String? {
let pipeToChild = Pipe()
let fileHandleToChild = pipeToChild.fileHandleForWriting
let pipeFromChild = Pipe()
let fileHandleFromChild = pipeFromChild.fileHandleForReading
let child = Process()
child.executableURL = URL(fileURLWithPath: "/usr/bin/openssl")
child.arguments = [
"enc",
"-base64",
"-e",
"-aes-256-cbc",
"-salt",
"-pass", "pass:passwordSalt"
]
child.standardInput = pipeToChild
child.standardOutput = pipeFromChild
try child.run()
try fileHandleToChild.write(contentsOf: plainText.data(using: .utf8)!)
try fileHandleToChild.close()
let data = try fileHandleFromChild.readToEnd()
return data.flatMap { String(data: $0, encoding: .utf8) }
}
#main
struct MyMain {
static func main() {
do {
let answer = try encrypt(#"string with \/\/eird ${embedded} "c"harac't'ers"#)
print(answer ?? "(failed to encrypt)")
}
catch {
print("error: \(error)")
}
}
}

Answer 2

Do this
printf '%s' 'randomString' | openssl enc -base64 -e -aes-256-cbc -salt -pass pass: "passwordSalt"
to avoid interpreting special format chars by printf
edit
use single quotes
printf '%s' '!##$%%^&*()_+=-0987654321\][{}|;:/.?>,<'
!##$%%^&*()_+=-0987654321\][{}|;:/.?>,<

Answer 3

With assistance from #rob mayoff I was able to avoid the piping of printf/echo to openssl altogether. Although I do think it's still a topic that probably needs to be answered ultimately.
I was able to pipe a string to the openssl process in swift:
mutating func encryptString(_ plainText: String) throws -> String? {
let pipeToChild = Pipe()
let fileHandleToChild = pipeToChild.fileHandleForWriting
let pipeFromChild = Pipe()
let fileHandleFromChild = pipeFromChild.fileHandleForReading
let child = Process()
child.executableURL = URL(fileURLWithPath: "/usr/bin/openssl")
child.arguments = [
"enc",
"-base64",
"-e",
"-aes-256-cbc",
"-salt",
"-pass", "pass:\(self.passwordSalt)"
]
child.standardInput = pipeToChild
child.standardOutput = pipeFromChild
try child.run()
try fileHandleToChild.write(contentsOf: plainText.data(using: .utf8)!)
try fileHandleToChild.close()
var output = try fileHandleFromChild.readToEnd()
var outputString = String(decoding: output!, as: UTF8.self)
print("output: \(output!)")
child.waitUntilExit()
print("encrypted String: \(outputString)")
self.encryptedPassword = outputString
return "Success"
}