Ectoplasm

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

Proprietary licensing terms are available to evaluate and tune an SLA-supported variant of the following entropy schema for the purpose of seeding cryptographic functions.

Example

The following 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.

// Copyright William Stafford Parsons

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

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

unsigned char oscillate(unsigned char entropy, unsigned char oscillation) {
  oscillation *= ((entropy + oscillation) % 111) | 1;
  oscillation /= (entropy + oscillation) | 1;
  oscillation += ((entropy + oscillation) % 11) + 11;
  return oscillation;
}

unsigned char collapse(unsigned char oscillation) {
  struct timespec s;
  int status = clock_gettime(CLOCK_REALTIME, &s) + 1;

  if (!status) {
    error();
  }

  oscillation += status;
  return (oscillation + s.tv_nsec) & 1;
}

unsigned char ectoplasm(void) {
  unsigned char oscillation = 111;
  unsigned char entropy = 1;

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

  oscillation += oscillate(entropy, oscillation);
  entropy = (entropy << 1) | collapse(oscillation);
  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.

Ectoplasm enables fine-grained control of entropy pool bounds on classical computers without potential inconsistencies from qubit phenomena.

Randomness

Ectoplasm creates a controlled range of entropy pool sizes while maintaining unpredictability by entangling entropy bits with CPU operations that create non-deterministic time fluctuations.

The stability factor relies on defining oscillate() operations collectively to elapse both a consistent lower-precision minimum time and a varying higher-precision average time.

After each oscillation set, collapse() truncates the smallest fraction of system-defined nanosecond Epoch time precision as 1 bit of the highest-quality entropy.

Considerations

SLA-supported, licensed implementations consider the following factors to avoid polluting entropy pools in critical scenarios.

1. Y2K38 could produce integer overflows from unpatched system clock functions.

2. High-resolution, system-wide clock reading with nanosecond time precision is required to accommodate for clock drift and frequency skew.

3. 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.

4. oscillate() should be validated with sequential timestamp differences to verify that each oscillation set elapses at least 100 nanoseconds to mitigate external clock interference.

5. The aforementioned sequential timestamp difference validation should use varying comparison values that are each greater than 100.

6. Deterministic conditioning that removes mathematical biases in sequential output is omitted.

7. Code must be structured carefully to support compiler optimization.

8. CPU time variances from oscillate()should be evaluated and tuned before implementation on specific platforms.