testsafer.java

jpeg2000编解码

  136, 213,  53,   6,  47, 224, 109, 160,   219,  86,  60, 145, 172, 116,  48, 107,
  176,  32,   6,  89,  39, 152, 171, 143,    17, 161, 187,  95, 105, 135, 164,   1,
  211,  29, 246,  81,  22,  51, 105,  79,    58,  56,  54, 193, 174,  28, 140, 184,
  244,  40, 192,  18, 185,  19,  13, 176,   160, 217,  42,  37, 241, 100,  49,  80,
   92, 189, 119, 176,  54,  38, 254,  59,    50, 146,  73, 211, 147, 199,  33, 182,
   36, 245, 251, 101, 134, 120, 241, 150,   114, 250, 222,  38,  78, 201, 243, 140,
  199, 196, 185,  46, 222,  24,  66, 229,   232, 251,  77, 219, 221,  32, 101,  22,
   19, 191, 242, 109,  41, 207, 125, 223,   103, 135,  55, 167, 240, 202, 224,  23,
   39, 208,   7,  63, 206, 207, 109,  91,    99,  43,  38,  87,   0, 115,  25,   0,
   93,  30,  36, 147, 239, 236,  50, 109,   120,  18, 104, 132, 241,  85,  45, 194,
    };

        out.println("\nSAFER in ECB mode: " +
            "safer -e -ecb -kx 00000000000000000102030405060708 -s -r 10\n");

        byte[] output = new byte[data.length];
        for (int i = 0; i < data.length; i++)
            output[i] = (byte)data[i];

        Cipher alg = Cipher.getInstance("SAFER", "Cryptix");
