0000000040025c50 <MD5Update>:
{
40025c50: a9b97bfd stp x29, x30, [sp, #-112]!
if ((mdContext->i[0] + ((UINT4)inLen << 3)) < mdContext->i[0])
40025c54: 531d7044 lsl w4, w2, #3
mdContext->i[1] += ((UINT4)inLen >> 29);
40025c58: 531d7c45 lsr w5, w2, #29
{
40025c5c: 910003fd mov x29, sp
40025c60: a90153f3 stp x19, x20, [sp, #16]
40025c64: aa0103f3 mov x19, x1
40025c68: a9025bf5 stp x21, x22, [sp, #32]
40025c6c: 8b224036 add x22, x1, w2, uxtw
40025c70: aa0003f5 mov x21, x0
mdContext->i[1]++;
40025c74: 29400403 ldp w3, w1, [x0]
40025c78: 2b040064 adds w4, w3, w4
mdContext->i[1] += ((UINT4)inLen >> 29);
40025c7c: 1a050021 adc w1, w1, w5
40025c80: 29000404 stp w4, w1, [x0]
mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
40025c84: d3432063 ubfx x3, x3, #3, #6
while (inLen--) {
40025c88: 340003c2 cbz w2, 40025d00 <MD5Update+0xb0> <== NEVER TAKEN
40025c8c: 91002000 add x0, x0, #0x8
40025c90: 9101c3f4 add x20, sp, #0x70
40025c94: 14000003 b 40025ca0 <MD5Update+0x50>
40025c98: eb16027f cmp x19, x22
40025c9c: 54000320 b.eq 40025d00 <MD5Update+0xb0> // b.none
mdContext->in[mdi++] = *inBuf++;
40025ca0: 8b23c2a1 add x1, x21, w3, sxtw
40025ca4: 38401662 ldrb w2, [x19], #1
40025ca8: 11000463 add w3, w3, #0x1
if (mdi == 0x40) {
40025cac: 7101007f cmp w3, #0x40
mdContext->in[mdi++] = *inBuf++;
40025cb0: 39006022 strb w2, [x1, #24]
if (mdi == 0x40) {
40025cb4: 54ffff21 b.ne 40025c98 <MD5Update+0x48> // b.any
40025cb8: 910062a3 add x3, x21, #0x18
40025cbc: 9100c3e6 add x6, sp, #0x30
(((UINT4)mdContext->in[ii+2]) << 16) |
40025cc0: 39400865 ldrb w5, [x3, #2]
in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
40025cc4: 39400c62 ldrb w2, [x3, #3]
(((UINT4)mdContext->in[ii+1]) << 8) |
40025cc8: 39400464 ldrb w4, [x3, #1]
((UINT4)mdContext->in[ii]);
40025ccc: 38404467 ldrb w7, [x3], #4
(((UINT4)mdContext->in[ii+2]) << 16) |
40025cd0: 53103ca5 lsl w5, w5, #16
(((UINT4)mdContext->in[ii+1]) << 8) |
40025cd4: 2a0260a2 orr w2, w5, w2, lsl #24
40025cd8: 2a0420e4 orr w4, w7, w4, lsl #8
40025cdc: 2a040042 orr w2, w2, w4
in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
40025ce0: b80044c2 str w2, [x6], #4
for (i = 0, ii = 0; i < 16; i++, ii += 4)
40025ce4: eb06029f cmp x20, x6
40025ce8: 54fffec1 b.ne 40025cc0 <MD5Update+0x70> // b.any
Transform (mdContext->buf, in);
40025cec: 9100c3e1 add x1, sp, #0x30
40025cf0: 97fffd50 bl 40025230 <Transform>
while (inLen--) {
40025cf4: eb16027f cmp x19, x22
mdi = 0;
40025cf8: 52800003 mov w3, #0x0 // #0
while (inLen--) {
40025cfc: 54fffd21 b.ne 40025ca0 <MD5Update+0x50> // b.any
}
40025d00: a94153f3 ldp x19, x20, [sp, #16]
40025d04: a9425bf5 ldp x21, x22, [sp, #32]
40025d08: a8c77bfd ldp x29, x30, [sp], #112
40025d0c: d65f03c0 ret
0000000040027650 <SHA256_Update>:
/* Add bytes into the hash */
void
SHA256_Update(SHA256_CTX * ctx, const void *in, size_t len)
{
40027650: a9bc7bfd stp x29, x30, [sp, #-64]!
40027654: 910003fd mov x29, sp
40027658: a90153f3 stp x19, x20, [sp, #16]
4002765c: aa0003f4 mov x20, x0
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;
40027660: f9401000 ldr x0, [x0, #32]
{
40027664: a9025bf5 stp x21, x22, [sp, #32]
/* Update number of bits */
ctx->count += bitlen;
/* Handle the case where we don't need to perform any transforms */
if (len < 64 - r) {
40027668: 52800815 mov w21, #0x40 // #64
r = (ctx->count >> 3) & 0x3f;
4002766c: 53032004 ubfx w4, w0, #3, #6
ctx->count += bitlen;
40027670: 8b020c03 add x3, x0, x2, lsl #3
40027674: f9001283 str x3, [x20, #32]
memcpy(&ctx->buf[r], src, len);
40027678: 1100a080 add w0, w4, #0x28
if (len < 64 - r) {
4002767c: 4b0402b5 sub w21, w21, w4
memcpy(&ctx->buf[r], src, len);
40027680: 8b000280 add x0, x20, x0
if (len < 64 - r) {
40027684: eb0202bf cmp x21, x2
40027688: 540003a8 b.hi 400276fc <SHA256_Update+0xac> // b.pmore
4002768c: aa0203f6 mov x22, x2
return;
}
/* Finish the current block */
memcpy(&ctx->buf[r], src, 64 - r);
40027690: aa1503e2 mov x2, x21
SHA256_Transform(ctx->state, ctx->buf);
src += 64 - r;
40027694: 8b150033 add x19, x1, x21
40027698: f9001bf7 str x23, [sp, #48]
memcpy(&ctx->buf[r], src, 64 - r);
4002769c: 94002ee0 bl 4003321c <memcpy>
SHA256_Transform(ctx->state, ctx->buf);
400276a0: 9100a297 add x23, x20, #0x28
len -= 64 - r;
400276a4: cb1502d6 sub x22, x22, x21
SHA256_Transform(ctx->state, ctx->buf);
400276a8: aa1703e1 mov x1, x23
400276ac: aa1403e0 mov x0, x20
400276b0: 97fff9d0 bl 40025df0 <SHA256_Transform>
/* Perform complete blocks */
while (len >= 64) {
400276b4: f100fedf cmp x22, #0x3f
400276b8: 540002a9 b.ls 4002770c <SHA256_Update+0xbc> // b.plast
400276bc: d10102d5 sub x21, x22, #0x40
400276c0: 927ae6b5 and x21, x21, #0xffffffffffffffc0
400276c4: 910102b5 add x21, x21, #0x40
400276c8: 8b150275 add x21, x19, x21
400276cc: d503201f nop
SHA256_Transform(ctx->state, src);
400276d0: aa1303e1 mov x1, x19
400276d4: aa1403e0 mov x0, x20
src += 64;
400276d8: 91010273 add x19, x19, #0x40
SHA256_Transform(ctx->state, src);
400276dc: 97fff9c5 bl 40025df0 <SHA256_Transform>
while (len >= 64) {
400276e0: eb15027f cmp x19, x21
400276e4: 54ffff61 b.ne 400276d0 <SHA256_Update+0x80> // b.any <== NEVER TAKEN
len -= 64;
400276e8: 924016d6 and x22, x22, #0x3f
}
/* Copy left over data into buffer */
memcpy(ctx->buf, src, len);
400276ec: aa1703e0 mov x0, x23
400276f0: aa1603e2 mov x2, x22
400276f4: f9401bf7 ldr x23, [sp, #48]
400276f8: aa1503e1 mov x1, x21
}
400276fc: a94153f3 ldp x19, x20, [sp, #16]
40027700: a9425bf5 ldp x21, x22, [sp, #32]
40027704: a8c47bfd ldp x29, x30, [sp], #64
memcpy(ctx->buf, src, len);
40027708: 14002ec5 b 4003321c <memcpy>
src += 64 - r;
4002770c: aa1303f5 mov x21, x19
40027710: 17fffff7 b 400276ec <SHA256_Update+0x9c>
...
0000000040029910 <SHA512_Update>:
/* Add bytes into the hash */
void
SHA512_Update(SHA512_CTX * ctx, const void *in, size_t len)
{
40029910: a9bc7bfd stp x29, x30, [sp, #-64]!
/* Number of bytes left in the buffer from previous updates */
r = (ctx->count[1] >> 3) & 0x7f;
/* Convert the length into a number of bits */
bitlen[1] = ((uint64_t)len) << 3;
40029914: d37df044 lsl x4, x2, #3
{
40029918: 910003fd mov x29, sp
4002991c: a90153f3 stp x19, x20, [sp, #16]
40029920: aa0003f4 mov x20, x0
r = (ctx->count[1] >> 3) & 0x7f;
40029924: f9402400 ldr x0, [x0, #72]
{
40029928: a9025bf5 stp x21, x22, [sp, #32]
bitlen[0] = ((uint64_t)len) >> 61;
/* Update number of bits */
if ((ctx->count[1] += bitlen[1]) < bitlen[1])
ctx->count[0]++;
4002992c: f9402283 ldr x3, [x20, #64]
40029930: ab040004 adds x4, x0, x4
{
40029934: a90363f7 stp x23, x24, [sp, #48]
r = (ctx->count[1] >> 3) & 0x7f;
40029938: d3432416 ubfx x22, x0, #3, #7
ctx->count[0]++;
4002993c: 9a833463 cinc x3, x3, cs // cs = hs, nlast
ctx->count[0] += bitlen[0];
40029940: 8b42f463 add x3, x3, x2, lsr #61
if ((ctx->count[1] += bitlen[1]) < bitlen[1])
40029944: a9041283 stp x3, x4, [x20, #64]
/* Handle the case where we don't need to perform any transforms */
if (len < 128 - r) {
memcpy(&ctx->buf[r], src, len);
40029948: 910142c0 add x0, x22, #0x50
if (len < 128 - r) {
4002994c: d2801018 mov x24, #0x80 // #128
40029950: cb160318 sub x24, x24, x22
memcpy(&ctx->buf[r], src, len);
40029954: 8b000280 add x0, x20, x0
if (len < 128 - r) {
40029958: eb02031f cmp x24, x2
4002995c: 540003a8 b.hi 400299d0 <SHA512_Update+0xc0> // b.pmore
40029960: aa0203f5 mov x21, x2
return;
}
/* Finish the current block */
memcpy(&ctx->buf[r], src, 128 - r);
40029964: aa1803e2 mov x2, x24
40029968: aa0103f3 mov x19, x1
SHA512_Transform(ctx->state, ctx->buf);
4002996c: 91014297 add x23, x20, #0x50
memcpy(&ctx->buf[r], src, 128 - r);
40029970: 9400262b bl 4003321c <memcpy>
SHA512_Transform(ctx->state, ctx->buf);
40029974: d10202b5 sub x21, x21, #0x80
40029978: aa1703e1 mov x1, x23
4002997c: aa1403e0 mov x0, x20
src += 128 - r;
len -= 128 - r;
40029980: 8b1602b5 add x21, x21, x22
SHA512_Transform(ctx->state, ctx->buf);
40029984: 97fff79f bl 40027800 <SHA512_Transform>
src += 128 - r;
40029988: 8b180273 add x19, x19, x24
/* Perform complete blocks */
while (len >= 128) {
4002998c: f101febf cmp x21, #0x7f
40029990: 540002a9 b.ls 400299e4 <SHA512_Update+0xd4> // b.plast <== ALWAYS TAKEN
40029994: d10202b6 sub x22, x21, #0x80 <== NOT EXECUTED
40029998: 9279e2d6 and x22, x22, #0xffffffffffffff80 <== NOT EXECUTED
4002999c: 910202d6 add x22, x22, #0x80 <== NOT EXECUTED
400299a0: 8b160276 add x22, x19, x22 <== NOT EXECUTED
400299a4: d503201f nop <== NOT EXECUTED
SHA512_Transform(ctx->state, src);
400299a8: aa1303e1 mov x1, x19 <== NOT EXECUTED
400299ac: aa1403e0 mov x0, x20 <== NOT EXECUTED
src += 128;
400299b0: 91020273 add x19, x19, #0x80 <== NOT EXECUTED
SHA512_Transform(ctx->state, src);
400299b4: 97fff793 bl 40027800 <SHA512_Transform> <== NOT EXECUTED
while (len >= 128) {
400299b8: eb16027f cmp x19, x22 <== NOT EXECUTED
400299bc: 54ffff61 b.ne 400299a8 <SHA512_Update+0x98> // b.any <== NOT EXECUTED
len -= 128;
400299c0: 92401ab5 and x21, x21, #0x7f <== NOT EXECUTED
}
/* Copy left over data into buffer */
memcpy(ctx->buf, src, len);
400299c4: aa1503e2 mov x2, x21
400299c8: aa1603e1 mov x1, x22
400299cc: aa1703e0 mov x0, x23
}
400299d0: a94153f3 ldp x19, x20, [sp, #16]
400299d4: a9425bf5 ldp x21, x22, [sp, #32]
400299d8: a94363f7 ldp x23, x24, [sp, #48]
400299dc: a8c47bfd ldp x29, x30, [sp], #64
memcpy(ctx->buf, src, len);
400299e0: 1400260f b 4003321c <memcpy>
src += 128 - r;
400299e4: aa1303f6 mov x22, x19
400299e8: 17fffff7 b 400299c4 <SHA512_Update+0xb4>
400299ec: 00000000 udf #0