Swift base64 decoding returns nil

Question

I am trying to decode a base64 string to an image in Swift using the following code:

let decodedData=NSData(base64EncodedString: encodedImageData, options: NSDataBase64DecodingOptions.IgnoreUnknownCharacters)

Unfortunately, the variable decodedData turns out to have a value of nil

Debugging through the code, I verified that the variable encodedImageData is not nil and is the correct encoded image data(verified by using an online base64 to image converter). What could possibly be the reason behind my issue?

Did you try with basic options? `let decodedData=NSData(base64EncodedString: encodedImageData, options: NSDataBase64EncodingOptions())` — Eric Aya, Apr 01 '16 at 23:59

jlasierra · Answer 1 · 2018-04-22T19:34:19.173

57

This method requires padding with “=“, the length of the string must be multiple of 4.

In some implementations of base64 the padding character is not needed for decoding, since the number of missing bytes can be calculated. But in Fundation's implementation it is mandatory.

Updated: As noted on the comments, it's a good idea to check first if the string lenght is already a multiple of 4. if encoded64 has your base64 string and it's not a constant, you can do something like this:

Swift 2

let remainder = encoded64.characters.count % 4
if remainder > 0 {
    encoded64 = encoded64.stringByPaddingToLength(encoded64.characters.count + 4 - remainder,
                                                  withPad: "=",
                                                  startingAt: 0)
}

Swift 3

let remainder = encoded64.characters.count % 4
if remainder > 0 {
    encoded64 = encoded64.padding(toLength: encoded64.characters.count + 4 - remainder,
                                  withPad: "=",
                                  startingAt: 0)
}

Swift 4

let remainder = encoded64.count % 4
if remainder > 0 {
    encoded64 = encoded64.padding(toLength: encoded64.count + 4 - remainder,
                                  withPad: "=",
                                  startingAt: 0)
}

Updated one line version:

Or you can use this one line version that returns the same string when its length is already a multiple of 4:

encoded64.padding(toLength: ((encoded64.count+3)/4)*4,
                  withPad: "=",
                  startingAt: 0)

edited Apr 22 '18 at 19:34

answered Apr 01 '16 at 21:52

jlasierra

1,096
7
12

for strings already have a length of multiple of 4, your code adds four unnecessary '='! – Mbt925 Apr 18 '17 at 21:27
@Mbt925 Here I am explaining to the OP why base64 decoding might be failing. Of course, it's not a bad idea to check first if your string lenght is already a multiple of 4. I take this opportunity to update to swift 3. – jlasierra Apr 19 '17 at 20:11
I ended up using: `encoded64 = encoded64.padding(toLength: encoded64.characters.count + (4 - remainder) % 4, withPad: "=", startingAt: 0)` without `if`. – Mbt925 Apr 23 '17 at 06:04
@Mbt925 I have updated the answer with another one line version that takes into account that the lenght can be already a multiple of 4. – jlasierra Apr 24 '17 at 12:54
padding with "=" seems to be broken at the moment. I suggest padding with "A", which actually works. Filed a bug already. – Daniel K Apr 17 '18 at 23:01
@DanielKanaan It works for me, with xcode 9.3 & swift 4.1. What is the bug with "="? – jlasierra Apr 22 '18 at 19:23
@DanielKanaan, be aware that 'A' is actual data, so if you use it for padding your output will have one or two extra bytes with 0. – jlasierra Apr 22 '18 at 19:25
@jlasierra `data1 = Data(base64Encoded: "C===") data2 = Data(base64Encoded: "A===") XCTAssert(data1 != data2)` – Daniel K Apr 24 '18 at 18:19
@DanielKanaan This is another problem, there are some undefined bits here. Base64 for one byte with 0 is "AA==" – jlasierra Apr 25 '18 at 17:03
@jlasierra what about `data1 = Data(base64Encoded: "AA==") data2 = Data(base64Encoded: "AC==") XCTAssert(data1 != data2)` – Daniel K Apr 25 '18 at 18:33
@DanielKanaan Both "AA==" and "AC==" decode to byte 0. Two characters decodes to 1 byte, with some unused bits. But extra bits should be 0. So the correct base64 for one byte with 0 is "AA==". See https://tools.ietf.org/html/rfc4648#page-5 – jlasierra Apr 26 '18 at 07:25
@jlasierra I am just figuring out that there are basically "illegal" combinations, such as AC==. There is no bug in the base64encoded string... – Daniel K Apr 26 '18 at 15:58
Can you please help, my code always goes in the else condition. the if condition is never true. What should I do.... The length of my String is 1132. – Pawan Apr 15 '19 at 05:01
@Pawan, This snippet is used to pad the base64 string when needed. Length of your string is already multiple of 4. It does not need padding. You still have to decode it with `Data(base64Encoded:options:)`. – jlasierra Apr 15 '19 at 16:58

