QUIZ KEAMANAN SISTEM KOMPUTER

Nama   : Reza Aulianda Putra
NIM     : 2017-31-271
Matkul : Keamanan Sistem Komputer
Dosen  : Desi Rose Hertina, S.T., M.Kom
Kelas   : A

KEAMANAN SISTEM KOMPUTER PADA BIDANG PERDAGANGAN

A. Algoritma

1. Deskripsikan hubungan KSK dengan Kriptografi Algortima Kelompok !

sistem keamanan komputer adalah untuk menjaga sumer daya sistem agar tidak digunakan,modfikasi,interupsi, dan diganggu oleh orang lain. Keamanan bisa diindentifikasikan dalam masalah teknis,manajerial,legalitas, dan politis. agar keamanan sistem tetap terjaga di buatlah algoritma untuk mengamankan sistem tersebut salah satunya yaitu algoritma RSA dimana Algoritma RSA yaitu algoritma pada enkripsi public key yang dipercayakan untuk mengamankan dengan menggunakan kunci yang cukup panjang.

2. Jelaskan tentang Algoritma kelompok mulai dari pengertian, sejarah, cara kerjanya(proses ekripsi dan proses deskrips), gambarkan flowchart berikan penjelasan ! 

    Algoritma RSA

  Pengertian RSA di bidang kriptografi adalah sebuah algoritme pada enkripsi public key. RSA merupakan algoritme pertama yang cocok untuk digital signature seperti halnya ekripsi, dan salah satu yang paling maju dalam bidang kriptografi public key. RSA masih digunakan secara luas dalam protokol electronic commerce, dan dipercaya dalam mengamnkan dengan menggunakan kunci yang cukup panjang.

   Sejarah Algortima RSA dijabarkan pada tahun 1977 oleh tiga orang : Ron Rivest, Adi Shamir dan Len Adleman dari Massachusetts Institute of Technology. Huruf RSA itu sendiri berasal dari inisial nama mereka (Rivest—Shamir—Adleman).

   Clifford Cocks, seorang matematikawan Inggris yang bekerja untuk GCHQ, menjabarkan tentang sistem ekuivalen pada dokumen internal pada tahun 1973. Penemuan Clifford Cocks tidak terungkap hingga tahun 1997 karena alasan top-secret classification.

  Algoritma tersebut dipatenkan oleh Massachusetts Institute of Technology pada tahun 1983 di Amerika Serikat sebagai U.S. Patent 4.405.829. Paten tersebut berlaku hingga 21 September 2000. Semenjak Algoritme RSA dipublikasikan sebagai aplikasi paten, regulasi di sebagian besar negara-negara lain tidak memungkinkan penggunaan paten. Hal ini menyebabkan hasil temuan Clifford Cocks di kenal secara umum, paten di Amerika Serikat tidak dapat mematenkannya.

Pembuatan Kunci

Semisal Alice berkeinginan untuk mengizinkan Bob untuk mengirimkan kepadanya sebuah pesan pribadi (private message) melalui media transmisi yang tidak aman (insecure). Alice melakukan langkah-langkah berikut untuk membuat pasangan kunci public key dan private key:

1.     Pilih dua bilangan prima p ≠ q secara acak dan terpisah untuk tiap-tiap p dan q. Hitung N = p q. N hasil perkalian dari p dikalikan dengan q.

2.     Hitung φ = (p-1)(q-1).

3.     Pilih bilangan bulat (integer) antara satu dan φ (1 < e < φ) yang juga merupakan koprima dari φ.

4.     Hitung d hingga d e ≡ 1 (mod φ).

• bilangan prima dapat diuji probabilitasnya menggunakan Fermat's little theorem- a^(n-1) mod n = 1 jika n adalah bilangan prima, diuji dengan beberapa nilai a menghasilkan kemungkinan yang tinggi bahwa n ialah bilangan prima. Carmichael numbers (angka-angka Carmichael) dapat melalui pengujian dari seluruh a, tetapi hal ini sangatlah langka.
• langkah 3 dan 4 dapat dihasilkan dengan algoritme extended Euclidean; lihat juga aritmatika modular.
• langkah 4 dapat dihasilkan dengan menemukan integer x sehingga d = (x(p-1)(q-1) + 1)/e menghasilkan bilangan bulat, kemudian menggunakan nilai dari d (mod (p-1)(q-1));
• langkah 2 PKCS#1 v2.1 menggunakan &lamda; = lcm(p-1, q-1) selain daripada φ = (p-1)(q-1)).

Pada public key terdiri atas:

• N, modulus yang digunakan.
• e, eksponen publik (sering juga disebut eksponen enkripsi).

Pada private key terdiri atas:

• N, modulus yang digunakan, digunakan pula pada public key.
• d, eksponen pribadi (sering juga disebut eksponen dekripsi), yang harus dijaga kerahasiaannya.

Biasanya, berbeda dari bentuk private key (termasuk parameter CRT):

• p dan q, bilangan prima dari pembangkitan kunci.
• d mod (p-1) dan d mod (q-1) (dikenal sebagai dmp1 dan dmq1).
• (1/q) mod p (dikenal sebagai iqmp).

Bentuk ini membuat proses dekripsi lebih cepat dan signing menggunakan Chinese Remainder Theorem (CRT). Dalam bentuk ini, seluruh bagian dari private key harus dijaga kerahasiaannya.

Alice mengirimkan public key kepada Bob, dan tetap merahasiakan private key yang digunakan. p dan q sangat sensitif dikarenakan merupakan faktorial dari N, dan membuat perhitungan dari d menghasilkan e. Jika p dan q tidak disimpan dalam bentuk CRT dari private key, maka p dan q telah terhapus bersama nilai-nilai lain dari proses pembangkitan kunci.

Proses enkripsi pesan

Misalkan Bob ingin mengirim pesan m ke Alice. Bob mengubah m menjadi angka n < N, menggunakan protokol yang sebelumnya telah disepakati dan dikenal sebagai padding scheme.

Maka Bob memiliki n dan mengetahui N dan e, yang telah diumumkan oleh Alice. Bob kemudian menghitung ciphertext c yang terkait pada n:

