int
main() {
    uint32_t i, irecvd, idiff;
    ut_connection utc;

    ut_init(&utc);

    for (i=0; i < 1000; i++) {
        irecvd = ut_next_index(&utc);
        idiff = i - irecvd;
        printf("%lu\t%lu\t%d\n", i, irecvd, idiff);
    }

    return 0;
}
Beispiel #2
0
err_status_t
test_rdb_db() {
  rdb_t rdb;
  uint32_t idx, ircvd;
  ut_connection utc;
  err_status_t err;

  if (rdb_init(&rdb) != err_status_ok) {
    printf("rdb_init failed\n");
    return err_status_init_fail;
  }

  /* test sequential insertion */
  for (idx=0; idx < num_trials; idx++) {
    err = rdb_check_add(&rdb, idx);
    if (err) 
      return err;
  }

  /* test for false positives */
  for (idx=0; idx < num_trials; idx++) {
    err = rdb_check_expect_failure(&rdb, idx);
    if (err) 
      return err;
  }

  /* re-initialize */
  if (rdb_init(&rdb) != err_status_ok) {
    printf("rdb_init failed\n");
    return err_status_fail;
  }

  /* test non-sequential insertion */
  ut_init(&utc);
  
  for (idx=0; idx < num_trials; idx++) {
    ircvd = ut_next_index(&utc);
    err = rdb_check_unordered(&rdb, ircvd);
    if (err) 
      return err;
  }

  return err_status_ok;
}
Beispiel #3
0
srtp_err_status_t test_rdb_db()
{
    srtp_rdb_t rdb;
    uint32_t idx, ircvd;
    ut_connection utc;
    srtp_err_status_t err;

    if (srtp_rdb_init(&rdb) != srtp_err_status_ok) {
        printf("rdb_init failed\n");
        return srtp_err_status_init_fail;
    }

    /* test sequential insertion */
    for (idx = 0; idx < num_trials; idx++) {
        err = rdb_check_add(&rdb, idx);
        if (err)
            return err;
    }

    /* test for false positives */
    for (idx = 0; idx < num_trials; idx++) {
        err = rdb_check_expect_failure(&rdb, idx);
        if (err)
            return err;
    }

    /* re-initialize */
    if (srtp_rdb_init(&rdb) != srtp_err_status_ok) {
        printf("rdb_init failed\n");
        return srtp_err_status_fail;
    }

    /* test non-sequential insertion */
    ut_init(&utc);

    for (idx = 0; idx < num_trials; idx++) {
        ircvd = ut_next_index(&utc);
        err = rdb_check_add_unordered(&rdb, ircvd);
        if (err)
            return err;
        err = rdb_check_expect_failure(&rdb, ircvd);
        if (err)
            return err;
    }

    /* re-initialize */
    if (srtp_rdb_init(&rdb) != srtp_err_status_ok) {
        printf("rdb_init failed\n");
        return srtp_err_status_fail;
    }

    /* test insertion with large gaps */
    for (idx = 0, ircvd = 0; idx < num_trials;
         idx++, ircvd += (1 << (srtp_cipher_rand_u32_for_tests() % 10))) {
        err = rdb_check_add(&rdb, ircvd);
        if (err)
            return err;
        err = rdb_check_expect_failure(&rdb, ircvd);
        if (err)
            return err;
    }

    /* re-initialize */
    if (srtp_rdb_init(&rdb) != srtp_err_status_ok) {
        printf("rdb_init failed\n");
        return srtp_err_status_fail;
    }

    /* test loss of first 513 packets */
    for (idx = 0; idx < num_trials; idx++) {
        err = rdb_check_add(&rdb, idx + 513);
        if (err)
            return err;
    }

    /* test for false positives */
    for (idx = 0; idx < num_trials + 513; idx++) {
        err = rdb_check_expect_failure(&rdb, idx);
        if (err)
            return err;
    }

    /* test for key expired */
    if (srtp_rdb_init(&rdb) != srtp_err_status_ok) {
        printf("rdb_init failed\n");
        return srtp_err_status_fail;
    }
    rdb.window_start = 0x7ffffffe;
    if (srtp_rdb_increment(&rdb) != srtp_err_status_ok) {
        printf("srtp_rdb_increment of 0x7ffffffe failed\n");
        return srtp_err_status_fail;
    }
    if (srtp_rdb_get_value(&rdb) != 0x7fffffff) {
        printf("rdb valiue was not 0x7fffffff\n");
        return srtp_err_status_fail;
    }
    if (srtp_rdb_increment(&rdb) != srtp_err_status_key_expired) {
        printf("srtp_rdb_increment of 0x7fffffff did not return "
               "srtp_err_status_key_expired\n");
        return srtp_err_status_fail;
    }
    if (srtp_rdb_get_value(&rdb) != 0x7fffffff) {
        printf("rdb valiue was not 0x7fffffff\n");
        return srtp_err_status_fail;
    }

    return srtp_err_status_ok;
}
err_status_t
test_replay_dbx(int num_trials, unsigned long ws) {
  rdbx_t rdbx;
  uint32_t idx, ircvd;
  ut_connection utc;
  err_status_t status;
  int num_fp_trials;

  status = rdbx_init(&rdbx, ws);
  if (status) {
    printf("replay_init failed with error code %d\n", status);
    exit(1);
  }

  /*
   *  test sequential insertion 
   */
  printf("\ttesting sequential insertion...");
  for (idx=0; idx < (uint32_t)num_trials; idx++) {
    status = rdbx_check_add(&rdbx, idx);
    if (status)
      return status;
  }
  printf("passed\n");

  /*
   *  test for false positives by checking all of the index
   *  values which we've just added
   *
   * note that we limit the number of trials here, since allowing the
   * rollover counter to roll over would defeat this test
   */
  num_fp_trials = num_trials % 0x10000;
  if (num_fp_trials == 0) {
    printf("warning: no false positive tests performed\n");
  }
  printf("\ttesting for false positives...");
  for (idx=0; idx < (uint32_t)num_fp_trials; idx++) {
    status = rdbx_check_expect_failure(&rdbx, idx);
    if (status)
      return status;
  }
  printf("passed\n");

  /* re-initialize */
  rdbx_uninit(&rdbx);

  if (rdbx_init(&rdbx, ws) != err_status_ok) {
    printf("replay_init failed\n");
    return err_status_init_fail;
  }

  /*
   * test non-sequential insertion 
   *
   * this test covers only fase negatives, since the values returned
   * by ut_next_index(...) are distinct
   */
  ut_init(&utc);

  printf("\ttesting non-sequential insertion...");  
  for (idx=0; idx < (uint32_t)num_trials; idx++) {
    ircvd = ut_next_index(&utc);
    status = rdbx_check_unordered(&rdbx, ircvd);
    if (status)
      return status;
  }
  printf("passed\n");

  /*
   * test a replay condition close to zero.
   */
  rdbx_uninit(&rdbx);

  if (rdbx_init(&rdbx, ws) != err_status_ok) {
    printf("replay_init failed\n");
    return err_status_init_fail;
  }

  printf("\ttesting replay close to zero...");
  status = rdbx_check_add(&rdbx, 1);
  if (status)
    return status;
  status = rdbx_check_expect_failure(&rdbx, 64500);
  if (status)
    return status;
  status = rdbx_check_add(&rdbx, 2);
  if (status)
    return status;
  printf("passed\n");

  rdbx_uninit(&rdbx);

  return err_status_ok;
}
Beispiel #5
0
srtp_err_status_t
roc_test(int num_trials) {
  srtp_xtd_seq_num_t local, est, ref;
  ut_connection utc;
  int i, num_bad_est = 0;
  int delta;
  uint32_t ircvd;
  double failure_rate;

  srtp_index_init(&local);
  srtp_index_init(&ref);
  srtp_index_init(&est);

  printf("\n\ttesting sequential insertion...");
  for (i=0; i < 2048; i++) {
    delta = srtp_index_guess(&local, &est, (uint16_t) ref);
#if ROC_VERBOSE
    printf("%lld, %lld, %d\n", ref, est,  i);
#endif
    if (ref != est) {
#if ROC_VERBOSE
      printf(" *bad estimate*\n");
#endif
      ++num_bad_est;
    }
    srtp_index_advance(&ref, 1);
  }
  failure_rate = (double) num_bad_est / num_trials;
  if (failure_rate > 0.01) {
    printf("error: failure rate too high (%d bad estimates in %d trials)\n", 
	   num_bad_est, num_trials);
    return srtp_err_status_algo_fail;
  }
  printf("done\n");


  printf("\ttesting non-sequential insertion...");
  srtp_index_init(&local);
  srtp_index_init(&ref);
  srtp_index_init(&est);
  ut_init(&utc);
  
  for (i=0; i < num_trials; i++) {
    
    /* get next seq num from unreliable transport simulator */
    ircvd = ut_next_index(&utc);
    
    /* set ref to value of ircvd */
    ref = ircvd; 

    /* estimate index based on low bits of ircvd */
    delta = srtp_index_guess(&local, &est, (uint16_t) ref);
#if ROC_VERBOSE
    printf("ref: %lld, local: %lld, est: %lld, ircvd: %d, delta: %d\n", 
	   ref, local, est, ircvd, delta);
#endif
    
    if (local + delta != est) {
      printf(" *bad delta*: local %llu + delta %d != est %llu\n",
	     (unsigned long long)local, delta, (unsigned long long)est);
      return srtp_err_status_algo_fail;
    }

    /* now update local srtp_xtd_seq_num_t as necessary */
    if (delta > 0) 
      srtp_index_advance(&local, delta);

    if (ref != est) {
#if ROC_VERBOSE
      printf(" *bad estimate*\n");
#endif
      /* record failure event */
      ++num_bad_est;
      
      /* reset local value to correct value */
      local = ref;
    }
  }
  failure_rate = (double) num_bad_est / num_trials;
  if (failure_rate > 0.01) {
    printf("error: failure rate too high (%d bad estimates in %d trials)\n", 
	   num_bad_est, num_trials);
    return srtp_err_status_algo_fail;
  }
  printf("done\n");

  return srtp_err_status_ok;
}