=============================================================================== 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 : 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 <== 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 : * 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 <== NEVER TAKEN 100847: 80 78 01 31 cmpb $0x31,0x1(%eax) 10084b: 0f 84 96 04 00 00 je 100ce7 <== 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 <== NEVER TAKEN 10086e: 84 c0 test %al,%al 100870: 0f 84 84 04 00 00 je 100cfa <== 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 100889: 80 fa 24 cmp $0x24,%dl 10088c: 74 04 je 100892 10088e: 39 c8 cmp %ecx,%eax 100890: 75 ee jne 100880 <== 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 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 <== 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(&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(&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 MD5Init(&ctx1); 1008f9: 89 34 24 mov %esi,(%esp) 1008fc: e8 cf 5c 00 00 call 1065d0 MD5Update(&ctx1, (const u_char *)pw, strlen(pw)); 100901: 89 3c 24 mov %edi,(%esp) 100904: e8 07 7a 02 00 call 128310 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(&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(&ctx1, (const u_char *)pw, strlen(pw)); 100932: 89 3c 24 mov %edi,(%esp) 100935: e8 d6 79 02 00 call 128310 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 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 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 100964: 85 c0 test %eax,%eax 100966: 74 34 je 10099c <== 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 <== 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 for(pl = (int)strlen(pw); pl > 0; pl -= MD5_SIZE) 100995: 85 ff test %edi,%edi 100997: 7f d7 jg 100970 <== 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 1009c4: 85 c0 test %eax,%eax 1009c6: 74 45 je 100a0d <== NEVER TAKEN 1009c8: 89 7d 08 mov %edi,0x8(%ebp) 1009cb: 89 c7 mov %eax,%edi 1009cd: eb 17 jmp 1009e6 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 for (i = strlen(pw); i; i >>= 1) 1009e2: d1 ef shr %edi 1009e4: 74 24 je 100a0a 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 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 for (i = strlen(pw); i; i >>= 1) 100a06: d1 ef shr %edi 100a08: 75 dc jne 1009e6 <== 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 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 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 for(i = 0; i < 1000; i++) { 100a58: e9 85 00 00 00 jmp 100ae2 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 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 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 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 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 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 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 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 MD5Init(&ctx1); 100ae2: 89 34 24 mov %esi,(%esp) 100ae5: e8 e6 5a 00 00 call 1065d0 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 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 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 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 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 MD5Update(&ctx1, (const u_char *)pw, strlen(pw)); 100b51: 89 3c 24 mov %edi,(%esp) 100b54: e8 b7 77 02 00 call 128310 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 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 MD5Update(&ctx1, (const u_char *)pw, strlen(pw)); 100b77: 89 3c 24 mov %edi,(%esp) 100b7a: e8 91 77 02 00 call 128310 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 100b8f: e9 2f ff ff ff jmp 100ac3 } 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 <== 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 <== NEVER TAKEN sp += strlen(magic); 100cf1: 83 45 0c 03 addl $0x3,0xc(%ebp) 100cf5: e9 66 fb ff ff jmp 100860 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 <== 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 : 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 <== 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 1007d7: 89 44 24 04 mov %eax,0x4(%esp) 1007db: 89 34 24 mov %esi,(%esp) 1007de: e8 8d 82 02 00 call 128a70 1007e3: 39 c6 cmp %eax,%esi 1007e5: 74 29 je 100810 SLIST_FOREACH(cf, &cf_head, link) 1007e7: 8b 3f mov (%edi),%edi 1007e9: 85 ff test %edi,%edi 1007eb: 75 e3 jne 1007d0 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 : /* 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 <== NEVER TAKEN 100d3b: 80 78 01 35 cmpb $0x35,0x1(%eax) 100d3f: 0f 84 fb 08 00 00 je 101640 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 100d6d: 85 c0 test %eax,%eax 100d6f: 0f 84 6b 09 00 00 je 1016e0 <== 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 100d9b: 89 85 b8 fe ff ff mov %eax,-0x148(%ebp) 100da1: 83 f8 0f cmp $0xf,%eax 100da4: 76 0b jbe 100db1 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 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 /* 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 /* 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 <== 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 /* 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 /* 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 /* 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 <== 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 /* 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 <== 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 for (cnt = key_len; cnt > 32; cnt -= 32) 100e8e: 83 ff 20 cmp $0x20,%edi 100e91: 77 dd ja 100e70 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 key_len = strlen(key); 100eba: 8b bd c4 fe ff ff mov -0x13c(%ebp),%edi 100ec0: eb 2d jmp 100eef 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 <== NOT EXECUTED for (cnt = key_len; cnt > 0; cnt >>= 1) 100eeb: d1 ef shr %edi 100eed: 74 22 je 100f11 if ((cnt & 1) != 0) 100eef: f7 c7 01 00 00 00 test $0x1,%edi 100ef5: 75 d9 jne 100ed0 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 for (cnt = key_len; cnt > 0; cnt >>= 1) 100f0d: d1 ef shr %edi 100f0f: 75 de jne 100eef <== 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 <== 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 /* 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 for (cnt = 0; cnt < key_len; ++cnt) 100f57: 39 fe cmp %edi,%esi 100f59: 77 e5 ja 100f40 /* 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 /* 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 <== 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 <== NEVER TAKEN 100fb1: f6 c2 02 test $0x2,%dl 100fb4: 0f 85 e6 05 00 00 jne 1015a0 <== 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 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 <== 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 <== 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 <== 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 <== 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 101052: 83 e6 01 and $0x1,%esi 101055: 0f 85 85 05 00 00 jne 1015e0 <== 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 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 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 /* 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 /* 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 <== 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 1010f9: f6 85 b8 fe ff ff 01 testb $0x1,-0x148(%ebp) 101100: 0f 85 0a 05 00 00 jne 101610 /* 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 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 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 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 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 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 <== 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 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 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 if ((cnt & 1) != 0) 10119a: 83 e7 01 and $0x1,%edi 10119d: 0f 85 6d ff ff ff jne 101110 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 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 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 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 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 if ((cnt & 1) != 0) 101218: 85 ff test %edi,%edi 10121a: 0f 85 36 ff ff ff jne 101156 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 10123c: e9 30 ff ff ff jmp 101171 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 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 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 <== 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 <== 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 <== 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 <== 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 <== 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_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 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 <== 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 <== 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 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 101604: eb da jmp 1015e0 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 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 <== ALWAYS TAKEN 101638: eb d6 jmp 101610 <== 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 <== 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 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 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 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 <== NEVER TAKEN 101698: f6 c1 02 test $0x2,%cl 10169b: 0f 85 ac 01 00 00 jne 10184d <== NEVER TAKEN 1016a1: 83 fe 04 cmp $0x4,%esi 1016a4: 0f 82 9a f9 ff ff jb 101044 <== 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 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 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 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 <== 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 <== 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 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 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 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 <== 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 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 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 for (cnt = key_len; cnt > 0; cnt >>= 1) 1017fc: 85 ff test %edi,%edi 1017fe: 0f 85 b6 f6 ff ff jne 100eba 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 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 : /* 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 1018bb: 80 78 01 36 cmpb $0x36,0x1(%eax) 1018bf: 0f 84 7b 0b 00 00 je 102440 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 1018ed: 85 c0 test %eax,%eax 1018ef: 0f 84 eb 0b 00 00 je 1024e0 <== 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 10191b: 89 85 ac fd ff ff mov %eax,-0x254(%ebp) 101921: 83 f8 0f cmp $0xf,%eax 101924: 76 0b jbe 101931 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 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 /* 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 /* 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 <== 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 /* 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 /* 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 /* 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 <== 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 /* 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 <== 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 <== NOT EXECUTED for (cnt = key_len; cnt > 64; cnt -= 64) 101a1e: 83 ff 40 cmp $0x40,%edi 101a21: 77 dd ja 101a00 <== 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 <== NOT EXECUTED key_len = strlen(key); 101a4a: 8b bd b4 fd ff ff mov -0x24c(%ebp),%edi 101a50: eb 2d jmp 101a7f 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 for (cnt = key_len; cnt > 0; cnt >>= 1) 101a7b: d1 ef shr %edi 101a7d: 74 22 je 101aa1 if ((cnt & 1) != 0) 101a7f: f7 c7 01 00 00 00 test $0x1,%edi 101a85: 75 d9 jne 101a60 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 for (cnt = key_len; cnt > 0; cnt >>= 1) 101a9d: d1 ef shr %edi 101a9f: 75 de jne 101a7f <== 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 <== 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 /* 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 for (cnt = 0; cnt < key_len; ++cnt) 101aea: 39 fe cmp %edi,%esi 101aec: 77 e2 ja 101ad0 /* 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 <== 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 <== 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 <== NEVER TAKEN 101b51: f6 c2 02 test $0x2,%dl 101b54: 0f 85 46 08 00 00 jne 1023a0 <== 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 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 <== 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 <== 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 <== 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 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 <== NEVER TAKEN 101bee: 83 e6 01 and $0x1,%esi 101bf1: 0f 85 e9 07 00 00 jne 1023e0 <== 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 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 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 /* 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 <== 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 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 <== NEVER TAKEN 101c9f: f6 85 ac fd ff ff 01 testb $0x1,-0x254(%ebp) 101ca6: 0f 85 64 07 00 00 jne 102410 <== 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 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 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 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 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 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 <== 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 <== 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 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 if ((cnt & 1) != 0) 101d4a: 83 e7 01 and $0x1,%edi 101d4d: 0f 85 6d ff ff ff jne 101cc0 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 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 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 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 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 if ((cnt & 1) != 0) 101dc8: 85 ff test %edi,%edi 101dca: 0f 85 36 ff ff ff jne 101d06 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 101dec: e9 30 ff ff ff jmp 101d21 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 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 <== 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 <== 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 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 <== 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 <== 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 <== 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_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 <== 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 <== 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 <== 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 <== 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 <== NEVER TAKEN 102404: eb da jmp 1023e0 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 <== 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 102438: eb d6 jmp 102410 <== 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 <== 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 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 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 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 <== NEVER TAKEN 102498: f6 c1 02 test $0x2,%cl 10249b: 0f 85 b2 01 00 00 jne 102653 <== NEVER TAKEN 1024a1: 83 fe 04 cmp $0x4,%esi 1024a4: 0f 82 36 f7 ff ff jb 101be0 <== 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 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 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 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 <== 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 <== 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 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 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 <== 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 <== 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 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 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 for (cnt = key_len; cnt > 0; cnt >>= 1) 1025fc: 85 ff test %edi,%edi 1025fe: 0f 85 46 f4 ff ff jne 101a4a 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 10268c: 90 nop 10268d: 90 nop 10268e: 90 nop 10268f: 90 nop