unit_test.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

    1 /*-
    2  * Copyright (c) 2000-2015 Mark R V Murray
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer
   10  *    in this position and unchanged.
   11  * 2. Redistributions in binary form must reproduce the above copyright
   12  *    notice, this list of conditions and the following disclaimer in the
   13  *    documentation and/or other materials provided with the distribution.
   14  *
   15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   25  *
   26  * $FreeBSD$
   27  */
   28 
   29 /*
   30  Build this by going:
   31 
   32 cc -g -O0 -pthread -DRANDOM_<alg> -I../.. -lstdthreads -Wall \
   33         unit_test.c \
   34         fortuna.c \
   35         hash.c \
   36         ../../crypto/rijndael/rijndael-api-fst.c \
   37         ../../crypto/rijndael/rijndael-alg-fst.c \
   38         ../../crypto/sha2/sha256c.c \
   39         -lz \
   40         -o unit_test
   41 ./unit_test
   42 
   43 Where <alg> is FORTUNA. The parameterisation is a leftover from
   44 when Yarrow was an option, and remains to enable the testing of
   45 possible future algorithms.
   46 */
   47 
   48 #include <sys/types.h>
   49 #include <inttypes.h>
   50 #include <stdbool.h>
   51 #include <stdio.h>
   52 #include <stdlib.h>
   53 #include <threads.h>
   54 #include <unistd.h>
   55 #include <zlib.h>
   56 
   57 #include "randomdev.h"
   58 #include "unit_test.h"
   59 
   60 #define NUM_THREADS       3
   61 #define DEBUG
   62 
   63 static volatile int stopseeding = 0;
   64 
   65 static __inline void
   66 check_err(int err, const char *func)
   67 {
   68         if (err != Z_OK) {
   69                 fprintf(stderr, "Compress error in %s: %d\n", func, err);
   70                 exit(0);
   71         }
   72 }
   73 
   74 void *
   75 myalloc(void *q, unsigned n, unsigned m)
   76 {
   77         q = Z_NULL;
   78         return (calloc(n, m));
   79 }
   80 
   81 void myfree(void *q, void *p)
   82 {
   83         q = Z_NULL;
   84         free(p);
   85 }
   86 
   87 size_t
   88 block_deflate(uint8_t *uncompr, uint8_t *compr, const size_t len)
   89 {
   90         z_stream c_stream;
   91         int err;
   92 
   93         if (len == 0)
   94                 return (0);
   95 
   96         c_stream.zalloc = myalloc;
   97         c_stream.zfree = myfree;
   98         c_stream.opaque = NULL;
   99 
  100         err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
  101         check_err(err, "deflateInit");
  102 
  103         c_stream.next_in  = uncompr;
  104         c_stream.next_out = compr;
  105         c_stream.avail_in = len;
  106         c_stream.avail_out = len*2u +512u;
  107 
  108         while (c_stream.total_in != len && c_stream.total_out < (len*2u + 512u)) {
  109                 err = deflate(&c_stream, Z_NO_FLUSH);
  110 #ifdef DEBUG
  111                 printf("deflate progress: len = %zd  total_in = %lu  total_out = %lu\n", len, c_stream.total_in, c_stream.total_out);
  112 #endif
  113                 check_err(err, "deflate(..., Z_NO_FLUSH)");
  114         }
  115 
  116         for (;;) {
  117                 err = deflate(&c_stream, Z_FINISH);
  118 #ifdef DEBUG
  119                 printf("deflate    final: len = %zd  total_in = %lu  total_out = %lu\n", len, c_stream.total_in, c_stream.total_out);
  120 #endif
  121                 if (err == Z_STREAM_END) break;
  122                 check_err(err, "deflate(..., Z_STREAM_END)");
  123         }
  124 
  125         err = deflateEnd(&c_stream);
  126         check_err(err, "deflateEnd");
  127 
  128         return ((size_t)c_stream.total_out);
  129 }
  130 
  131 void
  132 randomdev_unblock(void)
  133 {
  134 
  135 #if 0
  136         if (mtx_trylock(&random_reseed_mtx) == thrd_busy)
  137                 printf("Mutex held. Good.\n");
  138         else {
  139                 printf("Mutex not held. PANIC!!\n");
  140                 thrd_exit(0);
  141         }
  142 #endif
  143         printf("random: unblocking device.\n");
  144 }
  145 
  146 static int
  147 RunHarvester(void *arg __unused)
  148 {
  149         int i, r;
  150         struct harvest_event e;
  151 
  152         for (i = 0; ; i++) {
  153                 if (stopseeding)
  154                         break;
  155                 if (i % 1000 == 0)
  156                         printf("Harvest: %d\n", i);
  157                 r = random()%10;
  158                 e.he_somecounter = i;
  159                 *((uint64_t *)e.he_entropy) = random();
  160                 e.he_size = 8;
  161                 e.he_destination = i;
  162                 e.he_source = (i + 3)%7;
  163                 e.he_next = NULL;
  164                 random_alg_context.ra_event_processor(&e);
  165                 usleep(r);
  166         }
  167 
  168         printf("Thread #0 ends\n");
  169 
  170         thrd_exit(0);
  171 
  172         return (0);
  173 }
  174 
  175 static int
  176 ReadCSPRNG(void *threadid)
  177 {
  178         size_t tid, zsize;
  179         u_int buffersize;
  180         uint8_t *buf, *zbuf;
  181         int i;
  182 #ifdef DEBUG
  183         int j;
  184 #endif
  185 
  186         tid = (size_t)threadid;
  187         printf("Thread #%zd starts\n", tid);
  188 
  189         while (!random_alg_context.ra_seeded())
  190         {
  191                 random_alg_context.ra_pre_read();
  192                 usleep(100);
  193         }
  194 
  195         for (i = 0; i < 100000; i++) {
  196                 buffersize = i + RANDOM_BLOCKSIZE;
  197                 buffersize -= buffersize%RANDOM_BLOCKSIZE;
  198                 buf = malloc(buffersize);
  199                 zbuf = malloc(2*i + 1024);
  200                 if (i % 1000 == 0)
  201                         printf("Thread read %zd - %d\n", tid, i);
  202                 if (buf != NULL && zbuf != NULL) {
  203                         random_alg_context.ra_pre_read();
  204                         random_alg_context.ra_read(buf, buffersize);
  205                         zsize = block_deflate(buf, zbuf, i);
  206                         if (zsize < i)
  207                                 printf("ERROR!! Compressible RNG output!\n");
  208 #ifdef DEBUG
  209                         printf("RNG output:\n");
  210                         for (j = 0; j < i; j++) {
  211                                 printf(" %02X", buf[j]);
  212                                 if (j % 32 == 31 || j == i - 1)
  213                                         printf("\n");
  214                         }
  215                         printf("Compressed output:\n");
  216                         for (j = 0; j < zsize; j++) {
  217                                 printf(" %02X", zbuf[j]);
  218                                 if (j % 32 == 31 || j == zsize - 1)
  219                                         printf("\n");
  220                         }
  221 #endif
  222                         free(zbuf);
  223                         free(buf);
  224                 }
  225                 usleep(100);
  226         }
  227 
  228         printf("Thread #%zd ends\n", tid);
  229 
  230         thrd_exit(0);
  231 
  232         return (0);
  233 }
  234 
  235 int
  236 main(int argc, char *argv[])
  237 {
  238         thrd_t threads[NUM_THREADS];
  239         int rc;
  240         long t;
  241 
  242         random_alg_context.ra_init_alg(NULL);
  243 
  244         for (t = 0; t < NUM_THREADS; t++) {
  245                 printf("In main: creating thread %ld\n", t);
  246                 rc = thrd_create(&threads[t], (t == 0 ? RunHarvester : ReadCSPRNG), NULL);
  247                 if (rc != thrd_success) {
  248                         printf("ERROR; return code from thrd_create() is %d\n", rc);
  249                         exit(-1);
  250                 }
  251         }
  252 
  253         for (t = 2; t < NUM_THREADS; t++)
  254                 thrd_join(threads[t], &rc);
  255 
  256         stopseeding = 1;
  257 
  258         thrd_join(threads[1], &rc);
  259         thrd_join(threads[0], &rc);
  260 
  261         random_alg_context.ra_deinit_alg(NULL);
  262 
  263         /* Last thing that main() should do */
  264         thrd_exit(0);
  265 
  266         return (0);
  267 }

Cache object: 20d969f3fb9a97d911182a58868edf59

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.

FreeBSD/Linux Kernel Cross Reference sys/dev/random/unit_test.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/random/unit_test.c