=============================================================================== 001066f0 : { 1066f0: 55 push %ebp 1066f1: 89 e5 mov %esp,%ebp 1066f3: 57 push %edi 1066f4: 56 push %esi 1066f5: 53 push %ebx 1066f6: 83 ec 4c sub $0x4c,%esp 1066f9: 8b 5d 0c mov 0xc(%ebp),%ebx 1066fc: 8b 7d 08 mov 0x8(%ebp),%edi in[14] = mdContext->i[0]; 1066ff: 8b 03 mov (%ebx),%eax in[15] = mdContext->i[1]; 106701: 8b 53 04 mov 0x4(%ebx),%edx in[14] = mdContext->i[0]; 106704: 89 45 ec mov %eax,-0x14(%ebp) mdi = (int)((mdContext->i[0] >> 3) & 0x3F); 106707: c1 e8 03 shr $0x3,%eax in[15] = mdContext->i[1]; 10670a: 89 55 f0 mov %edx,-0x10(%ebp) mdi = (int)((mdContext->i[0] >> 3) & 0x3F); 10670d: 83 e0 3f and $0x3f,%eax padLen = (mdi < 56) ? (56 - mdi) : (120 - mdi); 106710: 83 f8 37 cmp $0x37,%eax 106713: 0f 8f a7 00 00 00 jg 1067c0 <== NEVER TAKEN 106719: ba 38 00 00 00 mov $0x38,%edx 10671e: 29 c2 sub %eax,%edx MD5Update (mdContext, PADDING, padLen); 106720: 89 54 24 08 mov %edx,0x8(%esp) 106724: b8 20 4c 13 00 mov $0x134c20,%eax 106729: 89 44 24 04 mov %eax,0x4(%esp) 10672d: 89 1c 24 mov %ebx,(%esp) 106730: e8 db fe ff ff call 106610 for (i = 0, ii = 0; i < 14; i++, ii += 4) 106735: 31 d2 xor %edx,%edx 106737: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10673e: 66 90 xchg %ax,%ax in[i] = (((UINT4)mdContext->in[ii+3]) << 24) | 106740: 0f b6 44 13 1b movzbl 0x1b(%ebx,%edx,1),%eax (((UINT4)mdContext->in[ii+2]) << 16) | 106745: 0f b6 4c 13 1a movzbl 0x1a(%ebx,%edx,1),%ecx in[i] = (((UINT4)mdContext->in[ii+3]) << 24) | 10674a: c1 e0 18 shl $0x18,%eax (((UINT4)mdContext->in[ii+2]) << 16) | 10674d: c1 e1 10 shl $0x10,%ecx in[i] = (((UINT4)mdContext->in[ii+3]) << 24) | 106750: 09 c8 or %ecx,%eax ((UINT4)mdContext->in[ii]); 106752: 0f b6 4c 13 18 movzbl 0x18(%ebx,%edx,1),%ecx (((UINT4)mdContext->in[ii+1]) << 8) | 106757: 09 c8 or %ecx,%eax 106759: 0f b6 4c 13 19 movzbl 0x19(%ebx,%edx,1),%ecx 10675e: c1 e1 08 shl $0x8,%ecx 106761: 09 c8 or %ecx,%eax 106763: 89 44 15 b4 mov %eax,-0x4c(%ebp,%edx,1) for (i = 0, ii = 0; i < 14; i++, ii += 4) 106767: 83 c2 04 add $0x4,%edx 10676a: 83 fa 38 cmp $0x38,%edx 10676d: 75 d1 jne 106740 Transform (mdContext->buf, in); 10676f: 8d 73 08 lea 0x8(%ebx),%esi 106772: 8d 55 b4 lea -0x4c(%ebp),%edx 106775: 89 f0 mov %esi,%eax 106777: e8 84 f7 ff ff call 105f00 for (i = 0, ii = 0; i < 4; i++, ii += 4) { 10677c: 89 f0 mov %esi,%eax 10677e: 8d 73 18 lea 0x18(%ebx),%esi mdContext->digest[ii] = (unsigned char)(mdContext->buf[i] & 0xFF); 106781: 8b 10 mov (%eax),%edx for (i = 0, ii = 0; i < 4; i++, ii += 4) { 106783: 83 c0 04 add $0x4,%eax mdContext->digest[ii] = (unsigned char)(mdContext->buf[i] & 0xFF); 106786: 88 50 4c mov %dl,0x4c(%eax) (unsigned char)((mdContext->buf[i] >> 16) & 0xFF); 106789: 89 d1 mov %edx,%ecx (unsigned char)((mdContext->buf[i] >> 8) & 0xFF); 10678b: 88 70 4d mov %dh,0x4d(%eax) (unsigned char)((mdContext->buf[i] >> 16) & 0xFF); 10678e: c1 e9 10 shr $0x10,%ecx 106791: 88 48 4e mov %cl,0x4e(%eax) (unsigned char)((mdContext->buf[i] >> 24) & 0xFF); 106794: c1 ea 18 shr $0x18,%edx 106797: 88 50 4f mov %dl,0x4f(%eax) for (i = 0, ii = 0; i < 4; i++, ii += 4) { 10679a: 39 c6 cmp %eax,%esi 10679c: 75 e3 jne 106781 memcpy(hash, mdContext->digest, 16); 10679e: 8b 53 58 mov 0x58(%ebx),%edx 1067a1: 89 17 mov %edx,(%edi) 1067a3: 8b 53 5c mov 0x5c(%ebx),%edx 1067a6: 89 57 04 mov %edx,0x4(%edi) 1067a9: 8b 53 60 mov 0x60(%ebx),%edx 1067ac: 89 57 08 mov %edx,0x8(%edi) 1067af: 8b 43 64 mov 0x64(%ebx),%eax 1067b2: 89 47 0c mov %eax,0xc(%edi) } 1067b5: 83 c4 4c add $0x4c,%esp 1067b8: 5b pop %ebx 1067b9: 5e pop %esi 1067ba: 5f pop %edi 1067bb: 5d pop %ebp 1067bc: c3 ret 1067bd: 8d 76 00 lea 0x0(%esi),%esi padLen = (mdi < 56) ? (56 - mdi) : (120 - mdi); 1067c0: ba 78 00 00 00 mov $0x78,%edx <== NOT EXECUTED 1067c5: 29 c2 sub %eax,%edx <== NOT EXECUTED 1067c7: e9 54 ff ff ff jmp 106720 <== NOT EXECUTED 1067cc: 90 nop 1067cd: 90 nop 1067ce: 90 nop 1067cf: 90 nop =============================================================================== 00106610 : { 106610: 55 push %ebp 106611: 89 e5 mov %esp,%ebp 106613: 57 push %edi 106614: 56 push %esi 106615: 53 push %ebx 106616: 83 ec 44 sub $0x44,%esp 106619: 8b 5d 08 mov 0x8(%ebp),%ebx 10661c: c7 45 b0 00 00 00 00 movl $0x0,-0x50(%ebp) 106623: 8b 55 10 mov 0x10(%ebp),%edx 106626: 8b 75 0c mov 0xc(%ebp),%esi mdi = (int)((mdContext->i[0] >> 3) & 0x3F); 106629: 8b 3b mov (%ebx),%edi if ((mdContext->i[0] + ((UINT4)inLen << 3)) < mdContext->i[0]) 10662b: 8d 0c d5 00 00 00 00 lea 0x0(,%edx,8),%ecx mdi = (int)((mdContext->i[0] >> 3) & 0x3F); 106632: 89 f8 mov %edi,%eax 106634: c1 e8 03 shr $0x3,%eax 106637: 83 e0 3f and $0x3f,%eax if ((mdContext->i[0] + ((UINT4)inLen << 3)) < mdContext->i[0]) 10663a: 01 f9 add %edi,%ecx 10663c: 0f 82 96 00 00 00 jb 1066d8 <== NEVER TAKEN mdContext->i[0] += ((UINT4)inLen << 3); 106642: 89 0b mov %ecx,(%ebx) mdContext->i[1]++; 106644: 8b 7b 04 mov 0x4(%ebx),%edi mdContext->i[1] += ((UINT4)inLen >> 29); 106647: 89 d1 mov %edx,%ecx mdContext->i[1]++; 106649: 83 7d b0 01 cmpl $0x1,-0x50(%ebp) 10664d: 83 df ff sbb $0xffffffff,%edi mdContext->i[1] += ((UINT4)inLen >> 29); 106650: c1 e9 1d shr $0x1d,%ecx 106653: 01 cf add %ecx,%edi while (inLen--) { 106655: 85 d2 test %edx,%edx mdContext->i[1] += ((UINT4)inLen >> 29); 106657: 89 7b 04 mov %edi,0x4(%ebx) Transform (mdContext->buf, in); 10665a: 8d 4b 08 lea 0x8(%ebx),%ecx 10665d: 89 4d b0 mov %ecx,-0x50(%ebp) 106660: 8d 3c 16 lea (%esi,%edx,1),%edi while (inLen--) { 106663: 75 0f jne 106674 <== ALWAYS TAKEN 106665: eb 69 jmp 1066d0 <== NOT EXECUTED 106667: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10666e: 66 90 xchg %ax,%ax <== NOT EXECUTED 106670: 39 fe cmp %edi,%esi 106672: 74 5c je 1066d0 mdContext->in[mdi++] = *inBuf++; 106674: 0f b6 16 movzbl (%esi),%edx 106677: 46 inc %esi 106678: 88 54 03 18 mov %dl,0x18(%ebx,%eax,1) if (mdi == 0x40) { 10667c: 40 inc %eax 10667d: 83 f8 40 cmp $0x40,%eax 106680: 75 ee jne 106670 for (i = 0, ii = 0; i < 16; i++, ii += 4) 106682: 31 d2 xor %edx,%edx 106684: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10668b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 10668f: 90 nop in[i] = (((UINT4)mdContext->in[ii+3]) << 24) | 106690: 0f b6 44 13 1b movzbl 0x1b(%ebx,%edx,1),%eax (((UINT4)mdContext->in[ii+2]) << 16) | 106695: 0f b6 4c 13 1a movzbl 0x1a(%ebx,%edx,1),%ecx in[i] = (((UINT4)mdContext->in[ii+3]) << 24) | 10669a: c1 e0 18 shl $0x18,%eax (((UINT4)mdContext->in[ii+2]) << 16) | 10669d: c1 e1 10 shl $0x10,%ecx in[i] = (((UINT4)mdContext->in[ii+3]) << 24) | 1066a0: 09 c8 or %ecx,%eax ((UINT4)mdContext->in[ii]); 1066a2: 0f b6 4c 13 18 movzbl 0x18(%ebx,%edx,1),%ecx (((UINT4)mdContext->in[ii+1]) << 8) | 1066a7: 09 c8 or %ecx,%eax 1066a9: 0f b6 4c 13 19 movzbl 0x19(%ebx,%edx,1),%ecx 1066ae: c1 e1 08 shl $0x8,%ecx 1066b1: 09 c8 or %ecx,%eax 1066b3: 89 44 15 b4 mov %eax,-0x4c(%ebp,%edx,1) for (i = 0, ii = 0; i < 16; i++, ii += 4) 1066b7: 83 c2 04 add $0x4,%edx 1066ba: 83 fa 40 cmp $0x40,%edx 1066bd: 75 d1 jne 106690 Transform (mdContext->buf, in); 1066bf: 8b 45 b0 mov -0x50(%ebp),%eax 1066c2: 8d 55 b4 lea -0x4c(%ebp),%edx 1066c5: e8 36 f8 ff ff call 105f00 mdi = 0; 1066ca: 31 c0 xor %eax,%eax while (inLen--) { 1066cc: 39 fe cmp %edi,%esi 1066ce: 75 a4 jne 106674 } 1066d0: 83 c4 44 add $0x44,%esp 1066d3: 5b pop %ebx 1066d4: 5e pop %esi 1066d5: 5f pop %edi 1066d6: 5d pop %ebp 1066d7: c3 ret 1066d8: c7 45 b0 01 00 00 00 movl $0x1,-0x50(%ebp) <== NOT EXECUTED 1066df: e9 5e ff ff ff jmp 106642 <== NOT EXECUTED 1066e4: 90 nop 1066e5: 90 nop 1066e6: 90 nop 1066e7: 90 nop 1066e8: 90 nop 1066e9: 90 nop 1066ea: 90 nop 1066eb: 90 nop 1066ec: 90 nop 1066ed: 90 nop 1066ee: 90 nop 1066ef: 90 nop =============================================================================== 00108b70 : * SHA-256 finalization. Pads the input data, exports the hash value, * and clears the context state. */ void SHA256_Final(unsigned char digest[32], SHA256_CTX * ctx) { 108b70: 55 push %ebp 108b71: 89 e5 mov %esp,%ebp 108b73: 57 push %edi 108b74: 56 push %esi 108b75: 53 push %ebx 108b76: 83 ec 24 sub $0x24,%esp 108b79: 8b 75 0c mov 0xc(%ebp),%esi be64enc(len, ctx->count); 108b7c: 8b 56 24 mov 0x24(%esi),%edx 108b7f: 8b 46 20 mov 0x20(%esi),%eax static __inline void be32enc(void *pp, uint32_t u) { uint8_t *p = (uint8_t *)pp; p[0] = (u >> 24) & 0xff; 108b82: 8b 4e 20 mov 0x20(%esi),%ecx p[1] = (u >> 16) & 0xff; p[2] = (u >> 8) & 0xff; 108b85: 88 75 ea mov %dh,-0x16(%ebp) p[0] = (u >> 24) & 0xff; 108b88: 89 d3 mov %edx,%ebx p[3] = u & 0xff; 108b8a: 88 55 eb mov %dl,-0x15(%ebp) p[0] = (u >> 24) & 0xff; 108b8d: c1 eb 18 shr $0x18,%ebx 108b90: 88 5d e8 mov %bl,-0x18(%ebp) r = (ctx->count >> 3) & 0x3f; 108b93: 0f ac d0 03 shrd $0x3,%edx,%eax p[1] = (u >> 16) & 0xff; 108b97: 89 d3 mov %edx,%ebx 108b99: c1 eb 10 shr $0x10,%ebx 108b9c: 83 e0 3f and $0x3f,%eax 108b9f: 0f c9 bswap %ecx 108ba1: 88 5d e9 mov %bl,-0x17(%ebp) plen = (r < 56) ? (56 - r) : (120 - r); 108ba4: 83 f8 37 cmp $0x37,%eax p[0] = (u >> 24) & 0xff; 108ba7: 89 4d ec mov %ecx,-0x14(%ebp) 108baa: 0f 87 b0 00 00 00 ja 108c60 108bb0: ba 38 00 00 00 mov $0x38,%edx 108bb5: 29 c2 sub %eax,%edx SHA256_Update(ctx, PAD, (size_t)plen); 108bb7: 89 54 24 08 mov %edx,0x8(%esp) 108bbb: b8 80 f9 12 00 mov $0x12f980,%eax 108bc0: 89 44 24 04 mov %eax,0x4(%esp) 108bc4: 89 34 24 mov %esi,(%esp) 108bc7: e8 e4 fc ff ff call 1088b0 SHA256_Update(ctx, len, 8); 108bcc: 8d 45 e8 lea -0x18(%ebp),%eax 108bcf: ba 08 00 00 00 mov $0x8,%edx 108bd4: 89 54 24 08 mov %edx,0x8(%esp) 108bd8: 89 44 24 04 mov %eax,0x4(%esp) 108bdc: 89 34 24 mov %esi,(%esp) 108bdf: e8 cc fc ff ff call 1088b0 for (i = 0; i < len / 4; i++) 108be4: 8b 5d 08 mov 0x8(%ebp),%ebx 108be7: 31 c9 xor %ecx,%ecx 108be9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi be32enc(dst + i * 4, src[i]); 108bf0: 8b 04 8e mov (%esi,%ecx,4),%eax p[2] = (u >> 8) & 0xff; 108bf3: 88 64 8b 02 mov %ah,0x2(%ebx,%ecx,4) p[0] = (u >> 24) & 0xff; 108bf7: 89 c2 mov %eax,%edx p[3] = u & 0xff; 108bf9: 88 44 8b 03 mov %al,0x3(%ebx,%ecx,4) p[0] = (u >> 24) & 0xff; 108bfd: c1 ea 18 shr $0x18,%edx 108c00: 88 14 8b mov %dl,(%ebx,%ecx,4) p[1] = (u >> 16) & 0xff; 108c03: 89 c2 mov %eax,%edx 108c05: c1 ea 10 shr $0x10,%edx 108c08: 88 54 8b 01 mov %dl,0x1(%ebx,%ecx,4) for (i = 0; i < len / 4; i++) 108c0c: 41 inc %ecx 108c0d: 83 f9 08 cmp $0x8,%ecx 108c10: 75 de jne 108bf0 /* Write the hash */ be32enc_vect(digest, ctx->state, 32); /* Clear the context state */ memset((void *)ctx, 0, sizeof(*ctx)); 108c12: 31 d2 xor %edx,%edx 108c14: f7 c6 01 00 00 00 test $0x1,%esi 108c1a: bb 68 00 00 00 mov $0x68,%ebx 108c1f: 75 7f jne 108ca0 <== NEVER TAKEN 108c21: f7 c6 02 00 00 00 test $0x2,%esi 108c27: 0f 85 93 00 00 00 jne 108cc0 <== NEVER TAKEN 108c2d: 89 d9 mov %ebx,%ecx 108c2f: 31 c0 xor %eax,%eax 108c31: 83 e1 f8 and $0xfffffff8,%ecx 108c34: 89 14 06 mov %edx,(%esi,%eax,1) 108c37: 89 54 06 04 mov %edx,0x4(%esi,%eax,1) 108c3b: 83 c0 08 add $0x8,%eax 108c3e: 39 c8 cmp %ecx,%eax 108c40: 72 f2 jb 108c34 108c42: 01 c6 add %eax,%esi 108c44: f6 c3 04 test $0x4,%bl 108c47: 75 47 jne 108c90 <== NEVER TAKEN 108c49: f6 c3 02 test $0x2,%bl 108c4c: 75 32 jne 108c80 <== NEVER TAKEN 108c4e: f6 c3 01 test $0x1,%bl 108c51: 75 1d jne 108c70 <== NEVER TAKEN } 108c53: 83 c4 24 add $0x24,%esp 108c56: 5b pop %ebx 108c57: 5e pop %esi 108c58: 5f pop %edi 108c59: 5d pop %ebp 108c5a: c3 ret 108c5b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 108c5f: 90 nop plen = (r < 56) ? (56 - r) : (120 - r); 108c60: ba 78 00 00 00 mov $0x78,%edx 108c65: 29 c2 sub %eax,%edx 108c67: e9 4b ff ff ff jmp 108bb7 108c6c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi memset((void *)ctx, 0, sizeof(*ctx)); 108c70: c6 06 00 movb $0x0,(%esi) <== NOT EXECUTED } 108c73: 83 c4 24 add $0x24,%esp <== NOT EXECUTED 108c76: 5b pop %ebx <== NOT EXECUTED 108c77: 5e pop %esi <== NOT EXECUTED 108c78: 5f pop %edi <== NOT EXECUTED 108c79: 5d pop %ebp <== NOT EXECUTED 108c7a: c3 ret <== NOT EXECUTED 108c7b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 108c7f: 90 nop <== NOT EXECUTED memset((void *)ctx, 0, sizeof(*ctx)); 108c80: 66 c7 06 00 00 movw $0x0,(%esi) <== NOT EXECUTED 108c85: 83 c6 02 add $0x2,%esi <== NOT EXECUTED 108c88: f6 c3 01 test $0x1,%bl <== NOT EXECUTED 108c8b: 74 c6 je 108c53 <== NOT EXECUTED 108c8d: eb e1 jmp 108c70 <== NOT EXECUTED 108c8f: 90 nop <== NOT EXECUTED 108c90: c7 06 00 00 00 00 movl $0x0,(%esi) <== NOT EXECUTED 108c96: 83 c6 04 add $0x4,%esi <== NOT EXECUTED 108c99: f6 c3 02 test $0x2,%bl <== NOT EXECUTED 108c9c: 74 b0 je 108c4e <== NOT EXECUTED 108c9e: eb e0 jmp 108c80 <== NOT EXECUTED 108ca0: c6 06 00 movb $0x0,(%esi) <== NOT EXECUTED 108ca3: 46 inc %esi <== NOT EXECUTED 108ca4: bb 67 00 00 00 mov $0x67,%ebx <== NOT EXECUTED 108ca9: f7 c6 02 00 00 00 test $0x2,%esi <== NOT EXECUTED 108caf: 0f 84 78 ff ff ff je 108c2d <== NOT EXECUTED 108cb5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 108cbc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 108cc0: 66 c7 06 00 00 movw $0x0,(%esi) <== NOT EXECUTED 108cc5: 83 eb 02 sub $0x2,%ebx <== NOT EXECUTED 108cc8: 83 c6 02 add $0x2,%esi <== NOT EXECUTED 108ccb: e9 5d ff ff ff jmp 108c2d <== NOT EXECUTED =============================================================================== 001088b0 : /* Add bytes into the hash */ void SHA256_Update(SHA256_CTX * ctx, const void *in, size_t len) { 1088b0: 55 push %ebp 1088b1: 89 e5 mov %esp,%ebp 1088b3: 57 push %edi 1088b4: 56 push %esi 1088b5: 53 push %ebx 1088b6: 83 ec 14 sub $0x14,%esp 1088b9: 8b 75 08 mov 0x8(%ebp),%esi uint64_t bitlen; uint32_t r; const unsigned char *src = in; /* Number of bytes left in the buffer from previous updates */ r = (ctx->count >> 3) & 0x3f; 1088bc: 8b 56 24 mov 0x24(%esi),%edx 1088bf: 8b 46 20 mov 0x20(%esi),%eax 1088c2: 89 d3 mov %edx,%ebx 1088c4: 89 c1 mov %eax,%ecx 1088c6: 0f ac d9 03 shrd $0x3,%ebx,%ecx /* Convert the length into a number of bits */ bitlen = len << 3; 1088ca: 31 db xor %ebx,%ebx r = (ctx->count >> 3) & 0x3f; 1088cc: 89 cf mov %ecx,%edi bitlen = len << 3; 1088ce: 8b 4d 10 mov 0x10(%ebp),%ecx r = (ctx->count >> 3) & 0x3f; 1088d1: 83 e7 3f and $0x3f,%edi 1088d4: 89 7d ec mov %edi,-0x14(%ebp) bitlen = len << 3; 1088d7: c1 e1 03 shl $0x3,%ecx /* Update number of bits */ ctx->count += bitlen; 1088da: 01 c1 add %eax,%ecx 1088dc: 89 4e 20 mov %ecx,0x20(%esi) 1088df: 11 d3 adc %edx,%ebx /* Handle the case where we don't need to perform any transforms */ if (len < 64 - r) { 1088e1: ba 40 00 00 00 mov $0x40,%edx ctx->count += bitlen; 1088e6: 89 5e 24 mov %ebx,0x24(%esi) if (len < 64 - r) { 1088e9: 29 fa sub %edi,%edx 1088eb: 3b 55 10 cmp 0x10(%ebp),%edx memcpy(&ctx->buf[r], src, len); 1088ee: 8d 7c 3e 28 lea 0x28(%esi,%edi,1),%edi if (len < 64 - r) { 1088f2: 0f 87 a8 01 00 00 ja 108aa0 return; } /* Finish the current block */ memcpy(&ctx->buf[r], src, 64 - r); 1088f8: 83 fa 04 cmp $0x4,%edx 1088fb: 8b 4d 0c mov 0xc(%ebp),%ecx 1088fe: 89 d3 mov %edx,%ebx 108900: 89 d0 mov %edx,%eax 108902: 0f 83 38 01 00 00 jae 108a40 108908: 31 d2 xor %edx,%edx 10890a: a8 02 test $0x2,%al 10890c: 0f 85 be 00 00 00 jne 1089d0 108912: a8 01 test $0x1,%al 108914: 0f 85 a6 00 00 00 jne 1089c0 SHA256_Transform(ctx->state, ctx->buf); 10891a: 8d 46 28 lea 0x28(%esi),%eax 10891d: 89 45 e8 mov %eax,-0x18(%ebp) 108920: 89 c2 mov %eax,%edx 108922: 89 f0 mov %esi,%eax 108924: e8 a7 de ff ff call 1067d0 src += 64 - r; 108929: 8b 45 0c mov 0xc(%ebp),%eax len -= 64 - r; 10892c: 8b 55 10 mov 0x10(%ebp),%edx src += 64 - r; 10892f: 01 c3 add %eax,%ebx len -= 64 - r; 108931: 8b 45 ec mov -0x14(%ebp),%eax src += 64 - r; 108934: 89 df mov %ebx,%edi len -= 64 - r; 108936: 8d 44 10 c0 lea -0x40(%eax,%edx,1),%eax 10893a: 89 45 ec mov %eax,-0x14(%ebp) /* Perform complete blocks */ while (len >= 64) { 10893d: 83 f8 3f cmp $0x3f,%eax 108940: 76 22 jbe 108964 108942: 8d 48 c0 lea -0x40(%eax),%ecx 108945: 83 e1 c0 and $0xffffffc0,%ecx 108948: 8d 5c 0b 40 lea 0x40(%ebx,%ecx,1),%ebx 10894c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi SHA256_Transform(ctx->state, src); 108950: 89 fa mov %edi,%edx 108952: 89 f0 mov %esi,%eax 108954: e8 77 de ff ff call 1067d0 src += 64; 108959: 83 c7 40 add $0x40,%edi while (len >= 64) { 10895c: 39 df cmp %ebx,%edi 10895e: 75 f0 jne 108950 <== NEVER TAKEN len -= 64; 108960: 83 65 ec 3f andl $0x3f,-0x14(%ebp) } /* Copy left over data into buffer */ memcpy(ctx->buf, src, len); 108964: 8b 45 ec mov -0x14(%ebp),%eax 108967: 8b 7d e8 mov -0x18(%ebp),%edi 10896a: 83 f8 04 cmp $0x4,%eax 10896d: 0f 83 7d 00 00 00 jae 1089f0 108973: 31 c0 xor %eax,%eax 108975: f6 45 ec 02 testb $0x2,-0x14(%ebp) 108979: 75 25 jne 1089a0 10897b: f6 45 ec 01 testb $0x1,-0x14(%ebp) 10897f: 75 0f jne 108990 } 108981: 83 c4 14 add $0x14,%esp 108984: 5b pop %ebx 108985: 5e pop %esi 108986: 5f pop %edi 108987: 5d pop %ebp 108988: c3 ret 108989: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi memcpy(ctx->buf, src, len); 108990: 0f b6 14 03 movzbl (%ebx,%eax,1),%edx 108994: 88 14 07 mov %dl,(%edi,%eax,1) } 108997: 83 c4 14 add $0x14,%esp 10899a: 5b pop %ebx 10899b: 5e pop %esi 10899c: 5f pop %edi 10899d: 5d pop %ebp 10899e: c3 ret 10899f: 90 nop memcpy(ctx->buf, src, len); 1089a0: 0f b7 03 movzwl (%ebx),%eax 1089a3: 66 89 07 mov %ax,(%edi) 1089a6: b8 02 00 00 00 mov $0x2,%eax 1089ab: f6 45 ec 01 testb $0x1,-0x14(%ebp) 1089af: 74 d0 je 108981 1089b1: eb dd jmp 108990 1089b3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1089ba: 8d b6 00 00 00 00 lea 0x0(%esi),%esi memcpy(&ctx->buf[r], src, 64 - r); 1089c0: 0f b6 04 11 movzbl (%ecx,%edx,1),%eax 1089c4: 88 04 17 mov %al,(%edi,%edx,1) 1089c7: e9 4e ff ff ff jmp 10891a 1089cc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 1089d0: 0f b7 11 movzwl (%ecx),%edx 1089d3: a8 01 test $0x1,%al 1089d5: 66 89 17 mov %dx,(%edi) 1089d8: ba 02 00 00 00 mov $0x2,%edx 1089dd: 0f 84 37 ff ff ff je 10891a 1089e3: eb db jmp 1089c0 1089e5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1089ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi memcpy(ctx->buf, src, len); 1089f0: f7 c7 01 00 00 00 test $0x1,%edi 1089f6: 0f 85 f2 00 00 00 jne 108aee <== NEVER TAKEN 1089fc: f7 c7 02 00 00 00 test $0x2,%edi 108a02: 0f 85 f6 00 00 00 jne 108afe <== NEVER TAKEN 108a08: 8b 45 ec mov -0x14(%ebp),%eax 108a0b: 83 f8 04 cmp $0x4,%eax 108a0e: 0f 82 5f ff ff ff jb 108973 <== NEVER TAKEN 108a14: 89 c1 mov %eax,%ecx 108a16: 31 c0 xor %eax,%eax 108a18: 83 e1 fc and $0xfffffffc,%ecx 108a1b: 8b 14 03 mov (%ebx,%eax,1),%edx 108a1e: 89 14 07 mov %edx,(%edi,%eax,1) 108a21: 83 c0 04 add $0x4,%eax 108a24: 39 c8 cmp %ecx,%eax 108a26: 72 f3 jb 108a1b 108a28: 01 c7 add %eax,%edi 108a2a: 01 c3 add %eax,%ebx 108a2c: 31 c0 xor %eax,%eax 108a2e: f6 45 ec 02 testb $0x2,-0x14(%ebp) 108a32: 0f 84 43 ff ff ff je 10897b 108a38: e9 63 ff ff ff jmp 1089a0 108a3d: 8d 76 00 lea 0x0(%esi),%esi memcpy(&ctx->buf[r], src, 64 - r); 108a40: f7 c7 01 00 00 00 test $0x1,%edi 108a46: 0f 85 c8 00 00 00 jne 108b14 108a4c: f7 c7 02 00 00 00 test $0x2,%edi 108a52: 0f 85 d4 00 00 00 jne 108b2c 108a58: 83 f8 04 cmp $0x4,%eax 108a5b: 0f 82 a7 fe ff ff jb 108908 <== NEVER TAKEN 108a61: 89 45 e4 mov %eax,-0x1c(%ebp) 108a64: 89 c2 mov %eax,%edx 108a66: 83 e2 fc and $0xfffffffc,%edx 108a69: 89 55 e8 mov %edx,-0x18(%ebp) 108a6c: 31 d2 xor %edx,%edx 108a6e: 8b 04 11 mov (%ecx,%edx,1),%eax 108a71: 89 04 17 mov %eax,(%edi,%edx,1) 108a74: 83 c2 04 add $0x4,%edx 108a77: 3b 55 e8 cmp -0x18(%ebp),%edx 108a7a: 72 f2 jb 108a6e 108a7c: 8b 45 e4 mov -0x1c(%ebp),%eax 108a7f: 01 d7 add %edx,%edi 108a81: 01 d1 add %edx,%ecx 108a83: 31 d2 xor %edx,%edx 108a85: a8 02 test $0x2,%al 108a87: 0f 84 85 fe ff ff je 108912 <== ALWAYS TAKEN 108a8d: e9 3e ff ff ff jmp 1089d0 <== NOT EXECUTED 108a92: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 108a99: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED memcpy(&ctx->buf[r], src, len); 108aa0: 8b 4d 10 mov 0x10(%ebp),%ecx 108aa3: 8b 75 0c mov 0xc(%ebp),%esi 108aa6: 83 f9 08 cmp $0x8,%ecx 108aa9: 73 15 jae 108ac0 108aab: f3 a4 rep movsb %ds:(%esi),%es:(%edi) } 108aad: 83 c4 14 add $0x14,%esp 108ab0: 5b pop %ebx 108ab1: 5e pop %esi 108ab2: 5f pop %edi 108ab3: 5d pop %ebp 108ab4: c3 ret 108ab5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 108abc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi memcpy(&ctx->buf[r], src, len); 108ac0: f7 c7 01 00 00 00 test $0x1,%edi 108ac6: 0f 85 87 00 00 00 jne 108b53 108acc: f7 c7 02 00 00 00 test $0x2,%edi 108ad2: 75 6d jne 108b41 108ad4: f7 c7 04 00 00 00 test $0x4,%edi 108ada: 74 cf je 108aab 108adc: 8b 06 mov (%esi),%eax 108ade: 83 c7 04 add $0x4,%edi 108ae1: 83 c6 04 add $0x4,%esi 108ae4: 83 e9 04 sub $0x4,%ecx 108ae7: 89 47 fc mov %eax,-0x4(%edi) 108aea: f3 a4 rep movsb %ds:(%esi),%es:(%edi) return; 108aec: eb bf jmp 108aad memcpy(ctx->buf, src, len); 108aee: 0f b6 03 movzbl (%ebx),%eax <== NOT EXECUTED 108af1: 47 inc %edi <== NOT EXECUTED 108af2: 43 inc %ebx <== NOT EXECUTED 108af3: 88 46 28 mov %al,0x28(%esi) <== NOT EXECUTED 108af6: ff 4d ec decl -0x14(%ebp) <== NOT EXECUTED 108af9: e9 fe fe ff ff jmp 1089fc <== NOT EXECUTED 108afe: 0f b7 03 movzwl (%ebx),%eax <== NOT EXECUTED 108b01: 83 c7 02 add $0x2,%edi <== NOT EXECUTED 108b04: 83 c3 02 add $0x2,%ebx <== NOT EXECUTED 108b07: 66 89 47 fe mov %ax,-0x2(%edi) <== NOT EXECUTED 108b0b: 83 6d ec 02 subl $0x2,-0x14(%ebp) <== NOT EXECUTED 108b0f: e9 f4 fe ff ff jmp 108a08 <== NOT EXECUTED memcpy(&ctx->buf[r], src, 64 - r); 108b14: 0f b6 01 movzbl (%ecx),%eax 108b17: 47 inc %edi 108b18: 88 45 e8 mov %al,-0x18(%ebp) 108b1b: 88 47 ff mov %al,-0x1(%edi) 108b1e: 8b 45 0c mov 0xc(%ebp),%eax 108b21: 8d 48 01 lea 0x1(%eax),%ecx 108b24: 8d 42 ff lea -0x1(%edx),%eax 108b27: e9 20 ff ff ff jmp 108a4c 108b2c: 0f b7 11 movzwl (%ecx),%edx 108b2f: 83 c7 02 add $0x2,%edi 108b32: 83 c1 02 add $0x2,%ecx 108b35: 83 e8 02 sub $0x2,%eax 108b38: 66 89 57 fe mov %dx,-0x2(%edi) 108b3c: e9 17 ff ff ff jmp 108a58 memcpy(&ctx->buf[r], src, len); 108b41: 0f b7 06 movzwl (%esi),%eax 108b44: 83 c7 02 add $0x2,%edi 108b47: 83 c6 02 add $0x2,%esi 108b4a: 83 e9 02 sub $0x2,%ecx 108b4d: 66 89 47 fe mov %ax,-0x2(%edi) 108b51: eb 81 jmp 108ad4 108b53: 0f b6 06 movzbl (%esi),%eax 108b56: 47 inc %edi 108b57: 46 inc %esi 108b58: 49 dec %ecx 108b59: 88 47 ff mov %al,-0x1(%edi) 108b5c: e9 6b ff ff ff jmp 108acc 108b61: 90 nop 108b62: 90 nop 108b63: 90 nop 108b64: 90 nop 108b65: 90 nop 108b66: 90 nop 108b67: 90 nop 108b68: 90 nop 108b69: 90 nop 108b6a: 90 nop 108b6b: 90 nop 108b6c: 90 nop 108b6d: 90 nop 108b6e: 90 nop 108b6f: 90 nop =============================================================================== 001136f0 : * SHA-512 finalization. Pads the input data, exports the hash value, * and clears the context state. */ void SHA512_Final(unsigned char digest[64], SHA512_CTX * ctx) { 1136f0: 55 push %ebp be64enc_vect(len, ctx->count, 16); 1136f1: b9 10 00 00 00 mov $0x10,%ecx { 1136f6: 89 e5 mov %esp,%ebp 1136f8: 57 push %edi 1136f9: 56 push %esi 1136fa: 53 push %ebx be64enc_vect(len, ctx->count, 16); 1136fb: 8d 75 d8 lea -0x28(%ebp),%esi { 1136fe: 83 ec 2c sub $0x2c,%esp 113701: 8b 7d 0c mov 0xc(%ebp),%edi be64enc_vect(len, ctx->count, 16); 113704: 89 f0 mov %esi,%eax 113706: 8d 57 40 lea 0x40(%edi),%edx 113709: e8 c2 55 ff ff call 108cd0 r = (ctx->count[1] >> 3) & 0x7f; 11370e: 8b 47 48 mov 0x48(%edi),%eax plen = (r < 112) ? (112 - r) : (240 - r); 113711: b9 6f 00 00 00 mov $0x6f,%ecx r = (ctx->count[1] >> 3) & 0x7f; 113716: 8b 57 4c mov 0x4c(%edi),%edx 113719: 0f ac d0 03 shrd $0x3,%edx,%eax 11371d: 89 c3 mov %eax,%ebx 11371f: 83 e3 7f and $0x7f,%ebx plen = (r < 112) ? (112 - r) : (240 - r); 113722: 39 d9 cmp %ebx,%ecx r = (ctx->count[1] >> 3) & 0x7f; 113724: 89 d8 mov %ebx,%eax plen = (r < 112) ? (112 - r) : (240 - r); 113726: 0f 82 a4 00 00 00 jb 1137d0 11372c: b9 70 00 00 00 mov $0x70,%ecx SHA512_Update(ctx, PAD, (size_t)plen); 113731: 89 3c 24 mov %edi,(%esp) plen = (r < 112) ? (112 - r) : (240 - r); 113734: 29 c1 sub %eax,%ecx SHA512_Update(ctx, PAD, (size_t)plen); 113736: b8 c0 f9 12 00 mov $0x12f9c0,%eax 11373b: 89 4c 24 08 mov %ecx,0x8(%esp) /* Write the hash */ be64enc_vect(digest, ctx->state, 64); /* Clear the context state */ memset((void *)ctx, 0, sizeof(*ctx)); 11373f: 89 fb mov %edi,%ebx SHA512_Update(ctx, PAD, (size_t)plen); 113741: 89 44 24 04 mov %eax,0x4(%esp) 113745: e8 96 fc ff ff call 1133e0 SHA512_Update(ctx, len, 16); 11374a: ba 10 00 00 00 mov $0x10,%edx 11374f: 89 54 24 08 mov %edx,0x8(%esp) 113753: 89 74 24 04 mov %esi,0x4(%esp) 113757: 89 3c 24 mov %edi,(%esp) 11375a: e8 81 fc ff ff call 1133e0 be64enc_vect(digest, ctx->state, 64); 11375f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 113762: b9 40 00 00 00 mov $0x40,%ecx <== NOT EXECUTED 113767: 89 fa mov %edi,%edx <== NOT EXECUTED 113769: e8 62 55 ff ff call 108cd0 <== NOT EXECUTED memset((void *)ctx, 0, sizeof(*ctx)); 11376e: 31 d2 xor %edx,%edx 113770: f6 c3 01 test $0x1,%bl 113773: b9 d0 00 00 00 mov $0xd0,%ecx 113778: 75 66 jne 1137e0 <== NEVER TAKEN 11377a: f6 c3 02 test $0x2,%bl 11377d: 75 71 jne 1137f0 <== NEVER TAKEN 11377f: 89 ce mov %ecx,%esi 113781: 31 c0 xor %eax,%eax 113783: 83 e6 f8 and $0xfffffff8,%esi 113786: 89 14 03 mov %edx,(%ebx,%eax,1) 113789: 89 54 03 04 mov %edx,0x4(%ebx,%eax,1) 11378d: 83 c0 08 add $0x8,%eax 113790: 39 f0 cmp %esi,%eax 113792: 72 f2 jb 113786 113794: 01 c3 add %eax,%ebx 113796: f6 c1 04 test $0x4,%cl 113799: 74 09 je 1137a4 <== ALWAYS TAKEN 11379b: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED 1137a1: 83 c3 04 add $0x4,%ebx <== NOT EXECUTED 1137a4: f6 c1 02 test $0x2,%cl 1137a7: 74 08 je 1137b1 <== ALWAYS TAKEN 1137a9: 66 c7 03 00 00 movw $0x0,(%ebx) <== NOT EXECUTED 1137ae: 83 c3 02 add $0x2,%ebx <== NOT EXECUTED 1137b1: f6 c1 01 test $0x1,%cl 1137b4: 74 03 je 1137b9 <== ALWAYS TAKEN 1137b6: c6 03 00 movb $0x0,(%ebx) <== NOT EXECUTED } 1137b9: 83 c4 2c add $0x2c,%esp 1137bc: 5b pop %ebx 1137bd: 5e pop %esi 1137be: 5f pop %edi 1137bf: 5d pop %ebp 1137c0: c3 ret 1137c1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1137c8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1137cf: 90 nop plen = (r < 112) ? (112 - r) : (240 - r); 1137d0: b9 f0 00 00 00 mov $0xf0,%ecx 1137d5: e9 57 ff ff ff jmp 113731 1137da: 8d b6 00 00 00 00 lea 0x0(%esi),%esi memset((void *)ctx, 0, sizeof(*ctx)); 1137e0: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED 1137e3: 43 inc %ebx <== NOT EXECUTED 1137e4: b9 cf 00 00 00 mov $0xcf,%ecx <== NOT EXECUTED 1137e9: f6 c3 02 test $0x2,%bl <== NOT EXECUTED 1137ec: 74 91 je 11377f <== NOT EXECUTED 1137ee: 66 90 xchg %ax,%ax <== NOT EXECUTED 1137f0: 66 c7 03 00 00 movw $0x0,(%ebx) <== NOT EXECUTED 1137f5: 83 e9 02 sub $0x2,%ecx <== NOT EXECUTED 1137f8: 83 c3 02 add $0x2,%ebx <== NOT EXECUTED 1137fb: eb 82 jmp 11377f <== NOT EXECUTED 1137fd: 90 nop 1137fe: 90 nop 1137ff: 90 nop =============================================================================== 001133e0 : /* Add bytes into the hash */ void SHA512_Update(SHA512_CTX * ctx, const void *in, size_t len) { 1133e0: 55 push %ebp 1133e1: 89 e5 mov %esp,%ebp 1133e3: 57 push %edi 1133e4: 56 push %esi 1133e5: 53 push %ebx 1133e6: 83 ec 14 sub $0x14,%esp uint64_t bitlen[2]; uint64_t r; const unsigned char *src = in; /* Number of bytes left in the buffer from previous updates */ r = (ctx->count[1] >> 3) & 0x7f; 1133e9: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp) { 1133f0: 8b 45 08 mov 0x8(%ebp),%eax r = (ctx->count[1] >> 3) & 0x7f; 1133f3: 8b 70 48 mov 0x48(%eax),%esi 1133f6: 8b 78 4c mov 0x4c(%eax),%edi 1133f9: 89 f1 mov %esi,%ecx 1133fb: 89 fb mov %edi,%ebx 1133fd: 0f ac d9 03 shrd $0x3,%ebx,%ecx 113401: 89 ca mov %ecx,%edx /* Convert the length into a number of bits */ bitlen[1] = ((uint64_t)len) << 3; 113403: 31 c9 xor %ecx,%ecx 113405: 89 4d e4 mov %ecx,-0x1c(%ebp) r = (ctx->count[1] >> 3) & 0x7f; 113408: 83 e2 7f and $0x7f,%edx bitlen[1] = ((uint64_t)len) << 3; 11340b: 89 cb mov %ecx,%ebx r = (ctx->count[1] >> 3) & 0x7f; 11340d: 89 55 e8 mov %edx,-0x18(%ebp) bitlen[1] = ((uint64_t)len) << 3; 113410: 8b 55 10 mov 0x10(%ebp),%edx 113413: 89 55 e0 mov %edx,-0x20(%ebp) 113416: 89 d1 mov %edx,%ecx 113418: 0f a4 cb 03 shld $0x3,%ecx,%ebx 11341c: c1 e1 03 shl $0x3,%ecx 11341f: 01 f1 add %esi,%ecx 113421: 11 fb adc %edi,%ebx 113423: 0f 82 b4 02 00 00 jb 1136dd <== NEVER TAKEN 113429: 31 d2 xor %edx,%edx bitlen[0] = ((uint64_t)len) >> 61; /* Update number of bits */ if ((ctx->count[1] += bitlen[1]) < bitlen[1]) 11342b: 89 48 48 mov %ecx,0x48(%eax) 11342e: 85 d2 test %edx,%edx 113430: 89 58 4c mov %ebx,0x4c(%eax) 113433: 74 08 je 11343d <== ALWAYS TAKEN ctx->count[0]++; 113435: 83 40 40 01 addl $0x1,0x40(%eax) <== NOT EXECUTED 113439: 83 50 44 00 adcl $0x0,0x44(%eax) <== NOT EXECUTED ctx->count[0] += bitlen[0]; /* Handle the case where we don't need to perform any transforms */ if (len < 128 - r) { 11343d: b9 80 00 00 00 mov $0x80,%ecx 113442: 31 db xor %ebx,%ebx 113444: 8b 55 e4 mov -0x1c(%ebp),%edx 113447: 2b 4d e8 sub -0x18(%ebp),%ecx 11344a: 8b 75 e8 mov -0x18(%ebp),%esi 11344d: 1b 5d ec sbb -0x14(%ebp),%ebx 113450: 39 4d 10 cmp %ecx,0x10(%ebp) memcpy(&ctx->buf[r], src, len); 113453: 8d 7c 30 50 lea 0x50(%eax,%esi,1),%edi if (len < 128 - r) { 113457: 19 da sbb %ebx,%edx 113459: 0f 82 c1 01 00 00 jb 113620 return; } /* Finish the current block */ memcpy(&ctx->buf[r], src, 128 - r); 11345f: ba 80 00 00 00 mov $0x80,%edx 113464: 8b 4d 0c mov 0xc(%ebp),%ecx 113467: 89 d3 mov %edx,%ebx 113469: 29 f3 sub %esi,%ebx 11346b: 89 5d e8 mov %ebx,-0x18(%ebp) 11346e: 83 fb 04 cmp $0x4,%ebx 113471: 0f 83 49 01 00 00 jae 1135c0 113477: 31 d2 xor %edx,%edx 113479: f6 45 e8 02 testb $0x2,-0x18(%ebp) 11347d: 0f 85 cd 00 00 00 jne 113550 113483: f6 45 e8 01 testb $0x1,-0x18(%ebp) 113487: 0f 85 b3 00 00 00 jne 113540 SHA512_Transform(ctx->state, ctx->buf); 11348d: 89 45 08 mov %eax,0x8(%ebp) 113490: 8d 50 50 lea 0x50(%eax),%edx 113493: 89 55 e8 mov %edx,-0x18(%ebp) 113496: e8 95 58 ff ff call 108d30 src += 128 - r; 11349b: 8b 45 0c mov 0xc(%ebp),%eax 11349e: 01 c3 add %eax,%ebx len -= 128 - r; 1134a0: 8b 45 10 mov 0x10(%ebp),%eax src += 128 - r; 1134a3: 89 df mov %ebx,%edi len -= 128 - r; 1134a5: 8d 74 06 80 lea -0x80(%esi,%eax,1),%esi /* Perform complete blocks */ while (len >= 128) { 1134a9: 8b 45 08 mov 0x8(%ebp),%eax 1134ac: 83 fe 7f cmp $0x7f,%esi 1134af: 76 37 jbe 1134e8 <== ALWAYS TAKEN 1134b1: 89 75 e0 mov %esi,-0x20(%ebp) <== NOT EXECUTED 1134b4: 8d 4e 80 lea -0x80(%esi),%ecx <== NOT EXECUTED 1134b7: 89 c6 mov %eax,%esi <== NOT EXECUTED 1134b9: 83 e1 80 and $0xffffff80,%ecx <== NOT EXECUTED 1134bc: 8d 9c 0b 80 00 00 00 lea 0x80(%ebx,%ecx,1),%ebx <== NOT EXECUTED 1134c3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 1134ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED SHA512_Transform(ctx->state, src); 1134d0: 89 fa mov %edi,%edx <== NOT EXECUTED 1134d2: 89 f0 mov %esi,%eax <== NOT EXECUTED 1134d4: e8 57 58 ff ff call 108d30 <== NOT EXECUTED src += 128; 1134d9: 83 ef 80 sub $0xffffff80,%edi <== NOT EXECUTED while (len >= 128) { 1134dc: 39 df cmp %ebx,%edi <== NOT EXECUTED 1134de: 75 f0 jne 1134d0 <== NOT EXECUTED len -= 128; 1134e0: 89 f0 mov %esi,%eax <== NOT EXECUTED 1134e2: 8b 75 e0 mov -0x20(%ebp),%esi <== NOT EXECUTED 1134e5: 83 e6 7f and $0x7f,%esi <== NOT EXECUTED } /* Copy left over data into buffer */ memcpy(ctx->buf, src, len); 1134e8: 83 fe 04 cmp $0x4,%esi 1134eb: 8b 7d e8 mov -0x18(%ebp),%edi 1134ee: 0f 83 7c 00 00 00 jae 113570 1134f4: 31 c0 xor %eax,%eax 1134f6: f7 c6 02 00 00 00 test $0x2,%esi 1134fc: 75 22 jne 113520 1134fe: 83 e6 01 and $0x1,%esi 113501: 75 0d jne 113510 } 113503: 83 c4 14 add $0x14,%esp 113506: 5b pop %ebx 113507: 5e pop %esi 113508: 5f pop %edi 113509: 5d pop %ebp 11350a: c3 ret 11350b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 11350f: 90 nop memcpy(ctx->buf, src, len); 113510: 0f b6 1c 03 movzbl (%ebx,%eax,1),%ebx <== NOT EXECUTED 113514: 88 1c 07 mov %bl,(%edi,%eax,1) <== NOT EXECUTED } 113517: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 11351a: 5b pop %ebx <== NOT EXECUTED 11351b: 5e pop %esi <== NOT EXECUTED 11351c: 5f pop %edi <== NOT EXECUTED 11351d: 5d pop %ebp <== NOT EXECUTED 11351e: c3 ret <== NOT EXECUTED 11351f: 90 nop <== NOT EXECUTED memcpy(ctx->buf, src, len); 113520: 0f b7 03 movzwl (%ebx),%eax 113523: 83 e6 01 and $0x1,%esi 113526: 66 89 07 mov %ax,(%edi) 113529: b8 02 00 00 00 mov $0x2,%eax 11352e: 74 d3 je 113503 113530: eb de jmp 113510 113532: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 113539: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi memcpy(&ctx->buf[r], src, 128 - r); 113540: 0f b6 0c 11 movzbl (%ecx,%edx,1),%ecx 113544: 88 0c 17 mov %cl,(%edi,%edx,1) 113547: e9 41 ff ff ff jmp 11348d 11354c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 113550: 0f b7 11 movzwl (%ecx),%edx 113553: 66 89 17 mov %dx,(%edi) 113556: ba 02 00 00 00 mov $0x2,%edx 11355b: f6 45 e8 01 testb $0x1,-0x18(%ebp) 11355f: 0f 84 28 ff ff ff je 11348d 113565: eb d9 jmp 113540 113567: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 11356e: 66 90 xchg %ax,%ax memcpy(ctx->buf, src, len); 113570: f7 c7 01 00 00 00 test $0x1,%edi 113576: 0f 85 f2 00 00 00 jne 11366e <== NEVER TAKEN 11357c: f7 c7 02 00 00 00 test $0x2,%edi 113582: 0f 85 20 01 00 00 jne 1136a8 <== NEVER TAKEN 113588: 83 fe 04 cmp $0x4,%esi 11358b: 0f 82 63 ff ff ff jb 1134f4 <== NEVER TAKEN 113591: 89 f1 mov %esi,%ecx 113593: 31 c0 xor %eax,%eax 113595: 83 e1 fc and $0xfffffffc,%ecx 113598: 8b 14 03 mov (%ebx,%eax,1),%edx 11359b: 89 14 07 mov %edx,(%edi,%eax,1) 11359e: 83 c0 04 add $0x4,%eax 1135a1: 39 c8 cmp %ecx,%eax 1135a3: 72 f3 jb 113598 1135a5: 01 c7 add %eax,%edi 1135a7: 01 c3 add %eax,%ebx 1135a9: 31 c0 xor %eax,%eax 1135ab: f7 c6 02 00 00 00 test $0x2,%esi 1135b1: 0f 84 47 ff ff ff je 1134fe 1135b7: e9 64 ff ff ff jmp 113520 1135bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi memcpy(&ctx->buf[r], src, 128 - r); 1135c0: f7 c7 01 00 00 00 test $0x1,%edi 1135c6: 0f 85 b0 00 00 00 jne 11367c 1135cc: f7 c7 02 00 00 00 test $0x2,%edi 1135d2: 0f 85 ba 00 00 00 jne 113692 1135d8: 8b 55 e8 mov -0x18(%ebp),%edx 1135db: 83 fa 04 cmp $0x4,%edx 1135de: 0f 82 93 fe ff ff jb 113477 <== NEVER TAKEN 1135e4: 89 45 08 mov %eax,0x8(%ebp) 1135e7: 83 e2 fc and $0xfffffffc,%edx 1135ea: 89 55 e0 mov %edx,-0x20(%ebp) 1135ed: 31 d2 xor %edx,%edx 1135ef: 8b 04 11 mov (%ecx,%edx,1),%eax 1135f2: 89 04 17 mov %eax,(%edi,%edx,1) 1135f5: 83 c2 04 add $0x4,%edx 1135f8: 3b 55 e0 cmp -0x20(%ebp),%edx 1135fb: 72 f2 jb 1135ef 1135fd: 01 d7 add %edx,%edi 1135ff: 01 d1 add %edx,%ecx 113601: 8b 45 08 mov 0x8(%ebp),%eax 113604: 31 d2 xor %edx,%edx 113606: f6 45 e8 02 testb $0x2,-0x18(%ebp) 11360a: 0f 84 73 fe ff ff je 113483 <== ALWAYS TAKEN 113610: e9 3b ff ff ff jmp 113550 <== NOT EXECUTED 113615: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 11361c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED memcpy(&ctx->buf[r], src, len); 113620: 8b 4d 10 mov 0x10(%ebp),%ecx 113623: 8b 75 0c mov 0xc(%ebp),%esi 113626: 83 f9 08 cmp $0x8,%ecx 113629: 73 15 jae 113640 11362b: f3 a4 rep movsb %ds:(%esi),%es:(%edi) } 11362d: 83 c4 14 add $0x14,%esp 113630: 5b pop %ebx 113631: 5e pop %esi 113632: 5f pop %edi 113633: 5d pop %ebp 113634: c3 ret 113635: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 11363c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi memcpy(&ctx->buf[r], src, len); 113640: f7 c7 01 00 00 00 test $0x1,%edi 113646: 0f 85 83 00 00 00 jne 1136cf 11364c: f7 c7 02 00 00 00 test $0x2,%edi 113652: 75 69 jne 1136bd 113654: f7 c7 04 00 00 00 test $0x4,%edi 11365a: 74 cf je 11362b 11365c: 8b 06 mov (%esi),%eax 11365e: 83 c7 04 add $0x4,%edi 113661: 83 c6 04 add $0x4,%esi 113664: 83 e9 04 sub $0x4,%ecx 113667: 89 47 fc mov %eax,-0x4(%edi) 11366a: f3 a4 rep movsb %ds:(%esi),%es:(%edi) return; 11366c: eb bf jmp 11362d memcpy(ctx->buf, src, len); 11366e: 0f b6 13 movzbl (%ebx),%edx <== NOT EXECUTED 113671: 47 inc %edi <== NOT EXECUTED 113672: 43 inc %ebx <== NOT EXECUTED 113673: 4e dec %esi <== NOT EXECUTED 113674: 88 50 50 mov %dl,0x50(%eax) <== NOT EXECUTED 113677: e9 00 ff ff ff jmp 11357c <== NOT EXECUTED memcpy(&ctx->buf[r], src, 128 - r); 11367c: 0f b6 11 movzbl (%ecx),%edx 11367f: 47 inc %edi 113680: 88 57 ff mov %dl,-0x1(%edi) 113683: 8d 53 ff lea -0x1(%ebx),%edx 113686: 89 55 e8 mov %edx,-0x18(%ebp) 113689: 8b 4d 0c mov 0xc(%ebp),%ecx 11368c: 41 inc %ecx 11368d: e9 3a ff ff ff jmp 1135cc 113692: 0f b7 11 movzwl (%ecx),%edx 113695: 83 c7 02 add $0x2,%edi 113698: 83 c1 02 add $0x2,%ecx 11369b: 66 89 57 fe mov %dx,-0x2(%edi) 11369f: 83 6d e8 02 subl $0x2,-0x18(%ebp) 1136a3: e9 30 ff ff ff jmp 1135d8 memcpy(ctx->buf, src, len); 1136a8: 0f b7 03 movzwl (%ebx),%eax <== NOT EXECUTED 1136ab: 83 c7 02 add $0x2,%edi <== NOT EXECUTED 1136ae: 83 c3 02 add $0x2,%ebx <== NOT EXECUTED 1136b1: 83 ee 02 sub $0x2,%esi <== NOT EXECUTED 1136b4: 66 89 47 fe mov %ax,-0x2(%edi) <== NOT EXECUTED 1136b8: e9 cb fe ff ff jmp 113588 <== NOT EXECUTED memcpy(&ctx->buf[r], src, len); 1136bd: 0f b7 06 movzwl (%esi),%eax 1136c0: 83 c7 02 add $0x2,%edi 1136c3: 83 c6 02 add $0x2,%esi 1136c6: 83 e9 02 sub $0x2,%ecx 1136c9: 66 89 47 fe mov %ax,-0x2(%edi) 1136cd: eb 85 jmp 113654 1136cf: 0f b6 06 movzbl (%esi),%eax 1136d2: 47 inc %edi 1136d3: 46 inc %esi 1136d4: 49 dec %ecx 1136d5: 88 47 ff mov %al,-0x1(%edi) 1136d8: e9 6f ff ff ff jmp 11364c 1136dd: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 1136e2: e9 44 fd ff ff jmp 11342b <== NOT EXECUTED 1136e7: 90 nop 1136e8: 90 nop 1136e9: 90 nop 1136ea: 90 nop 1136eb: 90 nop 1136ec: 90 nop 1136ed: 90 nop 1136ee: 90 nop 1136ef: 90 nop