Ejemplo n.º 1
0
  public static void main(String[] args) throws Exception {
    java.security.Security.addProvider(new cryptix.jce.provider.CryptixCrypto());
    java.security.Security.addProvider(new cryptix.openpgp.provider.CryptixOpenPGP());

    readKeyrings();
    decodeKeyRings();

    writeMsg();
  }
Ejemplo n.º 2
0
  public void initialise() throws InitialisationException {
    try {
      java.security.Security.addProvider(new cryptix.jce.provider.CryptixCrypto());
      java.security.Security.addProvider(new cryptix.openpgp.provider.CryptixOpenPGP());

      factory = new PGPSecurityContextFactory();
    } catch (Exception e) {
      throw new InitialisationException(CoreMessages.failedToCreate("PGPProvider"), e, this);
    }
  }
Ejemplo n.º 3
0
 static {
   try {
     Security.addProvider((Provider) Class.forName(DEFAULT_JCE).newInstance());
   } catch (Exception e) {
     log.info(e);
     try {
       Security.addProvider((Provider) Class.forName(IBM_JCE).newInstance());
     } catch (Exception ex) {
       log.info(ex);
     }
   }
 }
Ejemplo n.º 4
0
  public void initialise() throws InitialisationException {
    try {
      java.security.Security.addProvider(new cryptix.jce.provider.CryptixCrypto());
      java.security.Security.addProvider(new cryptix.openpgp.provider.CryptixOpenPGP());

      principalsKeyBundleMap = new HashMap();

      readPublicKeyRing();
      readPrivateKeyBundle();
    } catch (Exception e) {
      logger.error("errore in inizializzazione:" + e.getMessage(), e);
      throw new InitialisationException(CoreMessages.failedToCreate("PGPKeyRingImpl"), e, this);
    }
  }
Ejemplo n.º 5
0
  /**
   * Loads our X509 PEPPOL certificate togheter with our private key and initializes a
   * MdnMimeMessageFactory instance.
   */
  @Override
  public void init(ServletConfig servletConfig) {

    KeystoreManager keystoreManager = KeystoreManager.getInstance();
    X509Certificate ourCertificate = keystoreManager.getOurCertificate();
    PrivateKey ourPrivateKey = keystoreManager.getOurPrivateKey();
    mdnMimeMessageFactory = new MdnMimeMessageFactory(ourCertificate, ourPrivateKey);

    // Gives us access to BouncyCastle
    Security.addProvider(new BouncyCastleProvider());

    // Gives us access to the Message repository holding the received messages
    messageRepository = MessageRepositoryFactory.getInstance();

    // Creates the receiver for inbound messages
    inboundMessageReceiver = new InboundMessageReceiver();

    // Locates an instance of the repository used for storage of raw statistics
    rawStatisticsRepository =
        RawStatisticsRepositoryFactoryProvider.getInstance().getInstanceForRawStatistics();

    // fetch the CN of our certificate
    ourAccessPointIdentifier =
        AccessPointIdentifier.valueOf(KeystoreManager.getInstance().getOurCommonName());
  }
Ejemplo n.º 6
0
  public boolean generateKeys() {

    PublicKey keyPub;
    PrivateKey keyPri;
    SecureRandom rand;

    Security.addProvider(new ABAProvider());

    rand = new SecureRandom();

    rand.setSeed(System.currentTimeMillis());

    try {
      KeyPairGenerator fact;
      KeyPair keyPair;

      fact = KeyPairGenerator.getInstance("RSA", "ABA");

      fact.initialize(1024, rand);

      keyPair = fact.generateKeyPair();

      keyPub = keyPair.getPublic();

      keyPri = keyPair.getPrivate();

      pubKey = bytesToHexStr(keyPub.getEncoded());

      priKey = bytesToHexStr(keyPri.getEncoded());
    } catch (Exception e) {
      return false;
    }
    return true;
  }
