Пример #1
0
  private static String dumpBinaryDataAsString(String indent, byte[] bytes) {
    String nl = System.getProperty("line.separator");
    StringBuffer buf = new StringBuffer();

    indent += TAB;

    buf.append(nl);
    for (int i = 0; i < bytes.length; i += SAMPLE_SIZE) {
      if (bytes.length - i > SAMPLE_SIZE) {
        buf.append(indent);
        buf.append(new String(Hex.encode(bytes, i, SAMPLE_SIZE)));
        buf.append(TAB);
        buf.append(calculateAscString(bytes, i, SAMPLE_SIZE));
        buf.append(nl);
      } else {
        buf.append(indent);
        buf.append(new String(Hex.encode(bytes, i, bytes.length - i)));
        for (int j = bytes.length - i; j != SAMPLE_SIZE; j++) {
          buf.append("  ");
        }
        buf.append(TAB);
        buf.append(calculateAscString(bytes, i, bytes.length - i));
        buf.append(nl);
      }
    }

    return buf.toString();
  }
Пример #2
0
  private static String outputApplicationSpecific(
      String type, String indent, boolean verbose, DERObject obj, String nl) {
    DERApplicationSpecific app = (DERApplicationSpecific) obj;
    StringBuffer buf = new StringBuffer();

    if (app.isConstructed()) {
      try {
        ASN1Sequence s = ASN1Sequence.getInstance(app.getObject(DERTags.SEQUENCE));
        buf.append(indent + type + " ApplicationSpecific[" + app.getApplicationTag() + "]" + nl);
        for (Enumeration e = s.getObjects(); e.hasMoreElements(); ) {
          _dumpAsString(indent + TAB, verbose, (DERObject) e.nextElement(), buf);
        }
      } catch (IOException e) {
        buf.append(e);
      }
      return buf.toString();
    }

    return indent
        + type
        + " ApplicationSpecific["
        + app.getApplicationTag()
        + "] ("
        + new String(Hex.encode(app.getContents()))
        + ")"
        + nl;
  }
Пример #3
0
/** check that cipher input/output streams are working correctly */
public class CipherStreamTest extends SimpleTest {

  private static byte[] RK = Hex.decode("0123456789ABCDEF");
  private static byte[] RIN = Hex.decode("4e6f772069732074");
  private static byte[] ROUT = Hex.decode("3afbb5c77938280d");

  private static byte[] SIN =
      Hex.decode(
          "00000000000000000000000000000000"
              + "00000000000000000000000000000000"
              + "00000000000000000000000000000000"
              + "00000000000000000000000000000000");
  private static final byte[] SK = Hex.decode("80000000000000000000000000000000");
  private static final byte[] SIV = Hex.decode("0000000000000000");
  private static final byte[] SOUT =
      Hex.decode(
          "4DFA5E481DA23EA09A31022050859936"
              + "DA52FCEE218005164F267CB65F5CFD7F"
              + "2B4F97E0FF16924A52DF269515110A07"
              + "F9E460BC65EF95DA58F740B7D1DBB0AA");

  private static final byte[] HCIN = new byte[64];
  private static final byte[] HCIV = new byte[32];

  private static final byte[] HCK256A = new byte[32];
  private static final byte[] HC256A =
      Hex.decode(
          "5B078985D8F6F30D42C5C02FA6B67951"
              + "53F06534801F89F24E74248B720B4818"
              + "CD9227ECEBCF4DBF8DBF6977E4AE14FA"
              + "E8504C7BC8A9F3EA6C0106F5327E6981");

  private static final byte[] HCK128A = new byte[16];
  private static final byte[] HC128A =
      Hex.decode(
          "82001573A003FD3B7FD72FFB0EAF63AA"
              + "C62F12DEB629DCA72785A66268EC758B"
              + "1EDB36900560898178E0AD009ABF1F49"
              + "1330DC1C246E3D6CB264F6900271D59C");

  private static final byte[] GRAIN_V1 = Hex.decode("0123456789abcdef1234");
  private static final byte[] GRAIN_V1_IV = Hex.decode("0123456789abcdef");
  private static final byte[] GRAIN_V1_IN = new byte[10];
  private static final byte[] GRAIN_V1_OUT = Hex.decode("7f362bd3f7abae203664");

  private static final byte[] GRAIN_128 = Hex.decode("0123456789abcdef123456789abcdef0");
  private static final byte[] GRAIN_128_IV = Hex.decode("0123456789abcdef12345678");
  private static final byte[] GRAIN_128_IN = new byte[16];
  private static final byte[] GRAIN_128_OUT = Hex.decode("afb5babfa8de896b4b9c6acaf7c4fbfd");

  public CipherStreamTest() {}

