精华内容
下载资源
问答
  • 不安全的加密算法有哪几种
    千次阅读
    2020-12-20 21:51:41

    大家好,我是时间财富网智能客服时间君,上述问题将由我为大家进行解答。

    不安全的加密算法有以下几种:

    1、DES(Data Encryption Standard):数据加密标准,速度较快,适用于加密大量数据的场合。

    2、3DES(Triple DES):是基于DES,对一块数据用三个不同的密钥进行三次加密,强度更高。

    3、AES(Advanced Encryption Standard):高级加密标准,是下一代的加密算法标准,速度快,安全级别高。

    数据加密的基本过程就是对原来为明文的文件或数据按某种算法进行处理,使其成为不可读的一段代码为“密文”,使其只能在输入相应的密钥之后才能显示出原容,通过这样的途径来达到保护数据不被非法人窃取、阅读的目的。 该过程的逆过程为解密,即将该编码信息转化为其原来数据的过程。通过修改文件的md5值,可以绕过某些网盘的“违规文件扫描机制”,这是因为网盘服务器内存储着已知违规文件的md5值,当上传文件时会自动与服务器md5数据库匹配以判断是否违规。

    更多相关内容
  • 几种常用数据加密算法的比较45几种常用数据加密算法的比较Theo朋paris帆ofsoImoH姗伽崎一琳ed肪taD蝴了p归蚰Al酬thms陈健(福建商业高等专科学校计算机系福建福州350012)内容提要描述了密码体制中几种数据加密算法的...

    2003

    l

    o

    月第

    5

    健:几种常用数据加密算法的比较

    45

    几种常用数据加密算法的比较

    T

    he

    o

    par

    i

    s

    of

    soI

    m

    oH

    姗伽崎一琳

    ed

    t

    a

    D

    p

    Al

    t

    hm

    s

    (

    福建商业高等专科学校计算机系

    福建福州

    350012)

    内容提要

    描述了密码体制中几种数据加密算法的厚理及加密、解密过程,分析了各种算法的性能和适用的场合,提出了网络

    上实现数据加密较好的方法。

    关键词信息安垒算法公钥密钥

    中图分类号:

    TN

    918

    文献标识码:

    A

    文章编号:

    l

    8

    4940f

    2003)

    05

    一呻

    45

    一∞

    1

    网络发展的安全需求

    随着网络技术的发展及网上活动的丑益频繁,如何保证及

    加强信息安全性成为目前迫切需

    要解决的热点课题。网络的安

    全需求一般分为:

    ①数据保密:防止非授权用户截获并使用该数据;

    ②数据完整性:用户使用一种方案来确认网络上的数据在

    传输过程中没有被篡改;

    ③身份验证:用户需要对网络上的另一个用户进行验证.证

    实他就是他所声称的那个人;

    ④授权:用户需要控制谁能够访问网络上的信息并且能够

    进行何种操作;

    ⑤不可抵赖和不可否认:用户不能抵赖自已曾作出的行为,

    也不能否认曾经接到对方的信息.这在交易系统中十分重要。

    另外,保护硬件资源不被非法占有,软件资源免受病毒的侵

    害,都构成了整个信息网络上的安全需求。

    2

    密码体制概述

    防火墙等技术是一种被动的肪卫技术.而加密则是一种主

    动的防卫措施。网络安全的核心将建立在密码学理论与技术

    上。

    密码技术是保护信息安全的主要手段之一。使用密码技术

    不仅可以保证信息的机密性,而且可以保证信息的完整性和确

    证性.防止信息被篡改、伪造和假冒。从密码体制方面而言.密

    码体制有对称密钥密码技术和非对称密钥密码技术。对称密钥

    密码技术要求加密解密双方拥有相同的密钥;而非对称密钥密

    码技术是加密解密双方拥有不相同的密钥。在不知道陷门信息

    的情况下,加密密钥和解密密钥在计算上是不能相互算出的。

    密码学不仅仅是编码与破译的学问.而且包括安全管理、安

    全协议设计、秘密分存、散列函数等内容。到目前为止,密码学

    中出现了大量的新技术和新概念

    ,例如零知识证明技术、盲签

    名、比特承诺、遗忘传递、

    字化现金、量子密码技术、混炖密码

    等。

    3

    对称密钥密码技木

    3

    l

    序列密码

    序列密码的主要原理是,通过有限状态机产生性能优良的

    伪随机序列,使用该序列加密信息流

    (

    莲比特加密

    )

    得到密文序

    列。所以,序列密码算法的安全强度完全决定于它所产生的伪

    随机序列的好坏。衡量一个伪随机序列好坏的标准有多种,比

    较通用的有著名的

    c0

    蛐的三个条件:

    Ruep

    一的线性复杂度随

    机走动条件、线性逼近以及产生该序列的布尔函数满足的相关

    免疫条件等。

    3

    2

    分组密码

    分组密码的工作方式是将明文分成固定长度的组

    (

    )

    ,如

    64B

    一组.

    用同一密钥和算法

    对每一块加密.输

    出也是固定长度

    的密文。例如

    D

    Es

    密码算法的输人为

    64B

    明文,密钥长度

    56B

    密文长度“

    B

    设计分组密码算法的核心技术

    是:在相信复杂函数可以通

    过简单函数迭代若干圈得到的原则下,利用简单圈函数及对合

    等运算,

    充分利用非线性运算

    。以

    D

    Es

    算法为例

    ,它采用美国国

    家安全局精心设计的

    8

    s

    B

    0x

    P

    一置换,经过

    16

    圈迭代,最

    终产生

    64B

    密文,每圈迭代使用的鹌

    B

    子密钥是由原始的

    56B

    生的。

    采用

    D

    Es

    的一个著名的网络安全系统是

    kd

    e

    腊.由~叮开

    发,是网络通信中身份认证的工业上的事实标准。

    D

    ES(

    或其它分组密码

    )

    算法的

    使用方式有

    4

    种:电子密本、

    密码分组链接、输出反馈和密文反馈。

    D

    礴的密钥存在弱密铜,

    半弱密钥和互补密钥,选择密钥时要注意这些问题。

    DE

    s

    受到

    的最大攻击是它的密钥长度仅有

    56

    比特,强力攻击的代价低于

    1000

    万美元,

    1990

    s

    B

    i

    h

    啪和

    A

    s

    hr

    l

    if

    提出了差分攻击的方

    法,采用选择明文

    247

    攻击,最终找到可能的密钥,

    M

    M

    址嘶提出

    的线性分析方法.利用

    243

    个已知明文,成功地破译了

    16

    D

    Es

    算法,到目前为止,这是最有效的破译方法。

    基于以上弱点,人们将

    D

    Es

    算法作了多种变形,三重

    D

    Es

    式,独立子密钥

    法,可变的

    s

    B

    喊及其使用次序以及推广的

    G

    D

    Es

    等。这些改变有些是增强了密码算法的安全性,有些作用

    不大,有些还削弱了

    D

    ES

    的安全性。

    自从

    D

    展开全文
  • 常见的几种加密算法

    千次阅读 2020-12-20 21:51:36
    1、常见的几种加密算法:DES(DataEncryptionStandard):数据加密标准,速度较快,适用于加密大量数据的场合;3DES(TripleDES):是基于DES,对一块数据用三个不同的密钥进行三次加密,强度更高;RC2和RC4:用变长密钥...

    1

    、常见的几种加密算法:

    DES

    (

    Data Encryption Standard

    ):数据加密标准,速度较

    快,适用于加密大量数据的场合;

    3DES

    (

    Triple DES

    ):是基于

    DES

    ,对一块数据用三个不同的

    密钥进行三次加密,强度更高;

    RC2

    RC4

    :用变长密钥对大量数据进行加密,比

    DES

    快;

    IDEA

    (

    International Data Encryption Algorithm

    )国际数据

    加密算法,使用

    128

    位密钥提供非常强的安全性;

    RSA

    :由

    RSA

    公司发明,是一个支持变长密钥的公共密钥算

    法,需要加密的文件块的长度也是可变的;

    DSA

    (

    Digital Signature Algorithm

    ):数字签名算法,是一种

    标准的

    DSS

    (数字签名标准);

    AES

    (

    Advanced Encryption Standard

    ):高级加密标准,是

    下一代的加密算法标准,

    速度快,

    安全级别高,目前

    AES

    标准

    的一个实现是

    Rijndael

    算法;

    BLOWFISH

    ,它使用变长的密钥,长度可达

    448

    位,运行速度

    很快;

    其它算法,如

    ElGamal

    钥、

    Deffie-Hellman

    、新型椭圆曲线算

    ECC

    等。

    2

    、公钥和私钥:

    展开全文
  • 常见的几种加密方法

    千次阅读 2020-12-20 21:51:40
    常见的几种加密方法和实常见的几种加密方法 :MD5SHA1RSAAESDES1、MD5加密 是HASH算法一种、 是生成32位的数字字母混合码。 MD5主要特点是 不可逆MD5算法还具有以下性质:1、压缩性:任意长度的数据,算出的MD5值...

    常见的几种加密方法和实

    常见的几种加密方法 :

    MD5

    SHA1

    RSA

    AES

    DES

    1、MD5加密 是HASH算法一种、 是生成32位的数字字母混合码。 MD5主要特点是 不可逆

    MD5算法还具有以下性质:

    1、压缩性:任意长度的数据,算出的MD5值长度都是固定的。

    2、容易计算:从原数据计算出MD5值很容易。

    3、抗修改性:对原数据进行任何改动,哪怕只修改1个字节,所得到的MD5值都有很大区别。

    4、弱抗碰撞:已知原数据和其MD5值,想找到一个具有相同MD5值的数据(即伪造数据)是非常困难的。

    5、强抗碰撞:想找到两个不同的数据,使它们具有相同的MD5值,是非常困难的。

    具体代码

    //输出小写

    - (NSString *)lowerMD5:(NSString *)inPutText

    {

    //传入参数,转化成char

    const char *cStr = [inPutText UTF8String];

    //开辟一个16字节的空间

    unsigned char result[CC_MD5_DIGEST_LENGTH];

    /*

    extern unsigned char * CC_MD5(const void *data, CC_LONG len, unsigned char *md)官方封装好的加密方法

    把str字符串转换成了32位的16进制数列(这个过程不可逆转) 存储到了md这个空间中

    */

    CC_MD5(cStr, (CC_LONG)strlen(cStr), result);

    return [[NSString stringWithFormat:@"%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",

    result[0], result[1], result[2], result[3],

    result[4], result[5], result[6], result[7],

    result[8], result[9], result[10], result[11],

    result[12], result[13], result[14], result[15]

    ] lowercaseString];  //大小写注意

    }

    //输出大写

    - (NSString *)upperMD5:(NSString *)inPutText

    {

    //传入参数,转化成char

    const char *cStr = [inPutText UTF8String];

    //开辟一个16字节的空间

    unsigned char result[CC_MD5_DIGEST_LENGTH];

    /*

    extern unsigned char * CC_MD5(const void *data, CC_LONG len, unsigned char *md)官方封装好的加密方法

    把str字符串转换成了32位的16进制数列(这个过程不可逆转) 存储到了md这个空间中

    */

    CC_MD5(cStr, (CC_LONG)strlen(cStr), result);

    return [[NSString stringWithFormat:@"%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",

    result[0], result[1], result[2], result[3],

    result[4], result[5], result[6], result[7],

    result[8], result[9], result[10], result[11],

    result[12], result[13], result[14], result[15]

    ] uppercaseString];  //大小写注意

    }

    调用 : 代码实现

    NSLog(@"小写:%@",[self lowerMD5:@"123456"]);

    NSLog(@"大写:%@",[self upperMD5:@"123456"]);

    为了让MD5码更加安全 ,我们现在都采用加盐,盐要越长越乱,得到的MD5码就很难查到。

    static NSString * salt =@"asdfghjklpoiuytrewqzxcvbnm";

    NSLog(@"加盐小写:%@",[self lowerMD5:[@"123456" stringByAppendingString:salt]]);

    NSLog(@"加盐大写:%@",[self upperMD5:[@"123456" stringByAppendingString:salt]]);

    输出结果

    2018-11-27 15:27:12.012590+0800 Encryption[12828:3995427]

    小写:e10adc3949ba59abbe56e057f20f883e 2018-11-27 15:27:12.012774+0800

    Encryption[12828:3995427] 大写:E10ADC3949BA59ABBE56E057F20F883E

    2018-11-27 15:27:12.012901+0800 Encryption[12828:3995427]

    加盐小写:71d1bda9346fab4eea309f4ed74b8f80 2018-11-27 15:27:12.013108+0800

    Encryption[12828:3995427] 加盐大写:71D1BDA9346FAB4EEA309F4ED74B8F80

    2、SHA1 算法是哈希算法的一种

    代码实现 :

    //sha1

    - (NSString *)sha1:(NSString *)input

    {

    const char *cstr = [input cStringUsingEncoding:NSUTF8StringEncoding];

    NSData *data = [NSData dataWithBytes:cstr length:input.length];

    //使用对应的  CC_SHA1_DIGEST_LENGTH,CC_SHA224_DIGEST_LENGTH,CC_SHA256_DIGEST_LENGTH,CC_SHA384_DIGEST_LENGTH,CC_SHA512_DIGEST_LENGTH的长度分别是20,28,32,48,64。;看你们需求选择对应的长度

    uint8_t digest[CC_SHA1_DIGEST_LENGTH];

    CC_SHA1(data.bytes, (unsigned int)data.length, digest);

    NSMutableString *output = [NSMutableString stringWithCapacity:CC_SHA1_DIGEST_LENGTH * 2];

    for(int i=0; i

    [output appendFormat:@"%02x", digest[i]];

    }

    NSLog(@"sha----->%@",output);

    return output;

    }

    调用 代码实现 [self sha1:@"123456"];

    运行结果 :

    2018-11-27 15:27:12.013237+0800 Encryption[12828:3995427]

    sha----7c4a8d09ca3762af61e59520943dc26494f8941b

    3、RSA 非对称加密算法 (公钥私钥生成步骤点击)

    非对称加密算法需要两个密钥:公开密钥(publickey)和私有密钥(privatekey)

    公开密钥与私有密钥是一对,用公开密钥对数据进行加密,只有用对应的私有密钥才能解密;

    特点:

    非对称密码体制的特点:算法强度复杂、安全性依赖于算法与密钥但是由于其算法复杂,而使得加密解密速度没有对称加密解密的速度快

    对称密码体制中只有一种密钥,并且是非公开的,如果要解密就得让对方知道密钥。所以保证其安全性就是保证密钥的安全,而非对称密钥体制有两种密钥,其中一个是公开的,这样就可以不需要像对称密码那样传输对方的密钥了

    具体代码:

    .h

    // return base64 encoded string

    + (NSString *)encryptString:(NSString *)str publicKey:(NSString *)pubKey;

    // return raw data

    + (NSData *)encryptData:(NSData *)data publicKey:(NSString *)pubKey;

    // return base64 encoded string

    + (NSString *)encryptString:(NSString *)str privateKey:(NSString *)privKey;

    // return raw data

    + (NSData *)encryptData:(NSData *)data privateKey:(NSString *)privKey;

    // decrypt base64 encoded string, convert result to string(not base64 encoded)

    + (NSString *)decryptString:(NSString *)str publicKey:(NSString *)pubKey;

    + (NSData *)decryptData:(NSData *)data publicKey:(NSString *)pubKey;

    + (NSString *)decryptString:(NSString *)str privateKey:(NSString *)privKey;

    + (NSData *)decryptData:(NSData *)data privateKey:(NSString *)privKey;

    实现

    static NSString *base64_encode_data(NSData *data){

    data = [data base64EncodedDataWithOptions:0];

    NSString *ret = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];

    return ret;

    }

    static NSData *base64_decode(NSString *str){

    NSData *data = [[NSData alloc] initWithBase64EncodedString:str options:NSDataBase64DecodingIgnoreUnknownCharacters];

    return data;

    }

    + (NSData *)stripPublicKeyHeader:(NSData *)d_key{

    // Skip ASN.1 public key header

    if (d_key == nil) return(nil);

    unsigned long len = [d_key length];

    if (!len) return(nil);

    unsigned char *c_key = (unsigned char *)[d_key bytes];

    unsigned int  idx    = 0;

    if (c_key[idx++] != 0x30) return(nil);

    if (c_key[idx] > 0x80) idx += c_key[idx] - 0x80 + 1;

    else idx++;

    // PKCS #1 rsaEncryption szOID_RSA_RSA

    static unsigned char seqiod[] =

    { 0x30,  0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01,

    0x01, 0x05, 0x00 };

    if (memcmp(&c_key[idx], seqiod, 15)) return(nil);

    idx += 15;

    if (c_key[idx++] != 0x03) return(nil);

    if (c_key[idx] > 0x80) idx += c_key[idx] - 0x80 + 1;

    else idx++;

    if (c_key[idx++] != '\0') return(nil);

    // Now make a new NSData from this buffer

    return([NSData dataWithBytes:&c_key[idx] length:len - idx]);

    }

    + (NSData *)stripPrivateKeyHeader:(NSData *)d_key{

    // Skip ASN.1 private key header

    if (d_key == nil) return(nil);

    unsigned long len = [d_key length];

    if (!len) return(nil);

    unsigned char *c_key = (unsigned char *)[d_key bytes];

    unsigned int  idx    = 22; //magic byte at offset 22

    if (0x04 != c_key[idx++]) return nil;

    unsigned int c_len = c_key[idx++];

    int det = c_len & 0x80;

    if (!det) {

    c_len = c_len & 0x7f;

    } else {

    int byteCount = c_len & 0x7f;

    if (byteCount + idx > len) {

    //rsa length field longer than buffer

    return nil;

    }

    unsigned int accum = 0;

    unsigned char *ptr = &c_key[idx];

    idx += byteCount;

    while (byteCount) {

    accum = (accum << 8) + *ptr;

    ptr++;

    byteCount--;

    }

    c_len = accum;

    }

    // Now make a new NSData from this buffer

    return [d_key subdataWithRange:NSMakeRange(idx, c_len)];

    }

    + (SecKeyRef)addPublicKey:(NSString *)key{

    NSRange spos = [key rangeOfString:@"-----BEGIN PUBLIC KEY-----"];

    NSRange epos = [key rangeOfString:@"-----END PUBLIC KEY-----"];

    if(spos.location != NSNotFound && epos.location != NSNotFound){

    NSUInteger s = spos.location + spos.length;

    NSUInteger e = epos.location;

    NSRange range = NSMakeRange(s, e-s);

    key = [key substringWithRange:range];

    }

    key = [key stringByReplacingOccurrencesOfString:@"\r" withString:@""];

    key = [key stringByReplacingOccurrencesOfString:@"\n" withString:@""];

    key = [key stringByReplacingOccurrencesOfString:@"\t" withString:@""];

    key = [key stringByReplacingOccurrencesOfString:@" "  withString:@""];

    // This will be base64 encoded, decode it.

    NSData *data = base64_decode(key);

    data = [LHRSA stripPublicKeyHeader:data];

    if(!data){

    return nil;

    }

    //a tag to read/write keychain storage

    NSString *tag = @"RSAUtil_PubKey";

    NSData *d_tag = [NSData dataWithBytes:[tag UTF8String] length:[tag length]];

    // Delete any old lingering key with the same tag

    NSMutableDictionary *publicKey = [[NSMutableDictionary alloc] init];

    [publicKey setObject:(__bridge id) kSecClassKey forKey:(__bridge id)kSecClass];

    [publicKey setObject:(__bridge id) kSecAttrKeyTypeRSA forKey:(__bridge id)kSecAttrKeyType];

    [publicKey setObject:d_tag forKey:(__bridge id)kSecAttrApplicationTag];

    SecItemDelete((__bridge CFDictionaryRef)publicKey);

    // Add persistent version of the key to system keychain

    [publicKey setObject:data forKey:(__bridge id)kSecValueData];

    [publicKey setObject:(__bridge id) kSecAttrKeyClassPublic forKey:(__bridge id)

    kSecAttrKeyClass];

    [publicKey setObject:[NSNumber numberWithBool:YES] forKey:(__bridge id)

    kSecReturnPersistentRef];

    CFTypeRef persistKey = nil;

    OSStatus status = SecItemAdd((__bridge CFDictionaryRef)publicKey, &persistKey);

    if (persistKey != nil){

    CFRelease(persistKey);

    }

    if ((status != noErr) && (status != errSecDuplicateItem)) {

    return nil;

    }

    [publicKey removeObjectForKey:(__bridge id)kSecValueData];

    [publicKey removeObjectForKey:(__bridge id)kSecReturnPersistentRef];

    [publicKey setObject:[NSNumber numberWithBool:YES] forKey:(__bridge id)kSecReturnRef];

    [publicKey setObject:(__bridge id) kSecAttrKeyTypeRSA forKey:(__bridge id)kSecAttrKeyType];

    // Now fetch the SecKeyRef version of the key

    SecKeyRef keyRef = nil;

    status = SecItemCopyMatching((__bridge CFDictionaryRef)publicKey, (CFTypeRef *)&keyRef);

    if(status != noErr){

    return nil;

    }

    return keyRef;

    }

    + (SecKeyRef)addPrivateKey:(NSString *)key{

    NSRange spos;

    NSRange epos;

    spos = [key rangeOfString:@"-----BEGIN RSA PRIVATE KEY-----"];

    if(spos.length > 0){

    epos = [key rangeOfString:@"-----END RSA PRIVATE KEY-----"];

    }else{

    spos = [key rangeOfString:@"-----BEGIN PRIVATE KEY-----"];

    epos = [key rangeOfString:@"-----END PRIVATE KEY-----"];

    }

    if(spos.location != NSNotFound && epos.location != NSNotFound){

    NSUInteger s = spos.location + spos.length;

    NSUInteger e = epos.location;

    NSRange range = NSMakeRange(s, e-s);

    key = [key substringWithRange:range];

    }

    key = [key stringByReplacingOccurrencesOfString:@"\r" withString:@""];

    key = [key stringByReplacingOccurrencesOfString:@"\n" withString:@""];

    key = [key stringByReplacingOccurrencesOfString:@"\t" withString:@""];

    key = [key stringByReplacingOccurrencesOfString:@" "  withString:@""];

    // This will be base64 encoded, decode it.

    NSData *data = base64_decode(key);

    data = [LHRSA stripPrivateKeyHeader:data];

    if(!data){

    return nil;

    }

    //a tag to read/write keychain storage

    NSString *tag = @"RSAUtil_PrivKey";

    NSData *d_tag = [NSData dataWithBytes:[tag UTF8String] length:[tag length]];

    // Delete any old lingering key with the same tag

    NSMutableDictionary *privateKey = [[NSMutableDictionary alloc] init];

    [privateKey setObject:(__bridge id) kSecClassKey forKey:(__bridge id)kSecClass];

    [privateKey setObject:(__bridge id) kSecAttrKeyTypeRSA forKey:(__bridge id)kSecAttrKeyType];

    [privateKey setObject:d_tag forKey:(__bridge id)kSecAttrApplicationTag];

    SecItemDelete((__bridge CFDictionaryRef)privateKey);

    // Add persistent version of the key to system keychain

    [privateKey setObject:data forKey:(__bridge id)kSecValueData];

    [privateKey setObject:(__bridge id) kSecAttrKeyClassPrivate forKey:(__bridge id)

    kSecAttrKeyClass];

    [privateKey setObject:[NSNumber numberWithBool:YES] forKey:(__bridge id)

    kSecReturnPersistentRef];

    CFTypeRef persistKey = nil;

    OSStatus status = SecItemAdd((__bridge CFDictionaryRef)privateKey, &persistKey);

    if (persistKey != nil){

    CFRelease(persistKey);

    }

    if ((status != noErr) && (status != errSecDuplicateItem)) {

    return nil;

    }

    [privateKey removeObjectForKey:(__bridge id)kSecValueData];

    [privateKey removeObjectForKey:(__bridge id)kSecReturnPersistentRef];

    [privateKey setObject:[NSNumber numberWithBool:YES] forKey:(__bridge id)kSecReturnRef];

    [privateKey setObject:(__bridge id) kSecAttrKeyTypeRSA forKey:(__bridge id)kSecAttrKeyType];

    // Now fetch the SecKeyRef version of the key

    SecKeyRef keyRef = nil;

    status = SecItemCopyMatching((__bridge CFDictionaryRef)privateKey, (CFTypeRef *)&keyRef);

    if(status != noErr){

    return nil;

    }

    return keyRef;

    }

    /* START: Encryption & Decryption with RSA private key */

    + (NSData *)encryptData:(NSData *)data withKeyRef:(SecKeyRef) keyRef isSign:(BOOL)isSign {

    const uint8_t *srcbuf = (const uint8_t *)[data bytes];

    size_t srclen = (size_t)data.length;

    size_t block_size = SecKeyGetBlockSize(keyRef) * sizeof(uint8_t);

    void *outbuf = malloc(block_size);

    size_t src_block_size = block_size - 11;

    NSMutableData *ret = [[NSMutableData alloc] init];

    for(int idx=0; idx

    //NSLog(@"%d/%d block_size: %d", idx, (int)srclen, (int)block_size);

    size_t data_len = srclen - idx;

    if(data_len > src_block_size){

    data_len = src_block_size;

    }

    size_t outlen = block_size;

    OSStatus status = noErr;

    if (isSign) {

    status = SecKeyRawSign(keyRef,

    kSecPaddingPKCS1,

    srcbuf + idx,

    data_len,

    outbuf,

    &outlen

    );

    } else {

    status = SecKeyEncrypt(keyRef,

    kSecPaddingPKCS1,

    srcbuf + idx,

    data_len,

    outbuf,

    &outlen

    );

    }

    if (status != 0) {

    NSLog(@"SecKeyEncrypt fail. Error Code: %d", status);

    ret = nil;

    break;

    }else{

    [ret appendBytes:outbuf length:outlen];

    }

    }

    free(outbuf);

    CFRelease(keyRef);

    return ret;

    }

    + (NSString *)encryptString:(NSString *)str privateKey:(NSString *)privKey{

    NSData *data = [LHRSA encryptData:[str dataUsingEncoding:NSUTF8StringEncoding] privateKey:privKey];

    NSString *ret = base64_encode_data(data);

    return ret;

    }

    + (NSData *)encryptData:(NSData *)data privateKey:(NSString *)privKey{

    if(!data || !privKey){

    return nil;

    }

    SecKeyRef keyRef = [LHRSA addPrivateKey:privKey];

    if(!keyRef){

    return nil;

    }

    return [LHRSA encryptData:data withKeyRef:keyRef isSign:YES];

    }

    + (NSData *)decryptData:(NSData *)data withKeyRef:(SecKeyRef) keyRef{

    const uint8_t *srcbuf = (const uint8_t *)[data bytes];

    size_t srclen = (size_t)data.length;

    size_t block_size = SecKeyGetBlockSize(keyRef) * sizeof(uint8_t);

    UInt8 *outbuf = malloc(block_size);

    size_t src_block_size = block_size;

    NSMutableData *ret = [[NSMutableData alloc] init];

    for(int idx=0; idx

    //NSLog(@"%d/%d block_size: %d", idx, (int)srclen, (int)block_size);

    size_t data_len = srclen - idx;

    if(data_len > src_block_size){

    data_len = src_block_size;

    }

    size_t outlen = block_size;

    OSStatus status = noErr;

    status = SecKeyDecrypt(keyRef,

    kSecPaddingNone,

    srcbuf + idx,

    data_len,

    outbuf,

    &outlen

    );

    if (status != 0) {

    NSLog(@"SecKeyEncrypt fail. Error Code: %d", status);

    ret = nil;

    break;

    }else{

    //the actual decrypted data is in the middle, locate it!

    int idxFirstZero = -1;

    int idxNextZero = (int)outlen;

    for ( int i = 0; i < outlen; i++ ) {

    if ( outbuf[i] == 0 ) {

    if ( idxFirstZero < 0 ) {

    idxFirstZero = i;

    } else {

    idxNextZero = i;

    break;

    }

    }

    }

    [ret appendBytes:&outbuf[idxFirstZero+1] length:idxNextZero-idxFirstZero-1];

    }

    }

    free(outbuf);

    CFRelease(keyRef);

    return ret;

    }

    + (NSString *)decryptString:(NSString *)str privateKey:(NSString *)privKey{

    NSData *data = [[NSData alloc] initWithBase64EncodedString:str options:NSDataBase64DecodingIgnoreUnknownCharacters];

    data = [LHRSA decryptData:data privateKey:privKey];

    NSString *ret = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];

    return ret;

    }

    + (NSData *)decryptData:(NSData *)data privateKey:(NSString *)privKey{

    if(!data || !privKey){

    return nil;

    }

    SecKeyRef keyRef = [LHRSA addPrivateKey:privKey];

    if(!keyRef){

    return nil;

    }

    return [LHRSA decryptData:data withKeyRef:keyRef];

    }

    /* END: Encryption & Decryption with RSA private key */

    /* START: Encryption & Decryption with RSA public key */

    + (NSString *)encryptString:(NSString *)str publicKey:(NSString *)pubKey{

    NSData *data = [LHRSA encryptData:[str dataUsingEncoding:NSUTF8StringEncoding] publicKey:pubKey];

    NSString *ret = base64_encode_data(data);

    return ret;

    }

    + (NSData *)encryptData:(NSData *)data publicKey:(NSString *)pubKey{

    if(!data || !pubKey){

    return nil;

    }

    SecKeyRef keyRef = [LHRSA addPublicKey:pubKey];

    if(!keyRef){

    return nil;

    }

    return [LHRSA encryptData:data withKeyRef:keyRef isSign:NO];

    }

    + (NSString *)decryptString:(NSString *)str publicKey:(NSString *)pubKey{

    NSData *data = [[NSData alloc] initWithBase64EncodedString:str options:NSDataBase64DecodingIgnoreUnknownCharacters];

    data = [LHRSA decryptData:data publicKey:pubKey];

    NSString *ret = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];

    return ret;

    }

    + (NSData *)decryptData:(NSData *)data publicKey:(NSString *)pubKey{

    if(!data || !pubKey){

    return nil;

    }

    SecKeyRef keyRef = [LHRSA addPublicKey:pubKey];

    if(!keyRef){

    return nil;

    }

    return [LHRSA decryptData:data withKeyRef:keyRef];

    }

    调用

    //公钥

    NSString *publicKey = @"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCVtz/hQUNiLE1prYofqLlmYtK0OupHN7wk+ZaeYVoQqk0v+1w/MIUm20BGKNjVAo9ZBH7IDWSQ25Mhh9+niizPULk+tWqvm5wWOwEy5R/dbjNmGDFCrFXC0gYAXI4uLhcVNGNWbu3mm3BVh9LmVU+d3qr1ZxILkJ+36x/VCe/vIQIDAQAB";

    //私钥

    NSString *privateKey = @"MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAJW3P+FBQ2IsTWmtih+ouWZi0rQ66kc3vCT5lp5hWhCqTS/7XD8whSbbQEYo2NUCj1kEfsgNZJDbkyGH36eKLM9QuT61aq+bnBY7ATLlH91uM2YYMUKsVcLSBgBcji4uFxU0Y1Zu7eabcFWH0uZVT53eqvVnEguQn7frH9UJ7+8hAgMBAAECgYBrkxpRTkWOmuqczlb63I8q5EMlwVdpCMEliDkTYDwI0XVYzrG/rate+hc60krK82Xwvmwibo0eEMetRiYMChqbWrwnNwTRP0dJGRxiaVAaS7rBW79swNhzzz985cszkJ5fo7fIym6hbZjRFBz1dwtVNsCg4Ts5OCCrEoRn163m6QJBAMPKfihawOV9IKIBJ+J/jTUojuwuw/3MPLrVth27I0F0ET7MdtFG4qpmzmZtr0ZuV7ewGqRiT1Q7MfrvoHTYJ0sCQQDDwYWG8NAlv8FO56WlEuouuq4q+Pp6XOuGR6IUa4En+E+nvkYUc6Rmqy5Q/wuyiHEfAAgwE72nJHRDdHwPSGPDAkEAvGQXSBUrDqZ7w+aAzjwVT1UbUL8e7xKaTNxeQ/VRUyWvglGS8oPWjkglygE4afi6hpD40buWwWHEEcSJDGUASQJAdzuyhyS6w6NurQ7vmAJTXa8bUtVgS5O5aYrMMD/i5WObsQJ2URK2+kod5fvTNiVhMY6lbhM4G0xa/JNA1VY0XQJAJJ8pT9ienNfAxZSgF+4Q8WIq+bnz78L/FKKYRD0BOie23rgGHtBn2XCxPS46Vh3CT9FFKEfXv4r2TiFGF3yqYg==";

    //要加密的数据

    NSString *sourceStr = @"123456";

    //公钥加密

    NSString *encryptStr = [LHRSA encryptString:sourceStr publicKey:publicKey];

    //私钥解密

    NSString *decrypeStr = [LHRSA decryptString:encryptStr privateKey:privateKey];

    NSLog(@"\n加密后的数据:%@ \n 解密后的数据:%@",encryptStr,decrypeStr);

    运行结果 :

    2018-11-27 15:27:13.099152+0800 Encryption[12828:3995427]

    加密后的数据:F+I/egBsrrGlneTT4vr6b6Q9slJ5zPJBhGx85kKEsfkbkvlh1DcVOW29vaCdPQ2klwIyjVOC+FM9PoJRPa6h9RJX5h/ESEz2dD7ZAl2kEkvVr69Eg+1KYzLhAlNagHiT1bMcXRIBfO99oyrJFqLQoWlLG3jURyXwjzQ7Lwc9rmU=

    解密后的数据:123456

    4、AES 对称密钥加密

    加密代码实现:引入 #import

    + (NSData *)AES256EncryptWithKey:(NSString *)key encryptString:(NSString *)str{

    char keyPtr[kCCKeySizeAES256+1]; // room for terminator (unused)

    bzero(keyPtr, sizeof(keyPtr)); // fill with zeroes (for padding)

    // fetch key data

    [key getCString:keyPtr maxLength:sizeof(keyPtr) encoding:NSUTF8StringEncoding];

    NSUInteger dataLength = [str length];

    size_t bufferSize = dataLength + kCCBlockSizeAES128;

    void *buffer = malloc(bufferSize);

    size_t numBytesEncrypted = 0;

    CCCryptorStatus cryptStatus = CCCrypt(kCCEncrypt, kCCAlgorithmAES128, kCCOptionPKCS7Padding,

    keyPtr, kCCKeySizeAES256,

    NULL /* initialization vector (optional) */,

    [[str dataUsingEncoding:NSUTF8StringEncoding] bytes], dataLength, /* input */

    buffer, bufferSize, /* output */

    &numBytesEncrypted);

    if (cryptStatus == kCCSuccess) {

    //the returned NSData takes ownership of the buffer and will free it on deallocation

    return [NSData dataWithBytesNoCopy:buffer length:numBytesEncrypted];

    }

    free(buffer); //free the buffer;

    return nil;

    }

    + (NSData *)AES256DecryptWithKey:(NSString *)key DecryptString:(NSData *)str{

    // 'key' should be 32 bytes for AES256, will be null-padded otherwise

    char keyPtr[kCCKeySizeAES256+1]; // room for terminator (unused)

    bzero(keyPtr, sizeof(keyPtr)); // fill with zeroes (for padding)

    // fetch key data

    [key getCString:keyPtr maxLength:sizeof(keyPtr) encoding:NSUTF8StringEncoding];

    NSUInteger dataLength = [str length];

    size_t bufferSize = dataLength + kCCBlockSizeAES128;

    void *buffer = malloc(bufferSize);

    size_t numBytesDecrypted = 0;

    CCCryptorStatus cryptStatus = CCCrypt(kCCDecrypt, kCCAlgorithmAES128, kCCOptionPKCS7Padding,

    keyPtr, kCCKeySizeAES256,

    NULL /* initialization vector (optional) */,

    [str bytes], dataLength, /* input */

    buffer, bufferSize, /* output */

    &numBytesDecrypted);

    if (cryptStatus == kCCSuccess) {

    //the returned NSData takes ownership of the buffer and will free it on deallocation

    return [NSData dataWithBytesNoCopy:buffer length:numBytesDecrypted];

    }

    free(buffer); //free the buffer;

    return nil;

    }

    调用代码

    //用来密钥

    NSString * key = @"123456";

    //用来发送的原始数据

    NSString * secret = @"654321";

    //用密钥加密

    NSData * result = [LHAES AES256EncryptWithKey:key encryptString:secret];

    //输出测试

    NSLog(@"AES加密 :%@",result);

    //解密方法

    NSData * data = [LHAES AES256DecryptWithKey:key DecryptString:result];

    NSLog(@"AES解密 :%@", [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]);

    运行结果

    2018-11-27 15:27:13.100121+0800 Encryption[12828:3995427] AES加密

    :<93d4cdab 759376b4 51565e57 85f684f6> 2018-11-27 15:27:13.100257+0800

    Encryption[12828:3995427] AES解密 :654321

    5、DES 加密 :先将内容加密一下,然后转十六进制,传过去 ;DES解密 :把收到的数据转二进制,decode一下,然后再解密,得到原本的数据

    代码实现 :引入 #import

    //加密

    + (NSString *) encryptUseDES2:(NSString *)content key:(NSString *)key{

    NSString *ciphertext = nil;

    const char *textBytes = [content UTF8String];

    size_t dataLength = [content length];

    uint8_t *bufferPtr = NULL;

    size_t bufferPtrSize = 0;

    size_t movedBytes = 0;

    bufferPtrSize = (dataLength + kCCBlockSizeDES) & ~(kCCBlockSizeDES - 1);

    bufferPtr = malloc( bufferPtrSize * sizeof(uint8_t));

    memset((void *)bufferPtr, 0x0, bufferPtrSize);

    CCCryptorStatus cryptStatus = CCCrypt(kCCEncrypt, kCCAlgorithm3DES,

    kCCOptionPKCS7Padding|kCCOptionECBMode,

    [key UTF8String], kCCKeySize3DES,

    NULL,

    textBytes, dataLength,

    (void *)bufferPtr, bufferPtrSize,

    &movedBytes);

    if (cryptStatus == kCCSuccess) {

    ciphertext= [self parseByte2HexString:bufferPtr :(int)movedBytes];

    }

    ciphertext=[ciphertext uppercaseString];//字符变大写

    return ciphertext ;

    }

    //加密用到的二进制转化十六进制方法:

    + (NSString *) parseByte2HexString:(Byte *) bytes  :(int)len{

    NSString *hexStr = @"";

    if(bytes)

    {

    for(int i=0;i

    {

    NSString *newHexStr = [NSString stringWithFormat:@"%x",bytes[i]&0xff]; ///16进制数

    if([newHexStr length] == 1)

    hexStr = [NSString stringWithFormat:@"%@0%@",hexStr,newHexStr];

    else

    {

    hexStr = [NSString stringWithFormat:@"%@%@",hexStr,newHexStr];

    }

    }

    }

    return hexStr;

    }

    //解密

    + (NSString *)decryptUseDES:(NSString *)content key:(NSString *)key

    {

    NSData* cipherData = [self convertHexStrToData:[content lowercaseString]];

    unsigned char buffer[1024];

    memset(buffer, 0, sizeof(char));

    size_t numBytesDecrypted = 0;

    CCCryptorStatus cryptStatus = CCCrypt(kCCDecrypt,

    kCCAlgorithm3DES,

    kCCOptionPKCS7Padding|kCCOptionECBMode,

    [key UTF8String],

    kCCKeySize3DES,

    NULL,

    [cipherData bytes],

    [cipherData length],

    buffer,

    1024,

    &numBytesDecrypted);

    NSString* plainText = nil;

    if (cryptStatus == kCCSuccess) {

    NSData* data = [NSData dataWithBytes:buffer length:(NSUInteger)numBytesDecrypted];

    plainText = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];

    }

    return plainText;

    }

    //解密过程用到的十六进制转换二进制:

    + (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];

    [hexData appendData:entity];

    range.location += range.length;

    range.length = 2;

    }

    return hexData;

    }

    调用代码

    //用来密钥

    NSString * keyDES = @"123456";

    //用来发送的原始数据

    NSString * secretDES = @"654321";

    NSString * resultDES = [LHDES encryptUseDES2:secretDES key:keyDES];

    NSLog(@"DES加密 :%@",resultDES);

    NSString * decryptResult = [LHDES decryptUseDES:resultDES key:keyDES];

    NSLog(@"DES解密 :%@",decryptResult);

    运行结果

    2018-11-27 15:27:13.100455+0800 Encryption[12828:3995427] DES加密

    :CC1A2A7516D45169 2018-11-27 15:27:13.100643+0800

    Encryption[12828:3995427] DES解密 :654321

    展开全文
  • 几种常用加密算法比较

    万次阅读 多人点赞 2013-06-20 11:02:13
    由于计算机软件的非法复制,通信的泄密、数据安全...现在我们就几种常用的加密算法给大家比较一下。 DES加密算法 DES加密算法是一种分组密码,以64位为分组对数据加密,它的密钥长度是56位,加密解密用同一算法。
  • 几种常见加密算法的比较

    千次阅读 2018-02-02 17:27:33
    1.DES加密算法 DES加密算法是一分组密码,以64位为分组对数据加密,它的密钥长度是56位,加密解密用同一算法。DES加密算法是对密钥进行保密,而公开算法,包括加密和解密算法。这样,只有掌握了和发送方相同...
  • 浅谈“脆弱的SSL加密算法

    千次阅读 2020-07-06 11:24:31
    弱加密算法、脆弱的加密算法、脆弱的SSL加密算法、openssl的FREAK Attack漏洞 描述: 脆弱的SSL加密算法,是一常见的漏洞,且至今仍大量软件支持低强度的加密协议,包括部分版本的openssl。其实,该低强度...
  • 几种常见加密算法

    2018-03-16 15:07:10
    由于计算机软件的非法复制,通信的泄密、...现在我们就几种常用的加密算法给大家比较一下。DES加密算法DES加密算法是一种分组密码,以64位为分组对数据加密,它的密钥长度是56位,加密解密用同一算法。DES加密算法是...
  • 各种加密算法总结

    千次阅读 2020-10-16 11:15:15
    常见的散列算法有MD5、SHA、HMAC、RIPE-MD、HAVAL、N-Hash、Tiger等。 1. MD5算法 MD5消息摘要算法(Message Digest Algorithm 5)。 对MD5算法简要的叙述可以为:MD5以512位分组来处理输入的信息,且每一分组又被...
  • 等,但是还是傻傻的分不清这几种加密算法分别属于什么类型的加密,以及加密的逻辑。现在放在一起研究了下,于是整理出这篇文章来。 一、散列算法(Hash算法---单向加密算法) 1. 简介 散列是信息的提炼,通常其...
  • 分享Java常用几种加密算法(四种)

    千次阅读 2017-05-09 17:02:28
    本文给大家分享java常用的几种加密算法,需要的朋友可以参考下 对称加密算法是应用较早的加密算法,技术成熟。在对称加密算法中,数据发信方将明文(原始数据)和加密密钥(mi yue)一起经过特殊加密算法处理后,...
  • 而且,对于Web应用程序,使用加密算法保护敏感数据已经变成一个很关键的部分,但是,的Web应用程序经常存在一些不正确的做法,例如:使用一些设计不好的加密算法,使用不合适的加密算法或者不正确地使用一些很强的...
  • Java常用加密算法

    千次阅读 2020-03-23 10:42:26
    可以对数据编码和解码,是可逆的,安全度较低,不过,也可以作为最基础最简单的加密算法用于加密要求较的情况。 Base64可以使用JDk中自带的类实现,还可以使用Bouncy Castle(简称bc)或Commons Codec(简称cc)...
  • 加密算法优缺点及适用场景整理

    千次阅读 2021-01-26 09:46:48
    加密算法优缺点及适用场景整理 对称加密算法(DES和AES) ...DES 现在已经不被视为一安全的加密算法,主要原因是它使用的56位密钥过短。为了提供实用所需的安全性,可以使用 DES 的派生算法 3DES 来进行
  • 加密算法与随机数

    千次阅读 2020-04-30 18:04:12
    常见的加密算法分为分组加密算法和流加密算法,两者的实现原理不同。 1)分组加密算法基于分组(block)进行操作,根据算法的不同,每个分组的长度可能不同。分组加密算法的代表DES 3-DES Blowfish IDEA AES...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,640
精华内容 7,056
关键字:

弱加密算法有哪几种