@Test
  public void createSimpleContainer() throws Exception {

    URL trdm090Resource =
        CreateContainerTest.class.getClassLoader().getResource(TRDM090_SUBMIT_TENDER_SAMPLE_XML);
    assertNotNull(
        trdm090Resource, "Unable to locate " + TRDM090_SUBMIT_TENDER_SAMPLE_XML + " in class path");
    File trdm090SampleFile = new File(trdm090Resource.toURI());

    URL keystoreUrl = CreateContainerTest.class.getClassLoader().getResource(VEFA_INNLEVERING_JKS);
    assertNotNull(keystoreUrl, "Unable to locate the keystore " + VEFA_INNLEVERING_JKS);
    File keyStoreFile = new File(keystoreUrl.toURI());
    assertTrue(keyStoreFile.canRead(), "Keystore " + VEFA_INNLEVERING_JKS + " not readable");

    File archiveOutputFile = new File(System.getProperty("java.io.tmpdir"), "vefa-sample.asice");

    AsicWriterFactory asicWriterFactory = AsicWriterFactory.newFactory();
    asicWriterFactory
        .newContainer(archiveOutputFile)
        .add(trdm090SampleFile)
        .setRootEntryName(trdm090SampleFile.getName())
        .sign(
            keyStoreFile, KeyStoreUtil.getKeyStorePassword(), KeyStoreUtil.getPrivateKeyPassord());

    log.debug("Created ASiC archive in " + archiveOutputFile);
  }
예제 #2
0
 public void testRandomString() throws Exception {
   SecureRandom rng = MiscTestUtil.getSecureRandom();
   String r10 = KeyStoreUtil.randomString(10, rng);
   String r1024 = KeyStoreUtil.randomString(1024, rng);
   assertEquals(10, r10.length());
   assertEquals(1024, r1024.length());
   assertCharsBetween(32, 126, r10);
   assertCharsBetween(32, 126, r1024);
   assertNotEquals(r1024, KeyStoreUtil.randomString(1024, rng));
 }
  public void testSendingSameStreamDefinitions()
      throws MalformedURLException, AuthenticationException, TransportException, AgentException,
          UndefinedEventTypeException, DifferentStreamDefinitionAlreadyDefinedException,
          InterruptedException, DataBridgeException, MalformedStreamDefinitionException,
          StreamDefinitionException {

    TestServer testServer = new TestServer();
    testServer.start(7614);
    KeyStoreUtil.setTrustStoreParams();
    Thread.sleep(2000);

    // according to the convention the authentication port will be 7611+100= 7711 and its host will
    // be the same
    DataPublisher dataPublisher = new DataPublisher("tcp://localhost:7614", "admin", "admin");
    String id1 =
        dataPublisher.defineStream(
            "{"
                + "  'name':'org.wso2.esb.MediatorStatistics',"
                + "  'version':'2.3.0',"
                + "  'nickName': 'Stock Quote Information',"
                + "  'description': 'Some Desc',"
                + "  'tags':['foo', 'bar'],"
                + "  'metaData':["
                + "          {'name':'ipAdd','type':'STRING'}"
                + "  ],"
                + "  'payloadData':["
                + "          {'name':'symbol','type':'STRING'},"
                + "          {'name':'price','type':'DOUBLE'},"
                + "          {'name':'volume','type':'INT'},"
                + "          {'name':'max','type':'DOUBLE'},"
                + "          {'name':'min','type':'Double'}"
                + "  ]"
                + "}");
    String id2 =
        dataPublisher.defineStream(
            "{"
                + "  'name':'org.wso2.esb.MediatorStatistics',"
                + "  'version':'2.3.0',"
                + "  'nickName': 'Stock Quote Information',"
                + "  'description': 'Some Desc',"
                + "  'tags':['foo', 'bar'],"
                + "  'metaData':["
                + "          {'name':'ipAdd','type':'STRING'}"
                + "  ],"
                + "  'payloadData':["
                + "          {'name':'symbol','type':'STRING'},"
                + "          {'name':'price','type':'DOUBLE'},"
                + "          {'name':'volume','type':'INT'},"
                + "          {'name':'max','type':'DOUBLE'},"
                + "          {'name':'min','type':'Double'}"
                + "  ]"
                + "}");

    Assert.assertEquals(id1, id2);
    // In this case correlation data is null
    dataPublisher.publish(
        id1, new Object[] {"127.0.0.1"}, null, new Object[] {"IBM", 96.8, 300, 120.6, 70.4});
    dataPublisher.stop();
    testServer.stop();
  }
  public void testSendingTwoDifferentStreamDefinitionsWithSameStreamId()
      throws MalformedURLException, AuthenticationException, TransportException, AgentException,
          UndefinedEventTypeException, InterruptedException, DataBridgeException,
          MalformedStreamDefinitionException, StreamDefinitionException,
          DifferentStreamDefinitionAlreadyDefinedException {

    TestServer testServer = new TestServer();
    testServer.start(7617);
    KeyStoreUtil.setTrustStoreParams();
    Thread.sleep(2000);

    // according to the convention the authentication port will be 7611+100= 7711 and its host will
    // be the same
    DataPublisher dataPublisher = new DataPublisher("tcp://localhost:7617", "admin", "admin");
    dataPublisher.defineStream(
        "{"
            + "  'name':'org.wso2.esb.MediatorStatistics3',"
            + "  'version':'2.3.0',"
            + "  'nickName': 'Stock Quote Information',"
            + "  'description': 'Some Desc',"
            + "  'tags':['foo', 'bar'],"
            + "  'metaData':["
            + "          {'name':'ipAdd','type':'STRING'}"
            + "  ],"
            + "  'payloadData':["
            + "          {'name':'symbol','type':'STRING'},"
            + "          {'name':'price','type':'DOUBLE'},"
            + "          {'name':'volume','type':'INT'},"
            + "          {'name':'max','type':'DOUBLE'},"
            + "          {'name':'min','type':'Double'}"
            + "  ]"
            + "}");
    Boolean exceptionOccurred = false;
    try {
      dataPublisher.defineStream(
          "{"
              + "  'name':'org.wso2.esb.MediatorStatistics3',"
              + "  'version':'2.3.0',"
              + "  'nickName': 'Stock Quote Information',"
              + "  'description': 'Some Desc',"
              + "  'tags':['foo', 'bar'],"
              + "  'metaData':["
              + "          {'name':'ipAdd','type':'STRING'}"
              + "  ],"
              + "  'payloadData':["
              + "          {'name':'symbol','type':'STRING'},"
              + "          {'name':'price','type':'DOUBLE'},"
              + "          {'name':'volume','type':'INT'},"
              + "          {'name':'min','type':'Double'}"
              + "  ]"
              + "}");

    } catch (DifferentStreamDefinitionAlreadyDefinedException e) {
      exceptionOccurred = true;
    }
    Assert.assertTrue(exceptionOccurred);

    dataPublisher.stop();
    testServer.stop();
  }