Ejemplo n.º 7
0
  public void send(String mailto, String subject, String textMessage, String contentType)
      throws FileNotFoundException, MessagingException {
    Security.addProvider(new com.sun.net.ssl.internal.ssl.Provider());
    Properties props = new Properties();
    props.put("mail.smtp.user", smtpUsername);
    props.put("mail.smtp.host", smtpHost);
    props.put("mail.smtp.port", smtpPort);
    props.put("mail.smtp.starttls.enable", "true");
    props.put("mail.smtps.auth", "true");
    props.put("mail.smtp.debug", "true");
    props.put("mail.smtp.socketFactory.port", smtpPort);
    props.put("mail.smtp.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
    props.put("mail.smtp.socketFactory.fallback", "false");
    props.put("mail.smtp.ssl", "true");

    Authenticator auth = new SMTPAuthenticator();
    Session smtpSession = Session.getInstance(props, auth);
    smtpSession.setDebug(true);

    Message message = new MimeMessage(smtpSession);
    InternetAddress[] address = {new InternetAddress(mailto)};
    message.setRecipients(Message.RecipientType.TO, address);
    message.setSubject(subject);
    message.setSentDate(new Date());
    message.setContent(textMessage, contentType);

    Transport tr = smtpSession.getTransport("smtp");
    tr.connect(smtpHost, smtpUsername, smtpPassword);
    tr.sendMessage(message, message.getAllRecipients());
    tr.close();
  }
Ejemplo n.º 8
0
  /**
   * Decrypt a partialy file encrypted. Generate a signle file, totally decrypted.
   *
   * @param password String password used to crypt the file
   * @param output String path to the output file
   * @throws FileNotFoundException
   * @throws IOException
   * @throws GeneralSecurityException
   */
  public void decrypt(String password, String output)
      throws FileNotFoundException, IOException, GeneralSecurityException {
    this.prefix = FileUtility.unaggregate(this.file, this.marker);

    // use the API
    Security.addProvider(new BouncyCastleProvider());

    // create a new crypter
    FileCrypter crypter = new FileCrypter();

    // get key to be used from the password
    SecretKeySpec key = Password.getKey(password);

    // decrypt the second file (which is supposed to be crypted)
    crypter.decryptFile(
        key,
        this.file + FileUtility.extension_crypt,
        FileUtility.tmp + this.prefix + "-2" + FileUtility.extension_tmp);

    // recompose the file with an encrypted part in one single file
    FileUtility.recompose(this.prefix, output);

    // clean temporary files
    FileUtility.clean();
  }
  public SunSSLTransportFactory(Properties properties) throws GeneralSecurityException {
    X509TrustManager trustManager;
    HostnameVerifier hostnameVerifier;
    SSLContext sslContext;

    Security.addProvider(new com.sun.net.ssl.internal.ssl.Provider());

    url = (URL) properties.get(XmlRpcTransportFactory.TRANSPORT_URL);
    auth = properties.getProperty(XmlRpcTransportFactory.TRANSPORT_AUTH);

    trustManager = (X509TrustManager) properties.get(TRANSPORT_TRUSTMANAGER);
    if (trustManager == null) {
      trustManager = openTrustManager;
    }

    hostnameVerifier = (HostnameVerifier) properties.get(TRANSPORT_HOSTNAMEVERIFIER);
    if (hostnameVerifier == null) {
      hostnameVerifier = openHostnameVerifier;
    }

    sslContext = SSLContext.getInstance(SecurityTool.getSecurityProtocol());
    X509TrustManager[] tmArray = new X509TrustManager[] {trustManager};
    sslContext.init(null, tmArray, new SecureRandom());

    // Set the default SocketFactory and HostnameVerifier
    // for javax.net.ssl.HttpsURLConnection
    if (sslContext != null) {
      HttpsURLConnection.setDefaultSSLSocketFactory(sslContext.getSocketFactory());
    }
    HttpsURLConnection.setDefaultHostnameVerifier(hostnameVerifier);
  }
  /** {@inheritDoc} */
  public synchronized void start(StartContext context) throws StartException {
    Security.addProvider(new JBossSaslProvider());

    ProtocolChannelClient<ManagementChannel> client;
    try {
      ProtocolChannelClient.Configuration<ManagementChannel> configuration =
          new ProtocolChannelClient.Configuration<ManagementChannel>();
      configuration.setEndpoint(endpointInjector.getValue());
      configuration.setUri(
          new URI(
              "remote://"
                  + hcAddressInjector.getValue().getHostName()
                  + ":"
                  + hcAddressInjector.getValue().getPort()));
      configuration.setChannelFactory(new ManagementChannelFactory());
      client = ProtocolChannelClient.create(configuration);
    } catch (Exception e) {
      throw new StartException(e);
    }

    try {
      client.connect(new ClientCallbackHandler());
      channel = client.openChannel(RemotingServices.SERVER_CHANNEL);
      channel.startReceiving();
    } catch (IOException e) {
      throw new StartException("Failed to start remote Host Controller connection", e);
    }
  }
Ejemplo n.º 11
0
 /** Set up the CryptixCrypto provider if we're on a platform that requires it. */
 static {
   if (USE_CRYPTIX) {
     // Use reflection to load the Cryptix Provider.
     // It's safest that way (since we don't want to include
     // the cryptix jar on all installations, and Java
     // may try to load the class otherwise).
     try {
       Class clazz = Class.forName("cryptix.jce.provider.CryptixCrypto");
       Object o = clazz.newInstance();
       Security.addProvider((Provider) o);
     } catch (ClassNotFoundException e) {
       // NLogger.error( TigerTree.class, e, e );
     } catch (IllegalAccessException e) {
       // NLogger.error( TigerTree.class, e, e );
     } catch (InstantiationException e) {
       // NLogger.error( TigerTree.class, e, e );
     } catch (ExceptionInInitializerError e) {
       // NLogger.error( TigerTree.class, e, e );
     } catch (SecurityException e) {
       // NLogger.error( TigerTree.class, e, e );
     } catch (ClassCastException e) {
       // NLogger.error( TigerTree.class, e, e );
     }
   }
 }
  @Before
  public void setUp() throws Exception {
    this.servletTester = new ServletTester();
    String pathSpec = "/test.ocsp";
    this.servletTester.addServlet(OcspResponderTestServlet.class, pathSpec);
    this.servletTester.start();

    String servletUrl = this.servletTester.createSocketConnector(true);
    this.ocspUri = new URI(servletUrl + pathSpec);

    this.testedInstance = new OnlineOcspRepository();

    OcspResponderTestServlet.reset();

    this.rootKeyPair = TrustTestUtils.generateKeyPair();
    DateTime notBefore = new DateTime();
    DateTime notAfter = notBefore.plusMonths(1);
    this.rootCertificate =
        TrustTestUtils.generateSelfSignedCertificate(
            this.rootKeyPair, "CN=TestRoot", notBefore, notAfter);

    KeyPair keyPair = TrustTestUtils.generateKeyPair();
    this.certificate =
        TrustTestUtils.generateCertificate(
            keyPair.getPublic(),
            "CN=Test",
            notBefore,
            notAfter,
            this.rootCertificate,
            this.rootKeyPair.getPrivate());

    // required for org.bouncycastle.ocsp.CertificateID
    Security.addProvider(new BouncyCastleProvider());
  }
 static {
   try {
     MessageDigest.getInstance("MD4");
   } catch (NoSuchAlgorithmException e) {
     Security.addProvider(new BouncyCastleProvider());
   }
 }
  /**
   * Generates an OCSP request using BouncyCastle.
   *
   * @param issuerCert certificate of the issues
   * @param serialNumber serial number
   * @return an OCSP request
   * @throws OCSPException
   * @throws IOException
   */
  private static OCSPReq generateOCSPRequest(X509Certificate issuerCert, BigInteger serialNumber)
      throws OCSPException, IOException {
    // Add provider BC
    Security.addProvider(new repack.org.bouncycastle.jce.provider.BouncyCastleProvider());

    // Generate the id for the certificate we are looking for
    CertificateID id = new CertificateID(CertificateID.HASH_SHA1, issuerCert, serialNumber);

    // basic request generation with nonce
    OCSPReqGenerator gen = new OCSPReqGenerator();

    gen.addRequest(id);

    // create details for nonce extension
    Vector oids = new Vector();
    Vector values = new Vector();

    oids.add(OCSPObjectIdentifiers.id_pkix_ocsp_nonce);
    values.add(
        new X509Extension(
            false,
            new DEROctetString(new DEROctetString(PdfEncryption.createDocumentId()).getEncoded())));

    gen.setRequestExtensions(new X509Extensions(oids, values));

    return gen.generate();
  }
Ejemplo n.º 15
0
  @Before
  public void before() {
    Security.addProvider(new BouncyCastleProvider());

    /** BouncyCastleProvider为默认的provider */
    // Security.insertProviderAt(new BouncyCastleProvider(), 1);
  }
  @Before
  public void setup()
      throws CertificateEncodingException, InvalidKeyException, IllegalStateException,
          NoSuchAlgorithmException, SignatureException, NoSuchProviderException,
          InvalidKeySpecException, IOException {
    Security.addProvider(new BouncyCastleProvider());
    burpCertificateStore = new BurpCertificateStore();

    // Single Certificate
    BurpCertificateBuilder b1 = new BurpCertificateBuilder("CN=example.net");
    BurpCertificate c1 = b1.generateSelfSignedCertificate();
    burpCertificateStore.addCertificate(c1);

    // Single Certificate
    BurpCertificateBuilder b2 = new BurpCertificateBuilder("CN=foobar.net");
    BurpCertificate c2 = b2.generateSelfSignedCertificate();
    burpCertificateStore.addCertificate(c2);

    // Single Certificate
    BurpCertificateBuilder b3 = new BurpCertificateBuilder("CN=gugus.lan");
    BurpCertificate c3 = b3.generateSelfSignedCertificate();
    burpCertificateStore.addCertificate(c3);

    // Certificate Chain
    CertificateTabController certificateTabController =
        new CertificateTabController(new CertificateTab());
    List<BurpCertificate> certificateChain =
        certificateTabController.importCertificateChain("src/test/resources/hsr_chain.pem");
    burpCertificateStore.addCertificateChain(certificateChain);

    certificateTabController.cloneCertificateChain(certificateChain);
  }
Ejemplo n.º 17
0
  public static void sendSmtpSslMessage(
      String smtpHost,
      String smtpSslPort,
      String username,
      String password,
      String from,
      String to,
      String subject,
      String content,
      List<String> filenames,
      boolean debug) {

    logger.info("Send mail to {}, content: {}.", to, content);

    Security.addProvider(new com.sun.net.ssl.internal.ssl.Provider());

    Properties props = new Properties();
    props.put("mail.transport.protocol", "smtp");
    props.put("mail.host", smtpHost);
    props.put("mail.smtp.auth", "true");
    props.put("mail.smtp.port", smtpSslPort);
    props.put("mail.smtp.socketFactory.port", smtpSslPort);
    props.put("mail.smtp.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
    props.put("mail.smtp.socketFactory.fallback", "false");
    props.put("mail.debug", debug ? "true" : "false");

    Session session =
        Session.getDefaultInstance(props, new UsrPwdAuthenticator(username, password));
    session.setDebug(debug);

    sendMimeMessage(from, to, subject, content, filenames, session);

    logger.info("Mail sent");
  }
Ejemplo n.º 18
0
 private static Key loadKeyEncryptionKey() throws Exception {
   Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
   PEMReader pr = new PEMReader(new FileReader(EncryptTool.PRIVATE_KEY));
   KeyPair k = (KeyPair) pr.readObject();
   pr.close();
   return k.getPrivate();
 }
 /** Add crypto providers. */
 @Before
 public void setUp() {
   // Add Bouncy Castle Security Provider
   Security.addProvider(new BouncyCastleProvider());
   PowerAuthConfiguration.INSTANCE.setKeyConvertor(
       CryptoProviderUtilFactory.getCryptoProviderUtils());
 }
Ejemplo n.º 20
0
  public static void main(String[] args) throws Exception {
    Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());

    Misc func = new Misc();

    // initialize the key generator (KG) and generate the public/private key pair
    SecureRandom random = new SecureRandom();
    KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA", "BC");
    generator.initialize(1024, random);
    KeyPair pair = generator.generateKeyPair();

    /* initialize KG for digital signature and generate public/private keys for digital signatures
    It is generally not recommended to use the same public/private key pair for both encryption
    and digital signatures */
    KeyPairGenerator generatorTwo = KeyPairGenerator.getInstance("RSA");
    generatorTwo.initialize(1024);
    KeyPair sigKeyPair = generatorTwo.generateKeyPair();

    byte[] sigPubKey = sigKeyPair.getPublic().getEncoded();
    byte[] sigPrivKey = sigKeyPair.getPrivate().getEncoded();
    byte[] pubKey = pair.getPublic().getEncoded();
    byte[] privKey = pair.getPrivate().getEncoded();

    // output the generated keys
    func.outputText(func.byteToHex(sigPubKey), "alice-dspk.txt");
    func.outputText(func.byteToHex(sigPrivKey), "alice-dspvk.txt");
    func.outputText(func.byteToHex(pubKey), "bob-pkepk.txt");
    func.outputText(func.byteToHex(privKey), "bob-pkepvk.txt");

    // clear sensitive data
    func.clear(sigPubKey);
    func.clear(sigPrivKey);
    func.clear(pubKey);
    func.clear(privKey);
  }
Ejemplo n.º 21
0
  public boolean send() {
    try {
      Security.addProvider(new com.sun.net.ssl.internal.ssl.Provider());
      Properties props = new Properties();
      props.setProperty("mail.transport.protocol", "smtp");
      props.setProperty("mail.host", "smtp.gmail.com");
      props.put("mail.smtp.auth", "true");
      props.put("mail.smtp.port", "465");
      props.put("mail.debug", "true");
      props.put("mail.smtp.socketFactory.port", "465");
      props.put("mail.smtp.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
      props.put("mail.smtp.socketFactory.fallback", "false");
      Session session = Session.getDefaultInstance(props, new GJMailAuthenticator());
      session.setDebug(true);
      Transport transport = session.getTransport();
      InternetAddress addressFrom = new InternetAddress("*****@*****.**");
      MimeMessage message = new MimeMessage(session);
      message.setSender(addressFrom);
      message.setSubject(subject);
      message.setContent(text, "text/html");
      InternetAddress addressTo = new InternetAddress(to);
      message.setRecipient(Message.RecipientType.TO, addressTo);
      transport.connect();
      Transport.send(message);
      transport.close();
      System.out.println("DONE");

    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }

    return true;
  }
Ejemplo n.º 22
0
  /**
   * Create a self-signed X.509 Certificate. From
   * http://bfo.com/blog/2011/03/08/odds_and_ends_creating_a_new_x_509_certificate.html.
   *
   * @param dn the X.509 Distinguished Name, eg "CN=Test, L=London, C=GB"
   * @param pair the KeyPair
   * @param days how many days from now the Certificate is valid for
   * @param algorithm the signing algorithm, eg "SHA1withRSA"
   * @return the self-signed certificate
   * @throws CertificateException thrown if a security error or an IO error ocurred.
   */
  public static X509Certificate generateCertificate(
      String dn, KeyPair pair, int days, String algorithm) throws CertificateException {

    try {
      Security.addProvider(new BouncyCastleProvider());
      AlgorithmIdentifier sigAlgId =
          new DefaultSignatureAlgorithmIdentifierFinder().find(algorithm);
      AlgorithmIdentifier digAlgId = new DefaultDigestAlgorithmIdentifierFinder().find(sigAlgId);
      AsymmetricKeyParameter privateKeyAsymKeyParam =
          PrivateKeyFactory.createKey(pair.getPrivate().getEncoded());
      SubjectPublicKeyInfo subPubKeyInfo =
          SubjectPublicKeyInfo.getInstance(pair.getPublic().getEncoded());
      ContentSigner sigGen =
          new BcRSAContentSignerBuilder(sigAlgId, digAlgId).build(privateKeyAsymKeyParam);
      X500Name name = new X500Name(dn);
      Date from = new Date();
      Date to = new Date(from.getTime() + days * 86400000L);
      BigInteger sn = new BigInteger(64, new SecureRandom());

      X509v1CertificateBuilder v1CertGen =
          new X509v1CertificateBuilder(name, sn, from, to, name, subPubKeyInfo);
      X509CertificateHolder certificateHolder = v1CertGen.build(sigGen);
      return new JcaX509CertificateConverter().setProvider("BC").getCertificate(certificateHolder);
    } catch (CertificateException ce) {
      throw ce;
    } catch (Exception e) {
      throw new CertificateException(e);
    }
  }
Ejemplo n.º 23
0
 private DESedeEncryptor() {
   try {
     // 检测是否有 TripleDES 加密的供应程序
     // 如无,明确地安装SunJCE 供应程序
     try {
       Cipher.getInstance(DESEDE);
     } catch (Exception e) {
       logger.error("Installling SunJCE provider.");
       Provider sunjce = new com.sun.crypto.provider.SunJCE();
       Security.addProvider(sunjce);
     }
     // 得到 DESSede keys
     keyFactory = SecretKeyFactory.getInstance(DESEDE);
     // 创建一个 DESede 密码
     encryptCipher = Cipher.getInstance(DESEDE);
     decryptCipher = Cipher.getInstance(DESEDE);
     // 为 CBC 模式创建一个用于初始化的 vector 对象
     // IvParameters = new IvParameterSpec(new byte[] { 12, 34, 56,
     // 78, 90,
     // 87, 65, 43 });
   } catch (Exception e) {
     // 记录加密或解密操作错误
     logger.error("It's not support DESede encrypt arithmetic in this system!", e);
   }
 }
Ejemplo n.º 24
0
  /*  Ejemplo de uso de funciones de resumen Hash
   *  carga el fichero que recibe como parametro y genera el resumen
   */
  public static void main(String[] args) throws Exception {
    // Comprobar argumentos
    if (args.length != 1) {
      mensajeAyuda();
      System.exit(1);
    }

    /* Cargar "provider" (sólo si no se usa el que viene por defecto) */
    Security.addProvider(new BouncyCastleProvider()); // Usa provider BC

    /* Crear función resumen */
    // MessageDigest messageDigest = MessageDigest.getInstance("MD5"); // Usa MD5
    MessageDigest messageDigest = MessageDigest.getInstance("SHA-1"); // Usar SHA-1

    /* Leer fichero de 1k en 1k y pasar fragmentos leidos a la funcion resumen */
    byte[] buffer = new byte[1000];
    int leidos = in.read(buffer, 0, 1000);
    while (leidos != -1) {
      messageDigest.update(buffer); // Pasa texto claro a la función resumen
      leidos = in.read(buffer, 0, 1000);
    }
    in.close();

    byte[] resumen = messageDigest.digest(); // Completar el resumen

    // Mostrar resumen
    System.out.println("RESUMEN:");
    mostrarBytes(resumen);
    System.out.println();
  }
Ejemplo n.º 25
0
  public static void sfSendEmail(String subject, String message) throws Exception {

    String SMTP_HOST_NAME = "smtp.gmail.com";
    String SMTP_PORT = "465";
    // message = "Test Email Notification From Monitor";
    // subject = "Test Email Notification From Monitor";
    String from = "*****@*****.**";
    String[] recipients = {
      "*****@*****.**", "*****@*****.**", "*****@*****.**"
    };
    String SSL_FACTORY = "javax.net.ssl.SSLSocketFactory";
    // String[] recipients = { "*****@*****.**"};
    // String[] recipients = { "*****@*****.**", "*****@*****.**",
    // "*****@*****.**", "*****@*****.**", "*****@*****.**",
    // "*****@*****.**", "*****@*****.**"};
    // String[] recipients = {"*****@*****.**"};

    Security.addProvider(new com.sun.net.ssl.internal.ssl.Provider());

    boolean debug = true;

    Properties props = new Properties();
    props.put("mail.smtp.host", SMTP_HOST_NAME);
    props.put("mail.smtp.auth", "true");
    // props.put("mail.debug", "true");
    props.put("mail.smtp.port", SMTP_PORT);
    props.put("mail.smtp.socketFactory.port", SMTP_PORT);
    props.put("mail.smtp.socketFactory.class", SSL_FACTORY);
    props.put("mail.smtp.socketFactory.fallback", "false");

    Session session =
        Session.getDefaultInstance(
            props,
            new Authenticator() {

              protected PasswordAuthentication getPasswordAuthentication() {
                return new PasswordAuthentication(
                    "*****@*****.**", "els102sensorweb");
              }
            });

    // session.setDebug(debug);

    Message msg = new MimeMessage(session);
    InternetAddress addressFrom = new InternetAddress(from);
    msg.setFrom(addressFrom);

    InternetAddress[] addressTo = new InternetAddress[recipients.length];
    for (int i = 0; i < recipients.length; i++) {
      addressTo[i] = new InternetAddress(recipients[i]);
    }
    msg.setRecipients(Message.RecipientType.TO, addressTo);

    // Setting the Subject and Content Type
    msg.setSubject(subject);
    msg.setContent(message, "text/plain");
    Transport.send(msg);

    System.out.println("Sucessfully Sent mail to All Users");
  }
Ejemplo n.º 26
0
  public TestingKeys(final String keysFilePath) throws Exception {

    Security.addProvider(new BouncyCastleProvider());

    // load keys:
    File keysFile = new File(this.getClass().getResource(TestSigningUtils.KEYS_FILE).getFile());
    KeyStoreService storeService = new KeyStoreService(keysFile, "temp");
    storeService.setDefaultAlias(TestSigningUtils.ownerCertUri);
    storeService.init();

    privateKeys.put(
        TestSigningUtils.needCertUri, storeService.getPrivateKey(TestSigningUtils.needCertUri));
    privateKeys.put(
        TestSigningUtils.ownerCertUri, storeService.getPrivateKey(TestSigningUtils.ownerCertUri));
    privateKeys.put(
        TestSigningUtils.nodeCertUri, storeService.getPrivateKey(TestSigningUtils.nodeCertUri));

    publicKeys.put(
        TestSigningUtils.needCertUri,
        storeService.getCertificate(TestSigningUtils.needCertUri).getPublicKey());
    publicKeys.put(
        TestSigningUtils.ownerCertUri,
        storeService.getCertificate(TestSigningUtils.ownerCertUri).getPublicKey());
    publicKeys.put(
        TestSigningUtils.nodeCertUri,
        storeService.getCertificate(TestSigningUtils.nodeCertUri).getPublicKey());
  }
Ejemplo n.º 27
0
  private static void bcDES() throws Exception {
    Security.addProvider(new BouncyCastleProvider());

    // Key convert
    DESKeySpec desKeySpec = new DESKeySpec(bytesKey);
    SecretKeyFactory factory = SecretKeyFactory.getInstance("DES", "BC");
    SecretKey desKey = factory.generateSecret(desKeySpec);

    Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
    cipher.init(Cipher.ENCRYPT_MODE, desKey);

    System.out.println("BC" + cipher.getProvider());

    byte[] result = cipher.doFinal("ABC".getBytes());
    String hexResult = Hex.encodeHexString(result);
    System.out.println(hexResult);

    cipher.init(Cipher.DECRYPT_MODE, desKey);
    result =
        cipher.doFinal(
            Hex.decodeHex(hexResult.toCharArray())
            // result
            );
    System.out.println(new String(result));
  }
Ejemplo n.º 28
0
  @Test
  public void testCMD() throws Exception {
    Authentication auth =
        new SkeletonKeyClientBuilder()
            .username("wburke")
            .password("geheim")
            .authentication("Skeleton Key");
    ResteasyClient client = new ResteasyClient();
    WebTarget target = client.target(generateBaseUrl());
    String tiny = target.path("tokens").path("url").request().post(Entity.json(auth), String.class);
    System.out.println(tiny);
    System.out.println("tiny.size: " + tiny.length());
    Security.addProvider(new BouncyCastleProvider());

    KeyPair keyPair = KeyPairGenerator.getInstance("RSA", "BC").generateKeyPair();
    PrivateKey privateKey = keyPair.getPrivate();
    X509Certificate cert = KeyTools.generateTestCertificate(keyPair);

    byte[] signed = p7s(privateKey, cert, null, tiny.getBytes());

    CMSSignedData data = new CMSSignedData(signed);
    byte[] bytes = (byte[]) data.getSignedContent().getContent();
    System.out.println("BYTES: " + new String(bytes));
    System.out.println("size:" + signed.length);
    System.out.println("Base64.size: " + Base64.encodeBytes(signed).length());

    SignerInformation signer =
        (SignerInformation) data.getSignerInfos().getSigners().iterator().next();
    System.out.println("valid: " + signer.verify(cert, "BC"));
  }
Ejemplo n.º 29
0
  private static Properties getImapMailProperties(Account account) {
    Properties props = new Properties();

    if (account.getReceiveProtocolType().contains("gmail")) {
      props.put("mail.imap.host", "imap.gmail.com");
      props.put("mail.imap.port", "143");
      props.put("mail.imap.auth", "true");
      props.put("mail.store.protocol", "imap");
      props.put("mail.imap.starttls.enable", "true");
      props.put("mail.imap.socketFactory.port", "993");
      props.put("mail.imap.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
      props.put("mail.iamp.socketFactory.fallback", "false");
    } else {

      props.setProperty("mail.imap.port", account.getReceivePort());
      props.setProperty("mail.imap.connectiontimeout", "30000");
      if ("ssl".equals(account.getReceiveTs())) {
        Security.addProvider(new com.sun.net.ssl.internal.ssl.Provider());
        props.setProperty("mail.imap.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
        props.setProperty("mail.imap.socketFactory.fallback", "false");
        props.setProperty("mail.imap.socketFactory.port", account.getReceivePort());
      } else if ("tls".equals(account.getReceiveTs())) {
        props.setProperty("mail.imap.starttls.enable", "true");
        java.security.Security.setProperty(
            "ssl.SocketFactory.provider", "com.archermind.txtbl.mail.DummySSLSocketFactory");
      }
    }

    return props;
  }
 @BeforeClass
 public static void create() throws Exception {
   final WildFlyElytronProvider provider = new WildFlyElytronProvider();
   Security.addProvider(provider);
   providerName = provider.getName();
   endpoint = Endpoint.builder().setEndpointName("test").build();
   NetworkServerProvider networkServerProvider =
       endpoint.getConnectionProviderInterface("remote", NetworkServerProvider.class);
   final SecurityDomain.Builder domainBuilder = SecurityDomain.builder();
   final SimpleMapBackedSecurityRealm mainRealm = new SimpleMapBackedSecurityRealm();
   domainBuilder.addRealm("mainRealm", mainRealm).build();
   domainBuilder.setDefaultRealmName("mainRealm");
   domainBuilder.setPermissionMapper((permissionMappable, roles) -> PermissionVerifier.ALL);
   final PasswordFactory passwordFactory = PasswordFactory.getInstance("clear");
   mainRealm.setPasswordMap(
       "bob", passwordFactory.generatePassword(new ClearPasswordSpec("pass".toCharArray())));
   final SaslServerFactory saslServerFactory =
       new ServiceLoaderSaslServerFactory(RemoteChannelCloseTest.class.getClassLoader());
   final SaslAuthenticationFactory.Builder builder = SaslAuthenticationFactory.builder();
   builder.setSecurityDomain(domainBuilder.build());
   builder.setFactory(saslServerFactory);
   builder.addMechanism(
       SaslMechanismInformation.Names.SCRAM_SHA_256, MechanismConfiguration.EMPTY);
   final SaslAuthenticationFactory saslAuthenticationFactory = builder.build();
   streamServer =
       networkServerProvider.createServer(
           new InetSocketAddress("localhost", 30123), OptionMap.EMPTY, saslAuthenticationFactory);
 }