function stringToUint8Array(str) {
const length = str.length;
const uint8Array = new Uint8Array(length);
for (let i = 0; i < length; i++) {
uint8Array[i] = str.charCodeAt(i);
}
return uint8Array;
}
async function processAES256(action, plainText, password, iv){
var enc = new TextEncoder();
var salt = 'hY0wTq6xwc6ni01G';
var iterations = 1001;
var keyLength = 32; // 32 bytes for AES-256 (256 bits)
var digest = 'SHA-1';
var resultTxt = '';
iv = enc.encode(iv);
try {
var derivedKey = await generatePBKDF2(password, salt, iterations, keyLength, digest);
if(action == 'encrypt'){
//Encrypt
resultTxt = await encryptWithAES256(plainText, derivedKey, iv);
}else if(action == 'decrypt'){
//Decrypt
resultTxt = await decryptWithAES256(plainText, derivedKey, iv);
}
} catch (error) {
console.error('Error generating PBKDF2 or performing AES-256 encryption/decryption ('+action+'):', error);
}
return resultTxt;
}
async function generatePBKDF2(password, salt, iterations, keyLength, digest) {
const encoder = new TextEncoder();
const importedKey = await crypto.subtle.importKey(
'raw',
encoder.encode(password),
{ name: 'PBKDF2' },
false,
['deriveBits']
);
const derivedBits = await crypto.subtle.deriveBits(
{
name: 'PBKDF2',
salt: encoder.encode(salt),
iterations: iterations,
hash: digest
},
importedKey,
keyLength * 8 // Key length in bits
);
return crypto.subtle.importKey(
'raw',
derivedBits,
{ name: 'AES-CBC' },
false,
['encrypt', 'decrypt']
);
}
async function encryptWithAES256(plainText, derivedKey, iv) {
const encodedText = new TextEncoder().encode(plainText);
const encryptedData = await crypto.subtle.encrypt(
{ name: 'AES-CBC', iv: iv },
derivedKey,
encodedText
);
return arrayBufferToBase64(encryptedData);
}
async function decryptWithAES256(encryptedTxt, derivedKey, iv) {
//var iv = new Uint8Array(iv);
const encryptedData = new Uint8Array(base64ToArrayBuffer(encryptedTxt));
const decryptedData = await crypto.subtle.decrypt(
{ name: 'AES-CBC', iv: iv },
derivedKey,
encryptedData
);
const decodedText = new TextDecoder().decode(decryptedData);
return decodedText;
}
function arrayBufferToBase64( buffer ) {
var binary = '';
var bytes = new Uint8Array( buffer );
var len = bytes.byteLength;
for (var i = 0; i < len; i++) {
binary += String.fromCharCode( bytes[ i ] );
}
return window.btoa( binary );
}
function base64ToArrayBuffer(base64) {
var binaryString = atob(base64);
var bytes = new Uint8Array(binaryString.length);
for (var i = 0; i < binaryString.length; i++) {
bytes[i] = binaryString.charCodeAt(i);
}
return bytes.buffer;
}
async function generateSecureKey() {
const key = await crypto.subtle.generateKey(
{
name: "AES-CBC",
length: 256
},
true, // extractable
["encrypt", "decrypt"]
);
const keyData = await crypto.subtle.exportKey("raw", key);
const keyString = arrayBufferToBase64(keyData);
return keyString;
}
function generateSecureIV() {
const iv = crypto.getRandomValues(new Uint8Array(16));
return arrayBufferToBase64(iv);
}