精华内容
下载资源
问答
  • 废话不多说,开始今天的题目:问:Python中列表常见的方法有哪些?答:Python列表定义:按特定顺序排列的元素组成。在Python中,用方括号[]来表示列表,并用逗号来分隔其中的元素。Python列表是编程中很常见的数据...

    小猿会从最基础的面试题开始,每天一题。如果参考答案不够好,或者有错误的话,麻烦大家可以在留言区给出自己的意见和讨论,大家是要一起学习的 。

    废话不多说,开始今天的题目:

    问:Python中列表常见的方法有哪些?

    答:Python列表定义:按特定顺序排列的元素组成。在Python中,用方括号[]来表示列表,并用逗号来分隔其中的元素。Python列表是编程中很常见的数据类型 。

    列表是一种可修改的集合类型,其元素可以是数字、string等基本类型,也可以是列表、元组、字典等集合对象,甚至可以是自定义的类型。其定义方式如下:>>> nums = [1,2,3,4]>>> type(nums)>>> print nums[1, 2, 3, 4]>>> strs = ["hello","world"]>>> print strs['hello', 'world']>>> lst = [1,"hello",False,nums,strs]>>> type(lst)>>> print lst[1, 'hello', False, [1, 2, 3, 4], ['hello', 'world']]

    下面我们来看一下列表中有哪些常见的方法:count():统计某个元素在列表中出现的次数。index():从列表中找出某个值第一个匹配项的索引位置。append():在列表末尾添加新对象。extend():在列表末尾一次性追加另一个序列的多个值。insert():在列表的指定位置插入对象。pop():移除列表中的一个元素(默认最后一个元素),并且返回该元素的值。remove():移除列表中某个值的第一个匹配项。reverse():将列表中的元素反向,不重新拷贝一个列表。reversed():将列表中的元素反向,重新拷贝一个列表。sort():将列表中的元素排序,不重新拷贝一个列表。sortd():将列表中的元素排序,重新拷贝一个列表。copy():浅拷贝,只是给原来的列表贴上了一个新标签,对于一个复杂对象的子对象并不会完全复制,如果有子列表,改变原来的值,新的拷贝对象也会改变。deepcopy():深拷贝,将复杂对象的每一层复制一个单独的个体出来。就是完全拷贝。常见内置函数:max()、min()、sum()、len()、all()、any()、zip()、enumerate()由于文章篇幅有限,具体的代码,推荐大家看这篇文章:https://www.jianshu.com/p/da6e449f4c6a

    如果对于参考答案有不认同的,大家可以在评论区指出和补充,欢迎留言!

    更多题目:

    关注小猿公众号,每天学习一道题

    展开全文
  • 常见的几种加密方法和实常见的几种加密方法 :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

    展开全文
  • 几种模式分析: 直接使用Object创建会创建多个相似对象代码冗余问题 工厂模式: 解决上述问题,但产生对象无法知道是从。 构造函数模式: 解决工厂模式问题,但是对象的方法每次都重新创建。 原型...

    几种模式分析:
    直接使用Object创建会有创建多个相似对象代码冗余问题
    工厂模式:
    解决上述问题,但产生的对象无法知道是从哪来的。
    构造函数模式:
    解决工厂模式的问题,但是对象的方法每次都重新创建。
    原型函数模式:
    修改原型对象的属性,所有的实例对象都受到影响。
    构造函数和原型函数组合使用:
    最常见的使用方式。
    es6 Class:推荐,详见阮一峰es6

    1.this的用法,详见阮一峰this

    2.构造函数的new都做了什么:

    创建对象,this指向创建的对象,执行代码,创建的对象返回回来。

    3.构造函数和工厂函数的区别:

    没有显示的创建对象也就是 var o=new Object();//工厂函数里有
    将所有属性方法赋值给this
    没有显示的return语句
    构造函数的首字母大写

    4.constructor

    对象的属性,是一个指针,指向当前对象的构造函数。

    5.每个函数都有prototype属性。

    Person.prototype.constructor = Person;

    6.原型对象:图片见《高程》148页

    Person是构造函数、person1是实例对象、Person.prototype是Person的原型对象。
    Person.prototype有一个constructor会指向Person。
    person1有一个[[Prototype]]指向Person.prototype,但是[[Prototype]]无法直接访问到,可以通过Person.prototype.isPrototypeOf(person1); //true
    对应的es5的方法 Object.getPrototypeOf(person1) = =Person.prototype; //true

    person1.hasOwnProperty(‘name’) //实例对象有返回true,原型有返回false

    展开全文
  • 实现线程有哪几种方法 java5开始还有一些常见线程池的方法 为什么反对用stop 和 suspend()呢 extends Thread impliments Runnable 修饰同步的方法是Sychronized关键字 stop()可以解开线程获得所有锁,...

    实现线程有哪几种方法 java5开始还有一些常见线程池的方法 为什么反对用stop 和 suspend()呢

    extends Thread  impliments Runnable

    修饰同步的方法是Sychronized关键字

    stop()可以解开线程获得的所有的锁,如果一个对象在不连贯的状态下,其他线程可以修改和检查它的

    suspend()延迟 容易造成死锁,在使用suspend线程会停止 但是 还是会持有原来的锁,除非线程挂起,任何线程如果想获取一个锁定的资源,同时又想恢复自己的目标线程

    就会造成死锁。

    sleep 和 wait的方法的区别

    sleep 是Thread 类的方法,你调用了他,对象不会放弃对象锁,暂停你指定的时间只是让出了cpu

    然后恢复,

    wait是Object的方法,调用它会放弃对象锁,然后他进入等待此对象的锁的锁定迟池

     只有对此对象的发出notify方法,此对象才能准备获取对象锁进入运行状态,而且

    wait是已经进入了一个同步锁的线程内了 然后只有等到其他线程调用notify方法 调用wait线程才能进入去抢夺对象锁,不一定可以马上获取到对象锁,因为锁还在其他线程的手上,还没释放,

     

     

     

    展开全文
  • BOS常见问题FAQ

    2019-04-11 15:48:13
    二、流程转储有哪几种方式 三、消息转储有哪几种方式 四、消息发送如何带附件 第四部分 GUI主框架 一、客户化菜单有那几种升级维护方式 二、用户授权权起到什么作用及如何授权 基础系统篇 第一部分 组织架构 ...
  • 107.spring boot 配置文件有哪几种类型?它们有什么区别? 108.spring boot 有哪些方式可以实现热部署? 109.jpa 和 hibernate 有什么区别? 110.什么是 spring cloud? 111.spring cloud 断路器作用是什么? 112....
  • 声卡常见故障分析

    2013-03-12 12:20:00
    下面就让我们一起来看看声卡最常见的几种故障分析,了解这些后,对于这种现象我们也能坦然处之了。 常见故障一:声卡无声。 出现这种故障常见的原因: 1.驱动程序默认输出为“静音”。单击屏幕右下角的声音小...
  • 13.5 存储时间最好方法? 第14章 系统调用 14.1 怎样检查环境变量(environment variables)值? 14.2 怎样在程序中调用DOS函数? 14.3 怎样在程序中调用BIOS函数? 14.4 怎样在程序中存取重要...
  • 引用类型和原始类型具有不同特征和用法,它们包括:大小和速度问题,这种类型以哪种类型数据结构存储,当引用类型和原始类型用作某个类实例数据时所指定缺省值。对象引用实例变量缺省值为 null,而原始...
  • o 3.17 什么容易显示枚举值符号的方法? * 4. 表达式 o 4.1 为什么这样代码: a[i] = i++; 不能工作? o 4.2 使用我编译器,下面代码 int i=7; printf("%d\n", i++ * i++); 返回 49?不管按什么顺序...
  • 36、排序都有哪几种方法?请举例 冒泡 选择 快序 二分查找 网上答案: 排序的方法有:插入排序(直接插入排序、希尔排序), 交换排序(冒泡排序、快速排序), 选择排序(直接选择排序、堆排序), 归并...
  • 18、在ajax中data主要有哪几种? 28 19、jQuery中ajax由几部分组成? 28 20、js和jQuery获取value值得区别 29 四、jsp/servlet部分 29 1、Tomcat优化经验 29 2、Tomcat根目录下有哪些文件 31 3、什么是TOMCAT,怎样...
  • JAVA面试题最全集

    2010-03-13 13:09:10
    76.EJB有哪几种?区别是什么? 77.JavaBean与EJB有什么区别? 78.软件开发生命周期有哪几个阶段? 79.软件开发有哪些因素? 80.软件开发中如何进行版本控制? 81.UML中,类视图如何表示类中继承与聚合? 82.客户端...
  • 4.4.6 你知道哪几种垃圾收集器,各自优缺点,重点讲下cms和G1,包括原理,流程,优缺点。 4.4.7 垃圾回收算法实现原理。 4.4.8 当出现了内存溢出,你怎么排错。 4.4.9 JVM内存模型相关知识了解多少,比如重...
  • java面试题

    2018-01-01 15:35:15
    58. 排序都有哪几种方法?请列举。用JAVA实现一个快速排序。 40 59. 请对以下在J2EE中常用名词进行解释(或简单描述) 40 59.1. web 容器 40 59.2. EJB容器 40 59.3. JNDI 40 59.4. JMS 41 59.5. JTA 41 59.6. JAF ...
  • java 面试题 总结

    2009-09-16 08:45:34
    引用类型和原始类型具有不同特征和用法,它们包括:大小和速度问题,这种类型以哪种类型数据结构存储,当引用类型和原始类型用作某个类实例数据时所指定缺省值。对象引用实例变量缺省值为 null,而原始...
  • 先了解了解底下这几种: <pre><code>javascript // 为了方便,我把注释写在json中了。。 [{ "url": , // issue url "id": , // issue id , 是一个随机生成不重复数字串...
  • 答:主要软件开发方法有:结构化开发方法、Jackson(JSP、JSD)方法、原型化开发方 法、维也纳开发方法(VDM)和面向对象开发方法。 6. 软件生命期各阶段任务是什么? 答:软件生命期瀑布模型分为六个阶段: ...
  • 软件工程教程

    热门讨论 2012-07-06 23:10:29
    顺序图、协作图:单用例中个对象行为 顺序图突出顺序,协作图着重对象间链接关系 项目三 项目市场调研 任务1. 系统研发背景 任务2. 软件开发计划 油画创作背景 波洛克 《1948年第五号》 1.4亿$,最昂贵画作...

空空如也

空空如也

1 2 3 4 5
收藏数 99
精华内容 39
关键字:

常见的修改方法有哪几种