DEV Community: Va Da

Encrypt/decrypt with password

Va Da — Fri, 27 Dec 2024 17:12:28 +0000

Simple encryption/decription with password functions that work in Browser and Node.js

const bytesToString = (bytes) => new TextDecoder().decode(bytes);
const stringToBytes = (str) => new TextEncoder().encode(str);
const bytesToBase64 = (arr) => btoa(Array.from(arr, (b) => String.fromCharCode(b)).join(""));
const base64ToBytes = (base64) => Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));

export const getKey = async (password, salt) => {
  const bytes = stringToBytes(password);
  const initialKey = await crypto.subtle.importKey("raw", bytes, {name: "PBKDF2"}, false, ["deriveKey"]);
  return crypto.subtle.deriveKey(
    { name: "PBKDF2", salt, iterations: 100000, hash: "SHA-256" },
    initialKey,
    { name: "AES-GCM", length: 256 },
    false,
    ["encrypt", "decrypt"]
  );
};

export const encrypt = async (plaintext, password) => {
  const salt = crypto.getRandomValues(new Uint8Array(16));
  const key = await getKey(password, salt);
  const iv = crypto.getRandomValues(new Uint8Array(12));
  const contentBytes = stringToBytes(plaintext);
  const cipher = new Uint8Array(await crypto.subtle.encrypt({name: "AES-GCM", iv}, key, contentBytes));
  const line = `${bytesToBase64(salt)}:${bytesToBase64(iv)}:${bytesToBase64(cipher)}`;
  const decrypted = await decrypt(line, password);
  if (decrypted !== plaintext) throw new Error('Test decoding failed.');
  return line;
};

export const decrypt = async (line, password) => {
  const split = line.split(':');
  const encryptedData = {salt: split[0], iv: split[1], cipher: split[2]};
  const salt = base64ToBytes(encryptedData.salt);
  const key = await getKey(password, salt);
  const iv = base64ToBytes(encryptedData.iv);
  const cipher = base64ToBytes(encryptedData.cipher);
  const contentBytes = new Uint8Array(await crypto.subtle.decrypt({name: "AES-GCM", iv}, key, cipher));
  return bytesToString(contentBytes);
};

AI will solve all problems

Va Da — Mon, 19 Aug 2024 20:49:15 +0000

let todo = 'make peace and solve world hunger';
let url = 'http://api.openai.com/v1/_llama.php?tkn=' + todo;
let { solution } = await JSXHttpRequest().open('POST', url);

eval(solution);

Zero-overhead Async/Await

Va Da — Sun, 18 Aug 2024 09:10:40 +0000

Callbacks are significantly faster than Promises in Node.js. How can we get the performance of callbacks while benefiting from the Promise and async/await syntax?

JavaScript could introduce CallbackAwaitExpression, which syntactically would look very much like the existing AwaitExpression but it would operate on top of callbacks instead of promises.

The callbacks would have the following form:

type Callback<V, E = unknown> =
  | (error: E) => void;
  | (error: void, value: V) => void;

The new CallbackAwaitExpression would have an extra identifier parameter of type Callback, syntactically in between the await keyword and the expression being awaited, for example, note the cb identifier:

await cb fs.readFile('myfile.txt', 'utf-8', cb);

Likewise, the async function syntax would also be extended to allow AsyncCallbackFunction type. There as well, the syntax would allow a single callback identifier:

async cb function(args, cb) {
  // ...
}

Putting this all together, this would allow to write async/await syntax-powered code, while benefiting from the performance of callbacks. It would allow to write code like this:

async _ function getFileData(filename, _) {
  try {
    const data = await _ fs.readFile('myfile.txt', 'utf-8', _);
    return 'mydata: ' + data;
  } catch (error) {
    if (!!error && typeof error === 'object' && error.code === 'ENOENT') {
      throw new Error('not found');
    }
    throw error;
  }
}

The code would be equivalent to the existing JavaScript:

