Cryptage AES pour une NSString sur l'iPhone

Quelqu'un peut-il me diriger dans la bonne direction pour pouvoir crypter une chaîne, en renvoyant une autre chaîne avec les données cryptées? (J'ai essayé avec le cryptage AES256.) Je veux écrire une méthode qui prend deux instances NSString, l'une étant le message à crypter et l'autre étant un `` mot de passe '' pour le crypter avec - je suppose que je devrais générer la clé de chiffrement avec le mot de passe, d'une manière qui peut être inversée si le mot de passe est fourni avec les données chiffrées. La méthode doit ensuite renvoyer une NSString créée à partir des données chiffrées.

J'ai essayé la technique détaillée dans le premier commentaire sur ce post , mais je n'ai pas eu de chance jusqu'à présent. CryptoExercise d'Apple a certainement quelque chose, mais je ne peux pas y comprendre ... J'ai vu beaucoup de références à CCCrypt , mais il a échoué dans tous les cas où je l'ai utilisé.

Je devrais également être capable de déchiffrer une chaîne cryptée, mais j'espère que c'est aussi simple que kCCEncrypt / kCCDecrypt.

Comme vous n'avez pas publié de code, il est difficile de savoir exactement quels problèmes vous rencontrez. Cependant, le billet de blog vers CCCrypt()lequel vous créez un lien semble fonctionner assez décemment ... mis à part la virgule supplémentaire dans chaque appel qui a causé des erreurs de compilation.

Un commentaire ultérieur sur cet article inclut ce code adapté , qui fonctionne pour moi et semble un peu plus simple. Si vous incluez leur code pour la catégorie NSData, vous pouvez écrire quelque chose comme ceci: (Remarque: les printf()appels ne servent qu'à démontrer l'état des données à différents points - dans une application réelle, il n'aurait pas de sens d'imprimer de telles valeurs .)

int main (int argc, const char * argv[]) {
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

    NSString *key = @"my password";
    NSString *secret = @"text to encrypt";

    NSData *plain = [secret dataUsingEncoding:NSUTF8StringEncoding];
    NSData *cipher = [plain AES256EncryptWithKey:key];
    printf("%s\n", [[cipher description] UTF8String]);

    plain = [cipher AES256DecryptWithKey:key];
    printf("%s\n", [[plain description] UTF8String]);
    printf("%s\n", [[[NSString alloc] initWithData:plain encoding:NSUTF8StringEncoding] UTF8String]);

    [pool drain];
    return 0;
}

Compte tenu de ce code, et du fait que les données chiffrées ne se traduiront pas toujours bien en NSString, il peut être plus pratique d'écrire deux méthodes qui enveloppent la fonctionnalité dont vous avez besoin, en avant et en arrière ...

- (NSData*) encryptString:(NSString*)plaintext withKey:(NSString*)key {
    return [[plaintext dataUsingEncoding:NSUTF8StringEncoding] AES256EncryptWithKey:key];
}

- (NSString*) decryptData:(NSData*)ciphertext withKey:(NSString*)key {
    return [[[NSString alloc] initWithData:[ciphertext AES256DecryptWithKey:key]
                                  encoding:NSUTF8StringEncoding] autorelease];
}

Cela fonctionne définitivement sur Snow Leopard, et @Boz rapporte que CommonCrypto fait partie du Core OS sur l'iPhone. Les versions 10.4 et 10.5 ont toutes les deux /usr/include/CommonCrypto, bien que 10.5 ait une page de manuel pour CCCryptor.3ccet 10.4 pas, donc YMMV.

EDIT: Voir cette question de suivi sur l'utilisation du codage Base64 pour représenter les octets de données chiffrées sous forme de chaîne (si vous le souhaitez) à l'aide de conversions sûres et sans perte.

J'ai rassemblé une collection de catégories pour NSData et NSString qui utilise des solutions trouvées sur le blog de Jeff LaMarche et quelques conseils de Quinn Taylor ici sur Stack Overflow.

Il utilise des catégories pour étendre NSData afin de fournir un cryptage AES256 et offre également une extension de NSString aux données cryptées encodées en BASE64 en toute sécurité vers des chaînes.

Voici un exemple pour montrer l'utilisation du chiffrement des chaînes:

NSString *plainString = @"This string will be encrypted";
NSString *key = @"YourEncryptionKey"; // should be provided by a user

NSLog( @"Original String: %@", plainString );

NSString *encryptedString = [plainString AES256EncryptWithKey:key];
NSLog( @"Encrypted String: %@", encryptedString );

NSLog( @"Decrypted String: %@", [encryptedString AES256DecryptWithKey:key] );

Obtenez le code source complet ici:

https://gist.github.com/838614

Merci pour tous les conseils utiles!

-- Michael

