Le number stations

[Tomás de Torquemada]

Immagine tratta dal sito http://24.media.tumblr.com/

Le Numbers Stations

Il "mistero" delle Numbers Stations, anche se non molto conosciuto, č uno dei piů intriganti in circolazione ed anche uno dei piů recenti; Ma cosa sono le Number Stations? Non sono altro che stazioni radio ad onde corte che trasmettono di continuo parole e numeri in sequenza apparentemente casuale, da qui il nome “Numbers Station”.

Queste particolari stazioni radio esistono da svariati anni, se ne hanno tracce addirittura sin dalla prima guerra mondiale, ma agli inizi degli anni 90 il fenomeno č cresciuto a dismisura, diventando un vero e proprio caso internazionale ed anche una sorta di leggenda metropolitana.

CONTINUA A LEGGERE

[

[donerdarko]

Anche in Fringe, noto telefilm di fantascienza, si č parlato in una puntata di questi misteriosi messaggi in codice:

[Silvia]

[GNU-GPL]

Sono 2 anni che contribuisco allo sviluppo di Truecrypt TrueCrypt - Free Open-Source On-The-Fly Disk Encryption Software for Windows 7/Vista/XP, Mac OS X and Linux - Downloads

E questi ancora con le onde radio

[Tomás de Torquemada]

[Tomás de Torquemada]

Corea del Nord: comunicazioni con spie attraverso sistemi da guerra fredda?


Il leader nordcoreano Kim Jong-un davanti ad un computer. Fonte: Reuters

Redazione IBTimes USA

Strane stringhe di numeri sulle radio della Corea del Nord stanno facendo sospettare alcune autoritŕ di Seul che il paese stia utilizzando un vecchio sistema della Guerra Fredda per comunicare in codice. Piů volte nelle scorse cinque settimane, una donna č stata ascoltata durante una trasmissione radio mentre leggeva una sequenza di numeri, come ha riportato Associated Press. L’ultima trasmissione di questa natura da parte del Nord č avvenuta nel 2000, prima che le due Coree tenessero un meeting sulla riunificazione delle famiglie separate, stando a quanto ha riportato il giornale coreano JoongAng Daily.

Con le relazioni tra i due paesi che si stanno nuovamente irrigidendo, gli ascoltatori hanno sentito una donna andare in onda venerdě mattina dicendo, “A partire da ora passerň in rassegna i lavori agli agenti di esplorazione Numero 27”, secondo la Yonhap. La donna ha continuato dicendo frasi del tipo “a pagina 459, Numero 35”, “a pagina 913, Numero 55”, a pagina 135, Numero 86”. La donna ha continuato per 14 minuti, molto piů tempo rispetto ai due minuti di una simile trasmissione avvenuta a fine giugno.

La Corea era solita servirsi - cosě come la Corea del Sud e altri paesi - di stazioni radio a onde corte (conosciute con il nome numbers station) per dare informazioni alle spie. Un agente sotto copertura si sintonizza ad una specifica ora e su una specifica frequenza e converte i numeri in parole attraverso un codice che tengono con sé.

"Č un classico - č il modo piů sicuro per inviare messaggi senza lasciare tracce”, ha detto alla Reuters nel 2014 un ex agente che si fa identificare con il nome di Yeom.

Nel caso delle Coree durante la Guerra Fredda, la persona che inviava i messaggi e la spia spesso avevano lo stesso libro usato per decodificare i numeri, stando alla Yonhap. Per questa ragione le trasmissioni radio ascoltate venerdě e a fine giugno sull’assegnazione di matematica e fisica per “membri di esplorazione” ha sollevato preoccupazioni, come ha riportato AP.

Ma almeno un esperto fa notare che il sistema delle stazioni radio a onde corte non dovrebbero essere il sistema di comunicazione piů moderno e efficiente per trasmettere informazioni. Come ha scritto a inizio anno il Daily Beast, “Corea del Sud e Corea del Nord hanno le loro rispettive stazioni radio a corta frequenza, usate presumibilmente per comunicare con le loro rispettive spie, tuttavia č possibile che ognuno stia cercando di convincere l’altro che quello č quanto possono fare”.

Inoltre, la Corea del Sud ha annunciato martedě che Pyongyang ha lanciato tre missili balistici, in risposta al sistema di difesa area installato dagli Stati Uniti nel paese alleato.

Corea del Nord: comunicazioni con spie attraverso sistemi da guerra fredda? - http://it.ibtimes.com/

[GNU-GPL]

Hai capito il ciccione. Sa pure come trasmettere messaggi "sicuri"....

Is using a numbers station to transmit a one-time-pad as key actually insecure?

[...] if your PRNG is cryptographically secure and seeded with some initial randomness of large enough entropy (128 bits are enough), then it won't be predictable. [...]

key management - Is using a numbers station to transmit a one-time-pad as key actually insecure? - Information Security Stack Exchange

[GNU-GPL]

Per 50 linee di codice non sapremo mai a che ora lancia i missili atomici !!

https://sourceforge.net/projects/cryptomni/

"Cryptomni is a program which can encrypt and decrypt files using the one-time pad cipher. A key file is created using the cryptographically strong random number generator SecureRandom. If a key is truly random, kept secret, and never reused, this encryption algorithm can be proven to be unbreakable."

package src;

/*-- Cryptomni.java --------------------------------------------------------------

  Cryptomni Version 1.3

  Copyright (C) 2016 Byron Knoll

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU-GPL as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU-GPL
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

--------------------------------------------------------------------------------*/

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.security.SecureRandom;

/** 
 * Cryptomni is a program which can encrypt and decrypt files using the one-time 
 * pad cipher. A key file is created using the cryptographically strong random 
 * number generator SecureRandom. If a key is truly random, kept secret, and never
 * reused, this encryption algorithm can be proven to be unbreakable.
 * @author  Byron Knoll
 *  [MENTION=43225]Ver[/MENTION]sion 1.3, 02/25/2016
 */
public class Cryptomni
{
    public static void main(String[] args)
    {
        // Display program information:
        System.out.println("Cryptomni Version 1.3");
        System.out.println("Copyright (C) 2016 Byron Knoll\n");
        
        // The displayHelp variable will be set to true if invalid command-line 
        // arguments are used.
        boolean displayHelp = false;
        
        if (args.length == 0)
        {
            new CryptomniGUI(); // Open a graphical user interface.
        }
        else if (args.length == 1)
        {
            if (args[0].equals("-i")) 
            {
                String aboutString =
                "Cryptomni is a program which can encrypt and decrypt files"+
                "\nusing the one-time pad cipher. A key file is created using\n"+
                "the cryptographically strong random number generator \n" +
                "SecureRandom. If a key is truly random, kept secret, and\n" +
                "never reused, this encryption algorithm can be proven to\n" +
                "be unbreakable.\n\n"+
                "This program is free software; you can redistribute it and/or\n"+
                "modify it under the terms of the GNU General Public License\n"+
                "as published by the Free Software Foundation; either version\n"+
                "2 of the License, or (at your option) any later version. \n\n"+
                "This program is distributed in the hope that it will be useful,"+
                "\nbut WITHOUT ANY WARRANTY; without even the implied \n" +
                "warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\n" +
                "PURPOSE. See the GNU General Public License for more details.";
                System.out.println(aboutString);
            }
            else
            {
                displayHelp = true;
            }
        }
        else if (args.length == 3)
        {
            if (args[0].equals("-c")) 
            {
                try 
                {
                    // Attempt to convert the third argument to an integer.
                    int size = Integer.parseInt(args[2]);
                    // Attempt to create the Cryptomni key.
                    if (createKey(new File(args[1]), size))
                    {
                        System.out.println("Cryptomni key successfully created.");
                    }
                    else
                    {
                        System.out.println("File IO exception.\n");
                        displayHelp = true;
                    }
                } 
                catch (NumberFormatException e) 
                {
                    // The third argument must be an integer.
                    displayHelp = true;
                }
            }
            else displayHelp = true;
        }
        else if (args.length == 4)
        {
            if (args[0].equals("-e1"))
            {
                // Attempt to encrypt the file.
                if (encryptFile(new File(args[1]), new File (args[2]), 
                        new File (args[3]), false))
                {
                    System.out.println("File encrypted successfully.");
                }
                else
                {
                    System.out.println("File IO exception.\n");
                    displayHelp = true;
                }
            }
            else if (args[0].equals("-e2"))
            {
                // Attempt to encrypt the file.
                if (encryptFile(new File(args[1]), new File (args[2]), 
                        new File (args[3]), true))
                {
                    System.out.println("File encrypted successfully.");
                }
                else
                {
                    System.out.println("File IO exception.\n");
                    displayHelp = true;
                }
            }
            else if (args[0].equals("-d1"))
            {
                // Attempt to decrypt the file.
                if (decryptFile(new File(args[1]), new File (args[2]), 
                        new File (args[3]), false))
                {
                    System.out.println("File decrypted successfully.");
                }
                else
                {
                    System.out.println("File IO exception.\n");
                    displayHelp = true;
                }
            }
            else if (args[0].equals("-d2"))
            {
                // Attempt to decrypt the file.
                if (decryptFile(new File(args[1]), new File (args[2]), 
                        new File (args[3]), true))
                {
                    System.out.println("File decrypted successfully.");
                }
                else
                {
                    System.out.println("File IO exception.\n");
                    displayHelp = true;
                }
            }
            else displayHelp = true;
        }
        else // Invalid number of arguments.
        {
            System.out.println("Invalid number of command-line arguments.\n");
            displayHelp = true;
        }
        
        if (displayHelp) // Display usage instructions.
        {
            System.out.println("Usage:\n");
            System.out.println("A graphical user interface will open if no " +
                               "command-line arguments are provided.\n");
            System.out.println("-i");
            System.out.println("Display program information.\n");
            System.out.println("-c <filename> <size>");
            System.out.println("Create a Cryptomni key with the specified " +
                               "number of bytes.\n");
            System.out.println("-e1 <source file> <key file> <destination file>");
            System.out.println("Encrypt a file using the specified Cryptomni " +
                               "key (without modifying the key).\n");
            System.out.println("-e2 <source file> <key file> <destination file>");
            System.out.println("Encrypt a file using the specified Cryptomni " +
                               "key (deleting the used portion of the key " +
                               "file).\n");
            System.out.println("-d1 <encrypted file> <key file> " +
                               "<destination file>");
            System.out.println("Decrypt a file using the specified Cryptomni " +
                                   "key (without modifying the key).\n");    
            System.out.println("-d2 <encrypted file> <key file> " +
               "<destination file>");
            System.out.println("Decrypt a file using the specified Cryptomni " +
                               "key (deleting the used portion of the key " +
                               "file).\n");
        }
    }
    
    /** 
     * Attempts to create a Cryptomni key with the specified number of bytes.
     * 
     * @param  filename the location to create the Cryptomni key file.
     * @param  byteSize the number of bytes of the Cryptomni key file.
     * @return             a boolean that is true if the Cryptomni key was 
     *                     successfully created, or false if an IOException occurred.
     */
    public static boolean createKey (File filename, int byteSize)
    {
        // Create random bytes using a cryptographically strong random 
        // number generator.
        SecureRandom random  = new SecureRandom();
        byte[] pseudoRandom = new byte [byteSize];
        random.nextBytes(pseudoRandom);
        
        FileOutputStream out = null;
        try 
        {
            // Create a file output stream.
            out = new FileOutputStream(filename, false);
            // Iterate through each byte in the file.
            for (byte currentByte: pseudoRandom)
            {
                // Write a random byte to the file.
                out.write(currentByte);
            }
            // Close the output stream.
            out.close();
        }
        catch (IOException e1)
        {
            if (out != null) // Check if the output stream was created.
            {
                try
                {
                    // Close the output stream.
                    out.close();
                }
                catch (IOException e2) {}
            }
            // Return false because of the IOException.
            return false;
        }
        // Return true since the operation was successful.
        return true;
    }
    
    /** 
     * Attempts to encrypt a file using the specified Cryptomni key.
     * 
     * @param  sourceFile         the location of the file to encrypt.
     * @param  keyFile            the location of the Cryptomni key file.
     * @param  destinationFile    the location to create the new encrypted file.
     * @param  shrink            a boolean which determines whether the used 
     *                             portion of the key file should be deleted.
     * @return                     a boolean that is true if the file was 
     *                             successfully encrypted, or false if an 
     *                             IOException occurred.
     */
    public static boolean encryptFile (File sourceFile, File keyFile, 
            File destinationFile, boolean shrink)
    {
        FileInputStream in = null;
        FileInputStream key = null;
        FileOutputStream out = null;
        try 
        {
            // Create file IO streams.
            in = new FileInputStream(sourceFile);
            key = new FileInputStream(keyFile);
            out = new FileOutputStream(destinationFile, false);
            int currentByte, keyByte, newByte;

            // Iterate through the bytes in the original file.
            while ((currentByte = in.read()) != -1) 
            {
                keyByte = key.read();
                // Calculate the value of the encrypted byte.
                newByte = (currentByte+keyByte)%256;
                // Write the byte to the encrypted file.
                out.write(newByte);
            }
            
            // Check whether the key file needs to be changed.
            if (shrink && (sourceFile.length()<keyFile.length()))
            {
                // Create a temporary file.
                File temp = File.createTempFile("crypt", null);
                // Delete temp file when program exits.
                temp.deleteOnExit();
                // Create a new output stream.
                out.close();
                out = new FileOutputStream(temp, false);
                // Iterate through the remaining bytes in the key file.
                while ((currentByte = key.read()) != -1) 
                {
                    // Write the byte to the temp file.
                    out.write(currentByte);
                }
                // Close the IO streams.
                in.close();
                key.close();
                out.close();
                // Create new file IO streams to write the new key file.
                in = new FileInputStream(temp);
                out = new FileOutputStream(keyFile, false);
                // Write the new key file.
                while ((currentByte = in.read()) != -1) 
                {
                    // Write the byte to the key file.
                    out.write(currentByte);
                }
                // Close the remaining IO streams.
                in.close();
                out.close();
            }
            else
            {            
                // Close the IO streams.
                in.close();
                key.close();
                out.close();
            }
        } 
        catch (IOException e1) 
        {
            try
            {
                if (in != null) // Check if the input stream was created.
                {
                    // Close the input stream.
                    in.close();
                }
                if (key != null) // Check if the input stream was created.
                {
                    // Close the input stream.
                    key.close();
                }
                if (out != null) // Check if the output stream was created.
                {
                    // Close the output stream.
                    out.close();
                }
            }
            catch (IOException e2) {}
            // Return false because of the IOException.
            return false;
        }
        // Return true since the operation was successful.
        return true;
    }
    
    /** 
     * Attempts to decrypt a file using the specified Cryptomni key.
     * 
     * @param  encryptedFile    the location of the file to decrypt.
     * @param  keyFile            the location of the Cryptomni key file.
     * @param  destinationFile    the location to create the new decrypted file.
     * @param  shrink            a boolean which determines whether the used 
     *                             portion of the key file should be deleted.
     * @return                     a boolean that is true if the file was 
     *                             successfully decrypted, or false if an 
     *                             IOException occurred.
     */
    public static boolean decryptFile (File encryptedFile, File keyFile, 
            File destinationFile, boolean shrink)
    {
        FileInputStream in = null;
        FileInputStream key = null;
        FileOutputStream out = null;   
        try 
        {
            // Create file IO streams.
            in = new FileInputStream(encryptedFile);
            key = new FileInputStream(keyFile);
            out = new FileOutputStream(destinationFile, false);
            int currentByte, keyByte, newByte;

            // Iterate through the bytes in the encrypted file.
            while ((currentByte = in.read()) != -1) 
            {
                keyByte = key.read();
                // Calculate the value of the decrypted byte.
                newByte = currentByte-keyByte;
                if (newByte < 0) newByte+=256;
                // Write the byte to the decrypted file.
                out.write(newByte);
            }
            
            // Check whether the key file needs to be changed.
            if (shrink && (encryptedFile.length()<keyFile.length()))
            {
                // Create a temporary file.
                File temp = File.createTempFile("crypt", null);
                // Delete temp file when program exits.
                temp.deleteOnExit();
                // Create a new output stream.
                out.close();
                out = new FileOutputStream(temp, false);
                // Iterate through the remaining bytes in the key file.
                while ((currentByte = key.read()) != -1) 
                {
                    // Write the byte to the temp file.
                    out.write(currentByte);
                }
                // Close the IO streams.
                in.close();
                key.close();
                out.close();
                // Create new file IO streams to write the new key file.
                in = new FileInputStream(temp);
                out = new FileOutputStream(keyFile, false);
                // Write the new key file.
                while ((currentByte = in.read()) != -1) 
                {
                    // Write the byte to the key file.
                    out.write(currentByte);
                }
                // Close the remaining IO streams.
                in.close();
                out.close();
            }
            else
            {            
                // Close the IO streams.
                in.close();
                key.close();
                out.close();
            }
        } 
        catch (IOException e1) 
        {
            try
            {
                if (in != null) // Check if the input stream was created.
                {
                    // Close the input stream.
                    in.close();
                }
                if (key != null) // Check if the input stream was created.
                {
                    // Close the input stream.
                    key.close();
                }
                if (out != null) // Check if the output stream was created.
                {
                    // Close the output stream.
                    out.close();
                }
            }
            catch (IOException e2) {}
            // Return false because of the IOException.
            return false;
        }
        // Return true since the operation was successful.
        return true;
    }
} 

[GNU-GPL]

In effetti č l'unico modo per trasmettere messaggi indecifrabili... Usando una chiave "casuale" il risultato del testo cifrato sarŕ sempre diverso... E solo conoscendo la chiave usata sarŕ possibile risalire al messaggio... Infatti il testo cifrato trasmesso delle numbers station č del tutto casuale... Come lo č la chiave per la decrittazione posseduta dal destinatario del messaggio...

Cifrario di Vernam

Il cifrario di Vernam č un sistema crittografico basato sul cifrario di Vigenčre, al quale aggiunge il requisito che la chiave di cifratura sia lunga quanto il testo e non riutilizzabile (per questo viene spesso chiamato OTP, acronimo per l'inglese One Time Pad (OTP), letteralmente "blocco monouso".

Il cifrario di Vernam č l'unico sistema crittografico la cui sicurezza sia comprovata da una dimostrazione matematica e per questo si č guadagnato il titolo di "cifrario perfetto". La prima dimostrazione della sua inviolabilitŕ fu pubblicata nel 1949 da Claude Shannon nell'articolo "La teoria della comunicazione nei sistemi crittografici".

https://it.wikipedia.org/wiki/Cifrario_di_Vernam