Linux : Dimanakah direktori "Pentest" dalam Kali Linux ??

Haih.. pening beb. Puas aku cari, mana hilang semua tool pentest macam BackTrack Linux tu. Rupanya, dalam Kali Linux, direktori tu telah di alih ke tempat lain. Puas aku godek, akhirnya jumpa gak.. semuanya ada kat dalam :

/usr/share

Bolehlah guna macam biasa dan kena biasakan diri dengan struktur baru ni. Sekian semoga bermanfaat ~

Shell Code Generator

Assalamualaikum & salam sejahtera, korang pernah dengar tak shellcode? Biasanya dalam bentuk / di istihar sebagai BYTE. Banyaklah fungsi dia, Kalau nak tahu sangat boleh google sendiri persoalan tu. Hari ni aku nak berkongsi satu perisian iaitu, SCG-Shell Code Generator.

Muat-turun : - Dropbox

Android Studio

Akhbar UTUSAN (28 Jun 2013) : Purata gaji profesional ICT meningkat 8.9 peratus tahun ini (2013)

KUALA LUMPUR 28 Jun - Persatuan ICT Kebangsaan Malaysia (Pikom) menjangkakan purata gaji profesional dalam bidang industri maklumat (ICT) akan meningkat sebanyak 8.9 peratus pada tahun ini.

Nilai tersebut meningkat sehingga RM7,387 pada tahun ini, berbanding RM6,782 pada 2012.

Jumlah itu diperoleh hasil daripada analisis dan kajian sektor pasaran kerja yang dijalankan oleh Pikom bersama KPMG dan Jobstreet.com.

Pengerusinya, Woon Tai Hai berkata, kerjaya dalam bidang ICT memberi pulangan yang lumayan dan menjadi tempat kelima dalam sektor kerjaya di negara ini yang menerima gaji yang tinggi.

Woon Tai Hai menunjukkan buku Jangkaan Pasaran Kerja ICT di Malaysia 2013 pada sidang media di Kuala Lumpur, semalam.

Katanya, biarpun ekonomi dunia berdepan krisis dan senario politik yang tidak menentu pada tahun lalu, namun pertumbuhan purata gaji di kalangan profesional ICT di peringkat junior dan senior.

"Usaha kerajaan menerusi Program Transformasi Ekonomi dan Program Transformasi Digital menjadi faktor utama pertumbuhan gaji dan industri ICT," katanya pada sidang akhbar selepas membentangkan Jangkaan Pasaran Kerja 2013 itu di sini hari ini.

Katanya, menurut kajian itu, pekerjaan berkaitan jualan, pemasaran dan pembangunan perniagaan kekal dalam senarai lima pengkhususan pekerjaan yang dicari oleh majikan.

"Berbanding dengan beberapa negara maju yang lain, pertumbuhannya agak rendah tetapi ia tetap positif.

"Purata gaji di peringkat kemasukan graduan IT baharu meningkat sebanyak 4.7 peratus daripada RM2, 238 pada tahun 2011 kepada RM2, 343 pada tahun 2012," katanya

Woon menambah, Malaysia perlu meningkatkan purata gaji bagi mengelakkan penghijrahan dan kehilangan bakat di negara ini.

Sumber: Utusan Melayu (M) Bhd

C++ : Kira MD5 untuk fail, string , bandingkan fail pertama dengan fail kedua dan bandingkan fail dengan nilai MD5 sum

#include <iostream>
#include <stdlib.h>
#include <string>
#include "md5.h"

using namespace std;

