https://github.com/tniessen/node-mceliece-nist

Node.js bindings for the reference implementation of the Classic McEliece KEM.
https://github.com/tniessen/node-mceliece-nist

crypto mceliece nodejs post-quantum-cryptography pqc webassembly

Last synced: about 2 months ago
JSON representation

Node.js bindings for the reference implementation of the Classic McEliece KEM.

• Host: GitHub
• URL: https://github.com/tniessen/node-mceliece-nist
• Owner: tniessen
• Created: 2019-10-06T21:56:12.000Z (over 5 years ago)
• Default Branch: main
• Last Pushed: 2024-11-02T12:23:38.000Z (2 months ago)
• Last Synced: 2024-11-08T13:02:15.680Z (2 months ago)
• Topics: crypto, mceliece, nodejs, post-quantum-cryptography, pqc, webassembly
• Language: C++
• Homepage:
• Size: 392 KB
• Stars: 11
• Watchers: 3
• Forks: 8
• Open Issues: 0
• Metadata Files:
  • Readme: README.md

Awesome Lists containing this project

README

        
# mceliece-nist

This package provides Node.js bindings for the reference implementation that is

part of the [NIST submission](https://classic.mceliece.org/nist.html) by

Bernstein et al.

This version is based on the round-4 submission `mceliece-20221023`.

See [`deps/mceliece`](deps/mceliece).

## Installation

Installation should work as usual:

```sh

npm i mceliece-nist

```

## Example

```javascript

const { McEliece } = require('mceliece-nist');

const kem = new McEliece('mceliece8192128');

const { publicKey, privateKey } = kem.keypair();

const { key, encryptedKey } = kem.generateKey(publicKey);

console.log(`Bob is using the key ${key.toString('hex')}`);

const receivedKey = kem.decryptKey(privateKey, encryptedKey);

console.log(`Alice is using the key ${receivedKey.toString('hex')}`);

```

## API

The package exports a single class, `McEliece`.

### Class `McEliece`

#### `new McEliece(algorithm)`

Creates a new instance using the specified algorithm. `algorithm` must be one of

the values contained in `McEliece.supportedAlgorithms`.

#### `McEliece.supportedAlgorithms`

This static field is an array of all supported algorithms.

#### `instance.keySize`

The (maximum) key size in bytes that this instance can encapsulate.

#### `instance.encryptedKeySize`

The size of the encapsulated key in bytes.

#### `instance.publicKeySize`

The size of the public key in bytes.

#### `instance.privateKeySize`

The size of the private key in bytes.

#### `instance.keypair([callback])`

Creates and returns a new key pair `{ publicKey, privateKey }`. Both keys will

be returned as `Buffer`s.

If `callback` is a function, `keypair` immediately returns `undefined` and calls

`callback(err, { publicKey, privateKey })` as soon as a new keypair has been

generated.

#### `instance.generateKey(publicKey)`

Generates a new symmetric key and encrypts it using the given `publicKey`.

Returns `{ key, encryptedKey }`, both objects will be `Buffer`s.

#### `instance.decryptKey(privateKey, encryptedKey[, callback])`

Decrypts the `encryptedKey` that was returned by

`instance.generateKey(publicKey)` and returns the decrypted key as a `Buffer`.

If `callback` is a function, `decryptKey` immediately returns `undefined` and

calls `callback(err, key)` as soon as the key has been decrypted.

## License

This project is distributed under the ISC license.