Simpler TLS/SSL Client

#include <iostream>
#include <string>
#include <array>
#include <boost/bind.hpp>
#include <boost/asio.hpp>
#include <boost/asio/ssl.hpp>


typedef boost::asio::ssl::stream<boost::asio::ip::tcp::socket> ssl_socket;


std::string pass() {
	return "test";
}


int  main() {


	std::cout << "Server started..." << std::endl;


	while (true) {
		try {


			//Start TLS Socket
			boost::asio::io_context io_context;
			boost::asio::ip::tcp::acceptor acceptor(io_context, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), 11880));
			boost::asio::ssl::context context(boost::asio::ssl::context::sslv23);
			context.set_options(
				boost::asio::ssl::context::default_workarounds
				| boost::asio::ssl::context::no_sslv2);
			context.use_certificate_chain_file("public.pem");
			context.set_password_callback(boost::bind(pass));
			context.use_private_key_file("private.pem", boost::asio::ssl::context::pem);
			context.use_tmp_dh_file("dh2048.pem");
			ssl_socket stream(io_context, context);
			boost::asio::ip::tcp::endpoint peer_endpoint;
			acceptor.accept(stream.lowest_layer(), peer_endpoint);
			boost::system::error_code ec;
			stream.handshake(boost::asio::ssl::stream_base::server, ec);




			std::string response;
			std::string incoming;
			std::array<char, 1024> buffer;
			buffer.fill(0);
			boost::system::error_code error;


			stream.read_some(boost::asio::buffer(buffer, sizeof(buffer)), error); //Nachricht kommt an
			incoming = buffer.data();


			std::cout << incoming << std::endl;


			response += "ist angekommen: (" + incoming + ")"; //Antwort = "ist angekommen (%meineNachricht%)"
			boost::asio::write(stream, boost::asio::buffer(response, response.length())); //Antwort senden




		}
		catch (std::exception& myexc) {
			std::cout << myexc.what() << std::endl;
		}
	}
}

#include <cstdlib>
#include <iostream>
#include <boost/bind.hpp>
#include <boost/asio.hpp>
#include <boost/asio/ssl.hpp>
#include <string>


enum { max_length = 1024 };


class client
{
public:
	client(boost::asio::io_context& io_context,
		boost::asio::ssl::context& context,
		boost::asio::ip::tcp::resolver::results_type endpoints)
		: socket_(io_context, context)
	{
		socket_.set_verify_mode(boost::asio::ssl::verify_peer);
		socket_.set_verify_callback(
			boost::bind(&client::verify_certificate, this, _1, _2));


		boost::asio::async_connect(socket_.lowest_layer(), endpoints,
			boost::bind(&client::handle_connect, this,
				boost::asio::placeholders::error));
	}


	bool verify_certificate(bool preverified,
		boost::asio::ssl::verify_context& ctx)
	{
		char subject_name[256];
		X509* cert = X509_STORE_CTX_get_current_cert(ctx.native_handle());
		X509_NAME_oneline(X509_get_subject_name(cert), subject_name, 256);


		return preverified;
	}


	void handle_connect(const boost::system::error_code& error)
	{
		if (!error)
		{
			socket_.async_handshake(boost::asio::ssl::stream_base::client,
				boost::bind(&client::handle_handshake, this,
					boost::asio::placeholders::error));
		}
		else
		{
			std::cout << "Connect failed: " << error.message() << "\n";
		}
	}


	void handle_handshake(const boost::system::error_code& error)
	{
		if (!error)
		{
			std::cout << "Enter message: ";
			std::cin.getline(request_, max_length);
			size_t request_length = strlen(request_);


			boost::asio::async_write(socket_,
				boost::asio::buffer(request_),
				boost::bind(&client::handle_write, this,
					boost::asio::placeholders::error,
					boost::asio::placeholders::bytes_transferred));
		}
		else
		{
			std::cout << "Handshake failed: " << error.message() << "\n";
		}
	}


	void handle_write(const boost::system::error_code& error,
		size_t bytes_transferred)
	{
		if (!error)
		{
			reply_.fill(0);
			socket_.async_read_some(boost::asio::buffer(reply_, 1024),
				boost::bind(&client::handle_read, this,
					boost::asio::placeholders::error,
					boost::asio::placeholders::bytes_transferred));
		}
		else
		{
			std::cout << "Write failed: " << error.message() << "\n";
		}
	}


