์ ์ค์ ๊ฒ์ ํ์ํฉ๋๋ค.
์ค๋์ Telnet, TFTP ๋ฑ๊ณผ ๊ฐ์ ํ์ค Windows ์ ํธ๋ฆฌํฐ์ ๊ธฐ๋ฅ์ ์์ Java๋ก ์ํํ๋ ํด๋ผ์ด์ธํธ-์๋ฒ ์ ํ๋ฆฌ์ผ์ด์ ์ ์์ฑํ๋ ๊ณผ์ ์ ์ดํด๋ณด๊ณ ์ถ์ต๋๋ค. ์ ๊ฐ ์๋ก์ด ๊ฒ์ ๊ฐ์ ธ์ค์ง ์์ ๊ฒ์ด ๋ถ๋ช ํฉ๋๋ค. ์ด ๋ชจ๋ ์ ํธ๋ฆฌํฐ๋ XNUMX๋ ๋๊ฒ ์ฑ๊ณต์ ์ผ๋ก ์๋ํด ์์ง๋ง ๋ชจ๋ ์ฌ๋์ด ๋ด๋ถ์์ ๋ฌด์จ ์ผ์ด ์ผ์ด๋๊ณ ์๋์ง ์๋ ๊ฒ์ ์๋๋๋ค.
์ด๊ฒ์ด ๋ฐ๋ก ์ปท์์ ๋
ผ์๋ ๋ด์ฉ์
๋๋ค.
์ด ๊ธฐ์ฌ์์๋ ์ผ๋ฐ ์ ๋ณด ์ธ์ ํ
๋ท ์๋ฒ์ ๋ํด์๋ง ์์ฑํ์ง๋ง ํ์ฌ๋ ๋ค๋ฅธ ์ ํธ๋ฆฌํฐ์ ๋ํ ์๋ฃ๋ ์์ต๋๋ค. ์ด ๋ด์ฉ์ ์๋ฆฌ์ฆ์ ์ถ๊ฐ ๋ถ๋ถ์์ ๋ค๋ฃฐ ์์ ์
๋๋ค.
๋จผ์ Telnet์ด ๋ฌด์์ธ์ง, ๋ฌด์์ด ํ์ํ์ง, ์ด๋ค ์ฉ๋๋ก ์ฌ์ฉ๋๋์ง ํ์ ํด์ผ ํฉ๋๋ค. ์์ค๋ฅผ ๊ทธ๋๋ก ์ธ์ฉํ์ง๋ ์๊ฒ ์ต๋๋ค(ํ์ํ ๊ฒฝ์ฐ ๊ธฐ์ฌ ๋์ ํด๋น ์ฃผ์ ์ ๋ํ ์๋ฃ ๋งํฌ๋ฅผ ์ฒจ๋ถํ๊ฒ ์ต๋๋ค). Telnet์ด ์ฅ์น์ ๋ช ๋ น์ค์ ๋ํ ์๊ฒฉ ์ก์ธ์ค๋ฅผ ์ ๊ณตํ๋ค๊ณ ๋ง ๋ง์๋๋ฆฌ๊ฒ ์ต๋๋ค. ๋์ฒด๋ก ์ด๊ฒ์ด ๊ธฐ๋ฅ์ด ๋๋๋ ๊ณณ์ ๋๋ค(์ ๋ ์๋์ ์ผ๋ก ์๋ฒ ํฌํธ์ ์ก์ธ์คํ๋ ๊ฒ์ ๋ํด ์นจ๋ฌต์ ์ง์ผฐ์ต๋๋ค. ์ด์ ๋ํด์๋ ๋์ค์ ์์ธํ ์ค๋ช ํฉ๋๋ค). ์ด๋ ์ด๋ฅผ ๊ตฌํํ๋ ค๋ฉด ํด๋ผ์ด์ธํธ์์ ๋ผ์ธ์ ์๋ฝํ๊ณ , ์ด๋ฅผ ์๋ฒ์ ์ ๋ฌํ๊ณ , ์ด๋ฅผ ๋ช ๋ น์ค์ ์ ๋ฌํ๋ ค๊ณ ์๋ํ๊ณ , ๋ช ๋ น์ค ์๋ต์ ์ฝ๊ณ , ์๋ ๊ฒฝ์ฐ ์ด๋ฅผ ํด๋ผ์ด์ธํธ์ ๋ค์ ์ ๋ฌํด์ผ ํจ์ ์๋ฏธํฉ๋๋ค. ํ๋ฉด์ ํ์ํ๊ฑฐ๋ ์ค๋ฅ๊ฐ ์๋ ๊ฒฝ์ฐ ์ฌ์ฉ์์๊ฒ ๋ฌธ์ ๊ฐ ์์์ ์๋ ค์ค๋๋ค.
๋ฐ๋ผ์ ์์ ๋ด์ฉ์ ๊ตฌํํ๋ ค๋ฉด 2๊ฐ์ ์์
ํด๋์ค์ ์๋ฒ๋ฅผ ์์ํ๊ณ ํด๋ผ์ด์ธํธ๊ฐ ์๋ํ ํ
์คํธ ํด๋์ค๊ฐ ํ์ํฉ๋๋ค.
๋ฐ๋ผ์ ํ์ฌ ์ ํ๋ฆฌ์ผ์ด์
๊ตฌ์กฐ์๋ ๋ค์์ด ํฌํจ๋ฉ๋๋ค.
- ํ ๋ทํด๋ผ์ด์ธํธ
- Telnetํด๋ผ์ด์ธํธํ ์คํฐ
- ํ ๋ท์๋ฒ
- ํ ๋ท์๋ฒํ ์คํฐ
๊ฐ๊ฐ์ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
ํ ๋ทํด๋ผ์ด์ธํธ
์ด ํด๋์ค๊ฐ ์ํํ ์ ์๋ ์์ ์ ์์ ๋ ๋ช ๋ น์ ๋ณด๋ด๊ณ ์์ ๋ ์๋ต์ ํ์ํ๋ ๊ฒ๋ฟ์ ๋๋ค. ๋ํ ์์์ ์ธ๊ธํ ๊ฒ์ฒ๋ผ ์๊ฒฉ ์ฅ์น์ ์์ ํฌํธ์ ์ฐ๊ฒฐํ๊ณ ์ฐ๊ฒฐ์ ๋์ ์ ์์ด์ผ ํฉ๋๋ค.
์ด๋ฅผ ๋ฌ์ฑํ๊ธฐ ์ํด ๋ค์ ๊ธฐ๋ฅ์ด ๊ตฌํ๋์์ต๋๋ค.
์์ผ ์ฃผ์๋ฅผ ์ธ์๋ก ์ฌ์ฉํ๊ณ ์ฐ๊ฒฐ์ ์ด๊ณ ์ ๋ ฅ ๋ฐ ์ถ๋ ฅ ์คํธ๋ฆผ์ ์์ํ๋ ํจ์์ ๋๋ค(์คํธ๋ฆผ ๋ณ์๋ ์์์ ์ ์ธ๋์์ผ๋ฉฐ ์ ์ฒด ์์ค๋ ๊ธฐ์ฌ ๋์ ์์ต๋๋ค).
public void run(String ip, int port)
{
try {
Socket socket = new Socket(ip, port);
InputStream sin = socket.getInputStream();
OutputStream sout = socket.getOutputStream();
Scanner keyboard = new Scanner(System.in);
reader = new Thread(()->read(keyboard, sout));
writer = new Thread(()->write(sin));
reader.start();
writer.start();
}
catch (Exception e) {
System.out.println(e.getMessage());
}
}
๋์ผํ ๊ธฐ๋ฅ ์ค๋ฒ๋ก๋, ๊ธฐ๋ณธ ํฌํธ์ ์ฐ๊ฒฐ - ํ ๋ท์ ๊ฒฝ์ฐ 23
public void run(String ip)
{
run(ip, 23);
}
์ด ํจ์๋ ํค๋ณด๋์์ ๋ฌธ์๋ฅผ ์ฝ๊ณ ์ด๋ฅผ ์ถ๋ ฅ ์์ผ์ผ๋ก ๋ณด๋ ๋๋ค. ์ด๋ ์ผ๋ฐ์ ์ผ๋ก ๋ฌธ์ ๋ชจ๋๊ฐ ์๋ ๋ผ์ธ ๋ชจ๋์ ๋๋ค.
private void read(Scanner keyboard, OutputStream sout)
{
try {
String input = new String();
while (true) {
input = keyboard.nextLine();
for (char i : (input + " n").toCharArray())
sout.write(i);
}
}
catch (Exception e) {
System.out.println(e.getMessage());
}
}
์ด ํจ์๋ ์์ผ์ผ๋ก๋ถํฐ ๋ฐ์ดํฐ๋ฅผ ์์ ํ์ฌ ํ๋ฉด์ ํ์ํฉ๋๋ค.
private void write(InputStream sin)
{
try {
int tmp;
while (true){
tmp = sin.read();
System.out.print((char)tmp);
}
}
catch (Exception e) {
System.out.println(e.getMessage());
}
}
๋ฐ์ดํฐ ์์ ๋ฐ ์ ์ก์ ์ค์งํ๋ ๊ธฐ๋ฅ์ ๋๋ค.
public void stop()
{
reader.stop();
writer.stop();
}
}
ํ ๋ท์๋ฒ
์ด ํด๋์ค์๋ ์์ผ์์ ๋ช ๋ น์ ์์ ํ๊ณ , ์คํ์ ์ํด ๋ณด๋ด๊ณ , ๋ช ๋ น์ ์๋ต์ ๋ค์ ์์ผ์ผ๋ก ๋ณด๋ด๋ ๊ธฐ๋ฅ์ด ์์ด์ผ ํฉ๋๋ค. ํ๋ก๊ทธ๋จ์ ์๋์ ์ผ๋ก ์ ๋ ฅ ๋ฐ์ดํฐ๋ฅผ ํ์ธํ์ง ์์ต๋๋ค. ์๋ํ๋ฉด ์ฒซ์งธ, "๋ฐ์คํ ํ ๋ท"์์๋ ์๋ฒ ๋์คํฌ ํฌ๋งท์ด ๊ฐ๋ฅํ๊ณ , ๋์งธ, ์ด ๊ธฐ์ฌ์์๋ ๋ณด์ ๋ฌธ์ ๊ฐ ์์น์ ์ผ๋ก ์๋ต๋์ด ์๊ธฐ ๋๋ฌธ์ ๋๋ค. ์ํธํ ๋๋ SSL์ ๋ํ ํ๋ง๋.
ํจ์๋ 2๊ฐ๋ฟ์ด๊ณ (๊ทธ ์ค ํ๋๋ ์ค๋ฒ๋ก๋๋จ) ์ผ๋ฐ์ ์ผ๋ก ์ด๋ ๊ทธ๋ค์ง ์ข์ ์ต๊ด์ ์๋์ง๋ง ์ด ์์ ์ ๋ชฉ์ ์ ์ํด์๋ ๋ชจ๋ ๊ฒ์ ๊ทธ๋๋ก ๋๋ ๊ฒ์ด ์ ์ ํด ๋ณด์์ต๋๋ค.
boolean isRunning = true;
public void run(int port) {
(new Thread(()->{ try {
ServerSocket ss = new ServerSocket(port); // ัะพะทะดะฐะตะผ ัะพะบะตั ัะตัะฒะตัะฐ ะธ ะฟัะธะฒัะทัะฒะฐะตะผ ะตะณะพ ะบ ะฒััะตัะบะฐะทะฐะฝะฝะพะผั ะฟะพััั
System.out.println("Port "+port+" is waiting for connections");
Socket socket = ss.accept();
System.out.println("Connected");
System.out.println();
// ะะตัะตะผ ะฒั
ะพะดะฝะพะน ะธ ะฒัั
ะพะดะฝะพะน ะฟะพัะพะบะธ ัะพะบะตัะฐ, ัะตะฟะตัั ะผะพะถะตะผ ะฟะพะปััะฐัั ะธ ะพัััะปะฐัั ะดะฐะฝะฝัะต ะบะปะธะตะฝัั.
InputStream sin = socket.getInputStream();
OutputStream sout = socket.getOutputStream();
Map<String, String> env = System.getenv();
String wayToTemp = env.get("TEMP") + "tmp.txt";
for (int i :("Connectednnr".toCharArray()))
sout.write(i);
sout.flush();
String buffer = new String();
while (isRunning) {
int intReader = 0;
while ((char) intReader != 'n') {
intReader = sin.read();
buffer += (char) intReader;
}
final String inputToSubThread = "cmd /c " + buffer.substring(0, buffer.length()-2) + " 2>&1";
new Thread(()-> {
try {
Process p = Runtime.getRuntime().exec(inputToSubThread);
InputStream out = p.getInputStream();
Scanner fromProcess = new Scanner(out);
try {
while (fromProcess.hasNextLine()) {
String temp = fromProcess.nextLine();
System.out.println(temp);
for (char i : temp.toCharArray())
sout.write(i);
sout.write('n');
sout.write('r');
}
}
catch (Exception e) {
String output = "Something gets wrong... Err code: "+ e.getStackTrace();
System.out.println(output);
for (char i : output.toCharArray())
sout.write(i);
sout.write('n');
sout.write('r');
}
p.getErrorStream().close();
p.getOutputStream().close();
p.getInputStream().close();
sout.flush();
}
catch (Exception e) {
System.out.println("Error: " + e.getMessage());
}
}).start();
System.out.println(buffer);
buffer = "";
}
}
catch(Exception x) {
System.out.println(x.getMessage());
}})).start();
}
ํ๋ก๊ทธ๋จ์ ์๋ฒ ํฌํธ๋ฅผ ์ด๊ณ , ๋ช ๋ น ๋ ๋ฌธ์๋ฅผ ๋ง๋ ๋๊น์ง ๋ฐ์ดํฐ๋ฅผ ์ฝ๊ณ , ๋ช ๋ น์ ์ ํ๋ก์ธ์ค์ ์ ๋ฌํ๊ณ , ํ๋ก์ธ์ค์ ์ถ๋ ฅ์ ์์ผ์ผ๋ก ๋ฆฌ๋๋ ์ ํฉ๋๋ค. ๋ชจ๋ ๊ฒ์ด Kalashnikov ๋๊ฒฉ ์์ด๋งํผ ๊ฐ๋จํฉ๋๋ค.
๋ฐ๋ผ์ ๊ธฐ๋ณธ ํฌํธ๋ฅผ ์ฌ์ฉํ๋ฉด ์ด ๊ธฐ๋ฅ์ ๊ณผ๋ถํ๊ฐ ๋ฐ์ํฉ๋๋ค.
public void run()
{
run(23);
}
๋ฐ๋ผ์ ์๋ฒ๋ฅผ ์ค์งํ๋ ๊ธฐ๋ฅ๋ ์ฌ์ํ๋ฉฐ ์๊ตฌ ๋ฃจํ๋ฅผ ์ค๋จํ์ฌ ํด๋น ์กฐ๊ฑด์ ์๋ฐํฉ๋๋ค.
public void stop()
{
System.out.println("Server was stopped");
this.isRunning = false;
}
์ฌ๊ธฐ์๋ ํ ์คํธ ํด๋์ค๋ฅผ ์ ๊ณตํ์ง ์์ ๊ฒ์ ๋๋ค. ์๋์ ์์ต๋๋ค. ๊ทธ๋ค์ด ํ๋ ์ผ์ ๊ณต์ฉ ๋ฉ์๋์ ๊ธฐ๋ฅ์ ํ์ธํ๋ ๊ฒ๋ฟ์ ๋๋ค. ๋ชจ๋ ๊ฒ์ด git์ ์์ต๋๋ค.
์์ฝํ์๋ฉด, ๋ฉฐ์น ์ ๋ ์ด๋ฉด ๊ธฐ๋ณธ ์ฝ์ ์ ํธ๋ฆฌํฐ์ ์๋ ์๋ฆฌ๋ฅผ ์ดํดํ ์ ์์ต๋๋ค. ์ด์ ์๊ฒฉ ์ปดํจํฐ์ ํ ๋ ๋ท์ ์ฐ๊ฒฐํ๋ฉด ๋ฌด์จ ์ผ์ด ์ผ์ด๋๊ณ ์๋์ง ์ดํดํ๊ฒ ๋ฉ๋๋ค. ๋ง๋ฒ์ด ์ฌ๋ผ์ก์ต๋๋ค.)
๋ฐ๋ผ์ ๋งํฌ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
์ถ์ฒ : habr.com