java C# objective-c AES对称加解密

 /**
  * AES加解密
  */
 public class AESHelper {
     final static String AES_KEY = "43hr8fhu34b58123";  
 
     /**
      * AES加密
      *
      * @param text
      * 待加密字符串
      * @return 加密后字符串
      */
     public static String AESEncrypt(String text) {
         try {
             String password = AES_KEY;
             SecretKeySpec skeySpec = new SecretKeySpec(password.getBytes(), "AES");
             Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
             cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
             String strTmp = Base64.encodeToString(cipher.doFinal(text.getBytes()), Base64.DEFAULT);
             return strTmp;
         } catch (Exception e) {
             e.printStackTrace();
         }
         return text;
     }  
 
     /**
      * AES解密
      *
      * @param text
      * 待解密字符串
      * @return 解密后字符串
      */
     public static String aesDecrypt(String text) {
         try {
             String password = AES_KEY;
             SecretKeySpec skeySpec = new SecretKeySpec(password.getBytes(), "AES");
             Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
             cipher.init(Cipher.DECRYPT_MODE, skeySpec);
             String strTmp = new String(cipher.doFinal(Base64.decode(text, Base64.DEFAULT)));
             return strTmp;
         } catch (Exception ex) {
             ex.printStackTrace();
         }
         return text;
     }
 } 

Java

 public class AESHelper
     {
         const string AES_KEY = "43hr8fhu34b58123";  
 
         /// <summary>
         /// AES加密
         /// </summary>
         /// <param name="Text">待加密字符串</param>
         /// <returns>加密后字符串</returns>
         public static string AESEncrypt(string Text)
         {
             try
             {
                 string key = AES_KEY;
                 //分组加密算法
                 AesCryptoServiceProvider aes =new AesCryptoServiceProvider();
                 byte[] inputByteArray = Encoding.UTF8.GetBytes(Text);//得到需要加密的字节数组
                 //设置密钥及密钥向量
                 aes.Key = Encoding.UTF8.GetBytes(key);
                 //aes.IV = Encoding.UTF8.GetBytes(key);
                 aes.Mode = CipherMode.ECB;
                 aes.Padding = PaddingMode.PKCS7;
                 byte[] cipherBytes = null;
                 using (MemoryStream ms = new MemoryStream())
                 {
                     using (CryptoStream cs = new CryptoStream(ms, aes.CreateEncryptor(), CryptoStreamMode.Write))
                     {
                         cs.Write(inputByteArray, , inputByteArray.Length);
                         cs.FlushFinalBlock();
                         cipherBytes = ms.ToArray();//得到加密后的字节数组
                         cs.Close();
                         ms.Close();
                     }
                 }
                 return Convert.ToBase64String(cipherBytes);
             }
             catch { }
             return Text;
         }  
 
         /// <summary>
         /// AES解密
         /// </summary>
         /// <param name="Text">待解密字符串</param>
         /// <returns>解密后字符串</returns>
         public static string AESDecrypt(string Text)
         {
             try
             {
                 string key = AES_KEY;
                 byte[] cipherText = Convert.FromBase64String(Text);
                 AesCryptoServiceProvider aes = new AesCryptoServiceProvider();
                 aes.Key = Encoding.UTF8.GetBytes(key);
                 //aes.IV = Encoding.UTF8.GetBytes(key);
                 aes.Mode = CipherMode.ECB;
                 aes.Padding = PaddingMode.PKCS7;
                 byte[] decryptBytes = new byte[cipherText.Length];
                 using (MemoryStream ms = new MemoryStream(cipherText))
                 {
                     using (CryptoStream cs = new CryptoStream(ms, aes.CreateDecryptor(), CryptoStreamMode.Read))
                     {
                         cs.Read(decryptBytes, , decryptBytes.Length);
                         cs.Close();
                         ms.Close();
                     }
                 }
                 return Encoding.UTF8.GetString(decryptBytes).Replace("\0", "");   //将字符串后尾的'\0'去掉
             }
             catch { }
             return Text;
         }
     }  