int main(int argc,char* argv[]){

    MD5    md5; // give access to md5 to using MD5 class
    cout << "\nMD5 Encrpyter : Basic C++ Application \n" << endl;

    if(argc < 2){
        cout << "Example : \n " << argv[0] << " -string String1 String2... " << endl;
        cout << " " << argv[0] << " -file File1 File2... " << endl;
        cout << " " << argv[0] << " -cfile File1 File2... " << endl;
        cout << "\n Options : " << endl;
        cout << "  -file: Calculate MD5 hash of file" << endl;
        cout << "  -string: Calculate MD5 hash of string" << endl;
        cout << "  -cfile: Compare first file with second file" << endl;
        cout << "  -cfileg: Compare first file with given MD5 hash" << endl;
        cout << "\nJust for note, this application support multiple string hash :)" << endl;
        exit (EXIT_FAILURE);
    }else if(string(argv[1]) == "-file"){
        if(argc > 3){
            for(int i = 2;i < argc;i++){
                cout << argv[i] << " : " << md5.digestFile(argv[i]) << endl;
            }
        }else{
            cout << argv[2] << " : " << md5.digestFile(argv[2]) << endl;
            exit (EXIT_SUCCESS);
        }
    }else if(string(argv[1]) == "-string"){
        if(argc > 3){
            for(int i = 2;i < argc;i++){
                cout << argv[i] << " : " << md5.digestString(argv[i]) << endl;
            }
        }else{
            cout << argv[2] << " : " << md5.digestString(argv[2]) << endl;
            exit (EXIT_SUCCESS);
        }
    }else if(string(argv[1]) == "-cfile"){
        if(argc > 3){
            string one = md5.digestFile(argv[2]);
            string two = md5.digestFile(argv[3]);
            if(one == two){
                cout << argv[2] << " is same with " << argv[3] << endl;
            }else{
                cout << argv[2] << " not same with " << argv[3] << endl;
            }
        }
    }else if(string(argv[1]) == "-cfileg"){
        if(argc > 3){
            string one = md5.digestFile(argv[2]);
            string two = string(argv[3]);
            if(one == two){
                cout << argv[2] << " is same compare with your given MD5 hash" << endl;
            }else{
                cout << argv[2] << " is not same compare with your given MD5 hash" << endl;
            }
        }
    }

}

Header MD5 :

#ifndef MD5_H
#define MD5_H

// Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
// rights reserved.

// License to copy and use this software is granted provided that it
// is identified as the "RSA Data Security, Inc. MD5 Message-Digest
// Algorithm" in all material mentioning or referencing this software
// or this function.
//
// License is also granted to make and use derivative works provided
// that such works are identified as "derived from the RSA Data
// Security, Inc. MD5 Message-Digest Algorithm" in all material
// mentioning or referencing the derived work.
//
// RSA Data Security, Inc. makes no representations concerning either
// the merchantability of this software or the suitability of this
// software for any particular purpose. It is provided "as is"
// without express or implied warranty of any kind.
//
// These notices must be retained in any copies of any part of this
// documentation and/or software.



// The original md5 implementation avoids external libraries.
// This version has dependency on stdio.h for file input and
// string.h for memcpy.
#include <stdio.h>
#include <string.h>

#pragma region MD5 defines
// Constants for MD5Transform routine.
#define S11 7
#define S12 12
#define S13 17
#define S14 22
#define S21 5
#define S22 9
#define S23 14
#define S24 20
#define S31 4
#define S32 11
#define S33 16
#define S34 23
#define S41 6
#define S42 10
#define S43 15
#define S44 21






static unsigned char PADDING[64] = {
  0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

// F, G, H and I are basic MD5 functions.
#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define I(x, y, z) ((y) ^ ((x) | (~z)))

// ROTATE_LEFT rotates x left n bits.
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))

// FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
// Rotation is separate from addition to prevent recomputation.
#define FF(a, b, c, d, x, s, ac) { \
  (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
  (a) = ROTATE_LEFT ((a), (s)); \
  (a) += (b); \
  }
#define GG(a, b, c, d, x, s, ac) { \
  (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
  (a) = ROTATE_LEFT ((a), (s)); \
  (a) += (b); \
  }
#define HH(a, b, c, d, x, s, ac) { \
  (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
  (a) = ROTATE_LEFT ((a), (s)); \
  (a) += (b); \
  }
