יום ראשון, 26 ביולי 2015

Java Native Interface


רוב האפליקציות ב Android משתמשות בספריות Java תחת ה JVM (ליתר דיוק Dalvik) ללא צרכים מיוחדים אבל בחלק מהמקרים זה לא מספיק ונדרשת התערבות עמוקה יותר, בדומה לאחד המאמרים בו הצגתי את JavaScript Interface גם פה מדובר בממשק שהמערכת נותנת שמאפשר לנו להתחבר לעולם ה Native במכשיר ולהפעיל דרכו ספריות בעזרת שפת C.

שימו לב!

  • המאמר נכתב על Android Studio 1.0.1
  • מערכת הפעלה Windows 7 64 Bit


אם לרגע חשבתם שמעכשיו תכתבו אפליקציות ב C אז כדאי שתעצרו (למרות שזה אפשרי אבל לא חבל..), לא בשביל זה יש את ה NDK אלא עבור מקרים מאוד מיוחדים כמו למשל מוגבלויות ה API של Java או יצירת ממשק עבור חומרה חדשה, יש שימוש רחב ב NDK בתעשיית המשחקים בגלל ממשק ל OpenGL רחב יותר,

דרישות
  • Native Development Kit - NDK
  • +Java Development Kit - JDK 1.8
  • +Gradle 2.2

יש להוריד ולפרוס את ה NDK היכן שתרצו (מומלץ לשמור איפה שתיקיית ה SDK), כדאי מאוד לוודא שיש לכם את גרסת Java אחרונה, גרסאות ישנות מידי עלולות לגרום לבעיות שלא נעים להתעסק בהן, לאחר מכן יש להוסיף את הנתיבים לתיקיית ה Java וה NDK למשתנה ה Path הכללי של המערכת שניתן להגיע אליו דרך Environment Variables שנמצא ב Advanced במסך של ה System Properties.

ניצור פרויקט חדש, נגדיר פונקצית Native שאת המימוש שלה נעשה ב C:

public native String getStringFromNative();


לאחר מכן נפתח Terminal ב Android Studio ,צריך לוודא שאתם בתיקיית Main של הפרויקט ולהריץ את הפקודה הבא:

E:\NDKtest3\app\src\main>javah -d jni -classpath E:\Users\proxytype\AppData\Local\Android\sdk\platforms
\android-14\android.jar;..\..\build\intermediates\classes\debug legend.proxytype.ndktest3.MainActivity

הפקודה תיצור תיקייה בפרויקט בשם JNI בתוכה קובץ Header שמכיל את החתימה לפונקציה, ניצור בה 2 קבצים חדשים, הראשון נקרא Application.mk שמכיל את הקוד הבא:

APP_ABI := all
APP_PLATFORM := android-14

השורה הראשונה מגדירה לאיזו ארכיטקטורת מעבד תתואם הספריה החיצונית (ה NDK מגיע עם כל סוגי ה Tool Chain) במקרה של ALL תיווצר ספריה עבור כל ארכטיקטורה, השורה השנייה עבור סוג הפלטפורמה של ה Android.

הקובץ השני נקרא Android.mk שמכיל את ההגדרות של הספריה בדומה ל Makefile סטנדרטי:

LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE    := MyLib
LOCAL_SRC_FILES := main.c
include $(BUILD_SHARED_LIBRARY)  

חשוב לזכור להמשך את 2 הפרמטרים הבאים, הראשון ה LOCAL_MODULE שהוא שם הספריה שנשתמש בו ב Java כפי שנראה בהמשך, ו LOCAL_SRC_FILES שמצביע לקובץ ה main.c שמכיל את המימוש לפונקציות בקובץ ה Header שנוצר בתחילת התהליך.

C

התוכנית תכיל פונקציה שתחזיר מחרוזת מספריית ה Native שנכתבה ב C לאפליקציה עצמה שנכתבה ב Java, יש ליצור קובץ main.c ולרשום בו את הקוד הבא:

 //our generated header file
#include "legend_proxytype_ndktest3_MainActivity.h"

JNIEXPORT jstring JNICALL 
Java_legend_proxytype_ndktest3_MainActivity_getStringFromNative(JNIEnv * env, jobject obj)
 {
        return (*env)->NewStringUTF(env,"Hello From JNI!");
 }
