1/*
2 * Copyright (c) 2010 Apple Inc. All Rights Reserved.
3 */
4
5#include <CoreFoundation/CoreFoundation.h>
6#include <Security/SecInternal.h>
7#include <Security/SecItem.h>
8#include <Security/SecBase.h>
9#include <CommonCrypto/CommonHMAC.h>
10#include <stdlib.h>
11#include <unistd.h>
12#include <Security/SecPBKDF.h>
13
14#include "Security_regressions.h"
15
16#if 0
17static void
18printComparison(const uint8_t*left, const uint8_t* right, int length)
19{
20    int i;
21    for(i = 0; i < length; ++i)
22    {
23        fprintf(stderr, "#  Values :: 0x%02x :: 0x%02x\n", left[i], right[i]);
24    }
25}
26#endif
27
28static int kTestTestCount = 8;
29
30static void tests(void)
31{
32    {
33        const char *password =          "password";
34        const char *salt =              "salt";
35        const int iterations =          1;
36        const uint8_t expected[20] =  { 0x0c, 0x60, 0xc8, 0x0f,
37                                        0x96, 0x1f, 0x0e, 0x71,
38                                        0xf3, 0xa9, 0xb5, 0x24,
39                                        0xaf, 0x60, 0x12, 0x06,
40                                        0x2f, 0xe0, 0x37, 0xa6 };
41
42        const char resultSize = sizeof(expected);
43
44        uint8_t actual[resultSize];
45
46        pbkdf2_hmac_sha1((const uint8_t*) password, strlen(password), (const uint8_t*) salt, strlen(salt), iterations, actual, resultSize);
47
48        ok(memcmp(expected, actual, resultSize) == 0, "pbkdf-sha-1: P-'password' S-'Salt' I-1");
49    }
50
51    {
52        const char *password =          "password";
53        const char *salt =              "salt";
54        const int iterations =          2;
55        const uint8_t expected[20] =  { 0xea, 0x6c, 0x01, 0x4d,
56                                        0xc7, 0x2d, 0x6f, 0x8c,
57                                        0xcd, 0x1e, 0xd9, 0x2a,
58                                        0xce, 0x1d, 0x41, 0xf0,
59                                        0xd8, 0xde, 0x89, 0x57 };
60
61        const char resultSize = sizeof(expected);
62
63        uint8_t actual[resultSize];
64
65        pbkdf2_hmac_sha1((const uint8_t*) password, strlen(password), (const uint8_t*) salt, strlen(salt), iterations, actual, resultSize);
66
67        ok(memcmp(expected, actual, resultSize) == 0, "pbkdf-sha-1: P-'password' S-'Salt' I-2");
68    }
69
70    {
71        const char *password =          "password";
72        const char *salt =              "salt";
73        const int iterations =          4096;
74        const uint8_t expected[20] =  { 0x4b, 0x00, 0x79, 0x01,
75                                        0xb7, 0x65, 0x48, 0x9a,
76                                        0xbe, 0xad, 0x49, 0xd9,
77                                        0x26, 0xf7, 0x21, 0xd0,
78                                        0x65, 0xa4, 0x29, 0xc1 };
79
80        const char resultSize = sizeof(expected);
81
82        uint8_t actual[resultSize];
83
84        pbkdf2_hmac_sha1((const uint8_t*) password, strlen(password), (const uint8_t*) salt, strlen(salt), iterations, actual, resultSize);
85
86        ok(memcmp(expected, actual, resultSize) == 0, "pbkdf-sha-1: P-'password' S-'Salt' I-4096");
87    }
88
89    SKIP: {
90        skip("16777216 iterations is too slow", 1, 0);
91
92        const char *password =          "password";
93        const char *salt =              "salt";
94        const int iterations =          16777216;
95        const uint8_t expected[20] =  { 0xee, 0xfe, 0x3d, 0x61,
96                                        0xcd, 0x4d, 0xa4, 0xe4,
97                                        0xe9, 0x94, 0x5b, 0x3d,
98                                        0x6b, 0xa2, 0x15, 0x8c,
99                                        0x26, 0x34, 0xe9, 0x84 };
100
101        const char resultSize = sizeof(expected);
102
103        uint8_t actual[resultSize];
104
105        pbkdf2_hmac_sha1((const uint8_t*) password, strlen(password), (const uint8_t*) salt, strlen(salt), iterations, actual, resultSize);
106
107        ok(memcmp(expected, actual, resultSize) == 0, "pbkdf-sha-1: P-'password' S-'Salt' I-16777216");
108    }
109
110
111    {
112        CFStringRef password    = CFStringCreateWithCString(NULL, "password", kCFStringEncodingUTF8);
113        CFStringRef salt        = CFStringCreateWithCString(NULL, "salt", kCFStringEncodingUTF8);
114
115        CFDataRef   passwordData    = CFStringCreateExternalRepresentation(NULL, password, kCFStringEncodingUTF8, 0);
116        CFDataRef   saltData        = CFStringCreateExternalRepresentation(NULL, salt, kCFStringEncodingUTF8, 0);
117
118        const int iterations =          1;
119        const uint8_t expected[20] =  { 0x0c, 0x60, 0xc8, 0x0f,
120                                        0x96, 0x1f, 0x0e, 0x71,
121                                        0xf3, 0xa9, 0xb5, 0x24,
122                                        0xaf, 0x60, 0x12, 0x06,
123                                        0x2f, 0xe0, 0x37, 0xa6 };
124
125        const char resultSize = sizeof(expected);
126
127        CFMutableDataRef resultData = CFDataCreateMutable(NULL, resultSize);
128        CFDataIncreaseLength(resultData, resultSize);
129
130        SecKeyFromPassphraseDataHMACSHA1(passwordData, saltData, iterations, resultData);
131
132        ok(memcmp(expected, CFDataGetBytePtr(resultData), resultSize) == 0, "pbkdf-sha-1: P-'password' S-'Salt' I-1");
133
134        CFReleaseSafe(password);
135        CFReleaseSafe(salt);
136        CFReleaseSafe(passwordData);
137        CFReleaseSafe(saltData);
138        CFReleaseSafe(resultData);
139    }
140
141    {
142        CFStringRef password    = CFStringCreateWithCString(NULL, "password", kCFStringEncodingUTF8);
143        CFStringRef salt        = CFStringCreateWithCString(NULL, "salt", kCFStringEncodingUTF8);
144
145        CFDataRef   passwordData    = CFStringCreateExternalRepresentation(NULL, password, kCFStringEncodingUTF8, 0);
146        CFDataRef   saltData        = CFStringCreateExternalRepresentation(NULL, salt, kCFStringEncodingUTF8, 0);
147
148        const int iterations =          2;
149        const uint8_t expected[20] =  { 0xea, 0x6c, 0x01, 0x4d,
150                                        0xc7, 0x2d, 0x6f, 0x8c,
151                                        0xcd, 0x1e, 0xd9, 0x2a,
152                                        0xce, 0x1d, 0x41, 0xf0,
153                                        0xd8, 0xde, 0x89, 0x57 };
154
155        const char resultSize = sizeof(expected);
156
157        CFMutableDataRef resultData = CFDataCreateMutable(NULL, resultSize);
158        CFDataIncreaseLength(resultData, resultSize);
159
160        SecKeyFromPassphraseDataHMACSHA1(passwordData, saltData, iterations, resultData);
161
162        ok(memcmp(expected, CFDataGetBytePtr(resultData), resultSize) == 0, "pbkdf-sha-1: P-'password' S-'Salt' I-1");
163
164        CFReleaseSafe(password);
165        CFReleaseSafe(salt);
166        CFReleaseSafe(passwordData);
167        CFReleaseSafe(saltData);
168        CFReleaseSafe(resultData);
169    }
170
171    {
172        CFStringRef password    = CFStringCreateWithCString(NULL, "password", kCFStringEncodingUTF8);
173        CFStringRef salt        = CFStringCreateWithCString(NULL, "salt", kCFStringEncodingUTF8);
174
175        CFDataRef   passwordData    = CFStringCreateExternalRepresentation(NULL, password, kCFStringEncodingUTF8, 0);
176        CFDataRef   saltData        = CFStringCreateExternalRepresentation(NULL, salt, kCFStringEncodingUTF8, 0);
177
178        const int iterations =          4096;
179        const uint8_t expected[20] =  { 0x4b, 0x00, 0x79, 0x01,
180                                        0xb7, 0x65, 0x48, 0x9a,
181                                        0xbe, 0xad, 0x49, 0xd9,
182                                        0x26, 0xf7, 0x21, 0xd0,
183                                        0x65, 0xa4, 0x29, 0xc1 };
184
185
186        const char resultSize = sizeof(expected);
187
188        CFMutableDataRef resultData = CFDataCreateMutable(NULL, resultSize);
189        CFDataIncreaseLength(resultData, resultSize);
190
191        SecKeyFromPassphraseDataHMACSHA1(passwordData, saltData, iterations, resultData);
192
193        ok(memcmp(expected, CFDataGetBytePtr(resultData), resultSize) == 0, "pbkdf-sha-1: P-'password' S-'Salt' I-1");
194
195        CFReleaseSafe(password);
196        CFReleaseSafe(salt);
197        CFReleaseSafe(passwordData);
198        CFReleaseSafe(saltData);
199        CFReleaseSafe(resultData);
200    }
201
202    SKIP: {
203        skip("16777216 iterations is too slow", 1, 0);
204
205        CFStringRef password    = CFStringCreateWithCString(NULL, "password", kCFStringEncodingUTF8);
206        CFStringRef salt        = CFStringCreateWithCString(NULL, "salt", kCFStringEncodingUTF8);
207
208        CFDataRef   passwordData    = CFStringCreateExternalRepresentation(NULL, password, kCFStringEncodingUTF8, 0);
209        CFDataRef   saltData        = CFStringCreateExternalRepresentation(NULL, salt, kCFStringEncodingUTF8, 0);
210
211        const int iterations =          16777216;
212        const uint8_t expected[20] =  { 0xee, 0xfe, 0x3d, 0x61,
213                                        0xcd, 0x4d, 0xa4, 0xe4,
214                                        0xe9, 0x94, 0x5b, 0x3d,
215                                        0x6b, 0xa2, 0x15, 0x8c,
216                                        0x26, 0x34, 0xe9, 0x84 };
217
218
219        const char resultSize = sizeof(expected);
220
221        CFMutableDataRef resultData = CFDataCreateMutable(NULL, resultSize);
222        CFDataIncreaseLength(resultData, resultSize);
223
224        SecKeyFromPassphraseDataHMACSHA1(passwordData, saltData, iterations, resultData);
225
226        ok(memcmp(expected, CFDataGetBytePtr(resultData), resultSize) == 0, "pbkdf-sha-1: P-'password' S-'Salt' I-1");
227
228        CFReleaseSafe(password);
229        CFReleaseSafe(salt);
230        CFReleaseSafe(passwordData);
231        CFReleaseSafe(saltData);
232        CFReleaseSafe(resultData);
233    }
234
235}
236
237int spbkdf_00_hmac_sha1(int argc, char *const *argv)
238{
239	plan_tests(kTestTestCount);
240
241	tests();
242
243	return 0;
244}
245