#define II(a, b, c, d, x, s, ac) { \
  (a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
  (a) = ROTATE_LEFT ((a), (s)); \
  (a) += (b); \
  }
#pragma endregion

typedef unsigned char BYTE ;

// POINTER defines a generic pointer type
typedef unsigned char *POINTER;

// UINT2 defines a two byte word
typedef unsigned short int UINT2;

// UINT4 defines a four byte word
typedef unsigned long int UINT4;


// convenient object that wraps
// the C-functions for use in C++ only
class MD5
{
private:
  struct __context_t {
    UINT4 state[4];                                   /* state (ABCD) */
    UINT4 count[2];        /* number of bits, modulo 2^64 (lsb first) */
    unsigned char buffer[64];                         /* input buffer */
  } context ;

  #pragma region static helper functions
  // The core of the MD5 algorithm is here.
  // MD5 basic transformation. Transforms state based on block.
  static void MD5Transform( UINT4 state[4], unsigned char block[64] )
  {
    UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];

    Decode (x, block, 64);

    /* Round 1 */
    FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
    FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
    FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
    FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
    FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
    FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
    FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
    FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
    FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
    FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
    FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
    FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
    FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
    FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
    FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
    FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */

    /* Round 2 */
    GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
    GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
    GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
    GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
    GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
    GG (d, a, b, c, x[10], S22,  0x2441453); /* 22 */
    GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
    GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
    GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
    GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
    GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
    GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
    GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
    GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
    GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
    GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */

    /* Round 3 */
    HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
    HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
    HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
    HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
    HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
    HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
    HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
    HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
    HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
    HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
    HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
    HH (b, c, d, a, x[ 6], S34,  0x4881d05); /* 44 */
    HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
    HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
    HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
    HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */

    /* Round 4 */
    II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
    II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
    II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
    II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
    II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
    II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
    II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
    II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
    II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
    II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
    II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
    II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
    II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
    II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
    II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
    II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */

    state[0] += a;
    state[1] += b;
    state[2] += c;
    state[3] += d;

    // Zeroize sensitive information.
    memset((POINTER)x, 0, sizeof (x));
  }

  // Encodes input (UINT4) into output (unsigned char). Assumes len is
  // a multiple of 4.
  static void Encode( unsigned char *output, UINT4 *input, unsigned int len )
  {
    unsigned int i, j;

    for (i = 0, j = 0; j < len; i++, j += 4) {
      output[j] = (unsigned char)(input[i] & 0xff);
      output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
      output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
      output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
    }
  }

  // Decodes input (unsigned char) into output (UINT4). Assumes len is
  // a multiple of 4.
  static void Decode( UINT4 *output, unsigned char *input, unsigned int len )
  {
    unsigned int i, j;

    for (i = 0, j = 0; j < len; i++, j += 4)
      output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) |
      (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
  }
  #pragma endregion


