DES加密简介

DES是一种对称加密算法，采用64位密钥技术(实际上只有前8位用来校验)，用得比较广泛，在项目中也用到过，记录一下所踩到的坑。原生API，需要调用#import <CommonCrypto/CommonCryptor.h>

代码

获取8位随机数
+ (long long)random8Numbers
 {
       return [self randomNumber:10000000 to:100000000];
 }
// 取一个随机整数，范围在[from,to），包括from，不包括to
+ (long long)randomNumber:(long long)from to:(long long)to
{
    return (long long)(from + arc4random() % (to - from + 1));
}
//生成8位随机字符+数字串
+ (NSString*)genRandomNum
{
     int maxNum = 36;
     int i;
     int count = 0;
     char str[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
     NSMutableString* pwd = [[NSMutableString alloc] init];
     while (count < 8) {
         i = arc4random() % maxNum;
         if (i >= 0 && i < maxNum) {
             [pwd appendFormat:@"%@", [NSString stringWithFormat:@"%c",str[i]]];
             count++;
         }
     }
     return pwd;
 }
  加密方法
  plainText 加密明文
  key 加密密钥
+ (NSString *)encryptUseDES:(NSString *)plainText key:(NSString *)key 
{
      NSMutableString *ciphertext = [NSMutableString new];//用于拼接加密后的字符串
      NSData * encryptData =[plainText dataUsingEncoding:NSUTF8StringEncoding];//明文转二进制
      const char *encryptBytes = (const char *)[encryptData bytes];//转字符
      size_t encryptDataLength = [encryptData length];//获取字符长度
      NSData * keyData =[key dataUsingEncoding:NSUTF8StringEncoding];//密钥转二进制
      const char *keyBytes = (const char *)[keyData bytes];//密钥转字符
      //size_t keyDataLength = [keyData length];//获取密钥长度(默认kCCKeySizeDES 8位，你也可以传入自己获取的长度，前提你的key只能写前八位)
      NSString * iv =[NSString stringWithFormat:@"%lld",[self random8Numbers]];//获取8位随机数向量
      NSData * ivData =[iv dataUsingEncoding:NSUTF8StringEncoding];//向量转二进制
      const char *ivBytes = (const char *)[ivData bytes];//向量转字符
      unsigned char buffer[1024 *15];//加密缓存大小 自己写的15k大小 1k 1024b 容纳512个汉子
      memset(buffer, 0, sizeof(char));//给缓存区开辟内存空间
      size_t numBytesEncrypted = 0;//用来表示长度
      CCCryptorStatus cryptStatus = CCCrypt(kCCEncrypt, kCCAlgorithmDES,//加密，加密类型DES
                                      kCCOptionPKCS7Padding,//在JAVA中使用这种方式加密："DES/CBC/PKCS5Padding" 对应的OC的是 kCCOptionPKCS7Padding.
                                      keyBytes, kCCKeySizeDES,//密钥字符数据，密钥字符长度
                                      ivBytes,//向量字符数据
                                      encryptBytes, encryptDataLength,//明文字符数据，明文字符长度
                                      buffer, 1024 *15,//缓存buffer，缓存buffer长度
                                      &numBytesEncrypted);//获取加密后的字符长度
      if (cryptStatus == kCCSuccess)//加密成功
      {
            NSData *data = [NSData dataWithBytes:buffer length:(NSUInteger)numBytesEncrypted];//获取加密后的二进制数据          
            NSString * one =[self convertDataToHexStr:[iv dataUsingEncoding:NSUTF8StringEncoding]];//向量二进制数据转16进制字符串                  
            NSString * two = [self convertDataToHexStr:data];//加密后的二进制转16进制字符串 
            [ciphertext appendString:one];//拼接向量(根据后台需求 可能固定的向量就不用拼接)
            [ciphertext appendString:two];//拼接加密后的数据
            [ciphertext uppercaseString];//转大写   以上都是根据服务端需求来写,有些可能不是转16进制，可能是base64，可以用GTMBase库，github上搜一下就行。
      }
      return [ciphertext copy];//返回最后字符串 传给后台
}

解密 就是加密的一个逆推过程 仔细看一下就明白了 就不一一注释
cioherText 密文
key 密钥
+ (NSString *)decryptUseDES:(NSString*)cipherText key:(NSString*)key
{
    NSString * ivHex;
    NSString * cipherString =[cipherText copy];
    [cipherString lowercaseString];
    NSString * sub =[self convertDataToHexStr:[@"12345678" dataUsingEncoding:NSUTF8StringEncoding]];//获取向量长度，不一定12345678八位即可，只用来计算长度当然可以直接写个16    
    if ([cipherString length]>=[sub length])//截取出密码密文 和 向量密文
    {
        cipherText =[cipherString substringFromIndex:[sub length]];//密码16进制字符串
        ivHex =[cipherString substringToIndex:[sub length]];//向量16进制字符串
    }
    NSData* cipherData = [self convertHexStrToData:cipherText];
    const char *cipherBytes = (const char *)[cipherData bytes];
    size_t ciphertDataLength = [cipherData length];
    NSData * keyData =[key dataUsingEncoding:NSUTF8StringEncoding];
    const char *keyBytes = (const char *)[keyData bytes];
    // size_t keyDataLength = [keyData length];
    NSData * ivData =[self convertHexStrToData:ivHex];
    const char *ivBytes = (const char *)[ivData bytes];
    unsigned char buffer[1024 * 15];
    memset(buffer, 0, sizeof(char));
    size_t numBytesDecrypted = 0;
    CCCryptorStatus cryptStatus = CCCrypt(kCCDecrypt,
                                          kCCAlgorithmDES,kCCOptionPKCS7Padding,
                                          keyBytes,kCCKeySizeDES,
                                          ivBytes,
                                          cipherBytes,ciphertDataLength,
                                          buffer,1024 * 15,
                                          &numBytesDecrypted);
    NSString* plainText = nil;
    if (cryptStatus == kCCSuccess)
    {
        NSData* data = [NSData dataWithBytes:buffer length:(NSUInteger)numBytesDecrypted];
        plainText = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
    }
    return plainText;
}

 //将NSString转换成十六进制的字符串则可使用如下方式:
+ (NSString *)convertDataToHexStr:(NSData *)data
{
     NSMutableString *string = [[NSMutableString alloc] initWithCapacity:[data length]];

    [data enumerateByteRangesUsingBlock:^(const void *bytes, NSRange byteRange, BOOL *stop) {
        unsigned char *dataBytes = (unsigned char*)bytes;
        for (NSInteger i = 0; i < byteRange.length; i++) {
            NSString *hexStr = [NSString stringWithFormat:@"%x", (dataBytes[i]) & 0xff];
            if ([hexStr length] == 2) {
                [string appendString:hexStr];
            } else {
                [string appendFormat:@"0%@", hexStr];
            }
        }
    }];
    return string;
}
//将十六进制的字符串转换成NSString则可使用如下方式:
+ (NSData *)convertHexStrToData:(NSString *)str
{
    if (!str || [str length] == 0)
    {
        return nil;
    }
    NSMutableData *hexData = [[NSMutableData alloc] initWithCapacity:8];
    NSRange range;
    if ([str length] % 2 == 0)
    {
        range = NSMakeRange(0, 2);
    } else {
        range = NSMakeRange(0, 1);
    }
    for (NSInteger i = range.location; i < [str length]; i += 2) {
        unsigned int anInt;
        NSString *hexCharStr = [str substringWithRange:range];
        NSScanner *scanner = [[NSScanner alloc] initWithString:hexCharStr];
        [scanner scanHexInt:&anInt];
        NSData *entity = [[NSData alloc] initWithBytes:&anInt length:1];
        range.location += range.length;
        range.length = 2;
    }
    return hexData;
}

遇到的坑

1.首先是java和oc的不一致性，前人踩过后，得出的结果如下：
在JAVA中使用这种方式加密："DES/CBC/PKCS5Padding" 对应的OC的是 kCCOptionPKCS7Padding.
而使用 "DES/ECB/PKCS5Padding" 对应的OC的是 kCCOptionPKCS7Padding | kCCOptionECBMod
觉得似乎OC目前只支持这两种方式的加密,当然结果是已经得到验证的。
2.后台可能会加一些东西,或者改变一些方式:
比如加密后可能要转base64，可能要转16进制，可能要转大写。(根据后台需求来指定)
加密前的明文数据不足X位要补齐(至于补齐什么看后台规则)，超过X位但不是X位的倍数，所除的余数N，利用N再补字符(至于怎么补,看后台逻辑,会告诉你不然怎么联调)。！！！这是个大坑 联调了一天 加密结果跟后台结果老是不一样，就是因为没有告诉我这个逻辑，或许是这个逻辑是DES自带的 我不知道？

原创文章,转载请注明出处，谢谢！(有错误请及时指正，会尽快修改，第一次写难免会有遗漏!)

Demo