KiHoLee
25b5891b04
- exclude the all-ones Walsh-Hadamard row and test every key family against the all-ones guess - pass the model dimension to the noise scaling so the key-length sweep runs at a fixed per-dimension SNR - known-plaintext attack with nested accumulation and common random numbers, averaged over 40 collections - key sensitivity and brute-force search extended to the permutation key and the index cipher - make_tables regenerates all three result tables from the CSVs
295 lines
10 KiB
Python
295 lines
10 KiB
Python
"""Canonical replot script for paper 11: regenerates every result figure
|
|
from ../data/*.csv and writes paper-ready PDFs to ../fig/. No experiment
|
|
is rerun. All result plots share one canvas and axes rectangle (8:6 box).
|
|
Label dictionary is fixed here and copied verbatim into tables and prose.
|
|
|
|
fig_sec_snr.pdf : legitimate vs eavesdropper SER vs SNR (Fig. 2)
|
|
fig_sec_keylen.pdf : SER vs key length L (Fig. 3)
|
|
fig_sec_jam.pdf : target-user SER vs JSR (Fig. 4)
|
|
fig_sec_sens.pdf : Eve SER vs key correlation (Fig. 5)
|
|
fig_sec_brute.pdf : Eve SER vs number of key guesses (Fig. 6)
|
|
fig_sec_brute_rho.pdf : best key correlation vs guesses (Fig. 7)
|
|
"""
|
|
from __future__ import annotations
|
|
from pathlib import Path
|
|
import csv
|
|
|
|
import matplotlib
|
|
matplotlib.use("Agg")
|
|
import matplotlib.pyplot as plt
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
DATA = ROOT / "data"
|
|
FIG = ROOT / "fig"
|
|
FIG.mkdir(exist_ok=True)
|
|
|
|
plt.rcParams.update({
|
|
"font.family": "serif",
|
|
"font.serif": ["DejaVu Serif", "Times New Roman"],
|
|
"font.size": 9,
|
|
"axes.labelsize": 9,
|
|
"legend.fontsize": 6.6,
|
|
"xtick.labelsize": 8,
|
|
"ytick.labelsize": 8,
|
|
"axes.grid": True,
|
|
"grid.linestyle": "--",
|
|
"grid.linewidth": 0.4,
|
|
"grid.alpha": 0.6,
|
|
"lines.linewidth": 1.3,
|
|
"lines.markersize": 3.4,
|
|
"figure.figsize": (3.15, 2.36),
|
|
"pdf.fonttype": 42,
|
|
})
|
|
AXES_RECT = dict(left=0.185, right=0.965, top=0.955, bottom=0.195)
|
|
|
|
C_LEGIT = "#c0392b"
|
|
C_EVE = "#2c5fa8"
|
|
C_OMA = "#7f8c8d"
|
|
C_CH = "#95a5a6"
|
|
C_MATCH = "#8e44ad"
|
|
C_PUB = "#16a085"
|
|
|
|
# fixed label dictionary: tables and prose copy these strings verbatim
|
|
LBL = {
|
|
"legit": "Legitimate",
|
|
"oma": "OMA",
|
|
"eve_pub": "Eve, public masks",
|
|
"eve_key": "Eve, wrong key",
|
|
"chance": "Random guess",
|
|
"jam_m": "Matched jammer (public masks)",
|
|
"jam_b": "Blind jammer (proposed)",
|
|
"nojam": "No jammer",
|
|
}
|
|
|
|
|
|
def load(name):
|
|
with open(DATA / name) as f:
|
|
return list(csv.DictReader(f))
|
|
|
|
|
|
def col(rows, k, f=float):
|
|
return [f(r[k]) for r in rows]
|
|
|
|
|
|
def save(fig, name):
|
|
"""Write the figure and assert that no axis label is clipped.
|
|
|
|
A long y label, or wide minor tick labels such as 6x10^-1 on a log
|
|
axis that spans less than a decade, silently pushes the label off
|
|
the canvas under the fixed axes rectangle. Reading the plotting code
|
|
cannot reveal this, so the check is made on the rendered geometry.
|
|
"""
|
|
fig.subplots_adjust(**AXES_RECT)
|
|
fig.canvas.draw()
|
|
fbox = fig.get_window_extent()
|
|
for ax in fig.axes:
|
|
for lbl in (ax.yaxis.label, ax.xaxis.label):
|
|
if not lbl.get_text():
|
|
continue
|
|
b = lbl.get_window_extent()
|
|
if (b.x0 < fbox.x0 or b.y0 < fbox.y0
|
|
or b.x1 > fbox.x1 or b.y1 > fbox.y1):
|
|
raise RuntimeError(
|
|
f"{name}: axis label '{lbl.get_text()}' is clipped "
|
|
f"(label {b} outside figure {fbox}); shorten the "
|
|
f"label or widen the margin")
|
|
fig.savefig(FIG / f"{name}.pdf")
|
|
plt.close(fig)
|
|
print("[OK]", name)
|
|
|
|
|
|
def fig_snr():
|
|
r = load("sec_snr.csv")
|
|
x = col(r, "snr_db")
|
|
fig, ax = plt.subplots()
|
|
ax.semilogy(x, col(r, "legit"), color=C_LEGIT, marker="o", ls="-",
|
|
label=LBL["legit"])
|
|
ax.semilogy(x, col(r, "oma"), color=C_OMA, marker="^", ls=":",
|
|
label=LBL["oma"])
|
|
ax.semilogy(x, col(r, "eve_public"), color=C_PUB, marker="v",
|
|
ls="none", markersize=5.2, markerfacecolor="none",
|
|
label=LBL["eve_pub"])
|
|
ax.semilogy(x, col(r, "eve_wrong"), color=C_EVE, marker="s", ls="--",
|
|
label=LBL["eve_key"])
|
|
ax.plot(x, col(r, "chance"), color=C_CH, ls="-.", lw=0.9,
|
|
label=LBL["chance"])
|
|
ax.set_xlabel("SNR (dB)")
|
|
ax.set_ylabel("SER")
|
|
ax.set_xlim(min(x), max(x))
|
|
ax.legend(loc="lower left")
|
|
save(fig, "fig_sec_snr")
|
|
|
|
|
|
def fig_keylen():
|
|
r = load("sec_keylen.csv")
|
|
x = col(r, "L", int)
|
|
fig, ax = plt.subplots()
|
|
ax.semilogy(x, col(r, "legit_ser"), color=C_LEGIT, marker="o", ls="-",
|
|
label=LBL["legit"])
|
|
ax.semilogy(x, col(r, "oma"), color=C_OMA, marker="^", ls=":",
|
|
label=LBL["oma"])
|
|
ax.semilogy(x, col(r, "eve_ser"), color=C_EVE, marker="s", ls="--",
|
|
label=LBL["eve_key"])
|
|
ax.set_xlabel("Key length $L$")
|
|
ax.set_ylabel("SER")
|
|
ax.set_xscale("log", base=2)
|
|
ax.legend(loc="center right", bbox_to_anchor=(0.98, 0.72))
|
|
save(fig, "fig_sec_keylen")
|
|
|
|
|
|
def fig_jam():
|
|
# the target-user SER spans 0.3 to 1.0, less than one decade, so a
|
|
# linear axis is used: a log axis here produces wide minor tick
|
|
# labels (6x10^-1) that crowd out the y label under the fixed
|
|
# axes rectangle
|
|
r = load("sec_jam.csv")
|
|
x = col(r, "jsr_db")
|
|
fig, ax = plt.subplots()
|
|
ax.plot(x, col(r, "matched"), color=C_MATCH, marker="P", ls="--",
|
|
label=LBL["jam_m"])
|
|
ax.plot(x, col(r, "blind"), color=C_LEGIT, marker="o", ls="-",
|
|
label=LBL["jam_b"])
|
|
nojam = col(r, "nojam")[0]
|
|
ax.axhline(nojam, color=C_OMA, ls=":", lw=0.9, label=LBL["nojam"])
|
|
ax.set_xlabel("JSR (dB)")
|
|
ax.set_ylabel("SER")
|
|
ax.set_xlim(min(x), max(x))
|
|
ax.set_ylim(0.2, 1.02)
|
|
ax.legend(loc="lower right")
|
|
save(fig, "fig_sec_jam")
|
|
|
|
|
|
def fig_sens():
|
|
"""Key sensitivity of three schemes on one axis, the fraction of the
|
|
key the attacker holds. For keyed masking that fraction is the mask
|
|
correlation, for the permutation scheme the fraction of positions
|
|
placed correctly, for the index cipher the fraction of pad bits
|
|
known."""
|
|
r = load("sec_sens_cmp.csv")
|
|
x = col(r, "frac")
|
|
fig, ax = plt.subplots()
|
|
ax.plot(x, col(r, "ser_mask"), color=C_LEGIT, marker="o", ls="-",
|
|
label="Keyed masking")
|
|
ax.plot(x, col(r, "ser_perm"), color=C_EVE, marker="s", ls="--",
|
|
label="Permutation key")
|
|
ax.plot(x, col(r, "ser_pad"), color=C_PUB, marker="v", ls="-.",
|
|
label="Index cipher")
|
|
chance = 1.0 - (1.0 / 16.0) ** 4
|
|
ax.axhline(chance, color=C_CH, ls=":", lw=0.9, label=LBL["chance"])
|
|
ax.set_xlabel("Fraction of the key recovered")
|
|
ax.set_ylabel("Eavesdropper SER")
|
|
ax.set_xlim(0, 1)
|
|
ax.legend(loc="lower left")
|
|
save(fig, "fig_sec_sens")
|
|
|
|
|
|
def fig_brute():
|
|
"""Brute-force search against the three keyed schemes at the same
|
|
key length, each mapped through its own sensitivity curve."""
|
|
r = load("sec_brute_cmp.csv")
|
|
x = col(r, "K")
|
|
fig, ax = plt.subplots()
|
|
ax.semilogx(x, col(r, "ser_mask"), color=C_LEGIT, marker="o", ls="-",
|
|
label="Keyed masking")
|
|
ax.semilogx(x, col(r, "ser_perm"), color=C_EVE, marker="s", ls="--",
|
|
label="Permutation key")
|
|
ax.semilogx(x, col(r, "ser_pad"), color=C_PUB, marker="v", ls="-.",
|
|
label="Index cipher")
|
|
kl = load("sec_keylen.csv")
|
|
legit = float([q for q in kl if int(q["L"]) == 16][0]["legit_ser"])
|
|
ax.axhline(legit, color=C_OMA, ls=":", lw=0.9, label=LBL["legit"])
|
|
ax.set_xlabel("Number of key guesses $K$")
|
|
ax.set_ylabel("Eavesdropper SER")
|
|
ax.set_ylim(-0.03, 1.05)
|
|
ax.legend(loc="center left")
|
|
save(fig, "fig_sec_brute")
|
|
|
|
|
|
def fig_brute_rho():
|
|
"""Best key correlation a search of size K reaches, per key length.
|
|
This is a property of the key space alone."""
|
|
r = load("sec_brute.csv")
|
|
fig, ax = plt.subplots()
|
|
sty = {8: ("#c0392b", "o"), 16: ("#2c5fa8", "s"),
|
|
32: ("#16a085", "v"), 64: ("#8e44ad", "P")}
|
|
for Lp, (c, mk) in sty.items():
|
|
rows = [row for row in r if int(row["L"]) == Lp]
|
|
ax.semilogx([float(x["K"]) for x in rows],
|
|
[float(x["best_rho"]) for x in rows],
|
|
color=c, marker=mk, ls="-", label=f"$L={Lp}$")
|
|
ax.axhline(0.96, color=C_CH, ls="-.", lw=0.9, label="Break threshold")
|
|
ax.set_xlabel("Number of key guesses $K$")
|
|
ax.set_ylabel(r"Best key correlation $\kappa$")
|
|
ax.set_ylim(0, 1.05)
|
|
ax.legend(loc="upper left")
|
|
save(fig, "fig_sec_brute_rho")
|
|
|
|
|
|
def fig_real():
|
|
r = load("real_sec_ter.csv")
|
|
x = col(r, "snr_db")
|
|
fig, ax = plt.subplots()
|
|
ax.semilogy(x, col(r, "ter_legit"), color=C_LEGIT, marker="o", ls="-",
|
|
label=LBL["legit"])
|
|
ax.semilogy(x, col(r, "ter_oma"), color=C_OMA, marker="^", ls=":",
|
|
label=LBL["oma"])
|
|
ax.semilogy(x, col(r, "ter_insider"), color=C_PUB, marker="v", ls="-.",
|
|
label="Insider")
|
|
ax.semilogy(x, col(r, "ter_eve"), color=C_EVE, marker="s", ls="--",
|
|
label=LBL["eve_key"])
|
|
ax.set_xlabel("SNR (dB)")
|
|
ax.set_ylabel("TER")
|
|
ax.set_xlim(min(x), max(x))
|
|
ax.legend(loc="lower left")
|
|
save(fig, "fig_sec_real")
|
|
|
|
|
|
def fig_kpa():
|
|
r = load("kpa.csv")
|
|
fig, ax = plt.subplots()
|
|
sty = {0.0: ("#c0392b", "o"), 10.0: ("#2c5fa8", "s"),
|
|
20.0: ("#16a085", "v")}
|
|
for snr, (c, mk) in sty.items():
|
|
rows = [row for row in r if float(row["snr_db"]) == snr]
|
|
n = [float(row["n_frames"]) for row in rows]
|
|
ser = [float(row["eve_ser"]) for row in rows]
|
|
ax.semilogx(n, ser, color=c, marker=mk, ls="-",
|
|
label=f"{int(snr)} dB")
|
|
# legitimate reference measured with the SAME estimator as the
|
|
# eavesdropper curves, namely the four-user average of eval_ser_sse
|
|
# at L=16, taken from sec_keylen.csv rather than from the user-1
|
|
# convention of the scheme-comparison table
|
|
kl = load("sec_keylen.csv")
|
|
legit = float([r for r in kl if int(r["L"]) == 16][0]["legit_ser"])
|
|
ax.axhline(legit, color=C_OMA, ls=":", lw=0.9, label=LBL["legit"])
|
|
ax.set_xlabel("Known-plaintext frames $N$")
|
|
ax.set_ylabel("Eavesdropper SER")
|
|
ax.set_xscale("log", base=2)
|
|
ax.legend(loc="upper right")
|
|
save(fig, "fig_sec_kpa")
|
|
|
|
|
|
def main():
|
|
fig_snr()
|
|
fig_keylen()
|
|
fig_jam()
|
|
try:
|
|
fig_sens()
|
|
fig_brute()
|
|
fig_brute_rho()
|
|
except FileNotFoundError:
|
|
print("[skip] attack-difficulty CSVs not present yet")
|
|
try:
|
|
fig_real()
|
|
except FileNotFoundError:
|
|
print("[skip] real-token CSV not present yet")
|
|
try:
|
|
fig_kpa()
|
|
except FileNotFoundError:
|
|
print("[skip] known-plaintext CSV not present yet")
|
|
print("[done] figures in", FIG)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|