예제 #5
0
 public void testDefaults() throws Exception {
   Properties p = initProps();
   KeyStore ks = KeyStoreUtil.createKeyStore(p);
   List aliases = ListUtil.fromIterator(new EnumerationIterator(ks.aliases()));
   assertIsomorphic(SetUtil.set("mykey", "mycert"), SetUtil.theSet(aliases));
   assertNotNull(ks.getCertificate("mycert"));
   assertNull(ks.getCertificate("foocert"));
   assertEquals("JCEKS", ks.getType());
 }
예제 #6
0
  @Test
  public void testBoth()
      throws CertificateException, NoSuchAlgorithmException, KeyStoreException, IOException,
          InvalidKeySpecException, InvalidKeyException, NoSuchProviderException,
          SignatureException {
    File caPem = getTempFile("ca/cert.pem");
    File serverPem = getTempFile("server/cert.pem");
    File keyPem = getTempFile("server/key.pem");

    KeyStore keystore = createKeyStore();
    KeyStoreUtil.updateWithCaPem(keystore, caPem);
    KeyStoreUtil.updateWithServerPems(keystore, serverPem, keyPem, "RSA", new char[0]);

    X509Certificate caCert = (X509Certificate) keystore.getCertificate(CA_ALIAS);
    X509Certificate serverCert = (X509Certificate) keystore.getCertificate(SERVER_ALIAS);

    // Check that server cert is signed by ca
    serverCert.verify(caCert.getPublicKey());
  }
