AES-256-CBC Verschlüsselung Java/Objective-C

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • AES-256-CBC Verschlüsselung Java/Objective-C

    Hallo zusammen,
    ich muß Dateien/Text verschlüsseln bzw. entschlüsseln die mit folgenden Java Code generiert bzw. wieder entschlüsselt werden (MacOSX <=> java Applikation): Hier der Java-Code:

    Quellcode

    1. try {
    2. String text = "Test";
    3. String pw = "1234567812345678";
    4. String iv = "1234567812345678";
    5. byte[] data = text.getBytes("UTF-8");
    6. Cipher cipher = Cipher.getInstance( "AES/CBC/PKCS5Padding" );
    7. Key key = new SecretKeySpec( pw.getBytes("UTF-8"),0,16, "AES" ); // key muss 16 Byte lang sein !
    8. IvParameterSpec ivParameterSpec = new IvParameterSpec(iv.getBytes("UTF-8") );
    9. cipher.init(Cipher.ENCRYPT_MODE, key , ivParameterSpec);
    10. byte[] verschlüsselt = cipher.doFinal( text.getBytes("UTF8") );
    12. String encryptedString = new String(Base64.getEncoder().encode(verschlüsselt),"UTF-8");
    13. System.out.println(encryptedString);
    14. //outout: yhkFI8IuDFpT62URI28XlQ==
    15. }
    16. catch(Exception e) {
    17. System.out.println("Es ist ein Fehler aufgetreten:");
    18. e.printStackTrace();
    19. }
    Alles anzeigen



    In Objective-C versuche ich jetzt die gleiche Verschlüsselung/Entschlüsselung hinzubekommen, bei der Verschlüsselung bekomme ein Anderen Ausgabe String: Hier der Objective-C Code:

    Quellcode

    1. @implementation NSData (MyCrypt)
    3. #define key @"1234567812345678"
    4. #define iv @"1234567812345678"
    7. - (NSData *) cryptOperation:(CCOperation)operation
    8. {
    9. // 'key' should be 32 bytes for AES256, will be null-padded otherwise
    10. //char keys[kCCKeySizeAES256 + 1];
    11. char keys[16 + 1];
    12. [key getCString:keys maxLength:sizeof(keys) encoding:NSUTF8StringEncoding];
    13. // Perform PKCS7Padding on the key.
    14. unsigned long bytes_to_pad = sizeof(keys) - [key length];
    15. if (bytes_to_pad > 0)
    16. {
    17. char byte = bytes_to_pad;
    18. for (unsigned long i = sizeof(keys) - bytes_to_pad; i < sizeof(keys); i++)
    19. keys[i] = byte;
    20. }
    21. NSUInteger dataLength = [self length];
    22. //See the doc: For block ciphers, the output size will always be less than or
    23. //equal to the input size plus the size of one block.
    24. //That's why we need to add the size of one block here
    25. size_t bufferSize = dataLength + kCCBlockSizeAES128;
    26. void *buffer = malloc(bufferSize);
    27. size_t numBytesDecrypted = 0;
    28. CCCryptorStatus status = CCCrypt(operation, kCCAlgorithmAES128,kCCOptionPKCS7Padding,
    29. keys,kCCKeySizeAES256,
    30. [iv UTF8String],
    31. [self bytes], dataLength, /* input */
    32. buffer, bufferSize, /* output */
    33. &numBytesDecrypted);
    34. if (status == kCCSuccess)
    35. {
    36. //the returned NSData takes ownership of buffer and will free it on dealloc
    37. return [NSData dataWithBytesNoCopy:buffer length:numBytesDecrypted];
    38. }
    39. free(buffer); //free the buffer;
    40. return nil;
    41. }
    43. - (NSData *)AES256Encrypt
    44. {
    45. return [self cryptOperation:kCCEncrypt];
    46. }
    48. - (NSData *)AES256Decrypt
    49. {
    50. return [self cryptOperation:kCCDecrypt];
    51. }
    Alles anzeigen

    (Erweiterung für NSData) und rufe folgende Funktionen auf:

    Quellcode

    1. // Auszug ...
    3. + (NSString *)encrypt:(NSString *)string
    4. {
    5. NSData *data = [string dataUsingEncoding:NSUTF8StringEncoding];
    6. NSData *dataEncrypted = [data AES256Encrypt];
    7. NSString *strRecordEncrypted = [dataEncrypted base64EncodedStringWithOptions:0];
    8. return strRecordEncrypted;
    9. }
    11. + (NSString *)decrypt:(NSString *)string
    12. {
    13. if([string containsString:@"\n"] || [string containsString:@"\t"])
    14. {
    15. string = [[string componentsSeparatedByCharactersInSet:[NSCharacterSet newlineCharacterSet]] componentsJoinedByString:@""];
    16. string = [string stringByReplacingOccurrencesOfString:@"\t" withString:@""];
    17. }
    18. NSData *keyData = [[NSData alloc] initWithBase64EncodedString:string options:0];
    19. NSData *dataDecrypted = [keyData AES256Decrypt];
    20. NSString *receivedDataDecryptString = [[NSString alloc]initWithData:dataDecrypted encoding:NSUTF8StringEncoding];
    21. return receivedDataDecryptString;
    22. }
    24. - (IBAction)doCryptAction:(id)sender {
    25. NSString *text = [self.textField stringValue];
    26. NSString *crypt = [MyCrypt encrypt:text];
    27. [self.cryptTextField setStringValue:crypt];
    28. }
    30. - (IBAction)decyrpytAction:(id)sender {
    31. NSString *crypt = [self.cryptTextField stringValue];
    32. NSString *decrypt = [MyCrypt decrypt:crypt];
    33. [self.decrypttextField setStringValue:decrypt];
    34. }
    Alles anzeigen

    Ausgabe Obj-C: tyjRv4y7aIE2fMlFRHje9w==
    Mein Problem jetzt, Java und Objective-C liefern mir unterschiedliche Ausgaben für das Verschlüsseln. Die Anforderungen laut Java-Code: AES-256-CBC, mit einem Key von 16Byte und dem IV mit 16Byte, diese Angaben sind auf beiden Seiten gleich, meine ich ...

    Hat jemand schon ein ähnlichen problem gehabt oder sieht den Fehler, den ich vor lauter Bäumen wahrscheinlich nicht sehe ... :/
    Danke ...
    Si tacuisses, philosophus mansisses !

  • FRing schrieb:


    Ausgabe Obj-C: tyjRv4y7aIE2fMlFRHje9w==
    Mein Problem jetzt, Java und Objective-C liefern mir unterschiedliche Ausgaben für das Verschlüsseln. Die Anforderungen laut Java-Code: AES-256-CBC, mit einem Key von 16Byte und dem IV mit 16Byte, diese Angaben sind auf beiden Seiten gleich, meine ich ...
    Ich denke, dass die Angaben nicht auf beiden Seiten gleich sind:
    Der Java-Code verwendet offenbar AES/CBC/PKCS5Padding.
    Der Objective-C Code AES-128 (statt 256 wie der Betreff andeutet) und PKCS7Padding.

    Da im Objective-C Code
    // 'key' should be 32 bytes for AES256, will be null-padded otherwise
    steht, vermute ich, dass auch der Java-Code AES-128 nutzt.
    Bleibt die Abweichung beim Padding und evtl. ist CBC im Objective-C Code auch nicht
    aktiv - wird zumindest nicht aus den Argumenten her klar.

  • Hallo marco,
    das hatte ich mir auch schon gedacht. Ich habe 'gegoogelt' und es ist wahrscheinlich wirklich so, das hier die Angabe in Java richtig ist, den PKCS7Padding mit PKCS5Padding gleichbehandelt wird ... Ich weiß, das sieht komisch aus ...
    Aber danke erstmal für den Hinweis.
    Gruß
    Si tacuisses, philosophus mansisses !

  • Hallo MCDan,
    ich habe die Lösung von deinem erste Link benutzt, musste aber ein wenig Hand anlegen, weil nur Keys mit einer Länge von 16 Byte funktionieren (IV und Keys 16 Byte lang). Was auch schlecht dokumentiert ist die Verwendung des iv. Default ist dieser Null (nil) auf der Objective-C Seite. Ich setze diesen zusätzlich mit der Verwendung eines 256-Hash. Wenn jemand interessiert ist, stelle ich den Code für Java und Objective-C gerne zur verfügung.
    Danke nochmal und grüße !

    Auszug AES-Crypt (NSData+CommonCrypto.m)

    Quellcode

    1. @implementation NSData (CommonCryptor)
    3. - (NSData *) AES256EncryptedDataUsingKey: (id) key error: (NSError **) error
    4. {
    5. CCCryptorStatus status = kCCSuccess;
    6. /*
    7. NSData * result = [self dataEncryptedUsingAlgorithm: kCCAlgorithmAES128
    8. key: key
    9. options: kCCOptionPKCS7Padding
    10. error: &status];
    11. */
    12. NSString *_t = @"1234567812345678";
    13. NSData *iv = [[_t dataUsingEncoding:NSUTF8StringEncoding] SHA256Hash];
    15. NSData *result = [self dataEncryptedUsingAlgorithm:kCCAlgorithmAES128
    16. key:key
    17. initializationVector:iv
    18. options:kCCOptionPKCS7Padding
    19. error:&status];
    21. if ( result != nil )
    22. return ( result );
    24. if ( error != NULL )
    25. *error = [NSError errorWithCCCryptorStatus: status];
    27. return ( nil );
    28. }
    30. - (NSData *) decryptedAES256DataUsingKey: (id) key error: (NSError **) error
    31. {
    32. CCCryptorStatus status = kCCSuccess;
    34. /*
    35. NSData * result = [self decryptedDataUsingAlgorithm: kCCAlgorithmAES128
    36. key: key
    37. options: kCCOptionPKCS7Padding
    38. error: &status];
    39. */
    41. NSString *_t = @"1234567812345678";
    42. NSData *iv = [[_t dataUsingEncoding:NSUTF8StringEncoding] SHA256Hash];
    43. NSData *result = [self decryptedDataUsingAlgorithm:kCCAlgorithmAES128
    44. key:key
    45. initializationVector:iv
    46. options:kCCOptionPKCS7Padding
    47. error:&status];
    49. if ( result != nil )
    50. return ( result );
    52. if ( error != NULL )
    53. *error = [NSError errorWithCCCryptorStatus: status];
    55. return ( nil );
    56. }
    Alles anzeigen
    Java:


    Java-Quellcode

    1. import java.io.UnsupportedEncodingException;
    2. import java.security.Key;
    3. import java.security.MessageDigest;
    4. import java.security.NoSuchAlgorithmException;
    5. import java.security.spec.AlgorithmParameterSpec;
    6. import javax.crypto.Cipher;
    7. import javax.crypto.spec.IvParameterSpec;
    8. import javax.crypto.spec.SecretKeySpec;
    11. public enum AESUtil {
    12. ;
    14. /**
    15. *
    16. * @param src
    17. * @param pw
    18. * @param iv
    19. * @return
    20. */
    21. public static String encrypt(String src,String pw,String iv) {
    22. try {
    23. Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
    24. cipher.init(Cipher.ENCRYPT_MODE, makeKey(pw), makeIv(iv));
    26. // Encrypt:
    27. // 1. cipher encrypt
    28. // 2. Base64 encode
    29. byte[] encrypt = cipher.doFinal( src.getBytes() );
    30. return testmp3.Base64.encodeBytes( encrypt );
    31. }
    32. catch (Exception e) {
    33. throw new RuntimeException(e);
    34. }
    35. }
    37. /**
    38. *
    39. * @param src
    40. * @param pw
    41. * @param iv
    42. * @return
    43. */
    44. public static String decrypt(String src,String pw,String iv) {
    45. String decrypted = "";
    46. try {
    47. Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
    48. cipher.init(Cipher.DECRYPT_MODE, makeKey(pw), makeIv(iv) );
    50. // Decrypt:
    51. // 1. Base64 decode
    52. // 2. cipher decrypt
    53. byte[] buffer = Base64.decode(src);
    55. decrypted = new String(cipher.doFinal(buffer));
    56. }
    57. catch (Exception e) {
    58. throw new RuntimeException(e);
    59. }
    60. return decrypted;
    61. }
    63. /**
    64. *
    65. * @param data
    66. * @param pw
    67. * @param iv
    68. * @return
    69. */
    70. public static byte[] encrypt(byte[] data,String pw,String iv) {
    71. byte[] buffer = null;
    72. try {
    73. Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
    74. cipher.init(Cipher.ENCRYPT_MODE, makeKey(pw), makeIv(iv)); // key and iv 16Bytes
    76. // Encrypt:
    77. // 1. cipher encrypt
    78. // 2. Base64 encode
    79. buffer = cipher.doFinal(data);
    81. byte[] encrypt = Base64.encodeBytesToBytes(buffer);
    82. return encrypt;
    83. }
    84. catch (Exception e) {
    85. throw new RuntimeException(e);
    86. }
    87. }
    89. /**
    90. *
    91. * @param data
    92. * @param pw
    93. * @param iv
    94. * @return
    95. */
    96. public static byte[] decrypt(byte[] data,String pw,String iv) {
    97. byte[] decrypted = null;
    98. try {
    99. Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
    100. cipher.init(Cipher.DECRYPT_MODE, makeKey(pw), makeIv(iv) );
    101. // Decrypt:
    102. // 1. Base64 decode
    103. // 2. cipher decrypt
    104. byte[] buffer = Base64.decode(data);
    105. decrypted = cipher.doFinal(buffer);
    106. }
    107. catch (Exception e) {
    108. throw new RuntimeException(e);
    109. }
    110. return decrypted;
    111. }
    113. /**
    114. *
    115. * @param ivp
    116. * @return
    117. * @throws NoSuchAlgorithmException
    118. */
    119. static AlgorithmParameterSpec makeIv(String ivp) throws NoSuchAlgorithmException {
    120. try {
    121. MessageDigest md = MessageDigest.getInstance("SHA-256");
    122. byte[] iv = md.digest(ivp.getBytes("UTF-8"));
    123. return new IvParameterSpec(iv,0,16);
    124. }
    125. catch (UnsupportedEncodingException e) {
    126. e.printStackTrace();
    127. }
    128. return null;
    129. }
    131. /**
    132. *
    133. * @param pw
    134. * @return
    135. */
    136. static Key makeKey(String pw) {
    137. try {
    138. MessageDigest md = MessageDigest.getInstance("SHA-256");
    139. byte[] key = md.digest(pw.getBytes("UTF-8"));
    140. return new SecretKeySpec(key,0,16, "AES");
    141. }
    142. catch (NoSuchAlgorithmException e) {
    143. e.printStackTrace();
    144. }
    145. catch (UnsupportedEncodingException e) {
    146. e.printStackTrace();
    147. }
    149. return null;
    150. }
    151. }
    Alles anzeigen
    Si tacuisses, philosophus mansisses !

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von FRing ()