name string | code string | asm string | file string |
|---|---|---|---|
u64Parity | bool_t u64Parity(register u64 w)
{
w ^= w >> 1;
w ^= w >> 2;
w ^= w >> 4;
w ^= w >> 8;
w ^= w >> 16;
w ^= w >> 32;
return (bool_t)(w & U64_1);
} | movq %rdi, %rax
shrq %rax
xorq %rdi, %rax
movq %rax, %rcx
shrq $0x2, %rcx
xorq %rax, %rcx
movq %rcx, %rax
shrq $0x4, %rax
xorq %rcx, %rax
movq %rax, %rcx
shrq $0x8, %rcx
xorq %rax, %rcx
movq %rcx, %rdx
shrq $0x10, %rdx
xorq %rcx, %rdx
movq %rdx, %rax
shrq $0x20, %rax
xorl %edx, %eax
andl $0x1, %eax
retq
| /agievich[P]bee2/src/core/u64.c |
u64CTZ_fast | size_t FAST(u64CTZ)(register u64 w)
{
register size_t l = 64;
register u64 t;
if (t = w << 32)
l -= 32, w = t;
if (t = w << 16)
l -= 16, w = t;
if (t = w << 8)
l -= 8, w = t;
if (t = w << 4)
l -= 4, w = t;
if (t = w << 2)
l -= 2, w = t;
t = 0;
return ((u64)(w << 1)) ? l - 2 : l - (w ? 1 : 0);
} | xorl %eax, %eax
movq %rdi, %rcx
shlq $0x20, %rcx
sete %al
cmoveq %rdi, %rcx
shll $0x5, %eax
leaq 0x20(%rax), %rdx
movq %rcx, %rsi
shlq $0x10, %rsi
orq $0x10, %rax
testq %rsi, %rsi
cmoveq %rcx, %rsi
cmoveq %rdx, %rax
movq %rsi, %rcx
shlq $0x8, %rcx
leaq -0x8(%rax), %rdx
testq %rcx, %rcx
cmoveq %rsi, %rcx
cmoveq %rax, %r... | /agievich[P]bee2/src/core/u64.c |
u64CLZ_fast | size_t FAST(u64CLZ)(register u64 w)
{
register size_t l = 64;
register u64 t;
if (t = w >> 32)
l -= 32, w = t;
if (t = w >> 16)
l -= 16, w = t;
if (t = w >> 8)
l -= 8, w = t;
if (t = w >> 4)
l -= 4, w = t;
if (t = w >> 2)
l -= 2, w = t;
t = 0;
return (w >> 1) ? l - 2 : l - (w ? 1 : 0);
} | xorl %eax, %eax
movq %rdi, %rcx
shrq $0x20, %rcx
sete %al
cmoveq %rdi, %rcx
shll $0x5, %eax
leaq 0x20(%rax), %rdx
movq %rcx, %rsi
shrq $0x10, %rsi
orq $0x10, %rax
cmpq $0x10000, %rcx # imm = 0x10000
cmovbq %rcx, %rsi
cmovbq %rdx, %rax
movq %rsi, %rcx
shrq $0x8, %rcx
leaq -0x8(%rax), %rdx
cmpq $0x100, %rsi ... | /agievich[P]bee2/src/core/u64.c |
u64Shuffle | u64 u64Shuffle(register u64 w)
{
register u64 t;
t = (w ^ (w >> 16)) & 0x00000000FFFF0000, w ^= t ^ (t << 16);
t = (w ^ (w >> 8)) & 0x0000FF000000FF00, w ^= t ^ (t << 8);
t = (w ^ (w >> 4)) & 0x00F000F000F000F0, w ^= t ^ (t << 4);
t = (w ^ (w >> 2)) & 0x0C0C0C0C0C0C0C0C, w ^= t ^ (t << 2);
t = (w ^ (w >> 1)) & 0x... | movq %rdi, %rax
shrq $0x10, %rax
xorl %edi, %eax
andl $0xffff0000, %eax # imm = 0xFFFF0000
imulq $0x10001, %rax, %rax # imm = 0x10001
xorq %rdi, %rax
movq %rax, %rcx
shrq $0x8, %rcx
xorq %rax, %rcx
movabsq $0xff000000ff00, %rdx # imm = 0xFF000000FF00
andq %rcx, %rdx
imulq $0x101, %rdx, %rcx # imm = 0x10... | /agievich[P]bee2/src/core/u64.c |
u64Deshuffle | u64 u64Deshuffle(register u64 w)
{
register u64 t;
t = (w ^ (w >> 1 )) & 0x2222222222222222, w ^= t ^ (t << 1);
t = (w ^ (w >> 2 )) & 0x0C0C0C0C0C0C0C0C, w ^= t ^ (t << 2);
t = (w ^ (w >> 4 )) & 0x00F000F000F000F0, w ^= t ^ (t << 4);
t = (w ^ (w >> 8 )) & 0x0000FF000000FF00, w ^= t ^ (t << 8);
t = (w ^ (w >> 16))... | movq %rdi, %rax
shrq %rax
xorq %rdi, %rax
movabsq $0x2222222222222222, %rcx # imm = 0x2222222222222222
andq %rax, %rcx
leaq (%rcx,%rcx,2), %rax
xorq %rdi, %rax
movq %rax, %rcx
shrq $0x2, %rcx
xorq %rax, %rcx
movabsq $0xc0c0c0c0c0c0c0c, %rdx # imm = 0xC0C0C0C0C0C0C0C
andq %rcx, %rdx
leaq (%rdx,%rdx,4), %rcx
xorq %rax, %... | /agievich[P]bee2/src/core/u64.c |
u64NegInv | u64 u64NegInv(register u64 w)
{
register u64 ret = w;
ASSERT(w & 1);
ret = ret * (w * ret + 2);
ret = ret * (w * ret + 2);
ret = ret * (w * ret + 2);
ret = ret * (w * ret + 2);
ret = ret * (w * ret + 2);
ret = ret * (w * ret + 2);
w = 0;
return ret;
} | movq %rdi, %rax
imulq %rdi, %rax
orq $0x2, %rax
imulq %rdi, %rax
movq %rax, %rcx
imulq %rdi, %rcx
addq $0x2, %rcx
imulq %rax, %rcx
movq %rcx, %rax
imulq %rdi, %rax
addq $0x2, %rax
imulq %rcx, %rax
movq %rax, %rcx
imulq %rdi, %rcx
addq $0x2, %rcx
imulq %rax, %rcx
movq %rcx, %rdx
imulq %rdi, %rdx
addq $0x2, %rdx
imulq %r... | /agievich[P]bee2/src/core/u64.c |
u64From | void u64From(u64 dest[], const void* src, size_t count)
{
ASSERT(memIsValid(src, count));
ASSERT(memIsValid(dest, ((count + 7) / 8) * 8));
memMove(dest, src, count);
if (count % 8)
memSetZero((octet*)dest + count, 8 - count % 8);
#if (OCTET_ORDER == BIG_ENDIAN)
for (count = (count + 7) / 8; count--;)
dest[coun... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
callq 0xe130
movq %r14, %rax
andq $0x7, %rax
je 0x14e2d
addq %r14, %rbx
pushq $0x8
popq %rdx
subq %rax, %rdx
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf710
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /agievich[P]bee2/src/core/u64.c |
u64To | void u64To(void* dest, size_t count, const u64 src[])
{
ASSERT(memIsValid(src, (count + 7) / 8 * 8));
ASSERT(memIsValid(dest, count));
memMove(dest, src, count);
#if (OCTET_ORDER == BIG_ENDIAN)
if (count % 8)
{
size_t t = count / 8;
register u64 u = src[t];
for (t *= 8; t < count; ++t, u >>= 8)
((octet*)d... | movq %rsi, %rax
movq %rdx, %rsi
movq %rax, %rdx
jmp 0xe130
nop
| /agievich[P]bee2/src/core/u64.c |
utilMin | size_t utilMin(size_t n, ...)
{
size_t min = SIZE_MAX;
va_list marker;
ASSERT(n > 0);
va_start(marker, n);
while (n--)
{
size_t current = va_arg(marker, size_t);
if (current < min)
min = current;
}
va_end(marker);
return min;
} | subq $0x58, %rsp
leaq -0x60(%rsp), %r10
movq %rsi, 0x8(%r10)
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x14f46
movaps %xmm0, -0x30(%rsp)
movaps %xmm1, -0x20(%rsp)
movaps %xmm2, -0x10(%rsp)
movaps %xmm3, (%rsp)
movaps %xmm4, 0x10(%rsp)
movaps %xmm5, 0x20(%rsp... | /agievich[P]bee2/src/core/util.c |
utilMax | size_t utilMax(size_t n, ...)
{
size_t max = 0;
va_list marker;
ASSERT(n > 0);
va_start(marker, n);
while (n--)
{
size_t current = va_arg(marker, size_t);
if (current > max)
max = current;
}
va_end(marker);
return max;
} | subq $0x58, %rsp
leaq -0x60(%rsp), %r10
movq %rsi, 0x8(%r10)
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x14ff4
movaps %xmm0, -0x30(%rsp)
movaps %xmm1, -0x20(%rsp)
movaps %xmm2, -0x10(%rsp)
movaps %xmm3, (%rsp)
movaps %xmm4, 0x10(%rsp)
movaps %xmm5, 0x20(%rsp... | /agievich[P]bee2/src/core/util.c |
utilFNV32 | u32 utilFNV32(const void* buf, size_t count, u32 state)
{
const octet* octets = (const octet*)buf;
while (count--)
{
state ^= *octets++;
state += (state << 1) + (state << 4) + (state << 7) +
(state << 8) + (state << 24);
}
return state;
} | movl %edx, %eax
xorl %ecx, %ecx
cmpq %rcx, %rsi
je 0x15098
movzbl (%rdi,%rcx), %edx
xorl %edx, %eax
imull $0x1000193, %eax, %eax # imm = 0x1000193
incq %rcx
jmp 0x15082
retq
| /agievich[P]bee2/src/core/util.c |
utilNonce32 | u32 utilNonce32()
{
tm_time_t curtime;
tm_ticks_t curticks;
register u32 state = 2166136261u;
// UNIX-время
curtime = tmTime();
state = utilFNV32(&curtime, sizeof(curtime), state);
// число тактов
curticks = tmTicks();
state = utilFNV32(&curticks, sizeof(curticks), state);
// еще?
return state;
} | pushq %rbp
pushq %rbx
subq $0x18, %rsp
xorl %eax, %eax
callq 0xf0d0
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
pushq $0x8
popq %rbx
movq %rbx, %rsi
movl $0x811c9dc5, %edx # imm = 0x811C9DC5
callq 0xf8b0
movl %eax, %ebp
xorl %eax, %eax
callq 0xedd0
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %rbx, %rsi
movl %ebp, %ed... | /agievich[P]bee2/src/core/util.c |
utilOnExitInit | static void utilOnExitInit()
{
// создать мьютекс
if (!mtMtxCreate(_mtx))
return;
// зарегистрировать обработчик
if (atexit(utilOnExitRun) != 0)
{
mtMtxClose(_mtx);
return;
}
_inited = TRUE;
} | pushq %rax
leaq 0x53428(%rip), %rdi # 0x68510
callq 0xe620
testl %eax, %eax
je 0x15115
leaq 0x1f(%rip), %rdi # 0x15117
callq 0x4cb40
testl %eax, %eax
je 0x1510e
leaq 0x53408(%rip), %rdi # 0x68510
popq %rax
jmp 0xff00
movb $0x1, 0x533f3(%rip) # 0x68508
popq %rax
retq
| /agievich[P]bee2/src/core/util.c |
utilOnExitRun | static void utilOnExitRun(void)
{
size_t pos;
// pre
ASSERT(blobIsValid(_fns));
ASSERT(blobSize(_fns) % sizeof(util_onexit_t) == 0);
// вызвать зарегистрированные функции
for (pos = blobSize(_fns) / sizeof(util_onexit_t); pos--;)
_fns[pos]();
// закрыть список функций
blobClose(_fns), _fns = 0;
// закрыть мь... | pushq %rbx
movq 0x53419(%rip), %rdi # 0x68538
callq 0xe9f0
movq %rax, %rbx
shrq $0x3, %rbx
subq $0x1, %rbx
jb 0x1513f
movq 0x53400(%rip), %rcx # 0x68538
xorl %eax, %eax
callq *(%rcx,%rbx,8)
jmp 0x1512b
movq 0x533f2(%rip), %rdi # 0x68538
callq 0xe920
andq $0x0, 0x533e5(%rip) # 0x68538
leaq 0x533b6(%rip),... | /agievich[P]bee2/src/core/util.c |
bakeKDF | err_t bakeKDF(octet key[32], const octet secret[], size_t secret_len,
const octet iv[], size_t iv_len, size_t num)
{
void* state;
octet* block;
// проверить входные данные
if (!memIsValid(secret, secret_len) ||
!memIsValid(iv, iv_len) ||
!memIsValid(key, 32))
return ERR_BAD_INPUT;
// создать состояние
sta... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movq %r9, 0x20(%rsp)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xeeb0
pushq $0x6d
popq %rbx
testl %eax, %eax
je 0x152b6
movq %r12, %rdi
movq %r15, %rsi
callq 0xee... | /agievich[P]bee2/src/crypto/bake.c |
bakeBMQVStep4 | err_t bakeBMQVStep4(octet out[], const octet in[], const bake_cert* certa,
void* state)
{
err_t code;
bake_bmqv_o* s = (bake_bmqv_o*)state;
size_t n, no;
// стек
word* Qa; /* [2 * n] */
word* Va; /* [2 * n] */
word* t; /* [n / 2 + 1] */
word* sb; /* [n + n / 2 + 1] */
octet* K; /* [no] (совпадает с ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movq %rdx, %rbp
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, %rdi
callq 0xf850
pushq $0x6d
popq %r13
testl %eax, %eax
je 0x160db
movq 0x18(%r14), %rax
movq 0x18(%rax), %rax
movq 0x30(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0... | /agievich[P]bee2/src/crypto/bake.c |
bakeBMQVRunB | err_t bakeBMQVRunB(octet key[32], const bign_params* params,
const bake_settings* settings, const octet privkeyb[],
const bake_cert* certb, const bake_cert* certa,
read_i read, write_i write, void* file)
{
err_t code;
size_t len;
// блоб
blob_t blob;
octet* in; /* [l / 2 + 8] */
octet* out; /* [l / 2] */
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbp
movq %r8, %r12
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
pushq $0x20
popq %rsi
callq 0xeeb0
testl %eax, %eax
je 0x1670f
movq %rbp, 0x20(%rsp)
movq %r14, (%rsp)
movq (%r13), %r14
cmpq $0x80, %r14
je 0x... | /agievich[P]bee2/src/crypto/bake.c |
bakeBSTS_deep | static size_t bakeBSTS_deep(size_t n, size_t f_deep, size_t ec_d,
size_t ec_deep)
{
return utilMax(5,
bakeBSTSStart_deep(n, f_deep, ec_d, ec_deep),
bakeBSTSStep2_deep(n, f_deep, ec_d, ec_deep),
bakeBSTSStep3_deep(n, f_deep, ec_d, ec_deep),
bakeBSTSStep4_deep(n, f_deep, ec_d, ec_deep),
bakeBSTSStep5_deep(n, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r15
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r12
callq 0xf530
pushq $0x2
popq %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe320
movq %rax, 0x50(%rsp)
movq %r12, %rdi
movq %rbp, %rsi
movq %rb... | /agievich[P]bee2/src/crypto/bake.c |
belsGenM0 | err_t belsGenM0(octet m0[], size_t len, gen_i ang, void* ang_state)
{
size_t n, reps;
void* state;
word* f0;
void* stack;
// проверить генератор
if (ang == 0)
return ERR_BAD_ANG;
// проверить входные данные
if ((len != 16 && len != 24 && len != 32) ||
!memIsValid(m0, len))
return ERR_BAD_INPUT;
// созда... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
testq %rdx, %rdx
je 0x1e992
movq %rsi, %rbx
pushq $0x6d
popq %rbp
cmpq $0x20, %rsi
ja 0x1e9ab
movabsq $0x101010000, %rax # imm = 0x101010000
btq %rbx, %rax
jae 0x1e9ab
movq %rdx, %r12
movq %rdi, %r15
movq %rbx,... | /agievich[P]bee2/src/crypto/bels.c |
belsGenMi | err_t belsGenMi(octet mi[], size_t len, const octet m0[], gen_i ang,
void* ang_state)
{
size_t n, reps;
err_t code;
void* state;
word* f0;
word* u;
word* f;
void* stack;
// проверить генератор
if (ang == 0)
return ERR_BAD_ANG;
// проверить входные данные
if ((len != 16 && len != 24 && len != 32) ||
!m... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x20(%rsp)
testq %rcx, %rcx
je 0x1eaec
movq %rsi, %rbx
pushq $0x6d
popq %rbp
cmpq $0x20, %rsi
ja 0x1eb33
movabsq $0x101010000, %rax # imm = 0x101010000
btq %rbx, %rax
jae 0x1eb33
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, ... | /agievich[P]bee2/src/crypto/bels.c |
belsGenMid | err_t belsGenMid(octet mid[], size_t len, const octet m0[], const octet id[],
size_t id_len)
{
size_t n, reps;
void* state;
word* f0;
word* f;
word* u;
void* stack;
// проверить входные данные
if ((len != 16 && len != 24 && len != 32) ||
!memIsValid(m0, len) || !memIsValid(mid, len) ||
!memIsValid(id, i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
pushq $0x6d
popq %rbp
cmpq $0x20, %rsi
ja 0x1ed15
movq %rsi, %rbx
movabsq $0x101010000, %rax # imm = 0x101010000
btq %rsi, %rax
jae 0x1ed15
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r13
movq %rdi, %r12
movq %rdx, %rdi
movq %rbx, %r... | /agievich[P]bee2/src/crypto/bels.c |
belsShare | err_t belsShare(octet si[], size_t count, size_t threshold, size_t len,
const octet s[], const octet m0[], const octet mi[],
gen_i rng, void* rng_state)
{
size_t n, i;
void* state;
word* f;
word* k;
word* c;
void* stack;
// проверить генератор
if (rng == 0)
return ERR_BAD_RNG;
// проверить входные данные... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
cmpq $0x0, 0x98(%rsp)
je 0x1ef8b
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rcx, %rax
andq $-0x9, %rax
cmpq $0x10, %rax
setne %al
cmpq $0x20, %rcx
setne %cl
decq %rdx
pushq $0x6d
popq %rbp
cmpq %rsi, %rdx
jae 0x1ef90
andb %al,... | /agievich[P]bee2/src/crypto/bels.c |
belsShare3 | err_t belsShare3(octet si[], size_t count, size_t threshold, size_t len,
const octet s[])
{
void* state;
err_t code;
// проверить входные данные
if ((len != 16 && len != 24 && len != 32) || !memIsValid(s, len))
return ERR_BAD_INPUT;
// создать состояние
state = blobCreate(belsGenk_keep());
if (state == 0)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
pushq $0x6d
popq %rbp
cmpq $0x20, %rcx
ja 0x1f306
movq %rcx, %r14
movabsq $0x101010000, %rax # imm = 0x101010000
btq %rcx, %rax
jae 0x1f306
movq %r8, %rbx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
movq %r8, %rdi
movq %r14, %rs... | /agievich[P]bee2/src/crypto/bels.c |
belsRecover | err_t belsRecover(octet s[], size_t count, size_t len, const octet si[],
const octet m0[], const octet mi[])
{
size_t n, i, deep;
void* state;
word* f;
word* g;
word* d;
word* u;
word* v;
word* c;
word* t;
void* stack;
// проверить входные данные
if ((len != 16 && len != 24 && len != 32) || count == 0 || ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rcx, %rbp
movq %rdx, %rax
andq $-0x9, %rax
cmpq $0x10, %rax
setne %al
cmpq $0x20, %rdx
setne %cl
pushq $0x6d
popq %r12
testq %rsi, %rsi
je 0x1fa9f
andb %al, %cl
jne 0x1fa9f
movq %r8, %r13
movq %rdx, %r15
movq %rdi, %rbx
movq %r9, 0... | /agievich[P]bee2/src/crypto/bels.c |
belsRecover2 | err_t belsRecover2(octet s[], size_t count, size_t len, const octet si[])
{
size_t n, i, j, deep;
void* state;
word* f;
word* g;
word* d;
word* u;
word* v;
word* c;
word* t;
void* stack;
// проверить входные данные
if ((len != 16 && len != 24 && len != 32) || count == 0 || count > 16 ||
!memIsValid(si, co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rcx, %rbp
movq %rdx, %r15
movq %rdx, %rax
andq $-0x9, %rax
cmpq $0x10, %rax
setne %al
cmpq $0x20, %rdx
setne %cl
leaq -0x11(%rsi), %rdx
pushq $0x6d
popq %r14
cmpq $-0x10, %rdx
jb 0x2017a
andb %al, %cl
jne 0x2017a
movq %rsi, %r12
mo... | /agievich[P]bee2/src/crypto/bels.c |
beltKeyExpand2 | void beltKeyExpand2(u32 key_[8], const octet key[], size_t len)
{
ASSERT(memIsValid(key_, 32));
ASSERT(len == 16 || len == 24 || len == 32);
ASSERT(memIsValid(key, len));
u32From(key_, key, len);
if (len == 16)
{
key_[4] = key_[0];
key_[5] = key_[1];
key_[6] = key_[2];
key_[7] = key_[3];
}
else if (len ... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
callq 0xe940
cmpq $0x18, %r14
je 0x20215
cmpq $0x10, %r14
jne 0x2022c
movq (%rbx), %rax
movq %rax, 0x10(%rbx)
movl 0x8(%rbx), %eax
movl %eax, 0x18(%rbx)
movl 0xc(%rbx), %eax
jmp 0x20229
movl 0x4(%rbx), %ecx
xorl (%rbx), %ecx
movl 0x10(%rbx), %eax
xorl 0x8... | /agievich[P]bee2/src/crypto/belt/belt_block.c |
beltBlockEncr | void beltBlockEncr(octet block[16], const u32 key[8])
{
u32* t = (u32*)block;
ASSERT(memIsDisjoint2(block, 16, key, 32));
#if (OCTET_ORDER == BIG_ENDIAN)
t[0] = u32Rev(t[0]);
t[1] = u32Rev(t[1]);
t[2] = u32Rev(t[2]);
t[3] = u32Rev(t[3]);
#endif
E((t + 0), (t + 1), (t + 2), (t + 3), key);
#if (OCTET_ORDER == BIG_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl (%rdi), %ebx
movl (%rsi), %r11d
addl %ebx, %r11d
movl $0xff, %ecx
movl %r11d, %edx
andl %ecx, %edx
leaq 0x2de59(%rip), %r10 # 0x4e0b0
movl %r11d, %r8d
shrl $0x8, %r8d
andl %ecx, %r8d
leaq 0x2e248(%rip), %rax # 0x4e4b0
movl (%rax,%r8,4), %r14... | /agievich[P]bee2/src/crypto/belt/belt_block.c |
beltBlockDecr | void beltBlockDecr(octet block[16], const u32 key[8])
{
u32* t = (u32*)block;
ASSERT(memIsDisjoint2(block, 16, key, 32));
#if (OCTET_ORDER == BIG_ENDIAN)
t[0] = u32Rev(t[0]);
t[1] = u32Rev(t[1]);
t[2] = u32Rev(t[2]);
t[3] = u32Rev(t[3]);
#endif
D((t + 0), (t + 1), (t + 2), (t + 3), key);
#if (OCTET_ORDER == BIG_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl (%rdi), %ebx
movl 0x1c(%rsi), %r14d
addl %ebx, %r14d
movl $0xff, %ecx
movl %r14d, %edx
andl %ecx, %edx
leaq 0x2b619(%rip), %r10 # 0x4e0b0
movl %r14d, %r8d
shrl $0x8, %r8d
andl %ecx, %r8d
leaq 0x2ba08(%rip), %rax # 0x4e4b0
movl (%rax,%r8,4), ... | /agievich[P]bee2/src/crypto/belt/belt_block.c |
beltWBLStepEBase | void beltWBLStepEBase(void* buf, size_t count, void* state)
{
belt_wbl_st* st = (belt_wbl_st*)state;
word n = ((word)count + 15) / 16;
ASSERT(count >= 32);
ASSERT(memIsDisjoint2(buf, count, state, beltWBL_keep()));
ASSERT(st->round % (2 * n) == 0);
do
{
size_t i;
// block <- r1 + ... + r_{n-1}
beltBlockCop... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xf(%rsi), %r13
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq -0x10(%rsi), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rdx), %rbp
leaq 0x40(%rdx), %r12
shrq $0x3, %r13
andq $-0x2, %r13
mov... | /agievich[P]bee2/src/crypto/belt/belt_wbl.c |
beltWBLStepEOpt | void beltWBLStepEOpt(void* buf, size_t count, void* state)
{
belt_wbl_st* st = (belt_wbl_st*)state;
word n = ((word)count + 15) / 16;
size_t i;
ASSERT(count >= 32 && count % 16 == 0);
ASSERT(memIsDisjoint2(buf, count, state, beltWBL_keep()));
// sum <- r1 + ... + r_{n-1}
beltBlockCopy(st->sum, buf);
for (i = 16... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
movq %rax, 0x30(%rdx)
movq 0x8(%rdi), %rcx
pushq $0x20
popq %rdx
movq %rcx, 0x38(%rbx)
cmpq %r14, %rdx
jae 0x25422
xorq -0x10(%r15,%rdx), %rax
movq %rax, 0x30(%rbx)
xorq -... | /agievich[P]bee2/src/crypto/belt/belt_wbl.c |
beltWBLStepDBase | void beltWBLStepDBase(void* buf, size_t count, void* state)
{
belt_wbl_st* st = (belt_wbl_st*)state;
word n = ((word)count + 15) / 16;
ASSERT(count >= 32);
ASSERT(memIsDisjoint2(buf, count, state, beltWBL_keep()));
for (st->round = 2 * n; st->round; --st->round)
{
size_t i;
// block <- r*
beltBlockCopy(st->... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0xf(%rsi), %rax
shrq $0x3, %rax
andq $-0x2, %rax
leaq 0x40(%rdx), %rbp
leaq (%rdi,%rsi), %rcx
movq %rcx, 0x38(%rsp)
leaq 0x20(%rdx), %rcx
movq %rcx, 0x40(%rsp)
leaq -0x8(%rdi,%rsi), %rcx
movq %rcx, 0x... | /agievich[P]bee2/src/crypto/belt/belt_wbl.c |
beltWBLStepDOpt | void beltWBLStepDOpt(void* buf, size_t count, void* state)
{
belt_wbl_st* st = (belt_wbl_st*)state;
word n = ((word)count + 15) / 16;
size_t i;
ASSERT(count >= 32 && count % 16 == 0);
ASSERT(memIsDisjoint2(buf, count, state, beltWBL_keep()));
// sum <- r1 + ... + r_{n-2} (будущая сумма r2 + ... + r_{n-1})
beltBl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
movq %rax, 0x30(%rdx)
movq 0x8(%rdi), %rcx
movq %rcx, 0x38(%rdx)
pushq $0x30
popq %rdx
cmpq %r14, %rdx
jae 0x2567a
xorq -0x20(%r15,%rdx), %rax
movq %rax, 0x30(%rbx)
xorq -0x18(%... | /agievich[P]bee2/src/crypto/belt/belt_wbl.c |
beltWBLStepE | void beltWBLStepE(void* buf, size_t count, void* state)
{
belt_wbl_st* st = (belt_wbl_st*)state;
ASSERT(memIsValid(state, beltWBL_keep()));
st->round = 0;
(count % 16 || count < 64) ?
beltWBLStepEBase(buf, count, state) :
beltWBLStepEOpt(buf, count, state);
} | andq $0x0, 0x40(%rdx)
testb $0xf, %sil
sete %al
cmpq $0x40, %rsi
setae %cl
testb %al, %cl
jne 0xec50
jmp 0xee30
| /agievich[P]bee2/src/crypto/belt/belt_wbl.c |
beltWBLStepD2 | void beltWBLStepD2(void* buf1, void* buf2, size_t count, void* state)
{
belt_wbl_st* st = (belt_wbl_st*)state;
word n = ((word)count + 15) / 16;
// pre
ASSERT(count >= 32);
ASSERT(memIsDisjoint3(buf1, count - 16, buf2, 16, state, beltWBL_keep()));
for (st->round = 2 * n; st->round; --st->round)
{
size_t i;
/... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0xf(%rdx), %rax
shrq $0x3, %rax
andq $-0x2, %rax
leaq 0x40(%rcx), %r13
addq $0x20, %rcx
movq %rcx, 0x20(%rsp)
leaq -0x20(%rdi,%rdx), %rcx
movq %rcx, 0x8(%rsp)
leaq 0x10... | /agievich[P]bee2/src/crypto/belt/belt_wbl.c |
beltBlockAddBitSizeU32 | void beltBlockAddBitSizeU32(u32 block[4], size_t count)
{
// block <- block + 8 * count
register u32 carry = (u32)count << 3;
#if (B_PER_S < 32)
carry = (block[0] += carry) < carry;
carry = (block[1] += carry) < carry;
carry = (block[2] += carry) < carry;
block[3] += carry;
#else
register size_t t = count >> 29;... | leal (,%rsi,8), %eax
movq %rsi, %rcx
shrq $0x1d, %rcx
addl %eax, (%rdi)
movl 0x4(%rdi), %eax
adcl $0x0, %eax
setb %dl
addl %ecx, %eax
setb %r8b
testb %dl, %dl
cmovnel %ecx, %eax
orb %dl, %r8b
movzbl %r8b, %ecx
shrq $0x3d, %rsi
movl 0x8(%rdi), %edx
leal (%rcx,%rdx), %r8d
addl %esi, %r8d
setb %r9b
addl %edx, %ecx
movl %e... | /agievich[P]bee2/src/crypto/belt/belt_lcl.c |
beltHalfBlockAddBitSizeW | void beltHalfBlockAddBitSizeW(word block[W_OF_B(64)], size_t count)
{
// block <- block + 8 * count
register word carry = (word)count << 3;
#if (B_PER_W == 16)
register size_t t = count >> 13;
carry = (block[0] += carry) < carry;
if ((block[1] += carry) < carry)
block[1] = (word)t;
else
carry = (block[1] += (... | shlq $0x3, %rsi
addq %rsi, (%rdi)
retq
| /agievich[P]bee2/src/crypto/belt/belt_lcl.c |
beltPolyMul | void beltPolyMul(word c[], const word a[], const word b[], void* stack)
{
const size_t n = W_OF_B(128);
word* prod = (word*)stack;
stack = prod + 2 * n;
// умножить
ppMul(prod, a, n, b, n, stack);
// привести по модулю
ppRedBelt(prod);
wwCopy(c, prod, n);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %rcx
movq %rdi, %r14
leaq 0x20(%rbx), %r9
pushq $0x2
popq %r15
movq %rbx, %rdi
movq %r15, %rdx
movq %r15, %r8
callq 0xf5f0
movq %rbx, %rdi
callq 0xea70
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xe5c0
| /agievich[P]bee2/src/crypto/belt/belt_lcl.c |
beltBlockMulC | void beltBlockMulC(u32 block[4])
{
register u32 t = ~((block[3] >> 31) - U32_1) & 0x00000087;
block[3] = (block[3] << 1) ^ (block[2] >> 31);
block[2] = (block[2] << 1) ^ (block[1] >> 31);
block[1] = (block[1] << 1) ^ (block[0] >> 31);
block[0] = (block[0] << 1) ^ t;
t = 0;
} | movl 0xc(%rdi), %eax
movl %eax, %ecx
sarl $0x1f, %ecx
andl $0x87, %ecx
movl 0x8(%rdi), %edx
shldl $0x1, %edx, %eax
movl %eax, 0xc(%rdi)
movl 0x4(%rdi), %eax
shldl $0x1, %eax, %edx
movl (%rdi), %esi
movl %edx, 0x8(%rdi)
shldl $0x1, %esi, %eax
movl %eax, 0x4(%rdi)
addl %esi, %esi
xorl %ecx, %esi
movl %esi, (%rdi)
retq
no... | /agievich[P]bee2/src/crypto/belt/belt_lcl.c |
beltCBCStepE | void beltCBCStepE(void* buf, size_t count, void* state)
{
belt_cbc_st* st = (belt_cbc_st*)state;
ASSERT(count >= 16);
ASSERT(memIsDisjoint2(buf, count, state, beltCBC_keep()));
// цикл по полным блокам
while(count >= 16)
{
beltBlockXor2(st->block, buf);
beltBlockEncr(st->block, st->key);
beltBlockCopy(buf, ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq 0x20(%rdx), %r15
cmpq $0x10, %r14
jb 0x25a5d
movq (%r12), %rax
xorq %rax, 0x20(%rbx)
movq 0x8(%r12), %rax
xorq %rax, 0x28(%rbx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0xe140
movq 0x20(%rbx), %rax
movq %rax, (%r12)... | /agievich[P]bee2/src/crypto/belt/belt_cbc.c |
beltCBCStepD | void beltCBCStepD(void* buf, size_t count, void* state)
{
belt_cbc_st* st = (belt_cbc_st*)state;
ASSERT(count >= 16);
ASSERT(memIsDisjoint2(buf, count, state, beltCBC_keep()));
// цикл по полным блокам
while(count >= 32 || count == 16)
{
beltBlockCopy(st->block2, buf);
beltBlockDecr(buf, st->key);
beltBlock... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r15
leaq -0x10(%rsi), %rbp
xorl %r14d, %r14d
xorl %r13d, %r13d
leaq (%rdx,%r14), %rax
leaq (%r15,%r13), %r12
cmpq $0x20, %rax
setb %al
cmpq %r13, %rbp
setne %cl
testb %cl, %al
jne 0x25b1d
movq (%r15,... | /agievich[P]bee2/src/crypto/belt/belt_cbc.c |
beltCBCEncr | err_t beltCBCEncr(void* dest, const void* src, size_t count,
const octet key[], size_t len, const octet iv[16])
{
void* state;
// проверить входные данные
if (count < 16 ||
len != 16 && len != 24 && len != 32 ||
!memIsValid(src, count) ||
!memIsValid(key, len) ||
!memIsValid(iv, 16) ||
!memIsValid(dest, c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x6d
popq %rbp
cmpq $0x10, %rdx
jb 0x25c57
movq %r8, %r13
cmpq $0x20, %r8
ja 0x25c57
movabsq $0x101010000, %rax # imm = 0x101010000
btq %r13, %rax
jae 0x25c57
movq %r9, %r12
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi... | /agievich[P]bee2/src/crypto/belt/belt_cbc.c |
beltCBCDecr | err_t beltCBCDecr(void* dest, const void* src, size_t count,
const octet key[], size_t len, const octet iv[16])
{
void* state;
// проверить входные данные
if (count < 16 ||
len != 16 && len != 24 && len != 32 ||
!memIsValid(src, count) ||
!memIsValid(key, len) ||
!memIsValid(iv, 16) ||
!memIsValid(dest, c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x6d
popq %rbp
cmpq $0x10, %rdx
jb 0x25d3e
movq %r8, %r13
cmpq $0x20, %r8
ja 0x25d3e
movabsq $0x101010000, %rax # imm = 0x101010000
btq %r13, %rax
jae 0x25d3e
movq %r9, %r12
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi... | /agievich[P]bee2/src/crypto/belt/belt_cbc.c |
beltCFBStepE | void beltCFBStepE(void* buf, size_t count, void* state)
{
belt_cfb_st* st = (belt_cfb_st*)state;
ASSERT(memIsDisjoint2(buf, count, state, beltCFB_keep()));
// есть резерв гаммы?
if (st->reserved)
{
if (st->reserved >= count)
{
memXor2(st->block + 16 - st->reserved, buf, count);
memCopy(buf, st->block + 1... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30(%rdx), %r13
movq 0x30(%rdx), %rdx
testq %rdx, %rdx
je 0x25dd6
movq %r13, %rdi
subq %rdx, %rdi
movq %r14, %rsi
cmpq %rbx, %rdx
jae 0x25e44
callq 0xf0b0
movq (%r13), %rdx
movq %r13, %rsi
subq %rdx, %rsi
movq %... | /agievich[P]bee2/src/crypto/belt/belt_cfb.c |
beltCFBEncr | err_t beltCFBEncr(void* dest, const void* src, size_t count,
const octet key[], size_t len, const octet iv[16])
{
void* state;
// проверить входные данные
if (len != 16 && len != 24 && len != 32 ||
!memIsValid(src, count) ||
!memIsValid(key, len) ||
!memIsValid(iv, 16) ||
!memIsValid(dest, count))
return ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x6d
popq %rbp
cmpq $0x20, %r8
ja 0x26033
movq %r8, %r13
movabsq $0x101010000, %rax # imm = 0x101010000
btq %r8, %rax
jae 0x26033
movq %r9, %r12
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, (%rsp)
movq %rsi, %rdi
movq... | /agievich[P]bee2/src/crypto/belt/belt_cfb.c |
beltCompr | void beltCompr(u32 h[8], const u32 X[8], void* stack)
{
// [12]buf = [4]buf0 || [4]buf1 || [4]buf2
u32* buf = (u32*)stack;
// буферы не пересекаются?
ASSERT(memIsDisjoint3(h, 32, X, 32, buf, 48));
// buf0, buf1 <- h0 + h1
beltBlockXor(buf, h, h + 4);
beltBlockCopy(buf + 4, buf);
// buf0 <- beltBlock(buf0, X) + ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq 0x10(%rdi), %rax
xorq (%rdi), %rax
movq %rax, (%rdx)
movq 0x18(%rdi), %rcx
xorq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rdx)
leaq 0x10(%rdx), %r13
movq %rax, 0x10(%rdx)
movq %rcx, 0x18(%rdx)
movq %r... | /agievich[P]bee2/src/crypto/belt/belt_compr.c |
beltCTRStepE | void beltCTRStepE(void* buf, size_t count, void* state)
{
belt_ctr_st* st = (belt_ctr_st*)state;
ASSERT(memIsDisjoint2(buf, count, state, beltCTR_keep()));
// есть резерв гаммы?
if (st->reserved)
{
if (st->reserved >= count)
{
memXor2(buf, st->block + 16 - st->reserved, count);
st->reserved -= count;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x40(%rdx), %r13
movq 0x40(%rdx), %rdx
testq %rdx, %rdx
je 0x263a5
movq %r13, %rsi
subq %rdx, %rsi
cmpq %rbx, %rdx
jae 0x26436
movq %r14, %rdi
callq 0xf0b0
movq (%r13), %rax
subq %rax, %rbx
addq %rax, %r14
andq $... | /agievich[P]bee2/src/crypto/belt/belt_ctr.c |
beltCTR | err_t beltCTR(void* dest, const void* src, size_t count,
const octet key[], size_t len, const octet iv[16])
{
void* state;
// проверить входные данные
if (len != 16 && len != 24 && len != 32 ||
!memIsValid(src, count) ||
!memIsValid(key, len) ||
!memIsValid(iv, 16) ||
!memIsValid(dest, count))
return ERR_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x6d
popq %rbp
cmpq $0x20, %r8
ja 0x26522
movq %r8, %r13
movabsq $0x101010000, %rax # imm = 0x101010000
btq %r8, %rax
jae 0x26522
movq %r9, %r12
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, (%rsp)
movq %rsi, %rdi
movq... | /agievich[P]bee2/src/crypto/belt/belt_ctr.c |
beltDWPStepG_internal | static void beltDWPStepG_internal(void* state)
{
belt_dwp_st* st = (belt_dwp_st*)state;
ASSERT(memIsValid(state, beltDWP_keep()));
// создать копию t и завершить обработку данных
if (st->filled)
{
memSetZero(st->block + st->filled, 16 - st->filled);
wwFrom(st->t1, st->block, 16);
beltBlockXor2(st->t1, st->t)... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x98(%rdi), %rax
testq %rax, %rax
je 0x26925
leaq 0x88(%rbx), %r14
leaq (%rbx,%rax), %rdi
addq $0x88, %rdi
pushq $0x10
popq %r15
movq %r15, %rdx
subq %rax, %rdx
xorl %esi, %esi
callq 0xf710
leaq 0x68(%rbx), %r12
movq %r12, %rdi
movq %r14, %rsi
... | /agievich[P]bee2/src/crypto/belt/belt_dwp.c |
beltDWPUnwrap | err_t beltDWPUnwrap(void* dest, const void* src1, size_t count1,
const void* src2, size_t count2, const octet mac[8], const octet key[],
size_t len, const octet iv[16])
{
void* state;
// проверить входные данные
if (len != 16 && len != 24 && len != 32 ||
!memIsValid(src1, count1) ||
!memIsValid(src2, count2) |... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
pushq $0x6d
popq %rbp
movq 0x58(%rsp), %r12
cmpq $0x20, %r12
ja 0x26c4c
movabsq $0x101010000, %rax # imm = 0x101010000
btq %r12, %rax
jae 0x26c4c
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
mo... | /agievich[P]bee2/src/crypto/belt/belt_dwp.c |
beltCHEStart | void beltCHEStart(void* state, const octet key[], size_t len,
const octet iv[16])
{
belt_che_st* st = (belt_che_st*)state;
ASSERT(memIsDisjoint2(iv, 16, state, beltCHE_keep()));
// разобрать key и iv
beltKeyExpand2(st->key, key, len);
beltBlockCopy(st->r, iv);
beltBlockEncr((octet*)st->r, st->key);
u32From(st-... | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdi, %rbx
callq 0xed10
movq (%r14), %rax
leaq 0x30(%rbx), %r15
movq %rax, 0x30(%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x38(%rbx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0xe140
leaq 0x20(%rbx), %rdi
pushq $0x10
popq %r14
movq %r15, %rsi
movq %r14, %rdx
callq 0xe940
lea... | /agievich[P]bee2/src/crypto/belt/belt_che.c |
beltCHEStepI | void beltCHEStepI(const void* buf, size_t count, void* state)
{
belt_che_st* st = (belt_che_st*)state;
ASSERT(memIsDisjoint2(buf, count, state, beltCHE_keep()));
// критические данные не обрабатывались?
ASSERT(count == 0 || beltHalfBlockIsZero(st->len + W_OF_B(64)));
// обновить длину
beltHalfBlockAddBitSizeW(st-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x60(%rdx), %rdi
callq 0xf6b0
movq 0x90(%r14), %rax
testq %rax, %rax
je 0x26e8c
pushq $0x10
popq %rdx
subq %rax, %rdx
leaq (%r14,%rax), %rdi
addq $0x70, %rdi
cmpq %rbx, %rdx
jbe 0x26e3e
movq... | /agievich[P]bee2/src/crypto/belt/belt_che.c |
beltCHEStepA | void beltCHEStepA(const void* buf, size_t count, void* state)
{
belt_che_st* st = (belt_che_st*)state;
ASSERT(memIsDisjoint2(buf, count, state, beltCHE_keep()));
// первый непустой фрагмент критических данных?
// есть необработанные открытые данные?
if (count && beltHalfBlockIsZero(st->len + W_OF_B(64)) && st->fil... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
pushq $0x10
popq %r12
testq %rsi, %rsi
je 0x26f89
cmpq $0x0, 0x68(%r14)
jne 0x26f89
movq 0x90(%r14), %rax
testq %rax, %rax
je 0x26f89
leaq (%r14,%rax), %rdi
addq $0x70, %rdi
movq %r12, %rdx
subq ... | /agievich[P]bee2/src/crypto/belt/belt_che.c |
beltCHEStepG_internal | static void beltCHEStepG_internal(void* state)
{
belt_che_st* st = (belt_che_st*)state;
ASSERT(memIsValid(state, beltCHE_keep()));
// создать копию t и завершить обработку данных
if (st->filled)
{
memSetZero(st->block + st->filled, 16 - st->filled);
wwFrom(st->t1, st->block, 16);
beltBlockXor2(st->t1, st->t)... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x90(%rdi), %rax
testq %rax, %rax
je 0x2713d
leaq 0x70(%rbx), %r14
leaq (%rbx,%rax), %rdi
addq $0x70, %rdi
pushq $0x10
popq %r15
movq %r15, %rdx
subq %rax, %rdx
xorl %esi, %esi
callq 0xf710
leaq 0x50(%rbx), %r12
movq %r12, %rdi
movq %r14, %rsi
... | /agievich[P]bee2/src/crypto/belt/belt_che.c |
beltCHEWrap | err_t beltCHEWrap(void* dest, octet mac[8], const void* src1, size_t count1,
const void* src2, size_t count2, const octet key[], size_t len,
const octet iv[16])
{
void* state;
// проверить входные данные
if (len != 16 && len != 24 && len != 32 ||
!memIsValid(src1, count1) ||
!memIsValid(src2, count2) ||
!mem... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
pushq $0x6d
popq %rbp
movq 0x58(%rsp), %r15
cmpq $0x20, %r15
ja 0x272fe
movabsq $0x101010000, %rax # imm = 0x101010000
btq %r15, %rax
jae 0x272fe
movq %r9, %r13
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rdi, 0x10(%rsp)
mo... | /agievich[P]bee2/src/crypto/belt/belt_che.c |
beltCHEUnwrap | err_t beltCHEUnwrap(void* dest, const void* src1, size_t count1,
const void* src2, size_t count2, const octet mac[8], const octet key[],
size_t len, const octet iv[16])
{
void* state;
// проверить входные данные
if (len != 16 && len != 24 && len != 32 ||
!memIsValid(src1, count1) ||
!memIsValid(src2, count2) |... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
pushq $0x6d
popq %rbp
movq 0x58(%rsp), %r12
cmpq $0x20, %r12
ja 0x27466
movabsq $0x101010000, %rax # imm = 0x101010000
btq %r12, %rax
jae 0x27466
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
mo... | /agievich[P]bee2/src/crypto/belt/belt_che.c |
beltECBStepD | void beltECBStepD(void* buf, size_t count, void* state)
{
belt_ecb_st* st = (belt_ecb_st*)state;
ASSERT(count >= 16);
ASSERT(memIsDisjoint2(buf, count, state, beltECB_keep()));
// цикл по полным блокам
while(count >= 16)
{
beltBlockDecr(buf, st->key);
buf = (octet*)buf + 16;
count -= 16;
}
// неполный бло... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x10, %r14
jb 0x27512
movq %r15, %rdi
movq %rbx, %rsi
callq 0xe3d0
addq $0x10, %r15
addq $-0x10, %r14
jmp 0x274f7
testq %r14, %r14
je 0x2753f
leaq -0x10(%r15), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rd... | /agievich[P]bee2/src/crypto/belt/belt_ecb.c |
beltECBEncr | err_t beltECBEncr(void* dest, const void* src, size_t count,
const octet key[], size_t len)
{
void* state;
// проверить входные данные
if (count < 16 ||
len != 16 && len != 24 && len != 32 ||
!memIsValid(src, count) ||
!memIsValid(key, len) ||
!memIsValid(dest, count))
return ERR_BAD_INPUT;
// создать со... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x6d
popq %rbp
cmpq $0x10, %rdx
jb 0x27606
movq %r8, %r12
cmpq $0x20, %r8
ja 0x27606
movabsq $0x101010000, %rax # imm = 0x101010000
btq %r12, %rax
jae 0x27606
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rs... | /agievich[P]bee2/src/crypto/belt/belt_ecb.c |
beltECBDecr | err_t beltECBDecr(void* dest, const void* src, size_t count,
const octet key[], size_t len)
{
void* state;
// проверить входные данные
if (count < 16 ||
len != 16 && len != 24 && len != 32 ||
!memIsValid(src, count) ||
!memIsValid(key, len) ||
!memIsValid(dest, count))
return ERR_BAD_INPUT;
// создать со... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x6d
popq %rbp
cmpq $0x10, %rdx
jb 0x276d2
movq %r8, %r12
cmpq $0x20, %r8
ja 0x276d2
movabsq $0x101010000, %rax # imm = 0x101010000
btq %r12, %rax
jae 0x276d2
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rs... | /agievich[P]bee2/src/crypto/belt/belt_ecb.c |
beltBDEStepE | void beltBDEStepE(void* buf, size_t count, void* state)
{
belt_bde_st* st = (belt_bde_st*)state;
ASSERT(count % 16 == 0);
ASSERT(memIsDisjoint2(buf, count, state, beltBDE_keep()));
// цикл по блокам
while(count >= 16)
{
beltBlockMulC(st->s);
u32To(st->block, 16, st->s);
beltBlockXor2(buf, st->block);
belt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x20(%rdx), %r12
leaq 0x30(%rdx), %r13
pushq $0x10
popq %rbp
cmpq $0x10, %r14
jb 0x27788
movq %r12, %rdi
callq 0xf460
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0xf6c0
movq 0x30(%... | /agievich[P]bee2/src/crypto/belt/belt_bde.c |
beltBDEEncr | err_t beltBDEEncr(void* dest, const void* src, size_t count,
const octet key[], size_t len, const octet iv[16])
{
void* state;
// проверить входные данные
if (count % 16 != 0 || count < 16 ||
len != 16 && len != 24 && len != 32 ||
!memIsValid(src, count) ||
!memIsValid(key, len) ||
!memIsValid(iv, 16) ||
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
testb $0xf, %bl
setne %al
cmpq $0x10, %rdx
setb %cl
orb %al, %cl
pushq $0x6d
popq %rbp
jne 0x278f5
movq %r8, %r13
cmpq $0x20, %r8
ja 0x278f5
movabsq $0x101010000, %rax # imm = 0x101010000
btq %r13, %rax
jae... | /agievich[P]bee2/src/crypto/belt/belt_bde.c |
beltBDEDecr | err_t beltBDEDecr(void* dest, const void* src, size_t count,
const octet key[], size_t len, const octet iv[16])
{
void* state;
// проверить входные данные
if (count % 16 != 0 || count < 16 ||
len != 16 && len != 24 && len != 32 ||
!memIsValid(src, count) ||
!memIsValid(key, len) ||
!memIsValid(iv, 16) ||
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
testb $0xf, %bl
setne %al
cmpq $0x10, %rdx
setb %cl
orb %al, %cl
pushq $0x6d
popq %rbp
jne 0x279e7
movq %r8, %r13
cmpq $0x20, %r8
ja 0x279e7
movabsq $0x101010000, %rax # imm = 0x101010000
btq %r13, %rax
jae... | /agievich[P]bee2/src/crypto/belt/belt_bde.c |
beltSDEStepE | void beltSDEStepE(void* buf, size_t count, const octet iv[16], void* state)
{
belt_sde_st* st = (belt_sde_st*)state;
ASSERT(count % 16 == 0 && count >= 16);
ASSERT(memIsDisjoint2(buf, count, state, beltSDE_keep()));
ASSERT(memIsValid(iv, 16));
// зашифровать синхропосылку
memCopy(st->s, iv, 16);
beltBlockEncr(st... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x48(%rcx), %r12
pushq $0x10
popq %rax
movq %r12, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0xe970
movq %r12, %rdi
movq %rbx, %rsi
callq 0xe140
movq 0x48(%rbx), %rax
xorq %rax, (%r15)
movq 0x50(%rbx), %rax
xorq ... | /agievich[P]bee2/src/crypto/belt/belt_sde.c |
beltSDEStepD | void beltSDEStepD(void* buf, size_t count, const octet iv[16], void* state)
{
belt_sde_st* st = (belt_sde_st*)state;
ASSERT(count % 16 == 0 && count >= 32);
ASSERT(memIsDisjoint2(buf, count, state, beltSDE_keep()));
ASSERT(memIsValid(iv, 16));
// зашифровать синхропосылку
memCopy(st->s, iv, 16);
beltBlockEncr(st... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x48(%rcx), %r12
pushq $0x10
popq %rax
movq %r12, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0xe970
movq %r12, %rdi
movq %rbx, %rsi
callq 0xe140
movq 0x48(%rbx), %rax
xorq %rax, (%r15)
movq 0x50(%rbx), %rax
xorq ... | /agievich[P]bee2/src/crypto/belt/belt_sde.c |
beltSDEEncr | err_t beltSDEEncr(void* dest, const void* src, size_t count,
const octet key[], size_t len, const octet iv[16])
{
void* state;
// проверить входные данные
if (count % 16 != 0 || count < 32 ||
len != 16 && len != 24 && len != 32 ||
!memIsValid(src, count) ||
!memIsValid(key, len) ||
!memIsValid(iv, 16) ||
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
testb $0xf, %r14b
setne %al
cmpq $0x20, %rdx
setb %cl
orb %al, %cl
pushq $0x6d
popq %rbp
jne 0x27bb2
movq %r8, %r13
cmpq $0x20, %r8
ja 0x27bb2
movabsq $0x101010000, %rax # imm = 0x101010000
btq %r13, %rax
j... | /agievich[P]bee2/src/crypto/belt/belt_sde.c |
beltSDEDecr | err_t beltSDEDecr(void* dest, const void* src, size_t count,
const octet key[], size_t len, const octet iv[16])
{
void* state;
// проверить входные данные
if (count % 16 != 0 || count < 32 ||
len != 16 && len != 24 && len != 32 ||
!memIsValid(src, count) ||
!memIsValid(key, len) ||
!memIsValid(iv, 16) ||
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
testb $0xf, %r14b
setne %al
cmpq $0x20, %rdx
setb %cl
orb %al, %cl
pushq $0x6d
popq %rbp
jne 0x27ca2
movq %r8, %r13
cmpq $0x20, %r8
ja 0x27ca2
movabsq $0x101010000, %rax # imm = 0x101010000
btq %r13, %rax
j... | /agievich[P]bee2/src/crypto/belt/belt_sde.c |
beltFMTCalcB | static size_t beltFMTCalcB(u32 mod, size_t count)
{
const size_t m = W_OF_B(128);
word num[W_OF_B(128)];
word den[W_OF_B(128)];
size_t k;
word stack[W_OF_B(128) * 5];
word* t0 = stack;
word* t1 = t0 + m;
word* t2 = t1 + m;
word* t3 = t2 + m;
word* t4 = t3 + m;
// pre
ASSERT(2 <= mod && mod <= 65536);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
cmpl $0xc203, %edi # imm = 0xC203
sete %al
cmpq $0x140, %rsi # imm = 0x140
sete %cl
testb %cl, %al
je 0x27cfa
pushq $0x27
popq %rbx
jmp 0x27fd1
movq %rsi, %rbx
movl %edi, %ebp
cmpl $0x10000, %edi # imm = 0x1... | /agievich[P]bee2/src/crypto/belt/belt_fmt.c |
beltFMTStart | void beltFMTStart(void* state, u32 mod, size_t count, const octet key[],
size_t len)
{
belt_fmt_st* st = (belt_fmt_st*)state;
ASSERT(2 <= mod && mod <= 65536);
ASSERT(2 <= count && count <= 600);
ASSERT(memIsValid(state, beltFMT_keep(mod, count)));
// инициализировать состояние
beltWBLStart(st->wbl, key, len);
... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq %rcx, %rsi
movq %r8, %rdx
callq 0xf570
movl %ebp, 0x48(%rbx)
leaq 0x1(%r14), %rsi
shrq %rsi
movq %rsi, 0x50(%rbx)
movq %r14, %rax
shrq %rax
movq %rax, 0x58(%rbx)
movl %ebp, %edi
callq 0x27cca
movq %rax, 0x60(%rbx)
movq 0x58(%rbx), %rs... | /agievich[P]bee2/src/crypto/belt/belt_fmt.c |
belt32BlockEncr | static void belt32BlockEncr(octet block[24], const u32 key[8])
{
u32* t = (u32*)block;
u32From(t, block, 24);
// round #1
beltBlockEncr3(t + 2, t + 3, t + 4, t + 5, key);
t[2] ^= 1, t[0] ^= t[2], t[1] ^= t[3];
// round #2
beltBlockEncr3(t + 4, t + 5, t + 0, t + 1, key);
t[4] ^= 2, t[2] ^= t[4], t[3] ^= t[5];
/... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x18
popq %rdx
movq %rdi, %rsi
callq 0xe940
leaq 0x8(%rbx), %rdi
movq %rdi, (%rsp)
leaq 0xc(%rbx), %r13
leaq 0x10(%rbx), %rbp
leaq 0x14(%rbx), %r14
movq %r13, %rsi
movq %rbp, %rdx
movq %r14, %rcx
movq %r1... | /agievich[P]bee2/src/crypto/belt/belt_fmt.c |
beltBin2StrAdd | static void beltBin2StrAdd(u32 mod, u16 str[], size_t count,
octet bin[], size_t b)
{
register u32 t;
word* a;
size_t m;
// особый случай: mod может не уложиться в word
if (mod == 65536)
{
u16* uu = (u16*)bin;
u16From(uu, bin, 8 * b);
while (count--)
str[count] += uu[count];
return;
}
// настроить ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq (,%r8,8), %rdx
cmpl $0x10000, %edi # imm = 0x10000
jne 0x283d2
movq %rbx, %rdi
movq %rbx, %rsi
callq 0xe730
subq $0x1, %r14
jb 0x28433
movzwl (%rbx,%r14,2), %eax
addw %ax, (%r15,%r1... | /agievich[P]bee2/src/crypto/belt/belt_fmt.c |
beltFMTStepD | void beltFMTStepD(u16 buf[], const octet iv[16], void* state)
{
belt_fmt_st* st = (belt_fmt_st*)state;
size_t i;
ASSERT(memIsValid(state, sizeof(belt_fmt_st)));
ASSERT(memIsValid(state, beltFMT_keep(st->mod, st->n1 + st->n2)));
ASSERT(memIsNullOrValid(iv, 16));
ASSERT(memIsValid(buf, 2 * st->n1 + 2 * st->n2));
/... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x74(%rdx), %rdi
pushq $0x10
popq %rdx
testq %rsi, %rsi
je 0x28469
callq 0xe970
jmp 0x28470
xorl %esi, %esi
callq 0xf710
pushq $0x10
popq %rax
movq %rax, 0x18(%rsp)
leaq 0x88(%rbx), %r15
leaq 0x8c(%rb... | /agievich[P]bee2/src/crypto/belt/belt_fmt.c |
beltBin2StrSub | static void beltBin2StrSub(word mod, u16 str[], size_t count,
octet bin[], size_t b)
{
register u32 t;
word* a;
size_t m;
// особый случай: mod может не уложиться в word
if (mod == 65536)
{
u16* uu = (u16*)bin;
u16From(uu, bin, 8 * b);
while (count--)
str[count] -= uu[count];
return;
}
// настроить... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq (,%r8,8), %rdx
cmpq $0x10000, %rdi # imm = 0x10000
jne 0x2868a
movq %rbx, %rdi
movq %rbx, %rsi
callq 0xe730
subq $0x1, %r14
jb 0x286ec
movzwl (%rbx,%r14,2), %eax
subw %ax, (%r15,%r1... | /agievich[P]bee2/src/crypto/belt/belt_fmt.c |
beltFMTEncr | err_t beltFMTEncr(u16 dest[], u32 mod, const u16 src[], size_t count,
const octet key[], size_t len, const octet iv[16])
{
void* state;
// проверить входные данные
if (count < 2 ||
len != 16 && len != 24 && len != 32 ||
!memIsValid(src, 2 * count) ||
!memIsNullOrValid(iv, 16) ||
!memIsValid(key, len) ||
!... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
pushq $0x6d
popq %rbp
cmpq $0x2, %rcx
jb 0x28830
movq %r9, %r15
cmpq $0x20, %r9
ja 0x28830
movabsq $0x101010000, %rax # imm = 0x101010000
btq %r15, %rax
jae 0x28830
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r14
movq %rdi, %rbx
movl... | /agievich[P]bee2/src/crypto/belt/belt_fmt.c |
beltFMTDecr | err_t beltFMTDecr(u16 dest[], u32 mod, const u16 src[], size_t count,
const octet key[], size_t len, const octet iv[16])
{
void* state;
// проверить входные данные
if (count < 2 ||
len != 16 && len != 24 && len != 32 ||
!memIsValid(src, 2 * count) ||
!memIsNullOrValid(iv, 16) ||
!memIsValid(key, len) ||
!... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
pushq $0x6d
popq %rbp
cmpq $0x2, %rcx
jb 0x28976
movq %r9, %r15
cmpq $0x20, %r9
ja 0x28976
movabsq $0x101010000, %rax # imm = 0x101010000
btq %r15, %rax
jae 0x28976
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r14
movq %rdi, %rbx
movl... | /agievich[P]bee2/src/crypto/belt/belt_fmt.c |
beltHashStart | void beltHashStart(void* state)
{
belt_hash_st* st = (belt_hash_st*)state;
ASSERT(memIsValid(state, beltHash_keep()));
// len || s <- 0
beltBlockSetZero(st->ls);
beltBlockSetZero(st->ls + 4);
// h <- B194...0D
u32From(st->h, beltH(), 32);
// нет накопленнных данных
st->filled = 0;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %eax, %eax
callq 0xf920
pushq $0x20
popq %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0xe940
andq $0x0, 0x90(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /agievich[P]bee2/src/crypto/belt/belt_hash.c |
beltHMACStart | void beltHMACStart(void* state, const octet key[], size_t len)
{
belt_hmac_st* st = (belt_hmac_st*)state;
ASSERT(memIsDisjoint2(key, len, state, beltHMAC_keep()));
// key <- key || 0
if (len <= 32)
{
memCopy(st->block, key, len);
memSetZero(st->block + len, 32 - len);
#if (OCTET_ORDER == BIG_ENDIAN)
beltBloc... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
cmpq $0x20, %rdx
ja 0x28d10
leaq 0xd0(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xe970
leaq (%rbx,%r15), %rdi
addq $0xd0, %rdi
pushq $0x20
popq %rdx
subq %r15, %rdx
xorl %esi, %esi
... | /agievich[P]bee2/src/crypto/belt/belt_hmac.c |
beltHMACStepA | void beltHMACStepA(const void* buf, size_t count, void* state)
{
belt_hmac_st* st = (belt_hmac_st*)state;
ASSERT(memIsDisjoint2(buf, count, state, beltHMAC_keep()));
// обновить длину
beltBlockAddBitSizeU32(st->ls_in, count);
// есть накопленные данные?
if (st->filled)
{
if (count < 32 - st->filled)
{
mem... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rdx, %rdi
callq 0x10060
movq 0xf0(%r14), %rax
testq %rax, %rax
je 0x28f88
pushq $0x20
popq %r13
movq %r13, %rdx
subq %rax, %rdx
leaq (%r14,%rax), %rdi
addq $0xd0, %rdi
cmpq %rbx, %rdx
jbe 0... | /agievich[P]bee2/src/crypto/belt/belt_hmac.c |
beltHMACStepV | bool_t beltHMACStepV(const octet mac[32], void* state)
{
belt_hmac_st* st = (belt_hmac_st*)state;
ASSERT(memIsValid(mac, 32));
beltHMACStepG_internal(state);
#if (OCTET_ORDER == BIG_ENDIAN)
beltBlockRevU32(st->h1_out);
beltBlockRevU32(st->h1_out + 4);
#endif
return memEq(mac, st->h1_out, 32);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x29055
addq $0xa0, %rbx
pushq $0x20
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf140
| /agievich[P]bee2/src/crypto/belt/belt_hmac.c |
beltHMAC | err_t beltHMAC(octet mac[32], const void* src, size_t count,
const octet key[], size_t len)
{
void* state;
// проверить входные данные
if (!memIsValid(src, count) ||
!memIsValid(key, len) ||
!memIsValid(mac, 32))
return ERR_BAD_INPUT;
// создать состояние
state = blobCreate(beltHMAC_keep());
if (state == 0... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xeeb0
pushq $0x6d
popq %rbp
testl %eax, %eax
je 0x2926e
movq %r13, %rdi
movq %r12, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x29... | /agievich[P]bee2/src/crypto/belt/belt_hmac.c |
beltKRPStart | void beltKRPStart(void* state, const octet key[], size_t len,
const octet level[12])
{
belt_krp_st* st = (belt_krp_st*)state;
ASSERT(memIsDisjoint2(level, 12, state, beltKRP_keep()));
// block <- ... || level || ...
u32From(st->block + 1, level, 12);
// сохранить ключ
beltKeyExpand2(st->key, key, st->len = len)... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x2c, %rdi
pushq $0xc
popq %rdx
movq %rcx, %rsi
callq 0xe940
movq %rbx, 0x20(%r15)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xed10
| /agievich[P]bee2/src/crypto/belt/belt_krp.c |
beltKRPStepG | void beltKRPStepG(octet key_[], size_t key_len, const octet header[16],
void* state)
{
belt_krp_st* st = (belt_krp_st*)state;
// pre
ASSERT(memIsValid(state, beltKRP_keep()));
ASSERT(key_len == 16 || key_len == 24 || key_len == 32);
ASSERT(key_len <= st->len);
ASSERT(memIsDisjoint2(key_, key_len, state, beltKRP_... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rcx), %r12
xorl %eax, %eax
callq 0xf920
movq 0x20(%r15), %rcx
leaq (%rax,%rcx,4), %rax
leaq (%rax,%rbx,2), %rsi
addq $-0x60, %rsi
pushq $0x4
popq %rdx
movq %r12, %rdi
callq 0xe940
leaq 0x38(... | /agievich[P]bee2/src/crypto/belt/belt_krp.c |
beltKRP | err_t beltKRP(octet dest[], size_t m, const octet src[], size_t n,
const octet level[12], const octet header[16])
{
void* state;
// проверить входные данные
if (m > n ||
m != 16 && m != 24 && m != 32 ||
n != 16 && n != 24 && n != 32 ||
!memIsValid(src, n) ||
!memIsValid(level, 12) ||
!memIsValid(header, 1... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x6d
popq %rbx
cmpq %rcx, %rsi
jbe 0x29370
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r15
cmpq $0x20, %rsi
ja 0x2935f
movabsq $0x101010000, %rax # imm = 0x101010000
... | /agievich[P]bee2/src/crypto/belt/belt_krp.c |
beltKWPWrap | err_t beltKWPWrap(octet dest[], const octet src[], size_t count,
const octet header[16], const octet key[], size_t len)
{
void* state;
// проверить входные данные
if (count < 16 ||
len != 16 && len != 24 && len != 32 ||
!memIsValid(src, count) ||
!memIsNullOrValid(header, 16) ||
header && !memIsDisjoint2(sr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
pushq $0x6d
popq %rbp
cmpq $0x10, %rdx
jb 0x2957a
movq %r9, %r13
cmpq $0x20, %r9
ja 0x2957a
movabsq $0x101010000, %rax # imm = 0x101010000
btq %r13, %rax
jae 0x2957a
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
mov... | /agievich[P]bee2/src/crypto/belt/belt_kwp.c |
beltKWPUnwrap | err_t beltKWPUnwrap(octet dest[], const octet src[], size_t count,
const octet header[16], const octet key[], size_t len)
{
void* state;
octet* header2;
// проверить входные данные
if (count < 32 ||
len != 16 && len != 24 && len != 32 ||
!memIsValid(src, count) ||
!memIsNullOrValid(header, 16) ||
!memIsVal... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
pushq $0x6d
popq %rbx
cmpq $0x20, %rdx
jb 0x296ed
movq %r9, %rbp
cmpq $0x20, %r9
ja 0x296ed
movabsq $0x101010000, %rax # imm = 0x101010000
btq %rbp, %rax
jae 0x296ed
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
mov... | /agievich[P]bee2/src/crypto/belt/belt_kwp.c |
beltMACStepA | void beltMACStepA(const void* buf, size_t count, void* state)
{
belt_mac_st* st = (belt_mac_st*)state;
ASSERT(memIsDisjoint2(buf, count, state, beltMAC_keep()));
// накопить полный блок
if (st->filled < 16)
{
if (count <= 16 - st->filled)
{
memCopy(st->block + st->filled, buf, count);
st->filled += count... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x60(%rdx), %rax
cmpq $0xf, %rax
ja 0x29780
pushq $0x10
popq %rdx
subq %rax, %rdx
leaq (%rbx,%rax), %rdi
addq $0x50, %rdi
cmpq %r14, %rdx
jae 0x297f0
movq %r15, %rsi
callq 0xe970
movq 0x60(%rbx), %rax
addq %rax, ... | /agievich[P]bee2/src/crypto/belt/belt_mac.c |
beltMACStepG_internal | static void beltMACStepG_internal(void* state)
{
belt_mac_st* st = (belt_mac_st*)state;
ASSERT(memIsValid(state, beltMAC_keep()));
// полный блок?
if (st->filled == 16)
{
#if (OCTET_ORDER == BIG_ENDIAN)
beltBlockRevU32(st->block);
#endif
beltBlockXor(st->mac, st->s, st->block);
st->mac[0] ^= st->r[1];
st->... | pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rax
cmpq $0x10, %rax
jne 0x2987d
movq 0x50(%rbx), %rax
xorq 0x20(%rbx), %rax
movq 0x58(%rbx), %rcx
xorq 0x28(%rbx), %rcx
movl 0x34(%rbx), %edx
movl %eax, %esi
xorl %edx, %esi
movl %esi, 0x40(%rbx)
shrq $0x20, %rax
xorl 0x38(%rbx), %eax
movl %eax, 0x44(%rbx)
movl 0x3c(%rbx), ... | /agievich[P]bee2/src/crypto/belt/belt_mac.c |
beltMACStepV | bool_t beltMACStepV(const octet mac[8], void* state)
{
belt_mac_st* st = (belt_mac_st*)state;
ASSERT(memIsValid(mac, 8));
beltMACStepG_internal(state);
#if (OCTET_ORDER == BIG_ENDIAN)
st->mac[0] = u32Rev(st->mac[0]);
st->mac[1] = u32Rev(st->mac[1]);
#endif
return memEq(mac, st->mac, 8);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x29838
addq $0x40, %rbx
pushq $0x8
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf140
| /agievich[P]bee2/src/crypto/belt/belt_mac.c |
beltMACStepV2 | bool_t beltMACStepV2(const octet mac[], size_t mac_len, void* state)
{
belt_mac_st* st = (belt_mac_st*)state;
ASSERT(mac_len <= 8);
ASSERT(memIsValid(mac, mac_len));
beltMACStepG_internal(st);
#if (OCTET_ORDER == BIG_ENDIAN)
st->mac[0] = u32Rev(st->mac[0]);
st->mac[1] = u32Rev(st->mac[1]);
#endif
return memEq(ma... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x29838
addq $0x40, %rbx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xf140
| /agievich[P]bee2/src/crypto/belt/belt_mac.c |
beltPBKDF2 | err_t beltPBKDF2(octet key[32], const octet pwd[], size_t pwd_len,
size_t iter, const octet salt[], size_t salt_len)
{
void* state;
octet* t;
// проверить входные данные
if (iter == 0 ||
!memIsValid(pwd, pwd_len) ||
!memIsValid(salt, salt_len) ||
!memIsValid(key, 32))
return ERR_BAD_INPUT;
// создать сост... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
pushq $0x6d
popq %rbp
testq %rcx, %rcx
je 0x29b60
movq %r9, %r12
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x29b60
movq %r13, %rdi... | /agievich[P]bee2/src/crypto/belt/belt_pbkdf.c |
bignIdExtract | err_t bignIdExtract(octet id_privkey[], octet id_pubkey[],
const bign_params* params, const octet oid_der[], size_t oid_len,
const octet id_hash[], const octet sig[], octet pubkey[])
{
err_t code;
size_t no, n;
// состояние (буферы могут пересекаться)
void* state;
ec_o* ec; /* описание эллиптической кривой */... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %r12
movq %r8, %r13
movq %rcx, %rbp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0x150, %esi # imm = 0x150
movq %rdx, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x29ef6
movq %rbx, %rdi
callq 0x101d0
testl %eax, %... | /agievich[P]bee2/src/crypto/bign/bign_ibs.c |
bignIdSign | err_t bignIdSign(octet id_sig[], const bign_params* params,
const octet oid_der[], size_t oid_len, const octet id_hash[],
const octet hash[], const octet id_privkey[], gen_i rng, void* rng_state)
{
err_t code;
size_t no, n;
// состояние (буферы могут пересекаться)
void* state;
ec_o* ec; /* описание эллиптич... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %r14
movq %r8, %rbp
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
movl $0x150, %esi # imm = 0x150
movq %rbx, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x2a2db
movq %rbx, %rdi
callq 0x101d0
testl %eax, %... | /agievich[P]bee2/src/crypto/bign/bign_ibs.c |
bignIdVerify | err_t bignIdVerify(const bign_params* params, const octet oid_der[],
size_t oid_len, const octet id_hash[], const octet hash[],
const octet id_sig[], const octet id_pubkey[], const octet pubkey[])
{
err_t code;
size_t no, n;
// состояние (буферы R и V совпадают)
void* state;
ec_o* ec; /* описание эллиптическ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, %rbp
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
movl $0x150, %esi # imm = 0x150
callq 0xeeb0
testl %eax, %eax
je 0x2ab57
movq %rbx, %rdi
callq 0x101d0
testl %eax, %eax
je 0x2ab5c
m... | /agievich[P]bee2/src/crypto/bign/bign_ibs.c |
bignIdVerify_deep | static size_t bignIdVerify_deep(size_t n, size_t f_deep, size_t ec_d,
size_t ec_deep)
{
return O_OF_W(7 * n + 2) + beltHash_keep() +
utilMax(5,
beltHash_keep(),
ecpIsOnA_deep(n, f_deep),
zzMul_deep(n / 2, n / 2),
zzMod_deep(n + 1, n),
ecAddMulA_deep(n, ec_d, ec_deep, 3, n, n / 2 + 1, n));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rsi, %rbp
movq %rdi, %r14
imulq $0x38, %rdi, %r15
xorl %eax, %eax
callq 0xe560
movq %rax, %rbx
addq %r15, %rbx
xorl %eax, %eax
callq 0xe560
movq %rax, 0x10(%rsp)
movq %r14, %rdi
movq %rbp... | /agievich[P]bee2/src/crypto/bign/bign_ibs.c |
bignKeyWrap | err_t bignKeyWrap(octet token[], const bign_params* params, const octet key[],
size_t len, const octet header[16], const octet pubkey[],
gen_i rng, void* rng_state)
{
err_t code;
size_t no, n;
// состояние
void* state;
ec_o* ec; /* описание эллиптической кривой */
word* k; /* [n] одноразовый личный ключ *... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r13
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, 0x40(%rsp)
movl $0x150, %esi # imm = 0x150
movq %rbx, %rdi
callq 0xeeb0
pushq $0x6d
popq %rbp
testl %eax, %eax
je 0x2af5f
movq %rbx, %rdi... | /agievich[P]bee2/src/crypto/bign/bign_keyt.c |
bignKeyUnwrap | err_t bignKeyUnwrap(octet key[], const bign_params* params, const octet token[],
size_t len, const octet header[16], const octet privkey[])
{
err_t code;
size_t no, n;
// состояние (буферы могут пересекаться)
void* state;
ec_o* ec; /* описание эллиптической кривой */
word* d; /* [n] личный ключ */
word* ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, %rbp
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, 0x30(%rsp)
movl $0x150, %esi # imm = 0x150
movq %rbx, %rdi
callq 0xeeb0
pushq $0x6d
popq %r15
testl %eax, %eax
je 0x2b37c
movq %rbx, %rdi... | /agievich[P]bee2/src/crypto/bign/bign_keyt.c |
bignIsOperable | bool_t bignIsOperable(const bign_params* params)
{
size_t no;
// pre
ASSERT(memIsValid(params, sizeof(bign_params)));
// корректный уровень стойкости?
// p mod 4 == 3? q mod 2 == 1?
// p и q -- 2l-битовые?
// a != 0? b != 0?
// неиспользуемые октеты обнулены?
return
(params->l == 128 || params->l == 192 || p... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rax
xorl %ebx, %ebx
cmpq $0x80, %rax
je 0x2b66b
cmpq $0x100, %rax # imm = 0x100
je 0x2b66b
cmpq $0xc0, %rax
jne 0x2b6a7
movb 0x8(%r14), %cl
notb %cl
testb $0x3, %cl
jne 0x2b6a7
testb $0x1, 0xc8(%r14)
je... | /agievich[P]bee2/src/crypto/bign/bign_lcl.c |
bignKeypairGen | err_t bignKeypairGen(octet privkey[], octet pubkey[],
const bign_params* params, gen_i rng, void* rng_state)
{
err_t code;
size_t no, n;
// состояние
void* state;
ec_o* ec; /* описание эллиптической кривой */
word* d; /* [n] личный ключ */
word* Q; /* [2n] открытый ключ */
void* stack;
// проверить p... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r15
movl $0x150, %esi # imm = 0x150
movq %rdx, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x2b9bf
movq %rbp, %rdi
callq 0x101d0
testl %eax, %eax
je 0x2b9c4
... | /agievich[P]bee2/src/crypto/bign/bign_misc.c |
bignKeypairVal | err_t bignKeypairVal(const bign_params* params, const octet privkey[],
const octet pubkey[])
{
err_t code;
size_t no, n;
// состояние
void* state;
ec_o* ec; /* описание эллиптической кривой */
word* d; /* [n] личный ключ */
word* Q; /* [2n] открытый ключ */
void* stack;
// проверить params
if (!memI... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movl $0x150, %esi # imm = 0x150
callq 0xeeb0
testl %eax, %eax
je 0x2bb59
movq %r15, %rdi
callq 0x101d0
testl %eax, %eax
je 0x2bb5d
movq (%r15), %rdi
leaq 0x177(%rip), %rsi ... | /agievich[P]bee2/src/crypto/bign/bign_misc.c |
bignPubkeyCalc | err_t bignPubkeyCalc(octet pubkey[], const bign_params* params,
const octet privkey[])
{
err_t code;
size_t no, n;
// состояние
void* state;
ec_o* ec; /* описание эллиптической кривой */
word* d; /* [n] личный ключ */
word* Q; /* [2n] открытый ключ */
void* stack;
// проверить params
if (!memIsValid... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
movl $0x150, %esi # imm = 0x150
movq %r15, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x2be4c
movq %r15, %rdi
callq 0x101d0
testl %eax, %eax
je 0x2be50
movq (%r15), %rdi
leaq 0x135(%r... | /agievich[P]bee2/src/crypto/bign/bign_misc.c |
bignDH | err_t bignDH(octet key[], const bign_params* params, const octet privkey[],
const octet pubkey[], size_t key_len)
{
err_t code;
size_t no, n;
// состояние
void* state;
ec_o* ec; /* описание эллиптической кривой */
word* d; /* [n] личный ключ */
word* Q; /* [2n] открытый ключ */
void* stack;
// провер... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movl $0x150, %esi # imm = 0x150
movq %rbp, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x2c088
movq %rbp, %rdi
callq 0x101d0
testl %eax, %eax
je 0x2c08c
... | /agievich[P]bee2/src/crypto/bign/bign_misc.c |
bignParamsStd | err_t bignParamsStd(bign_params* params, const char* name)
{
if (!memIsValid(params, sizeof(bign_params)))
return ERR_BAD_INPUT;
memSetZero(params, sizeof(bign_params));
if (strEq(name, _curve128v1_name))
{
params->l = 128;
memCopy(params->p, _curve128v1_p, 32);
memCopy(params->a, _curve128v1_a, 32);
memC... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x150, %esi # imm = 0x150
callq 0xeeb0
testl %eax, %eax
je 0x2c2d9
xorl %ebp, %ebp
movl $0x150, %edx # imm = 0x150
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf710
leaq 0x22eb0(%rip), %rsi # 0x4f0c0
movq %r14, %rdi
callq 0xebd0... | /agievich[P]bee2/src/crypto/bign/bign_params.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.