הקוד מאוד פשוט וניתן לראות את החשיפה של הפונקציה עבור מנגנון ה JNI והאפשרות לקרוא לה מבחוץ, קיים באג ב Android Studio שמחייב ליצור קובץ נוסף ריק על מנת שנוכל לבנות את הספריה.

Java

בשביל להפעיל את הפונקציה יש לטעון את הספריה באפליקציה עם השם שנתנו ב Android.mk, אח"כ נקרא לה ונקבל ממנה מחרוזת:

package legend.proxytype.ndktest3;

import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;

public class MainActivity extends Activity {

    //loading the library with the name from android.mk
    static
    {
       System.loadLibrary("MyLib");
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        TextView lbl_jni = (TextView)findViewById(R.id.lbl_jni);
        //make the call to function
        lbl_jni.setText(getStringFromNative());

    }

    public native String getStringFromNative();
}


Gradle

אם חשבתם שסיימנו אז עוד קצת וזה נגמר, יש לערוך את קובץ build.gradle על מנת שיבנה את הספריה באופן אוטומטי בכל בנייה מחדש של האפליקציה, יש לקרוא ל Module עם אותו שם של הספריה, ולהגדיר Task שיקרא ל Shell שיפעיל את ה NDK:

import org.apache.tools.ant.taskdefs.condition.Os

apply plugin: 'com.android.application'

android {
    compileSdkVersion 22
    buildToolsVersion "22.0.1"

    defaultConfig {
        applicationId "legend.proxytype.ndktest3"
        minSdkVersion 14
        targetSdkVersion 22
        versionCode 1
        versionName "1.0"

        ndk
         {
          //same as the name in android.mk
           moduleName "MyLib"
         }
    }

    sourceSets.main {
        jniLibs.srcDir 'src/main/libs'
        jni.srcDirs = [] 
    }

    //set task for the compilation of the library
    task ndkBuild(type: Exec) {
        //hadling different host machine
        if (Os.isFamily(Os.FAMILY_WINDOWS)) {
            commandLine('ndk-build.cmd', '-C' , file('src/main').absolutePath)
        } else {
            commandLine 'ndk-build', '-C', file('src/main').absolutePath
        }
    }

    //the build of the application depend on the success of the JNI
    tasks.withType(JavaCompile) {
        compileTask -> compileTask.dependsOn ndkBuild
    }

    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.android.support:appcompat-v7:22.2.0'
}

דבר אחרון לפני סיום הוא לוודא שתיקיית ה NDK מוגדרת ב Local.Properties של Gradle:

ndk.dir=E\:\\Users\\proxytype\\AppData\\Local\\Android\\ndk



מבנה האפליקציה אחרי כל הבלאגן

סיכום

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

100% טבעי...
פורסם על ידי ב- תגובה 1:
תוויות: , ,

יום שני, 13 ביולי 2015

MySql Proxy



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

דרישות:

שימו לב!
  • המאמר נכתב על Windows 7 64 Bit
לפני שנתחיל לצלול פנימה יש להוריד את ולפרוס את קבצי MySql Proxy באיזה מקום שתרצו על השרת, לאחר מכן יש להוריד ולהתקין את Lua, שפת סקריפטים מאוד מהירה, היא פופלרית בעיקר ב Embedded ומשחקי מחשב, היה בה שימוש רחב ב World Of Warcraft.

לצורך הדוגמה ניצור טבלה שתכיל מספרי אשראי ונעמיס עליה נתונים,נבצע שאילתה פשוטה:

בקשה ישירה למסד הנתונים

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

Proxy

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


על מנת להפעיל את ה Proxy יש לכתוב את הפקודה הבאה:

C:\mySqlProxy\bin>mysql-proxy.exe --proxy-backend-addresses=127.0.0.1:3306 --proxy-address=127.0.0.1:4040 --proxy-lua-script=all-hooks.lua

הפקודה מחברת את שרת ה Proxy למסד הנתונים ובנוסף מוסיפים קריאה לקובץ סקריפט של Lua, מאותו רגע כל בקשה שתגיע לפורט 4040 תפעיל מספר פונקציות ונוכל לדוג אותן, לדוגמה ברגע שיבצעו שיאלתא, הפונקציה read_query תרוץ ונוכל להחליט אם להעביר את השאילתא או לא ובמקרה של תשובה מהשרת הפונקציה read_query_result תרוץ ובה נוכל לשנות את המידע שחוזר.

Hooks


-- all-hooks.lua
local access_ndx = 0

-- fired when client connect to server
function connect_server()
    print_access ('inside connect_server')
