mirror of
https://github.com/Effect-TS/effect.git
synced 2026-11-21 02:01:57 +08:00
156 lines
7.6 KiB
TypeScript
156 lines
7.6 KiB
TypeScript
import * as NodeCrypto from "@effect/platform-node/NodeCrypto"
|
|
import { assert, describe, it } from "@effect/vitest"
|
|
import * as Aead from "effect/crypto/Aead"
|
|
import * as Digest from "effect/crypto/Digest"
|
|
import * as Kdf from "effect/crypto/Kdf"
|
|
import * as Mac from "effect/crypto/Mac"
|
|
import * as SecureRandom from "effect/crypto/SecureRandom"
|
|
import * as Effect from "effect/Effect"
|
|
import * as Hex from "effect/encoding/Hex"
|
|
import * as Layer from "effect/Layer"
|
|
import * as Result from "effect/Result"
|
|
import * as NodeCryptoModule from "node:crypto"
|
|
|
|
const encode = (text: string): Uint8Array => new TextEncoder().encode(text)
|
|
const bytes = (hex: string): Uint8Array => Result.getOrThrow(Hex.decode(hex))
|
|
|
|
// RFC 8439, section 2.8.2, and draft-irtf-cfrg-xchacha-03, Appendix A.3.1.
|
|
const sunscreen = encode(
|
|
"Ladies and Gentlemen of the class of '99: If I could offer you only one tip for the future, sunscreen would be it."
|
|
)
|
|
const chachaKey = "808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f"
|
|
const aeadVectors: ReadonlyArray<readonly [Aead.Algorithm, string, string, string]> = [
|
|
[
|
|
Aead.chacha20Poly1305,
|
|
chachaKey,
|
|
"070000004041424344454647",
|
|
"d31a8d34648e60db7b86afbc53ef7ec2a4aded51296e08fea9e2b5a736ee62d63dbea45e8ca9671282fafb69da92728b" +
|
|
"1a71de0a9e060b2905d6a5b67ecd3b3692ddbd7f2d778b8c9803aee328091b58fab324e4fad675945585808b4831d7bc" +
|
|
"3ff4def08e4b7a9de576d26586cec64b61161ae10b594f09e26a7e902ecbd0600691"
|
|
],
|
|
[
|
|
Aead.xchacha20Poly1305,
|
|
chachaKey,
|
|
"404142434445464748494a4b4c4d4e4f5051525354555657",
|
|
"bd6d179d3e83d43b9576579493c0e939572a1700252bfaccbed2902c21396cbb731c7f1b0b4aa6440bf3a82f4eda7e39" +
|
|
"ae64c6708c54c216cb96b72e1213b4522f8c9ba40db5d945b11b69b982c1bb9e3f3fac2bc369488f76b2383565d3fff9" +
|
|
"21f9664c97637da9768812f615c68b13b52ec0875924c1c7987947deafd8780acf49"
|
|
]
|
|
]
|
|
|
|
describe("NodeCrypto", () => {
|
|
it.effect("layerDigest computes MD5 and SHA digests", () =>
|
|
Effect.gen(function*() {
|
|
const digest = yield* Digest.Digest
|
|
const abc = new TextEncoder().encode("abc")
|
|
// RFC 1321 and FIPS 180-2 "abc" vectors.
|
|
assert.strictEqual(yield* digest.digestHex(Digest.md5, abc), "900150983cd24fb0d6963f7d28e17f72")
|
|
assert.strictEqual(yield* digest.digestHex(Digest.sha1, abc), "a9993e364706816aba3e25717850c26c9cd0d89d")
|
|
assert.strictEqual(
|
|
yield* digest.digestHex(Digest.sha256, abc),
|
|
"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
|
|
)
|
|
assert.strictEqual((yield* digest.digest(Digest.sha512, abc)).length, 64)
|
|
}).pipe(Effect.provide(NodeCrypto.layerDigest)))
|
|
|
|
it.effect("layerMac signs with byte-backed and CryptoKey-backed keys", () =>
|
|
Effect.gen(function*() {
|
|
const mac = yield* Mac.Mac
|
|
// RFC 4231, test case 2.
|
|
const secret = encode("Jefe")
|
|
const message = encode("what do ya want for nothing?")
|
|
const expected = "5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843"
|
|
const cryptoKey = yield* Effect.promise(() =>
|
|
globalThis.crypto.subtle.importKey("raw", secret as BufferSource, { name: "HMAC", hash: "SHA-256" }, false, [
|
|
"sign",
|
|
"verify"
|
|
])
|
|
)
|
|
for (const key of [yield* Mac.key(Mac.hmacSha256, secret), yield* Mac.fromCryptoKey(Mac.hmacSha256, cryptoKey)]) {
|
|
const tag = yield* mac.sign(key, message)
|
|
assert.strictEqual(Hex.encode(tag), expected)
|
|
assert.isTrue(yield* mac.verify(key, tag, message))
|
|
assert.isFalse(yield* mac.verify(key, tag.subarray(1), message))
|
|
}
|
|
}).pipe(Effect.provide(NodeCrypto.layerMac.pipe(Layer.provide(SecureRandom.layerWebCrypto)))))
|
|
|
|
it.effect("layerKdf derives Argon2id where node:crypto has it, and HKDF through the core implementation", () =>
|
|
Effect.gen(function*() {
|
|
const kdf = yield* Kdf.Kdf
|
|
const password = encode("password")
|
|
const salt = encode("somesalt")
|
|
// From the Argon2 reference CLI: `argon2 somesalt -id -t 2 -k 64 -p 1 -l 32`.
|
|
const argon2id = Kdf.argon2id({ memory: 64, passes: 2, parallelism: 1 })
|
|
if (typeof NodeCryptoModule.argon2 === "function") {
|
|
assert.strictEqual(
|
|
Hex.encode(yield* kdf.derive(argon2id, password, { salt, length: 32 })),
|
|
"16a1a498734609dd01456da406de9f3d9da93e6c86c300a12fc1465214ce4922"
|
|
)
|
|
} else {
|
|
const error = yield* Effect.flip(kdf.derive(argon2id, password, { salt, length: 32 }))
|
|
assert.strictEqual(error.reason._tag, "Unsupported")
|
|
}
|
|
// RFC 5869, test case 3.
|
|
assert.strictEqual(
|
|
Hex.encode(
|
|
yield* kdf.derive(Kdf.hkdfSha256, new Uint8Array(22).fill(0x0b), { salt: new Uint8Array(), length: 42 })
|
|
),
|
|
"8da4e775a563c18f715f802a063c5a31b8a11f5c5ee1879ec3454e5f3c738d2d9d201395faa4b61a96c8"
|
|
)
|
|
}).pipe(Effect.provide(NodeCrypto.layerKdf)))
|
|
|
|
it.effect("layerAead encrypts ChaCha20-Poly1305 on node:crypto and the other algorithms through the core implementation", () =>
|
|
Effect.gen(function*() {
|
|
const aead = yield* Aead.Aead
|
|
const aad = bytes("50515253c0c1c2c3c4c5c6c7")
|
|
for (const [algorithm, keyHex, nonceHex, expected] of aeadVectors) {
|
|
const key = yield* Aead.key(algorithm, bytes(keyHex))
|
|
const nonce = bytes(nonceHex)
|
|
const sealed = yield* aead.encrypt(key, sunscreen, { nonce, aad })
|
|
assert.strictEqual(Hex.encode(sealed), expected)
|
|
assert.deepStrictEqual(yield* aead.decrypt(key, sealed, { nonce, aad }), sunscreen)
|
|
sealed[sealed.length - 1] ^= 1
|
|
for (const data of [sealed, sealed.subarray(0, 15)]) {
|
|
const error = yield* Effect.flip(aead.decrypt(key, data, { nonce, aad }))
|
|
assert.strictEqual(error.reason._tag, "DecryptionFailed")
|
|
assert.strictEqual(error.message, "Aead.decrypt: Could not decrypt the data")
|
|
}
|
|
// node:crypto would throw its own error for a wrong nonce length.
|
|
const error = yield* Effect.flip(aead.encrypt(key, sunscreen, { nonce: new Uint8Array(16) }))
|
|
assert.strictEqual(error.reason._tag, "InvalidArgument")
|
|
}
|
|
|
|
const cryptoKey = yield* Effect.promise(() =>
|
|
globalThis.crypto.subtle.importKey("raw", new Uint8Array(32), "AES-GCM", false, ["encrypt", "decrypt"])
|
|
)
|
|
for (
|
|
const key of [
|
|
yield* Aead.key(Aead.aes256Gcm, new Uint8Array(32)),
|
|
yield* Aead.fromCryptoKey(Aead.aes256Gcm, cryptoKey)
|
|
]
|
|
) {
|
|
const nonce = new Uint8Array(12)
|
|
// The GCM specification, test case 13.
|
|
assert.strictEqual(
|
|
Hex.encode(yield* aead.encrypt(key, new Uint8Array(), { nonce })),
|
|
"530f8afbc74536b9a963b4f1c4cb738b"
|
|
)
|
|
}
|
|
}).pipe(Effect.provide(NodeCrypto.layerAead.pipe(Layer.provide(SecureRandom.layerWebCrypto)))))
|
|
|
|
// An effect may run later than it is built, so node:crypto must not see a
|
|
// nonce that was valid only when the effect was built.
|
|
it.effect("layerAead checks the ChaCha20-Poly1305 nonce length when the effect runs", () =>
|
|
Effect.gen(function*() {
|
|
const aead = yield* Aead.Aead
|
|
const key = yield* Aead.key(Aead.chacha20Poly1305, bytes(chachaKey))
|
|
const options = { nonce: new Uint8Array(12) }
|
|
const data = new Uint8Array(32)
|
|
const encrypt = aead.encrypt(key, data, options)
|
|
const decrypt = aead.decrypt(key, data, options)
|
|
options.nonce = new Uint8Array(16)
|
|
assert.strictEqual((yield* Effect.flip(encrypt)).reason._tag, "InvalidArgument")
|
|
assert.strictEqual((yield* Effect.flip(decrypt)).reason._tag, "InvalidArgument")
|
|
}).pipe(Effect.provide(NodeCrypto.layerAead.pipe(Layer.provide(SecureRandom.layerWebCrypto)))))
|
|
})
|