יום שבת, 22 בפברואר 2014

SmoothWall Router Guide




זהו, הגעתי למאמר האחרון בסדרה של Cloud Solutions, בסדרה הדגמתי כיצד לבנות ענן בעזרת מערכות Open Source בלבד שנותנות מענה בכל שכבה ,משלב האחסון, הוירטואליזציה ואיזון עומסים, השלב האחרון הוא התקשורת עם העולם החיצון ואבטחת המידע, קיימות המון מערכות הפעלה לניהול ראוטרים עם Firewall מבוססות Linux שמאפשרות לשמור על הסביבה מסכנות מבחוץ.

Setup

שלב ההתקנה שכרגיל חוזר על עצמו נוריד את ה ISO מהאתר, נצרוב ונתחיל לרוץ...

חלון פתיחה מרשים

יצירת הדיסק 

העתקת הקבצים



אפשרות לעשות שחזור של המערכת עם הגדרות ישנות



Network Settings

ניתן שם למכונה ואח"כ נבחר את סוג הפוליסה, יש 3 תבניות מוכנות מראש:
  • Open - כל הבקשות החוצה יוצאות ללא הפרעות.
  • Half-Open - חלק מהבקשות יוצאות החוצה, בקשות מסוכנות נופלות.
  • Closed - אף בקשה לא יוצאת החוצה ויש לפתוח ידנית.

שם למכונה

סוג הפוליסה

לאחר מכן נפתח תפריט שמגדירים בו את התקשורת, תחילה נבחר ב Network Configuration Type שמאפשר לבחור את התצורה של המערכת, הדגש במקרה הזה הוא כמובן על כמות הממשקים (Interfaces) הפיזיים שיש במכונה למשל נוכל להוסיף Wifi כ Access Point או DMZ.

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



בסיום נחזור לתפריט הראשי ונבחר באפשרות Card Assignments, נגדיר את החיבור בין ה Interface לכרטיסי רשת.


כפי שניתן לראות קיימים 2 ממשקים שמחולקים לצבעים:

  • Green - הממשק של ה Deep Web מאחורי Smooth Wall.
  • Red - הממשק החיצוני, לצורך הדוגמה הוא מתחבר לנתב אחר ויוצא ממנו לאינטרנט.


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




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



שימו לב! - במקרה שבחרנו להשתמש בכתובת סטטית יש להגדיר Dns / Gateway.

בסיום נפתח התפריט המרכזי שדרכו מנהלים את ה Router רוב האפשרויות ניתנות לשינוי בסביבת ה Web, הדבר האחרון שנשאר הוא לתת סיסמאת ניהול ולהיכנס לממשק בדפדפן.



Web Interface
ניכנס לכתובת של ה Default Gateway בפורט 81 לממשק ניהול.

קצת יותר נוח


לצורך הדוגמה הפעלתי שרת Fedora עם Apache והגדרתי כתובת סטטית (10.10.10.5) עם Default Gateway לממשק הירוק (10.10.10.254).



נחזור לממשק ה Web ונלחץ על Networking - Incoming ונגדיר את השירות שברצוננו לחשוף:



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



 שימו לב!

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


סיכום

SmoothWall זה לא ה Firewall הכי מתקדם אבל הוא עושה את העבודה, הוא מגיע בגרסה 64\x86 כך שניתן להתקין אותו על כל מחשב שאין בו שימוש ולהפוך אותו ל Router עצבני, הוא מכיל בתוכו אפשרויות נוספות כמו VPN ו IPS אבל את זה אני משאיר לכם, אפשר לומר שהשלמנו את החוליה האחרונה בענן ולא שלמנו שקל על אף רישיון והכל בזכות Linux ו Open Source.

מבנה הענן הסופי



מי רצה ענן ולא קיבל?

יום רביעי, 12 בפברואר 2014

Managed / UnManaged Code




לאורך הבלוג נזרק המושג Managed Code מספר פעמים ולא יותר מידי הרחבתי עליו , אבל מסתתר מאחוריו פואנטה שכדאי להכיר ולכן החלטתי לכתוב מאמר קצרצר שיסביר את הנושא למרות שכבר עברתי עליו בצורה כזאת או אחרת בבלוג, החיבור בין 2 שיטות ריצה שונות מאפשר יצירת תוכניות מורכבות שמאפשרות ניצול של 2 פלטפורמות שונות זו מזו, לדוגמה האפשרות לכתוב שכבה שעובדת מול Win32 API שלא ניתן לגשת אליה באופן חופשי מ .Net כפי שכבר הראתי בעבר ב Personal Firewall.