function getFileData(filename, callback) {
  const onCatch = (error) => {
    if (!!error && typeof error === 'object' && error.code === 'ENOENT') {
      callback(new Error('not found'));
    } else {
      callback(error);
    }
  };
  try {
    fs.readFile('myfile.txt', 'utf-8', (err, data) => {
      if (err) {
        onCatch(err);
      } else {
        try {
          callback(null, 'mydata: ' + data);
        } catch (error) {
          onCatch(error);
        }
      }
    });
  } catch (error) {
    onCatch(error);
  }
}

Here is how the above code can look like using the existing async/await syntax. The code is almost equivalent to the async/await callback proposal, but less performant due to Promise usage.

async function getFileDataAsync(filename) {
    try {
    const data = await promisify(fs.readFile)('myfile.txt', 'utf-8');
    return 'mydata: ' + data;
  } catch (error) {
    if (!!error && typeof error === 'object' && error.code === 'ENOENT') {
      throw new Error('not found');
    }
    throw error;
  }
}

Or, equivalently, the good old promisify utility could convert our callback powered function to this Promise powered one:

const getFileDataAsync = promisify(getFileData);

Sugar Syntax

When awaiting one can explicitly specify the callback identifier and explicitly use it as an argument:

await myCallback fs.readFile('a.txt', myCallback)

If the await identifier myCallback is not used, it is automatically inserted in the function call as the last argument:

await _ fs.readFile('a.txt')

When defining an async callback function, the above text proposed to explicitly specify the callback identifier, like so:

async myCallback function getData(filename, myCallback) {}

Instead it can be reduced by simply using the async keyword once, in place of some argument:

function getData(filename, async) {}

The above syntax modifications reduce the example getFileData function to the following:

function getFileData(filename, async) {
  try {
    const data = await _ fs.readFile('myfile.txt', 'utf-8');
    return 'mydata: ' + data;
  } catch (error) {
    // ...
  }
}

Using with TypeScript

From the point of view of TypeScript, to define a new async callback function, one can simply use the CallbackType:

type GetFileData = (filename: string, callback: Callback<string>) => void;

Alternatively, the async type shorthand could be introduced, to make it more explicit:

type GetFileData = (filename: string, async<string>) => void;

Maybe it could be called callback:

type GetFileData = (filename: string, callback<string>) => void;

Fuzz testing list CRDTs

Va Da — Fri, 16 Jun 2023 16:56:40 +0000

In this lates blog post we take a look how json-joy tests its RGA list CRDT implementation. json-joy implementation is highly optimized, and optimizations themselves lead to bugs. We use three different fuzzers to verify correctness of our list CRDT implementation:

A fuzzer which simulates two random users editing.

A fuzzer which simulates multiple random users editing.

And finally, a fuzzer which simulates whole JSON, including string CRDT and array CRDT operations, of multiple users concurrently editing a document.

JSON serialization benchmarks in JavaScript

Va Da — Tue, 13 Jun 2023 13:50:54 +0000

When you pick a binary JSON serializer from NPM, make sure to check the benchmarks. As it stands, if you need to use CBOR or MessagePack, your best bet is to use json-joy, msgpackr or cbor-x. Maybe, if you really like the features of @msgpack/msgpack, you can use that, but it is not as fast as the other three. Pretty much all other NPM packages are significantly slower than the three mentioned above — if you just pick a random package from NPM, you will most likely get an order of magnitude worse performance than what built-in JSON global provides.

json-joy NPM package ships zero-dependency open source json-pack module, which is the fastest implementations of MessagePack, CBOR, and JSON codecs available for JavaScript. How fast is it?

In this benchmarking blog post we take a look at serialization speeds of various NPM implementations of JSON-like codecs, such as MessagePack, CBOR, JSON, UBJSON, and Amazon Ion.

First post

Va Da — Sun, 21 May 2023 00:48:38 +0000

Testing...