  private void runTest(String name) throws Exception {
    String lCode = "ABCDEFGHIJKLMNOPQRSTUVWXY0123456789";
    KeyGenerator kGen;

    if (name.indexOf('/') < 0) {
      kGen = KeyGenerator.getInstance(name, "BC");
    } else {
      kGen = KeyGenerator.getInstance(name.substring(0, name.indexOf('/')), "BC");
    }

    Cipher in = Cipher.getInstance(name, "BC");
    Cipher out = Cipher.getInstance(name, "BC");
    Key key = kGen.generateKey();
    ByteArrayInputStream bIn = new ByteArrayInputStream(lCode.getBytes());
    ByteArrayOutputStream bOut = new ByteArrayOutputStream();

    in.init(Cipher.ENCRYPT_MODE, key);
    if (in.getIV() != null) {
      out.init(Cipher.DECRYPT_MODE, key, new IvParameterSpec(in.getIV()));
    } else {
      out.init(Cipher.DECRYPT_MODE, key);
    }

    CipherInputStream cIn = new CipherInputStream(bIn, in);
    CipherOutputStream cOut = new CipherOutputStream(bOut, out);

    int c;

    while ((c = cIn.read()) >= 0) {
      cOut.write(c);
    }

    cIn.close();

    cOut.flush();
    cOut.close();

    String res = new String(bOut.toByteArray());

    if (!res.equals(lCode)) {
      fail("Failed - decrypted data doesn't match.");
    }
  }

  private void testAlgorithm(
      String name, byte[] keyBytes, byte[] iv, byte[] plainText, byte[] cipherText)
      throws Exception {
    SecretKey key = new SecretKeySpec(keyBytes, name);
    Cipher in = Cipher.getInstance(name, "BC");
    Cipher out = Cipher.getInstance(name, "BC");

    if (iv != null) {
      in.init(Cipher.ENCRYPT_MODE, key, new IvParameterSpec(iv));
      out.init(Cipher.DECRYPT_MODE, key, new IvParameterSpec(iv));
    } else {
      in.init(Cipher.ENCRYPT_MODE, key);
      out.init(Cipher.DECRYPT_MODE, key);
    }

    byte[] enc = in.doFinal(plainText);
    if (!areEqual(enc, cipherText)) {
      fail(name + ": cipher text doesn't match");
    }

    byte[] dec = out.doFinal(enc);

    if (!areEqual(dec, plainText)) {
      fail(name + ": plain text doesn't match");
    }
  }

  private void testException(String name) {
    try {
      byte[] key128 = {
        (byte) 128, (byte) 131, (byte) 133, (byte) 134,
        (byte) 137, (byte) 138, (byte) 140, (byte) 143,
        (byte) 128, (byte) 131, (byte) 133, (byte) 134,
        (byte) 137, (byte) 138, (byte) 140, (byte) 143
      };

      byte[] key256 = {
        (byte) 128, (byte) 131, (byte) 133, (byte) 134,
        (byte) 137, (byte) 138, (byte) 140, (byte) 143,
        (byte) 128, (byte) 131, (byte) 133, (byte) 134,
        (byte) 137, (byte) 138, (byte) 140, (byte) 143,
        (byte) 128, (byte) 131, (byte) 133, (byte) 134,
        (byte) 137, (byte) 138, (byte) 140, (byte) 143,
        (byte) 128, (byte) 131, (byte) 133, (byte) 134,
        (byte) 137, (byte) 138, (byte) 140, (byte) 143
      };

      byte[] keyBytes;
      if (name.equals("HC256")) {
        keyBytes = key256;
      } else {
        keyBytes = key128;
      }

      SecretKeySpec cipherKey = new SecretKeySpec(keyBytes, name);
      Cipher ecipher = Cipher.getInstance(name, "BC");
      ecipher.init(Cipher.ENCRYPT_MODE, cipherKey);

      byte[] cipherText = new byte[0];
      try {
        // According specification Method engineUpdate(byte[] input,
        // int inputOffset, int inputLen, byte[] output, int
        // outputOffset)
        // throws ShortBufferException - if the given output buffer is
        // too
        // small to hold the result
        ecipher.update(new byte[20], 0, 20, cipherText);

        fail("failed exception test - no ShortBufferException thrown");
      } catch (ShortBufferException e) {
        // ignore
      }

      try {
        Cipher c = Cipher.getInstance(name, "BC");

        Key k =
            new PublicKey() {

              public String getAlgorithm() {
                return "STUB";
              }

              public String getFormat() {
                return null;
              }

              public byte[] getEncoded() {
                return null;
              }
            };

        c.init(Cipher.ENCRYPT_MODE, k);

        fail("failed exception test - no InvalidKeyException thrown for public key");
      } catch (InvalidKeyException e) {
        // okay
      }

      try {
        Cipher c = Cipher.getInstance(name, "BC");

        Key k =
            new PrivateKey() {

              public String getAlgorithm() {
                return "STUB";
              }

              public String getFormat() {
                return null;
              }

              public byte[] getEncoded() {
                return null;
              }
            };

        c.init(Cipher.DECRYPT_MODE, k);

        fail("failed exception test - no InvalidKeyException thrown for private key");
      } catch (InvalidKeyException e) {
        // okay
      }
    } catch (Exception e) {
      fail("unexpected exception.", e);
    }
  }

