Datasets:
LLM4Binary
/
decompile-bench

Dataset card Data Studio Files
xet
 Community
1
name
string
code
string
asm
string
file
string
x509_get_basic_constraints
static int x509_get_basic_constraints( unsigned char **p, const unsigned char *end, int *ca_istrue, int *max_pathlen ) { int ret; size_t len; /* * BasicConstraints ::= SEQUENCE { *...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x10, %rsp movq %rcx, %r14 movq %rdx, %r13 movq %rsi, %r15 movq %rdi, %r12 xorl %ebx, %ebx movl %ebx, (%rdx) movl %ebx, (%rcx) leaq 0x8(%rsp), %rdx movl $0x30, %ecx callq 0x2539d testl %eax, %eax je 0x23d6d addl $0xffffdb00, %eax # imm = 0xFFFFDB00 movl...
/Dragonchang[P]https_client/mbedtls/library/x509_crt.c
mbedtls_x509_get_serial
int mbedtls_x509_get_serial( unsigned char **p, const unsigned char *end, mbedtls_x509_buf *serial ) { int ret; if( ( end - *p ) < 1 ) return( MBEDTLS_ERR_X509_INVALID_SERIAL + MBEDTLS_ERR_ASN1_OUT_OF_DATA ); if( **p != ( MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS...
movq (%rdi), %rax movq %rsi, %rcx subq %rax, %rcx testq %rcx, %rcx jle 0x24311 pushq %r14 pushq %rbx pushq %rax movzbl (%rax), %ecx orl $0x80, %ecx cmpl $0x82, %ecx jne 0x24317 movq %rdx, %rbx movq %rdi, %r14 leaq 0x1(%rax), %rcx movq %rcx, (%rdi) movzbl (%rax), %eax movl %eax, (%rdx) addq $0x8, %rdx callq 0x252c8 test...
/Dragonchang[P]https_client/mbedtls/library/x509.c
x509_get_hash_alg
static int x509_get_hash_alg( const mbedtls_x509_buf *alg, mbedtls_md_type_t *md_alg ) { int ret; unsigned char *p; const unsigned char *end; mbedtls_x509_buf md_oid; size_t len; /* Make sure we got a SEQUENCE and setup bounds */ if( alg->tag != ( MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQ...
movl $0xffffdc9e, %eax # imm = 0xFFFFDC9E cmpl $0x30, (%rdi) jne 0x24668 pushq %r14 pushq %rbx subq $0x28, %rsp movq 0x10(%rdi), %rax movq %rax, (%rsp) movq 0x8(%rdi), %rbx testq %rbx, %rbx jle 0x2465c movq %rsi, %r14 addq %rax, %rbx movzbl (%rax), %eax leaq 0x18(%rsp), %rdx movl %eax, -0x8(%rdx) movq %rsp, %rdi ...
/Dragonchang[P]https_client/mbedtls/library/x509.c
mbedtls_x509_get_time
int mbedtls_x509_get_time( unsigned char **p, const unsigned char *end, mbedtls_x509_time *time ) { int ret; size_t len, year_len; unsigned char tag; if( ( end - *p ) < 1 ) return( MBEDTLS_ERR_X509_INVALID_DATE + MBEDTLS_ERR_ASN1_OUT_OF_DATA ); tag = **p;...
movq (%rdi), %rcx movq %rsi, %rax subq %rcx, %rax testq %rax, %rax jle 0x2486e pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdx, %rbx movq %rdi, %r14 movzbl (%rcx), %edx cmpl $0x17, %edx je 0x24874 movl $0xffffdb9e, %eax # imm = 0xFFFFDB9E cmpl $0x18, %edx jne 0x248ab movl $0x4, %r15d xorl %ebp, %...
/Dragonchang[P]https_client/mbedtls/library/x509.c
mbedtls_x509_get_sig
int mbedtls_x509_get_sig( unsigned char **p, const unsigned char *end, mbedtls_x509_buf *sig ) { int ret; size_t len; int tag_type; if( ( end - *p ) < 1 ) return( MBEDTLS_ERR_X509_INVALID_SIGNATURE + MBEDTLS_ERR_ASN1_OUT_OF_DATA ); tag_type = **p; if( ( ret = mbedtls_a...
movq (%rdi), %rax movq %rsi, %rcx subq %rax, %rcx testq %rcx, %rcx jle 0x24ab8 pushq %rbp pushq %r14 pushq %rbx subq $0x10, %rsp movq %rdx, %r14 movq %rdi, %rbx movzbl (%rax), %ebp leaq 0x8(%rsp), %rdx callq 0x2559a testl %eax, %eax je 0x24abe addl $0xffffdb80, %eax # imm = 0xFFFFDB80 jmp 0x24ad9 movl $0xffffdb20...
/Dragonchang[P]https_client/mbedtls/library/x509.c
mbedtls_x509_sig_alg_gets
int mbedtls_x509_sig_alg_gets( char *buf, size_t size, const mbedtls_x509_buf *sig_oid, mbedtls_pk_type_t pk_alg, mbedtls_md_type_t md_alg, const void *sig_opts ) { int ret; char *p = buf; size_t n = size; const char *desc = NULL; ret = mbedtls_oid_get_...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %r9, %r12 movl %r8d, %r13d movl %ecx, %r15d movq %rsi, %rbx movq %rdi, %r14 leaq 0x10(%rsp), %rsi movq $0x0, (%rsi) movq %rdx, %rdi callq 0x3a08b testl %eax, %eax je 0x24ee2 leaq 0x306e5(%rip), %rdx # 0x555b8 movq %r14, %rdi mov...
/Dragonchang[P]https_client/mbedtls/library/x509.c
x509_check_time
static int x509_check_time( const mbedtls_x509_time *before, const mbedtls_x509_time *after ) { if( before->year > after->year ) return( 1 ); if( before->year == after->year && before->mon > after->mon ) return( 1 ); if( before->year == after->year && before->mon == aft...
movl (%rsi), %ecx movl $0x1, %eax cmpl %ecx, (%rdi) jg 0x250f2 jne 0x250f0 movl 0x4(%rsi), %ecx cmpl %ecx, 0x4(%rdi) jg 0x250f2 jne 0x250f0 movl 0x8(%rdi), %ecx cmpl 0x8(%rsi), %ecx jg 0x250f2 movl 0x8(%rdi), %ecx cmpl 0x8(%rsi), %ecx jne 0x250b8 movl 0xc(%rdi), %ecx cmpl 0xc(%rsi), %ecx jg 0x250f2 movl 0x8(%rdi), %ecx...
/Dragonchang[P]https_client/mbedtls/library/x509.c
mbedtls_x509_self_test
int mbedtls_x509_self_test( int verbose ) { #if defined(MBEDTLS_CERTS_C) && defined(MBEDTLS_SHA1_C) int ret; uint32_t flags; mbedtls_x509_crt cacert; mbedtls_x509_crt clicert; if( verbose != 0 ) mbedtls_printf( " X.509 certificate load: " ); mbedtls_x509_crt_init( &clicert ); ret...
pushq %rbp pushq %rbx subq $0x468, %rsp # imm = 0x468 movl %edi, %ebp testl %edi, %edi je 0x25140 leaq 0x308bc(%rip), %rdi # 0x559f5 xorl %eax, %eax callq 0xf110 leaq 0x18(%rsp), %rbx movq %rbx, %rdi callq 0x21da5 leaq 0x4d11c(%rip), %rax # 0x72270 movq (%rax), %rsi leaq 0x300f2(%rip), %rax # 0x5...
/Dragonchang[P]https_client/mbedtls/library/x509.c
mbedtls_asn1_get_len
int mbedtls_asn1_get_len( unsigned char **p, const unsigned char *end, size_t *len ) { if( ( end - *p ) < 1 ) return( MBEDTLS_ERR_ASN1_OUT_OF_DATA ); if( ( **p & 0x80 ) == 0 ) *len = *(*p)++; else { switch( **p & 0x7F ) { case ...
movq (%rdi), %rcx movq %rsi, %r8 subq %rcx, %r8 movl $0xffffffa0, %eax # imm = 0xFFFFFFA0 testq %r8, %r8 jle 0x25301 movzbl (%rcx), %r9d testb %r9b, %r9b js 0x25302 leaq 0x1(%rcx), %r8 movq %r8, (%rdi) movzbl (%rcx), %eax movq %rax, (%rdx) subq %r8, %rsi xorl %ecx, %ecx cmpq %rsi, %rax movl $0xffffffa0, %eax ...
/Dragonchang[P]https_client/mbedtls/library/asn1parse.c
mbedtls_asn1_get_int
int mbedtls_asn1_get_int( unsigned char **p, const unsigned char *end, int *val ) { int ret; size_t len; if( ( ret = mbedtls_asn1_get_tag( p, end, &len, MBEDTLS_ASN1_INTEGER ) ) != 0 ) return( ret ); if( len == 0 || len > sizeof( int ) || ( **p & 0x80 ) != 0...
movq (%rdi), %rcx movq %rsi, %rax subq %rcx, %rax testq %rax, %rax jle 0x254a8 pushq %r14 pushq %rbx pushq %rax movl $0xffffff9e, %eax # imm = 0xFFFFFF9E cmpb $0x2, (%rcx) jne 0x254a0 movq %rdx, %rbx movq %rdi, %r14 incq %rcx movq %rcx, (%rdi) movq %rsp, %rdx callq 0x252c8 testl %eax, %eax jne 0x254a0 movq (%rsp)...
/Dragonchang[P]https_client/mbedtls/library/asn1parse.c
mbedtls_asn1_get_sequence_of
int mbedtls_asn1_get_sequence_of( unsigned char **p, const unsigned char *end, mbedtls_asn1_sequence *cur, int tag) { int ret; size_t len; mbedtls_asn1_buf *buf; /* Get main sequence tag */ if( ( ret = mbedtls_asn1_get_ta...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movl %ecx, %ebp movq (%rdi), %rax movq %rsi, %rcx subq %rax, %rcx testq %rcx, %rcx jle 0x256e0 cmpb $0x30, (%rax) jne 0x256e7 movq %rdx, %r15 movq %rsi, %rbx movq %rdi, %r14 incq %rax movq %rax, (%rdi) movq %rsp, %rdx callq 0x252c8 testl %eax, %eax jne 0x256ec movq...
/Dragonchang[P]https_client/mbedtls/library/asn1parse.c
mbedtls_asn1_get_alg_null
int mbedtls_asn1_get_alg_null( unsigned char **p, const unsigned char *end, mbedtls_asn1_buf *alg ) { int ret; mbedtls_asn1_buf params; memset( &params, 0, sizeof(mbedtls_asn1_buf) ); if( ( ret = mbedtls_asn1_get_alg( p, end, alg, &params ) ) != 0 ) ...
subq $0x18, %rsp xorps %xmm0, %xmm0 movq %rsp, %rcx movaps %xmm0, (%rcx) movq $0x0, 0x10(%rcx) callq 0x256fe testl %eax, %eax jne 0x25850 xorl %ecx, %ecx cmpq $0x0, 0x8(%rsp) movl $0xffffff98, %eax # imm = 0xFFFFFF98 cmovnel %eax, %ecx movl (%rsp), %edx testl %edx, %edx cmovel %ecx, %eax cmpl $0x5, %edx cmovel %e...
/Dragonchang[P]https_client/mbedtls/library/asn1parse.c
mbedtls_mpi_free
void mbedtls_mpi_free( mbedtls_mpi *X ) { if( X == NULL ) return; if( X->p != NULL ) { mbedtls_mpi_zeroize( X->p, X->n ); mbedtls_free( X->p ); } X->s = 1; X->n = 0; X->p = NULL; }
testq %rdi, %rdi je 0x2594b pushq %rbx movq %rdi, %rbx movq 0x10(%rdi), %rdi testq %rdi, %rdi je 0x2593d movq 0x8(%rbx), %rax testq %rax, %rax je 0x25938 xorl %ecx, %ecx movq $0x0, (%rdi,%rcx,8) incq %rcx cmpq %rcx, %rax jne 0x25928 callq 0xf030 movl $0x1, (%rbx) xorps %xmm0, %xmm0 movups %xmm0, 0x8(%rbx) popq %rbx ret...
/Dragonchang[P]https_client/mbedtls/library/bignum.c
mbedtls_mpi_grow
int mbedtls_mpi_grow( mbedtls_mpi *X, size_t nblimbs ) { mbedtls_mpi_uint *p; if( nblimbs > MBEDTLS_MPI_MAX_LIMBS ) return( MBEDTLS_ERR_MPI_ALLOC_FAILED ); if( X->n < nblimbs ) { if( ( p = (mbedtls_mpi_uint*)mbedtls_calloc( nblimbs, ciL ) ) == NULL ) return( MBEDTLS_ERR_MPI...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movl $0xfffffff0, %ebp # imm = 0xFFFFFFF0 cmpq $0x2710, %rsi # imm = 0x2710 ja 0x259ce movq %rsi, %r14 movq %rdi, %rbx movq 0x8(%rdi), %r13 cmpq %rsi, %r13 jae 0x259cc movl $0x8, %esi movq %r14, %rdi callq 0xf1d0 testq %rax, %r...
/Dragonchang[P]https_client/mbedtls/library/bignum.c
mbedtls_mpi_read_string
int mbedtls_mpi_read_string( mbedtls_mpi *X, int radix, const char *s ) { int ret; size_t i, j, slen, n; mbedtls_mpi_uint d; mbedtls_mpi T; if( radix < 2 || radix > 16 ) return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA ); mbedtls_mpi_init( &T ); slen = strlen( s ); if( radix == 16 ) ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x58, %rsp movl %esi, %r13d leal -0x11(%r13), %eax movl $0xfffffffc, %r12d # imm = 0xFFFFFFFC cmpl $-0xf, %eax jb 0x25f70 movq %rdx, %rbx movq %rdi, %r14 movl $0x1, 0x40(%rsp) xorps %xmm0, %xmm0 movups %xmm0, 0x48(%rsp) movq %rdx, %rdi callq 0...
/Dragonchang[P]https_client/mbedtls/library/bignum.c
mbedtls_mpi_add_int
int mbedtls_mpi_add_int( mbedtls_mpi *X, const mbedtls_mpi *A, mbedtls_mpi_sint b ) { mbedtls_mpi _B; mbedtls_mpi_uint p[1]; p[0] = ( b < 0 ) ? -b : b; _B.s = ( b < 0 ) ? -1 : 1; _B.n = 1; _B.p = p; return( mbedtls_mpi_add_mpi( X, A, &_B ) ); }
subq $0x28, %rsp movq %rdx, %rax negq %rax cmovsq %rdx, %rax leaq 0x8(%rsp), %rcx movq %rax, (%rcx) sarq $0x3f, %rdx orl $0x1, %edx leaq 0x10(%rsp), %rax movl %edx, (%rax) movq $0x1, 0x8(%rax) movq %rcx, 0x10(%rax) movq %rax, %rdx callq 0x26d51 addq $0x28, %rsp retq
/Dragonchang[P]https_client/mbedtls/library/bignum.c
mbedtls_mpi_write_string
int mbedtls_mpi_write_string( const mbedtls_mpi *X, int radix, char *buf, size_t buflen, size_t *olen ) { int ret = 0; size_t n; char *p; mbedtls_mpi T; if( radix < 2 || radix > 16 ) return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA ); n = mbedtls_mpi_bitlen( X ); ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movl %esi, %r12d leal -0x11(%r12), %eax movl $0xfffffffc, %ebp # imm = 0xFFFFFFFC cmpl $-0xf, %eax jb 0x26370 movq %r8, %rbx movq %rcx, %r13 movq %rdx, %r14 movq %rdi, %r15 callq 0x25d9f cmpl $0x4, %r12d setae %cl shrq %cl, %rax cm...
/Dragonchang[P]https_client/mbedtls/library/bignum.c
mbedtls_mpi_read_file
int mbedtls_mpi_read_file( mbedtls_mpi *X, int radix, FILE *fin ) { mbedtls_mpi_uint d; size_t slen; char *p; /* * Buffer should have space for (short) label and decimal formatted MPI, * newline characters and '\0' */ char s[ MBEDTLS_MPI_RW_BUFFER_SIZE ]; memset( s, 0, sizeof( s ...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x9b8, %rsp # imm = 0x9B8 movq %rdx, %r15 movl %esi, %ebx movq %rdi, %r14 movq %rsp, %r12 movl $0x9b4, %edx # imm = 0x9B4 movq %r12, %rdi xorl %esi, %esi callq 0xf150 movq %r12, %rdi movl $0x9b3, %esi # imm = 0x9B3 movq %r15, %rdx callq ...
/Dragonchang[P]https_client/mbedtls/library/bignum.c
mbedtls_mpi_shift_r
int mbedtls_mpi_shift_r( mbedtls_mpi *X, size_t count ) { size_t i, v0, v1; mbedtls_mpi_uint r0 = 0, r1; v0 = count / biL; v1 = count & (biL - 1); if( v0 > X->n || ( v0 == X->n && v1 > 0 ) ) return mbedtls_mpi_lset( X, 0 ); /* * shift by count / limb_size */ if( v0 > 0 ...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movq %rsi, %rcx shrq $0x6, %rcx movl %esi, %eax andl $0x3f, %eax movq 0x8(%rdi), %rdi cmpq %rdi, %rcx ja 0x268da setne %dl testq %rax, %rax sete %r8b orb %dl, %r8b jne 0x2691e movl $0x1, %esi movq %rbx, %rdi callq 0x2594c movl %eax, %r14d testl %eax, %eax jne 0x269bf mov...
/Dragonchang[P]https_client/mbedtls/library/bignum.c
mbedtls_mpi_cmp_abs
int mbedtls_mpi_cmp_abs( const mbedtls_mpi *X, const mbedtls_mpi *Y ) { size_t i, j; for( i = X->n; i > 0; i-- ) if( X->p[i - 1] != 0 ) break; for( j = Y->n; j > 0; j-- ) if( Y->p[j - 1] != 0 ) break; if( i == 0 && j == 0 ) return( 0 ); if( i > j )...
movq 0x8(%rdi), %rcx testq %rcx, %rcx je 0x269e4 movq 0x10(%rdi), %rax cmpq $0x0, -0x8(%rax,%rcx,8) jne 0x269e6 decq %rcx jne 0x269d7 xorl %ecx, %ecx movq 0x8(%rsi), %rdx xorl %eax, %eax testq %rdx, %rdx je 0x26a02 movq 0x10(%rsi), %r8 cmpq $0x0, -0x8(%r8,%rdx,8) jne 0x26a04 decq %rdx jne 0x269f5 xorl %edx, %edx movq %...
/Dragonchang[P]https_client/mbedtls/library/bignum.c
mbedtls_mpi_cmp_mpi
int mbedtls_mpi_cmp_mpi( const mbedtls_mpi *X, const mbedtls_mpi *Y ) { size_t i, j; for( i = X->n; i > 0; i-- ) if( X->p[i - 1] != 0 ) break; for( j = Y->n; j > 0; j-- ) if( Y->p[j - 1] != 0 ) break; if( i == 0 && j == 0 ) return( 0 ); if( i > j )...
movq 0x8(%rdi), %rcx testq %rcx, %rcx je 0x26a53 movq 0x10(%rdi), %rax cmpq $0x0, -0x8(%rax,%rcx,8) jne 0x26a55 decq %rcx jne 0x26a46 xorl %ecx, %ecx movq 0x8(%rsi), %rax testq %rax, %rax je 0x26a6f movq 0x10(%rsi), %rdx cmpq $0x0, -0x8(%rdx,%rax,8) jne 0x26a71 decq %rax jne 0x26a62 xorl %eax, %eax movq %rax, %rdx orq ...
/Dragonchang[P]https_client/mbedtls/library/bignum.c
mpi_montmul
static int mpi_montmul( mbedtls_mpi *A, const mbedtls_mpi *B, const mbedtls_mpi *N, mbedtls_mpi_uint mm, const mbedtls_mpi *T ) { size_t i, n, m; mbedtls_mpi_uint u0, u1, *d; if( T->n < N->n + 1 || T->p == NULL ) return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA ); memset( T->p, ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq %r8, %rbx movq %rcx, %rbp movq %rdx, %r15 movq 0x8(%r8), %rdx movq 0x8(%r15), %rcx incq %rcx movl $0xfffffffc, %eax # imm = 0xFFFFFFFC cmpq %rcx, %rdx jb 0x28560 movq %rdi, %r14 movq 0x10(%rbx), %rdi testq %rdi, %rdi je 0x2856...
/Dragonchang[P]https_client/mbedtls/library/bignum.c
mpi_check_small_factors
static int mpi_check_small_factors( const mbedtls_mpi *X ) { int ret = 0; size_t i; mbedtls_mpi_uint r; if( ( X->p[0] & 1 ) == 0 ) return( MBEDTLS_ERR_MPI_NOT_ACCEPTABLE ); for( i = 0; small_prime[i] > 0; i++ ) { if( mbedtls_mpi_cmp_int( X, small_prime[i] ) <= 0 ) r...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq 0x10(%rdi), %rcx movl $0xfffffff2, %eax # imm = 0xFFFFFFF2 testb $0x1, (%rcx) je 0x29132 movq %rdi, %r14 xorl %r13d, %r13d leaq 0x8(%rsp), %rbx leaq 0x10(%rsp), %r15 movq %rsp, %r12 leaq 0x2ce03(%rip), %rax # 0x55ed0 movl ...
/Dragonchang[P]https_client/mbedtls/library/bignum.c
mbedtls_mpi_gen_prime
int mbedtls_mpi_gen_prime( mbedtls_mpi *X, size_t nbits, int dh_flag, int (*f_rng)(void *, unsigned char *, size_t), void *p_rng ) { int ret; size_t k, n; mbedtls_mpi_uint r; mbedtls_mpi Y; if( nbits < 3 || nbits > MBEDTLS_MPI_MAX_BITS ) return( MBEDTLS...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x438, %rsp # imm = 0x438 leaq -0x2001(%rsi), %rax movl $0xfffffffc, %ebp # imm = 0xFFFFFFFC cmpq $-0x1ffe, %rax # imm = 0xE002 jb 0x2981c movq %rsi, %rbx movl $0x1, 0x10(%rsp) xorps %xmm0, %xmm0 movups %xmm0, 0x18(%rsp) m...
/Dragonchang[P]https_client/mbedtls/library/bignum.c
mbedtls_cipher_list
const int *mbedtls_cipher_list( void ) { const mbedtls_cipher_definition_t *def; int *type; if( ! supported_init ) { def = mbedtls_cipher_definitions; type = mbedtls_cipher_supported; while( def->type != 0 ) *type++ = (*def++).type; *type = 0; supp...
cmpb $0x0, 0x484fd(%rip) # 0x72504 jne 0x2a047 leaq 0x465e0(%rip), %rax # 0x705f0 movl (%rax), %edx testl %edx, %edx je 0x2a033 addq $0x10, %rax leaq 0x484ef(%rip), %rcx # 0x72510 movl %edx, (%rcx) addq $0x4, %rcx movl (%rax), %edx addq $0x10, %rax testl %edx, %edx jne 0x2a021 jmp 0x2a03a leaq 0x484d6(%rip)...
/Dragonchang[P]https_client/mbedtls/library/cipher.c
mbedtls_cipher_info_from_values
const mbedtls_cipher_info_t *mbedtls_cipher_info_from_values( const mbedtls_cipher_id_t cipher_id, int key_bitlen, const mbedtls_cipher_mode_t mode ) { const mbedtls_cipher_definition_t *def; for( def = mbedtls_cipher_d...
leaq 0x46522(%rip), %rcx # 0x705f0 movq 0x8(%rcx), %rax testq %rax, %rax je 0x2a0fa addq $0x18, %rcx movq 0x28(%rax), %r8 cmpl %edi, (%r8) jne 0x2a0ee cmpl %esi, 0x8(%rax) jne 0x2a0ee cmpl %edx, 0x4(%rax) je 0x2a0fc movq (%rcx), %rax addq $0x10, %rcx testq %rax, %rax jne 0x2a0db xorl %eax, %eax retq
/Dragonchang[P]https_client/mbedtls/library/cipher.c
mbedtls_cipher_set_padding_mode
int mbedtls_cipher_set_padding_mode( mbedtls_cipher_context_t *ctx, mbedtls_cipher_padding_t mode ) { if( NULL == ctx || MBEDTLS_MODE_CBC != ctx->cipher_info->mode ) { return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA ); } switch( mode ) { #if defined(MBEDTLS_CIPHER_PADDING_PKCS7) case ...
movl $0xffff9f00, %eax # imm = 0xFFFF9F00 testq %rdi, %rdi je 0x2a206 movq (%rdi), %rcx cmpl $0x2, 0x4(%rcx) jne 0x2a206 movl $0xffff9f80, %eax # imm = 0xFFFF9F80 cmpl $0x4, %esi ja 0x2a206 movl %esi, %eax leaq 0x45ae3(%rip), %rcx # 0x6fcd0 movq (%rcx,%rax,8), %rcx leaq 0x45b00(%rip), %rdx # 0x6fcf8...
/Dragonchang[P]https_client/mbedtls/library/cipher.c
mbedtls_cipher_update_ad
int mbedtls_cipher_update_ad( mbedtls_cipher_context_t *ctx, const unsigned char *ad, size_t ad_len ) { if( NULL == ctx || NULL == ctx->cipher_info ) return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA ); if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode ) { return mbedtls_gcm_star...
movl $0xffff9f00, %eax # imm = 0xFFFF9F00 testq %rdi, %rdi je 0x2a314 movq %rdx, %r9 movq %rdi, %rdx movq (%rdi), %rcx testq %rcx, %rcx je 0x2a314 xorl %eax, %eax cmpl $0x6, 0x4(%rcx) jne 0x2a314 movq %rsi, %r8 movq 0x50(%rdx), %rdi movl 0xc(%rdx), %esi movq 0x48(%rdx), %rcx addq $0x38, %rdx jmp 0x37eb0 retq
/Dragonchang[P]https_client/mbedtls/library/cipher.c
mbedtls_cipher_finish
int mbedtls_cipher_finish( mbedtls_cipher_context_t *ctx, unsigned char *output, size_t *olen ) { if( NULL == ctx || NULL == ctx->cipher_info || NULL == olen ) return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA ); *olen = 0; if( MBEDTLS_MODE_CFB == ctx->cipher_info->mode || MBEDT...
pushq %r15 pushq %r14 pushq %rbx movl $0xffff9f00, %eax # imm = 0xFFFF9F00 testq %rdi, %rdi je 0x2a704 movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 movq (%rdi), %rcx testq %rcx, %rcx sete %dl testq %rbx, %rbx sete %sil orb %dl, %sil jne 0x2a704 movq $0x0, (%rbx) movl 0x4(%rcx), %edx decl %edx cmpl $0x6, %edx j...
/Dragonchang[P]https_client/mbedtls/library/cipher.c
get_one_and_zeros_padding
static int get_one_and_zeros_padding( unsigned char *input, size_t input_len, size_t *data_len ) { size_t i; unsigned char done = 0, prev_done, bad; if( NULL == input || NULL == data_len ) return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA ); bad = 0xFF; *data_...
testq %rdi, %rdi sete %al testq %rdx, %rdx sete %cl orb %al, %cl movl $0xffff9f00, %eax # imm = 0xFFFF9F00 jne 0x2a82f movq $0x0, (%rdx) testq %rsi, %rsi je 0x2a830 decq %rsi xorl %ecx, %ecx movb $-0x1, %al xorl %r8d, %r8d xorl %r9d, %r9d cmpb $0x0, (%rdi,%rsi) setne %r9b orl %r8d, %r9d cmpl %r8d, %r9d sete %r8b ...
/Dragonchang[P]https_client/mbedtls/library/cipher.c
mbedtls_cipher_write_tag
int mbedtls_cipher_write_tag( mbedtls_cipher_context_t *ctx, unsigned char *tag, size_t tag_len ) { if( NULL == ctx || NULL == ctx->cipher_info || NULL == tag ) return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA ); if( MBEDTLS_ENCRYPT != ctx->operation ) return( MBEDTLS_ERR_CIPHER_...
movl $0xffff9f00, %eax # imm = 0xFFFF9F00 testq %rdi, %rdi je 0x2a983 movq (%rdi), %rcx testq %rcx, %rcx sete %r8b testq %rsi, %rsi sete %r9b orb %r8b, %r9b jne 0x2a983 cmpl $0x1, 0xc(%rdi) jne 0x2a983 xorl %eax, %eax cmpl $0x6, 0x4(%rcx) jne 0x2a983 movq 0x50(%rdi), %rdi jmp 0x38312 retq
/Dragonchang[P]https_client/mbedtls/library/cipher.c
mbedtls_cipher_crypt
int mbedtls_cipher_crypt( mbedtls_cipher_context_t *ctx, const unsigned char *iv, size_t iv_len, const unsigned char *input, size_t ilen, unsigned char *output, size_t *olen ) { int ret; size_t finish_olen; if( ( ret = mbedtls_cipher_set_iv( ctx, iv, iv...
movl $0xffff9f00, %eax # imm = 0xFFFF9F00 testq %rdi, %rdi je 0x2aac4 pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rcx, %r12 movq %rdx, %r13 movq %rdi, %r14 movq (%rdi), %rcx testq %rcx, %rcx sete %dl testq %rsi, %rsi sete %dil orb %dl, %dil jne 0x2aab6 movl $0xffff9f80, %eax...
/Dragonchang[P]https_client/mbedtls/library/cipher.c
mbedtls_cipher_auth_decrypt
int mbedtls_cipher_auth_decrypt( mbedtls_cipher_context_t *ctx, const unsigned char *iv, size_t iv_len, const unsigned char *ad, size_t ad_len, const unsigned char *input, size_t ilen, unsigned char *output, size_t *olen...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %r9, %r10 movq %r8, %r9 movq %rcx, %r8 movq %rdx, %rcx movq %rsi, %rdx movq 0x50(%rsp), %rbx movq 0x48(%rsp), %r11 movq 0x40(%rsp), %r15 movq 0x38(%rsp), %r14 movq 0x30(%rsp), %rsi movq (%rdi), %rax movl 0x4(%rax), %ebp cmpl $0x8, %ebp je 0x2abc1 movl $0xffff9...
/Dragonchang[P]https_client/mbedtls/library/cipher.c
camellia_ctx_alloc
static void * camellia_ctx_alloc( void ) { mbedtls_camellia_context *ctx; ctx = mbedtls_calloc( 1, sizeof( mbedtls_camellia_context ) ); if( ctx == NULL ) return( NULL ); mbedtls_camellia_init( ctx ); return( ctx ); }
pushq %rbx movl $0x1, %edi movl $0x114, %esi # imm = 0x114 callq 0xf1d0 movq %rax, %rbx testq %rax, %rax je 0x2adb6 movq %rbx, %rdi callq 0x46d38 movq %rbx, %rax popq %rbx retq
/Dragonchang[P]https_client/mbedtls/library/cipher_wrap.c
mbedtls_ctr_drbg_seed_entropy_len
int mbedtls_ctr_drbg_seed_entropy_len( mbedtls_ctr_drbg_context *ctx, int (*f_entropy)(void *, unsigned char *, size_t), void *p_entropy, const unsigned char *custom, size_t len, size_t entropy_len ) { ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp movq %r9, %rbx movq %r8, 0x8(%rsp) movq %rcx, (%rsp) movq %rdx, %r12 movq %rsi, %r13 movq %rdi, %rbp xorps %xmm0, %xmm0 leaq 0x10(%rsp), %r14 movaps %xmm0, 0x10(%r14) movaps %xmm0, (%r14) leaq 0x28(%rdi), %r15 movq %r15, %rdi callq 0x441...
/Dragonchang[P]https_client/mbedtls/library/ctr_drbg.c
mbedtls_ctr_drbg_free
void mbedtls_ctr_drbg_free( mbedtls_ctr_drbg_context *ctx ) { if( ctx == NULL ) return; #if defined(MBEDTLS_THREADING_C) mbedtls_mutex_free( &ctx->mutex ); #endif mbedtls_aes_free( &ctx->aes_ctx ); mbedtls_zeroize( ctx, sizeof( mbedtls_ctr_drbg_context ) ); }
testq %rdi, %rdi je 0x2b023 pushq %rbx movq %rdi, %rbx addq $0x28, %rdi callq 0x44208 xorl %eax, %eax movb $0x0, (%rbx,%rax) incq %rax cmpq $0x158, %rax # imm = 0x158 jne 0x2b013 popq %rbx retq
/Dragonchang[P]https_client/mbedtls/library/ctr_drbg.c
mbedtls_ctr_drbg_random_with_add
int mbedtls_ctr_drbg_random_with_add( void *p_rng, unsigned char *output, size_t output_len, const unsigned char *additional, size_t add_len ) { int ret = 0; mbedtls_ctr_drbg_context *ctx = (mbedtls_ctr_drbg_context *) p_rng; unsigned char add_inpu...
movl $0xffffffca, %eax # imm = 0xFFFFFFCA cmpq $0x400, %rdx # imm = 0x400 ja 0x2b3a8 movl $0xffffffc8, %eax # imm = 0xFFFFFFC8 cmpq $0x100, %r8 # imm = 0x100 ja 0x2b3a8 pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x48, %rsp movq %rdx, %r14 movq %rsi, %r15 m...
/Dragonchang[P]https_client/mbedtls/library/ctr_drbg.c
mbedtls_des_setkey_dec
int mbedtls_des_setkey_dec( mbedtls_des_context *ctx, const unsigned char key[MBEDTLS_DES_KEY_SIZE] ) { int i; mbedtls_des_setkey( ctx->sk, key ); for( i = 0; i < 16; i += 2 ) { SWAP( ctx->sk[i ], ctx->sk[30 - i] ); SWAP( ctx->sk[i + 1], ctx->sk[31 - i] ); } return( 0 ); }
pushq %rbx movq %rdi, %rbx callq 0x2b8db leaq 0x7c(%rbx), %rax movq $-0x2, %rcx movl 0x8(%rbx,%rcx,4), %edx movl -0x4(%rax), %esi movl %esi, 0x8(%rbx,%rcx,4) movl %edx, -0x4(%rax) movl 0xc(%rbx,%rcx,4), %edx movl (%rax), %esi movl %esi, 0xc(%rbx,%rcx,4) movl %edx, (%rax) addq $0x2, %rcx addq $-0x8, %rax cmpq $0xe, %rcx...
/Dragonchang[P]https_client/mbedtls/library/des.c
des3_set2key
static void des3_set2key( uint32_t esk[96], uint32_t dsk[96], const unsigned char key[MBEDTLS_DES_KEY_SIZE*2] ) { int i; mbedtls_des_setkey( esk, key ); mbedtls_des_setkey( dsk + 32, key + 8 ); for( i = 0; i < 32; i += 2 ) { dsk[i ] =...
pushq %r15 pushq %r14 pushq %rbx movq %rdx, %r15 movq %rsi, %rbx movq %rdi, %r14 movq %rdx, %rsi callq 0x2b8db leaq 0x80(%rbx), %rdi addq $0x8, %r15 movq %r15, %rsi callq 0x2b8db movl $0x40, %ecx movl $0x3f, %eax movl -0x84(%r14,%rax,4), %edx movl %edx, -0x100(%rbx,%rcx,4) movl -0x80(%r14,%rax,4), %edx movl %edx, -0xfc...
/Dragonchang[P]https_client/mbedtls/library/des.c
mbedtls_des3_crypt_cbc
int mbedtls_des3_crypt_cbc( mbedtls_des3_context *ctx, int mode, size_t length, unsigned char iv[8], const unsigned char *input, unsigned char *output ) { int i; unsigned char temp[8]; if( length % 8 ) ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdx, %r12 movl $0xffffffce, %eax # imm = 0xFFFFFFCE testb $0x7, %r12b jne 0x2c7de movq %r9, %rbx movq %r8, %r14 movq %rcx, %r15 movq %rdi, %r13 cmpl $0x1, %esi jne 0x2c7a3 testq %r12, %r12 je 0x2c7dc xorl %eax, %eax movb (%r15,%rax...
/Dragonchang[P]https_client/mbedtls/library/des.c
mbedtls_dhm_make_params
int mbedtls_dhm_make_params( mbedtls_dhm_context *ctx, int x_size, unsigned char *output, size_t *olen, int (*f_rng)(void *, unsigned char *, size_t), void *p_rng ) { int ret, count = 0; size_t n1, n2, n3; unsigned char *p; if( mbedtls_mpi_...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp movq %r9, 0x8(%rsp) movq %r8, %rbp movq %rcx, %rbx movq %rdx, 0x10(%rsp) movl %esi, %r15d movq %rdi, %r13 leaq 0x8(%rdi), %r12 xorl %r14d, %r14d movq %r12, %rdi xorl %esi, %esi callq 0x26ad2 testl %eax, %eax je 0x2cf03 movq %rbx, 0x28(%r...
/Dragonchang[P]https_client/mbedtls/library/dhm.c
mbedtls_dhm_make_public
int mbedtls_dhm_make_public( mbedtls_dhm_context *ctx, int x_size, unsigned char *output, size_t olen, int (*f_rng)(void *, unsigned char *, size_t), void *p_rng ) { int ret, count = 0; if( ctx == NULL || olen < 1 || olen > ctx->len ) retur...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rcx, %rbx testq %rdi, %rdi sete %al testq %rcx, %rcx sete %cl orb %al, %cl movl $0xffffcf80, %r14d # imm = 0xFFFFCF80 jne 0x2d11d movq %rdi, %r15 cmpq %rbx, (%rdi) jb 0x2d11d movl %esi, %r13d movq %r8, 0x8(%rsp) movq %r9, 0x10...
/Dragonchang[P]https_client/mbedtls/library/dhm.c
mbedtls_ecp_curve_info_from_grp_id
const mbedtls_ecp_curve_info *mbedtls_ecp_curve_info_from_grp_id( mbedtls_ecp_group_id grp_id ) { const mbedtls_ecp_curve_info *curve_info; for( curve_info = mbedtls_ecp_curve_list(); curve_info->grp_id != MBEDTLS_ECP_DP_NONE; curve_info++ ) { if( curve_info->grp_id == grp_id ) ...
leaq 0x43011(%rip), %rax # 0x70c60 movl $0x5, %ecx cmpl %edi, %ecx je 0x2dc65 movl 0x10(%rax), %ecx addq $0x10, %rax testl %ecx, %ecx jne 0x2dc54 xorl %eax, %eax retq
/Dragonchang[P]https_client/mbedtls/library/ecp.c
mbedtls_ecp_point_write_binary
int mbedtls_ecp_point_write_binary( const mbedtls_ecp_group *grp, const mbedtls_ecp_point *P, int format, size_t *olen, unsigned char *buf, size_t buflen ) { int ret = 0; size_t plen; if( format != MBEDTLS_ECP_PF_UNCOMPRESSED && format != MBED...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movl $0xffffb080, %eax # imm = 0xFFFFB080 cmpl $0x1, %edx jbe 0x2dfa5 addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %r9, %r12 movq %r8, %rbx movq %rcx, %r13 movl %edx, %ebp movq %rsi, %r14 movq %rd...
/Dragonchang[P]https_client/mbedtls/library/ecp.c
mbedtls_ecp_tls_read_point
int mbedtls_ecp_tls_read_point( const mbedtls_ecp_group *grp, mbedtls_ecp_point *pt, const unsigned char **buf, size_t buf_len ) { unsigned char data_len; const unsigned char *buf_start; /* * We must have at least two bytes (1 for length, at least one for data) */ if( ...
cmpq $0x2, %rcx jb 0x2e158 movq (%rdx), %r8 leaq 0x1(%r8), %rax movq %rax, (%rdx) movzbl (%r8), %r8d testq %r8, %r8 je 0x2e158 decq %rcx cmpq %r8, %rcx jae 0x2e15e movl $0xffffb080, %eax # imm = 0xFFFFB080 retq leaq (%rax,%r8), %rcx movq %rcx, (%rdx) movq %rax, %rdx movq %r8, %rcx jmp 0x2e07e
/Dragonchang[P]https_client/mbedtls/library/ecp.c
mbedtls_ecp_tls_write_group
int mbedtls_ecp_tls_write_group( const mbedtls_ecp_group *grp, size_t *olen, unsigned char *buf, size_t blen ) { const mbedtls_ecp_curve_info *curve_info; if( ( curve_info = mbedtls_ecp_curve_info_from_grp_id( grp->id ) ) == NULL ) return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA ); ...
movl (%rdi), %eax movl $0x5, %r8d leaq 0x42a62(%rip), %rdi # 0x70c70 cmpl %eax, %r8d je 0x2e225 movl (%rdi), %r8d addq $0x10, %rdi testl %r8d, %r8d jne 0x2e20e movl $0xffffb080, %eax # imm = 0xFFFFB080 retq movq $0x3, (%rsi) movl $0xffffb100, %eax # imm = 0xFFFFB100 cmpq $0x3, %rcx jb 0x2e246 movb $0x3,...
/Dragonchang[P]https_client/mbedtls/library/ecp.c
ecp_mul_comb
static int ecp_mul_comb( mbedtls_ecp_group *grp, mbedtls_ecp_point *R, const mbedtls_mpi *m, const mbedtls_ecp_point *P, int (*f_rng)(void *, unsigned char *, size_t), void *p_rng ) { int ret; unsigned char w, m_is_odd, p_eq_g, pre_len, ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x1a8, %rsp # imm = 0x1A8 movq %r9, %r14 movq %r8, %rbx movq %rcx, %rbp movq %rdx, 0x28(%rsp) movq %rsi, %r12 movq %rdi, %r15 leaq 0x70(%rsp), %rdi callq 0x258f8 leaq 0x88(%rsp), %rdi callq 0x258f8 leaq 0x98(%r15), %rdi movq %rdi, 0x68(%...
/Dragonchang[P]https_client/mbedtls/library/ecp.c
mbedtls_ecp_gen_keypair_base
int mbedtls_ecp_gen_keypair_base( mbedtls_ecp_group *grp, const mbedtls_ecp_point *G, mbedtls_mpi *d, mbedtls_ecp_point *Q, int (*f_rng)(void *, unsigned char *, size_t), void *p_rng ) { int ret; size_t n_size = ( grp->nbits + 7...
cmpq $0x0, 0x60(%rdi) je 0x2fd59 pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x78, %rsp movq %r9, %rbx movq %r8, %r14 movq %rdx, %r12 movq %rsi, %rbp movq %rcx, 0x20(%rsp) movq 0xb8(%rdi), %r13 addq $0x7, %r13 movq %r13, %r15 shrq $0x3, %r15 movq %rdi, 0x8(%rsp) cmpq $0x0, 0x78(%rdi) je 0x2f...
/Dragonchang[P]https_client/mbedtls/library/ecp.c
ecp_comb_fixed
static void ecp_comb_fixed( unsigned char x[], size_t d, unsigned char w, const mbedtls_mpi *m ) { size_t i, j; unsigned char c, cc, adjust; memset( x, 0, d+1 ); /* First get the classical comb values (except for x_d = 0) */ for( i = 0; i < d; i++ ) for( j = 0; ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rcx, %r15 movl %edx, %ebp movq %rsi, %rbx movq %rdi, %r14 leaq 0x1(%rsi), %rdx xorl %esi, %esi callq 0xf150 testq %rbx, %rbx je 0x307b4 movq %rbx, %r10 movzbl %bpl, %eax xorl %ebx, %ebx movl %ebp, 0xc(%rsp) movq %rax, 0x10(%rsp) te...
/Dragonchang[P]https_client/mbedtls/library/ecp.c
ecp_normalize_jac_many
static int ecp_normalize_jac_many( const mbedtls_ecp_group *grp, mbedtls_ecp_point *T[], size_t t_len ) { int ret; size_t i; mbedtls_mpi *c, u, Zi, ZZi; if( t_len < 2 ) return( ecp_normalize_jac( grp, *T ) ); if( ( c = mbedtls_calloc( t_len, sizeof( mbedt...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x68, %rsp movq %rsi, %r12 movq %rdi, %r15 cmpq $0x1, %rdx ja 0x3131e movq (%r12), %rsi movq %r15, %rdi addq $0x68, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp jmp 0x2fae8 movq %rdx, %rbx movl $0x18, %esi movq %rdx, %rdi callq ...
/Dragonchang[P]https_client/mbedtls/library/ecp.c
mbedtls_ecp_group_load
int mbedtls_ecp_group_load( mbedtls_ecp_group *grp, mbedtls_ecp_group_id id ) { mbedtls_ecp_group_free( grp ); grp->id = id; switch( id ) { #if defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED) case MBEDTLS_ECP_DP_SECP192R1: NIST_MODP( p192 ); return( LOAD_GROUP( secp192r1 ) );...
pushq %r15 pushq %r14 pushq %rbx movl %esi, %r14d movq %rdi, %rbx callq 0x2dd5b movl %r14d, (%rbx) decl %r14d cmpl $0xb, %r14d ja 0x31af5 leaq 0x25ca1(%rip), %rax # 0x573a0 movslq (%rax,%r14,4), %rcx addq %rax, %rcx jmpq *%rcx leaq 0x412(%rip), %rax # 0x31b21 movq %rax, 0xc8(%rbx) subq $0x8, %rsp movl $0x18, ...
/Dragonchang[P]https_client/mbedtls/library/ecp_curves.c
ecp_group_load
static int ecp_group_load( mbedtls_ecp_group *grp, const mbedtls_mpi_uint *p, size_t plen, const mbedtls_mpi_uint *a, size_t alen, const mbedtls_mpi_uint *b, size_t blen, const mbedtls_mpi_uint *gx, size_t gxl...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdi, %rbx movq 0x70(%rsp), %r13 movq 0x68(%rsp), %r12 movq 0x60(%rsp), %r10 movq 0x58(%rsp), %rax movq 0x50(%rsp), %r15 movq 0x48(%rsp), %r11 movq 0x40(%rsp), %r14 addq $0x8, %rdi movl $0x1, 0x8(%rbx) shrq $0x3, %rdx movq %rdx, 0x10(%rbx...
/Dragonchang[P]https_client/mbedtls/library/ecp_curves.c
ecp_mod_koblitz
static inline int ecp_mod_koblitz( mbedtls_mpi *N, mbedtls_mpi_uint *Rp, size_t p_limbs, size_t adjust, size_t shift, mbedtls_mpi_uint mask ) { int ret; size_t i; mbedtls_mpi M, R; mbedtls_mpi_uint Mp[P_KOBLITZ_MAX + P_KOBLITZ_R + 1]; if( N->n < p_limbs ) ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x88, %rsp movq 0x8(%rdi), %r12 xorl %eax, %eax cmpq %rdx, %r12 jb 0x32b4b movq %rcx, %r13 movq %rdx, %r14 movq %rdi, %rbx movq %r9, 0x20(%rsp) movl $0x1, %eax movl %eax, 0x38(%rsp) movq %rsi, 0x48(%rsp) movq $0x1, 0x40(%rsp) movl %eax, 0x8(%rsp) l...
/Dragonchang[P]https_client/mbedtls/library/ecp_curves.c
mbedtls_entropy_add_source
int mbedtls_entropy_add_source( mbedtls_entropy_context *ctx, mbedtls_entropy_f_source_ptr f_source, void *p_source, size_t threshold, int strong ) { int index, ret = 0; #if defined(MBEDTLS_THREADING_C) if( ( ret = mbedtls_mutex_lock( &ctx->mutex ) ) != 0 ) ...
movslq 0xd8(%rdi), %r9 movl $0xffffffc2, %eax # imm = 0xFFFFFFC2 cmpq $0x13, %r9 jg 0x32d0d leaq (%r9,%r9,4), %rax movq %rsi, 0xe0(%rdi,%rax,8) movq %rdx, 0xe8(%rdi,%rax,8) movq %rcx, 0xf8(%rdi,%rax,8) movl %r8d, 0x100(%rdi,%rax,8) leal 0x1(%r9), %eax movl %eax, 0xd8(%rdi) xorl %eax, %eax retq
/Dragonchang[P]https_client/mbedtls/library/entropy.c
mbedtls_entropy_func
int mbedtls_entropy_func( void *data, unsigned char *output, size_t len ) { int ret, count = 0, i, done; mbedtls_entropy_context *ctx = (mbedtls_entropy_context *) data; unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE]; if( len > MBEDTLS_ENTROPY_BLOCK_SIZE ) return( MBEDTLS_ERR_ENTROPY_SOURCE_FAIL...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x48, %rsp movl $0xffffffc4, %ebp # imm = 0xFFFFFFC4 cmpq $0x40, %rdx ja 0x33023 movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 xorl %r12d, %r12d xorl %r13d, %r13d cmpl $0x101, %r13d # imm = 0x101 je 0x33023 movq %r15, %rdi callq 0...
/Dragonchang[P]https_client/mbedtls/library/entropy.c
mbedtls_entropy_update_seed_file
int mbedtls_entropy_update_seed_file( mbedtls_entropy_context *ctx, const char *path ) { FILE *f; size_t n; unsigned char buf[ MBEDTLS_ENTROPY_MAX_SEED_SIZE ]; if( ( f = fopen( path, "rb" ) ) == NULL ) return( MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR ); fseek( f, 0, SEEK_END ); n = (size_t) f...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x408, %rsp # imm = 0x408 movq %rsi, %rbx movq %rdi, %r14 leaq 0x233a9(%rip), %rsi # 0x56473 movq %rbx, %rdi callq 0xf2f0 movl $0xffffffc1, %ebp # imm = 0xFFFFFFC1 testq %rax, %rax je 0x33155 movq %rax, %r15 movq %rax, %rdi xor...
/Dragonchang[P]https_client/mbedtls/library/entropy.c
mbedtls_platform_entropy_poll
int mbedtls_platform_entropy_poll( void *data, unsigned char *output, size_t len, size_t *olen ) { FILE *file; size_t read_len; ((void) data); #if defined(HAVE_GETRANDOM) if( has_getrandom == -1 ) has_getrandom = ( check_version_3_17_plus() == 0 ); if( has_getran...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x190, %rsp # imm = 0x190 movq %rcx, %rbx movq %rdx, %r14 movq %rsi, %r15 movl 0x3ef4e(%rip), %eax # 0x722a0 cmpl $-0x1, %eax jne 0x333a2 leaq 0xa(%rsp), %r12 movq %r12, %rdi callq 0xf130 movb 0x82(%r12), %cl leal -0x33(%rcx), %eax cmpb $0x6, %...
/Dragonchang[P]https_client/mbedtls/library/entropy_poll.c
mbedtls_gcm_setkey
int mbedtls_gcm_setkey( mbedtls_gcm_context *ctx, mbedtls_cipher_id_t cipher, const unsigned char *key, unsigned int keybits ) { int ret; const mbedtls_cipher_info_t *cipher_info; cipher_info = mbedtls_cipher_info_from_values( cipher, ...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x18, %rsp movl %ecx, %ebp movq %rdx, %r14 movq %rdi, %rbx movl %esi, %edi movl %ecx, %esi movl $0x1, %edx callq 0x2a0c7 movq %rax, %r15 movl $0xffffffec, %eax # imm = 0xFFFFFFEC testq %r15, %r15 je 0x37ea5 cmpl $0x10, 0x20(%r15) jne 0x37ea5 movq %rbx, %rdi callq ...
/Dragonchang[P]https_client/mbedtls/library/gcm.c
mbedtls_gcm_crypt_and_tag
int mbedtls_gcm_crypt_and_tag( mbedtls_gcm_context *ctx, int mode, size_t length, const unsigned char *iv, size_t iv_len, const unsigned char *add, size_t add_len, ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %r9, %rax movq %rdx, %r12 movq %rdi, %rbx movq 0x60(%rsp), %r15 movq 0x58(%rsp), %r14 movq 0x50(%rsp), %r13 movq 0x48(%rsp), %rbp movq 0x40(%rsp), %r9 movq %rcx, %rdx movq %r8, %rcx movq %rax, %r8 callq 0x37eb0 testl %eax, %eax jne 0x384f...
/Dragonchang[P]https_client/mbedtls/library/gcm.c
mbedtls_md_hmac_finish
int mbedtls_md_hmac_finish( mbedtls_md_context_t *ctx, unsigned char *output ) { unsigned char tmp[MBEDTLS_MD_MAX_SIZE]; unsigned char *opad; if( ctx == NULL || ctx->md_info == NULL || ctx->hmac_ctx == NULL ) return( MBEDTLS_ERR_MD_BAD_INPUT_DATA ); opad = (unsigned char *) ctx->hmac_ctx + ctx...
movl $0xffffaf00, %eax # imm = 0xFFFFAF00 testq %rdi, %rdi je 0x39149 pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x48, %rsp movq %rdi, %r14 movq (%rdi), %rcx testq %rcx, %rcx je 0x3913e movq 0x10(%r14), %r15 testq %r15, %r15 je 0x3913e movq %rsi, %rbx movslq 0x14(%rcx), %rax addq %rax, %r15 movq 0x8(%r14),...
/Dragonchang[P]https_client/mbedtls/library/md.c
mbedtls_md_hmac_reset
int mbedtls_md_hmac_reset( mbedtls_md_context_t *ctx ) { unsigned char *ipad; if( ctx == NULL || ctx->md_info == NULL || ctx->hmac_ctx == NULL ) return( MBEDTLS_ERR_MD_BAD_INPUT_DATA ); ipad = (unsigned char *) ctx->hmac_ctx; ctx->md_info->starts_func( ctx->md_ctx ); ctx->md_info->update_...
movl $0xffffaf00, %eax # imm = 0xFFFFAF00 testq %rdi, %rdi je 0x3918d pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movq (%rdi), %rcx testq %rcx, %rcx je 0x39186 movq 0x10(%rbx), %r14 testq %r14, %r14 je 0x39186 movq 0x8(%rbx), %rdi callq *0x18(%rcx) movq (%rbx), %rax movq 0x8(%rbx), %rdi movslq 0x14(%rax), %r...
/Dragonchang[P]https_client/mbedtls/library/md.c
mbedtls_md5_self_test
int mbedtls_md5_self_test( int verbose ) { int i; unsigned char md5sum[16]; for( i = 0; i < 7; i++ ) { if( verbose != 0 ) mbedtls_printf( " MD5 test #%d: ", i + 1 ); mbedtls_md5( md5_test_buf[i], md5_test_buflen[i], md5sum ); if( memcmp( md5sum, md5_test_sum[i], 1...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movl %edi, %ebx leaq 0x2275b(%rip), %r13 # 0x5c430 leaq 0x22994(%rip), %rbp # 0x5c670 movq %rsp, %r14 leaq 0x229aa(%rip), %r15 # 0x5c690 xorl %r12d, %r12d testl %ebx, %ebx je 0x39d00 leal 0x1(%r12), %esi leaq 0x22717(%rip), %...
/Dragonchang[P]https_client/mbedtls/library/md5.c
mbedtls_oid_get_numeric_string
int mbedtls_oid_get_numeric_string( char *buf, size_t size, const mbedtls_asn1_buf *oid ) { int ret; size_t i, n; unsigned int value; char *p; p = buf; n = size; /* First byte contains first two dots */ if( oid->len > 0 ) { ret = mbedtls_snprintf...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rsi, %rbx cmpq $0x0, 0x8(%rdx) movq %rsi, %r12 je 0x3a504 movq %rdx, %r14 movq %rdi, %r15 movq 0x10(%rdx), %rax movzbl (%rax), %eax imull $0xcd, %eax, %ecx shrl $0xd, %ecx leal (,%rcx,8), %edx leal (%rdx,%rdx,4), %edx subb %dl, %al movzb...
/Dragonchang[P]https_client/mbedtls/library/oid.c
mbedtls_pem_read_buffer
int mbedtls_pem_read_buffer( mbedtls_pem_context *ctx, const char *header, const char *footer, const unsigned char *data, const unsigned char *pwd, size_t pwdlen, size_t *use_len ) { int ret, enc; size_t len; unsigned char *buf; const unsigned char *s1, *s2, *en...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp testq %rdi, %rdi je 0x3a6c5 movq %rcx, %r13 movq %rdx, %r14 movq %rsi, %r15 movq %rdi, %rbx movq %r8, 0x30(%rsp) movq %r9, 0x28(%rsp) movq %rcx, %rdi callq 0xf360 movl $0xffffef80, %ebp # imm = 0xFFFFEF80 testq %rax, %rax je 0x3a6c...
/Dragonchang[P]https_client/mbedtls/library/pem.c
pem_des_decrypt
static void pem_des_decrypt( unsigned char des_iv[8], unsigned char *buf, size_t buflen, const unsigned char *pwd, size_t pwdlen ) { mbedtls_des_context des_ctx; unsigned char des_key[8]; mbedtls_des_init( &des_ctx ); pem_pbkdf1( des_key, 8...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x98, %rsp movq %r8, %rbx movq %rcx, %r14 movq %rdx, 0x8(%rsp) movq %rsi, %r12 movq %rdi, %r13 leaq 0x18(%rsp), %rbp movq %rbp, %rdi callq 0x2b810 leaq 0x10(%rsp), %r15 movl $0x8, %esi movq %r15, %rdi movq %r13, %rdx movq %r14, %rcx movq %rbx, %r8 ...
/Dragonchang[P]https_client/mbedtls/library/pem.c
pem_pbkdf1
static void pem_pbkdf1( unsigned char *key, size_t keylen, unsigned char *iv, const unsigned char *pwd, size_t pwdlen ) { mbedtls_md5_context md5_ctx; unsigned char md5sum[16]; size_t use_len; mbedtls_md5_init( &md5_ctx ); /* * key[ 0..15] = MD5...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x68, %rsp movq %r8, %r12 movq %rcx, %r13 movq %rdx, %r15 movq %rsi, %r14 movq %rdi, %rbx leaq 0x10(%rsp), %rbp movq %rbp, %rdi callq 0x3928c movq %rbp, %rdi callq 0x392c8 movq %rbp, %rdi movq %r13, %rsi movq %r12, %rdx callq 0x39a96 movl $0x8, %ed...
/Dragonchang[P]https_client/mbedtls/library/pem.c
mbedtls_pk_verify
int mbedtls_pk_verify( mbedtls_pk_context *ctx, mbedtls_md_type_t md_alg, const unsigned char *hash, size_t hash_len, const unsigned char *sig, size_t sig_len ) { if( ctx == NULL || ctx->pk_info == NULL || pk_hashlen_helper( md_alg, &hash_len ) != 0 ) return( MBEDTLS_ER...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movl $0xffffc180, %r13d # imm = 0xFFFFC180 testq %rdi, %rdi je 0x3b14e movq %rdi, %r12 movq (%rdi), %rax testq %rax, %rax je 0x3b14e movq %r9, %rbx movq %r8, %r14 movq %rdx, %r15 movl %esi, %ebp testq %rcx, %rcx jne 0x3b11f movl %ebp, %ed...
/Dragonchang[P]https_client/mbedtls/library/pk.c
mbedtls_pk_decrypt
int mbedtls_pk_decrypt( mbedtls_pk_context *ctx, const unsigned char *input, size_t ilen, unsigned char *output, size_t *olen, size_t osize, int (*f_rng)(void *, unsigned char *, size_t), void *p_rng ) { if( ctx == NULL || ctx->pk_info == NULL ) return( MBEDTL...
movl $0xffffc180, %eax # imm = 0xFFFFC180 testq %rdi, %rdi je 0x3b366 movq (%rdi), %r10 testq %r10, %r10 je 0x3b366 movq 0x30(%r10), %rax testq %rax, %rax je 0x3b361 movq 0x8(%rdi), %rdi jmpq *%rax movl $0xffffc100, %eax # imm = 0xFFFFC100 retq
/Dragonchang[P]https_client/mbedtls/library/pk.c
mbedtls_pk_check_pair
int mbedtls_pk_check_pair( const mbedtls_pk_context *pub, const mbedtls_pk_context *prv ) { if( pub == NULL || pub->pk_info == NULL || prv == NULL || prv->pk_info == NULL || prv->pk_info->check_pair_func == NULL ) { return( MBEDTLS_ERR_PK_BAD_INPUT_DATA ); } if( prv->pk_info->ty...
movl $0xffffc180, %eax # imm = 0xFFFFC180 testq %rdi, %rdi je 0x3b3e2 movq (%rdi), %rcx testq %rcx, %rcx sete %dl testq %rsi, %rsi sete %r8b orb %dl, %r8b jne 0x3b3e2 movq (%rsi), %r8 testq %r8, %r8 je 0x3b3e2 movq 0x40(%r8), %rdx testq %rdx, %rdx je 0x3b3e2 cmpl $0x5, (%r8) jne 0x3b3d8 movl $0xffffc100, %eax ...
/Dragonchang[P]https_client/mbedtls/library/pk.c
mbedtls_pk_debug
int mbedtls_pk_debug( const mbedtls_pk_context *ctx, mbedtls_pk_debug_item *items ) { if( ctx == NULL || ctx->pk_info == NULL ) return( MBEDTLS_ERR_PK_BAD_INPUT_DATA ); if( ctx->pk_info->debug_func == NULL ) return( MBEDTLS_ERR_PK_TYPE_MISMATCH ); ctx->pk_info->debug_func( ctx->pk_ctx, ite...
movl $0xffffc180, %eax # imm = 0xFFFFC180 testq %rdi, %rdi je 0x3b422 movq (%rdi), %rcx testq %rcx, %rcx je 0x3b422 movq 0x58(%rcx), %rax testq %rax, %rax je 0x3b423 pushq %rax movq 0x8(%rdi), %rdi callq *%rax xorl %eax, %eax addq $0x8, %rsp retq movl $0xffffc100, %eax # imm = 0xFFFFC100 retq
/Dragonchang[P]https_client/mbedtls/library/pk.c
rsa_debug
static void rsa_debug( const void *ctx, mbedtls_pk_debug_item *items ) { items->type = MBEDTLS_PK_DEBUG_MPI; items->name = "rsa.N"; items->value = &( ((mbedtls_rsa_context *) ctx)->N ); items++; items->type = MBEDTLS_PK_DEBUG_MPI; items->name = "rsa.E"; items->value = &( ((mbedtls_rsa_cont...
movl $0x1, %eax movl %eax, (%rsi) leaq 0x21bb7(%rip), %rcx # 0x5d197 movq %rcx, 0x8(%rsi) leaq 0x10(%rdi), %rcx movq %rcx, 0x10(%rsi) movl %eax, 0x18(%rsi) leaq 0x21ba7(%rip), %rax # 0x5d19d movq %rax, 0x20(%rsi) addq $0x28, %rdi movq %rdi, 0x28(%rsi) retq
/Dragonchang[P]https_client/mbedtls/library/pk_wrap.c
eckey_verify_wrap
static int eckey_verify_wrap( void *ctx, mbedtls_md_type_t md_alg, const unsigned char *hash, size_t hash_len, const unsigned char *sig, size_t sig_len ) { int ret; mbedtls_ecdsa_context ecdsa; mbedtls_ecdsa_init( &ecdsa ); if( ( ret = mbedtls_ecdsa_from_k...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x158, %rsp # imm = 0x158 movq %r9, %rbx movq %r8, %r14 movq %rcx, %r15 movq %rdx, %r12 movq %rdi, %r13 movq %rsp, %rbp movq %rbp, %rdi callq 0x49317 movq %rbp, %rdi movq %r13, %rsi callq 0x492bd movl %eax, %ebp testl %eax, %eax jne 0x3b...
/Dragonchang[P]https_client/mbedtls/library/pk_wrap.c
rsa_alt_decrypt_wrap
static int rsa_alt_decrypt_wrap( void *ctx, const unsigned char *input, size_t ilen, unsigned char *output, size_t *olen, size_t osize, int (*f_rng)(void *, unsigned char *, size_t), void *p_rng ) { mbedtls_rsa_alt_context *rsa_alt = (mbedtls_rsa_alt_conte...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %r9, %rbx movq %r8, %r15 movq %rcx, %r14 movq %rdx, %rbp movq %rsi, %r12 movq %rdi, %r13 movq (%rdi), %rdi callq *0x18(%r13) cmpq %rbp, %rax jne 0x3b8c5 movq (%r13), %rdi movq 0x8(%r13), %rax movl $0x1, %esi movq %r15, %rdx movq %r12, %rc...
/Dragonchang[P]https_client/mbedtls/library/pk_wrap.c
rsa_alt_check_pair
static int rsa_alt_check_pair( const void *pub, const void *prv ) { unsigned char sig[MBEDTLS_MPI_MAX_SIZE]; unsigned char hash[32]; size_t sig_len = 0; int ret; if( rsa_alt_get_bitlen( prv ) != rsa_get_bitlen( pub ) ) return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED ); memset( hash, 0x2a, siz...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x428, %rsp # imm = 0x428 movq %rsi, %r14 movq %rdi, %rbx movq (%rsi), %rdi callq *0x18(%rsi) movq %rax, %rcx xorq 0x8(%rbx), %rcx shlq $0x3, %rcx movl $0xffffbe00, %eax # imm = 0xFFFFBE00 testq %rcx, %rcx jne 0x3b976 movaps 0x21861(%rip), %xmm0 # 0x...
/Dragonchang[P]https_client/mbedtls/library/pk_wrap.c
mbedtls_pk_parse_subpubkey
int mbedtls_pk_parse_subpubkey( unsigned char **p, const unsigned char *end, mbedtls_pk_context *pk ) { int ret; size_t len; mbedtls_asn1_buf alg_params; mbedtls_pk_type_t pk_alg = MBEDTLS_PK_NONE; const mbedtls_pk_info_t *pk_info; if( ( ret = mbedtls_asn1_get_tag( p, en...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movq %rdx, %rbx movq %rdi, %r14 movl $0x0, 0x4(%rsp) leaq 0x8(%rsp), %rdx movl $0x30, %ecx callq 0x2539d testl %eax, %eax je 0x3bfbb movl %eax, %ebp addl $0xffffc300, %ebp # imm = 0xFFFFC300 jmp 0x3c010 movq (%r14), %r15 addq 0x8(%rsp), %r15 leaq 0x4(%r...
/Dragonchang[P]https_client/mbedtls/library/pkparse.c
pk_get_ecpubkey
static int pk_get_ecpubkey( unsigned char **p, const unsigned char *end, mbedtls_ecp_keypair *key ) { int ret; if( ( ret = mbedtls_ecp_point_read_binary( &key->grp, &key->Q, (const unsigned char *) *p, end - *p ) ) == 0 ) { ret = mbedtls_ecp_check_pub...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rdx, %r15 movq %rsi, %rbx movq %rdi, %r14 leaq 0x110(%rdx), %r12 movq (%rdi), %rdx movq %rsi, %rcx subq %rdx, %rcx movq %r15, %rdi movq %r12, %rsi callq 0x2e07e testl %eax, %eax jne 0x3c6ec movq %r15, %rdi movq %r12, %rsi callq 0x2ec17 movq %rbx, (%r14) addq ...
/Dragonchang[P]https_client/mbedtls/library/pkparse.c
mbedtls_ripemd160_starts
void mbedtls_ripemd160_starts( mbedtls_ripemd160_context *ctx ) { ctx->total[0] = 0; ctx->total[1] = 0; ctx->state[0] = 0x67452301; ctx->state[1] = 0xEFCDAB89; ctx->state[2] = 0x98BADCFE; ctx->state[3] = 0x10325476; ctx->state[4] = 0xC3D2E1F0; }
movaps 0x1f5a9(%rip), %xmm0 # 0x5c3f0 movups %xmm0, (%rdi) movabsq $0x1032547698badcfe, %rax # imm = 0x1032547698BADCFE movq %rax, 0x10(%rdi) movl $0xc3d2e1f0, 0x18(%rdi) # imm = 0xC3D2E1F0 retq
/Dragonchang[P]https_client/mbedtls/library/ripemd160.c
mbedtls_ripemd160_update
void mbedtls_ripemd160_update( mbedtls_ripemd160_context *ctx, const unsigned char *input, size_t ilen ) { size_t fill; uint32_t left; if( ilen == 0 ) return; left = ctx->total[0] & 0x3F; fill = 64 - left; ctx->total[0] += (uint32_t) ilen; ctx->total[0] &= 0...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx testq %rdx, %rdx je 0x3e45c movq %rsi, %rbx movq %rdi, %r14 movl (%rdi), %ecx movl %ecx, %eax andl $0x3f, %eax movl %edx, %esi addl %ecx, %esi movl %esi, (%rdi) jae 0x3e3d7 incl 0x4(%r14) testl %eax, %eax je 0x3e415 movl $0x40, %r15d subq %rax, %r15 movq %rdx, %r13...
/Dragonchang[P]https_client/mbedtls/library/ripemd160.c
mbedtls_rsa_rsaes_oaep_decrypt
int mbedtls_rsa_rsaes_oaep_decrypt( mbedtls_rsa_context *ctx, int (*f_rng)(void *, unsigned char *, size_t), void *p_rng, int mode, const unsigned char *label, size_t label_len, si...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x488, %rsp # imm = 0x488 movl %ecx, %r15d movq %rdx, %r13 movq %rsi, %r14 movq %rdi, %rbx cmpl $0x1, %ecx jne 0x3f888 movl $0xffffbf80, %ebp # imm = 0xFFFFBF80 cmpl $0x1, 0x148(%rbx) jne 0x3faad movq 0x8(%rbx), %rcx leaq -0x401(%r...
/Dragonchang[P]https_client/mbedtls/library/rsa.c
mbedtls_sha256_update
void mbedtls_sha256_update( mbedtls_sha256_context *ctx, const unsigned char *input, size_t ilen ) { size_t fill; uint32_t left; if( ilen == 0 ) return; left = ctx->total[0] & 0x3F; fill = 64 - left; ctx->total[0] += (uint32_t) ilen; ctx->total[0] &= 0xFFFFFFFF...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx testq %rdx, %rdx je 0x42cb7 movq %rsi, %rbx movq %rdi, %r14 movl (%rdi), %ecx movl %ecx, %eax andl $0x3f, %eax movl %edx, %esi addl %ecx, %esi movl %esi, (%rdi) jae 0x42c32 incl 0x4(%r14) testl %eax, %eax je 0x42c70 movl $0x40, %r15d subq %rax, %r15 movq %rdx, %r13...
/Dragonchang[P]https_client/mbedtls/library/sha256.c
mbedtls_sha512
void mbedtls_sha512( const unsigned char *input, size_t ilen, unsigned char output[64], int is384 ) { mbedtls_sha512_context ctx; mbedtls_sha512_init( &ctx ); mbedtls_sha512_starts( &ctx, is384 ); mbedtls_sha512_update( &ctx, input, ilen ); mbedtls_sha512_finish( &ctx, output ); mb...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0xe0, %rsp movl %ecx, %ebp movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 leaq 0x8(%rsp), %rdi movl $0xd8, %edx xorl %esi, %esi callq 0xf150 testl %ebp, %ebp je 0x43a13 movaps 0x1a4f4(%rip), %xmm0 # 0x5def0 movaps 0x1a4fd(%rip), %xmm1 # 0x5df00 movaps ...
/Dragonchang[P]https_client/mbedtls/library/sha512.c
mbedtls_aes_setkey_dec
int mbedtls_aes_setkey_dec( mbedtls_aes_context *ctx, const unsigned char *key, unsigned int keybits ) { int i, j, ret; mbedtls_aes_context cty; uint32_t *RK; uint32_t *SK; mbedtls_aes_init( &cty ); #if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_PADLOCK_ALIGN16) if( aes_...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x128, %rsp # imm = 0x128 movl %edx, %ebx movq %rsi, %r15 movq %rdi, %r14 leaq 0x8(%rsp), %r12 movl $0x120, %edx # imm = 0x120 movq %r12, %rdi xorl %esi, %esi callq 0xf150 leaq 0x10(%r14), %rax movq %rax, 0x8(%r14) movq %r12, ...
/Dragonchang[P]https_client/mbedtls/library/aes.c
mbedtls_aes_encrypt
void mbedtls_aes_encrypt( mbedtls_aes_context *ctx, const unsigned char input[16], unsigned char output[16] ) { int i; uint32_t *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3; RK = ctx->rk; GET_UINT32_LE( X0, input, 0 ); X0 ^= *RK++; GET_UINT32_LE( X1, inp...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %rdx, -0x8(%rsp) movq 0x8(%rdi), %rax movl (%rax), %ecx movl 0x4(%rax), %r8d xorl (%rsi), %ecx xorl 0x4(%rsi), %r8d movl 0x8(%rax), %r9d xorl 0x8(%rsi), %r9d movl 0xc(%rax), %edx addq $0x10, %rax xorl 0xc(%rsi), %edx movl (%rdi), %esi sarl %esi leaq...
/Dragonchang[P]https_client/mbedtls/library/aes.c
mbedtls_aes_crypt_cbc
int mbedtls_aes_crypt_cbc( mbedtls_aes_context *ctx, int mode, size_t length, unsigned char iv[16], const unsigned char *input, unsigned char *output ) { int i; unsigned char temp[16]; if( length % 16 ) ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rdx, %r12 movl $0xffffffde, %eax # imm = 0xFFFFFFDE testb $0xf, %r12b jne 0x45480 movq %r9, %rbx movq %r8, %r14 movq %rcx, %r15 movl %esi, %ebp movq %rdi, %r13 testl %esi, %esi je 0x45439 testq %r12, %r12 je 0x4547e xorl %eax...
/Dragonchang[P]https_client/mbedtls/library/aes.c
mbedtls_camellia_setkey_enc
int mbedtls_camellia_setkey_enc( mbedtls_camellia_context *ctx, const unsigned char *key, unsigned int keybits ) { int idx; size_t i; uint32_t *RK; unsigned char t[64]; uint32_t SIGMA[6][2]; uint32_t KC[16]; uint32_t TK[20]; RK = ctx->rk; memset( t, 0, 64 )...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x138, %rsp # imm = 0x138 movl %edx, %ebp movq %rsi, %r15 movq %rdi, %r14 leaq 0x4(%rdi), %rbx pxor %xmm0, %xmm0 movdqa %xmm0, 0xf0(%rsp) movdqa %xmm0, 0x100(%rsp) movdqa %xmm0, 0x110(%rsp) movdqa %xmm0, 0x120(%rsp) movl $0x110, %edx ...
/Dragonchang[P]https_client/mbedtls/library/camellia.c
derive_mpi
static int derive_mpi( const mbedtls_ecp_group *grp, mbedtls_mpi *x, const unsigned char *buf, size_t blen ) { int ret; size_t n_size = ( grp->nbits + 7 ) / 8; size_t use_size = blen > n_size ? n_size : blen; MBEDTLS_MPI_CHK( mbedtls_mpi_read_binary( x, buf, use_size ) ); if(...
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %rbx movq 0xb8(%rdi), %r15 addq $0x7, %r15 shrq $0x3, %r15 cmpq %rcx, %r15 cmovaeq %rcx, %r15 movq %rsi, %rdi movq %rdx, %rsi movq %r15, %rdx callq 0x26657 testl %eax, %eax je 0x48c7e popq %rbx popq %r14 popq %r15 retq shlq $0x3, %r15 subq 0xb8(%rbx), %r15 jbe...
/Dragonchang[P]https_client/mbedtls/library/ecdsa.c
mbedtls_ecdsa_sign_det
int mbedtls_ecdsa_sign_det( mbedtls_ecp_group *grp, mbedtls_mpi *r, mbedtls_mpi *s, const mbedtls_mpi *d, const unsigned char *buf, size_t blen, mbedtls_md_type_t md_alg ) { int ret; mbedtls_hmac_drbg_context rng_ctx; unsigned char data[2 * MBEDTLS_ECP_MAX_BYTES]; ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x148, %rsp # imm = 0x148 movq %r9, %rbx movq %r8, %r14 movq %rcx, %r15 movq %rdx, 0x20(%rsp) movq %rsi, 0x18(%rsp) movq %rdi, %rbp movl 0x180(%rsp), %edi movq 0xb8(%rbp), %r12 callq 0x38cdb testq %rax, %rax je 0x48ddf movq %rax, %r13 mo...
/Dragonchang[P]https_client/mbedtls/library/ecdsa.c
mbedtls_hmac_drbg_random
int mbedtls_hmac_drbg_random( void *p_rng, unsigned char *output, size_t out_len ) { int ret; mbedtls_hmac_drbg_context *ctx = (mbedtls_hmac_drbg_context *) p_rng; #if defined(MBEDTLS_THREADING_C) if( ( ret = mbedtls_mutex_lock( &ctx->mutex ) ) != 0 ) return( ret ); #endif ret = mbedtls_hmac_d...
xorl %ecx, %ecx xorl %r8d, %r8d jmp 0x4961b
/Dragonchang[P]https_client/mbedtls/library/hmac_drbg.c
mbedtls_asn1_write_int
int mbedtls_asn1_write_int( unsigned char **p, unsigned char *start, int val ) { int ret; size_t len = 0; // TODO negative values and values larger than 128 // DER format assumes 2s complement for numbers, so the leftmost bit // should be 0 for positive numbers and 1 for negative numbers. // ...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq (%rdi), %rax movq %rax, %rcx subq %rsi, %rcx movl $0xffffff94, %ebx # imm = 0xFFFFFF94 testq %rcx, %rcx jle 0x4aec3 movq %rsi, %r15 movq %rdi, %r14 leaq -0x1(%rax), %rcx movq %rcx, (%rdi) movb %dl, -0x1(%rax) movl $0x1, %r12d testl %edx, %edx jle 0x4ae8e...
/Dragonchang[P]https_client/mbedtls/library/asn1write.c
boost::ext::ut::v1_1_8::runner<boost::ext::ut::v1_1_8::reporter<boost::ext::ut::v1_1_8::printer>, 16>::runner()
constexpr runner() = default;
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax vxorps %xmm0, %xmm0, %xmm0 leaq 0x162f8(%rip), %rax # 0x20851 leaq 0x162f6(%rip), %rcx # 0x20856 leaq 0x60(%rdi), %r14 movq %rdi, %rbx vmovups %zmm0, 0x1a8(%rdi) vmovups %zmm0, (%rdi) vmovups %zmm0, 0x40(%rdi) vmovups %zmm0, 0x180(%rdi) vmovups %zmm0, 0x140...
/quesnel[P]baryonyx/external/ut/include/boost/ut.hpp
boost::ext::ut::v1_1_8::runner<boost::ext::ut::v1_1_8::reporter<boost::ext::ut::v1_1_8::printer>, 16>::~runner()
~runner() { const auto should_run = not run_; if (should_run) { static_cast<void>(run()); } if (not dry_run_) { reporter_.on(events::summary{}); } if (should_run and fails_) { std::exit(-1); } }
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movb 0x208(%rdi), %bpl movq %rdi, %rbx testb %bpl, %bpl jne 0xa6ed movb $0x1, 0x208(%rbx) movq 0x1e8(%rbx), %r14 movq 0x1f0(%rbx), %r15 cmpq %r15, %r14 je 0xa6ed callq *(%r14) addq $0x8, %r14 cmpq %r15, %r14 jne 0xa6ca movq 0x1e8(%rbx), %rax cmpq %rax, 0x1f0(%rbx) ...
/quesnel[P]baryonyx/external/ut/include/boost/ut.hpp
void boost::ext::ut::v1_1_8::reporter<boost::ext::ut::v1_1_8::printer>::on<bool>(boost::ext::ut::v1_1_8::events::assertion_fail<bool>)
auto on(events::assertion_fail<TExpr> assertion) -> void { constexpr auto short_name = [](std::string_view name) { return name.rfind('/') != std::string_view::npos ? name.substr(name.rfind('/') + 1) : name; }; printer_ << "\n " << short_name(assertion.loc...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x10, %rsp leaq 0x70(%rdi), %r14 leaq 0x1533a(%rip), %rsi # 0x1fc55 movl $0x3, %edx movq %rdi, %rbx leaq 0x40(%rsp), %r12 movq %r14, %rdi callq 0x3270 movq 0x8(%r12), %r15 movq %r15, %rdi callq 0x30c0 testq %rax, %rax je 0xa980 movq %rax, %rdx movq %rax, ...
/quesnel[P]baryonyx/external/ut/include/boost/ut.hpp
bool boost::ext::ut::v1_1_8::runner<boost::ext::ut::v1_1_8::reporter<boost::ext::ut::v1_1_8::printer>, 16>::filter::operator()<std::array<std::basic_string_view<char, std::char_traits<char>>, 16ul>>(unsigned long, std::array<std::basic_string_view<char, std::char_traits<char>>, 16ul> const&) const
constexpr auto operator()(const std::size_t level, const TPath& path) const -> bool { for (auto i = 0u; i < math::min_value(level + 1, std::size(path_)); ++i) { if (not utility::is_match(path[i], path_[i])) { return false; } } ...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq (%rdi), %rcx movq 0x8(%rdi), %rax movq %rsi, %r14 incq %r14 subq %rcx, %rax sarq $0x4, %rax cmpq %r14, %rax cmovaeq %r14, %rax testq %rax, %rax je 0xafa3 movq %rdx, %rbx movq %rdi, %r15 movl $0x1, %ebp xorl %r8d, %r8d shlq $0x4, %r8 movq (%rcx,%r8), %rdx movq ...
/quesnel[P]baryonyx/external/ut/include/boost/ut.hpp
boost::ext::ut::v1_1_8::reporter<boost::ext::ut::v1_1_8::printer>::on(boost::ext::ut::v1_1_8::events::test_end)
auto on(events::test_end) -> void { if (asserts_.fail > fails_) { ++tests_.fail; printer_ << '\n' << printer_.colors().fail << "FAILED" << printer_.colors().none << '\n'; } else { ++tests_.pass; printer_ << printer_.colors().pass << "PASSED" ...
pushq %rbp pushq %r14 pushq %rbx subq $0x10, %rsp movq 0x20(%rdi), %rax leaq 0x70(%rdi), %rbx movq %rdi, %r14 cmpq 0x28(%rdi), %rax jbe 0xb0a1 incq 0x8(%r14) movb $0xa, %bpl leaq 0xd(%rsp), %rsi movl $0x1, %edx movq %rbx, %rdi movb %bpl, (%rsi) callq 0x3270 movq 0x50(%r14), %rdx movq 0x58(%r14), %rsi movq %rbx, %rdi ca...
/quesnel[P]baryonyx/external/ut/include/boost/ut.hpp
baryonyx::itm::shared_subvector::check_index(unsigned int) const
void check_index([[maybe_unused]] size_type i) const noexcept { bx_assert(i + m_element_size <= m_container.size()); bx_assert(i % m_element_size == 0); }
pushq %rax movq 0x8(%rdi), %rdx movl 0x18(%rdi), %ecx subq (%rdi), %rdx leal (%rcx,%rsi), %eax cmpq %rax, %rdx jb 0xb493 movl %esi, %eax xorl %edx, %edx divl %ecx testl %edx, %edx jne 0xb498 popq %rax retq callq 0x3567 callq 0x3545 nop
/quesnel[P]baryonyx/lib/src/branch-and-bound-solver.hpp
void std::__move_median_to_first<__gnu_cxx::__normal_iterator<baryonyx::itm::branch_and_bound_solver<baryonyx::itm::maximize_tag, double>::item*, std::vector<baryonyx::itm::branch_and_bound_solver<baryonyx::itm::maximize_tag, double>::item, std::allocator<baryonyx::itm::branch_and_bound_solver<baryonyx::itm::maximize_t...
constexpr bool operator<(const item& other) const noexcept { if constexpr (std::is_same_v<Mode, minimize_tag>) return (r / static_cast<Float>(factor)) < (other.r / static_cast<Float>(factor)); else return (other.r / static_cast<Float...
vcvtsi2sdl 0x10(%rsi), %xmm0, %xmm0 vmovsd (%rdx), %xmm1 vmovhpd (%rsi), %xmm1, %xmm2 # xmm2 = xmm1[0],mem[0] vmovddup %xmm0, %xmm3 # xmm3 = xmm0[0,0] vdivpd %xmm3, %xmm2, %xmm2 vshufpd $0x1, %xmm2, %xmm2, %xmm3 # xmm3 = xmm2[1,0] vucomisd %xmm2, %xmm3 vmovsd (%rcx), %xmm2 jbe 0xbf36 vcvtsi2sdl 0x10(%rdx)...
/quesnel[P]baryonyx/lib/src/branch-and-bound-solver.hpp
baryonyx::pnm_vector::flush()
void flush() noexcept { if (m_heigth == 0) return; m_ofs.write(reinterpret_cast<char*>(m_buffer.get()), size()); --m_heigth; }
pushq %rbx cmpq $0x0, 0x208(%rdi) je 0xd412 movq %rdi, %rbx movq 0x210(%rbx), %rax movq (%rbx), %rsi addq $0x8, %rdi leaq (%rax,%rax,2), %rdx callq 0x32b0 decq 0x208(%rbx) popq %rbx retq movq %rax, %rdi callq 0xa883
/quesnel[P]baryonyx/lib/src/pnm.hpp
fmt::v7::detail::vformat[abi:cxx11](fmt::v7::basic_string_view<char>, fmt::v7::format_args)
FMT_FUNC std::string detail::vformat(string_view format_str, format_args args) { if (format_str.size() == 2 && equal2(format_str.data(), "{}")) { auto arg = args.get(0); if (!arg) error_handler().on_error("argument not found"); return visit_format_arg(stringifier(), arg); } memory_buffer buffer; det...
pushq %r15 pushq %r14 pushq %rbx subq $0x230, %rsp # imm = 0x230 movq %rdi, %rbx cmpq $0x2, %rdx jne 0xd66c cmpw $0x7d7b, (%rsi) # imm = 0x7D7B je 0xd6dd leaq 0x30(%rsp), %r14 leaq 0x1c6e0(%rip), %rax # 0x29d58 movq $0x0, -0x10(%r14) movq %rax, -0x20(%r14) movq %r14, -0x18(%r14) movq $0x1f4, -0x8...
/quesnel[P]baryonyx/external/fmt/include/fmt/format-inl.h
fmt::v7::detail::stringifier::operator()[abi:cxx11](fmt::v7::basic_format_arg<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>::handle) const
std::string operator()(basic_format_arg<format_context>::handle h) const { memory_buffer buf; format_parse_context parse_ctx({}); format_context format_ctx(buffer_appender<char>(buf), {}, {}); h.format(parse_ctx, format_ctx); return to_string(buf); }
pushq %r14 pushq %rbx subq $0x258, %rsp # imm = 0x258 movq %rdx, %rax leaq 0x60(%rsp), %r14 leaq 0x1c03f(%rip), %rsi # 0x29d58 vxorps %xmm0, %xmm0, %xmm0 leaq 0x40(%rsp), %r8 leaq 0x20(%rsp), %rdx movq %rdi, %rbx xorl %edi, %edi movq %rdi, -0x10(%r14) movq %rsi, -0x20(%r14) movq %rsp, %rsi movq %r14, -0x...
/quesnel[P]baryonyx/external/fmt/include/fmt/format-inl.h
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> fmt::v7::to_string<unsigned int, 0>(unsigned int)
inline std::string to_string(T value) { // The buffer should be large enough to store the number including the sign or // "false" for bool. constexpr int max_size = detail::digits10<T>() + 2; char buffer[max_size > 5 ? static_cast<unsigned>(max_size) : 5]; char* begin = buffer; return std::string(begin, det...
pushq %r14 pushq %rbx subq $0x18, %rsp leaq 0xd(%rsp), %r14 movq %rdi, %rbx movq %r14, %rdi callq 0xdfc3 leaq 0x10(%rbx), %rcx movq %rbx, %rdi movq %r14, %rsi movq %rax, %rdx movq %rcx, (%rbx) callq 0xdeb0 movq %rbx, %rax addq $0x18, %rsp popq %rbx popq %r14 retq
/quesnel[P]baryonyx/external/fmt/include/fmt/format.h