end

-- fired when starting the handshake
function read_handshake( auth )
    print_access ('inside read_handshake' )
end

-- fired when starting the authentication
function read_auth( auth )
    print_access ('inside read_auth ')
end

--fired when authentication finished
function read_auth_result( auth )
    print_access ('inside read_auth_result')
end

--fired when client disconnected
function disconnect_client()
    print_access('inside disconnect_client')
end

--fired when query requested
function read_query (packet)
proxy.queries:append(1, packet,{ resultset_is_needed = true })
return proxy.PROXY_SEND_QUERY
end

--fired when query result
function read_query_result (inj)

--create result set containes columns and rows
proxy.response.resultset = {fields = {}, rows = {}}

--checking if the query holding creditcard table name
if(string.match(inj.query,"creditcard")) then

for n = 1, #inj.resultset.fields do
-- insert column to table
table.insert(proxy.response.resultset.fields, {type
             =inj.resultset.fields[n].type,name = inj.resultset.fields[n].name})
end


for row in inj.resultset.rows do
if(row ~= nil) then
 for i,v in pairs(row) do
--looking for creditcard pattern
if string.match(v,'%d%d%d%d%-%d%d%d%d%
                                                                 -%d%d%d%d%-%d%d%d%d') then
print_access("found visa - column position: " .. i 
                                                                      .. " column value: " .. v)
row[i] = "mask credit card"
end
 end
table.insert(proxy.response.resultset.rows, row)
end
end

--overwrite results
proxy.response.type = proxy.MYSQLD_PACKET_OK
return proxy.PROXY_SEND_RESULT
end
end

-- simple print message
function print_access(msg)
    access_ndx = access_ndx + 1
    print( string.format('%3d %-30s',access_ndx,msg))
end



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

התוצאות שחוזרות מה Proxy


סיכום

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

לא תשתמש בו?

פורסם על ידי ב- אין תגובות:
תוויות: , , ,

יום שבת, 7 במרץ 2015

Android Music Player



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

שימו לב!

  • המחלקה נכתבה על Android Studio.
  • המחלקה תואמת ל Api 14.
Music Search

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

    private class SongDetails {
        String songTitle = "";
        String songArtist = "";
        //song location on the device
        String songData = "";
    }

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

 private void getAllSongs()
    {
       //creating selection for the database
        String selection = MediaStore.Audio.Media.IS_MUSIC + " != 0";
        final String[] projection = new String[] {
                MediaStore.Audio.Media.DISPLAY_NAME,
                MediaStore.Audio.Media.ARTIST,
                MediaStore.Audio.Media.DATA};
        
        //creating sort by for database
        final String sortOrder = MediaStore.Audio.AudioColumns.TITLE
                + " COLLATE LOCALIZED ASC";

        //stating pointer
        Cursor cursor = null;

        try {
            //the table for query
            Uri uri = android.provider.MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
            // query the db
            cursor = getBaseContext().getContentResolver().query(uri,
                    projection, selection, null, sortOrder);
            if (cursor != null) {
                
                //create array for incoming songs
                songs = new ArrayList<SongDetails>(cursor.getCount());
                
                //go to the first row
                cursor.moveToFirst();

                SongDetails details;

                while (!cursor.isAfterLast()) {
                    //collecting song information and store in array,
                    //moving to the next row
                    details = new SongDetails();
                    details.songTitle = cursor.getString(0);
                    details.songArtist = cursor.getString(1);
                    details.songData = cursor.getString(2);
                    songs.add(details);
                    cursor.moveToNext();
                    
                }
            }
        } catch (Exception ex) {

        } finally {
            if (cursor != null) {
                cursor.close();
            }
        }
    }



Simple Player

עד עכשיו היה החלק הטכני שבו אנחנו מקבלים את חומרי הגלם ועכשיו אפשר להתחיל לעבוד איתם בעזרת מחלקה מאוד פשוטה שעושה פעולות (Stop, Play, Pause, Forward, Backward, Seek) כמו כל נגן סטנדרטי , על מנת לעדכן את ה Gui נעזר ב Interface משותף כפי שניתן לראות בדוגמה:

public interface OnPlayerEventListener {
    void onPlayerComplete();
    void onPlayerStart(String Title,int songDuration,int songPosition);
}


המחלקה מקבלת את המופע של ה Activity שמפעיל אותה, מאתחלים אותה עם רשימת השרים ששלפנו מה Database ומחכים לפקודות מה Gui.

public class simplePlayer
{
    OnPlayerEventListener mListener;
    Activity mActivity;

    //give access to the gui
    public ArrayList<songDetails> songs = null;
    public boolean isPaused = false;
    public int currentPosition = 0;
    public int currentDuration = 0;

    //single instance
    public static MediaPlayer player;

   //getting gui player interface
   public  simplePlayer(Activity ma)
   {
       mActivity = ma;
       mListener = (OnPlayerEventListener) mActivity;
   }

    //initialize the player
    public void init(ArrayList<songDetails>_songs)
    {
        songs = _songs;
        currentPosition = 0;


        if(player == null)
        {
            player = new MediaPlayer();
            player.setAudioStreamType(AudioManager.STREAM_MUSIC);
            player.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
                @Override
                public void onCompletion(MediaPlayer mp) {

                    player.stop();
                    player.reset();

                    nextSong();
                    mListener.onPlayerSongComplete();

                }
            });
        }
    }

    //stop the current song
    public void stop()
    {
        if(player != null)
        {
            if(player.isPlaying())
                //stop music
                player.stop();

            //reset pointer
            player.reset();
        }
    }

    //pause the current song
    public void pause()
    {
        if(!isPaused && player != null)
        {
            player.pause();
            isPaused = true;
        }
    }

    //playing the current song
    public void play()
    {
        if(player != null)
        {
            if(!isPaused && !player.isPlaying())
            {
                if(songs != null)
                {
                    if(songs.size() > 0)
                    {
                        try {
                            //getting file path from data
                            Uri u = Uri.fromFile(new File(songs.get(currentPosition).songData));

                            //set player file
                            player.setDataSource(mActivity,u);
                            //loading the file
                            player.prepare();
                            //getting song total time in milliseconds
                            currentDuration = player.getDuration();
                          
                            //start playing music!
                            player.start();
                            mListener.onPlayerSongStart("Now Playing: "
                                    + songs.get(currentPosition).songArtist
                                    + " - "+ songs.get(currentPosition).songTitle
                                    ,currentDuration,currentPosition);
                        }
                        catch (Exception ex)
                        {
                            ex.printStackTrace();
                        }
                    }
                }
                else
                {
                    //continue playing, reset the flag
                    player.start();
                    isPaused = false;
                }
            }
        }
    }

    //playing the next song in the array
    public  void nextSong()
    {
        if(player != null)
        {
            if(isPaused)
                isPaused = false;

            if(player.isPlaying())
                player.stop();

            player.reset();

            if((currentPosition + 1) == songs.size())
                currentPosition = 0;
            else
                currentPosition  = currentPosition + 1;

            play();
        }
    }

    //playing the previous song in the array
    public void previousSong()
    {
        if(player != null)
        {
            if(isPaused)
                isPaused = false;

            if(player.isPlaying())
                player.stop();

            player.reset();

            if(currentPosition - 1 < 0)
                currentPosition = songs.size();
            else
                currentPosition = currentPosition -1;

            play();
        }
    }

    //getting new position for playing by the gui seek bar
    public void setSeekPosition(int msec)
    {
        if(player != null)
            player.seekTo(msec);
    }

    //getting the current duration of music
    public int getSeekPosition()
    {
        if(player != null)
            return  player.getDuration();
        else
            return -1;
    }
}

ה Activity ממש את ה Interface, ומחפש שירים על המכשיר ומכניס אותם למערך שנשלח למחלקה, ניתן ליצור כפתורים ולשלוט במחלקה בעזרת Gui:

public class MainActivity extends ActionBarActivity 
implements OnPlayerEventListener {

    simplePlayer player;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //getting all songs in the device
        getAllSongs();

        if (player == null) {
            //create new instance and send the listener
            player = new simplePlayer(this);
            //initialize the simplePlayer
            player.init(songs);
            //start playing the first song
            player.play();

            seekBar.setMax(player.currentDuration);
        }
    }

    @Override
    public void onPlayerSongComplete() {

    }

    @Override
    public void onPlayerSongStart(String Title, int songDuration, int songPosition) {
        this.setTitle(Title);
        seekBar.setMax(songDuration);
        seekBar.setProgress(0);
    }
}

סיכום:

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

אל תפריעו לשכנים...
פורסם על ידי ב- אין תגובות:
תוויות: ,
הירשם ל- רשומות (Atom)