Forensics: แกะรอยอีเมล์?

WARNING: บทความ (อะไรก็ไม่รู้) นี้อาจมีเนื้อหาที่คล้ายการส่งเสริมการกระทำผิดกฎหมายหรือข้อบังคับของบ้านเมือง ซึ่งผู้เขียนไม่สนับสนนให้ผู้อ่านกระทำตาม บทความนี้มีไว้เพื่อการศึกษาเท่านั้น -- end warning

เคยสงสัยกันไหมครับว่า อีเมล์ที่คนนั้นคนนี้ส่งมา เขาส่งกันมาจากไหน ส่งกันได้ยังไง บางที เราได้เมล์จากใครก็ไม่รู้ หรือต้องการ (เจือก) อะไรบางอย่างจากจดหมายแต่ละฉบับ จริงๆ มันทำได้ครับ แต่บอกนิดเดียวก็แล้วกัน

หลักการเบื้องต้น: คิดว่ามันเป็นจดหมายธรรมดา โดยให้ผู้ส่งหย่อนใส่ตู้ ให้ไปรษณีย์เป็น Mail Server (SMTP) ให้ ตู้ ปณ ฝั่งผู้รับเป็น Mail Server อีกตัว (POP/IMAP ฝั่งผู้รับ) (ต้องเป็น ปณ นะครับ ไปรษณีย์ธรรมดามันไม่ได้มโณภาพ จริงๆ นะ)

