=============================================================================== 400066cc : { 400066cc: 9d e3 bf 60 save %sp, -160, %sp in[14] = mdContext->i[0]; 400066d0: d4 06 40 00 ld [ %i1 ], %o2 in[15] = mdContext->i[1]; 400066d4: c2 06 60 04 ld [ %i1 + 4 ], %g1 in[14] = mdContext->i[0]; 400066d8: d4 27 bf f8 st %o2, [ %fp + -8 ] mdi = (int)((mdContext->i[0] >> 3) & 0x3F); 400066dc: 95 32 a0 03 srl %o2, 3, %o2 400066e0: 94 0a a0 3f and %o2, 0x3f, %o2 padLen = (mdi < 56) ? (56 - mdi) : (120 - mdi); 400066e4: 80 a2 a0 37 cmp %o2, 0x37 400066e8: 14 80 00 2e bg 400067a0 <== NEVER TAKEN 400066ec: c2 27 bf fc st %g1, [ %fp + -4 ] 400066f0: 82 10 20 38 mov 0x38, %g1 400066f4: 94 20 40 0a sub %g1, %o2, %o2 MD5Update (mdContext, PADDING, padLen); 400066f8: 90 10 00 19 mov %i1, %o0 400066fc: 13 10 00 93 sethi %hi(0x40024c00), %o1 40006700: 7f ff ff bf call 400065fc 40006704: 92 12 61 78 or %o1, 0x178, %o1 ! 40024d78 for (i = 0, ii = 0; i < 14; i++, ii += 4) 40006708: b4 06 60 18 add %i1, 0x18, %i2 4000670c: 86 07 bf c0 add %fp, -64, %g3 40006710: 84 10 00 1a mov %i2, %g2 40006714: b6 07 bf f8 add %fp, -8, %i3 in[i] = (((UINT4)mdContext->in[ii+3]) << 24) | 40006718: c2 08 a0 03 ldub [ %g2 + 3 ], %g1 (((UINT4)mdContext->in[ii+2]) << 16) | 4000671c: fa 08 a0 02 ldub [ %g2 + 2 ], %i5 ((UINT4)mdContext->in[ii]); 40006720: f8 08 80 00 ldub [ %g2 ], %i4 (((UINT4)mdContext->in[ii+1]) << 8) | 40006724: c8 08 a0 01 ldub [ %g2 + 1 ], %g4 in[i] = (((UINT4)mdContext->in[ii+3]) << 24) | 40006728: 83 28 60 18 sll %g1, 0x18, %g1 (((UINT4)mdContext->in[ii+2]) << 16) | 4000672c: bb 2f 60 10 sll %i5, 0x10, %i5 (((UINT4)mdContext->in[ii+1]) << 8) | 40006730: 89 29 20 08 sll %g4, 8, %g4 in[i] = (((UINT4)mdContext->in[ii+3]) << 24) | 40006734: 82 10 40 1d or %g1, %i5, %g1 (((UINT4)mdContext->in[ii+1]) << 8) | 40006738: 82 10 40 1c or %g1, %i4, %g1 4000673c: 82 10 40 04 or %g1, %g4, %g1 in[i] = (((UINT4)mdContext->in[ii+3]) << 24) | 40006740: c2 20 c0 00 st %g1, [ %g3 ] for (i = 0, ii = 0; i < 14; i++, ii += 4) 40006744: 86 00 e0 04 add %g3, 4, %g3 40006748: 80 a6 c0 03 cmp %i3, %g3 4000674c: 12 bf ff f3 bne 40006718 40006750: 84 00 a0 04 add %g2, 4, %g2 Transform (mdContext->buf, in); 40006754: 90 06 60 08 add %i1, 8, %o0 40006758: 92 07 bf c0 add %fp, -64, %o1 4000675c: 7f ff fc 58 call 400058bc 40006760: ba 10 00 08 mov %o0, %i5 for (i = 0, ii = 0; i < 4; i++, ii += 4) { 40006764: 90 10 00 1d mov %i5, %o0 mdContext->digest[ii] = (unsigned char)(mdContext->buf[i] & 0xFF); 40006768: c2 02 00 00 ld [ %o0 ], %g1 4000676c: c2 2a 20 50 stb %g1, [ %o0 + 0x50 ] (unsigned char)((mdContext->buf[i] >> 8) & 0xFF); 40006770: 87 30 60 08 srl %g1, 8, %g3 (unsigned char)((mdContext->buf[i] >> 16) & 0xFF); 40006774: 85 30 60 10 srl %g1, 0x10, %g2 (unsigned char)((mdContext->buf[i] >> 8) & 0xFF); 40006778: c6 2a 20 51 stb %g3, [ %o0 + 0x51 ] (unsigned char)((mdContext->buf[i] >> 24) & 0xFF); 4000677c: 83 30 60 18 srl %g1, 0x18, %g1 (unsigned char)((mdContext->buf[i] >> 16) & 0xFF); 40006780: c4 2a 20 52 stb %g2, [ %o0 + 0x52 ] for (i = 0, ii = 0; i < 4; i++, ii += 4) { 40006784: 90 02 20 04 add %o0, 4, %o0 40006788: 80 a6 80 08 cmp %i2, %o0 4000678c: 12 bf ff f7 bne 40006768 40006790: c2 2a 20 4f stb %g1, [ %o0 + 0x4f ] memcpy(hash, mdContext->digest, 16); 40006794: b4 10 20 10 mov 0x10, %i2 40006798: 40 00 4e d4 call 4001a2e8 4000679c: 93 ee 60 58 restore %i1, 0x58, %o1 padLen = (mdi < 56) ? (56 - mdi) : (120 - mdi); 400067a0: 82 10 20 78 mov 0x78, %g1 <== NOT EXECUTED 400067a4: 10 bf ff d5 b 400066f8 <== NOT EXECUTED 400067a8: 94 20 40 0a sub %g1, %o2, %o2 <== NOT EXECUTED =============================================================================== 400065fc : { 400065fc: 9d e3 bf 60 save %sp, -160, %sp mdi = (int)((mdContext->i[0] >> 3) & 0x3F); 40006600: c2 06 00 00 ld [ %i0 ], %g1 mdContext->i[1]++; 40006604: c6 06 20 04 ld [ %i0 + 4 ], %g3 if ((mdContext->i[0] + ((UINT4)inLen << 3)) < mdContext->i[0]) 40006608: 85 2e a0 03 sll %i2, 3, %g2 mdContext->i[1] += ((UINT4)inLen >> 29); 4000660c: 89 36 a0 1d srl %i2, 0x1d, %g4 40006610: 84 80 40 02 addcc %g1, %g2, %g2 40006614: 86 40 c0 04 addx %g3, %g4, %g3 mdContext->i[0] += ((UINT4)inLen << 3); 40006618: c4 26 00 00 st %g2, [ %i0 ] mdi = (int)((mdContext->i[0] >> 3) & 0x3F); 4000661c: 83 30 60 03 srl %g1, 3, %g1 mdContext->i[1] += ((UINT4)inLen >> 29); 40006620: c6 26 20 04 st %g3, [ %i0 + 4 ] 40006624: a0 06 40 1a add %i1, %i2, %l0 mdi = (int)((mdContext->i[0] >> 3) & 0x3F); 40006628: 82 08 60 3f and %g1, 0x3f, %g1 while (inLen--) { 4000662c: b6 10 00 1e mov %fp, %i3 40006630: 80 a6 a0 00 cmp %i2, 0 40006634: 12 80 00 06 bne 4000664c <== ALWAYS TAKEN 40006638: a2 06 20 08 add %i0, 8, %l1 4000663c: 30 80 00 22 b,a 400066c4 <== NOT EXECUTED 40006640: 80 a6 40 10 cmp %i1, %l0 40006644: 02 80 00 20 be 400066c4 40006648: 01 00 00 00 nop mdContext->in[mdi++] = *inBuf++; 4000664c: c6 0e 40 00 ldub [ %i1 ], %g3 40006650: 84 06 00 01 add %i0, %g1, %g2 40006654: c6 28 a0 18 stb %g3, [ %g2 + 0x18 ] 40006658: 82 00 60 01 inc %g1 if (mdi == 0x40) { 4000665c: 80 a0 60 40 cmp %g1, 0x40 40006660: 12 bf ff f8 bne 40006640 40006664: b2 06 60 01 inc %i1 40006668: 84 06 20 18 add %i0, 0x18, %g2 4000666c: 86 07 bf c0 add %fp, -64, %g3 in[i] = (((UINT4)mdContext->in[ii+3]) << 24) | 40006670: c2 08 a0 03 ldub [ %g2 + 3 ], %g1 (((UINT4)mdContext->in[ii+2]) << 16) | 40006674: fa 08 a0 02 ldub [ %g2 + 2 ], %i5 ((UINT4)mdContext->in[ii]); 40006678: f8 08 80 00 ldub [ %g2 ], %i4 (((UINT4)mdContext->in[ii+1]) << 8) | 4000667c: c8 08 a0 01 ldub [ %g2 + 1 ], %g4 in[i] = (((UINT4)mdContext->in[ii+3]) << 24) | 40006680: 83 28 60 18 sll %g1, 0x18, %g1 (((UINT4)mdContext->in[ii+2]) << 16) | 40006684: bb 2f 60 10 sll %i5, 0x10, %i5 (((UINT4)mdContext->in[ii+1]) << 8) | 40006688: 89 29 20 08 sll %g4, 8, %g4 in[i] = (((UINT4)mdContext->in[ii+3]) << 24) | 4000668c: 82 10 40 1d or %g1, %i5, %g1 (((UINT4)mdContext->in[ii+1]) << 8) | 40006690: 82 10 40 1c or %g1, %i4, %g1 40006694: 82 10 40 04 or %g1, %g4, %g1 in[i] = (((UINT4)mdContext->in[ii+3]) << 24) | 40006698: c2 20 c0 00 st %g1, [ %g3 ] for (i = 0, ii = 0; i < 16; i++, ii += 4) 4000669c: 86 00 e0 04 add %g3, 4, %g3 400066a0: 80 a6 c0 03 cmp %i3, %g3 400066a4: 12 bf ff f3 bne 40006670 400066a8: 84 00 a0 04 add %g2, 4, %g2 Transform (mdContext->buf, in); 400066ac: 92 07 bf c0 add %fp, -64, %o1 400066b0: 7f ff fc 83 call 400058bc 400066b4: 90 10 00 11 mov %l1, %o0 while (inLen--) { 400066b8: 80 a6 40 10 cmp %i1, %l0 400066bc: 12 bf ff e4 bne 4000664c 400066c0: 82 10 20 00 clr %g1 } 400066c4: 81 c7 e0 08 ret 400066c8: 81 e8 00 00 restore =============================================================================== 4000902c : /* Add bytes into the hash */ void SHA256_Update(SHA256_CTX * ctx, const void *in, size_t len) { 4000902c: 9d e3 bf a0 save %sp, -96, %sp 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; 40009030: c4 1e 20 20 ldd [ %i0 + 0x20 ], %g2 /* Convert the length into a number of bits */ bitlen = len << 3; 40009034: 83 2e a0 03 sll %i2, 3, %g1 /* Update number of bits */ ctx->count += bitlen; 40009038: 9a 80 c0 01 addcc %g3, %g1, %o5 4000903c: 98 40 a0 00 addx %g2, 0, %o4 40009040: d8 3e 20 20 std %o4, [ %i0 + 0x20 ] r = (ctx->count >> 3) & 0x3f; 40009044: b7 30 e0 03 srl %g3, 3, %i3 /* Handle the case where we don't need to perform any transforms */ if (len < 64 - r) { 40009048: ba 10 20 40 mov 0x40, %i5 r = (ctx->count >> 3) & 0x3f; 4000904c: b6 0e e0 3f and %i3, 0x3f, %i3 { 40009050: b8 10 00 18 mov %i0, %i4 if (len < 64 - r) { 40009054: ba 27 40 1b sub %i5, %i3, %i5 memcpy(&ctx->buf[r], src, len); 40009058: 90 06 e0 28 add %i3, 0x28, %o0 if (len < 64 - r) { 4000905c: 80 a7 40 1a cmp %i5, %i2 40009060: 18 80 00 1c bgu 400090d0 40009064: 90 06 00 08 add %i0, %o0, %o0 return; } /* Finish the current block */ memcpy(&ctx->buf[r], src, 64 - r); 40009068: 94 10 00 1d mov %i5, %o2 4000906c: 40 00 44 9f call 4001a2e8 40009070: 92 10 00 19 mov %i1, %o1 SHA256_Transform(ctx->state, ctx->buf); 40009074: b0 06 20 28 add %i0, 0x28, %i0 40009078: 90 10 00 1c mov %i4, %o0 4000907c: 7f ff f5 cc call 400067ac 40009080: 92 10 00 18 mov %i0, %o1 src += 64 - r; 40009084: b4 06 bf c0 add %i2, -64, %i2 len -= 64 - r; 40009088: b4 06 80 1b add %i2, %i3, %i2 /* Perform complete blocks */ while (len >= 64) { 4000908c: 80 a6 a0 3f cmp %i2, 0x3f 40009090: 08 80 00 12 bleu 400090d8 40009094: ba 06 40 1d add %i1, %i5, %i5 40009098: b2 06 bf c0 add %i2, -64, %i1 4000909c: b2 0e 7f c0 and %i1, -64, %i1 400090a0: b2 06 60 40 add %i1, 0x40, %i1 400090a4: b2 07 40 19 add %i5, %i1, %i1 SHA256_Transform(ctx->state, src); 400090a8: 92 10 00 1d mov %i5, %o1 400090ac: 7f ff f5 c0 call 400067ac 400090b0: 90 10 00 1c mov %i4, %o0 src += 64; 400090b4: ba 07 60 40 add %i5, 0x40, %i5 while (len >= 64) { 400090b8: 80 a7 40 19 cmp %i5, %i1 400090bc: 12 bf ff fc bne 400090ac <== NEVER TAKEN 400090c0: 92 10 00 1d mov %i5, %o1 len -= 64; 400090c4: b4 0e a0 3f and %i2, 0x3f, %i2 } /* Copy left over data into buffer */ memcpy(ctx->buf, src, len); 400090c8: 40 00 44 88 call 4001a2e8 400090cc: 81 e8 00 00 restore memcpy(&ctx->buf[r], src, len); 400090d0: 40 00 44 86 call 4001a2e8 400090d4: 91 e8 00 08 restore %g0, %o0, %o0 memcpy(ctx->buf, src, len); 400090d8: 40 00 44 84 call 4001a2e8 400090dc: 93 e8 00 1d restore %g0, %i5, %o1 =============================================================================== 40010900 : * 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) { 40010900: 9d e3 bf 90 save %sp, -112, %sp be64enc_vect(len, ctx->count, 16); 40010904: 94 10 20 10 mov 0x10, %o2 40010908: 92 06 60 40 add %i1, 0x40, %o1 4001090c: 40 00 26 77 call 4001a2e8 40010910: 90 07 bf f0 add %fp, -16, %o0 r = (ctx->count[1] >> 3) & 0x7f; 40010914: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 40010918: 83 30 60 03 srl %g1, 3, %g1 4001091c: 84 10 20 00 clr %g2 { 40010920: ba 10 00 19 mov %i1, %i5 plen = (r < 112) ? (112 - r) : (240 - r); 40010924: 80 a0 a0 00 cmp %g2, 0 40010928: 12 80 00 18 bne 40010988 <== NEVER TAKEN 4001092c: 86 08 60 7f and %g1, 0x7f, %g3 40010930: 80 a0 e0 6f cmp %g3, 0x6f 40010934: 18 80 00 16 bgu 4001098c 40010938: 9a 10 20 f0 mov 0xf0, %o5 4001093c: 9a 10 20 70 mov 0x70, %o5 40010940: b6 a3 40 03 subcc %o5, %g3, %i3 SHA512_Update(ctx, PAD, (size_t)plen); 40010944: 94 10 00 1b mov %i3, %o2 40010948: 90 10 00 1d mov %i5, %o0 4001094c: 13 10 00 87 sethi %hi(0x40021c00), %o1 40010950: 7f ff ff af call 4001080c 40010954: 92 12 63 20 or %o1, 0x320, %o1 ! 40021f20 SHA512_Update(ctx, len, 16); 40010958: 94 10 20 10 mov 0x10, %o2 4001095c: 92 07 bf f0 add %fp, -16, %o1 40010960: 7f ff ff ab call 4001080c 40010964: 90 10 00 1d mov %i5, %o0 /* Add padding */ SHA512_Pad(ctx); /* Write the hash */ be64enc_vect(digest, ctx->state, 64); 40010968: 90 10 00 18 mov %i0, %o0 4001096c: 94 10 20 40 mov 0x40, %o2 40010970: 92 10 00 1d mov %i5, %o1 40010974: 40 00 26 5d call 4001a2e8 40010978: b4 10 20 d0 mov 0xd0, %i2 /* Clear the context state */ memset((void *)ctx, 0, sizeof(*ctx)); 4001097c: b2 10 20 00 clr %i1 40010980: 40 00 26 99 call 4001a3e4 40010984: 91 e8 00 1d restore %g0, %i5, %o0 plen = (r < 112) ? (112 - r) : (240 - r); 40010988: 9a 10 20 f0 mov 0xf0, %o5 <== NOT EXECUTED 4001098c: 10 bf ff ee b 40010944 40010990: b6 a3 40 03 subcc %o5, %g3, %i3 =============================================================================== 4001080c : /* Add bytes into the hash */ void SHA512_Update(SHA512_CTX * ctx, const void *in, size_t len) { 4001080c: 9d e3 bf a0 save %sp, -96, %sp 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; 40010810: c4 1e 20 48 ldd [ %i0 + 0x48 ], %g2 /* Convert the length into a number of bits */ bitlen[1] = ((uint64_t)len) << 3; 40010814: 99 36 a0 1d srl %i2, 0x1d, %o4 40010818: 9b 2e a0 03 sll %i2, 3, %o5 4001081c: 96 80 c0 0d addcc %g3, %o5, %o3 40010820: 94 c0 80 0c addxcc %g2, %o4, %o2 bitlen[0] = ((uint64_t)len) >> 61; /* Update number of bits */ if ((ctx->count[1] += bitlen[1]) < bitlen[1]) 40010824: d4 3e 20 48 std %o2, [ %i0 + 0x48 ] r = (ctx->count[1] >> 3) & 0x7f; 40010828: 83 30 e0 03 srl %g3, 3, %g1 { 4001082c: b8 10 00 18 mov %i0, %i4 r = (ctx->count[1] >> 3) & 0x7f; 40010830: 84 10 20 00 clr %g2 if ((ctx->count[1] += bitlen[1]) < bitlen[1]) 40010834: 1a 80 00 06 bcc 4001084c <== ALWAYS TAKEN 40010838: 86 08 60 7f and %g1, 0x7f, %g3 ctx->count[0]++; 4001083c: d8 1e 20 40 ldd [ %i0 + 0x40 ], %o4 <== NOT EXECUTED 40010840: 96 83 60 01 addcc %o5, 1, %o3 <== NOT EXECUTED 40010844: 94 43 20 00 addx %o4, 0, %o2 <== NOT EXECUTED 40010848: d4 3e 20 40 std %o2, [ %i0 + 0x40 ] <== NOT EXECUTED ctx->count[0] += bitlen[0]; /* Handle the case where we don't need to perform any transforms */ if (len < 128 - r) { 4001084c: 96 10 20 80 mov 0x80, %o3 40010850: 9a a2 c0 03 subcc %o3, %g3, %o5 memcpy(&ctx->buf[r], src, len); 40010854: 90 00 e0 50 add %g3, 0x50, %o0 if (len < 128 - r) { 40010858: 94 10 20 00 clr %o2 4001085c: b6 10 00 03 mov %g3, %i3 40010860: 98 62 80 02 subx %o2, %g2, %o4 40010864: 80 a3 20 00 cmp %o4, 0 40010868: 18 80 00 22 bgu 400108f0 <== NEVER TAKEN 4001086c: 90 07 00 08 add %i4, %o0, %o0 40010870: 02 80 00 1e be 400108e8 <== ALWAYS TAKEN 40010874: 80 a3 40 1a cmp %o5, %i2 return; } /* Finish the current block */ memcpy(&ctx->buf[r], src, 128 - r); 40010878: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4001087c: ba 10 20 80 mov 0x80, %i5 40010880: ba 27 40 1b sub %i5, %i3, %i5 40010884: 40 00 26 99 call 4001a2e8 40010888: 94 10 00 1d mov %i5, %o2 SHA512_Transform(ctx->state, ctx->buf); 4001088c: b0 07 20 50 add %i4, 0x50, %i0 40010890: 90 10 00 1c mov %i4, %o0 40010894: 7f ff e2 3e call 4000918c 40010898: 92 10 00 18 mov %i0, %o1 src += 128 - r; 4001089c: b4 06 bf 80 add %i2, -128, %i2 len -= 128 - r; 400108a0: b4 06 c0 1a add %i3, %i2, %i2 /* Perform complete blocks */ while (len >= 128) { 400108a4: 80 a6 a0 7f cmp %i2, 0x7f 400108a8: 08 80 00 14 bleu 400108f8 <== ALWAYS TAKEN 400108ac: ba 06 40 1d add %i1, %i5, %i5 400108b0: b2 06 bf 80 add %i2, -128, %i1 <== NOT EXECUTED 400108b4: b2 0e 7f 80 and %i1, -128, %i1 <== NOT EXECUTED 400108b8: b2 06 60 80 add %i1, 0x80, %i1 <== NOT EXECUTED 400108bc: b2 07 40 19 add %i5, %i1, %i1 <== NOT EXECUTED SHA512_Transform(ctx->state, src); 400108c0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 400108c4: 7f ff e2 32 call 4000918c <== NOT EXECUTED 400108c8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED src += 128; 400108cc: ba 07 60 80 add %i5, 0x80, %i5 <== NOT EXECUTED while (len >= 128) { 400108d0: 80 a7 40 19 cmp %i5, %i1 <== NOT EXECUTED 400108d4: 12 bf ff fc bne 400108c4 <== NOT EXECUTED 400108d8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED len -= 128; 400108dc: b4 0e a0 7f and %i2, 0x7f, %i2 <== NOT EXECUTED } /* Copy left over data into buffer */ memcpy(ctx->buf, src, len); 400108e0: 40 00 26 82 call 4001a2e8 <== NOT EXECUTED 400108e4: 81 e8 00 00 restore <== NOT EXECUTED if (len < 128 - r) { 400108e8: 08 bf ff e5 bleu 4001087c 400108ec: 92 10 00 19 mov %i1, %o1 memcpy(&ctx->buf[r], src, len); 400108f0: 40 00 26 7e call 4001a2e8 400108f4: 91 e8 00 08 restore %g0, %o0, %o0 memcpy(ctx->buf, src, len); 400108f8: 40 00 26 7c call 4001a2e8 400108fc: 93 e8 00 1d restore %g0, %i5, %o1