공부중인학생
18
2017-10-26 16:11:40
23
8200

저절로써지는 코드... 해킹인가요?


제가 지금 카페에서 인텔리제이 프로그램으로 코딩연습을 하던 도중에

잠시 친구랑 2-30분 얘기를 하느라 그냥 프로그램은 켜놓고 가만히 놔뒀는데
갑자기 화면을 보니까 코드가 저절로 써지고있더라고요...
너무 무서워서 일단은 제가 마우스를 움직여보니까 그후로는 안움직이는데
써진 코드를 보니까
파일명은 FileInputStream.java로 써져있고 코드내용은 아래에 첨부했어요ㅜㅜㅜ
진짜 너무무서워서 물어봅니다.. 제가 이런 클래스 만든적도 없고 이렇게 긴 코드는 쓸줄도 몰라요..
이거 해킹된건가요/..? 그렇다면 어떻게 조치를 해야하는지도 궁금합니다.

/*
* Copyright (c) 1994, 2013, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/

package java.io;

import java.nio.channels.FileChannel;
import sun.nio.ch.FileChannelImpl;


/**
* A <code>FileInputStream</code> obtains input bytes
* from a file in a file system. What files
* are available depends on the host environment.
*
* <p><code>FileInputStream</code> is meant for reading streams of raw bytes
* such as image data. For reading streams of characters, consider using
* <code>FileReader</code>.
*
* @author Arthur van Hoff
* @see java.io.File
* @see java.io.FileDescriptor
* @see java.io.FileOutputStream
* @see java.nio.file.Files#newInputStream
* @since JDK1.0
*/
public
class FileInputStream extends InputStream
{
/* File Descriptor - handle to the open file */
private final FileDescriptor fd;

/**
* The path of the referenced file
* (null if the stream is created with a file descriptor)
*/
private final String path;

private FileChannel channel = null;

private final Object closeLock = new Object();
private volatile boolean closed = false;

/**
* Creates a <code>FileInputStream</code> by
* opening a connection to an actual file,
* the file named by the path name <code>name</code>
* in the file system. A new <code>FileDescriptor</code>
* object is created to represent this file
* connection.
* <p>
* First, if there is a security
* manager, its <code>checkRead</code> method
* is called with the <code>name</code> argument
* as its argument.
* <p>
* If the named file does not exist, is a directory rather than a regular
* file, or for some other reason cannot be opened for reading then a
* <code>FileNotFoundException</code> is thrown.
*
* @param name the system-dependent file name.
* @exception FileNotFoundException if the file does not exist,
* is a directory rather than a regular file,
* or for some other reason cannot be opened for
* reading.
* @exception SecurityException if a security manager exists and its
* <code>checkRead</code> method denies read access
* to the file.
* @see java.lang.SecurityManager#checkRead(java.lang.String)
*/
public FileInputStream(String name) throws FileNotFoundException {
this(name != null ? new File(name) : null);
}

/**
* Creates a <code>FileInputStream</code> by
* opening a connection to an actual file,
* the file named by the <code>File</code>
* object <code>file</code> in the file system.
* A new <code>FileDescriptor</code> object
* is created to represent this file connection.
* <p>
* First, if there is a security manager,
* its <code>checkRead</code> method is called
* with the path represented by the <code>file</code>
* argument as its argument.
* <p>
* If the named file does not exist, is a directory rather than a regular
* file, or for some other reason cannot be opened for reading then a
* <code>FileNotFoundException</code> is thrown.
*
* @param file the file to be opened for reading.
* @exception FileNotFoundException if the file does not exist,
* is a directory rather than a regular file,
* or for some other reason cannot be opened for
* reading.
* @exception SecurityException if a security manager exists and its
* <code>checkRead</code> method denies read access to the file.
* @see java.io.File#getPath()
* @see java.lang.SecurityManager#checkRead(java.lang.String)
*/
public FileInputStream(File file) throws FileNotFoundException {
String name = (file != null ? file.getPath() : null);
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkRead(name);
}
if (name == null) {
throw new NullPointerException();
}
if (file.isInvalid()) {
throw new FileNotFoundException("Invalid file path");
}
fd = new FileDescriptor();
fd.attach(this);
path = name;
open(name);
}

