name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
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, %rdx
movq %rcx, %rsi
shlq $0x4, %rsi
leaq -0x4(%rdx), %rax
testq %rsi, %rsi
cmoveq %rcx, %rsi
cmoveq %rdx, %rax
leaq (,%rsi,4), %rcx
leaq -0x2(%rax), %rdx
testq %rcx, %rcx
cmovneq %rcx, %rsi
cmoveq %rax, %rdx
leaq (,%rsi,2), %rax
sarq $0x3f, %rsi
testq %rax, %rax
pushq $-0x2
popq %rax
cmoveq %rsi, %rax
addq %rdx, %rax
retq
| /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 # imm = 0x100
cmovbq %rsi, %rcx
cmovbq %rax, %rdx
movq %rcx, %rax
shrq $0x4, %rax
leaq -0x4(%rdx), %rsi
cmpq $0x10, %rcx
cmovbq %rcx, %rax
cmovbq %rdx, %rsi
movq %rax, %rcx
shrq $0x2, %rcx
leaq -0x2(%rsi), %rdx
cmpq $0x4, %rax
cmovbq %rax, %rcx
cmovbq %rsi, %rdx
movq %rcx, %rsi
negq %rsi
cmpq $0x2, %rcx
pushq $-0x2
popq %rax
cmovbq %rsi, %rax
addq %rdx, %rax
retq
| /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)) & 0x2222222222222222, w ^= t ^ (t << 1);
t = 0;
return w;
} | 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 = 0x101
xorq %rax, %rcx
movq %rcx, %rax
shrq $0x4, %rax
xorq %rcx, %rax
movabsq $0xf000f000f000f0, %rdx # imm = 0xF000F000F000F0
andq %rax, %rdx
imulq $0x11, %rdx, %rax
xorq %rcx, %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, %rcx
movq %rcx, %rax
shrq %rax
xorq %rcx, %rax
movabsq $0x2222222222222222, %rdx # imm = 0x2222222222222222
andq %rax, %rdx
leaq (%rdx,%rdx,2), %rax
xorq %rcx, %rax
retq
| /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)) & 0x00000000FFFF0000, w ^= t ^ (t << 16);
t = 0;
return w;
} | 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, %rcx
movq %rcx, %rax
shrq $0x4, %rax
xorq %rcx, %rax
movabsq $0xf000f000f000f0, %rdx # imm = 0xF000F000F000F0
andq %rax, %rdx
imulq $0x11, %rdx, %rax
xorq %rcx, %rax
movq %rax, %rcx
shrq $0x8, %rcx
xorq %rax, %rcx
movabsq $0xff000000ff00, %rdx # imm = 0xFF000000FF00
andq %rcx, %rdx
imulq $0x101, %rdx, %rcx # imm = 0x101
xorq %rax, %rcx
movq %rcx, %rax
shrq $0x10, %rax
xorl %ecx, %eax
andl $0xffff0000, %eax # imm = 0xFFFF0000
imulq $0x10001, %rax, %rax # imm = 0x10001
xorq %rcx, %rax
retq
| /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 %rcx, %rdx
imulq %rdx, %rdi
leaq 0x2(%rdi), %rax
imulq %rdx, %rax
retq
| /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[count] = u64Rev(dest[count]);
#endif // OCTET_ORDER
} | 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*)dest)[t] = (octet)u;
}
for (count /= 8; count--;)
((u64*)dest)[count] = u64Rev(((u64*)dest)[count]);
#endif // OCTET_ORDER
} | 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)
movaps %xmm6, 0x30(%rsp)
movaps %xmm7, 0x40(%rsp)
movq %r10, -0x70(%rsp)
leaq 0x60(%rsp), %rdx
movq %rdx, -0x78(%rsp)
movabsq $0x3000000008, %rax # imm = 0x3000000008
movq %rax, -0x80(%rsp)
movl $0x8, %ecx
movabsq $-0x1, %rax
subq $0x1, %rdi
jb 0x14fa7
cmpl $0x28, %ecx
ja 0x14f8f
movq %rdx, %rsi
movl %ecx, %edx
addq %r10, %rdx
addl $0x8, %ecx
movl %ecx, -0x80(%rsp)
jmp 0x14f98
leaq 0x8(%rdx), %rsi
movq %rsi, -0x78(%rsp)
movq (%rdx), %rdx
cmpq %rax, %rdx
cmovbq %rdx, %rax
movq %rsi, %rdx
jmp 0x14f73
addq $0x58, %rsp
retq
| /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)
movaps %xmm6, 0x30(%rsp)
movaps %xmm7, 0x40(%rsp)
movq %r10, -0x70(%rsp)
leaq 0x60(%rsp), %rdx
movq %rdx, -0x78(%rsp)
movabsq $0x3000000008, %rax # imm = 0x3000000008
movq %rax, -0x80(%rsp)
movl $0x8, %ecx
xorl %eax, %eax
subq $0x1, %rdi
jb 0x1504d
cmpl $0x28, %ecx
ja 0x15035
movq %rdx, %rsi
movl %ecx, %edx
addq %r10, %rdx
addl $0x8, %ecx
movl %ecx, -0x80(%rsp)
jmp 0x1503e
leaq 0x8(%rdx), %rsi
movq %rsi, -0x78(%rsp)
movq (%rdx), %rdx
cmpq %rax, %rdx
cmovaq %rdx, %rax
movq %rsi, %rdx
jmp 0x15019
addq $0x58, %rsp
retq
| /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, %edx
callq 0xf8b0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
| /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;
// закрыть мьютекс
mtMtxClose(_mtx);
} | 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), %rdi # 0x68510
popq %rbx
jmp 0xff00
| /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;
// создать состояние
state = blobCreate(utilMax(2, beltHash_keep(), beltKRP_keep() + 16));
if (state == 0)
return ERR_OUTOFMEMORY;
block = (octet*)state + beltKRP_keep();
// key <- beltHash(secret || iv)
beltHashStart(state);
beltHashStepH(secret, secret_len, state);
beltHashStepH(iv, iv_len, state);
beltHashStepG(key, state);
// key <- beltKRP(Y, 1^96, num)
memSet(block, 0xFF, 12);
beltKRPStart(state, key, 32, block);
CASSERT(B_PER_S <= 128);
memCopy(block, &num, sizeof(size_t));
#if (OCTET_ORDER == BIG_ENDIAN)
memRev(block, sizeof(size_t));
#endif
memSetZero(block + sizeof(size_t), 16 - sizeof(size_t));
beltKRPStepG(key, 32, block, state);
// завершить
blobClose(state);
return ERR_OK;
} | 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 0xeeb0
testl %eax, %eax
je 0x152b6
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x152b6
movq %r14, 0x18(%rsp)
xorl %ebx, %ebx
xorl %eax, %eax
callq 0xe560
movq %rax, %r14
xorl %eax, %eax
callq 0xf720
leaq 0x10(%rax), %rdx
pushq $0x2
popq %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0xe320
movq %rax, %rdi
callq 0xf190
testq %rax, %rax
je 0x152b3
movq %rax, %r14
xorl %eax, %eax
callq 0xf720
movq %rax, 0x10(%rsp)
addq %r14, %rax
movq %rax, 0x8(%rsp)
movq %r14, %rdi
callq 0xe5d0
movq %rbp, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0xe360
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xe360
movq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0xf1f0
pushq $0xc
popq %rdx
movq 0x8(%rsp), %rbp
movq %rbp, %rdi
movl $0xff, %esi
callq 0xf710
pushq $0x20
popq %r15
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %rbp, %rcx
callq 0xe850
leaq 0x20(%rsp), %rsi
pushq $0x8
popq %r12
movq %rbp, %rdi
movq %r12, %rdx
callq 0xe970
movq 0x10(%rsp), %rax
leaq (%r14,%rax), %rdi
addq $0x8, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0xf710
movq %r13, %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r14, %rcx
callq 0xe380
movq %r14, %rdi
callq 0xe920
jmp 0x152b6
pushq $0x6e
popq %rbx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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] (совпадает с Qa) */
octet* block0; /* [16] (совпадает с t) */
octet* block1; /* [16] (следует за block0) */
void* stack;
// проверить входные данные
if (!objIsOperable(s))
return ERR_BAD_INPUT;
n = s->ec->f->n, no = s->ec->f->no;
if (!memIsValid(in, 2 * no + (s->settings->kca ? 8u : 0)) ||
!memIsValid(out, s->settings->kcb ? 8u : 0) ||
!memIsValid(certa, sizeof(bake_cert)) ||
!memIsValid(certa->data, certa->len) ||
certa->val == 0)
return ERR_BAD_INPUT;
ASSERT(memIsDisjoint2(out, s->settings->kcb ? 8u : 0, s, objKeep(s)));
// раскладка стека
Qa = objEnd(s, word);
Va = Qa + 2 * n;
t = Va + 2 * n;
sb = t + n / 2 + 1;
stack = sb + n + n / 2 + 1;
K = (octet*)Qa;
block0 = (octet*)t;
block1 = block0 + 16;
ASSERT(block1 + 16 <= (octet*)stack);
// проверить certa
code = certa->val((octet*)Qa, s->params, certa->data, certa->len);
ERR_CALL_CHECK(code);
if (!qrFrom(ecX(Qa), (octet*)Qa, s->ec->f, stack) ||
!qrFrom(ecY(Qa, n), (octet*)Qa + no, s->ec->f, stack) ||
!ecpIsOnA(Qa, s->ec, stack))
return ERR_BAD_CERT;
// Va <- in, Va \in E*?
if (!qrFrom(ecX(Va), in, s->ec->f, stack) ||
!qrFrom(ecY(Va, n), in + no, s->ec->f, stack) ||
!ecpIsOnA(Va, s->ec, stack))
return ERR_BAD_POINT;
// t <- <beltHash(<Va>_2l || <Vb>_2l)>_l
beltHashStart(stack);
beltHashStepH(in, no, stack);
beltHashStepH(s->Vb, no, stack);
beltHashStepG2((octet*)t, no / 2, stack);
wwFrom(t, t, no / 2);
// sb <- (ub - (2^l + t)db) \mod q
zzMul(sb, t, n / 2, s->d, n, stack);
sb[n + n / 2] = zzAdd2(sb + n / 2, s->d, n);
zzMod(sb, sb, n + n / 2 + 1, s->ec->order, n, stack);
zzSubMod(sb, s->u, sb, s->ec->order, n);
// K <- sb(Va - (2^l + t)Qa), K == O => K <- G
t[n / 2] = 1;
if (!ecMulA(Qa, Qa, s->ec, t, n / 2 + 1, stack))
return ERR_BAD_PARAMS;
if (!ecpSubAA(Va, Va, Qa, s->ec, stack))
qrTo(K, s->ec->base, s->ec->f, stack);
else
{
if (!ecMulA(Va, Va, s->ec, sb, n, stack))
return ERR_BAD_PARAMS;
qrTo(K, ecX(Va), s->ec->f, stack);
}
// K <- beltHash(<K>_2l || certa || certb || helloa || hellob)
beltHashStart(stack);
beltHashStepH(K, no, stack);
beltHashStepH(certa->data, certa->len, stack);
beltHashStepH(s->cert->data, s->cert->len, stack);
if (s->settings->helloa)
beltHashStepH(s->settings->helloa, s->settings->helloa_len, stack);
if (s->settings->hellob)
beltHashStepH(s->settings->hellob, s->settings->hellob_len, stack);
beltHashStepG(K, stack);
// K0 <- beltKRP(K, 1^96, 0)
memSetZero(block0, 16);
memSet(block1, 0xFF, 16);
beltKRPStart(stack, K, 32, block1);
beltKRPStepG(s->K0, 32, block0, stack);
// K1 <- beltKRP(K, 1^96, 1)
if (s->settings->kca || s->settings->kcb)
{
block0[0] = 1;
beltKRPStepG(s->K1, 32, block0, stack);
}
// Ta == beltMAC(0^128, K1)?
if (s->settings->kca)
{
block0[0] = 0;
beltMACStart(stack, s->K1, 32);
beltMACStepA(block0, 16, stack);
if (!beltMACStepV(in + 2 * no, stack))
return ERR_AUTH;
}
// Tb <- beltMAC(1^128, K1)?
if (s->settings->kcb)
{
beltMACStart(stack, s->K1, 32);
beltMACStepA(block1, 16, stack);
beltMACStepG(out, stack);
}
// все нормально
return ERR_OK;
} | 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 0x38(%rax), %r12
leaq (%r12,%r12), %rcx
xorl %eax, %eax
cmpl $0x0, 0x188(%r14)
setne %al
movq %rcx, 0x50(%rsp)
leaq (%rcx,%rax,8), %rsi
movq %r15, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x160db
xorl %esi, %esi
cmpl $0x0, 0x18c(%r14)
setne %sil
shll $0x3, %esi
movq %rbx, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x160db
pushq $0x18
popq %rsi
movq %rbp, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x160db
movq (%rbp), %rdi
movq 0x8(%rbp), %rsi
callq 0xeeb0
testl %eax, %eax
je 0x160db
movq %rbx, 0x48(%rsp)
movq 0x10(%rbp), %rax
testq %rax, %rax
je 0x160db
movq (%r14), %rbx
addq %r14, %rbx
leaq 0x38(%r14), %rsi
movq (%rbp), %rdx
movq 0x8(%rbp), %rcx
movq %rbx, %rdi
callq *%rax
movl %eax, %r13d
testl %eax, %eax
je 0x160ed
movl %r13d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %rsi
movq %rsi, %rax
shlq $0x4, %rax
leaq (%rbx,%rax), %rdx
movq %rax, 0x40(%rsp)
movq %rdx, 0x20(%rsp)
addq %rdx, %rax
movq %rsi, %rcx
shrq %rcx
movq %rax, 0x18(%rsp)
leaq (%rax,%rcx,8), %rax
leaq (%rax,%rsi,8), %rax
addq $0x8, %rax
movq %rcx, 0x38(%rsp)
leaq 0x8(%rax,%rcx,8), %rcx
movq 0x18(%r14), %rax
movq 0x18(%rax), %rdx
movq %rbx, %rdi
movq %rbx, %rsi
movq %rcx, 0x8(%rsp)
callq *0x40(%rdx)
movl $0x202, %r13d # imm = 0x202
testl %eax, %eax
je 0x160db
movq 0x18(%r14), %rax
movq 0x18(%rax), %rdx
movq 0x10(%rsp), %rax
leaq (%rbx,%rax,8), %rdi
leaq (%rbx,%r12), %rsi
movq 0x8(%rsp), %rcx
callq *0x40(%rdx)
testl %eax, %eax
je 0x160db
movq 0x18(%r14), %rsi
movq %rbx, %rdi
movq 0x8(%rsp), %rdx
callq 0xfbd0
testl %eax, %eax
je 0x160db
movq %rbx, 0x30(%rsp)
movq 0x18(%r14), %rax
movq 0x18(%rax), %rdx
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq 0x8(%rsp), %rcx
callq *0x40(%rdx)
movl $0x191, %r13d # imm = 0x191
testl %eax, %eax
je 0x160db
movq 0x18(%r14), %rax
movq 0x18(%rax), %rdx
movq 0x10(%rsp), %rax
leaq (%rbx,%rax,8), %rdi
leaq (%r15,%r12), %rsi
movq 0x8(%rsp), %rcx
callq *0x40(%rdx)
testl %eax, %eax
je 0x160db
movq 0x18(%r14), %rsi
movq %rbx, %rdi
movq 0x8(%rsp), %rdx
callq 0xfbd0
testl %eax, %eax
je 0x160db
movq 0x18(%rsp), %rbx
movq 0x38(%rsp), %rax
leaq (%rbx,%rax,8), %rax
addq $0x8, %rax
movq %rax, 0x28(%rsp)
movq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0xe5d0
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xe360
movq 0x30(%r14), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xe360
movq %r12, %r13
shrq %r13
movq %rbx, %rdi
movq %r13, %rsi
movq 0x8(%rsp), %rdx
callq 0xfa20
movq %rbx, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0xf540
movq 0x20(%r14), %rcx
movq 0x28(%rsp), %rdi
movq %rbx, %rsi
movq 0x38(%rsp), %r13
movq %r13, %rdx
movq 0x10(%rsp), %rbx
movq %rbx, %r8
movq 0x8(%rsp), %r9
callq 0xe240
movq 0x28(%rsp), %rax
leaq (%rax,%r13,8), %rdi
movq 0x20(%r14), %rsi
movq %rbx, %rdx
callq 0xe1a0
leaq (%rbx,%r13), %rcx
movq 0x28(%rsp), %rdi
movq %rax, (%rdi,%rcx,8)
leaq (%rbx,%r13), %rdx
incq %rdx
movq 0x18(%r14), %rax
movq 0x38(%rax), %rcx
movq %rdi, %rsi
movq %rdi, %r13
movq %rbx, %r8
movq 0x8(%rsp), %r9
callq 0xfc00
movq 0x18(%r14), %rax
movq 0x28(%r14), %rsi
movq 0x38(%rax), %rcx
movq %r13, %rdi
movq %r13, %rdx
movq %rbx, %r8
callq 0xec10
movq $0x1, -0x8(%r13)
movq 0x30(%rsp), %rbx
movq 0x18(%r14), %rdx
movq 0x38(%rsp), %r8
incq %r8
movq %rbx, %rdi
movq %rbx, %rsi
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %r9
callq 0xff30
movl $0x1f6, %r13d # imm = 0x1F6
testl %eax, %eax
je 0x160db
movq 0x18(%r14), %rcx
movq 0x20(%rsp), %rdi
movq %rdi, %rsi
movq %rbx, %rdx
movq 0x8(%rsp), %r8
callq 0xee90
movq 0x18(%r14), %rdx
testl %eax, %eax
je 0x16381
movq 0x20(%rsp), %rdi
movq %rdi, %rsi
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %r9
callq 0xff30
testl %eax, %eax
movq 0x30(%rsp), %rbx
je 0x160db
movq 0x18(%r14), %rax
movq 0x18(%rax), %rdx
movq %rbx, %rdi
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %r13
movq %r13, %rcx
callq *0x48(%rdx)
jmp 0x1639f
movq 0x18(%rdx), %rax
movq 0x30(%rdx), %rsi
movq 0x30(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rdx
movq 0x8(%rsp), %r13
movq %r13, %rcx
callq *0x48(%rax)
movq %r13, %rdi
callq 0xe5d0
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xe360
movq (%rbp), %rdi
movq 0x8(%rbp), %rsi
movq %r13, %rdx
callq 0xe360
movq 0x1c0(%r14), %rdi
movq 0x1c8(%r14), %rsi
movq %r13, %rdx
callq 0xe360
movq 0x190(%r14), %rdi
testq %rdi, %rdi
je 0x163f6
movq 0x198(%r14), %rsi
movq %r13, %rdx
callq 0xe360
movq 0x40(%rsp), %rax
movq 0x20(%rsp), %rcx
addq %rcx, %rax
addq $0x10, %rax
movq %rax, 0x10(%rsp)
movq 0x1a0(%r14), %rdi
testq %rdi, %rdi
je 0x16427
movq 0x1a8(%r14), %rsi
movq %r13, %rdx
callq 0xe360
movq 0x30(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0xf1f0
movq %r13, %r12
xorl %r13d, %r13d
pushq $0x10
popq %rdx
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0xf710
movq 0x10(%rsp), %rbp
movq %rbp, %rdi
movl $0xff, %esi
pushq $0x10
popq %rdx
callq 0xf710
pushq $0x20
popq %rdx
movq %r12, %rdi
movq %rbx, %rsi
movq %rdx, %rbx
movq %rbp, %rcx
callq 0xe850
leaq 0x1d8(%r14), %rdi
movq %rbx, %rsi
movq 0x18(%rsp), %rdx
movq %r12, %rcx
callq 0xe380
cmpl $0x0, 0x188(%r14)
jne 0x164a4
cmpl $0x0, 0x18c(%r14)
je 0x160db
movq 0x18(%rsp), %r13
movb $0x1, (%r13)
leaq 0x1f8(%r14), %rbp
pushq $0x20
popq %rsi
movq %rbp, %rdi
movq %r13, %rdx
movq %r12, %rcx
callq 0xe380
cmpl $0x0, 0x188(%r14)
je 0x16505
movb $0x0, (%r13)
pushq $0x20
popq %rdx
movq %r12, %rdi
movq %rbp, %rsi
callq 0xe5b0
pushq $0x10
popq %rsi
movq %r13, %rdi
movq %r12, %rdx
callq 0xebf0
addq 0x50(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0xf8c0
testl %eax, %eax
je 0x16546
xorl %r13d, %r13d
cmpl $0x0, 0x18c(%r14)
je 0x160db
pushq $0x20
popq %rdx
movq %r12, %rdi
movq %rbp, %rsi
callq 0xe5b0
pushq $0x10
popq %rsi
movq 0x10(%rsp), %rdi
movq %r12, %rdx
callq 0xebf0
movq 0x48(%rsp), %rdi
movq %r12, %rsi
callq 0xe6c0
jmp 0x160db
movl $0x209, %r13d # imm = 0x209
jmp 0x160db
| /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] */
void* state; /* [bakeBMQV_keep()] */
// проверить key
if (!memIsValid(key, 32))
return ERR_BAD_INPUT;
// создать блоб
if (params->l != 128 && params->l != 192 && params->l != 256)
return ERR_BAD_PARAMS;
blob = blobCreate(params->l + 8 + bakeBMQV_keep(params->l));
if (blob == 0)
return ERR_OUTOFMEMORY;
// раскладка блоба
in = (octet*)blob;
out = in + params->l / 2 + 8;
state = out + params->l / 2;
// старт
code = bakeBMQVStart(state, params, settings, privkeyb, certb);
ERR_CALL_HANDLE(code, blobClose(blob));
// шаг 2
code = bakeBMQVStep2(out, state);
ERR_CALL_HANDLE(code, blobClose(blob));
code = write(&len, out, params->l / 2, file);
ERR_CALL_HANDLE(code, blobClose(blob));
// шаг 4
code = read(&len, in, params->l / 2 + (settings->kca ? 8u : 0), file);
ERR_CALL_HANDLE(code, blobClose(blob));
code = bakeBMQVStep4(out, in, certa, state);
ERR_CALL_HANDLE(code, blobClose(blob));
if (settings->kcb)
{
code = write(&len, out, 8, file);
ERR_CALL_HANDLE(code, blobClose(blob));
}
// завершение
code = bakeBMQVStepG(key, state);
blobClose(blob);
return code;
} | 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 0x166a2
cmpq $0x100, %r14 # imm = 0x100
je 0x166a2
movl $0x1f6, %ebp # imm = 0x1F6
cmpq $0xc0, %r14
jne 0x16716
movq %r14, %rdi
callq 0xfae0
leaq (%r14,%rax), %rdi
addq $0x8, %rdi
callq 0xf190
testq %rax, %rax
je 0x16713
movq %rbx, 0x18(%rsp)
movq (%r13), %r14
shrq %r14
movq %rax, %rbx
addq %r14, %rax
movq %r12, %r8
leaq 0x8(%r14,%rax), %r12
movq %r12, %rdi
movq %r13, %rsi
movq (%rsp), %rdx
movq %r15, %rcx
callq 0xee70
testl %eax, %eax
jne 0x16703
leaq (%rbx,%r14), %r15
addq $0x8, %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0xf5b0
testl %eax, %eax
je 0x16727
movl %eax, %ebp
movq %rbx, %rdi
callq 0xe920
jmp 0x16716
pushq $0x6d
jmp 0x16715
pushq $0x6e
popq %rbp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %r14
movq 0x70(%rsp), %rbx
movq (%r13), %rdx
shrq %rdx
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq *0x68(%rsp)
testl %eax, %eax
je 0x16750
movl %eax, %ebp
movq %r14, %rdi
jmp 0x16708
movq %r15, 0x8(%rsp)
movq (%r13), %rax
shrq %rax
xorl %ecx, %ecx
movq (%rsp), %rdx
cmpl $0x0, (%rdx)
setne %cl
leaq (%rax,%rcx,8), %rdx
leaq 0x10(%rsp), %rdi
movq %rbx, %r15
movq %r14, %rbx
movq %r14, %rsi
movq %r15, %rcx
callq *0x60(%rsp)
testl %eax, %eax
jne 0x16703
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq 0x20(%rsp), %rdx
movq %r12, %rcx
callq 0xf5d0
testl %eax, %eax
jne 0x16703
movq (%rsp), %rax
cmpl $0x0, 0x4(%rax)
je 0x167c8
leaq 0x10(%rsp), %rdi
pushq $0x8
popq %rdx
movq 0x8(%rsp), %rsi
movq %r15, %rcx
callq *0x68(%rsp)
testl %eax, %eax
jne 0x16749
movq 0x18(%rsp), %rdi
movq %r12, %rsi
callq 0xe4a0
jmp 0x16749
| /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, f_deep, ec_d, ec_deep));
} | 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 %rbp, 0x30(%rsp)
movq %r15, %rdx
movq %r15, 0x38(%rsp)
movq %r12, %rcx
callq 0xfa10
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe320
movq %rax, 0x48(%rsp)
movq %r12, %r13
shlq $0x5, %r13
movq %r12, %rdi
movq %rbx, %rsi
callq 0xf530
movq %rax, 0x28(%rsp)
movq %r12, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0xfa10
movq %rax, (%rsp)
xorl %eax, %eax
callq 0xe560
movq %rax, 0x18(%rsp)
movq %r12, %rbp
shrq %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0xfe10
movq %rax, 0x10(%rsp)
leaq 0x1(%rbp), %rax
movq %rax, 0x40(%rsp)
leaq (%r12,%rbp), %rdi
incq %rdi
movq %rdi, 0x20(%rsp)
movq %r12, %rsi
callq 0xe7f0
movq %rax, 0x8(%rsp)
xorl %eax, %eax
callq 0xf720
movq %rax, %r15
xorl %eax, %eax
callq 0xfa60
movq %rax, %r14
xorl %eax, %eax
callq 0xebc0
movq %rax, %r10
pushq $0x9
popq %rdi
movq %rbx, %rsi
movq 0x28(%rsp), %rdx
movq (%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x10(%rsp), %r9
xorl %eax, %eax
pushq %r10
pushq %r14
pushq %r15
pushq 0x20(%rsp)
callq 0xe320
addq $0x20, %rsp
addq %r13, %rax
addq $0x30, %rax
movq %rax, 0x28(%rsp)
imulq $0x30, %r12, %rax
movq %rax, (%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0xf530
movq %rax, 0x18(%rsp)
movq %r12, %rdi
movq 0x30(%rsp), %r15
movq %r15, %rsi
movq 0x38(%rsp), %r14
movq %r14, %rdx
movq %r12, %rcx
callq 0xfa10
movq %rax, 0x10(%rsp)
xorl %eax, %eax
callq 0xe560
movq %rax, 0x8(%rsp)
movq %rbp, %rdi
movq %r12, %rsi
callq 0xfe10
movq %rax, %rbp
movq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0xe7f0
movq %rax, 0x20(%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
pushq $0x2
popq %rcx
movq %r12, %r8
movq 0x40(%rsp), %r9
xorl %eax, %eax
callq 0xec00
movq %rax, %r15
xorl %eax, %eax
callq 0xf720
movq %rax, %r13
xorl %eax, %eax
callq 0xfa60
movq %rax, %r14
xorl %eax, %eax
callq 0xebc0
movq %rax, %r10
subq $0x8, %rsp
pushq $0xa
popq %rdi
movq %rbx, %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movq %rbp, %r9
xorl %eax, %eax
pushq %r10
pushq %r14
pushq %r13
pushq %r15
pushq 0x48(%rsp)
callq 0xe320
addq $0x30, %rsp
movq (%rsp), %rcx
addq %rcx, %rax
addq $0x30, %rax
movq %rax, (%rsp)
imulq $0x18, %r12, %r15
xorl %eax, %eax
callq 0xebc0
movq %rax, %r13
xorl %eax, %eax
callq 0xfa60
movq %rax, %rbp
movq %r12, %rdi
movq %rbx, %rsi
callq 0xf530
movq %rax, %r14
movq %r12, %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
pushq $0x2
popq %rcx
movq %r12, %r8
movq 0x40(%rsp), %r9
xorl %eax, %eax
callq 0xec00
pushq $0x5
popq %r12
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
movq %r14, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0xe320
addq %rax, %r15
movq %r12, %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq (%rsp), %r8
movq %r15, %r9
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe320
| /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;
// создать состояние
n = W_OF_O(len);
state = blobCreate(n + 1 + ppIsIrred_deep(n + 1));
if (state == 0)
return ERR_OUTOFMEMORY;
// раскладка состояния
f0 = (word*)state;
stack = f0 + n + 1;
// сгенерировать многочлен
f0[n] = 1;
for (reps = len * 8 * B_PER_IMPOSSIBLE * 3 / 4; reps--;)
{
ang(f0, len, ang_state);
wwFrom(f0, f0, len);
if (ppIsIrred(f0, n + 1, stack))
{
wwTo(m0, len, f0);
break;
}
}
// завершение
blobClose(state);
return reps != SIZE_MAX ? ERR_OK : ERR_BAD_ANG;
} | 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, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x1e9ab
movq %rbx, %r14
shrq $0x3, %r14
leaq 0x1(%r14), %rbp
movq %rbp, %rdi
callq 0xe840
leaq (%rax,%r14), %rdi
incq %rdi
callq 0xf190
testq %rax, %rax
je 0x1e999
movq %rax, %r13
movq %r15, 0x8(%rsp)
leaq (%rax,%rbx), %r15
addq $0x8, %r15
movq $0x1, (%rax,%rbx)
imulq $0x180, %rbx, %r14 # imm = 0x180
notq %r14
incq %r14
je 0x1e99e
movq %r13, %rdi
movq %rbx, %rsi
movq 0x10(%rsp), %rdx
callq *%r12
movq %r13, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0xf540
movq %r13, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0xed70
testl %eax, %eax
je 0x1e94b
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0xf300
xorl %ebp, %ebp
jmp 0x1e9a3
movl $0x131, %ebp # imm = 0x131
jmp 0x1e9ab
pushq $0x6e
popq %rbp
jmp 0x1e9ab
movl $0x131, %ebp # imm = 0x131
movq %r13, %rdi
callq 0xe920
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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) ||
!memIsValid(m0, len) || !memIsValid(mi, len))
return ERR_BAD_INPUT;
EXPECT(belsValM(m0, len) == ERR_OK);
// создать состояние
n = W_OF_O(len);
state = blobCreate(O_OF_W(2 * n + 2) + ppMinPolyMod_deep(n + 1));
if (state == 0)
return ERR_OUTOFMEMORY;
// раскладка состояния
f0 = (word*)state;
f = f0 + n + 1;
u = f;
stack = f + n + 1;
// загрузить многочлен
wwFrom(f0, m0, len);
f0[n] = 1;
// попытки генерации
for (reps = 3; reps--; )
{
ang(u, len, ang_state);
wwFrom(u, u, len), u[n] = 0;
// f <- минимальный многочлен элемента u
ppMinPolyMod(f, u, f0, n + 1, stack);
// f подходит?
if (f[n] == 1 && wwCmp(f, f0, n) != 0)
{
wwTo(mi, len, f);
break;
}
}
// завершение
if (reps != SIZE_MAX)
code = ERR_OK;
else if (wwEq(f, f0, n + 1))
code = ERR_BAD_ANG;
else
code = ERR_BAD_PUBKEY;
blobClose(state);
return code;
} | 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, %r14
movq %rdx, %rdi
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x1eb33
movq %r14, %rdi
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x1eb33
movq %rbx, %rax
shrq $0x3, %rax
movq %rax, 0x18(%rsp)
leaq 0x1(%rax), %rdi
movq %rdi, 0x8(%rsp)
callq 0xe760
leaq (%rax,%rbx,2), %rdi
addq $0x10, %rdi
callq 0xf190
testq %rax, %rax
je 0x1eb14
movq %rax, %r13
movq %r14, 0x10(%rsp)
movq %r12, %rsi
leaq (%rax,%rbx), %r12
addq $0x8, %r12
addq %rbx, %rax
leaq (%rbx,%rax), %r14
addq $0x10, %r14
movq %r13, %rdi
movq %rbx, %rdx
callq 0xf540
movq $0x1, (%r13,%rbx)
pushq $-0x3
popq %rbp
testq %rbp, %rbp
je 0x1eaf3
movq %r12, %rdi
movq %rbx, %rsi
movq 0x20(%rsp), %rdx
callq *%r15
movq %r12, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xf540
andq $0x0, (%r12,%rbx)
movq %r12, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq 0x8(%rsp), %rcx
movq %r14, %r8
callq 0xfa40
cmpq $0x1, (%r12,%rbx)
jne 0x1eae7
movq %r12, %rdi
movq %r13, %rsi
movq 0x18(%rsp), %rdx
callq 0xf1b0
testl %eax, %eax
jne 0x1eb19
incq %rbp
jmp 0x1ea90
movl $0x131, %ebp # imm = 0x131
jmp 0x1eb33
movq %r12, %rdi
movq %r13, %rsi
movq 0x8(%rsp), %rdx
callq 0xf520
testl %eax, %eax
movl $0x1f9, %eax # imm = 0x1F9
movl $0x131, %ebp # imm = 0x131
cmovel %eax, %ebp
jmp 0x1eb2b
pushq $0x6e
popq %rbp
jmp 0x1eb33
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xf300
xorl %ebp, %ebp
movq %r13, %rdi
callq 0xe920
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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, id_len))
return ERR_BAD_INPUT;
EXPECT(belsValM(m0, len) == ERR_OK);
// создать состояние
n = W_OF_O(len);
state = blobCreate(O_OF_W(2 * n + 2) + 32 + O_PER_W +
utilMax(2,
beltHash_keep(),
ppMinPolyMod_deep(n + 1)));
if (state == 0)
return ERR_OUTOFMEMORY;
// раскладка состояния
f0 = (word*)state;
f = f0 + n + 1;
u = f + n + 1;
stack = u + W_OF_O(32) + 1;
// загрузить многочлен
wwFrom(f0, m0, len);
f0[n] = 1;
// хэшировать
beltHashStart(stack);
beltHashStepH(id, id_len, stack);
beltHashStepG((octet*)u, stack);
wwFrom(u, u, 32);
u[n] = 0;
// попытки генерации
for (reps = MAX2(3, B_PER_IMPOSSIBLE * 2 / len / 8); reps--;)
{
// f <- минимальный многочлен элемента u
ppMinPolyMod(f, u, f0, n + 1, stack);
// f подходит?
if (f[n] == 1 && !wwEq(f, f0, n))
{
wwTo(mid, len, f);
break;
}
// u <- u + 1
zzAddW2(u, n, 1);
}
// завершение
blobClose(state);
return reps != SIZE_MAX ? ERR_OK : ERR_BAD_PUBKEY;
} | 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, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x1ed15
movq %r12, %rdi
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x1ed15
movq %r15, %rdi
movq %r14, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x1ed15
movq %r13, 0x20(%rsp)
movq %r15, 0x28(%rsp)
movq %r14, (%rsp)
movq %rbx, %r15
shrq $0x3, %r15
xorl %eax, %eax
callq 0xe560
movq %rax, %r14
movq %r15, 0x8(%rsp)
leaq 0x1(%r15), %rdi
movq %rdi, 0x30(%rsp)
callq 0xe760
pushq $0x2
popq %rdi
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe320
leaq (%rax,%rbx,2), %rdi
addq $0x38, %rdi
callq 0xf190
testq %rax, %rax
je 0x1ecf5
movq %rax, %r13
movq %r12, 0x10(%rsp)
leaq (%rax,%rbx), %r14
addq $0x8, %r14
addq %rbx, %rax
leaq (%rbx,%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0x18(%rsp)
leaq 0x10(%rbx,%rax), %rbp
leaq 0x38(%rbx,%rax), %r12
movq %r13, %rdi
movq 0x20(%rsp), %rsi
movq %rbx, %rdx
callq 0xf540
movq $0x1, (%r13,%rbx)
movq %r12, %rdi
callq 0xe5d0
movq 0x28(%rsp), %rdi
movq (%rsp), %rsi
movq %r12, %rdx
callq 0xe360
movq %rbp, %rdi
movq %r12, %r15
movq %r12, %rsi
callq 0xf1f0
pushq $0x20
popq %rdx
movq %rbp, %rdi
movq %rbp, %rsi
callq 0xf540
movq %rbx, %rax
movq 0x18(%rsp), %rcx
movq %rcx, %rbx
movq %rax, (%rsp)
andq $0x0, 0x8(%rax,%rcx)
pushq $-0x3
popq %r12
testq %r12, %r12
je 0x1ecee
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq 0x30(%rsp), %rcx
movq %r15, %r8
callq 0xfa40
cmpq $0x1, (%rbx)
jne 0x1ecd9
movq %r14, %rdi
movq %r13, %rsi
movq 0x8(%rsp), %rdx
callq 0xf520
testl %eax, %eax
je 0x1ecfa
movq %rbp, %rdi
movq 0x8(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0xeb00
incq %r12
jmp 0x1eca4
movl $0x1f9, %ebp # imm = 0x1F9
jmp 0x1ed0d
pushq $0x6e
popq %rbp
jmp 0x1ed15
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movq %r14, %rdx
callq 0xf300
xorl %ebp, %ebp
movq %r13, %rdi
callq 0xe920
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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;
// проверить входные данные
if ((len != 16 && len != 24 && len != 32) ||
threshold == 0 || count < threshold ||
!memIsValid(s, len) || !memIsValid(m0, len) ||
!memIsValid(mi, len * count) || !memIsValid(si, count * len))
return ERR_BAD_INPUT;
EXPECT(belsValM(m0, len) == ERR_OK);
// создать состояние
n = W_OF_O(len);
state = blobCreate(O_OF_W(2 * threshold * n + 1) +
utilMax(2,
ppMul_deep(threshold * n - n, n),
ppMod_deep(threshold * n, n + 1)));
if (state == 0)
return ERR_OUTOFMEMORY;
// раскладка состояния
f = (word*)state;
k = f + n + 1;
c = k + threshold * n - n;
stack = c + threshold * n;
// сгенерировать k
rng(k, threshold * len - len, rng_state);
wwFrom(k, k, threshold * len - len);
// c(x) <- (x^l + m0(x))k(x) + s(x)
wwFrom(f, m0, len);
ppMul(c, k, threshold * n - n, f, n, stack);
wwXor2(c + n, k, threshold * n - n);
wwFrom(f, s, len);
wwXor2(c, f, n);
// цикл по пользователям
for (i = 0; i < count; ++i)
{
// f(x) <- x^l + mi(x)
EXPECT(belsValM(mi + i * len, len) == ERR_OK);
wwFrom(f, mi + i * len, len);
f[n] = 1;
// si(x) <- c(x) mod f(x)
ppMod(f, c, threshold * n, f, n + 1, stack);
wwTo(si + i * len, len, f);
}
// завершение
blobClose(state);
return ERR_OK;
} | 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, %cl
jne 0x1ef90
movq %r8, %r13
movq %rdi, %r12
movq %rdx, 0x48(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, %rdi
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x1ef90
movq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x1ef90
movq %r13, 0x40(%rsp)
movq %r14, 0x20(%rsp)
movq 0x90(%rsp), %r13
movq %rbx, %r14
imulq %r15, %r14
movq %r13, %rdi
movq %r14, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x1ef90
movq %r12, %rdi
movq %r14, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x1ef90
movq %rbx, %rbp
shrq $0x3, %rbp
movq 0x20(%rsp), %r14
imulq %rbp, %r14
movq %r14, %rax
shlq $0x4, %rax
movq %rax, (%rsp)
movq %r14, %rdi
subq %rbp, %rdi
movq %rdi, 0x38(%rsp)
movq %rbp, %rsi
callq 0xea00
movq %rax, 0x8(%rsp)
movq %rbp, 0x18(%rsp)
leaq 0x1(%rbp), %rsi
movq %r14, %rdi
movq %rsi, 0x50(%rsp)
callq 0xf350
pushq $0x2
popq %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe320
movq (%rsp), %rcx
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
callq 0xf190
testq %rax, %rax
je 0x1efad
movq %rax, %rbp
movq 0xa0(%rsp), %rdx
leaq (%rax,%rbx), %rdi
addq $0x8, %rdi
movq %rdi, 0x10(%rsp)
addq %rbx, %rax
leaq (%rax,%r14,8), %rcx
addq $0x8, %rcx
movq %rcx, 0x30(%rsp)
movq 0x18(%rsp), %rax
leaq (,%rax,8), %rax
subq %rax, %rcx
movq %rcx, (%rsp)
leaq (%rcx,%r14,8), %rax
movq %rax, 0x8(%rsp)
movq %r14, 0x20(%rsp)
movq 0x48(%rsp), %r14
imulq %rbx, %r14
movq %r14, %rsi
callq *0x98(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, %rsi
movq %r14, %rdx
callq 0xf540
movq %rbp, %rdi
movq 0x28(%rsp), %rsi
movq %rbx, %rdx
callq 0xf540
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x38(%rsp), %r14
movq %r14, %rdx
movq %rbp, %rcx
movq 0x18(%rsp), %r8
movq 0x8(%rsp), %r9
callq 0xf5f0
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0xeed0
movq %rbp, %rdi
movq 0x40(%rsp), %rsi
movq %rbx, %rdx
callq 0xf540
movq (%rsp), %rdi
movq %rbp, %rsi
movq 0x18(%rsp), %rdx
callq 0xeed0
movq 0x20(%rsp), %r14
subq $0x1, %r15
jb 0x1efa1
movq %rbp, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0xf540
movq $0x1, (%rbp,%rbx)
movq %rbp, %rdi
movq (%rsp), %rsi
movq %r14, %rdx
movq %rbp, %rcx
movq 0x50(%rsp), %r8
movq 0x8(%rsp), %r9
callq 0x100c0
movq %r12, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0xf300
addq %rbx, %r12
addq %rbx, %r13
jmp 0x1ef3c
movl $0x130, %ebp # imm = 0x130
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbp, %rdi
callq 0xe920
xorl %ebp, %ebp
jmp 0x1ef90
pushq $0x6e
popq %rbp
jmp 0x1ef90
| /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)
return ERR_OUTOFMEMORY;
// запустить генератор
belsGenkStart(state, s, count, threshold, len);
// разделить секрет
code = belsShare2(si, count, threshold, len, s, belsGenkStepR, state);
// завершение
blobClose(state);
return code;
} | 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, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x1f306
movq %r15, 0x20(%rsp)
xorl %eax, %eax
callq 0xfe20
movq %rax, %r15
xorl %eax, %eax
callq 0xf650
cmpq %rax, %r15
jbe 0x1f2bf
xorl %eax, %eax
callq 0xfe20
jmp 0x1f2c6
xorl %eax, %eax
callq 0xf650
addq $0x60, %rax
movq %rax, %rdi
callq 0xf190
testq %rax, %rax
je 0x1f303
movq %rax, %rbp
movq %r12, 0x10(%rsp)
xorl %eax, %eax
callq 0xfe20
movq %rax, %r15
xorl %eax, %eax
callq 0xf650
cmpq %rax, %r15
movq %r13, 0x8(%rsp)
jbe 0x1f30d
xorl %eax, %eax
callq 0xfe20
jmp 0x1f314
pushq $0x6e
popq %rbp
movl %ebp, %eax
jmp 0x1f408
xorl %eax, %eax
callq 0xf650
movq %rax, %r12
leaq (%rax,%rbp), %r15
leaq (%rax,%rbp), %r13
addq $0x20, %r13
movq %r13, %rdi
movq %rbx, 0x18(%rsp)
movq %rbx, %rsi
movq %r14, %rdx
callq 0xed10
leaq (%r12,%rbp), %rdi
addq $0x40, %rdi
pushq $0x20
popq %rbx
movq %r13, %rsi
movq %rbx, %rdx
callq 0xe970
movq %r13, %rdi
movq %rbx, %rsi
callq 0xe810
movq %r15, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0xf4a0
movq %r15, %rdi
pushq $0x20
popq %rsi
movq %r15, %rdx
callq 0xf6c0
leaq (%r12,%rbp), %rdx
addq $0x30, %rdx
movq 0x8(%rsp), %rax
movl %eax, 0x30(%rbp,%r12)
leaq 0x34(%rbp,%r12), %rbx
movq 0x10(%rsp), %rax
movl %eax, 0x34(%rbp,%r12)
pushq $0x4
popq %rsi
movq %r13, %rdi
callq 0xf6c0
leaq (%r12,%rbp), %rdi
addq $0x24, %rdi
pushq $0x4
popq %rsi
movq %rbx, %rdx
callq 0xf6c0
leaq (%r12,%rbp), %rdi
addq $0x28, %rdi
pushq $0x8
popq %rdx
xorl %esi, %esi
callq 0xf710
movq %rbp, %rdi
movq %r15, %rsi
pushq $0x20
popq %rdx
movq %r13, %rcx
callq 0xeaa0
movq %rbp, (%rsp)
leaq 0x37(%rip), %r9 # 0x1f417
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rcx
movq 0x18(%rsp), %r8
callq 0xe390
movl %eax, %ebx
movq %rbp, %rdi
callq 0xe920
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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 ||
!memIsValid(si, count * len) || !memIsValid(m0, len) ||
!memIsValid(mi, len * count) || !memIsValid(s, len))
return ERR_BAD_INPUT;
EXPECT(belsValM(m0, len) == ERR_OK);
// расчет глубины стека
n = W_OF_O(len);
deep = utilMax(2,
ppMul_deep(n, n),
ppMod_deep(count * n, n + 1));
for (i = 1; i < count; ++i)
deep = utilMax(6,
deep,
ppExGCD_deep(n + 1, i * n + 1),
ppMul_deep(i * n, i * n),
ppMul_deep(2 * i * n, n),
ppMul_deep(2 * n, i * n),
ppMod_deep((2 * i + 1) * n, (i + 1) * n + 1));
deep += O_OF_W(
n + 1 +
count * n + 1 +
(count - 1) * n + 1 +
(count - 1) * n + 1 +
n + 1 +
(2 * count - 1) * n +
MAX2((2 * count - 2) * n, (count + 1) * n));
// создать состояние
state = blobCreate(deep);
if (state == 0)
return ERR_OUTOFMEMORY;
// раскладка состояния
f = (word*)state;
g = f + n + 1;
d = g + count * n + 1;
u = d + (count - 1) * n + 1;
v = u + (count - 1) * n + 1;
c = v + n + 1;
t = c + (2 * count - 1) * n;
stack = t + MAX2((2 * count - 2) * n, (count + 1) * n);
// [n]c(x) <- s1(x)
wwFrom(c, si, len);
// [n + 1]g(x) <- x^l + m1(x)
wwFrom(g, mi, len), g[n] = 1;
// цикл по пользователям
for (f[n] = 1, i = 1; i < count; ++i)
{
// [n + 1]f(x) <- x^l + mi(x)
wwFrom(f, mi + i * len, len);
// найти d(x) = \gcd(f(x), g(x)) и коэфф. Безу [i * n]u(x), [n]v(x)
ppExGCD(d, u, v, f, n + 1, g, i * n + 1, stack);
ASSERT(u[i * n] == 0 && v[n] == 0);
// d(x) != 1?
if (wwCmpW(d, i * n + 1, 1) != 0)
{
blobClose(state);
return ERR_BAD_PUBKEY;
}
// [2 * i * n]c(x) <- u(x)f(x)c(x)
// (с помощью [2 * i * n]t)
ppMul(t, u, i * n, c, i * n, stack);
ppMul(c, t, 2 * i * n, f, n, stack);
wwXor2(c + n, t, 2 * i * n);
// c(x) <- c(x) + v(x)g(x)si(x)
// (с помощью [2 * n]d и [(i + 2) * n]t)
wwFrom(t, si + i * len, len);
ppMul(d, v, n, t, n, stack);
ppMul(t, d, 2 * n, g, i * n, stack);
wwXor2(t + i * n, d, 2 * n);
wwXor2(c, t, (i + 2) * n);
// [(i + 1) * n + 1]g(x) <- g(x)f(x)
// (с помощью [(i + 1) * n]t)
ppMul(t, f, n, g, i * n, stack);
wwXor2(t + n, g, i * n);
wwXor2(t + i * n, f, n);
wwCopy(g, t, (i + 1) * n);
g[(i + 1) * n] = 1;
// [(i + 1) * n]c(x) <- c(x) mod g(x)
ppMod(c, c, (2 * i + 1) * n, g, (i + 1) * n + 1, stack);
ASSERT(c[(i + 1) * n] == 0);
}
// [n]s(x) <- c(x) mod (x^l + m0(x))
wwFrom(f, m0, len), f[n] = 1;
ppMod(c, c, count * n, f, n + 1, stack);
ASSERT(c[n] == 0);
wwTo(s, len, c);
// завершение
blobClose(state);
return ERR_OK;
} | 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, 0x40(%rsp)
movq %rdx, %r14
movq %rsi, 0x18(%rsp)
imulq %rsi, %r14
movq %rbp, %rdi
movq %r14, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x1fa9f
movq %r13, %rdi
movq %r15, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x1fa9f
movq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x1fa9f
movq %rbx, %rdi
movq %r15, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x1fa9f
movq %rbp, 0x30(%rsp)
movq %r13, 0x88(%rsp)
movq %rbx, 0x90(%rsp)
movq %r15, %r13
shrq $0x3, %r13
movq %r13, %rdi
movq %r13, %rsi
callq 0xea00
movq %rax, %rbx
movq %r13, %rdi
movq 0x18(%rsp), %r14
imulq %r14, %rdi
leaq 0x1(%r13), %rsi
movq %rdi, 0x60(%rsp)
movq %rsi, 0x48(%rsp)
callq 0xf350
pushq $0x2
popq %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe320
movq %r14, %rdx
movq %r15, 0x38(%rsp)
movq %r15, %r14
shrq $0x2, %r14
leaq -0x1(%rdx), %rbp
leaq (,%r13,2), %r15
addq %r13, %r15
movq %r14, %r12
orq $0x1, %r12
movq %r13, %rbx
movq %r14, 0x80(%rsp)
movq %r13, 0x58(%rsp)
subq $0x1, %rbp
jb 0x1f62b
movq %rax, (%rsp)
leaq 0x1(%rbx), %rsi
movq 0x48(%rsp), %rdi
callq 0xe500
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0xea00
movq %rax, 0x28(%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0xea00
movq %rax, 0x20(%rsp)
movq %r14, %r13
movq 0x80(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xea00
movq %rax, 0x50(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xf350
movq %rax, %r10
subq $0x8, %rsp
pushq $0x6
popq %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
movq 0x58(%rsp), %r9
xorl %eax, %eax
pushq %r10
callq 0xe320
movq 0x28(%rsp), %rdx
addq $0x10, %rsp
addq %r14, %r15
addq %r14, %r13
movq %r13, %r14
movq 0x58(%rsp), %r13
addq %r13, %rbx
addq %r13, %r12
jmp 0x1f576
leaq -0x1(%rdx), %rbx
movq %r13, %r14
imulq %rbx, %r14
movq %r13, %r12
leaq -0x1(,%rdx,2), %r13
imulq %r12, %r13
leaq -0x2(,%rdx,2), %rcx
imulq %r12, %rcx
leaq 0x1(%rdx), %r15
imulq %r12, %r15
cmpq %r15, %rcx
cmovaq %rcx, %r15
movq 0x60(%rsp), %rbp
leaq (%r12,%rbp), %rsi
addq 0x48(%rsp), %rsi
addq %r13, %rsi
addq %r15, %rsi
movq %r14, %rcx
shlq $0x4, %rcx
leaq (%rcx,%rsi,8), %rcx
leaq (%rax,%rcx), %rdi
addq $0x20, %rdi
callq 0xf190
testq %rax, %rax
je 0x1fa2b
movq %rbx, 0xd0(%rsp)
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rbx
movq 0x8(%rsp), %rax
leaq (%rax,%rbx), %rcx
movq %rcx, 0x20(%rsp)
movq 0x8(%rsp), %rax
leaq 0x8(%rax,%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x8(%rcx,%rbp,8), %rax
leaq 0x10(%rcx,%rbp,8), %rcx
movq %rcx, 0xc8(%rsp)
leaq 0x8(%rax,%r14,8), %rcx
leaq 0x10(%rax,%r14,8), %rax
movq %rax, 0xc0(%rsp)
leaq 0x8(%rcx,%r14,8), %rax
leaq 0x10(%rcx,%r14,8), %rcx
movq %rcx, 0x78(%rsp)
leaq 0x8(%rbx,%rax), %r14
leaq 0x10(%rbx,%rax), %rdi
leaq 0x8(%r14,%r13,8), %rbp
leaq (%rbp,%r15,8), %rax
movq %rax, (%rsp)
movq %rdi, 0x28(%rsp)
movq 0x30(%rsp), %r15
movq %r15, %rsi
movq %rbx, %rdx
callq 0xf540
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %r13
movq %r13, %rsi
movq %rbx, %rdx
callq 0xf540
movq %r13, %rsi
pushq $0x1
popq %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rbx,%rax)
movq 0x8(%rsp), %rax
movq %rcx, (%rax,%rbx)
leaq 0x8(%rbx,%r14), %rax
movq %rax, 0xb0(%rsp)
movq %rbp, 0xb8(%rsp)
leaq (%rbp,%rbx), %rax
movq %rax, 0xa8(%rsp)
leaq (%r12,%r12,2), %rax
movq %rax, 0x70(%rsp)
leaq (%r12,%r12), %rax
movq %rax, 0x68(%rsp)
addq %rbx, %r15
movq %r15, 0x30(%rsp)
addq %rbx, %rsi
imulq $0x28, 0x18(%rsp), %rax
addq $-0x10, %rax
imulq %r12, %rax
leaq (%rax,%rbx,2), %rax
movq 0x8(%rsp), %rcx
leaq (%rcx,%rax), %r15
addq $0x28, %r15
leaq (,%r12,8), %rax
movq %rax, 0xa0(%rsp)
shlq $0x4, %r12
addq %rbx, %r12
movq 0x8(%rsp), %rdx
leaq (%rdx,%r12), %rax
addq $0x8, %rax
movq %rax, 0x98(%rsp)
xorl %ebx, %ebx
xorl %eax, %eax
subq $0x1, 0xd0(%rsp)
jb 0x1fa31
movq %rax, 0x20(%rsp)
movq %r15, 0xe0(%rsp)
movq 0x8(%rsp), %r13
movq %r13, %rdi
movq 0x38(%rsp), %r15
movq %r15, %rdx
movq %rsi, 0x40(%rsp)
callq 0xf540
movq 0x58(%rsp), %r12
movq %rbx, %r14
leaq (%r12,%rbx), %rax
incq %rax
movq %rax, 0x18(%rsp)
movq 0xc8(%rsp), %rbx
movq %rbx, %rdi
movq 0xc0(%rsp), %rbp
movq %rbp, %rsi
movq 0x78(%rsp), %rdx
movq %r13, %rcx
movq 0x48(%rsp), %r8
movq 0x10(%rsp), %r9
pushq (%rsp)
pushq %rax
callq 0xe2d0
popq %rax
popq %rcx
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0xe3b0
testl %eax, %eax
jne 0x1fa8f
movq %r14, 0x50(%rsp)
leaq (%r12,%r14), %rdx
movq %rdx, 0xd8(%rsp)
movq 0xb8(%rsp), %r12
movq %r12, %rdi
movq %rbp, %rsi
movq 0x28(%rsp), %rbp
movq %rbp, %rcx
movq %rdx, %r8
movq (%rsp), %r9
callq 0xf5f0
movq 0x20(%rsp), %rax
movq 0x68(%rsp), %rcx
leaq (%rcx,%rax), %r14
movq %r14, 0x18(%rsp)
movq %rbp, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r13, %rcx
movq 0x58(%rsp), %rbp
movq %rbp, %r8
movq (%rsp), %r9
callq 0xf5f0
movq 0xb0(%rsp), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xeed0
movq %r12, %rdi
movq 0x30(%rsp), %rsi
movq %r15, %rdx
callq 0xf540
movq %rbx, %rdi
movq 0x78(%rsp), %rsi
movq %rbp, %rdx
movq %r12, %rcx
movq %rbp, %r8
movq (%rsp), %r9
callq 0xf5f0
movq %r12, %rdi
movq %rbx, %rsi
movq 0x80(%rsp), %r13
movq %r13, %rdx
movq 0x10(%rsp), %rcx
movq 0xd8(%rsp), %r14
movq %r14, %r8
movq (%rsp), %r9
callq 0xf5f0
movq 0xe0(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq 0x8(%rsp), %rbx
callq 0xeed0
movq 0x50(%rsp), %rax
movq 0x70(%rsp), %rcx
leaq (%rcx,%rax), %rdx
movq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0xeed0
movq %r12, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
movq 0x10(%rsp), %rcx
movq %r14, %r8
movq (%rsp), %r9
callq 0xf5f0
movq 0xa8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0xeed0
movq %r15, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0xeed0
movq 0x50(%rsp), %rbx
movq 0x68(%rsp), %rbp
leaq (%rbx,%rbp), %rdx
movq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0xe5c0
movq 0x98(%rsp), %rax
movq $0x1, (%rax,%rbx,8)
movq 0x20(%rsp), %rdx
addq 0x70(%rsp), %rdx
leaq (%rbx,%rbp), %r8
incq %r8
movq 0x28(%rsp), %rdi
movq %rdi, %rsi
movq 0x10(%rsp), %rcx
movq (%rsp), %r9
callq 0x100c0
movq 0x38(%rsp), %rax
addq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rsi
addq %rax, %rsi
addq 0xa0(%rsp), %r15
movq %r14, %rbx
movq 0x18(%rsp), %rax
jmp 0x1f7e0
pushq $0x6e
popq %r12
jmp 0x1fa9f
movq 0x8(%rsp), %r15
movq %r15, %rdi
movq 0x88(%rsp), %rsi
movq 0x38(%rsp), %rbx
movq %rbx, %rdx
callq 0xf540
movq $0x1, (%r15,%rbx)
movq 0x28(%rsp), %r14
movq %r14, %rdi
movq %r14, %rsi
movq 0x60(%rsp), %rdx
movq %r15, %rcx
movq 0x48(%rsp), %r8
movq (%rsp), %r9
callq 0x100c0
movq 0x90(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xf300
xorl %r12d, %r12d
jmp 0x1fa95
movl $0x1f9, %r12d # imm = 0x1F9
movq 0x8(%rsp), %rdi
callq 0xe920
movl %r12d, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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, count * (len + 1)) || !memIsValid(s, len))
return ERR_BAD_INPUT;
// проверить номера частичных секретов
for (i = 0; i < count; ++i)
{
if (si[i * (len + 1)] == 0 || si[i * (len + 1)] > 16)
return ERR_BAD_PUBKEY;
for (j = i + 1; j < count; ++j)
if (si[i * (len + 1)] == si[j * (len + 1)])
return ERR_BAD_PUBKEY;
}
// расчет глубины стека
n = W_OF_O(len);
deep = utilMax(2,
ppMul_deep(n, n),
ppMod_deep(count * n, n + 1));
for (i = 1; i < count; ++i)
deep = utilMax(6,
deep,
ppExGCD_deep(n + 1, i * n + 1),
ppMul_deep(i * n, i * n),
ppMul_deep(2 * i * n, n),
ppMul_deep(2 * n, i * n),
ppMod_deep((2 * i + 1) * n, (i + 1) * n + 1));
deep += O_OF_W(
n + 1 +
count * n + 1 +
(count - 1) * n + 1 +
(count - 1) * n + 1 +
n + 1 +
(2 * count - 1) * n +
MAX2((2 * count - 2) * n, (count + 1) * n));
// создать состояние
state = blobCreate(deep);
if (state == 0)
return ERR_OUTOFMEMORY;
// раскладка состояния
f = (word*)state;
g = f + n + 1;
d = g + count * n + 1;
u = d + (count - 1) * n + 1;
v = u + (count - 1) * n + 1;
c = v + n + 1;
t = c + (2 * count - 1) * n;
stack = t + MAX2((2 * count - 2) * n, (count + 1) * n);
// [n]c(x) <- s1(x)
wwFrom(c, si + 1, len);
// [n + 1]g(x) <- x^l + m1(x)
belsStdM((octet*)g, len, si[0]);
wwFrom(g, g, len), g[n] = 1;
// цикл по пользователям
for (f[n] = 1, i = 1; i < count; ++i)
{
// [n + 1]f(x) <- x^l + mi(x)
belsStdM((octet*)f, len, si[i * (len + 1)]);
wwFrom(f, f, len);
// найти d(x) = \gcd(f(x), g(x)) и коэфф. Безу [i * n]u(x), [n]v(x)
ppExGCD(d, u, v, f, n + 1, g, i * n + 1, stack);
ASSERT(u[i * n] == 0 && v[n] == 0);
// d(x) != 1?
if (wwCmpW(d, i * n + 1, 1) != 0)
{
blobClose(state);
return ERR_BAD_PUBKEY;
}
// [2 * i * n]c(x) <- u(x)f(x)c(x)
// (с помощью [2 * i * n]t)
ppMul(t, u, i * n, c, i * n, stack);
ppMul(c, t, 2 * i * n, f, n, stack);
wwXor2(c + n, t, 2 * i * n);
// c(x) <- c(x) + v(x)g(x)si(x)
// (с помощью [2 * n]d и [(i + 2) * n]t)
wwFrom(t, si + i * (len + 1) + 1, len);
ppMul(d, v, n, t, n, stack);
ppMul(t, d, 2 * n, g, i * n, stack);
wwXor2(t + i * n, d, 2 * n);
wwXor2(c, t, (i + 2) * n);
// [(i + 1) * n + 1]g(x) <- g(x)f(x)
// (с помощью [(i + 1) * n]t)
ppMul(t, f, n, g, i * n, stack);
wwXor2(t + n, g, i * n);
wwXor2(t + i * n, f, n);
wwCopy(g, t, (i + 1) * n);
g[(i + 1) * n] = 1;
// [(i + 1) * n]c(x) <- c(x) mod g(x)
ppMod(c, c, (2 * i + 1) * n, g, (i + 1) * n + 1, stack);
ASSERT(c[(i + 1) * n] == 0);
}
// [n]s(x) <- c(x) mod (x^l + m0(x))
belsStdM((octet*)f, len, 0);
wwFrom(f, f, len), f[n] = 1;
ppMod(c, c, count * n, f, n + 1, stack);
ASSERT(c[n] == 0);
wwTo(s, len, c);
// завершение
blobClose(state);
return ERR_OK;
} | 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
movq %rdi, %r13
movq %r15, %rbx
orq $0x1, %rbx
movq %rbx, %rsi
imulq %r12, %rsi
movq %rbp, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x2017a
movq %r13, %rdi
movq %r15, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x2017a
leaq (%rbx,%rbp), %rax
xorl %ecx, %ecx
cmpq %r12, %rcx
je 0x1fb81
movq %rcx, %rdx
imulq %rbx, %rdx
movb (%rbp,%rdx), %dl
leal -0x11(%rdx), %esi
movl $0x1f9, %r14d # imm = 0x1F9
cmpb $-0x10, %sil
jb 0x2017a
leaq 0x1(%rcx), %rsi
movq %rax, %rdi
incq %rcx
cmpq %r12, %rcx
jae 0x1fb79
leaq (%rdi,%rbx), %r8
cmpb (%rdi), %dl
movq %r8, %rdi
jne 0x1fb61
jmp 0x2017a
addq %rbx, %rax
movq %rsi, %rcx
jmp 0x1fb37
movq %rbp, 0x40(%rsp)
movq %rbx, 0xd0(%rsp)
movq %r13, 0x90(%rsp)
movq %r15, %r14
shrq $0x3, %r14
movq %r14, %rdi
movq %r14, %rsi
callq 0xea00
movq %rax, %r13
movq %r14, %rbx
imulq %r12, %rbx
leaq 0x1(%r14), %rsi
movq %rbx, %rdi
movq %rsi, 0x48(%rsp)
callq 0xf350
pushq $0x2
popq %rdi
movq %r13, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe320
movq %r15, 0x38(%rsp)
movq %r15, %rcx
shrq $0x2, %rcx
leaq -0x1(%r12), %rsi
leaq (%r14,%r14,2), %r15
movq %rcx, %rbp
orq $0x1, %rbp
movq %r14, 0x30(%rsp)
movq %r14, %r13
movq %rcx, 0x88(%rsp)
movq %rcx, %r14
movq %rbx, 0x70(%rsp)
movq 0x88(%rsp), %rbx
subq $0x1, %rsi
jb 0x1fcbe
movq %rax, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
leaq 0x1(%r13), %rsi
movq 0x48(%rsp), %rdi
callq 0xe500
movq %rax, 0x28(%rsp)
movq %r13, %rdi
movq %r13, %rsi
callq 0xea00
movq %rax, 0x20(%rsp)
movq %r14, %rdi
movq 0x30(%rsp), %rsi
callq 0xea00
movq %rax, 0x58(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0xea00
movq %rax, 0x50(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
callq 0xf350
movq %rax, %r10
subq $0x8, %rsp
pushq $0x6
popq %rdi
movq 0x20(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x60(%rsp), %r8
movq 0x58(%rsp), %r9
xorl %eax, %eax
pushq %r10
callq 0xe320
movq 0x20(%rsp), %rsi
addq $0x10, %rsp
addq %rbx, %r15
addq %rbx, %r14
movq 0x30(%rsp), %rcx
addq %rcx, %r13
addq %rcx, %rbp
jmp 0x1fc0f
leaq -0x1(%r12), %rbx
movq 0x30(%rsp), %rdx
movq %rdx, %r15
imulq %rbx, %r15
leaq -0x1(,%r12,2), %r14
imulq %rdx, %r14
leaq -0x2(,%r12,2), %rcx
imulq %rdx, %rcx
leaq 0x1(%r12), %rbp
imulq %rdx, %rbp
cmpq %rbp, %rcx
cmovaq %rcx, %rbp
movq 0x70(%rsp), %r13
addq %r13, %rdx
addq 0x48(%rsp), %rdx
addq %r14, %rdx
addq %rbp, %rdx
movq %r15, %rcx
shlq $0x4, %rcx
leaq (%rcx,%rdx,8), %rcx
leaq (%rax,%rcx), %rdi
addq $0x20, %rdi
callq 0xf190
testq %rax, %rax
je 0x200ef
movq %rbx, 0x80(%rsp)
movq %r13, %rcx
movq 0x38(%rsp), %r13
leaq (%rax,%r13), %rdi
movq %rdi, 0x20(%rsp)
leaq 0x8(%rax,%r13), %rsi
leaq 0x8(%rdi,%rcx,8), %rdx
leaq 0x10(%rdi,%rcx,8), %rcx
movq %rcx, 0x68(%rsp)
leaq 0x8(%rdx,%r15,8), %rcx
leaq 0x10(%rdx,%r15,8), %rdx
movq %rdx, 0xc8(%rsp)
leaq 0x8(%rcx,%r15,8), %rdx
leaq 0x10(%rcx,%r15,8), %rcx
movq %rcx, 0x60(%rsp)
leaq 0x8(%r13,%rdx), %r15
leaq 0x10(%r13,%rdx), %rdi
leaq 0x8(%r15,%r14,8), %r14
leaq (%r14,%rbp,8), %rcx
movq %rcx, 0x10(%rsp)
movq %rsi, %rbp
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rbx
leaq 0x1(%rbx), %rsi
movq %rdi, 0x28(%rsp)
movq %r13, %rdx
callq 0xf540
movzbl (%rbx), %edx
movq %rbp, %rdi
movq %r13, %rsi
callq 0xf0f0
movq %rbp, %rdi
movq %rbp, 0x18(%rsp)
movq %rbp, %rsi
movq %r13, %rdx
callq 0xf540
pushq $0x1
popq %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%r13,%rax)
movq 0x8(%rsp), %rax
movq %rcx, (%rax,%r13)
leaq 0x8(%r13,%r15), %rax
movq %rax, 0xb8(%rsp)
movq %r14, 0xc0(%rsp)
leaq (%r14,%r13), %rax
movq %rax, 0xb0(%rsp)
movq 0x30(%rsp), %rcx
leaq (%rcx,%rcx,2), %rax
movq %rax, 0xa8(%rsp)
leaq (%rcx,%rcx), %rax
movq %rax, 0x78(%rsp)
leaq (%rbx,%r13), %rsi
addq $0x2, %rsi
movq 0x8(%rsp), %rdx
imulq $0x28, %r12, %rax
addq $-0x10, %rax
imulq %rcx, %rax
leaq (%rax,%r13,2), %rax
leaq (%rdx,%rax), %rbp
addq $0x28, %rbp
leaq (,%rcx,8), %rax
movq %rax, 0xa0(%rsp)
movq %rcx, %rax
shlq $0x4, %rax
addq %r13, %rax
movq 0x60(%rsp), %rcx
movq 0x68(%rsp), %r13
addq %rdx, %rax
addq $0x8, %rax
movq %rax, 0x98(%rsp)
xorl %r14d, %r14d
xorl %ebx, %ebx
movq 0x80(%rsp), %rax
subq $0x1, %rax
jb 0x200f8
movq %rbx, 0x20(%rsp)
movq %rax, 0x80(%rsp)
movzbl -0x1(%rsi), %edx
movq %rbp, 0xe0(%rsp)
movq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %rcx, %rbx
movq 0x38(%rsp), %r15
movq %rsi, 0x58(%rsp)
movq %r15, %rsi
callq 0xf0f0
movq %rbp, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0xf540
movq 0x30(%rsp), %r12
leaq (%r12,%r14), %rax
incq %rax
movq %r13, %rdi
movq %r14, %r15
movq 0xc8(%rsp), %r14
movq %r14, %rsi
movq %rbx, %rdx
movq %rbp, %rcx
movq 0x48(%rsp), %r8
movq 0x18(%rsp), %r9
pushq 0x10(%rsp)
pushq %rax
movq %rax, %rbx
callq 0xe2d0
popq %rax
popq %rcx
movq %r13, %rdi
movq %rbx, %rsi
pushq $0x1
popq %rdx
callq 0xe3b0
testl %eax, %eax
jne 0x2016c
movq %r12, %r13
movq %r15, 0x50(%rsp)
leaq (%r12,%r15), %rdx
movq %rdx, 0x40(%rsp)
movq 0xc0(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq 0x28(%rsp), %r14
movq %r14, %rcx
movq %rdx, %r8
movq 0x10(%rsp), %r9
callq 0xf5f0
movq 0x20(%rsp), %rax
movq 0x78(%rsp), %rcx
leaq (%rcx,%rax), %rbx
movq %rbx, 0xd8(%rsp)
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %rbp, %rcx
movq %r13, %r8
movq 0x10(%rsp), %r9
callq 0xf5f0
movq 0xb8(%rsp), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xeed0
movq %r12, %rdi
movq 0x58(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0xf540
movq 0x68(%rsp), %rbx
movq %rbx, %rdi
movq 0x60(%rsp), %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r13, %r8
movq 0x10(%rsp), %r9
callq 0xf5f0
movq %r12, %rdi
movq %rbx, %rsi
movq 0x88(%rsp), %r15
movq %r15, %rdx
movq 0x18(%rsp), %rcx
movq 0x40(%rsp), %r14
movq %r14, %r8
movq 0x10(%rsp), %r9
callq 0xf5f0
movq 0xe0(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq 0x8(%rsp), %rbx
callq 0xeed0
movq 0xa8(%rsp), %r15
movq 0x50(%rsp), %rax
leaq (%r15,%rax), %rdx
movq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0xeed0
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq 0x18(%rsp), %rcx
movq %r14, %r8
movq 0x10(%rsp), %r9
callq 0xf5f0
movq 0xb0(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %r14, %rdx
callq 0xeed0
movq %rbp, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0xeed0
movq 0x50(%rsp), %rbx
movq 0x78(%rsp), %r14
leaq (%r14,%rbx), %rdx
movq 0x18(%rsp), %rdi
movq %r12, %rsi
callq 0xe5c0
movq 0x98(%rsp), %rax
movq $0x1, (%rax,%rbx,8)
movq 0x20(%rsp), %rdx
addq %r15, %rdx
leaq (%r14,%rbx), %r8
incq %r8
movq 0x28(%rsp), %rdi
movq %rdi, %rsi
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r9
callq 0x100c0
movq 0x58(%rsp), %rsi
addq 0xd0(%rsp), %rsi
addq 0xa0(%rsp), %rbp
movq 0x40(%rsp), %r14
movq 0xd8(%rsp), %rbx
movq 0x68(%rsp), %r13
movq 0x60(%rsp), %rcx
jmp 0x1fe7e
pushq $0x6e
popq %r14
jmp 0x2017a
xorl %r14d, %r14d
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rbx
movq %rbx, %rsi
xorl %edx, %edx
callq 0xf0f0
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
callq 0xf540
movq 0x8(%rsp), %rax
movq $0x1, (%rax,%rbx)
movq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r15, %rsi
movq 0x70(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq 0x48(%rsp), %r8
movq 0x10(%rsp), %r9
callq 0x100c0
movq 0x90(%rsp), %rdi
movq %rbx, %rsi
movq 0x8(%rsp), %rbp
movq %r15, %rdx
callq 0xf300
jmp 0x20172
movl $0x1f9, %r14d # imm = 0x1F9
movq %rbp, %rdi
callq 0xe920
movl %r14d, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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 == 24)
{
key_[6] = key_[0] ^ key_[1] ^ key_[2];
key_[7] = key_[3] ^ key_[4] ^ key_[5];
}
} | 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(%rbx), %ecx
movl %ecx, 0x18(%rbx)
xorl 0xc(%rbx), %eax
xorl 0x14(%rbx), %eax
movl %eax, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /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_ENDIAN)
t[3] = u32Rev(t[3]);
t[2] = u32Rev(t[2]);
t[1] = u32Rev(t[1]);
t[0] = u32Rev(t[0]);
#endif
} | 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), %r14d
xorl (%r10,%rdx,4), %r14d
movl %r11d, %r9d
shrl $0xe, %r9d
movl $0x3fc, %edx # imm = 0x3FC
andl %edx, %r9d
leaq 0x2e62a(%rip), %r8 # 0x4e8b0
xorl (%r9,%r8), %r14d
shrl $0x18, %r11d
leaq 0x2ea1b(%rip), %r9 # 0x4ecb0
xorl (%r9,%r11,4), %r14d
movl 0xc(%rdi), %r11d
xorl 0x4(%rdi), %r14d
movl %r14d, 0x4(%rdi)
movl 0x4(%rsi), %r12d
addl %r11d, %r12d
movl %r12d, %r13d
andl %ecx, %r13d
movl %r12d, %r15d
shrl $0x8, %r15d
andl %ecx, %r15d
movl (%r9,%r15,4), %r15d
xorl (%r8,%r13,4), %r15d
movl %r12d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r10), %r15d
shrl $0x18, %r12d
xorl (%rax,%r12,4), %r15d
xorl 0x8(%rdi), %r15d
movl %r15d, 0x8(%rdi)
movl 0x8(%rsi), %r12d
addl %r14d, %r12d
movl %r12d, %r13d
andl %ecx, %r13d
movl %r12d, %ebp
shrl $0x8, %ebp
andl %ecx, %ebp
movl (%r8,%rbp,4), %ebp
xorl (%rax,%r13,4), %ebp
movl %r12d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r9), %ebp
shrl $0x18, %r12d
xorl (%r10,%r12,4), %ebp
subl %ebp, %ebx
movl %ebx, (%rdi)
leal (%r15,%r14), %r12d
movl %r12d, 0x8(%rdi)
addl 0xc(%rsi), %r12d
movl %r12d, %r13d
andl %ecx, %r13d
movl (%r8,%r13,4), %ebp
movl %r12d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %ebp
movl %r12d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r10), %ebp
shrl $0x18, %r12d
xorl (%rax,%r12,4), %ebp
xorl $0x1, %ebp
addl %ebp, %r14d
movl %r14d, 0x4(%rdi)
subl %ebp, %r15d
movl %r15d, 0x8(%rdi)
movl 0x10(%rsi), %r13d
addl %r15d, %r13d
movl %r13d, %ebp
andl %ecx, %ebp
movl %r13d, %r12d
shrl $0x8, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
xorl (%rax,%rbp,4), %r12d
movl %r13d, %ebp
shrl $0xe, %ebp
andl %edx, %ebp
xorl (%rbp,%r9), %r12d
shrl $0x18, %r13d
xorl (%r10,%r13,4), %r12d
addl %r11d, %r12d
movl %r12d, 0xc(%rdi)
movl 0x14(%rsi), %r13d
addl %ebx, %r13d
movl %r13d, %r11d
andl %ecx, %r11d
movl (%r8,%r11,4), %r11d
movl %r13d, %ebp
shrl $0x8, %ebp
andl %ecx, %ebp
xorl (%r9,%rbp,4), %r11d
movl %r13d, %ebp
shrl $0xe, %ebp
andl %edx, %ebp
shrl $0x18, %r13d
xorl (%rbp,%r10), %r11d
xorl (%rax,%r13,4), %r11d
xorl %r14d, %r11d
movl %r11d, 0x4(%rdi)
movl 0x18(%rsi), %r14d
addl %r12d, %r14d
movl %r14d, %r13d
andl %ecx, %r13d
movl (%r10,%r13,4), %ebp
movl %r14d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%rax,%r13,4), %ebp
movl %r14d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %r14d
xorl (%r13,%r8), %ebp
xorl (%r9,%r14,4), %ebp
xorl %r15d, %ebp
movl %ebp, 0x8(%rdi)
movl 0x1c(%rsi), %r15d
addl %r11d, %r15d
movl %r15d, %r14d
andl %ecx, %r14d
movl (%r10,%r14,4), %r14d
movl %r15d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%rax,%r13,4), %r14d
movl %r15d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %r15d
xorl (%r13,%r8), %r14d
xorl (%r9,%r15,4), %r14d
xorl %r12d, %r14d
movl %r14d, 0xc(%rdi)
movl (%rsi), %r12d
addl %ebp, %r12d
movl %r12d, %r15d
andl %ecx, %r15d
movl (%r8,%r15,4), %r15d
movl %r12d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %r15d
movl %r12d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %r12d
xorl (%r13,%r10), %r15d
xorl (%rax,%r12,4), %r15d
xorl %ebx, %r15d
movl %r15d, (%rdi)
movl 0x4(%rsi), %ebx
addl %r14d, %ebx
movl %ebx, %r12d
andl %ecx, %r12d
movl %ebx, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
movl (%r8,%r13,4), %r13d
xorl (%rax,%r12,4), %r13d
movl %ebx, %r12d
shrl $0xe, %r12d
andl %edx, %r12d
xorl (%r12,%r9), %r13d
shrl $0x18, %ebx
xorl (%r10,%rbx,4), %r13d
subl %r13d, %r11d
movl %r11d, 0x4(%rdi)
leal (%r15,%r14), %ebx
movl %ebx, (%rdi)
addl 0x8(%rsi), %ebx
movl %ebx, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
movl %ebx, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %r12d
movl %ebx, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %ebx
xorl (%r13,%r10), %r12d
xorl (%rax,%rbx,4), %r12d
xorl $0x2, %r12d
addl %r12d, %r14d
movl %r14d, 0xc(%rdi)
subl %r12d, %r15d
movl %r15d, (%rdi)
movl 0xc(%rsi), %ebx
addl %r15d, %ebx
movl %ebx, %r13d
andl %ecx, %r13d
movl %ebx, %r12d
shrl $0x8, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
xorl (%rax,%r13,4), %r12d
movl %ebx, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r9), %r12d
shrl $0x18, %ebx
xorl (%r10,%rbx,4), %r12d
addl %ebp, %r12d
movl %r12d, 0x8(%rdi)
movl 0x10(%rsi), %r13d
addl %r11d, %r13d
movl %r13d, %ebx
andl %ecx, %ebx
movl (%r8,%rbx,4), %ebx
movl %r13d, %ebp
shrl $0x8, %ebp
andl %ecx, %ebp
xorl (%r9,%rbp,4), %ebx
movl %r13d, %ebp
shrl $0xe, %ebp
andl %edx, %ebp
xorl (%rbp,%r10), %ebx
shrl $0x18, %r13d
xorl (%rax,%r13,4), %ebx
xorl %r14d, %ebx
movl %ebx, 0xc(%rdi)
movl 0x14(%rsi), %r14d
addl %r12d, %r14d
movl %r14d, %r13d
andl %ecx, %r13d
movl (%r10,%r13,4), %ebp
movl %r14d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%rax,%r13,4), %ebp
movl %r14d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r8), %ebp
shrl $0x18, %r14d
xorl (%r9,%r14,4), %ebp
xorl %r15d, %ebp
movl %ebp, (%rdi)
movl 0x18(%rsi), %r15d
addl %ebx, %r15d
movl %r15d, %r14d
andl %ecx, %r14d
movl (%r10,%r14,4), %r14d
movl %r15d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%rax,%r13,4), %r14d
movl %r15d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r8), %r14d
shrl $0x18, %r15d
xorl (%r9,%r15,4), %r14d
xorl %r12d, %r14d
movl %r14d, 0x8(%rdi)
movl 0x1c(%rsi), %r12d
addl %ebp, %r12d
movl %r12d, %r15d
andl %ecx, %r15d
movl (%r8,%r15,4), %r15d
movl %r12d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %r15d
movl %r12d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r10), %r15d
shrl $0x18, %r12d
xorl (%rax,%r12,4), %r15d
xorl %r11d, %r15d
movl %r15d, 0x4(%rdi)
movl (%rsi), %r11d
addl %r14d, %r11d
movl %r11d, %r12d
andl %ecx, %r12d
movl %r11d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
movl (%r8,%r13,4), %r13d
xorl (%rax,%r12,4), %r13d
movl %r11d, %r12d
shrl $0xe, %r12d
andl %edx, %r12d
xorl (%r12,%r9), %r13d
shrl $0x18, %r11d
xorl (%r10,%r11,4), %r13d
subl %r13d, %ebx
movl %ebx, 0xc(%rdi)
leal (%r15,%r14), %r11d
movl %r11d, 0x4(%rdi)
addl 0x4(%rsi), %r11d
movl %r11d, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
movl %r11d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %r12d
movl %r11d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r10), %r12d
shrl $0x18, %r11d
xorl (%rax,%r11,4), %r12d
xorl $0x3, %r12d
addl %r12d, %r14d
movl %r14d, 0x8(%rdi)
subl %r12d, %r15d
movl %r15d, 0x4(%rdi)
movl 0x8(%rsi), %r11d
addl %r15d, %r11d
movl %r11d, %r13d
andl %ecx, %r13d
movl %r11d, %r12d
shrl $0x8, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
xorl (%rax,%r13,4), %r12d
movl %r11d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r9), %r12d
shrl $0x18, %r11d
xorl (%r10,%r11,4), %r12d
addl %ebp, %r12d
movl %r12d, (%rdi)
movl 0xc(%rsi), %r13d
addl %ebx, %r13d
movl %r13d, %r11d
andl %ecx, %r11d
movl (%r8,%r11,4), %r11d
movl %r13d, %ebp
shrl $0x8, %ebp
andl %ecx, %ebp
xorl (%r9,%rbp,4), %r11d
movl %r13d, %ebp
shrl $0xe, %ebp
andl %edx, %ebp
shrl $0x18, %r13d
xorl (%rbp,%r10), %r11d
xorl (%rax,%r13,4), %r11d
xorl %r14d, %r11d
movl %r11d, 0x8(%rdi)
movl 0x10(%rsi), %r14d
addl %r12d, %r14d
movl %r14d, %r13d
andl %ecx, %r13d
movl (%r10,%r13,4), %ebp
movl %r14d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%rax,%r13,4), %ebp
movl %r14d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %r14d
xorl (%r13,%r8), %ebp
xorl (%r9,%r14,4), %ebp
xorl %r15d, %ebp
movl %ebp, 0x4(%rdi)
movl 0x14(%rsi), %r15d
addl %r11d, %r15d
movl %r15d, %r14d
andl %ecx, %r14d
movl (%r10,%r14,4), %r14d
movl %r15d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%rax,%r13,4), %r14d
movl %r15d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %r15d
xorl (%r13,%r8), %r14d
xorl (%r9,%r15,4), %r14d
xorl %r12d, %r14d
movl %r14d, (%rdi)
movl 0x18(%rsi), %r12d
addl %ebp, %r12d
movl %r12d, %r15d
andl %ecx, %r15d
movl (%r8,%r15,4), %r15d
movl %r12d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %r15d
movl %r12d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %r12d
xorl (%r13,%r10), %r15d
xorl (%rax,%r12,4), %r15d
xorl %ebx, %r15d
movl %r15d, 0xc(%rdi)
movl 0x1c(%rsi), %ebx
addl %r14d, %ebx
movl %ebx, %r12d
andl %ecx, %r12d
movl %ebx, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
movl (%r8,%r13,4), %r13d
xorl (%rax,%r12,4), %r13d
movl %ebx, %r12d
shrl $0xe, %r12d
andl %edx, %r12d
xorl (%r12,%r9), %r13d
shrl $0x18, %ebx
xorl (%r10,%rbx,4), %r13d
subl %r13d, %r11d
movl %r11d, 0x8(%rdi)
leal (%r15,%r14), %ebx
movl %ebx, 0xc(%rdi)
addl (%rsi), %ebx
movl %ebx, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
movl %ebx, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %r12d
movl %ebx, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %ebx
xorl (%r13,%r10), %r12d
xorl (%rax,%rbx,4), %r12d
xorl $0x4, %r12d
addl %r12d, %r14d
movl %r14d, (%rdi)
subl %r12d, %r15d
movl %r15d, 0xc(%rdi)
movl 0x4(%rsi), %ebx
addl %r15d, %ebx
movl %ebx, %r13d
andl %ecx, %r13d
movl %ebx, %r12d
shrl $0x8, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
xorl (%rax,%r13,4), %r12d
movl %ebx, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r9), %r12d
shrl $0x18, %ebx
xorl (%r10,%rbx,4), %r12d
addl %ebp, %r12d
movl %r12d, 0x4(%rdi)
movl 0x8(%rsi), %r13d
addl %r11d, %r13d
movl %r13d, %ebx
andl %ecx, %ebx
movl (%r8,%rbx,4), %ebx
movl %r13d, %ebp
shrl $0x8, %ebp
andl %ecx, %ebp
xorl (%r9,%rbp,4), %ebx
movl %r13d, %ebp
shrl $0xe, %ebp
andl %edx, %ebp
xorl (%rbp,%r10), %ebx
shrl $0x18, %r13d
xorl (%rax,%r13,4), %ebx
xorl %r14d, %ebx
movl %ebx, (%rdi)
movl 0xc(%rsi), %r14d
addl %r12d, %r14d
movl %r14d, %r13d
andl %ecx, %r13d
movl (%r10,%r13,4), %ebp
movl %r14d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%rax,%r13,4), %ebp
movl %r14d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r8), %ebp
shrl $0x18, %r14d
xorl (%r9,%r14,4), %ebp
xorl %r15d, %ebp
movl %ebp, 0xc(%rdi)
movl 0x10(%rsi), %r15d
addl %ebx, %r15d
movl %r15d, %r14d
andl %ecx, %r14d
movl (%r10,%r14,4), %r14d
movl %r15d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%rax,%r13,4), %r14d
movl %r15d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r8), %r14d
shrl $0x18, %r15d
xorl (%r9,%r15,4), %r14d
xorl %r12d, %r14d
movl %r14d, 0x4(%rdi)
movl 0x14(%rsi), %r12d
addl %ebp, %r12d
movl %r12d, %r15d
andl %ecx, %r15d
movl (%r8,%r15,4), %r15d
movl %r12d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %r15d
movl %r12d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r10), %r15d
shrl $0x18, %r12d
xorl (%rax,%r12,4), %r15d
xorl %r11d, %r15d
movl %r15d, 0x8(%rdi)
movl 0x18(%rsi), %r11d
addl %r14d, %r11d
movl %r11d, %r12d
andl %ecx, %r12d
movl %r11d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
movl (%r8,%r13,4), %r13d
xorl (%rax,%r12,4), %r13d
movl %r11d, %r12d
shrl $0xe, %r12d
andl %edx, %r12d
xorl (%r12,%r9), %r13d
shrl $0x18, %r11d
xorl (%r10,%r11,4), %r13d
subl %r13d, %ebx
movl %ebx, (%rdi)
leal (%r15,%r14), %r11d
movl %r11d, 0x8(%rdi)
addl 0x1c(%rsi), %r11d
movl %r11d, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
movl %r11d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %r12d
movl %r11d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r10), %r12d
shrl $0x18, %r11d
xorl (%rax,%r11,4), %r12d
xorl $0x5, %r12d
addl %r12d, %r14d
movl %r14d, 0x4(%rdi)
subl %r12d, %r15d
movl %r15d, 0x8(%rdi)
movl (%rsi), %r11d
addl %r15d, %r11d
movl %r11d, %r13d
andl %ecx, %r13d
movl %r11d, %r12d
shrl $0x8, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
xorl (%rax,%r13,4), %r12d
movl %r11d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r9), %r12d
shrl $0x18, %r11d
xorl (%r10,%r11,4), %r12d
addl %ebp, %r12d
movl %r12d, 0xc(%rdi)
movl 0x4(%rsi), %r13d
addl %ebx, %r13d
movl %r13d, %r11d
andl %ecx, %r11d
movl (%r8,%r11,4), %r11d
movl %r13d, %ebp
shrl $0x8, %ebp
andl %ecx, %ebp
xorl (%r9,%rbp,4), %r11d
movl %r13d, %ebp
shrl $0xe, %ebp
andl %edx, %ebp
shrl $0x18, %r13d
xorl (%rbp,%r10), %r11d
xorl (%rax,%r13,4), %r11d
xorl %r14d, %r11d
movl %r11d, 0x4(%rdi)
movl 0x8(%rsi), %r14d
addl %r12d, %r14d
movl %r14d, %r13d
andl %ecx, %r13d
movl (%r10,%r13,4), %ebp
movl %r14d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%rax,%r13,4), %ebp
movl %r14d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %r14d
xorl (%r13,%r8), %ebp
xorl (%r9,%r14,4), %ebp
xorl %r15d, %ebp
movl %ebp, 0x8(%rdi)
movl 0xc(%rsi), %r15d
addl %r11d, %r15d
movl %r15d, %r14d
andl %ecx, %r14d
movl (%r10,%r14,4), %r14d
movl %r15d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%rax,%r13,4), %r14d
movl %r15d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %r15d
xorl (%r13,%r8), %r14d
xorl (%r9,%r15,4), %r14d
xorl %r12d, %r14d
movl %r14d, 0xc(%rdi)
movl 0x10(%rsi), %r12d
addl %ebp, %r12d
movl %r12d, %r15d
andl %ecx, %r15d
movl (%r8,%r15,4), %r15d
movl %r12d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %r15d
movl %r12d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %r12d
xorl (%r13,%r10), %r15d
xorl (%rax,%r12,4), %r15d
xorl %ebx, %r15d
movl %r15d, (%rdi)
movl 0x14(%rsi), %ebx
addl %r14d, %ebx
movl %ebx, %r12d
andl %ecx, %r12d
movl %ebx, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
movl (%r8,%r13,4), %r13d
xorl (%rax,%r12,4), %r13d
movl %ebx, %r12d
shrl $0xe, %r12d
andl %edx, %r12d
xorl (%r12,%r9), %r13d
shrl $0x18, %ebx
xorl (%r10,%rbx,4), %r13d
subl %r13d, %r11d
movl %r11d, 0x4(%rdi)
leal (%r15,%r14), %ebx
movl %ebx, (%rdi)
addl 0x18(%rsi), %ebx
movl %ebx, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
movl %ebx, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %r12d
movl %ebx, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %ebx
xorl (%r13,%r10), %r12d
xorl (%rax,%rbx,4), %r12d
xorl $0x6, %r12d
addl %r12d, %r14d
movl %r14d, 0xc(%rdi)
subl %r12d, %r15d
movl %r15d, (%rdi)
movl 0x1c(%rsi), %ebx
addl %r15d, %ebx
movl %ebx, %r13d
andl %ecx, %r13d
movl %ebx, %r12d
shrl $0x8, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
xorl (%rax,%r13,4), %r12d
movl %ebx, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r9), %r12d
shrl $0x18, %ebx
xorl (%r10,%rbx,4), %r12d
addl %ebp, %r12d
movl %r12d, 0x8(%rdi)
movl (%rsi), %r13d
addl %r11d, %r13d
movl %r13d, %ebx
andl %ecx, %ebx
movl (%r8,%rbx,4), %ebx
movl %r13d, %ebp
shrl $0x8, %ebp
andl %ecx, %ebp
xorl (%r9,%rbp,4), %ebx
movl %r13d, %ebp
shrl $0xe, %ebp
andl %edx, %ebp
xorl (%rbp,%r10), %ebx
shrl $0x18, %r13d
xorl (%rax,%r13,4), %ebx
xorl %r14d, %ebx
movl %ebx, 0xc(%rdi)
movl 0x4(%rsi), %r14d
addl %r12d, %r14d
movl %r14d, %r13d
andl %ecx, %r13d
movl (%r10,%r13,4), %ebp
movl %r14d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%rax,%r13,4), %ebp
movl %r14d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r8), %ebp
shrl $0x18, %r14d
xorl (%r9,%r14,4), %ebp
xorl %r15d, %ebp
movl %ebp, (%rdi)
movl 0x8(%rsi), %r15d
addl %ebx, %r15d
movl %r15d, %r14d
andl %ecx, %r14d
movl (%r10,%r14,4), %r14d
movl %r15d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%rax,%r13,4), %r14d
movl %r15d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r8), %r14d
shrl $0x18, %r15d
xorl (%r9,%r15,4), %r14d
xorl %r12d, %r14d
movl %r14d, 0x8(%rdi)
movl 0xc(%rsi), %r12d
addl %ebp, %r12d
movl %r12d, %r15d
andl %ecx, %r15d
movl (%r8,%r15,4), %r15d
movl %r12d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %r15d
movl %r12d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r10), %r15d
shrl $0x18, %r12d
xorl (%rax,%r12,4), %r15d
xorl %r11d, %r15d
movl %r15d, 0x4(%rdi)
movl 0x10(%rsi), %r11d
addl %r14d, %r11d
movl %r11d, %r12d
andl %ecx, %r12d
movl %r11d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
movl (%r8,%r13,4), %r13d
xorl (%rax,%r12,4), %r13d
movl %r11d, %r12d
shrl $0xe, %r12d
andl %edx, %r12d
xorl (%r12,%r9), %r13d
shrl $0x18, %r11d
xorl (%r10,%r11,4), %r13d
subl %r13d, %ebx
movl %ebx, 0xc(%rdi)
leal (%r15,%r14), %r11d
movl %r11d, 0x4(%rdi)
addl 0x14(%rsi), %r11d
movl %r11d, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
movl %r11d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %r12d
movl %r11d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r10), %r12d
shrl $0x18, %r11d
xorl (%rax,%r11,4), %r12d
xorl $0x7, %r12d
addl %r12d, %r14d
movl %r14d, 0x8(%rdi)
subl %r12d, %r15d
movl %r15d, 0x4(%rdi)
movl 0x18(%rsi), %r11d
addl %r15d, %r11d
movl %r11d, %r13d
andl %ecx, %r13d
movl %r11d, %r12d
shrl $0x8, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
xorl (%rax,%r13,4), %r12d
movl %r11d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r9), %r12d
shrl $0x18, %r11d
xorl (%r10,%r11,4), %r12d
addl %ebp, %r12d
movl %r12d, (%rdi)
movl 0x1c(%rsi), %r13d
addl %ebx, %r13d
movl %r13d, %r11d
andl %ecx, %r11d
movl (%r8,%r11,4), %r11d
movl %r13d, %ebp
shrl $0x8, %ebp
andl %ecx, %ebp
xorl (%r9,%rbp,4), %r11d
movl %r13d, %ebp
shrl $0xe, %ebp
andl %edx, %ebp
shrl $0x18, %r13d
xorl (%rbp,%r10), %r11d
xorl (%rax,%r13,4), %r11d
xorl %r14d, %r11d
movl %r11d, 0x8(%rdi)
movl (%rsi), %r14d
addl %r12d, %r14d
movl %r14d, %r13d
andl %ecx, %r13d
movl (%r10,%r13,4), %ebp
movl %r14d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%rax,%r13,4), %ebp
movl %r14d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %r14d
xorl (%r13,%r8), %ebp
xorl (%r9,%r14,4), %ebp
xorl %r15d, %ebp
movl %ebp, 0x4(%rdi)
movl 0x4(%rsi), %r15d
addl %r11d, %r15d
movl %r15d, %r14d
andl %ecx, %r14d
movl (%r10,%r14,4), %r14d
movl %r15d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%rax,%r13,4), %r14d
movl %r15d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %r15d
xorl (%r13,%r8), %r14d
xorl (%r9,%r15,4), %r14d
xorl %r12d, %r14d
movl %r14d, (%rdi)
movl 0x8(%rsi), %r12d
addl %ebp, %r12d
movl %r12d, %r15d
andl %ecx, %r15d
movl (%r8,%r15,4), %r15d
movl %r12d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %r15d
movl %r12d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %r12d
xorl (%r13,%r10), %r15d
xorl (%rax,%r12,4), %r15d
xorl %ebx, %r15d
movl %r15d, 0xc(%rdi)
movl 0xc(%rsi), %ebx
addl %r14d, %ebx
movl %ebx, %r12d
andl %ecx, %r12d
movl %ebx, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
movl (%r8,%r13,4), %r13d
xorl (%rax,%r12,4), %r13d
movl %ebx, %r12d
shrl $0xe, %r12d
andl %edx, %r12d
xorl (%r12,%r9), %r13d
shrl $0x18, %ebx
xorl (%r10,%rbx,4), %r13d
subl %r13d, %r11d
movl %r11d, 0x8(%rdi)
leal (%r15,%r14), %ebx
movl %ebx, 0xc(%rdi)
addl 0x10(%rsi), %ebx
movl %ebx, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
movl %ebx, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %r12d
movl %ebx, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %ebx
xorl (%r13,%r10), %r12d
xorl (%rax,%rbx,4), %r12d
xorl $0x8, %r12d
addl %r12d, %r14d
movl %r14d, (%rdi)
subl %r12d, %r15d
movl %r15d, 0xc(%rdi)
movl 0x14(%rsi), %r12d
addl %r15d, %r12d
movl %r12d, %r13d
andl %ecx, %r13d
movl %r12d, %ebx
shrl $0x8, %ebx
andl %ecx, %ebx
movl (%r8,%rbx,4), %ebx
xorl (%rax,%r13,4), %ebx
movl %r12d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r9), %ebx
shrl $0x18, %r12d
xorl (%r10,%r12,4), %ebx
addl %ebp, %ebx
movl %ebx, 0x4(%rdi)
movl 0x18(%rsi), %r12d
addl %r11d, %r12d
movl %r12d, %r13d
andl %ecx, %r13d
movl (%r8,%r13,4), %ebp
movl %r12d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %ebp
movl %r12d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r10), %ebp
shrl $0x18, %r12d
xorl (%rax,%r12,4), %ebp
xorl %r14d, %ebp
movl %ebp, (%rdi)
movl 0x1c(%rsi), %esi
addl %ebx, %esi
movl %esi, %r14d
andl %ecx, %r14d
movl (%r10,%r14,4), %r10d
movl %esi, %r14d
shrl $0x8, %r14d
andl %ecx, %r14d
xorl (%rax,%r14,4), %r10d
movl %esi, %eax
shrl $0xe, %eax
andl %edx, %eax
xorl (%rax,%r8), %r10d
shrl $0x18, %esi
xorl (%r9,%rsi,4), %r10d
xorl %r15d, %r10d
movl %ebx, (%rdi)
movl %r11d, 0xc(%rdi)
movl %ebp, 0x8(%rdi)
movl %r10d, 0x4(%rdi)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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_ENDIAN)
t[3] = u32Rev(t[3]);
t[2] = u32Rev(t[2]);
t[1] = u32Rev(t[1]);
t[0] = u32Rev(t[0]);
#endif
} | 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), %r11d
xorl (%r10,%rdx,4), %r11d
movl %r14d, %r9d
shrl $0xe, %r9d
movl $0x3fc, %edx # imm = 0x3FC
andl %edx, %r9d
leaq 0x2bdea(%rip), %r8 # 0x4e8b0
xorl (%r9,%r8), %r11d
shrl $0x18, %r14d
leaq 0x2c1db(%rip), %r9 # 0x4ecb0
xorl (%r9,%r14,4), %r11d
movl 0xc(%rdi), %ebp
xorl 0x4(%rdi), %r11d
movl %r11d, 0x4(%rdi)
movl 0x18(%rsi), %r15d
addl %ebp, %r15d
movl %r15d, %r12d
andl %ecx, %r12d
movl %r15d, %r14d
shrl $0x8, %r14d
andl %ecx, %r14d
movl (%r9,%r14,4), %r14d
xorl (%r8,%r12,4), %r14d
movl %r15d, %r12d
shrl $0xe, %r12d
andl %edx, %r12d
xorl (%r12,%r10), %r14d
shrl $0x18, %r15d
xorl (%rax,%r15,4), %r14d
xorl 0x8(%rdi), %r14d
movl %r14d, 0x8(%rdi)
movl 0x14(%rsi), %r15d
addl %r11d, %r15d
movl %r15d, %r12d
andl %ecx, %r12d
movl %r15d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
movl (%r8,%r13,4), %r13d
xorl (%rax,%r12,4), %r13d
movl %r15d, %r12d
shrl $0xe, %r12d
andl %edx, %r12d
xorl (%r12,%r9), %r13d
shrl $0x18, %r15d
xorl (%r10,%r15,4), %r13d
subl %r13d, %ebx
movl %ebx, (%rdi)
leal (%r14,%r11), %r15d
movl %r15d, 0x8(%rdi)
addl 0x10(%rsi), %r15d
movl %r15d, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
movl %r15d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %r12d
movl %r15d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r10), %r12d
shrl $0x18, %r15d
xorl (%rax,%r15,4), %r12d
xorl $0x8, %r12d
addl %r12d, %r11d
movl %r11d, 0x4(%rdi)
subl %r12d, %r14d
movl %r14d, 0x8(%rdi)
movl 0xc(%rsi), %r15d
addl %r14d, %r15d
movl %r15d, %r13d
andl %ecx, %r13d
movl %r15d, %r12d
shrl $0x8, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
xorl (%rax,%r13,4), %r12d
movl %r15d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r9), %r12d
shrl $0x18, %r15d
xorl (%r10,%r15,4), %r12d
addl %ebp, %r12d
movl %r12d, 0xc(%rdi)
movl 0x8(%rsi), %r15d
addl %ebx, %r15d
movl %r15d, %r13d
andl %ecx, %r13d
movl (%r8,%r13,4), %ebp
movl %r15d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %ebp
movl %r15d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %r15d
xorl (%r13,%r10), %ebp
xorl (%rax,%r15,4), %ebp
xorl %r11d, %ebp
movl %ebp, 0x4(%rdi)
movl 0x4(%rsi), %r15d
addl %r12d, %r15d
movl %r15d, %r11d
andl %ecx, %r11d
movl (%r10,%r11,4), %r11d
movl %r15d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%rax,%r13,4), %r11d
movl %r15d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %r15d
xorl (%r13,%r8), %r11d
xorl (%r9,%r15,4), %r11d
xorl %r14d, %r11d
movl %r11d, 0x8(%rdi)
movl (%rsi), %r15d
addl %r11d, %r15d
movl %r15d, %r14d
andl %ecx, %r14d
movl (%r10,%r14,4), %r14d
movl %r15d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%rax,%r13,4), %r14d
movl %r15d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %r15d
xorl (%r13,%r8), %r14d
xorl (%r9,%r15,4), %r14d
xorl %ebx, %r14d
movl %r14d, (%rdi)
movl 0x1c(%rsi), %ebx
addl %ebp, %ebx
movl %ebx, %r15d
andl %ecx, %r15d
movl (%r8,%r15,4), %r15d
movl %ebx, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %r15d
movl %ebx, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %ebx
xorl (%r13,%r10), %r15d
xorl (%rax,%rbx,4), %r15d
xorl %r12d, %r15d
movl %r15d, 0xc(%rdi)
movl 0x18(%rsi), %ebx
addl %r14d, %ebx
movl %ebx, %r12d
andl %ecx, %r12d
movl %ebx, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
movl (%r8,%r13,4), %r13d
xorl (%rax,%r12,4), %r13d
movl %ebx, %r12d
shrl $0xe, %r12d
andl %edx, %r12d
xorl (%r12,%r9), %r13d
shrl $0x18, %ebx
xorl (%r10,%rbx,4), %r13d
subl %r13d, %r11d
movl %r11d, 0x8(%rdi)
leal (%r15,%r14), %ebx
movl %ebx, 0xc(%rdi)
addl 0x14(%rsi), %ebx
movl %ebx, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
movl %ebx, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %r12d
movl %ebx, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %ebx
xorl (%r13,%r10), %r12d
xorl (%rax,%rbx,4), %r12d
xorl $0x7, %r12d
addl %r12d, %r14d
movl %r14d, (%rdi)
subl %r12d, %r15d
movl %r15d, 0xc(%rdi)
movl 0x10(%rsi), %ebx
addl %r15d, %ebx
movl %ebx, %r13d
andl %ecx, %r13d
movl %ebx, %r12d
shrl $0x8, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
xorl (%rax,%r13,4), %r12d
movl %ebx, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r9), %r12d
shrl $0x18, %ebx
xorl (%r10,%rbx,4), %r12d
addl %ebp, %r12d
movl %r12d, 0x4(%rdi)
movl 0xc(%rsi), %ebx
addl %r11d, %ebx
movl %ebx, %r13d
andl %ecx, %r13d
movl (%r8,%r13,4), %ebp
movl %ebx, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %ebp
movl %ebx, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r10), %ebp
shrl $0x18, %ebx
xorl (%rax,%rbx,4), %ebp
xorl %r14d, %ebp
movl %ebp, (%rdi)
movl 0x8(%rsi), %r14d
addl %r12d, %r14d
movl %r14d, %ebx
andl %ecx, %ebx
movl (%r10,%rbx,4), %ebx
movl %r14d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%rax,%r13,4), %ebx
movl %r14d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r8), %ebx
shrl $0x18, %r14d
xorl (%r9,%r14,4), %ebx
xorl %r15d, %ebx
movl %ebx, 0xc(%rdi)
movl 0x4(%rsi), %r15d
addl %ebx, %r15d
movl %r15d, %r14d
andl %ecx, %r14d
movl (%r10,%r14,4), %r14d
movl %r15d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%rax,%r13,4), %r14d
movl %r15d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r8), %r14d
shrl $0x18, %r15d
xorl (%r9,%r15,4), %r14d
xorl %r11d, %r14d
movl %r14d, 0x8(%rdi)
movl (%rsi), %r11d
addl %ebp, %r11d
movl %r11d, %r15d
andl %ecx, %r15d
movl (%r8,%r15,4), %r15d
movl %r11d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %r15d
movl %r11d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r10), %r15d
shrl $0x18, %r11d
xorl (%rax,%r11,4), %r15d
xorl %r12d, %r15d
movl %r15d, 0x4(%rdi)
movl 0x1c(%rsi), %r11d
addl %r14d, %r11d
movl %r11d, %r12d
andl %ecx, %r12d
movl %r11d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
movl (%r8,%r13,4), %r13d
xorl (%rax,%r12,4), %r13d
movl %r11d, %r12d
shrl $0xe, %r12d
andl %edx, %r12d
xorl (%r12,%r9), %r13d
shrl $0x18, %r11d
xorl (%r10,%r11,4), %r13d
subl %r13d, %ebx
movl %ebx, 0xc(%rdi)
leal (%r15,%r14), %r11d
movl %r11d, 0x4(%rdi)
addl 0x18(%rsi), %r11d
movl %r11d, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
movl %r11d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %r12d
movl %r11d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r10), %r12d
shrl $0x18, %r11d
xorl (%rax,%r11,4), %r12d
xorl $0x6, %r12d
addl %r12d, %r14d
movl %r14d, 0x8(%rdi)
subl %r12d, %r15d
movl %r15d, 0x4(%rdi)
movl 0x14(%rsi), %r11d
addl %r15d, %r11d
movl %r11d, %r13d
andl %ecx, %r13d
movl %r11d, %r12d
shrl $0x8, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
xorl (%rax,%r13,4), %r12d
movl %r11d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r9), %r12d
shrl $0x18, %r11d
xorl (%r10,%r11,4), %r12d
addl %ebp, %r12d
movl %r12d, (%rdi)
movl 0x10(%rsi), %r11d
addl %ebx, %r11d
movl %r11d, %r13d
andl %ecx, %r13d
movl (%r8,%r13,4), %ebp
movl %r11d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %ebp
movl %r11d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %r11d
xorl (%r13,%r10), %ebp
xorl (%rax,%r11,4), %ebp
xorl %r14d, %ebp
movl %ebp, 0x8(%rdi)
movl 0xc(%rsi), %r14d
addl %r12d, %r14d
movl %r14d, %r11d
andl %ecx, %r11d
movl (%r10,%r11,4), %r11d
movl %r14d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%rax,%r13,4), %r11d
movl %r14d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %r14d
xorl (%r13,%r8), %r11d
xorl (%r9,%r14,4), %r11d
xorl %r15d, %r11d
movl %r11d, 0x4(%rdi)
movl 0x8(%rsi), %r15d
addl %r11d, %r15d
movl %r15d, %r14d
andl %ecx, %r14d
movl (%r10,%r14,4), %r14d
movl %r15d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%rax,%r13,4), %r14d
movl %r15d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %r15d
xorl (%r13,%r8), %r14d
xorl (%r9,%r15,4), %r14d
xorl %ebx, %r14d
movl %r14d, 0xc(%rdi)
movl 0x4(%rsi), %ebx
addl %ebp, %ebx
movl %ebx, %r15d
andl %ecx, %r15d
movl (%r8,%r15,4), %r15d
movl %ebx, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %r15d
movl %ebx, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %ebx
xorl (%r13,%r10), %r15d
xorl (%rax,%rbx,4), %r15d
xorl %r12d, %r15d
movl %r15d, (%rdi)
movl (%rsi), %ebx
addl %r14d, %ebx
movl %ebx, %r12d
andl %ecx, %r12d
movl %ebx, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
movl (%r8,%r13,4), %r13d
xorl (%rax,%r12,4), %r13d
movl %ebx, %r12d
shrl $0xe, %r12d
andl %edx, %r12d
xorl (%r12,%r9), %r13d
shrl $0x18, %ebx
xorl (%r10,%rbx,4), %r13d
subl %r13d, %r11d
movl %r11d, 0x4(%rdi)
leal (%r15,%r14), %ebx
movl %ebx, (%rdi)
addl 0x1c(%rsi), %ebx
movl %ebx, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
movl %ebx, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %r12d
movl %ebx, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %ebx
xorl (%r13,%r10), %r12d
xorl (%rax,%rbx,4), %r12d
xorl $0x5, %r12d
addl %r12d, %r14d
movl %r14d, 0xc(%rdi)
subl %r12d, %r15d
movl %r15d, (%rdi)
movl 0x18(%rsi), %ebx
addl %r15d, %ebx
movl %ebx, %r13d
andl %ecx, %r13d
movl %ebx, %r12d
shrl $0x8, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
xorl (%rax,%r13,4), %r12d
movl %ebx, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r9), %r12d
shrl $0x18, %ebx
xorl (%r10,%rbx,4), %r12d
addl %ebp, %r12d
movl %r12d, 0x8(%rdi)
movl 0x14(%rsi), %ebx
addl %r11d, %ebx
movl %ebx, %r13d
andl %ecx, %r13d
movl (%r8,%r13,4), %ebp
movl %ebx, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %ebp
movl %ebx, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r10), %ebp
shrl $0x18, %ebx
xorl (%rax,%rbx,4), %ebp
xorl %r14d, %ebp
movl %ebp, 0xc(%rdi)
movl 0x10(%rsi), %r14d
addl %r12d, %r14d
movl %r14d, %ebx
andl %ecx, %ebx
movl (%r10,%rbx,4), %ebx
movl %r14d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%rax,%r13,4), %ebx
movl %r14d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r8), %ebx
shrl $0x18, %r14d
xorl (%r9,%r14,4), %ebx
xorl %r15d, %ebx
movl %ebx, (%rdi)
movl 0xc(%rsi), %r15d
addl %ebx, %r15d
movl %r15d, %r14d
andl %ecx, %r14d
movl (%r10,%r14,4), %r14d
movl %r15d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%rax,%r13,4), %r14d
movl %r15d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r8), %r14d
shrl $0x18, %r15d
xorl (%r9,%r15,4), %r14d
xorl %r11d, %r14d
movl %r14d, 0x4(%rdi)
movl 0x8(%rsi), %r11d
addl %ebp, %r11d
movl %r11d, %r15d
andl %ecx, %r15d
movl (%r8,%r15,4), %r15d
movl %r11d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %r15d
movl %r11d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r10), %r15d
shrl $0x18, %r11d
xorl (%rax,%r11,4), %r15d
xorl %r12d, %r15d
movl %r15d, 0x8(%rdi)
movl 0x4(%rsi), %r11d
addl %r14d, %r11d
movl %r11d, %r12d
andl %ecx, %r12d
movl %r11d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
movl (%r8,%r13,4), %r13d
xorl (%rax,%r12,4), %r13d
movl %r11d, %r12d
shrl $0xe, %r12d
andl %edx, %r12d
xorl (%r12,%r9), %r13d
shrl $0x18, %r11d
xorl (%r10,%r11,4), %r13d
subl %r13d, %ebx
movl %ebx, (%rdi)
leal (%r15,%r14), %r11d
movl %r11d, 0x8(%rdi)
addl (%rsi), %r11d
movl %r11d, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
movl %r11d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %r12d
movl %r11d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r10), %r12d
shrl $0x18, %r11d
xorl (%rax,%r11,4), %r12d
xorl $0x4, %r12d
addl %r12d, %r14d
movl %r14d, 0x4(%rdi)
subl %r12d, %r15d
movl %r15d, 0x8(%rdi)
movl 0x1c(%rsi), %r11d
addl %r15d, %r11d
movl %r11d, %r13d
andl %ecx, %r13d
movl %r11d, %r12d
shrl $0x8, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
xorl (%rax,%r13,4), %r12d
movl %r11d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r9), %r12d
shrl $0x18, %r11d
xorl (%r10,%r11,4), %r12d
addl %ebp, %r12d
movl %r12d, 0xc(%rdi)
movl 0x18(%rsi), %r11d
addl %ebx, %r11d
movl %r11d, %r13d
andl %ecx, %r13d
movl (%r8,%r13,4), %ebp
movl %r11d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %ebp
movl %r11d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %r11d
xorl (%r13,%r10), %ebp
xorl (%rax,%r11,4), %ebp
xorl %r14d, %ebp
movl %ebp, 0x4(%rdi)
movl 0x14(%rsi), %r14d
addl %r12d, %r14d
movl %r14d, %r11d
andl %ecx, %r11d
movl (%r10,%r11,4), %r11d
movl %r14d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%rax,%r13,4), %r11d
movl %r14d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %r14d
xorl (%r13,%r8), %r11d
xorl (%r9,%r14,4), %r11d
xorl %r15d, %r11d
movl %r11d, 0x8(%rdi)
movl 0x10(%rsi), %r15d
addl %r11d, %r15d
movl %r15d, %r14d
andl %ecx, %r14d
movl (%r10,%r14,4), %r14d
movl %r15d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%rax,%r13,4), %r14d
movl %r15d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %r15d
xorl (%r13,%r8), %r14d
xorl (%r9,%r15,4), %r14d
xorl %ebx, %r14d
movl %r14d, (%rdi)
movl 0xc(%rsi), %ebx
addl %ebp, %ebx
movl %ebx, %r15d
andl %ecx, %r15d
movl (%r8,%r15,4), %r15d
movl %ebx, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %r15d
movl %ebx, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %ebx
xorl (%r13,%r10), %r15d
xorl (%rax,%rbx,4), %r15d
xorl %r12d, %r15d
movl %r15d, 0xc(%rdi)
movl 0x8(%rsi), %ebx
addl %r14d, %ebx
movl %ebx, %r12d
andl %ecx, %r12d
movl %ebx, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
movl (%r8,%r13,4), %r13d
xorl (%rax,%r12,4), %r13d
movl %ebx, %r12d
shrl $0xe, %r12d
andl %edx, %r12d
xorl (%r12,%r9), %r13d
shrl $0x18, %ebx
xorl (%r10,%rbx,4), %r13d
subl %r13d, %r11d
movl %r11d, 0x8(%rdi)
leal (%r15,%r14), %ebx
movl %ebx, 0xc(%rdi)
addl 0x4(%rsi), %ebx
movl %ebx, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
movl %ebx, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %r12d
movl %ebx, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %ebx
xorl (%r13,%r10), %r12d
xorl (%rax,%rbx,4), %r12d
xorl $0x3, %r12d
addl %r12d, %r14d
movl %r14d, (%rdi)
subl %r12d, %r15d
movl %r15d, 0xc(%rdi)
movl (%rsi), %ebx
addl %r15d, %ebx
movl %ebx, %r13d
andl %ecx, %r13d
movl %ebx, %r12d
shrl $0x8, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
xorl (%rax,%r13,4), %r12d
movl %ebx, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r9), %r12d
shrl $0x18, %ebx
xorl (%r10,%rbx,4), %r12d
addl %ebp, %r12d
movl %r12d, 0x4(%rdi)
movl 0x1c(%rsi), %ebx
addl %r11d, %ebx
movl %ebx, %r13d
andl %ecx, %r13d
movl (%r8,%r13,4), %ebp
movl %ebx, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %ebp
movl %ebx, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r10), %ebp
shrl $0x18, %ebx
xorl (%rax,%rbx,4), %ebp
xorl %r14d, %ebp
movl %ebp, (%rdi)
movl 0x18(%rsi), %r14d
addl %r12d, %r14d
movl %r14d, %ebx
andl %ecx, %ebx
movl (%r10,%rbx,4), %ebx
movl %r14d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%rax,%r13,4), %ebx
movl %r14d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r8), %ebx
shrl $0x18, %r14d
xorl (%r9,%r14,4), %ebx
xorl %r15d, %ebx
movl %ebx, 0xc(%rdi)
movl 0x14(%rsi), %r15d
addl %ebx, %r15d
movl %r15d, %r14d
andl %ecx, %r14d
movl (%r10,%r14,4), %r14d
movl %r15d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%rax,%r13,4), %r14d
movl %r15d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r8), %r14d
shrl $0x18, %r15d
xorl (%r9,%r15,4), %r14d
xorl %r11d, %r14d
movl %r14d, 0x8(%rdi)
movl 0x10(%rsi), %r11d
addl %ebp, %r11d
movl %r11d, %r15d
andl %ecx, %r15d
movl (%r8,%r15,4), %r15d
movl %r11d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %r15d
movl %r11d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r10), %r15d
shrl $0x18, %r11d
xorl (%rax,%r11,4), %r15d
xorl %r12d, %r15d
movl %r15d, 0x4(%rdi)
movl 0xc(%rsi), %r11d
addl %r14d, %r11d
movl %r11d, %r12d
andl %ecx, %r12d
movl %r11d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
movl (%r8,%r13,4), %r13d
xorl (%rax,%r12,4), %r13d
movl %r11d, %r12d
shrl $0xe, %r12d
andl %edx, %r12d
xorl (%r12,%r9), %r13d
shrl $0x18, %r11d
xorl (%r10,%r11,4), %r13d
subl %r13d, %ebx
movl %ebx, 0xc(%rdi)
leal (%r15,%r14), %r11d
movl %r11d, 0x4(%rdi)
addl 0x8(%rsi), %r11d
movl %r11d, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
movl %r11d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %r12d
movl %r11d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r10), %r12d
shrl $0x18, %r11d
xorl (%rax,%r11,4), %r12d
xorl $0x2, %r12d
addl %r12d, %r14d
movl %r14d, 0x8(%rdi)
subl %r12d, %r15d
movl %r15d, 0x4(%rdi)
movl 0x4(%rsi), %r11d
addl %r15d, %r11d
movl %r11d, %r13d
andl %ecx, %r13d
movl %r11d, %r12d
shrl $0x8, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
xorl (%rax,%r13,4), %r12d
movl %r11d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r9), %r12d
shrl $0x18, %r11d
xorl (%r10,%r11,4), %r12d
addl %ebp, %r12d
movl %r12d, (%rdi)
movl (%rsi), %r11d
addl %ebx, %r11d
movl %r11d, %r13d
andl %ecx, %r13d
movl (%r8,%r13,4), %ebp
movl %r11d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %ebp
movl %r11d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %r11d
xorl (%r13,%r10), %ebp
xorl (%rax,%r11,4), %ebp
xorl %r14d, %ebp
movl %ebp, 0x8(%rdi)
movl 0x1c(%rsi), %r14d
addl %r12d, %r14d
movl %r14d, %r11d
andl %ecx, %r11d
movl (%r10,%r11,4), %r11d
movl %r14d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%rax,%r13,4), %r11d
movl %r14d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %r14d
xorl (%r13,%r8), %r11d
xorl (%r9,%r14,4), %r11d
xorl %r15d, %r11d
movl %r11d, 0x4(%rdi)
movl 0x18(%rsi), %r15d
addl %r11d, %r15d
movl %r15d, %r14d
andl %ecx, %r14d
movl (%r10,%r14,4), %r14d
movl %r15d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%rax,%r13,4), %r14d
movl %r15d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %r15d
xorl (%r13,%r8), %r14d
xorl (%r9,%r15,4), %r14d
xorl %ebx, %r14d
movl %r14d, 0xc(%rdi)
movl 0x14(%rsi), %r15d
addl %ebp, %r15d
movl %r15d, %ebx
andl %ecx, %ebx
movl (%r8,%rbx,4), %ebx
movl %r15d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %ebx
movl %r15d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %r15d
xorl (%r13,%r10), %ebx
xorl (%rax,%r15,4), %ebx
xorl %r12d, %ebx
movl %ebx, (%rdi)
movl 0x10(%rsi), %r15d
addl %r14d, %r15d
movl %r15d, %r12d
andl %ecx, %r12d
movl %r15d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
movl (%r8,%r13,4), %r13d
xorl (%rax,%r12,4), %r13d
movl %r15d, %r12d
shrl $0xe, %r12d
andl %edx, %r12d
xorl (%r12,%r9), %r13d
shrl $0x18, %r15d
xorl (%r10,%r15,4), %r13d
subl %r13d, %r11d
movl %r11d, 0x4(%rdi)
leal (%rbx,%r14), %r15d
movl %r15d, (%rdi)
addl 0xc(%rsi), %r15d
movl %r15d, %r12d
andl %ecx, %r12d
movl (%r8,%r12,4), %r12d
movl %r15d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %r12d
movl %r15d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
shrl $0x18, %r15d
xorl (%r13,%r10), %r12d
xorl (%rax,%r15,4), %r12d
xorl $0x1, %r12d
addl %r12d, %r14d
movl %r14d, 0xc(%rdi)
subl %r12d, %ebx
movl %ebx, (%rdi)
movl 0x8(%rsi), %r12d
addl %ebx, %r12d
movl %r12d, %r13d
andl %ecx, %r13d
movl %r12d, %r15d
shrl $0x8, %r15d
andl %ecx, %r15d
movl (%r8,%r15,4), %r15d
xorl (%rax,%r13,4), %r15d
movl %r12d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r9), %r15d
shrl $0x18, %r12d
xorl (%r10,%r12,4), %r15d
addl %ebp, %r15d
movl %r15d, 0x8(%rdi)
movl 0x4(%rsi), %r12d
addl %r11d, %r12d
movl %r12d, %r13d
andl %ecx, %r13d
movl (%r8,%r13,4), %ebp
movl %r12d, %r13d
shrl $0x8, %r13d
andl %ecx, %r13d
xorl (%r9,%r13,4), %ebp
movl %r12d, %r13d
shrl $0xe, %r13d
andl %edx, %r13d
xorl (%r13,%r10), %ebp
shrl $0x18, %r12d
xorl (%rax,%r12,4), %ebp
xorl %r14d, %ebp
movl %ebp, 0xc(%rdi)
movl (%rsi), %esi
addl %r15d, %esi
movl %esi, %r14d
andl %ecx, %r14d
movl (%r10,%r14,4), %r10d
movl %esi, %r14d
shrl $0x8, %r14d
andl %ecx, %r14d
xorl (%rax,%r14,4), %r10d
movl %esi, %eax
shrl $0xe, %eax
andl %edx, %eax
xorl (%rax,%r8), %r10d
shrl $0x18, %esi
xorl (%r9,%rsi,4), %r10d
xorl %ebx, %r10d
movl %r10d, 0x4(%rdi)
movl %ebp, 0x8(%rdi)
movl %r11d, 0xc(%rdi)
movl %r15d, (%rdi)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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}
beltBlockCopy(st->block, buf);
for (i = 16; i + 16 < count; i += 16)
beltBlockXor2(st->block, (octet*)buf + i);
// r <- ShLo^128(r)
memMove(buf, (octet*)buf + 16, count - 16);
// r* <- block
beltBlockCopy((octet*)buf + count - 16, st->block);
// block <- beltBlockEncr(block) + <round>
beltBlockEncr(st->block, st->key);
st->round++;
#if (OCTET_ORDER == LITTLE_ENDIAN)
memXor2(st->block, &st->round, O_PER_W);
#else // BIG_ENDIAN
st->round = wordRev(st->round);
memXor2(st->block, &st->round, O_PER_W);
st->round = wordRev(st->round);
#endif // OCTET_ORDER
// r*_до_сдвига <- r*_до_сдвига + block
beltBlockXor2((octet*)buf + count - 32, st->block);
}
while (st->round % (2 * n));
} | 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
movq (%r15), %rax
movq %rax, (%rbp)
movq 0x8(%r15), %rcx
pushq $0x20
popq %rdx
movq %rcx, 0x28(%rbx)
cmpq %r14, %rdx
jae 0x2536c
xorq -0x10(%r15,%rdx), %rax
movq %rax, (%rbp)
xorq -0x8(%r15,%rdx), %rcx
addq $0x10, %rdx
jmp 0x2534f
movq %r15, %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xe130
movq 0x20(%rbx), %rax
movq %rax, -0x10(%r15,%r14)
movq 0x28(%rbx), %rax
movq %rax, -0x8(%r15,%r14)
movq %rbp, %rdi
movq %rbx, %rsi
callq 0xe140
incq 0x40(%rbx)
movq %rbp, %rdi
movq %r12, %rsi
pushq $0x8
popq %rdx
callq 0xf0b0
movq 0x20(%rbx), %rax
xorq %rax, -0x20(%r15,%r14)
movq 0x28(%rbx), %rax
xorq %rax, -0x18(%r15,%r14)
movq 0x40(%rbx), %rax
xorl %edx, %edx
divq %r13
testq %rdx, %rdx
jne 0x25341
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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; i + 16 < count; i += 16)
beltBlockXor2(st->sum, (octet*)buf + i);
// 2 * n итераций
ASSERT(st->round % (2 * n) == 0);
// sum будет записываться по смещению i:
// это блок r1 в начале такта и блок r* в конце)
i = 0;
do
{
// block <- beltBlockEncr(sum) + <round>
beltBlockCopy(st->block, st->sum);
beltBlockEncr(st->block, st->key);
st->round++;
#if (OCTET_ORDER == LITTLE_ENDIAN)
memXor2(st->block, &st->round, O_PER_W);
#else // BIG_ENDIAN
st->round = wordRev(st->round);
memXor2(st->block, &st->round, O_PER_W);
st->round = wordRev(st->round);
#endif // OCTET_ORDER
// r* <- r* + block
beltBlockXor2((octet*)buf + (i + count - 16) % count, st->block);
// запомнить sum
beltBlockCopy(st->block, st->sum);
// пересчитать sum: добавить новое слагаемое
beltBlockXor2(st->sum, (octet*)buf + (i + count - 16) % count);
// пересчитать sum: исключить старое слагаемое
beltBlockXor2(st->sum, (octet*)buf + i);
// сохранить sum
beltBlockCopy((octet*)buf + i, st->block);
// вперед
i = (i + 16) % count;
}
while (st->round % (2 * n));
} | 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 -0x8(%r15,%rdx), %rcx
addq $0x10, %rdx
jmp 0x25405
leaq 0xf(%r14), %r13
leaq 0x20(%rbx), %r12
leaq 0x40(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq -0x10(%r14), %rax
movq %rax, 0x8(%rsp)
shrq $0x3, %r13
andq $-0x2, %r13
xorl %ebp, %ebp
movq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
movq 0x38(%rbx), %rax
movq %rax, 0x28(%rbx)
movq %r12, %rdi
movq %rbx, %rsi
callq 0xe140
incq 0x40(%rbx)
movq %r12, %rdi
movq 0x10(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0xf0b0
movq 0x20(%rbx), %rcx
movq 0x8(%rsp), %rax
addq %rbp, %rax
xorl %edx, %edx
divq %r14
xorq %rcx, (%r15,%rdx)
movq 0x28(%rbx), %rax
xorq %rax, 0x8(%r15,%rdx)
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rcx
movq %rax, 0x20(%rbx)
movq %rcx, 0x28(%rbx)
movq (%r15,%rdx), %rsi
xorq %rax, %rsi
movq %rsi, 0x30(%rbx)
xorq 0x8(%r15,%rdx), %rcx
movq %rcx, 0x38(%rbx)
xorq (%r15,%rbp), %rsi
movq %rsi, 0x30(%rbx)
xorq 0x8(%r15,%rbp), %rcx
movq %rcx, 0x38(%rbx)
movq %rax, (%r15,%rbp)
movq 0x28(%rbx), %rax
movq %rax, 0x8(%r15,%rbp)
addq $0x10, %rbp
movq %rbp, %rax
xorl %edx, %edx
divq %r14
movq 0x40(%rbx), %rax
movq %rdx, %rbp
xorl %edx, %edx
divq %r13
testq %rdx, %rdx
jne 0x25446
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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->block, (octet*)buf + count - 16);
// r <- ShHi^128(r)
memMove((octet*)buf + 16, buf, count - 16);
// r1 <- block
beltBlockCopy(buf, st->block);
// block <- beltBlockEncr(block) + <round>
beltBlockEncr(st->block, st->key);
#if (OCTET_ORDER == LITTLE_ENDIAN)
memXor2(st->block, &st->round, O_PER_W);
#else // BIG_ENDIAN
st->round = wordRev(st->round);
memXor2(st->block, &st->round, O_PER_W);
st->round = wordRev(st->round);
#endif // OCTET_ORDER
// r* <- r* + block
beltBlockXor2((octet*)buf + count - 16, st->block);
// r1 <- r1 + r2 + ... + r_{n-1}
for (i = 16; i + 16 < count; i += 16)
beltBlockXor2(buf, (octet*)buf + i);
}
} | 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, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
leaq 0x28(%rdx), %rcx
movq %rcx, 0x18(%rsp)
leaq 0x10(%rdi), %rcx
movq %rcx, 0x10(%rsp)
leaq -0x10(%rsi), %rcx
movq %rcx, 0x8(%rsp)
leaq 0x8(%rdi), %r13
movq %rbp, 0x30(%rsp)
movq 0x38(%rsp), %r12
movq 0x28(%rsp), %rbx
movq %rax, (%rbp)
testq %rax, %rax
je 0x25628
movq -0x10(%r12), %rax
movq %rax, 0x20(%rbx)
movq -0x8(%r12), %rax
movq %rax, 0x28(%rbx)
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movq 0x8(%rsp), %rdx
callq 0xe130
movq 0x20(%rbx), %rax
movq %rax, (%r15)
movq 0x28(%rbx), %rax
movq %rax, 0x8(%r15)
movq 0x40(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
callq 0xe140
movq %rbp, %rdi
movq 0x30(%rsp), %rbp
movq %rbp, %rsi
pushq $0x8
popq %rdx
callq 0xf0b0
movq 0x20(%rbx), %rax
xorq %rax, -0x10(%r12)
pushq $0x20
popq %rax
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rsi
pushq $0x10
popq %rcx
movq (%rdx), %rdx
xorq %rdx, (%rsi)
cmpq %r14, %rax
jae 0x2561c
movq -0x10(%r15,%rax), %rdx
xorq %rdx, (%r15)
leaq (%r15,%rcx), %rdx
addq $0x8, %rdx
addq $0x10, %rax
addq $0x10, %rcx
movq %r13, %rsi
jmp 0x255f4
movq (%rbp), %rax
decq %rax
jmp 0x25578
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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})
beltBlockCopy(st->sum, (octet*)buf);
for (i = 16; i + 32 < count; i += 16)
beltBlockXor2(st->sum, (octet*)buf + i);
// 2 * n итераций (sum будет записываться по смещению i:
// это блок r* в начале такта и блок r1 в конце)
for (st->round = 2 * n, i = count - 16; st->round; --st->round)
{
// block <- beltBlockEncr(r*) + <round>
beltBlockCopy(st->block, (octet*)buf + i);
beltBlockEncr(st->block, st->key);
#if (OCTET_ORDER == LITTLE_ENDIAN)
memXor2(st->block, &st->round, O_PER_W);
#else // BIG_ENDIAN
st->round = wordRev(st->round);
memXor2(st->block, &st->round, O_PER_W);
st->round = wordRev(st->round);
#endif // OCTET_ORDER
// r* <- r* + block
beltBlockXor2((octet*)buf + (i + count - 16) % count, st->block);
// r1 <- pre r* + sum
beltBlockXor2((octet*)buf + i, st->sum);
// пересчитать sum: исключить старое слагаемое
beltBlockXor2(st->sum, (octet*)buf + (i + count - 32) % count);
// пересчитать sum: добавить новое слагаемое
beltBlockXor2(st->sum, (octet*)buf + i);
// назад
i = (i + count - 16) % count;
}
} | 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(%r15,%rdx), %rcx
movq %rcx, 0x38(%rbx)
addq $0x10, %rdx
jmp 0x2565d
leaq 0xf(%r14), %rax
shrq $0x3, %rax
andq $-0x2, %rax
leaq 0x40(%rbx), %r12
movq %rax, 0x40(%rbx)
leaq -0x10(%r14), %rbp
leaq 0x20(%rbx), %r13
testq %rax, %rax
je 0x25745
movq (%r15,%rbp), %rax
movq %rax, 0x20(%rbx)
movq 0x8(%r15,%rbp), %rax
movq %rax, 0x28(%rbx)
movq %r13, %rdi
movq %rbx, %rsi
callq 0xe140
movq %r13, %rdi
movq %r12, %rsi
pushq $0x8
popq %rdx
callq 0xf0b0
movq 0x20(%rbx), %rsi
leaq (%r14,%rbp), %rax
addq $-0x10, %rax
xorl %edx, %edx
divq %r14
movq %rdx, %rcx
xorq %rsi, (%r15,%rdx)
movq 0x28(%rbx), %rax
xorq %rax, 0x8(%r15,%rdx)
movq 0x30(%rbx), %rax
xorq %rax, (%r15,%rbp)
movq 0x38(%rbx), %rax
xorq %rax, 0x8(%r15,%rbp)
leaq (%r14,%rbp), %rax
addq $-0x20, %rax
xorl %edx, %edx
divq %r14
movq 0x30(%rbx), %rax
xorq (%r15,%rdx), %rax
movq 0x38(%rbx), %rsi
movq %rax, 0x30(%rbx)
xorq 0x8(%r15,%rdx), %rsi
movq %rsi, 0x38(%rbx)
xorq (%r15,%rbp), %rax
movq %rax, 0x30(%rbx)
xorq 0x8(%r15,%rbp), %rsi
movq %rsi, 0x38(%rbx)
movq 0x40(%rbx), %rax
decq %rax
movq %rax, 0x40(%rbx)
movq %rcx, %rbp
jmp 0x25696
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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;
// block <- r*
beltBlockCopy(st->block, buf2);
// r <- ShHi^128(r)
memCopy(buf2, (octet*)buf1 + count - 32, 16);
memMove((octet*)buf1 + 16, buf1, count - 32);
// r1 <- block
beltBlockCopy(buf1, st->block);
// block <- beltBlockEncr(block) + <round>
beltBlockEncr(st->block, st->key);
#if (OCTET_ORDER == LITTLE_ENDIAN)
memXor2(st->block, &st->round, O_PER_W);
#else // BIG_ENDIAN
st->round = wordRev(st->round);
memXor2(st->block, &st->round, O_PER_W);
st->round = wordRev(st->round);
#endif // OCTET_ORDER
// r* <- r* + block
beltBlockXor2(buf2, st->block);
// r1 <- r1 + r2 + ... + r_{n-1}
for (i = 16; i + 32 < count; i += 16)
beltBlockXor2(buf1, (octet*)buf1 + i);
ASSERT(i + 16 <= count && i + 32 >= count);
if (i + 16 < count)
{
memXor2(buf1, (octet*)buf1 + i, count - 16 - i);
memXor2((octet*)buf1 + count - 16 - i, buf2, 32 + i - count);
}
}
} | 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(%rdi), %rcx
movq %rcx, 0x18(%rsp)
leaq -0x20(%rdx), %rcx
movq %rcx, (%rsp)
pushq $0x30
popq %rcx
subq %rdx, %rcx
movq %rcx, 0x10(%rsp)
movq %rax, (%r13)
testq %rax, %rax
je 0x258cb
movq (%r15), %rax
movq %rax, 0x20(%rbx)
movq 0x8(%r15), %rax
movq %rax, 0x28(%rbx)
movq %r15, %rdi
movq 0x8(%rsp), %rsi
pushq $0x10
popq %rdx
callq 0xe970
movq 0x18(%rsp), %rdi
movq %r12, %rsi
movq (%rsp), %rdx
callq 0xe130
movq 0x20(%rbx), %rax
movq %rax, (%r12)
movq 0x28(%rbx), %rax
movq %rax, 0x8(%r12)
movq 0x20(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
callq 0xe140
movq %rbp, %rdi
movq %r13, %rsi
pushq $0x8
popq %rdx
callq 0xf0b0
movq 0x20(%rbx), %rax
xorq %rax, (%r15)
movq 0x28(%rbx), %rax
xorq %rax, 0x8(%r15)
xorl %ebp, %ebp
leaq 0x30(%rbp), %rax
cmpq %r14, %rax
jae 0x25887
movq 0x10(%r12,%rbp), %rax
xorq %rax, (%r12)
movq 0x18(%r12,%rbp), %rax
xorq %rax, 0x8(%r12)
addq $0x10, %rbp
jmp 0x25865
leaq 0x20(%rbp), %rax
cmpq %r14, %rax
jae 0x258bf
leaq (%r12,%rbp), %rsi
addq $0x10, %rsi
movq (%rsp), %rdx
subq %rbp, %rdx
movq %r12, %rdi
callq 0xf0b0
movq 0x8(%rsp), %rdi
subq %rbp, %rdi
addq 0x10(%rsp), %rbp
movq %r15, %rsi
movq %rbp, %rdx
callq 0xf0b0
movq (%r13), %rax
decq %rax
jmp 0x257e8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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;
carry = (block[0] += carry) < carry;
if ((block[1] += carry) < carry)
block[1] = (u32)t;
else
carry = (block[1] += (u32)t) < (u32)t;
t >>= 16, t >>= 16;
if ((block[2] += carry) < carry)
block[2] = (u32)t;
else
carry = (block[2] += (u32)t) < (u32)t;
t >>= 16, t >>= 16;
block[3] += carry;
block[3] += (u32)t;
t = 0;
#endif
carry = 0;
} | 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 %eax, 0x4(%rdi)
cmovbl %esi, %r8d
setb %al
orb %r9b, %al
movzbl %al, %eax
andl $0x1, %eax
movl %r8d, 0x8(%rdi)
addl %eax, 0xc(%rdi)
retq
| /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] += (word)t) < (word)t;
t >>= 8, t >>= 8;
if ((block[2] += carry) < carry)
block[2] = (word)t;
else
carry = (block[2] += (word)t) < (word)t;
t >>= 8, t >>= 8;
block[3] += carry;
block[3] += (word)t;
#elif (B_PER_W == 32)
register size_t t = count;
carry = (block[0] += carry) < carry;
t >>= 15, t >>= 14;
block[1] += carry;
block[1] += (u32)t;
t = 0;
#elif (B_PER_W == 64)
block[0] += carry;
#else
#error "Unsupported word size"
#endif // B_PER_W
carry = 0;
} | 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
nopl (%rax)
| /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, st->block);
buf = (octet*)buf + 16;
count -= 16;
}
// неполный блок? кража блока
if (count)
{
memSwap((octet*)buf - 16, buf, count);
memXor2((octet*)buf - 16, st->block, count);
beltBlockEncr((octet*)buf - 16, st->key);
}
} | 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)
movq 0x28(%rbx), %rax
movq %rax, 0x8(%r12)
addq $0x10, %r12
addq $-0x10, %r14
jmp 0x25a20
testq %r14, %r14
je 0x25a97
leaq -0x10(%r12), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xfec0
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xf0b0
movq %r13, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xe140
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /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);
beltBlockXor2(buf, st->block);
beltBlockCopy(st->block, st->block2);
buf = (octet*)buf + 16;
count -= 16;
}
// неполный блок? кража блока
if (count)
{
ASSERT(16 < count && count < 32);
beltBlockDecr(buf, st->key);
memSwap(buf, (octet*)buf + 16, count - 16);
memXor2((octet*)buf + 16, buf, count - 16);
beltBlockDecr(buf, st->key);
beltBlockXor2(buf, st->block);
}
} | 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,%r13), %rax
movq %rax, 0x30(%rbx)
movq 0x8(%r15,%r13), %rax
movq %rax, 0x38(%rbx)
movq %r12, %rdi
movq %rbx, %rsi
movq %rdx, %r12
callq 0xe3d0
movq %r12, %rdx
movq 0x20(%rbx), %rax
xorq %rax, (%r15,%r13)
movq 0x28(%rbx), %rax
xorq %rax, 0x8(%r15,%r13)
movups 0x30(%rbx), %xmm0
movups %xmm0, 0x20(%rbx)
addq $0x10, %r13
addq $-0x10, %r14
jmp 0x25abf
subq %r13, %rdx
je 0x25b72
movq %r12, %rdi
movq %rbx, %rsi
movq %rdx, %r14
callq 0xe3d0
addq %r13, %r15
addq $0x10, %r15
addq $-0x10, %r14
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xfec0
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xf0b0
movq %r12, %rdi
movq %rbx, %rsi
callq 0xe3d0
movq 0x20(%rbx), %rax
xorq %rax, -0x10(%r15)
movq 0x28(%rbx), %rax
xorq %rax, -0x8(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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, count))
return ERR_BAD_INPUT;
// создать состояние
state = blobCreate(beltCBC_keep());
if (state == 0)
return ERR_OUTOFMEMORY;
// зашифровать
beltCBCStart(state, key, len, iv);
memMove(dest, src, count);
beltCBCStepE(dest, count, state);
// завершить
blobClose(state);
return ERR_OK;
} | 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, (%rsp)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x25c57
movq %r14, %rdi
movq %r13, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x25c57
pushq $0x10
popq %rsi
movq %r12, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x25c57
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x25c57
pushq $0x40
popq %rdi
callq 0xf190
testq %rax, %rax
je 0x25c54
movq %rax, %rbp
movq %rax, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0xf220
movq (%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xe130
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0xf2a0
movq %rbp, %rdi
callq 0xe920
xorl %ebp, %ebp
jmp 0x25c57
pushq $0x6e
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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, count))
return ERR_BAD_INPUT;
// создать состояние
state = blobCreate(beltCBC_keep());
if (state == 0)
return ERR_OUTOFMEMORY;
// расшифровать
beltCBCStart(state, key, len, iv);
memMove(dest, src, count);
beltCBCStepD(dest, count, state);
// завершить
blobClose(state);
return ERR_OK;
} | 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, (%rsp)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x25d3e
movq %r14, %rdi
movq %r13, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x25d3e
pushq $0x10
popq %rsi
movq %r12, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x25d3e
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x25d3e
pushq $0x40
popq %rdi
callq 0xf190
testq %rax, %rax
je 0x25d3b
movq %rax, %rbp
movq %rax, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0xf220
movq (%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xe130
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0xf580
movq %rbp, %rdi
callq 0xe920
xorl %ebp, %ebp
jmp 0x25d3e
pushq $0x6e
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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 + 16 - st->reserved, count);
st->reserved -= count;
return;
}
memXor2(st->block + 16 - st->reserved, buf, st->reserved);
memCopy(buf, st->block + 16 - st->reserved, st->reserved);
count -= st->reserved;
buf = (octet*)buf + st->reserved;
st->reserved = 0;
}
// цикл по полным блокам
while (count >= 16)
{
beltBlockEncr(st->block, st->key);
beltBlockXor2(st->block, buf);
beltBlockCopy(buf, st->block);
buf = (octet*)buf + 16;
count -= 16;
}
// неполный блок?
if (count)
{
beltBlockEncr(st->block, st->key);
memXor2(st->block, buf, count);
memCopy(buf, st->block, count);
st->reserved = 16 - count;
}
} | 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 %r14, %rdi
callq 0xe970
movq (%r13), %rax
subq %rax, %rbx
addq %rax, %r14
andq $0x0, (%r13)
leaq 0x20(%r15), %r12
cmpq $0x10, %rbx
jb 0x25e13
movq %r12, %rdi
movq %r15, %rsi
callq 0xe140
movq 0x20(%r15), %rax
xorq (%r14), %rax
movq %rax, 0x20(%r15)
movq 0x8(%r14), %rcx
xorq %rcx, 0x28(%r15)
movq %rax, (%r14)
movq 0x28(%r15), %rax
movq %rax, 0x8(%r14)
addq $0x10, %r14
addq $-0x10, %rbx
jmp 0x25dda
testq %rbx, %rbx
je 0x25e69
movq %r12, %rdi
movq %r15, %rsi
callq 0xe140
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf0b0
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xe970
pushq $0x10
popq %rax
jmp 0x25e62
movq %rbx, %rdx
callq 0xf0b0
movq %r13, %rsi
subq (%r13), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xe970
movq (%r13), %rax
subq %rbx, %rax
movq %rax, (%r13)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /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 ERR_BAD_INPUT;
// создать состояние
state = blobCreate(beltCFB_keep());
if (state == 0)
return ERR_OUTOFMEMORY;
// зашифровать
beltCFBStart(state, key, len, iv);
memMove(dest, src, count);
beltCFBStepE(dest, count, state);
// завершить
blobClose(state);
return ERR_OK;
} | 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 %rdx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x26033
movq %r14, %rdi
movq %r13, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x26033
pushq $0x10
popq %rsi
movq %r12, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x26033
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x26033
pushq $0x38
popq %rdi
callq 0xf190
testq %rax, %rax
je 0x26030
movq %rax, %rbp
movq %rax, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0xe820
movq (%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xe130
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0xfa90
movq %rbp, %rdi
callq 0xe920
xorl %ebp, %ebp
jmp 0x26033
pushq $0x6e
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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) + buf1
beltBlockEncr2(buf, X);
beltBlockXor2(buf, buf + 4);
// buf2 <- h0
beltBlockCopy(buf + 8, h);
// buf1 <- h1 [buf01 == K1]
beltBlockCopy(buf + 4, h + 4);
// h0 <- beltBlock(X0, buf01) + X0
beltBlockCopy(h, X);
beltBlockEncr2(h, buf);
beltBlockXor2(h, X);
// buf1 <- ~buf0 [buf12 == K2]
beltBlockNeg(buf + 4, buf);
// h1 <- beltBlock(X1, buf12) + X1
beltBlockCopy(h + 4, X + 4);
beltBlockEncr2(h + 4, buf + 4);
beltBlockXor2(h + 4, X + 4);
} | 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 %rdx, %rdi
callq 0x100d0
movdqu (%r12), %xmm0
movdqu 0x10(%r12), %xmm1
pxor %xmm0, %xmm1
movdqu %xmm1, (%r12)
movq (%rbx), %rax
movq %rax, 0x20(%r12)
movq 0x8(%rbx), %rax
movq %rax, 0x28(%r12)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r12)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%r12)
movq (%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x100d0
movq (%r14), %rax
xorq %rax, (%rbx)
movq 0x8(%r14), %rax
xorq %rax, 0x8(%rbx)
movdqu (%r12), %xmm0
pcmpeqd %xmm1, %xmm1
pxor %xmm0, %xmm1
movdqu %xmm1, 0x10(%r12)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movq 0x18(%r14), %rax
movq %rax, 0x18(%rbx)
movq %r15, %rdi
movq %r13, %rsi
callq 0x100d0
movq 0x10(%r14), %rax
xorq %rax, 0x10(%rbx)
movq 0x18(%r14), %rax
xorq %rax, 0x18(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /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;
return;
}
memXor2(buf, st->block + 16 - st->reserved, st->reserved);
count -= st->reserved;
buf = (octet*)buf + st->reserved;
st->reserved = 0;
}
// цикл по полным блокам
while (count >= 16)
{
beltBlockIncU32(st->ctr);
beltBlockCopy(st->block, st->ctr);
beltBlockEncr2((u32*)st->block, st->key);
#if (OCTET_ORDER == BIG_ENDIAN)
beltBlockRevU32(st->block);
#endif
beltBlockXor2(buf, st->block);
buf = (octet*)buf + 16;
count -= 16;
}
// неполный блок?
if (count)
{
beltBlockIncU32(st->ctr);
beltBlockCopy(st->block, st->ctr);
beltBlockEncr2((u32*)st->block, st->key);
#if (OCTET_ORDER == BIG_ENDIAN)
beltBlockRevU32(st->block);
#endif
memXor2(buf, st->block, count);
st->reserved = 16 - 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 $0x0, (%r13)
leaq 0x30(%r15), %r12
cmpq $0x10, %rbx
jb 0x263f3
incl 0x20(%r15)
jne 0x263c5
incl 0x24(%r15)
jne 0x263c5
incl 0x28(%r15)
jne 0x263c5
incl 0x2c(%r15)
movups 0x20(%r15), %xmm0
movups %xmm0, 0x30(%r15)
movq %r12, %rdi
movq %r15, %rsi
callq 0x100d0
movq 0x30(%r15), %rax
xorq %rax, (%r14)
movq 0x38(%r15), %rax
xorq %rax, 0x8(%r14)
addq $0x10, %r14
addq $-0x10, %rbx
jmp 0x263a9
testq %rbx, %rbx
je 0x2644c
incl 0x20(%r15)
jne 0x2640e
incl 0x24(%r15)
jne 0x2640e
incl 0x28(%r15)
jne 0x2640e
incl 0x2c(%r15)
movups 0x20(%r15), %xmm0
movups %xmm0, 0x30(%r15)
movq %r12, %rdi
movq %r15, %rsi
callq 0x100d0
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xf0b0
pushq $0x10
popq %rax
jmp 0x26445
movq %r14, %rdi
movq %rbx, %rdx
callq 0xf0b0
movq (%r13), %rax
subq %rbx, %rax
movq %rax, (%r13)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /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_BAD_INPUT;
// создать состояние
state = blobCreate(beltCTR_keep());
if (state == 0)
return ERR_OUTOFMEMORY;
// зашифровать
beltCTRStart(state, key, len, iv);
memMove(dest, src, count);
beltCTRStepE(dest, count, state);
// завершить
blobClose(state);
return ERR_OK;
} | 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 %rdx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x26522
movq %r14, %rdi
movq %r13, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x26522
pushq $0x10
popq %rsi
movq %r12, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x26522
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x26522
pushq $0x48
popq %rdi
callq 0xf190
testq %rax, %rax
je 0x2651f
movq %rax, %rbp
movq %rax, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0xeaa0
movq (%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xe130
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0xe4e0
movq %rbp, %rdi
callq 0xe920
xorl %ebp, %ebp
jmp 0x26522
pushq $0x6e
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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);
beltPolyMul(st->t1, st->t1, st->r, st->stack);
}
else
memCopy(st->t1, st->t, 16);
// обработать блок длины
beltBlockXor2(st->t1, st->len);
beltPolyMul(st->t1, st->t1, st->r, st->stack);
#if (OCTET_ORDER == BIG_ENDIAN)
beltBlockRevW(st->t1);
#endif
beltBlockEncr((octet*)st->t1, st->ctr->key);
} | 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
movq %r15, %rdx
callq 0xf540
movups 0x58(%rbx), %xmm0
movups 0x68(%rbx), %xmm1
xorps %xmm0, %xmm1
movups %xmm1, 0x68(%rbx)
leaq 0x48(%rbx), %rdx
leaq 0xa0(%rbx), %rcx
movq %r12, %rdi
movq %r12, %rsi
callq 0xf970
jmp 0x26935
leaq 0x68(%rbx), %rdi
leaq 0x58(%rbx), %rsi
pushq $0x10
popq %rdx
callq 0xe970
leaq 0x68(%rbx), %r14
movups 0x68(%rbx), %xmm0
movups 0x78(%rbx), %xmm1
xorps %xmm0, %xmm1
movups %xmm1, 0x68(%rbx)
leaq 0x48(%rbx), %rdx
leaq 0xa0(%rbx), %rcx
movq %r14, %rdi
movq %r14, %rsi
callq 0xf970
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe140
| /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) ||
!memIsValid(mac, 8) ||
!memIsValid(key, len) ||
!memIsValid(iv, 16) ||
!memIsValid(dest, count1))
return ERR_BAD_INPUT;
// создать состояние
state = blobCreate(beltDWP_keep());
if (state == 0)
return ERR_OUTOFMEMORY;
// снять защиту
beltDWPStart(state, key, len, iv);
beltDWPStepI(src2, count2, state);
beltDWPStepA(src1, count1, state);
if (!beltDWPStepV(mac, state))
{
blobClose(state);
return ERR_BAD_MAC;
}
memMove(dest, src1, count1);
beltDWPStepD(dest, count1, state);
// завершить
blobClose(state);
return ERR_OK;
} | 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
movq %rdi, 0x8(%rsp)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x26c4c
movq %r14, %rdi
movq %r13, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x26c4c
pushq $0x8
popq %rsi
movq 0x10(%rsp), %rdi
callq 0xeeb0
testl %eax, %eax
je 0x26c4c
movq 0x50(%rsp), %rdi
movq %r12, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x26c4c
movq 0x60(%rsp), %rdi
pushq $0x10
popq %rsi
callq 0xeeb0
testl %eax, %eax
je 0x26c4c
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x26c4c
callq 0xfd20
movq %rax, %rdi
callq 0xf190
testq %rax, %rax
je 0x26c3a
movq %rax, %rbp
movq %rax, %rdi
movq 0x50(%rsp), %rsi
movq %r12, %rdx
movq 0x60(%rsp), %rcx
callq 0xfac0
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0xee80
movq %r15, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0xedc0
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0xe540
testl %eax, %eax
je 0x26c3f
movq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xe130
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0xe4e0
movq %rbp, %rdi
xorl %ebp, %ebp
jmp 0x26c47
pushq $0x6e
popq %rbp
jmp 0x26c4c
movq %rbp, %rdi
movl $0x1ff, %ebp # imm = 0x1FF
callq 0xe920
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
| /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->s, st->r, 16);
#if (OCTET_ORDER == BIG_ENDIAN)
beltBlockRevW(st->r);
#endif
// подготовить t
wwFrom(st->t, beltH(), 16);
// обнулить счетчики
memSetZero(st->len, sizeof(st->len));
st->reserved = 0;
st->filled = 0;
} | 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
leaq 0x40(%rbx), %r15
xorl %eax, %eax
callq 0xf920
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xf540
leaq 0x60(%rbx), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0xf710
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rbx)
popq %rbx
popq %r14
popq %r15
retq
| /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->len, count);
// есть накопленные данные?
if (st->filled)
{
if (count < 16 - st->filled)
{
memCopy(st->block + st->filled, buf, count);
st->filled += count;
return;
}
memCopy(st->block + st->filled, buf, 16 - st->filled);
count -= 16 - st->filled;
buf = (const octet*)buf + 16 - st->filled;
#if (OCTET_ORDER == BIG_ENDIAN)
beltBlockRevW(st->block);
#endif
beltBlockXor2(st->t, st->block);
beltPolyMul(st->t, st->t, st->r, st->stack);
st->filled = 0;
}
// цикл по полным блокам
while (count >= 16)
{
beltBlockCopy(st->block, buf);
#if (OCTET_ORDER == BIG_ENDIAN)
beltBlockRevW(st->block);
#endif
beltBlockXor2(st->t, st->block);
beltPolyMul(st->t, st->t, st->r, st->stack);
buf = (const octet*)buf + 16;
count -= 16;
}
// неполный блок?
if (count)
memCopy(st->block, buf, st->filled = count);
} | 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 %r15, %rsi
movq %rbx, %rdx
callq 0xe970
addq %rbx, 0x90(%r14)
jmp 0x26f04
movq %r15, %rsi
callq 0xe970
movq 0x90(%r14), %rax
addq %rax, %rbx
addq $-0x10, %rbx
subq %rax, %r15
addq $0x10, %r15
leaq 0x40(%r14), %rdi
movups 0x40(%r14), %xmm0
movups 0x70(%r14), %xmm1
xorps %xmm0, %xmm1
movups %xmm1, 0x40(%r14)
leaq 0x30(%r14), %rdx
leaq 0xa0(%r14), %rcx
movq %rdi, %rsi
callq 0xf970
andq $0x0, 0x90(%r14)
leaq 0x70(%r14), %rax
movq %rax, (%rsp)
leaq 0x40(%r14), %r13
leaq 0x30(%r14), %rbp
leaq 0xa0(%r14), %r12
cmpq $0x10, %rbx
jb 0x26edb
movq (%r15), %rax
movq %rax, 0x70(%r14)
movq 0x8(%r15), %rcx
movq %rcx, 0x78(%r14)
xorq %rax, 0x40(%r14)
xorq %rcx, 0x48(%r14)
movq %r13, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r12, %rcx
callq 0xf970
addq $0x10, %r15
addq $-0x10, %rbx
jmp 0x26ea3
testq %rbx, %rbx
je 0x26f04
movq %rbx, 0x90(%r14)
movq (%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe970
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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->filled)
{
memSetZero(st->block + st->filled, 16 - st->filled);
#if (OCTET_ORDER == BIG_ENDIAN)
beltBlockRevW(st->block);
#endif
beltBlockXor2(st->t, st->block);
beltPolyMul(st->t, st->t, st->r, st->stack);
st->filled = 0;
}
// обновить длину
beltHalfBlockAddBitSizeW(st->len + W_OF_B(64), count);
// есть накопленные данные?
if (st->filled)
{
if (count < 16 - st->filled)
{
memCopy(st->block + st->filled, buf, count);
st->filled += count;
return;
}
memCopy(st->block + st->filled, buf, 16 - st->filled);
count -= 16 - st->filled;
buf = (const octet*)buf + 16 - st->filled;
#if (OCTET_ORDER == BIG_ENDIAN)
beltBlockRevW(st->block);
#endif
beltBlockXor2(st->t, st->block);
beltPolyMul(st->t, st->t, st->r, st->stack);
st->filled = 0;
}
// цикл по полным блокам
while (count >= 16)
{
beltBlockCopy(st->block, buf);
#if (OCTET_ORDER == BIG_ENDIAN)
beltBlockRevW(st->block);
#endif
beltBlockXor2(st->t, st->block);
beltPolyMul(st->t, st->t, st->r, st->stack);
buf = (const octet*)buf + 16;
count -= 16;
}
// неполный блок?
if (count)
memCopy(st->block, buf, st->filled = count);
} | 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 %rax, %rdx
xorl %esi, %esi
callq 0xf710
leaq 0x40(%r14), %rdi
movups 0x40(%r14), %xmm0
movups 0x70(%r14), %xmm1
xorps %xmm0, %xmm1
movups %xmm1, 0x40(%r14)
leaq 0x30(%r14), %rdx
leaq 0xa0(%r14), %rcx
movq %rdi, %rsi
callq 0xf970
andq $0x0, 0x90(%r14)
leaq 0x68(%r14), %rdi
movq %rbx, %rsi
callq 0xf6b0
movq 0x90(%r14), %rax
testq %rax, %rax
je 0x27019
subq %rax, %r12
leaq (%r14,%rax), %rdi
addq $0x70, %rdi
cmpq %rbx, %r12
jbe 0x26fc8
movq %r15, %rsi
movq %rbx, %rdx
callq 0xe970
addq %rbx, 0x90(%r14)
jmp 0x27091
movq %r15, %rsi
movq %r12, %rdx
callq 0xe970
movq 0x90(%r14), %rax
addq %rax, %rbx
addq $-0x10, %rbx
subq %rax, %r15
addq $0x10, %r15
leaq 0x40(%r14), %rdi
movups 0x40(%r14), %xmm0
movups 0x70(%r14), %xmm1
xorps %xmm0, %xmm1
movups %xmm1, 0x40(%r14)
leaq 0x30(%r14), %rdx
leaq 0xa0(%r14), %rcx
movq %rdi, %rsi
callq 0xf970
andq $0x0, 0x90(%r14)
leaq 0x70(%r14), %rax
movq %rax, (%rsp)
leaq 0x40(%r14), %r13
leaq 0x30(%r14), %rbp
leaq 0xa0(%r14), %r12
cmpq $0x10, %rbx
jb 0x27068
movq (%r15), %rax
movq %rax, 0x70(%r14)
movq 0x8(%r15), %rcx
movq %rcx, 0x78(%r14)
xorq %rax, 0x40(%r14)
xorq %rcx, 0x48(%r14)
movq %r13, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r12, %rcx
callq 0xf970
addq $0x10, %r15
addq $-0x10, %rbx
jmp 0x27030
testq %rbx, %rbx
je 0x27091
movq %rbx, 0x90(%r14)
movq (%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe970
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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);
beltPolyMul(st->t1, st->t1, st->r, st->stack);
}
else
memCopy(st->t1, st->t, 16);
// обработать блок длины
beltBlockXor2(st->t1, st->len);
beltPolyMul(st->t1, st->t1, st->r, st->stack);
#if (OCTET_ORDER == BIG_ENDIAN)
beltBlockRevW(st->t1);
#endif
beltBlockEncr((octet*)st->t1, st->key);
} | 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
movq %r15, %rdx
callq 0xf540
movups 0x40(%rbx), %xmm0
movups 0x50(%rbx), %xmm1
xorps %xmm0, %xmm1
movups %xmm1, 0x50(%rbx)
leaq 0x30(%rbx), %rdx
leaq 0xa0(%rbx), %rcx
movq %r12, %rdi
movq %r12, %rsi
callq 0xf970
jmp 0x2714d
leaq 0x50(%rbx), %rdi
leaq 0x40(%rbx), %rsi
pushq $0x10
popq %rdx
callq 0xe970
leaq 0x50(%rbx), %r14
movups 0x50(%rbx), %xmm0
movups 0x60(%rbx), %xmm1
xorps %xmm0, %xmm1
movups %xmm1, 0x50(%rbx)
leaq 0x30(%rbx), %rdx
leaq 0xa0(%rbx), %rcx
movq %r14, %rdi
movq %r14, %rsi
callq 0xf970
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe140
| /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) ||
!memIsValid(key, len) ||
!memIsValid(iv, 16) ||
!memIsValid(dest, count1) ||
!memIsValid(mac, 8))
return ERR_BAD_INPUT;
// создать состояние
state = blobCreate(beltCHE_keep());
if (state == 0)
return ERR_OUTOFMEMORY;
// установить защиту (I перед E из-за разрешенного пересечения src2 и dest)
beltCHEStart(state, key, len, iv);
beltCHEStepI(src2, count2, state);
memMove(dest, src1, count1);
beltCHEStepE(dest, count1, state);
beltCHEStepA(dest, count1, state);
beltCHEStepG(mac, state);
// завершить
blobClose(state);
return ERR_OK;
} | 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)
movq %rsi, 0x8(%rsp)
movq %rdx, %rdi
movq %rcx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x272fe
movq %rbx, %rdi
movq %r13, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x272fe
movq 0x50(%rsp), %rdi
movq %r15, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x272fe
movq 0x60(%rsp), %rdi
pushq $0x10
popq %rsi
callq 0xeeb0
testl %eax, %eax
je 0x272fe
movq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x272fe
pushq $0x8
popq %rsi
movq 0x8(%rsp), %rdi
callq 0xeeb0
testl %eax, %eax
je 0x272fe
callq 0xe670
movq %rax, %rdi
callq 0xf190
testq %rax, %rax
je 0x272fb
movq %rax, %rbp
movq %rax, %rdi
movq 0x50(%rsp), %rsi
movq %r15, %rdx
movq 0x60(%rsp), %rcx
callq 0xf4b0
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x100e0
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xe130
movq %rbx, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0xe2e0
movq %rbx, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0xe260
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0xe340
movq %rbp, %rdi
callq 0xe920
xorl %ebp, %ebp
jmp 0x272fe
pushq $0x6e
popq %rbp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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) ||
!memIsValid(mac, 8) ||
!memIsValid(key, len) ||
!memIsValid(iv, 16) ||
!memIsValid(dest, count1))
return ERR_BAD_INPUT;
// создать состояние
state = blobCreate(beltDWP_keep());
if (state == 0)
return ERR_OUTOFMEMORY;
// снять защиту
beltCHEStart(state, key, len, iv);
beltCHEStepI(src2, count2, state);
beltCHEStepA(src1, count1, state);
if (!beltCHEStepV(mac, state))
{
blobClose(state);
return ERR_BAD_MAC;
}
memMove(dest, src1, count1);
beltCHEStepD(dest, count1, state);
// завершить
blobClose(state);
return ERR_OK;
} | 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
movq %rdi, 0x8(%rsp)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x27466
movq %r14, %rdi
movq %r13, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x27466
pushq $0x8
popq %rsi
movq 0x10(%rsp), %rdi
callq 0xeeb0
testl %eax, %eax
je 0x27466
movq 0x50(%rsp), %rdi
movq %r12, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x27466
movq 0x60(%rsp), %rdi
pushq $0x10
popq %rsi
callq 0xeeb0
testl %eax, %eax
je 0x27466
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x27466
xorl %eax, %eax
callq 0xfd20
movq %rax, %rdi
callq 0xf190
testq %rax, %rax
je 0x27454
movq %rax, %rbp
movq %rax, %rdi
movq 0x50(%rsp), %rsi
movq %r12, %rdx
movq 0x60(%rsp), %rcx
callq 0xf4b0
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x100e0
movq %r15, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0xe260
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0xf5c0
testl %eax, %eax
je 0x27459
movq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xe130
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0xe2e0
movq %rbp, %rdi
xorl %ebp, %ebp
jmp 0x27461
pushq $0x6e
popq %rbp
jmp 0x27466
movq %rbp, %rdi
movl $0x1ff, %ebp # imm = 0x1FF
callq 0xe920
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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;
}
// неполный блок? кража блока
if (count)
{
memSwap((octet*)buf - 16, buf, count);
beltBlockDecr((octet*)buf - 16, st->key);
}
} | 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, %rdx
callq 0xfec0
movq %r12, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe3d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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;
// создать состояние
state = blobCreate(beltECB_keep());
if (state == 0)
return ERR_OUTOFMEMORY;
// зашифровать
beltECBStart(state, key, len);
memMove(dest, src, count);
beltECBStepE(dest, count, state);
// завершить
blobClose(state);
return ERR_OK;
} | 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 %rsi, %rdi
movq %rdx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x27606
movq %r13, %rdi
movq %r12, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x27606
movq %r14, %rdi
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x27606
pushq $0x20
popq %rdi
callq 0xf190
testq %rax, %rax
je 0x27603
movq %rax, %rbp
movq %rax, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xed10
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xe130
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0xe3c0
movq %rbp, %rdi
callq 0xe920
xorl %ebp, %ebp
jmp 0x27606
pushq $0x6e
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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;
// создать состояние
state = blobCreate(beltECB_keep());
if (state == 0)
return ERR_OUTOFMEMORY;
// расшифровать
beltECBStart(state, key, len);
memMove(dest, src, count);
beltECBStepD(dest, count, state);
// завершить
blobClose(state);
return ERR_OK;
} | 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 %rsi, %rdi
movq %rdx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x276d2
movq %r13, %rdi
movq %r12, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x276d2
movq %r14, %rdi
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x276d2
pushq $0x20
popq %rdi
callq 0xf190
testq %rax, %rax
je 0x276cf
movq %rax, %rbp
movq %rax, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xed10
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xe130
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0xf5a0
movq %rbp, %rdi
callq 0xe920
xorl %ebp, %ebp
jmp 0x276d2
pushq $0x6e
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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);
beltBlockEncr(buf, st->key);
beltBlockXor2(buf, st->block);
buf = (octet*)buf + 16;
count -= 16;
}
} | 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(%rbx), %rax
xorq %rax, (%r15)
movq 0x38(%rbx), %rax
xorq %rax, 0x8(%r15)
movq %r15, %rdi
movq %rbx, %rsi
callq 0xe140
movq 0x30(%rbx), %rax
xorq %rax, (%r15)
movq 0x38(%rbx), %rax
xorq %rax, 0x8(%r15)
addq $0x10, %r15
addq $-0x10, %r14
jmp 0x27739
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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) ||
!memIsValid(dest, count))
return ERR_BAD_INPUT;
// создать состояние
state = blobCreate(beltBDE_keep());
if (state == 0)
return ERR_OUTOFMEMORY;
// зашифровать
beltBDEStart(state, key, len, iv);
memMove(dest, src, count);
beltBDEStepE(dest, count, state);
// завершить
blobClose(state);
return ERR_OK;
} | 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 0x278f5
movq %r9, %r12
movq %rsi, %r15
movq %rdi, (%rsp)
movq %rsi, %rdi
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x278f5
movq %r14, %rdi
movq %r13, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x278f5
pushq $0x10
popq %rsi
movq %r12, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x278f5
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x278f5
pushq $0x40
popq %rdi
callq 0xf190
testq %rax, %rax
je 0x278f2
movq %rax, %rbp
movq %rax, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0xecc0
movq (%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xe130
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0xffa0
movq %rbp, %rdi
callq 0xe920
xorl %ebp, %ebp
jmp 0x278f5
pushq $0x6e
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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) ||
!memIsValid(dest, count))
return ERR_BAD_INPUT;
// создать состояние
state = blobCreate(beltBDE_keep());
if (state == 0)
return ERR_OUTOFMEMORY;
// расшифровать
beltBDEStart(state, key, len, iv);
memMove(dest, src, count);
beltBDEStepD(dest, count, state);
// завершить
blobClose(state);
return ERR_OK;
} | 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 0x279e7
movq %r9, %r12
movq %rsi, %r15
movq %rdi, (%rsp)
movq %rsi, %rdi
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x279e7
movq %r14, %rdi
movq %r13, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x279e7
pushq $0x10
popq %rsi
movq %r12, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x279e7
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x279e7
pushq $0x40
popq %rdi
callq 0xf190
testq %rax, %rax
je 0x279e4
movq %rax, %rbp
movq %rax, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0xecc0
movq (%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xe130
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0xeec0
movq %rbp, %rdi
callq 0xe920
xorl %ebp, %ebp
jmp 0x279e7
pushq $0x6e
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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->s, st->wbl->key);
// каскад XEX
beltBlockXor2(buf, st->s);
beltWBLStepE(buf, count, st->wbl);
beltBlockXor2(buf, st->s);
} | 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 %rax, 0x8(%r15)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf910
movq 0x48(%rbx), %rax
xorq %rax, (%r15)
movq 0x50(%rbx), %rax
xorq %rax, 0x8(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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->s, st->wbl->key);
// каскад XEX
beltBlockXor2(buf, st->s);
beltWBLStepD(buf, count, st->wbl);
beltBlockXor2(buf, st->s);
} | 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 %rax, 0x8(%r15)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xe600
movq 0x48(%rbx), %rax
xorq %rax, (%r15)
movq 0x50(%rbx), %rax
xorq %rax, 0x8(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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) ||
!memIsValid(dest, count))
return ERR_BAD_INPUT;
// создать состояние
state = blobCreate(beltSDE_keep());
if (state == 0)
return ERR_OUTOFMEMORY;
// зашифровать
beltSDEStart(state, key, len);
memMove(dest, src, count);
beltSDEStepE(dest, count, iv, state);
// завершить
blobClose(state);
return ERR_OK;
} | 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
jae 0x27bb2
movq %rsi, %r12
movq %rdi, %r15
movq %r9, (%rsp)
movq %rsi, %rdi
movq %r14, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x27bb2
movq %rbx, %rdi
movq %r13, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x27bb2
pushq $0x10
popq %rsi
movq (%rsp), %rdi
callq 0xeeb0
testl %eax, %eax
je 0x27bb2
movq %r15, %rdi
movq %r14, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x27bb2
pushq $0x58
popq %rdi
callq 0xf190
testq %rax, %rax
je 0x27baf
movq %rax, %rbp
movq %rax, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0xf570
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xe130
movq %r15, %rdi
movq %r14, %rsi
movq (%rsp), %rdx
movq %rbp, %rcx
callq 0xece0
movq %rbp, %rdi
callq 0xe920
xorl %ebp, %ebp
jmp 0x27bb2
pushq $0x6e
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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) ||
!memIsValid(dest, count))
return ERR_BAD_INPUT;
// создать состояние
state = blobCreate(beltSDE_keep());
if (state == 0)
return ERR_OUTOFMEMORY;
// расшифровать
beltSDEStart(state, key, len);
memMove(dest, src, count);
beltSDEStepD(dest, count, iv, state);
// завершить
blobClose(state);
return ERR_OK;
} | 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
jae 0x27ca2
movq %rsi, %r12
movq %rdi, %r15
movq %r9, (%rsp)
movq %rsi, %rdi
movq %r14, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x27ca2
movq %rbx, %rdi
movq %r13, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x27ca2
pushq $0x10
popq %rsi
movq (%rsp), %rdi
callq 0xeeb0
testl %eax, %eax
je 0x27ca2
movq %r15, %rdi
movq %r14, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x27ca2
pushq $0x58
popq %rdi
callq 0xf190
testq %rax, %rax
je 0x27c9f
movq %rax, %rbp
movq %rax, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0xf570
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xe130
movq %r15, %rdi
movq %r14, %rsi
movq (%rsp), %rdx
movq %rbp, %rcx
callq 0xfe00
movq %rbp, %rdi
callq 0xe920
xorl %ebp, %ebp
jmp 0x27ca2
pushq $0x6e
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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);
ASSERT(1 <= count && count <= 300);
// обработать особые сочетания (mod, count)
if (mod == 49667 && count == 320)
return 39;
// обработать mod, который не умещается в 16 битов
if (mod == 65536)
return (16 * count + 63) / 64;
// k <- ceil(log2(mod))
k = B_PER_W - wordCLZ((word)mod);
ASSERT(k > 0);
if ((U32_1 << k) - mod > mod - (U32_1 << (k - 1)))
--k;
// t0 <- 8^k
wwSetZero(t0, m);
wwSetBit(t0, 3 * k, 1);
// t1 <- 4^k mod
wwSetZero(t1, m);
wwSetBit(t1, 2 * k, 1);
zzMulW(t1, t1, m, mod);
// t2 <- 2^k mod^2
wwSetZero(t2, m);
wwSetBit(t2, k, 1);
zzMulW(t2, t2, m, mod);
zzMulW(t2, t2, m, mod);
// t3 <- mod^3
wwSetW(t3, m, mod);
zzMulW(t3, t3, m, mod);
zzMulW(t3, t3, m, mod);
// den <- t0 + 9 * t1 + 9 * t2 + t3
wwCopy(den, t0, m);
zzAdd2(den, t3, m);
wwCopy(t4, t1, m);
zzAdd2(t4, t2, m);
zzMulW(t4, t4, m, 9);
zzAdd2(den, t4, m);
// num <- den * 4767 k
wwCopy(num, den, m);
zzMulW(num, num, m, 4764);
zzMulW(num, num, m, (word)k);
// num <- count * (num - 25201 t0 - 61857 t1 + 61857 t2 + 25201 t3)
zzMulW(t3, t3, m, 25201);
zzAdd2(num, t3, m);
zzMulW(t2, t2, m, 61857u);
zzAdd2(num, t2, m);
zzMulW(t1, t1, m, 61857u);
zzSub2(num, t1, m);
zzMulW(t0, t0, m, 25201);
zzSub2(num, t0, m);
zzMulW(num, num, m, (word)count);
// den <- 304896 * den
zzMulW(den, den, m, 768);
zzMulW(den, den, m, 397);
// num <- num + den - 1
zzAdd2(num, den, m);
zzSubW2(num, m, 1);
// num <- num / den
for (k = m; den[k - 1] == 0; --k);
ASSERT(zzDiv_deep(m, k) <= sizeof(stack));
zzDiv(den, num, num, m, den, k, stack);
// возврат
return (size_t)den[0];
} | 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 = 0x10000
jne 0x27d18
shlq $0x4, %rbx
addq $0x3f, %rbx
shrq $0x6, %rbx
jmp 0x27fd1
movl %ebp, %r14d
movq %r14, %rdi
callq 0xe6b0
pushq $0x40
popq %rsi
subq %rax, %rsi
movl %eax, %edx
pushq $0x3f
popq %r12
subq %rax, %r12
movq %rax, %rcx
negq %rcx
pushq $0x1
popq %r13
movl %r13d, %eax
shll %cl, %eax
subl %ebp, %eax
notb %dl
pushq $-0x1
popq %rdi
movl %edx, %ecx
shll %cl, %edi
addl %ebp, %edi
cmpl %edi, %eax
cmovbeq %rsi, %r12
leaq 0x20(%rsp), %rbp
pushq $0x2
popq %r15
movq %rbp, %rdi
movq %r15, %rsi
callq 0xfe90
leaq (%r12,%r12,2), %rsi
movq %rbp, %rdi
movl %r13d, %edx
callq 0xf590
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0xfe90
leaq (%r12,%r12), %rsi
movq %rbp, %rdi
movl %r13d, %edx
callq 0xf590
movq %rbp, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0xef90
leaq 0x40(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0xfe90
movq %rbp, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0xf590
movq %rbp, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0xef90
movq %rbp, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0xef90
leaq 0x50(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xfee0
movq %r13, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0xef90
movq %r13, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0xef90
leaq 0x10(%rsp), %r14
movq %r14, %rdi
leaq 0x20(%rsp), %rsi
movq %r15, %rdx
callq 0xe5c0
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xe1a0
leaq 0x60(%rsp), %rbp
movq %rbp, %rdi
leaq 0x30(%rsp), %rsi
movq %r15, %rdx
callq 0xe5c0
movq %rbp, %rdi
leaq 0x40(%rsp), %rsi
movq %r15, %rdx
callq 0xe1a0
pushq $0x9
popq %rcx
movq %rbp, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0xef90
movq %r14, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0xe1a0
leaq 0x70(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe5c0
movl $0x129c, %ecx # imm = 0x129C
movq %rbp, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0xef90
movq %rbp, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %r12, %rcx
leaq 0x20(%rsp), %r12
callq 0xef90
movl $0x6271, %ecx # imm = 0x6271
movq %r13, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xef90
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xe1a0
movl $0xf1a1, %ecx # imm = 0xF1A1
leaq 0x40(%rsp), %rdi
movq %rdi, %rsi
movq %rdi, %r13
movq %r15, %rdx
callq 0xef90
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xe1a0
movl $0xf1a1, %ecx # imm = 0xF1A1
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movq %rdi, %r13
movq %r15, %rdx
callq 0xef90
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xee10
movl $0x6271, %ecx # imm = 0x6271
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xef90
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xee10
movq %rbp, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0xef90
movl $0x300, %ecx # imm = 0x300
movq %r14, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xef90
movl $0x18d, %ecx # imm = 0x18D
movq %r14, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xef90
movq %rbp, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe1a0
pushq $0x1
popq %rdx
movq %rbp, %rdi
movq %r15, %rsi
callq 0xfb20
pushq $0x3
popq %r9
cmpq $0x0, (%rsp,%r9,8)
leaq -0x1(%r9), %r9
je 0x27fa4
movq %r12, (%rsp)
leaq 0x70(%rsp), %rdx
pushq $0x2
popq %rcx
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rdx, %rsi
movq %rbx, %r8
callq 0xf7a0
movq (%rbx), %rbx
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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);
st->mod = mod;
st->n1 = (count + 1) / 2;
st->n2 = count / 2;
st->b1 = beltFMTCalcB(mod, st->n1);
st->b2 = beltFMTCalcB(mod, st->n2);
#if (OCTET_ORDER == LITTLE_ENDIAN)
((u16*)st->iv)[0] = (u16)mod;
((u16*)st->iv)[1] = (u16)count;
#else
((u16*)st->iv)[0] = u16Rev((u16)mod);
((u16*)st->iv)[1] = u16Rev((u16)count);
#endif
memCopy(st->iv + 20, st->iv, 4);
} | 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), %rsi
movl %ebp, %edi
callq 0x27cca
movq %rax, 0x68(%rbx)
leaq 0x70(%rbx), %rsi
movw %bp, 0x70(%rbx)
movw %r14w, 0x72(%rbx)
addq $0x84, %rbx
pushq $0x4
popq %rdx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xe970
| /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];
// round #3
beltBlockEncr3(t + 0, t + 1, t + 2, t + 3, key);
t[0] ^= 3, t[4] ^= t[0], t[5] ^= t[1];
// возврат
u32To(block, 24, t);
} | 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 %r15, %r8
callq 0xef20
movl 0x8(%rbx), %eax
movl 0xc(%rbx), %ecx
xorl $0x1, %eax
movl %eax, 0x8(%rbx)
xorl %eax, (%rbx)
leaq 0x4(%rbx), %r12
xorl %ecx, 0x4(%rbx)
movq %rbp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0xef20
movl 0x10(%rbx), %eax
movl 0x14(%rbx), %ecx
xorl $0x2, %eax
movl %eax, 0x10(%rbx)
xorl %eax, 0x8(%rbx)
xorl %ecx, 0xc(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
movq (%rsp), %rdx
movq %r13, %rcx
movq %r15, %r8
callq 0xef20
movl (%rbx), %eax
movl 0x4(%rbx), %ecx
xorl $0x3, %eax
movl %eax, (%rbx)
xorl %eax, 0x10(%rbx)
xorl %ecx, 0x14(%rbx)
movq %rbx, %rdi
pushq $0x18
popq %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf6c0
| /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;
}
// настроить память
m = W_OF_O(8 * b);
a = (word*)bin;
wwFrom(a, bin, 8 * b);
// конвертировать и сложить
ASSERT(2 <= mod && mod < 65536);
while (count--)
{
t = (u32)zzModW(a, m, mod);
t += str[0], t %= mod;
str[0] = (u16)t, ++str;
zzDivW(a, a, m, mod);
}
t = 0;
} | 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,%r14,2)
jmp 0x283c0
movq %r8, %r12
movl %edi, %ebp
movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFFF
andq %rax, %r12
movq %rbx, %rdi
movq %rbx, %rsi
callq 0xf540
movl %ebp, 0x4(%rsp)
movl %ebp, %r13d
xorl %ebp, %ebp
cmpq %rbp, %r14
je 0x28433
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xfc10
movzwl (%r15,%rbp,2), %ecx
addl %ecx, %eax
xorl %edx, %edx
divl 0x4(%rsp)
movw %dx, (%r15,%rbp,2)
movq %rbx, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0xf9d0
incq %rbp
jmp 0x283f8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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));
// подготовить синхропосылку
if (iv)
memCopy(st->iv + 4, iv, 16);
else
memSetZero(st->iv + 4, 16);
// такты
for (i = 3; i--;)
{
// вторая половинка
beltStr2Bin(st->buf, st->b1, st->mod, buf, st->n1);
memCopy(st->buf + st->b1 * 8, beltH() + 8 * i + 4, 4);
memCopy(st->buf + st->b1 * 8 + 4, st->iv + 8 * i + 4, 4);
if (st->b1 == 1)
beltBlockEncr(st->buf, st->wbl->key);
else if (st->b1 == 2)
belt32BlockEncr(st->buf, st->wbl->key);
else
beltWBLStepE(st->buf, 8 * st->b1 + 8, st->wbl);
beltBin2StrSub(st->mod, buf + st->n1, st->n2, st->buf, st->b1 + 1);
// первая половинка
beltStr2Bin(st->buf, st->b2, st->mod, buf + st->n1, st->n2);
memCopy(st->buf + st->b2 * 8, beltH() + 8 * i, 4);
memCopy(st->buf + st->b2 * 8 + 4, st->iv + 8 * i, 4);
if (st->b2 == 1)
beltBlockEncr(st->buf, st->wbl->key);
else if (st->b2 == 2)
belt32BlockEncr(st->buf, st->wbl->key);
else
beltWBLStepE(st->buf, 8 * st->b2 + 8, st->wbl);
beltBin2StrSub(st->mod, buf, st->n1, st->buf, st->b2 + 1);
}
} | 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(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x80(%rbx), %rbp
leaq 0x84(%rbx), %rax
movq %rax, 0x8(%rsp)
pushq $-0x3
popq %r13
pushq $0x14
popq %rax
movq %rax, (%rsp)
pushq $0x4
popq %r12
testq %r13, %r13
je 0x28639
movq %rbp, 0x20(%rsp)
movq 0x60(%rbx), %rsi
movl 0x48(%rbx), %edx
movq 0x50(%rbx), %r8
movq %r15, %rdi
movq %r14, %rcx
callq 0x28224
movq 0x60(%rbx), %rax
leaq (%r15,%rax,8), %rbp
xorl %eax, %eax
callq 0xf920
movq (%rsp), %rcx
leaq (%rax,%rcx), %rsi
movq %rbp, %rdi
pushq $0x4
popq %rbp
movq %rbp, %rdx
callq 0xe970
movq 0x60(%rbx), %rax
movq 0x10(%rsp), %rcx
leaq (%rcx,%rax,8), %rdi
movq 0x8(%rsp), %rsi
movq %rbp, %rdx
callq 0xe970
movq 0x60(%rbx), %rax
cmpq $0x2, %rax
je 0x2852d
cmpq $0x1, %rax
jne 0x2853a
movq %r15, %rdi
movq %rbx, %rsi
callq 0xe140
jmp 0x2854d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x282d4
jmp 0x2854d
leaq 0x8(,%rax,8), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0xf910
movl 0x48(%rbx), %edi
movq 0x50(%rbx), %rax
leaq (%r14,%rax,2), %rsi
movq 0x58(%rbx), %rdx
movq 0x60(%rbx), %r8
incq %r8
movq %r15, %rcx
callq 0x28648
movq 0x68(%rbx), %rsi
movl 0x48(%rbx), %edx
movq 0x50(%rbx), %rax
leaq (%r14,%rax,2), %rcx
movq 0x58(%rbx), %r8
movq %r15, %rdi
callq 0x28224
movq 0x68(%rbx), %rax
leaq (%r15,%rax,8), %rbp
xorl %eax, %eax
callq 0xf920
movq 0x18(%rsp), %rcx
leaq (%rax,%rcx), %rsi
movq %rbp, %rdi
movq %r12, %rdx
callq 0xe970
movq 0x68(%rbx), %rax
movq 0x10(%rsp), %rcx
leaq (%rcx,%rax,8), %rdi
movq 0x20(%rsp), %rbp
movq %rbp, %rsi
movq %r12, %rdx
callq 0xe970
movq 0x68(%rbx), %rax
cmpq $0x2, %rax
je 0x285e3
cmpq $0x1, %rax
jne 0x285f0
movq %r15, %rdi
movq %rbx, %rsi
callq 0xe140
jmp 0x28603
movq %r15, %rdi
movq %rbx, %rsi
callq 0x282d4
jmp 0x28603
leaq 0x8(,%rax,8), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0xf910
movl 0x48(%rbx), %edi
movq 0x50(%rbx), %rdx
movq 0x68(%rbx), %r8
incq %r8
movq %r14, %rsi
movq %r15, %rcx
callq 0x28648
incq %r13
addq $-0x8, (%rsp)
addq $-0x8, %rbp
addq $-0x8, 0x8(%rsp)
addq $-0x8, 0x18(%rsp)
jmp 0x284ad
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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;
}
// настроить память
m = W_OF_O(8 * b);
a = (word*)bin;
wwFrom(a, bin, 8 * b);
// конвертировать и вычесть
ASSERT(2 <= mod && mod <= 65536);
while (count--)
{
t = (u32)zzModW(a, m, mod);
t = str[0] + mod - t, t %= mod;
str[0] = (u16)t, ++str;
zzDivW(a, a, m, mod);
}
t = 0;
} | 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,%r14,2)
jmp 0x28678
movq %r8, %r12
movq %rdi, %r13
movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFFF
andq %rax, %r12
movq %rbx, %rdi
movq %rbx, %rsi
callq 0xf540
xorl %ebp, %ebp
cmpq %rbp, %r14
je 0x286ec
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xfc10
movzwl (%r15,%rbp,2), %edx
movl %r13d, %ecx
subl %eax, %ecx
addl %edx, %ecx
movq %rcx, %rax
xorl %edx, %edx
divq %r13
movw %dx, (%r15,%rbp,2)
movq %rbx, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0xf9d0
incq %rbp
jmp 0x286aa
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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) ||
!memIsValid(dest, 2 * count) ||
iv && !memIsDisjoint2(dest, 2 * count, iv, 16))
return ERR_BAD_INPUT;
if (count > 600)
return ERR_NOT_IMPLEMENTED;
// создать состояние
state = blobCreate(beltFMT_keep(mod, count));
if (state == 0)
return ERR_OUTOFMEMORY;
// зашифровать
beltFMTStart(state, mod, count, key, len);
memMove(dest, src, 2 * count);
beltFMTStepE(dest, iv, state);
// завершить
blobClose(state);
return ERR_OK;
} | 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 %esi, 0xc(%rsp)
leaq (%rcx,%rcx), %rsi
movq %rdx, %rdi
movq %rsi, 0x10(%rsp)
callq 0xeeb0
testl %eax, %eax
je 0x28830
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x2877a
pushq $0x10
popq %rsi
callq 0xeeb0
testl %eax, %eax
je 0x28830
movq %r12, %rdi
movq %r15, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x28830
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0xeeb0
testl %eax, %eax
je 0x28830
cmpq $0x0, 0x50(%rsp)
je 0x287c3
pushq $0x10
popq %rcx
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x10140
testl %eax, %eax
je 0x28830
cmpq $0x258, %r13 # imm = 0x258
jbe 0x287d0
pushq $0x77
jmp 0x2882f
movl 0xc(%rsp), %edi
movq %r13, %rsi
callq 0xf000
movq %rax, %rdi
callq 0xf190
testq %rax, %rax
je 0x2882d
movq %rax, %rbp
movq %rax, %rdi
movl 0xc(%rsp), %esi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0xfa80
movq %rbx, %rdi
movq %r14, %rsi
movq 0x10(%rsp), %rdx
callq 0xe130
movq %rbx, %rdi
movq 0x50(%rsp), %rsi
movq %rbp, %rdx
callq 0xfc80
movq %rbp, %rdi
callq 0xe920
xorl %ebp, %ebp
jmp 0x28830
pushq $0x6e
popq %rbp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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) ||
!memIsValid(dest, 2 * count) ||
iv && !memIsDisjoint2(dest, 2 * count, iv, 16))
return ERR_BAD_INPUT;
if (count > 600)
return ERR_NOT_IMPLEMENTED;
// создать состояние
state = blobCreate(beltFMT_keep(mod, count));
if (state == 0)
return ERR_OUTOFMEMORY;
// зашифровать
beltFMTStart(state, mod, count, key, len);
memMove(dest, src, 2 * count);
beltFMTStepD(dest, iv, state);
// завершить
blobClose(state);
return ERR_OK;
} | 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 %esi, 0xc(%rsp)
leaq (%rcx,%rcx), %rsi
movq %rdx, %rdi
movq %rsi, 0x10(%rsp)
callq 0xeeb0
testl %eax, %eax
je 0x28976
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x288c0
pushq $0x10
popq %rsi
callq 0xeeb0
testl %eax, %eax
je 0x28976
movq %r12, %rdi
movq %r15, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x28976
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0xeeb0
testl %eax, %eax
je 0x28976
cmpq $0x0, 0x50(%rsp)
je 0x28909
pushq $0x10
popq %rcx
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x10140
testl %eax, %eax
je 0x28976
cmpq $0x258, %r13 # imm = 0x258
jbe 0x28916
pushq $0x77
jmp 0x28975
movl 0xc(%rsp), %edi
movq %r13, %rsi
callq 0xf000
movq %rax, %rdi
callq 0xf190
testq %rax, %rax
je 0x28973
movq %rax, %rbp
movq %rax, %rdi
movl 0xc(%rsp), %esi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0xfa80
movq %rbx, %rdi
movq %r14, %rsi
movq 0x10(%rsp), %rdx
callq 0xe130
movq %rbx, %rdi
movq 0x50(%rsp), %rsi
movq %rbp, %rdx
callq 0xeab0
movq %rbp, %rdi
callq 0xe920
xorl %ebp, %ebp
jmp 0x28976
pushq $0x6e
popq %rbp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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)
beltBlockRevU32(st->block);
beltBlockRevU32(st->block + 16);
#endif
}
// key <- beltHash(key)
else
{
beltBlockSetZero(st->ls_in);
beltBlockAddBitSizeU32(st->ls_in, len);
beltBlockSetZero(st->ls_in + 4);
u32From(st->h_in, beltH(), 32);
while (len >= 32)
{
beltBlockCopy(st->block, key);
beltBlockCopy(st->block + 16, key + 16);
#if (OCTET_ORDER == BIG_ENDIAN)
beltBlockRevU32(st->block);
beltBlockRevU32(st->block + 16);
#endif
beltCompr2(st->ls_in + 4, st->h_in, (u32*)st->block, st->stack);
key += 32;
len -= 32;
}
if (len)
{
memCopy(st->block, key, len);
memSetZero(st->block + len, 32 - len);
#if (OCTET_ORDER == BIG_ENDIAN)
beltBlockRevU32(st->block);
beltBlockRevU32(st->block + 16);
#endif
beltCompr2(st->ls_in + 4, st->h_in, (u32*)st->block, st->stack);
}
beltCompr(st->h_in, st->ls_in, st->stack);
beltBlockCopy(st->block, st->h_in);
beltBlockCopy(st->block + 16, st->h_in + 4);
}
// сформировать key ^ ipad
for (len = 0; len < 32; ++len)
st->block[len] ^= 0x36;
// начать внутреннее хэширование
beltBlockSetZero(st->ls_in);
beltBlockAddBitSizeU32(st->ls_in, 32);
beltBlockSetZero(st->ls_in + 4);
u32From(st->h_in, beltH(), 32);
beltCompr2(st->ls_in + 4, st->h_in, (u32*)st->block, st->stack);
st->filled = 0;
// сформировать key ^ opad [0x36 ^ 0x5C == 0x6A]
for (; len--; )
st->block[len] ^= 0x6A;
// начать внешнее хэширование [будет хэшироваться ровно два блока]
beltBlockSetZero(st->ls_out);
beltBlockAddBitSizeU32(st->ls_out, 32 * 2);
beltBlockSetZero(st->ls_out + 4);
u32From(st->h_out, beltH(), 32);
beltCompr2(st->ls_out + 4, st->h_out, (u32*)st->block, st->stack);
} | 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
callq 0xf710
jmp 0x28e13
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10060
leaq 0x10(%rbx), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
xorl %eax, %eax
callq 0xf920
pushq $0x20
popq %rdx
movq %r14, %r13
movq %r14, %rdi
movq %rax, %rsi
callq 0xe940
leaq 0xd0(%rbx), %r14
leaq 0xf8(%rbx), %rbp
movq %r15, 0x10(%rsp)
cmpq $0x20, %r15
jb 0x28db2
movq (%r12), %rax
movq %rax, 0xd0(%rbx)
movq 0x8(%r12), %rax
movq %rax, 0xd8(%rbx)
movq 0x10(%r12), %rax
movq %rax, 0xe0(%rbx)
movq 0x18(%r12), %rax
movq %rax, 0xe8(%rbx)
movq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbp, %rcx
callq 0xf0e0
addq $0x20, %r12
addq $-0x20, %r15
jmp 0x28d60
movq 0x10(%rsp), %r15
andq $0x1f, %r15
je 0x28def
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xe970
leaq (%r14,%r15), %rdi
pushq $0x20
popq %rdx
subq %r15, %rdx
xorl %esi, %esi
callq 0xf710
movq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbp, %rcx
callq 0xf0e0
movq %r13, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0xf4a0
movups 0x20(%rbx), %xmm0
movups 0x30(%rbx), %xmm1
movups %xmm0, 0xd0(%rbx)
movups %xmm1, 0xe0(%rbx)
leaq 0xd0(%rbx), %r14
movl $0xd0, %eax
cmpq $0xf0, %rax
je 0x28e30
xorb $0x36, (%rbx,%rax)
incq %rax
jmp 0x28e1f
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
pushq $0x20
popq %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10060
leaq 0x10(%rbx), %r12
leaq 0x20(%rbx), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
xorl %ebp, %ebp
xorl %eax, %eax
callq 0xf920
movq %r13, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xe940
leaq 0xf8(%rbx), %r15
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0xf0e0
andq $0x0, 0xf0(%rbx)
cmpq $-0x20, %rbp
je 0x28e9e
xorb $0x6a, 0xef(%rbx,%rbp)
decq %rbp
jmp 0x28e8b
leaq 0x60(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
pushq $0x40
popq %rsi
callq 0x10060
leaq 0x70(%rbx), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rbx)
subq $-0x80, %rbx
xorl %eax, %eax
callq 0xf920
pushq $0x20
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe940
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf0e0
| /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)
{
memCopy(st->block + st->filled, buf, count);
st->filled += count;
return;
}
memCopy(st->block + st->filled, buf, 32 - st->filled);
count -= 32 - st->filled;
buf = (const octet*)buf + (32 - st->filled);
#if (OCTET_ORDER == BIG_ENDIAN)
beltBlockRevU32(st->block);
beltBlockRevU32(st->block + 16);
#endif
beltCompr2(st->ls_in + 4, st->h_in, (u32*)st->block, st->stack);
st->filled = 0;
}
// цикл по полным блокам
while (count >= 32)
{
beltBlockCopy(st->block, buf);
beltBlockCopy(st->block + 16, (const octet*)buf + 16);
#if (OCTET_ORDER == BIG_ENDIAN)
beltBlockRevU32(st->block);
beltBlockRevU32(st->block + 16);
#endif
beltCompr2(st->ls_in + 4, st->h_in, (u32*)st->block, st->stack);
buf = (const octet*)buf + 32;
count -= 32;
}
// неполный блок?
if (count)
memCopy(st->block, buf, st->filled = count);
} | 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 0x28f4d
movq %r15, %rsi
movq %rbx, %rdx
callq 0xe970
addq %rbx, 0xf0(%r14)
jmp 0x29018
leaq 0xd0(%r14), %r12
movq %r15, %rsi
callq 0xe970
subq 0xf0(%r14), %r13
subq %r13, %rbx
addq %r13, %r15
leaq 0x10(%r14), %rdi
leaq 0x20(%r14), %rsi
leaq 0xf8(%r14), %rcx
movq %r12, %rdx
callq 0xf0e0
andq $0x0, 0xf0(%r14)
leaq 0xd0(%r14), %rax
movq %rax, (%rsp)
leaq 0x10(%r14), %r13
leaq 0x20(%r14), %rbp
leaq 0xf8(%r14), %r12
cmpq $0x20, %rbx
jb 0x28fef
movq (%r15), %rax
movq %rax, 0xd0(%r14)
movq 0x8(%r15), %rax
movq %rax, 0xd8(%r14)
movq 0x10(%r15), %rax
movq %rax, 0xe0(%r14)
movq 0x18(%r15), %rax
movq %rax, 0xe8(%r14)
movq %r13, %rdi
movq %rbp, %rsi
movq (%rsp), %rdx
movq %r12, %rcx
callq 0xf0e0
addq $0x20, %r15
addq $-0x20, %rbx
jmp 0x28fa2
testq %rbx, %rbx
je 0x29018
movq %rbx, 0xf0(%r14)
movq (%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe970
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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)
return ERR_OUTOFMEMORY;
// выработать имитовставку
beltHMACStart(state, key, len);
beltHMACStepA(src, count, state);
beltHMACStepG(mac, state);
// завершить
blobClose(state);
return ERR_OK;
} | 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 0x2926e
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x2926e
callq 0xe420
movq %rax, %rdi
callq 0xf190
testq %rax, %rax
je 0x2926b
movq %rax, %rbp
movq %rax, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xf090
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0xf5e0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xf550
movq %rbp, %rdi
callq 0xe920
xorl %ebp, %ebp
jmp 0x2926e
pushq $0x6e
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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_keep()));
ASSERT(memIsDisjoint2(header, 16, state, beltKRP_keep()));
// полностью определить st->block
u32From(st->block, beltH() + 4 * (st->len - 16) + 2 * (key_len - 16), 4);
u32From(st->block + 4, header, 16);
// применить belt-compr2
beltBlockCopy(st->key_new, st->key);
beltBlockCopy(st->key_new + 4, st->key + 4);
beltCompr(st->key_new, st->block, st->stack);
// выгрузить ключ
u32To(key_, key_len, st->key_new);
} | 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(%r15), %rdi
pushq $0x10
popq %rdx
movq %r13, %rsi
callq 0xe940
leaq 0x48(%r15), %r13
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm0, 0x48(%r15)
movups %xmm1, 0x58(%r15)
addq $0x68, %r15
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xf4a0
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf6c0
| /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, 16) ||
!memIsValid(dest, m))
return ERR_BAD_INPUT;
// создать состояние
state = blobCreate(beltKRP_keep());
if (state == 0)
return ERR_OUTOFMEMORY;
// преобразовать ключ
beltKRPStart(state, src, n, level);
beltKRPStepG(dest, m, header, state);
// завершить
blobClose(state);
return ERR_OK;
} | 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
btq %r15, %rax
jae 0x2935f
movq %rcx, %rbp
cmpq $0x20, %rcx
ja 0x2935f
btq %rbp, %rax
jae 0x2935f
movq %r8, %r13
movq %rdx, %r14
movq %rdi, %r12
movq %r9, (%rsp)
movq %rdx, %rdi
movq %rbp, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x2935f
pushq $0xc
popq %rsi
movq %r13, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x2935f
pushq $0x10
popq %rsi
movq (%rsp), %rdi
callq 0xeeb0
testl %eax, %eax
je 0x2935f
movq %r12, %rdi
movq %r15, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x2935f
callq 0xf720
movq %rax, %rdi
callq 0xf190
testq %rax, %rax
je 0x2942d
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq %r13, %rcx
callq 0xe850
movq %r12, %rdi
movq %r15, %rsi
movq (%rsp), %rdx
movq %rbx, %rcx
callq 0xe380
movq %rbx, %rdi
callq 0xe920
xorl %ebx, %ebx
jmp 0x2935f
pushq $0x6e
popq %rbx
jmp 0x2935f
nopl (%rax)
| /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(src, count, header, 16) ||
!memIsValid(key, len) ||
!memIsValid(dest, count + 16))
return ERR_BAD_INPUT;
// создать состояние
state = blobCreate(beltKWP_keep());
if (state == 0)
return ERR_OUTOFMEMORY;
// установить защиту
beltKWPStart(state, key, len);
memMove(dest, src, count);
if (header)
memJoin(dest, src, count, header, 16);
else
memSetZero(dest + count, 16);
beltKWPStepE(dest, count + 16, state);
// завершить
blobClose(state);
return ERR_OK;
} | 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
movq %rdi, 0x8(%rsp)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x2957a
testq %r15, %r15
je 0x294c9
pushq $0x10
popq %rsi
movq %r15, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x2957a
pushq $0x10
popq %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x10140
testl %eax, %eax
je 0x2957a
movq %rbx, %rdi
movq %r13, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x2957a
leaq 0x10(%r14), %rsi
movq 0x8(%rsp), %rdi
movq %rsi, 0x10(%rsp)
callq 0xeeb0
testl %eax, %eax
je 0x2957a
xorl %eax, %eax
callq 0xf030
movq %rax, %rdi
callq 0xf190
testq %rax, %rax
je 0x2954b
movq %rax, %rbp
movq %rax, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0xf570
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xe130
testq %r15, %r15
je 0x29550
pushq $0x10
popq %r8
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0xefa0
jmp 0x29560
pushq $0x6e
popq %rbp
jmp 0x2957a
addq %rbx, %r14
pushq $0x10
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0xf710
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movq %rbp, %rdx
callq 0xf910
movq %rbp, %rdi
callq 0xe920
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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) ||
!memIsValid(key, len) ||
!memIsValid(dest, count - 16))
return ERR_BAD_INPUT;
// создать состояние
state = blobCreate(beltKWP_keep() + 16);
if (state == 0)
return ERR_OUTOFMEMORY;
header2 = (octet*)state + beltKWP_keep();
// снять защиту
beltKWPStart(state, key, len);
memCopy(header2, src + count - 16, 16);
memMove(dest, src, count - 16);
beltKWPStepD2(dest, header2, count, state);
if (header && !memEq(header, header2, 16) ||
header == 0 && !memIsZero(header2, 16))
{
memSetZero(dest, count - 16);
blobClose(state);
return ERR_BAD_KEYTOKEN;
}
// завершить
blobClose(state);
return ERR_OK;
} | 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
movq %rdi, (%rsp)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x296ed
testq %r15, %r15
je 0x29602
pushq $0x10
popq %rsi
movq %r15, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x296ed
movq %r14, %rdi
movq %rbp, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x296ed
leaq -0x10(%r12), %rsi
movq (%rsp), %rdi
movq %rsi, 0x10(%rsp)
callq 0xeeb0
testl %eax, %eax
je 0x296ed
xorl %eax, %eax
callq 0xf030
leaq 0x10(%rax), %rdi
callq 0xf190
testq %rax, %rax
je 0x296be
xorl %ebx, %ebx
movq %rax, 0x8(%rsp)
xorl %eax, %eax
callq 0xf030
movq 0x8(%rsp), %rdi
addq %rdi, %rax
movq %r14, %rsi
movq %rbp, %rdx
movq %rax, %rbp
callq 0xf570
leaq (%r12,%r13), %rsi
addq $-0x10, %rsi
pushq $0x10
popq %rdx
movq %rbp, %rdi
callq 0xe970
movq (%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
movq 0x10(%rsp), %r13
movq %r13, %rdx
callq 0xe130
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq 0x8(%rsp), %r14
movq %r14, %rcx
callq 0xeb80
testq %r15, %r15
je 0x296c3
pushq $0x10
popq %rdx
movq %r15, %rdi
movq %rbp, %rsi
callq 0xf140
jmp 0x296ce
pushq $0x6e
popq %rbx
jmp 0x296ed
pushq $0x10
popq %rsi
movq %rbp, %rdi
callq 0xfe60
testl %eax, %eax
jne 0x296e5
movq (%rsp), %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0xf710
movl $0x201, %ebx # imm = 0x201
movq %r14, %rdi
callq 0xe920
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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;
return;
}
memCopy(st->block + st->filled, buf, 16 - st->filled);
count -= 16 - st->filled;
buf = (const octet*)buf + 16 - st->filled;
st->filled = 16;
}
// цикл по полным блокам
while (count >= 16)
{
#if (OCTET_ORDER == BIG_ENDIAN)
beltBlockRevU32(st->block);
#endif
beltBlockXor2(st->s, st->block);
beltBlockEncr2(st->s, st->key);
beltBlockCopy(st->block, buf);
buf = (const octet*)buf + 16;
count -= 16;
}
// неполный блок?
if (count)
{
#if (OCTET_ORDER == BIG_ENDIAN)
beltBlockRevU32(st->block);
#endif
beltBlockXor2(st->s, st->block);
beltBlockEncr2(st->s, st->key);
memCopy(st->block, 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, %r14
addq $-0x10, %r14
subq %rax, %r15
addq $0x10, %r15
movq $0x10, 0x60(%rbx)
leaq 0x50(%rbx), %r12
leaq 0x20(%rbx), %r13
cmpq $0x10, %r14
jb 0x297c1
movups 0x20(%rbx), %xmm0
movups 0x50(%rbx), %xmm1
xorps %xmm0, %xmm1
movups %xmm1, 0x20(%rbx)
movq %r13, %rdi
movq %rbx, %rsi
callq 0x100d0
movq (%r15), %rax
movq %rax, 0x50(%rbx)
movq 0x8(%r15), %rax
movq %rax, 0x58(%rbx)
addq $0x10, %r15
addq $-0x10, %r14
jmp 0x29788
testq %r14, %r14
je 0x29803
movups 0x20(%rbx), %xmm0
movups 0x50(%rbx), %xmm1
xorps %xmm0, %xmm1
movups %xmm1, 0x20(%rbx)
movq %r13, %rdi
movq %rbx, %rsi
callq 0x100d0
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xe970
jmp 0x297ff
movq %r15, %rsi
movq %r14, %rdx
callq 0xe970
addq 0x60(%rbx), %r14
movq %r14, 0x60(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /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->mac[1] ^= st->r[2];
st->mac[2] ^= st->r[3];
st->mac[3] ^= st->r[0] ^ st->r[1];
#if (OCTET_ORDER == BIG_ENDIAN)
beltBlockRevU32(st->block);
#endif
}
// неполный (в т.ч. пустой) блок?
else
{
st->block[st->filled] = 0x80;
memSetZero(st->block + st->filled + 1, 16 - st->filled - 1);
#if (OCTET_ORDER == BIG_ENDIAN)
beltBlockRevU32(st->block);
#endif
beltBlockXor(st->mac, st->s, st->block);
st->mac[0] ^= st->r[0] ^ st->r[3];
st->mac[1] ^= st->r[0];
st->mac[2] ^= st->r[1];
st->mac[3] ^= st->r[2];
#if (OCTET_ORDER == BIG_ENDIAN)
beltBlockRevU32(st->block);
#endif
}
beltBlockEncr2(st->mac, st->key);
} | 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), %eax
xorl %ecx, %eax
movl %eax, 0x48(%rbx)
shrq $0x20, %rcx
xorl 0x30(%rbx), %ecx
xorl %edx, %ecx
jmp 0x298d0
movb $-0x80, 0x50(%rbx,%rax)
movq 0x60(%rbx), %rax
leaq (%rbx,%rax), %rdi
addq $0x51, %rdi
pushq $0xf
popq %rdx
subq %rax, %rdx
xorl %esi, %esi
callq 0xf710
movq 0x50(%rbx), %rax
xorq 0x20(%rbx), %rax
movq 0x58(%rbx), %rcx
xorq 0x28(%rbx), %rcx
movl 0x30(%rbx), %edx
movl 0x3c(%rbx), %esi
xorl %eax, %esi
xorl %edx, %esi
movl %esi, 0x40(%rbx)
shrq $0x20, %rax
xorl %edx, %eax
movl %eax, 0x44(%rbx)
movl 0x34(%rbx), %eax
xorl %ecx, %eax
movl %eax, 0x48(%rbx)
shrq $0x20, %rcx
xorl 0x38(%rbx), %ecx
movl %ecx, 0x4c(%rbx)
leaq 0x40(%rbx), %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x100d0
| /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(mac, st->mac, mac_len);
} | 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;
// создать состояние
state = blobCreate(beltHMAC_keep() + 32);
if (state == 0)
return ERR_OUTOFMEMORY;
t = (octet*)state + beltHMAC_keep();
// key <- HMAC(pwd, salt || 00000001)
beltHMACStart(state, pwd, pwd_len);
beltHMACStepA(salt, salt_len, state);
*(u32*)key = 0, key[3] = 1;
beltHMACStepA(key, 4, state);
beltHMACStepG(key, state);
// пересчитать key
memCopy(t, key, 32);
while (--iter)
{
beltHMACStart(state, pwd, pwd_len);
beltHMACStepA(t, 32, state);
beltHMACStepG(t, state);
memXor2(key, t, 32);
}
// завершить
blobClose(state);
return ERR_OK;
} | 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
movq %r12, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x29b60
pushq $0x20
popq %rsi
movq 0x8(%rsp), %rdi
callq 0xeeb0
testl %eax, %eax
je 0x29b60
movq %r13, 0x10(%rsp)
xorl %eax, %eax
callq 0xe420
leaq 0x20(%rax), %rdi
callq 0xf190
testq %rax, %rax
je 0x29b5d
movq %rax, %r13
xorl %eax, %eax
callq 0xe420
movq %rax, %rbp
addq %r13, %rbp
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xf090
movq 0x10(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xf5e0
movq 0x8(%rsp), %r12
movl $0x1000000, (%r12) # imm = 0x1000000
pushq $0x4
popq %rsi
movq %r12, %rdi
movq %r13, %rdx
callq 0xf5e0
movq %r12, %rdi
movq %r13, %rsi
callq 0xf550
pushq $0x20
popq %r12
movq %rbp, %rdi
movq 0x8(%rsp), %rsi
movq %r12, %rdx
callq 0xe970
decq %rbx
subq $0x1, %rbx
jb 0x29b51
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xf090
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xf5e0
movq %rbp, %rdi
movq %r13, %rsi
callq 0xf550
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0xf0b0
jmp 0x29b12
movq %r13, %rdi
callq 0xe920
xorl %ebp, %ebp
jmp 0x29b60
pushq $0x6e
popq %rbp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
| /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; /* описание эллиптической кривой */
word* Q; /* [2n] открытый ключ */
word* R; /* [2n] точка R */
word* H; /* [n] хэш-значение */
word* s0; /* [n / 2 + 1] первая часть подписи */
word* s1; /* [n] вторая часть подписи */
octet* stack;
// проверить params
if (!memIsValid(params, sizeof(bign_params)))
return ERR_BAD_INPUT;
if (!bignIsOperable(params))
return ERR_BAD_PARAMS;
// проверить oid_der
if (oid_len == SIZE_MAX || oidFromDER(0, oid_der, oid_len) == SIZE_MAX)
return ERR_BAD_OID;
// создать состояние
state = blobCreate(bignStart_keep(params->l, bignIdExtract_deep));
if (state == 0)
return ERR_OUTOFMEMORY;
// старт
code = bignStart(state, params);
ERR_CALL_HANDLE(code, blobClose(state));
ec = (ec_o*)state;
// размерности
no = ec->f->no;
n = ec->f->n;
ASSERT(n % 2 == 0);
// проверить входные указатели
if (!memIsValid(id_hash, no) ||
!memIsValid(sig, no + no / 2) ||
!memIsValid(pubkey, 2 * no) ||
!memIsValid(id_privkey, no) ||
!memIsValid(id_pubkey, 2 * no))
{
blobClose(state);
return ERR_BAD_INPUT;
}
// раскладка состояния
Q = R = objEnd(ec, word);
H = s0 = Q + 2 * n;
s1 = H + n;
stack = (octet*)(s1 + n);
// загрузить Q
if (!qrFrom(ecX(Q), pubkey, ec->f, stack) ||
!qrFrom(ecY(Q, n), pubkey + no, ec->f, stack))
{
blobClose(state);
return ERR_BAD_PUBKEY;
}
// загрузить и проверить s1
wwFrom(s1, sig + no / 2, no);
if (wwCmp(s1, ec->order, n) >= 0)
{
blobClose(state);
return ERR_BAD_SIG;
}
// s1 <- (s1 + H) mod q
wwFrom(H, id_hash, no);
if (wwCmp(H, ec->order, n) >= 0)
{
zzSub2(H, ec->order, n);
// 2^{l - 1} < q < 2^l, H < 2^l => H - q < q
ASSERT(wwCmp(H, ec->order, n) < 0);
}
zzAddMod(s1, s1, H, ec->order, n);
// загрузить s0
wwFrom(s0, sig, no);
s0[n / 2] = 1;
// R <- s1 G + (s0 + 2^l) Q
if (!ecAddMulA(R, ec, stack, 2, ec->base, s1, n, Q, s0, n / 2 + 1))
{
blobClose(state);
return ERR_BAD_SIG;
}
qrTo((octet*)R, ecX(R), ec->f, stack);
// s0 == belt-hash(oid || R || H) mod 2^l?
beltHashStart(stack);
beltHashStepH(oid_der, oid_len, stack);
beltHashStepH(R, no, stack);
beltHashStepH(id_hash, no, stack);
if (beltHashStepV2(sig, no / 2, stack))
{
wwTo(id_privkey, no, s1);
memCopy(id_pubkey, R, no);
qrTo(id_pubkey + no, ecY(R, n), ec->f, stack);
}
else
code = ERR_BAD_SIG;
// завершение
blobClose(state);
return code;
} | 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, %eax
je 0x29efc
movq %r15, 0x48(%rsp)
movl $0x12d, %r15d # imm = 0x12D
cmpq $-0x1, %r13
je 0x29f15
xorl %edi, %edi
movq %rbp, %rsi
movq %r13, %rdx
callq 0xe710
cmpq $-0x1, %rax
je 0x29f15
movq (%rbx), %rdi
leaq 0x338(%rip), %rsi # 0x29f27
callq 0xf410
movq %rax, %rdi
callq 0xf190
testq %rax, %rax
je 0x29f04
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0xf290
movq %r15, %rbx
movl %eax, %r15d
testl %eax, %eax
jne 0x29f0d
movq %rbx, 0x30(%rsp)
movq 0x18(%rbx), %rax
movq 0x30(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x38(%rax), %rbx
movq %r12, %rdi
movq %rbx, %rsi
callq 0xeeb0
pushq $0x6d
popq %r15
testl %eax, %eax
je 0x29f08
movq 0x90(%rsp), %rdi
movq %rbx, %rax
shrq %rax
movq %rax, 0x40(%rsp)
leaq (%rax,%rbx), %rsi
callq 0xeeb0
testl %eax, %eax
je 0x29f08
movq 0x98(%rsp), %rdi
leaq (%rbx,%rbx), %rsi
movq %rsi, 0x8(%rsp)
callq 0xeeb0
testl %eax, %eax
je 0x29f08
movq %r14, %rdi
movq %rbx, 0x20(%rsp)
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x29f08
movq 0x48(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xeeb0
testl %eax, %eax
movq 0x30(%rsp), %rbx
je 0x29f0d
movq (%rbx), %rdi
addq %rbx, %rdi
movq 0x10(%rsp), %rcx
movq %rcx, %rax
shlq $0x4, %rax
addq %rdi, %rax
movq %rax, 0x18(%rsp)
leaq (%rax,%rcx,8), %rax
movq %rax, 0x38(%rsp)
leaq (%rax,%rcx,8), %rcx
movq 0x18(%rbx), %rdx
movq %rdi, 0x28(%rsp)
movq 0x98(%rsp), %rsi
movq %rcx, 0x8(%rsp)
callq *0x40(%rdx)
movl $0x1f9, %r15d # imm = 0x1F9
testl %eax, %eax
je 0x29f0d
movq 0x18(%rbx), %rdx
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
leaq (%rax,%rcx,8), %rdi
movq 0x98(%rsp), %rsi
addq 0x20(%rsp), %rsi
movq %rdi, 0x50(%rsp)
movq 0x8(%rsp), %rcx
callq *0x40(%rdx)
testl %eax, %eax
je 0x29f0d
movq 0x40(%rsp), %rax
movq 0x90(%rsp), %rcx
leaq (%rcx,%rax), %rsi
movq 0x38(%rsp), %r15
movq %r15, %rdi
movq 0x20(%rsp), %rdx
callq 0xf540
movq 0x38(%rbx), %rsi
movq %r15, %rdi
movq 0x10(%rsp), %rdx
callq 0xf1b0
movl $0x1fe, %r15d # imm = 0x1FE
testl %eax, %eax
jns 0x29f0d
movq 0x18(%rsp), %rdi
movq %r12, %rsi
movq 0x20(%rsp), %rdx
callq 0xf540
movq 0x38(%rbx), %rsi
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
callq 0xf1b0
testl %eax, %eax
js 0x29dc4
movq 0x38(%rbx), %rsi
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
callq 0xee10
movq 0x38(%rbx), %rcx
movq 0x38(%rsp), %rdi
movq %rdi, %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %r8
callq 0xfff0
movq 0x18(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xf540
movq 0x10(%rsp), %r10
shrq %r10
movq 0x18(%rsp), %r11
movq $0x1, (%r11,%r10,8)
movq 0x30(%rbx), %r8
incq %r10
pushq $0x2
popq %rcx
movq 0x28(%rsp), %rdi
movq %rbx, %rsi
movq 0x8(%rsp), %rdx
movq 0x38(%rsp), %r9
xorl %eax, %eax
pushq %r10
pushq %r11
pushq %rdi
pushq 0x28(%rsp)
callq 0xe220
addq $0x20, %rsp
testl %eax, %eax
je 0x29f0d
movq 0x18(%rbx), %rdx
movq 0x28(%rsp), %rdi
movq %rdi, %rsi
movq 0x8(%rsp), %rcx
callq *0x48(%rdx)
movq 0x8(%rsp), %rdi
callq 0xe5d0
movq %rbp, %rdi
movq %r13, %rsi
movq 0x8(%rsp), %rbp
movq %rbp, %rdx
callq 0xe360
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %r13
movq %r13, %rsi
movq %rbp, %rdx
callq 0xe360
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0xe360
movq 0x90(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq %rbp, %rdx
callq 0xe3a0
testl %eax, %eax
je 0x29f0d
movq %r14, %rdi
movq 0x20(%rsp), %r15
movq %r15, %rsi
movq 0x38(%rsp), %rdx
callq 0xf300
movq 0x48(%rsp), %r14
movq %r14, %rdi
movq 0x28(%rsp), %rsi
movq %r15, %rdx
callq 0xe970
movq 0x18(%rbx), %rdx
addq %r15, %r14
movq %r14, %rdi
movq 0x50(%rsp), %rsi
movq 0x8(%rsp), %rcx
callq *0x48(%rdx)
xorl %r15d, %r15d
jmp 0x29f0d
pushq $0x6d
popq %r15
jmp 0x29f15
movl $0x1f6, %r15d # imm = 0x1F6
jmp 0x29f15
pushq $0x6e
jmp 0x29ef8
movq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0xe920
movl %r15d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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; /* описание эллиптической кривой */
word* e; /* [n] личный ключ */
word* k; /* [n] одноразовый личный ключ */
word* V; /* [2n] точка V */
word* s0; /* [n/2] первая часть подписи */
word* s1; /* [n] вторая часть подписи */
octet* stack;
// проверить params
if (!memIsValid(params, sizeof(bign_params)))
return ERR_BAD_INPUT;
if (!bignIsOperable(params))
return ERR_BAD_PARAMS;
// проверить oid_der
if (oid_len == SIZE_MAX || oidFromDER(0, oid_der, oid_len) == SIZE_MAX)
return ERR_BAD_OID;
// проверить rng
if (rng == 0)
return ERR_BAD_RNG;
// создать состояние
state = blobCreate(bignStart_keep(params->l, bignIdSign_deep));
if (state == 0)
return ERR_OUTOFMEMORY;
// старт
code = bignStart(state, params);
ERR_CALL_HANDLE(code, blobClose(state));
ec = (ec_o*)state;
// размерности
no = ec->f->no;
n = ec->f->n;
ASSERT(n % 2 == 0);
// проверить входные указатели
if (!memIsValid(id_hash, no) ||
!memIsValid(hash, no) ||
!memIsValid(id_privkey, no) ||
!memIsValid(id_sig, no + no / 2))
{
blobClose(state);
return ERR_BAD_INPUT;
}
// раскладка состояния
e = s1 = objEnd(ec, word);
k = e + n;
V = k + n;
s0 = V + n + n / 2;
stack = (octet*)(V + 2 * n);
// загрузить e
wwFrom(e, id_privkey, no);
if (wwCmp(e, ec->order, n) >= 0)
{
blobClose(state);
return ERR_BAD_PRIVKEY;
}
// сгенерировать k с помощью rng
if (!zzRandNZMod(k, ec->order, n, rng, rng_state))
{
blobClose(state);
return ERR_BAD_RNG;
}
// V <- k G
if (!ecMulA(V, ec->base, ec, k, n, stack))
{
blobClose(state);
return ERR_BAD_PARAMS;
}
qrTo((octet*)V, ecX(V), ec->f, stack);
// s0 <- belt-hash(oid || V || H0 || H) mod 2^l
beltHashStart(stack);
beltHashStepH(oid_der, oid_len, stack);
beltHashStepH(V, no, stack);
beltHashStepH(id_hash, no, stack);
beltHashStepH(hash, no, stack);
beltHashStepG2(id_sig, no / 2, stack);
wwFrom(s0, id_sig, no / 2);
// V <- (s0 + 2^l) e
zzMul(V, s0, n / 2, e, n, stack);
V[n + n / 2] = zzAdd(V + n / 2, V + n / 2, e, n);
// s1 <- V mod q
zzMod(s1, V, n + n / 2 + 1, ec->order, n, stack);
// s1 <- (k - s1 - H) mod q
zzSubMod(s1, k, s1, ec->order, n);
wwFrom(k, hash, no);
zzSubMod(s1, s1, k, ec->order, n);
// выгрузить s1
wwTo(id_sig + no / 2, no, s1);
// все нормально
blobClose(state);
return ERR_OK;
} | 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, %eax
je 0x2a2e1
movq %r15, 0x30(%rsp)
movl $0x12d, %r15d # imm = 0x12D
cmpq $-0x1, %r13
je 0x2a302
xorl %edi, %edi
movq %r12, %rsi
movq %r13, %rdx
callq 0xe710
cmpq $-0x1, %rax
je 0x2a302
cmpq $0x0, 0x98(%rsp)
je 0x2a2e9
movq (%rbx), %rdi
leaq 0x309(%rip), %rsi # 0x2a324
callq 0xf410
movq %rax, %rdi
callq 0xf190
testq %rax, %rax
je 0x2a2f1
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0xf290
movq %r15, %rbx
movl %eax, %r15d
testl %eax, %eax
jne 0x2a2fa
movq %rbx, 0x18(%rsp)
movq 0x18(%rbx), %rax
movq 0x30(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x38(%rax), %rbx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0xeeb0
pushq $0x6d
popq %r15
testl %eax, %eax
je 0x2a2f5
movq %r14, %rdi
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x2a2f5
movq 0x90(%rsp), %rdi
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x2a2f5
movq %rbx, %rax
shrq %rax
movq %rax, 0x48(%rsp)
leaq (%rax,%rbx), %rsi
movq 0x30(%rsp), %rdi
callq 0xeeb0
testl %eax, %eax
movq %rbx, %rax
movq 0x18(%rsp), %rbx
je 0x2a2fa
movq (%rbx), %r15
addq %rbx, %r15
movq %r15, %rdi
movq 0x90(%rsp), %rsi
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdx
callq 0xf540
movq 0x38(%rbx), %rsi
movq %r15, 0x20(%rsp)
movq %r15, %rdi
movq 0x10(%rsp), %rdx
callq 0xf1b0
movl $0x1f8, %r15d # imm = 0x1F8
testl %eax, %eax
jns 0x2a2fa
movq 0xa0(%rsp), %r8
movq 0x10(%rsp), %r15
movq 0x20(%rsp), %rax
leaq (%rax,%r15,8), %rdi
movq 0x38(%rbx), %rsi
movq %rdi, 0x40(%rsp)
movq %r15, %rdx
movq 0x98(%rsp), %rcx
callq 0xfc40
testl %eax, %eax
je 0x2a314
movq 0x40(%rsp), %rcx
leaq (%rcx,%r15,8), %rdi
movq %r15, %r8
shlq $0x4, %r15
addq %rdi, %r15
movq 0x30(%rbx), %rsi
movq %rdi, 0x8(%rsp)
movq %rbx, %rdx
movq %r15, %r9
callq 0xff30
testl %eax, %eax
je 0x2a31c
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rdi
leaq (%rdi,%rcx,8), %rax
shrq %rcx
movq %rcx, 0x50(%rsp)
leaq (%rax,%rcx,8), %rax
movq %rax, 0x38(%rsp)
movq 0x18(%rbx), %rdx
movq %rdi, %rsi
movq %r15, %rcx
callq *0x48(%rdx)
movq %r15, %rdi
callq 0xe5d0
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xe360
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %r12
movq %r12, %rsi
movq %r15, %rdx
callq 0xe360
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xe360
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xe360
movq 0x30(%rsp), %r12
movq %r12, %rdi
movq 0x48(%rsp), %r13
movq %r13, %rsi
movq %r15, %rdx
callq 0xfa20
movq 0x38(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xf540
movq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq 0x38(%rsp), %rsi
movq 0x50(%rsp), %r13
movq %r13, %rdx
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %r12
movq %r12, %r8
movq %r15, %r9
callq 0xe240
leaq (,%r13,8), %rdi
addq %rbp, %rdi
movq %rdi, %rsi
movq 0x20(%rsp), %rbp
movq %rbp, %rdx
movq %r12, %rcx
callq 0xf610
movq %r12, %r8
leaq (%r12,%r13), %rcx
movq 0x8(%rsp), %rsi
movq %rax, (%rsi,%rcx,8)
leaq 0x1(%r13,%r12), %rdx
movq 0x38(%rbx), %rcx
movq %rbp, %rdi
movq %r15, %r9
callq 0xfc00
movq 0x38(%rbx), %rcx
movq %rbp, %rdi
movq 0x40(%rsp), %r15
movq %r15, %rsi
movq %rbp, %rdx
movq %r12, %r8
callq 0xec10
movq %r15, %rdi
movq %r14, %rsi
movq 0x28(%rsp), %r14
movq %r14, %rdx
callq 0xf540
movq 0x38(%rbx), %rcx
movq %rbp, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %r12, %r8
callq 0xec10
movq 0x30(%rsp), %rdi
addq 0x48(%rsp), %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0xf300
xorl %r15d, %r15d
jmp 0x2a2fa
pushq $0x6d
popq %r15
jmp 0x2a302
movl $0x1f6, %r15d # imm = 0x1F6
jmp 0x2a302
movl $0x130, %r15d # imm = 0x130
jmp 0x2a302
pushq $0x6e
jmp 0x2a2dd
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0xe920
movl %r15d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x130, %r15d # imm = 0x130
jmp 0x2a2fa
movl $0x1f6, %r15d # imm = 0x1F6
jmp 0x2a2fa
| /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; /* описание эллиптической кривой */
word* R; /* [2n] открытый ключ R */
word* Q; /* [2n] открытый ключ Q */
word* V; /* [2n] точка V (V == R) */
word* s0; /* [n / 2 + 1] первая часть подписи */
word* s1; /* [n] вторая часть подписи */
word* t; /* [n / 2] переменная t */
word* t1; /* [n + 1] произведение (s0 + 2^l)(t + 2^l) */
octet* hash_state; /* [beltHash_keep] состояние хэширования */
octet* stack;
// проверить params
if (!memIsValid(params, sizeof(bign_params)))
return ERR_BAD_INPUT;
if (!bignIsOperable(params))
return ERR_BAD_PARAMS;
// проверить oid_der
if (oid_len == SIZE_MAX || oidFromDER(0, oid_der, oid_len) == SIZE_MAX)
return ERR_BAD_OID;
// создать состояние
state = blobCreate(bignStart_keep(params->l, bignIdVerify_deep));
if (state == 0)
return ERR_OUTOFMEMORY;
// старт
code = bignStart(state, params);
ERR_CALL_HANDLE(code, blobClose(state));
ec = (ec_o*)state;
// размерности
no = ec->f->no;
n = ec->f->n;
ASSERT(n % 2 == 0);
// проверить входные указатели
if (!memIsValid(id_hash, no) ||
!memIsValid(hash, no) ||
!memIsValid(id_sig, no + no / 2) ||
!memIsValid(id_pubkey, 2 * no) ||
!memIsValid(pubkey, 2 * no))
{
blobClose(state);
return ERR_BAD_INPUT;
}
// раскладка состояния
R = V = objEnd(ec, word);
Q = R + 2 * n;
s0 = Q + 2 * n;
s1 = s0 + n / 2 + 1;
t = s1 + n;
t1 = t + n / 2;
hash_state = (octet*)(t1 + n + 1);
stack = hash_state + beltHash_keep();
// загрузить R
if (!qrFrom(ecX(R), id_pubkey, ec->f, stack) ||
!qrFrom(ecY(R, n), id_pubkey + no, ec->f, stack) ||
!ecpIsOnA(R, ec, stack))
{
blobClose(state);
return ERR_BAD_PUBKEY;
}
// загрузить Q
if (!qrFrom(ecX(Q), pubkey, ec->f, stack) ||
!qrFrom(ecY(Q, n), pubkey + no, ec->f, stack))
{
blobClose(state);
return ERR_BAD_PUBKEY;
}
// загрузить и проверить s1
wwFrom(s1, id_sig + no / 2, no);
if (wwCmp(s1, ec->order, n) >= 0)
{
blobClose(state);
return ERR_BAD_SIG;
}
// s1 <- (s1 + H) mod q
wwFrom(t, hash, no);
if (wwCmp(t, ec->order, n) >= 0)
{
zzSub2(t, ec->order, n);
// 2^{l - 1} < q < 2^l, H < 2^l => H - q < q
ASSERT(wwCmp(t, ec->order, n) < 0);
}
zzAddMod(s1, s1, t, ec->order, n);
// загрузить s0
wwFrom(s0, id_sig, no / 2);
s0[n / 2] = 1;
// belt-hash(oid...)
beltHashStart(hash_state);
beltHashStepH(oid_der, oid_len, hash_state);
// t <- belt-hash(oid || R || H0) mod 2^l
memCopy(stack, hash_state, beltHash_keep());
beltHashStepH(id_pubkey, no, stack);
beltHashStepH(id_hash, no, stack);
beltHashStepG2((octet*)t, no / 2, stack);
wwFrom(t, t, no / 2);
// t1 <- -(t + 2^l)(s0 + 2^l) mod q
zzMul(t1, t, n / 2, s0, n / 2, stack);
t1[n] = zzAdd2(t1 + n / 2, t, n / 2);
t1[n] += zzAdd2(t1 + n / 2, s0, n / 2);
++t1[n];
zzMod(t1, t1, n + 1, ec->order, n, stack);
zzNegMod(t1, t1, ec->order, n);
// V <- s1 G + (s0 + 2^l) R + t Q
if (!ecAddMulA(V, ec, stack,
3, ec->base, s1, n, R, s0, n / 2 + 1, Q, t1, n))
{
blobClose(state);
return ERR_BAD_SIG;
}
qrTo((octet*)V, ecX(V), ec->f, stack);
// s0 == belt-hash(oid || V || H0 || H) mod 2^l?
beltHashStepH(V, no, hash_state);
beltHashStepH(id_hash, no, hash_state);
beltHashStepH(hash, no, hash_state);
code = beltHashStepV2(id_sig, no / 2, hash_state) ? ERR_OK : ERR_BAD_SIG;
// завершение
blobClose(state);
return code;
} | 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
movq %rbp, 0x48(%rsp)
movl $0x12d, %ebp # imm = 0x12D
cmpq $-0x1, %r13
je 0x2ab61
xorl %edi, %edi
movq %r15, %rsi
movq %r13, %rdx
callq 0xe710
cmpq $-0x1, %rax
je 0x2ab61
movq (%rbx), %rdi
leaq 0x4c8(%rip), %rsi # 0x2add8
callq 0xf410
movq %rax, %rdi
callq 0xf190
testq %rax, %rax
je 0x2ab72
movq %rax, %rbp
movq %rax, %rdi
movq %rbx, %rsi
callq 0xf290
movq %rbp, %rbx
movl %eax, %ebp
testl %eax, %eax
jne 0x2ab4d
movq %rbx, 0x10(%rsp)
movq 0x18(%rbx), %rax
movq 0x30(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x38(%rax), %rbx
movq %r12, %rdi
movq %rbx, %rsi
callq 0xeeb0
pushq $0x6d
popq %rbp
testl %eax, %eax
je 0x2ab48
movq %r14, %rdi
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x2ab48
movq %rbx, %rax
shrq %rax
movq %rax, 0x38(%rsp)
leaq (%rax,%rbx), %rsi
movq 0x48(%rsp), %rdi
callq 0xeeb0
testl %eax, %eax
je 0x2ab48
movq 0xb0(%rsp), %rdi
movq %rbx, 0x28(%rsp)
addq %rbx, %rbx
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x2ab48
movq 0xb8(%rsp), %rdi
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
movq 0x10(%rsp), %rbx
je 0x2ab4d
movq (%rbx), %rbp
addq %rbx, %rbp
movq 0x8(%rsp), %rdx
movq %rdx, %rax
shlq $0x4, %rax
leaq (%rax,%rbp), %rcx
movq %rcx, 0x58(%rsp)
addq %rcx, %rax
movq %rdx, %rcx
shrq %rcx
movq %rax, 0x30(%rsp)
leaq (%rax,%rcx,8), %rax
leaq (%rax,%rdx,8), %rax
addq $0x8, %rax
movq %rcx, 0x20(%rsp)
movq %rax, 0x18(%rsp)
leaq (%rax,%rcx,8), %rax
movq %rax, 0x68(%rsp)
leaq (%rax,%rdx,8), %rax
movq %rax, (%rsp)
xorl %eax, %eax
callq 0xe560
movq (%rsp), %rcx
addq %rax, %rcx
addq $0x8, %rcx
movq 0x18(%rbx), %rdx
movq %rbp, 0x40(%rsp)
movq %rbp, %rdi
movq 0xb0(%rsp), %rsi
movq %rcx, (%rsp)
callq *0x40(%rdx)
movl $0x1f9, %ebp # imm = 0x1F9
testl %eax, %eax
je 0x2ab4d
movq 0x18(%rbx), %rdx
movq 0x40(%rsp), %rax
movq 0x8(%rsp), %rcx
leaq (%rax,%rcx,8), %rdi
movq 0x28(%rsp), %rax
movq 0xb0(%rsp), %rcx
leaq (%rcx,%rax), %rsi
movq (%rsp), %rcx
callq *0x40(%rdx)
testl %eax, %eax
je 0x2ab4d
movq 0x40(%rsp), %rdi
movq %rbx, %rsi
movq (%rsp), %rdx
callq 0xfbd0
testl %eax, %eax
je 0x2ab4d
movq 0x18(%rbx), %rdx
movq 0x58(%rsp), %rdi
movq 0xb8(%rsp), %rsi
movq (%rsp), %rcx
callq *0x40(%rdx)
testl %eax, %eax
je 0x2ab4d
movq 0x18(%rbx), %rdx
movq 0x8(%rsp), %rax
movq 0x58(%rsp), %rcx
leaq (%rcx,%rax,8), %rdi
movq 0xb8(%rsp), %rsi
addq 0x28(%rsp), %rsi
movq (%rsp), %rcx
callq *0x40(%rdx)
testl %eax, %eax
je 0x2ab4d
movq 0x30(%rsp), %rax
movq 0x20(%rsp), %rcx
leaq (%rax,%rcx,8), %rbp
addq $0x8, %rbp
movq 0x48(%rsp), %rax
movq 0x38(%rsp), %rcx
leaq (%rax,%rcx), %rsi
movq %rbp, %rdi
movq 0x28(%rsp), %rdx
callq 0xf540
movq 0x38(%rbx), %rsi
movq %rbp, 0x60(%rsp)
movq %rbp, %rdi
movq 0x8(%rsp), %rbx
movq %rbx, %rdx
callq 0xf1b0
movl $0x1fe, %ebp # imm = 0x1FE
testl %eax, %eax
js 0x2ab76
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0xe920
jmp 0x2ab61
pushq $0x6d
popq %rbp
jmp 0x2ab61
movl $0x1f6, %ebp # imm = 0x1F6
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x6e
jmp 0x2ab59
movq 0x68(%rsp), %rax
leaq (%rax,%rbx,8), %rax
addq $0x8, %rax
movq %rax, 0x50(%rsp)
movq 0x18(%rsp), %rdi
movq %r14, %rsi
movq 0x28(%rsp), %rdx
callq 0xf540
movq %rbx, %rdx
movq 0x10(%rsp), %rbx
movq 0x38(%rbx), %rsi
movq 0x18(%rsp), %rdi
callq 0xf1b0
testl %eax, %eax
js 0x2abc7
movq 0x38(%rbx), %rsi
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
callq 0xee10
movq 0x38(%rbx), %rcx
movq 0x60(%rsp), %rdi
movq %rdi, %rsi
movq 0x18(%rsp), %rdx
movq 0x8(%rsp), %r8
callq 0xfff0
movq 0x30(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0xf540
movq 0x30(%rsp), %rax
movq 0x20(%rsp), %rcx
movq $0x1, (%rax,%rcx,8)
movq 0x50(%rsp), %rdi
callq 0xe5d0
movq %r15, %rdi
movq %r13, %rsi
movq 0x50(%rsp), %r13
movq %r13, %rdx
callq 0xe360
xorl %eax, %eax
callq 0xe560
movq (%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xe970
movq 0xb0(%rsp), %rdi
movq 0x28(%rsp), %r13
movq %r13, %rsi
movq %r15, %rdx
callq 0xe360
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xe360
movq 0x18(%rsp), %r13
movq %r13, %rdi
movq 0x38(%rsp), %rsi
movq %r15, %rdx
callq 0xfa20
movq %r13, %rdi
movq %r13, %rsi
movq 0x38(%rsp), %rdx
callq 0xf540
movq 0x68(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
movq 0x20(%rsp), %rdx
movq 0x30(%rsp), %r13
movq %r13, %rcx
movq %rdx, %r8
movq (%rsp), %r9
callq 0xe240
movq 0x20(%rsp), %rdx
leaq (%r15,%rdx,8), %rdi
movq %rdi, 0x70(%rsp)
movq 0x18(%rsp), %rsi
callq 0xe1a0
movq 0x8(%rsp), %rcx
movq %rax, (%r15,%rcx,8)
movq 0x70(%rsp), %rdi
movq %r13, %rsi
movq 0x20(%rsp), %rdx
callq 0xe1a0
movq 0x8(%rsp), %r13
movq (%r15,%r13,8), %rcx
addq %rcx, %rax
incq %rax
movq %rax, (%r15,%r13,8)
leaq 0x1(%r13), %rdx
movq 0x38(%rbx), %rcx
movq %r15, %rdi
movq %r15, %rsi
movq %r13, %r8
movq (%rsp), %r9
callq 0xfc00
movq 0x38(%rbx), %rdx
movq %r15, %rdi
movq %r15, %rsi
movq %r13, %rcx
callq 0xf780
movq 0x30(%rbx), %r8
movq 0x20(%rsp), %r10
incq %r10
subq $0x8, %rsp
pushq $0x3
popq %rcx
movq 0x48(%rsp), %rdi
movq %rbx, %rsi
movq 0x8(%rsp), %rdx
movq 0x68(%rsp), %r9
xorl %eax, %eax
pushq %r13
pushq %r15
pushq 0x70(%rsp)
pushq %r10
pushq 0x58(%rsp)
pushq %rdi
pushq %r13
callq 0xe220
addq $0x40, %rsp
testl %eax, %eax
je 0x2ab4d
movq 0x18(%rbx), %rdx
movq 0x40(%rsp), %r13
movq %r13, %rdi
movq %r13, %rsi
movq (%rsp), %rcx
callq *0x48(%rdx)
movq %r13, %rdi
movq 0x28(%rsp), %r13
movq %r13, %rsi
movq 0x50(%rsp), %r15
movq %r15, %rdx
callq 0xe360
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xe360
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xe360
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq %r15, %rdx
callq 0xe3a0
testl %eax, %eax
movl $0x1fe, %eax # imm = 0x1FE
movl $0x0, %ebp
cmovel %eax, %ebp
jmp 0x2ab4d
| /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, %rsi
callq 0xf530
movq %rax, %rbp
movq %r14, %r15
shrq %r15
movq %r15, %rdi
movq %r15, %rsi
callq 0xfe10
movq %rax, %r12
leaq 0x1(%r14), %rdi
movq %r14, %rsi
callq 0xe7f0
movq %rax, %r13
incq %r15
movq %r14, (%rsp)
pushq $0x3
popq %rcx
movq %r14, %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %r14, %r8
movq %r15, %r9
xorl %eax, %eax
callq 0xec00
pushq $0x5
popq %rdi
movq 0x10(%rsp), %rsi
movq %rbp, %rdx
movq %r12, %rcx
movq %r13, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0xe320
addq %rbx, %rax
addq $0x10, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
| /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] одноразовый личный ключ */
word* R; /* [2n] точка R */
octet* theta; /* [32] ключ защиты */
octet* stack;
// проверить params
if (!memIsValid(params, sizeof(bign_params)))
return ERR_BAD_INPUT;
if (!bignIsOperable(params))
return ERR_BAD_PARAMS;
// проверить rng
if (rng == 0)
return ERR_BAD_RNG;
// проверить header и key
if (len < 16 ||
!memIsValid(key, len) ||
!memIsNullOrValid(header, 16))
return ERR_BAD_INPUT;
// создать состояние
state = blobCreate(bignStart_keep(params->l, bignKeyWrap_deep));
if (state == 0)
return ERR_OUTOFMEMORY;
// старт
code = bignStart(state, params);
ERR_CALL_HANDLE(code, blobClose(state));
ec = (ec_o*)state;
// размерности
no = ec->f->no;
n = ec->f->n;
// проверить входные указатели
if (!memIsValid(pubkey, 2 * no) ||
!memIsValid(token, 16 + no + len))
{
blobClose(state);
return ERR_BAD_INPUT;
}
// раскладка состояния
k = objEnd(ec, word);
R = k + n;
theta = (octet*)(R + 2 * n);
stack = theta + 32;
// сгенерировать k
if (!zzRandNZMod(k, ec->order, n, rng, rng_state))
{
blobClose(state);
return ERR_BAD_RNG;
}
// R <- k Q
if (!qrFrom(ecX(R), pubkey, ec->f, stack) ||
!qrFrom(ecY(R, n), pubkey + no, ec->f, stack))
{
blobClose(state);
return ERR_BAD_PUBKEY;
}
if (!ecMulA(R, R, ec, k, n, stack))
{
blobClose(state);
return ERR_BAD_PARAMS;
}
// theta <- <R>_{256}
qrTo(theta, ecX(R), ec->f, stack);
// R <- k G
if (!ecMulA(R, ec->base, ec, k, n, stack))
{
blobClose(state);
return ERR_BAD_PARAMS;
}
qrTo((octet*)R, ecX(R), ec->f, stack);
// сформировать блок для шифрования
// (буферы key, header и token могут пересекаться)
if (header)
memCopy(R + n, header, 16);
else
memSetZero(R + n, 16);
memMove(token + no, key, len);
memCopy(token + no + len, R + n, 16);
// зашифровать
beltKWPStart(stack, theta, 32);
beltKWPStepE(token + no, len + 16, stack);
// доопределить токен
memCopy(token, R, no);
// все нормально
blobClose(state);
return ERR_OK;
} | 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
callq 0x101d0
testl %eax, %eax
je 0x2af53
cmpq $0x0, 0x80(%rsp)
je 0x2af5a
cmpq $0x10, %r14
jb 0x2af5f
movq %r15, %rdi
movq %r14, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x2af5f
testq %r12, %r12
je 0x2af16
pushq $0x10
popq %rsi
movq %r12, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x2af5f
movq (%rbx), %rdi
leaq 0x271(%rip), %rsi # 0x2b191
callq 0xf410
movq %rax, %rdi
callq 0xf190
testq %rax, %rax
je 0x2af70
movq %rax, %rbp
movq %rax, %rdi
movq %rbx, %rsi
callq 0xf290
movq %rbp, %rbx
movl %eax, %ebp
testl %eax, %eax
je 0x2af75
movq %rbx, %rdi
callq 0xe920
jmp 0x2af5f
movl $0x1f6, %ebp # imm = 0x1F6
jmp 0x2af5f
movl $0x130, %ebp # imm = 0x130
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x6e
popq %rbp
jmp 0x2af5f
movq %rbx, 0x28(%rsp)
movq 0x18(%rbx), %rax
movq 0x30(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x38(%rax), %rbx
leaq (%rbx,%rbx), %rsi
movq %r13, %rdi
callq 0xeeb0
pushq $0x6d
popq %rbp
testl %eax, %eax
je 0x2b187
movq %rbx, 0x20(%rsp)
leaq (%r14,%rbx), %rsi
addq $0x10, %rsi
movq 0x40(%rsp), %rdi
callq 0xeeb0
testl %eax, %eax
movq 0x28(%rsp), %rbx
je 0x2af49
movq 0x88(%rsp), %r8
movq (%rbx), %rbp
addq %rbx, %rbp
movq 0x38(%rbx), %rsi
movq %rbp, %rdi
movq 0x8(%rsp), %rdx
movq 0x80(%rsp), %rcx
callq 0xfc40
testl %eax, %eax
je 0x2b10b
movq %rbp, 0x38(%rsp)
movq 0x8(%rsp), %rcx
leaq (,%rcx,8), %rdi
addq %rbp, %rdi
movq %rcx, %rax
movq %rcx, %rbp
shlq $0x4, %rax
movq %rax, 0x10(%rsp)
leaq (%rax,%rdi), %rcx
addq $0x20, %rcx
movq 0x18(%rbx), %rdx
movq %rdi, 0x18(%rsp)
movq %r13, %rsi
movq %rcx, (%rsp)
callq *0x40(%rdx)
movq %rbp, %rcx
movl $0x1f9, %ebp # imm = 0x1F9
testl %eax, %eax
je 0x2af49
movq 0x18(%rbx), %rdx
movq 0x18(%rsp), %rax
leaq (%rax,%rcx,8), %rdi
addq 0x20(%rsp), %r13
movq %rdi, 0x30(%rsp)
movq %r13, %rsi
movq (%rsp), %rcx
callq *0x40(%rdx)
testl %eax, %eax
movq 0x18(%rsp), %r13
je 0x2af49
movq %r13, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq 0x38(%rsp), %rcx
movq 0x8(%rsp), %r8
movq (%rsp), %r9
callq 0xff30
movl $0x1f6, %ebp # imm = 0x1F6
testl %eax, %eax
je 0x2af49
movq 0x10(%rsp), %rdi
addq %r13, %rdi
movq 0x18(%rbx), %rdx
movq %rdi, 0x10(%rsp)
movq %r13, %rsi
movq (%rsp), %rcx
callq *0x48(%rdx)
movq 0x30(%rbx), %rsi
movq %r13, %rdi
movq %rbx, %rdx
movq 0x38(%rsp), %rcx
movq 0x8(%rsp), %r8
movq (%rsp), %r9
callq 0xff30
testl %eax, %eax
je 0x2af49
leaq 0x10(%r14), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rbx), %rdx
movq %r13, %rdi
movq %r13, %rsi
movq (%rsp), %rcx
callq *0x48(%rdx)
pushq $0x10
popq %rdx
testq %r12, %r12
je 0x2b115
movq 0x30(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0xe970
jmp 0x2b124
movl $0x130, %ebp # imm = 0x130
jmp 0x2af49
movq 0x30(%rsp), %rbp
movq %rbp, %rdi
xorl %esi, %esi
callq 0xf710
movq 0x20(%rsp), %rbx
movq 0x40(%rsp), %r13
leaq (%rbx,%r13), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xe130
addq %r12, %r14
pushq $0x10
popq %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0xe970
pushq $0x20
popq %rdx
movq (%rsp), %r14
movq %r14, %rdi
movq 0x10(%rsp), %rsi
callq 0xf570
movq %r12, %rdi
movq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0xf910
movq %r13, %rdi
movq 0x18(%rsp), %rsi
movq %rbx, %rdx
callq 0xe970
xorl %ebp, %ebp
movq 0x28(%rsp), %rbx
jmp 0x2af49
| /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* R; /* [2n] точка R */
word* t1; /* [n] вспомогательное число */
word* t2; /* [n] вспомогательное число */
octet* theta; /* [32] ключ защиты */
octet* header2; /* [16] заголовок2 */
void* stack; /* граница стека */
// проверить params
if (!memIsValid(params, sizeof(bign_params)))
return ERR_BAD_INPUT;
if (!bignIsOperable(params))
return ERR_BAD_PARAMS;
// проверить token и header
if (!memIsValid(token, len) ||
!memIsNullOrValid(header, 16))
return ERR_BAD_INPUT;
// создать состояние
state = blobCreate(bignStart_keep(params->l, bignKeyUnwrap_deep));
if (state == 0)
return ERR_OUTOFMEMORY;
// старт
code = bignStart(state, params);
ERR_CALL_HANDLE(code, blobClose(state));
ec = (ec_o*)state;
// размерности
no = ec->f->no;
n = ec->f->n;
// проверить длину токена
if (len < 32 + no)
{
blobClose(state);
return ERR_BAD_KEYTOKEN;
}
// проверить входные указатели
if (!memIsValid(privkey, no) ||
!memIsValid(key, len - 16 - no))
{
blobClose(state);
return ERR_BAD_INPUT;
}
// раскладка состояния
d = objEnd(ec, word);
R = d + n;
t1 = R + 2 * n;
t2 = t1 + n;
theta = (octet*)d;
header2 = theta + 32;
if (5 * no >= 48)
stack = t2 + n;
else
stack = header2 + 16;
// загрузить d
wwFrom(d, privkey, no);
if (wwIsZero(d, n) || wwCmp(d, ec->order, n) >= 0)
{
blobClose(state);
return ERR_BAD_PRIVKEY;
}
// xR <- x
if (!qrFrom(R, token, ec->f, stack))
{
blobClose(state);
return ERR_BAD_KEYTOKEN;
}
// t1 <- x^3 + a x + b
qrSqr(t1, R, ec->f, stack);
zmAdd(t1, t1, ec->A, ec->f);
qrMul(t1, t1, R, ec->f, stack);
zmAdd(t1, t1, ec->B, ec->f);
// yR <- t1^{(p + 1) / 4}
wwCopy(R + n, ec->f->mod, n);
zzAddW2(R + n, n, 1);
wwShLo(R + n, n, 2);
qrPower(R + n, t1, R + n, n, ec->f, stack);
// t2 <- yR^2
qrSqr(t2, R + n, ec->f, stack);
// (xR, yR) на кривой? t1 == t2?
if (!wwEq(t1, t2, n))
{
blobClose(state);
return ERR_BAD_KEYTOKEN;
}
// R <- d R
if (!ecMulA(R, R, ec, d, n, stack))
{
blobClose(state);
return ERR_BAD_PARAMS;
}
// theta <- <R>_{256}
qrTo(theta, ecX(R), ec->f, stack);
// сформировать данные для расшифрования
memCopy(key, token + no, len - no - 16);
memCopy(header2, token + len - 16, 16);
// расшифровать
beltKWPStart(stack, theta, 32);
beltKWPStepD2(key, header2, len - no, stack);
// проверить целостность
if (header && !memEq(header, header2, 16) ||
header == 0 && !memIsZero(header2, 16))
{
memSetZero(key, len - no - 16);
code = ERR_BAD_KEYTOKEN;
}
// завершение
blobClose(state);
return code;
} | 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
callq 0x101d0
testl %eax, %eax
je 0x2b2a0
movq %r13, %rdi
movq %r12, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x2b37c
testq %r14, %r14
je 0x2b246
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x2b37c
movq (%rbx), %rdi
leaq 0x376(%rip), %rsi # 0x2b5c6
callq 0xf410
movq %rax, %rdi
callq 0xf190
testq %rax, %rax
je 0x2b2ab
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xf290
movq 0x8(%rsp), %rdi
movl %eax, %r15d
testl %eax, %eax
jne 0x2b377
movq 0x18(%rdi), %rax
movq 0x38(%rax), %rbx
leaq 0x20(%rbx), %rcx
cmpq %r12, %rcx
jbe 0x2b2b4
movl $0x201, %r15d # imm = 0x201
jmp 0x2b377
movl $0x1f6, %r15d # imm = 0x1F6
jmp 0x2b37c
pushq $0x6e
popq %r15
jmp 0x2b37c
movq 0x30(%rax), %rax
movq %rax, 0x18(%rsp)
movq %rbp, %rdi
movq %rbx, %rsi
callq 0xeeb0
pushq $0x6d
popq %r15
testl %eax, %eax
je 0x2b372
movq %r12, %rax
subq %rbx, %rax
movq %rax, 0x60(%rsp)
movq %rbx, 0x40(%rsp)
leaq -0x10(%rax), %rbx
movq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
movq 0x8(%rsp), %rdi
je 0x2b377
movq %rbx, 0x38(%rsp)
movq (%rdi), %rsi
leaq (%rdi,%rsi), %rcx
movq 0x18(%rsp), %r15
leaq (%rcx,%r15,8), %rax
movq %r15, %rbx
shlq $0x4, %rbx
movq %rax, 0x10(%rsp)
addq %rax, %rbx
leaq (%rbx,%r15,8), %r8
movq 0x40(%rsp), %rdx
leaq (%rdx,%rdx,4), %rax
cmpq $0x30, %rax
movq %r8, 0x58(%rsp)
leaq (%r8,%r15,8), %rax
movq %rsi, 0x50(%rsp)
leaq 0x30(%rdi,%rsi), %rsi
cmovaeq %rax, %rsi
movq %rsi, 0x28(%rsp)
movq %rcx, %rdi
movq %rbp, %rsi
movq %rcx, %rbp
callq 0xf540
movq %rbp, %rdi
movq %r15, %rsi
callq 0xffc0
movl $0x1f8, %r15d # imm = 0x1F8
testl %eax, %eax
je 0x2b38e
movq 0x8(%rsp), %rdi
callq 0xe920
movl %r15d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, 0x20(%rsp)
movq 0x8(%rsp), %rbx
movq 0x38(%rbx), %rsi
movq %rbp, %rdi
movq 0x18(%rsp), %rdx
callq 0xf1b0
testl %eax, %eax
movq %rbx, %rdi
jns 0x2b377
movq %rbp, 0x48(%rsp)
movq 0x18(%rdi), %rdx
movq %rdi, %rbp
movq 0x10(%rsp), %rdi
movq %r13, %rsi
movq 0x28(%rsp), %r15
movq %r15, %rcx
callq *0x40(%rdx)
testl %eax, %eax
je 0x2b57d
movq 0x18(%rbp), %rdx
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movq %r15, %rcx
callq *0x70(%rdx)
movq 0x18(%rbp), %rax
movq 0x20(%rbp), %rdx
movq 0x18(%rax), %rcx
movq 0x30(%rax), %r8
movq %rbx, %rdi
movq %rbx, %rsi
callq 0xfff0
movq 0x18(%rbp), %rcx
movq %rbx, %rdi
movq %rbx, %rsi
movq 0x10(%rsp), %rdx
movq %r15, %r8
callq *0x68(%rcx)
movq 0x18(%rbp), %rax
movq 0x28(%rbp), %rdx
movq 0x18(%rax), %rcx
movq 0x30(%rax), %r8
movq %rbx, %rdi
movq %rbx, %rsi
callq 0xfff0
movq 0x18(%rsp), %rbx
movq 0x10(%rsp), %rax
leaq (%rax,%rbx,8), %r15
movq 0x18(%rbp), %rax
movq 0x18(%rax), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0xe5c0
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xeb00
pushq $0x2
popq %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xf9a0
movq 0x18(%rbp), %r8
movq %r15, %rdi
movq 0x20(%rsp), %rsi
movq %r15, %rdx
movq %rbx, %rcx
movq 0x28(%rsp), %r9
callq 0xf6f0
movq 0x18(%rbp), %rdx
movq 0x58(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
movq %rbx, %r15
movq 0x28(%rsp), %rbx
movq %rbx, %rcx
callq *0x70(%rdx)
movq 0x20(%rsp), %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0xf520
testl %eax, %eax
je 0x2b5bb
movq 0x10(%rsp), %rdi
movq %rdi, %rsi
movq 0x8(%rsp), %rbp
movq %rbp, %rdx
movq %r15, %r8
movq 0x48(%rsp), %r15
movq %r15, %rcx
movq %rbx, %r9
callq 0xff30
testl %eax, %eax
je 0x2b585
movq 0x50(%rsp), %rax
addq %rbp, %rax
addq $0x20, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rbp), %rdx
movq %r15, %rdi
movq 0x10(%rsp), %rsi
movq %rbx, %rcx
callq *0x48(%rdx)
movq 0x40(%rsp), %rsi
addq %r13, %rsi
movq 0x30(%rsp), %rbp
movq %rbp, %rdi
movq 0x38(%rsp), %rdx
callq 0xe970
leaq (%r12,%r13), %rsi
addq $-0x10, %rsi
pushq $0x10
popq %rdx
movq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0xe970
pushq $0x20
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf570
movq %rbp, %rdi
movq %r12, %rsi
movq 0x60(%rsp), %rdx
movq %rbx, %rcx
callq 0xeb80
testq %r14, %r14
je 0x2b593
pushq $0x10
popq %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0xf140
jmp 0x2b59e
movl $0x201, %r15d # imm = 0x201
jmp 0x2b58b
movl $0x1f6, %r15d # imm = 0x1F6
movq %rbp, %rdi
jmp 0x2b377
pushq $0x10
popq %rsi
movq %r12, %rdi
callq 0xfe60
testl %eax, %eax
je 0x2b5aa
xorl %r15d, %r15d
jmp 0x2b372
movq 0x30(%rsp), %rdi
xorl %esi, %esi
movq 0x38(%rsp), %rdx
callq 0xf710
movl $0x201, %r15d # imm = 0x201
jmp 0x2b372
| /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 || params->l == 256) &&
(no = O_OF_B(2 * params->l)) &&
params->p[0] % 4 == 3 && params->q[0] % 2 == 1 &&
params->p[no - 1] >= 128 && params->q[no - 1] >= 128 &&
memIsZero(params->p + no, sizeof(params->p) - no) &&
!memIsZero(params->a, no) &&
!memIsZero(params->b, no) &&
memIsZero(params->a + no, sizeof(params->a) - no) &&
memIsZero(params->b + no, sizeof(params->b) - no) &&
memIsZero(params->q + no, sizeof(params->q) - no) &&
memIsZero(params->yG + no, sizeof(params->yG) - no);
} | 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 0x2b6a7
leaq 0x7(,%rax,2), %r15
shrq $0x3, %r15
leaq 0x8(%r14), %rdi
cmpb $0x0, -0x1(%r15,%rdi)
jns 0x2b6a7
leaq 0xc8(%r14), %r13
cmpb $0x0, -0x1(%r13,%r15)
js 0x2b6b8
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq %r15, %rdi
pushq $0x40
popq %r12
subq %r15, %r12
movq %r12, %rsi
callq 0xfe60
testl %eax, %eax
je 0x2b6a7
leaq 0x48(%r14), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0xfe60
testl %eax, %eax
jne 0x2b6a7
leaq 0x88(%r14), %rdi
movq %rdi, (%rsp)
movq %r15, %rsi
callq 0xfe60
testl %eax, %eax
jne 0x2b6a7
addq %r15, %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0xfe60
testl %eax, %eax
je 0x2b6a7
movq (%rsp), %rdi
addq %r15, %rdi
movq %r12, %rsi
callq 0xfe60
testl %eax, %eax
je 0x2b6a7
addq %r15, %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0xfe60
testl %eax, %eax
je 0x2b6a7
leaq (%r14,%r15), %rdi
addq $0x108, %rdi # imm = 0x108
movq %r12, %rsi
callq 0xfe60
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
jmp 0x2b6a7
| /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;
// проверить params
if (!memIsValid(params, sizeof(bign_params)))
return ERR_BAD_INPUT;
if (!bignIsOperable(params))
return ERR_BAD_PARAMS;
// проверить rng
if (rng == 0)
return ERR_BAD_RNG;
// создать состояние
state = blobCreate(bignStart_keep(params->l, bignKeypairGen_deep));
if (state == 0)
return ERR_OUTOFMEMORY;
// старт
code = bignStart(state, params);
ERR_CALL_HANDLE(code, blobClose(state));
ec = (ec_o*)state;
// размерности
no = ec->f->no;
n = ec->f->n;
// проверить входные указатели
if (!memIsValid(privkey, no) || !memIsValid(pubkey, 2 * no))
{
blobClose(state);
return ERR_BAD_INPUT;
}
// раскладка состояния
d = objEnd(ec, word);
Q = d + n;
stack = Q + 2 * n;
// d <-R {1,2,..., q - 1}
if (!zzRandNZMod(d, ec->f->mod, n, rng, rng_state))
{
blobClose(state);
return ERR_BAD_RNG;
}
// Q <- d G
if (ecMulA(Q, ec->base, ec, d, n, stack))
{
// выгрузить ключи
wwTo(privkey, no, d);
qrTo(pubkey, ecX(Q), ec->f, stack);
qrTo(pubkey + no, ecY(Q, n), ec->f, stack);
}
else
code = ERR_BAD_PARAMS;
// завершение
blobClose(state);
return code;
} | 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
testq %r13, %r13
je 0x2b9cb
movq (%rbp), %rdi
leaq 0x146(%rip), %rsi # 0x2bad5
callq 0xf410
movq %rax, %rdi
callq 0xf190
testq %rax, %rax
je 0x2b9e1
movq %rax, %r14
movq %rax, %rdi
movq %rbp, %rsi
callq 0xf290
movl %eax, %ebp
testl %eax, %eax
je 0x2b9e5
movq %r14, %rdi
callq 0xe920
jmp 0x2b9d0
pushq $0x6d
popq %rbp
jmp 0x2b9d0
movl $0x1f6, %ebp # imm = 0x1F6
jmp 0x2b9d0
movl $0x130, %ebp # imm = 0x130
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x6e
jmp 0x2b9c1
movq 0x18(%r14), %rax
movq 0x30(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x38(%rax), %rsi
movq %r15, %rdi
movq %rsi, 0x10(%rsp)
callq 0xeeb0
pushq $0x6d
popq %rbp
testl %eax, %eax
je 0x2b9b5
movq 0x10(%rsp), %rax
leaq (%rax,%rax), %rsi
movq %rbx, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x2b9b5
movq (%r14), %rbp
addq %r14, %rbp
movq 0x18(%r14), %rax
movq 0x18(%rax), %rsi
movq %rbp, %rdi
movq 0x8(%rsp), %rdx
movq %r13, %rcx
movq %r12, %r8
callq 0xfc40
testl %eax, %eax
je 0x2bac1
movq 0x8(%rsp), %r8
leaq (,%r8,8), %r13
addq %rbp, %r13
movq %r8, %r12
shlq $0x4, %r12
addq %r13, %r12
movq 0x30(%r14), %rsi
movq %r13, %rdi
movq %r14, %rdx
movq %rbp, %rcx
movq %r12, %r9
callq 0xff30
testl %eax, %eax
je 0x2bacb
movq %r15, %rdi
movq 0x10(%rsp), %r15
movq %r15, %rsi
movq %rbp, %rdx
callq 0xf300
movq 0x18(%r14), %rdx
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rcx
callq *0x48(%rdx)
movq 0x18(%r14), %rdx
addq %r15, %rbx
movq 0x8(%rsp), %rax
leaq (,%rax,8), %rsi
addq %r13, %rsi
movq %rbx, %rdi
movq %r12, %rcx
callq *0x48(%rdx)
xorl %ebp, %ebp
jmp 0x2b9b5
movl $0x130, %ebp # imm = 0x130
jmp 0x2b9b5
movl $0x1f6, %ebp # imm = 0x1F6
jmp 0x2b9b5
| /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 (!memIsValid(params, sizeof(bign_params)))
return ERR_BAD_INPUT;
if (!bignIsOperable(params))
return ERR_BAD_PARAMS;
// создать состояние
state = blobCreate(bignStart_keep(params->l, bignKeypairVal_deep));
if (state == 0)
return ERR_OUTOFMEMORY;
// старт
code = bignStart(state, params);
ERR_CALL_HANDLE(code, blobClose(state));
ec = (ec_o*)state;
// размерности
no = ec->f->no;
n = ec->f->n;
// проверить входные указатели
if (!memIsValid(privkey, no) || !memIsValid(pubkey, 2 * no))
{
blobClose(state);
return ERR_BAD_INPUT;
}
// раскладка состояния
d = objEnd(ec, word);
Q = d + n;
stack = Q + 2 * n;
// d <- privkey
wwFrom(d, privkey, no);
// 0 < d < q?
wwFrom(Q, params->q, no);
if (wwIsZero(d, n) || wwCmp(d, Q, n) >= 0)
{
blobClose(state);
return ERR_BAD_PRIVKEY;
}
// Q <- d G
if (ecMulA(Q, ec->base, ec, d, n, stack))
{
// Q == pubkey?
wwTo(Q, 2 * no, Q);
if (!memEq(Q, pubkey, 2 * no))
code = ERR_BAD_PUBKEY;
}
else
code = ERR_BAD_PARAMS;
// завершение
blobClose(state);
return code;
} | 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 # 0x2bc9f
callq 0xf410
movq %rax, %rdi
callq 0xf190
testq %rax, %rax
je 0x2bb65
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xf290
movl %eax, %r13d
testl %eax, %eax
je 0x2bb7b
movq %r14, %rdi
callq 0xe920
jmp 0x2bb69
pushq $0x6d
jmp 0x2bb67
movl $0x1f6, %r13d # imm = 0x1F6
jmp 0x2bb69
pushq $0x6e
popq %r13
movl %r13d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r14), %rax
movq 0x30(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x38(%rax), %rbp
movq %r12, %rdi
movq %rbp, %rsi
callq 0xeeb0
pushq $0x6d
popq %r13
testl %eax, %eax
je 0x2bb4f
leaq (,%rbp,2), %rsi
movq %rbx, %rdi
movq %rsi, 0x18(%rsp)
callq 0xeeb0
testl %eax, %eax
je 0x2bb4f
movq %rbp, %rdx
movq %rbp, 0x20(%rsp)
movq (%r14), %rbp
addq %r14, %rbp
movq 0x10(%rsp), %r13
leaq (,%r13,8), %rax
addq %rbp, %rax
movq %rbp, %rdi
movq %r12, %rsi
movq %rax, %r12
callq 0xf540
addq $0xc8, %r15
movq %r12, 0x8(%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %r15
movq 0x20(%rsp), %rdx
callq 0xf540
movq %rbp, %rdi
movq %r13, %rsi
callq 0xffc0
movl $0x1f8, %r13d # imm = 0x1F8
testl %eax, %eax
jne 0x2bb4f
movq %rbp, %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0xf1b0
testl %eax, %eax
jns 0x2bb4f
movq 0x10(%rsp), %r8
movq %r8, %r9
shlq $0x4, %r9
movq 0x8(%rsp), %rdi
addq %rdi, %r9
movq 0x30(%r14), %rsi
movq %r14, %rdx
movq %rbp, %rcx
callq 0xff30
testl %eax, %eax
je 0x2bc94
movq 0x8(%rsp), %r12
movq %r12, %rdi
movq 0x18(%rsp), %r15
movq %r15, %rsi
movq %r12, %rdx
callq 0xf300
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xf140
xorl %ecx, %ecx
testl %eax, %eax
movl $0x1f9, %r13d # imm = 0x1F9
cmovnel %ecx, %r13d
jmp 0x2bb4f
movl $0x1f6, %r13d # imm = 0x1F6
jmp 0x2bb4f
| /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(params, sizeof(bign_params)))
return ERR_BAD_INPUT;
if (!bignIsOperable(params))
return ERR_BAD_PARAMS;
// создать состояние
state = blobCreate(bignStart_keep(params->l, bignPubkeyCalc_deep));
if (state == 0)
return ERR_OUTOFMEMORY;
// старт
code = bignStart(state, params);
ERR_CALL_HANDLE(code, blobClose(state));
ec = (ec_o*)state;
// размерности
no = ec->f->no;
n = ec->f->n;
// проверить входные указатели
if (!memIsValid(privkey, no) || !memIsValid(pubkey, 2 * no))
{
blobClose(state);
return ERR_BAD_INPUT;
}
// раскладка состояния
d = objEnd(ec, word);
Q = d + n;
stack = Q + 2 * n;
// загрузить d
wwFrom(d, privkey, no);
if (wwIsZero(d, n) || wwCmp(d, ec->order, n) >= 0)
{
blobClose(state);
return ERR_BAD_PRIVKEY;
}
// Q <- d G
if (ecMulA(Q, ec->base, ec, d, n, stack))
{
// выгрузить открытый ключ
qrTo(pubkey, ecX(Q), ec->f, stack);
qrTo(pubkey + no, ecY(Q, n), ec->f, stack);
}
else
code = ERR_BAD_PARAMS;
// завершение
blobClose(state);
return code;
} | 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(%rip), %rsi # 0x2bf51
callq 0xf410
movq %rax, %rdi
callq 0xf190
testq %rax, %rax
je 0x2be57
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xf290
movl %eax, %ebp
testl %eax, %eax
je 0x2be6b
movq %r14, %rdi
callq 0xe920
jmp 0x2be5a
pushq $0x6d
jmp 0x2be59
movl $0x1f6, %ebp # imm = 0x1F6
jmp 0x2be5a
pushq $0x6e
popq %rbp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r14), %rax
movq 0x30(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x38(%rax), %r15
movq %r13, %rdi
movq %r15, %rsi
callq 0xeeb0
pushq $0x6d
popq %rbp
testl %eax, %eax
je 0x2be42
leaq (%r15,%r15), %rsi
movq %rbx, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x2be42
movq (%r14), %r12
addq %r14, %r12
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xf540
movq %r12, %rdi
movq 0x8(%rsp), %r13
movq %r13, %rsi
callq 0xffc0
movl $0x1f8, %ebp # imm = 0x1F8
testl %eax, %eax
jne 0x2be42
movq 0x38(%r14), %rsi
movq %r12, %rdi
movq %r13, %rdx
callq 0xf1b0
testl %eax, %eax
jns 0x2be42
movq 0x8(%rsp), %rbp
leaq (%r12,%rbp,8), %rdi
movq %rbp, %r13
shlq $0x4, %r13
addq %rdi, %r13
movq 0x30(%r14), %rsi
movq %rdi, 0x10(%rsp)
movq %r14, %rdx
movq %r12, %rcx
movq %rbp, %r8
movq %r13, %r9
callq 0xff30
testl %eax, %eax
je 0x2bf47
movq 0x18(%r14), %rdx
movq %rbx, %rdi
movq 0x10(%rsp), %r12
movq %r12, %rsi
movq %r13, %rcx
callq *0x48(%rdx)
movq 0x18(%r14), %rdx
addq %rbx, %r15
leaq (%r12,%rbp,8), %rsi
movq %r15, %rdi
movq %r13, %rcx
callq *0x48(%rdx)
xorl %ebp, %ebp
jmp 0x2be42
movl $0x1f6, %ebp # imm = 0x1F6
jmp 0x2be42
| /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;
// проверить params
if (!memIsValid(params, sizeof(bign_params)))
return ERR_BAD_INPUT;
if (!bignIsOperable(params))
return ERR_BAD_PARAMS;
// создать состояние
state = blobCreate(bignStart_keep(params->l, bignDH_deep));
if (state == 0)
return ERR_OUTOFMEMORY;
// старт
code = bignStart(state, params);
ERR_CALL_HANDLE(code, blobClose(state));
ec = (ec_o*)state;
// размерности
no = ec->f->no;
n = ec->f->n;
// проверить длину key
if (key_len > 2 * no)
{
blobClose(state);
return ERR_BAD_SHAREDKEY;
}
// проверить входные указатели
if (!memIsValid(privkey, no) ||
!memIsValid(pubkey, 2 * no) ||
!memIsValid(key, key_len))
{
blobClose(state);
return ERR_BAD_INPUT;
}
// раскладка состояния
d = objEnd(ec, word);
Q = d + n;
stack = Q + 2 * n;
// загрузить d
wwFrom(d, privkey, no);
if (wwIsZero(d, n) || wwCmp(d, ec->order, n) >= 0)
{
blobClose(state);
return ERR_BAD_PRIVKEY;
}
// загрузить Q
if (!qrFrom(ecX(Q), pubkey, ec->f, stack) ||
!qrFrom(ecY(Q, n), pubkey + no, ec->f, stack) ||
!ecpIsOnA(Q, ec, stack))
{
blobClose(state);
return ERR_BAD_PUBKEY;
}
// Q <- d Q
if (ecMulA(Q, Q, ec, d, n, stack))
{
// выгрузить общий ключ
qrTo((octet*)Q, ecX(Q), ec->f, stack);
if (key_len > no)
qrTo((octet*)Q + no, ecY(Q, n), ec->f, stack);
memCopy(key, Q, key_len);
}
else
code = ERR_BAD_PARAMS;
// завершение
blobClose(state);
return code;
} | 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
movq (%rbp), %rdi
leaq 0x1d8(%rip), %rsi # 0x2c18e
callq 0xf410
movq %rax, %rdi
callq 0xf190
testq %rax, %rax
je 0x2c093
movq %rax, %r15
movq %r14, 0x18(%rsp)
movq %rax, %rdi
movq %rbp, %rsi
callq 0xf290
movl %eax, %ebp
testl %eax, %eax
jne 0x2c07e
movq 0x18(%r15), %rax
movq 0x38(%rax), %rsi
leaq (%rsi,%rsi), %r14
movl $0x1fb, %ebp # imm = 0x1FB
cmpq %rbx, %r14
jb 0x2c07e
movq 0x30(%rax), %rax
movq %rax, 0x8(%rsp)
movq %r13, %rdi
movq %rsi, 0x10(%rsp)
callq 0xeeb0
pushq $0x6d
popq %rbp
testl %eax, %eax
je 0x2c07e
movq %r12, %rdi
movq %r14, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x2c07e
movq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
movq 0x10(%rsp), %rdx
je 0x2c07e
movq (%r15), %rdi
addq %r15, %rdi
movq %r13, %rsi
movq %rdi, %r13
callq 0xf540
movq %r13, %rdi
movq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0xffc0
movl $0x1f8, %ebp # imm = 0x1F8
testl %eax, %eax
jne 0x2c07e
movq 0x38(%r15), %rsi
movq %r13, %rdi
movq %r14, %rdx
callq 0xf1b0
testl %eax, %eax
js 0x2c0a7
movq %r15, %rdi
callq 0xe920
jmp 0x2c096
pushq $0x6d
jmp 0x2c095
movl $0x1f6, %ebp # imm = 0x1F6
jmp 0x2c096
pushq $0x6e
popq %rbp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %r14
movq %r13, 0x28(%rsp)
leaq (,%r14,8), %rdi
addq %r13, %rdi
movq %r14, %r13
shlq $0x4, %r13
addq %rdi, %r13
movq 0x18(%r15), %rdx
movq %rdi, 0x30(%rsp)
movq %r12, %rsi
movq %r13, %rcx
callq *0x40(%rdx)
movl $0x1f9, %ebp # imm = 0x1F9
testl %eax, %eax
je 0x2c07e
movq 0x18(%r15), %rdx
movq 0x30(%rsp), %rax
leaq (%rax,%r14,8), %rdi
movq %rax, %r14
addq 0x10(%rsp), %r12
movq %rdi, 0x20(%rsp)
movq %r12, %rsi
movq %r13, %rcx
callq *0x40(%rdx)
testl %eax, %eax
je 0x2c07e
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xfbd0
testl %eax, %eax
movq 0x28(%rsp), %rcx
je 0x2c07e
movq %r14, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq 0x8(%rsp), %r8
movq %r13, %r9
callq 0xff30
testl %eax, %eax
je 0x2c184
movq 0x18(%r15), %rdx
movq %r14, %rdi
movq %r14, %rsi
movq %r13, %rcx
callq *0x48(%rdx)
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
jae 0x2c16d
movq 0x18(%r15), %rdx
addq %r14, %rdi
movq 0x20(%rsp), %rsi
movq %r13, %rcx
callq *0x48(%rdx)
movq 0x18(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xe970
xorl %ebp, %ebp
jmp 0x2c07e
movl $0x1f6, %ebp # imm = 0x1F6
jmp 0x2c07e
| /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);
memCopy(params->seed, _curve128v1_seed, 8);
memCopy(params->b, _curve128v1_b, 32);
memCopy(params->q, _curve128v1_q, 32);
memCopy(params->yG, _curve128v1_yG, 32);
return ERR_OK;
}
if (strEq(name, _curve192v1_name))
{
params->l = 192;
memCopy(params->p, _curve192v1_p, 48);
memCopy(params->a, _curve192v1_a, 48);
memCopy(params->seed, _curve192v1_seed, 8);
memCopy(params->b, _curve192v1_b, 48);
memCopy(params->q, _curve192v1_q, 48);
memCopy(params->yG, _curve192v1_yG, 48);
return ERR_OK;
}
if (strEq(name, _curve256v1_name))
{
params->l = 256;
memCopy(params->p, _curve256v1_p, 64);
memCopy(params->a, _curve256v1_a, 64);
memCopy(params->seed, _curve256v1_seed, 8);
memCopy(params->b, _curve256v1_b, 64);
memCopy(params->q, _curve256v1_q, 64);
memCopy(params->yG, _curve256v1_yG, 64);
return ERR_OK;
}
return ERR_FILE_NOT_FOUND;
} | 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
testl %eax, %eax
je 0x2c2e1
leaq 0x22f69(%rip), %rsi # 0x4f190
movq %r14, %rdi
callq 0xebd0
testl %eax, %eax
je 0x2c372
leaq 0x23072(%rip), %rsi # 0x4f2b0
movq %r14, %rdi
callq 0xebd0
movl $0xca, %ebp
testl %eax, %eax
jne 0x2c400
movq $0x100, (%rbx) # imm = 0x100
leaq 0x8(%rbx), %rdi
leaq 0x2306b(%rip), %rsi # 0x4f2d0
pushq $0x40
popq %r14
movq %r14, %rdx
callq 0xe970
leaq 0x48(%rbx), %rdi
leaq 0x23094(%rip), %rsi # 0x4f310
movq %r14, %rdx
callq 0xe970
leaq 0x148(%rbx), %rdi
leaq 0x230be(%rip), %rsi # 0x4f350
pushq $0x8
popq %rdx
callq 0xe970
leaq 0x88(%rbx), %rdi
leaq 0x230b8(%rip), %rsi # 0x4f360
movq %r14, %rdx
callq 0xe970
leaq 0xc8(%rbx), %rdi
leaq 0x230e2(%rip), %rsi # 0x4f3a0
movq %r14, %rdx
callq 0xe970
addq $0x108, %rbx # imm = 0x108
leaq 0x2310c(%rip), %rsi # 0x4f3e0
jmp 0x2c3f3
pushq $0x6d
popq %rbp
jmp 0x2c400
movq $0x80, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x22ded(%rip), %rsi # 0x4f0e0
pushq $0x20
popq %r14
movq %r14, %rdx
callq 0xe970
leaq 0x48(%rbx), %rdi
leaq 0x22df6(%rip), %rsi # 0x4f100
movq %r14, %rdx
callq 0xe970
leaq 0x148(%rbx), %rdi
leaq 0x22e00(%rip), %rsi # 0x4f120
pushq $0x8
popq %rdx
callq 0xe970
leaq 0x88(%rbx), %rdi
leaq 0x22dfa(%rip), %rsi # 0x4f130
movq %r14, %rdx
callq 0xe970
leaq 0xc8(%rbx), %rdi
leaq 0x22e04(%rip), %rsi # 0x4f150
movq %r14, %rdx
callq 0xe970
addq $0x108, %rbx # imm = 0x108
leaq 0x22e0e(%rip), %rsi # 0x4f170
movq %rbx, %rdi
movq %r14, %rdx
callq 0xe970
jmp 0x2c400
movq $0xc0, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x22e2c(%rip), %rsi # 0x4f1b0
pushq $0x30
popq %r14
movq %r14, %rdx
callq 0xe970
leaq 0x48(%rbx), %rdi
leaq 0x22e45(%rip), %rsi # 0x4f1e0
movq %r14, %rdx
callq 0xe970
leaq 0x148(%rbx), %rdi
leaq 0x22e5f(%rip), %rsi # 0x4f210
pushq $0x8
popq %rdx
callq 0xe970
leaq 0x88(%rbx), %rdi
leaq 0x22e59(%rip), %rsi # 0x4f220
movq %r14, %rdx
callq 0xe970
leaq 0xc8(%rbx), %rdi
leaq 0x22e73(%rip), %rsi # 0x4f250
movq %r14, %rdx
callq 0xe970
addq $0x108, %rbx # imm = 0x108
leaq 0x22e8d(%rip), %rsi # 0x4f280
movq %rbx, %rdi
movq %r14, %rdx
callq 0xe970
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
| /agievich[P]bee2/src/crypto/bign/bign_params.c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.