Bitcoin Core 32.1.0
P2P Digital Currency
Loading...
Searching...
No Matches
randomenv.cpp
Go to the documentation of this file.
1// Copyright (c) 2009-2010 Satoshi Nakamoto
2// Copyright (c) 2009-present The Bitcoin Core developers
3// Distributed under the MIT software license, see the accompanying
4// file COPYING or http://www.opensource.org/licenses/mit-license.php.
5
6#include <bitcoin-build-config.h> // IWYU pragma: keep
7
8#include <randomenv.h>
9
10#include <clientversion.h>
11#include <compat/compat.h>
12#include <compat/cpuid.h>
13#include <crypto/sha512.h>
14#include <span.h>
15#include <support/cleanse.h>
16#include <util/byte_units.h>
17#include <util/time.h>
18
19#include <algorithm>
20#include <atomic>
21#include <cstdint>
22#include <cstring>
23#include <chrono>
24#include <climits>
25#include <thread>
26#include <vector>
27
28#include <sys/types.h> // must go before a number of other headers
29
30#ifdef WIN32
31#include <windows.h>
32#else
33#include <fcntl.h>
34#include <netinet/in.h>
35#include <sys/resource.h>
36#include <sys/socket.h>
37#include <sys/stat.h>
38#include <sys/time.h>
39#include <sys/utsname.h>
40#include <unistd.h>
41#endif
42#ifdef HAVE_IFADDRS
43#include <ifaddrs.h>
44#endif
45#ifdef HAVE_SYSCTL
46#include <sys/sysctl.h>
47#if __has_include(<vm/vm_param.h>)
48#include <vm/vm_param.h>
49#endif
50#if __has_include(<sys/resources.h>)
51#include <sys/resources.h>
52#endif
53#if __has_include(<sys/vmmeter.h>)
54#include <sys/vmmeter.h>
55#endif
56#endif
57#if defined(HAVE_STRONG_GETAUXVAL)
58#include <sys/auxv.h>
59#endif
60
61#if defined(__APPLE__) || \
62 defined(__FreeBSD__) || \
63 defined(__NetBSD__) || \
64 defined(__OpenBSD__) || \
65 defined(__illumos__)
66extern char** environ; // Necessary on the above platforms
67#endif
68
69namespace {
70
76template<typename T>
77CSHA512& operator<<(CSHA512& hasher, const T& data) {
78 static_assert(!std::is_same_v<std::decay_t<T>, char*>, "Calling operator<<(CSHA512, char*) is probably not what you want");
79 static_assert(!std::is_same_v<std::decay_t<T>, unsigned char*>, "Calling operator<<(CSHA512, unsigned char*) is probably not what you want");
80 static_assert(!std::is_same_v<std::decay_t<T>, const char*>, "Calling operator<<(CSHA512, const char*) is probably not what you want");
81 static_assert(!std::is_same_v<std::decay_t<T>, const unsigned char*>, "Calling operator<<(CSHA512, const unsigned char*) is probably not what you want");
82 hasher.Write((const unsigned char*)&data, sizeof(data));
83 return hasher;
84}
85
86#ifndef WIN32
87void AddSockaddr(CSHA512& hasher, const struct sockaddr *addr)
88{
89 if (addr == nullptr) return;
90 switch (addr->sa_family) {
91 case AF_INET:
92 hasher.Write((const unsigned char*)addr, sizeof(sockaddr_in));
93 break;
94 case AF_INET6:
95 hasher.Write((const unsigned char*)addr, sizeof(sockaddr_in6));
96 break;
97 default:
98 hasher.Write((const unsigned char*)&addr->sa_family, sizeof(addr->sa_family));
99 }
100}
101
102void AddFile(CSHA512& hasher, const char *path)
103{
104 struct stat sb = {};
105 int f = open(path, O_RDONLY);
106 size_t total = 0;
107 if (f != -1) {
108 unsigned char fbuf[4096];
109 int n;
110 hasher.Write((const unsigned char*)&f, sizeof(f));
111 if (fstat(f, &sb) == 0) hasher << sb;
112 do {
113 n = read(f, fbuf, sizeof(fbuf));
114 if (n > 0) hasher.Write(fbuf, n);
115 total += n;
116 /* not bothering with EINTR handling. */
117 } while (n == sizeof(fbuf) && total < 1_MiB); // Read only the first 1 Mbyte
118 close(f);
119 }
120}
121
122void AddPath(CSHA512& hasher, const char *path)
123{
124 struct stat sb = {};
125 if (stat(path, &sb) == 0) {
126 hasher.Write((const unsigned char*)path, strlen(path) + 1);
127 hasher << sb;
128 }
129}
130#endif
131
132#ifdef HAVE_SYSCTL
133template<int... S>
134void AddSysctl(CSHA512& hasher)
135{
136 int CTL[sizeof...(S)] = {S...};
137 unsigned char buffer[65536];
138 size_t siz = 65536;
139 int ret = sysctl(CTL, sizeof...(S), buffer, &siz, nullptr, 0);
140 if (ret == 0 || (ret == -1 && errno == ENOMEM)) {
141 hasher << sizeof(CTL);
142 hasher.Write((const unsigned char*)CTL, sizeof(CTL));
143 if (siz > sizeof(buffer)) siz = sizeof(buffer);
144 hasher << siz;
145 hasher.Write(buffer, siz);
146 }
147}
148#endif
149
150#ifdef HAVE_GETCPUID
151void inline AddCPUID(CSHA512& hasher, uint32_t leaf, uint32_t subleaf, uint32_t& ax, uint32_t& bx, uint32_t& cx, uint32_t& dx)
152{
153 GetCPUID(leaf, subleaf, ax, bx, cx, dx);
154 hasher << leaf << subleaf << ax << bx << cx << dx;
155}
156
157void AddAllCPUID(CSHA512& hasher)
158{
159 uint32_t ax, bx, cx, dx;
160 // Iterate over all standard leaves
161 AddCPUID(hasher, 0, 0, ax, bx, cx, dx); // Returns max leaf in ax
162 uint32_t max = ax;
163 for (uint32_t leaf = 1; leaf <= max && leaf <= 0xFF; ++leaf) {
164 uint32_t maxsub = 0;
165 for (uint32_t subleaf = 0; subleaf <= 0xFF; ++subleaf) {
166 AddCPUID(hasher, leaf, subleaf, ax, bx, cx, dx);
167 // Iterate subleafs for leaf values 4, 7, 11, 13
168 if (leaf == 4) {
169 if ((ax & 0x1f) == 0) break;
170 } else if (leaf == 7) {
171 if (subleaf == 0) maxsub = ax;
172 if (subleaf == maxsub) break;
173 } else if (leaf == 11) {
174 if ((cx & 0xff00) == 0) break;
175 } else if (leaf == 13) {
176 if (ax == 0 && bx == 0 && cx == 0 && dx == 0) break;
177 } else {
178 // For any other leaf, stop after subleaf 0.
179 break;
180 }
181 }
182 }
183 // Iterate over all extended leaves
184 AddCPUID(hasher, 0x80000000, 0, ax, bx, cx, dx); // Returns max extended leaf in ax
185 uint32_t ext_max = ax;
186 for (uint32_t leaf = 0x80000001; leaf <= ext_max && leaf <= 0x800000FF; ++leaf) {
187 AddCPUID(hasher, leaf, 0, ax, bx, cx, dx);
188 }
189}
190#endif
191} // namespace
192
193void RandAddDynamicEnv(CSHA512& hasher)
194{
195 // Various clocks
196#ifdef WIN32
197 FILETIME ftime;
198 GetSystemTimeAsFileTime(&ftime);
199 hasher << ftime;
200#else
201 struct timespec ts = {};
202# ifdef CLOCK_MONOTONIC
203 clock_gettime(CLOCK_MONOTONIC, &ts);
204 hasher << ts;
205# endif
206# ifdef CLOCK_REALTIME
207 clock_gettime(CLOCK_REALTIME, &ts);
208 hasher << ts;
209# endif
210# ifdef CLOCK_BOOTTIME
211 clock_gettime(CLOCK_BOOTTIME, &ts);
212 hasher << ts;
213# endif
214 // gettimeofday is available on all UNIX systems, but only has microsecond precision.
215 struct timeval tv = {};
216 gettimeofday(&tv, nullptr);
217 hasher << tv;
218#endif
219 // Probably redundant, but also use all the standard library clocks:
220 hasher << std::chrono::system_clock::now().time_since_epoch().count();
221 hasher << std::chrono::steady_clock::now().time_since_epoch().count();
222 hasher << std::chrono::high_resolution_clock::now().time_since_epoch().count();
223
224#ifndef WIN32
225 // Current resource usage.
226 struct rusage usage = {};
227 if (getrusage(RUSAGE_SELF, &usage) == 0) hasher << usage;
228#endif
229
230#ifdef __linux__
231 AddFile(hasher, "/proc/diskstats");
232 AddFile(hasher, "/proc/vmstat");
233 AddFile(hasher, "/proc/schedstat");
234 AddFile(hasher, "/proc/zoneinfo");
235 AddFile(hasher, "/proc/meminfo");
236 AddFile(hasher, "/proc/softirqs");
237 AddFile(hasher, "/proc/stat");
238 AddFile(hasher, "/proc/self/schedstat");
239 AddFile(hasher, "/proc/self/status");
240#endif
241
242#ifdef HAVE_SYSCTL
243# ifdef CTL_KERN
244# if defined(KERN_PROC) && defined(KERN_PROC_ALL)
245 AddSysctl<CTL_KERN, KERN_PROC, KERN_PROC_ALL>(hasher);
246# endif
247# endif
248# ifdef CTL_HW
249# ifdef HW_DISKSTATS
250 AddSysctl<CTL_HW, HW_DISKSTATS>(hasher);
251# endif
252# endif
253# ifdef CTL_VM
254# ifdef VM_LOADAVG
255 AddSysctl<CTL_VM, VM_LOADAVG>(hasher);
256# endif
257# ifdef VM_TOTAL
258 AddSysctl<CTL_VM, VM_TOTAL>(hasher);
259# endif
260# ifdef VM_METER
261 AddSysctl<CTL_VM, VM_METER>(hasher);
262# endif
263# endif
264#endif
265
266 // Stack and heap location
267 void* addr = malloc(4097);
268 hasher << &addr << addr;
269 free(addr);
270}
271
272void RandAddStaticEnv(CSHA512& hasher)
273{
274 // Some compile-time static properties
275 hasher << (CHAR_MIN < 0) << sizeof(void*) << sizeof(long) << sizeof(int);
276#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
277 hasher << __GNUC__ << __GNUC_MINOR__ << __GNUC_PATCHLEVEL__;
278#endif
279#ifdef _MSC_VER
280 hasher << _MSC_VER;
281#endif
282 hasher << __cplusplus;
283#ifdef _XOPEN_VERSION
284 hasher << _XOPEN_VERSION;
285#endif
286#ifdef __VERSION__
287 const char* COMPILER_VERSION = __VERSION__;
288 hasher.Write((const unsigned char*)COMPILER_VERSION, strlen(COMPILER_VERSION) + 1);
289#endif
290
291 // Bitcoin client version
292 hasher << CLIENT_VERSION;
293
294#if defined(HAVE_STRONG_GETAUXVAL)
295 // Information available through getauxval()
296# ifdef AT_HWCAP
297 hasher << getauxval(AT_HWCAP);
298# endif
299# ifdef AT_HWCAP2
300 hasher << getauxval(AT_HWCAP2);
301# endif
302# ifdef AT_RANDOM
303 const unsigned char* random_aux = (const unsigned char*)getauxval(AT_RANDOM);
304 if (random_aux) hasher.Write(random_aux, 16);
305# endif
306# ifdef AT_PLATFORM
307 const char* platform_str = (const char*)getauxval(AT_PLATFORM);
308 if (platform_str) hasher.Write((const unsigned char*)platform_str, strlen(platform_str) + 1);
309# endif
310# ifdef AT_EXECFN
311 const char* exec_str = (const char*)getauxval(AT_EXECFN);
312 if (exec_str) hasher.Write((const unsigned char*)exec_str, strlen(exec_str) + 1);
313# endif
314#endif // HAVE_STRONG_GETAUXVAL
315
316#ifdef HAVE_GETCPUID
317 AddAllCPUID(hasher);
318#endif
319
320 // Memory locations
321 hasher << &hasher << &RandAddStaticEnv << &malloc << &errno << &environ;
322
323 // Hostname
324#ifdef WIN32
325 constexpr DWORD max_size = MAX_COMPUTERNAME_LENGTH + 1;
326 char hname[max_size];
327 DWORD size = max_size;
328 if (GetComputerNameA(hname, &size) != 0) {
329 hasher.Write(UCharCast(hname), size);
330 }
331#else
332 char hname[256];
333 if (gethostname(hname, 256) == 0) {
334 hasher.Write((const unsigned char*)hname, strnlen(hname, 256));
335 }
336#endif
337
338#ifdef HAVE_IFADDRS
339 // Network interfaces
340 struct ifaddrs *ifad = nullptr;
341 getifaddrs(&ifad);
342 struct ifaddrs *ifit = ifad;
343 while (ifit != nullptr) {
344 hasher.Write((const unsigned char*)&ifit, sizeof(ifit));
345 hasher.Write((const unsigned char*)ifit->ifa_name, strlen(ifit->ifa_name) + 1);
346 hasher.Write((const unsigned char*)&ifit->ifa_flags, sizeof(ifit->ifa_flags));
347 AddSockaddr(hasher, ifit->ifa_addr);
348 AddSockaddr(hasher, ifit->ifa_netmask);
349 AddSockaddr(hasher, ifit->ifa_dstaddr);
350 ifit = ifit->ifa_next;
351 }
352 freeifaddrs(ifad);
353#endif
354
355#ifndef WIN32
356 // UNIX kernel information
357 struct utsname name;
358 if (uname(&name) != -1) {
359 hasher.Write((const unsigned char*)&name.sysname, strlen(name.sysname) + 1);
360 hasher.Write((const unsigned char*)&name.nodename, strlen(name.nodename) + 1);
361 hasher.Write((const unsigned char*)&name.release, strlen(name.release) + 1);
362 hasher.Write((const unsigned char*)&name.version, strlen(name.version) + 1);
363 hasher.Write((const unsigned char*)&name.machine, strlen(name.machine) + 1);
364 }
365
366 /* Path and filesystem provided data */
367 AddPath(hasher, "/");
368 AddPath(hasher, ".");
369 AddPath(hasher, "/tmp");
370 AddPath(hasher, "/home");
371 AddPath(hasher, "/proc");
372#ifdef __linux__
373 AddFile(hasher, "/proc/cmdline");
374 AddFile(hasher, "/proc/cpuinfo");
375 AddFile(hasher, "/proc/version");
376#endif
377 AddFile(hasher, "/etc/passwd");
378 AddFile(hasher, "/etc/group");
379 AddFile(hasher, "/etc/hosts");
380 AddFile(hasher, "/etc/resolv.conf");
381 AddFile(hasher, "/etc/timezone");
382 AddFile(hasher, "/etc/localtime");
383#endif
384
385 // For MacOS/BSDs, gather data through sysctl instead of /proc. Not all of these
386 // will exist on every system.
387#ifdef HAVE_SYSCTL
388# ifdef CTL_HW
389# ifdef HW_MACHINE
390 AddSysctl<CTL_HW, HW_MACHINE>(hasher);
391# endif
392# ifdef HW_MODEL
393 AddSysctl<CTL_HW, HW_MODEL>(hasher);
394# endif
395# ifdef HW_NCPU
396 AddSysctl<CTL_HW, HW_NCPU>(hasher);
397# endif
398# ifdef HW_PHYSMEM
399 AddSysctl<CTL_HW, HW_PHYSMEM>(hasher);
400# endif
401# ifdef HW_USERMEM
402 AddSysctl<CTL_HW, HW_USERMEM>(hasher);
403# endif
404# ifdef HW_MACHINE_ARCH
405 AddSysctl<CTL_HW, HW_MACHINE_ARCH>(hasher);
406# endif
407# ifdef HW_REALMEM
408 AddSysctl<CTL_HW, HW_REALMEM>(hasher);
409# endif
410# ifdef HW_CPU_FREQ
411 AddSysctl<CTL_HW, HW_CPU_FREQ>(hasher);
412# endif
413# ifdef HW_BUS_FREQ
414 AddSysctl<CTL_HW, HW_BUS_FREQ>(hasher);
415# endif
416# ifdef HW_CACHELINE
417 AddSysctl<CTL_HW, HW_CACHELINE>(hasher);
418# endif
419# endif
420# ifdef CTL_KERN
421# ifdef KERN_BOOTFILE
422 AddSysctl<CTL_KERN, KERN_BOOTFILE>(hasher);
423# endif
424# ifdef KERN_BOOTTIME
425 AddSysctl<CTL_KERN, KERN_BOOTTIME>(hasher);
426# endif
427# ifdef KERN_CLOCKRATE
428 AddSysctl<CTL_KERN, KERN_CLOCKRATE>(hasher);
429# endif
430# ifdef KERN_HOSTID
431 AddSysctl<CTL_KERN, KERN_HOSTID>(hasher);
432# endif
433# ifdef KERN_HOSTUUID
434 AddSysctl<CTL_KERN, KERN_HOSTUUID>(hasher);
435# endif
436# ifdef KERN_HOSTNAME
437 AddSysctl<CTL_KERN, KERN_HOSTNAME>(hasher);
438# endif
439# ifdef KERN_OSRELDATE
440 AddSysctl<CTL_KERN, KERN_OSRELDATE>(hasher);
441# endif
442# ifdef KERN_OSRELEASE
443 AddSysctl<CTL_KERN, KERN_OSRELEASE>(hasher);
444# endif
445# ifdef KERN_OSREV
446 AddSysctl<CTL_KERN, KERN_OSREV>(hasher);
447# endif
448# ifdef KERN_OSTYPE
449 AddSysctl<CTL_KERN, KERN_OSTYPE>(hasher);
450# endif
451# ifdef KERN_POSIX1
452 AddSysctl<CTL_KERN, KERN_OSREV>(hasher);
453# endif
454# ifdef KERN_VERSION
455 AddSysctl<CTL_KERN, KERN_VERSION>(hasher);
456# endif
457# endif
458#endif
459
460 // Env variables
461 if (environ) {
462 for (size_t i = 0; environ[i]; ++i) {
463 hasher.Write((const unsigned char*)environ[i], strlen(environ[i]));
464 }
465 }
466
467 // Process, thread, user, session, group, ... ids.
468#ifdef WIN32
469 hasher << GetCurrentProcessId() << GetCurrentThreadId();
470#else
471 hasher << getpid() << getppid() << getsid(0) << getpgid(0) << getuid() << geteuid() << getgid() << getegid();
472#endif
473 hasher << std::this_thread::get_id();
474}
ret
int ret
Definition bitcoin-cli.cpp:1691
operator<<
QDataStream & operator<<(QDataStream &out, const BitcoinUnit &unit)
Definition bitcoinunits.cpp:255
byte_units.h
CSHA512
A hasher class for SHA-512.
Definition sha512.h:13
CSHA512::Write
CSHA512 & Write(const unsigned char *data, size_t len)
Definition sha512.cpp:159
CLIENT_VERSION
constexpr int CLIENT_VERSION
Definition clientversion.h:26
T
#define T(expected, seed, data)
S
#define S(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)
Definition precomputed_ecmult.c:8
RandAddStaticEnv
void RandAddStaticEnv(CSHA512 &hasher)
Gather non-cryptographic environment data that does not change over time.
Definition randomenv.cpp:272
RandAddDynamicEnv
void RandAddDynamicEnv(CSHA512 &hasher)
Gather non-cryptographic environment data that changes over time.
Definition randomenv.cpp:193
UCharCast
unsigned char * UCharCast(char *c)
Definition span.h:95
Generated on for Bitcoin Core by doxygen 1.18.0