int hdd_io(int hdd_n, void *buff, u16 sectors, u64 start, int read)
{
u8 sbuf[32];
rm_ctx ctx;
u32 head, cyl;
u8 dos_n = hdd2dos(hdd_n);
hdd_inf *hdd = &iodb.p_hdd[hdd_n];
lba_p *lba = pv(0x580); /* this needed for avoid stupid actions by buggy BIOSes */
int succs = 0;
/* setup initial context */
set_ctx(0, &ctx);
if (hdd->flags & HDD_LBA)
{
/* save old buffer */
mincpy(sbuf, lba, sizeof(sbuf));
/* setup LBA block */
lba->size = sizeof(lba_p);
lba->unk = 0;
lba->dst_sel = rm_seg(buff);
lba->dst_off = rm_off(buff);
lba->numb = sectors;
lba->sector = start;
ctx.ah = read ? 0x42:0x43;
ctx.dl = dos_n;
ctx.si = 0x180;
ctx.ds = 0x40; /* if DS can be 0x40, we can avoid AWARD BIOS bug of int13/AX=4B01 */
/* set additional registers to serve buggy BIOSes. */
ctx.es = ctx.ds;
ctx.di = ctx.si;
ctx.bx = ctx.si;
ctx.cx = ctx.ds;
/* do not check AH because some buggy USB BIOSes fail to clear AH on success */
succs = bios_call(0x13, &ctx);
/* restore saved buffer */
mincpy(lba, sbuf, sizeof(sbuf));
} else
{
head = d32(start) / hdd->max_sect;
cyl = head / hdd->max_head;
ctx.ah = read ? 0x02:0x03;
ctx.al = d8(sectors);
ctx.ch = d8(cyl);
ctx.cl = d8(((cyl & 0x0300) >> 2) | (d32(start) % hdd->max_sect + 1));
ctx.dh = head % hdd->max_head;
ctx.dl = dos_n;
ctx.es = rm_seg(buff);
ctx.bx = rm_off(buff);
/* do not check AH because some buggy USB BIOSes fail to clear AH on success */
succs = bios_call(0x13, &ctx);
}
return succs;
}
void serpent256_decrypt(const unsigned char *in, unsigned char *out, serpent256_key *key)
{
u32 b[4];
int i;
mincpy(b, in, SERPENT_BLOCK_SIZE);
for (i = 31; i >= 0; i--) {
if (i == 31) KXf(key->expkey, 32, b); else ITf(b);
sd_tab[i % 8](b); KXf(key->expkey, i, b);
}
mincpy(out, b, SERPENT_BLOCK_SIZE);
}
void serpent256_encrypt(const unsigned char *in, unsigned char *out, serpent256_key *key)
{
u32 b[4];
int i;
mincpy(b, in, SERPENT_BLOCK_SIZE);
for (i = 0; i < 32; i++) {
KXf(key->expkey, i, b); se_tab[i % 8](b);
if (i == 31) KXf(key->expkey, 32, b); else LTf(b);
}
mincpy(out, b, SERPENT_BLOCK_SIZE);
}
void serpent256_set_key(const unsigned char *key, serpent256_key *skey)
{
u32 W[140], i;
mincpy(W, key, SERPENT_KEY_SIZE);
for(i = 8; i != 140; ++i) {
W[i] = ROL32(W[i-8] ^ W[i-5] ^ W[i-3] ^ W[i-1] ^ PHI ^ (i-8), 11);
}
for (i = 8; i <= 136; i += 4) {
se_tab[7 - (((i / 4) + 2) % 8)](&W[i]);
}
mincpy(skey->expkey, W+8, SERPENT_EXPKEY_WORDS*sizeof(u32));
}
static int set_to_val(HKEY h_key, wchar_t *v_name, wchar_t *name)
{
wchar_t buf[MAX_PATH];
u32 len, cb;
wchar_t *p;
len = (u32)((wcslen(name) + 1) * sizeof(wchar_t));
cb = sizeof(buf); p = buf;
if (RegQueryValueEx(h_key, v_name, NULL, NULL, p8(buf), &cb) != 0) {
buf[0] = 0; cb = sizeof(wchar_t);
}
while (*p != 0)
{
if (wcscmp(p, name) == 0) {
p = NULL; break;
} else {
p = addof(p, (wcslen(p) * sizeof(wchar_t)) + sizeof(wchar_t));
}
}
if (p == NULL) { return 1; }
memmove(p8(buf) + len, buf, cb);
mincpy(buf, name, len);
cb += len;
return RegSetValueEx(h_key, v_name, 0, REG_MULTI_SZ, p8(buf), cb) == 0;
}
dc_pass *__get_pass_keyfiles(
HWND h_pass,
BOOL use_keyfiles,
int key_list
)
{
dc_pass *pass;
wchar_t *s_pass;
size_t plen;
int rlt;
if ( (pass = secure_alloc(sizeof(dc_pass))) == NULL )
{
return NULL;
}
if ( (s_pass = secure_alloc((MAX_PASSWORD + 1) * sizeof(wchar_t))) == NULL)
{
return NULL;
}
GetWindowText( h_pass, s_pass, MAX_PASSWORD + 1 );
if ( wcslen(s_pass) > 0 )
{
plen = wcslen(s_pass) * sizeof(wchar_t);
pass->size = d32( min( plen, MAX_PASSWORD * sizeof(wchar_t) ) );
mincpy( &pass->pass, s_pass, pass->size );
secure_free( s_pass );
}
if ( use_keyfiles )
{
_list_key_files *key_file;
if ( key_file = _first_keyfile(key_list) )
{
do {
rlt = dc_add_keyfiles( pass, key_file->path );
if ( rlt != ST_OK )
{
__error_s( GetParent(h_pass), L"Keyfiles not loaded", rlt );
secure_free( pass );
pass = NULL;
break;
}
key_file = _next_keyfile( key_file, key_list );
} while ( key_file != NULL );
}
}
return pass;
}
void sha512_pkcs5_2(
int i_count,
const void *pwd, size_t pwd_len,
const char *salt, size_t salt_len,
char *dk, size_t dklen
)
{
u8 buff[128];
u8 blk[SHA512_DIGEST_SIZE];
u8 hmac[SHA512_DIGEST_SIZE];
u32 block = 1;
size_t c_len, j;
int i;
while (dklen != 0)
{
/* first interation */
mincpy(buff, salt, salt_len);
p32(buff + salt_len)[0] = BE32(block);
sha512_hmac(pwd, pwd_len, buff, salt_len + 4, hmac);
autocpy(blk, hmac, SHA512_DIGEST_SIZE);
/* next interations */
for (i = 1; i < i_count; i++)
{
sha512_hmac(pwd, pwd_len, hmac, SHA512_DIGEST_SIZE, hmac);
for (j = 0; j < SHA512_DIGEST_SIZE; j++) {
blk[j] ^= hmac[j];
}
}
c_len = min(dklen, SHA512_DIGEST_SIZE);
mincpy(dk, blk, c_len);
dk += c_len; dklen -= c_len; block++;
}
/* prevent leaks */
zeroauto(buff, sizeof(buff));
zeroauto(blk, sizeof(blk));
zeroauto(hmac, sizeof(hmac));
}
int bios_call(int num, rm_ctx *ctx)
{
/* copy initial context to real mode buffer */
if (ctx != NULL) {
mincpy(&bdat->rmc, ctx, sizeof(rm_ctx));
}
/* get interrupt seg/off */
if ( (num == 0x13) && (bdat->old_int13 != 0) ) {
bdat->segoff = bdat->old_int13;
} else {
bdat->segoff = p32(0)[num];
}
bdat->rmc.efl = FL_IF;
/* call to real mode */
bdat->call_rm();
/* copy changed context */
if (ctx != NULL) {
mincpy(ctx, &bdat->rmc, sizeof(rm_ctx));
}
return (bdat->rmc.efl & FL_CF) == 0;
}
wchar_t *_mark(
double digit,
wchar_t *text,
wchar_t dec
)
{
wchar_t ws_dsp[100];
wchar_t *result = text;
wchar_t *pws_dsp = (wchar_t *)&ws_dsp;
size_t trim;
size_t k;
_snwprintf( pws_dsp, 50, L"%.2f", digit );
trim = wcslen(pws_dsp) % 3;
mincpy( text, ws_dsp, trim );
for ( pws_dsp += trim, text += trim,
k = wcslen(pws_dsp) / 3-1;
k; k-- )
{
if ( trim )
{
*text++ = '\x2c';
} else {
trim = 1;
}
mincpy( text, pws_dsp, 3 );
text += 3; pws_dsp += 3;
}
if ( dec )
{
mincpy( text, pws_dsp, 3 );
}
*text = '\0';
return result;
}
void bios_jump_boot(int hdd_n, int n_mount)
{
if (n_mount != 0) {
/* setup backup data block */
mincpy(addof(bdat->bd_base, bdat->bd_size - 384), bdat, offsetof(bd_data, ret_32));
} else {
/* clear boot data block signature */
bdat->sign1 = 0; bdat->sign2 = 0;
}
bdat->boot_dsk = hdd2dos(hdd_n);
bdat->rmc.dx = 0x80;
bdat->rmc.efl = FL_IF; /* enable interrupts */
bdat->segoff = 0x7C00;
bios_jump_rm();
}
void sha512_hmac(const char *k, size_t k_len, const char *d, size_t d_len, char *out)
{
sha512_ctx ctx;
u8 buf[SHA512_BLOCK_SIZE];
u8 hval[SHA512_DIGEST_SIZE];
size_t i;
/* zero key buffer */
zeroauto(buf, sizeof(buf));
/* compress hmac key */
if (k_len > SHA512_BLOCK_SIZE) {
sha512_init(&ctx);
sha512_hash(&ctx, k, k_len);
sha512_done(&ctx, buf);
} else {
mincpy(buf, k, k_len);
}
/* create the hash initial vector */
for (i = 0; i < SHA512_BLOCK_SIZE; i++) {
buf[i] ^= 0x36;
}
/* hash key and data */
sha512_init(&ctx);
sha512_hash(&ctx, buf, SHA512_BLOCK_SIZE);
sha512_hash(&ctx, d, d_len);
sha512_done(&ctx, hval);
/* create the second HMAC vector */
for (i = 0; i < SHA512_BLOCK_SIZE; i++) {
buf[i] ^= 0x6A;
}
/* calculate "outer" hash */
sha512_init(&ctx);
sha512_hash(&ctx, buf, SHA512_BLOCK_SIZE);
sha512_hash(&ctx, hval, SHA512_DIGEST_SIZE);
sha512_done(&ctx, out);
/* prevent leaks */
zeroauto(buf, sizeof(buf));
zeroauto(hval, sizeof(hval));
zeroauto(&ctx, sizeof(ctx));
}
static void add_smap(e820entry *map)
{
if ( (bdat->mem_map.n_map < E820MAX) && (map->size != 0) ) {
mincpy(&bdat->mem_map.map[bdat->mem_map.n_map++], map, sizeof(e820entry));
}
}
static void int13_callback()
{
rm_ctx ctx;
u16 p_efl = bdat->push_fl;
int need = 0;
hdd_inf *hdd = NULL;
lba_p *lba = NULL;
void *buff;
u16 numb;
u64 start;
int hdd_n;
if (bdat->rmc.dl == 0x80) {
bdat->rmc.dl = bdat->boot_dsk;
} else if (bdat->rmc.dl == bdat->boot_dsk) {
bdat->rmc.dl = 0x80;
}
/* copy context to temporary buffer */
mincpy(&ctx, &bdat->rmc, sizeof(rm_ctx));
if ( ((hdd_n = dos2hdd(ctx.dl)) >= 0) && (hdd_n < iodb.n_hdd) ) {
hdd = &iodb.p_hdd[hdd_n];
}
if (hdd != NULL)
{
if ( (ctx.ah == 0x02) || (ctx.ah == 0x03) )
{
start = ((ctx.ch + ((ctx.cl & 0xC0) << 2)) *
hdd->max_head + ctx.dh) * hdd->max_sect + (ctx.cl & 0x3F) - 1;
buff = pm_off(ctx.es, ctx.bx);
numb = ctx.al;
need = 1;
}
if ( (ctx.ah == 0x42) || (ctx.ah == 0x43) )
{
lba = pm_off(ctx.ds, ctx.si);
start = lba->sector;
buff = pm_off(lba->dst_sel, lba->dst_off);
numb = lba->numb;
need = 1;
}
}
if (need != 0)
{
if (dc_disk_io(hdd_n, buff, numb, start, (ctx.ah == 0x02) || (ctx.ah == 0x42)) != 0)
{
ctx.ah = 0;
ctx.efl &= ~FL_CF;
if (lba != NULL) {
lba->numb = numb;
} else {
ctx.al = d8(numb);
}
} else {
ctx.efl |= FL_CF;
}
/* setup new context */
mincpy(&bdat->rmc, &ctx, sizeof(rm_ctx));
} else
{
/* interrupt is not processed, call original handler */
bdat->rmc.efl = FL_IF; /* enable interrupts */
bdat->segoff = bdat->old_int13;
bdat->call_rm();
}
/* copy saved interrupt flag to exit context */
bdat->rmc.efl = (bdat->rmc.efl & ~FL_IF) | (p_efl & FL_IF);
}