c = n e mod N {\displaystyle c=n^{e}\mod {N}}

Perhitungan tersebut dapat diselesaikan dengan cepat menggunakan metode exponentiation by squaring. Bob kemudian mengirimkan c kepada Alice.

Proses dekripsi pesan

Alice menerima c dari Bob, dan mengetahui private key yang digunakan oleh Alice sendiri. Alice kemudian memulihkan n dari c dengan langkah-langkah berikut:

Perhitungan di atas akan menghasilkan n, dengan begitu Alice dapat mengembalikan pesan semula m. Prosedur dekripsi bekerja karena

.

Kemudian, dikarenakan ed ≡ 1 (mod p-1) dan ed ≡ 1 (mod q-1), hasil dari Fermat's little theorem.

dan

Dikarenakan p dan q merupakan bilangan prima yang berbeda, mengaplikasikan Chinese Remainder Theorem akan menghasilkan dua macam kongruen

n e d ≡ n ( mod p q ) {\displaystyle n^{ed}\equiv n{\pmod {pq}}} .

serta

c d ≡ n ( mod N ) {\displaystyle c^{d}\equiv n{\pmod {N}}} .

Keterangan :

Mulai,

Pertama, masukkan bilangan prima p dan q, dimana p tidak sama denga q tetapi p>q.

Kedua, hitung n dan Ф(n)

Ketiga,masukkan nilai e atau kunci publik yang relatif prima terhadap

n dimana 1 < e < n-1.

Keempat, hitung d atau kunci pribadi.

Kelima, tentukan kunci publik (e,n) dan kunci pribadi (d,n)

Keenam, masukkan pesan atau plaintext.

Ketujuh,ubah pesan atau plaintext tersebut kedalam kode ASCII

Kedelapan,hitung C dimana akan menghasilkan output cipher text (pada langkah ke9).

Jika pesan atau plaintext yang telah di enkripsi ingin di ubah kembali ke plaintext atau di dekripsi maka dilanjutkan ke langkah ke10 yaitu hitung nilai d dimana akan menghasilkan output plaintext(pada langkah ke11).

Kemudian,selesai.

3. Berikan deskripsi dari study kasus terkait tema kelompok dan pada bagian mana dari study kasus tersebut Algortima kelompok diterapkan !

   Study Kasus

     Kasus Peretasan Penjualan Tiket Online Citilink Indonesia

Dalam kasus tersebut Pihak Citilink juga mengalami kerugian sebesar Rp1.973.784.434 karena ada sejumlah orang yang membeli tiket dari sindikat peretas tersebut melakukan pembatalan dan refund.

Ada kemungkinan dari sisi maskapai Citilink sendiri yang rentan seperti belum membatasi penyaringan terhadap special character yang memungkinkan seorang penyerang untuk menarik konten di database dari halaman front end aplikasi (dikenal SQL Injection).

Umumnya dari hasil ini, seseorang dapat mempergunakan data untuk login ke halaman yang lebih tertentu (seperti halaman admin) atau dapat juga untuk mengambil data sensitif pengguna lain.

Namun Taufik menambahkan, bila ditarik dari kesimpulan tersebut, masih terlalu banyak hal yang dapat dijadikan dugaan karena tidak hanya SQL Injection yang dapat membuat seseorang berhasil memperoleh akses masuk.

Peretas tersebut melakukan atau login ke akun maskapai Citilink, kemudian membagikan atau menjual tiket tersebut secara murah ke sosial media Facebook.

Penerapan :

Pada algoritma RSA kami menerapkan keamanan pada saat seseorang berusaha login, misalnya pada kasus diatas, seseorang yang berhasil masuk atau login pada server Citilink karena keamanannya masih kurang. Maka akan diterapkan kunci publik yang dimiliki semua pegawai citilink dimana kunci publik tersebut digunakan untuk membuka pesan yang dikirimkan oleh pegawai lain misalnya A, kemudian si A ini memiliki kunci pribadi yang tidak diketahui orang lain dan hanya dia saja yang tahu.

Nah dari kasus itu misalnya si A login maka akan muncul username dan password beserta kunci pribadi itu. Sehingga seseorang tidak akan bisa masuk dengan mudahnya ke akun citilink.

4. berikan sintaks dari algoritma (proses enkripsi dan deskripsi) kelompok dengan bahasa pemograman yang dipilih !

Sintaks Dari Algoritma RSA

#include<iostream>

#include<math.h>

#include<string.h>

#include<stdlib.h>

using namespace std;

long int p, q, n, t, flag, e[100], d[100], temp[100], j, m[100], en[100], i;

string msg;

int prime(long int);

void ce();

long int cd(long int);

void encrypt();

void decrypt();

int prime(long int pr){

int i ;

j=sqrt(pr);

for (i=2 ; i<=j ; i++){

if (pr%i==0)

return 0 ;

}

return 1 ;

}

int main (){

cout<<"\nMASUKKAN ANGKA PRIMA : ";

cin>>p;

flag=prime(p);

if (flag==0){

cout<<"\nINPUT SALAH"<<endl;

exit(1);

}

cout<<"\nMASUKKAN BILANGAN PRIMA LAINNYA : ";

cin>>q;

flag=prime(q);

if (flag==0 || p==q){

cout<<"\nINPUT SALAH"<<endl;

exit(1);

}

cout<<"\nMASUKKAN PESAN"<<endl;

fflush(stdin);

getline(cin,msg);

for(i=0; msg[i] != '\0'; i++)

m[i]=msg[i];

n=p*q;

t=(p-1)*(q-1);

ce();

cout<<"\nANGKA TERSEDIA DARI E DAN D"<<endl;

for (i=0; i<j -1; i++)

cout<<e[i]<<"\t"<<d[i]<<"\n";

encrypt();

decrypt();

return 0;

}

void ce(){

int k;

k=0;

for(i=2; i<t; i++){

if(t%i==0)

continue;

flag=prime(i);

if (flag==1 && i !=q){

e[k]=i;

flag=cd(e[k]);

if (flag>0){

d[k]=flag;

k++;

}

if (k==99)

break;

}

}

}

