Dalam artikel ini dibatasi contoh pembangkitan random yang mungkin dapat anda gunakan sebagai bahan baku untuk enkripsi keamanan atau identitas unik. Selanjutnya menangani teknik enkripsi dan dekripsinya tidak dibahas dalam artikel ini.
- Pseudo-random dan True-random
- Random Seed
- Membangkitkan Random
- True Random Online Random.org
- Math.random()
- seedrandom.js
- Membangkitkan Secret Key
- Token Google dan oAuth
PSEUDO RANDOM DAN TRUE RANDOM
Pada artikel sebelumnya telah disebutkan yang membedakan antara Pseudo Random [acak semu] dan True Random [acak murni] adalah Pseudo Random masih punya peluang untuk bisa diprediksi keluarannya dan biasanya dibangkitkan oleh komputer.
Beberapa riset mencoba membangkitkan True Random dengan komputer salah satunya bisa anda coba di random.org. Sekalipun acak namun tetap harus terjamin keunikannya dalam kondisi apapun dan kapanpun.
Keunikan yang berarti tidak bisa diprediksi kemungkinan keluarannya dan menjamin tidak terjadi dua user dengan ID yang sama sekalipun ID tersebut dibangkitkan secara random.
Pseudo Random masih punya kemungkinan menghasilkan angka random identik yang berulang di waktu dan kondisi berbeda SiLiKiDi
RANDOM SEED
Dalam pengolahan angka biasa yang biasa dilakukan sekalipun dikonversi menjadi object String atau ke bentuk lain tidak akan mengubah komposisi urutan di dalamnya:
Untuk memahami Random Seed dapat diilustrasikan sebagai biji beras. Biji beras diolah lanjutan akan berbentuk berbeda dari aslinya biji beras bisa berupa nasi, bubur, tepung beras, atau bibit tanaman padi yang baru. Begitu pula dengan Random Seed sekalipun hanya dikonversi ke bentuk string hasilnya akan berbeda dari aslinya seperti tampak berikut:
MEMBANGKITKAN RANDOM
Kita dapat membangkitkan random dengan formula sendiri atau formula javascript dari riset-riset sebelumnya. Bahkan bisa pula meminjam pembangkitan random dari library cryptograph yang biasanya selalu menyertakan metode pembangkitan random karena membutuhkan satu elemen secret key atau phrase key dalam melakukan enkripsi mereka.
TRUE RANDOM ONLINE RANDOM.ORG
Random.org menyediakan pembangkitan online True Random maupun Pseudo Random. Anda bisa memanfaatkan hasil pembangkitannya untuk diolah di dalam Apps Script dengan trik dijelaskan pada artikel True Random Dengan Apps Script dan Random.org
Math.random()
Di dalam core javascript sendiri disediakan metode Math.random() yang dapat dicontohkan dengan pseudo-random sederhana dalam rentang tertentu:
const generateID = ( minimal, maksimal ) => {
return Math.floor( Math.random() * ( maksimal - minimal + 1 ) ) + minimal;
}
Logger.log( generateID( 1000000, 5000000 ) );
Math.random bersifat non-cryptographic random numbers sehingga Developer Mozilla tidak merekomendasikannya untuk diaplikasikan ke dalam platform keamanan aplikasi.
Lebih disarankan menggunakan crypto.getRandomValues() atau SubtleCrypto.generateKey() untuk membangkitkan random yang lebih aman.
Keduanya tersedia dalam Web Crypto API core javascript terbaru namun belum didukung Apps Script sehingga anda perlu membuat polyfill dari kedua metode tersebut SiLiKiDi
seedrandom.js
Di sini merekomendasikan untuk lebih berkiblat menggunakan formula David Bau yang menyediakan library seedrandom.js sebagai kritikan atas celah potensi predictable dari Math.random dan Cryptico.
Rilis terakhir seedrandom.js menyertakan 6 tambahan library selain seedrandom.js itu sendiri yang dapat dipanggil langsung dari seedrandom.js: alea, xor128, tychei, xorwow, xor4096, xorshift7, seedrandomjs. Benchmark dari ketujuh library tersebut menempatkan alea sebagai yang tercepat.
Kendala dari seedrandom.js ini harus dimuat terpisah secara eksternal saat diintegrasikan dalam Apps Script. Untuk mengatasinya telah dibahas dalam artikel sebelumnya SiLiKiDi
Menyisipkan seedrandom.js Ke Dalam Apps Script
Karena seedrandom.js bukan core javascript melainkan library external dan belum ada dalam library Apps Script, maka kita perlu menyisipkannya ke dalam Apps Script dengan melalui fungsi eval() berikut:
const loadJSFromUrl = ( url ) => {
return eval( UrlFetchApp.fetch(url).getContentText() );
}
const LIBRARIES = {
seedrandomJS: "https://cdnjs.cloudflare.com/ajax/libs/seedrandom/3.0.5/seedrandom.min.js",
alea: "https://cdnjs.cloudflare.com/ajax/libs/seedrandom/3.0.5/lib/alea.min.js",
};
Object.keys( LIBRARIES ).forEach( function ( library ) {
newFunc = loadJSFromUrl( LIBRARIES[library] );
eval( "let " + library + " = " + newFunc );
});
Atau dengan memanfaatkan object Function yang lebih aman dan cepat:
const alternativeToEval = () => {
let jsURL = "https://cdnjs.cloudflare.com/ajax/libs/seedrandom/3.0.5/seedrandom.min.js";
let jsFetch = UrlFetchApp.fetch( jsURL ).getContentText();
return Function( jsFetch )();
}
const testAlternativeToEval = () => {
altToEval();
let seed = Math.seedrandom();
let angka = new Math.seedrandom( seed, { entropy: true } );
Logger.log( "Seed Random: " + angka() );
}
Menggunakan seedrandom.js
Selanjutnya untuk memangilnya cukup mendeklarasikannya dengan new Math.seedrandom():
const seedrandomJS = () => {
let seed = Math.seedrandom();
let angka = new Math.seedrandom( seed, { entropy: true } );
return angka;
}
Logger.log( seedrandomJS() );
Bila anda lebih memilih metode pembangkitan alea gunakan notasi berikut:
const seedrandomAlea = () => {
let seed = alea();
let angka = new alea( seed, { entropy: true } );
return angka;
}
Logger.log( seedrandomAlea() );
Saveable Random State seedrandom.js
Normalnya pada hasil pembangkitan awal random tidak akan bisa diakses dan diolah lanjutan. Bila anda menginginkan nilai pembangkitan awal tersebut maka tambahkan properti state: true.
const seedrandomJSSaveable = () => {
let seedrandom = Math.seedrandom;
let saveable = seedrandom( seedrandom, { state: true });
for ( let j = 0; j < 1e5; ++j ) saveable();
let saved = saveable.state();
let replica = seedrandom( '', { state: saved } );
Logger.log( 'saveable: ' + saveable() );
//output diharapkan: 'saveable: 0.5691433454032999'
let obj = {};
obj[ "string" ] = String( replica() ).substring(2);
Logger.log( 'replica string: ' + obj[ "string" ] );
//output diharapkan: 'replica string: 5691433454032999'
}
MEMBANGKITKAN SECRET KEY
Saat menggunakan metode kriptografi dengan algoritma apapun akan selalu dibutuhkan kata kunci khusus yang terkadang disebut Secret Key, Private Key, atau Phrase Key. Biasanya kata kunci dalam kriptografi punya panjang 64 karakter.
Kata kunci tersebut membantu mempersulit upaya pemecahan kriptografi karena sifatnya manual atau dengan algoritma terpisah dari algoritma kriptografi itu sendiri sehingga semakin sulit diprediksi.
Untuk membangkitkannya gunakan Utilities.computeDigest dari Apps Script dengan Algoritma SHA_256 yang menghasilkan random 64 karakter:
/*********************************
* 64 KARAKTER SECRET KEY SHA_256 *
**********************************/
const generateSecretKey = ( keyword ) => {
const digest = Utilities.computeDigest( Utilities.DigestAlgorithm.SHA_256, keyword, Utilities.Charset.UTF_8 );
return digest.map(
function(e) {
return ( '0' + (e < 0 ? e + 256 : e).toString(16) ).slice(-2)
}
).join( '' );
};
let keyword = 'Seblak Pedas';
Logger.log( 'Secret Key Anda: ' + generateSecretKey( keyword ) );
TOKEN GOOGLE DAN oAuth
Token Google biasanya digunakan dalam otorisasi akun dan ijin akses sumber daya Google. Anda dapat meminjam metode pembangkitan random dengan memanfaatkan pembangkitan token yang disediakan Apps Script untuk anda olah dengan flow algoritma racikan anda sendiri.
Apps Script menyediakan fitur Script.App untuk penanganan token dan lainnya yang berkaitan dengan otorisasi.
Di antaranya metode createToken() dan getOAuthToken() khusus untuk otorisasi oAuth 2.0
Contoh Penggunaan Dalam Apps Script
/********************************************************************
* MEMINJAM TOKEN GOOGLE API 140-162 KARAKTER DAN OAuth 165 KARAKTER *
*********************************************************************/
Logger.log( ScriptApp.newStateToken().createToken() );
Logger.log(
ScriptApp
.newStateToken()
.withArgument( "client", "John Doe" )
.withTimeout( 3600 )
.withMethod( "myFunction" )
.createToken()
);
Logger.log( ScriptApp.getOAuthToken() );
Penerapan Dalam URL GET
Terkadang kita melihat URL Google disertai token dengan kode aneh yang panjang, dan anda bisa mengadopsinya dalam konsep yang sama sesuai kebutuhan anda.
Token Google API biasanya mempunyai panjang berkisar 140-162 karakter, sedangkan token oAuth berkisar 165 karakter. Berikut contoh pembangkitan token yang kemudian ditempelkan pada url:
/*******************************************
* MEMBUAT TOKEN UNTUK DITEMPELKAN PADA URL *
********************************************/
const getCallbackURL = ( callbackFunction ) => {
let googleWebAppsURL = 'https://script.google.com/macros/s/1234567890abcdefghijklmonpqrstuvwxyz/exec';
googleWebAppsURL = googleWebAppsURL.slice( 0, -4 ) + 'usercallback?state='; //ganti akhiran /exec menjadi /usercallback?state=
let stateToken = ScriptApp.newStateToken()
.withMethod( callbackFunction )
.withTimeout( 3600 )
.createToken();
return googleWebAppsURL + stateToken;
}
Logger.log( getCallbackURL( 'myFunction' ) );
Pengolahan Lanjutan Token
Di sini tidak dibahas pengolahan lanjutan dari token yang dibangkitkan tersebut. Anda bisa mendalaminya melalui contoh-contoh penerapannya dengan aplikasi populer seperti Facebook, Zoom, Yahoo, dll di Official Google Workspace Github dengan contoh penggunaannya di sini.
Dapatkan skrip semua materi di repository
Dukung donasi agar tutorial ini tetap operasional:
SiLiKiDi
Komentar
Posting Komentar