Comment dois-je faire de l'encodage base64 sur iOS?

C'est un bon cas d'utilisation pour Objectif C catégories.

Pour l'encodage Base64:

#import <Foundation/NSString.h>
@interface NSString (NSStringAdditions)
+ (NSString *) base64StringFromData:(NSData *)data length:(int)length;
@end
-------------------------------------------
#import "NSStringAdditions.h"
static char base64EncodingTable[64] = {
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
};
@implementation NSString (NSStringAdditions)
+ (NSString *) base64StringFromData: (NSData *)data length: (int)length {
unsigned long ixtext, lentext;
long ctremaining;
unsigned char input[3], output[4];
short i, charsonline = 0, ctcopy;
const unsigned char *raw;
NSMutableString *result;
lentext = [data length]; 
if (lentext < 1)
return @"";
result = [NSMutableString stringWithCapacity: lentext];
raw = [data bytes];
ixtext = 0; 
while (true) {
ctremaining = lentext - ixtext;
if (ctremaining <= 0) 
break;        
for (i = 0; i < 3; i++) { 
unsigned long ix = ixtext + i;
if (ix < lentext)
input[i] = raw[ix];
else
input[i] = 0;
}
output[0] = (input[0] & 0xFC) >> 2;
output[1] = ((input[0] & 0x03) << 4) | ((input[1] & 0xF0) >> 4);
output[2] = ((input[1] & 0x0F) << 2) | ((input[2] & 0xC0) >> 6);
output[3] = input[2] & 0x3F;
ctcopy = 4;
switch (ctremaining) {
case 1: 
ctcopy = 2; 
break;
case 2: 
ctcopy = 3; 
break;
}
for (i = 0; i < ctcopy; i++)
[result appendString: [NSString stringWithFormat: @"%c", base64EncodingTable[output[i]]]];
for (i = ctcopy; i < 4; i++)
[result appendString: @"="];
ixtext += 3;
charsonline += 4;
if ((length > 0) && (charsonline >= length))
charsonline = 0;
}     
return result;
}
@end

Pour un décodage Base64:

#import <Foundation/Foundation.h>
@class NSString;
@interface NSData (NSDataAdditions)
+ (NSData *) base64DataFromString:(NSString *)string;
@end
-------------------------------------------
#import "NSDataAdditions.h"
@implementation NSData (NSDataAdditions)
+ (NSData *)base64DataFromString: (NSString *)string
{
unsigned long ixtext, lentext;
unsigned char ch, inbuf[4], outbuf[3];
short i, ixinbuf;
Boolean flignore, flendtext = false;
const unsigned char *tempcstring;
NSMutableData *theData;
if (string == nil)
{
return [NSData data];
}
ixtext = 0;
tempcstring = (const unsigned char *)[string UTF8String];
lentext = [string length];
theData = [NSMutableData dataWithCapacity: lentext];
ixinbuf = 0;
while (true)
{
if (ixtext >= lentext)
{
break;
}
ch = tempcstring [ixtext++];
flignore = false;
if ((ch >= 'A') && (ch <= 'Z'))
{
ch = ch - 'A';
}
else if ((ch >= 'a') && (ch <= 'z'))
{
ch = ch - 'a' + 26;
}
else if ((ch >= '0') && (ch <= '9'))
{
ch = ch - '0' + 52;
}
else if (ch == '+')
{
ch = 62;
}
else if (ch == '=')
{
flendtext = true;
}
else if (ch == '/')
{
ch = 63;
}
else
{
flignore = true; 
}
if (!flignore)
{
short ctcharsinbuf = 3;
Boolean flbreak = false;
if (flendtext)
{
if (ixinbuf == 0)
{
break;
}
if ((ixinbuf == 1) || (ixinbuf == 2))
{
ctcharsinbuf = 1;
}
else
{
ctcharsinbuf = 2;
}
ixinbuf = 3;
flbreak = true;
}
inbuf [ixinbuf++] = ch;
if (ixinbuf == 4)
{
ixinbuf = 0;
outbuf[0] = (inbuf[0] << 2) | ((inbuf[1] & 0x30) >> 4);
outbuf[1] = ((inbuf[1] & 0x0F) << 4) | ((inbuf[2] & 0x3C) >> 2);
outbuf[2] = ((inbuf[2] & 0x03) << 6) | (inbuf[3] & 0x3F);
for (i = 0; i < ctcharsinbuf; i++)
{
[theData appendBytes: &outbuf[i] length: 1];
}
}
if (flbreak)
{
break;
}
}
}
return theData;
}
@end

Historiquement, nous aurait dirigé vous vers l'un des nombreux tiers de la base de 64 bibliothèques (comme indiqué dans les autres réponses) pour la conversion de données binaires à base 64 de la chaîne (et de retour), mais iOS 7 a maintenant natif de codage en base 64 (et expose précédemment privé iOS 4 méthodes, dans le cas où vous avez besoin de support des versions antérieures d'iOS).

