Hallo.
Ich musste für ein lokales Programm, das ein Kunde auf seinem Computer installiert und eine Verbindung mit einem Remote Server aufbaut, eine passende Übertragungsmöglichkeit/Empfangsarchitekturfür Daten finden,.
Habe mich für TCP entschieden, nach dem Client-Server Prinzip. RMI habe ich aus persönlichen Gründen nicht genommen.
Jedenfalls ist meine konkrete Frage, in welcher Art und Weise könnte es Probleme geben, was die Security meines Clients/Servers angeht? Ich kenne mich mit der Materie leider nicht besonders gut aus.
Jedenfalls kann sich momentan jeder x-beliebige wenn er die Server IP und den Server Port besitzt mittels Telnet drauf einklinken, was in der Server Klasse dann als "Verbindung Nr.X" angezeigt wird.
Es gibt einen TCPServer, einen ServerThread und den Clienten.
Der Client schickt ein User Namen und User Passwort als String/UTF an den Server.
Der ServerThread ruft aus anderen lokalen Klassen dann Methoden auf, die verarbeitet werden.
ServerThread schickt dann den Return Wert an den Clienten.
TCP Server:
TCP-Server Thread:
TCP-Client:
Hättet ihr Tipps bzw Ratschläge auf was ich noch achten soll?
Würde mich über Antworten freuen.
Ich musste für ein lokales Programm, das ein Kunde auf seinem Computer installiert und eine Verbindung mit einem Remote Server aufbaut, eine passende Übertragungsmöglichkeit/Empfangsarchitekturfür Daten finden,.
Habe mich für TCP entschieden, nach dem Client-Server Prinzip. RMI habe ich aus persönlichen Gründen nicht genommen.
Jedenfalls ist meine konkrete Frage, in welcher Art und Weise könnte es Probleme geben, was die Security meines Clients/Servers angeht? Ich kenne mich mit der Materie leider nicht besonders gut aus.
Jedenfalls kann sich momentan jeder x-beliebige wenn er die Server IP und den Server Port besitzt mittels Telnet drauf einklinken, was in der Server Klasse dann als "Verbindung Nr.X" angezeigt wird.
Es gibt einen TCPServer, einen ServerThread und den Clienten.
Der Client schickt ein User Namen und User Passwort als String/UTF an den Server.
Der ServerThread ruft aus anderen lokalen Klassen dann Methoden auf, die verarbeitet werden.
ServerThread schickt dann den Return Wert an den Clienten.
TCP Server:
Java:
public class TCPServer {
public static void main(String args[]) {
int anz = 1;
try {
ServerSocket ss = new ServerSocket(7788);
while (true) {
Socket sverb = ss.accept();
System.out.println("Verbindung Nr." + anz);
new ServerThread(sverb, anz).start();
anz++;
}
} catch (Exception e) {
System.out.println(e);
}
}
}TCP-Server Thread:
Java:
public class ServerThread extends Thread implements Serializable{
private MonitorRemote mr;
private Socket sverb;
private int anz;
private DataInputStream in;
private DataOutputStream dout;
ServerThread(Socket s, int z) {
this.sverb = s;
this.anz = z;
}
public void sendData(DataOutputStream d) throws IOException {
ObjectOutputStream oos = new ObjectOutputStream(sverb.getOutputStream());
ObjectInputStream ois = new ObjectInputStream(sverb.getInputStream());
oos.writeObject(q); // Int
oos.writeObject(u); // String array
oos.writeObject(lsa); // Liste von String arrays
}
public void login(DataInputStream in, DataOutputStream dout) throws IOException {
mr = new MonitorBean();
DataOutputStream d = dout;
String user = in.readUTF();
String pass = in.readUTF();
System.out.println(user + pass);
System.out.println("kurz in login funk...");
String s = mr.echo(user, pass);
dout.writeUTF(s);
if (s.equals("1")) {
sendData(d);
}
}
@Override
public void run() {
try {
in = new DataInputStream(sverb.getInputStream());
dout = new DataOutputStream(sverb.getOutputStream());
PrintStream out = new PrintStream(sverb.getOutputStream());
String s = null;
boolean q = true;
while (q) {
s = in.readUTF();
System.out.println(s);
if (s.equals("10")) {
login(in, dout);
q = false;
}
}
sverb.close();
} catch (Exception e) {
System.out.println(e);
}
}
}TCP-Client:
Java:
/* eventuell Überlegung Wert, dass sich user nur 4mal hintereinander einloggen darf
* mit falschen Passwort. Anschließend wird login für X Minuten gesperrt
*/
import java.net.*;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
public class TCPClient implements Serializable {
private String user;
private String pass;
private DataInputStream in;
private DataOutputStream out;
private Socket clientSocket;
private ObjectOutputStream oos;
private ObjectInputStream ois;
private List<String> MaxTraffic;
private List<String[]> IP;
private Integer Traffic;
private String host;
private int serverPort;
public TCPClient(String host, int serverPort, String user, String pass) throws IOException, ClassNotFoundException {
this.host = host;
this.serverPort = serverPort;
this.user = user;
this.pass = pass;
System.out.println("TCP Client wird gerade erstelllt");
//login();
}
public void setUser(String user) {
this.user = user;
}
public void setPass(String pass) {
this.pass = pass;
}
public void write(String msg) throws IOException {
out.writeUTF(msg);
}
public String read() throws IOException{
return in.readUTF();
}
public void getObjectStreams() throws IOException, ClassNotFoundException{
oos = new ObjectOutputStream(clientSocket.getOutputStream());
ois = new ObjectInputStream(clientSocket.getInputStream());
this.Traffic = (Integer)ois.readObject();
this.MaxTraffic = (ArrayList<String>)ois.readObject(); // erstellt wurden
this.IP = (ArrayList<String[]>)ois.readObject();
}
public List<String> getMaxTraffic() throws IOException, ClassNotFoundException{
return this.MaxTraffic;
}
public List<String[]> getIP() throws IOException, ClassNotFoundException{
return this.IP;
}
public Integer getTraffic() throws IOException, ClassNotFoundException{
System.out.println("in get traffic drinnen");
return this.Traffic;
}
public int accept(){
return 1;
}
public void login() throws IOException, ClassNotFoundException {
this.clientSocket = new Socket(host, serverPort);
in = new DataInputStream(clientSocket.getInputStream());
out = new DataOutputStream(clientSocket.getOutputStream());
write("10");
write(user);
write(pass);
String s = read();
System.out.println(s);
if (s.equals("1"))
{
accept();
getObjectStreams();
}
out.close();
ois.close();
oos.close();
clientSocket.close();
}
}Hättet ihr Tipps bzw Ratschläge auf was ich noch achten soll?
Würde mich über Antworten freuen.