long int cd(long int x){

long int k=1;

while(1){

k=k+t;

if(k%x==0)

return (k/x);

}

}

void encrypt(){

long int pt,ct,key=e[0], k, len;

i=0;

len=msg.length();

while(i != len){

pt=m[i];

pt=pt-96;

k=1;

for(j=0; j<key; j++){

k=k*pt;

k=k%n;

}

temp[i]=k;

ct=k+96;

en[i]=ct;

i++;

}

en[i]=-1;

cout<<"\nPESAN ENKRIPSI"<<endl;

for(i=0; en[i] != -1; i++)

printf("%c",en[i]);

}

void decrypt(){

long int pt,ct,key=d[0],k;

i=0;

while(en[i] != -1){

ct=temp[i];

k=1;

for(j=0; j<key; j++){

k=k*ct;

k=k%n;

}

pt=k+96;

m[i]=pt;

i++;

}

m[i]=-1;

cout<<"\nPESAN DEKRIPSI"<<endl;

for(i=0; m[i] !=-1; i++)

printf("%c",m[i]);

}

5. Link Blog Anggota Kelompok  6 :

     

1.     Nuraini Kafita walla          http://fitawalla.blogspot.com/
2.     Syafira Nur Amalia Arif     https://syafirarif.blogspot.com
3.     Maulida Nabila Akbar       http://maulidanabsttpln.blogspot.com/2018/12/1.html?m=1
4.     Alvian Arif Gandari           http://alvingandari15.blogspot.com/
5.     Reza Aulianda Putra        https://rezaaulianda.blogspot.com/2018/12/keamanan-sistem-komputer.html

6. Referensi Sumber dari Materi 

• https://www.researchgate.net/publication/321310951_UJICOBA_SISTEM_KEAMANAN_INFORMASI_DENGAN_ALGORITMA_KRIPTOGRAFI_RSA_DAN_RSA-CRT_PADA_SISTEM_E-MEMO_BERBASIS_MOBILE
• https://fmipa.unmul.ac.id/files/docs/05-jurnal-ilkom-unmul-v-4-3.pdf
• http://www.maribelajar.web.id/2015/07/cara-perhitungan-manual-algoritma-rsa.html?m=1
• file:///C:/Users/IDRIANI/Downloads/Kajian_Perhitungan_dan_Penerapan_Algorit.pdf
• http://www.elkompedia.com/2016/02/keamanan-komputer-dan-pentingnya.html
• https://www.researchgate.net/figure/Gambar-3-Flowchart-Proses-Algoritma-RSA_fig1_321310951
• http://octarapribadi.blogspot.com/2016/02/enkripsi-dan-dekripsi-menggunakan-rsa.html

B. Analisa Algoritma 

 1. Dekripsi hubungan KSK dengan Kriptografi algoritma kelompok dan algoritma kelompok         lain yang memiliki kemiripan cara kerja!

Algoritma kriptografi block cipehr beroperasi pada plainteks/cipherteks dalam bentuk blok bit, yang dalam hal ini rangkaian bit dibagi menjadi blok-blik bit yang panjangnya sudah ditentukan sebelumnya. Misalnya panjang blok adalah 64 bit, maka itu berarti algoritma enkripsi memperlakukan 8 karakter setiap kali enkripsi (1 karakter sama dengan 8 bit dalam pengkodean ASCII).

Algoritma RSA dan Block Cipher memiliki hubungan dalam keamanan data atau pesan yang diubah kedalam kode ASCII. Dari segi keamanan, algoritma block cipher ini melindungi kerahasiaan data yang dikirim melalui media telekomunikasi dan melindungi kerahasiaan data yang disimpan pada media penyimpanan. Kelemahan dari sistem ini adalah baik pengirim maupun penerima pesan harus memiliki kunci yang sama, sehingga pengirim pesan harus mencari cara yang aman untuk memberitahukan kunci kepada penerima pesan.

Contoh lain :

2. Jelaskan tentang Algoritma kelompok lain mulai dari , pengertian, sejarah, cara kerjanya(proses enkripsi dan proses deskripsi), gambarkan flowchart berikan penjelasan!

Pengertian Algoritma Block Chiper
Blok cipher merupakan algoritma kriptografi simetrik yang mengenkripsi satu blok plaintext dengan jumlah bit tertentu dan menghasilkan blok ciphertext dengan jumlah bit yang sama. Misalkan ukuran blok plaintext yang dienkripsi adalah 64 bit, maka akan menghasilkan ciphertext yang berukuran 64 bit. Pada umumnya, setiap blok plaintext yang diproses berukuran 64 bit. Namun, seiring dengan kemajuan teknologi, ukuran blok plaintext berkembang menjadi 128 bit, 256 bit bahkan menjadi 512 bit
https://cryptobounce.wordpress.com/2008/06/19/block-cipher/

Sejarah Algoritma Block Chiper

Mode operasi paling awal, ECB, CBC, OFB, dan CFB , tahun 1981 dan ditentukan dalam FIPS 81, Mode DES Operasi. Pada tahun 2001, Lembaga Standar dan Teknologi Nasional AS (NIST) merevisi daftar mode operasi yang disetujui dengan memasukkan AES sebagai chiper block dan menambahkan mode RKPT di SP800-38A, Rekomendasi untuk Blok Cipher Mode Operasi. Akhirnya, pada bulan Januari 2010, NIST menambahkan XTS-AES di SP800-38E, Rekomendasi untuk Blok Cipher Mode Operasi: Mode XTS-AES untuk Kerahasiaan pada Perangkat Penyimpanan. Mode kerahasiaan lainnya ada yang belum disetujui oleh NIST. 

https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#History_and_standardization

Cara Kerja Algoritma Block Chiper

Electronic Codebook Mode

Mode Operasi block cipher yang paling sederhana adalah Electronic Codebook Mode (ECB). Pada mode operasi ini, pola dari plaintext akan diketahui, karena blok plaintext yang sama selalu menghasilkan blok ciphertext yang sama. Sehingga jika cryptanalyst mengetahui bahwa hasil enkripsi blok plaintext “8d226acd” adalah “1c7ed351”, maka dia dapat dengan mudah mendekripsi ciphertext dengan bentuk yang sama, setiap kali ciphertext tersebut terlihat di dalam message. Kelemahan ini berpeluang besar terjadi pada awal dan akhir dari message, karena pada header dan footer berisi informasi mengenai pengirim (sender), penerima (receiver), tanggal dan lain sebagainya.