Ainsi, pour convertir NSData à NSString base 64 représentation vous pouvez utiliser base64EncodedStringWithOptions. Si vous avez pour soutenir iOS versions antérieures à la version 7.0, vous pouvez le faire:

NSString *string;
if ([data respondsToSelector:@selector(base64EncodedStringWithOptions:)]) {
string = [data base64EncodedStringWithOptions:kNilOptions];  //iOS 7+
} else {
string = [data base64Encoding];                              //pre iOS7
}

Et à convertir en base 64 NSString retour à NSData vous pouvez utiliser initWithBase64EncodedString. De même, si vous avez besoin de soutien iOS versions antérieures à la version 7.0, vous pouvez le faire:

NSData *data;
if ([NSData instancesRespondToSelector:@selector(initWithBase64EncodedString:options:)]) {
data = [[NSData alloc] initWithBase64EncodedString:string options:kNilOptions];  //iOS 7+
} else {
data = [[NSData alloc] initWithBase64Encoding:string];                           //pre iOS7
}

---

Évidemment, si vous n'avez pas besoin de compatibilité descendante avec les versions d'iOS antérieures à la version 7.0, il est encore plus facile, il suffit d'utiliser base64EncodedStringWithOptions ou initWithBase64EncodedString, respectivement, et ne vous embêtez pas avec le moment de l'exécution de vérifier pour d'anciennes versions iOS. En fait, si vous utilisez le code ci-dessus lorsque votre objectif minimum est de iOS 7 ou plus, vous recevrez un avertissement du compilateur sur les méthodes obsolètes. Donc, dans iOS 7 et plus, il vous suffit de convertir en base 64 chaîne avec:

NSString *string = [data base64EncodedStringWithOptions:kNilOptions];

et de retour à nouveau avec:

NSData *data = [[NSData alloc] initWithBase64EncodedString:string options:kNilOptions]; 

Depuis ce qui semble être le numéro un de google a frappé sur le codage base64 et iphone, j'ai eu envie de partager mon expérience avec l'extrait de code ci-dessus.

Cela fonctionne, mais il est extrêmement lent. Une référence sur une image aléatoire (0.4 mb) a pris de 37 secondes sur native de l'iphone. La raison principale est probablement tous de la programmation orientée objet magique - char NSStrings etc, qui ne sont autoreleased après le codage est fait.

Une autre suggestion posté ici (ab)utilise la bibliothèque openssl, qui se sent comme overkill ainsi.

