name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
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 {
* cA BOOLEAN DEFAULT FALSE,
* pathLenConstraint INTEGER (0..MAX) OPTIONAL }
*/
*ca_istrue = 0; /* DEFAULT FALSE */
*max_pathlen = 0; /* endless */
if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
if( *p == end )
return( 0 );
if( ( ret = mbedtls_asn1_get_bool( p, end, ca_istrue ) ) != 0 )
{
if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
ret = mbedtls_asn1_get_int( p, end, ca_istrue );
if( ret != 0 )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
if( *ca_istrue != 0 )
*ca_istrue = 1;
}
if( *p == end )
return( 0 );
if( ( ret = mbedtls_asn1_get_int( p, end, max_pathlen ) ) != 0 )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
if( *p != end )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
(*max_pathlen)++;
return( 0 );
} | 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 %eax, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
cmpq %r15, (%r12)
je 0x23d5d
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x253ca
testl %eax, %eax
je 0x23dab
cmpl $-0x62, %eax
jne 0x23d98
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x2542e
testl %eax, %eax
jne 0x23d56
cmpl $0x0, (%r13)
je 0x23dab
movl $0x1, (%r13)
cmpq %r15, (%r12)
je 0x23d5d
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2542e
testl %eax, %eax
je 0x23dcd
movl %eax, %ebx
addl $0xffffdb00, %ebx # imm = 0xFFFFDB00
jmp 0x23d5d
movl $0xffffda9a, %ebx # imm = 0xFFFFDA9A
cmpq %r15, (%r12)
jne 0x23d5d
incl (%r14)
xorl %ebx, %ebx
jmp 0x23d5d
| /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_ASN1_PRIMITIVE | 2 ) &&
**p != MBEDTLS_ASN1_INTEGER )
return( MBEDTLS_ERR_X509_INVALID_SERIAL +
MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
serial->tag = *(*p)++;
if( ( ret = mbedtls_asn1_get_len( p, end, &serial->len ) ) != 0 )
return( MBEDTLS_ERR_X509_INVALID_SERIAL + ret );
serial->p = *p;
*p += serial->len;
return( 0 );
} | 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
testl %eax, %eax
je 0x2431e
addl $0xffffdd80, %eax # imm = 0xFFFFDD80
jmp 0x2432e
movl $0xffffdd20, %eax # imm = 0xFFFFDD20
retq
movl $0xffffdd1e, %eax # imm = 0xFFFFDD1E
jmp 0x2432e
movq (%r14), %rax
movq %rax, 0x10(%rbx)
addq 0x8(%rbx), %rax
movq %rax, (%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /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_SEQUENCE ) )
return( MBEDTLS_ERR_X509_INVALID_ALG +
MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
p = (unsigned char *) alg->p;
end = p + alg->len;
if( p >= end )
return( MBEDTLS_ERR_X509_INVALID_ALG +
MBEDTLS_ERR_ASN1_OUT_OF_DATA );
/* Parse md_oid */
md_oid.tag = *p;
if( ( ret = mbedtls_asn1_get_tag( &p, end, &md_oid.len, MBEDTLS_ASN1_OID ) ) != 0 )
return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
md_oid.p = p;
p += md_oid.len;
/* Get md_alg from md_oid */
if( ( ret = mbedtls_oid_get_md_alg( &md_oid, md_alg ) ) != 0 )
return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
/* Make sure params is absent of NULL */
if( p == end )
return( 0 );
if( ( ret = mbedtls_asn1_get_tag( &p, end, &len, MBEDTLS_ASN1_NULL ) ) != 0 || len != 0 )
return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
if( p != end )
return( MBEDTLS_ERR_X509_INVALID_ALG +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
return( 0 );
} | 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
movq %rbx, %rsi
movl $0x6, %ecx
callq 0x2539d
testl %eax, %eax
jne 0x24655
movq (%rsp), %rax
leaq 0x10(%rsp), %rdi
movq %rax, 0x10(%rdi)
addq 0x8(%rdi), %rax
movq %rax, (%rsp)
movq %r14, %rsi
callq 0x3a318
testl %eax, %eax
je 0x24669
addl $0xffffdd00, %eax # imm = 0xFFFFDD00
jmp 0x24661
movl $0xffffdca0, %eax # imm = 0xFFFFDCA0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
cmpq %rbx, (%rsp)
je 0x246a0
movq %rsp, %rdi
leaq 0x8(%rsp), %rdx
movq %rbx, %rsi
movl $0x5, %ecx
callq 0x2539d
testl %eax, %eax
jne 0x24655
cmpq $0x0, 0x8(%rsp)
jne 0x24655
xorl %ecx, %ecx
cmpq %rbx, (%rsp)
movl $0xffffdc9a, %eax # imm = 0xFFFFDC9A
cmovel %ecx, %eax
jmp 0x24661
xorl %eax, %eax
jmp 0x24661
| /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;
if( tag == MBEDTLS_ASN1_UTC_TIME )
year_len = 2;
else if( tag == MBEDTLS_ASN1_GENERALIZED_TIME )
year_len = 4;
else
return( MBEDTLS_ERR_X509_INVALID_DATE +
MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
(*p)++;
ret = mbedtls_asn1_get_len( p, end, &len );
if( ret != 0 )
return( MBEDTLS_ERR_X509_INVALID_DATE + ret );
return x509_parse_time( p, len, year_len, time );
} | 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, %ebp
jmp 0x2487d
movl $0xffffdba0, %eax # imm = 0xFFFFDBA0
retq
movl $0x2, %r15d
movb $0x1, %bpl
incq %rcx
movq %rcx, (%r14)
movq %rsp, %rdx
movq %r14, %rdi
callq 0x252c8
testl %eax, %eax
je 0x24899
addl $0xffffdc00, %eax # imm = 0xFFFFDC00
jmp 0x248ab
movq (%rsp), %rcx
leaq 0x8(%r15), %rdx
movl $0xffffdc00, %eax # imm = 0xFFFFDC00
subq %rdx, %rcx
jae 0x248b6
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x0, (%rbx)
movq (%r14), %rdx
incq %rdx
xorl %esi, %esi
movb -0x1(%rdx), %dil
addb $-0x3a, %dil
cmpb $-0xa, %dil
jb 0x248ab
addl %esi, %esi
leal (%rsi,%rsi,4), %esi
movl %esi, (%rbx)
movq %rdx, (%r14)
movzbl -0x1(%rdx), %edi
addl %edi, %esi
addl $-0x30, %esi
movl %esi, (%rbx)
incq %rdx
decq %r15
jne 0x248c4
testb %bpl, %bpl
je 0x24905
leal 0x64(%rsi), %edi
cmpl $0x32, %esi
cmovgel %esi, %edi
addl $0x76c, %edi # imm = 0x76C
movl %edi, (%rbx)
movl $0x0, 0x4(%rbx)
xorl %edi, %edi
movq $-0x2, %rsi
movb -0x1(%rdx), %r8b
addb $-0x3a, %r8b
cmpb $-0xa, %r8b
jb 0x248ab
addl %edi, %edi
leal (%rdi,%rdi,4), %edi
movl %edi, 0x4(%rbx)
movq %rdx, (%r14)
movzbl -0x1(%rdx), %r8d
addl %r8d, %edi
addl $-0x30, %edi
movl %edi, 0x4(%rbx)
incq %rdx
incq %rsi
jne 0x24915
movl $0x0, 0x8(%rbx)
xorl %edi, %edi
movq $-0x2, %rsi
movb -0x1(%rdx), %r8b
addb $-0x3a, %r8b
cmpb $-0xa, %r8b
jb 0x248ab
addl %edi, %edi
leal (%rdi,%rdi,4), %edi
movl %edi, 0x8(%rbx)
movq %rdx, (%r14)
movzbl -0x1(%rdx), %r8d
addl %r8d, %edi
addl $-0x30, %edi
movl %edi, 0x8(%rbx)
incq %rdx
incq %rsi
jne 0x24954
movl $0x0, 0xc(%rbx)
xorl %edi, %edi
movq $-0x2, %rsi
movb -0x1(%rdx), %r8b
addb $-0x3a, %r8b
cmpb $-0xa, %r8b
jb 0x248ab
addl %edi, %edi
leal (%rdi,%rdi,4), %edi
movl %edi, 0xc(%rbx)
movq %rdx, (%r14)
movzbl -0x1(%rdx), %r8d
addl %r8d, %edi
addl $-0x30, %edi
movl %edi, 0xc(%rbx)
incq %rdx
incq %rsi
jne 0x24997
movl $0x0, 0x10(%rbx)
xorl %edi, %edi
movq $-0x2, %rsi
movb -0x1(%rdx), %r8b
addb $-0x3a, %r8b
cmpb $-0xa, %r8b
jb 0x248ab
addl %edi, %edi
leal (%rdi,%rdi,4), %edi
movl %edi, 0x10(%rbx)
movq %rdx, (%r14)
movzbl -0x1(%rdx), %r8d
addl %r8d, %edi
addl $-0x30, %edi
movl %edi, 0x10(%rbx)
incq %rdx
incq %rsi
jne 0x249da
cmpq $0x2, %rcx
jb 0x248ab
movl $0x0, 0x14(%rbx)
xorl %edi, %edi
movq $-0x2, %rsi
movb -0x1(%rdx), %r8b
addb $-0x3a, %r8b
cmpb $-0xa, %r8b
jb 0x248ab
addl %edi, %edi
leal (%rdi,%rdi,4), %edi
movl %edi, 0x14(%rbx)
movq %rdx, (%r14)
movzbl -0x1(%rdx), %r8d
addl %r8d, %edi
addl $-0x30, %edi
movl %edi, 0x14(%rbx)
incq %rdx
incq %rsi
jne 0x24a27
cmpq $0x2, %rcx
je 0x24a77
cmpq $0x3, %rcx
jne 0x248ab
cmpb $0x5a, -0x1(%rdx)
jne 0x248ab
movq %rdx, (%r14)
movq %rbx, %rdi
callq 0x25253
jmp 0x248ab
| /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_asn1_get_bitstring_null( p, end, &len ) ) != 0 )
return( MBEDTLS_ERR_X509_INVALID_SIGNATURE + ret );
sig->tag = tag_type;
sig->len = len;
sig->p = *p;
*p += len;
return( 0 );
} | 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, %eax # imm = 0xFFFFDB20
retq
movl %ebp, (%r14)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%r14)
movq (%rbx), %rcx
movq %rcx, 0x10(%r14)
addq %rax, %rcx
movq %rcx, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| /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_sig_alg_desc( sig_oid, &desc );
if( ret != 0 )
ret = mbedtls_snprintf( p, n, "???" );
else
ret = mbedtls_snprintf( p, n, "%s", desc );
MBEDTLS_X509_SAFE_SNPRINTF;
#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
if( pk_alg == MBEDTLS_PK_RSASSA_PSS )
{
const mbedtls_pk_rsassa_pss_options *pss_opts;
const mbedtls_md_info_t *md_info, *mgf_md_info;
pss_opts = (const mbedtls_pk_rsassa_pss_options *) sig_opts;
md_info = mbedtls_md_info_from_type( md_alg );
mgf_md_info = mbedtls_md_info_from_type( pss_opts->mgf1_hash_id );
ret = mbedtls_snprintf( p, n, " (%s, MGF1-%s, 0x%02X)",
md_info ? mbedtls_md_get_name( md_info ) : "???",
mgf_md_info ? mbedtls_md_get_name( mgf_md_info ) : "???",
pss_opts->expected_salt_len );
MBEDTLS_X509_SAFE_SNPRINTF;
}
#else
((void) pk_alg);
((void) md_alg);
((void) sig_opts);
#endif /* MBEDTLS_X509_RSASSA_PSS_SUPPORT */
return( (int)( size - n ) );
} | 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
movq %rbx, %rsi
xorl %eax, %eax
callq 0xf120
jmp 0x24efb
movq 0x10(%rsp), %rcx
leaq 0x27447(%rip), %rdx # 0x4c335
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0xf120
movl $0xffffd680, %ebp # imm = 0xFFFFD680
testl %eax, %eax
js 0x24fbd
movl %r13d, %edi
movq %r12, 0x8(%rsp)
movl %eax, %r13d
movq %rbx, %r12
subq %r13, %r12
jbe 0x24fbd
cmpl $0x6, %r15d
jne 0x24fb8
callq 0x38cdb
movq %rax, %r15
movq 0x8(%rsp), %rax
movl (%rax), %edi
callq 0x38cdb
leaq 0x30674(%rip), %r8 # 0x555b8
movq %r8, %rcx
testq %r15, %r15
je 0x24f64
movq %r15, %rdi
movq %rax, %r15
callq 0x3927c
leaq 0x3065a(%rip), %r8 # 0x555b8
movq %rax, %rcx
movq %r15, %rax
addq %r13, %r14
testq %rax, %rax
je 0x24f7d
movq %rax, %rdi
movq %rcx, %r15
callq 0x3927c
movq %r15, %rcx
movq %rax, %r8
movq 0x8(%rsp), %rax
movl 0x4(%rax), %r9d
leaq 0x30a45(%rip), %rdx # 0x559d2
xorl %r15d, %r15d
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0xf120
testl %eax, %eax
setns %cl
movl %eax, %eax
cmpq %rax, %r12
seta %dl
andb %cl, %dl
cmovneq %rax, %r15
cmpb $0x1, %dl
jne 0x24fbd
subq %r15, %r12
subl %r12d, %ebx
movl %ebx, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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 == after->mon &&
before->day > after->day )
return( 1 );
if( before->year == after->year &&
before->mon == after->mon &&
before->day == after->day &&
before->hour > after->hour )
return( 1 );
if( before->year == after->year &&
before->mon == after->mon &&
before->day == after->day &&
before->hour == after->hour &&
before->min > after->min )
return( 1 );
if( before->year == after->year &&
before->mon == after->mon &&
before->day == after->day &&
before->hour == after->hour &&
before->min == after->min &&
before->sec > after->sec )
return( 1 );
return( 0 );
} | 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
cmpl 0x8(%rsi), %ecx
jne 0x250d0
movl 0xc(%rdi), %ecx
cmpl 0xc(%rsi), %ecx
jne 0x250d0
movl 0x10(%rdi), %ecx
cmpl 0x10(%rsi), %ecx
jg 0x250f2
movl 0x8(%rdi), %ecx
cmpl 0x8(%rsi), %ecx
jne 0x250f0
movl 0xc(%rdi), %ecx
cmpl 0xc(%rsi), %ecx
jne 0x250f0
movl 0x10(%rdi), %ecx
cmpl 0x10(%rsi), %ecx
jne 0x250f0
movl 0x14(%rdi), %ecx
cmpl 0x14(%rsi), %ecx
jg 0x250f2
xorl %eax, %eax
retq
| /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 = mbedtls_x509_crt_parse( &clicert, (const unsigned char *) mbedtls_test_cli_crt,
mbedtls_test_cli_crt_len );
if( ret != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
return( ret );
}
mbedtls_x509_crt_init( &cacert );
ret = mbedtls_x509_crt_parse( &cacert, (const unsigned char *) mbedtls_test_ca_crt,
mbedtls_test_ca_crt_len );
if( ret != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
return( ret );
}
if( verbose != 0 )
mbedtls_printf( "passed\n X.509 signature verify: ");
ret = mbedtls_x509_crt_verify( &clicert, &cacert, NULL, NULL, &flags, NULL, NULL );
if( ret != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
return( ret );
}
if( verbose != 0 )
mbedtls_printf( "passed\n\n");
mbedtls_x509_crt_free( &cacert );
mbedtls_x509_crt_free( &clicert );
return( 0 );
#else
((void) verbose);
return( 0 );
#endif /* MBEDTLS_CERTS_C && MBEDTLS_SHA1_C */
} | 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 # 0x55250
movq (%rax), %rdx
movq %rbx, %rdi
callq 0x21db1
testl %eax, %eax
jne 0x2519d
leaq 0x240(%rsp), %rbx
movq %rbx, %rdi
callq 0x21da5
leaq 0x4d0c4(%rip), %rax # 0x72248
movq (%rax), %rsi
leaq 0x3009a(%rip), %rax # 0x55228
movq (%rax), %rdx
movq %rbx, %rdi
callq 0x21db1
testl %eax, %eax
je 0x251bb
movl %eax, %ebx
testl %ebp, %ebp
je 0x251af
leaq 0x27c6b(%rip), %rdi # 0x4ce15
callq 0xf060
movl %ebx, %eax
addq $0x468, %rsp # imm = 0x468
popq %rbx
popq %rbp
retq
testl %ebp, %ebp
je 0x251fb
leaq 0x3084a(%rip), %rdi # 0x55a10
xorl %eax, %eax
callq 0xf110
movq $0x0, (%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x240(%rsp), %rsi
leaq 0x14(%rsp), %r8
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x22dae
testl %eax, %eax
je 0x25229
movl %eax, %ebx
jmp 0x251a3
movq $0x0, (%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x240(%rsp), %rsi
leaq 0x14(%rsp), %r8
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x22dae
movl %eax, %ebx
testl %eax, %eax
jne 0x251af
jmp 0x25235
leaq 0x30802(%rip), %rdi # 0x55a32
callq 0xf060
leaq 0x240(%rsp), %rdi
callq 0x2387e
leaq 0x18(%rsp), %rdi
callq 0x2387e
xorl %ebx, %ebx
jmp 0x251af
| /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 1:
if( ( end - *p ) < 2 )
return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
*len = (*p)[1];
(*p) += 2;
break;
case 2:
if( ( end - *p ) < 3 )
return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
*len = ( (size_t)(*p)[1] << 8 ) | (*p)[2];
(*p) += 3;
break;
case 3:
if( ( end - *p ) < 4 )
return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
*len = ( (size_t)(*p)[1] << 16 ) |
( (size_t)(*p)[2] << 8 ) | (*p)[3];
(*p) += 4;
break;
case 4:
if( ( end - *p ) < 5 )
return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
*len = ( (size_t)(*p)[1] << 24 ) | ( (size_t)(*p)[2] << 16 ) |
( (size_t)(*p)[3] << 8 ) | (*p)[4];
(*p) += 5;
break;
default:
return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
}
}
if( *len > (size_t) ( end - *p ) )
return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
return( 0 );
} | 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 # imm = 0xFFFFFFA0
cmovbel %ecx, %eax
retq
andl $0x7f, %r9d
decl %r9d
cmpl $0x3, %r9d
ja 0x25397
leaq 0x30722(%rip), %r10 # 0x55a3c
movslq (%r10,%r9,4), %r9
addq %r10, %r9
jmpq *%r9
cmpq $0x1, %r8
je 0x25301
movzbl 0x1(%rcx), %eax
movq %rax, (%rdx)
addq $0x2, %rcx
jmp 0x2538c
cmpq $0x4, %r8
jb 0x25301
movzbl 0x1(%rcx), %eax
shll $0x10, %eax
movzbl 0x2(%rcx), %r8d
shll $0x8, %r8d
orl %eax, %r8d
movzbl 0x3(%rcx), %eax
orq %r8, %rax
movq %rax, (%rdx)
addq $0x4, %rcx
jmp 0x2538c
cmpq $0x5, %r8
jb 0x25301
movl 0x1(%rcx), %eax
bswapl %eax
movq %rax, (%rdx)
addq $0x5, %rcx
jmp 0x2538c
cmpq $0x3, %r8
jb 0x25301
movzwl 0x1(%rcx), %eax
rolw $0x8, %ax
movzwl %ax, %eax
movq %rax, (%rdx)
addq $0x3, %rcx
movq %rcx, (%rdi)
movq %rcx, %r8
jmp 0x252f1
movl $0xffffff9c, %eax # imm = 0xFFFFFF9C
retq
| /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 )
return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
*val = 0;
while( len-- > 0 )
{
*val = ( *val << 8 ) | **p;
(*p)++;
}
return( 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), %rcx
leaq -0x5(%rcx), %rdx
movl $0xffffff9c, %eax # imm = 0xFFFFFF9C
cmpq $-0x4, %rdx
jb 0x254a0
movq (%r14), %rdx
cmpb $0x0, (%rdx)
js 0x254a0
movl $0x0, (%rbx)
incq %rdx
xorl %eax, %eax
xorl %esi, %esi
shll $0x8, %esi
movzbl -0x1(%rdx), %edi
orl %edi, %esi
movl %esi, (%rbx)
movq %rdx, (%r14)
incq %rdx
decq %rcx
jne 0x2548a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0xffffffa0, %eax # imm = 0xFFFFFFA0
retq
| /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_tag( p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
return( ret );
if( *p + len != end )
return( MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
while( *p < end )
{
buf = &(cur->buf);
buf->tag = **p;
if( ( ret = mbedtls_asn1_get_tag( p, end, &buf->len, tag ) ) != 0 )
return( ret );
buf->p = *p;
*p += buf->len;
/* Allocate and assign next pointer */
if( *p < end )
{
cur->next = (mbedtls_asn1_sequence*)mbedtls_calloc( 1,
sizeof( mbedtls_asn1_sequence ) );
if( cur->next == NULL )
return( MBEDTLS_ERR_ASN1_ALLOC_FAILED );
cur = cur->next;
}
}
/* Set final sequence entry's next pointer to NULL */
cur->next = NULL;
if( *p != end )
return( MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
return( 0 );
} | 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 (%r14), %rcx
movq (%rsp), %rdx
addq %rcx, %rdx
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rbx, %rdx
jne 0x256ec
jmp 0x256c4
movzbl (%rcx), %eax
movl %eax, (%r15)
movq %rbx, %rax
subq %rcx, %rax
testq %rax, %rax
jle 0x256e0
movzbl (%rcx), %eax
cmpl %ebp, %eax
jne 0x256e7
leaq 0x8(%r15), %rdx
incq %rcx
movq %rcx, (%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x252c8
testl %eax, %eax
jne 0x256ec
movq (%r14), %rcx
movq %rcx, 0x10(%r15)
addq 0x8(%r15), %rcx
movq %rcx, (%r14)
cmpq %rbx, %rcx
jae 0x256c4
movl $0x1, %edi
movl $0x20, %esi
callq 0xf1d0
movq %rax, 0x18(%r15)
testq %rax, %rax
je 0x256f7
movq (%r14), %rcx
movq %rax, %r15
cmpq %rbx, %rcx
jb 0x25662
movq $0x0, 0x18(%r15)
xorl %ecx, %ecx
cmpq %rbx, (%r14)
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmovel %ecx, %eax
jmp 0x256ec
movl $0xffffffa0, %eax # imm = 0xFFFFFFA0
jmp 0x256ec
movl $0xffffff9e, %eax # imm = 0xFFFFFF9E
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffff96, %eax # imm = 0xFFFFFF96
jmp 0x256ec
| /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( ¶ms, 0, sizeof(mbedtls_asn1_buf) );
if( ( ret = mbedtls_asn1_get_alg( p, end, alg, ¶ms ) ) != 0 )
return( ret );
if( ( params.tag != MBEDTLS_ASN1_NULL && params.tag != 0 ) || params.len != 0 )
return( MBEDTLS_ERR_ASN1_INVALID_DATA );
return( 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 %ecx, %eax
addq $0x18, %rsp
retq
| /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
retq
| /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_ALLOC_FAILED );
if( X->p != NULL )
{
memcpy( p, X->p, X->n * ciL );
mbedtls_mpi_zeroize( X->p, X->n );
mbedtls_free( X->p );
}
X->n = nblimbs;
X->p = p;
}
return( 0 );
} | 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, %rax
je 0x259ce
movq %rax, %r15
movq 0x10(%rbx), %r12
testq %r12, %r12
je 0x259c4
leaq (,%r13,8), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0xf240
testq %r13, %r13
je 0x259bc
xorl %eax, %eax
movq $0x0, (%r12,%rax,8)
incq %rax
cmpq %rax, %r13
jne 0x259ac
movq %r12, %rdi
callq 0xf030
movq %r14, 0x8(%rbx)
movq %r15, 0x10(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/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 )
{
if( slen > MPI_SIZE_T_MAX >> 2 )
return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
n = BITS_TO_LIMBS( slen << 2 );
MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, n ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_lset( X, 0 ) );
for( i = slen, j = 0; i > 0; i--, j++ )
{
if( i == 1 && s[i - 1] == '-' )
{
X->s = -1;
break;
}
MBEDTLS_MPI_CHK( mpi_get_digit( &d, radix, s[i - 1] ) );
X->p[j / ( 2 * ciL )] |= d << ( ( j % ( 2 * ciL ) ) << 2 );
}
}
else
{
MBEDTLS_MPI_CHK( mbedtls_mpi_lset( X, 0 ) );
for( i = 0; i < slen; i++ )
{
if( i == 0 && s[i] == '-' )
{
X->s = -1;
continue;
}
MBEDTLS_MPI_CHK( mpi_get_digit( &d, radix, s[i] ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_mul_int( &T, X, radix ) );
if( X->s == 1 )
{
MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( X, &T, d ) );
}
else
{
MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( X, &T, d ) );
}
}
}
cleanup:
mbedtls_mpi_free( &T );
return( ret );
} | 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 0xf100
movq %rax, %r15
cmpl $0x10, %r13d
jne 0x25f5c
movq %r15, %rax
shrq $0x3e, %rax
jne 0x25f70
movq %r15, %rsi
shrq $0x4, %rsi
movl %r15d, %eax
andl $0xf, %eax
cmpq $0x1, %rax
sbbq $-0x1, %rsi
movq %r14, %rdi
callq 0x2594c
testl %eax, %eax
jne 0x25f6d
movl $0x1, %esi
movq %r14, %rdi
callq 0x2594c
testl %eax, %eax
jne 0x25f6d
movq 0x8(%r14), %rdx
movq 0x10(%r14), %rdi
shlq $0x3, %rdx
xorl %r12d, %r12d
xorl %esi, %esi
callq 0xf150
movq 0x10(%r14), %rax
movq $0x0, (%rax)
movl $0x1, (%r14)
movl $0xff, %edx
xorl %esi, %esi
xorl %edi, %edi
cmpq $0x1, %r15
je 0x25ef7
testq %r15, %r15
jne 0x25f00
jmp 0x25f70
cmpb $0x2d, (%rbx)
je 0x2613c
movsbl -0x1(%rbx,%r15), %r8d
leal -0x30(%r8), %ecx
leal -0x30(%r8), %r9d
cmpb $0xa, %cl
cmovaeq %rdx, %r9
leal -0x41(%r8), %ecx
leal -0x37(%r8), %r10d
cmpb $0x6, %cl
cmovaeq %r9, %r10
leal -0x61(%r8), %ecx
addl $-0x57, %r8d
cmpb $0x6, %cl
cmovaeq %r10, %r8
cmpq $0xf, %r8
ja 0x26131
movl %esi, %ecx
andb $0x3c, %cl
shlq %cl, %r8
movq %rdi, %rcx
shrq $0x4, %rcx
orq %r8, (%rax,%rcx,8)
decq %r15
incq %rdi
addq $0x4, %rsi
jmp 0x25eea
movl $0x1, %esi
movq %r14, %rdi
callq 0x2594c
testl %eax, %eax
je 0x25f82
movl %eax, %r12d
movl %r12d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r14), %rdx
movq 0x10(%r14), %rdi
shlq $0x3, %rdx
xorl %r12d, %r12d
xorl %esi, %esi
callq 0xf150
movq 0x10(%r14), %rax
movq $0x0, (%rax)
movl $0x1, (%r14)
testq %r15, %r15
je 0x25f70
movq %r14, 0x38(%rsp)
movl %r13d, %esi
xorl %ebp, %ebp
leaq 0x40(%rsp), %r14
movq %r15, 0x30(%rsp)
movq %rbx, 0x28(%rsp)
testq %rbp, %rbp
jne 0x25fe2
cmpb $0x2d, (%rbx)
jne 0x25fe2
movq 0x38(%rsp), %rax
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
jmp 0x260e1
movsbl (%rbx,%rbp), %r13d
leal -0x30(%r13), %eax
leal -0x30(%r13), %ecx
cmpb $0xa, %al
movl $0xff, %eax
cmovaeq %rax, %rcx
leal -0x41(%r13), %eax
leal -0x37(%r13), %edx
cmpb $0x6, %al
cmovaeq %rcx, %rdx
leal -0x61(%r13), %eax
addl $-0x57, %r13d
cmpb $0x6, %al
cmovaeq %rdx, %r13
cmpq %rsi, %r13
jae 0x260f7
movl $0x1, 0x10(%rsp)
movq $0x1, 0x18(%rsp)
leaq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %rsi, %rbx
movq %rsi, 0x8(%rsp)
movq %r14, %r15
movq %r14, %rdi
movq 0x38(%rsp), %r14
movq %r14, %rsi
leaq 0x10(%rsp), %rdx
callq 0x26e2d
testl %eax, %eax
jne 0x260f2
cmpl $0x1, (%r14)
jne 0x2609d
movq %r13, 0x8(%rsp)
movl $0x1, 0x10(%rsp)
movq $0x1, 0x18(%rsp)
leaq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %r14, %rdi
movq %r15, %r14
movq %r15, %rsi
leaq 0x10(%rsp), %rdx
callq 0x26d51
jmp 0x260d0
movq %r13, 0x8(%rsp)
movl $0x1, 0x10(%rsp)
movq $0x1, 0x18(%rsp)
leaq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %r14, %rdi
movq %r15, %r14
movq %r15, %rsi
leaq 0x10(%rsp), %rdx
callq 0x26dbf
testl %eax, %eax
movq %rbx, %rsi
movq 0x28(%rsp), %rbx
movq 0x30(%rsp), %r15
jne 0x260f2
incq %rbp
cmpq %rbp, %r15
jne 0x25fc8
xorl %r12d, %r12d
jmp 0x260fd
movl %eax, %r12d
jmp 0x260fd
movl $0xfffffffa, %r12d # imm = 0xFFFFFFFA
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x25f70
movq 0x48(%rsp), %rax
testq %rax, %rax
je 0x26127
xorl %ecx, %ecx
movq $0x0, (%rdi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x26117
callq 0xf030
jmp 0x25f70
movl $0xfffffffa, %r12d # imm = 0xFFFFFFFA
jmp 0x25f70
movl $0xffffffff, (%r14) # imm = 0xFFFFFFFF
jmp 0x25f70
| /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 );
if( radix >= 4 ) n >>= 1;
if( radix >= 16 ) n >>= 1;
/*
* Round up the buffer length to an even value to ensure that there is
* enough room for hexadecimal values that can be represented in an odd
* number of digits.
*/
n += 3 + ( ( n + 1 ) & 1 );
if( buflen < n )
{
*olen = n;
return( MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL );
}
p = buf;
mbedtls_mpi_init( &T );
if( X->s == -1 )
*p++ = '-';
if( radix == 16 )
{
int c;
size_t i, j, k;
for( i = X->n, k = 0; i > 0; i-- )
{
for( j = ciL; j > 0; j-- )
{
c = ( X->p[i - 1] >> ( ( j - 1 ) << 3) ) & 0xFF;
if( c == 0 && k == 0 && ( i + j ) != 2 )
continue;
*(p++) = "0123456789ABCDEF" [c / 16];
*(p++) = "0123456789ABCDEF" [c % 16];
k = 1;
}
}
}
else
{
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &T, X ) );
if( T.s == -1 )
T.s = 1;
MBEDTLS_MPI_CHK( mpi_write_hlp( &T, radix, &p ) );
}
*p++ = '\0';
*olen = p - buf;
cleanup:
mbedtls_mpi_free( &T );
return( ret );
} | 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
cmpl $0x10, %r12d
setae %cl
shrq %cl, %rax
andq $-0x2, %rax
addq $0x4, %rax
cmpq %r13, %rax
jbe 0x26255
movq %rax, (%rbx)
movl $0xfffffff8, %ebp # imm = 0xFFFFFFF8
jmp 0x26370
movq %r14, 0x8(%rsp)
movl $0x1, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
cmpl $-0x1, (%r15)
movq %r14, %rax
jne 0x26280
leaq 0x1(%r14), %rax
movq %rax, 0x8(%rsp)
movb $0x2d, (%r14)
cmpl $0x10, %r12d
jne 0x2630d
movq 0x8(%r15), %rdx
testq %rdx, %rdx
je 0x262fd
xorl %edi, %edi
leaq 0x2f7b0(%rip), %rsi # 0x55a4c
movl $0x38, %ecx
movq $-0x6, %r8
movq 0x10(%r15), %r9
movq -0x8(%r9,%rdx,8), %r9
shrq %cl, %r9
movzbl %r9b, %r10d
cmpq %r8, %rdx
je 0x262cb
testl %r10d, %r10d
jne 0x262cb
testq %rdi, %rdi
jne 0x262cb
xorl %edi, %edi
jmp 0x262eb
shrl $0x4, %r10d
movb (%r10,%rsi), %dil
movb %dil, (%rax)
andl $0xf, %r9d
movb (%r9,%rsi), %dil
movb %dil, 0x1(%rax)
addq $0x2, %rax
movl $0x1, %edi
addq $-0x8, %rcx
incq %r8
cmpq $-0x8, %rcx
jne 0x262a8
decq %rdx
jne 0x2629c
movb $0x0, (%rax)
subq %r14, %rax
incq %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
jmp 0x26345
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x25a94
testl %eax, %eax
jne 0x26343
cmpl $-0x1, 0x10(%rsp)
jne 0x2632d
movl $0x1, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl %r12d, %esi
callq 0x2638b
testl %eax, %eax
je 0x26381
movl %eax, %ebp
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x26370
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x2636b
xorl %ecx, %ecx
movq $0x0, (%rdi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x2635b
callq 0xf030
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rax
jmp 0x262fd
| /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 ) );
if( fgets( s, sizeof( s ) - 1, fin ) == NULL )
return( MBEDTLS_ERR_MPI_FILE_IO_ERROR );
slen = strlen( s );
if( slen == sizeof( s ) - 2 )
return( MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL );
if( s[slen - 1] == '\n' ) { slen--; s[slen] = '\0'; }
if( s[slen - 1] == '\r' ) { slen--; s[slen] = '\0'; }
p = s + slen;
while( --p >= s )
if( mpi_get_digit( &d, radix, *p ) != 0 )
break;
return( mbedtls_mpi_read_string( X, radix, p + 1 ) );
} | 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 0xf1b0
testq %rax, %rax
je 0x264db
movq %rsp, %r15
movq %r15, %rdi
callq 0xf100
movl $0xfffffff8, %ecx # imm = 0xFFFFFFF8
cmpq $0x9b2, %rax # imm = 0x9B2
je 0x26553
leaq -0x1(%rax), %rcx
movb -0x1(%rsp,%rax), %sil
cmpb $0xa, %sil
jne 0x264e2
movb $0x0, -0x1(%rsp,%rax)
movq %rax, %rdx
addq $-0x2, %rdx
movb -0x2(%rsp,%rax), %sil
jmp 0x264e8
movl $0xfffffffe, %ecx # imm = 0xFFFFFFFE
jmp 0x26553
movq %rcx, %rdx
movq %rax, %rcx
cmpb $0xd, %sil
jne 0x264f5
movb $0x0, (%rsp,%rdx)
movq %rdx, %rcx
movslq %ebx, %rax
leaq (%rcx,%r15), %rdi
decq %rdi
movl $0xff, %ecx
movq %rdi, %rdx
cmpq %r15, %rdi
jb 0x26544
movsbl (%rdx), %esi
leal -0x30(%rsi), %edi
leal -0x30(%rsi), %r8d
cmpb $0xa, %dil
cmovaeq %rcx, %r8
leal -0x41(%rsi), %edi
leal -0x37(%rsi), %r9d
cmpb $0x6, %dil
cmovaeq %r8, %r9
leal -0x61(%rsi), %edi
addl $-0x57, %esi
cmpb $0x6, %dil
cmovaeq %r9, %rsi
leaq -0x1(%rdx), %rdi
cmpq %rax, %rsi
jb 0x26504
incq %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x25e23
movl %eax, %ecx
movl %ecx, %eax
addq $0x9b8, %rsp # imm = 0x9B8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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 )
{
for( i = 0; i < X->n - v0; i++ )
X->p[i] = X->p[i + v0];
for( ; i < X->n; i++ )
X->p[i] = 0;
}
/*
* shift by count % limb_size
*/
if( v1 > 0 )
{
for( i = X->n; i > 0; i-- )
{
r1 = X->p[i - 1] << (biL - v1);
X->p[i - 1] >>= v1;
X->p[i - 1] |= r0;
r0 = r1;
}
}
return( 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
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rdi
shlq $0x3, %rdx
xorl %r14d, %r14d
xorl %esi, %esi
callq 0xf150
movq 0x10(%rbx), %rax
movq $0x0, (%rax)
movl $0x1, (%rbx)
jmp 0x269bf
cmpq $0x40, %rsi
jb 0x26971
cmpq %rdi, %rcx
jne 0x26930
xorl %edx, %edx
movq %rcx, %rdi
jmp 0x26954
movq 0x10(%rbx), %rsi
leaq (%rsi,%rcx,8), %r8
xorl %edx, %edx
movq (%r8,%rdx,8), %rdi
movq %rdi, (%rsi,%rdx,8)
incq %rdx
movq 0x8(%rbx), %rdi
movq %rdi, %r9
subq %rcx, %r9
cmpq %r9, %rdx
jb 0x2693a
cmpq %rdi, %rdx
jae 0x26971
movq 0x10(%rbx), %rcx
movq $0x0, (%rcx,%rdx,8)
incq %rdx
movq 0x8(%rbx), %rdi
cmpq %rdi, %rdx
jb 0x2695d
testq %rax, %rax
sete %cl
testq %rdi, %rdi
sete %dl
xorl %r14d, %r14d
orb %cl, %dl
jne 0x269bf
movq 0x10(%rbx), %rsi
movl $0x40, %edx
subq %rax, %rdx
xorl %r14d, %r14d
xorl %r8d, %r8d
movq -0x8(%rsi,%rdi,8), %r9
movq %r9, %r10
movl %edx, %ecx
shlq %cl, %r10
movl %eax, %ecx
shrq %cl, %r9
orq %r8, %r9
movq %r9, -0x8(%rsi,%rdi,8)
leaq -0x1(%rdi), %rcx
movq %r10, %r8
movq %rcx, %rdi
testq %rcx, %rcx
jne 0x26996
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /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 ) return( 1 );
if( j > i ) return( -1 );
for( ; i > 0; i-- )
{
if( X->p[i - 1] > Y->p[i - 1] ) return( 1 );
if( X->p[i - 1] < Y->p[i - 1] ) return( -1 );
}
return( 0 );
} | 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 %rdx, %r8
orq %rcx, %r8
je 0x26a16
cmpq %rdx, %rcx
jbe 0x26a17
movl $0x1, %eax
retq
jb 0x26a33
subq $0x1, %rcx
jb 0x26a16
movq 0x10(%rdi), %rdx
movq 0x10(%rsi), %r8
movq (%r8,%rcx,8), %r8
cmpq %r8, (%rdx,%rcx,8)
ja 0x26a11
jae 0x26a19
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
retq
| /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 ) return( X->s );
if( j > i ) return( -Y->s );
if( X->s > 0 && Y->s < 0 ) return( 1 );
if( Y->s > 0 && X->s < 0 ) return( -1 );
for( ; i > 0; i-- )
{
if( X->p[i - 1] > Y->p[i - 1] ) return( X->s );
if( X->p[i - 1] < Y->p[i - 1] ) return( -X->s );
}
return( 0 );
} | 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 %rcx, %rdx
je 0x26acf
cmpq %rax, %rcx
jbe 0x26a81
movl (%rdi), %eax
retq
jae 0x26a88
xorl %eax, %eax
subl (%rsi), %eax
retq
movl (%rdi), %edx
movl (%rsi), %eax
testl %edx, %edx
jle 0x26a9a
testl %eax, %eax
jns 0x26ab0
movl $0x1, %eax
retq
testl %eax, %eax
setg %r8b
testl %edx, %edx
setne %r9b
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testb %r8b, %r9b
jne 0x26ace
subq $0x1, %rcx
jb 0x26acf
movq 0x10(%rdi), %rax
movq 0x10(%rsi), %r8
movq (%r8,%rcx,8), %r8
cmpq %r8, (%rax,%rcx,8)
ja 0x26acc
jae 0x26ab0
negl %edx
movl %edx, %eax
retq
xorl %eax, %eax
retq
| /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, 0, T->n * ciL );
d = T->p;
n = N->n;
m = ( B->n < n ) ? B->n : n;
for( i = 0; i < n; i++ )
{
/*
* T = (T + u0*B + u1*N) / 2^biL
*/
u0 = A->p[i];
u1 = ( d[0] + u0 * B->p[0] ) * mm;
mpi_mul_hlp( m, B->p, d, u0 );
mpi_mul_hlp( n, N->p, d, u1 );
*d++ = u0; d[n + 1] = 0;
}
memcpy( A->p, d, ( n + 1 ) * ciL );
if( mbedtls_mpi_cmp_abs( A, N ) >= 0 )
mpi_sub_hlp( n, N->p, A->p );
else
/* prevent timing attacks */
mpi_sub_hlp( n, A->p, T->p );
return( 0 );
} | 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 0x28560
movq %rsi, %r8
addq $0x10, %rbx
shlq $0x3, %rdx
xorl %esi, %esi
movq %r8, 0x8(%rsp)
callq 0xf150
movq 0x8(%rsp), %rcx
movq %rbx, 0x10(%rsp)
movq (%rbx), %r12
movq 0x8(%r15), %rdx
movq 0x8(%rcx), %r13
cmpq %rdx, %r13
cmovaeq %rdx, %r13
testq %rdx, %rdx
movq %r15, (%rsp)
je 0x28516
movq %rbp, 0x18(%rsp)
xorl %ebp, %ebp
movq %r14, 0x20(%rsp)
movq 0x10(%r14), %rax
movq (%rax,%rbp,8), %r14
movq 0x10(%rcx), %rsi
movq (%rsi), %r15
imulq %r14, %r15
addq (%r12), %r15
imulq 0x18(%rsp), %r15
movq %r13, %rdi
movq %rdx, %rbx
movq %r12, %rdx
movq %r14, %rcx
callq 0x26fea
movq (%rsp), %rax
movq 0x10(%rax), %rsi
movq %rbx, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0x26fea
movq %rbx, %rdx
movq 0x8(%rsp), %rcx
leaq 0x8(%r12), %rsi
movq %r14, (%r12)
movq 0x20(%rsp), %r14
movq $0x0, 0x10(%r12,%rbx,8)
incq %rbp
movq %rsi, %r12
cmpq %rbp, %rbx
jne 0x284a6
jmp 0x28519
movq %r12, %rsi
leaq 0x10(%r14), %rbx
movq 0x10(%r14), %rdi
movq %rdx, %r12
leaq 0x8(,%rdx,8), %rdx
callq 0xf240
movq %r14, %rdi
movq (%rsp), %r15
movq %r15, %rsi
callq 0x269ca
testl %eax, %eax
cmovnsq %r15, %r14
movq 0x10(%rsp), %rax
cmovnsq %rbx, %rax
movq 0x10(%r14), %rsi
movq (%rax), %rdx
movq %r12, %rdi
callq 0x26cfb
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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 )
return( 1 );
MBEDTLS_MPI_CHK( mbedtls_mpi_mod_int( &r, X, small_prime[i] ) );
if( r == 0 )
return( MBEDTLS_ERR_MPI_NOT_ACCEPTABLE );
}
cleanup:
return( ret );
} | 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 (%r13,%rax), %ebp
movq %rbp, 0x8(%rsp)
movl $0x1, 0x10(%rsp)
movq $0x1, 0x18(%rsp)
movq %rbx, 0x20(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x26a39
testl %eax, %eax
jle 0x29126
movslq %ebp, %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x27bf1
testl %eax, %eax
jne 0x29132
cmpq $0x0, (%rsp)
je 0x2912d
addq $0x4, %r13
cmpq $0x29c, %r13 # imm = 0x29C
jne 0x290c6
xorl %eax, %eax
jmp 0x29132
movl $0x1, %eax
jmp 0x29132
movl $0xfffffff2, %eax # imm = 0xFFFFFFF2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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_ERR_MPI_BAD_INPUT_DATA );
mbedtls_mpi_init( &Y );
n = BITS_TO_LIMBS( nbits );
MBEDTLS_MPI_CHK( mbedtls_mpi_fill_random( X, n * ciL, f_rng, p_rng ) );
k = mbedtls_mpi_bitlen( X );
if( k > nbits ) MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( X, k - nbits + 1 ) );
mbedtls_mpi_set_bit( X, nbits-1, 1 );
X->p[0] |= 1;
if( dh_flag == 0 )
{
while( ( ret = mbedtls_mpi_is_prime( X, f_rng, p_rng ) ) != 0 )
{
if( ret != MBEDTLS_ERR_MPI_NOT_ACCEPTABLE )
goto cleanup;
MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( X, X, 2 ) );
}
}
else
{
/*
* An necessary condition for Y and X = 2Y + 1 to be prime
* is X = 2 mod 3 (which is equivalent to Y = 2 mod 3).
* Make sure it is satisfied, while keeping X = 3 mod 4
*/
X->p[0] |= 2;
MBEDTLS_MPI_CHK( mbedtls_mpi_mod_int( &r, X, 3 ) );
if( r == 0 )
MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( X, X, 8 ) );
else if( r == 1 )
MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( X, X, 4 ) );
/* Set Y = (X-1) / 2, which is X / 2 because X is odd */
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &Y, X ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &Y, 1 ) );
while( 1 )
{
/*
* First, check small factors for X and Y
* before doing Miller-Rabin on any of them
*/
if( ( ret = mpi_check_small_factors( X ) ) == 0 &&
( ret = mpi_check_small_factors( &Y ) ) == 0 &&
( ret = mpi_miller_rabin( X, f_rng, p_rng ) ) == 0 &&
( ret = mpi_miller_rabin( &Y, f_rng, p_rng ) ) == 0 )
{
break;
}
if( ret != MBEDTLS_ERR_MPI_NOT_ACCEPTABLE )
goto cleanup;
/*
* Next candidates. We want to preserve Y = (X-1) / 2 and
* Y = 1 mod 2 and Y = 2 mod 3 (eq X = 3 mod 4 and X = 2 mod 3)
* so up Y by 6 and X by 12.
*/
MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( X, X, 12 ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( &Y, &Y, 6 ) );
}
}
cleanup:
mbedtls_mpi_free( &Y );
return( ret );
} | 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)
movq %rsi, %r13
shrq $0x6, %r13
movl %ebx, %eax
andl $0x3f, %eax
cmpq $0x1, %rax
sbbq $-0x1, %r13
cmpq $0x80, %r13
ja 0x297f1
movq %rcx, %r14
movl %edx, %r12d
movq %rdi, %r15
shlq $0x3, %r13
leaq 0x30(%rsp), %rsi
movq %r8, %rdi
movq %r13, %rdx
movq %r8, 0x8(%rsp)
callq *%rcx
movl %eax, %ebp
testl %eax, %eax
jne 0x297f1
leaq 0x30(%rsp), %rsi
movq %r15, %rdi
movq %r13, %rdx
callq 0x26657
testl %eax, %eax
je 0x29830
movl %eax, %ebp
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2981c
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x29817
xorl %ecx, %ecx
movq $0x0, (%rdi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x29807
callq 0xf030
movl %ebp, %eax
addq $0x438, %rsp # imm = 0x438
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x25d9f
subq %rbx, %rax
jbe 0x2984f
incq %rax
movq %r15, %rdi
movq %rax, %rsi
callq 0x268af
testl %eax, %eax
jne 0x297ef
decq %rbx
movq %r15, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x25ceb
movq 0x10(%r15), %rax
movq (%rax), %rcx
movq %rcx, %rdx
orq $0x1, %rdx
movq %rdx, (%rax)
testl %r12d, %r12d
je 0x298b9
orq $0x3, %rcx
movq %rcx, (%rax)
leaq 0x28(%rsp), %rdi
movl $0x3, %edx
movq %r15, %rsi
callq 0x27bf1
testl %eax, %eax
jne 0x297ef
movq 0x28(%rsp), %rax
cmpq $0x1, %rax
je 0x29911
testq %rax, %rax
jne 0x29945
movq %rsp, %rax
movq $0x8, (%rax)
jmp 0x2991b
movq %rsp, %r12
leaq 0x30(%rsp), %rbx
movq %r15, %rdi
movq %r14, %rsi
movq 0x8(%rsp), %rdx
callq 0x28fac
cmpl $-0xe, %eax
jne 0x297ef
movq $0x2, (%rsp)
movl $0x1, 0x30(%rsp)
movq $0x1, 0x38(%rsp)
movq %r12, 0x40(%rsp)
movq %r15, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x26d51
movl %eax, %ebp
testl %eax, %eax
je 0x298c1
jmp 0x297f1
movq %rsp, %rax
movq $0x4, (%rax)
leaq 0x30(%rsp), %rdx
movl $0x1, (%rdx)
movq $0x1, 0x8(%rdx)
movq %rax, 0x10(%rdx)
movq %r15, %rdi
movq %r15, %rsi
callq 0x26d51
testl %eax, %eax
jne 0x297ef
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x25a94
testl %eax, %eax
jne 0x297ef
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x268af
testl %eax, %eax
jne 0x297ef
leaq 0x10(%rsp), %r12
movq %rsp, %rbx
leaq 0x30(%rsp), %r13
movq %r15, %rdi
callq 0x29097
testl %eax, %eax
jne 0x299aa
movq %r12, %rdi
callq 0x29097
testl %eax, %eax
jne 0x299aa
movq %r15, %rdi
movq %r14, %rsi
movq 0x8(%rsp), %rdx
callq 0x29141
testl %eax, %eax
je 0x29a24
movl %eax, %ebp
cmpl $-0xe, %eax
jne 0x297f1
movq $0xc, (%rsp)
movl $0x1, 0x30(%rsp)
movq $0x1, 0x38(%rsp)
movq %rbx, 0x40(%rsp)
movq %r15, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x26d51
testl %eax, %eax
jne 0x297ef
movq $0x6, (%rsp)
movl $0x1, 0x30(%rsp)
movq $0x1, 0x38(%rsp)
movq %rbx, 0x40(%rsp)
movq %r12, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x26d51
movl %eax, %ebp
testl %eax, %eax
je 0x2997e
jmp 0x297f1
movq %r12, %rdi
movq %r14, %rsi
movq 0x8(%rsp), %rdx
callq 0x29141
cmpl $-0xe, %eax
je 0x299b5
jmp 0x297ef
| /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;
supported_init = 1;
}
return( mbedtls_cipher_supported );
} | 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), %rcx # 0x72510
movl $0x0, (%rcx)
movb $0x1, 0x484bd(%rip) # 0x72504
leaq 0x484c2(%rip), %rax # 0x72510
retq
| /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_definitions; def->info != NULL; def++ )
if( def->info->base->cipher == cipher_id &&
def->info->key_bitlen == (unsigned) key_bitlen &&
def->info->mode == mode )
return( def->info );
return( NULL );
} | 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 MBEDTLS_PADDING_PKCS7:
ctx->add_padding = add_pkcs_padding;
ctx->get_padding = get_pkcs_padding;
break;
#endif
#if defined(MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS)
case MBEDTLS_PADDING_ONE_AND_ZEROS:
ctx->add_padding = add_one_and_zeros_padding;
ctx->get_padding = get_one_and_zeros_padding;
break;
#endif
#if defined(MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN)
case MBEDTLS_PADDING_ZEROS_AND_LEN:
ctx->add_padding = add_zeros_and_len_padding;
ctx->get_padding = get_zeros_and_len_padding;
break;
#endif
#if defined(MBEDTLS_CIPHER_PADDING_ZEROS)
case MBEDTLS_PADDING_ZEROS:
ctx->add_padding = add_zeros_padding;
ctx->get_padding = get_zeros_padding;
break;
#endif
case MBEDTLS_PADDING_NONE:
ctx->add_padding = NULL;
ctx->get_padding = get_no_padding;
break;
default:
return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
}
return( 0 );
} | 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
movq (%rdx,%rax,8), %rax
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
xorl %eax, %eax
retq
| /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_starts( (mbedtls_gcm_context *) ctx->cipher_ctx, ctx->operation,
ctx->iv, ctx->iv_size, ad, ad_len );
}
return( 0 );
} | 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 ||
MBEDTLS_MODE_CTR == ctx->cipher_info->mode ||
MBEDTLS_MODE_GCM == ctx->cipher_info->mode ||
MBEDTLS_MODE_STREAM == ctx->cipher_info->mode )
{
return( 0 );
}
if( MBEDTLS_MODE_ECB == ctx->cipher_info->mode )
{
if( ctx->unprocessed_len != 0 )
return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
return( 0 );
}
#if defined(MBEDTLS_CIPHER_MODE_CBC)
if( MBEDTLS_MODE_CBC == ctx->cipher_info->mode )
{
int ret = 0;
if( MBEDTLS_ENCRYPT == ctx->operation )
{
/* check for 'no padding' mode */
if( NULL == ctx->add_padding )
{
if( 0 != ctx->unprocessed_len )
return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
return( 0 );
}
ctx->add_padding( ctx->unprocessed_data, mbedtls_cipher_get_iv_size( ctx ),
ctx->unprocessed_len );
}
else if( mbedtls_cipher_get_block_size( ctx ) != ctx->unprocessed_len )
{
/*
* For decrypt operations, expect a full block,
* or an empty block if no padding
*/
if( NULL == ctx->add_padding && 0 == ctx->unprocessed_len )
return( 0 );
return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
}
/* cipher block */
if( 0 != ( ret = ctx->cipher_info->base->cbc_func( ctx->cipher_ctx,
ctx->operation, mbedtls_cipher_get_block_size( ctx ), ctx->iv,
ctx->unprocessed_data, output ) ) )
{
return( ret );
}
/* Set output size for decryption */
if( MBEDTLS_DECRYPT == ctx->operation )
return ctx->get_padding( output, mbedtls_cipher_get_block_size( ctx ),
olen );
/* Set output size for encryption */
*olen = mbedtls_cipher_get_block_size( ctx );
return( 0 );
}
#else
((void) output);
#endif /* MBEDTLS_CIPHER_MODE_CBC */
return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
} | 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
ja 0x2a6a0
xorl %eax, %eax
leaq 0x2bb3c(%rip), %rsi # 0x56188
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
xorl %ecx, %ecx
cmpq $0x0, 0x30(%r15)
movl $0xffff9d80, %eax # imm = 0xFFFF9D80
cmovel %ecx, %eax
jmp 0x2a704
movl 0xc(%r15), %esi
cmpl $0x1, %esi
jne 0x2a6a7
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x2a655
leaq 0x20(%r15), %rdi
movq 0x48(%r15), %rdx
testq %rdx, %rdx
jne 0x2a68b
movl 0x18(%rcx), %edx
movslq %edx, %rsi
movq 0x30(%r15), %rdx
callq *%rax
movq (%r15), %rcx
movl 0xc(%r15), %esi
movl 0x20(%rcx), %edx
jmp 0x2a6b3
movl $0xffff9f80, %eax # imm = 0xFFFF9F80
jmp 0x2a704
movl 0x20(%rcx), %edx
movq 0x30(%r15), %rax
cmpq %rdx, %rax
jne 0x2a6e3
movq 0x28(%rcx), %rax
movq 0x50(%r15), %rdi
leaq 0x38(%r15), %rcx
leaq 0x20(%r15), %r8
movq %r14, %r9
callq *0x10(%rax)
testl %eax, %eax
jne 0x2a704
cmpl $0x0, 0xc(%r15)
je 0x2a6ee
movq (%r15), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x2a6ff
movl 0x20(%rcx), %ecx
jmp 0x2a701
xorl %ecx, %ecx
orq 0x10(%r15), %rax
jmp 0x2a65c
movq (%r15), %rcx
movq 0x18(%r15), %rax
testq %rcx, %rcx
je 0x2a70a
movl 0x20(%rcx), %esi
jmp 0x2a70c
xorl %ecx, %ecx
movq %rcx, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
xorl %esi, %esi
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
| /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_len = 0;
for( i = input_len; i > 0; i-- )
{
prev_done = done;
done |= ( input[i-1] != 0 );
*data_len |= ( i - 1 ) * ( done != prev_done );
bad &= ( input[i-1] ^ 0x80 ) | ( done == prev_done );
}
return( MBEDTLS_ERR_CIPHER_INVALID_PADDING * ( bad != 0 ) );
} | 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
movl $0x0, %r10d
cmovneq %rsi, %r10
orq %r10, %rcx
movq %rcx, (%rdx)
orb (%rdi,%rsi), %r8b
addb $-0x80, %r8b
andb %r8b, %al
movl %r9d, %r8d
addq $-0x1, %rsi
jb 0x2a7ea
xorl %ecx, %ecx
testb %al, %al
movl $0xffff9e00, %eax # imm = 0xFFFF9E00
cmovel %ecx, %eax
retq
movl $0xffff9e00, %eax # imm = 0xFFFF9E00
retq
| /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_BAD_INPUT_DATA );
if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
return mbedtls_gcm_finish( (mbedtls_gcm_context *) ctx->cipher_ctx, tag, tag_len );
return( 0 );
} | 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_len ) ) != 0 )
return( ret );
if( ( ret = mbedtls_cipher_reset( ctx ) ) != 0 )
return( ret );
if( ( ret = mbedtls_cipher_update( ctx, input, ilen, output, olen ) ) != 0 )
return( ret );
if( ( ret = mbedtls_cipher_finish( ctx, output + *olen, &finish_olen ) ) != 0 )
return( ret );
*olen += finish_olen;
return( 0 );
} | 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 # imm = 0xFFFF9F80
cmpq $0x10, %r13
ja 0x2aab6
movq %r9, %rbx
movq %r8, %r15
testb $0x1, 0x1c(%rcx)
jne 0x2aa61
movl 0x18(%rcx), %ecx
movl $0xffff9f00, %eax # imm = 0xFFFF9F00
cmpq %r13, %rcx
movq %rcx, %r13
ja 0x2aab6
movq 0x40(%rsp), %rbp
leaq 0x38(%r14), %rdi
movq %r13, %rdx
callq 0xf240
movq %r13, 0x48(%r14)
movq $0x0, 0x30(%r14)
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
movq %rbp, %r8
callq 0x2a315
testl %eax, %eax
jne 0x2aab6
addq (%rbp), %rbx
movq %rsp, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2a5fd
testl %eax, %eax
jne 0x2aab6
movq (%rsp), %rax
addq %rax, (%rbp)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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,
const unsigned char *tag, size_t tag_len )
{
#if defined(MBEDTLS_GCM_C)
if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
{
int ret;
*olen = ilen;
ret = mbedtls_gcm_auth_decrypt( ctx->cipher_ctx, ilen,
iv, iv_len, ad, ad_len,
tag, tag_len, input, output );
if( ret == MBEDTLS_ERR_GCM_AUTH_FAILED )
ret = MBEDTLS_ERR_CIPHER_AUTH_FAILED;
return( ret );
}
#endif /* MBEDTLS_GCM_C */
#if defined(MBEDTLS_CCM_C)
if( MBEDTLS_MODE_CCM == ctx->cipher_info->mode )
{
int ret;
*olen = ilen;
ret = mbedtls_ccm_auth_decrypt( ctx->cipher_ctx, ilen,
iv, iv_len, ad, ad_len,
input, output, tag, tag_len );
if( ret == MBEDTLS_ERR_CCM_AUTH_FAILED )
ret = MBEDTLS_ERR_CIPHER_AUTH_FAILED;
return( ret );
}
#endif /* MBEDTLS_CCM_C */
return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
} | 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 $0xffff9f80, %eax # imm = 0xFFFF9F80
cmpl $0x6, %ebp
jne 0x2abe5
movq %rsi, (%r15)
movq 0x50(%rdi), %rdi
pushq %r14
pushq %r10
pushq %rbx
pushq %r11
callq 0x3852a
addq $0x20, %rsp
movl %eax, %ecx
cmpl $-0x12, %eax
jmp 0x2abdd
movq %rsi, (%r15)
movq 0x50(%rdi), %rdi
pushq %rbx
pushq %r11
pushq %r14
pushq %r10
callq 0x486b8
addq $0x20, %rsp
movl %eax, %ecx
cmpl $-0xf, %eax
movl $0xffff9d00, %eax # imm = 0xFFFF9D00
cmovnel %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /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 )
{
int ret;
unsigned char key[MBEDTLS_CTR_DRBG_KEYSIZE];
memset( key, 0, MBEDTLS_CTR_DRBG_KEYSIZE );
mbedtls_aes_init( &ctx->aes_ctx );
ctx->f_entropy = f_entropy;
ctx->p_entropy = p_entropy;
ctx->entropy_len = entropy_len;
ctx->reseed_interval = MBEDTLS_CTR_DRBG_RESEED_INTERVAL;
/*
* Initialize with an empty key
*/
mbedtls_aes_setkey_enc( &ctx->aes_ctx, key, MBEDTLS_CTR_DRBG_KEYBITS );
if( ( ret = mbedtls_ctr_drbg_reseed( ctx, custom, len ) ) != 0 )
return( ret );
return( 0 );
} | 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 0x441fc
movq %r13, 0x148(%rbp)
movq %r12, 0x150(%rbp)
movq %rbx, 0x18(%rbp)
movl $0x2710, 0x20(%rbp) # imm = 0x2710
movq %r15, %rdi
movq %r14, %rsi
movl $0x100, %edx # imm = 0x100
callq 0x4421f
movq %rbp, %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x2af2d
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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_input[MBEDTLS_CTR_DRBG_SEEDLEN];
unsigned char *p = output;
unsigned char tmp[MBEDTLS_CTR_DRBG_BLOCKSIZE];
int i;
size_t use_len;
if( output_len > MBEDTLS_CTR_DRBG_MAX_REQUEST )
return( MBEDTLS_ERR_CTR_DRBG_REQUEST_TOO_BIG );
if( add_len > MBEDTLS_CTR_DRBG_MAX_INPUT )
return( MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG );
memset( add_input, 0, MBEDTLS_CTR_DRBG_SEEDLEN );
if( ctx->reseed_counter > ctx->reseed_interval ||
ctx->prediction_resistance )
{
if( ( ret = mbedtls_ctr_drbg_reseed( ctx, additional, add_len ) ) != 0 )
return( ret );
add_len = 0;
}
if( add_len > 0 )
{
block_cipher_df( add_input, additional, add_len );
ctr_drbg_update_internal( ctx, add_input );
}
while( output_len > 0 )
{
/*
* Increase counter
*/
for( i = MBEDTLS_CTR_DRBG_BLOCKSIZE; i > 0; i-- )
if( ++ctx->counter[i - 1] != 0 )
break;
/*
* Crypt counter block
*/
mbedtls_aes_crypt_ecb( &ctx->aes_ctx, MBEDTLS_AES_ENCRYPT, ctx->counter, tmp );
use_len = ( output_len > MBEDTLS_CTR_DRBG_BLOCKSIZE ) ? MBEDTLS_CTR_DRBG_BLOCKSIZE :
output_len;
/*
* Copy random block to destination
*/
memcpy( p, tmp, use_len );
p += use_len;
output_len -= use_len;
}
ctr_drbg_update_internal( ctx, add_input );
ctx->reseed_counter++;
return( 0 );
} | 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
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl 0x10(%rdi), %eax
cmpl 0x20(%rdi), %eax
jg 0x2b2f9
cmpl $0x0, 0x14(%rbx)
je 0x2b311
movq %rbx, %rdi
movq %rcx, %rsi
movq %r8, %rdx
callq 0x2af2d
testl %eax, %eax
jne 0x2b39a
jmp 0x2b332
testq %r8, %r8
je 0x2b332
movq %rsp, %r12
movq %r12, %rdi
movq %rcx, %rsi
movq %r8, %rdx
callq 0x2b06d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2b1f4
testq %r14, %r14
je 0x2b38a
leaq 0x28(%rbx), %r12
leaq 0x30(%rsp), %r13
movl $0xf, %eax
cmpq $-0x1, %rax
je 0x2b354
incb (%rbx,%rax)
leaq -0x1(%rax), %rax
je 0x2b345
movq %r12, %rdi
movl $0x1, %esi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x45363
cmpq $0x10, %r14
movl $0x10, %ebp
cmovbq %r14, %rbp
movq %r15, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0xf240
addq %rbp, %r15
subq %rbp, %r14
jne 0x2b340
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2b1f4
incl 0x10(%rbx)
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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
jb 0x2bd72
xorl %eax, %eax
popq %rbx
retq
| /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 ] = esk[30 - i];
dsk[i + 1] = esk[31 - i];
esk[i + 32] = dsk[62 - i];
esk[i + 33] = dsk[63 - i];
esk[i + 64] = esk[i ];
esk[i + 65] = esk[i + 1];
dsk[i + 64] = dsk[i ];
dsk[i + 65] = dsk[i + 1];
}
} | 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(%rbx,%rcx,4)
movl -0x4(%rbx,%rax,4), %edx
movl %edx, -0x80(%r14,%rcx,4)
movl (%rbx,%rax,4), %edx
movl %edx, -0x7c(%r14,%rcx,4)
movq -0x100(%r14,%rcx,4), %rdx
movq %rdx, (%r14,%rcx,4)
movq -0x100(%rbx,%rcx,4), %rdx
movq %rdx, (%rbx,%rcx,4)
leaq 0x2(%rcx), %rdx
addq $-0x40, %rcx
addq $-0x2, %rax
cmpq $0x1e, %rcx
movq %rdx, %rcx
jb 0x2bdfe
popq %rbx
popq %r14
popq %r15
retq
| /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 )
return( MBEDTLS_ERR_DES_INVALID_INPUT_LENGTH );
if( mode == MBEDTLS_DES_ENCRYPT )
{
while( length > 0 )
{
for( i = 0; i < 8; i++ )
output[i] = (unsigned char)( input[i] ^ iv[i] );
mbedtls_des3_crypt_ecb( ctx, output, output );
memcpy( iv, output, 8 );
input += 8;
output += 8;
length -= 8;
}
}
else /* MBEDTLS_DES_DECRYPT */
{
while( length > 0 )
{
memcpy( temp, input, 8 );
mbedtls_des3_crypt_ecb( ctx, input, output );
for( i = 0; i < 8; i++ )
output[i] = (unsigned char)( output[i] ^ iv[i] );
memcpy( iv, temp, 8 );
input += 8;
output += 8;
length -= 8;
}
}
return( 0 );
} | 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), %cl
xorb (%r14,%rax), %cl
movb %cl, (%rbx,%rax)
incq %rax
cmpq $0x8, %rax
jne 0x2c76b
movq %r13, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x2c288
movq (%rbx), %rax
movq %rax, (%r15)
addq $0x8, %r14
addq $0x8, %rbx
addq $-0x8, %r12
jne 0x2c769
jmp 0x2c7dc
testq %r12, %r12
je 0x2c7dc
movq (%r14), %rbp
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2c288
xorl %eax, %eax
movb (%r15,%rax), %cl
xorb %cl, (%rbx,%rax)
incq %rax
cmpq $0x8, %rax
jne 0x2c7bb
movq %rbp, (%r15)
addq $0x8, %r14
addq $0x8, %rbx
addq $-0x8, %r12
jne 0x2c7a8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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_cmp_int( &ctx->P, 0 ) == 0 )
return( MBEDTLS_ERR_DHM_BAD_INPUT_DATA );
/*
* Generate X as large as possible ( < P )
*/
do
{
mbedtls_mpi_fill_random( &ctx->X, x_size, f_rng, p_rng );
while( mbedtls_mpi_cmp_mpi( &ctx->X, &ctx->P ) >= 0 )
MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &ctx->X, 1 ) );
if( count++ > 10 )
return( MBEDTLS_ERR_DHM_MAKE_PARAMS_FAILED );
}
while( dhm_check_range( &ctx->X, &ctx->P ) != 0 );
/*
* Calculate GX = G^X mod P
*/
MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &ctx->GX, &ctx->G, &ctx->X,
&ctx->P , &ctx->RP ) );
if( ( ret = dhm_check_range( &ctx->GX, &ctx->P ) ) != 0 )
return( ret );
/*
* export P, G, GX
*/
#define DHM_MPI_EXPORT(X,n) \
MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( X, p + 2, n ) ); \
*p++ = (unsigned char)( n >> 8 ); \
*p++ = (unsigned char)( n ); p += n;
n1 = mbedtls_mpi_size( &ctx->P );
n2 = mbedtls_mpi_size( &ctx->G );
n3 = mbedtls_mpi_size( &ctx->GX );
p = output;
DHM_MPI_EXPORT( &ctx->P , n1 );
DHM_MPI_EXPORT( &ctx->G , n2 );
DHM_MPI_EXPORT( &ctx->GX, n3 );
*olen = p - output;
ctx->len = n1;
cleanup:
if( ret != 0 )
return( MBEDTLS_ERR_DHM_MAKE_PARAMS_FAILED + ret );
return( 0 );
} | 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(%rsp)
movq %r13, 0x30(%rsp)
leaq 0x38(%r13), %rbx
movslq %r15d, %r15
movq 0x8(%rsp), %r13
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r13, %rcx
callq 0x2887e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x26a39
testl %eax, %eax
js 0x2cebb
movl $0x1, %esi
movq %rbx, %rdi
callq 0x268af
testl %eax, %eax
je 0x2ce99
jmp 0x2cefc
cmpl $0xb, %r14d
je 0x2cf17
incl %r14d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2cda2
testl %eax, %eax
jne 0x2ce88
movq 0x30(%rsp), %r14
leaq 0x50(%r14), %r13
leaq 0x20(%r14), %rbp
leaq 0x98(%r14), %r8
movq %r13, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x27c79
testl %eax, %eax
je 0x2cf1e
addl $0xffffce80, %eax # imm = 0xFFFFCE80
jmp 0x2cf08
movl $0xffffcf80, %eax # imm = 0xFFFFCF80
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffce80, %eax # imm = 0xFFFFCE80
jmp 0x2cf08
movq %r13, %rdi
movq %r12, %rsi
callq 0x2cda2
testl %eax, %eax
jne 0x2cf08
movq %r12, %rdi
callq 0x25e13
movq %rax, %r15
movq %rbp, %rdi
callq 0x25e13
movq %rax, 0x20(%rsp)
movq %r13, %rdi
callq 0x25e13
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rbx
leaq 0x2(%rbx), %rsi
movq %r12, %rdi
movq %rsi, %r12
movq %r15, 0x8(%rsp)
movq %r15, %rdx
callq 0x26734
testl %eax, %eax
jne 0x2cefc
movq 0x8(%rsp), %rcx
movl %ecx, %eax
rolw $0x8, %ax
movw %ax, (%rbx)
leaq (%r12,%rcx), %rbx
addq $0x2, %rbx
movq %rbp, %rdi
movq %rbx, %rsi
movq 0x20(%rsp), %rbp
movq %rbp, %rdx
callq 0x26734
testl %eax, %eax
jne 0x2cefc
addq 0x8(%rsp), %r12
movl %ebp, %eax
rolw $0x8, %ax
movw %ax, (%r12)
leaq (%rbx,%rbp), %r15
addq $0x2, %r15
movq %r13, %rdi
movq %r15, %rsi
movq 0x18(%rsp), %r13
movq %r13, %rdx
callq 0x26734
testl %eax, %eax
jne 0x2cefc
addq %rbp, %rbx
movl %r13d, %eax
rolw $0x8, %ax
movw %ax, (%rbx)
addq %r13, %r15
subq 0x10(%rsp), %r15
movq 0x28(%rsp), %rax
movq %r15, (%rax)
movq 0x8(%rsp), %rax
movq %rax, (%r14)
xorl %eax, %eax
jmp 0x2cf08
| /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 )
return( MBEDTLS_ERR_DHM_BAD_INPUT_DATA );
if( mbedtls_mpi_cmp_int( &ctx->P, 0 ) == 0 )
return( MBEDTLS_ERR_DHM_BAD_INPUT_DATA );
/*
* generate X and calculate GX = G^X mod P
*/
do
{
mbedtls_mpi_fill_random( &ctx->X, x_size, f_rng, p_rng );
while( mbedtls_mpi_cmp_mpi( &ctx->X, &ctx->P ) >= 0 )
MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &ctx->X, 1 ) );
if( count++ > 10 )
return( MBEDTLS_ERR_DHM_MAKE_PUBLIC_FAILED );
}
while( dhm_check_range( &ctx->X, &ctx->P ) != 0 );
MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &ctx->GX, &ctx->G, &ctx->X,
&ctx->P , &ctx->RP ) );
if( ( ret = dhm_check_range( &ctx->GX, &ctx->P ) ) != 0 )
return( ret );
MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( &ctx->GX, output, olen ) );
cleanup:
if( ret != 0 )
return( MBEDTLS_ERR_DHM_MAKE_PUBLIC_FAILED + ret );
return( 0 );
} | 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(%rsp)
movq %rdx, (%rsp)
leaq 0x8(%r15), %r12
xorl %ebp, %ebp
movq %r12, %rdi
xorl %esi, %esi
callq 0x26ad2
testl %eax, %eax
je 0x2d11d
leaq 0x38(%r15), %r14
movslq %r13d, %r13
movq %r14, %rdi
movq %r13, %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x2887e
movq %r14, %rdi
movq %r12, %rsi
callq 0x26a39
testl %eax, %eax
js 0x2d0d6
movl $0x1, %esi
movq %r14, %rdi
callq 0x268af
testl %eax, %eax
je 0x2d0b4
jmp 0x2d110
cmpl $0xb, %ebp
je 0x2d12f
incl %ebp
movq %r14, %rdi
movq %r12, %rsi
callq 0x2cda2
testl %eax, %eax
jne 0x2d09f
leaq 0x50(%r15), %r13
leaq 0x20(%r15), %rsi
addq $0x98, %r15
movq %r13, %rdi
movq %r14, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0x27c79
testl %eax, %eax
je 0x2d137
leal -0x3280(%rax), %r14d
testl %eax, %eax
cmovel %eax, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffcd80, %r14d # imm = 0xFFFFCD80
jmp 0x2d11d
movq %r13, %rdi
movq %r12, %rsi
callq 0x2cda2
movl %eax, %r14d
testl %eax, %eax
jne 0x2d11d
movq %r13, %rdi
movq (%rsp), %rsi
movq %rbx, %rdx
callq 0x26734
jmp 0x2d110
| /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 )
return( curve_info );
}
return( NULL );
} | 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 != MBEDTLS_ECP_PF_COMPRESSED )
return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
/*
* Common case: P == 0
*/
if( mbedtls_mpi_cmp_int( &P->Z, 0 ) == 0 )
{
if( buflen < 1 )
return( MBEDTLS_ERR_ECP_BUFFER_TOO_SMALL );
buf[0] = 0x00;
*olen = 1;
return( 0 );
}
plen = mbedtls_mpi_size( &grp->P );
if( format == MBEDTLS_ECP_PF_UNCOMPRESSED )
{
*olen = 2 * plen + 1;
if( buflen < *olen )
return( MBEDTLS_ERR_ECP_BUFFER_TOO_SMALL );
buf[0] = 0x04;
MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( &P->X, buf + 1, plen ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( &P->Y, buf + 1 + plen, plen ) );
}
else if( format == MBEDTLS_ECP_PF_COMPRESSED )
{
*olen = plen + 1;
if( buflen < *olen )
return( MBEDTLS_ERR_ECP_BUFFER_TOO_SMALL );
buf[0] = 0x02 + mbedtls_mpi_get_bit( &P->Y, 0 );
MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( &P->X, buf + 1, plen ) );
}
cleanup:
return( ret );
} | 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 %rdi, %r15
leaq 0x30(%rsi), %rdi
xorl %esi, %esi
callq 0x26ad2
testl %eax, %eax
je 0x2e01a
addq $0x8, %r15
movq %r15, %rdi
callq 0x25e13
movq %rax, %r15
testl %ebp, %ebp
je 0x2e031
movq %r15, %rcx
incq %rcx
movq %rcx, (%r13)
movl $0xffffb100, %eax # imm = 0xFFFFB100
cmpq %r12, %rcx
ja 0x2df96
leaq 0x18(%r14), %rdi
xorl %esi, %esi
callq 0x25cc3
addb $0x2, %al
movb %al, (%rbx)
incq %rbx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x26734
testq %r12, %r12
je 0x2e074
movb $0x0, (%rbx)
movq $0x1, (%r13)
xorl %eax, %eax
jmp 0x2df96
leaq (%r15,%r15), %rcx
leaq 0x1(,%r15,2), %rax
movq %rax, (%r13)
movl $0xffffb100, %eax # imm = 0xFFFFB100
cmpq %r12, %rcx
jae 0x2df96
movb $0x4, (%rbx)
incq %rbx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x26734
testl %eax, %eax
jne 0x2df96
addq $0x18, %r14
addq %r15, %rbx
jmp 0x2dffe
movl $0xffffb100, %eax # imm = 0xFFFFB100
jmp 0x2df96
| /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( buf_len < 2 )
return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
data_len = *(*buf)++;
if( data_len < 1 || data_len > buf_len - 1 )
return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
/*
* Save buffer start for read_binary and update buf
*/
buf_start = *buf;
*buf += data_len;
return mbedtls_ecp_point_read_binary( grp, pt, buf_start, data_len );
} | 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 );
/*
* We are going to write 3 bytes (see below)
*/
*olen = 3;
if( blen < *olen )
return( MBEDTLS_ERR_ECP_BUFFER_TOO_SMALL );
/*
* First byte is curve_type, always named_curve
*/
*buf++ = MBEDTLS_ECP_TLS_NAMED_CURVE;
/*
* Next two bytes are the namedcurve value
*/
buf[0] = curve_info->tls_id >> 8;
buf[1] = curve_info->tls_id & 0xFF;
return( 0 );
} | 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, (%rdx)
movzwl -0xc(%rdi), %eax
movb %ah, 0x1(%rdx)
movb %al, 0x2(%rdx)
xorl %eax, %eax
retq
| /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, i;
size_t d;
unsigned char k[COMB_MAX_D + 1];
mbedtls_ecp_point *T;
mbedtls_mpi M, mm;
mbedtls_mpi_init( &M );
mbedtls_mpi_init( &mm );
/* we need N to be odd to trnaform m in an odd number, check now */
if( mbedtls_mpi_get_bit( &grp->N, 0 ) != 1 )
return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
/*
* Minimize the number of multiplications, that is minimize
* 10 * d * w + 18 * 2^(w-1) + 11 * d + 7 * w, with d = ceil( nbits / w )
* (see costs of the various parts, with 1S = 1M)
*/
w = grp->nbits >= 384 ? 5 : 4;
/*
* If P == G, pre-compute a bit more, since this may be re-used later.
* Just adding one avoids upping the cost of the first mul too much,
* and the memory cost too.
*/
#if MBEDTLS_ECP_FIXED_POINT_OPTIM == 1
p_eq_g = ( mbedtls_mpi_cmp_mpi( &P->Y, &grp->G.Y ) == 0 &&
mbedtls_mpi_cmp_mpi( &P->X, &grp->G.X ) == 0 );
if( p_eq_g )
w++;
#else
p_eq_g = 0;
#endif
/*
* Make sure w is within bounds.
* (The last test is useful only for very small curves in the test suite.)
*/
if( w > MBEDTLS_ECP_WINDOW_SIZE )
w = MBEDTLS_ECP_WINDOW_SIZE;
if( w >= grp->nbits )
w = 2;
/* Other sizes that depend on w */
pre_len = 1U << ( w - 1 );
d = ( grp->nbits + w - 1 ) / w;
/*
* Prepare precomputed points: if P == G we want to
* use grp->T if already initialized, or initialize it.
*/
T = p_eq_g ? grp->T : NULL;
if( T == NULL )
{
T = mbedtls_calloc( pre_len, sizeof( mbedtls_ecp_point ) );
if( T == NULL )
{
ret = MBEDTLS_ERR_ECP_ALLOC_FAILED;
goto cleanup;
}
MBEDTLS_MPI_CHK( ecp_precompute_comb( grp, T, P, w, d ) );
if( p_eq_g )
{
grp->T = T;
grp->T_size = pre_len;
}
}
/*
* Make sure M is odd (M = m or M = N - m, since N is odd)
* using the fact that m * P = - (N - m) * P
*/
m_is_odd = ( mbedtls_mpi_get_bit( m, 0 ) == 1 );
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &M, m ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &mm, &grp->N, m ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_safe_cond_assign( &M, &mm, ! m_is_odd ) );
/*
* Go for comb multiplication, R = M * P
*/
ecp_comb_fixed( k, d, w, &M );
MBEDTLS_MPI_CHK( ecp_mul_comb_core( grp, R, T, pre_len, k, d, f_rng, p_rng ) );
/*
* Now get m * P from M * P and normalize it
*/
MBEDTLS_MPI_CHK( ecp_safe_invert_jac( grp, R, ! m_is_odd ) );
MBEDTLS_MPI_CHK( ecp_normalize_jac( grp, R ) );
cleanup:
if( T != NULL && ! p_eq_g )
{
for( i = 0; i < pre_len; i++ )
mbedtls_ecp_point_free( &T[i] );
mbedtls_free( T );
}
mbedtls_mpi_free( &M );
mbedtls_mpi_free( &mm );
if( ret != 0 )
mbedtls_ecp_point_free( R );
return( ret );
} | 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(%rsp)
xorl %esi, %esi
callq 0x25cc3
movl $0xffffb080, %r13d # imm = 0xFFFFB080
cmpl $0x1, %eax
jne 0x2f1bf
movq %r14, 0x58(%rsp)
movq %rbx, 0x60(%rsp)
cmpq $0x180, 0xb8(%r15) # imm = 0x180
setae %bl
orb $0x4, %bl
leaq 0x18(%rbp), %rdi
leaq 0x68(%r15), %rsi
callq 0x26a39
testl %eax, %eax
je 0x2ef2b
xorl %r14d, %r14d
jmp 0x2ef3d
leaq 0x50(%r15), %rsi
movq %rbp, %rdi
callq 0x26a39
testl %eax, %eax
sete %r14b
addb %r14b, %bl
movzbl %bl, %eax
movq 0xb8(%r15), %rdx
cmpq %rax, %rdx
movl $0x2, %esi
cmoval %eax, %esi
leal -0x1(%rsi), %ecx
movl $0x1, %r13d
shll %cl, %r13d
movzbl %sil, %ecx
leaq (%rdx,%rcx), %rax
decq %rax
movq %rax, 0x20(%rsp)
xorl %edx, %edx
movq %rcx, 0x30(%rsp)
divq %rcx
movq %rax, %rbx
testb %r14b, %r14b
movq %r15, 0x10(%rsp)
je 0x2f078
movq 0xe8(%r15), %r15
testq %r15, %r15
je 0x2f078
movq %rbx, 0x18(%rsp)
movl %r13d, 0x4(%rsp)
movq 0x28(%rsp), %rbp
movq %rbp, %rdi
xorl %esi, %esi
callq 0x25cc3
movl %eax, %ebx
leaq 0x70(%rsp), %rdi
movq %rbp, %rsi
callq 0x25a94
testl %eax, %eax
jne 0x2f0a6
leaq 0x88(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq %rbp, %rdx
callq 0x26dbf
testl %eax, %eax
jne 0x2f0a6
xorl %ebp, %ebp
cmpl $0x1, %ebx
setne %bpl
leaq 0x70(%rsp), %rdi
leaq 0x88(%rsp), %rsi
movl %ebp, %edx
callq 0x25b5f
testl %eax, %eax
jne 0x2f0a6
movl %ebp, 0x28(%rsp)
movl %r14d, (%rsp)
movq %r12, %r14
leaq 0xa0(%rsp), %r12
leaq 0x70(%rsp), %rcx
movq %r12, %rdi
movq 0x18(%rsp), %rbx
movq %rbx, %rsi
movq 0x30(%rsp), %rdx
callq 0x306e1
movzbl 0x4(%rsp), %ecx
movq 0x10(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %r8
movq %rbx, %r9
pushq 0x58(%rsp)
pushq 0x68(%rsp)
callq 0x307c3
addq $0x10, %rsp
testl %eax, %eax
je 0x2f1d4
movl %eax, %r13d
movq %r14, %r12
jmp 0x2f15d
movl %r13d, %edi
movl $0x48, %esi
movq %rdi, 0x50(%rsp)
callq 0xf1d0
testq %rax, %rax
je 0x2f0ae
movq %rax, %r15
movl %r13d, 0x4(%rsp)
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2de5b
testl %eax, %eax
je 0x2f0b9
movl %eax, %r13d
jmp 0x2f161
movl $0xffffb280, %r13d # imm = 0xFFFFB280
jmp 0x2f196
movq %rbx, 0x18(%rsp)
movl %r14d, (%rsp)
movq %r12, 0x8(%rsp)
movl $0x1, %r12d
xorl %ebx, %ebx
movl %r12d, %eax
leaq (%rax,%rax,8), %rax
leaq (%r15,%rax,8), %rbp
movl %r12d, %eax
shrl %eax
leaq (%rax,%rax,8), %rax
leaq (%r15,%rax,8), %rsi
movq %rbp, %rdi
callq 0x2de5b
testl %eax, %eax
jne 0x2f155
movq 0x18(%rsp), %r14
movq 0x20(%rsp), %rax
cmpq 0x30(%rsp), %rax
jb 0x2f11d
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
movq %rbp, %rdx
callq 0x30b93
testl %eax, %eax
jne 0x2f155
decq %r14
jne 0x2f104
movzbl %bl, %eax
incb %bl
movq %rbp, 0xa0(%rsp,%rax,8)
addl %r12d, %r12d
movzbl %r12b, %r12d
cmpl 0x4(%rsp), %r12d
jb 0x2f0cf
movzbl %bl, %edx
leaq 0xa0(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x312ea
testl %eax, %eax
je 0x2f1fd
movl %eax, %r13d
movq 0x8(%rsp), %r12
movl (%rsp), %r14d
testb %r14b, %r14b
jne 0x2f196
movzbl 0x4(%rsp), %eax
cmpl $0x1, %eax
adcl $0x0, %eax
shlq $0x3, %rax
leaq (%rax,%rax,8), %rbx
xorl %r14d, %r14d
leaq (%r15,%r14), %rdi
callq 0x2dd36
addq $0x48, %r14
cmpq %r14, %rbx
jne 0x2f17c
movq %r15, %rdi
callq 0xf030
leaq 0x70(%rsp), %rdi
callq 0x2590b
leaq 0x88(%rsp), %rdi
callq 0x2590b
testl %r13d, %r13d
je 0x2f1bc
movq %r12, %rdi
callq 0x2dd36
jmp 0x2f1bf
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x1a8, %rsp # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbp, %rdi
movq %r14, %rsi
movl 0x28(%rsp), %edx
callq 0x30b1b
testl %eax, %eax
movq %r14, %r12
jne 0x2f1f5
movq %rbp, %rdi
movq %r12, %rsi
callq 0x2fae8
movl %eax, %r13d
jmp 0x2f15d
leaq -0x48(%r15), %rax
movq %rax, 0x38(%rsp)
movb $0x1, %al
xorl %ecx, %ecx
movl (%rsp), %r14d
movzbl %al, %ebx
testb %bl, %bl
movq %rbx, 0x40(%rsp)
je 0x2f281
leal (,%rbx,8), %eax
leaq (%rax,%rax,8), %rdx
leaq (%r15,%rdx), %rax
movq %rax, 0x48(%rsp)
movq 0x38(%rsp), %rax
addq %rax, %rdx
leaq (%rbx,%rbx,8), %rbp
shll $0x4, %ebp
addq %rax, %rbp
movl %ecx, 0x20(%rsp)
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
movq %rdx, %r12
movq 0x48(%rsp), %rcx
callq 0x2f48c
testl %eax, %eax
jne 0x2f2a7
decq %rbx
movl 0x20(%rsp), %ecx
movzbl %cl, %eax
incb %cl
movq %rbp, 0xa0(%rsp,%rax,8)
movq %r12, %rdx
addq $-0x48, %rdx
addq $-0x48, %rbp
testq %rbx, %rbx
jne 0x2f240
movq 0x40(%rsp), %rax
addl %eax, %eax
cmpb 0x4(%rsp), %al
jb 0x2f20e
movzbl %cl, %edx
leaq 0xa0(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x312ea
testl %eax, %eax
je 0x2f2b4
movl %eax, %r13d
movq 0x8(%rsp), %r12
jmp 0x2f161
testb %r14b, %r14b
je 0x2f2d1
movq 0x10(%rsp), %rax
movq %r15, 0xe8(%rax)
movq 0x50(%rsp), %rcx
movq %rcx, 0xf0(%rax)
movq 0x8(%rsp), %r12
movl (%rsp), %r14d
movl 0x4(%rsp), %r13d
movq 0x18(%rsp), %rbx
jmp 0x2ef9c
| /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 ) / 8;
#if defined(ECP_MONTGOMERY)
if( ecp_get_type( grp ) == ECP_TYPE_MONTGOMERY )
{
/* [M225] page 5 */
size_t b;
do {
MBEDTLS_MPI_CHK( mbedtls_mpi_fill_random( d, n_size, f_rng, p_rng ) );
} while( mbedtls_mpi_bitlen( d ) == 0);
/* Make sure the most significant bit is nbits */
b = mbedtls_mpi_bitlen( d ) - 1; /* mbedtls_mpi_bitlen is one-based */
if( b > grp->nbits )
MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( d, b - grp->nbits ) );
else
MBEDTLS_MPI_CHK( mbedtls_mpi_set_bit( d, grp->nbits, 1 ) );
/* Make sure the last three bits are unset */
MBEDTLS_MPI_CHK( mbedtls_mpi_set_bit( d, 0, 0 ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_set_bit( d, 1, 0 ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_set_bit( d, 2, 0 ) );
}
else
#endif /* ECP_MONTGOMERY */
#if defined(ECP_SHORTWEIERSTRASS)
if( ecp_get_type( grp ) == ECP_TYPE_SHORT_WEIERSTRASS )
{
/* SEC1 3.2.1: Generate d such that 1 <= n < N */
int count = 0;
unsigned char rnd[MBEDTLS_ECP_MAX_BYTES];
/*
* Match the procedure given in RFC 6979 (deterministic ECDSA):
* - use the same byte ordering;
* - keep the leftmost nbits bits of the generated octet string;
* - try until result is in the desired range.
* This also avoids any biais, which is especially important for ECDSA.
*/
do
{
MBEDTLS_MPI_CHK( f_rng( p_rng, rnd, n_size ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_read_binary( d, rnd, n_size ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( d, 8 * n_size - grp->nbits ) );
/*
* Each try has at worst a probability 1/2 of failing (the msb has
* a probability 1/2 of being 0, and then the result will be < N),
* so after 30 tries failure probability is a most 2**(-30).
*
* For most curves, 1 try is enough with overwhelming probability,
* since N starts with a lot of 1s in binary, but some curves
* such as secp224k1 are actually very close to the worst case.
*/
if( ++count > 30 )
return( MBEDTLS_ERR_ECP_RANDOM_FAILED );
}
while( mbedtls_mpi_cmp_int( d, 1 ) < 0 ||
mbedtls_mpi_cmp_mpi( d, &grp->N ) >= 0 );
}
else
#endif /* ECP_SHORTWEIERSTRASS */
return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
cleanup:
if( ret != 0 )
return( ret );
return( mbedtls_ecp_mul( grp, Q, d, G, f_rng, p_rng ) );
} | 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 0x2fd3f
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq *%r14
testl %eax, %eax
jne 0x2fdfa
movq %rbx, 0x10(%rsp)
movq %rbp, 0x18(%rsp)
andq $-0x8, %r13
movq 0x8(%rsp), %rax
addq $0x98, %rax
movq %rax, 0x28(%rsp)
movl $0x1f, %ebp
leaq 0x30(%rsp), %rsi
movq %r12, %rdi
movq %rsi, %rbx
movq %r15, %rdx
callq 0x26657
testl %eax, %eax
jne 0x2fdfa
movq %r13, %rsi
movq 0x8(%rsp), %rax
subq 0xb8(%rax), %rsi
movq %r12, %rdi
callq 0x268af
testl %eax, %eax
jne 0x2fdfa
decl %ebp
je 0x2fdce
movl $0x1, %esi
movq %r12, %rdi
callq 0x26ad2
testl %eax, %eax
js 0x2fd18
movq %r12, %rdi
movq 0x28(%rsp), %rsi
callq 0x26a39
testl %eax, %eax
js 0x2fdd5
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq *%r14
movq %rbx, %rsi
testl %eax, %eax
je 0x2fcb5
jmp 0x2fdfa
movq %r12, %rdi
callq 0x25d9f
testq %rax, %rax
jne 0x2fd5f
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2887e
testl %eax, %eax
je 0x2fd32
jmp 0x2fdfa
movl $0xffffb080, %eax # imm = 0xFFFFB080
retq
movq %r12, %rdi
callq 0x25d9f
decq %rax
movq 0x8(%rsp), %rcx
movq 0xb8(%rcx), %rsi
movq %r12, %rdi
subq %rsi, %rax
jbe 0x2fd88
movq %rax, %rsi
callq 0x268af
jmp 0x2fd92
movl $0x1, %edx
callq 0x25ceb
testl %eax, %eax
jne 0x2fdfa
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x25ceb
testl %eax, %eax
jne 0x2fdfa
movl $0x1, %esi
movq %r12, %rdi
xorl %edx, %edx
callq 0x25ceb
testl %eax, %eax
jne 0x2fdfa
movl $0x2, %esi
movq %r12, %rdi
xorl %edx, %edx
callq 0x25ceb
testl %eax, %eax
jne 0x2fdfa
jmp 0x2fddf
movl $0xffffb300, %eax # imm = 0xFFFFB300
jmp 0x2fdfa
movq 0x18(%rsp), %rbp
movq 0x10(%rsp), %rbx
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %r12, %rdx
movq %rbp, %rcx
movq %r14, %r8
movq %rbx, %r9
callq 0x2e247
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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; j < w; j++ )
x[i] |= mbedtls_mpi_get_bit( m, i + d * j ) << j;
/* Now make sure x_1 .. x_d are odd */
c = 0;
for( i = 1; i <= d; i++ )
{
/* Add carry and update it */
cc = x[i] & c;
x[i] = x[i] ^ c;
c = cc;
/* Adjust if needed, avoiding branches */
adjust = 1 - ( x[i] & 0x01 );
c |= x[i] & ( x[i-1] * adjust );
x[i] = x[i] ^ ( x[i-1] * adjust );
x[i-1] |= adjust << 7;
}
} | 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)
testb %bpl, %bpl
je 0x30761
movq %rbx, %r12
xorl %r13d, %r13d
movq %r15, %rdi
movq %r12, %rsi
movq %r15, %rbp
movq %r14, %r15
movq %r10, %r14
callq 0x25cc3
movq %r14, %r10
movq %r15, %r14
movq %rbp, %r15
movl %r13d, %ecx
shll %cl, %eax
orb %al, (%r14,%rbx)
movq 0x10(%rsp), %rax
incq %r13
addq %r10, %r12
cmpq %r13, %rax
jne 0x3072b
incq %rbx
cmpq %r10, %rbx
movl 0xc(%rsp), %ebp
jne 0x30720
movb (%r14), %dl
xorl %ecx, %ecx
xorl %esi, %esi
movb 0x1(%r14,%rcx), %dil
movl %edi, %r8d
andb %sil, %r8b
xorb %sil, %dil
movl %edi, %r9d
notb %r9b
movl %r9d, %eax
andb $0x1, %al
mulb %dl
movl %eax, %esi
andb %dil, %sil
orb %r8b, %sil
xorb %al, %dil
movb %dil, 0x1(%r14,%rcx)
shlb $0x7, %r9b
orb %dl, %r9b
movb %r9b, (%r14,%rcx)
incq %rcx
movl %edi, %edx
cmpq %rcx, %r10
jne 0x30774
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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( mbedtls_mpi ) ) ) == NULL )
return( MBEDTLS_ERR_ECP_ALLOC_FAILED );
mbedtls_mpi_init( &u ); mbedtls_mpi_init( &Zi ); mbedtls_mpi_init( &ZZi );
/*
* c[i] = Z_0 * ... * Z_i
*/
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &c[0], &T[0]->Z ) );
for( i = 1; i < t_len; i++ )
{
MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &c[i], &c[i-1], &T[i]->Z ) );
MOD_MUL( c[i] );
}
/*
* u = 1 / (Z_0 * ... * Z_n) mod P
*/
MBEDTLS_MPI_CHK( mbedtls_mpi_inv_mod( &u, &c[t_len-1], &grp->P ) );
for( i = t_len - 1; ; i-- )
{
/*
* Zi = 1 / Z_i mod p
* u = 1 / (Z_0 * ... * Z_i) mod P
*/
if( i == 0 ) {
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &Zi, &u ) );
}
else
{
MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &Zi, &u, &c[i-1] ) ); MOD_MUL( Zi );
MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &u, &u, &T[i]->Z ) ); MOD_MUL( u );
}
/*
* proceed as in normalize()
*/
MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &ZZi, &Zi, &Zi ) ); MOD_MUL( ZZi );
MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T[i]->X, &T[i]->X, &ZZi ) ); MOD_MUL( T[i]->X );
MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T[i]->Y, &T[i]->Y, &ZZi ) ); MOD_MUL( T[i]->Y );
MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T[i]->Y, &T[i]->Y, &Zi ) ); MOD_MUL( T[i]->Y );
/*
* Post-precessing: reclaim some memory by shrinking coordinates
* - not storing Z (always 1)
* - shrinking other coordinates, but still keeping the same number of
* limbs as P, as otherwise it will too likely be regrown too fast.
*/
MBEDTLS_MPI_CHK( mbedtls_mpi_shrink( &T[i]->X, grp->P.n ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_shrink( &T[i]->Y, grp->P.n ) );
mbedtls_mpi_free( &T[i]->Z );
if( i == 0 )
break;
}
cleanup:
mbedtls_mpi_free( &u ); mbedtls_mpi_free( &Zi ); mbedtls_mpi_free( &ZZi );
for( i = 0; i < t_len; i++ )
mbedtls_mpi_free( &c[i] );
mbedtls_free( c );
return( ret );
} | 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 0xf1d0
testq %rax, %rax
je 0x3136f
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x258f8
leaq 0x20(%rsp), %rdi
callq 0x258f8
leaq 0x50(%rsp), %rdi
callq 0x258f8
movq (%r12), %rsi
addq $0x30, %rsi
movq %r14, %rdi
callq 0x25a94
testl %eax, %eax
je 0x31379
movl %eax, %ebp
jmp 0x315e0
movl $0xffffb280, %ebp # imm = 0xFFFFB280
jmp 0x3161a
movq %r14, %r13
movl $0x1, %r14d
movq %r13, 0x8(%rsp)
movq %r13, %rsi
addq $0x18, %r13
movq (%r12,%r14,8), %rdx
addq $0x30, %rdx
movq %r13, %rdi
callq 0x26e2d
testl %eax, %eax
jne 0x315d9
movq %r13, %rdi
movq %r15, %rsi
callq 0x30600
testl %eax, %eax
jne 0x315d9
incq 0x41270(%rip) # 0x72630
incq %r14
cmpq %r14, %rbx
jne 0x31387
leaq (%rbx,%rbx,2), %r13
movq 0x8(%rsp), %r14
leaq (%r14,%r13,8), %rsi
addq $-0x18, %rsi
leaq 0x8(%r15), %rdx
leaq 0x38(%rsp), %rdi
callq 0x288c8
testl %eax, %eax
jne 0x31368
leaq (%r14,%r13,8), %rdx
addq $-0x30, %rdx
leaq 0x20(%rsp), %r13
movq %rbx, %rax
movq %rax, 0x10(%rsp)
cmpq $0x1, %rax
movq %rdx, 0x18(%rsp)
movq %r13, %rdi
leaq 0x38(%rsp), %rsi
jne 0x31425
callq 0x25a94
testl %eax, %eax
je 0x31491
jmp 0x31368
callq 0x26e2d
testl %eax, %eax
jne 0x31368
movq %r13, %rdi
movq %r15, %rsi
callq 0x30600
testl %eax, %eax
jne 0x31368
incq 0x411e4(%rip) # 0x72630
movq 0x10(%rsp), %rax
movq -0x8(%r12,%rax,8), %rdx
addq $0x30, %rdx
leaq 0x38(%rsp), %r13
movq %r13, %rdi
movq %r13, %rsi
callq 0x26e2d
testl %eax, %eax
jne 0x31368
movq %r13, %rdi
movq %r15, %rsi
callq 0x30600
testl %eax, %eax
jne 0x31368
incq 0x411a4(%rip) # 0x72630
leaq 0x20(%rsp), %r13
leaq 0x50(%rsp), %rdi
movq %r13, %rsi
movq %r13, %rdx
callq 0x26e2d
testl %eax, %eax
jne 0x31368
leaq 0x50(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x30600
testl %eax, %eax
jne 0x31368
movq %r13, %rdx
incq 0x41165(%rip) # 0x72630
movq 0x10(%rsp), %r13
movq -0x8(%r12,%r13,8), %rdi
movq %rdi, %rsi
callq 0x26e2d
testl %eax, %eax
jne 0x31368
movq -0x8(%r12,%r13,8), %rdi
movq %r15, %rsi
callq 0x30600
testl %eax, %eax
jne 0x31368
incq 0x4112f(%rip) # 0x72630
movq -0x8(%r12,%r13,8), %rdi
addq $0x18, %rdi
movq %rdi, %rsi
leaq 0x50(%rsp), %rdx
callq 0x26e2d
testl %eax, %eax
jne 0x31368
movq -0x8(%r12,%r13,8), %rdi
addq $0x18, %rdi
movq %r15, %rsi
callq 0x30600
testl %eax, %eax
jne 0x31368
incq 0x410f1(%rip) # 0x72630
movq -0x8(%r12,%r13,8), %rdi
addq $0x18, %rdi
movq %rdi, %rsi
leaq 0x20(%rsp), %rdx
callq 0x26e2d
testl %eax, %eax
jne 0x31368
movq -0x8(%r12,%r13,8), %rdi
addq $0x18, %rdi
movq %r15, %rsi
callq 0x30600
testl %eax, %eax
jne 0x31368
incq 0x410b3(%rip) # 0x72630
movq -0x8(%r12,%r13,8), %rdi
movq 0x10(%r15), %rsi
callq 0x259df
testl %eax, %eax
jne 0x31368
movq -0x8(%r12,%r13,8), %rdi
addq $0x18, %rdi
movq 0x10(%r15), %rsi
callq 0x259df
testl %eax, %eax
jne 0x31368
movq -0x8(%r12,%r13,8), %rdi
addq $0x30, %rdi
callq 0x2590b
movq 0x18(%rsp), %rdx
addq $-0x18, %rdx
xorl %ebp, %ebp
decq %r13
movq %r13, %rax
leaq 0x20(%rsp), %r13
jne 0x313ff
jmp 0x315e0
movl %eax, %ebp
movq 0x8(%rsp), %r14
leaq 0x38(%rsp), %rdi
callq 0x2590b
leaq 0x20(%rsp), %rdi
callq 0x2590b
leaq 0x50(%rsp), %rdi
callq 0x2590b
movq %r14, %r15
movq %r15, %rdi
callq 0x2590b
addq $0x18, %r15
decq %rbx
jne 0x31601
movq %r14, %rdi
callq 0xf030
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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 ) );
#endif /* MBEDTLS_ECP_DP_SECP192R1_ENABLED */
#if defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED)
case MBEDTLS_ECP_DP_SECP224R1:
NIST_MODP( p224 );
return( LOAD_GROUP( secp224r1 ) );
#endif /* MBEDTLS_ECP_DP_SECP224R1_ENABLED */
#if defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
case MBEDTLS_ECP_DP_SECP256R1:
NIST_MODP( p256 );
return( LOAD_GROUP( secp256r1 ) );
#endif /* MBEDTLS_ECP_DP_SECP256R1_ENABLED */
#if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
case MBEDTLS_ECP_DP_SECP384R1:
NIST_MODP( p384 );
return( LOAD_GROUP( secp384r1 ) );
#endif /* MBEDTLS_ECP_DP_SECP384R1_ENABLED */
#if defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED)
case MBEDTLS_ECP_DP_SECP521R1:
NIST_MODP( p521 );
return( LOAD_GROUP( secp521r1 ) );
#endif /* MBEDTLS_ECP_DP_SECP521R1_ENABLED */
#if defined(MBEDTLS_ECP_DP_SECP192K1_ENABLED)
case MBEDTLS_ECP_DP_SECP192K1:
grp->modp = ecp_mod_p192k1;
return( LOAD_GROUP_A( secp192k1 ) );
#endif /* MBEDTLS_ECP_DP_SECP192K1_ENABLED */
#if defined(MBEDTLS_ECP_DP_SECP224K1_ENABLED)
case MBEDTLS_ECP_DP_SECP224K1:
grp->modp = ecp_mod_p224k1;
return( LOAD_GROUP_A( secp224k1 ) );
#endif /* MBEDTLS_ECP_DP_SECP224K1_ENABLED */
#if defined(MBEDTLS_ECP_DP_SECP256K1_ENABLED)
case MBEDTLS_ECP_DP_SECP256K1:
grp->modp = ecp_mod_p256k1;
return( LOAD_GROUP_A( secp256k1 ) );
#endif /* MBEDTLS_ECP_DP_SECP256K1_ENABLED */
#if defined(MBEDTLS_ECP_DP_BP256R1_ENABLED)
case MBEDTLS_ECP_DP_BP256R1:
return( LOAD_GROUP_A( brainpoolP256r1 ) );
#endif /* MBEDTLS_ECP_DP_BP256R1_ENABLED */
#if defined(MBEDTLS_ECP_DP_BP384R1_ENABLED)
case MBEDTLS_ECP_DP_BP384R1:
return( LOAD_GROUP_A( brainpoolP384r1 ) );
#endif /* MBEDTLS_ECP_DP_BP384R1_ENABLED */
#if defined(MBEDTLS_ECP_DP_BP512R1_ENABLED)
case MBEDTLS_ECP_DP_BP512R1:
return( LOAD_GROUP_A( brainpoolP512r1 ) );
#endif /* MBEDTLS_ECP_DP_BP512R1_ENABLED */
#if defined(MBEDTLS_ECP_DP_CURVE25519_ENABLED)
case MBEDTLS_ECP_DP_CURVE25519:
grp->modp = ecp_mod_p255;
return( ecp_use_curve25519( grp ) );
#endif /* MBEDTLS_ECP_DP_CURVE25519_ENABLED */
default:
mbedtls_ecp_group_free( grp );
return( MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE );
}
} | 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, %eax
leaq 0x25d2a(%rip), %r10 # 0x57450
leaq 0x25d03(%rip), %r11 # 0x57430
leaq 0x25cdc(%rip), %r15 # 0x57410
leaq 0x25c95(%rip), %rsi # 0x573d0
leaq 0x25cae(%rip), %r9 # 0x573f0
xorl %r14d, %r14d
movl $0x18, %edx
jmp 0x31932
leaq 0x11d7(%rip), %rax # 0x3292d
movq %rax, 0xc8(%rbx)
subq $0x8, %rsp
movl $0x20, %eax
leaq 0x26253(%rip), %r10 # 0x579c0
leaq 0x2622c(%rip), %r11 # 0x579a0
leaq 0x26205(%rip), %r14 # 0x57980
leaq 0x261ce(%rip), %rsi # 0x57950
leaq 0x261e7(%rip), %rcx # 0x57970
leaq 0x261e8(%rip), %r9 # 0x57978
jmp 0x31a20
leaq 0x10b0(%rip), %rax # 0x3284c
movq %rax, 0xc8(%rbx)
subq $0x8, %rsp
movl $0x48, %eax
leaq 0x2602d(%rip), %r10 # 0x577e0
leaq 0x25fd6(%rip), %r11 # 0x57790
leaq 0x25f7f(%rip), %r15 # 0x57740
leaq 0x25ed8(%rip), %rsi # 0x576a0
leaq 0x25f21(%rip), %r9 # 0x576f0
xorl %r14d, %r14d
movl $0x48, %edx
jmp 0x31932
leaq 0x110f(%rip), %rax # 0x328f2
movq %rax, 0xc8(%rbx)
subq $0x8, %rsp
movl $0x18, %eax
leaq 0x260a6(%rip), %r10 # 0x578a0
leaq 0x2607f(%rip), %r11 # 0x57880
leaq 0x26058(%rip), %r14 # 0x57860
leaq 0x26021(%rip), %rsi # 0x57830
leaq 0x26032(%rip), %rcx # 0x57848
leaq 0x26033(%rip), %r9 # 0x57850
movl $0x18, %edx
jmp 0x31a25
leaq 0x775(%rip), %rax # 0x31fa3
movq %rax, 0xc8(%rbx)
subq $0x8, %rsp
movl $0x20, %eax
leaq 0x25d4b(%rip), %r10 # 0x57590
leaq 0x25d24(%rip), %r11 # 0x57570
leaq 0x25cfd(%rip), %r15 # 0x57550
leaq 0x25cb6(%rip), %rsi # 0x57510
leaq 0x25ccf(%rip), %r9 # 0x57530
jmp 0x3192a
leaq 0xb13(%rip), %rax # 0x32380
movq %rax, 0xc8(%rbx)
subq $0x8, %rsp
movl $0x30, %eax
leaq 0x25dec(%rip), %r10 # 0x57670
leaq 0x25db5(%rip), %r11 # 0x57640
leaq 0x25d7e(%rip), %r15 # 0x57610
leaq 0x25d17(%rip), %rsi # 0x575b0
leaq 0x25d40(%rip), %r9 # 0x575e0
xorl %r14d, %r14d
movl $0x30, %edx
jmp 0x31932
subq $0x8, %rsp
movl $0x40, %eax
leaq 0x26443(%rip), %r10 # 0x57d00
leaq 0x263fc(%rip), %r11 # 0x57cc0
leaq 0x263b5(%rip), %r14 # 0x57c80
leaq 0x262ee(%rip), %rsi # 0x57bc0
leaq 0x26327(%rip), %rcx # 0x57c00
leaq 0x26360(%rip), %r9 # 0x57c40
movl $0x40, %edx
movl $0x40, %r8d
jmp 0x319d0
leaq 0x3f8(%rip), %rax # 0x31cef
movq %rax, 0xc8(%rbx)
subq $0x8, %rsp
movl $0x20, %eax
leaq 0x25be2(%rip), %r10 # 0x574f0
leaq 0x25bbb(%rip), %r11 # 0x574d0
leaq 0x25b94(%rip), %r15 # 0x574b0
leaq 0x25b4d(%rip), %rsi # 0x57470
leaq 0x25b66(%rip), %r9 # 0x57490
xorl %r14d, %r14d
movl $0x20, %edx
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
pushq %rax
pushq %r10
pushq %rax
pushq %r11
pushq %rax
pushq %r15
pushq %rax
callq 0x31bef
addq $0x40, %rsp
jmp 0x31a45
subq $0x8, %rsp
movl $0x20, %eax
leaq 0x2611e(%rip), %r10 # 0x57a80
leaq 0x260f7(%rip), %r11 # 0x57a60
leaq 0x260d0(%rip), %r14 # 0x57a40
leaq 0x26069(%rip), %rsi # 0x579e0
leaq 0x26082(%rip), %rcx # 0x57a00
leaq 0x2609b(%rip), %r9 # 0x57a20
movl $0x20, %edx
movl $0x20, %r8d
jmp 0x319d0
subq $0x8, %rsp
movl $0x30, %eax
leaq 0x261ee(%rip), %r10 # 0x57b90
leaq 0x261b7(%rip), %r11 # 0x57b60
leaq 0x26180(%rip), %r14 # 0x57b30
leaq 0x260e9(%rip), %rsi # 0x57aa0
leaq 0x26112(%rip), %rcx # 0x57ad0
leaq 0x2613b(%rip), %r9 # 0x57b00
movl $0x30, %edx
movl $0x30, %r8d
movq %rbx, %rdi
pushq %rax
pushq %r10
pushq %rax
pushq %r11
pushq %rax
pushq %r14
pushq %rax
jmp 0x31a39
leaq 0xf25(%rip), %rax # 0x3290b
movq %rax, 0xc8(%rbx)
subq $0x8, %rsp
movl $0x20, %eax
leaq 0x25f33(%rip), %r10 # 0x57930
leaq 0x25f0c(%rip), %r11 # 0x57910
leaq 0x25ee5(%rip), %r14 # 0x578f0
leaq 0x25eae(%rip), %rsi # 0x578c0
leaq 0x25ec7(%rip), %rcx # 0x578e0
leaq 0x25ec8(%rip), %r9 # 0x578e8
movl $0x20, %edx
movl $0x8, %r8d
movq %rbx, %rdi
pushq %rax
pushq %r10
pushq %rax
pushq %r11
pushq %rax
pushq %r14
pushq $0x8
callq 0x31bef
addq $0x40, %rsp
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xef1(%rip), %rax # 0x32946
movq %rax, 0xc8(%rbx)
leaq 0x20(%rbx), %rdi
leaq 0x262d9(%rip), %rdx # 0x57d40
movl $0x10, %esi
callq 0x25e23
testl %eax, %eax
jne 0x31ae5
leaq 0x8(%rbx), %r15
movl $0x1, %esi
movq %r15, %rdi
callq 0x25c74
testl %eax, %eax
jne 0x31ae5
movl $0xff, %esi
movq %r15, %rdi
callq 0x267c5
testl %eax, %eax
jne 0x31ae5
movl $0x13, %edx
movq %r15, %rdi
movq %r15, %rsi
callq 0x261b5
testl %eax, %eax
jne 0x31ae5
movq %r15, %rdi
callq 0x25d9f
movq %rax, 0xb0(%rbx)
leaq 0x50(%rbx), %rdi
movl $0x9, %esi
callq 0x25c74
testl %eax, %eax
jne 0x31ae5
leaq 0x80(%rbx), %rdi
movl $0x1, %esi
callq 0x25c74
testl %eax, %eax
je 0x31b08
movl %eax, %r14d
movq %rbx, %rdi
callq 0x2dd5b
jmp 0x31a45
movq %rbx, %rdi
callq 0x2dd5b
movl $0xffffb180, %r14d # imm = 0xFFFFB180
jmp 0x31a45
leaq 0x68(%rbx), %rdi
callq 0x2590b
movq $0xfe, 0xb8(%rbx)
jmp 0x31a42
| /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 gxlen,
const mbedtls_mpi_uint *gy, size_t gylen,
const mbedtls_mpi_uint *n, size_t nlen)
{
ecp_mpi_load( &grp->P, p, plen );
if( a != NULL )
ecp_mpi_load( &grp->A, a, alen );
ecp_mpi_load( &grp->B, b, blen );
ecp_mpi_load( &grp->N, n, nlen );
ecp_mpi_load( &grp->G.X, gx, gxlen );
ecp_mpi_load( &grp->G.Y, gy, gylen );
ecp_mpi_set1( &grp->G.Z );
grp->pbits = mbedtls_mpi_bitlen( &grp->P );
grp->nbits = mbedtls_mpi_bitlen( &grp->N );
grp->h = 1;
return( 0 );
} | 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)
movq %rsi, 0x18(%rbx)
testq %rcx, %rcx
je 0x31c4f
movl $0x1, 0x20(%rbx)
shrq $0x3, %r8
movq %r8, 0x28(%rbx)
movq %rcx, 0x30(%rbx)
movl $0x1, %ebp
movl %ebp, 0x38(%rbx)
shrq $0x3, %r14
movq %r14, 0x40(%rbx)
movq %r9, 0x48(%rbx)
leaq 0x98(%rbx), %r14
movl %ebp, 0x98(%rbx)
shrq $0x3, %r13
movq %r13, 0xa0(%rbx)
movq %r12, 0xa8(%rbx)
movl %ebp, 0x50(%rbx)
shrq $0x3, %r15
movq %r15, 0x58(%rbx)
movq %r11, 0x60(%rbx)
movl %ebp, 0x68(%rbx)
shrq $0x3, %r10
movq %r10, 0x70(%rbx)
movq %rax, 0x78(%rbx)
movl %ebp, 0x80(%rbx)
movq $0x1, 0x88(%rbx)
leaq 0x405c8(%rip), %rax # 0x72280
movq %rax, 0x90(%rbx)
callq 0x25d9f
movq %rax, 0xb0(%rbx)
movq %r14, %rdi
callq 0x25d9f
movq %rax, 0xb8(%rbx)
movl %ebp, 0xc0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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 )
return( 0 );
/* Init R */
R.s = 1;
R.p = Rp;
R.n = P_KOBLITZ_R;
/* Common setup for M */
M.s = 1;
M.p = Mp;
/* M = A1 */
M.n = N->n - ( p_limbs - adjust );
if( M.n > p_limbs + adjust )
M.n = p_limbs + adjust;
memset( Mp, 0, sizeof Mp );
memcpy( Mp, N->p + p_limbs - adjust, M.n * sizeof( mbedtls_mpi_uint ) );
if( shift != 0 )
MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &M, shift ) );
M.n += R.n; /* Make room for multiplication by R */
/* N = A0 */
if( mask != 0 )
N->p[p_limbs - 1] &= mask;
for( i = p_limbs; i < N->n; i++ )
N->p[i] = 0;
/* N = A0 + R * A1 */
MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &M, &M, &R ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_add_abs( N, N, &M ) );
/* Second pass */
/* M = A1 */
M.n = N->n - ( p_limbs - adjust );
if( M.n > p_limbs + adjust )
M.n = p_limbs + adjust;
memset( Mp, 0, sizeof Mp );
memcpy( Mp, N->p + p_limbs - adjust, M.n * sizeof( mbedtls_mpi_uint ) );
if( shift != 0 )
MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &M, shift ) );
M.n += R.n; /* Make room for multiplication by R */
/* N = A0 */
if( mask != 0 )
N->p[p_limbs - 1] &= mask;
for( i = p_limbs; i < N->n; i++ )
N->p[i] = 0;
/* N = A0 + R * A1 */
MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &M, &M, &R ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_add_abs( N, N, &M ) );
cleanup:
return( ret );
} | 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)
leaq 0x50(%rsp), %rdi
movq %rdx, %rbp
subq %rcx, %rbp
subq %rbp, %r12
leaq (%rcx,%rdx), %r15
cmpq %r15, %r12
cmovaeq %r15, %r12
movq %rdi, 0x18(%rsp)
movq %r12, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, 0x20(%rdi)
leaq (,%rdx,8), %rax
movq 0x10(%rbx), %rsi
movq %rax, 0x30(%rsp)
addq %rax, %rsi
leaq (,%rcx,8), %rax
subq %rax, %rsi
leaq (,%r12,8), %rdx
movq %r8, 0x28(%rsp)
callq 0xf240
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x32ae8
leaq 0x8(%rsp), %rdi
callq 0x268af
testl %eax, %eax
jne 0x32b4b
movq 0x10(%rsp), %r12
incq %r12
movq %r12, 0x10(%rsp)
movq 0x20(%rsp), %rcx
testq %rcx, %rcx
je 0x32b03
movq 0x10(%rbx), %rax
andq %rcx, -0x8(%rax,%r14,8)
cmpq %r14, 0x8(%rbx)
jbe 0x32b21
movq 0x10(%rbx), %rax
movq %r14, %rcx
movq $0x0, (%rax,%rcx,8)
incq %rcx
cmpq 0x8(%rbx), %rcx
jb 0x32b10
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rdx
movq %rdi, %rsi
callq 0x26e2d
testl %eax, %eax
jne 0x32b4b
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x26b0f
testl %eax, %eax
je 0x32b5d
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
negq %r13
movq 0x8(%rbx), %r12
subq %rbp, %r12
cmpq %r15, %r12
cmovaeq %r15, %r12
movq %r12, 0x10(%rsp)
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %rdi
movaps %xmm0, (%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, 0x20(%rdi)
movq 0x30(%rsp), %rax
addq 0x10(%rbx), %rax
leaq (%rax,%r13,8), %rsi
leaq (,%r12,8), %rdx
callq 0xf240
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x32bbd
leaq 0x8(%rsp), %rdi
callq 0x268af
testl %eax, %eax
jne 0x32b4b
movq 0x10(%rsp), %r12
addq 0x40(%rsp), %r12
movq %r12, 0x10(%rsp)
movq 0x20(%rsp), %rcx
testq %rcx, %rcx
je 0x32bda
movq 0x10(%rbx), %rax
andq %rcx, -0x8(%rax,%r14,8)
cmpq %r14, 0x8(%rbx)
jbe 0x32bf5
movq 0x10(%rbx), %rax
movq $0x0, (%rax,%r14,8)
incq %r14
cmpq 0x8(%rbx), %r14
jb 0x32be4
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rdx
movq %rdi, %rsi
callq 0x26e2d
testl %eax, %eax
jne 0x32b4b
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x26b0f
jmp 0x32b4b
| /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 )
return( ret );
#endif
index = ctx->source_count;
if( index >= MBEDTLS_ENTROPY_MAX_SOURCES )
{
ret = MBEDTLS_ERR_ENTROPY_MAX_SOURCES;
goto exit;
}
ctx->source[index].f_source = f_source;
ctx->source[index].p_source = p_source;
ctx->source[index].threshold = threshold;
ctx->source[index].strong = strong;
ctx->source_count++;
exit:
#if defined(MBEDTLS_THREADING_C)
if( mbedtls_mutex_unlock( &ctx->mutex ) != 0 )
return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
#endif
return( ret );
} | 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_FAILED );
#if defined(MBEDTLS_ENTROPY_NV_SEED)
/* Update the NV entropy seed before generating any entropy for outside
* use.
*/
if( ctx->initial_entropy_run == 0 )
{
ctx->initial_entropy_run = 1;
if( ( ret = mbedtls_entropy_update_nv_seed( ctx ) ) != 0 )
return( ret );
}
#endif
#if defined(MBEDTLS_THREADING_C)
if( ( ret = mbedtls_mutex_lock( &ctx->mutex ) ) != 0 )
return( ret );
#endif
/*
* Always gather extra entropy before a call
*/
do
{
if( count++ > ENTROPY_MAX_LOOP )
{
ret = MBEDTLS_ERR_ENTROPY_SOURCE_FAILED;
goto exit;
}
if( ( ret = entropy_gather_internal( ctx ) ) != 0 )
goto exit;
done = 1;
for( i = 0; i < ctx->source_count; i++ )
if( ctx->source[i].size < ctx->source[i].threshold )
done = 0;
}
while( ! done );
memset( buf, 0, MBEDTLS_ENTROPY_BLOCK_SIZE );
#if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR)
mbedtls_sha512_finish( &ctx->accumulator, buf );
/*
* Reset accumulator and counters and recycle existing entropy
*/
memset( &ctx->accumulator, 0, sizeof( mbedtls_sha512_context ) );
mbedtls_sha512_starts( &ctx->accumulator, 0 );
mbedtls_sha512_update( &ctx->accumulator, buf, MBEDTLS_ENTROPY_BLOCK_SIZE );
/*
* Perform second SHA-512 on entropy
*/
mbedtls_sha512( buf, MBEDTLS_ENTROPY_BLOCK_SIZE, buf, 0 );
#else /* MBEDTLS_ENTROPY_SHA512_ACCUMULATOR */
mbedtls_sha256_finish( &ctx->accumulator, buf );
/*
* Reset accumulator and counters and recycle existing entropy
*/
memset( &ctx->accumulator, 0, sizeof( mbedtls_sha256_context ) );
mbedtls_sha256_starts( &ctx->accumulator, 0 );
mbedtls_sha256_update( &ctx->accumulator, buf, MBEDTLS_ENTROPY_BLOCK_SIZE );
/*
* Perform second SHA-256 on entropy
*/
mbedtls_sha256( buf, MBEDTLS_ENTROPY_BLOCK_SIZE, buf, 0 );
#endif /* MBEDTLS_ENTROPY_SHA512_ACCUMULATOR */
for( i = 0; i < ctx->source_count; i++ )
ctx->source[i].size = 0;
memcpy( output, buf, len );
ret = 0;
exit:
#if defined(MBEDTLS_THREADING_C)
if( mbedtls_mutex_unlock( &ctx->mutex ) != 0 )
return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
#endif
return( ret );
} | 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 0x32da6
testl %eax, %eax
jne 0x33021
movslq 0xd8(%r15), %rax
testq %rax, %rax
jle 0x32ef7
incl %r13d
shlq $0x3, %rax
leaq (%rax,%rax,4), %rcx
movl $0x1, %eax
xorl %edx, %edx
movq 0xf0(%r15,%rdx), %rsi
cmpq 0xf8(%r15,%rdx), %rsi
cmovbl %r12d, %eax
addq $0x28, %rdx
cmpq %rdx, %rcx
jne 0x32ed6
testl %eax, %eax
je 0x32e9b
pxor %xmm0, %xmm0
movq %rsp, %r12
movdqa %xmm0, 0x30(%r12)
movdqa %xmm0, 0x20(%r12)
movdqa %xmm0, 0x10(%r12)
movdqa %xmm0, (%r12)
movq %r15, %rdi
movq %r12, %rsi
callq 0x4370d
xorl %ebp, %ebp
movl $0xd8, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0xf150
movq %r15, %rdi
xorl %esi, %esi
callq 0x43105
movl $0x40, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x4364b
movl $0x40, %esi
movq %r12, %rdi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x439c6
movslq 0xd8(%r15), %rax
testq %rax, %rax
jle 0x33011
leal 0x1(%rax), %ecx
decq %rax
movq %rax, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
shrl %ecx
shlq $0x4, %rcx
leaq (%rcx,%rcx,4), %rax
movdqa 0x24dbd(%rip), %xmm1 # 0x57d50
xorl %ecx, %ecx
movdqa 0x24dc3(%rip), %xmm2 # 0x57d60
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x24dc3(%rip), %xmm4 # 0x57d70
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7 # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5 # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %edx
notl %edx
testb $0x1, %dl
je 0x32fea
movq $0x0, 0xf0(%r15,%rcx)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %edx
testb $0x1, %dl
je 0x33004
movq $0x0, 0x118(%r15,%rcx)
paddq %xmm4, %xmm1
addq $0x50, %rcx
cmpq %rcx, %rax
jne 0x32fad
movq %rsp, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xf240
jmp 0x33023
movl %eax, %ebp
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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) ftell( f );
fseek( f, 0, SEEK_SET );
if( n > MBEDTLS_ENTROPY_MAX_SEED_SIZE )
n = MBEDTLS_ENTROPY_MAX_SEED_SIZE;
if( fread( buf, 1, n, f ) != n )
{
fclose( f );
return( MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR );
}
fclose( f );
mbedtls_entropy_update_manual( ctx, buf, n );
return( mbedtls_entropy_write_seed_file( ctx, path ) );
} | 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
xorl %esi, %esi
movl $0x2, %edx
callq 0xf2c0
movq %r15, %rdi
callq 0xf220
movq %rax, %r13
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xf2c0
movl $0x400, %r12d # imm = 0x400
cmpq %r12, %r13
cmovbq %r13, %r12
movq %rsp, %rdi
movl $0x1, %esi
movq %r12, %rdx
movq %r15, %rcx
callq 0xf080
movq %rax, %r13
movq %r15, %rdi
callq 0xf0d0
cmpq %r12, %r13
jne 0x33155
movq %rsp, %rdx
movq %r14, %rdi
movl $0x14, %esi
movq %r12, %rcx
callq 0x32d35
movq %r14, %rdi
movq %rbx, %rsi
callq 0x33034
movl %eax, %ebp
movl %ebp, %eax
addq $0x408, %rsp # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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_getrandom )
{
int ret;
if( ( ret = getrandom_wrapper( output, len, 0 ) ) < 0 )
return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
*olen = ret;
return( 0 );
}
#endif /* HAVE_GETRANDOM */
*olen = 0;
file = fopen( "/dev/urandom", "rb" );
if( file == NULL )
return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
read_len = fread( output, 1, len, file );
if( read_len != len )
{
fclose( file );
return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
}
fclose( file );
*olen = len;
return( 0 );
} | 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, %al
ja 0x3339a
cmpb $0x2e, 0x8d(%rsp)
jne 0x3339a
movl $0x1, %eax
cmpb $0x33, %cl
jne 0x3339c
movb 0x8e(%rsp), %al
leal -0x3a(%rax), %ecx
cmpb $-0xa, %cl
jae 0x33431
xorl %eax, %eax
movl %eax, 0x3eefe(%rip) # 0x722a0
testl %eax, %eax
je 0x333d0
movl $0x13e, %edi # imm = 0x13E
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0xf210
movq %rax, %r14
movl $0xffffffc4, %ebp # imm = 0xFFFFFFC4
testl %r14d, %r14d
js 0x3341f
andl $0x7fffffff, %r14d # imm = 0x7FFFFFFF
jmp 0x3341a
movq $0x0, (%rbx)
leaq 0x249b3(%rip), %rdi # 0x57d91
leaq 0x2308e(%rip), %rsi # 0x56473
callq 0xf2f0
movl $0xffffffc4, %ebp # imm = 0xFFFFFFC4
testq %rax, %rax
je 0x3341f
movq %rax, %r12
movl $0x1, %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
callq 0xf080
movq %rax, %r15
movq %r12, %rdi
callq 0xf0d0
cmpq %r14, %r15
jne 0x3341f
movq %r14, (%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x190, %rsp # imm = 0x190
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
addb $-0x30, %al
movzbl %al, %ecx
movzbl 0x8f(%rsp), %edx
leal -0x30(%rdx), %eax
cmpb $0x9, %al
ja 0x33450
leal (%rcx,%rcx,4), %eax
leal (%rdx,%rax,2), %ecx
addl $-0x30, %ecx
jmp 0x3345e
movl $0x0, %eax
cmpl $0x2e, %edx
jne 0x3339c
xorl %eax, %eax
cmpl $0x11, %ecx
setae %al
jmp 0x3339c
| /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, keybits, MBEDTLS_MODE_ECB );
if( cipher_info == NULL )
return( MBEDTLS_ERR_GCM_BAD_INPUT );
if( cipher_info->block_size != 16 )
return( MBEDTLS_ERR_GCM_BAD_INPUT );
mbedtls_cipher_free( &ctx->cipher_ctx );
if( ( ret = mbedtls_cipher_setup( &ctx->cipher_ctx, cipher_info ) ) != 0 )
return( ret );
if( ( ret = mbedtls_cipher_setkey( &ctx->cipher_ctx, key, keybits,
MBEDTLS_ENCRYPT ) ) != 0 )
{
return( ret );
}
if( ( ret = gcm_gen_table( ctx ) ) != 0 )
return( ret );
return( 0 );
} | 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 0x2a11c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2a149
testl %eax, %eax
jne 0x37ea5
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl $0x1, %ecx
callq 0x2a207
testl %eax, %eax
jne 0x37ea5
leaq 0x10(%rsp), %r8
movq $0x0, (%r8)
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movl $0x10, %edx
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x2a315
testl %eax, %eax
jne 0x37ea5
movq (%rsp), %r14
movq 0x8(%rsp), %r15
bswapq %r14
bswapq %r15
movq %r15, 0x98(%rbx)
movq %r14, 0x118(%rbx)
movl $0x2, %edi
callq 0x45d28
testl %eax, %eax
jne 0x37ea3
xorl %eax, %eax
movq %rax, 0xd8(%rbx)
movq %rax, 0x58(%rbx)
movl $0x4, %ecx
movabsq $-0x1f00000000000000, %rax # imm = 0xE100000000000000
movq %r15, %rdx
movl $0x4, %esi
shrdq $0x1, %r14, %rdx
shrq %r14
testb $0x1, %r15b
movl $0x0, %edi
cmovneq %rax, %rdi
xorq %rdi, %r14
movl %ecx, %edi
movq %rdx, 0x58(%rbx,%rdi,8)
movq %r14, 0xd8(%rbx,%rdi,8)
shrl %esi
movq %rdx, %r15
cmpl $0x1, %ecx
movl %esi, %ecx
ja 0x37e21
leaq 0xe0(%rbx), %rax
movl $0x2, %ecx
movl %ecx, %edx
movq 0x58(%rbx,%rdx,8), %rsi
movq 0xd8(%rbx,%rdx,8), %rdi
leaq (%rax,%rdx,8), %r8
decq %rdx
xorl %r9d, %r9d
movq (%rax,%r9,8), %r10
xorq %rdi, %r10
movq %r10, (%r8,%r9,8)
movq -0x80(%rax,%r9,8), %r10
xorq %rsi, %r10
movq %r10, -0x80(%r8,%r9,8)
incq %r9
cmpq %r9, %rdx
jne 0x37e79
leal (%rcx,%rcx), %edx
cmpl $0x5, %ecx
movl %edx, %ecx
jb 0x37e60
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /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,
const unsigned char *input,
unsigned char *output,
size_t tag_len,
unsigned char *tag )
{
int ret;
if( ( ret = mbedtls_gcm_starts( ctx, mode, iv, iv_len, add, add_len ) ) != 0 )
return( ret );
if( ( ret = mbedtls_gcm_update( ctx, length, input, output ) ) != 0 )
return( ret );
if( ( ret = mbedtls_gcm_finish( ctx, tag, tag_len ) ) != 0 )
return( ret );
return( 0 );
} | 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 0x384ff
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
movq %r13, %rcx
callq 0x381c6
testl %eax, %eax
je 0x3850e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x38312
| /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->md_info->block_size;
ctx->md_info->finish_func( ctx->md_ctx, tmp );
ctx->md_info->starts_func( ctx->md_ctx );
ctx->md_info->update_func( ctx->md_ctx, opad, ctx->md_info->block_size );
ctx->md_info->update_func( ctx->md_ctx, tmp, ctx->md_info->size );
ctx->md_info->finish_func( ctx->md_ctx, output );
return( 0 );
} | 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), %rdi
movq %rsp, %r12
movq %r12, %rsi
callq *0x28(%rcx)
movq (%r14), %rax
movq 0x8(%r14), %rdi
callq *0x18(%rax)
movq (%r14), %rax
movq 0x8(%r14), %rdi
movslq 0x14(%rax), %rdx
movq %r15, %rsi
callq *0x20(%rax)
movq (%r14), %rax
movq 0x8(%r14), %rdi
movslq 0x10(%rax), %rdx
movq %r12, %rsi
callq *0x20(%rax)
movq (%r14), %rax
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq *0x28(%rax)
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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_func( ctx->md_ctx, ipad, ctx->md_info->block_size );
return( 0 );
} | 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), %rdx
movq %r14, %rsi
callq *0x20(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /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], 16 ) != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
return( 1 );
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
mbedtls_printf( "\n" );
return( 0 );
} | 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), %rdi # 0x5c410
xorl %eax, %eax
callq 0xf110
leaq (%r12,%r12,8), %rax
leaq (%rax,%rax,8), %rdi
addq %r13, %rdi
movslq (%rbp,%r12,4), %rsi
movq %r14, %rdx
callq 0x39c52
movq %r12, %rax
shlq $0x4, %rax
movdqu (%rax,%r15), %xmm0
pcmpeqb (%rsp), %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
jne 0x39d5b
testl %ebx, %ebx
je 0x39d50
leaq 0x16e7f(%rip), %rdi # 0x50bbf
callq 0xf060
incq %r12
cmpq $0x7, %r12
jne 0x39ce9
jmp 0x39d72
incq %r12
cmpq $0x7, %r12
jne 0x39ce9
jmp 0x39d7c
movl $0x1, %ebp
testl %ebx, %ebx
je 0x39d7e
leaq 0x130aa(%rip), %rdi # 0x4ce15
callq 0xf060
jmp 0x39d7e
movl $0xa, %edi
callq 0xf040
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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( p, n, "%d.%d", oid->p[0] / 40, oid->p[0] % 40 );
OID_SAFE_SNPRINTF;
}
value = 0;
for( i = 1; i < oid->len; i++ )
{
/* Prevent overflow in value. */
if( ( ( value << 7 ) >> 7 ) != value )
return( MBEDTLS_ERR_OID_BUF_TOO_SMALL );
value <<= 7;
value += oid->p[i] & 0x7F;
if( !( oid->p[i] & 0x80 ) )
{
/* Last byte */
ret = mbedtls_snprintf( p, n, ".%d", value );
OID_SAFE_SNPRINTF;
value = 0;
}
}
return( (int) ( size - n ) );
} | 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
movzbl %al, %r8d
leaq 0x222c0(%rip), %rdx # 0x5c740
movq %rbx, %rsi
xorl %eax, %eax
callq 0xf120
movl $0xfffffff5, %ebp # imm = 0xFFFFFFF5
testl %eax, %eax
js 0x3a509
movl %eax, %ecx
movq %rbx, %r12
subq %rcx, %r12
jbe 0x3a509
movq 0x8(%r14), %rax
cmpq $0x2, %rax
jb 0x3a504
addq %rcx, %r15
movl $0x1, %r13d
xorl %ecx, %ecx
cmpl $0x1ffffff, %ecx # imm = 0x1FFFFFF
ja 0x3a509
movl %ecx, %edx
shll $0x7, %edx
movq 0x10(%r14), %rcx
movzbl (%rcx,%r13), %esi
movl %esi, %ecx
andl $0x7f, %ecx
orl %edx, %ecx
testb %sil, %sil
js 0x3a4fc
movq %r15, %rdi
movq %r12, %rsi
leaq 0x22261(%rip), %rdx # 0x5c742
xorl %eax, %eax
callq 0xf120
testl %eax, %eax
js 0x3a509
movl %eax, %eax
subq %rax, %r12
jbe 0x3a509
addq %rax, %r15
movq 0x8(%r14), %rax
xorl %ecx, %ecx
incq %r13
cmpq %rax, %r13
jb 0x3a4b2
subl %r12d, %ebx
movl %ebx, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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, *end;
#if defined(MBEDTLS_MD5_C) && defined(MBEDTLS_CIPHER_MODE_CBC) && \
( defined(MBEDTLS_DES_C) || defined(MBEDTLS_AES_C) )
unsigned char pem_iv[16];
mbedtls_cipher_type_t enc_alg = MBEDTLS_CIPHER_NONE;
#else
((void) pwd);
((void) pwdlen);
#endif /* MBEDTLS_MD5_C && MBEDTLS_CIPHER_MODE_CBC &&
( MBEDTLS_AES_C || MBEDTLS_DES_C ) */
if( ctx == NULL )
return( MBEDTLS_ERR_PEM_BAD_INPUT_DATA );
s1 = (unsigned char *) strstr( (const char *) data, header );
if( s1 == NULL )
return( MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT );
s2 = (unsigned char *) strstr( (const char *) data, footer );
if( s2 == NULL || s2 <= s1 )
return( MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT );
s1 += strlen( header );
if( *s1 == ' ' ) s1++;
if( *s1 == '\r' ) s1++;
if( *s1 == '\n' ) s1++;
else return( MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT );
end = s2;
end += strlen( footer );
if( *end == ' ' ) end++;
if( *end == '\r' ) end++;
if( *end == '\n' ) end++;
*use_len = end - data;
enc = 0;
if( s2 - s1 >= 22 && memcmp( s1, "Proc-Type: 4,ENCRYPTED", 22 ) == 0 )
{
#if defined(MBEDTLS_MD5_C) && defined(MBEDTLS_CIPHER_MODE_CBC) && \
( defined(MBEDTLS_DES_C) || defined(MBEDTLS_AES_C) )
enc++;
s1 += 22;
if( *s1 == '\r' ) s1++;
if( *s1 == '\n' ) s1++;
else return( MBEDTLS_ERR_PEM_INVALID_DATA );
#if defined(MBEDTLS_DES_C)
if( s2 - s1 >= 23 && memcmp( s1, "DEK-Info: DES-EDE3-CBC,", 23 ) == 0 )
{
enc_alg = MBEDTLS_CIPHER_DES_EDE3_CBC;
s1 += 23;
if( s2 - s1 < 16 || pem_get_iv( s1, pem_iv, 8 ) != 0 )
return( MBEDTLS_ERR_PEM_INVALID_ENC_IV );
s1 += 16;
}
else if( s2 - s1 >= 18 && memcmp( s1, "DEK-Info: DES-CBC,", 18 ) == 0 )
{
enc_alg = MBEDTLS_CIPHER_DES_CBC;
s1 += 18;
if( s2 - s1 < 16 || pem_get_iv( s1, pem_iv, 8) != 0 )
return( MBEDTLS_ERR_PEM_INVALID_ENC_IV );
s1 += 16;
}
#endif /* MBEDTLS_DES_C */
#if defined(MBEDTLS_AES_C)
if( s2 - s1 >= 14 && memcmp( s1, "DEK-Info: AES-", 14 ) == 0 )
{
if( s2 - s1 < 22 )
return( MBEDTLS_ERR_PEM_UNKNOWN_ENC_ALG );
else if( memcmp( s1, "DEK-Info: AES-128-CBC,", 22 ) == 0 )
enc_alg = MBEDTLS_CIPHER_AES_128_CBC;
else if( memcmp( s1, "DEK-Info: AES-192-CBC,", 22 ) == 0 )
enc_alg = MBEDTLS_CIPHER_AES_192_CBC;
else if( memcmp( s1, "DEK-Info: AES-256-CBC,", 22 ) == 0 )
enc_alg = MBEDTLS_CIPHER_AES_256_CBC;
else
return( MBEDTLS_ERR_PEM_UNKNOWN_ENC_ALG );
s1 += 22;
if( s2 - s1 < 32 || pem_get_iv( s1, pem_iv, 16 ) != 0 )
return( MBEDTLS_ERR_PEM_INVALID_ENC_IV );
s1 += 32;
}
#endif /* MBEDTLS_AES_C */
if( enc_alg == MBEDTLS_CIPHER_NONE )
return( MBEDTLS_ERR_PEM_UNKNOWN_ENC_ALG );
if( *s1 == '\r' ) s1++;
if( *s1 == '\n' ) s1++;
else return( MBEDTLS_ERR_PEM_INVALID_DATA );
#else
return( MBEDTLS_ERR_PEM_FEATURE_UNAVAILABLE );
#endif /* MBEDTLS_MD5_C && MBEDTLS_CIPHER_MODE_CBC &&
( MBEDTLS_AES_C || MBEDTLS_DES_C ) */
}
if( s1 >= s2 )
return( MBEDTLS_ERR_PEM_INVALID_DATA );
ret = mbedtls_base64_decode( NULL, 0, &len, s1, s2 - s1 );
if( ret == MBEDTLS_ERR_BASE64_INVALID_CHARACTER )
return( MBEDTLS_ERR_PEM_INVALID_DATA + ret );
if( ( buf = mbedtls_calloc( 1, len ) ) == NULL )
return( MBEDTLS_ERR_PEM_ALLOC_FAILED );
if( ( ret = mbedtls_base64_decode( buf, len, &len, s1, s2 - s1 ) ) != 0 )
{
mbedtls_free( buf );
return( MBEDTLS_ERR_PEM_INVALID_DATA + ret );
}
if( enc != 0 )
{
#if defined(MBEDTLS_MD5_C) && defined(MBEDTLS_CIPHER_MODE_CBC) && \
( defined(MBEDTLS_DES_C) || defined(MBEDTLS_AES_C) )
if( pwd == NULL )
{
mbedtls_free( buf );
return( MBEDTLS_ERR_PEM_PASSWORD_REQUIRED );
}
#if defined(MBEDTLS_DES_C)
if( enc_alg == MBEDTLS_CIPHER_DES_EDE3_CBC )
pem_des3_decrypt( pem_iv, buf, len, pwd, pwdlen );
else if( enc_alg == MBEDTLS_CIPHER_DES_CBC )
pem_des_decrypt( pem_iv, buf, len, pwd, pwdlen );
#endif /* MBEDTLS_DES_C */
#if defined(MBEDTLS_AES_C)
if( enc_alg == MBEDTLS_CIPHER_AES_128_CBC )
pem_aes_decrypt( pem_iv, 16, buf, len, pwd, pwdlen );
else if( enc_alg == MBEDTLS_CIPHER_AES_192_CBC )
pem_aes_decrypt( pem_iv, 24, buf, len, pwd, pwdlen );
else if( enc_alg == MBEDTLS_CIPHER_AES_256_CBC )
pem_aes_decrypt( pem_iv, 32, buf, len, pwd, pwdlen );
#endif /* MBEDTLS_AES_C */
/*
* The result will be ASN.1 starting with a SEQUENCE tag, with 1 to 3
* length bytes (allow 4 to be sure) in all known use cases.
*
* Use that as heurisitic to try detecting password mismatchs.
*/
if( len <= 2 || buf[0] != 0x30 || buf[1] > 0x83 )
{
mbedtls_free( buf );
return( MBEDTLS_ERR_PEM_PASSWORD_MISMATCH );
}
#else
mbedtls_free( buf );
return( MBEDTLS_ERR_PEM_FEATURE_UNAVAILABLE );
#endif /* MBEDTLS_MD5_C && MBEDTLS_CIPHER_MODE_CBC &&
( MBEDTLS_AES_C || MBEDTLS_DES_C ) */
}
ctx->buf = buf;
ctx->buflen = len;
return( 0 );
} | 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 0x3a6ca
movq %rax, %r12
movq %r13, %rdi
movq %r14, %rsi
callq 0xf360
cmpq %r12, %rax
jbe 0x3a6ca
movq %rax, 0x8(%rsp)
movq %r15, %rdi
callq 0xf100
movq %r12, %rcx
addq %rax, %rcx
xorl %edx, %edx
cmpb $0x20, (%r12,%rax)
sete %dl
xorl %eax, %eax
cmpb $0xd, (%rdx,%rcx)
leaq (%rcx,%rdx), %r15
sete %al
cmpb $0xa, (%rax,%r15)
jne 0x3a6ca
movq 0x70(%rsp), %r12
addq %rax, %r15
leaq 0x1(%r15), %rax
movq %r14, %rdi
movq %rax, %r14
callq 0xf100
xorl %ecx, %ecx
movq 0x8(%rsp), %r8
cmpb $0x20, (%r8,%rax)
leaq (%r8,%rax), %rax
sete %cl
leaq (%rax,%rcx), %rdx
xorl %esi, %esi
cmpb $0xd, (%rcx,%rax)
sete %sil
leaq (%rdx,%rsi), %rax
xorl %ecx, %ecx
cmpb $0xa, (%rsi,%rdx)
sete %cl
addq %rax, %rcx
subq %r13, %rcx
movq %rcx, (%r12)
movq %r8, %rax
subq %r14, %rax
xorl %r13d, %r13d
movb $0x1, %r12b
cmpq $0x16, %rax
jl 0x3a649
movdqu (%r14), %xmm0
movdqu 0x6(%r14), %xmm1
pcmpeqb 0x229d2(%rip), %xmm1 # 0x5d000
pcmpeqb 0x229da(%rip), %xmm0 # 0x5d010
pand %xmm1, %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
je 0x3a6db
movl $0xffffef00, %ebp # imm = 0xFFFFEF00
cmpq %r8, %r14
jae 0x3a6ca
movq 0x8(%rsp), %r8
subq %r14, %r8
movq %rsp, %rdx
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rcx
movq %r8, %r15
callq 0x4655b
movl $0xffffeed4, %ebp # imm = 0xFFFFEED4
cmpl $-0x2c, %eax
je 0x3a6ca
movq %r14, %rbp
movq (%rsp), %r14
movl $0x1, %edi
movq %r14, %rsi
callq 0xf1d0
testq %rax, %rax
je 0x3a77c
movq %rsp, %rdx
movq %rax, %rdi
movq %r14, %rsi
movq %rbp, %rcx
movq %rax, %r14
movq %r15, %r8
callq 0x4655b
testl %eax, %eax
je 0x3a786
movl %eax, %ebp
movq %r14, %rdi
callq 0xf030
addl $0xffffef00, %ebp # imm = 0xFFFFEF00
jmp 0x3a6ca
movl $0xffffeb80, %ebp # imm = 0xFFFFEB80
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17(%r15), %r14
leaq 0x18(%r15), %rax
xorl %ecx, %ecx
cmpb $0xd, 0x17(%r15)
cmoveq %rax, %r14
sete %cl
movl $0xffffef00, %ebp # imm = 0xFFFFEF00
cmpb $0xa, 0x17(%rcx,%r15)
jne 0x3a6ca
leaq 0x1(%r14), %rdx
movq %r8, %rax
subq %rdx, %rax
cmpq $0x17, %rax
movq %rdx, %rcx
jl 0x3a7a1
movdqu (%rdx), %xmm0
movdqu 0x7(%rdx), %xmm1
pcmpeqb 0x228fa(%rip), %xmm1 # 0x5d020
pcmpeqb 0x22902(%rip), %xmm0 # 0x5d030
pand %xmm1, %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
jne 0x3a7a7
leaq 0x18(%r14), %rdi
movq %r8, %rax
subq %rdi, %rax
movl $0xffffee00, %ebp # imm = 0xFFFFEE00
cmpq $0x10, %rax
jl 0x3a6ca
leaq 0x10(%rsp), %rsi
movl $0x8, %edx
callq 0x3aa73
testl %eax, %eax
jne 0x3a6ca
addq $0x28, %r14
movl $0x25, %r13d
jmp 0x3a8d8
movl $0xffffee80, %ebp # imm = 0xFFFFEE80
jmp 0x3a6ca
testb %r12b, %r12b
je 0x3a847
movq (%rsp), %rax
movq %r14, (%rbx)
movq %rax, 0x8(%rbx)
xorl %ebp, %ebp
jmp 0x3a6ca
cmpq $0x12, %rax
jl 0x3a7d6
movdqu (%rcx), %xmm0
movzwl 0x10(%rcx), %eax
movd %eax, %xmm1
pcmpeqb 0x22885(%rip), %xmm0 # 0x5d040
pcmpeqb 0x2288d(%rip), %xmm1 # 0x5d050
pand %xmm0, %xmm1
pmovmskb %xmm1, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
je 0x3a89e
xorl %r13d, %r13d
movb $0x1, %al
movq %rcx, %r14
movq %r8, %rcx
subq %r14, %rcx
cmpq $0xe, %rcx
jl 0x3a80e
movabsq $0x6f666e492d4b4544, %rdx # imm = 0x6F666E492D4B4544
xorq (%r14), %rdx
movabsq $0x2d534541203a6f66, %rsi # imm = 0x2D534541203A6F66
xorq 0x6(%r14), %rsi
orq %rdx, %rsi
je 0x3a8e4
movl $0xffffed80, %ebp # imm = 0xFFFFED80
testb %al, %al
jne 0x3a6ca
xorl %eax, %eax
cmpb $0xd, (%r14)
sete %al
cmpb $0xa, (%r14,%rax)
movl $0xffffef00, %ebp # imm = 0xFFFFEF00
jne 0x3a6ca
addq %rax, %r14
incq %r14
xorl %r12d, %r12d
movq 0x8(%rsp), %r8
jmp 0x3a649
movq 0x30(%rsp), %r8
testq %r8, %r8
je 0x3a98d
cmpl $0x6, %r13d
jle 0x3a99f
cmpl $0x7, %r13d
movq 0x28(%rsp), %r9
je 0x3a9c0
cmpl $0x21, %r13d
je 0x3a9d0
cmpl $0x25, %r13d
jne 0x3a9ff
movq (%rsp), %rdx
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %r8, %rcx
movq %r9, %r8
callq 0x3ab18
jmp 0x3a9ff
leaq 0x13(%r14), %rdi
movq %r8, %rax
subq %rdi, %rax
movl $0xffffee00, %ebp # imm = 0xFFFFEE00
cmpq $0x10, %rax
jl 0x3a6ca
leaq 0x10(%rsp), %rsi
movl $0x8, %edx
callq 0x3aa73
testl %eax, %eax
jne 0x3a6ca
addq $0x23, %r14
movl $0x21, %r13d
xorl %eax, %eax
movq 0x8(%rsp), %r8
jmp 0x3a7de
movl $0xffffed80, %ebp # imm = 0xFFFFED80
cmpq $0x16, %rcx
jb 0x3a6ca
movdqu (%r14), %xmm0
movdqu 0x6(%r14), %xmm1
pcmpeqb 0x2275a(%rip), %xmm1 # 0x5d060
pcmpeqb 0x22762(%rip), %xmm0 # 0x5d070
pand %xmm1, %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
je 0x3aa2c
movdqu (%r14), %xmm0
movdqu 0x6(%r14), %xmm1
pcmpeqb 0x2274c(%rip), %xmm1 # 0x5d080
pcmpeqb 0x22754(%rip), %xmm0 # 0x5d090
pand %xmm1, %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
je 0x3aa34
movdqu (%r14), %xmm0
movdqu 0x6(%r14), %xmm1
pcmpeqb 0x2273e(%rip), %xmm1 # 0x5d0a0
pcmpeqb 0x22746(%rip), %xmm0 # 0x5d0b0
pand %xmm1, %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
jne 0x3a6ca
movl $0x7, %r13d
movq 0x8(%rsp), %r8
jmp 0x3aa3a
movq %r14, %rdi
callq 0xf030
movl $0xffffed00, %ebp # imm = 0xFFFFED00
jmp 0x3a6ca
cmpl $0x5, %r13d
movq 0x28(%rsp), %r9
je 0x3a9e9
cmpl $0x6, %r13d
jne 0x3a9ff
movq (%rsp), %rcx
leaq 0x10(%rsp), %rdi
movl $0x18, %esi
jmp 0x3a9f7
movq (%rsp), %rcx
leaq 0x10(%rsp), %rdi
movl $0x20, %esi
jmp 0x3a9f7
movq (%rsp), %rdx
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %r8, %rcx
movq %r9, %r8
callq 0x3abaf
jmp 0x3a9ff
movq (%rsp), %rcx
leaq 0x10(%rsp), %rdi
movl $0x10, %esi
movq %r14, %rdx
callq 0x3ac46
movq (%rsp), %rax
cmpq $0x3, %rax
jb 0x3aa1a
cmpb $0x30, (%r14)
jne 0x3aa1a
cmpb $-0x7c, 0x1(%r14)
jb 0x3a793
movq %r14, %rdi
callq 0xf030
movl $0xffffec80, %ebp # imm = 0xFFFFEC80
jmp 0x3a6ca
movl $0x5, %r13d
jmp 0x3aa3a
movl $0x6, %r13d
leaq 0x16(%r14), %rdi
movq %r8, %rax
subq %rdi, %rax
movl $0xffffee00, %ebp # imm = 0xFFFFEE00
cmpq $0x20, %rax
jl 0x3a6ca
leaq 0x10(%rsp), %rsi
movl $0x10, %edx
callq 0x3aa73
testl %eax, %eax
jne 0x3a6ca
addq $0x36, %r14
jmp 0x3a81b
| /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, des_iv, pwd, pwdlen );
mbedtls_des_setkey_dec( &des_ctx, des_key );
mbedtls_des_crypt_cbc( &des_ctx, MBEDTLS_DES_DECRYPT, buflen,
des_iv, buf, buf );
mbedtls_des_free( &des_ctx );
mbedtls_zeroize( 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
callq 0x3aea0
movq %rbp, %rdi
movq %r15, %rsi
callq 0x2bd5e
xorl %ebx, %ebx
movq %rbp, %rdi
xorl %esi, %esi
movq 0x8(%rsp), %rdx
movq %r13, %rcx
movq %r12, %r8
movq %r12, %r9
callq 0x2c1d1
movq %rbp, %rdi
callq 0x2b833
movb $0x0, 0x10(%rsp,%rbx)
incq %rbx
cmpq $0x8, %rbx
jne 0x3ac26
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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(pwd || IV)
*/
mbedtls_md5_starts( &md5_ctx );
mbedtls_md5_update( &md5_ctx, pwd, pwdlen );
mbedtls_md5_update( &md5_ctx, iv, 8 );
mbedtls_md5_finish( &md5_ctx, md5sum );
if( keylen <= 16 )
{
memcpy( key, md5sum, keylen );
mbedtls_md5_free( &md5_ctx );
mbedtls_zeroize( md5sum, 16 );
return;
}
memcpy( key, md5sum, 16 );
/*
* key[16..23] = MD5(key[ 0..15] || pwd || IV])
*/
mbedtls_md5_starts( &md5_ctx );
mbedtls_md5_update( &md5_ctx, md5sum, 16 );
mbedtls_md5_update( &md5_ctx, pwd, pwdlen );
mbedtls_md5_update( &md5_ctx, iv, 8 );
mbedtls_md5_finish( &md5_ctx, md5sum );
use_len = 16;
if( keylen < 32 )
use_len = keylen - 16;
memcpy( key + 16, md5sum, use_len );
mbedtls_md5_free( &md5_ctx );
mbedtls_zeroize( md5sum, 16 );
} | 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, %edx
movq %rbp, %rdi
movq %r15, %rsi
callq 0x39a96
movq %rsp, %rsi
movq %rbp, %rdi
callq 0x39b50
cmpq $0x10, %r14
ja 0x3af2d
movq %rsp, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xf240
leaq 0x10(%rsp), %rdi
callq 0x392ab
xorl %eax, %eax
movb $0x0, (%rsp,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x3af1b
jmp 0x3afb3
movq %rsp, %rax
movaps (%rax), %xmm0
movups %xmm0, (%rbx)
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
callq 0x392c8
movl $0x10, %edx
movq %rbp, %rdi
movq %rsp, %rsi
callq 0x39a96
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x39a96
movl $0x8, %edx
movq %rbp, %rdi
movq %r15, %rsi
callq 0x39a96
movq %rbp, %rdi
movq %rsp, %rsi
callq 0x39b50
leaq -0x10(%r14), %rdx
cmpq $0x20, %r14
movl $0x10, %eax
cmovaeq %rax, %rdx
addq $0x10, %rbx
movq %rbx, %rdi
movq %rsp, %rsi
callq 0xf240
movq %rbp, %rdi
callq 0x392ab
xorl %eax, %eax
movb $0x0, (%rsp,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x3afa6
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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_ERR_PK_BAD_INPUT_DATA );
if( ctx->pk_info->verify_func == NULL )
return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
return( ctx->pk_info->verify_func( ctx->pk_ctx, md_alg, hash, hash_len,
sig, sig_len ) );
} | 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, %edi
callq 0x38cdb
testq %rax, %rax
je 0x3b14e
movq %rax, %rdi
callq 0x39265
movzbl %al, %ecx
movq (%r12), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x3b148
movq 0x8(%r12), %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %r14, %r8
movq %rbx, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movl $0xffffc100, %r13d # imm = 0xFFFFC100
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
if( ctx->pk_info->decrypt_func == NULL )
return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
return( ctx->pk_info->decrypt_func( ctx->pk_ctx, input, ilen,
output, olen, osize, f_rng, p_rng ) );
} | 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->type == MBEDTLS_PK_RSA_ALT )
{
if( pub->pk_info->type != MBEDTLS_PK_RSA )
return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
}
else
{
if( pub->pk_info != prv->pk_info )
return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
}
return( prv->pk_info->check_pair_func( pub->pk_ctx, prv->pk_ctx ) );
} | 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 # imm = 0xFFFFC100
cmpl $0x1, (%rcx)
jne 0x3b3e2
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rsi
jmpq *%rdx
movl $0xffffc100, %eax # imm = 0xFFFFC100
cmpq %r8, %rcx
je 0x3b3ce
retq
| /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, items );
return( 0 );
} | 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_context *) ctx)->E );
} | 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_keypair( &ecdsa, ctx ) ) == 0 )
ret = ecdsa_verify_wrap( &ecdsa, md_alg, hash, hash_len, sig, sig_len );
mbedtls_ecdsa_free( &ecdsa );
return( ret );
} | 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 0x3b67f
movq %rsp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x49178
cmpl $0xffffb400, %eax # imm = 0xFFFFB400
movl $0xffffc700, %ebp # imm = 0xFFFFC700
cmovnel %eax, %ebp
movq %rsp, %rdi
callq 0x49312
movl %ebp, %eax
addq $0x158, %rsp # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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_context *) ctx;
((void) f_rng);
((void) p_rng);
if( ilen != rsa_alt->key_len_func( rsa_alt->key ) )
return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
return( rsa_alt->decrypt_func( rsa_alt->key,
MBEDTLS_RSA_PRIVATE, olen, input, output, osize ) );
} | 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, %rcx
movq %r14, %r8
movq %rbx, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movl $0xffffbf80, %eax # imm = 0xFFFFBF80
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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, sizeof( hash ) );
if( ( ret = rsa_alt_sign_wrap( (void *) prv, MBEDTLS_MD_NONE,
hash, sizeof( hash ),
sig, &sig_len, NULL, NULL ) ) != 0 )
{
return( ret );
}
if( rsa_verify_wrap( (void *) pub, MBEDTLS_MD_NONE,
hash, sizeof( hash ), sig, sig_len ) != 0 )
{
return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED );
}
return( 0 );
} | 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 # 0x5d170
movq %rsp, %r12
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
movq (%r14), %rdi
callq *0x18(%r14)
movq %rax, %r15
movq (%r14), %rdi
leaq 0x20(%rsp), %rax
xorl %esi, %esi
xorl %edx, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
movl $0x20, %r9d
pushq %rax
pushq %r12
callq *0x10(%r14)
addq $0x10, %rsp
testl %eax, %eax
jne 0x3b976
movq %rsp, %rdx
leaq 0x20(%rsp), %r8
movl $0x20, %ecx
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %r9
callq 0x3b46f
movl %eax, %ecx
testl %eax, %eax
movl $0xffffbe00, %eax # imm = 0xFFFFBE00
cmovel %ecx, %eax
addq $0x428, %rsp # imm = 0x428
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
{
return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
}
end = *p + len;
if( ( ret = pk_get_pk_alg( p, end, &pk_alg, &alg_params ) ) != 0 )
return( ret );
if( ( ret = mbedtls_asn1_get_bitstring_null( p, end, &len ) ) != 0 )
return( MBEDTLS_ERR_PK_INVALID_PUBKEY + ret );
if( *p + len != end )
return( MBEDTLS_ERR_PK_INVALID_PUBKEY +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
if( ( pk_info = mbedtls_pk_info_from_type( pk_alg ) ) == NULL )
return( MBEDTLS_ERR_PK_UNKNOWN_PK_ALG );
if( ( ret = mbedtls_pk_setup( pk, pk_info ) ) != 0 )
return( ret );
#if defined(MBEDTLS_RSA_C)
if( pk_alg == MBEDTLS_PK_RSA )
{
ret = pk_get_rsapubkey( p, end, mbedtls_pk_rsa( *pk ) );
} else
#endif /* MBEDTLS_RSA_C */
#if defined(MBEDTLS_ECP_C)
if( pk_alg == MBEDTLS_PK_ECKEY_DH || pk_alg == MBEDTLS_PK_ECKEY )
{
ret = pk_use_ecparams( &alg_params, &mbedtls_pk_ec( *pk )->grp );
if( ret == 0 )
ret = pk_get_ecpubkey( p, end, mbedtls_pk_ec( *pk ) );
} else
#endif /* MBEDTLS_ECP_C */
ret = MBEDTLS_ERR_PK_UNKNOWN_PK_ALG;
if( ret == 0 && *p != end )
ret = MBEDTLS_ERR_PK_INVALID_PUBKEY
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH;
if( ret != 0 )
mbedtls_pk_free( pk );
return( ret );
} | 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(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3c0ac
testl %eax, %eax
je 0x3bfe0
movl %eax, %ebp
jmp 0x3c010
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2559a
testl %eax, %eax
je 0x3bffe
movl %eax, %ebp
addl $0xffffc500, %ebp # imm = 0xFFFFC500
jmp 0x3c010
movq (%r14), %rax
addq 0x8(%rsp), %rax
movl $0xffffc49a, %ebp # imm = 0xFFFFC49A
cmpq %r15, %rax
je 0x3c01d
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x4(%rsp), %edi
callq 0x3aff9
testq %rax, %rax
je 0x3c066
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3b011
testl %eax, %eax
jne 0x3bfdc
movl 0x4(%rsp), %eax
cmpl $0x1, %eax
jne 0x3c06d
movq 0x8(%rbx), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3c117
movl %eax, %ebp
testl %eax, %eax
jne 0x3c08e
movl $0xffffc49a, %ebp # imm = 0xFFFFC49A
cmpq %r15, (%r14)
jne 0x3c08e
xorl %ebp, %ebp
jmp 0x3c010
movl $0xffffc380, %ebp # imm = 0xFFFFC380
jmp 0x3c010
andl $-0x2, %eax
movl $0xffffc380, %ebp # imm = 0xFFFFC380
cmpl $0x2, %eax
jne 0x3c08e
movq 0x8(%rbx), %rsi
leaq 0x10(%rsp), %rdi
callq 0x3c1b9
movl %eax, %ebp
testl %eax, %eax
je 0x3c09b
movq %rbx, %rdi
callq 0x3afd0
jmp 0x3c010
movq 0x8(%rbx), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3c6b1
jmp 0x3c052
| /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_pubkey( &key->grp, &key->Q );
}
/*
* We know mbedtls_ecp_point_read_binary consumed all bytes or failed
*/
*p = (unsigned char *) end;
return( ret );
} | 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 $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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] &= 0xFFFFFFFF;
if( ctx->total[0] < (uint32_t) ilen )
ctx->total[1]++;
if( left && ilen >= fill )
{
memcpy( (void *) (ctx->buffer + left), input, fill );
mbedtls_ripemd160_process( ctx, ctx->buffer );
input += fill;
ilen -= fill;
left = 0;
}
while( ilen >= 64 )
{
mbedtls_ripemd160_process( ctx, input );
input += 64;
ilen -= 64;
}
if( ilen > 0 )
{
memcpy( (void *) (ctx->buffer + left), input, ilen );
}
} | 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
subq %r15, %r13
jb 0x3e441
leaq 0x1c(%r14), %r12
movl %eax, %eax
leaq (%r14,%rax), %rdi
addq $0x1c, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xf240
movq %r14, %rdi
movq %r12, %rsi
callq 0x3ce60
addq %r15, %rbx
jmp 0x3e418
movq %rdx, %r13
cmpq $0x40, %r13
jb 0x3e437
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3ce60
addq $0x40, %rbx
addq $-0x40, %r13
cmpq $0x3f, %r13
ja 0x3e41e
xorl %eax, %eax
movq %r13, %rdx
testq %r13, %r13
je 0x3e45c
movl %eax, %eax
leaq (%r14,%rax), %rdi
addq $0x1c, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf240
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /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,
size_t *olen,
const unsigned char *input,
unsigned char *output,
size_t output_max_len )
{
int ret;
size_t ilen, i, pad_len;
unsigned char *p, bad, pad_done;
unsigned char buf[MBEDTLS_MPI_MAX_SIZE];
unsigned char lhash[MBEDTLS_MD_MAX_SIZE];
unsigned int hlen;
const mbedtls_md_info_t *md_info;
mbedtls_md_context_t md_ctx;
/*
* Parameters sanity checks
*/
if( mode == MBEDTLS_RSA_PRIVATE && ctx->padding != MBEDTLS_RSA_PKCS_V21 )
return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
ilen = ctx->len;
if( ilen < 16 || ilen > sizeof( buf ) )
return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
md_info = mbedtls_md_info_from_type( (mbedtls_md_type_t) ctx->hash_id );
if( md_info == NULL )
return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
hlen = mbedtls_md_get_size( md_info );
// checking for integer underflow
if( 2 * hlen + 2 > ilen )
return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
/*
* RSA operation
*/
ret = ( mode == MBEDTLS_RSA_PUBLIC )
? mbedtls_rsa_public( ctx, input, buf )
: mbedtls_rsa_private( ctx, f_rng, p_rng, input, buf );
if( ret != 0 )
return( ret );
/*
* Unmask data and generate lHash
*/
mbedtls_md_init( &md_ctx );
if( ( ret = mbedtls_md_setup( &md_ctx, md_info, 0 ) ) != 0 )
{
mbedtls_md_free( &md_ctx );
return( ret );
}
/* Generate lHash */
mbedtls_md( md_info, label, label_len, lhash );
/* seed: Apply seedMask to maskedSeed */
mgf_mask( buf + 1, hlen, buf + hlen + 1, ilen - hlen - 1,
&md_ctx );
/* DB: Apply dbMask to maskedDB */
mgf_mask( buf + hlen + 1, ilen - hlen - 1, buf + 1, hlen,
&md_ctx );
mbedtls_md_free( &md_ctx );
/*
* Check contents, in "constant-time"
*/
p = buf;
bad = 0;
bad |= *p++; /* First byte must be 0 */
p += hlen; /* Skip seed */
/* Check lHash */
for( i = 0; i < hlen; i++ )
bad |= lhash[i] ^ *p++;
/* Get zero-padding len, but always read till end of buffer
* (minus one, for the 01 byte) */
pad_len = 0;
pad_done = 0;
for( i = 0; i < ilen - 2 * hlen - 2; i++ )
{
pad_done |= p[i];
pad_len += ((pad_done | (unsigned char)-pad_done) >> 7) ^ 1;
}
p += pad_len;
bad |= *p++ ^ 0x01;
/*
* The only information "leaked" is whether the padding was correct or not
* (eg, no data is copied if it was not correct). This meets the
* recommendations in PKCS#1 v2.2: an opponent cannot distinguish between
* the different error conditions.
*/
if( bad != 0 )
return( MBEDTLS_ERR_RSA_INVALID_PADDING );
if( ilen - ( p - buf ) > output_max_len )
return( MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE );
*olen = ilen - (p - buf);
memcpy( output, p, *olen );
return( 0 );
} | 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(%rcx), %rax
movl $0xffffbf80, %ebp # imm = 0xFFFFBF80
cmpq $-0x3f1, %rax # imm = 0xFC0F
jb 0x3faad
movq %r8, 0x18(%rsp)
movq %r9, 0x20(%rsp)
movq %rcx, 0x8(%rsp)
movl 0x14c(%rbx), %edi
callq 0x38cdb
testq %rax, %rax
je 0x3faad
movq %rax, %r12
movq %rax, %rdi
callq 0x39265
movzbl %al, %eax
movq %rax, 0x10(%rsp)
leal 0x2(,%rax,2), %eax
cmpq %rax, 0x8(%rsp)
jb 0x3faad
movq 0x4c8(%rsp), %rcx
testl %r15d, %r15d
je 0x3f911
leaq 0x80(%rsp), %r8
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x3efb5
jmp 0x3f924
leaq 0x80(%rsp), %rdx
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x3eef3
movl %eax, %ebp
testl %eax, %eax
jne 0x3faad
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x38cf4
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x38da1
testl %eax, %eax
je 0x3f95d
movl %eax, %ebp
leaq 0x28(%rsp), %rdi
callq 0x38d03
jmp 0x3faad
movq 0x10(%rsp), %rbp
leal (,%rbp,2), %r13d
leaq 0x40(%rsp), %rcx
movq %r12, %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x38e72
leaq 0x81(%rsp), %rbx
leaq (%rsp,%rbp), %r14
addq $0x81, %r14
movq %rbp, %r15
notq %r15
addq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x3f591
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %rbp, %rcx
movq %r12, %r8
callq 0x3f591
movq %r12, %rdi
callq 0x38d03
movb -0x1(%rbx), %al
testb %bpl, %bpl
je 0x3fa05
leaq 0x1(,%rbp,2), %rcx
xorl %edx, %edx
movb (%r14,%rdx), %sil
xorb 0x40(%rsp,%rdx), %sil
orb %sil, %al
incq %rdx
cmpq %rdx, %rbp
jne 0x3f9e6
leaq (%rsp,%rcx), %r14
addq $0x80, %r14
movq 0x8(%rsp), %rcx
leaq -0x2(%rcx), %rdx
xorl %esi, %esi
subq %r13, %rdx
jne 0x3fa19
xorl %ecx, %ecx
jmp 0x3fa5d
cmpq $0x1, %rdx
adcq $0x0, %rdx
leaq 0x80(%rsp), %rcx
leaq (%rcx,%r13), %rdi
incq %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
movzbl (%rdi,%r8), %r9d
orl %r9d, %esi
movl %esi, %r9d
negl %r9d
movzbl %r9b, %r9d
orl %esi, %r9d
shrl $0x7, %r9d
xorl $0x1, %r9d
addq %r9, %rcx
incq %r8
cmpq %r8, %rdx
jne 0x3fa35
movb (%r14,%rcx), %dl
xorb $0x1, %dl
movl $0xffffbf00, %ebp # imm = 0xFFFFBF00
orb %al, %dl
jne 0x3faad
leaq (%r14,%rcx), %rsi
incq %rsi
leaq 0x80(%rsp), %rdx
subq %rsi, %rdx
addq 0x8(%rsp), %rdx
movl $0xffffbc00, %ebp # imm = 0xFFFFBC00
cmpq 0x4d8(%rsp), %rdx
ja 0x3faad
movq 0x4d0(%rsp), %rdi
movq 0x4c0(%rsp), %rax
movq %rdx, (%rax)
callq 0xf240
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x488, %rsp # imm = 0x488
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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;
if( ctx->total[0] < (uint32_t) ilen )
ctx->total[1]++;
if( left && ilen >= fill )
{
memcpy( (void *) (ctx->buffer + left), input, fill );
mbedtls_sha256_process( ctx, ctx->buffer );
input += fill;
ilen -= fill;
left = 0;
}
while( ilen >= 64 )
{
mbedtls_sha256_process( ctx, input );
input += 64;
ilen -= 64;
}
if( ilen > 0 )
memcpy( (void *) (ctx->buffer + left), input, ilen );
} | 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
subq %r15, %r13
jb 0x42c9c
leaq 0x28(%r14), %r12
movl %eax, %eax
leaq (%r14,%rax), %rdi
addq $0x28, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xf240
movq %r14, %rdi
movq %r12, %rsi
callq 0x421e5
addq %r15, %rbx
jmp 0x42c73
movq %rdx, %r13
cmpq $0x40, %r13
jb 0x42c92
movq %r14, %rdi
movq %rbx, %rsi
callq 0x421e5
addq $0x40, %rbx
addq $-0x40, %r13
cmpq $0x3f, %r13
ja 0x42c79
xorl %eax, %eax
movq %r13, %rdx
testq %r13, %r13
je 0x42cb7
movl %eax, %eax
leaq (%r14,%rax), %rdi
addq $0x28, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf240
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /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 );
mbedtls_sha512_free( &ctx );
} | 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 0x1a506(%rip), %xmm2 # 0x5df10
movaps 0x1a50f(%rip), %xmm3 # 0x5df20
jmp 0x43a2f
movaps 0x1a496(%rip), %xmm0 # 0x5deb0
movaps 0x1a49f(%rip), %xmm1 # 0x5dec0
movaps 0x1a4a8(%rip), %xmm2 # 0x5ded0
movaps 0x1a4b1(%rip), %xmm3 # 0x5dee0
leaq 0x8(%rsp), %r12
movups %xmm3, 0x10(%r12)
movups %xmm2, 0x20(%r12)
movups %xmm1, 0x30(%r12)
movups %xmm0, 0x40(%r12)
movl %ebp, 0xd0(%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4364b
movq %r12, %rdi
movq %rbx, %rsi
callq 0x4370d
xorl %eax, %eax
movb $0x0, 0x8(%rsp,%rax)
incq %rax
cmpq $0xd8, %rax
jne 0x43a6f
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /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_padlock_ace == -1 )
aes_padlock_ace = mbedtls_padlock_has_support( MBEDTLS_PADLOCK_ACE );
if( aes_padlock_ace )
ctx->rk = RK = MBEDTLS_PADLOCK_ALIGN16( ctx->buf );
else
#endif
ctx->rk = RK = ctx->buf;
/* Also checks keybits */
if( ( ret = mbedtls_aes_setkey_enc( &cty, key, keybits ) ) != 0 )
goto exit;
ctx->nr = cty.nr;
#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
if( mbedtls_aesni_has_support( MBEDTLS_AESNI_AES ) )
{
mbedtls_aesni_inverse_key( (unsigned char *) ctx->rk,
(const unsigned char *) cty.rk, ctx->nr );
goto exit;
}
#endif
SK = cty.rk + cty.nr * 4;
*RK++ = *SK++;
*RK++ = *SK++;
*RK++ = *SK++;
*RK++ = *SK++;
for( i = ctx->nr - 1, SK -= 8; i > 0; i--, SK -= 8 )
{
for( j = 0; j < 4; j++, SK++ )
{
*RK++ = RT0[ FSb[ ( *SK ) & 0xFF ] ] ^
RT1[ FSb[ ( *SK >> 8 ) & 0xFF ] ] ^
RT2[ FSb[ ( *SK >> 16 ) & 0xFF ] ] ^
RT3[ FSb[ ( *SK >> 24 ) & 0xFF ] ];
}
}
*RK++ = *SK++;
*RK++ = *SK++;
*RK++ = *SK++;
*RK++ = *SK++;
exit:
mbedtls_aes_free( &cty );
return( ret );
} | 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, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x4421f
movl %eax, %ebx
testl %eax, %eax
jne 0x44a2d
movl 0x8(%rsp), %eax
movl %eax, (%r14)
movl $0x2000000, %edi # imm = 0x2000000
callq 0x45d28
testl %eax, %eax
je 0x44924
movq 0x8(%r14), %rdi
movq 0x10(%rsp), %rsi
movl (%r14), %edx
callq 0x45f71
jmp 0x44a2d
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
addq $-0x10, %rax
movl 0x10(%rax), %ecx
movl %ecx, 0x10(%r14)
movl 0x14(%rax), %ecx
movl %ecx, 0x14(%r14)
movl 0x18(%rax), %ecx
movl %ecx, 0x18(%r14)
movl 0x1c(%rax), %ecx
leaq 0x20(%r14), %r15
movl %ecx, 0x1c(%r14)
movl (%r14), %ecx
cmpl $0x2, %ecx
jl 0x44a13
leaq 0x2dd14(%rip), %rdx # 0x72680
leaq 0x2de0d(%rip), %rsi # 0x72780
movl $0xff, %edi
leaq 0x2e201(%rip), %r8 # 0x72b80
leaq 0x2e5fa(%rip), %r9 # 0x72f80
leaq 0x2e9f3(%rip), %r11 # 0x73380
movq %r15, %r10
xorl %r15d, %r15d
xorl %r14d, %r14d
movl (%rax,%r15,4), %r12d
movzbl %r12b, %r13d
movzbl (%r13,%rdx), %r13d
movl %r12d, %ebp
shrl $0x8, %ebp
andl %edi, %ebp
movzbl (%rbp,%rdx), %ebp
movl (%r8,%rbp,4), %ebp
xorl (%rsi,%r13,4), %ebp
movl %r12d, %r13d
shrl $0x10, %r13d
andl %edi, %r13d
movzbl (%r13,%rdx), %r13d
xorl (%r9,%r13,4), %ebp
shrl $0x18, %r12d
movzbl (%r12,%rdx), %r12d
xorl (%r11,%r12,4), %ebp
movl %ebp, (%r10,%r15,4)
addq $-0x4, %r14
incq %r15
cmpl $0x4, %r15d
jne 0x44996
leal -0x1(%rcx), %ebp
movq %rax, %r12
subq %r14, %r12
leaq -0x20(%r12), %rax
movq %r10, %r15
subq %r14, %r15
cmpl $0x2, %ecx
movl %ebp, %ecx
jg 0x4498d
addq $-0x20, %r12
subq %r14, %r10
movq %r10, %r15
movq %r12, %rax
movl (%rax), %ecx
movl %ecx, (%r15)
movl 0x4(%rax), %ecx
movl %ecx, 0x4(%r15)
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%r15)
movl 0xc(%rax), %eax
movl %eax, 0xc(%r15)
xorl %eax, %eax
movb $0x0, 0x8(%rsp,%rax)
incq %rax
cmpq $0x120, %rax # imm = 0x120
jne 0x44a2f
movl %ebx, %eax
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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, input, 4 ); X1 ^= *RK++;
GET_UINT32_LE( X2, input, 8 ); X2 ^= *RK++;
GET_UINT32_LE( X3, input, 12 ); X3 ^= *RK++;
for( i = ( ctx->nr >> 1 ) - 1; i > 0; i-- )
{
AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
}
AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
X0 = *RK++ ^ \
( (uint32_t) FSb[ ( Y0 ) & 0xFF ] ) ^
( (uint32_t) FSb[ ( Y1 >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) FSb[ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) FSb[ ( Y3 >> 24 ) & 0xFF ] << 24 );
X1 = *RK++ ^ \
( (uint32_t) FSb[ ( Y1 ) & 0xFF ] ) ^
( (uint32_t) FSb[ ( Y2 >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) FSb[ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) FSb[ ( Y0 >> 24 ) & 0xFF ] << 24 );
X2 = *RK++ ^ \
( (uint32_t) FSb[ ( Y2 ) & 0xFF ] ) ^
( (uint32_t) FSb[ ( Y3 >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) FSb[ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) FSb[ ( Y1 >> 24 ) & 0xFF ] << 24 );
X3 = *RK++ ^ \
( (uint32_t) FSb[ ( Y3 ) & 0xFF ] ) ^
( (uint32_t) FSb[ ( Y0 >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) FSb[ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) FSb[ ( Y2 >> 24 ) & 0xFF ] << 24 );
PUT_UINT32_LE( X0, output, 0 );
PUT_UINT32_LE( X1, output, 4 );
PUT_UINT32_LE( X2, output, 8 );
PUT_UINT32_LE( X3, output, 12 );
} | 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 0x2ecf1(%rip), %rbp # 0x73780
leaq 0x2f0ea(%rip), %r10 # 0x73b80
cmpl $0x2, %esi
jl 0x44c64
incl %esi
movl $0xff, %ebx
leaq 0x2ecd3(%rip), %rbp # 0x73780
leaq 0x2f4cc(%rip), %r15 # 0x73f80
movl %esi, -0x14(%rsp)
movl %ecx, %esi
andl %ebx, %esi
movl (%rbp,%rsi,4), %r12d
xorl (%rax), %r12d
movl %r8d, %esi
shrl $0x8, %esi
andl %ebx, %esi
xorl (%r10,%rsi,4), %r12d
movl %r9d, %esi
shrl $0xe, %esi
movl $0x3fc, %edi # imm = 0x3FC
andl %edi, %esi
xorl (%rsi,%r15), %r12d
movl %edx, %esi
shrl $0x18, %esi
leaq 0x2f893(%rip), %r14 # 0x74380
xorl (%r14,%rsi,4), %r12d
movl %r8d, %esi
andl %ebx, %esi
movl (%rbp,%rsi,4), %r13d
xorl 0x4(%rax), %r13d
movl %r9d, %esi
shrl $0x8, %esi
andl %ebx, %esi
xorl (%r10,%rsi,4), %r13d
movl %edx, %esi
shrl $0xe, %esi
andl %edi, %esi
movl $0x3fc, %r11d # imm = 0x3FC
xorl (%rsi,%r15), %r13d
movl %ecx, %esi
shrl $0x18, %esi
xorl (%r14,%rsi,4), %r13d
movl %r9d, %esi
andl %ebx, %esi
movl (%rbp,%rsi,4), %esi
xorl 0x8(%rax), %esi
movq %r10, %rdi
movl %edx, %r10d
shrl $0x8, %r10d
andl %ebx, %r10d
xorl (%rdi,%r10,4), %esi
movl %ecx, %r10d
shrl $0xe, %r10d
andl %r11d, %r10d
xorl (%r10,%r15), %esi
movl %r8d, %r10d
shrl $0x18, %r10d
xorl (%r14,%r10,4), %esi
andl %ebx, %edx
movl (%rbp,%rdx,4), %r10d
xorl 0xc(%rax), %r10d
shrl $0x8, %ecx
andl %ebx, %ecx
xorl (%rdi,%rcx,4), %r10d
shrl $0xe, %r8d
andl %r11d, %r8d
xorl (%r8,%r15), %r10d
shrl $0x18, %r9d
movq %r14, %r11
xorl (%r14,%r9,4), %r10d
movl %r12d, %ecx
andl %ebx, %ecx
movl (%rbp,%rcx,4), %ecx
xorl 0x10(%rax), %ecx
movl %r13d, %edx
shrl $0x8, %edx
andl %ebx, %edx
xorl (%rdi,%rdx,4), %ecx
movl %esi, %edx
shrl $0xe, %edx
movl $0x3fc, %r9d # imm = 0x3FC
andl %r9d, %edx
xorl (%rdx,%r15), %ecx
movl %r10d, %edx
shrl $0x18, %edx
xorl (%r14,%rdx,4), %ecx
movl %r13d, %edx
andl %ebx, %edx
movl (%rbp,%rdx,4), %r8d
xorl 0x14(%rax), %r8d
movl %esi, %edx
shrl $0x8, %edx
andl %ebx, %edx
xorl (%rdi,%rdx,4), %r8d
movl %r10d, %edx
shrl $0xe, %edx
andl %r9d, %edx
xorl (%rdx,%r15), %r8d
movl %r12d, %edx
shrl $0x18, %edx
xorl (%r14,%rdx,4), %r8d
movl %esi, %edx
andl %ebx, %edx
movl (%rbp,%rdx,4), %r9d
xorl 0x18(%rax), %r9d
movl %r10d, %edx
shrl $0x8, %edx
andl %ebx, %edx
xorl (%rdi,%rdx,4), %r9d
movl %r12d, %edx
shrl $0xe, %edx
movl $0x3fc, %r14d # imm = 0x3FC
andl %r14d, %edx
xorl (%rdx,%r15), %r9d
movl %r13d, %edx
shrl $0x18, %edx
xorl (%r11,%rdx,4), %r9d
andl %ebx, %r10d
movl (%rbp,%r10,4), %edx
movq %rdi, %r10
xorl 0x1c(%rax), %edx
shrl $0x8, %r12d
andl %ebx, %r12d
xorl (%rdi,%r12,4), %edx
shrl $0xe, %r13d
andl %r14d, %r13d
xorl (%r13,%r15), %edx
shrl $0x18, %esi
xorl (%r11,%rsi,4), %edx
movl -0x14(%rsp), %esi
addq $0x20, %rax
decl %esi
cmpl $0x2, %esi
ja 0x44ab4
leaq 0x2eb1c(%rip), %rbp # 0x73780
movl $0xff, %ebx
movl %ecx, %esi
andl %ebx, %esi
movl (%rbp,%rsi,4), %r12d
xorl (%rax), %r12d
movl %r8d, %esi
shrl $0x8, %esi
andl %ebx, %esi
xorl (%r10,%rsi,4), %r12d
movq %r10, %rdi
movl %r9d, %r10d
shrl $0xe, %r10d
movl $0x3fc, %esi # imm = 0x3FC
andl %esi, %r10d
leaq 0x2f2e6(%rip), %r14 # 0x73f80
xorl (%r10,%r14), %r12d
movl %edx, %r10d
shrl $0x18, %r10d
leaq 0x2f6d4(%rip), %r13 # 0x74380
xorl (%r13,%r10,4), %r12d
movl %r8d, %r10d
andl %ebx, %r10d
movl (%rbp,%r10,4), %r11d
xorl 0x4(%rax), %r11d
movl %r9d, %r10d
shrl $0x8, %r10d
andl %ebx, %r10d
xorl (%rdi,%r10,4), %r11d
movl %edx, %r10d
shrl $0xe, %r10d
andl %esi, %r10d
xorl (%r10,%r14), %r11d
movl %ecx, %r10d
shrl $0x18, %r10d
xorl (%r13,%r10,4), %r11d
movl %r9d, %r10d
andl %ebx, %r10d
movl (%rbp,%r10,4), %r15d
xorl 0x8(%rax), %r15d
movl %edx, %r10d
shrl $0x8, %r10d
andl %ebx, %r10d
xorl (%rdi,%r10,4), %r15d
movl %ecx, %r10d
shrl $0xe, %r10d
andl %esi, %r10d
xorl (%r10,%r14), %r15d
movl %r8d, %r10d
shrl $0x18, %r10d
xorl (%r13,%r10,4), %r15d
andl %ebx, %edx
movl (%rbp,%rdx,4), %r10d
xorl 0xc(%rax), %r10d
shrl $0x8, %ecx
andl %ebx, %ecx
xorl (%rdi,%rcx,4), %r10d
shrl $0xe, %r8d
andl %esi, %r8d
xorl (%r8,%r14), %r10d
shrl $0x18, %r9d
xorl (%r13,%r9,4), %r10d
movl %r12d, %ecx
andl %ebx, %ecx
leaq 0x2d92d(%rip), %rdi # 0x72680
movzbl (%rcx,%rdi), %ecx
xorl 0x10(%rax), %ecx
movl %ecx, %r8d
movl %ecx, -0x10(%rsp)
movl %r11d, %ecx
shrl $0x8, %ecx
andl %ebx, %ecx
movzbl (%rcx,%rdi), %ecx
shll $0x8, %ecx
movl %r15d, %esi
shrl $0x10, %esi
andl %ebx, %esi
movzbl (%rsi,%rdi), %esi
shll $0x10, %esi
orl %ecx, %esi
movl %r10d, %ecx
shrl $0x18, %ecx
movzbl (%rcx,%rdi), %ecx
shll $0x18, %ecx
orl %esi, %ecx
movl %r11d, %esi
andl %ebx, %esi
movzbl (%rsi,%rdi), %edx
xorl 0x14(%rax), %edx
movl %edx, -0x14(%rsp)
movl %r15d, %edx
shrl $0x8, %edx
andl %ebx, %edx
movl %r10d, %r13d
shrl $0x10, %r13d
movl %r15d, %esi
andl %ebx, %esi
movzbl (%rsi,%rdi), %esi
xorl 0x18(%rax), %esi
movl %esi, -0xc(%rsp)
andl %ebx, %r13d
movl %r10d, %ebp
shrl $0x8, %ebp
andl %ebx, %ebp
andl %ebx, %r10d
movzbl (%r10,%rdi), %r9d
xorl 0x1c(%rax), %r9d
movl %r12d, %r10d
shrl $0x10, %r10d
andl %ebx, %r10d
movl %r12d, %eax
shrl $0x8, %r12d
andl %ebx, %r12d
movl %r11d, %r14d
shrl $0x10, %r11d
andl %ebx, %r11d
xorl %r8d, %ecx
movzbl (%rdx,%rdi), %esi
movzbl (%r13,%rdi), %r13d
shrl $0x18, %eax
movzbl (%rax,%rdi), %eax
movzbl (%rbp,%rdi), %r8d
movzbl (%r10,%rdi), %ebp
shrl $0x18, %r14d
movzbl (%r14,%rdi), %ebx
movzbl (%r12,%rdi), %r10d
movzbl (%r11,%rdi), %r11d
shrl $0x18, %r15d
movzbl (%r15,%rdi), %r14d
movq -0x8(%rsp), %rdx
movl -0x10(%rsp), %edi
movb %dil, (%rdx)
movb %ch, 0x1(%rdx)
movl %ecx, %edi
shrl $0x10, %edi
movb %dil, 0x2(%rdx)
shrl $0x18, %ecx
movb %cl, 0x3(%rdx)
shll $0x8, %esi
shll $0x10, %r13d
orl %esi, %r13d
shll $0x18, %eax
orl %r13d, %eax
movl -0x14(%rsp), %ecx
xorl %ecx, %eax
movb %cl, 0x4(%rdx)
movb %ah, 0x5(%rdx)
movl %eax, %ecx
shrl $0x10, %ecx
movb %cl, 0x6(%rdx)
shrl $0x18, %eax
movb %al, 0x7(%rdx)
shll $0x8, %r8d
shll $0x10, %ebp
orl %r8d, %ebp
shll $0x18, %ebx
orl %ebp, %ebx
movl -0xc(%rsp), %eax
xorl %eax, %ebx
movb %al, 0x8(%rdx)
movb %bh, 0x9(%rdx)
movl %ebx, %eax
shrl $0x10, %eax
movb %al, 0xa(%rdx)
shrl $0x18, %ebx
movb %bl, 0xb(%rdx)
shll $0x8, %r10d
shll $0x10, %r11d
orl %r10d, %r11d
movl %r14d, %ecx
shll $0x18, %ecx
orl %r11d, %ecx
xorl %r9d, %ecx
movb %r9b, 0xc(%rdx)
movb %ch, 0xd(%rdx)
movl %ecx, %eax
shrl $0x10, %eax
movb %al, 0xe(%rdx)
shrl $0x18, %ecx
movb %cl, 0xf(%rdx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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 )
return( MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_HAVE_X86)
if( aes_padlock_ace )
{
if( mbedtls_padlock_xcryptcbc( ctx, mode, length, iv, input, output ) == 0 )
return( 0 );
// If padlock data misaligned, we just fall back to
// unaccelerated mode
//
}
#endif
if( mode == MBEDTLS_AES_DECRYPT )
{
while( length > 0 )
{
memcpy( temp, input, 16 );
mbedtls_aes_crypt_ecb( ctx, mode, input, output );
for( i = 0; i < 16; i++ )
output[i] = (unsigned char)( output[i] ^ iv[i] );
memcpy( iv, temp, 16 );
input += 16;
output += 16;
length -= 16;
}
}
else
{
while( length > 0 )
{
for( i = 0; i < 16; i++ )
output[i] = (unsigned char)( input[i] ^ iv[i] );
mbedtls_aes_crypt_ecb( ctx, mode, output, output );
memcpy( iv, output, 16 );
input += 16;
output += 16;
length -= 16;
}
}
return( 0 );
} | 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, %eax
movb (%r15,%rax), %cl
xorb (%r14,%rax), %cl
movb %cl, (%rbx,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x453fe
movq %r13, %rdi
movl %ebp, %esi
movq %rbx, %rdx
movq %rbx, %rcx
callq 0x45363
movups (%rbx), %xmm0
movups %xmm0, (%r15)
addq $0x10, %r14
addq $0x10, %rbx
addq $-0x10, %r12
jne 0x453fc
jmp 0x4547e
testq %r12, %r12
je 0x4547e
movups (%r14), %xmm0
movaps %xmm0, (%rsp)
movq %r13, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x45363
xorl %eax, %eax
movb (%r15,%rax), %cl
xorb %cl, (%rbx,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x45458
movaps (%rsp), %xmm0
movups %xmm0, (%r15)
addq $0x10, %r14
addq $0x10, %rbx
addq $-0x10, %r12
jne 0x4543e
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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 );
memset( RK, 0, sizeof(ctx->rk) );
switch( keybits )
{
case 128: ctx->nr = 3; idx = 0; break;
case 192:
case 256: ctx->nr = 4; idx = 1; break;
default : return( MBEDTLS_ERR_CAMELLIA_INVALID_KEY_LENGTH );
}
for( i = 0; i < keybits / 8; ++i )
t[i] = key[i];
if( keybits == 192 ) {
for( i = 0; i < 8; i++ )
t[24 + i] = ~t[16 + i];
}
/*
* Prepare SIGMA values
*/
for( i = 0; i < 6; i++ ) {
GET_UINT32_BE( SIGMA[i][0], SIGMA_CHARS[i], 0 );
GET_UINT32_BE( SIGMA[i][1], SIGMA_CHARS[i], 4 );
}
/*
* Key storage in KC
* Order: KL, KR, KA, KB
*/
memset( KC, 0, sizeof(KC) );
/* Store KL, KR */
for( i = 0; i < 8; i++ )
GET_UINT32_BE( KC[i], t, i * 4 );
/* Generate KA */
for( i = 0; i < 4; ++i )
KC[8 + i] = KC[i] ^ KC[4 + i];
camellia_feistel( KC + 8, SIGMA[0], KC + 10 );
camellia_feistel( KC + 10, SIGMA[1], KC + 8 );
for( i = 0; i < 4; ++i )
KC[8 + i] ^= KC[i];
camellia_feistel( KC + 8, SIGMA[2], KC + 10 );
camellia_feistel( KC + 10, SIGMA[3], KC + 8 );
if( keybits > 128 ) {
/* Generate KB */
for( i = 0; i < 4; ++i )
KC[12 + i] = KC[4 + i] ^ KC[8 + i];
camellia_feistel( KC + 12, SIGMA[4], KC + 14 );
camellia_feistel( KC + 14, SIGMA[5], KC + 12 );
}
/*
* Generating subkeys
*/
/* Manipulating KL */
SHIFT_AND_PLACE( idx, 0 );
/* Manipulating KR */
if( keybits > 128 ) {
SHIFT_AND_PLACE( idx, 1 );
}
/* Manipulating KA */
SHIFT_AND_PLACE( idx, 2 );
/* Manipulating KB */
if( keybits > 128 ) {
SHIFT_AND_PLACE( idx, 3 );
}
/* Do transpositions */
for( i = 0; i < 20; i++ ) {
if( transposes[idx][i] != -1 ) {
RK[32 + 12 * idx + i] = RK[transposes[idx][i]];
}
}
return( 0 );
} | 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 # imm = 0x110
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf150
cmpl $0x100, %ebp # imm = 0x100
movl %ebp, 0xc(%rsp)
je 0x46df5
cmpl $0xc0, %ebp
je 0x46df5
movl $0xffffffdc, %eax # imm = 0xFFFFFFDC
cmpl $0x80, %ebp
jne 0x476bf
movl $0x3, (%r14)
movl %ebp, %edx
shrl $0x3, %edx
leaq 0xf0(%rsp), %rdi
movq %r15, %rsi
callq 0xf240
xorl %r13d, %r13d
jmp 0x46e32
movl $0x4, (%r14)
movl %ebp, %edx
shrl $0x3, %edx
leaq 0xf0(%rsp), %rdi
movq %r15, %rsi
callq 0xf240
movl $0x1, %r13d
cmpl $0xc0, %ebp
jne 0x46e32
movq 0x100(%rsp), %rax
notq %rax
movq %rax, 0x108(%rsp)
xorl %eax, %eax
leaq 0x18e25(%rip), %rcx # 0x5fc60
movl (%rcx,%rax,8), %edx
movl 0x4(%rcx,%rax,8), %esi
bswapl %edx
movl %edx, 0x70(%rsp,%rax,8)
bswapl %esi
movl %esi, 0x74(%rsp,%rax,8)
incq %rax
cmpq $0x6, %rax
jne 0x46e3b
movq %r14, 0x68(%rsp)
pxor %xmm0, %xmm0
movdqa %xmm0, 0x50(%rsp)
movdqa %xmm0, 0x40(%rsp)
movdqa %xmm0, 0x30(%rsp)
movdqa %xmm0, 0x20(%rsp)
xorl %eax, %eax
movl 0xf0(%rsp,%rax,4), %ecx
bswapl %ecx
movl %ecx, 0x20(%rsp,%rax,4)
incq %rax
cmpq $0x8, %rax
jne 0x46e7a
leaq 0x40(%rsp), %r15
movaps -0x10(%r15), %xmm0
xorps -0x20(%r15), %xmm0
movaps %xmm0, (%r15)
leaq 0x48(%rsp), %r12
movl -0x8(%r12), %edi
movl -0x4(%r12), %esi
movl 0x70(%rsp), %edx
movl 0x74(%rsp), %ecx
movq %r12, %r8
callq 0x476d1
movl (%r12), %edi
movl 0x4(%r12), %esi
movl 0x78(%rsp), %edx
movl 0x7c(%rsp), %ecx
movq %r15, %r8
callq 0x476d1
movdqa -0x8(%r12), %xmm0
pxor -0x28(%r12), %xmm0
movdqa %xmm0, -0x8(%r12)
movl -0x8(%r12), %edi
movl -0x4(%r12), %esi
movl 0x80(%rsp), %edx
movl 0x84(%rsp), %ecx
movq %r12, %r8
callq 0x476d1
movl (%r12), %edi
movl 0x4(%r12), %esi
movl 0x88(%rsp), %edx
movl 0x8c(%rsp), %ecx
movq %r15, %r8
callq 0x476d1
cmpl $0x81, 0xc(%rsp)
jb 0x46f93
leaq 0x50(%rsp), %r15
movdqa -0x10(%r15), %xmm0
pxor -0x20(%r15), %xmm0
movdqa %xmm0, (%r15)
leaq 0x58(%rsp), %r12
movl -0x8(%r12), %edi
movl -0x4(%r12), %esi
movl 0x90(%rsp), %edx
movl 0x94(%rsp), %ecx
movq %r12, %r8
callq 0x476d1
movl (%r12), %edi
movl 0x4(%r12), %esi
movl 0x98(%rsp), %edx
movl 0x9c(%rsp), %ecx
movq %r15, %r8
callq 0x476d1
movl 0x20(%rsp), %edi
movl 0x24(%rsp), %r14d
movl %edi, 0xa0(%rsp)
movl %r14d, 0xa4(%rsp)
movl 0x28(%rsp), %esi
movl %esi, 0xa8(%rsp)
movl 0x2c(%rsp), %r11d
movl %r11d, 0xac(%rsp)
movl %r13d, %eax
movq %rax, 0x10(%rsp)
shll $0x4, %r13d
leaq 0x1955a(%rip), %rax # 0x60530
addq %rax, %r13
movl $0x1c, %r8d
movl $0xf, %eax
cmpb $0x0, (%r13)
je 0x4705e
movl %edi, %r15d
movl %eax, %ecx
shll %cl, %r15d
movl %eax, %edx
andb $0x1f, %dl
negb %dl
movl %r14d, %r12d
movl %edx, %ecx
shrl %cl, %r12d
movl %r14d, %r9d
movl %eax, %ecx
shll %cl, %r9d
movl %esi, %r10d
movl %edx, %ecx
shrl %cl, %r10d
xorl %r15d, %r12d
movl %r12d, 0x94(%rsp,%r8)
movl %esi, %r15d
movl %eax, %ecx
shll %cl, %r15d
movl %r11d, %r12d
movl %edx, %ecx
shrl %cl, %r12d
xorl %r9d, %r10d
movl %r10d, 0x98(%rsp,%r8)
movl %r11d, %r9d
movl %eax, %ecx
shll %cl, %r9d
movl %edi, %r10d
movl %edx, %ecx
shrl %cl, %r10d
xorl %r15d, %r12d
movl %r12d, 0x9c(%rsp,%r8)
xorl %r9d, %r10d
movl %r10d, 0xa0(%rsp,%r8)
addq $0x10, %r8
incq %r13
addl $0xf, %eax
cmpq $0x5c, %r8
jne 0x46fe4
movq 0x10(%rsp), %rax
leaq (%rax,%rax,4), %rax
movq %rax, 0x18(%rsp)
shll $0x4, %eax
leaq 0x18c06(%rip), %rcx # 0x5fc90
addq %rcx, %rax
xorl %ecx, %ecx
pcmpeqd %xmm0, %xmm0
movl 0xc(%rsp), %r13d
movd (%rax,%rcx), %xmm2
movdqa %xmm2, %xmm3
pcmpeqb %xmm0, %xmm3
movdqa 0xa0(%rsp,%rcx,4), %xmm1
movd %xmm3, %r8d
notb %r8b
movd %xmm2, %edx
testb $0x1, %r8b
je 0x470ca
movsbq %dl, %r8
movd %xmm1, (%rbx,%r8,4)
movdqa %xmm2, %xmm3
pslld $0x8, %xmm3
pcmpeqb %xmm0, %xmm3
pxor %xmm0, %xmm3
pextrw $0x1, %xmm3, %r8d
testb $0x1, %r8b
je 0x470fd
movl %edx, %r8d
shrl $0x8, %r8d
movsbq %r8b, %r8
pshufd $0x55, %xmm1, %xmm3 # xmm3 = xmm1[1,1,1,1]
movd %xmm3, (%rbx,%r8,4)
pshuflw $0x55, %xmm2, %xmm3 # xmm3 = xmm2[1,1,1,1,4,5,6,7]
pcmpeqb %xmm0, %xmm3
pxor %xmm0, %xmm3
pextrw $0x2, %xmm3, %r8d
testb $0x1, %r8b
je 0x4712c
movl %edx, %r8d
shrl $0x10, %r8d
movsbq %r8b, %r8
pshufd $0xee, %xmm1, %xmm3 # xmm3 = xmm1[2,3,2,3]
movd %xmm3, (%rbx,%r8,4)
psllq $0x18, %xmm2
pcmpeqb %xmm0, %xmm2
pxor %xmm0, %xmm2
pextrw $0x3, %xmm2, %r8d
testb $0x1, %r8b
je 0x47156
shrl $0x18, %edx
movsbq %dl, %rdx
pshufd $0xff, %xmm1, %xmm1 # xmm1 = xmm1[3,3,3,3]
movd %xmm1, (%rbx,%rdx,4)
addq $0x4, %rcx
cmpq $0x14, %rcx
jne 0x47098
cmpl $0x81, %r13d
jb 0x47312
movl 0x30(%rsp), %r10d
movl 0x34(%rsp), %edi
leaq 0xbc(%rsp), %r15
movl %r10d, -0x1c(%r15)
movl %edi, -0x18(%r15)
movl 0x38(%rsp), %ebp
movl %ebp, -0x14(%r15)
movl 0x3c(%rsp), %r13d
movl %r13d, -0x10(%r15)
movq 0x10(%rsp), %rax
shll $0x4, %eax
leaq 0x19386(%rip), %rcx # 0x60530
leaq (%rax,%rcx), %r8
addq $0x4, %r8
movl $0xf, %eax
xorl %r9d, %r9d
cmpb $0x0, (%r8,%r9)
je 0x47220
movl %r10d, %esi
movl %eax, %ecx
shll %cl, %esi
movl %eax, %edx
andb $0x1f, %dl
negb %dl
movl %edi, %r14d
movl %edx, %ecx
shrl %cl, %r14d
movl %edi, %r11d
movl %eax, %ecx
shll %cl, %r11d
movl %ebp, %r12d
movl %edx, %ecx
shrl %cl, %r12d
xorl %esi, %r14d
movl %r14d, -0xc(%r15)
movl %ebp, %esi
movl %eax, %ecx
shll %cl, %esi
movl %r13d, %r14d
movl %edx, %ecx
shrl %cl, %r14d
xorl %r11d, %r12d
movl %r12d, -0x8(%r15)
movl %r13d, %r11d
movl %eax, %ecx
shll %cl, %r11d
movl %r10d, %r12d
movl %edx, %ecx
shrl %cl, %r12d
xorl %esi, %r14d
movl %r14d, -0x4(%r15)
xorl %r11d, %r12d
movl %r12d, (%r15)
incq %r9
addq $0x10, %r15
addl $0xf, %eax
cmpq $0x4, %r9
jne 0x471ba
movq 0x18(%rsp), %rax
shll $0x4, %eax
leaq 0x18a51(%rip), %rcx # 0x5fc90
addq %rcx, %rax
addq $0x14, %rax
xorl %ecx, %ecx
pcmpeqd %xmm0, %xmm0
movl 0xc(%rsp), %r13d
movd (%rax,%rcx), %xmm2
movdqa %xmm2, %xmm3
pcmpeqb %xmm0, %xmm3
movdqa 0xa0(%rsp,%rcx,4), %xmm1
movd %xmm3, %esi
notb %sil
movd %xmm2, %edx
testb $0x1, %sil
je 0x47281
movsbq %dl, %rsi
movd %xmm1, (%rbx,%rsi,4)
movdqa %xmm2, %xmm3
pslld $0x8, %xmm3
pcmpeqb %xmm0, %xmm3
pxor %xmm0, %xmm3
pextrw $0x1, %xmm3, %esi
testb $0x1, %sil
je 0x472b0
movl %edx, %esi
shrl $0x8, %esi
movsbq %sil, %rsi
pshufd $0x55, %xmm1, %xmm3 # xmm3 = xmm1[1,1,1,1]
movd %xmm3, (%rbx,%rsi,4)
pshuflw $0x55, %xmm2, %xmm3 # xmm3 = xmm2[1,1,1,1,4,5,6,7]
pcmpeqb %xmm0, %xmm3
pxor %xmm0, %xmm3
pextrw $0x2, %xmm3, %esi
testb $0x1, %sil
je 0x472db
movl %edx, %esi
shrl $0x10, %esi
movsbq %sil, %rsi
pshufd $0xee, %xmm1, %xmm3 # xmm3 = xmm1[2,3,2,3]
movd %xmm3, (%rbx,%rsi,4)
psllq $0x18, %xmm2
pcmpeqb %xmm0, %xmm2
pxor %xmm0, %xmm2
pextrw $0x3, %xmm2, %esi
testb $0x1, %sil
je 0x47304
shrl $0x18, %edx
movsbq %dl, %rdx
pshufd $0xff, %xmm1, %xmm1 # xmm1 = xmm1[3,3,3,3]
movd %xmm1, (%rbx,%rdx,4)
addq $0x4, %rcx
cmpq $0x14, %rcx
jne 0x47251
movl 0x40(%rsp), %r10d
movl 0x44(%rsp), %r11d
movl %r10d, 0xa0(%rsp)
movl %r11d, 0xa4(%rsp)
movl 0x48(%rsp), %r15d
movl %r15d, 0xa8(%rsp)
movl 0x4c(%rsp), %r12d
movl %r12d, 0xac(%rsp)
movq 0x10(%rsp), %rax
shll $0x4, %eax
leaq 0x191db(%rip), %rcx # 0x60530
leaq (%rax,%rcx), %r8
addq $0x8, %r8
movl $0x1c, %r9d
movl $0xf, %eax
cmpb $0x0, (%r8)
je 0x473d9
movl %r10d, %esi
movl %eax, %ecx
shll %cl, %esi
movl %eax, %edx
andb $0x1f, %dl
negb %dl
movl %r11d, %edi
movl %edx, %ecx
shrl %cl, %edi
movl %r11d, %ebp
movl %eax, %ecx
shll %cl, %ebp
movl %r15d, %r14d
movl %edx, %ecx
shrl %cl, %r14d
xorl %esi, %edi
movl %edi, 0x94(%rsp,%r9)
movl %r15d, %esi
movl %eax, %ecx
shll %cl, %esi
movl %r12d, %edi
movl %edx, %ecx
shrl %cl, %edi
xorl %ebp, %r14d
movl %r14d, 0x98(%rsp,%r9)
movl %r12d, %ebp
movl %eax, %ecx
shll %cl, %ebp
movl %r10d, %r14d
movl %edx, %ecx
shrl %cl, %r14d
xorl %esi, %edi
movl %edi, 0x9c(%rsp,%r9)
xorl %ebp, %r14d
movl %r14d, 0xa0(%rsp,%r9)
addq $0x10, %r9
incq %r8
addl $0xf, %eax
cmpq $0x5c, %r9
jne 0x47368
movq 0x18(%rsp), %rax
shll $0x4, %eax
leaq 0x18894(%rip), %rcx # 0x5fc90
addq %rcx, %rax
addq $0x28, %rax
xorl %ecx, %ecx
pcmpeqd %xmm0, %xmm0
movq 0x68(%rsp), %rdi
movd (%rax,%rcx), %xmm2
movdqa %xmm2, %xmm3
pcmpeqb %xmm0, %xmm3
movdqa 0xa0(%rsp,%rcx,4), %xmm1
movd %xmm3, %esi
notb %sil
movd %xmm2, %edx
testb $0x1, %sil
je 0x4743e
movsbq %dl, %rsi
movd %xmm1, (%rbx,%rsi,4)
movdqa %xmm2, %xmm3
pslld $0x8, %xmm3
pcmpeqb %xmm0, %xmm3
pxor %xmm0, %xmm3
pextrw $0x1, %xmm3, %esi
testb $0x1, %sil
je 0x4746d
movl %edx, %esi
shrl $0x8, %esi
movsbq %sil, %rsi
pshufd $0x55, %xmm1, %xmm3 # xmm3 = xmm1[1,1,1,1]
movd %xmm3, (%rbx,%rsi,4)
pshuflw $0x55, %xmm2, %xmm3 # xmm3 = xmm2[1,1,1,1,4,5,6,7]
pcmpeqb %xmm0, %xmm3
pxor %xmm0, %xmm3
pextrw $0x2, %xmm3, %esi
testb $0x1, %sil
je 0x47498
movl %edx, %esi
shrl $0x10, %esi
movsbq %sil, %rsi
pshufd $0xee, %xmm1, %xmm3 # xmm3 = xmm1[2,3,2,3]
movd %xmm3, (%rbx,%rsi,4)
psllq $0x18, %xmm2
pcmpeqb %xmm0, %xmm2
pxor %xmm0, %xmm2
pextrw $0x3, %xmm2, %esi
testb $0x1, %sil
je 0x474c1
shrl $0x18, %edx
movsbq %dl, %rdx
pshufd $0xff, %xmm1, %xmm1 # xmm1 = xmm1[3,3,3,3]
movd %xmm1, (%rbx,%rdx,4)
addq $0x4, %rcx
cmpq $0x14, %rcx
jne 0x4740e
cmpl $0x81, %r13d
jb 0x4767a
movl 0x50(%rsp), %r10d
movl 0x54(%rsp), %r11d
leaq 0xbc(%rsp), %r15
movl %r10d, -0x1c(%r15)
movl %r11d, -0x18(%r15)
movl 0x58(%rsp), %ebp
movl %ebp, -0x14(%r15)
movl 0x5c(%rsp), %r12d
movl %r12d, -0x10(%r15)
movq 0x10(%rsp), %rax
shll $0x4, %eax
leaq 0x1901a(%rip), %rcx # 0x60530
leaq (%rax,%rcx), %r8
addq $0xc, %r8
movl $0xf, %eax
xorl %r9d, %r9d
cmpb $0x0, (%r8,%r9)
je 0x47588
movl %r10d, %esi
movl %eax, %ecx
shll %cl, %esi
movl %eax, %edx
andb $0x1f, %dl
negb %dl
movl %r11d, %edi
movl %edx, %ecx
shrl %cl, %edi
movl %r11d, %r14d
movl %eax, %ecx
shll %cl, %r14d
movl %ebp, %r13d
movl %edx, %ecx
shrl %cl, %r13d
xorl %esi, %edi
movl %edi, -0xc(%r15)
movl %ebp, %esi
movl %eax, %ecx
shll %cl, %esi
movl %r12d, %edi
movl %edx, %ecx
shrl %cl, %edi
xorl %r14d, %r13d
movl %r13d, -0x8(%r15)
movl %r12d, %r14d
movl %eax, %ecx
shll %cl, %r14d
movl %r10d, %r13d
movl %edx, %ecx
shrl %cl, %r13d
xorl %esi, %edi
movl %edi, -0x4(%r15)
xorl %r14d, %r13d
movl %r13d, (%r15)
incq %r9
addq $0x10, %r15
addl $0xf, %eax
cmpq $0x4, %r9
jne 0x47526
movq 0x18(%rsp), %rax
shll $0x4, %eax
leaq 0x186e9(%rip), %rcx # 0x5fc90
addq %rcx, %rax
addq $0x3c, %rax
xorl %ecx, %ecx
pcmpeqd %xmm0, %xmm0
movq 0x68(%rsp), %rdi
movd (%rax,%rcx), %xmm2
movdqa %xmm2, %xmm3
pcmpeqb %xmm0, %xmm3
movdqa 0xa0(%rsp,%rcx,4), %xmm1
movd %xmm3, %esi
notb %sil
movd %xmm2, %edx
testb $0x1, %sil
je 0x475e9
movsbq %dl, %rsi
movd %xmm1, (%rbx,%rsi,4)
movdqa %xmm2, %xmm3
pslld $0x8, %xmm3
pcmpeqb %xmm0, %xmm3
pxor %xmm0, %xmm3
pextrw $0x1, %xmm3, %esi
testb $0x1, %sil
je 0x47618
movl %edx, %esi
shrl $0x8, %esi
movsbq %sil, %rsi
pshufd $0x55, %xmm1, %xmm3 # xmm3 = xmm1[1,1,1,1]
movd %xmm3, (%rbx,%rsi,4)
pshuflw $0x55, %xmm2, %xmm3 # xmm3 = xmm2[1,1,1,1,4,5,6,7]
pcmpeqb %xmm0, %xmm3
pxor %xmm0, %xmm3
pextrw $0x2, %xmm3, %esi
testb $0x1, %sil
je 0x47643
movl %edx, %esi
shrl $0x10, %esi
movsbq %sil, %rsi
pshufd $0xee, %xmm1, %xmm3 # xmm3 = xmm1[2,3,2,3]
movd %xmm3, (%rbx,%rsi,4)
psllq $0x18, %xmm2
pcmpeqb %xmm0, %xmm2
pxor %xmm0, %xmm2
pextrw $0x3, %xmm2, %esi
testb $0x1, %sil
je 0x4766c
shrl $0x18, %edx
movsbq %dl, %rdx
pshufd $0xff, %xmm1, %xmm1 # xmm1 = xmm1[3,3,3,3]
movd %xmm1, (%rbx,%rdx,4)
addq $0x4, %rcx
cmpq $0x14, %rcx
jne 0x475b9
movq 0x10(%rsp), %rcx
leaq (%rcx,%rcx,2), %rax
shll $0x4, %eax
addq %rdi, %rax
addq $0x84, %rax
shll $0x2, %ecx
leaq (%rcx,%rcx,4), %rcx
xorl %edx, %edx
leaq 0x18691(%rip), %rsi # 0x5fd30
leaq (%rcx,%rdx), %rdi
movsbq (%rsi,%rdi), %rdi
cmpq $-0x1, %rdi
je 0x476b4
movl (%rbx,%rdi,4), %edi
movl %edi, (%rax,%rdx,4)
incq %rdx
cmpq $0x14, %rdx
jne 0x4769f
xorl %eax, %eax
addq $0x138, %rsp # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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( use_size * 8 > grp->nbits )
MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( x, use_size * 8 - grp->nbits ) );
/* While at it, reduce modulo N */
if( mbedtls_mpi_cmp_mpi( x, &grp->N ) >= 0 )
MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( x, x, &grp->N ) );
cleanup:
return( ret );
} | 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 0x48c9a
movq %r14, %rdi
movq %r15, %rsi
callq 0x268af
testl %eax, %eax
jne 0x48c78
addq $0x98, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x26a39
testl %eax, %eax
js 0x48cc3
movq %r14, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x26dbf
xorl %eax, %eax
jmp 0x48c78
| /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];
size_t grp_len = ( grp->nbits + 7 ) / 8;
const mbedtls_md_info_t *md_info;
mbedtls_mpi h;
if( ( md_info = mbedtls_md_info_from_type( md_alg ) ) == NULL )
return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
mbedtls_mpi_init( &h );
mbedtls_hmac_drbg_init( &rng_ctx );
/* Use private key and message hash (reduced) to initialize HMAC_DRBG */
MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( d, data, grp_len ) );
MBEDTLS_MPI_CHK( derive_mpi( grp, &h, buf, blen ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( &h, data + grp_len, grp_len ) );
mbedtls_hmac_drbg_seed_buf( &rng_ctx, md_info, data, 2 * grp_len );
ret = mbedtls_ecdsa_sign( grp, r, s, d, buf, blen,
mbedtls_hmac_drbg_random, &rng_ctx );
cleanup:
mbedtls_hmac_drbg_free( &rng_ctx );
mbedtls_mpi_free( &h );
return( ret );
} | 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
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
addq $0x7, %r12
shrq $0x3, %r12
leaq 0x28(%rsp), %rdi
callq 0x258f8
leaq 0xc8(%rsp), %r14
movq %r14, %rdi
callq 0x4931c
leaq 0x40(%rsp), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x26734
testl %eax, %eax
jne 0x48dc4
leaq 0x28(%rsp), %rsi
movq %rbp, %rdi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x48c45
testl %eax, %eax
jne 0x48dc4
leaq (%rsp,%r12), %rsi
addq $0x40, %rsi
leaq 0x28(%rsp), %rdi
movq %r12, %rdx
callq 0x26734
testl %eax, %eax
jne 0x48dc4
addq %r12, %r12
leaq 0x40(%rsp), %rdx
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rcx
callq 0x49420
leaq 0x99f(%rip), %rax # 0x4973d
movq %rbp, %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %r15, %rcx
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %r9
pushq %r14
pushq %rax
callq 0x48950
addq $0x10, %rsp
movl %eax, %ebx
leaq 0xc8(%rsp), %rdi
callq 0x49747
leaq 0x28(%rsp), %rdi
callq 0x2590b
jmp 0x48de4
movl $0xffffb080, %ebx # imm = 0xFFFFB080
movl %ebx, %eax
addq $0x148, %rsp # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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_drbg_random_with_add( ctx, output, out_len, NULL, 0 );
#if defined(MBEDTLS_THREADING_C)
if( mbedtls_mutex_unlock( &ctx->mutex ) != 0 )
return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
#endif
return( ret );
} | 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.
//
if( *p - start < 1 )
return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
len += 1;
*--(*p) = val;
if( val > 0 && **p & 0x80 )
{
if( *p - start < 1 )
return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
*--(*p) = 0x00;
len += 1;
}
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_INTEGER ) );
return( (int) len );
} | 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
movq (%r14), %rax
cmpb $0x0, (%rax)
jns 0x4ae8e
movq %rax, %rcx
subq %r15, %rcx
testq %rcx, %rcx
jle 0x4aec3
leaq -0x1(%rax), %rcx
movq %rcx, (%r14)
movb $0x0, -0x1(%rax)
movl $0x2, %r12d
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4a9ec
testl %eax, %eax
js 0x4aec1
movq (%r14), %rcx
movq %rcx, %rdx
subq %r15, %rdx
testq %rdx, %rdx
jle 0x4aec3
leaq -0x1(%rcx), %rdx
movq %rdx, (%r14)
movb $0x2, -0x1(%rcx)
leal (%r12,%rax), %ebx
incl %ebx
jmp 0x4aec3
movl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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(%rdi)
vmovups %zmm0, 0x100(%rdi)
vmovups %zmm0, 0xc0(%rdi)
vmovups %zmm0, 0x80(%rdi)
movq $0x4, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movl $0x5, %eax
movq %rax, 0x40(%rdi)
movq %rcx, 0x48(%rdi)
leaq 0x1629b(%rip), %rcx # 0x2085c
movq %rax, 0x50(%rdi)
movq %rcx, 0x58(%rdi)
movq %r14, %rdi
vzeroupper
callq 0x3180
vxorps %xmm0, %xmm0, %xmm0
leaq 0x1e8(%rbx), %r12
leaq 0x318(%rbx), %rdi
movb $0x0, 0x208(%rbx)
vmovups %ymm0, 0x1e8(%rbx)
vxorps %xmm0, %xmm0, %xmm0
movq $0x0, 0x310(%rbx)
vmovups %zmm0, 0x210(%rbx)
vmovups %zmm0, 0x250(%rbx)
vmovups %zmm0, 0x290(%rbx)
vmovups %zmm0, 0x2d0(%rbx)
xorl %esi, %esi
xorl %edx, %edx
vzeroupper
callq 0x1dce6
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x339(%rbx)
vmovups %xmm0, 0x330(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%r12), %rdi
movq %rax, %r15
testq %rdi, %rdi
je 0xa673
movq 0x1f8(%rbx), %rsi
subq %rdi, %rsi
callq 0x3230
movq 0x1f91e(%rip), %rsi # 0x29f98
movq %r14, %rdi
callq 0x31c0
addq $0xe0, %rbx
movq %rbx, %rdi
callq 0x3090
movq %r15, %rdi
callq 0x3390
nop
| /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)
je 0xa6ed
movq %rax, 0x1f0(%rbx)
cmpb $0x0, 0x348(%rbx)
jne 0xa6fe
movq %rbx, %rdi
callq 0x1deee
testb %bpl, %bpl
jne 0xa70d
cmpq $0x0, 0x210(%rbx)
jne 0xa787
movq 0x330(%rbx), %rdi
testq %rdi, %rdi
je 0xa728
movq 0x340(%rbx), %rsi
subq %rdi, %rsi
callq 0x3230
movq 0x318(%rbx), %rdi
testq %rdi, %rdi
je 0xa743
movq 0x328(%rbx), %rsi
subq %rdi, %rsi
callq 0x3230
movq 0x1e8(%rbx), %rdi
testq %rdi, %rdi
je 0xa75e
movq 0x1f8(%rbx), %rsi
subq %rdi, %rsi
callq 0x3230
movq 0x1f833(%rip), %rsi # 0x29f98
leaq 0x60(%rbx), %rdi
callq 0x31c0
addq $0xe0, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3090
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
callq 0x3290
jmp 0xa793
movq %rax, %rdi
callq 0xa883
nop
| /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.location.file_name()) << ':'
<< assertion.location.line() << ':' << printer_.colors().fail
<< "FAILED" << printer_.colors().none << " [" << std::boolalpha
<< assertion.expr << printer_.colors().none << ']';
++asserts_.fail;
} | 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, %rcx
subq $0x1, %rcx
jb 0xa982
cmpb $0x2f, -0x1(%r15,%rdx)
movq %rcx, %rdx
jne 0xa948
addq %rax, %r15
negq %rax
xorl %edx, %edx
movq %rdx, %rcx
cmpq %rdx, %rax
je 0xa975
cmpb $0x2f, -0x1(%r15,%rcx)
leaq -0x1(%rcx), %rdx
jne 0xa961
addq %rcx, %r15
negq %rcx
movq %rcx, %rax
jmp 0xa982
xorl %eax, %eax
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x3270
movb $0x3a, %bpl
leaq 0xd(%rsp), %rsi
movl $0x1, %edx
movq %r14, %rdi
movb %bpl, (%rsi)
callq 0x3270
movl 0x10(%r12), %esi
movq %r14, %rdi
callq 0x3380
leaq 0xe(%rsp), %rsi
movl $0x1, %edx
movq %r14, %rdi
movb %bpl, (%rsi)
callq 0x3270
movq 0x50(%rbx), %rdx
movq 0x58(%rbx), %rsi
movq %r14, %rdi
callq 0x3270
leaq 0x15278(%rip), %rsi # 0x1fc59
movl $0x6, %edx
movq %r14, %rdi
callq 0x3270
movq 0x30(%rbx), %rdx
movq 0x38(%rbx), %rsi
movq %r14, %rdi
callq 0x3270
leaq 0x1525b(%rip), %rsi # 0x1fc60
movl $0x2, %edx
movq %r14, %rdi
callq 0x3270
movq 0x70(%rbx), %rax
movq %r14, %rdi
movq -0x18(%rax), %rax
orl $0x1, 0x88(%rbx,%rax)
movzbl (%r12), %esi
callq 0x3350
movq 0x30(%rbx), %rdx
movq 0x38(%rbx), %rsi
movq %r14, %rdi
callq 0x3270
leaq 0xf(%rsp), %rsi
movl $0x1, %edx
movq %r14, %rdi
movb $0x5d, (%rsi)
callq 0x3270
incq 0x20(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
| /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;
}
}
return true;
} | 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 (%rbx,%r8), %rdi
movq 0x8(%rbx,%r8), %rsi
movq 0x8(%rcx,%r8), %rcx
callq 0xae85
testb %al, %al
je 0xafa5
movq (%r15), %rcx
movq 0x8(%r15), %rdx
movl %ebp, %r8d
subq %rcx, %rdx
sarq $0x4, %rdx
cmpq %r14, %rdx
cmovaeq %r14, %rdx
incl %ebp
cmpq %r8, %rdx
ja 0xaf63
jmp 0xafa5
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /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" << printer_.colors().none
<< '\n';
}
} | 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
callq 0x3270
leaq 0x14bdf(%rip), %rsi # 0x1fc59
movl $0x6, %edx
movq %rbx, %rdi
callq 0x3270
movq 0x30(%r14), %rdx
movq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x3270
leaq 0xe(%rsp), %rsi
movb %bpl, (%rsi)
jmp 0xb0e0
incq (%r14)
movq %rbx, %rdi
movq 0x40(%r14), %rdx
movq 0x48(%r14), %rsi
callq 0x3270
leaq 0x14c71(%rip), %rsi # 0x1fd2c
movl $0x6, %edx
movq %rbx, %rdi
callq 0x3270
movq 0x30(%r14), %rdx
movq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x3270
leaq 0xf(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x3270
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| /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_tag, double>::item>>>, __gnu_cxx::__ops::_Iter_less_iter>(__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_tag, double>::item>>>, __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_tag, double>::item>>>, __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_tag, double>::item>>>, __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_tag, double>::item>>>, __gnu_cxx::__ops::_Iter_less_iter) | 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>(factor)) <
(r / static_cast<Float>(factor));
} | 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), %xmm4, %xmm4
vunpcklpd %xmm1, %xmm2, %xmm1 # xmm1 = xmm2[0],xmm1[0]
vmovddup %xmm4, %xmm4 # xmm4 = xmm4[0,0]
vdivpd %xmm4, %xmm1, %xmm1
vshufpd $0x1, %xmm1, %xmm1, %xmm4 # xmm4 = xmm1[1,0]
vucomisd %xmm1, %xmm4
ja 0xbf9c
vdivsd %xmm0, %xmm2, %xmm0
vucomisd %xmm0, %xmm3
jbe 0xbf40
jmp 0xbf7c
vdivsd %xmm0, %xmm2, %xmm0
vucomisd %xmm0, %xmm3
jbe 0xbf60
vmovups (%rdi), %ymm0
vmovups %ymm0, -0x28(%rsp)
vmovups (%rsi), %ymm0
vmovups %ymm0, (%rdi)
vmovups -0x28(%rsp), %ymm0
vmovups %ymm0, (%rsi)
vzeroupper
retq
vcvtsi2sdl 0x10(%rdx), %xmm4, %xmm0
vunpcklpd %xmm1, %xmm2, %xmm1 # xmm1 = xmm2[0],xmm1[0]
vmovddup %xmm0, %xmm0 # xmm0 = xmm0[0,0]
vdivpd %xmm0, %xmm1, %xmm0
vshufpd $0x1, %xmm0, %xmm0, %xmm1 # xmm1 = xmm0[1,0]
vucomisd %xmm0, %xmm1
jbe 0xbf9c
vmovups (%rdi), %ymm0
vmovups %ymm0, -0x28(%rsp)
vmovups (%rcx), %ymm0
vmovups %ymm0, (%rdi)
vmovups -0x28(%rsp), %ymm0
vmovups %ymm0, (%rcx)
vzeroupper
retq
vmovups (%rdi), %ymm0
vmovups %ymm0, -0x28(%rsp)
vmovups (%rdx), %ymm0
vmovups %ymm0, (%rdi)
vmovups -0x28(%rsp), %ymm0
vmovups %ymm0, (%rdx)
vzeroupper
retq
| /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;
detail::vformat_to(buffer, format_str, args);
return to_string(buffer);
} | 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(%r14) # imm = 0x1F4
leaq 0x10(%rsp), %rdi
xorl %r9d, %r9d
callq 0xd97e
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x1d802
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0xd6cd
movq 0x28(%rsp), %rsi
callq 0x3230
movq %rbx, %rax
addq $0x230, %rsp # imm = 0x230
popq %rbx
popq %r14
popq %r15
retq
testq %rcx, %rcx
js 0xd6ec
andl $0xf, %ecx
jne 0xd700
jmp 0xd882
testl %ecx, %ecx
jle 0xd882
movl 0x10(%r8), %ecx
testl %ecx, %ecx
je 0xd882
movq (%r8), %rdx
movq 0x8(%r8), %rax
decl %ecx
cmpl $0xe, %ecx
ja 0xd893
leaq 0x121a7(%rip), %rsi # 0x1f8c0
movslq (%rsi,%rcx,4), %rcx
addq %rsi, %rcx
jmpq *%rcx
movq %rbx, %rdi
movl %edx, %esi
callq 0xddbb
jmp 0xd6cd
leaq 0xf(%rsp), %rsi
movq %rbx, %rdi
movq %rax, %rcx
callq 0xdd00
jmp 0xd6cd
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %rdx, (%rsi)
callq 0x136e0
jmp 0xd6cd
movq %rdx, %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0xe204
jmp 0xd6cd
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %rdx, (%rsi)
movq %rax, 0x8(%rsi)
callq 0x137c4
jmp 0xd6cd
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %rdx, (%rsi)
callq 0xfb18
jmp 0xd6cd
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xe049
jmp 0xd6cd
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xe131
jmp 0xd6cd
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movb %dl, 0x10(%rbx)
movq $0x1, 0x8(%rbx)
movb $0x0, 0x11(%rbx)
jmp 0xd6cd
movq %rbx, %rdi
movl %edx, %esi
callq 0xdf8c
jmp 0xd6cd
movq %rdx, %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0xe459
jmp 0xd6cd
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %rdx, (%rsi)
callq 0x13834
jmp 0xd6cd
movzbl %dl, %r14d
leaq 0x12957(%rip), %rax # 0x2016a
leaq 0x12955(%rip), %rsi # 0x2016f
leaq 0x10(%rsp), %r15
andl $0x1, %r14d
movq %r15, %rdi
xorq $0x5, %r14
testb $0x1, %dl
cmovneq %rax, %rsi
movq %r14, %rdx
callq 0x31e0
leaq 0x10(%rsp,%r14), %rdx
leaq 0x10(%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, (%rbx)
callq 0xdeb0
jmp 0xd6cd
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %rdx, (%rsi)
movw %ax, 0x8(%rsi)
callq 0x10fed
jmp 0xd6cd
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movl %edx, (%rsi)
callq 0xe68a
jmp 0xd6cd
leaq 0x127f5(%rip), %rsi # 0x2007e
leaq 0x10(%rsp), %rdi
callq 0xd936
leaq 0x10(%rbx), %rax
leaq 0x127f3(%rip), %rdi # 0x20091
leaq 0x13058(%rip), %rdx # 0x208fd
movl $0x7d7, %esi # imm = 0x7D7
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
callq 0xde89
movq 0x18(%rsp), %rdi
movq %rax, %rbx
cmpq %r14, %rdi
je 0xd8d5
movq 0x28(%rsp), %rsi
callq 0x3230
movq %rbx, %rdi
callq 0x3390
nop
| /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, -0x18(%r14)
movq %r8, (%rdx)
movq %rdi, 0x8(%rdx)
movq $0x1f4, -0x8(%r14) # imm = 0x1F4
vmovaps %xmm0, (%rsi)
movl $0x0, 0x10(%rsi)
movq %rdi, 0x18(%rdx)
movq %rax, %rdi
callq *%rcx
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x1d802
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0xdd8e
movq 0x58(%rsp), %rsi
callq 0x3230
movq %rbx, %rax
addq $0x258, %rsp # imm = 0x258
popq %rbx
popq %r14
retq
movq 0x48(%rsp), %rdi
movq %rax, %rbx
cmpq %r14, %rdi
je 0xddb3
movq 0x58(%rsp), %rsi
callq 0x3230
movq %rbx, %rdi
callq 0x3390
| /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, detail::write<char>(begin, value));
} | 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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.