PRNG 12개 타이머 PHP: 엔트로피 7.1 비트

## ChaosRNG: 12개 타이머를 활용한 PHP 의사난수 바이트 생성기

ChaosRNG 클래스는 12개의 상호 연결된 타이머를 활용해 바이트당 엔트로피 최대 7.1~8비트를 가진 바이트를 생성합니다. 각 타이머는 기본 시간, 나노초부터 일시정지와 0바이트 삽입까지 비선형성을 더합니다. 이 실험적 접근법은 인증된 암호화 프리미티브가 필요 없는 작업에 적합합니다.

생성자는 마이크로초(T1), 나노초(T2), PID, 메모리 사용량(T7)의 XOR로 상태를 초기화합니다. 왜곡 계수는 1.001부터 시작하며, 스위치는 기본적으로 활성화됩니다.

타이머 로직

타이머들은 처리 파이프라인을 형성합니다:

• T1: 1970년 이후 마이크로초.
• T2: 시스템 부팅 이후 나노초.
• T3: 총합의 최하위 바이트를 더하거나 빼서 64비트 상태 업데이트.
• T4: 각 사이클에서 업데이트되는 계수 k로 시간 곱셈/나눗셈 변조.
• T5: 슬라이스 결정 (1000~10000).
• T6: 시간 가중치를 위한 슬라이스 선택.
• T7: PID와 메모리를 통한 캐시 및 인터럽트 지터.
• T8: 꺼질 때 실제 바이트 건너뛰기 스위치.
• T9: 마지막 바이트(<5 켜짐, >5 꺼짐)에 따라 T8 제어.
• T10: 생성자 내 숨겨진 시작점.
• T11: ($state & 10) === 0일 때 0x00 삽입.
• T12: 대기 중 상태 업데이트와 함께 1~100 사이클 일시정지.

/**
 * ChaosRNG - 12개 타이머를 가진 난수 바이트 생성기
 * 
 * 12개 타이머:
 * T1  – 표준 클럭 (microtime)
 * T2  – 고해상도 클럭 (hrtime)
 * T3  – 메모리 (상태 $state)
 * T4  – 왜곡기 (시간 곱셈/나눗셈)
 * T5  – 슬라이서 (1000-10000 슬라이스)
 * T6  – 선택기 (슬라이스 선택)
 * T7  – 숨겨진 노이즈 (지터, 인터럽트)
 * T8  – 스위치 (출력 on/off)
 * T9  – 감시자 (스위치 제어)
 * T10 – 시작점 (초기화 순간)
 * T11 – 블롭 (제로 바이트 삽입)
 * T12 – 정음기 (1-100 사이클 일시정지)
 */

class ChaosRNG {
    // 클래스 속성
    private $state;      // T3: 64비트 상태
    private $k;          // T4: 왜곡 계수
    private $enabled;    // T8: 스위치 (on/off)
    private $lastByte;   // T9: 마지막 출력 바이트
    private $dot;        // T11: 도트 플래그
    private $pauseLen;   // T12: 일시정지 길이
    private $pauseRem;   // T12: 일시정지 잔여
    
    /**
     * 생성자 — T10 (시작점)
     * 모든 비반복 소스 혼합
     */
    public function __construct() {
        // 모든 소스 XOR → 고유 초기 상태
        $this->state = (int)(microtime(true) * 1000000) ^  // T1: 마이크로초
                       hrtime(true) ^                      // T2: 나노초
                       getmypid() ^                        // T7: 프로세스 PID
                       memory_get_usage();                // T7: 메모리 사용량
        
        $this->k = 1.001;           // T4: 초기 계수
        $this->enabled = true;      // T8: 스위치 켜짐
        $this->lastByte = 0;        // T9: 마지막 바이트 없음
        $this->dot = false;         // T11: 도트 삽입 안함
        $this->pauseLen = 0;        // T12: 일시정지 없음
        $this->pauseRem = 0;        // T12: 잔여 0
    }
    
    /**
     * T1: 표준 클럭
     * 1970년 이후 마이크로초 반환
     */
    private function t1() {
        return (int)(microtime(true) * 1000000);
    }
    
    /**
     * T2: 고해상도 클럭
     * 부팅 이후 나노초 반환
     */
    private function t2() {
        return hrtime(true);
    }
    
