CryptoPassphrase  Diff

Differences From Artifact [37a8c168df]:

To Artifact [17ced95bbb]:


1
2

3
4

5
6
7
8
9
10
11
1

2
3

4
5
6
7
8
9
10
11

-
+

-
+







/*
 * Copyright (c) 2016 - 2019 Jonathan Schleifer <js@heap.zone>
 * Copyright (c) 2016 - 2020 Jonathan Schleifer <js@nil.im>
 *
 * https://heap.zone/git/cryptopassphrase.git
 * https://nil.im/git/cryptopassphrase.git
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice is present in all copies.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41
42
43
44
45
46
47

48


49
50
51
52
53

54
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
41
42
43
44
45
46
47
48

49
50
51
52
53
54

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







+
-
+
+




-
+
-
-
+
-
-
-
+
+

-
+







-
+
-
-
-
-
+
+
+
+

-
-
-
+
+
+

+
-
-
-
+
+
+
-
-
-
-
-
+
-

-
+



-
+


}

- (void)derivePassword
{
	OFSHA384Hash *siteHash = [OFSHA384Hash
	    cryptoHashWithAllowsSwappableMemory: true];
	size_t passphraseLength, combinedPassphraseLength;
	OFSecureData *combinedPassphrase;
	char *combinedPassphrase;
	char *combinedPassphraseItems;
	unsigned char *outputItems;

	[siteHash updateWithBuffer: _site.UTF8String
			    length: _site.UTF8StringLength];

	if (_output != NULL) {
	[_output release];
		of_explicit_memset(_output, 0, _length);
		[self freeMemory: _output];
	_output = nil;
	}

	_output = [self allocMemoryWithSize: _length + 1];
	_output = [[OFSecureData alloc] initWithCount: _length + 1
				allowsSwappableMemory: false];

	passphraseLength = combinedPassphraseLength = strlen(_passphrase);
	passphraseLength = combinedPassphraseLength = _passphrase.count - 1;
	if (_keyFile != nil) {
		if (SIZE_MAX - combinedPassphraseLength < _keyFile.count)
			@throw [OFOutOfRangeException exception];

		combinedPassphraseLength += _keyFile.count;
	}

	if ((combinedPassphrase = malloc(combinedPassphraseLength)) == NULL)
	combinedPassphrase = [OFSecureData
		@throw [OFOutOfMemoryException
		    exceptionWithRequestedSize: combinedPassphraseLength];
	@try {
		memcpy(combinedPassphrase, _passphrase, passphraseLength);
		    dataWithCount: combinedPassphraseLength
	    allowsSwappableMemory: false];
	combinedPassphraseItems = combinedPassphrase.mutableItems;
	memcpy(combinedPassphraseItems, _passphrase.items, passphraseLength);

		if (_keyFile != nil)
			memcpy(combinedPassphrase + passphraseLength,
			    _keyFile.items, _keyFile.count);
	if (_keyFile != nil)
		memcpy(combinedPassphraseItems + passphraseLength,
		    _keyFile.items, _keyFile.count);

	outputItems = _output.mutableItems;
		of_scrypt(8, 524288, 2, siteHash.digest,
		    [siteHash.class digestSize], combinedPassphrase,
		    combinedPassphraseLength, _output, _length, true);
	of_scrypt(8, 524288, 2, siteHash.digest, [siteHash.class digestSize],
	    combinedPassphraseItems, combinedPassphraseLength, outputItems,
	    _length, true);
	} @finally {
		of_explicit_memset(combinedPassphrase, 0,
		    combinedPassphraseLength);
		free(combinedPassphrase);
	}


	for (size_t i = 0; i < _length; i++)
		_output[i] =
		outputItems[i] =
		    "123456789"
		    "abcdefghijkmnopqrstuvwxyz"
		    "ABCDEFGHJKLMNPQRSTUVWXYZ"
		    "#$%-=?"[_output[i] & 0x3F];
		    "#$%-=?"[outputItems[i] & 0x3F];
}
@end