C++ random_bytes函数代码示例

void
test_main (void) 
{
  int fd_a, fd_b;
  size_t ofs_a = 0, ofs_b = 0;

  random_init (0);
  random_bytes (buf_a, sizeof buf_a);
  random_bytes (buf_b, sizeof buf_b);

  CHECK (create ("a", 0), "create \"a\"");
  CHECK (create ("b", 0), "create \"b\"");

  CHECK ((fd_a = open ("a")) > 1, "open \"a\"");
  CHECK ((fd_b = open ("b")) > 1, "open \"b\"");

  msg ("write \"a\" and \"b\" alternately");
  while (ofs_a < FILE_SIZE || ofs_b < FILE_SIZE) 
    {
      write_some_bytes ("a", fd_a, buf_a, &ofs_a);
      write_some_bytes ("b", fd_b, buf_b, &ofs_b);
    }

  msg ("close \"a\"");
  close (fd_a);

  msg ("close \"b\"");
  close (fd_b);

  check_file ("a", buf_a, FILE_SIZE);
  check_file ("b", buf_b, FILE_SIZE);
}

void init_key() {
  unsigned char binkey[64];
  random_bytes((unsigned char *)&secret_key_len, sizeof(secret_key_len));
  secret_key_len &= 0x7fffffff;
  secret_key_len = (16 + secret_key_len % 16);
  
  random_bytes(binkey, secret_key_len);
  // secret_key is null terminated
  hexencode(binkey, secret_key_len, secret_key);
  //  printf("key_len: %d\n", secret_key_len);
  //printf("%s\n", secret_key);
}

int arc_encode(char *clear, int clear_len, unsigned char **crypt, char *password, int pad_to)
{
	struct arc_state *st;
	unsigned char *key;
	char *padded = NULL;
	int key_len, i, padded_len;

	key_len = strlen(password) + ARC_IV_LEN;
	if (clear_len <= 0) {
		clear_len = strlen(clear);
	}

	/* Pad the string to the closest multiple of pad_to. This makes it
	   impossible to see the exact length of the password. */
	if (pad_to > 0 && (clear_len % pad_to) > 0) {
		padded_len = clear_len + pad_to - (clear_len % pad_to);
		padded = g_malloc(padded_len);
		memcpy(padded, clear, clear_len);

		/* First a \0 and then random data, so we don't have to do
		   anything special when decrypting. */
		padded[clear_len] = 0;
		random_bytes((unsigned char *) padded + clear_len + 1, padded_len - clear_len - 1);

		clear = padded;
		clear_len = padded_len;
	}

	/* Prepare buffers and the key + IV */
	*crypt = g_malloc(clear_len + ARC_IV_LEN);
	key = g_malloc(key_len);
	strcpy((char *) key, password);

	/* Add the salt. Save it for later (when decrypting) and, of course,
	   add it to the encryption key. */
	random_bytes(crypt[0], ARC_IV_LEN);
	memcpy(key + key_len - ARC_IV_LEN, crypt[0], ARC_IV_LEN);

	/* Generate the initial S[] from the IVed key. */
	st = arc_keymaker(key, key_len, ARC_CYCLES);
	g_free(key);

	for (i = 0; i < clear_len; i++) {
		crypt[0][i + ARC_IV_LEN] = clear[i] ^ arc_getbyte(st);
	}

	g_free(st);
	g_free(padded);

	return clear_len + ARC_IV_LEN;
}

/**
 * Test implementation.
 */
void G_COLD
tea_test(void)
{
	tea_key_t key;
	tea_block_t value;
	tea_block_t encrypted;
	tea_block_t decrypted;
	int i;
	char in[80];
	char out[80];
	char recovered[80];

	STATIC_ASSERT(sizeof(key.v) == TEA_KEY_SIZE);
	STATIC_ASSERT(sizeof(value.v) == TEA_BLOCK_SIZE);

	for (i = 0; i < 10; i++) {
		int j;
		bool randomized = FALSE;

		for (j = 0; j < 10; j++) {
			random_bytes(key.v, TEA_KEY_SIZE);
			random_bytes(value.v, TEA_BLOCK_SIZE);

			t_encrypt(&encrypted, &key, &value);
			if (0 != memcmp(value.v, encrypted.v, TEA_BLOCK_SIZE)) {
				randomized = TRUE;
				break;
			}
		}

		if (!randomized)
			g_error("no luck with random numbers in tea_test()");

		t_decrypt(&decrypted, &key, &encrypted);
		if (0 != memcmp(value.v, decrypted.v, TEA_BLOCK_SIZE)) {
			g_error("TEA implementation tests FAILED");
			return;
		}
	}

	STATIC_ASSERT(sizeof in == sizeof out);
	STATIC_ASSERT(sizeof in == sizeof recovered);

	random_bytes(key.v, TEA_KEY_SIZE);
	random_bytes(in, sizeof in);
	tea_encrypt(&key, out, in, sizeof in);
	tea_decrypt(&key, recovered, out, sizeof out);

	if (0 != memcmp(in, recovered, sizeof in))
		g_error("TEA implementation tests FAILED");
}