예제 #7
0
  public void testCreateSharedPLNKeyStores() throws Exception {
    List<String> hosts = ListUtil.list("host1", "host2.foo.bar", "host3");
    List<String> hosts2 = ListUtil.list("host3", "host4");
    File dir = getTempDir();
    File pub = new File(dir, "pub.ks");
    KeyStoreUtil.createSharedPLNKeyStores(
        dir, hosts, pub, "pubpass", MiscTestUtil.getSecureRandom());
    assertPubKs(pub, "pubpass", hosts);
    for (String host : hosts) {
      assertPrivateKs(
          new File(dir, host + ".jceks"), StringUtil.fromFile(new File(dir, host + ".pass")), host);
    }
    KeyStore pubks1 = loadKeyStore("jceks", new File(dir, "pub.ks"), "pubpass");

    Certificate host1cert1 = pubks1.getCertificate("host1.crt");
    Certificate host3cert1 = pubks1.getCertificate("host3.crt");

    String host1priv1 = StringUtil.fromFile(new File(dir, "host1.jceks"));
    String host3priv1 = StringUtil.fromFile(new File(dir, "host3.jceks"));

    // Now add host4 and generate a new key for host3
    KeyStoreUtil.createSharedPLNKeyStores(
        dir, hosts2, pub, "pubpass", MiscTestUtil.getSecureRandom());
    List<String> both = ListUtils.sum(hosts, hosts2);
    assertPubKs(pub, "pubpass", both);
    for (String host : both) {
      assertPrivateKs(
          new File(dir, host + ".jceks"), StringUtil.fromFile(new File(dir, host + ".pass")), host);
    }
    KeyStore pubks2 = loadKeyStore("jceks", new File(dir, "pub.ks"), "pubpass");
    // host1 should have the same cert, host3 not
    Certificate host1cert2 = pubks2.getCertificate("host1.crt");
    Certificate host3cert2 = pubks2.getCertificate("host3.crt");
    assertEquals(host1cert1, host1cert2);
    assertNotEquals(host3cert1, host3cert2);

    // host1's private key file should be the same, host3's not
    String host1priv2 = StringUtil.fromFile(new File(dir, "host1.jceks"));
    String host3priv2 = StringUtil.fromFile(new File(dir, "host3.jceks"));
    assertEquals(host1priv1, host1priv2);
    assertNotEquals(host3priv1, host3priv2);
  }
예제 #8
0
  public void start(int receiverPort) throws DataBridgeException {
    KeyStoreUtil.setKeyStoreParams();
    DataBridge databridge =
        new DataBridge(
            new AuthenticationHandler() {
              @Override
              public boolean authenticate(String userName, String password) {
                return true; // allays authenticate to true
              }

              @Override
              public String getTenantDomain(String userName) {
                return "admin";
              }
            },
            new InMemoryStreamDefinitionStore());
    thriftDataReceiver = new ThriftDataReceiver(receiverPort, databridge);

    databridge.subscribe(
        new AgentCallback() {
          int totalSize = 0;

          public void definedStream(StreamDefinition streamDefinition, Credentials credentials) {
            log.info("Added StreamDefinition " + streamDefinition);
          }

          @Override
          public void removeStream(StreamDefinition streamDefinition, Credentials credentials) {
            log.info("Removed StreamDefinition " + streamDefinition);
          }

          @Override
          public void receive(List<Event> eventList, Credentials credentials) {
            log.info(
                "eventListSize="
                    + eventList.size()
                    + " eventList "
                    + eventList
                    + " for username "
                    + credentials.getUsername());
            eventReceived = true;
            stop();
          }
        });

    try {
      String address = HostAddressFinder.findAddress("localhost");
      log.info("Test Server starting on " + address);
      thriftDataReceiver.start(address);
      log.info("Test Server Started");
    } catch (SocketException e) {
      log.error("Test Server not started !", e);
    }
  }
예제 #9
0
 @Test
 public void testSelfSignedCertificate() throws Exception {
   KeyStore keystore = createKeyStore();
   KeyStoreUtil.updateWithSelfSignedServerCertificate(keystore);
   X509Certificate cert = (X509Certificate) keystore.getCertificate("jolokia-agent");
   assertNotNull(cert);
   assertEquals(
       cert.getSubjectDN().getName(),
       "CN=Jolokia Agent "
           + Version.getAgentVersion()
           + ", OU=JVM, O=jolokia.org, L=Pegnitz, ST=Franconia, C=DE");
   assertEquals(cert.getSubjectDN(), cert.getIssuerDN());
 }
