//

//  MYDigest.m

//  MYCrypto

//

//  Created by Jens Alfke on 1/4/08.

//  Copyright 2008 Jens Alfke. All rights reserved.

//

#import "MYDigest.h"

#import <CommonCrypto/CommonDigest.h>

#import "MYCrypto_Private.h"

#if MYCRYPTO_USE_IPHONE_API

enum {

    CSSM_ALGID_SHA1 = 8,

    CSSM_ALGID_SHA256 = 0x80000000 + 14

};

#endif

@implementation MYDigest

+ (uint32_t) algorithm {

    AssertAbstractMethod();

}

+ (size_t) length {

    AssertAbstractMethod();

}

+ (void) computeDigest: (void*)dstDigest ofBytes: (const void*)bytes length: (size_t)length {

    AssertAbstractMethod();

}

- (id) initWithRawDigest: (const void*)rawDigest length: (size_t)length {

    Assert([self class] != [MYDigest class], @"MYDigest is an abstract class");

    Assert(rawDigest!=NULL);

    AssertEq(length,[[self class] length]);

    self = [super init];

    if (self) {

        _rawDigest = malloc(length);

        Assert(_rawDigest);

        memcpy(_rawDigest,rawDigest,length);

    }

    return self;

}

- (void) dealloc

{

    if(_rawDigest) free(_rawDigest);

    [super dealloc];

}

- (void) finalize

{

    if(_rawDigest) free(_rawDigest);

    [super finalize];

}

- (id) copyWithZone: (NSZone*)zone

{

    return [self retain];

}

- (id)initWithCoder:(NSCoder *)decoder

{

    NSUInteger length;

    const void *bytes = [decoder decodeBytesForKey: @"digest" returnedLength: &length];

    return [self initWithRawDigest: bytes length: length];

}

- (void)encodeWithCoder:(NSCoder *)coder

{

    [coder encodeBytes: self.bytes length: self.length forKey: @"digest"];

}

+ (MYDigest*) digestFromDigestData: (NSData*)digestData {

    return [[[self alloc] initWithRawDigest: digestData.bytes length: digestData.length] autorelease];

}

+ (MYDigest*) digestFromHexString: (NSString*)hexString

{

    const char *cStr = [hexString UTF8String];

    const size_t length = [self length];

    if( !cStr || strlen(cStr)!=2*length )

        return nil;

    uint8_t digest[length];

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

        if( sscanf(cStr, "%2hhx", &digest[i]) != 1 )

            return nil;

        cStr += 2;

    }

    return [[[self alloc] initWithRawDigest: &digest length: length] autorelease];

}

+ (MYDigest*) digestOfData: (NSData*)data {

    return [self digestOfBytes: data.bytes length: data.length];

}

+ (MYDigest*) digestOfBytes: (const void*)bytes length: (size_t)length {

    const size_t digestLength = [self length];

    uint8_t digest[digestLength];

    [self computeDigest: digest ofBytes: bytes length: length];

    return [[[self alloc] initWithRawDigest: &digest length: digestLength] autorelease];

}

- (uint32_t) algorithm {

    return [[self class] algorithm];

}

- (size_t) length {

    return [[self class] length];

}

- (const void*) bytes {

    return _rawDigest;

}

- (BOOL) isEqual: (id)digest

{

    return [digest isKindOfClass: [MYDigest class]]

        && [digest algorithm] == self.algorithm

        && memcmp(self.bytes, [digest bytes], self.length)==0;

}

- (NSUInteger) hash

{

    return *(NSUInteger*)self.bytes;

    //? This makes the hashcode endian-dependent. Does that matter?

}

- (NSComparisonResult) compare: (MYDigest*)other

{

    size_t size=self.length, otherSize=other.length;

    NSComparisonResult cmp = memcmp(self.bytes, other.bytes, MIN(size,otherSize));

    return cmp ? cmp : ((int)size - (int)otherSize);

}

- (NSData*) asData

{

    return [NSData dataWithBytes: self.bytes length: self.length];

}

- (NSString*) description

{

    return [NSString stringWithFormat: @"%@[%@]", [self class], [self abbreviatedHexString]];

}

- (NSString*) hexString

{

    const uint8_t *bytes = self.bytes;

    size_t length = self.length;

    char out[2*length+1];

    char *dst = &out[0];

    for( int i=0; i<length; i+=1 )

        dst += sprintf(dst,"%02X", bytes[i]);

    return [[[NSString alloc] initWithBytes: out length: 2*length encoding: NSASCIIStringEncoding]

            autorelease];

}

