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;  
    }  
} 

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, 0, 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, 0, decryptBytes.Length);  
                        cs.Close();  
                        ms.Close();  
                    }  
                }  
                return Encoding.UTF8.GetString(decryptBytes).Replace("", "");   //将字符串后尾的''去掉  
            }  
            catch { }  
            return Text;  
        }  
    }  

/*
 *.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 + 1];  
    memset(keyPtr, 0, 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 = 0;  
    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 + 1];  
    memset(keyPtr, 0, 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 = 0;  
    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] == 0)  
        return [NSData data];  
      
    static charchar *decodingTable = NULL;  
    if (decodingTable == NULL)  
    {  
        decodingTable = malloc(256);  
        if (decodingTable == NULL)  
            return nil;  
        memset(decodingTable, CHAR_MAX, 256);  
        NSUInteger i;  
        for (i = 0; i < 64; 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] + 3) / 4) * 3);  
    if (bytes == NULL)  
        return nil;  
    NSUInteger length = 0;  
      
    NSUInteger i = 0;  
    while (YES)  
    {  
        char buffer[4];  
        short bufferLength;  
        for (bufferLength = 0; bufferLength < 4; i++)  
        {  
            if (characters[i] == '')  
                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 == 0)  
            break;  
        if (bufferLength == 1)      //  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[0] << 2) | (buffer[1] >> 4);  
        if (bufferLength > 2)  
            bytes[length++] = (buffer[1] << 4) | (buffer[2] >> 2);  
        if (bufferLength > 3)  
            bytes[length++] = (buffer[2] << 6) | buffer[3];  
    }  
      
    bytes = realloc(bytes, length);  
    return [NSData dataWithBytesNoCopy:bytes length:length];  
}  
  
+ (NSString *)base64EncodedStringFrom:(NSData *)data  
{  
    if ([data length] == 0)  
        return @"";  
      
    charchar *characters = malloc((([data length] + 2) / 3) * 4);  
    if (characters == NULL)  
        return nil;  
    NSUInteger length = 0;  
      
    NSUInteger i = 0;  
    while (i < [data length])  
    {  
        char buffer[3] = {0,0,0};  
        short bufferLength = 0;  
        while (bufferLength < 3 && 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[0] & 0xFC) >> 2];  
        characters[length++] = encodingTable[((buffer[0] & 0x03) << 4) | ((buffer[1] & 0xF0) >> 4)];  
        if (bufferLength > 1)  
            characters[length++] = encodingTable[((buffer[1] & 0x0F) << 2) | ((buffer[2] & 0xC0) >> 6)];  
        else characters[length++] = '=';  
        if (bufferLength > 2)  
            characters[length++] = encodingTable[buffer[2] & 0x3F];  
        else characters[length++] = '=';  
    }  
      
    return [[NSString alloc] initWithBytesNoCopy:characters length:length encoding:NSASCIIStringEncoding freeWhenDone:YES];  
}  
  
@end