예제 #10
0
  @Test
  public void testInvalid()
      throws IOException, CertificateException, NoSuchAlgorithmException, KeyStoreException,
          InvalidKeySpecException {

    for (String file :
        new String[] {"invalid/base64.pem", "invalid/begin.pem", "invalid/end.pem"}) {
      File invalidPem = getTempFile(file);

      KeyStore keystore = createKeyStore();
      try {
        KeyStoreUtil.updateWithCaPem(keystore, invalidPem);
        fail();
      } catch (Exception exp) {
      }
      try {
        KeyStoreUtil.updateWithServerPems(
            keystore, getTempFile("server/cert.pem"), invalidPem, "RSA", new char[0]);
        fail();
      } catch (Exception exp) {
      }
    }
  }
예제 #11
0
 public void testCreateIllProv() throws Exception {
   File dir = getTempDir();
   File file = new File(dir, "test.ks");
   Properties p = initProps();
   p.put(KeyStoreUtil.PROP_KEYSTORE_FILE, file.toString());
   p.put(KeyStoreUtil.PROP_KEYSTORE_TYPE, "JKS");
   p.put(KeyStoreUtil.PROP_KEYSTORE_PROVIDER, "not_a_provider");
   assertFalse(file.exists());
   try {
     KeyStoreUtil.createKeyStore(p);
     fail("Illegal keystore type should throw");
   } catch (NoSuchProviderException e) {
   }
   assertFalse(file.exists());
 }
예제 #12
0
  public void testStore() throws Exception {
    File dir = getTempDir();
    File file = new File(dir, "test.ks");
    Properties p = initProps();
    p.put(KeyStoreUtil.PROP_KEYSTORE_FILE, file.toString());
    assertFalse(file.exists());
    KeyStore ks = KeyStoreUtil.createKeyStore(p);
    assertTrue(file.exists());

    KeyStore ks2 = loadKeyStore(ks.getType(), file, PASSWD);
    List aliases = ListUtil.fromIterator(new EnumerationIterator(ks2.aliases()));
    assertIsomorphic(SetUtil.set("mykey", "mycert"), SetUtil.theSet(aliases));
    assertNotNull(ks2.getCertificate("mycert"));
    assertNull(ks2.getCertificate("foocert"));
    assertEquals("JCEKS", ks2.getType());
  }
예제 #13
0
  @Test
  public void testTrustStore()
      throws KeyStoreException, CertificateException, NoSuchAlgorithmException, IOException {
    File caPem = getTempFile("ca/cert.pem");
    KeyStore keystore = createKeyStore();

    KeyStoreUtil.updateWithCaPem(keystore, caPem);

    Enumeration<String> aliases = keystore.aliases();
    String alias = aliases.nextElement();
    assertFalse(aliases.hasMoreElements());
    assertTrue(alias.contains("ca.test.jolokia.org"));
    X509Certificate cert = (X509Certificate) keystore.getCertificate(alias);
    cert.checkValidity();
    assertTrue(cert.getSubjectDN().getName().contains(CA_CERT_SUBJECT_DN_CN));
    RSAPublicKey key = (RSAPublicKey) cert.getPublicKey();
    assertEquals(key.getAlgorithm(), "RSA");
  }
  public static void main(String[] args)
      throws KeyStoreException, NoSuchAlgorithmException, CertificateException, IOException,
          NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException,
          InvalidKeyException, UnrecoverableKeyException, NoSuchProviderException,
          SignatureException {

    /** At the client side */
    KeyStoreUtil keyStoreUtil = new KeyStoreUtil();
    // Generate Symmetric key
    byte[] symmetrickey = keyStoreUtil.generateSessionKey();
    // Encrypt data by symmetric key
    String data = "ABC";
    System.out.println("Data : " + data);
    String encryptedData = keyStoreUtil.encryptWithAESKey(data, symmetrickey);
    System.out.println("encryptedData : " + encryptedData);

    // Encrypt symmetric key using trustore
    String encryptedKey = keyStoreUtil.encryptKey(symmetrickey, "mykey");
    System.out.println("encryptedKey : " + encryptedKey);

    // Generate the signature of symmetric key
    byte[] signedEncryptedKey = keyStoreUtil.signData(Base64.decodeBase64(encryptedKey));
    String signatureOfKey = Base64.encodeBase64String(signedEncryptedKey);
    System.out.println("Signed Ecrypted Key : " + signatureOfKey);

    /** At the receiver */

    // Verify signature
    keyStoreUtil.verifySignature(Base64.decodeBase64(encryptedKey), signedEncryptedKey);

    // Decrypt symmteric key using keystore
    String decryptedKey = keyStoreUtil.decryptKey(encryptedKey, "mykey");
    System.out.println("decryptedKey : " + decryptedKey);

    // Decrypt data using decrypted symetric key

    System.out.println(
        "Decrypted Data : " + keyStoreUtil.decryptWithAESKey(encryptedData, decryptedKey));
  }