Cipher Block Chaining

Mode operasi Cipher Block Chaining (CBC) merupakan salah satu mode operasi block cipher yang menggunakan vektor inisialisasi (initialitation vector/IV) dengan ukuran tertentu (ukurannya sama dengan satu blok plaintext). Pada mode operasi ini plaintext dibagi menjadi beberapa blok, kemudian masing-masing blok dienkripsi dengan ketentuan blok plaintext pertama dienkripsi lebih dahulu. Sebelum dienkripsi, plaintext di-XOR dengan IV. Lalu, hasil XOR tersebut dienkripsi hingga menghasilkan ciphertext. Selanjutnya, ciphertext tersebut digunakan sebagai IV untuk proses penyandian blok plaintext selanjutnya.
Mode operasi CBC menutupi kelemahan dari mode operasi ECB, karena pada CBC dapat menyembunyikan  pola dari plaintext. Mengapa demikian? Karena sebelum dienkripsi, plaintext di-XOR dengan IV atau ciphertext sebelumnya, sehingga plaintext yang sama belum tentu menghasilkan ciphertext yang sama, kecuali jika memiliki IV/ciphertext sebelumnya yang sama.
Kelemahan dari CBC adalah untuk mendekripsi ciphertext, dipengaruhi oleh ciphertext sebelumnya. Jika ada kesalahan pada ciphertext sebelumnya, maka ciphertext selanjutnya pun akan salah

Flowchart

1. Electronic Code Book.

Electronic Code Book

Metode standar dari Block Cipher, yaitu masing – masing blok plainteks dienkripsi dengan kunci yang sama secara independen. Kelemahan utama dari metode ini adalah mudahnya pendeteksian, terutama jika ada blok  – blok data yang sama dan dienkripsi dengan kunci yang sama maka akan menghasilkan cipherteks yang sama pula. Hal inilah yang menyebabkan mengapa disebut Electronic Code Book,karena seolah kita dapat mengetahui dan membuat sebuah kamus atau ensiklopedi dari plainteks dan cipherteks dengan kunci yang sama.

2. Cipher Block Chaining

Cipher Block Chaining Scheme

Untuk mengatasi kekurangan yang dimiliki oleh ECB, maka dibentuklah metode Cipher Block Chaining Ini. Pada dasarnya, konsep enkripsinya sama dengan ECB, namun ada perbedaan disini, bahwa plaintext yang akan dienkripsi, terlebih dahulu dilakukan XOR dengan ciphertext fase sebelumnya. Untuk fase pertama digunakanlah Initialization Vector sebagai nilai awal, yang kemudian di XOR dengan blok plaintext yang selanjutnya dilakukan enkripsi dengan kunci yang telah disepakati. Selanjutnya, blok ciphertext yang dihasilkan, selain dikeluarkan melalui output, blok ciphertext tersebut dilakukan XOR lagi dengan blok plaintext yang selanjutnya.

Pada metode dekripsi, yang dilakukan terlebih dahulu adalah mendekripsi blok ciphertext yang kemudian dilakukan XOR dengan ciphertext sebelumnya, dimana untuk fase awal digunakan Initialization Vector yang sama dengan pada saat enkripsi. Selanjutnya, blok ciphertext ini diXOR dengan blok ciphertext selanjutnya setelah dilakukan proses dekripsi.

3. Lakukan pengetesan kedua algoritma tersebut dengan menggunakan sintaks bahasa                    pemograman yang dipilih!, Dengan inputan plaintext berupa nama dan NIM (Proses                  enkripsi dan deskripsi)

RSA :

Blok Cipher

Bahasa pemrograman : PHP

//PHP version

//Paul Tero, July 2001

//http://www.tero.co.uk/des/

//

//Optimised for performance with large blocks by Michael Hayworth, November 2001

//http://www.netdealing.com

//

//Converted from JavaScript to PHP by Jim Gibbs, June 2004

//

//Updated to be safe in PHP on 64-bit architectures by Jirka Pech, July 2007

//http://hq.cz/

//

//THIS SOFTWARE IS PROVIDED "AS IS" AND

//ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

//IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

//ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE

//FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

//DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

//OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

//HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

//LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

//OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

//SUCH DAMAGE.



//des

//this takes the key, the message, and whether to encrypt or decrypt