เวลาเราส่งจดหมาย เราไม่ได้ส่งไปแต่จดหมาย แต่เราส่งข้อมูลเกี่ยวกับจดหมายไปด้วย (เช่น ชื่อผู้ส่ง จ่าหน้าถึงใคร วงเล็บมุมซองว่าอะไร ติดสแตมป์กี่บาท (เกี่ยวมั้ย =__=") ส่งเมื่อไหร่ (ปั๊มจากไปรษณีย์) ) เป็นต้น ใครไม่เคยเห็นจดหมาย (ผมเชื่อว่ามันต้องมี ไม่เป็นไรครับ เกิดมาผมส่งจดหมายไม่ถึงสิบฉบับตามที่โรงเรียนสั่ง และได้รับแต่พัสดุตามที่สั่งรับไว้) ก็ลองไปขอจากครูหรืออาจารย์ที่มีอายุหน่อยนึง หรือเปิดหนังสือเรียนภาษาไทยดูได้ครับ (ผมมั่นใจว่ามันมีแน่ๆ) จะได้เข้าใจตรงกัน

เอาละพอแล้ว ตรูเขียนเรื่อง Email นิ ไม่ใช่ สปช หรือ หลักภาษาไทย ซะหน่อย =__="

เอาเป็นว่า เวลาที่เราส่ง Email ออกไป (ผ่าน SMTP Server หรือตู้ไปรษณีย์) (สังเกตนะครับว่าจริงๆ แล้วเราไม่ต้องมี email account ก็ส่งได้) เราจะส่งข้อความเหล่านี้ออกไปให้กับ SMTP Server เป็นพื้นฐานสุดครับ ตัวอย่างคำสั่ง SMTP (ใสโดย "Win-Start" -> Run -> CMD -> "telnet <server> <smtp port>" แต่ต้องไปหา Mail Server มาลงก่อนนะครับ)

ตัวอย่างนี้คือ ผมส่งข้อความทดสอบ (นี่มันไม่ได้ทดสอบแล้วละ) ไปให้ "kyon" ที่เป็นสมาชิกของ "localhost" (ถ้าชื่อใครมันคุ้นๆ ก็อย่าว่ากันนะครับ)

HELO localhost
MAIL From:<admin@thaimodz.net>
RCPT To:<kyon@localhost>
DATA
Subject: About your Folder
Haruhi has known about your... secret... folder about Mikuru. Please be aware around both of them.
.
QUIT

ครับ แค่นี้เราก็ส่งอีเมล์ได้แล้ว สังเกตบรรทัด MAIL From: นะครับ จริงๆ ผมจะใส่เป็นชื่อใครก็ได้ จะ DSI คมช ฯลฯ ได้หมดครับ (แต่เขาจะเชื่อหรือไม่ก็อีกเรื่องนึง)

สังเกตว่า กว่าผมจะได้เขียนจดหมายจริงๆ ก็ต้องลงชื่อผู้ส่งและจ่าหน้าซองก่อน พอเขียนเสร็จก็ต้องใส่ซองติดแสตมป์ให้เรียบร้อย (สังเกตตัว . (จุด) ให้ดีครับ เป็นคำสั่ง "เลิกเขียนจดหมาย" ของ SMTP) บรรทัดก่อนนั้นใช้เป็นข้อมูลของจดหมายทั้งสิ้น

คราวนี้เรามาดูที่ฝั่งผู้รับ ผมใช้โปรแกรม James ในการรัน Mail Server (เป็น Java) จึงได้เนื้อหามาแบบนี้ครับ โดยอันนี้ไป "งัดแงะ" มาจากคลังไฟล์โดยตรง

Return-Path: <admin@thaimodz.net>
Received: from localhost ([127.0.0.1])
by thaimodz (JAMES SMTP Server 2.2.0) with SMTP ID 11
for <kyon@localhost>;
Thu, 10 May 2007 08:58:56 +0700 (ICT)
Subject:555
Date: Thu, 10 May 2007 08:58:56 +0700 (ICT)
From: admin@thaimodz.net
Delivered-To: kyon@localhost
Content-Transfer-Encoding: quoted-printable
Content-Type: text/plain; charset=Cp1252
Mime-Version: 1.0
Message-ID: <31131058.1178762370671.javamail.thaimodz@thaimodz>

Haruhi has known about your... secret... folder about Mikuru. Please be aware around both of them.

ลองสังเกตดูก็จะเห็นว่า ทาง James (ชื่อ Mail Server) ได้เพิ่มหัวจดหมายไปเยอะพอสมควร หากตั้งใจอ่านดูดีๆ ก็จะเห็นถึง ชื่อ Mail Server ที่ส่งออกมา (กรณีนี้ loopback อยู่ในเครื่องตัวเอง จึงเป็น Localhost) และชื่อผู้ส่งยังไปตกใน reply-to อีกด้วย ซึ่งจะถูกใช้เมื่อมีการตอบอีเมล์นี้

แน่นอน ข้อมูลที่เราย่อมสนใจคือ ผู้ส่งอยู่ที่ไหน แต่ James ก็ใส่มาเพียงแค่เวลา กับ Time Zone เท่านั้น ซึ่งจัดว่าคลุมเครือมากสำหรับการส่งอีเมล์ ทีนี้ผมจะให้ดูหัวแบบ X-header บางส่วนที่นำมาจาก Inbox บ้างครับ (ปรุงแต่งเพื่อรักษาสิทธิส่วนบุคคลแล้ว เนื่องจากหยิบของเพื่อนมา)

X-Originating-IP: [158.108.XXX.XXX]
X-Originating-Email: [undisclosed_name@some-mail-server.com]

สังเกต บรรทัด X-originating-IP ซึ่ง Mail Server แห่งหนึ่งได้ "ยัด" มาให้ด้วย อ่านเอาก็รู้ว่านี่คือการเก็บ Log ของ Mail Server ที่ส่งออกมาแน่นอนโดยไม่ต้องสงสัย ก็ไป Map หรือ Tracert หาเองนะครับว่าเมล์ของท่านน่ะ มันมาจากไหน?

(ว่ามันส่งมาจาก ม.เกษตร แต่... เอ่อ ช่างเหอะ เรื่องส่วนตัวห้ามปนกับเรื่องงาน เออน่า ไม่ใช่แฟนหรอก =__=")

เอาละ สรุปว่า เราไม่สามารถตรวจหาแหล่งที่มาได้ชัดเจน จนกว่า... (เรียงตามความละเอียด น้อยไปมาก)

1. เราได้ข้อมูลจาก Header
2. เรามีข้อมูลมากพอ เช่น สำนวน ภาษา เวลาที่ส่ง Time Zone หรือแม้กระทั่ง IP ของ SMTP Server
3. SMTP Server "ใจดี" ส่ง Originating IP มาให้ด้วย (แม้ไม่ใช่บริษัทเครือข่ายมือถือก็ตาม)
4. เราสามารถเข้าไปอ่าน Access Logs แล้วตาม IP Address กลับไปได้ (ไว้เขียนวันหลังนะครับ)


DEDICATION:
ให้ท่าน "ผู้จัดการ" ที่สงสัยเกี่ยวกับระบบอีเมล์อย่างแรง จนป๋มเกิดแรงบันดาลใจเขียนไอ้ข้อความอะไรก็ไม่รู้นี่ขึ้นมา!!!


.... อ้อ นี่คือภาคต่อของจดหมายฉบับนั้นครับ!! (คิดซะว่าเป็น exercise ละกัน)
(DISCLAIMER: เนื้อหานี้เพื่อความสะใจส่วนบุคคล ไม่มีส่วนเกี่ยวข้องกับองค์กร บุคคล โรงเรียน หรือ "พระเจ้า" ใดๆ ทั้งสิ้นเด็ดขาด!)

Return-Path: <suzumiya_haruhi@sosdan.northhigh.ac.jp>
Received: from localhost ([127.0.0.1])
by thaimodz (JAMES SMTP Server 2.2.0) with SMTP ID 291
for <kyon@localhost>;
Tue, 15 May 2007 23:41:28 +0700 (ICT)
Subject:Die Kyon DIE!!!
You think that agent you hired could protect you and your filthy actions from the god like me? WRONG! Now you wait there and prepare yourself for CAPITAL PUNISHMENT!
Date: Tue, 15 May 2007 23:41:28 +0700 (ICT)
From: suzumiya_haruhi@sosdan.northhigh.ac.jp
Delivered-To: kyon@localhost
Content-Transfer-Encoding: 7bit
Content-Type: text/plain; charset=us-ascii
Mime-Version: 1.0
Message-ID: <24569170.1179247304968.javamail.thaimodz@thaimodz>

บายจ้า~! ^__^

JAVA : Tomcat is not a Cat (Brief)

เอาละ วันนี้ข้าน้อยเบื่ออีกแล้ว (เอาไงกันเนี่ย เบื่อง่ายจัง) ก็เลยว่าจะมาลง blog ให้นิดหน่อยครับ เรื่อง Tomcat (ไม่ใช่ Tom Cat ที่กัดกับ Jerry Mouse แล้วแพ้ตลอดนะครับ เจ้านี้ชนะเรื่อง Java Server ด้วยซ้ำ)

ก็ขอบอกอีกทีว่าไม่ได้เก่งอะไรมากมายนะครับ ก็อาจพลาดหรือตกหล่นอะไรได้ ก็เพิ่มลงไปใน comment ได้เลยครับ แล้วจะ update ให้ถูกต้องอีกที

ในปัจจุบัน ตลาดโปรแกรมมีการแข่งขันกันมากขึ้น ทำให้ต้องมีการพัฒนาโปรแกรม และภาษาโปรแกรมให้ดีขึ้นกว่าคู่แข่งเสมอ มีช่วงหนึง ตั้งแต่การถือกำเนิดของ Java กับ Concept ว่า "Write once, Run anywhere" (ไม่ถูกนักหรอกครับ) การเขียนโปรแกรมก็ไปทำบนเว็บมากขึ้น

Microsoft มี ASP แล้ว Sun ก็เลยมี JSP ด้วย ทั้งสองอย่างเป็นโปรแกรมที่รันจาก server ทั้งสิ้น

จริงๆ แล้ว Tomcat นั้น เป็น project ของ Jakarta (สาขาย่อยของ Apache นะครับ ไม่ใช่ Indonesia) ซึ่งเป็นสาขาที่ทำงานเกี่ยวกับ Java ของทาง Apache เอง (เจ้าของ "Apache Server" ที่เป็นที่นิยมมากที่สุดในปัจจุบัน) แต่จากความน่าจนใจและคุณภาพของงาน ทำให้ Jakarta Tomcat ได้เลื่อนยศเป็น Apache Tomcat ในที่สุด

ที่ควรรู้คือ Tomcat นั้น ก็เป็น Web Server กลายๆ ด้วย (แม้ว่าเขาจะไม่ใช้กันก็เถอะ) เพราะฉะนั้น อย่าเพิ่งไปรัน Server app อื่นๆ ถ้ามี เพราะ port จะชนกัน ใช้ไม่ได้อีก

ทีนี้ การจะใช้ Tomcat นั้นไม่ค่อยยากนักครับ เพราะหลักๆ แล้วจะเป็นเรื่องของการเขียน code ที่ยากกว่า เพราะต้องมีเรื่องของลักษณะการทำงานกับ server ที่ค่อนข้างเฉพาะกว่าการใช้ Applet (ซึ่งปัจจุบันเขา*แนะให้เลิกใช้ เพราะมันไม่ค่อยสะดวก)

ส่วนในหลักการทำงาน Tomcat สามารถรับเอา Web app ใหม่เข้ามารันได้เลย โดยหากเรานำไฟล์ .war (ก็คือ .jar ที่ rename ใหม่) มาวางใน %Tomcat_dir%/webapps/ (ตรงที่มี ROOT) ในขณะที่ Tomcat กำลังทำงานอยู่ มันจะโหลดเอา war เข้าไปเองโดยไม่ต้อง reset Tomcat เลย

ยังไม่หมดครับ Tomcat ยังมี port ฉุกเฉิน สามารถตัดระบบได้ง่าย โดยเข้า telnet ไปที่ port 8005 แล้วสั่ง SHUTDOWN ได้ทันที

ในแต่ละ Web app ก็ยังมี folder ชื่อ WEB-INF (ซึ่งต้องมี และ case sensitive) สำหรับเก็บ classes และ jars รวมไปถึง config และไฟล์อื่นๆ ที่เราต้องการเก็บเป็นความลับด้วย (โดยเรียกเอาจากโปรแกรมได้อย่างเดียว)

อ้อ เกือบลืมไป help และ docs มีติดมากับ Tomcat แล้วนะครับ ไม่ต้องไปหาเพิ่ม

เอาเป็นว่า วันนี้เหนื่อยมากแล้วครับ (เหนื่อยง่ายจังเรา) เพราะเพิ่งได้ Java Workshop certificate จาก Software Park มาหมาดๆ (แต่ก็ยังถ่ายทอดเนื้อหาห่วยแตกเหมียนเดิม T_T)

สุดท้ายนี้ ก็ขอให้โชคดีนะครับ จบแล้ว เหอๆๆๆ = ="

* "เขา" คือ ดร.วีระศักดิ์ ซึงถาวร ครับ

JAVA : GUI Basics

วันนี้ข้าน้อยรู้สึกเบื่อๆ ครับ ก็เลยมาโพสซะหน่อย เนื้อหาคงวกไปวนมาหน่อยนะครับ (เอาเรื่องยากมาลงก่อนนิ) แต่คงเป็นประโยชน์สำหรับคนที่กำลังทำ GUI อยู่นะครับ

เวลาเราเขียนโปรแกรม เราใช้คนเดียว เราใช้รับ String args[] เอาก็ได้ใช่ไหมครับ แต่ว่าเวลาเอาไปให้คนอื่นใช้ ถ้าเขาเป็น End User ก็คงใช้ไม่ถูก

ยิ่งสมัยก่อน ระบบเป็นแบบ Text-Based (เช่น สมัย DOS) แน่นอน GUI ไม่มีเลย ทุกอย่างใช้การส่งค่าเข้าไปในโปรแกรมตรงๆ ตลอด ตัวอย่างก็เช่น ping, tracert ก็ต้องระบุ IP ของเป้าหมายลงไป ก็ถือเป็นการส่งค่า parameter อย่างหนึ่ง

ต่อมา ในสมัย Windows ก็ได้เกิดการใช้สัญลักษณ์และภาพ หรือเมนู ในการแสดงผล และรับคำสั่งจากผู้ใช้ จากนั้นมาจนถึงปัจจุบัน การใช้งานคอมพิวเตอร์ทำได้อย่างสะดวกสบาย อย่างตอนที่ผมกำลังพิมพ์บทความนี้อยู่ ผมก็กำลังพิมพ์ลงใน Text Box ซึ่งก็เป็นส่วนหนึ่งของ GUI ครับ

GUI ที่ดี จะต้องสวยงาม (อย่างน้อยก็เป็นระเบียบละ) ใช้งานได้ง่าย ทำงานได้รวดเร็วไม่หน่วงระบบ และไม่ทำให้เกิดความสับสนแก่ผู้ใช้ครับ (ถ้าเราสร้่าง Frame1 Frame2 Frame3 etc. แบบนี้พร้อมๆ กัน แถมมีปุ่มอะไรไม่รู้อีกเยอะแยะ User คงงงตาย กดไปจะระเบิดรึเปล่าเนี่ย)

เอาละ เกริ่นกันมามาก เดี๋ยวท่านๆ จะนึกว่าข้าน้อยกำลังบ่นแบบคนแก่ซะเปล่าๆ เอาเป็นว่ามาเริ่มกันเลยครับ

ระบบ GUI ของ Java นั้นมีลักษณะเฉพาะตัว ก็เนื่องมาจากการที่ Java มี JVM อยู่นั่นเอง ทำให้การทำงานมีขั้นตอนมากกว่า C อยู่พอสมควร

Components
Component ก็คือ "ชิ้นส่วน" บน Interface นั่นเอง เช่น Button, TextField, ฯลฯ ซึ่งจะต้องวางลงบน Frame หรือ Component อื่นที่มีคุณสมบัติเป็น Container (เช่น Frame, Window, Dialog, Panel)

ทุกอย่างจะต้อง "วาด" ลงบนวัตถุที่เป็น Top-Level ก็คือ พื้นหน้าจอต่างๆ นั่นเอง หากตัวเองไม่ใช่ Top-Level แล้ว ก็ทำได้แค่ใช้หน่วยความจำ จากนั้นค่อยวาดลงไปบน Top-Level Component อีกที


Layout Manager
Layout Manager ก็คือระบบที่ไว้ช่วยจัดวาง GUI ให้เรานั่นเอง Layout Manager มีสี่อย่างหลักๆ ได้แก่...

- FlowLayout เป็นการแบ่งหน้าจอเป็นบรรทัดๆ วางลงให้เต็มทีละบรรทัด (เรียงตามลำดับการ new Component) จัดกลางเสมอ
- BorderLayout แบ่งจอเป็นห้าส่วน ได้แก่ North, East, South, West และ Center. แต่ละ Region จะวางวัตถุได้แค่ชิ้นเดียว (ซึ่งแก้ได้ด้วยการใช้ Panel)
- GridLayout จะรับค่าจากผู้ใช้ แล้วแบ่งจอออกเป็นส่วนๆ ตามที่ผู้ใช้กำหนด แต่ละช่องมีขนาดเท่ากันเสมอ
- Null - ที่สุดแห่งกระบวนท่า คือไร้กระบวนท่า - ระบบนี้จะให้เราจัดวางตำแหน่งของวัตถุต่างๆ ได้อย่างอิสระ โดยใช้คำสั่ง <object>.setBounds (X,Y,Width,Height); ในการช่วยจัดวาง


Toolkits
ระบบดั้งเดิมสำหรับทำ Interface ก็คือระบบ AWT (Abstract Windowing Toolkit) ซึ่งมีมาใน JDK ตั้งแต่รุ่นแรกๆ มีคำสั่งพื้นฐานสำหรับการสร้าง Interface มาให้ (import java.awt.*;)

ข้อดีของ AWT นั้นคือสามารถใช้ฝึกได้ เพราะไม่มีการอำนวยความสะดวกมากนัก ทำให้ไม่ "รู้สึกสบายจนเคยตัว" และ AWT นั้น ก็คือรูปแบบที่เข้าใจง่าย รูปแบบเรียบๆ

ส่วนข้อเสียนั้น ก็คือ AWT ทำงานค่อนข้างช้าครับ AWT ทำงานโดยการ....

1. ส่งไปยัง JVM
2. JVM โหลดเข้า API (ซึ่งเป็นของ OS)
3. API ใช้ subroutine ของตัวเอง (หลายบรรทัดอยู่มาก) ในการ render ออกมาเป็นภาพ

จากขั้นตอนเหล่านี้ ทำให้ระบบ AWT ไม่ค่อยเป็นที่นิยมในปัจจุบัน

ต่อมาในยุค Java 1.1 ก็ได้เกิดระบบ Swing ขึ้น (เกิดจากภาพ animation เจ้า Duke โล้ชิงช้าในระบบ GUI ในสมัยนั้น จึงได้ชื่อนี้มา) ซึ่งหลักการแตกต่างออกไป คือ จะมีการใช้ Graphic Memory เข้าช่วย และไม่ได้ใช้ subroutine ของ OS โดยตรง ทำให้ลดภาระลงไป และที่มากไปกว่านั้นก็คือ Components ต่างๆ สามารถโหลดเข้า Graphic Memory ได้จาก JVM โดยไม่ต้องใช้ API ทำให้...

1. เร็วขึ้น เนื่องจากไม่หน่วงเครื่องด้วย subroutine มากมาย
2. Platform-Independent เนื่องจาก ใช้ API น้อยลง ทำให้รันบนระบบใดก็ได้ผลคล้ายกันมากๆ
3. เนื่องจากความเป็น Free Source ของ Java ทำให้ออกแบบ component ใหม่เองได้อีกมาก


ก็คงพอจะอ่านเล่นแก้เบื่อได้นะครับ หากมีอะไรเพิ่มเติมก็ใส่ได้เลยนะครับ เพราะว่าอันนี้หนักไปทางการบันทึกทบทวนหลังเรียนเฉยๆ วันไหนว่างๆ จะมาต่อเรื่อง Client/Server นะครับ