SHA-256 Grover algorithm decryption ( wind turbine noise and ionization possibility part 1)

 

import numpy as np

import matplotlib.pyplot as plt

from scipy.signal import spectrogram

from scipy.fftpack import fft

from sklearn.preprocessing import MinMaxScaler

# -------------------------------------------------------------

# 1. LOAD YOUR CAPTURED DATA

# -------------------------------------------------------------

# jitter: array of cycle-to-cycle timing deltas (picoseconds)

# em: EM burst amplitude trace

# power: micro power-draw samples

jitter = np.load("jitter_trace.npy")

em = np.load("em_trace.npy")

power = np.load("power_trace.npy")

# -------------------------------------------------------------

# 2. NORMALIZE JITTER

# -------------------------------------------------------------

scaler = MinMaxScaler()

jitter_norm = scaler.fit_transform(jitter.reshape(-1, 1)).flatten()

# -------------------------------------------------------------

# 3. SEGMENT INTO 64 SHA-256 ROUNDS

# -------------------------------------------------------------

rounds = 64

segment_length = len(jitter_norm) // rounds

segments = [jitter_norm[i*segment_length:(i+1)*segment_length] for i in range(rounds)]

round_means = np.array([np.mean(seg) for seg in segments])

# -------------------------------------------------------------

# 4. SPECTROGRAM (TURBINE HARMONICS + ROUND STRUCTURE)

# -------------------------------------------------------------

f, t, Sxx = spectrogram(jitter_norm, fs=1e9, nperseg=256)

# -------------------------------------------------------------

# 5. PHASE-SPACE ATTRACTOR (NONLINEAR DYNAMICS)

# -------------------------------------------------------------

tau = 3

x = jitter_norm[:-2*tau]

y = jitter_norm[tau:-tau]

z = jitter_norm[2*tau:]

# -------------------------------------------------------------

# 6. VISUALIZATIONS

# -------------------------------------------------------------

plt.figure(figsize=(12, 6))

plt.plot(jitter_norm, color="#00ff66")

plt.title("Jitter Envelope", color="#00ff66")

plt.xlabel("Cycle")

plt.ylabel("Normalized Jitter")

plt.grid(False)

plt.show()

plt.figure(figsize=(12, 6))

plt.plot(round_means, marker="o", color="#00ff66")

plt.title("64-Step Round Staircase", color="#00ff66")

plt.xlabel("Round")

plt.ylabel("Mean Jitter")

plt.grid(False)

plt.show()

plt.figure(figsize=(12, 6))

plt.pcolormesh(t, f, Sxx, shading='gouraud', cmap="Greens")

plt.title("Harmonic Coupling Spectrogram", color="#00ff66")

plt.ylabel("Frequency (Hz)")

plt.xlabel("Time")

plt.show()

fig = plt.figure(figsize=(10, 10))

ax = fig.add_subplot(111, projection='3d')

ax.scatter(x, y, z, c="#00ff66", s=2)

ax.set_title("Phase-Space Attractor", color="#00ff66")

plt.show()

#include "stm32h7xx_hal.h"

#include "tdc_driver.h"

#include "adc_driver.h"

#include "uart_dma.h"

#define SAMPLE_RATE_EM   1000000   // 1 MHz

#define SAMPLE_RATE_PWR  1000000   // 1 MHz

#define HASH_WINDOW      64        // SHA-256 rounds

typedef struct {

    uint32_t jitter_ps;

    uint16_t em_amp;

    uint16_t pwr_amp;

    uint8_t  round_index;

} CapturePacket;

CapturePacket packet;

void SystemClock_Config(void);

void SyncController_Init(void);

void Capture_Loop(void);

int main(void) {

    HAL_Init();

    SystemClock_Config();

    TDC_Init();

    ADC_Init();

    UART_DMA_Init();

    SyncController_Init();

    while (1) {

        Capture_Loop();

    }

}

void Capture_Loop(void) {

    for (uint8_t round = 0; round < HASH_WINDOW; round++) {

        packet.jitter_ps = TDC_ReadCycleDelta();

        packet.em_amp    = ADC_ReadChannel(EM_CHANNEL);

        packet.pwr_amp   = ADC_ReadChannel(PWR_CHANNEL);

        packet.round_index = round;

        UART_DMA_Send((uint8_t*)&packet, sizeof(packet));

    }

}