public:
  // MAIN FUNCTIONS
  MD5()
  {
    Init() ;
  }

  // MD5 initialization. Begins an MD5 operation, writing a new context.
  void Init()
  {
    context.count[0] = context.count[1] = 0;

    // Load magic initialization constants.
    context.state[0] = 0x67452301;
    context.state[1] = 0xefcdab89;
    context.state[2] = 0x98badcfe;
    context.state[3] = 0x10325476;
  }

  // MD5 block update operation. Continues an MD5 message-digest
  // operation, processing another message block, and updating the
  // context.
  void Update(
    unsigned char *input,   // input block
    unsigned int inputLen ) // length of input block
  {
    unsigned int i, index, partLen;

    // Compute number of bytes mod 64
    index = (unsigned int)((context.count[0] >> 3) & 0x3F);

    // Update number of bits
    if ((context.count[0] += ((UINT4)inputLen << 3))
      < ((UINT4)inputLen << 3))
      context.count[1]++;
    context.count[1] += ((UINT4)inputLen >> 29);

    partLen = 64 - index;

    // Transform as many times as possible.
    if (inputLen >= partLen) {
      memcpy((POINTER)&context.buffer[index], (POINTER)input, partLen);
      MD5Transform (context.state, context.buffer);

      for (i = partLen; i + 63 < inputLen; i += 64)
        MD5Transform (context.state, &input[i]);

      index = 0;
    }
    else
      i = 0;

    /* Buffer remaining input */
    memcpy((POINTER)&context.buffer[index], (POINTER)&input[i], inputLen-i);
  }

  // MD5 finalization. Ends an MD5 message-digest operation, writing the
  // the message digest and zeroizing the context.
  // Writes to digestRaw
  void Final()
  {
    unsigned char bits[8];
    unsigned int index, padLen;

    // Save number of bits
    Encode( bits, context.count, 8 );

    // Pad out to 56 mod 64.
    index = (unsigned int)((context.count[0] >> 3) & 0x3f);
    padLen = (index < 56) ? (56 - index) : (120 - index);
    Update( PADDING, padLen );

    // Append length (before padding)
    Update( bits, 8 );

    // Store state in digest
    Encode( digestRaw, context.state, 16);

    // Zeroize sensitive information.
    memset((POINTER)&context, 0, sizeof (context));

    writeToString() ;
  }

  /// Buffer must be 32+1 (nul) = 33 chars long at least
  void writeToString()
  {
    int pos ;

    for( pos = 0 ; pos < 16 ; pos++ )
      sprintf( digestChars+(pos*2), "%02x", digestRaw[pos] ) ;
  }


public:
  // an MD5 digest is a 16-byte number (32 hex digits)
  BYTE digestRaw[ 16 ] ;

  // This version of the digest is actually
  // a "printf'd" version of the digest.
  char digestChars[ 33 ] ;

  /// Load a file from disk and digest it
  // Digests a file and returns the result.
  char* digestFile( char *filename )
  {
    Init() ;

    FILE *file;

    int len;
    unsigned char buffer[1024] ;

    if( (file = fopen (filename, "rb")) == NULL )
      printf( "%s can't be opened\n", filename ) ;
    else
    {
      while( len = fread( buffer, 1, 1024, file ) )
        Update( buffer, len ) ;
      Final();

      fclose( file );
    }

    return digestChars ;
  }

  /// Digests a byte-array already in memory
  char* digestMemory( BYTE *memchunk, int len )
  {
    Init() ;
    Update( memchunk, len ) ;
    Final() ;

    return digestChars ;
  }

  // Digests a string and prints the result.
  char* digestString( char *string )
  {
    Init() ;
    Update( (unsigned char*)string, strlen(string) ) ;
    Final() ;

    return digestChars ;
  }
} ;

#endif

PHP : Semak dan tapis emel dengan menggunakan fungsi filter_var()

Assalamualaikum & salam sejahtera. Hari ni aku kongsikan cara untuk menapis alamat emel. Bukan tapis sama ada emel tu wujud atau tak tapi tapis dari segi strruktur alamat emel tersebut. Aku malas nak taip panjang, klu korang gunakan blog aku ni sebagai rujukan maknanya korang dah faham. Aku gunakan fungsi filter_var() untuk membuat tugas macam ini.

1 2 3 4 5 6 7 8 9

<?php $emel = "2013@l33t.com"; if(filter_var($emel, FILTER_VALIDATE_EMAIL)){ echo "Cun.. alamat email <b>$emel</b> betul lah tu brader!"; } else{ echo "Halamak brader, alamat emel <b>$emel</b> salah!"; } ?>

Cubalah korang ubah pemboleh ubah $emel pada baris ke-2 tu dengan struktur alamat emel yang salah (contoh : 2013&l33t.com). Ada lagi cara lain untuk tugasan macamni iaitu pakai regex (regular expression) dengan fungsi preg_match() tp tutorial aku ni cara paling mudah nak guna dan faham untuk orang yang baru nak berjinak dengan PHP. Wassalam~