    /**
     * 내부 바이트 생성기 (T3-T7)
     * 상태 업데이트 후 하나의 바이트 반환
     */
    private function nextByteInternal() {
        // T5: 슬라이스 수 1000~10000
        $K = 1000 + ($this->state % 9001);
        
        // T6: 특정 슬라이스 선택
        $slot = (($this->state >> 8) % $K);
        
        // T1과 T2: 현재 시간 가져오기
        $t1 = $this->t1();
        $t2 = $this->t2();
        
        // T4: 왜곡기 (시간 늘리기/줄이기)
        if ($this->state & 1) {
            $t1 = $t1 * $this->k;   // T1 늘리기
        } else {
            $t2 = $t2 / $this->k;   // T2 줄이기
        }
        
        // 선택된 슬라이스와 합산
        $total = (int)($t1 * ($slot + 1) / $K) +
                 (int)($t2 * ($slot + 1) / $K);
        
        // T3: 상태 업데이트 (더하기/빼기)
        if ($total & 1) {
            $this->state += ($total & 0xFF);
        } else {
            $this->state -= ($total & 0xFF);
        }
        
        // 왜곡 계수 업데이트
        $this->k = 1.0 + (($this->state & 0xFF) / 10000.0);
        
        // 상태 최하위 바이트 반환
        return $this->state & 0xFF;
    }
    
    /**
     * 공개 메서드: N개 난수 바이트 가져오기
     * 모든 12개 타이머 반영
     */
    public function getBytes($n) {
        $out = [];
        
        for ($i = 0; $i < $n; $i++) {
            // T12: 일시정지 (정음기)
            while ($this->pauseRem > 0) {
                $this->pauseRem--;
                $this->nextByteInternal(); // 상태 변경
            }
            
            // 일시정지 종료 시 새로 생성
            if ($this->pauseRem === 0 && $this->pauseLen === 0) {
                $this->pauseLen = 1 + ($this->state % 100); // 1-100 사이클
                $this->pauseRem = $this->pauseLen;
            }
            
            // T11: 도트 (제로 바이트 삽입)
            if (($this->state & 10) === 0 && !$this->dot) {
                $this->dot = true;
                $this->nextByteInternal();
                $out[] = 0x00; // 도트 = 제로 바이트
                continue;
            }
            $this->dot = false;
            
            // T9: 스위치 감시자
            if ($this->lastByte < 5) {
                $this->enabled = true;   // 켜기
            } elseif ($this->lastByte > 5) {
                $this->enabled = false;  // 끄기
            }
            // ==5일 때는 변경 없음
            
            // 바이트 생성
            $byte = $this->nextByteInternal();
            
            // T8: 스위치
            if (!$this->enabled) {
                // 꺼짐 — 더미 바이트 출력
                $out[] = $this->nextByteInternal() & 0xFF;
                continue;
            }
            
            // 마지막 출력 바이트 저장
            $this->lastByte = $byte;
            
            // 실제 바이트 후 일시정지 리셋
            if ($this->pauseLen > 0) {
                $this->pauseLen = 0;
                $this->pauseRem = 0;
            }
            
            $out[] = $byte;
        }
        
        return $out;
    }
}

섀넌 엔트로피 계산

정적 entropy() 메서드는 바이트 빈도에 대해 -Σ p * log2(p)를 사용해 섀넌 엔트로피를 계산합니다. 64KB 데이터 테스트에서 평균 7.12비트입니다.

public static function entropy($bytes) {
    // 바이트 빈도 계산
    $freq = array_fill(0, 256, 0);
    foreach ($bytes as $b) {
        $freq[$b]++;
    }
    
    // 섀넌 공식: -Σ p * log2(p)
    $e = 0;
    $total = count($bytes);
    foreach ($freq as $c) {
        if ($c > 0) {
            $p = $c / $total;
            $e -= $p * log($p, 2);
        }
    }
    
    return $e;
}

// 테스트
$rng = new ChaosRNG();
$data = $rng->getBytes(65536);
$entropy = ChaosRNG::entropy($data);
echo "엔트로피: " . round($entropy, 4) . " / 8 비트\n";

비선형성과 탄력성

상태 복구를 위해서는 k, 슬라이스 수, 일시정지, 스위치 위치를 알아야 합니다. 64비트 상태는 서버 접근 없이 공격을 어렵게 합니다. VM에서도 엔트로피 >6.5비트로 시퀀스가 통계적으로 무작위에 가깝습니다.

사용 사례: 토큰 및 비밀번호 생성 (16자 ~113비트 엔트로피). 암호화에는 사용 금지—실험용입니다.

주요 요약

• 12개 타이머가 일시정지와 건너뛰기로 분석을 방해하는 비선형 파이프라인 생성.
• 바이트당 섀넌 엔트로피 7.1+비트, 64KB 테스트.
• T12(일시정지)와 T11(제로)이 시간적·순차적 예측성 파괴.
• 64비트 상태로 탄력성과 속도 균형.
• 프로덕션 암호화 금지: 실험적 PRNG.

— Editorial Team