	void handle_read(const boost::system::error_code& error,
		size_t bytes_transferred)
	{
		if (!error)
		{
			size_t length = bytes_transferred;


			std::string test;
			for (UINT i = 0; i < length; i++) {
				test += reply_[i];
			}




			std::cout << test;
			std::cout << "\n";
		}
		else
		{
			std::cout << "Read failed: " << error.message() << "\n";
		}
	}


private:
	boost::asio::ssl::stream<boost::asio::ip::tcp::socket> socket_;
	char request_[max_length];
	std::array<char, 1024> reply_;
};


int main() {
	try {


		while (true) {
			boost::asio::io_context io_context;


			boost::asio::ip::tcp::resolver resolver(io_context);
			boost::asio::ip::tcp::resolver::results_type endpoints = resolver.resolve("127.0.0.1", "11880");


			boost::asio::ssl::context ctx(boost::asio::ssl::context::sslv23);
			ctx.load_verify_file("public.pem");


			client c(io_context, ctx, endpoints);


			io_context.run();
			std::cin.get();
		}
	}
	catch (std::exception& myexc) {
		std::cerr << "Exception: " << myexc.what() << "\n";
		std::cin.get();
	}


	return 0;
}

public class MainActivity extends Activity {


    // Inistailierung
    Button Send;
    EditText IP;
    EditText Port;
    TextView Answer;
    EditText Message;


    private String ip_address;
    private int port = 11880;
    private SSLSocket socket = null;
    private BufferedReader in = null;
    private BufferedWriter out = null;
    private final String TAG = "TAG";
    private char keystorepass[] = "key12345".toCharArray();




    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);


        Send = (Button) findViewById(R.id.btnSend);
        IP = (EditText) findViewById(R.id.etIP);
        Port = (EditText) findViewById(R.id.etPort);
        Answer = (TextView) findViewById(R.id.tvAnswer);
        Message = (EditText) findViewById(R.id.etMessage);




        Send.setClickable(true);
        Send.setOnClickListener(new View.OnClickListener() {


            @Override
            public void onClick(View v) {
                if (IP.getText().toString().equals(null) || Port.getText().toString().equals(null)){
                    Toast.makeText(v.getContext(), "Bitte IP und Port eingeben", Toast.LENGTH_LONG).show();
                }else {
                    String temp = Message.getText().toString();
                    if (temp == null){
                        temp = "Es wurde keine Nachricht eingegeben";
                    }
                    port = Integer.parseInt(Port.getText().toString());
                    ip_address = IP.getText().toString();


                    try {
                        KeyStore ks = KeyStore.getInstance("BKS");
                        InputStream keyin = v.getResources().openRawResource(R.raw.neuserverkeypem);
                        ks.load(keyin,keystorepass);
                        org.apache.http.conn.ssl.SSLSocketFactory socketFactory = new org.apache.http.conn.ssl.SSLSocketFactory(ks);
                        socketFactory.setHostnameVerifier(socketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
                        socket = (SSLSocket)
                                socketFactory.createSocket(new Socket(ip_address,port), ip_address, port, false);
                        socket.startHandshake();


                        printServerCertificate(socket);
                        printSocketInfo(socket);


                        out = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
                        in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                        chat(temp);
                    } catch (UnknownHostException e) {
                        Toast.makeText(v.getContext(), "Unknown host", Toast.LENGTH_SHORT).show();
                        Log.i(TAG,"Unknown host");
                        //System.exit(1);
                    } catch  (IOException e) {
                        Toast.makeText(v.getContext(), "No I/O", Toast.LENGTH_SHORT).show();
                        Log.i(TAG,"No I/O");
                        e.printStackTrace();
                        //System.exit(1);
                    } catch (KeyStoreException e) {
                        Toast.makeText(v.getContext(), "Keystore ks error", Toast.LENGTH_SHORT).show();
                        Log.i(TAG,"Keystore ks error");
                        //System.exit(-1);
                    } catch (NoSuchAlgorithmException e) {
                        Toast.makeText(v.getContext(), "No such algorithm for ks.load", Toast.LENGTH_SHORT).show();
                        Log.i(TAG,"No such algorithm for ks.load");
                        e.printStackTrace();
                        //System.exit(-1);
                    } catch (CertificateException e) {
                        Toast.makeText(v.getContext(), "certificate missing", Toast.LENGTH_SHORT).show();
                        Log.i(TAG,"certificate missing");
                        e.printStackTrace();
                        //System.exit(-1);
                    } catch (UnrecoverableKeyException e) {
                        Toast.makeText(v.getContext(), "UnrecoverableKeyException", Toast.LENGTH_SHORT).show();
                        Log.i(TAG,"unrecoverableKeyException");
                        e.printStackTrace();
                        //System.exit(-1);
                    } catch (KeyManagementException e) {
                        Toast.makeText(v.getContext(), "KeyManagementException", Toast.LENGTH_SHORT).show();
                        Log.i(TAG,"key management exception");
                        e.printStackTrace();
                        //System.exit(-1);
                    }
                }
            }
        });






    }
    private void printServerCertificate(SSLSocket socket) {
        try {
            Certificate[] serverCerts =
                    socket.getSession().getPeerCertificates();
            for (int i = 0; i < serverCerts.length; i++) {
                Certificate myCert = serverCerts[i];
                Log.i(TAG,"====Certificate:" + (i+1) + "====");
                Log.i(TAG,"-Public Key-\n" + myCert.getPublicKey());
                Log.i(TAG,"-Certificate Type-\n " + myCert.getType());


                System.out.println();
            }
        } catch (SSLPeerUnverifiedException e) {
            Log.i(TAG,"Could not verify peer");
            e.printStackTrace();
            System.exit(-1);
        }
    }
    private void printSocketInfo(SSLSocket s) {
        Log.i(TAG,"Socket class: "+s.getClass());
        Log.i(TAG,"   Remote address = "
                +s.getInetAddress().toString());
        Log.i(TAG,"   Remote port = "+s.getPort());
        Log.i(TAG,"   Local socket address = "
                +s.getLocalSocketAddress().toString());
        Log.i(TAG,"   Local address = "
                +s.getLocalAddress().toString());
        Log.i(TAG,"   Local port = "+s.getLocalPort());
        Log.i(TAG,"   Need client authentication = "
                +s.getNeedClientAuth());
        SSLSession ss = s.getSession();
        Log.i(TAG,"   Cipher suite = "+ss.getCipherSuite());
        Log.i(TAG,"   Protocol = "+ss.getProtocol());
    }


    public void chat(String temp){
        String message = temp;
        String line = "";
        // send id of the device to match with the image
        try {
            out.write(message+"\n");
            out.flush();
        } catch (IOException e2) {
            Log.i(TAG,"Read failed");
            System.exit(1);
        }
        // receive a ready command from the server
        try {
            line = in.readLine();
            Answer.setText("SERVER SAID: "+line);
            //Log.i(TAG,line);
        } catch (IOException e1) {
            Log.i(TAG,"Read failed");
            System.exit(1);
        }
    }
}

