cachepc-qemu

Fork of AMDESE/qemu with changes for cachepc side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-qemu
Log | Files | Refs | Submodules | LICENSE | sfeed.txt

pbkdf.c (3355B)

      1/*
      2 * QEMU Crypto PBKDF support (Password-Based Key Derivation Function)
      3 *
      4 * Copyright (c) 2015-2016 Red Hat, Inc.
      5 *
      6 * This library is free software; you can redistribute it and/or
      7 * modify it under the terms of the GNU Lesser General Public
      8 * License as published by the Free Software Foundation; either
      9 * version 2.1 of the License, or (at your option) any later version.
     10 *
     11 * This library is distributed in the hope that it will be useful,
     12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
     13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     14 * Lesser General Public License for more details.
     15 *
     16 * You should have received a copy of the GNU Lesser General Public
     17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
     18 *
     19 */
     20
     21#include "qemu/osdep.h"
     22#include "qapi/error.h"
     23#include "crypto/pbkdf.h"
     24#ifndef _WIN32
     25#include <sys/resource.h>
     26#endif
     27
     28
     29static int qcrypto_pbkdf2_get_thread_cpu(unsigned long long *val_ms,
     30                                         Error **errp)
     31{
     32#ifdef _WIN32
     33    FILETIME creation_time, exit_time, kernel_time, user_time;
     34    ULARGE_INTEGER thread_time;
     35
     36    if (!GetThreadTimes(GetCurrentThread(), &creation_time, &exit_time,
     37                        &kernel_time, &user_time)) {
     38        error_setg(errp, "Unable to get thread CPU usage");
     39        return -1;
     40    }
     41
     42    thread_time.LowPart = user_time.dwLowDateTime;
     43    thread_time.HighPart = user_time.dwHighDateTime;
     44
     45    /* QuadPart is units of 100ns and we want ms as unit */
     46    *val_ms = thread_time.QuadPart / 10000ll;
     47    return 0;
     48#elif defined(RUSAGE_THREAD)
     49    struct rusage ru;
     50    if (getrusage(RUSAGE_THREAD, &ru) < 0) {
     51        error_setg_errno(errp, errno, "Unable to get thread CPU usage");
     52        return -1;
     53    }
     54
     55    *val_ms = ((ru.ru_utime.tv_sec * 1000ll) +
     56               (ru.ru_utime.tv_usec / 1000));
     57    return 0;
     58#else
     59    *val_ms = 0;
     60    error_setg(errp, "Unable to calculate thread CPU usage on this platform");
     61    return -1;
     62#endif
     63}
     64
     65uint64_t qcrypto_pbkdf2_count_iters(QCryptoHashAlgorithm hash,
     66                                    const uint8_t *key, size_t nkey,
     67                                    const uint8_t *salt, size_t nsalt,
     68                                    size_t nout,
     69                                    Error **errp)
     70{
     71    uint64_t ret = -1;
     72    g_autofree uint8_t *out = g_new(uint8_t, nout);
     73    uint64_t iterations = (1 << 15);
     74    unsigned long long delta_ms, start_ms, end_ms;
     75
     76    while (1) {
     77        if (qcrypto_pbkdf2_get_thread_cpu(&start_ms, errp) < 0) {
     78            goto cleanup;
     79        }
     80        if (qcrypto_pbkdf2(hash,
     81                           key, nkey,
     82                           salt, nsalt,
     83                           iterations,
     84                           out, nout,
     85                           errp) < 0) {
     86            goto cleanup;
     87        }
     88        if (qcrypto_pbkdf2_get_thread_cpu(&end_ms, errp) < 0) {
     89            goto cleanup;
     90        }
     91
     92        delta_ms = end_ms - start_ms;
     93
     94        if (delta_ms > 500) {
     95            break;
     96        } else if (delta_ms < 100) {
     97            iterations = iterations * 10;
     98        } else {
     99            iterations = (iterations * 1000 / delta_ms);
    100        }
    101    }
    102
    103    iterations = iterations * 1000 / delta_ms;
    104
    105    ret = iterations;
    106
    107 cleanup:
    108    memset(out, 0, nout);
    109    return ret;
    110}