function des ($key, $message, $encrypt, $mode, $iv, $padding) {

  //declaring this locally speeds things up a bit

  $spfunction1 = array (0x1010400,0,0x10000,0x1010404,0x1010004,0x10404,0x4,0x10000,0x400,0x1010400,0x1010404,0x400,0x1000404,0x1010004,0x1000000,0x4,0x404,0x1000400,0x1000400,0x10400,0x10400,0x1010000,0x1010000,0x1000404,0x10004,0x1000004,0x1000004,0x10004,0,0x404,0x10404,0x1000000,0x10000,0x1010404,0x4,0x1010000,0x1010400,0x1000000,0x1000000,0x400,0x1010004,0x10000,0x10400,0x1000004,0x400,0x4,0x1000404,0x10404,0x1010404,0x10004,0x1010000,0x1000404,0x1000004,0x404,0x10404,0x1010400,0x404,0x1000400,0x1000400,0,0x10004,0x10400,0,0x1010004);

  $spfunction2 = array (-0x7fef7fe0,-0x7fff8000,0x8000,0x108020,0x100000,0x20,-0x7fefffe0,-0x7fff7fe0,-0x7fffffe0,-0x7fef7fe0,-0x7fef8000,-0x80000000,-0x7fff8000,0x100000,0x20,-0x7fefffe0,0x108000,0x100020,-0x7fff7fe0,0,-0x80000000,0x8000,0x108020,-0x7ff00000,0x100020,-0x7fffffe0,0,0x108000,0x8020,-0x7fef8000,-0x7ff00000,0x8020,0,0x108020,-0x7fefffe0,0x100000,-0x7fff7fe0,-0x7ff00000,-0x7fef8000,0x8000,-0x7ff00000,-0x7fff8000,0x20,-0x7fef7fe0,0x108020,0x20,0x8000,-0x80000000,0x8020,-0x7fef8000,0x100000,-0x7fffffe0,0x100020,-0x7fff7fe0,-0x7fffffe0,0x100020,0x108000,0,-0x7fff8000,0x8020,-0x80000000,-0x7fefffe0,-0x7fef7fe0,0x108000);

  $spfunction3 = array (0x208,0x8020200,0,0x8020008,0x8000200,0,0x20208,0x8000200,0x20008,0x8000008,0x8000008,0x20000,0x8020208,0x20008,0x8020000,0x208,0x8000000,0x8,0x8020200,0x200,0x20200,0x8020000,0x8020008,0x20208,0x8000208,0x20200,0x20000,0x8000208,0x8,0x8020208,0x200,0x8000000,0x8020200,0x8000000,0x20008,0x208,0x20000,0x8020200,0x8000200,0,0x200,0x20008,0x8020208,0x8000200,0x8000008,0x200,0,0x8020008,0x8000208,0x20000,0x8000000,0x8020208,0x8,0x20208,0x20200,0x8000008,0x8020000,0x8000208,0x208,0x8020000,0x20208,0x8,0x8020008,0x20200);

  $spfunction4 = array (0x802001,0x2081,0x2081,0x80,0x802080,0x800081,0x800001,0x2001,0,0x802000,0x802000,0x802081,0x81,0,0x800080,0x800001,0x1,0x2000,0x800000,0x802001,0x80,0x800000,0x2001,0x2080,0x800081,0x1,0x2080,0x800080,0x2000,0x802080,0x802081,0x81,0x800080,0x800001,0x802000,0x802081,0x81,0,0,0x802000,0x2080,0x800080,0x800081,0x1,0x802001,0x2081,0x2081,0x80,0x802081,0x81,0x1,0x2000,0x800001,0x2001,0x802080,0x800081,0x2001,0x2080,0x800000,0x802001,0x80,0x800000,0x2000,0x802080);

  $spfunction5 = array (0x100,0x2080100,0x2080000,0x42000100,0x80000,0x100,0x40000000,0x2080000,0x40080100,0x80000,0x2000100,0x40080100,0x42000100,0x42080000,0x80100,0x40000000,0x2000000,0x40080000,0x40080000,0,0x40000100,0x42080100,0x42080100,0x2000100,0x42080000,0x40000100,0,0x42000000,0x2080100,0x2000000,0x42000000,0x80100,0x80000,0x42000100,0x100,0x2000000,0x40000000,0x2080000,0x42000100,0x40080100,0x2000100,0x40000000,0x42080000,0x2080100,0x40080100,0x100,0x2000000,0x42080000,0x42080100,0x80100,0x42000000,0x42080100,0x2080000,0,0x40080000,0x42000000,0x80100,0x2000100,0x40000100,0x80000,0,0x40080000,0x2080100,0x40000100);

  $spfunction6 = array (0x20000010,0x20400000,0x4000,0x20404010,0x20400000,0x10,0x20404010,0x400000,0x20004000,0x404010,0x400000,0x20000010,0x400010,0x20004000,0x20000000,0x4010,0,0x400010,0x20004010,0x4000,0x404000,0x20004010,0x10,0x20400010,0x20400010,0,0x404010,0x20404000,0x4010,0x404000,0x20404000,0x20000000,0x20004000,0x10,0x20400010,0x404000,0x20404010,0x400000,0x4010,0x20000010,0x400000,0x20004000,0x20000000,0x4010,0x20000010,0x20404010,0x404000,0x20400000,0x404010,0x20404000,0,0x20400010,0x10,0x4000,0x20400000,0x404010,0x4000,0x400010,0x20004010,0,0x20404000,0x20000000,0x400010,0x20004010);

  $spfunction7 = array (0x200000,0x4200002,0x4000802,0,0x800,0x4000802,0x200802,0x4200800,0x4200802,0x200000,0,0x4000002,0x2,0x4000000,0x4200002,0x802,0x4000800,0x200802,0x200002,0x4000800,0x4000002,0x4200000,0x4200800,0x200002,0x4200000,0x800,0x802,0x4200802,0x200800,0x2,0x4000000,0x200800,0x4000000,0x200800,0x200000,0x4000802,0x4000802,0x4200002,0x4200002,0x2,0x200002,0x4000000,0x4000800,0x200000,0x4200800,0x802,0x200802,0x4200800,0x802,0x4000002,0x4200802,0x4200000,0x200800,0,0x2,0x4200802,0,0x200802,0x4200000,0x800,0x4000002,0x4000800,0x800,0x200002);

  $spfunction8 = array (0x10001040,0x1000,0x40000,0x10041040,0x10000000,0x10001040,0x40,0x10000000,0x40040,0x10040000,0x10041040,0x41000,0x10041000,0x41040,0x1000,0x40,0x10040000,0x10000040,0x10001000,0x1040,0x41000,0x40040,0x10040040,0x10041000,0x1040,0,0,0x10040040,0x10000040,0x10001000,0x41040,0x40000,0x41040,0x40000,0x10041000,0x1000,0x40,0x10040040,0x1000,0x41040,0x10001000,0x40,0x10000040,0x10040000,0x10040040,0x10000000,0x40000,0x10001040,0,0x10041040,0x40040,0x10000040,0x10040000,0x10001000,0x10001040,0,0x10041040,0x41000,0x41000,0x1040,0x1040,0x40040,0x10000000,0x10041000);

  $masks = array (4294967295,2147483647,1073741823,536870911,268435455,134217727,67108863,33554431,16777215,8388607,4194303,2097151,1048575,524287,262143,131071,65535,32767,16383,8191,4095,2047,1023,511,255,127,63,31,15,7,3,1,0);



  //create the 16 or 48 subkeys we will need

  $keys = des_createKeys ($key);

  $m=0;

  $len = strlen($message);

  $chunk = 0;

  //set up the loops for single and triple des

  $iterations = ((count($keys) == 32) ? 3 : 9); //single or triple des

  if ($iterations == 3) {$looping = (($encrypt) ? array (0, 32, 2) : array (30, -2, -2));}

  else {$looping = (($encrypt) ? array (0, 32, 2, 62, 30, -2, 64, 96, 2) : array (94, 62, -2, 32, 64, 2, 30, -2, -2));}



  //pad the message depending on the padding parameter

  if ($padding == 2) $message .= "        "; //pad the message with spaces

  else if ($padding == 1) {$temp = 8-($len%8); $message .= chr($temp) . chr($temp) . chr($temp) . chr($temp) . chr($temp) . chr($temp) . chr($temp) . chr($temp); if ($temp==8) $len+=8;} //PKCS7 padding

  else if (!$padding) $message .= (chr(0) . chr(0) . chr(0) . chr(0) . chr(0) . chr(0) . chr(0) . chr(0)); //pad the message out with null bytes



  //store the result here

  $result = "";

  $tempresult = "";



  if ($mode == 1) { //CBC mode

    $cbcleft = (ord($iv{$m++}) << 24) | (ord($iv{$m++}) << 16) | (ord($iv{$m++}) << 8) | ord($iv{$m++});

    $cbcright = (ord($iv{$m++}) << 24) | (ord($iv{$m++}) << 16) | (ord($iv{$m++}) << 8) | ord($iv{$m++});

    $m=0;

  }



  //loop through each 64 bit chunk of the message

  while ($m < $len) {

    $left = (ord($message{$m++}) << 24) | (ord($message{$m++}) << 16) | (ord($message{$m++}) << 8) | ord($message{$m++});

    $right = (ord($message{$m++}) << 24) | (ord($message{$m++}) << 16) | (ord($message{$m++}) << 8) | ord($message{$m++});



    //for Cipher Block Chaining mode, xor the message with the previous result

    if ($mode == 1) {if ($encrypt) {$left ^= $cbcleft; $right ^= $cbcright;} else {$cbcleft2 = $cbcleft; $cbcright2 = $cbcright; $cbcleft = $left; $cbcright = $right;}}



    //first each 64 but chunk of the message must be permuted according to IP

    $temp = (($left >> 4 & $masks[4]) ^ $right) & 0x0f0f0f0f; $right ^= $temp; $left ^= ($temp << 4);

    $temp = (($left >> 16 & $masks[16]) ^ $right) & 0x0000ffff; $right ^= $temp; $left ^= ($temp << 16);

    $temp = (($right >> 2 & $masks[2]) ^ $left) & 0x33333333; $left ^= $temp; $right ^= ($temp << 2);

    $temp = (($right >> 8 & $masks[8]) ^ $left) & 0x00ff00ff; $left ^= $temp; $right ^= ($temp << 8);

    $temp = (($left >> 1 & $masks[1]) ^ $right) & 0x55555555; $right ^= $temp; $left ^= ($temp << 1);



    $left = (($left << 1) | ($left >> 31 & $masks[31]));

    $right = (($right << 1) | ($right >> 31 & $masks[31]));



    //do this either 1 or 3 times for each chunk of the message

    for ($j=0; $j<$iterations; $j+=3) {

      $endloop = $looping[$j+1];

      $loopinc = $looping[$j+2];

      //now go through and perform the encryption or decryption

      for ($i=$looping[$j]; $i!=$endloop; $i+=$loopinc) { //for efficiency

        $right1 = $right ^ $keys[$i];

        $right2 = (($right >> 4 & $masks[4]) | ($right << 28 & 0xffffffff)) ^ $keys[$i+1];

        //the result is attained by passing these bytes through the S selection functions

        $temp = $left;

        $left = $right;

        $right = $temp ^ ($spfunction2[($right1 >> 24 & $masks[24]) & 0x3f] | $spfunction4[($right1 >> 16 & $masks[16]) & 0x3f]

              | $spfunction6[($right1 >>  8 & $masks[8]) & 0x3f] | $spfunction8[$right1 & 0x3f]

              | $spfunction1[($right2 >> 24 & $masks[24]) & 0x3f] | $spfunction3[($right2 >> 16 & $masks[16]) & 0x3f]

              | $spfunction5[($right2 >>  8 & $masks[8]) & 0x3f] | $spfunction7[$right2 & 0x3f]);

      }

      $temp = $left; $left = $right; $right = $temp; //unreverse left and right

    } //for either 1 or 3 iterations



    //move then each one bit to the right

    $left = (($left >> 1 & $masks[1]) | ($left << 31));

    $right = (($right >> 1 & $masks[1]) | ($right << 31));



    //now perform IP-1, which is IP in the opposite direction

    $temp = (($left >> 1 & $masks[1]) ^ $right) & 0x55555555; $right ^= $temp; $left ^= ($temp << 1);

    $temp = (($right >> 8 & $masks[8]) ^ $left) & 0x00ff00ff; $left ^= $temp; $right ^= ($temp << 8);

    $temp = (($right >> 2 & $masks[2]) ^ $left) & 0x33333333; $left ^= $temp; $right ^= ($temp << 2);

    $temp = (($left >> 16 & $masks[16]) ^ $right) & 0x0000ffff; $right ^= $temp; $left ^= ($temp << 16);

    $temp = (($left >> 4 & $masks[4]) ^ $right) & 0x0f0f0f0f; $right ^= $temp; $left ^= ($temp << 4);



    //for Cipher Block Chaining mode, xor the message with the previous result

    if ($mode == 1) {if ($encrypt) {$cbcleft = $left; $cbcright = $right;} else {$left ^= $cbcleft2; $right ^= $cbcright2;}}

    $tempresult .= (chr($left>>24 & $masks[24]) . chr(($left>>16 & $masks[16]) & 0xff) . chr(($left>>8 & $masks[8]) & 0xff) . chr($left & 0xff) . chr($right>>24 & $masks[24]) . chr(($right>>16 & $masks[16]) & 0xff) . chr(($right>>8 & $masks[8]) & 0xff) . chr($right & 0xff));



    $chunk += 8;

    if ($chunk == 512) {$result .= $tempresult; $tempresult = ""; $chunk = 0;}

  } //for every 8 characters, or 64 bits in the message



  //return the result as an array

  return ($result . $tempresult);

} //end of des



