=============================================================================== 0000000040022050 <_crypt_b64_from_24bit>: void b64_from_24bit(uint8_t B2, uint8_t B1, uint8_t B0, int n, int *buflen, char **cp) { 40022050: 12001c42 and w2, w2, #0xff uint32_t w; int i; #if defined(__rtems__) w = ((uint32_t)B2 << 16) | ((uint32_t)B1 << 8) | B0; 40022054: 53181c21 ubfiz w1, w1, #8, #8 40022058: 2a020022 orr w2, w1, w2 4002205c: 53101c00 ubfiz w0, w0, #16, #8 #else w = (B2 << 16) | (B1 << 8) | B0; #endif for (i = 0; i < n; i++) { 40022060: 7100007f cmp w3, #0x0 w = ((uint32_t)B2 << 16) | ((uint32_t)B1 << 8) | B0; 40022064: 2a000042 orr w2, w2, w0 for (i = 0; i < n; i++) { 40022068: 5400028d b.le 400220b8 <_crypt_b64_from_24bit+0x68> <== NEVER TAKEN 4002206c: b00000c8 adrp x8, 4003b000 40022070: 913b6108 add x8, x8, #0xed8 40022074: 52800006 mov w6, #0x0 // #0 **cp = itoa64[w&0x3f]; 40022078: f94000a0 ldr x0, [x5] 4002207c: 14000003 b 40022088 <_crypt_b64_from_24bit+0x38> for (i = 0; i < n; i++) { 40022080: 6b06007f cmp w3, w6 40022084: 540001a0 b.eq 400220b8 <_crypt_b64_from_24bit+0x68> // b.none **cp = itoa64[w&0x3f]; 40022088: 12001441 and w1, w2, #0x3f for (i = 0; i < n; i++) { 4002208c: 110004c6 add w6, w6, #0x1 **cp = itoa64[w&0x3f]; 40022090: 53067c42 lsr w2, w2, #6 40022094: 38614901 ldrb w1, [x8, w1, uxtw] 40022098: 39000001 strb w1, [x0] (*cp)++; 4002209c: f94000a0 ldr x0, [x5] if ((*buflen)-- < 0) 400220a0: b9400081 ldr w1, [x4] (*cp)++; 400220a4: 91000400 add x0, x0, #0x1 400220a8: f90000a0 str x0, [x5] if ((*buflen)-- < 0) 400220ac: 51000427 sub w7, w1, #0x1 400220b0: b9000087 str w7, [x4] 400220b4: 36fffe61 tbz w1, #31, 40022080 <_crypt_b64_from_24bit+0x30> <== ALWAYS TAKEN break; w >>= 6; } } 400220b8: d65f03c0 ret 400220bc: 00000000 udf #0 =============================================================================== 0000000040022010 <_crypt_to64>: "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; void _crypt_to64(char *s, u_long v, int n) { while (--n >= 0) { 40022010: 7100005f cmp w2, #0x0 40022014: 540001ad b.le 40022048 <_crypt_to64+0x38> <== NEVER TAKEN 40022018: 51000442 sub w2, w2, #0x1 4002201c: b00000c4 adrp x4, 4003b000 40022020: 913b6084 add x4, x4, #0xed8 40022024: 91000442 add x2, x2, #0x1 40022028: 8b020002 add x2, x0, x2 4002202c: d503201f nop *s++ = itoa64[v&0x3f]; 40022030: 92401423 and x3, x1, #0x3f v >>= 6; 40022034: d346fc21 lsr x1, x1, #6 *s++ = itoa64[v&0x3f]; 40022038: 38636883 ldrb w3, [x4, x3] 4002203c: 38001403 strb w3, [x0], #1 while (--n >= 0) { 40022040: eb02001f cmp x0, x2 40022044: 54ffff61 b.ne 40022030 <_crypt_to64+0x20> // b.any } } 40022048: d65f03c0 ret 4002204c: 00000000 udf #0 =============================================================================== 0000000040020cf0 : &cf_default }; void crypt_add_format(struct crypt_format *cf) { if (cf->link.sle_next == NULL) 40020cf0: f9400001 ldr x1, [x0] 40020cf4: b4000041 cbz x1, 40020cfc <== ALWAYS TAKEN SLIST_INSERT_HEAD(&cf_head, cf, link); } 40020cf8: d65f03c0 ret <== NOT EXECUTED SLIST_INSERT_HEAD(&cf_head, cf, link); 40020cfc: 90000701 adrp x1, 40100000 <_RTEMS_tasks_Information> 40020d00: f9408022 ldr x2, [x1, #256] 40020d04: f9008020 str x0, [x1, #256] 40020d08: f9000002 str x2, [x0] } 40020d0c: d65f03c0 ret =============================================================================== 0000000040020d90 : * UNIX password */ char * crypt_md5_r(const char *pw, const char *salt, struct crypt_data *data) { 40020d90: a9ac7bfd stp x29, x30, [sp, #-320]! 40020d94: 910003fd mov x29, sp 40020d98: a90153f3 stp x19, x20, [sp, #16] 40020d9c: aa0003f4 mov x20, x0 40020da0: a9025bf5 stp x21, x22, [sp, #32] 40020da4: a90363f7 stp x23, x24, [sp, #48] 40020da8: a9046bf9 stp x25, x26, [sp, #64] 40020dac: aa0103fa mov x26, x1 40020db0: a90573fb stp x27, x28, [sp, #80] 40020db4: aa0203fc mov x28, x2 /* Refine the Salt first */ sp = salt; /* If it starts with the magic string, then skip that */ if(!strncmp(sp, magic, strlen(magic))) 40020db8: 39400020 ldrb w0, [x1] 40020dbc: 7100901f cmp w0, #0x24 40020dc0: 54000081 b.ne 40020dd0 // b.any <== NEVER TAKEN 40020dc4: 39400420 ldrb w0, [x1, #1] 40020dc8: 7100c41f cmp w0, #0x31 40020dcc: 54001dc0 b.eq 40021184 // b.none <== ALWAYS TAKEN sp += strlen(magic); /* It stops at the first '$', max 8 chars */ for(ep = sp; *ep && *ep != '$' && ep < (sp + 8); ep++) 40020dd0: 39400340 ldrb w0, [x26] 40020dd4: 7100901f cmp w0, #0x24 40020dd8: 7a401804 ccmp w0, #0x0, #0x4, ne // ne = any 40020ddc: 54001de0 b.eq 40021198 // b.none <== NEVER TAKEN 40020de0: 91002342 add x2, x26, #0x8 40020de4: aa1a03e0 mov x0, x26 40020de8: 38401c01 ldrb w1, [x0, #1]! 40020dec: 7100903f cmp w1, #0x24 40020df0: 7a401824 ccmp w1, #0x0, #0x4, ne // ne = any 40020df4: 54000060 b.eq 40020e00 // b.none 40020df8: eb02001f cmp x0, x2 40020dfc: 54ffff61 b.ne 40020de8 // b.any <== ALWAYS TAKEN continue; /* get the length of the true salt */ sl = ep - sp; 40020e00: cb1a0000 sub x0, x0, x26 /* Then our magic string */ MD5Update(&ctx, (const u_char *)magic, strlen(magic)); /* Then the raw salt */ MD5Update(&ctx, (const u_char *)sp, (u_int)sl); 40020e04: 2a0003fb mov w27, w0 else MD5Update(&ctx, (const u_char *)pw, 1); /* Now make the output string */ strcpy(passwd, magic); strncat(passwd, sp, (u_int)sl); 40020e08: 92407c15 and x21, x0, #0xffffffff MD5Init(&ctx); 40020e0c: 9101c3e0 add x0, sp, #0x70 40020e10: 94001384 bl 40025c20 MD5Update(&ctx, (const u_char *)pw, strlen(pw)); 40020e14: aa1403e0 mov x0, x20 40020e18: 94004aa2 bl 400338a0 40020e1c: aa1403e1 mov x1, x20 40020e20: 2a0003e2 mov w2, w0 40020e24: 9101c3e0 add x0, sp, #0x70 40020e28: 9400138a bl 40025c50 MD5Update(&ctx, (const u_char *)magic, strlen(magic)); 40020e2c: 9101c3e0 add x0, sp, #0x70 40020e30: 52800062 mov w2, #0x3 // #3 40020e34: f00000c1 adrp x1, 4003b000 40020e38: 913a4021 add x1, x1, #0xe90 40020e3c: 94001385 bl 40025c50 MD5Update(&ctx, (const u_char *)sp, (u_int)sl); 40020e40: 2a1b03e2 mov w2, w27 40020e44: aa1a03e1 mov x1, x26 40020e48: 9101c3e0 add x0, sp, #0x70 40020e4c: 94001381 bl 40025c50 MD5Init(&ctx1); 40020e50: 910363e0 add x0, sp, #0xd8 40020e54: 94001373 bl 40025c20 MD5Update(&ctx1, (const u_char *)pw, strlen(pw)); 40020e58: aa1403e0 mov x0, x20 40020e5c: 94004a91 bl 400338a0 40020e60: aa1403e1 mov x1, x20 40020e64: 2a0003e2 mov w2, w0 40020e68: 910363e0 add x0, sp, #0xd8 40020e6c: 94001379 bl 40025c50 MD5Update(&ctx1, (const u_char *)sp, (u_int)sl); 40020e70: 2a1b03e2 mov w2, w27 40020e74: aa1a03e1 mov x1, x26 40020e78: 910363e0 add x0, sp, #0xd8 40020e7c: 94001375 bl 40025c50 MD5Update(&ctx1, (const u_char *)pw, strlen(pw)); 40020e80: aa1403e0 mov x0, x20 40020e84: 94004a87 bl 400338a0 40020e88: 2a0003e2 mov w2, w0 40020e8c: aa1403e1 mov x1, x20 40020e90: 910363e0 add x0, sp, #0xd8 40020e94: 9400136f bl 40025c50 MD5Final(final, &ctx1); 40020e98: 910363e1 add x1, sp, #0xd8 40020e9c: 910183e0 add x0, sp, #0x60 40020ea0: 9400139c bl 40025d10 for(pl = (int)strlen(pw); pl > 0; pl -= MD5_SIZE) 40020ea4: aa1403e0 mov x0, x20 40020ea8: 94004a7e bl 400338a0 40020eac: 7100001f cmp w0, #0x0 40020eb0: 2a0003f3 mov w19, w0 40020eb4: 540001ed b.le 40020ef0 <== NEVER TAKEN 40020eb8: 51000416 sub w22, w0, #0x1 40020ebc: 51004000 sub w0, w0, #0x10 40020ec0: 121c6ed6 and w22, w22, #0xfffffff0 (u_int)(pl > MD5_SIZE ? MD5_SIZE : pl)); 40020ec4: 52800217 mov w23, #0x10 // #16 40020ec8: 4b160016 sub w22, w0, w22 40020ecc: d503201f nop 40020ed0: 7100427f cmp w19, #0x10 MD5Update(&ctx, (const u_char *)final, 40020ed4: 910183e1 add x1, sp, #0x60 40020ed8: 1a97d262 csel w2, w19, w23, le 40020edc: 9101c3e0 add x0, sp, #0x70 for(pl = (int)strlen(pw); pl > 0; pl -= MD5_SIZE) 40020ee0: 51004273 sub w19, w19, #0x10 MD5Update(&ctx, (const u_char *)final, 40020ee4: 9400135b bl 40025c50 for(pl = (int)strlen(pw); pl > 0; pl -= MD5_SIZE) 40020ee8: 6b16027f cmp w19, w22 40020eec: 54ffff21 b.ne 40020ed0 // b.any <== NEVER TAKEN for (i = strlen(pw); i; i >>= 1) 40020ef0: aa1403e0 mov x0, x20 memset(final, 0, sizeof(final)); 40020ef4: a9067fff stp xzr, xzr, [sp, #96] for (i = strlen(pw); i; i >>= 1) 40020ef8: 94004a6a bl 400338a0 40020efc: 2a0003f3 mov w19, w0 40020f00: 350000e0 cbnz w0, 40020f1c <== ALWAYS TAKEN 40020f04: 1400000d b 40020f38 <== NOT EXECUTED MD5Update(&ctx, (const u_char *)final, 1); 40020f08: 910183e1 add x1, sp, #0x60 40020f0c: 9101c3e0 add x0, sp, #0x70 for (i = strlen(pw); i; i >>= 1) 40020f10: 53017e73 lsr w19, w19, #1 MD5Update(&ctx, (const u_char *)final, 1); 40020f14: 9400134f bl 40025c50 for (i = strlen(pw); i; i >>= 1) 40020f18: 34000113 cbz w19, 40020f38 MD5Update(&ctx, (const u_char *)final, 1); 40020f1c: 52800022 mov w2, #0x1 // #1 if(i & 1) 40020f20: 3707ff53 tbnz w19, #0, 40020f08 MD5Update(&ctx, (const u_char *)pw, 1); 40020f24: aa1403e1 mov x1, x20 40020f28: 9101c3e0 add x0, sp, #0x70 for (i = strlen(pw); i; i >>= 1) 40020f2c: 53017e73 lsr w19, w19, #1 MD5Update(&ctx, (const u_char *)pw, 1); 40020f30: 94001348 bl 40025c50 for (i = strlen(pw); i; i >>= 1) 40020f34: 35ffff53 cbnz w19, 40020f1c <== ALWAYS TAKEN strncat(passwd, sp, (u_int)sl); 40020f38: aa1503e2 mov x2, x21 strcpy(passwd, magic); 40020f3c: 52800623 mov w3, #0x31 // #49 strncat(passwd, sp, (u_int)sl); 40020f40: aa1a03e1 mov x1, x26 strcpy(passwd, magic); 40020f44: 52800495 mov w21, #0x24 // #36 40020f48: 39000395 strb w21, [x28] strncat(passwd, sp, (u_int)sl); 40020f4c: aa1c03e0 mov x0, x28 strcpy(passwd, magic); 40020f50: 39000783 strb w3, [x28, #1] for(i = 0; i < 1000; i++) { MD5Init(&ctx1); if(i & 1) MD5Update(&ctx1, (const u_char *)pw, strlen(pw)); else MD5Update(&ctx1, (const u_char *)final, MD5_SIZE); 40020f54: 52955579 mov w25, #0xaaab // #43691 40020f58: 72b55559 movk w25, #0xaaaa, lsl #16 strcpy(passwd, magic); 40020f5c: 39000b95 strb w21, [x28, #2] 40020f60: 39000f9f strb wzr, [x28, #3] if(i % 3) MD5Update(&ctx1, (const u_char *)sp, (u_int)sl); 40020f64: 528db6f7 mov w23, #0x6db7 // #28087 40020f68: 72b6db77 movk w23, #0xb6db, lsl #16 if(i % 7) 40020f6c: 52892496 mov w22, #0x4924 // #18724 40020f70: 72a49256 movk w22, #0x2492, lsl #16 strncat(passwd, sp, (u_int)sl); 40020f74: 94004a5c bl 400338e4 strcat(passwd, "$"); 40020f78: aa1c03e0 mov x0, x28 40020f7c: 94004a49 bl 400338a0 40020f80: aa0003e2 mov x2, x0 40020f84: 8b000383 add x3, x28, x0 MD5Final(final, &ctx); 40020f88: 9101c3e1 add x1, sp, #0x70 40020f8c: 910183e0 add x0, sp, #0x60 for(i = 0; i < 1000; i++) { 40020f90: 52800013 mov w19, #0x0 // #0 if(i % 3) 40020f94: 3200f3f8 mov w24, #0x55555555 // #1431655765 strcat(passwd, "$"); 40020f98: 38226b95 strb w21, [x28, x2] 40020f9c: 3900047f strb wzr, [x3, #1] MD5Final(final, &ctx); 40020fa0: 9400135c bl 40025d10 for(i = 0; i < 1000; i++) { 40020fa4: d503201f nop MD5Init(&ctx1); 40020fa8: 910363e0 add x0, sp, #0xd8 if(i & 1) 40020fac: 12000275 and w21, w19, #0x1 MD5Init(&ctx1); 40020fb0: 9400131c bl 40025c20 if(i & 1) 40020fb4: 36000d13 tbz w19, #0, 40021154 MD5Update(&ctx1, (const u_char *)pw, strlen(pw)); 40020fb8: aa1403e0 mov x0, x20 40020fbc: 94004a39 bl 400338a0 40020fc0: aa1403e1 mov x1, x20 40020fc4: 2a0003e2 mov w2, w0 40020fc8: 910363e0 add x0, sp, #0xd8 40020fcc: 94001321 bl 40025c50 MD5Update(&ctx1, (const u_char *)final, MD5_SIZE); 40020fd0: 1b197e60 mul w0, w19, w25 if(i % 3) 40020fd4: 6b18001f cmp w0, w24 40020fd8: 54000cc8 b.hi 40021170 // b.pmore MD5Update(&ctx1, (const u_char *)sp, (u_int)sl); 40020fdc: 1b177e60 mul w0, w19, w23 if(i % 7) 40020fe0: 6b16001f cmp w0, w22 40020fe4: 540009c8 b.hi 4002111c // b.pmore MD5Update(&ctx1, (const u_char *)pw, strlen(pw)); if(i & 1) 40020fe8: 34000a95 cbz w21, 40021138 MD5Update(&ctx1, (const u_char *)final, MD5_SIZE); 40020fec: 910183e1 add x1, sp, #0x60 40020ff0: 910363e0 add x0, sp, #0xd8 40020ff4: 52800202 mov w2, #0x10 // #16 40020ff8: 94001316 bl 40025c50 for(i = 0; i < 1000; i++) { 40020ffc: 11000673 add w19, w19, #0x1 else MD5Update(&ctx1, (const u_char *)pw, strlen(pw)); MD5Final(final, &ctx1); 40021000: 910363e1 add x1, sp, #0xd8 40021004: 910183e0 add x0, sp, #0x60 40021008: 94001342 bl 40025d10 for(i = 0; i < 1000; i++) { 4002100c: 710fa27f cmp w19, #0x3e8 40021010: 54fffcc1 b.ne 40020fa8 // b.any } p = passwd + strlen(passwd); 40021014: aa1c03e0 mov x0, x28 40021018: 94004a22 bl 400338a0 l = (final[ 0]<<16) | (final[ 6]<<8) | final[12]; 4002101c: 39419be3 ldrb w3, [sp, #102] p = passwd + strlen(passwd); 40021020: 8b000393 add x19, x28, x0 l = (final[ 0]<<16) | (final[ 6]<<8) | final[12]; 40021024: 394183e1 ldrb w1, [sp, #96] _crypt_to64(p, l, 4); p += 4; 40021028: aa1303e0 mov x0, x19 l = (final[ 0]<<16) | (final[ 6]<<8) | final[12]; 4002102c: 3941b3e4 ldrb w4, [sp, #108] _crypt_to64(p, l, 4); p += 4; 40021030: 52800082 mov w2, #0x4 // #4 l = (final[ 0]<<16) | (final[ 6]<<8) | final[12]; 40021034: 53185c63 lsl w3, w3, #8 40021038: 2a014061 orr w1, w3, w1, lsl #16 4002103c: 2a040021 orr w1, w1, w4 _crypt_to64(p, l, 4); p += 4; 40021040: 92405c21 and x1, x1, #0xffffff 40021044: 940003f3 bl 40022010 <_crypt_to64> l = (final[ 1]<<16) | (final[ 7]<<8) | final[13]; 40021048: 39419fe3 ldrb w3, [sp, #103] _crypt_to64(p, l, 4); p += 4; 4002104c: 91001260 add x0, x19, #0x4 l = (final[ 1]<<16) | (final[ 7]<<8) | final[13]; 40021050: 394187e1 ldrb w1, [sp, #97] _crypt_to64(p, l, 4); p += 4; 40021054: 52800082 mov w2, #0x4 // #4 l = (final[ 1]<<16) | (final[ 7]<<8) | final[13]; 40021058: 3941b7e4 ldrb w4, [sp, #109] 4002105c: 53185c63 lsl w3, w3, #8 40021060: 2a014061 orr w1, w3, w1, lsl #16 40021064: 2a040021 orr w1, w1, w4 _crypt_to64(p, l, 4); p += 4; 40021068: 92405c21 and x1, x1, #0xffffff 4002106c: 940003e9 bl 40022010 <_crypt_to64> l = (final[ 2]<<16) | (final[ 8]<<8) | final[14]; 40021070: 3941a3e3 ldrb w3, [sp, #104] _crypt_to64(p, l, 4); p += 4; 40021074: 91002260 add x0, x19, #0x8 l = (final[ 2]<<16) | (final[ 8]<<8) | final[14]; 40021078: 39418be1 ldrb w1, [sp, #98] _crypt_to64(p, l, 4); p += 4; 4002107c: 52800082 mov w2, #0x4 // #4 l = (final[ 2]<<16) | (final[ 8]<<8) | final[14]; 40021080: 3941bbe4 ldrb w4, [sp, #110] 40021084: 53185c63 lsl w3, w3, #8 40021088: 2a014061 orr w1, w3, w1, lsl #16 4002108c: 2a040021 orr w1, w1, w4 _crypt_to64(p, l, 4); p += 4; 40021090: 92405c21 and x1, x1, #0xffffff 40021094: 940003df bl 40022010 <_crypt_to64> l = (final[ 3]<<16) | (final[ 9]<<8) | final[15]; 40021098: 3941a7e3 ldrb w3, [sp, #105] _crypt_to64(p, l, 4); p += 4; 4002109c: 91003260 add x0, x19, #0xc l = (final[ 3]<<16) | (final[ 9]<<8) | final[15]; 400210a0: 39418fe1 ldrb w1, [sp, #99] _crypt_to64(p, l, 4); p += 4; 400210a4: 52800082 mov w2, #0x4 // #4 l = (final[ 3]<<16) | (final[ 9]<<8) | final[15]; 400210a8: 3941bfe4 ldrb w4, [sp, #111] 400210ac: 53185c63 lsl w3, w3, #8 400210b0: 2a014061 orr w1, w3, w1, lsl #16 400210b4: 2a040021 orr w1, w1, w4 _crypt_to64(p, l, 4); p += 4; 400210b8: 92405c21 and x1, x1, #0xffffff 400210bc: 940003d5 bl 40022010 <_crypt_to64> l = (final[ 4]<<16) | (final[10]<<8) | final[ 5]; 400210c0: 3941abe3 ldrb w3, [sp, #106] _crypt_to64(p, l, 4); p += 4; 400210c4: 91004260 add x0, x19, #0x10 l = (final[ 4]<<16) | (final[10]<<8) | final[ 5]; 400210c8: 394193e1 ldrb w1, [sp, #100] _crypt_to64(p, l, 4); p += 4; 400210cc: 52800082 mov w2, #0x4 // #4 l = (final[ 4]<<16) | (final[10]<<8) | final[ 5]; 400210d0: 394197e4 ldrb w4, [sp, #101] 400210d4: 53185c63 lsl w3, w3, #8 400210d8: 2a014061 orr w1, w3, w1, lsl #16 400210dc: 2a040021 orr w1, w1, w4 _crypt_to64(p, l, 4); p += 4; 400210e0: 92405c21 and x1, x1, #0xffffff 400210e4: 940003cb bl 40022010 <_crypt_to64> l = final[11]; _crypt_to64(p, l, 2); p += 2; 400210e8: 3941afe1 ldrb w1, [sp, #107] 400210ec: 91005260 add x0, x19, #0x14 400210f0: 52800042 mov w2, #0x2 // #2 400210f4: 940003c7 bl 40022010 <_crypt_to64> *p = '\0'; 400210f8: 39005a7f strb wzr, [x19, #22] /* Don't leave anything around in vm they could use. */ memset(final, 0, sizeof(final)); return (passwd); } 400210fc: aa1c03e0 mov x0, x28 40021100: a94153f3 ldp x19, x20, [sp, #16] 40021104: a9425bf5 ldp x21, x22, [sp, #32] 40021108: a94363f7 ldp x23, x24, [sp, #48] 4002110c: a9446bf9 ldp x25, x26, [sp, #64] 40021110: a94573fb ldp x27, x28, [sp, #80] 40021114: a8d47bfd ldp x29, x30, [sp], #320 40021118: d65f03c0 ret MD5Update(&ctx1, (const u_char *)pw, strlen(pw)); 4002111c: aa1403e0 mov x0, x20 40021120: 940049e0 bl 400338a0 40021124: aa1403e1 mov x1, x20 40021128: 2a0003e2 mov w2, w0 4002112c: 910363e0 add x0, sp, #0xd8 40021130: 940012c8 bl 40025c50 if(i & 1) 40021134: 35fff5d5 cbnz w21, 40020fec MD5Update(&ctx1, (const u_char *)pw, strlen(pw)); 40021138: aa1403e0 mov x0, x20 4002113c: 940049d9 bl 400338a0 40021140: aa1403e1 mov x1, x20 40021144: 2a0003e2 mov w2, w0 40021148: 910363e0 add x0, sp, #0xd8 4002114c: 940012c1 bl 40025c50 40021150: 17ffffab b 40020ffc MD5Update(&ctx1, (const u_char *)final, MD5_SIZE); 40021154: 910363e0 add x0, sp, #0xd8 40021158: 910183e1 add x1, sp, #0x60 4002115c: 52800202 mov w2, #0x10 // #16 40021160: 940012bc bl 40025c50 40021164: 1b197e60 mul w0, w19, w25 if(i % 3) 40021168: 6b18001f cmp w0, w24 4002116c: 54fff389 b.ls 40020fdc // b.plast MD5Update(&ctx1, (const u_char *)sp, (u_int)sl); 40021170: 2a1b03e2 mov w2, w27 40021174: aa1a03e1 mov x1, x26 40021178: 910363e0 add x0, sp, #0xd8 4002117c: 940012b5 bl 40025c50 40021180: 17ffff97 b 40020fdc if(!strncmp(sp, magic, strlen(magic))) 40021184: 39400821 ldrb w1, [x1, #2] sp += strlen(magic); 40021188: 91000f40 add x0, x26, #0x3 4002118c: 7100903f cmp w1, #0x24 40021190: 9a9a001a csel x26, x0, x26, eq // eq = none 40021194: 17ffff0f b 40020dd0 for(ep = sp; *ep && *ep != '$' && ep < (sp + 8); ep++) 40021198: d2800015 mov x21, #0x0 // #0 <== NOT EXECUTED 4002119c: 5280001b mov w27, #0x0 // #0 <== NOT EXECUTED 400211a0: 17ffff1b b 40020e0c <== NOT EXECUTED ... =============================================================================== 0000000040020d10 : char * crypt_r(const char *passwd, const char *salt, struct crypt_data *data) { 40020d10: a9bc7bfd stp x29, x30, [sp, #-64]! 40020d14: 910003fd mov x29, sp 40020d18: f9001bf7 str x23, [sp, #48] const struct crypt_format *cf; SLIST_FOREACH(cf, &cf_head, link) 40020d1c: 90000703 adrp x3, 40100000 <_RTEMS_tasks_Information> 40020d20: f9408077 ldr x23, [x3, #256] { 40020d24: a90153f3 stp x19, x20, [sp, #16] 40020d28: aa0103f4 mov x20, x1 40020d2c: a9025bf5 stp x21, x22, [sp, #32] 40020d30: aa0003f5 mov x21, x0 40020d34: aa0203f6 mov x22, x2 SLIST_FOREACH(cf, &cf_head, link) 40020d38: b4000157 cbz x23, 40020d60 <== NEVER TAKEN 40020d3c: aa1703f3 mov x19, x23 if (cf->magic != NULL && strstr(salt, cf->magic) == salt) 40020d40: f9400a61 ldr x1, [x19, #16] 40020d44: aa1403e0 mov x0, x20 40020d48: b4000081 cbz x1, 40020d58 40020d4c: 94004b5f bl 40033ac8 40020d50: eb00029f cmp x20, x0 40020d54: 540001a0 b.eq 40020d88 // b.none SLIST_FOREACH(cf, &cf_head, link) 40020d58: f9400273 ldr x19, [x19] 40020d5c: b5ffff33 cbnz x19, 40020d40 return (cf->func(passwd, salt, data)); cf = SLIST_FIRST(&cf_head); return (cf->func(passwd, salt, data)); 40020d60: f94006e3 ldr x3, [x23, #8] 40020d64: aa1603e2 mov x2, x22 40020d68: aa1403e1 mov x1, x20 40020d6c: aa1503e0 mov x0, x21 } 40020d70: a94153f3 ldp x19, x20, [sp, #16] return (cf->func(passwd, salt, data)); 40020d74: aa0303f0 mov x16, x3 } 40020d78: a9425bf5 ldp x21, x22, [sp, #32] 40020d7c: f9401bf7 ldr x23, [sp, #48] 40020d80: a8c47bfd ldp x29, x30, [sp], #64 return (cf->func(passwd, salt, data)); 40020d84: d61f0200 br x16 return (cf->func(passwd, salt, data)); 40020d88: f9400663 ldr x3, [x19, #8] 40020d8c: 17fffff6 b 40020d64 =============================================================================== 00000000400211b0 : /* Maximum number of rounds. */ #define ROUNDS_MAX 999999999 char * crypt_sha256_r(const char *key, const char *salt, struct crypt_data *data) { 400211b0: a9a57bfd stp x29, x30, [sp, #-432]! 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]; int buflen = (int)sizeof(data->buffer); 400211b4: 52802003 mov w3, #0x100 // #256 { 400211b8: 910003fd mov x29, sp 400211bc: a90153f3 stp x19, x20, [sp, #16] 400211c0: a9025bf5 stp x21, x22, [sp, #32] 400211c4: aa0103f6 mov x22, x1 400211c8: a90363f7 stp x23, x24, [sp, #48] 400211cc: aa0003f7 mov x23, x0 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) 400211d0: 52800480 mov w0, #0x24 // #36 { 400211d4: a9046bf9 stp x25, x26, [sp, #64] 400211d8: a90573fb stp x27, x28, [sp, #80] if (strncmp(sha256_salt_prefix, salt, sizeof(sha256_salt_prefix) - 1) == 0) 400211dc: 39400021 ldrb w1, [x1] { 400211e0: f9003fa2 str x2, [x29, #120] int buflen = (int)sizeof(data->buffer); 400211e4: b9008fa3 str w3, [x29, #140] if (strncmp(sha256_salt_prefix, salt, sizeof(sha256_salt_prefix) - 1) == 0) 400211e8: 6b01001f cmp w0, w1 400211ec: 54000081 b.ne 400211fc // b.any <== NEVER TAKEN 400211f0: 394006c1 ldrb w1, [x22, #1] 400211f4: 7100d43f cmp w1, #0x35 400211f8: 54002a20 b.eq 4002173c // b.none <== ALWAYS TAKEN /* Skip salt prefix. */ salt += sizeof(sha256_salt_prefix) - 1; if (strncmp(salt, sha256_rounds_prefix, sizeof(sha256_rounds_prefix) - 1) 400211fc: d00000c0 adrp x0, 4003b000 40021200: 913ac000 add x0, x0, #0xeb0 40021204: aa0003e1 mov x1, x0 40021208: d28000e2 mov x2, #0x7 // #7 rounds = ROUNDS_DEFAULT; 4002120c: d2827119 mov x25, #0x1388 // #5000 if (strncmp(salt, sha256_rounds_prefix, sizeof(sha256_rounds_prefix) - 1) 40021210: f90037a0 str x0, [x29, #104] 40021214: aa1603e0 mov x0, x22 rounds_custom = false; 40021218: b90077bf str wzr, [x29, #116] if (strncmp(salt, sha256_rounds_prefix, sizeof(sha256_rounds_prefix) - 1) 4002121c: 940049d9 bl 40033980 40021220: 34002b60 cbz w0, 4002178c rounds = MAX(ROUNDS_MIN, MIN(srounds, ROUNDS_MAX)); rounds_custom = true; } } salt_len = MIN(strcspn(salt, "$"), SALT_LEN_MAX); 40021224: aa1603e0 mov x0, x22 40021228: d00000c1 adrp x1, 4003b000 4002122c: 913a6021 add x1, x1, #0xe98 40021230: 94004945 bl 40033744 40021234: aa0003f5 mov x21, x0 40021238: d2800201 mov x1, #0x10 // #16 4002123c: eb0102bf cmp x21, x1 key_len = strlen(key); 40021240: aa1703e0 mov x0, x23 salt_len = MIN(strcspn(salt, "$"), SALT_LEN_MAX); 40021244: 9a8132b5 csel x21, x21, x1, cc // cc = lo, ul, last key_len = strlen(key); 40021248: 94004996 bl 400338a0 4002124c: aa0003f4 mov x20, x0 /* Prepare for the real work. */ SHA256_Init(&ctx); 40021250: 910383a0 add x0, x29, #0xe0 40021254: 940018eb bl 40027600 /* Add the key string. */ SHA256_Update(&ctx, key, key_len); 40021258: aa1403e2 mov x2, x20 4002125c: aa1703e1 mov x1, x23 40021260: 910383a0 add x0, x29, #0xe0 40021264: 940018fb bl 40027650 /* 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); 40021268: aa1503e2 mov x2, x21 4002126c: aa1603e1 mov x1, x22 40021270: 910383a0 add x0, x29, #0xe0 40021274: 940018f7 bl 40027650 /* Compute alternate SHA256 sum with input KEY, SALT, and KEY. The * final result will be added to the first context. */ SHA256_Init(&alt_ctx); 40021278: 910523a0 add x0, x29, #0x148 4002127c: 940018e1 bl 40027600 /* Add key. */ SHA256_Update(&alt_ctx, key, key_len); 40021280: aa1403e2 mov x2, x20 40021284: aa1703e1 mov x1, x23 40021288: 910523a0 add x0, x29, #0x148 4002128c: 940018f1 bl 40027650 /* Add salt. */ SHA256_Update(&alt_ctx, salt, salt_len); 40021290: aa1503e2 mov x2, x21 40021294: aa1603e1 mov x1, x22 40021298: 910523a0 add x0, x29, #0x148 4002129c: 940018ed bl 40027650 /* Add key again. */ SHA256_Update(&alt_ctx, key, key_len); 400212a0: aa1403e2 mov x2, x20 400212a4: aa1703e1 mov x1, x23 400212a8: 910523a0 add x0, x29, #0x148 400212ac: 940018e9 bl 40027650 /* Now get result of this (32 bytes) and add it to the other context. */ SHA256_Final(alt_result, &alt_ctx); 400212b0: 910523a1 add x1, x29, #0x148 400212b4: 910283a0 add x0, x29, #0xa0 400212b8: 9400191a bl 40027720 /* Add for any character in the key one byte of the alternate sum. */ for (cnt = key_len; cnt > 32; cnt -= 32) 400212bc: f100829f cmp x20, #0x20 400212c0: 54002969 b.ls 400217ec // b.plast 400212c4: aa1403f3 mov x19, x20 400212c8: d1008273 sub x19, x19, #0x20 SHA256_Update(&ctx, alt_result, 32); 400212cc: 910283a1 add x1, x29, #0xa0 400212d0: 910383a0 add x0, x29, #0xe0 400212d4: d2800402 mov x2, #0x20 // #32 400212d8: 940018de bl 40027650 for (cnt = key_len; cnt > 32; cnt -= 32) 400212dc: f100827f cmp x19, #0x20 400212e0: 54ffff48 b.hi 400212c8 // b.pmore 400212e4: d1008683 sub x3, x20, #0x21 400212e8: d1008282 sub x2, x20, #0x20 SHA256_Update(&ctx, alt_result, cnt); 400212ec: 910283a1 add x1, x29, #0xa0 400212f0: 910383a0 add x0, x29, #0xe0 for (cnt = key_len; cnt > 32; cnt -= 32) 400212f4: cb4317e3 neg x3, x3, lsr #5 SHA256_Update(&ctx, alt_result, cnt); 400212f8: 8b031442 add x2, x2, x3, lsl #5 400212fc: 940018d5 bl 40027650 key_len = strlen(key); 40021300: aa1403f3 mov x19, x20 40021304: d503201f nop /* 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) 40021308: 36002113 tbz w19, #0, 40021728 SHA256_Update(&ctx, alt_result, 32); 4002130c: 910283a1 add x1, x29, #0xa0 40021310: 910383a0 add x0, x29, #0xe0 40021314: d2800402 mov x2, #0x20 // #32 40021318: 940018ce bl 40027650 for (cnt = key_len; cnt > 0; cnt >>= 1) 4002131c: d341fe73 lsr x19, x19, #1 40021320: b5ffff53 cbnz x19, 40021308 else SHA256_Update(&ctx, key, key_len); /* Create intermediate result. */ SHA256_Final(alt_result, &ctx); 40021324: 910383a1 add x1, x29, #0xe0 40021328: 910283a0 add x0, x29, #0xa0 4002132c: 940018fd bl 40027720 /* Start computation of P byte sequence. */ SHA256_Init(&alt_ctx); 40021330: 910523a0 add x0, x29, #0x148 40021334: 940018b3 bl 40027600 /* For every character in the password add the entire password. */ for (cnt = 0; cnt < key_len; ++cnt) 40021338: 91000673 add x19, x19, #0x1 SHA256_Update(&alt_ctx, key, key_len); 4002133c: aa1403e2 mov x2, x20 40021340: aa1703e1 mov x1, x23 40021344: 910523a0 add x0, x29, #0x148 40021348: 940018c2 bl 40027650 for (cnt = 0; cnt < key_len; ++cnt) 4002134c: eb13029f cmp x20, x19 40021350: 54ffff48 b.hi 40021338 // b.pmore /* Finish the digest. */ SHA256_Final(temp_result, &alt_ctx); 40021354: 910303b7 add x23, x29, #0xc0 40021358: 910523a1 add x1, x29, #0x148 4002135c: aa1703e0 mov x0, x23 40021360: 940018f0 bl 40027720 /* Create byte sequence P. */ cp = p_bytes = alloca(key_len); 40021364: 91003e80 add x0, x20, #0xf for (cnt = key_len; cnt >= 32; cnt -= 32) { 40021368: f1007e9f cmp x20, #0x1f cp = p_bytes = alloca(key_len); 4002136c: 927cec00 and x0, x0, #0xfffffffffffffff0 40021370: cb2063ff sub sp, sp, x0 40021374: 910003f8 mov x24, sp 40021378: f9004bb8 str x24, [x29, #144] for (cnt = key_len; cnt >= 32; cnt -= 32) { 4002137c: aa1803e0 mov x0, x24 40021380: 540025c9 b.ls 40021838 // b.plast 40021384: aa1403f3 mov x19, x20 memcpy(cp, temp_result, 32); 40021388: aa1703e1 mov x1, x23 4002138c: d2800402 mov x2, #0x20 // #32 40021390: 940047a3 bl 4003321c for (cnt = key_len; cnt >= 32; cnt -= 32) { 40021394: d1008273 sub x19, x19, #0x20 cp += 32; 40021398: f9404ba0 ldr x0, [x29, #144] for (cnt = key_len; cnt >= 32; cnt -= 32) { 4002139c: f1007e7f cmp x19, #0x1f cp += 32; 400213a0: 91008000 add x0, x0, #0x20 400213a4: f9004ba0 str x0, [x29, #144] for (cnt = key_len; cnt >= 32; cnt -= 32) { 400213a8: 54ffff08 b.hi 40021388 // b.pmore 400213ac: 92401282 and x2, x20, #0x1f } memcpy(cp, temp_result, cnt); 400213b0: aa1703e1 mov x1, x23 400213b4: 9400479a bl 4003321c /* Start computation of S byte sequence. */ SHA256_Init(&alt_ctx); 400213b8: 910523a0 add x0, x29, #0x148 /* For every character in the password add the entire password. */ for (cnt = 0; cnt < 16 + alt_result[0]; ++cnt) 400213bc: d2800013 mov x19, #0x0 // #0 SHA256_Init(&alt_ctx); 400213c0: 94001890 bl 40027600 for (cnt = 0; cnt < 16 + alt_result[0]; ++cnt) 400213c4: d503201f nop SHA256_Update(&alt_ctx, salt, salt_len); 400213c8: 910523a0 add x0, x29, #0x148 400213cc: aa1503e2 mov x2, x21 400213d0: aa1603e1 mov x1, x22 400213d4: 9400189f bl 40027650 for (cnt = 0; cnt < 16 + alt_result[0]; ++cnt) 400213d8: 394283a0 ldrb w0, [x29, #160] 400213dc: 91000673 add x19, x19, #0x1 400213e0: 91004000 add x0, x0, #0x10 400213e4: eb13001f cmp x0, x19 400213e8: 54ffff08 b.hi 400213c8 // b.pmore /* Finish the digest. */ SHA256_Final(temp_result, &alt_ctx); 400213ec: 910523a1 add x1, x29, #0x148 400213f0: aa1703e0 mov x0, x23 400213f4: 940018cb bl 40027720 /* Add key or last result. */ if ((cnt & 1) != 0) SHA256_Update(&ctx, p_bytes, key_len); else SHA256_Update(&ctx, alt_result, 32); 400213f8: b201f3fb mov x27, #0xaaaaaaaaaaaaaaaa // #-6148914691236517206 cp = s_bytes = alloca(salt_len); 400213fc: 91003ea0 add x0, x21, #0xf memcpy(cp, temp_result, cnt); 40021400: aa1703e1 mov x1, x23 cp = s_bytes = alloca(salt_len); 40021404: 927cec00 and x0, x0, #0xfffffffffffffff0 memcpy(cp, temp_result, cnt); 40021408: aa1503e2 mov x2, x21 cp = s_bytes = alloca(salt_len); 4002140c: cb2063ff sub sp, sp, x0 for (cnt = 0; cnt < rounds; ++cnt) { 40021410: d2800013 mov x19, #0x0 // #0 cp = s_bytes = alloca(salt_len); 40021414: 910003fc mov x28, sp SHA256_Update(&ctx, alt_result, 32); 40021418: f295557b movk x27, #0xaaab memcpy(cp, temp_result, cnt); 4002141c: aa1c03e0 mov x0, x28 /* Add salt for numbers not divisible by 3. */ if (cnt % 3 != 0) 40021420: b200f3fa mov x26, #0x5555555555555555 // #6148914691236517205 cp = s_bytes = alloca(salt_len); 40021424: f9004bbc str x28, [x29, #144] memcpy(cp, temp_result, cnt); 40021428: 9400477d bl 4003321c for (cnt = 0; cnt < rounds; ++cnt) { 4002142c: d503201f nop SHA256_Init(&ctx); 40021430: 910383a0 add x0, x29, #0xe0 if ((cnt & 1) != 0) 40021434: 92400277 and x23, x19, #0x1 SHA256_Init(&ctx); 40021438: 94001872 bl 40027600 if ((cnt & 1) != 0) 4002143c: 360015f3 tbz w19, #0, 400216f8 SHA256_Update(&ctx, p_bytes, key_len); 40021440: 910383a0 add x0, x29, #0xe0 40021444: aa1403e2 mov x2, x20 40021448: aa1803e1 mov x1, x24 4002144c: 94001881 bl 40027650 SHA256_Update(&ctx, alt_result, 32); 40021450: 9b1b7e60 mul x0, x19, x27 if (cnt % 3 != 0) 40021454: eb1a001f cmp x0, x26 40021458: 540015e8 b.hi 40021714 // b.pmore SHA256_Update(&ctx, s_bytes, salt_len); 4002145c: d28db6e0 mov x0, #0x6db7 // #28087 40021460: f2b6db60 movk x0, #0xb6db, lsl #16 40021464: f2db6da0 movk x0, #0xdb6d, lsl #32 40021468: f2edb6c0 movk x0, #0x6db6, lsl #48 /* Add key for numbers not divisible by 7. */ if (cnt % 7 != 0) 4002146c: d2849241 mov x1, #0x2492 // #9362 40021470: f2b24921 movk x1, #0x9249, lsl #16 SHA256_Update(&ctx, s_bytes, salt_len); 40021474: 9b007e60 mul x0, x19, x0 if (cnt % 7 != 0) 40021478: f2c92481 movk x1, #0x4924, lsl #32 4002147c: f2e49241 movk x1, #0x2492, lsl #48 40021480: eb01001f cmp x0, x1 40021484: 54001268 b.hi 400216d0 // b.pmore SHA256_Update(&ctx, p_bytes, key_len); /* Add key or last result. */ if ((cnt & 1) != 0) 40021488: b40012f7 cbz x23, 400216e4 SHA256_Update(&ctx, alt_result, 32); 4002148c: 910283a1 add x1, x29, #0xa0 40021490: 910383a0 add x0, x29, #0xe0 40021494: d2800402 mov x2, #0x20 // #32 40021498: 9400186e bl 40027650 for (cnt = 0; cnt < rounds; ++cnt) { 4002149c: 91000673 add x19, x19, #0x1 else SHA256_Update(&ctx, p_bytes, key_len); /* Create intermediate result. */ SHA256_Final(alt_result, &ctx); 400214a0: 910383a1 add x1, x29, #0xe0 400214a4: 910283a0 add x0, x29, #0xa0 400214a8: 9400189e bl 40027720 for (cnt = 0; cnt < rounds; ++cnt) { 400214ac: eb13033f cmp x25, x19 400214b0: 54fffc01 b.ne 40021430 // b.any } /* Now we can construct the result string. It consists of three * parts. */ cp = stpncpy(buffer, sha256_salt_prefix, MAX(0, buflen)); 400214b4: b9408fb3 ldr w19, [x29, #140] 400214b8: d00000c1 adrp x1, 4003b000 400214bc: 913ae021 add x1, x1, #0xeb8 400214c0: f9403fa0 ldr x0, [x29, #120] 400214c4: 7100027f cmp w19, #0x0 400214c8: 1a9fa262 csel w2, w19, wzr, ge // ge = tcont 400214cc: 93407c42 sxtw x2, w2 400214d0: 94004840 bl 400335d0 buflen -= sizeof(sha256_salt_prefix) - 1; if (rounds_custom) { 400214d4: b94077a1 ldr w1, [x29, #116] buflen -= sizeof(sha256_salt_prefix) - 1; 400214d8: 71000e73 subs w19, w19, #0x3 n = snprintf(cp, MAX(0, buflen), "%s%zu$", 400214dc: 1a9f5262 csel w2, w19, wzr, pl // pl = nfrst buflen -= sizeof(sha256_salt_prefix) - 1; 400214e0: b9008fb3 str w19, [x29, #140] cp = stpncpy(buffer, sha256_salt_prefix, MAX(0, buflen)); 400214e4: f9004ba0 str x0, [x29, #144] 400214e8: aa0003e3 mov x3, x0 n = snprintf(cp, MAX(0, buflen), "%s%zu$", 400214ec: 93407c42 sxtw x2, w2 if (rounds_custom) { 400214f0: 35001301 cbnz w1, 40021750 cp += n; buflen -= n; } cp = stpncpy(cp, salt, MIN((size_t)MAX(0, buflen), salt_len)); 400214f4: eb0202bf cmp x21, x2 400214f8: aa1603e1 mov x1, x22 400214fc: 9a8292a2 csel x2, x21, x2, ls // ls = plast 40021500: aa0303e0 mov x0, x3 40021504: 94004833 bl 400335d0 40021508: f9004ba0 str x0, [x29, #144] buflen -= MIN((size_t)MAX(0, buflen), salt_len); 4002150c: b9408fa1 ldr w1, [x29, #140] 40021510: 7100003f cmp w1, #0x0 40021514: 1a9fa022 csel w2, w1, wzr, ge // ge = tcont 40021518: 93407c42 sxtw x2, w2 4002151c: eb15005f cmp x2, x21 40021520: 9a959055 csel x21, x2, x21, ls // ls = plast 40021524: 4b150021 sub w1, w1, w21 40021528: b9008fa1 str w1, [x29, #140] if (buflen > 0) { 4002152c: 7100003f cmp w1, #0x0 40021530: 5400010d b.le 40021550 <== NEVER TAKEN *cp++ = '$'; 40021534: 91000401 add x1, x0, #0x1 40021538: f9004ba1 str x1, [x29, #144] 4002153c: 52800481 mov w1, #0x24 // #36 40021540: 39000001 strb w1, [x0] --buflen; 40021544: b9408fa0 ldr w0, [x29, #140] 40021548: 51000400 sub w0, w0, #0x1 4002154c: b9008fa0 str w0, [x29, #140] } b64_from_24bit(alt_result[0], alt_result[10], alt_result[20], 4, &buflen, &cp); 40021550: 394283a0 ldrb w0, [x29, #160] 40021554: 910243a5 add x5, x29, #0x90 40021558: 3942aba1 ldrb w1, [x29, #170] 4002155c: 910233a4 add x4, x29, #0x8c 40021560: 3942d3a2 ldrb w2, [x29, #180] 40021564: 52800083 mov w3, #0x4 // #4 40021568: 940002ba bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[21], alt_result[1], alt_result[11], 4, &buflen, &cp); 4002156c: 394287a1 ldrb w1, [x29, #161] 40021570: 910243a5 add x5, x29, #0x90 40021574: 3942afa2 ldrb w2, [x29, #171] 40021578: 910233a4 add x4, x29, #0x8c 4002157c: 3942d7a0 ldrb w0, [x29, #181] 40021580: 52800083 mov w3, #0x4 // #4 40021584: 940002b3 bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[12], alt_result[22], alt_result[2], 4, &buflen, &cp); 40021588: 39428ba2 ldrb w2, [x29, #162] 4002158c: 910243a5 add x5, x29, #0x90 40021590: 3942b3a0 ldrb w0, [x29, #172] 40021594: 910233a4 add x4, x29, #0x8c 40021598: 3942dba1 ldrb w1, [x29, #182] 4002159c: 52800083 mov w3, #0x4 // #4 400215a0: 940002ac bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[3], alt_result[13], alt_result[23], 4, &buflen, &cp); 400215a4: 39428fa0 ldrb w0, [x29, #163] 400215a8: 910243a5 add x5, x29, #0x90 400215ac: 3942b7a1 ldrb w1, [x29, #173] 400215b0: 910233a4 add x4, x29, #0x8c 400215b4: 3942dfa2 ldrb w2, [x29, #183] 400215b8: 52800083 mov w3, #0x4 // #4 400215bc: 940002a5 bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[24], alt_result[4], alt_result[14], 4, &buflen, &cp); 400215c0: 394293a1 ldrb w1, [x29, #164] 400215c4: 910243a5 add x5, x29, #0x90 400215c8: 3942bba2 ldrb w2, [x29, #174] 400215cc: 910233a4 add x4, x29, #0x8c 400215d0: 3942e3a0 ldrb w0, [x29, #184] 400215d4: 52800083 mov w3, #0x4 // #4 400215d8: 9400029e bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[15], alt_result[25], alt_result[5], 4, &buflen, &cp); 400215dc: 394297a2 ldrb w2, [x29, #165] 400215e0: 910243a5 add x5, x29, #0x90 400215e4: 3942bfa0 ldrb w0, [x29, #175] 400215e8: 910233a4 add x4, x29, #0x8c 400215ec: 3942e7a1 ldrb w1, [x29, #185] 400215f0: 52800083 mov w3, #0x4 // #4 400215f4: 94000297 bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[6], alt_result[16], alt_result[26], 4, &buflen, &cp); 400215f8: 39429ba0 ldrb w0, [x29, #166] 400215fc: 910243a5 add x5, x29, #0x90 40021600: 3942c3a1 ldrb w1, [x29, #176] 40021604: 910233a4 add x4, x29, #0x8c 40021608: 3942eba2 ldrb w2, [x29, #186] 4002160c: 52800083 mov w3, #0x4 // #4 40021610: 94000290 bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[27], alt_result[7], alt_result[17], 4, &buflen, &cp); 40021614: 39429fa1 ldrb w1, [x29, #167] 40021618: 910243a5 add x5, x29, #0x90 4002161c: 3942c7a2 ldrb w2, [x29, #177] 40021620: 910233a4 add x4, x29, #0x8c 40021624: 3942efa0 ldrb w0, [x29, #187] 40021628: 52800083 mov w3, #0x4 // #4 4002162c: 94000289 bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[18], alt_result[28], alt_result[8], 4, &buflen, &cp); 40021630: 3942a3a2 ldrb w2, [x29, #168] 40021634: 910243a5 add x5, x29, #0x90 40021638: 3942cba0 ldrb w0, [x29, #178] 4002163c: 910233a4 add x4, x29, #0x8c 40021640: 3942f3a1 ldrb w1, [x29, #188] 40021644: 52800083 mov w3, #0x4 // #4 40021648: 94000282 bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[9], alt_result[19], alt_result[29], 4, &buflen, &cp); 4002164c: 3942a7a0 ldrb w0, [x29, #169] 40021650: 910243a5 add x5, x29, #0x90 40021654: 3942cfa1 ldrb w1, [x29, #179] 40021658: 910233a4 add x4, x29, #0x8c 4002165c: 3942f7a2 ldrb w2, [x29, #189] 40021660: 52800083 mov w3, #0x4 // #4 40021664: 9400027b bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(0, alt_result[31], alt_result[30], 3, &buflen, &cp); 40021668: 3942fba2 ldrb w2, [x29, #190] 4002166c: 52800000 mov w0, #0x0 // #0 40021670: 3942ffa1 ldrb w1, [x29, #191] 40021674: 910243a5 add x5, x29, #0x90 40021678: 910233a4 add x4, x29, #0x8c 4002167c: 52800063 mov w3, #0x3 // #3 40021680: 94000274 bl 40022050 <_crypt_b64_from_24bit> if (buflen <= 0) { 40021684: b9408fa0 ldr w0, [x29, #140] 40021688: 7100001f cmp w0, #0x0 4002168c: 54000a6d b.le 400217d8 <== NEVER TAKEN errno = ERANGE; buffer = NULL; } else *cp = '\0'; /* Terminate the string. */ 40021690: f9404ba0 ldr x0, [x29, #144] 40021694: 3900001f strb wzr, [x0] /* 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); 40021698: 910383a0 add x0, x29, #0xe0 4002169c: 940017d9 bl 40027600 SHA256_Final(alt_result, &ctx); 400216a0: 910383a1 add x1, x29, #0xe0 400216a4: 910283a0 add x0, x29, #0xa0 400216a8: 9400181e bl 40027720 memset(copied_key, '\0', key_len); if (copied_salt != NULL) memset(copied_salt, '\0', salt_len); return buffer; } 400216ac: f9403fa0 ldr x0, [x29, #120] 400216b0: 910003bf mov sp, x29 400216b4: a94153f3 ldp x19, x20, [sp, #16] 400216b8: a9425bf5 ldp x21, x22, [sp, #32] 400216bc: a94363f7 ldp x23, x24, [sp, #48] 400216c0: a9446bf9 ldp x25, x26, [sp, #64] 400216c4: a94573fb ldp x27, x28, [sp, #80] 400216c8: a8db7bfd ldp x29, x30, [sp], #432 400216cc: d65f03c0 ret SHA256_Update(&ctx, p_bytes, key_len); 400216d0: aa1403e2 mov x2, x20 400216d4: aa1803e1 mov x1, x24 400216d8: 910383a0 add x0, x29, #0xe0 400216dc: 940017dd bl 40027650 if ((cnt & 1) != 0) 400216e0: b5ffed77 cbnz x23, 4002148c SHA256_Update(&ctx, p_bytes, key_len); 400216e4: aa1403e2 mov x2, x20 400216e8: aa1803e1 mov x1, x24 400216ec: 910383a0 add x0, x29, #0xe0 400216f0: 940017d8 bl 40027650 400216f4: 17ffff6a b 4002149c SHA256_Update(&ctx, alt_result, 32); 400216f8: 910383a0 add x0, x29, #0xe0 400216fc: 910283a1 add x1, x29, #0xa0 40021700: d2800402 mov x2, #0x20 // #32 40021704: 940017d3 bl 40027650 40021708: 9b1b7e60 mul x0, x19, x27 if (cnt % 3 != 0) 4002170c: eb1a001f cmp x0, x26 40021710: 54ffea69 b.ls 4002145c // b.plast SHA256_Update(&ctx, s_bytes, salt_len); 40021714: aa1503e2 mov x2, x21 40021718: aa1c03e1 mov x1, x28 4002171c: 910383a0 add x0, x29, #0xe0 40021720: 940017cc bl 40027650 40021724: 17ffff4e b 4002145c SHA256_Update(&ctx, key, key_len); 40021728: aa1403e2 mov x2, x20 4002172c: aa1703e1 mov x1, x23 40021730: 910383a0 add x0, x29, #0xe0 40021734: 940017c7 bl 40027650 40021738: 17fffef9 b 4002131c if (strncmp(sha256_salt_prefix, salt, sizeof(sha256_salt_prefix) - 1) == 0) 4002173c: 39400ac2 ldrb w2, [x22, #2] salt += sizeof(sha256_salt_prefix) - 1; 40021740: 91000ec1 add x1, x22, #0x3 40021744: 6b02001f cmp w0, w2 40021748: 9a960036 csel x22, x1, x22, eq // eq = none 4002174c: 17fffeac b 400211fc n = snprintf(cp, MAX(0, buflen), "%s%zu$", 40021750: f94037a3 ldr x3, [x29, #104] 40021754: aa0203e1 mov x1, x2 40021758: aa1903e4 mov x4, x25 4002175c: d00000c2 adrp x2, 4003b000 40021760: 913a8042 add x2, x2, #0xea0 40021764: 94004744 bl 40033474 buflen -= n; 40021768: b9408fa2 ldr w2, [x29, #140] cp += n; 4002176c: f9404ba3 ldr x3, [x29, #144] buflen -= n; 40021770: 6b000042 subs w2, w2, w0 40021774: b9008fa2 str w2, [x29, #140] cp = stpncpy(cp, salt, MIN((size_t)MAX(0, buflen), salt_len)); 40021778: 1a9f5042 csel w2, w2, wzr, pl // pl = nfrst cp += n; 4002177c: 8b20c063 add x3, x3, w0, sxtw cp = stpncpy(cp, salt, MIN((size_t)MAX(0, buflen), salt_len)); 40021780: 93407c42 sxtw x2, w2 cp += n; 40021784: f9004ba3 str x3, [x29, #144] buflen -= n; 40021788: 17ffff5b b 400214f4 srounds = strtoul(num, &endp, 10); 4002178c: 910263a1 add x1, x29, #0x98 40021790: 52800142 mov w2, #0xa // #10 40021794: 91001ec0 add x0, x22, #0x7 40021798: 940049ab bl 40033e44 if (*endp == '$') { 4002179c: f9404fa1 ldr x1, [x29, #152] 400217a0: 39400022 ldrb w2, [x1] 400217a4: 7100905f cmp w2, #0x24 400217a8: 54ffd3e1 b.ne 40021224 // b.any <== NEVER TAKEN rounds = MAX(ROUNDS_MIN, MIN(srounds, ROUNDS_MAX)); 400217ac: d2993ff9 mov x25, #0xc9ff // #51711 400217b0: f2a77359 movk x25, #0x3b9a, lsl #16 400217b4: eb19001f cmp x0, x25 salt = endp + 1; 400217b8: 91000436 add x22, x1, #0x1 rounds = MAX(ROUNDS_MIN, MIN(srounds, ROUNDS_MAX)); 400217bc: 9a999019 csel x25, x0, x25, ls // ls = plast 400217c0: d2807d00 mov x0, #0x3e8 // #1000 400217c4: f10fa33f cmp x25, #0x3e8 400217c8: 9a802339 csel x25, x25, x0, cs // cs = hs, nlast rounds_custom = true; 400217cc: 52800020 mov w0, #0x1 // #1 400217d0: b90077a0 str w0, [x29, #116] 400217d4: 17fffe94 b 40021224 errno = ERANGE; 400217d8: 94004631 bl 4003309c <__errno> <== NOT EXECUTED buffer = NULL; 400217dc: f9003fbf str xzr, [x29, #120] <== NOT EXECUTED errno = ERANGE; 400217e0: 52800441 mov w1, #0x22 // #34 <== NOT EXECUTED 400217e4: b9000001 str w1, [x0] <== NOT EXECUTED buffer = NULL; 400217e8: 17ffffac b 40021698 <== NOT EXECUTED SHA256_Update(&ctx, alt_result, cnt); 400217ec: aa1403e2 mov x2, x20 400217f0: 910283a1 add x1, x29, #0xa0 400217f4: 910383a0 add x0, x29, #0xe0 400217f8: 94001796 bl 40027650 for (cnt = key_len; cnt > 0; cnt >>= 1) 400217fc: b5ffd834 cbnz x20, 40021300 <== ALWAYS TAKEN SHA256_Final(alt_result, &ctx); 40021800: 910383a1 add x1, x29, #0xe0 <== NOT EXECUTED 40021804: 910283a0 add x0, x29, #0xa0 <== NOT EXECUTED 40021808: 940017c6 bl 40027720 <== NOT EXECUTED SHA256_Final(temp_result, &alt_ctx); 4002180c: 910303b7 add x23, x29, #0xc0 <== NOT EXECUTED SHA256_Init(&alt_ctx); 40021810: 910523a0 add x0, x29, #0x148 <== NOT EXECUTED cp = p_bytes = alloca(key_len); 40021814: 910003f8 mov x24, sp <== NOT EXECUTED SHA256_Init(&alt_ctx); 40021818: 9400177a bl 40027600 <== NOT EXECUTED SHA256_Final(temp_result, &alt_ctx); 4002181c: aa1703e0 mov x0, x23 <== NOT EXECUTED 40021820: 910523a1 add x1, x29, #0x148 <== NOT EXECUTED 40021824: 940017bf bl 40027720 <== NOT EXECUTED cp = p_bytes = alloca(key_len); 40021828: f9004bb8 str x24, [x29, #144] <== NOT EXECUTED 4002182c: 910003e0 mov x0, sp <== NOT EXECUTED 40021830: d2800002 mov x2, #0x0 // #0 <== NOT EXECUTED 40021834: 17fffedf b 400213b0 <== NOT EXECUTED for (cnt = key_len; cnt >= 32; cnt -= 32) { 40021838: aa1403e2 mov x2, x20 4002183c: 17fffedd b 400213b0 =============================================================================== 0000000040021840 : /* Maximum number of rounds. */ #define ROUNDS_MAX 999999999 char * crypt_sha512_r(const char *key, const char *salt, struct crypt_data *data) { 40021840: d10b03ff sub sp, sp, #0x2c0 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]; int buflen = (int)sizeof(data->buffer); 40021844: 52802003 mov w3, #0x100 // #256 { 40021848: a9007bfd stp x29, x30, [sp] 4002184c: 910003fd mov x29, sp 40021850: a90153f3 stp x19, x20, [sp, #16] 40021854: a9025bf5 stp x21, x22, [sp, #32] 40021858: aa0103f6 mov x22, x1 4002185c: a90363f7 stp x23, x24, [sp, #48] 40021860: aa0003f7 mov x23, x0 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) 40021864: 52800480 mov w0, #0x24 // #36 { 40021868: a9046bf9 stp x25, x26, [sp, #64] 4002186c: a90573fb stp x27, x28, [sp, #80] if (strncmp(sha512_salt_prefix, salt, sizeof(sha512_salt_prefix) - 1) == 0) 40021870: 39400021 ldrb w1, [x1] { 40021874: f9003fa2 str x2, [x29, #120] int buflen = (int)sizeof(data->buffer); 40021878: b9008fa3 str w3, [x29, #140] if (strncmp(sha512_salt_prefix, salt, sizeof(sha512_salt_prefix) - 1) == 0) 4002187c: 6b01001f cmp w0, w1 40021880: 54000081 b.ne 40021890 // b.any 40021884: 394006c1 ldrb w1, [x22, #1] 40021888: 7100d83f cmp w1, #0x36 4002188c: 54003400 b.eq 40021f0c // b.none <== ALWAYS TAKEN /* Skip salt prefix. */ salt += sizeof(sha512_salt_prefix) - 1; if (strncmp(salt, sha512_rounds_prefix, sizeof(sha512_rounds_prefix) - 1) 40021890: d00000c0 adrp x0, 4003b000 40021894: 913b2000 add x0, x0, #0xec8 40021898: aa0003e1 mov x1, x0 4002189c: d28000e2 mov x2, #0x7 // #7 rounds = ROUNDS_DEFAULT; 400218a0: d2827119 mov x25, #0x1388 // #5000 if (strncmp(salt, sha512_rounds_prefix, sizeof(sha512_rounds_prefix) - 1) 400218a4: f90037a0 str x0, [x29, #104] 400218a8: aa1603e0 mov x0, x22 rounds_custom = false; 400218ac: b90077bf str wzr, [x29, #116] if (strncmp(salt, sha512_rounds_prefix, sizeof(sha512_rounds_prefix) - 1) 400218b0: 94004834 bl 40033980 400218b4: 34003540 cbz w0, 40021f5c rounds = MAX(ROUNDS_MIN, MIN(srounds, ROUNDS_MAX)); rounds_custom = true; } } salt_len = MIN(strcspn(salt, "$"), SALT_LEN_MAX); 400218b8: aa1603e0 mov x0, x22 400218bc: d00000c1 adrp x1, 4003b000 400218c0: 913a6021 add x1, x1, #0xe98 400218c4: 940047a0 bl 40033744 400218c8: aa0003f5 mov x21, x0 400218cc: d2800201 mov x1, #0x10 // #16 400218d0: eb0102bf cmp x21, x1 key_len = strlen(key); 400218d4: aa1703e0 mov x0, x23 salt_len = MIN(strcspn(salt, "$"), SALT_LEN_MAX); 400218d8: 9a8132b5 csel x21, x21, x1, cc // cc = lo, ul, last key_len = strlen(key); 400218dc: 940047f1 bl 400338a0 400218e0: aa0003f4 mov x20, x0 /* Prepare for the real work. */ SHA512_Init(&ctx); 400218e4: 910483a0 add x0, x29, #0x120 400218e8: 94001fe2 bl 40029870 /* Add the key string. */ SHA512_Update(&ctx, key, key_len); 400218ec: aa1403e2 mov x2, x20 400218f0: aa1703e1 mov x1, x23 400218f4: 910483a0 add x0, x29, #0x120 400218f8: 94002006 bl 40029910 /* 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); 400218fc: aa1503e2 mov x2, x21 40021900: aa1603e1 mov x1, x22 40021904: 910483a0 add x0, x29, #0x120 40021908: 94002002 bl 40029910 /* Compute alternate SHA512 sum with input KEY, SALT, and KEY. The * final result will be added to the first context. */ SHA512_Init(&alt_ctx); 4002190c: 9107c3a0 add x0, x29, #0x1f0 40021910: 94001fd8 bl 40029870 /* Add key. */ SHA512_Update(&alt_ctx, key, key_len); 40021914: aa1403e2 mov x2, x20 40021918: aa1703e1 mov x1, x23 4002191c: 9107c3a0 add x0, x29, #0x1f0 40021920: 94001ffc bl 40029910 /* Add salt. */ SHA512_Update(&alt_ctx, salt, salt_len); 40021924: aa1503e2 mov x2, x21 40021928: aa1603e1 mov x1, x22 4002192c: 9107c3a0 add x0, x29, #0x1f0 40021930: 94001ff8 bl 40029910 /* Add key again. */ SHA512_Update(&alt_ctx, key, key_len); 40021934: aa1403e2 mov x2, x20 40021938: aa1703e1 mov x1, x23 4002193c: 9107c3a0 add x0, x29, #0x1f0 40021940: 94001ff4 bl 40029910 /* Now get result of this (64 bytes) and add it to the other context. */ SHA512_Final(alt_result, &alt_ctx); 40021944: 9107c3a1 add x1, x29, #0x1f0 40021948: 910283a0 add x0, x29, #0xa0 4002194c: 94002029 bl 400299f0 /* Add for any character in the key one byte of the alternate sum. */ for (cnt = key_len; cnt > 64; cnt -= 64) 40021950: f101029f cmp x20, #0x40 40021954: 54003349 b.ls 40021fbc // b.plast 40021958: aa1403f3 mov x19, x20 4002195c: d503201f nop 40021960: d1010273 sub x19, x19, #0x40 SHA512_Update(&ctx, alt_result, 64); 40021964: 910283a1 add x1, x29, #0xa0 40021968: 910483a0 add x0, x29, #0x120 4002196c: d2800802 mov x2, #0x40 // #64 40021970: 94001fe8 bl 40029910 for (cnt = key_len; cnt > 64; cnt -= 64) 40021974: f101027f cmp x19, #0x40 40021978: 54ffff48 b.hi 40021960 // b.pmore <== NEVER TAKEN 4002197c: d1010683 sub x3, x20, #0x41 40021980: d1010282 sub x2, x20, #0x40 SHA512_Update(&ctx, alt_result, cnt); 40021984: 910283a1 add x1, x29, #0xa0 40021988: 910483a0 add x0, x29, #0x120 for (cnt = key_len; cnt > 64; cnt -= 64) 4002198c: cb431be3 neg x3, x3, lsr #6 SHA512_Update(&ctx, alt_result, cnt); 40021990: 8b031842 add x2, x2, x3, lsl #6 40021994: 94001fdf bl 40029910 key_len = strlen(key); 40021998: aa1403f3 mov x19, x20 4002199c: d503201f nop /* 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) 400219a0: 36002ad3 tbz w19, #0, 40021ef8 SHA512_Update(&ctx, alt_result, 64); 400219a4: 910283a1 add x1, x29, #0xa0 400219a8: 910483a0 add x0, x29, #0x120 400219ac: d2800802 mov x2, #0x40 // #64 400219b0: 94001fd8 bl 40029910 for (cnt = key_len; cnt > 0; cnt >>= 1) 400219b4: d341fe73 lsr x19, x19, #1 400219b8: b5ffff53 cbnz x19, 400219a0 else SHA512_Update(&ctx, key, key_len); /* Create intermediate result. */ SHA512_Final(alt_result, &ctx); 400219bc: 910483a1 add x1, x29, #0x120 400219c0: 910283a0 add x0, x29, #0xa0 400219c4: 9400200b bl 400299f0 /* Start computation of P byte sequence. */ SHA512_Init(&alt_ctx); 400219c8: 9107c3a0 add x0, x29, #0x1f0 400219cc: 94001fa9 bl 40029870 /* For every character in the password add the entire password. */ for (cnt = 0; cnt < key_len; ++cnt) 400219d0: 91000673 add x19, x19, #0x1 SHA512_Update(&alt_ctx, key, key_len); 400219d4: aa1403e2 mov x2, x20 400219d8: aa1703e1 mov x1, x23 400219dc: 9107c3a0 add x0, x29, #0x1f0 400219e0: 94001fcc bl 40029910 for (cnt = 0; cnt < key_len; ++cnt) 400219e4: eb13029f cmp x20, x19 400219e8: 54ffff48 b.hi 400219d0 // b.pmore /* Finish the digest. */ SHA512_Final(temp_result, &alt_ctx); 400219ec: 910383b7 add x23, x29, #0xe0 400219f0: 9107c3a1 add x1, x29, #0x1f0 400219f4: aa1703e0 mov x0, x23 400219f8: 94001ffe bl 400299f0 /* Create byte sequence P. */ cp = p_bytes = alloca(key_len); 400219fc: 91003e80 add x0, x20, #0xf for (cnt = key_len; cnt >= 64; cnt -= 64) { 40021a00: f100fe9f cmp x20, #0x3f cp = p_bytes = alloca(key_len); 40021a04: 927cec00 and x0, x0, #0xfffffffffffffff0 40021a08: cb2063ff sub sp, sp, x0 40021a0c: 910003f8 mov x24, sp 40021a10: f9004bb8 str x24, [x29, #144] for (cnt = key_len; cnt >= 64; cnt -= 64) { 40021a14: aa1803e0 mov x0, x24 40021a18: 54002f89 b.ls 40022008 // b.plast 40021a1c: aa1403f3 mov x19, x20 memcpy(cp, temp_result, 64); 40021a20: aa1703e1 mov x1, x23 40021a24: d2800802 mov x2, #0x40 // #64 40021a28: 940045fd bl 4003321c for (cnt = key_len; cnt >= 64; cnt -= 64) { 40021a2c: d1010273 sub x19, x19, #0x40 cp += 64; 40021a30: f9404ba0 ldr x0, [x29, #144] for (cnt = key_len; cnt >= 64; cnt -= 64) { 40021a34: f100fe7f cmp x19, #0x3f cp += 64; 40021a38: 91010000 add x0, x0, #0x40 40021a3c: f9004ba0 str x0, [x29, #144] for (cnt = key_len; cnt >= 64; cnt -= 64) { 40021a40: 54ffff08 b.hi 40021a20 // b.pmore <== NEVER TAKEN 40021a44: 92401682 and x2, x20, #0x3f } memcpy(cp, temp_result, cnt); 40021a48: aa1703e1 mov x1, x23 40021a4c: 940045f4 bl 4003321c /* Start computation of S byte sequence. */ SHA512_Init(&alt_ctx); 40021a50: 9107c3a0 add x0, x29, #0x1f0 /* For every character in the password add the entire password. */ for (cnt = 0; cnt < 16 + alt_result[0]; ++cnt) 40021a54: d2800013 mov x19, #0x0 // #0 SHA512_Init(&alt_ctx); 40021a58: 94001f86 bl 40029870 for (cnt = 0; cnt < 16 + alt_result[0]; ++cnt) 40021a5c: d503201f nop SHA512_Update(&alt_ctx, salt, salt_len); 40021a60: 9107c3a0 add x0, x29, #0x1f0 40021a64: aa1503e2 mov x2, x21 40021a68: aa1603e1 mov x1, x22 40021a6c: 94001fa9 bl 40029910 for (cnt = 0; cnt < 16 + alt_result[0]; ++cnt) 40021a70: 394283a0 ldrb w0, [x29, #160] 40021a74: 91000673 add x19, x19, #0x1 40021a78: 91004000 add x0, x0, #0x10 40021a7c: eb13001f cmp x0, x19 40021a80: 54ffff08 b.hi 40021a60 // b.pmore /* Finish the digest. */ SHA512_Final(temp_result, &alt_ctx); 40021a84: 9107c3a1 add x1, x29, #0x1f0 40021a88: aa1703e0 mov x0, x23 40021a8c: 94001fd9 bl 400299f0 /* Add key or last result. */ if ((cnt & 1) != 0) SHA512_Update(&ctx, p_bytes, key_len); else SHA512_Update(&ctx, alt_result, 64); 40021a90: b201f3fb mov x27, #0xaaaaaaaaaaaaaaaa // #-6148914691236517206 cp = s_bytes = alloca(salt_len); 40021a94: 91003ea0 add x0, x21, #0xf memcpy(cp, temp_result, cnt); 40021a98: aa1703e1 mov x1, x23 cp = s_bytes = alloca(salt_len); 40021a9c: 927cec00 and x0, x0, #0xfffffffffffffff0 memcpy(cp, temp_result, cnt); 40021aa0: aa1503e2 mov x2, x21 cp = s_bytes = alloca(salt_len); 40021aa4: cb2063ff sub sp, sp, x0 for (cnt = 0; cnt < rounds; ++cnt) { 40021aa8: d2800013 mov x19, #0x0 // #0 cp = s_bytes = alloca(salt_len); 40021aac: 910003fc mov x28, sp SHA512_Update(&ctx, alt_result, 64); 40021ab0: f295557b movk x27, #0xaaab memcpy(cp, temp_result, cnt); 40021ab4: aa1c03e0 mov x0, x28 /* Add salt for numbers not divisible by 3. */ if (cnt % 3 != 0) 40021ab8: b200f3fa mov x26, #0x5555555555555555 // #6148914691236517205 cp = s_bytes = alloca(salt_len); 40021abc: f9004bbc str x28, [x29, #144] memcpy(cp, temp_result, cnt); 40021ac0: 940045d7 bl 4003321c for (cnt = 0; cnt < rounds; ++cnt) { 40021ac4: d503201f nop SHA512_Init(&ctx); 40021ac8: 910483a0 add x0, x29, #0x120 if ((cnt & 1) != 0) 40021acc: 92400277 and x23, x19, #0x1 SHA512_Init(&ctx); 40021ad0: 94001f68 bl 40029870 if ((cnt & 1) != 0) 40021ad4: 36001fb3 tbz w19, #0, 40021ec8 SHA512_Update(&ctx, p_bytes, key_len); 40021ad8: 910483a0 add x0, x29, #0x120 40021adc: aa1403e2 mov x2, x20 40021ae0: aa1803e1 mov x1, x24 40021ae4: 94001f8b bl 40029910 SHA512_Update(&ctx, alt_result, 64); 40021ae8: 9b1b7e60 mul x0, x19, x27 if (cnt % 3 != 0) 40021aec: eb1a001f cmp x0, x26 40021af0: 54001fa8 b.hi 40021ee4 // b.pmore SHA512_Update(&ctx, s_bytes, salt_len); 40021af4: d28db6e0 mov x0, #0x6db7 // #28087 40021af8: f2b6db60 movk x0, #0xb6db, lsl #16 40021afc: f2db6da0 movk x0, #0xdb6d, lsl #32 40021b00: f2edb6c0 movk x0, #0x6db6, lsl #48 /* Add key for numbers not divisible by 7. */ if (cnt % 7 != 0) 40021b04: d2849241 mov x1, #0x2492 // #9362 40021b08: f2b24921 movk x1, #0x9249, lsl #16 SHA512_Update(&ctx, s_bytes, salt_len); 40021b0c: 9b007e60 mul x0, x19, x0 if (cnt % 7 != 0) 40021b10: f2c92481 movk x1, #0x4924, lsl #32 40021b14: f2e49241 movk x1, #0x2492, lsl #48 40021b18: eb01001f cmp x0, x1 40021b1c: 54001c28 b.hi 40021ea0 // b.pmore SHA512_Update(&ctx, p_bytes, key_len); /* Add key or last result. */ if ((cnt & 1) != 0) 40021b20: b4001cb7 cbz x23, 40021eb4 SHA512_Update(&ctx, alt_result, 64); 40021b24: 910283a1 add x1, x29, #0xa0 40021b28: 910483a0 add x0, x29, #0x120 40021b2c: d2800802 mov x2, #0x40 // #64 40021b30: 94001f78 bl 40029910 for (cnt = 0; cnt < rounds; ++cnt) { 40021b34: 91000673 add x19, x19, #0x1 else SHA512_Update(&ctx, p_bytes, key_len); /* Create intermediate result. */ SHA512_Final(alt_result, &ctx); 40021b38: 910483a1 add x1, x29, #0x120 40021b3c: 910283a0 add x0, x29, #0xa0 40021b40: 94001fac bl 400299f0 for (cnt = 0; cnt < rounds; ++cnt) { 40021b44: eb13033f cmp x25, x19 40021b48: 54fffc01 b.ne 40021ac8 // b.any } /* Now we can construct the result string. It consists of three * parts. */ cp = stpncpy(buffer, sha512_salt_prefix, MAX(0, buflen)); 40021b4c: b9408fb3 ldr w19, [x29, #140] 40021b50: d00000c1 adrp x1, 4003b000 40021b54: 913b4021 add x1, x1, #0xed0 40021b58: f9403fa0 ldr x0, [x29, #120] 40021b5c: 7100027f cmp w19, #0x0 40021b60: 1a9fa262 csel w2, w19, wzr, ge // ge = tcont 40021b64: 93407c42 sxtw x2, w2 40021b68: 9400469a bl 400335d0 buflen -= sizeof(sha512_salt_prefix) - 1; if (rounds_custom) { 40021b6c: b94077a1 ldr w1, [x29, #116] buflen -= sizeof(sha512_salt_prefix) - 1; 40021b70: 71000e73 subs w19, w19, #0x3 n = snprintf(cp, MAX(0, buflen), "%s%zu$", 40021b74: 1a9f5262 csel w2, w19, wzr, pl // pl = nfrst buflen -= sizeof(sha512_salt_prefix) - 1; 40021b78: b9008fb3 str w19, [x29, #140] cp = stpncpy(buffer, sha512_salt_prefix, MAX(0, buflen)); 40021b7c: f9004ba0 str x0, [x29, #144] 40021b80: aa0003e3 mov x3, x0 n = snprintf(cp, MAX(0, buflen), "%s%zu$", 40021b84: 93407c42 sxtw x2, w2 if (rounds_custom) { 40021b88: 35001cc1 cbnz w1, 40021f20 cp += n; buflen -= n; } cp = stpncpy(cp, salt, MIN((size_t)MAX(0, buflen), salt_len)); 40021b8c: eb0202bf cmp x21, x2 40021b90: aa1603e1 mov x1, x22 40021b94: 9a8292a2 csel x2, x21, x2, ls // ls = plast 40021b98: aa0303e0 mov x0, x3 40021b9c: 9400468d bl 400335d0 40021ba0: f9004ba0 str x0, [x29, #144] buflen -= MIN((size_t)MAX(0, buflen), salt_len); 40021ba4: b9408fa1 ldr w1, [x29, #140] 40021ba8: 7100003f cmp w1, #0x0 40021bac: 1a9fa022 csel w2, w1, wzr, ge // ge = tcont 40021bb0: 93407c42 sxtw x2, w2 40021bb4: eb15005f cmp x2, x21 40021bb8: 9a959055 csel x21, x2, x21, ls // ls = plast 40021bbc: 4b150021 sub w1, w1, w21 40021bc0: b9008fa1 str w1, [x29, #140] if (buflen > 0) { 40021bc4: 7100003f cmp w1, #0x0 40021bc8: 5400010d b.le 40021be8 <== NEVER TAKEN *cp++ = '$'; 40021bcc: 91000401 add x1, x0, #0x1 40021bd0: f9004ba1 str x1, [x29, #144] 40021bd4: 52800481 mov w1, #0x24 // #36 40021bd8: 39000001 strb w1, [x0] --buflen; 40021bdc: b9408fa0 ldr w0, [x29, #140] 40021be0: 51000400 sub w0, w0, #0x1 40021be4: b9008fa0 str w0, [x29, #140] } b64_from_24bit(alt_result[0], alt_result[21], alt_result[42], 4, &buflen, &cp); 40021be8: 394283a0 ldrb w0, [x29, #160] 40021bec: 910243a5 add x5, x29, #0x90 40021bf0: 3942d7a1 ldrb w1, [x29, #181] 40021bf4: 910233a4 add x4, x29, #0x8c 40021bf8: 39432ba2 ldrb w2, [x29, #202] 40021bfc: 52800083 mov w3, #0x4 // #4 40021c00: 94000114 bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[22], alt_result[43], alt_result[1], 4, &buflen, &cp); 40021c04: 394287a2 ldrb w2, [x29, #161] 40021c08: 910243a5 add x5, x29, #0x90 40021c0c: 3942dba0 ldrb w0, [x29, #182] 40021c10: 910233a4 add x4, x29, #0x8c 40021c14: 39432fa1 ldrb w1, [x29, #203] 40021c18: 52800083 mov w3, #0x4 // #4 40021c1c: 9400010d bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[44], alt_result[2], alt_result[23], 4, &buflen, &cp); 40021c20: 39428ba1 ldrb w1, [x29, #162] 40021c24: 910243a5 add x5, x29, #0x90 40021c28: 3942dfa2 ldrb w2, [x29, #183] 40021c2c: 910233a4 add x4, x29, #0x8c 40021c30: 394333a0 ldrb w0, [x29, #204] 40021c34: 52800083 mov w3, #0x4 // #4 40021c38: 94000106 bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[3], alt_result[24], alt_result[45], 4, &buflen, &cp); 40021c3c: 39428fa0 ldrb w0, [x29, #163] 40021c40: 910243a5 add x5, x29, #0x90 40021c44: 3942e3a1 ldrb w1, [x29, #184] 40021c48: 910233a4 add x4, x29, #0x8c 40021c4c: 394337a2 ldrb w2, [x29, #205] 40021c50: 52800083 mov w3, #0x4 // #4 40021c54: 940000ff bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[25], alt_result[46], alt_result[4], 4, &buflen, &cp); 40021c58: 394293a2 ldrb w2, [x29, #164] 40021c5c: 910243a5 add x5, x29, #0x90 40021c60: 3942e7a0 ldrb w0, [x29, #185] 40021c64: 910233a4 add x4, x29, #0x8c 40021c68: 39433ba1 ldrb w1, [x29, #206] 40021c6c: 52800083 mov w3, #0x4 // #4 40021c70: 940000f8 bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[47], alt_result[5], alt_result[26], 4, &buflen, &cp); 40021c74: 394297a1 ldrb w1, [x29, #165] 40021c78: 910243a5 add x5, x29, #0x90 40021c7c: 3942eba2 ldrb w2, [x29, #186] 40021c80: 910233a4 add x4, x29, #0x8c 40021c84: 39433fa0 ldrb w0, [x29, #207] 40021c88: 52800083 mov w3, #0x4 // #4 40021c8c: 940000f1 bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[6], alt_result[27], alt_result[48], 4, &buflen, &cp); 40021c90: 39429ba0 ldrb w0, [x29, #166] 40021c94: 910243a5 add x5, x29, #0x90 40021c98: 3942efa1 ldrb w1, [x29, #187] 40021c9c: 910233a4 add x4, x29, #0x8c 40021ca0: 394343a2 ldrb w2, [x29, #208] 40021ca4: 52800083 mov w3, #0x4 // #4 40021ca8: 940000ea bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[28], alt_result[49], alt_result[7], 4, &buflen, &cp); 40021cac: 39429fa2 ldrb w2, [x29, #167] 40021cb0: 910243a5 add x5, x29, #0x90 40021cb4: 3942f3a0 ldrb w0, [x29, #188] 40021cb8: 910233a4 add x4, x29, #0x8c 40021cbc: 394347a1 ldrb w1, [x29, #209] 40021cc0: 52800083 mov w3, #0x4 // #4 40021cc4: 940000e3 bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[50], alt_result[8], alt_result[29], 4, &buflen, &cp); 40021cc8: 3942a3a1 ldrb w1, [x29, #168] 40021ccc: 910243a5 add x5, x29, #0x90 40021cd0: 3942f7a2 ldrb w2, [x29, #189] 40021cd4: 910233a4 add x4, x29, #0x8c 40021cd8: 39434ba0 ldrb w0, [x29, #210] 40021cdc: 52800083 mov w3, #0x4 // #4 40021ce0: 940000dc bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[9], alt_result[30], alt_result[51], 4, &buflen, &cp); 40021ce4: 3942a7a0 ldrb w0, [x29, #169] 40021ce8: 910243a5 add x5, x29, #0x90 40021cec: 3942fba1 ldrb w1, [x29, #190] 40021cf0: 910233a4 add x4, x29, #0x8c 40021cf4: 39434fa2 ldrb w2, [x29, #211] 40021cf8: 52800083 mov w3, #0x4 // #4 40021cfc: 940000d5 bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[31], alt_result[52], alt_result[10], 4, &buflen, &cp); 40021d00: 3942aba2 ldrb w2, [x29, #170] 40021d04: 910243a5 add x5, x29, #0x90 40021d08: 3942ffa0 ldrb w0, [x29, #191] 40021d0c: 910233a4 add x4, x29, #0x8c 40021d10: 394353a1 ldrb w1, [x29, #212] 40021d14: 52800083 mov w3, #0x4 // #4 40021d18: 940000ce bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[53], alt_result[11], alt_result[32], 4, &buflen, &cp); 40021d1c: 3942afa1 ldrb w1, [x29, #171] 40021d20: 910243a5 add x5, x29, #0x90 40021d24: 394303a2 ldrb w2, [x29, #192] 40021d28: 910233a4 add x4, x29, #0x8c 40021d2c: 394357a0 ldrb w0, [x29, #213] 40021d30: 52800083 mov w3, #0x4 // #4 40021d34: 940000c7 bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[12], alt_result[33], alt_result[54], 4, &buflen, &cp); 40021d38: 3942b3a0 ldrb w0, [x29, #172] 40021d3c: 910243a5 add x5, x29, #0x90 40021d40: 394307a1 ldrb w1, [x29, #193] 40021d44: 910233a4 add x4, x29, #0x8c 40021d48: 39435ba2 ldrb w2, [x29, #214] 40021d4c: 52800083 mov w3, #0x4 // #4 40021d50: 940000c0 bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[34], alt_result[55], alt_result[13], 4, &buflen, &cp); 40021d54: 3942b7a2 ldrb w2, [x29, #173] 40021d58: 910243a5 add x5, x29, #0x90 40021d5c: 39430ba0 ldrb w0, [x29, #194] 40021d60: 910233a4 add x4, x29, #0x8c 40021d64: 39435fa1 ldrb w1, [x29, #215] 40021d68: 52800083 mov w3, #0x4 // #4 40021d6c: 940000b9 bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[56], alt_result[14], alt_result[35], 4, &buflen, &cp); 40021d70: 3942bba1 ldrb w1, [x29, #174] 40021d74: 910243a5 add x5, x29, #0x90 40021d78: 39430fa2 ldrb w2, [x29, #195] 40021d7c: 910233a4 add x4, x29, #0x8c 40021d80: 394363a0 ldrb w0, [x29, #216] 40021d84: 52800083 mov w3, #0x4 // #4 40021d88: 940000b2 bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[15], alt_result[36], alt_result[57], 4, &buflen, &cp); 40021d8c: 3942bfa0 ldrb w0, [x29, #175] 40021d90: 910243a5 add x5, x29, #0x90 40021d94: 394313a1 ldrb w1, [x29, #196] 40021d98: 910233a4 add x4, x29, #0x8c 40021d9c: 394367a2 ldrb w2, [x29, #217] 40021da0: 52800083 mov w3, #0x4 // #4 40021da4: 940000ab bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[37], alt_result[58], alt_result[16], 4, &buflen, &cp); 40021da8: 3942c3a2 ldrb w2, [x29, #176] 40021dac: 910243a5 add x5, x29, #0x90 40021db0: 394317a0 ldrb w0, [x29, #197] 40021db4: 910233a4 add x4, x29, #0x8c 40021db8: 39436ba1 ldrb w1, [x29, #218] 40021dbc: 52800083 mov w3, #0x4 // #4 40021dc0: 940000a4 bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[59], alt_result[17], alt_result[38], 4, &buflen, &cp); 40021dc4: 3942c7a1 ldrb w1, [x29, #177] 40021dc8: 910243a5 add x5, x29, #0x90 40021dcc: 39431ba2 ldrb w2, [x29, #198] 40021dd0: 910233a4 add x4, x29, #0x8c 40021dd4: 39436fa0 ldrb w0, [x29, #219] 40021dd8: 52800083 mov w3, #0x4 // #4 40021ddc: 9400009d bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[18], alt_result[39], alt_result[60], 4, &buflen, &cp); 40021de0: 3942cba0 ldrb w0, [x29, #178] 40021de4: 910243a5 add x5, x29, #0x90 40021de8: 39431fa1 ldrb w1, [x29, #199] 40021dec: 910233a4 add x4, x29, #0x8c 40021df0: 394373a2 ldrb w2, [x29, #220] 40021df4: 52800083 mov w3, #0x4 // #4 40021df8: 94000096 bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[40], alt_result[61], alt_result[19], 4, &buflen, &cp); 40021dfc: 3942cfa2 ldrb w2, [x29, #179] 40021e00: 910243a5 add x5, x29, #0x90 40021e04: 394323a0 ldrb w0, [x29, #200] 40021e08: 910233a4 add x4, x29, #0x8c 40021e0c: 394377a1 ldrb w1, [x29, #221] 40021e10: 52800083 mov w3, #0x4 // #4 40021e14: 9400008f bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(alt_result[62], alt_result[20], alt_result[41], 4, &buflen, &cp); 40021e18: 3942d3a1 ldrb w1, [x29, #180] 40021e1c: 910243a5 add x5, x29, #0x90 40021e20: 394327a2 ldrb w2, [x29, #201] 40021e24: 910233a4 add x4, x29, #0x8c 40021e28: 39437ba0 ldrb w0, [x29, #222] 40021e2c: 52800083 mov w3, #0x4 // #4 40021e30: 94000088 bl 40022050 <_crypt_b64_from_24bit> b64_from_24bit(0, 0, alt_result[63], 2, &buflen, &cp); 40021e34: 39437fa2 ldrb w2, [x29, #223] 40021e38: 52800000 mov w0, #0x0 // #0 40021e3c: 910243a5 add x5, x29, #0x90 40021e40: 910233a4 add x4, x29, #0x8c 40021e44: 52800043 mov w3, #0x2 // #2 40021e48: 52800001 mov w1, #0x0 // #0 40021e4c: 94000081 bl 40022050 <_crypt_b64_from_24bit> if (buflen <= 0) { 40021e50: b9408fa0 ldr w0, [x29, #140] 40021e54: 7100001f cmp w0, #0x0 40021e58: 54000a8d b.le 40021fa8 <== NEVER TAKEN errno = ERANGE; buffer = NULL; } else *cp = '\0'; /* Terminate the string. */ 40021e5c: f9404ba0 ldr x0, [x29, #144] 40021e60: 3900001f strb wzr, [x0] /* 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); 40021e64: 910483a0 add x0, x29, #0x120 40021e68: 94001e82 bl 40029870 SHA512_Final(alt_result, &ctx); 40021e6c: 910483a1 add x1, x29, #0x120 40021e70: 910283a0 add x0, x29, #0xa0 40021e74: 94001edf bl 400299f0 memset(copied_key, '\0', key_len); if (copied_salt != NULL) memset(copied_salt, '\0', salt_len); return buffer; } 40021e78: f9403fa0 ldr x0, [x29, #120] 40021e7c: 910003bf mov sp, x29 40021e80: a9407bfd ldp x29, x30, [sp] 40021e84: a94153f3 ldp x19, x20, [sp, #16] 40021e88: a9425bf5 ldp x21, x22, [sp, #32] 40021e8c: a94363f7 ldp x23, x24, [sp, #48] 40021e90: a9446bf9 ldp x25, x26, [sp, #64] 40021e94: a94573fb ldp x27, x28, [sp, #80] 40021e98: 910b03ff add sp, sp, #0x2c0 40021e9c: d65f03c0 ret SHA512_Update(&ctx, p_bytes, key_len); 40021ea0: aa1403e2 mov x2, x20 40021ea4: aa1803e1 mov x1, x24 40021ea8: 910483a0 add x0, x29, #0x120 40021eac: 94001e99 bl 40029910 if ((cnt & 1) != 0) 40021eb0: b5ffe3b7 cbnz x23, 40021b24 SHA512_Update(&ctx, p_bytes, key_len); 40021eb4: aa1403e2 mov x2, x20 40021eb8: aa1803e1 mov x1, x24 40021ebc: 910483a0 add x0, x29, #0x120 40021ec0: 94001e94 bl 40029910 40021ec4: 17ffff1c b 40021b34 SHA512_Update(&ctx, alt_result, 64); 40021ec8: 910483a0 add x0, x29, #0x120 40021ecc: 910283a1 add x1, x29, #0xa0 40021ed0: d2800802 mov x2, #0x40 // #64 40021ed4: 94001e8f bl 40029910 40021ed8: 9b1b7e60 mul x0, x19, x27 if (cnt % 3 != 0) 40021edc: eb1a001f cmp x0, x26 40021ee0: 54ffe0a9 b.ls 40021af4 // b.plast SHA512_Update(&ctx, s_bytes, salt_len); 40021ee4: aa1503e2 mov x2, x21 40021ee8: aa1c03e1 mov x1, x28 40021eec: 910483a0 add x0, x29, #0x120 40021ef0: 94001e88 bl 40029910 40021ef4: 17ffff00 b 40021af4 SHA512_Update(&ctx, key, key_len); 40021ef8: aa1403e2 mov x2, x20 40021efc: aa1703e1 mov x1, x23 40021f00: 910483a0 add x0, x29, #0x120 40021f04: 94001e83 bl 40029910 40021f08: 17fffeab b 400219b4 if (strncmp(sha512_salt_prefix, salt, sizeof(sha512_salt_prefix) - 1) == 0) 40021f0c: 39400ac2 ldrb w2, [x22, #2] salt += sizeof(sha512_salt_prefix) - 1; 40021f10: 91000ec1 add x1, x22, #0x3 40021f14: 6b02001f cmp w0, w2 40021f18: 9a960036 csel x22, x1, x22, eq // eq = none 40021f1c: 17fffe5d b 40021890 n = snprintf(cp, MAX(0, buflen), "%s%zu$", 40021f20: f94037a3 ldr x3, [x29, #104] 40021f24: aa0203e1 mov x1, x2 40021f28: aa1903e4 mov x4, x25 40021f2c: d00000c2 adrp x2, 4003b000 40021f30: 913a8042 add x2, x2, #0xea0 40021f34: 94004550 bl 40033474 buflen -= n; 40021f38: b9408fa2 ldr w2, [x29, #140] cp += n; 40021f3c: f9404ba3 ldr x3, [x29, #144] buflen -= n; 40021f40: 6b000042 subs w2, w2, w0 40021f44: b9008fa2 str w2, [x29, #140] cp = stpncpy(cp, salt, MIN((size_t)MAX(0, buflen), salt_len)); 40021f48: 1a9f5042 csel w2, w2, wzr, pl // pl = nfrst cp += n; 40021f4c: 8b20c063 add x3, x3, w0, sxtw cp = stpncpy(cp, salt, MIN((size_t)MAX(0, buflen), salt_len)); 40021f50: 93407c42 sxtw x2, w2 cp += n; 40021f54: f9004ba3 str x3, [x29, #144] buflen -= n; 40021f58: 17ffff0d b 40021b8c srounds = strtoul(num, &endp, 10); 40021f5c: 910263a1 add x1, x29, #0x98 40021f60: 52800142 mov w2, #0xa // #10 40021f64: 91001ec0 add x0, x22, #0x7 40021f68: 940047b7 bl 40033e44 if (*endp == '$') { 40021f6c: f9404fa1 ldr x1, [x29, #152] 40021f70: 39400022 ldrb w2, [x1] 40021f74: 7100905f cmp w2, #0x24 40021f78: 54ffca01 b.ne 400218b8 // b.any <== NEVER TAKEN rounds = MAX(ROUNDS_MIN, MIN(srounds, ROUNDS_MAX)); 40021f7c: d2993ff9 mov x25, #0xc9ff // #51711 40021f80: f2a77359 movk x25, #0x3b9a, lsl #16 40021f84: eb19001f cmp x0, x25 salt = endp + 1; 40021f88: 91000436 add x22, x1, #0x1 rounds = MAX(ROUNDS_MIN, MIN(srounds, ROUNDS_MAX)); 40021f8c: 9a999019 csel x25, x0, x25, ls // ls = plast 40021f90: d2807d00 mov x0, #0x3e8 // #1000 40021f94: f10fa33f cmp x25, #0x3e8 40021f98: 9a802339 csel x25, x25, x0, cs // cs = hs, nlast rounds_custom = true; 40021f9c: 52800020 mov w0, #0x1 // #1 40021fa0: b90077a0 str w0, [x29, #116] 40021fa4: 17fffe45 b 400218b8 errno = ERANGE; 40021fa8: 9400443d bl 4003309c <__errno> <== NOT EXECUTED buffer = NULL; 40021fac: f9003fbf str xzr, [x29, #120] <== NOT EXECUTED errno = ERANGE; 40021fb0: 52800441 mov w1, #0x22 // #34 <== NOT EXECUTED 40021fb4: b9000001 str w1, [x0] <== NOT EXECUTED buffer = NULL; 40021fb8: 17ffffab b 40021e64 <== NOT EXECUTED SHA512_Update(&ctx, alt_result, cnt); 40021fbc: aa1403e2 mov x2, x20 40021fc0: 910283a1 add x1, x29, #0xa0 40021fc4: 910483a0 add x0, x29, #0x120 40021fc8: 94001e52 bl 40029910 for (cnt = key_len; cnt > 0; cnt >>= 1) 40021fcc: b5ffce74 cbnz x20, 40021998 <== ALWAYS TAKEN SHA512_Final(alt_result, &ctx); 40021fd0: 910483a1 add x1, x29, #0x120 <== NOT EXECUTED 40021fd4: 910283a0 add x0, x29, #0xa0 <== NOT EXECUTED 40021fd8: 94001e86 bl 400299f0 <== NOT EXECUTED SHA512_Final(temp_result, &alt_ctx); 40021fdc: 910383b7 add x23, x29, #0xe0 <== NOT EXECUTED SHA512_Init(&alt_ctx); 40021fe0: 9107c3a0 add x0, x29, #0x1f0 <== NOT EXECUTED cp = p_bytes = alloca(key_len); 40021fe4: 910003f8 mov x24, sp <== NOT EXECUTED SHA512_Init(&alt_ctx); 40021fe8: 94001e22 bl 40029870 <== NOT EXECUTED SHA512_Final(temp_result, &alt_ctx); 40021fec: aa1703e0 mov x0, x23 <== NOT EXECUTED 40021ff0: 9107c3a1 add x1, x29, #0x1f0 <== NOT EXECUTED 40021ff4: 94001e7f bl 400299f0 <== NOT EXECUTED cp = p_bytes = alloca(key_len); 40021ff8: f9004bb8 str x24, [x29, #144] <== NOT EXECUTED 40021ffc: 910003e0 mov x0, sp <== NOT EXECUTED 40022000: d2800002 mov x2, #0x0 // #0 <== NOT EXECUTED 40022004: 17fffe91 b 40021a48 <== NOT EXECUTED for (cnt = key_len; cnt >= 64; cnt -= 64) { 40022008: aa1403e2 mov x2, x20 4002200c: 17fffe8f b 40021a48