int main(int argc, char *argv[]) {
  int i, wait1, wait2, seed, start;
  unsigned int value;

  signal(SIGINT, SIGINT_handler);

  if(argc < 2) {
    random_bytes((unsigned char *)&wait1, sizeof(wait1));
    wait1 &= 0x7fffffff;
    wait1 = wait1 % 960 + 40;
    
    random_bytes((unsigned char *)&wait2, sizeof(wait2));
    wait2 &= 0x7fffffff;
    wait2 = wait2 % 960 + 40;
    
    printf("about to spend %d seconds running bad crypto code, OK?\n", wait1 + wait2);
    
    if(sleep(wait1)) {
      printf("sleep was interrupted\n");
    }
    
    seed = time(NULL);  
    FILE *fp = fopen("seed", "w");
    fprintf(fp, "%d", seed);
    fclose(fp);
    
    MT_initialize_generator(seed);
    
    sleep(wait2);  
    
    printf("secret: %u\n", MT_extract_number());
  } else {
    sscanf(argv[1], "%u", &value);
    if(argc > 2)
      sscanf(argv[2], "%d", &start);
    else
      start = time(NULL);

    printf("brute force search for seed generating %u, starting at %d\n", value, start);

    do {
      MT_initialize_generator(start--);
    } while(MT_extract_number() != value);
    start++;
    printf("generator seeded with: %d\n", start);
  }

  return 0;
}

void
seq_test (const char *file_name, void *buf, size_t size, size_t initial_size,
          size_t (*block_size_func) (void),
          void (*check_func) (int fd, long ofs))
{
  size_t ofs;
  int fd;

  random_bytes (buf, size);
  CHECK (create (file_name, initial_size), "create \"%s\"", file_name);
  CHECK ((fd = open (file_name)) > 1, "open \"%s\"", file_name);

  ofs = 0;
  msg ("writing \"%s\"", file_name);
  while (ofs < size)
    {
      size_t block_size = block_size_func ();
      if (block_size > size - ofs)
        block_size = size - ofs;

      if (write (fd, buf + ofs, block_size) != (int) block_size)
        fail ("write %zu bytes at offset %zu in \"%s\" failed",
              block_size, ofs, file_name);

      ofs += block_size;
      if (check_func != NULL)
        check_func (fd, ofs);
    }
  msg ("close \"%s\"", file_name);
  close (fd);
  check_file (file_name, buf, size);
}

static void test_acquire_data_fd_one(unsigned flags) {
        char wbuffer[196*1024 - 7];
        char rbuffer[sizeof(wbuffer)];
        int fd;

        fd = acquire_data_fd("foo", 3, flags);
        assert_se(fd >= 0);

        zero(rbuffer);
        assert_se(read(fd, rbuffer, sizeof(rbuffer)) == 3);
        assert_se(streq(rbuffer, "foo"));

        fd = safe_close(fd);

        fd = acquire_data_fd("", 0, flags);
        assert_se(fd >= 0);

        zero(rbuffer);
        assert_se(read(fd, rbuffer, sizeof(rbuffer)) == 0);
        assert_se(streq(rbuffer, ""));

        fd = safe_close(fd);

        random_bytes(wbuffer, sizeof(wbuffer));

        fd = acquire_data_fd(wbuffer, sizeof(wbuffer), flags);
        assert_se(fd >= 0);

        zero(rbuffer);
        assert_se(read(fd, rbuffer, sizeof(rbuffer)) == sizeof(rbuffer));
        assert_se(memcmp(rbuffer, wbuffer, sizeof(rbuffer)) == 0);

        fd = safe_close(fd);
}

int
main (int argc, const char *argv[]) 
{
  int child_idx;
  int fd;
  size_t i;

  quiet = true;
  
  CHECK (argc == 2, "argc must be 2, actually %d", argc);
  child_idx = atoi (argv[1]);

  random_init (0);
  random_bytes (buf, sizeof buf);

  CHECK ((fd = open (file_name)) > 1, "open \"%s\"", file_name);
  for (i = 0; i < sizeof buf; i++) 
    {
      char c;
      CHECK (read (fd, &c, 1) > 0, "read \"%s\"", file_name);
      compare_bytes (&c, buf + i, 1, i, file_name);
    }
  close (fd);

  return child_idx;
}