//des_createKeys

//this takes as input a 64 bit key (even though only 56 bits are used)

//as an array of 2 integers, and returns 16 48 bit keys

function des_createKeys ($key) {

  //declaring this locally speeds things up a bit

  $pc2bytes0  = array (0,0x4,0x20000000,0x20000004,0x10000,0x10004,0x20010000,0x20010004,0x200,0x204,0x20000200,0x20000204,0x10200,0x10204,0x20010200,0x20010204);

  $pc2bytes1  = array (0,0x1,0x100000,0x100001,0x4000000,0x4000001,0x4100000,0x4100001,0x100,0x101,0x100100,0x100101,0x4000100,0x4000101,0x4100100,0x4100101);

  $pc2bytes2  = array (0,0x8,0x800,0x808,0x1000000,0x1000008,0x1000800,0x1000808,0,0x8,0x800,0x808,0x1000000,0x1000008,0x1000800,0x1000808);

  $pc2bytes3  = array (0,0x200000,0x8000000,0x8200000,0x2000,0x202000,0x8002000,0x8202000,0x20000,0x220000,0x8020000,0x8220000,0x22000,0x222000,0x8022000,0x8222000);

  $pc2bytes4  = array (0,0x40000,0x10,0x40010,0,0x40000,0x10,0x40010,0x1000,0x41000,0x1010,0x41010,0x1000,0x41000,0x1010,0x41010);

  $pc2bytes5  = array (0,0x400,0x20,0x420,0,0x400,0x20,0x420,0x2000000,0x2000400,0x2000020,0x2000420,0x2000000,0x2000400,0x2000020,0x2000420);

  $pc2bytes6  = array (0,0x10000000,0x80000,0x10080000,0x2,0x10000002,0x80002,0x10080002,0,0x10000000,0x80000,0x10080000,0x2,0x10000002,0x80002,0x10080002);

  $pc2bytes7  = array (0,0x10000,0x800,0x10800,0x20000000,0x20010000,0x20000800,0x20010800,0x20000,0x30000,0x20800,0x30800,0x20020000,0x20030000,0x20020800,0x20030800);

  $pc2bytes8  = array (0,0x40000,0,0x40000,0x2,0x40002,0x2,0x40002,0x2000000,0x2040000,0x2000000,0x2040000,0x2000002,0x2040002,0x2000002,0x2040002);

  $pc2bytes9  = array (0,0x10000000,0x8,0x10000008,0,0x10000000,0x8,0x10000008,0x400,0x10000400,0x408,0x10000408,0x400,0x10000400,0x408,0x10000408);

  $pc2bytes10 = array (0,0x20,0,0x20,0x100000,0x100020,0x100000,0x100020,0x2000,0x2020,0x2000,0x2020,0x102000,0x102020,0x102000,0x102020);

  $pc2bytes11 = array (0,0x1000000,0x200,0x1000200,0x200000,0x1200000,0x200200,0x1200200,0x4000000,0x5000000,0x4000200,0x5000200,0x4200000,0x5200000,0x4200200,0x5200200);

  $pc2bytes12 = array (0,0x1000,0x8000000,0x8001000,0x80000,0x81000,0x8080000,0x8081000,0x10,0x1010,0x8000010,0x8001010,0x80010,0x81010,0x8080010,0x8081010);

  $pc2bytes13 = array (0,0x4,0x100,0x104,0,0x4,0x100,0x104,0x1,0x5,0x101,0x105,0x1,0x5,0x101,0x105);

  $masks = array (4294967295,2147483647,1073741823,536870911,268435455,134217727,67108863,33554431,16777215,8388607,4194303,2097151,1048575,524287,262143,131071,65535,32767,16383,8191,4095,2047,1023,511,255,127,63,31,15,7,3,1,0);



  //how many iterations (1 for des, 3 for triple des)

  $iterations = ((strlen($key) > 8) ? 3 : 1); //changed by Paul 16/6/2007 to use Triple DES for 9+ byte keys

  //stores the return keys

  $keys = array (); // size = 32 * iterations but you don't specify this in php

  //now define the left shifts which need to be done

  $shifts = array (0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0);

  //other variables

  $m=0;

  $n=0;



  for ($j=0; $j<$iterations; $j++) { //either 1 or 3 iterations

    $left = (ord($key{$m++}) << 24) | (ord($key{$m++}) << 16) | (ord($key{$m++}) << 8) | ord($key{$m++});

    $right = (ord($key{$m++}) << 24) | (ord($key{$m++}) << 16) | (ord($key{$m++}) << 8) | ord($key{$m++});



    $temp = (($left >> 4 & $masks[4]) ^ $right) & 0x0f0f0f0f; $right ^= $temp; $left ^= ($temp << 4);

    $temp = (($right >> 16 & $masks[16]) ^ $left) & 0x0000ffff; $left ^= $temp; $right ^= ($temp << 16);

    $temp = (($left >> 2 & $masks[2]) ^ $right) & 0x33333333; $right ^= $temp; $left ^= ($temp << 2);

    $temp = (($right >> 16 & $masks[16]) ^ $left) & 0x0000ffff; $left ^= $temp; $right ^= ($temp << 16);

    $temp = (($left >> 1 & $masks[1]) ^ $right) & 0x55555555; $right ^= $temp; $left ^= ($temp << 1);

    $temp = (($right >> 8 & $masks[8]) ^ $left) & 0x00ff00ff; $left ^= $temp; $right ^= ($temp << 8);

    $temp = (($left >> 1 & $masks[1]) ^ $right) & 0x55555555; $right ^= $temp; $left ^= ($temp << 1);



    //the right side needs to be shifted and to get the last four bits of the left side

    $temp = ($left << 8) | (($right >> 20 & $masks[20]) & 0x000000f0);

    //left needs to be put upside down

    $left = ($right << 24) | (($right << 8) & 0xff0000) | (($right >> 8 & $masks[8]) & 0xff00) | (($right >> 24 & $masks[24]) & 0xf0);

    $right = $temp;



    //now go through and perform these shifts on the left and right keys

    for ($i=0; $i < count($shifts); $i++) {

      //shift the keys either one or two bits to the left

      if ($shifts[$i] > 0) {

         $left = (($left << 2) | ($left >> 26 & $masks[26]));

         $right = (($right << 2) | ($right >> 26 & $masks[26]));

      } else {

         $left = (($left << 1) | ($left >> 27 & $masks[27]));

         $right = (($right << 1) | ($right >> 27 & $masks[27]));

      }

      $left = $left & -0xf;

      $right = $right & -0xf;



      //now apply PC-2, in such a way that E is easier when encrypting or decrypting

      //this conversion will look like PC-2 except only the last 6 bits of each byte are used

      //rather than 48 consecutive bits and the order of lines will be according to

      //how the S selection functions will be applied: S2, S4, S6, S8, S1, S3, S5, S7

      $lefttemp = $pc2bytes0[$left >> 28 & $masks[28]] | $pc2bytes1[($left >> 24 & $masks[24]) & 0xf]

              | $pc2bytes2[($left >> 20 & $masks[20]) & 0xf] | $pc2bytes3[($left >> 16 & $masks[16]) & 0xf]

              | $pc2bytes4[($left >> 12 & $masks[12]) & 0xf] | $pc2bytes5[($left >> 8 & $masks[8]) & 0xf]

              | $pc2bytes6[($left >> 4 & $masks[4]) & 0xf];

      $righttemp = $pc2bytes7[$right >> 28 & $masks[28]] | $pc2bytes8[($right >> 24 & $masks[24]) & 0xf]

                | $pc2bytes9[($right >> 20 & $masks[20]) & 0xf] | $pc2bytes10[($right >> 16 & $masks[16]) & 0xf]

                | $pc2bytes11[($right >> 12 & $masks[12]) & 0xf] | $pc2bytes12[($right >> 8 & $masks[8]) & 0xf]

                | $pc2bytes13[($right >> 4 & $masks[4]) & 0xf];

      $temp = (($righttemp >> 16 & $masks[16]) ^ $lefttemp) & 0x0000ffff;

      $keys[$n++] = $lefttemp ^ $temp; $keys[$n++] = $righttemp ^ ($temp << 16);

    }

  } //for each iterations

  //return the keys we've created

  return $keys;

} //end of des_createKeys



