name string | code string | asm string | file string |
|---|---|---|---|
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",
... | 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(!use... | 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,... | /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(!f... | 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, %a... | /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 (i... | 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... | /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 ... | 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 ... | /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... | 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), %r... | /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 != '-' ||
... | 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 %e... | /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)))
&& (ri... | 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, ... | /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->... | 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 0x... | /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... | 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 ... | /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 : -... | 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 0x14... | /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_... | 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 ... | /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, ... | 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... | /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... | 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 $0... | /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 = nu... | 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 $0x... | /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)(a... | 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, %... | /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': r... | 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 0... | /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, ... | 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 $0... | /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 %x... | /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,
rejec... | 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 %xm... | /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... | 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... | /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&)::'... | 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), %r... | /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... | 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(c... | 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 0x... | /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_c... | 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,... | /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::ch... | LIBKRIGING_EXPORT Kriging::Kriging(const arma::vec& y,
const arma::mat& X,
const std::string& covType,
const Trend::RegressionModel& regmodel,
bool normalize,
... | 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
mo... | /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... | 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: ... | 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) ... | 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 0x1... | /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();
... | 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
... | /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"] ... | 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,... | /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 << ") lkallo... | 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 %ec... | /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> c... | 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*>(d... | 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 0x... | /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 s... | 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, -... | /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;
/* ********** *... | 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),... | /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 ... | /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.... | 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 %r... | /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 m... | 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 ... | /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 );
... | 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, %r... | /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 =... | 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), ... | /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() "
... | 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, ... | /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()"... | 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... | /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... | 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
... | /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 )... | 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... | /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"... | 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 0... | /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 certi... | 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
x... | /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 ... | 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 defi... | 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
m... | /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_re... | 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)
m... | /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 < MBEDT... | 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_S... | 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 ... | /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_S... | 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 )... | 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(... | /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_b... | 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)
te... | /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->ha... | 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
xo... | /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 );
}
... | 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... | /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 );
... | 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
j... | /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_f... | 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 ... | /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" );
c... | 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
le... | /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 ... | 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,... | 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_ste... | 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 = 0x1... | /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 m... | 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(... | /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->c... | 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
mo... | /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_fre... | 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_UNAVA... | 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 );
mb... | 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
t... | /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
d... | 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_SHA25... | 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... | 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 ... | 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
m... | /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 ... | 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 0... | /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,... | 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
j... | /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 )
{
... | 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
re... | /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_out... | 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 # ... | /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... | 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
tes... | /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_E... | 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
ca... | /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... | 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 $0x... | /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)... | 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... | /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_... | 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... | /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.... | 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 ... | /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 {
* EC... | 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 = 0... | /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(MBEDT... | 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)
mo... | /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 in... | 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 $0x... | /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_H... | 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... | /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 ||
... | 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(... | /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->a... | 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... | /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->ps... | 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,... | /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 );
... | 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... | /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... | 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... | /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 uninitia... | 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 $0... | /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_REPUDIATIO... | 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 %r1... | /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 &... | 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
lea... | /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->ex... | 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 %... | /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 *, ... | 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, 0x1... | /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( ... | 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), ... | /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 *, i... | 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
j... | /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
{
... | 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
call... | /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_... | 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(%r... | /Dragonchang[P]https_client/mbedtls/library/x509_crt.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.