int
main (int argc, const char *argv[])
{
  int child_idx;
  int fd;
  size_t ofs;

  quiet = true;

  CHECK (argc == 2, "argc must be 2, actually %d", argc);
  child_idx = atoi (argv[1]);

  random_init (0);
  random_bytes (buf1, sizeof buf1);

  CHECK ( (fd = open (file_name)) > 1, "open \"%s\"", file_name);
  ofs = 0;
  while (ofs < sizeof buf2)
    {
      int bytes_read = read (fd, buf2 + ofs, sizeof buf2 - ofs);
      CHECK (bytes_read >= -1 && bytes_read <= (int) (sizeof buf2 - ofs),
             "%zu-byte read on \"%s\" returned invalid value of %d",
             sizeof buf2 - ofs, file_name, bytes_read);
      if (bytes_read > 0)
        {
          compare_bytes (buf2 + ofs, buf1 + ofs, bytes_read, ofs, file_name);
          ofs += bytes_read;
        }
    }
  close (fd);

  return child_idx;
}

END_TEST

START_TEST(random_bytes_returns_random_bytes) {
  random_t random;
  random_create(random);

  uint8_t a[16] = {};
  uint8_t b[16] = {};

  random_bytes(random, a, 16);
  random_bytes(random, b, 16);

  fail_unless(memcmp(a, b, 16) != 0);

  random_free(random);
}

static
void write_offer(struct master_config* config, struct endpoint* endpoint, struct udpaddress* remote) {
    char* key;
    char token[1500];
    char obuf[1500];
    ssize_t tlength, olength, r;
    struct proto proto;
    struct session* session;
    struct cipher_context* rkey = config->key0;

    key = alloca(config->cipher_keysize);
    random_bytes(key, config->cipher_keysize);

    session = session_find_by_address(config, &endpoint->local, remote);
    if (session) {
        if (session->rkey) {
            rkey = session->rkey;
        }
    }

    tlength = encrypt_challenge(config, remote, &endpoint->local, session ? session->key1 : 0, key, token);

    memset(&proto, 0, sizeof(proto));
    proto.type = PROTO_OFFER;
    proto.id.value = token;
    proto.id.length = tlength;
    proto.key.value = key;
    proto.key.length = config->cipher_keysize;
    olength = proto_encode(&proto, obuf, sizeof(obuf));

    encrypt_and_write(config, endpoint->socket, remote, rkey, obuf, olength);
}

/* Returns a pseudo-random unsigned long.
   Use random_ulong() % n to obtain a random number in the range
   0...n (exclusive). */
unsigned long
random_ulong (void) 
{
  unsigned long ul;
  random_bytes (&ul, sizeof ul);
  return ul;
}

bool test_encode_base64 (Test *test)
{
        char *base64;
        char bytes[1024 * 16];
        size_t i;

        TITLE ();
        CATCH (encode_base64 (NULL, 0));
        CATCH (error_at (0).error != ErrorInvalidArgument);
        CATCH (error_at (0).code != 1);
        CATCH (encode_base64 ("", 0));
        CATCH (error_at (0).error != ErrorInvalidArgument);
        CATCH (error_at (0).code != 2);
        memory_commit_limit (0);
        CATCH (encode_base64 ("abc", 3));
        CATCH (error_at (0).error != ErrorFunctionCall);
        memory_commit_limit (ULLONG_MAX);

        for (i = 0; i < 1000; i++) {
                CATCH (!(base64 = encode_base64 ("any carnal pleasure.", 20)));
                CATCH (!string_equals (base64, "YW55IGNhcm5hbCBwbGVhc3VyZS4="));
                string_destroy (base64);
        }

        CATCH (!random_open ());
        for (i = 0; i < 1000; i++) {
                CATCH (!random_bytes ((unsigned char *)&bytes, 1024 * 16));
                CATCH (!(base64 = encode_base64 (bytes, 1024 * 16)));
                CATCH (string_length (base64) < 21848);
                string_destroy (base64);
        }
        random_close ();
        PASS ();
}

static void random_key(secp256k1_context *ctx,
		       struct seckey *seckey, secp256k1_pubkey *pkey)
{
	do {
		random_bytes(seckey->u.u8, sizeof(seckey->u));
	} while (!secp256k1_ec_pubkey_create(ctx, pkey, seckey->u.u8));
}

/*
 * Return a new random number.
 */
u32_t magic() {
  u32_t new_rand;

  random_bytes((unsigned char *)&new_rand, sizeof(new_rand));

  return new_rand;
}