C#

 /*
  *.h文件
  */
 #import <Foundation/Foundation.h>  
 
 @interface Security : NSObject
 +(NSString*)AesEncrypt:(NSString*)str;
 +(NSString*)AesDecrypt:(NSString*)str;
 @end  
 
 --------------------------------------------------------------------------------
 
 /*
  *.m文件
  */
 #import "Security.h"
 #import <CommonCrypto/CommonCryptor.h>
 static const char encodingTable[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 #define LocalStr_None @"" //空字符串  
 
 @implementation Security  
 
 /*
  * AES加密
  *
  */
 +(NSString*)AesEncrypt:(NSString*)str{
     NSString *key=@"43hr8fhu34b58123"; // 密钥
     NSData *data=[str dataUsingEncoding:NSUTF8StringEncoding]; // 待加密字符转为NSData型
     char keyPtr[kCCKeySizeAES128 + ];
     memset(keyPtr, , sizeof(keyPtr));
     [key getCString:keyPtr maxLength:sizeof(keyPtr) encoding:NSUTF8StringEncoding];  
 
     NSUInteger dataLength = [data length];
     size_t bufferSize = dataLength + kCCBlockSizeAES128;
     voidvoid *buffer = malloc(bufferSize);  
 
     size_t numBytesCrypted = ;
     CCCryptorStatus cryptStatus = CCCrypt(kCCEncrypt,
                                           kCCAlgorithmAES128,
                                           kCCOptionPKCS7Padding|kCCOptionECBMode,
                                           keyPtr,
                                           kCCBlockSizeAES128,
                                           nil,
                                           [data bytes],
                                           dataLength,
                                           buffer,
                                           bufferSize,
                                           &numBytesCrypted);
     if (cryptStatus == kCCSuccess) {
         NSData *resultData=[NSData dataWithBytesNoCopy:buffer length:numBytesCrypted];
         NSString *result =[self base64EncodedStringFrom:resultData];
         return result;
     }
     free(buffer);
     return str;
 }  
 
 /*
  * AES解密
  *
  */
 +(NSString*)AesDecrypt:(NSString*)str{
     NSString *key=@"Q*1_3@c!4kd^j&g%"; // 密钥
     NSData *data=[self dataWithBase64EncodedString:str]; // base4解码
     char keyPtr[kCCKeySizeAES128 + ];
     memset(keyPtr, , sizeof(keyPtr));
     [key getCString:keyPtr maxLength:sizeof(keyPtr) encoding:NSUTF8StringEncoding];  
 
     NSUInteger dataLength = [data length];
     size_t bufferSize = dataLength + kCCBlockSizeAES128;
     voidvoid *buffer = malloc(bufferSize);  
 
     size_t numBytesCrypted = ;
     CCCryptorStatus cryptStatus = CCCrypt(kCCDecrypt,
                                           kCCAlgorithmAES128,
                                           kCCOptionPKCS7Padding|kCCOptionECBMode,
                                           keyPtr,
                                           kCCBlockSizeAES128,
                                           nil,
                                           [data bytes],
                                           dataLength,
                                           buffer,
                                           bufferSize,
                                           &numBytesCrypted);
     if (cryptStatus == kCCSuccess) {
         NSData *resultData=[NSData dataWithBytesNoCopy:buffer length:numBytesCrypted];
         NSString *result =[[NSString alloc]initWithData:resultData encoding:NSUTF8StringEncoding];
         return result;
     }
     free(buffer);
     return str;
 }  
 
 + (NSString *)base64StringFromText:(NSString *)text
 {
     if (text && ![text isEqualToString:LocalStr_None]) {
         NSData *data = [text dataUsingEncoding:NSUTF8StringEncoding];
         return [self base64EncodedStringFrom:data];
     }
     else {
         return LocalStr_None;
     }
 }  
 
 + (NSString *)textFromBase64String:(NSString *)base64
 {
     if (base64 && ![base64 isEqualToString:LocalStr_None]) {
         NSData *data = [self dataWithBase64EncodedString:base64];
         return [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
     }
     else {
         return LocalStr_None;
     }
 }  
 
 + (NSData *)dataWithBase64EncodedString:(NSString *)string
 {
     if (string == nil)
         [NSException raise:NSInvalidArgumentException format:nil];
     if ([string length] == )
         return [NSData data];  
 
     static charchar *decodingTable = NULL;
     if (decodingTable == NULL)
     {
         decodingTable = malloc();
         if (decodingTable == NULL)
             return nil;
         memset(decodingTable, CHAR_MAX, );
         NSUInteger i;
         for (i = ; i < ; i++)
             decodingTable[(short)encodingTable[i]] = i;
     }  
 
     const charchar *characters = [string cStringUsingEncoding:NSASCIIStringEncoding];
     if (characters == NULL)     //  Not an ASCII string!
         return nil;
     charchar *bytes = malloc((([string length] + ) / ) * );
     if (bytes == NULL)
         return nil;
     NSUInteger length = ;  
 
     NSUInteger i = ;
     while (YES)
     {
         char buffer[];
         short bufferLength;
         for (bufferLength = ; bufferLength < ; i++)
         {
             if (characters[i] == '\0')
                 break;
             if (isspace(characters[i]) || characters[i] == '=')
                 continue;
             buffer[bufferLength] = decodingTable[(short)characters[i]];
             if (buffer[bufferLength++] == CHAR_MAX)      //  Illegal character!
             {
                 free(bytes);
                 return nil;
             }
         }  
 
         if (bufferLength == )
             break;
         if (bufferLength == )      //  At least two characters are needed to produce one byte!
         {
             free(bytes);
             return nil;
         }  
 
         //  Decode the characters in the buffer to bytes.
         bytes[length++] = (buffer[] << ) | (buffer[] >> );
         if (bufferLength > )
             bytes[length++] = (buffer[] << ) | (buffer[] >> );
         if (bufferLength > )
             bytes[length++] = (buffer[] << ) | buffer[];
     }  
 
     bytes = realloc(bytes, length);
     return [NSData dataWithBytesNoCopy:bytes length:length];
 }  
 
 + (NSString *)base64EncodedStringFrom:(NSData *)data
 {
     if ([data length] == )
         return @"";  
 
     charchar *characters = malloc((([data length] + ) / ) * );
     if (characters == NULL)
         return nil;
     NSUInteger length = ;  
 
     NSUInteger i = ;
     while (i < [data length])
     {
         char buffer[] = {,,};
         short bufferLength = ;
         while (bufferLength <  && i < [data length])
             buffer[bufferLength++] = ((charchar *)[data bytes])[i++];  
 
         //  Encode the bytes in the buffer to four characters, including padding "=" characters if necessary.
         characters[length++] = encodingTable[(buffer[] & 0xFC) >> ];
         characters[length++] = encodingTable[((buffer[] & 0x03) << ) | ((buffer[] & 0xF0) >> )];
         if (bufferLength > )
             characters[length++] = encodingTable[((buffer[] & 0x0F) << ) | ((buffer[] & 0xC0) >> )];
         else characters[length++] = '=';
         if (bufferLength > )
             characters[length++] = encodingTable[buffer[] & 0x3F];
         else characters[length++] = '=';
     }  
 
     return [[NSString alloc] initWithBytesNoCopy:characters length:length encoding:NSASCIIStringEncoding freeWhenDone:YES];
 }  
 
 @end  

Objective-C