////////////////////////////// TEST //////////////////////////////

function stringToHex ($s) {

  $r = "0x";

  $hexes = array ("0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f");

  for ($i=0; $i<strlen($s); $i++) {$r .= ($hexes [(ord($s{$i}) >> 4)] . $hexes [(ord($s{$i}) & 0xf)]);}

  return $r;

}



function hexToString ($h) {

  $r = "";

  for ($i= (substr($h, 0, 2)=="0x")?2:0; $i<strlen($h); $i+=2) {$r .= chr (base_convert (substr ($h, $i, 2), 16, 10));}

  return $r;

}



echo "<PRE>";

$key = "this is a 24 byte key !!";

$message = "This is a test message";

$ciphertext = des ($key, $message, 1, 0, null);

echo "DES Test Encrypted: " . stringToHex ($ciphertext);

$recovered_message = des ($key, $ciphertext, 0, 0, null);


echo "\n";

Hasil Enkripsi :

Hasil Deskripsi :

4. Lakukan perbandingan kedua algoritma tersebut dengan menemukan 3 persamaan  dan 3        perbedaanya!

    Persamaan :

1.  Keduanya sama sama mengubah pesan kedalam kode ASCII
2.  Keduanya merupakan Algoritma Kriptografi Asimetris
3.  RSA dan Block Cipher sebelum dilakukan enkripsi, plaintext yang ada dibagi bagi menjadi             blok-blok yang sama. 

     Perbedaan :

