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

In the era of pervasive surveillance reminiscent of Orwellian nightmares, old-school Cold War hacks have staged a comeback, offering a clandestine refuge for the exchange of information.
