Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.bouncycastle.crypto.test;
  
  import java.util.Vector;
  
Test case for NaccacheStern cipher. For details on this cipher, please see http://www.gemplus.com/smart/rd/publications/pdf/NS98pkcs.pdf Performs the following tests:
  • Toy example from the NaccacheSternPaper
  • 768 bit test with text "Now is the time for all good men." (ripped from RSA test) and the same test with the first byte replaced by 0xFF
  • 1024 bit test analog to 768 bit test
 
 public class NaccacheSternTest
     extends SimpleTest
 {
     static final boolean debug = false;
 
     static final NaccacheSternEngine cryptEng = new NaccacheSternEngine();
 
     static final NaccacheSternEngine decryptEng = new NaccacheSternEngine();
 
     static
     {
         .setDebug();
         .setDebug();
     }
 
     // Values from NaccacheStern paper
     static final BigInteger a = BigInteger.valueOf(101);
 
     static final BigInteger u1 = BigInteger.valueOf(3);
 
     static final BigInteger u2 = BigInteger.valueOf(5);
 
     static final BigInteger u3 = BigInteger.valueOf(7);
 
     static final BigInteger b = BigInteger.valueOf(191);
 
     static final BigInteger v1 = BigInteger.valueOf(11);
 
     static final BigInteger v2 = BigInteger.valueOf(13);
 
     static final BigInteger v3 = BigInteger.valueOf(17);
 
     static final BigInteger ONE = BigInteger.valueOf(1);
 
     static final BigInteger TWO = BigInteger.valueOf(2);
 
     static final BigInteger sigma = .multiply().multiply().multiply()
             .multiply().multiply();
 
     static final BigInteger p = .multiply().multiply().multiply()
             .multiply().add();
 
     static final BigInteger q = .multiply().multiply().multiply()
             .multiply().add();
 
     static final BigInteger n = .multiply();
 
     static final BigInteger phi_n = .subtract().multiply(.subtract());
 
     static final BigInteger g = BigInteger.valueOf(131);
 
     static final Vector smallPrimes = new Vector();
 
     // static final BigInteger paperTest = BigInteger.valueOf(202);
 
     static final String input = "4e6f77206973207468652074696d6520666f7220616c6c20676f6f64206d656e";
 
     static final BigInteger paperTest = BigInteger.valueOf(202);
 
     //
     // to check that we handling byte extension by big number correctly.
     //
     static final String edgeInput = "ff6f77206973207468652074696d6520666f7220616c6c20676f6f64206d656e";
 
     public String getName()
     {
         return "NaccacheStern";
     }
 
     public void performTest()
    {
        // Test with given key from NaccacheSternPaper (totally insecure)
        // First the Parameters from the NaccacheStern Paper
        // (see http://www.gemplus.com/smart/rd/publications/pdf/NS98pkcs.pdf )
        .addElement();
        .addElement();
        .addElement();
        .addElement();
        .addElement();
        .addElement();
        NaccacheSternKeyParameters pubParameters = new NaccacheSternKeyParameters(false.bitLength());
        AsymmetricCipherKeyPair pair = new AsymmetricCipherKeyPair(pubParametersprivParameters);
        // Initialize Engines with KeyPair
        if ()
        {
            ..println("initializing encryption engine");
        }
        .init(truepair.getPublic());
        if ()
        {
            ..println("initializing decryption engine");
        }
        .init(falsepair.getPrivate());
        byte[] data = .toByteArray();
        if (!new BigInteger(data).equals(new BigInteger(enDeCrypt(data))))
        {
            fail("failed NaccacheStern paper test");
        }
        //
        // key generation test
        //
        // 
        // 768 Bit test
        //
        if ()
        {
            ..println();
            ..println("768 Bit TEST");
        }
        // specify key generation parameters
        NaccacheSternKeyGenerationParameters genParam
            = new NaccacheSternKeyGenerationParameters(new SecureRandom(), 768, 8, 30, );
        // Initialize Key generator and generate key pair
        pGen.init(genParam);
        pair = pGen.generateKeyPair();
        if (((NaccacheSternKeyParameters)pair.getPublic()).getModulus().bitLength() < 768)
        {
            ..println("FAILED: key size is <786 bit, exactly "
                            + ((NaccacheSternKeyParameters)pair.getPublic()).getModulus().bitLength() + " bit");
            fail("failed key generation (768) length test");
        }
        // Initialize Engines with KeyPair
        if ()
        {
            ..println("initializing " + genParam.getStrength() + " bit encryption engine");
        }
        .init(truepair.getPublic());
        if ()
        {
            ..println("initializing " + genParam.getStrength() + " bit decryption engine");
        }
        .init(falsepair.getPrivate());
        // Basic data input
        data = Hex.decode();
        if (!new BigInteger(1, data).equals(new BigInteger(1, enDeCrypt(data))))
        {
            fail("failed encryption decryption (" + genParam.getStrength() + ") basic test");
        }
        // Data starting with FF byte (would be interpreted as negative
        // BigInteger)
        data = Hex.decode();
        if (!new BigInteger(1, data).equals(new BigInteger(1, enDeCrypt(data))))
        {
            fail("failed encryption decryption (" + genParam.getStrength() + ") edgeInput test");
        }
        // 
        // 1024 Bit Test
        // 
/*
        if (debug)
        {
            System.out.println();
            System.out.println("1024 Bit TEST");
        }
        // specify key generation parameters
        genParam = new NaccacheSternKeyGenerationParameters(new SecureRandom(), 1024, 8, 40);
        pGen.init(genParam);
        pair = pGen.generateKeyPair();
        if (((NaccacheSternKeyParameters)pair.getPublic()).getModulus().bitLength() < 1024)
        {
            if (debug)
            {
                System.out.println("FAILED: key size is <1024 bit, exactly "
                                + ((NaccacheSternKeyParameters)pair.getPublic()).getModulus().bitLength() + " bit");
            }
            fail("failed key generation (1024) length test");
        }
        // Initialize Engines with KeyPair
        if (debug)
        {
            System.out.println("initializing " + genParam.getStrength() + " bit encryption engine");
        }
        cryptEng.init(true, pair.getPublic());
        if (debug)
        {
            System.out.println("initializing " + genParam.getStrength() + " bit decryption engine");
        }
        decryptEng.init(false, pair.getPrivate());
        if (debug)
        {
            System.out.println("Data is           " + new BigInteger(1, data));
        }
        // Basic data input
        data = Hex.decode(input);
        if (!new BigInteger(1, data).equals(new BigInteger(1, enDeCrypt(data))))
        {
            fail("failed encryption decryption (" + genParam.getStrength() + ") basic test");
        }
        // Data starting with FF byte (would be interpreted as negative
        // BigInteger)
        data = Hex.decode(edgeInput);
        if (!new BigInteger(1, data).equals(new BigInteger(1, enDeCrypt(data))))
        {
            fail("failed encryption decryption (" + genParam.getStrength() + ") edgeInput test");
        }
*/
        // END OF TEST CASE
        try
        {
            new NaccacheSternEngine().processBlock(new byte[]{ 1 }, 0, 1);
            fail("failed initialisation check");
        }
        catch (IllegalStateException e)
        {
            // expected
        }
        catch (InvalidCipherTextException e)
        {
            fail("failed initialisation check");
        }
        if ()
        {
            ..println("All tests successful");
        }
    }
    private byte[] enDeCrypt(byte[] input)
    {
        // create work array
        byte[] data = new byte[input.length];
        System.arraycopy(input, 0, data, 0, data.length);
        // Perform encryption like in the paper from Naccache-Stern
        if ()
        {
            ..println("encrypting data. Data representation\n"
            //                    + "As String:.... " + new String(data) + "\n"
                            + "As BigInteger: " + new BigInteger(1, data));
            ..println("data length is " + data.length);
        }
        try
        {
            data = .processData(data);
        }
        catch (InvalidCipherTextException e)
        {
            if ()
            {
                ..println("failed - exception " + e.toString() + "\n" + e.getMessage());
            }
            fail("failed - exception " + e.toString() + "\n" + e.getMessage());
        }
        if ()
        {
            ..println("enrypted data representation\n"
            //                    + "As String:.... " + new String(data) + "\n"
                            + "As BigInteger: " + new BigInteger(1, data));
            ..println("data length is " + data.length);
        }
        try
        {
            data = .processData(data);
        }
        catch (InvalidCipherTextException e)
        {
            if ()
            {
                ..println("failed - exception " + e.toString() + "\n" + e.getMessage());
            }
            fail("failed - exception " + e.toString() + "\n" + e.getMessage());
        }
        if ()
        {
            ..println("decrypted data representation\n"
            //                    + "As String:.... " + new String(data) + "\n"
                            + "As BigInteger: " + new BigInteger(1, data));
            ..println("data length is " + data.length);
        }
        return data;
    }
    public static void main(String[] args)
    {
        runTest(new NaccacheSternTest());
    }
New to GrepCode? Check out our FAQ X