open-index/open-npm huggingface dataset:
npm package: @streamplace/chloride
Description: node.js sodium bindings + pure js polyfil
Author: Dominic Tarr
Latest version: 2.2.12

# chloride

Chloride is a Cryptography Library (Cl) for javascript enviroments.

## about

Chloride decends from Dan J. Bernstein's [NaCl](http://nacl.cr.yp.to/) library ("Networking And Cryptography Library",
not to be confused with the other NaCl, google's Native Client)
djb wrote nacl, but did not maintain it, some ideas in the library (in particular the networking part)
wasn't really fully baked, and the best parts where taken and maintained as [libsodium](http://libsodium.org)
(although "Na" represents the element sodium, so they took the wrong part of the acronym)

chloride is a compatibility layer that gives you bindings to [libsodium](https://npm.im/sodium) when used in node.js,
and either the [libsodium-wrappers](https://npm.im/libsodium-wrappers) which is libsodium compiled to javascript via [emscripten](http://kripken.github.io/emscripten-site/)
if performance is important but code size isn't.
Or, if you are not doing many crypto operations, it uses
[tweetnacl](https://www.npmjs.com/package/tweetnacl), which is a handwritten
port, and 1/10 the size of libsodium-wrappers.

## support

I have wrapped and tested enough functions for my crypto modules to work.

  * [private-box](https://github.com/auditdrivencrypto/private-box) write a shortish message to multiple recipients.
  * [pull-box-stream](https://github.com/dominictarr/pull-box-stream) encrypt (every byte in) a one-way stream.
  * [secret-handshake](https://github.com/dominictarr/secret-handshake) create an authenticated private channel to a public key.

This is probably everything you need, nacl doesn't have a very large api, so this is probably everything.

## do i need performance or code size?

nacl was written with performance in mind, unfortunately a lot of that is lost when you compile it to javascript.
However, chloride still has the fastest _javascript_ elliptic curve signature that I am aware of.
(and asymmetric crypto is much slower than symmetric, so this is always the weak point)

If you are only doing a symmetric ciphers (crypto_box) or a signature or two,
then performance is probably not a problem. If you are veryify _many_ signatures,
performance _may_ be a problem. Bear in mind that an asymetric operation
(sign, verify, scalarmult, keygen) are usually 50 times slower than a symmetric operation,
say a hash.

See [sodiumperf](https://github.com/dominictarr/sodiumperf) performance comparisons.

to run chloride in performance mode, load via

``` js
var chloride = require('chloride')
```
to run in low size mode

``` js
var chloride = require('chloride/small')
```

This only applies to enviroments that only support javascript.
If you are running this on the server and could compile sodium,
then you have the same fast crypto either way.

## License

MIT
npm package: @streamplace/react-scripts
Description: Configuration and scripts for Create React App.
Latest version: 1.1.4-fork

# react-scripts

This package includes scripts and configuration used by [Create React App](https://github.com/facebookincubator/create-react-app).<br>
Please refer to its documentation:

* [Getting Started](https://github.com/facebookincubator/create-react-app/blob/master/README.md#getting-started) – How to create a new app.
* [User Guide](https://github.com/facebookincubator/create-react-app/blob/master/packages/react-scripts/template/README.md) – How to develop apps bootstrapped with Create React App.
npm package: @streamplace/ssb-keys
Description: keyfile operations for ssb
Author: Paul Frazee
Latest version: 7.0.21

# SSB-Keys

supplies key loading and other cryptographic functions needed in secure-scuttlebutt apps.

```js
var ssbkeys = require('ssb-keys')

//usually, load keys like this
var keys = ssbkeys.loadOrCreateSync(filename)
/* => {
  id: String,
  public: String,
  private: String
}*/

//but for testing, .generate() is useful.
var keys = ssbkeys.generate()
/* => {
  id: String,
  public: String,
  private: String
}*/


//hmac_key is a fixed value that applies to _THIS_ signature use, see below.

var obj = ssbkeys.signObj(k, hmac_key, { foo: 'bar' })
console.log(obj) /* => {
  foo: 'bar',
  signature: ...
} */
ssbkeys.verifyObj(k, hmac_key, obj) // => true
```

## api

### loadOrCreateSync (filename)

Load a file containing the your private key. the file will also
contain a comment with a warning about keeping the file secret.

Works in the browser, or stores the keys is localStorage in the browser.
(web apps should be hosted a secure way, for example [web-bootloader](https://github.com/dominictarr/web-bootloader))

If the file does not exist it will be created. there is also
variations and parts `loadOrCreate` (async), `load`, `create`
`createSync` `loadSync`. But since you only need to load once,
using the combined function is easiest.

### generate(curve, seed)

generate a key, with optional seed.
curve defaults to `ed25519` (and no other type is currently supported)
seed should be a 32 byte buffer.

### signObj(keys, hmac_key?, obj)

signs a javascript object, and then adds a signature property to it.

If `hmac_key` is provided, the object is hmaced before signing,
which means it cannot be verified without the correct `hmac_key`.
If each way that signatures are used in your application use a different
hmac key, it means that a signature intended for one use cannot be reused in another
(chosen protocol attack)

### verifyObj(keys, hmac_key?, obj)

verify a signed object. `hmac_key` must be the same value as passed to `signObj`.

### box(msg, recipients)

encrypt a message to many recipients. msg will be JSON encoded, then encrypted
with [private-box](https://github.com/auditdrivencrypto/private-box)

### unbox (boxed, keys)

decrypt a message encrypted with `box`. If the `boxed` successfully decrypted,
the parsed JSON is returned, if not, `undefined` is returned.

### LICENSE

MIT
npm package: @streampot/server
Description: A CLI tool for launching a StreamPot server
Latest version: 0.4.0

### Building and running your application

When you're ready, start your application by running:
`docker compose up --build`.

Your application will be available at http://localhost:3000.

### Deploying your application to the cloud

First, build your image, e.g.: `docker build -t myapp .`.
If your cloud uses a different CPU architecture than your development
machine (e.g., you are on a Mac M1 and your cloud provider is amd64),
you'll want to build the image for that platform, e.g.:
`docker build --platform=linux/amd64 -t myapp .`.

Then, push it to your registry, e.g. `docker push myregistry.com/myapp`.

Consult Docker's [getting started](https://docs.docker.com/go/get-started-sharing/)
docs for more detail on building and pushing.

### References
* [Docker's Node.js guide](https://docs.docker.com/language/nodejs/)
npm package: @streamr/fetch
Description: A light-weight module that brings Fetch API to node.js
Latest version: 0.0.2

# @streamr/fetch

[`node-fetch`](https://www.npmjs.com/package/node-fetch) repackaged for ESM, CommonJS, & with a browser fallback.

### Build

```
npm run build
```

### Publish

The content of the package is located in `dist` directory along with a sanitized `package.json` file, and that's what gets published.

```
npm run publish
```

Don't use `npm publish`. The working copy of `package.json` (the one in the root directory of the repo) is marked private for safety.

If you need to run `npm publish` with more arguments use `--` to add them up like so:

```
npm run publish -- --dry-run
```