Factor out more test-things.

[gigi.git] / tests / org / cacert / gigi / testUtils / ManagedTest.java

diff --git a/tests/org/cacert/gigi/testUtils/ManagedTest.java b/tests/org/cacert/gigi/testUtils/ManagedTest.java
index 2d6631ef0312349e25c26753f4d390bfe75cae4e..aa800251e5b7a9995fd3d7a25e9a89c7d9a1c2ad 100644 (file)
--- a/tests/org/cacert/gigi/testUtils/ManagedTest.java
+++ b/tests/org/cacert/gigi/testUtils/ManagedTest.java
@@ -1,5 +1,6 @@
 package org.cacert.gigi.testUtils;
 
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertTrue;
 
@@ -12,11 +13,18 @@ import java.io.OutputStream;
 import java.io.UnsupportedEncodingException;
 import java.net.HttpURLConnection;
 import java.net.InetSocketAddress;
+import java.net.MalformedURLException;
+import java.net.Socket;
 import java.net.URL;
 import java.net.URLConnection;
 import java.net.URLEncoder;
 import java.nio.file.Files;
 import java.nio.file.Paths;
+import java.security.KeyManagementException;
+import java.security.NoSuchAlgorithmException;
+import java.security.Principal;
+import java.security.PrivateKey;
+import java.security.cert.X509Certificate;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
@@ -24,10 +32,16 @@ import java.util.Properties;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
+import javax.net.ssl.HttpsURLConnection;
+import javax.net.ssl.KeyManager;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.X509KeyManager;
+
 import org.cacert.gigi.DevelLauncher;
 import org.cacert.gigi.database.DatabaseConnection;
 import org.cacert.gigi.testUtils.TestEmailReciever.TestMail;
 import org.cacert.gigi.util.DatabaseManager;
+import org.cacert.gigi.util.SimpleSigner;
 import org.junit.After;
 import org.junit.AfterClass;
 import org.junit.BeforeClass;
@@ -113,12 +127,15 @@ public class ManagedTest {
                                throw new Error("Server startup failed");
                        }
                        ter = new TestEmailReciever(new InetSocketAddress("localhost", 8473));
+                       SimpleSigner.runSigner();
                } catch (IOException e) {
                        throw new Error(e);
                } catch (ClassNotFoundException e1) {
                        e1.printStackTrace();
                } catch (SQLException e1) {
                        e1.printStackTrace();
+               } catch (InterruptedException e) {
+                       e.printStackTrace();
                }
 
        }
@@ -131,6 +148,11 @@ public class ManagedTest {
                        return;
                }
                gigi.destroy();
+               try {
+                       SimpleSigner.stopSigner();
+               } catch (InterruptedException e) {
+                       e.printStackTrace();
+               }
        }
 
        @After
@@ -156,7 +178,7 @@ public class ManagedTest {
                HttpURLConnection csrfConn = (HttpURLConnection) regist.openConnection();
 
                String headerField = csrfConn.getHeaderField("Set-Cookie");
-               headerField = headerField.substring(0, headerField.indexOf(';'));
+               headerField = stripCookie(headerField);
 
                String csrf = getCSRF(csrfConn);
                uc.addRequestProperty("Cookie", headerField);
@@ -253,6 +275,19 @@ public class ManagedTest {
                return "test" + System.currentTimeMillis() + "a" + (count++);
        }
 
+       private String stripCookie(String headerField) {
+               return headerField.substring(0, headerField.indexOf(';'));
+       }
+
+       public static final String SECURE_REFERENCE = "/account/certs/email";
+
+       public boolean isLoggedin(String cookie) throws IOException {
+               URL u = new URL("https://" + getServerName() + SECURE_REFERENCE);
+               HttpURLConnection huc = (HttpURLConnection) u.openConnection();
+               huc.addRequestProperty("Cookie", cookie);
+               return huc.getResponseCode() == 200;
+       }
+
        public String login(String email, String pw) throws IOException {
                URL u = new URL("https://" + getServerName() + "/login");
                HttpURLConnection huc = (HttpURLConnection) u.openConnection();
@@ -262,8 +297,66 @@ public class ManagedTest {
                os.write(data.getBytes());
                os.flush();
                String headerField = huc.getHeaderField("Set-Cookie");
-               headerField = headerField.substring(0, headerField.indexOf(';'));
-               return headerField;
+               return stripCookie(headerField);
+       }
+
+       public String login(final PrivateKey pk, final X509Certificate ce) throws NoSuchAlgorithmException,
+               KeyManagementException, IOException, MalformedURLException {
+
+               HttpURLConnection connection = (HttpURLConnection) new URL("https://"
+                       + getServerName().replaceFirst("^www.", "secure.") + "/login").openConnection();
+               authenticateClientCert(pk, ce, connection);
+               if (connection.getResponseCode() == 302) {
+                       assertEquals("https://" + getServerName().replaceFirst("^www.", "secure.").replaceFirst(":443$", "") + "/",
+                               connection.getHeaderField("Location").replaceFirst(":443$", ""));
+                       return stripCookie(connection.getHeaderField("Set-Cookie"));
+               } else {
+                       return null;
+               }
+       }
+
+       public void authenticateClientCert(final PrivateKey pk, final X509Certificate ce, HttpURLConnection connection)
+               throws NoSuchAlgorithmException, KeyManagementException {
+               KeyManager km = new X509KeyManager() {
+
+                       @Override
+                       public String chooseClientAlias(String[] arg0, Principal[] arg1, Socket arg2) {
+                               return "client";
+                       }
+
+                       @Override
+                       public String chooseServerAlias(String arg0, Principal[] arg1, Socket arg2) {
+                               return null;
+                       }
+
+                       @Override
+                       public X509Certificate[] getCertificateChain(String arg0) {
+                               return new X509Certificate[] { ce };
+                       }
+
+                       @Override
+                       public String[] getClientAliases(String arg0, Principal[] arg1) {
+                               return new String[] { "client" };
+                       }
+
+                       @Override
+                       public PrivateKey getPrivateKey(String arg0) {
+                               if (arg0.equals("client")) {
+                                       return pk;
+                               }
+                               return null;
+                       }
+
+                       @Override
+                       public String[] getServerAliases(String arg0, Principal[] arg1) {
+                               return new String[] { "client" };
+                       }
+               };
+               SSLContext sc = SSLContext.getInstance("TLS");
+               sc.init(new KeyManager[] { km }, null, null);
+               if (connection instanceof HttpsURLConnection) {
+                       ((HttpsURLConnection) connection).setSSLSocketFactory(sc.getSocketFactory());
+               }
        }
 
        public String getCSRF(URLConnection u) throws IOException {
@@ -275,4 +368,19 @@ public class ManagedTest {
                }
                return m.group(1);
        }
+
+       public static String[] generateCSR(String dn) throws IOException {
+               Process p = Runtime.getRuntime().exec(
+                       new String[] { "openssl", "req", "-newkey", "rsa:1024", "-nodes", "-subj", dn, "-config",
+                                       "keys/selfsign.config" });
+               String csr = IOUtils.readURL(new InputStreamReader(p.getInputStream()));
+
+               String[] parts = csr.split("(?<=-----)\n(?=-----)");
+               if (parts.length != 2) {
+                       System.err.println(IOUtils.readURL(new InputStreamReader(p.getErrorStream())));
+                       throw new Error();
+               }
+               return parts;
+       }
+
 }