1. RSA memiliki 2 kunci yaitu public key dan private key, sedangka Block Cipher hanya memiliki 1 kunci yaitu public key.
2.  Keamanan data atau pesan pada RSA lebih terjamin dibandingkan dengan Block Cipher
3.  RSA sangat sulit dalam enkripsi dan dekripsinya sedangkan Block Cipher mudah.

5. Berikan Link Blog anggota kelompok lain tersebut !
     
    Kelompok 7 :

1. Hanum Salsabila                                                               https://pemvis.blogspot.com/2018/12/rabu-12-desember-2018-a.html?m=1
2. Indri Mulyani                   https://keamanansistemkomputerindustri.blogspot.com/2018/12/keamanan-sistem-komputer-industri.html
3. Teuku Rifki Dhulu Fata                      http://teukurifkidhululfata.blogspot.com/2018/12/algoritma-chiper-blok.html
4. Puspa Riri Agustina                                                https://pusparirii.blogspot.com/2018/12/keamanan-sistem-komputer-algoritma.html
5. Lely Meylia                 http://keamanansistemkomputerindustri.blogspot.com/2018/12/keamanan-sistem-komputer-industri.html

6.  Berikan referensi sumber dari materi !

https://ilmukriptografi.wordpress.com/2012/10/24/public-key-rsa/

https://idnetwork2102.wordpress.com/2011/03/26/asimetris-kriptografi/

https://ilmukriptografi.wordpress.com/2012/04/25/kriptografi-simetrik-dasar-block-cipher/#more-39

C. Kesimpulan

Berdasarkan hasil analisis dan perhitungan algoritma RSA dapat disimpulkan bahwa:

1. Keamanan algoritma RSA terletak pada tingkat kesulitan dalam memfaktorkan bilangan non prima menjadi faktor primanya, yang dalam hal ini r = p × q.
2.  Semakin tinggi angka yang digunakan maka akan semakin sulit pula pesan/sandi dapat ditebak oleh pihak ketiga.
3.  Untuk menjaga keamanan dari serangan maka dapat menggunakan atau menerapkan Algoritma RSA ini dibandingkan dengan Block Cipher yang hanya memiliki 1 key saja yang dapat diketahui banyak orang sehingga sangat mudah untuk seseorang bisa masuk/diretas.