package Extensions;

import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import java.net.UnknownHostException;
import java.nio.charset.Charset;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import org.apache.http.HeaderElement;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpVersion;
import org.apache.http.NameValuePair;
import org.apache.http.StatusLine;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.methods.HttpRequestBase;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.impl.auth.BasicScheme;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;
import org.apache.http.protocol.HTTP;

import android.util.Log;

public class CRunGetThread extends Thread
{
    public DefaultHttpClient client;
    public HttpRequestBase request;

    String text;
    volatile Boolean finished;
    String Password;
    String Username;
    String Hosts;
    int    Ports;
    String Header;
    int    Timeout;
    boolean isHttps = false;

    int nError;

    public CRunGetThread()
    {
        text = "";
        finished = false;
    }

    public DefaultHttpClient mmfHttpClient() {

        try {
            KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
            trustStore.load(null, null);

            SSLSocketFactory sf = new MySSLSocketFactory(trustStore);
            sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

            HttpParams params = new BasicHttpParams();
            HttpConnectionParams.setSoTimeout(params, Timeout);
            HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
            HttpProtocolParams.setContentCharset(params, HTTP.UTF_8);

            SchemeRegistry registry = new SchemeRegistry();
            registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
            registry.register(new Scheme("https", sf, 443));

            ClientConnectionManager ccm = new ThreadSafeClientConnManager(params, registry);

            return new DefaultHttpClient(ccm, params);

        } catch (Exception e) {
            return new DefaultHttpClient();
        }
    }