/**
* Creates a <code>FileInputStream</code> by using the file descriptor
* <code>fdObj</code>, which represents an existing connection to an
* actual file in the file system.
* <p>
* If there is a security manager, its <code>checkRead</code> method is
* called with the file descriptor <code>fdObj</code> as its argument to
* see if it's ok to read the file descriptor. If read access is denied
* to the file descriptor a <code>SecurityException</code> is thrown.
* <p>
* If <code>fdObj</code> is null then a <code>NullPointerException</code>
* is thrown.
* <p>
* This constructor does not throw an exception if <code>fdObj</code>
* is {@link java.io.FileDescriptor#valid() invalid}.
* However, if the methods are invoked on the resulting stream to attempt
* I/O on the stream, an <code>IOException</code> is thrown.
*
* @param fdObj the file descriptor to be opened for reading.
* @throws SecurityException if a security manager exists and its
* <code>checkRead</code> method denies read access to the
* file descriptor.
* @see SecurityManager#checkRead(java.io.FileDescriptor)
*/
public FileInputStream(FileDescriptor fdObj) {
SecurityManager security = System.getSecurityManager();
if (fdObj == null) {
throw new NullPointerException();
}
if (security != null) {
security.checkRead(fdObj);
}
fd = fdObj;
path = null;

/*
* FileDescriptor is being shared by streams.
* Register this stream with FileDescriptor tracker.
*/
fd.attach(this);
}

/**
* Opens the specified file for reading.
* @param name the name of the file
*/
private native void open0(String name) throws FileNotFoundException;

// wrap native call to allow instrumentation
/**
* Opens the specified file for reading.
* @param name the name of the file
*/
private void open(String name) throws FileNotFoundException {
open0(name);
}

/**
* Reads a byte of data from this input stream. This method blocks
* if no input is yet available.
*
* @return the next byte of data, or <code>-1</code> if the end of the
* file is reached.
* @exception IOException if an I/O error occurs.
*/
public int read() throws IOException {
return read0();
}

private native int read0() throws IOException;

/**
* Reads a subarray as a sequence of bytes.
* @param b the data to be written
* @param off the start offset in the data
* @param len the number of bytes that are written
* @exception IOException If an I/O error has occurred.
*/
private native int readBytes(byte b[], int off, int len) throws IOException;

/**
* Reads up to <code>b.length</code> bytes of data from this input
* stream into an array of bytes. This method blocks until some input
* is available.
*
* @param b the buffer into which the data is read.
* @return the total number of bytes read into the buffer, or
* <code>-1</code> if there is no more data because the end of
* the file has been reached.
* @exception IOException if an I/O error occurs.
*/
public int read(byte b[]) throws IOException {
return readBytes(b, 0, b.length);
}

/**
* Reads up to <code>len</code> bytes of data from this input stream
* into an array of bytes. If <code>len</code> is not zero, the method
* blocks until some input is available; otherwise, no
* bytes are read and <code>0</code> is returned.
*
* @param b the buffer into which the data is read.
* @param off the start offset in the destination array <code>b</code>
* @param len the maximum number of bytes read.
* @return the total number of bytes read into the buffer, or
* <code>-1</code> if there is no more data because the end of
* the file has been reached.
* @exception NullPointerException If <code>b</code> is <code>null</code>.
* @exception IndexOutOfBoundsException If <code>off</code> is negative,
* <code>len</code> is negative, or <code>len</code> is greater than
* <code>b.length - off</code>
* @exception IOException if an I/O error occurs.
*/
public int read(byte b[], int off, int len) throws IOException {
return readBytes(b, off, len);
}

