Ectoplasm™

Ectoplasm™ is the entropy schema by GhostProxies that generates bits efficiently with the highest level of unpredictability.

A multi-level SLA is available through Tome™ to evaluate and implement the following proprietary schema as an entropy source for seeding cryptographic functions.

Example

The following Linux 3.10+ POSIX C program is a minimal Ectoplasm™ code example that generates 10 8-bit seeds for the purpose of demonstrating basic functionality without an SLA.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void error(void) {
  exit(EXIT_FAILURE);
}

unsigned char oscillate(unsigned char entropy, unsigned char oscillation,
                        struct timespec *s) {
  time_t seconds = s->tv_sec;
  long nanoseconds = s->tv_nsec;
  signed char elapsed_nanoseconds_minimum = (
    (entropy + oscillation) & 15
  ) + 100;
  int is_successful_clock_measurement = entropy & 1;

  s->tv_sec = 0;
  s->tv_nsec = elapsed_nanoseconds_minimum - 1;

  while (
    (s->tv_nsec - nanoseconds) < elapsed_nanoseconds_minimum &&
    (
      s->tv_sec == seconds ||
      !s->tv_sec
    )
  ) {
    oscillation *= ((entropy + oscillation) % 111) | 1;
    oscillation /= (entropy + oscillation) | 1;
    oscillation += ((entropy + oscillation) % 11) + 11;
    oscillation -= s->tv_nsec & 31;
    is_successful_clock_measurement = clock_gettime(CLOCK_TAI, s) + 1;

    if (!is_successful_clock_measurement) {
      error();
    }

    oscillation += is_successful_clock_measurement;
  }

  return oscillation;
}

unsigned char collapse(unsigned char oscillation, struct timespec *s) {
  return (oscillation + s->tv_nsec) & 1;
}

unsigned char ectoplasm(void) {
  struct timespec s;
  int is_successful_clock_measurement = clock_getres(CLOCK_TAI, &s) + 1;
  unsigned char oscillation = 111;
  unsigned char entropy = 1;

  if (
    !is_successful_clock_measurement ||
    s.tv_nsec != 1
  ) {
    error();
  }

  oscillation += is_successful_clock_measurement;
  oscillation -= s.tv_nsec & 31;
  is_successful_clock_measurement = clock_gettime(CLOCK_TAI, &s) + 1;

  if (!is_successful_clock_measurement) {
    error();
  }

  oscillation += is_successful_clock_measurement;

  while (!(entropy >> 7)) {
    oscillation += oscillate(entropy, oscillation, &s);
    entropy = (entropy << 1) | collapse(oscillation, &s);
  }

  oscillation += oscillate(entropy, oscillation, &s);
  entropy = (entropy << 1) | collapse(oscillation, &s);
  return entropy;
}

int main(void) {
  unsigned char i = 0;

  while (i < 10) {
    i++;
    printf("Result %u is %u.\n", i, ectoplasm());
  }

  return 0;
}

Quantum Alignment

Ectoplasm™ uses classical computing to generate process-isolated entropy pools that stabilize the desirable entropic properties of quantum mechanics.

oscillate mimics a qubit in superposition and collapse mimics a collapsed qubit.

ectoplasm returns the concatenated result of each collapse entropy bit.

Randomness

Ectoplasm™ enables fine-grained control of entropy pool bounds on classical computers without either qubit phenomena inconsistencies or round-trip quantum computer errors.

Unpredictability is controlled by deterministic procedures that create non-deterministic time measurements from CPU oscillations with fewer failure points than QRNG procedures.

The stability factor relies on defining the oscillation set procedures carefully to elapse both a consistent lower-precision minimum time and a varying higher-precision average time.

After processing an oscillation set, Ectoplasm™ truncates the smallest fraction of a system-defined nanosecond Epoch time measurement as 1 bit of the highest-quality entropy.

Visual

The following animation is a step-by-step portrayal that simulates Ectoplasm™ quantum alignment for visual demonstration purposes.

Considerations

SLA-bound Ectoplasm™ implementations consider the following factors to avoid polluting entropy pools.

1. Y2K38 could produce integer overflows when unpatched system clock functions require 32-bit, signed integers.

2. Each clock measurement requires a nanosecond-precision, system-wide clock that has both fixed-interval time continuity and process-level immutability.

3. A clock that both specifies process-level immutability and changes either nanosecond precision or fixed-interval time continuity is beyond the scope of implementation.

4. Anomalous system clock failures are handled by aborting with EXIT_FAILURE, although other fallbacks may be preferred, such as mixing in ASLR-based addresses and cloud APIs.

5. oscillate should be validated with sequential timestamp differences to verify that each oscillation set elapses a minimum amount of varying nanoseconds.

6. Deterministic conditioning that guarantees the removal of mathematical biases in sequential ectoplasm output is omitted.

7. Code must be structured to support compiler optimization.

8. oscillate procedures must be evaluated and tuned for CPU time variances, clock drift, frequency skew and process speed requirements.