score 5 · Answer 2 · edited Jul 29 '16 at 19:09

When the number of characters is divisible by 4, you need to avoid padding.

private func base64PaddingWithEqual(encoded64: String) -> String {
  let remainder = encoded64.characters.count % 4
  if remainder == 0 {
    return encoded64
  } else {
    // padding with equal
    let newLength = encoded64.characters.count + (4 - remainder)
    return encoded64.stringByPaddingToLength(newLength, withString: "=", startingAtIndex: 0)
  }
}

score 4 · Answer 3 · answered Sep 18 '17 at 09:11

(Swift 3) I been in this situation, Trying to get the data using base64 encoded string returns nil with me when I used this line

let imageData = Data(base64Encoded: strBase64, options: .ignoreUnknownCharacters)

Tried padding the string and didn't work out too

This is what worked with me

func imageForBase64String(_ strBase64: String) -> UIImage? {

    do{
        let imageData = try Data(contentsOf: URL(string: strBase64)!)
        let image = UIImage(data: imageData)
        return image!
    }
    catch{
        return nil
    }
}

score 1 · Answer 4 · answered Nov 01 '19 at 19:23

Check the content of your decodedData variable and look for this prefix "data:image/png;base64", I had this issue and noticed that my String base64 had a prefix like this, so I used this approached and it worked

extension String {
func getImageFromBase64() -> UIImage? {
    guard let url = URL(string: self) else {
        return nil
    }
    do {
        let data = try Data(contentsOf: url)
        return UIImage(data: data)
    } catch {
        return nil
    }

}

}

score 1 · Answer 5 · answered Apr 14 '20 at 15:11

This helped me:

extension String {
    func fromBase64() -> String? {
        guard let data = Data(base64Encoded: self.replacingOccurrences(of: "_", with: "="), options: Data.Base64DecodingOptions(rawValue: 0)) else {
            return nil
        }

        return String(data: data, encoding: .utf8)
    }
}

Usage:

print(base64EncodedString.fromBase64())

score 0 · Answer 6 · answered May 29 '17 at 12:35

0

Another one-line version:

let length = encoded64.characters.count
encoded64 = encoded64.padding(toLength: length + (4 - length % 4) % 4, withPad: "=", startingAt: 0)

answered May 29 '17 at 12:35

Mbt925

1,317
1
16
31

score 0 · Answer 7 · answered Feb 11 '20 at 16:31

It's make problem with special character, but an interesting point is if we use NSData and NSString then it's working fine.

static func decodeBase64(input: String)->String{
        let base64Decoded = NSData(base64Encoded: input, options:   NSData.Base64DecodingOptions(rawValue: 0))
            .map({ NSString(data: $0 as Data, encoding: String.Encoding.utf8.rawValue) })

        return base64Decoded!! as String
}

score 0 · Answer 8 · answered Aug 17 '22 at 13:17

You can use this extension to make sure that the string has the correct length fro decoding with Foundation (divisible by 4):

extension String {
    var paddedForBase64Decoding: String {
        appending(String(repeating: "=", count: (4 - count % 4) % 4))
    }
}

Usage:

Data(base64Encoded: base64String.paddedForBase64Decoding)

Swift base64 decoding returns nil

8 Answers8

Linked