Managed Code

סביבת .Net מוגדרת כ Manage Code ומזכירה בהתנהגות שלה את Java בכך שב 2 הסביבות נוצר חדר נקי שמאפשר לקוד לרוץ ללא הפרעות, במקרה של .Net אומנם נוצר קובץ EXE בסוף התהליך, אך כאשר מפעילים אותו הוא מפעיל מערכת שלמה מאחורי הקלעים על מנת שיוכל לרוץ, כאשר הקובץ נוצר, הוא נשמר בשפת בניים הנקראת IL ועובר למנגנון CLR ומשם ל JIT כפי שכתבתי במאמר Managed .Net RootKit, לכן זה לא באמת קוד מכונה, הוא נהפך לקוד מכונה תוך כדי ריצה.

UnManaged Code

זה קוד שנהפך לקוד מכונה ברגע שמבצעים את ה Compile ומאותו רגע הוא יכול לרוץ ולכן מהיר יותר, בדר"כ נכתוב אותו ב ++C/ C ונשתמש ב Compilers ותיקים בתחום, לא קיים חדר נקי ולכן התוכניות עלולות לגרום נזק למערכת הפעלה ישירות, בדרך כלל נשתמש בו כאשר נרצה לדבר ישירות עם ה Win32API או לשפר ביצועים, השפה שנהנת מכל העולמות היא ++C שמאפשרת כתיבת קוד משולב.

שימו לב! - ב Managed Code קיים מנגנון ה Garbage Collector שמשחרר זיכרון באופן עצמי גם אם לא שחררתם אותו בעצמכם לעומת זאת ב UnManaged Code הוא לא קיים ואחריות שחרור הזיכרון היא על המפתחים בלבד.

בדוגמה הבאה אני ידגים כיצד לחבר בין אפליקציית .Net עם פונקציות שנכתבו ב  ++C/ C, תחילה נתמקד ב UnManaged Code שאותו אני אכתוב ב ++C בעזרת Visual Studio.

dllctest.h

//in C++ we can have functions with the same name,
//the compiler create unique name for each function, 
//in C is not possible to have different functions with the same name, 
//the extern "C" tell the compiler to keep the name as is like in C
//be aware from functions with the same name!.
extern "C" {
//exported function signature,
//__declspec tell to compiler to expose the function
__declspec(dllexport)   char *  getString(void);
__declspec(dllexport)   void  setString(char * data);
}


dllctest.cpp

//dllctest.cpp : Defines the exported functions for the DLL application.
#include "stdafx.h"
#include "dllctest.h"

static char * sdata;

//tell to compiler someone else going to use this method
extern char * getString(void)
{
return sdata;
}

//tell to compiler someone else going to use this method
extern void setString(char * data)
{
sdata = data;
}

יש מספר מילים שמורות שאומרות ל Compiler שמדובר על פונקציות שמשהו אחר (חיצוני) הולך להשתמש בהם, ומאפשרות לחשוף אותן החוצה, בגלל שהקוד עצמו  ב ++C חשוב להגיד ל Compiler שישמור על השמות של הפונקציות כמו שהם בדומה להתנהגות של C כי אחרת הוא ממציא להן שמות בעצמו.

שימו לב! - חשוב מאוד שהשמות של הפונקציות לא יחזרו על עצמן, ב C זה בלתי אפשרי אבל ב ++C זה אפשרי ועלולה להיות התנגשות בין הפונקציות.

dllctestcs.cs

class Program
{
        //call to external function from dll 
        //using the same signature from the dll
        [DllImport(@"C:\inetpub\wwwroot\dllctest\Debug\dllctest.dll", CharSet = CharSet.Unicode)]
        extern static void setString(string data);

        [DllImport(@"C:\inetpub\wwwroot\dllctest\Debug\dllctest.dll",CharSet=CharSet.Unicode)]
        extern static string getString();

        static void Main(string[] args)
        {
            setString("HI");

            Console.Write(getString());

            Console.ReadLine();
        }
    }
על מנת לדבר עם ה DLL שיצרנו נשתמש ב (Platform Invocation Services (PInvoke , מנגנון שמגיע עם .Net שמאפשר לטעון DLL של UnManaged Code תוך כדי ריצה, במקרה שלנו אנחנו מעבירים מחרוזות לכן חשוב להגדיר את סוג הקידוד.

סיכום

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

השילוב הראוי...