RTEMS-6
Annotated Report
libcrypt
Sun Feb 28 23:30:06 2021
001026d0 <_crypt_b64_from_24bit>:
void
b64_from_24bit(uint8_t B2, uint8_t B1, uint8_t B0, int n, int *buflen, char **cp)
{
1026d0: 55 push %ebp
1026d1: 89 e5 mov %esp,%ebp
1026d3: 57 push %edi
1026d4: 56 push %esi
1026d5: 53 push %ebx
1026d6: 83 ec 04 sub $0x4,%esp
uint32_t w;
int i;
#if defined(__rtems__)
w = ((uint32_t)B2 << 16) | ((uint32_t)B1 << 8) | B0;
1026d9: 0f b6 55 0c movzbl 0xc(%ebp),%edx
1026dd: 0f b6 45 10 movzbl 0x10(%ebp),%eax
#else
w = (B2 << 16) | (B1 << 8) | B0;
#endif
for (i = 0; i < n; i++) {
1026e1: 8b 4d 14 mov 0x14(%ebp),%ecx
{
1026e4: 8b 75 18 mov 0x18(%ebp),%esi
w = ((uint32_t)B2 << 16) | ((uint32_t)B1 << 8) | B0;
1026e7: c1 e2 08 shl $0x8,%edx
{
1026ea: 8b 5d 1c mov 0x1c(%ebp),%ebx
w = ((uint32_t)B2 << 16) | ((uint32_t)B1 << 8) | B0;
1026ed: 09 c2 or %eax,%edx
1026ef: 0f b6 45 08 movzbl 0x8(%ebp),%eax
1026f3: c1 e0 10 shl $0x10,%eax
1026f6: 09 c2 or %eax,%edx
for (i = 0; i < n; i++) {
1026f8: 85 c9 test %ecx,%ecx
1026fa: 7e 40 jle 10273c <_crypt_b64_from_24bit+0x6c> <== NEVER TAKEN
1026fc: 31 ff xor %edi,%edi
**cp = itoa64[w&0x3f];
1026fe: 8b 03 mov (%ebx),%eax
for (i = 0; i < n; i++) {
102700: 89 7d f0 mov %edi,-0x10(%ebp)
102703: eb 19 jmp 10271e <_crypt_b64_from_24bit+0x4e>
102705: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10270c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
102710: ff 45 f0 incl -0x10(%ebp)
(*cp)++;
if ((*buflen)-- < 0)
break;
w >>= 6;
102713: c1 ea 06 shr $0x6,%edx
for (i = 0; i < n; i++) {
102716: 8b 7d f0 mov -0x10(%ebp),%edi
102719: 39 7d 14 cmp %edi,0x14(%ebp)
10271c: 74 1e je 10273c <_crypt_b64_from_24bit+0x6c>
**cp = itoa64[w&0x3f];
10271e: 89 d1 mov %edx,%ecx
102720: 83 e1 3f and $0x3f,%ecx
102723: 0f b6 89 00 f6 12 00 movzbl 0x12f600(%ecx),%ecx
10272a: 88 08 mov %cl,(%eax)
(*cp)++;
10272c: 8b 03 mov (%ebx),%eax
if ((*buflen)-- < 0)
10272e: 8b 0e mov (%esi),%ecx
(*cp)++;
102730: 40 inc %eax
102731: 89 03 mov %eax,(%ebx)
if ((*buflen)-- < 0)
102733: 8d 79 ff lea -0x1(%ecx),%edi
102736: 85 c9 test %ecx,%ecx
102738: 89 3e mov %edi,(%esi)
10273a: 79 d4 jns 102710 <_crypt_b64_from_24bit+0x40> <== ALWAYS TAKEN
}
}
10273c: 58 pop %eax
10273d: 5b pop %ebx
10273e: 5e pop %esi
10273f: 5f pop %edi
102740: 5d pop %ebp
102741: c3 ret
102742: 90 nop
102743: 90 nop
102744: 90 nop
102745: 90 nop
102746: 90 nop
102747: 90 nop
102748: 90 nop
102749: 90 nop
10274a: 90 nop
10274b: 90 nop
10274c: 90 nop
10274d: 90 nop
10274e: 90 nop
10274f: 90 nop
00102690 <_crypt_to64>:
static const char itoa64[] = /* 0 ... 63 => ascii - 64 */
"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
void
_crypt_to64(char *s, u_long v, int n)
{
102690: 55 push %ebp
102691: 89 e5 mov %esp,%ebp
102693: 53 push %ebx
102694: 8b 5d 10 mov 0x10(%ebp),%ebx
102697: 8b 45 08 mov 0x8(%ebp),%eax
10269a: 8b 55 0c mov 0xc(%ebp),%edx
while (--n >= 0) {
10269d: 85 db test %ebx,%ebx
10269f: 7e 26 jle 1026c7 <_crypt_to64+0x37> <== NEVER TAKEN
1026a1: 01 c3 add %eax,%ebx
1026a3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1026aa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
*s++ = itoa64[v&0x3f];
1026b0: 89 d1 mov %edx,%ecx
1026b2: 40 inc %eax
v >>= 6;
1026b3: c1 ea 06 shr $0x6,%edx
*s++ = itoa64[v&0x3f];
1026b6: 83 e1 3f and $0x3f,%ecx
1026b9: 0f b6 89 00 f6 12 00 movzbl 0x12f600(%ecx),%ecx
while (--n >= 0) {
1026c0: 39 c3 cmp %eax,%ebx
*s++ = itoa64[v&0x3f];
1026c2: 88 48 ff mov %cl,-0x1(%eax)
while (--n >= 0) {
1026c5: 75 e9 jne 1026b0 <_crypt_to64+0x20>
}
}
1026c7: 5b pop %ebx
1026c8: 5d pop %ebp
1026c9: c3 ret
1026ca: 90 nop
1026cb: 90 nop
1026cc: 90 nop
1026cd: 90 nop
1026ce: 90 nop
1026cf: 90 nop
00100780 <crypt_add_format>:
static SLIST_HEAD(, crypt_format) cf_head = {
&cf_default
};
void crypt_add_format(struct crypt_format *cf)
{
100780: 55 push %ebp
100781: 89 e5 mov %esp,%ebp
100783: 8b 45 08 mov 0x8(%ebp),%eax
if (cf->link.sle_next == NULL)
100786: 8b 10 mov (%eax),%edx
100788: 85 d2 test %edx,%edx
10078a: 74 04 je 100790 <crypt_add_format+0x10> <== ALWAYS TAKEN
SLIST_INSERT_HEAD(&cf_head, cf, link);
}
10078c: 5d pop %ebp <== NOT EXECUTED
10078d: c3 ret <== NOT EXECUTED
10078e: 66 90 xchg %ax,%ax <== NOT EXECUTED
SLIST_INSERT_HEAD(&cf_head, cf, link);
100790: 8b 15 9c 4a 13 00 mov 0x134a9c,%edx
100796: a3 9c 4a 13 00 mov %eax,0x134a9c
10079b: 89 10 mov %edx,(%eax)
}
10079d: 5d pop %ebp
10079e: c3 ret
10079f: 90 nop
00100830 <crypt_md5_r>:
* UNIX password
*/
char *
crypt_md5_r(const char *pw, const char *salt, struct crypt_data *data)
{
100830: 55 push %ebp
100831: 89 e5 mov %esp,%ebp
100833: 57 push %edi
100834: 56 push %esi
100835: 53 push %ebx
100836: 81 ec 0c 01 00 00 sub $0x10c,%esp
/* Refine the Salt first */
sp = salt;
/* If it starts with the magic string, then skip that */
if(!strncmp(sp, magic, strlen(magic)))
10083c: 8b 45 0c mov 0xc(%ebp),%eax
{
10083f: 8b 7d 08 mov 0x8(%ebp),%edi
if(!strncmp(sp, magic, strlen(magic)))
100842: 80 38 24 cmpb $0x24,(%eax)
100845: 75 19 jne 100860 <crypt_md5_r+0x30> <== NEVER TAKEN
100847: 80 78 01 31 cmpb $0x31,0x1(%eax)
10084b: 0f 84 96 04 00 00 je 100ce7 <crypt_md5_r+0x4b7> <== ALWAYS TAKEN
100851: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
100858: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10085f: 90 nop
sp += strlen(magic);
/* It stops at the first '$', max 8 chars */
for(ep = sp; *ep && *ep != '$' && ep < (sp + 8); ep++)
100860: 8b 45 0c mov 0xc(%ebp),%eax
100863: 0f b6 00 movzbl (%eax),%eax
100866: 3c 24 cmp $0x24,%al
100868: 0f 84 8c 04 00 00 je 100cfa <crypt_md5_r+0x4ca> <== NEVER TAKEN
10086e: 84 c0 test %al,%al
100870: 0f 84 84 04 00 00 je 100cfa <crypt_md5_r+0x4ca> <== NEVER TAKEN
100876: 8b 45 0c mov 0xc(%ebp),%eax
100879: 8d 48 08 lea 0x8(%eax),%ecx
10087c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
100880: 0f b6 50 01 movzbl 0x1(%eax),%edx
100884: 40 inc %eax
100885: 84 d2 test %dl,%dl
100887: 74 09 je 100892 <crypt_md5_r+0x62>
100889: 80 fa 24 cmp $0x24,%dl
10088c: 74 04 je 100892 <crypt_md5_r+0x62>
10088e: 39 c8 cmp %ecx,%eax
100890: 75 ee jne 100880 <crypt_md5_r+0x50> <== ALWAYS TAKEN
continue;
/* get the length of the true salt */
sl = ep - sp;
100892: 8b 5d 0c mov 0xc(%ebp),%ebx
100895: 29 d8 sub %ebx,%eax
100897: 89 85 00 ff ff ff mov %eax,-0x100(%ebp)
MD5Init(&ctx);
10089d: 8d 9d 18 ff ff ff lea -0xe8(%ebp),%ebx
1008a3: 89 1c 24 mov %ebx,(%esp)
/* Then the raw salt */
MD5Update(&ctx, (const u_char *)sp, (u_int)sl);
/* Then just as many characters of the MD5(pw,salt,pw) */
MD5Init(&ctx1);
1008a6: 8d 75 80 lea -0x80(%ebp),%esi
MD5Init(&ctx);
1008a9: e8 22 5d 00 00 call 1065d0 <MD5Init>
MD5Update(&ctx, (const u_char *)pw, strlen(pw));
1008ae: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
1008b1: e8 5a 7a 02 00 call 128310 <strlen> <== NOT EXECUTED
1008b6: 89 7c 24 04 mov %edi,0x4(%esp)
1008ba: 89 1c 24 mov %ebx,(%esp)
1008bd: 89 44 24 08 mov %eax,0x8(%esp)
1008c1: e8 4a 5d 00 00 call 106610 <MD5Update>
MD5Update(&ctx, (const u_char *)magic, strlen(magic));
1008c6: ba bc f5 12 00 mov $0x12f5bc,%edx
1008cb: b8 03 00 00 00 mov $0x3,%eax
1008d0: 89 54 24 04 mov %edx,0x4(%esp)
1008d4: 89 44 24 08 mov %eax,0x8(%esp)
1008d8: 89 1c 24 mov %ebx,(%esp)
1008db: e8 30 5d 00 00 call 106610 <MD5Update>
MD5Update(&ctx, (const u_char *)sp, (u_int)sl);
1008e0: 8b 4d 0c mov 0xc(%ebp),%ecx
1008e3: 89 1c 24 mov %ebx,(%esp)
1008e6: 8b 85 00 ff ff ff mov -0x100(%ebp),%eax
1008ec: 89 4c 24 04 mov %ecx,0x4(%esp)
1008f0: 89 44 24 08 mov %eax,0x8(%esp)
1008f4: e8 17 5d 00 00 call 106610 <MD5Update>
MD5Init(&ctx1);
1008f9: 89 34 24 mov %esi,(%esp)
1008fc: e8 cf 5c 00 00 call 1065d0 <MD5Init>
MD5Update(&ctx1, (const u_char *)pw, strlen(pw));
100901: 89 3c 24 mov %edi,(%esp)
100904: e8 07 7a 02 00 call 128310 <strlen>
100909: 89 7c 24 04 mov %edi,0x4(%esp)
10090d: 89 34 24 mov %esi,(%esp)
100910: 89 44 24 08 mov %eax,0x8(%esp)
100914: e8 f7 5c 00 00 call 106610 <MD5Update>
MD5Update(&ctx1, (const u_char *)sp, (u_int)sl);
100919: 8b 85 00 ff ff ff mov -0x100(%ebp),%eax
10091f: 89 34 24 mov %esi,(%esp)
100922: 89 44 24 08 mov %eax,0x8(%esp)
100926: 8b 45 0c mov 0xc(%ebp),%eax
100929: 89 44 24 04 mov %eax,0x4(%esp)
10092d: e8 de 5c 00 00 call 106610 <MD5Update>
MD5Update(&ctx1, (const u_char *)pw, strlen(pw));
100932: 89 3c 24 mov %edi,(%esp)
100935: e8 d6 79 02 00 call 128310 <strlen>
10093a: 89 7c 24 04 mov %edi,0x4(%esp)
10093e: 89 34 24 mov %esi,(%esp)
100941: 89 44 24 08 mov %eax,0x8(%esp)
100945: e8 c6 5c 00 00 call 106610 <MD5Update>
MD5Final(final, &ctx1);
10094a: 8d 85 08 ff ff ff lea -0xf8(%ebp),%eax
100950: 89 04 24 mov %eax,(%esp)
100953: 89 74 24 04 mov %esi,0x4(%esp)
100957: e8 94 5d 00 00 call 1066f0 <MD5Final>
for(pl = (int)strlen(pw); pl > 0; pl -= MD5_SIZE)
10095c: 89 3c 24 mov %edi,(%esp)
10095f: e8 ac 79 02 00 call 128310 <strlen>
100964: 85 c0 test %eax,%eax
100966: 74 34 je 10099c <crypt_md5_r+0x16c> <== NEVER TAKEN
100968: 89 7d 08 mov %edi,0x8(%ebp)
10096b: 89 c7 mov %eax,%edi
10096d: 8d 76 00 lea 0x0(%esi),%esi
MD5Update(&ctx, (const u_char *)final,
(u_int)(pl > MD5_SIZE ? MD5_SIZE : pl));
100970: 83 ff 10 cmp $0x10,%edi
100973: 89 f8 mov %edi,%eax
100975: 7e 05 jle 10097c <crypt_md5_r+0x14c> <== ALWAYS TAKEN
100977: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED
MD5Update(&ctx, (const u_char *)final,
10097c: 89 44 24 08 mov %eax,0x8(%esp)
100980: 8d 85 08 ff ff ff lea -0xf8(%ebp),%eax
for(pl = (int)strlen(pw); pl > 0; pl -= MD5_SIZE)
100986: 83 ef 10 sub $0x10,%edi
MD5Update(&ctx, (const u_char *)final,
100989: 89 44 24 04 mov %eax,0x4(%esp)
10098d: 89 1c 24 mov %ebx,(%esp)
100990: e8 7b 5c 00 00 call 106610 <MD5Update>
for(pl = (int)strlen(pw); pl > 0; pl -= MD5_SIZE)
100995: 85 ff test %edi,%edi
100997: 7f d7 jg 100970 <crypt_md5_r+0x140> <== NEVER TAKEN
100999: 8b 7d 08 mov 0x8(%ebp),%edi
/* Don't leave anything around in vm they could use. */
memset(final, 0, sizeof(final));
/* Then something really weird... */
for (i = strlen(pw); i; i >>= 1)
10099c: 89 3c 24 mov %edi,(%esp)
memset(final, 0, sizeof(final));
10099f: 31 c0 xor %eax,%eax
1009a1: 89 85 08 ff ff ff mov %eax,-0xf8(%ebp)
1009a7: 31 c0 xor %eax,%eax
1009a9: 89 85 0c ff ff ff mov %eax,-0xf4(%ebp)
1009af: 31 c0 xor %eax,%eax
1009b1: 89 85 10 ff ff ff mov %eax,-0xf0(%ebp)
1009b7: 31 c0 xor %eax,%eax
1009b9: 89 85 14 ff ff ff mov %eax,-0xec(%ebp)
for (i = strlen(pw); i; i >>= 1)
1009bf: e8 4c 79 02 00 call 128310 <strlen>
1009c4: 85 c0 test %eax,%eax
1009c6: 74 45 je 100a0d <crypt_md5_r+0x1dd> <== NEVER TAKEN
1009c8: 89 7d 08 mov %edi,0x8(%ebp)
1009cb: 89 c7 mov %eax,%edi
1009cd: eb 17 jmp 1009e6 <crypt_md5_r+0x1b6>
1009cf: 90 nop
if(i & 1)
MD5Update(&ctx, (const u_char *)final, 1);
1009d0: 89 1c 24 mov %ebx,(%esp)
1009d3: 8d 85 08 ff ff ff lea -0xf8(%ebp),%eax
1009d9: 89 44 24 04 mov %eax,0x4(%esp)
1009dd: e8 2e 5c 00 00 call 106610 <MD5Update>
for (i = strlen(pw); i; i >>= 1)
1009e2: d1 ef shr %edi
1009e4: 74 24 je 100a0a <crypt_md5_r+0x1da>
MD5Update(&ctx, (const u_char *)final, 1);
1009e6: b9 01 00 00 00 mov $0x1,%ecx
if(i & 1)
1009eb: f7 c7 01 00 00 00 test $0x1,%edi
MD5Update(&ctx, (const u_char *)final, 1);
1009f1: 89 4c 24 08 mov %ecx,0x8(%esp)
if(i & 1)
1009f5: 75 d9 jne 1009d0 <crypt_md5_r+0x1a0>
else
MD5Update(&ctx, (const u_char *)pw, 1);
1009f7: 89 1c 24 mov %ebx,(%esp)
1009fa: 8b 45 08 mov 0x8(%ebp),%eax
1009fd: 89 44 24 04 mov %eax,0x4(%esp)
100a01: e8 0a 5c 00 00 call 106610 <MD5Update>
for (i = strlen(pw); i; i >>= 1)
100a06: d1 ef shr %edi
100a08: 75 dc jne 1009e6 <crypt_md5_r+0x1b6> <== ALWAYS TAKEN
100a0a: 8b 7d 08 mov 0x8(%ebp),%edi
/* Now make the output string */
strcpy(passwd, magic);
100a0d: 8b 4d 10 mov 0x10(%ebp),%ecx
100a10: a1 bc f5 12 00 mov 0x12f5bc,%eax
100a15: 89 01 mov %eax,(%ecx)
strncat(passwd, sp, (u_int)sl);
100a17: 8b 85 00 ff ff ff mov -0x100(%ebp),%eax
100a1d: 89 0c 24 mov %ecx,(%esp)
100a20: 89 44 24 08 mov %eax,0x8(%esp)
100a24: 8b 45 0c mov 0xc(%ebp),%eax
100a27: 89 44 24 04 mov %eax,0x4(%esp)
100a2b: e8 60 79 02 00 call 128390 <strncat>
strcat(passwd, "$");
100a30: 8b 45 10 mov 0x10(%ebp),%eax
100a33: 89 04 24 mov %eax,(%esp)
100a36: e8 d5 78 02 00 call 128310 <strlen>
100a3b: 8b 4d 10 mov 0x10(%ebp),%ecx
100a3e: 66 c7 04 01 24 00 movw $0x24,(%ecx,%eax,1)
MD5Final(final, &ctx);
100a44: 8d 85 08 ff ff ff lea -0xf8(%ebp),%eax
100a4a: 89 5c 24 04 mov %ebx,0x4(%esp)
/*
* and now, just to make sure things don't run too fast
* On a 60 Mhz Pentium this takes 34 msec, so you would
* need 30 seconds to build a 1000 entry dictionary...
*/
for(i = 0; i < 1000; i++) {
100a4e: 31 db xor %ebx,%ebx
MD5Final(final, &ctx);
100a50: 89 04 24 mov %eax,(%esp)
100a53: e8 98 5c 00 00 call 1066f0 <MD5Final>
for(i = 0; i < 1000; i++) {
100a58: e9 85 00 00 00 jmp 100ae2 <crypt_md5_r+0x2b2>
100a5d: 8d 76 00 lea 0x0(%esi),%esi
MD5Init(&ctx1);
if(i & 1)
MD5Update(&ctx1, (const u_char *)pw, strlen(pw));
100a60: 89 3c 24 mov %edi,(%esp)
100a63: e8 a8 78 02 00 call 128310 <strlen>
100a68: 89 7c 24 04 mov %edi,0x4(%esp)
100a6c: 89 34 24 mov %esi,(%esp)
100a6f: 89 44 24 08 mov %eax,0x8(%esp)
100a73: e8 98 5b 00 00 call 106610 <MD5Update>
else
MD5Update(&ctx1, (const u_char *)final, MD5_SIZE);
100a78: 69 c3 ab aa aa aa imul $0xaaaaaaab,%ebx,%eax
if(i % 3)
100a7e: 3d 55 55 55 55 cmp $0x55555555,%eax
100a83: 0f 87 9e 00 00 00 ja 100b27 <crypt_md5_r+0x2f7>
MD5Update(&ctx1, (const u_char *)sp, (u_int)sl);
100a89: 69 c3 b7 6d db b6 imul $0xb6db6db7,%ebx,%eax
if(i % 7)
100a8f: 3d 24 49 92 24 cmp $0x24924924,%eax
100a94: 0f 87 b7 00 00 00 ja 100b51 <crypt_md5_r+0x321>
MD5Update(&ctx1, (const u_char *)pw, strlen(pw));
if(i & 1)
100a9a: 8b 85 04 ff ff ff mov -0xfc(%ebp),%eax
100aa0: 85 c0 test %eax,%eax
100aa2: 0f 84 cf 00 00 00 je 100b77 <crypt_md5_r+0x347>
MD5Update(&ctx1, (const u_char *)final, MD5_SIZE);
100aa8: 89 34 24 mov %esi,(%esp)
100aab: b8 10 00 00 00 mov $0x10,%eax
100ab0: 89 44 24 08 mov %eax,0x8(%esp)
100ab4: 8d 85 08 ff ff ff lea -0xf8(%ebp),%eax
100aba: 89 44 24 04 mov %eax,0x4(%esp)
100abe: e8 4d 5b 00 00 call 106610 <MD5Update>
else
MD5Update(&ctx1, (const u_char *)pw, strlen(pw));
MD5Final(final, &ctx1);
100ac3: 89 74 24 04 mov %esi,0x4(%esp)
100ac7: 8d 85 08 ff ff ff lea -0xf8(%ebp),%eax
for(i = 0; i < 1000; i++) {
100acd: 43 inc %ebx
MD5Final(final, &ctx1);
100ace: 89 04 24 mov %eax,(%esp)
100ad1: e8 1a 5c 00 00 call 1066f0 <MD5Final>
for(i = 0; i < 1000; i++) {
100ad6: 81 fb e8 03 00 00 cmp $0x3e8,%ebx
100adc: 0f 84 b2 00 00 00 je 100b94 <crypt_md5_r+0x364>
MD5Init(&ctx1);
100ae2: 89 34 24 mov %esi,(%esp)
100ae5: e8 e6 5a 00 00 call 1065d0 <MD5Init>
if(i & 1)
100aea: 89 d8 mov %ebx,%eax
100aec: 83 e0 01 and $0x1,%eax
100aef: 89 85 04 ff ff ff mov %eax,-0xfc(%ebp)
100af5: 0f 85 65 ff ff ff jne 100a60 <crypt_md5_r+0x230>
MD5Update(&ctx1, (const u_char *)final, MD5_SIZE);
100afb: 89 34 24 mov %esi,(%esp)
100afe: 8d 85 08 ff ff ff lea -0xf8(%ebp),%eax
100b04: ba 10 00 00 00 mov $0x10,%edx
100b09: 89 44 24 04 mov %eax,0x4(%esp)
100b0d: 89 54 24 08 mov %edx,0x8(%esp)
100b11: e8 fa 5a 00 00 call 106610 <MD5Update>
100b16: 69 c3 ab aa aa aa imul $0xaaaaaaab,%ebx,%eax
if(i % 3)
100b1c: 3d 55 55 55 55 cmp $0x55555555,%eax
100b21: 0f 86 62 ff ff ff jbe 100a89 <crypt_md5_r+0x259>
MD5Update(&ctx1, (const u_char *)sp, (u_int)sl);
100b27: 89 34 24 mov %esi,(%esp)
100b2a: 8b 85 00 ff ff ff mov -0x100(%ebp),%eax
100b30: 89 44 24 08 mov %eax,0x8(%esp)
100b34: 8b 45 0c mov 0xc(%ebp),%eax
100b37: 89 44 24 04 mov %eax,0x4(%esp)
100b3b: e8 d0 5a 00 00 call 106610 <MD5Update>
100b40: 69 c3 b7 6d db b6 imul $0xb6db6db7,%ebx,%eax
if(i % 7)
100b46: 3d 24 49 92 24 cmp $0x24924924,%eax
100b4b: 0f 86 49 ff ff ff jbe 100a9a <crypt_md5_r+0x26a>
MD5Update(&ctx1, (const u_char *)pw, strlen(pw));
100b51: 89 3c 24 mov %edi,(%esp)
100b54: e8 b7 77 02 00 call 128310 <strlen>
100b59: 89 7c 24 04 mov %edi,0x4(%esp)
100b5d: 89 34 24 mov %esi,(%esp)
100b60: 89 44 24 08 mov %eax,0x8(%esp)
100b64: e8 a7 5a 00 00 call 106610 <MD5Update>
if(i & 1)
100b69: 8b 85 04 ff ff ff mov -0xfc(%ebp),%eax
100b6f: 85 c0 test %eax,%eax
100b71: 0f 85 31 ff ff ff jne 100aa8 <crypt_md5_r+0x278>
MD5Update(&ctx1, (const u_char *)pw, strlen(pw));
100b77: 89 3c 24 mov %edi,(%esp)
100b7a: e8 91 77 02 00 call 128310 <strlen>
100b7f: 89 7c 24 04 mov %edi,0x4(%esp)
100b83: 89 34 24 mov %esi,(%esp)
100b86: 89 44 24 08 mov %eax,0x8(%esp)
100b8a: e8 81 5a 00 00 call 106610 <MD5Update>
100b8f: e9 2f ff ff ff jmp 100ac3 <crypt_md5_r+0x293>
}
p = passwd + strlen(passwd);
100b94: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
l = (final[ 0]<<16) | (final[ 6]<<8) | final[12];
_crypt_to64(p, l, 4); p += 4;
l = (final[ 1]<<16) | (final[ 7]<<8) | final[13];
_crypt_to64(p, l, 4); p += 4;
100b97: be 04 00 00 00 mov $0x4,%esi <== NOT EXECUTED
l = (final[ 2]<<16) | (final[ 8]<<8) | final[14];
_crypt_to64(p, l, 4); p += 4;
100b9c: bf 04 00 00 00 mov $0x4,%edi <== NOT EXECUTED
p = passwd + strlen(passwd);
100ba1: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
100ba4: e8 67 77 02 00 call 128310 <strlen> <== NOT EXECUTED
100ba9: 8b 55 10 mov 0x10(%ebp),%edx
_crypt_to64(p, l, 4); p += 4;
100bac: b9 04 00 00 00 mov $0x4,%ecx
100bb1: 89 4c 24 08 mov %ecx,0x8(%esp)
p = passwd + strlen(passwd);
100bb5: 01 d0 add %edx,%eax
l = (final[ 0]<<16) | (final[ 6]<<8) | final[12];
100bb7: 0f b6 95 0e ff ff ff movzbl -0xf2(%ebp),%edx
p = passwd + strlen(passwd);
100bbe: 89 c3 mov %eax,%ebx
l = (final[ 0]<<16) | (final[ 6]<<8) | final[12];
100bc0: 0f b6 85 08 ff ff ff movzbl -0xf8(%ebp),%eax
_crypt_to64(p, l, 4); p += 4;
100bc7: 89 1c 24 mov %ebx,(%esp)
l = (final[ 0]<<16) | (final[ 6]<<8) | final[12];
100bca: c1 e2 08 shl $0x8,%edx
100bcd: c1 e0 10 shl $0x10,%eax
100bd0: 09 d0 or %edx,%eax
100bd2: 0f b6 95 14 ff ff ff movzbl -0xec(%ebp),%edx
100bd9: 09 d0 or %edx,%eax
_crypt_to64(p, l, 4); p += 4;
100bdb: 89 44 24 04 mov %eax,0x4(%esp)
100bdf: e8 ac 1a 00 00 call 102690 <_crypt_to64>
l = (final[ 1]<<16) | (final[ 7]<<8) | final[13];
100be4: 0f b6 85 09 ff ff ff movzbl -0xf7(%ebp),%eax
_crypt_to64(p, l, 4); p += 4;
100beb: 89 74 24 08 mov %esi,0x8(%esp)
l = (final[ 1]<<16) | (final[ 7]<<8) | final[13];
100bef: 0f b6 95 0f ff ff ff movzbl -0xf1(%ebp),%edx
100bf6: c1 e0 10 shl $0x10,%eax
100bf9: c1 e2 08 shl $0x8,%edx
100bfc: 09 d0 or %edx,%eax
100bfe: 0f b6 95 15 ff ff ff movzbl -0xeb(%ebp),%edx
100c05: 09 d0 or %edx,%eax
_crypt_to64(p, l, 4); p += 4;
100c07: 89 44 24 04 mov %eax,0x4(%esp)
_crypt_to64(p, l, 4); p += 4;
100c0b: 8d 43 04 lea 0x4(%ebx),%eax
_crypt_to64(p, l, 4); p += 4;
100c0e: 89 04 24 mov %eax,(%esp)
100c11: e8 7a 1a 00 00 call 102690 <_crypt_to64>
l = (final[ 2]<<16) | (final[ 8]<<8) | final[14];
100c16: 0f b6 85 0a ff ff ff movzbl -0xf6(%ebp),%eax
_crypt_to64(p, l, 4); p += 4;
100c1d: 89 7c 24 08 mov %edi,0x8(%esp)
l = (final[ 2]<<16) | (final[ 8]<<8) | final[14];
100c21: 0f b6 95 10 ff ff ff movzbl -0xf0(%ebp),%edx
100c28: c1 e0 10 shl $0x10,%eax
100c2b: c1 e2 08 shl $0x8,%edx
100c2e: 09 d0 or %edx,%eax
100c30: 0f b6 95 16 ff ff ff movzbl -0xea(%ebp),%edx
100c37: 09 d0 or %edx,%eax
_crypt_to64(p, l, 4); p += 4;
100c39: 89 44 24 04 mov %eax,0x4(%esp)
_crypt_to64(p, l, 4); p += 4;
100c3d: 8d 43 08 lea 0x8(%ebx),%eax
_crypt_to64(p, l, 4); p += 4;
100c40: 89 04 24 mov %eax,(%esp)
100c43: e8 48 1a 00 00 call 102690 <_crypt_to64>
l = (final[ 3]<<16) | (final[ 9]<<8) | final[15];
_crypt_to64(p, l, 4); p += 4;
100c48: b8 04 00 00 00 mov $0x4,%eax
l = (final[ 3]<<16) | (final[ 9]<<8) | final[15];
100c4d: 0f b6 95 11 ff ff ff movzbl -0xef(%ebp),%edx
_crypt_to64(p, l, 4); p += 4;
100c54: 89 44 24 08 mov %eax,0x8(%esp)
l = (final[ 3]<<16) | (final[ 9]<<8) | final[15];
100c58: 0f b6 85 0b ff ff ff movzbl -0xf5(%ebp),%eax
100c5f: c1 e2 08 shl $0x8,%edx
100c62: c1 e0 10 shl $0x10,%eax
100c65: 09 d0 or %edx,%eax
100c67: 0f b6 95 17 ff ff ff movzbl -0xe9(%ebp),%edx
100c6e: 09 d0 or %edx,%eax
_crypt_to64(p, l, 4); p += 4;
100c70: 89 44 24 04 mov %eax,0x4(%esp)
_crypt_to64(p, l, 4); p += 4;
100c74: 8d 43 0c lea 0xc(%ebx),%eax
_crypt_to64(p, l, 4); p += 4;
100c77: 89 04 24 mov %eax,(%esp)
100c7a: e8 11 1a 00 00 call 102690 <_crypt_to64>
l = (final[ 4]<<16) | (final[10]<<8) | final[ 5];
_crypt_to64(p, l, 4); p += 4;
100c7f: b8 04 00 00 00 mov $0x4,%eax
l = (final[ 4]<<16) | (final[10]<<8) | final[ 5];
100c84: 0f b6 95 12 ff ff ff movzbl -0xee(%ebp),%edx
_crypt_to64(p, l, 4); p += 4;
100c8b: 89 44 24 08 mov %eax,0x8(%esp)
l = (final[ 4]<<16) | (final[10]<<8) | final[ 5];
100c8f: 0f b6 85 0c ff ff ff movzbl -0xf4(%ebp),%eax
100c96: c1 e2 08 shl $0x8,%edx
100c99: c1 e0 10 shl $0x10,%eax
100c9c: 09 d0 or %edx,%eax
100c9e: 0f b6 95 0d ff ff ff movzbl -0xf3(%ebp),%edx
100ca5: 09 d0 or %edx,%eax
_crypt_to64(p, l, 4); p += 4;
100ca7: 89 44 24 04 mov %eax,0x4(%esp)
_crypt_to64(p, l, 4); p += 4;
100cab: 8d 43 10 lea 0x10(%ebx),%eax
_crypt_to64(p, l, 4); p += 4;
100cae: 89 04 24 mov %eax,(%esp)
100cb1: e8 da 19 00 00 call 102690 <_crypt_to64>
l = final[11];
_crypt_to64(p, l, 2); p += 2;
100cb6: b8 02 00 00 00 mov $0x2,%eax
100cbb: 89 44 24 08 mov %eax,0x8(%esp)
l = final[11];
100cbf: 0f b6 85 13 ff ff ff movzbl -0xed(%ebp),%eax
100cc6: 89 44 24 04 mov %eax,0x4(%esp)
_crypt_to64(p, l, 4); p += 4;
100cca: 8d 43 14 lea 0x14(%ebx),%eax
_crypt_to64(p, l, 2); p += 2;
100ccd: 89 04 24 mov %eax,(%esp)
100cd0: e8 bb 19 00 00 call 102690 <_crypt_to64>
/* Don't leave anything around in vm they could use. */
memset(final, 0, sizeof(final));
return (passwd);
}
100cd5: 8b 45 10 mov 0x10(%ebp),%eax
*p = '\0';
100cd8: c6 43 16 00 movb $0x0,0x16(%ebx)
}
100cdc: 81 c4 0c 01 00 00 add $0x10c,%esp
100ce2: 5b pop %ebx
100ce3: 5e pop %esi
100ce4: 5f pop %edi
100ce5: 5d pop %ebp
100ce6: c3 ret
if(!strncmp(sp, magic, strlen(magic)))
100ce7: 80 78 02 24 cmpb $0x24,0x2(%eax)
100ceb: 0f 85 6f fb ff ff jne 100860 <crypt_md5_r+0x30> <== NEVER TAKEN
sp += strlen(magic);
100cf1: 83 45 0c 03 addl $0x3,0xc(%ebp)
100cf5: e9 66 fb ff ff jmp 100860 <crypt_md5_r+0x30>
for(ep = sp; *ep && *ep != '$' && ep < (sp + 8); ep++)
100cfa: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
100cfc: 89 8d 00 ff ff ff mov %ecx,-0x100(%ebp) <== NOT EXECUTED
100d02: e9 96 fb ff ff jmp 10089d <crypt_md5_r+0x6d> <== NOT EXECUTED
100d07: 90 nop
100d08: 90 nop
100d09: 90 nop
100d0a: 90 nop
100d0b: 90 nop
100d0c: 90 nop
100d0d: 90 nop
100d0e: 90 nop
100d0f: 90 nop
001007a0 <crypt_r>:
char *
crypt_r(const char *passwd, const char *salt, struct crypt_data *data)
{
1007a0: 55 push %ebp
1007a1: 89 e5 mov %esp,%ebp
1007a3: 57 push %edi
1007a4: 56 push %esi
1007a5: 53 push %ebx
1007a6: 83 ec 2c sub $0x2c,%esp
1007a9: 8b 45 08 mov 0x8(%ebp),%eax
const struct crypt_format *cf;
SLIST_FOREACH(cf, &cf_head, link)
1007ac: 8b 1d 9c 4a 13 00 mov 0x134a9c,%ebx
{
1007b2: 8b 75 0c mov 0xc(%ebp),%esi
1007b5: 89 45 e4 mov %eax,-0x1c(%ebp)
1007b8: 8b 45 10 mov 0x10(%ebp),%eax
SLIST_FOREACH(cf, &cf_head, link)
1007bb: 85 db test %ebx,%ebx
{
1007bd: 89 45 e0 mov %eax,-0x20(%ebp)
SLIST_FOREACH(cf, &cf_head, link)
1007c0: 74 2b je 1007ed <crypt_r+0x4d> <== NEVER TAKEN
1007c2: 89 df mov %ebx,%edi
1007c4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1007cb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
1007cf: 90 nop
if (cf->magic != NULL && strstr(salt, cf->magic) == salt)
1007d0: 8b 47 08 mov 0x8(%edi),%eax
1007d3: 85 c0 test %eax,%eax
1007d5: 74 10 je 1007e7 <crypt_r+0x47>
1007d7: 89 44 24 04 mov %eax,0x4(%esp)
1007db: 89 34 24 mov %esi,(%esp)
1007de: e8 8d 82 02 00 call 128a70 <strstr>
1007e3: 39 c6 cmp %eax,%esi
1007e5: 74 29 je 100810 <crypt_r+0x70>
SLIST_FOREACH(cf, &cf_head, link)
1007e7: 8b 3f mov (%edi),%edi
1007e9: 85 ff test %edi,%edi
1007eb: 75 e3 jne 1007d0 <crypt_r+0x30>
return (cf->func(passwd, salt, data));
cf = SLIST_FIRST(&cf_head);
return (cf->func(passwd, salt, data));
1007ed: 89 75 0c mov %esi,0xc(%ebp)
1007f0: 8b 45 e0 mov -0x20(%ebp),%eax
1007f3: 89 45 10 mov %eax,0x10(%ebp)
1007f6: 8b 45 e4 mov -0x1c(%ebp),%eax
1007f9: 89 45 08 mov %eax,0x8(%ebp)
1007fc: 8b 43 04 mov 0x4(%ebx),%eax
}
1007ff: 83 c4 2c add $0x2c,%esp
100802: 5b pop %ebx
100803: 5e pop %esi
100804: 5f pop %edi
100805: 5d pop %ebp
return (cf->func(passwd, salt, data));
100806: ff e0 jmp *%eax
100808: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10080f: 90 nop
return (cf->func(passwd, salt, data));
100810: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED
100813: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED
100816: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED
100819: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
10081c: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
10081f: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED
}
100822: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED
100825: 5b pop %ebx <== NOT EXECUTED
100826: 5e pop %esi <== NOT EXECUTED
100827: 5f pop %edi <== NOT EXECUTED
100828: 5d pop %ebp <== NOT EXECUTED
return (cf->func(passwd, salt, data));
100829: ff e0 jmp *%eax <== NOT EXECUTED
10082b: 90 nop
10082c: 90 nop
10082d: 90 nop
10082e: 90 nop
10082f: 90 nop
00100d10 <crypt_sha256_r>:
/* Maximum number of rounds. */
#define ROUNDS_MAX 999999999
char *
crypt_sha256_r(const char *key, const char *salt, struct crypt_data *data)
{
100d10: 55 push %ebp
100d11: 89 e5 mov %esp,%ebp
100d13: 57 push %edi
100d14: 56 push %esi
100d15: 53 push %ebx
100d16: 81 ec 7c 01 00 00 sub $0x17c,%esp
SHA256_CTX ctx, alt_ctx;
size_t salt_len, key_len, cnt, rounds;
char *cp, *copied_key, *copied_salt, *p_bytes, *s_bytes, *endp;
const char *num;
bool rounds_custom;
char *buffer = &data->buffer[0];
100d1c: 8b 45 10 mov 0x10(%ebp),%eax
{
100d1f: 8b 75 08 mov 0x8(%ebp),%esi
char *buffer = &data->buffer[0];
100d22: 89 85 a8 fe ff ff mov %eax,-0x158(%ebp)
int buflen = (int)sizeof(data->buffer);
100d28: b8 00 01 00 00 mov $0x100,%eax
100d2d: 89 85 d4 fe ff ff mov %eax,-0x12c(%ebp)
rounds = ROUNDS_DEFAULT;
rounds_custom = false;
/* Find beginning of salt string. The prefix should normally always
* be present. Just in case it is not. */
if (strncmp(sha256_salt_prefix, salt, sizeof(sha256_salt_prefix) - 1) == 0)
100d33: 8b 45 0c mov 0xc(%ebp),%eax
100d36: 80 38 24 cmpb $0x24,(%eax)
100d39: 75 15 jne 100d50 <crypt_sha256_r+0x40> <== NEVER TAKEN
100d3b: 80 78 01 35 cmpb $0x35,0x1(%eax)
100d3f: 0f 84 fb 08 00 00 je 101640 <crypt_sha256_r+0x930>
100d45: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
100d4c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
/* Skip salt prefix. */
salt += sizeof(sha256_salt_prefix) - 1;
if (strncmp(salt, sha256_rounds_prefix, sizeof(sha256_rounds_prefix) - 1)
100d50: b8 07 00 00 00 mov $0x7,%eax
100d55: 89 44 24 08 mov %eax,0x8(%esp)
100d59: b8 d0 f5 12 00 mov $0x12f5d0,%eax
100d5e: 89 44 24 04 mov %eax,0x4(%esp)
100d62: 8b 45 0c mov 0xc(%ebp),%eax
100d65: 89 04 24 mov %eax,(%esp)
100d68: e8 a3 76 02 00 call 128410 <strncmp>
100d6d: 85 c0 test %eax,%eax
100d6f: 0f 84 6b 09 00 00 je 1016e0 <crypt_sha256_r+0x9d0> <== NEVER TAKEN
rounds_custom = false;
100d75: c6 85 a7 fe ff ff 00 movb $0x0,-0x159(%ebp)
rounds = ROUNDS_DEFAULT;
100d7c: b9 88 13 00 00 mov $0x1388,%ecx
100d81: 89 8d ac fe ff ff mov %ecx,-0x154(%ebp)
rounds = MAX(ROUNDS_MIN, MIN(srounds, ROUNDS_MAX));
rounds_custom = true;
}
}
salt_len = MIN(strcspn(salt, "$"), SALT_LEN_MAX);
100d87: 8b 45 0c mov 0xc(%ebp),%eax
100d8a: ba c2 f5 12 00 mov $0x12f5c2,%edx
100d8f: 89 54 24 04 mov %edx,0x4(%esp)
100d93: 89 04 24 mov %eax,(%esp)
100d96: e8 45 74 02 00 call 1281e0 <strcspn>
100d9b: 89 85 b8 fe ff ff mov %eax,-0x148(%ebp)
100da1: 83 f8 0f cmp $0xf,%eax
100da4: 76 0b jbe 100db1 <crypt_sha256_r+0xa1>
100da6: b8 10 00 00 00 mov $0x10,%eax
100dab: 89 85 b8 fe ff ff mov %eax,-0x148(%ebp)
key_len = strlen(key);
100db1: 89 34 24 mov %esi,(%esp)
/* Prepare for the real work. */
SHA256_Init(&ctx);
100db4: 8d 9d 18 ff ff ff lea -0xe8(%ebp),%ebx
key_len = strlen(key);
100dba: e8 51 75 02 00 call 128310 <strlen>
SHA256_Init(&ctx);
100dbf: 89 1c 24 mov %ebx,(%esp)
key_len = strlen(key);
100dc2: 89 85 c4 fe ff ff mov %eax,-0x13c(%ebp)
100dc8: 89 c7 mov %eax,%edi
SHA256_Init(&ctx);
100dca: e8 91 7a 00 00 call 108860 <SHA256_Init>
/* Add the key string. */
SHA256_Update(&ctx, key, key_len);
100dcf: 89 7c 24 08 mov %edi,0x8(%esp)
100dd3: 89 74 24 04 mov %esi,0x4(%esp)
100dd7: 89 1c 24 mov %ebx,(%esp)
100dda: e8 d1 7a 00 00 call 1088b0 <SHA256_Update>
/* The last part is the salt string. This must be at most 8
* characters and it ends at the first `$' character (for
* compatibility with existing implementations). */
SHA256_Update(&ctx, salt, salt_len);
100ddf: 8b 85 b8 fe ff ff mov -0x148(%ebp),%eax <== NOT EXECUTED
100de5: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
100de8: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED
100deb: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
100def: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
100df3: e8 b8 7a 00 00 call 1088b0 <SHA256_Update> <== NOT EXECUTED
/* Compute alternate SHA256 sum with input KEY, SALT, and KEY. The
* final result will be added to the first context. */
SHA256_Init(&alt_ctx);
100df8: 8d 4d 80 lea -0x80(%ebp),%ecx
100dfb: 89 0c 24 mov %ecx,(%esp)
100dfe: e8 5d 7a 00 00 call 108860 <SHA256_Init>
/* Add key. */
SHA256_Update(&alt_ctx, key, key_len);
100e03: 8d 55 80 lea -0x80(%ebp),%edx
100e06: 89 14 24 mov %edx,(%esp)
100e09: 89 7c 24 08 mov %edi,0x8(%esp)
100e0d: 89 74 24 04 mov %esi,0x4(%esp)
100e11: e8 9a 7a 00 00 call 1088b0 <SHA256_Update>
/* Add salt. */
SHA256_Update(&alt_ctx, salt, salt_len);
100e16: 8b 85 b8 fe ff ff mov -0x148(%ebp),%eax
100e1c: 89 44 24 08 mov %eax,0x8(%esp)
100e20: 8b 45 0c mov 0xc(%ebp),%eax
100e23: 89 44 24 04 mov %eax,0x4(%esp)
100e27: 8d 45 80 lea -0x80(%ebp),%eax
100e2a: 89 04 24 mov %eax,(%esp)
100e2d: e8 7e 7a 00 00 call 1088b0 <SHA256_Update>
/* Add key again. */
SHA256_Update(&alt_ctx, key, key_len);
100e32: 8d 45 80 lea -0x80(%ebp),%eax <== NOT EXECUTED
100e35: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
100e38: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED
100e3c: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
100e40: e8 6b 7a 00 00 call 1088b0 <SHA256_Update> <== NOT EXECUTED
/* Now get result of this (32 bytes) and add it to the other context. */
SHA256_Final(alt_result, &alt_ctx);
100e45: 8d 45 80 lea -0x80(%ebp),%eax
100e48: 89 44 24 04 mov %eax,0x4(%esp)
100e4c: 8d 85 d8 fe ff ff lea -0x128(%ebp),%eax
100e52: 89 04 24 mov %eax,(%esp)
100e55: e8 16 7d 00 00 call 108b70 <SHA256_Final>
/* Add for any character in the key one byte of the alternate sum. */
for (cnt = key_len; cnt > 32; cnt -= 32)
100e5a: 83 ff 20 cmp $0x20,%edi
100e5d: 0f 86 7d 09 00 00 jbe 1017e0 <crypt_sha256_r+0xad0> <== NEVER TAKEN
100e63: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
100e6a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
SHA256_Update(&ctx, alt_result, 32);
100e70: 89 1c 24 mov %ebx,(%esp)
100e73: b8 20 00 00 00 mov $0x20,%eax
for (cnt = key_len; cnt > 32; cnt -= 32)
100e78: 83 ef 20 sub $0x20,%edi
SHA256_Update(&ctx, alt_result, 32);
100e7b: 89 44 24 08 mov %eax,0x8(%esp)
100e7f: 8d 85 d8 fe ff ff lea -0x128(%ebp),%eax
100e85: 89 44 24 04 mov %eax,0x4(%esp)
100e89: e8 22 7a 00 00 call 1088b0 <SHA256_Update>
for (cnt = key_len; cnt > 32; cnt -= 32)
100e8e: 83 ff 20 cmp $0x20,%edi
100e91: 77 dd ja 100e70 <crypt_sha256_r+0x160>
SHA256_Update(&ctx, alt_result, cnt);
100e93: 89 1c 24 mov %ebx,(%esp)
for (cnt = key_len; cnt > 32; cnt -= 32)
100e96: 8b 85 c4 fe ff ff mov -0x13c(%ebp),%eax
100e9c: 8d 50 df lea -0x21(%eax),%edx
100e9f: 83 e8 20 sub $0x20,%eax
100ea2: 83 e2 e0 and $0xffffffe0,%edx
100ea5: 29 d0 sub %edx,%eax
SHA256_Update(&ctx, alt_result, cnt);
100ea7: 89 44 24 08 mov %eax,0x8(%esp)
100eab: 8d 85 d8 fe ff ff lea -0x128(%ebp),%eax
100eb1: 89 44 24 04 mov %eax,0x4(%esp)
100eb5: e8 f6 79 00 00 call 1088b0 <SHA256_Update>
key_len = strlen(key);
100eba: 8b bd c4 fe ff ff mov -0x13c(%ebp),%edi
100ec0: eb 2d jmp 100eef <crypt_sha256_r+0x1df>
100ec2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
100ec9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
/* Take the binary representation of the length of the key and for
* every 1 add the alternate sum, for every 0 the key. */
for (cnt = key_len; cnt > 0; cnt >>= 1)
if ((cnt & 1) != 0)
SHA256_Update(&ctx, alt_result, 32);
100ed0: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
100ed3: b8 20 00 00 00 mov $0x20,%eax <== NOT EXECUTED
100ed8: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
100edc: 8d 85 d8 fe ff ff lea -0x128(%ebp),%eax <== NOT EXECUTED
100ee2: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
100ee6: e8 c5 79 00 00 call 1088b0 <SHA256_Update> <== NOT EXECUTED
for (cnt = key_len; cnt > 0; cnt >>= 1)
100eeb: d1 ef shr %edi
100eed: 74 22 je 100f11 <crypt_sha256_r+0x201>
if ((cnt & 1) != 0)
100eef: f7 c7 01 00 00 00 test $0x1,%edi
100ef5: 75 d9 jne 100ed0 <crypt_sha256_r+0x1c0>
else
SHA256_Update(&ctx, key, key_len);
100ef7: 89 74 24 04 mov %esi,0x4(%esp)
100efb: 8b 85 c4 fe ff ff mov -0x13c(%ebp),%eax
100f01: 89 1c 24 mov %ebx,(%esp)
100f04: 89 44 24 08 mov %eax,0x8(%esp)
100f08: e8 a3 79 00 00 call 1088b0 <SHA256_Update>
for (cnt = key_len; cnt > 0; cnt >>= 1)
100f0d: d1 ef shr %edi
100f0f: 75 de jne 100eef <crypt_sha256_r+0x1df> <== ALWAYS TAKEN
/* Create intermediate result. */
SHA256_Final(alt_result, &ctx);
100f11: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
100f15: 8d 85 d8 fe ff ff lea -0x128(%ebp),%eax <== NOT EXECUTED
100f1b: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
100f1e: e8 4d 7c 00 00 call 108b70 <SHA256_Final> <== NOT EXECUTED
/* Start computation of P byte sequence. */
SHA256_Init(&alt_ctx);
100f23: 8d 45 80 lea -0x80(%ebp),%eax
100f26: 89 04 24 mov %eax,(%esp)
100f29: e8 32 79 00 00 call 108860 <SHA256_Init>
/* For every character in the password add the entire password. */
for (cnt = 0; cnt < key_len; ++cnt)
100f2e: 89 75 08 mov %esi,0x8(%ebp)
100f31: 8b b5 c4 fe ff ff mov -0x13c(%ebp),%esi
100f37: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
100f3e: 66 90 xchg %ax,%ax
SHA256_Update(&alt_ctx, key, key_len);
100f40: 89 74 24 08 mov %esi,0x8(%esp)
100f44: 8b 45 08 mov 0x8(%ebp),%eax
for (cnt = 0; cnt < key_len; ++cnt)
100f47: 47 inc %edi
SHA256_Update(&alt_ctx, key, key_len);
100f48: 89 44 24 04 mov %eax,0x4(%esp)
100f4c: 8d 45 80 lea -0x80(%ebp),%eax
100f4f: 89 04 24 mov %eax,(%esp)
100f52: e8 59 79 00 00 call 1088b0 <SHA256_Update>
for (cnt = 0; cnt < key_len; ++cnt)
100f57: 39 fe cmp %edi,%esi
100f59: 77 e5 ja 100f40 <crypt_sha256_r+0x230>
/* Finish the digest. */
SHA256_Final(temp_result, &alt_ctx);
100f5b: 8d 45 80 lea -0x80(%ebp),%eax
100f5e: 89 44 24 04 mov %eax,0x4(%esp)
100f62: 8d bd f8 fe ff ff lea -0x108(%ebp),%edi
100f68: 89 3c 24 mov %edi,(%esp)
100f6b: e8 00 7c 00 00 call 108b70 <SHA256_Final>
/* Create byte sequence P. */
cp = p_bytes = alloca(key_len);
100f70: 8b 8d c4 fe ff ff mov -0x13c(%ebp),%ecx
100f76: 8d 41 1b lea 0x1b(%ecx),%eax
100f79: 83 e0 f0 and $0xfffffff0,%eax
100f7c: 29 c4 sub %eax,%esp
100f7e: 8d 44 24 27 lea 0x27(%esp),%eax
100f82: 83 e0 f0 and $0xfffffff0,%eax
for (cnt = key_len; cnt >= 32; cnt -= 32) {
100f85: 83 f9 1f cmp $0x1f,%ecx
cp = p_bytes = alloca(key_len);
100f88: 89 85 bc fe ff ff mov %eax,-0x144(%ebp)
100f8e: 89 85 cc fe ff ff mov %eax,-0x134(%ebp)
for (cnt = key_len; cnt >= 32; cnt -= 32) {
100f94: 0f 86 db 08 00 00 jbe 101875 <crypt_sha256_r+0xb65> <== NEVER TAKEN
100f9a: 89 8d b0 fe ff ff mov %ecx,-0x150(%ebp)
memcpy(cp, temp_result, 32);
100fa0: a8 01 test $0x1,%al
100fa2: 89 c2 mov %eax,%edx
100fa4: 89 f9 mov %edi,%ecx
100fa6: be 20 00 00 00 mov $0x20,%esi
100fab: 0f 85 0f 06 00 00 jne 1015c0 <crypt_sha256_r+0x8b0> <== NEVER TAKEN
100fb1: f6 c2 02 test $0x2,%dl
100fb4: 0f 85 e6 05 00 00 jne 1015a0 <crypt_sha256_r+0x890> <== NEVER TAKEN
100fba: 89 b5 b4 fe ff ff mov %esi,-0x14c(%ebp)
100fc0: 89 f0 mov %esi,%eax
100fc2: 83 e0 fc and $0xfffffffc,%eax
100fc5: 89 85 c0 fe ff ff mov %eax,-0x140(%ebp)
100fcb: 31 c0 xor %eax,%eax
100fcd: 8b 34 01 mov (%ecx,%eax,1),%esi
100fd0: 89 34 02 mov %esi,(%edx,%eax,1)
100fd3: 83 c0 04 add $0x4,%eax
100fd6: 3b 85 c0 fe ff ff cmp -0x140(%ebp),%eax
100fdc: 72 ef jb 100fcd <crypt_sha256_r+0x2bd>
100fde: 8b b5 b4 fe ff ff mov -0x14c(%ebp),%esi
100fe4: 01 c2 add %eax,%edx
100fe6: 01 c1 add %eax,%ecx
100fe8: 31 c0 xor %eax,%eax
100fea: f7 c6 02 00 00 00 test $0x2,%esi
100ff0: 74 0b je 100ffd <crypt_sha256_r+0x2ed> <== ALWAYS TAKEN
100ff2: 0f b7 01 movzwl (%ecx),%eax <== NOT EXECUTED
100ff5: 66 89 02 mov %ax,(%edx) <== NOT EXECUTED
100ff8: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED
100ffd: 83 e6 01 and $0x1,%esi
101000: 74 07 je 101009 <crypt_sha256_r+0x2f9> <== ALWAYS TAKEN
101002: 0f b6 0c 01 movzbl (%ecx,%eax,1),%ecx <== NOT EXECUTED
101006: 88 0c 02 mov %cl,(%edx,%eax,1) <== NOT EXECUTED
for (cnt = key_len; cnt >= 32; cnt -= 32) {
101009: 83 ad b0 fe ff ff 20 subl $0x20,-0x150(%ebp)
cp += 32;
101010: 8b 85 cc fe ff ff mov -0x134(%ebp),%eax
for (cnt = key_len; cnt >= 32; cnt -= 32) {
101016: 8b 8d b0 fe ff ff mov -0x150(%ebp),%ecx
cp += 32;
10101c: 83 c0 20 add $0x20,%eax
10101f: 89 85 cc fe ff ff mov %eax,-0x134(%ebp)
for (cnt = key_len; cnt >= 32; cnt -= 32) {
101025: 83 f9 1f cmp $0x1f,%ecx
101028: 0f 87 72 ff ff ff ja 100fa0 <crypt_sha256_r+0x290> <== NEVER TAKEN
10102e: 8b b5 c4 fe ff ff mov -0x13c(%ebp),%esi
101034: 83 e6 1f and $0x1f,%esi
}
memcpy(cp, temp_result, cnt);
101037: 83 fe 04 cmp $0x4,%esi
10103a: 89 c1 mov %eax,%ecx
10103c: 89 fa mov %edi,%edx
10103e: 0f 83 4c 06 00 00 jae 101690 <crypt_sha256_r+0x980> <== ALWAYS TAKEN
101044: 31 c0 xor %eax,%eax
101046: f7 c6 02 00 00 00 test $0x2,%esi
10104c: 0f 85 9e 05 00 00 jne 1015f0 <crypt_sha256_r+0x8e0>
101052: 83 e6 01 and $0x1,%esi
101055: 0f 85 85 05 00 00 jne 1015e0 <crypt_sha256_r+0x8d0> <== NEVER TAKEN
/* Start computation of S byte sequence. */
SHA256_Init(&alt_ctx);
10105b: 8d 45 80 lea -0x80(%ebp),%eax
/* For every character in the password add the entire password. */
for (cnt = 0; cnt < 16 + alt_result[0]; ++cnt)
10105e: 31 f6 xor %esi,%esi
SHA256_Init(&alt_ctx);
101060: 89 04 24 mov %eax,(%esp)
101063: e8 f8 77 00 00 call 108860 <SHA256_Init>
for (cnt = 0; cnt < 16 + alt_result[0]; ++cnt)
101068: 89 bd c0 fe ff ff mov %edi,-0x140(%ebp)
10106e: 8b bd b8 fe ff ff mov -0x148(%ebp),%edi
101074: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10107b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10107f: 90 nop
SHA256_Update(&alt_ctx, salt, salt_len);
101080: 89 7c 24 08 mov %edi,0x8(%esp)
101084: 8b 45 0c mov 0xc(%ebp),%eax
for (cnt = 0; cnt < 16 + alt_result[0]; ++cnt)
101087: 46 inc %esi
SHA256_Update(&alt_ctx, salt, salt_len);
101088: 89 44 24 04 mov %eax,0x4(%esp)
10108c: 8d 45 80 lea -0x80(%ebp),%eax
10108f: 89 04 24 mov %eax,(%esp)
101092: e8 19 78 00 00 call 1088b0 <SHA256_Update>
for (cnt = 0; cnt < 16 + alt_result[0]; ++cnt)
101097: 0f b6 85 d8 fe ff ff movzbl -0x128(%ebp),%eax
10109e: 83 c0 10 add $0x10,%eax
1010a1: 39 f0 cmp %esi,%eax
1010a3: 77 db ja 101080 <crypt_sha256_r+0x370>
/* Finish the digest. */
SHA256_Final(temp_result, &alt_ctx);
1010a5: 8b bd c0 fe ff ff mov -0x140(%ebp),%edi
1010ab: 8d 45 80 lea -0x80(%ebp),%eax
1010ae: 89 44 24 04 mov %eax,0x4(%esp)
1010b2: 89 3c 24 mov %edi,(%esp)
1010b5: e8 b6 7a 00 00 call 108b70 <SHA256_Final>
/* Create byte sequence S. */
cp = s_bytes = alloca(salt_len);
1010ba: 8b 95 b8 fe ff ff mov -0x148(%ebp),%edx
1010c0: 8d 42 1b lea 0x1b(%edx),%eax
1010c3: 83 e0 f0 and $0xfffffff0,%eax
1010c6: 29 c4 sub %eax,%esp
1010c8: 8d 44 24 27 lea 0x27(%esp),%eax
1010cc: 83 e0 f0 and $0xfffffff0,%eax
for (cnt = salt_len; cnt >= 32; cnt -= 32) {
memcpy(cp, temp_result, 32);
cp += 32;
}
memcpy(cp, temp_result, cnt);
1010cf: 83 fa 04 cmp $0x4,%edx
cp = s_bytes = alloca(salt_len);
1010d2: 89 85 c0 fe ff ff mov %eax,-0x140(%ebp)
1010d8: 89 c6 mov %eax,%esi
memcpy(cp, temp_result, cnt);
1010da: 89 c1 mov %eax,%ecx
cp = s_bytes = alloca(salt_len);
1010dc: 89 85 cc fe ff ff mov %eax,-0x134(%ebp)
memcpy(cp, temp_result, cnt);
1010e2: 89 f8 mov %edi,%eax
1010e4: 0f 83 76 05 00 00 jae 101660 <crypt_sha256_r+0x950> <== ALWAYS TAKEN
1010ea: 31 d2 xor %edx,%edx
1010ec: f6 85 b8 fe ff ff 02 testb $0x2,-0x148(%ebp)
1010f3: 0f 85 27 05 00 00 jne 101620 <crypt_sha256_r+0x910>
1010f9: f6 85 b8 fe ff ff 01 testb $0x1,-0x148(%ebp)
101100: 0f 85 0a 05 00 00 jne 101610 <crypt_sha256_r+0x900>
/* Repeatedly run the collected hash value through SHA256 to burn CPU
* cycles. */
for (cnt = 0; cnt < rounds; ++cnt) {
101106: 31 f6 xor %esi,%esi
101108: e9 83 00 00 00 jmp 101190 <crypt_sha256_r+0x480>
10110d: 8d 76 00 lea 0x0(%esi),%esi
/* New context. */
SHA256_Init(&ctx);
/* Add key or last result. */
if ((cnt & 1) != 0)
SHA256_Update(&ctx, p_bytes, key_len);
101110: 89 1c 24 mov %ebx,(%esp)
101113: 8b 85 c4 fe ff ff mov -0x13c(%ebp),%eax
101119: 89 44 24 08 mov %eax,0x8(%esp)
10111d: 8b 85 bc fe ff ff mov -0x144(%ebp),%eax
101123: 89 44 24 04 mov %eax,0x4(%esp)
101127: e8 84 77 00 00 call 1088b0 <SHA256_Update>
else
SHA256_Update(&ctx, alt_result, 32);
10112c: 69 c6 ab aa aa aa imul $0xaaaaaaab,%esi,%eax
/* Add salt for numbers not divisible by 3. */
if (cnt % 3 != 0)
101132: 3d 55 55 55 55 cmp $0x55555555,%eax
101137: 0f 87 92 00 00 00 ja 1011cf <crypt_sha256_r+0x4bf>
SHA256_Update(&ctx, s_bytes, salt_len);
10113d: 69 c6 b7 6d db b6 imul $0xb6db6db7,%esi,%eax
/* Add key for numbers not divisible by 7. */
if (cnt % 7 != 0)
101143: 3d 24 49 92 24 cmp $0x24924924,%eax
101148: 0f 87 ae 00 00 00 ja 1011fc <crypt_sha256_r+0x4ec>
SHA256_Update(&ctx, p_bytes, key_len);
/* Add key or last result. */
if ((cnt & 1) != 0)
10114e: 85 ff test %edi,%edi
101150: 0f 84 ca 00 00 00 je 101220 <crypt_sha256_r+0x510>
SHA256_Update(&ctx, alt_result, 32);
101156: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
101159: b8 20 00 00 00 mov $0x20,%eax <== NOT EXECUTED
10115e: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
101162: 8d 85 d8 fe ff ff lea -0x128(%ebp),%eax <== NOT EXECUTED
101168: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10116c: e8 3f 77 00 00 call 1088b0 <SHA256_Update> <== NOT EXECUTED
else
SHA256_Update(&ctx, p_bytes, key_len);
/* Create intermediate result. */
SHA256_Final(alt_result, &ctx);
101171: 89 5c 24 04 mov %ebx,0x4(%esp)
101175: 8d 85 d8 fe ff ff lea -0x128(%ebp),%eax
for (cnt = 0; cnt < rounds; ++cnt) {
10117b: 46 inc %esi
SHA256_Final(alt_result, &ctx);
10117c: 89 04 24 mov %eax,(%esp)
10117f: e8 ec 79 00 00 call 108b70 <SHA256_Final>
for (cnt = 0; cnt < rounds; ++cnt) {
101184: 39 b5 ac fe ff ff cmp %esi,-0x154(%ebp)
10118a: 0f 84 c0 00 00 00 je 101250 <crypt_sha256_r+0x540>
SHA256_Init(&ctx);
101190: 89 1c 24 mov %ebx,(%esp)
if ((cnt & 1) != 0)
101193: 89 f7 mov %esi,%edi
SHA256_Init(&ctx);
101195: e8 c6 76 00 00 call 108860 <SHA256_Init>
if ((cnt & 1) != 0)
10119a: 83 e7 01 and $0x1,%edi
10119d: 0f 85 6d ff ff ff jne 101110 <crypt_sha256_r+0x400>
SHA256_Update(&ctx, alt_result, 32);
1011a3: 89 1c 24 mov %ebx,(%esp)
1011a6: b8 20 00 00 00 mov $0x20,%eax
1011ab: 89 44 24 08 mov %eax,0x8(%esp)
1011af: 8d 85 d8 fe ff ff lea -0x128(%ebp),%eax
1011b5: 89 44 24 04 mov %eax,0x4(%esp)
1011b9: e8 f2 76 00 00 call 1088b0 <SHA256_Update>
1011be: 69 c6 ab aa aa aa imul $0xaaaaaaab,%esi,%eax
if (cnt % 3 != 0)
1011c4: 3d 55 55 55 55 cmp $0x55555555,%eax
1011c9: 0f 86 6e ff ff ff jbe 10113d <crypt_sha256_r+0x42d>
SHA256_Update(&ctx, s_bytes, salt_len);
1011cf: 89 1c 24 mov %ebx,(%esp)
1011d2: 8b 85 b8 fe ff ff mov -0x148(%ebp),%eax
1011d8: 89 44 24 08 mov %eax,0x8(%esp)
1011dc: 8b 85 c0 fe ff ff mov -0x140(%ebp),%eax
1011e2: 89 44 24 04 mov %eax,0x4(%esp)
1011e6: e8 c5 76 00 00 call 1088b0 <SHA256_Update>
1011eb: 69 c6 b7 6d db b6 imul $0xb6db6db7,%esi,%eax
if (cnt % 7 != 0)
1011f1: 3d 24 49 92 24 cmp $0x24924924,%eax
1011f6: 0f 86 52 ff ff ff jbe 10114e <crypt_sha256_r+0x43e>
SHA256_Update(&ctx, p_bytes, key_len);
1011fc: 89 1c 24 mov %ebx,(%esp)
1011ff: 8b 85 c4 fe ff ff mov -0x13c(%ebp),%eax
101205: 89 44 24 08 mov %eax,0x8(%esp)
101209: 8b 85 bc fe ff ff mov -0x144(%ebp),%eax
10120f: 89 44 24 04 mov %eax,0x4(%esp)
101213: e8 98 76 00 00 call 1088b0 <SHA256_Update>
if ((cnt & 1) != 0)
101218: 85 ff test %edi,%edi
10121a: 0f 85 36 ff ff ff jne 101156 <crypt_sha256_r+0x446>
SHA256_Update(&ctx, p_bytes, key_len);
101220: 89 1c 24 mov %ebx,(%esp)
101223: 8b 85 c4 fe ff ff mov -0x13c(%ebp),%eax
101229: 89 44 24 08 mov %eax,0x8(%esp)
10122d: 8b 85 bc fe ff ff mov -0x144(%ebp),%eax
101233: 89 44 24 04 mov %eax,0x4(%esp)
101237: e8 74 76 00 00 call 1088b0 <SHA256_Update>
10123c: e9 30 ff ff ff jmp 101171 <crypt_sha256_r+0x461>
101241: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
101248: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10124f: 90 nop
}
/* Now we can construct the result string. It consists of three
* parts. */
cp = stpncpy(buffer, sha256_salt_prefix, MAX(0, buflen));
101250: 8b b5 d4 fe ff ff mov -0x12c(%ebp),%esi
101256: bf d8 f5 12 00 mov $0x12f5d8,%edi
10125b: 89 7c 24 04 mov %edi,0x4(%esp)
10125f: 89 f0 mov %esi,%eax
101261: f7 d0 not %eax
101263: c1 f8 1f sar $0x1f,%eax
101266: 21 f0 and %esi,%eax
buflen -= sizeof(sha256_salt_prefix) - 1;
101268: 83 ee 03 sub $0x3,%esi
cp = stpncpy(buffer, sha256_salt_prefix, MAX(0, buflen));
10126b: 89 44 24 08 mov %eax,0x8(%esp)
10126f: 8b 45 10 mov 0x10(%ebp),%eax
101272: 89 04 24 mov %eax,(%esp)
101275: e8 86 6d 02 00 call 128000 <stpncpy>
if (rounds_custom) {
n = snprintf(cp, MAX(0, buflen), "%s%zu$",
10127a: 89 f2 mov %esi,%edx
buflen -= sizeof(sha256_salt_prefix) - 1;
10127c: 89 b5 d4 fe ff ff mov %esi,-0x12c(%ebp)
n = snprintf(cp, MAX(0, buflen), "%s%zu$",
101282: f7 d2 not %edx
101284: c1 fa 1f sar $0x1f,%edx
101287: 21 d6 and %edx,%esi
if (rounds_custom) {
101289: 80 bd a7 fe ff ff 00 cmpb $0x0,-0x159(%ebp)
cp = stpncpy(buffer, sha256_salt_prefix, MAX(0, buflen));
101290: 89 85 cc fe ff ff mov %eax,-0x134(%ebp)
if (rounds_custom) {
101296: 0f 85 a4 04 00 00 jne 101740 <crypt_sha256_r+0xa30>
cp += n;
buflen -= n;
}
cp = stpncpy(cp, salt, MIN((size_t)MAX(0, buflen), salt_len));
10129c: 8b 8d b8 fe ff ff mov -0x148(%ebp),%ecx
1012a2: 39 f1 cmp %esi,%ecx
1012a4: 89 ca mov %ecx,%edx
1012a6: 76 02 jbe 1012aa <crypt_sha256_r+0x59a> <== ALWAYS TAKEN
1012a8: 89 f2 mov %esi,%edx <== NOT EXECUTED
1012aa: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED
1012ae: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
1012b1: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1012b4: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
1012b8: e8 43 6d 02 00 call 128000 <stpncpy> <== NOT EXECUTED
buflen -= MIN((size_t)MAX(0, buflen), salt_len);
1012bd: 8b 95 d4 fe ff ff mov -0x12c(%ebp),%edx
1012c3: 8b bd b8 fe ff ff mov -0x148(%ebp),%edi
cp = stpncpy(cp, salt, MIN((size_t)MAX(0, buflen), salt_len));
1012c9: 89 85 cc fe ff ff mov %eax,-0x134(%ebp)
1012cf: 89 c1 mov %eax,%ecx
buflen -= MIN((size_t)MAX(0, buflen), salt_len);
1012d1: 89 d0 mov %edx,%eax
1012d3: f7 d0 not %eax
1012d5: c1 f8 1f sar $0x1f,%eax
1012d8: 21 d0 and %edx,%eax
1012da: 39 f8 cmp %edi,%eax
1012dc: 76 02 jbe 1012e0 <crypt_sha256_r+0x5d0> <== NEVER TAKEN
1012de: 89 f8 mov %edi,%eax
1012e0: 29 c2 sub %eax,%edx
1012e2: 89 95 d4 fe ff ff mov %edx,-0x12c(%ebp)
if (buflen > 0) {
1012e8: 85 d2 test %edx,%edx
1012ea: 7e 12 jle 1012fe <crypt_sha256_r+0x5ee> <== NEVER TAKEN
*cp++ = '$';
1012ec: 8d 41 01 lea 0x1(%ecx),%eax
1012ef: 89 85 cc fe ff ff mov %eax,-0x134(%ebp)
1012f5: c6 01 24 movb $0x24,(%ecx)
--buflen;
1012f8: ff 8d d4 fe ff ff decl -0x12c(%ebp)
}
b64_from_24bit(alt_result[0], alt_result[10], alt_result[20], 4, &buflen, &cp);
1012fe: 0f b6 85 ec fe ff ff movzbl -0x114(%ebp),%eax
101305: 8d bd cc fe ff ff lea -0x134(%ebp),%edi
10130b: ba 04 00 00 00 mov $0x4,%edx
101310: 89 54 24 0c mov %edx,0xc(%esp)
101314: 8d b5 d4 fe ff ff lea -0x12c(%ebp),%esi
10131a: 89 7c 24 14 mov %edi,0x14(%esp)
10131e: 89 74 24 10 mov %esi,0x10(%esp)
101322: 89 44 24 08 mov %eax,0x8(%esp)
101326: 0f b6 85 e2 fe ff ff movzbl -0x11e(%ebp),%eax
10132d: 89 44 24 04 mov %eax,0x4(%esp)
101331: 0f b6 85 d8 fe ff ff movzbl -0x128(%ebp),%eax
101338: 89 04 24 mov %eax,(%esp)
10133b: e8 90 13 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[21], alt_result[1], alt_result[11], 4, &buflen, &cp);
101340: 0f b6 85 e3 fe ff ff movzbl -0x11d(%ebp),%eax
101347: b9 04 00 00 00 mov $0x4,%ecx
10134c: 89 4c 24 0c mov %ecx,0xc(%esp)
101350: 89 7c 24 14 mov %edi,0x14(%esp)
101354: 89 74 24 10 mov %esi,0x10(%esp)
101358: 89 44 24 08 mov %eax,0x8(%esp)
10135c: 0f b6 85 d9 fe ff ff movzbl -0x127(%ebp),%eax
101363: 89 44 24 04 mov %eax,0x4(%esp)
101367: 0f b6 85 ed fe ff ff movzbl -0x113(%ebp),%eax
10136e: 89 04 24 mov %eax,(%esp)
101371: e8 5a 13 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[12], alt_result[22], alt_result[2], 4, &buflen, &cp);
101376: b8 04 00 00 00 mov $0x4,%eax
10137b: 89 44 24 0c mov %eax,0xc(%esp)
10137f: 0f b6 85 da fe ff ff movzbl -0x126(%ebp),%eax
101386: 89 7c 24 14 mov %edi,0x14(%esp)
10138a: 89 74 24 10 mov %esi,0x10(%esp)
10138e: 89 44 24 08 mov %eax,0x8(%esp)
101392: 0f b6 85 ee fe ff ff movzbl -0x112(%ebp),%eax
101399: 89 44 24 04 mov %eax,0x4(%esp)
10139d: 0f b6 85 e4 fe ff ff movzbl -0x11c(%ebp),%eax
1013a4: 89 04 24 mov %eax,(%esp)
1013a7: e8 24 13 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[3], alt_result[13], alt_result[23], 4, &buflen, &cp);
1013ac: b8 04 00 00 00 mov $0x4,%eax
1013b1: 89 44 24 0c mov %eax,0xc(%esp)
1013b5: 0f b6 85 ef fe ff ff movzbl -0x111(%ebp),%eax
1013bc: 89 7c 24 14 mov %edi,0x14(%esp)
1013c0: 89 74 24 10 mov %esi,0x10(%esp)
1013c4: 89 44 24 08 mov %eax,0x8(%esp)
1013c8: 0f b6 85 e5 fe ff ff movzbl -0x11b(%ebp),%eax
1013cf: 89 44 24 04 mov %eax,0x4(%esp)
1013d3: 0f b6 85 db fe ff ff movzbl -0x125(%ebp),%eax
1013da: 89 04 24 mov %eax,(%esp)
1013dd: e8 ee 12 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[24], alt_result[4], alt_result[14], 4, &buflen, &cp);
1013e2: b8 04 00 00 00 mov $0x4,%eax
1013e7: 89 44 24 0c mov %eax,0xc(%esp)
1013eb: 0f b6 85 e6 fe ff ff movzbl -0x11a(%ebp),%eax
1013f2: 89 7c 24 14 mov %edi,0x14(%esp)
1013f6: 89 74 24 10 mov %esi,0x10(%esp)
1013fa: 89 44 24 08 mov %eax,0x8(%esp)
1013fe: 0f b6 85 dc fe ff ff movzbl -0x124(%ebp),%eax
101405: 89 44 24 04 mov %eax,0x4(%esp)
101409: 0f b6 85 f0 fe ff ff movzbl -0x110(%ebp),%eax
101410: 89 04 24 mov %eax,(%esp)
101413: e8 b8 12 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[15], alt_result[25], alt_result[5], 4, &buflen, &cp);
101418: b8 04 00 00 00 mov $0x4,%eax
10141d: 89 44 24 0c mov %eax,0xc(%esp)
101421: 0f b6 85 dd fe ff ff movzbl -0x123(%ebp),%eax
101428: 89 7c 24 14 mov %edi,0x14(%esp)
10142c: 89 74 24 10 mov %esi,0x10(%esp)
101430: 89 44 24 08 mov %eax,0x8(%esp)
101434: 0f b6 85 f1 fe ff ff movzbl -0x10f(%ebp),%eax
10143b: 89 44 24 04 mov %eax,0x4(%esp)
10143f: 0f b6 85 e7 fe ff ff movzbl -0x119(%ebp),%eax
101446: 89 04 24 mov %eax,(%esp)
101449: e8 82 12 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[6], alt_result[16], alt_result[26], 4, &buflen, &cp);
10144e: b8 04 00 00 00 mov $0x4,%eax
101453: 89 44 24 0c mov %eax,0xc(%esp)
101457: 0f b6 85 f2 fe ff ff movzbl -0x10e(%ebp),%eax
10145e: 89 7c 24 14 mov %edi,0x14(%esp)
101462: 89 74 24 10 mov %esi,0x10(%esp)
101466: 89 44 24 08 mov %eax,0x8(%esp)
10146a: 0f b6 85 e8 fe ff ff movzbl -0x118(%ebp),%eax
101471: 89 44 24 04 mov %eax,0x4(%esp)
101475: 0f b6 85 de fe ff ff movzbl -0x122(%ebp),%eax
10147c: 89 04 24 mov %eax,(%esp)
10147f: e8 4c 12 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[27], alt_result[7], alt_result[17], 4, &buflen, &cp);
101484: 0f b6 85 e9 fe ff ff movzbl -0x117(%ebp),%eax
10148b: ba 04 00 00 00 mov $0x4,%edx
101490: 89 54 24 0c mov %edx,0xc(%esp)
101494: 89 7c 24 14 mov %edi,0x14(%esp)
101498: 89 74 24 10 mov %esi,0x10(%esp)
10149c: 89 44 24 08 mov %eax,0x8(%esp)
1014a0: 0f b6 85 df fe ff ff movzbl -0x121(%ebp),%eax
1014a7: 89 44 24 04 mov %eax,0x4(%esp)
1014ab: 0f b6 85 f3 fe ff ff movzbl -0x10d(%ebp),%eax
1014b2: 89 04 24 mov %eax,(%esp)
1014b5: e8 16 12 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[18], alt_result[28], alt_result[8], 4, &buflen, &cp);
1014ba: 0f b6 85 e0 fe ff ff movzbl -0x120(%ebp),%eax
1014c1: b9 04 00 00 00 mov $0x4,%ecx
1014c6: 89 4c 24 0c mov %ecx,0xc(%esp)
1014ca: 89 7c 24 14 mov %edi,0x14(%esp)
1014ce: 89 74 24 10 mov %esi,0x10(%esp)
1014d2: 89 44 24 08 mov %eax,0x8(%esp)
1014d6: 0f b6 85 f4 fe ff ff movzbl -0x10c(%ebp),%eax
1014dd: 89 44 24 04 mov %eax,0x4(%esp)
1014e1: 0f b6 85 ea fe ff ff movzbl -0x116(%ebp),%eax
1014e8: 89 04 24 mov %eax,(%esp)
1014eb: e8 e0 11 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[9], alt_result[19], alt_result[29], 4, &buflen, &cp);
1014f0: b8 04 00 00 00 mov $0x4,%eax
1014f5: 89 44 24 0c mov %eax,0xc(%esp)
1014f9: 0f b6 85 f5 fe ff ff movzbl -0x10b(%ebp),%eax
101500: 89 7c 24 14 mov %edi,0x14(%esp)
101504: 89 74 24 10 mov %esi,0x10(%esp)
101508: 89 44 24 08 mov %eax,0x8(%esp)
10150c: 0f b6 85 eb fe ff ff movzbl -0x115(%ebp),%eax
101513: 89 44 24 04 mov %eax,0x4(%esp)
101517: 0f b6 85 e1 fe ff ff movzbl -0x11f(%ebp),%eax
10151e: 89 04 24 mov %eax,(%esp)
101521: e8 aa 11 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(0, alt_result[31], alt_result[30], 3, &buflen, &cp);
101526: b8 03 00 00 00 mov $0x3,%eax
10152b: 89 44 24 0c mov %eax,0xc(%esp)
10152f: 0f b6 85 f6 fe ff ff movzbl -0x10a(%ebp),%eax
101536: 89 7c 24 14 mov %edi,0x14(%esp)
10153a: 89 74 24 10 mov %esi,0x10(%esp)
10153e: c7 04 24 00 00 00 00 movl $0x0,(%esp)
101545: 89 44 24 08 mov %eax,0x8(%esp)
101549: 0f b6 85 f7 fe ff ff movzbl -0x109(%ebp),%eax
101550: 89 44 24 04 mov %eax,0x4(%esp)
101554: e8 77 11 00 00 call 1026d0 <_crypt_b64_from_24bit>
if (buflen <= 0) {
101559: 8b 85 d4 fe ff ff mov -0x12c(%ebp),%eax
10155f: 85 c0 test %eax,%eax
101561: 0f 8e 39 02 00 00 jle 1017a0 <crypt_sha256_r+0xa90> <== NEVER TAKEN
errno = ERANGE;
buffer = NULL;
}
else
*cp = '\0'; /* Terminate the string. */
101567: 8b 85 cc fe ff ff mov -0x134(%ebp),%eax
10156d: c6 00 00 movb $0x0,(%eax)
/* Clear the buffer for the intermediate result so that people
* attaching to processes or reading core dumps cannot get any
* information. We do it in this way to clear correct_words[] inside
* the SHA256 implementation as well. */
SHA256_Init(&ctx);
101570: 89 1c 24 mov %ebx,(%esp)
101573: e8 e8 72 00 00 call 108860 <SHA256_Init>
SHA256_Final(alt_result, &ctx);
101578: 8d 85 d8 fe ff ff lea -0x128(%ebp),%eax
10157e: 89 5c 24 04 mov %ebx,0x4(%esp)
101582: 89 04 24 mov %eax,(%esp)
101585: e8 e6 75 00 00 call 108b70 <SHA256_Final>
memset(copied_key, '\0', key_len);
if (copied_salt != NULL)
memset(copied_salt, '\0', salt_len);
return buffer;
}
10158a: 8b 85 a8 fe ff ff mov -0x158(%ebp),%eax
101590: 8d 65 f4 lea -0xc(%ebp),%esp
101593: 5b pop %ebx
101594: 5e pop %esi
101595: 5f pop %edi
101596: 5d pop %ebp
101597: c3 ret
101598: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10159f: 90 nop
memcpy(cp, temp_result, 32);
1015a0: 0f b7 01 movzwl (%ecx),%eax <== NOT EXECUTED
1015a3: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
1015a6: 83 c1 02 add $0x2,%ecx <== NOT EXECUTED
1015a9: 83 ee 02 sub $0x2,%esi <== NOT EXECUTED
1015ac: 66 89 42 fe mov %ax,-0x2(%edx) <== NOT EXECUTED
1015b0: e9 05 fa ff ff jmp 100fba <crypt_sha256_r+0x2aa> <== NOT EXECUTED
1015b5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1015bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1015c0: 0f b6 0f movzbl (%edi),%ecx <== NOT EXECUTED
1015c3: 42 inc %edx <== NOT EXECUTED
1015c4: be 1f 00 00 00 mov $0x1f,%esi <== NOT EXECUTED
1015c9: 88 08 mov %cl,(%eax) <== NOT EXECUTED
1015cb: 8d 8d f9 fe ff ff lea -0x107(%ebp),%ecx <== NOT EXECUTED
1015d1: e9 db f9 ff ff jmp 100fb1 <crypt_sha256_r+0x2a1> <== NOT EXECUTED
1015d6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1015dd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
memcpy(cp, temp_result, cnt);
1015e0: 0f b6 14 02 movzbl (%edx,%eax,1),%edx
1015e4: 88 14 01 mov %dl,(%ecx,%eax,1)
1015e7: e9 6f fa ff ff jmp 10105b <crypt_sha256_r+0x34b>
1015ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
1015f0: 0f b7 02 movzwl (%edx),%eax
1015f3: 83 e6 01 and $0x1,%esi
1015f6: 66 89 01 mov %ax,(%ecx)
1015f9: b8 02 00 00 00 mov $0x2,%eax
1015fe: 0f 84 57 fa ff ff je 10105b <crypt_sha256_r+0x34b>
101604: eb da jmp 1015e0 <crypt_sha256_r+0x8d0>
101606: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10160d: 8d 76 00 lea 0x0(%esi),%esi
memcpy(cp, temp_result, cnt);
101610: 0f b6 04 10 movzbl (%eax,%edx,1),%eax
101614: 88 04 11 mov %al,(%ecx,%edx,1)
101617: e9 ea fa ff ff jmp 101106 <crypt_sha256_r+0x3f6>
10161c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
101620: 0f b7 10 movzwl (%eax),%edx
101623: 66 89 11 mov %dx,(%ecx)
101626: ba 02 00 00 00 mov $0x2,%edx
10162b: f6 85 b8 fe ff ff 01 testb $0x1,-0x148(%ebp)
101632: 0f 84 ce fa ff ff je 101106 <crypt_sha256_r+0x3f6> <== ALWAYS TAKEN
101638: eb d6 jmp 101610 <crypt_sha256_r+0x900> <== NOT EXECUTED
10163a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (strncmp(sha256_salt_prefix, salt, sizeof(sha256_salt_prefix) - 1) == 0)
101640: 0f b6 40 02 movzbl 0x2(%eax),%eax
101644: ba 24 00 00 00 mov $0x24,%edx
101649: 39 c2 cmp %eax,%edx
10164b: 0f 85 ff f6 ff ff jne 100d50 <crypt_sha256_r+0x40> <== NEVER TAKEN
salt += sizeof(sha256_salt_prefix) - 1;
101651: 83 45 0c 03 addl $0x3,0xc(%ebp)
101655: e9 f6 f6 ff ff jmp 100d50 <crypt_sha256_r+0x40>
10165a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
memcpy(cp, temp_result, cnt);
101660: 89 d1 mov %edx,%ecx
101662: 31 c0 xor %eax,%eax
101664: 83 e1 fc and $0xfffffffc,%ecx
101667: 8b 14 07 mov (%edi,%eax,1),%edx
10166a: 89 14 06 mov %edx,(%esi,%eax,1)
10166d: 83 c0 04 add $0x4,%eax
101670: 39 c8 cmp %ecx,%eax
101672: 72 f3 jb 101667 <crypt_sha256_r+0x957>
101674: 8b 95 c0 fe ff ff mov -0x140(%ebp),%edx
10167a: 8d 0c 02 lea (%edx,%eax,1),%ecx
10167d: 01 f8 add %edi,%eax
10167f: e9 66 fa ff ff jmp 1010ea <crypt_sha256_r+0x3da>
101684: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10168b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10168f: 90 nop
memcpy(cp, temp_result, cnt);
101690: a8 01 test $0x1,%al
101692: 0f 85 ca 01 00 00 jne 101862 <crypt_sha256_r+0xb52> <== NEVER TAKEN
101698: f6 c1 02 test $0x2,%cl
10169b: 0f 85 ac 01 00 00 jne 10184d <crypt_sha256_r+0xb3d> <== NEVER TAKEN
1016a1: 83 fe 04 cmp $0x4,%esi
1016a4: 0f 82 9a f9 ff ff jb 101044 <crypt_sha256_r+0x334> <== NEVER TAKEN
1016aa: 89 b5 b4 fe ff ff mov %esi,-0x14c(%ebp)
1016b0: 89 f0 mov %esi,%eax
1016b2: 83 e0 fc and $0xfffffffc,%eax
1016b5: 89 85 c0 fe ff ff mov %eax,-0x140(%ebp)
1016bb: 31 c0 xor %eax,%eax
1016bd: 8b 34 02 mov (%edx,%eax,1),%esi
1016c0: 89 34 01 mov %esi,(%ecx,%eax,1)
1016c3: 83 c0 04 add $0x4,%eax
1016c6: 3b 85 c0 fe ff ff cmp -0x140(%ebp),%eax
1016cc: 72 ef jb 1016bd <crypt_sha256_r+0x9ad>
1016ce: 8b b5 b4 fe ff ff mov -0x14c(%ebp),%esi
1016d4: 01 c1 add %eax,%ecx
1016d6: 01 c2 add %eax,%edx
1016d8: e9 67 f9 ff ff jmp 101044 <crypt_sha256_r+0x334>
1016dd: 8d 76 00 lea 0x0(%esi),%esi
srounds = strtoul(num, &endp, 10);
1016e0: b8 0a 00 00 00 mov $0xa,%eax
1016e5: 89 44 24 08 mov %eax,0x8(%esp)
1016e9: 8d 85 d0 fe ff ff lea -0x130(%ebp),%eax
1016ef: 89 44 24 04 mov %eax,0x4(%esp)
num = salt + sizeof(sha256_rounds_prefix) - 1;
1016f3: 8b 45 0c mov 0xc(%ebp),%eax
1016f6: 83 c0 07 add $0x7,%eax
srounds = strtoul(num, &endp, 10);
1016f9: 89 04 24 mov %eax,(%esp)
1016fc: e8 7f 7a 02 00 call 129180 <strtoul>
if (*endp == '$') {
101701: 8b 95 d0 fe ff ff mov -0x130(%ebp),%edx
101707: 80 3a 24 cmpb $0x24,(%edx)
10170a: 0f 85 65 f6 ff ff jne 100d75 <crypt_sha256_r+0x65> <== NEVER TAKEN
rounds = MAX(ROUNDS_MIN, MIN(srounds, ROUNDS_MAX));
101710: 89 85 ac fe ff ff mov %eax,-0x154(%ebp)
salt = endp + 1;
101716: 8d 5a 01 lea 0x1(%edx),%ebx
rounds = MAX(ROUNDS_MIN, MIN(srounds, ROUNDS_MAX));
101719: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax
salt = endp + 1;
10171e: 89 5d 0c mov %ebx,0xc(%ebp)
rounds = MAX(ROUNDS_MIN, MIN(srounds, ROUNDS_MAX));
101721: 0f 86 91 00 00 00 jbe 1017b8 <crypt_sha256_r+0xaa8> <== ALWAYS TAKEN
101727: bf ff c9 9a 3b mov $0x3b9ac9ff,%edi <== NOT EXECUTED
10172c: 89 bd ac fe ff ff mov %edi,-0x154(%ebp) <== NOT EXECUTED
rounds_custom = true;
101732: c6 85 a7 fe ff ff 01 movb $0x1,-0x159(%ebp)
101739: e9 49 f6 ff ff jmp 100d87 <crypt_sha256_r+0x77>
10173e: 66 90 xchg %ax,%ax
n = snprintf(cp, MAX(0, buflen), "%s%zu$",
101740: 89 74 24 04 mov %esi,0x4(%esp)
101744: 8b 8d ac fe ff ff mov -0x154(%ebp),%ecx
10174a: ba d0 f5 12 00 mov $0x12f5d0,%edx
10174f: 89 54 24 0c mov %edx,0xc(%esp)
101753: 89 04 24 mov %eax,(%esp)
101756: 89 4c 24 10 mov %ecx,0x10(%esp)
10175a: b9 c4 f5 12 00 mov $0x12f5c4,%ecx
10175f: 89 4c 24 08 mov %ecx,0x8(%esp)
101763: e8 48 67 02 00 call 127eb0 <snprintf>
buflen -= n;
101768: 8b b5 d4 fe ff ff mov -0x12c(%ebp),%esi
n = snprintf(cp, MAX(0, buflen), "%s%zu$",
10176e: 89 c2 mov %eax,%edx
cp += n;
101770: 8b 85 cc fe ff ff mov -0x134(%ebp),%eax
buflen -= n;
101776: 29 d6 sub %edx,%esi
101778: 89 b5 d4 fe ff ff mov %esi,-0x12c(%ebp)
cp += n;
10177e: 01 d0 add %edx,%eax
cp = stpncpy(cp, salt, MIN((size_t)MAX(0, buflen), salt_len));
101780: 89 f2 mov %esi,%edx
cp += n;
101782: 89 85 cc fe ff ff mov %eax,-0x134(%ebp)
cp = stpncpy(cp, salt, MIN((size_t)MAX(0, buflen), salt_len));
101788: f7 d2 not %edx
10178a: c1 fa 1f sar $0x1f,%edx
10178d: 21 d6 and %edx,%esi
10178f: e9 08 fb ff ff jmp 10129c <crypt_sha256_r+0x58c>
101794: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10179b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10179f: 90 nop
errno = ERANGE;
1017a0: e8 1b 64 02 00 call 127bc0 <__errno> <== NOT EXECUTED
1017a5: c7 00 22 00 00 00 movl $0x22,(%eax) <== NOT EXECUTED
buffer = NULL;
1017ab: 31 c0 xor %eax,%eax <== NOT EXECUTED
1017ad: 89 85 a8 fe ff ff mov %eax,-0x158(%ebp) <== NOT EXECUTED
1017b3: e9 b8 fd ff ff jmp 101570 <crypt_sha256_r+0x860> <== NOT EXECUTED
1017b8: 81 bd ac fe ff ff e8 cmpl $0x3e8,-0x154(%ebp)
1017bf: 03 00 00
1017c2: 0f 83 6a ff ff ff jae 101732 <crypt_sha256_r+0xa22>
1017c8: bb e8 03 00 00 mov $0x3e8,%ebx
1017cd: 89 9d ac fe ff ff mov %ebx,-0x154(%ebp)
1017d3: e9 5a ff ff ff jmp 101732 <crypt_sha256_r+0xa22>
1017d8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1017df: 90 nop
SHA256_Update(&ctx, alt_result, cnt);
1017e0: 89 1c 24 mov %ebx,(%esp)
1017e3: 8b bd c4 fe ff ff mov -0x13c(%ebp),%edi
1017e9: 8d 85 d8 fe ff ff lea -0x128(%ebp),%eax
1017ef: 89 44 24 04 mov %eax,0x4(%esp)
1017f3: 89 7c 24 08 mov %edi,0x8(%esp)
1017f7: e8 b4 70 00 00 call 1088b0 <SHA256_Update>
for (cnt = key_len; cnt > 0; cnt >>= 1)
1017fc: 85 ff test %edi,%edi
1017fe: 0f 85 b6 f6 ff ff jne 100eba <crypt_sha256_r+0x1aa>
SHA256_Final(alt_result, &ctx);
101804: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
101808: 8d 85 d8 fe ff ff lea -0x128(%ebp),%eax <== NOT EXECUTED
cp = p_bytes = alloca(key_len);
10180e: 31 f6 xor %esi,%esi <== NOT EXECUTED
SHA256_Final(alt_result, &ctx);
101810: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
SHA256_Final(temp_result, &alt_ctx);
101813: 8d bd f8 fe ff ff lea -0x108(%ebp),%edi <== NOT EXECUTED
SHA256_Final(alt_result, &ctx);
101819: e8 52 73 00 00 call 108b70 <SHA256_Final> <== NOT EXECUTED
SHA256_Init(&alt_ctx);
10181e: 8d 45 80 lea -0x80(%ebp),%eax <== NOT EXECUTED
101821: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
101824: e8 37 70 00 00 call 108860 <SHA256_Init> <== NOT EXECUTED
SHA256_Final(temp_result, &alt_ctx);
101829: 8d 45 80 lea -0x80(%ebp),%eax <== NOT EXECUTED
10182c: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
101830: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
101833: e8 38 73 00 00 call 108b70 <SHA256_Final> <== NOT EXECUTED
cp = p_bytes = alloca(key_len);
101838: 8d 44 24 18 lea 0x18(%esp),%eax <== NOT EXECUTED
10183c: 89 85 bc fe ff ff mov %eax,-0x144(%ebp) <== NOT EXECUTED
101842: 89 85 cc fe ff ff mov %eax,-0x134(%ebp) <== NOT EXECUTED
for (cnt = key_len; cnt >= 32; cnt -= 32) {
101848: e9 ea f7 ff ff jmp 101037 <crypt_sha256_r+0x327> <== NOT EXECUTED
memcpy(cp, temp_result, cnt);
10184d: 0f b7 02 movzwl (%edx),%eax <== NOT EXECUTED
101850: 83 c1 02 add $0x2,%ecx <== NOT EXECUTED
101853: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
101856: 83 ee 02 sub $0x2,%esi <== NOT EXECUTED
101859: 66 89 41 fe mov %ax,-0x2(%ecx) <== NOT EXECUTED
10185d: e9 3f fe ff ff jmp 1016a1 <crypt_sha256_r+0x991> <== NOT EXECUTED
101862: 0f b6 07 movzbl (%edi),%eax <== NOT EXECUTED
101865: 41 inc %ecx <== NOT EXECUTED
101866: 4e dec %esi <== NOT EXECUTED
101867: 8d 95 f9 fe ff ff lea -0x107(%ebp),%edx <== NOT EXECUTED
10186d: 88 41 ff mov %al,-0x1(%ecx) <== NOT EXECUTED
101870: e9 23 fe ff ff jmp 101698 <crypt_sha256_r+0x988> <== NOT EXECUTED
for (cnt = key_len; cnt >= 32; cnt -= 32) {
101875: 8b 85 bc fe ff ff mov -0x144(%ebp),%eax
10187b: 8b b5 c4 fe ff ff mov -0x13c(%ebp),%esi
101881: e9 b1 f7 ff ff jmp 101037 <crypt_sha256_r+0x327>
101886: 90 nop
101887: 90 nop
101888: 90 nop
101889: 90 nop
10188a: 90 nop
10188b: 90 nop
10188c: 90 nop
10188d: 90 nop
10188e: 90 nop
10188f: 90 nop
00101890 <crypt_sha512_r>:
/* Maximum number of rounds. */
#define ROUNDS_MAX 999999999
char *
crypt_sha512_r(const char *key, const char *salt, struct crypt_data *data)
{
101890: 55 push %ebp
101891: 89 e5 mov %esp,%ebp
101893: 57 push %edi
101894: 56 push %esi
101895: 53 push %ebx
101896: 81 ec 8c 02 00 00 sub $0x28c,%esp
SHA512_CTX ctx, alt_ctx;
size_t salt_len, key_len, cnt, rounds;
char *cp, *copied_key, *copied_salt, *p_bytes, *s_bytes, *endp;
const char *num;
bool rounds_custom;
char *buffer = &data->buffer[0];
10189c: 8b 45 10 mov 0x10(%ebp),%eax
{
10189f: 8b 75 08 mov 0x8(%ebp),%esi
char *buffer = &data->buffer[0];
1018a2: 89 85 98 fd ff ff mov %eax,-0x268(%ebp)
int buflen = (int)sizeof(data->buffer);
1018a8: b8 00 01 00 00 mov $0x100,%eax
1018ad: 89 85 c4 fd ff ff mov %eax,-0x23c(%ebp)
rounds = ROUNDS_DEFAULT;
rounds_custom = false;
/* Find beginning of salt string. The prefix should normally always
* be present. Just in case it is not. */
if (strncmp(sha512_salt_prefix, salt, sizeof(sha512_salt_prefix) - 1) == 0)
1018b3: 8b 45 0c mov 0xc(%ebp),%eax
1018b6: 80 38 24 cmpb $0x24,(%eax)
1018b9: 75 15 jne 1018d0 <crypt_sha512_r+0x40>
1018bb: 80 78 01 36 cmpb $0x36,0x1(%eax)
1018bf: 0f 84 7b 0b 00 00 je 102440 <crypt_sha512_r+0xbb0>
1018c5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1018cc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
/* Skip salt prefix. */
salt += sizeof(sha512_salt_prefix) - 1;
if (strncmp(salt, sha512_rounds_prefix, sizeof(sha512_rounds_prefix) - 1)
1018d0: b8 07 00 00 00 mov $0x7,%eax
1018d5: 89 44 24 08 mov %eax,0x8(%esp)
1018d9: b8 e0 f5 12 00 mov $0x12f5e0,%eax
1018de: 89 44 24 04 mov %eax,0x4(%esp)
1018e2: 8b 45 0c mov 0xc(%ebp),%eax
1018e5: 89 04 24 mov %eax,(%esp)
1018e8: e8 23 6b 02 00 call 128410 <strncmp>
1018ed: 85 c0 test %eax,%eax
1018ef: 0f 84 eb 0b 00 00 je 1024e0 <crypt_sha512_r+0xc50> <== NEVER TAKEN
rounds_custom = false;
1018f5: c6 85 97 fd ff ff 00 movb $0x0,-0x269(%ebp)
rounds = ROUNDS_DEFAULT;
1018fc: ba 88 13 00 00 mov $0x1388,%edx
101901: 89 95 a4 fd ff ff mov %edx,-0x25c(%ebp)
rounds = MAX(ROUNDS_MIN, MIN(srounds, ROUNDS_MAX));
rounds_custom = true;
}
}
salt_len = MIN(strcspn(salt, "$"), SALT_LEN_MAX);
101907: b8 c2 f5 12 00 mov $0x12f5c2,%eax
10190c: 89 44 24 04 mov %eax,0x4(%esp)
101910: 8b 45 0c mov 0xc(%ebp),%eax
101913: 89 04 24 mov %eax,(%esp)
101916: e8 c5 68 02 00 call 1281e0 <strcspn>
10191b: 89 85 ac fd ff ff mov %eax,-0x254(%ebp)
101921: 83 f8 0f cmp $0xf,%eax
101924: 76 0b jbe 101931 <crypt_sha512_r+0xa1>
101926: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED
10192b: 89 85 ac fd ff ff mov %eax,-0x254(%ebp) <== NOT EXECUTED
key_len = strlen(key);
101931: 89 34 24 mov %esi,(%esp)
/* Prepare for the real work. */
SHA512_Init(&ctx);
101934: 8d 9d 48 fe ff ff lea -0x1b8(%ebp),%ebx
key_len = strlen(key);
10193a: e8 d1 69 02 00 call 128310 <strlen>
SHA512_Init(&ctx);
10193f: 89 1c 24 mov %ebx,(%esp)
key_len = strlen(key);
101942: 89 85 b4 fd ff ff mov %eax,-0x24c(%ebp)
101948: 89 c7 mov %eax,%edi
SHA512_Init(&ctx);
10194a: e8 f1 19 01 00 call 113340 <SHA512_Init>
/* Add the key string. */
SHA512_Update(&ctx, key, key_len);
10194f: 89 7c 24 08 mov %edi,0x8(%esp)
101953: 89 74 24 04 mov %esi,0x4(%esp)
101957: 89 1c 24 mov %ebx,(%esp)
10195a: e8 81 1a 01 00 call 1133e0 <SHA512_Update>
/* The last part is the salt string. This must be at most 8
* characters and it ends at the first `$' character (for
* compatibility with existing implementations). */
SHA512_Update(&ctx, salt, salt_len);
10195f: 8b 85 ac fd ff ff mov -0x254(%ebp),%eax <== NOT EXECUTED
101965: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
101968: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
10196b: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10196f: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
101973: e8 68 1a 01 00 call 1133e0 <SHA512_Update> <== NOT EXECUTED
/* Compute alternate SHA512 sum with input KEY, SALT, and KEY. The
* final result will be added to the first context. */
SHA512_Init(&alt_ctx);
101978: 8d 8d 18 ff ff ff lea -0xe8(%ebp),%ecx
10197e: 89 0c 24 mov %ecx,(%esp)
101981: e8 ba 19 01 00 call 113340 <SHA512_Init>
/* Add key. */
SHA512_Update(&alt_ctx, key, key_len);
101986: 8d 8d 18 ff ff ff lea -0xe8(%ebp),%ecx
10198c: 89 0c 24 mov %ecx,(%esp)
10198f: 89 7c 24 08 mov %edi,0x8(%esp)
101993: 89 74 24 04 mov %esi,0x4(%esp)
101997: e8 44 1a 01 00 call 1133e0 <SHA512_Update>
/* Add salt. */
SHA512_Update(&alt_ctx, salt, salt_len);
10199c: 8b 85 ac fd ff ff mov -0x254(%ebp),%eax
1019a2: 89 44 24 08 mov %eax,0x8(%esp)
1019a6: 8b 45 0c mov 0xc(%ebp),%eax
1019a9: 89 44 24 04 mov %eax,0x4(%esp)
1019ad: 8d 85 18 ff ff ff lea -0xe8(%ebp),%eax
1019b3: 89 04 24 mov %eax,(%esp)
1019b6: e8 25 1a 01 00 call 1133e0 <SHA512_Update>
/* Add key again. */
SHA512_Update(&alt_ctx, key, key_len);
1019bb: 8d 85 18 ff ff ff lea -0xe8(%ebp),%eax <== NOT EXECUTED
1019c1: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1019c4: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED
1019c8: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
1019cc: e8 0f 1a 01 00 call 1133e0 <SHA512_Update> <== NOT EXECUTED
/* Now get result of this (64 bytes) and add it to the other context. */
SHA512_Final(alt_result, &alt_ctx);
1019d1: 8d 85 18 ff ff ff lea -0xe8(%ebp),%eax
1019d7: 89 44 24 04 mov %eax,0x4(%esp)
1019db: 8d 85 c8 fd ff ff lea -0x238(%ebp),%eax
1019e1: 89 04 24 mov %eax,(%esp)
1019e4: e8 07 1d 01 00 call 1136f0 <SHA512_Final>
/* Add for any character in the key one byte of the alternate sum. */
for (cnt = key_len; cnt > 64; cnt -= 64)
1019e9: 83 ff 40 cmp $0x40,%edi
1019ec: 0f 86 ee 0b 00 00 jbe 1025e0 <crypt_sha512_r+0xd50> <== NEVER TAKEN
1019f2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1019f9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
SHA512_Update(&ctx, alt_result, 64);
101a00: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
101a03: b8 40 00 00 00 mov $0x40,%eax <== NOT EXECUTED
for (cnt = key_len; cnt > 64; cnt -= 64)
101a08: 83 ef 40 sub $0x40,%edi <== NOT EXECUTED
SHA512_Update(&ctx, alt_result, 64);
101a0b: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
101a0f: 8d 85 c8 fd ff ff lea -0x238(%ebp),%eax <== NOT EXECUTED
101a15: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
101a19: e8 c2 19 01 00 call 1133e0 <SHA512_Update> <== NOT EXECUTED
for (cnt = key_len; cnt > 64; cnt -= 64)
101a1e: 83 ff 40 cmp $0x40,%edi
101a21: 77 dd ja 101a00 <crypt_sha512_r+0x170> <== NEVER TAKEN
SHA512_Update(&ctx, alt_result, cnt);
101a23: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
for (cnt = key_len; cnt > 64; cnt -= 64)
101a26: 8b 85 b4 fd ff ff mov -0x24c(%ebp),%eax <== NOT EXECUTED
101a2c: 8d 50 bf lea -0x41(%eax),%edx <== NOT EXECUTED
101a2f: 83 e8 40 sub $0x40,%eax <== NOT EXECUTED
101a32: 83 e2 c0 and $0xffffffc0,%edx <== NOT EXECUTED
101a35: 29 d0 sub %edx,%eax <== NOT EXECUTED
SHA512_Update(&ctx, alt_result, cnt);
101a37: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
101a3b: 8d 85 c8 fd ff ff lea -0x238(%ebp),%eax <== NOT EXECUTED
101a41: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
101a45: e8 96 19 01 00 call 1133e0 <SHA512_Update> <== NOT EXECUTED
key_len = strlen(key);
101a4a: 8b bd b4 fd ff ff mov -0x24c(%ebp),%edi
101a50: eb 2d jmp 101a7f <crypt_sha512_r+0x1ef>
101a52: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
101a59: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
/* Take the binary representation of the length of the key and for
* every 1 add the alternate sum, for every 0 the key. */
for (cnt = key_len; cnt > 0; cnt >>= 1)
if ((cnt & 1) != 0)
SHA512_Update(&ctx, alt_result, 64);
101a60: 89 1c 24 mov %ebx,(%esp)
101a63: b8 40 00 00 00 mov $0x40,%eax
101a68: 89 44 24 08 mov %eax,0x8(%esp)
101a6c: 8d 85 c8 fd ff ff lea -0x238(%ebp),%eax
101a72: 89 44 24 04 mov %eax,0x4(%esp)
101a76: e8 65 19 01 00 call 1133e0 <SHA512_Update>
for (cnt = key_len; cnt > 0; cnt >>= 1)
101a7b: d1 ef shr %edi
101a7d: 74 22 je 101aa1 <crypt_sha512_r+0x211>
if ((cnt & 1) != 0)
101a7f: f7 c7 01 00 00 00 test $0x1,%edi
101a85: 75 d9 jne 101a60 <crypt_sha512_r+0x1d0>
else
SHA512_Update(&ctx, key, key_len);
101a87: 89 74 24 04 mov %esi,0x4(%esp)
101a8b: 8b 85 b4 fd ff ff mov -0x24c(%ebp),%eax
101a91: 89 1c 24 mov %ebx,(%esp)
101a94: 89 44 24 08 mov %eax,0x8(%esp)
101a98: e8 43 19 01 00 call 1133e0 <SHA512_Update>
for (cnt = key_len; cnt > 0; cnt >>= 1)
101a9d: d1 ef shr %edi
101a9f: 75 de jne 101a7f <crypt_sha512_r+0x1ef> <== ALWAYS TAKEN
/* Create intermediate result. */
SHA512_Final(alt_result, &ctx);
101aa1: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
101aa5: 8d 85 c8 fd ff ff lea -0x238(%ebp),%eax <== NOT EXECUTED
101aab: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
101aae: e8 3d 1c 01 00 call 1136f0 <SHA512_Final> <== NOT EXECUTED
/* Start computation of P byte sequence. */
SHA512_Init(&alt_ctx);
101ab3: 8d 85 18 ff ff ff lea -0xe8(%ebp),%eax
101ab9: 89 04 24 mov %eax,(%esp)
101abc: e8 7f 18 01 00 call 113340 <SHA512_Init>
/* For every character in the password add the entire password. */
for (cnt = 0; cnt < key_len; ++cnt)
101ac1: 89 75 08 mov %esi,0x8(%ebp)
101ac4: 8b b5 b4 fd ff ff mov -0x24c(%ebp),%esi
101aca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
SHA512_Update(&alt_ctx, key, key_len);
101ad0: 89 74 24 08 mov %esi,0x8(%esp)
101ad4: 8b 45 08 mov 0x8(%ebp),%eax
for (cnt = 0; cnt < key_len; ++cnt)
101ad7: 47 inc %edi
SHA512_Update(&alt_ctx, key, key_len);
101ad8: 89 44 24 04 mov %eax,0x4(%esp)
101adc: 8d 85 18 ff ff ff lea -0xe8(%ebp),%eax
101ae2: 89 04 24 mov %eax,(%esp)
101ae5: e8 f6 18 01 00 call 1133e0 <SHA512_Update>
for (cnt = 0; cnt < key_len; ++cnt)
101aea: 39 fe cmp %edi,%esi
101aec: 77 e2 ja 101ad0 <crypt_sha512_r+0x240>
/* Finish the digest. */
SHA512_Final(temp_result, &alt_ctx);
101aee: 8d 85 18 ff ff ff lea -0xe8(%ebp),%eax <== NOT EXECUTED
101af4: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
101af8: 8d bd 08 fe ff ff lea -0x1f8(%ebp),%edi <== NOT EXECUTED
101afe: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
101b01: e8 ea 1b 01 00 call 1136f0 <SHA512_Final> <== NOT EXECUTED
/* Create byte sequence P. */
cp = p_bytes = alloca(key_len);
101b06: 8b 8d b4 fd ff ff mov -0x24c(%ebp),%ecx
101b0c: 8d 41 1b lea 0x1b(%ecx),%eax
101b0f: 83 e0 f0 and $0xfffffff0,%eax
101b12: 29 c4 sub %eax,%esp
101b14: 8d 44 24 27 lea 0x27(%esp),%eax
101b18: 83 e0 f0 and $0xfffffff0,%eax
for (cnt = key_len; cnt >= 64; cnt -= 64) {
101b1b: 83 f9 3f cmp $0x3f,%ecx
cp = p_bytes = alloca(key_len);
101b1e: 89 85 b0 fd ff ff mov %eax,-0x250(%ebp)
101b24: 89 85 bc fd ff ff mov %eax,-0x244(%ebp)
for (cnt = key_len; cnt >= 64; cnt -= 64) {
101b2a: 0f 86 4b 0b 00 00 jbe 10267b <crypt_sha512_r+0xdeb> <== NEVER TAKEN
101b30: 89 8d 9c fd ff ff mov %ecx,-0x264(%ebp)
101b36: 89 bd a8 fd ff ff mov %edi,-0x258(%ebp)
memcpy(cp, temp_result, 64);
101b3c: a8 01 test $0x1,%al
101b3e: 8b 8d a8 fd ff ff mov -0x258(%ebp),%ecx
101b44: 89 c2 mov %eax,%edx
101b46: be 40 00 00 00 mov $0x40,%esi
101b4b: 0f 85 6f 08 00 00 jne 1023c0 <crypt_sha512_r+0xb30> <== NEVER TAKEN
101b51: f6 c2 02 test $0x2,%dl
101b54: 0f 85 46 08 00 00 jne 1023a0 <crypt_sha512_r+0xb10> <== NEVER TAKEN
101b5a: 89 b5 a0 fd ff ff mov %esi,-0x260(%ebp)
101b60: 89 f7 mov %esi,%edi
101b62: 31 c0 xor %eax,%eax
101b64: 83 e7 fc and $0xfffffffc,%edi
101b67: 8b 34 01 mov (%ecx,%eax,1),%esi
101b6a: 89 34 02 mov %esi,(%edx,%eax,1)
101b6d: 83 c0 04 add $0x4,%eax
101b70: 39 f8 cmp %edi,%eax
101b72: 72 f3 jb 101b67 <crypt_sha512_r+0x2d7>
101b74: 8b b5 a0 fd ff ff mov -0x260(%ebp),%esi
101b7a: 01 c2 add %eax,%edx
101b7c: 01 c1 add %eax,%ecx
101b7e: 31 c0 xor %eax,%eax
101b80: f7 c6 02 00 00 00 test $0x2,%esi
101b86: 74 0b je 101b93 <crypt_sha512_r+0x303> <== ALWAYS TAKEN
101b88: 0f b7 01 movzwl (%ecx),%eax <== NOT EXECUTED
101b8b: 66 89 02 mov %ax,(%edx) <== NOT EXECUTED
101b8e: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED
101b93: 83 e6 01 and $0x1,%esi
101b96: 74 07 je 101b9f <crypt_sha512_r+0x30f> <== ALWAYS TAKEN
101b98: 0f b6 0c 01 movzbl (%ecx,%eax,1),%ecx <== NOT EXECUTED
101b9c: 88 0c 02 mov %cl,(%edx,%eax,1) <== NOT EXECUTED
for (cnt = key_len; cnt >= 64; cnt -= 64) {
101b9f: 83 ad 9c fd ff ff 40 subl $0x40,-0x264(%ebp)
cp += 64;
101ba6: 8b 85 bc fd ff ff mov -0x244(%ebp),%eax
for (cnt = key_len; cnt >= 64; cnt -= 64) {
101bac: 8b 8d 9c fd ff ff mov -0x264(%ebp),%ecx
cp += 64;
101bb2: 83 c0 40 add $0x40,%eax
101bb5: 89 85 bc fd ff ff mov %eax,-0x244(%ebp)
for (cnt = key_len; cnt >= 64; cnt -= 64) {
101bbb: 83 f9 3f cmp $0x3f,%ecx
101bbe: 0f 87 78 ff ff ff ja 101b3c <crypt_sha512_r+0x2ac> <== NEVER TAKEN
101bc4: 8b b5 b4 fd ff ff mov -0x24c(%ebp),%esi <== NOT EXECUTED
101bca: 8b bd a8 fd ff ff mov -0x258(%ebp),%edi <== NOT EXECUTED
101bd0: 83 e6 3f and $0x3f,%esi <== NOT EXECUTED
}
memcpy(cp, temp_result, cnt);
101bd3: 83 fe 04 cmp $0x4,%esi
101bd6: 89 c1 mov %eax,%ecx
101bd8: 89 fa mov %edi,%edx
101bda: 0f 83 b0 08 00 00 jae 102490 <crypt_sha512_r+0xc00>
101be0: 31 c0 xor %eax,%eax
101be2: f7 c6 02 00 00 00 test $0x2,%esi
101be8: 0f 85 02 08 00 00 jne 1023f0 <crypt_sha512_r+0xb60> <== NEVER TAKEN
101bee: 83 e6 01 and $0x1,%esi
101bf1: 0f 85 e9 07 00 00 jne 1023e0 <crypt_sha512_r+0xb50> <== NEVER TAKEN
/* Start computation of S byte sequence. */
SHA512_Init(&alt_ctx);
101bf7: 8d 85 18 ff ff ff lea -0xe8(%ebp),%eax
/* For every character in the password add the entire password. */
for (cnt = 0; cnt < 16 + alt_result[0]; ++cnt)
101bfd: 31 f6 xor %esi,%esi
SHA512_Init(&alt_ctx);
101bff: 89 04 24 mov %eax,(%esp)
101c02: e8 39 17 01 00 call 113340 <SHA512_Init>
for (cnt = 0; cnt < 16 + alt_result[0]; ++cnt)
101c07: 89 bd a8 fd ff ff mov %edi,-0x258(%ebp)
101c0d: 8b bd ac fd ff ff mov -0x254(%ebp),%edi
101c13: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
101c1a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
SHA512_Update(&alt_ctx, salt, salt_len);
101c20: 89 7c 24 08 mov %edi,0x8(%esp)
101c24: 8b 45 0c mov 0xc(%ebp),%eax
for (cnt = 0; cnt < 16 + alt_result[0]; ++cnt)
101c27: 46 inc %esi
SHA512_Update(&alt_ctx, salt, salt_len);
101c28: 89 44 24 04 mov %eax,0x4(%esp)
101c2c: 8d 85 18 ff ff ff lea -0xe8(%ebp),%eax
101c32: 89 04 24 mov %eax,(%esp)
101c35: e8 a6 17 01 00 call 1133e0 <SHA512_Update>
for (cnt = 0; cnt < 16 + alt_result[0]; ++cnt)
101c3a: 0f b6 85 c8 fd ff ff movzbl -0x238(%ebp),%eax
101c41: 83 c0 10 add $0x10,%eax
101c44: 39 f0 cmp %esi,%eax
101c46: 77 d8 ja 101c20 <crypt_sha512_r+0x390>
/* Finish the digest. */
SHA512_Final(temp_result, &alt_ctx);
101c48: 8b bd a8 fd ff ff mov -0x258(%ebp),%edi <== NOT EXECUTED
101c4e: 8d 85 18 ff ff ff lea -0xe8(%ebp),%eax <== NOT EXECUTED
101c54: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
101c58: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
101c5b: e8 90 1a 01 00 call 1136f0 <SHA512_Final> <== NOT EXECUTED
/* Create byte sequence S. */
cp = s_bytes = alloca(salt_len);
101c60: 8b 95 ac fd ff ff mov -0x254(%ebp),%edx
101c66: 8d 42 1b lea 0x1b(%edx),%eax
101c69: 83 e0 f0 and $0xfffffff0,%eax
101c6c: 29 c4 sub %eax,%esp
101c6e: 8d 44 24 27 lea 0x27(%esp),%eax
101c72: 83 e0 f0 and $0xfffffff0,%eax
for (cnt = salt_len; cnt >= 64; cnt -= 64) {
memcpy(cp, temp_result, 64);
cp += 64;
}
memcpy(cp, temp_result, cnt);
101c75: 83 fa 04 cmp $0x4,%edx
cp = s_bytes = alloca(salt_len);
101c78: 89 85 a8 fd ff ff mov %eax,-0x258(%ebp)
101c7e: 89 c6 mov %eax,%esi
memcpy(cp, temp_result, cnt);
101c80: 89 c1 mov %eax,%ecx
cp = s_bytes = alloca(salt_len);
101c82: 89 85 bc fd ff ff mov %eax,-0x244(%ebp)
memcpy(cp, temp_result, cnt);
101c88: 89 f8 mov %edi,%eax
101c8a: 0f 83 d0 07 00 00 jae 102460 <crypt_sha512_r+0xbd0>
101c90: 31 d2 xor %edx,%edx
101c92: f6 85 ac fd ff ff 02 testb $0x2,-0x254(%ebp)
101c99: 0f 85 81 07 00 00 jne 102420 <crypt_sha512_r+0xb90> <== NEVER TAKEN
101c9f: f6 85 ac fd ff ff 01 testb $0x1,-0x254(%ebp)
101ca6: 0f 85 64 07 00 00 jne 102410 <crypt_sha512_r+0xb80> <== NEVER TAKEN
/* Repeatedly run the collected hash value through SHA512 to burn CPU
* cycles. */
for (cnt = 0; cnt < rounds; ++cnt) {
101cac: 31 f6 xor %esi,%esi
101cae: e9 8d 00 00 00 jmp 101d40 <crypt_sha512_r+0x4b0>
101cb3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
101cba: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
/* New context. */
SHA512_Init(&ctx);
/* Add key or last result. */
if ((cnt & 1) != 0)
SHA512_Update(&ctx, p_bytes, key_len);
101cc0: 89 1c 24 mov %ebx,(%esp)
101cc3: 8b 85 b4 fd ff ff mov -0x24c(%ebp),%eax
101cc9: 89 44 24 08 mov %eax,0x8(%esp)
101ccd: 8b 85 b0 fd ff ff mov -0x250(%ebp),%eax
101cd3: 89 44 24 04 mov %eax,0x4(%esp)
101cd7: e8 04 17 01 00 call 1133e0 <SHA512_Update>
else
SHA512_Update(&ctx, alt_result, 64);
101cdc: 69 c6 ab aa aa aa imul $0xaaaaaaab,%esi,%eax
/* Add salt for numbers not divisible by 3. */
if (cnt % 3 != 0)
101ce2: 3d 55 55 55 55 cmp $0x55555555,%eax
101ce7: 0f 87 92 00 00 00 ja 101d7f <crypt_sha512_r+0x4ef>
SHA512_Update(&ctx, s_bytes, salt_len);
101ced: 69 c6 b7 6d db b6 imul $0xb6db6db7,%esi,%eax
/* Add key for numbers not divisible by 7. */
if (cnt % 7 != 0)
101cf3: 3d 24 49 92 24 cmp $0x24924924,%eax
101cf8: 0f 87 ae 00 00 00 ja 101dac <crypt_sha512_r+0x51c>
SHA512_Update(&ctx, p_bytes, key_len);
/* Add key or last result. */
if ((cnt & 1) != 0)
101cfe: 85 ff test %edi,%edi
101d00: 0f 84 ca 00 00 00 je 101dd0 <crypt_sha512_r+0x540>
SHA512_Update(&ctx, alt_result, 64);
101d06: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
101d09: 8d 85 c8 fd ff ff lea -0x238(%ebp),%eax <== NOT EXECUTED
101d0f: bf 40 00 00 00 mov $0x40,%edi <== NOT EXECUTED
101d14: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED
101d18: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
101d1c: e8 bf 16 01 00 call 1133e0 <SHA512_Update> <== NOT EXECUTED
else
SHA512_Update(&ctx, p_bytes, key_len);
/* Create intermediate result. */
SHA512_Final(alt_result, &ctx);
101d21: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
101d25: 8d 85 c8 fd ff ff lea -0x238(%ebp),%eax <== NOT EXECUTED
for (cnt = 0; cnt < rounds; ++cnt) {
101d2b: 46 inc %esi <== NOT EXECUTED
SHA512_Final(alt_result, &ctx);
101d2c: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
101d2f: e8 bc 19 01 00 call 1136f0 <SHA512_Final> <== NOT EXECUTED
for (cnt = 0; cnt < rounds; ++cnt) {
101d34: 39 b5 a4 fd ff ff cmp %esi,-0x25c(%ebp)
101d3a: 0f 84 c0 00 00 00 je 101e00 <crypt_sha512_r+0x570>
SHA512_Init(&ctx);
101d40: 89 1c 24 mov %ebx,(%esp)
if ((cnt & 1) != 0)
101d43: 89 f7 mov %esi,%edi
SHA512_Init(&ctx);
101d45: e8 f6 15 01 00 call 113340 <SHA512_Init>
if ((cnt & 1) != 0)
101d4a: 83 e7 01 and $0x1,%edi
101d4d: 0f 85 6d ff ff ff jne 101cc0 <crypt_sha512_r+0x430>
SHA512_Update(&ctx, alt_result, 64);
101d53: 89 1c 24 mov %ebx,(%esp)
101d56: b8 40 00 00 00 mov $0x40,%eax
101d5b: 89 44 24 08 mov %eax,0x8(%esp)
101d5f: 8d 85 c8 fd ff ff lea -0x238(%ebp),%eax
101d65: 89 44 24 04 mov %eax,0x4(%esp)
101d69: e8 72 16 01 00 call 1133e0 <SHA512_Update>
101d6e: 69 c6 ab aa aa aa imul $0xaaaaaaab,%esi,%eax
if (cnt % 3 != 0)
101d74: 3d 55 55 55 55 cmp $0x55555555,%eax
101d79: 0f 86 6e ff ff ff jbe 101ced <crypt_sha512_r+0x45d>
SHA512_Update(&ctx, s_bytes, salt_len);
101d7f: 89 1c 24 mov %ebx,(%esp)
101d82: 8b 85 ac fd ff ff mov -0x254(%ebp),%eax
101d88: 89 44 24 08 mov %eax,0x8(%esp)
101d8c: 8b 85 a8 fd ff ff mov -0x258(%ebp),%eax
101d92: 89 44 24 04 mov %eax,0x4(%esp)
101d96: e8 45 16 01 00 call 1133e0 <SHA512_Update>
101d9b: 69 c6 b7 6d db b6 imul $0xb6db6db7,%esi,%eax
if (cnt % 7 != 0)
101da1: 3d 24 49 92 24 cmp $0x24924924,%eax
101da6: 0f 86 52 ff ff ff jbe 101cfe <crypt_sha512_r+0x46e>
SHA512_Update(&ctx, p_bytes, key_len);
101dac: 89 1c 24 mov %ebx,(%esp)
101daf: 8b 85 b4 fd ff ff mov -0x24c(%ebp),%eax
101db5: 89 44 24 08 mov %eax,0x8(%esp)
101db9: 8b 85 b0 fd ff ff mov -0x250(%ebp),%eax
101dbf: 89 44 24 04 mov %eax,0x4(%esp)
101dc3: e8 18 16 01 00 call 1133e0 <SHA512_Update>
if ((cnt & 1) != 0)
101dc8: 85 ff test %edi,%edi
101dca: 0f 85 36 ff ff ff jne 101d06 <crypt_sha512_r+0x476>
SHA512_Update(&ctx, p_bytes, key_len);
101dd0: 89 1c 24 mov %ebx,(%esp)
101dd3: 8b 85 b4 fd ff ff mov -0x24c(%ebp),%eax
101dd9: 89 44 24 08 mov %eax,0x8(%esp)
101ddd: 8b 85 b0 fd ff ff mov -0x250(%ebp),%eax
101de3: 89 44 24 04 mov %eax,0x4(%esp)
101de7: e8 f4 15 01 00 call 1133e0 <SHA512_Update>
101dec: e9 30 ff ff ff jmp 101d21 <crypt_sha512_r+0x491>
101df1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
101df8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
101dff: 90 nop
}
/* Now we can construct the result string. It consists of three
* parts. */
cp = stpncpy(buffer, sha512_salt_prefix, MAX(0, buflen));
101e00: 8b b5 c4 fd ff ff mov -0x23c(%ebp),%esi
101e06: b9 e8 f5 12 00 mov $0x12f5e8,%ecx
101e0b: 89 4c 24 04 mov %ecx,0x4(%esp)
101e0f: 89 f0 mov %esi,%eax
101e11: f7 d0 not %eax
101e13: c1 f8 1f sar $0x1f,%eax
101e16: 21 f0 and %esi,%eax
buflen -= sizeof(sha512_salt_prefix) - 1;
101e18: 83 ee 03 sub $0x3,%esi
cp = stpncpy(buffer, sha512_salt_prefix, MAX(0, buflen));
101e1b: 89 44 24 08 mov %eax,0x8(%esp)
101e1f: 8b 45 10 mov 0x10(%ebp),%eax
101e22: 89 04 24 mov %eax,(%esp)
101e25: e8 d6 61 02 00 call 128000 <stpncpy>
if (rounds_custom) {
n = snprintf(cp, MAX(0, buflen), "%s%zu$",
101e2a: 89 f2 mov %esi,%edx
buflen -= sizeof(sha512_salt_prefix) - 1;
101e2c: 89 b5 c4 fd ff ff mov %esi,-0x23c(%ebp)
n = snprintf(cp, MAX(0, buflen), "%s%zu$",
101e32: f7 d2 not %edx
101e34: c1 fa 1f sar $0x1f,%edx
101e37: 21 d6 and %edx,%esi
if (rounds_custom) {
101e39: 80 bd 97 fd ff ff 00 cmpb $0x0,-0x269(%ebp)
cp = stpncpy(buffer, sha512_salt_prefix, MAX(0, buflen));
101e40: 89 85 bc fd ff ff mov %eax,-0x244(%ebp)
if (rounds_custom) {
101e46: 0f 85 f4 06 00 00 jne 102540 <crypt_sha512_r+0xcb0> <== NEVER TAKEN
cp += n;
buflen -= n;
}
cp = stpncpy(cp, salt, MIN((size_t)MAX(0, buflen), salt_len));
101e4c: 8b 8d ac fd ff ff mov -0x254(%ebp),%ecx
101e52: 39 f1 cmp %esi,%ecx
101e54: 89 ca mov %ecx,%edx
101e56: 76 02 jbe 101e5a <crypt_sha512_r+0x5ca> <== ALWAYS TAKEN
101e58: 89 f2 mov %esi,%edx <== NOT EXECUTED
101e5a: 89 54 24 08 mov %edx,0x8(%esp)
101e5e: 8b 4d 0c mov 0xc(%ebp),%ecx
101e61: 89 04 24 mov %eax,(%esp)
101e64: 89 4c 24 04 mov %ecx,0x4(%esp)
101e68: e8 93 61 02 00 call 128000 <stpncpy>
buflen -= MIN((size_t)MAX(0, buflen), salt_len);
101e6d: 8b 95 c4 fd ff ff mov -0x23c(%ebp),%edx
101e73: 8b b5 ac fd ff ff mov -0x254(%ebp),%esi
cp = stpncpy(cp, salt, MIN((size_t)MAX(0, buflen), salt_len));
101e79: 89 85 bc fd ff ff mov %eax,-0x244(%ebp)
101e7f: 89 c1 mov %eax,%ecx
buflen -= MIN((size_t)MAX(0, buflen), salt_len);
101e81: 89 d0 mov %edx,%eax
101e83: f7 d0 not %eax
101e85: c1 f8 1f sar $0x1f,%eax
101e88: 21 d0 and %edx,%eax
101e8a: 39 f0 cmp %esi,%eax
101e8c: 76 02 jbe 101e90 <crypt_sha512_r+0x600> <== NEVER TAKEN
101e8e: 89 f0 mov %esi,%eax
101e90: 29 c2 sub %eax,%edx
101e92: 89 95 c4 fd ff ff mov %edx,-0x23c(%ebp)
if (buflen > 0) {
101e98: 85 d2 test %edx,%edx
101e9a: 7e 12 jle 101eae <crypt_sha512_r+0x61e> <== NEVER TAKEN
*cp++ = '$';
101e9c: 8d 41 01 lea 0x1(%ecx),%eax
101e9f: 89 85 bc fd ff ff mov %eax,-0x244(%ebp)
101ea5: c6 01 24 movb $0x24,(%ecx)
--buflen;
101ea8: ff 8d c4 fd ff ff decl -0x23c(%ebp)
}
b64_from_24bit(alt_result[0], alt_result[21], alt_result[42], 4, &buflen, &cp);
101eae: 0f b6 85 f2 fd ff ff movzbl -0x20e(%ebp),%eax
101eb5: 8d b5 c4 fd ff ff lea -0x23c(%ebp),%esi
101ebb: ba 04 00 00 00 mov $0x4,%edx
101ec0: 89 54 24 0c mov %edx,0xc(%esp)
101ec4: 8d bd bc fd ff ff lea -0x244(%ebp),%edi
101eca: 89 74 24 10 mov %esi,0x10(%esp)
101ece: 89 7c 24 14 mov %edi,0x14(%esp)
101ed2: 89 44 24 08 mov %eax,0x8(%esp)
101ed6: 0f b6 85 dd fd ff ff movzbl -0x223(%ebp),%eax
101edd: 89 44 24 04 mov %eax,0x4(%esp)
101ee1: 0f b6 85 c8 fd ff ff movzbl -0x238(%ebp),%eax
101ee8: 89 04 24 mov %eax,(%esp)
101eeb: e8 e0 07 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[22], alt_result[43], alt_result[1], 4, &buflen, &cp);
101ef0: 0f b6 85 c9 fd ff ff movzbl -0x237(%ebp),%eax
101ef7: b9 04 00 00 00 mov $0x4,%ecx
101efc: 89 4c 24 0c mov %ecx,0xc(%esp)
101f00: 89 74 24 10 mov %esi,0x10(%esp)
101f04: 89 7c 24 14 mov %edi,0x14(%esp)
101f08: 89 44 24 08 mov %eax,0x8(%esp)
101f0c: 0f b6 85 f3 fd ff ff movzbl -0x20d(%ebp),%eax
101f13: 89 44 24 04 mov %eax,0x4(%esp)
101f17: 0f b6 85 de fd ff ff movzbl -0x222(%ebp),%eax
101f1e: 89 04 24 mov %eax,(%esp)
101f21: e8 aa 07 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[44], alt_result[2], alt_result[23], 4, &buflen, &cp);
101f26: b8 04 00 00 00 mov $0x4,%eax
101f2b: 89 44 24 0c mov %eax,0xc(%esp)
101f2f: 0f b6 85 df fd ff ff movzbl -0x221(%ebp),%eax
101f36: 89 74 24 10 mov %esi,0x10(%esp)
101f3a: 89 7c 24 14 mov %edi,0x14(%esp)
101f3e: 89 44 24 08 mov %eax,0x8(%esp)
101f42: 0f b6 85 ca fd ff ff movzbl -0x236(%ebp),%eax
101f49: 89 44 24 04 mov %eax,0x4(%esp)
101f4d: 0f b6 85 f4 fd ff ff movzbl -0x20c(%ebp),%eax
101f54: 89 04 24 mov %eax,(%esp)
101f57: e8 74 07 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[3], alt_result[24], alt_result[45], 4, &buflen, &cp);
101f5c: b8 04 00 00 00 mov $0x4,%eax
101f61: 89 44 24 0c mov %eax,0xc(%esp)
101f65: 0f b6 85 f5 fd ff ff movzbl -0x20b(%ebp),%eax
101f6c: 89 74 24 10 mov %esi,0x10(%esp)
101f70: 89 7c 24 14 mov %edi,0x14(%esp)
101f74: 89 44 24 08 mov %eax,0x8(%esp)
101f78: 0f b6 85 e0 fd ff ff movzbl -0x220(%ebp),%eax
101f7f: 89 44 24 04 mov %eax,0x4(%esp)
101f83: 0f b6 85 cb fd ff ff movzbl -0x235(%ebp),%eax
101f8a: 89 04 24 mov %eax,(%esp)
101f8d: e8 3e 07 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[25], alt_result[46], alt_result[4], 4, &buflen, &cp);
101f92: b8 04 00 00 00 mov $0x4,%eax
101f97: 89 44 24 0c mov %eax,0xc(%esp)
101f9b: 0f b6 85 cc fd ff ff movzbl -0x234(%ebp),%eax
101fa2: 89 74 24 10 mov %esi,0x10(%esp)
101fa6: 89 7c 24 14 mov %edi,0x14(%esp)
101faa: 89 44 24 08 mov %eax,0x8(%esp)
101fae: 0f b6 85 f6 fd ff ff movzbl -0x20a(%ebp),%eax
101fb5: 89 44 24 04 mov %eax,0x4(%esp)
101fb9: 0f b6 85 e1 fd ff ff movzbl -0x21f(%ebp),%eax
101fc0: 89 04 24 mov %eax,(%esp)
101fc3: e8 08 07 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[47], alt_result[5], alt_result[26], 4, &buflen, &cp);
101fc8: b8 04 00 00 00 mov $0x4,%eax
101fcd: 89 44 24 0c mov %eax,0xc(%esp)
101fd1: 0f b6 85 e2 fd ff ff movzbl -0x21e(%ebp),%eax
101fd8: 89 74 24 10 mov %esi,0x10(%esp)
101fdc: 89 7c 24 14 mov %edi,0x14(%esp)
101fe0: 89 44 24 08 mov %eax,0x8(%esp)
101fe4: 0f b6 85 cd fd ff ff movzbl -0x233(%ebp),%eax
101feb: 89 44 24 04 mov %eax,0x4(%esp)
101fef: 0f b6 85 f7 fd ff ff movzbl -0x209(%ebp),%eax
101ff6: 89 04 24 mov %eax,(%esp)
101ff9: e8 d2 06 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[6], alt_result[27], alt_result[48], 4, &buflen, &cp);
101ffe: b8 04 00 00 00 mov $0x4,%eax
102003: 89 44 24 0c mov %eax,0xc(%esp)
102007: 0f b6 85 f8 fd ff ff movzbl -0x208(%ebp),%eax
10200e: 89 74 24 10 mov %esi,0x10(%esp)
102012: 89 7c 24 14 mov %edi,0x14(%esp)
102016: 89 44 24 08 mov %eax,0x8(%esp)
10201a: 0f b6 85 e3 fd ff ff movzbl -0x21d(%ebp),%eax
102021: 89 44 24 04 mov %eax,0x4(%esp)
102025: 0f b6 85 ce fd ff ff movzbl -0x232(%ebp),%eax
10202c: 89 04 24 mov %eax,(%esp)
10202f: e8 9c 06 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[28], alt_result[49], alt_result[7], 4, &buflen, &cp);
102034: 0f b6 85 cf fd ff ff movzbl -0x231(%ebp),%eax
10203b: ba 04 00 00 00 mov $0x4,%edx
102040: 89 54 24 0c mov %edx,0xc(%esp)
102044: 89 74 24 10 mov %esi,0x10(%esp)
102048: 89 7c 24 14 mov %edi,0x14(%esp)
10204c: 89 44 24 08 mov %eax,0x8(%esp)
102050: 0f b6 85 f9 fd ff ff movzbl -0x207(%ebp),%eax
102057: 89 44 24 04 mov %eax,0x4(%esp)
10205b: 0f b6 85 e4 fd ff ff movzbl -0x21c(%ebp),%eax
102062: 89 04 24 mov %eax,(%esp)
102065: e8 66 06 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[50], alt_result[8], alt_result[29], 4, &buflen, &cp);
10206a: 0f b6 85 e5 fd ff ff movzbl -0x21b(%ebp),%eax
102071: b9 04 00 00 00 mov $0x4,%ecx
102076: 89 4c 24 0c mov %ecx,0xc(%esp)
10207a: 89 74 24 10 mov %esi,0x10(%esp)
10207e: 89 7c 24 14 mov %edi,0x14(%esp)
102082: 89 44 24 08 mov %eax,0x8(%esp)
102086: 0f b6 85 d0 fd ff ff movzbl -0x230(%ebp),%eax
10208d: 89 44 24 04 mov %eax,0x4(%esp)
102091: 0f b6 85 fa fd ff ff movzbl -0x206(%ebp),%eax
102098: 89 04 24 mov %eax,(%esp)
10209b: e8 30 06 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[9], alt_result[30], alt_result[51], 4, &buflen, &cp);
1020a0: b8 04 00 00 00 mov $0x4,%eax
1020a5: 89 44 24 0c mov %eax,0xc(%esp)
1020a9: 0f b6 85 fb fd ff ff movzbl -0x205(%ebp),%eax
1020b0: 89 74 24 10 mov %esi,0x10(%esp)
1020b4: 89 7c 24 14 mov %edi,0x14(%esp)
1020b8: 89 44 24 08 mov %eax,0x8(%esp)
1020bc: 0f b6 85 e6 fd ff ff movzbl -0x21a(%ebp),%eax
1020c3: 89 44 24 04 mov %eax,0x4(%esp)
1020c7: 0f b6 85 d1 fd ff ff movzbl -0x22f(%ebp),%eax
1020ce: 89 04 24 mov %eax,(%esp)
1020d1: e8 fa 05 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[31], alt_result[52], alt_result[10], 4, &buflen, &cp);
1020d6: b8 04 00 00 00 mov $0x4,%eax
1020db: 89 44 24 0c mov %eax,0xc(%esp)
1020df: 0f b6 85 d2 fd ff ff movzbl -0x22e(%ebp),%eax
1020e6: 89 74 24 10 mov %esi,0x10(%esp)
1020ea: 89 7c 24 14 mov %edi,0x14(%esp)
1020ee: 89 44 24 08 mov %eax,0x8(%esp)
1020f2: 0f b6 85 fc fd ff ff movzbl -0x204(%ebp),%eax
1020f9: 89 44 24 04 mov %eax,0x4(%esp)
1020fd: 0f b6 85 e7 fd ff ff movzbl -0x219(%ebp),%eax
102104: 89 04 24 mov %eax,(%esp)
102107: e8 c4 05 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[53], alt_result[11], alt_result[32], 4, &buflen, &cp);
10210c: b8 04 00 00 00 mov $0x4,%eax
102111: 89 44 24 0c mov %eax,0xc(%esp)
102115: 0f b6 85 e8 fd ff ff movzbl -0x218(%ebp),%eax
10211c: 89 74 24 10 mov %esi,0x10(%esp)
102120: 89 7c 24 14 mov %edi,0x14(%esp)
102124: 89 44 24 08 mov %eax,0x8(%esp)
102128: 0f b6 85 d3 fd ff ff movzbl -0x22d(%ebp),%eax
10212f: 89 44 24 04 mov %eax,0x4(%esp)
102133: 0f b6 85 fd fd ff ff movzbl -0x203(%ebp),%eax
10213a: 89 04 24 mov %eax,(%esp)
10213d: e8 8e 05 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[12], alt_result[33], alt_result[54], 4, &buflen, &cp);
102142: b8 04 00 00 00 mov $0x4,%eax
102147: 89 44 24 0c mov %eax,0xc(%esp)
10214b: 0f b6 85 fe fd ff ff movzbl -0x202(%ebp),%eax
102152: 89 74 24 10 mov %esi,0x10(%esp)
102156: 89 7c 24 14 mov %edi,0x14(%esp)
10215a: 89 44 24 08 mov %eax,0x8(%esp)
10215e: 0f b6 85 e9 fd ff ff movzbl -0x217(%ebp),%eax
102165: 89 44 24 04 mov %eax,0x4(%esp)
102169: 0f b6 85 d4 fd ff ff movzbl -0x22c(%ebp),%eax
102170: 89 04 24 mov %eax,(%esp)
102173: e8 58 05 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[34], alt_result[55], alt_result[13], 4, &buflen, &cp);
102178: b8 04 00 00 00 mov $0x4,%eax
10217d: 89 44 24 0c mov %eax,0xc(%esp)
102181: 0f b6 85 d5 fd ff ff movzbl -0x22b(%ebp),%eax
102188: 89 74 24 10 mov %esi,0x10(%esp)
10218c: 89 7c 24 14 mov %edi,0x14(%esp)
102190: 89 44 24 08 mov %eax,0x8(%esp)
102194: 0f b6 85 ff fd ff ff movzbl -0x201(%ebp),%eax
10219b: 89 44 24 04 mov %eax,0x4(%esp)
10219f: 0f b6 85 ea fd ff ff movzbl -0x216(%ebp),%eax
1021a6: 89 04 24 mov %eax,(%esp)
1021a9: e8 22 05 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[56], alt_result[14], alt_result[35], 4, &buflen, &cp);
1021ae: 0f b6 85 eb fd ff ff movzbl -0x215(%ebp),%eax
1021b5: ba 04 00 00 00 mov $0x4,%edx
1021ba: 89 54 24 0c mov %edx,0xc(%esp)
1021be: 89 74 24 10 mov %esi,0x10(%esp)
1021c2: 89 7c 24 14 mov %edi,0x14(%esp)
1021c6: 89 44 24 08 mov %eax,0x8(%esp)
1021ca: 0f b6 85 d6 fd ff ff movzbl -0x22a(%ebp),%eax
1021d1: 89 44 24 04 mov %eax,0x4(%esp)
1021d5: 0f b6 85 00 fe ff ff movzbl -0x200(%ebp),%eax
1021dc: 89 04 24 mov %eax,(%esp)
1021df: e8 ec 04 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[15], alt_result[36], alt_result[57], 4, &buflen, &cp);
1021e4: 0f b6 85 01 fe ff ff movzbl -0x1ff(%ebp),%eax
1021eb: b9 04 00 00 00 mov $0x4,%ecx
1021f0: 89 4c 24 0c mov %ecx,0xc(%esp)
1021f4: 89 74 24 10 mov %esi,0x10(%esp)
1021f8: 89 7c 24 14 mov %edi,0x14(%esp)
1021fc: 89 44 24 08 mov %eax,0x8(%esp)
102200: 0f b6 85 ec fd ff ff movzbl -0x214(%ebp),%eax
102207: 89 44 24 04 mov %eax,0x4(%esp)
10220b: 0f b6 85 d7 fd ff ff movzbl -0x229(%ebp),%eax
102212: 89 04 24 mov %eax,(%esp)
102215: e8 b6 04 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[37], alt_result[58], alt_result[16], 4, &buflen, &cp);
10221a: b8 04 00 00 00 mov $0x4,%eax
10221f: 89 44 24 0c mov %eax,0xc(%esp)
102223: 0f b6 85 d8 fd ff ff movzbl -0x228(%ebp),%eax
10222a: 89 74 24 10 mov %esi,0x10(%esp)
10222e: 89 7c 24 14 mov %edi,0x14(%esp)
102232: 89 44 24 08 mov %eax,0x8(%esp)
102236: 0f b6 85 02 fe ff ff movzbl -0x1fe(%ebp),%eax
10223d: 89 44 24 04 mov %eax,0x4(%esp)
102241: 0f b6 85 ed fd ff ff movzbl -0x213(%ebp),%eax
102248: 89 04 24 mov %eax,(%esp)
10224b: e8 80 04 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[59], alt_result[17], alt_result[38], 4, &buflen, &cp);
102250: b8 04 00 00 00 mov $0x4,%eax
102255: 89 44 24 0c mov %eax,0xc(%esp)
102259: 0f b6 85 ee fd ff ff movzbl -0x212(%ebp),%eax
102260: 89 74 24 10 mov %esi,0x10(%esp)
102264: 89 7c 24 14 mov %edi,0x14(%esp)
102268: 89 44 24 08 mov %eax,0x8(%esp)
10226c: 0f b6 85 d9 fd ff ff movzbl -0x227(%ebp),%eax
102273: 89 44 24 04 mov %eax,0x4(%esp)
102277: 0f b6 85 03 fe ff ff movzbl -0x1fd(%ebp),%eax
10227e: 89 04 24 mov %eax,(%esp)
102281: e8 4a 04 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[18], alt_result[39], alt_result[60], 4, &buflen, &cp);
102286: b8 04 00 00 00 mov $0x4,%eax
10228b: 89 44 24 0c mov %eax,0xc(%esp)
10228f: 0f b6 85 04 fe ff ff movzbl -0x1fc(%ebp),%eax
102296: 89 74 24 10 mov %esi,0x10(%esp)
10229a: 89 7c 24 14 mov %edi,0x14(%esp)
10229e: 89 44 24 08 mov %eax,0x8(%esp)
1022a2: 0f b6 85 ef fd ff ff movzbl -0x211(%ebp),%eax
1022a9: 89 44 24 04 mov %eax,0x4(%esp)
1022ad: 0f b6 85 da fd ff ff movzbl -0x226(%ebp),%eax
1022b4: 89 04 24 mov %eax,(%esp)
1022b7: e8 14 04 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[40], alt_result[61], alt_result[19], 4, &buflen, &cp);
1022bc: b8 04 00 00 00 mov $0x4,%eax
1022c1: 89 44 24 0c mov %eax,0xc(%esp)
1022c5: 0f b6 85 db fd ff ff movzbl -0x225(%ebp),%eax
1022cc: 89 74 24 10 mov %esi,0x10(%esp)
1022d0: 89 7c 24 14 mov %edi,0x14(%esp)
1022d4: 89 44 24 08 mov %eax,0x8(%esp)
1022d8: 0f b6 85 05 fe ff ff movzbl -0x1fb(%ebp),%eax
1022df: 89 44 24 04 mov %eax,0x4(%esp)
1022e3: 0f b6 85 f0 fd ff ff movzbl -0x210(%ebp),%eax
1022ea: 89 04 24 mov %eax,(%esp)
1022ed: e8 de 03 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(alt_result[62], alt_result[20], alt_result[41], 4, &buflen, &cp);
1022f2: b8 04 00 00 00 mov $0x4,%eax
1022f7: 89 44 24 0c mov %eax,0xc(%esp)
1022fb: 0f b6 85 f1 fd ff ff movzbl -0x20f(%ebp),%eax
102302: 89 74 24 10 mov %esi,0x10(%esp)
102306: 89 7c 24 14 mov %edi,0x14(%esp)
10230a: 89 44 24 08 mov %eax,0x8(%esp)
10230e: 0f b6 85 dc fd ff ff movzbl -0x224(%ebp),%eax
102315: 89 44 24 04 mov %eax,0x4(%esp)
102319: 0f b6 85 06 fe ff ff movzbl -0x1fa(%ebp),%eax
102320: 89 04 24 mov %eax,(%esp)
102323: e8 a8 03 00 00 call 1026d0 <_crypt_b64_from_24bit>
b64_from_24bit(0, 0, alt_result[63], 2, &buflen, &cp);
102328: 0f b6 85 07 fe ff ff movzbl -0x1f9(%ebp),%eax
10232f: 31 c9 xor %ecx,%ecx
102331: 89 74 24 10 mov %esi,0x10(%esp)
102335: ba 02 00 00 00 mov $0x2,%edx
10233a: 89 7c 24 14 mov %edi,0x14(%esp)
10233e: 89 54 24 0c mov %edx,0xc(%esp)
102342: 89 44 24 08 mov %eax,0x8(%esp)
102346: 89 4c 24 04 mov %ecx,0x4(%esp)
10234a: c7 04 24 00 00 00 00 movl $0x0,(%esp)
102351: e8 7a 03 00 00 call 1026d0 <_crypt_b64_from_24bit>
if (buflen <= 0) {
102356: 8b b5 c4 fd ff ff mov -0x23c(%ebp),%esi
10235c: 85 f6 test %esi,%esi
10235e: 0f 8e 3c 02 00 00 jle 1025a0 <crypt_sha512_r+0xd10> <== NEVER TAKEN
errno = ERANGE;
buffer = NULL;
}
else
*cp = '\0'; /* Terminate the string. */
102364: 8b 85 bc fd ff ff mov -0x244(%ebp),%eax
10236a: c6 00 00 movb $0x0,(%eax)
/* Clear the buffer for the intermediate result so that people
* attaching to processes or reading core dumps cannot get any
* information. We do it in this way to clear correct_words[] inside
* the SHA512 implementation as well. */
SHA512_Init(&ctx);
10236d: 89 1c 24 mov %ebx,(%esp)
102370: e8 cb 0f 01 00 call 113340 <SHA512_Init>
SHA512_Final(alt_result, &ctx);
102375: 8d 85 c8 fd ff ff lea -0x238(%ebp),%eax <== NOT EXECUTED
10237b: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
10237f: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
102382: e8 69 13 01 00 call 1136f0 <SHA512_Final> <== NOT EXECUTED
memset(copied_key, '\0', key_len);
if (copied_salt != NULL)
memset(copied_salt, '\0', salt_len);
return buffer;
}
102387: 8b 85 98 fd ff ff mov -0x268(%ebp),%eax
10238d: 8d 65 f4 lea -0xc(%ebp),%esp
102390: 5b pop %ebx
102391: 5e pop %esi
102392: 5f pop %edi
102393: 5d pop %ebp
102394: c3 ret
102395: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10239c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
memcpy(cp, temp_result, 64);
1023a0: 0f b7 01 movzwl (%ecx),%eax <== NOT EXECUTED
1023a3: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
1023a6: 83 c1 02 add $0x2,%ecx <== NOT EXECUTED
1023a9: 83 ee 02 sub $0x2,%esi <== NOT EXECUTED
1023ac: 66 89 42 fe mov %ax,-0x2(%edx) <== NOT EXECUTED
1023b0: e9 a5 f7 ff ff jmp 101b5a <crypt_sha512_r+0x2ca> <== NOT EXECUTED
1023b5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1023bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1023c0: 0f b6 09 movzbl (%ecx),%ecx <== NOT EXECUTED
1023c3: 42 inc %edx <== NOT EXECUTED
1023c4: be 3f 00 00 00 mov $0x3f,%esi <== NOT EXECUTED
1023c9: 88 8d a0 fd ff ff mov %cl,-0x260(%ebp) <== NOT EXECUTED
1023cf: 88 08 mov %cl,(%eax) <== NOT EXECUTED
1023d1: 8d 8d 09 fe ff ff lea -0x1f7(%ebp),%ecx <== NOT EXECUTED
1023d7: e9 75 f7 ff ff jmp 101b51 <crypt_sha512_r+0x2c1> <== NOT EXECUTED
1023dc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
memcpy(cp, temp_result, cnt);
1023e0: 0f b6 14 02 movzbl (%edx,%eax,1),%edx <== NOT EXECUTED
1023e4: 88 14 01 mov %dl,(%ecx,%eax,1) <== NOT EXECUTED
1023e7: e9 0b f8 ff ff jmp 101bf7 <crypt_sha512_r+0x367> <== NOT EXECUTED
1023ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1023f0: 0f b7 02 movzwl (%edx),%eax
1023f3: 83 e6 01 and $0x1,%esi
1023f6: 66 89 01 mov %ax,(%ecx)
1023f9: b8 02 00 00 00 mov $0x2,%eax
1023fe: 0f 84 f3 f7 ff ff je 101bf7 <crypt_sha512_r+0x367> <== NEVER TAKEN
102404: eb da jmp 1023e0 <crypt_sha512_r+0xb50>
102406: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10240d: 8d 76 00 lea 0x0(%esi),%esi
memcpy(cp, temp_result, cnt);
102410: 0f b6 04 10 movzbl (%eax,%edx,1),%eax <== NOT EXECUTED
102414: 88 04 11 mov %al,(%ecx,%edx,1) <== NOT EXECUTED
102417: e9 90 f8 ff ff jmp 101cac <crypt_sha512_r+0x41c> <== NOT EXECUTED
10241c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
102420: 0f b7 10 movzwl (%eax),%edx
102423: 66 89 11 mov %dx,(%ecx)
102426: ba 02 00 00 00 mov $0x2,%edx
10242b: f6 85 ac fd ff ff 01 testb $0x1,-0x254(%ebp)
102432: 0f 84 74 f8 ff ff je 101cac <crypt_sha512_r+0x41c>
102438: eb d6 jmp 102410 <crypt_sha512_r+0xb80> <== NOT EXECUTED
10243a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (strncmp(sha512_salt_prefix, salt, sizeof(sha512_salt_prefix) - 1) == 0)
102440: 0f b6 40 02 movzbl 0x2(%eax),%eax
102444: ba 24 00 00 00 mov $0x24,%edx
102449: 39 c2 cmp %eax,%edx
10244b: 0f 85 7f f4 ff ff jne 1018d0 <crypt_sha512_r+0x40> <== NEVER TAKEN
salt += sizeof(sha512_salt_prefix) - 1;
102451: 83 45 0c 03 addl $0x3,0xc(%ebp)
102455: e9 76 f4 ff ff jmp 1018d0 <crypt_sha512_r+0x40>
10245a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
memcpy(cp, temp_result, cnt);
102460: 89 d1 mov %edx,%ecx
102462: 31 c0 xor %eax,%eax
102464: 83 e1 fc and $0xfffffffc,%ecx
102467: 8b 14 07 mov (%edi,%eax,1),%edx
10246a: 89 14 06 mov %edx,(%esi,%eax,1)
10246d: 83 c0 04 add $0x4,%eax
102470: 39 c8 cmp %ecx,%eax
102472: 72 f3 jb 102467 <crypt_sha512_r+0xbd7>
102474: 8b 8d a8 fd ff ff mov -0x258(%ebp),%ecx
10247a: 01 c1 add %eax,%ecx
10247c: 01 f8 add %edi,%eax
10247e: e9 0d f8 ff ff jmp 101c90 <crypt_sha512_r+0x400>
102483: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10248a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
memcpy(cp, temp_result, cnt);
102490: a8 01 test $0x1,%al
102492: 0f 85 d0 01 00 00 jne 102668 <crypt_sha512_r+0xdd8> <== NEVER TAKEN
102498: f6 c1 02 test $0x2,%cl
10249b: 0f 85 b2 01 00 00 jne 102653 <crypt_sha512_r+0xdc3> <== NEVER TAKEN
1024a1: 83 fe 04 cmp $0x4,%esi
1024a4: 0f 82 36 f7 ff ff jb 101be0 <crypt_sha512_r+0x350> <== NEVER TAKEN
1024aa: 89 b5 a0 fd ff ff mov %esi,-0x260(%ebp)
1024b0: 89 f0 mov %esi,%eax
1024b2: 83 e0 fc and $0xfffffffc,%eax
1024b5: 89 85 a8 fd ff ff mov %eax,-0x258(%ebp)
1024bb: 31 c0 xor %eax,%eax
1024bd: 8b 34 02 mov (%edx,%eax,1),%esi
1024c0: 89 34 01 mov %esi,(%ecx,%eax,1)
1024c3: 83 c0 04 add $0x4,%eax
1024c6: 3b 85 a8 fd ff ff cmp -0x258(%ebp),%eax
1024cc: 72 ef jb 1024bd <crypt_sha512_r+0xc2d>
1024ce: 8b b5 a0 fd ff ff mov -0x260(%ebp),%esi
1024d4: 01 c1 add %eax,%ecx
1024d6: 01 c2 add %eax,%edx
1024d8: e9 03 f7 ff ff jmp 101be0 <crypt_sha512_r+0x350>
1024dd: 8d 76 00 lea 0x0(%esi),%esi
srounds = strtoul(num, &endp, 10);
1024e0: 8d 85 c0 fd ff ff lea -0x240(%ebp),%eax
1024e6: bf 0a 00 00 00 mov $0xa,%edi
1024eb: 89 44 24 04 mov %eax,0x4(%esp)
num = salt + sizeof(sha512_rounds_prefix) - 1;
1024ef: 8b 45 0c mov 0xc(%ebp),%eax
srounds = strtoul(num, &endp, 10);
1024f2: 89 7c 24 08 mov %edi,0x8(%esp)
num = salt + sizeof(sha512_rounds_prefix) - 1;
1024f6: 83 c0 07 add $0x7,%eax
srounds = strtoul(num, &endp, 10);
1024f9: 89 04 24 mov %eax,(%esp)
1024fc: e8 7f 6c 02 00 call 129180 <strtoul>
if (*endp == '$') {
102501: 8b 95 c0 fd ff ff mov -0x240(%ebp),%edx
102507: 80 3a 24 cmpb $0x24,(%edx)
10250a: 0f 85 e5 f3 ff ff jne 1018f5 <crypt_sha512_r+0x65> <== NEVER TAKEN
rounds = MAX(ROUNDS_MIN, MIN(srounds, ROUNDS_MAX));
102510: 89 85 a4 fd ff ff mov %eax,-0x25c(%ebp)
salt = endp + 1;
102516: 8d 5a 01 lea 0x1(%edx),%ebx
rounds = MAX(ROUNDS_MIN, MIN(srounds, ROUNDS_MAX));
102519: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax
salt = endp + 1;
10251e: 89 5d 0c mov %ebx,0xc(%ebp)
rounds = MAX(ROUNDS_MIN, MIN(srounds, ROUNDS_MAX));
102521: 0f 86 91 00 00 00 jbe 1025b8 <crypt_sha512_r+0xd28> <== ALWAYS TAKEN
102527: bb ff c9 9a 3b mov $0x3b9ac9ff,%ebx <== NOT EXECUTED
10252c: 89 9d a4 fd ff ff mov %ebx,-0x25c(%ebp) <== NOT EXECUTED
rounds_custom = true;
102532: c6 85 97 fd ff ff 01 movb $0x1,-0x269(%ebp)
102539: e9 c9 f3 ff ff jmp 101907 <crypt_sha512_r+0x77>
10253e: 66 90 xchg %ax,%ax
n = snprintf(cp, MAX(0, buflen), "%s%zu$",
102540: 8b 8d a4 fd ff ff mov -0x25c(%ebp),%ecx
102546: ba c4 f5 12 00 mov $0x12f5c4,%edx
10254b: bf e0 f5 12 00 mov $0x12f5e0,%edi
102550: 89 54 24 08 mov %edx,0x8(%esp)
102554: 89 74 24 04 mov %esi,0x4(%esp)
102558: 89 7c 24 0c mov %edi,0xc(%esp)
10255c: 89 4c 24 10 mov %ecx,0x10(%esp)
102560: 89 04 24 mov %eax,(%esp)
102563: e8 48 59 02 00 call 127eb0 <snprintf>
buflen -= n;
102568: 8b b5 c4 fd ff ff mov -0x23c(%ebp),%esi <== NOT EXECUTED
n = snprintf(cp, MAX(0, buflen), "%s%zu$",
10256e: 89 c2 mov %eax,%edx <== NOT EXECUTED
cp += n;
102570: 8b 85 bc fd ff ff mov -0x244(%ebp),%eax <== NOT EXECUTED
buflen -= n;
102576: 29 d6 sub %edx,%esi <== NOT EXECUTED
102578: 89 b5 c4 fd ff ff mov %esi,-0x23c(%ebp) <== NOT EXECUTED
cp += n;
10257e: 01 d0 add %edx,%eax <== NOT EXECUTED
cp = stpncpy(cp, salt, MIN((size_t)MAX(0, buflen), salt_len));
102580: 89 f2 mov %esi,%edx <== NOT EXECUTED
cp += n;
102582: 89 85 bc fd ff ff mov %eax,-0x244(%ebp) <== NOT EXECUTED
cp = stpncpy(cp, salt, MIN((size_t)MAX(0, buflen), salt_len));
102588: f7 d2 not %edx <== NOT EXECUTED
10258a: c1 fa 1f sar $0x1f,%edx <== NOT EXECUTED
10258d: 21 d6 and %edx,%esi <== NOT EXECUTED
10258f: e9 b8 f8 ff ff jmp 101e4c <crypt_sha512_r+0x5bc> <== NOT EXECUTED
102594: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10259b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10259f: 90 nop <== NOT EXECUTED
errno = ERANGE;
1025a0: e8 1b 56 02 00 call 127bc0 <__errno> <== NOT EXECUTED
1025a5: c7 00 22 00 00 00 movl $0x22,(%eax) <== NOT EXECUTED
buffer = NULL;
1025ab: 31 c0 xor %eax,%eax <== NOT EXECUTED
1025ad: 89 85 98 fd ff ff mov %eax,-0x268(%ebp) <== NOT EXECUTED
1025b3: e9 b5 fd ff ff jmp 10236d <crypt_sha512_r+0xadd> <== NOT EXECUTED
1025b8: 81 bd a4 fd ff ff e8 cmpl $0x3e8,-0x25c(%ebp)
1025bf: 03 00 00
1025c2: 0f 83 6a ff ff ff jae 102532 <crypt_sha512_r+0xca2>
1025c8: b9 e8 03 00 00 mov $0x3e8,%ecx
1025cd: 89 8d a4 fd ff ff mov %ecx,-0x25c(%ebp)
1025d3: e9 5a ff ff ff jmp 102532 <crypt_sha512_r+0xca2>
1025d8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1025df: 90 nop
SHA512_Update(&ctx, alt_result, cnt);
1025e0: 89 1c 24 mov %ebx,(%esp)
1025e3: 8b bd b4 fd ff ff mov -0x24c(%ebp),%edi
1025e9: 8d 85 c8 fd ff ff lea -0x238(%ebp),%eax
1025ef: 89 44 24 04 mov %eax,0x4(%esp)
1025f3: 89 7c 24 08 mov %edi,0x8(%esp)
1025f7: e8 e4 0d 01 00 call 1133e0 <SHA512_Update>
for (cnt = key_len; cnt > 0; cnt >>= 1)
1025fc: 85 ff test %edi,%edi
1025fe: 0f 85 46 f4 ff ff jne 101a4a <crypt_sha512_r+0x1ba>
SHA512_Final(alt_result, &ctx);
102604: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
102608: 8d 85 c8 fd ff ff lea -0x238(%ebp),%eax <== NOT EXECUTED
cp = p_bytes = alloca(key_len);
10260e: 31 f6 xor %esi,%esi <== NOT EXECUTED
SHA512_Final(alt_result, &ctx);
102610: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
SHA512_Final(temp_result, &alt_ctx);
102613: 8d bd 08 fe ff ff lea -0x1f8(%ebp),%edi <== NOT EXECUTED
SHA512_Final(alt_result, &ctx);
102619: e8 d2 10 01 00 call 1136f0 <SHA512_Final> <== NOT EXECUTED
SHA512_Init(&alt_ctx);
10261e: 8d 85 18 ff ff ff lea -0xe8(%ebp),%eax <== NOT EXECUTED
102624: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
102627: e8 14 0d 01 00 call 113340 <SHA512_Init> <== NOT EXECUTED
SHA512_Final(temp_result, &alt_ctx);
10262c: 8d 85 18 ff ff ff lea -0xe8(%ebp),%eax <== NOT EXECUTED
102632: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
102636: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
102639: e8 b2 10 01 00 call 1136f0 <SHA512_Final> <== NOT EXECUTED
cp = p_bytes = alloca(key_len);
10263e: 8d 44 24 18 lea 0x18(%esp),%eax <== NOT EXECUTED
102642: 89 85 b0 fd ff ff mov %eax,-0x250(%ebp) <== NOT EXECUTED
102648: 89 85 bc fd ff ff mov %eax,-0x244(%ebp) <== NOT EXECUTED
for (cnt = key_len; cnt >= 64; cnt -= 64) {
10264e: e9 80 f5 ff ff jmp 101bd3 <crypt_sha512_r+0x343> <== NOT EXECUTED
memcpy(cp, temp_result, cnt);
102653: 0f b7 02 movzwl (%edx),%eax <== NOT EXECUTED
102656: 83 c1 02 add $0x2,%ecx <== NOT EXECUTED
102659: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
10265c: 83 ee 02 sub $0x2,%esi <== NOT EXECUTED
10265f: 66 89 41 fe mov %ax,-0x2(%ecx) <== NOT EXECUTED
102663: e9 39 fe ff ff jmp 1024a1 <crypt_sha512_r+0xc11> <== NOT EXECUTED
102668: 0f b6 07 movzbl (%edi),%eax <== NOT EXECUTED
10266b: 41 inc %ecx <== NOT EXECUTED
10266c: 4e dec %esi <== NOT EXECUTED
10266d: 8d 95 09 fe ff ff lea -0x1f7(%ebp),%edx <== NOT EXECUTED
102673: 88 41 ff mov %al,-0x1(%ecx) <== NOT EXECUTED
102676: e9 1d fe ff ff jmp 102498 <crypt_sha512_r+0xc08> <== NOT EXECUTED
for (cnt = key_len; cnt >= 64; cnt -= 64) {
10267b: 8b 85 b0 fd ff ff mov -0x250(%ebp),%eax
102681: 8b b5 b4 fd ff ff mov -0x24c(%ebp),%esi
102687: e9 47 f5 ff ff jmp 101bd3 <crypt_sha512_r+0x343>
10268c: 90 nop
10268d: 90 nop
10268e: 90 nop
10268f: 90 nop