Modified src/Makefile
from [1b174a549a]
to [1e045757f6].
︙ | | | ︙ | |
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
OFBlock.m \
OFCharacterSet.m \
OFColor.m \
OFConstantString.m \
OFCountedSet.m \
OFData.m \
OFData+ASN1DERParsing.m \
OFData+CryptoHashing.m \
OFData+MessagePackParsing.m \
OFDate.m \
OFDictionary.m \
OFEnumerator.m \
OFFileManager.m \
OFGZIPStream.m \
OFHMAC.m \
|
|
|
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
OFBlock.m \
OFCharacterSet.m \
OFColor.m \
OFConstantString.m \
OFCountedSet.m \
OFData.m \
OFData+ASN1DERParsing.m \
OFData+CryptographicHashing.m \
OFData+MessagePackParsing.m \
OFDate.m \
OFDictionary.m \
OFEnumerator.m \
OFFileManager.m \
OFGZIPStream.m \
OFHMAC.m \
|
︙ | | | ︙ | |
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
|
OFSHA384Hash.m \
OFSHA384Or512Hash.m \
OFSHA512Hash.m \
OFSortedList.m \
OFStdIOStream.m \
OFStream.m \
OFString.m \
OFString+CryptoHashing.m \
OFString+JSONParsing.m \
OFString+PropertyListParsing.m \
OFString+Serialization.m \
OFString+URLEncoding.m \
OFString+XMLEscaping.m \
OFString+XMLUnescaping.m \
${OF_SUBUPROCESS_M} \
|
|
|
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
|
OFSHA384Hash.m \
OFSHA384Or512Hash.m \
OFSHA512Hash.m \
OFSortedList.m \
OFStdIOStream.m \
OFStream.m \
OFString.m \
OFString+CryptographicHashing.m \
OFString+JSONParsing.m \
OFString+PropertyListParsing.m \
OFString+Serialization.m \
OFString+URLEncoding.m \
OFString+XMLEscaping.m \
OFString+XMLUnescaping.m \
${OF_SUBUPROCESS_M} \
|
︙ | | | ︙ | |
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
atomic_osatomic.h \
atomic_powerpc.h \
atomic_sync_builtins.h \
atomic_x86.h
INCLUDES := ${SRCS:.m=.h} \
OFASN1DERRepresentation.h \
OFCollection.h \
OFCryptoHash.h \
OFJSONRepresentation.h \
OFKernelEventObserver.h \
OFKeyValueCoding.h \
OFLocking.h \
OFMessagePackRepresentation.h \
OFSerialization.h \
OFTLSSocket.h \
|
|
|
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
atomic_osatomic.h \
atomic_powerpc.h \
atomic_sync_builtins.h \
atomic_x86.h
INCLUDES := ${SRCS:.m=.h} \
OFASN1DERRepresentation.h \
OFCollection.h \
OFCryptographicHash.h \
OFJSONRepresentation.h \
OFKernelEventObserver.h \
OFKeyValueCoding.h \
OFLocking.h \
OFMessagePackRepresentation.h \
OFSerialization.h \
OFTLSSocket.h \
|
︙ | | | ︙ | |
Renamed and modified
src/OFCryptoHash.h
[eb798114fa]
to src/OFCryptographicHash.h
[3e39e62dc1].
︙ | | | ︙ | |
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
*/
#import "OFObject.h"
OF_ASSUME_NONNULL_BEGIN
/**
* @protocol OFCryptoHash OFCryptoHash.h ObjFW/OFCryptoHash.h
*
* @brief A protocol for classes providing cryptographic hash functions.
*
* A cryptographic hash implementing this protocol can be copied. The entire
* state is copied, allowing to calculate a new hash from there. This is
* especially useful for generating many hashes with a common prefix.
*/
@protocol OFCryptoHash <OFObject, OFCopying>
#ifdef OF_HAVE_CLASS_PROPERTIES
@property (class, readonly, nonatomic) size_t digestSize;
@property (class, readonly, nonatomic) size_t blockSize;
#endif
/**
* @brief The digest size of the cryptographic hash, in bytes.
|
|
>
|
|
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
*/
#import "OFObject.h"
OF_ASSUME_NONNULL_BEGIN
/**
* @protocol OFCryptographicHash \
* OFCryptographicHash.h ObjFW/OFCryptographicHash.h
*
* @brief A protocol for classes providing cryptographic hash functions.
*
* A cryptographic hash implementing this protocol can be copied. The entire
* state is copied, allowing to calculate a new hash from there. This is
* especially useful for generating many hashes with a common prefix.
*/
@protocol OFCryptographicHash <OFObject, OFCopying>
#ifdef OF_HAVE_CLASS_PROPERTIES
@property (class, readonly, nonatomic) size_t digestSize;
@property (class, readonly, nonatomic) size_t blockSize;
#endif
/**
* @brief The digest size of the cryptographic hash, in bytes.
|
︙ | | | ︙ | |
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
|
OF_RETURNS_INNER_POINTER;
/**
* @brief Creates a new cryptographic hash.
*
* @return A new autoreleased cryptographic hash
*/
+ (instancetype)cryptoHashWithAllowsSwappableMemory:
(bool)allowsSwappableMemory;
/**
* @brief Returns the digest size of the cryptographic hash, in bytes.
*
* @return The digest size of the cryptographic hash, in bytes
*/
+ (size_t)digestSize;
|
<
|
|
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
|
OF_RETURNS_INNER_POINTER;
/**
* @brief Creates a new cryptographic hash.
*
* @return A new autoreleased cryptographic hash
*/
+ (instancetype)hashWithAllowsSwappableMemory: (bool)allowsSwappableMemory;
/**
* @brief Returns the digest size of the cryptographic hash, in bytes.
*
* @return The digest size of the cryptographic hash, in bytes
*/
+ (size_t)digestSize;
|
︙ | | | ︙ | |
Renamed and modified
src/OFData+CryptoHashing.h
[eadea66cdb]
to src/OFData+CryptographicHashing.h
[c987e02085].
︙ | | | ︙ | |
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
OF_ASSUME_NONNULL_BEGIN
@class OFString;
#ifdef __cplusplus
extern "C" {
#endif
extern int _OFData_CryptoHashing_reference;
#ifdef __cplusplus
}
#endif
@interface OFData (CryptoHashing)
/**
* @brief The MD5 hash of the data as a string.
*/
@property (readonly, nonatomic) OFString *stringByMD5Hashing;
/**
* @brief The RIPEMD-160 hash of the data as a string.
|
|
|
|
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
OF_ASSUME_NONNULL_BEGIN
@class OFString;
#ifdef __cplusplus
extern "C" {
#endif
extern int _OFData_CryptographicHashing_reference;
#ifdef __cplusplus
}
#endif
@interface OFData (CryptographicHashing)
/**
* @brief The MD5 hash of the data as a string.
*/
@property (readonly, nonatomic) OFString *stringByMD5Hashing;
/**
* @brief The RIPEMD-160 hash of the data as a string.
|
︙ | | | ︙ | |
Renamed and modified
src/OFData+CryptoHashing.m
[9f6c94ab4a]
to src/OFData+CryptographicHashing.m
[6d7c26a863].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFData+CryptoHashing.h"
#import "OFString.h"
#import "OFCryptoHash.h"
#import "OFMD5Hash.h"
#import "OFRIPEMD160Hash.h"
#import "OFSHA1Hash.h"
#import "OFSHA224Hash.h"
#import "OFSHA256Hash.h"
#import "OFSHA384Hash.h"
#import "OFSHA512Hash.h"
int _OFData_CryptoHashing_reference;
@implementation OFData (CryptoHashing)
- (OFString *)of_cryptoHashWithClass: (Class <OFCryptoHash>)class OF_DIRECT
{
void *pool = objc_autoreleasePoolPush();
id <OFCryptoHash> hash =
[class cryptoHashWithAllowsSwappableMemory: true];
size_t digestSize = [class digestSize];
const unsigned char *digest;
char cString[digestSize * 2];
[hash updateWithBuffer: _items length: _count * _itemSize];
digest = hash.digest;
for (size_t i = 0; i < digestSize; i++) {
uint8_t high, low;
high = digest[i] >> 4;
low = digest[i] & 0x0F;
|
|
|
|
|
>
|
|
|
|
>
|
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFData+CryptographicHashing.h"
#import "OFString.h"
#import "OFCryptographicHash.h"
#import "OFMD5Hash.h"
#import "OFRIPEMD160Hash.h"
#import "OFSHA1Hash.h"
#import "OFSHA224Hash.h"
#import "OFSHA256Hash.h"
#import "OFSHA384Hash.h"
#import "OFSHA512Hash.h"
int _OFData_CryptographicHashing_reference;
@implementation OFData (CryptographicHashing)
static OFString *
stringByHashing(Class <OFCryptographicHash> class, OFData *self)
{
void *pool = objc_autoreleasePoolPush();
id <OFCryptographicHash> hash =
[class hashWithAllowsSwappableMemory: true];
size_t digestSize = [class digestSize];
const unsigned char *digest;
char cString[digestSize * 2];
[hash updateWithBuffer: self->_items
length: self->_count * self->_itemSize];
digest = hash.digest;
for (size_t i = 0; i < digestSize; i++) {
uint8_t high, low;
high = digest[i] >> 4;
low = digest[i] & 0x0F;
|
︙ | | | ︙ | |
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
return [OFString stringWithCString: cString
encoding: OF_STRING_ENCODING_ASCII
length: digestSize * 2];
}
- (OFString *)stringByMD5Hashing
{
return [self of_cryptoHashWithClass: [OFMD5Hash class]];
}
- (OFString *)stringByRIPEMD160Hashing
{
return [self of_cryptoHashWithClass: [OFRIPEMD160Hash class]];
}
- (OFString *)stringBySHA1Hashing
{
return [self of_cryptoHashWithClass: [OFSHA1Hash class]];
}
- (OFString *)stringBySHA224Hashing
{
return [self of_cryptoHashWithClass: [OFSHA224Hash class]];
}
- (OFString *)stringBySHA256Hashing
{
return [self of_cryptoHashWithClass: [OFSHA256Hash class]];
}
- (OFString *)stringBySHA384Hashing
{
return [self of_cryptoHashWithClass: [OFSHA384Hash class]];
}
- (OFString *)stringBySHA512Hashing
{
return [self of_cryptoHashWithClass: [OFSHA512Hash class]];
}
@end
|
|
|
|
|
|
|
|
|
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
|
return [OFString stringWithCString: cString
encoding: OF_STRING_ENCODING_ASCII
length: digestSize * 2];
}
- (OFString *)stringByMD5Hashing
{
return stringByHashing([OFMD5Hash class], self);
}
- (OFString *)stringByRIPEMD160Hashing
{
return stringByHashing([OFRIPEMD160Hash class], self);
}
- (OFString *)stringBySHA1Hashing
{
return stringByHashing([OFSHA1Hash class], self);
}
- (OFString *)stringBySHA224Hashing
{
return stringByHashing([OFSHA224Hash class], self);
}
- (OFString *)stringBySHA256Hashing
{
return stringByHashing([OFSHA256Hash class], self);
}
- (OFString *)stringBySHA384Hashing
{
return stringByHashing([OFSHA384Hash class], self);
}
- (OFString *)stringBySHA512Hashing
{
return stringByHashing([OFSHA512Hash class], self);
}
@end
|
Modified src/OFData.h
from [4a70713abd]
to [30fd329fb3].
︙ | | | ︙ | |
328
329
330
331
332
333
334
335
336
|
- (void)writeToURL: (OFURL *)URL;
@end
OF_ASSUME_NONNULL_END
#import "OFMutableData.h"
#import "OFData+ASN1DERParsing.h"
#import "OFData+CryptoHashing.h"
#import "OFData+MessagePackParsing.h"
|
|
|
328
329
330
331
332
333
334
335
336
|
- (void)writeToURL: (OFURL *)URL;
@end
OF_ASSUME_NONNULL_END
#import "OFMutableData.h"
#import "OFData+ASN1DERParsing.h"
#import "OFData+CryptographicHashing.h"
#import "OFData+MessagePackParsing.h"
|
Modified src/OFData.m
from [0640a57f3d]
to [526e2e37ba].
︙ | | | ︙ | |
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
|
#import "base64.h"
/* References for static linking */
void
_references_to_categories_of_OFData(void)
{
_OFData_ASN1DERParsing_reference = 1;
_OFData_CryptoHashing_reference = 1;
_OFData_MessagePackParsing_reference = 1;
}
@implementation OFData
@synthesize itemSize = _itemSize;
+ (instancetype)dataWithItems: (const void *)items count: (size_t)count
|
|
|
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
|
#import "base64.h"
/* References for static linking */
void
_references_to_categories_of_OFData(void)
{
_OFData_ASN1DERParsing_reference = 1;
_OFData_CryptographicHashing_reference = 1;
_OFData_MessagePackParsing_reference = 1;
}
@implementation OFData
@synthesize itemSize = _itemSize;
+ (instancetype)dataWithItems: (const void *)items count: (size_t)count
|
︙ | | | ︙ | |
Modified src/OFHMAC.h
from [60aea49324]
to [bca836378e].
︙ | | | ︙ | |
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#import "OFObject.h"
#import "OFCryptoHash.h"
OF_ASSUME_NONNULL_BEGIN
/**
* @class OFHMAC OFHMAC.h ObjFW/OFHMAC.h
*
* @brief A class which provides methods to calculate an HMAC.
*/
OF_SUBCLASSING_RESTRICTED
@interface OFHMAC: OFObject
{
Class <OFCryptoHash> _hashClass;
bool _allowsSwappableMemory;
id <OFCryptoHash> _Nullable _outerHash, _innerHash;
id <OFCryptoHash> _Nullable _outerHashCopy, _innerHashCopy;
bool _calculated;
}
/**
* @brief The class for the cryptographic hash used by the HMAC.
*/
@property (readonly, nonatomic) Class <OFCryptoHash> hashClass;
/**
* @brief Whether data may be stored in swappable memory.
*/
@property (readonly, nonatomic) bool allowsSwappableMemory;
/**
|
|
|
|
|
|
|
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#import "OFObject.h"
#import "OFCryptographicHash.h"
OF_ASSUME_NONNULL_BEGIN
/**
* @class OFHMAC OFHMAC.h ObjFW/OFHMAC.h
*
* @brief A class which provides methods to calculate an HMAC.
*/
OF_SUBCLASSING_RESTRICTED
@interface OFHMAC: OFObject
{
Class <OFCryptographicHash> _hashClass;
bool _allowsSwappableMemory;
id <OFCryptographicHash> _Nullable _outerHash, _innerHash;
id <OFCryptographicHash> _Nullable _outerHashCopy, _innerHashCopy;
bool _calculated;
}
/**
* @brief The class for the cryptographic hash used by the HMAC.
*/
@property (readonly, nonatomic) Class <OFCryptographicHash> hashClass;
/**
* @brief Whether data may be stored in swappable memory.
*/
@property (readonly, nonatomic) bool allowsSwappableMemory;
/**
|
︙ | | | ︙ | |
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
|
/**
* @brief Returns a new OFHMAC with the specified hashing algorithm.
*
* @param hashClass The class of the hashing algorithm
* @param allowsSwappableMemory Whether data may be stored in swappable memory
* @return A new, autoreleased OFHMAC
*/
+ (instancetype)HMACWithHashClass: (Class <OFCryptoHash>)hashClass
allowsSwappableMemory: (bool)allowsSwappableMemory;
- (instancetype)init OF_UNAVAILABLE;
/**
* @brief Initialized an already allocated OFHMAC with the specified hashing
* algorithm.
*
* @param hashClass The class of the hashing algorithm
* @param allowsSwappableMemory Whether data may be stored in swappable memory
* @return An initialized OFHMAC
*/
- (instancetype)initWithHashClass: (Class <OFCryptoHash>)hashClass
allowsSwappableMemory: (bool)allowsSwappableMemory
OF_DESIGNATED_INITIALIZER;
/**
* @brief Sets the key for the HMAC.
*
* @note This resets the HMAC!
|
|
|
|
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
|
/**
* @brief Returns a new OFHMAC with the specified hashing algorithm.
*
* @param hashClass The class of the hashing algorithm
* @param allowsSwappableMemory Whether data may be stored in swappable memory
* @return A new, autoreleased OFHMAC
*/
+ (instancetype)HMACWithHashClass: (Class <OFCryptographicHash>)hashClass
allowsSwappableMemory: (bool)allowsSwappableMemory;
- (instancetype)init OF_UNAVAILABLE;
/**
* @brief Initialized an already allocated OFHMAC with the specified hashing
* algorithm.
*
* @param hashClass The class of the hashing algorithm
* @param allowsSwappableMemory Whether data may be stored in swappable memory
* @return An initialized OFHMAC
*/
- (instancetype)initWithHashClass: (Class <OFCryptographicHash>)hashClass
allowsSwappableMemory: (bool)allowsSwappableMemory
OF_DESIGNATED_INITIALIZER;
/**
* @brief Sets the key for the HMAC.
*
* @note This resets the HMAC!
|
︙ | | | ︙ | |
Modified src/OFHMAC.m
from [a4fe560b23]
to [23d069a3eb].
︙ | | | ︙ | |
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
|
#import "OFHashAlreadyCalculatedException.h"
#import "OFInvalidArgumentException.h"
@implementation OFHMAC
@synthesize hashClass = _hashClass;
@synthesize allowsSwappableMemory = _allowsSwappableMemory;
+ (instancetype)HMACWithHashClass: (Class <OFCryptoHash>)class
allowsSwappableMemory: (bool)allowsSwappableMemory
{
return [[[self alloc] initWithHashClass: class
allowsSwappableMemory: allowsSwappableMemory]
autorelease];
}
- (instancetype)init
{
OF_INVALID_INIT_METHOD
}
- (instancetype)initWithHashClass: (Class <OFCryptoHash>)class
allowsSwappableMemory: (bool)allowsSwappableMemory
{
self = [super init];
_hashClass = class;
_allowsSwappableMemory = allowsSwappableMemory;
|
|
|
|
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
|
#import "OFHashAlreadyCalculatedException.h"
#import "OFInvalidArgumentException.h"
@implementation OFHMAC
@synthesize hashClass = _hashClass;
@synthesize allowsSwappableMemory = _allowsSwappableMemory;
+ (instancetype)HMACWithHashClass: (Class <OFCryptographicHash>)class
allowsSwappableMemory: (bool)allowsSwappableMemory
{
return [[[self alloc] initWithHashClass: class
allowsSwappableMemory: allowsSwappableMemory]
autorelease];
}
- (instancetype)init
{
OF_INVALID_INIT_METHOD
}
- (instancetype)initWithHashClass: (Class <OFCryptographicHash>)class
allowsSwappableMemory: (bool)allowsSwappableMemory
{
self = [super init];
_hashClass = class;
_allowsSwappableMemory = allowsSwappableMemory;
|
︙ | | | ︙ | |
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
|
[_innerHash release];
[_outerHashCopy release];
[_innerHashCopy release];
_outerHash = _innerHash = _outerHashCopy = _innerHashCopy = nil;
@try {
if (length > blockSize) {
id <OFCryptoHash> hash = [_hashClass
cryptoHashWithAllowsSwappableMemory:
_allowsSwappableMemory];
[hash updateWithBuffer: key length: length];
length = hash.digestSize;
if OF_UNLIKELY (length > blockSize)
length = blockSize;
|
|
|
|
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
|
[_innerHash release];
[_outerHashCopy release];
[_innerHashCopy release];
_outerHash = _innerHash = _outerHashCopy = _innerHashCopy = nil;
@try {
if (length > blockSize) {
id <OFCryptographicHash> hash = [_hashClass
hashWithAllowsSwappableMemory:
_allowsSwappableMemory];
[hash updateWithBuffer: key length: length];
length = hash.digestSize;
if OF_UNLIKELY (length > blockSize)
length = blockSize;
|
︙ | | | ︙ | |
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
|
memset(innerKeyPadItems + length, 0, blockSize - length);
for (size_t i = 0; i < blockSize; i++) {
outerKeyPadItems[i] ^= 0x5C;
innerKeyPadItems[i] ^= 0x36;
}
_outerHash = [[_hashClass cryptoHashWithAllowsSwappableMemory:
_allowsSwappableMemory] retain];
_innerHash = [[_hashClass cryptoHashWithAllowsSwappableMemory:
_allowsSwappableMemory] retain];
[_outerHash updateWithBuffer: outerKeyPadItems
length: blockSize];
[_innerHash updateWithBuffer: innerKeyPadItems
length: blockSize];
} @catch (id e) {
|
|
|
|
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
|
memset(innerKeyPadItems + length, 0, blockSize - length);
for (size_t i = 0; i < blockSize; i++) {
outerKeyPadItems[i] ^= 0x5C;
innerKeyPadItems[i] ^= 0x36;
}
_outerHash = [[_hashClass hashWithAllowsSwappableMemory:
_allowsSwappableMemory] retain];
_innerHash = [[_hashClass hashWithAllowsSwappableMemory:
_allowsSwappableMemory] retain];
[_outerHash updateWithBuffer: outerKeyPadItems
length: blockSize];
[_innerHash updateWithBuffer: innerKeyPadItems
length: blockSize];
} @catch (id e) {
|
︙ | | | ︙ | |
Modified src/OFMD5Hash.h
from [2ab0f29af9]
to [308882c688].
︙ | | | ︙ | |
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
*
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#import "OFCryptoHash.h"
OF_ASSUME_NONNULL_BEGIN
@class OFSecureData;
/**
* @class OFMD5Hash OFMD5Hash.h ObjFW/OFMD5Hash.h
*
* @brief A class which provides methods to create an MD5 hash.
*/
OF_SUBCLASSING_RESTRICTED
@interface OFMD5Hash: OFObject <OFCryptoHash>
{
OFSecureData *_iVarsData;
struct of_md5_hash_ivars {
uint32_t state[4];
uint64_t bits;
union of_md5_hash_buffer {
unsigned char bytes[64];
|
|
|
|
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
*
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#import "OFCryptographicHash.h"
OF_ASSUME_NONNULL_BEGIN
@class OFSecureData;
/**
* @class OFMD5Hash OFMD5Hash.h ObjFW/OFMD5Hash.h
*
* @brief A class which provides methods to create an MD5 hash.
*/
OF_SUBCLASSING_RESTRICTED
@interface OFMD5Hash: OFObject <OFCryptographicHash>
{
OFSecureData *_iVarsData;
struct of_md5_hash_ivars {
uint32_t state[4];
uint64_t bits;
union of_md5_hash_buffer {
unsigned char bytes[64];
|
︙ | | | ︙ | |
Modified src/OFMD5Hash.m
from [bf7cb6efee]
to [2c1eebf461].
︙ | | | ︙ | |
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
}
+ (size_t)blockSize
{
return BLOCK_SIZE;
}
+ (instancetype)cryptoHashWithAllowsSwappableMemory: (bool)allowsSwappableMemory
{
return [[[self alloc] initWithAllowsSwappableMemory:
allowsSwappableMemory] autorelease];
}
- (instancetype)initWithAllowsSwappableMemory: (bool)allowsSwappableMemory
{
|
|
|
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
}
+ (size_t)blockSize
{
return BLOCK_SIZE;
}
+ (instancetype)hashWithAllowsSwappableMemory: (bool)allowsSwappableMemory
{
return [[[self alloc] initWithAllowsSwappableMemory:
allowsSwappableMemory] autorelease];
}
- (instancetype)initWithAllowsSwappableMemory: (bool)allowsSwappableMemory
{
|
︙ | | | ︙ | |
Modified src/OFRIPEMD160Hash.h
from [294f0a5d27]
to [222f93a653].
︙ | | | ︙ | |
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
*
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#import "OFCryptoHash.h"
OF_ASSUME_NONNULL_BEGIN
@class OFSecureData;
/**
* @class OFRIPEMD160Hash OFRIPEMD160Hash.h ObjFW/OFRIPEMD160Hash.h
*
* @brief A class which provides methods to create a RIPEMD-160 hash.
*/
OF_SUBCLASSING_RESTRICTED
@interface OFRIPEMD160Hash: OFObject <OFCryptoHash>
{
OFSecureData *_iVarsData;
struct of_ripemd160_hash_ivars {
uint32_t state[5];
uint64_t bits;
union of_ripemd160_hash_buffer {
unsigned char bytes[64];
|
|
|
|
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
*
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#import "OFCryptographicHash.h"
OF_ASSUME_NONNULL_BEGIN
@class OFSecureData;
/**
* @class OFRIPEMD160Hash OFRIPEMD160Hash.h ObjFW/OFRIPEMD160Hash.h
*
* @brief A class which provides methods to create a RIPEMD-160 hash.
*/
OF_SUBCLASSING_RESTRICTED
@interface OFRIPEMD160Hash: OFObject <OFCryptographicHash>
{
OFSecureData *_iVarsData;
struct of_ripemd160_hash_ivars {
uint32_t state[5];
uint64_t bits;
union of_ripemd160_hash_buffer {
unsigned char bytes[64];
|
︙ | | | ︙ | |
Modified src/OFRIPEMD160Hash.m
from [00be784cc9]
to [c81097cb16].
︙ | | | ︙ | |
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
}
+ (size_t)blockSize
{
return BLOCK_SIZE;
}
+ (instancetype)cryptoHashWithAllowsSwappableMemory: (bool)allowsSwappableMemory
{
return [[[self alloc] initWithAllowsSwappableMemory:
allowsSwappableMemory] autorelease];
}
- (instancetype)initWithAllowsSwappableMemory: (bool)allowsSwappableMemory
{
|
|
|
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
}
+ (size_t)blockSize
{
return BLOCK_SIZE;
}
+ (instancetype)hashWithAllowsSwappableMemory: (bool)allowsSwappableMemory
{
return [[[self alloc] initWithAllowsSwappableMemory:
allowsSwappableMemory] autorelease];
}
- (instancetype)initWithAllowsSwappableMemory: (bool)allowsSwappableMemory
{
|
︙ | | | ︙ | |
Modified src/OFSHA1Hash.h
from [1ea7850492]
to [e3b92b0480].
︙ | | | ︙ | |
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
*
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#import "OFCryptoHash.h"
OF_ASSUME_NONNULL_BEGIN
@class OFSecureData;
/**
* @class OFSHA1Hash OFSHA1Hash.h ObjFW/OFSHA1Hash.h
*
* @brief A class which provides methods to create an SHA-1 hash.
*/
OF_SUBCLASSING_RESTRICTED
@interface OFSHA1Hash: OFObject <OFCryptoHash>
{
OFSecureData *_iVarsData;
struct of_sha1_hash_ivars {
uint32_t state[5];
uint64_t bits;
union of_sha1_hash_buffer {
unsigned char bytes[64];
|
|
|
|
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
*
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#import "OFCryptographicHash.h"
OF_ASSUME_NONNULL_BEGIN
@class OFSecureData;
/**
* @class OFSHA1Hash OFSHA1Hash.h ObjFW/OFSHA1Hash.h
*
* @brief A class which provides methods to create an SHA-1 hash.
*/
OF_SUBCLASSING_RESTRICTED
@interface OFSHA1Hash: OFObject <OFCryptographicHash>
{
OFSecureData *_iVarsData;
struct of_sha1_hash_ivars {
uint32_t state[5];
uint64_t bits;
union of_sha1_hash_buffer {
unsigned char bytes[64];
|
︙ | | | ︙ | |
Modified src/OFSHA1Hash.m
from [6dc47e8d09]
to [79fab1d90f].
︙ | | | ︙ | |
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
}
+ (size_t)blockSize
{
return BLOCK_SIZE;
}
+ (instancetype)cryptoHashWithAllowsSwappableMemory: (bool)allowsSwappableMemory
{
return [[[self alloc] initWithAllowsSwappableMemory:
allowsSwappableMemory] autorelease];
}
- (instancetype)initWithAllowsSwappableMemory: (bool)allowsSwappableMemory
{
|
|
|
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
}
+ (size_t)blockSize
{
return BLOCK_SIZE;
}
+ (instancetype)hashWithAllowsSwappableMemory: (bool)allowsSwappableMemory
{
return [[[self alloc] initWithAllowsSwappableMemory:
allowsSwappableMemory] autorelease];
}
- (instancetype)initWithAllowsSwappableMemory: (bool)allowsSwappableMemory
{
|
︙ | | | ︙ | |
Modified src/OFSHA224Or256Hash.h
from [25d2fa7cb5]
to [f40021c439].
︙ | | | ︙ | |
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
*
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#import "OFCryptoHash.h"
OF_ASSUME_NONNULL_BEGIN
@class OFSecureData;
/**
* @class OFSHA224Or256Hash OFSHA224Or256Hash.h ObjFW/OFSHA224Or256Hash.h
*
* @brief A base class for SHA-224 and SHA-256.
*/
@interface OFSHA224Or256Hash: OFObject <OFCryptoHash>
{
@private
OFSecureData *_iVarsData;
@protected
struct of_sha224_or_256_hash_ivars {
uint32_t state[8];
uint64_t bits;
|
|
|
|
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
*
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#import "OFCryptographicHash.h"
OF_ASSUME_NONNULL_BEGIN
@class OFSecureData;
/**
* @class OFSHA224Or256Hash OFSHA224Or256Hash.h ObjFW/OFSHA224Or256Hash.h
*
* @brief A base class for SHA-224 and SHA-256.
*/
@interface OFSHA224Or256Hash: OFObject <OFCryptographicHash>
{
@private
OFSecureData *_iVarsData;
@protected
struct of_sha224_or_256_hash_ivars {
uint32_t state[8];
uint64_t bits;
|
︙ | | | ︙ | |
Modified src/OFSHA224Or256Hash.m
from [e77f5555d4]
to [1d1ad26ec5].
︙ | | | ︙ | |
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
}
+ (size_t)blockSize
{
return BLOCK_SIZE;
}
+ (instancetype)cryptoHashWithAllowsSwappableMemory: (bool)allowsSwappableMemory
{
return [[[self alloc] initWithAllowsSwappableMemory:
allowsSwappableMemory] autorelease];
}
- (instancetype)initWithAllowsSwappableMemory: (bool)allowsSwappableMemory
{
|
|
|
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
}
+ (size_t)blockSize
{
return BLOCK_SIZE;
}
+ (instancetype)hashWithAllowsSwappableMemory: (bool)allowsSwappableMemory
{
return [[[self alloc] initWithAllowsSwappableMemory:
allowsSwappableMemory] autorelease];
}
- (instancetype)initWithAllowsSwappableMemory: (bool)allowsSwappableMemory
{
|
︙ | | | ︙ | |
Modified src/OFSHA384Or512Hash.h
from [f783b37416]
to [a9ade386ad].
︙ | | | ︙ | |
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
*
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#import "OFCryptoHash.h"
OF_ASSUME_NONNULL_BEGIN
@class OFSecureData;
/**
* @class OFSHA384Or512Hash OFSHA384Or512Hash.h ObjFW/OFSHA384Or512Hash.h
*
* @brief A base class for SHA-384 and SHA-512.
*/
@interface OFSHA384Or512Hash: OFObject <OFCryptoHash>
{
@private
OFSecureData *_iVarsData;
@protected
struct of_sha384_or_512_hash_ivars {
uint64_t state[8];
uint64_t bits[2];
|
|
|
|
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
*
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#import "OFCryptographicHash.h"
OF_ASSUME_NONNULL_BEGIN
@class OFSecureData;
/**
* @class OFSHA384Or512Hash OFSHA384Or512Hash.h ObjFW/OFSHA384Or512Hash.h
*
* @brief A base class for SHA-384 and SHA-512.
*/
@interface OFSHA384Or512Hash: OFObject <OFCryptographicHash>
{
@private
OFSecureData *_iVarsData;
@protected
struct of_sha384_or_512_hash_ivars {
uint64_t state[8];
uint64_t bits[2];
|
︙ | | | ︙ | |
Modified src/OFSHA384Or512Hash.m
from [d2d324bc83]
to [4e88edca81].
︙ | | | ︙ | |
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
}
+ (size_t)blockSize
{
return BLOCK_SIZE;
}
+ (instancetype)cryptoHashWithAllowsSwappableMemory: (bool)allowsSwappableMemory
{
return [[[self alloc] initWithAllowsSwappableMemory:
allowsSwappableMemory] autorelease];
}
- (instancetype)initWithAllowsSwappableMemory: (bool)allowsSwappableMemory
{
|
|
|
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
}
+ (size_t)blockSize
{
return BLOCK_SIZE;
}
+ (instancetype)hashWithAllowsSwappableMemory: (bool)allowsSwappableMemory
{
return [[[self alloc] initWithAllowsSwappableMemory:
allowsSwappableMemory] autorelease];
}
- (instancetype)initWithAllowsSwappableMemory: (bool)allowsSwappableMemory
{
|
︙ | | | ︙ | |
Renamed and modified
src/OFString+CryptoHashing.h
[a8ec191fe6]
to src/OFString+CryptographicHashing.h
[059d7ea04f].
︙ | | | ︙ | |
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
#import "OFString.h"
OF_ASSUME_NONNULL_BEGIN
#ifdef __cplusplus
extern "C" {
#endif
extern int _OFString_CryptoHashing_reference;
#ifdef __cplusplus
}
#endif
@interface OFString (CryptoHashing)
/**
* @brief The MD5 hash of the string as a string.
*/
@property (readonly, nonatomic) OFString *stringByMD5Hashing;
/**
* @brief The RIPEMD-160 hash of the string as a string.
|
|
|
|
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
#import "OFString.h"
OF_ASSUME_NONNULL_BEGIN
#ifdef __cplusplus
extern "C" {
#endif
extern int _OFString_CryptographicHashing_reference;
#ifdef __cplusplus
}
#endif
@interface OFString (CryptographicHashing)
/**
* @brief The MD5 hash of the string as a string.
*/
@property (readonly, nonatomic) OFString *stringByMD5Hashing;
/**
* @brief The RIPEMD-160 hash of the string as a string.
|
︙ | | | ︙ | |
Renamed and modified
src/OFString+CryptoHashing.m
[e8341b8291]
to src/OFString+CryptographicHashing.m
[9f70fbd17b].
︙ | | | ︙ | |
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFString.h"
#import "OFCryptoHash.h"
#import "OFMD5Hash.h"
#import "OFRIPEMD160Hash.h"
#import "OFSHA1Hash.h"
#import "OFSHA224Hash.h"
#import "OFSHA256Hash.h"
#import "OFSHA384Hash.h"
#import "OFSHA512Hash.h"
int _OFString_CryptoHashing_reference;
@implementation OFString (CryptoHashing)
- (OFString *)of_cryptoHashWithClass: (Class <OFCryptoHash>)class
{
void *pool = objc_autoreleasePoolPush();
id <OFCryptoHash> hash = [class
cryptoHashWithAllowsSwappableMemory: true];
size_t digestSize = [class digestSize];
const unsigned char *digest;
char cString[digestSize * 2];
[hash updateWithBuffer: self.UTF8String length: self.UTF8StringLength];
digest = hash.digest;
|
|
|
|
|
>
|
|
|
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFString.h"
#import "OFCryptographicHash.h"
#import "OFMD5Hash.h"
#import "OFRIPEMD160Hash.h"
#import "OFSHA1Hash.h"
#import "OFSHA224Hash.h"
#import "OFSHA256Hash.h"
#import "OFSHA384Hash.h"
#import "OFSHA512Hash.h"
int _OFString_CryptographicHashing_reference;
@implementation OFString (CryptographicHashing)
static OFString *
stringByHashing(Class <OFCryptographicHash> class, OFString *self)
{
void *pool = objc_autoreleasePoolPush();
id <OFCryptographicHash> hash =
[class hashWithAllowsSwappableMemory: true];
size_t digestSize = [class digestSize];
const unsigned char *digest;
char cString[digestSize * 2];
[hash updateWithBuffer: self.UTF8String length: self.UTF8StringLength];
digest = hash.digest;
|
︙ | | | ︙ | |
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
|
return [OFString stringWithCString: cString
encoding: OF_STRING_ENCODING_ASCII
length: digestSize * 2];
}
- (OFString *)stringByMD5Hashing
{
return [self of_cryptoHashWithClass: [OFMD5Hash class]];
}
- (OFString *)stringByRIPEMD160Hashing
{
return [self of_cryptoHashWithClass: [OFRIPEMD160Hash class]];
}
- (OFString *)stringBySHA1Hashing
{
return [self of_cryptoHashWithClass: [OFSHA1Hash class]];
}
- (OFString *)stringBySHA224Hashing
{
return [self of_cryptoHashWithClass: [OFSHA224Hash class]];
}
- (OFString *)stringBySHA256Hashing
{
return [self of_cryptoHashWithClass: [OFSHA256Hash class]];
}
- (OFString *)stringBySHA384Hashing
{
return [self of_cryptoHashWithClass: [OFSHA384Hash class]];
}
- (OFString *)stringBySHA512Hashing
{
return [self of_cryptoHashWithClass: [OFSHA512Hash class]];
}
@end
|
|
|
|
|
|
|
|
|
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
return [OFString stringWithCString: cString
encoding: OF_STRING_ENCODING_ASCII
length: digestSize * 2];
}
- (OFString *)stringByMD5Hashing
{
return stringByHashing([OFMD5Hash class], self);
}
- (OFString *)stringByRIPEMD160Hashing
{
return stringByHashing([OFRIPEMD160Hash class], self);
}
- (OFString *)stringBySHA1Hashing
{
return stringByHashing([OFSHA1Hash class], self);
}
- (OFString *)stringBySHA224Hashing
{
return stringByHashing([OFSHA224Hash class], self);
}
- (OFString *)stringBySHA256Hashing
{
return stringByHashing([OFSHA256Hash class], self);
}
- (OFString *)stringBySHA384Hashing
{
return stringByHashing([OFSHA384Hash class], self);
}
- (OFString *)stringBySHA512Hashing
{
return stringByHashing([OFSHA512Hash class], self);
}
@end
|
Modified src/OFString.h
from [048f9d26ff]
to [9aa19fe6df].
︙ | | | ︙ | |
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
|
#endif
OF_ASSUME_NONNULL_END
#include "OFConstantString.h"
#include "OFMutableString.h"
#ifdef __OBJC__
# import "OFString+CryptoHashing.h"
# import "OFString+JSONParsing.h"
# ifdef OF_HAVE_FILES
# import "OFString+PathAdditions.h"
# endif
# import "OFString+PropertyListParsing.h"
# import "OFString+Serialization.h"
# import "OFString+URLEncoding.h"
|
|
|
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
|
#endif
OF_ASSUME_NONNULL_END
#include "OFConstantString.h"
#include "OFMutableString.h"
#ifdef __OBJC__
# import "OFString+CryptographicHashing.h"
# import "OFString+JSONParsing.h"
# ifdef OF_HAVE_FILES
# import "OFString+PathAdditions.h"
# endif
# import "OFString+PropertyListParsing.h"
# import "OFString+Serialization.h"
# import "OFString+URLEncoding.h"
|
︙ | | | ︙ | |
Modified src/OFString.m
from [ff9b0b5a48]
to [d43b0aa5cd].
︙ | | | ︙ | |
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
extern bool of_unicode_to_koi8_u(const of_unichar_t *, unsigned char *,
size_t, bool);
/* References for static linking */
void
_references_to_categories_of_OFString(void)
{
_OFString_CryptoHashing_reference = 1;
_OFString_JSONParsing_reference = 1;
#ifdef OF_HAVE_FILES
_OFString_PathAdditions_reference = 1;
#endif
_OFString_PropertyListParsing_reference = 1;
_OFString_Serialization_reference = 1;
_OFString_URLEncoding_reference = 1;
|
|
|
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
extern bool of_unicode_to_koi8_u(const of_unichar_t *, unsigned char *,
size_t, bool);
/* References for static linking */
void
_references_to_categories_of_OFString(void)
{
_OFString_CryptographicHashing_reference = 1;
_OFString_JSONParsing_reference = 1;
#ifdef OF_HAVE_FILES
_OFString_PathAdditions_reference = 1;
#endif
_OFString_PropertyListParsing_reference = 1;
_OFString_Serialization_reference = 1;
_OFString_URLEncoding_reference = 1;
|
︙ | | | ︙ | |
Modified src/ObjFW.h
from [ff04d9fe70]
to [b598346c9a].
︙ | | | ︙ | |
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
# import "OFHTTPServer.h"
#endif
#ifdef OF_HAVE_SUBPROCESSES
# import "OFSubprocess.h"
#endif
#import "OFCryptoHash.h"
#import "OFMD5Hash.h"
#import "OFRIPEMD160Hash.h"
#import "OFSHA1Hash.h"
#import "OFSHA224Hash.h"
#import "OFSHA256Hash.h"
#import "OFSHA384Hash.h"
#import "OFSHA512Hash.h"
|
|
|
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
# import "OFHTTPServer.h"
#endif
#ifdef OF_HAVE_SUBPROCESSES
# import "OFSubprocess.h"
#endif
#import "OFCryptographicHash.h"
#import "OFMD5Hash.h"
#import "OFRIPEMD160Hash.h"
#import "OFSHA1Hash.h"
#import "OFSHA224Hash.h"
#import "OFSHA256Hash.h"
#import "OFSHA384Hash.h"
#import "OFSHA512Hash.h"
|
︙ | | | ︙ | |
Modified tests/OFMD5HashTests.m
from [b161ec4641]
to [73092aedf1].
︙ | | | ︙ | |
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
@implementation TestsAppDelegate (OFMD5HashTests)
- (void)MD5HashTests
{
void *pool = objc_autoreleasePoolPush();
OFMD5Hash *md5, *copy;
OFFile *f = [OFFile fileWithPath: @"testfile.bin" mode: @"r"];
TEST(@"+[cryptoHashWithAllowsSwappableMemory:]",
(md5 = [OFMD5Hash cryptoHashWithAllowsSwappableMemory: true]))
while (!f.atEndOfStream) {
char buf[64];
size_t len = [f readIntoBuffer: buf length: 64];
[md5 updateWithBuffer: buf length: len];
}
[f close];
|
|
|
|
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
@implementation TestsAppDelegate (OFMD5HashTests)
- (void)MD5HashTests
{
void *pool = objc_autoreleasePoolPush();
OFMD5Hash *md5, *copy;
OFFile *f = [OFFile fileWithPath: @"testfile.bin" mode: @"r"];
TEST(@"+[hashWithAllowsSwappableMemory:]",
(md5 = [OFMD5Hash hashWithAllowsSwappableMemory: true]))
while (!f.atEndOfStream) {
char buf[64];
size_t len = [f readIntoBuffer: buf length: 64];
[md5 updateWithBuffer: buf length: len];
}
[f close];
|
︙ | | | ︙ | |
Modified tests/OFRIPEMD160HashTests.m
from [1bef7d37d4]
to [4b2bd712b4].
︙ | | | ︙ | |
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
@implementation TestsAppDelegate (OFRIPEMD160HashTests)
- (void)RIPEMD160HashTests
{
void *pool = objc_autoreleasePoolPush();
OFRIPEMD160Hash *rmd160, *copy;
OFFile *f = [OFFile fileWithPath: @"testfile.bin" mode: @"r"];
TEST(@"+[cryptoHashWithAllowsSwappableMemory:]",
(rmd160 = [OFRIPEMD160Hash
cryptoHashWithAllowsSwappableMemory: true]))
while (!f.atEndOfStream) {
char buf[64];
size_t len = [f readIntoBuffer: buf length: 64];
[rmd160 updateWithBuffer: buf length: len];
}
[f close];
|
|
|
<
|
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
@implementation TestsAppDelegate (OFRIPEMD160HashTests)
- (void)RIPEMD160HashTests
{
void *pool = objc_autoreleasePoolPush();
OFRIPEMD160Hash *rmd160, *copy;
OFFile *f = [OFFile fileWithPath: @"testfile.bin" mode: @"r"];
TEST(@"+[hashWithAllowsSwappableMemory:]",
(rmd160 = [OFRIPEMD160Hash hashWithAllowsSwappableMemory: true]))
while (!f.atEndOfStream) {
char buf[64];
size_t len = [f readIntoBuffer: buf length: 64];
[rmd160 updateWithBuffer: buf length: len];
}
[f close];
|
︙ | | | ︙ | |
Modified tests/OFSHA1HashTests.m
from [145fd9ade0]
to [3bceacae61].
︙ | | | ︙ | |
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
@implementation TestsAppDelegate (SHA1HashTests)
- (void)SHA1HashTests
{
void *pool = objc_autoreleasePoolPush();
OFSHA1Hash *sha1, *copy;
OFFile *f = [OFFile fileWithPath: @"testfile.bin" mode: @"r"];
TEST(@"+[cryptoHashWithAllowsSwappableMemory:]",
(sha1 = [OFSHA1Hash cryptoHashWithAllowsSwappableMemory: true]))
while (!f.atEndOfStream) {
char buf[64];
size_t len = [f readIntoBuffer: buf length: 64];
[sha1 updateWithBuffer: buf length: len];
}
[f close];
|
|
|
|
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
@implementation TestsAppDelegate (SHA1HashTests)
- (void)SHA1HashTests
{
void *pool = objc_autoreleasePoolPush();
OFSHA1Hash *sha1, *copy;
OFFile *f = [OFFile fileWithPath: @"testfile.bin" mode: @"r"];
TEST(@"+[hashWithAllowsSwappableMemory:]",
(sha1 = [OFSHA1Hash hashWithAllowsSwappableMemory: true]))
while (!f.atEndOfStream) {
char buf[64];
size_t len = [f readIntoBuffer: buf length: 64];
[sha1 updateWithBuffer: buf length: len];
}
[f close];
|
︙ | | | ︙ | |
Modified tests/OFSHA224HashTests.m
from [114b68c56f]
to [4309676a79].
︙ | | | ︙ | |
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
@implementation TestsAppDelegate (SHA224HashTests)
- (void)SHA224HashTests
{
void *pool = objc_autoreleasePoolPush();
OFSHA224Hash *sha224, *copy;
OFFile *f = [OFFile fileWithPath: @"testfile.bin" mode: @"r"];
TEST(@"+[cryptoHashWithAllowsSwappableMemory:]",
(sha224 = [OFSHA224Hash cryptoHashWithAllowsSwappableMemory: true]))
while (!f.atEndOfStream) {
char buf[64];
size_t len = [f readIntoBuffer: buf length: 64];
[sha224 updateWithBuffer: buf length: len];
}
[f close];
|
|
|
|
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
@implementation TestsAppDelegate (SHA224HashTests)
- (void)SHA224HashTests
{
void *pool = objc_autoreleasePoolPush();
OFSHA224Hash *sha224, *copy;
OFFile *f = [OFFile fileWithPath: @"testfile.bin" mode: @"r"];
TEST(@"+[hashWithAllowsSwappableMemory:]",
(sha224 = [OFSHA224Hash hashWithAllowsSwappableMemory: true]))
while (!f.atEndOfStream) {
char buf[64];
size_t len = [f readIntoBuffer: buf length: 64];
[sha224 updateWithBuffer: buf length: len];
}
[f close];
|
︙ | | | ︙ | |
Modified tests/OFSHA256HashTests.m
from [2b578b5f30]
to [2f9948771c].
︙ | | | ︙ | |
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
@implementation TestsAppDelegate (SHA256HashTests)
- (void)SHA256HashTests
{
void *pool = objc_autoreleasePoolPush();
OFSHA256Hash *sha256, *copy;
OFFile *f = [OFFile fileWithPath: @"testfile.bin" mode: @"r"];
TEST(@"+[cryptoHashWithAllowsSwappableMemory:]",
(sha256 = [OFSHA256Hash cryptoHashWithAllowsSwappableMemory: true]))
while (!f.atEndOfStream) {
char buf[64];
size_t len = [f readIntoBuffer: buf length: 64];
[sha256 updateWithBuffer: buf length: len];
}
[f close];
|
|
|
|
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
@implementation TestsAppDelegate (SHA256HashTests)
- (void)SHA256HashTests
{
void *pool = objc_autoreleasePoolPush();
OFSHA256Hash *sha256, *copy;
OFFile *f = [OFFile fileWithPath: @"testfile.bin" mode: @"r"];
TEST(@"+[hashWithAllowsSwappableMemory:]",
(sha256 = [OFSHA256Hash hashWithAllowsSwappableMemory: true]))
while (!f.atEndOfStream) {
char buf[64];
size_t len = [f readIntoBuffer: buf length: 64];
[sha256 updateWithBuffer: buf length: len];
}
[f close];
|
︙ | | | ︙ | |
Modified tests/OFSHA384HashTests.m
from [2c0ef0b0b7]
to [fdfc8fecb8].
︙ | | | ︙ | |
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
@implementation TestsAppDelegate (SHA384HashTests)
- (void)SHA384HashTests
{
void *pool = objc_autoreleasePoolPush();
OFSHA384Hash *sha384, *copy;
OFFile *f = [OFFile fileWithPath: @"testfile.bin" mode: @"r"];
TEST(@"+[cryptoHashWithAllowsSwappableMemory:]",
(sha384 = [OFSHA384Hash cryptoHashWithAllowsSwappableMemory: true]))
while (!f.atEndOfStream) {
char buf[128];
size_t len = [f readIntoBuffer: buf length: 128];
[sha384 updateWithBuffer: buf length: len];
}
[f close];
|
|
|
|
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
@implementation TestsAppDelegate (SHA384HashTests)
- (void)SHA384HashTests
{
void *pool = objc_autoreleasePoolPush();
OFSHA384Hash *sha384, *copy;
OFFile *f = [OFFile fileWithPath: @"testfile.bin" mode: @"r"];
TEST(@"+[hashWithAllowsSwappableMemory:]",
(sha384 = [OFSHA384Hash hashWithAllowsSwappableMemory: true]))
while (!f.atEndOfStream) {
char buf[128];
size_t len = [f readIntoBuffer: buf length: 128];
[sha384 updateWithBuffer: buf length: len];
}
[f close];
|
︙ | | | ︙ | |
Modified tests/OFSHA512HashTests.m
from [99450ee331]
to [ff0238e62b].
︙ | | | ︙ | |
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
@implementation TestsAppDelegate (SHA512HashTests)
- (void)SHA512HashTests
{
void *pool = objc_autoreleasePoolPush();
OFSHA512Hash *sha512, *copy;
OFFile *f = [OFFile fileWithPath: @"testfile.bin" mode: @"r"];
TEST(@"+[cryptoHashWithAllowsSwappableMemory:]",
(sha512 = [OFSHA512Hash cryptoHashWithAllowsSwappableMemory: true]))
while (!f.atEndOfStream) {
char buf[128];
size_t len = [f readIntoBuffer: buf length: 128];
[sha512 updateWithBuffer: buf length: len];
}
[f close];
|
|
|
|
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
@implementation TestsAppDelegate (SHA512HashTests)
- (void)SHA512HashTests
{
void *pool = objc_autoreleasePoolPush();
OFSHA512Hash *sha512, *copy;
OFFile *f = [OFFile fileWithPath: @"testfile.bin" mode: @"r"];
TEST(@"+[hashWithAllowsSwappableMemory:]",
(sha512 = [OFSHA512Hash hashWithAllowsSwappableMemory: true]))
while (!f.atEndOfStream) {
char buf[128];
size_t len = [f readIntoBuffer: buf length: 128];
[sha512 updateWithBuffer: buf length: len];
}
[f close];
|
︙ | | | ︙ | |
Modified utils/ofhash/OFHash.m
from [fe019671c9]
to [e2ddd0324e].
︙ | | | ︙ | |
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
|
@"--sha384|--sha512] file1 [file2 ...]",
@"prog", [OFApplication programName])];
[OFApplication terminateWithStatus: 1];
}
static void
printHash(OFString *algo, OFString *path, id <OFCryptoHash> hash)
{
const unsigned char *digest = hash.digest;
size_t digestSize = hash.digestSize;
[of_stdout writeFormat: @"%@ ", algo];
for (size_t i = 0; i < digestSize; i++)
|
|
|
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
|
@"--sha384|--sha512] file1 [file2 ...]",
@"prog", [OFApplication programName])];
[OFApplication terminateWithStatus: 1];
}
static void
printHash(OFString *algo, OFString *path, id <OFCryptographicHash> hash)
{
const unsigned char *digest = hash.digest;
size_t digestSize = hash.digestSize;
[of_stdout writeFormat: @"%@ ", algo];
for (size_t i = 0; i < digestSize; i++)
|
︙ | | | ︙ | |
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
!calculateSHA512)
help();
if (optionsParser.remainingArguments.count < 1)
help();
if (calculateMD5)
MD5Hash = [OFMD5Hash cryptoHashWithAllowsSwappableMemory: true];
if (calculateRIPEMD160)
RIPEMD160Hash =
[OFRIPEMD160Hash cryptoHashWithAllowsSwappableMemory: true];
if (calculateSHA1)
SHA1Hash =
[OFSHA1Hash cryptoHashWithAllowsSwappableMemory: true];
if (calculateSHA224)
SHA224Hash =
[OFSHA224Hash cryptoHashWithAllowsSwappableMemory: true];
if (calculateSHA256)
SHA256Hash =
[OFSHA256Hash cryptoHashWithAllowsSwappableMemory: true];
if (calculateSHA384)
SHA384Hash =
[OFSHA384Hash cryptoHashWithAllowsSwappableMemory: true];
if (calculateSHA512)
SHA512Hash =
[OFSHA512Hash cryptoHashWithAllowsSwappableMemory: true];
for (OFString *path in optionsParser.remainingArguments) {
void *pool = objc_autoreleasePoolPush();
OFStream *file;
if ([path isEqual: @"-"])
file = of_stdin;
|
|
|
<
|
<
|
<
|
<
|
<
|
|
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
!calculateSHA512)
help();
if (optionsParser.remainingArguments.count < 1)
help();
if (calculateMD5)
MD5Hash = [OFMD5Hash hashWithAllowsSwappableMemory: true];
if (calculateRIPEMD160)
RIPEMD160Hash =
[OFRIPEMD160Hash hashWithAllowsSwappableMemory: true];
if (calculateSHA1)
SHA1Hash = [OFSHA1Hash hashWithAllowsSwappableMemory: true];
if (calculateSHA224)
SHA224Hash = [OFSHA224Hash hashWithAllowsSwappableMemory: true];
if (calculateSHA256)
SHA256Hash = [OFSHA256Hash hashWithAllowsSwappableMemory: true];
if (calculateSHA384)
SHA384Hash = [OFSHA384Hash hashWithAllowsSwappableMemory: true];
if (calculateSHA512)
SHA512Hash = [OFSHA512Hash hashWithAllowsSwappableMemory: true];
for (OFString *path in optionsParser.remainingArguments) {
void *pool = objc_autoreleasePoolPush();
OFStream *file;
if ([path isEqual: @"-"])
file = of_stdin;
|
︙ | | | ︙ | |