예제 #15
0
  @Test
  public void testKeyStore()
      throws IOException, CertificateException, NoSuchAlgorithmException, KeyStoreException,
          InvalidKeySpecException, UnrecoverableKeyException {
    File serverPem = getTempFile("server/cert.pem");
    File keyPem = getTempFile("server/key.pem");
    KeyStore keystore = createKeyStore();

    KeyStoreUtil.updateWithServerPems(keystore, serverPem, keyPem, "RSA", new char[0]);

    Enumeration<String> aliases = keystore.aliases();
    String alias = aliases.nextElement();
    assertFalse(aliases.hasMoreElements());

    assertTrue(alias.contains("server"));

    X509Certificate cert = (X509Certificate) keystore.getCertificate(alias);
    cert.checkValidity();
    assertEquals(cert.getSubjectDN().getName(), SERVER_CERT_SUBJECT_DN);
    RSAPrivateCrtKey key = (RSAPrivateCrtKey) keystore.getKey(alias, new char[0]);
    assertEquals("RSA", key.getAlgorithm());
    RSAPublicKey pubKey = (RSAPublicKey) cert.getPublicKey();
    assertEquals("RSA", pubKey.getAlgorithm());
  }
예제 #16
0
  public static void main(String[] args)
      throws AgentException, MalformedStreamDefinitionException, StreamDefinitionException,
          DifferentStreamDefinitionAlreadyDefinedException, MalformedURLException,
          AuthenticationException, NoStreamDefinitionExistException, TransportException,
          SocketException, org.wso2.carbon.databridge.commons.exception.AuthenticationException {
    System.out.println("Starting Activity Monitoring Sample");

    KeyStoreUtil.setTrustStoreParams();

    String host = args[0];
    String port = args[1];
    String username = args[2];
    String password = args[3];
    int events = Integer.parseInt(args[4]);

    // create data publisher

    DataPublisher dataPublisher =
        new DataPublisher("tcp://" + host + ":" + port, username, password);
    String streamId = null;

    try {
      streamId = dataPublisher.findStream(ACTIVITY_MONITORING_STREAM, VERSION);
      System.out.println("Stream already defined");

    } catch (NoStreamDefinitionExistException e) {
      streamId =
          dataPublisher.defineStream(
              "{"
                  + "  'name':'"
                  + ACTIVITY_MONITORING_STREAM
                  + "',"
                  + "  'version':'"
                  + VERSION
                  + "',"
                  + "  'nickName': 'Activity_Monitoring',"
                  + "  'description': 'A sample for Activity Monitoring',"
                  + "  'metaData':["
                  + "          {'name':'character_set_encoding','type':'STRING'},"
                  + "          {'name':'host','type':'STRING'},"
                  + "          {'name':'http_method','type':'STRING'},"
                  + "          {'name':'message_type','type':'STRING'},"
                  + "          {'name':'remote_address','type':'STRING'},"
                  + "          {'name':'remote_host','type':'STRING'},"
                  + "          {'name':'service_prefix','type':'STRING'},"
                  + "          {'name':'tenant_id','type':'INT'},"
                  + "          {'name':'transport_in_url','type':'STRING'}"
                  + "  ],"
                  + "  'correlationData':["
                  + "          {'name':'bam_activity_id','type':'STRING'}"
                  + "  ],"
                  + "  'payloadData':["
                  + "          {'name':'soap_body','type':'STRING'},"
                  + "          {'name':'soap_header','type':'STRING'},"
                  + "          {'name':'message_direction','type':'STRING'},"
                  + "          {'name':'message_id','type':'STRING'},"
                  + "          {'name':'operation_name','type':'STRING'},"
                  + "          {'name':'service_name','type':'STRING'},"
                  + "          {'name':'timestamp','type':'LONG'}"
                  + "  ]"
                  + "}");
      //            //Define event stream
    }

    // Publish event for a valid stream
    if (!streamId.isEmpty()) {
      System.out.println("Stream ID: " + streamId);

      for (int i = 0; i < events; i++) {
        publishEvents(dataPublisher, streamId, i);
        System.out.println("Events published : " + (i + 1));
      }
      try {
        Thread.sleep(2000);
      } catch (InterruptedException e) {
      }

      dataPublisher.stop();
    }
  }