test
ANau2qBh4lPNksKrDMlsJAQnwzGORXIwIBAg==
-----END DH PARAMETERS-----
S-----
lGJYbY7IuK9+MQWTFx8Eg5s1JU5dE/Xw0EetVSAxYNP+r56pHwmxZEXB/aAmF
OYeZqrwnHzfEZHpQ9khf86sp42aNryrzYqpbnaUknM2DPQAFxxekX4QCLVXMEB8o
x6gpxTBupu8xQhhE901MRh7XLvyAwLJ8qpYbF2dpimb2/EoUsjb/let6W55pA5bJ
Y9nzCaX5NPU8fHjgvHzaa9dCbUv9lAhQJLQtBkSyPB5fuw1tMY7VmVsxNURunNjV
eREJ/r2fQuuPEEkrtRfzmFDwL+w8D505jV5ofxdN4qC+74YAecel6Vlb4uOMtIcv
MUlZ3kECgYEA2hLjMXOa74dMyZ0qrhFpTs4tg9mwkVuQ254FmHOyMx2BTd9Z09/+
nYZJjbOl61I3m/7eChNv/FLjId6R2EoYcDJ3SrCxEZoemDb/uyC3QpWKZG9yN/vh
JmDcayyHClrOmFxFSD0SQeaqAbiQeScly7nmYKpJysVr9NmErdG7ieUCgYEA1NCN
WHfVEZNu6LN3jELSj5FXTqdMo5fr+QSAdinc0pnzIG4kHa6pi/fPGOD92/Oymd2w
OyEH8bnMvcxWEPHDKXSc9qlfNHl22j66KL8jVEbMSf/l2IPafssW8/QFqdyCdmLS
qTwt3qhTE5lJROlDVoqZWIMCq6VPpEeA2aet29kCgYAD0ejg6OGB6KDTt0kUG4H4
u2vYr2uEYFI9RptafExW0OF+97afG4FeSQfoz4jMgngu51wEWSrRBLKt2TQ80a9z
565nRIkVgdmfWPdJ09zh8bSm5bzedi8PeQrjZbhH2idcS+F6zncPaHb56L2/IYxr
8Smz78ezIZoug9DrKo1acQKBgQC3aS4ISu6lAS2a++FSTtztwtM+BE22yF4k9U5J
iHa6QtgY4RPbSQbyjJY92Nqwz+zjUv5;ñvT4k

