crypto es
v2.0.4
Perpustakaan Algoritma Kriptografi Kompatibel dengan ES6 dan TypeScript
Instalasi:
yarn add crypto-es
Dalam proyek Node.js, kami menyarankan Anda untuk menggunakan modul ecmascript Insead of Commonjs:
// package.json
{
"type": "module"
}
Maka Anda dapat mengimpor cryptoes:
import CryptoES from 'crypto-es';
const rst = CryptoES.MD5("Message").toString();
Atau sebagian mengimpor fungsi untuk mengurangi berat paket:
import { MD5 } from 'crypto-es/lib/md5.js';
const rst = MD5("Message").toString();
Setiap file di perpustakaan ini memiliki file .d.ts sendiri sekarang, sehingga tersedia sebagian untuk mengimpor sebagian file algoritma dalam proyek TypeScript.
Sama seperti cryptojs
Md5
MD5 adalah fungsi hash yang banyak digunakan. Ini telah digunakan dalam berbagai aplikasi keamanan dan juga umumnya digunakan untuk memeriksa integritas file. Padahal, MD5 tidak tahan tabrakan, dan tidak cocok untuk aplikasi seperti sertifikat SSL atau tanda tangan digital yang mengandalkan properti ini.
const hash = CryptoES.MD5("Message");
Sha-1
Fungsi hash SHA dirancang oleh Badan Keamanan Nasional (NSA). SHA-1 adalah yang paling mapan dari fungsi hash SHA yang ada, dan digunakan dalam berbagai aplikasi dan protokol keamanan. Padahal, resistensi tabrakan SHA-1 telah melemah ketika serangan baru ditemukan atau ditingkatkan.
const hash = CryptoES.SHA1("Message");
Sha-2
SHA-256 adalah salah satu dari empat varian di set SHA-2. Ini tidak banyak digunakan seperti SHA-1, meskipun tampaknya memberikan keamanan yang jauh lebih baik.
const hash = CryptoES.SHA256("Message");
SHA-512 sebagian besar identik dengan SHA-256 tetapi beroperasi dengan kata-kata 64-bit daripada 32.
const hash = CryptoES.SHA512("Message");
Cryptoes juga mendukung SHA-224 dan SHA-384, yang masing-masing sebagian besar identik tetapi terpotong dari SHA-256 dan SHA-512.
Sha-3
SHA-3 adalah pemenang kompetisi lima tahun untuk memilih algoritma hash kriptografi baru di mana 64 desain yang bersaing dievaluasi.
Catatan: Saya membuat kesalahan ketika saya menamai implementasi ini SHA-3. Itu harus dinamai Keccak [C = 2D]. Masing-masing fungsi SHA-3 didasarkan pada contoh algoritma Keccak, yang dipilih NIST sebagai pemenang kompetisi SHA-3, tetapi fungsi SHA-3 itu tidak akan menghasilkan hash yang identik dengan Keccak.
const hash = CryptoES.SHA3("Message");
SHA-3 dapat dikonfigurasi ke output hash length dari salah satu dari 224, 256, 384, atau 512 bit. Standarnya adalah 512 bit.
const hash = CryptoES.SHA3("Message", { outputLength: 512 });
const hash = CryptoES.SHA3("Message", { outputLength: 384 });
const hash = CryptoES.SHA3("Message", { outputLength: 256 });
const hash = CryptoES.SHA3("Message", { outputLength: 224 });
RIPEMD-160
const hash = CryptoES.RIPEMD160("Message");
Algoritma hash menerima string atau contoh cryptoes.lib.wordarray. Objek WordArray mewakili array kata 32-bit. Saat Anda melewati string, itu secara otomatis dikonversi ke WordArray yang dikodekan sebagai UTF-8.
Hash yang Anda dapatkan belum menjadi string. Ini adalah objek WordArray. Saat Anda menggunakan objek WordArray dalam konteks string, itu secara otomatis dikonversi ke string hex.
const hash = CryptoES.SHA256("Message");
alert(typeof hash); // object
alert(hash); // 2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91
Anda dapat mengonversi objek WordArray ke format lain dengan secara eksplisit memanggil metode tostring dan melewati encoder.
const hash = CryptoES.SHA256("Message");
alert(hash.toString(CryptoES.enc.Base64)); // L3dmip37+NWEi57rSnFFypTG7ZI25Kdz9tyvpRMrL5E= alert(hash.toString(CryptoES.enc.Latin1)); // /wf��ûøÕ���ëJqEÊ�Æí�6ä§söܯ¥�+/�
alert(hash.toString(CryptoES.enc.Hex)); // 2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91
const sha256 = CryptoES.algo.SHA256.create();
sha256.update("Message Part 1");
sha256.update("Message Part 2");
sha256.update("Message Part 3");
const hash = sha256.finalize();
Kode Otentikasi Pesan Keyed-Hash (HMAC) adalah mekanisme untuk otentikasi pesan menggunakan fungsi hash kriptografi.
HMAC dapat digunakan dalam kombinasi dengan fungsi hash kriptografi yang diulang.
const hash = CryptoES.HmacMD5("Message", "Secret Passphrase");
const hash = CryptoES.HmacSHA1("Message", "Secret Passphrase");
const hash = CryptoES.HmacSHA256("Message", "Secret Passphrase");
const hash = CryptoES.HmacSHA512("Message", "Secret Passphrase");
const hmac = CryptoES.algo.HMAC.create(CryptoES.algo.SHA256, "Secret Passphrase");
hmac.update("Message Part 1");
hmac.update("Message Part 2");
hmac.update("Message Part 3");
const hash = hmac.finalize();
PBKDF2 adalah fungsi derivasi kunci berbasis kata sandi. Dalam banyak aplikasi kriptografi, keamanan pengguna pada akhirnya tergantung pada kata sandi, dan karena kata sandi biasanya tidak dapat digunakan secara langsung sebagai kunci kriptografi, beberapa pemrosesan diperlukan.
Garam memberikan satu set kunci besar untuk kata sandi apa pun, dan jumlah iterasi meningkatkan biaya menghasilkan kunci dari kata sandi, sehingga juga meningkatkan kesulitan serangan.
const salt = CryptoES.lib.WordArray.random(128/8);
const key128Bits = CryptoES.PBKDF2("Secret Passphrase", salt, { keySize: 128/32 });
const key256Bits = CryptoES.PBKDF2("Secret Passphrase", salt, { keySize: 256/32 });
const key512Bits = CryptoES.PBKDF2("Secret Passphrase", salt, { keySize: 512/32 });
const key512Bits1000Iterations = CryptoES.PBKDF2("Secret Passphrase", salt, { keySize: 512/32, iterations: 1000 });
AES
Standar Enkripsi Advanced (AES) adalah Standar Pemrosesan Informasi Federal AS (FIPS). Itu dipilih setelah proses 5 tahun di mana 15 desain yang bersaing dievaluasi.
const encrypted = CryptoES.AES.encrypt("Message", "Secret Passphrase");
const decrypted = CryptoES.AES.decrypt(encrypted, "Secret Passphrase");
Cryptoes mendukung AES-128, AES-192, dan AES-256. Ini akan memilih varian berdasarkan ukuran kunci yang Anda lewati. Jika Anda menggunakan frasa sandi, maka itu akan menghasilkan kunci 256-bit.
Des, Triple Des
DES adalah algoritma yang sebelumnya dominan untuk enkripsi, dan diterbitkan sebagai standar pemrosesan informasi federal resmi (FIPS). DES sekarang dianggap tidak aman karena ukuran kunci kecil.
const encrypted = CryptoES.DES.encrypt("Message", "Secret Passphrase");
const decrypted = CryptoES.DES.decrypt(encrypted, "Secret Passphrase");
Triple DES berlaku DES tiga kali untuk setiap blok untuk meningkatkan ukuran kunci. Algoritma ini diyakini aman dalam bentuk ini.
const encrypted = CryptoES.TripleDES.encrypt("Message", "Secret Passphrase");
const decrypted = CryptoES.TripleDES.decrypt(encrypted, "Secret Passphrase");
Kelinci
Kelinci adalah cipher aliran berkinerja tinggi dan finalis dalam portofolio Estream. Ini adalah salah satu dari empat desain yang dipilih setelah proses 3 1/2 tahun di mana 22 desain dievaluasi.
const encrypted = CryptoES.Rabbit.encrypt("Message", "Secret Passphrase");
const decrypted = CryptoES.Rabbit.decrypt(encrypted, "Secret Passphrase");
RC4, RC4Drop
RC4 adalah cipher aliran yang banyak digunakan. Ini digunakan dalam protokol populer seperti SSL dan WEP. Meskipun luar biasa karena kesederhanaan dan kecepatannya, sejarah algoritma tidak menginspirasi kepercayaan pada keamanannya.
const encrypted = CryptoES.RC4.encrypt("Message", "Secret Passphrase");
const decrypted = CryptoES.RC4.decrypt(encrypted, "Secret Passphrase");
Ditemukan bahwa beberapa byte keystream pertama sangat non-acak dan informasi bocor tentang kunci tersebut. Kita dapat bertahan melawan serangan ini dengan membuang bagian awal keystream. Algoritma yang dimodifikasi ini secara tradisional disebut RC4-Drop.
Secara default, 192 kata (768 byte) dijatuhkan, tetapi Anda dapat mengkonfigurasi algoritma untuk menjatuhkan sejumlah kata.
const encrypted = CryptoES.RC4Drop.encrypt("Message", "Secret Passphrase");
const encrypted = CryptoES.RC4Drop.encrypt("Message", "Secret Passphrase", { drop: 3072/4 });
const decrypted = CryptoES.RC4Drop.decrypt(encrypted, "Secret Passphrase", { drop: 3072/4 });
Blowfish
Blowfish adalah cipher blok kunci simetris, yang dirancang pada tahun 1993 oleh Bruce Schneier dan termasuk dalam banyak cipher suite dan produk enkripsi. Blowfish memberikan tingkat enkripsi yang baik dalam perangkat lunak, dan tidak ada kriptanalisis yang efektif telah ditemukan hingga saat ini. Namun, Standar Enkripsi Lanjutan (AES) sekarang menerima lebih banyak perhatian, dan Schneier merekomendasikan TwoFish untuk aplikasi modern.
Schneier merancang blowfish sebagai algoritma tujuan umum, dimaksudkan sebagai alternatif dari DES yang sudah tua dan bebas dari masalah dan kendala yang terkait dengan algoritma lainnya. Pada saat Blowfish dirilis, banyak desain lainnya adalah milik, dibebani oleh paten, atau rahasia komersial atau pemerintah. Schneier telah menyatakan bahwa "Blowfish tidak terpatahkan, dan akan tetap demikian di semua negara. Algoritma ini ditempatkan di domain publik, dan dapat digunakan secara bebas oleh siapa pun."
Fitur penting dari desain termasuk kotak-S yang bergantung pada kunci dan jadwal utama yang sangat kompleks.
const ciphertext = CryptoJS.Blowfish.encrypt(message, key, cfg);
const plaintext = CryptoJS.Blowfish.decrypt(ciphertext, key, cfg);
const key = CryptoES.enc.Hex.parse('000102030405060708090a0b0c0d0e0f');
const iv = CryptoES.enc.Hex.parse('101112131415161718191a1b1c1d1e1f');
const encrypted = CryptoES.AES.encrypt("Message", key, { iv: iv });
const encrypted = CryptoES.AES.encrypt("Message", "Secret Passphrase", { mode: CryptoES.mode.CFB, padding: CryptoES.pad.AnsiX923 });
Cryptoes mendukung mode berikut:
Dan cryptoes mendukung skema padding berikut:
Untuk pesan plaintext, algoritma cipher menerima string atau contoh cryptoes.lib.wordarray.
Untuk kunci, ketika Anda melewati string, itu diperlakukan sebagai frasa sandi dan digunakan untuk mendapatkan kunci dan IV yang sebenarnya. Atau Anda dapat melewati WordArray yang mewakili kunci yang sebenarnya. Jika Anda melewati kunci yang sebenarnya, Anda juga harus melewati IV yang sebenarnya.
Untuk ciphertext, algoritma cipher menerima baik string atau contoh cryptoes.lib.cipherparams. Objek cipherparams mewakili kumpulan parameter seperti IV, garam, dan ciphertext mentah itu sendiri. Saat Anda melewati string, secara otomatis dikonversi ke objek CipherParams sesuai dengan strategi format yang dapat dikonfigurasi.
Plaintext yang Anda dapatkan setelah dekripsi adalah objek WordArray. Lihat output Hashers untuk lebih detail.
Ciphertext yang Anda dapatkan kembali setelah enkripsi belum menjadi string. Ini adalah objek cipherparams. Objek cipherparams memberi Anda akses ke semua parameter yang digunakan selama enkripsi. Saat Anda menggunakan objek CipherParams dalam konteks string, itu secara otomatis dikonversi ke string sesuai dengan strategi format. Defaultnya adalah format yang kompatibel dengan openssl.
const encrypted = CryptoES.AES.encrypt("Message", "Secret Passphrase"); alert(encrypted.key); // 74eb593087a982e2a6f5dded54ecd96d1fd0f3d44a58728cdcd40c55227522223
alert(encrypted.iv); // 7781157e2629b094f0e3dd48c4d786115
alert(encrypted.salt); // 7a25f9132ec6a8b34
alert(encrypted.ciphertext); // 73e54154a15d1beeb509d9e12f1e462a0
alert(encrypted); // U2FsdGVkX1+iX5Ey7GqLND5UFUoV0b7rUJ2eEvHkYqA=
Anda dapat mendefinisikan format Anda sendiri agar dapat kompatibel dengan implementasi crypto lainnya. Format adalah objek dengan dua metode - stringify dan parse - yang dikonversi antara objek cipherparams dan string ciphertext.
Begini cara Anda menulis formatter JSON:
const JsonFormatter = {
stringify: function (cipherParams) { // create json object with ciphertext
const jsonObj = { ct: cipherParams.ciphertext.toString(CryptoES.enc.Base64) }; // optionally add iv and salt
if (cipherParams.iv) {
jsonObj.iv = cipherParams.iv.toString();
}
if (cipherParams.salt) {
jsonObj.s = cipherParams.salt.toString();
}
// stringify json object
return JSON.stringify(jsonObj);
},
parse: function (jsonStr) { // parse json string
const jsonObj = JSON.parse(jsonStr); // extract ciphertext from json object, and create cipher params object
const cipherParams = CryptoES.lib.CipherParams.create(
{ ciphertext: CryptoES.enc.Base64.parse(jsonObj.ct) },
); // optionally extract iv and salt
if (jsonObj.iv) {
cipherParams.iv = CryptoES.enc.Hex.parse(jsonObj.iv)
}
if (jsonObj.s) {
cipherParams.salt = CryptoES.enc.Hex.parse(jsonObj.s)
}
return cipherParams;
},
};
const encrypted = CryptoES.AES.encrypt(
"Message",
"Secret Passphrase",
{ format: JsonFormatter },
);
alert(encrypted); // {"ct":"tZ4MsEnfbcDOwqau68aOrQ==","iv":"8a8c8fd8fe33743d3638737ea4a00698","s":"ba06373c8f57179c"}
const decrypted = CryptoES.AES.decrypt(
encrypted,
"Secret Passphrase",
{ format: JsonFormatter },
);
alert(decrypted.toString(CryptoES.enc.Utf8)); // Message
const key = CryptoES.enc.Hex.parse('000102030405060708090a0b0c0d0e0f');
const iv = CryptoES.enc.Hex.parse('101112131415161718191a1b1c1d1e1f');
const aesEncryptor = CryptoES.algo.AES.createEncryptor(key, { iv: iv });
const ciphertextPart1 = aesEncryptor.process("Message Part 1");
const ciphertextPart2 = aesEncryptor.process("Message Part 2");
const ciphertextPart3 = aesEncryptor.process("Message Part 3");
const ciphertextPart4 = aesEncryptor.finalize();
const aesDecryptor = CryptoES.algo.AES.createDecryptor(key, { iv: iv });
const plaintextPart1 = aesDecryptor.process(ciphertextPart1);
const plaintextPart2 = aesDecryptor.process(ciphertextPart2);
const plaintextPart3 = aesDecryptor.process(ciphertextPart3);
const plaintextPart4 = aesDecryptor.process(ciphertextPart4);
const plaintextPart5 = aesDecryptor.finalize();
Dengan openssl
Enkripsi dengan OpenSSL:
openssl enc -aes-256-cbc -in infile -out outfile -pass pass:"Secret Passphrase" -e -base64
Dekripsi dengan Cryptoes:
const decrypted = CryptoES.AES.decrypt(openSSLEncrypted, "Secret Passphrase");
Crypto dapat dikonversi dari format pengkodean seperti Base64, Latin1 atau Hex ke WordArray Objects dan Vica Versa.
const words = CryptoES.enc.Base64.parse('SGVsbG8sIFdvcmxkIQ==');
const base64 = CryptoES.enc.Base64.stringify(words);
const words = CryptoES.enc.Base64url.parse('SGVsbG8sIFdvcmxkIQ==');
const base64url = CryptoES.enc.Base64.stringify(words);
const words = CryptoES.enc.Latin1.parse('Hello, World!');
const latin1 = CryptoES.enc.Latin1.stringify(words);
const words = CryptoES.enc.Hex.parse('48656c6c6f2c20576f726c6421');
const hex = CryptoES.enc.Hex.stringify(words);
const words = CryptoES.enc.Utf8.parse('?');
const utf8 = CryptoES.enc.Utf8.stringify(words);
const words = CryptoES.enc.Utf16.parse('Hello, World!');
const utf16 = CryptoES.enc.Utf16.stringify(words);
const words = CryptoES.enc.Utf16LE.parse('Hello, World!');
const utf16 = CryptoES.enc.Utf16LE.stringify(words);
Pencipta WordArray dapat menerima arraybuffer atau TypedArray sehingga algorisme krim dapat berlaku untuk mereka:
const words = CryptoES.lib.WordArray.create(new ArrayBuffer(8));
const rst = CryptoES.AES.encrypt(words, 'Secret Passphrase')
Catatan : ArrayBuffer tidak dapat langsung diteruskan ke algorisme, Anda harus mengubahnya menjadi WordArray terlebih dahulu.
Dengan ini, enkripsi file akan lebih mudah:
const fileInput = document.getElementById('fileInput');
const file = fileInput.files[0];
const reader = new FileReader();
reader.readAsArrayBuffer(file);
reader.onload = function () {
const arrayBuffer = reader.result;
const words = CryptoES.lib.WordArray.create(arrayBuffer);
const rst = CryptoES.AES.encrypt(words, 'Secret Passphrase')
...
};
Ubah log
Refactoring cryptojs dalam ecmascript modern