    @Override
    public void run()
    {
        try
        {
            nError = 0;

            HttpParams params = request.getParams();

            HttpProtocolParams.setContentCharset(params, HTTP.UTF_8);
            HttpProtocolParams.setUseExpectContinue(params, false);
            request.setParams(params);

            client = mmfHttpClient();

            if(Username != null && Password != null) {
                UsernamePasswordCredentials creds = new UsernamePasswordCredentials(Username, Password);
                request.addHeader(BasicScheme.authenticate(creds,"US-ASCII",false));
            }

            HttpResponse response = client.execute(request);
            StatusLine statusLine = response.getStatusLine();

            int statusCode = statusLine.getStatusCode();

            if (statusCode == 200) { // Status OK
                HttpEntity entity = response.getEntity();

                String charset = GetCharset(entity);

                InputStreamReader reader;

                if(charset !=null)
                    reader = new InputStreamReader(entity.getContent(), charset);
                else
                    reader = new InputStreamReader(entity.getContent(), "UTF-8");

                char [] buffer = new char [1024 * 32];
                StringBuilder builder = new StringBuilder();

                for (;;)
                {
                    int length = reader.read (buffer);

                    if (length < 0)
                        break;

                    builder.append(buffer, 0, length);
                }

                text = builder.toString();
                if(charset == null) {
                    if(text.contains("charset")) {
                        String textTmp = text;
                        String charsetName;
                        int count = textTmp.indexOf("charset=",1);
                        charsetName = textTmp.substring(textTmp.indexOf("=",count+1)+1, textTmp.indexOf(">", count+2));
                        charsetName = charsetName.replace(""", "");
                        charsetName = charsetName.replace("/", "");
                        charsetName = charsetName.replace(" ", "");
                        text = new String(textTmp.getBytes(), charsetName);
                    }
                }
            }
            else {
                text="";
                nError = statusCode;
            }
            finished = true;
        }
        catch(Exception e)
        {
            Log.i("GET","Error: "+e.toString());
            text = "";
            finished = true;
        }
        finally
        {
            if (client != null && client.getConnectionManager() != null) {
                client.getConnectionManager().shutdown();
                client = null;
            }
            finished = true;
        }
    }

    public String GetCharset(HttpEntity entity) {
        String charset = null;
        if (entity.getContentType() != null) {
            HeaderElement values[] = entity.getContentType().getElements();
            if (values.length > 0) {
                NameValuePair param = values[0].getParameterByName("charset");
                if (param != null) {
                    charset = param.getValue();
                }
            }
        }
        return charset;
    }
}

class MySSLSocketFactory extends SSLSocketFactory {
    SSLContext sslContext = SSLContext.getInstance("TLS");

    public MySSLSocketFactory(KeyStore truststore) throws NoSuchAlgorithmException, KeyManagementException, KeyStoreException, UnrecoverableKeyException {
        super(truststore);

        TrustManager tm = new X509TrustManager() {
            @Override
            public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            }

            @Override
            public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            }

            @Override
            public X509Certificate[] getAcceptedIssuers() {
                return null;
            }
        };

        sslContext.init(null, new TrustManager[] { tm }, null);
    }

    @Override
    public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException, UnknownHostException {
        return sslContext.getSocketFactory().createSocket(socket, host, port, autoClose);
    }

    @Override
    public Socket createSocket() throws IOException {
        return sslContext.getSocketFactory().createSocket();
    }
}

package Extensions;

import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.List;

import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URLEncodedUtils;

import Actions.CActExtension;
import Conditions.CCndExtension;
import Expressions.CValue;
import RunLoop.CCreateObjectInfo;
import Services.CBinaryFile;


public class CRunGet extends CRunExtension
{
    private Boolean usePost;

    private CRunGetThread thread;
    private String response;
    private String sURL;
    private URL mURL;
    private String mHeader="";
    private String mUser="";
    private String mPassword="";
    private String mUserAgent="";
    private int Timeout;

    private int nError;

    private ArrayList<NameValuePair> postData;

    @Override public int getNumberOfConditions()
    {
        return 3;
    }

    @Override
    public boolean createRunObject(CBinaryFile file, CCreateObjectInfo cob, int version)
    {
        usePost = false;
        postData = new ArrayList<NameValuePair>();

        return true;
    }

    @Override
    public void destroyRunObject(boolean bFast)
    {
        if(thread != null)
             thread = null;
    }

    @Override
    public int handleRunObject()
    {
        if(thread != null)
        {
            if(thread.finished)
            {
                response = thread.text;

                ho.generateEvent(0, 0);
                thread = null;
            }
        }

        return 0;
    }

    @Override
    public boolean condition(int num, CCndExtension cnd)
    {
        switch (num)
        {
            case 0:
                return true;

            case 1:
                return thread != null;

            case 2:
                return true;
        }

        return false;
    }

    @Override
    public void action(int num, CActExtension act)
    {
        switch (num)
        {
            case 0:

                if(thread != null)
                    return;

                try
                {
                    thread = new CRunGetThread();

                    sURL = act.getParamExpString(rh, 0);
                    mURL = new URL(sURL);

                    thread.Hosts = mURL.getHost();
                    thread.Ports = mURL.getPort();

                    if(mURL.getUserInfo() != null){
                        String UserInfo = mURL.getUserInfo();
                        String Login[] = UserInfo.split(":");
                        thread.Username = Login[0];
                        thread.Password = Login[1];
                        mURL = new URL (mURL.getProtocol(), mURL.getHost(), mURL.getPort(), mURL.getFile());
                    }
                    else if(mUser.length()>0){
                        thread.Username = mUser;
                        if(mPassword.length()>0)
                            thread.Password = mPassword;
                        else
                            thread.Password = null;
                    }
                    else {
                        thread.Username = null;
                        thread.Password = null;
                    }

                    // Verify for what type of protocol it is
                    if(mURL.getProtocol().toLowerCase().equals("https"))
                        thread.isHttps = true;
                    else
                        thread.isHttps = false;

                    thread.Timeout = Timeout;

                    if(usePost)
                    {

                        HttpPost post = new HttpPost(mURL.toString());

                        if(mUserAgent.length()==0)
                            post.addHeader("user-agent",  "Chrome");
                        else
                            post.addHeader("user-agent",  mUserAgent);

                        post.addHeader("Content-Type", "application/x-www-form-urlencoded");


                        if(mHeader.length() > 0) {
                            String lines[] = mHeader.split("[\r\n]+");
                            for (int i=0; i < lines.length; i++) {
                                String fields[] = lines[i].split(":");
                                post.addHeader(fields[0].trim(), fields[1].trim());
                            }
                        }


                        try
                        {
                            post.setEntity(new UrlEncodedFormEntity(postData));
                        }
                        catch(Exception e)
                        {
                            response = "";
                            nError = -1;
                            ho.generateEvent(0, 0);
                            thread.finished = true;
                            return;
                        }

                        thread.request = post;
                        thread.start();

                        usePost = false;
                        postData = new ArrayList<NameValuePair>();
                    }
                    else
                    {
                        HttpGet get = new HttpGet(mURL.toString());

                        thread.request = get;
                        thread.start();
                   }
                }
                catch(RuntimeException e)
                {
                    response = "";
                    nError=-1;
                    ho.generateEvent(0, 0);
                    thread.finished = true;
                    return;

                } catch (MalformedURLException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }

                break;

            case 1:

                usePost = true;

                final String name = act.getParamExpString(rh, 0);
                final String value = act.getParamExpString(rh, 1);

                postData.add(new NameValuePair()
                {
                    @Override
                    public String getName()
                    {
                        return name;
                    }

                    @Override
                    public String getValue()
                    {
                        return value;
                    }
                });

                break;

            case 2:                 // Custom Header
                mHeader = act.getParamExpString(rh, 0);
                break;
            case 3:                 // Set User
                mUser = act.getParamExpString(rh, 0);
                break;
            case 4:                 // Set password
                mPassword = act.getParamExpString(rh, 0);
                break;
            case 5:                 // Set Timeout
                Timeout = act.getParamExpression(rh, 0);
                break;
            case 6:                 // Set User-Agent
                mUserAgent = act.getParamExpString(rh, 0);
                break;

        }
    }

    @Override
    public CValue expression(int num)
    {
        switch (num)
        {
            case 0:
                return new CValue(response);

            case 1:
                return new CValue(java.net.URLEncoder.encode(ho.getExpParam().getString()));

            case 2:
                return new CValue(nError);
        }

        return new CValue(0);
    }

}