-----BEGIN RSA PRIVATE KEY-----
MIIEpAIBAAKCAQEAtUlL5U+e2jaaAIC2h3JMIgc0EaYM3rjjGVgsq2QQZ8nTGUBw
o5G+3LVrxmpP33oRcoVffacDqCBhPKGYudd7EzYji8hsQIiGCavU60KPj+JAhzbq
XylcKnRUIZi2FLq7DN5PNyUMXQVwGv6bgmq+fGwNjpUBfxKjS1WzzjlLAVBOeoRh
bbqgiZQ0Bvg4rxek3G+r7vDtMGg4cakHnCQk/nb6ZVa3aGRrTCcDegInZrdYk0ch
67VuxAVoNDZoqbvAQWiAVK33NE1yZ9B+mySuHIHJH7/tYR9rTbqtKWwKbt6r+TVP
3upKdrMkopxoy8hETzIn5c5z5b4tl5+Pya/KHQIDAQABAoIBAG91v0of6AU2aP1C
JfelGJYbY7IuK9+MQWTFx8Eg5s1JU5dE/Xw0EetVSAxYNP+r56pHwmxZEXB/aAmF
OYeZqrwnHzfEZHpQ9khf86sp42aNryrzYqpbnaUknM2DPQAFxxekX4QCLVXMEB8o
x6gpxTBupu8xQhhE901MRh7XLvyAwLJ8qpYbF2dpimb2/EoUsjb/let6W55pA5bJ
Y9nzCaX5NPU8fHjgvHzaa9dCbUv9lAhQJLQtBkSyPB5fuw1tMY7VmVsxNURunNjV
eREJ/r2fQuuPEEkrtRfzmFDwL+w8D505jV5ofxdN4qC+74YAecel6Vlb4uOMtIcv
MUlZ3kECgYEA2hLjMXOa74dMyZ0qrhFpTs4tg9mwkVuQ254FmHOyMx2BTd9Z09/+
nYZJjbOl61I3m/7eChNv/FLjId6R2EoYcDJ3SrCxEZoemDb/uyC3QpWKZG9yN/vh
JmDcayyHClrOmFxFSD0SQeaqAbiQeScly7nmYKpJysVr9NmErdG7ieUCgYEA1NCN
WHfVEZNu6LN3jELSj5FXTqdMo5fr+QSAdinc0pnzIG4kHa6pi/fPGOD92/Oymd2w
OyEH8bnMvcxWEPHDKXSc9qlfNHl22j66KL8jVEbMSf/l2IPafssW8/QFqdyCdmLS
qTwt3qhTE5lJROlDVoqZWIMCq6VPpEeA2aet29kCgYAD0ejg6OGB6KDTt0kUG4H4
u2vYr2uEYFI9RptafExW0OF+97afG4FeSQfoz4jMgngu51wEWSrRBLKt2TQ80a9z
565nRIkVgdmfWPdJ09zh8bSm5bzedi8PeQrjZbhH2idcS+F6zncPaHb56L2/IYxr
8Smz78ezIZoug9DrKo1acQKBgQC3aS4ISu6lAS2a++FSTtztwtM+BE22yF4k9U5J
iHa6QtgY4RPbSQbyjJY92Nqwz+zjUv5pV2RjXkAoa4zZeaM7fTcyFnLo5K4cFeeW
6nRmU8YJGLRcz/ZlRF75zRt8c4E0yqLIHAdkWCmRQJC3BVp1oWnbsL2CdSyYZs+T
xkG+sQKBgQCYtxjh6dQkWgLf9Wm4hrDYs6FABdGxGmkW6UZlescPiRbNysECxzQQ
sYmu0nGrzcLDY25YEZSNEuige9GmaBnfcSX4mD3VVcZ9HuqHvzSfmIfVWd6amR7Q
YnTNi1WKMjmiHb+IiXW9jlvMbVlAB0C4snQLCh15tw4aBtTCWPEsUw==
-----END RSA PRIVATE KEY-----