//        ((Parameterized) alg).setParameter("variant", "SK-128"); // this is the default variant
//        ((Parameterized) alg).setParameter("rounds", new Integer(10)); // this is also the default
        byte[] b = new byte[16];
        for (int i = 0; i < 8; i++) { b[i + 8] = (byte)(i + 1);  b[i] = (byte)0; }
        RawSecretKey key = new RawSecretKey("SAFER", b);
            
        alg.initEncrypt(key);
        compareIt(alg.crypt(input), output);
    }

    // The next two tests appear to be "options" only, they should probably be included here.
    //
    // This is using a text key - how to interpret extra chars?
    //    safer -e -ecb -k AaBcDeFgHiJkLmNoPqRsTuVwXyZz0123456789
    //
    private void test8D() throws Exception {
        int[] data = {
  205,  12,  46, 193, 207, 240, 215,  91,    13, 210,  52,   6,  71, 172,   3, 254,
  205,  12,  46, 193, 207, 240, 215,  91,    13, 210,  52,   6,  71, 172,   3, 254,
   96,  29,  39,  40,  55, 146, 237, 123,   163, 222, 184, 162, 239,  94,  48, 227,
  228, 222, 185, 200,   2, 157, 249, 164,    68,  39, 224, 119,  89,  33,  96,   7,
  242, 117, 142,  64,  57, 232, 204, 149,   190, 247, 201, 153,  52,  49,   3,  63,
  155, 237,  13,  46, 120, 238, 140, 219,   122,  30, 255,  85,  78,  61,  10,  48,
  168, 115,  66, 152, 102,  60, 154, 227,   107,  14, 152,  53, 133, 152,  68, 139,
   83, 200,  77,  30, 227,  67,  72, 211,   164, 177,  85, 204, 155, 172, 146,  35,
    8, 193, 190,  95, 239,  98, 140,  95,   233,  65,  18, 184, 202, 230, 205,  91,
  255, 104, 241,   3, 226, 173, 125,   6,   244, 176,  44,  67, 248, 195,  43, 191,
  124,  41, 157,  69, 145,  16, 177, 172,   169, 234, 191, 227,  52, 188, 217, 124,
  141, 132,  66, 147, 148, 208, 139,  53,    74,  34, 190, 164, 218, 124, 123, 229,
  208, 105, 140,  21,  81,  68,  50,  58,   125, 159, 156,  47, 200, 186, 151,  23,
  193, 147, 212, 182,  33, 100, 119, 187,    84, 210, 239, 222, 193, 230, 145,  53,
  240, 212, 114, 130, 109, 253, 150, 142,   230, 219, 160, 207,  73, 147, 129,  21,
   54, 163, 136, 104,  15, 147,  61, 237,    73,  70, 215,  57,  52, 209, 173, 244,
   14,   9,  56,  52,  95,  76,  40,  70,   148,  21, 166,  15,  66, 204,  46, 196,
   68, 243, 154,  48,  91, 149, 142,  20,   118,  65,   1, 124,  83,  86, 111,  82,
    };

        out.println("\nSAFER in ECB mode: " +
            "safer -e -ecb -k AaBcDeFgHiJkLmNoPqRsTuVwXyZz0123456789\n");

        byte[] output = new byte[data.length];
        for (int i = 0; i < data.length; i++)
            output[i] = (byte)data[i];

        Cipher alg = Cipher.getInstance("SAFER", "Cryptix");
        ((Parameterized) alg).setParameter("variant", "K-128");
            // default rounds is 10 for K-128
        byte[] b = new byte[16];
//how to interpret key?
//for (int i = 0; i < 8; i++) { b[i + 8] = (byte)(i + 1);  b[i] = (byte)0; }
        RawSecretKey key = new RawSecretKey("SAFER", b);
            
        alg.initEncrypt(key);
        compareIt(alg.crypt(input), output);
    }

    // This is just combining the options.
    //    safer -ecbkx 42431BA40D291F81D66083C605D3A4D6
    //
    private void test8E() throws Exception {
        int[] data = {
  249, 118, 152, 143, 221,  25, 156, 132,    38,  89, 129, 249, 212, 217,  39,  66,
  249, 118, 152, 143, 221,  25, 156, 132,    38,  89, 129, 249, 212, 217,  39,  66,
  212, 160,  72, 109, 162, 244,  13,   6,   237, 228, 143, 223, 216, 238, 188, 151,
  149, 236, 141, 238, 223, 191,  16, 133,   208, 169, 126,  87, 136,  68,  18,  19,
  235, 112, 249,  81,  19,  74, 153,  74,   133, 255, 187, 201,  93,  49,   1, 135,
  116, 231, 223, 137, 117, 184, 130, 120,   141, 191, 176, 154,  87,  91,  77,  77,
  191,  70, 198, 162,  67, 234,  95,  57,    12,  74, 134,   3, 179,  67,  40,   1,
  138,  85,  70, 107, 230, 140, 199, 224,    16,   6,  76, 150, 237, 122,  76, 178,
  137, 186,  54,  55,  35,  38, 189, 191,   104, 123,  16,  46, 237,  93, 192, 191,
  127, 251, 160,   7,  80, 103,  86, 226,    82, 145,  61,  28,  69,  49,  59, 239,
  153,  40,  25, 164, 175, 163, 103,  54,   157, 181,  57, 211, 173,  10, 254, 209,
  131,  21, 240, 174, 155, 170, 193, 252,    27,  46, 156, 207, 204,  38,  69,  60,
   84, 241, 118, 129, 107, 181,  76,  70,   166, 233, 136,  85, 193, 118, 154, 207,
   19, 129, 201, 152,  80, 235, 240, 180,   220, 151, 183, 196, 193,  98, 104, 193,
  111, 215,  58, 139, 250,  52, 147,  22,   121, 231,  59, 251, 121,   1,  29, 148,
  246, 143, 211, 211, 199, 202, 195,  13,    53, 225, 142,   6,  75,  43, 227,  74,
  151,  96, 118, 187, 166,  56,   3,  15,   164, 176,  21, 134,  77, 114, 247,  69,
  159, 143, 156, 109, 116, 149,  75, 109,   138,  83,  97,  21,  95,  62,  45,  41,
    };

        out.println("\nSAFER in ECB mode: " +
            "safer -ecbkx 42431BA40D291F81D66083C605D3A4D6\n");

        byte[] output = new byte[data.length];
        for (int i = 0; i < data.length; i++)
            output[i] = (byte)data[i];

        Cipher alg = Cipher.getInstance("SAFER", "Cryptix");
        ((Parameterized) alg).setParameter("variant", "K-128");
            // default rounds is 10 for K-128
//      String kk = "42431BA40D291F81D66083C605D3A4D6";
//      RawSecretKey key = new RawSecretKey("SAFER", Hex.fromString(kk));

        alg.initEncrypt(aKey);
        compareIt(alg.crypt(input), output);
    }