  public void performTest() throws Exception {
    runTest("RC4");
    testException("RC4");
    testAlgorithm("RC4", RK, null, RIN, ROUT);
    runTest("Salsa20");
    testException("Salsa20");
    testAlgorithm("Salsa20", SK, SIV, SIN, SOUT);
    runTest("HC128");
    testException("HC128");
    testAlgorithm("HC128", HCK128A, HCIV, HCIN, HC128A);
    runTest("HC256");
    testException("HC256");
    testAlgorithm("HC256", HCK256A, HCIV, HCIN, HC256A);
    runTest("VMPC");
    testException("VMPC");
    // testAlgorithm("VMPC", a, iv, in, a);
    runTest("VMPC-KSA3");
    testException("VMPC-KSA3");
    // testAlgorithm("VMPC-KSA3", a, iv, in, a);
    testAlgorithm("Grainv1", GRAIN_V1, GRAIN_V1_IV, GRAIN_V1_IN, GRAIN_V1_OUT);
    testAlgorithm("Grain128", GRAIN_128, GRAIN_128_IV, GRAIN_128_IN, GRAIN_128_OUT);
    runTest("DES/ECB/PKCS7Padding");
    runTest("DES/CFB8/NoPadding");
  }

  public String getName() {
    return "CipherStreamTest";
  }

