Comment décrypter la string dans c # a été cryptée dans iOS en utilisant Rijndael

J'essaye de chiffrer et de déchiffrer la string en utilisant l'objective c et C #. les deux fonctionnent bien dans le code natif, mais quand j'essayais de décrypter la string dans c # était crypté dans iOS. J'ai une erreur.

C'était le code que j'ai utilisé dans l'objective c

- (NSData *)AES256EncryptWithKey:(NSSsortingng *)key Data: (NSData *) data { char keyPtr[kCCKeySizeAES256+1]; // room for terminator (unused) bzero(keyPtr, sizeof(keyPtr)); // fill with zeroes (for padding) [key getCSsortingng:keyPtr maxLength:sizeof(keyPtr) encoding:NSUTF8SsortingngEncoding]; NSUInteger dataLength = [data length]; NSData *iv = [@"abcdefghijklmnopqrstuvwxyz123456" dataUsingEncoding:NSUTF8SsortingngEncoding]; size_t bufferSize = dataLength + kCCBlockSizeAES128; void *buffer = malloc(bufferSize); size_t numBytesEncrypted = 0; CCCryptorStatus cryptStatus = CCCrypt(kCCEncrypt, kCCAlgorithmAES128, kCCOptionPKCS7Padding, keyPtr, kCCKeySizeAES256, [iv bytes] /* initialization vector (optional) */, [data bytes], dataLength, /* input */ buffer, bufferSize, /* output */ &numBytesEncrypted); if (cryptStatus == kCCSuccess) { return [NSData dataWithBytesNoCopy:buffer length:numBytesEncrypted]; } free(buffer); //free the buffer; return nil; }

En voulant savoir comment décrypter en C #, je donne blocksize est 256, ivsize à 32 et utilisé "RijndaelManaged ()". Je n'utilise pas de sel et mot de passe. Erreur: quelque chose comme "Padding est invalide et ne peut pas être supprimé". J'ai essayé de régler le padding aussi comme PKCS7, none, zero mais rien n'aider à décrypter.

quelqu'un peut-il aider cela?

Edit: Mon code C # ici

 public ssortingng DecryptSsortingng(ssortingng encrypted) { ssortingng result = null; _encoder = new UTF8Encoding(); if (!ssortingng.IsNullOrWhiteSpace(encrypted) && (encrypted.Length >= 32)) { var messageBytes = Convert.FromBase64Ssortingng(encrypted); using (var rm = new RijndaelManaged()) { rm.BlockSize = _blockSize; rm.Key = _encoder.GetBytes("mykey_here"); rm.IV = _encoder.GetBytes("abcdefghijklmnopqrstuvwxyz123456"); ; rm.Padding = PaddingMode.Zeros; var decryptor = rm.CreateDecryptor(rm.Key, messageBytes.Take(_ivSize).ToArray()); result = _encoder.GetSsortingng(Transform(messageBytes.Skip(_ivSize).ToArray(), decryptor)); } } return result; } protected byte[] Transform(byte[] buffer, ICryptoTransform transform) { byte[] result; using (var stream = new MemoryStream()) using (var cs = new CryptoStream(stream, transform, CryptoStreamMode.Write)) { cs.Write(buffer, 0, buffer.Length); cs.FlushFinalBlock(); result = stream.ToArray(); } return result; }

iOS (Common Crypto) spécifie explicitement tous les parameters de encryption, le code C # détermine implicitement de nombreux parameters. Ces parameters implicites, tout en simplifiant l'utilisation, sont problématiques lorsqu'on tente de réaliser l'interopérabilité.

La class C # RijndaelManaged permet explicitement de spécifier le paramètre, changez votre code pour les utiliser, en particulier BlockSize ( 128 ), KeySize ( 128 ), Mode ( CipherMode.CBC ) et Padding ( PaddingMode.PKCS7 ). Les valeurs par défaut pour le mode et le Padding sont OK. Voir la documentation de RijndaelManaged

AES et Rijndael ne sont pas les mêmes, en particulier AES utilise seulement une taille de bloc de 128 bits (16 octets) et Rijndael permet plusieurs tailles de blocs. Il faut donc spécifier une taille de bloc de 128 bits pour Rijndael. Ainsi, l'iv est également 128 bits (16 octets). Les deux prennent en charge les keys de encryption de 128, 192 et 256 octets.

Il vaut probablement mieux utiliser la class AESManaged que la class RijndaelManaged . Voir la documentation AesManaged

Le côté C # s'attend à ce que datatables soient codées en Base64, le côté iOS ne montre pas cette opération d'enencoding, assurez-vous que cela se fait du côté iOS.

Puisque vous utilisez un iv assurez-vous que vous utilisez le mode CBC des deux côtés. En Common Crypto CBC est le mode par défaut, assurez-vous que le mode CBC est utilisé du côté C #.

Assurez-vous que le côté C # utilise le remplissage PKCS # 7 ou PKCS # 5, ils sont équivalents. Il semble que PKCS # 7 soit la valeur par défaut du côté C #, cela devrait donc être OK.

Il est préférable d'utiliser une key de la taille spécifiée et de ne pas utiliser le remplissage par défaut. Dans Common Crypto, la taille de la key est explicitement spécifiée et le remplissage est nul si la key fournie est trop courte. Le C # a l'air de déterminer la taille de la key à l'aide de la key fournie, dans ce cas la key est de 10 octets, donc la key de déencryption a probablement 128 bits par défaut et la key est complétée par des zéros. Sur iOS, vous spécifiez explicitement une taille de key de 256 bits. C'est un mauvais match qui doit être corrigé. Fournissez une key dont la taille exacte est indiquée sur le côté iOS.

Enfin, il y a le iv, le code C # s'attend à ce que l'iv soit ajouté aux données cryptées mais le code iOS ne le fournit pas. La solution consiste à modifier le code iOS pour append l'iv au code chiffré. Changer le iv à 16 octets, la taille du bloc AES.

Enfin, fournissez des vidages hexadécimaux des données de test, des données sortantes, iv et de la key juste avant et après l'appel de chiffrement si vous avez besoin de plus d'aide.