name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
test | int test(LIBSSH2_SESSION *session)
{
#if LIBSSH2_RSA_SHA1 && \
(defined(LIBSSH2_OPENSSL) || defined(LIBSSH2_WOLFSSL))
/* set in Dockerfile */
return test_auth_pubkey(session, 0,
"libssh2",
NULL,
"key_rsa_signed-cert.pub",
"key_rsa_signed");
#else
(void)session;
return 0;
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
leaq 0x1bcb(%rip), %rdx # 0x4004
xorl %eax, %eax
movl %eax, %ecx
leaq 0x1bc8(%rip), %r8 # 0x400c
leaq 0x1bd9(%rip), %r9 # 0x4024
callq 0x2eb0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /sysprogs[P]libssh2/tests/test_auth_pubkey_ok_rsa_signed.c |
test_auth_keyboard | int test_auth_keyboard(LIBSSH2_SESSION *session, int flags,
const char *username,
const char *password)
{
int rc;
const char *userauth_list =
libssh2_userauth_list(session, username,
(unsigned int)strlen(username));
if(!userauth_list) {
print_last_session_error("libssh2_userauth_list");
return 1;
}
if(!strstr(userauth_list, "keyboard-interactive")) {
fprintf(stderr,
"'keyboard-interactive' was expected in userauth list: %s\n",
userauth_list);
return 1;
}
kbd_password = password;
rc = libssh2_userauth_keyboard_interactive_ex(session, username,
(unsigned int)strlen(username),
kbd_callback);
kbd_password = NULL;
if((flags & TEST_AUTH_SHOULDFAIL) != 0) {
if(rc == 0) {
fprintf(stderr, "Keyboard-interactive auth succeeded "
"with wrong response\n");
return 1;
}
}
else {
if(rc) {
print_last_session_error(
"libssh2_userauth_keyboard_interactive_ex");
return 1;
}
}
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x20f0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl %eax, %edx
callq 0x21d0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x2b42
leaq 0x17f6(%rip), %rdi # 0x4327
callq 0x28b0
movl $0x1, -0x4(%rbp)
jmp 0x2c20
movq -0x38(%rbp), %rdi
leaq 0x17f0(%rip), %rsi # 0x433d
callq 0x2070
cmpq $0x0, %rax
jne 0x2b80
movq 0x4481(%rip), %rax # 0x6fe0
movq (%rax), %rdi
movq -0x38(%rbp), %rdx
leaq 0x17e5(%rip), %rsi # 0x4352
movb $0x0, %al
callq 0x2290
movl $0x1, -0x4(%rbp)
jmp 0x2c20
movq -0x28(%rbp), %rax
movq %rax, 0x2464d(%rip) # 0x271d8
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rdi
callq 0x20f0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movl %eax, %edx
leaq 0x7b(%rip), %rcx # 0x2c30
callq 0x2180
movl %eax, -0x2c(%rbp)
movq $0x0, 0x24610(%rip) # 0x271d8
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2bfc
cmpl $0x0, -0x2c(%rbp)
jne 0x2bfa
movq 0x4400(%rip), %rax # 0x6fe0
movq (%rax), %rdi
leaq 0x17a2(%rip), %rsi # 0x438c
movb $0x0, %al
callq 0x2290
movl $0x1, -0x4(%rbp)
jmp 0x2c20
jmp 0x2c19
cmpl $0x0, -0x2c(%rbp)
je 0x2c17
leaq 0x17bc(%rip), %rdi # 0x43c5
callq 0x28b0
movl $0x1, -0x4(%rbp)
jmp 0x2c20
jmp 0x2c19
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| /sysprogs[P]libssh2/tests/session_fixture.c |
read_file | static int read_file(const char *path, char **out_buffer, size_t *out_len)
{
FILE *fp;
char *buffer;
size_t len;
if(!out_buffer || !out_len || !path) {
fprintf(stderr, "invalid params.\n");
return 1;
}
*out_buffer = NULL;
*out_len = 0;
fp = fopen(path, "r");
if(!fp) {
fprintf(stderr, "File could not be read: %s\n", path);
return 1;
}
fseek(fp, 0L, SEEK_END);
len = ftell(fp);
rewind(fp);
buffer = calloc(1, len + 1);
if(!buffer) {
fclose(fp);
fprintf(stderr, "Could not alloc memory.\n");
return 1;
}
if(1 != fread(buffer, len, 1, fp)) {
fclose(fp);
free(buffer);
fprintf(stderr, "Could not read file into memory.\n");
return 1;
}
fclose(fp);
*out_buffer = buffer;
*out_len = len;
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3139
cmpq $0x0, -0x20(%rbp)
je 0x3139
cmpq $0x0, -0x10(%rbp)
jne 0x315d
movq 0x3ea0(%rip), %rax # 0x6fe0
movq (%rax), %rdi
leaq 0x147e(%rip), %rsi # 0x45c8
movb $0x0, %al
callq 0x2290
movl $0x1, -0x4(%rbp)
jmp 0x32a1
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
leaq 0x18c8(%rip), %rsi # 0x4a46
callq 0x21f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x31b6
movq 0x3e4b(%rip), %rax # 0x6fe0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x1436(%rip), %rsi # 0x45d9
movb $0x0, %al
callq 0x2290
movl $0x1, -0x4(%rbp)
jmp 0x32a1
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x21e0
movq -0x28(%rbp), %rdi
callq 0x2030
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2050
movq -0x38(%rbp), %rsi
addq $0x1, %rsi
movl $0x1, %edi
callq 0x2130
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x3225
movq -0x28(%rbp), %rdi
callq 0x2190
movq 0x3dd5(%rip), %rax # 0x6fe0
movq (%rax), %rdi
leaq 0x13e0(%rip), %rsi # 0x45f5
movb $0x0, %al
callq 0x2290
movl $0x1, -0x4(%rbp)
jmp 0x32a1
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rcx
movl $0x1, %edx
callq 0x22a0
movq %rax, %rcx
movl $0x1, %eax
cmpq %rcx, %rax
je 0x327b
movq -0x28(%rbp), %rdi
callq 0x2190
movq -0x30(%rbp), %rdi
callq 0x2200
movq 0x3d7f(%rip), %rax # 0x6fe0
movq (%rax), %rdi
leaq 0x13a3(%rip), %rsi # 0x460e
movb $0x0, %al
callq 0x2290
movl $0x1, -0x4(%rbp)
jmp 0x32a1
movq -0x28(%rbp), %rdi
callq 0x2190
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /sysprogs[P]libssh2/tests/session_fixture.c |
port_from_container | static int port_from_container(char *container_id, char **port_out)
{
if(is_running_inside_a_container()) {
*port_out = strdup("22");
return 0;
}
else {
return run_command(port_out,
"docker inspect --format "
"\"{{ index (index (index .NetworkSettings.Ports "
"\\\"22/tcp\\\") 0) \\\"HostPort\\\" }}\" %s",
container_id);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x3da0
cmpl $0x0, %eax
je 0x3d39
leaq 0xd27(%rip), %rdi # 0x4a48
callq 0x22f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x3d52
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0xd03(%rip), %rsi # 0x4a4b
movb $0x0, %al
callq 0x3850
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /sysprogs[P]libssh2/tests/openssh_fixture.c |
assert_int_eq(int, int, char const*, int) | int assert_int_eq(int a, int b, const char *testcase, int line)
{
test_counter++;
int err = a!=b;
if(err) {
printf("not ok %d - %s...\n", test_counter, testcase);
printf("# Expected %d, but observed %d instead (line %d)\n", a, b, line);
global_err++;
} else
printf("ok %d - %s...\n", test_counter, testcase);
return err;
} | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
movl 0x5eaa(%rip), %esi # 0x70a4
incl %esi
movl %esi, 0x5ea2(%rip) # 0x70a4
cmpl %ebx, %edi
je 0x1234
movl %ecx, %r14d
leaq 0x2e00(%rip), %rdi # 0x4010
xorl %eax, %eax
callq 0x1030
leaq 0x2e05(%rip), %rdi # 0x4023
movl %ebp, %esi
movl %ebx, %edx
movl %r14d, %ecx
xorl %eax, %eax
callq 0x1030
incl 0x5e6e(%rip) # 0x70a0
jmp 0x1242
leaq 0x2dd9(%rip), %rdi # 0x4014
xorl %eax, %eax
callq 0x1030
xorl %eax, %eax
cmpl %ebx, %ebp
setne %al
popq %rbx
popq %r14
popq %rbp
retq
| /fundamental[P]rtosc/test/common.h |
strings() | void strings()
{
l[0].type = l[1].type = 's';
l[0].val.s = "rtosc rtosc rtosc";
l[1].val.s = "rtosc";
r[0].val.s = "rt0sc";
r[1].val.s = "";
cmp_gt(l, r, 1, 1, NULL, "one string", "another string", __LINE__);
cmp_gt(l, l+1, 1, 1, NULL, "one string", "subset string", __LINE__);
cmp_gt(r, r+1, 1, 1, NULL, "normal string", "empty string", __LINE__);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movb $0x73, %al
movb %al, 0x4f46(%rip) # 0x70c8
leaq 0x4f3f(%rip), %r14 # 0x70c8
leaq 0x4f20(%rip), %r15 # 0x70b0
movb %al, 0x4f1a(%rip) # 0x70b0
leaq 0x21b0(%rip), %rax # 0x434d
movq %rax, 0x4f14(%rip) # 0x70b8
leaq 0x21ae(%rip), %rax # 0x4359
movq %rax, 0x4f1e(%rip) # 0x70d0
leaq 0x21a6(%rip), %rax # 0x435f
movq %rax, 0x4f48(%rip) # 0x7108
leaq 0x4f39(%rip), %rbx # 0x7100
leaq 0x207d(%rip), %rax # 0x424b
movq %rax, 0x4f4b(%rip) # 0x7120
leaq 0x2194(%rip), %rax # 0x4370
leaq 0x2182(%rip), %r12 # 0x4365
movl $0x1, %edx
movl $0x1, %ecx
movq %r15, %rdi
movq %rbx, %rsi
xorl %r8d, %r8d
movq %r12, %r9
pushq $0xb7
pushq %rax
callq 0x1af9
addq $0x10, %rsp
leaq 0x2170(%rip), %rax # 0x437f
movl $0x1, %edx
movl $0x1, %ecx
movq %r15, %rdi
movq %r14, %rsi
xorl %r8d, %r8d
movq %r12, %r9
pushq $0xb8
pushq %rax
callq 0x1af9
addq $0x10, %rsp
leaq 0x2160(%rip), %rax # 0x439b
leaq 0x4ed6(%rip), %rsi # 0x7118
leaq 0x2144(%rip), %r9 # 0x438d
movl $0x1, %edx
movl $0x1, %ecx
movq %rbx, %rdi
xorl %r8d, %r8d
pushq $0xb9
pushq %rax
callq 0x1af9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /fundamental[P]rtosc/test/arg-val-cmp.cpp |
rtosc_arg_vals_cmp_has_next | int rtosc_arg_vals_cmp_has_next(const rtosc_arg_val_itr* litr,
const rtosc_arg_val_itr* ritr,
size_t lsize, size_t rsize)
{
return (litr->i < lsize) && (ritr->i < rsize)
&& (litr->av->type != '-' || ritr->av->type != '-' ||
rtosc_av_rep_num(litr->av) || rtosc_av_rep_num(ritr->av));
} | pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpq %rdx, 0x8(%rdi)
jae 0x2dae
movq %rsi, %r14
cmpq %rcx, 0x8(%rsi)
jae 0x2dae
movq (%rdi), %rdi
movl $0x1, %ebx
cmpb $0x2d, (%rdi)
jne 0x2dae
movq (%r14), %rax
cmpb $0x2d, (%rax)
jne 0x2dae
callq 0x2d52
testl %eax, %eax
jne 0x2dae
movq (%r14), %rdi
callq 0x2d52
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /fundamental[P]rtosc/src/cpp/arg-val-cmp.c |
rtosc_arg_vals_eq_after_abort | int rtosc_arg_vals_eq_after_abort(const rtosc_arg_val_itr* litr,
const rtosc_arg_val_itr* ritr,
size_t lsize, size_t rsize)
{
return (litr->i == lsize ||
(litr->av->type == '-' && !rtosc_av_rep_num(litr->av)))
&& (ritr->i == rsize ||
(ritr->av->type == '-' && !rtosc_av_rep_num(ritr->av)));
} | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r15
movq %rsi, %r14
cmpq %rdx, 0x8(%rdi)
jne 0x2dec
movl $0x1, %ebx
cmpq %r15, 0x8(%r14)
je 0x2dff
movq (%r14), %rdi
xorl %ebx, %ebx
cmpb $0x2d, (%rdi)
jne 0x2dff
callq 0x2d52
xorl %ebx, %ebx
testl %eax, %eax
sete %bl
jmp 0x2dff
movq (%rdi), %rdi
xorl %ebx, %ebx
cmpb $0x2d, (%rdi)
jne 0x2dff
callq 0x2d52
testl %eax, %eax
je 0x2dc9
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
| /fundamental[P]rtosc/src/cpp/arg-val-cmp.c |
rtosc_arg_vals_eq_single | int rtosc_arg_vals_eq_single(const rtosc_arg_val_t* _lhs,
const rtosc_arg_val_t* _rhs,
const rtosc_cmp_options* opt)
{
#define mfabs(val) (((val) >= 0) ? (val) : -(val))
int rval;
if(!opt)
opt = &default_cmp_options;
if(_lhs->type == _rhs->type)
switch(_lhs->type)
{
case 'i':
case 'c':
case 'r':
rval = _lhs->val.i == _rhs->val.i;
break;
case 'I':
case 'T':
case 'F':
case 'N':
rval = 1;
break;
case 'f':
rval = (opt->float_tolerance == 0.0)
? _lhs->val.f == _rhs->val.f
: mfabs(_lhs->val.f - _rhs->val.f) <=
(float)opt->float_tolerance;
break;
case 'd':
rval = (opt->float_tolerance == 0.0)
? _lhs->val.d == _rhs->val.d
: mfabs(_lhs->val.d - _rhs->val.d) <=
opt->float_tolerance;
break;
case 'h':
rval = _lhs->val.h == _rhs->val.h;
break;
case 't':
rval = _lhs->val.t == _rhs->val.t;
break;
case 'm':
rval = 0 == memcmp(_lhs->val.m, _rhs->val.m, 4);
break;
case 's':
case 'S':
rval = (_lhs->val.s == NULL || _rhs->val.s == NULL)
? _lhs->val.s == _rhs->val.s
: (0 == strcmp(_lhs->val.s, _rhs->val.s));
break;
case 'b':
{
int32_t lbs = _lhs->val.b.len,
rbs = _rhs->val.b.len;
rval = lbs == rbs;
if(rval)
rval = 0 == memcmp(_lhs->val.b.data, _rhs->val.b.data, lbs);
break;
}
case 'a':
{
if( rtosc_av_arr_type(_lhs) != rtosc_av_arr_type(_rhs)
&& !(rtosc_av_arr_type(_lhs) == 'T' && rtosc_av_arr_type(_rhs) == 'F')
&& !(rtosc_av_arr_type(_lhs) == 'F' && rtosc_av_arr_type(_rhs) == 'T'))
rval = 0;
else
rval = rtosc_arg_vals_eq(_lhs+1, _rhs+1,
rtosc_av_arr_len(_lhs), rtosc_av_arr_len(_rhs),
opt);
break;
}
default:
rval = -1;
// no recovery: the programmer did not pass the right args, and
// we don't have a function to compare ranges here
assert(false);
exit(1);
break;
}
else
{
rval = 0;
}
return rval;
#undef mfabs
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
leaq 0x1804(%rip), %r15 # 0x4620
cmovneq %rdx, %r15
movzbl (%rdi), %ecx
cmpb (%rsi), %cl
jne 0x2ff6
movl $0x1, %eax
cmpl $0x52, %ecx
jle 0x2e5e
movq %rsi, %rbx
movq %rdi, %r14
leal -0x61(%rcx), %edx
cmpl $0x13, %edx
ja 0x2e7b
leaq 0x1736(%rip), %rax # 0x4580
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl 0x8(%r14), %ecx
xorl %eax, %eax
cmpl 0x8(%rbx), %ecx
jmp 0x2e9d
cmpl $0x46, %ecx
je 0x2ff8
cmpl $0x49, %ecx
je 0x2ff8
cmpl $0x4e, %ecx
je 0x2ff8
jmp 0x2e89
cmpl $0x53, %ecx
je 0x2ea5
cmpl $0x54, %ecx
je 0x2ff8
movl $0x1, %edi
callq 0x1090
movq 0x8(%r14), %rcx
xorl %eax, %eax
cmpq 0x8(%rbx), %rcx
sete %al
jmp 0x2ff8
movq 0x8(%r14), %rdi
movq 0x8(%rbx), %rsi
testq %rdi, %rdi
je 0x3009
testq %rsi, %rsi
je 0x3007
callq 0x10b0
testl %eax, %eax
jmp 0x300c
movsd (%r15), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movss 0x8(%r14), %xmm1
movss 0x8(%rbx), %xmm2
jne 0x3014
jp 0x3014
cmpeqss %xmm2, %xmm1
movd %xmm1, %eax
andl $0x1, %eax
jmp 0x303d
movslq 0x8(%r14), %rdx
movl $0x0, %eax
cmpl 0x8(%rbx), %edx
jne 0x2ff8
movq 0x10(%r14), %rdi
movq 0x10(%rbx), %rsi
callq 0x1070
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jmp 0x2e9d
movq %r14, %rdi
callq 0x2d41
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2d41
cmpb %al, %bpl
jne 0x2fb4
leaq 0x18(%r14), %r12
leaq 0x18(%rbx), %r13
movq %r14, %rdi
callq 0x2d45
movslq %eax, %r14
movq %rbx, %rdi
callq 0x2d45
movslq %eax, %rcx
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3073
movsd (%r15), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movsd 0x8(%r14), %xmm1
movsd 0x8(%rbx), %xmm2
jne 0x3042
jp 0x3042
cmpeqsd %xmm2, %xmm1
movq %xmm1, %rax
andl $0x1, %eax
jmp 0x306e
movq %r14, %rdi
callq 0x2d41
cmpb $0x54, %al
jne 0x2fd0
movq %rbx, %rdi
callq 0x2d41
cmpb $0x46, %al
je 0x2f41
movq %r14, %rdi
callq 0x2d41
cmpb $0x46, %al
jne 0x2ff6
movq %rbx, %rdi
callq 0x2d41
movl %eax, %ecx
movl $0x0, %eax
cmpb $0x54, %cl
je 0x2f41
jmp 0x2ff8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %esi, %esi
cmpq %rsi, %rdi
sete %al
movzbl %al, %eax
jmp 0x2ff8
subss %xmm2, %xmm1
movaps 0x1551(%rip), %xmm2 # 0x4570
xorps %xmm1, %xmm2
movaps %xmm2, %xmm3
cmpnless %xmm1, %xmm3
andps %xmm3, %xmm2
andnps %xmm1, %xmm3
cvtsd2ss %xmm0, %xmm0
orps %xmm2, %xmm3
ucomiss %xmm3, %xmm0
setae %al
movzbl %al, %eax
jmp 0x2ff8
subsd %xmm2, %xmm1
movapd 0x1512(%rip), %xmm2 # 0x4560
xorpd %xmm1, %xmm2
movapd %xmm2, %xmm3
cmpnlesd %xmm1, %xmm3
andpd %xmm3, %xmm2
andnpd %xmm1, %xmm3
orpd %xmm2, %xmm3
ucomisd %xmm3, %xmm0
setae %al
movzbl %al, %eax
jmp 0x2ff8
| /fundamental[P]rtosc/src/cpp/arg-val-cmp.c |
rtosc_arg_vals_eq | int rtosc_arg_vals_eq(const rtosc_arg_val_t* lhs, const rtosc_arg_val_t* rhs,
size_t lsize, size_t rsize,
const rtosc_cmp_options* opt)
{
// used if the value of lhs or rhs is range-computed:
rtosc_arg_val_t rlhs, rrhs;
rtosc_arg_val_itr litr, ritr;
rtosc_arg_val_itr_init(&litr, lhs);
rtosc_arg_val_itr_init(&ritr, rhs);
int rval = 1;
if(!opt)
opt = &default_cmp_options;
for( ; rtosc_arg_vals_cmp_has_next(&litr, &ritr, lsize, rsize) && rval;
rtosc_arg_val_itr_next(&litr),
rtosc_arg_val_itr_next(&ritr))
{
rval = rtosc_arg_vals_eq_single(rtosc_arg_val_itr_get(&litr, &rlhs),
rtosc_arg_val_itr_get(&ritr, &rrhs),
opt);
}
return rval
? rtosc_arg_vals_eq_after_abort(&litr, &ritr, lsize, rsize)
: rval;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rsi
leaq 0x20(%rsp), %r13
movq %r13, %rdi
callq 0x35c0
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0x35c0
testq %r12, %r12
leaq 0x1569(%rip), %r15 # 0x4620
cmovneq %r12, %r15
movq %r13, %rdi
movq %rbp, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2d6c
testl %eax, %eax
je 0x3137
leaq 0x20(%rsp), %r12
leaq 0x8(%rsp), %rbp
movq %r12, %rdi
leaq 0x50(%rsp), %rsi
callq 0x35d3
movq %rax, %r13
movq %rbp, %rdi
leaq 0x38(%rsp), %rsi
callq 0x35d3
movq %r13, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x2e07
movl %eax, %r13d
movq %r12, %rdi
callq 0x361e
movq %rbp, %rdi
callq 0x361e
movq %r12, %rdi
movq %rbp, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2d6c
testl %eax, %eax
je 0x3132
testl %r13d, %r13d
jne 0x30da
testl %r13d, %r13d
je 0x314e
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2db8
jmp 0x3150
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /fundamental[P]rtosc/src/cpp/arg-val-cmp.c |
rtosc_arg_vals_cmp_single | int rtosc_arg_vals_cmp_single(const rtosc_arg_val_t* _lhs,
const rtosc_arg_val_t* _rhs,
const rtosc_cmp_options* opt)
{
#define cmp_3way(val1,val2) (((val1) == (val2)) \
? 0 \
: (((val1) > (val2)) ? 1 : -1))
#define mfabs(val) (((val) >= 0) ? (val) : -(val))
int rval;
if(!opt)
opt = &default_cmp_options;
if(_lhs->type == _rhs->type)
switch(_lhs->type)
{
case 'i':
case 'c':
case 'r':
rval = cmp_3way(_lhs->val.i, _rhs->val.i);
break;
case 'I':
case 'T':
case 'F':
case 'N':
rval = 0;
break;
case 'f':
rval = (opt->float_tolerance == 0.0)
? cmp_3way(_lhs->val.f, _rhs->val.f)
: (mfabs(_lhs->val.f - _rhs->val.f)
<= (float)opt->float_tolerance)
? 0
: ((_lhs->val.f > _rhs->val.f) ? 1 : -1);
break;
case 'd':
rval = (opt->float_tolerance == 0.0)
? cmp_3way(_lhs->val.d, _rhs->val.d)
: (mfabs(_lhs->val.d - _rhs->val.d)
<= opt->float_tolerance)
? 0
: ((_lhs->val.d > _rhs->val.d) ? 1 : -1);
break;
case 'h':
rval = cmp_3way(_lhs->val.h, _rhs->val.h);
break;
case 't':
// immediately is considered lower than everything else
// this means if you send two events to a client,
// one being "immediately" and one being different, the
// immediately-event has the higher priority, event if the
// other one is in the past
rval = (_lhs->val.t == 1)
? (_rhs->val.t == 1)
? 0
: -1 // _lhs has higher priority => _lhs < _rhs
: (_rhs->val.t == 1)
? 1
: cmp_3way(_lhs->val.t, _rhs->val.t);
break;
case 'm':
rval = memcmp(_lhs->val.m, _rhs->val.m, 4);
break;
case 's':
case 'S':
rval = (_lhs->val.s == NULL || _rhs->val.s == NULL)
? cmp_3way(_lhs->val.s, _rhs->val.s)
: strcmp(_lhs->val.s, _rhs->val.s);
break;
case 'b':
{
int32_t lbs = _lhs->val.b.len,
rbs = _rhs->val.b.len;
int32_t minlen = (lbs < rbs) ? lbs : rbs;
rval = memcmp(_lhs->val.b.data, _rhs->val.b.data, minlen);
if(lbs != rbs && !rval)
{
// both equal until here
// the string that ends here is lexicographically smaller
rval = (lbs > rbs)
? _lhs->val.b.data[minlen]
: -_rhs->val.b.data[minlen];
}
break;
}
case 'a':
{
int32_t llen = rtosc_av_arr_len(_lhs), rlen = rtosc_av_arr_len(_rhs);
if( rtosc_av_arr_type(_lhs) != rtosc_av_arr_type(_rhs)
&& !(rtosc_av_arr_type(_lhs) == 'T' && rtosc_av_arr_type(_rhs))
&& !(rtosc_av_arr_type(_lhs) == 'F' && rtosc_av_arr_type(_rhs)))
rval = (rtosc_av_arr_type(_lhs) > rtosc_av_arr_type(_rhs)) ? 1 : -1;
else
{
// the arg vals differ in this array => compare and return
rval = rtosc_arg_vals_cmp(_lhs+1, _rhs+1, llen, rlen, opt);
}
break;
}
case '-':
rval = -1;
// no recovery: the programmer did not pass the right args, and
// we don't have a function to compare ranges here
assert(false);
break;
default:
rval = -1;
assert(false);
}
else
{
rval = (_lhs->type > _rhs->type) ? 1 : -1;
}
return rval;
#undef mfabs
#undef cmp_3way
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
leaq 0x14ac(%rip), %r15 # 0x4620
cmovneq %rdx, %r15
movzbl (%rdi), %ecx
movb (%rsi), %al
cmpb %al, %cl
jne 0x31b1
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
leal -0x61(%rcx), %edx
cmpl $0x13, %edx
ja 0x31ce
leaq 0x1438(%rip), %rcx # 0x45d0
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movl 0x8(%r14), %eax
xorl %ecx, %ecx
xorl %edx, %edx
cmpl 0x8(%rbx), %eax
jmp 0x3231
xorl %edx, %edx
cmpb %al, %cl
setg %dl
leal -0x1(,%rdx,2), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addl $-0x2d, %ecx
cmpl $0x27, %ecx
ja 0x321e
movabsq $0x8212000000, %rdx # imm = 0x8212000000
btq %rcx, %rdx
jb 0x31bf
testq %rcx, %rcx
je 0x321e
cmpq $0x26, %rcx
jne 0x321e
movq 0x8(%r14), %rdi
movq 0x8(%rbx), %rsi
testq %rdi, %rdi
je 0x33bc
testq %rsi, %rsi
je 0x33ea
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10b0
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x31bf
movq 0x8(%r14), %rax
xorl %ecx, %ecx
xorl %edx, %edx
cmpq 0x8(%rbx), %rax
setg %dl
leal -0x1(%rdx,%rdx), %eax
cmovel %ecx, %eax
jmp 0x31bf
movsd (%r15), %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
movss 0x8(%r14), %xmm0
movss 0x8(%rbx), %xmm1
jne 0x33fc
jp 0x33fc
ucomiss %xmm1, %xmm0
jmp 0x3388
movl 0x8(%r14), %ebp
movl 0x8(%rbx), %r12d
cmpl %r12d, %ebp
movl %r12d, %eax
cmovll %ebp, %eax
movq 0x10(%r14), %r14
movq 0x10(%rbx), %r15
movslq %eax, %rbx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1040
cmpl %r12d, %ebp
je 0x31bf
testl %eax, %eax
jne 0x31bf
cmpl %r12d, %ebp
jle 0x3484
movzbl (%r14,%rbx), %eax
jmp 0x31bf
movq %r14, %rdi
callq 0x2d45
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2d45
movl %eax, %r12d
movq %r14, %rdi
callq 0x2d41
movl %eax, %r13d
movq %rbx, %rdi
callq 0x2d41
cmpb %al, %r13b
je 0x331c
movq %r14, %rdi
callq 0x2d41
cmpb $0x54, %al
jne 0x32fc
movq %rbx, %rdi
callq 0x2d41
testb %al, %al
jne 0x331c
movq %r14, %rdi
callq 0x2d41
cmpb $0x46, %al
jne 0x3490
movq %rbx, %rdi
callq 0x2d41
testb %al, %al
je 0x3490
addq $0x18, %r14
addq $0x18, %rbx
movslq %ebp, %rdx
movslq %r12d, %rcx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34b6
movl 0x8(%r14), %ecx
movl 0x8(%rbx), %edx
bswapl %ecx
bswapl %edx
xorl %eax, %eax
cmpl %edx, %ecx
seta %al
sbbl $0x0, %eax
jmp 0x31bf
movsd (%r15), %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
movsd 0x8(%r14), %xmm0
movsd 0x8(%rbx), %xmm1
jne 0x3437
jp 0x3437
ucomisd %xmm1, %xmm0
movl $0x0, %eax
jne 0x3395
jnp 0x31bf
seta %al
movzbl %al, %eax
jmp 0x3478
movq 0x8(%r14), %rdx
movq 0x8(%rbx), %rcx
cmpq $0x1, %rdx
jne 0x33c6
xorl %eax, %eax
cmpq $0x1, %rcx
setne %al
jmp 0x3489
cmpq %rsi, %rdi
jne 0x33ec
jmp 0x31bf
movl $0x1, %eax
cmpq $0x1, %rcx
je 0x31bf
movl $0x0, %eax
cmpq %rcx, %rdx
je 0x31bf
xorl %eax, %eax
cmpq %rdx, %rcx
jmp 0x33f1
xorl %esi, %esi
xorl %eax, %eax
cmpq %rdi, %rsi
adcl $-0x1, %eax
orl $0x1, %eax
jmp 0x31bf
movaps %xmm0, %xmm3
subss %xmm1, %xmm3
movaps 0x1166(%rip), %xmm4 # 0x4570
xorps %xmm3, %xmm4
movaps %xmm4, %xmm5
cmpnless %xmm3, %xmm5
andps %xmm5, %xmm4
andnps %xmm3, %xmm5
cvtsd2ss %xmm2, %xmm2
orps %xmm4, %xmm5
ucomiss %xmm5, %xmm2
movl $0x0, %eax
jae 0x31bf
xorl %eax, %eax
ucomiss %xmm1, %xmm0
jmp 0x3475
movapd %xmm0, %xmm3
subsd %xmm1, %xmm3
movapd 0x1119(%rip), %xmm4 # 0x4560
xorpd %xmm3, %xmm4
movapd %xmm4, %xmm5
cmpnlesd %xmm3, %xmm5
andpd %xmm5, %xmm4
andnpd %xmm3, %xmm5
orpd %xmm4, %xmm5
ucomisd %xmm5, %xmm2
movl $0x0, %eax
jae 0x31bf
xorl %eax, %eax
ucomisd %xmm1, %xmm0
seta %al
leal -0x1(,%rax,2), %eax
jmp 0x31bf
movzbl (%r15,%rbx), %eax
negl %eax
jmp 0x31bf
movq %r14, %rdi
callq 0x2d41
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2d41
xorl %ecx, %ecx
cmpb %al, %bpl
setg %cl
leal -0x1(,%rcx,2), %eax
jmp 0x31bf
| /fundamental[P]rtosc/src/cpp/arg-val-cmp.c |
rtosc_arg_vals_cmp | int rtosc_arg_vals_cmp(const rtosc_arg_val_t* lhs, const rtosc_arg_val_t* rhs,
size_t lsize, size_t rsize,
const rtosc_cmp_options* opt)
{
// used if the value of lhs or rhs is range-computed:
rtosc_arg_val_t rlhs, rrhs;
rtosc_arg_val_itr litr, ritr;
rtosc_arg_val_itr_init(&litr, lhs);
rtosc_arg_val_itr_init(&ritr, rhs);
int rval = 0;
if(!opt)
opt = &default_cmp_options;
for( ; rtosc_arg_vals_cmp_has_next(&litr, &ritr, lsize, rsize) && !rval;
rtosc_arg_val_itr_next(&litr),
rtosc_arg_val_itr_next(&ritr))
{
rval = rtosc_arg_vals_cmp_single(rtosc_arg_val_itr_get(&litr, &rlhs),
rtosc_arg_val_itr_get(&ritr, &rrhs),
opt);
}
return rval ? rval
: (rtosc_arg_vals_eq_after_abort(&litr, &ritr, lsize, rsize))
? 0
// they're equal until here, so one array must have
// elements left:
: (lsize-(litr.i) > rsize-(ritr.i))
? 1
: -1;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rsi
leaq 0x20(%rsp), %r13
movq %r13, %rdi
callq 0x35c0
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0x35c0
testq %r12, %r12
leaq 0x1126(%rip), %r15 # 0x4620
cmovneq %r12, %r15
movq %r13, %rdi
movq %rbp, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2d6c
testl %eax, %eax
je 0x357a
leaq 0x20(%rsp), %r12
leaq 0x8(%rsp), %rbp
movq %r12, %rdi
leaq 0x50(%rsp), %rsi
callq 0x35d3
movq %rax, %r13
movq %rbp, %rdi
leaq 0x38(%rsp), %rsi
callq 0x35d3
movq %r13, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x315f
movl %eax, %r13d
movq %r12, %rdi
callq 0x361e
movq %rbp, %rdi
callq 0x361e
movq %r12, %rdi
movq %rbp, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2d6c
testl %eax, %eax
je 0x3575
testl %r13d, %r13d
je 0x351d
testl %r13d, %r13d
jne 0x35ae
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2db8
xorl %r13d, %r13d
testl %eax, %eax
jne 0x35ae
subq 0x28(%rsp), %r14
subq 0x10(%rsp), %rbx
xorl %r13d, %r13d
cmpq %r14, %rbx
adcl $-0x1, %r13d
orl $0x1, %r13d
movl %r13d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /fundamental[P]rtosc/src/cpp/arg-val-cmp.c |
rtosc_arg_val_itr_get | const rtosc_arg_val_t* rtosc_arg_val_itr_get(const rtosc_arg_val_itr *itr,
rtosc_arg_val_t* buffer)
{
const rtosc_arg_val_t* result;
if(itr->av->type == '-')
{
if(rtosc_av_rep_has_delta(itr->av))
rtosc_arg_val_range_arg(itr->av, itr->range_i, buffer);
else
*buffer = itr->av[1];
result = buffer;
}
else result = itr->av;
return result;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rdi
cmpb $0x2d, (%rdi)
jne 0x35ff
movq %rsi, %rbx
callq 0x2d56
movq (%r14), %rdi
testl %eax, %eax
je 0x3604
movl 0x10(%r14), %esi
movq %rbx, %rdx
callq 0x3b6f
jmp 0x3613
movq %rdi, %rbx
jmp 0x3613
movq 0x28(%rdi), %rax
movq %rax, 0x10(%rbx)
movups 0x18(%rdi), %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /fundamental[P]rtosc/src/cpp/arg-val-itr.c |
rtosc_arg_val_null | int rtosc_arg_val_null(rtosc_arg_val_t* av, char type)
{
av->type = type;
switch(type)
{
case 'h': av->val.h = 0; return true;
case 't': av->val.t = 0; return true;
case 's':
case 'S': av->val.s = NULL; return true;
case 'd': av->val.d = 0.0; return true;
case 'f': av->val.f = 0.0f; return true;
case 'c':
case 'i':
case 'r': av->val.i = 0; return true;
case 'T':
case 'F': av->type = 'F'; av->val.T = 0; return true;
default: return false;
}
} | movb %sil, (%rdi)
xorl %eax, %eax
cmpl $0x62, %esi
jle 0x36eb
addl $-0x63, %esi
cmpl $0x11, %esi
ja 0x3710
leaq 0xf4f(%rip), %rcx # 0x4628
movslq (%rcx,%rsi,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movl $0x0, 0x8(%rdi)
jmp 0x370b
cmpl $0x46, %esi
je 0x36fa
cmpl $0x53, %esi
je 0x3703
cmpl $0x54, %esi
jne 0x3710
movb $0x46, (%rdi)
movb $0x0, 0x8(%rdi)
jmp 0x370b
movq $0x0, 0x8(%rdi)
movl $0x1, %eax
retq
| /fundamental[P]rtosc/src/cpp/arg-val-math.c |
rtosc_arg_val_from_int | int rtosc_arg_val_from_int(rtosc_arg_val_t* av, char type, int number)
{
av->type = type;
switch(type)
{
case 'h': av->val.h = number; return true;
case 'd': av->val.d = number; return true;
case 'f': av->val.f = number; return true;
case 'c':
case 'i': av->val.i = number; return true;
case 'F':
case 'T':
// note: we discard av->type here!
// it's clear that the decision should be based on "number",
// not on the current type
av->val.T = (number != 0.0);
av->type = av->val.T ? 'T' : 'F';
return true;
default: return false;
}
} | movb %sil, (%rdi)
xorl %eax, %eax
leal -0x63(%rsi), %ecx
cmpl $0x6, %ecx
ja 0x3733
leaq 0xf4b(%rip), %rsi # 0x4670
movslq (%rsi,%rcx,4), %rcx
addq %rsi, %rcx
jmpq *%rcx
movl %edx, 0x8(%rdi)
jmp 0x3771
cmpl $0x46, %esi
je 0x373d
cmpl $0x54, %esi
jne 0x3776
testl %edx, %edx
setne 0x8(%rdi)
movl $0x54, %eax
movl $0x46, %ecx
cmovnel %eax, %ecx
movb %cl, (%rdi)
jmp 0x3771
cvtsi2ss %edx, %xmm0
movss %xmm0, 0x8(%rdi)
jmp 0x3771
movslq %edx, %rax
movq %rax, 0x8(%rdi)
jmp 0x3771
cvtsi2sd %edx, %xmm0
movsd %xmm0, 0x8(%rdi)
movl $0x1, %eax
retq
| /fundamental[P]rtosc/src/cpp/arg-val-math.c |
rtosc_arg_val_round | int rtosc_arg_val_round(rtosc_arg_val_t* av)
{
int tmp;
switch(av->type)
{
case 'd':
tmp = (int)(av->val.d);
av->val.d = tmp + (int)(av->val.d - tmp >= 0.999);
return true;
case 'f':
tmp = (int)(av->val.f);
av->val.f = tmp + (int)(av->val.f - tmp >= 0.999f);
return true;
case 'h':
case 'c':
case 'i':
case 'T':
case 'F':
return true;
default:
return false;
}
} | movzbl (%rdi), %ecx
movl $0x1, %eax
leal -0x63(%rcx), %edx
cmpl $0x6, %edx
ja 0x387e
leaq 0xe50(%rip), %rcx # 0x46c4
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
retq
cmpl $0x46, %ecx
je 0x387d
cmpl $0x54, %ecx
je 0x387d
xorl %eax, %eax
retq
movsd 0x8(%rdi), %xmm0
cvttsd2si %xmm0, %ecx
cvttpd2dq %xmm0, %xmm1
cvtdq2pd %xmm1, %xmm1
subsd %xmm1, %xmm0
ucomisd 0xec8(%rip), %xmm0 # 0x4770
sbbl $-0x1, %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0x8(%rdi)
retq
movss 0x8(%rdi), %xmm0
cvttss2si %xmm0, %ecx
cvttps2dq %xmm0, %xmm1
cvtdq2ps %xmm1, %xmm1
subss %xmm1, %xmm0
ucomiss 0xe99(%rip), %xmm0 # 0x476c
sbbl $-0x1, %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
movss %xmm0, 0x8(%rdi)
retq
| /fundamental[P]rtosc/src/cpp/arg-val-math.c |
rtosc_arg_val_div | int rtosc_arg_val_div(const rtosc_arg_val_t* lhs, const rtosc_arg_val_t* rhs,
rtosc_arg_val_t* res)
{
if(lhs->type != rhs->type)
return false;
res->type = lhs->type;
switch(lhs->type)
{
case 'd': res->val.d = lhs->val.d / rhs->val.d; return true;
case 'f': res->val.f = lhs->val.f / rhs->val.f; return true;
case 'h': res->val.h = lhs->val.h / rhs->val.h; return true;
case 'c':
case 'i': res->val.i = lhs->val.i / rhs->val.i; return true;
case 'T': res->type = 'T'; res->val.T = 1; return true;
case 'F': assert(false); return false; // divide by 0
default: return false;
}
} | movq %rdx, %rcx
movb (%rdi), %dl
xorl %eax, %eax
cmpb (%rsi), %dl
jne 0x3b28
movb %dl, (%rcx)
movzbl (%rdi), %r8d
leal -0x63(%r8), %edx
cmpl $0x6, %edx
ja 0x3ae4
leaq 0xc65(%rip), %r8 # 0x4734
movslq (%r8,%rdx,4), %rdx
addq %r8, %rdx
jmpq *%rdx
movl 0x8(%rdi), %eax
cltd
idivl 0x8(%rsi)
movl %eax, 0x8(%rcx)
jmp 0x3b23
cmpl $0x54, %r8d
jne 0x3b28
movb $0x54, (%rcx)
movb $0x1, 0x8(%rcx)
jmp 0x3b23
movq 0x8(%rdi), %rax
cqto
idivq 0x8(%rsi)
movq %rax, 0x8(%rcx)
jmp 0x3b23
movsd 0x8(%rdi), %xmm0
divsd 0x8(%rsi), %xmm0
movsd %xmm0, 0x8(%rcx)
jmp 0x3b23
movss 0x8(%rdi), %xmm0
divss 0x8(%rsi), %xmm0
movss %xmm0, 0x8(%rcx)
movl $0x1, %eax
retq
| /fundamental[P]rtosc/src/cpp/arg-val-math.c |
tst_qpromise_finally::rejectedSync_void() | void tst_qpromise_finally::rejectedSync_void()
{
int value = -1;
auto p = QtPromise::QPromise<void>::reject(QString{"foo"}).finally([&]() {
value = 8;
return 16; // ignored!
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QtPromise::QPromise<void>>::value));
QCOMPARE(waitForError(p, QString{}), QString{"foo"});
QCOMPARE(p.isRejected(), true);
QCOMPARE(value, 8);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
orl $-0x1, 0x4c(%rsp)
leaq 0x128bc(%rip), %rsi # 0x1b0a3
leaq 0xd8(%rsp), %rbx
movq %rbx, %rdi
callq 0x10a2a
leaq 0xf0(%rsp), %rdi
movq %rbx, %rsi
callq 0x10b32
leaq 0x1e2b2(%rip), %r12 # 0x26ac0
addq $0x10, %r12
movq %r12, 0x98(%rsp)
movq 0xf8(%rsp), %rax
movq %rax, 0xa0(%rsp)
testq %rax, %rax
je 0x8833
lock
incl 0x8(%rax)
leaq 0x1e23e(%rip), %r15 # 0x26a78
addq $0x10, %r15
movq %r15, 0x98(%rsp)
leaq 0x1e1fb(%rip), %rbx # 0x26a48
addq $0x10, %rbx
movq %rbx, 0x38(%rsp)
pushq $0x68
popq %rdi
callq 0x40a0
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
andq $0x0, 0x60(%rax)
movq %rax, %rdi
callq 0x11bc0
movq %r14, 0x40(%rsp)
lock
incl 0x8(%r14)
movq %rbx, 0xb0(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0xb8(%rsp)
testq %rax, %rax
je 0x88b0
lock
incl 0x8(%rax)
leaq 0x1e2c9(%rip), %r13 # 0x26b80
addq $0x10, %r13
leaq 0xb0(%rsp), %rsi
movq %r13, (%rsi)
leaq 0x60(%rsp), %rdi
callq 0x11be0
leaq 0xb0(%rsp), %rdi
callq 0x10c02
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x88fb
lock
incl (%rax)
movq 0x60(%rsp), %rcx
movq 0x8(%rsp), %rax
jmp 0x88ff
xorl %eax, %eax
xorl %ecx, %ecx
andq $0x0, 0x8(%rsp)
movq %rax, 0x50(%rsp)
movq %rcx, 0x10(%rsp)
testq %rcx, %rcx
je 0x8923
lock
incl (%rcx)
movq 0x10(%rsp), %rcx
movq 0x50(%rsp), %rax
jmp 0x8925
xorl %ecx, %ecx
andq $0x0, 0x10(%rsp)
movq %rcx, (%rsp)
movq 0xa0(%rsp), %rbx
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x8948
lock
incl (%rax)
movq (%rsp), %rcx
movq %rcx, 0x20(%rsp)
testq %rcx, %rcx
je 0x8955
lock
incl (%rcx)
leaq 0x4c(%rsp), %rbp
movq %rbp, 0x28(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x120(%rsp)
movaps %xmm0, 0x130(%rsp)
pushq $0x18
popq %rdi
callq 0x40a0
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
testq %rcx, %rcx
je 0x898a
lock
incl (%rcx)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rax)
testq %rcx, %rcx
je 0x899b
lock
incl (%rcx)
leaq 0x18(%rsp), %rdi
movq 0x10(%rdi), %rcx
movq %rcx, 0x10(%rax)
leaq 0x120(%rsp), %r14
movq %rax, (%r14)
leaq 0x6330(%rip), %rax # 0xecea
movq %rax, 0x18(%r14)
leaq 0x6335(%rip), %rax # 0xecfa
movq %rax, 0x10(%r14)
callq 0xecd4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14a3a
leaq 0x120(%rsp), %rdi
callq 0x11f1c
movq 0xa0(%rsp), %rbx
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x8a00
lock
incl (%rax)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x8a11
lock
incl (%rax)
movq %rbp, 0x28(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x100(%rsp)
movaps %xmm0, 0x110(%rsp)
pushq $0x18
popq %rdi
callq 0x40a0
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
testq %rcx, %rcx
je 0x8a41
lock
incl (%rcx)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rax)
testq %rcx, %rcx
je 0x8a52
lock
incl (%rcx)
leaq 0x18(%rsp), %rdi
movq 0x10(%rdi), %rcx
movq %rcx, 0x10(%rax)
leaq 0x100(%rsp), %r14
movq %rax, (%r14)
leaq 0x63a3(%rip), %rax # 0xee14
movq %rax, 0x18(%r14)
leaq 0x63da(%rip), %rax # 0xee56
movq %rax, 0x10(%r14)
callq 0xedfe
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14ac4
leaq 0x100(%rsp), %rdi
callq 0x11f1c
movq %rsp, %rdi
callq 0x12092
leaq 0x10(%rsp), %rdi
callq 0x12092
leaq 0x50(%rsp), %rdi
callq 0x12092
leaq 0x8(%rsp), %rdi
callq 0x12092
leaq 0x60(%rsp), %rdi
callq 0x12092
movq %r13, 0x38(%rsp)
movq 0xa0(%rsp), %rdi
callq 0x11352
testb %al, %al
jne 0x8af0
movq 0xa0(%rsp), %rdi
callq 0x110a8
movq %r12, 0x50(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x58(%rsp)
testq %rax, %rax
je 0x8b0b
lock
incl 0x8(%rax)
movq %r15, 0x50(%rsp)
movq %r12, 0x78(%rsp)
pushq $0x58
popq %rdi
callq 0x40a0
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
andq $0x0, 0x50(%rax)
movq %rax, %rdi
callq 0x10c46
movq %r14, 0x80(%rsp)
lock
incl 0x8(%r14)
movq %r12, 0x60(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x68(%rsp)
testq %rax, %rax
je 0x8b6b
lock
incl 0x8(%rax)
leaq 0x60(%rsp), %rsi
movq %r15, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x10c60
leaq 0x60(%rsp), %rdi
callq 0x109dc
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x8ba5
lock
incl (%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
jmp 0x8ba9
xorl %eax, %eax
xorl %ecx, %ecx
andq $0x0, 0x10(%rsp)
movq %rax, (%rsp)
movq %rcx, 0x88(%rsp)
testq %rcx, %rcx
je 0x8bd1
lock
incl (%rcx)
movq 0x88(%rsp), %rcx
movq (%rsp), %rax
jmp 0x8bd3
xorl %ecx, %ecx
andq $0x0, 0x88(%rsp)
movq %rcx, 0x90(%rsp)
movq 0x40(%rsp), %rbx
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x8bfe
lock
incl (%rax)
movq 0x90(%rsp), %rcx
movq %rcx, 0x20(%rsp)
testq %rcx, %rcx
je 0x8c0b
lock
incl (%rcx)
movq %r12, 0x28(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x30(%rsp)
testq %rax, %rax
je 0x8c23
lock
incl 0x8(%rax)
movq %r15, 0x28(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0xb0(%rsp)
movaps %xmm0, 0xc0(%rsp)
pushq $0x20
popq %rdi
callq 0x40a0
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
testq %rcx, %rcx
je 0x8c53
lock
incl (%rcx)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rax)
testq %rcx, %rcx
je 0x8c64
lock
incl (%rcx)
movq %r12, 0x10(%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x18(%rax)
testq %rcx, %rcx
je 0x8c7a
lock
incl 0x8(%rcx)
movq %r15, 0x10(%rax)
leaq 0xb0(%rsp), %r14
movq %rax, (%r14)
leaq 0x626e(%rip), %rax # 0xeefe
movq %rax, 0x18(%r14)
leaq 0x635b(%rip), %rax # 0xeff6
movq %rax, 0x10(%r14)
leaq 0x18(%rsp), %rdi
callq 0xeede
movq %rbx, %rdi
movq %r14, %rsi
callq 0x125d8
leaq 0xb0(%rsp), %rdi
callq 0x11f1c
movq 0x40(%rsp), %rbx
leaq 0x18(%rsp), %rdi
movq %rsp, %rdx
leaq 0x90(%rsp), %rcx
xorl %esi, %esi
callq 0x14832
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x12662
leaq 0x18(%rsp), %rdi
callq 0x11f1c
leaq 0x90(%rsp), %rdi
callq 0x11052
leaq 0x88(%rsp), %rdi
callq 0x11052
movq %rsp, %rdi
callq 0x11052
leaq 0x10(%rsp), %rdi
callq 0x11052
leaq 0x8(%rsp), %rdi
callq 0x11052
movq %r15, 0x78(%rsp)
movq 0x40(%rsp), %rdi
callq 0x1252c
testb %al, %al
jne 0x8d47
movq 0x40(%rsp), %rdi
callq 0x12126
leaq 0x50(%rsp), %rdi
callq 0x109dc
leaq 0x38(%rsp), %rdi
callq 0x10c02
leaq 0x98(%rsp), %rdi
callq 0x109dc
leaq 0xf0(%rsp), %rdi
callq 0x109dc
leaq 0xd8(%rsp), %rdi
callq 0x11960
xorps %xmm0, %xmm0
leaq 0x60(%rsp), %rdx
movaps %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
leaq 0xd8(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0xc1ac
leaq 0x122f8(%rip), %rsi # 0x1b0a3
leaq 0x98(%rsp), %rdi
callq 0x10a2a
leaq 0x1228e(%rip), %rdx # 0x1b04d
leaq 0x122e1(%rip), %rcx # 0x1b0a7
leaq 0x12147(%rip), %r8 # 0x1af14
leaq 0xd8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
movl $0x8f, %r9d
callq 0x109fd
movl %eax, %ebx
leaq 0x98(%rsp), %rdi
callq 0x11960
leaq 0xd8(%rsp), %rdi
callq 0x11960
leaq 0x60(%rsp), %rdi
callq 0x11960
testb %bl, %bl
je 0x8e7c
movq 0x80(%rsp), %rdi
callq 0x1682e
leaq 0xd8(%rsp), %rdi
movb %al, (%rdi)
leaq 0x60(%rsp), %rsi
movb $0x1, (%rsi)
leaq 0x1223f(%rip), %rdx # 0x1b077
leaq 0x121e5(%rip), %rcx # 0x1b024
leaq 0x120ce(%rip), %r8 # 0x1af14
movl $0x90, %r9d
callq 0x107e5
testb %al, %al
je 0x8e7c
movl 0x4c(%rsp), %edi
leaq 0x121c9(%rip), %rdx # 0x1b029
leaq 0x121c8(%rip), %rcx # 0x1b02f
leaq 0x120a6(%rip), %r8 # 0x1af14
pushq $0x8
popq %rsi
movl $0x91, %r9d
callq 0x4070
leaq 0x78(%rsp), %rdi
callq 0x109dc
addq $0x148, %rsp # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8e9c
jmp 0x8e9c
movq %rax, %rbx
jmp 0x8ee1
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x11960
jmp 0x8ec0
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
jmp 0x8efb
movq %rax, %rbx
leaq 0xd8(%rsp), %rdi
callq 0x11960
jmp 0x8ed7
movq %rax, %rbx
jmp 0x8f1c
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x11960
leaq 0x78(%rsp), %rdi
callq 0x109dc
jmp 0x9139
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x11f1c
jmp 0x8f1c
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x11f1c
leaq 0x18(%rsp), %rdi
callq 0xeede
leaq 0x90(%rsp), %rdi
callq 0x11052
leaq 0x88(%rsp), %rdi
callq 0x11052
movq %rsp, %rdi
callq 0x11052
leaq 0x10(%rsp), %rdi
callq 0x11052
movq %rbx, %rdi
callq 0x4030
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x4150
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x10cc8
movq %rsp, %rdi
callq 0x10d04
callq 0x4260
jmp 0x8d20
movq %rax, %rbx
jmp 0x8f8f
movq %rax, %rbx
movq %rsp, %rdi
callq 0x10d04
callq 0x4260
leaq 0x8(%rsp), %rdi
callq 0x11052
jmp 0x8fad
jmp 0x90ae
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x109dc
leaq 0x80(%rsp), %rdi
callq 0x10d1a
jmp 0x90f9
movq %rax, %rbx
leaq 0x100(%rsp), %rdi
jmp 0x900e
movq %rax, %rbx
pushq $0x58
popq %rsi
movq %r14, %rdi
callq 0x4080
jmp 0x90f9
movq %rax, %rbx
leaq 0x100(%rsp), %rdi
callq 0x11f1c
leaq 0x18(%rsp), %rdi
callq 0xedfe
jmp 0x902f
movq %rax, %rbx
jmp 0x90f9
movq %rax, %rbx
leaq 0x120(%rsp), %rdi
callq 0x11f1c
jmp 0x902f
movq %rax, %rbx
leaq 0x120(%rsp), %rdi
callq 0x11f1c
leaq 0x18(%rsp), %rdi
callq 0xecd4
movq %rsp, %rdi
callq 0x12092
leaq 0x10(%rsp), %rdi
callq 0x12092
leaq 0x50(%rsp), %rdi
callq 0x12092
leaq 0x8(%rsp), %rdi
callq 0x12092
movq %rbx, %rdi
callq 0x4030
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x4150
leaq 0x60(%rsp), %rdi
movq %rbx, %rsi
callq 0x11c48
leaq 0x18(%rsp), %rdi
callq 0x10d04
callq 0x4260
jmp 0x8ac3
movq %rax, %rbx
jmp 0x90a2
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x10d04
callq 0x4260
leaq 0x60(%rsp), %rdi
callq 0x12092
jmp 0x90c6
movq %rax, %rdi
callq 0x10d0f
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x10c02
leaq 0x40(%rsp), %rdi
callq 0x10be4
jmp 0x9112
movq %rax, %rbx
pushq $0x68
popq %rsi
movq %r14, %rdi
callq 0x4080
jmp 0x9112
movq %rax, %rbx
jmp 0x9112
movq %rax, %rbx
jmp 0x912c
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x109dc
leaq 0x50(%rsp), %rdi
callq 0x109dc
jmp 0x9108
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x10c02
leaq 0x98(%rsp), %rdi
callq 0x109dc
leaq 0xf0(%rsp), %rdi
callq 0x109dc
leaq 0xd8(%rsp), %rdi
callq 0x11960
movq %rbx, %rdi
callq 0x4210
nop
| /simonbrunel[P]qtpromise/tests/auto/qtpromise/qpromise/tst_finally.cpp |
int waitForValue<int>(QtPromise::QPromise<int> const&, int const&) | static inline T waitForValue(const QtPromise::QPromise<T>& promise, const T& initial)
{
T value(initial);
promise
.then([&](const T& res) {
value = res;
})
.wait();
return value;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
movl (%rsi), %eax
movl %eax, 0x14(%rsp)
leaq 0x1afaa(%rip), %r15 # 0x26ac0
addq $0x10, %r15
movq %r15, 0x30(%rsp)
pushq $0x58
popq %rdi
callq 0x40a0
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
andq $0x0, 0x50(%rax)
movq %rax, %rdi
callq 0x10c46
movq %r14, 0x38(%rsp)
lock
incl 0x8(%r14)
movq %r15, 0x60(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x68(%rsp)
testq %rax, %rax
je 0xbb6f
lock
incl 0x8(%rax)
leaq 0x1af02(%rip), %r12 # 0x26a78
addq $0x10, %r12
leaq 0x60(%rsp), %rsi
movq %r12, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x10c60
leaq 0x60(%rsp), %rdi
callq 0x109dc
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
testq %rax, %rax
je 0xbbb4
lock
incl (%rax)
movq 0x8(%rsp), %rcx
movq 0x28(%rsp), %rax
jmp 0xbbb8
xorl %eax, %eax
xorl %ecx, %ecx
andq $0x0, 0x28(%rsp)
movq %rax, (%rsp)
movq %rcx, 0x18(%rsp)
testq %rcx, %rcx
je 0xbbda
lock
incl (%rcx)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
jmp 0xbbdc
xorl %ecx, %ecx
andq $0x0, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x8(%rbx), %r14
movq %rax, 0x40(%rsp)
testq %rax, %rax
je 0xbbfd
lock
incl (%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x48(%rsp)
testq %rcx, %rcx
je 0xbc0a
lock
incl (%rcx)
leaq 0x14(%rsp), %rax
movq %rax, 0x50(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x80(%rsp)
pushq $0x18
popq %rdi
callq 0x40a0
movq 0x40(%rsp), %rcx
movq %rcx, (%rax)
testq %rcx, %rcx
je 0xbc3c
lock
incl (%rcx)
movq 0x48(%rsp), %rcx
movq %rcx, 0x8(%rax)
testq %rcx, %rcx
je 0xbc4d
lock
incl (%rcx)
leaq 0x40(%rsp), %rdi
movq 0x10(%rdi), %rcx
movq %rcx, 0x10(%rax)
leaq 0x70(%rsp), %r15
movq %rax, (%r15)
leaq 0xddd(%rip), %rax # 0xca46
movq %rax, 0x18(%r15)
leaq 0xe42(%rip), %rax # 0xcab6
movq %rax, 0x10(%r15)
callq 0xca30
movq %r14, %rdi
movq %r15, %rsi
callq 0x125d8
leaq 0x70(%rsp), %rdi
callq 0x11f1c
movq 0x8(%rbx), %r14
leaq 0x40(%rsp), %rdi
movq %rsp, %rdx
leaq 0x20(%rsp), %rcx
xorl %esi, %esi
callq 0x14832
leaq 0x40(%rsp), %rsi
movq %r14, %rdi
callq 0x12662
leaq 0x40(%rsp), %rdi
callq 0x11f1c
leaq 0x20(%rsp), %rdi
callq 0x11052
leaq 0x18(%rsp), %rdi
callq 0x11052
movq %rsp, %rdi
callq 0x11052
leaq 0x28(%rsp), %rdi
callq 0x11052
leaq 0x8(%rsp), %rdi
callq 0x11052
movq %r12, 0x30(%rsp)
movq 0x8(%rbx), %rdi
callq 0x1252c
testb %al, %al
jne 0xbd0c
movq 0x8(%rbx), %rdi
callq 0x12126
leaq 0x98(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x10b54
leaq 0x98(%rsp), %rdi
callq 0x109dc
leaq 0x30(%rsp), %rdi
callq 0x109dc
movl 0x14(%rsp), %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x40(%rsp), %rdi
jmp 0xbd64
movq %rax, %r14
jmp 0xbd82
jmp 0xbe2c
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0x11f1c
jmp 0xbd82
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0x11f1c
leaq 0x40(%rsp), %rdi
callq 0xca30
leaq 0x20(%rsp), %rdi
callq 0x11052
leaq 0x18(%rsp), %rdi
callq 0x11052
movq %rsp, %rdi
callq 0x11052
leaq 0x28(%rsp), %rdi
callq 0x11052
movq %r14, %rdi
callq 0x4030
movq %rsp, %r14
movq %r14, %rdi
callq 0x4150
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x10cc8
movq %rsp, %rdi
callq 0x10d04
callq 0x4260
jmp 0xbce7
movq %rax, %rbx
jmp 0xbdef
movq %rax, %rbx
movq %rsp, %rdi
callq 0x10d04
callq 0x4260
leaq 0x8(%rsp), %rdi
callq 0x11052
jmp 0xbe10
movq %rax, %rdi
callq 0x10d0f
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x109dc
leaq 0x38(%rsp), %rdi
callq 0x10d1a
jmp 0xbe39
movq %rax, %rbx
pushq $0x58
popq %rsi
movq %r14, %rdi
callq 0x4080
jmp 0xbe39
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x109dc
movq %rbx, %rdi
callq 0x4210
| /simonbrunel[P]qtpromise/tests/auto/qtpromise/qpromise/../shared/utils.h |
void QtPromisePrivate::PromiseDispatch<QtPromise::QPromise<int>>::call<QtPromise::QPromiseResolve<int>, QtPromise::QPromiseReject<int>, tst_qpromise_finally::rejectedAsyncResolve()::$_1>(QtPromise::QPromiseResolve<int> const&, QtPromise::QPromiseReject<int> const&, tst_qpromise_finally::rejectedAsyncResolve()::$_1) | static void call(const Resolve& resolve, const Reject& reject, Functor fn, Args&&... args)
{
try {
PromiseFulfill<Unqualified<Result>>::call(fn(std::forward<Args>(args)...),
resolve,
reject);
} catch (...) {
reject(std::current_exception());
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rsi, 0x48(%rsp)
movq %rdi, %r14
leaq 0x17102(%rip), %rbx # 0x26a48
addq $0x10, %rbx
movq %rbx, 0x28(%rsp)
pushq $0x68
popq %rdi
callq 0x40a0
movq %rax, %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
andq $0x0, 0x60(%rax)
movq %rax, %rdi
callq 0x11bc0
movq %r12, 0x30(%rsp)
lock
incl 0x8(%r12)
movq %rbx, 0x58(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
testq %rax, %rax
je 0xf9a4
lock
incl 0x8(%rax)
leaq 0x171d5(%rip), %rbx # 0x26b80
addq $0x10, %rbx
leaq 0x58(%rsp), %rsi
movq %rbx, (%rsi)
leaq 0x20(%rsp), %rdi
callq 0x11be0
leaq 0x58(%rsp), %rdi
callq 0x10c02
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0xf9e4
lock
incl (%rax)
movq 0x18(%rsp), %rax
jmp 0xf9e6
xorl %eax, %eax
andq $0x0, 0x18(%rsp)
movq %rax, 0x50(%rsp)
movq %r15, 0x8(%rsp)
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0xfa03
lock
incl (%rax)
leaq 0x10(%rsp), %r12
callq 0x4230
leaq 0x38(%rsp), %rdi
movq %rax, %rsi
callq 0x131e4
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0xfac6
movl 0x4(%rax), %ecx
testl %ecx, %ecx
sete %cl
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
sete %dl
orb %cl, %dl
jne 0xfac6
movl 0x4(%rax), %eax
callq 0x4270
testb %al, %al
jne 0xfac6
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0xfa67
movl 0x4(%rax), %eax
testl %eax, %eax
je 0xfa67
movq 0x40(%rsp), %rdi
jmp 0xfa69
xorl %edi, %edi
callq 0x4250
movq %rax, %r13
testq %rax, %rax
jne 0xfa7f
callq 0x43a0
testb %al, %al
jne 0xfac6
pushq $0x20
popq %rdi
callq 0x40a0
movq %rax, %rbp
movq %rax, %rdi
xorl %esi, %esi
callq 0x4200
leaq 0x16e55(%rip), %rax # 0x268f0
movq %rax, (%rbp)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rbp)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rbp)
testq %rax, %rax
je 0xfab9
lock
incl (%rax)
movq %r13, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x40e0
leaq 0x38(%rsp), %rdi
callq 0x10f5c
movq %r12, %rdi
callq 0x12092
leaq 0x50(%rsp), %rdi
callq 0x12092
leaq 0x18(%rsp), %rdi
callq 0x12092
leaq 0x20(%rsp), %rdi
callq 0x12092
movq %rbx, 0x28(%rsp)
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x16850
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movq 0x48(%rsp), %rdx
callq 0x139b4
leaq 0x28(%rsp), %rdi
callq 0x10c02
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
pushq $0x20
popq %rsi
movq %rbp, %rdi
callq 0x4080
jmp 0xfb44
movq %rax, %r13
leaq 0x38(%rsp), %rdi
callq 0x10f5c
jmp 0xfbeb
jmp 0xfb55
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x10c02
jmp 0xfb90
movq %rax, %r14
leaq 0x58(%rsp), %rdi
callq 0x10c02
leaq 0x30(%rsp), %rdi
callq 0x10be4
jmp 0xfb90
movq %rax, %r14
pushq $0x68
popq %rsi
movq %r12, %rdi
callq 0x4080
jmp 0xfb90
movq %rax, %r14
movq %r14, %rdi
callq 0x4030
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4150
movq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x11c48
leaq 0x8(%rsp), %rdi
callq 0x10d04
callq 0x4260
jmp 0xfb22
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x10d04
callq 0x4260
movq %rbx, %rdi
callq 0x4210
movq %rax, %rdi
callq 0x10d0f
movq %rax, %r13
movq %r12, %rdi
callq 0x12092
leaq 0x50(%rsp), %rdi
callq 0x12092
leaq 0x18(%rsp), %rdi
callq 0x12092
movq %r13, %rdi
callq 0x4030
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x4150
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x11c48
leaq 0x8(%rsp), %rdi
callq 0x10d04
callq 0x4260
jmp 0xfaec
movq %rax, %r14
jmp 0xfc54
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x10d04
callq 0x4260
leaq 0x20(%rsp), %rdi
callq 0x12092
jmp 0xfb71
jmp 0xfbe0
| /simonbrunel[P]qtpromise/include/../src/qtpromise/qpromise_p.h |
void QtPromisePrivate::PromiseFulfill<QtPromise::QPromise<int>>::call<QtPromise::QPromiseResolve<int>, QtPromise::QPromiseReject<int>>(QtPromise::QPromise<int> const&, QtPromise::QPromiseResolve<int> const&, QtPromise::QPromiseReject<int> const&) | static void
call(const QtPromise::QPromise<T>& promise, const TResolve& resolve, const TReject& reject)
{
if (promise.isFulfilled()) {
resolve(promise.m_d->value());
} else if (promise.isRejected()) {
reject(promise.m_d->error());
} else {
promise.then(
[=]() {
resolve(promise.m_d->value());
},
[=]() { // catch all
reject(promise.m_d->error());
});
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x1084a
testb %al, %al
je 0x139e8
movq 0x8(%rbx), %rsi
addq $0x58, %rsi
movq %r15, %rdi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x13b52
movq %rbx, %rdi
callq 0x10a82
testb %al, %al
je 0x13a0d
movq 0x8(%rbx), %rsi
addq $0x50, %rsi
movq %r14, %rdi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x13bcc
movq (%r15), %rax
movq %rax, (%rsp)
testq %rax, %rax
je 0x13a1c
lock
incl (%rax)
leaq 0x13025(%rip), %rax # 0x26a48
addq $0x10, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rbx), %rcx
movq %rcx, 0x10(%rsp)
testq %rcx, %rcx
je 0x13a3e
lock
incl 0x8(%rcx)
leaq 0x1313b(%rip), %rdx # 0x26b80
addq $0x10, %rdx
movq %rdx, 0x8(%rsp)
movq (%r14), %rcx
movq %rcx, 0x18(%rsp)
testq %rcx, %rcx
je 0x13a5e
lock
incl (%rcx)
movq %rax, 0x20(%rsp)
movq 0x8(%rbx), %rax
movq %rax, 0x28(%rsp)
testq %rax, %rax
je 0x13a75
lock
incl 0x8(%rax)
leaq 0x18(%rsp), %rcx
movq %rdx, 0x8(%rcx)
leaq 0x30(%rsp), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq 0x13ad2
leaq 0x30(%rsp), %rdi
callq 0x109dc
leaq 0x18(%rsp), %rdi
callq 0x13b26
movq %rsp, %rdi
callq 0x13b3c
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x13b26
movq %rsp, %rdi
callq 0x13b3c
movq %rbx, %rdi
callq 0x4210
nop
| /simonbrunel[P]qtpromise/include/../src/qtpromise/qpromise_p.h |
std::function<void (int const&)> QtPromisePrivate::PromiseHandler<int, void QtPromisePrivate::PromiseFulfill<QtPromise::QPromise<int>>::call<QtPromise::QPromiseResolve<int>, QtPromise::QPromiseReject<int>>(QtPromise::QPromise<int> const&, QtPromise::QPromiseResolve<int> const&, QtPromise::QPromiseReject<int> const&)::'lambda'(), void>::create<QtPromise::QPromiseResolve<void>, QtPromise::QPromiseReject<void>>(void QtPromisePrivate::PromiseFulfill<QtPromise::QPromise<int>>::call<QtPromise::QPromiseResolve<int>, QtPromise::QPromiseReject<int>>(QtPromise::QPromise<int> const&, QtPromise::QPromiseResolve<int> const&, QtPromise::QPromiseReject<int> const&)::'lambda'() const&, QtPromise::QPromiseResolve<int> const&, QtPromise::QPromiseReject<int> const&) | static std::function<void(const T&)>
create(const THandler& handler, const TResolve& resolve, const TReject& reject)
{
return [=](const T&) {
PromiseDispatch<ResType>::call(resolve, reject, handler);
};
} | pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq (%rdx), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x13f0c
lock
incl (%rax)
movq (%rcx), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x13f1c
lock
incl (%rax)
movq (%rsi), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x13f2c
lock
incl (%rax)
leaq 0x12b15(%rip), %rax # 0x26a48
addq $0x10, %rax
movq %rax, 0x20(%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x28(%rsp)
testq %rax, %rax
je 0x13f4e
lock
incl 0x8(%rax)
leaq 0x12c2b(%rip), %rax # 0x26b80
addq $0x10, %rax
leaq 0x8(%rsp), %rsi
movq %rax, 0x18(%rsi)
movq %rbx, %rdi
callq 0x1406e
leaq 0x8(%rsp), %rdi
callq 0x140b6
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x140b6
movq %rbx, %rdi
callq 0x4210
| /simonbrunel[P]qtpromise/include/../src/qtpromise/qpromise_p.h |
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::get() | char_int_type get()
{
++position.chars_read_total;
++position.chars_read_current_line;
if (next_unget)
{
// just reset the next_unget variable and work with current
next_unget = false;
}
else
{
current = ia.get_character();
}
if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
{
token_string.push_back(char_traits<char_type>::to_char_type(current));
}
if (current == '\n')
{
++position.lines_read;
position.chars_read_current_line = 0;
}
return current;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movdqu 0x20(%rdi), %xmm0
pcmpeqd %xmm1, %xmm1
psubq %xmm1, %xmm0
movdqu %xmm0, 0x20(%rdi)
cmpb $0x1, 0x18(%rdi)
jne 0x13520
movb $0x0, 0x18(%rbx)
movl 0x14(%rbx), %eax
cmpl $-0x1, %eax
je 0x1352d
leaq 0x38(%rbx), %rdi
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
callq 0xc6d0
movl 0x14(%rbx), %eax
cmpl $0xa, %eax
jne 0x1351a
incq 0x30(%rbx)
andq $0x0, 0x28(%rbx)
pushq $0xa
popq %rax
addq $0x10, %rsp
popq %rbx
retq
movq %rbx, %rdi
callq 0x13532
movl %eax, 0x14(%rbx)
jmp 0x134f1
pushq $-0x1
jmp 0x13519
nop
| /libKriging[P]libKriging/src/lib/include/libKriging/utils/nlohmann/json.hpp |
arma::Mat<double>::Mat<arma::eOp<arma::Col<double>, arma::eop_neg>, arma::eOp<arma::Col<double>, arma::eop_square>, arma::eglue_div>(arma::eGlue<arma::eOp<arma::Col<double>, arma::eop_neg>, arma::eOp<arma::Col<double>, arma::eop_square>, arma::eglue_div> const&) | inline
Mat<eT>::Mat(const eGlue<T1, T2, eglue_type>& X)
: n_rows(X.get_n_rows())
, n_cols(X.get_n_cols())
, n_elem(X.get_n_elem())
, n_alloc()
, vec_state(0)
, mem_state(0)
, mem()
{
arma_debug_sigprint_this(this);
arma_type_check(( is_same_type< eT, typename T1::elem_type >::no ));
arma_type_check(( is_same_type< eT, typename T2::elem_type >::no ));
init_cold();
eglue_type::apply(*this, X);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq (%rax), %rax
movl (%rax), %ecx
movl %ecx, (%rdi)
movl $0x1, 0x4(%rdi)
movl 0x8(%rax), %edi
xorl %ecx, %ecx
movl %edi, 0x8(%r14)
movq %rcx, 0x20(%r14)
movq %rcx, 0xc(%r14)
cmpq $0x10, %rdi
ja 0x2a2eb
leaq 0x30(%r14), %rax
testq %rdi, %rdi
cmoveq %rdi, %rax
movq %rax, 0x20(%r14)
jmp 0x2a305
shlq $0x3, %rdi
callq 0xc8c0
testq %rax, %rax
je 0x2a3f0
movq %rax, 0x20(%r14)
movl 0x8(%r14), %ecx
movl %ecx, 0xc(%r14)
movq (%rbx), %rcx
movq (%rcx), %rdx
movl 0x8(%rdx), %ecx
testb $0xf, %al
je 0x2a35d
testq %rcx, %rcx
je 0x2a3b4
movq 0x10(%rbx), %rsi
movq 0x20(%rdx), %rdx
movq (%rsi), %rsi
movq 0x20(%rsi), %rsi
xorl %edi, %edi
movapd 0x7bf68(%rip), %xmm0 # 0xa62a0
movsd (%rdx,%rdi,8), %xmm1
xorpd %xmm0, %xmm1
movsd (%rsi,%rdi,8), %xmm2
mulsd %xmm2, %xmm2
divsd %xmm2, %xmm1
movsd %xmm1, (%rax,%rdi,8)
incq %rdi
cmpq %rdi, %rcx
jne 0x2a338
jmp 0x2a3b4
movq 0x20(%rdx), %rdx
testb $0xf, %dl
jne 0x2a377
movq 0x10(%rbx), %rsi
movq (%rsi), %rsi
movq 0x20(%rsi), %rsi
testb $0xf, %sil
je 0x2a3bc
testq %rcx, %rcx
je 0x2a3b4
movq 0x10(%rbx), %rsi
movq (%rsi), %rsi
movq 0x20(%rsi), %rsi
xorl %edi, %edi
movapd 0x7bf0f(%rip), %xmm0 # 0xa62a0
movsd (%rdx,%rdi,8), %xmm1
xorpd %xmm0, %xmm1
movsd (%rsi,%rdi,8), %xmm2
mulsd %xmm2, %xmm2
divsd %xmm2, %xmm1
movsd %xmm1, (%rax,%rdi,8)
incq %rdi
cmpq %rdi, %rcx
jne 0x2a391
addq $0x8, %rsp
popq %rbx
popq %r14
retq
testq %rcx, %rcx
je 0x2a3b4
xorl %edi, %edi
movapd 0x7bed5(%rip), %xmm0 # 0xa62a0
movsd (%rdx,%rdi,8), %xmm1
xorpd %xmm0, %xmm1
movsd (%rsi,%rdi,8), %xmm2
mulsd %xmm2, %xmm2
divsd %xmm2, %xmm1
movsd %xmm1, (%rax,%rdi,8)
incq %rdi
cmpq %rdi, %rcx
jne 0x2a3cb
jmp 0x2a3b4
callq 0x11c73
nop
| /libKriging[P]libKriging/build_O3/dependencies/armadillo-code/tmp/include/armadillo_bits/Mat_meat.hpp |
Kriging::Kriging(arma::Col<double> const&, arma::Mat<double> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Trend::RegressionModel const&, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, KrigingParameters const&) | LIBKRIGING_EXPORT Kriging::Kriging(const arma::vec& y,
const arma::mat& X,
const std::string& covType,
const Trend::RegressionModel& regmodel,
bool normalize,
const std::string& optim,
const std::string& objective,
const Parameters& parameters) {
if (y.n_elem != X.n_rows)
throw std::runtime_error("Dimension of new data should be the same:\n X: (" + std::to_string(X.n_rows) + "x"
+ std::to_string(X.n_cols) + "), y: (" + std::to_string(y.n_elem) + ")");
make_Cov(covType);
fit(y, X, regmodel, normalize, optim, objective, parameters);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
movq %rax, 0x40(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rdi)
movl %eax, 0x30(%rdi)
movss 0x79d8b(%rip), %xmm1 # 0xa6050
movaps %xmm1, 0xd0(%rdi)
movl $0x2, %edx
movl %edx, 0xe0(%rdi)
movq %rax, 0xf0(%rdi)
movaps %xmm1, 0x180(%rdi)
movl %edx, 0x190(%rdi)
movq %rax, 0x1a0(%rdi)
movsd 0x79f66(%rip), %xmm1 # 0xa6260
movaps %xmm1, 0x230(%rdi)
movl $0x1, %edx
movl %edx, 0x240(%rdi)
movq %rax, 0x250(%rdi)
leaq 0x308(%rdi), %rsi
movaps %xmm0, 0x2e0(%rdi)
movb %al, 0x2f0(%rdi)
movq %rsi, 0x8(%rsp)
movq %rsi, 0x2f8(%rdi)
movq %rax, 0x300(%rdi)
movb %al, 0x308(%rdi)
leaq 0x328(%rdi), %r13
movq %r13, 0x318(%rdi)
movq %rax, 0x320(%rdi)
movb %al, 0x328(%rdi)
movq %rax, 0x360(%rdi)
movl %eax, 0x350(%rdi)
movaps %xmm0, 0x340(%rdi)
movaps %xmm1, 0x3f0(%rdi)
movl %edx, 0x400(%rdi)
movq %rax, 0x410(%rdi)
movq %rax, 0x4c0(%rdi)
movaps %xmm0, 0x4a0(%rdi)
movl %eax, 0x4b0(%rdi)
movq %rax, 0x570(%rdi)
movaps %xmm0, 0x550(%rdi)
movl %eax, 0x560(%rdi)
movq %rax, 0x620(%rdi)
movaps %xmm0, 0x600(%rdi)
movl %eax, 0x610(%rdi)
movq %rax, 0x6d0(%rdi)
movaps %xmm0, 0x6b0(%rdi)
movl %eax, 0x6c0(%rdi)
movq %rax, 0x780(%rdi)
movl %eax, 0x770(%rdi)
movaps %xmm0, 0x760(%rdi)
movq %rax, 0x830(%rdi)
movl %eax, 0x820(%rdi)
movaps %xmm0, 0x810(%rdi)
movaps %xmm1, 0x8c0(%rdi)
movl %edx, 0x8d0(%rdi)
movq %rax, 0x8e0(%rdi)
movaps %xmm1, 0x970(%rdi)
movl %edx, 0x980(%rdi)
movq %rax, 0x990(%rdi)
movb %al, 0xa20(%rdi)
movaps %xmm1, 0xa30(%rdi)
movl %edx, 0xa40(%rdi)
movq %rax, 0xa50(%rdi)
movb %al, 0xae0(%rdi)
movq %rax, 0xae8(%rdi)
movw $0x100, 0xaf0(%rdi) # imm = 0x100
movq %rax, 0xb20(%rdi)
movl %eax, 0xb10(%rdi)
movaps %xmm0, 0xb00(%rdi)
movq %rax, 0xbd0(%rdi)
movl %eax, 0xbc0(%rdi)
movaps %xmm0, 0xbb0(%rdi)
movq %rax, 0xc60(%rdi)
movq %rax, 0xc90(%rdi)
movl %eax, 0xc80(%rdi)
movaps %xmm0, 0xc70(%rdi)
movq %rax, 0xd40(%rdi)
movl %eax, 0xd30(%rdi)
movaps %xmm0, 0xd20(%rdi)
movq %rax, 0xdf0(%rdi)
movl %eax, 0xde0(%rdi)
movaps %xmm0, 0xdd0(%rdi)
movq %rax, 0xea0(%rdi)
movl %eax, 0xe90(%rdi)
movaps %xmm0, 0xe80(%rdi)
movq %rax, 0xf50(%rdi)
movl %eax, 0xf40(%rdi)
movaps %xmm0, 0xf30(%rdi)
movq %rax, 0x1000(%rdi)
movl %eax, 0xff0(%rdi)
movaps %xmm0, 0xfe0(%rdi)
movq %rax, 0x10b0(%rdi)
movl %eax, 0x10a0(%rdi)
movaps %xmm0, 0x1090(%rdi)
movq %rax, 0x1160(%rdi)
movl %eax, 0x1150(%rdi)
movaps %xmm0, 0x1140(%rdi)
movq %rax, 0x1210(%rdi)
movl %eax, 0x1200(%rdi)
movaps %xmm0, 0x11f0(%rdi)
movq %rax, 0x12c0(%rdi)
movl %eax, 0x12b0(%rdi)
movaps %xmm0, 0x12a0(%rdi)
movq %rax, 0x1370(%rdi)
movl %eax, 0x1360(%rdi)
movaps %xmm0, 0x1350(%rdi)
movq %rax, 0x1420(%rdi)
movl %eax, 0x1410(%rdi)
movaps %xmm0, 0x1400(%rdi)
movq %rax, 0x14d0(%rdi)
movl %eax, 0x14c0(%rdi)
movaps %xmm0, 0x14b0(%rdi)
movq %rax, 0x1580(%rdi)
movl %eax, 0x1570(%rdi)
movaps %xmm0, 0x1560(%rdi)
movq %rax, 0x1630(%rdi)
movl %eax, 0x1620(%rdi)
movaps %xmm0, 0x1610(%rdi)
movq %rax, 0x16e0(%rdi)
movl %eax, 0x16d0(%rdi)
movaps %xmm0, 0x16c0(%rdi)
movq %rax, 0x1790(%rdi)
movl %eax, 0x1780(%rdi)
movaps %xmm0, 0x1770(%rdi)
movq %rax, 0x1840(%rdi)
movl %eax, 0x1830(%rdi)
movaps %xmm0, 0x1820(%rdi)
movq %rax, 0x1930(%rdi)
movaps %xmm0, 0x1920(%rdi)
movaps %xmm0, 0x1910(%rdi)
movaps %xmm0, 0x1900(%rdi)
movaps %xmm0, 0x18f0(%rdi)
movaps %xmm0, 0x18e0(%rdi)
movaps %xmm0, 0x18d0(%rdi)
movl 0x8(%r14), %eax
cmpl (%r12), %eax
jne 0x2c677
movl %r9d, %ebp
movq %r8, %r15
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x2b2a4
movq 0x240(%rsp), %r9
movzbl %bpl, %r8d
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r15, %rcx
pushq 0x250(%rsp)
pushq 0x250(%rsp)
callq 0xccf0
addq $0x10, %rsp
addq $0x208, %rsp # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xc340
movq %rax, %r15
movl (%r12), %esi
leaq 0x148(%rsp), %rdi
callq 0xcbd0
leaq 0x7b4da(%rip), %rsi # 0xa7b76
leaq 0x1a8(%rsp), %rdi
leaq 0x148(%rsp), %rdx
callq 0xcd10
leaq 0x7b8ec(%rip), %rsi # 0xa7fa4
leaq 0x1a8(%rsp), %rdi
callq 0xceb0
leaq 0x118(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x2c6e9
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
jmp 0x2c6fc
movq %rdx, 0x108(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x118(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x110(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl 0x4(%r12), %esi
leaq 0x188(%rsp), %rdi
callq 0xcbd0
leaq 0x1c8(%rsp), %rdi
leaq 0x108(%rsp), %rsi
leaq 0x188(%rsp), %rdx
callq 0xc700
leaq 0x7b459(%rip), %rsi # 0xa7ba6
leaq 0x1c8(%rsp), %rdi
callq 0xceb0
leaq 0x138(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x2c780
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x2c793
movq %rdx, 0x128(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x138(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x130(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl 0x8(%r14), %esi
leaq 0x168(%rsp), %rdi
callq 0xcbd0
leaq 0x1e8(%rsp), %rdi
leaq 0x128(%rsp), %rsi
leaq 0x168(%rsp), %rdx
callq 0xc700
leaq 0x7a037(%rip), %rsi # 0xa681a
leaq 0x1e8(%rsp), %rdi
callq 0xceb0
leaq 0xf8(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x2c81b
movups (%rcx), %xmm0
leaq 0xf8(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x2c82e
movq %rdx, 0xe8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xf8(%rsp)
movq 0x8(%rax), %rdx
leaq 0xe8(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %r14b
movq %r15, %rdi
callq 0xcc90
xorl %r14d, %r14d
movq 0xa078e(%rip), %rsi # 0xccff0
movq 0xa06d7(%rip), %rdx # 0xccf40
movq %r15, %rdi
callq 0xcd60
movq %rax, (%rsp)
movq 0xe8(%rsp), %rdi
leaq 0xf8(%rsp), %rax
cmpq %rax, %rdi
je 0x2c8a3
movq 0xf8(%rsp), %rsi
incq %rsi
callq 0xc830
jmp 0x2c8a3
movq %rax, (%rsp)
movb $0x1, %r14b
leaq 0x1f8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c8cd
movq 0x1f8(%rsp), %rsi
incq %rsi
callq 0xc830
jmp 0x2c8cd
movq %rax, (%rsp)
movb $0x1, %r14b
leaq 0x178(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c8f7
movq 0x178(%rsp), %rsi
incq %rsi
callq 0xc830
jmp 0x2c8f7
movq %rax, (%rsp)
movb $0x1, %r14b
movq 0x128(%rsp), %rdi
cmpq %r12, %rdi
je 0x2c91d
movq 0x138(%rsp), %rsi
incq %rsi
callq 0xc830
jmp 0x2c91d
movq %rax, (%rsp)
movb $0x1, %r14b
leaq 0x1d8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c947
movq 0x1d8(%rsp), %rsi
incq %rsi
callq 0xc830
jmp 0x2c947
movq %rax, (%rsp)
movb $0x1, %r14b
leaq 0x198(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c971
movq 0x198(%rsp), %rsi
incq %rsi
callq 0xc830
jmp 0x2c971
movq %rax, (%rsp)
movb $0x1, %r14b
movq 0x108(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2c997
movq 0x118(%rsp), %rsi
incq %rsi
callq 0xc830
jmp 0x2c997
movq %rax, (%rsp)
movb $0x1, %r14b
leaq 0x1b8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c9b8
movq 0x1b8(%rsp), %rsi
incq %rsi
callq 0xc830
leaq 0x158(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c9d9
movq 0x158(%rsp), %rsi
incq %rsi
callq 0xc830
testb %r14b, %r14b
jne 0x2ca0b
jmp 0x2ca19
movq %rax, (%rsp)
leaq 0x158(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ca0b
movq 0x158(%rsp), %rsi
incq %rsi
callq 0xc830
jmp 0x2ca0b
movq %rax, (%rsp)
movq %r15, %rdi
callq 0xc5d0
jmp 0x2ca19
movq %rax, (%rsp)
movq 0x1920(%rbx), %rax
testq %rax, %rax
je 0x2ca36
leaq 0x1910(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x1900(%rbx), %rax
testq %rax, %rax
je 0x2ca53
leaq 0x18f0(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x18e0(%rbx), %rax
testq %rax, %rax
je 0x2ca70
leaq 0x18d0(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x340(%rbx), %rax
movq %rax, 0xe0(%rsp)
leaq 0x3f0(%rbx), %rax
movq %rax, 0xd8(%rsp)
leaq 0x4a0(%rbx), %rax
movq %rax, 0xd0(%rsp)
leaq 0x550(%rbx), %rax
movq %rax, 0xc8(%rsp)
leaq 0x600(%rbx), %rax
movq %rax, 0xc0(%rsp)
leaq 0x6b0(%rbx), %rax
movq %rax, 0xb8(%rsp)
leaq 0x760(%rbx), %rax
movq %rax, 0xb0(%rsp)
leaq 0x810(%rbx), %rax
movq %rax, 0xa8(%rsp)
leaq 0x8c0(%rbx), %rax
movq %rax, 0xa0(%rsp)
leaq 0x970(%rbx), %rax
movq %rax, 0x98(%rsp)
leaq 0xa30(%rbx), %rax
movq %rax, 0x90(%rsp)
leaq 0xb00(%rbx), %rax
movq %rax, 0x88(%rsp)
leaq 0xbb0(%rbx), %rax
movq %rax, 0x80(%rsp)
leaq 0xc70(%rbx), %rax
movq %rax, 0x78(%rsp)
leaq 0xd20(%rbx), %rax
movq %rax, 0x70(%rsp)
leaq 0xdd0(%rbx), %rax
movq %rax, 0x68(%rsp)
leaq 0xe80(%rbx), %rax
movq %rax, 0x60(%rsp)
leaq 0xf30(%rbx), %rax
movq %rax, 0x58(%rsp)
leaq 0xfe0(%rbx), %rax
movq %rax, 0x50(%rsp)
leaq 0x1090(%rbx), %rax
movq %rax, 0x48(%rsp)
leaq 0x1140(%rbx), %rax
movq %rax, 0x40(%rsp)
leaq 0x11f0(%rbx), %rax
movq %rax, 0x38(%rsp)
leaq 0x12a0(%rbx), %rax
movq %rax, 0x30(%rsp)
leaq 0x1350(%rbx), %rax
movq %rax, 0x28(%rsp)
leaq 0x1400(%rbx), %rax
movq %rax, 0x20(%rsp)
leaq 0x14b0(%rbx), %rax
movq %rax, 0x18(%rsp)
leaq 0x1560(%rbx), %r12
leaq 0x1610(%rbx), %r15
leaq 0x16c0(%rbx), %rbp
leaq 0x1770(%rbx), %r14
leaq 0x1820(%rbx), %rdi
callq 0x1c318
movq %r14, %rdi
callq 0x1c318
movq %rbp, %rdi
callq 0x1c318
movq %r15, %rdi
callq 0x1c318
movq %r12, %rdi
callq 0x1c318
movq 0x18(%rsp), %rdi
callq 0x1c318
movq 0x20(%rsp), %rdi
callq 0x1c318
movq 0x28(%rsp), %rdi
callq 0x1c318
movq 0x30(%rsp), %rdi
callq 0x1c318
movq 0x38(%rsp), %rdi
callq 0x1c318
movq 0x40(%rsp), %rdi
callq 0x1c318
movq 0x48(%rsp), %rdi
callq 0x1c318
movq 0x50(%rsp), %rdi
callq 0x1c318
movq 0x58(%rsp), %rdi
callq 0x1c318
movq 0x60(%rsp), %rdi
callq 0x1c318
movq 0x68(%rsp), %rdi
callq 0x1c318
movq 0x70(%rsp), %rdi
callq 0x1c318
movq 0x78(%rsp), %rdi
callq 0x1c318
movq 0x80(%rsp), %rdi
callq 0x1c318
movq 0x88(%rsp), %rdi
callq 0x1c318
movq 0x90(%rsp), %rdi
callq 0x1c318
movq 0x98(%rsp), %rdi
callq 0x1c318
movq 0xa0(%rsp), %rdi
callq 0x1c318
movq 0xa8(%rsp), %rdi
callq 0x1c318
movq 0xb0(%rsp), %rdi
callq 0x1c318
movq 0xb8(%rsp), %rdi
callq 0x1c318
movq 0xc0(%rsp), %rdi
callq 0x1c318
movq 0xc8(%rsp), %rdi
callq 0x1c318
movq 0xd0(%rsp), %rdi
callq 0x1c318
movq 0xd8(%rsp), %rdi
callq 0x1c318
movq 0xe0(%rsp), %rdi
callq 0x1c318
movq 0x318(%rbx), %rdi
cmpq %r13, %rdi
je 0x2cd5a
movq (%r13), %rsi
incq %rsi
callq 0xc830
leaq 0x20(%rbx), %r14
leaq 0xd0(%rbx), %r15
leaq 0x180(%rbx), %r12
leaq 0x230(%rbx), %rbp
movq 0x2f8(%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x2cd91
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0xc830
movq %rbp, %rdi
callq 0x1c318
movq %r12, %rdi
callq 0x1c318
movq %r15, %rdi
callq 0x1c318
movq %r14, %rdi
callq 0x1c318
movq (%rbx), %rdi
cmpq 0x10(%rsp), %rdi
je 0x2cdcb
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0xc830
movq (%rsp), %rdi
callq 0xcdb0
jmp 0x2cdd8
jmp 0x2cdd8
movq %rax, %rdi
callq 0x1c342
| /libKriging[P]libKriging/src/lib/Kriging.cpp |
Kriging::_logLikelihood(arma::Col<double> const&, arma::Col<double>*, arma::Mat<double>*, Kriging::KModel*, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, double>>>*) const | double Kriging::_logLikelihood(const arma::vec& _theta,
arma::vec* grad_out,
arma::mat* hess_out,
Kriging::KModel* model,
std::map<std::string, double>* bench) const {
// arma::cout << " theta: " << _theta << arma::endl;
Kriging::KModel m = make_Model(_theta, bench);
if (model != nullptr)
*model = m;
arma::uword n = m_X.n_rows;
double sigma2;
double ll;
if (m_est_sigma2) { // DiceKriging: model@case == "LLconcentration_beta_sigma2"
sigma2 = m.SSEstar / n;
ll = -0.5 * (n * log(2 * M_PI * sigma2) + 2 * arma::sum(log(m.L.diag())) + n);
} else { // DiceKriging: model@case == "LLconcentration_beta"
sigma2 = m_sigma2;
ll = -0.5
* (n * log(2 * M_PI * sigma2) + 2 * arma::sum(log(m.L.diag()))
+ as_scalar(LinearAlgebra::crossprod(m.Estar)) / sigma2);
}
if (grad_out != nullptr) {
arma::uword d = m_X.n_cols;
arma::uword p = m_F.n_cols;
auto t0 = Bench::tic();
arma::vec terme1 = arma::vec(d); // useful if (hess_out != nullptr)
if ((m.Linv.memptr() == nullptr) || (arma::size(m.Linv) != arma::size(m.L))) {
m.Linv = LinearAlgebra::solve(m.L, arma::mat(n, n, arma::fill::eye));
t0 = Bench::toc(bench, "L ^-1", t0);
}
arma::mat Rinv = LinearAlgebra::crossprod(m.Linv);
t0 = Bench::toc(bench, "R^-1 = t(L^-1) * L^-1", t0);
arma::mat x = LinearAlgebra::solve(m.L.t(), m.Estar);
t0 = Bench::toc(bench, "x = tL \\ z", t0);
arma::cube gradR = arma::cube(n, n, d, arma::fill::none);
const arma::vec zeros = arma::vec(d, arma::fill::zeros);
for (arma::uword i = 0; i < n; i++) {
gradR.tube(i, i) = zeros;
for (arma::uword j = 0; j < i; j++) {
gradR.tube(i, j) = m.R.at(i, j) * _DlnCovDtheta(m_dX.col(i * n + j), _theta);
gradR.tube(j, i) = gradR.tube(i, j);
}
}
t0 = Bench::toc(bench, "gradR = R * dlnCov(dX)", t0);
for (arma::uword k = 0; k < d; k++) {
t0 = Bench::tic();
arma::mat gradR_k = gradR.slice(k);
t0 = Bench::toc(bench, "gradR_k = gradR[k]", t0);
// should make a fast function trace_prod(A,B) -> sum_i(sum_j(Ai,j*Bj,i))
terme1.at(k) = as_scalar(x.t() * gradR_k * x) / sigma2;
double terme2 = -arma::trace(Rinv * gradR_k); //-arma::accu(Rinv % gradR_k_upper)
(*grad_out).at(k) = (terme1.at(k) + terme2) / 2;
t0 = Bench::toc(bench, "grad_ll[k] = xt * gradR_k / S2 + tr(Ri * gradR_k)", t0);
if (hess_out != nullptr) {
//' @ref O. Roustant
// for (k in 1:d) {
// for (l in 1:k) {
// aux <- grad_R[[k]] %*% Rinv %*% grad_R[[l]]
// Dkl <- d2_matcor(X, modele_proba$covariance, R, grad_logR, k,l)
// xk <- backsolve(t(T),grad_R[[k]]%*%x, upper.tri=FALSE)
// xl <- backsolve(t(T),grad_R[[l]]%*%x, upper.tri=FALSE)
//
// hess_A <- - (t(xk) %*% H %*% xl) / sigma2_hat
// hess_B <- (t(x) %*% ( -Dkl+2*aux ) %*% x) / sigma2_hat
// hess_C <- - grad_A[k] * grad_A[l] / n
// hess_D <- - sum(diag( Rinv %*% aux ))
// hess_E <- sum(diag( Rinv %*% Dkl ))
//
// hess_log_vrais[k,l] <- 2*hess_A + hess_B + hess_C + hess_D + hess_E
// hess_log_vrais[l,k] <- hess_log_vrais[k,l]
// }
// }
t0 = Bench::tic();
arma::mat H = LinearAlgebra::tcrossprod(m.Qstar);
t0 = Bench::toc(bench, "H = Q* * t(Q*)", t0);
for (arma::uword l = 0; l <= k; l++) {
arma::mat gradR_l = gradR.slice(l); // arma::mat(n, n);
t0 = Bench::tic();
arma::mat aux = gradR_k * Rinv * gradR_l;
t0 = Bench::toc(bench, "aux = gradR[k] * Ri * gradR[l]", t0);
arma::mat hessR_k_l = arma::mat(n, n, arma::fill::none);
if (k == l) {
for (arma::uword i = 0; i < n; i++) {
hessR_k_l.at(i, i) = 0;
for (arma::uword j = 0; j < i; j++) {
double dln_k = gradR_k.at(i, j);
hessR_k_l.at(i, j) = hessR_k_l.at(j, i)
= dln_k * (dln_k / m.R.at(i, j) - (_Cov_pow + 1) / _theta.at(k));
// !! NO: it just work for exp type kernels. Matern MUST have a special treatment !!!
}
}
} else {
for (arma::uword i = 0; i < n; i++) {
hessR_k_l.at(i, i) = 0;
for (arma::uword j = 0; j < i; j++) {
hessR_k_l.at(i, j) = hessR_k_l.at(j, i) = gradR_k.at(i, j) * gradR_l.at(i, j) / m.R.at(i, j);
//= gradR.slice(i).col(j)[k] * gradR.slice(i).col(j)[l] / m.R.at(i, j);
}
}
}
t0 = Bench::toc(bench, "hessR_k_l = ...", t0);
// arma::mat xk =LinearAlgebra::solve(m.T, gradsR[k] * x);
arma::mat xk = m.Linv * gradR_k * x;
t0 = Bench::toc(bench, "xk = L \\ gradR[k] * x", t0);
arma::mat xl;
if (k == l)
xl = xk;
else
xl = m.Linv * gradR_l * x;
t0 = Bench::toc(bench, "xl = L \\ gradR[l] * x", t0);
// arma::cout << " hess_A:" << -xk.t() * H * xl / sigma2 << arma::endl;
// arma::cout << " hess_B:" << -x.t() * (hessR_k_l - 2*aux) * x / sigma2 << arma::endl;
// arma::cout << " hess_C:" << -terme1.at(k) * terme1.at(l) / n << arma::endl;
// arma::cout << " hess_D:" << -arma::trace(Rinv * aux) << arma::endl;
// arma::cout << " hess_E:" << arma::trace(Rinv * hessR_k_l) << arma::endl;
double h_lk
= (2.0 * xk.t() * H * xl / (sigma2) + x.t() * (hessR_k_l - 2 * aux) * x / (sigma2)
+ arma::trace(Rinv * aux) + -arma::trace(Rinv * hessR_k_l))[0]; // should optim there using accu &%
if (m_est_sigma2)
h_lk += terme1.at(k) * terme1.at(l) / n;
(*hess_out).at(l, k) = (*hess_out).at(k, l) = h_lk / 2;
t0 = Bench::toc(bench, "hess_ll[l,k] = ...", t0);
}
}
}
}
return ll;
} | subq $0x648, %rsp # imm = 0x648
movq %r9, %rcx
movq %rsi, %rdx
movq %rdi, %rsi
movq %rsp, %rdi
callq 0x33554
| /libKriging[P]libKriging/src/lib/Kriging.cpp |
Kriging::leaveOneOutVec(arma::Col<double> const&) | LIBKRIGING_EXPORT std::tuple<arma::vec, arma::vec> Kriging::leaveOneOutVec(const arma::vec& _theta) {
double loo = -1;
arma::mat yhat = arma::mat(m_y.n_elem, 2, arma::fill::none);
loo = _leaveOneOut(_theta, nullptr, &yhat, nullptr, nullptr);
return std::make_tuple(std::move(yhat.col(0)), std::move(yhat.col(1) * std::sqrt(m_sigma2)));
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x6f0, %rsp # imm = 0x6F0
movl 0x238(%rsi), %eax
movl %eax, (%rsp)
movl $0x2, 0x4(%rsp)
leal (%rax,%rax), %ebp
movl %ebp, 0x8(%rsp)
movq $0x0, 0xc(%rsp)
testl %eax, %eax
jns 0x356a3
leaq 0x70a32(%rip), %rax # 0xa60c5
leaq 0xb0(%rsp), %rdi
movq %rax, (%rdi)
callq 0x11ca0
movq %rdx, %rbx
movq %rsi, %r14
cmpl $0x10, %ebp
ja 0x356c2
testl %ebp, %ebp
leaq 0x30(%rsp), %rcx
movl $0x0, %eax
cmovneq %rcx, %rax
xorl %ebp, %ebp
jmp 0x356d7
movl %ebp, %edi
shlq $0x3, %rdi
callq 0xc8c0
testq %rax, %rax
jne 0x356d7
callq 0x11d28
movq %rax, 0x20(%rsp)
movl %ebp, 0xc(%rsp)
leaq 0xb0(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x33554
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1c318
movq %rbx, %rdi
callq 0xcdb0
| /libKriging[P]libKriging/src/lib/Kriging.cpp |
arma::Mat<double>::Mat<arma::eGlue<arma::Mat<double>, arma::Mat<double>, arma::eglue_minus>, arma::eop_scalar_div_post>(arma::eOp<arma::eGlue<arma::Mat<double>, arma::Mat<double>, arma::eglue_minus>, arma::eop_scalar_div_post> const&) | inline
Mat<eT>::Mat(const eOp<T1, eop_type>& X)
: n_rows(X.get_n_rows())
, n_cols(X.get_n_cols())
, n_elem(X.get_n_elem())
, n_alloc()
, vec_state(0)
, mem_state(0)
, mem()
{
arma_debug_sigprint_this(this);
arma_type_check(( is_same_type< eT, typename T1::elem_type >::no ));
init_cold();
eop_type::apply(*this, X);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq (%rax), %rdx
movl (%rdx), %ecx
movl %ecx, (%rdi)
movl 0x4(%rdx), %eax
movl %eax, 0x4(%rdi)
movl 0x8(%rdx), %edi
movl %edi, 0x8(%r14)
xorl %edx, %edx
movq %rdx, 0x20(%r14)
movl $0x10000, %esi # imm = 0x10000
cmpl %esi, %ecx
setae %r8b
cmpl %esi, %eax
setae %sil
orb %r8b, %sil
movq %rdx, 0xc(%r14)
cmpb $0x1, %sil
jne 0x4a601
movl %ecx, %ecx
cvtsi2sd %rcx, %xmm0
movl %eax, %eax
cvtsi2sd %rax, %xmm1
mulsd %xmm0, %xmm1
ucomisd 0x5ba5d(%rip), %xmm1 # 0xa6058
ja 0x4a6e6
cmpl $0x10, %edi
ja 0x4a619
leaq 0x30(%r14), %rax
testq %rdi, %rdi
cmoveq %rdi, %rax
movq %rax, 0x20(%r14)
xorl %ecx, %ecx
jmp 0x4a633
shlq $0x3, %rdi
callq 0xc8c0
testq %rax, %rax
je 0x4a6f8
movq %rax, 0x20(%r14)
movl 0x8(%r14), %ecx
movl %ecx, 0xc(%r14)
movsd 0x10(%rbx), %xmm0
movq (%rbx), %rsi
movq (%rsi), %rdx
movl 0x8(%rdx), %ecx
testb $0xf, %al
je 0x4a679
testq %rcx, %rcx
je 0x4a6ba
movq 0x20(%rdx), %rdx
movq 0x10(%rsi), %rsi
movq 0x20(%rsi), %rsi
xorl %edi, %edi
movsd (%rdx,%rdi,8), %xmm1
subsd (%rsi,%rdi,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rax,%rdi,8)
incq %rdi
cmpq %rdi, %rcx
jne 0x4a65c
jmp 0x4a6ba
movq 0x20(%rdx), %rdx
testb $0xf, %dl
jne 0x4a690
movq 0x10(%rsi), %rdi
movq 0x20(%rdi), %rdi
testb $0xf, %dil
je 0x4a6c2
testq %rcx, %rcx
je 0x4a6ba
movq 0x10(%rsi), %rsi
movq 0x20(%rsi), %rsi
xorl %edi, %edi
movsd (%rdx,%rdi,8), %xmm1
subsd (%rsi,%rdi,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rax,%rdi,8)
incq %rdi
cmpq %rdi, %rcx
jne 0x4a69f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
testq %rcx, %rcx
je 0x4a6ba
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm1
subsd (%rdi,%rsi,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rax,%rsi,8)
incq %rsi
cmpq %rsi, %rcx
jne 0x4a6c9
jmp 0x4a6ba
leaq 0x5b9d8(%rip), %rax # 0xa60c5
movq %rsp, %rdi
movq %rax, (%rdi)
callq 0x11ca0
callq 0x11d28
nop
| /libKriging[P]libKriging/build_O3/dependencies/armadillo-code/tmp/include/armadillo_bits/Mat_meat.hpp |
NoiseKriging::save(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const | void NoiseKriging::save(const std::string filename) const {
nlohmann::json j;
j["version"] = 2;
j["content"] = "NoiseKriging";
// _Cov_pow & std::function embedded by make_Cov
j["covType"] = m_covType;
j["X"] = to_json(m_X);
j["centerX"] = to_json(m_centerX);
j["scaleX"] = to_json(m_scaleX);
j["y"] = to_json(m_y);
j["centerY"] = m_centerY;
j["scaleY"] = m_scaleY;
j["normalize"] = m_normalize;
j["noise"] = to_json(m_noise);
j["regmodel"] = Trend::toString(m_regmodel);
j["optim"] = m_optim;
j["objective"] = m_objective;
// Auxiliary data
j["dX"] = to_json(m_dX);
j["maxdX"] = to_json(m_maxdX);
j["F"] = to_json(m_F);
j["T"] = to_json(m_T);
j["R"] = to_json(m_R);
j["M"] = to_json(m_M);
j["star"] = to_json(m_star);
j["circ"] = to_json(m_circ);
j["z"] = to_json(m_z);
j["beta"] = to_json(m_beta);
j["est_beta"] = m_est_beta;
j["theta"] = to_json(m_theta);
j["est_theta"] = m_est_theta;
j["sigma2"] = m_sigma2;
j["est_sigma2"] = m_est_sigma2;
std::ofstream f(filename);
f << std::setw(4) << j;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x3e8, %rsp # imm = 0x3E8
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movb $0x0, (%r15)
movq $0x0, 0x8(%r15)
movq %r15, %rdi
movl $0x1, %esi
callq 0x4d8fe
movq %r15, %rdi
movl $0x1, %esi
callq 0x4d8fe
xorps %xmm0, %xmm0
leaq 0x80(%rsp), %r12
movaps %xmm0, (%r12)
movl $0x2, %esi
movq %r12, %rdi
callq 0x549fe
movq %r12, %rdi
movl $0x1, %esi
callq 0x4d8fe
leaq 0x15a0a(%rip), %rsi # 0xa8186
movq %r15, %rdi
callq 0x4b098
leaq 0x80(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b10e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
leaq 0x1b038(%rip), %rsi # 0xad7e8
leaq 0x1d8(%rsp), %rdi
callq 0x98bda
leaq 0x159ca(%rip), %rsi # 0xa818e
movq %rsp, %rdi
callq 0x4b098
leaq 0x1d8(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b10e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
leaq 0x1c8(%rsp), %rdi
movq %r14, %rsi
callq 0x4b192
leaq 0x1598e(%rip), %rsi # 0xa8196
movq %rsp, %rdi
callq 0x4b098
leaq 0x1c8(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b10e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
leaq 0x20(%r14), %rsi
leaq 0x1b8(%rsp), %rdi
callq 0xc770
leaq 0x1bcff(%rip), %rsi # 0xae54c
movq %rsp, %rdi
callq 0x4b098
leaq 0x1b8(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b10e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
leaq 0xd0(%r14), %rsi
leaq 0x1a8(%rsp), %rdi
callq 0xc130
leaq 0x15909(%rip), %rsi # 0xa819e
movq %rsp, %rdi
callq 0x4b098
leaq 0x1a8(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b10e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
leaq 0x180(%r14), %rsi
leaq 0x198(%rsp), %rdi
callq 0xc130
leaq 0x158c9(%rip), %rsi # 0xa81a6
movq %rsp, %rdi
callq 0x4b098
leaq 0x198(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b10e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
leaq 0x230(%r14), %rsi
leaq 0x188(%rsp), %rdi
callq 0xcc00
leaq 0x159a7(%rip), %rsi # 0xa82cc
movq %rsp, %rdi
callq 0x4b098
leaq 0x188(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b10e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
xorps %xmm0, %xmm0
leaq 0x70(%rsp), %r15
movaps %xmm0, (%r15)
movsd 0x2e0(%r14), %xmm0
movq %r15, %rdi
callq 0x54b56
movq %r15, %rdi
movl $0x1, %esi
callq 0x4d8fe
leaq 0x1582a(%rip), %rsi # 0xa81ad
movq %rsp, %rdi
callq 0x4b098
leaq 0x70(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b10e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
leaq 0x60(%rsp), %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movsd 0x2e8(%r14), %xmm0
movq %r15, %rdi
callq 0x54b56
movq %r15, %rdi
movl $0x1, %esi
callq 0x4d8fe
leaq 0x157d7(%rip), %rsi # 0xa81b5
movq %rsp, %rdi
callq 0x4b098
leaq 0x60(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b10e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %r15
movaps %xmm0, (%r15)
movzbl 0x2f0(%r14), %esi
movq %r15, %rdi
callq 0x54b98
movq %r15, %rdi
movl $0x1, %esi
callq 0x4d8fe
leaq 0x15784(%rip), %rsi # 0xa81bc
movq %rsp, %rdi
callq 0x4b098
leaq 0x50(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b10e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
leaq 0x300(%r14), %rsi
leaq 0x178(%rsp), %rdi
callq 0xcc00
leaq 0x1ad78(%rip), %rsi # 0xad7f5
movq %rsp, %rdi
callq 0x4b098
leaq 0x178(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b10e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
leaq 0x3b0(%r14), %rsi
leaq 0x1e8(%rsp), %rdi
callq 0xc7a0
leaq 0x168(%rsp), %rdi
leaq 0x1e8(%rsp), %rsi
callq 0x4b1cc
leaq 0x156ec(%rip), %rsi # 0xa81c6
movq %rsp, %rdi
callq 0x4b098
leaq 0x168(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b10e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
leaq 0x1f8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x92b28
movq 0x1f8(%rsp), %rsi
incq %rsi
callq 0xc830
leaq 0x3b8(%r14), %rsi
leaq 0x158(%rsp), %rdi
callq 0x4b192
leaq 0x1568c(%rip), %rsi # 0xa81cf
movq %rsp, %rdi
callq 0x4b098
leaq 0x158(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b10e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
leaq 0x3d8(%r14), %rsi
leaq 0x148(%rsp), %rdi
callq 0x4b192
leaq 0x1564a(%rip), %rsi # 0xa81d5
movq %rsp, %rdi
callq 0x4b098
leaq 0x148(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b10e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
leaq 0x400(%r14), %rsi
leaq 0x138(%rsp), %rdi
callq 0xc770
leaq 0x1560f(%rip), %rsi # 0xa81e2
movq %rsp, %rdi
callq 0x4b098
leaq 0x138(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b10e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
leaq 0x4b0(%r14), %rsi
leaq 0x128(%rsp), %rdi
callq 0xcc00
leaq 0x155c4(%rip), %rsi # 0xa81df
movq %rsp, %rdi
callq 0x4b098
leaq 0x128(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b10e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
leaq 0x560(%r14), %rsi
leaq 0x118(%rsp), %rdi
callq 0xc770
leaq 0x17446(%rip), %rsi # 0xaa0a9
movq %rsp, %rdi
callq 0x4b098
leaq 0x118(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b10e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
leaq 0x610(%r14), %rsi
leaq 0x108(%rsp), %rdi
callq 0xc770
leaq 0x139ba(%rip), %rsi # 0xa6665
movq %rsp, %rdi
callq 0x4b098
leaq 0x108(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b10e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
leaq 0x6c0(%r14), %rsi
leaq 0xf8(%rsp), %rdi
callq 0xc770
leaq 0x1b715(%rip), %rsi # 0xae408
movq %rsp, %rdi
callq 0x4b098
leaq 0xf8(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b10e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
leaq 0x770(%r14), %rsi
leaq 0xe8(%rsp), %rdi
callq 0xc770
leaq 0x154aa(%rip), %rsi # 0xa81e5
movq %rsp, %rdi
callq 0x4b098
leaq 0xe8(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b10e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
leaq 0x820(%r14), %rsi
leaq 0xd8(%rsp), %rdi
callq 0xc770
leaq 0x15464(%rip), %rsi # 0xa81e7
movq %rsp, %rdi
callq 0x4b098
leaq 0xd8(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b10e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
leaq 0x8d0(%r14), %rsi
leaq 0xc8(%rsp), %rdi
callq 0xc770
leaq 0x15421(%rip), %rsi # 0xa81ec
movq %rsp, %rdi
callq 0x4b098
leaq 0xc8(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b10e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
leaq 0x980(%r14), %rsi
leaq 0xb8(%rsp), %rdi
callq 0xcc00
leaq 0x153de(%rip), %rsi # 0xa81f1
movq %rsp, %rdi
callq 0x4b098
leaq 0xb8(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b10e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
leaq 0xa30(%r14), %rsi
leaq 0xa8(%rsp), %rdi
callq 0xcc00
leaq 0x1539c(%rip), %rsi # 0xa81f7
movq %rsp, %rdi
callq 0x4b098
leaq 0xa8(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b10e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %r15
movaps %xmm0, (%r15)
movzbl 0xae0(%r14), %esi
movq %r15, %rdi
callq 0x54b98
movq %r15, %rdi
movl $0x1, %esi
callq 0x4d8fe
leaq 0x1533b(%rip), %rsi # 0xa81f3
movq %rsp, %rdi
callq 0x4b098
leaq 0x40(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b10e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
leaq 0xaf0(%r14), %rsi
leaq 0x98(%rsp), %rdi
callq 0xcc00
leaq 0x15303(%rip), %rsi # 0xa8200
movq %rsp, %rdi
callq 0x4b098
leaq 0x98(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b10e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %r15
movaps %xmm0, (%r15)
movzbl 0xba0(%r14), %esi
movq %r15, %rdi
callq 0x54b98
movq %r15, %rdi
movl $0x1, %esi
callq 0x4d8fe
leaq 0x152a2(%rip), %rsi # 0xa81fc
movq %rsp, %rdi
callq 0x4b098
leaq 0x30(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b10e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
leaq 0x20(%rsp), %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movsd 0xba8(%r14), %xmm0
movq %r15, %rdi
callq 0x54b56
movq %r15, %rdi
movl $0x1, %esi
callq 0x4d8fe
leaq 0x15255(%rip), %rsi # 0xa820a
movq %rsp, %rdi
callq 0x4b098
leaq 0x20(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b10e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r15
movaps %xmm0, (%r15)
movzbl 0xbb0(%r14), %esi
movq %r15, %rdi
callq 0x54b98
movq %r15, %rdi
movl $0x1, %esi
callq 0x4d8fe
leaq 0x151f7(%rip), %rsi # 0xa8206
movq %rsp, %rdi
callq 0x4b098
leaq 0x10(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x4b10e
movq %r14, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r14, %rdi
callq 0x4d9d4
leaq 0x1e8(%rsp), %rdi
movq %rbx, %rsi
movl $0x10, %edx
callq 0xcee0
leaq 0x1e8(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movq $0x4, 0x1f8(%rsp,%rax)
movq %rsp, %rsi
callq 0x4b205
movq 0x39eb0(%rip), %rax # 0xccf28
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x1f0(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x1e8(%rsp,%rcx)
callq 0xc6e0
leaq 0x2e0(%rsp), %rdi
callq 0xc210
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %rbx, %rdi
callq 0x4d9d4
addq $0x3e8, %rsp # imm = 0x3E8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x1e8(%rsp), %rdi
callq 0xcb40
jmp 0x932d7
jmp 0x932d4
movq %rax, %rbx
leaq 0x10(%rsp), %r14
jmp 0x932c0
movq %rax, %rbx
leaq 0x20(%rsp), %r14
jmp 0x932c0
movq %rax, %rbx
leaq 0x30(%rsp), %r14
jmp 0x932c0
movq %rax, %rbx
leaq 0x98(%rsp), %r14
jmp 0x932c0
movq %rax, %rbx
leaq 0x40(%rsp), %r14
jmp 0x932c0
movq %rax, %rbx
leaq 0xa8(%rsp), %r14
jmp 0x932c0
movq %rax, %rbx
leaq 0xb8(%rsp), %r14
jmp 0x932c0
movq %rax, %rbx
leaq 0xc8(%rsp), %r14
jmp 0x932c0
movq %rax, %rbx
leaq 0xd8(%rsp), %r14
jmp 0x932c0
movq %rax, %rbx
leaq 0xe8(%rsp), %r14
jmp 0x932c0
movq %rax, %rbx
leaq 0xf8(%rsp), %r14
jmp 0x932c0
movq %rax, %rbx
leaq 0x108(%rsp), %r14
jmp 0x932c0
movq %rax, %rbx
leaq 0x118(%rsp), %r14
jmp 0x932c0
movq %rax, %rbx
leaq 0x128(%rsp), %r14
jmp 0x932c0
movq %rax, %rbx
leaq 0x138(%rsp), %r14
jmp 0x932c0
movq %rax, %rbx
leaq 0x148(%rsp), %r14
jmp 0x932c0
movq %rax, %rbx
leaq 0x158(%rsp), %r14
jmp 0x932c0
movq %rax, %rbx
leaq 0x168(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r14, %rdi
callq 0x4d9d4
jmp 0x9320d
movq %rax, %rbx
leaq 0x1f8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x932d7
movq 0x1f8(%rsp), %rsi
incq %rsi
callq 0xc830
jmp 0x932d7
jmp 0x932d4
movq %rax, %rbx
leaq 0x178(%rsp), %r14
jmp 0x932c0
movq %rax, %rbx
leaq 0x50(%rsp), %r14
jmp 0x932c0
movq %rax, %rbx
leaq 0x60(%rsp), %r14
jmp 0x932c0
movq %rax, %rbx
leaq 0x70(%rsp), %r14
jmp 0x932c0
movq %rax, %rbx
leaq 0x188(%rsp), %r14
jmp 0x932c0
movq %rax, %rbx
leaq 0x198(%rsp), %r14
jmp 0x932c0
movq %rax, %rbx
leaq 0x1a8(%rsp), %r14
jmp 0x932c0
movq %rax, %rbx
leaq 0x1b8(%rsp), %r14
jmp 0x932c0
movq %rax, %rbx
leaq 0x1c8(%rsp), %r14
jmp 0x932c0
movq %rax, %rbx
leaq 0x1d8(%rsp), %r14
jmp 0x932c0
movq %rax, %rbx
leaq 0x80(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r14, %rdi
callq 0x4d9d4
jmp 0x932d7
movq %rax, %rbx
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r14, %rdi
callq 0x4d9d4
movq %rbx, %rdi
callq 0xcdb0
| /libKriging[P]libKriging/src/lib/NoiseKriging.cpp |
lkalloc::free(void*) | LIBKRIGING_EXPORT
void free(void* mem_ptr) {
#ifdef LIBKRIGING_DEBUG_ALLOC
static int count = 0;
++count;
// std::cout << "Using lkalloc deallocator " /* << custom_free */ << " (#" << count << ") in " << dllName() << "\n";
if (seens.find(mem_ptr) == seens.end()) {
std::cout << "### (#" << count << ") lkalloc allocator has never seen " << mem_ptr << " ##" << std::endl;
return;
}
#endif
if (custom_free) {
(*custom_free)(mem_ptr);
} else {
#ifdef _MSC_VER
return _aligned_free(mem_ptr);
#else
::free(mem_ptr);
#endif
}
#ifdef LIBKRIGING_DEBUG_ALLOC
seens.erase(mem_ptr);
#endif
} | movq 0x3421c(%rip), %rax # 0xcf180
testq %rax, %rax
je 0xc950
jmpq *%rax
| /libKriging[P]libKriging/src/lib/lkalloc.cpp |
to_json[abi:cxx11](arma::Row<double> const&) | LIBKRIGING_EXPORT nlohmann::json to_json(const arma::rowvec& t) {
auto data = serialize(t.memptr(), t.size());
std::string base64_data = base64_encode(data.data(), data.size(), false);
return {{"type", "rowvec"}, {"size", t.size()}, {"base64_data", base64_data}};
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rsi, %r15
movq %rdi, %r14
movq 0x20(%rsi), %rsi
movl 0x8(%r15), %edx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x9dcbb
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
subq %rsi, %rdx
leaq 0x20(%rsp), %rdi
xorl %ecx, %ecx
callq 0x9bcd4
leaq 0x1168c(%rip), %rsi # 0xadf78
leaq 0x70(%rsp), %rdi
callq 0x9e364
leaq 0x88(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x11670(%rip), %rsi # 0xadf7d
callq 0x9e430
leaq 0x70(%rsp), %rsi
movq $0x0, 0x28(%rsi)
leaq 0xd0(%rsp), %rbx
movl $0x2, %edx
movq %rbx, %rdi
movl $0x1, %ecx
movl $0x2, %r8d
callq 0x9dd52
leaq 0xe8(%rsp), %rbx
movq $0x0, -0x8(%rbx)
leaq 0x98f6(%rip), %rsi # 0xa624c
leaq 0xa0(%rsp), %rdi
callq 0x9e364
xorl %r13d, %r13d
leaq 0xb8(%rsp), %r12
movq %r13, -0x8(%r12)
movl 0x8(%r15), %esi
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movq %r12, %rdi
callq 0x5e80e
movq %r12, %rdi
movl $0x1, %esi
callq 0x4d8fe
movq %r13, 0x10(%r12)
leaq 0xa0(%rsp), %rsi
movl $0x2, %edx
movq %rbx, %rdi
movl $0x1, %ecx
movl $0x2, %r8d
callq 0x9dd52
leaq 0x100(%rsp), %rbx
movq $0x0, -0x8(%rbx)
leaq 0x115b4(%rip), %rsi # 0xadf84
leaq 0x40(%rsp), %rdi
callq 0x9e4fc
leaq 0x58(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x20(%rsp), %rsi
callq 0x5d060
leaq 0x40(%rsp), %rsi
movq $0x0, 0x28(%rsi)
movl $0x2, %edx
movq %rbx, %rdi
movl $0x1, %ecx
movl $0x2, %r8d
callq 0x9dd52
leaq 0xd0(%rsp), %rsi
movq $0x0, 0x40(%rsi)
movl $0x3, %edx
movq %r14, %rdi
movl $0x1, %ecx
movl $0x2, %r8d
callq 0x9dd52
movl $0x30, %r15d
leaq (%rsp,%r15), %rbx
addq $0xd0, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %rbx, %rdi
callq 0x4d9d4
addq $-0x18, %r15
cmpq $-0x18, %r15
jne 0x9ca44
movl $0x18, %r15d
leaq (%rsp,%r15), %rbx
addq $0x40, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %rbx, %rdi
callq 0x4d9d4
addq $-0x18, %r15
cmpq $-0x18, %r15
jne 0x9ca71
movl $0x18, %r15d
leaq (%rsp,%r15), %rbx
addq $0xa0, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %rbx, %rdi
callq 0x4d9d4
addq $-0x18, %r15
cmpq $-0x18, %r15
jne 0x9ca9b
movl $0x18, %r15d
leaq (%rsp,%r15), %rbx
addq $0x70, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %rbx, %rdi
callq 0x4d9d4
addq $-0x18, %r15
cmpq $-0x18, %r15
jne 0x9cac8
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9cb07
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc830
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x9cb1e
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0xc830
movq %r14, %rax
addq $0x118, %rsp # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x30, %r12d
xorl %ebp, %ebp
leaq (%rsp,%r12), %r15
addq $0xd0, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
addq $-0x18, %r12
cmpq $-0x18, %r12
jne 0x9cb3e
jmp 0x9cb6d
movq %rax, %r14
movb $0x1, %bpl
movl $0x18, %r12d
leaq (%rsp,%r12), %r15
addq $0x40, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
addq $-0x18, %r12
cmpq $-0x18, %r12
jne 0x9cb73
jmp 0x9cbbd
movq %rax, %r14
leaq 0x40(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
jmp 0x9cbba
jmp 0x9cbb7
movq %rax, %r14
movb $0x1, %bpl
movl $0x18, %r12d
leaq (%rsp,%r12), %r15
addq $0xa0, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
addq $-0x18, %r12
cmpq $-0x18, %r12
jne 0x9cbc3
jmp 0x9cbf4
jmp 0x9cbee
movq %rax, %r14
movb $0x1, %bpl
movl $0x18, %r12d
leaq (%rsp,%r12), %r15
addq $0x70, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %r15, %rdi
callq 0x4d9d4
addq $-0x18, %r12
cmpq $-0x18, %r12
jne 0x9cbfa
leaq 0xd0(%rsp), %r15
cmpq %rbx, %r15
setne %al
andb %al, %bpl
cmpb $0x1, %bpl
jne 0x9cc71
addq $-0x18, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %rbx, %rdi
callq 0x4d9d4
cmpq %r15, %rbx
jne 0x9cc35
jmp 0x9cc71
movq %rax, %r14
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4d8fe
movq %rbx, %rdi
callq 0x4d9d4
jmp 0x9cc71
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9cc8c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc830
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x9cca3
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0xc830
movq %r14, %rdi
callq 0xcdb0
movq %rax, %r14
jmp 0x9cc8c
| /libKriging[P]libKriging/src/lib/utils/jsonutils.cpp |
colvec_from_json(nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&) | LIBKRIGING_EXPORT arma::colvec colvec_from_json(const nlohmann::json& json_node) {
assert(json_node["type"] == "colvec");
std::string base64_data = json_node["base64_data"];
const std::string data = base64_decode(base64_data);
std::vector<double> raw_data = deserialize<double>(reinterpret_cast<const uint8_t*>(data.data()), data.size());
assert(raw_data.size() == json_node["size"]);
return {raw_data};
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10776(%rip), %rsi # 0xadf78
movq %r14, %rdi
callq 0x9df7c
leaq 0x1077f(%rip), %rsi # 0xadf90
movq %rax, %rdi
callq 0x9df2b
testb %al, %al
je 0x9d98b
leaq 0x1075c(%rip), %rsi # 0xadf84
movq %r14, %rdi
callq 0x9df7c
leaq 0x38(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x4d5c6
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x9be5f
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %rsp, %rdi
callq 0x9dff2
movq (%rsp), %r12
movq 0x8(%rsp), %r15
leaq 0x89db(%rip), %rsi # 0xa624c
movq %r14, %rdi
callq 0x9df7c
subq %r12, %r15
sarq $0x3, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x9e095
testb %al, %al
je 0x9d9aa
movabsq $0x7fffffff8, %r14 # imm = 0x7FFFFFFF8
movq (%rsp), %rcx
movq 0x8(%rsp), %rdx
subq %rcx, %rdx
movq %rdx, %rax
shrq $0x3, %rax
movl %eax, (%rbx)
movl $0x1, 0x4(%rbx)
movl %eax, 0x8(%rbx)
movabsq $0x100000000, %rsi # imm = 0x100000000
movq %rsi, 0xc(%rbx)
movq $0x0, 0x20(%rbx)
cmpl $0x10, %eax
ja 0x9d8ee
leaq 0x30(%rbx), %rdi
xorl %esi, %esi
testl %eax, %eax
movl $0x0, %eax
cmovneq %rdi, %rax
movq %rax, 0x20(%rbx)
jmp 0x9d915
andq %r14, %rdx
movq %rdx, %rdi
callq 0xc8c0
testq %rax, %rax
je 0x9d9c9
movq %rax, 0x20(%rbx)
movl 0x8(%rbx), %esi
movq (%rsp), %rcx
movq 0x8(%rsp), %rdx
subq %rcx, %rdx
movl %esi, 0xc(%rbx)
andq %r14, %rdx
je 0x9d931
cmpq %rcx, %rax
je 0x9d931
movq %rax, %rdi
movq %rcx, %rsi
callq 0xc6a0
movq (%rsp), %rcx
testq %rcx, %rcx
je 0x9d946
movq 0x10(%rsp), %rsi
subq %rcx, %rsi
movq %rcx, %rdi
callq 0xc830
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9d961
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xc830
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9d97c
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xc830
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x106ef(%rip), %rdi # 0xae081
leaq 0x10627(%rip), %rsi # 0xadfc0
leaq 0x106ff(%rip), %rcx # 0xae09f
movl $0x5e, %edx
callq 0xc520
leaq 0x106ab(%rip), %rdi # 0xae05c
leaq 0x10608(%rip), %rsi # 0xadfc0
leaq 0x106e0(%rip), %rcx # 0xae09f
movl $0x62, %edx
callq 0xc520
callq 0x14a48
movq %rax, %rbx
jmp 0x9d9f1
movq %rax, %rbx
jmp 0x9da0c
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x9d9f1
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0xc830
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9da0c
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xc830
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9da27
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xc830
movq %rbx, %rdi
callq 0xcdb0
| /libKriging[P]libKriging/src/lib/utils/jsonutils.cpp |
hpsolb_ | int hpsolb_(integer *n, doublereal *t, integer *iorder,
integer *iheap)
{
/* System generated locals */
integer i__1;
/* Local variables */
static integer i__, j, k;
static doublereal out, ddum;
static integer indxin, indxou;
/* ************ */
/* Subroutine hpsolb */
/* This subroutine sorts out the least element of t, and puts the */
/* remaining elements of t in a heap. */
/* n is an integer variable. */
/* On entry n is the dimension of the arrays t and iorder. */
/* On exit n is unchanged. */
/* t is a double precision array of dimension n. */
/* On entry t stores the elements to be sorted, */
/* On exit t(n) stores the least elements of t, and t(1) to t(n-1) */
/* stores the remaining elements in the form of a heap. */
/* iorder is an integer array of dimension n. */
/* On entry iorder(i) is the index of t(i). */
/* On exit iorder(i) is still the index of t(i), but iorder may be */
/* permuted in accordance with t. */
/* iheap is an integer variable specifying the task. */
/* On entry iheap should be set as follows: */
/* iheap .eq. 0 if t(1) to t(n) is not in the form of a heap, */
/* iheap .ne. 0 if otherwise. */
/* On exit iheap is unchanged. */
/* References: */
/* Algorithm 232 of CACM (J. W. J. Williams): HEAPSORT. */
/* * * * */
/* NEOS, November 1994. (Latest revision June 1996.) */
/* Optimization Technology Center. */
/* Argonne National Laboratory and Northwestern University. */
/* Written by */
/* Ciyou Zhu */
/* in collaboration with R.H. Byrd, P. Lu-Chen and J. Nocedal. */
/* ************ */
/* Parameter adjustments */
--iorder;
--t;
/* Function Body */
if (*iheap == 0) {
/* Rearrange the elements t(1) to t(n) to form a heap. */
i__1 = *n;
for (k = 2; k <= i__1; ++k) {
ddum = t[k];
indxin = iorder[k];
/* Add ddum to the heap. */
i__ = k;
L10:
if (i__ > 1) {
j = i__ / 2;
if (ddum < t[j]) {
t[i__] = t[j];
iorder[i__] = iorder[j];
i__ = j;
goto L10;
}
}
t[i__] = ddum;
iorder[i__] = indxin;
/* L20: */
}
}
/* Assign to 'out' the value of t(1), the least member of the heap, */
/* and rearrange the remaining members to form a heap as */
/* elements 1 to n-1 of t. */
if (*n > 1) {
i__ = 1;
out = t[1];
indxou = iorder[1];
ddum = t[*n];
indxin = iorder[*n];
/* Restore the heap */
L30:
j = i__ + i__;
if (j <= *n - 1) {
if (t[j + 1] < t[j]) {
++j;
}
if (t[j] < ddum) {
t[i__] = t[j];
iorder[i__] = iorder[j];
i__ = j;
goto L30;
}
}
t[i__] = ddum;
iorder[i__] = indxin;
/* Put the least member in t(n). */
t[*n] = out;
iorder[*n] = indxou;
}
return 0;
} | cmpl $0x0, (%rcx)
setne %al
movl (%rdi), %ecx
cmpl $0x2, %ecx
setl %r8b
orb %al, %r8b
jne 0xa3d30
movl %ecx, %eax
incq %rax
movl $0x2, %ecx
movsd -0x8(%rsi,%rcx,8), %xmm0
movl -0x4(%rdx,%rcx,4), %r8d
movl %ecx, %r9d
movl %r9d, %r10d
shrl %r9d
movsd -0x8(%rsi,%r9,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xa3d17
movsd %xmm1, -0x8(%rsi,%r10,8)
movl -0x4(%rdx,%r9,4), %r11d
movl %r11d, -0x4(%rdx,%r10,4)
cmpl $0x3, %r10d
ja 0xa3ceb
jmp 0xa3d1a
movq %r10, %r9
movsd %xmm0, -0x8(%rsi,%r9,8)
movl %r8d, -0x4(%rdx,%r9,4)
incq %rcx
cmpq %rax, %rcx
jne 0xa3cdd
movl (%rdi), %ecx
cmpl $0x2, %ecx
jl 0xa3dd0
pushq %rbx
movsd (%rsi), %xmm0
movl (%rdx), %eax
movl %ecx, %ecx
movsd -0x8(%rsi,%rcx,8), %xmm1
movl -0x4(%rdx,%rcx,4), %ecx
movl $0x1, %r8d
je 0xa3db6
movl $0x1, %r10d
movl $0x2, %r8d
movl %r8d, %r9d
orl $0x1, %r9d
movslq %r9d, %r11
movslq %r8d, %rbx
movsd -0x8(%rsi,%rbx,8), %xmm2
ucomisd -0x8(%rsi,%r11,8), %xmm2
ja 0xa3d7f
movl %r8d, %r9d
movslq %r9d, %r8
movsd -0x8(%rsi,%r8,8), %xmm2
ucomisd %xmm2, %xmm1
jbe 0xa3db0
movslq %r10d, %r10
movsd %xmm2, -0x8(%rsi,%r10,8)
movl -0x4(%rdx,%r8,4), %r11d
movl %r11d, -0x4(%rdx,%r10,4)
addl %r8d, %r8d
movl %r9d, %r10d
cmpl (%rdi), %r8d
jl 0xa3d60
jmp 0xa3db3
movl %r10d, %r9d
movslq %r9d, %r8
movsd %xmm1, -0x8(%rsi,%r8,8)
movl %ecx, -0x4(%rdx,%r8,4)
movslq (%rdi), %rcx
movsd %xmm0, -0x8(%rsi,%rcx,8)
movl %eax, -0x4(%rdx,%rcx,4)
popq %rbx
xorl %eax, %eax
retq
| /libKriging[P]libKriging/dependencies/lbfgsb_cpp/Lbfgsb.3.0/lbfgsb.c |
Wnrm2_ | doublereal dnrm2_(integer *n, doublereal *x, integer *incx)
{
/* System generated locals */
integer i__1, i__2;
doublereal ret_val, d__1, d__2, d__3;
/* Builtin functions */
double sqrt(doublereal);
/* Local variables */
static integer i__;
static doublereal scale;
/* ********** */
/* Function dnrm2 */
/* Given a vector x of length n, this function calculates the */
/* Euclidean norm of x with stride incx. */
/* The function statement is */
/* double precision function dnrm2(n,x,incx) */
/* where */
/* n is a positive integer input variable. */
/* x is an input array of length n. */
/* incx is a positive integer variable that specifies the */
/* stride of the vector. */
/* Subprograms called */
/* FORTRAN-supplied ... abs, max, sqrt */
/* MINPACK-2 Project. February 1991. */
/* Argonne National Laboratory. */
/* Brett M. Averick. */
/* ********** */
/* Parameter adjustments */
--x;
/* Function Body */
ret_val = 0.;
scale = 0.;
i__1 = *n;
i__2 = *incx;
for (i__ = 1; i__2 < 0 ? i__ >= i__1 : i__ <= i__1; i__ += i__2) {
/* Computing MAX */
d__2 = scale, d__3 = (d__1 = x[i__], abs(d__1));
scale = max(d__2,d__3);
/* L10: */
}
if (scale == 0.) {
return ret_val;
}
i__2 = *n;
i__1 = *incx;
for (i__ = 1; i__1 < 0 ? i__ >= i__2 : i__ <= i__2; i__ += i__1) {
/* Computing 2nd power */
d__1 = x[i__] / scale;
ret_val += d__1 * d__1;
/* L20: */
}
ret_val = scale * sqrt(ret_val);
return ret_val;
} | movslq (%rdi), %rax
xorl %edi, %edi
testq %rax, %rax
setg %dil
xorl %r8d, %r8d
cmpq $0x2, %rax
setl %r8b
movslq (%rdx), %rcx
testq %rcx, %rcx
cmovsl %r8d, %edi
xorpd %xmm0, %xmm0
cmpb $0x1, %dil
jne 0xa5901
leaq 0x1(%rcx), %rdx
xorpd %xmm1, %xmm1
xorl %r8d, %r8d
movapd 0xa0e(%rip), %xmm0 # 0xa62a0
leaq (%rdx,%r8), %r11
xorl %r10d, %r10d
xorl %r9d, %r9d
cmpq %rax, %r11
setge %r10b
setle %r9b
testl %ecx, %ecx
movsd (%rsi,%r8,8), %xmm2
movapd %xmm2, %xmm3
xorpd %xmm0, %xmm3
movapd %xmm3, %xmm4
cmplesd %xmm2, %xmm4
andpd %xmm4, %xmm2
andnpd %xmm3, %xmm4
orpd %xmm2, %xmm4
movapd %xmm4, %xmm3
cmplesd %xmm1, %xmm3
movapd %xmm3, %xmm2
andnpd %xmm4, %xmm2
andpd %xmm1, %xmm3
cmovsl %r10d, %r9d
orpd %xmm2, %xmm3
addq %rcx, %r8
movapd %xmm3, %xmm1
testb %r9b, %r9b
jne 0xa5892
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm3
jne 0xa5902
jp 0xa5902
retq
xorpd %xmm1, %xmm1
testb %dil, %dil
je 0xa5941
xorl %edi, %edi
leaq (%rdx,%rdi), %r8
xorl %r9d, %r9d
xorl %r10d, %r10d
cmpq %rax, %r8
setge %r9b
setle %r10b
testl %ecx, %ecx
movsd (%rsi,%rdi,8), %xmm2
divsd %xmm3, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
cmovsl %r9d, %r10d
addq %rcx, %rdi
testb %r10b, %r10b
jne 0xa590d
ucomisd %xmm1, %xmm0
jb 0xa594d
sqrtsd %xmm0, %xmm0
jmp 0xa5964
subq $0x18, %rsp
movapd %xmm3, (%rsp)
callq 0xc640
movapd (%rsp), %xmm3
addq $0x18, %rsp
mulsd %xmm0, %xmm3
movapd %xmm3, %xmm0
retq
| /libKriging[P]libKriging/dependencies/lbfgsb_cpp/Lbfgsb.3.0/blas.c |
void (anonymous namespace)::randomize_container<std::array<unsigned char, 32ul>>(std::array<unsigned char, 32ul>&) | void randomize_container(C& container) {
std::uniform_int_distribution<unsigned int> dist{
0, std::numeric_limits<typename C::value_type>::max()};
std::random_device rnd;
std::default_random_engine eng(rnd());
std::generate(container.begin(), container.end(), [&dist, &eng] { return dist(eng); });
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1398, %rsp # imm = 0x1398
movq %rdi, %rbx
movabsq $0xff00000000, %rax # imm = 0xFF00000000
movq %rax, (%rsp)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x56a4c
movq %r14, %rdi
callq 0x186f0
movl %eax, %ecx
leaq (%rcx,%rcx,2), %rcx
shrq $0x20, %rcx
movl %eax, %edx
subl %ecx, %edx
shrl %edx
addl %ecx, %edx
shrl $0x1e, %edx
movl %edx, %ecx
shll $0x1f, %ecx
orl %edx, %ecx
leal (%rax,%rcx), %edx
cmpl $0x1, %edx
adcl %eax, %ecx
leaq 0x8(%rsp), %r14
movq %rcx, (%r14)
xorl %r12d, %r12d
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x56ab6
movb %al, (%rbx,%r12)
incq %r12
cmpq $0x20, %r12
jne 0x32052
leaq 0x10(%rsp), %rdi
callq 0x18480
addq $0x1398, %rsp # imm = 0x1398
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x3209f
jmp 0x3208a
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x18480
movq %rbx, %rdi
callq 0x18900
movq %rax, %rdi
callq 0x374a0
| /IAIK[P]Picnic/tools/utils.h |
mbedtls_net_set_nonblock | int mbedtls_net_set_nonblock( mbedtls_net_context *ctx )
{
#if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \
!defined(EFI32)
u_long n = 1;
return( ioctlsocket( ctx->fd, FIONBIO, &n ) );
#else
return( fcntl( ctx->fd, F_SETFL, fcntl( ctx->fd, F_GETFL ) | O_NONBLOCK ) );
#endif
} | pushq %rbx
movl (%rdi), %ebx
movl %ebx, %edi
movl $0x3, %esi
xorl %eax, %eax
callq 0xf0b0
orl $0x800, %eax # imm = 0x800
movl %ebx, %edi
movl $0x4, %esi
movl %eax, %edx
xorl %eax, %eax
popq %rbx
jmp 0xf0b0
| /Dragonchang[P]https_client/mbedtls/library/net_sockets.c |
mbedtls_net_usleep | void mbedtls_net_usleep( unsigned long usec )
{
#if defined(_WIN32)
Sleep( ( usec + 999 ) / 1000 );
#else
struct timeval tv;
tv.tv_sec = usec / 1000000;
#if defined(__unix__) || defined(__unix) || \
( defined(__APPLE__) && defined(__MACH__) )
tv.tv_usec = (suseconds_t) usec % 1000000;
#else
tv.tv_usec = usec % 1000000;
#endif
select( 0, NULL, NULL, NULL, &tv );
#endif
} | subq $0x18, %rsp
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
movq %rdi, %rax
mulq %rcx
shrq $0x12, %rdx
leaq 0x8(%rsp), %r8
movq %rdx, (%r8)
movq %rdi, %rax
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x12, %rdx
addq %rax, %rdx
imulq $0xf4240, %rdx, %rax # imm = 0xF4240
subq %rax, %rdi
movq %rdi, 0x8(%r8)
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf260
addq $0x18, %rsp
retq
| /Dragonchang[P]https_client/mbedtls/library/net_sockets.c |
mbedtls_ssl_derive_keys | int mbedtls_ssl_derive_keys( mbedtls_ssl_context *ssl )
{
int ret = 0;
unsigned char tmp[64];
unsigned char keyblk[256];
unsigned char *key1;
unsigned char *key2;
unsigned char *mac_enc;
unsigned char *mac_dec;
size_t iv_copy_len;
const mbedtls_cipher_info_t *cipher_info;
const mbedtls_md_info_t *md_info;
mbedtls_ssl_session *session = ssl->session_negotiate;
mbedtls_ssl_transform *transform = ssl->transform_negotiate;
mbedtls_ssl_handshake_params *handshake = ssl->handshake;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> derive keys" ) );
cipher_info = mbedtls_cipher_info_from_type( transform->ciphersuite_info->cipher );
if( cipher_info == NULL )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "cipher info for %d not found",
transform->ciphersuite_info->cipher ) );
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
md_info = mbedtls_md_info_from_type( transform->ciphersuite_info->mac );
if( md_info == NULL )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "mbedtls_md info for %d not found",
transform->ciphersuite_info->mac ) );
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
/*
* Set appropriate PRF function and other SSL / TLS / TLS1.2 functions
*/
#if defined(MBEDTLS_SSL_PROTO_SSL3)
if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 )
{
handshake->tls_prf = ssl3_prf;
handshake->calc_verify = ssl_calc_verify_ssl;
handshake->calc_finished = ssl_calc_finished_ssl;
}
else
#endif
#if defined(MBEDTLS_SSL_PROTO_TLS1) || defined(MBEDTLS_SSL_PROTO_TLS1_1)
if( ssl->minor_ver < MBEDTLS_SSL_MINOR_VERSION_3 )
{
handshake->tls_prf = tls1_prf;
handshake->calc_verify = ssl_calc_verify_tls;
handshake->calc_finished = ssl_calc_finished_tls;
}
else
#endif
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
#if defined(MBEDTLS_SHA512_C)
if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 &&
transform->ciphersuite_info->mac == MBEDTLS_MD_SHA384 )
{
handshake->tls_prf = tls_prf_sha384;
handshake->calc_verify = ssl_calc_verify_tls_sha384;
handshake->calc_finished = ssl_calc_finished_tls_sha384;
}
else
#endif
#if defined(MBEDTLS_SHA256_C)
if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 )
{
handshake->tls_prf = tls_prf_sha256;
handshake->calc_verify = ssl_calc_verify_tls_sha256;
handshake->calc_finished = ssl_calc_finished_tls_sha256;
}
else
#endif
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
/*
* SSLv3:
* master =
* MD5( premaster + SHA1( 'A' + premaster + randbytes ) ) +
* MD5( premaster + SHA1( 'BB' + premaster + randbytes ) ) +
* MD5( premaster + SHA1( 'CCC' + premaster + randbytes ) )
*
* TLSv1+:
* master = PRF( premaster, "master secret", randbytes )[0..47]
*/
if( handshake->resume == 0 )
{
MBEDTLS_SSL_DEBUG_BUF( 3, "premaster secret", handshake->premaster,
handshake->pmslen );
#if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
if( ssl->handshake->extended_ms == MBEDTLS_SSL_EXTENDED_MS_ENABLED )
{
unsigned char session_hash[48];
size_t hash_len;
MBEDTLS_SSL_DEBUG_MSG( 3, ( "using extended master secret" ) );
ssl->handshake->calc_verify( ssl, session_hash );
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 )
{
#if defined(MBEDTLS_SHA512_C)
if( ssl->transform_negotiate->ciphersuite_info->mac ==
MBEDTLS_MD_SHA384 )
{
hash_len = 48;
}
else
#endif
hash_len = 32;
}
else
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
hash_len = 36;
MBEDTLS_SSL_DEBUG_BUF( 3, "session hash", session_hash, hash_len );
ret = handshake->tls_prf( handshake->premaster, handshake->pmslen,
"extended master secret",
session_hash, hash_len,
session->master, 48 );
if( ret != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "prf", ret );
return( ret );
}
}
else
#endif
ret = handshake->tls_prf( handshake->premaster, handshake->pmslen,
"master secret",
handshake->randbytes, 64,
session->master, 48 );
if( ret != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "prf", ret );
return( ret );
}
mbedtls_zeroize( handshake->premaster, sizeof(handshake->premaster) );
}
else
MBEDTLS_SSL_DEBUG_MSG( 3, ( "no premaster (session resumed)" ) );
/*
* Swap the client and server random values.
*/
memcpy( tmp, handshake->randbytes, 64 );
memcpy( handshake->randbytes, tmp + 32, 32 );
memcpy( handshake->randbytes + 32, tmp, 32 );
mbedtls_zeroize( tmp, sizeof( tmp ) );
/*
* SSLv3:
* key block =
* MD5( master + SHA1( 'A' + master + randbytes ) ) +
* MD5( master + SHA1( 'BB' + master + randbytes ) ) +
* MD5( master + SHA1( 'CCC' + master + randbytes ) ) +
* MD5( master + SHA1( 'DDDD' + master + randbytes ) ) +
* ...
*
* TLSv1:
* key block = PRF( master, "key expansion", randbytes )
*/
ret = handshake->tls_prf( session->master, 48, "key expansion",
handshake->randbytes, 64, keyblk, 256 );
if( ret != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "prf", ret );
return( ret );
}
MBEDTLS_SSL_DEBUG_MSG( 3, ( "ciphersuite = %s",
mbedtls_ssl_get_ciphersuite_name( session->ciphersuite ) ) );
MBEDTLS_SSL_DEBUG_BUF( 3, "master secret", session->master, 48 );
MBEDTLS_SSL_DEBUG_BUF( 4, "random bytes", handshake->randbytes, 64 );
MBEDTLS_SSL_DEBUG_BUF( 4, "key block", keyblk, 256 );
mbedtls_zeroize( handshake->randbytes, sizeof( handshake->randbytes ) );
/*
* Determine the appropriate key, IV and MAC length.
*/
transform->keylen = cipher_info->key_bitlen / 8;
if( cipher_info->mode == MBEDTLS_MODE_GCM ||
cipher_info->mode == MBEDTLS_MODE_CCM )
{
transform->maclen = 0;
transform->ivlen = 12;
transform->fixed_ivlen = 4;
/* Minimum length is expicit IV + tag */
transform->minlen = transform->ivlen - transform->fixed_ivlen
+ ( transform->ciphersuite_info->flags &
MBEDTLS_CIPHERSUITE_SHORT_TAG ? 8 : 16 );
}
else
{
/* Initialize HMAC contexts */
if( ( ret = mbedtls_md_setup( &transform->md_ctx_enc, md_info, 1 ) ) != 0 ||
( ret = mbedtls_md_setup( &transform->md_ctx_dec, md_info, 1 ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_md_setup", ret );
return( ret );
}
/* Get MAC length */
transform->maclen = mbedtls_md_get_size( md_info );
#if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
/*
* If HMAC is to be truncated, we shall keep the leftmost bytes,
* (rfc 6066 page 13 or rfc 2104 section 4),
* so we only need to adjust the length here.
*/
if( session->trunc_hmac == MBEDTLS_SSL_TRUNC_HMAC_ENABLED )
transform->maclen = MBEDTLS_SSL_TRUNCATED_HMAC_LEN;
#endif /* MBEDTLS_SSL_TRUNCATED_HMAC */
/* IV length */
transform->ivlen = cipher_info->iv_size;
/* Minimum length */
if( cipher_info->mode == MBEDTLS_MODE_STREAM )
transform->minlen = transform->maclen;
else
{
/*
* GenericBlockCipher:
* 1. if EtM is in use: one block plus MAC
* otherwise: * first multiple of blocklen greater than maclen
* 2. IV except for SSL3 and TLS 1.0
*/
#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
if( session->encrypt_then_mac == MBEDTLS_SSL_ETM_ENABLED )
{
transform->minlen = transform->maclen
+ cipher_info->block_size;
}
else
#endif
{
transform->minlen = transform->maclen
+ cipher_info->block_size
- transform->maclen % cipher_info->block_size;
}
#if defined(MBEDTLS_SSL_PROTO_SSL3) || defined(MBEDTLS_SSL_PROTO_TLS1)
if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 ||
ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_1 )
; /* No need to adjust minlen */
else
#endif
#if defined(MBEDTLS_SSL_PROTO_TLS1_1) || defined(MBEDTLS_SSL_PROTO_TLS1_2)
if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_2 ||
ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 )
{
transform->minlen += transform->ivlen;
}
else
#endif
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
}
}
MBEDTLS_SSL_DEBUG_MSG( 3, ( "keylen: %d, minlen: %d, ivlen: %d, maclen: %d",
transform->keylen, transform->minlen, transform->ivlen,
transform->maclen ) );
/*
* Finally setup the cipher contexts, IVs and MAC secrets.
*/
#if defined(MBEDTLS_SSL_CLI_C)
if( ssl->conf->endpoint == MBEDTLS_SSL_IS_CLIENT )
{
key1 = keyblk + transform->maclen * 2;
key2 = keyblk + transform->maclen * 2 + transform->keylen;
mac_enc = keyblk;
mac_dec = keyblk + transform->maclen;
/*
* This is not used in TLS v1.1.
*/
iv_copy_len = ( transform->fixed_ivlen ) ?
transform->fixed_ivlen : transform->ivlen;
memcpy( transform->iv_enc, key2 + transform->keylen, iv_copy_len );
memcpy( transform->iv_dec, key2 + transform->keylen + iv_copy_len,
iv_copy_len );
}
else
#endif /* MBEDTLS_SSL_CLI_C */
#if defined(MBEDTLS_SSL_SRV_C)
if( ssl->conf->endpoint == MBEDTLS_SSL_IS_SERVER )
{
key1 = keyblk + transform->maclen * 2 + transform->keylen;
key2 = keyblk + transform->maclen * 2;
mac_enc = keyblk + transform->maclen;
mac_dec = keyblk;
/*
* This is not used in TLS v1.1.
*/
iv_copy_len = ( transform->fixed_ivlen ) ?
transform->fixed_ivlen : transform->ivlen;
memcpy( transform->iv_dec, key1 + transform->keylen, iv_copy_len );
memcpy( transform->iv_enc, key1 + transform->keylen + iv_copy_len,
iv_copy_len );
}
else
#endif /* MBEDTLS_SSL_SRV_C */
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
#if defined(MBEDTLS_SSL_PROTO_SSL3)
if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 )
{
if( transform->maclen > sizeof transform->mac_enc )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
memcpy( transform->mac_enc, mac_enc, transform->maclen );
memcpy( transform->mac_dec, mac_dec, transform->maclen );
}
else
#endif /* MBEDTLS_SSL_PROTO_SSL3 */
#if defined(MBEDTLS_SSL_PROTO_TLS1) || defined(MBEDTLS_SSL_PROTO_TLS1_1) || \
defined(MBEDTLS_SSL_PROTO_TLS1_2)
if( ssl->minor_ver >= MBEDTLS_SSL_MINOR_VERSION_1 )
{
mbedtls_md_hmac_starts( &transform->md_ctx_enc, mac_enc, transform->maclen );
mbedtls_md_hmac_starts( &transform->md_ctx_dec, mac_dec, transform->maclen );
}
else
#endif
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
#if defined(MBEDTLS_SSL_HW_RECORD_ACCEL)
if( mbedtls_ssl_hw_record_init != NULL )
{
int ret = 0;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "going for mbedtls_ssl_hw_record_init()" ) );
if( ( ret = mbedtls_ssl_hw_record_init( ssl, key1, key2, transform->keylen,
transform->iv_enc, transform->iv_dec,
iv_copy_len,
mac_enc, mac_dec,
transform->maclen ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_hw_record_init", ret );
return( MBEDTLS_ERR_SSL_HW_ACCEL_FAILED );
}
}
#endif /* MBEDTLS_SSL_HW_RECORD_ACCEL */
#if defined(MBEDTLS_SSL_EXPORT_KEYS)
if( ssl->conf->f_export_keys != NULL )
{
ssl->conf->f_export_keys( ssl->conf->p_export_keys,
session->master, keyblk,
transform->maclen, transform->keylen,
iv_copy_len );
}
#endif
if( ( ret = mbedtls_cipher_setup( &transform->cipher_ctx_enc,
cipher_info ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_cipher_setup", ret );
return( ret );
}
if( ( ret = mbedtls_cipher_setup( &transform->cipher_ctx_dec,
cipher_info ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_cipher_setup", ret );
return( ret );
}
if( ( ret = mbedtls_cipher_setkey( &transform->cipher_ctx_enc, key1,
cipher_info->key_bitlen,
MBEDTLS_ENCRYPT ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_cipher_setkey", ret );
return( ret );
}
if( ( ret = mbedtls_cipher_setkey( &transform->cipher_ctx_dec, key2,
cipher_info->key_bitlen,
MBEDTLS_DECRYPT ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_cipher_setkey", ret );
return( ret );
}
#if defined(MBEDTLS_CIPHER_MODE_CBC)
if( cipher_info->mode == MBEDTLS_MODE_CBC )
{
if( ( ret = mbedtls_cipher_set_padding_mode( &transform->cipher_ctx_enc,
MBEDTLS_PADDING_NONE ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_cipher_set_padding_mode", ret );
return( ret );
}
if( ( ret = mbedtls_cipher_set_padding_mode( &transform->cipher_ctx_dec,
MBEDTLS_PADDING_NONE ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_cipher_set_padding_mode", ret );
return( ret );
}
}
#endif /* MBEDTLS_CIPHER_MODE_CBC */
mbedtls_zeroize( keyblk, sizeof( keyblk ) );
#if defined(MBEDTLS_ZLIB_SUPPORT)
// Initialize compression
//
if( session->compression == MBEDTLS_SSL_COMPRESS_DEFLATE )
{
if( ssl->compress_buf == NULL )
{
MBEDTLS_SSL_DEBUG_MSG( 3, ( "Allocating compression buffer" ) );
ssl->compress_buf = mbedtls_calloc( 1, MBEDTLS_SSL_BUFFER_LEN );
if( ssl->compress_buf == NULL )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "alloc(%d bytes) failed",
MBEDTLS_SSL_BUFFER_LEN ) );
return( MBEDTLS_ERR_SSL_ALLOC_FAILED );
}
}
MBEDTLS_SSL_DEBUG_MSG( 3, ( "Initializing zlib states" ) );
memset( &transform->ctx_deflate, 0, sizeof( transform->ctx_deflate ) );
memset( &transform->ctx_inflate, 0, sizeof( transform->ctx_inflate ) );
if( deflateInit( &transform->ctx_deflate,
Z_DEFAULT_COMPRESSION ) != Z_OK ||
inflateInit( &transform->ctx_inflate ) != Z_OK )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "Failed to initialize compression" ) );
return( MBEDTLS_ERR_SSL_COMPRESSION_FAILED );
}
}
#endif /* MBEDTLS_ZLIB_SUPPORT */
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= derive keys" ) );
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdi, %rbx
movq 0x58(%rdi), %rbp
movq 0x60(%rdi), %r12
movq 0x80(%rdi), %r14
leaq 0x3bb06(%rip), %rdx # 0x4c4bc
leaq 0x3bb6b(%rip), %r8 # 0x4c528
movl $0x2, %esi
movl $0x1f5, %ecx # imm = 0x1F5
xorl %eax, %eax
callq 0xf997
movq (%r14), %rax
movl 0x10(%rax), %edi
callq 0x2a04f
movq %rax, %r15
movq (%r14), %rax
testq %r15, %r15
je 0x10b66
movl 0x14(%rax), %edi
callq 0x38cdb
testq %rax, %rax
je 0x10b87
movq %rax, %rcx
movl 0x18(%rbx), %eax
cmpl $0x2, %eax
jg 0x10bc9
leaq 0x932(%rip), %rax # 0x11341
movq %rax, 0x608(%r12)
leaq 0xc64(%rip), %rax # 0x11682
movq %rax, 0x5f8(%r12)
leaq 0xd46(%rip), %rax # 0x11773
movq %rax, 0x600(%r12)
movq %rcx, 0x28(%rsp)
cmpl $0x0, 0xa7c(%r12)
je 0x10c09
leaq 0x3ba6c(%rip), %rdx # 0x4c4bc
leaq 0x3bb71(%rip), %r8 # 0x4c5c8
movq %rbx, %rdi
movl $0x3, %esi
movl $0x27c, %ecx # imm = 0x27C
xorl %eax, %eax
callq 0xf997
movq %r14, 0x48(%rsp)
leaq 0x618(%r12), %r13
movups 0x618(%r12), %xmm0
movups 0x628(%r12), %xmm1
movups 0x638(%r12), %xmm2
movups 0x648(%r12), %xmm3
movaps %xmm3, 0x80(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movups 0x638(%r12), %xmm0
movups 0x648(%r12), %xmm1
movups %xmm0, 0x618(%r12)
movups %xmm1, 0x628(%r12)
movaps 0x50(%rsp), %xmm0
movaps 0x60(%rsp), %xmm1
movups %xmm0, 0x638(%r12)
movups %xmm1, 0x648(%r12)
xorl %eax, %eax
movb $0x0, 0x50(%rsp,%rax)
incq %rax
cmpq $0x40, %rax
jne 0x10af5
leaq 0x38(%rbp), %r14
movq $0x100, (%rsp) # imm = 0x100
leaq 0x3bad1(%rip), %rdx # 0x4c5e7
leaq 0x90(%rsp), %r9
movl $0x30, %esi
movl $0x40, %r8d
movq %r14, %rdi
movq %r13, %rcx
callq *0x608(%r12)
testl %eax, %eax
je 0x10d71
movl %eax, %ebp
leaq 0x3b974(%rip), %rdx # 0x4c4bc
leaq 0x3ba75(%rip), %r8 # 0x4c5c4
movq %rbx, %rdi
movl $0x1, %esi
movl $0x296, %ecx # imm = 0x296
movl %ebp, %r9d
callq 0xfa82
jmp 0x10bb5
movl 0x10(%rax), %r9d
leaq 0x3b94b(%rip), %rdx # 0x4c4bc
leaq 0x3b9bf(%rip), %r8 # 0x4c537
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1fb, %ecx # imm = 0x1FB
jmp 0x10ba9
movq (%r14), %rax
movl 0x14(%rax), %r9d
leaq 0x3b927(%rip), %rdx # 0x4c4bc
leaq 0x3b9b8(%rip), %r8 # 0x4c554
movq %rbx, %rdi
movl $0x1, %esi
movl $0x203, %ecx # imm = 0x203
xorl %eax, %eax
callq 0xf997
movl $0xffff8f00, %ebp # imm = 0xFFFF8F00
movl %ebp, %eax
addq $0x198, %rsp # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x3, %eax
jne 0x10d45
movq (%r14), %rax
cmpl $0x7, 0x14(%rax)
jne 0x1106f
leaq 0xd61(%rip), %rax # 0x11947
movq %rax, 0x608(%r12)
leaq 0xd7a(%rip), %rax # 0x1196f
movq %rax, 0x5f8(%r12)
leaq 0xe29(%rip), %rax # 0x11a2d
jmp 0x10a2d
leaq 0x658(%r12), %r13
movq 0x610(%r12), %rax
movq %rax, (%rsp)
leaq 0x3b898(%rip), %rdx # 0x4c4bc
leaq 0x3b95e(%rip), %r8 # 0x4c589
movq %rbx, %rdi
movl $0x3, %esi
movl $0x243, %ecx # imm = 0x243
movq %r13, %r9
callq 0xfb06
movq 0x60(%rbx), %rax
cmpl $0x1, 0xa90(%rax)
movq %rbp, 0x18(%rsp)
jne 0x11011
movq %r15, 0x20(%rsp)
leaq 0x3b85a(%rip), %rdx # 0x4c4bc
leaq 0x3b931(%rip), %r8 # 0x4c59a
movq %rbx, %rdi
movl $0x3, %esi
movl $0x24b, %ecx # imm = 0x24B
xorl %eax, %eax
callq 0xf997
movq 0x60(%rbx), %rax
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq *0x5f8(%rax)
movl $0x24, %r15d
cmpl $0x3, 0x18(%rbx)
jne 0x10cbb
movq 0x80(%rbx), %rax
movq (%rax), %rax
xorl %r15d, %r15d
cmpl $0x7, 0x14(%rax)
sete %r15b
shll $0x4, %r15d
orq $0x20, %r15
movq %r15, (%rsp)
leaq 0x3b7f6(%rip), %rdx # 0x4c4bc
leaq 0x3b8ea(%rip), %r8 # 0x4c5b7
leaq 0x90(%rsp), %rbp
movq %rbx, %rdi
movl $0x3, %esi
movl $0x260, %ecx # imm = 0x260
movq %rbp, %r9
callq 0xfb06
movq 0x610(%r12), %rsi
movq 0x18(%rsp), %rax
leaq 0x38(%rax), %r9
movq $0x30, (%rsp)
leaq 0x3b896(%rip), %rdx # 0x4c5a0
movq %r13, %rdi
movq %rbp, %rcx
movq %r15, %r8
callq *0x608(%r12)
testl %eax, %eax
je 0x1110e
movl %eax, %ebp
leaq 0x3b790(%rip), %rdx # 0x4c4bc
leaq 0x3b891(%rip), %r8 # 0x4c5c4
movq %rbx, %rdi
movl $0x1, %esi
movl $0x268, %ecx # imm = 0x268
jmp 0x10b5c
leaq 0x3b770(%rip), %rdx # 0x4c4bc
leaq 0x3b822(%rip), %r8 # 0x4c575
movq %rbx, %rdi
movl $0x1, %esi
movl $0x232, %ecx # imm = 0x232
xorl %eax, %eax
callq 0xf997
movl $0xffff9400, %ebp # imm = 0xFFFF9400
jmp 0x10bb5
movq %r15, 0x20(%rsp)
movq %rbp, %r12
movl 0x8(%rbp), %edi
callq 0x190e4
leaq 0x3b734(%rip), %rbp # 0x4c4bc
leaq 0x3b866(%rip), %r8 # 0x4c5f5
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x3, %esi
movq %rbp, %rdx
movl $0x29b, %ecx # imm = 0x29B
movq %rax, %r9
xorl %eax, %eax
callq 0xf997
movq $0x30, (%rsp)
leaq 0x3b7ee(%rip), %r8 # 0x4c5a9
movq %rbx, %rdi
movl $0x3, %esi
movq %rbp, %rdx
movl $0x29c, %ecx # imm = 0x29C
movq %r14, 0x40(%rsp)
movq %r14, %r9
callq 0xfb06
movq $0x40, (%rsp)
leaq 0x3efea(%rip), %r8 # 0x4fdd1
movq %rbx, %rdi
movl $0x4, %esi
movq %rbp, %rdx
movl $0x29d, %ecx # imm = 0x29D
movq %r13, %r9
callq 0xfb06
movq $0x100, (%rsp) # imm = 0x100
leaq 0x3b7f8(%rip), %r8 # 0x4c606
leaq 0x90(%rsp), %rax
movq %rbx, %rdi
movl $0x4, %esi
movq %rbp, %rdx
movq %rax, %rbp
movl $0x29e, %ecx # imm = 0x29E
movq %rax, %r9
callq 0xfb06
movb $0x0, (%r13,%r15)
incq %r15
cmpq $0x40, %r15
jne 0x10e31
movq 0x20(%rsp), %r15
movl 0x8(%r15), %eax
shrl $0x3, %eax
movq 0x48(%rsp), %r14
movl %eax, 0x8(%r14)
movl 0x4(%r15), %eax
cmpl $0x8, %eax
je 0x10e67
cmpl $0x6, %eax
jne 0x11099
movq $0x0, 0x28(%r14)
movq $0xc, 0x18(%r14)
movq $0x4, 0x20(%r14)
movq (%r14), %rax
xorl %ecx, %ecx
testb $0x2, 0x2c(%rax)
sete %cl
leaq 0x10(,%rcx,8), %rdi
movq %rdi, 0x10(%r14)
movl $0xc, %esi
xorl %ecx, %ecx
movl 0x8(%r14), %r9d
movq %rcx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, (%rsp)
leaq 0x3b605(%rip), %rdx # 0x4c4bc
leaq 0x3b763(%rip), %r8 # 0x4c621
movq %rbx, %rdi
movl $0x3, %esi
movl $0x2ff, %ecx # imm = 0x2FF
xorl %eax, %eax
callq 0xf997
movq (%rbx), %rax
movl 0x174(%rax), %ecx
andl $0x1, %ecx
movq 0x28(%r14), %rsi
leaq (%rsp,%rsi,2), %rdx
addq $0x90, %rdx
movl 0x8(%r14), %eax
leaq (%rdx,%rax), %r12
movl %ecx, %edi
shll $0x4, %edi
addq $0x30, %rdi
xorl %r15d, %r15d
testl %ecx, %ecx
movq %rsi, 0x28(%rsp)
leaq 0x90(%rsp,%rsi), %r13
movq %rbp, %rcx
cmoveq %r13, %rcx
movq %rcx, 0x18(%rsp)
sete %r15b
cmoveq %rbp, %r13
movq %rdx, %rcx
cmoveq %r12, %rcx
movq %rcx, 0x30(%rsp)
cmovneq %r12, %rdx
movq %rdx, 0x38(%rsp)
movq 0x20(%r14), %rbp
shll $0x4, %r15d
addq $0x30, %r15
testq %rbp, %rbp
jne 0x10f4e
movq 0x18(%r14), %rbp
addq %r14, %rdi
addq %rax, %r12
movq %r12, %rsi
movq %rbp, %rdx
callq 0xf240
addq %r14, %r15
addq %rbp, %r12
movq %r15, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0xf240
cmpl $0x0, 0x18(%rbx)
jle 0x110ee
leaq 0x50(%r14), %rdi
movq %r13, %rsi
movq 0x28(%rsp), %rdx
callq 0x38fa0
leaq 0x68(%r14), %rdi
movq 0x28(%r14), %rdx
movq 0x18(%rsp), %rsi
callq 0x38fa0
movq (%rbx), %rcx
movq 0xb8(%rcx), %rax
testq %rax, %rax
je 0x10fd0
movq 0xc0(%rcx), %rdi
movq 0x28(%r14), %rcx
movl 0x8(%r14), %r8d
leaq 0x90(%rsp), %rdx
movq 0x40(%rsp), %rsi
movq %rbp, %r9
callq *%rax
leaq 0x80(%r14), %r12
movq %r12, %rdi
movq 0x20(%rsp), %r15
movq %r15, %rsi
callq 0x2a149
testl %eax, %eax
je 0x11130
movl %eax, %ebp
leaq 0x3b4c4(%rip), %rdx # 0x4c4bc
leaq 0x3b650(%rip), %r8 # 0x4c64f
movq %rbx, %rdi
movl $0x1, %esi
movl $0x36d, %ecx # imm = 0x36D
jmp 0x10b5c
movq 0x610(%r12), %rsi
leaq 0x618(%r12), %rcx
leaq 0x38(%rbp), %r9
movq $0x30, (%rsp)
leaq 0x3b575(%rip), %rdx # 0x4c5a9
movl $0x40, %r8d
movq %r13, %rdi
callq *0x608(%r12)
testl %eax, %eax
je 0x11113
movl %eax, %ebp
leaq 0x3b466(%rip), %rdx # 0x4c4bc
leaq 0x3b567(%rip), %r8 # 0x4c5c4
movq %rbx, %rdi
movl $0x1, %esi
movl $0x275, %ecx # imm = 0x275
jmp 0x10b5c
leaq 0xb1a(%rip), %rax # 0x11b90
movq %rax, 0x608(%r12)
leaq 0xb33(%rip), %rax # 0x11bb8
movq %rax, 0x5f8(%r12)
leaq 0xbdc(%rip), %rax # 0x11c70
jmp 0x10a2d
leaq 0x50(%r14), %rdi
movq 0x28(%rsp), %r13
movq %r13, %rsi
movl $0x1, %edx
callq 0x38da1
testl %eax, %eax
jne 0x110cc
leaq 0x68(%r14), %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x38da1
testl %eax, %eax
je 0x111a8
movl %eax, %ebp
leaq 0x3b3e7(%rip), %rdx # 0x4c4bc
leaq 0x3b534(%rip), %r8 # 0x4c610
movq %rbx, %rdi
movl $0x1, %esi
movl $0x2bb, %ecx # imm = 0x2BB
jmp 0x10b5c
leaq 0x3b3c7(%rip), %rdx # 0x4c4bc
leaq 0x3b479(%rip), %r8 # 0x4c575
movq %rbx, %rdi
movl $0x1, %esi
movl $0x349, %ecx # imm = 0x349
jmp 0x10d60
movq 0x20(%rsp), %r15
xorl %eax, %eax
movq 0x18(%rsp), %rbp
movb $0x0, (%r13,%rax)
incq %rax
cmpq $0x424, %rax # imm = 0x424
jne 0x1111a
jmp 0x10a6b
addq $0xd8, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x2a149
testl %eax, %eax
je 0x11168
movl %eax, %ebp
leaq 0x3b36d(%rip), %rdx # 0x4c4bc
leaq 0x3b4f9(%rip), %r8 # 0x4c64f
movq %rbx, %rdi
movl $0x1, %esi
movl $0x374, %ecx # imm = 0x374
jmp 0x10b5c
movl 0x8(%r15), %edx
movq %r12, %rdi
movq 0x38(%rsp), %rsi
movl $0x1, %ecx
callq 0x2a207
testl %eax, %eax
je 0x11239
movl %eax, %ebp
leaq 0x3b32d(%rip), %rdx # 0x4c4bc
leaq 0x3b4ce(%rip), %r8 # 0x4c664
movq %rbx, %rdi
movl $0x1, %esi
movl $0x37c, %ecx # imm = 0x37C
jmp 0x10b5c
movq %r13, %rdi
callq 0x39265
movzbl %al, %eax
cmpl $0x1, 0x90(%r12)
movl $0xa, %ecx
cmovneq %rax, %rcx
movq %rcx, 0x28(%r14)
movl 0x18(%r15), %esi
movq %rsi, 0x18(%r14)
cmpl $0x7, 0x4(%r15)
jne 0x111ec
movq %rcx, 0x10(%r14)
movq %rcx, %rdi
leaq 0x90(%rsp), %rbp
jmp 0x10e9e
movl 0x20(%r15), %r8d
leaq (%rcx,%r8), %rdi
cmpl $0x1, 0x94(%r12)
leaq 0x90(%rsp), %rbp
je 0x11211
movl %ecx, %eax
xorl %edx, %edx
divl %r8d
subq %rdx, %rdi
movq %rdi, 0x10(%r14)
movl 0x18(%rbx), %eax
cmpl $0x2, %eax
jb 0x10e9e
addl $-0x2, %eax
cmpl $0x1, %eax
ja 0x112b0
addq %rsi, %rdi
movq %rdi, 0x10(%r14)
jmp 0x10e9e
movl 0x8(%r15), %edx
movq %r14, %rdi
movq 0x30(%rsp), %rsi
xorl %ecx, %ecx
callq 0x2a207
testl %eax, %eax
je 0x11272
movl %eax, %ebp
leaq 0x3b263(%rip), %rdx # 0x4c4bc
leaq 0x3b404(%rip), %r8 # 0x4c664
movq %rbx, %rdi
movl $0x1, %esi
movl $0x384, %ecx # imm = 0x384
jmp 0x10b5c
cmpl $0x2, 0x4(%r15)
jne 0x11303
movq %r12, %rdi
movl $0x4, %esi
callq 0x2a1c7
testl %eax, %eax
je 0x112d0
movl %eax, %ebp
leaq 0x3b225(%rip), %rdx # 0x4c4bc
leaq 0x3b3dc(%rip), %r8 # 0x4c67a
movq %rbx, %rdi
movl $0x1, %esi
movl $0x38e, %ecx # imm = 0x38E
jmp 0x10b5c
leaq 0x3b205(%rip), %rdx # 0x4c4bc
leaq 0x3b2b7(%rip), %r8 # 0x4c575
movq %rbx, %rdi
movl $0x1, %esi
movl $0x2f7, %ecx # imm = 0x2F7
jmp 0x10d60
movq %r14, %rdi
movl $0x4, %esi
callq 0x2a1c7
testl %eax, %eax
je 0x11303
movl %eax, %ebp
leaq 0x3b1d2(%rip), %rdx # 0x4c4bc
leaq 0x3b389(%rip), %r8 # 0x4c67a
movq %rbx, %rdi
movl $0x1, %esi
movl $0x395, %ecx # imm = 0x395
jmp 0x10b5c
xorl %eax, %eax
movb $0x0, 0x90(%rsp,%rax)
incq %rax
cmpq $0x100, %rax # imm = 0x100
jne 0x11305
leaq 0x3b19d(%rip), %rdx # 0x4c4bc
leaq 0x3b374(%rip), %r8 # 0x4c69a
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x2, %esi
movl $0x3bd, %ecx # imm = 0x3BD
xorl %eax, %eax
callq 0xf997
jmp 0x10bb5
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
ssl_calc_verify_tls | void ssl_calc_verify_tls( mbedtls_ssl_context *ssl, unsigned char hash[36] )
{
mbedtls_md5_context md5;
mbedtls_sha1_context sha1;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> calc verify tls" ) );
mbedtls_md5_init( &md5 );
mbedtls_sha1_init( &sha1 );
mbedtls_md5_clone( &md5, &ssl->handshake->fin_md5 );
mbedtls_sha1_clone( &sha1, &ssl->handshake->fin_sha1 );
mbedtls_md5_finish( &md5, hash );
mbedtls_sha1_finish( &sha1, hash + 16 );
MBEDTLS_SSL_DEBUG_BUF( 3, "calculated verify result", hash, 36 );
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= calc verify" ) );
mbedtls_md5_free( &md5 );
mbedtls_sha1_free( &sha1 );
return;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x3ae1d(%rip), %r14 # 0x4c4bc
leaq 0x3c05c(%rip), %r8 # 0x4d702
movl $0x2, %esi
movq %r14, %rdx
movl $0x3f9, %ecx # imm = 0x3F9
xorl %eax, %eax
callq 0xf997
leaq 0xc(%rsp), %r12
movq %r12, %rdi
callq 0x3928c
leaq 0x64(%rsp), %r13
movq %r13, %rdi
callq 0x40c04
movl $0x3f8, %esi # imm = 0x3F8
addq 0x60(%rbx), %rsi
movq %r12, %rdi
callq 0x392c0
movl $0x450, %esi # imm = 0x450
addq 0x60(%rbx), %rsi
movq %r13, %rdi
callq 0x40c34
movq %r12, %rdi
movq %r15, %rsi
callq 0x39b50
leaq 0x10(%r15), %rsi
movq %r13, %rdi
callq 0x41e45
movq $0x24, (%rsp)
leaq 0x3bff9(%rip), %r8 # 0x4d715
movq %rbx, %rdi
movl $0x3, %esi
movq %r14, %rdx
movl $0x404, %ecx # imm = 0x404
movq %r15, %r9
callq 0xfb06
leaq 0x3bff3(%rip), %r8 # 0x4d72e
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
movl $0x405, %ecx # imm = 0x405
xorl %eax, %eax
callq 0xf997
movq %r12, %rdi
callq 0x392ab
movq %r13, %rdi
callq 0x40c1f
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
ssl_calc_finished_tls_sha256 | static void ssl_calc_finished_tls_sha256(
mbedtls_ssl_context *ssl, unsigned char *buf, int from )
{
int len = 12;
const char *sender;
mbedtls_sha256_context sha256;
unsigned char padbuf[32];
mbedtls_ssl_session *session = ssl->session_negotiate;
if( !session )
session = ssl->session;
mbedtls_sha256_init( &sha256 );
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> calc finished tls sha256" ) );
mbedtls_sha256_clone( &sha256, &ssl->handshake->fin_sha256 );
/*
* TLSv1.2:
* hash = PRF( master, finished_label,
* Hash( handshake ) )[0.11]
*/
#if !defined(MBEDTLS_SHA256_ALT)
MBEDTLS_SSL_DEBUG_BUF( 4, "finished sha2 state", (unsigned char *)
sha256.state, sizeof( sha256.state ) );
#endif
sender = ( from == MBEDTLS_SSL_IS_CLIENT )
? "client finished"
: "server finished";
mbedtls_sha256_finish( &sha256, padbuf );
ssl->handshake->tls_prf( session->master, 48, sender,
padbuf, 32, buf, len );
MBEDTLS_SSL_DEBUG_BUF( 3, "calc finished result", buf, len );
mbedtls_sha256_free( &sha256 );
mbedtls_zeroize( padbuf, sizeof( padbuf ) );
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= calc finished" ) );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %edx, %ebp
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
movq 0x58(%rdi), %r12
testq %r12, %r12
jne 0x11c98
movq 0x50(%rbx), %r12
leaq 0x3c(%rsp), %r14
movq %r14, %rdi
callq 0x42170
leaq 0x3a810(%rip), %r13 # 0x4c4bc
leaq 0x3c24d(%rip), %r8 # 0x4df00
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x2, %esi
movq %r13, %rdx
movl $0x12f8, %ecx # imm = 0x12F8
xorl %eax, %eax
callq 0xf997
movl $0x4ac, %esi # imm = 0x4AC
addq 0x60(%rbx), %rsi
movq %r14, %rdi
callq 0x421a4
leaq 0x44(%rsp), %r9
movq $0x20, (%rsp)
leaq 0x3c22b(%rip), %r8 # 0x4df1d
movq %rbx, %rdi
movl $0x4, %esi
movq %r13, %rdx
movl $0x1304, %ecx # imm = 0x1304
callq 0xfb06
testl %ebp, %ebp
leaq 0x3c1a9(%rip), %rax # 0x4deb9
leaq 0x3c1b2(%rip), %rbp # 0x4dec9
cmoveq %rax, %rbp
leaq 0x10(%rsp), %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x42cc1
movq 0x60(%rbx), %rax
addq $0x38, %r12
movl $0xc, %r14d
movq %r14, (%rsp)
movl $0x30, %esi
movl $0x20, %r8d
movq %r12, %rdi
movq %rbp, %rdx
movq %r13, %rcx
movq 0x8(%rsp), %r12
movq %r12, %r9
callq *0x608(%rax)
movq %r14, (%rsp)
leaq 0x3c16f(%rip), %r8 # 0x4ded9
movq %rbx, %rdi
movl $0x3, %esi
leaq 0x3a743(%rip), %rdx # 0x4c4bc
movl $0x1310, %ecx # imm = 0x1310
movq %r12, %r9
callq 0xfb06
leaq 0x3c(%rsp), %rdi
callq 0x4218f
movb $0x0, 0x10(%rsp,%r15)
incq %r15
cmpq $0x20, %r15
jne 0x11d90
leaq 0x3a716(%rip), %rdx # 0x4c4bc
leaq 0x3c141(%rip), %r8 # 0x4deee
movq %rbx, %rdi
movl $0x2, %esi
movl $0x1316, %ecx # imm = 0x1316
xorl %eax, %eax
callq 0xf997
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_fetch_input | int mbedtls_ssl_fetch_input( mbedtls_ssl_context *ssl, size_t nb_want )
{
int ret;
size_t len;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> fetch input" ) );
if( ssl->f_recv == NULL && ssl->f_recv_timeout == NULL )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "Bad usage of mbedtls_ssl_set_bio() "
"or mbedtls_ssl_set_bio()" ) );
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
if( nb_want > MBEDTLS_SSL_BUFFER_LEN - (size_t)( ssl->in_hdr - ssl->in_buf ) )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "requesting more data than fits" ) );
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
uint32_t timeout;
/* Just to be sure */
if( ssl->f_set_timer == NULL || ssl->f_get_timer == NULL )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "You must use "
"mbedtls_ssl_set_timer_cb() for DTLS" ) );
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
/*
* The point is, we need to always read a full datagram at once, so we
* sometimes read more then requested, and handle the additional data.
* It could be the rest of the current record (while fetching the
* header) and/or some other records in the same datagram.
*/
/*
* Move to the next record in the already read datagram if applicable
*/
if( ssl->next_record_offset != 0 )
{
if( ssl->in_left < ssl->next_record_offset )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
ssl->in_left -= ssl->next_record_offset;
if( ssl->in_left != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 2, ( "next record in same datagram, offset: %d",
ssl->next_record_offset ) );
memmove( ssl->in_hdr,
ssl->in_hdr + ssl->next_record_offset,
ssl->in_left );
}
ssl->next_record_offset = 0;
}
MBEDTLS_SSL_DEBUG_MSG( 2, ( "in_left: %d, nb_want: %d",
ssl->in_left, nb_want ) );
/*
* Done if we already have enough data.
*/
if( nb_want <= ssl->in_left)
{
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= fetch input" ) );
return( 0 );
}
/*
* A record can't be split accross datagrams. If we need to read but
* are not at the beginning of a new record, the caller did something
* wrong.
*/
if( ssl->in_left != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
/*
* Don't even try to read if time's out already.
* This avoids by-passing the timer when repeatedly receiving messages
* that will end up being dropped.
*/
if( ssl_check_timer( ssl ) != 0 )
ret = MBEDTLS_ERR_SSL_TIMEOUT;
else
{
len = MBEDTLS_SSL_BUFFER_LEN - ( ssl->in_hdr - ssl->in_buf );
if( ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER )
timeout = ssl->handshake->retransmit_timeout;
else
timeout = ssl->conf->read_timeout;
MBEDTLS_SSL_DEBUG_MSG( 3, ( "f_recv_timeout: %u ms", timeout ) );
if( ssl->f_recv_timeout != NULL )
ret = ssl->f_recv_timeout( ssl->p_bio, ssl->in_hdr, len,
timeout );
else
ret = ssl->f_recv( ssl->p_bio, ssl->in_hdr, len );
MBEDTLS_SSL_DEBUG_RET( 2, "ssl->f_recv(_timeout)", ret );
if( ret == 0 )
return( MBEDTLS_ERR_SSL_CONN_EOF );
}
if( ret == MBEDTLS_ERR_SSL_TIMEOUT )
{
MBEDTLS_SSL_DEBUG_MSG( 2, ( "timeout" ) );
ssl_set_timer( ssl, 0 );
if( ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER )
{
if( ssl_double_retransmit_timeout( ssl ) != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "handshake timeout" ) );
return( MBEDTLS_ERR_SSL_TIMEOUT );
}
if( ( ret = mbedtls_ssl_resend( ssl ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_resend", ret );
return( ret );
}
return( MBEDTLS_ERR_SSL_WANT_READ );
}
#if defined(MBEDTLS_SSL_SRV_C) && defined(MBEDTLS_SSL_RENEGOTIATION)
else if( ssl->conf->endpoint == MBEDTLS_SSL_IS_SERVER &&
ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_PENDING )
{
if( ( ret = ssl_resend_hello_request( ssl ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "ssl_resend_hello_request", ret );
return( ret );
}
return( MBEDTLS_ERR_SSL_WANT_READ );
}
#endif /* MBEDTLS_SSL_SRV_C && MBEDTLS_SSL_RENEGOTIATION */
}
if( ret < 0 )
return( ret );
ssl->in_left = ret;
}
else
#endif
{
MBEDTLS_SSL_DEBUG_MSG( 2, ( "in_left: %d, nb_want: %d",
ssl->in_left, nb_want ) );
while( ssl->in_left < nb_want )
{
len = nb_want - ssl->in_left;
if( ssl_check_timer( ssl ) != 0 )
ret = MBEDTLS_ERR_SSL_TIMEOUT;
else
{
if( ssl->f_recv_timeout != NULL )
{
ret = ssl->f_recv_timeout( ssl->p_bio,
ssl->in_hdr + ssl->in_left, len,
ssl->conf->read_timeout );
}
else
{
ret = ssl->f_recv( ssl->p_bio,
ssl->in_hdr + ssl->in_left, len );
}
}
MBEDTLS_SSL_DEBUG_MSG( 2, ( "in_left: %d, nb_want: %d",
ssl->in_left, nb_want ) );
MBEDTLS_SSL_DEBUG_RET( 2, "ssl->f_recv(_timeout)", ret );
if( ret == 0 )
return( MBEDTLS_ERR_SSL_CONN_EOF );
if( ret < 0 )
return( ret );
ssl->in_left += ret;
}
}
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= fetch input" ) );
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3a476(%rip), %rdx # 0x4c4bc
leaq 0x3a69d(%rip), %r8 # 0x4c6ea
movl $0x2, %esi
movl $0x8a0, %ecx # imm = 0x8A0
xorl %eax, %eax
callq 0xf997
cmpq $0x0, 0x28(%rbx)
jne 0x12070
cmpq $0x0, 0x30(%rbx)
je 0x1223f
movq 0xa0(%rbx), %rax
subq 0xb0(%rbx), %rax
addq $0x414d, %rax # imm = 0x414D
cmpq %r14, %rax
jae 0x120a9
leaq 0x3a42c(%rip), %rdx # 0x4c4bc
leaq 0x3a69e(%rip), %r8 # 0x4c735
movq %rbx, %rdi
movl $0x1, %esi
movl $0x8ab, %ecx # imm = 0x8AB
jmp 0x12277
movq (%rbx), %rax
testb $0x2, 0x174(%rax)
jne 0x121ef
movq 0xe8(%rbx), %r9
movq %r14, (%rsp)
leaq 0x3a3f1(%rip), %rdx # 0x4c4bc
leaq 0x3a6dc(%rip), %r8 # 0x4c7ae
movq %rbx, %rdi
movl $0x2, %esi
movl $0x93e, %ecx # imm = 0x93E
xorl %eax, %eax
callq 0xf997
movq 0xe8(%rbx), %r12
cmpq %r14, %r12
jae 0x121c6
leaq 0x3a3bf(%rip), %r15 # 0x4c4bc
leaq 0x3a6e8(%rip), %r13 # 0x4c7ec
movq %rbx, %rdi
callq 0x12563
movl $0xffff9800, %ebp # imm = 0xFFFF9800
testl %eax, %eax
jne 0x1215a
movq %r14, %rdx
subq %r12, %rdx
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x12143
movq (%rbx), %rcx
movq 0x38(%rbx), %rdi
movq 0xb0(%rbx), %rsi
addq 0xe8(%rbx), %rsi
movl 0x150(%rcx), %ecx
callq *%rax
jmp 0x12158
movq 0x38(%rbx), %rdi
movq 0xb0(%rbx), %rsi
addq 0xe8(%rbx), %rsi
callq *0x28(%rbx)
movl %eax, %ebp
movq 0xe8(%rbx), %r9
movq %r14, (%rsp)
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
movl $0x956, %ecx # imm = 0x956
leaq 0x3a632(%rip), %r8 # 0x4c7ae
xorl %eax, %eax
callq 0xf997
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
movl $0x957, %ecx # imm = 0x957
movq %r13, %r8
movl %ebp, %r9d
callq 0xfa82
testl %ebp, %ebp
je 0x1254f
js 0x12283
movl %ebp, %r12d
addq 0xe8(%rbx), %r12
movq %r12, 0xe8(%rbx)
cmpq %r14, %r12
jb 0x12104
leaq 0x3a2ef(%rip), %rdx # 0x4c4bc
leaq 0x3a5f3(%rip), %r8 # 0x4c7c7
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x2, %esi
movl $0x963, %ecx # imm = 0x963
xorl %eax, %eax
callq 0xf997
jmp 0x12283
cmpq $0x0, 0x90(%rbx)
je 0x1225c
cmpq $0x0, 0x98(%rbx)
je 0x1225c
movq 0xf8(%rbx), %r9
testq %r9, %r9
je 0x122e7
movq 0xe8(%rbx), %rax
subq %r9, %rax
jae 0x12294
leaq 0x3a296(%rip), %rdx # 0x4c4bc
leaq 0x3a348(%rip), %r8 # 0x4c575
movq %rbx, %rdi
movl $0x1, %esi
movl $0x8ca, %ecx # imm = 0x8CA
jmp 0x12342
leaq 0x3a276(%rip), %rdx # 0x4c4bc
leaq 0x3a4ac(%rip), %r8 # 0x4c6f9
movq %rbx, %rdi
movl $0x1, %esi
movl $0x8a5, %ecx # imm = 0x8A5
jmp 0x12277
leaq 0x3a259(%rip), %rdx # 0x4c4bc
leaq 0x3a4ea(%rip), %r8 # 0x4c754
movq %rbx, %rdi
movl $0x1, %esi
movl $0x8b8, %ecx # imm = 0x8B8
xorl %eax, %eax
callq 0xf997
movl $0xffff8f00, %ebp # imm = 0xFFFF8F00
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, 0xe8(%rbx)
je 0x122dc
leaq 0x3a218(%rip), %rdx # 0x4c4bc
leaq 0x3a4da(%rip), %r8 # 0x4c785
movq %rbx, %rdi
movl $0x2, %esi
movl $0x8d3, %ecx # imm = 0x8D3
xorl %eax, %eax
callq 0xf997
movq 0xb0(%rbx), %rdi
movq 0xe8(%rbx), %rdx
movq 0xf8(%rbx), %rsi
addq %rdi, %rsi
callq 0xf2e0
movq $0x0, 0xf8(%rbx)
movq 0xe8(%rbx), %r9
movq %r14, (%rsp)
leaq 0x3a1c3(%rip), %rdx # 0x4c4bc
leaq 0x3a4ae(%rip), %r8 # 0x4c7ae
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x2, %esi
movl $0x8dd, %ecx # imm = 0x8DD
xorl %eax, %eax
callq 0xf997
movq 0xe8(%rbx), %rax
cmpq %r14, %rax
jae 0x12353
testq %rax, %rax
je 0x12373
leaq 0x3a18e(%rip), %rdx # 0x4c4bc
leaq 0x3a240(%rip), %r8 # 0x4c575
movq %rbx, %rdi
movl $0x1, %esi
movl $0x8ef, %ecx # imm = 0x8EF
xorl %eax, %eax
callq 0xf997
movl $0xffff9400, %ebp # imm = 0xFFFF9400
jmp 0x12283
leaq 0x3a162(%rip), %rdx # 0x4c4bc
leaq 0x3a466(%rip), %r8 # 0x4c7c7
movq %rbx, %rdi
movl $0x2, %esi
movl $0x8e4, %ecx # imm = 0x8E4
jmp 0x121e3
movq %rbx, %rdi
callq 0x12563
testl %eax, %eax
je 0x12442
leaq 0x3a132(%rip), %rdx # 0x4c4bc
leaq 0x3a47b(%rip), %r8 # 0x4c80c
movq %rbx, %rdi
movl $0x2, %esi
movl $0x913, %ecx # imm = 0x913
xorl %eax, %eax
callq 0xf997
movq %rbx, %rdi
xorl %esi, %esi
callq 0x125b5
cmpl $0x10, 0x8(%rbx)
jne 0x12406
movq (%rbx), %rax
movl $0xffff9800, %ebp # imm = 0xFFFF9800
testb $0x1, 0x174(%rax)
je 0x12283
cmpl $0x3, 0xc(%rbx)
jne 0x12283
movq %rbx, %rdi
callq 0x12812
testl %eax, %eax
je 0x12559
movl %eax, %ebp
leaq 0x3a0cf(%rip), %rdx # 0x4c4bc
leaq 0x3a420(%rip), %r8 # 0x4c814
movq %rbx, %rdi
movl $0x1, %esi
movl $0x92c, %ecx # imm = 0x92C
jmp 0x124e6
movq %rbx, %rdi
callq 0x12609
testl %eax, %eax
je 0x124b9
leaq 0x3a09f(%rip), %rdx # 0x4c4bc
leaq 0x3a3de(%rip), %r8 # 0x4c802
movq %rbx, %rdi
movl $0x1, %esi
movl $0x91a, %ecx # imm = 0x91A
xorl %eax, %eax
callq 0xf997
movl $0xffff9800, %ebp # imm = 0xFFFF9800
jmp 0x12283
movq 0xa0(%rbx), %r14
subq 0xb0(%rbx), %r14
addq $0x414d, %r14 # imm = 0x414D
leaq 0x60(%rbx), %rax
cmpl $0x10, 0x8(%rbx)
cmoveq %rbx, %rax
movl $0x150, %ecx # imm = 0x150
movl $0x3c8, %edx # imm = 0x3C8
cmoveq %rcx, %rdx
movq (%rax), %rax
movl (%rax,%rdx), %ebp
leaq 0x3a03e(%rip), %rdx # 0x4c4bc
leaq 0x3a351(%rip), %r8 # 0x4c7d6
movq %rbx, %rdi
movl $0x3, %esi
movl $0x903, %ecx # imm = 0x903
movl %ebp, %r9d
xorl %eax, %eax
callq 0xf997
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x124f3
movq 0x38(%rbx), %rdi
movq 0xb0(%rbx), %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq *%rax
jmp 0x12504
movq %rbx, %rdi
callq 0x12663
testl %eax, %eax
je 0x12559
movl %eax, %ebp
leaq 0x39fea(%rip), %rdx # 0x4c4bc
leaq 0x3a42c(%rip), %r8 # 0x4c905
movq %rbx, %rdi
movl $0x1, %esi
movl $0x920, %ecx # imm = 0x920
movl %ebp, %r9d
callq 0xfa82
jmp 0x12283
movq 0x38(%rbx), %rdi
movq 0xb0(%rbx), %rsi
movq %r14, %rdx
callq *0x28(%rbx)
movl %eax, %ebp
leaq 0x39faf(%rip), %rdx # 0x4c4bc
leaq 0x3a2d8(%rip), %r8 # 0x4c7ec
movq %rbx, %rdi
movl $0x2, %esi
movl $0x90b, %ecx # imm = 0x90B
movl %eax, %r9d
callq 0xfa82
testl %ebp, %ebp
je 0x1254f
cmpl $0xffff9800, %ebp # imm = 0xFFFF9800
je 0x12383
testl %ebp, %ebp
js 0x12283
movl %ebp, %eax
movq %rax, 0xe8(%rbx)
jmp 0x121c6
movl $0xffff8d80, %ebp # imm = 0xFFFF8D80
jmp 0x12283
movl $0xffff9700, %ebp # imm = 0xFFFF9700
jmp 0x12283
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_flush_output | int mbedtls_ssl_flush_output( mbedtls_ssl_context *ssl )
{
int ret;
unsigned char *buf, i;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> flush output" ) );
if( ssl->f_send == NULL )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "Bad usage of mbedtls_ssl_set_bio() "
"or mbedtls_ssl_set_bio()" ) );
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
/* Avoid incrementing counter if data is flushed */
if( ssl->out_left == 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= flush output" ) );
return( 0 );
}
while( ssl->out_left > 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 2, ( "message length: %d, out_left: %d",
mbedtls_ssl_hdr_len( ssl ) + ssl->out_msglen, ssl->out_left ) );
buf = ssl->out_hdr + mbedtls_ssl_hdr_len( ssl ) +
ssl->out_msglen - ssl->out_left;
ret = ssl->f_send( ssl->p_bio, buf, ssl->out_left );
MBEDTLS_SSL_DEBUG_RET( 2, "ssl->f_send", ret );
if( ret <= 0 )
return( ret );
ssl->out_left -= ret;
}
for( i = 8; i > ssl_ep_len( ssl ); i-- )
if( ++ssl->out_ctr[i - 1] != 0 )
break;
/* The loop goes to its end iff the counter is wrapping */
if( i == ssl_ep_len( ssl ) )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "outgoing message counter would wrap" ) );
return( MBEDTLS_ERR_SSL_COUNTER_WRAPPING );
}
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= flush output" ) );
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x39c2b(%rip), %rdx # 0x4c4bc
leaq 0x39f95(%rip), %r8 # 0x4c82d
movl $0x2, %esi
movl $0x970, %ecx # imm = 0x970
xorl %eax, %eax
callq 0xf997
cmpq $0x0, 0x20(%rbx)
je 0x129ac
movq 0x160(%rbx), %rax
testq %rax, %rax
je 0x129d5
leaq 0x39bf1(%rip), %r14 # 0x4c4bc
leaq 0x39f7b(%rip), %r15 # 0x4c84d
leaq 0x39f95(%rip), %r12 # 0x4c86e
movq (%rbx), %rcx
movq 0x158(%rbx), %rdx
movl 0x174(%rcx), %ecx
andl $0x2, %ecx
leaq (%rdx,%rcx,4), %r9
addq $0x5, %r9
movq %rax, (%rsp)
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
movl $0x983, %ecx # imm = 0x983
movq %r15, %r8
xorl %eax, %eax
callq 0xf997
movq (%rbx), %rax
movl 0x174(%rax), %esi
andl $0x2, %esi
shlq $0x2, %rsi
addq 0x130(%rbx), %rsi
addq 0x158(%rbx), %rsi
movq 0x38(%rbx), %rdi
movq 0x160(%rbx), %rdx
subq %rdx, %rsi
addq $0x5, %rsi
callq *0x20(%rbx)
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
movl $0x989, %ecx # imm = 0x989
movq %r12, %r8
movl %eax, %r9d
callq 0xfa82
testl %ebp, %ebp
jle 0x12a4e
movl %ebp, %ecx
movq 0x160(%rbx), %rax
subq %rcx, %rax
movq %rax, 0x160(%rbx)
jne 0x128d9
movb $0x8, %al
movzbl %al, %ecx
movq 0x128(%rbx), %rdx
incb -0x1(%rdx,%rcx)
movq (%rbx), %rdx
jne 0x129f4
decb %al
movl 0x174(%rdx), %edx
andl $0x2, %edx
movzbl %al, %ecx
cmpl %ecx, %edx
jb 0x12985
jmp 0x129fd
leaq 0x39b09(%rip), %rdx # 0x4c4bc
leaq 0x39d3f(%rip), %r8 # 0x4c6f9
movq %rbx, %rdi
movl $0x1, %esi
movl $0x975, %ecx # imm = 0x975
xorl %eax, %eax
callq 0xf997
movl $0xffff8f00, %ebp # imm = 0xFFFF8F00
jmp 0x12a4e
leaq 0x39ae0(%rip), %rdx # 0x4c4bc
leaq 0x39e5a(%rip), %r8 # 0x4c83d
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x2, %esi
movl $0x97c, %ecx # imm = 0x97C
jmp 0x12a47
movl 0x174(%rdx), %edx
andl $0x2, %edx
cmpl %ecx, %edx
jne 0x12a2a
leaq 0x39ab4(%rip), %rdx # 0x4c4bc
leaq 0x39e6b(%rip), %r8 # 0x4c87a
movq %rbx, %rdi
movl $0x1, %esi
movl $0x998, %ecx # imm = 0x998
xorl %eax, %eax
callq 0xf997
movl $0xffff9480, %ebp # imm = 0xFFFF9480
jmp 0x12a4e
leaq 0x39a8b(%rip), %rdx # 0x4c4bc
leaq 0x39e05(%rip), %r8 # 0x4c83d
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x2, %esi
movl $0x99c, %ecx # imm = 0x99C
xorl %eax, %eax
callq 0xf997
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_dtls_replay_check | int mbedtls_ssl_dtls_replay_check( mbedtls_ssl_context *ssl )
{
uint64_t rec_seqnum = ssl_load_six_bytes( ssl->in_ctr + 2 );
uint64_t bit;
if( ssl->conf->anti_replay == MBEDTLS_SSL_ANTI_REPLAY_DISABLED )
return( 0 );
if( rec_seqnum > ssl->in_window_top )
return( 0 );
bit = ssl->in_window_top - rec_seqnum;
if( bit >= 64 )
return( -1 );
if( ( ssl->in_window & ( (uint64_t) 1 << bit ) ) != 0 )
return( -1 );
return( 0 );
} | movq (%rdi), %rcx
xorl %eax, %eax
testb $0x10, 0x175(%rcx)
je 0x1414f
movq 0xa8(%rdi), %rcx
movzbl 0x2(%rcx), %edx
shlq $0x28, %rdx
movzbl 0x3(%rcx), %esi
shlq $0x20, %rsi
orq %rdx, %rsi
movzbl 0x4(%rcx), %edx
shll $0x18, %edx
orq %rsi, %rdx
movzbl 0x5(%rcx), %esi
shll $0x10, %esi
orq %rdx, %rsi
movzbl 0x6(%rcx), %edx
shll $0x8, %edx
orq %rsi, %rdx
movzbl 0x7(%rcx), %esi
orq %rdx, %rsi
movq 0x100(%rdi), %rcx
subq %rsi, %rcx
jb 0x1414f
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq $0x3f, %rcx
ja 0x1414f
movq 0x108(%rdi), %rdx
xorl %eax, %eax
btq %rcx, %rdx
sbbl %eax, %eax
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_read_record | int mbedtls_ssl_read_record( mbedtls_ssl_context *ssl )
{
int ret;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> read record" ) );
do {
if( ( ret = mbedtls_ssl_read_record_layer( ssl ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, ( "mbedtls_ssl_read_record_layer" ), ret );
return( ret );
}
ret = mbedtls_ssl_handle_message_type( ssl );
} while( MBEDTLS_ERR_SSL_NON_FATAL == ret );
if( 0 != ret )
{
MBEDTLS_SSL_DEBUG_RET( 1, ( "mbedtls_ssl_handle_message_type" ), ret );
return( ret );
}
if( ssl->in_msgtype == MBEDTLS_SSL_MSG_HANDSHAKE )
{
mbedtls_ssl_update_handshake_status( ssl );
}
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= read record" ) );
return( 0 );
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x382bd(%rip), %rdx # 0x4c4bc
leaq 0x38919(%rip), %r8 # 0x4cb1f
movl $0x2, %esi
movl $0xe90, %ecx # imm = 0xE90
xorl %eax, %eax
callq 0xf997
movq %rbx, %rdi
callq 0x142ba
testl %eax, %eax
jne 0x1426f
movq %rbx, %rdi
callq 0x15611
cmpl $0xffff9980, %eax # imm = 0xFFFF9980
je 0x14217
movl %eax, %ebp
testl %eax, %eax
jne 0x1428e
cmpl $0x16, 0xd8(%rbx)
jne 0x14249
movq %rbx, %rdi
callq 0x14095
leaq 0x3826c(%rip), %rdx # 0x4c4bc
leaq 0x38915(%rip), %r8 # 0x4cb6c
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x2, %esi
movl $0xea9, %ecx # imm = 0xEA9
xorl %eax, %eax
callq 0xf997
jmp 0x142b1
movl %eax, %ebp
leaq 0x38244(%rip), %rdx # 0x4c4bc
leaq 0x388af(%rip), %r8 # 0x4cb2e
movq %rbx, %rdi
movl $0x1, %esi
movl $0xe96, %ecx # imm = 0xE96
jmp 0x142a9
leaq 0x38227(%rip), %rdx # 0x4c4bc
leaq 0x388b0(%rip), %r8 # 0x4cb4c
movq %rbx, %rdi
movl $0x1, %esi
movl $0xea0, %ecx # imm = 0xEA0
movl %ebp, %r9d
callq 0xfa82
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_send_fatal_handshake_failure | int mbedtls_ssl_send_fatal_handshake_failure( mbedtls_ssl_context *ssl )
{
int ret;
if( ( ret = mbedtls_ssl_send_alert_message( ssl,
MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE ) ) != 0 )
{
return( ret );
}
return( 0 );
} | movl $0x2, %esi
movl $0x28, %edx
jmp 0x15727
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_write_certificate | int mbedtls_ssl_write_certificate( mbedtls_ssl_context *ssl )
{
int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
size_t i, n;
const mbedtls_x509_crt *crt;
const mbedtls_ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write certificate" ) );
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK ||
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK ||
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK ||
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECJPAKE )
{
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip write certificate" ) );
ssl->state++;
return( 0 );
}
#if defined(MBEDTLS_SSL_CLI_C)
if( ssl->conf->endpoint == MBEDTLS_SSL_IS_CLIENT )
{
if( ssl->client_auth == 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip write certificate" ) );
ssl->state++;
return( 0 );
}
#if defined(MBEDTLS_SSL_PROTO_SSL3)
/*
* If using SSLv3 and got no cert, send an Alert message
* (otherwise an empty Certificate message will be sent).
*/
if( mbedtls_ssl_own_cert( ssl ) == NULL &&
ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 )
{
ssl->out_msglen = 2;
ssl->out_msgtype = MBEDTLS_SSL_MSG_ALERT;
ssl->out_msg[0] = MBEDTLS_SSL_ALERT_LEVEL_WARNING;
ssl->out_msg[1] = MBEDTLS_SSL_ALERT_MSG_NO_CERT;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "got no certificate to send" ) );
goto write_msg;
}
#endif /* MBEDTLS_SSL_PROTO_SSL3 */
}
#endif /* MBEDTLS_SSL_CLI_C */
#if defined(MBEDTLS_SSL_SRV_C)
if( ssl->conf->endpoint == MBEDTLS_SSL_IS_SERVER )
{
if( mbedtls_ssl_own_cert( ssl ) == NULL )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "got no certificate to send" ) );
return( MBEDTLS_ERR_SSL_CERTIFICATE_REQUIRED );
}
}
#endif
MBEDTLS_SSL_DEBUG_CRT( 3, "own certificate", mbedtls_ssl_own_cert( ssl ) );
/*
* 0 . 0 handshake type
* 1 . 3 handshake length
* 4 . 6 length of all certs
* 7 . 9 length of cert. 1
* 10 . n-1 peer certificate
* n . n+2 length of cert. 2
* n+3 . ... upper level cert, etc.
*/
i = 7;
crt = mbedtls_ssl_own_cert( ssl );
while( crt != NULL )
{
n = crt->raw.len;
if( n > MBEDTLS_SSL_MAX_CONTENT_LEN - 3 - i )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "certificate too large, %d > %d",
i + 3 + n, MBEDTLS_SSL_MAX_CONTENT_LEN ) );
return( MBEDTLS_ERR_SSL_CERTIFICATE_TOO_LARGE );
}
ssl->out_msg[i ] = (unsigned char)( n >> 16 );
ssl->out_msg[i + 1] = (unsigned char)( n >> 8 );
ssl->out_msg[i + 2] = (unsigned char)( n );
i += 3; memcpy( ssl->out_msg + i, crt->raw.p, n );
i += n; crt = crt->next;
}
ssl->out_msg[4] = (unsigned char)( ( i - 7 ) >> 16 );
ssl->out_msg[5] = (unsigned char)( ( i - 7 ) >> 8 );
ssl->out_msg[6] = (unsigned char)( ( i - 7 ) );
ssl->out_msglen = i;
ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;
ssl->out_msg[0] = MBEDTLS_SSL_HS_CERTIFICATE;
#if defined(MBEDTLS_SSL_PROTO_SSL3) && defined(MBEDTLS_SSL_CLI_C)
write_msg:
#endif
ssl->state++;
if( ( ret = mbedtls_ssl_write_record( ssl ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_write_record", ret );
return( ret );
}
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write certificate" ) );
return( ret );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x80(%rdi), %rax
movq (%rax), %rbx
leaq 0x36c04(%rip), %rdx # 0x4c4bc
leaq 0x37439(%rip), %r8 # 0x4ccf8
movl $0x2, %esi
movl $0x100b, %ecx # imm = 0x100B
xorl %eax, %eax
callq 0xf997
movl 0x18(%rbx), %eax
cmpl $0xb, %eax
ja 0x15917
movl $0x960, %ecx # imm = 0x960
btl %eax, %ecx
jae 0x15917
leaq 0x36bd3(%rip), %rdx # 0x4c4bc
leaq 0x3741d(%rip), %r8 # 0x4cd0d
xorl %ebp, %ebp
movq %r14, %rdi
movl $0x2, %esi
movl $0x1012, %ecx # imm = 0x1012
xorl %eax, %eax
callq 0xf997
incl 0x8(%r14)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rax
testb $0x1, 0x174(%rax)
jne 0x15933
cmpl $0x0, 0x16c(%r14)
je 0x159a8
movq 0x60(%r14), %rcx
jmp 0x1595a
movq 0x60(%r14), %rcx
testq %rcx, %rcx
je 0x15948
movq 0x380(%rcx), %rdx
testq %rdx, %rdx
jne 0x15954
movq 0xd0(%rax), %rdx
testq %rdx, %rdx
je 0x1597c
cmpq $0x0, (%rdx)
je 0x1597c
testq %rcx, %rcx
je 0x1596b
movq 0x380(%rcx), %rcx
testq %rcx, %rcx
jne 0x15977
movq 0xd0(%rax), %rcx
testq %rcx, %rcx
je 0x159ca
movq (%rcx), %r9
jmp 0x159cd
leaq 0x36b39(%rip), %rdx # 0x4c4bc
leaq 0x3739d(%rip), %r8 # 0x4cd27
movq %r14, %rdi
movl $0x1, %esi
movl $0x1039, %ecx # imm = 0x1039
xorl %eax, %eax
callq 0xf997
movl $0xffff8a80, %ebp # imm = 0xFFFF8A80
jmp 0x1590a
leaq 0x36b0d(%rip), %rdx # 0x4c4bc
leaq 0x37357(%rip), %r8 # 0x4cd0d
xorl %ebp, %ebp
movq %r14, %rdi
movl $0x2, %esi
movl $0x101c, %ecx # imm = 0x101C
jmp 0x158ff
xorl %r9d, %r9d
leaq 0x36ae8(%rip), %rdx # 0x4c4bc
leaq 0x37367(%rip), %r8 # 0x4cd42
movq %r14, %rdi
movl $0x3, %esi
movl $0x103f, %ecx # imm = 0x103F
callq 0x10078
movq 0x60(%r14), %rax
testq %rax, %rax
je 0x15a02
movq 0x380(%rax), %rax
testq %rax, %rax
jne 0x15a11
movq (%r14), %rax
movq 0xd0(%rax), %rax
testq %rax, %rax
je 0x15a84
movq (%rax), %r15
testq %r15, %r15
je 0x15a84
movl $0x7, %ebp
movq 0x8(%r15), %rbx
movl $0x3ffd, %eax # imm = 0x3FFD
subq %rbp, %rax
cmpq %rax, %rbx
ja 0x15b2f
movl %ebx, %eax
shrl $0x10, %eax
movq 0x148(%r14), %rcx
movb %al, (%rcx,%rbp)
movq 0x148(%r14), %rax
movb %bh, 0x1(%rax,%rbp)
movq 0x148(%r14), %rax
movb %bl, 0x2(%rax,%rbp)
leaq 0x3(%rbp), %rdi
addq 0x148(%r14), %rdi
movq 0x10(%r15), %rsi
movq %rbx, %rdx
callq 0xf240
addq %rbx, %rbp
addq $0x3, %rbp
movq 0x220(%r15), %r15
testq %r15, %r15
jne 0x15a1e
jmp 0x15a89
movl $0x7, %ebp
leaq -0x7(%rbp), %rax
movl %eax, %ecx
shrl $0x10, %ecx
movq 0x148(%r14), %rdx
movb %cl, 0x4(%rdx)
movq 0x148(%r14), %rcx
movb %ah, 0x5(%rcx)
movq 0x148(%r14), %rcx
movb %al, 0x6(%rcx)
movq %rbp, 0x158(%r14)
movl $0x16, 0x150(%r14)
movq 0x148(%r14), %rax
movb $0xb, (%rax)
incl 0x8(%r14)
movq %r14, %rdi
callq 0x12b2b
testl %eax, %eax
je 0x15b06
movl %eax, %ebp
leaq 0x369d7(%rip), %rdx # 0x4c4bc
leaq 0x36dfd(%rip), %r8 # 0x4c8e9
movq %r14, %rdi
movl $0x1, %esi
movl $0x106f, %ecx # imm = 0x106F
movl %eax, %r9d
callq 0xfa82
jmp 0x1590a
leaq 0x369af(%rip), %rdx # 0x4c4bc
leaq 0x3725d(%rip), %r8 # 0x4cd71
xorl %ebp, %ebp
movq %r14, %rdi
movl $0x2, %esi
movl $0x1073, %ecx # imm = 0x1073
xorl %eax, %eax
callq 0xf997
jmp 0x1590a
leaq (%rbx,%rbp), %r9
addq $0x3, %r9
movl $0x4000, (%rsp) # imm = 0x4000
leaq 0x36977(%rip), %rdx # 0x4c4bc
leaq 0x37206(%rip), %r8 # 0x4cd52
movq %r14, %rdi
movl $0x1, %esi
movl $0x1053, %ecx # imm = 0x1053
xorl %eax, %eax
callq 0xf997
movl $0xffff8b00, %ebp # imm = 0xFFFF8B00
jmp 0x1590a
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_parse_certificate | int mbedtls_ssl_parse_certificate( mbedtls_ssl_context *ssl )
{
int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
size_t i, n;
const mbedtls_ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
int authmode = ssl->conf->authmode;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse certificate" ) );
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK ||
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK ||
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK ||
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECJPAKE )
{
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip parse certificate" ) );
ssl->state++;
return( 0 );
}
#if defined(MBEDTLS_SSL_SRV_C)
if( ssl->conf->endpoint == MBEDTLS_SSL_IS_SERVER &&
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK )
{
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip parse certificate" ) );
ssl->state++;
return( 0 );
}
#if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
if( ssl->handshake->sni_authmode != MBEDTLS_SSL_VERIFY_UNSET )
authmode = ssl->handshake->sni_authmode;
#endif
if( ssl->conf->endpoint == MBEDTLS_SSL_IS_SERVER &&
authmode == MBEDTLS_SSL_VERIFY_NONE )
{
ssl->session_negotiate->verify_result = MBEDTLS_X509_BADCERT_SKIP_VERIFY;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip parse certificate" ) );
ssl->state++;
return( 0 );
}
#endif
if( ( ret = mbedtls_ssl_read_record( ssl ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_read_record", ret );
return( ret );
}
ssl->state++;
#if defined(MBEDTLS_SSL_SRV_C)
#if defined(MBEDTLS_SSL_PROTO_SSL3)
/*
* Check if the client sent an empty certificate
*/
if( ssl->conf->endpoint == MBEDTLS_SSL_IS_SERVER &&
ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 )
{
if( ssl->in_msglen == 2 &&
ssl->in_msgtype == MBEDTLS_SSL_MSG_ALERT &&
ssl->in_msg[0] == MBEDTLS_SSL_ALERT_LEVEL_WARNING &&
ssl->in_msg[1] == MBEDTLS_SSL_ALERT_MSG_NO_CERT )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "SSLv3 client has no certificate" ) );
ssl->session_negotiate->verify_result = MBEDTLS_X509_BADCERT_MISSING;
if( authmode == MBEDTLS_SSL_VERIFY_OPTIONAL )
return( 0 );
else
return( MBEDTLS_ERR_SSL_NO_CLIENT_CERTIFICATE );
}
}
#endif /* MBEDTLS_SSL_PROTO_SSL3 */
#if defined(MBEDTLS_SSL_PROTO_TLS1) || defined(MBEDTLS_SSL_PROTO_TLS1_1) || \
defined(MBEDTLS_SSL_PROTO_TLS1_2)
if( ssl->conf->endpoint == MBEDTLS_SSL_IS_SERVER &&
ssl->minor_ver != MBEDTLS_SSL_MINOR_VERSION_0 )
{
if( ssl->in_hslen == 3 + mbedtls_ssl_hs_hdr_len( ssl ) &&
ssl->in_msgtype == MBEDTLS_SSL_MSG_HANDSHAKE &&
ssl->in_msg[0] == MBEDTLS_SSL_HS_CERTIFICATE &&
memcmp( ssl->in_msg + mbedtls_ssl_hs_hdr_len( ssl ), "\0\0\0", 3 ) == 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "TLSv1 client has no certificate" ) );
ssl->session_negotiate->verify_result = MBEDTLS_X509_BADCERT_MISSING;
if( authmode == MBEDTLS_SSL_VERIFY_OPTIONAL )
return( 0 );
else
return( MBEDTLS_ERR_SSL_NO_CLIENT_CERTIFICATE );
}
}
#endif /* MBEDTLS_SSL_PROTO_TLS1 || MBEDTLS_SSL_PROTO_TLS1_1 || \
MBEDTLS_SSL_PROTO_TLS1_2 */
#endif /* MBEDTLS_SSL_SRV_C */
if( ssl->in_msgtype != MBEDTLS_SSL_MSG_HANDSHAKE )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate message" ) );
return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
}
if( ssl->in_msg[0] != MBEDTLS_SSL_HS_CERTIFICATE ||
ssl->in_hslen < mbedtls_ssl_hs_hdr_len( ssl ) + 3 + 3 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE );
}
i = mbedtls_ssl_hs_hdr_len( ssl );
/*
* Same message structure as in mbedtls_ssl_write_certificate()
*/
n = ( ssl->in_msg[i+1] << 8 ) | ssl->in_msg[i+2];
if( ssl->in_msg[i] != 0 ||
ssl->in_hslen != n + 3 + mbedtls_ssl_hs_hdr_len( ssl ) )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE );
}
/* In case we tried to reuse a session but it failed */
if( ssl->session_negotiate->peer_cert != NULL )
{
mbedtls_x509_crt_free( ssl->session_negotiate->peer_cert );
mbedtls_free( ssl->session_negotiate->peer_cert );
}
if( ( ssl->session_negotiate->peer_cert = mbedtls_calloc( 1,
sizeof( mbedtls_x509_crt ) ) ) == NULL )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "alloc(%d bytes) failed",
sizeof( mbedtls_x509_crt ) ) );
return( MBEDTLS_ERR_SSL_ALLOC_FAILED );
}
mbedtls_x509_crt_init( ssl->session_negotiate->peer_cert );
i += 3;
while( i < ssl->in_hslen )
{
if( ssl->in_msg[i] != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE );
}
n = ( (unsigned int) ssl->in_msg[i + 1] << 8 )
| (unsigned int) ssl->in_msg[i + 2];
i += 3;
if( n < 128 || i + n > ssl->in_hslen )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE );
}
ret = mbedtls_x509_crt_parse_der( ssl->session_negotiate->peer_cert,
ssl->in_msg + i, n );
if( 0 != ret && ( MBEDTLS_ERR_X509_UNKNOWN_SIG_ALG + MBEDTLS_ERR_OID_NOT_FOUND ) != ret )
{
MBEDTLS_SSL_DEBUG_RET( 1, " mbedtls_x509_crt_parse_der", ret );
return( ret );
}
i += n;
}
MBEDTLS_SSL_DEBUG_CRT( 3, "peer certificate", ssl->session_negotiate->peer_cert );
/*
* On client, make sure the server cert doesn't change during renego to
* avoid "triple handshake" attack: https://secure-resumption.com/
*/
#if defined(MBEDTLS_SSL_RENEGOTIATION) && defined(MBEDTLS_SSL_CLI_C)
if( ssl->conf->endpoint == MBEDTLS_SSL_IS_CLIENT &&
ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS )
{
if( ssl->session->peer_cert == NULL )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "new server cert during renegotiation" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE );
}
if( ssl->session->peer_cert->raw.len !=
ssl->session_negotiate->peer_cert->raw.len ||
memcmp( ssl->session->peer_cert->raw.p,
ssl->session_negotiate->peer_cert->raw.p,
ssl->session->peer_cert->raw.len ) != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "server cert changed during renegotiation" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE );
}
}
#endif /* MBEDTLS_SSL_RENEGOTIATION && MBEDTLS_SSL_CLI_C */
if( authmode != MBEDTLS_SSL_VERIFY_NONE )
{
mbedtls_x509_crt *ca_chain;
mbedtls_x509_crl *ca_crl;
#if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
if( ssl->handshake->sni_ca_chain != NULL )
{
ca_chain = ssl->handshake->sni_ca_chain;
ca_crl = ssl->handshake->sni_ca_crl;
}
else
#endif
{
ca_chain = ssl->conf->ca_chain;
ca_crl = ssl->conf->ca_crl;
}
if( ca_chain == NULL )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "got no CA chain" ) );
return( MBEDTLS_ERR_SSL_CA_CHAIN_REQUIRED );
}
/*
* Main check: verify certificate
*/
ret = mbedtls_x509_crt_verify_with_profile(
ssl->session_negotiate->peer_cert,
ca_chain, ca_crl,
ssl->conf->cert_profile,
ssl->hostname,
&ssl->session_negotiate->verify_result,
ssl->conf->f_vrfy, ssl->conf->p_vrfy );
if( ret != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "x509_verify_cert", ret );
}
/*
* Secondary checks: always done, but change 'ret' only if it was 0
*/
#if defined(MBEDTLS_ECP_C)
{
const mbedtls_pk_context *pk = &ssl->session_negotiate->peer_cert->pk;
/* If certificate uses an EC key, make sure the curve is OK */
if( mbedtls_pk_can_do( pk, MBEDTLS_PK_ECKEY ) &&
mbedtls_ssl_check_curve( ssl, mbedtls_pk_ec( *pk )->grp.id ) != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate (EC key curve)" ) );
if( ret == 0 )
ret = MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE;
}
}
#endif /* MBEDTLS_ECP_C */
if( mbedtls_ssl_check_cert_usage( ssl->session_negotiate->peer_cert,
ciphersuite_info,
! ssl->conf->endpoint,
&ssl->session_negotiate->verify_result ) != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate (usage extensions)" ) );
if( ret == 0 )
ret = MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE;
}
if( authmode == MBEDTLS_SSL_VERIFY_OPTIONAL )
ret = 0;
}
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse certificate" ) );
return( ret );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x80(%rdi), %rcx
movq (%rcx), %r14
movl 0x174(%rax), %r12d
leaq 0x36926(%rip), %rdx # 0x4c4bc
leaq 0x371e9(%rip), %r8 # 0x4cd86
movl $0x2, %esi
movl $0x107f, %ecx # imm = 0x107F
xorl %eax, %eax
callq 0xf997
movl 0x18(%r14), %ecx
cmpl $0xb, %ecx
ja 0x15bf9
movl $0x960, %eax # imm = 0x960
btl %ecx, %eax
jae 0x15bf9
leaq 0x368f4(%rip), %rdx # 0x4c4bc
leaq 0x371cc(%rip), %r8 # 0x4cd9b
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x2, %esi
movl $0x1086, %ecx # imm = 0x1086
xorl %eax, %eax
callq 0xf997
incl 0x8(%rbx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rax
movl 0x174(%rax), %eax
testb $0x1, %al
sete %dl
cmpl $0x7, %ecx
setne %cl
orb %dl, %cl
jne 0x15c30
leaq 0x368a4(%rip), %rdx # 0x4c4bc
leaq 0x3717c(%rip), %r8 # 0x4cd9b
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x2, %esi
movl $0x108f, %ecx # imm = 0x108F
jmp 0x15bde
shrl $0x2, %r12d
andl $0x3, %r12d
movq 0x60(%rbx), %rcx
movl 0x388(%rcx), %ecx
cmpl $0x3, %ecx
cmovnel %ecx, %r12d
testb $0x1, %al
je 0x15c7f
testl %r12d, %r12d
jne 0x15c7f
movq 0x58(%rbx), %rax
movl $0x80, 0x70(%rax)
leaq 0x36858(%rip), %rdx # 0x4c4bc
leaq 0x37130(%rip), %r8 # 0x4cd9b
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x2, %esi
movl $0x109d, %ecx # imm = 0x109D
jmp 0x15bde
movq %rbx, %rdi
callq 0x141f2
testl %eax, %eax
je 0x15cb5
movl %eax, %ebp
leaq 0x36828(%rip), %rdx # 0x4c4bc
leaq 0x3711a(%rip), %r8 # 0x4cdb5
movq %rbx, %rdi
movl $0x1, %esi
movl $0x10a5, %ecx # imm = 0x10A5
movl %ebp, %r9d
callq 0xfa82
jmp 0x15be8
incl 0x8(%rbx)
movq (%rbx), %rax
movl 0x174(%rax), %r15d
testb $0x1, %r15b
je 0x15d0c
cmpl $0x0, 0x18(%rbx)
je 0x15d0c
movl %r15d, %eax
andl $0x2, %eax
shll $0x2, %eax
leaq 0x7(%rax), %rcx
cmpq %rcx, 0x110(%rbx)
jne 0x15d0c
cmpl $0x16, 0xd8(%rbx)
jne 0x15d0c
movq 0xc8(%rbx), %rcx
cmpb $0xb, (%rcx)
jne 0x15d0c
orq $0x4, %rax
movzbl 0x2(%rcx,%rax), %edx
orw (%rcx,%rax), %dx
je 0x15ea3
cmpl $0x16, 0xd8(%rbx)
jne 0x15d59
movq 0xc8(%rbx), %rcx
cmpb $0xb, (%rcx)
jne 0x15d39
movq 0x110(%rbx), %rax
andl $0x2, %r15d
shll $0x2, %r15d
leaq 0xa(%r15), %rdx
cmpq %rdx, %rax
jae 0x15d85
leaq 0x3677c(%rip), %rdx # 0x4c4bc
leaq 0x370a6(%rip), %r8 # 0x4cded
movq %rbx, %rdi
movl $0x1, %esi
movl $0x10e3, %ecx # imm = 0x10E3
jmp 0x15e92
leaq 0x3675c(%rip), %rdx # 0x4c4bc
leaq 0x37086(%rip), %r8 # 0x4cded
movq %rbx, %rdi
movl $0x1, %esi
movl $0x10dc, %ecx # imm = 0x10DC
xorl %eax, %eax
callq 0xf997
movl $0xffff8900, %ebp # imm = 0xFFFF8900
jmp 0x15be8
orq $0x4, %r15
cmpb $0x0, (%rcx,%r15)
jne 0x15e77
movzwl 0x1(%rcx,%r15), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
addq %r15, %rcx
addq $0x3, %rcx
cmpq %rcx, %rax
jne 0x15e77
movq 0x58(%rbx), %r13
movq 0x68(%r13), %rdi
testq %rdi, %rdi
je 0x15dd4
callq 0x2387e
movq 0x58(%rbx), %rax
movq 0x68(%rax), %rdi
callq 0xf030
movq 0x58(%rbx), %r13
movl $0x1, %edi
movl $0x228, %esi # imm = 0x228
callq 0xf1d0
movq %rax, 0x68(%r13)
testq %rax, %rax
je 0x15f7c
orq $0x3, %r15
movq %rax, %rdi
callq 0x21da5
movq 0x110(%rbx), %rax
xorl %ebp, %ebp
cmpq %rax, %r15
jae 0x15ee5
movq 0xc8(%rbx), %rsi
cmpb $0x0, (%rsi,%r15)
jne 0x15fef
movzwl 0x1(%rsi,%r15), %ecx
rolw $0x8, %cx
movzwl %cx, %edx
cmpl $0x80, %edx
jb 0x15fcf
movq %r15, %rcx
addq $0x3, %rcx
leaq (%rdx,%rcx), %r15
cmpq %rax, %r15
ja 0x15fcf
movq 0x58(%rbx), %rax
movq 0x68(%rax), %rdi
addq %rcx, %rsi
callq 0x218d4
movl %eax, %ebp
cmpl $0xffffd9d2, %eax # imm = 0xFFFFD9D2
je 0x15e6e
testl %ebp, %ebp
jne 0x1619b
movq 0x110(%rbx), %rax
jmp 0x15e05
leaq 0x3663e(%rip), %rdx # 0x4c4bc
leaq 0x36f68(%rip), %r8 # 0x4cded
movq %rbx, %rdi
movl $0x1, %esi
movl $0x10f1, %ecx # imm = 0x10F1
xorl %eax, %eax
callq 0xf997
movl $0xffff8600, %ebp # imm = 0xFFFF8600
jmp 0x15be8
leaq 0x36612(%rip), %rdx # 0x4c4bc
leaq 0x36f1c(%rip), %r8 # 0x4cdcd
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x1, %esi
movl $0x10cd, %ecx # imm = 0x10CD
xorl %eax, %eax
callq 0xf997
movq 0x58(%rbx), %rax
movl $0x40, 0x70(%rax)
cmpl $0x1, %r12d
movl $0xffff8b80, %ebp # imm = 0xFFFF8B80
cmovel %r14d, %ebp
jmp 0x15be8
movq 0x58(%rbx), %rax
movq 0x68(%rax), %r9
leaq 0x365c8(%rip), %rdx # 0x4c4bc
leaq 0x36f3d(%rip), %r8 # 0x4ce38
movq %rbx, %rdi
movl $0x3, %esi
movl $0x1125, %ecx # imm = 0x1125
callq 0x10078
movq (%rbx), %r15
testb $0x1, 0x174(%r15)
jne 0x15fae
cmpl $0x1, 0xc(%rbx)
jne 0x15fae
movq 0x50(%rbx), %rax
movq 0x68(%rax), %rax
testq %rax, %rax
je 0x1617b
movq 0x8(%rax), %rdx
movq 0x58(%rbx), %rcx
movq 0x68(%rcx), %rcx
cmpq 0x8(%rcx), %rdx
jne 0x15f5c
movq 0x10(%rax), %rdi
movq 0x10(%rcx), %rsi
callq 0xf2b0
testl %eax, %eax
je 0x15fae
leaq 0x36559(%rip), %rdx # 0x4c4bc
leaq 0x36f04(%rip), %r8 # 0x4ce6e
movq %rbx, %rdi
movl $0x1, %esi
movl $0x113b, %ecx # imm = 0x113B
jmp 0x15e92
leaq 0x36539(%rip), %rdx # 0x4c4bc
leaq 0x36e7b(%rip), %r8 # 0x4ce05
movl $0x228, %r9d # imm = 0x228
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1100, %ecx # imm = 0x1100
xorl %eax, %eax
callq 0xf997
movl $0xffff8100, %ebp # imm = 0xFFFF8100
jmp 0x15be8
testl %r12d, %r12d
je 0x16154
movq 0x60(%rbx), %rax
movq 0x398(%rax), %rsi
testq %rsi, %rsi
je 0x1600f
addq $0x3a0, %rax # imm = 0x3A0
jmp 0x16026
leaq 0x364e6(%rip), %rdx # 0x4c4bc
leaq 0x36e10(%rip), %r8 # 0x4cded
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1116, %ecx # imm = 0x1116
jmp 0x15e92
leaq 0x364c6(%rip), %rdx # 0x4c4bc
leaq 0x36df0(%rip), %r8 # 0x4cded
movq %rbx, %rdi
movl $0x1, %esi
movl $0x110c, %ecx # imm = 0x110C
jmp 0x15e92
movq 0xd8(%r15), %rsi
testq %rsi, %rsi
je 0x161bb
leaq 0xe0(%r15), %rax
movq (%rax), %rdx
movq 0x58(%rbx), %r9
movq 0x170(%rbx), %r8
movq 0x68(%r9), %rdi
movq 0xc8(%r15), %rcx
addq $0x70, %r9
movups 0x68(%r15), %xmm0
movups %xmm0, (%rsp)
callq 0x22dcf
movl %eax, %r15d
testl %eax, %eax
je 0x1607b
leaq 0x3645d(%rip), %rdx # 0x4c4bc
leaq 0x36e41(%rip), %r8 # 0x4cea7
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1166, %ecx # imm = 0x1166
movl %r15d, %r9d
callq 0xfa82
movq 0x58(%rbx), %rax
movq 0x68(%rax), %r13
leaq 0x148(%r13), %rdi
movl $0x2, %esi
callq 0x3b0be
movq (%rbx), %rdx
testl %eax, %eax
je 0x160f9
movq 0xf0(%rdx), %rax
testq %rax, %rax
je 0x160c8
movl (%rax), %ecx
testl %ecx, %ecx
je 0x160c8
movq 0x150(%r13), %rsi
movl (%rsi), %esi
addq $0x4, %rax
cmpl %esi, %ecx
je 0x160f9
movl (%rax), %ecx
addq $0x4, %rax
testl %ecx, %ecx
jne 0x160ba
leaq 0x363ed(%rip), %rdx # 0x4c4bc
leaq 0x36de2(%rip), %r8 # 0x4ceb8
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1175, %ecx # imm = 0x1175
xorl %eax, %eax
callq 0xf997
testl %r15d, %r15d
movl $0xffff8600, %eax # imm = 0xFFFF8600
cmovel %eax, %r15d
movq (%rbx), %rdx
movq 0x58(%rbx), %rcx
movq 0x68(%rcx), %rdi
movl 0x174(%rdx), %edx
notl %edx
andl $0x1, %edx
addq $0x70, %rcx
movq %r14, %rsi
callq 0x16217
testl %eax, %eax
je 0x1614a
leaq 0x36399(%rip), %rdx # 0x4c4bc
leaq 0x36dad(%rip), %r8 # 0x4ced7
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1181, %ecx # imm = 0x1181
xorl %eax, %eax
callq 0xf997
testl %r15d, %r15d
movl $0xffff8600, %eax # imm = 0xFFFF8600
cmovel %eax, %r15d
xorl %ebp, %ebp
cmpl $0x1, %r12d
cmovnel %r15d, %ebp
leaq 0x36361(%rip), %rdx # 0x4c4bc
leaq 0x36d98(%rip), %r8 # 0x4cefa
movq %rbx, %rdi
movl $0x2, %esi
movl $0x118a, %ecx # imm = 0x118A
xorl %eax, %eax
callq 0xf997
jmp 0x15be8
leaq 0x3633a(%rip), %rdx # 0x4c4bc
leaq 0x36cc0(%rip), %r8 # 0x4ce49
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1131, %ecx # imm = 0x1131
jmp 0x15e92
leaq 0x3631a(%rip), %rdx # 0x4c4bc
leaq 0x36c73(%rip), %r8 # 0x4ce1c
movq %rbx, %rdi
movl $0x1, %esi
movl $0x111e, %ecx # imm = 0x111E
jmp 0x15ca8
leaq 0x362fa(%rip), %rdx # 0x4c4bc
leaq 0x36cce(%rip), %r8 # 0x4ce97
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1155, %ecx # imm = 0x1155
xorl %eax, %eax
callq 0xf997
movl $0xffff8980, %ebp # imm = 0xFFFF8980
jmp 0x15be8
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_check_curve | int mbedtls_ssl_check_curve( const mbedtls_ssl_context *ssl, mbedtls_ecp_group_id grp_id )
{
const mbedtls_ecp_group_id *gid;
if( ssl->conf->curve_list == NULL )
return( -1 );
for( gid = ssl->conf->curve_list; *gid != MBEDTLS_ECP_DP_NONE; gid++ )
if( *gid == grp_id )
return( 0 );
return( -1 );
} | movq (%rdi), %rax
movq 0xf0(%rax), %rcx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testq %rcx, %rcx
je 0x16213
movl (%rcx), %edx
testl %edx, %edx
je 0x16213
addq $0x4, %rcx
cmpl %esi, %edx
je 0x16214
movl (%rcx), %edx
addq $0x4, %rcx
testl %edx, %edx
jne 0x16205
retq
xorl %eax, %eax
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_check_cert_usage | int mbedtls_ssl_check_cert_usage( const mbedtls_x509_crt *cert,
const mbedtls_ssl_ciphersuite_t *ciphersuite,
int cert_endpoint,
uint32_t *flags )
{
int ret = 0;
#if defined(MBEDTLS_X509_CHECK_KEY_USAGE)
int usage = 0;
#endif
#if defined(MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE)
const char *ext_oid;
size_t ext_len;
#endif
#if !defined(MBEDTLS_X509_CHECK_KEY_USAGE) && \
!defined(MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE)
((void) cert);
((void) cert_endpoint);
((void) flags);
#endif
#if defined(MBEDTLS_X509_CHECK_KEY_USAGE)
if( cert_endpoint == MBEDTLS_SSL_IS_SERVER )
{
/* Server part of the key exchange */
switch( ciphersuite->key_exchange )
{
case MBEDTLS_KEY_EXCHANGE_RSA:
case MBEDTLS_KEY_EXCHANGE_RSA_PSK:
usage = MBEDTLS_X509_KU_KEY_ENCIPHERMENT;
break;
case MBEDTLS_KEY_EXCHANGE_DHE_RSA:
case MBEDTLS_KEY_EXCHANGE_ECDHE_RSA:
case MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA:
usage = MBEDTLS_X509_KU_DIGITAL_SIGNATURE;
break;
case MBEDTLS_KEY_EXCHANGE_ECDH_RSA:
case MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA:
usage = MBEDTLS_X509_KU_KEY_AGREEMENT;
break;
/* Don't use default: we want warnings when adding new values */
case MBEDTLS_KEY_EXCHANGE_NONE:
case MBEDTLS_KEY_EXCHANGE_PSK:
case MBEDTLS_KEY_EXCHANGE_DHE_PSK:
case MBEDTLS_KEY_EXCHANGE_ECDHE_PSK:
case MBEDTLS_KEY_EXCHANGE_ECJPAKE:
usage = 0;
}
}
else
{
/* Client auth: we only implement rsa_sign and mbedtls_ecdsa_sign for now */
usage = MBEDTLS_X509_KU_DIGITAL_SIGNATURE;
}
if( mbedtls_x509_crt_check_key_usage( cert, usage ) != 0 )
{
*flags |= MBEDTLS_X509_BADCERT_KEY_USAGE;
ret = -1;
}
#else
((void) ciphersuite);
#endif /* MBEDTLS_X509_CHECK_KEY_USAGE */
#if defined(MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE)
if( cert_endpoint == MBEDTLS_SSL_IS_SERVER )
{
ext_oid = MBEDTLS_OID_SERVER_AUTH;
ext_len = MBEDTLS_OID_SIZE( MBEDTLS_OID_SERVER_AUTH );
}
else
{
ext_oid = MBEDTLS_OID_CLIENT_AUTH;
ext_len = MBEDTLS_OID_SIZE( MBEDTLS_OID_CLIENT_AUTH );
}
if( mbedtls_x509_crt_check_extended_key_usage( cert, ext_oid, ext_len ) != 0 )
{
*flags |= MBEDTLS_X509_BADCERT_EXT_KEY_USAGE;
ret = -1;
}
#endif /* MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE */
return( ret );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %rax
movq %rdi, %r14
movl $0x80, %esi
cmpl $0x1, %edx
jne 0x1624b
movl 0x18(%rax), %eax
decl %eax
xorl %esi, %esi
cmpl $0x9, %eax
ja 0x1624b
movl %eax, %eax
leaq 0x3623c(%rip), %rcx # 0x4c484
movl (%rcx,%rax,4), %esi
movq %r14, %rdi
callq 0x22cb5
testl %eax, %eax
je 0x16263
orb $0x8, 0x1(%rbx)
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
jmp 0x16266
xorl %r15d, %r15d
cmpl $0x1, %ebp
leaq 0x37480(%rip), %rax # 0x4d6f0
leaq 0x37482(%rip), %rsi # 0x4d6f9
cmoveq %rax, %rsi
movl $0x8, %edx
movq %r14, %rdi
callq 0x22ce7
testl %eax, %eax
je 0x16296
orb $0x10, 0x1(%rbx)
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_write_change_cipher_spec | int mbedtls_ssl_write_change_cipher_spec( mbedtls_ssl_context *ssl )
{
int ret;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write change cipher spec" ) );
ssl->out_msgtype = MBEDTLS_SSL_MSG_CHANGE_CIPHER_SPEC;
ssl->out_msglen = 1;
ssl->out_msg[0] = 1;
ssl->state++;
if( ( ret = mbedtls_ssl_write_record( ssl ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_write_record", ret );
return( ret );
}
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write change cipher spec" ) );
return( 0 );
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3620b(%rip), %rdx # 0x4c4bc
leaq 0x36c57(%rip), %r8 # 0x4cf0f
movl $0x2, %esi
movl $0x119a, %ecx # imm = 0x119A
xorl %eax, %eax
callq 0xf997
movl $0x14, 0x150(%rbx)
movq $0x1, 0x158(%rbx)
movq 0x148(%rbx), %rax
movb $0x1, (%rax)
incl 0x8(%rbx)
movq %rbx, %rdi
callq 0x12b2b
movl %eax, %ebp
leaq 0x361c0(%rip), %rdx # 0x4c4bc
testl %eax, %eax
je 0x1631e
leaq 0x365e2(%rip), %r8 # 0x4c8e9
movq %rbx, %rdi
movl $0x1, %esi
movl $0x11a4, %ecx # imm = 0x11A4
movl %ebp, %r9d
callq 0xfa82
jmp 0x16339
leaq 0x36c06(%rip), %r8 # 0x4cf2b
movq %rbx, %rdi
movl $0x2, %esi
movl $0x11a8, %ecx # imm = 0x11A8
xorl %eax, %eax
callq 0xf997
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_optimize_checksum | void mbedtls_ssl_optimize_checksum( mbedtls_ssl_context *ssl,
const mbedtls_ssl_ciphersuite_t *ciphersuite_info )
{
((void) ciphersuite_info);
#if defined(MBEDTLS_SSL_PROTO_SSL3) || defined(MBEDTLS_SSL_PROTO_TLS1) || \
defined(MBEDTLS_SSL_PROTO_TLS1_1)
if( ssl->minor_ver < MBEDTLS_SSL_MINOR_VERSION_3 )
ssl->handshake->update_checksum = ssl_update_checksum_md5sha1;
else
#endif
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
#if defined(MBEDTLS_SHA512_C)
if( ciphersuite_info->mac == MBEDTLS_MD_SHA384 )
ssl->handshake->update_checksum = ssl_update_checksum_sha384;
else
#endif
#if defined(MBEDTLS_SHA256_C)
if( ciphersuite_info->mac != MBEDTLS_MD_SHA384 )
ssl->handshake->update_checksum = ssl_update_checksum_sha256;
else
#endif
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
return;
}
} | cmpl $0x2, 0x18(%rdi)
jg 0x1650b
movq 0x60(%rdi), %rax
leaq 0x24(%rip), %rcx # 0x1652d
jmp 0x16525
cmpl $0x7, 0x14(%rsi)
movq 0x60(%rdi), %rax
jne 0x1651e
leaq 0x46(%rip), %rcx # 0x16562
jmp 0x16525
leaq 0x4e(%rip), %rcx # 0x16573
movq %rcx, 0x5f0(%rax)
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_handshake_wrapup | void mbedtls_ssl_handshake_wrapup( mbedtls_ssl_context *ssl )
{
int resume = ssl->handshake->resume;
MBEDTLS_SSL_DEBUG_MSG( 3, ( "=> handshake wrapup" ) );
#if defined(MBEDTLS_SSL_RENEGOTIATION)
if( ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS )
{
ssl->renego_status = MBEDTLS_SSL_RENEGOTIATION_DONE;
ssl->renego_records_seen = 0;
}
#endif
/*
* Free the previous session and switch in the current one
*/
if( ssl->session )
{
#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
/* RFC 7366 3.1: keep the EtM state */
ssl->session_negotiate->encrypt_then_mac =
ssl->session->encrypt_then_mac;
#endif
mbedtls_ssl_session_free( ssl->session );
mbedtls_free( ssl->session );
}
ssl->session = ssl->session_negotiate;
ssl->session_negotiate = NULL;
/*
* Add cache entry
*/
if( ssl->conf->f_set_cache != NULL &&
ssl->session->id_len != 0 &&
resume == 0 )
{
if( ssl->conf->f_set_cache( ssl->conf->p_cache, ssl->session ) != 0 )
MBEDTLS_SSL_DEBUG_MSG( 1, ( "cache did not store session" ) );
}
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
ssl->handshake->flight != NULL )
{
/* Cancel handshake timer */
ssl_set_timer( ssl, 0 );
/* Keep last flight around in case we need to resend it:
* we need the handshake and transform structures for that */
MBEDTLS_SSL_DEBUG_MSG( 3, ( "skip freeing handshake and transform" ) );
}
else
#endif
ssl_handshake_wrapup_free_hs_transform( ssl );
ssl->state++;
MBEDTLS_SSL_DEBUG_MSG( 3, ( "<= handshake wrapup" ) );
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movl 0xa7c(%rax), %ebp
leaq 0x35edd(%rip), %rdx # 0x4c4bc
leaq 0x369ff(%rip), %r8 # 0x4cfe5
movl $0x3, %esi
movl $0x1369, %ecx # imm = 0x1369
xorl %eax, %eax
callq 0xf997
cmpl $0x1, 0xc(%rbx)
jne 0x16605
movq $0x2, 0xc(%rbx)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x1662c
movl 0x94(%rdi), %eax
movq 0x58(%rbx), %rcx
movl %eax, 0x94(%rcx)
callq 0x166fa
movq 0x50(%rbx), %rdi
callq 0xf030
movq (%rbx), %rax
movq 0x58(%rbx), %rsi
movq %rsi, 0x50(%rbx)
movq $0x0, 0x58(%rbx)
movq 0x48(%rax), %rcx
testq %rcx, %rcx
je 0x1667f
cmpq $0x0, 0x10(%rsi)
je 0x1667f
testl %ebp, %ebp
jne 0x1667f
movq 0x50(%rax), %rdi
callq *%rcx
testl %eax, %eax
je 0x1667f
leaq 0x35e58(%rip), %rdx # 0x4c4bc
leaq 0x3698e(%rip), %r8 # 0x4cff9
movq %rbx, %rdi
movl $0x1, %esi
movl $0x138c, %ecx # imm = 0x138C
xorl %eax, %eax
callq 0xf997
movq (%rbx), %rax
testb $0x2, 0x174(%rax)
je 0x166c7
movq 0x60(%rbx), %rax
cmpq $0x0, 0x3d0(%rax)
je 0x166c7
movq %rbx, %rdi
xorl %esi, %esi
callq 0x125b5
leaq 0x35e12(%rip), %rdx # 0x4c4bc
leaq 0x36964(%rip), %r8 # 0x4d015
movq %rbx, %rdi
movl $0x3, %esi
movl $0x1398, %ecx # imm = 0x1398
xorl %eax, %eax
callq 0xf997
jmp 0x166cf
movq %rbx, %rdi
callq 0x15801
incl 0x8(%rbx)
leaq 0x35de3(%rip), %rdx # 0x4c4bc
leaq 0x3695a(%rip), %r8 # 0x4d03a
movq %rbx, %rdi
movl $0x3, %esi
movl $0x13a0, %ecx # imm = 0x13A0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xf997
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_session_free | void mbedtls_ssl_session_free( mbedtls_ssl_session *session )
{
if( session == NULL )
return;
#if defined(MBEDTLS_X509_CRT_PARSE_C)
if( session->peer_cert != NULL )
{
mbedtls_x509_crt_free( session->peer_cert );
mbedtls_free( session->peer_cert );
}
#endif
#if defined(MBEDTLS_SSL_SESSION_TICKETS) && defined(MBEDTLS_SSL_CLI_C)
mbedtls_free( session->ticket );
#endif
mbedtls_zeroize( session, sizeof( mbedtls_ssl_session ) );
} | testq %rdi, %rdi
je 0x16735
pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
testq %rdi, %rdi
je 0x1671a
callq 0x2387e
movq 0x68(%rbx), %rdi
callq 0xf030
movq 0x78(%rbx), %rdi
callq 0xf030
xorl %eax, %eax
movb $0x0, (%rbx,%rax)
incq %rax
cmpq $0x98, %rax
jne 0x16725
popq %rbx
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_parse_finished | int mbedtls_ssl_parse_finished( mbedtls_ssl_context *ssl )
{
int ret;
unsigned int hash_len;
unsigned char buf[SSL_MAX_HASH_LEN];
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse finished" ) );
ssl->handshake->calc_finished( ssl, buf, ssl->conf->endpoint ^ 1 );
if( ( ret = mbedtls_ssl_read_record( ssl ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_read_record", ret );
return( ret );
}
if( ssl->in_msgtype != MBEDTLS_SSL_MSG_HANDSHAKE )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad finished message" ) );
return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
}
/* There is currently no ciphersuite using another length with TLS 1.2 */
#if defined(MBEDTLS_SSL_PROTO_SSL3)
if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 )
hash_len = 36;
else
#endif
hash_len = 12;
if( ssl->in_msg[0] != MBEDTLS_SSL_HS_FINISHED ||
ssl->in_hslen != mbedtls_ssl_hs_hdr_len( ssl ) + hash_len )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad finished message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_FINISHED );
}
if( mbedtls_ssl_safer_memcmp( ssl->in_msg + mbedtls_ssl_hs_hdr_len( ssl ),
buf, hash_len ) != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad finished message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_FINISHED );
}
#if defined(MBEDTLS_SSL_RENEGOTIATION)
ssl->verify_data_len = hash_len;
memcpy( ssl->peer_verify_data, buf, hash_len );
#endif
if( ssl->handshake->resume != 0 )
{
#if defined(MBEDTLS_SSL_CLI_C)
if( ssl->conf->endpoint == MBEDTLS_SSL_IS_CLIENT )
ssl->state = MBEDTLS_SSL_CLIENT_CHANGE_CIPHER_SPEC;
#endif
#if defined(MBEDTLS_SSL_SRV_C)
if( ssl->conf->endpoint == MBEDTLS_SSL_IS_SERVER )
ssl->state = MBEDTLS_SSL_HANDSHAKE_WRAPUP;
#endif
}
else
ssl->state++;
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
mbedtls_ssl_recv_flight_completed( ssl );
#endif
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse finished" ) );
return( 0 );
} | pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x35b46(%rip), %rdx # 0x4c4bc
leaq 0x36727(%rip), %r8 # 0x4d0a4
movl $0x2, %esi
movl $0x1425, %ecx # imm = 0x1425
xorl %eax, %eax
callq 0xf997
movq (%rbx), %rax
movq 0x60(%rbx), %rcx
movl 0x174(%rax), %edx
notl %edx
andl $0x1, %edx
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq *0x600(%rcx)
movq %rbx, %rdi
callq 0x141f2
testl %eax, %eax
je 0x169e4
movl %eax, %ebp
leaq 0x35af9(%rip), %rdx # 0x4c4bc
leaq 0x363eb(%rip), %r8 # 0x4cdb5
movq %rbx, %rdi
movl $0x1, %esi
movl $0x142b, %ecx # imm = 0x142B
movl %eax, %r9d
callq 0xfa82
jmp 0x16aaf
cmpl $0x16, 0xd8(%rbx)
jne 0x16a5f
movq 0xc8(%rbx), %rcx
cmpb $0x14, (%rcx)
jne 0x16a88
movq (%rbx), %rax
movb 0x174(%rax), %dl
andb $0x2, %dl
shrb %dl
movzbl %dl, %edx
shll $0x3, %edx
leaq 0x10(%rdx), %rsi
cmpq %rsi, 0x110(%rbx)
jne 0x16a88
orq $0x4, %rdx
addq %rdx, %rcx
xorl %edx, %edx
xorl %esi, %esi
movb 0xc(%rsp,%rsi), %dil
xorb (%rcx,%rsi), %dil
orb %dil, %dl
incq %rsi
cmpq $0xc, %rsi
jne 0x16a29
testb %dl, %dl
je 0x16ab8
leaq 0x35a73(%rip), %rdx # 0x4c4bc
leaq 0x36666(%rip), %r8 # 0x4d0b6
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1447, %ecx # imm = 0x1447
jmp 0x16aa3
leaq 0x35a56(%rip), %rdx # 0x4c4bc
leaq 0x36649(%rip), %r8 # 0x4d0b6
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1431, %ecx # imm = 0x1431
xorl %eax, %eax
callq 0xf997
movl $0xffff8900, %ebp # imm = 0xFFFF8900
jmp 0x16aaf
leaq 0x35a2d(%rip), %rdx # 0x4c4bc
leaq 0x36620(%rip), %r8 # 0x4d0b6
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1440, %ecx # imm = 0x1440
xorl %eax, %eax
callq 0xf997
movl $0xffff8180, %ebp # imm = 0xFFFF8180
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq $0xc, 0x198(%rbx)
movl 0x14(%rsp), %ecx
movl %ecx, 0x1b4(%rbx)
movq 0xc(%rsp), %rcx
movq %rcx, 0x1ac(%rbx)
movq 0x60(%rbx), %rcx
cmpl $0x0, 0xa7c(%rcx)
je 0x16b08
testb $0x1, 0x174(%rax)
jne 0x16aff
movl $0xa, 0x8(%rbx)
testb $0x1, 0x174(%rax)
je 0x16b0b
movl $0xf, 0x8(%rbx)
jmp 0x16b0b
incl 0x8(%rbx)
testb $0x2, 0x174(%rax)
je 0x16b1c
movq %rbx, %rdi
callq 0x137db
leaq 0x35999(%rip), %rdx # 0x4c4bc
leaq 0x365a1(%rip), %r8 # 0x4d0cb
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x2, %esi
movl $0x1463, %ecx # imm = 0x1463
xorl %eax, %eax
callq 0xf997
jmp 0x16aaf
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_setup | int mbedtls_ssl_setup( mbedtls_ssl_context *ssl,
const mbedtls_ssl_config *conf )
{
int ret;
const size_t len = MBEDTLS_SSL_BUFFER_LEN;
ssl->conf = conf;
/*
* Prepare base structures
*/
if( ( ssl-> in_buf = mbedtls_calloc( 1, len ) ) == NULL ||
( ssl->out_buf = mbedtls_calloc( 1, len ) ) == NULL )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "alloc(%d bytes) failed", len ) );
mbedtls_free( ssl->in_buf );
ssl->in_buf = NULL;
return( MBEDTLS_ERR_SSL_ALLOC_FAILED );
}
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
ssl->out_hdr = ssl->out_buf;
ssl->out_ctr = ssl->out_buf + 3;
ssl->out_len = ssl->out_buf + 11;
ssl->out_iv = ssl->out_buf + 13;
ssl->out_msg = ssl->out_buf + 13;
ssl->in_hdr = ssl->in_buf;
ssl->in_ctr = ssl->in_buf + 3;
ssl->in_len = ssl->in_buf + 11;
ssl->in_iv = ssl->in_buf + 13;
ssl->in_msg = ssl->in_buf + 13;
}
else
#endif
{
ssl->out_ctr = ssl->out_buf;
ssl->out_hdr = ssl->out_buf + 8;
ssl->out_len = ssl->out_buf + 11;
ssl->out_iv = ssl->out_buf + 13;
ssl->out_msg = ssl->out_buf + 13;
ssl->in_ctr = ssl->in_buf;
ssl->in_hdr = ssl->in_buf + 8;
ssl->in_len = ssl->in_buf + 11;
ssl->in_iv = ssl->in_buf + 13;
ssl->in_msg = ssl->in_buf + 13;
}
if( ( ret = ssl_handshake_init( ssl ) ) != 0 )
return( ret );
return( 0 );
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, (%rdi)
movl $0x1, %edi
movl $0x414d, %esi # imm = 0x414D
callq 0xf1d0
movq %rax, 0xa0(%rbx)
testq %rax, %rax
je 0x16bc2
movq %rax, %r14
movl $0x1, %edi
movl $0x414d, %esi # imm = 0x414D
callq 0xf1d0
movq %rax, 0x120(%rbx)
testq %rax, %rax
je 0x16bc2
testb $0x2, 0x174(%r15)
jne 0x16c0c
movq %rax, 0x128(%rbx)
leaq 0x8(%rax), %rsi
leaq 0x8(%r14), %rdx
movq %r14, %rcx
jmp 0x16c21
leaq 0x358f3(%rip), %rdx # 0x4c4bc
leaq 0x36235(%rip), %r8 # 0x4ce05
movl $0x414d, %r9d # imm = 0x414D
movq %rbx, %rdi
movl $0x1, %esi
movl $0x151f, %ecx # imm = 0x151F
xorl %eax, %eax
callq 0xf997
movq 0xa0(%rbx), %rdi
callq 0xf030
movq $0x0, 0xa0(%rbx)
movl $0xffff8100, %eax # imm = 0xFFFF8100
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3(%rax), %rcx
movq %rcx, 0x128(%rbx)
leaq 0x3(%r14), %rcx
movq %rax, %rsi
movq %r14, %rdx
leaq 0xd(%r14), %rdi
addq $0xb, %r14
leaq 0xd(%rax), %r8
addq $0xb, %rax
movq %rsi, 0x130(%rbx)
movq %rax, 0x138(%rbx)
movq %r8, 0x140(%rbx)
movq %r8, 0x148(%rbx)
movq %rcx, 0xa8(%rbx)
movq %rdx, 0xb0(%rbx)
movq %r14, 0xb8(%rbx)
movq %rdi, 0xc0(%rbx)
movq %rdi, 0xc8(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x16c7a
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
ssl_handshake_init | static int ssl_handshake_init( mbedtls_ssl_context *ssl )
{
/* Clear old handshake information if present */
if( ssl->transform_negotiate )
mbedtls_ssl_transform_free( ssl->transform_negotiate );
if( ssl->session_negotiate )
mbedtls_ssl_session_free( ssl->session_negotiate );
if( ssl->handshake )
mbedtls_ssl_handshake_free( ssl->handshake );
/*
* Either the pointers are now NULL or cleared properly and can be freed.
* Now allocate missing structures.
*/
if( ssl->transform_negotiate == NULL )
{
ssl->transform_negotiate = mbedtls_calloc( 1, sizeof(mbedtls_ssl_transform) );
}
if( ssl->session_negotiate == NULL )
{
ssl->session_negotiate = mbedtls_calloc( 1, sizeof(mbedtls_ssl_session) );
}
if( ssl->handshake == NULL )
{
ssl->handshake = mbedtls_calloc( 1, sizeof(mbedtls_ssl_handshake_params) );
}
/* All pointers should exist and can be directly freed without issue */
if( ssl->handshake == NULL ||
ssl->transform_negotiate == NULL ||
ssl->session_negotiate == NULL )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "alloc() of ssl sub-contexts failed" ) );
mbedtls_free( ssl->handshake );
mbedtls_free( ssl->transform_negotiate );
mbedtls_free( ssl->session_negotiate );
ssl->handshake = NULL;
ssl->transform_negotiate = NULL;
ssl->session_negotiate = NULL;
return( MBEDTLS_ERR_SSL_ALLOC_FAILED );
}
/* Initialize structures */
mbedtls_ssl_session_init( ssl->session_negotiate );
ssl_transform_init( ssl->transform_negotiate );
ssl_handshake_params_init( ssl->handshake );
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
ssl->handshake->alt_transform_out = ssl->transform_out;
if( ssl->conf->endpoint == MBEDTLS_SSL_IS_CLIENT )
ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_PREPARING;
else
ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_WAITING;
ssl_set_timer( ssl, 0 );
}
#endif
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x80(%rdi), %rdi
testq %rdi, %rdi
je 0x16c96
callq 0x18455
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x16ca4
callq 0x166fa
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x16cb2
callq 0x1849b
leaq 0x58(%rbx), %r15
cmpq $0x0, 0x80(%rbx)
je 0x16cc4
xorl %ebp, %ebp
jmp 0x16ce1
movl $0x1, %edi
movl $0x130, %esi # imm = 0x130
callq 0xf1d0
movq %rax, 0x80(%rbx)
testq %rax, %rax
sete %bpl
movq (%r15), %r14
testq %r14, %r14
jne 0x16cfe
movl $0x1, %edi
movl $0x98, %esi
callq 0xf1d0
movq %rax, %r14
movq %rax, (%r15)
cmpq $0x0, 0x60(%rbx)
je 0x16d73
testq %r14, %r14
setne %al
notb %bpl
testb %al, %bpl
jne 0x16d9d
leaq 0x3579e(%rip), %rdx # 0x4c4bc
leaq 0x3727f(%rip), %r8 # 0x4dfa4
movq %rbx, %rdi
movl $0x1, %esi
movl $0x14c6, %ecx # imm = 0x14C6
xorl %eax, %eax
callq 0xf997
movq 0x60(%rbx), %rdi
callq 0xf030
movq 0x80(%rbx), %rdi
callq 0xf030
movq 0x58(%rbx), %rdi
callq 0xf030
movq $0x0, 0x80(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movl $0xffff8100, %ebp # imm = 0xFFFF8100
jmp 0x16ed3
movl $0x1, %edi
movl $0xa98, %esi # imm = 0xA98
callq 0xf1d0
movq %rax, 0x60(%rbx)
testq %rax, %rax
sete %al
testq %r14, %r14
sete %cl
orb %bpl, %al
orb %cl, %al
jne 0x16d17
xorl %ebp, %ebp
movl $0x98, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0xf150
movq 0x80(%rbx), %r14
movl $0x130, %edx # imm = 0x130
movq %r14, %rdi
xorl %esi, %esi
callq 0xf150
leaq 0x80(%r14), %rdi
callq 0x2a0fd
leaq 0xd8(%r14), %rdi
callq 0x2a0fd
leaq 0x50(%r14), %rdi
callq 0x38cf4
addq $0x68, %r14
movq %r14, %rdi
callq 0x38cf4
movq 0x60(%rbx), %r14
movl $0xa98, %edx # imm = 0xA98
movq %r14, %rdi
xorl %esi, %esi
callq 0xf150
leaq 0x3f8(%r14), %r15
movq %r15, %rdi
callq 0x3928c
leaq 0x450(%r14), %r12
movq %r12, %rdi
callq 0x40c04
movq %r15, %rdi
callq 0x392c8
movq %r12, %rdi
callq 0x40c3c
leaq 0x4ac(%r14), %r15
movq %r15, %rdi
callq 0x42170
movq %r15, %rdi
xorl %esi, %esi
callq 0x421ac
leaq 0x518(%r14), %r15
movq %r15, %rdi
callq 0x430d8
movq %r15, %rdi
movl $0x1, %esi
callq 0x43105
leaq 0x2025(%rip), %rax # 0x18e93
movq %rax, 0x5f0(%r14)
movl $0x2, (%r14)
leaq 0x8(%r14), %rdi
callq 0x2ccd0
leaq 0x100(%r14), %rdi
callq 0x2d8c7
movl $0x3, 0x388(%r14)
movq (%rbx), %rax
testb $0x2, 0x174(%rax)
je 0x16ed3
movq 0x60(%rbx), %rcx
movq 0x70(%rbx), %rdx
movq %rdx, 0x3e8(%rcx)
movb 0x174(%rax), %al
addb %al, %al
andb $0x2, %al
movb %al, 0x3cc(%rcx)
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x125b5
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_set_session | int mbedtls_ssl_set_session( mbedtls_ssl_context *ssl, const mbedtls_ssl_session *session )
{
int ret;
if( ssl == NULL ||
session == NULL ||
ssl->session_negotiate == NULL ||
ssl->conf->endpoint != MBEDTLS_SSL_IS_CLIENT )
{
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
if( ( ret = ssl_session_copy( ssl->session_negotiate, session ) ) != 0 )
return( ret );
ssl->handshake->resume = 1;
return( 0 );
} | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movl $0xffff8f00, %eax # imm = 0xFFFF8F00
jne 0x17149
pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
testq %rdi, %rdi
je 0x17148
movq (%rbx), %rcx
testb $0x1, 0x174(%rcx)
jne 0x17148
callq 0x1714a
testl %eax, %eax
jne 0x17148
movq 0x60(%rbx), %rax
movl $0x1, 0xa7c(%rax)
xorl %eax, %eax
popq %rbx
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_set_hs_psk | int mbedtls_ssl_set_hs_psk( mbedtls_ssl_context *ssl,
const unsigned char *psk, size_t psk_len )
{
if( psk == NULL || ssl->handshake == NULL )
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
if( psk_len > MBEDTLS_PSK_MAX_LEN )
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
if( ssl->handshake->psk != NULL )
mbedtls_free( ssl->handshake->psk );
if( ( ssl->handshake->psk = mbedtls_calloc( 1, psk_len ) ) == NULL )
return( MBEDTLS_ERR_SSL_ALLOC_FAILED );
ssl->handshake->psk_len = psk_len;
memcpy( ssl->handshake->psk, psk, ssl->handshake->psk_len );
return( 0 );
} | movl $0xffff8f00, %eax # imm = 0xFFFF8F00
testq %rsi, %rsi
je 0x17461
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r15
movq 0x60(%rdi), %r12
testq %r12, %r12
sete %cl
cmpq $0x21, %rdx
setae %dl
orb %cl, %dl
jne 0x17456
movq %rsi, %r14
movq 0x370(%r12), %rdi
testq %rdi, %rdi
je 0x1741d
callq 0xf030
movq 0x60(%r15), %r12
movl $0x1, %edi
movq %rbx, %rsi
callq 0xf1d0
movq %rax, 0x370(%r12)
testq %rax, %rax
je 0x17451
movq %rbx, 0x378(%r12)
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf240
xorl %eax, %eax
jmp 0x17456
movl $0xffff8100, %eax # imm = 0xFFFF8100
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_conf_dh_param_ctx | int mbedtls_ssl_conf_dh_param_ctx( mbedtls_ssl_config *conf, mbedtls_dhm_context *dhm_ctx )
{
int ret;
if( ( ret = mbedtls_mpi_copy( &conf->dhm_P, &dhm_ctx->P ) ) != 0 ||
( ret = mbedtls_mpi_copy( &conf->dhm_G, &dhm_ctx->G ) ) != 0 )
{
mbedtls_mpi_free( &conf->dhm_P );
mbedtls_mpi_free( &conf->dhm_G );
return( ret );
}
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xf8(%rdi), %r14
addq $0x8, %rsi
movq %r14, %rdi
callq 0x25a94
testl %eax, %eax
jne 0x17513
leaq 0x110(%rbx), %rdi
addq $0x20, %r15
movq %r15, %rsi
callq 0x25a94
testl %eax, %eax
je 0x17539
movl %eax, %ebp
movq %r14, %rdi
callq 0x2590b
addq $0x110, %rbx # imm = 0x110
movq %rbx, %rdi
callq 0x2590b
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
jmp 0x1752c
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_get_version | const char *mbedtls_ssl_get_version( const mbedtls_ssl_context *ssl )
{
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
switch( ssl->minor_ver )
{
case MBEDTLS_SSL_MINOR_VERSION_2:
return( "DTLSv1.0" );
case MBEDTLS_SSL_MINOR_VERSION_3:
return( "DTLSv1.2" );
default:
return( "unknown (DTLS)" );
}
}
#endif
switch( ssl->minor_ver )
{
case MBEDTLS_SSL_MINOR_VERSION_0:
return( "SSLv3.0" );
case MBEDTLS_SSL_MINOR_VERSION_1:
return( "TLSv1.0" );
case MBEDTLS_SSL_MINOR_VERSION_2:
return( "TLSv1.1" );
case MBEDTLS_SSL_MINOR_VERSION_3:
return( "TLSv1.2" );
default:
return( "unknown" );
}
} | movq (%rdi), %rax
testb $0x2, 0x174(%rax)
movl 0x18(%rdi), %eax
jne 0x1780f
cmpl $0x3, %eax
ja 0x17835
leaq 0x34ca5(%rip), %rcx # 0x4c4ac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
cmpq $0x3, %rax
leaq 0x358cc(%rip), %rcx # 0x4d0e6
leaq 0x358ce(%rip), %rdx # 0x4d0ef
cmoveq %rcx, %rdx
cmpq $0x2, %rax
leaq 0x358ad(%rip), %rax # 0x4d0dd
cmovneq %rdx, %rax
retq
leaq 0x43226(%rip), %rax # 0x5aa62
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_get_max_frag_len | size_t mbedtls_ssl_get_max_frag_len( const mbedtls_ssl_context *ssl )
{
size_t max_len;
/*
* Assume mfl_code is correct since it was checked when set
*/
max_len = mfl_code_to_length[ssl->conf->mfl_code];
/*
* Check if a smaller max length was negotiated
*/
if( ssl->session_out != NULL &&
mfl_code_to_length[ssl->session_out->mfl_code] < max_len )
{
max_len = mfl_code_to_length[ssl->session_out->mfl_code];
}
return max_len;
} | movq (%rdi), %rax
movq 0x48(%rdi), %rcx
movl 0x174(%rax), %eax
shrl $0x5, %eax
andl $0x1c, %eax
leaq 0x34b8e(%rip), %rdx # 0x4c470
movl (%rax,%rdx), %eax
testq %rcx, %rcx
je 0x178f9
movzbl 0x8c(%rcx), %ecx
movl (%rdx,%rcx,4), %ecx
cmpl %eax, %ecx
cmovbl %ecx, %eax
movl %eax, %eax
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_get_session | int mbedtls_ssl_get_session( const mbedtls_ssl_context *ssl, mbedtls_ssl_session *dst )
{
if( ssl == NULL ||
dst == NULL ||
ssl->session == NULL ||
ssl->conf->endpoint != MBEDTLS_SSL_IS_CLIENT )
{
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
return( ssl_session_copy( dst, ssl->session ) );
} | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x17942
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x17942
movq (%rdi), %rcx
testb $0x1, 0x174(%rcx)
jne 0x17942
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x1714a
movl $0xffff8f00, %eax # imm = 0xFFFF8F00
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_handshake | int mbedtls_ssl_handshake( mbedtls_ssl_context *ssl )
{
int ret = 0;
if( ssl == NULL || ssl->conf == NULL )
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> handshake" ) );
while( ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER )
{
ret = mbedtls_ssl_handshake_step( ssl );
if( ret != 0 )
break;
}
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= handshake" ) );
return( ret );
} | pushq %r14
pushq %rbx
pushq %rax
movl $0xffff8f00, %ebx # imm = 0xFFFF8F00
testq %rdi, %rdi
je 0x179f8
movq %rdi, %r14
cmpq $0x0, (%rdi)
je 0x179f8
leaq 0x34b18(%rip), %rdx # 0x4c4bc
leaq 0x35763(%rip), %r8 # 0x4d10e
xorl %ebx, %ebx
movq %r14, %rdi
movl $0x2, %esi
movl $0x18c0, %ecx # imm = 0x18C0
xorl %eax, %eax
callq 0xf997
cmpl $0x10, 0x8(%r14)
je 0x179d6
movq %r14, %rdi
callq 0x17948
testl %eax, %eax
je 0x179c1
movl %eax, %ebx
leaq 0x34adf(%rip), %rdx # 0x4c4bc
leaq 0x35737(%rip), %r8 # 0x4d11b
movq %r14, %rdi
movl $0x2, %esi
movl $0x18ca, %ecx # imm = 0x18CA
xorl %eax, %eax
callq 0xf997
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
ssl_start_renegotiation | static int ssl_start_renegotiation( mbedtls_ssl_context *ssl )
{
int ret;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> renegotiate" ) );
if( ( ret = ssl_handshake_init( ssl ) ) != 0 )
return( ret );
/* RFC 6347 4.2.2: "[...] the HelloRequest will have message_seq = 0 and
* the ServerHello will have message_seq = 1" */
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_PENDING )
{
if( ssl->conf->endpoint == MBEDTLS_SSL_IS_SERVER )
ssl->handshake->out_msg_seq = 1;
else
ssl->handshake->in_msg_seq = 1;
}
#endif
ssl->state = MBEDTLS_SSL_HELLO_REQUEST;
ssl->renego_status = MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS;
if( ( ret = mbedtls_ssl_handshake( ssl ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_handshake", ret );
return( ret );
}
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= renegotiate" ) );
return( 0 );
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x34938(%rip), %rdx # 0x4c4bc
leaq 0x3646a(%rip), %r8 # 0x4dff5
movl $0x2, %esi
movl $0x18f7, %ecx # imm = 0x18F7
xorl %eax, %eax
callq 0xf997
movq %rbx, %rdi
callq 0x16c7a
movl %eax, %ebp
testl %eax, %eax
jne 0x17c44
movq (%rbx), %rax
movl 0x174(%rax), %eax
testb $0x2, %al
je 0x17bdf
cmpl $0x3, 0xc(%rbx)
jne 0x17bdf
movq 0x60(%rbx), %rcx
testb $0x1, %al
jne 0x17bd5
movl $0x1, 0x3ac(%rcx)
jmp 0x17bdf
movl $0x1, 0x3a8(%rcx)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x17986
testl %eax, %eax
je 0x17c20
movl %eax, %ebp
leaq 0x348ba(%rip), %rdx # 0x4c4bc
leaq 0x35537(%rip), %r8 # 0x4d140
movq %rbx, %rdi
movl $0x1, %esi
movl $0x190e, %ecx # imm = 0x190E
movl %eax, %r9d
callq 0xfa82
jmp 0x17c44
leaq 0x34895(%rip), %rdx # 0x4c4bc
leaq 0x363d6(%rip), %r8 # 0x4e004
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x2, %esi
movl $0x1912, %ecx # imm = 0x1912
xorl %eax, %eax
callq 0xf997
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_read | int mbedtls_ssl_read( mbedtls_ssl_context *ssl, unsigned char *buf, size_t len )
{
int ret, record_read = 0;
size_t n;
if( ssl == NULL || ssl->conf == NULL )
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> read" ) );
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
if( ( ret = mbedtls_ssl_flush_output( ssl ) ) != 0 )
return( ret );
if( ssl->handshake != NULL &&
ssl->handshake->retransmit_state == MBEDTLS_SSL_RETRANS_SENDING )
{
if( ( ret = mbedtls_ssl_resend( ssl ) ) != 0 )
return( ret );
}
}
#endif
#if defined(MBEDTLS_SSL_RENEGOTIATION)
if( ( ret = ssl_check_ctr_renegotiate( ssl ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "ssl_check_ctr_renegotiate", ret );
return( ret );
}
#endif
if( ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER )
{
ret = mbedtls_ssl_handshake( ssl );
if( ret == MBEDTLS_ERR_SSL_WAITING_SERVER_HELLO_RENEGO )
{
record_read = 1;
}
else if( ret != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_handshake", ret );
return( ret );
}
}
if( ssl->in_offt == NULL )
{
/* Start timer if not already running */
if( ssl->f_get_timer != NULL &&
ssl->f_get_timer( ssl->p_timer ) == -1 )
{
ssl_set_timer( ssl, ssl->conf->read_timeout );
}
if( ! record_read )
{
if( ( ret = mbedtls_ssl_read_record( ssl ) ) != 0 )
{
if( ret == MBEDTLS_ERR_SSL_CONN_EOF )
return( 0 );
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_read_record", ret );
return( ret );
}
}
if( ssl->in_msglen == 0 &&
ssl->in_msgtype == MBEDTLS_SSL_MSG_APPLICATION_DATA )
{
/*
* OpenSSL sends empty messages to randomize the IV
*/
if( ( ret = mbedtls_ssl_read_record( ssl ) ) != 0 )
{
if( ret == MBEDTLS_ERR_SSL_CONN_EOF )
return( 0 );
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_read_record", ret );
return( ret );
}
}
#if defined(MBEDTLS_SSL_RENEGOTIATION)
if( ssl->in_msgtype == MBEDTLS_SSL_MSG_HANDSHAKE )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "received handshake message" ) );
#if defined(MBEDTLS_SSL_CLI_C)
if( ssl->conf->endpoint == MBEDTLS_SSL_IS_CLIENT &&
( ssl->in_msg[0] != MBEDTLS_SSL_HS_HELLO_REQUEST ||
ssl->in_hslen != mbedtls_ssl_hs_hdr_len( ssl ) ) )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "handshake received (not HelloRequest)" ) );
/* With DTLS, drop the packet (probably from last handshake) */
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
return( MBEDTLS_ERR_SSL_WANT_READ );
#endif
return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
}
if( ssl->conf->endpoint == MBEDTLS_SSL_IS_SERVER &&
ssl->in_msg[0] != MBEDTLS_SSL_HS_CLIENT_HELLO )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "handshake received (not ClientHello)" ) );
/* With DTLS, drop the packet (probably from last handshake) */
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
return( MBEDTLS_ERR_SSL_WANT_READ );
#endif
return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
}
#endif
if( ssl->conf->disable_renegotiation == MBEDTLS_SSL_RENEGOTIATION_DISABLED ||
( ssl->secure_renegotiation == MBEDTLS_SSL_LEGACY_RENEGOTIATION &&
ssl->conf->allow_legacy_renegotiation ==
MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION ) )
{
MBEDTLS_SSL_DEBUG_MSG( 3, ( "refusing renegotiation, sending alert" ) );
#if defined(MBEDTLS_SSL_PROTO_SSL3)
if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 )
{
/*
* SSLv3 does not have a "no_renegotiation" alert
*/
if( ( ret = mbedtls_ssl_send_fatal_handshake_failure( ssl ) ) != 0 )
return( ret );
}
else
#endif /* MBEDTLS_SSL_PROTO_SSL3 */
#if defined(MBEDTLS_SSL_PROTO_TLS1) || defined(MBEDTLS_SSL_PROTO_TLS1_1) || \
defined(MBEDTLS_SSL_PROTO_TLS1_2)
if( ssl->minor_ver >= MBEDTLS_SSL_MINOR_VERSION_1 )
{
if( ( ret = mbedtls_ssl_send_alert_message( ssl,
MBEDTLS_SSL_ALERT_LEVEL_WARNING,
MBEDTLS_SSL_ALERT_MSG_NO_RENEGOTIATION ) ) != 0 )
{
return( ret );
}
}
else
#endif /* MBEDTLS_SSL_PROTO_TLS1 || MBEDTLS_SSL_PROTO_TLS1_1 ||
MBEDTLS_SSL_PROTO_TLS1_2 */
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
}
else
{
/* DTLS clients need to know renego is server-initiated */
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
ssl->conf->endpoint == MBEDTLS_SSL_IS_CLIENT )
{
ssl->renego_status = MBEDTLS_SSL_RENEGOTIATION_PENDING;
}
#endif
ret = ssl_start_renegotiation( ssl );
if( ret == MBEDTLS_ERR_SSL_WAITING_SERVER_HELLO_RENEGO )
{
record_read = 1;
}
else if( ret != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "ssl_start_renegotiation", ret );
return( ret );
}
}
/* If a non-handshake record was read during renego, fallthrough,
* else tell the user they should call mbedtls_ssl_read() again */
if( ! record_read )
return( MBEDTLS_ERR_SSL_WANT_READ );
}
else if( ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_PENDING )
{
if( ssl->conf->renego_max_records >= 0 )
{
if( ++ssl->renego_records_seen > ssl->conf->renego_max_records )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "renegotiation requested, "
"but not honored by client" ) );
return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
}
}
}
#endif /* MBEDTLS_SSL_RENEGOTIATION */
/* Fatal and closure alerts handled by mbedtls_ssl_read_record() */
if( ssl->in_msgtype == MBEDTLS_SSL_MSG_ALERT )
{
MBEDTLS_SSL_DEBUG_MSG( 2, ( "ignoring non-fatal non-closure alert" ) );
return( MBEDTLS_ERR_SSL_WANT_READ );
}
if( ssl->in_msgtype != MBEDTLS_SSL_MSG_APPLICATION_DATA )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad application data message" ) );
return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
}
ssl->in_offt = ssl->in_msg;
/* We're going to return something now, cancel timer,
* except if handshake (renegotiation) is in progress */
if( ssl->state == MBEDTLS_SSL_HANDSHAKE_OVER )
ssl_set_timer( ssl, 0 );
#if defined(MBEDTLS_SSL_PROTO_DTLS)
/* If we requested renego but received AppData, resend HelloRequest.
* Do it now, after setting in_offt, to avoid taking this branch
* again if ssl_write_hello_request() returns WANT_WRITE */
#if defined(MBEDTLS_SSL_SRV_C) && defined(MBEDTLS_SSL_RENEGOTIATION)
if( ssl->conf->endpoint == MBEDTLS_SSL_IS_SERVER &&
ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_PENDING )
{
if( ( ret = ssl_resend_hello_request( ssl ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "ssl_resend_hello_request", ret );
return( ret );
}
}
#endif /* MBEDTLS_SSL_SRV_C && MBEDTLS_SSL_RENEGOTIATION */
#endif
}
n = ( len < ssl->in_msglen )
? len : ssl->in_msglen;
memcpy( buf, ssl->in_offt, n );
ssl->in_msglen -= n;
if( ssl->in_msglen == 0 )
/* all bytes consumed */
ssl->in_offt = NULL;
else
/* more data available */
ssl->in_offt += n;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= read" ) );
return( (int) n );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0xffff8f00, %ebp # imm = 0xFFFF8F00
testq %rdi, %rdi
je 0x17ece
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x17ece
movq %rdx, %r14
movq %rsi, %r15
leaq 0x3483f(%rip), %rdx # 0x4c4bc
leaq 0x354d2(%rip), %r8 # 0x4d156
movq %rbx, %rdi
movl $0x2, %esi
movl $0x197a, %ecx # imm = 0x197A
xorl %eax, %eax
callq 0xf997
movq (%rbx), %rax
testb $0x2, 0x174(%rax)
jne 0x17cda
movq %rbx, %rdi
callq 0x18171
testl %eax, %eax
je 0x17ced
movl %eax, %ebp
leaq 0x34803(%rip), %rdx # 0x4c4bc
leaq 0x3549e(%rip), %r8 # 0x4d15e
movq %rbx, %rdi
movl $0x1, %esi
movl $0x198e, %ecx # imm = 0x198E
movl %ebp, %r9d
callq 0xfa82
jmp 0x17ece
movq %rbx, %rdi
callq 0x1287b
testl %eax, %eax
je 0x17d28
movl %eax, %ebp
jmp 0x17ece
movb $0x1, %r12b
cmpl $0x10, 0x8(%rbx)
je 0x17d56
movq %rbx, %rdi
callq 0x17986
cmpl $0xffff9500, %eax # imm = 0xFFFF9500
je 0x17d53
movl %eax, %ebp
testl %eax, %eax
je 0x17d56
leaq 0x347aa(%rip), %rdx # 0x4c4bc
leaq 0x35427(%rip), %r8 # 0x4d140
movq %rbx, %rdi
movl $0x1, %esi
movl $0x199c, %ecx # imm = 0x199C
jmp 0x17ccd
movq 0x60(%rbx), %rax
testq %rax, %rax
je 0x17ca4
cmpb $0x1, 0x3cc(%rax)
jne 0x17ca4
movq %rbx, %rdi
callq 0x12663
testl %eax, %eax
jne 0x17ce6
jmp 0x17ca4
xorl %r12d, %r12d
cmpq $0x0, 0xd0(%rbx)
je 0x17d94
movq 0xd0(%rbx), %rsi
movq 0xe0(%rbx), %rax
cmpq %r14, %rax
cmovbq %rax, %r14
movq %r15, %rdi
movq %r14, %rdx
callq 0xf240
subq %r14, 0xe0(%rbx)
jne 0x17e98
xorl %eax, %eax
jmp 0x17ea2
movq 0x98(%rbx), %rax
testq %rax, %rax
je 0x17dbf
movq 0x88(%rbx), %rdi
callq *%rax
cmpl $-0x1, %eax
jne 0x17dbf
movq (%rbx), %rax
movl 0x150(%rax), %esi
movq %rbx, %rdi
callq 0x125b5
testb %r12b, %r12b
je 0x17de1
movq %rbx, %rdi
callq 0x141f2
cmpl $0xffff8d80, %eax # imm = 0xFFFF8D80
je 0x17f25
movl %eax, %ebp
testl %eax, %eax
jne 0x17f29
cmpq $0x0, 0xe0(%rbx)
jne 0x17e11
cmpl $0x17, 0xd8(%rbx)
jne 0x17e11
movq %rbx, %rdi
callq 0x141f2
cmpl $0xffff8d80, %eax # imm = 0xFFFF8D80
je 0x17f25
movl %eax, %ebp
testl %eax, %eax
jne 0x18105
cmpl $0x16, 0xd8(%rbx)
jne 0x17ed9
leaq 0x34697(%rip), %rdx # 0x4c4bc
leaq 0x3534c(%rip), %r8 # 0x4d178
movq %rbx, %rdi
movl $0x1, %esi
movl $0x19c9, %ecx # imm = 0x19C9
xorl %eax, %eax
callq 0xf997
movq (%rbx), %rax
movq 0xc8(%rbx), %rcx
movl 0x174(%rax), %eax
movb (%rcx), %cl
testb $0x1, %al
jne 0x17f49
testb %cl, %cl
jne 0x17e78
movl %eax, %ecx
andl $0x2, %ecx
leaq 0x4(,%rcx,4), %rcx
cmpq %rcx, 0x110(%rbx)
je 0x17f4e
leaq 0x3463d(%rip), %rdx # 0x4c4bc
leaq 0x3530d(%rip), %r8 # 0x4d193
movq %rbx, %rdi
movl $0x1, %esi
movl $0x19d0, %ecx # imm = 0x19D0
jmp 0x17fbf
movq 0xd0(%rbx), %rax
addq %r14, %rax
movq %rax, 0xd0(%rbx)
leaq 0x3460c(%rip), %rdx # 0x4c4bc
leaq 0x353c2(%rip), %r8 # 0x4d279
movq %rbx, %rdi
movl $0x2, %esi
movl $0x1a6a, %ecx # imm = 0x1A6A
xorl %eax, %eax
callq 0xf997
movl %r14d, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x3, 0xc(%rbx)
jne 0x18036
movq (%rbx), %rax
movl 0x15c(%rax), %eax
testl %eax, %eax
js 0x18036
movl 0x10(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x10(%rbx)
cmpl %eax, %ecx
jl 0x18036
leaq 0x345b0(%rip), %rdx # 0x4c4bc
leaq 0x352f1(%rip), %r8 # 0x4d204
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1a30, %ecx # imm = 0x1A30
jmp 0x180f4
xorl %ebp, %ebp
jmp 0x17ece
leaq 0x3458c(%rip), %rdx # 0x4c4bc
leaq 0x34e7e(%rip), %r8 # 0x4cdb5
movq %rbx, %rdi
movl $0x1, %esi
movl $0x19b1, %ecx # imm = 0x19B1
jmp 0x17ccd
cmpb $0x1, %cl
jne 0x17fa4
btl $0xe, %eax
jae 0x17fe2
movl %eax, %ecx
andl $0x30, %ecx
orl 0x190(%rbx), %ecx
je 0x17fe2
andl $0x3, %eax
cmpl $0x2, %eax
jne 0x17f74
movl $0x3, 0xc(%rbx)
movq %rbx, %rdi
callq 0x17b77
cmpl $0xffff9500, %eax # imm = 0xFFFF9500
je 0x18036
movl %eax, %ebp
testl %eax, %eax
jne 0x18151
movl $0xffff9700, %ebp # imm = 0xFFFF9700
testb %r12b, %r12b
jne 0x17ece
jmp 0x18036
leaq 0x34511(%rip), %rdx # 0x4c4bc
leaq 0x35207(%rip), %r8 # 0x4d1b9
movq %rbx, %rdi
movl $0x1, %esi
movl $0x19dd, %ecx # imm = 0x19DD
xorl %eax, %eax
callq 0xf997
movq (%rbx), %rax
testb $0x2, 0x174(%rax)
movl $0xffff8900, %eax # imm = 0xFFFF8900
movl $0xffff9700, %ebp # imm = 0xFFFF9700
cmovel %eax, %ebp
jmp 0x17ece
leaq 0x344d3(%rip), %rdx # 0x4c4bc
leaq 0x351ee(%rip), %r8 # 0x4d1de
movq %rbx, %rdi
movl $0x3, %esi
movl $0x19ed, %ecx # imm = 0x19ED
xorl %eax, %eax
callq 0xf997
cmpl $0x0, 0x18(%rbx)
jle 0x18125
movq %rbx, %rdi
movl $0x1, %esi
movl $0x64, %edx
callq 0x15727
testl %eax, %eax
setne %cl
movl $0xffff9700, %ebp # imm = 0xFFFF9700
cmovnel %eax, %ebp
orb %cl, %r12b
jne 0x17ece
movl 0xd8(%rbx), %eax
cmpl $0x17, %eax
je 0x18076
leaq 0x34474(%rip), %rdx # 0x4c4bc
cmpl $0x15, %eax
jne 0x180e0
leaq 0x351df(%rip), %r8 # 0x4d237
movq %rbx, %rdi
movl $0x2, %esi
movl $0x1a3a, %ecx # imm = 0x1A3A
xorl %eax, %eax
callq 0xf997
movl $0xffff9700, %ebp # imm = 0xFFFF9700
jmp 0x17ece
movq 0xc8(%rbx), %rax
movq %rax, 0xd0(%rbx)
cmpl $0x10, 0x8(%rbx)
jne 0x18094
movq %rbx, %rdi
xorl %esi, %esi
callq 0x125b5
movq (%rbx), %rax
testb $0x1, 0x174(%rax)
je 0x17d60
cmpl $0x3, 0xc(%rbx)
jne 0x17d60
movq %rbx, %rdi
callq 0x12812
testl %eax, %eax
je 0x17d60
movl %eax, %ebp
leaq 0x343f5(%rip), %rdx # 0x4c4bc
leaq 0x34746(%rip), %r8 # 0x4c814
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1a55, %ecx # imm = 0x1A55
jmp 0x17ccd
leaq 0x35175(%rip), %r8 # 0x4d25c
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1a40, %ecx # imm = 0x1A40
xorl %eax, %eax
callq 0xf997
movl $0xffff8900, %ebp # imm = 0xFFFF8900
jmp 0x17ece
leaq 0x343b0(%rip), %rdx # 0x4c4bc
leaq 0x34ca2(%rip), %r8 # 0x4cdb5
movq %rbx, %rdi
movl $0x1, %esi
movl $0x19c1, %ecx # imm = 0x19C1
jmp 0x17ccd
leaq 0x34390(%rip), %rdx # 0x4c4bc
leaq 0x34442(%rip), %r8 # 0x4c575
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1a09, %ecx # imm = 0x1A09
xorl %eax, %eax
callq 0xf997
movl $0xffff9400, %ebp # imm = 0xFFFF9400
jmp 0x17ece
leaq 0x34364(%rip), %rdx # 0x4c4bc
leaq 0x34fc9(%rip), %r8 # 0x4d128
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1a1e, %ecx # imm = 0x1A1E
jmp 0x17ccd
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_transform_free | void mbedtls_ssl_transform_free( mbedtls_ssl_transform *transform )
{
if( transform == NULL )
return;
#if defined(MBEDTLS_ZLIB_SUPPORT)
deflateEnd( &transform->ctx_deflate );
inflateEnd( &transform->ctx_inflate );
#endif
mbedtls_cipher_free( &transform->cipher_ctx_enc );
mbedtls_cipher_free( &transform->cipher_ctx_dec );
mbedtls_md_free( &transform->md_ctx_enc );
mbedtls_md_free( &transform->md_ctx_dec );
mbedtls_zeroize( transform, sizeof( mbedtls_ssl_transform ) );
} | testq %rdi, %rdi
je 0x1849a
pushq %rbx
movq %rdi, %rbx
addq $0x80, %rdi
callq 0x2a11c
leaq 0xd8(%rbx), %rdi
callq 0x2a11c
leaq 0x50(%rbx), %rdi
callq 0x38d03
leaq 0x68(%rbx), %rdi
callq 0x38d03
xorl %eax, %eax
movb $0x0, (%rbx,%rax)
incq %rax
cmpq $0x130, %rax # imm = 0x130
jne 0x1848a
popq %rbx
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
ssl_cookie_write_dummy | static int ssl_cookie_write_dummy( void *ctx,
unsigned char **p, unsigned char *end,
const unsigned char *cli_id, size_t cli_id_len )
{
((void) ctx);
((void) p);
((void) end);
((void) cli_id);
((void) cli_id_len);
return( MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE );
} | movl $0xffff8f80, %eax # imm = 0xFFFF8F80
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_config_free | void mbedtls_ssl_config_free( mbedtls_ssl_config *conf )
{
#if defined(MBEDTLS_DHM_C)
mbedtls_mpi_free( &conf->dhm_P );
mbedtls_mpi_free( &conf->dhm_G );
#endif
#if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
if( conf->psk != NULL )
{
mbedtls_zeroize( conf->psk, conf->psk_len );
mbedtls_zeroize( conf->psk_identity, conf->psk_identity_len );
mbedtls_free( conf->psk );
mbedtls_free( conf->psk_identity );
conf->psk_len = 0;
conf->psk_identity_len = 0;
}
#endif
#if defined(MBEDTLS_X509_CRT_PARSE_C)
ssl_key_cert_free( conf->key_cert );
#endif
mbedtls_zeroize( conf, sizeof( mbedtls_ssl_config ) );
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0xf8, %rdi
callq 0x2590b
leaq 0x110(%rbx), %rdi
callq 0x2590b
movq 0x128(%rbx), %rax
testq %rax, %rax
je 0x1890a
movq 0x130(%rbx), %rcx
testq %rcx, %rcx
je 0x188c1
xorl %edx, %edx
movb $0x0, (%rax,%rdx)
incq %rdx
cmpq %rdx, %rcx
jne 0x188b5
movq 0x140(%rbx), %rax
testq %rax, %rax
je 0x188e2
movq 0x138(%rbx), %rcx
xorl %edx, %edx
movb $0x0, (%rcx,%rdx)
incq %rdx
cmpq %rdx, %rax
jne 0x188d6
movq 0x128(%rbx), %rdi
callq 0xf030
movq 0x138(%rbx), %rdi
callq 0xf030
xorl %eax, %eax
movq %rax, 0x130(%rbx)
movq %rax, 0x140(%rbx)
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x18927
movq 0x10(%rdi), %r14
callq 0xf030
movq %r14, %rdi
testq %r14, %r14
jne 0x18916
xorl %eax, %eax
movb $0x0, (%rbx,%rax)
incq %rax
cmpq $0x178, %rax # imm = 0x178
jne 0x18929
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_pk_alg_from_sig | mbedtls_pk_type_t mbedtls_ssl_pk_alg_from_sig( unsigned char sig )
{
switch( sig )
{
#if defined(MBEDTLS_RSA_C)
case MBEDTLS_SSL_SIG_RSA:
return( MBEDTLS_PK_RSA );
#endif
#if defined(MBEDTLS_ECDSA_C)
case MBEDTLS_SSL_SIG_ECDSA:
return( MBEDTLS_PK_ECDSA );
#endif
default:
return( MBEDTLS_PK_NONE );
}
} | xorl %eax, %eax
cmpl $0x3, %edi
sete %al
shll $0x2, %eax
cmpl $0x1, %edi
cmovel %edi, %eax
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_hash_from_md_alg | unsigned char mbedtls_ssl_hash_from_md_alg( int md )
{
switch( md )
{
#if defined(MBEDTLS_MD5_C)
case MBEDTLS_MD_MD5:
return( MBEDTLS_SSL_HASH_MD5 );
#endif
#if defined(MBEDTLS_SHA1_C)
case MBEDTLS_MD_SHA1:
return( MBEDTLS_SSL_HASH_SHA1 );
#endif
#if defined(MBEDTLS_SHA256_C)
case MBEDTLS_MD_SHA224:
return( MBEDTLS_SSL_HASH_SHA224 );
case MBEDTLS_MD_SHA256:
return( MBEDTLS_SSL_HASH_SHA256 );
#endif
#if defined(MBEDTLS_SHA512_C)
case MBEDTLS_MD_SHA384:
return( MBEDTLS_SSL_HASH_SHA384 );
case MBEDTLS_MD_SHA512:
return( MBEDTLS_SSL_HASH_SHA512 );
#endif
default:
return( MBEDTLS_SSL_HASH_NONE );
}
} | addl $-0x3, %edi
leal 0x1(%rdi), %eax
xorl %ecx, %ecx
cmpl $0x6, %edi
movzbl %al, %eax
cmovael %ecx, %eax
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_read_version | void mbedtls_ssl_read_version( int *major, int *minor, int transport,
const unsigned char ver[2] )
{
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
*major = 255 - ver[0] + 2;
*minor = 255 - ver[1] + 1;
if( *minor == MBEDTLS_SSL_MINOR_VERSION_1 )
++*minor; /* DTLS 1.0 stored as TLS 1.1 internally */
}
else
#else
((void) transport);
#endif
{
*major = ver[0];
*minor = ver[1];
}
} | movzbl (%rcx), %eax
cmpl $0x1, %edx
jne 0x18a03
notb %al
movzbl %al, %eax
addl $0x2, %eax
movl %eax, (%rdi)
movzbl 0x1(%rcx), %eax
movl $0xff, %ecx
movl %eax, %edx
xorl %ecx, %edx
incl %edx
cmpl %ecx, %eax
movl $0x2, %eax
cmovnel %edx, %eax
jmp 0x18a09
movl %eax, (%rdi)
movzbl 0x1(%rcx), %eax
movl %eax, (%rsi)
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
tls_prf_generic | static int tls_prf_generic( mbedtls_md_type_t md_type,
const unsigned char *secret, size_t slen,
const char *label,
const unsigned char *random, size_t rlen,
unsigned char *dstbuf, size_t dlen )
{
size_t nb;
size_t i, j, k, md_len;
unsigned char tmp[128];
unsigned char h_i[MBEDTLS_MD_MAX_SIZE];
const mbedtls_md_info_t *md_info;
mbedtls_md_context_t md_ctx;
int ret;
mbedtls_md_init( &md_ctx );
if( ( md_info = mbedtls_md_info_from_type( md_type ) ) == NULL )
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
md_len = mbedtls_md_get_size( md_info );
if( sizeof( tmp ) < md_len + strlen( label ) + rlen )
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
nb = strlen( label );
memcpy( tmp + md_len, label, nb );
memcpy( tmp + md_len + nb, random, rlen );
nb += rlen;
/*
* Compute P_<hash>(secret, label + random)[0..dlen]
*/
if ( ( ret = mbedtls_md_setup( &md_ctx, md_info, 1 ) ) != 0 )
return( ret );
mbedtls_md_hmac_starts( &md_ctx, secret, slen );
mbedtls_md_hmac_update( &md_ctx, tmp + md_len, nb );
mbedtls_md_hmac_finish( &md_ctx, tmp );
for( i = 0; i < dlen; i += md_len )
{
mbedtls_md_hmac_reset ( &md_ctx );
mbedtls_md_hmac_update( &md_ctx, tmp, md_len + nb );
mbedtls_md_hmac_finish( &md_ctx, h_i );
mbedtls_md_hmac_reset ( &md_ctx );
mbedtls_md_hmac_update( &md_ctx, tmp, md_len );
mbedtls_md_hmac_finish( &md_ctx, tmp );
k = ( i + md_len > dlen ) ? dlen % md_len : md_len;
for( j = 0; j < k; j++ )
dstbuf[i + j] = h_i[j];
}
mbedtls_md_free( &md_ctx );
mbedtls_zeroize( tmp, sizeof( tmp ) );
mbedtls_zeroize( h_i, sizeof( h_i ) );
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %r9, %r15
movq %r8, 0x18(%rsp)
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, %r12
movl %edi, %ebx
leaq 0x28(%rsp), %rdi
callq 0x38cf4
movl %ebx, %edi
callq 0x38cdb
testq %rax, %rax
je 0x18c15
movq %rax, %r13
movq %r12, 0x10(%rsp)
movq %rax, %rdi
callq 0x39265
movzbl %al, %ebx
movq %rbp, %rdi
callq 0xf100
movq %rax, %r12
addq %r15, %rax
movq %rax, 0x8(%rsp)
leaq (%rax,%rbx), %rcx
movl $0xffff8f00, %eax # imm = 0xFFFF8F00
movq %rcx, 0x20(%rsp)
cmpq $0x80, %rcx
ja 0x18c1a
leaq (%rsp,%rbx), %rdi
addq $0x80, %rdi
movq %rbp, %rsi
movq %rdi, %rbp
movq %r12, %rdx
callq 0xf240
addq %rbp, %r12
movq %r12, %rdi
movq 0x18(%rsp), %rsi
movq %r15, %rdx
callq 0xf240
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x38da1
testl %eax, %eax
jne 0x18c1a
movq 0x148(%rsp), %r15
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x38fa0
movq %r12, %rdi
movq %rbp, %rsi
movq 0x8(%rsp), %rdx
callq 0x3909b
leaq 0x80(%rsp), %rsi
movq %r12, %rdi
callq 0x390c3
testq %r15, %r15
je 0x18be2
xorl %ebp, %ebp
leaq 0x28(%rsp), %r12
leaq 0x80(%rsp), %r13
movq %rbp, %r14
movq %r12, %rdi
callq 0x3914a
movq %r12, %rdi
movq %r13, %rsi
movq 0x20(%rsp), %rdx
callq 0x3909b
movq %r12, %rdi
leaq 0x40(%rsp), %rsi
callq 0x390c3
movq %r12, %rdi
callq 0x3914a
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x3909b
movq %r12, %rdi
movq %r13, %rsi
callq 0x390c3
addq %rbx, %rbp
movq %rbx, %rdx
cmpq %r15, %rbp
jbe 0x18bc3
movq %r15, %rax
xorl %edx, %edx
divq %rbx
testq %rdx, %rdx
je 0x18bdd
addq 0x140(%rsp), %r14
movq %r14, %rdi
leaq 0x40(%rsp), %rsi
callq 0xf240
cmpq %r15, %rbp
jb 0x18b67
leaq 0x28(%rsp), %rdi
callq 0x38d03
xorl %eax, %eax
movb $0x0, 0x80(%rsp,%rax)
incq %rax
cmpq $0x80, %rax
jne 0x18bee
xorl %eax, %eax
xorl %ecx, %ecx
movb $0x0, 0x40(%rsp,%rcx)
incq %rcx
cmpq $0x40, %rcx
jne 0x18c05
jmp 0x18c1a
movl $0xffff9400, %eax # imm = 0xFFFF9400
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
ssl_update_checksum_start | static void ssl_update_checksum_start( mbedtls_ssl_context *ssl,
const unsigned char *buf, size_t len )
{
#if defined(MBEDTLS_SSL_PROTO_SSL3) || defined(MBEDTLS_SSL_PROTO_TLS1) || \
defined(MBEDTLS_SSL_PROTO_TLS1_1)
mbedtls_md5_update( &ssl->handshake->fin_md5 , buf, len );
mbedtls_sha1_update( &ssl->handshake->fin_sha1, buf, len );
#endif
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
#if defined(MBEDTLS_SHA256_C)
mbedtls_sha256_update( &ssl->handshake->fin_sha256, buf, len );
#endif
#if defined(MBEDTLS_SHA512_C)
mbedtls_sha512_update( &ssl->handshake->fin_sha512, buf, len );
#endif
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x3f8, %edi # imm = 0x3F8
addq 0x60(%r15), %rdi
callq 0x39a96
movl $0x450, %edi # imm = 0x450
addq 0x60(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x41d8b
movl $0x4ac, %edi # imm = 0x4AC
addq 0x60(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x42c07
movl $0x518, %edi # imm = 0x518
addq 0x60(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x4364b
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_list_ciphersuites | const int *mbedtls_ssl_list_ciphersuites( void )
{
/*
* On initial call filter out all ciphersuites not supported by current
* build based on presence in the ciphersuite_definitions.
*/
if( supported_init == 0 )
{
const int *p;
int *q;
for( p = ciphersuite_preference, q = supported_ciphersuites;
*p != 0 && q < supported_ciphersuites + MAX_CIPHERSUITES - 1;
p++ )
{
#if defined(MBEDTLS_REMOVE_ARC4_CIPHERSUITES)
const mbedtls_ssl_ciphersuite_t *cs_info;
if( ( cs_info = mbedtls_ssl_ciphersuite_from_id( *p ) ) != NULL &&
cs_info->cipher != MBEDTLS_CIPHER_ARC4_128 )
#else
if( mbedtls_ssl_ciphersuite_from_id( *p ) != NULL )
#endif
*(q++) = *p;
}
*q = 0;
supported_init = 1;
}
return( supported_ciphersuites );
} | cmpb $0x0, 0x592ad(%rip) # 0x722c0
jne 0x19084
leaq 0x35074(%rip), %rax # 0x4e090
leaq 0x592ad(%rip), %rcx # 0x722d0
movl $0xc02c, %edi # imm = 0xC02C
xorl %edx, %edx
leaq 0x5510f(%rip), %rsi # 0x6e140
movq %rcx, %r8
movl $0xc009, %r10d # imm = 0xC009
movq %rsi, %r9
cmpl %edi, %r10d
je 0x19050
movl (%r9), %r10d
addq $0x30, %r9
testl %r10d, %r10d
jne 0x1903d
jmp 0x1905e
cmpl $0x2a, -0x20(%r9)
je 0x1905e
addq $0x4, %rdx
movl %edi, (%r8)
leaq (%rcx,%rdx), %r8
movl 0x4(%rax), %edi
testl %edi, %edi
je 0x19076
addq $0x4, %rax
cmpq $0x230, %rdx # imm = 0x230
jl 0x19034
movl $0x0, (%r8)
movb $0x1, 0x5923c(%rip) # 0x722c0
leaq 0x59245(%rip), %rax # 0x722d0
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_ciphersuites.c |
mbedtls_ssl_ciphersuite_from_string | const mbedtls_ssl_ciphersuite_t *mbedtls_ssl_ciphersuite_from_string(
const char *ciphersuite_name )
{
const mbedtls_ssl_ciphersuite_t *cur = ciphersuite_definitions;
if( NULL == ciphersuite_name )
return( NULL );
while( cur->id != 0 )
{
if( 0 == strcmp( cur->name, ciphersuite_name ) )
return( cur );
cur++;
}
return( NULL );
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x190d7
movq %rdi, %r14
leaq 0x55053(%rip), %rbx # 0x6e110
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0xf1e0
testl %eax, %eax
je 0x190d9
cmpl $0x0, 0x30(%rbx)
leaq 0x30(%rbx), %rbx
jne 0x190bd
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_ciphersuites.c |
mbedtls_ssl_handshake_client_step | int mbedtls_ssl_handshake_client_step( mbedtls_ssl_context *ssl )
{
int ret = 0;
if( ssl->state == MBEDTLS_SSL_HANDSHAKE_OVER || ssl->handshake == NULL )
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
MBEDTLS_SSL_DEBUG_MSG( 2, ( "client state: %d", ssl->state ) );
if( ( ret = mbedtls_ssl_flush_output( ssl ) ) != 0 )
return( ret );
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
ssl->handshake->retransmit_state == MBEDTLS_SSL_RETRANS_SENDING )
{
if( ( ret = mbedtls_ssl_resend( ssl ) ) != 0 )
return( ret );
}
#endif
/* Change state now, so that it is right in mbedtls_ssl_read_record(), used
* by DTLS for dropping out-of-sequence ChangeCipherSpec records */
#if defined(MBEDTLS_SSL_SESSION_TICKETS)
if( ssl->state == MBEDTLS_SSL_SERVER_CHANGE_CIPHER_SPEC &&
ssl->handshake->new_session_ticket != 0 )
{
ssl->state = MBEDTLS_SSL_SERVER_NEW_SESSION_TICKET;
}
#endif
switch( ssl->state )
{
case MBEDTLS_SSL_HELLO_REQUEST:
ssl->state = MBEDTLS_SSL_CLIENT_HELLO;
break;
/*
* ==> ClientHello
*/
case MBEDTLS_SSL_CLIENT_HELLO:
ret = ssl_write_client_hello( ssl );
break;
/*
* <== ServerHello
* Certificate
* ( ServerKeyExchange )
* ( CertificateRequest )
* ServerHelloDone
*/
case MBEDTLS_SSL_SERVER_HELLO:
ret = ssl_parse_server_hello( ssl );
break;
case MBEDTLS_SSL_SERVER_CERTIFICATE:
ret = mbedtls_ssl_parse_certificate( ssl );
break;
case MBEDTLS_SSL_SERVER_KEY_EXCHANGE:
ret = ssl_parse_server_key_exchange( ssl );
break;
case MBEDTLS_SSL_CERTIFICATE_REQUEST:
ret = ssl_parse_certificate_request( ssl );
break;
case MBEDTLS_SSL_SERVER_HELLO_DONE:
ret = ssl_parse_server_hello_done( ssl );
break;
/*
* ==> ( Certificate/Alert )
* ClientKeyExchange
* ( CertificateVerify )
* ChangeCipherSpec
* Finished
*/
case MBEDTLS_SSL_CLIENT_CERTIFICATE:
ret = mbedtls_ssl_write_certificate( ssl );
break;
case MBEDTLS_SSL_CLIENT_KEY_EXCHANGE:
ret = ssl_write_client_key_exchange( ssl );
break;
case MBEDTLS_SSL_CERTIFICATE_VERIFY:
ret = ssl_write_certificate_verify( ssl );
break;
case MBEDTLS_SSL_CLIENT_CHANGE_CIPHER_SPEC:
ret = mbedtls_ssl_write_change_cipher_spec( ssl );
break;
case MBEDTLS_SSL_CLIENT_FINISHED:
ret = mbedtls_ssl_write_finished( ssl );
break;
/*
* <== ( NewSessionTicket )
* ChangeCipherSpec
* Finished
*/
#if defined(MBEDTLS_SSL_SESSION_TICKETS)
case MBEDTLS_SSL_SERVER_NEW_SESSION_TICKET:
ret = ssl_parse_new_session_ticket( ssl );
break;
#endif
case MBEDTLS_SSL_SERVER_CHANGE_CIPHER_SPEC:
ret = mbedtls_ssl_parse_change_cipher_spec( ssl );
break;
case MBEDTLS_SSL_SERVER_FINISHED:
ret = mbedtls_ssl_parse_finished( ssl );
break;
case MBEDTLS_SSL_FLUSH_BUFFERS:
MBEDTLS_SSL_DEBUG_MSG( 2, ( "handshake: done" ) );
ssl->state = MBEDTLS_SSL_HANDSHAKE_WRAPUP;
break;
case MBEDTLS_SSL_HANDSHAKE_WRAPUP:
mbedtls_ssl_handshake_wrapup( ssl );
break;
default:
MBEDTLS_SSL_DEBUG_MSG( 1, ( "invalid state %d", ssl->state ) );
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
return( ret );
} | pushq %rbp
pushq %rbx
pushq %rax
movl 0x8(%rdi), %r9d
movl $0xffff8f00, %ebp # imm = 0xFFFF8F00
cmpl $0x10, %r9d
je 0x191d8
movq %rdi, %rbx
cmpq $0x0, 0x60(%rdi)
je 0x191d8
leaq 0x365a9(%rip), %rdx # 0x4f758
leaq 0x3660e(%rip), %r8 # 0x4f7c4
movq %rbx, %rdi
movl $0x2, %esi
movl $0xccf, %ecx # imm = 0xCCF
xorl %eax, %eax
callq 0xf997
movq %rbx, %rdi
callq 0x1287b
testl %eax, %eax
je 0x191e1
movl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq (%rbx), %rax
testb $0x2, 0x174(%rax)
je 0x19206
movq 0x60(%rbx), %rax
cmpb $0x1, 0x3cc(%rax)
jne 0x19206
movq %rbx, %rdi
callq 0x12663
testl %eax, %eax
jne 0x191d6
movl 0x8(%rbx), %r9d
cmpq $0x11, %r9
ja 0x192aa
leaq 0x364bd(%rip), %rax # 0x4f6d8
movslq (%rax,%r9,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0x1, 0x8(%rbx)
jmp 0x1935d
movq 0x60(%rbx), %rax
cmpl $0x0, 0xa8c(%rax)
je 0x19364
movl $0x11, 0x8(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1c77a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x162a4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1b122
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x19372
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1b94e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x16736
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x15b6a
leaq 0x364a7(%rip), %rdx # 0x4f758
leaq 0x3652d(%rip), %r8 # 0x4f7e5
movq %rbx, %rdi
movl $0x1, %esi
movl $0xd47, %ecx # imm = 0xD47
xorl %eax, %eax
callq 0xf997
jmp 0x191d8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1a319
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1bc6f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1589d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x16966
leaq 0x36448(%rip), %rdx # 0x4f758
leaq 0x364be(%rip), %r8 # 0x4f7d5
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x2, %esi
movl $0xd3e, %ecx # imm = 0xD3E
xorl %eax, %eax
callq 0xf997
movl $0xf, 0x8(%rbx)
jmp 0x191d8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1c403
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1bdaf
movq %rbx, %rdi
callq 0x165c8
xorl %ebp, %ebp
jmp 0x191d8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x16342
| /Dragonchang[P]https_client/mbedtls/library/ssl_cli.c |
ssl_parse_server_hello | static int ssl_parse_server_hello( mbedtls_ssl_context *ssl )
{
int ret, i;
size_t n;
size_t ext_len;
unsigned char *buf, *ext;
unsigned char comp;
#if defined(MBEDTLS_ZLIB_SUPPORT)
int accept_comp;
#endif
#if defined(MBEDTLS_SSL_RENEGOTIATION)
int renegotiation_info_seen = 0;
#endif
int handshake_failure = 0;
const mbedtls_ssl_ciphersuite_t *suite_info;
#if defined(MBEDTLS_DEBUG_C)
uint32_t t;
#endif
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse server hello" ) );
buf = ssl->in_msg;
if( ( ret = mbedtls_ssl_read_record( ssl ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_read_record", ret );
return( ret );
}
if( ssl->in_msgtype != MBEDTLS_SSL_MSG_HANDSHAKE )
{
#if defined(MBEDTLS_SSL_RENEGOTIATION)
if( ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS )
{
ssl->renego_records_seen++;
if( ssl->conf->renego_max_records >= 0 &&
ssl->renego_records_seen > ssl->conf->renego_max_records )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "renegotiation requested, "
"but not honored by server" ) );
return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
}
MBEDTLS_SSL_DEBUG_MSG( 1, ( "non-handshake message during renego" ) );
return( MBEDTLS_ERR_SSL_WAITING_SERVER_HELLO_RENEGO );
}
#endif /* MBEDTLS_SSL_RENEGOTIATION */
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
}
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
if( buf[0] == MBEDTLS_SSL_HS_HELLO_VERIFY_REQUEST )
{
MBEDTLS_SSL_DEBUG_MSG( 2, ( "received hello verify request" ) );
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse server hello" ) );
return( ssl_parse_hello_verify_request( ssl ) );
}
else
{
/* We made it through the verification process */
mbedtls_free( ssl->handshake->verify_cookie );
ssl->handshake->verify_cookie = NULL;
ssl->handshake->verify_cookie_len = 0;
}
}
#endif /* MBEDTLS_SSL_PROTO_DTLS */
if( ssl->in_hslen < 38 + mbedtls_ssl_hs_hdr_len( ssl ) ||
buf[0] != MBEDTLS_SSL_HS_SERVER_HELLO )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
}
/*
* 0 . 1 server_version
* 2 . 33 random (maybe including 4 bytes of Unix time)
* 34 . 34 session_id length = n
* 35 . 34+n session_id
* 35+n . 36+n cipher_suite
* 37+n . 37+n compression_method
*
* 38+n . 39+n extensions length (optional)
* 40+n . .. extensions
*/
buf += mbedtls_ssl_hs_hdr_len( ssl );
MBEDTLS_SSL_DEBUG_BUF( 3, "server hello, version", buf + 0, 2 );
mbedtls_ssl_read_version( &ssl->major_ver, &ssl->minor_ver,
ssl->conf->transport, buf + 0 );
if( ssl->major_ver < ssl->conf->min_major_ver ||
ssl->minor_ver < ssl->conf->min_minor_ver ||
ssl->major_ver > ssl->conf->max_major_ver ||
ssl->minor_ver > ssl->conf->max_minor_ver )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "server version out of bounds - "
" min: [%d:%d], server: [%d:%d], max: [%d:%d]",
ssl->conf->min_major_ver, ssl->conf->min_minor_ver,
ssl->major_ver, ssl->minor_ver,
ssl->conf->max_major_ver, ssl->conf->max_minor_ver ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_PROTOCOL_VERSION );
return( MBEDTLS_ERR_SSL_BAD_HS_PROTOCOL_VERSION );
}
#if defined(MBEDTLS_DEBUG_C)
t = ( (uint32_t) buf[2] << 24 )
| ( (uint32_t) buf[3] << 16 )
| ( (uint32_t) buf[4] << 8 )
| ( (uint32_t) buf[5] );
MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, current time: %lu", t ) );
#endif
memcpy( ssl->handshake->randbytes + 32, buf + 2, 32 );
n = buf[34];
MBEDTLS_SSL_DEBUG_BUF( 3, "server hello, random bytes", buf + 2, 32 );
if( n > 32 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
}
if( ssl->in_hslen > mbedtls_ssl_hs_hdr_len( ssl ) + 39 + n )
{
ext_len = ( ( buf[38 + n] << 8 )
| ( buf[39 + n] ) );
if( ( ext_len > 0 && ext_len < 4 ) ||
ssl->in_hslen != mbedtls_ssl_hs_hdr_len( ssl ) + 40 + n + ext_len )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
}
}
else if( ssl->in_hslen == mbedtls_ssl_hs_hdr_len( ssl ) + 38 + n )
{
ext_len = 0;
}
else
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
}
/* ciphersuite (used later) */
i = ( buf[35 + n] << 8 ) | buf[36 + n];
/*
* Read and check compression
*/
comp = buf[37 + n];
#if defined(MBEDTLS_ZLIB_SUPPORT)
/* See comments in ssl_write_client_hello() */
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
accept_comp = 0;
else
#endif
accept_comp = 1;
if( comp != MBEDTLS_SSL_COMPRESS_NULL &&
( comp != MBEDTLS_SSL_COMPRESS_DEFLATE || accept_comp == 0 ) )
#else /* MBEDTLS_ZLIB_SUPPORT */
if( comp != MBEDTLS_SSL_COMPRESS_NULL )
#endif/* MBEDTLS_ZLIB_SUPPORT */
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "server hello, bad compression: %d", comp ) );
return( MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE );
}
/*
* Initialize update checksum functions
*/
ssl->transform_negotiate->ciphersuite_info = mbedtls_ssl_ciphersuite_from_id( i );
if( ssl->transform_negotiate->ciphersuite_info == NULL )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "ciphersuite info for %04x not found", i ) );
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
mbedtls_ssl_optimize_checksum( ssl, ssl->transform_negotiate->ciphersuite_info );
MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, session id len.: %d", n ) );
MBEDTLS_SSL_DEBUG_BUF( 3, "server hello, session id", buf + 35, n );
/*
* Check if the session can be resumed
*/
if( ssl->handshake->resume == 0 || n == 0 ||
#if defined(MBEDTLS_SSL_RENEGOTIATION)
ssl->renego_status != MBEDTLS_SSL_INITIAL_HANDSHAKE ||
#endif
ssl->session_negotiate->ciphersuite != i ||
ssl->session_negotiate->compression != comp ||
ssl->session_negotiate->id_len != n ||
memcmp( ssl->session_negotiate->id, buf + 35, n ) != 0 )
{
ssl->state++;
ssl->handshake->resume = 0;
#if defined(MBEDTLS_HAVE_TIME)
ssl->session_negotiate->start = mbedtls_time( NULL );
#endif
ssl->session_negotiate->ciphersuite = i;
ssl->session_negotiate->compression = comp;
ssl->session_negotiate->id_len = n;
memcpy( ssl->session_negotiate->id, buf + 35, n );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x35427(%rip), %rdx # 0x4f758
leaq 0x3594f(%rip), %r8 # 0x4fc87
movl $0x2, %esi
movl $0x582, %ecx # imm = 0x582
xorl %eax, %eax
callq 0xf997
movq 0xc8(%rbx), %r12
movq %rbx, %rdi
callq 0x141f2
testl %eax, %eax
je 0x1a392
movl %eax, %ebp
leaq 0x353f3(%rip), %rdx # 0x4f758
leaq 0x32a49(%rip), %r8 # 0x4cdb5
movq %rbx, %rdi
movl $0x1, %esi
movl $0x588, %ecx # imm = 0x588
movl %ebp, %r9d
callq 0xfa82
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x16, 0xd8(%rbx)
jne 0x1a4e5
movq (%rbx), %rcx
movl $0x4, %eax
testb $0x2, 0x174(%rcx)
je 0x1a599
cmpb $0x3, (%r12)
jne 0x1a55b
leaq 0x35392(%rip), %r15 # 0x4f758
leaq 0x35940(%rip), %r8 # 0x4fd0d
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
movl $0x5a9, %ecx # imm = 0x5A9
xorl %eax, %eax
callq 0xf997
leaq 0x35940(%rip), %r8 # 0x4fd2b
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
movl $0x5aa, %ecx # imm = 0x5AA
xorl %eax, %eax
callq 0xf997
movq (%rbx), %rax
movq 0xc8(%rbx), %rcx
movl 0x174(%rax), %eax
andl $0x2, %eax
leaq (%rcx,%rax,4), %r14
addq $0x4, %r14
leaq 0x35cdd(%rip), %r8 # 0x50101
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
movl $0x52e, %ecx # imm = 0x52E
xorl %eax, %eax
callq 0xf997
movq $0x2, (%rsp)
leaq 0x35cd9(%rip), %r8 # 0x50123
movq %rbx, %rdi
movl $0x3, %esi
movq %r15, %rdx
movl $0x536, %ecx # imm = 0x536
movq %r14, %r9
callq 0xfb06
movq (%rbx), %rax
movl 0x174(%rax), %edx
shrl %edx
andl $0x1, %edx
leaq 0x44(%rsp), %r15
leaq 0x40(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rcx
callq 0x189d6
movl (%r15), %ecx
cmpl $0x3, %ecx
setl %dl
movl (%r12), %eax
cmpl $0x2, %eax
setl %sil
orb %dl, %sil
jne 0x1a4be
movq (%rbx), %rdx
movzbl 0x170(%rdx), %esi
cmpl %esi, %ecx
ja 0x1a4be
movzbl 0x171(%rdx), %ecx
cmpl %ecx, %eax
jbe 0x1a6fd
leaq 0x35293(%rip), %rdx # 0x4f758
leaq 0x35c53(%rip), %r8 # 0x5011f
movq %rbx, %rdi
movl $0x1, %esi
movl $0x543, %ecx # imm = 0x543
xorl %eax, %eax
callq 0xf997
jmp 0x1a6e1
cmpl $0x1, 0xc(%rbx)
jne 0x1a53b
movl 0x10(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x10(%rbx)
movq (%rbx), %rcx
movl 0x15c(%rcx), %ecx
testl %ecx, %ecx
sets %dl
cmpl %ecx, %eax
setl %al
orb %dl, %al
je 0x1a64a
leaq 0x35242(%rip), %rdx # 0x4f758
leaq 0x357b3(%rip), %r8 # 0x4fcd0
movq %rbx, %rdi
movl $0x1, %esi
movl $0x59b, %ecx # imm = 0x59B
xorl %eax, %eax
callq 0xf997
movl $0xffff9500, %ebp # imm = 0xFFFF9500
jmp 0x1a381
leaq 0x35216(%rip), %rdx # 0x4f758
leaq 0x357ab(%rip), %r8 # 0x4fcf4
movq %rbx, %rdi
movl $0x1, %esi
movl $0x5a0, %ecx # imm = 0x5A0
jmp 0x1a665
movq 0x60(%rbx), %rax
movq 0x3b0(%rax), %rdi
callq 0xf030
movq 0x60(%rbx), %rax
movq $0x0, 0x3b0(%rax)
movb $0x0, 0x3b8(%rax)
movq (%rbx), %rax
movb 0x174(%rax), %al
andb $0x2, %al
shrb %al
movzbl %al, %eax
leaq 0x4(,%rax,8), %rax
leaq 0x26(%rax), %rcx
cmpq %rcx, 0x110(%rbx)
jb 0x1a61e
cmpb $0x2, (%r12)
jne 0x1a61e
addq %rax, %r12
movq $0x2, (%rsp)
leaq 0x35199(%rip), %rdx # 0x4f758
leaq 0x3577b(%rip), %r8 # 0x4fd41
movq %rbx, %rdi
movl $0x3, %esi
movl $0x5cb, %ecx # imm = 0x5CB
movq %r12, %r9
callq 0xfb06
leaq 0x14(%rbx), %rdi
leaq 0x18(%rbx), %r14
movq (%rbx), %rax
movl 0x174(%rax), %edx
shrl %edx
andl $0x1, %edx
movq %r14, %rsi
movq %r12, %rcx
callq 0x189d6
movl 0x14(%rbx), %eax
movq (%rbx), %rcx
movzbl 0x172(%rcx), %r9d
cmpl %r9d, %eax
jge 0x1a676
movzbl 0x173(%rcx), %edx
movl (%r14), %esi
jmp 0x1a69e
leaq 0x35133(%rip), %rdx # 0x4f758
leaq 0x356c8(%rip), %r8 # 0x4fcf4
movq %rbx, %rdi
movl $0x1, %esi
movl $0x5ba, %ecx # imm = 0x5BA
xorl %eax, %eax
callq 0xf997
movl $0xffff8680, %ebp # imm = 0xFFFF8680
jmp 0x1a381
leaq 0x35107(%rip), %rdx # 0x4f758
leaq 0x35645(%rip), %r8 # 0x4fc9d
movq %rbx, %rdi
movl $0x1, %esi
movl $0x597, %ecx # imm = 0x597
xorl %eax, %eax
callq 0xf997
movl $0xffff8900, %ebp # imm = 0xFFFF8900
jmp 0x1a381
movl (%r14), %esi
movzbl 0x173(%rcx), %edx
cmpl %edx, %esi
jl 0x1a69e
movzbl 0x170(%rcx), %edi
cmpl %edi, %eax
ja 0x1a69e
movzbl 0x171(%rcx), %edi
cmpl %edi, %esi
jbe 0x1a807
movzbl 0x170(%rcx), %edi
movzbl 0x171(%rcx), %ecx
movl %ecx, 0x20(%rsp)
movl %edi, 0x18(%rsp)
movl %esi, 0x10(%rsp)
movl %eax, 0x8(%rsp)
movl %edx, (%rsp)
leaq 0x35092(%rip), %rdx # 0x4f758
leaq 0x3568a(%rip), %r8 # 0x4fd57
movq %rbx, %rdi
movl $0x1, %esi
movl $0x5d8, %ecx # imm = 0x5D8
xorl %eax, %eax
callq 0xf997
movq %rbx, %rdi
movl $0x2, %esi
movl $0x46, %edx
callq 0x15727
movl $0xffff9180, %ebp # imm = 0xFFFF9180
jmp 0x1a381
movb 0x2(%r14), %bpl
addq $0x3, %r14
movzbl %bpl, %r15d
movq %r15, (%rsp)
leaq 0x35044(%rip), %rdx # 0x4f758
leaq 0x3520b(%rip), %r8 # 0x4f926
movq %rbx, %rdi
movl $0x3, %esi
movl $0x54c, %ecx # imm = 0x54C
movq %r14, %r9
callq 0xfb06
movq 0xc8(%rbx), %rax
addq 0xe0(%rbx), %rax
subq %r14, %rax
cmpq %r15, %rax
jge 0x1a77f
leaq 0x3500b(%rip), %rdx # 0x4f758
leaq 0x359de(%rip), %r8 # 0x50132
movq %rbx, %rdi
movl $0x1, %esi
movl $0x551, %ecx # imm = 0x551
xorl %eax, %eax
callq 0xf997
movq %rbx, %rdi
movl $0x2, %esi
movl $0x32, %edx
callq 0x15727
jmp 0x1a640
movq 0x60(%rbx), %rax
movq 0x3b0(%rax), %rdi
callq 0xf030
movl $0x1, %edi
movq %r15, %rsi
callq 0xf1d0
movq 0x60(%rbx), %r12
movq %rax, 0x3b0(%r12)
testq %rax, %rax
je 0x1a8aa
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xf240
movb %bpl, 0x3b8(%r12)
movl $0x1, 0x8(%rbx)
movq %rbx, %rdi
callq 0x16584
movq %rbx, %rdi
callq 0x137db
leaq 0x34f73(%rip), %rdx # 0x4f758
leaq 0x35979(%rip), %r8 # 0x50165
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x2, %esi
movl $0x569, %ecx # imm = 0x569
xorl %eax, %eax
callq 0xf997
jmp 0x1a381
leaq 0x2(%r12), %r15
movl 0x2(%r12), %r9d
bswapl %r9d
leaq 0x34f3d(%rip), %rbp # 0x4f758
leaq 0x35581(%rip), %r8 # 0x4fda3
movq %rbx, %rdi
movl $0x3, %esi
movq %rbp, %rdx
movl $0x5e5, %ecx # imm = 0x5E5
xorl %eax, %eax
callq 0xf997
movq 0x60(%rbx), %rax
movups 0x2(%r12), %xmm0
movups 0x12(%r12), %xmm1
movups %xmm1, 0x648(%rax)
movups %xmm0, 0x638(%rax)
movzbl 0x22(%r12), %r13d
movq $0x20, (%rsp)
leaq 0x35557(%rip), %r8 # 0x4fdc3
movq %rbx, %rdi
movl $0x3, %esi
movq %rbp, %rdx
movl $0x5ec, %ecx # imm = 0x5EC
movq %r15, %r9
callq 0xfb06
cmpq $0x21, %r13
jb 0x1a8d9
leaq 0x34ec7(%rip), %rdx # 0x4f758
leaq 0x3545c(%rip), %r8 # 0x4fcf4
movq %rbx, %rdi
movl $0x1, %esi
movl $0x5f0, %ecx # imm = 0x5F0
jmp 0x1a639
leaq 0x34ea7(%rip), %rdx # 0x4f758
leaq 0x33118(%rip), %r8 # 0x4d9d0
movq %rbx, %rdi
movl $0x1, %esi
movl $0x55c, %ecx # imm = 0x55C
movl %r15d, %r9d
xorl %eax, %eax
callq 0xf997
movl $0xffff8100, %ebp # imm = 0xFFFF8100
jmp 0x1a381
movq (%rbx), %rcx
movq 0x110(%rbx), %rax
movb 0x174(%rcx), %cl
andb $0x2, %cl
shrb %cl
movzbl %cl, %edx
leaq 0x4(,%rdx,8), %rcx
leaq 0x2b(,%rdx,8), %rdx
addq %r13, %rdx
cmpq %rdx, %rax
jbe 0x1a950
movzwl 0x26(%r12,%r13), %edx
rolw $0x8, %dx
movzwl %dx, %r15d
leaq -0x1(%r15), %rdx
cmpq $0x3, %rdx
jb 0x1a930
addq %r13, %rcx
addq %r15, %rcx
addq $0x28, %rcx
cmpq %rcx, %rax
je 0x1a95f
leaq 0x34e21(%rip), %rdx # 0x4f758
leaq 0x353b6(%rip), %r8 # 0x4fcf4
movq %rbx, %rdi
movl $0x1, %esi
movl $0x5fc, %ecx # imm = 0x5FC
jmp 0x1a639
addq %r13, %rcx
addq $0x26, %rcx
cmpq %rcx, %rax
jne 0x1a996
xorl %r15d, %r15d
movzbl 0x25(%r12,%r13), %r9d
testl %r9d, %r9d
je 0x1a9b6
leaq 0x34de7(%rip), %rdx # 0x4f758
leaq 0x35466(%rip), %r8 # 0x4fdde
movq %rbx, %rdi
movl $0x1, %esi
movl $0x621, %ecx # imm = 0x621
xorl %eax, %eax
callq 0xf997
movl $0xffff8f80, %ebp # imm = 0xFFFF8F80
jmp 0x1a381
leaq 0x34dbb(%rip), %rdx # 0x4f758
leaq 0x35350(%rip), %r8 # 0x4fcf4
movq %rbx, %rdi
movl $0x1, %esi
movl $0x606, %ecx # imm = 0x606
jmp 0x1a639
movzwl 0x23(%r12,%r13), %eax
rolw $0x8, %ax
movzwl %ax, %edi
movl %edi, 0x38(%rsp)
callq 0x1908c
movq 0x80(%rbx), %rcx
movq %rax, (%rcx)
testq %rax, %rax
je 0x1ab8c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x164f8
leaq 0x34d67(%rip), %rbp # 0x4f758
leaq 0x3542c(%rip), %r8 # 0x4fe24
movq %rbx, %rdi
movl $0x3, %esi
movq %rbp, %rdx
movl $0x632, %ecx # imm = 0x632
movq %r13, %r9
xorl %eax, %eax
callq 0xf997
leaq 0x23(%r12), %r9
movq %r13, (%rsp)
leaq 0x35424(%rip), %r8 # 0x4fe46
movq %rbx, %rdi
movl $0x3, %esi
movq %rbp, %rdx
movl $0x633, %ecx # imm = 0x633
movq %r9, 0x30(%rsp)
callq 0xfb06
movq 0x60(%rbx), %rbp
cmpl $0x0, 0xa7c(%rbp)
je 0x1aa86
testb %r13b, %r13b
je 0x1aa86
cmpl $0x0, 0xc(%rbx)
jne 0x1aa86
movq 0x58(%rbx), %rdi
movl 0x38(%rsp), %eax
cmpl %eax, 0x8(%rdi)
jne 0x1aa86
cmpl $0x0, 0xc(%rdi)
jne 0x1aa86
cmpq %r13, 0x10(%rdi)
jne 0x1aa86
addq $0x18, %rdi
movq 0x30(%rsp), %rsi
movq %r13, %rdx
callq 0xf2b0
testl %eax, %eax
je 0x1b096
incl 0x8(%rbx)
xorl %eax, %eax
movl %eax, 0xa7c(%rbp)
xorl %ebp, %ebp
xorl %edi, %edi
callq 0xf250
movq 0x58(%rbx), %rdi
movq %rax, (%rdi)
movl 0x38(%rsp), %eax
movl %eax, 0x8(%rdi)
movl %ebp, 0xc(%rdi)
movq %r13, 0x10(%rdi)
addq $0x18, %rdi
movq 0x30(%rsp), %rsi
movq %r13, %rdx
callq 0xf240
movq 0x60(%rbx), %rax
cmpl $0x0, 0xa7c(%rax)
leaq 0x353c1(%rip), %rax # 0x4fe93
leaq 0x33132(%rip), %r9 # 0x4dc0b
cmoveq %rax, %r9
leaq 0x34c74(%rip), %rbp # 0x4f758
leaq 0x3538c(%rip), %r8 # 0x4fe77
movq %rbx, %rdi
movl $0x3, %esi
movq %rbp, %rdx
movl $0x657, %ecx # imm = 0x657
xorl %eax, %eax
callq 0xf997
leaq 0x3538d(%rip), %r8 # 0x4fe96
movq %rbx, %rdi
movl $0x3, %esi
movq %rbp, %rdx
movl $0x659, %ecx # imm = 0x659
movl 0x38(%rsp), %r9d
xorl %eax, %eax
callq 0xf997
movzbl 0x25(%r12,%r13), %r9d
leaq 0x3538b(%rip), %r8 # 0x4febd
movq %rbx, %rdi
movl $0x3, %esi
movq %rbp, %rdx
movl $0x65a, %ecx # imm = 0x65A
xorl %eax, %eax
callq 0xf997
movq 0x58(%rbx), %rax
movl 0x8(%rax), %edi
callq 0x1908c
testq %rax, %rax
je 0x1ab6c
movq (%rbx), %rcx
testb $0x40, 0x174(%rcx)
je 0x1abbd
cmpl $0x2a, 0x10(%rax)
jne 0x1abbd
leaq 0x34be5(%rip), %rdx # 0x4f758
leaq 0x3517a(%rip), %r8 # 0x4fcf4
movq %rbx, %rdi
movl $0x1, %esi
movl $0x664, %ecx # imm = 0x664
jmp 0x1a639
leaq 0x34bc5(%rip), %rdx # 0x4f758
leaq 0x35266(%rip), %r8 # 0x4fe00
movq %rbx, %rdi
movl $0x1, %esi
movl $0x62c, %ecx # imm = 0x62C
movl 0x38(%rsp), %r9d
xorl %eax, %eax
callq 0xf997
movl $0xffff8f00, %ebp # imm = 0xFFFF8F00
jmp 0x1a381
movq 0x8(%rax), %r9
leaq 0x34b90(%rip), %rdx # 0x4f758
leaq 0x3530e(%rip), %r8 # 0x4fedd
movq %rbx, %rdi
movl $0x3, %esi
movl $0x668, %ecx # imm = 0x668
xorl %eax, %eax
callq 0xf997
movq (%rbx), %rax
movslq 0x18(%rbx), %rcx
movq (%rax,%rcx,8), %rax
movl (%rax), %ecx
testl %ecx, %ecx
je 0x1afa7
movq 0x58(%rbx), %rdx
addq $0x4, %rax
cmpl 0x8(%rdx), %ecx
jne 0x1abee
movl $0x0, 0xc(%rdx)
addq %r12, %r13
addq $0x28, %r13
leaq 0x34b3e(%rip), %rdx # 0x4f758
leaq 0x352e1(%rip), %r8 # 0x4ff02
movq %rbx, %rdi
movl $0x2, %esi
movl $0x687, %ecx # imm = 0x687
movq %r15, %r9
xorl %eax, %eax
callq 0xf997
movl $0x0, 0x30(%rsp)
testq %r15, %r15
je 0x1afc7
movzwl 0x2(%r13), %eax
rolw $0x8, %ax
movzwl %ax, %r12d
leal 0x4(%r12), %ecx
subq %rcx, %r15
jb 0x1afff
movzwl (%r13), %eax
rolw $0x8, %ax
movzwl %ax, %r9d
cmpl $0x15, %r9d
movq %rcx, 0x38(%rsp)
jg 0x1acf3
cmpl $0xa, %r9d
jg 0x1ad6e
cmpl $0x1, %r9d
je 0x1ae0d
cmpl $0x4, %r9d
jne 0x1af52
movq %rbx, %rdi
movl $0x3, %esi
leaq 0x34aaf(%rip), %rdx # 0x4f758
movl $0x6b3, %ecx # imm = 0x6B3
leaq 0x352b8(%rip), %r8 # 0x4ff6d
xorl %eax, %eax
callq 0xf997
movl $0xffff8680, %ebp # imm = 0xFFFF8680
testl %r12d, %r12d
jne 0x1a381
movq (%rbx), %rax
movl 0x174(%rax), %eax
movl $0x8000, %ecx # imm = 0x8000
andl %ecx, %eax
je 0x1a381
movq 0x58(%rbx), %rax
movl $0x1, 0x90(%rax)
jmp 0x1af74
cmpl $0x22, %r9d
jg 0x1adb8
cmpl $0x16, %r9d
je 0x1ae65
cmpl $0x17, %r9d
jne 0x1af52
movq %rbx, %rdi
movl $0x3, %esi
leaq 0x34a38(%rip), %rdx # 0x4f758
movl $0x6cd, %ecx # imm = 0x6CD
leaq 0x35281(%rip), %r8 # 0x4ffad
xorl %eax, %eax
callq 0xf997
movq (%rbx), %rax
movl $0xffff8680, %ebp # imm = 0xFFFF8680
testb $0x8, 0x175(%rax)
je 0x1a381
testl %r12d, %r12d
jne 0x1a381
cmpl $0x0, (%r14)
je 0x1a381
movq 0x60(%rbx), %rax
movl $0x1, 0xa90(%rax)
jmp 0x1af74
cmpl $0xb, %r9d
je 0x1aec2
cmpl $0x10, %r9d
jne 0x1af52
movq %rbx, %rdi
movl $0x3, %esi
leaq 0x349c7(%rip), %rdx # 0x4f758
movl $0x703, %ecx # imm = 0x703
leaq 0x3527e(%rip), %r8 # 0x5001b
xorl %eax, %eax
callq 0xf997
leaq 0x4(%r13), %rsi
movl %r12d, %edx
movq %rbx, %rdi
callq 0x1cb90
jmp 0x1aef3
cmpl $0x23, %r9d
je 0x1aefc
cmpl $0xff01, %r9d # imm = 0xFF01
jne 0x1af52
movq %rbx, %rdi
movl $0x3, %esi
leaq 0x3497a(%rip), %rdx # 0x4f758
movl $0x699, %ecx # imm = 0x699
leaq 0x35141(%rip), %r8 # 0x4ff2b
xorl %eax, %eax
callq 0xf997
leaq 0x4(%r13), %rsi
movl %r12d, %edx
movq %rbx, %rdi
callq 0x1ca06
movl $0x1, 0x30(%rsp)
jmp 0x1aef3
movq %rbx, %rdi
movl $0x3, %esi
leaq 0x3493c(%rip), %rdx # 0x4f758
movl $0x6a6, %ecx # imm = 0x6A6
leaq 0x35121(%rip), %r8 # 0x4ff49
xorl %eax, %eax
callq 0xf997
movl $0xffff8680, %ebp # imm = 0xFFFF8680
cmpl $0x1, %r12d
jne 0x1a381
movq (%rbx), %rax
movl 0x174(%rax), %eax
shrl $0x7, %eax
andl $0x7, %eax
je 0x1a381
movzbl 0x4(%r13), %ecx
cmpl %ecx, %eax
je 0x1af74
jmp 0x1a381
movq %rbx, %rdi
movl $0x3, %esi
leaq 0x348e4(%rip), %rdx # 0x4f758
movl $0x6c0, %ecx # imm = 0x6C0
leaq 0x3510c(%rip), %r8 # 0x4ff8c
xorl %eax, %eax
callq 0xf997
movq (%rbx), %rax
movl $0xffff8680, %ebp # imm = 0xFFFF8680
testb $0x4, 0x175(%rax)
je 0x1a381
testl %r12d, %r12d
jne 0x1a381
cmpl $0x0, (%r14)
je 0x1a381
movq 0x58(%rbx), %rax
movl $0x1, 0x94(%rax)
jmp 0x1af74
movq %rbx, %rdi
movl $0x3, %esi
leaq 0x34887(%rip), %rdx # 0x4f758
movl $0x6e8, %ecx # imm = 0x6E8
leaq 0x35116(%rip), %r8 # 0x4fff3
xorl %eax, %eax
callq 0xf997
leaq 0x4(%r13), %rsi
movl %r12d, %edx
movq %rbx, %rdi
callq 0x1caf5
testl %eax, %eax
je 0x1af74
jmp 0x1b069
movq %rbx, %rdi
movl $0x3, %esi
leaq 0x3484d(%rip), %rdx # 0x4f758
movl $0x6da, %ecx # imm = 0x6DA
leaq 0x350bd(%rip), %r8 # 0x4ffd4
xorl %eax, %eax
callq 0xf997
movl $0xffff8680, %ebp # imm = 0xFFFF8680
testl %r12d, %r12d
jne 0x1a381
movq (%rbx), %rax
movl 0x174(%rax), %eax
movl $0x10000, %ecx # imm = 0x10000
andl %ecx, %eax
je 0x1a381
movq 0x60(%rbx), %rax
movl $0x1, 0xa8c(%rax)
jmp 0x1af74
movq %rbx, %rdi
movl $0x3, %esi
leaq 0x347f7(%rip), %rdx # 0x4f758
movl $0x70d, %ecx # imm = 0x70D
leaq 0x350c3(%rip), %r8 # 0x50030
xorl %eax, %eax
callq 0xf997
addq 0x38(%rsp), %r13
leaq -0x1(%r15), %rax
cmpq $0x2, %rax
ja 0x1ac40
leaq 0x347ca(%rip), %rdx # 0x4f758
leaq 0x34d5f(%rip), %r8 # 0x4fcf4
movq %rbx, %rdi
movl $0x1, %esi
movl $0x715, %ecx # imm = 0x715
jmp 0x1a639
leaq 0x347aa(%rip), %rdx # 0x4f758
leaq 0x34d3f(%rip), %r8 # 0x4fcf4
movq %rbx, %rdi
movl $0x1, %esi
movl $0x66f, %ecx # imm = 0x66F
jmp 0x1a639
movl 0x190(%rbx), %eax
testl %eax, %eax
jne 0x1b01f
movq (%rbx), %rcx
movl 0x174(%rcx), %ecx
andl $0x30, %ecx
cmpl $0x20, %ecx
jne 0x1b01f
leaq 0x3476f(%rip), %rdx # 0x4f758
leaq 0x35067(%rip), %r8 # 0x50057
movq %rbx, %rdi
movl $0x1, %esi
movl $0x720, %ecx # imm = 0x720
jmp 0x1b04b
leaq 0x34752(%rip), %rdx # 0x4f758
leaq 0x34ce7(%rip), %r8 # 0x4fcf4
movq %rbx, %rdi
movl $0x1, %esi
movl $0x692, %ecx # imm = 0x692
jmp 0x1a639
cmpl $0x1, 0xc(%rbx)
jne 0x1b074
movl %eax, %ecx
xorl $0x1, %ecx
orl 0x30(%rsp), %ecx
jne 0x1b070
leaq 0x34721(%rip), %rdx # 0x4f758
leaq 0x35046(%rip), %r8 # 0x50084
movq %rbx, %rdi
movl $0x1, %esi
movl $0x728, %ecx # imm = 0x728
xorl %eax, %eax
callq 0xf997
movq %rbx, %rdi
callq 0x1588e
testl %eax, %eax
movl $0xffff8680, %ebp # imm = 0xFFFF8680
cmovnel %eax, %ebp
jmp 0x1a381
movl %eax, %ebp
jmp 0x1a381
testl %eax, %eax
je 0x1b0cf
leaq 0x346dd(%rip), %rdx # 0x4f758
leaq 0x34ca9(%rip), %r8 # 0x4fd2b
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x2, %esi
movl $0x743, %ecx # imm = 0x743
jmp 0x1a7fb
movl $0xc, 0x8(%rbx)
movq %rbx, %rdi
callq 0x1098c
testl %eax, %eax
je 0x1aac0
movl %eax, %ebp
leaq 0x346a2(%rip), %rdx # 0x4f758
leaq 0x34da2(%rip), %r8 # 0x4fe5f
movq %rbx, %rdi
movl $0x1, %esi
movl $0x651, %ecx # imm = 0x651
jmp 0x1a379
movq (%rbx), %rax
testb $0x30, 0x174(%rax)
je 0x1b102
cmpl $0x1, 0x30(%rsp)
jne 0x1b074
leaq 0x3466f(%rip), %rdx # 0x4f758
leaq 0x34fe3(%rip), %r8 # 0x500d3
movq %rbx, %rdi
movl $0x1, %esi
movl $0x736, %ecx # imm = 0x736
jmp 0x1b04b
leaq 0x3464f(%rip), %rdx # 0x4f758
leaq 0x34fa2(%rip), %r8 # 0x500b2
movq %rbx, %rdi
movl $0x1, %esi
movl $0x72f, %ecx # imm = 0x72F
jmp 0x1b04b
| /Dragonchang[P]https_client/mbedtls/library/ssl_cli.c |
ssl_parse_server_key_exchange | static int ssl_parse_server_key_exchange( mbedtls_ssl_context *ssl )
{
int ret;
const mbedtls_ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
unsigned char *p, *end;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse server key exchange" ) );
#if defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED)
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA )
{
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip parse server key exchange" ) );
ssl->state++;
return( 0 );
}
((void) p);
((void) end);
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED) || \
defined(MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDH_RSA ||
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA )
{
if( ( ret = ssl_get_ecdh_params_from_cert( ssl ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "ssl_get_ecdh_params_from_cert", ret );
return( ret );
}
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip parse server key exchange" ) );
ssl->state++;
return( 0 );
}
((void) p);
((void) end);
#endif /* MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED ||
MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
if( ( ret = mbedtls_ssl_read_record( ssl ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_read_record", ret );
return( ret );
}
if( ssl->in_msgtype != MBEDTLS_SSL_MSG_HANDSHAKE )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
}
/*
* ServerKeyExchange may be skipped with PSK and RSA-PSK when the server
* doesn't use a psk_identity_hint
*/
if( ssl->in_msg[0] != MBEDTLS_SSL_HS_SERVER_KEY_EXCHANGE )
{
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK ||
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK )
{
ssl->record_read = 1;
goto exit;
}
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
}
p = ssl->in_msg + mbedtls_ssl_hs_hdr_len( ssl );
end = ssl->in_msg + ssl->in_hslen;
MBEDTLS_SSL_DEBUG_BUF( 3, "server key exchange", p, end - p );
#if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK ||
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK ||
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK ||
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK )
{
if( ssl_parse_server_psk_hint( ssl, &p, end ) != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
}
} /* FALLTROUGH */
#endif /* MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED) || \
defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED)
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK ||
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK )
; /* nothing more to do */
else
#endif /* MBEDTLS_KEY_EXCHANGE_PSK_ENABLED ||
MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED) || \
defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED)
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_RSA ||
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK )
{
if( ssl_parse_server_dh_params( ssl, &p, end ) != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
}
}
else
#endif /* MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED ||
MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED) || \
defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_RSA ||
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK ||
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA )
{
if( ssl_parse_server_ecdh_params( ssl, &p, end ) != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
}
}
else
#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED ||
MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECJPAKE )
{
ret = mbedtls_ecjpake_read_round_two( &ssl->handshake->ecjpake_ctx,
p, end - p );
if( ret != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecjpake_read_round_two", ret );
return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
}
}
else
#endif /* MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED */
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED) || \
defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_RSA ||
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_RSA ||
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA )
{
size_t sig_len, hashlen;
unsigned char hash[64];
mbedtls_md_type_t md_alg = MBEDTLS_MD_NONE;
mbedtls_pk_type_t pk_alg = MBEDTLS_PK_NONE;
unsigned char *params = ssl->in_msg + mbedtls_ssl_hs_hdr_len( ssl );
size_t params_len = p - params;
/*
* Handle the digitally-signed structure
*/
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 )
{
if( ssl_parse_signature_algorithm( ssl, &p, end,
&md_alg, &pk_alg ) != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
}
if( pk_alg != mbedtls_ssl_get_ciphersuite_sig_pk_alg( ciphersuite_info ) )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
}
}
else
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
#if defined(MBEDTLS_SSL_PROTO_SSL3) || defined(MBEDTLS_SSL_PROTO_TLS1) || \
defined(MBEDTLS_SSL_PROTO_TLS1_1)
if( ssl->minor_ver < MBEDTLS_SSL_MINOR_VERSION_3 )
{
pk_alg = mbedtls_ssl_get_ciphersuite_sig_pk_alg( ciphersuite_info );
/* Default hash for ECDSA is SHA-1 */
if( pk_alg == MBEDTLS_PK_ECDSA && md_alg == MBEDTLS_MD_NONE )
md_alg = MBEDTLS_MD_SHA1;
}
else
#endif
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
/*
* Read signature
*/
sig_len = ( p[0] << 8 ) | p[1];
p += 2;
if( end != p + sig_len )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
}
MBEDTLS_SSL_DEBUG_BUF( 3, "signature", p, sig_len );
/*
* Compute the hash that has been signed
*/
#if defined(MBEDTLS_SSL_PROTO_SSL3) || defined(MBEDTLS_SSL_PROTO_TLS1) || \
defined(MBEDTLS_SSL_PROTO_TLS1_1)
if( md_alg == MBEDTLS_MD_NONE )
{
mbedtls_md5_context mbedtls_md5;
mbedtls_sha1_context mbedtls_sha1;
mbedtls_md5_init( &mbedtls_md5 );
mbedtls_sha1_init( &mbedtls_sha1 );
hashlen = 36;
/*
* digitally-signed struct {
* opaque md5_hash[16];
* opaque sha_hash[20];
* };
*
* md5_hash
* MD5(ClientHello.random + ServerHello.random
* + ServerParams);
* sha_hash
* SHA(ClientHello.random + ServerHello.random
* + ServerParams);
*/
mbedtls_md5_starts( &mbedtls_md5 );
mbedtls_md5_update( &mbedtls_md5, ssl->handshake->randbytes, 64 );
mbedtls_md5_update( &mbedtls_md5, params, params_len );
mbedtls_md5_finish( &mbedtls_md5, hash );
mbedtls_sha1_starts( &mbedtls_sha1 );
mbedtls_sha1_update( &mbedtls_sha1, ssl->handshake->randbytes, 64 );
mbedtls_sha1_update( &mbedtls_sha1, params, params_len );
mbedtls_sha1_finish( &mbedtls_sha1, hash + 16 );
mbedtls_md5_free( &mbedtls_md5 );
mbedtls_sha1_free( &mbedtls_sha1 );
}
else
#endif /* MBEDTLS_SSL_PROTO_SSL3 || MBEDTLS_SSL_PROTO_TLS1 || \
MBEDTLS_SSL_PROTO_TLS1_1 */
#if defined(MBEDTLS_SSL_PROTO_TLS1) || defined(MBEDTLS_SSL_PROTO_TLS1_1) || \
defined(MBEDTLS_SSL_PROTO_TLS1_2)
if( md_alg != MBEDTLS_MD_NONE )
{
mbedtls_md_context_t ctx;
mbedtls_md_init( &ctx );
/* Info from md_alg will be used instead */
hashlen = 0;
/*
* digitally-signed struct {
* opaque client_random[32];
* opaque server_random[32];
* ServerDHParams params;
* };
*/
if( ( ret = mbedtls_md_setup( &ctx,
mbedtls_md_info_from_type( md_alg ), 0 ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_md_setup", ret );
return( ret );
}
mbedtls_md_starts( &ctx );
mbedtls_md_update( &ctx, ssl->handshake->randbytes, 64 );
mbedtls_md_update( &ctx, params, params_len );
mbedtls_md_finish( &ctx, hash );
mbedtls_md_free( &ctx );
}
else
#endif /* MBEDTLS_SSL_PROTO_TLS1 || MBEDTLS_SSL_PROTO_TLS1_1 || \
MBEDTLS_SSL_PROTO_TLS1_2 */
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
MBEDTLS_SSL_DEBUG_BUF( 3, "parameters hash", hash, hashlen != 0 ? hashlen :
(unsigned int) ( mbedtls_md_get_size( mbedtls_md_info_from_type( md_alg ) ) ) );
if( ssl->session_negotiate->peer_cert == NULL )
{
MBEDTLS_SSL_DEBUG_MSG( 2, ( "certificate required" ) );
return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
}
/*
* Verify signature
*/
if( ! mbedtls_pk_can_do( &ssl->session_negotiate->peer_cert->pk, pk_alg ) )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
return( MBEDTLS_ERR_SSL_PK_TYPE_MISMATCH );
}
if( ( ret = mbedtls_pk_verify( &ssl->session_negotiate->peer_cert->pk,
md_alg, hash, hashlen, p, sig_len ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_pk_verify", ret );
return( ret );
}
}
#endif /* MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED ||
MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED */
exit:
ssl->state++;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse server key exchange" ) );
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdi, %rbx
movq 0x80(%rdi), %rax
movq (%rax), %r14
leaq 0x34611(%rip), %rdx # 0x4f758
leaq 0x350ac(%rip), %r8 # 0x501fa
movl $0x2, %esi
movl $0x896, %ecx # imm = 0x896
xorl %eax, %eax
callq 0xf997
movl 0x18(%r14), %eax
leal -0x9(%rax), %ecx
cmpl $0x2, %ecx
jae 0x1b1ea
movq 0x58(%rbx), %rax
movq 0x68(%rax), %rdi
testq %rdi, %rdi
je 0x1b24b
addq $0x148, %rdi # imm = 0x148
movl $0x2, %esi
callq 0x3b0be
testl %eax, %eax
je 0x1b278
movq 0x58(%rbx), %rax
movq 0x68(%rax), %rax
movq 0x150(%rax), %rsi
movl $0x100, %edi # imm = 0x100
addq 0x60(%rbx), %rdi
movl $0x1, %edx
callq 0x2da2a
testl %eax, %eax
je 0x1b385
movl %eax, %r13d
leaq 0x3458f(%rip), %rdx # 0x4f758
leaq 0x35117(%rip), %r8 # 0x502e7
movq %rbx, %rdi
movl $0x1, %esi
movl $0x881, %ecx # imm = 0x881
movl %eax, %r9d
callq 0xfa82
jmp 0x1b3bd
cmpl $0x1, %eax
jne 0x1b21c
leaq 0x34562(%rip), %rdx # 0x4f758
leaq 0x3501a(%rip), %r8 # 0x50217
xorl %r13d, %r13d
movq %rbx, %rdi
movl $0x2, %esi
movl $0x89b, %ecx # imm = 0x89B
xorl %eax, %eax
callq 0xf997
incl 0x8(%rbx)
jmp 0x1b3e0
movq %rbx, %rdi
callq 0x141f2
testl %eax, %eax
je 0x1b2a5
movl %eax, %r13d
leaq 0x34526(%rip), %rdx # 0x4f758
leaq 0x31b7c(%rip), %r8 # 0x4cdb5
movq %rbx, %rdi
movl $0x1, %esi
movl $0x8b9, %ecx # imm = 0x8B9
jmp 0x1b3d8
leaq 0x34506(%rip), %rdx # 0x4f758
leaq 0x3502e(%rip), %r8 # 0x50287
movq %rbx, %rdi
movl $0x2, %esi
movl $0x871, %ecx # imm = 0x871
xorl %eax, %eax
callq 0xf997
movl $0xffff8900, %r13d # imm = 0xFFFF8900
jmp 0x1b3bd
leaq 0x344d9(%rip), %rdx # 0x4f758
leaq 0x35045(%rip), %r8 # 0x502cb
movq %rbx, %rdi
movl $0x1, %esi
movl $0x878, %ecx # imm = 0x878
xorl %eax, %eax
callq 0xf997
movl $0xffff9300, %r13d # imm = 0xFFFF9300
jmp 0x1b3bd
cmpl $0x16, 0xd8(%rbx)
jne 0x1b3f5
movq 0xc8(%rbx), %r15
cmpb $0xc, (%r15)
jne 0x1b43b
movq (%rbx), %rax
movl 0x174(%rax), %eax
andl $0x2, %eax
leaq 0x4(,%rax,4), %rcx
leaq (%r15,%rax,4), %r12
addq $0x4, %r12
movq %r12, 0x10(%rsp)
movq 0x110(%rbx), %rax
addq %rax, %r15
subq %rcx, %rax
movq %rax, (%rsp)
leaq 0x3445c(%rip), %rdx # 0x4f758
leaq 0x34fb4(%rip), %r8 # 0x502b7
movq %rbx, %rdi
movl $0x3, %esi
movl $0x8d6, %ecx # imm = 0x8D6
movq %r12, %r9
callq 0xfb06
movl 0x18(%r14), %eax
leal -0x5(%rax), %ecx
cmpl $0x3, %ecx
ja 0x1b478
movzwl (%r12), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
addq %r12, %rcx
addq $0x2, %rcx
cmpq %r15, %rcx
jbe 0x1b473
leaq 0x3440d(%rip), %r14 # 0x4f758
leaq 0x34fe9(%rip), %r8 # 0x5033b
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
movl $0x7ca, %ecx # imm = 0x7CA
xorl %eax, %eax
callq 0xf997
leaq 0x34ee7(%rip), %r8 # 0x50257
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
movl $0x8e0, %ecx # imm = 0x8E0
jmp 0x1b707
movq %rbx, %rdi
callq 0x1cf08
leaq 0x343c4(%rip), %rdx # 0x4f758
testl %eax, %eax
je 0x1b41f
leaq 0x34f5c(%rip), %r8 # 0x502ff
movq %rbx, %rdi
movl $0x1, %esi
movl $0x887, %ecx # imm = 0x887
xorl %eax, %eax
callq 0xf997
movl $0xffff8600, %r13d # imm = 0xFFFF8600
leaq 0x34394(%rip), %rdx # 0x4f758
leaq 0x34e6e(%rip), %r8 # 0x50239
movq %rbx, %rdi
movl $0x1, %esi
movl $0x8aa, %ecx # imm = 0x8AA
movl %r13d, %r9d
callq 0xfa82
movl %r13d, %eax
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3435c(%rip), %rdx # 0x4f758
leaq 0x34e54(%rip), %r8 # 0x50257
movq %rbx, %rdi
movl $0x1, %esi
movl $0x8bf, %ecx # imm = 0x8BF
xorl %eax, %eax
callq 0xf997
movl $0xffff8900, %r13d # imm = 0xFFFF8900
jmp 0x1b3e0
leaq 0x34df1(%rip), %r8 # 0x50217
xorl %r13d, %r13d
movq %rbx, %rdi
movl $0x2, %esi
movl $0x8ae, %ecx # imm = 0x8AE
jmp 0x1b20d
movl 0x18(%r14), %eax
orl $0x2, %eax
cmpl $0x7, %eax
jne 0x1b456
movl $0x1, 0x11c(%rbx)
jmp 0x1b8d4
leaq 0x342fb(%rip), %rdx # 0x4f758
leaq 0x34df3(%rip), %r8 # 0x50257
movq %rbx, %rdi
movl $0x1, %esi
movl $0x8d0, %ecx # imm = 0x8D0
jmp 0x1b410
movq %rcx, 0x10(%rsp)
cmpl $0x8, %eax
ja 0x1b49f
movl $0x118, %ecx # imm = 0x118
btl %eax, %ecx
jb 0x1b4bf
movl $0x44, %ecx
btl %eax, %ecx
jb 0x1b4f3
movl $0xa0, %ecx
btl %eax, %ecx
jb 0x1b527
leaq 0x342b2(%rip), %rdx # 0x4f758
leaq 0x310c8(%rip), %r8 # 0x4c575
movq %rbx, %rdi
movl $0x1, %esi
movl $0x91b, %ecx # imm = 0x91B
jmp 0x1b5d8
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x1cd45
testl %eax, %eax
je 0x1b527
leaq 0x3427e(%rip), %rdx # 0x4f758
leaq 0x34d76(%rip), %r8 # 0x50257
movq %rbx, %rdi
movl $0x1, %esi
movl $0x905, %ecx # imm = 0x905
jmp 0x1b707
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x1cc3a
testl %eax, %eax
je 0x1b527
leaq 0x3424a(%rip), %rdx # 0x4f758
leaq 0x34d42(%rip), %r8 # 0x50257
movq %rbx, %rdi
movl $0x1, %esi
movl $0x8f5, %ecx # imm = 0x8F5
jmp 0x1b707
movl 0x18(%r14), %eax
addl $-0x2, %eax
cmpl $0x2, %eax
ja 0x1b8d4
xorl %eax, %eax
movl %eax, 0x18(%rsp)
movl %eax, 0x1c(%rsp)
movq 0xc8(%rbx), %r13
movq (%rbx), %rax
movb 0x174(%rax), %bpl
movq 0x10(%rsp), %r12
movl 0x18(%rbx), %eax
cmpl $0x3, %eax
jne 0x1b59d
leaq 0x10(%rsp), %rsi
leaq 0x18(%rsp), %rcx
leaq 0x1c(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rdx
callq 0x1cdc4
testl %eax, %eax
je 0x1b5ea
leaq 0x341d4(%rip), %rdx # 0x4f758
leaq 0x34ccc(%rip), %r8 # 0x50257
movq %rbx, %rdi
movl $0x1, %esi
movl $0x936, %ecx # imm = 0x936
jmp 0x1b707
jge 0x1b5bd
movq %r14, %rdi
callq 0x19149
movl %eax, %edx
cmpl $0x4, %eax
jne 0x1b612
movl $0x4, 0x18(%rsp)
movl $0x4, %edx
jmp 0x1b612
leaq 0x34194(%rip), %rdx # 0x4f758
leaq 0x30faa(%rip), %r8 # 0x4c575
movq %rbx, %rdi
movl $0x1, %esi
movl $0x94f, %ecx # imm = 0x94F
xorl %eax, %eax
callq 0xf997
movl $0xffff9400, %r13d # imm = 0xFFFF9400
jmp 0x1b3e0
movq %r13, 0x20(%rsp)
movq %r12, %r13
movl 0x1c(%rsp), %r12d
movq %r14, %rdi
callq 0x19149
movl %r12d, %edx
movq %r13, %r12
movq 0x20(%rsp), %r13
cmpl %eax, %edx
jne 0x1b6ec
movq 0x10(%rsp), %rax
movzwl (%rax), %ecx
rolw $0x8, %cx
movzwl %cx, %r14d
leaq 0x2(%rax), %r9
movq %r9, 0x10(%rsp)
addq %r14, %rax
addq $0x2, %rax
cmpq %rax, %r15
je 0x1b657
leaq 0x3411a(%rip), %rdx # 0x4f758
leaq 0x34c12(%rip), %r8 # 0x50257
movq %rbx, %rdi
movl $0x1, %esi
movl $0x95b, %ecx # imm = 0x95B
jmp 0x1b707
movl %edx, 0x20(%rsp)
andb $0x2, %bpl
shrb %bpl
movzbl %bpl, %eax
leaq 0x4(,%rax,8), %r15
addq %r13, %r15
subq %r15, %r12
movq %r14, (%rsp)
leaq 0x340d9(%rip), %rdx # 0x4f758
leaq 0x35ea3(%rip), %r8 # 0x51529
movq %rbx, %rdi
movl $0x3, %esi
movl $0x95f, %ecx # imm = 0x95F
callq 0xfb06
movl 0x18(%rsp), %ebp
testl %ebp, %ebp
je 0x1b719
leaq 0x70(%rsp), %r13
movq %r13, %rdi
callq 0x38cf4
movl %ebp, %edi
callq 0x38cdb
movq %r13, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x38da1
testl %eax, %eax
je 0x1b7dc
movl %eax, %r13d
leaq 0x34085(%rip), %rdx # 0x4f758
leaq 0x30f36(%rip), %r8 # 0x4c610
movq %rbx, %rdi
movl $0x1, %esi
movl $0x9a2, %ecx # imm = 0x9A2
jmp 0x1b3d8
leaq 0x34065(%rip), %rdx # 0x4f758
leaq 0x34b5d(%rip), %r8 # 0x50257
movq %rbx, %rdi
movl $0x1, %esi
movl $0x93c, %ecx # imm = 0x93C
xorl %eax, %eax
callq 0xf997
movl $0xffff8500, %r13d # imm = 0xFFFF8500
jmp 0x1b3e0
leaq 0xd0(%rsp), %r13
movq %r13, %rdi
callq 0x3928c
leaq 0x70(%rsp), %rdi
callq 0x40c04
movq %r13, %rdi
movl %ebp, 0x2c(%rsp)
movq %r13, %rbp
callq 0x392c8
movl $0x618, %r13d # imm = 0x618
movq 0x60(%rbx), %rsi
addq %r13, %rsi
movl $0x40, %edx
movq %rbp, %rdi
callq 0x39a96
movq %rbp, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x39a96
leaq 0x30(%rsp), %rsi
movq %rbp, %rdi
callq 0x39b50
leaq 0x70(%rsp), %rbp
movq %rbp, %rdi
callq 0x40c3c
addq 0x60(%rbx), %r13
movl $0x40, %edx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x41d8b
movq %rbp, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x41d8b
leaq 0x40(%rsp), %rsi
movq %rbp, %r15
movq %rbp, %rdi
callq 0x41e45
leaq 0xd0(%rsp), %rdi
movl 0x2c(%rsp), %ebp
callq 0x392ab
movq %r15, %rdi
callq 0x40c1f
movl $0x24, %r15d
movl $0x24, %eax
jmp 0x1b837
leaq 0x70(%rsp), %r13
movq %r13, %rdi
callq 0x38e0f
movl $0x618, %esi # imm = 0x618
addq 0x60(%rbx), %rsi
movl $0x40, %edx
movq %r13, %rdi
callq 0x38e30
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x38e30
leaq 0x30(%rsp), %rsi
movq %r13, %rdi
callq 0x38e51
movq %r13, %rdi
callq 0x38d03
movl %ebp, %edi
callq 0x38cdb
movq %rax, %rdi
callq 0x39265
movzbl %al, %eax
xorl %r15d, %r15d
movq %rax, (%rsp)
leaq 0x33f16(%rip), %rdx # 0x4f758
leaq 0x34a2e(%rip), %r8 # 0x50277
leaq 0x30(%rsp), %r9
movq %rbx, %rdi
movl $0x3, %esi
movl $0x9b5, %ecx # imm = 0x9B5
callq 0xfb06
movq 0x58(%rbx), %rax
movq 0x68(%rax), %rdi
testq %rdi, %rdi
je 0x1b901
addq $0x148, %rdi # imm = 0x148
movl 0x20(%rsp), %esi
callq 0x3b0be
testl %eax, %eax
je 0x1b921
movq 0x58(%rbx), %rax
movl $0x148, %edi # imm = 0x148
addq 0x68(%rax), %rdi
movq 0x10(%rsp), %r8
leaq 0x30(%rsp), %rdx
movl %ebp, %esi
movq %r15, %rcx
movq %r14, %r9
callq 0x3b0d3
testl %eax, %eax
je 0x1b8d4
movl %eax, %r13d
leaq 0x33e9d(%rip), %rdx # 0x4f758
leaq 0x349da(%rip), %r8 # 0x5029c
movq %rbx, %rdi
movl $0x1, %esi
movl $0x9c9, %ecx # imm = 0x9C9
jmp 0x1b3d8
incl 0x8(%rbx)
leaq 0x33e7a(%rip), %rdx # 0x4f758
leaq 0x349c9(%rip), %r8 # 0x502ae
xorl %r13d, %r13d
movq %rbx, %rdi
movl $0x2, %esi
movl $0x9d4, %ecx # imm = 0x9D4
xorl %eax, %eax
callq 0xf997
jmp 0x1b3e0
leaq 0x33e50(%rip), %rdx # 0x4f758
leaq 0x34978(%rip), %r8 # 0x50287
movq %rbx, %rdi
movl $0x2, %esi
movl $0x9b9, %ecx # imm = 0x9B9
jmp 0x1b410
leaq 0x33e30(%rip), %rdx # 0x4f758
leaq 0x34928(%rip), %r8 # 0x50257
movq %rbx, %rdi
movl $0x1, %esi
movl $0x9c2, %ecx # imm = 0x9C2
xorl %eax, %eax
callq 0xf997
movl $0xffff9300, %r13d # imm = 0xFFFF9300
jmp 0x1b3e0
| /Dragonchang[P]https_client/mbedtls/library/ssl_cli.c |
ssl_parse_server_hello_done | static int ssl_parse_server_hello_done( mbedtls_ssl_context *ssl )
{
int ret;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse server hello done" ) );
if( ssl->record_read == 0 )
{
if( ( ret = mbedtls_ssl_read_record( ssl ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_read_record", ret );
return( ret );
}
if( ssl->in_msgtype != MBEDTLS_SSL_MSG_HANDSHAKE )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello done message" ) );
return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
}
}
ssl->record_read = 0;
if( ssl->in_hslen != mbedtls_ssl_hs_hdr_len( ssl ) ||
ssl->in_msg[0] != MBEDTLS_SSL_HS_SERVER_HELLO_DONE )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello done message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO_DONE );
}
ssl->state++;
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
mbedtls_ssl_recv_flight_completed( ssl );
#endif
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse server hello done" ) );
return( 0 );
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x33adc(%rip), %rdx # 0x4f758
leaq 0x3490e(%rip), %r8 # 0x50591
movl $0x2, %esi
movl $0xa81, %ecx # imm = 0xA81
xorl %eax, %eax
callq 0xf997
cmpl $0x0, 0x11c(%rbx)
je 0x1bd3f
movl $0x0, 0x11c(%rbx)
movq (%rbx), %rax
movb 0x174(%rax), %cl
andb $0x2, %cl
shrb %cl
movzbl %cl, %ecx
leaq 0x4(,%rcx,8), %rcx
cmpq %rcx, 0x110(%rbx)
jne 0x1bd16
movq 0xc8(%rbx), %rcx
cmpb $0xe, (%rcx)
jne 0x1bd16
incl 0x8(%rbx)
testb $0x2, 0x174(%rax)
je 0x1bced
movq %rbx, %rdi
callq 0x137db
leaq 0x33a64(%rip), %rdx # 0x4f758
leaq 0x348cf(%rip), %r8 # 0x505ca
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x2, %esi
movl $0xaa1, %ecx # imm = 0xAA1
xorl %eax, %eax
callq 0xf997
jmp 0x1bda6
leaq 0x33a3b(%rip), %rdx # 0x4f758
leaq 0x34888(%rip), %r8 # 0x505ac
movq %rbx, %rdi
movl $0x1, %esi
movl $0xa96, %ecx # imm = 0xA96
xorl %eax, %eax
callq 0xf997
movl $0xffff8480, %ebp # imm = 0xFFFF8480
jmp 0x1bda6
movq %rbx, %rdi
callq 0x141f2
testl %eax, %eax
je 0x1bd72
movl %eax, %ebp
leaq 0x33a04(%rip), %rdx # 0x4f758
leaq 0x3105a(%rip), %r8 # 0x4cdb5
movq %rbx, %rdi
movl $0x1, %esi
movl $0xa87, %ecx # imm = 0xA87
movl %eax, %r9d
callq 0xfa82
jmp 0x1bda6
cmpl $0x16, 0xd8(%rbx)
je 0x1bca1
leaq 0x339d2(%rip), %rdx # 0x4f758
leaq 0x3481f(%rip), %r8 # 0x505ac
movq %rbx, %rdi
movl $0x1, %esi
movl $0xa8d, %ecx # imm = 0xA8D
xorl %eax, %eax
callq 0xf997
movl $0xffff8900, %ebp # imm = 0xFFFF8900
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_cli.c |
ssl_write_client_key_exchange | static int ssl_write_client_key_exchange( mbedtls_ssl_context *ssl )
{
int ret;
size_t i, n;
const mbedtls_ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write client key exchange" ) );
#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED)
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_RSA )
{
/*
* DHM key exchange -- send G^X mod P
*/
n = ssl->handshake->dhm_ctx.len;
ssl->out_msg[4] = (unsigned char)( n >> 8 );
ssl->out_msg[5] = (unsigned char)( n );
i = 6;
ret = mbedtls_dhm_make_public( &ssl->handshake->dhm_ctx,
(int) mbedtls_mpi_size( &ssl->handshake->dhm_ctx.P ),
&ssl->out_msg[i], n,
ssl->conf->f_rng, ssl->conf->p_rng );
if( ret != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_dhm_make_public", ret );
return( ret );
}
MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: X ", &ssl->handshake->dhm_ctx.X );
MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: GX", &ssl->handshake->dhm_ctx.GX );
if( ( ret = mbedtls_dhm_calc_secret( &ssl->handshake->dhm_ctx,
ssl->handshake->premaster,
MBEDTLS_PREMASTER_SIZE,
&ssl->handshake->pmslen,
ssl->conf->f_rng, ssl->conf->p_rng ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_dhm_calc_secret", ret );
return( ret );
}
MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: K ", &ssl->handshake->dhm_ctx.K );
}
else
#endif /* MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED) || \
defined(MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED) || \
defined(MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_RSA ||
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA ||
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDH_RSA ||
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA )
{
/*
* ECDH key exchange -- send client public value
*/
i = 4;
ret = mbedtls_ecdh_make_public( &ssl->handshake->ecdh_ctx,
&n,
&ssl->out_msg[i], 1000,
ssl->conf->f_rng, ssl->conf->p_rng );
if( ret != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecdh_make_public", ret );
return( ret );
}
MBEDTLS_SSL_DEBUG_ECP( 3, "ECDH: Q", &ssl->handshake->ecdh_ctx.Q );
if( ( ret = mbedtls_ecdh_calc_secret( &ssl->handshake->ecdh_ctx,
&ssl->handshake->pmslen,
ssl->handshake->premaster,
MBEDTLS_MPI_MAX_SIZE,
ssl->conf->f_rng, ssl->conf->p_rng ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecdh_calc_secret", ret );
return( ret );
}
MBEDTLS_SSL_DEBUG_MPI( 3, "ECDH: z", &ssl->handshake->ecdh_ctx.z );
}
else
#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED ||
MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED ||
MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK ||
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK ||
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK ||
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK )
{
/*
* opaque psk_identity<0..2^16-1>;
*/
if( ssl->conf->psk == NULL || ssl->conf->psk_identity == NULL )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "got no private key for PSK" ) );
return( MBEDTLS_ERR_SSL_PRIVATE_KEY_REQUIRED );
}
i = 4;
n = ssl->conf->psk_identity_len;
if( i + 2 + n > MBEDTLS_SSL_MAX_CONTENT_LEN )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "psk identity too long or "
"SSL buffer too short" ) );
return( MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
}
ssl->out_msg[i++] = (unsigned char)( n >> 8 );
ssl->out_msg[i++] = (unsigned char)( n );
memcpy( ssl->out_msg + i, ssl->conf->psk_identity, ssl->conf->psk_identity_len );
i += ssl->conf->psk_identity_len;
#if defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED)
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK )
{
n = 0;
}
else
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED)
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK )
{
if( ( ret = ssl_write_encrypted_pms( ssl, i, &n, 2 ) ) != 0 )
return( ret );
}
else
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED)
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK )
{
/*
* ClientDiffieHellmanPublic public (DHM send G^X mod P)
*/
n = ssl->handshake->dhm_ctx.len;
if( i + 2 + n > MBEDTLS_SSL_MAX_CONTENT_LEN )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "psk identity or DHM size too long"
" or SSL buffer too short" ) );
return( MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
}
ssl->out_msg[i++] = (unsigned char)( n >> 8 );
ssl->out_msg[i++] = (unsigned char)( n );
ret = mbedtls_dhm_make_public( &ssl->handshake->dhm_ctx,
(int) mbedtls_mpi_size( &ssl->handshake->dhm_ctx.P ),
&ssl->out_msg[i], n,
ssl->conf->f_rng, ssl->conf->p_rng );
if( ret != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_dhm_make_public", ret );
return( ret );
}
}
else
#endif /* MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK )
{
/*
* ClientECDiffieHellmanPublic public;
*/
ret = mbedtls_ecdh_make_public( &ssl->handshake->ecdh_ctx, &n,
&ssl->out_msg[i], MBEDTLS_SSL_MAX_CONTENT_LEN - i,
ssl->conf->f_rng, ssl->conf->p_rng );
if( ret != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecdh_make_public", ret );
return( ret );
}
MBEDTLS_SSL_DEBUG_ECP( 3, "ECDH: Q", &ssl->handshake->ecdh_ctx.Q );
}
else
#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
if( ( ret = mbedtls_ssl_psk_derive_premaster( ssl,
ciphersuite_info->key_exchange ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_psk_derive_premaster", ret );
return( ret );
}
}
else
#endif /* MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED)
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA )
{
i = 4;
if( ( ret = ssl_write_encrypted_pms( ssl, i, &n, 0 ) ) != 0 )
return( ret );
}
else
#endif /* MBEDTLS_KEY_EXCHANGE_RSA_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECJPAKE )
{
i = 4;
ret = mbedtls_ecjpake_write_round_two( &ssl->handshake->ecjpake_ctx,
ssl->out_msg + i, MBEDTLS_SSL_MAX_CONTENT_LEN - i, &n,
ssl->conf->f_rng, ssl->conf->p_rng );
if( ret != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecjpake_write_round_two", ret );
return( ret );
}
ret = mbedtls_ecjpake_derive_secret( &ssl->handshake->ecjpake_ctx,
ssl->handshake->premaster, 32, &ssl->handshake->pmslen,
ssl->conf->f_rng, ssl->conf->p_rng );
if( ret != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecjpake_derive_secret", ret );
return( ret );
}
}
else
#endif /* MBEDTLS_KEY_EXCHANGE_RSA_ENABLED */
{
((void) ciphersuite_info);
MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
ssl->out_msglen = i + n;
ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;
ssl->out_msg[0] = MBEDTLS_SSL_HS_CLIENT_KEY_EXCHANGE;
ssl->state++;
if( ( ret = mbedtls_ssl_write_record( ssl ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_write_record", ret );
return( ret );
}
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write client key exchange" ) );
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x80(%rdi), %rax
movq (%rax), %r12
leaq 0x33989(%rip), %rdx # 0x4f758
leaq 0x3480f(%rip), %r8 # 0x505e5
movl $0x2, %esi
movl $0xaac, %ecx # imm = 0xAAC
xorl %eax, %eax
callq 0xf997
movl 0x18(%r12), %eax
decl %eax
cmpl $0x9, %eax
ja 0x1c01e
leaq 0x33922(%rip), %rcx # 0x4f720
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x100, %edi # imm = 0x100
addq 0x60(%rbx), %rdi
movq (%rbx), %rax
movq 0x148(%rbx), %rdx
addq $0x4, %rdx
movq 0x30(%rax), %r8
movq 0x38(%rax), %r9
leaq 0x8(%rsp), %rsi
movl $0x3e8, %ecx # imm = 0x3E8
callq 0x2da9e
testl %eax, %eax
je 0x1beee
movl %eax, %ebp
leaq 0x33912(%rip), %rdx # 0x4f758
leaq 0x347dd(%rip), %r8 # 0x5062a
movq %rbx, %rdi
movl $0x1, %esi
movl $0xae9, %ecx # imm = 0xAE9
jmp 0x1c3ec
movq (%rbx), %rax
cmpq $0x0, 0x128(%rax)
je 0x1bec2
cmpq $0x0, 0x138(%rax)
je 0x1bec2
movq 0x140(%rax), %rax
movq %rax, 0x8(%rsp)
leaq -0x3ffb(%rax), %rcx
cmpq $-0x4002, %rcx # imm = 0xBFFE
ja 0x1c04a
leaq 0x338bb(%rip), %rdx # 0x4f758
leaq 0x347c2(%rip), %r8 # 0x50666
movq %rbx, %rdi
movl $0x1, %esi
movl $0xb15, %ecx # imm = 0xB15
xorl %eax, %eax
callq 0xf997
movl $0xffff9600, %ebp # imm = 0xFFFF9600
jmp 0x1c3f4
leaq 0x3388f(%rip), %rdx # 0x4f758
leaq 0x3477b(%rip), %r8 # 0x5064b
movq %rbx, %rdi
movl $0x1, %esi
movl $0xb0b, %ecx # imm = 0xB0B
xorl %eax, %eax
callq 0xf997
movl $0xffff8a00, %ebp # imm = 0xFFFF8A00
jmp 0x1c3f4
movl $0x210, %r9d # imm = 0x210
addq 0x60(%rbx), %r9
leaq 0x33859(%rip), %rdx # 0x4f758
leaq 0x3473d(%rip), %r8 # 0x50643
movq %rbx, %rdi
movl $0x3, %esi
movl $0xaed, %ecx # imm = 0xAED
callq 0xfd4c
movq (%rbx), %rax
movq 0x60(%rbx), %rdx
leaq 0x100(%rdx), %rdi
leaq 0x610(%rdx), %rsi
addq $0x658, %rdx # imm = 0x658
movq 0x30(%rax), %r8
movq 0x38(%rax), %r9
movl $0x400, %ecx # imm = 0x400
callq 0x2db67
testl %eax, %eax
je 0x1c0c0
movl %eax, %ebp
leaq 0x33801(%rip), %rdx # 0x4f758
leaq 0x3076b(%rip), %r8 # 0x4c6c9
movq %rbx, %rdi
movl $0x1, %esi
movl $0xaf5, %ecx # imm = 0xAF5
jmp 0x1c3ec
movl $0x4, %r14d
leaq 0x8(%rsp), %rdx
movl $0x4, %esi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x1cfba
testl %eax, %eax
je 0x1c0f0
movl %eax, %ebp
jmp 0x1c3f4
movq 0x60(%rbx), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x148(%rbx), %rcx
movb %ah, 0x4(%rcx)
movb 0x8(%rsp), %al
movq 0x148(%rbx), %rcx
movb %al, 0x5(%rcx)
movq 0x60(%rbx), %rdi
leaq 0x8(%rdi), %r14
addq $0x10, %rdi
callq 0x25e13
movq (%rbx), %rsi
movq 0x148(%rbx), %rdx
addq $0x6, %rdx
movq 0x8(%rsp), %rcx
movq 0x30(%rsi), %r8
movq 0x38(%rsi), %r9
movq %r14, %rdi
movl %eax, %esi
callq 0x2d038
testl %eax, %eax
je 0x1c16a
movl %eax, %ebp
leaq 0x33753(%rip), %rdx # 0x4f758
leaq 0x345f6(%rip), %r8 # 0x50602
movq %rbx, %rdi
movl $0x1, %esi
movl $0xac0, %ecx # imm = 0xAC0
jmp 0x1c3ec
leaq 0x33733(%rip), %rdx # 0x4f758
leaq 0x30549(%rip), %r8 # 0x4c575
movq %rbx, %rdi
movl $0x1, %esi
movl $0xb91, %ecx # imm = 0xB91
xorl %eax, %eax
callq 0xf997
movl $0xffff9400, %ebp # imm = 0xFFFF9400
jmp 0x1c3f4
movq 0x148(%rbx), %rcx
movb %ah, 0x4(%rcx)
movb 0x8(%rsp), %al
movq 0x148(%rbx), %rcx
movb %al, 0x5(%rcx)
movq (%rbx), %rax
movq 0x148(%rbx), %rdi
addq $0x6, %rdi
movq 0x138(%rax), %rsi
movq 0x140(%rax), %rdx
callq 0xf240
movl 0x18(%r12), %ecx
addl $-0x5, %ecx
cmpl $0x3, %ecx
ja 0x1c2c5
movq (%rbx), %rsi
movq 0x140(%rsi), %rax
leaq 0x6(%rax), %r14
leaq 0x3369f(%rip), %rdx # 0x4f748
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq $0x0, 0x8(%rsp)
jmp 0x1c3ba
movl $0x2a0, %r9d # imm = 0x2A0
addq 0x60(%rbx), %r9
leaq 0x33687(%rip), %rdx # 0x4f758
leaq 0x3060a(%rip), %r8 # 0x4c6e2
movq %rbx, %rdi
movl $0x3, %esi
movl $0xaf9, %ecx # imm = 0xAF9
callq 0xfdfd
movl $0x4, %r14d
addq 0x8(%rsp), %r14
movq %r14, 0x158(%rbx)
movl $0x16, 0x150(%rbx)
movq 0x148(%rbx), %rax
movb $0x10, (%rax)
incl 0x8(%rbx)
movq %rbx, %rdi
callq 0x12b2b
testl %eax, %eax
je 0x1c141
movl %eax, %ebp
leaq 0x33630(%rip), %rdx # 0x4f758
leaq 0x307ba(%rip), %r8 # 0x4c8e9
movq %rbx, %rdi
movl $0x1, %esi
movl $0xb9d, %ecx # imm = 0xB9D
jmp 0x1c3ec
leaq 0x33610(%rip), %rdx # 0x4f758
leaq 0x345a0(%rip), %r8 # 0x506ef
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x2, %esi
movl $0xba1, %ecx # imm = 0xBA1
xorl %eax, %eax
callq 0xf997
jmp 0x1c3f4
movq 0x60(%rbx), %r9
addq $0x40, %r9
leaq 0x335df(%rip), %r14 # 0x4f758
leaq 0x3449a(%rip), %r8 # 0x5061a
movq %rbx, %rdi
movl $0x3, %esi
movq %r14, %rdx
movl $0xac4, %ecx # imm = 0xAC4
callq 0xfdfd
movq 0x60(%rbx), %r9
addq $0x58, %r9
leaq 0x3447e(%rip), %r8 # 0x50622
movq %rbx, %rdi
movl $0x3, %esi
movq %r14, %rdx
movl $0xac5, %ecx # imm = 0xAC5
callq 0xfdfd
movq (%rbx), %rax
movq 0x60(%rbx), %rcx
leaq 0x8(%rcx), %rdi
leaq 0x658(%rcx), %rsi
addq $0x610, %rcx # imm = 0x610
movq 0x30(%rax), %r8
movq 0x38(%rax), %r9
movl $0x424, %edx # imm = 0x424
callq 0x2d15a
testl %eax, %eax
je 0x1c2e5
movl %eax, %ebp
leaq 0x33563(%rip), %rdx # 0x4f758
leaq 0x304ad(%rip), %r8 # 0x4c6a9
movq %rbx, %rdi
movl $0x1, %esi
movl $0xacd, %ecx # imm = 0xACD
jmp 0x1c3ec
leaq 0x8(%rsp), %rdx
movl $0x2, %ecx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1cfba
testl %eax, %eax
jne 0x1bf92
jmp 0x1c3ba
movl $0x100, %edi # imm = 0x100
addq 0x60(%rbx), %rdi
movq 0x148(%rbx), %rdx
addq %r14, %rdx
movl $0x3ffa, %ecx # imm = 0x3FFA
subq %rax, %rcx
movq 0x30(%rsi), %r8
movq 0x38(%rsi), %r9
leaq 0x8(%rsp), %rsi
callq 0x2da9e
testl %eax, %eax
je 0x1c390
movl %eax, %ebp
leaq 0x334ea(%rip), %rdx # 0x4f758
leaq 0x343b5(%rip), %r8 # 0x5062a
movq %rbx, %rdi
movl $0x1, %esi
movl $0xb57, %ecx # imm = 0xB57
jmp 0x1c3ec
movq 0x60(%rbx), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rsp)
leaq (%rcx,%rax), %rdx
addq $0x8, %rdx
cmpq $0x4001, %rdx # imm = 0x4001
jb 0x1c31a
leaq 0x334ac(%rip), %rdx # 0x4f758
leaq 0x343e1(%rip), %r8 # 0x50694
movq %rbx, %rdi
movl $0x1, %esi
movl $0xb39, %ecx # imm = 0xB39
jmp 0x1beb1
leaq 0x3348c(%rip), %rdx # 0x4f758
leaq 0x302a2(%rip), %r8 # 0x4c575
movq %rbx, %rdi
movl $0x1, %esi
movl $0xb60, %ecx # imm = 0xB60
jmp 0x1c039
movl $0x88, %r9d
addq 0x60(%rbx), %r9
leaq 0x33462(%rip), %rdx # 0x4f758
leaq 0x303c4(%rip), %r8 # 0x4c6c1
movq %rbx, %rdi
movl $0x3, %esi
movl $0xad1, %ecx # imm = 0xAD1
callq 0xfdfd
movl $0x6, %r14d
jmp 0x1c0f0
leaq 0x8(%rax), %r14
movq 0x148(%rbx), %rdx
movb %ch, 0x6(%rdx,%rax)
movb 0x8(%rsp), %cl
movq 0x148(%rbx), %rdx
movb %cl, 0x7(%rdx,%rax)
movq 0x60(%rbx), %rdi
leaq 0x8(%rdi), %r15
addq $0x10, %rdi
callq 0x25e13
movq 0x148(%rbx), %rdx
addq %r14, %rdx
movq 0x8(%rsp), %rcx
movq (%rbx), %rsi
movq 0x30(%rsi), %r8
movq 0x38(%rsi), %r9
movq %r15, %rdi
movl %eax, %esi
callq 0x2d038
testl %eax, %eax
je 0x1c3ba
movl %eax, %ebp
leaq 0x333de(%rip), %rdx # 0x4f758
leaq 0x34281(%rip), %r8 # 0x50602
movq %rbx, %rdi
movl $0x1, %esi
movl $0xb46, %ecx # imm = 0xB46
jmp 0x1c3ec
movl $0x210, %r9d # imm = 0x210
addq 0x60(%rbx), %r9
leaq 0x333b7(%rip), %rdx # 0x4f758
leaq 0x3429b(%rip), %r8 # 0x50643
movq %rbx, %rdi
movl $0x3, %esi
movl $0xb5b, %ecx # imm = 0xB5B
callq 0xfd4c
movl 0x18(%r12), %esi
movq %rbx, %rdi
callq 0x11dd3
testl %eax, %eax
je 0x1c0f0
movl %eax, %ebp
leaq 0x33380(%rip), %rdx # 0x4f758
leaq 0x342ef(%rip), %r8 # 0x506ce
movq %rbx, %rdi
movl $0x1, %esi
movl $0xb67, %ecx # imm = 0xB67
movl %ebp, %r9d
callq 0xfa82
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_cli.c |
ssl_parse_alpn_ext | static int ssl_parse_alpn_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf, size_t len )
{
size_t list_len, name_len;
const char **p;
/* If we didn't send it, the server shouldn't send it */
if( ssl->conf->alpn_list == NULL )
return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
/*
* opaque ProtocolName<1..2^8-1>;
*
* struct {
* ProtocolName protocol_name_list<2..2^16-1>
* } ProtocolNameList;
*
* the "ProtocolNameList" MUST contain exactly one "ProtocolName"
*/
/* Min length is 2 (list_len) + 1 (name_len) + 1 (name) */
if( len < 4 )
return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
list_len = ( buf[0] << 8 ) | buf[1];
if( list_len != len - 2 )
return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
name_len = buf[2];
if( name_len != list_len - 1 )
return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
/* Check that the server chosen protocol was in our list and save it */
for( p = ssl->conf->alpn_list; *p != NULL; p++ )
{
if( name_len == strlen( *p ) &&
memcmp( buf + 3, *p, name_len ) == 0 )
{
ssl->alpn_chosen = *p;
return( 0 );
}
}
return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x148(%rax), %rbp
testq %rbp, %rbp
sete %al
cmpq $0x4, %rdx
setb %cl
orb %al, %cl
movl $0xffff8680, %ebx # imm = 0xFFFF8680
jne 0x1cc29
movq %rsi, %r15
movzwl (%rsi), %eax
rolw $0x8, %ax
movzwl %ax, %eax
addq $-0x2, %rdx
cmpq %rdx, %rax
jne 0x1cc29
movzbl 0x2(%r15), %r12d
decq %rax
cmpq %r12, %rax
jne 0x1cc29
movq (%rbp), %r13
testq %r13, %r13
je 0x1cc29
movq %rdi, %r14
addq $0x3, %r15
addq $0x8, %rbp
movq %r13, %rdi
callq 0xf100
cmpq %r12, %rax
jne 0x1cc11
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xf2b0
testl %eax, %eax
je 0x1cc20
movq (%rbp), %r13
addq $0x8, %rbp
testq %r13, %r13
jne 0x1cbf2
jmp 0x1cc29
movq %r13, 0x178(%r14)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_cli.c |
ssl_parse_server_dh_params | static int ssl_parse_server_dh_params( mbedtls_ssl_context *ssl, unsigned char **p,
unsigned char *end )
{
int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
/*
* Ephemeral DH parameters:
*
* struct {
* opaque dh_p<1..2^16-1>;
* opaque dh_g<1..2^16-1>;
* opaque dh_Ys<1..2^16-1>;
* } ServerDHParams;
*/
if( ( ret = mbedtls_dhm_read_params( &ssl->handshake->dhm_ctx, p, end ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 2, ( "mbedtls_dhm_read_params" ), ret );
return( ret );
}
if( ssl->handshake->dhm_ctx.len * 8 < ssl->conf->dhm_min_bitlen )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "DHM prime too short: %d < %d",
ssl->handshake->dhm_ctx.len * 8,
ssl->conf->dhm_min_bitlen ) );
return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
}
MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: P ", &ssl->handshake->dhm_ctx.P );
MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: G ", &ssl->handshake->dhm_ctx.G );
MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: GY", &ssl->handshake->dhm_ctx.GY );
return( ret );
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
addq $0x8, %rdi
callq 0x2ccdc
testl %eax, %eax
je 0x1cc80
movl %eax, %ebp
leaq 0x32af9(%rip), %rdx # 0x4f758
leaq 0x33710(%rip), %r8 # 0x50376
movq %rbx, %rdi
movl $0x2, %esi
movl $0x75a, %ecx # imm = 0x75A
movl %eax, %r9d
callq 0xfa82
jmp 0x1cd3a
movq (%rbx), %rcx
movq 0x60(%rbx), %rax
movq 0x8(%rax), %r9
shlq $0x3, %r9
movl 0x16c(%rcx), %ecx
cmpq %rcx, %r9
jae 0x1ccc6
movl %ecx, (%rsp)
leaq 0x32ab4(%rip), %rdx # 0x4f758
leaq 0x336e3(%rip), %r8 # 0x5038e
movq %rbx, %rdi
movl $0x1, %esi
movl $0x762, %ecx # imm = 0x762
xorl %eax, %eax
callq 0xf997
movl $0xffff8500, %ebp # imm = 0xFFFF8500
jmp 0x1cd3a
addq $0x10, %rax
leaq 0x32a87(%rip), %r14 # 0x4f758
leaq 0x336d3(%rip), %r8 # 0x503ab
movq %rbx, %rdi
movl $0x3, %esi
movq %r14, %rdx
movl $0x766, %ecx # imm = 0x766
movq %rax, %r9
callq 0xfdfd
movq 0x60(%rbx), %r9
addq $0x28, %r9
leaq 0x336b4(%rip), %r8 # 0x503b3
movq %rbx, %rdi
movl $0x3, %esi
movq %r14, %rdx
movl $0x767, %ecx # imm = 0x767
callq 0xfdfd
movq 0x60(%rbx), %r9
addq $0x70, %r9
leaq 0x33698(%rip), %r8 # 0x503bb
movq %rbx, %rdi
movl $0x3, %esi
movq %r14, %rdx
movl $0x768, %ecx # imm = 0x768
callq 0xfdfd
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_cli.c |
ssl_parse_server_ecdh_params | static int ssl_parse_server_ecdh_params( mbedtls_ssl_context *ssl,
unsigned char **p,
unsigned char *end )
{
int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
/*
* Ephemeral ECDH parameters:
*
* struct {
* ECParameters curve_params;
* ECPoint public;
* } ServerECDHParams;
*/
if( ( ret = mbedtls_ecdh_read_params( &ssl->handshake->ecdh_ctx,
(const unsigned char **) p, end ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, ( "mbedtls_ecdh_read_params" ), ret );
return( ret );
}
if( ssl_check_server_ecdh_params( ssl ) != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message (ECDHE curve)" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
}
return( ret );
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x100, %edi # imm = 0x100
addq 0x60(%rbx), %rdi
callq 0x2d9ed
testl %eax, %eax
je 0x1cd84
movl %eax, %ebp
leaq 0x329f2(%rip), %rdx # 0x4f758
leaq 0x33656(%rip), %r8 # 0x503c3
movq %rbx, %rdi
movl $0x1, %esi
movl $0x7a7, %ecx # imm = 0x7A7
movl %eax, %r9d
callq 0xfa82
jmp 0x1cdbb
movq %rbx, %rdi
callq 0x1cf08
testl %eax, %eax
je 0x1cdb9
leaq 0x329c1(%rip), %rdx # 0x4f758
leaq 0x3363e(%rip), %r8 # 0x503dc
movq %rbx, %rdi
movl $0x1, %esi
movl $0x7ad, %ecx # imm = 0x7AD
xorl %eax, %eax
callq 0xf997
movl $0xffff8500, %ebp # imm = 0xFFFF8500
jmp 0x1cdbb
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_cli.c |
ssl_write_server_hello_done | static int ssl_write_server_hello_done( mbedtls_ssl_context *ssl )
{
int ret;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write server hello done" ) );
ssl->out_msglen = 4;
ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;
ssl->out_msg[0] = MBEDTLS_SSL_HS_SERVER_HELLO_DONE;
ssl->state++;
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
mbedtls_ssl_send_flight_completed( ssl );
#endif
if( ( ret = mbedtls_ssl_write_record( ssl ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_write_record", ret );
return( ret );
}
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write server hello done" ) );
return( 0 );
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x30db9(%rip), %rdx # 0x50954
leaq 0x31a36(%rip), %r8 # 0x515d8
movl $0x2, %esi
movl $0xbe1, %ecx # imm = 0xBE1
xorl %eax, %eax
callq 0xf997
movq $0x4, 0x158(%rbx)
movl $0x16, 0x150(%rbx)
movq 0x148(%rbx), %rax
movb $0xe, (%rax)
incl 0x8(%rbx)
movq (%rbx), %rax
testb $0x2, 0x174(%rax)
je 0x1fbe9
movq %rbx, %rdi
callq 0x13868
movq %rbx, %rdi
callq 0x12b2b
movl %eax, %ebp
leaq 0x30d5a(%rip), %rdx # 0x50954
testl %eax, %eax
je 0x1fc1c
leaq 0x2cce4(%rip), %r8 # 0x4c8e9
movq %rbx, %rdi
movl $0x1, %esi
movl $0xbf0, %ecx # imm = 0xBF0
movl %ebp, %r9d
callq 0xfa82
jmp 0x1fc37
leaq 0x319d0(%rip), %r8 # 0x515f3
movq %rbx, %rdi
movl $0x2, %esi
movl $0xbf4, %ecx # imm = 0xBF4
xorl %eax, %eax
callq 0xf997
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_srv.c |
ssl_parse_signature_algorithms_ext | static int ssl_parse_signature_algorithms_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
size_t sig_alg_list_size;
const unsigned char *p;
const unsigned char *end = buf + len;
const int *md_cur;
sig_alg_list_size = ( ( buf[0] << 8 ) | ( buf[1] ) );
if( sig_alg_list_size + 2 != len ||
sig_alg_list_size % 2 != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
/*
* For now, ignore the SignatureAlgorithm part and rely on offered
* ciphersuites only for that part. To be fixed later.
*
* So, just look at the HashAlgorithm part.
*/
for( md_cur = ssl->conf->sig_hashes; *md_cur != MBEDTLS_MD_NONE; md_cur++ ) {
for( p = buf + 2; p < end; p += 2 ) {
if( *md_cur == (int) mbedtls_ssl_md_alg_from_hash( p[0] ) ) {
ssl->handshake->sig_alg = p[0];
goto have_sig_alg;
}
}
}
/* Some key echanges do not need signatures at all */
MBEDTLS_SSL_DEBUG_MSG( 3, ( "no signature_algorithm in common" ) );
return( 0 );
have_sig_alg:
MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello v3, signature_algorithm ext: %d",
ssl->handshake->sig_alg ) );
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzbl 0x1(%rsi), %eax
testb $0x1, %al
jne 0x20a57
movq %rdx, %r14
movq %rsi, %r15
movzbl (%rsi), %ecx
shll $0x8, %ecx
addq %rcx, %rax
addq $0x2, %rax
cmpq %rdx, %rax
jne 0x20a57
movq (%rbx), %rax
movq 0xe8(%rax), %r12
cmpl $0x0, (%r12)
je 0x20a31
addq %r15, %r14
addq $0x2, %r15
movq %r15, %r13
cmpq %r14, %r13
jae 0x20a24
movl (%r12), %ebp
movzbl (%r13), %edi
callq 0x18981
addq $0x2, %r13
cmpl %eax, %ebp
jne 0x20a07
jmp 0x20a80
cmpl $0x0, 0x4(%r12)
leaq 0x4(%r12), %r12
jne 0x20a04
leaq 0x2ff1c(%rip), %rdx # 0x50954
leaq 0x30460(%rip), %r8 # 0x50e9f
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x3, %esi
movl $0xdf, %ecx
xorl %eax, %eax
callq 0xf997
jmp 0x20ab0
leaq 0x2fef6(%rip), %rdx # 0x50954
leaq 0x2ffa4(%rip), %r8 # 0x50a09
movq %rbx, %rdi
movl $0x1, %esi
movl $0xcb, %ecx
xorl %eax, %eax
callq 0xf997
movl $0xffff8700, %ebp # imm = 0xFFFF8700
jmp 0x20ab0
movzbl -0x2(%r13), %r9d
movq 0x60(%rbx), %rax
movl %r9d, (%rax)
leaq 0x2fec1(%rip), %rdx # 0x50954
leaq 0x30426(%rip), %r8 # 0x50ec0
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x3, %esi
movl $0xe4, %ecx
xorl %eax, %eax
callq 0xf997
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_srv.c |
ssl_parse_truncated_hmac_ext | static int ssl_parse_truncated_hmac_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
if( len != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
((void) buf);
if( ssl->conf->trunc_hmac == MBEDTLS_SSL_TRUNC_HMAC_ENABLED )
ssl->session_negotiate->trunc_hmac = MBEDTLS_SSL_TRUNC_HMAC_ENABLED;
return( 0 );
} | testq %rsi, %rsi
je 0x20cd1
pushq %rax
leaq 0x2fca5(%rip), %rdx # 0x50954
leaq 0x2fd53(%rip), %r8 # 0x50a09
movl $0x1, %esi
movl $0x17b, %ecx # imm = 0x17B
xorl %eax, %eax
callq 0xf997
movl $0xffff8700, %eax # imm = 0xFFFF8700
addq $0x8, %rsp
retq
movq (%rdi), %rcx
xorl %eax, %eax
testb $-0x80, 0x175(%rcx)
je 0x20ced
movq 0x58(%rdi), %rcx
movl $0x1, 0x90(%rcx)
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_srv.c |
ssl_parse_session_ticket_ext | static int ssl_parse_session_ticket_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t len )
{
int ret;
mbedtls_ssl_session session;
mbedtls_ssl_session_init( &session );
if( ssl->conf->f_ticket_parse == NULL ||
ssl->conf->f_ticket_write == NULL )
{
return( 0 );
}
/* Remember the client asked us to send a new ticket */
ssl->handshake->new_session_ticket = 1;
MBEDTLS_SSL_DEBUG_MSG( 3, ( "ticket length: %d", len ) );
if( len == 0 )
return( 0 );
#if defined(MBEDTLS_SSL_RENEGOTIATION)
if( ssl->renego_status != MBEDTLS_SSL_INITIAL_HANDSHAKE )
{
MBEDTLS_SSL_DEBUG_MSG( 3, ( "ticket rejected: renegotiating" ) );
return( 0 );
}
#endif /* MBEDTLS_SSL_RENEGOTIATION */
/*
* Failures are ok: just ignore the ticket and proceed.
*/
if( ( ret = ssl->conf->f_ticket_parse( ssl->conf->p_ticket, &session,
buf, len ) ) != 0 )
{
mbedtls_ssl_session_free( &session );
if( ret == MBEDTLS_ERR_SSL_INVALID_MAC )
MBEDTLS_SSL_DEBUG_MSG( 3, ( "ticket is not authentic" ) );
else if( ret == MBEDTLS_ERR_SSL_SESSION_TICKET_EXPIRED )
MBEDTLS_SSL_DEBUG_MSG( 3, ( "ticket is expired" ) );
else
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_ticket_parse", ret );
return( 0 );
}
/*
* Keep the session ID sent by the client, since we MUST send it back to
* inform them we're accepting the ticket (RFC 5077 section 3.4)
*/
session.id_len = ssl->session_negotiate->id_len;
memcpy( &session.id, ssl->session_negotiate->id, session.id_len );
mbedtls_ssl_session_free( ssl->session_negotiate );
memcpy( ssl->session_negotiate, &session, sizeof( mbedtls_ssl_session ) );
/* Zeroize instead of free as we copied the content */
mbedtls_zeroize( &session, sizeof( mbedtls_ssl_session ) );
MBEDTLS_SSL_DEBUG_MSG( 3, ( "session successfully restored from ticket" ) );
ssl->handshake->resume = 1;
/* Don't send a new ticket after all, this one is OK */
ssl->handshake->new_session_ticket = 0;
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x16b45
movq (%rbx), %rax
cmpq $0x0, 0xa8(%rax)
je 0x20e27
cmpq $0x0, 0xa0(%rax)
je 0x20e27
movq 0x60(%rbx), %rax
movl $0x1, 0xa8c(%rax)
leaq 0x2fb78(%rip), %rdx # 0x50954
leaq 0x2fa51(%rip), %r8 # 0x50834
movq %rbx, %rdi
movl $0x3, %esi
movl $0x1c9, %ecx # imm = 0x1C9
movq %r14, %r9
xorl %eax, %eax
callq 0xf997
testq %r14, %r14
je 0x20e27
cmpl $0x0, 0xc(%rbx)
je 0x20e35
leaq 0x2fb48(%rip), %rdx # 0x50954
leaq 0x300da(%rip), %r8 # 0x50eed
movq %rbx, %rdi
movl $0x3, %esi
movl $0x1d1, %ecx # imm = 0x1D1
xorl %eax, %eax
callq 0xf997
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rax
movq 0xb0(%rax), %rdi
movq %rsp, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq *0xa8(%rax)
testl %eax, %eax
je 0x20e91
movl %eax, %ebp
movq %rsp, %rdi
callq 0x166fa
leaq 0x2faf1(%rip), %rdx # 0x50954
cmpl $0xffff9280, %ebp # imm = 0xFFFF9280
je 0x20f14
cmpl $0xffff8e80, %ebp # imm = 0xFFFF8E80
jne 0x20f2d
leaq 0x3008a(%rip), %r8 # 0x50f0c
movq %rbx, %rdi
movl $0x3, %esi
movl $0x1df, %ecx # imm = 0x1DF
jmp 0x20e20
movq 0x58(%rbx), %r14
movq 0x10(%r14), %rdx
leaq 0x18(%rsp), %rdi
movq %rdx, -0x8(%rdi)
leaq 0x18(%r14), %rsi
callq 0xf240
movq %r14, %rdi
callq 0x166fa
movq 0x58(%rbx), %rdi
movq %rsp, %rsi
movl $0x98, %edx
callq 0xf240
xorl %eax, %eax
movb $0x0, (%rsp,%rax)
incq %rax
cmpq $0x98, %rax
jne 0x20ec6
leaq 0x2fa78(%rip), %rdx # 0x50954
leaq 0x3006c(%rip), %r8 # 0x50f4f
movq %rbx, %rdi
movl $0x3, %esi
movl $0x1f5, %ecx # imm = 0x1F5
xorl %eax, %eax
callq 0xf997
movq 0x60(%rbx), %rax
movl $0x1, 0xa7c(%rax)
movl $0x0, 0xa8c(%rax)
jmp 0x20e27
leaq 0x30009(%rip), %r8 # 0x50f24
movq %rbx, %rdi
movl $0x3, %esi
movl $0x1e1, %ecx # imm = 0x1E1
jmp 0x20e20
leaq 0x30002(%rip), %r8 # 0x50f36
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1e3, %ecx # imm = 0x1E3
movl %ebp, %r9d
callq 0xfa82
jmp 0x20e27
| /Dragonchang[P]https_client/mbedtls/library/ssl_srv.c |
ssl_parse_alpn_ext | static int ssl_parse_alpn_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf, size_t len )
{
size_t list_len, cur_len, ours_len;
const unsigned char *theirs, *start, *end;
const char **ours;
/* If ALPN not configured, just ignore the extension */
if( ssl->conf->alpn_list == NULL )
return( 0 );
/*
* opaque ProtocolName<1..2^8-1>;
*
* struct {
* ProtocolName protocol_name_list<2..2^16-1>
* } ProtocolNameList;
*/
/* Min length is 2 (list_len) + 1 (name_len) + 1 (name) */
if( len < 4 )
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
list_len = ( buf[0] << 8 ) | buf[1];
if( list_len != len - 2 )
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
/*
* Use our order of preference
*/
start = buf + 2;
end = buf + len;
for( ours = ssl->conf->alpn_list; *ours != NULL; ours++ )
{
ours_len = strlen( *ours );
for( theirs = start; theirs != end; theirs += cur_len )
{
/* If the list is well formed, we should get equality first */
if( theirs > end )
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
cur_len = *theirs++;
/* Empty strings MUST NOT be included */
if( cur_len == 0 )
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
if( cur_len == ours_len &&
memcmp( theirs, *ours, cur_len ) == 0 )
{
ssl->alpn_chosen = *ours;
return( 0 );
}
}
}
/* If we get there, no match was found */
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_NO_APPLICATION_PROTOCOL );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rdi), %rax
movq 0x148(%rax), %r12
xorl %ebx, %ebx
testq %r12, %r12
je 0x21035
movq %rdx, %r15
movl $0xffff8700, %ebx # imm = 0xFFFF8700
cmpq $0x4, %rdx
jb 0x21035
movzwl (%rsi), %eax
rolw $0x8, %ax
movzwl %ax, %eax
leaq -0x2(%r15), %rcx
cmpq %rcx, %rax
jne 0x21035
movq (%r12), %rax
movq %rax, (%rsp)
testq %rax, %rax
je 0x21012
leaq 0x2(%rsi), %rbp
addq %rsi, %r15
movq %rdi, 0x8(%rsp)
movq %rbp, 0x10(%rsp)
movq (%rsp), %rdi
callq 0xf100
movq %rax, %r13
cmpq %r15, %rbp
ja 0x21035
movzbl (%rbp), %r14d
testq %r14, %r14
je 0x21035
incq %rbp
cmpq %r14, %r13
jne 0x20fee
movq %rbp, %rdi
movq (%rsp), %rsi
movq %r13, %rdx
callq 0xf2b0
testl %eax, %eax
je 0x21023
addq %r14, %rbp
cmpq %r15, %rbp
jne 0x20fc4
movq 0x8(%r12), %rax
addq $0x8, %r12
movq %rax, (%rsp)
testq %rax, %rax
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rbp
jne 0x20fb8
movl $0x2, %esi
movl $0x78, %edx
callq 0x15727
jmp 0x21035
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x178(%rax)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_srv.c |
ssl_parse_client_psk_identity | static int ssl_parse_client_psk_identity( mbedtls_ssl_context *ssl, unsigned char **p,
const unsigned char *end )
{
int ret = 0;
size_t n;
if( ssl->conf->f_psk == NULL &&
( ssl->conf->psk == NULL || ssl->conf->psk_identity == NULL ||
ssl->conf->psk_identity_len == 0 || ssl->conf->psk_len == 0 ) )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "got no pre-shared key" ) );
return( MBEDTLS_ERR_SSL_PRIVATE_KEY_REQUIRED );
}
/*
* Receive client pre-shared key identity name
*/
if( *p + 2 > end )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
}
n = ( (*p)[0] << 8 ) | (*p)[1];
*p += 2;
if( n < 1 || n > 65535 || *p + n > end )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
}
if( ssl->conf->f_psk != NULL )
{
if( ssl->conf->f_psk( ssl->conf->p_psk, ssl, *p, n ) != 0 )
ret = MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY;
}
else
{
/* Identity is not a big secret since clients send it in the clear,
* but treat it carefully anyway, just in case */
if( n != ssl->conf->psk_identity_len ||
mbedtls_ssl_safer_memcmp( ssl->conf->psk_identity, *p, n ) != 0 )
{
ret = MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY;
}
}
if( ret == MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY )
{
MBEDTLS_SSL_DEBUG_BUF( 3, "Unknown PSK identity", *p, n );
if( ( ret = mbedtls_ssl_send_alert_message( ssl,
MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_UNKNOWN_PSK_IDENTITY ) ) != 0 )
{
return( ret );
}
return( MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY );
}
*p += n;
return( 0 );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
cmpq $0x0, 0x78(%rax)
je 0x2153d
movq (%r14), %rax
leaq 0x2(%rax), %r9
cmpq %rdx, %r9
jbe 0x2158e
leaq 0x2f430(%rip), %rdx # 0x50954
leaq 0x30100(%rip), %r8 # 0x5162b
movq %rbx, %rdi
movl $0x1, %esi
movl $0xc9c, %ecx # imm = 0xC9C
jmp 0x215cf
cmpq $0x0, 0x128(%rax)
je 0x21565
cmpq $0x0, 0x138(%rax)
je 0x21565
cmpq $0x0, 0x140(%rax)
je 0x21565
cmpq $0x0, 0x130(%rax)
jne 0x21511
leaq 0x2f3e8(%rip), %rdx # 0x50954
leaq 0x301c8(%rip), %r8 # 0x5173b
movq %rbx, %rdi
movl $0x1, %esi
movl $0xc93, %ecx # imm = 0xC93
xorl %eax, %eax
callq 0xf997
movl $0xffff8a00, %eax # imm = 0xFFFF8A00
jmp 0x215db
movzwl (%rax), %eax
rolw $0x8, %ax
movzwl %ax, %r15d
movq %r9, (%r14)
testw %r15w, %r15w
sete %al
leaq (%r9,%r15), %rcx
cmpq %rdx, %rcx
seta %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x215e5
leaq 0x2f399(%rip), %rdx # 0x50954
leaq 0x30069(%rip), %r8 # 0x5162b
movq %rbx, %rdi
movl $0x1, %esi
movl $0xca5, %ecx # imm = 0xCA5
xorl %eax, %eax
callq 0xf997
movl $0xffff8400, %eax # imm = 0xFFFF8400
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq (%rbx), %rcx
movq 0x78(%rcx), %rax
testq %rax, %rax
je 0x2160c
movq 0x80(%rcx), %rdi
movq %rbx, %rsi
movq %r9, %rdx
movq %r15, %rcx
callq *%rax
movq (%r14), %r9
testl %eax, %eax
jne 0x21637
jmp 0x2167e
cmpq 0x140(%rcx), %r15
jne 0x21637
movq 0x138(%rcx), %rcx
xorl %eax, %eax
xorl %edx, %edx
movb (%r9,%rdx), %sil
xorb (%rcx,%rdx), %sil
orb %sil, %al
incq %rdx
cmpq %rdx, %r15
jne 0x21620
testb %al, %al
je 0x2167e
movq %r15, (%rsp)
leaq 0x2f312(%rip), %rdx # 0x50954
leaq 0x30108(%rip), %r8 # 0x51751
movq %rbx, %rdi
movl $0x3, %esi
movl $0xcbb, %ecx # imm = 0xCBB
callq 0xfb06
movq %rbx, %rdi
movl $0x2, %esi
movl $0x73, %edx
callq 0x15727
movl %eax, %ecx
testl %eax, %eax
movl $0xffff9380, %eax # imm = 0xFFFF9380
cmovnel %ecx, %eax
jmp 0x215db
addq %r15, %r9
movq %r9, (%r14)
xorl %eax, %eax
jmp 0x215db
| /Dragonchang[P]https_client/mbedtls/library/ssl_srv.c |
mbedtls_x509_crt_parse_der | int mbedtls_x509_crt_parse_der( mbedtls_x509_crt *chain, const unsigned char *buf,
size_t buflen )
{
int ret;
mbedtls_x509_crt *crt = chain, *prev = NULL;
/*
* Check for valid input
*/
if( crt == NULL || buf == NULL )
return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
while( crt->version != 0 && crt->next != NULL )
{
prev = crt;
crt = crt->next;
}
/*
* Add new certificate on the end of the chain if needed.
*/
if( crt->version != 0 && crt->next == NULL )
{
crt->next = mbedtls_calloc( 1, sizeof( mbedtls_x509_crt ) );
if( crt->next == NULL )
return( MBEDTLS_ERR_X509_ALLOC_FAILED );
prev = crt;
mbedtls_x509_crt_init( crt->next );
crt = crt->next;
}
if( ( ret = x509_crt_parse_der_core( crt, buf, buflen ) ) != 0 )
{
if( prev )
prev->next = NULL;
if( crt != chain )
mbedtls_free( crt );
return( ret );
}
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movl $0xffffd800, %ebp # imm = 0xFFFFD800
jne 0x219fc
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
cmpl $0x0, 0x30(%rdi)
je 0x21925
movq %r13, %r14
movq %r14, %rbx
movq 0x220(%r14), %r14
testq %r14, %r14
je 0x2192c
cmpl $0x0, 0x30(%r14)
jne 0x2190d
jmp 0x21961
xorl %ebx, %ebx
movq %r13, %r14
jmp 0x21961
movl $0x1, %edi
movl $0x228, %esi # imm = 0x228
callq 0xf1d0
movq %rax, 0x220(%rbx)
testq %rax, %rax
je 0x21a0d
movl $0x228, %edx # imm = 0x228
movq %rax, %rdi
xorl %esi, %esi
callq 0xf150
movq 0x220(%rbx), %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
xorl %eax, %eax
movq %rax, 0x30(%rsp)
movaps %xmm0, 0x60(%rsp)
movq %rax, 0x70(%rsp)
movaps %xmm0, 0x40(%rsp)
movq %rax, 0x50(%rsp)
testq %r14, %r14
je 0x219da
movq %r13, 0x18(%rsp)
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x8(%rsp), %rdx
movq %r15, (%rdx)
addq %r12, %r15
movq %r15, %rsi
movl $0x30, %ecx
callq 0x2539d
movl $0xffffde80, %ebp # imm = 0xFFFFDE80
testl %eax, %eax
jne 0x219cb
movq 0x8(%rsp), %rbp
movq (%rsp), %r13
subq %r13, %r15
cmpq %r15, %rbp
jbe 0x21a14
movl $0xffffde1a, %ebp # imm = 0xFFFFDE1A
movq %r14, %rdi
callq 0x2387e
movq 0x18(%rsp), %r13
jmp 0x219df
movl $0xffffd800, %ebp # imm = 0xFFFFD800
testq %rbx, %rbx
je 0x219ef
movq $0x0, 0x220(%rbx)
cmpq %r13, %r14
je 0x219fc
movq %r14, %rdi
callq 0xf030
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffd780, %ebp # imm = 0xFFFFD780
jmp 0x219fc
addq %rbp, %r13
subq %r12, %r13
movq %r13, 0x8(%r14)
movl $0x1, %edi
movq %r13, %rsi
callq 0xf1d0
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x21a93
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xf240
movq %r13, %rax
subq %rbp, %rax
addq %r15, %rax
movq %rsp, %rdi
movq %rax, (%rdi)
addq %r13, %r15
movq %rax, 0x28(%r14)
leaq 0x8(%rsp), %rdx
movq %r15, %rsi
movl $0x30, %ecx
callq 0x2539d
testl %eax, %eax
je 0x21a9d
movl %eax, %ebp
movq 0x18(%rsp), %r13
movq %r14, %rdi
callq 0x2387e
addl $0xffffde80, %ebp # imm = 0xFFFFDE80
jne 0x219df
xorl %ebp, %ebp
jmp 0x219fc
movl $0xffffd780, %ebp # imm = 0xFFFFD780
jmp 0x219d3
movq %rsp, %rdi
movq (%rdi), %r12
addq 0x8(%rsp), %r12
movq %r12, %rax
subq 0x28(%r14), %rax
movq %rax, 0x20(%r14)
leaq 0x30(%r14), %rax
movq %rax, 0x10(%rsp)
leaq 0x38(%rsp), %rdx
movq %r12, %rsi
movl $0xa0, %ecx
callq 0x2539d
testl %eax, %eax
je 0x21ae6
movl %eax, %ebp
cmpl $-0x62, %eax
jne 0x21b0a
movq 0x10(%rsp), %rax
movl $0x0, (%rax)
jmp 0x21b12
movq %rsp, %rdi
movq (%rdi), %r13
addq 0x38(%rsp), %r13
movq %r13, %rsi
movq 0x10(%rsp), %rdx
callq 0x2542e
testl %eax, %eax
je 0x21b47
movl %eax, %ebp
addl $0xffffde00, %ebp # imm = 0xFFFFDE00
testl %ebp, %ebp
jne 0x219cb
leaq 0x38(%r14), %rdx
movq %rsp, %rdi
movq %r12, %rsi
callq 0x242c8
testl %eax, %eax
jne 0x21b40
leaq 0x50(%r14), %r13
movq %rsp, %rdi
leaq 0x20(%rsp), %rcx
movq %r12, %rsi
movq %r13, %rdx
callq 0x24349
testl %eax, %eax
je 0x21b57
movl %eax, %ebp
jmp 0x219cb
cmpq %r13, (%rsp)
je 0x21b12
movl $0xffffdd9a, %ebp # imm = 0xFFFFDD9A
jmp 0x219cb
movq 0x10(%rsp), %rdx
movl (%rdx), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%rdx)
movl $0xffffda80, %ebp # imm = 0xFFFFDA80
cmpl $0x2, %eax
jg 0x219cb
leaq 0x210(%r14), %rdx
leaq 0x214(%r14), %rcx
leaq 0x218(%r14), %r8
leaq 0x20(%rsp), %rsi
movq %r13, %rdi
callq 0x24ae2
testl %eax, %eax
jne 0x21b40
movq %rsp, %rdi
movq (%rdi), %rax
movq %rax, 0x78(%r14)
leaq 0x8(%rsp), %rdx
movq %r12, %rsi
movl $0x30, %ecx
callq 0x2539d
testl %eax, %eax
jne 0x21a71
movq %rsp, %rdi
movq (%rdi), %rsi
addq 0x8(%rsp), %rsi
leaq 0x98(%r14), %rdx
callq 0x246a4
testl %eax, %eax
jne 0x21b40
movq %rsp, %rdi
movq (%rdi), %rax
subq 0x78(%r14), %rax
movq %rax, 0x70(%r14)
leaq 0x118(%r14), %rdx
leaq 0x130(%r14), %rcx
movq %r12, %rsi
callq 0x239c6
testl %eax, %eax
jne 0x21b40
movq %rsp, %rdi
movq (%rdi), %rax
movq %rax, 0x90(%r14)
leaq 0x8(%rsp), %rdx
movq %r12, %rsi
movl $0x30, %ecx
callq 0x2539d
testl %eax, %eax
jne 0x21a71
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x21c51
movq %rsp, %rdi
addq (%rdi), %rsi
leaq 0xd8(%r14), %rdx
callq 0x246a4
testl %eax, %eax
jne 0x21b40
movq %rsp, %rdi
movq (%rdi), %rax
subq 0x90(%r14), %rax
movq %rax, 0x88(%r14)
leaq 0x148(%r14), %rdx
movq %r12, %rsi
callq 0x3bf86
testl %eax, %eax
jne 0x21b40
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0x2, %ecx
jne 0x21cb3
leaq 0x158(%r14), %rdx
movq %rsp, %rdi
movq %r12, %rsi
movl $0x1, %ecx
callq 0x23a33
testl %eax, %eax
jne 0x21b40
movq 0x10(%rsp), %rax
movl (%rax), %eax
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0x21cfa
leaq 0x170(%r14), %rdx
movq %rsp, %rdi
movq %r12, %rsi
movl $0x2, %ecx
callq 0x23a33
testl %eax, %eax
jne 0x21b40
movq 0x10(%rsp), %rax
cmpl $0x3, (%rax)
jne 0x21cfa
movq %rsp, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x23a7d
testl %eax, %eax
jne 0x21b40
cmpq %r12, (%rsp)
jne 0x219c6
movq %rsp, %rdi
leaq 0x40(%rsp), %rdx
leaq 0x60(%rsp), %rcx
movq %r15, %rsi
callq 0x24349
testl %eax, %eax
jne 0x21b40
movq 0x58(%r14), %rdx
movl $0xffffd980, %ebp # imm = 0xFFFFD980
cmpq 0x48(%rsp), %rdx
jne 0x219cb
movq 0x60(%r14), %rdi
movq 0x50(%rsp), %rsi
callq 0xf2b0
testl %eax, %eax
jne 0x219cb
movq 0x28(%rsp), %rdx
cmpq 0x68(%rsp), %rdx
jne 0x219cb
testq %rdx, %rdx
je 0x21d77
movq 0x30(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0xf2b0
testl %eax, %eax
jne 0x219cb
leaq 0x1f8(%r14), %rdx
movq %rsp, %rdi
movq %r15, %rsi
callq 0x24a84
testl %eax, %eax
jne 0x21b40
movl $0xffffde1a, %ebp # imm = 0xFFFFDE1A
cmpq %r15, (%rsp)
jne 0x219cb
jmp 0x21a8c
| /Dragonchang[P]https_client/mbedtls/library/x509_crt.c |
mbedtls_x509_crt_parse | int mbedtls_x509_crt_parse( mbedtls_x509_crt *chain, const unsigned char *buf, size_t buflen )
{
#if defined(MBEDTLS_PEM_PARSE_C)
int success = 0, first_error = 0, total_failed = 0;
int buf_format = MBEDTLS_X509_FORMAT_DER;
#endif
/*
* Check for valid input
*/
if( chain == NULL || buf == NULL )
return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
/*
* Determine buffer content. Buffer contains either one DER certificate or
* one or more PEM certificates.
*/
#if defined(MBEDTLS_PEM_PARSE_C)
if( buflen != 0 && buf[buflen - 1] == '\0' &&
strstr( (const char *) buf, "-----BEGIN CERTIFICATE-----" ) != NULL )
{
buf_format = MBEDTLS_X509_FORMAT_PEM;
}
if( buf_format == MBEDTLS_X509_FORMAT_DER )
return mbedtls_x509_crt_parse_der( chain, buf, buflen );
#else
return mbedtls_x509_crt_parse_der( chain, buf, buflen );
#endif
#if defined(MBEDTLS_PEM_PARSE_C)
if( buf_format == MBEDTLS_X509_FORMAT_PEM )
{
int ret;
mbedtls_pem_context pem;
/* 1 rather than 0 since the terminating NULL byte is counted in */
while( buflen > 1 )
{
size_t use_len;
mbedtls_pem_init( &pem );
/* If we get there, we know the string is null-terminated */
ret = mbedtls_pem_read_buffer( &pem,
"-----BEGIN CERTIFICATE-----",
"-----END CERTIFICATE-----",
buf, NULL, 0, &use_len );
if( ret == 0 )
{
/*
* Was PEM encoded
*/
buflen -= use_len;
buf += use_len;
}
else if( ret == MBEDTLS_ERR_PEM_BAD_INPUT_DATA )
{
return( ret );
}
else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
{
mbedtls_pem_free( &pem );
/*
* PEM header and footer were found
*/
buflen -= use_len;
buf += use_len;
if( first_error == 0 )
first_error = ret;
total_failed++;
continue;
}
else
break;
ret = mbedtls_x509_crt_parse_der( chain, pem.buf, pem.buflen );
mbedtls_pem_free( &pem );
if( ret != 0 )
{
/*
* Quit parsing on a memory error
*/
if( ret == MBEDTLS_ERR_X509_ALLOC_FAILED )
return( ret );
if( first_error == 0 )
first_error = ret;
total_failed++;
continue;
}
success = 1;
}
}
if( success )
return( total_failed );
else if( first_error )
return( first_error );
else
return( MBEDTLS_ERR_X509_CERT_UNKNOWN_FORMAT );
#endif /* MBEDTLS_PEM_PARSE_C */
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movl $0xffffd800, %eax # imm = 0xFFFFD800
je 0x21de3
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x21df9
cmpb $0x0, -0x1(%r14,%rbx)
je 0x21e15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x218d4
leaq 0x33479(%rip), %rsi # 0x55295
movq %r14, %rdi
callq 0xf360
testq %rax, %rax
je 0x21df9
cmpq $0x1, %rbx
jne 0x21e36
movl $0xffffd880, %eax # imm = 0xFFFFD880
jmp 0x21dd4
movq $0x0, 0x18(%rsp)
leaq 0x30(%rsp), %r12
movl $0x0, 0x14(%rsp)
movl $0x0, 0x24(%rsp)
movq %r12, %rdi
callq 0x3a51c
leaq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq %r12, %rdi
leaq 0x33426(%rip), %rsi # 0x55295
leaq 0x3343b(%rip), %rdx # 0x552b1
movq %r14, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x3a52b
testl %eax, %eax
je 0x21eac
movl %eax, %ebp
cmpl $0xffffeb80, %eax # imm = 0xFFFFEB80
je 0x21f34
cmpl $0xffffef80, %ebp # imm = 0xFFFFEF80
je 0x21f11
movq %r12, %rdi
callq 0x3acf0
movq 0x28(%rsp), %r13
jmp 0x21ed9
movq 0x28(%rsp), %r13
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq %r15, %rdi
callq 0x218d4
movl %eax, %ebp
movq %r12, %rdi
callq 0x3acf0
testl %ebp, %ebp
je 0x21ef4
cmpl $0xffffd780, %ebp # imm = 0xFFFFD780
je 0x21f34
movl 0x14(%rsp), %eax
testl %eax, %eax
cmovel %ebp, %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
incl %eax
movq %rax, 0x18(%rsp)
jmp 0x21efc
movl $0x1, 0x24(%rsp)
subq %r13, %rbx
addq %r13, %r14
cmpq $0x1, %rbx
leaq 0x30(%rsp), %r12
ja 0x21e54
cmpl $0x0, 0x24(%rsp)
movq 0x18(%rsp), %rax
jne 0x21dd4
movl 0x14(%rsp), %ecx
movl %ecx, %eax
testl %ecx, %ecx
jne 0x21dd4
jmp 0x21e2f
movl %ebp, %eax
jmp 0x21dd4
| /Dragonchang[P]https_client/mbedtls/library/x509_crt.c |
mbedtls_x509_crt_info | int mbedtls_x509_crt_info( char *buf, size_t size, const char *prefix,
const mbedtls_x509_crt *crt )
{
int ret;
size_t n;
char *p;
char key_size_str[BEFORE_COLON];
p = buf;
n = size;
if( NULL == crt )
{
ret = mbedtls_snprintf( p, n, "\nCertificate is uninitialised!\n" );
MBEDTLS_X509_SAFE_SNPRINTF;
return( (int) ( size - n ) );
}
ret = mbedtls_snprintf( p, n, "%scert. version : %d\n",
prefix, crt->version );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_snprintf( p, n, "%sserial number : ",
prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_x509_serial_gets( p, n, &crt->serial );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_snprintf( p, n, "\n%sissuer name : ", prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_x509_dn_gets( p, n, &crt->issuer );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_snprintf( p, n, "\n%ssubject name : ", prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_x509_dn_gets( p, n, &crt->subject );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_snprintf( p, n, "\n%sissued on : " \
"%04d-%02d-%02d %02d:%02d:%02d", prefix,
crt->valid_from.year, crt->valid_from.mon,
crt->valid_from.day, crt->valid_from.hour,
crt->valid_from.min, crt->valid_from.sec );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_snprintf( p, n, "\n%sexpires on : " \
"%04d-%02d-%02d %02d:%02d:%02d", prefix,
crt->valid_to.year, crt->valid_to.mon,
crt->valid_to.day, crt->valid_to.hour,
crt->valid_to.min, crt->valid_to.sec );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_snprintf( p, n, "\n%ssigned using : ", prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_x509_sig_alg_gets( p, n, &crt->sig_oid, crt->sig_pk,
crt->sig_md, crt->sig_opts );
MBEDTLS_X509_SAFE_SNPRINTF;
/* Key size */
if( ( ret = mbedtls_x509_key_size_helper( key_size_str, BEFORE_COLON,
mbedtls_pk_get_name( &crt->pk ) ) ) != 0 )
{
return( ret );
}
ret = mbedtls_snprintf( p, n, "\n%s%-" BC "s: %d bits", prefix, key_size_str,
(int) mbedtls_pk_get_bitlen( &crt->pk ) );
MBEDTLS_X509_SAFE_SNPRINTF;
/*
* Optional extensions
*/
if( crt->ext_types & MBEDTLS_X509_EXT_BASIC_CONSTRAINTS )
{
ret = mbedtls_snprintf( p, n, "\n%sbasic constraints : CA=%s", prefix,
crt->ca_istrue ? "true" : "false" );
MBEDTLS_X509_SAFE_SNPRINTF;
if( crt->max_pathlen > 0 )
{
ret = mbedtls_snprintf( p, n, ", max_pathlen=%d", crt->max_pathlen - 1 );
MBEDTLS_X509_SAFE_SNPRINTF;
}
}
if( crt->ext_types & MBEDTLS_X509_EXT_SUBJECT_ALT_NAME )
{
ret = mbedtls_snprintf( p, n, "\n%ssubject alt name : ", prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
if( ( ret = x509_info_subject_alt_name( &p, &n,
&crt->subject_alt_names ) ) != 0 )
return( ret );
}
if( crt->ext_types & MBEDTLS_X509_EXT_NS_CERT_TYPE )
{
ret = mbedtls_snprintf( p, n, "\n%scert. type : ", prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
if( ( ret = x509_info_cert_type( &p, &n, crt->ns_cert_type ) ) != 0 )
return( ret );
}
if( crt->ext_types & MBEDTLS_X509_EXT_KEY_USAGE )
{
ret = mbedtls_snprintf( p, n, "\n%skey usage : ", prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
if( ( ret = x509_info_key_usage( &p, &n, crt->key_usage ) ) != 0 )
return( ret );
}
if( crt->ext_types & MBEDTLS_X509_EXT_EXTENDED_KEY_USAGE )
{
ret = mbedtls_snprintf( p, n, "\n%sext key usage : ", prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
if( ( ret = x509_info_ext_key_usage( &p, &n,
&crt->ext_key_usage ) ) != 0 )
return( ret );
}
ret = mbedtls_snprintf( p, n, "\n" );
MBEDTLS_X509_SAFE_SNPRINTF;
return( (int) ( size - n ) );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %r13
testq %rcx, %rcx
je 0x22364
movq %rcx, %r15
movq %rdx, %r12
movl 0x30(%rcx), %r8d
leaq 0x3322e(%rip), %rdx # 0x552f1
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rcx
xorl %eax, %eax
callq 0xf120
movl $0xffffd680, %ebx # imm = 0xFFFFD680
testl %eax, %eax
js 0x2238f
movl %eax, %eax
movq %r14, %rbp
subq %rax, %rbp
jbe 0x2238f
addq %rax, %r13
leaq 0x33213(%rip), %rdx # 0x5530b
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rcx
xorl %eax, %eax
callq 0xf120
testl %eax, %eax
js 0x2238f
movl %eax, %eax
subq %rax, %rbp
jbe 0x2238f
addq %rax, %r13
leaq 0x38(%r15), %rdx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x24da7
testl %eax, %eax
js 0x2238f
movl %eax, %eax
subq %rax, %rbp
jbe 0x2238f
addq %rax, %r13
leaq 0x331d8(%rip), %rdx # 0x55322
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rcx
xorl %eax, %eax
callq 0xf120
testl %eax, %eax
js 0x2238f
movl %eax, %eax
subq %rax, %rbp
jbe 0x2238f
addq %rax, %r13
leaq 0x98(%r15), %rdx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x24c0a
testl %eax, %eax
js 0x2238f
movl %eax, %eax
subq %rax, %rbp
jbe 0x2238f
addq %rax, %r13
leaq 0x3319b(%rip), %rdx # 0x5533a
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rcx
xorl %eax, %eax
callq 0xf120
testl %eax, %eax
js 0x2238f
movl %eax, %eax
subq %rax, %rbp
jbe 0x2238f
addq %rax, %r13
leaq 0xd8(%r15), %rdx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x24c0a
testl %eax, %eax
js 0x2238f
movl %eax, %eax
subq %rax, %rbp
jbe 0x2238f
movq %rbp, 0x8(%rsp)
addq %rax, %r13
movq %r13, (%rsp)
movl 0x118(%r15), %r8d
movl 0x11c(%r15), %r9d
movl 0x120(%r15), %eax
movq %rax, 0x18(%rsp)
movl 0x124(%r15), %eax
movq %rax, 0x10(%rsp)
movl 0x128(%r15), %r10d
movl 0x12c(%r15), %r11d
leaq 0x33121(%rip), %rdx # 0x55352
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rcx
xorl %eax, %eax
pushq %r11
pushq %r10
pushq 0x20(%rsp)
pushq 0x30(%rsp)
callq 0xf120
addq $0x20, %rsp
testl %eax, %eax
js 0x2238f
movl %eax, %eax
subq %rax, %rbp
jbe 0x2238f
addq %rax, %r13
movl 0x130(%r15), %r8d
movl 0x134(%r15), %r9d
movl 0x138(%r15), %eax
movq %rax, 0x18(%rsp)
movl 0x13c(%r15), %eax
movq %rax, 0x10(%rsp)
movl 0x140(%r15), %r10d
movl 0x144(%r15), %r11d
leaq 0x330e5(%rip), %rdx # 0x55387
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rcx
xorl %eax, %eax
pushq %r11
pushq %r10
pushq 0x20(%rsp)
pushq 0x30(%rsp)
callq 0xf120
addq $0x20, %rsp
testl %eax, %eax
js 0x2238f
movl %eax, %eax
subq %rax, %rbp
jbe 0x2238f
addq %rax, %r13
leaq 0x330dd(%rip), %rdx # 0x553bc
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rcx
xorl %eax, %eax
callq 0xf120
testl %eax, %eax
js 0x2238f
movl %eax, %eax
subq %rax, %rbp
jbe 0x2238f
addq %rax, %r13
leaq 0x50(%r15), %rdx
movl 0x210(%r15), %r8d
movl 0x214(%r15), %ecx
movq 0x218(%r15), %r9
movq %r13, %rdi
movq %rbp, %rsi
callq 0x24e97
testl %eax, %eax
js 0x2238f
movl %eax, %eax
movq %rax, 0x18(%rsp)
subq %rax, %rbp
jbe 0x2238f
leaq 0x148(%r15), %rdi
movq %rdi, 0x10(%rsp)
callq 0x3b429
leaq 0x20(%rsp), %rdi
movl $0x12, %esi
movq %rax, %rdx
callq 0x24fce
testl %eax, %eax
je 0x223a0
movl %eax, %ebx
jmp 0x2238f
leaq 0x32f66(%rip), %rdx # 0x552d1
movq %r13, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0xf120
movl %eax, %ecx
cmpq %r14, %rcx
movl $0xffffd680, %ebx # imm = 0xFFFFD680
cmovbl %eax, %ebx
movl $0xffffd680, %ecx # imm = 0xFFFFD680
testl %eax, %eax
cmovsl %ecx, %ebx
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq 0x18(%rsp), %r13
movq 0x10(%rsp), %rdi
callq 0x3b3e3
leaq 0x3301e(%rip), %rdx # 0x553d4
leaq 0x20(%rsp), %r8
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rcx
movl %eax, %r9d
xorl %eax, %eax
callq 0xf120
testl %eax, %eax
js 0x2238f
movl %eax, %eax
subq %rax, %rbp
jbe 0x2238f
addq %rax, %r13
testb $0x1, 0x1c1(%r15)
jne 0x22445
movl 0x1c0(%r15), %eax
testb $0x20, %al
jne 0x224cc
btl $0x10, %eax
jb 0x22530
testb $0x4, %al
jne 0x22595
btl $0xb, %eax
jb 0x225f9
leaq 0x3a9c4(%rip), %rdx # 0x5cddc
movq %r13, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0xf120
testl %eax, %eax
js 0x2238f
movl %eax, %eax
cmpq %rbp, %rax
jae 0x2238f
subl %ebp, %eax
addl %eax, %r14d
movl %r14d, %ebx
jmp 0x2238f
cmpl $0x0, 0x1c4(%r15)
leaq 0x32fb4(%rip), %rax # 0x55408
leaq 0x32fa8(%rip), %r8 # 0x55403
cmoveq %rax, %r8
leaq 0x32f80(%rip), %rdx # 0x553e6
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rcx
xorl %eax, %eax
callq 0xf120
testl %eax, %eax
js 0x2238f
movl %eax, %eax
subq %rax, %rbp
jbe 0x2238f
addq %rax, %r13
movl 0x1c8(%r15), %ecx
testl %ecx, %ecx
jle 0x223e6
decl %ecx
leaq 0x32f6a(%rip), %rdx # 0x5540e
movq %r13, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0xf120
testl %eax, %eax
js 0x2238f
movl %eax, %eax
subq %rax, %rbp
jbe 0x2238f
addq %rax, %r13
jmp 0x223e6
leaq 0x32f4c(%rip), %rdx # 0x5541f
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rcx
xorl %eax, %eax
callq 0xf120
testl %eax, %eax
js 0x2238f
movl %eax, %eax
subq %rax, %rbp
jbe 0x2238f
leaq 0x8(%rsp), %rsi
movq %rbp, (%rsi)
addq %rax, %r13
movq %rsp, %rdi
movq %r13, (%rdi)
leaq 0x1a0(%r15), %rdx
callq 0x22659
testl %eax, %eax
jne 0x22360
movl 0x1c0(%r15), %eax
movq (%rsp), %r13
movq 0x8(%rsp), %rbp
jmp 0x223f5
leaq 0x32f00(%rip), %rdx # 0x55437
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rcx
xorl %eax, %eax
callq 0xf120
testl %eax, %eax
js 0x2238f
movl %eax, %eax
subq %rax, %rbp
jbe 0x2238f
leaq 0x8(%rsp), %rsi
movq %rbp, (%rsi)
addq %rax, %r13
movq %rsp, %rdi
movq %r13, (%rdi)
movzbl 0x1f0(%r15), %edx
callq 0x226fe
testl %eax, %eax
jne 0x22360
movl 0x1c0(%r15), %eax
movq (%rsp), %r13
movq 0x8(%rsp), %rbp
jmp 0x223ff
leaq 0x32eb3(%rip), %rdx # 0x5544f
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rcx
xorl %eax, %eax
callq 0xf120
testl %eax, %eax
js 0x2238f
movl %eax, %eax
subq %rax, %rbp
jbe 0x2238f
leaq 0x8(%rsp), %rsi
movq %rbp, (%rsi)
addq %rax, %r13
movq %rsp, %rdi
movq %r13, (%rdi)
movl 0x1cc(%r15), %edx
callq 0x22912
testl %eax, %eax
jne 0x22360
movl 0x1c0(%r15), %eax
movq (%rsp), %r13
movq 0x8(%rsp), %rbp
jmp 0x22407
leaq 0x32e67(%rip), %rdx # 0x55467
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rcx
xorl %eax, %eax
callq 0xf120
testl %eax, %eax
js 0x2238f
movl %eax, %eax
subq %rax, %rbp
jbe 0x2238f
leaq 0x8(%rsp), %rsi
movq %rbp, (%rsi)
addq %rax, %r13
movq %rsp, %rdi
movq %r13, (%rdi)
addq $0x1d0, %r15 # imm = 0x1D0
movq %r15, %rdx
callq 0x22b56
testl %eax, %eax
jne 0x22360
movq (%rsp), %r13
movq 0x8(%rsp), %rbp
jmp 0x22411
| /Dragonchang[P]https_client/mbedtls/library/x509_crt.c |
x509_info_key_usage | static int x509_info_key_usage( char **buf, size_t *size,
unsigned int key_usage )
{
int ret;
size_t n = *size;
char *p = *buf;
const char *sep = "";
KEY_USAGE( MBEDTLS_X509_KU_DIGITAL_SIGNATURE, "Digital Signature" );
KEY_USAGE( MBEDTLS_X509_KU_NON_REPUDIATION, "Non Repudiation" );
KEY_USAGE( MBEDTLS_X509_KU_KEY_ENCIPHERMENT, "Key Encipherment" );
KEY_USAGE( MBEDTLS_X509_KU_DATA_ENCIPHERMENT, "Data Encipherment" );
KEY_USAGE( MBEDTLS_X509_KU_KEY_AGREEMENT, "Key Agreement" );
KEY_USAGE( MBEDTLS_X509_KU_KEY_CERT_SIGN, "Key Cert Sign" );
KEY_USAGE( MBEDTLS_X509_KU_CRL_SIGN, "CRL Sign" );
KEY_USAGE( MBEDTLS_X509_KU_ENCIPHER_ONLY, "Encipher Only" );
KEY_USAGE( MBEDTLS_X509_KU_DECIPHER_ONLY, "Decipher Only" );
*size = n;
*buf = p;
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
movq (%rdi), %r12
testb %bpl, %bpl
js 0x22936
leaq 0x3a4be(%rip), %rcx # 0x5cdf2
jmp 0x22975
leaq 0x32be3(%rip), %rdx # 0x55520
leaq 0x3a4ae(%rip), %rcx # 0x5cdf2
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xf120
movl %eax, %ecx
movl $0xffffd680, %eax # imm = 0xFFFFD680
testl %ecx, %ecx
js 0x22b4d
movl %ecx, %ecx
subq %rcx, %r15
jbe 0x22b4d
addq %rcx, %r12
leaq 0x32b42(%rip), %rcx # 0x554b7
testb $0x40, %bpl
je 0x229b3
leaq 0x32bb2(%rip), %rdx # 0x55534
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xf120
movl %eax, %ecx
movl $0xffffd680, %eax # imm = 0xFFFFD680
testl %ecx, %ecx
js 0x22b4d
movl %ecx, %ecx
subq %rcx, %r15
jbe 0x22b4d
addq %rcx, %r12
leaq 0x32b04(%rip), %rcx # 0x554b7
testb $0x20, %bpl
je 0x229f1
leaq 0x32b86(%rip), %rdx # 0x55546
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xf120
movl %eax, %ecx
movl $0xffffd680, %eax # imm = 0xFFFFD680
testl %ecx, %ecx
js 0x22b4d
movl %ecx, %ecx
subq %rcx, %r15
jbe 0x22b4d
addq %rcx, %r12
leaq 0x32ac6(%rip), %rcx # 0x554b7
testb $0x10, %bpl
je 0x22a2f
leaq 0x32b5b(%rip), %rdx # 0x55559
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xf120
movl %eax, %ecx
movl $0xffffd680, %eax # imm = 0xFFFFD680
testl %ecx, %ecx
js 0x22b4d
movl %ecx, %ecx
subq %rcx, %r15
jbe 0x22b4d
addq %rcx, %r12
leaq 0x32a88(%rip), %rcx # 0x554b7
testb $0x8, %bpl
je 0x22a6d
leaq 0x32b31(%rip), %rdx # 0x5556d
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xf120
movl %eax, %ecx
movl $0xffffd680, %eax # imm = 0xFFFFD680
testl %ecx, %ecx
js 0x22b4d
movl %ecx, %ecx
subq %rcx, %r15
jbe 0x22b4d
addq %rcx, %r12
leaq 0x32a4a(%rip), %rcx # 0x554b7
testb $0x4, %bpl
je 0x22aab
leaq 0x32b03(%rip), %rdx # 0x5557d
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xf120
movl %eax, %ecx
movl $0xffffd680, %eax # imm = 0xFFFFD680
testl %ecx, %ecx
js 0x22b4d
movl %ecx, %ecx
subq %rcx, %r15
jbe 0x22b4d
addq %rcx, %r12
leaq 0x32a0c(%rip), %rcx # 0x554b7
testb $0x2, %bpl
je 0x22ae1
leaq 0x32ad5(%rip), %rdx # 0x5558d
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xf120
movl %eax, %ecx
movl $0xffffd680, %eax # imm = 0xFFFFD680
testl %ecx, %ecx
js 0x22b4d
movl %ecx, %ecx
subq %rcx, %r15
jbe 0x22b4d
addq %rcx, %r12
leaq 0x329d6(%rip), %rcx # 0x554b7
testb $0x1, %bpl
je 0x22b17
leaq 0x32aaa(%rip), %rdx # 0x55598
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xf120
movl %eax, %ecx
movl $0xffffd680, %eax # imm = 0xFFFFD680
testl %ecx, %ecx
js 0x22b4d
movl %ecx, %ecx
subq %rcx, %r15
jbe 0x22b4d
addq %rcx, %r12
leaq 0x329a0(%rip), %rcx # 0x554b7
testw %bp, %bp
jns 0x22b45
leaq 0x32a85(%rip), %rdx # 0x555a8
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xf120
movl %eax, %ecx
movl $0xffffd680, %eax # imm = 0xFFFFD680
testl %ecx, %ecx
js 0x22b4d
movl %ecx, %ecx
subq %rcx, %r15
jbe 0x22b4d
addq %rcx, %r12
movq %r15, (%r14)
movq %r12, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/x509_crt.c |
mbedtls_x509_crt_verify_info | int mbedtls_x509_crt_verify_info( char *buf, size_t size, const char *prefix,
uint32_t flags )
{
int ret;
const struct x509_crt_verify_string *cur;
char *p = buf;
size_t n = size;
for( cur = x509_crt_verify_strings; cur->string != NULL ; cur++ )
{
if( ( flags & cur->code ) == 0 )
continue;
ret = mbedtls_snprintf( p, n, "%s%s\n", prefix, cur->string );
MBEDTLS_X509_SAFE_SNPRINTF;
flags ^= cur->code;
}
if( flags != 0 )
{
ret = mbedtls_snprintf( p, n, "%sUnknown reason "
"(this should not happen)\n", prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
}
return( (int) ( size - n ) );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq 0x4cf5d(%rip), %rbx # 0x6fb80
leaq 0x32992(%rip), %r8 # 0x555bc
movq %rsi, (%rsp)
movl (%rbx), %r13d
testl %ebp, %r13d
je 0x22c65
movq %r12, %rdi
movq %r14, %rsi
leaq 0x3283c(%rip), %rdx # 0x5547f
movq %r15, %rcx
xorl %eax, %eax
callq 0xf120
movl %eax, %ecx
movl $0xffffd680, %eax # imm = 0xFFFFD680
testl %ecx, %ecx
js 0x22ca6
movl %ecx, %ecx
subq %rcx, %r14
jbe 0x22ca6
addq %rcx, %r12
xorl %r13d, %ebp
movq 0x18(%rbx), %r8
addq $0x10, %rbx
testq %r8, %r8
jne 0x22c2e
testl %ebp, %ebp
je 0x22c9f
leaq 0x32808(%rip), %rdx # 0x55485
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rcx
xorl %eax, %eax
callq 0xf120
movl %eax, %ecx
movl $0xffffd680, %eax # imm = 0xFFFFD680
testl %ecx, %ecx
js 0x22ca6
movl %ecx, %ecx
subq %rcx, %r14
jbe 0x22ca6
movq (%rsp), %rax
subl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/x509_crt.c |
mbedtls_x509_crt_check_extended_key_usage | int mbedtls_x509_crt_check_extended_key_usage( const mbedtls_x509_crt *crt,
const char *usage_oid,
size_t usage_len )
{
const mbedtls_x509_sequence *cur;
/* Extension is not mandatory, absent means no restriction */
if( ( crt->ext_types & MBEDTLS_X509_EXT_EXTENDED_KEY_USAGE ) == 0 )
return( 0 );
/*
* Look for the requested usage (or wildcard ANY) in our list
*/
for( cur = &crt->ext_key_usage; cur != NULL; cur = cur->next )
{
const mbedtls_x509_buf *cur_oid = &cur->buf;
if( cur_oid->len == usage_len &&
memcmp( cur_oid->p, usage_oid, usage_len ) == 0 )
{
return( 0 );
}
if( MBEDTLS_OID_CMP( MBEDTLS_OID_ANY_EXTENDED_KEY_USAGE, cur_oid ) == 0 )
return( 0 );
}
return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
xorl %ebx, %ebx
testb $0x8, 0x1c1(%rdi)
je 0x22d4b
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
addq $0x1d0, %r12 # imm = 0x1D0
movq 0x8(%r12), %r13
cmpq %r14, %r13
jne 0x22d29
movq 0x10(%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xf2b0
testl %eax, %eax
je 0x22d4b
cmpq $0x4, %r13
jne 0x22d3c
movq 0x10(%r12), %rax
cmpl $0x251d55, (%rax) # imm = 0x251D55
je 0x22d4b
movq 0x18(%r12), %r12
testq %r12, %r12
jne 0x22d0b
movl $0xffffd800, %ebx # imm = 0xFFFFD800
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /Dragonchang[P]https_client/mbedtls/library/x509_crt.c |
mbedtls_x509_crt_verify_with_profile | int mbedtls_x509_crt_verify_with_profile( mbedtls_x509_crt *crt,
mbedtls_x509_crt *trust_ca,
mbedtls_x509_crl *ca_crl,
const mbedtls_x509_crt_profile *profile,
const char *cn, uint32_t *flags,
int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
void *p_vrfy )
{
size_t cn_len;
int ret;
int pathlen = 0, selfsigned = 0;
mbedtls_x509_crt *parent;
mbedtls_x509_name *name;
mbedtls_x509_sequence *cur = NULL;
mbedtls_pk_type_t pk_type;
if( profile == NULL )
return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
*flags = 0;
if( cn != NULL )
{
name = &crt->subject;
cn_len = strlen( cn );
if( crt->ext_types & MBEDTLS_X509_EXT_SUBJECT_ALT_NAME )
{
cur = &crt->subject_alt_names;
while( cur != NULL )
{
if( cur->buf.len == cn_len &&
x509_memcasecmp( cn, cur->buf.p, cn_len ) == 0 )
break;
if( cur->buf.len > 2 &&
memcmp( cur->buf.p, "*.", 2 ) == 0 &&
x509_check_wildcard( cn, &cur->buf ) == 0 )
{
break;
}
cur = cur->next;
}
if( cur == NULL )
*flags |= MBEDTLS_X509_BADCERT_CN_MISMATCH;
}
else
{
while( name != NULL )
{
if( MBEDTLS_OID_CMP( MBEDTLS_OID_AT_CN, &name->oid ) == 0 )
{
if( name->val.len == cn_len &&
x509_memcasecmp( name->val.p, cn, cn_len ) == 0 )
break;
if( name->val.len > 2 &&
memcmp( name->val.p, "*.", 2 ) == 0 &&
x509_check_wildcard( cn, &name->val ) == 0 )
break;
}
name = name->next;
}
if( name == NULL )
*flags |= MBEDTLS_X509_BADCERT_CN_MISMATCH;
}
}
/* Check the type and size of the key */
pk_type = mbedtls_pk_get_type( &crt->pk );
if( x509_profile_check_pk_alg( profile, pk_type ) != 0 )
*flags |= MBEDTLS_X509_BADCERT_BAD_PK;
if( x509_profile_check_key( profile, pk_type, &crt->pk ) != 0 )
*flags |= MBEDTLS_X509_BADCERT_BAD_KEY;
/* Look for a parent in trusted CAs */
for( parent = trust_ca; parent != NULL; parent = parent->next )
{
if( x509_crt_check_parent( crt, parent, 0, pathlen == 0 ) == 0 )
break;
}
if( parent != NULL )
{
ret = x509_crt_verify_top( crt, parent, ca_crl, profile,
pathlen, selfsigned, flags, f_vrfy, p_vrfy );
if( ret != 0 )
return( ret );
}
else
{
/* Look for a parent upwards the chain */
for( parent = crt->next; parent != NULL; parent = parent->next )
if( x509_crt_check_parent( crt, parent, 0, pathlen == 0 ) == 0 )
break;
/* Are we part of the chain or at the top? */
if( parent != NULL )
{
ret = x509_crt_verify_child( crt, parent, trust_ca, ca_crl, profile,
pathlen, selfsigned, flags, f_vrfy, p_vrfy );
if( ret != 0 )
return( ret );
}
else
{
ret = x509_crt_verify_top( crt, trust_ca, ca_crl, profile,
pathlen, selfsigned, flags, f_vrfy, p_vrfy );
if( ret != 0 )
return( ret );
}
}
if( *flags != 0 )
return( MBEDTLS_ERR_X509_CERT_VERIFY_FAILED );
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
testq %rcx, %rcx
je 0x22ed1
movq %r9, %rbx
movq %r8, %rbp
movq %rcx, %r14
movq %rdi, %r13
movq %rdx, 0x10(%rsp)
movl $0x0, (%r9)
testq %r8, %r8
je 0x22f58
movq %rbp, %rdi
callq 0xf100
movq %rax, %r15
testb $0x20, 0x1c0(%r13)
jne 0x22edb
leaq 0xd8(%r13), %r12
cmpq $0x3, 0x8(%r12)
jne 0x22e4e
movq 0x10(%r12), %rax
movzwl (%rax), %ecx
xorl $0x455, %ecx # imm = 0x455
movzbl 0x2(%rax), %eax
xorl $0x3, %eax
orw %cx, %ax
je 0x22e5d
movq 0x30(%r12), %r12
testq %r12, %r12
jne 0x22e2c
jmp 0x22f52
movq 0x20(%r12), %rax
cmpq %r15, %rax
jne 0x22ea9
testq %r15, %r15
je 0x22f58
movq 0x28(%r12), %rcx
xorl %edx, %edx
movb (%rcx,%rdx), %sil
movb (%rbp,%rdx), %dil
cmpb %dil, %sil
je 0x22e9c
xorb %sil, %dil
cmpb $0x20, %dil
jne 0x22ea9
andb $-0x21, %sil
addb $-0x41, %sil
cmpb $0x19, %sil
ja 0x22ea9
incq %rdx
cmpq %rdx, %r15
jne 0x22e77
jmp 0x22f58
cmpq $0x3, %rax
jb 0x22e4e
movq 0x28(%r12), %rax
cmpw $0x2e2a, (%rax) # imm = 0x2E2A
jne 0x22e4e
leaq 0x18(%r12), %rsi
movq %rbp, %rdi
callq 0x23066
testl %eax, %eax
jne 0x22e4e
jmp 0x22f58
movl $0xffffd800, %eax # imm = 0xFFFFD800
jmp 0x23057
leaq 0x1a0(%r13), %r12
movq 0x8(%r12), %rax
cmpq %r15, %rax
jne 0x22f27
testq %r15, %r15
je 0x22f58
movq 0x10(%r12), %rcx
xorl %edx, %edx
movb (%rbp,%rdx), %sil
movb (%rcx,%rdx), %dil
cmpb %dil, %sil
je 0x22f1d
xorb %sil, %dil
cmpb $0x20, %dil
jne 0x22f27
andb $-0x21, %sil
addb $-0x41, %sil
cmpb $0x19, %sil
ja 0x22f27
incq %rdx
cmpq %rdx, %r15
jne 0x22ef8
jmp 0x22f58
cmpq $0x3, %rax
jb 0x22f48
movq 0x10(%r12), %rax
cmpw $0x2e2a, (%rax) # imm = 0x2E2A
jne 0x22f48
movq %rbp, %rdi
movq %r12, %rsi
callq 0x23066
testl %eax, %eax
je 0x22f58
movq 0x18(%r12), %r12
testq %r12, %r12
jne 0x22ee2
movl $0x4, (%rbx)
leaq 0x148(%r13), %r15
movq %r15, %rdi
callq 0x3b442
movl 0x4(%r14), %ecx
movl %eax, %edx
decb %dl
movzbl %dl, %edx
btl %edx, %ecx
jb 0x22f7b
orb $-0x80, 0x1(%rbx)
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
callq 0x2310f
testl %eax, %eax
je 0x22f90
orb $0x1, 0x2(%rbx)
movq 0x58(%rsp), %rbp
movq 0x50(%rsp), %r12
movq %r13, %r15
cmpq $0x0, 0x8(%rsp)
je 0x22fcf
movq 0x8(%rsp), %r15
movq %r13, %rdi
movq %r15, %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x23159
testl %eax, %eax
je 0x23022
movq 0x220(%r15), %r15
testq %r15, %r15
jne 0x22faa
movq %r13, %r15
movq 0x220(%r15), %r15
testq %r15, %r15
je 0x23014
movq %r13, %rdi
movq %r15, %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x23159
testl %eax, %eax
jne 0x22fcf
movq %r13, %rdi
movq %r15, %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %r14, %r8
xorl %r9d, %r9d
pushq %rbp
pushq %r12
pushq %rbx
pushq $0x0
callq 0x23527
jmp 0x23043
subq $0x8, %rsp
movq %r13, %rdi
movq 0x10(%rsp), %rsi
jmp 0x2302c
subq $0x8, %rsp
movq %r13, %rdi
movq %r15, %rsi
movq 0x18(%rsp), %rdx
movq %r14, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rbp
pushq %r12
pushq %rbx
callq 0x231f6
addq $0x20, %rsp
testl %eax, %eax
jne 0x23057
movl (%rbx), %ecx
testl %ecx, %ecx
movl $0xffffd900, %eax # imm = 0xFFFFD900
cmovel %ecx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/x509_crt.c |
x509_profile_check_key | static int x509_profile_check_key( const mbedtls_x509_crt_profile *profile,
mbedtls_pk_type_t pk_alg,
const mbedtls_pk_context *pk )
{
#if defined(MBEDTLS_RSA_C)
if( pk_alg == MBEDTLS_PK_RSA || pk_alg == MBEDTLS_PK_RSASSA_PSS )
{
if( mbedtls_pk_get_bitlen( pk ) >= profile->rsa_min_bitlen )
return( 0 );
return( -1 );
}
#endif
#if defined(MBEDTLS_ECP_C)
if( pk_alg == MBEDTLS_PK_ECDSA ||
pk_alg == MBEDTLS_PK_ECKEY ||
pk_alg == MBEDTLS_PK_ECKEY_DH )
{
mbedtls_ecp_group_id gid = mbedtls_pk_ec( *pk )->grp.id;
if( ( profile->allowed_curves & MBEDTLS_X509_ID_FLAG( gid ) ) != 0 )
return( 0 );
return( -1 );
}
#endif
return( -1 );
} | pushq %rbx
movq %rdi, %rbx
cmpl $0x6, %esi
je 0x2311d
cmpl $0x1, %esi
jne 0x23134
movq %rdx, %rdi
callq 0x3b3e3
movq %rax, %rcx
movl 0xc(%rbx), %edx
xorl %eax, %eax
cmpq %rdx, %rcx
sbbl %eax, %eax
popq %rbx
retq
addl $-0x2, %esi
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl $0x2, %esi
ja 0x23132
movq 0x8(%rdx), %rax
movb (%rax), %al
movl 0x8(%rbx), %ecx
decb %al
movzbl %al, %edx
xorl %eax, %eax
btl %edx, %ecx
adcl $-0x1, %eax
jmp 0x23132
| /Dragonchang[P]https_client/mbedtls/library/x509_crt.c |
x509_crt_verify_top | static int x509_crt_verify_top(
mbedtls_x509_crt *child, mbedtls_x509_crt *trust_ca,
mbedtls_x509_crl *ca_crl,
const mbedtls_x509_crt_profile *profile,
int path_cnt, int self_cnt, uint32_t *flags,
int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
void *p_vrfy )
{
int ret;
uint32_t ca_flags = 0;
int check_path_cnt;
unsigned char hash[MBEDTLS_MD_MAX_SIZE];
const mbedtls_md_info_t *md_info;
mbedtls_x509_crt *future_past_ca = NULL;
if( mbedtls_x509_time_is_past( &child->valid_to ) )
*flags |= MBEDTLS_X509_BADCERT_EXPIRED;
if( mbedtls_x509_time_is_future( &child->valid_from ) )
*flags |= MBEDTLS_X509_BADCERT_FUTURE;
if( x509_profile_check_md_alg( profile, child->sig_md ) != 0 )
*flags |= MBEDTLS_X509_BADCERT_BAD_MD;
if( x509_profile_check_pk_alg( profile, child->sig_pk ) != 0 )
*flags |= MBEDTLS_X509_BADCERT_BAD_PK;
/*
* Child is the top of the chain. Check against the trust_ca list.
*/
*flags |= MBEDTLS_X509_BADCERT_NOT_TRUSTED;
md_info = mbedtls_md_info_from_type( child->sig_md );
if( md_info == NULL )
{
/*
* Cannot check 'unknown', no need to try any CA
*/
trust_ca = NULL;
}
else
mbedtls_md( md_info, child->tbs.p, child->tbs.len, hash );
for( /* trust_ca */ ; trust_ca != NULL; trust_ca = trust_ca->next )
{
if( x509_crt_check_parent( child, trust_ca, 1, path_cnt == 0 ) != 0 )
continue;
check_path_cnt = path_cnt + 1;
/*
* Reduce check_path_cnt to check against if top of the chain is
* the same as the trusted CA
*/
if( child->subject_raw.len == trust_ca->subject_raw.len &&
memcmp( child->subject_raw.p, trust_ca->subject_raw.p,
child->issuer_raw.len ) == 0 )
{
check_path_cnt--;
}
/* Self signed certificates do not count towards the limit */
if( trust_ca->max_pathlen > 0 &&
trust_ca->max_pathlen < check_path_cnt - self_cnt )
{
continue;
}
if( mbedtls_pk_verify_ext( child->sig_pk, child->sig_opts, &trust_ca->pk,
child->sig_md, hash, mbedtls_md_get_size( md_info ),
child->sig.p, child->sig.len ) != 0 )
{
continue;
}
if( mbedtls_x509_time_is_past( &trust_ca->valid_to ) ||
mbedtls_x509_time_is_future( &trust_ca->valid_from ) )
{
if ( future_past_ca == NULL )
future_past_ca = trust_ca;
continue;
}
break;
}
if( trust_ca != NULL || ( trust_ca = future_past_ca ) != NULL )
{
/*
* Top of chain is signed by a trusted CA
*/
*flags &= ~MBEDTLS_X509_BADCERT_NOT_TRUSTED;
if( x509_profile_check_key( profile, child->sig_pk, &trust_ca->pk ) != 0 )
*flags |= MBEDTLS_X509_BADCERT_BAD_KEY;
}
/*
* If top of chain is not the same as the trusted CA send a verify request
* to the callback for any issues with validity and CRL presence for the
* trusted CA certificate.
*/
if( trust_ca != NULL &&
( child->subject_raw.len != trust_ca->subject_raw.len ||
memcmp( child->subject_raw.p, trust_ca->subject_raw.p,
child->issuer_raw.len ) != 0 ) )
{
#if defined(MBEDTLS_X509_CRL_PARSE_C)
/* Check trusted CA's CRL for the chain's top crt */
*flags |= x509_crt_verifycrl( child, trust_ca, ca_crl, profile );
#else
((void) ca_crl);
#endif
if( mbedtls_x509_time_is_past( &trust_ca->valid_to ) )
ca_flags |= MBEDTLS_X509_BADCERT_EXPIRED;
if( mbedtls_x509_time_is_future( &trust_ca->valid_from ) )
ca_flags |= MBEDTLS_X509_BADCERT_FUTURE;
if( NULL != f_vrfy )
{
if( ( ret = f_vrfy( p_vrfy, trust_ca, path_cnt + 1,
&ca_flags ) ) != 0 )
{
return( ret );
}
}
}
/* Call callback on top cert */
if( NULL != f_vrfy )
{
if( ( ret = f_vrfy( p_vrfy, child, path_cnt, flags ) ) != 0 )
return( ret );
}
*flags |= ca_flags;
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %r9d, 0x2c(%rsp)
movq %r8, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, 0x30(%rsp)
movq %rsi, %r13
movq %rdi, %r15
movq 0xc0(%rsp), %rbx
movl $0x0, 0x4(%rsp)
addq $0x130, %rdi # imm = 0x130
callq 0x25002
testl %eax, %eax
je 0x23244
orb $0x1, (%rbx)
leaq 0x118(%r15), %rdi
callq 0x250f3
movl (%rbx), %ecx
testl %eax, %eax
je 0x2325e
orl $0x200, %ecx # imm = 0x200
movl %ecx, (%rbx)
movb 0x210(%r15), %al
movq 0x10(%rsp), %rdx
movl (%rdx), %edx
decb %al
movzbl %al, %eax
btl %eax, %edx
jb 0x2327e
orl $0x4000, %ecx # imm = 0x4000
movl %ecx, (%rbx)
movb 0x214(%r15), %al
movq 0x10(%rsp), %rdx
movl 0x4(%rdx), %edx
decb %al
movzbl %al, %eax
movl %ecx, %esi
orl $0x8000, %esi # imm = 0x8000
btl %eax, %edx
cmovbl %ecx, %esi
orl $0x8, %esi
movl %esi, (%rbx)
movl 0x210(%r15), %edi
callq 0x38cdb
testq %rax, %rax
je 0x234e6
movq 0x20(%r15), %rdx
movq 0x28(%r15), %rsi
leaq 0x40(%rsp), %rcx
movq %rax, %rdi
movq %rax, 0x38(%rsp)
callq 0x38e72
testq %r13, %r13
je 0x234e6
xorl %ebp, %ebp
movq 0x18(%rsp), %rax
testl %eax, %eax
sete %bpl
leal 0x1(%rax), %r14d
movq $0x0, 0x20(%rsp)
movl %ebp, 0xc(%rsp)
movl %r14d, 0x8(%rsp)
movq %r15, %rdi
movq %r13, %rsi
movl $0x1, %edx
movl %ebp, %ecx
callq 0x23159
testl %eax, %eax
jne 0x2340b
movq 0x88(%r15), %rax
movl %r14d, %ecx
cmpq 0x88(%r13), %rax
jne 0x23350
movq 0x70(%r15), %rdx
movq 0x90(%r15), %rdi
movq 0x90(%r13), %rsi
callq 0xf2b0
movq 0x18(%rsp), %rcx
testl %eax, %eax
je 0x23350
movl %r14d, %ecx
movl 0x1c8(%r13), %eax
testl %eax, %eax
jle 0x23367
subl 0x2c(%rsp), %ecx
cmpl %ecx, %eax
jl 0x2340b
movl 0x210(%r15), %ebp
movl 0x214(%r15), %ebx
movq 0x218(%r15), %r12
leaq 0x148(%r13), %r14
movq 0x38(%rsp), %rdi
callq 0x39265
movzbl %al, %r9d
movl %ebx, %edi
movq %r12, %rsi
movq %r14, %rdx
movl %ebp, %ecx
leaq 0x40(%rsp), %r8
pushq 0x200(%r15)
pushq 0x208(%r15)
callq 0x3b160
addq $0x10, %rsp
testl %eax, %eax
je 0x233c9
movq 0xc0(%rsp), %rbx
movl 0xc(%rsp), %ebp
jmp 0x23406
leaq 0x130(%r13), %rdi
callq 0x25002
testl %eax, %eax
movq 0xc0(%rsp), %rbx
movl 0xc(%rsp), %ebp
jne 0x233f5
leaq 0x118(%r13), %rdi
callq 0x250f3
testl %eax, %eax
je 0x23429
movq 0x20(%rsp), %rax
testq %rax, %rax
cmoveq %r13, %rax
movq %rax, 0x20(%rsp)
movl 0x8(%rsp), %r14d
movq 0x220(%r13), %r13
testq %r13, %r13
jne 0x23300
movq 0x20(%rsp), %r13
testq %r13, %r13
je 0x234e6
andb $-0x9, (%rbx)
movl 0x214(%r15), %esi
leaq 0x148(%r13), %rdx
movq 0x10(%rsp), %rdi
callq 0x2310f
testl %eax, %eax
je 0x2344c
orb $0x1, 0x2(%rbx)
movq 0x88(%r15), %rax
cmpq 0x88(%r13), %rax
jne 0x23477
movq 0x70(%r15), %rdx
movq 0x90(%r15), %rdi
movq 0x90(%r13), %rsi
callq 0xf2b0
testl %eax, %eax
je 0x234e6
movq %r15, %rdi
movq %r13, %rsi
movq 0x30(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x240d1
orl %eax, (%rbx)
leaq 0x130(%r13), %rdi
callq 0x25002
testl %eax, %eax
je 0x234a3
orb $0x1, 0x4(%rsp)
leaq 0x118(%r13), %rdi
callq 0x250f3
testl %eax, %eax
movq 0xc8(%rsp), %r14
je 0x234c0
orb $0x2, 0x5(%rsp)
testq %r14, %r14
je 0x2350d
movq 0x18(%rsp), %rax
leal 0x1(%rax), %edx
leaq 0x4(%rsp), %rcx
movq 0xd0(%rsp), %rdi
movq %r13, %rsi
callq *%r14
testl %eax, %eax
jne 0x23515
jmp 0x234f3
movq 0xc8(%rsp), %r14
testq %r14, %r14
je 0x2350d
movq 0xd0(%rsp), %rdi
movq %r15, %rsi
movq 0x18(%rsp), %rdx
movq %rbx, %rcx
callq *%r14
testl %eax, %eax
jne 0x23515
movl 0x4(%rsp), %eax
orl %eax, (%rbx)
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/x509_crt.c |
mbedtls_x509_crt_free | void mbedtls_x509_crt_free( mbedtls_x509_crt *crt )
{
mbedtls_x509_crt *cert_cur = crt;
mbedtls_x509_crt *cert_prv;
mbedtls_x509_name *name_cur;
mbedtls_x509_name *name_prv;
mbedtls_x509_sequence *seq_cur;
mbedtls_x509_sequence *seq_prv;
if( crt == NULL )
return;
do
{
mbedtls_pk_free( &cert_cur->pk );
#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
mbedtls_free( cert_cur->sig_opts );
#endif
name_cur = cert_cur->issuer.next;
while( name_cur != NULL )
{
name_prv = name_cur;
name_cur = name_cur->next;
mbedtls_zeroize( name_prv, sizeof( mbedtls_x509_name ) );
mbedtls_free( name_prv );
}
name_cur = cert_cur->subject.next;
while( name_cur != NULL )
{
name_prv = name_cur;
name_cur = name_cur->next;
mbedtls_zeroize( name_prv, sizeof( mbedtls_x509_name ) );
mbedtls_free( name_prv );
}
seq_cur = cert_cur->ext_key_usage.next;
while( seq_cur != NULL )
{
seq_prv = seq_cur;
seq_cur = seq_cur->next;
mbedtls_zeroize( seq_prv, sizeof( mbedtls_x509_sequence ) );
mbedtls_free( seq_prv );
}
seq_cur = cert_cur->subject_alt_names.next;
while( seq_cur != NULL )
{
seq_prv = seq_cur;
seq_cur = seq_cur->next;
mbedtls_zeroize( seq_prv, sizeof( mbedtls_x509_sequence ) );
mbedtls_free( seq_prv );
}
if( cert_cur->raw.p != NULL )
{
mbedtls_zeroize( cert_cur->raw.p, cert_cur->raw.len );
mbedtls_free( cert_cur->raw.p );
}
cert_cur = cert_cur->next;
}
while( cert_cur != NULL );
cert_cur = crt;
do
{
cert_prv = cert_cur;
cert_cur = cert_cur->next;
mbedtls_zeroize( cert_prv, sizeof( mbedtls_x509_crt ) );
if( cert_prv != crt )
mbedtls_free( cert_prv );
}
while( cert_cur != NULL );
} | testq %rdi, %rdi
je 0x239c5
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rdi, %r14
leaq 0x148(%r14), %rdi
callq 0x3afd0
movq 0x218(%r14), %rdi
callq 0xf030
movq 0xc8(%r14), %rdi
testq %rdi, %rdi
je 0x238d6
movq 0x30(%rdi), %r15
xorl %eax, %eax
movb $0x0, (%rdi,%rax)
incq %rax
cmpq $0x40, %rax
jne 0x238bc
callq 0xf030
movq %r15, %rdi
testq %r15, %r15
jne 0x238b6
movq 0x108(%r14), %rdi
testq %rdi, %rdi
je 0x23902
movq 0x30(%rdi), %r15
xorl %eax, %eax
movb $0x0, (%rdi,%rax)
incq %rax
cmpq $0x40, %rax
jne 0x238e8
callq 0xf030
movq %r15, %rdi
testq %r15, %r15
jne 0x238e2
movq 0x1e8(%r14), %rdi
testq %rdi, %rdi
je 0x2392e
movq 0x18(%rdi), %r15
xorl %eax, %eax
movb $0x0, (%rdi,%rax)
incq %rax
cmpq $0x20, %rax
jne 0x23914
callq 0xf030
movq %r15, %rdi
testq %r15, %r15
jne 0x2390e
movq 0x1b8(%r14), %rdi
testq %rdi, %rdi
je 0x2395a
movq 0x18(%rdi), %r15
xorl %eax, %eax
movb $0x0, (%rdi,%rax)
incq %rax
cmpq $0x20, %rax
jne 0x23940
callq 0xf030
movq %r15, %rdi
testq %r15, %r15
jne 0x2393a
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x23983
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2397e
xorl %ecx, %ecx
movb $0x0, (%rdi,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x2396e
movq 0x10(%r14), %rdi
callq 0xf030
movq 0x220(%r14), %r14
testq %r14, %r14
jne 0x23892
movq %rbx, %r14
movq %r14, %rdi
movq 0x220(%r14), %r14
xorl %eax, %eax
movb $0x0, (%rdi,%rax)
incq %rax
cmpq $0x228, %rax # imm = 0x228
jne 0x239a2
cmpq %rbx, %rdi
je 0x239bb
callq 0xf030
testq %r14, %r14
jne 0x23996
popq %rbx
popq %r14
popq %r15
retq
| /Dragonchang[P]https_client/mbedtls/library/x509_crt.c |
x509_get_uid | static int x509_get_uid( unsigned char **p,
const unsigned char *end,
mbedtls_x509_buf *uid, int n )
{
int ret;
if( *p == end )
return( 0 );
uid->tag = **p;
if( ( ret = mbedtls_asn1_get_tag( p, end, &uid->len,
MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | n ) ) != 0 )
{
if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
return( 0 );
return( ret );
}
uid->p = *p;
*p += uid->len;
return( 0 );
} | pushq %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rax
xorl %ebp, %ebp
cmpq %rsi, %rax
je 0x23a76
movq %rdx, %rbx
movq %rdi, %r14
movzbl (%rax), %eax
movl %eax, (%rdx)
addq $0x8, %rdx
orl $0xa0, %ecx
callq 0x2539d
cmpl $-0x62, %eax
je 0x23a76
movl %eax, %ebp
testl %eax, %eax
jne 0x23a76
movq (%r14), %rax
movq %rax, 0x10(%rbx)
addq 0x8(%rbx), %rax
movq %rax, (%r14)
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/x509_crt.c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.