1 /*
2 * Portable interface to the CPU cycle counter
3 *
4 * Copyright The Mbed TLS Contributors
5 * SPDX-License-Identifier: Apache-2.0
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License"); you may
8 * not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
15 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 */
19
20 #include "common.h"
21
22 #if defined(MBEDTLS_TIMING_C)
23
24 #include "mbedtls/timing.h"
25
26 #if !defined(MBEDTLS_TIMING_ALT)
27
28 #if !defined(unix) && !defined(__unix__) && !defined(__unix) && \
29 !defined(__APPLE__) && !defined(_WIN32) && !defined(__QNXNTO__) && \
30 !defined(__HAIKU__) && !defined(__midipix__)
31 #error "This module only works on Unix and Windows, see MBEDTLS_TIMING_C in mbedtls_config.h"
32 #endif
33
34 #if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
35
36 #include <windows.h>
37 #include <process.h>
38
39 struct _hr_time {
40 LARGE_INTEGER start;
41 };
42
43 #else
44
45 #include <unistd.h>
46 #include <sys/types.h>
47 #include <signal.h>
48 /* time.h should be included independently of MBEDTLS_HAVE_TIME. If the
49 * platform matches the ifdefs above, it will be used. */
50 #include <time.h>
51 #include <sys/time.h>
52 struct _hr_time {
53 struct timeval start;
54 };
55 #endif /* _WIN32 && !EFIX64 && !EFI32 */
56
57 /**
58 * \brief Return the elapsed time in milliseconds
59 *
60 * \warning May change without notice
61 *
62 * \param val points to a timer structure
63 * \param reset If 0, query the elapsed time. Otherwise (re)start the timer.
64 *
65 * \return Elapsed time since the previous reset in ms. When
66 * restarting, this is always 0.
67 *
68 * \note To initialize a timer, call this function with reset=1.
69 *
70 * Determining the elapsed time and resetting the timer is not
71 * atomic on all platforms, so after the sequence
72 * `{ get_timer(1); ...; time1 = get_timer(1); ...; time2 =
73 * get_timer(0) }` the value time1+time2 is only approximately
74 * the delay since the first reset.
75 */
76 #if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
77
mbedtls_timing_get_timer(struct mbedtls_timing_hr_time * val,int reset)78 unsigned long mbedtls_timing_get_timer(struct mbedtls_timing_hr_time *val, int reset)
79 {
80 struct _hr_time *t = (struct _hr_time *) val;
81
82 if (reset) {
83 QueryPerformanceCounter(&t->start);
84 return 0;
85 } else {
86 unsigned long delta;
87 LARGE_INTEGER now, hfreq;
88 QueryPerformanceCounter(&now);
89 QueryPerformanceFrequency(&hfreq);
90 delta = (unsigned long) ((now.QuadPart - t->start.QuadPart) * 1000ul
91 / hfreq.QuadPart);
92 return delta;
93 }
94 }
95
96 #else /* _WIN32 && !EFIX64 && !EFI32 */
97
mbedtls_timing_get_timer(struct mbedtls_timing_hr_time * val,int reset)98 unsigned long mbedtls_timing_get_timer(struct mbedtls_timing_hr_time *val, int reset)
99 {
100 struct _hr_time *t = (struct _hr_time *) val;
101
102 if (reset) {
103 gettimeofday(&t->start, NULL);
104 return 0;
105 } else {
106 unsigned long delta;
107 struct timeval now;
108 gettimeofday(&now, NULL);
109 delta = (now.tv_sec - t->start.tv_sec) * 1000ul
110 + (now.tv_usec - t->start.tv_usec) / 1000;
111 return delta;
112 }
113 }
114
115 #endif /* _WIN32 && !EFIX64 && !EFI32 */
116
117 /*
118 * Set delays to watch
119 */
mbedtls_timing_set_delay(void * data,uint32_t int_ms,uint32_t fin_ms)120 void mbedtls_timing_set_delay(void *data, uint32_t int_ms, uint32_t fin_ms)
121 {
122 mbedtls_timing_delay_context *ctx = (mbedtls_timing_delay_context *) data;
123
124 ctx->int_ms = int_ms;
125 ctx->fin_ms = fin_ms;
126
127 if (fin_ms != 0) {
128 (void) mbedtls_timing_get_timer(&ctx->timer, 1);
129 }
130 }
131
132 /*
133 * Get number of delays expired
134 */
mbedtls_timing_get_delay(void * data)135 int mbedtls_timing_get_delay(void *data)
136 {
137 mbedtls_timing_delay_context *ctx = (mbedtls_timing_delay_context *) data;
138 unsigned long elapsed_ms;
139
140 if (ctx->fin_ms == 0) {
141 return -1;
142 }
143
144 elapsed_ms = mbedtls_timing_get_timer(&ctx->timer, 0);
145
146 if (elapsed_ms >= ctx->fin_ms) {
147 return 2;
148 }
149
150 if (elapsed_ms >= ctx->int_ms) {
151 return 1;
152 }
153
154 return 0;
155 }
156
157 /*
158 * Get the final delay.
159 */
mbedtls_timing_get_final_delay(const mbedtls_timing_delay_context * data)160 uint32_t mbedtls_timing_get_final_delay(
161 const mbedtls_timing_delay_context *data)
162 {
163 return data->fin_ms;
164 }
165 #endif /* !MBEDTLS_TIMING_ALT */
166 #endif /* MBEDTLS_TIMING_C */
167