- (NSString*) abbreviatedHexString

{

    const uint8_t *bytes = self.bytes;

    return [NSString stringWithFormat: @"%02hhX%02hhX%02hhX%02hhX...",

            bytes[0],bytes[1],bytes[2],bytes[3]];

}

@end

@implementation MYSHA1Digest

+ (void) computeDigest: (void*)dstDigest ofBytes: (const void*)bytes length: (size_t)length {

    NSParameterAssert(bytes!=NULL);

    NSParameterAssert(length>0);

    CC_SHA1(bytes,length, dstDigest);

}

+ (uint32_t) algorithm            {return CSSM_ALGID_SHA1;}

+ (size_t) length               {return sizeof(RawSHA1Digest);}

- (MYSHA1Digest*) initWithRawSHA1Digest: (const RawSHA1Digest*)rawDigest {

    return [super initWithRawDigest: rawDigest length: sizeof(*rawDigest)];

}

+ (MYSHA1Digest*) digestFromRawSHA1Digest: (const RawSHA1Digest*)rawDigest {

    return [[[self alloc] initWithRawSHA1Digest: rawDigest] autorelease];

}

- (const RawSHA1Digest*) rawSHA1Digest {

    return self.bytes;

}

@end

@implementation MYSHA256Digest

+ (void) computeDigest: (void*)dstDigest ofBytes: (const void*)bytes length: (size_t)length {

    NSParameterAssert(bytes!=NULL);

    NSParameterAssert(length>0);

    CC_SHA256(bytes,length, dstDigest);

}

+ (uint32_t) algorithm            {return CSSM_ALGID_SHA256;}

+ (size_t) length               {return sizeof(RawSHA256Digest);}

- (MYSHA256Digest*) initWithRawSHA256Digest: (const RawSHA256Digest*)rawDigest {

    return [super initWithRawDigest: rawDigest length: sizeof(*rawDigest)];

}

+ (MYSHA256Digest*) digestFromRawSHA256Digest: (const RawSHA256Digest*)rawDigest {

    return [[[self alloc] initWithRawSHA256Digest: rawDigest] autorelease];

}

- (const RawSHA256Digest*) rawSHA256Digest {

    return self.bytes;

}

@end

@implementation NSData (MYDigest)

- (MYSHA1Digest*) my_SHA1Digest

{

    return (MYSHA1Digest*) [MYSHA1Digest digestOfData: self];

}

- (MYSHA256Digest*) my_SHA256Digest

{

    return (MYSHA256Digest*) [MYSHA256Digest digestOfData: self];

}

@end

#import "Test.h"

static void testDigestOf( NSData *src, NSString *expectedSHA1Hex, NSString *expectedSHA256Hex )

{

    MYSHA1Digest *d1 = [src my_SHA1Digest];

    NSString *hex = d1.hexString;

    Log(@"Digesting %u bytes to %@",src.length,hex);

    if( expectedSHA1Hex )

        CAssertEqual(hex,expectedSHA1Hex);

    MYSHA1Digest *d2 = (MYSHA1Digest*) [MYSHA1Digest digestFromHexString: hex];

    CAssertEqual(d1,d2);

    CAssertEqual(d2.hexString,hex);

    MYSHA256Digest *d256 = [src my_SHA256Digest];

    hex = d256.hexString;

    Log(@"Digesting %u bytes to %@",src.length,hex);

    if( expectedSHA256Hex )

        CAssertEqual(hex,expectedSHA256Hex);

    MYSHA256Digest *d256_2 = (MYSHA256Digest*) [MYSHA256Digest digestFromHexString: hex];

    CAssertEqual(d256,d256_2);

    CAssertEqual(d256_2.hexString,hex);

}

TestCase(MYDigest) {

    testDigestOf([@"Pack my box with five dozen liquor jugs, you ugly potatoe pie!" 

                          dataUsingEncoding: NSUTF8StringEncoding],

                 @"4F254781ED6C0103BE056DD8418EFBAC0C2EBE3C",

                 @"08AA4BCDDF7654D7AB5CDD25395A4DD8F3BEB5C79FE567D10C1A21B9134F48FD");

    testDigestOf([NSData dataWithContentsOfFile: @"/Library/Desktop Pictures/Nature/Zen Garden.jpg"],

                 @"62A17839B3B86D3543EB2E34D2718A0FE044FA31",

                 @"FBD25FA6CEE794049973DE3BDF752345617FCA81018C8FC65350BCDD901142DB");

}