PKCS#5 padding in Swift

Question

How to apply PKCS5 to an NSData ?

There doesn't seem to be much info about this yet, I've found this Objective-C solution that would work but I'm looking for a "swiftier" approach if possible.

Here is my failed attempt :

func pkcs5(data: NSData, blocksize: Int = 16) -> NSMutableData {
    var data = NSMutableData(data: data)
    let count = blocksize - data.length % blocksize

    for _ in 0...count {
        // somehow append the equivalent of chr(count) to data
    }

    return data
}

If you know Python, here's the function I'm trying to copy :

def pkcs5_pad(data, blocksize=16):
    pad_count = blocksize - len(data) % blocksize
    return data + (chr(pad_count) * pad_count).encode('utf-8')

Thanks.

Answer 1

You can use appendBytes():

func pkcs5(data: NSData, blocksize: Int = 16) -> NSMutableData {
    var data = NSMutableData(data: data)
    var count = UInt8(blocksize - data.length % blocksize)

    for _ in 0 ..< count {
        data.appendBytes(&count, length: 1)
    }

    return data
}

The "trick" is to declare count as a variable of type UInt8, so that you can pass a pointer with &count.

Alternatively, you can create an array with the padding bytes first and then append the data in one step:

func pkcs5(data: NSData, blocksize: Int = 16) -> NSData {
    var data = NSMutableData(data: data)
    let count = blocksize - data.length % blocksize
    let padding = [UInt8](count: count, repeatedValue: UInt8(count))
    data.appendBytes(padding, length: count)
    return data
}

Answer 2

I think @MartinR answer is no problem, but if you want more example:

Using libc: performance

func pkcs5_mem(data: NSData, blocksize: Int = 16) -> NSData {
    let count = blocksize - data.length % blocksize
    let buf = UnsafeMutablePointer<UInt8>(malloc(UInt(data.length + count)))
    // you should check `buf` is not `nil` here
    memcpy(buf, data.bytes, UInt(data.length))
    memset(buf + data.length, Int32(count), UInt(count))
    return NSData(bytesNoCopy: buf, length: data.length + count)
}

Using NSMutableData: safe any easy

func pkcs5_mutable(data: NSData, blocksize: Int = 16) -> NSData {
    let count = blocksize - data.length % blocksize
    let result = NSMutableData(capacity: data.length + count)!
    result.appendBytes(data.bytes, length: data.length)
    result.appendBytes([UInt8](count: count, repeatedValue: UInt8(count)), length: count)
    return result
}

Using Array as buffer: maybe slow

func pkcs5_array(data: NSData, blocksize: Int = 16) -> NSData {
    let count = blocksize - data.length % blocksize
    var buf = [UInt8]()
    buf.reserveCapacity(data.length + count)
    buf += UnsafeBufferPointer<UInt8>(start: UnsafePointer<UInt8>(data.bytes), count: data.length)
    buf += [UInt8](count: count, repeatedValue: UInt8(count))
    return NSData(bytes: buf, length: buf.count)
}