KiHoLee
cbdb068219
The unjammed reference puts the range at 0.053 to 0.998, over a decade, so the linear axis and its below-zero legend band are no longer needed. Minor tick labels are suppressed to keep the left margin clear.
579 lines
24 KiB
Python
579 lines
24 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 and 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, four cases (Fig. 4)
|
|
fig_sec_sens.pdf : eavesdropper SER vs fraction of key held (Fig. 5)
|
|
fig_sec_brute.pdf : eavesdropper SER vs number of key guesses (Fig. 6)
|
|
fig_sec_kpa.pdf : eavesdropper SER vs known-plaintext frames (Fig. 7)
|
|
fig_sec_real.pdf : token error rate on real streams (Fig. 8)
|
|
|
|
Curves that coincide by construction are drawn deliberately layered: the
|
|
lower one wide and semi-transparent, the upper one narrow with open
|
|
markers, and their markers staggered to different sample points through
|
|
markevery offsets. Marker size is uniform across every figure, so the
|
|
stagger, not the size, is what keeps each legend entry visible.
|
|
"""
|
|
from __future__ import annotations
|
|
from pathlib import Path
|
|
import csv
|
|
import math
|
|
|
|
import matplotlib
|
|
matplotlib.use("Agg")
|
|
import matplotlib.pyplot as plt
|
|
import matplotlib.ticker as mticker
|
|
|
|
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"],
|
|
# The manuscript includes each result figure at 0.74 of a 3.455 in
|
|
# column while the canvas is 3.15 in, a printed scale of 0.812. Every
|
|
# size below is therefore pre-divided by that scale so the PRINTED
|
|
# sizes are 8 pt labels, 7.6 pt ticks and a 6 pt legend at the
|
|
# smallest rung. Change the include width and these must change
|
|
# with it.
|
|
"font.size": 9.9,
|
|
"axes.labelsize": 9.9,
|
|
"legend.fontsize": 9.2,
|
|
"xtick.labelsize": 9.4,
|
|
"ytick.labelsize": 9.4,
|
|
"axes.grid": True,
|
|
"grid.linestyle": "--",
|
|
"grid.linewidth": 0.4,
|
|
"grid.alpha": 0.6,
|
|
"lines.linewidth": 1.5,
|
|
"lines.markersize": 5.2,
|
|
"figure.figsize": (3.15, 2.25), # shorter canvas: same printed width and font size, less page height
|
|
"pdf.fonttype": 42,
|
|
})
|
|
AXES_RECT = dict(left=0.215, right=0.970, top=0.955, bottom=0.225)
|
|
|
|
C_LEGIT = "#c0392b" # KM, structured keys
|
|
C_LEARN = "#d98c00" # KM, learned keys
|
|
C_OMA = "#7f8c8d" # orthogonal multiple access
|
|
C_PUB = "#16a085" # public masks
|
|
C_PERM = "#8e44ad" # permutation key
|
|
C_PAD = "#a0522d" # index cipher
|
|
C_EVE = "#2c5fa8" # an adversary of KM
|
|
C_CH = "#95a5a6" # chance and reference levels
|
|
C_MATCH = C_PUB # the matched jammer is what public masks admit
|
|
|
|
# One entry per curve the figures draw. Colour identifies the scheme and
|
|
# line style the role: solid for a legitimate rate, dashed for an
|
|
# adversary, dash-dot for a comparison scheme, dotted for a reference.
|
|
# Every figure reads its curves from here, so a reader who learns a
|
|
# curve in one figure reads the same curve in the next.
|
|
STY = {
|
|
"km_str": dict(color=C_LEGIT, marker="o", ls="-"),
|
|
"km_lrn": dict(color=C_LEARN, marker="d", ls="-"),
|
|
"oma": dict(color=C_OMA, marker="^", ls=":"),
|
|
"pub": dict(color=C_PUB, marker="v", ls="-."),
|
|
"perm": dict(color=C_PERM, marker="X", ls="--"),
|
|
"pad": dict(color=C_PAD, marker="P", ls="-."),
|
|
"eve": dict(color=C_EVE, marker="s", ls="--"),
|
|
"insider": dict(color=C_EVE, marker="v", ls="-."),
|
|
}
|
|
|
|
# fixed label dictionary: tables and prose copy these strings verbatim
|
|
LBL = {
|
|
"legit": "KM (str.)",
|
|
"legit_learned": "KM (lrn.)",
|
|
"oma": "OMA",
|
|
"eve_pub": "Eavesdropper, public masks",
|
|
"eve_key": "Eavesdropper", # the wrong-key condition is in the caption
|
|
"chance": "Random guess",
|
|
"nojam": "No jammer",
|
|
"mask": "KM (str.)",
|
|
"perm": "Permutation key",
|
|
"pad": "Index cipher",
|
|
"insider": "Insider",
|
|
"outsider": "Outsider",
|
|
}
|
|
# deliberate-layering style for the LOWER of two coinciding curves
|
|
UNDER = dict(lw=2.6, alpha=0.85) # thick filled line, layered under
|
|
# and for the curve riding on top of it
|
|
OVER = dict(lw=1.2, mfc="none") # thin open marker, rides on top
|
|
|
|
|
|
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 _inflate(box, fig):
|
|
"""Grow a bounding box by the marker radius plus the line width, in
|
|
pixels, so a marker whose CENTER clears the box cannot still touch
|
|
its frame."""
|
|
pad = (plt.rcParams["lines.markersize"] / 2.0
|
|
+ plt.rcParams["lines.linewidth"]) * fig.dpi / 72.0
|
|
from matplotlib.transforms import Bbox
|
|
return Bbox.from_extents(box.x0 - pad, box.y0 - pad,
|
|
box.x1 + pad, box.y1 + pad)
|
|
|
|
|
|
def save(fig, name, insets=()):
|
|
"""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")
|
|
# No curve may pass under the legend box. Reading the code cannot
|
|
# reveal this, so the check is made on the rendered geometry, the
|
|
# same discipline as the clipping guard above.
|
|
leg = ax.get_legend()
|
|
if leg is not None:
|
|
raw = leg.get_window_extent()
|
|
if (raw.x0 < fbox.x0 or raw.y0 < fbox.y0
|
|
or raw.x1 > fbox.x1 or raw.y1 > fbox.y1):
|
|
raise RuntimeError(
|
|
f"{name}: the legend box leaves the canvas "
|
|
f"({raw} outside {fbox}); narrow or move it")
|
|
lb = _inflate(raw, fig)
|
|
for line in ax.get_lines():
|
|
# full-span reference lines (axhline/axvline) carry axes-
|
|
# fraction endpoints [0,1]; they are not data curves and,
|
|
# spanning the whole axis, would forbid any bottom legend
|
|
xd = list(line.get_xdata())
|
|
if xd == [0, 1] or list(line.get_ydata()) == [0, 1]:
|
|
continue
|
|
xy = line.get_xydata()
|
|
if len(xy) == 0:
|
|
continue
|
|
for px, py in ax.transData.transform(xy):
|
|
if lb.x0 <= px <= lb.x1 and lb.y0 <= py <= lb.y1:
|
|
raise RuntimeError(
|
|
f"{name}: a data curve passes under the legend "
|
|
f"box; move the legend or shrink it")
|
|
for t in ax.texts:
|
|
tb = t.get_window_extent()
|
|
if (lb.x0 < tb.x1 and tb.x0 < lb.x1
|
|
and lb.y0 < tb.y1 and tb.y0 < lb.y1):
|
|
raise RuntimeError(
|
|
f"{name}: the annotation {t.get_text()!r} sits under "
|
|
f"the legend box; move one of them")
|
|
for t in ax.texts:
|
|
tb = t.get_window_extent()
|
|
for line in ax.get_lines():
|
|
xy = line.get_xydata()
|
|
if len(xy) == 0:
|
|
continue
|
|
for px, py in ax.transData.transform(xy):
|
|
if tb.x0 <= px <= tb.x1 and tb.y0 <= py <= tb.y1:
|
|
raise RuntimeError(
|
|
f"{name}: a curve is drawn through the "
|
|
f"annotation {t.get_text()!r}; move it")
|
|
for ins in insets:
|
|
ib = ins.get_window_extent()
|
|
for a in fig.axes:
|
|
if a is ins:
|
|
continue
|
|
for line in a.get_lines():
|
|
xy = line.get_xydata()
|
|
if len(xy) == 0:
|
|
continue
|
|
for px, py in a.transData.transform(xy):
|
|
if ib.x0 <= px <= ib.x1 and ib.y0 <= py <= ib.y1:
|
|
raise RuntimeError(
|
|
f"{name}: a data curve passes under the inset "
|
|
f"panel; move or shrink the inset")
|
|
fig.savefig(FIG / f"{name}.pdf")
|
|
plt.close(fig)
|
|
print("[OK]", name)
|
|
|
|
|
|
PL_CHOSEN = [] # sizes the sweep settled on, one per figure
|
|
PL_FORCED = None # set by main() on its second pass
|
|
|
|
|
|
def main_legit(snr_db="10"):
|
|
"""The legitimate SER of the main configuration, read from the curve
|
|
the main configuration produced rather than looked up by key length."""
|
|
for r in load("sec_snr.csv"):
|
|
if float(r["snr_db"]) == float(snr_db):
|
|
return float(r["legit"])
|
|
raise KeyError("no %s dB row in sec_snr.csv" % snr_db)
|
|
|
|
|
|
|
|
# Legend order, applied by place_legend to whatever subset a figure
|
|
# draws: the proposal first, then the comparison schemes in the order of
|
|
# Table IV, then adversaries, then reference levels. Entries not listed
|
|
# keep their plot order after the ranked ones.
|
|
LEGEND_ORDER = [
|
|
"KM (str.)", "KM (lrn.)",
|
|
"Public masks", "Permutation key", "Index cipher", "OMA",
|
|
"Eavesdropper", "Eavesdropper, keyed", "Eavesdropper, public masks",
|
|
"Outsider", "Insider",
|
|
"No jammer", "Random guess",
|
|
]
|
|
|
|
|
|
def _rank(label):
|
|
"""Rank a legend label, matching the collection-SNR variants of
|
|
Fig. 7 on their scheme prefix so they stay together and in order."""
|
|
for i, name in enumerate(LEGEND_ORDER):
|
|
if label == name or label.startswith(name + ","):
|
|
return i
|
|
return len(LEGEND_ORDER)
|
|
|
|
|
|
def place_legend(ax, cands=("lower left", "upper left", "center left",
|
|
"center right", "lower center", "upper right",
|
|
"upper center", "center", "lower right"),
|
|
sizes=(9.2, 8.8, 8.4, 8.0, 7.6, 7.2, 6.8, 6.4), ncol=1):
|
|
"""Choose the location and font size whose box the fewest curve points
|
|
fall inside, scored on rendered geometry rather than guessed from the
|
|
data. The size sweep is what makes a long label set placeable: a
|
|
five-entry legend of full scheme names has no clear corner at the
|
|
default size on every figure.
|
|
|
|
The axes rectangle is applied first, because save() enforces the same
|
|
test after applying it. Scoring the default layout and then checking
|
|
a different one is how a placement that looked clear here failed
|
|
there.
|
|
|
|
When PL_FORCED is set, only that size is tried: the driver runs every
|
|
figure once to learn the smallest size any of them needs, then reruns
|
|
them all at that one size so the legends print uniformly."""
|
|
ax.figure.subplots_adjust(**AXES_RECT)
|
|
if PL_FORCED is not None:
|
|
sizes = (PL_FORCED,)
|
|
best = None
|
|
for size in sizes:
|
|
for loc in cands:
|
|
h, l = ax.get_legend_handles_labels()
|
|
idx = sorted(range(len(l)), key=lambda k: (_rank(l[k]), k))
|
|
h = [h[k] for k in idx]
|
|
l = [l[k] for k in idx]
|
|
leg = ax.legend(h, l, loc=loc, prop={"size": size}, ncol=ncol,
|
|
handlelength=1.4, columnspacing=0.9,
|
|
handletextpad=0.5, borderaxespad=0.55,
|
|
framealpha=1.0)
|
|
ax.figure.canvas.draw()
|
|
lb = _inflate(leg.get_window_extent(), ax.figure)
|
|
hits = 0
|
|
for line in ax.get_lines():
|
|
xy = line.get_xydata()
|
|
if len(xy) == 0:
|
|
continue
|
|
for px, py in ax.transData.transform(xy):
|
|
if lb.x0 <= px <= lb.x1 and lb.y0 <= py <= lb.y1:
|
|
hits += 1
|
|
for t in ax.texts:
|
|
tb = t.get_window_extent()
|
|
if (lb.x0 < tb.x1 and tb.x0 < lb.x1
|
|
and lb.y0 < tb.y1 and tb.y0 < lb.y1):
|
|
hits += 50 # an annotation hidden is worse than a
|
|
# few curve points clipped
|
|
if best is None or hits < best[2]:
|
|
best = (loc, size, hits)
|
|
if hits == 0:
|
|
h, l = ax.get_legend_handles_labels()
|
|
idx = sorted(range(len(l)), key=lambda k: (_rank(l[k]), k))
|
|
h = [h[k] for k in idx]
|
|
l = [l[k] for k in idx]
|
|
ax.legend(h, l, loc=loc, prop={"size": size}, ncol=ncol,
|
|
handlelength=1.4, columnspacing=0.9,
|
|
handletextpad=0.5, borderaxespad=0.55,
|
|
framealpha=1.0)
|
|
PL_CHOSEN.append(size)
|
|
return best
|
|
h, l = ax.get_legend_handles_labels()
|
|
idx = sorted(range(len(l)), key=lambda k: (_rank(l[k]), k))
|
|
h = [h[k] for k in idx]
|
|
l = [l[k] for k in idx]
|
|
ax.legend(h, l, loc=best[0], prop={"size": best[1]}, ncol=ncol,
|
|
handlelength=1.4, columnspacing=0.9, handletextpad=0.5,
|
|
borderaxespad=0.55, framealpha=1.0)
|
|
PL_CHOSEN.append(best[1])
|
|
return best
|
|
|
|
|
|
def fig_snr():
|
|
r = load("sec_snr.csv")
|
|
x = col(r, "snr_db")
|
|
fig, ax = plt.subplots()
|
|
# legitimate and the public-mask eavesdropper coincide by
|
|
# construction (same physical layer, public masks decode alike), so
|
|
# the pair is deliberately layered; OMA is separate at this frame
|
|
ax.semilogy(x, col(r, "legit"), **STY["km_str"],
|
|
markevery=(0, 3), label=LBL["legit"], **UNDER)
|
|
# the learned family is the other end of the key-space trade-off,
|
|
# so the figure carries what it costs at every SNR
|
|
rl = load("sec_snr_learned.csv")
|
|
ax.semilogy(col(rl, "snr_db"), col(rl, "legit"), **STY["km_lrn"],
|
|
markevery=(2, 3), label=LBL["legit_learned"])
|
|
ax.semilogy(x, col(r, "oma"), **STY["oma"],
|
|
markevery=(1, 3), label=LBL["oma"], **OVER)
|
|
ax.semilogy(x, col(r, "eve_public"), color=STY["pub"]["color"], marker=STY["pub"]["marker"],
|
|
ls="none", markevery=(2, 3), markerfacecolor="none",
|
|
label=LBL["eve_pub"])
|
|
# this figure carries two eavesdroppers, so the bare label of the
|
|
# key-length figure would not tell them apart
|
|
ax.semilogy(x, col(r, "eve_wrong"), **STY["eve"], label="Eavesdropper, keyed")
|
|
# the chance level lies within 3.5e-4 of the wrong-key curve, so it is
|
|
# drawn for reference but left out of the legend, which the caption
|
|
# names instead; five long entries leave this figure no clear corner
|
|
ax.plot(x, col(r, "chance"), color=C_CH, ls="-.", lw=0.9)
|
|
ax.set_xlabel("SNR (dB)")
|
|
ax.set_ylabel("SER")
|
|
ax.set_xlim(min(x), max(x))
|
|
# most of a decade below the data leaves the lower-left genuinely
|
|
# empty, which is what gives the legend a clear berth
|
|
ax.set_ylim(bottom=2e-4)
|
|
place_legend(ax)
|
|
save(fig, "fig_sec_snr")
|
|
|
|
|
|
def fig_keylen():
|
|
"""The OMA reference is the resource-matched one of oma_ser_keylen,
|
|
which is undefined below L=16 unless 16/L is an integer; those
|
|
rows carry nan and are skipped."""
|
|
r = load("sec_keylen.csv")
|
|
x = col(r, "L", int)
|
|
fig, ax = plt.subplots()
|
|
ax.semilogy(x, col(r, "legit_ser"), **STY["km_str"], label=LBL["legit"])
|
|
rl = load("sec_keylen_learned.csv")
|
|
ax.semilogy(col(rl, "L", int), col(rl, "legit_ser"), **STY["km_lrn"], label=LBL["legit_learned"])
|
|
op = [(l, v) for l, v in zip(x, col(r, "oma")) if not math.isnan(v)]
|
|
ax.semilogy([p[0] for p in op], [p[1] for p in op], **STY["oma"], label=LBL["oma"])
|
|
ax.semilogy(x, col(r, "eve_ser"), **STY["eve"], label=LBL["eve_key"])
|
|
ax.set_ylim(top=22.0) # headroom above the flat eavesdropper curve
|
|
# an error rate cannot exceed one, and the room below the data holds
|
|
# the legend, since every curve decays to the right
|
|
ax.set_ylim(top=1.4, bottom=1.2e-2)
|
|
ax.set_xlabel("Key length $L$")
|
|
ax.set_ylabel("SER")
|
|
ax.set_xscale("log", base=2)
|
|
place_legend(ax)
|
|
save(fig, "fig_sec_keylen")
|
|
|
|
|
|
def fig_jam():
|
|
"""Target-user SER against JSR in five cases, on a log ordinate.
|
|
|
|
With the unjammed reference the range spans 0.053 to 0.998, over a
|
|
decade, so the axis carries two major ticks and the minor tick
|
|
labels that crowd a sub-decade log axis are suppressed. The room
|
|
below the data holds the legend, which is why the earlier linear
|
|
version reserved a band below zero instead. The no-jammer reference
|
|
is named in the caption rather than in the legend."""
|
|
r = load("sec_jam_cmp.csv")
|
|
x = col(r, "jsr_db")
|
|
me = max(1, len(x) // 8)
|
|
fig, ax = plt.subplots()
|
|
rj = load("sec_jam_learned.csv")
|
|
ax.semilogy(col(rj, "jsr_db"), col(rj, "blind"), **STY["km_lrn"],
|
|
markevery=(1, me), label=LBL["legit_learned"])
|
|
ax.semilogy(x, col(r, "matched"), **STY["pub"],
|
|
markevery=me, label="Public masks")
|
|
ax.semilogy(x, col(r, "oma_targeted"), **STY["oma"],
|
|
markevery=me, label=LBL["oma"])
|
|
# the two blind curves agree to 0.002; deliberate layering
|
|
ax.semilogy(x, col(r, "blind"), **STY["km_str"],
|
|
markevery=(0, me), label=LBL["mask"], **UNDER)
|
|
ax.semilogy(x, col(r, "perm_blind"), **STY["perm"],
|
|
markevery=(me // 2, me), label=LBL["perm"], **OVER)
|
|
nojam = float(load("sec_jam.csv")[0]["nojam"])
|
|
# the unjammed reference is named in the caption rather than in the
|
|
# legend, which keeps the folded legend two rows tall
|
|
# Behind the legend rather than through it. The placement guard skips
|
|
# axis-spanning lines, so it cannot move the legend off this one, and
|
|
# a reference drawn along the legend frame reads as part of the box.
|
|
ax.axhline(nojam, color=C_OMA, ls=(0, (1, 3)), lw=0.9, zorder=0)
|
|
ax.set_ylim(6e-3, 1.4)
|
|
# a log axis spanning little more than a decade prints minor labels
|
|
# like 6x10^-1 that consume the left margin, so only the decades are
|
|
# labelled
|
|
ax.yaxis.set_minor_formatter(mticker.NullFormatter())
|
|
ax.set_xlabel("JSR (dB)")
|
|
ax.set_ylabel("SER")
|
|
ax.set_xlim(min(x), max(x))
|
|
place_legend(ax)
|
|
save(fig, "fig_sec_jam")
|
|
|
|
|
|
def fig_sens():
|
|
"""Key sensitivity of three schemes on one axis, the fraction of the
|
|
key the attacker holds. All three ride the random-guess level over
|
|
most of the range, so the flat region is deliberately layered."""
|
|
r = load("sec_sens_cmp.csv")
|
|
x = col(r, "frac")
|
|
fig, ax = plt.subplots()
|
|
ax.plot(x, col(r, "ser_mask"), **STY["km_str"],
|
|
markevery=(0, 3), label=LBL["mask"], **UNDER)
|
|
rs = load("sec_sens_learned.csv")
|
|
ax.plot(col(rs, "frac"), col(rs, "ser_mask"), **STY["km_lrn"],
|
|
markevery=(1, 3), label=LBL["legit_learned"])
|
|
ax.plot(x, col(r, "ser_perm"), **STY["perm"],
|
|
markevery=(1, 3), label=LBL["perm"], **OVER)
|
|
ax.plot(x, col(r, "ser_pad"), **STY["pad"],
|
|
markevery=(2, 3), lw=1.2, mfc="none", label=LBL["pad"])
|
|
# the chance level comes from the stored curve, not from a second
|
|
# copy of the configuration constants
|
|
chance = float(load("sec_snr.csv")[0]["chance"])
|
|
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)
|
|
place_legend(ax)
|
|
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_perm"), **STY["perm"],
|
|
markevery=(0, 3), label=LBL["perm"], **UNDER)
|
|
ax.semilogx(x, col(r, "ser_pad"), **STY["pad"],
|
|
markevery=(1, 3), label=LBL["pad"], **OVER)
|
|
ax.semilogx(x, col(r, "ser_mask"), **STY["km_str"],
|
|
markevery=(2, 3), label=LBL["mask"])
|
|
rb = load("sec_brute_learned.csv")
|
|
ax.semilogx(col(rb, "K"), col(rb, "ser_mask"), **STY["km_lrn"],
|
|
markevery=(1, 3), label=LBL["legit_learned"])
|
|
ax.set_xlabel("Number of key guesses $K$")
|
|
ax.set_ylabel("Eavesdropper SER")
|
|
ax.set_ylim(0.0, 1.05) # keep the reference line off the spine
|
|
place_legend(ax)
|
|
save(fig, "fig_sec_brute")
|
|
|
|
|
|
def fig_real():
|
|
r = load("real_sec_ter.csv")
|
|
x = col(r, "snr_db")
|
|
fig, ax = plt.subplots()
|
|
# insider and outsider still nearly coincide and are layered; the
|
|
# legitimate and OMA curves are separate at this frame
|
|
ax.semilogy(x, col(r, "ter_legit"), **STY["km_str"],
|
|
markevery=(0, 2), label=LBL["legit"], **UNDER)
|
|
rt = load("real_sec_ter_learned.csv")
|
|
ax.semilogy(col(rt, "snr_db"), col(rt, "ter_legit"),
|
|
**STY["km_lrn"], markevery=(1, 2),
|
|
label=LBL["legit_learned"])
|
|
ax.semilogy(x, col(r, "ter_oma"), **STY["oma"],
|
|
markevery=(1, 2), label=LBL["oma"], **OVER)
|
|
ax.semilogy(x, col(r, "ter_insider"), **STY["insider"],
|
|
markevery=(0, 2), label=LBL["insider"], **UNDER)
|
|
ax.semilogy(x, col(r, "ter_eve"), **STY["eve"],
|
|
markevery=(1, 2), label=LBL["outsider"], **OVER)
|
|
ax.set_xlabel("SNR (dB)")
|
|
ax.set_ylabel("TER")
|
|
ax.set_xlim(min(x), max(x))
|
|
place_legend(ax)
|
|
save(fig, "fig_sec_real")
|
|
|
|
|
|
def fig_kpa():
|
|
"""Known-plaintext recovery of the keyed masks at three collection
|
|
SNRs, with the permutation key under the same attack as the linear
|
|
comparison scheme."""
|
|
r = load("kpa.csv")
|
|
fig, ax = plt.subplots()
|
|
sty = {0.0: (C_LEGIT, "o"), 10.0: (C_EVE, "s"),
|
|
20.0: (C_PUB, "v")}
|
|
for off, (snr, (c, mk)) in enumerate(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="-",
|
|
markevery=(off, 4), markerfacecolor="none" if off else c,
|
|
label=f"KM (str.), {int(snr)} dB")
|
|
if snr == 10.0:
|
|
kl = [q for q in load("kpa_learned.csv")
|
|
if float(q["snr_db"]) == snr]
|
|
ax.semilogx([float(q["n_frames"]) for q in kl],
|
|
[float(q["eve_ser"]) for q in kl], **STY["km_lrn"],
|
|
markevery=(2, 4),
|
|
label=f"KM (lrn.), {int(snr)} dB")
|
|
try:
|
|
p = load("pkpa.csv")
|
|
ax.semilogx(col(p, "n_frames"), col(p, "eve_ser"), color=C_MATCH,
|
|
marker="P", ls="--", markevery=(3, 4),
|
|
label=LBL["perm"] + ", 20 dB")
|
|
except FileNotFoundError:
|
|
print("[skip] pkpa.csv not present yet")
|
|
# legitimate reference measured with the SAME estimator as the
|
|
# eavesdropper curves, namely the four-user average of eval_ser_sse
|
|
# in the main configuration, rather than the user-1 convention of the
|
|
# scheme-comparison table
|
|
ax.set_xlabel("Known-plaintext frames $N$")
|
|
ax.set_ylabel("Eavesdropper SER")
|
|
ax.set_xscale("log", base=2)
|
|
# the 0 dB curve sweeps the upper-right, so anchor the legend at the
|
|
# top edge past the steep drops, above every curve at large N
|
|
ax.set_ylim(top=1.18)
|
|
place_legend(ax)
|
|
save(fig, "fig_sec_kpa")
|
|
|
|
|
|
def run_all():
|
|
fig_snr()
|
|
fig_keylen()
|
|
fig_jam()
|
|
try:
|
|
fig_sens()
|
|
fig_brute()
|
|
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")
|
|
|
|
|
|
def main():
|
|
"""Two passes: the first learns the smallest legend size any figure
|
|
needs, the second forces that one size everywhere so the legends
|
|
print uniformly, which the figure standard requires."""
|
|
global PL_FORCED
|
|
PL_FORCED = None
|
|
PL_CHOSEN.clear()
|
|
run_all()
|
|
if PL_CHOSEN:
|
|
PL_FORCED = min(PL_CHOSEN)
|
|
print("[uniform] legend size %.1f pt on every figure" % PL_FORCED)
|
|
PL_CHOSEN.clear()
|
|
run_all()
|
|
print("[done] figures in", FIG)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|