Le code ci-dessous prend 70 ms - qui est 500 fois plus rapide. Cette seulement le codage base64 (décodage suivront dès que je rencontre c')

+ (NSString *) base64StringFromData: (NSData *)data length: (int)length {
int lentext = [data length]; 
if (lentext < 1) return @"";
char *outbuf = malloc(lentext*4/3+4); //add 4 to be sure
if ( !outbuf ) return nil;
const unsigned char *raw = [data bytes];
int inp = 0;
int outp = 0;
int do_now = lentext - (lentext%3);
for ( outp = 0, inp = 0; inp < do_now; inp += 3 )
{
outbuf[outp++] = base64EncodingTable[(raw[inp] & 0xFC) >> 2];
outbuf[outp++] = base64EncodingTable[((raw[inp] & 0x03) << 4) | ((raw[inp+1] & 0xF0) >> 4)];
outbuf[outp++] = base64EncodingTable[((raw[inp+1] & 0x0F) << 2) | ((raw[inp+2] & 0xC0) >> 6)];
outbuf[outp++] = base64EncodingTable[raw[inp+2] & 0x3F];
}
if ( do_now < lentext )
{
char tmpbuf[2] = {0,0};
int left = lentext%3;
for ( int i=0; i < left; i++ )
{
tmpbuf[i] = raw[do_now+i];
}
raw = tmpbuf;
outbuf[outp++] = base64EncodingTable[(raw[inp] & 0xFC) >> 2];
outbuf[outp++] = base64EncodingTable[((raw[inp] & 0x03) << 4) | ((raw[inp+1] & 0xF0) >> 4)];
if ( left == 2 ) outbuf[outp++] = base64EncodingTable[((raw[inp+1] & 0x0F) << 2) | ((raw[inp+2] & 0xC0) >> 6)];
}
NSString *ret = [[[NSString alloc] initWithBytes:outbuf length:outp encoding:NSASCIIStringEncoding] autorelease];
free(outbuf);
return ret;
}

J'ai quitté la ligne de coupe, puisque je n'ai pas besoin de cela, mais il est facile d'ajouter.

Pour ceux qui sont intéressés par l'optimisation: l'objectif est de minimiser ce qui se passe dans la boucle principale. Donc en toute logique de traiter avec les 3 derniers octets est traitée en dehors de la boucle.

Aussi, essayez de travailler sur des données en place, sans autre copie vers/depuis les tampons. Et de réduire l'arithmétique au strict minimum.

Observer que les bits qui sont mis ensemble pour rechercher une entrée dans la table, se chevauchent pas quand ils devaient être orred ensemble sans se déplacer. Une amélioration majeure pourrait donc être d'utiliser 4 256 octets de tables de recherche et d'éliminer les décalages, comme ceci:

outbuf[outp++] = base64EncodingTable1[(raw[inp] & 0xFC)];
outbuf[outp++] = base64EncodingTable2[(raw[inp] & 0x03) | (raw[inp+1] & 0xF0)];
outbuf[outp++] = base64EncodingTable3[(raw[inp+1] & 0x0F) | (raw[inp+2] & 0xC0)];
outbuf[outp++] = base64EncodingTable4[raw[inp+2] & 0x3F];

Bien sûr, vous pourriez prendre un ensemble beaucoup plus loin, mais c'est au-delà de la portée ici.

Meilleure solution :

Il y a une fonction intégrée dans NSData

[data base64Encoding]; //iOS < 7.0
[data base64EncodedStringWithOptions:NSDataBase64Encoding76CharacterLineLength]; //iOS >= 7.0

Sous iOS8 et de les utiliser plus tard - (NSString *)base64EncodedStringWithOptions:(NSDataBase64EncodingOptions)options de NSData

Pour une mise à jour pour utiliser le NSData (NSDataBase64Encoding) catégorie de méthodes dans iOS7 voir ma réponse ici: https://stackoverflow.com/a/18927627/1602729

iOS a construit-dans le codage Base64 et méthodes de décodage (sans l'aide de libresolv) depuis iOS 4. Cependant, il n'est déclarée dans l'iOS 7 SDK. La documentation d'Apple indique que vous pouvez utiliser lorsque vous ciblez iOS 4 et au-dessus.

NSData *myData = ... some data
NSString *base64String = [myData base64Encoding];
NSData *decodedData = [[NSData alloc] initWithBase64Encoding:base64String];

dans iOS 7

        NSData *data=[[NSData alloc]init];
[data base64Encoding];

Je Pense que Ce sera utile

 + (NSString *)toBase64String:(NSString *)string {
NSData *data = [string dataUsingEncoding: NSUnicodeStringEncoding];
NSString *ret = [data base64EncodedStringWithOptions:NSDataBase64Encoding64CharacterLineLength];
return ret;
}
+ (NSString *)fromBase64String:(NSString *)string {
NSData *aData = [string dataUsingEncoding:NSUTF8StringEncoding];
NSData *aDataDecoded = [[NSData alloc]initWithBase64EncodedString:string options:0];
NSString *decryptedStr = [[NSString alloc]initWithData:aDataDecoded encoding:NSUTF8StringEncoding];
return [decryptedStr autorelease];

}

Selon vos besoins, j'ai créé un exemple de démonstration utilisant Swift 4 dans lequel vous pouvez encoder/décoder la chaîne et de l'image selon vos besoins.

• J'ai également ajouté les exemples de méthodes d'opérations pertinentes.

  //
  // Base64VC.swift
  // SOF_SortArrayOfCustomObject
  //
  // Created by Test User on 09/01/18.
  // Copyright © 2018 Test User. All rights reserved.
  //
  import UIKit
  import Foundation
  class Base64VC: NSObject {
  //----------------------------------------------------------------
  //MARK:-
  //MARK:- String to Base64 Encode Methods
  //----------------------------------------------------------------
  func sampleStringEncodingAndDecoding() {
  if let base64String = self.base64Encode(string: "TestString") {
  print("Base64 Encoded String: \n\(base64String)")
  if let originalString = self.base64Decode(base64String: base64String) {
  print("Base64 Decoded String: \n\(originalString)")
  }
  }
  }
  //----------------------------------------------------------------
  func base64Encode(string: String) -> String? {
  if let stringData = string.data(using: .utf8) {
  return stringData.base64EncodedString()
  }
  return nil
  }
  //----------------------------------------------------------------
  func base64Decode(base64String: String) -> String? {
  if let base64Data = Data(base64Encoded: base64String) {
  return String(data: base64Data, encoding: .utf8)
  }
  return nil
  }
  //----------------------------------------------------------------
  //MARK:-
  //MARK:- Image to Base64 Encode  Methods
  //----------------------------------------------------------------
  func sampleImageEncodingAndDecoding() {
  if let base64ImageString = self.base64Encode(image: UIImage.init(named: "yourImageName")!) {
  print("Base64 Encoded Image: \n\(base64ImageString)")
  if let originaImage = self.base64Decode(base64ImageString: base64ImageString) {
  print("originalImageData \n\(originaImage)")
  }
  }
  }
  //----------------------------------------------------------------
  func base64Encode(image: UIImage) -> String? {
  if let imageData = UIImagePNGRepresentation(image) {
  return imageData.base64EncodedString()
  }
  return nil
  }
  //----------------------------------------------------------------
  func base64Decode(base64ImageString: String) -> UIImage? {
  if let base64Data = Data(base64Encoded: base64ImageString) {
  return UIImage(data: base64Data)!
  }
  return nil
  }
  }