npcm7xx_rng-test.c (8239B)
1 /* 2 * QTest testcase for the Nuvoton NPCM7xx Random Number Generator 3 * 4 * Copyright 2020 Google LLC 5 * 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License as published by the 8 * Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * for more details. 15 */ 16 17 #include "qemu/osdep.h" 18 19 #include <math.h> 20 21 #include "libqtest-single.h" 22 #include "qemu/bitops.h" 23 #include "qemu/cutils.h" 24 25 #define RNG_BASE_ADDR 0xf000b000 26 27 /* Control and Status Register */ 28 #define RNGCS 0x00 29 # define DVALID BIT(1) /* Data Valid */ 30 # define RNGE BIT(0) /* RNG Enable */ 31 /* Data Register */ 32 #define RNGD 0x04 33 /* Mode Register */ 34 #define RNGMODE 0x08 35 # define ROSEL_NORMAL (2) /* RNG only works in this mode */ 36 37 /* Number of bits to collect for randomness tests. */ 38 #define TEST_INPUT_BITS (128) 39 40 static void dump_buf_if_failed(const uint8_t *buf, size_t size) 41 { 42 if (g_test_failed()) { 43 qemu_hexdump(stderr, "", buf, size); 44 } 45 } 46 47 static void rng_writeb(unsigned int offset, uint8_t value) 48 { 49 writeb(RNG_BASE_ADDR + offset, value); 50 } 51 52 static uint8_t rng_readb(unsigned int offset) 53 { 54 return readb(RNG_BASE_ADDR + offset); 55 } 56 57 /* Disable RNG and set normal ring oscillator mode. */ 58 static void rng_reset(void) 59 { 60 rng_writeb(RNGCS, 0); 61 rng_writeb(RNGMODE, ROSEL_NORMAL); 62 } 63 64 /* Reset RNG and then enable it. */ 65 static void rng_reset_enable(void) 66 { 67 rng_reset(); 68 rng_writeb(RNGCS, RNGE); 69 } 70 71 /* Wait until Data Valid bit is set. */ 72 static bool rng_wait_ready(void) 73 { 74 /* qemu_guest_getrandom may fail. Assume it won't fail 10 times in a row. */ 75 int retries = 10; 76 77 while (retries-- > 0) { 78 if (rng_readb(RNGCS) & DVALID) { 79 return true; 80 } 81 } 82 83 return false; 84 } 85 86 /* 87 * Perform a frequency (monobit) test, as defined by NIST SP 800-22, on the 88 * sequence in buf and return the P-value. This represents the probability of a 89 * truly random sequence having the same proportion of zeros and ones as the 90 * sequence in buf. 91 * 92 * An RNG which always returns 0x00 or 0xff, or has some bits stuck at 0 or 1, 93 * will fail this test. However, an RNG which always returns 0x55, 0xf0 or some 94 * other value with an equal number of zeroes and ones will pass. 95 */ 96 static double calc_monobit_p(const uint8_t *buf, unsigned int len) 97 { 98 unsigned int i; 99 double s_obs; 100 int sn = 0; 101 102 for (i = 0; i < len; i++) { 103 /* 104 * Each 1 counts as 1, each 0 counts as -1. 105 * s = cp - (8 - cp) = 2 * cp - 8 106 */ 107 sn += 2 * ctpop8(buf[i]) - 8; 108 } 109 110 s_obs = abs(sn) / sqrt(len * BITS_PER_BYTE); 111 112 return erfc(s_obs / sqrt(2)); 113 } 114 115 /* 116 * Perform a runs test, as defined by NIST SP 800-22, and return the P-value. 117 * This represents the probability of a truly random sequence having the same 118 * number of runs (i.e. uninterrupted sequences of identical bits) as the 119 * sequence in buf. 120 */ 121 static double calc_runs_p(const unsigned long *buf, unsigned int nr_bits) 122 { 123 unsigned int j; 124 unsigned int k; 125 int nr_ones = 0; 126 int vn_obs = 0; 127 double pi; 128 129 g_assert(nr_bits % BITS_PER_LONG == 0); 130 131 for (j = 0; j < nr_bits / BITS_PER_LONG; j++) { 132 nr_ones += __builtin_popcountl(buf[j]); 133 } 134 pi = (double)nr_ones / nr_bits; 135 136 for (k = 0; k < nr_bits - 1; k++) { 137 vn_obs += (test_bit(k, buf) ^ test_bit(k + 1, buf)); 138 } 139 vn_obs += 1; 140 141 return erfc(fabs(vn_obs - 2 * nr_bits * pi * (1.0 - pi)) 142 / (2 * sqrt(2 * nr_bits) * pi * (1.0 - pi))); 143 } 144 145 /* 146 * Verifies that DVALID is clear, and RNGD reads zero, when RNGE is cleared, 147 * and DVALID eventually becomes set when RNGE is set. 148 */ 149 static void test_enable_disable(void) 150 { 151 /* Disable: DVALID should not be set, and RNGD should read zero */ 152 rng_reset(); 153 g_assert_cmphex(rng_readb(RNGCS), ==, 0); 154 g_assert_cmphex(rng_readb(RNGD), ==, 0); 155 156 /* Enable: DVALID should be set, but we can't make assumptions about RNGD */ 157 rng_writeb(RNGCS, RNGE); 158 g_assert_true(rng_wait_ready()); 159 g_assert_cmphex(rng_readb(RNGCS), ==, DVALID | RNGE); 160 161 /* Disable: DVALID should not be set, and RNGD should read zero */ 162 rng_writeb(RNGCS, 0); 163 g_assert_cmphex(rng_readb(RNGCS), ==, 0); 164 g_assert_cmphex(rng_readb(RNGD), ==, 0); 165 } 166 167 /* 168 * Verifies that the RNG only produces data when RNGMODE is set to 'normal' 169 * ring oscillator mode. 170 */ 171 static void test_rosel(void) 172 { 173 rng_reset_enable(); 174 g_assert_true(rng_wait_ready()); 175 rng_writeb(RNGMODE, 0); 176 g_assert_false(rng_wait_ready()); 177 rng_writeb(RNGMODE, ROSEL_NORMAL); 178 g_assert_true(rng_wait_ready()); 179 rng_writeb(RNGMODE, 0); 180 g_assert_false(rng_wait_ready()); 181 } 182 183 /* 184 * Verifies that a continuous sequence of bits collected after enabling the RNG 185 * satisfies a monobit test. 186 */ 187 static void test_continuous_monobit(void) 188 { 189 uint8_t buf[TEST_INPUT_BITS / BITS_PER_BYTE]; 190 unsigned int i; 191 192 rng_reset_enable(); 193 for (i = 0; i < sizeof(buf); i++) { 194 g_assert_true(rng_wait_ready()); 195 buf[i] = rng_readb(RNGD); 196 } 197 198 g_assert_cmpfloat(calc_monobit_p(buf, sizeof(buf)), >, 0.01); 199 dump_buf_if_failed(buf, sizeof(buf)); 200 } 201 202 /* 203 * Verifies that a continuous sequence of bits collected after enabling the RNG 204 * satisfies a runs test. 205 */ 206 static void test_continuous_runs(void) 207 { 208 union { 209 unsigned long l[TEST_INPUT_BITS / BITS_PER_LONG]; 210 uint8_t c[TEST_INPUT_BITS / BITS_PER_BYTE]; 211 } buf; 212 unsigned int i; 213 214 rng_reset_enable(); 215 for (i = 0; i < sizeof(buf); i++) { 216 g_assert_true(rng_wait_ready()); 217 buf.c[i] = rng_readb(RNGD); 218 } 219 220 g_assert_cmpfloat(calc_runs_p(buf.l, sizeof(buf) * BITS_PER_BYTE), >, 0.01); 221 dump_buf_if_failed(buf.c, sizeof(buf)); 222 } 223 224 /* 225 * Verifies that the first data byte collected after enabling the RNG satisfies 226 * a monobit test. 227 */ 228 static void test_first_byte_monobit(void) 229 { 230 /* Enable, collect one byte, disable. Repeat until we have 100 bits. */ 231 uint8_t buf[TEST_INPUT_BITS / BITS_PER_BYTE]; 232 unsigned int i; 233 234 rng_reset(); 235 for (i = 0; i < sizeof(buf); i++) { 236 rng_writeb(RNGCS, RNGE); 237 g_assert_true(rng_wait_ready()); 238 buf[i] = rng_readb(RNGD); 239 rng_writeb(RNGCS, 0); 240 } 241 242 g_assert_cmpfloat(calc_monobit_p(buf, sizeof(buf)), >, 0.01); 243 dump_buf_if_failed(buf, sizeof(buf)); 244 } 245 246 /* 247 * Verifies that the first data byte collected after enabling the RNG satisfies 248 * a runs test. 249 */ 250 static void test_first_byte_runs(void) 251 { 252 /* Enable, collect one byte, disable. Repeat until we have 100 bits. */ 253 union { 254 unsigned long l[TEST_INPUT_BITS / BITS_PER_LONG]; 255 uint8_t c[TEST_INPUT_BITS / BITS_PER_BYTE]; 256 } buf; 257 unsigned int i; 258 259 rng_reset(); 260 for (i = 0; i < sizeof(buf); i++) { 261 rng_writeb(RNGCS, RNGE); 262 g_assert_true(rng_wait_ready()); 263 buf.c[i] = rng_readb(RNGD); 264 rng_writeb(RNGCS, 0); 265 } 266 267 g_assert_cmpfloat(calc_runs_p(buf.l, sizeof(buf) * BITS_PER_BYTE), >, 0.01); 268 dump_buf_if_failed(buf.c, sizeof(buf)); 269 } 270 271 int main(int argc, char **argv) 272 { 273 int ret; 274 275 g_test_init(&argc, &argv, NULL); 276 g_test_set_nonfatal_assertions(); 277 278 qtest_add_func("npcm7xx_rng/enable_disable", test_enable_disable); 279 qtest_add_func("npcm7xx_rng/rosel", test_rosel); 280 /* 281 * These tests fail intermittently; only run them on explicit 282 * request until we figure out why. 283 */ 284 if (getenv("QEMU_TEST_FLAKY_RNG_TESTS")) { 285 qtest_add_func("npcm7xx_rng/continuous/monobit", test_continuous_monobit); 286 qtest_add_func("npcm7xx_rng/continuous/runs", test_continuous_runs); 287 qtest_add_func("npcm7xx_rng/first_byte/monobit", test_first_byte_monobit); 288 qtest_add_func("npcm7xx_rng/first_byte/runs", test_first_byte_runs); 289 } 290 291 qtest_start("-machine npcm750-evb"); 292 ret = g_test_run(); 293 qtest_end(); 294 295 return ret; 296 }