xref: /openbmc/qemu/crypto/pbkdf.c (revision f1733749)
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  
29  static 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  
65  uint64_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  }
111