/**
* Skips over and discards <code>n</code> bytes of data from the
* input stream.
*
* <p>The <code>skip</code> method may, for a variety of
* reasons, end up skipping over some smaller number of bytes,
* possibly <code>0</code>. If <code>n</code> is negative, the method
* will try to skip backwards. In case the backing file does not support
* backward skip at its current position, an <code>IOException</code> is
* thrown. The actual number of bytes skipped is returned. If it skips
* forwards, it returns a positive value. If it skips backwards, it
* returns a negative value.
*
* <p>This method may skip more bytes than what are remaining in the
* backing file. This produces no exception and the number of bytes skipped
* may include some number of bytes that were beyond the EOF of the
* backing file. Attempting to read from the stream after skipping past
* the end will result in -1 indicating the end of the file.
*
* @param n the number of bytes to be skipped.
* @return the actual number of bytes skipped.
* @exception IOException if n is negative, if the stream does not
* support seek, or if an I/O error occurs.
*/
public native long skip(long n) throws IOException;

/**
* Returns an estimate of the number of remaining bytes that can be read (or
* skipped over) from this input stream without blocking by the next
* invocation of a method for this input stream. Returns 0 when the file
* position is beyond EOF. The next invocation might be the same thread
* or another thread. A single read or skip of this many bytes will not
* block, but may read or skip fewer bytes.
*
* <p> In some cases, a non-blocking read (or skip) may appear to be
* blocked when it is merely slow, for example when reading large
* files over slow networks.
*
* @return an estimate of the number of remaining bytes that can be read
* (or skipped over) from this input stream without blocking.
* @exception IOException if this file input stream has been closed by calling
* {@code close} or an I/O error occurs.
*/
public native int available() throws IOException;

/**
* Closes this file input stream and releases any system resources
* associated with the stream.
*
* <p> If this stream has an associated channel then the channel is closed
* as well.
*
* @exception IOException if an I/O error occurs.
*
* @revised 1.4
* @spec JSR-51
*/
public void close() throws IOException {
synchronized (closeLock) {
if (closed) {
return;
}
closed = true;
}
if (channel != null) {
channel.close();
}

fd.closeAll(new Closeable() {
public void close() throws IOException {
close0();
}
});
}

/**
* Returns the <code>FileDescriptor</code>
* object that represents the connection to
* the actual file in the file system being
* used by this <code>FileInputStream</code>.
*
* @return the file descriptor object associated with this stream.
* @exception IOException if an I/O error occurs.
* @see java.io.FileDescriptor
*/
public final FileDescriptor getFD() throws IOException {
if (fd != null) {
return fd;
}
throw new IOException();
}

/**
* Returns the unique {@link java.nio.channels.FileChannel FileChannel}
* object associated with this file input stream.
*
* <p> The initial {@link java.nio.channels.FileChannel#position()
* position} of the returned channel will be equal to the
* number of bytes read from the file so far. Reading bytes from this
* stream will increment the channel's position. Changing the channel's
* position, either explicitly or by reading, will change this stream's
* file position.
*
* @return the file channel associated with this file input stream
*
* @since 1.4
* @spec JSR-51
*/
public FileChannel getChannel() {
synchronized (this) {
if (channel == null) {
channel = FileChannelImpl.open(fd, path, true, false, this);
}
return channel;
}
}

private static native void initIDs();

private native void close0() throws IOException;

static {
initIDs();
}