//............................... MODE TESTS ................................
//
// Mode tests are not strictly necessary.
// The next test in <code>check.ref</code> is test #11, further down.
// It is a (CBC) mode test:
//    safer -cbckx 42431BA40D291F81D66083C605D3A4D6:74536EBDC211484A
//...........................................................................

    private void test9() throws Exception {
        int[] data = {
  251, 221, 148,   3, 222,  99, 246, 105,     9, 253, 180,  32,  22,  75,  11, 213,
   56, 232, 236, 153, 153,  92, 253,  97,    39,  54,  14,  69,  23,  95, 212,  37,
  161,   9,  26, 224, 245, 215,  57, 210,    53, 131,  63, 111,  94, 178,  65, 235,
  183,  88, 244,  42,  86,   6, 154, 213,   111,  59, 179,  11,   4,   4,  39, 199,
    8, 190, 114, 105, 117, 168, 126, 106,   226, 247,  84, 100, 219, 249,  30,  18,
  250,  82, 221,  11, 124, 218, 156,  27,   108,  72,  43, 222, 132, 148,  37, 177,
  185, 197, 166,  74,  41,  88, 247, 169,    14, 163,  26, 178,  79,  15,  49, 112,
  129, 171,  54, 147, 224,  78, 181,  50,   221, 191, 166, 224, 235,  73, 160, 113,
  170, 172, 188,  19,  25, 154, 114, 144,   158,  64, 185,  30, 243, 120, 184, 193,
  128, 159, 136, 128,  49, 166,  81,  75,   166, 120,  95, 116, 225,  37, 228,  62,
  245,  30,  89, 115,  23, 205, 247, 137,   197, 194, 211,  91, 115, 241, 191,  93,
  113, 126, 232, 106, 118,  95,  62, 206,    69, 102,  42, 176, 155, 102, 166,  27,
   82,   6, 174,  34, 144, 203,  93, 255,    57, 197,   9,  64, 138, 225, 204, 151,
  214,   0, 123, 225,  85, 191, 233,  18,   176, 217, 192, 128, 162, 213,  16, 212,
  101,  97, 100, 135, 194, 186,  79, 105,   216,  70, 152,  40, 134, 217,  76, 115,
   65,  89, 202,  13, 123, 181,  94,  35,    38, 253, 153, 104, 137, 244, 208, 102,
   94, 142,  58, 219, 141, 132, 166, 136,   174, 247,  99,  31,  50,  74,  68,  79,
  106,  89,  51,  71,  70,   6,  84,  69,   139, 229,  78, 232, 188, 118,  26,  17
    };

        out.println("\nSAFER in CFB mode: " +
            "safer -cfbkx 42431BA40D291F81D66083C605D3A4D6:74536EBDC211484A\n");

        byte[] output = new byte[data.length];
        for (int i = 0; i < data.length; i++)
            output[i] = (byte)data[i];

        Cipher alg = Cipher.getInstance("SAFER/CFB", "Cryptix");
        ((Parameterized) alg).setParameter("variant", "K-128");
        ((FeedbackCipher) alg).setInitializationVector(anIV);
        alg.initEncrypt(aKey);
        compareIt(alg.crypt(input), output);

        out.println("\nDecrypting input and checking it against output:\n");
        alg.initDecrypt(aKey);
        compareIt(alg.crypt(output), input);
    }
    
    private void test10() throws Exception {
        int[] data = {
  251, 221, 148,   3, 222,  99, 246, 105,     9, 253, 180,  32,  22,  75,  11, 213,
  162,  53, 126,  83, 219,  33,  48, 193,    63, 143,  14, 194,  20,  93, 226,  67,
   66,  17, 114,  26, 204, 190, 221, 173,   181,  32, 143, 213,  75,  56, 106, 155,
   19,  68, 122, 230, 144,  69,  36, 218,   207,  25,  28,  90, 228, 113,   4, 170,
  201,  65, 206,  75, 122,  23,  55, 252,    77, 162,   4, 254, 172,  25, 129, 238,
  230,  17,  91, 175,  92, 252, 132, 126,   252, 174, 150, 132, 148, 118,  43, 206,
   36,  16, 155,  58, 130,  46, 173,  74,    88, 230, 128, 171, 154, 183,  67, 235,
   75,  70, 180, 110, 170, 220, 206, 193,   237, 221, 214,  64, 157, 118, 200,   3,
   31, 200,   1, 251,   5,  54, 135,  22,    51, 245, 132, 202, 244, 202,  40,  39,
   98, 110, 244, 198,  96,  90,  76, 174,    53, 128, 217, 224,  53,  69, 118,  51,
  230, 117,  36, 211, 166,  41, 143, 183,   195, 155,  46,  49, 203,  54,  88,  70,
  216, 185, 212, 220, 122,  45,  93,  43,   167,  67, 131,  82,   7, 104,  18,  90,
  238,  97, 204, 240,  42, 153, 157, 105,   194,  77,  87, 247,  54, 210, 142,  56,
   31, 191,  59, 182,  26, 200,  38,  91,    76,  22, 100, 209,   2, 135,  77, 156,
  231, 128,  81, 241,  44, 218,   8, 227,    50, 236, 152, 128,  25, 206,  82,  62,
  105,  57,  67, 153,  42,  57, 105, 198,   135,  68,  17,  54,  73, 216, 136,   9,
   91,  85, 103, 146, 107,  37, 224,   1,   238, 149,  31, 133, 147, 138, 233,  61,
  187, 120, 162,   6, 230,  35,  39,  75,   169, 142, 185, 209, 195, 141,  66, 198
    };

        out.println("\nSAFER in OFB mode: " +
            "safer -ofbkx 42431BA40D291F81D66083C605D3A4D6:74536EBDC211484A\n");
        byte[] output = new byte[data.length];
        for (int i = 0; i < data.length; i++)
            output[i] = (byte)data[i];

        Cipher alg = Cipher.getInstance("SAFER/OFB", "Cryptix");
        ((Parameterized) alg).setParameter("variant", "K-128");
        ((FeedbackCipher) alg).setInitializationVector(anIV);
        alg.initEncrypt(aKey);
        compareIt(alg.crypt(input), output);
        
        out.println("\nDecrypting input and checking it against output:\n");
        alg.initDecrypt(aKey);
        compareIt(alg.crypt(output), input);
    }
    
    private void test11() throws Exception {
        int[] data = {
  251, 221, 148,   3, 222,  99, 246, 105,   226,  42,  71,  84,  68,  15,  77, 253,
  159, 242, 171, 246, 112,  85,   1,  17,   201, 140,  36,  25, 241, 217, 207,  44,
   80, 203, 156, 123,   6, 117, 108,  33,   253, 118, 156,  50, 215,  83, 192, 211,
  192,  96, 132, 205, 118,  92, 206, 254,   202, 230, 171, 236,  51, 135, 233, 194,
   53,  57,  72,  89,   0, 227, 222,  39,   185,  94, 100, 159,  46, 224, 186, 134,
  232,  36,  54, 169,  81, 223, 150, 161,   105,  97, 100, 184,  37, 205, 111, 144,
   43, 156, 135, 129,  56,  57,   2, 115,    59, 120, 171,  26, 204,  97, 254,  53,
  164,  17, 135,  22,  23, 121,  49, 144,   173,  38, 181,  61, 227, 132, 145,  40,
   75,  69,  65, 164,  65,  64,  25,   9,   199,  38, 132, 165, 135,  97, 129, 144,
    4, 179, 112,  60, 182, 250, 222, 252,   248,  23,  59, 228, 191,   0,  56, 237,
  163,  20,  30, 104, 216,  45, 209, 254,   107, 188, 169,  97, 173,  41, 205, 249,
  164, 128, 120, 201, 215, 188,  35, 103,   108, 202, 174, 140, 138,  95, 241,  71,
   83, 199,  70, 162,  73, 226,  87,  84,    43,  17, 178, 203,  21, 250, 128, 159,
  137, 190, 174,  11, 215,  22, 155,  34,    34, 169,  13,  95, 208, 118, 231,  89,
   88, 179,   4,  29, 176,  17,  64, 235,    58,  88, 114,  65,  57,  96, 211, 163,
  188,  18, 100,   4,  91,  45, 233,  80,   217,  90,  45,  93, 144,  82,  60, 203,
  224,  81, 113, 231, 159, 185, 171, 128,   109, 224, 154, 141,  33,  66, 255,  44,
  112,  41, 125, 205, 154, 174, 226, 225,   173, 243, 107, 172, 214, 234,  22, 186
    };

        out.println("\nSAFER in CBC mode: " +
            "safer -cbckx 42431BA40D291F81D66083C605D3A4D6:74536EBDC211484A\n");

        byte[] output = new byte[data.length];
        for (int i = 0; i < data.length; i++)
            output[i] = (byte)data[i];

        Cipher alg = Cipher.getInstance("SAFER/CBC", "Cryptix");
        ((Parameterized) alg).setParameter("variant", "K-128");
        ((FeedbackCipher) alg).setInitializationVector(anIV);
        alg.initEncrypt(aKey);
        byte[] x = alg.crypt(input);
        compareIt(x, output);
        
        out.println("\nNow decrypting this and checking it against input:\n");
        alg.initDecrypt(aKey);
        compareIt(alg.crypt(x), input);
    }

    // These (skipped) tests from <code>check.ref</code> are Hash Functions
    // tandem Davies-Meyer scheme:
    //        safer -h -tan -kx 42431BA40D291F81D66083C605D3A4D6
    // abreast Davies-Meyer scheme:
    //        safer -h -abr -kx 42431BA40D291F81D66083C605D3A4D6

    private void compareIt (byte[] o1, byte[] o2) {
        out.print("  computed output:" + Hex.dumpString(o1));
        boolean ok = ArrayUtil.areEqual(o1, o2);
        if (!ok)
            out.print("\n certified output:" + Hex.dumpString(o2));
        passIf(ok, " *** SAFER OUTPUT");
    }
}