1 /*
2 * AIX ssha cracker patch for JtR. Hacked together during April of 2013 by Dhiru
3 * Kholia <dhiru at openwall.com> and magnum.
4 *
5 * Thanks to atom (of hashcat project) and philsmd for discovering and
6 * publishing the details of various AIX hashing algorithms.
7 *
8 * This software is Copyright (c) 2013 Dhiru Kholia <dhiru at openwall.com> and
9 * magnum, and it is hereby released to the general public under the following
10 * terms:
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted.
14 */
15
16 #if FMT_EXTERNS_H
17 extern struct fmt_main fmt_aixssha1;
18 extern struct fmt_main fmt_aixssha256;
19 extern struct fmt_main fmt_aixssha512;
20 #elif FMT_REGISTERS_H
21 john_register_one(&fmt_aixssha1);
22 john_register_one(&fmt_aixssha256);
23 john_register_one(&fmt_aixssha512);
24 #else
25
26 #include <string.h>
27 #ifdef _OPENMP
28 #include <omp.h>
29 #endif
30
31 #include "arch.h"
32 #include "misc.h"
33 #include "common.h"
34 #include "formats.h"
35 #include "params.h"
36 #include "options.h"
37 #include "pbkdf2_hmac_sha1.h"
38 #include "pbkdf2_hmac_sha256.h"
39 #include "pbkdf2_hmac_sha512.h"
40
41 #ifndef OMP_SCALE
42 #define OMP_SCALE 4 // MKPC and OMP_SCALE tuned for core i7
43 #endif
44
45 #define FORMAT_LABEL_SHA1 "aix-ssha1"
46 #define FORMAT_LABEL_SHA256 "aix-ssha256"
47 #define FORMAT_LABEL_SHA512 "aix-ssha512"
48 #define FORMAT_NAME_SHA1 "AIX LPA {ssha1}"
49 #define FORMAT_NAME_SHA256 "AIX LPA {ssha256}"
50 #define FORMAT_NAME_SHA512 "AIX LPA {ssha512}"
51
52 #define FORMAT_TAG1 "{ssha1}"
53 #define FORMAT_TAG256 "{ssha256}"
54 #define FORMAT_TAG512 "{ssha512}"
55 #define FORMAT_TAG1_LEN (sizeof(FORMAT_TAG1)-1)
56 #define FORMAT_TAG256_LEN (sizeof(FORMAT_TAG256)-1)
57 #define FORMAT_TAG512_LEN (sizeof(FORMAT_TAG512)-1)
58
59 #ifdef SIMD_COEF_32
60 #define ALGORITHM_NAME_SHA1 "PBKDF2-SHA1 " SHA1_ALGORITHM_NAME
61 #else
62 #define ALGORITHM_NAME_SHA1 "PBKDF2-SHA1 32/" ARCH_BITS_STR
63 #endif
64 #ifdef SIMD_COEF_32
65 #define ALGORITHM_NAME_SHA256 "PBKDF2-SHA256 " SHA256_ALGORITHM_NAME
66 #else
67 #define ALGORITHM_NAME_SHA256 "PBKDF2-SHA256 32/" ARCH_BITS_STR
68 #endif
69 #ifdef SIMD_COEF_64
70 #define ALGORITHM_NAME_SHA512 "PBKDF2-SHA512 " SHA512_ALGORITHM_NAME
71 #else
72 #define ALGORITHM_NAME_SHA512 "PBKDF2-SHA512 32/" ARCH_BITS_STR
73 #endif
74 #define BENCHMARK_COMMENT ""
75 #define BENCHMARK_LENGTH 7
76 #define PLAINTEXT_LENGTH 125 /* actual max in AIX is 255 */
77 #define BINARY_SIZE 20
78 #define BINARY_ALIGN 4
79 #define CMP_SIZE BINARY_SIZE - 2
80 #define LARGEST_BINARY_SIZE 64
81 #define MAX_SALT_SIZE 24
82 #define SALT_SIZE sizeof(struct custom_salt)
83 #define SALT_ALIGN 4
84 #define MIN_KEYS_PER_CRYPT 1
85 #define MAX_KEYS_PER_CRYPT 1
86
87 static struct fmt_tests aixssha_tests1[] = {
88 {"{ssha1}06$T6numGi8BRLzTYnF$AdXq1t6baevg9/cu5QBBk8Xg.se", "whatdoyouwantfornothing$$$$$$"},
89 {"{ssha1}06$6cZ2YrFYwVQPAVNb$1agAljwERjlin9RxFxzKl.E0.sJ", "gentoo=>meh"},
90 /* Full 125 byte PW (longest JtR will handle). generated by pass_gen.pl */
91 {"{ssha1}06$uOYCzfO5dt0EdnwG$CK81ljQknzEAcfwg97cocEwz.gv", "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345"},
92 {NULL}
93 };
94
95 static struct fmt_tests aixssha_tests256[] = {
96 {"{ssha256}06$YPhynOx/iJQaJOeV$EXQbOSYZftEo3k01uoanAbA7jEKZRUU9LCCs/tyU.wG", "verylongbutnotverystrongpassword"},
97 {"{ssha256}06$5lsi4pETf/0p/12k$xACBftDMh30RqgrM5Sppl.Txgho41u0oPoD21E1b.QT", "I<3JtR"},
98 /* Full 125 byte PW (longest JtR will handle). generated by pass_gen.pl */
99 {"{ssha256}06$qcXPTOQzDAqZuiHc$pS/1HC4uI5jIERNerX8.Zd0G/gDepZuqR7S5WHEn.AW", "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345"},
100 {NULL}
101 };
102 static struct fmt_tests aixssha_tests512[] = {
103 {"{ssha512}06$y2/.O4drNJd3ecgJ$DhNk3sS28lkIo7XZaXWSkFOIdP2Zsd9DIKdYDSuSU5tsnl29Q7xTc3f64eAGMpcMJCVp/SXZ4Xgx3jlHVIOr..", "solarisalwaysbusyitseems"},
104 {"{ssha512}06$Dz/dDr1qa8JJm0UB$DFNu2y8US18fW37ht8WRiwhSeOqAMJTJ6mLDW03D/SeQpdI50GJMYb1fBog5/ZU3oM9qsSr9w6u22.OjjufV..", "idontbelievethatyourpasswordislongerthanthisone"},
105 /* hash posted on john-users */
106 {"{ssha512}06$................$0egLaF88SUk6GAFIMN/vTwa/IYB.KlubYmjiaWvmQ975vHvgC3rf0I6ZYzgyUiQftS8qs7ULLQpRLrA3LA....", "44"},
107 {"{ssha512}06$aXayEJGxA02Bl4d2$TWfWx34oD.UjrS/Qtco6Ij2XPY1CPYJfdk3CcxEjnMZvQw2p5obHYH7SI2wxcJgaS9.S9Hz948R.GdGwsvR...", "test"},
108 /* http://www.ibmsystemsmag.com/aix/administrator/security/password_hash/?page=2 <== partially corrupted hash? */
109 {"{ssha512}06$otYx2eSXx.OkEY4F$No5ZvSfhYuB1MSkBhhcKJIjS0.q//awdkcZwF9/TXi3EnL6QeronmS0jCc3P2aEV9WLi5arzN1YjVwkx8bng..", "colorado"},
110 /* Full 125 byte PW (longest JtR will handle). generated by pass_gen.pl */
111 {"{ssha512}06$w6THk2lJbkqW0rXv$yH6VWp3X9ad2l8nhYi22lrrmWskXvEU.PONbWUAZHrjhgQjdU83jtRnYmpRZIJzTVC3RFcoqpbtd63n/UdlS..", "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345"},
112 {NULL}
113 };
114
115 static char (*saved_key)[PLAINTEXT_LENGTH + 1];
116 static uint32_t (*crypt_out)[BINARY_SIZE / sizeof(uint32_t)];
117
118 static struct custom_salt {
119 int iterations;
120 int type;
121 unsigned char salt[MAX_SALT_SIZE + 1];
122 } *cur_salt;
123
init(struct fmt_main * self)124 static void init(struct fmt_main *self)
125 {
126 omp_autotune(self, OMP_SCALE);
127
128 saved_key = mem_calloc_align(sizeof(*saved_key),
129 self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
130 crypt_out = mem_calloc_align(sizeof(*crypt_out),
131 self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
132 }
133
done(void)134 static void done(void)
135 {
136 MEM_FREE(crypt_out);
137 MEM_FREE(saved_key);
138 }
valid_common(char * ciphertext,struct fmt_main * self,int b64len,char * sig,int siglen)139 static inline int valid_common(char *ciphertext, struct fmt_main *self, int b64len, char *sig, int siglen)
140 {
141 char *p = ciphertext;
142 int len;
143
144 if (!strncmp(p, sig, siglen))
145 p += siglen;
146 else
147 return 0;
148
149 len = strspn(p, DIGITCHARS); /* iterations, exactly two digits */
150 if (len != 2 || atoi(p) > 31) /* actual range is 4..31 */
151 return 0;
152 p += 2;
153 if (*p++ != '$')
154 return 0;
155
156 len = strspn(p, BASE64_CRYPT); /* salt, 8..24 base64 chars */
157 if (len < 8 || len > MAX_SALT_SIZE)
158 return 0;
159 p += len;
160 if (*p++ != '$')
161 return 0;
162 len = strspn(p, BASE64_CRYPT); /* hash */
163 if (len != b64len)
164 return 0;
165 if (p[len] != 0) /* nothing more allowed */
166 return 0;
167
168 return 1;
169 }
170
valid_sha1(char * ciphertext,struct fmt_main * self)171 static int valid_sha1(char *ciphertext, struct fmt_main *self) {
172 return valid_common(ciphertext, self, 27, FORMAT_TAG1, FORMAT_TAG1_LEN);
173 }
valid_sha256(char * ciphertext,struct fmt_main * self)174 static int valid_sha256(char *ciphertext, struct fmt_main *self) {
175 return valid_common(ciphertext, self, 43, FORMAT_TAG256, FORMAT_TAG256_LEN);
176 }
valid_sha512(char * ciphertext,struct fmt_main * self)177 static int valid_sha512(char *ciphertext, struct fmt_main *self) {
178 return valid_common(ciphertext, self, 86, FORMAT_TAG512, FORMAT_TAG512_LEN);
179 }
180
get_salt(char * ciphertext)181 static void *get_salt(char *ciphertext)
182 {
183 char *ctcopy = strdup(ciphertext);
184 char *keeptr = ctcopy;
185 char *p;
186 static struct custom_salt cs;
187 keeptr = ctcopy;
188
189 memset(&cs, 0, sizeof(cs));
190 if ((strncmp(ciphertext, FORMAT_TAG1, FORMAT_TAG1_LEN) == 0)) {
191 cs.type = 1;
192 ctcopy += FORMAT_TAG1_LEN;
193 } else if ((strncmp(ciphertext, FORMAT_TAG256, FORMAT_TAG256_LEN) == 0)) {
194 cs.type = 256;
195 ctcopy += FORMAT_TAG256_LEN;
196 } else {
197 cs.type = 512;
198 ctcopy += FORMAT_TAG512_LEN;
199 }
200
201 p = strtokm(ctcopy, "$");
202 cs.iterations = 1 << atoi(p);
203 p = strtokm(NULL, "$");
204 strncpy((char*)cs.salt, p, 17);
205
206 MEM_FREE(keeptr);
207 return (void *)&cs;
208 }
209
210 #define TO_BINARY(b1, b2, b3) { \
211 value = (uint32_t)atoi64[ARCH_INDEX(pos[0])] | \
212 ((uint32_t)atoi64[ARCH_INDEX(pos[1])] << 6) | \
213 ((uint32_t)atoi64[ARCH_INDEX(pos[2])] << 12) | \
214 ((uint32_t)atoi64[ARCH_INDEX(pos[3])] << 18); \
215 pos += 4; \
216 out.c[b1] = value >> 16; \
217 out.c[b2] = value >> 8; \
218 out.c[b3] = value; }
219
get_binary(char * ciphertext)220 static void *get_binary(char *ciphertext)
221 {
222 static union {
223 unsigned char c[LARGEST_BINARY_SIZE+3];
224 uint64_t dummy;
225 } out;
226 uint32_t value;
227 char *pos = strrchr(ciphertext, '$') + 1;
228 int len = strlen(pos);
229 int i;
230
231 memset(&out, 0, sizeof(out));
232 for (i = 0; i < len/4*3; i += 3)
233 TO_BINARY(i, i + 1, i + 2);
234
235 if (len % 3 == 1) {
236 value = (uint32_t)atoi64[ARCH_INDEX(pos[0])] |
237 ((uint32_t)atoi64[ARCH_INDEX(pos[1])] << 6);
238 out.c[i] = value;
239 } else if (len % 3 == 2) { /* sha-1, sha-256 */
240 value = (uint32_t)atoi64[ARCH_INDEX(pos[0])] |
241 ((uint32_t)atoi64[ARCH_INDEX(pos[1])] << 6) |
242 ((uint32_t)atoi64[ARCH_INDEX(pos[2])] << 12);
243 out.c[i++] = value >> 8;
244 out.c[i++] = value;
245 }
246 return (void *)out.c;
247 }
248
249 #define COMMON_GET_HASH_VAR crypt_out
250 #include "common-get-hash.h"
251
set_salt(void * salt)252 static void set_salt(void *salt)
253 {
254 cur_salt = (struct custom_salt *)salt;
255 }
256
crypt_all(int * pcount,struct db_salt * salt)257 static int crypt_all(int *pcount, struct db_salt *salt)
258 {
259 const int count = *pcount;
260 int inc=1, index = 0;
261
262 switch(cur_salt->type) {
263 case 1:
264 #ifdef SSE_GROUP_SZ_SHA1
265 inc = SSE_GROUP_SZ_SHA1;
266 #endif
267 break;
268 case 256:
269 #ifdef SSE_GROUP_SZ_SHA256
270 inc = SSE_GROUP_SZ_SHA256;
271 #endif
272 break;
273 default:
274 #ifdef SSE_GROUP_SZ_SHA512
275 inc = SSE_GROUP_SZ_SHA512;
276 #endif
277 break;
278 }
279
280 #ifdef _OPENMP
281 #pragma omp parallel for
282 #endif
283 for (index = 0; index < count; index += inc)
284 {
285 int j = index;
286 while (j < index + inc) {
287 if (cur_salt->type == 1) {
288 #ifdef SSE_GROUP_SZ_SHA1
289 int lens[SSE_GROUP_SZ_SHA1], i;
290 unsigned char *pin[SSE_GROUP_SZ_SHA1];
291 union {
292 uint32_t *pout[SSE_GROUP_SZ_SHA1];
293 unsigned char *poutc;
294 } x;
295 for (i = 0; i < SSE_GROUP_SZ_SHA1; ++i) {
296 lens[i] = strlen(saved_key[j]);
297 pin[i] = (unsigned char*)(saved_key[j]);
298 x.pout[i] = crypt_out[j];
299 ++j;
300 }
301 pbkdf2_sha1_sse((const unsigned char **)pin, lens, cur_salt->salt, strlen((char*)cur_salt->salt), cur_salt->iterations, &(x.poutc), BINARY_SIZE, 0);
302 #else
303 pbkdf2_sha1((const unsigned char*)(saved_key[j]), strlen(saved_key[j]),
304 cur_salt->salt, strlen((char*)cur_salt->salt),
305 cur_salt->iterations, (unsigned char*)crypt_out[j], BINARY_SIZE, 0);
306 ++j;
307 #endif
308 }
309 else if (cur_salt->type == 256) {
310 #ifdef SSE_GROUP_SZ_SHA256
311 int lens[SSE_GROUP_SZ_SHA256], i;
312 unsigned char *pin[SSE_GROUP_SZ_SHA256];
313 union {
314 uint32_t *pout[SSE_GROUP_SZ_SHA256];
315 unsigned char *poutc;
316 } x;
317 for (i = 0; i < SSE_GROUP_SZ_SHA256; ++i) {
318 lens[i] = strlen(saved_key[j]);
319 pin[i] = (unsigned char*)saved_key[j];
320 x.pout[i] = crypt_out[j];
321 ++j;
322 }
323 pbkdf2_sha256_sse((const unsigned char **)pin, lens, cur_salt->salt, strlen((char*)cur_salt->salt), cur_salt->iterations, &(x.poutc), BINARY_SIZE, 0);
324 #else
325 pbkdf2_sha256((const unsigned char*)(saved_key[j]), strlen(saved_key[j]),
326 cur_salt->salt, strlen((char*)cur_salt->salt),
327 cur_salt->iterations, (unsigned char*)crypt_out[j], BINARY_SIZE, 0);
328 ++j;
329 #endif
330 }
331 else {
332 #ifdef SSE_GROUP_SZ_SHA512
333 int lens[SSE_GROUP_SZ_SHA512], i;
334 unsigned char *pin[SSE_GROUP_SZ_SHA512];
335 union {
336 uint32_t *pout[SSE_GROUP_SZ_SHA512];
337 unsigned char *poutc;
338 } x;
339 for (i = 0; i < SSE_GROUP_SZ_SHA512; ++i) {
340 lens[i] = strlen(saved_key[j]);
341 pin[i] = (unsigned char*)saved_key[j];
342 x.pout[i] = crypt_out[j];
343 ++j;
344 }
345 pbkdf2_sha512_sse((const unsigned char **)pin, lens, cur_salt->salt, strlen((char*)cur_salt->salt), cur_salt->iterations, &(x.poutc), BINARY_SIZE, 0);
346 #else
347 pbkdf2_sha512((const unsigned char*)(saved_key[j]), strlen(saved_key[j]),
348 cur_salt->salt, strlen((char*)cur_salt->salt),
349 cur_salt->iterations, (unsigned char*)crypt_out[j], BINARY_SIZE, 0);
350 ++j;
351 #endif
352 }
353 }
354 }
355 return count;
356 }
357
cmp_all(void * binary,int count)358 static int cmp_all(void *binary, int count)
359 {
360 int index;
361
362 // dump_stuff_msg("\nbinary ", binary, CMP_SIZE);
363 for (index = 0; index < count; index++) {
364 // dump_stuff_msg("crypt_out", crypt_out[index], CMP_SIZE);
365 if (!memcmp(binary, crypt_out[index], CMP_SIZE-2))
366 return 1;
367 }
368 return 0;
369 }
370
cmp_one(void * binary,int index)371 static int cmp_one(void *binary, int index)
372 {
373 return !memcmp(binary, crypt_out[index], CMP_SIZE-2);
374 }
375
cmp_exact(char * source,int index)376 static int cmp_exact(char *source, int index)
377 {
378 return 1;
379 }
380
aixssha_set_key(char * key,int index)381 static void aixssha_set_key(char *key, int index)
382 {
383 strnzcpy(saved_key[index], key, sizeof(*saved_key));
384 }
385
get_key(int index)386 static char *get_key(int index)
387 {
388 return saved_key[index];
389 }
390
391 /* report iteration count as tunable cost value */
aixssha_iteration_count(void * salt)392 static unsigned int aixssha_iteration_count(void *salt)
393 {
394 struct custom_salt *my_salt;
395
396 my_salt = salt;
397 return (unsigned int) my_salt->iterations;
398 }
399
400 struct fmt_main fmt_aixssha1 = {
401 {
402 FORMAT_LABEL_SHA1,
403 FORMAT_NAME_SHA1,
404 ALGORITHM_NAME_SHA1,
405 BENCHMARK_COMMENT,
406 BENCHMARK_LENGTH,
407 0,
408 PLAINTEXT_LENGTH,
409 BINARY_SIZE,
410 BINARY_ALIGN,
411 SALT_SIZE,
412 SALT_ALIGN,
413 #ifdef SIMD_COEF_32
414 SSE_GROUP_SZ_SHA1,
415 SSE_GROUP_SZ_SHA1,
416 #else
417 MIN_KEYS_PER_CRYPT,
418 MAX_KEYS_PER_CRYPT,
419 #endif
420 FMT_CASE | FMT_8_BIT | FMT_OMP,
421 {
422 "iteration count",
423 },
424 { FORMAT_TAG1 },
425 aixssha_tests1
426 }, {
427 init,
428 done,
429 fmt_default_reset,
430 fmt_default_prepare,
431 valid_sha1,
432 fmt_default_split,
433 get_binary,
434 get_salt,
435 {
436 aixssha_iteration_count,
437 },
438 fmt_default_source,
439 {
440 fmt_default_binary_hash_0,
441 fmt_default_binary_hash_1,
442 fmt_default_binary_hash_2,
443 fmt_default_binary_hash_3,
444 fmt_default_binary_hash_4,
445 fmt_default_binary_hash_5,
446 fmt_default_binary_hash_6
447 },
448 fmt_default_salt_hash,
449 NULL,
450 set_salt,
451 aixssha_set_key,
452 get_key,
453 fmt_default_clear_keys,
454 crypt_all,
455 {
456 #define COMMON_GET_HASH_LINK
457 #include "common-get-hash.h"
458 },
459 cmp_all,
460 cmp_one,
461 cmp_exact
462 }
463 };
464
465 struct fmt_main fmt_aixssha256 = {
466 {
467 FORMAT_LABEL_SHA256,
468 FORMAT_NAME_SHA256,
469 ALGORITHM_NAME_SHA256,
470 BENCHMARK_COMMENT,
471 BENCHMARK_LENGTH,
472 0,
473 PLAINTEXT_LENGTH,
474 BINARY_SIZE,
475 BINARY_ALIGN,
476 SALT_SIZE,
477 SALT_ALIGN,
478 #ifdef SIMD_COEF_32
479 SSE_GROUP_SZ_SHA256,
480 SSE_GROUP_SZ_SHA256,
481 #else
482 MIN_KEYS_PER_CRYPT,
483 MAX_KEYS_PER_CRYPT,
484 #endif
485 FMT_CASE | FMT_8_BIT | FMT_OMP,
486 {
487 "iteration count",
488 },
489 { FORMAT_TAG256 },
490 aixssha_tests256
491 }, {
492 init,
493 done,
494 fmt_default_reset,
495 fmt_default_prepare,
496 valid_sha256,
497 fmt_default_split,
498 get_binary,
499 get_salt,
500 {
501 aixssha_iteration_count,
502 },
503 fmt_default_source,
504 {
505 fmt_default_binary_hash_0,
506 fmt_default_binary_hash_1,
507 fmt_default_binary_hash_2,
508 fmt_default_binary_hash_3,
509 fmt_default_binary_hash_4,
510 fmt_default_binary_hash_5,
511 fmt_default_binary_hash_6
512 },
513 fmt_default_salt_hash,
514 NULL,
515 set_salt,
516 aixssha_set_key,
517 get_key,
518 fmt_default_clear_keys,
519 crypt_all,
520 {
521 #define COMMON_GET_HASH_LINK
522 #include "common-get-hash.h"
523 },
524 cmp_all,
525 cmp_one,
526 cmp_exact
527 }
528 };
529
530 struct fmt_main fmt_aixssha512 = {
531 {
532 FORMAT_LABEL_SHA512,
533 FORMAT_NAME_SHA512,
534 ALGORITHM_NAME_SHA512,
535 BENCHMARK_COMMENT,
536 BENCHMARK_LENGTH,
537 0,
538 PLAINTEXT_LENGTH,
539 BINARY_SIZE,
540 BINARY_ALIGN,
541 SALT_SIZE,
542 SALT_ALIGN,
543 #ifdef SIMD_COEF_64
544 SSE_GROUP_SZ_SHA512,
545 SSE_GROUP_SZ_SHA512,
546 #else
547 MIN_KEYS_PER_CRYPT,
548 MAX_KEYS_PER_CRYPT,
549 #endif
550 FMT_CASE | FMT_8_BIT | FMT_OMP,
551 {
552 "iteration count",
553 },
554 { FORMAT_TAG512 },
555 aixssha_tests512
556 }, {
557 init,
558 done,
559 fmt_default_reset,
560 fmt_default_prepare,
561 valid_sha512,
562 fmt_default_split,
563 get_binary,
564 get_salt,
565 {
566 aixssha_iteration_count,
567 },
568 fmt_default_source,
569 {
570 fmt_default_binary_hash_0,
571 fmt_default_binary_hash_1,
572 fmt_default_binary_hash_2,
573 fmt_default_binary_hash_3,
574 fmt_default_binary_hash_4,
575 fmt_default_binary_hash_5,
576 fmt_default_binary_hash_6
577 },
578 fmt_default_salt_hash,
579 NULL,
580 set_salt,
581 aixssha_set_key,
582 get_key,
583 fmt_default_clear_keys,
584 crypt_all,
585 {
586 #define COMMON_GET_HASH_LINK
587 #include "common-get-hash.h"
588 },
589 cmp_all,
590 cmp_one,
591 cmp_exact
592 }
593 };
594
595 #endif /* plugin stanza */
596