/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package neembuu.uploader.accounts;
/*import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;*/
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import neembuu.uploader.translation.Translation;
import neembuu.uploader.exceptions.NUException;
import neembuu.uploader.exceptions.accounts.NUInvalidLoginException;
import neembuu.uploader.httpclient.NUHttpClient;
import neembuu.uploader.httpclient.httprequest.NUHttpPost;
import neembuu.uploader.interfaces.abstractimpl.AbstractAccount;
import neembuu.uploader.utils.NULogger;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.CookieStore;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.protocol.ClientContext;
import org.apache.http.impl.client.BasicCookieStore;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.BasicHttpContext;
import org.apache.http.util.EntityUtils;
import neembuu.uploader.uploaders.common.StringUtils;
//--
/*import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.Map;
import java.util.Set;
import java.util.zip.GZIPInputStream;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;*/
import neembuu.uploader.utils.RemoveCryptographyRestrictions;
/**
*
* @author Paralytic
*/
public class HiVeAccount extends AbstractAccount{
private final HttpClient httpclient = NUHttpClient.getHttpClient();
private HttpResponse httpResponse;
private NUHttpPost httpPost;
private CookieStore cookieStore;
private String responseString;
private String uploadStatus = "";
private String token = "";
public HiVeAccount() {
KEY_USERNAME = "hiveusername";
KEY_PASSWORD = "hivepassword";
HOSTNAME = "HiVe.im";
}
@Override
public void disableLogin() {
resetLogin();
hostsAccountUI().hostUI(HOSTNAME).setEnabled(false);
hostsAccountUI().hostUI(HOSTNAME).setSelected(false);
updateSelectedHostsLabel();
NULogger.getLogger().log(Level.INFO, "{0} account disabled", getHOSTNAME());
}
@Override
public void login() {
loginsuccessful = false;
try {
initialize();
NULogger.getLogger().info("Trying to log in to HiVe.im");
httpPost = new NUHttpPost("https://api.hive.im/api/user/sign-in/");
httpPost.setHeader("Client-Type", "Browser");
httpPost.setHeader("Host", "api.hive.im");
httpPost.setHeader("Origin", "https://touch.hive.im");
List<NameValuePair> formparams = new ArrayList<NameValuePair>();
formparams.add(new BasicNameValuePair("email", getUsername()));
formparams.add(new BasicNameValuePair("password", getPassword()));
UrlEncodedFormEntity entity = new UrlEncodedFormEntity(formparams, "UTF-8");
httpPost.setEntity(entity);
httpResponse = httpclient.execute(httpPost, httpContext);
NULogger.getLogger().info(httpResponse.getStatusLine().toString());
responseString = EntityUtils.toString(httpResponse.getEntity());
uploadStatus = StringUtils.stringBetweenTwoStrings(responseString, "\"status\":\"", "\"");
token = StringUtils.stringBetweenTwoStrings(responseString, "\"token\":\"", "\"");
if (uploadStatus.equals("success") && !token.isEmpty()) {
EntityUtils.consume(httpResponse.getEntity());
loginsuccessful = true;
username = getUsername();
password = getPassword();
hostsAccountUI().hostUI(HOSTNAME).setEnabled(true);
NULogger.getLogger().info("HiVe.im login successful!");
} else {
//Get error message
String error = uploadStatus;
if("Incorrect Login or Password".equals(error)){
throw new NUInvalidLoginException(getUsername(), HOSTNAME);
}
//Generic exception
throw new Exception("Login error: " + error);
}
} catch(NUException ex){
resetLogin();
ex.printError();
accountUIShow().setVisible(true);
} catch (Exception e) {
resetLogin();
NULogger.getLogger().log(Level.SEVERE, "{0}: {1}", new Object[]{getClass().getName(), e});
showWarningMessage( Translation.T().loginerror(), HOSTNAME);
accountUIShow().setVisible(true);
}
}
private void initialize() throws Exception {
RemoveCryptographyRestrictions.removeCryptographyRestrictions();
httpContext = new BasicHttpContext();
cookieStore = new BasicCookieStore();
httpContext.setAttribute(ClientContext.COOKIE_STORE, cookieStore);
/*NULogger.getLogger().info("Getting startup cookies & link from HiVe.im");
//responseString = NUHttpClientUtils.getData("https://www.hive.im/", httpContext);
//System.out.println(shouldAcceptUnsafeCerts());
URL url = new URL("https://www.hive.im/");
HttpsURLConnection.setDefaultHostnameVerifier(DO_NOT_VERIFY);
HttpsURLConnection con = (HttpsURLConnection)url.openConnection();
con.setHostnameVerifier(DO_NOT_VERIFY);
con.setRequestProperty("Accept-Encoding", "gzip");
con.setRequestProperty("Content-type", "application/x-www-form-urlencoded;charset=windows-1251");
Map<String, List<String>> headers = con.getHeaderFields();
Set<Map.Entry<String, List<String>>> entrySet = headers.entrySet();
for (Map.Entry<String, List<String>> entry : entrySet) {
String resp = "";
String headerName = entry.getKey();
List<String> headerValues = entry.getValue();
for (String value : headerValues) {
resp = headerName +": "+ value;
}
System.out.println(resp);
}
InputStream inStream = new GZIPInputStream(con.getInputStream());
BufferedReader br = new BufferedReader(new InputStreamReader(inStream));
String input, htmlResponse = "";
while ((input = br.readLine()) != null){
htmlResponse += input;
//System.out.println(input);
}
br.close();*/
}
private void resetLogin(){
loginsuccessful = false;
username = "";
password = "";
}
public static void main(String[] args) {
neembuu.uploader.paralytics_tests.GenericPluginTester.test(
neembuu.uploader.uploaders.HiVe.class,
neembuu.uploader.accounts.HiVeAccount.class
);
}
// always verify the host - dont check for certificate
/*final static HostnameVerifier DO_NOT_VERIFY = new HostnameVerifier() {
public boolean verify(String hostname, SSLSession session) {
return true;
}
};*/
/**
* Trust every server - dont check for any certificate
*/
/*private static void trustAllHosts() {
// Create a trust manager that does not validate certificate chains
TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {
public java.security.cert.X509Certificate[] getAcceptedIssuers() {
return new java.security.cert.X509Certificate[] {};
}
public void checkClientTrusted(X509Certificate[] chain,
String authType) throws CertificateException {
}
public void checkServerTrusted(X509Certificate[] chain,
String authType) throws CertificateException {
}
} };
// Install the all-trusting trust manager
try {
SSLContext sc = SSLContext.getInstance("SSL");
sc.init(null, trustAllCerts, new java.security.SecureRandom());
HttpsURLConnection
.setDefaultSSLSocketFactory(sc.getSocketFactory());
} catch (Exception e) {
e.printStackTrace();
}
}*/
/*private String shouldAcceptUnsafeCerts() throws Exception {
DefaultHttpClient httpclient = httpClientTrustingAllSSLCerts();
HttpGet httpGet = new HttpGet("https://www.hive.im/");
HttpResponse response = httpclient.execute(httpGet);
return response.toString();
}
private DefaultHttpClient httpClientTrustingAllSSLCerts() throws NoSuchAlgorithmException, KeyManagementException {
DefaultHttpClient httpclient = new DefaultHttpClient();
SSLContext sc = SSLContext.getInstance("SSL");
sc.init(null, getTrustingManager(), new java.security.SecureRandom());
SSLSocketFactory socketFactory = new SSLSocketFactory(sc);
Scheme sch = new Scheme("https", 443, socketFactory);
httpclient.getConnectionManager().getSchemeRegistry().register(sch);
return httpclient;
}
private TrustManager[] getTrustingManager() {
TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {
@Override
public java.security.cert.X509Certificate[] getAcceptedIssuers() {
return null;
}
@Override
public void checkClientTrusted(X509Certificate[] certs, String authType) {
// Do nothing
}
@Override
public void checkServerTrusted(X509Certificate[] certs, String authType) {
// Do nothing
}
} };
return trustAllCerts;
}*/
}