/**
* Ensures that the <code>close</code> method of this file input stream is
* called when there are no more references to it.
*
* @exception IOException if an I/O error occurs.
* @see java.io.FileInputStream#close()
*/
protected void finalize() throws IOException {
if ((fd != null) && (fd != FileDescriptor.in)) {
/* if fd is shared, the references in FileDescriptor
* will ensure that finalizer is only called when
* safe to do so. All references using the fd have
* become unreachable. We can call close()
*/
close();
}
}
}
0
  • 답변 23

  • byungil
    433
    2017-10-26 16:15:10

    귀신의 소행이군요 !

  • 공부중인학생
    18
    2017-10-26 16:16:30

    저게 무슨내용의 코드인가요....ㅎㄷㄷㄷ.ㄷ......ㅠㅠ무서워여

  • Courage
    2k
    2017-10-26 16:16:58

    ㅋㅋㅋㅋ 툴 사용법을 좀 더 익히심이...

  • 구구구구우
    1k
    2017-10-26 16:19:26
    JDK 기본으로 내장된 코드인데요, 
  • 꾸아앙
    1k
    2017-10-26 16:21:05

    해커가 주석까지 친절하게 달아주셨군요

  • 가난디지털단지
    151
    2017-10-26 16:21:48

    고스트 코딩왕 ㅋㅋㅋㅋ

  • 공부중인학생
    18
    2017-10-26 16:21:50
    ㅠㅠ갑자기 화면봤는데 마우스혼자움직이면서 저런코드가 쓰여져있어서 놀랬네요... 그러면 해킹은 아닌가요...저혼자만 무서운건가요..ㅠ
  • iops
    1k
    2017-10-26 16:22:04

    우렁각시인가

  • ktsedd
    6k
    2017-10-26 16:27:05

    ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ고스트 코딩왕

    상사의 모략으로 죽게된 30년차개발자가

    코딩훈수를 두기위해 저승에서 올라옴


  • 청솔모
    367
    2017-10-26 16:44:56

    ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ 웃고갑니닼

  • mjxaone
    33
    2017-10-26 16:54:56 작성 2017-10-26 16:55:15 수정됨

    해킹입니다. 포멧하세요.(진지, 근엄)

    ....

    ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ(귀여워...윽...)

  • shaffron
    4k
    2017-10-26 17:14:06

    인텔리제이가 그런지는 잘 모르겠는데 일정시간동안 입력 없으면 화면보호기처럼 캐릭터가 장난을 한다던가 겪으신 상황처럼 장난치는 경우가 종종 잇는데 그런경우가 아닌가 합니다 ㅋㅋ

    제가 쓰는 SSH 터미널 프로그램은 일정시간동안 입력이 없으면 펭귄들이 드릴들고 와서 코드를 뚫어버리더군요 ㅋㅋㅋ

  • onimusha
    8k
    2017-10-26 17:23:05

    착한 개발자님을 위해 하늘에서 코딩각시를 내려주셨어요..

  • 아스키
    10k
    2017-10-27 00:07:48

    포맷하세요..컴퓨터가 맛이 갔습니다...인공지능 탑재중...인듯..

  • DHS
    463
    2017-10-27 09:11:28

    ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ앜ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ


  • 초코쪼꼬
    6k
    2017-10-27 10:43:56


  • theFluker
    212
    2017-10-27 17:09:12
    ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ 귀여우신분
  • syubrofo
    225
    2017-10-27 19:24:24

    shaffron 님 어떤 SSH 터미널 프로그램 사용하시나요? 펭귄들이 나오는게 보고 싶네요 ㅋㅋㅋ

  • lllllllllllllll
    8k
    2017-10-28 01:05:22

    코딩요정 ㅋㅋㅋㅋㅋㅋㅋㅋ

  • SlowGun
    34
    2017-10-28 10:18:52

    덕분에 뜻밖에 웃고 갑니다 :)

    댓글들로 어느 정도 감은 잡으신듯 하니...

    안심하고 좋은 주말 보내세요 ㅎㅎ

  • 팥빙수
    888
    2017-10-29 16:25:47

    ㅋㅋㅋㅋ 암것도 아닌 상황인거 같긴한데, 진지하게 처음부터 설명 해주실 분 없나요?

    그래도 궁금하네요. 정확히 뭐 때문인지. shaffron 님의 설명보다 좀더 자세히... ㅎ

  • theFluker
    212
    2017-10-30 10:43:48
    개발자들보고 일하라고 넣어둔 이스터에그 같은거에요~
  • shaffron
    4k
    2017-10-30 13:12:00 작성 2017-10-30 13:51:14 수정됨

    aka5's // MobaXterm 이라는 프로그램입니다.

    5분인가.. 10분인가 입력없으면 펭귄들이 머리에 프로펠러 돌리면서 천천히 내려오다가

    글자 만나면 사정없이 드릴로 뚫어버립니다. ㅋㅋㅋ

  • 로그인을 하시면 답변 을 등록할 수 있습니다.