@owlstead, concernant votre demande de "variante cryptographiquement sécurisée de l'une des réponses données", veuillez consulter RNCryptor . Il a été conçu pour faire exactement ce que vous demandez (et a été construit en réponse aux problèmes avec le code répertorié ici).

RNCryptor utilise PBKDF2 avec sel, fournit un IV aléatoire et attache HMAC (également généré à partir de PBKDF2 avec son propre sel. Il prend en charge le fonctionnement synchrone et asynchrone.

J'ai attendu un peu sur @QuinnTaylor pour mettre à jour sa réponse, mais comme il ne l'a pas fait, voici la réponse un peu plus clairement et de manière à ce qu'elle se charge sur XCode7 (et peut-être plus). J'ai utilisé ceci dans une application Cocoa, mais cela fonctionnera probablement aussi bien avec une application iOS. N'a aucune erreur ARC.

Collez avant toute section @implementation dans votre fichier AppDelegate.m ou AppDelegate.mm.

#import <CommonCrypto/CommonCryptor.h>

@implementation NSData (AES256)

- (NSData *)AES256EncryptWithKey:(NSString *)key {
    // 'key' should be 32 bytes for AES256, will be null-padded otherwise
    char keyPtr[kCCKeySizeAES256+1]; // room for terminator (unused)
    bzero(keyPtr, sizeof(keyPtr)); // fill with zeroes (for padding)

    // fetch key data
    [key getCString:keyPtr maxLength:sizeof(keyPtr) encoding:NSUTF8StringEncoding];

    NSUInteger dataLength = [self length];

    //See the doc: For block ciphers, the output size will always be less than or 
    //equal to the input size plus the size of one block.
    //That's why we need to add the size of one block here
    size_t bufferSize = dataLength + kCCBlockSizeAES128;
    void *buffer = malloc(bufferSize);

    size_t numBytesEncrypted = 0;
    CCCryptorStatus cryptStatus = CCCrypt(kCCEncrypt, kCCAlgorithmAES128, kCCOptionPKCS7Padding,
                                     keyPtr, kCCKeySizeAES256,
                                     NULL /* initialization vector (optional) */,
                                     [self bytes], dataLength, /* input */
                                     buffer, bufferSize, /* output */
                                     &numBytesEncrypted);
    if (cryptStatus == kCCSuccess) {
        //the returned NSData takes ownership of the buffer and will free it on deallocation
        return [NSData dataWithBytesNoCopy:buffer length:numBytesEncrypted];
    }

    free(buffer); //free the buffer;
    return nil;
}

- (NSData *)AES256DecryptWithKey:(NSString *)key {
    // 'key' should be 32 bytes for AES256, will be null-padded otherwise
    char keyPtr[kCCKeySizeAES256+1]; // room for terminator (unused)
    bzero(keyPtr, sizeof(keyPtr)); // fill with zeroes (for padding)

    // fetch key data
    [key getCString:keyPtr maxLength:sizeof(keyPtr) encoding:NSUTF8StringEncoding];

    NSUInteger dataLength = [self length];

    //See the doc: For block ciphers, the output size will always be less than or 
    //equal to the input size plus the size of one block.
    //That's why we need to add the size of one block here
    size_t bufferSize = dataLength + kCCBlockSizeAES128;
    void *buffer = malloc(bufferSize);

    size_t numBytesDecrypted = 0;
    CCCryptorStatus cryptStatus = CCCrypt(kCCDecrypt, kCCAlgorithmAES128, kCCOptionPKCS7Padding,
                                     keyPtr, kCCKeySizeAES256,
                                     NULL /* initialization vector (optional) */,
                                     [self bytes], dataLength, /* input */
                                     buffer, bufferSize, /* output */
                                     &numBytesDecrypted);

    if (cryptStatus == kCCSuccess) {
        //the returned NSData takes ownership of the buffer and will free it on deallocation
        return [NSData dataWithBytesNoCopy:buffer length:numBytesDecrypted];
    }

    free(buffer); //free the buffer;
    return nil;
}

@end

Collez ces deux fonctions dans la classe @implementation de votre choix. Dans mon cas, j'ai choisi @implementation AppDelegate dans mon fichier AppDelegate.mm ou AppDelegate.m.

- (NSString *) encryptString:(NSString*)plaintext withKey:(NSString*)key {
    NSData *data = [[plaintext dataUsingEncoding:NSUTF8StringEncoding] AES256EncryptWithKey:key];
    return [data base64EncodedStringWithOptions:kNilOptions];
}

- (NSString *) decryptString:(NSString *)ciphertext withKey:(NSString*)key {
    NSData *data = [[NSData alloc] initWithBase64EncodedString:ciphertext options:kNilOptions];
    return [[NSString alloc] initWithData:[data AES256DecryptWithKey:key] encoding:NSUTF8StringEncoding];
}

Please use the below mentioned URL to encrypt string using AES excryption with 
key and IV values.

https://github.com/muneebahmad/AESiOSObjC