  public static void main(String[] args) {
    Security.addProvider(new BouncyCastleProvider());

    runTest(new CipherStreamTest());
  }
}
Пример #4
0
  /**
   * dump a DER object as a formatted string with indentation
   *
   * @param obj the DERObject to be dumped out.
   */
  static void _dumpAsString(String indent, boolean verbose, DERObject obj, StringBuffer buf) {
    String nl = System.getProperty("line.separator");
    if (obj instanceof ASN1Sequence) {
      Enumeration e = ((ASN1Sequence) obj).getObjects();
      String tab = indent + TAB;

      buf.append(indent);
      if (obj instanceof BERSequence) {
        buf.append("BER Sequence");
      } else if (obj instanceof DERSequence) {
        buf.append("DER Sequence");
      } else {
        buf.append("Sequence");
      }

      buf.append(nl);

      while (e.hasMoreElements()) {
        Object o = e.nextElement();

        if (o == null || o.equals(new DERNull())) {
          buf.append(tab);
          buf.append("NULL");
          buf.append(nl);
        } else if (o instanceof DERObject) {
          _dumpAsString(tab, verbose, (DERObject) o, buf);
        } else {
          _dumpAsString(tab, verbose, ((DEREncodable) o).getDERObject(), buf);
        }
      }
    } else if (obj instanceof DERTaggedObject) {
      String tab = indent + TAB;

      buf.append(indent);
      if (obj instanceof BERTaggedObject) {
        buf.append("BER Tagged [");
      } else {
        buf.append("Tagged [");
      }

      DERTaggedObject o = (DERTaggedObject) obj;

      buf.append(Integer.toString(o.getTagNo()));
      buf.append(']');

      if (!o.isExplicit()) {
        buf.append(" IMPLICIT ");
      }

      buf.append(nl);

      if (o.isEmpty()) {
        buf.append(tab);
        buf.append("EMPTY");
        buf.append(nl);
      } else {
        _dumpAsString(tab, verbose, o.getObject(), buf);
      }
    } else if (obj instanceof BERSet) {
      Enumeration e = ((ASN1Set) obj).getObjects();
      String tab = indent + TAB;

      buf.append(indent);
      buf.append("BER Set");
      buf.append(nl);

      while (e.hasMoreElements()) {
        Object o = e.nextElement();

        if (o == null) {
          buf.append(tab);
          buf.append("NULL");
          buf.append(nl);
        } else if (o instanceof DERObject) {
          _dumpAsString(tab, verbose, (DERObject) o, buf);
        } else {
          _dumpAsString(tab, verbose, ((DEREncodable) o).getDERObject(), buf);
        }
      }
    } else if (obj instanceof DERSet) {
      Enumeration e = ((ASN1Set) obj).getObjects();
      String tab = indent + TAB;

      buf.append(indent);
      buf.append("DER Set");
      buf.append(nl);

      while (e.hasMoreElements()) {
        Object o = e.nextElement();

        if (o == null) {
          buf.append(tab);
          buf.append("NULL");
          buf.append(nl);
        } else if (o instanceof DERObject) {
          _dumpAsString(tab, verbose, (DERObject) o, buf);
        } else {
          _dumpAsString(tab, verbose, ((DEREncodable) o).getDERObject(), buf);
        }
      }
    } else if (obj instanceof DERObjectIdentifier) {
      buf.append(indent + "ObjectIdentifier(" + ((DERObjectIdentifier) obj).getId() + ")" + nl);
    } else if (obj instanceof DERBoolean) {
      buf.append(indent + "Boolean(" + ((DERBoolean) obj).isTrue() + ")" + nl);
    } else if (obj instanceof DERInteger) {
      buf.append(indent + "Integer(" + ((DERInteger) obj).getValue() + ")" + nl);
    } else if (obj instanceof BERConstructedOctetString) {
      ASN1OctetString oct = (ASN1OctetString) obj;
      buf.append(indent + "BER Constructed Octet String" + "[" + oct.getOctets().length + "] ");
      if (verbose) {
        buf.append(dumpBinaryDataAsString(indent, oct.getOctets()));
      } else {
        buf.append(nl);
      }
    } else if (obj instanceof DEROctetString) {
      ASN1OctetString oct = (ASN1OctetString) obj;
      buf.append(indent + "DER Octet String" + "[" + oct.getOctets().length + "] ");
      if (verbose) {
        buf.append(dumpBinaryDataAsString(indent, oct.getOctets()));
      } else {
        buf.append(nl);
      }
    } else if (obj instanceof DERBitString) {
      DERBitString bt = (DERBitString) obj;
      buf.append(
          indent + "DER Bit String" + "[" + bt.getBytes().length + ", " + bt.getPadBits() + "] ");
      if (verbose) {
        buf.append(dumpBinaryDataAsString(indent, bt.getBytes()));
      } else {
        buf.append(nl);
      }
    } else if (obj instanceof DERIA5String) {
      buf.append(indent + "IA5String(" + ((DERIA5String) obj).getString() + ") " + nl);
    } else if (obj instanceof DERUTF8String) {
      buf.append(indent + "UTF8String(" + ((DERUTF8String) obj).getString() + ") " + nl);
    } else if (obj instanceof DERPrintableString) {
      buf.append(indent + "PrintableString(" + ((DERPrintableString) obj).getString() + ") " + nl);
    } else if (obj instanceof DERVisibleString) {
      buf.append(indent + "VisibleString(" + ((DERVisibleString) obj).getString() + ") " + nl);
    } else if (obj instanceof DERBMPString) {
      buf.append(indent + "BMPString(" + ((DERBMPString) obj).getString() + ") " + nl);
    } else if (obj instanceof DERT61String) {
      buf.append(indent + "T61String(" + ((DERT61String) obj).getString() + ") " + nl);
    } else if (obj instanceof DERUTCTime) {
      buf.append(indent + "UTCTime(" + ((DERUTCTime) obj).getTime() + ") " + nl);
    } else if (obj instanceof DERGeneralizedTime) {
      buf.append(indent + "GeneralizedTime(" + ((DERGeneralizedTime) obj).getTime() + ") " + nl);
    } else if (obj instanceof DERUnknownTag) {
      buf.append(
          indent
              + "Unknown "
              + Integer.toString(((DERUnknownTag) obj).getTag(), 16)
              + " "
              + new String(Hex.encode(((DERUnknownTag) obj).getData()))
              + nl);
    } else if (obj instanceof BERApplicationSpecific) {
      buf.append(outputApplicationSpecific("BER", indent, verbose, obj, nl));
    } else if (obj instanceof DERApplicationSpecific) {
      buf.append(outputApplicationSpecific("DER", indent, verbose, obj, nl));
    } else if (obj instanceof DEREnumerated) {
      DEREnumerated en = (DEREnumerated) obj;
      buf.append(indent + "DER Enumerated(" + en.getValue() + ")" + nl);
    } else if (obj instanceof DERExternal) {
      DERExternal ext = (DERExternal) obj;
      buf.append(indent + "External " + nl);
      String tab = indent + TAB;
      if (ext.getDirectReference() != null) {
        buf.append(tab + "Direct Reference: " + ext.getDirectReference().getId() + nl);
      }
      if (ext.getIndirectReference() != null) {
        buf.append(tab + "Indirect Reference: " + ext.getIndirectReference().toString() + nl);
      }
      if (ext.getDataValueDescriptor() != null) {
        _dumpAsString(tab, verbose, ext.getDataValueDescriptor(), buf);
      }
      buf.append(tab + "Encoding: " + ext.getEncoding() + nl);
      _dumpAsString(tab, verbose, ext.getExternalContent(), buf);
    } else {
      buf.append(indent + obj.toString() + nl);
    }
  }